cde/programs/dtscreen/worm.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: worm.c /main/3 1995/11/02 16:09:04 rswiston $ */
  24 /*
  25  */
  26 /*                                                                      *
  27  * (c) Copyright 1993, 1994 Hewlett-Packard Company                     *
  28  * (c) Copyright 1993, 1994 International Business Machines Corp.       *
  29  * (c) Copyright 1993, 1994 Sun Microsystems, Inc.                      *
  30  * (c) Copyright 1993, 1994 Novell, Inc.                                *
  31  */
  32 /*-
  33  * worm.c - draw wiggly worms.
  34  *
  35  * Copyright (c) 1991 by Patrick J. Naughton.
  36  *
  37  * See dtscreen.c for copying information.
  38  *
  39  * Revision History:
  40  * 27-Sep-91: got rid of all malloc calls since there were no calls to free().
  41  * 25-Sep-91: Integrated into X11R5 contrib dtscreen.
  42  *
  43  * Adapted from a concept in the Dec 87 issue of Scientific American.
  44  *
  45  * SunView version: Brad Taylor (brad@sun.com)
  46  * X11 version: Dave Lemke (lemke@ncd.com)
  47  * xlock version: Boris Putanec (bp@cs.brown.edu)
  48  *
  49  * This code is a static memory pig... like almost 200K... but as contributed
  50  * it leaked at a massive rate, so I made everything static up front... feel
  51  * free to contribute the proper memory management code.
  52  *
  53  */
  54
  55 #include "dtscreen.h"
  56 #include <math.h>
  57 #include <stdlib.h>
  58
  59 #define MAXCOLORS 64
  60 #define MAXWORMS 64
  61 #define CIRCSIZE 2
  62 #define MAXWORMLEN 50
  63
  64 #define PI 3.14159265358979323844
  65 #define SEGMENTS  36
  66 static int  sintab[SEGMENTS];
  67 static int  costab[SEGMENTS];
  68 static int  init_table = 0;
  69
  70 typedef struct {
  71     int         xcirc[MAXWORMLEN];
  72     int         ycirc[MAXWORMLEN];
  73     int         dir;
  74     int         tail;
  75     int         x;
  76     int         y;
  77 }           wormstuff;
  78
  79 typedef struct {
  80     int         xsize;
  81     int         ysize;
  82     int         wormlength;
  83     int         monopix;
  84     int         nc;
  85     int         nw;
  86     wormstuff   worm[MAXWORMS];
  87     XRectangle  rects[MAXCOLORS][MAXWORMS];
  88     int         size[MAXCOLORS];
  89 }           wormstruct;
  90
  91 #if !defined(CSRG_BASED) && !defined(sun) && !defined(linux)
  92 int
  93 round(float x)
  94 {
  95     return ((int) floor((double) x));
  96 }
  97 #endif
  98
  99
 100 void
 101 worm_doit(perwindow *pwin, wormstruct *wp, int which, unsigned long color)
 102 {
 103     wormstuff  *ws = &wp->worm[which];
 104     int         x, y;
 105
 106     ws->tail++;
 107     if (ws->tail == wp->wormlength)
 108         ws->tail = 0;
 109
 110     x = ws->xcirc[ws->tail];
 111     y = ws->ycirc[ws->tail];
 112     XClearArea(dsp, pwin->w, x, y, CIRCSIZE, CIRCSIZE, False);
 113
 114     if (random() & 1) {
 115         ws->dir = (ws->dir + 1) % SEGMENTS;
 116     } else {
 117         ws->dir = (ws->dir + SEGMENTS - 1) % SEGMENTS;
 118     }
 119
 120     x = (ws->x + costab[ws->dir] + wp->xsize) % wp->xsize;
 121     y = (ws->y + sintab[ws->dir] + wp->ysize) % wp->ysize;
 122
 123     ws->xcirc[ws->tail] = x;
 124     ws->ycirc[ws->tail] = y;
 125     ws->x = x;
 126     ws->y = y;
 127
 128     wp->rects[color][wp->size[color]].x = x;
 129     wp->rects[color][wp->size[color]].y = y;
 130     wp->size[color]++;
 131 }
 132
 133
 134 void
 135 initworm(perwindow *pwin)
 136 {
 137     int         i, j;
 138     wormstruct *wp;
 139     XWindowAttributes xwa;
 140
 141     if (pwin->data) free(pwin->data);
 142     pwin->data = (void *)malloc(sizeof(wormstruct));
 143     memset(pwin->data, '\0', sizeof(wormstruct));
 144     wp = (wormstruct *)pwin->data;
 145     wp->nc = pwin->perscreen->npixels;
 146     if (wp->nc > MAXCOLORS)
 147         wp->nc = MAXCOLORS;
 148
 149     wp->nw = batchcount;
 150     if (wp->nw > MAXWORMS)
 151         wp->nw = MAXWORMS;
 152
 153     if (!init_table) {
 154         init_table = 1;
 155         for (i = 0; i < SEGMENTS; i++) {
 156             sintab[i] = round(CIRCSIZE * sin(i * 2 * PI / SEGMENTS));
 157             costab[i] = round(CIRCSIZE * cos(i * 2 * PI / SEGMENTS));
 158         }
 159     }
 160     XGetWindowAttributes(dsp, pwin->w, &xwa);
 161     wp->xsize = xwa.width;
 162     wp->ysize = xwa.height;
 163
 164     if (xwa.width < 100) {
 165         wp->monopix = BlackPixelOfScreen(pwin->perscreen->screen);
 166         wp->wormlength = MAXWORMLEN / 10;
 167     } else {
 168         wp->monopix = WhitePixelOfScreen(pwin->perscreen->screen);
 169         wp->wormlength = MAXWORMLEN;
 170     }
 171
 172     for (i = 0; i < wp->nc; i++) {
 173         for (j = 0; j < wp->nw / wp->nc + 1; j++) {
 174             wp->rects[i][j].width = CIRCSIZE;
 175             wp->rects[i][j].height = CIRCSIZE;
 176         }
 177     }
 178     memset(wp->size, '\0', wp->nc * sizeof(int));
 179
 180     for (i = 0; i < wp->nw; i++) {
 181         for (j = 0; j < wp->wormlength; j++) {
 182             wp->worm[i].xcirc[j] = wp->xsize / 2;
 183             wp->worm[i].ycirc[j] = wp->ysize / 2;
 184         }
 185         wp->worm[i].dir = (unsigned) random() % SEGMENTS;
 186         wp->worm[i].tail = 0;
 187         wp->worm[i].x = wp->xsize / 2;
 188         wp->worm[i].y = wp->ysize / 2;
 189     }
 190
 191     XClearWindow(dsp, pwin->w);
 192 }
 193
 194
 195 void
 196 drawworm(perwindow *pwin)
 197 {
 198     int         i;
 199     wormstruct *wp = (wormstruct *)pwin->data;
 200     unsigned int wcolor;
 201     static unsigned int chromo = 0;
 202
 203     memset(wp->size, '\0', wp->nc * sizeof(int));
 204
 205     for (i = 0; i < wp->nw; i++) {
 206         if (!mono && wp->nc > 2) {
 207             wcolor = (i + chromo) % wp->nc;
 208
 209             worm_doit(pwin, wp, i, wcolor);
 210         } else
 211             worm_doit(pwin, wp, i, 0);
 212     }
 213
 214     if (!mono && wp->nc > 2) {
 215         for (i = 0; i < wp->nc; i++) {
 216             XSetForeground(dsp, pwin->gc, pwin->perscreen->pixels[i]);
 217             XFillRectangles(dsp, pwin->w, pwin->gc, wp->rects[i],
 218                             wp->size[i]);
 219         }
 220     } else {
 221         XSetForeground(dsp, pwin->gc, wp->monopix);
 222         XFillRectangles(dsp, pwin->w, pwin->gc, wp->rects[0],
 223                         wp->size[0]);
 224     }
 225
 226     if (++chromo == wp->nc)
 227         chromo = 0;
 228 }