xautolock_diy.c

   1 /*****************************************************************************
   2  *
   3  * Authors: Michel Eyckmans (MCE) & Stefan De Troch (SDT)
   4  *
   5  * Content: This file is part of version 2.x of xautolock. It implements
   6  *          the stuff used when the program is not using a screen saver
   7  *          extension and thus has to use the good old "do it yourself"
   8  *          approach for detecting user activity.
   9  *
  10  *          The basic idea is that we initially traverse the window tree,
  11  *          selecting SubstructureNotify on all windows and adding each
  12  *          window to a temporary list. About +- 30 seconds later, we
  13  *          scan this list, now asking for KeyPress events. The delay
  14  *          is needed in order to interfere as little as possible with
  15  *          the event propagation mechanism. Whenever a new window is
  16  *          created by an application, a similar process takes place.
  17  *
  18  *          Please send bug reports etc. to eyckmans@imec.be.
  19  *
  20  * --------------------------------------------------------------------------
  21  *
  22  * Copyright 1990,1992-1999,2001-2002 by Stefan De Troch and Michel Eyckmans.
  23  *
  24  * Versions 2.0 and above of xautolock are available under version 2 of the
  25  * GNU GPL. Earlier versions are available under other conditions. For more
  26  * information, see the License file.
  27  *
  28  *****************************************************************************/
  29
  30 #include <X11/Xlib.h>
  31 #include <stdlib.h>
  32 #include <time.h>
  33
  34 #include "xautolock_c.h"
  35
  36 static void selectEvents (Window window, Bool substructureOnly);
  37
  38 /*
  39  *  Window queue management.
  40  */
  41 typedef struct item
  42 {
  43   Window       window;
  44   time_t       creationtime;
  45   struct item* next;
  46 } xautolock_anItem, *xautolock_item;
  47
  48 static struct
  49 {
  50   Display*     display;
  51   struct item* head;
  52   struct item* tail;
  53 } queue;
  54
  55 static void
  56 addToQueue (Window window)
  57 {
  58   xautolock_item newItem = malloc(sizeof(xautolock_anItem));
  59
  60   newItem->window = window;
  61   newItem->creationtime = time (0);
  62   newItem->next = 0;
  63
  64   if (!queue.head) queue.head = newItem;
  65   if ( queue.tail) queue.tail->next = newItem;
  66
  67   queue.tail = newItem;
  68 }
  69
  70 static void
  71 processQueue (time_t age)
  72 {
  73   if (queue.head)
  74   {
  75     time_t now = time (0);
  76     xautolock_item current = queue.head;
  77
  78     while (current && current->creationtime + age < now)
  79     {
  80       selectEvents (current->window, False);
  81       queue.head = current->next;
  82       free (current);
  83       current = queue.head;
  84     }
  85
  86     if (!queue.head) queue.tail = 0;
  87   }
  88 }
  89
  90 /*
  91  *  Function for selecting all interesting events on a given
  92  *  (tree of) window(s).
  93  */
  94 static void
  95 selectEvents (Window window, Bool substructureOnly)
  96 {
  97   Window            root;              /* root window of the window */
  98   Window            parent;            /* parent of the window      */
  99   Window*           children;          /* children of the window    */
 100   unsigned          nofChildren = 0;   /* number of children        */
 101   unsigned          i;                 /* loop counter              */
 102   XWindowAttributes attribs;           /* attributes of the window  */
 103
 104   if( xautolock_ignoreWindow( window ))
 105       return;
 106  /*
 107   *  Start by querying the server about the root and parent windows.
 108   */
 109   if (!XQueryTree (queue.display, window, &root, &parent,
 110                    &children, &nofChildren))
 111   {
 112     return;
 113   }
 114
 115   if (nofChildren) (void) XFree ((char*) children);
 116
 117  /*
 118   *  Build the appropriate event mask. The basic idea is that we don't
 119   *  want to interfere with the normal event propagation mechanism if
 120   *  we don't have to.
 121   *
 122   *  On the root window, we need to ask for both substructureNotify
 123   *  and KeyPress events. On all other windows, we always need
 124   *  substructureNotify, but only need Keypress if some other client
 125   *  also asked for them, or if they are not being propagated up the
 126   *  window tree.
 127   */
 128 #if 0
 129   if (substructureOnly)
 130   {
 131     (void) XSelectInput (queue.display, window, SubstructureNotifyMask);
 132   }
 133   else
 134   {
 135     if (parent == None) /* the *real* rootwindow */
 136     {
 137       attribs.all_event_masks =
 138       attribs.do_not_propagate_mask = KeyPressMask;
 139     }
 140     else if (!XGetWindowAttributes (queue.display, window, &attribs))
 141 #else
 142     {
 143     if (!XGetWindowAttributes (queue.display, window, &attribs))
 144 #endif
 145     {
 146       return;
 147     }
 148
 149 #if 0
 150     (void) XSelectInput (queue.display, window,
 151                            SubstructureNotifyMask
 152                          | (  (  attribs.all_event_masks
 153                                | attribs.do_not_propagate_mask)
 154                             & KeyPressMask));
 155 #else
 156     {
 157     int mask = SubstructureNotifyMask | attribs.your_event_mask;
 158     if( !substructureOnly )
 159         {
 160         mask |=            (  (  attribs.all_event_masks
 161                                | attribs.do_not_propagate_mask)
 162                             & KeyPressMask  );
 163         }
 164     (void) XSelectInput (queue.display, window, mask );
 165     }
 166 #endif
 167
 168   }
 169
 170  /*
 171   *  Now ask for the list of children again, since it might have changed
 172   *  in between the last time and us selecting SubstructureNotifyMask.
 173   *
 174   *  There is a (very small) chance that we might process a subtree twice:
 175   *  child windows that have been created after our XSelectinput() has
 176   *  been processed but before we get to the XQueryTree() bit will be
 177   *  in this situation. This is harmless. It could be avoided by using
 178   *  XGrabServer(), but that'd be an impolite thing to do, and since it
 179   *  isn't required...
 180   */
 181   if (!XQueryTree (queue.display, window, &root, &parent,
 182                    &children, &nofChildren))
 183   {
 184     return;
 185   }
 186
 187  /*
 188   *  Now do the same thing for all children.
 189   */
 190   for (i = 0; i < nofChildren; ++i)
 191   {
 192     selectEvents (children[i], substructureOnly);
 193   }
 194
 195   if (nofChildren) (void) XFree ((char*) children);
 196 }
 197
 198 #if 0
 199 /*
 200  *  Function for processing any events that have come in since
 201  *  last time. It is crucial that this function does not block
 202  *  in case nothing interesting happened.
 203  */
 204 void
 205 processEvents (void)
 206 {
 207   while (XPending (queue.display))
 208   {
 209     XEvent event;
 210
 211     if (XCheckMaskEvent (queue.display, SubstructureNotifyMask, &event))
 212     {
 213       if (event.type == CreateNotify)
 214       {
 215         addToQueue (event.xcreatewindow.window);
 216       }
 217     }
 218     else
 219     {
 220       (void) XNextEvent (queue.display, &event);
 221     }
 222
 223    /*
 224     *  Reset the triggers if and only if the event is a
 225     *  KeyPress event *and* was not generated by XSendEvent().
 226     */
 227     if (   event.type == KeyPress
 228         && !event.xany.send_event)
 229     {
 230       resetTriggers ();
 231     }
 232   }
 233
 234  /*
 235   *  Check the window queue for entries that are older than
 236   *  CREATION_DELAY seconds.
 237   */
 238   processQueue ((time_t) CREATION_DELAY);
 239 }
 240 #else
 241 void xautolock_processEvent( XEvent* event )
 242 {
 243       if (event->type == CreateNotify)
 244       {
 245         addToQueue (event->xcreatewindow.window);
 246       }
 247    /*
 248     *  Reset the triggers if and only if the event is a
 249     *  KeyPress event *and* was not generated by XSendEvent().
 250     */
 251     if (   event->type == KeyPress
 252         && !event->xany.send_event)
 253     {
 254       xautolock_resetTriggers ();
 255     }
 256 }
 257
 258 void xautolock_processQueue()
 259 {
 260  /*
 261   *  Check the window queue for entries that are older than
 262   *  CREATION_DELAY seconds.
 263   */
 264   processQueue ((time_t) CREATION_DELAY);
 265 }
 266 #endif
 267
 268
 269 /*
 270  *  Function for initialising the whole shebang.
 271  */
 272 void
 273 xautolock_initDiy (Display* d)
 274 {
 275   int s;
 276
 277   queue.display = d;
 278   queue.tail = 0;
 279   queue.head = 0;
 280
 281   for (s = -1; ++s < ScreenCount (d); )
 282   {
 283     Window root = RootWindowOfScreen (ScreenOfDisplay (d, s));
 284     addToQueue (root);
 285 #if 0
 286     selectEvents (root, True);
 287 #endif
 288   }
 289 }