+ if (*err) WHINE();
+ }
+
+# undef X1
+# undef X2
+# undef Y1
+# undef Y2
+# undef W1
+# undef W2
+# undef H1
+# undef H2
+}
+
+#endif /* HAVE_XINERAMA */
+
+
+
+/* Examine all of the display's screens, and populate the `saver_screen_info'
+ structures. Make sure this is called after hack_environment() sets $PATH.
+ */
+static void
+initialize_per_screen_info (saver_info *si, Widget toplevel_shell)
+{
+ Bool found_any_writable_cells = False;
+ int i;
+
+# ifdef HAVE_XINERAMA
+ {
+ int event, error;
+ si->xinerama_p = (XineramaQueryExtension (si->dpy, &event, &error) &&
+ XineramaIsActive (si->dpy));
+ }
+
+ if (si->xinerama_p && ScreenCount (si->dpy) != 1)
+ {
+ si->xinerama_p = False;
+ if (si->prefs.verbose_p)
+ fprintf (stderr,
+ "%s: Xinerama AND %d screens? Disabling Xinerama support!\n",
+ blurb(), ScreenCount(si->dpy));
+ }
+
+ if (si->xinerama_p)
+ {
+ int nscreens = 0;
+ XineramaScreenInfo *xsi = XineramaQueryScreens (si->dpy, &nscreens);
+ if (!xsi)
+ si->xinerama_p = False;
+ else
+ {
+ int j = 0;
+ si->screens = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), nscreens);
+ check_xinerama_sanity (nscreens, si->prefs.verbose_p, xsi);
+ for (i = 0; i < nscreens; i++)
+ {
+ if (xsi[i].screen_number < 0) /* deemed insane */
+ continue;
+ si->screens[j].x = xsi[i].x_org;
+ si->screens[j].y = xsi[i].y_org;
+ si->screens[j].width = xsi[i].width;
+ si->screens[j].height = xsi[i].height;
+ j++;
+ }
+ si->nscreens = j;
+ XFree (xsi);
+ }
+ si->default_screen = &si->screens[0];
+ si->default_screen->real_screen_p = True;
+ }
+# endif /* !HAVE_XINERAMA */
+
+ if (!si->xinerama_p)
+ {
+ si->nscreens = ScreenCount(si->dpy);
+ si->screens = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), si->nscreens);
+ si->default_screen = &si->screens[DefaultScreen(si->dpy)];
+
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ ssi->width = DisplayWidth (si->dpy, i);
+ ssi->height = DisplayHeight (si->dpy, i);
+ ssi->real_screen_p = True;
+ ssi->real_screen_number = i;
+ }
+ }
+
+
+# ifdef QUAD_MODE
+ /* In "quad mode", we use the Xinerama code to pretend that there are 4
+ screens for every physical screen, and run four times as many hacks...
+ */
+ if (si->prefs.quad_p)
+ {
+ int ns2 = si->nscreens * 4;
+ saver_screen_info *ssi2 = (saver_screen_info *)
+ calloc(sizeof(saver_screen_info), ns2);
+
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *old = &si->screens[i];
+
+ if (si->prefs.debug_p) old->width = old->width / 2;
+
+ ssi2[i*4 ] = *old;
+ ssi2[i*4+1] = *old;
+ ssi2[i*4+2] = *old;
+ ssi2[i*4+3] = *old;
+
+ ssi2[i*4 ].width /= 2;
+ ssi2[i*4 ].height /= 2;
+
+ ssi2[i*4+1].x += ssi2[i*4 ].width;
+ ssi2[i*4+1].width -= ssi2[i*4 ].width;
+ ssi2[i*4+1].height /= 2;
+
+ ssi2[i*4+2].y += ssi2[i*4 ].height;
+ ssi2[i*4+2].width /= 2;
+ ssi2[i*4+2].height -= ssi2[i*4 ].height;
+
+ ssi2[i*4+3].x += ssi2[i*4+2].width;
+ ssi2[i*4+3].y += ssi2[i*4+2].height;
+ ssi2[i*4+3].width -= ssi2[i*4+2].width;
+ ssi2[i*4+3].height -= ssi2[i*4+2].height;
+
+ ssi2[i*4+1].real_screen_p = False;
+ ssi2[i*4+2].real_screen_p = False;
+ ssi2[i*4+3].real_screen_p = False;
+ }
+
+ si->nscreens = ns2;
+ free (si->screens);
+ si->screens = ssi2;
+ si->default_screen = &si->screens[DefaultScreen(si->dpy) * 4];
+ si->xinerama_p = True;
+ }
+# endif /* QUAD_MODE */
+
+ /* finish initializing the screens.
+ */
+ for (i = 0; i < si->nscreens; i++)
+ {
+ saver_screen_info *ssi = &si->screens[i];
+ ssi->global = si;
+
+ ssi->number = i;
+ ssi->screen = ScreenOfDisplay (si->dpy, ssi->real_screen_number);
+ ssi->poll_mouse_last_root_x = -1;
+ ssi->poll_mouse_last_root_y = -1;
+
+ if (!si->xinerama_p)
+ {
+ ssi->width = WidthOfScreen (ssi->screen);
+ ssi->height = HeightOfScreen (ssi->screen);
+ }
+
+ /* Note: we can't use the resource ".visual" because Xt is SO FUCKED. */
+ ssi->default_visual =
+ get_visual_resource (ssi->screen, "visualID", "VisualID", False);
+
+ ssi->current_visual = ssi->default_visual;
+ ssi->current_depth = visual_depth (ssi->screen, ssi->current_visual);
+
+ /* Execute a subprocess to find the GL visual. */
+ ssi->best_gl_visual = get_best_gl_visual (ssi);
+
+ if (ssi == si->default_screen)
+ /* Since this is the default screen, use the one already created. */
+ ssi->toplevel_shell = toplevel_shell;
+ else
+ /* Otherwise, each screen must have its own unmapped root widget. */
+ ssi->toplevel_shell =
+ XtVaAppCreateShell (progname, progclass, applicationShellWidgetClass,
+ si->dpy,
+ XtNscreen, ssi->screen,
+ XtNvisual, ssi->current_visual,
+ XtNdepth, visual_depth (ssi->screen,
+ ssi->current_visual),
+ NULL);
+
+ if (! found_any_writable_cells)
+ {
+ /* Check to see whether fading is ever possible -- if any of the
+ screens on the display has a PseudoColor visual, then fading can
+ work (on at least some screens.) If no screen has a PseudoColor
+ visual, then don't bother ever trying to fade, because it will
+ just cause a delay without causing any visible effect.
+ */
+ if (has_writable_cells (ssi->screen, ssi->current_visual) ||
+ get_visual (ssi->screen, "PseudoColor", True, False) ||
+ get_visual (ssi->screen, "GrayScale", True, False))
+ found_any_writable_cells = True;
+ }
+ }
+
+ si->fading_possible_p = found_any_writable_cells;
+
+#ifdef HAVE_XF86VMODE_GAMMA
+ si->fading_possible_p = True; /* if we can gamma fade, go for it */
+#endif
+}
+
+
+/* If any server extensions have been requested, try and initialize them.
+ Issue warnings if requests can't be honored.
+ */
+static void
+initialize_server_extensions (saver_info *si)
+{
+ saver_preferences *p = &si->prefs;
+
+ Bool server_has_xidle_extension_p = False;
+ Bool server_has_sgi_saver_extension_p = False;
+ Bool server_has_mit_saver_extension_p = False;
+ Bool system_has_proc_interrupts_p = False;
+ const char *piwhy = 0;
+
+ si->using_xidle_extension = p->use_xidle_extension;
+ si->using_sgi_saver_extension = p->use_sgi_saver_extension;
+ si->using_mit_saver_extension = p->use_mit_saver_extension;
+ si->using_proc_interrupts = p->use_proc_interrupts;
+
+#ifdef HAVE_XIDLE_EXTENSION
+ server_has_xidle_extension_p = query_xidle_extension (si);
+#endif
+#ifdef HAVE_SGI_SAVER_EXTENSION
+ server_has_sgi_saver_extension_p = query_sgi_saver_extension (si);
+#endif
+#ifdef HAVE_MIT_SAVER_EXTENSION
+ server_has_mit_saver_extension_p = query_mit_saver_extension (si);
+#endif
+#ifdef HAVE_PROC_INTERRUPTS
+ system_has_proc_interrupts_p = query_proc_interrupts_available (si, &piwhy);
+#endif
+
+ if (!server_has_xidle_extension_p)
+ si->using_xidle_extension = False;
+ else if (p->verbose_p)
+ {
+ if (si->using_xidle_extension)
+ fprintf (stderr, "%s: using XIDLE extension.\n", blurb());
+ else
+ fprintf (stderr, "%s: not using server's XIDLE extension.\n", blurb());
+ }
+
+ if (!server_has_sgi_saver_extension_p)
+ si->using_sgi_saver_extension = False;
+ else if (p->verbose_p)
+ {
+ if (si->using_sgi_saver_extension)
+ fprintf (stderr, "%s: using SGI SCREEN_SAVER extension.\n", blurb());
+ else
+ fprintf (stderr,
+ "%s: not using server's SGI SCREEN_SAVER extension.\n",
+ blurb());
+ }
+
+ if (!server_has_mit_saver_extension_p)
+ si->using_mit_saver_extension = False;
+ else if (p->verbose_p)
+ {
+ if (si->using_mit_saver_extension)
+ fprintf (stderr, "%s: using lame MIT-SCREEN-SAVER extension.\n",
+ blurb());
+ else
+ fprintf (stderr,
+ "%s: not using server's lame MIT-SCREEN-SAVER extension.\n",
+ blurb());
+ }
+
+ /* These are incompatible (or at least, our support for them is...) */
+ if (si->xinerama_p && si->using_mit_saver_extension)
+ {
+ si->using_mit_saver_extension = False;