← Back to branch summary

~ubuntu-branches/ubuntu/dapper/xscreensaver/dapper-updates

« back to all changes in this revision

Viewing changes to hacks/lissie.c

  • Committer: Bazaar Package Importer
  • Author(s): Ralf Hildebrandt
  • Date: 2005-04-09 00:06:43 UTC
  • mfrom: (1.1.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20050409000643-z0abtifbt9s20pcc
Tags: 4.21-3
http://bugs.debian.org/303374
http://bugs.debian.org/286664
Patch by Joachim Breitner to check more frequently if DPMS kicked in (closes: #303374, #286664).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hacks/lissie.c
1
1
/* -*- Mode: C; tab-width: 4 -*- */
2
2
/* lissie --- the Lissajous worm */
3
3
 
4
 
#if !defined( lint ) && !defined( SABER )
5
 
static const char sccsid[] = "@(#)lissie.c      4.04 97/07/28 xlockmore";
 
4
#if 0
 
5
static const char sccsid[] = "@(#)lissie.c      5.00 2000/11/01 xlockmore";
6
6
#endif
7
7
 
8
8
/*-
24
24
 * other special, indirect and consequential damages.
25
25
 *
26
26
 * Revision History:
27
 
 * 10-May-97: Compatible with xscreensaver
28
 
 * 18-Aug-96: added refresh-hook.
29
 
 * 01-May-96: written.
 
27
 * 01-Nov-2000: Allocation checks
 
28
 * 10-May-1997: Compatible with xscreensaver
 
29
 * 18-Aug-1996: added refresh-hook.
 
30
 * 01-May-1996: written.
30
31
 */
31
32
 
32
33
#ifdef STANDALONE
33
 
# define PROGCLASS "Lissie"
34
 
# define HACK_INIT init_lissie
35
 
# define HACK_DRAW draw_lissie
36
 
# define lissie_opts xlockmore_opts
37
 
# define DEFAULTS       "*delay:   10000 \n"    \
38
 
                                        "*count:   1     \n"    \
39
 
                                        "*cycles:  2000  \n"    \
40
 
                                        "*size:   -200   \n"    \
41
 
                                        "*ncolors: 64    \n"
42
 
# define SMOOTH_COLORS
43
 
# include "xlockmore.h"         /* in xscreensaver distribution */
 
34
#define MODE_lissie
 
35
#define PROGCLASS "Lissie"
 
36
#define HACK_INIT init_lissie
 
37
#define HACK_DRAW draw_lissie
 
38
#define lissie_opts xlockmore_opts
 
39
#define DEFAULTS "*delay: 10000 \n" \
 
40
 "*count: 1 \n" \
 
41
 "*cycles: 20000 \n" \
 
42
 "*size: -200 \n" \
 
43
 "*ncolors: 200 \n"
 
44
#define SMOOTH_COLORS
 
45
#include "xlockmore.h"          /* in xscreensaver distribution */
44
46
#else /* STANDALONE */
45
 
# include "xlock.h"             /* in xlockmore distribution */
 
47
#include "xlock.h"              /* in xlockmore distribution */
46
48
#endif /* STANDALONE */
47
49
 
 
50
#ifdef MODE_lissie
 
51
 
48
52
ModeSpecOpt lissie_opts =
49
 
{0, NULL, 0, NULL, NULL};
 
53
{0, (XrmOptionDescRec *) NULL, 0, (argtype *) NULL, (OptionStruct *) NULL};
 
54
 
 
55
#ifdef USE_MODULES
 
56
ModStruct   lissie_description =
 
57
{"lissie", "init_lissie", "draw_lissie", "release_lissie",
 
58
 "refresh_lissie", "init_lissie", (char *) NULL, &lissie_opts,
 
59
 10000, 1, 2000, -200, 64, 0.6, "",
 
60
 "Shows lissajous worms", 0, NULL};
 
61
 
 
62
#endif
50
63
 
51
64
#define MINSIZE 1
52
65
 
81
94
        int         xi, yi, ri, rx, ry, len, pos;
82
95
        int         redrawing, redrawpos;
83
96
        XPoint      loc[MAXLISSIELEN];
84
 
        int         color;
 
97
        unsigned long color;
85
98
} lissiestruct;
86
99
 
87
100
typedef struct {
 
101
        Bool        painted;
88
102
        int         width, height;
89
103
        int         nlissies;
90
104
        lissiestruct *lissie;
91
105
        int         loopcount;
92
106
} lissstruct;
93
107
 
94
 
static lissstruct *lisses = NULL;
 
108
static lissstruct *lisses = (lissstruct *) NULL;
95
109
 
96
110
 
97
111
static void
127
141
        lissie->loc[p].y = lissie->yi + (int) (sin(lissie->ty) * lissie->ry);
128
142
 
129
143
        /* Mask */
130
 
        XSetForeground(display, gc, MI_WIN_BLACK_PIXEL(mi));
 
144
        XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
131
145
        Lissie(oldp);
132
146
 
133
147
        /* Redraw */
134
148
        if (MI_NPIXELS(mi) > 2) {
135
149
                XSetForeground(display, gc, MI_PIXEL(mi, lissie->color));
136
 
                if (++lissie->color >= MI_NPIXELS(mi))
 
150
                if (++lissie->color >= (unsigned) MI_NPIXELS(mi))
137
151
                        lissie->color = 0;
138
152
        } else
139
 
                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
 
153
                XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
140
154
        Lissie(p);
141
155
        if (lissie->redrawing) {
142
156
                int         i;
165
179
        if (MI_NPIXELS(mi) > 2)
166
180
                lissie->color = NRAND(MI_NPIXELS(mi));
167
181
        else
168
 
                lissie->color = MI_WIN_WHITE_PIXEL(mi);
 
182
                lissie->color = MI_WHITE_PIXEL(mi);
169
183
        /* Initialize parameters */
170
184
        if (size < -MINSIZE)
171
185
                lissie->ri = NRAND(MIN(-size, MAX(MINSIZE,
214
228
        }
215
229
        lp = &lisses[MI_SCREEN(mi)];
216
230
 
217
 
        lp->width = MI_WIN_WIDTH(mi);
218
 
        lp->height = MI_WIN_HEIGHT(mi);
 
231
        lp->width = MI_WIDTH(mi);
 
232
        lp->height = MI_HEIGHT(mi);
219
233
 
220
 
        lp->nlissies = MI_BATCHCOUNT(mi);
 
234
        lp->nlissies = MI_COUNT(mi);
221
235
        if (lp->nlissies < -MINLISSIES) {
222
236
                if (lp->lissie) {
223
237
                        (void) free((void *) lp->lissie);
224
 
                        lp->lissie = NULL;
 
238
                        lp->lissie = (lissiestruct *) NULL;
225
239
                }
226
240
                lp->nlissies = NRAND(-lp->nlissies - MINLISSIES + 1) + MINLISSIES;
227
241
        } else if (lp->nlissies < MINLISSIES)
229
243
 
230
244
        lp->loopcount = 0;
231
245
 
232
 
        if (!lp->lissie)
233
 
                lp->lissie = (lissiestruct *) calloc(lp->nlissies, sizeof (lissiestruct));
234
 
        XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
 
246
        if (lp->lissie == NULL)
 
247
                if ((lp->lissie = (lissiestruct *) calloc(lp->nlissies,
 
248
                                sizeof (lissiestruct))) == NULL)
 
249
                        return;
 
250
 
 
251
        MI_CLEARWINDOW(mi);
 
252
        lp->painted = False;
 
253
 
235
254
        for (ball = 0; ball < (unsigned char) lp->nlissies; ball++)
236
255
                initlissie(mi, &lp->lissie[ball]);
237
256
 
240
259
void
241
260
draw_lissie(ModeInfo * mi)
242
261
{
243
 
        lissstruct *lp = &lisses[MI_SCREEN(mi)];
244
262
        register unsigned char ball;
245
 
 
246
 
        if (++lp->loopcount > MI_CYCLES(mi))
 
263
        lissstruct *lp;
 
264
 
 
265
        if (lisses == NULL)
 
266
                return;
 
267
        lp = &lisses[MI_SCREEN(mi)];
 
268
        if (lp->lissie == NULL)
 
269
                return;
 
270
 
 
271
        MI_IS_DRAWN(mi) = True;
 
272
 
 
273
        if (++lp->loopcount > MI_CYCLES(mi)) {
247
274
                init_lissie(mi);
248
 
        else
 
275
        } else {
 
276
                lp->painted = True;
249
277
                for (ball = 0; ball < (unsigned char) lp->nlissies; ball++)
250
278
                        drawlissie(mi, &lp->lissie[ball]);
 
279
        }
251
280
}
252
281
 
253
282
void
259
288
                for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
260
289
                        lissstruct *lp = &lisses[screen];
261
290
 
262
 
                        if (lp->lissie) {
 
291
                        if (lp->lissie != NULL) {
263
292
                                (void) free((void *) lp->lissie);
264
 
                                lp->lissie = NULL;
 
293
                                /* lp->lissie = NULL; */
265
294
                        }
266
295
                }
267
296
                (void) free((void *) lisses);
268
 
                lisses = NULL;
 
297
                lisses = (lissstruct *) NULL;
269
298
        }
270
299
}
271
300
 
272
301
void
273
302
refresh_lissie(ModeInfo * mi)
274
303
{
275
 
        if (lisses != NULL) {
276
 
                lissstruct *lp = &lisses[MI_SCREEN(mi)];
277
 
                int         i;
278
 
 
 
304
        int         i;
 
305
        lissstruct *lp;
 
306
 
 
307
        if (lisses == NULL)
 
308
                return;
 
309
        lp = &lisses[MI_SCREEN(mi)];
 
310
        if (lp->lissie == NULL)
 
311
                return;
 
312
 
 
313
        if (lp->painted) {
 
314
                MI_CLEARWINDOW(mi);
279
315
                for (i = 0; i < lp->nlissies; i++) {
280
316
                        lp->lissie[i].redrawing = 1;
281
317
                        lp->lissie[i].redrawpos = 0;
282
318
                }
283
319
        }
284
320
}
 
321
 
 
322
#endif /* MODE_lissie */