bff002cb8ce3e6838e26e26c120b0fe37adcc7c1
[xscreensaver] / hacks / slidescreen.c
1 /* xscreensaver, Copyright (c) 1992-2014 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or 
9  * implied warranty.
10  */
11
12 #include "screenhack.h"
13
14 enum { DOWN = 0, LEFT, UP, RIGHT };
15 enum { VERTICAL, HORIZONTAL };
16
17 struct state {
18   Display *dpy;
19   Window window;
20
21   int grid_size;
22   int pix_inc;
23   int hole_x, hole_y;
24   int bitmap_w, bitmap_h;
25   int xoff, yoff;
26   int grid_w, grid_h;
27   int delay, delay2;
28   int duration;
29   GC gc;
30   unsigned long fg, bg;
31   int max_width, max_height;
32   int early_i;
33
34   int draw_rnd, draw_i;
35   int draw_x, draw_y, draw_ix, draw_iy, draw_dx, draw_dy;
36   int draw_dir, draw_w, draw_h, draw_size, draw_inc;
37   int draw_last;
38   int draw_initted;
39
40   time_t start_time;
41   async_load_state *img_loader;
42 };
43
44
45 static void *
46 slidescreen_init (Display *dpy, Window window)
47 {
48   struct state *st = (struct state *) calloc (1, sizeof(*st));
49   XWindowAttributes xgwa;
50   XGCValues gcv;
51   long gcflags;
52
53   st->dpy = dpy;
54   st->window = window;
55   XGetWindowAttributes (st->dpy, st->window, &xgwa);
56   st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
57                                             st->window, 0, 0);
58   st->start_time = time ((time_t) 0);
59
60   st->max_width = xgwa.width;
61   st->max_height = xgwa.height;
62
63   st->delay = get_integer_resource (st->dpy, "delay", "Integer");
64   st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer");
65   st->duration = get_integer_resource (st->dpy, "duration", "Seconds");
66   st->grid_size = get_integer_resource (st->dpy, "gridSize", "Integer");
67   st->pix_inc = get_integer_resource (st->dpy, "pixelIncrement", "Integer");
68
69   /* Don't let the grid be smaller than 5x5 */
70   while (st->grid_size > xgwa.width / 5)
71     st->grid_size /= 2;
72   while (st->grid_size > xgwa.height / 5)
73     st->grid_size /= 2;
74
75   if (st->delay < 0) st->delay = 0;
76   if (st->delay2 < 0) st->delay2 = 0;
77   if (st->duration < 1) st->duration = 1;
78   if (st->pix_inc < 1) st->pix_inc = 1;
79   if (st->grid_size < 1) st->grid_size = 1;
80
81
82   {
83     XColor fgc, bgc;
84     char *fgs = get_string_resource(st->dpy, "background", "Background");
85     char *bgs = get_string_resource(st->dpy, "foreground", "Foreground");
86     Bool fg_ok, bg_ok;
87     if (!XParseColor (st->dpy, xgwa.colormap, fgs, &fgc))
88       XParseColor (st->dpy, xgwa.colormap, "black", &bgc);
89     if (!XParseColor (st->dpy, xgwa.colormap, bgs, &bgc))
90       XParseColor (st->dpy, xgwa.colormap, "gray", &fgc);
91
92     fg_ok = XAllocColor (st->dpy, xgwa.colormap, &fgc);
93     bg_ok = XAllocColor (st->dpy, xgwa.colormap, &bgc);
94
95     /* If we weren't able to allocate the two colors we want from the
96        colormap (which is likely if the screen has been grabbed on an
97        8-bit SGI visual -- don't ask) then just go through the map
98        and find the closest color to the ones we wanted, and use those
99        pixels without actually allocating them.
100      */
101     if (fg_ok)
102       st->fg = fgc.pixel;
103     else
104       st->fg = 0;
105
106     if (bg_ok)
107       st->bg = bgc.pixel;
108     else
109       st->bg = 1;
110
111 #ifndef HAVE_COCOA
112     if (!fg_ok || bg_ok)
113       {
114         int i;
115         unsigned long fgd = ~0;
116         unsigned long bgd = ~0;
117         int max = visual_cells (xgwa.screen, xgwa.visual);
118         XColor *all = (XColor *) calloc(sizeof (*all), max);
119         for (i = 0; i < max; i++)
120           {
121             all[i].flags = DoRed|DoGreen|DoBlue;
122             all[i].pixel = i;
123           }
124         XQueryColors (st->dpy, xgwa.colormap, all, max);
125         for(i = 0; i < max; i++)
126           {
127             long rd, gd, bd;
128             unsigned long dd;
129             if (!fg_ok)
130               {
131                 rd = (all[i].red   >> 8) - (fgc.red   >> 8);
132                 gd = (all[i].green >> 8) - (fgc.green >> 8);
133                 bd = (all[i].blue  >> 8) - (fgc.blue  >> 8);
134                 if (rd < 0) rd = -rd;
135                 if (gd < 0) gd = -gd;
136                 if (bd < 0) bd = -bd;
137                 dd = (rd << 1) + (gd << 2) + bd;
138                 if (dd < fgd)
139                   {
140                     fgd = dd;
141                     st->fg = all[i].pixel;
142                     if (dd == 0)
143                       fg_ok = True;
144                   }
145               }
146
147             if (!bg_ok)
148               {
149                 rd = (all[i].red   >> 8) - (bgc.red   >> 8);
150                 gd = (all[i].green >> 8) - (bgc.green >> 8);
151                 bd = (all[i].blue  >> 8) - (bgc.blue  >> 8);
152                 if (rd < 0) rd = -rd;
153                 if (gd < 0) gd = -gd;
154                 if (bd < 0) bd = -bd;
155                 dd = (rd << 1) + (gd << 2) + bd;
156                 if (dd < bgd)
157                   {
158                     bgd = dd;
159                     st->bg = all[i].pixel;
160                     if (dd == 0)
161                       bg_ok = True;
162                   }
163               }
164
165             if (fg_ok && bg_ok)
166               break;
167           }
168         XFree(all);
169       }
170 #endif /* !HAVE_COCOA */
171   }
172
173   gcv.foreground = st->fg;
174   gcv.function = GXcopy;
175   gcv.subwindow_mode = IncludeInferiors;
176   gcflags = GCForeground |GCFunction;
177   if (use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
178     gcflags |= GCSubwindowMode;
179   st->gc = XCreateGC (st->dpy, st->window, gcflags, &gcv);
180
181   return st;
182 }
183
184 static void
185 draw_grid (struct state *st)
186 {
187   int i;
188   Drawable d;
189   int border;
190   XWindowAttributes xgwa;
191
192   XGetWindowAttributes (st->dpy, st->window, &xgwa);
193
194   border = get_integer_resource (st->dpy, "internalBorderWidth",
195                                  "InternalBorderWidth");
196
197   XGetWindowAttributes (st->dpy, st->window, &xgwa);
198   st->bitmap_w = xgwa.width;
199   st->bitmap_h = xgwa.height;
200
201   st->grid_w = st->bitmap_w / st->grid_size;
202   st->grid_h = st->bitmap_h / st->grid_size;
203   st->hole_x = random () % st->grid_w;
204   st->hole_y = random () % st->grid_h;
205   st->xoff = (st->bitmap_w - (st->grid_w * st->grid_size)) / 2;
206   st->yoff = (st->bitmap_h - (st->grid_h * st->grid_size)) / 2;
207
208   d = st->window;
209
210   st->early_i = -10;
211   st->draw_last = -1;
212
213   if (border)
214     {
215       int half = border/2;
216       int half2 = (border & 1 ? half+1 : half);
217       XSetForeground(st->dpy, st->gc, st->bg);
218       for (i = 0; i < st->bitmap_w; i += st->grid_size)
219         {
220           int j;
221           for (j = 0; j < st->bitmap_h; j += st->grid_size)
222             XDrawRectangle (st->dpy, d, st->gc,
223                             st->xoff+i+half2, st->yoff+j+half2,
224                             st->grid_size-border-1, st->grid_size-border-1);
225         }
226
227       XSetForeground(st->dpy, st->gc, st->fg);
228       for (i = 0; i <= st->bitmap_w; i += st->grid_size)
229         XFillRectangle (st->dpy, d, st->gc, st->xoff+i-half, st->yoff, border, st->bitmap_h);
230       for (i = 0; i <= st->bitmap_h; i += st->grid_size)
231         XFillRectangle (st->dpy, d, st->gc, st->xoff, st->yoff+i-half, st->bitmap_w, border);
232     }
233
234   if (st->xoff)
235     {
236       XFillRectangle (st->dpy, d, st->gc, 0, 0, st->xoff, st->bitmap_h);
237       XFillRectangle (st->dpy, d, st->gc, st->bitmap_w - st->xoff, 0, st->xoff, st->bitmap_h);
238     }
239   if (st->yoff)
240     {
241       XFillRectangle (st->dpy, d, st->gc, 0, 0, st->bitmap_w, st->yoff);
242       XFillRectangle (st->dpy, d, st->gc, 0, st->bitmap_h - st->yoff, st->bitmap_w, st->yoff);
243     }
244 }
245
246
247 static int
248 slidescreen_draw_early (struct state *st)
249 {
250   while (st->early_i < 0)
251     {
252       st->early_i++;
253       return 1;
254     }
255
256   /* for (early_i = 0; early_i < grid_size; early_i += pix_inc) */
257    {
258      XPoint points [3];
259      points[0].x = st->xoff + st->grid_size * st->hole_x;
260      points[0].y = st->yoff + st->grid_size * st->hole_y;
261      points[1].x = points[0].x + st->grid_size;
262      points[1].y = points[0].y;
263      points[2].x = points[0].x;
264      points[2].y = points[0].y + st->early_i;
265      XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
266
267      points[1].x = points[0].x;
268      points[1].y = points[0].y + st->grid_size;
269      points[2].x = points[0].x + st->early_i;
270      points[2].y = points[0].y + st->grid_size;
271      XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
272
273      points[0].x = points[1].x + st->grid_size;
274      points[0].y = points[1].y;
275      points[2].x = points[0].x;
276      points[2].y = points[0].y - st->early_i;
277      XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
278
279      points[1].x = points[0].x;
280      points[1].y = points[0].y - st->grid_size;
281      points[2].x = points[1].x - st->early_i;
282      points[2].y = points[1].y;
283      XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
284    }
285
286    st->early_i += st->pix_inc;
287    if (st->early_i < st->grid_size)
288      return 1;
289
290    XFillRectangle (st->dpy, st->window, st->gc,
291                    st->xoff + st->grid_size * st->hole_x,
292                    st->yoff + st->grid_size * st->hole_y,
293                    st->grid_size, st->grid_size);
294    return 0;
295 }
296
297
298 static unsigned long
299 slidescreen_draw (Display *dpy, Window window, void *closure)
300 {
301   struct state *st = (struct state *) closure;
302   int this_delay = st->delay;
303
304   /* this code is a total kludge, but who cares, it works... */
305
306   if (st->img_loader)   /* still loading */
307     {
308       st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
309       if (! st->img_loader) {  /* just finished */
310         st->start_time = time ((time_t) 0);
311         draw_grid (st);
312       }
313       return st->delay;
314     }
315
316   if (!st->img_loader &&
317       st->start_time + st->duration < time ((time_t) 0)) {
318     XWindowAttributes xgwa;
319     XGetWindowAttributes(st->dpy, st->window, &xgwa);
320     st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
321                                               st->window, 0, 0);
322     st->start_time = time ((time_t) 0);
323     st->draw_initted = 0;
324     return st->delay;
325   }
326
327   if (! st->draw_initted)
328     {
329       if (!slidescreen_draw_early (st))
330         {
331           st->draw_initted = 1;
332           return st->delay2;
333         }
334       else
335         return st->delay;
336     }
337
338  if (st->draw_i == 0)
339    {
340      if (st->draw_last == -1) st->draw_last = random () % 2;
341
342      /* alternate between horizontal and vertical slides */
343      /* note that draw_dir specifies the direction the _hole_ moves, not the tiles */
344      if (st->draw_last == VERTICAL) {
345        if (((st->grid_w > 1) ? st->draw_rnd = random () % (st->grid_w - 1) : 0)
346            < st->hole_x) {
347          st->draw_dx = -1; st->draw_dir = LEFT;  st->hole_x -= st->draw_rnd;
348        } else {
349          st->draw_dx =  1; st->draw_dir = RIGHT; st->draw_rnd -= st->hole_x;
350        }
351        st->draw_dy = 0; st->draw_w = st->draw_size = st->draw_rnd + 1; st->draw_h = 1;
352        st->draw_last = HORIZONTAL;
353      } else {
354        if (((st->grid_h > 1) ? st->draw_rnd = random () % (st->grid_h - 1) : 0)
355            < st->hole_y) {
356          st->draw_dy = -1; st->draw_dir = UP;    st->hole_y -= st->draw_rnd;
357        } else {
358          st->draw_dy =  1; st->draw_dir = DOWN;  st->draw_rnd -= st->hole_y;
359        }
360        st->draw_dx = 0; st->draw_h = st->draw_size = st->draw_rnd + 1; st->draw_w = 1;
361        st->draw_last = VERTICAL;
362      }
363  
364      st->draw_ix = st->draw_x = st->xoff + (st->hole_x + st->draw_dx) * st->grid_size;
365      st->draw_iy = st->draw_y = st->yoff + (st->hole_y + st->draw_dy) * st->grid_size;
366      st->draw_inc = st->pix_inc;
367
368    }
369
370  /* for (draw_i = 0; draw_i < grid_size; draw_i += draw_inc) */
371    {
372      int fx, fy, tox, toy;
373      if (st->draw_inc + st->draw_i > st->grid_size)
374        st->draw_inc = st->grid_size - st->draw_i;
375      tox = st->draw_x - st->draw_dx * st->draw_inc;
376      toy = st->draw_y - st->draw_dy * st->draw_inc;
377
378      fx = (st->draw_x < 0 ? 0 : st->draw_x > st->max_width  ? st->max_width  : st->draw_x);
379      fy = (st->draw_y < 0 ? 0 : st->draw_y > st->max_height ? st->max_height : st->draw_y);
380      tox = (tox < 0 ? 0 : tox > st->max_width  ? st->max_width  : tox);
381      toy = (toy < 0 ? 0 : toy > st->max_height ? st->max_height : toy);
382
383      XCopyArea (st->dpy, st->window, st->window, st->gc,
384                 fx, fy,
385                 st->grid_size * st->draw_w, st->grid_size * st->draw_h,
386                 tox, toy);
387
388      st->draw_x -= st->draw_dx * st->draw_inc;
389      st->draw_y -= st->draw_dy * st->draw_inc;
390      switch (st->draw_dir)
391        {
392        case DOWN: XFillRectangle (st->dpy, st->window, st->gc,
393                                st->draw_ix, st->draw_y + st->grid_size * st->draw_h, st->grid_size * st->draw_w, st->draw_iy - st->draw_y);
394          break;
395        case LEFT: XFillRectangle (st->dpy, st->window, st->gc, st->draw_ix, st->draw_iy, st->draw_x - st->draw_ix, st->grid_size * st->draw_h);
396          break;
397        case UP: XFillRectangle (st->dpy, st->window, st->gc, st->draw_ix, st->draw_iy, st->grid_size * st->draw_w, st->draw_y - st->draw_iy);
398          break;
399        case RIGHT: XFillRectangle (st->dpy, st->window, st->gc,
400                                st->draw_x + st->grid_size * st->draw_w, st->draw_iy, st->draw_ix - st->draw_x, st->grid_size * st->draw_h);
401          break;
402        }
403    }
404
405    st->draw_i += st->draw_inc;
406    if (st->draw_i >= st->grid_size)
407      {
408        st->draw_i = 0;
409
410        switch (st->draw_dir)
411          {
412          case DOWN: st->hole_y += st->draw_size; break;
413          case LEFT: st->hole_x--; break;
414          case UP: st->hole_y--; break;
415          case RIGHT: st->hole_x += st->draw_size; break;
416          }
417
418        this_delay = st->delay2;
419      }
420
421    return this_delay;
422 }
423
424 static void
425 slidescreen_reshape (Display *dpy, Window window, void *closure, 
426                  unsigned int w, unsigned int h)
427 {
428   struct state *st = (struct state *) closure;
429   st->max_width = w;
430   st->max_height = h;
431   if (! st->img_loader) {
432     XWindowAttributes xgwa;
433     XGetWindowAttributes (st->dpy, st->window, &xgwa);
434     st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
435                                               st->window, 0, 0);
436     st->start_time = time ((time_t) 0);
437   }
438 }
439
440 static Bool
441 slidescreen_event (Display *dpy, Window window, void *closure, XEvent *event)
442 {
443   struct state *st = (struct state *) closure;
444   if (screenhack_event_helper (dpy, window, event))
445     {
446       st->start_time = 0;
447       return True;
448     }
449   return False;
450 }
451
452 static void
453 slidescreen_free (Display *dpy, Window window, void *closure)
454 {
455   struct state *st = (struct state *) closure;
456   XFreeGC (dpy, st->gc);
457   free (st);
458 }
459
460 \f
461
462 static const char *slidescreen_defaults [] = {
463   "*dontClearRoot:              True",
464   "*fpsSolid:                   true",
465
466 #ifdef __sgi    /* really, HAVE_READ_DISPLAY_EXTENSION */
467   "*visualID:                   Best",
468 #endif
469
470   ".background:                 Black",
471   ".foreground:                 #BEBEBE",
472   "*gridSize:                   70",
473   "*pixelIncrement:             10",
474   "*internalBorderWidth:        4",
475   "*delay:                      50000",
476   "*delay2:                     1000000",
477   "*duration:                   120",
478 #ifdef USE_IPHONE
479   "*ignoreRotation:             True",
480   "*rotateImages:               True",
481 #endif
482   0
483 };
484
485 static XrmOptionDescRec slidescreen_options [] = {
486   { "-grid-size",       ".gridSize",            XrmoptionSepArg, 0 },
487   { "-ibw",             ".internalBorderWidth", XrmoptionSepArg, 0 },
488   { "-increment",       ".pixelIncrement",      XrmoptionSepArg, 0 },
489   { "-delay",           ".delay",               XrmoptionSepArg, 0 },
490   { "-delay2",          ".delay2",              XrmoptionSepArg, 0 },
491   {"-duration",         ".duration",            XrmoptionSepArg, 0 },
492   { 0, 0, 0, 0 }
493 };
494
495 XSCREENSAVER_MODULE ("SlideScreen", slidescreen)