X-Git-Url: http://git.hungrycats.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=driver%2Fwindows.c;h=8598e7e0f1ab05cfe4aae2afe3b0cb59aa9d44ab;hb=8eb2873d7054e705c4e83f22d18c40946a9e2529;hp=ded26972a547d1b1241ff25f43605b45bb88e01b;hpb=df7adbee81405e2849728a24b498ad2117784b1f;p=xscreensaver

diff --git a/driver/windows.c b/driver/windows.c
index ded26972..8598e7e0 100644
--- a/driver/windows.c
+++ b/driver/windows.c
@@ -1,5 +1,5 @@
 /* windows.c --- turning the screen black; dealing with visuals, virtual roots.
- * xscreensaver, Copyright (c) 1991-1998 Jamie Zawinski <jwz@jwz.org>
+ * xscreensaver, Copyright (c) 1991-2001 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
@@ -45,6 +45,10 @@
 # include <X11/extensions/xf86vmode.h>
 #endif /* HAVE_XF86VMODE */
 
+#ifdef HAVE_XINERAMA
+# include <X11/extensions/Xinerama.h>
+#endif /* HAVE_XINERAMA */
+
 
 /* This file doesn't need the Xt headers, so stub these types out... */
 #undef XtPointer
@@ -63,13 +67,13 @@ extern int kill (pid_t, int);		/* signal() is in sys/signal.h... */
 
 Atom XA_VROOT, XA_XSETROOT_ID;
 Atom XA_SCREENSAVER, XA_SCREENSAVER_VERSION, XA_SCREENSAVER_ID;
-Atom XA_SCREENSAVER_TIME;
+Atom XA_SCREENSAVER_STATUS;
 
 
 extern saver_info *global_si_kludge;	/* I hate C so much... */
 
-
-static void store_activate_time (saver_info *si, Bool use_last_p);
+static void maybe_transfer_grabs (saver_screen_info *ssi,
+                                  Window old_w, Window new_w, int new_screen);
 
 #define ALL_POINTER_EVENTS \
 	(ButtonPressMask | ButtonReleaseMask | EnterWindowMask | \
@@ -98,7 +102,7 @@ grab_string(int status)
 }
 
 static int
-grab_kbd(saver_info *si, Window w)
+grab_kbd(saver_info *si, Window w, int screen_no)
 {
   saver_preferences *p = &si->prefs;
   int status = XGrabKeyboard (si->dpy, w, True,
@@ -107,28 +111,34 @@ grab_kbd(saver_info *si, Window w)
 			      GrabModeSync, GrabModeAsync,
 			      CurrentTime);
   if (status == GrabSuccess)
-    si->keyboard_grab_window = w;
+    {
+      si->keyboard_grab_window = w;
+      si->keyboard_grab_screen = screen_no;
+    }
 
   if (p->verbose_p)
-    fprintf(stderr, "%s: grabbing keyboard on 0x%x... %s.\n",
-	    blurb(), (unsigned long) w, grab_string(status));
+    fprintf(stderr, "%s: %d: grabbing keyboard on 0x%x... %s.\n",
+	    blurb(), screen_no, (unsigned long) w, grab_string(status));
   return status;
 }
 
 
 static int
-grab_mouse (saver_info *si, Window w, Cursor cursor)
+grab_mouse (saver_info *si, Window w, Cursor cursor, int screen_no)
 {
   saver_preferences *p = &si->prefs;
   int status = XGrabPointer (si->dpy, w, True, ALL_POINTER_EVENTS,
 			     GrabModeAsync, GrabModeAsync, w,
 			     cursor, CurrentTime);
   if (status == GrabSuccess)
-    si->mouse_grab_window = w;
+    {
+      si->mouse_grab_window = w;
+      si->mouse_grab_screen = screen_no;
+    }
 
   if (p->verbose_p)
-    fprintf(stderr, "%s: grabbing mouse on 0x%x... %s.\n",
-	    blurb(), (unsigned long) w, grab_string(status));
+    fprintf(stderr, "%s: %d: grabbing mouse on 0x%x... %s.\n",
+	    blurb(), screen_no, (unsigned long) w, grab_string(status));
   return status;
 }
 
@@ -139,8 +149,9 @@ ungrab_kbd(saver_info *si)
   saver_preferences *p = &si->prefs;
   XUngrabKeyboard(si->dpy, CurrentTime);
   if (p->verbose_p)
-    fprintf(stderr, "%s: ungrabbing keyboard (was 0x%x).\n", blurb(),
-	    (unsigned long) si->keyboard_grab_window);
+    fprintf(stderr, "%s: %d: ungrabbing keyboard (was 0x%x).\n",
+            blurb(), si->keyboard_grab_screen,
+            (unsigned long) si->keyboard_grab_window);
   si->keyboard_grab_window = 0;
 }
 
@@ -151,38 +162,51 @@ ungrab_mouse(saver_info *si)
   saver_preferences *p = &si->prefs;
   XUngrabPointer(si->dpy, CurrentTime);
   if (p->verbose_p)
-    fprintf(stderr, "%s: ungrabbing mouse (was 0x%x).\n", blurb(),
-	    (unsigned long) si->mouse_grab_window);
+    fprintf(stderr, "%s: %d: ungrabbing mouse (was 0x%x).\n",
+            blurb(), si->mouse_grab_screen,
+            (unsigned long) si->mouse_grab_window);
   si->mouse_grab_window = 0;
 }
 
 
 static Bool
-grab_keyboard_and_mouse (saver_info *si, Window window, Cursor cursor)
+grab_keyboard_and_mouse (saver_info *si, Window window, Cursor cursor,
+                         int screen_no)
 {
   Status mstatus, kstatus;
-  XSync (si->dpy, False);
+  int i;
+  int retries = 4;
 
-  kstatus = grab_kbd (si, window);
-  if (kstatus != GrabSuccess)
-    {	/* try again in a second */
+  for (i = 0; i < retries; i++)
+    {
+      XSync (si->dpy, False);
+      kstatus = grab_kbd (si, window, screen_no);
+      if (kstatus == GrabSuccess)
+        break;
+
+      /* else, wait a second and try to grab again. */
       sleep (1);
-      kstatus = grab_kbd (si, window);
-      if (kstatus != GrabSuccess)
-	fprintf (stderr, "%s: couldn't grab keyboard!  (%s)\n",
-		 blurb(), grab_string(kstatus));
     }
 
-  mstatus = grab_mouse (si, window, cursor);
-  if (mstatus != GrabSuccess)
-    {	/* try again in a second */
+  if (kstatus != GrabSuccess)
+    fprintf (stderr, "%s: couldn't grab keyboard!  (%s)\n",
+             blurb(), grab_string(kstatus));
+
+  for (i = 0; i < retries; i++)
+    {
+      XSync (si->dpy, False);
+      mstatus = grab_mouse (si, window, cursor, screen_no);
+      if (mstatus == GrabSuccess)
+        break;
+
+      /* else, wait a second and try to grab again. */
       sleep (1);
-      mstatus = grab_mouse (si, window, cursor);
-      if (mstatus != GrabSuccess)
-	fprintf (stderr, "%s: couldn't grab pointer!  (%s)\n",
-		 blurb(), grab_string(mstatus));
     }
 
+  if (mstatus != GrabSuccess)
+    fprintf (stderr, "%s: couldn't grab pointer!  (%s)\n",
+             blurb(), grab_string(mstatus));
+
   return (kstatus == GrabSuccess ||
 	  mstatus == GrabSuccess);
 }
@@ -196,12 +220,12 @@ ungrab_keyboard_and_mouse (saver_info *si)
 
 
 int
-move_mouse_grab (saver_info *si, Window to, Cursor cursor)
+move_mouse_grab (saver_info *si, Window to, Cursor cursor, int to_screen_no)
 {
   Window old = si->mouse_grab_window;
 
   if (old == 0)
-    return grab_mouse (si, to, cursor);
+    return grab_mouse (si, to, cursor, to_screen_no);
   else
     {
       saver_preferences *p = &si->prefs;
@@ -215,18 +239,18 @@ move_mouse_grab (saver_info *si, Window to, Cursor cursor)
         fprintf(stderr, "%s: grabbing server...\n", blurb());
 
       ungrab_mouse (si);
-      status = grab_mouse (si, to, cursor);
+      status = grab_mouse (si, to, cursor, to_screen_no);
 
       if (status != GrabSuccess)   /* Augh! */
         {
           sleep (1);               /* Note dramatic evil of sleeping
                                       with server grabbed. */
           XSync (si->dpy, False);
-          status = grab_mouse (si, to, cursor);
+          status = grab_mouse (si, to, cursor, to_screen_no);
         }
 
       if (status != GrabSuccess)   /* Augh!  Try to get the old one back... */
-        grab_mouse (si, to, cursor);
+        grab_mouse (si, old, cursor, to_screen_no);
 
       XUngrabServer (si->dpy);
       XSync (si->dpy, False);			/* ###### (danger over) */
@@ -615,7 +639,9 @@ handle_signals (saver_info *si, Bool on_p)
   catch_signal (si, SIGQUIT, on_p);
   catch_signal (si, SIGILL,  on_p);
   catch_signal (si, SIGTRAP, on_p);
+#ifdef SIGIOT
   catch_signal (si, SIGIOT,  on_p);
+#endif
   catch_signal (si, SIGABRT, on_p);
 #ifdef SIGEMT
   catch_signal (si, SIGEMT,  on_p);
@@ -653,11 +679,10 @@ saver_exit (saver_info *si, int status, const char *dump_core_reason)
   
   vrs = restore_real_vroot_1 (si);
   emergency_kill_subproc (si);
+  shutdown_stderr (si);
 
-  if (vrs && (p->verbose_p || status != 0))
-    fprintf (real_stderr, "%s: vroot restored, exiting.\n", blurb());
-  else if (p->verbose_p)
-    fprintf (real_stderr, "%s: no vroot to restore; exiting.\n", blurb());
+  if (p->verbose_p && vrs)
+    fprintf (real_stderr, "%s: old vroot restored.\n", blurb());
 
   fflush(real_stdout);
 
@@ -731,7 +756,7 @@ store_saver_id (saver_screen_info *ssi)
   struct passwd *p = getpwuid (getuid ());
   const char *name, *host;
   char *id;
-  
+
   /* First store the name and class on the window.
    */
   class_hints.res_name = progname;
@@ -786,6 +811,35 @@ store_saver_id (saver_screen_info *ssi)
 }
 
 
+void
+store_saver_status (saver_info *si)
+{
+  CARD32 *status;
+  int size = si->nscreens + 2;
+  int i;
+
+  status = (CARD32 *) calloc (size, sizeof(CARD32));
+
+  status[0] = (CARD32) (si->screen_blanked_p
+                        ? (si->locked_p ? XA_LOCK : XA_BLANK)
+                        : 0);
+  status[1] = (CARD32) si->blank_time;
+
+  for (i = 0; i < si->nscreens; i++)
+    {
+      saver_screen_info *ssi = &si->screens[i];
+      status [2 + i] = ssi->current_hack + 1;
+    }
+
+  XChangeProperty (si->dpy,
+                   RootWindow (si->dpy, 0),  /* always screen #0 */
+                   XA_SCREENSAVER_STATUS,
+                   XA_INTEGER, 32, PropModeReplace,
+                   (unsigned char *) status, size);
+}
+
+
+
 /* Returns the area of the screen which the xscreensaver window should cover.
    Normally this is the whole screen, but if the X server's root window is
    actually larger than the monitor's displayable area, then we want to
@@ -795,6 +849,7 @@ void
 get_screen_viewport (saver_screen_info *ssi,
                      int *x_ret, int *y_ret,
                      int *w_ret, int *h_ret,
+                     int target_x, int target_y,
                      Bool verbose_p)
 {
   int w = WidthOfScreen (ssi->screen);
@@ -802,15 +857,68 @@ get_screen_viewport (saver_screen_info *ssi,
 
 #ifdef HAVE_XF86VMODE
   saver_info *si = ssi->global;
-  int screen_no = screen_number (ssi->screen);
   int event, error;
   int dot;
   XF86VidModeModeLine ml;
   int x, y;
+  Bool xinerama_p;
+  Bool placement_only_p = (target_x != -1 && target_y != -1);
+
+#ifdef HAVE_XINERAMA
+  xinerama_p = (XineramaQueryExtension (si->dpy, &event, &error) &&
+                XineramaIsActive (si->dpy));
+#else  /* !HAVE_XINERAMA */
+  /* Even if we don't have the client-side Xinerama lib, check to see if
+     the server supports Xinerama, so that we know to ignore the VidMode
+     extension -- otherwise a server crash could result.  Yay. */
+  xinerama_p = XQueryExtension (si->dpy, "XINERAMA", &error, &event, &error);
+  
+#endif /* !HAVE_XINERAMA */
 
-  if (XF86VidModeQueryExtension (si->dpy, &event, &error) &&
-      XF86VidModeGetModeLine (si->dpy, screen_no, &dot, &ml) &&
-      XF86VidModeGetViewPort (si->dpy, screen_no, &x, &y))
+#ifdef HAVE_XINERAMA
+  if (xinerama_p && placement_only_p)
+    {
+      int nscreens = 0;
+      XineramaScreenInfo *xsi = XineramaQueryScreens (si->dpy, &nscreens);
+      if (xsi)
+        {
+          /* Find the screen that contains the mouse. */
+          int which = -1;
+          int i;
+          for (i = 0; i < nscreens; i++)
+            {
+              if (target_x >= xsi[i].x_org &&
+                  target_y >= xsi[i].y_org &&
+                  target_x < xsi[i].x_org + xsi[i].width &&
+                  target_y < xsi[i].y_org + xsi[i].height)
+                which = i;
+              if (verbose_p)
+                {
+                  fprintf (stderr, "%s: %d: xinerama vp: %dx%d+%d+%d",
+                           blurb(), i,
+                           xsi[which].width, xsi[which].height,
+                           xsi[i].x_org, xsi[i].y_org);
+                  if (which == i)
+                    fprintf (stderr, "; mouse at %d,%d",
+                             target_x, target_y);
+                  fprintf (stderr, ".\n");
+                }
+            }
+          if (which == -1) which = 0;  /* didn't find it?  Use the first. */
+          *x_ret = xsi[which].x_org;
+          *y_ret = xsi[which].y_org;
+          *w_ret = xsi[which].width;
+          *h_ret = xsi[which].height;
+          XFree (xsi);
+          return;
+        }
+    }
+#endif /* HAVE_XINERAMA */
+
+  if (!xinerama_p &&  /* Xinerama + VidMode = broken. */
+      XF86VidModeQueryExtension (si->dpy, &event, &error) &&
+      XF86VidModeGetModeLine (si->dpy, ssi->number, &dot, &ml) &&
+      XF86VidModeGetViewPort (si->dpy, ssi->number, &x, &y))
     {
       char msg[512];
       *x_ret = x;
@@ -822,8 +930,37 @@ get_screen_viewport (saver_screen_info *ssi,
         /* There is no viewport -- the screen does not scroll. */
         return;
 
-      sprintf (msg, "%s: vp is %dx%d+%d+%d",
-               blurb(), *w_ret, *h_ret, *x_ret, *y_ret);
+
+      /* Apparently some versions of XFree86 return nonsense here!
+         I've had reports of 1024x768 viewports at -1936862040, -1953705044.
+         So, sanity-check the values and give up if they are out of range.
+       */
+      if (*x_ret <  0 || *x_ret >= w ||
+          *y_ret <  0 || *y_ret >= h ||
+          *w_ret <= 0 || *w_ret >  w ||
+          *h_ret <= 0 || *h_ret >  h)
+        {
+          static int warned_once = 0;
+          if (!warned_once)
+            {
+              fprintf (stderr, "\n"
+                  "%s: X SERVER BUG: %dx%d viewport at %d,%d is impossible.\n"
+                  "%s: The XVidMode server extension is returning nonsense.\n"
+                  "%s: Please report this bug to your X server vendor.\n\n",
+                       blurb(), *w_ret, *h_ret, *x_ret, *y_ret,
+                       blurb(), blurb());
+              warned_once = 1;
+            }
+          *x_ret = 0;
+          *y_ret = 0;
+          *w_ret = w;
+          *h_ret = h;
+          return;
+        }
+
+      sprintf (msg, "%s: %d: vp is %dx%d+%d+%d",
+               blurb(), ssi->number,
+               *w_ret, *h_ret, *x_ret, *y_ret);
 
 
       /* Apparently, though the server stores the X position in increments of
@@ -886,6 +1023,80 @@ get_screen_viewport (saver_screen_info *ssi,
 }
 
 
+static Bool error_handler_hit_p = False;
+
+static int
+ignore_all_errors_ehandler (Display *dpy, XErrorEvent *error)
+{
+  error_handler_hit_p = True;
+  return 0;
+}
+
+
+/* Returns True if successful, False if an X error occurred.
+   We need this because other programs might have done things to
+   our window that will cause XChangeWindowAttributes() to fail:
+   if that happens, we give up, destroy the window, and re-create
+   it.
+ */
+static Bool
+safe_XChangeWindowAttributes (Display *dpy, Window window,
+                              unsigned long mask,
+                              XSetWindowAttributes *attrs)
+{
+  XErrorHandler old_handler;
+  XSync (dpy, False);
+  error_handler_hit_p = False;
+  old_handler = XSetErrorHandler (ignore_all_errors_ehandler);
+
+  XChangeWindowAttributes (dpy, window, mask, attrs);
+
+  XSync (dpy, False);
+  XSetErrorHandler (old_handler);
+  XSync (dpy, False);
+
+  return (!error_handler_hit_p);
+}
+
+
+/* This might not be necessary, but just in case. */
+static Bool
+safe_XConfigureWindow (Display *dpy, Window window,
+                       unsigned long mask, XWindowChanges *changes)
+{
+  XErrorHandler old_handler;
+  XSync (dpy, False);
+  error_handler_hit_p = False;
+  old_handler = XSetErrorHandler (ignore_all_errors_ehandler);
+
+  XConfigureWindow (dpy, window, mask, changes);
+
+  XSync (dpy, False);
+  XSetErrorHandler (old_handler);
+  XSync (dpy, False);
+
+  return (!error_handler_hit_p);
+}
+
+/* This might not be necessary, but just in case. */
+static Bool
+safe_XDestroyWindow (Display *dpy, Window window)
+{
+  XErrorHandler old_handler;
+  XSync (dpy, False);
+  error_handler_hit_p = False;
+  old_handler = XSetErrorHandler (ignore_all_errors_ehandler);
+
+  XDestroyWindow (dpy, window);
+
+  XSync (dpy, False);
+  XSetErrorHandler (old_handler);
+  XSync (dpy, False);
+
+  return (!error_handler_hit_p);
+}
+
+
 static void
 initialize_screensaver_window_1 (saver_screen_info *ssi)
 {
@@ -903,8 +1114,9 @@ initialize_screensaver_window_1 (saver_screen_info *ssi)
   unsigned long attrmask;
   int x, y, width, height;
   static Bool printed_visual_info = False;  /* only print the message once. */
+  Window horked_window = 0;
 
-  get_screen_viewport (ssi, &x, &y, &width, &height,
+  get_screen_viewport (ssi, &x, &y, &width, &height, -1, -1,
                        (p->verbose_p && !si->screen_blanked_p));
 
   black.red = black.green = black.blue = 0;
@@ -965,7 +1177,7 @@ initialize_screensaver_window_1 (saver_screen_info *ssi)
     ;
   else if (ssi->current_visual == DefaultVisualOfScreen (ssi->screen))
     {
-      fprintf (stderr, "%s: using default visual ", blurb());
+      fprintf (stderr, "%s: %d: visual ", blurb(), ssi->number);
       describe_visual (stderr, ssi->screen, ssi->current_visual,
 		       install_cmap_p);
     }
@@ -1042,12 +1254,17 @@ initialize_screensaver_window_1 (saver_screen_info *ssi)
       changes.height = height;
       changes.border_width = 0;
 
-      XConfigureWindow (si->dpy, ssi->screensaver_window,
-			changesmask, &changes);
-      XChangeWindowAttributes (si->dpy, ssi->screensaver_window,
-			       attrmask, &attrs);
+      if (! (safe_XConfigureWindow (si->dpy, ssi->screensaver_window,
+                                  changesmask, &changes) &&
+             safe_XChangeWindowAttributes (si->dpy, ssi->screensaver_window,
+                                           attrmask, &attrs)))
+        {
+          horked_window = ssi->screensaver_window;
+          ssi->screensaver_window = 0;
+        }
     }
-  else
+
+  if (!ssi->screensaver_window)
     {
       ssi->screensaver_window =
 	XCreateWindow (si->dpy, RootWindowOfScreen (ssi->screen),
@@ -1056,14 +1273,25 @@ initialize_screensaver_window_1 (saver_screen_info *ssi)
 		       ssi->current_visual, attrmask, &attrs);
 
       reset_stderr (ssi);
-      store_activate_time(si, True);
+
+      if (horked_window)
+        {
+          fprintf (stderr,
+            "%s: someone horked our saver window (0x%lx)!  Recreating it...\n",
+                   blurb(), (unsigned long) horked_window);
+          maybe_transfer_grabs (ssi, horked_window, ssi->screensaver_window,
+                                ssi->number);
+          safe_XDestroyWindow (si->dpy, horked_window);
+          horked_window = 0;
+        }
+
       if (p->verbose_p)
-	fprintf (stderr, "%s: saver window is 0x%lx.\n",
-		 blurb(), (unsigned long) ssi->screensaver_window);
+	fprintf (stderr, "%s: %d: saver window is 0x%lx.\n",
+                 blurb(), ssi->number,
+                 (unsigned long) ssi->screensaver_window);
     }
 
-
-  store_saver_id (ssi);
+  store_saver_id (ssi);       /* store window name and IDs */
 
   if (!ssi->cursor)
     {
@@ -1200,22 +1428,63 @@ raise_window (saver_info *si,
     }
 }
 
+
+int
+mouse_screen (saver_info *si)
+{
+  saver_preferences *p = &si->prefs;
+
+  if (si->nscreens == 1)
+    return 0;
+  else
+    {
+      int i;
+      for (i = 0; i < si->nscreens; i++)
+        {
+          saver_screen_info *ssi = &si->screens[i];
+          Window pointer_root, pointer_child;
+          int root_x, root_y, win_x, win_y;
+          unsigned int mask;
+          if (XQueryPointer (si->dpy,
+                             RootWindowOfScreen (ssi->screen),
+                             &pointer_root, &pointer_child,
+                             &root_x, &root_y, &win_x, &win_y, &mask))
+            {
+              if (p->verbose_p)
+                fprintf (stderr, "%s: mouse is on screen %d\n",
+                         blurb(), i, si->nscreens);
+              return i;
+            }
+        }
+
+      /* couldn't figure out where the mouse is?  Oh well. */
+      return 0;
+    }
+}
+
+
 Bool
 blank_screen (saver_info *si)
 {
   int i;
   Bool ok;
+  Window w;
+  int mscreen;
 
   /* Note: we do our grabs on the root window, not on the screensaver window.
      If we grabbed on the saver window, then the demo mode and lock dialog
      boxes wouldn't get any events.
+
+     By "the root window", we mean "the root window that contains the mouse."
+     We use to always grab the mouse on screen 0, but that has the effect of
+     moving the mouse to screen 0 from whichever screen it was on, on
+     multi-head systems.
    */
-  ok = grab_keyboard_and_mouse (si,
-                                /*si->screens[0].screensaver_window,*/
-                                RootWindowOfScreen(si->screens[0].screen),
-                                (si->demoing_p
-                                 ? 0
-                                 : si->screens[0].cursor));
+  mscreen = mouse_screen (si);
+  w = RootWindowOfScreen(si->screens[mscreen].screen);
+  ok = grab_keyboard_and_mouse (si, w,
+                                (si->demoing_p ? 0 : si->screens[0].cursor),
+                                mscreen);
 
 
   if (si->using_mit_saver_extension || si->using_sgi_saver_extension)
@@ -1248,15 +1517,19 @@ blank_screen (saver_info *si)
       }
 #endif /* HAVE_XF86VMODE */
     }
-  store_activate_time (si, si->screen_blanked_p);
+
   raise_window (si, False, False, False);
 
   si->screen_blanked_p = True;
+  si->blank_time = time ((time_t) 0);
   si->last_wall_clock_time = 0;
 
+  store_saver_status (si);  /* store blank time */
+
   return True;
 }
 
+
 void
 unblank_screen (saver_info *si)
 {
@@ -1265,8 +1538,6 @@ unblank_screen (saver_info *si)
   int i;
 
   monitor_power_on (si);
-
-  store_activate_time (si, True);
   reset_watchdog_timer (si, False);
 
   if (si->demoing_p)
@@ -1360,8 +1631,7 @@ unblank_screen (saver_info *si)
       kill_xsetroot_data (si->dpy, ssi->screensaver_window, p->verbose_p);
     }
 
-  store_activate_time(si, False);  /* store unblank time */
-
+  store_saver_status (si);  /* store unblank time */
   ungrab_keyboard_and_mouse (si);
   restore_real_vroot (si);
 
@@ -1373,30 +1643,54 @@ unblank_screen (saver_info *si)
     XUnmapWindow (si->dpy, si->screens[i].screensaver_window);
 
   si->screen_blanked_p = False;
+  si->blank_time = time ((time_t) 0);
   si->last_wall_clock_time = 0;
+
+  store_saver_status (si);  /* store unblank time */
 }
 
 
+/* Transfer any grabs from the old window to the new.
+   Actually I think none of this is necessary, since we always
+   hold our grabs on the root window, but I wrote this before
+   re-discovering that...
+ */
 static void
-store_activate_time (saver_info *si, Bool use_last_p)
+maybe_transfer_grabs (saver_screen_info *ssi,
+                      Window old_w, Window new_w,
+                      int new_screen_no)
 {
-  static time_t last_time = 0;
-  time_t now = ((use_last_p && last_time) ? last_time : time ((time_t) 0));
-  CARD32 now32 = (CARD32) now;
-  int i;
-  last_time = now;
+  saver_info *si = ssi->global;
 
-  for (i = 0; i < si->nscreens; i++)
+  /* If the old window held our mouse grab, transfer the grab to the new
+     window.  (Grab the server while so doing, to avoid a race condition.)
+   */
+  if (old_w == si->mouse_grab_window)
     {
-      saver_screen_info *ssi = &si->screens[i];
-      if (!ssi->screensaver_window) continue;
-      XChangeProperty (si->dpy, ssi->screensaver_window, XA_SCREENSAVER_TIME,
-		       XA_INTEGER, 32, PropModeReplace,
-		       (unsigned char *) &now32, 1);
+      XGrabServer (si->dpy);		/* ############ DANGER! */
+      ungrab_mouse (si);
+      grab_mouse (si, ssi->screensaver_window,
+                  (si->demoing_p ? 0 : ssi->cursor),
+                  new_screen_no);
+      XUngrabServer (si->dpy);
+      XSync (si->dpy, False);		/* ###### (danger over) */
+    }
+
+  /* If the old window held our keyboard grab, transfer the grab to the new
+     window.  (Grab the server while so doing, to avoid a race condition.)
+   */
+  if (old_w == si->keyboard_grab_window)
+    {
+      XGrabServer (si->dpy);		/* ############ DANGER! */
+      ungrab_kbd(si);
+      grab_kbd(si, ssi->screensaver_window, ssi->number);
+      XUngrabServer (si->dpy);
+      XSync (si->dpy, False);		/* ###### (danger over) */
     }
 }
 
 
+
 Bool
 select_visual (saver_screen_info *ssi, const char *visual_name)
 {
@@ -1409,25 +1703,29 @@ select_visual (saver_screen_info *ssi, const char *visual_name)
 
   if (visual_name && *visual_name)
     {
-      if (!strcmp(visual_name, "default-i"))
+      if (!strcmp(visual_name, "default-i") ||
+          !strcmp(visual_name, "Default-i") ||
+          !strcmp(visual_name, "Default-I")
+          )
 	{
 	  visual_name = "default";
 	  install_cmap_p = True;
 	}
-      else if (!strcmp(visual_name, "default-n"))
+      else if (!strcmp(visual_name, "default-n") ||
+               !strcmp(visual_name, "Default-n") ||
+               !strcmp(visual_name, "Default-N"))
 	{
 	  visual_name = "default";
 	  install_cmap_p = False;
 	}
-#ifdef DAEMON_USE_GL
       else if (!strcmp(visual_name, "gl") ||
+               !strcmp(visual_name, "Gl") ||
                !strcmp(visual_name, "GL"))
         {
-          new_v = get_gl_visual (ssi->screen);
+          new_v = ssi->best_gl_visual;
           if (!new_v && p->verbose_p)
             fprintf (stderr, "%s: no GL visuals.\n", progname);
         }
-#endif /* DAEMON_USE_GL */
 
       if (!new_v)
         new_v = get_visual (ssi->screen, visual_name, True, False);
@@ -1454,10 +1752,10 @@ select_visual (saver_screen_info *ssi, const char *visual_name)
 
       if (p->verbose_p)
 	{
-	  fprintf (stderr, "%s: switching to visual ", blurb());
+	  fprintf (stderr, "%s: %d: visual ", blurb(), ssi->number);
 	  describe_visual (stderr, ssi->screen, new_v, install_cmap_p);
 #if 0
-	  fprintf (stderr, "%s:                from ", blurb());
+	  fprintf (stderr, "%s:                  from ", blurb());
 	  describe_visual (stderr, ssi->screen, ssi->current_visual,
 			   was_installed_p);
 #endif
@@ -1480,53 +1778,16 @@ select_visual (saver_screen_info *ssi, const char *visual_name)
       raise_window (si, True, True, False);
       store_vroot_property (si->dpy,
 			    ssi->screensaver_window, ssi->screensaver_window);
-      store_activate_time (si, True);
-
-
-
-      /* Transfer the grabs from the old window to the new.
-	 Actually I think none of this is necessary, since we always
-	 hold our grabs on the root window, but I wrote this before
-	 re-discovering that...
-       */
-
-
-      /* If we're destroying the window that holds our mouse grab,
-	 transfer the grab to the new window.  (Grab the server while
-	 so doing, to avoid a race condition.)
-       */
-      if (old_w == si->mouse_grab_window)
-	{
-	  XGrabServer (si->dpy);		/* ############ DANGER! */
-	  ungrab_mouse (si);
-	  grab_mouse (si, ssi->screensaver_window,
-		      (si->demoing_p
-		       ? 0
-		       : ssi->cursor));
-	  XUngrabServer (si->dpy);
-	  XSync (si->dpy, False);		/* ###### (danger over) */
-	}
-
-      /* If we're destroying the window that holds our keyboard grab,
-	 transfer the grab to the new window.  (Grab the server while
-	 so doing, to avoid a race condition.)
-       */
-      if (old_w == si->keyboard_grab_window)
-	{
-	  XGrabServer (si->dpy);		/* ############ DANGER! */
-	  ungrab_kbd(si);
-	  grab_kbd(si, ssi->screensaver_window);
-	  XUngrabServer (si->dpy);
-	  XSync (si->dpy, False);		/* ###### (danger over) */
-	}
 
-      /* Now we can destroy this window without horking our grabs. */
+      /* Transfer any grabs from the old window to the new. */
+      maybe_transfer_grabs (ssi, old_w, ssi->screensaver_window, ssi->number);
 
+      /* Now we can destroy the old window without horking our grabs. */
       XDestroyWindow (si->dpy, old_w);
 
       if (p->verbose_p)
-	fprintf (stderr, "%s: destroyed old saver window 0x%lx.\n",
-		 blurb(), (unsigned long) old_w);
+	fprintf (stderr, "%s: %d: destroyed old saver window 0x%lx.\n",
+		 blurb(), ssi->number, (unsigned long) old_w);
 
       if (old_c &&
 	  old_c != DefaultColormapOfScreen (ssi->screen) &&