-/* xscreensaver, Copyright (c) 1991-2003 Jamie Zawinski <jwz@jwz.org>
+/* xscreensaver, Copyright (c) 1991-2008 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
* via the $XSCREENSAVER_WINDOW environment variable -- this trick requires
* a recent (Aug 2003) revision of vroot.h.
*
+ * (See comments in screens.c for more details about Xinerama/RANDR stuff.)
+ *
* While we are waiting for user activity, we also set up timers so that,
* after a certain amount of time has passed, we can start a different
* screenhack. We do this by killing the running child process with
#include <time.h>
#include <sys/time.h>
#include <netdb.h> /* for gethostbyname() */
+#include <sys/types.h>
+#include <pwd.h>
#ifdef HAVE_XMU
# ifndef VMS
# include <X11/Xmu/Error.h>
#include "resources.h"
#include "visual.h"
#include "usleep.h"
+#include "auth.h"
saver_info *global_si_kludge = 0; /* I hate C so much... */
/* useful for debugging */
{ "-no-capture-stderr", ".captureStderr", XrmoptionNoArg, "off" },
-
- /* There's really no reason to have these command-line args; they just
- lead to confusion when the .xscreensaver file has conflicting values.
- */
-#if 0
- { "-splash", ".splash", XrmoptionNoArg, "on" },
- { "-capture-stderr", ".captureStderr", XrmoptionNoArg, "on" },
- { "-timeout", ".timeout", XrmoptionSepArg, 0 },
- { "-cycle", ".cycle", XrmoptionSepArg, 0 },
- { "-lock-mode", ".lock", XrmoptionNoArg, "on" },
- { "-no-lock-mode", ".lock", XrmoptionNoArg, "off" },
- { "-no-lock", ".lock", XrmoptionNoArg, "off" },
- { "-lock-timeout", ".lockTimeout", XrmoptionSepArg, 0 },
- { "-lock-vts", ".lockVTs", XrmoptionNoArg, "on" },
- { "-no-lock-vts", ".lockVTs", XrmoptionNoArg, "off" },
- { "-visual", ".visualID", XrmoptionSepArg, 0 },
- { "-install", ".installColormap", XrmoptionNoArg, "on" },
- { "-no-install", ".installColormap", XrmoptionNoArg, "off" },
- { "-timestamp", ".timestamp", XrmoptionNoArg, "on" },
- { "-xidle-extension", ".xidleExtension", XrmoptionNoArg, "on" },
- { "-no-xidle-extension", ".xidleExtension", XrmoptionNoArg, "off" },
- { "-mit-extension", ".mitSaverExtension",XrmoptionNoArg, "on" },
- { "-no-mit-extension", ".mitSaverExtension",XrmoptionNoArg, "off" },
- { "-sgi-extension", ".sgiSaverExtension",XrmoptionNoArg, "on" },
- { "-no-sgi-extension", ".sgiSaverExtension",XrmoptionNoArg, "off" },
- { "-proc-interrupts", ".procInterrupts", XrmoptionNoArg, "on" },
- { "-no-proc-interrupts", ".procInterrupts", XrmoptionNoArg, "off" },
- { "-idelay", ".initialDelay", XrmoptionSepArg, 0 },
- { "-nice", ".nice", XrmoptionSepArg, 0 },
-#endif /* 0 */
+ { "-log", ".logFile", XrmoptionSepArg, 0 },
};
#ifdef __GNUC__
fflush (stdout);
fflush (stderr);
fprintf (stdout, "\
-xscreensaver %s, copyright (c) 1991-2004 by Jamie Zawinski <jwz@jwz.org>\n\
+xscreensaver %s, copyright (c) 1991-2008 by Jamie Zawinski <jwz@jwz.org>\n\
\n\
All xscreensaver configuration is via the `~/.xscreensaver' file.\n\
Rather than editing that file by hand, just run `xscreensaver-demo':\n\
return str;
}
-static Bool blurb_timestamp_p = False; /* kludge */
+static Bool blurb_timestamp_p = True; /* kludge */
const char *
blurb (void)
}
else
{
+#ifdef __GNUC__
+ __extension__ /* don't warn about "string length is greater than the
+ length ISO C89 compilers are required to support". */
+#endif
fprintf (real_stderr,
- "#######################################"
- "#######################################\n\n");
- fprintf (real_stderr,
+ "#######################################################################\n"
+ "\n"
" If at all possible, please re-run xscreensaver with the command\n"
- " line arguments `-sync -verbose -no-capture', and reproduce this\n"
+ " line arguments `-sync -verbose -log log.txt', and reproduce this\n"
" bug. That will cause xscreensaver to dump a `core' file to the\n"
" current directory. Please include the stack trace from that core\n"
- " file in your bug report. *DO NOT* mail the core file itself!\n"
- " That won't work.\n");
- fprintf (real_stderr,
+ " file in your bug report. *DO NOT* mail the core file itself! That\n"
+ " won't work. A \"log.txt\" file will also be written. Please *do*\n"
+ " include the complete \"log.txt\" file with your bug report.\n"
"\n"
" http://www.jwz.org/xscreensaver/bugs.html explains how to create\n"
" the most useful bug reports, and how to examine core files.\n"
"\n"
" The more information you can provide, the better. But please\n"
" report this bug, regardless!\n"
+ "\n"
+ "#######################################################################\n"
+ "\n"
"\n");
- fprintf (real_stderr,
- "#######################################"
- "#######################################\n\n");
saver_exit (si, -1, 0);
}
with `xscreensaver-demo' or `xscreensaver-command'.\n\
. See the man pages for details, or check the web page:\n\
http://www.jwz.org/xscreensaver/\n\n");
-
- /* Since version 1.21 renamed the "-lock" option to "-lock-mode",
- suggest that explicitly. */
- if (!strcmp (s, "-lock"))
- fprintf (stderr, "\
- Or perhaps you meant either the \"-lock-mode\" or the\n\
- \"-lock-timeout <minutes>\" options to xscreensaver?\n\n");
}
exit (1);
whether to print the banner (and so that the banner gets printed before
any resource-database-related error messages.)
*/
- p->verbose_p = (p->debug_p || get_boolean_resource ("verbose", "Boolean"));
+ p->verbose_p = (p->debug_p ||
+ get_boolean_resource (si->dpy, "verbose", "Boolean"));
/* Ditto, for the locking_disabled_p message. */
- p->lock_p = get_boolean_resource ("lock", "Boolean");
+ p->lock_p = get_boolean_resource (si->dpy, "lock", "Boolean");
if (p->verbose_p)
fprintf (stderr,
- "%s %s, copyright (c) 1991-2004 "
+ "%s %s, copyright (c) 1991-2008 "
"by Jamie Zawinski <jwz@jwz.org>.\n",
progname, si->version);
}
+/* called from screens.c so that all the Xt crud is here. */
+void
+initialize_screen_root_widget (saver_screen_info *ssi)
+{
+ saver_info *si = ssi->global;
+ if (ssi->toplevel_shell)
+ XtDestroyWidget (ssi->toplevel_shell);
+ 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);
+}
+
+
/* 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)
- {
- XineramaScreenInfo *xsi = XineramaQueryScreens (si->dpy, &si->nscreens);
- if (!xsi)
- si->xinerama_p = False;
- else
- {
- si->screens = (saver_screen_info *)
- calloc(sizeof(saver_screen_info), si->nscreens);
- for (i = 0; i < si->nscreens; i++)
- {
- si->screens[i].x = xsi[i].x_org;
- si->screens[i].y = xsi[i].y_org;
- si->screens[i].width = xsi[i].width;
- si->screens[i].height = xsi[i].height;
- }
- XFree (xsi);
- }
- si->default_screen = &si->screens[0];
- si->default_screen->real_screen_p = True;
- }
-# endif /* !HAVE_XINERAMA */
+ update_screen_layout (si);
- 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;
- }
- }
-
-
- /* 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;
- }
-
- /* finish initializing the screens.
+ /* 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.
*/
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);
-
- if (!si->xinerama_p)
+ if (has_writable_cells (ssi->screen, ssi->current_visual) ||
+ get_visual (ssi->screen, "PseudoColor", True, False) ||
+ get_visual (ssi->screen, "GrayScale", True, False))
{
- ssi->width = WidthOfScreen (ssi->screen);
- ssi->height = HeightOfScreen (ssi->screen);
+ si->fading_possible_p = True;
+ break;
}
-
- /* 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
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;
- if (p->verbose_p)
- fprintf (stderr, "%s: Xinerama in use: disabling MIT-SCREEN-SAVER.\n",
- blurb());
- }
+#ifdef HAVE_RANDR
+ query_randr_extension (si);
+#endif
if (!system_has_proc_interrupts_p)
{
}
+#ifdef DEBUG_MULTISCREEN
+static void
+debug_multiscreen_timer (XtPointer closure, XtIntervalId *id)
+{
+ saver_info *si = (saver_info *) closure;
+ saver_preferences *p = &si->prefs;
+ if (update_screen_layout (si))
+ {
+ if (p->verbose_p)
+ {
+ fprintf (stderr, "%s: new layout:\n", blurb());
+ describe_monitor_layout (si);
+ }
+ resize_screensaver_window (si);
+ }
+ XtAppAddTimeOut (si->app, 1000*4, debug_multiscreen_timer, (XtPointer) si);
+}
+#endif /* DEBUG_MULTISCREEN */
+
+
/* For the case where we aren't using an server extensions, select user events
on all the existing windows, and launch timers to select events on
newly-created windows as well.
if (p->verbose_p)
fprintf (stderr, " done.\n");
+
+# ifdef DEBUG_MULTISCREEN
+ if (p->debug_p) debug_multiscreen_timer ((XtPointer) si, 0);
+# endif
}
fprintf (stderr, "%s: file \"%s\" has changed, reloading.\n",
blurb(), init_file_name());
- load_init_file (p);
+ load_init_file (si->dpy, p);
/* If a server extension is in use, and p->timeout has changed,
we need to inform the server of the new timeout. */
{
saver_preferences *p = &si->prefs;
Bool ok_to_unblank;
+ int i;
while (1)
{
/* Go around the loop and wait for the next bout of idleness,
or for the init file to change, or for a remote command to
come in, or something.
+
+ But, if locked_p is true, go ahead. This can only happen
+ if we're in "disabled" mode but a "lock" clientmessage came
+ in: in that case, we should go ahead and blank/lock the screen.
*/
- continue;
+ if (!si->locked_p)
+ continue;
}
+ /* Since we're about to blank the screen, kill the de-race timer,
+ if any. It might still be running if we have unblanked and then
+ re-blanked in a short period (e.g., when using the "next" button
+ in xscreensaver-demo.)
+ */
+ if (si->de_race_id)
+ {
+ if (p->verbose_p)
+ fprintf (stderr, "%s: stopping de-race timer (%d remaining.)\n",
+ blurb(), si->de_race_ticks);
+ XtRemoveTimeOut (si->de_race_id);
+ si->de_race_id = 0;
+ }
+
+
+ /* Now, try to blank.
+ */
+
if (! blank_screen (si))
{
/* We were unable to grab either the keyboard or mouse.
see any events, and the display would be wedged.
So, just go around the loop again and wait for the
- next bout of idleness.
+ next bout of idleness. (If the user remains idle, we
+ will next try to blank the screen again in no more than
+ 60 seconds.)
*/
+ Time retry = 60 * 1000;
+ if (p->timeout < retry)
+ retry = p->timeout;
- fprintf (stderr,
+ if (p->debug_p)
+ {
+ fprintf (stderr,
+ "%s: DEBUG MODE: unable to grab -- BLANKING ANYWAY.\n",
+ blurb());
+ }
+ else
+ {
+ fprintf (stderr,
"%s: unable to grab keyboard or mouse! Blanking aborted.\n",
- blurb());
- continue;
+ blurb());
+
+ schedule_wakeup_event (si, retry, p->debug_p);
+ continue;
+ }
}
- kill_screenhack (si);
+ for (i = 0; i < si->nscreens; i++)
+ kill_screenhack (&si->screens[i]);
- if (!si->throttled_p)
- spawn_screenhack (si, True);
- else if (p->verbose_p)
+ raise_window (si, True, True, False);
+ if (si->throttled_p)
fprintf (stderr, "%s: not launching hack (throttled.)\n", blurb());
+ else
+ for (i = 0; i < si->nscreens; i++)
+ spawn_screenhack (&si->screens[i]);
/* Don't start the cycle timer in demo mode. */
if (!si->demoing_p && p->cycle)
was_locked = True;
si->dbox_up_p = True;
- suspend_screenhack (si, True);
+ for (i = 0; i < si->nscreens; i++)
+ suspend_screenhack (&si->screens[i], True); /* suspend */
XUndefineCursor (si->dpy, ssi->screensaver_window);
ok_to_unblank = unlock_p (si);
si->dbox_up_p = False;
XDefineCursor (si->dpy, ssi->screensaver_window, ssi->cursor);
- suspend_screenhack (si, False); /* resume */
+ for (i = 0; i < si->nscreens; i++)
+ suspend_screenhack (&si->screens[i], False); /* resume */
if (!ok_to_unblank &&
!screenhack_running_p (si))
blurb(), timestring ());
/* Kill before unblanking, to stop drawing as soon as possible. */
- kill_screenhack (si);
+ for (i = 0; i < si->nscreens; i++)
+ kill_screenhack (&si->screens[i]);
unblank_screen (si);
set_locked_p (si, False);
si->lock_id = 0;
}
- /* It's possible that a race condition could have led to the saver
- window being unexpectedly still mapped. This can happen like so:
-
- - screen is blanked
- - hack is launched
- - that hack tries to grab a screen image (it does this by
- first unmapping the saver window, then remapping it.)
- - hack unmaps window
- - hack waits
- - user becomes active
- - hack re-maps window (*)
- - driver kills subprocess
- - driver unmaps window (**)
-
- The race is that (*) might have been sent to the server before
- the client process was killed, but, due to scheduling randomness,
- might not have been received by the server until after (**).
- In other words, (*) and (**) might happen out of order, meaning
- the driver will unmap the window, and then after that, the
- recently-dead client will re-map it. This leaves the user
- locked out (it looks like a desktop, but it's not!)
-
- To avoid this: after un-blanking the screen, sleep for a second,
- and then really make sure the window is unmapped.
-
- Update: actually, let's do that once a second for 8 seconds,
- because sometimes the machine is slow, and we miss...
- */
- {
- int i, j;
- for (j = 0; j < 8; j++)
- {
- XSync (si->dpy, False);
- sleep (1);
- for (i = 0; i < si->nscreens; i++)
- {
- saver_screen_info *ssi = &si->screens[i];
- Window w = ssi->screensaver_window;
- XWindowAttributes xgwa;
- XGetWindowAttributes (si->dpy, w, &xgwa);
- if (xgwa.map_state != IsUnmapped)
- {
- if (p->verbose_p)
- fprintf (stderr,
- "%s: %d: client race! emergency unmap 0x%lx.\n",
- blurb(), i, (unsigned long) w);
- XUnmapWindow (si->dpy, w);
- }
- }
- XSync (si->dpy, False);
- }
- }
+ /* Since we're unblanked now, break race conditions and make
+ sure we stay that way (see comment in timers.c.) */
+ if (! si->de_race_id)
+ de_race_timer ((XtPointer) si, 0);
}
}
saver_info the_si;
saver_info *si = &the_si;
saver_preferences *p = &si->prefs;
+ struct passwd *spasswd;
int i;
memset(si, 0, sizeof(*si));
privileged_initialization (si, &argc, argv);
hack_environment (si);
+ spasswd = getpwuid(getuid());
+ if (!spasswd)
+ {
+ fprintf(stderr, "Could not figure out who the current user is!\n");
+ return 1;
+ }
+
+ si->user = strdup(spasswd->pw_name ? spasswd->pw_name : "(unknown)");
+
+# ifndef NO_LOCKING
+ si->unlock_cb = gui_auth_conv;
+ si->auth_finished_cb = auth_finished_cb;
+# endif /* !NO_LOCKING */
+
shell = connect_to_server (si, &argc, argv);
process_command_line (si, &argc, argv);
+ stderr_log_file (si);
print_banner (si);
- load_init_file (p); /* must be before initialize_per_screen_info() */
+ load_init_file(si->dpy, p); /* must be before initialize_per_screen_info() */
blurb_timestamp_p = p->timestamp_p; /* kludge */
initialize_per_screen_info (si, shell); /* also sets si->fading_possible_p */
static void
bogus_clientmessage_warning (saver_info *si, XEvent *event)
{
+#if 0 /* Oh, fuck it. GNOME likes to spew random ClientMessages at us
+ all the time. This is presumably indicative of an error in
+ the sender of that ClientMessage: if we're getting it and
+ ignoring it, then it's not reaching the intended recipient.
+ But people complain to me about this all the time ("waaah!
+ xscreensaver is printing to it's stderr and that gets my
+ panties all in a bunch!") And I'm sick of hearing about it.
+ So we'll just ignore these messages and let GNOME go right
+ ahead and continue to stumble along in its malfunction.
+ */
+
+ saver_preferences *p = &si->prefs;
char *str = XGetAtomName_safe (si->dpy, event->xclient.message_type);
Window w = event->xclient.window;
char wdesc[255];
int screen = 0;
+ Bool root_p = False;
*wdesc = 0;
for (screen = 0; screen < si->nscreens; screen++)
else if (w == RootWindow (si->dpy, screen))
{
strcpy (wdesc, "root");
+ root_p = True;
break;
}
+ /* If this ClientMessage was sent to the real root window instead of to the
+ xscreensaver window, then it might be intended for someone else who is
+ listening on the root window (e.g., the window manager). So only print
+ the warning if: we are in debug mode; or if the bogus message was
+ actually sent to one of the xscreensaver-created windows.
+ */
+ if (root_p && !p->debug_p)
+ return;
+
if (!*wdesc)
{
XErrorHandler old_handler;
fprintf (stderr, "%s: %d: for window 0x%lx (%s)\n",
blurb(), screen, (unsigned long) w, wdesc);
if (str) XFree (str);
+
+#endif /* 0 */
}
+
Bool
handle_clientmessage (saver_info *si, XEvent *event, Bool until_idle_p)
{
"exiting.");
if (! until_idle_p)
{
+ int i;
+ for (i = 0; i < si->nscreens; i++)
+ kill_screenhack (&si->screens[i]);
unblank_screen (si);
- kill_screenhack (si);
XSync (si->dpy, False);
}
saver_exit (si, 0, 0);
"restarting.");
if (! until_idle_p)
{
+ int i;
+ for (i = 0; i < si->nscreens; i++)
+ kill_screenhack (&si->screens[i]);
unblank_screen (si);
- kill_screenhack (si);
XSync (si->dpy, False);
}
else if (type == XA_DEMO)
{
long arg = event->xclient.data.l[1];
- Bool demo_one_hack_p = (arg == 300);
+ Bool demo_one_hack_p = (arg == 5000);
if (demo_one_hack_p)
{
"not compiled with support for locking.",
"locking not enabled.");
#else /* !NO_LOCKING */
- if (p->mode == DONT_BLANK)
- clientmessage_response(si, window, True,
- "LOCK ClientMessage received in DONT_BLANK mode.",
- "screen blanking is currently disabled.");
- else if (si->locking_disabled_p)
+ if (si->locking_disabled_p)
clientmessage_response (si, window, True,
"LOCK ClientMessage received, but locking is disabled.",
"locking not enabled.");
}
else if (type == XA_THROTTLE)
{
+ /* The THROTTLE command is deprecated -- it predates the XDPMS
+ extension. Instead of using -throttle, users should instead
+ just power off the monitor (e.g., "xset dpms force off".)
+ In a few minutes, xscreensaver will notice that the monitor
+ is off, and cease running hacks.
+ */
if (si->throttled_p)
clientmessage_response (si, window, True,
"THROTTLE ClientMessage received, but "
False
# endif
}, { "XINERAMA", "Xinerama",
+# ifdef HAVE_XINERAMA
+ True
+# else
+ False
+# endif
+ }, { "RANDR", "Resize-and-Rotate",
+# ifdef HAVE_RANDR
+ True
+# else
+ False
+# endif
+ }, { "DRI", "DRI",
True
}, { "Apple-DRI", "Apple-DRI (XDarwin)",
True
},
};
- fprintf (stderr, "%s: running on display \"%s\" (%d %sscreen%s).\n",
- blurb(),
- DisplayString(si->dpy),
- si->nscreens,
- (si->xinerama_p ? "Xinerama " : ""),
- (si->nscreens == 1 ? "" : "s"));
+ fprintf (stderr, "%s: running on display \"%s\"\n", blurb(),
+ DisplayString(si->dpy));
fprintf (stderr, "%s: vendor is %s, %d.\n", blurb(),
ServerVendor(si->dpy), VendorRelease(si->dpy));
j = strlen (buf);
strcat (buf, exts[i].desc);
if (!exts[i].useful_p)
- {
- int k = j + 18;
- while (strlen (buf) < k) strcat (buf, " ");
- strcat (buf, "<-- not supported at compile time!");
- }
+ strcat (buf, " (disabled at compile time)");
fprintf (stderr, "%s\n", buf);
}
}
}
- if (si->xinerama_p)
- {
- fprintf (stderr, "%s: Xinerama layout:\n", blurb());
- for (i = 0; i < si->nscreens; i++)
- {
- saver_screen_info *ssi = &si->screens[i];
- fprintf (stderr, "%s: %c %d/%d: %dx%d+%d+%d\n",
- blurb(),
- (ssi->real_screen_p ? '+' : ' '),
- ssi->number, ssi->real_screen_number,
- ssi->width, ssi->height, ssi->x, ssi->y);
- }
- }
+ describe_monitor_layout (si);
}
+
Bool
display_is_on_console_p (saver_info *si)
{
not_on_console = False;
else if (gethostname (localname, sizeof (localname)))
not_on_console = True; /* can't find hostname? */
+ else if (!strncmp (dpyname, "/tmp/launch-", 12)) /* MacOS X launchd */
+ not_on_console = False;
else
{
/* We have to call gethostbyname() on the result of gethostname()
void
check_for_leaks (const char *where)
{
-#ifdef HAVE_SBRK
+#if defined(HAVE_SBRK) && defined(LEAK_PARANOIA)
static unsigned long last_brk = 0;
int b = (unsigned long) sbrk(0);
if (last_brk && last_brk < b)
projects / xscreensaver / blobdiff