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