1 /* timers.c --- detecting when the user is idle, and other timer-related tasks.
2 * xscreensaver, Copyright (c) 1991-2012 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 */
268 maybe_reload_init_file (si);
269 for (i = 0; i < si->nscreens; i++)
270 kill_screenhack (&si->screens[i]);
272 raise_window (si, True, True, False);
274 if (!si->throttled_p)
275 for (i = 0; i < si->nscreens; i++)
276 spawn_screenhack (&si->screens[i]);
280 fprintf (stderr, "%s: not launching new hack (throttled.)\n",
287 si->cycle_id = XtAppAddTimeOut (si->app, how_long, cycle_timer,
291 fprintf (stderr, "%s: starting cycle_timer (%ld, %ld)\n",
292 blurb(), how_long, si->cycle_id);
297 fprintf (stderr, "%s: not starting cycle_timer: how_long == %ld\n",
298 blurb(), (unsigned long) how_long);
304 activate_lock_timer (XtPointer closure, XtIntervalId *id)
306 saver_info *si = (saver_info *) closure;
307 saver_preferences *p = &si->prefs;
310 fprintf (stderr, "%s: timed out; activating lock.\n", blurb());
311 set_locked_p (si, True);
315 /* Call this when user activity (or "simulated" activity) has been noticed.
318 reset_timers (saver_info *si)
320 saver_preferences *p = &si->prefs;
321 if (si->using_mit_saver_extension || si->using_sgi_saver_extension)
327 fprintf (stderr, "%s: killing idle_timer (%ld, %ld)\n",
328 blurb(), p->timeout, si->timer_id);
329 XtRemoveTimeOut (si->timer_id);
333 schedule_wakeup_event (si, p->timeout, p->debug_p); /* sets si->timer_id */
335 if (si->cycle_id) abort (); /* no cycle timer when inactive */
337 si->last_activity_time = time ((time_t *) 0);
339 /* This will (hopefully, supposedly) tell the server to re-set its
340 DPMS timer. Without this, the -deactivate clientmessage would
341 prevent xscreensaver from blanking, but would not prevent the
342 monitor from powering down. */
344 /* #### With some servers, this causes the screen to flicker every
345 time a key is pressed! Ok, I surrender. I give up on ever
346 having DPMS work properly.
348 XForceScreenSaver (si->dpy, ScreenSaverReset);
350 /* And if the monitor is already powered off, turn it on.
351 You'd think the above would do that, but apparently not? */
352 monitor_power_on (si, True);
358 /* Returns true if a mouse has moved since the last time we checked.
359 Small motions (of less than "hysteresis" pixels/second) are ignored.
362 device_pointer_moved_p (saver_info *si, poll_mouse_data *last_poll_mouse,
363 poll_mouse_data *this_poll_mouse, Bool mods_p,
364 const char *debug_type, int debug_id)
366 saver_preferences *p = &si->prefs;
368 unsigned int distance, dps;
369 unsigned long seconds = 0;
370 Bool moved_p = False;
372 distance = MAX (ABS (last_poll_mouse->root_x - this_poll_mouse->root_x),
373 ABS (last_poll_mouse->root_y - this_poll_mouse->root_y));
374 seconds = (this_poll_mouse->time - last_poll_mouse->time);
377 /* When the screen is blanked, we get MotionNotify events, but when not
378 blanked, we poll only every 5 seconds, and that's not enough resolution
379 to do hysteresis based on a 1 second interval. So, assume that any
380 motion we've seen during the 5 seconds when our eyes were closed happened
381 in the last 1 second instead.
383 if (seconds > 1) seconds = 1;
385 dps = (seconds <= 0 ? distance : (distance / seconds));
387 /* Motion only counts if the rate is more than N pixels per second.
389 if (dps >= p->pointer_hysteresis &&
393 /* If the mouse is not on this screen but used to be, that's motion.
394 If the mouse was not on this screen, but is now, that's motion.
397 Bool on_screen_p = (this_poll_mouse->root_x != -1 &&
398 this_poll_mouse->root_y != -1);
399 Bool was_on_screen_p = (last_poll_mouse->root_x != -1 &&
400 last_poll_mouse->root_y != -1);
402 if (on_screen_p != was_on_screen_p)
406 if (p->debug_p && (distance != 0 || moved_p))
408 fprintf (stderr, "%s: %s %d: pointer %s", blurb(), debug_type, debug_id,
409 (moved_p ? "moved: " : "ignored:"));
410 if (last_poll_mouse->root_x == -1)
411 fprintf (stderr, "off screen");
413 fprintf (stderr, "%d,%d",
414 last_poll_mouse->root_x,
415 last_poll_mouse->root_y);
416 fprintf (stderr, " -> ");
417 if (this_poll_mouse->root_x == -1)
418 fprintf (stderr, "off screen");
420 fprintf (stderr, "%d,%d", this_poll_mouse->root_x,
421 this_poll_mouse->root_y);
422 if (last_poll_mouse->root_x != -1 && this_poll_mouse->root_x != -1)
423 fprintf (stderr, " (%d,%d; %d/%lu=%d)",
424 ABS(last_poll_mouse->root_x - this_poll_mouse->root_x),
425 ABS(last_poll_mouse->root_y - this_poll_mouse->root_y),
426 distance, seconds, dps);
428 fprintf (stderr, ".\n");
433 this_poll_mouse->mask != last_poll_mouse->mask)
438 fprintf (stderr, "%s: %s %d: modifiers changed: 0x%04x -> 0x%04x.\n",
439 blurb(), debug_type, debug_id,
440 last_poll_mouse->mask, this_poll_mouse->mask);
443 last_poll_mouse->child = this_poll_mouse->child;
444 last_poll_mouse->mask = this_poll_mouse->mask;
446 if (moved_p || seconds > 0)
448 last_poll_mouse->time = this_poll_mouse->time;
449 last_poll_mouse->root_x = this_poll_mouse->root_x;
450 last_poll_mouse->root_y = this_poll_mouse->root_y;
456 /* Returns true if core mouse pointer has moved since the last time we checked.
459 pointer_moved_p (saver_screen_info *ssi, Bool mods_p)
461 saver_info *si = ssi->global;
464 poll_mouse_data this_poll_mouse;
467 /* don't check xinerama pseudo-screens. */
468 if (!ssi->real_screen_p) return False;
470 this_poll_mouse.time = time ((time_t *) 0);
472 if (!XQueryPointer (si->dpy, ssi->screensaver_window, &root,
473 &this_poll_mouse.child,
474 &this_poll_mouse.root_x, &this_poll_mouse.root_y,
475 &x, &y, &this_poll_mouse.mask))
477 /* If XQueryPointer() returns false, the mouse is not on this screen.
479 this_poll_mouse.root_x = -1;
480 this_poll_mouse.root_y = -1;
481 this_poll_mouse.child = 0;
482 this_poll_mouse.mask = 0;
485 si->last_activity_screen = ssi;
487 return device_pointer_moved_p(si, &(ssi->last_poll_mouse), &this_poll_mouse,
488 mods_p, "screen", ssi->number);
492 /* When we aren't using a server extension, this timer is used to periodically
493 wake up and poll the mouse position, which is possibly more reliable than
494 selecting motion events on every window.
497 check_pointer_timer (XtPointer closure, XtIntervalId *id)
500 saver_info *si = (saver_info *) closure;
501 saver_preferences *p = &si->prefs;
502 Bool active_p = False;
504 if (!si->using_proc_interrupts &&
505 (si->using_xidle_extension ||
506 si->using_mit_saver_extension ||
507 si->using_sgi_saver_extension))
508 /* If an extension is in use, we should not be polling the mouse.
509 Unless we're also checking /proc/interrupts, in which case, we should.
513 if (id && *id == si->check_pointer_timer_id) /* this is us - it's expired */
514 si->check_pointer_timer_id = 0;
516 if (si->check_pointer_timer_id) /* only queue one at a time */
517 XtRemoveTimeOut (si->check_pointer_timer_id);
519 si->check_pointer_timer_id = /* now re-queue */
520 XtAppAddTimeOut (si->app, p->pointer_timeout, check_pointer_timer,
523 for (i = 0; i < si->nscreens; i++)
525 saver_screen_info *ssi = &si->screens[i];
526 if (pointer_moved_p (ssi, True))
530 #ifdef HAVE_PROC_INTERRUPTS
532 si->using_proc_interrupts &&
533 proc_interrupts_activity_p (si))
537 #endif /* HAVE_PROC_INTERRUPTS */
542 check_for_clock_skew (si);
546 /* An unfortunate situation is this: the saver is not active, because the
547 user has been typing. The machine is a laptop. The user closes the lid
548 and suspends it. The CPU halts. Some hours later, the user opens the
549 lid. At this point, Xt's timers will fire, and xscreensaver will blank
552 So far so good -- well, not really, but it's the best that we can do,
553 since the OS doesn't send us a signal *before* shutdown -- but if the
554 user had delayed locking (lockTimeout > 0) then we should start off
555 in the locked state, rather than only locking N minutes from when the
556 lid was opened. Also, eschewing fading is probably a good idea, to
557 clamp down as soon as possible.
559 We only do this when we'd be polling the mouse position anyway.
560 This amounts to an assumption that machines with APM support also
561 have /proc/interrupts.
564 check_for_clock_skew (saver_info *si)
566 saver_preferences *p = &si->prefs;
567 time_t now = time ((time_t *) 0);
568 long shift = now - si->last_wall_clock_time;
572 int i = (si->last_wall_clock_time == 0 ? 0 : shift);
574 "%s: checking wall clock for hibernation (%d:%02d:%02d).\n",
576 (i / (60 * 60)), ((i / 60) % 60), (i % 60));
579 if (si->last_wall_clock_time != 0 &&
580 shift > (p->timeout / 1000))
583 fprintf (stderr, "%s: wall clock has jumped by %ld:%02ld:%02ld!\n",
585 (shift / (60 * 60)), ((shift / 60) % 60), (shift % 60));
587 si->emergency_lock_p = True;
588 idle_timer ((XtPointer) si, 0);
591 si->last_wall_clock_time = now;
597 dispatch_event (saver_info *si, XEvent *event)
599 /* If this is for the splash dialog, pass it along.
600 Note that the password dialog is handled with its own event loop,
601 so events for that window will never come through here.
603 if (si->splash_dialog && event->xany.window == si->splash_dialog)
604 handle_splash_event (si, event);
606 XtDispatchEvent (event);
611 swallow_unlock_typeahead_events (saver_info *si, XEvent *e)
617 memset (buf, 0, sizeof(buf));
623 if (event.xany.type == KeyPress)
626 int size = XLookupString ((XKeyEvent *) &event, s, 1, 0, 0);
627 if (size != 1) continue;
630 case '\010': case '\177': /* Backspace */
633 case '\025': case '\030': /* Erase line */
634 case '\012': case '\015': /* Enter */
635 case '\033': /* ESC */
638 case '\040': /* Space */
640 break; /* ignore space at beginning of line */
641 /* else, fall through */
648 } while (i < sizeof(buf)-1 &&
649 XCheckMaskEvent (si->dpy, KeyPressMask, &event));
653 if (si->unlock_typeahead)
655 memset (si->unlock_typeahead, 0, strlen(si->unlock_typeahead));
656 free (si->unlock_typeahead);
660 si->unlock_typeahead = strdup (buf);
662 si->unlock_typeahead = 0;
664 memset (buf, 0, sizeof(buf));
668 /* methods of detecting idleness:
670 explicitly informed by SGI SCREEN_SAVER server event;
671 explicitly informed by MIT-SCREEN-SAVER server event;
672 poll server idle time with XIDLE extension;
673 select events on all windows, and note absence of recent events;
674 note that /proc/interrupts has not changed in a while;
675 activated by clientmessage.
677 methods of detecting non-idleness:
679 read events on the xscreensaver window;
680 explicitly informed by SGI SCREEN_SAVER server event;
681 explicitly informed by MIT-SCREEN-SAVER server event;
682 select events on all windows, and note events on any of them;
683 note that /proc/interrupts has changed;
684 deactivated by clientmessage.
686 I trust that explains why this function is a big hairy mess.
689 sleep_until_idle (saver_info *si, Bool until_idle_p)
691 saver_preferences *p = &si->prefs;
693 /* We have to go through this union bullshit because gcc-4.4.0 has
694 stricter struct-aliasing rules. Without this, the optimizer
700 XRRScreenChangeNotifyEvent xrr_event;
701 # endif /* HAVE_RANDR */
702 # ifdef HAVE_MIT_SAVER_EXTENSION
703 XScreenSaverNotifyEvent sevent;
704 # endif /* HAVE_MIT_SAVER_EXTENSION */
707 /* We need to select events on all windows if we're not using any extensions.
708 Otherwise, we don't need to. */
709 Bool scanning_all_windows = !(si->using_xidle_extension ||
710 si->using_mit_saver_extension ||
711 si->using_sgi_saver_extension);
713 /* We need to periodically wake up and check for idleness if we're not using
714 any extensions, or if we're using the XIDLE extension. The other two
715 extensions explicitly deliver events when we go idle/non-idle, so we
716 don't need to poll. */
717 Bool polling_for_idleness = !(si->using_mit_saver_extension ||
718 si->using_sgi_saver_extension);
720 /* Whether we need to periodically wake up and check to see if the mouse has
721 moved. We only need to do this when not using any extensions. The reason
722 this isn't the same as `polling_for_idleness' is that the "idleness" poll
723 can happen (for example) 5 minutes from now, whereas the mouse-position
724 poll should happen with low periodicity. We don't need to poll the mouse
725 position with the XIDLE extension, but we do need to periodically wake up
726 and query the server with that extension. For our purposes, polling
727 /proc/interrupts is just like polling the mouse position. It has to
728 happen on the same kind of schedule. */
729 Bool polling_mouse_position = (si->using_proc_interrupts ||
730 !(si->using_xidle_extension ||
731 si->using_mit_saver_extension ||
732 si->using_sgi_saver_extension) ||
733 si->using_xinput_extension);
735 const char *why = 0; /* What caused the idle-state to change? */
739 if (polling_for_idleness)
740 /* This causes a no-op event to be delivered to us in a while, so that
741 we come back around through the event loop again. */
742 schedule_wakeup_event (si, p->timeout, p->debug_p);
744 if (polling_mouse_position)
745 /* Check to see if the mouse has moved, and set up a repeating timer
746 to do so periodically (typically, every 5 seconds.) */
747 check_pointer_timer ((XtPointer) si, 0);
752 XtAppNextEvent (si->app, &event.x_event);
754 switch (event.x_event.xany.type) {
755 case 0: /* our synthetic "timeout" event has been signalled */
760 /* We may be idle; check one last time to see if the mouse has
761 moved, just in case the idle-timer went off within the 5 second
762 window between mouse polling. If the mouse has moved, then
763 check_pointer_timer() will reset last_activity_time.
765 if (polling_mouse_position)
766 check_pointer_timer ((XtPointer) si, 0);
768 #ifdef HAVE_XIDLE_EXTENSION
769 if (si->using_xidle_extension)
771 /* The XIDLE extension uses the synthetic event to prod us into
772 re-asking the server how long the user has been idle. */
773 if (! XGetIdleTime (si->dpy, &idle))
775 fprintf (stderr, "%s: XGetIdleTime() failed.\n", blurb());
776 saver_exit (si, 1, 0);
780 #endif /* HAVE_XIDLE_EXTENSION */
781 #ifdef HAVE_MIT_SAVER_EXTENSION
782 if (si->using_mit_saver_extension)
784 /* We don't need to do anything in this case - the synthetic
785 event isn't necessary, as we get sent specific events
786 to wake us up. In fact, this event generally shouldn't
787 be being delivered when the MIT extension is in use. */
791 #endif /* HAVE_MIT_SAVER_EXTENSION */
792 #ifdef HAVE_SGI_SAVER_EXTENSION
793 if (si->using_sgi_saver_extension)
795 /* We don't need to do anything in this case - the synthetic
796 event isn't necessary, as we get sent specific events
797 to wake us up. In fact, this event generally shouldn't
798 be being delivered when the SGI extension is in use. */
802 #endif /* HAVE_SGI_SAVER_EXTENSION */
804 /* Otherwise, no server extension is in use. The synthetic
805 event was to tell us to wake up and see if the user is now
806 idle. Compute the amount of idle time by comparing the
807 `last_activity_time' to the wall clock. The l_a_t was set
808 by calling `reset_timers()', which is called only in only
809 two situations: when polling the mouse position has revealed
810 the the mouse has moved (user activity) or when we have read
811 an event (again, user activity.)
813 idle = 1000 * (si->last_activity_time - time ((time_t *) 0));
816 if (idle >= p->timeout)
818 /* Look, we've been idle long enough. We're done. */
822 else if (si->emergency_lock_p)
824 /* Oops, the wall clock has jumped far into the future, so
825 we need to lock down in a hurry! */
826 why = "large wall clock change";
831 /* The event went off, but it turns out that the user has not
832 yet been idle for long enough. So re-signal the event.
833 Be economical: if we should blank after 5 minutes, and the
834 user has been idle for 2 minutes, then set this timer to
837 if (polling_for_idleness)
838 schedule_wakeup_event (si, p->timeout - idle, p->debug_p);
844 if (handle_clientmessage (si, &event.x_event, until_idle_p))
846 why = "ClientMessage";
852 /* A window has been created on the screen somewhere. If we're
853 supposed to scan all windows for events, prepare this window. */
854 if (scanning_all_windows)
856 Window w = event.x_event.xcreatewindow.window;
857 start_notice_events_timer (si, w, p->debug_p);
863 /* Ignore release events so that hitting ESC at the password dialog
864 doesn't result in the password dialog coming right back again when
865 the fucking release key is seen! */
866 /* case KeyRelease:*/
867 /* case ButtonRelease:*/
872 Window root=0, window=0;
874 const char *type = 0;
875 if (event.x_event.xany.type == MotionNotify)
877 /*type = "MotionNotify";*/
878 root = event.x_event.xmotion.root;
879 window = event.x_event.xmotion.window;
880 x = event.x_event.xmotion.x_root;
881 y = event.x_event.xmotion.y_root;
883 else if (event.x_event.xany.type == KeyPress)
886 root = event.x_event.xkey.root;
887 window = event.x_event.xkey.window;
890 else if (event.x_event.xany.type == ButtonPress)
892 type = "ButtonPress";
893 root = event.x_event.xkey.root;
894 window = event.x_event.xkey.window;
895 x = event.x_event.xmotion.x_root;
896 y = event.x_event.xmotion.y_root;
902 for (i = 0; i < si->nscreens; i++)
903 if (root == RootWindowOfScreen (si->screens[i].screen))
905 fprintf (stderr,"%s: %d: %s on 0x%lx",
906 blurb(), i, type, (unsigned long) window);
908 /* Be careful never to do this unless in -debug mode, as
909 this could expose characters from the unlock password. */
910 if (p->debug_p && event.x_event.xany.type == KeyPress)
914 XLookupString (&event.x_event.xkey, &c, 1, &keysym, 0);
915 fprintf (stderr, " (%s%s)",
916 (event.x_event.xkey.send_event ? "synthetic " : ""),
917 XKeysymToString (keysym));
921 fprintf (stderr, "\n");
923 fprintf (stderr, " at %d,%d.\n", x, y);
927 /* If any widgets want to handle this event, let them. */
928 dispatch_event (si, &event.x_event);
931 /* If we got a MotionNotify event, figure out what screen it
932 was on and poll the mouse there: if the mouse hasn't moved
933 far enough to count as "real" motion, then ignore this
936 if (event.x_event.xany.type == MotionNotify)
939 for (i = 0; i < si->nscreens; i++)
940 if (event.x_event.xmotion.root ==
941 RootWindowOfScreen (si->screens[i].screen))
943 if (i < si->nscreens)
945 if (!pointer_moved_p (&si->screens[i], False))
951 /* We got a user event.
952 If we're waiting for the user to become active, this is it.
953 If we're waiting until the user becomes idle, reset the timers
954 (since now we have longer to wait.)
959 (event.x_event.xany.type == MotionNotify ||
960 event.x_event.xany.type == KeyRelease))
961 /* When we're demoing a single hack, mouse motion doesn't
962 cause deactivation. Only clicks and keypresses do. */
966 /* If we're not demoing, then any activity causes deactivation.
968 why = (event.x_event.xany.type == MotionNotify ?"mouse motion":
969 event.x_event.xany.type == KeyPress?"keyboard activity":
970 event.x_event.xany.type == ButtonPress ? "mouse click" :
971 "unknown user activity");
982 #ifdef HAVE_MIT_SAVER_EXTENSION
983 if (event.x_event.type == si->mit_saver_ext_event_number)
985 /* This event's number is that of the MIT-SCREEN-SAVER server
986 extension. This extension has one event number, and the event
987 itself contains sub-codes that say what kind of event it was
988 (an "idle" or "not-idle" event.)
990 if (event.sevent.state == ScreenSaverOn)
994 fprintf (stderr, "%s: MIT ScreenSaverOn event received.\n",
997 /* Get the "real" server window(s) out of the way as soon
999 for (i = 0; i < si->nscreens; i++)
1001 saver_screen_info *ssi = &si->screens[i];
1002 if (ssi->server_mit_saver_window &&
1003 window_exists_p (si->dpy,
1004 ssi->server_mit_saver_window))
1005 XUnmapWindow (si->dpy, ssi->server_mit_saver_window);
1008 if (event.sevent.kind != ScreenSaverExternal)
1011 "%s: ScreenSaverOn event wasn't of type External!\n",
1017 why = "MIT ScreenSaverOn";
1021 else if (event.sevent.state == ScreenSaverOff)
1024 fprintf (stderr, "%s: MIT ScreenSaverOff event received.\n",
1028 why = "MIT ScreenSaverOff";
1034 "%s: unknown MIT-SCREEN-SAVER event %d received!\n",
1035 blurb(), event.sevent.state);
1039 #endif /* HAVE_MIT_SAVER_EXTENSION */
1042 #ifdef HAVE_SGI_SAVER_EXTENSION
1043 if (event.x_event.type == (si->sgi_saver_ext_event_number + ScreenSaverStart))
1045 /* The SGI SCREEN_SAVER server extension has two event numbers,
1046 and this event matches the "idle" event. */
1048 fprintf (stderr, "%s: SGI ScreenSaverStart event received.\n",
1053 why = "SGI ScreenSaverStart";
1057 else if (event.x_event.type == (si->sgi_saver_ext_event_number +
1060 /* The SGI SCREEN_SAVER server extension has two event numbers,
1061 and this event matches the "idle" event. */
1063 fprintf (stderr, "%s: SGI ScreenSaverEnd event received.\n",
1067 why = "SGI ScreenSaverEnd";
1072 #endif /* HAVE_SGI_SAVER_EXTENSION */
1075 /* If we got a MotionNotify event, check to see if the mouse has
1076 moved far enough to count as "real" motion, if not, then ignore
1079 if ((si->num_xinput_devices > 0) &&
1080 (event.x_event.type == si->xinput_DeviceMotionNotify))
1082 XDeviceMotionEvent *dme = (XDeviceMotionEvent *) &event;
1083 poll_mouse_data *last_poll_mouse = NULL;
1086 for (d = 0; d < si->num_xinput_devices; d++)
1088 if (si->xinput_devices[d].device->device_id == dme->deviceid)
1090 last_poll_mouse = &(si->xinput_devices[d].last_poll_mouse);
1095 if (last_poll_mouse)
1097 poll_mouse_data this_poll_mouse;
1098 this_poll_mouse.root_x = dme->x_root;
1099 this_poll_mouse.root_y = dme->y_root;
1100 this_poll_mouse.child = dme->subwindow;
1101 this_poll_mouse.mask = dme->device_state;
1102 this_poll_mouse.time = dme->time / 1000; /* milliseconds */
1104 if (!device_pointer_moved_p (si, last_poll_mouse,
1105 &this_poll_mouse, False,
1106 "device", dme->deviceid))
1109 else if (p->debug_p)
1111 "%s: received MotionNotify from unknown device %d\n",
1112 blurb(), (int) dme->deviceid);
1115 if ((!until_idle_p) &&
1116 (si->num_xinput_devices > 0) &&
1117 (event.x_event.type == si->xinput_DeviceMotionNotify ||
1118 event.x_event.type == si->xinput_DeviceButtonPress))
1119 /* Ignore DeviceButtonRelease, see ButtonRelease comment above. */
1122 dispatch_event (si, &event.x_event);
1123 if (si->demoing_p &&
1124 event.x_event.type == si->xinput_DeviceMotionNotify)
1125 /* When we're demoing a single hack, mouse motion doesn't
1126 cause deactivation. Only clicks and keypresses do. */
1129 /* If we're not demoing, then any activity causes deactivation.
1132 why = (event.x_event.type == si->xinput_DeviceMotionNotify
1133 ? "XI mouse motion" :
1134 event.x_event.type == si->xinput_DeviceButtonPress
1135 ? "XI mouse click" : "unknown XINPUT event");
1140 #endif /* HAVE_XINPUT */
1143 if (si->using_randr_extension &&
1144 (event.x_event.type ==
1145 (si->randr_event_number + RRScreenChangeNotify)))
1147 /* The Resize and Rotate extension sends an event when the
1148 size, rotation, or refresh rate of any screen has changed.
1152 /* XRRRootToScreen is in Xrandr.h 1.4, 2001/06/07 */
1153 int screen = XRRRootToScreen (si->dpy, event.xrr_event.window);
1154 fprintf (stderr, "%s: %d: screen change event received\n",
1158 # ifdef RRScreenChangeNotifyMask
1159 /* Inform Xlib that it's ok to update its data structures. */
1160 XRRUpdateConfiguration (&event.x_event); /* Xrandr.h 1.9, 2002/09/29 */
1161 # endif /* RRScreenChangeNotifyMask */
1163 /* Resize the existing xscreensaver windows and cached ssi data. */
1164 if (update_screen_layout (si))
1168 fprintf (stderr, "%s: new layout:\n", blurb());
1169 describe_monitor_layout (si);
1171 resize_screensaver_window (si);
1175 #endif /* HAVE_RANDR */
1177 /* Just some random event. Let the Widgets handle it, if desired. */
1178 dispatch_event (si, &event.x_event);
1185 if (! why) why = "unknown reason";
1186 fprintf (stderr, "%s: %s (%s)\n", blurb(),
1187 (until_idle_p ? "user is idle" : "user is active"),
1191 /* If there's a user event on the queue, swallow it.
1192 If we're using a server extension, and the user becomes active, we
1193 get the extension event before the user event -- so the keypress or
1194 motion or whatever is still on the queue. This makes "unfade" not
1195 work, because it sees that event, and bugs out. (This problem
1196 doesn't exhibit itself without an extension, because in that case,
1197 there's only one event generated by user activity, not two.)
1199 if (!until_idle_p && si->locked_p)
1200 swallow_unlock_typeahead_events (si, &event.x_event);
1202 while (XCheckMaskEvent (si->dpy,
1203 (KeyPressMask|ButtonPressMask|PointerMotionMask),
1208 if (si->check_pointer_timer_id)
1210 XtRemoveTimeOut (si->check_pointer_timer_id);
1211 si->check_pointer_timer_id = 0;
1215 XtRemoveTimeOut (si->timer_id);
1219 if (until_idle_p && si->cycle_id) /* no cycle timer when inactive */
1225 /* Some crap for dealing with /proc/interrupts.
1227 On Linux systems, it's possible to see the hardware interrupt count
1228 associated with the keyboard. We can therefore use that as another method
1229 of detecting idleness.
1231 Why is it a good idea to do this? Because it lets us detect keyboard
1232 activity that is not associated with X events. For example, if the user
1233 has switched to another virtual console, it's good for xscreensaver to not
1234 be running graphics hacks on the (non-visible) X display. The common
1235 complaint that checking /proc/interrupts addresses is that the user is
1236 playing Quake on a non-X console, and the GL hacks are perceptibly slowing
1239 This is tricky for a number of reasons.
1241 * First, we must be sure to only do this when running on an X server that
1242 is on the local machine (because otherwise, we'd be reacting to the
1243 wrong keyboard.) The way we do this is by noting that the $DISPLAY is
1244 pointing to display 0 on the local machine. It *could* be that display
1245 1 is also on the local machine (e.g., two X servers, each on a different
1246 virtual-terminal) but it's also possible that screen 1 is an X terminal,
1247 using this machine as the host. So we can't take that chance.
1249 * Second, one can only access these interrupt numbers in a completely
1250 and utterly brain-damaged way. You would think that one would use an
1251 ioctl for this. But no. The ONLY way to get this information is to
1252 open the pseudo-file /proc/interrupts AS A FILE, and read the numbers
1253 out of it TEXTUALLY. Because this is Unix, and all the world's a file,
1254 and the only real data type is the short-line sequence of ASCII bytes.
1256 Now it's all well and good that the /proc/interrupts pseudo-file
1257 exists; that's a clever idea, and a useful API for things that are
1258 already textually oriented, like shell scripts, and users doing
1259 interactive debugging sessions. But to make a *C PROGRAM* open a file
1260 and parse the textual representation of integers out of it is just
1263 * Third, you can't just hold the file open, and fseek() back to the
1264 beginning to get updated data! If you do that, the data never changes.
1265 And I don't want to call open() every five seconds, because I don't want
1266 to risk going to disk for any inodes. It turns out that if you dup()
1267 it early, then each copy gets fresh data, so we can get around that in
1268 this way (but for how many releases, one might wonder?)
1270 * Fourth, the format of the output of the /proc/interrupts file is
1271 undocumented, and has changed several times already! In Linux 2.0.33,
1272 even on a multiprocessor machine, it looks like this:
1277 but in Linux 2.2 and 2.4 kernels with MP machines, it looks like this:
1280 0: 1671450 1672618 IO-APIC-edge timer
1281 1: 13037 13495 IO-APIC-edge keyboard
1283 and in Linux 2.6, it's gotten even goofier: now there are two lines
1284 labelled "i8042". One of them is the keyboard, and one of them is
1285 the PS/2 mouse -- and of course, you can't tell them apart, except
1286 by wiggling the mouse and noting which one changes:
1289 1: 32051 30864 IO-APIC-edge i8042
1290 12: 476577 479913 IO-APIC-edge i8042
1292 Joy! So how are we expected to parse that? Well, this code doesn't
1293 parse it: it saves the first line with the string "keyboard" (or
1294 "i8042") in it, and does a string-comparison to note when it has
1295 changed. If there are two "i8042" lines, we assume the first is
1296 the keyboard and the second is the mouse (doesn't matter which is
1297 which, really, as long as we don't compare them against each other.)
1299 Thanks to Nat Friedman <nat@nat.org> for figuring out most of this crap.
1301 Note that if you have a serial or USB mouse, or a USB keyboard, it won't
1302 detect it. That's because there's no way to tell the difference between a
1303 serial mouse and a general serial port, and all USB devices look the same
1304 from here. It would be somewhat unfortunate to have the screensaver turn
1305 off when the modem on COM1 burped, or when a USB disk was accessed.
1309 #ifdef HAVE_PROC_INTERRUPTS
1311 #define PROC_INTERRUPTS "/proc/interrupts"
1314 query_proc_interrupts_available (saver_info *si, const char **why)
1316 /* We can use /proc/interrupts if $DISPLAY points to :0, and if the
1317 "/proc/interrupts" file exists and is readable.
1322 if (!display_is_on_console_p (si))
1324 if (why) *why = "not on primary console";
1328 f = fopen (PROC_INTERRUPTS, "r");
1331 if (why) *why = "does not exist";
1341 proc_interrupts_activity_p (saver_info *si)
1343 static FILE *f0 = 0;
1346 static char last_kbd_line[255] = { 0, };
1347 static char last_ptr_line[255] = { 0, };
1348 char new_line[sizeof(last_kbd_line)];
1349 Bool checked_kbd = False, kbd_changed = False;
1350 Bool checked_ptr = False, ptr_changed = False;
1351 int i8042_count = 0;
1355 /* First time -- open the file. */
1356 f0 = fopen (PROC_INTERRUPTS, "r");
1360 sprintf(buf, "%s: error opening %s", blurb(), PROC_INTERRUPTS);
1365 # if defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
1366 /* Close this fd upon exec instead of inheriting / leaking it. */
1367 if (fcntl (fileno (f0), F_SETFD, FD_CLOEXEC) != 0)
1368 perror ("fcntl: CLOEXEC:");
1372 if (f0 == (FILE *) -1) /* means we got an error initializing. */
1375 fd = dup (fileno (f0));
1379 sprintf(buf, "%s: could not dup() the %s fd", blurb(), PROC_INTERRUPTS);
1384 f1 = fdopen (fd, "r");
1388 sprintf(buf, "%s: could not fdopen() the %s fd", blurb(),
1394 /* Actually, I'm unclear on why this fseek() is necessary, given the timing
1395 of the dup() above, but it is. */
1396 if (fseek (f1, 0, SEEK_SET) != 0)
1399 sprintf(buf, "%s: error rewinding %s", blurb(), PROC_INTERRUPTS);
1404 /* Now read through the pseudo-file until we find the "keyboard",
1405 "PS/2 mouse", or "i8042" lines. */
1407 while (fgets (new_line, sizeof(new_line)-1, f1))
1409 Bool i8042_p = !!strstr (new_line, "i8042");
1410 if (i8042_p) i8042_count++;
1412 if (strchr (new_line, ','))
1414 /* Ignore any line that has a comma on it: this is because
1417 12: 930935 XT-PIC usb-uhci, PS/2 Mouse
1419 is really bad news. It *looks* like we can note mouse
1420 activity from that line, but really, that interrupt gets
1421 fired any time any USB device has activity! So we have
1422 to ignore any shared IRQs.
1425 else if (!checked_kbd &&
1426 (strstr (new_line, "keyboard") ||
1427 (i8042_p && i8042_count == 1)))
1429 /* Assume the keyboard interrupt is the line that says "keyboard",
1430 or the *first* line that says "i8042".
1432 kbd_changed = (*last_kbd_line && !!strcmp (new_line, last_kbd_line));
1433 strcpy (last_kbd_line, new_line);
1436 else if (!checked_ptr &&
1437 (strstr (new_line, "PS/2 Mouse") ||
1438 (i8042_p && i8042_count == 2)))
1440 /* Assume the mouse interrupt is the line that says "PS/2 mouse",
1441 or the *second* line that says "i8042".
1443 ptr_changed = (*last_ptr_line && !!strcmp (new_line, last_ptr_line));
1444 strcpy (last_ptr_line, new_line);
1448 if (checked_kbd && checked_ptr)
1452 if (checked_kbd || checked_ptr)
1456 if (si->prefs.debug_p && (kbd_changed || ptr_changed))
1457 fprintf (stderr, "%s: /proc/interrupts activity: %s\n",
1459 ((kbd_changed && ptr_changed) ? "mouse and kbd" :
1460 kbd_changed ? "kbd" :
1461 ptr_changed ? "mouse" : "ERR"));
1463 return (kbd_changed || ptr_changed);
1467 /* If we got here, we didn't find either a "keyboard" or a "PS/2 Mouse"
1468 line in the file at all. */
1469 fprintf (stderr, "%s: no keyboard or mouse data in %s?\n",
1470 blurb(), PROC_INTERRUPTS);
1476 if (f0 && f0 != (FILE *) -1)
1483 #endif /* HAVE_PROC_INTERRUPTS */
1486 /* This timer goes off every few minutes, whether the user is idle or not,
1487 to try and clean up anything that has gone wrong.
1489 It calls disable_builtin_screensaver() so that if xset has been used,
1490 or some other program (like xlock) has messed with the XSetScreenSaver()
1491 settings, they will be set back to sensible values (if a server extension
1492 is in use, messing with xlock can cause xscreensaver to never get a wakeup
1493 event, and could cause monitor power-saving to occur, and all manner of
1496 If the screen is currently blanked, it raises the window, in case some
1497 other window has been mapped on top of it.
1499 If the screen is currently blanked, and there is no hack running, it
1500 clears the window, in case there is an error message printed on it (we
1501 don't want the error message to burn in.)
1505 watchdog_timer (XtPointer closure, XtIntervalId *id)
1507 saver_info *si = (saver_info *) closure;
1508 saver_preferences *p = &si->prefs;
1510 disable_builtin_screensaver (si, False);
1512 /* If the DPMS settings on the server have changed, change them back to
1513 what ~/.xscreensaver says they should be. */
1514 sync_server_dpms_settings (si->dpy,
1515 (p->dpms_enabled_p &&
1516 p->mode != DONT_BLANK),
1517 p->dpms_standby / 1000,
1518 p->dpms_suspend / 1000,
1522 if (si->screen_blanked_p)
1524 Bool running_p = screenhack_running_p (si);
1528 if (si->prefs.debug_p)
1529 fprintf (stderr, "%s: dialog box is up: not raising screen.\n",
1534 if (si->prefs.debug_p)
1535 fprintf (stderr, "%s: watchdog timer raising %sscreen.\n",
1536 blurb(), (running_p ? "" : "and clearing "));
1538 raise_window (si, True, True, running_p);
1541 if (screenhack_running_p (si) &&
1542 !monitor_powered_on_p (si))
1545 if (si->prefs.verbose_p)
1547 "%s: X says monitor has powered down; "
1548 "killing running hacks.\n", blurb());
1549 for (i = 0; i < si->nscreens; i++)
1550 kill_screenhack (&si->screens[i]);
1553 /* Re-schedule this timer. The watchdog timer defaults to a bit less
1554 than the hack cycle period, but is never longer than one hour.
1556 si->watchdog_id = 0;
1557 reset_watchdog_timer (si, True);
1563 reset_watchdog_timer (saver_info *si, Bool on_p)
1565 saver_preferences *p = &si->prefs;
1567 if (si->watchdog_id)
1569 XtRemoveTimeOut (si->watchdog_id);
1570 si->watchdog_id = 0;
1573 if (on_p && p->watchdog_timeout)
1575 si->watchdog_id = XtAppAddTimeOut (si->app, p->watchdog_timeout,
1576 watchdog_timer, (XtPointer) si);
1579 fprintf (stderr, "%s: restarting watchdog_timer (%ld, %ld)\n",
1580 blurb(), p->watchdog_timeout, si->watchdog_id);
1585 /* It's possible that a race condition could have led to the saver
1586 window being unexpectedly still mapped. This can happen like so:
1590 - that hack tries to grab a screen image (it does this by
1591 first unmapping the saver window, then remapping it.)
1592 - hack unmaps window
1594 - user becomes active
1595 - hack re-maps window (*)
1596 - driver kills subprocess
1597 - driver unmaps window (**)
1599 The race is that (*) might have been sent to the server before
1600 the client process was killed, but, due to scheduling randomness,
1601 might not have been received by the server until after (**).
1602 In other words, (*) and (**) might happen out of order, meaning
1603 the driver will unmap the window, and then after that, the
1604 recently-dead client will re-map it. This leaves the user
1605 locked out (it looks like a desktop, but it's not!)
1607 To avoid this: after un-blanking the screen, we launch a timer
1608 that wakes up once a second for ten seconds, and makes damned
1609 sure that the window is still unmapped.
1613 de_race_timer (XtPointer closure, XtIntervalId *id)
1615 saver_info *si = (saver_info *) closure;
1616 saver_preferences *p = &si->prefs;
1619 if (id == 0) /* if id is 0, this is the initialization call. */
1621 si->de_race_ticks = 10;
1623 fprintf (stderr, "%s: starting de-race timer (%d seconds.)\n",
1624 blurb(), si->de_race_ticks);
1629 XSync (si->dpy, False);
1630 for (i = 0; i < si->nscreens; i++)
1632 saver_screen_info *ssi = &si->screens[i];
1633 Window w = ssi->screensaver_window;
1634 XWindowAttributes xgwa;
1635 XGetWindowAttributes (si->dpy, w, &xgwa);
1636 if (xgwa.map_state != IsUnmapped)
1640 "%s: %d: client race! emergency unmap 0x%lx.\n",
1641 blurb(), i, (unsigned long) w);
1642 XUnmapWindow (si->dpy, w);
1644 else if (p->debug_p)
1645 fprintf (stderr, "%s: %d: (de-race of 0x%lx is cool.)\n",
1646 blurb(), i, (unsigned long) w);
1648 XSync (si->dpy, False);
1650 si->de_race_ticks--;
1653 if (id && *id == si->de_race_id)
1656 if (si->de_race_id) abort();
1658 if (si->de_race_ticks <= 0)
1662 fprintf (stderr, "%s: de-race completed.\n", blurb());
1666 si->de_race_id = XtAppAddTimeOut (si->app, secs * 1000,
1667 de_race_timer, closure);