1 /* timers.c --- detecting when the user is idle, and other timer-related tasks.
2 * xscreensaver, Copyright (c) 1991-2004 Jamie Zawinski <jwz@jwz.org>
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation. No representations are made about the suitability of this
9 * software for any purpose. It is provided "as is" without express or
19 #include <X11/Intrinsic.h>
25 # include <X11/Xmu/Error.h>
27 # include <Xmu/Error.h>
29 # else /* !HAVE_XMU */
31 #endif /* !HAVE_XMU */
33 #ifdef HAVE_XIDLE_EXTENSION
34 #include <X11/extensions/xidle.h>
35 #endif /* HAVE_XIDLE_EXTENSION */
37 #ifdef HAVE_MIT_SAVER_EXTENSION
38 #include <X11/extensions/scrnsaver.h>
39 #endif /* HAVE_MIT_SAVER_EXTENSION */
41 #ifdef HAVE_SGI_SAVER_EXTENSION
42 #include <X11/extensions/XScreenSaver.h>
43 #endif /* HAVE_SGI_SAVER_EXTENSION */
46 #include <X11/extensions/Xrandr.h>
47 #endif /* HAVE_RANDR */
49 #include "xscreensaver.h"
52 #define ABS(x)((x)<0?-(x):(x))
55 #define MAX(x,y)((x)>(y)?(x):(y))
58 #ifdef HAVE_PROC_INTERRUPTS
59 static Bool proc_interrupts_activity_p (saver_info *si);
60 #endif /* HAVE_PROC_INTERRUPTS */
62 static void check_for_clock_skew (saver_info *si);
66 idle_timer (XtPointer closure, XtIntervalId *id)
68 saver_info *si = (saver_info *) closure;
70 /* What an amazingly shitty design. Not only does Xt execute timeout
71 events from XtAppNextEvent() instead of from XtDispatchEvent(), but
72 there is no way to tell Xt to block until there is an X event OR a
73 timeout happens. Once your timeout proc is called, XtAppNextEvent()
74 still won't return until a "real" X event comes in.
76 So this function pushes a stupid, gratuitous, unnecessary event back
77 on the event queue to force XtAppNextEvent to return Right Fucking Now.
78 When the code in sleep_until_idle() sees an event of type XAnyEvent,
79 which the server never generates, it knows that a timeout has occurred.
82 fake_event.type = 0; /* XAnyEvent type, ignored. */
83 fake_event.xany.display = si->dpy;
84 fake_event.xany.window = 0;
85 XPutBackEvent (si->dpy, &fake_event);
87 /* If we are the timer that just went off, clear the pointer to the id. */
90 if (si->timer_id && *id != si->timer_id)
91 abort(); /* oops, scheduled timer twice?? */
98 schedule_wakeup_event (saver_info *si, Time when, Bool verbose_p)
103 fprintf (stderr, "%s: idle_timer already running\n", blurb());
107 /* Wake up periodically to ask the server if we are idle. */
108 si->timer_id = XtAppAddTimeOut (si->app, when, idle_timer,
112 fprintf (stderr, "%s: starting idle_timer (%ld, %ld)\n",
113 blurb(), when, si->timer_id);
118 notice_events (saver_info *si, Window window, Bool top_p)
120 saver_preferences *p = &si->prefs;
121 XWindowAttributes attrs;
122 unsigned long events;
123 Window root, parent, *kids;
127 if (XtWindowToWidget (si->dpy, window))
128 /* If it's one of ours, don't mess up its event mask. */
131 if (!XQueryTree (si->dpy, window, &root, &parent, &kids, &nkids))
136 /* Figure out which screen this window is on, for the diagnostics. */
137 for (screen_no = 0; screen_no < si->nscreens; screen_no++)
138 if (root == RootWindowOfScreen (si->screens[screen_no].screen))
141 XGetWindowAttributes (si->dpy, window, &attrs);
142 events = ((attrs.all_event_masks | attrs.do_not_propagate_mask)
145 /* Select for SubstructureNotify on all windows.
146 Select for KeyPress on all windows that already have it selected.
148 Note that we can't select for ButtonPress, because of X braindamage:
149 only one client at a time may select for ButtonPress on a given
150 window, though any number can select for KeyPress. Someone explain
153 So, if the user spends a while clicking the mouse without ever moving
154 the mouse or touching the keyboard, we won't know that they've been
155 active, and the screensaver will come on. That sucks, but I don't
156 know how to get around it.
158 Since X presents mouse wheels as clicks, this applies to those, too:
159 scrolling through a document using only the mouse wheel doesn't
160 count as activity... Fortunately, /proc/interrupts helps, on
161 systems that have it. Oh, if it's a PS/2 mouse, not serial or USB.
164 XSelectInput (si->dpy, window, SubstructureNotifyMask | events);
166 if (top_p && p->debug_p && (events & KeyPressMask))
168 /* Only mention one window per tree (hack hack). */
169 fprintf (stderr, "%s: %d: selected KeyPress on 0x%lX\n",
170 blurb(), screen_no, (unsigned long) window);
177 notice_events (si, kids [--nkids], top_p);
178 XFree ((char *) kids);
184 BadWindow_ehandler (Display *dpy, XErrorEvent *error)
186 /* When we notice a window being created, we spawn a timer that waits
187 30 seconds or so, and then selects events on that window. This error
188 handler is used so that we can cope with the fact that the window
189 may have been destroyed <30 seconds after it was created.
191 if (error->error_code == BadWindow ||
192 error->error_code == BadMatch ||
193 error->error_code == BadDrawable)
196 return saver_ehandler (dpy, error);
200 struct notice_events_timer_arg {
206 notice_events_timer (XtPointer closure, XtIntervalId *id)
208 struct notice_events_timer_arg *arg =
209 (struct notice_events_timer_arg *) closure;
211 XErrorHandler old_handler = XSetErrorHandler (BadWindow_ehandler);
213 saver_info *si = arg->si;
214 Window window = arg->w;
217 notice_events (si, window, True);
218 XSync (si->dpy, False);
219 XSetErrorHandler (old_handler);
223 start_notice_events_timer (saver_info *si, Window w, Bool verbose_p)
225 saver_preferences *p = &si->prefs;
226 struct notice_events_timer_arg *arg =
227 (struct notice_events_timer_arg *) malloc(sizeof(*arg));
230 XtAppAddTimeOut (si->app, p->notice_events_timeout, notice_events_timer,
234 fprintf (stderr, "%s: starting notice_events_timer for 0x%X (%lu)\n",
235 blurb(), (unsigned int) w, p->notice_events_timeout);
239 /* When the screensaver is active, this timer will periodically change
243 cycle_timer (XtPointer closure, XtIntervalId *id)
245 saver_info *si = (saver_info *) closure;
246 saver_preferences *p = &si->prefs;
247 Time how_long = p->cycle;
249 if (si->selection_mode > 0 &&
250 screenhack_running_p (si))
251 /* If we're in "SELECT n" mode, the cycle timer going off will just
252 restart this same hack again. There's not much point in doing this
253 every 5 or 10 minutes, but on the other hand, leaving one hack running
254 for days is probably not a great idea, since they tend to leak and/or
255 crash. So, restart the thing once an hour. */
256 how_long = 1000 * 60 * 60;
261 fprintf (stderr, "%s: dialog box up; delaying hack change.\n",
263 how_long = 30000; /* 30 secs */
267 maybe_reload_init_file (si);
268 kill_screenhack (si);
270 if (!si->throttled_p)
271 spawn_screenhack (si, False);
274 raise_window (si, True, True, False);
276 fprintf (stderr, "%s: not launching new hack (throttled.)\n",
283 si->cycle_id = XtAppAddTimeOut (si->app, how_long, cycle_timer,
287 fprintf (stderr, "%s: starting cycle_timer (%ld, %ld)\n",
288 blurb(), how_long, si->cycle_id);
293 fprintf (stderr, "%s: not starting cycle_timer: how_long == %ld\n",
294 blurb(), (unsigned long) how_long);
300 activate_lock_timer (XtPointer closure, XtIntervalId *id)
302 saver_info *si = (saver_info *) closure;
303 saver_preferences *p = &si->prefs;
306 fprintf (stderr, "%s: timed out; activating lock.\n", blurb());
307 set_locked_p (si, True);
311 /* Call this when user activity (or "simulated" activity) has been noticed.
314 reset_timers (saver_info *si)
316 saver_preferences *p = &si->prefs;
317 if (si->using_mit_saver_extension || si->using_sgi_saver_extension)
323 fprintf (stderr, "%s: killing idle_timer (%ld, %ld)\n",
324 blurb(), p->timeout, si->timer_id);
325 XtRemoveTimeOut (si->timer_id);
329 schedule_wakeup_event (si, p->timeout, p->debug_p); /* sets si->timer_id */
331 if (si->cycle_id) abort (); /* no cycle timer when inactive */
333 si->last_activity_time = time ((time_t *) 0);
335 /* This will (hopefully, supposedly) tell the server to re-set its
336 DPMS timer. Without this, the -deactivate clientmessage would
337 prevent xscreensaver from blanking, but would not prevent the
338 monitor from powering down. */
340 /* #### With some servers, this causes the screen to flicker every
341 time a key is pressed! Ok, I surrender. I give up on ever
342 having DPMS work properly.
344 XForceScreenSaver (si->dpy, ScreenSaverReset);
346 /* And if the monitor is already powered off, turn it on.
347 You'd think the above would do that, but apparently not? */
348 monitor_power_on (si);
354 /* Returns true if the mouse has moved since the last time we checked.
355 Small motions (of less than "hysteresis" pixels/second) are ignored.
358 pointer_moved_p (saver_screen_info *ssi, Bool mods_p)
360 saver_info *si = ssi->global;
361 saver_preferences *p = &si->prefs;
364 int root_x, root_y, x, y;
366 time_t now = time ((time_t *) 0);
367 unsigned int distance, dps;
368 unsigned long seconds = 0;
369 Bool moved_p = False;
371 /* don't check xinerama pseudo-screens. */
372 if (!ssi->real_screen_p) return False;
374 if (!XQueryPointer (si->dpy, ssi->screensaver_window, &root, &child,
375 &root_x, &root_y, &x, &y, &mask))
377 /* If XQueryPointer() returns false, the mouse is not on this screen.
385 distance = MAX (ABS (ssi->poll_mouse_last_root_x - root_x),
386 ABS (ssi->poll_mouse_last_root_y - root_y));
387 seconds = (now - ssi->poll_mouse_last_time);
390 /* When the screen is blanked, we get MotionNotify events, but when not
391 blanked, we poll only every 5 seconds, and that's not enough resolution
392 to do hysteresis based on a 1 second interval. So, assume that any
393 motion we've seen during the 5 seconds when our eyes were closed happened
394 in the last 1 second instead.
396 if (seconds > 1) seconds = 1;
398 dps = (seconds <= 0 ? distance : (distance / seconds));
400 /* Motion only counts if the rate is more than N pixels per second.
402 if (dps >= p->pointer_hysteresis &&
406 /* If the mouse is not on this screen but used to be, that's motion.
407 If the mouse was not on this screen, but is now, that's motion.
410 Bool on_screen_p = (root_x != -1 && root_y != -1);
411 Bool was_on_screen_p = (ssi->poll_mouse_last_root_x != -1 &&
412 ssi->poll_mouse_last_root_y != -1);
414 if (on_screen_p != was_on_screen_p)
418 if (p->debug_p && (distance != 0 || moved_p))
420 fprintf (stderr, "%s: %d: pointer %s", blurb(), ssi->number,
421 (moved_p ? "moved: " : "ignored:"));
422 if (ssi->poll_mouse_last_root_x == -1)
423 fprintf (stderr, "off screen");
425 fprintf (stderr, "%d,%d",
426 ssi->poll_mouse_last_root_x,
427 ssi->poll_mouse_last_root_y);
428 fprintf (stderr, " -> ");
430 fprintf (stderr, "off screen");
432 fprintf (stderr, "%d,%d", root_x, root_y);
433 if (ssi->poll_mouse_last_root_x != -1 && root_x != -1)
434 fprintf (stderr, " (%d,%d; %d/%lu=%d)",
435 ABS(ssi->poll_mouse_last_root_x - root_x),
436 ABS(ssi->poll_mouse_last_root_y - root_y),
437 distance, seconds, dps);
439 fprintf (stderr, ".\n");
444 mask != ssi->poll_mouse_last_mask)
449 fprintf (stderr, "%s: %d: modifiers changed: 0x%04x -> 0x%04x.\n",
450 blurb(), ssi->number, ssi->poll_mouse_last_mask, mask);
453 si->last_activity_screen = ssi;
454 ssi->poll_mouse_last_child = child;
455 ssi->poll_mouse_last_mask = mask;
457 if (moved_p || seconds > 0)
459 ssi->poll_mouse_last_time = now;
460 ssi->poll_mouse_last_root_x = root_x;
461 ssi->poll_mouse_last_root_y = root_y;
468 /* When we aren't using a server extension, this timer is used to periodically
469 wake up and poll the mouse position, which is possibly more reliable than
470 selecting motion events on every window.
473 check_pointer_timer (XtPointer closure, XtIntervalId *id)
476 saver_info *si = (saver_info *) closure;
477 saver_preferences *p = &si->prefs;
478 Bool active_p = False;
480 if (!si->using_proc_interrupts &&
481 (si->using_xidle_extension ||
482 si->using_mit_saver_extension ||
483 si->using_sgi_saver_extension))
484 /* If an extension is in use, we should not be polling the mouse.
485 Unless we're also checking /proc/interrupts, in which case, we should.
489 if (id && *id == si->check_pointer_timer_id) /* this is us - it's expired */
490 si->check_pointer_timer_id = 0;
492 if (si->check_pointer_timer_id) /* only queue one at a time */
493 XtRemoveTimeOut (si->check_pointer_timer_id);
495 si->check_pointer_timer_id = /* now re-queue */
496 XtAppAddTimeOut (si->app, p->pointer_timeout, check_pointer_timer,
499 for (i = 0; i < si->nscreens; i++)
501 saver_screen_info *ssi = &si->screens[i];
502 if (pointer_moved_p (ssi, True))
506 #ifdef HAVE_PROC_INTERRUPTS
508 si->using_proc_interrupts &&
509 proc_interrupts_activity_p (si))
513 #endif /* HAVE_PROC_INTERRUPTS */
518 check_for_clock_skew (si);
522 /* An unfortunate situation is this: the saver is not active, because the
523 user has been typing. The machine is a laptop. The user closes the lid
524 and suspends it. The CPU halts. Some hours later, the user opens the
525 lid. At this point, Xt's timers will fire, and xscreensaver will blank
528 So far so good -- well, not really, but it's the best that we can do,
529 since the OS doesn't send us a signal *before* shutdown -- but if the
530 user had delayed locking (lockTimeout > 0) then we should start off
531 in the locked state, rather than only locking N minutes from when the
532 lid was opened. Also, eschewing fading is probably a good idea, to
533 clamp down as soon as possible.
535 We only do this when we'd be polling the mouse position anyway.
536 This amounts to an assumption that machines with APM support also
537 have /proc/interrupts.
540 check_for_clock_skew (saver_info *si)
542 saver_preferences *p = &si->prefs;
543 time_t now = time ((time_t *) 0);
544 long shift = now - si->last_wall_clock_time;
548 int i = (si->last_wall_clock_time == 0 ? 0 : shift);
550 "%s: checking wall clock for hibernation (%d:%02d:%02d).\n",
552 (i / (60 * 60)), ((i / 60) % 60), (i % 60));
555 if (si->last_wall_clock_time != 0 &&
556 shift > (p->timeout / 1000))
559 fprintf (stderr, "%s: wall clock has jumped by %ld:%02ld:%02ld!\n",
561 (shift / (60 * 60)), ((shift / 60) % 60), (shift % 60));
563 si->emergency_lock_p = True;
564 idle_timer ((XtPointer) si, 0);
567 si->last_wall_clock_time = now;
573 dispatch_event (saver_info *si, XEvent *event)
575 /* If this is for the splash dialog, pass it along.
576 Note that the password dialog is handled with its own event loop,
577 so events for that window will never come through here.
579 if (si->splash_dialog && event->xany.window == si->splash_dialog)
580 handle_splash_event (si, event);
582 XtDispatchEvent (event);
587 swallow_unlock_typeahead_events (saver_info *si, XEvent *e)
593 memset (buf, 0, sizeof(buf));
599 if (event.xany.type == KeyPress)
602 int size = XLookupString ((XKeyEvent *) &event, s, 1, 0, 0);
603 if (size != 1) continue;
606 case '\010': case '\177': /* Backspace */
609 case '\025': case '\030': /* Erase line */
610 case '\012': case '\015': /* Enter */
613 case '\040': /* Space */
615 break; /* ignore space at beginning of line */
616 /* else, fall through */
623 } while (i < sizeof(buf)-1 &&
624 XCheckMaskEvent (si->dpy, KeyPressMask, &event));
628 if (si->unlock_typeahead)
630 memset (si->unlock_typeahead, 0, strlen(si->unlock_typeahead));
631 free (si->unlock_typeahead);
635 si->unlock_typeahead = strdup (buf);
637 si->unlock_typeahead = 0;
639 memset (buf, 0, sizeof(buf));
643 /* methods of detecting idleness:
645 explicitly informed by SGI SCREEN_SAVER server event;
646 explicitly informed by MIT-SCREEN-SAVER server event;
647 poll server idle time with XIDLE extension;
648 select events on all windows, and note absence of recent events;
649 note that /proc/interrupts has not changed in a while;
650 activated by clientmessage.
652 methods of detecting non-idleness:
654 read events on the xscreensaver window;
655 explicitly informed by SGI SCREEN_SAVER server event;
656 explicitly informed by MIT-SCREEN-SAVER server event;
657 select events on all windows, and note events on any of them;
658 note that /proc/interrupts has changed;
659 deactivated by clientmessage.
661 I trust that explains why this function is a big hairy mess.
664 sleep_until_idle (saver_info *si, Bool until_idle_p)
666 saver_preferences *p = &si->prefs;
669 /* We need to select events on all windows if we're not using any extensions.
670 Otherwise, we don't need to. */
671 Bool scanning_all_windows = !(si->using_xidle_extension ||
672 si->using_mit_saver_extension ||
673 si->using_sgi_saver_extension);
675 /* We need to periodically wake up and check for idleness if we're not using
676 any extensions, or if we're using the XIDLE extension. The other two
677 extensions explicitly deliver events when we go idle/non-idle, so we
678 don't need to poll. */
679 Bool polling_for_idleness = !(si->using_mit_saver_extension ||
680 si->using_sgi_saver_extension);
682 /* Whether we need to periodically wake up and check to see if the mouse has
683 moved. We only need to do this when not using any extensions. The reason
684 this isn't the same as `polling_for_idleness' is that the "idleness" poll
685 can happen (for example) 5 minutes from now, whereas the mouse-position
686 poll should happen with low periodicity. We don't need to poll the mouse
687 position with the XIDLE extension, but we do need to periodically wake up
688 and query the server with that extension. For our purposes, polling
689 /proc/interrupts is just like polling the mouse position. It has to
690 happen on the same kind of schedule. */
691 Bool polling_mouse_position = (si->using_proc_interrupts ||
692 !(si->using_xidle_extension ||
693 si->using_mit_saver_extension ||
694 si->using_sgi_saver_extension));
698 if (polling_for_idleness)
699 /* This causes a no-op event to be delivered to us in a while, so that
700 we come back around through the event loop again. */
701 schedule_wakeup_event (si, p->timeout, p->debug_p);
703 if (polling_mouse_position)
704 /* Check to see if the mouse has moved, and set up a repeating timer
705 to do so periodically (typically, every 5 seconds.) */
706 check_pointer_timer ((XtPointer) si, 0);
711 XtAppNextEvent (si->app, &event);
713 switch (event.xany.type) {
714 case 0: /* our synthetic "timeout" event has been signalled */
719 /* We may be idle; check one last time to see if the mouse has
720 moved, just in case the idle-timer went off within the 5 second
721 window between mouse polling. If the mouse has moved, then
722 check_pointer_timer() will reset last_activity_time.
724 if (polling_mouse_position)
725 check_pointer_timer ((XtPointer) si, 0);
727 #ifdef HAVE_XIDLE_EXTENSION
728 if (si->using_xidle_extension)
730 /* The XIDLE extension uses the synthetic event to prod us into
731 re-asking the server how long the user has been idle. */
732 if (! XGetIdleTime (si->dpy, &idle))
734 fprintf (stderr, "%s: XGetIdleTime() failed.\n", blurb());
735 saver_exit (si, 1, 0);
739 #endif /* HAVE_XIDLE_EXTENSION */
740 #ifdef HAVE_MIT_SAVER_EXTENSION
741 if (si->using_mit_saver_extension)
743 /* We don't need to do anything in this case - the synthetic
744 event isn't necessary, as we get sent specific events
745 to wake us up. In fact, this event generally shouldn't
746 be being delivered when the MIT extension is in use. */
750 #endif /* HAVE_MIT_SAVER_EXTENSION */
751 #ifdef HAVE_SGI_SAVER_EXTENSION
752 if (si->using_sgi_saver_extension)
754 /* We don't need to do anything in this case - the synthetic
755 event isn't necessary, as we get sent specific events
756 to wake us up. In fact, this event generally shouldn't
757 be being delivered when the SGI extension is in use. */
761 #endif /* HAVE_SGI_SAVER_EXTENSION */
763 /* Otherwise, no server extension is in use. The synthetic
764 event was to tell us to wake up and see if the user is now
765 idle. Compute the amount of idle time by comparing the
766 `last_activity_time' to the wall clock. The l_a_t was set
767 by calling `reset_timers()', which is called only in only
768 two situations: when polling the mouse position has revealed
769 the the mouse has moved (user activity) or when we have read
770 an event (again, user activity.)
772 idle = 1000 * (si->last_activity_time - time ((time_t *) 0));
775 if (idle >= p->timeout)
777 /* Look, we've been idle long enough. We're done. */
780 else if (si->emergency_lock_p)
782 /* Oops, the wall clock has jumped far into the future, so
783 we need to lock down in a hurry! */
788 /* The event went off, but it turns out that the user has not
789 yet been idle for long enough. So re-signal the event.
790 Be economical: if we should blank after 5 minutes, and the
791 user has been idle for 2 minutes, then set this timer to
794 if (polling_for_idleness)
795 schedule_wakeup_event (si, p->timeout - idle, p->debug_p);
801 if (handle_clientmessage (si, &event, until_idle_p))
806 /* A window has been created on the screen somewhere. If we're
807 supposed to scan all windows for events, prepare this window. */
808 if (scanning_all_windows)
810 Window w = event.xcreatewindow.window;
811 start_notice_events_timer (si, w, p->debug_p);
823 Window root=0, window=0;
825 const char *type = 0;
826 if (event.xany.type == MotionNotify)
828 /*type = "MotionNotify";*/
829 root = event.xmotion.root;
830 window = event.xmotion.window;
831 x = event.xmotion.x_root;
832 y = event.xmotion.y_root;
834 else if (event.xany.type == KeyPress)
837 root = event.xkey.root;
838 window = event.xkey.window;
841 else if (event.xany.type == ButtonPress)
843 type = "ButtonPress";
844 root = event.xkey.root;
845 window = event.xkey.window;
846 x = event.xmotion.x_root;
847 y = event.xmotion.y_root;
853 for (i = 0; i < si->nscreens; i++)
854 if (root == RootWindowOfScreen (si->screens[i].screen))
856 fprintf (stderr,"%s: %d: %s on 0x%lx",
857 blurb(), i, type, (unsigned long) window);
859 /* Be careful never to do this unless in -debug mode, as
860 this could expose characters from the unlock password. */
861 if (p->debug_p && event.xany.type == KeyPress)
865 XLookupString (&event.xkey, &c, 1, &keysym, 0);
866 fprintf (stderr, " (%s%s)",
867 (event.xkey.send_event ? "synthetic " : ""),
868 XKeysymToString (keysym));
872 fprintf (stderr, "\n");
874 fprintf (stderr, " at %d,%d.\n", x, y);
878 /* If any widgets want to handle this event, let them. */
879 dispatch_event (si, &event);
882 /* If we got a MotionNotify event, figure out what screen it
883 was on and poll the mouse there: if the mouse hasn't moved
884 far enough to count as "real" motion, then ignore this
887 if (event.xany.type == MotionNotify)
890 for (i = 0; i < si->nscreens; i++)
891 if (event.xmotion.root ==
892 RootWindowOfScreen (si->screens[i].screen))
894 if (i < si->nscreens)
896 if (!pointer_moved_p (&si->screens[i], False))
902 /* We got a user event.
903 If we're waiting for the user to become active, this is it.
904 If we're waiting until the user becomes idle, reset the timers
905 (since now we have longer to wait.)
910 (event.xany.type == MotionNotify ||
911 event.xany.type == KeyRelease))
912 /* When we're demoing a single hack, mouse motion doesn't
913 cause deactivation. Only clicks and keypresses do. */
916 /* If we're not demoing, then any activity causes deactivation.
927 #ifdef HAVE_MIT_SAVER_EXTENSION
928 if (event.type == si->mit_saver_ext_event_number)
930 /* This event's number is that of the MIT-SCREEN-SAVER server
931 extension. This extension has one event number, and the event
932 itself contains sub-codes that say what kind of event it was
933 (an "idle" or "not-idle" event.)
935 XScreenSaverNotifyEvent *sevent =
936 (XScreenSaverNotifyEvent *) &event;
937 if (sevent->state == ScreenSaverOn)
941 fprintf (stderr, "%s: MIT ScreenSaverOn event received.\n",
944 /* Get the "real" server window(s) out of the way as soon
946 for (i = 0; i < si->nscreens; i++)
948 saver_screen_info *ssi = &si->screens[i];
949 if (ssi->server_mit_saver_window &&
950 window_exists_p (si->dpy,
951 ssi->server_mit_saver_window))
952 XUnmapWindow (si->dpy, ssi->server_mit_saver_window);
955 if (sevent->kind != ScreenSaverExternal)
958 "%s: ScreenSaverOn event wasn't of type External!\n",
965 else if (sevent->state == ScreenSaverOff)
968 fprintf (stderr, "%s: MIT ScreenSaverOff event received.\n",
975 "%s: unknown MIT-SCREEN-SAVER event %d received!\n",
976 blurb(), sevent->state);
980 #endif /* HAVE_MIT_SAVER_EXTENSION */
983 #ifdef HAVE_SGI_SAVER_EXTENSION
984 if (event.type == (si->sgi_saver_ext_event_number + ScreenSaverStart))
986 /* The SGI SCREEN_SAVER server extension has two event numbers,
987 and this event matches the "idle" event. */
989 fprintf (stderr, "%s: SGI ScreenSaverStart event received.\n",
995 else if (event.type == (si->sgi_saver_ext_event_number +
998 /* The SGI SCREEN_SAVER server extension has two event numbers,
999 and this event matches the "idle" event. */
1001 fprintf (stderr, "%s: SGI ScreenSaverEnd event received.\n",
1007 #endif /* HAVE_SGI_SAVER_EXTENSION */
1010 if (event.type == (si->randr_event_number + RRScreenChangeNotify))
1012 /* The Resize and Rotate extension sends an event when the
1013 size, rotation, or refresh rate of the screen has changed. */
1015 XRRScreenChangeNotifyEvent *xrr_event =
1016 (XRRScreenChangeNotifyEvent *) &event;
1017 /* XRRRootToScreen is in Xrandr.h 1.4, 2001/06/07 */
1018 int screen = XRRRootToScreen (si->dpy, xrr_event->window);
1022 if (si->screens[screen].width == xrr_event->width &&
1023 si->screens[screen].height == xrr_event->height)
1025 "%s: %d: no-op screen size change event (%dx%d)\n",
1027 xrr_event->width, xrr_event->height);
1030 "%s: %d: screen size changed from %dx%d to %dx%d\n",
1032 si->screens[screen].width,
1033 si->screens[screen].height,
1034 xrr_event->width, xrr_event->height);
1037 # ifdef RRScreenChangeNotifyMask
1038 /* Inform Xlib that it's ok to update its data structures. */
1039 XRRUpdateConfiguration (&event); /* Xrandr.h 1.9, 2002/09/29 */
1040 # endif /* RRScreenChangeNotifyMask */
1042 /* Resize the existing xscreensaver windows and cached ssi data. */
1043 resize_screensaver_window (si);
1046 #endif /* HAVE_RANDR */
1048 /* Just some random event. Let the Widgets handle it, if desired. */
1049 dispatch_event (si, &event);
1055 /* If there's a user event on the queue, swallow it.
1056 If we're using a server extension, and the user becomes active, we
1057 get the extension event before the user event -- so the keypress or
1058 motion or whatever is still on the queue. This makes "unfade" not
1059 work, because it sees that event, and bugs out. (This problem
1060 doesn't exhibit itself without an extension, because in that case,
1061 there's only one event generated by user activity, not two.)
1063 if (!until_idle_p && si->locked_p)
1064 swallow_unlock_typeahead_events (si, &event);
1066 while (XCheckMaskEvent (si->dpy,
1067 (KeyPressMask|ButtonPressMask|PointerMotionMask),
1072 if (si->check_pointer_timer_id)
1074 XtRemoveTimeOut (si->check_pointer_timer_id);
1075 si->check_pointer_timer_id = 0;
1079 XtRemoveTimeOut (si->timer_id);
1083 if (until_idle_p && si->cycle_id) /* no cycle timer when inactive */
1091 /* Some crap for dealing with /proc/interrupts.
1093 On Linux systems, it's possible to see the hardware interrupt count
1094 associated with the keyboard. We can therefore use that as another method
1095 of detecting idleness.
1097 Why is it a good idea to do this? Because it lets us detect keyboard
1098 activity that is not associated with X events. For example, if the user
1099 has switched to another virtual console, it's good for xscreensaver to not
1100 be running graphics hacks on the (non-visible) X display. The common
1101 complaint that checking /proc/interrupts addresses is that the user is
1102 playing Quake on a non-X console, and the GL hacks are perceptibly slowing
1105 This is tricky for a number of reasons.
1107 * First, we must be sure to only do this when running on an X server that
1108 is on the local machine (because otherwise, we'd be reacting to the
1109 wrong keyboard.) The way we do this is by noting that the $DISPLAY is
1110 pointing to display 0 on the local machine. It *could* be that display
1111 1 is also on the local machine (e.g., two X servers, each on a different
1112 virtual-terminal) but it's also possible that screen 1 is an X terminal,
1113 using this machine as the host. So we can't take that chance.
1115 * Second, one can only access these interrupt numbers in a completely
1116 and utterly brain-damaged way. You would think that one would use an
1117 ioctl for this. But no. The ONLY way to get this information is to
1118 open the pseudo-file /proc/interrupts AS A FILE, and read the numbers
1119 out of it TEXTUALLY. Because this is Unix, and all the world's a file,
1120 and the only real data type is the short-line sequence of ASCII bytes.
1122 Now it's all well and good that the /proc/interrupts pseudo-file
1123 exists; that's a clever idea, and a useful API for things that are
1124 already textually oriented, like shell scripts, and users doing
1125 interactive debugging sessions. But to make a *C PROGRAM* open a file
1126 and parse the textual representation of integers out of it is just
1129 * Third, you can't just hold the file open, and fseek() back to the
1130 beginning to get updated data! If you do that, the data never changes.
1131 And I don't want to call open() every five seconds, because I don't want
1132 to risk going to disk for any inodes. It turns out that if you dup()
1133 it early, then each copy gets fresh data, so we can get around that in
1134 this way (but for how many releases, one might wonder?)
1136 * Fourth, the format of the output of the /proc/interrupts file is
1137 undocumented, and has changed several times already! In Linux 2.0.33,
1138 even on a multiprocessor machine, it looks like this:
1143 but in Linux 2.2 and 2.4 kernels with MP machines, it looks like this:
1146 0: 1671450 1672618 IO-APIC-edge timer
1147 1: 13037 13495 IO-APIC-edge keyboard
1149 and in Linux 2.6, it's gotten even goofier: now there are two lines
1150 labelled "i8042". One of them is the keyboard, and one of them is
1151 the PS/2 mouse -- and of course, you can't tell them apart, except
1152 by wiggling the mouse and noting which one changes:
1155 1: 32051 30864 IO-APIC-edge i8042
1156 12: 476577 479913 IO-APIC-edge i8042
1158 Joy! So how are we expected to parse that? Well, this code doesn't
1159 parse it: it saves the first line with the string "keyboard" (or
1160 "i8042") in it, and does a string-comparison to note when it has
1161 changed. If there are two "i8042" lines, we assume the first is
1162 the keyboard and the second is the mouse (doesn't matter which is
1163 which, really, as long as we don't compare them against each other.)
1165 Thanks to Nat Friedman <nat@nat.org> for figuring out most of this crap.
1167 Note that if you have a serial or USB mouse, or a USB keyboard, it won't
1168 detect it. That's because there's no way to tell the difference between a
1169 serial mouse and a general serial port, and all USB devices look the same
1170 from here. It would be somewhat unfortunate to have the screensaver turn
1171 off when the modem on COM1 burped, or when a USB disk was accessed.
1175 #ifdef HAVE_PROC_INTERRUPTS
1177 #define PROC_INTERRUPTS "/proc/interrupts"
1180 query_proc_interrupts_available (saver_info *si, const char **why)
1182 /* We can use /proc/interrupts if $DISPLAY points to :0, and if the
1183 "/proc/interrupts" file exists and is readable.
1188 if (!display_is_on_console_p (si))
1190 if (why) *why = "not on primary console";
1194 f = fopen (PROC_INTERRUPTS, "r");
1204 proc_interrupts_activity_p (saver_info *si)
1206 static FILE *f0 = 0;
1209 static char last_kbd_line[255] = { 0, };
1210 static char last_ptr_line[255] = { 0, };
1211 char new_line[sizeof(last_kbd_line)];
1212 Bool checked_kbd = False, kbd_changed = False;
1213 Bool checked_ptr = False, ptr_changed = False;
1214 int i8042_count = 0;
1218 /* First time -- open the file. */
1219 f0 = fopen (PROC_INTERRUPTS, "r");
1223 sprintf(buf, "%s: error opening %s", blurb(), PROC_INTERRUPTS);
1229 if (f0 == (FILE *) -1) /* means we got an error initializing. */
1232 fd = dup (fileno (f0));
1236 sprintf(buf, "%s: could not dup() the %s fd", blurb(), PROC_INTERRUPTS);
1241 f1 = fdopen (fd, "r");
1245 sprintf(buf, "%s: could not fdopen() the %s fd", blurb(),
1251 /* Actually, I'm unclear on why this fseek() is necessary, given the timing
1252 of the dup() above, but it is. */
1253 if (fseek (f1, 0, SEEK_SET) != 0)
1256 sprintf(buf, "%s: error rewinding %s", blurb(), PROC_INTERRUPTS);
1261 /* Now read through the pseudo-file until we find the "keyboard",
1262 "PS/2 mouse", or "i8042" lines. */
1264 while (fgets (new_line, sizeof(new_line)-1, f1))
1266 Bool i8042_p = !!strstr (new_line, "i8042");
1267 if (i8042_p) i8042_count++;
1269 if (strchr (new_line, ','))
1271 /* Ignore any line that has a comma on it: this is because
1274 12: 930935 XT-PIC usb-uhci, PS/2 Mouse
1276 is really bad news. It *looks* like we can note mouse
1277 activity from that line, but really, that interrupt gets
1278 fired any time any USB device has activity! So we have
1279 to ignore any shared IRQs.
1282 else if (!checked_kbd &&
1283 (strstr (new_line, "keyboard") ||
1284 (i8042_p && i8042_count == 1)))
1286 /* Assume the keyboard interrupt is the line that says "keyboard",
1287 or the *first* line that says "i8042".
1289 kbd_changed = (*last_kbd_line && !!strcmp (new_line, last_kbd_line));
1290 strcpy (last_kbd_line, new_line);
1293 else if (!checked_ptr &&
1294 (strstr (new_line, "PS/2 Mouse") ||
1295 (i8042_p && i8042_count == 2)))
1297 /* Assume the mouse interrupt is the line that says "PS/2 mouse",
1298 or the *second* line that says "i8042".
1300 ptr_changed = (*last_ptr_line && !!strcmp (new_line, last_ptr_line));
1301 strcpy (last_ptr_line, new_line);
1305 if (checked_kbd && checked_ptr)
1309 if (checked_kbd || checked_ptr)
1313 if (si->prefs.debug_p && (kbd_changed || ptr_changed))
1314 fprintf (stderr, "%s: /proc/interrupts activity: %s\n",
1316 ((kbd_changed && ptr_changed) ? "mouse and kbd" :
1317 kbd_changed ? "kbd" :
1318 ptr_changed ? "mouse" : "ERR"));
1320 return (kbd_changed || ptr_changed);
1324 /* If we got here, we didn't find either a "keyboard" or a "PS/2 Mouse"
1325 line in the file at all. */
1326 fprintf (stderr, "%s: no keyboard or mouse data in %s?\n",
1327 blurb(), PROC_INTERRUPTS);
1333 if (f0 && f0 != (FILE *) -1)
1340 #endif /* HAVE_PROC_INTERRUPTS */
1343 /* This timer goes off every few minutes, whether the user is idle or not,
1344 to try and clean up anything that has gone wrong.
1346 It calls disable_builtin_screensaver() so that if xset has been used,
1347 or some other program (like xlock) has messed with the XSetScreenSaver()
1348 settings, they will be set back to sensible values (if a server extension
1349 is in use, messing with xlock can cause xscreensaver to never get a wakeup
1350 event, and could cause monitor power-saving to occur, and all manner of
1353 If the screen is currently blanked, it raises the window, in case some
1354 other window has been mapped on top of it.
1356 If the screen is currently blanked, and there is no hack running, it
1357 clears the window, in case there is an error message printed on it (we
1358 don't want the error message to burn in.)
1362 watchdog_timer (XtPointer closure, XtIntervalId *id)
1364 saver_info *si = (saver_info *) closure;
1365 saver_preferences *p = &si->prefs;
1367 disable_builtin_screensaver (si, False);
1369 /* If the DPMS settings on the server have changed, change them back to
1370 what ~/.xscreensaver says they should be. */
1371 sync_server_dpms_settings (si->dpy,
1372 (p->dpms_enabled_p &&
1373 p->mode != DONT_BLANK),
1374 p->dpms_standby / 1000,
1375 p->dpms_suspend / 1000,
1379 if (si->screen_blanked_p)
1381 Bool running_p = screenhack_running_p (si);
1385 if (si->prefs.debug_p)
1386 fprintf (stderr, "%s: dialog box is up: not raising screen.\n",
1391 if (si->prefs.debug_p)
1392 fprintf (stderr, "%s: watchdog timer raising %sscreen.\n",
1393 blurb(), (running_p ? "" : "and clearing "));
1395 raise_window (si, True, True, running_p);
1398 if (screenhack_running_p (si) &&
1399 !monitor_powered_on_p (si))
1401 if (si->prefs.verbose_p)
1403 "%s: X says monitor has powered down; "
1404 "killing running hacks.\n", blurb());
1405 kill_screenhack (si);
1408 /* Re-schedule this timer. The watchdog timer defaults to a bit less
1409 than the hack cycle period, but is never longer than one hour.
1411 si->watchdog_id = 0;
1412 reset_watchdog_timer (si, True);
1418 reset_watchdog_timer (saver_info *si, Bool on_p)
1420 saver_preferences *p = &si->prefs;
1422 if (si->watchdog_id)
1424 XtRemoveTimeOut (si->watchdog_id);
1425 si->watchdog_id = 0;
1428 if (on_p && p->watchdog_timeout)
1430 si->watchdog_id = XtAppAddTimeOut (si->app, p->watchdog_timeout,
1431 watchdog_timer, (XtPointer) si);
1434 fprintf (stderr, "%s: restarting watchdog_timer (%ld, %ld)\n",
1435 blurb(), p->watchdog_timeout, si->watchdog_id);
1440 /* It's possible that a race condition could have led to the saver
1441 window being unexpectedly still mapped. This can happen like so:
1445 - that hack tries to grab a screen image (it does this by
1446 first unmapping the saver window, then remapping it.)
1447 - hack unmaps window
1449 - user becomes active
1450 - hack re-maps window (*)
1451 - driver kills subprocess
1452 - driver unmaps window (**)
1454 The race is that (*) might have been sent to the server before
1455 the client process was killed, but, due to scheduling randomness,
1456 might not have been received by the server until after (**).
1457 In other words, (*) and (**) might happen out of order, meaning
1458 the driver will unmap the window, and then after that, the
1459 recently-dead client will re-map it. This leaves the user
1460 locked out (it looks like a desktop, but it's not!)
1462 To avoid this: after un-blanking the screen, we launch a timer
1463 that wakes up once a second for ten seconds, and makes damned
1464 sure that the window is still unmapped.
1468 de_race_timer (XtPointer closure, XtIntervalId *id)
1470 saver_info *si = (saver_info *) closure;
1471 saver_preferences *p = &si->prefs;
1474 if (id == 0) /* if id is 0, this is the initialization call. */
1476 si->de_race_ticks = 10;
1478 fprintf (stderr, "%s: starting de-race timer (%d seconds.)\n",
1479 blurb(), si->de_race_ticks);
1484 XSync (si->dpy, False);
1485 for (i = 0; i < si->nscreens; i++)
1487 saver_screen_info *ssi = &si->screens[i];
1488 Window w = ssi->screensaver_window;
1489 XWindowAttributes xgwa;
1490 XGetWindowAttributes (si->dpy, w, &xgwa);
1491 if (xgwa.map_state != IsUnmapped)
1495 "%s: %d: client race! emergency unmap 0x%lx.\n",
1496 blurb(), i, (unsigned long) w);
1497 XUnmapWindow (si->dpy, w);
1499 else if (p->debug_p)
1500 fprintf (stderr, "%s: %d: (de-race of 0x%lx is cool.)\n",
1501 blurb(), i, (unsigned long) w);
1503 XSync (si->dpy, False);
1505 si->de_race_ticks--;
1508 if (id && *id == si->de_race_id)
1511 if (si->de_race_id) abort();
1513 if (si->de_race_ticks <= 0)
1517 fprintf (stderr, "%s: de-race completed.\n", blurb());
1521 si->de_race_id = XtAppAddTimeOut (si->app, secs * 1000,
1522 de_race_timer, closure);