← Back to branch summary

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

« back to all changes in this revision

Viewing changes to hacks/lightning.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/lightning.c
1
 
/* -*- Mode: C; tab-width: 4 -*-
2
 
 * lightning --- fractal lightning bolts.
3
 
 */
4
 
#if !defined( lint ) && !defined( SABER )
5
 
static const char sccsid[] = "@(#)lightning.c   4.00 97/01/01 xlockmore";
 
1
/* -*- Mode: C; tab-width: 4 -*- */
 
2
/* lightning --- fractal lightning bolds */
 
3
 
 
4
#if 0
 
5
static const char sccsid[] = "@(#)lightning.c   5.00 2000/11/01 xlockmore";
6
6
#endif
7
7
 
8
 
/* Copyright (c) 1996 by Keith Romberg <kromberg@saxe.com>.
 
8
/*-
 
9
 * Copyright (c) 1996 by Keith Romberg <kromberg@saxe.com>
9
10
 *
10
11
 * Permission to use, copy, modify, and distribute this software and its
11
12
 * documentation for any purpose and without fee is hereby granted,
20
21
 * other special, indirect and consequential damages.
21
22
 *
22
23
 * Revision History:
23
 
 * 10-May-97: jwz@jwz.org: turned into a standalone program.
24
 
 * 14-Jul-96: Cleaned up code.
25
 
 * 27-Jun-96: Written and submitted by Keith Romberg <kromberg@saxe.com>.
 
24
 * 01-Nov-2000: Allocation checks
 
25
 * 10-May-1997: Compatible with xscreensaver
 
26
 * 14-Jul-1996: Cleaned up code.
 
27
 * 27-Jun-1996: Written and submitted by Keith Romberg <kromberg@saxe.com>.
26
28
 */
27
29
 
28
30
#ifdef STANDALONE
29
 
# define PROGCLASS                                      "Lightning"
30
 
# define HACK_INIT                                      init_lightning
31
 
# define HACK_DRAW                                      draw_lightning
32
 
# define lightning_opts                         xlockmore_opts
33
 
# define DEFAULTS       "*delay:                10000 \n"                       \
34
 
                                        "*ncolors:              200   \n"
35
 
# define BRIGHT_COLORS
36
 
# include "xlockmore.h"                         /* from the xscreensaver distribution */
37
 
#else  /* !STANDALONE */
38
 
# include "xlock.h"                                     /* from the xlockmore distribution */
39
 
#endif /* !STANDALONE */
40
 
 
41
 
ModeSpecOpt lightning_opts = {
42
 
  0, NULL, 0, NULL, NULL };
43
 
 
44
 
/*----------------------------   defines   -------------------------------*/
 
31
#define MODE_lightning
 
32
#define PROGCLASS "Lightning"
 
33
#define HACK_INIT init_lightning
 
34
#define HACK_DRAW draw_lightning
 
35
#define lightning_opts xlockmore_opts
 
36
#define DEFAULTS "*delay: 10000 \n" \
 
37
                 "*ncolors: 64  \n"
 
38
#define BRIGHT_COLORS
 
39
#include "xlockmore.h"          /* in xscreensaver distribution */
 
40
#else /* STANDALONE */
 
41
#include "xlock.h"              /* in xlockmore distribution */
 
42
#endif /* STANDALONE */
 
43
 
 
44
#ifdef MODE_lightning
 
45
 
 
46
ModeSpecOpt lightning_opts =
 
47
{0, (XrmOptionDescRec *) NULL, 0, (argtype *) NULL, (OptionStruct *) NULL};
 
48
 
 
49
#ifdef USE_MODULES
 
50
ModStruct   lightning_description =
 
51
{"lightning", "init_lightning", "draw_lightning", "release_lightning",
 
52
 "refresh_lightning", "init_lightning", (char *) NULL, &lightning_opts,
 
53
 10000, 1, 1, 1, 64, 0.6, "",
 
54
 "Shows Keith's fractal lightning bolts", 0, NULL};
 
55
 
 
56
#endif
45
57
 
46
58
#define BOLT_NUMBER 4
47
59
#define BOLT_ITERATION 4
100
112
        int         give_it_hell;
101
113
        int         draw_time;
102
114
        int         stage;
 
115
        int         busyLoop;
103
116
        unsigned long color;
104
117
} Storm;
105
118
 
106
 
static Storm *Helga = NULL;
 
119
static Storm *Helga = (Storm *) NULL;
107
120
 
108
121
/*-------------------   function prototypes  ----------------------------*/
109
122
 
113
126
static int  flashing_strike(void);
114
127
static void flash_duration(int *start, int *end, int total_duration);
115
128
static void random_storm(Storm * st);
116
 
static void generate(XPoint A, XPoint B, int iter, XPoint * verts, int *index);
 
129
static void generate(XPoint A, XPoint B, int iter, XPoint * verts, int *vert_index);
117
130
static void create_fork(Fork * f, XPoint start, XPoint end, int level);
118
131
 
119
132
static void first_strike(Lightning bolt, ModeInfo * mi);
123
136
static void level2_strike(Lightning bolt, ModeInfo * mi);
124
137
 
125
138
static int  storm_active(Storm * st);
126
 
static void update_bolt(Lightning * bolt, int time);
 
139
static void update_bolt(Lightning * bolt, int time_now);
127
140
static void wiggle_bolt(Lightning * bolt);
128
141
static void wiggle_line(XPoint * p, int number, int wiggle_amount);
129
142
 
220
233
}
221
234
 
222
235
static void
223
 
generate(XPoint A, XPoint B, int iter, XPoint * verts, int *index)
 
236
generate(XPoint A, XPoint B, int iter, XPoint * verts, int *vert_index)
224
237
{
225
238
        XPoint      mid;
226
239
 
228
241
        mid.y = (A.y + B.y) / 2 + NRAND(HEIGHT_VARIATION) - HEIGHT_VARIATION / 2;
229
242
 
230
243
        if (!iter) {
231
 
                verts[*index].x = mid.x;
232
 
                verts[*index].y = mid.y;
233
 
                (*index)++;
 
244
                verts[*vert_index].x = mid.x;
 
245
                verts[*vert_index].y = mid.y;
 
246
                (*vert_index)++;
234
247
                return;
235
248
        }
236
 
        generate(A, mid, iter - 1, verts, index);
237
 
        generate(mid, B, iter - 1, verts, index);
 
249
        generate(A, mid, iter - 1, verts, vert_index);
 
250
        generate(mid, B, iter - 1, verts, vert_index);
238
251
}
239
252
 
240
253
/*------------------------------------------------------------------------*/
270
283
/*------------------------------------------------------------------------*/
271
284
 
272
285
static void
273
 
update_bolt(Lightning * bolt, int time)
 
286
update_bolt(Lightning * bolt, int time_now)
274
287
{
275
288
        wiggle_bolt(bolt);
276
289
        if ((bolt->wiggle_amount == 0) && (bolt->wiggle_number > 2))
277
290
                bolt->wiggle_number = 0;
278
 
        if (((time % 3) == 0))
 
291
        if (((time_now % 3) == 0))
279
292
                bolt->wiggle_amount++;
280
293
 
281
 
        if (((time >= bolt->delay_time) && (time < bolt->flash_begin)) ||
282
 
            (time > bolt->flash_stop))
 
294
        if (((time_now >= bolt->delay_time) && (time_now < bolt->flash_begin)) ||
 
295
            (time_now > bolt->flash_stop))
283
296
                bolt->visible = 1;
284
297
        else
285
298
                bolt->visible = 0;
286
299
 
287
 
        if (time == bolt->delay_time)
 
300
        if (time_now == bolt->delay_time)
288
301
                bolt->strike_level = FIRST_LEVEL_STRIKE;
289
 
        else if (time == (bolt->delay_time + 1))
 
302
        else if (time_now == (bolt->delay_time + 1))
290
303
                bolt->strike_level = LEVEL_ONE_STRIKE;
291
 
        else if ((time > (bolt->delay_time + 1)) &&
292
 
                 (time <= (bolt->delay_time + bolt->flash_begin - 2)))
 
304
        else if ((time_now > (bolt->delay_time + 1)) &&
 
305
                 (time_now <= (bolt->delay_time + bolt->flash_begin - 2)))
293
306
                bolt->strike_level = LEVEL_TWO_STRIKE;
294
 
        else if (time == (bolt->delay_time + bolt->flash_begin - 1))
 
307
        else if (time_now == (bolt->delay_time + bolt->flash_begin - 1))
295
308
                bolt->strike_level = LEVEL_ONE_STRIKE;
296
 
        else if (time == (bolt->delay_time + bolt->flash_stop + 1))
 
309
        else if (time_now == (bolt->delay_time + bolt->flash_stop + 1))
297
310
                bolt->strike_level = LEVEL_ONE_STRIKE;
298
311
        else
299
312
                bolt->strike_level = LEVEL_TWO_STRIKE;
324
337
        GC          gc = MI_GC(mi);
325
338
        int         i;
326
339
 
327
 
        XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
 
340
        XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
328
341
        XDrawLine(display, window, gc,
329
342
               bolt.end1.x, bolt.end1.y, bolt.middle[0].x, bolt.middle[0].y);
330
343
        draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, 0);
375
388
        if (MI_NPIXELS(mi) > 2) /* color */
376
389
                XSetForeground(display, gc, MI_PIXEL(mi, st->color));
377
390
        else
378
 
                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
 
391
                XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
379
392
        XDrawLine(display, window, gc,
380
393
        bolt.end1.x - 1, bolt.end1.y, bolt.middle[0].x - 1, bolt.middle[0].y);
381
394
        draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, -1);
403
416
static int
404
417
distance(XPoint a, XPoint b)
405
418
{
406
 
        return ((int) sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)));
 
419
        return ((int) sqrt((double) (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)));
407
420
}
408
421
 
409
422
/*------------------------------------------------------------------------*/
424
437
        if (MI_NPIXELS(mi) > 2)
425
438
                XSetForeground(display, gc, MI_PIXEL(mi, st->color));
426
439
        else
427
 
                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
 
440
                XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
428
441
        XDrawLine(display, window, gc,
429
442
        bolt.end1.x - 2, bolt.end1.y, bolt.middle[0].x - 2, bolt.middle[0].y);
430
443
        draw_line(mi, bolt.middle, BOLT_VERTICIES, gc, -2);
513
526
        }
514
527
        st = &Helga[MI_SCREEN(mi)];
515
528
 
516
 
        st->scr_width = MI_WIN_WIDTH(mi);
517
 
        st->scr_height = MI_WIN_HEIGHT(mi);
 
529
        st->scr_width = MI_WIDTH(mi);
 
530
        st->scr_height = MI_HEIGHT(mi);
518
531
 
519
532
        st->multi_strike = setup_multi_strike();
520
533
        random_storm(st);
526
539
void
527
540
draw_lightning(ModeInfo * mi)
528
541
{
529
 
        Storm      *st = &Helga[MI_SCREEN(mi)];
530
542
        int         i;
 
543
        Storm      *st;
531
544
 
 
545
        if (Helga == NULL)
 
546
                return;
 
547
        st = &Helga[MI_SCREEN(mi)];
 
548
        MI_IS_DRAWN(mi) = True;
532
549
        switch (st->stage) {
533
550
                case 0:
534
 
                        XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
 
551
                        MI_IS_DRAWN(mi) = False;
 
552
                        MI_CLEARWINDOW(mi);
 
553
                        MI_IS_DRAWN(mi) = True;
 
554
 
535
555
                        st->color = NRAND(MI_NPIXELS(mi));
536
556
                        st->draw_time = 0;
537
557
                        if (storm_active(st))
538
558
                                st->stage++;
539
559
                        else
540
 
                                st->stage = 3;
 
560
                                st->stage = 4;
541
561
                        break;
542
562
                case 1:
543
563
                        for (i = 0; i < st->multi_strike; i++) {
546
566
                                update_bolt(&(st->bolts[i]), st->draw_time);
547
567
                        }
548
568
                        st->draw_time++;
549
 
                        XFlush(MI_DISPLAY(mi));
550
 
                        MI_PAUSE(mi) = 60000;
551
569
                        st->stage++;
 
570
                        st->busyLoop = 0;
552
571
                        break;
553
572
                case 2:
554
 
                        XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
 
573
                        if (++st->busyLoop > 6) {
 
574
                                st->stage++;
 
575
                                st->busyLoop = 0;
 
576
                        }
 
577
                        break;
 
578
                case 3:
 
579
                        MI_IS_DRAWN(mi) = False;
 
580
                        MI_CLEARWINDOW(mi);
 
581
                        MI_IS_DRAWN(mi) = True;
 
582
 
555
583
                        if (storm_active(st))
556
584
                                st->stage = 1;
557
585
                        else
558
586
                                st->stage++;
559
587
                        break;
560
 
                case 3:
561
 
                        MI_PAUSE(mi) = 1000000;
 
588
                case 4:
 
589
                        if (++st->busyLoop > 100) {
 
590
                                st->busyLoop = 0;
 
591
                        }
562
592
                        init_lightning(mi);
563
593
                        break;
564
594
        }
569
599
{
570
600
        if (Helga != NULL) {
571
601
                (void) free((void *) Helga);
572
 
                Helga = NULL;
 
602
                Helga = (Storm *) NULL;
573
603
        }
574
604
}
575
605
 
578
608
{
579
609
        /* Do nothing, it will refresh by itself */
580
610
}
 
611
 
 
612
#endif /* MODE_lightning */