X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?p=xscreensaver;a=blobdiff_plain;f=hacks%2Fslidescreen.c;h=42d3fefca029a6b10a03d81b640f7f334f942f90;hp=37ca4d159392d5589123e227b50310d02bfde197;hb=07faf451b99879183ed7e909e43a0e065be1ee7f;hpb=0a1527cc01e9894017614b7c36b838b2b6914ba9

diff --git a/hacks/slidescreen.c b/hacks/slidescreen.c
index 37ca4d15..42d3fefc 100644
--- a/hacks/slidescreen.c
+++ b/hacks/slidescreen.c
@@ -1,4 +1,4 @@
-/* xscreensaver, Copyright (c) 1992, 1993 Jamie Zawinski <jwz@lucid.com>
+/* xscreensaver, Copyright (c) 1992-2006 Jamie Zawinski <jwz@jwz.org>
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -11,307 +11,446 @@
 
 #include "screenhack.h"
 
-static int grid_size;
-static int pix_inc;
-static int hole_x, hole_y;
-static int bitmap_w, bitmap_h;
-static int xoff, yoff;
-static int grid_w, grid_h;
-static int delay, delay2;
-static GC gc;
-
-static Bool
-MapNotify_event_p (dpy, event, window)
-     Display *dpy;
-     XEvent *event;
-     XPointer window;
-{
-  return (event->xany.type == MapNotify &&
-	  event->xvisibility.window == (Window) window);
-}
+enum { DOWN = 0, LEFT, UP, RIGHT };
+enum { VERTICAL, HORIZONTAL };
+
+struct state {
+  Display *dpy;
+  Window window;
+
+  int grid_size;
+  int pix_inc;
+  int hole_x, hole_y;
+  int bitmap_w, bitmap_h;
+  int xoff, yoff;
+  int grid_w, grid_h;
+  int delay, delay2;
+  GC gc;
+  unsigned long fg, bg;
+  int max_width, max_height;
+  int early_i;
+
+  int draw_rnd, draw_i;
+  int draw_x, draw_y, draw_ix, draw_iy, draw_dx, draw_dy;
+  int draw_dir, draw_w, draw_h, draw_size, draw_inc;
+  int draw_last;
+  int draw_initted;
+
+  async_load_state *img_loader;
+};
 
 
-static Bool
-screensaver_window_p (dpy, window)
-     Display *dpy;
-     Window window;
+static void *
+slidescreen_init (Display *dpy, Window window)
 {
-  Atom type;
-  int format;
-  unsigned long nitems, bytesafter;
-  char *version;
-  Pixmap pixmap;
-  if (XGetWindowProperty (dpy, window,
-			  XInternAtom (dpy, "_SCREENSAVER_VERSION", False),
-			  0, 1, False, XA_STRING,
-			  &type, &format, &nitems, &bytesafter,
-			  (unsigned char **) &version)
-      == Success
-      && type != None)
-    return True;
-  return False;
+  struct state *st = (struct state *) calloc (1, sizeof(*st));
+  XWindowAttributes xgwa;
+  Visual *visual;
+  XGCValues gcv;
+  long gcflags;
+
+  st->dpy = dpy;
+  st->window = window;
+  XGetWindowAttributes (st->dpy, st->window, &xgwa);
+  st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
+                                            st->window, 0, 0);
+
+  visual = xgwa.visual;
+  st->max_width = xgwa.width;
+  st->max_height = xgwa.height;
+
+  st->delay = get_integer_resource (st->dpy, "delay", "Integer");
+  st->delay2 = get_integer_resource (st->dpy, "delay2", "Integer");
+  st->grid_size = get_integer_resource (st->dpy, "gridSize", "Integer");
+  st->pix_inc = get_integer_resource (st->dpy, "pixelIncrement", "Integer");
+
+  /* Don't let the grid be smaller than 5x5 */
+  while (st->grid_size > xgwa.width / 5)
+    st->grid_size /= 2;
+  while (st->grid_size > xgwa.height / 5)
+    st->grid_size /= 2;
+
+  if (st->delay < 0) st->delay = 0;
+  if (st->delay2 < 0) st->delay2 = 0;
+  if (st->pix_inc < 1) st->pix_inc = 1;
+  if (st->grid_size < 1) st->grid_size = 1;
+
+
+  {
+    XColor fgc, bgc;
+    char *fgs = get_string_resource(st->dpy, "background", "Background");
+    char *bgs = get_string_resource(st->dpy, "foreground", "Foreground");
+    Bool fg_ok, bg_ok;
+    if (!XParseColor (st->dpy, xgwa.colormap, fgs, &fgc))
+      XParseColor (st->dpy, xgwa.colormap, "black", &bgc);
+    if (!XParseColor (st->dpy, xgwa.colormap, bgs, &bgc))
+      XParseColor (st->dpy, xgwa.colormap, "gray", &fgc);
+
+    fg_ok = XAllocColor (st->dpy, xgwa.colormap, &fgc);
+    bg_ok = XAllocColor (st->dpy, xgwa.colormap, &bgc);
+
+    /* If we weren't able to allocate the two colors we want from the
+       colormap (which is likely if the screen has been grabbed on an
+       8-bit SGI visual -- don't ask) then just go through the map
+       and find the closest color to the ones we wanted, and use those
+       pixels without actually allocating them.
+     */
+    if (fg_ok)
+      st->fg = fgc.pixel;
+    else
+      st->fg = 0;
+
+    if (bg_ok)
+      st->bg = bgc.pixel;
+    else
+      st->bg = 1;
+
+#ifndef HAVE_COCOA
+    if (!fg_ok || bg_ok)
+      {
+        int i;
+	unsigned long fgd = ~0;
+	unsigned long bgd = ~0;
+	int max = visual_cells (xgwa.screen, xgwa.visual);
+	XColor *all = (XColor *) calloc(sizeof (*all), max);
+	for (i = 0; i < max; i++)
+	  {
+	    all[i].flags = DoRed|DoGreen|DoBlue;
+	    all[i].pixel = i;
+	  }
+	XQueryColors (st->dpy, xgwa.colormap, all, max);
+	for(i = 0; i < max; i++)
+	  {
+	    long rd, gd, bd;
+	    unsigned long dd;
+	    if (!fg_ok)
+	      {
+		rd = (all[i].red   >> 8) - (fgc.red   >> 8);
+		gd = (all[i].green >> 8) - (fgc.green >> 8);
+		bd = (all[i].blue  >> 8) - (fgc.blue  >> 8);
+		if (rd < 0) rd = -rd;
+		if (gd < 0) gd = -gd;
+		if (bd < 0) bd = -bd;
+		dd = (rd << 1) + (gd << 2) + bd;
+		if (dd < fgd)
+		  {
+		    fgd = dd;
+		    st->fg = all[i].pixel;
+		    if (dd == 0)
+		      fg_ok = True;
+		  }
+	      }
+
+	    if (!bg_ok)
+	      {
+		rd = (all[i].red   >> 8) - (bgc.red   >> 8);
+		gd = (all[i].green >> 8) - (bgc.green >> 8);
+		bd = (all[i].blue  >> 8) - (bgc.blue  >> 8);
+		if (rd < 0) rd = -rd;
+		if (gd < 0) gd = -gd;
+		if (bd < 0) bd = -bd;
+		dd = (rd << 1) + (gd << 2) + bd;
+		if (dd < bgd)
+		  {
+		    bgd = dd;
+		    st->bg = all[i].pixel;
+		    if (dd == 0)
+		      bg_ok = True;
+		  }
+	      }
+
+	    if (fg_ok && bg_ok)
+	      break;
+	  }
+	XFree(all);
+      }
+#endif /* !HAVE_COCOA */
+  }
+
+  gcv.foreground = st->fg;
+  gcv.function = GXcopy;
+  gcv.subwindow_mode = IncludeInferiors;
+  gcflags = GCForeground |GCFunction;
+  if (use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
+    gcflags |= GCSubwindowMode;
+  st->gc = XCreateGC (st->dpy, st->window, gcflags, &gcv);
+
+  return st;
 }
 
 static void
-init_slide (dpy, window)
-     Display *dpy;
-     Window window;
+draw_grid (struct state *st)
 {
   int i;
-  XEvent event;
-  XGCValues gcv;
-  XWindowAttributes xgwa;
-  int border;
-  int root_p;
-  unsigned long fg;
-  Pixmap pixmap = 0;
   Drawable d;
-  Colormap cmap;
-
-  XGetWindowAttributes (dpy, window, &xgwa);
-  cmap = xgwa.colormap;
-
-  delay = get_integer_resource ("delay", "Integer");
-  delay2 = get_integer_resource ("delay2", "Integer");
-  grid_size = get_integer_resource ("gridSize", "Integer");
-  pix_inc = get_integer_resource ("pixelIncrement", "Integer");
-  border = get_integer_resource ("internalBorderWidth", "InternalBorderWidth");
-  fg = get_pixel_resource ("background", "Background", dpy, cmap);
-  root_p = get_boolean_resource ("root", "Boolean");
-
-  if (delay < 0) delay = 0;
-  if (delay2 < 0) delay2 = 0;
-  if (pix_inc < 1) pix_inc = 1;
-  if (grid_size < 1) grid_size = 1;
+  int border;
+  XWindowAttributes xgwa;
 
-  gcv.foreground = fg;
-  gcv.function = GXcopy;
-  gcv.subwindow_mode = IncludeInferiors;
-  gc = XCreateGC (dpy, window, GCForeground |GCFunction | GCSubwindowMode,
-		  &gcv);
+  XGetWindowAttributes (st->dpy, st->window, &xgwa);
 
-  if (screensaver_window_p (dpy, window))
-    {
-      /* note: this assumes vroot.h didn't encapsulate the XRootWindowOfScreen
-	 function, only the RootWindowOfScreen macro... */
-      Window real_root = XRootWindowOfScreen (DefaultScreenOfDisplay (dpy));
+  border = get_integer_resource (st->dpy, "internalBorderWidth",
+                                 "InternalBorderWidth");
 
-      XSetWindowBackgroundPixmap (dpy, window, None);
+  XGetWindowAttributes (st->dpy, st->window, &xgwa);
+  st->bitmap_w = xgwa.width;
+  st->bitmap_h = xgwa.height;
 
-      /* prevent random viewer of the screen saver (locker) from messing
-	 with windows.   We don't check whether it succeeded, because what
-	 are our options, really... */
-      XGrabPointer (dpy, real_root, True, ButtonPressMask|ButtonReleaseMask,
-		    GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
-      XGrabKeyboard (dpy, real_root, True, GrabModeSync, GrabModeAsync,
-		     CurrentTime);
+  st->grid_w = st->bitmap_w / st->grid_size;
+  st->grid_h = st->bitmap_h / st->grid_size;
+  st->hole_x = random () % st->grid_w;
+  st->hole_y = random () % st->grid_h;
+  st->xoff = (st->bitmap_w - (st->grid_w * st->grid_size)) / 2;
+  st->yoff = (st->bitmap_h - (st->grid_h * st->grid_size)) / 2;
 
-      XUnmapWindow (dpy, window);
-      XSync (dpy, True);
-      sleep (5);     /* wait for everyone to swap in and handle exposes... */
-      XMapWindow (dpy, window);
+  d = st->window;
 
-      XUngrabPointer (dpy, CurrentTime);
-      XUngrabKeyboard (dpy, CurrentTime);
+  st->early_i = -10;
+  st->draw_last = -1;
 
-      XSync (dpy, True);
-    }
-  else if (root_p)
-    {
-      pixmap = XCreatePixmap(dpy, window, xgwa.width, xgwa.height, xgwa.depth);
-      XCopyArea (dpy, RootWindowOfScreen (xgwa.screen), pixmap, gc,
-		 xgwa.x, xgwa.y, xgwa.width, xgwa.height, 0, 0);
-      XSetWindowBackgroundPixmap (dpy, window, pixmap);
-    }
-  else
+  if (border)
     {
-      XSetWindowBackgroundPixmap (dpy, window, None);
-      XMapWindow (dpy, window);
-      XFlush (dpy);
-      XIfEvent (dpy, &event, MapNotify_event_p, (XPointer) window);
-      XSync (dpy, True);
+      int half = border/2;
+      int half2 = (border & 1 ? half+1 : half);
+      XSetForeground(st->dpy, st->gc, st->bg);
+      for (i = 0; i < st->bitmap_w; i += st->grid_size)
+	{
+	  int j;
+	  for (j = 0; j < st->bitmap_h; j += st->grid_size)
+	    XDrawRectangle (st->dpy, d, st->gc,
+			    st->xoff+i+half2, st->yoff+j+half2,
+			    st->grid_size-border-1, st->grid_size-border-1);
+	}
+
+      XSetForeground(st->dpy, st->gc, st->fg);
+      for (i = 0; i <= st->bitmap_w; i += st->grid_size)
+	XFillRectangle (st->dpy, d, st->gc, st->xoff+i-half, st->yoff, border, st->bitmap_h);
+      for (i = 0; i <= st->bitmap_h; i += st->grid_size)
+	XFillRectangle (st->dpy, d, st->gc, st->xoff, st->yoff+i-half, st->bitmap_w, border);
     }
 
-  XGetWindowAttributes (dpy, window, &xgwa);
-  bitmap_w = xgwa.width;
-  bitmap_h = xgwa.height;
-
-  grid_w = bitmap_w / grid_size;
-  grid_h = bitmap_h / grid_size;
-  hole_x = random () % grid_w;
-  hole_y = random () % grid_h;
-  xoff = (bitmap_w - (grid_w * grid_size)) / 2;
-  yoff = (bitmap_h - (grid_h * grid_size)) / 2;
-
-  d = (pixmap ? pixmap : window);
-
-  if (border)
+  if (st->xoff)
     {
-      int i;
-      for (i = 0; i <= bitmap_w; i += grid_size)
-	XFillRectangle (dpy, d, gc, xoff+i-border/2, yoff, border, bitmap_h);
-      for (i = 0; i <= bitmap_h; i += grid_size)
-	XFillRectangle (dpy, d, gc, xoff, yoff+i-border/2, bitmap_w, border);
+      XFillRectangle (st->dpy, d, st->gc, 0, 0, st->xoff, st->bitmap_h);
+      XFillRectangle (st->dpy, d, st->gc, st->bitmap_w - st->xoff, 0, st->xoff, st->bitmap_h);
     }
-
-  if (xoff)
+  if (st->yoff)
     {
-      XFillRectangle (dpy, d, gc, 0, 0, xoff, bitmap_h);
-      XFillRectangle (dpy, d, gc, bitmap_w - xoff, 0, xoff, bitmap_h);
+      XFillRectangle (st->dpy, d, st->gc, 0, 0, st->bitmap_w, st->yoff);
+      XFillRectangle (st->dpy, d, st->gc, 0, st->bitmap_h - st->yoff, st->bitmap_w, st->yoff);
     }
-  if (yoff)
+}
+
+
+static int
+slidescreen_draw_early (struct state *st)
+{
+  while (st->early_i < 0)
     {
-      XFillRectangle (dpy, d, gc, 0, 0, bitmap_w, yoff);
-      XFillRectangle (dpy, d, gc, 0, bitmap_h - yoff, bitmap_w, yoff);
+      st->early_i++;
+      return 1;
     }
 
-  if (pixmap) XClearWindow (dpy, window);
-  XSync (dpy, True);
-  if (delay2) usleep (delay2 * 2);
- for (i = 0; i < grid_size; i += pix_inc)
+  /* for (early_i = 0; early_i < grid_size; early_i += pix_inc) */
    {
      XPoint points [3];
-     points[0].x = xoff + grid_size * hole_x;
-     points[0].y = yoff + grid_size * hole_y;
-     points[1].x = points[0].x + grid_size;
+     points[0].x = st->xoff + st->grid_size * st->hole_x;
+     points[0].y = st->yoff + st->grid_size * st->hole_y;
+     points[1].x = points[0].x + st->grid_size;
      points[1].y = points[0].y;
      points[2].x = points[0].x;
-     points[2].y = points[0].y + i;
-     XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin);
+     points[2].y = points[0].y + st->early_i;
+     XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
 
      points[1].x = points[0].x;
-     points[1].y = points[0].y + grid_size;
-     points[2].x = points[0].x + i;
-     points[2].y = points[0].y + grid_size;
-     XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin);
+     points[1].y = points[0].y + st->grid_size;
+     points[2].x = points[0].x + st->early_i;
+     points[2].y = points[0].y + st->grid_size;
+     XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
 
-     points[0].x = points[1].x + grid_size;
+     points[0].x = points[1].x + st->grid_size;
      points[0].y = points[1].y;
      points[2].x = points[0].x;
-     points[2].y = points[0].y - i;
-     XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin);
+     points[2].y = points[0].y - st->early_i;
+     XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
 
      points[1].x = points[0].x;
-     points[1].y = points[0].y - grid_size;
-     points[2].x = points[1].x - i;
+     points[1].y = points[0].y - st->grid_size;
+     points[2].x = points[1].x - st->early_i;
      points[2].y = points[1].y;
-     XFillPolygon (dpy, window, gc, points, 3, Convex, CoordModeOrigin);
-
-     XSync (dpy, True);
-     if (delay) usleep (delay);
+     XFillPolygon (st->dpy, st->window, st->gc, points, 3, Convex, CoordModeOrigin);
    }
 
-  XFillRectangle (dpy, window, gc,
-		  xoff + grid_size * hole_x,
-		  yoff + grid_size * hole_y,
-		  grid_size, grid_size);
+   st->early_i += st->pix_inc;
+   if (st->early_i < st->grid_size)
+     return 1;
+
+   XFillRectangle (st->dpy, st->window, st->gc,
+                   st->xoff + st->grid_size * st->hole_x,
+                   st->yoff + st->grid_size * st->hole_y,
+                   st->grid_size, st->grid_size);
+   return 0;
 }
 
-static void
-slide1 (dpy, window)
-     Display *dpy;
-     Window window;
+
+static unsigned long
+slidescreen_draw (Display *dpy, Window window, void *closure)
 {
+  struct state *st = (struct state *) closure;
+  int this_delay = st->delay;
+
   /* this code is a total kludge, but who cares, it works... */
- int i, x, y, ix, iy, dx, dy, dir, w, h, size, inc;
- static int last = -1;
- do {
-   dir = random () % 4;
-   switch (dir)
-     {
-     case 0: dx = 0,  dy = 1;  break;
-     case 1: dx = -1, dy = 0;  break;
-     case 2: dx = 0,  dy = -1; break;
-     case 3: dx = 1,  dy = 0;  break;
-     }
- } while (dir == last ||
-	  hole_x + dx < 0 || hole_x + dx >= grid_w ||
-	  hole_y + dy < 0 || hole_y + dy >= grid_h);
- if (grid_w > 1 && grid_h > 1)
-   last = (dir == 0 ? 2 : dir == 2 ? 0 : dir == 1 ? 3 : 1);
 
- switch (dir)
+  if (st->img_loader)   /* still loading */
+    {
+      st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
+      if (! st->img_loader)  /* just finished */
+        draw_grid (st);
+      return st->delay;
+    }
+
+  if (! st->draw_initted)
+    {
+      if (!slidescreen_draw_early (st))
+        {
+          st->draw_initted = 1;
+          return st->delay2;
+        }
+      else
+        return st->delay;
+    }
+
+ if (st->draw_i == 0)
    {
-   case 0: size = 1 + (random()%(grid_h - hole_y - 1)); h = size; w = 1; break;
-   case 1: size = 1 + (random()%hole_x); 	        w = size; h = 1; break;
-   case 2: size = 1 + (random()%hole_y);	        h = size; w = 1; break;
-   case 3: size = 1 + (random()%(grid_w - hole_x - 1)); w = size; h = 1; break;
-   }
+     if (st->draw_last == -1) st->draw_last = random () % 2;
+
+     /* alternate between horizontal and vertical slides */
+     /* note that draw_dir specifies the direction the _hole_ moves, not the tiles */
+     if (st->draw_last == VERTICAL) {
+       if (((st->grid_w > 1) ? st->draw_rnd = random () % (st->grid_w - 1) : 0)
+	   < st->hole_x) {
+         st->draw_dx = -1; st->draw_dir = LEFT;  st->hole_x -= st->draw_rnd;
+       } else {
+         st->draw_dx =  1; st->draw_dir = RIGHT; st->draw_rnd -= st->hole_x;
+       }
+       st->draw_dy = 0; st->draw_w = st->draw_size = st->draw_rnd + 1; st->draw_h = 1;
+       st->draw_last = HORIZONTAL;
+     } else {
+       if (((st->grid_h > 1) ? st->draw_rnd = random () % (st->grid_h - 1) : 0)
+	   < st->hole_y) {
+         st->draw_dy = -1; st->draw_dir = UP;    st->hole_y -= st->draw_rnd;
+       } else {
+         st->draw_dy =  1; st->draw_dir = DOWN;  st->draw_rnd -= st->hole_y;
+       }
+       st->draw_dx = 0; st->draw_h = st->draw_size = st->draw_rnd + 1; st->draw_w = 1;
+       st->draw_last = VERTICAL;
+     }
+ 
+     st->draw_ix = st->draw_x = st->xoff + (st->hole_x + st->draw_dx) * st->grid_size;
+     st->draw_iy = st->draw_y = st->yoff + (st->hole_y + st->draw_dy) * st->grid_size;
+     st->draw_inc = st->pix_inc;
 
- if (dx == -1) hole_x -= (size - 1);
- else if (dy == -1) hole_y -= (size - 1);
+   }
 
- ix = x = xoff + (hole_x + dx) * grid_size;
- iy = y = yoff + (hole_y + dy) * grid_size;
- inc = pix_inc;
- for (i = 0; i < grid_size; i += inc)
+ /* for (draw_i = 0; draw_i < grid_size; draw_i += draw_inc) */
    {
-     if (inc + i > grid_size)
-       inc = grid_size - i;
-     XCopyArea (dpy, window, window, gc, x, y, grid_size * w, grid_size * h,
-		x - dx * inc, y - dy * inc);
-     x -= dx * inc;
-     y -= dy * inc;
-     switch (dir)
+     int fx, fy, tox, toy;
+     if (st->draw_inc + st->draw_i > st->grid_size)
+       st->draw_inc = st->grid_size - st->draw_i;
+     tox = st->draw_x - st->draw_dx * st->draw_inc;
+     toy = st->draw_y - st->draw_dy * st->draw_inc;
+
+     fx = (st->draw_x < 0 ? 0 : st->draw_x > st->max_width  ? st->max_width  : st->draw_x);
+     fy = (st->draw_y < 0 ? 0 : st->draw_y > st->max_height ? st->max_height : st->draw_y);
+     tox = (tox < 0 ? 0 : tox > st->max_width  ? st->max_width  : tox);
+     toy = (toy < 0 ? 0 : toy > st->max_height ? st->max_height : toy);
+
+     XCopyArea (st->dpy, st->window, st->window, st->gc,
+		fx, fy,
+		st->grid_size * st->draw_w, st->grid_size * st->draw_h,
+		tox, toy);
+
+     st->draw_x -= st->draw_dx * st->draw_inc;
+     st->draw_y -= st->draw_dy * st->draw_inc;
+     switch (st->draw_dir)
        {
-       case 0: XFillRectangle (dpy, window, gc,
-			       ix, y + grid_size * h, grid_size * w, iy - y);
+       case DOWN: XFillRectangle (st->dpy, st->window, st->gc,
+			       st->draw_ix, st->draw_y + st->grid_size * st->draw_h, st->grid_size * st->draw_w, st->draw_iy - st->draw_y);
 	 break;
-       case 1: XFillRectangle (dpy, window, gc, ix, iy, x - ix, grid_size * h);
+       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);
 	 break;
-       case 2: XFillRectangle (dpy, window, gc, ix, iy, grid_size * w, y - iy);
+       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);
 	 break;
-       case 3: XFillRectangle (dpy, window, gc,
-			       x + grid_size * w, iy, ix - x, grid_size * h);
+       case RIGHT: XFillRectangle (st->dpy, st->window, st->gc,
+			       st->draw_x + st->grid_size * st->draw_w, st->draw_iy, st->draw_ix - st->draw_x, st->grid_size * st->draw_h);
 	 break;
        }
-
-     XSync (dpy, True);
-     if (delay) usleep (delay);
-   }
- switch (dir)
-   {
-   case 0: hole_y += size; break;
-   case 1: hole_x--; break;
-   case 2: hole_y--; break;
-   case 3: hole_x += size; break;
    }
+
+   st->draw_i += st->draw_inc;
+   if (st->draw_i >= st->grid_size)
+     {
+       st->draw_i = 0;
+
+       switch (st->draw_dir)
+         {
+         case DOWN: st->hole_y += st->draw_size; break;
+         case LEFT: st->hole_x--; break;
+         case UP: st->hole_y--; break;
+         case RIGHT: st->hole_x += st->draw_size; break;
+         }
+
+       this_delay = st->delay2;
+     }
+
+   return this_delay;
+}
+
+static void
+slidescreen_reshape (Display *dpy, Window window, void *closure, 
+                 unsigned int w, unsigned int h)
+{
+}
+
+static Bool
+slidescreen_event (Display *dpy, Window window, void *closure, XEvent *event)
+{
+  return False;
+}
+
+static void
+slidescreen_free (Display *dpy, Window window, void *closure)
+{
+  struct state *st = (struct state *) closure;
+  XFreeGC (dpy, st->gc);
+  free (st);
 }
 
 
-char *progclass = "SlidePuzzle";
 
-char *defaults [] = {
-  "SlidePuzzle.mappedWhenManaged:false",
-  "SlidePuzzle.dontClearWindow:	 true",
-  "*background:			black",
+static const char *slidescreen_defaults [] = {
+  "*dontClearRoot:		True",
+
+#ifdef __sgi	/* really, HAVE_READ_DISPLAY_EXTENSION */
+  "*visualID:			Best",
+#endif
+
+  ".background:			Black",
+  ".foreground:			#BEBEBE",
   "*gridSize:			70",
   "*pixelIncrement:		10",
-  "*internalBorderWidth:	1",
+  "*internalBorderWidth:	4",
   "*delay:			50000",
   "*delay2:			1000000",
   0
 };
 
-XrmOptionDescRec options [] = {
+static XrmOptionDescRec slidescreen_options [] = {
   { "-grid-size",	".gridSize",		XrmoptionSepArg, 0 },
   { "-ibw",		".internalBorderWidth",	XrmoptionSepArg, 0 },
   { "-increment",	".pixelIncrement",	XrmoptionSepArg, 0 },
   { "-delay",		".delay",		XrmoptionSepArg, 0 },
   { "-delay2",		".delay2",		XrmoptionSepArg, 0 },
+  { 0, 0, 0, 0 }
 };
 
-int options_size = (sizeof (options) / sizeof (options[0]));
-
-void
-screenhack (dpy, window)
-     Display *dpy;
-     Window window;
-{
-  init_slide (dpy, window);
-  while (1)
-    {
-      slide1 (dpy, window);
-      if (delay2) usleep (delay2);
-    }
-}
+XSCREENSAVER_MODULE ("Slidescreen", slidescreen)