1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 event.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
33 #include "menuframe.h"
37 #include "focus_cycle.h"
38 #include "moveresize.h"
42 #include "obt/display.h"
43 #include "obt/xqueue.h"
45 #include "obt/keyboard.h"
48 #include <X11/Xatom.h>
51 #ifdef HAVE_SYS_SELECT_H
52 # include <sys/select.h>
58 # include <unistd.h> /* for usleep() */
62 #include <X11/ICE/ICElib.h>
79 gulong start; /* inclusive */
80 gulong end; /* inclusive */
83 static void event_process(const XEvent *e, gpointer data);
84 static void event_handle_root(XEvent *e);
85 static gboolean event_handle_menu_input(XEvent *e);
86 static void event_handle_menu(ObMenuFrame *frame, XEvent *e);
87 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e);
88 static void event_handle_dock(ObDock *s, XEvent *e);
89 static void event_handle_dockapp(ObDockApp *app, XEvent *e);
90 static void event_handle_client(ObClient *c, XEvent *e);
91 static gboolean event_handle_user_input(ObClient *client, XEvent *e);
92 static gboolean is_enter_focus_event_ignored(gulong serial);
93 static void event_ignore_enter_range(gulong start, gulong end);
95 static void focus_delay_dest(gpointer data);
96 static void unfocus_delay_dest(gpointer data);
97 static gboolean focus_delay_func(gpointer data);
98 static gboolean unfocus_delay_func(gpointer data);
99 static void focus_delay_client_dest(ObClient *client, gpointer data);
101 Time event_last_user_time = CurrentTime;
103 /*! The time of the current X event (if it had a timestamp) */
104 static Time event_curtime = CurrentTime;
105 /*! The source time that started the current X event (user-provided, so not
107 static Time event_sourcetime = CurrentTime;
109 /*! The serial of the current X event */
110 static gulong event_curserial;
111 static gboolean focus_left_screen = FALSE;
112 static gboolean waiting_for_focusin = FALSE;
113 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
114 static GSList *ignore_serials = NULL;
115 static guint focus_delay_timeout_id = 0;
116 static ObClient *focus_delay_timeout_client = NULL;
117 static guint unfocus_delay_timeout_id = 0;
118 static ObClient *unfocus_delay_timeout_client = NULL;
121 static gboolean ice_handler(GIOChannel *source, GIOCondition cond,
125 IceProcessMessages(conn, NULL, &b);
126 return TRUE; /* don't remove the event source */
129 static void ice_watch(IceConn conn, IcePointer data, Bool opening,
130 IcePointer *watch_data)
137 ch = g_io_channel_unix_new(IceConnectionNumber(conn));
138 id = g_io_add_watch(ch, G_IO_IN, ice_handler, conn);
139 g_io_channel_unref(ch);
147 void event_startup(gboolean reconfig)
149 if (reconfig) return;
151 xqueue_add_callback(event_process, NULL);
154 IceAddConnectionWatch(ice_watch, NULL);
157 client_add_destroy_notify(focus_delay_client_dest, NULL);
160 void event_shutdown(gboolean reconfig)
162 if (reconfig) return;
165 IceRemoveConnectionWatch(ice_watch, NULL);
168 client_remove_destroy_notify(focus_delay_client_dest);
171 static Window event_get_window(XEvent *e)
178 window = obt_root(ob_screen);
181 window = e->xcreatewindow.window;
184 window = e->xmaprequest.window;
187 window = e->xmap.window;
190 window = e->xunmap.window;
193 window = e->xdestroywindow.window;
195 case ConfigureRequest:
196 window = e->xconfigurerequest.window;
198 case ConfigureNotify:
199 window = e->xconfigure.window;
203 if (obt_display_extension_xkb &&
204 e->type == obt_display_extension_xkb_basep)
206 switch (((XkbAnyEvent*)e)->xkb_type) {
208 window = ((XkbBellNotifyEvent*)e)->window;
216 if (obt_display_extension_sync &&
217 e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
222 window = e->xany.window;
227 static inline Time event_get_timestamp(const XEvent *e)
229 Time t = CurrentTime;
231 /* grab the lasttime and hack up the state */
247 t = e->xproperty.time;
251 t = e->xcrossing.time;
255 if (obt_display_extension_sync &&
256 e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
258 t = ((const XSyncAlarmNotifyEvent*)e)->time;
261 /* if more event types are anticipated, get their timestamp
269 static void event_set_curtime(XEvent *e)
271 Time t = event_get_timestamp(e);
273 /* watch that if we get an event earlier than the last specified user_time,
274 which can happen if the clock goes backwards, we erase the last
275 specified user_time */
276 if (t && event_last_user_time && event_time_after(event_last_user_time, t))
277 event_reset_user_time();
279 event_sourcetime = CurrentTime;
283 static void event_hack_mods(XEvent *e)
288 e->xbutton.state = obt_keyboard_only_modmasks(e->xbutton.state);
295 e->xmotion.state = obt_keyboard_only_modmasks(e->xmotion.state);
296 /* compress events */
299 ObtXQueueWindowType wt;
301 wt.window = e->xmotion.window;
302 wt.type = MotionNotify;
303 while (xqueue_remove_local(&ce, xqueue_match_window_type, &wt)) {
304 e->xmotion.x = ce.xmotion.x;
305 e->xmotion.y = ce.xmotion.y;
306 e->xmotion.x_root = ce.xmotion.x_root;
307 e->xmotion.y_root = ce.xmotion.y_root;
314 static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
316 gint mode = e->xfocus.mode;
317 gint detail = e->xfocus.detail;
318 Window win = e->xany.window;
320 if (e->type == FocusIn) {
321 /* These are ones we never want.. */
323 /* This means focus was given by a keyboard/mouse grab. */
324 if (mode == NotifyGrab)
326 /* This means focus was given back from a keyboard/mouse grab. */
327 if (mode == NotifyUngrab)
330 /* These are the ones we want.. */
332 if (win == obt_root(ob_screen)) {
333 /* If looking for a focus in on a client, then always return
334 FALSE for focus in's to the root window */
337 /* This means focus reverted off of a client */
338 else if (detail == NotifyPointerRoot ||
339 detail == NotifyDetailNone ||
340 detail == NotifyInferior ||
341 /* This means focus got here from another screen */
342 detail == NotifyNonlinear)
348 /* It was on a client, was it a valid one?
349 It's possible to get a FocusIn event for a client that was managed
352 if (in_client_only) {
353 ObWindow *w = window_find(e->xfocus.window);
354 if (!w || !WINDOW_IS_CLIENT(w))
358 /* This means focus reverted to parent from the client (this
359 happens often during iconify animation) */
360 if (detail == NotifyInferior)
364 /* This means focus moved from the root window to a client */
365 if (detail == NotifyVirtual)
367 /* This means focus moved from one client to another */
368 if (detail == NotifyNonlinearVirtual)
374 g_assert(e->type == FocusOut);
376 /* These are ones we never want.. */
378 /* This means focus was taken by a keyboard/mouse grab. */
379 if (mode == NotifyGrab)
381 /* This means focus was grabbed on a window and it was released. */
382 if (mode == NotifyUngrab)
385 /* Focus left the root window revertedto state */
386 if (win == obt_root(ob_screen))
389 /* These are the ones we want.. */
391 /* This means focus moved from a client to the root window */
392 if (detail == NotifyVirtual)
394 /* This means focus moved from one client to another */
395 if (detail == NotifyNonlinearVirtual)
403 static gboolean event_look_for_focusin(XEvent *e, gpointer data)
405 return e->type == FocusIn && wanted_focusevent(e, FALSE);
408 static gboolean event_look_for_focusin_client(XEvent *e, gpointer data)
410 return e->type == FocusIn && wanted_focusevent(e, TRUE);
413 static void print_focusevent(XEvent *e)
415 gint mode = e->xfocus.mode;
416 gint detail = e->xfocus.detail;
417 Window win = e->xany.window;
418 const gchar *modestr, *detailstr;
421 case NotifyNormal: modestr="NotifyNormal"; break;
422 case NotifyGrab: modestr="NotifyGrab"; break;
423 case NotifyUngrab: modestr="NotifyUngrab"; break;
424 case NotifyWhileGrabbed: modestr="NotifyWhileGrabbed"; break;
425 default: g_assert_not_reached();
428 case NotifyAncestor: detailstr="NotifyAncestor"; break;
429 case NotifyVirtual: detailstr="NotifyVirtual"; break;
430 case NotifyInferior: detailstr="NotifyInferior"; break;
431 case NotifyNonlinear: detailstr="NotifyNonlinear"; break;
432 case NotifyNonlinearVirtual: detailstr="NotifyNonlinearVirtual"; break;
433 case NotifyPointer: detailstr="NotifyPointer"; break;
434 case NotifyPointerRoot: detailstr="NotifyPointerRoot"; break;
435 case NotifyDetailNone: detailstr="NotifyDetailNone"; break;
436 default: g_assert_not_reached();
439 if (mode == NotifyGrab || mode == NotifyUngrab)
444 ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s",
445 (e->xfocus.type == FocusIn ? "In" : "Out"),
451 static void event_process(const XEvent *ec, gpointer data)
455 ObClient *client = NULL;
457 ObDockApp *dockapp = NULL;
458 ObWindow *obwin = NULL;
459 ObMenuFrame *menu = NULL;
460 ObPrompt *prompt = NULL;
463 /* make a copy we can mangle */
467 window = event_get_window(e);
468 if (window == obt_root(ob_screen))
469 /* don't do any lookups, waste of cpu */;
470 else if ((obwin = window_find(window))) {
471 switch (obwin->type) {
472 case OB_WINDOW_CLASS_DOCK:
473 dock = WINDOW_AS_DOCK(obwin);
475 case OB_WINDOW_CLASS_CLIENT:
476 client = WINDOW_AS_CLIENT(obwin);
477 /* events on clients can be events on prompt windows too */
478 prompt = client->prompt;
480 case OB_WINDOW_CLASS_MENUFRAME:
481 menu = WINDOW_AS_MENUFRAME(obwin);
483 case OB_WINDOW_CLASS_INTERNAL:
484 /* we don't do anything with events directly on these windows */
486 case OB_WINDOW_CLASS_PROMPT:
487 prompt = WINDOW_AS_PROMPT(obwin);
492 dockapp = dock_find_dockapp(window);
494 event_set_curtime(e);
495 event_curserial = e->xany.serial;
498 /* deal with it in the kernel */
500 if (e->type == FocusIn) {
502 if (!wanted_focusevent(e, FALSE)) {
503 if (waiting_for_focusin) {
504 /* We were waiting for this FocusIn, since we got a FocusOut
505 earlier, but it went to a window that isn't a client. */
506 ob_debug_type(OB_DEBUG_FOCUS,
507 "Focus went to an unmanaged window 0x%x !",
509 focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
512 else if (client && e->xfocus.detail == NotifyInferior) {
513 ob_debug_type(OB_DEBUG_FOCUS, "Focus went to the frame window");
515 focus_left_screen = FALSE;
517 focus_fallback(FALSE, config_focus_under_mouse, TRUE, TRUE);
519 /* We don't get a FocusOut for this case, because it's just moving
520 from our Inferior up to us. This happens when iconifying a
521 window with RevertToParent focus */
522 frame_adjust_focus(client->frame, FALSE);
523 /* focus_set_client(NULL) has already been called */
525 else if (e->xfocus.detail == NotifyPointerRoot ||
526 e->xfocus.detail == NotifyDetailNone ||
527 e->xfocus.detail == NotifyInferior ||
528 e->xfocus.detail == NotifyNonlinear)
530 ob_debug_type(OB_DEBUG_FOCUS,
531 "Focus went to root or pointer root/none");
533 if (e->xfocus.detail == NotifyInferior ||
534 e->xfocus.detail == NotifyNonlinear)
536 focus_left_screen = FALSE;
539 /* If another FocusIn is in the queue then don't fallback yet. This
540 fixes the fun case of:
541 window map -> send focusin
542 window unmap -> get focusout
543 window map -> send focusin
544 get first focus out -> fall back to something (new window
545 hasn't received focus yet, so something else) -> send focusin
546 which means the "something else" is the last thing to get a
547 focusin sent to it, so the new window doesn't end up with focus.
549 But if the other focus in is something like PointerRoot then we
550 still want to fall back.
552 if (xqueue_exists_local(event_look_for_focusin_client, NULL)) {
553 ob_debug_type(OB_DEBUG_FOCUS,
554 " but another FocusIn is coming");
556 /* Focus has been reverted.
558 FocusOut events come after UnmapNotify, so we don't need to
559 worry about focusing an invalid window
562 if (!focus_left_screen)
563 focus_fallback(FALSE, config_focus_under_mouse,
569 ob_debug_type(OB_DEBUG_FOCUS,
570 "Focus went to a window that is already gone");
572 /* If you send focus to a window and then it disappears, you can
573 get the FocusIn for it, after it is unmanaged.
574 Just wait for the next FocusOut/FocusIn pair, but make note that
575 the window that was focused no longer is. */
576 focus_set_client(NULL);
578 else if (client != focus_client) {
579 focus_left_screen = FALSE;
580 frame_adjust_focus(client->frame, TRUE);
581 focus_set_client(client);
582 client_calc_layer(client);
583 client_bring_helper_windows(client);
586 waiting_for_focusin = FALSE;
587 } else if (e->type == FocusOut) {
589 if (!wanted_focusevent(e, FALSE))
590 ; /* skip this one */
591 /* Look for the followup FocusIn */
592 else if (!xqueue_exists_local(event_look_for_focusin, NULL)) {
593 /* There is no FocusIn, this means focus went to a window that
594 is not being managed, or a window on another screen. */
598 obt_display_ignore_errors(TRUE);
599 if (XGetInputFocus(obt_display, &win, &i) &&
600 XGetGeometry(obt_display, win, &root, &i,&i,&u,&u,&u,&u) &&
601 root != obt_root(ob_screen))
603 ob_debug_type(OB_DEBUG_FOCUS,
604 "Focus went to another screen !");
605 focus_left_screen = TRUE;
608 ob_debug_type(OB_DEBUG_FOCUS,
609 "Focus went to a black hole !");
610 obt_display_ignore_errors(FALSE);
611 /* nothing is focused */
612 focus_set_client(NULL);
614 /* Focus moved, so mark that we are waiting to process that
616 waiting_for_focusin = TRUE;
618 /* nothing is focused right now, but will be again shortly */
619 focus_set_client(NULL);
622 if (client && client != focus_client)
623 frame_adjust_focus(client->frame, FALSE);
626 event_handle_client(client, e);
628 event_handle_dockapp(dockapp, e);
630 event_handle_dock(dock, e);
632 event_handle_menu(menu, e);
633 else if (window == obt_root(ob_screen))
634 event_handle_root(e);
635 else if (e->type == MapRequest)
636 window_manage(window);
637 else if (e->type == MappingNotify) {
638 /* keyboard layout changes for modifier mapping changes. reload the
639 modifier map, and rebind all the key bindings as appropriate */
640 if (config_keyboard_rebind_on_mapping_notify) {
641 ob_debug("Keyboard map changed. Reloading keyboard bindings.");
642 ob_set_state(OB_STATE_RECONFIGURING);
643 obt_keyboard_reload();
645 ob_set_state(OB_STATE_RUNNING);
648 else if (e->type == ClientMessage) {
649 /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
650 windows that are not managed yet. */
651 if (e->xclient.message_type ==
652 OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS))
654 /* Pretend to manage the client, getting information used to
655 determine its decorations */
656 ObClient *c = client_fake_manage(e->xclient.window);
659 /* set the frame extents on the window */
660 vals[0] = c->frame->size.left;
661 vals[1] = c->frame->size.right;
662 vals[2] = c->frame->size.top;
663 vals[3] = c->frame->size.bottom;
664 OBT_PROP_SETA32(e->xclient.window, NET_FRAME_EXTENTS,
667 /* Free the pretend client */
668 client_fake_unmanage(c);
671 else if (e->type == ConfigureRequest) {
672 /* unhandled configure requests must be used to configure the
676 xwc.x = e->xconfigurerequest.x;
677 xwc.y = e->xconfigurerequest.y;
678 xwc.width = e->xconfigurerequest.width;
679 xwc.height = e->xconfigurerequest.height;
680 xwc.border_width = e->xconfigurerequest.border_width;
681 xwc.sibling = e->xconfigurerequest.above;
682 xwc.stack_mode = e->xconfigurerequest.detail;
684 /* we are not to be held responsible if someone sends us an
686 obt_display_ignore_errors(TRUE);
687 XConfigureWindow(obt_display, window,
688 e->xconfigurerequest.value_mask, &xwc);
689 obt_display_ignore_errors(FALSE);
692 else if (obt_display_extension_sync &&
693 e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
695 XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
696 if (se->alarm == moveresize_alarm && moveresize_in_progress)
701 if (e->type == ButtonPress || e->type == ButtonRelease) {
703 static guint pressed = 0;
705 event_sourcetime = event_curtime;
707 /* If the button press was on some non-root window, or was physically
708 on the root window... */
709 if (window != obt_root(ob_screen) ||
710 e->xbutton.subwindow == None ||
711 /* ...or if it is related to the last button press we handled... */
712 pressed == e->xbutton.button ||
713 /* ...or it if it was physically on an openbox
714 internal window... */
715 ((w = window_find(e->xbutton.subwindow)) &&
716 (WINDOW_IS_INTERNAL(w) || WINDOW_IS_DOCK(w))))
717 /* ...then process the event, otherwise ignore it */
719 used = event_handle_user_input(client, e);
722 used = event_handle_prompt(prompt, e);
724 if (e->type == ButtonPress)
725 pressed = e->xbutton.button;
728 else if (e->type == KeyPress || e->type == KeyRelease ||
729 e->type == MotionNotify)
731 event_sourcetime = event_curtime;
733 used = event_handle_user_input(client, e);
736 used = event_handle_prompt(prompt, e);
739 /* show any debug prompts that are queued */
740 ob_debug_show_prompts();
742 /* if something happens and it's not from an XEvent, then we don't know
743 the time, so clear it here until the next event is handled */
744 event_curtime = event_sourcetime = CurrentTime;
748 static void event_handle_root(XEvent *e)
754 ob_debug("Another WM has requested to replace us. Exiting.");
759 if (e->xclient.format != 32) break;
761 msgtype = e->xclient.message_type;
762 if (msgtype == OBT_PROP_ATOM(NET_CURRENT_DESKTOP)) {
763 guint d = e->xclient.data.l[0];
764 if (d < screen_num_desktops) {
765 if (e->xclient.data.l[1] == 0)
766 ob_debug_type(OB_DEBUG_APP_BUGS,
767 "_NET_CURRENT_DESKTOP message is missing "
770 event_sourcetime = e->xclient.data.l[1];
771 screen_set_desktop(d, TRUE);
773 } else if (msgtype == OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS)) {
774 guint d = e->xclient.data.l[0];
775 if (d > 0 && d <= 1000)
776 screen_set_num_desktops(d);
777 } else if (msgtype == OBT_PROP_ATOM(NET_SHOWING_DESKTOP)) {
778 ObScreenShowDestopMode show_mode;
779 if (e->xclient.data.l[0] != 0)
780 show_mode = SCREEN_SHOW_DESKTOP_UNTIL_WINDOW;
782 show_mode = SCREEN_SHOW_DESKTOP_NO;
783 screen_show_desktop(show_mode, NULL);
784 } else if (msgtype == OBT_PROP_ATOM(OB_CONTROL)) {
785 ob_debug("OB_CONTROL: %d", e->xclient.data.l[0]);
786 if (e->xclient.data.l[0] == 1)
788 else if (e->xclient.data.l[0] == 2)
790 else if (e->xclient.data.l[0] == 3)
792 } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
793 if ((Atom)e->xclient.data.l[0] == OBT_PROP_ATOM(NET_WM_PING))
794 ping_got_pong(e->xclient.data.l[1]);
798 if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_NAMES)) {
799 ob_debug("UPDATE DESKTOP NAMES");
800 screen_update_desktop_names();
802 else if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_LAYOUT))
803 screen_update_layout();
805 case ConfigureNotify:
807 XRRUpdateConfiguration(e);
816 void event_enter_client(ObClient *client)
818 g_assert(config_focus_follow);
820 if (is_enter_focus_event_ignored(event_curserial)) {
821 ob_debug_type(OB_DEBUG_FOCUS, "Ignoring enter event with serial %lu "
822 "on client 0x%x", event_curserial, client->window);
826 ob_debug_type(OB_DEBUG_FOCUS, "using enter event with serial %lu "
827 "on client 0x%x", event_curserial, client->window);
829 if (client_enter_focusable(client) && client_can_focus(client)) {
830 if (config_focus_delay) {
831 ObFocusDelayData *data;
833 if (focus_delay_timeout_id)
834 g_source_remove(focus_delay_timeout_id);
836 data = g_slice_new(ObFocusDelayData);
837 data->client = client;
838 data->time = event_time();
839 data->serial = event_curserial;
841 focus_delay_timeout_id = g_timeout_add_full(G_PRIORITY_DEFAULT,
846 focus_delay_timeout_client = client;
848 ObFocusDelayData data;
849 data.client = client;
850 data.time = event_time();
851 data.serial = event_curserial;
852 focus_delay_func(&data);
857 void event_leave_client(ObClient *client)
859 g_assert(config_focus_follow);
861 if (is_enter_focus_event_ignored(event_curserial)) {
862 ob_debug_type(OB_DEBUG_FOCUS, "Ignoring leave event with serial %lu\n"
863 "on client 0x%x", event_curserial, client->window);
867 if (client == focus_client) {
868 if (config_focus_delay) {
869 ObFocusDelayData *data;
871 if (unfocus_delay_timeout_id)
872 g_source_remove(unfocus_delay_timeout_id);
874 data = g_slice_new(ObFocusDelayData);
875 data->client = client;
876 data->time = event_time();
877 data->serial = event_curserial;
879 unfocus_delay_timeout_id = g_timeout_add_full(G_PRIORITY_DEFAULT,
884 unfocus_delay_timeout_client = client;
886 ObFocusDelayData data;
887 data.client = client;
888 data.time = event_time();
889 data.serial = event_curserial;
890 unfocus_delay_func(&data);
895 static gboolean *context_to_button(ObFrame *f, ObFrameContext con, gboolean press)
899 case OB_FRAME_CONTEXT_MAXIMIZE:
900 return &f->max_press;
901 case OB_FRAME_CONTEXT_CLOSE:
902 return &f->close_press;
903 case OB_FRAME_CONTEXT_ICONIFY:
904 return &f->iconify_press;
905 case OB_FRAME_CONTEXT_ALLDESKTOPS:
906 return &f->desk_press;
907 case OB_FRAME_CONTEXT_SHADE:
908 return &f->shade_press;
914 case OB_FRAME_CONTEXT_MAXIMIZE:
915 return &f->max_hover;
916 case OB_FRAME_CONTEXT_CLOSE:
917 return &f->close_hover;
918 case OB_FRAME_CONTEXT_ICONIFY:
919 return &f->iconify_hover;
920 case OB_FRAME_CONTEXT_ALLDESKTOPS:
921 return &f->desk_hover;
922 case OB_FRAME_CONTEXT_SHADE:
923 return &f->shade_hover;
930 static gboolean more_client_message_event(Window window, Atom msgtype)
932 ObtXQueueWindowMessage wm;
934 wm.message = msgtype;
935 return xqueue_exists_local(xqueue_match_window_message, &wm);
938 struct ObSkipPropertyChange {
943 static gboolean skip_property_change(XEvent *e, gpointer data)
945 const struct ObSkipPropertyChange s = *(struct ObSkipPropertyChange*)data;
947 if (e->type == PropertyNotify && e->xproperty.window == s.window) {
948 const Atom a = e->xproperty.atom;
949 const Atom b = s.prop;
951 /* these are all updated together */
952 if ((a == OBT_PROP_ATOM(NET_WM_NAME) ||
953 a == OBT_PROP_ATOM(WM_NAME) ||
954 a == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
955 a == OBT_PROP_ATOM(WM_ICON_NAME))
957 (b == OBT_PROP_ATOM(NET_WM_NAME) ||
958 b == OBT_PROP_ATOM(WM_NAME) ||
959 b == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
960 b == OBT_PROP_ATOM(WM_ICON_NAME)))
964 else if (a == b && a == OBT_PROP_ATOM(NET_WM_ICON))
970 static void event_handle_client(ObClient *client, XEvent *e)
975 static gint px = -1, py = -1;
977 static ObFrameContext pcon = OB_FRAME_CONTEXT_NONE;
981 /* save where the press occured for the first button pressed */
983 pb = e->xbutton.button;
987 pcon = frame_context(client, e->xbutton.window, px, py);
988 pcon = mouse_button_frame_context(pcon, e->xbutton.button,
992 /* Wheel buttons don't draw because they are an instant click, so it
993 is a waste of resources to go drawing it.
994 if the user is doing an interactive thing, or has a menu open then
995 the mouse is grabbed (possibly) and if we get these events we don't
996 want to deal with them
998 if (!(e->xbutton.button == 4 || e->xbutton.button == 5) &&
1001 /* use where the press occured */
1002 con = frame_context(client, e->xbutton.window, px, py);
1003 con = mouse_button_frame_context(con, e->xbutton.button,
1006 /* button presses on CLIENT_CONTEXTs are not accompanied by a
1007 release because they are Replayed to the client */
1008 if ((e->type == ButtonRelease || CLIENT_CONTEXT(con, client)) &&
1009 e->xbutton.button == pb)
1010 pb = 0, px = py = -1, pcon = OB_FRAME_CONTEXT_NONE;
1012 but = context_to_button(client->frame, con, TRUE);
1014 *but = (e->type == ButtonPress);
1015 frame_adjust_state(client->frame);
1020 /* when there is a grab on the pointer, we won't get enter/leave
1021 notifies, but we still get motion events */
1022 if (grab_on_pointer()) break;
1024 con = frame_context(client, e->xmotion.window,
1025 e->xmotion.x, e->xmotion.y);
1027 case OB_FRAME_CONTEXT_TITLEBAR:
1028 case OB_FRAME_CONTEXT_TLCORNER:
1029 case OB_FRAME_CONTEXT_TRCORNER:
1030 /* we've left the button area inside the titlebar */
1031 if (client->frame->max_hover || client->frame->desk_hover ||
1032 client->frame->shade_hover || client->frame->iconify_hover ||
1033 client->frame->close_hover)
1035 client->frame->max_hover =
1036 client->frame->desk_hover =
1037 client->frame->shade_hover =
1038 client->frame->iconify_hover =
1039 client->frame->close_hover = FALSE;
1040 frame_adjust_state(client->frame);
1044 but = context_to_button(client->frame, con, FALSE);
1045 if (but && !*but && !pb) {
1047 frame_adjust_state(client->frame);
1053 con = frame_context(client, e->xcrossing.window,
1054 e->xcrossing.x, e->xcrossing.y);
1056 case OB_FRAME_CONTEXT_TITLEBAR:
1057 case OB_FRAME_CONTEXT_TLCORNER:
1058 case OB_FRAME_CONTEXT_TRCORNER:
1059 /* we've left the button area inside the titlebar */
1060 client->frame->max_hover =
1061 client->frame->desk_hover =
1062 client->frame->shade_hover =
1063 client->frame->iconify_hover =
1064 client->frame->close_hover = FALSE;
1065 if (e->xcrossing.mode == NotifyGrab) {
1066 client->frame->max_press =
1067 client->frame->desk_press =
1068 client->frame->shade_press =
1069 client->frame->iconify_press =
1070 client->frame->close_press = FALSE;
1073 case OB_FRAME_CONTEXT_FRAME:
1074 /* When the mouse leaves an animating window, don't use the
1075 corresponding enter events. Pretend like the animating window
1076 doesn't even exist..! */
1077 if (frame_iconify_animating(client->frame))
1078 event_end_ignore_all_enters(event_start_ignore_all_enters());
1080 ob_debug_type(OB_DEBUG_FOCUS,
1081 "%sNotify mode %d detail %d on %lx",
1082 (e->type == EnterNotify ? "Enter" : "Leave"),
1084 e->xcrossing.detail, (client?client->window:0));
1085 if (grab_on_keyboard())
1087 if (config_focus_follow &&
1088 /* leave inferior events can happen when the mouse goes onto
1089 the window's border and then into the window before the
1091 e->xcrossing.detail != NotifyInferior)
1093 if (config_focus_delay && focus_delay_timeout_id)
1094 g_source_remove(focus_delay_timeout_id);
1095 if (config_unfocus_leave)
1096 event_leave_client(client);
1100 but = context_to_button(client->frame, con, FALSE);
1103 if (e->xcrossing.mode == NotifyGrab) {
1104 but = context_to_button(client->frame, con, TRUE);
1107 frame_adjust_state(client->frame);
1114 con = frame_context(client, e->xcrossing.window,
1115 e->xcrossing.x, e->xcrossing.y);
1117 case OB_FRAME_CONTEXT_FRAME:
1118 if (grab_on_keyboard())
1120 if (e->xcrossing.mode == NotifyGrab ||
1121 (e->xcrossing.mode == NotifyUngrab &&
1122 /* ungrab enters are used when _under_ mouse is being used */
1123 !(config_focus_follow && config_focus_under_mouse)) ||
1124 /*ignore enters when we're already in the window */
1125 e->xcrossing.detail == NotifyInferior)
1127 ob_debug_type(OB_DEBUG_FOCUS,
1128 "%sNotify mode %d detail %d serial %lu on %lx "
1130 (e->type == EnterNotify ? "Enter" : "Leave"),
1132 e->xcrossing.detail,
1133 e->xcrossing.serial,
1134 client?client->window:0);
1137 ob_debug_type(OB_DEBUG_FOCUS,
1138 "%sNotify mode %d detail %d serial %lu on %lx, "
1140 (e->type == EnterNotify ? "Enter" : "Leave"),
1142 e->xcrossing.detail,
1143 e->xcrossing.serial,
1144 (client?client->window:0));
1145 if (config_focus_follow) {
1146 if (config_focus_delay && unfocus_delay_timeout_id)
1147 g_source_remove(unfocus_delay_timeout_id);
1148 event_enter_client(client);
1153 but = context_to_button(client->frame, con, FALSE);
1156 if (e->xcrossing.mode == NotifyUngrab) {
1157 but = context_to_button(client->frame, con, TRUE);
1158 *but = (con == pcon);
1160 frame_adjust_state(client->frame);
1166 case ConfigureRequest:
1168 /* dont compress these unless you're going to watch for property
1169 notifies in between (these can change what the configure would
1171 also you can't compress stacking events
1175 gboolean move = FALSE;
1176 gboolean resize = FALSE;
1178 /* get the current area */
1179 RECT_TO_DIMS(client->area, x, y, w, h);
1181 ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1184 screen_desktop, client->wmstate, client->frame->visible);
1185 ob_debug(" x %d y %d w %d h %d b %d",
1186 x, y, w, h, client->border_width);
1188 if (e->xconfigurerequest.value_mask & CWBorderWidth)
1189 if (client->border_width != e->xconfigurerequest.border_width) {
1190 client->border_width = e->xconfigurerequest.border_width;
1192 /* if the border width is changing then that is the same
1193 as requesting a resize, but we don't actually change
1194 the client's border, so it will change their root
1195 coordinates (since they include the border width) and
1196 we need to a notify then */
1200 if (e->xconfigurerequest.value_mask & CWStackMode) {
1201 ObClient *sibling = NULL;
1202 gulong ignore_start;
1205 /* get the sibling */
1206 if (e->xconfigurerequest.value_mask & CWSibling) {
1208 win = window_find(e->xconfigurerequest.above);
1209 if (win && WINDOW_IS_CLIENT(win) &&
1210 WINDOW_AS_CLIENT(win) != client)
1212 sibling = WINDOW_AS_CLIENT(win);
1215 /* an invalid sibling was specified so don't restack at
1216 all, it won't make sense no matter what we do */
1221 if (!config_focus_under_mouse)
1222 ignore_start = event_start_ignore_all_enters();
1223 stacking_restack_request(client, sibling,
1224 e->xconfigurerequest.detail);
1225 if (!config_focus_under_mouse)
1226 event_end_ignore_all_enters(ignore_start);
1229 /* a stacking change moves the window without resizing */
1233 if ((e->xconfigurerequest.value_mask & CWX) ||
1234 (e->xconfigurerequest.value_mask & CWY) ||
1235 (e->xconfigurerequest.value_mask & CWWidth) ||
1236 (e->xconfigurerequest.value_mask & CWHeight))
1238 /* don't allow clients to move shaded windows (fvwm does this)
1240 if (e->xconfigurerequest.value_mask & CWX) {
1241 if (!client->shaded)
1242 x = e->xconfigurerequest.x;
1245 if (e->xconfigurerequest.value_mask & CWY) {
1246 if (!client->shaded)
1247 y = e->xconfigurerequest.y;
1251 if (e->xconfigurerequest.value_mask & CWWidth) {
1252 w = e->xconfigurerequest.width;
1255 if (e->xconfigurerequest.value_mask & CWHeight) {
1256 h = e->xconfigurerequest.height;
1261 ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1262 "move %d resize %d",
1263 e->xconfigurerequest.value_mask & CWX, x,
1264 e->xconfigurerequest.value_mask & CWY, y,
1265 e->xconfigurerequest.value_mask & CWWidth, w,
1266 e->xconfigurerequest.value_mask & CWHeight, h,
1269 /* check for broken apps moving to their root position
1271 XXX remove this some day...that would be nice. right now all
1272 kde apps do this when they try activate themselves on another
1273 desktop. eg. open amarok window on desktop 1, switch to desktop
1274 2, click amarok tray icon. it will move by its decoration size.
1276 if (x != client->area.x &&
1277 x == (client->frame->area.x + client->frame->size.left -
1278 (gint)client->border_width) &&
1279 y != client->area.y &&
1280 y == (client->frame->area.y + client->frame->size.top -
1281 (gint)client->border_width) &&
1282 w == client->area.width &&
1283 h == client->area.height)
1285 ob_debug_type(OB_DEBUG_APP_BUGS,
1286 "Application %s is trying to move via "
1287 "ConfigureRequest to it's root window position "
1288 "but it is not using StaticGravity",
1294 /* they still requested a move, so don't change whether a
1295 notify is sent or not */
1298 /* check for broken apps (java swing) moving to 0,0 when there is a
1301 XXX remove this some day...that would be nice. but really unexpected
1302 from Sun Microsystems.
1304 if (x == 0 && y == 0 && client->gravity == NorthWestGravity &&
1305 client_normal(client))
1307 const Rect to = { x, y, w, h };
1309 /* oldschool fullscreen windows are allowed */
1310 if (!client_is_oldfullscreen(client, &to)) {
1313 r = screen_area(client->desktop, SCREEN_AREA_ALL_MONITORS,
1316 /* move the window only to the corner outside struts */
1320 ob_debug_type(OB_DEBUG_APP_BUGS,
1321 "Application %s is trying to move via "
1322 "ConfigureRequest to 0,0 using "
1323 "NorthWestGravity, while there is a "
1325 "Moving buggy app from (0,0) to (%d,%d)",
1326 client->title, r->x, r->y);
1329 g_slice_free(Rect, r);
1331 /* they still requested a move, so don't change whether a
1332 notify is sent or not */
1339 client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
1341 /* if x was not given, then use gravity to figure out the new
1342 x. the reference point should not be moved */
1343 if ((e->xconfigurerequest.value_mask & CWWidth &&
1344 !(e->xconfigurerequest.value_mask & CWX)))
1345 client_gravity_resize_w(client, &x, client->area.width, w);
1347 if ((e->xconfigurerequest.value_mask & CWHeight &&
1348 !(e->xconfigurerequest.value_mask & CWY)))
1349 client_gravity_resize_h(client, &y, client->area.height,h);
1351 client_find_onscreen(client, &x, &y, w, h, FALSE);
1353 ob_debug("Granting ConfigureRequest x %d y %d w %d h %d",
1355 client_configure(client, x, y, w, h, FALSE, TRUE, TRUE);
1360 ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1362 client->window, e->xunmap.event, e->xunmap.from_configure,
1363 client->ignore_unmaps);
1364 if (client->ignore_unmaps) {
1365 client->ignore_unmaps--;
1368 client_unmanage(client);
1371 ob_debug("DestroyNotify for window 0x%x", client->window);
1372 client_unmanage(client);
1374 case ReparentNotify:
1375 /* this is when the client is first taken captive in the frame */
1376 if (e->xreparent.parent == client->frame->window) break;
1379 This event is quite rare and is usually handled in unmapHandler.
1380 However, if the window is unmapped when the reparent event occurs,
1381 the window manager never sees it because an unmap event is not sent
1382 to an already unmapped window.
1385 ob_debug("ReparentNotify for window 0x%x", client->window);
1386 client_unmanage(client);
1389 ob_debug("MapRequest for 0x%lx", client->window);
1390 if (!client->iconic) break; /* this normally doesn't happen, but if it
1391 does, we don't want it!
1392 it can happen now when the window is on
1393 another desktop, but we still don't
1395 client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE);
1398 /* validate cuz we query stuff off the client here */
1399 if (!client_validate(client)) break;
1401 if (e->xclient.format != 32) return;
1403 msgtype = e->xclient.message_type;
1404 if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) {
1405 if (!more_client_message_event(client->window, msgtype))
1406 client_set_wm_state(client, e->xclient.data.l[0]);
1407 } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) {
1408 if (!more_client_message_event(client->window, msgtype) &&
1409 ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
1410 (unsigned)e->xclient.data.l[0] == DESKTOP_ALL))
1412 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
1415 } else if (msgtype == OBT_PROP_ATOM(NET_WM_STATE)) {
1416 gulong ignore_start;
1418 /* can't compress these */
1419 ob_debug("net_wm_state %s %ld %ld for 0x%lx",
1420 (e->xclient.data.l[0] == 0 ? "Remove" :
1421 e->xclient.data.l[0] == 1 ? "Add" :
1422 e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
1423 e->xclient.data.l[1], e->xclient.data.l[2],
1426 /* ignore enter events caused by these like ob actions do */
1427 if (!config_focus_under_mouse)
1428 ignore_start = event_start_ignore_all_enters();
1429 client_set_state(client, e->xclient.data.l[0],
1430 e->xclient.data.l[1], e->xclient.data.l[2]);
1431 if (!config_focus_under_mouse)
1432 event_end_ignore_all_enters(ignore_start);
1433 } else if (msgtype == OBT_PROP_ATOM(NET_CLOSE_WINDOW)) {
1434 ob_debug("net_close_window for 0x%lx", client->window);
1435 client_close(client);
1436 } else if (msgtype == OBT_PROP_ATOM(NET_ACTIVE_WINDOW)) {
1437 ob_debug("net_active_window for 0x%lx source=%s",
1439 (e->xclient.data.l[0] == 0 ? "unknown" :
1440 (e->xclient.data.l[0] == 1 ? "application" :
1441 (e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
1442 /* XXX make use of data.l[2] !? */
1443 if (e->xclient.data.l[0] == 1 || e->xclient.data.l[0] == 2) {
1444 /* we can not trust the timestamp from applications.
1445 e.g. chromium passes a very old timestamp. openbox thinks
1446 the window will get focus and calls XSetInputFocus with the
1447 (old) timestamp, which doesn't end up moving focus at all.
1448 but the window is raised, not hilited, etc, as if it was
1449 really going to get focus.
1451 so do not use this timestamp in event_curtime, as this would
1452 be used in XSetInputFocus.
1454 event_sourcetime = e->xclient.data.l[1];
1455 if (e->xclient.data.l[1] == 0)
1456 ob_debug_type(OB_DEBUG_APP_BUGS,
1457 "_NET_ACTIVE_WINDOW message for window %s is"
1458 " missing a timestamp", client->title);
1460 ob_debug_type(OB_DEBUG_APP_BUGS,
1461 "_NET_ACTIVE_WINDOW message for window %s is "
1462 "missing source indication", client->title);
1463 /* TODO(danakj) This should use
1464 (e->xclient.data.l[0] == 0 ||
1465 e->xclient.data.l[0] == 2)
1466 to determine if a user requested the activation, however GTK+
1467 applications seem unable to make this distinction ever
1468 (including panels such as xfce4-panel and gnome-panel).
1469 So we are left just assuming all activations are from the user.
1471 client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE);
1472 } else if (msgtype == OBT_PROP_ATOM(NET_WM_MOVERESIZE)) {
1473 ob_debug("net_wm_moveresize for 0x%lx direction %d",
1474 client->window, e->xclient.data.l[2]);
1475 if ((Atom)e->xclient.data.l[2] ==
1476 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT) ||
1477 (Atom)e->xclient.data.l[2] ==
1478 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP) ||
1479 (Atom)e->xclient.data.l[2] ==
1480 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT) ||
1481 (Atom)e->xclient.data.l[2] ==
1482 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
1483 (Atom)e->xclient.data.l[2] ==
1484 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
1485 (Atom)e->xclient.data.l[2] ==
1486 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT) ||
1487 (Atom)e->xclient.data.l[2] ==
1488 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM) ||
1489 (Atom)e->xclient.data.l[2] ==
1490 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT) ||
1491 (Atom)e->xclient.data.l[2] ==
1492 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT) ||
1493 (Atom)e->xclient.data.l[2] ==
1494 OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE) ||
1495 (Atom)e->xclient.data.l[2] ==
1496 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD) ||
1497 (Atom)e->xclient.data.l[2] ==
1498 OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD))
1500 moveresize_start(client, e->xclient.data.l[0],
1501 e->xclient.data.l[1], e->xclient.data.l[3],
1502 e->xclient.data.l[2]);
1504 else if ((Atom)e->xclient.data.l[2] ==
1505 OBT_PROP_ATOM(NET_WM_MOVERESIZE_CANCEL))
1506 if (moveresize_client)
1507 moveresize_end(TRUE);
1508 } else if (msgtype == OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW)) {
1509 gint ograv, x, y, w, h;
1511 ograv = client->gravity;
1513 if (e->xclient.data.l[0] & 0xff)
1514 client->gravity = e->xclient.data.l[0] & 0xff;
1516 if (e->xclient.data.l[0] & 1 << 8)
1517 x = e->xclient.data.l[1];
1520 if (e->xclient.data.l[0] & 1 << 9)
1521 y = e->xclient.data.l[2];
1525 if (e->xclient.data.l[0] & 1 << 10) {
1526 w = e->xclient.data.l[3];
1528 /* if x was not given, then use gravity to figure out the new
1529 x. the reference point should not be moved */
1530 if (!(e->xclient.data.l[0] & 1 << 8))
1531 client_gravity_resize_w(client, &x, client->area.width, w);
1534 w = client->area.width;
1536 if (e->xclient.data.l[0] & 1 << 11) {
1537 h = e->xclient.data.l[4];
1540 if (!(e->xclient.data.l[0] & 1 << 9))
1541 client_gravity_resize_h(client, &y, client->area.height,h);
1544 h = client->area.height;
1546 ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)",
1547 e->xclient.data.l[0] & 1 << 8, x,
1548 e->xclient.data.l[0] & 1 << 9, y,
1551 client_find_onscreen(client, &x, &y, w, h, FALSE);
1553 client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
1555 client->gravity = ograv;
1556 } else if (msgtype == OBT_PROP_ATOM(NET_RESTACK_WINDOW)) {
1557 if (e->xclient.data.l[0] != 2) {
1558 ob_debug_type(OB_DEBUG_APP_BUGS,
1559 "_NET_RESTACK_WINDOW sent for window %s with "
1560 "invalid source indication %ld",
1561 client->title, e->xclient.data.l[0]);
1563 ObClient *sibling = NULL;
1564 if (e->xclient.data.l[1]) {
1565 ObWindow *win = window_find(e->xclient.data.l[1]);
1566 if (WINDOW_IS_CLIENT(win) &&
1567 WINDOW_AS_CLIENT(win) != client)
1569 sibling = WINDOW_AS_CLIENT(win);
1571 if (sibling == NULL)
1572 ob_debug_type(OB_DEBUG_APP_BUGS,
1573 "_NET_RESTACK_WINDOW sent for window %s "
1574 "with invalid sibling 0x%x",
1575 client->title, e->xclient.data.l[1]);
1577 if (e->xclient.data.l[2] == Below ||
1578 e->xclient.data.l[2] == BottomIf ||
1579 e->xclient.data.l[2] == Above ||
1580 e->xclient.data.l[2] == TopIf ||
1581 e->xclient.data.l[2] == Opposite)
1583 gulong ignore_start;
1585 if (!config_focus_under_mouse)
1586 ignore_start = event_start_ignore_all_enters();
1587 /* just raise, don't activate */
1588 stacking_restack_request(client, sibling,
1589 e->xclient.data.l[2]);
1590 if (!config_focus_under_mouse)
1591 event_end_ignore_all_enters(ignore_start);
1593 /* send a synthetic ConfigureNotify, cuz this is supposed
1594 to be like a ConfigureRequest. */
1595 client_reconfigure(client, TRUE);
1597 ob_debug_type(OB_DEBUG_APP_BUGS,
1598 "_NET_RESTACK_WINDOW sent for window %s "
1599 "with invalid detail %d",
1600 client->title, e->xclient.data.l[2]);
1604 case PropertyNotify:
1605 /* validate cuz we query stuff off the client here */
1606 if (!client_validate(client)) break;
1608 msgtype = e->xproperty.atom;
1610 /* ignore changes to some properties if there is another change
1611 coming in the queue */
1613 struct ObSkipPropertyChange s;
1614 s.window = client->window;
1616 if (xqueue_exists_local(skip_property_change, &s))
1620 msgtype = e->xproperty.atom;
1621 if (msgtype == XA_WM_NORMAL_HINTS) {
1622 int x, y, w, h, lw, lh;
1624 ob_debug("Update NORMAL hints");
1625 client_update_normal_hints(client);
1626 /* normal hints can make a window non-resizable */
1627 client_setup_decor_and_functions(client, FALSE);
1631 w = client->area.width;
1632 h = client->area.height;
1634 /* apply the new normal hints */
1635 client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
1636 /* make sure the window is visible, and if the window is resized
1637 off-screen due to the normal hints changing then this will push
1638 it back onto the screen. */
1639 client_find_onscreen(client, &x, &y, w, h, FALSE);
1641 /* make sure the client's sizes are within its bounds, but don't
1642 make it reply with a configurenotify unless something changed.
1643 emacs will update its normal hints every time it receives a
1645 client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
1646 } else if (msgtype == OBT_PROP_ATOM(MOTIF_WM_HINTS)) {
1647 client_get_mwm_hints(client);
1648 /* This can override some mwm hints */
1649 client_get_type_and_transientness(client);
1651 /* Apply the changes to the window */
1652 client_setup_decor_and_functions(client, TRUE);
1653 } else if (msgtype == XA_WM_HINTS) {
1654 client_update_wmhints(client);
1655 } else if (msgtype == XA_WM_TRANSIENT_FOR) {
1656 /* get the transient-ness first, as this affects if the client
1657 decides to be transient for the group or not in
1658 client_update_transient_for() */
1659 client_get_type_and_transientness(client);
1660 client_update_transient_for(client);
1661 /* type may have changed, so update the layer */
1662 client_calc_layer(client);
1663 client_setup_decor_and_functions(client, TRUE);
1664 } else if (msgtype == OBT_PROP_ATOM(NET_WM_NAME) ||
1665 msgtype == OBT_PROP_ATOM(WM_NAME) ||
1666 msgtype == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
1667 msgtype == OBT_PROP_ATOM(WM_ICON_NAME)) {
1668 client_update_title(client);
1669 } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
1670 client_update_protocols(client);
1672 else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT) ||
1673 msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) {
1674 client_update_strut(client);
1676 else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON)) {
1677 client_update_icons(client);
1679 else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY)) {
1680 client_update_icon_geometry(client);
1682 else if (msgtype == OBT_PROP_ATOM(NET_WM_USER_TIME)) {
1684 if (client == focus_client &&
1685 OBT_PROP_GET32(client->window, NET_WM_USER_TIME, CARDINAL, &t)
1686 && t && !event_time_after(t, e->xproperty.time) &&
1687 (!event_last_user_time ||
1688 event_time_after(t, event_last_user_time)))
1690 event_last_user_time = t;
1693 else if (msgtype == OBT_PROP_ATOM(NET_WM_WINDOW_OPACITY)) {
1694 client_update_opacity(client);
1697 else if (msgtype == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER)) {
1698 /* if they are resizing right now this would cause weird behaviour.
1699 if one day a user reports clients stop resizing, then handle
1700 this better by resetting a new XSync alarm and stuff on the
1701 new counter, but I expect it will never happen */
1702 if (moveresize_client == client)
1703 moveresize_end(FALSE);
1704 client_update_sync_request_counter(client);
1708 case ColormapNotify:
1709 client_update_colormap(client, e->xcolormap.colormap);
1716 if (obt_display_extension_shape &&
1717 e->type == obt_display_extension_shape_basep)
1719 switch (((XShapeEvent*)e)->kind) {
1722 client->shaped = ((XShapeEvent*)e)->shaped;
1723 kind = ShapeBounding;
1727 client->shaped_input = ((XShapeEvent*)e)->shaped;
1732 g_assert_not_reached();
1734 frame_adjust_shape_kind(client->frame, kind);
1741 static void event_handle_dock(ObDock *s, XEvent *e)
1748 /* don't hide when moving into a dock app */
1749 if (e->xcrossing.detail != NotifyInferior)
1755 static void event_handle_dockapp(ObDockApp *app, XEvent *e)
1759 dock_app_drag(app, &e->xmotion);
1762 if (app->ignore_unmaps) {
1763 app->ignore_unmaps--;
1766 dock_unmanage(app, TRUE);
1769 case ReparentNotify:
1770 dock_unmanage(app, FALSE);
1772 case ConfigureNotify:
1773 dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
1778 static ObMenuFrame* find_active_menu(void)
1781 ObMenuFrame *ret = NULL;
1783 for (it = menu_frame_visible; it; it = g_list_next(it)) {
1792 static ObMenuFrame* find_active_or_last_menu(void)
1794 ObMenuFrame *ret = NULL;
1796 ret = find_active_menu();
1797 if (!ret && menu_frame_visible)
1798 ret = menu_frame_visible->data;
1802 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e)
1808 return prompt_mouse_event(p, e);
1811 return prompt_key_event(p, e);
1817 static gboolean event_handle_menu_input(XEvent *ev)
1819 gboolean ret = FALSE;
1821 if (ev->type == ButtonRelease || ev->type == ButtonPress) {
1822 ObMenuEntryFrame *e;
1824 if ((ev->xbutton.button < 4 || ev->xbutton.button > 5) &&
1825 ((ev->type == ButtonRelease && menu_hide_delay_reached()) ||
1826 ev->type == ButtonPress))
1828 if ((e = menu_entry_frame_under(ev->xbutton.x_root,
1829 ev->xbutton.y_root)))
1831 if (ev->type == ButtonPress && e->frame->child)
1832 menu_frame_select(e->frame->child, NULL, TRUE);
1833 menu_frame_select(e->frame, e, TRUE);
1834 if (ev->type == ButtonRelease)
1835 menu_entry_frame_execute(e, ev->xbutton.state);
1838 menu_frame_hide_all();
1842 else if (ev->type == KeyPress || ev->type == KeyRelease) {
1846 /* get the modifiers */
1847 mods = obt_keyboard_only_modmasks(ev->xkey.state);
1849 frame = find_active_or_last_menu();
1851 g_assert_not_reached(); /* there is no active menu */
1853 /* Allow control while going thru the menu */
1854 else if (ev->type == KeyPress && (mods & ~ControlMask) == 0) {
1858 frame->got_press = TRUE;
1859 frame->press_keycode = ev->xkey.keycode;
1860 frame->press_doexec = FALSE;
1862 sym = obt_keyboard_keypress_to_keysym(ev);
1864 if (sym == XK_Escape) {
1865 menu_frame_hide_all();
1869 else if (sym == XK_Left) {
1870 /* Left goes to the parent menu */
1871 if (frame->parent) {
1872 /* remove focus from the child */
1873 menu_frame_select(frame, NULL, TRUE);
1874 /* and put it in the parent */
1875 menu_frame_select(frame->parent, frame->parent->selected,
1881 else if (sym == XK_Right || sym == XK_Return || sym == XK_KP_Enter)
1883 /* Right and enter goes to the selected submenu.
1884 Enter executes instead if it's not on a submenu. */
1886 if (frame->selected) {
1887 const ObMenuEntryType t = frame->selected->entry->type;
1889 if (t == OB_MENU_ENTRY_TYPE_SUBMENU) {
1890 /* make sure it is visible */
1891 menu_frame_select(frame, frame->selected, TRUE);
1892 /* move focus to the child menu */
1893 menu_frame_select_next(frame->child);
1895 else if (sym != XK_Right) {
1896 frame->press_doexec = TRUE;
1902 else if (sym == XK_Up) {
1903 menu_frame_select_previous(frame);
1907 else if (sym == XK_Down) {
1908 menu_frame_select_next(frame);
1912 else if (sym == XK_Home) {
1913 menu_frame_select_first(frame);
1917 else if (sym == XK_End) {
1918 menu_frame_select_last(frame);
1922 /* keyboard accelerator shortcuts. (if it was a valid key) */
1923 else if (frame->entries &&
1925 obt_keyboard_keypress_to_unichar(menu_frame_ic(frame),
1930 ObMenuEntryFrame *found = NULL;
1931 guint num_found = 0;
1933 /* start after the selected one */
1934 start = frame->entries;
1935 if (frame->selected) {
1936 for (it = start; frame->selected != it->data;
1937 it = g_list_next(it))
1938 g_assert(it != NULL); /* nothing was selected? */
1939 /* next with wraparound */
1940 start = g_list_next(it);
1941 if (start == NULL) start = frame->entries;
1946 ObMenuEntryFrame *e = it->data;
1947 gunichar entrykey = 0;
1949 if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
1950 entrykey = e->entry->data.normal.shortcut;
1951 else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
1952 entrykey = e->entry->data.submenu.submenu->shortcut;
1954 if (unikey == entrykey) {
1955 if (found == NULL) found = e;
1959 /* next with wraparound */
1960 it = g_list_next(it);
1961 if (it == NULL) it = frame->entries;
1962 } while (it != start);
1965 menu_frame_select(frame, found, TRUE);
1967 if (num_found == 1) {
1968 if (found->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU) {
1969 /* move focus to the child menu */
1970 menu_frame_select_next(frame->child);
1973 frame->press_doexec = TRUE;
1981 /* Use KeyRelease events for running things so that the key release
1982 doesn't get sent to the focused application.
1984 Allow ControlMask only, and don't bother if the menu is empty */
1985 else if (ev->type == KeyRelease && (mods & ~ControlMask) == 0) {
1986 if (frame->press_keycode == ev->xkey.keycode &&
1988 frame->press_doexec)
1990 if (frame->selected)
1991 menu_entry_frame_execute(frame->selected, ev->xkey.state);
1999 static gboolean event_look_for_menu_enter(XEvent *ev, gpointer data)
2001 const ObMenuFrame *f = (ObMenuFrame*)data;
2002 ObMenuEntryFrame *e;
2003 return ev->type == EnterNotify &&
2004 (e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
2005 e->frame == f && !e->ignore_enters;
2008 static void event_handle_menu(ObMenuFrame *frame, XEvent *ev)
2011 ObMenuEntryFrame *e;
2015 /* We need to catch MotionNotify in addition to EnterNotify because
2016 it is possible for the menu to be opened under the mouse cursor, and
2017 moving the mouse should select the item. */
2018 if ((e = g_hash_table_lookup(menu_frame_map, &ev->xmotion.window))) {
2019 if (e->ignore_enters)
2021 else if (!(f = find_active_menu()) ||
2023 f->parent == e->frame ||
2024 f->child == e->frame)
2025 menu_frame_select(e->frame, e, FALSE);
2029 if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
2030 if (e->ignore_enters)
2032 else if (!(f = find_active_menu()) ||
2034 f->parent == e->frame ||
2035 f->child == e->frame)
2036 menu_frame_select(e->frame, e, FALSE);
2040 /* ignore leaves when we're already in the window */
2041 if (ev->xcrossing.detail == NotifyInferior)
2044 if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
2045 /* check if an EnterNotify event is coming, and if not, then select
2046 nothing in the menu */
2047 if (!xqueue_exists_local(event_look_for_menu_enter, e->frame))
2048 menu_frame_select(e->frame, NULL, FALSE);
2054 static gboolean event_handle_user_input(ObClient *client, XEvent *e)
2056 g_assert(e->type == ButtonPress || e->type == ButtonRelease ||
2057 e->type == MotionNotify || e->type == KeyPress ||
2058 e->type == KeyRelease);
2060 if (menu_frame_visible) {
2061 if (event_handle_menu_input(e))
2062 /* don't use the event if the menu used it, but if the menu
2063 didn't use it and it's a keypress that is bound, it will
2064 close the menu and be used */
2068 /* if the keyboard interactive action uses the event then dont
2069 use it for bindings. likewise is moveresize uses the event. */
2070 if (actions_interactive_input_event(e) || moveresize_event(e))
2073 if (moveresize_in_progress)
2074 /* make further actions work on the client being
2076 client = moveresize_client;
2078 if (e->type == ButtonPress ||
2079 e->type == ButtonRelease ||
2080 e->type == MotionNotify)
2082 /* the frame may not be "visible" but they can still click on it
2083 in the case where it is animating before disappearing */
2084 if (!client || !frame_iconify_animating(client->frame))
2085 return mouse_event(client, e);
2087 return keyboard_event((focus_cycle_target ? focus_cycle_target :
2088 (client ? client : focus_client)), e);
2093 static void focus_delay_dest(gpointer data)
2095 g_slice_free(ObFocusDelayData, data);
2096 focus_delay_timeout_id = 0;
2097 focus_delay_timeout_client = NULL;
2100 static void unfocus_delay_dest(gpointer data)
2102 g_slice_free(ObFocusDelayData, data);
2103 unfocus_delay_timeout_id = 0;
2104 unfocus_delay_timeout_client = NULL;
2107 static gboolean focus_delay_func(gpointer data)
2109 ObFocusDelayData *d = data;
2110 Time old = event_curtime; /* save the curtime */
2112 event_curtime = d->time;
2113 event_curserial = d->serial;
2114 if (client_focus(d->client) && config_focus_raise)
2115 stacking_raise(CLIENT_AS_WINDOW(d->client));
2116 event_curtime = old;
2117 return FALSE; /* no repeat */
2120 static gboolean unfocus_delay_func(gpointer data)
2122 ObFocusDelayData *d = data;
2123 Time old = event_curtime; /* save the curtime */
2125 event_curtime = d->time;
2126 event_curserial = d->serial;
2128 event_curtime = old;
2129 return FALSE; /* no repeat */
2132 static void focus_delay_client_dest(ObClient *client, gpointer data)
2134 if (focus_delay_timeout_client == client && focus_delay_timeout_id)
2135 g_source_remove(focus_delay_timeout_id);
2136 if (unfocus_delay_timeout_client == client && unfocus_delay_timeout_id)
2137 g_source_remove(unfocus_delay_timeout_id);
2140 void event_halt_focus_delay(void)
2142 /* ignore all enter events up till the event which caused this to occur */
2143 if (event_curserial) event_ignore_enter_range(1, event_curserial);
2144 if (focus_delay_timeout_id) g_source_remove(focus_delay_timeout_id);
2145 if (unfocus_delay_timeout_id) g_source_remove(unfocus_delay_timeout_id);
2148 gulong event_start_ignore_all_enters(void)
2150 return NextRequest(obt_display);
2153 static void event_ignore_enter_range(gulong start, gulong end)
2157 g_assert(start != 0);
2160 r = g_slice_new(ObSerialRange);
2163 ignore_serials = g_slist_prepend(ignore_serials, r);
2165 ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu",
2168 /* increment the serial so we don't ignore events we weren't meant to */
2169 OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS);
2172 void event_end_ignore_all_enters(gulong start)
2174 /* Use (NextRequest-1) so that we ignore up to the current serial only.
2175 Inside event_ignore_enter_range, we increment the serial by one, but if
2176 we ignore that serial too, then any enter events generated by mouse
2177 movement will be ignored until we create some further network traffic.
2178 Instead ignore up to NextRequest-1, then when we increment the serial,
2179 we will be *past* the range of ignored serials */
2180 event_ignore_enter_range(start, NextRequest(obt_display)-1);
2183 static gboolean is_enter_focus_event_ignored(gulong serial)
2187 for (it = ignore_serials; it; it = next) {
2188 ObSerialRange *r = it->data;
2190 next = g_slist_next(it);
2192 if ((glong)(serial - r->end) > 0) {
2194 ignore_serials = g_slist_delete_link(ignore_serials, it);
2195 g_slice_free(ObSerialRange, r);
2197 else if ((glong)(serial - r->start) >= 0)
2203 void event_cancel_all_key_grabs(void)
2205 if (actions_interactive_act_running()) {
2206 actions_interactive_cancel_act();
2207 ob_debug("KILLED interactive action");
2209 else if (menu_frame_visible) {
2210 menu_frame_hide_all();
2211 ob_debug("KILLED open menus");
2213 else if (moveresize_in_progress) {
2214 moveresize_end(TRUE);
2215 ob_debug("KILLED interactive moveresize");
2217 else if (grab_on_keyboard()) {
2219 ob_debug("KILLED active grab on keyboard");
2222 ungrab_passive_key();
2224 XSync(obt_display, FALSE);
2227 gboolean event_time_after(guint32 t1, guint32 t2)
2229 g_assert(t1 != CurrentTime);
2230 g_assert(t2 != CurrentTime);
2233 Timestamp values wrap around (after about 49.7 days). The server, given
2234 its current time is represented by timestamp T, always interprets
2235 timestamps from clients by treating half of the timestamp space as being
2236 later in time than T.
2237 - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
2240 /* TIME_HALF is not half of the number space of a Time type variable.
2241 * Rather, it is half the number space of a timestamp value, which is
2242 * always 32 bits. */
2243 #define TIME_HALF (guint32)(1 << 31)
2245 if (t2 >= TIME_HALF)
2246 /* t2 is in the second half so t1 might wrap around and be smaller than
2248 return t1 >= t2 || t1 < (t2 + TIME_HALF);
2250 /* t2 is in the first half so t1 has to come after it */
2251 return t1 >= t2 && t1 < (t2 + TIME_HALF);
2254 gboolean find_timestamp(XEvent *e, gpointer data)
2256 const Time t = event_get_timestamp(e);
2257 if (t && t >= event_curtime) {
2265 static Time next_time(void)
2267 /* Some events don't come with timestamps :(
2268 ...but we can get one anyways >:) */
2270 /* Generate a timestamp so there is guaranteed at least one in the queue
2272 XChangeProperty(obt_display, screen_support_win,
2273 OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING),
2274 8, PropModeAppend, NULL, 0);
2276 /* Grab the first timestamp available */
2277 xqueue_exists(find_timestamp, NULL);
2279 /*g_assert(event_curtime != CurrentTime);*/
2281 /* Save the time so we don't have to do this again for this event */
2282 return event_curtime;
2285 Time event_time(void)
2287 if (event_curtime) return event_curtime;
2292 Time event_source_time(void)
2294 return event_sourcetime;
2297 void event_reset_time(void)
2302 void event_update_user_time(void)
2304 event_last_user_time = event_time();
2307 void event_reset_user_time(void)
2309 event_last_user_time = CurrentTime;