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