Return to bitrot.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / hacks / bitrot

Annotation of 43BSD/contrib/X/hacks/bitrot/bitrot.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * This neat little program, another in a continuing series of eye (and
                      3:  * screen) grabbers, will cause a disease to strike a random window on your 
                      4:  * screen.... Need I say more??
                      5:  */
                      6: 
                      7: 
                      8: #include <stdio.h>
                      9: #include <X/Xlib.h>
                     10: #include "twiddle.h"
                     11: #define TRUE 1
                     12: #define FALSE 0
                     13: #include <strings.h>
                     14: 
                     15: typedef struct
                     16: {
                     17:   int x,y;
                     18:   int falling;
                     19: } BadBit;
                     20: 
                     21: BadBit disease[100000];
                     22: 
                     23: int NoRotted;
                     24: 
                     25: Window Victim;
                     26: WindowInfo Info;
                     27: 
                     28: caddr_t *bitmap;
                     29: 
                     30: Display *dpy;
                     31: 
                     32: main(argc,argv)
                     33: int argc;
                     34: char **argv;
                     35: {
                     36:   
                     37:   Window foo, *targets;
                     38:   int ntargets;
                     39:   char display[256];
                     40:   int i;
                     41:   char *strind;
                     42: 
                     43:   display[0] = '\0';
                     44: 
                     45:   for (i=0; i < argc; i++) {
                     46:     strind = index (argv[i], ':');
                     47:     if(strind != NULL) {
                     48:       strncpy(display, argv[i], sizeof(display));
                     49:       continue;
                     50:     }
                     51:   }
                     52:   
                     53:   srandom (getpid());
                     54:   dpy = XOpenDisplay(display);
                     55: 
                     56:   XQueryTree(RootWindow, &foo, &ntargets, &targets);
                     57: 
                     58:   do
                     59:     {
                     60:       Victim = targets[rnd(ntargets)];
                     61:       XQueryWindow(Victim, &Info);
                     62:     }
                     63:   while (Info.mapped != IsMapped && Info.type != IsOpaque);
                     64: 
                     65:   printf("Info:\nWindow:%d  X:%d   Y:%d\n", Victim, Info.x, Info.y);
                     66: 
                     67:   NoRotted = 0;                        /* Not for long.. */
                     68: 
                     69:   GrabBitmap();
                     70:   while(1) 
                     71:     {
                     72: /*      GrabBitmap(); */
                     73:       RotMoreBits();
                     74:       MoveBits();
                     75:       XFlush();
                     76:     }
                     77: }
                     78: 
                     79: GrabBitmap()
                     80: {
                     81:   XQueryWindow(Victim, &Info);
                     82:   bitmap = (caddr_t *)calloc( XYPixmapSize(Info.width, Info.height, dpy -> dplanes) ,1 );
                     83:   XPixmapGetXY(Victim, 0, 0, Info.width, Info.height, bitmap);
                     84: }
                     85: 
                     86: RotABit(x,y)
                     87:      register int x,y;
                     88: {
                     89:   register BadBit *p=disease;
                     90:   register int i;
                     91: 
                     92:   for(i=NoRotted; i; i--,p++)
                     93:     if (p->x==x && p->y==y) return;
                     94:   disease[NoRotted].x=x;
                     95:   disease[NoRotted].y=y;
                     96:   disease[NoRotted].falling = FALSE;
                     97:   ++NoRotted;
                     98: }
                     99: RotMoreBits()
                    100: {
                    101:   register int i, x, y, bxsz;
                    102:   bxsz = (Info.width+15) & ~0xf ;
                    103: 
                    104:   for (i=100; i; --i)
                    105:     {
                    106:       x=rnd(Info.width);
                    107:       y=rnd(Info.height);
                    108: 
                    109:       if (!fetch (bitmap, (x + y*bxsz))) { RotABit(x,y);}
                    110:     }
                    111: }
                    112: 
                    113: MoveBits()
                    114: {
                    115:   register int i, bxsz;
                    116:   register BadBit *p;
                    117: 
                    118:   bxsz = (Info.width+15) & ~0xf;
                    119: 
                    120:   for (i=NoRotted, p=disease; i; --i, ++p)
                    121:     {
                    122:       if (p->falling)
                    123:        {
                    124:          if (!fetch(bitmap, p->x + (p->y*bxsz)) && 
                    125:              fetch(bitmap, p->x + (p->y+1) * bxsz))
                    126:            {
                    127:              set(bitmap, p->x + p->y*bxsz);
                    128:              SetBit(p->x, p->y);
                    129:              (p->y)+=1;
                    130:              reset(bitmap, p->x + p->y*bxsz);
                    131:              ClearBit(p->x, p->y);
                    132:            }
                    133:          else {p->falling = FALSE; RotABit(p->x, p->y+1);}
                    134:        }
                    135:       else
                    136:        {
                    137:          if (fetch(bitmap, p->x + (p -> y+1) *bxsz))
                    138:            p->falling = TRUE;
                    139:        }
                    140:     }
                    141: }
                    142: SetBit(x,y)
                    143:      int x,y;
                    144: {
                    145:   XTileSet(Victim, x, y, 1, 1, WhitePixmap);
                    146: }
                    147: 
                    148: ClearBit(x,y)
                    149:      int x,y;
                    150: {
                    151:   XTileSet(Victim, x, y, 1, 1, BlackPixmap);
                    152: }
                    153: 
                    154: SplatBitmap()
                    155: {
                    156:   Pixmap map;
                    157:   
                    158:   map = XStorePixmapXY(Info.width, Info.height, bitmap);
                    159:   XPixmapPut(Victim, 0, 0, 0, 0,
                    160:                     Info.width, Info.height,
                    161:             map, GXcopy, dpy -> dplanes);
                    162:   XFlush();
                    163:   XFreePixmap(map);
                    164: }
                    165: 
                    166: rnd(n)
                    167:      int n;
                    168: 
                    169: {
                    170:   long random();
                    171: 
                    172:   return (random() % n);
                    173: }
                    174:   

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.