handle multiple maprequests graciously
[dana/openbox.git] / openbox / event.c
1 #include "openbox.h"
2 #include "client.h"
3 #include "xerror.h"
4 #include "prop.h"
5 #include "screen.h"
6 #include "frame.h"
7 #include "engine.h"
8 #include "focus.h"
9 #include "stacking.h"
10 #include "extensions.h"
11 #include "timer.h"
12 #include "engine.h"
13 #include "dispatch.h"
14
15 #include <X11/Xlib.h>
16 #include <X11/keysym.h>
17 #include <X11/Xatom.h>
18 #ifdef HAVE_SYS_SELECT_H
19 #  include <sys/select.h>
20 #endif
21
22 static void event_process(XEvent *e);
23 static void event_handle_root(XEvent *e);
24 static void event_handle_client(Client *c, XEvent *e);
25
26 Time event_lasttime = 0;
27
28 /*! The value of the mask for the NumLock modifier */
29 unsigned int NumLockMask;
30 /*! The value of the mask for the ScrollLock modifier */
31 unsigned int ScrollLockMask;
32 /*! The key codes for the modifier keys */
33 static XModifierKeymap *modmap;
34 /*! Table of the constant modifier masks */
35 static const int mask_table[] = {
36     ShiftMask, LockMask, ControlMask, Mod1Mask,
37     Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
38 };
39 static int mask_table_size;
40
41 void event_startup()
42 {
43     mask_table_size = sizeof(mask_table) / sizeof(mask_table[0]);
44      
45     /* get lock masks that are defined by the display (not constant) */
46     modmap = XGetModifierMapping(ob_display);
47     g_assert(modmap);
48     if (modmap && modmap->max_keypermod > 0) {
49         size_t cnt;
50         const size_t size = mask_table_size * modmap->max_keypermod;
51         /* get the values of the keyboard lock modifiers
52            Note: Caps lock is not retrieved the same way as Scroll and Num
53            lock since it doesn't need to be. */
54         const KeyCode num_lock = XKeysymToKeycode(ob_display, XK_Num_Lock);
55         const KeyCode scroll_lock = XKeysymToKeycode(ob_display,
56                                                      XK_Scroll_Lock);
57           
58         for (cnt = 0; cnt < size; ++cnt) {
59             if (! modmap->modifiermap[cnt]) continue;
60                
61             if (num_lock == modmap->modifiermap[cnt])
62                 NumLockMask = mask_table[cnt / modmap->max_keypermod];
63             if (scroll_lock == modmap->modifiermap[cnt])
64                 ScrollLockMask = mask_table[cnt / modmap->max_keypermod];
65         }
66     }
67 }
68
69 void event_shutdown()
70 {
71     XFreeModifiermap(modmap);
72 }
73
74 void event_loop()
75 {
76     fd_set selset;
77     XEvent e;
78     int x_fd;
79     struct timeval *wait;
80
81     while (TRUE) {
82         /*
83           There are slightly different event retrieval semantics here for
84           local (or high bandwidth) versus remote (or low bandwidth)
85           connections to the display/Xserver.
86         */
87         if (ob_remote) {
88             if (!XPending(ob_display))
89                 break;
90         } else {
91             /*
92               This XSync allows for far more compression of events, which
93               makes things like Motion events perform far far better. Since
94               it also means network traffic for every event instead of every
95               X events (where X is the number retrieved at a time), it
96               probably should not be used for setups where Openbox is
97               running on a remote/low bandwidth display/Xserver.
98             */
99             XSync(ob_display, FALSE);
100             if (!XEventsQueued(ob_display, QueuedAlready))
101                 break;
102         }
103         XNextEvent(ob_display, &e);
104
105         event_process(&e);
106     }
107      
108     timer_dispatch((GTimeVal**)&wait);
109     x_fd = ConnectionNumber(ob_display);
110     FD_ZERO(&selset);
111     FD_SET(x_fd, &selset);
112     select(x_fd + 1, &selset, NULL, NULL, wait);
113 }
114
115 void event_process(XEvent *e)
116 {
117     XEvent ce;
118     KeyCode *kp;
119     Window window;
120     int i, k;
121     Client *client;
122
123     /* pick a window */
124     switch (e->type) {
125     case MapRequest:
126         window = e->xmap.window;
127         break;
128     case UnmapNotify:
129         window = e->xunmap.window;
130         break;
131     case DestroyNotify:
132         window = e->xdestroywindow.window;
133         break;
134     case ConfigureRequest:
135         window = e->xconfigurerequest.window;
136         break;
137     default:
138         /* XKB events */
139         if (e->type == extensions_xkb_event_basep) {
140             switch (((XkbAnyEvent*)&e)->xkb_type) {
141             case XkbBellNotify:
142                 window = ((XkbBellNotifyEvent*)&e)->window;
143             default:
144                 window = None;
145             }
146         } else
147             window = e->xany.window;
148     }
149      
150     /* grab the lasttime and hack up the state */
151     switch (e->type) {
152     case ButtonPress:
153     case ButtonRelease:
154         event_lasttime = e->xbutton.time;
155         e->xbutton.state &= ~(LockMask | NumLockMask | ScrollLockMask);
156         /* kill off the Button1Mask etc, only want the modifiers */
157         e->xbutton.state &= (ControlMask | ShiftMask | Mod1Mask |
158                              Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
159         break;
160     case KeyPress:
161         event_lasttime = e->xkey.time;
162         e->xkey.state &= ~(LockMask | NumLockMask | ScrollLockMask);
163         /* kill off the Button1Mask etc, only want the modifiers */
164         e->xkey.state &= (ControlMask | ShiftMask | Mod1Mask |
165                           Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
166         /* add to the state the mask of the modifier being pressed, if it is
167            a modifier key being pressed (this is a little ugly..) */
168 /* I'm commenting this out cuz i don't want "C-Control_L" being returned. */
169 /*      kp = modmap->modifiermap;*/
170 /*      for (i = 0; i < mask_table_size; ++i) {*/
171 /*          for (k = 0; k < modmap->max_keypermod; ++k) {*/
172 /*              if (*kp == e->xkey.keycode) {*/ /* found the keycode */
173                     /* add the mask for it */
174 /*                  e->xkey.state |= mask_table[i];*/
175                     /* cause the first loop to break; */
176 /*                  i = mask_table_size;*/
177 /*                  break;*/ /* get outta here! */
178 /*              }*/
179 /*              ++kp;*/
180 /*          }*/
181 /*      }*/
182
183         break;
184     case KeyRelease:
185         event_lasttime = e->xkey.time;
186         e->xkey.state &= ~(LockMask | NumLockMask | ScrollLockMask);
187         /* kill off the Button1Mask etc, only want the modifiers */
188         e->xkey.state &= (ControlMask | ShiftMask | Mod1Mask |
189                           Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
190         /* remove from the state the mask of the modifier being released, if
191            it is a modifier key being released (this is a little ugly..) */
192         kp = modmap->modifiermap;
193         for (i = 0; i < mask_table_size; ++i) {
194             for (k = 0; k < modmap->max_keypermod; ++k) {
195                 if (*kp == e->xkey.keycode) { /* found the keycode */
196                     /* remove the mask for it */
197                     e->xkey.state &= ~mask_table[i];
198                     /* cause the first loop to break; */
199                     i = mask_table_size;
200                     break; /* get outta here! */
201                 }
202                 ++kp;
203             }
204         }
205         break;
206     case MotionNotify:
207         event_lasttime = e->xmotion.time;
208         e->xmotion.state &= ~(LockMask | NumLockMask | ScrollLockMask);
209         /* kill off the Button1Mask etc, only want the modifiers */
210         e->xmotion.state &= (ControlMask | ShiftMask | Mod1Mask |
211                              Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
212         /* compress events */
213         while (XCheckTypedWindowEvent(ob_display, window, e->type, &ce)) {
214             e->xmotion.x_root = ce.xmotion.x_root;
215             e->xmotion.y_root = ce.xmotion.y_root;
216         }
217         break;
218     case PropertyNotify:
219         event_lasttime = e->xproperty.time;
220         break;
221     case FocusIn:
222     case FocusOut:
223         if (e->xfocus.mode == NotifyGrab)
224             /*|| e.xfocus.mode == NotifyUngrab ||*/
225                
226             /* From Metacity, from WindowMaker, ignore all funky pointer
227                root events. Its commented out cuz I don't think we need this
228                at all. If problems arise we can look into it */
229             /*e.xfocus.detail > NotifyNonlinearVirtual) */
230             return; /* skip me! */
231         if (e->type == FocusOut) {
232             /* FocusOut events just make us look for FocusIn events. They
233                are mostly ignored otherwise. */
234             XEvent fi;
235             if (XCheckTypedEvent(ob_display, FocusIn, &fi)) {
236                 event_process(&fi);
237                 /* dont unfocus the window we just focused! */
238                 if (fi.xfocus.window == e->xfocus.window)
239                     return;
240             }
241         }
242         break;
243     case EnterNotify:
244     case LeaveNotify:
245         event_lasttime = e->xcrossing.time;
246         /* XXX this caused problems before... but i don't remember why. hah.
247            so back it is. if problems arise again, then try filtering on the
248            detail instead of the mode. */
249         if (e->xcrossing.mode != NotifyNormal) return;
250         break;
251     }
252
253     client = g_hash_table_lookup(client_map, (gpointer)window);
254     g_message("EVENT: 0x%lx -> 0x%lx", window, client);
255
256     /* deal with it in the kernel */
257     if (client)
258         event_handle_client(client, e);
259     else if (window == ob_root)
260         event_handle_root(e);
261     else if (e->type == MapRequest)
262         client_manage(window);
263     else if (e->type == ConfigureRequest) {
264         /* unhandled configure requests must be used to configure the
265            window directly */
266         XWindowChanges xwc;
267                
268         xwc.x = e->xconfigurerequest.x;
269         xwc.y = e->xconfigurerequest.y;
270         xwc.width = e->xconfigurerequest.width;
271         xwc.height = e->xconfigurerequest.height;
272         xwc.border_width = e->xconfigurerequest.border_width;
273         xwc.sibling = e->xconfigurerequest.above;
274         xwc.stack_mode = e->xconfigurerequest.detail;
275        
276         g_message("Proxying configure event for 0x%lx", window);
277        
278         /* we are not to be held responsible if someone sends us an
279            invalid request! */
280         xerror_set_ignore(TRUE);
281         XConfigureWindow(ob_display, window,
282                          e->xconfigurerequest.value_mask, &xwc);
283         xerror_set_ignore(FALSE);
284     }
285
286     /* dispatch the event to registered handlers */
287     dispatch_x(e, client);
288 }
289
290 static void event_handle_root(XEvent *e)
291 {
292     Atom msgtype;
293      
294     switch(e->type) {
295     case ClientMessage:
296         if (e->xclient.format != 32) break;
297
298         msgtype = e->xclient.message_type;
299         if (msgtype == prop_atoms.net_current_desktop) {
300             unsigned int d = e->xclient.data.l[0];
301             if (d <= screen_num_desktops)
302                 screen_set_desktop(d);
303         } else if (msgtype == prop_atoms.net_number_of_desktops) {
304             unsigned int d = e->xclient.data.l[0];
305             if (d > 0)
306                 screen_set_num_desktops(d);
307         } else if (msgtype == prop_atoms.net_showing_desktop) {
308             screen_show_desktop(e->xclient.data.l[0] != 0);
309         }
310         break;
311     case PropertyNotify:
312         if (e->xproperty.atom == prop_atoms.net_desktop_names)
313             screen_update_desktop_names();
314         else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
315             screen_update_layout();
316         break;
317     }
318 }
319
320 static void event_handle_client(Client *client, XEvent *e)
321 {
322     XEvent ce;
323     Atom msgtype;
324      
325     switch (e->type) {
326     case FocusIn:
327         client_set_focused(client, TRUE);
328         break;
329     case FocusOut:
330         client_set_focused(client, FALSE);
331         break;
332     case ConfigureRequest:
333         g_message("ConfigureRequest for window %lx", client->window);
334         /* compress these */
335         while (XCheckTypedWindowEvent(ob_display, client->window,
336                                       ConfigureRequest, &ce)) {
337             /* XXX if this causes bad things.. we can compress config req's
338                with the same mask. */
339             e->xconfigurerequest.value_mask |=
340                 ce.xconfigurerequest.value_mask;
341             if (ce.xconfigurerequest.value_mask & CWX)
342                 e->xconfigurerequest.x = ce.xconfigurerequest.x;
343             if (ce.xconfigurerequest.value_mask & CWY)
344                 e->xconfigurerequest.y = ce.xconfigurerequest.y;
345             if (ce.xconfigurerequest.value_mask & CWWidth)
346                 e->xconfigurerequest.width = ce.xconfigurerequest.width;
347             if (ce.xconfigurerequest.value_mask & CWHeight)
348                 e->xconfigurerequest.height = ce.xconfigurerequest.height;
349             if (ce.xconfigurerequest.value_mask & CWBorderWidth)
350                 e->xconfigurerequest.border_width =
351                     ce.xconfigurerequest.border_width;
352             if (ce.xconfigurerequest.value_mask & CWStackMode)
353                 e->xconfigurerequest.detail = ce.xconfigurerequest.detail;
354         }
355
356         /* if we are iconic (or shaded (fvwm does this)) ignore the event */
357         if (client->iconic || client->shaded) return;
358
359         if (e->xconfigurerequest.value_mask & CWBorderWidth)
360             client->border_width = e->xconfigurerequest.border_width;
361
362         /* resize, then move, as specified in the EWMH section 7.7 */
363         if (e->xconfigurerequest.value_mask & (CWWidth | CWHeight |
364                                                CWX | CWY)) {
365             int x, y, w, h;
366             Corner corner;
367                
368             x = (e->xconfigurerequest.value_mask & CWX) ?
369                 e->xconfigurerequest.x : client->area.x;
370             y = (e->xconfigurerequest.value_mask & CWY) ?
371                 e->xconfigurerequest.y : client->area.y;
372             w = (e->xconfigurerequest.value_mask & CWWidth) ?
373                 e->xconfigurerequest.width : client->area.width;
374             h = (e->xconfigurerequest.value_mask & CWHeight) ?
375                 e->xconfigurerequest.height : client->area.height;
376                
377             switch (client->gravity) {
378             case NorthEastGravity:
379             case EastGravity:
380                 corner = Corner_TopRight;
381                 break;
382             case SouthWestGravity:
383             case SouthGravity:
384                 corner = Corner_BottomLeft;
385                 break;
386             case SouthEastGravity:
387                 corner = Corner_BottomRight;
388                 break;
389             default:     /* NorthWest, Static, etc */
390                 corner = Corner_TopLeft;
391             }
392
393             client_configure(client, corner, x, y, w, h, FALSE, FALSE);
394         }
395
396         if (e->xconfigurerequest.value_mask & CWStackMode) {
397             switch (e->xconfigurerequest.detail) {
398             case Below:
399             case BottomIf:
400                 stacking_lower(client);
401                 break;
402
403             case Above:
404             case TopIf:
405             default:
406                 stacking_raise(client);
407                 break;
408             }
409         }
410         break;
411     case UnmapNotify:
412         if (client->ignore_unmaps) {
413             client->ignore_unmaps--;
414             break;
415         }
416         g_message("UnmapNotify for %lx", client->window);
417         client_unmanage(client);
418         break;
419     case DestroyNotify:
420         g_message("DestroyNotify for %lx", client->window);
421         client_unmanage(client);
422         break;
423     case ReparentNotify:
424         /* this is when the client is first taken captive in the frame */
425         if (e->xreparent.parent == client->frame->plate) break;
426
427         /*
428           This event is quite rare and is usually handled in unmapHandler.
429           However, if the window is unmapped when the reparent event occurs,
430           the window manager never sees it because an unmap event is not sent
431           to an already unmapped window.
432         */
433
434         /* we don't want the reparent event, put it back on the stack for the
435            X server to deal with after we unmanage the window */
436         XPutBackEvent(ob_display, e);
437      
438         client_unmanage(client);
439         break;
440     case MapRequest:
441         if (screen_showing_desktop)
442             screen_show_desktop(FALSE);
443         client_iconify(client, FALSE, TRUE);
444         if (!client->frame->visible)
445             /* if its not visible still, then don't mess with it */
446             break;
447         if (client->shaded)
448             client_shade(client, FALSE);
449         client_focus(client);
450         stacking_raise(client);
451         break;
452     case ClientMessage:
453         /* validate cuz we query stuff off the client here */
454         if (!client_validate(client)) break;
455   
456         if (e->xclient.format != 32) return;
457
458         msgtype = e->xclient.message_type;
459         if (msgtype == prop_atoms.wm_change_state) {
460             /* compress changes into a single change */
461             while (XCheckTypedWindowEvent(ob_display, e->type,
462                                           client->window, &ce)) {
463                 /* XXX: it would be nice to compress ALL messages of a
464                    type, not just messages in a row without other
465                    message types between. */
466                 if (ce.xclient.message_type != msgtype) {
467                     XPutBackEvent(ob_display, &ce);
468                     break;
469                 }
470                 e->xclient = ce.xclient;
471             }
472             client_set_wm_state(client, e->xclient.data.l[0]);
473         } else if (msgtype == prop_atoms.net_wm_desktop) {
474             /* compress changes into a single change */
475             while (XCheckTypedWindowEvent(ob_display, e->type,
476                                           client->window, &ce)) {
477                 /* XXX: it would be nice to compress ALL messages of a
478                    type, not just messages in a row without other
479                    message types between. */
480                 if (ce.xclient.message_type != msgtype) {
481                     XPutBackEvent(ob_display, &ce);
482                     break;
483                 }
484                 e->xclient = ce.xclient;
485             }
486             client_set_desktop(client, e->xclient.data.l[0]);
487         } else if (msgtype == prop_atoms.net_wm_state) {
488             /* can't compress these */
489             g_message("net_wm_state %s %ld %ld for 0x%lx\n",
490                       (e->xclient.data.l[0] == 0 ? "Remove" :
491                        e->xclient.data.l[0] == 1 ? "Add" :
492                        e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
493                       e->xclient.data.l[1], e->xclient.data.l[2],
494                       client->window);
495             client_set_state(client, e->xclient.data.l[0],
496                              e->xclient.data.l[1], e->xclient.data.l[2]);
497         } else if (msgtype == prop_atoms.net_close_window) {
498             g_message("net_close_window for 0x%lx\n", client->window);
499             client_close(client);
500         } else if (msgtype == prop_atoms.net_active_window) {
501             g_message("net_active_window for 0x%lx\n", client->window);
502             if (screen_showing_desktop)
503                 screen_show_desktop(FALSE);
504             if (client->iconic)
505                 client_iconify(client, FALSE, TRUE);
506             else if (!client->frame->visible)
507                 /* if its not visible for other reasons, then don't mess
508                    with it */
509                 break;
510             if (client->shaded)
511                 client_shade(client, FALSE);
512             client_focus(client);
513             stacking_raise(client);
514         }
515         break;
516     case PropertyNotify:
517         /* validate cuz we query stuff off the client here */
518         if (!client_validate(client)) break;
519   
520         /* compress changes to a single property into a single change */
521         while (XCheckTypedWindowEvent(ob_display, e->type,
522                                       client->window, &ce)) {
523             /* XXX: it would be nice to compress ALL changes to a property,
524                not just changes in a row without other props between. */
525             if (ce.xproperty.atom != e->xproperty.atom) {
526                 XPutBackEvent(ob_display, &ce);
527                 break;
528             }
529         }
530
531         msgtype = e->xproperty.atom;
532         if (msgtype == XA_WM_NORMAL_HINTS) {
533             client_update_normal_hints(client);
534             /* normal hints can make a window non-resizable */
535             client_setup_decor_and_functions(client);
536         }
537         else if (msgtype == XA_WM_HINTS)
538             client_update_wmhints(client);
539         else if (msgtype == XA_WM_TRANSIENT_FOR) {
540             client_update_transient_for(client);
541             client_get_type(client);
542             /* type may have changed, so update the layer */
543             client_calc_layer(client);
544             client_setup_decor_and_functions(client);
545         }
546         else if (msgtype == prop_atoms.net_wm_name ||
547                  msgtype == prop_atoms.wm_name)
548             client_update_title(client);
549         else if (msgtype == prop_atoms.net_wm_icon_name ||
550                  msgtype == prop_atoms.wm_icon_name)
551             client_update_icon_title(client);
552         else if (msgtype == prop_atoms.wm_class)
553             client_update_class(client);
554         else if (msgtype == prop_atoms.wm_protocols) {
555             client_update_protocols(client);
556             client_setup_decor_and_functions(client);
557         }
558         else if (msgtype == prop_atoms.net_wm_strut)
559             client_update_strut(client);
560         else if (msgtype == prop_atoms.net_wm_icon)
561             client_update_icons(client);
562         else if (msgtype == prop_atoms.kwm_win_icon)
563             client_update_kwm_icon(client);
564     }
565 }