5c4700ae8e226a0882290e442d94d7234c77392c
[mikachu/openbox.git] / openbox / event.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    event.c for the Openbox window manager
4    Copyright (c) 2006        Mikael Magnusson
5    Copyright (c) 2003-2007   Dana Jansens
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "event.h"
21 #include "debug.h"
22 #include "window.h"
23 #include "openbox.h"
24 #include "dock.h"
25 #include "actions.h"
26 #include "client.h"
27 #include "xerror.h"
28 #include "prop.h"
29 #include "config.h"
30 #include "screen.h"
31 #include "frame.h"
32 #include "grab.h"
33 #include "menu.h"
34 #include "prompt.h"
35 #include "menuframe.h"
36 #include "keyboard.h"
37 #include "modkeys.h"
38 #include "mouse.h"
39 #include "mainloop.h"
40 #include "focus.h"
41 #include "focus_cycle.h"
42 #include "moveresize.h"
43 #include "group.h"
44 #include "stacking.h"
45 #include "extensions.h"
46 #include "translate.h"
47 #include "ping.h"
48
49 #include <X11/Xlib.h>
50 #include <X11/Xatom.h>
51 #include <glib.h>
52
53 #ifdef HAVE_SYS_SELECT_H
54 #  include <sys/select.h>
55 #endif
56 #ifdef HAVE_SIGNAL_H
57 #  include <signal.h>
58 #endif
59 #ifdef HAVE_UNISTD_H
60 #  include <unistd.h> /* for usleep() */
61 #endif
62 #ifdef XKB
63 #  include <X11/XKBlib.h>
64 #endif
65
66 #ifdef USE_SM
67 #include <X11/ICE/ICElib.h>
68 #endif
69
70 typedef struct
71 {
72     gboolean ignored;
73 } ObEventData;
74
75 typedef struct
76 {
77     ObClient *client;
78     Time time;
79     gulong serial;
80 } ObFocusDelayData;
81
82 typedef struct
83 {
84     gulong start; /* inclusive */
85     gulong end;   /* inclusive */
86 } ObSerialRange;
87
88 static void event_process(const XEvent *e, gpointer data);
89 static void event_handle_root(XEvent *e);
90 static gboolean event_handle_menu_keyboard(XEvent *e);
91 static gboolean event_handle_menu(XEvent *e);
92 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e);
93 static void event_handle_dock(ObDock *s, XEvent *e);
94 static void event_handle_dockapp(ObDockApp *app, XEvent *e);
95 static void event_handle_client(ObClient *c, XEvent *e);
96 static void event_handle_user_input(ObClient *client, XEvent *e);
97 static gboolean is_enter_focus_event_ignored(gulong serial);
98 static void event_ignore_enter_range(gulong start, gulong end);
99
100 static void focus_delay_dest(gpointer data);
101 static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2);
102 static gboolean focus_delay_func(gpointer data);
103 static void focus_delay_client_dest(ObClient *client, gpointer data);
104
105 Time event_curtime = CurrentTime;
106 Time event_last_user_time = CurrentTime;
107 /*! The serial of the current X event */
108
109 static gulong event_curserial;
110 static gboolean focus_left_screen = FALSE;
111 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
112 static GSList *ignore_serials = NULL;
113
114 #ifdef USE_SM
115 static void ice_handler(gint fd, gpointer conn)
116 {
117     Bool b;
118     IceProcessMessages(conn, NULL, &b);
119 }
120
121 static void ice_watch(IceConn conn, IcePointer data, Bool opening,
122                       IcePointer *watch_data)
123 {
124     static gint fd = -1;
125
126     if (opening) {
127         fd = IceConnectionNumber(conn);
128         ob_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
129     } else {
130         ob_main_loop_fd_remove(ob_main_loop, fd);
131         fd = -1;
132     }
133 }
134 #endif
135
136 void event_startup(gboolean reconfig)
137 {
138     if (reconfig) return;
139
140     ob_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
141
142 #ifdef USE_SM
143     IceAddConnectionWatch(ice_watch, NULL);
144 #endif
145
146     client_add_destroy_notify(focus_delay_client_dest, NULL);
147 }
148
149 void event_shutdown(gboolean reconfig)
150 {
151     if (reconfig) return;
152
153 #ifdef USE_SM
154     IceRemoveConnectionWatch(ice_watch, NULL);
155 #endif
156
157     client_remove_destroy_notify(focus_delay_client_dest);
158 }
159
160 static Window event_get_window(XEvent *e)
161 {
162     Window window;
163
164     /* pick a window */
165     switch (e->type) {
166     case SelectionClear:
167         window = RootWindow(ob_display, ob_screen);
168         break;
169     case MapRequest:
170         window = e->xmap.window;
171         break;
172     case UnmapNotify:
173         window = e->xunmap.window;
174         break;
175     case DestroyNotify:
176         window = e->xdestroywindow.window;
177         break;
178     case ConfigureRequest:
179         window = e->xconfigurerequest.window;
180         break;
181     case ConfigureNotify:
182         window = e->xconfigure.window;
183         break;
184     default:
185 #ifdef XKB
186         if (extensions_xkb && e->type == extensions_xkb_event_basep) {
187             switch (((XkbAnyEvent*)e)->xkb_type) {
188             case XkbBellNotify:
189                 window = ((XkbBellNotifyEvent*)e)->window;
190             default:
191                 window = None;
192             }
193         } else
194 #endif
195 #ifdef SYNC
196         if (extensions_sync &&
197             e->type == extensions_sync_event_basep + XSyncAlarmNotify)
198         {
199             window = None;
200         } else
201 #endif
202             window = e->xany.window;
203     }
204     return window;
205 }
206
207 static void event_set_curtime(XEvent *e)
208 {
209     Time t = CurrentTime;
210
211     /* grab the lasttime and hack up the state */
212     switch (e->type) {
213     case ButtonPress:
214     case ButtonRelease:
215         t = e->xbutton.time;
216         break;
217     case KeyPress:
218         t = e->xkey.time;
219         break;
220     case KeyRelease:
221         t = e->xkey.time;
222         break;
223     case MotionNotify:
224         t = e->xmotion.time;
225         break;
226     case PropertyNotify:
227         t = e->xproperty.time;
228         break;
229     case EnterNotify:
230     case LeaveNotify:
231         t = e->xcrossing.time;
232         break;
233     default:
234 #ifdef SYNC
235         if (extensions_sync &&
236             e->type == extensions_sync_event_basep + XSyncAlarmNotify)
237         {
238             t = ((XSyncAlarmNotifyEvent*)e)->time;
239         }
240 #endif
241         /* if more event types are anticipated, get their timestamp
242            explicitly */
243         break;
244     }
245
246     /* watch that if we get an event earlier than the last specified user_time,
247        which can happen if the clock goes backwards, we erase the last
248        specified user_time */
249     if (t && event_last_user_time && event_time_after(event_last_user_time, t))
250         event_last_user_time = CurrentTime;
251
252     event_curtime = t;
253 }
254
255 static void event_hack_mods(XEvent *e)
256 {
257 #ifdef XKB
258     XkbStateRec xkb_state;
259 #endif
260
261     switch (e->type) {
262     case ButtonPress:
263     case ButtonRelease:
264         e->xbutton.state = modkeys_only_modifier_masks(e->xbutton.state);
265         break;
266     case KeyPress:
267         e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
268         break;
269     case KeyRelease:
270 #ifdef XKB
271         /* If XKB is present, then the modifiers are all strange from its
272            magic.  Our X core protocol stuff won't work, so we use this to
273            find what the modifier state is instead. */
274         if (XkbGetState(ob_display, XkbUseCoreKbd, &xkb_state) == Success)
275             e->xkey.state =
276                 modkeys_only_modifier_masks(xkb_state.compat_state);
277         else
278 #endif
279         {
280             e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
281             /* remove from the state the mask of the modifier key being
282                released, if it is a modifier key being released that is */
283             e->xkey.state &= ~modkeys_keycode_to_mask(e->xkey.keycode);
284         }
285         break;
286     case MotionNotify:
287         e->xmotion.state = modkeys_only_modifier_masks(e->xmotion.state);
288         /* compress events */
289         {
290             XEvent ce;
291             while (XCheckTypedWindowEvent(ob_display, e->xmotion.window,
292                                           e->type, &ce)) {
293                 e->xmotion.x = ce.xmotion.x;
294                 e->xmotion.y = ce.xmotion.y;
295                 e->xmotion.x_root = ce.xmotion.x_root;
296                 e->xmotion.y_root = ce.xmotion.y_root;
297             }
298         }
299         break;
300     }
301 }
302
303 static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
304 {
305     gint mode = e->xfocus.mode;
306     gint detail = e->xfocus.detail;
307     Window win = e->xany.window;
308
309     if (e->type == FocusIn) {
310         /* These are ones we never want.. */
311
312         /* This means focus was given by a keyboard/mouse grab. */
313         if (mode == NotifyGrab)
314             return FALSE;
315         /* This means focus was given back from a keyboard/mouse grab. */
316         if (mode == NotifyUngrab)
317             return FALSE;
318
319         /* These are the ones we want.. */
320
321         if (win == RootWindow(ob_display, ob_screen)) {
322             /* If looking for a focus in on a client, then always return
323                FALSE for focus in's to the root window */
324             if (in_client_only)
325                 return FALSE;
326             /* This means focus reverted off of a client */
327             else if (detail == NotifyPointerRoot ||
328                      detail == NotifyDetailNone ||
329                      detail == NotifyInferior ||
330                      /* This means focus got here from another screen */
331                      detail == NotifyNonlinear)
332                 return TRUE;
333             else
334                 return FALSE;
335         }
336
337         /* It was on a client, was it a valid one?
338            It's possible to get a FocusIn event for a client that was managed
339            but has disappeared.
340         */
341         if (in_client_only) {
342             ObWindow *w = g_hash_table_lookup(window_map, &e->xfocus.window);
343             if (!w || !WINDOW_IS_CLIENT(w))
344                 return FALSE;
345         }
346         else {
347             /* This means focus reverted to parent from the client (this
348                happens often during iconify animation) */
349             if (detail == NotifyInferior)
350                 return TRUE;
351         }
352
353         /* This means focus moved from the root window to a client */
354         if (detail == NotifyVirtual)
355             return TRUE;
356         /* This means focus moved from one client to another */
357         if (detail == NotifyNonlinearVirtual)
358             return TRUE;
359
360         /* Otherwise.. */
361         return FALSE;
362     } else {
363         g_assert(e->type == FocusOut);
364
365         /* These are ones we never want.. */
366
367         /* This means focus was taken by a keyboard/mouse grab. */
368         if (mode == NotifyGrab)
369             return FALSE;
370         /* This means focus was grabbed on a window and it was released. */
371         if (mode == NotifyUngrab)
372             return FALSE;
373
374         /* Focus left the root window revertedto state */
375         if (win == RootWindow(ob_display, ob_screen))
376             return FALSE;
377
378         /* These are the ones we want.. */
379
380         /* This means focus moved from a client to the root window */
381         if (detail == NotifyVirtual)
382             return TRUE;
383         /* This means focus moved from one client to another */
384         if (detail == NotifyNonlinearVirtual)
385             return TRUE;
386
387         /* Otherwise.. */
388         return FALSE;
389     }
390 }
391
392 static Bool event_look_for_focusin(Display *d, XEvent *e, XPointer arg)
393 {
394     return e->type == FocusIn && wanted_focusevent(e, FALSE);
395 }
396
397 static Bool event_look_for_focusin_client(Display *d, XEvent *e, XPointer arg)
398 {
399     return e->type == FocusIn && wanted_focusevent(e, TRUE);
400 }
401
402 static void print_focusevent(XEvent *e)
403 {
404     gint mode = e->xfocus.mode;
405     gint detail = e->xfocus.detail;
406     Window win = e->xany.window;
407     const gchar *modestr, *detailstr;
408
409     switch (mode) {
410     case NotifyNormal:       modestr="NotifyNormal";       break;
411     case NotifyGrab:         modestr="NotifyGrab";         break;
412     case NotifyUngrab:       modestr="NotifyUngrab";       break;
413     case NotifyWhileGrabbed: modestr="NotifyWhileGrabbed"; break;
414     }
415     switch (detail) {
416     case NotifyAncestor:    detailstr="NotifyAncestor";    break;
417     case NotifyVirtual:     detailstr="NotifyVirtual";     break;
418     case NotifyInferior:    detailstr="NotifyInferior";    break;
419     case NotifyNonlinear:   detailstr="NotifyNonlinear";   break;
420     case NotifyNonlinearVirtual: detailstr="NotifyNonlinearVirtual"; break;
421     case NotifyPointer:     detailstr="NotifyPointer";     break;
422     case NotifyPointerRoot: detailstr="NotifyPointerRoot"; break;
423     case NotifyDetailNone:  detailstr="NotifyDetailNone";  break;
424     }
425
426     if (mode == NotifyGrab || mode == NotifyUngrab)
427         return;
428
429     g_assert(modestr);
430     g_assert(detailstr);
431     ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s\n",
432                   (e->xfocus.type == FocusIn ? "In" : "Out"),
433                   win,
434                   modestr, detailstr);
435
436 }
437
438 static gboolean event_ignore(XEvent *e, ObClient *client)
439 {
440     switch(e->type) {
441     case FocusIn:
442         print_focusevent(e);
443         if (!wanted_focusevent(e, FALSE))
444             return TRUE;
445         break;
446     case FocusOut:
447         print_focusevent(e);
448         if (!wanted_focusevent(e, FALSE))
449             return TRUE;
450         break;
451     }
452     return FALSE;
453 }
454
455 static void event_process(const XEvent *ec, gpointer data)
456 {
457     Window window;
458     ObClient *client = NULL;
459     ObDock *dock = NULL;
460     ObDockApp *dockapp = NULL;
461     ObWindow *obwin = NULL;
462     XEvent ee, *e;
463     ObEventData *ed = data;
464     ObPrompt *prompt = NULL;
465
466     /* make a copy we can mangle */
467     ee = *ec;
468     e = &ee;
469
470     window = event_get_window(e);
471     if ((obwin = g_hash_table_lookup(window_map, &window))) {
472         switch (obwin->type) {
473         case Window_Dock:
474             dock = WINDOW_AS_DOCK(obwin);
475             break;
476         case Window_DockApp:
477             dockapp = WINDOW_AS_DOCKAPP(obwin);
478             break;
479         case Window_Client:
480             client = WINDOW_AS_CLIENT(obwin);
481             /* events on clients can be events on prompt windows too */
482             prompt = client->prompt;
483             break;
484         case Window_Menu:
485             /* not to be used for events */
486             g_assert_not_reached();
487             break;
488         case Window_Internal:
489             /* we don't do anything with events directly on these windows */
490             break;
491         case Window_Prompt:
492             prompt = WINDOW_AS_PROMPT(obwin);
493             break;
494         }
495     }
496
497     event_set_curtime(e);
498     event_curserial = e->xany.serial;
499     event_hack_mods(e);
500     if (event_ignore(e, client)) {
501         if (ed)
502             ed->ignored = TRUE;
503         return;
504     } else if (ed)
505             ed->ignored = FALSE;
506
507     /* deal with it in the kernel */
508
509     if (menu_frame_visible &&
510         (e->type == EnterNotify || e->type == LeaveNotify))
511     {
512         /* crossing events for menu */
513         event_handle_menu(e);
514     } else if (e->type == FocusIn) {
515         if (client &&
516             e->xfocus.detail == NotifyInferior)
517         {
518             ob_debug_type(OB_DEBUG_FOCUS,
519                           "Focus went to the frame window");
520
521             focus_left_screen = FALSE;
522
523             focus_fallback(FALSE, config_focus_under_mouse, TRUE, TRUE);
524
525             /* We don't get a FocusOut for this case, because it's just moving
526                from our Inferior up to us. This happens when iconifying a
527                window with RevertToParent focus */
528             frame_adjust_focus(client->frame, FALSE);
529             /* focus_set_client(NULL) has already been called */
530         }
531         else if (e->xfocus.detail == NotifyPointerRoot ||
532                  e->xfocus.detail == NotifyDetailNone ||
533                  e->xfocus.detail == NotifyInferior ||
534                  e->xfocus.detail == NotifyNonlinear)
535         {
536             XEvent ce;
537
538             ob_debug_type(OB_DEBUG_FOCUS,
539                           "Focus went to root or pointer root/none\n");
540
541             if (e->xfocus.detail == NotifyInferior ||
542                 e->xfocus.detail == NotifyNonlinear)
543             {
544                 focus_left_screen = FALSE;
545             }
546
547             /* If another FocusIn is in the queue then don't fallback yet. This
548                fixes the fun case of:
549                window map -> send focusin
550                window unmap -> get focusout
551                window map -> send focusin
552                get first focus out -> fall back to something (new window
553                  hasn't received focus yet, so something else) -> send focusin
554                which means the "something else" is the last thing to get a
555                focusin sent to it, so the new window doesn't end up with focus.
556
557                But if the other focus in is something like PointerRoot then we
558                still want to fall back.
559             */
560             if (XCheckIfEvent(ob_display, &ce, event_look_for_focusin_client,
561                               NULL))
562             {
563                 XPutBackEvent(ob_display, &ce);
564                 ob_debug_type(OB_DEBUG_FOCUS,
565                               "  but another FocusIn is coming\n");
566             } else {
567                 /* Focus has been reverted.
568
569                    FocusOut events come after UnmapNotify, so we don't need to
570                    worry about focusing an invalid window
571                 */
572
573                 if (!focus_left_screen)
574                     focus_fallback(FALSE, config_focus_under_mouse,
575                                    TRUE, TRUE);
576             }
577         }
578         else if (!client)
579         {
580             ob_debug_type(OB_DEBUG_FOCUS,
581                           "Focus went to a window that is already gone\n");
582
583             /* If you send focus to a window and then it disappears, you can
584                get the FocusIn for it, after it is unmanaged.
585                Just wait for the next FocusOut/FocusIn pair, but make note that
586                the window that was focused no longer is. */
587             focus_set_client(NULL);
588         }
589         else if (client != focus_client) {
590             focus_left_screen = FALSE;
591             frame_adjust_focus(client->frame, TRUE);
592             focus_set_client(client);
593             client_calc_layer(client);
594             client_bring_helper_windows(client);
595         }
596     } else if (e->type == FocusOut) {
597         XEvent ce;
598
599         /* Look for the followup FocusIn */
600         if (!XCheckIfEvent(ob_display, &ce, event_look_for_focusin, NULL)) {
601             /* There is no FocusIn, this means focus went to a window that
602                is not being managed, or a window on another screen. */
603             Window win, root;
604             gint i;
605             guint u;
606             xerror_set_ignore(TRUE);
607             if (XGetInputFocus(ob_display, &win, &i) != 0 &&
608                 XGetGeometry(ob_display, win, &root, &i,&i,&u,&u,&u,&u) != 0 &&
609                 root != RootWindow(ob_display, ob_screen))
610             {
611                 ob_debug_type(OB_DEBUG_FOCUS,
612                               "Focus went to another screen !\n");
613                 focus_left_screen = TRUE;
614             }
615             else
616                 ob_debug_type(OB_DEBUG_FOCUS,
617                               "Focus went to a black hole !\n");
618             xerror_set_ignore(FALSE);
619             /* nothing is focused */
620             focus_set_client(NULL);
621         } else {
622             /* Focus moved, so process the FocusIn event */
623             ObEventData ed = { .ignored = FALSE };
624             event_process(&ce, &ed);
625             if (ed.ignored) {
626                 /* The FocusIn was ignored, this means it was on a window
627                    that isn't a client. */
628                 ob_debug_type(OB_DEBUG_FOCUS,
629                               "Focus went to an unmanaged window 0x%x !\n",
630                               ce.xfocus.window);
631                 focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
632             }
633         }
634
635         if (client && client != focus_client) {
636             frame_adjust_focus(client->frame, FALSE);
637             /* focus_set_client(NULL) has already been called in this
638                section or by focus_fallback */
639         }
640     }
641     else if (client)
642         event_handle_client(client, e);
643     else if (dockapp)
644         event_handle_dockapp(dockapp, e);
645     else if (dock)
646         event_handle_dock(dock, e);
647     else if (window == RootWindow(ob_display, ob_screen))
648         event_handle_root(e);
649     else if (e->type == MapRequest)
650         client_manage(window, NULL);
651     else if (e->type == MappingNotify) {
652         /* keyboard layout changes for modifier mapping changes. reload the
653            modifier map, and rebind all the key bindings as appropriate */
654         ob_debug("Kepboard map changed. Reloading keyboard bindings.\n");
655         modkeys_shutdown(TRUE);
656         modkeys_startup(TRUE);
657         keyboard_rebind();
658     }
659     else if (e->type == ClientMessage) {
660         /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
661            windows that are not managed yet. */
662         if (e->xclient.message_type == prop_atoms.net_request_frame_extents) {
663             /* Pretend to manage the client, getting information used to
664                determine its decorations */
665             ObClient *c = client_fake_manage(e->xclient.window);
666             gulong vals[4];
667
668             /* set the frame extents on the window */
669             vals[0] = c->frame->size.left;
670             vals[1] = c->frame->size.right;
671             vals[2] = c->frame->size.top;
672             vals[3] = c->frame->size.bottom;
673             PROP_SETA32(e->xclient.window, net_frame_extents,
674                         cardinal, vals, 4);
675
676             /* Free the pretend client */
677             client_fake_unmanage(c);
678         }
679     }
680     else if (e->type == ConfigureRequest) {
681         /* unhandled configure requests must be used to configure the
682            window directly */
683         XWindowChanges xwc;
684
685         xwc.x = e->xconfigurerequest.x;
686         xwc.y = e->xconfigurerequest.y;
687         xwc.width = e->xconfigurerequest.width;
688         xwc.height = e->xconfigurerequest.height;
689         xwc.border_width = e->xconfigurerequest.border_width;
690         xwc.sibling = e->xconfigurerequest.above;
691         xwc.stack_mode = e->xconfigurerequest.detail;
692
693         /* we are not to be held responsible if someone sends us an
694            invalid request! */
695         xerror_set_ignore(TRUE);
696         XConfigureWindow(ob_display, window,
697                          e->xconfigurerequest.value_mask, &xwc);
698         xerror_set_ignore(FALSE);
699     }
700 #ifdef SYNC
701     else if (extensions_sync &&
702         e->type == extensions_sync_event_basep + XSyncAlarmNotify)
703     {
704         XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
705         if (se->alarm == moveresize_alarm && moveresize_in_progress)
706             moveresize_event(e);
707     }
708 #endif
709
710     if (prompt && event_handle_prompt(prompt, e))
711         ;
712     else if (e->type == ButtonPress || e->type == ButtonRelease) {
713         /* If the button press was on some non-root window, or was physically
714            on the root window, then process it */
715         if (window != RootWindow(ob_display, ob_screen) ||
716             e->xbutton.subwindow == None)
717         {
718             event_handle_user_input(client, e);
719         }
720         /* Otherwise only process it if it was physically on an openbox
721            internal window */
722         else {
723             ObWindow *w;
724
725             if ((w = g_hash_table_lookup(window_map, &e->xbutton.subwindow)) &&
726                 WINDOW_IS_INTERNAL(w))
727             {
728                 event_handle_user_input(client, e);
729             }
730         }
731     }
732     else if (e->type == KeyPress || e->type == KeyRelease ||
733              e->type == MotionNotify)
734         event_handle_user_input(client, e);
735
736     /* if something happens and it's not from an XEvent, then we don't know
737        the time */
738     event_curtime = CurrentTime;
739     event_curserial = 0;
740 }
741
742 static void event_handle_root(XEvent *e)
743 {
744     Atom msgtype;
745
746     switch(e->type) {
747     case SelectionClear:
748         ob_debug("Another WM has requested to replace us. Exiting.\n");
749         ob_exit_replace();
750         break;
751
752     case ClientMessage:
753         if (e->xclient.format != 32) break;
754
755         msgtype = e->xclient.message_type;
756         if (msgtype == prop_atoms.net_current_desktop) {
757             guint d = e->xclient.data.l[0];
758             if (d < screen_num_desktops) {
759                 event_curtime = e->xclient.data.l[1];
760                 if (event_curtime == 0)
761                     ob_debug_type(OB_DEBUG_APP_BUGS,
762                                   "_NET_CURRENT_DESKTOP message is missing "
763                                   "a timestamp\n");
764                 screen_set_desktop(d, TRUE);
765             }
766         } else if (msgtype == prop_atoms.net_number_of_desktops) {
767             guint d = e->xclient.data.l[0];
768             if (d > 0 && d <= 1000)
769                 screen_set_num_desktops(d);
770         } else if (msgtype == prop_atoms.net_showing_desktop) {
771             screen_show_desktop(e->xclient.data.l[0] != 0, NULL);
772         } else if (msgtype == prop_atoms.ob_control) {
773             ob_debug("OB_CONTROL: %d\n", e->xclient.data.l[0]);
774             if (e->xclient.data.l[0] == 1)
775                 ob_reconfigure();
776             else if (e->xclient.data.l[0] == 2)
777                 ob_restart();
778             else if (e->xclient.data.l[0] == 3)
779                 ob_exit(0);
780         } else if (msgtype == prop_atoms.wm_protocols) {
781             if ((Atom)e->xclient.data.l[0] == prop_atoms.net_wm_ping)
782                 ping_got_pong(e->xclient.data.l[1]);
783         }
784         break;
785     case PropertyNotify:
786         if (e->xproperty.atom == prop_atoms.net_desktop_names) {
787             ob_debug("UPDATE DESKTOP NAMES\n");
788             screen_update_desktop_names();
789         }
790         else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
791             screen_update_layout();
792         break;
793     case ConfigureNotify:
794 #ifdef XRANDR
795         XRRUpdateConfiguration(e);
796 #endif
797         screen_resize();
798         break;
799     default:
800         ;
801     }
802 }
803
804 void event_enter_client(ObClient *client)
805 {
806     g_assert(config_focus_follow);
807
808     if (is_enter_focus_event_ignored(event_curserial)) {
809         ob_debug_type(OB_DEBUG_FOCUS, "Ignoring enter event with serial %lu\n"
810                       "on client 0x%x", event_curserial, client->window);
811         return;
812     }
813
814     if (client_enter_focusable(client) && client_can_focus(client)) {
815         if (config_focus_delay) {
816             ObFocusDelayData *data;
817
818             ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
819
820             data = g_new(ObFocusDelayData, 1);
821             data->client = client;
822             data->time = event_curtime;
823             data->serial = event_curserial;
824
825             ob_main_loop_timeout_add(ob_main_loop,
826                                      config_focus_delay * 1000,
827                                      focus_delay_func,
828                                      data, focus_delay_cmp, focus_delay_dest);
829         } else {
830             ObFocusDelayData data;
831             data.client = client;
832             data.time = event_curtime;
833             data.serial = event_curserial;
834             focus_delay_func(&data);
835         }
836     }
837 }
838
839 static gboolean *context_to_button(ObFrame *f, ObFrameContext con, gboolean press)
840 {
841     if (press) {
842         switch (con) {
843         case OB_FRAME_CONTEXT_MAXIMIZE:
844             return &f->max_press;
845         case OB_FRAME_CONTEXT_CLOSE:
846             return &f->close_press;
847         case OB_FRAME_CONTEXT_ICONIFY:
848             return &f->iconify_press;
849         case OB_FRAME_CONTEXT_ALLDESKTOPS:
850             return &f->desk_press;
851         case OB_FRAME_CONTEXT_SHADE:
852             return &f->shade_press;
853         default:
854             return NULL;
855         }
856     } else {
857         switch (con) {
858         case OB_FRAME_CONTEXT_MAXIMIZE:
859             return &f->max_hover;
860         case OB_FRAME_CONTEXT_CLOSE:
861             return &f->close_hover;
862         case OB_FRAME_CONTEXT_ICONIFY:
863             return &f->iconify_hover;
864         case OB_FRAME_CONTEXT_ALLDESKTOPS:
865             return &f->desk_hover;
866         case OB_FRAME_CONTEXT_SHADE:
867             return &f->shade_hover;
868         default:
869             return NULL;
870         }
871     }
872 }
873
874 static void compress_client_message_event(XEvent *e, XEvent *ce, Window window,
875                                           Atom msgtype)
876 {
877     /* compress changes into a single change */
878     while (XCheckTypedWindowEvent(ob_display, window, e->type, ce)) {
879         /* XXX: it would be nice to compress ALL messages of a
880            type, not just messages in a row without other
881            message types between. */
882         if (ce->xclient.message_type != msgtype) {
883             XPutBackEvent(ob_display, ce);
884             break;
885         }
886         e->xclient = ce->xclient;
887     }
888 }
889
890 static void event_handle_client(ObClient *client, XEvent *e)
891 {
892     XEvent ce;
893     Atom msgtype;
894     ObFrameContext con;
895     gboolean *but;
896     static gint px = -1, py = -1;
897     static guint pb = 0;
898     static ObFrameContext pcon = OB_FRAME_CONTEXT_NONE;
899
900     switch (e->type) {
901     case ButtonPress:
902         /* save where the press occured for the first button pressed */
903         if (!pb) {
904             pb = e->xbutton.button;
905             px = e->xbutton.x;
906             py = e->xbutton.y;
907
908             pcon = frame_context(client, e->xbutton.window, px, py);
909             pcon = mouse_button_frame_context(pcon, e->xbutton.button,
910                                               e->xbutton.state);
911         }
912     case ButtonRelease:
913         /* Wheel buttons don't draw because they are an instant click, so it
914            is a waste of resources to go drawing it.
915            if the user is doing an interactive thing, or has a menu open then
916            the mouse is grabbed (possibly) and if we get these events we don't
917            want to deal with them
918         */
919         if (!(e->xbutton.button == 4 || e->xbutton.button == 5) &&
920             !grab_on_keyboard())
921         {
922             /* use where the press occured */
923             con = frame_context(client, e->xbutton.window, px, py);
924             con = mouse_button_frame_context(con, e->xbutton.button,
925                                              e->xbutton.state);
926
927             /* button presses on CLIENT_CONTEXTs are not accompanied by a
928                release because they are Replayed to the client */
929             if ((e->type == ButtonRelease || CLIENT_CONTEXT(con, client)) &&
930                 e->xbutton.button == pb)
931                 pb = 0, px = py = -1, pcon = OB_FRAME_CONTEXT_NONE;
932
933             but = context_to_button(client->frame, con, TRUE);
934             if (but) {
935                 *but = (e->type == ButtonPress);
936                 frame_adjust_state(client->frame);
937             }
938         }
939         break;
940     case MotionNotify:
941         /* when there is a grab on the pointer, we won't get enter/leave
942            notifies, but we still get motion events */
943         if (grab_on_pointer()) break;
944
945         con = frame_context(client, e->xmotion.window,
946                             e->xmotion.x, e->xmotion.y);
947         switch (con) {
948         case OB_FRAME_CONTEXT_TITLEBAR:
949         case OB_FRAME_CONTEXT_TLCORNER:
950         case OB_FRAME_CONTEXT_TRCORNER:
951             /* we've left the button area inside the titlebar */
952             if (client->frame->max_hover || client->frame->desk_hover ||
953                 client->frame->shade_hover || client->frame->iconify_hover ||
954                 client->frame->close_hover)
955             {
956                 client->frame->max_hover =
957                     client->frame->desk_hover =
958                     client->frame->shade_hover =
959                     client->frame->iconify_hover =
960                     client->frame->close_hover = FALSE;
961                 frame_adjust_state(client->frame);
962             }
963             break;
964         default:
965             but = context_to_button(client->frame, con, FALSE);
966             if (but && !*but && !pb) {
967                 *but = TRUE;
968                 frame_adjust_state(client->frame);
969             }
970             break;
971         }
972         break;
973     case LeaveNotify:
974         con = frame_context(client, e->xcrossing.window,
975                             e->xcrossing.x, e->xcrossing.y);
976         switch (con) {
977         case OB_FRAME_CONTEXT_TITLEBAR:
978         case OB_FRAME_CONTEXT_TLCORNER:
979         case OB_FRAME_CONTEXT_TRCORNER:
980             /* we've left the button area inside the titlebar */
981             client->frame->max_hover =
982                 client->frame->desk_hover =
983                 client->frame->shade_hover =
984                 client->frame->iconify_hover =
985                 client->frame->close_hover = FALSE;
986             if (e->xcrossing.mode == NotifyGrab) {
987                 client->frame->max_press =
988                     client->frame->desk_press =
989                     client->frame->shade_press =
990                     client->frame->iconify_press =
991                     client->frame->close_press = FALSE;
992             }
993             break;
994         case OB_FRAME_CONTEXT_FRAME:
995             /* When the mouse leaves an animating window, don't use the
996                corresponding enter events. Pretend like the animating window
997                doesn't even exist..! */
998             if (frame_iconify_animating(client->frame))
999                 event_end_ignore_all_enters(event_start_ignore_all_enters());
1000
1001             ob_debug_type(OB_DEBUG_FOCUS,
1002                           "%sNotify mode %d detail %d on %lx\n",
1003                           (e->type == EnterNotify ? "Enter" : "Leave"),
1004                           e->xcrossing.mode,
1005                           e->xcrossing.detail, (client?client->window:0));
1006             if (grab_on_keyboard())
1007                 break;
1008             if (config_focus_follow && config_focus_delay &&
1009                 /* leave inferior events can happen when the mouse goes onto
1010                    the window's border and then into the window before the
1011                    delay is up */
1012                 e->xcrossing.detail != NotifyInferior)
1013             {
1014                 ob_main_loop_timeout_remove_data(ob_main_loop,
1015                                                  focus_delay_func,
1016                                                  client, FALSE);
1017             }
1018             break;
1019         default:
1020             but = context_to_button(client->frame, con, FALSE);
1021             if (but) {
1022                 *but = FALSE;
1023                 if (e->xcrossing.mode == NotifyGrab) {
1024                     but = context_to_button(client->frame, con, TRUE);
1025                     *but = FALSE;
1026                 }
1027                 frame_adjust_state(client->frame);
1028             }
1029             break;
1030         }
1031         break;
1032     case EnterNotify:
1033     {
1034         con = frame_context(client, e->xcrossing.window,
1035                             e->xcrossing.x, e->xcrossing.y);
1036         switch (con) {
1037         case OB_FRAME_CONTEXT_FRAME:
1038             if (grab_on_keyboard())
1039                 break;
1040             if (e->xcrossing.mode == NotifyGrab ||
1041                 e->xcrossing.mode == NotifyUngrab ||
1042                 /*ignore enters when we're already in the window */
1043                 e->xcrossing.detail == NotifyInferior)
1044             {
1045                 ob_debug_type(OB_DEBUG_FOCUS,
1046                               "%sNotify mode %d detail %d serial %lu on %lx "
1047                               "IGNORED\n",
1048                               (e->type == EnterNotify ? "Enter" : "Leave"),
1049                               e->xcrossing.mode,
1050                               e->xcrossing.detail,
1051                               e->xcrossing.serial,
1052                               client?client->window:0);
1053             }
1054             else {
1055                 ob_debug_type(OB_DEBUG_FOCUS,
1056                               "%sNotify mode %d detail %d serial %lu on %lx, "
1057                               "focusing window\n",
1058                               (e->type == EnterNotify ? "Enter" : "Leave"),
1059                               e->xcrossing.mode,
1060                               e->xcrossing.detail,
1061                               e->xcrossing.serial,
1062                               (client?client->window:0));
1063                 if (config_focus_follow)
1064                     event_enter_client(client);
1065             }
1066             break;
1067         default:
1068             but = context_to_button(client->frame, con, FALSE);
1069             if (but) {
1070                 *but = TRUE;
1071                 if (e->xcrossing.mode == NotifyUngrab) {
1072                     but = context_to_button(client->frame, con, TRUE);
1073                     *but = (con == pcon);
1074                 }
1075                 frame_adjust_state(client->frame);
1076             }
1077             break;
1078         }
1079         break;
1080     }
1081     case ConfigureRequest:
1082     {
1083         /* dont compress these unless you're going to watch for property
1084            notifies in between (these can change what the configure would
1085            do to the window).
1086            also you can't compress stacking events
1087         */
1088
1089         gint x, y, w, h;
1090         gboolean move = FALSE;
1091         gboolean resize = FALSE;
1092
1093         /* get the current area */
1094         RECT_TO_DIMS(client->area, x, y, w, h);
1095
1096         ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1097                  "visible %d\n"
1098                  "                     x %d y %d w %d h %d b %d\n",
1099                  client->title,
1100                  screen_desktop, client->wmstate, client->frame->visible,
1101                  x, y, w, h, client->border_width);
1102
1103         if (e->xconfigurerequest.value_mask & CWBorderWidth)
1104             if (client->border_width != e->xconfigurerequest.border_width) {
1105                 client->border_width = e->xconfigurerequest.border_width;
1106
1107                 /* if the border width is changing then that is the same
1108                    as requesting a resize, but we don't actually change
1109                    the client's border, so it will change their root
1110                    coordinates (since they include the border width) and
1111                    we need to a notify then */
1112                 move = TRUE;
1113             }
1114
1115
1116         if (e->xconfigurerequest.value_mask & CWStackMode) {
1117             ObClient *sibling = NULL;
1118             gulong ignore_start;
1119             gboolean ok = TRUE;
1120
1121             /* get the sibling */
1122             if (e->xconfigurerequest.value_mask & CWSibling) {
1123                 ObWindow *win;
1124                 win = g_hash_table_lookup(window_map,
1125                                           &e->xconfigurerequest.above);
1126                 if (win && WINDOW_IS_CLIENT(win) &&
1127                     WINDOW_AS_CLIENT(win) != client)
1128                 {
1129                     sibling = WINDOW_AS_CLIENT(win);
1130                 }
1131                 else
1132                     /* an invalid sibling was specified so don't restack at
1133                        all, it won't make sense no matter what we do */
1134                     ok = FALSE;
1135             }
1136
1137             if (ok) {
1138                 if (!config_focus_under_mouse)
1139                     ignore_start = event_start_ignore_all_enters();
1140                 stacking_restack_request(client, sibling,
1141                                          e->xconfigurerequest.detail);
1142                 if (!config_focus_under_mouse)
1143                     event_end_ignore_all_enters(ignore_start);
1144             }
1145
1146             /* a stacking change moves the window without resizing */
1147             move = TRUE;
1148         }
1149
1150         if ((e->xconfigurerequest.value_mask & CWX) ||
1151             (e->xconfigurerequest.value_mask & CWY) ||
1152             (e->xconfigurerequest.value_mask & CWWidth) ||
1153             (e->xconfigurerequest.value_mask & CWHeight))
1154         {
1155             /* don't allow clients to move shaded windows (fvwm does this)
1156             */
1157             if (e->xconfigurerequest.value_mask & CWX) {
1158                 if (!client->shaded)
1159                     x = e->xconfigurerequest.x;
1160                 move = TRUE;
1161             }
1162             if (e->xconfigurerequest.value_mask & CWY) {
1163                 if (!client->shaded)
1164                     y = e->xconfigurerequest.y;
1165                 move = TRUE;
1166             }
1167
1168             if (e->xconfigurerequest.value_mask & CWWidth) {
1169                 w = e->xconfigurerequest.width;
1170                 resize = TRUE;
1171             }
1172             if (e->xconfigurerequest.value_mask & CWHeight) {
1173                 h = e->xconfigurerequest.height;
1174                 resize = TRUE;
1175             }
1176         }
1177
1178         ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1179                  "move %d resize %d\n",
1180                  e->xconfigurerequest.value_mask & CWX, x,
1181                  e->xconfigurerequest.value_mask & CWY, y,
1182                  e->xconfigurerequest.value_mask & CWWidth, w,
1183                  e->xconfigurerequest.value_mask & CWHeight, h,
1184                  move, resize);
1185
1186         /* check for broken apps moving to their root position
1187
1188            XXX remove this some day...that would be nice. right now all
1189            kde apps do this when they try activate themselves on another
1190            desktop. eg. open amarok window on desktop 1, switch to desktop
1191            2, click amarok tray icon. it will move by its decoration size.
1192         */
1193         if (x != client->area.x &&
1194             x == (client->frame->area.x + client->frame->size.left -
1195                   (gint)client->border_width) &&
1196             y != client->area.y &&
1197             y == (client->frame->area.y + client->frame->size.top -
1198                   (gint)client->border_width) &&
1199             w == client->area.width &&
1200             h == client->area.height)
1201         {
1202             ob_debug_type(OB_DEBUG_APP_BUGS,
1203                           "Application %s is trying to move via "
1204                           "ConfigureRequest to it's root window position "
1205                           "but it is not using StaticGravity\n",
1206                           client->title);
1207             /* don't move it */
1208             x = client->area.x;
1209             y = client->area.y;
1210
1211             /* they still requested a move, so don't change whether a
1212                notify is sent or not */
1213         }
1214
1215         {
1216             gint lw, lh;
1217
1218             client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
1219
1220             /* if x was not given, then use gravity to figure out the new
1221                x.  the reference point should not be moved */
1222             if ((e->xconfigurerequest.value_mask & CWWidth &&
1223                  !(e->xconfigurerequest.value_mask & CWX)))
1224                 client_gravity_resize_w(client, &x, client->area.width, w);
1225             /* same for y */
1226             if ((e->xconfigurerequest.value_mask & CWHeight &&
1227                  !(e->xconfigurerequest.value_mask & CWY)))
1228                 client_gravity_resize_h(client, &y, client->area.height,h);
1229
1230             client_find_onscreen(client, &x, &y, w, h, FALSE);
1231
1232             ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
1233                      x, y, w, h);
1234             client_configure(client, x, y, w, h, FALSE, TRUE, TRUE);
1235         }
1236         break;
1237     }
1238     case UnmapNotify:
1239         if (client->ignore_unmaps) {
1240             client->ignore_unmaps--;
1241             break;
1242         }
1243         ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1244                  "ignores left %d\n",
1245                  client->window, e->xunmap.event, e->xunmap.from_configure,
1246                  client->ignore_unmaps);
1247         client_unmanage(client);
1248         break;
1249     case DestroyNotify:
1250         ob_debug("DestroyNotify for window 0x%x\n", client->window);
1251         client_unmanage(client);
1252         break;
1253     case ReparentNotify:
1254         /* this is when the client is first taken captive in the frame */
1255         if (e->xreparent.parent == client->frame->window) break;
1256
1257         /*
1258           This event is quite rare and is usually handled in unmapHandler.
1259           However, if the window is unmapped when the reparent event occurs,
1260           the window manager never sees it because an unmap event is not sent
1261           to an already unmapped window.
1262         */
1263
1264         /* we don't want the reparent event, put it back on the stack for the
1265            X server to deal with after we unmanage the window */
1266         XPutBackEvent(ob_display, e);
1267
1268         ob_debug("ReparentNotify for window 0x%x\n", client->window);
1269         client_unmanage(client);
1270         break;
1271     case MapRequest:
1272         ob_debug("MapRequest for 0x%lx\n", client->window);
1273         if (!client->iconic) break; /* this normally doesn't happen, but if it
1274                                        does, we don't want it!
1275                                        it can happen now when the window is on
1276                                        another desktop, but we still don't
1277                                        want it! */
1278         client_activate(client, FALSE, TRUE, TRUE, TRUE);
1279         break;
1280     case ClientMessage:
1281         /* validate cuz we query stuff off the client here */
1282         if (!client_validate(client)) break;
1283
1284         if (e->xclient.format != 32) return;
1285
1286         msgtype = e->xclient.message_type;
1287         if (msgtype == prop_atoms.wm_change_state) {
1288             compress_client_message_event(e, &ce, client->window, msgtype);
1289             client_set_wm_state(client, e->xclient.data.l[0]);
1290         } else if (msgtype == prop_atoms.net_wm_desktop) {
1291             compress_client_message_event(e, &ce, client->window, msgtype);
1292             if ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
1293                 (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)
1294                 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
1295                                    FALSE, FALSE);
1296         } else if (msgtype == prop_atoms.net_wm_state) {
1297             gulong ignore_start;
1298
1299             /* can't compress these */
1300             ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
1301                      (e->xclient.data.l[0] == 0 ? "Remove" :
1302                       e->xclient.data.l[0] == 1 ? "Add" :
1303                       e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
1304                      e->xclient.data.l[1], e->xclient.data.l[2],
1305                      client->window);
1306
1307             /* ignore enter events caused by these like ob actions do */
1308             if (!config_focus_under_mouse)
1309                 ignore_start = event_start_ignore_all_enters();
1310             client_set_state(client, e->xclient.data.l[0],
1311                              e->xclient.data.l[1], e->xclient.data.l[2]);
1312             if (!config_focus_under_mouse)
1313                 event_end_ignore_all_enters(ignore_start);
1314         } else if (msgtype == prop_atoms.net_close_window) {
1315             ob_debug("net_close_window for 0x%lx\n", client->window);
1316             client_close(client);
1317         } else if (msgtype == prop_atoms.net_active_window) {
1318             ob_debug("net_active_window for 0x%lx source=%s\n",
1319                      client->window,
1320                      (e->xclient.data.l[0] == 0 ? "unknown" :
1321                       (e->xclient.data.l[0] == 1 ? "application" :
1322                        (e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
1323             /* XXX make use of data.l[2] !? */
1324             if (e->xclient.data.l[0] == 1 || e->xclient.data.l[0] == 2) {
1325                 /* don't use the user's timestamp for client_focus, cuz if it's
1326                    an old broken timestamp (happens all the time) then focus
1327                    won't move even though we're trying to move it
1328                   event_curtime = e->xclient.data.l[1];*/
1329                 if (e->xclient.data.l[1] == 0)
1330                     ob_debug_type(OB_DEBUG_APP_BUGS,
1331                                   "_NET_ACTIVE_WINDOW message for window %s is"
1332                                   " missing a timestamp\n", client->title);
1333             } else
1334                 ob_debug_type(OB_DEBUG_APP_BUGS,
1335                               "_NET_ACTIVE_WINDOW message for window %s is "
1336                               "missing source indication\n");
1337             client_activate(client, TRUE, TRUE, TRUE,
1338                             (e->xclient.data.l[0] == 0 ||
1339                              e->xclient.data.l[0] == 2));
1340         } else if (msgtype == prop_atoms.net_wm_moveresize) {
1341             ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
1342                      client->window, e->xclient.data.l[2]);
1343             if ((Atom)e->xclient.data.l[2] ==
1344                 prop_atoms.net_wm_moveresize_size_topleft ||
1345                 (Atom)e->xclient.data.l[2] ==
1346                 prop_atoms.net_wm_moveresize_size_top ||
1347                 (Atom)e->xclient.data.l[2] ==
1348                 prop_atoms.net_wm_moveresize_size_topright ||
1349                 (Atom)e->xclient.data.l[2] ==
1350                 prop_atoms.net_wm_moveresize_size_right ||
1351                 (Atom)e->xclient.data.l[2] ==
1352                 prop_atoms.net_wm_moveresize_size_right ||
1353                 (Atom)e->xclient.data.l[2] ==
1354                 prop_atoms.net_wm_moveresize_size_bottomright ||
1355                 (Atom)e->xclient.data.l[2] ==
1356                 prop_atoms.net_wm_moveresize_size_bottom ||
1357                 (Atom)e->xclient.data.l[2] ==
1358                 prop_atoms.net_wm_moveresize_size_bottomleft ||
1359                 (Atom)e->xclient.data.l[2] ==
1360                 prop_atoms.net_wm_moveresize_size_left ||
1361                 (Atom)e->xclient.data.l[2] ==
1362                 prop_atoms.net_wm_moveresize_move ||
1363                 (Atom)e->xclient.data.l[2] ==
1364                 prop_atoms.net_wm_moveresize_size_keyboard ||
1365                 (Atom)e->xclient.data.l[2] ==
1366                 prop_atoms.net_wm_moveresize_move_keyboard) {
1367
1368                 moveresize_start(client, e->xclient.data.l[0],
1369                                  e->xclient.data.l[1], e->xclient.data.l[3],
1370                                  e->xclient.data.l[2]);
1371             }
1372             else if ((Atom)e->xclient.data.l[2] ==
1373                      prop_atoms.net_wm_moveresize_cancel)
1374                 moveresize_end(TRUE);
1375         } else if (msgtype == prop_atoms.net_moveresize_window) {
1376             gint ograv, x, y, w, h;
1377
1378             ograv = client->gravity;
1379
1380             if (e->xclient.data.l[0] & 0xff)
1381                 client->gravity = e->xclient.data.l[0] & 0xff;
1382
1383             if (e->xclient.data.l[0] & 1 << 8)
1384                 x = e->xclient.data.l[1];
1385             else
1386                 x = client->area.x;
1387             if (e->xclient.data.l[0] & 1 << 9)
1388                 y = e->xclient.data.l[2];
1389             else
1390                 y = client->area.y;
1391
1392             if (e->xclient.data.l[0] & 1 << 10) {
1393                 w = e->xclient.data.l[3];
1394
1395                 /* if x was not given, then use gravity to figure out the new
1396                    x.  the reference point should not be moved */
1397                 if (!(e->xclient.data.l[0] & 1 << 8))
1398                     client_gravity_resize_w(client, &x, client->area.width, w);
1399             }
1400             else
1401                 w = client->area.width;
1402
1403             if (e->xclient.data.l[0] & 1 << 11) {
1404                 h = e->xclient.data.l[4];
1405
1406                 /* same for y */
1407                 if (!(e->xclient.data.l[0] & 1 << 9))
1408                     client_gravity_resize_h(client, &y, client->area.height,h);
1409             }
1410             else
1411                 h = client->area.height;
1412
1413             ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
1414                      e->xclient.data.l[0] & 1 << 8, x,
1415                      e->xclient.data.l[0] & 1 << 9, y,
1416                      client->gravity);
1417
1418             client_find_onscreen(client, &x, &y, w, h, FALSE);
1419
1420             client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
1421
1422             client->gravity = ograv;
1423         } else if (msgtype == prop_atoms.net_restack_window) {
1424             if (e->xclient.data.l[0] != 2) {
1425                 ob_debug_type(OB_DEBUG_APP_BUGS,
1426                               "_NET_RESTACK_WINDOW sent for window %s with "
1427                               "invalid source indication %ld\n",
1428                               client->title, e->xclient.data.l[0]);
1429             } else {
1430                 ObClient *sibling = NULL;
1431                 if (e->xclient.data.l[1]) {
1432                     ObWindow *win = g_hash_table_lookup
1433                         (window_map, &e->xclient.data.l[1]);
1434                     if (WINDOW_IS_CLIENT(win) &&
1435                         WINDOW_AS_CLIENT(win) != client)
1436                     {
1437                         sibling = WINDOW_AS_CLIENT(win);
1438                     }
1439                     if (sibling == NULL)
1440                         ob_debug_type(OB_DEBUG_APP_BUGS,
1441                                       "_NET_RESTACK_WINDOW sent for window %s "
1442                                       "with invalid sibling 0x%x\n",
1443                                  client->title, e->xclient.data.l[1]);
1444                 }
1445                 if (e->xclient.data.l[2] == Below ||
1446                     e->xclient.data.l[2] == BottomIf ||
1447                     e->xclient.data.l[2] == Above ||
1448                     e->xclient.data.l[2] == TopIf ||
1449                     e->xclient.data.l[2] == Opposite)
1450                 {
1451                     gulong ignore_start;
1452
1453                     if (!config_focus_under_mouse)
1454                         ignore_start = event_start_ignore_all_enters();
1455                     /* just raise, don't activate */
1456                     stacking_restack_request(client, sibling,
1457                                              e->xclient.data.l[2]);
1458                     if (!config_focus_under_mouse)
1459                         event_end_ignore_all_enters(ignore_start);
1460
1461                     /* send a synthetic ConfigureNotify, cuz this is supposed
1462                        to be like a ConfigureRequest. */
1463                     client_reconfigure(client, TRUE);
1464                 } else
1465                     ob_debug_type(OB_DEBUG_APP_BUGS,
1466                                   "_NET_RESTACK_WINDOW sent for window %s "
1467                                   "with invalid detail %d\n",
1468                                   client->title, e->xclient.data.l[2]);
1469             }
1470         }
1471         break;
1472     case PropertyNotify:
1473         /* validate cuz we query stuff off the client here */
1474         if (!client_validate(client)) break;
1475
1476         /* compress changes to a single property into a single change */
1477         while (XCheckTypedWindowEvent(ob_display, client->window,
1478                                       e->type, &ce)) {
1479             Atom a, b;
1480
1481             /* XXX: it would be nice to compress ALL changes to a property,
1482                not just changes in a row without other props between. */
1483
1484             a = ce.xproperty.atom;
1485             b = e->xproperty.atom;
1486
1487             if (a == b)
1488                 continue;
1489             if ((a == prop_atoms.net_wm_name ||
1490                  a == prop_atoms.wm_name ||
1491                  a == prop_atoms.net_wm_icon_name ||
1492                  a == prop_atoms.wm_icon_name)
1493                 &&
1494                 (b == prop_atoms.net_wm_name ||
1495                  b == prop_atoms.wm_name ||
1496                  b == prop_atoms.net_wm_icon_name ||
1497                  b == prop_atoms.wm_icon_name)) {
1498                 continue;
1499             }
1500             if (a == prop_atoms.net_wm_icon &&
1501                 b == prop_atoms.net_wm_icon)
1502                 continue;
1503
1504             XPutBackEvent(ob_display, &ce);
1505             break;
1506         }
1507
1508         msgtype = e->xproperty.atom;
1509         if (msgtype == XA_WM_NORMAL_HINTS) {
1510             ob_debug("Update NORMAL hints\n");
1511             client_update_normal_hints(client);
1512             /* normal hints can make a window non-resizable */
1513             client_setup_decor_and_functions(client, FALSE);
1514
1515             /* make sure the client's sizes are within its bounds, but only
1516                reconfigure the window if it needs to. emacs will update its
1517                normal hints every time it receives a conigurenotify */
1518             client_reconfigure(client, FALSE);
1519         } else if (msgtype == XA_WM_HINTS) {
1520             client_update_wmhints(client);
1521         } else if (msgtype == XA_WM_TRANSIENT_FOR) {
1522             client_update_transient_for(client);
1523             client_get_type_and_transientness(client);
1524             /* type may have changed, so update the layer */
1525             client_calc_layer(client);
1526             client_setup_decor_and_functions(client, TRUE);
1527         } else if (msgtype == prop_atoms.net_wm_name ||
1528                    msgtype == prop_atoms.wm_name ||
1529                    msgtype == prop_atoms.net_wm_icon_name ||
1530                    msgtype == prop_atoms.wm_icon_name) {
1531             client_update_title(client);
1532         } else if (msgtype == prop_atoms.wm_protocols) {
1533             client_update_protocols(client);
1534             client_setup_decor_and_functions(client, TRUE);
1535         }
1536         else if (msgtype == prop_atoms.net_wm_strut ||
1537                  msgtype == prop_atoms.net_wm_strut_partial) {
1538             client_update_strut(client);
1539         }
1540         else if (msgtype == prop_atoms.net_wm_icon) {
1541             client_update_icons(client);
1542         }
1543         else if (msgtype == prop_atoms.net_wm_icon_geometry) {
1544             client_update_icon_geometry(client);
1545         }
1546         else if (msgtype == prop_atoms.net_wm_user_time) {
1547             guint32 t;
1548             if (client == focus_client &&
1549                 PROP_GET32(client->window, net_wm_user_time, cardinal, &t) &&
1550                 t && !event_time_after(t, e->xproperty.time) &&
1551                 (!event_last_user_time ||
1552                  event_time_after(t, event_last_user_time)))
1553             {
1554                 event_last_user_time = t;
1555             }
1556         }
1557 #ifdef SYNC
1558         else if (msgtype == prop_atoms.net_wm_sync_request_counter) {
1559             client_update_sync_request_counter(client);
1560         }
1561 #endif
1562         break;
1563     case ColormapNotify:
1564         client_update_colormap(client, e->xcolormap.colormap);
1565         break;
1566     default:
1567         ;
1568 #ifdef SHAPE
1569         if (extensions_shape && e->type == extensions_shape_event_basep) {
1570             client->shaped = ((XShapeEvent*)e)->shaped;
1571             frame_adjust_shape(client->frame);
1572         }
1573 #endif
1574     }
1575 }
1576
1577 static void event_handle_dock(ObDock *s, XEvent *e)
1578 {
1579     switch (e->type) {
1580     case ButtonPress:
1581         if (e->xbutton.button == 1)
1582             stacking_raise(DOCK_AS_WINDOW(s));
1583         else if (e->xbutton.button == 2)
1584             stacking_lower(DOCK_AS_WINDOW(s));
1585         break;
1586     case EnterNotify:
1587         dock_hide(FALSE);
1588         break;
1589     case LeaveNotify:
1590         /* don't hide when moving into a dock app */
1591         if (e->xcrossing.detail != NotifyInferior)
1592             dock_hide(TRUE);
1593         break;
1594     }
1595 }
1596
1597 static void event_handle_dockapp(ObDockApp *app, XEvent *e)
1598 {
1599     switch (e->type) {
1600     case MotionNotify:
1601         dock_app_drag(app, &e->xmotion);
1602         break;
1603     case UnmapNotify:
1604         if (app->ignore_unmaps) {
1605             app->ignore_unmaps--;
1606             break;
1607         }
1608         dock_remove(app, TRUE);
1609         break;
1610     case DestroyNotify:
1611     case ReparentNotify:
1612         dock_remove(app, FALSE);
1613         break;
1614     case ConfigureNotify:
1615         dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
1616         break;
1617     }
1618 }
1619
1620 static ObMenuFrame* find_active_menu(void)
1621 {
1622     GList *it;
1623     ObMenuFrame *ret = NULL;
1624
1625     for (it = menu_frame_visible; it; it = g_list_next(it)) {
1626         ret = it->data;
1627         if (ret->selected)
1628             break;
1629         ret = NULL;
1630     }
1631     return ret;
1632 }
1633
1634 static ObMenuFrame* find_active_or_last_menu(void)
1635 {
1636     ObMenuFrame *ret = NULL;
1637
1638     ret = find_active_menu();
1639     if (!ret && menu_frame_visible)
1640         ret = menu_frame_visible->data;
1641     return ret;
1642 }
1643
1644 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e)
1645 {
1646     switch (e->type) {
1647     case ButtonPress:
1648     case ButtonRelease:
1649     case MotionNotify:
1650         return prompt_mouse_event(p, e);
1651         break;
1652     case KeyPress:
1653         return prompt_key_event(p, e);
1654         break;
1655     }
1656     return FALSE;
1657 }
1658
1659 static gboolean event_handle_menu_keyboard(XEvent *ev)
1660 {
1661     guint keycode, state;
1662     gunichar unikey;
1663     ObMenuFrame *frame;
1664     gboolean ret = FALSE;
1665
1666     keycode = ev->xkey.keycode;
1667     state = ev->xkey.state;
1668     unikey = translate_unichar(keycode);
1669
1670     frame = find_active_or_last_menu();
1671     if (frame == NULL)
1672         g_assert_not_reached(); /* there is no active menu */
1673
1674     /* Allow control while going thru the menu */
1675     else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
1676         frame->got_press = TRUE;
1677
1678         if (keycode == ob_keycode(OB_KEY_ESCAPE)) {
1679             menu_frame_hide_all();
1680             ret = TRUE;
1681         }
1682
1683         else if (keycode == ob_keycode(OB_KEY_LEFT)) {
1684             /* Left goes to the parent menu */
1685             if (frame->parent)
1686                 menu_frame_select(frame, NULL, TRUE);
1687             ret = TRUE;
1688         }
1689
1690         else if (keycode == ob_keycode(OB_KEY_RIGHT)) {
1691             /* Right goes to the selected submenu */
1692             if (frame->child) menu_frame_select_next(frame->child);
1693             ret = TRUE;
1694         }
1695
1696         else if (keycode == ob_keycode(OB_KEY_UP)) {
1697             menu_frame_select_previous(frame);
1698             ret = TRUE;
1699         }
1700
1701         else if (keycode == ob_keycode(OB_KEY_DOWN)) {
1702             menu_frame_select_next(frame);
1703             ret = TRUE;
1704         }
1705     }
1706
1707     /* Use KeyRelease events for running things so that the key release doesn't
1708        get sent to the focused application.
1709
1710        Allow ControlMask only, and don't bother if the menu is empty */
1711     else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 &&
1712              frame->entries && frame->got_press)
1713     {
1714         if (keycode == ob_keycode(OB_KEY_RETURN)) {
1715             /* Enter runs the active item or goes into the submenu.
1716                Control-Enter runs it without closing the menu. */
1717             if (frame->child)
1718                 menu_frame_select_next(frame->child);
1719             else if (frame->selected)
1720                 menu_entry_frame_execute(frame->selected, state);
1721
1722             ret = TRUE;
1723         }
1724
1725         /* keyboard accelerator shortcuts. (if it was a valid key) */
1726         else if (unikey != 0) {
1727             GList *start;
1728             GList *it;
1729             ObMenuEntryFrame *found = NULL;
1730             guint num_found = 0;
1731
1732             /* start after the selected one */
1733             start = frame->entries;
1734             if (frame->selected) {
1735                 for (it = start; frame->selected != it->data;
1736                      it = g_list_next(it))
1737                     g_assert(it != NULL); /* nothing was selected? */
1738                 /* next with wraparound */
1739                 start = g_list_next(it);
1740                 if (start == NULL) start = frame->entries;
1741             }
1742
1743             it = start;
1744             do {
1745                 ObMenuEntryFrame *e = it->data;
1746                 gunichar entrykey = 0;
1747
1748                 if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
1749                     entrykey = e->entry->data.normal.shortcut;
1750                 else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
1751                     entrykey = e->entry->data.submenu.submenu->shortcut;
1752
1753                 if (unikey == entrykey) {
1754                     if (found == NULL) found = e;
1755                     ++num_found;
1756                 }
1757
1758                 /* next with wraparound */
1759                 it = g_list_next(it);
1760                 if (it == NULL) it = frame->entries;
1761             } while (it != start);
1762
1763             if (found) {
1764                 if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
1765                     num_found == 1)
1766                 {
1767                     menu_frame_select(frame, found, TRUE);
1768                     usleep(50000); /* highlight the item for a short bit so the
1769                                       user can see what happened */
1770                     menu_entry_frame_execute(found, state);
1771                 } else {
1772                     menu_frame_select(frame, found, TRUE);
1773                     if (num_found == 1)
1774                         menu_frame_select_next(frame->child);
1775                 }
1776
1777                 ret = TRUE;
1778             }
1779         }
1780     }
1781
1782     return ret;
1783 }
1784
1785 static gboolean event_handle_menu(XEvent *ev)
1786 {
1787     ObMenuFrame *f;
1788     ObMenuEntryFrame *e;
1789     gboolean ret = TRUE;
1790
1791     switch (ev->type) {
1792     case ButtonRelease:
1793         if (menu_hide_delay_reached() &&
1794             (ev->xbutton.button < 4 || ev->xbutton.button > 5))
1795         {
1796             if ((e = menu_entry_frame_under(ev->xbutton.x_root,
1797                                             ev->xbutton.y_root)))
1798             {
1799                 menu_frame_select(e->frame, e, TRUE);
1800                 menu_entry_frame_execute(e, ev->xbutton.state);
1801             }
1802             else
1803                 menu_frame_hide_all();
1804         }
1805         break;
1806     case EnterNotify:
1807         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
1808             if (e->ignore_enters)
1809                 --e->ignore_enters;
1810             else if (!(f = find_active_menu()) ||
1811                      f == e->frame ||
1812                      f->parent == e->frame ||
1813                      f->child == e->frame)
1814                 menu_frame_select(e->frame, e, FALSE);
1815         }
1816         break;
1817     case LeaveNotify:
1818         /*ignore leaves when we're already in the window */
1819         if (ev->xcrossing.detail == NotifyInferior)
1820             break;
1821
1822         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
1823             (f = find_active_menu()) && f->selected == e &&
1824             e->entry->type != OB_MENU_ENTRY_TYPE_SUBMENU)
1825         {
1826             menu_frame_select(e->frame, NULL, FALSE);
1827         }
1828         break;
1829     case MotionNotify:
1830         if ((e = menu_entry_frame_under(ev->xmotion.x_root,
1831                                         ev->xmotion.y_root)))
1832             if (!(f = find_active_menu()) ||
1833                 f == e->frame ||
1834                 f->parent == e->frame ||
1835                 f->child == e->frame)
1836                 menu_frame_select(e->frame, e, FALSE);
1837         break;
1838     case KeyPress:
1839     case KeyRelease:
1840         ret = event_handle_menu_keyboard(ev);
1841         break;
1842     }
1843     return ret;
1844 }
1845
1846 static void event_handle_user_input(ObClient *client, XEvent *e)
1847 {
1848     g_assert(e->type == ButtonPress || e->type == ButtonRelease ||
1849              e->type == MotionNotify || e->type == KeyPress ||
1850              e->type == KeyRelease);
1851
1852     if (menu_frame_visible) {
1853         if (event_handle_menu(e))
1854             /* don't use the event if the menu used it, but if the menu
1855                didn't use it and it's a keypress that is bound, it will
1856                close the menu and be used */
1857             return;
1858     }
1859
1860     /* if the keyboard interactive action uses the event then dont
1861        use it for bindings. likewise is moveresize uses the event. */
1862     if (!actions_interactive_input_event(e) && !moveresize_event(e)) {
1863         if (moveresize_in_progress)
1864             /* make further actions work on the client being
1865                moved/resized */
1866             client = moveresize_client;
1867
1868         if (e->type == ButtonPress ||
1869             e->type == ButtonRelease ||
1870             e->type == MotionNotify)
1871         {
1872             /* the frame may not be "visible" but they can still click on it
1873                in the case where it is animating before disappearing */
1874             if (!client || !frame_iconify_animating(client->frame))
1875                 mouse_event(client, e);
1876         } else
1877             keyboard_event((focus_cycle_target ? focus_cycle_target :
1878                             (client ? client : focus_client)), e);
1879     }
1880 }
1881
1882 static void focus_delay_dest(gpointer data)
1883 {
1884     g_free(data);
1885 }
1886
1887 static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2)
1888 {
1889     const ObFocusDelayData *f1 = d1;
1890     return f1->client == d2;
1891 }
1892
1893 static gboolean focus_delay_func(gpointer data)
1894 {
1895     ObFocusDelayData *d = data;
1896     Time old = event_curtime;
1897
1898     /* don't move focus and kill the menu or the move/resize */
1899     if (menu_frame_visible || moveresize_in_progress) return FALSE;
1900
1901     event_curtime = d->time;
1902     event_curserial = d->serial;
1903     if (client_focus(d->client) && config_focus_raise)
1904         stacking_raise(CLIENT_AS_WINDOW(d->client));
1905     event_curtime = old;
1906     return FALSE; /* no repeat */
1907 }
1908
1909 static void focus_delay_client_dest(ObClient *client, gpointer data)
1910 {
1911     ob_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
1912                                      client, FALSE);
1913 }
1914
1915 void event_halt_focus_delay(void)
1916 {
1917     /* ignore all enter events up till the event which caused this to occur */
1918     if (event_curserial) event_ignore_enter_range(1, event_curserial);
1919     ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
1920 }
1921
1922 gulong event_start_ignore_all_enters(void)
1923 {
1924     return NextRequest(ob_display);
1925 }
1926
1927 static void event_ignore_enter_range(gulong start, gulong end)
1928 {
1929     ObSerialRange *r;
1930
1931     g_assert(start != 0);
1932     g_assert(end != 0);
1933
1934     r = g_new(ObSerialRange, 1);
1935     r->start = start;
1936     r->end = end;
1937     ignore_serials = g_slist_prepend(ignore_serials, r);
1938
1939     ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu\n",
1940                   r->start, r->end);
1941
1942     /* increment the serial so we don't ignore events we weren't meant to */
1943     PROP_ERASE(screen_support_win, motif_wm_hints);
1944 }
1945
1946 void event_end_ignore_all_enters(gulong start)
1947 {
1948     /* Use (NextRequest-1) so that we ignore up to the current serial only.
1949        Inside event_ignore_enter_range, we increment the serial by one, but if
1950        we ignore that serial too, then any enter events generated by mouse
1951        movement will be ignored until we create some further network traffic.
1952        Instead ignore up to NextRequest-1, then when we increment the serial,
1953        we will be *past* the range of ignored serials */
1954     event_ignore_enter_range(start, NextRequest(ob_display)-1);
1955 }
1956
1957 static gboolean is_enter_focus_event_ignored(gulong serial)
1958 {
1959     GSList *it, *next;
1960
1961     for (it = ignore_serials; it; it = next) {
1962         ObSerialRange *r = it->data;
1963
1964         next = g_slist_next(it);
1965
1966         if ((glong)(serial - r->end) > 0) {
1967             /* past the end */
1968             ignore_serials = g_slist_delete_link(ignore_serials, it);
1969             g_free(r);
1970         }
1971         else if ((glong)(serial - r->start) >= 0)
1972             return TRUE;
1973     }
1974     return FALSE;
1975 }
1976
1977 void event_cancel_all_key_grabs(void)
1978 {
1979     if (actions_interactive_act_running()) {
1980         actions_interactive_cancel_act();
1981         ob_debug("KILLED interactive action\n");
1982     }
1983     else if (menu_frame_visible) {
1984         menu_frame_hide_all();
1985         ob_debug("KILLED open menus\n");
1986     }
1987     else if (moveresize_in_progress) {
1988         moveresize_end(TRUE);
1989         ob_debug("KILLED interactive moveresize\n");
1990     }
1991     else if (grab_on_keyboard()) {
1992         ungrab_keyboard();
1993         ob_debug("KILLED active grab on keyboard\n");
1994     }
1995     else
1996         ungrab_passive_key();
1997
1998     XSync(ob_display, FALSE);
1999 }
2000
2001 gboolean event_time_after(Time t1, Time t2)
2002 {
2003     g_assert(t1 != CurrentTime);
2004     g_assert(t2 != CurrentTime);
2005
2006     /*
2007       Timestamp values wrap around (after about 49.7 days). The server, given
2008       its current time is represented by timestamp T, always interprets
2009       timestamps from clients by treating half of the timestamp space as being
2010       later in time than T.
2011       - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
2012     */
2013
2014     /* TIME_HALF is half of the number space of a Time type variable */
2015 #define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
2016
2017     if (t2 >= TIME_HALF)
2018         /* t2 is in the second half so t1 might wrap around and be smaller than
2019            t2 */
2020         return t1 >= t2 || t1 < (t2 + TIME_HALF);
2021     else
2022         /* t2 is in the first half so t1 has to come after it */
2023         return t1 >= t2 && t1 < (t2 + TIME_HALF);
2024 }
2025
2026 Time event_get_server_time(void)
2027 {
2028     /* Generate a timestamp */
2029     XEvent event;
2030
2031     XChangeProperty(ob_display, screen_support_win,
2032                     prop_atoms.wm_class, prop_atoms.string,
2033                     8, PropModeAppend, NULL, 0);
2034     XWindowEvent(ob_display, screen_support_win, PropertyChangeMask, &event);
2035     return event.xproperty.time;
2036 }