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"
40 #include "focus_cycle.h"
41 #include "moveresize.h"
44 #include "extensions.h"
45 #include "translate.h"
48 #include <X11/Xatom.h>
51 #ifdef HAVE_SYS_SELECT_H
52 # include <sys/select.h>
58 # include <unistd.h> /* for usleep() */
61 # include <X11/XKBlib.h>
65 #include <X11/ICE/ICElib.h>
81 gulong start
; /* inclusive */
82 gulong end
; /* inclusive */
85 static void event_process(const XEvent
*e
, gpointer data
);
86 static void event_handle_root(XEvent
*e
);
87 static gboolean
event_handle_menu_keyboard(XEvent
*e
);
88 static gboolean
event_handle_menu(XEvent
*e
);
89 static void event_handle_dock(ObDock
*s
, XEvent
*e
);
90 static void event_handle_dockapp(ObDockApp
*app
, XEvent
*e
);
91 static void event_handle_client(ObClient
*c
, XEvent
*e
);
92 static void event_handle_user_time_window_clients(GSList
*l
, XEvent
*e
);
93 static void event_handle_user_input(ObClient
*client
, XEvent
*e
);
94 static gboolean
is_enter_focus_event_ignored(XEvent
*e
);
96 static void focus_delay_dest(gpointer data
);
97 static gboolean
focus_delay_cmp(gconstpointer d1
, gconstpointer d2
);
98 static gboolean
focus_delay_func(gpointer data
);
99 static void focus_delay_client_dest(ObClient
*client
, gpointer data
);
101 /* The time for the current event being processed */
102 Time event_curtime
= CurrentTime
;
104 static gboolean focus_left_screen
= FALSE
;
105 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
106 static GSList
*ignore_serials
= NULL
;
109 static void ice_handler(gint fd
, gpointer conn
)
112 IceProcessMessages(conn
, NULL
, &b
);
115 static void ice_watch(IceConn conn
, IcePointer data
, Bool opening
,
116 IcePointer
*watch_data
)
121 fd
= IceConnectionNumber(conn
);
122 ob_main_loop_fd_add(ob_main_loop
, fd
, ice_handler
, conn
, NULL
);
124 ob_main_loop_fd_remove(ob_main_loop
, fd
);
130 void event_startup(gboolean reconfig
)
132 if (reconfig
) return;
134 ob_main_loop_x_add(ob_main_loop
, event_process
, NULL
, NULL
);
137 IceAddConnectionWatch(ice_watch
, NULL
);
140 client_add_destroy_notify(focus_delay_client_dest
, NULL
);
143 void event_shutdown(gboolean reconfig
)
145 if (reconfig
) return;
148 IceRemoveConnectionWatch(ice_watch
, NULL
);
151 client_remove_destroy_notify(focus_delay_client_dest
);
154 static Window
event_get_window(XEvent
*e
)
161 window
= RootWindow(ob_display
, ob_screen
);
164 window
= e
->xmap
.window
;
167 window
= e
->xunmap
.window
;
170 window
= e
->xdestroywindow
.window
;
172 case ConfigureRequest
:
173 window
= e
->xconfigurerequest
.window
;
175 case ConfigureNotify
:
176 window
= e
->xconfigure
.window
;
180 if (extensions_xkb
&& e
->type
== extensions_xkb_event_basep
) {
181 switch (((XkbAnyEvent
*)e
)->xkb_type
) {
183 window
= ((XkbBellNotifyEvent
*)e
)->window
;
190 if (extensions_sync
&&
191 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
196 window
= e
->xany
.window
;
201 static void event_set_curtime(XEvent
*e
)
203 Time t
= CurrentTime
;
205 /* grab the lasttime and hack up the state */
221 t
= e
->xproperty
.time
;
225 t
= e
->xcrossing
.time
;
229 if (extensions_sync
&&
230 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
232 t
= ((XSyncAlarmNotifyEvent
*)e
)->time
;
235 /* if more event types are anticipated, get their timestamp
243 static void event_hack_mods(XEvent
*e
)
246 XkbStateRec xkb_state
;
252 e
->xbutton
.state
= modkeys_only_modifier_masks(e
->xbutton
.state
);
255 e
->xkey
.state
= modkeys_only_modifier_masks(e
->xkey
.state
);
258 e
->xkey
.state
= modkeys_only_modifier_masks(e
->xkey
.state
);
260 if (XkbGetState(ob_display
, XkbUseCoreKbd
, &xkb_state
) == Success
) {
261 e
->xkey
.state
= xkb_state
.compat_state
;
265 /* remove from the state the mask of the modifier key being released,
266 if it is a modifier key being released that is */
267 e
->xkey
.state
&= ~modkeys_keycode_to_mask(e
->xkey
.keycode
);
270 e
->xmotion
.state
= modkeys_only_modifier_masks(e
->xmotion
.state
);
271 /* compress events */
274 while (XCheckTypedWindowEvent(ob_display
, e
->xmotion
.window
,
276 e
->xmotion
.x
= ce
.xmotion
.x
;
277 e
->xmotion
.y
= ce
.xmotion
.y
;
278 e
->xmotion
.x_root
= ce
.xmotion
.x_root
;
279 e
->xmotion
.y_root
= ce
.xmotion
.y_root
;
286 static gboolean
wanted_focusevent(XEvent
*e
, gboolean in_client_only
)
288 gint mode
= e
->xfocus
.mode
;
289 gint detail
= e
->xfocus
.detail
;
290 Window win
= e
->xany
.window
;
292 if (e
->type
== FocusIn
) {
293 /* These are ones we never want.. */
295 /* This means focus was given by a keyboard/mouse grab. */
296 if (mode
== NotifyGrab
)
298 /* This means focus was given back from a keyboard/mouse grab. */
299 if (mode
== NotifyUngrab
)
302 /* These are the ones we want.. */
304 if (win
== RootWindow(ob_display
, ob_screen
)) {
305 /* If looking for a focus in on a client, then always return
306 FALSE for focus in's to the root window */
309 /* This means focus reverted off of a client */
310 else if (detail
== NotifyPointerRoot
||
311 detail
== NotifyDetailNone
||
312 detail
== NotifyInferior
||
313 /* This means focus got here from another screen */
314 detail
== NotifyNonlinear
)
320 /* It was on a client, was it a valid one?
321 It's possible to get a FocusIn event for a client that was managed
324 if (in_client_only
) {
325 ObWindow
*w
= g_hash_table_lookup(window_map
, &e
->xfocus
.window
);
326 if (!w
|| !WINDOW_IS_CLIENT(w
))
330 /* This means focus reverted to parent from the client (this
331 happens often during iconify animation) */
332 if (detail
== NotifyInferior
)
336 /* This means focus moved from the root window to a client */
337 if (detail
== NotifyVirtual
)
339 /* This means focus moved from one client to another */
340 if (detail
== NotifyNonlinearVirtual
)
346 g_assert(e
->type
== FocusOut
);
348 /* These are ones we never want.. */
350 /* This means focus was taken by a keyboard/mouse grab. */
351 if (mode
== NotifyGrab
)
353 /* This means focus was grabbed on a window and it was released. */
354 if (mode
== NotifyUngrab
)
357 /* Focus left the root window revertedto state */
358 if (win
== RootWindow(ob_display
, ob_screen
))
361 /* These are the ones we want.. */
363 /* This means focus moved from a client to the root window */
364 if (detail
== NotifyVirtual
)
366 /* This means focus moved from one client to another */
367 if (detail
== NotifyNonlinearVirtual
)
375 static Bool
event_look_for_focusin(Display
*d
, XEvent
*e
, XPointer arg
)
377 return e
->type
== FocusIn
&& wanted_focusevent(e
, FALSE
);
380 static Bool
event_look_for_focusin_client(Display
*d
, XEvent
*e
, XPointer arg
)
382 return e
->type
== FocusIn
&& wanted_focusevent(e
, TRUE
);
385 static void print_focusevent(XEvent
*e
)
387 gint mode
= e
->xfocus
.mode
;
388 gint detail
= e
->xfocus
.detail
;
389 Window win
= e
->xany
.window
;
390 const gchar
*modestr
, *detailstr
;
393 case NotifyNormal
: modestr
="NotifyNormal"; break;
394 case NotifyGrab
: modestr
="NotifyGrab"; break;
395 case NotifyUngrab
: modestr
="NotifyUngrab"; break;
396 case NotifyWhileGrabbed
: modestr
="NotifyWhileGrabbed"; break;
399 case NotifyAncestor
: detailstr
="NotifyAncestor"; break;
400 case NotifyVirtual
: detailstr
="NotifyVirtual"; break;
401 case NotifyInferior
: detailstr
="NotifyInferior"; break;
402 case NotifyNonlinear
: detailstr
="NotifyNonlinear"; break;
403 case NotifyNonlinearVirtual
: detailstr
="NotifyNonlinearVirtual"; break;
404 case NotifyPointer
: detailstr
="NotifyPointer"; break;
405 case NotifyPointerRoot
: detailstr
="NotifyPointerRoot"; break;
406 case NotifyDetailNone
: detailstr
="NotifyDetailNone"; break;
409 if (mode
== NotifyGrab
|| mode
== NotifyUngrab
)
414 ob_debug_type(OB_DEBUG_FOCUS
, "Focus%s 0x%x mode=%s detail=%s\n",
415 (e
->xfocus
.type
== FocusIn
? "In" : "Out"),
421 static gboolean
event_ignore(XEvent
*e
, ObClient
*client
)
426 if (!wanted_focusevent(e
, FALSE
))
431 if (!wanted_focusevent(e
, FALSE
))
438 static void event_process(const XEvent
*ec
, gpointer data
)
441 ObClient
*client
= NULL
;
443 ObDockApp
*dockapp
= NULL
;
444 ObWindow
*obwin
= NULL
;
445 GSList
*timewinclients
= NULL
;
447 ObEventData
*ed
= data
;
449 /* make a copy we can mangle */
453 window
= event_get_window(e
);
454 if (e
->type
!= PropertyNotify
||
455 !(timewinclients
= propwin_get_clients(window
,
456 OB_PROPWIN_USER_TIME
)))
457 if ((obwin
= g_hash_table_lookup(window_map
, &window
))) {
458 switch (obwin
->type
) {
460 dock
= WINDOW_AS_DOCK(obwin
);
463 dockapp
= WINDOW_AS_DOCKAPP(obwin
);
466 client
= WINDOW_AS_CLIENT(obwin
);
469 case Window_Internal
:
470 /* not to be used for events */
471 g_assert_not_reached();
476 event_set_curtime(e
);
478 if (event_ignore(e
, client
)) {
485 /* deal with it in the kernel */
487 if (menu_frame_visible
&&
488 (e
->type
== EnterNotify
|| e
->type
== LeaveNotify
))
490 /* crossing events for menu */
491 event_handle_menu(e
);
492 } else if (e
->type
== FocusIn
) {
494 e
->xfocus
.detail
== NotifyInferior
)
496 ob_debug_type(OB_DEBUG_FOCUS
,
497 "Focus went to the frame window");
499 focus_left_screen
= FALSE
;
501 focus_fallback(FALSE
, config_focus_under_mouse
, TRUE
);
503 /* We don't get a FocusOut for this case, because it's just moving
504 from our Inferior up to us. This happens when iconifying a
505 window with RevertToParent focus */
506 frame_adjust_focus(client
->frame
, FALSE
);
507 /* focus_set_client(NULL) has already been called */
508 client_calc_layer(client
);
510 if (e
->xfocus
.detail
== NotifyPointerRoot
||
511 e
->xfocus
.detail
== NotifyDetailNone
||
512 e
->xfocus
.detail
== NotifyInferior
||
513 e
->xfocus
.detail
== NotifyNonlinear
)
517 ob_debug_type(OB_DEBUG_FOCUS
,
518 "Focus went to root or pointer root/none\n");
520 if (e
->xfocus
.detail
== NotifyInferior
||
521 e
->xfocus
.detail
== NotifyNonlinear
)
523 focus_left_screen
= FALSE
;
526 /* If another FocusIn is in the queue then don't fallback yet. This
527 fixes the fun case of:
528 window map -> send focusin
529 window unmap -> get focusout
530 window map -> send focusin
531 get first focus out -> fall back to something (new window
532 hasn't received focus yet, so something else) -> send focusin
533 which means the "something else" is the last thing to get a
534 focusin sent to it, so the new window doesn't end up with focus.
536 But if the other focus in is something like PointerRoot then we
537 still want to fall back.
539 if (XCheckIfEvent(ob_display
, &ce
, event_look_for_focusin_client
,
542 XPutBackEvent(ob_display
, &ce
);
543 ob_debug_type(OB_DEBUG_FOCUS
,
544 " but another FocusIn is coming\n");
546 /* Focus has been reverted.
548 FocusOut events come after UnmapNotify, so we don't need to
549 worry about focusing an invalid window
552 if (!focus_left_screen
)
553 focus_fallback(FALSE
, config_focus_under_mouse
, TRUE
);
558 ob_debug_type(OB_DEBUG_FOCUS
,
559 "Focus went to a window that is already gone\n");
561 /* If you send focus to a window and then it disappears, you can
562 get the FocusIn for it, after it is unmanaged.
563 Just wait for the next FocusOut/FocusIn pair, but make note that
564 the window that was focused no longer is. */
565 focus_set_client(NULL
);
567 else if (client
!= focus_client
) {
568 focus_left_screen
= FALSE
;
569 frame_adjust_focus(client
->frame
, TRUE
);
570 focus_set_client(client
);
571 client_calc_layer(client
);
572 client_bring_helper_windows(client
);
574 } else if (e
->type
== FocusOut
) {
577 /* Look for the followup FocusIn */
578 if (!XCheckIfEvent(ob_display
, &ce
, event_look_for_focusin
, NULL
)) {
579 /* There is no FocusIn, this means focus went to a window that
580 is not being managed, or a window on another screen. */
584 xerror_set_ignore(TRUE
);
585 if (XGetInputFocus(ob_display
, &win
, &i
) != 0 &&
586 XGetGeometry(ob_display
, win
, &root
, &i
,&i
,&u
,&u
,&u
,&u
) != 0 &&
587 root
!= RootWindow(ob_display
, ob_screen
))
589 ob_debug_type(OB_DEBUG_FOCUS
,
590 "Focus went to another screen !\n");
591 focus_left_screen
= TRUE
;
594 ob_debug_type(OB_DEBUG_FOCUS
,
595 "Focus went to a black hole !\n");
596 xerror_set_ignore(FALSE
);
597 /* nothing is focused */
598 focus_set_client(NULL
);
600 /* Focus moved, so process the FocusIn event */
601 ObEventData ed
= { .ignored
= FALSE
};
602 event_process(&ce
, &ed
);
604 /* The FocusIn was ignored, this means it was on a window
605 that isn't a client. */
606 ob_debug_type(OB_DEBUG_FOCUS
,
607 "Focus went to an unmanaged window 0x%x !\n",
609 focus_fallback(TRUE
, config_focus_under_mouse
, TRUE
);
613 if (client
&& client
!= focus_client
) {
614 frame_adjust_focus(client
->frame
, FALSE
);
615 /* focus_set_client(NULL) has already been called in this
616 section or by focus_fallback */
617 client_calc_layer(client
);
619 } else if (timewinclients
)
620 event_handle_user_time_window_clients(timewinclients
, e
);
622 event_handle_client(client
, e
);
624 event_handle_dockapp(dockapp
, e
);
626 event_handle_dock(dock
, e
);
627 else if (window
== RootWindow(ob_display
, ob_screen
))
628 event_handle_root(e
);
629 else if (e
->type
== MapRequest
)
630 client_manage(window
);
631 else if (e
->type
== ClientMessage
) {
632 /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
633 windows that are not managed yet. */
634 if (e
->xclient
.message_type
== prop_atoms
.net_request_frame_extents
) {
635 /* Pretend to manage the client, getting information used to
636 determine its decorations */
637 ObClient
*c
= client_fake_manage(e
->xclient
.window
);
640 /* set the frame extents on the window */
641 vals
[0] = c
->frame
->size
.left
;
642 vals
[1] = c
->frame
->size
.right
;
643 vals
[2] = c
->frame
->size
.top
;
644 vals
[3] = c
->frame
->size
.bottom
;
645 PROP_SETA32(e
->xclient
.window
, net_frame_extents
,
648 /* Free the pretend client */
649 client_fake_unmanage(c
);
652 else if (e
->type
== ConfigureRequest
) {
653 /* unhandled configure requests must be used to configure the
657 xwc
.x
= e
->xconfigurerequest
.x
;
658 xwc
.y
= e
->xconfigurerequest
.y
;
659 xwc
.width
= e
->xconfigurerequest
.width
;
660 xwc
.height
= e
->xconfigurerequest
.height
;
661 xwc
.border_width
= e
->xconfigurerequest
.border_width
;
662 xwc
.sibling
= e
->xconfigurerequest
.above
;
663 xwc
.stack_mode
= e
->xconfigurerequest
.detail
;
665 /* we are not to be held responsible if someone sends us an
667 xerror_set_ignore(TRUE
);
668 XConfigureWindow(ob_display
, window
,
669 e
->xconfigurerequest
.value_mask
, &xwc
);
670 xerror_set_ignore(FALSE
);
673 else if (extensions_sync
&&
674 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
676 XSyncAlarmNotifyEvent
*se
= (XSyncAlarmNotifyEvent
*)e
;
677 if (se
->alarm
== moveresize_alarm
&& moveresize_in_progress
)
682 if (e
->type
== ButtonPress
|| e
->type
== ButtonRelease
||
683 e
->type
== MotionNotify
|| e
->type
== KeyPress
||
684 e
->type
== KeyRelease
)
686 event_handle_user_input(client
, e
);
689 /* if something happens and it's not from an XEvent, then we don't know
691 event_curtime
= CurrentTime
;
694 static void event_handle_root(XEvent
*e
)
700 ob_debug("Another WM has requested to replace us. Exiting.\n");
705 if (e
->xclient
.format
!= 32) break;
707 msgtype
= e
->xclient
.message_type
;
708 if (msgtype
== prop_atoms
.net_current_desktop
) {
709 guint d
= e
->xclient
.data
.l
[0];
710 if (d
< screen_num_desktops
) {
711 event_curtime
= e
->xclient
.data
.l
[1];
712 if (event_curtime
== 0)
713 ob_debug_type(OB_DEBUG_APP_BUGS
,
714 "_NET_CURRENT_DESKTOP message is missing "
716 screen_set_desktop(d
, TRUE
);
718 } else if (msgtype
== prop_atoms
.net_number_of_desktops
) {
719 guint d
= e
->xclient
.data
.l
[0];
720 if (d
> 0 && d
<= 1000)
721 screen_set_num_desktops(d
);
722 } else if (msgtype
== prop_atoms
.net_showing_desktop
) {
723 screen_show_desktop(e
->xclient
.data
.l
[0] != 0, NULL
);
724 } else if (msgtype
== prop_atoms
.ob_control
) {
725 ob_debug("OB_CONTROL: %d\n", e
->xclient
.data
.l
[0]);
726 if (e
->xclient
.data
.l
[0] == 1)
728 else if (e
->xclient
.data
.l
[0] == 2)
733 if (e
->xproperty
.atom
== prop_atoms
.net_desktop_names
) {
734 ob_debug("UPDATE DESKTOP NAMES\n");
735 screen_update_desktop_names();
737 else if (e
->xproperty
.atom
== prop_atoms
.net_desktop_layout
)
738 screen_update_layout();
740 case ConfigureNotify
:
742 XRRUpdateConfiguration(e
);
751 void event_enter_client(ObClient
*client
)
753 g_assert(config_focus_follow
);
755 if (client_enter_focusable(client
) && client_can_focus(client
)) {
756 if (config_focus_delay
) {
757 ObFocusDelayData
*data
;
759 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
761 data
= g_new(ObFocusDelayData
, 1);
762 data
->client
= client
;
763 data
->time
= event_curtime
;
765 ob_main_loop_timeout_add(ob_main_loop
,
768 data
, focus_delay_cmp
, focus_delay_dest
);
770 ObFocusDelayData data
;
771 data
.client
= client
;
772 data
.time
= event_curtime
;
773 focus_delay_func(&data
);
778 static void event_handle_user_time_window_clients(GSList
*l
, XEvent
*e
)
780 g_assert(e
->type
== PropertyNotify
);
781 if (e
->xproperty
.atom
== prop_atoms
.net_wm_user_time
) {
782 for (; l
; l
= g_slist_next(l
))
783 client_update_user_time(l
->data
);
787 static void event_handle_client(ObClient
*client
, XEvent
*e
)
792 static gint px
= -1, py
= -1;
797 /* save where the press occured for the first button pressed */
799 pb
= e
->xbutton
.button
;
804 /* Wheel buttons don't draw because they are an instant click, so it
805 is a waste of resources to go drawing it.
806 if the user is doing an intereactive thing, or has a menu open then
807 the mouse is grabbed (possibly) and if we get these events we don't
808 want to deal with them
810 if (!(e
->xbutton
.button
== 4 || e
->xbutton
.button
== 5) &&
811 !keyboard_interactively_grabbed() &&
814 /* use where the press occured */
815 con
= frame_context(client
, e
->xbutton
.window
, px
, py
);
816 con
= mouse_button_frame_context(con
, e
->xbutton
.button
,
819 if (e
->type
== ButtonRelease
&& e
->xbutton
.button
== pb
)
820 pb
= 0, px
= py
= -1;
823 case OB_FRAME_CONTEXT_MAXIMIZE
:
824 client
->frame
->max_press
= (e
->type
== ButtonPress
);
825 frame_adjust_state(client
->frame
);
827 case OB_FRAME_CONTEXT_CLOSE
:
828 client
->frame
->close_press
= (e
->type
== ButtonPress
);
829 frame_adjust_state(client
->frame
);
831 case OB_FRAME_CONTEXT_ICONIFY
:
832 client
->frame
->iconify_press
= (e
->type
== ButtonPress
);
833 frame_adjust_state(client
->frame
);
835 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
836 client
->frame
->desk_press
= (e
->type
== ButtonPress
);
837 frame_adjust_state(client
->frame
);
839 case OB_FRAME_CONTEXT_SHADE
:
840 client
->frame
->shade_press
= (e
->type
== ButtonPress
);
841 frame_adjust_state(client
->frame
);
844 /* nothing changes with clicks for any other contexts */
850 /* when there is a grab on the pointer, we won't get enter/leave
851 notifies, but we still get motion events */
852 if (grab_on_pointer()) break;
854 con
= frame_context(client
, e
->xmotion
.window
,
855 e
->xmotion
.x
, e
->xmotion
.y
);
857 case OB_FRAME_CONTEXT_TITLEBAR
:
858 case OB_FRAME_CONTEXT_TLCORNER
:
859 case OB_FRAME_CONTEXT_TRCORNER
:
860 /* we've left the button area inside the titlebar */
861 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
862 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
863 client
->frame
->close_hover
)
865 client
->frame
->max_hover
= FALSE
;
866 client
->frame
->desk_hover
= FALSE
;
867 client
->frame
->shade_hover
= FALSE
;
868 client
->frame
->iconify_hover
= FALSE
;
869 client
->frame
->close_hover
= FALSE
;
870 frame_adjust_state(client
->frame
);
873 case OB_FRAME_CONTEXT_MAXIMIZE
:
874 if (!client
->frame
->max_hover
) {
875 client
->frame
->max_hover
= TRUE
;
876 frame_adjust_state(client
->frame
);
879 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
880 if (!client
->frame
->desk_hover
) {
881 client
->frame
->desk_hover
= TRUE
;
882 frame_adjust_state(client
->frame
);
885 case OB_FRAME_CONTEXT_SHADE
:
886 if (!client
->frame
->shade_hover
) {
887 client
->frame
->shade_hover
= TRUE
;
888 frame_adjust_state(client
->frame
);
891 case OB_FRAME_CONTEXT_ICONIFY
:
892 if (!client
->frame
->iconify_hover
) {
893 client
->frame
->iconify_hover
= TRUE
;
894 frame_adjust_state(client
->frame
);
897 case OB_FRAME_CONTEXT_CLOSE
:
898 if (!client
->frame
->close_hover
) {
899 client
->frame
->close_hover
= TRUE
;
900 frame_adjust_state(client
->frame
);
908 con
= frame_context(client
, e
->xcrossing
.window
,
909 e
->xcrossing
.x
, e
->xcrossing
.y
);
911 case OB_FRAME_CONTEXT_TITLEBAR
:
912 case OB_FRAME_CONTEXT_TLCORNER
:
913 case OB_FRAME_CONTEXT_TRCORNER
:
914 /* we've left the button area inside the titlebar */
915 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
916 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
917 client
->frame
->close_hover
)
919 client
->frame
->max_hover
= FALSE
;
920 client
->frame
->desk_hover
= FALSE
;
921 client
->frame
->shade_hover
= FALSE
;
922 client
->frame
->iconify_hover
= FALSE
;
923 client
->frame
->close_hover
= FALSE
;
924 frame_adjust_state(client
->frame
);
927 case OB_FRAME_CONTEXT_MAXIMIZE
:
928 client
->frame
->max_hover
= FALSE
;
929 frame_adjust_state(client
->frame
);
931 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
932 client
->frame
->desk_hover
= FALSE
;
933 frame_adjust_state(client
->frame
);
935 case OB_FRAME_CONTEXT_SHADE
:
936 client
->frame
->shade_hover
= FALSE
;
937 frame_adjust_state(client
->frame
);
939 case OB_FRAME_CONTEXT_ICONIFY
:
940 client
->frame
->iconify_hover
= FALSE
;
941 frame_adjust_state(client
->frame
);
943 case OB_FRAME_CONTEXT_CLOSE
:
944 client
->frame
->close_hover
= FALSE
;
945 frame_adjust_state(client
->frame
);
947 case OB_FRAME_CONTEXT_FRAME
:
948 /* When the mouse leaves an animating window, don't use the
949 corresponding enter events. Pretend like the animating window
950 doesn't even exist..! */
951 if (frame_iconify_animating(client
->frame
))
952 event_end_ignore_all_enters(event_start_ignore_all_enters());
954 ob_debug_type(OB_DEBUG_FOCUS
,
955 "%sNotify mode %d detail %d on %lx\n",
956 (e
->type
== EnterNotify
? "Enter" : "Leave"),
958 e
->xcrossing
.detail
, (client
?client
->window
:0));
959 if (keyboard_interactively_grabbed())
961 if (config_focus_follow
&& config_focus_delay
&&
962 /* leave inferior events can happen when the mouse goes onto
963 the window's border and then into the window before the
965 e
->xcrossing
.detail
!= NotifyInferior
)
967 ob_main_loop_timeout_remove_data(ob_main_loop
,
978 con
= frame_context(client
, e
->xcrossing
.window
,
979 e
->xcrossing
.x
, e
->xcrossing
.y
);
981 case OB_FRAME_CONTEXT_MAXIMIZE
:
982 client
->frame
->max_hover
= TRUE
;
983 frame_adjust_state(client
->frame
);
985 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
986 client
->frame
->desk_hover
= TRUE
;
987 frame_adjust_state(client
->frame
);
989 case OB_FRAME_CONTEXT_SHADE
:
990 client
->frame
->shade_hover
= TRUE
;
991 frame_adjust_state(client
->frame
);
993 case OB_FRAME_CONTEXT_ICONIFY
:
994 client
->frame
->iconify_hover
= TRUE
;
995 frame_adjust_state(client
->frame
);
997 case OB_FRAME_CONTEXT_CLOSE
:
998 client
->frame
->close_hover
= TRUE
;
999 frame_adjust_state(client
->frame
);
1001 case OB_FRAME_CONTEXT_FRAME
:
1002 if (keyboard_interactively_grabbed())
1004 if (e
->xcrossing
.mode
== NotifyGrab
||
1005 e
->xcrossing
.mode
== NotifyUngrab
||
1006 /*ignore enters when we're already in the window */
1007 e
->xcrossing
.detail
== NotifyInferior
||
1008 is_enter_focus_event_ignored(e
))
1010 ob_debug_type(OB_DEBUG_FOCUS
,
1011 "%sNotify mode %d detail %d on %lx IGNORED\n",
1012 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1014 e
->xcrossing
.detail
, client
?client
->window
:0);
1017 ob_debug_type(OB_DEBUG_FOCUS
,
1018 "%sNotify mode %d detail %d on %lx, "
1019 "focusing window\n",
1020 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1022 e
->xcrossing
.detail
, (client
?client
->window
:0));
1023 if (config_focus_follow
)
1024 event_enter_client(client
);
1032 case ConfigureRequest
:
1034 /* dont compress these unless you're going to watch for property
1035 notifies in between (these can change what the configure would
1037 also you can't compress stacking events
1041 gboolean move
= FALSE
;
1042 gboolean resize
= FALSE
;
1044 /* get the current area */
1045 RECT_TO_DIMS(client
->area
, x
, y
, w
, h
);
1047 ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1049 " x %d y %d w %d h %d b %d\n",
1051 screen_desktop
, client
->wmstate
, client
->frame
->visible
,
1052 x
, y
, w
, h
, client
->border_width
);
1054 if (e
->xconfigurerequest
.value_mask
& CWBorderWidth
)
1055 if (client
->border_width
!= e
->xconfigurerequest
.border_width
) {
1056 client
->border_width
= e
->xconfigurerequest
.border_width
;
1058 /* if the border width is changing then that is the same
1059 as requesting a resize, but we don't actually change
1060 the client's border, so it will change their root
1061 coordiantes (since they include the border width) and
1062 we need to a notify then */
1067 if (e
->xconfigurerequest
.value_mask
& CWStackMode
) {
1068 ObClient
*sibling
= NULL
;
1069 gulong ignore_start
;
1071 /* get the sibling */
1072 if (e
->xconfigurerequest
.value_mask
& CWSibling
) {
1074 win
= g_hash_table_lookup(window_map
,
1075 &e
->xconfigurerequest
.above
);
1076 if (WINDOW_IS_CLIENT(win
) && WINDOW_AS_CLIENT(win
) != client
)
1077 sibling
= WINDOW_AS_CLIENT(win
);
1080 if (!config_focus_under_mouse
)
1081 ignore_start
= event_start_ignore_all_enters();
1082 stacking_restack_request(client
, sibling
,
1083 e
->xconfigurerequest
.detail
);
1084 if (!config_focus_under_mouse
)
1085 event_end_ignore_all_enters(ignore_start
);
1087 /* if a stacking change moves the window without resizing */
1091 if ((e
->xconfigurerequest
.value_mask
& CWX
) ||
1092 (e
->xconfigurerequest
.value_mask
& CWY
) ||
1093 (e
->xconfigurerequest
.value_mask
& CWWidth
) ||
1094 (e
->xconfigurerequest
.value_mask
& CWHeight
))
1096 if (e
->xconfigurerequest
.value_mask
& CWX
) {
1097 /* don't allow clients to move shaded windows (fvwm does this)
1099 if (!client
->shaded
)
1100 x
= e
->xconfigurerequest
.x
;
1103 if (e
->xconfigurerequest
.value_mask
& CWY
) {
1104 /* don't allow clients to move shaded windows (fvwm does this)
1106 if (!client
->shaded
)
1107 y
= e
->xconfigurerequest
.y
;
1111 if (e
->xconfigurerequest
.value_mask
& CWWidth
) {
1112 w
= e
->xconfigurerequest
.width
;
1115 if (e
->xconfigurerequest
.value_mask
& CWHeight
) {
1116 h
= e
->xconfigurerequest
.height
;
1121 ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1122 "move %d resize %d\n",
1123 e
->xconfigurerequest
.value_mask
& CWX
, x
,
1124 e
->xconfigurerequest
.value_mask
& CWY
, y
,
1125 e
->xconfigurerequest
.value_mask
& CWWidth
, w
,
1126 e
->xconfigurerequest
.value_mask
& CWHeight
, h
,
1129 /* check for broken apps moving to their root position
1131 XXX remove this some day...that would be nice. right now all
1132 kde apps do this when they try activate themselves on another
1133 desktop. eg. open amarok window on desktop 1, switch to desktop
1134 2, click amarok tray icon. it will move by its decoration size.
1136 if (x
!= client
->area
.x
&&
1137 x
== (client
->frame
->area
.x
+ client
->frame
->size
.left
-
1138 (gint
)client
->border_width
) &&
1139 y
!= client
->area
.y
&&
1140 y
== (client
->frame
->area
.y
+ client
->frame
->size
.top
-
1141 (gint
)client
->border_width
) &&
1142 w
== client
->area
.width
&&
1143 h
== client
->area
.height
)
1145 ob_debug_type(OB_DEBUG_APP_BUGS
,
1146 "Application %s is trying to move via "
1147 "ConfigureRequest to it's root window position "
1148 "but it is not using StaticGravity\n",
1154 /* they still requested a move, so don't change whether a
1155 notify is sent or not */
1161 client_try_configure(client
, &x
, &y
, &w
, &h
, &lw
, &lh
, FALSE
);
1163 /* if x was not given, then use gravity to figure out the new
1164 x. the reference point should not be moved */
1165 if ((e
->xconfigurerequest
.value_mask
& CWWidth
&&
1166 !(e
->xconfigurerequest
.value_mask
& CWX
)))
1167 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1168 /* if y was not given, then use gravity to figure out the new
1169 y. the reference point should not be moved */
1170 if ((e
->xconfigurerequest
.value_mask
& CWHeight
&&
1171 !(e
->xconfigurerequest
.value_mask
& CWY
)))
1172 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1174 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1176 ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
1178 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
, TRUE
);
1183 if (client
->ignore_unmaps
) {
1184 client
->ignore_unmaps
--;
1187 ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1188 "ignores left %d\n",
1189 client
->window
, e
->xunmap
.event
, e
->xunmap
.from_configure
,
1190 client
->ignore_unmaps
);
1191 client_unmanage(client
);
1194 ob_debug("DestroyNotify for window 0x%x\n", client
->window
);
1195 client_unmanage(client
);
1197 case ReparentNotify
:
1198 /* this is when the client is first taken captive in the frame */
1199 if (e
->xreparent
.parent
== client
->frame
->window
) break;
1202 This event is quite rare and is usually handled in unmapHandler.
1203 However, if the window is unmapped when the reparent event occurs,
1204 the window manager never sees it because an unmap event is not sent
1205 to an already unmapped window.
1208 /* we don't want the reparent event, put it back on the stack for the
1209 X server to deal with after we unmanage the window */
1210 XPutBackEvent(ob_display
, e
);
1212 ob_debug("ReparentNotify for window 0x%x\n", client
->window
);
1213 client_unmanage(client
);
1216 ob_debug("MapRequest for 0x%lx\n", client
->window
);
1217 if (!client
->iconic
) break; /* this normally doesn't happen, but if it
1218 does, we don't want it!
1219 it can happen now when the window is on
1220 another desktop, but we still don't
1222 client_activate(client
, FALSE
, TRUE
);
1225 /* validate cuz we query stuff off the client here */
1226 if (!client_validate(client
)) break;
1228 if (e
->xclient
.format
!= 32) return;
1230 msgtype
= e
->xclient
.message_type
;
1231 if (msgtype
== prop_atoms
.wm_change_state
) {
1232 /* compress changes into a single change */
1233 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1235 /* XXX: it would be nice to compress ALL messages of a
1236 type, not just messages in a row without other
1237 message types between. */
1238 if (ce
.xclient
.message_type
!= msgtype
) {
1239 XPutBackEvent(ob_display
, &ce
);
1242 e
->xclient
= ce
.xclient
;
1244 client_set_wm_state(client
, e
->xclient
.data
.l
[0]);
1245 } else if (msgtype
== prop_atoms
.net_wm_desktop
) {
1246 /* compress changes into a single change */
1247 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1249 /* XXX: it would be nice to compress ALL messages of a
1250 type, not just messages in a row without other
1251 message types between. */
1252 if (ce
.xclient
.message_type
!= msgtype
) {
1253 XPutBackEvent(ob_display
, &ce
);
1256 e
->xclient
= ce
.xclient
;
1258 if ((unsigned)e
->xclient
.data
.l
[0] < screen_num_desktops
||
1259 (unsigned)e
->xclient
.data
.l
[0] == DESKTOP_ALL
)
1260 client_set_desktop(client
, (unsigned)e
->xclient
.data
.l
[0],
1262 } else if (msgtype
== prop_atoms
.net_wm_state
) {
1263 gulong ignore_start
;
1265 /* can't compress these */
1266 ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
1267 (e
->xclient
.data
.l
[0] == 0 ? "Remove" :
1268 e
->xclient
.data
.l
[0] == 1 ? "Add" :
1269 e
->xclient
.data
.l
[0] == 2 ? "Toggle" : "INVALID"),
1270 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2],
1273 /* ignore enter events caused by these like ob actions do */
1274 if (!config_focus_under_mouse
)
1275 ignore_start
= event_start_ignore_all_enters();
1276 client_set_state(client
, e
->xclient
.data
.l
[0],
1277 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2]);
1278 if (!config_focus_under_mouse
)
1279 event_end_ignore_all_enters(ignore_start
);
1280 } else if (msgtype
== prop_atoms
.net_close_window
) {
1281 ob_debug("net_close_window for 0x%lx\n", client
->window
);
1282 client_close(client
);
1283 } else if (msgtype
== prop_atoms
.net_active_window
) {
1284 ob_debug("net_active_window for 0x%lx source=%s\n",
1286 (e
->xclient
.data
.l
[0] == 0 ? "unknown" :
1287 (e
->xclient
.data
.l
[0] == 1 ? "application" :
1288 (e
->xclient
.data
.l
[0] == 2 ? "user" : "INVALID"))));
1289 /* XXX make use of data.l[2] !? */
1290 if (e
->xclient
.data
.l
[0] == 1 || e
->xclient
.data
.l
[0] == 2) {
1291 event_curtime
= e
->xclient
.data
.l
[1];
1292 if (event_curtime
== 0)
1293 ob_debug_type(OB_DEBUG_APP_BUGS
,
1294 "_NET_ACTIVE_WINDOW message for window %s is"
1295 " missing a timestamp\n", client
->title
);
1297 ob_debug_type(OB_DEBUG_APP_BUGS
,
1298 "_NET_ACTIVE_WINDOW message for window %s is "
1299 "missing source indication\n");
1300 client_activate(client
, FALSE
,
1301 (e
->xclient
.data
.l
[0] == 0 ||
1302 e
->xclient
.data
.l
[0] == 2));
1303 } else if (msgtype
== prop_atoms
.net_wm_moveresize
) {
1304 ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
1305 client
->window
, e
->xclient
.data
.l
[2]);
1306 if ((Atom
)e
->xclient
.data
.l
[2] ==
1307 prop_atoms
.net_wm_moveresize_size_topleft
||
1308 (Atom
)e
->xclient
.data
.l
[2] ==
1309 prop_atoms
.net_wm_moveresize_size_top
||
1310 (Atom
)e
->xclient
.data
.l
[2] ==
1311 prop_atoms
.net_wm_moveresize_size_topright
||
1312 (Atom
)e
->xclient
.data
.l
[2] ==
1313 prop_atoms
.net_wm_moveresize_size_right
||
1314 (Atom
)e
->xclient
.data
.l
[2] ==
1315 prop_atoms
.net_wm_moveresize_size_right
||
1316 (Atom
)e
->xclient
.data
.l
[2] ==
1317 prop_atoms
.net_wm_moveresize_size_bottomright
||
1318 (Atom
)e
->xclient
.data
.l
[2] ==
1319 prop_atoms
.net_wm_moveresize_size_bottom
||
1320 (Atom
)e
->xclient
.data
.l
[2] ==
1321 prop_atoms
.net_wm_moveresize_size_bottomleft
||
1322 (Atom
)e
->xclient
.data
.l
[2] ==
1323 prop_atoms
.net_wm_moveresize_size_left
||
1324 (Atom
)e
->xclient
.data
.l
[2] ==
1325 prop_atoms
.net_wm_moveresize_move
||
1326 (Atom
)e
->xclient
.data
.l
[2] ==
1327 prop_atoms
.net_wm_moveresize_size_keyboard
||
1328 (Atom
)e
->xclient
.data
.l
[2] ==
1329 prop_atoms
.net_wm_moveresize_move_keyboard
) {
1331 moveresize_start(client
, e
->xclient
.data
.l
[0],
1332 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[3],
1333 e
->xclient
.data
.l
[2]);
1335 else if ((Atom
)e
->xclient
.data
.l
[2] ==
1336 prop_atoms
.net_wm_moveresize_cancel
)
1337 moveresize_end(TRUE
);
1338 } else if (msgtype
== prop_atoms
.net_moveresize_window
) {
1339 gint ograv
, x
, y
, w
, h
;
1341 ograv
= client
->gravity
;
1343 if (e
->xclient
.data
.l
[0] & 0xff)
1344 client
->gravity
= e
->xclient
.data
.l
[0] & 0xff;
1346 if (e
->xclient
.data
.l
[0] & 1 << 8)
1347 x
= e
->xclient
.data
.l
[1];
1350 if (e
->xclient
.data
.l
[0] & 1 << 9)
1351 y
= e
->xclient
.data
.l
[2];
1355 if (e
->xclient
.data
.l
[0] & 1 << 10) {
1356 w
= e
->xclient
.data
.l
[3];
1358 /* if x was not given, then use gravity to figure out the new
1359 x. the reference point should not be moved */
1360 if (!(e
->xclient
.data
.l
[0] & 1 << 8))
1361 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1364 w
= client
->area
.width
;
1366 if (e
->xclient
.data
.l
[0] & 1 << 11) {
1367 h
= e
->xclient
.data
.l
[4];
1369 /* if y was not given, then use gravity to figure out the new
1370 y. the reference point should not be moved */
1371 if (!(e
->xclient
.data
.l
[0] & 1 << 9))
1372 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1375 h
= client
->area
.height
;
1377 ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
1378 e
->xclient
.data
.l
[0] & 1 << 8, x
,
1379 e
->xclient
.data
.l
[0] & 1 << 9, y
,
1382 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1384 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
, FALSE
);
1386 client
->gravity
= ograv
;
1387 } else if (msgtype
== prop_atoms
.net_restack_window
) {
1388 if (e
->xclient
.data
.l
[0] != 2) {
1389 ob_debug_type(OB_DEBUG_APP_BUGS
,
1390 "_NET_RESTACK_WINDOW sent for window %s with "
1391 "invalid source indication %ld\n",
1392 client
->title
, e
->xclient
.data
.l
[0]);
1394 ObClient
*sibling
= NULL
;
1395 if (e
->xclient
.data
.l
[1]) {
1396 ObWindow
*win
= g_hash_table_lookup
1397 (window_map
, &e
->xclient
.data
.l
[1]);
1398 if (WINDOW_IS_CLIENT(win
) &&
1399 WINDOW_AS_CLIENT(win
) != client
)
1401 sibling
= WINDOW_AS_CLIENT(win
);
1403 if (sibling
== NULL
)
1404 ob_debug_type(OB_DEBUG_APP_BUGS
,
1405 "_NET_RESTACK_WINDOW sent for window %s "
1406 "with invalid sibling 0x%x\n",
1407 client
->title
, e
->xclient
.data
.l
[1]);
1409 if (e
->xclient
.data
.l
[2] == Below
||
1410 e
->xclient
.data
.l
[2] == BottomIf
||
1411 e
->xclient
.data
.l
[2] == Above
||
1412 e
->xclient
.data
.l
[2] == TopIf
||
1413 e
->xclient
.data
.l
[2] == Opposite
)
1415 gulong ignore_start
;
1417 if (!config_focus_under_mouse
)
1418 ignore_start
= event_start_ignore_all_enters();
1419 /* just raise, don't activate */
1420 stacking_restack_request(client
, sibling
,
1421 e
->xclient
.data
.l
[2]);
1422 if (!config_focus_under_mouse
)
1423 event_end_ignore_all_enters(ignore_start
);
1425 /* send a synthetic ConfigureNotify, cuz this is supposed
1426 to be like a ConfigureRequest. */
1427 client_reconfigure(client
, TRUE
);
1429 ob_debug_type(OB_DEBUG_APP_BUGS
,
1430 "_NET_RESTACK_WINDOW sent for window %s "
1431 "with invalid detail %d\n",
1432 client
->title
, e
->xclient
.data
.l
[2]);
1436 case PropertyNotify
:
1437 /* validate cuz we query stuff off the client here */
1438 if (!client_validate(client
)) break;
1440 /* compress changes to a single property into a single change */
1441 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1445 /* XXX: it would be nice to compress ALL changes to a property,
1446 not just changes in a row without other props between. */
1448 a
= ce
.xproperty
.atom
;
1449 b
= e
->xproperty
.atom
;
1453 if ((a
== prop_atoms
.net_wm_name
||
1454 a
== prop_atoms
.wm_name
||
1455 a
== prop_atoms
.net_wm_icon_name
||
1456 a
== prop_atoms
.wm_icon_name
)
1458 (b
== prop_atoms
.net_wm_name
||
1459 b
== prop_atoms
.wm_name
||
1460 b
== prop_atoms
.net_wm_icon_name
||
1461 b
== prop_atoms
.wm_icon_name
)) {
1464 if (a
== prop_atoms
.net_wm_icon
&&
1465 b
== prop_atoms
.net_wm_icon
)
1468 XPutBackEvent(ob_display
, &ce
);
1472 msgtype
= e
->xproperty
.atom
;
1473 if (msgtype
== XA_WM_NORMAL_HINTS
) {
1474 ob_debug("Update NORMAL hints\n");
1475 client_update_normal_hints(client
);
1476 /* normal hints can make a window non-resizable */
1477 client_setup_decor_and_functions(client
, FALSE
);
1479 /* make sure the client's sizes are within its bounds, but only
1480 reconfigure the window if it needs to. emacs will update its
1481 normal hints every time it receives a conigurenotify */
1482 client_reconfigure(client
, FALSE
);
1483 } else if (msgtype
== XA_WM_HINTS
) {
1484 client_update_wmhints(client
);
1485 } else if (msgtype
== XA_WM_TRANSIENT_FOR
) {
1486 client_update_transient_for(client
);
1487 client_get_type_and_transientness(client
);
1488 /* type may have changed, so update the layer */
1489 client_calc_layer(client
);
1490 client_setup_decor_and_functions(client
, TRUE
);
1491 } else if (msgtype
== prop_atoms
.net_wm_name
||
1492 msgtype
== prop_atoms
.wm_name
||
1493 msgtype
== prop_atoms
.net_wm_icon_name
||
1494 msgtype
== prop_atoms
.wm_icon_name
) {
1495 client_update_title(client
);
1496 } else if (msgtype
== prop_atoms
.wm_protocols
) {
1497 client_update_protocols(client
);
1498 client_setup_decor_and_functions(client
, TRUE
);
1500 else if (msgtype
== prop_atoms
.net_wm_strut
) {
1501 client_update_strut(client
);
1503 else if (msgtype
== prop_atoms
.net_wm_strut_partial
) {
1504 client_update_strut(client
);
1506 else if (msgtype
== prop_atoms
.net_wm_icon
) {
1507 client_update_icons(client
);
1509 else if (msgtype
== prop_atoms
.net_wm_icon_geometry
) {
1510 client_update_icon_geometry(client
);
1512 else if (msgtype
== prop_atoms
.net_wm_user_time
) {
1513 client_update_user_time(client
);
1515 else if (msgtype
== prop_atoms
.net_wm_user_time_window
) {
1516 client_update_user_time_window(client
);
1519 else if (msgtype
== prop_atoms
.net_wm_sync_request_counter
) {
1520 client_update_sync_request_counter(client
);
1524 case ColormapNotify
:
1525 client_update_colormap(client
, e
->xcolormap
.colormap
);
1530 if (extensions_shape
&& e
->type
== extensions_shape_event_basep
) {
1531 client
->shaped
= ((XShapeEvent
*)e
)->shaped
;
1532 frame_adjust_area(client
->frame
, FALSE
, TRUE
, FALSE
);
1538 static void event_handle_dock(ObDock
*s
, XEvent
*e
)
1542 if (e
->xbutton
.button
== 1)
1543 stacking_raise(DOCK_AS_WINDOW(s
));
1544 else if (e
->xbutton
.button
== 2)
1545 stacking_lower(DOCK_AS_WINDOW(s
));
1551 /* don't hide when moving into a dock app */
1552 if (e
->xcrossing
.detail
!= NotifyInferior
)
1558 static void event_handle_dockapp(ObDockApp
*app
, XEvent
*e
)
1562 dock_app_drag(app
, &e
->xmotion
);
1565 if (app
->ignore_unmaps
) {
1566 app
->ignore_unmaps
--;
1569 dock_remove(app
, TRUE
);
1572 dock_remove(app
, FALSE
);
1574 case ReparentNotify
:
1575 dock_remove(app
, FALSE
);
1577 case ConfigureNotify
:
1578 dock_app_configure(app
, e
->xconfigure
.width
, e
->xconfigure
.height
);
1583 static ObMenuFrame
* find_active_menu()
1586 ObMenuFrame
*ret
= NULL
;
1588 for (it
= menu_frame_visible
; it
; it
= g_list_next(it
)) {
1597 static ObMenuFrame
* find_active_or_last_menu()
1599 ObMenuFrame
*ret
= NULL
;
1601 ret
= find_active_menu();
1602 if (!ret
&& menu_frame_visible
)
1603 ret
= menu_frame_visible
->data
;
1607 static gboolean
event_handle_menu_keyboard(XEvent
*ev
)
1609 guint keycode
, state
;
1612 gboolean ret
= TRUE
;
1614 keycode
= ev
->xkey
.keycode
;
1615 state
= ev
->xkey
.state
;
1616 unikey
= translate_unichar(keycode
);
1618 frame
= find_active_or_last_menu();
1622 else if (keycode
== ob_keycode(OB_KEY_ESCAPE
) && state
== 0)
1623 menu_frame_hide_all();
1625 else if (keycode
== ob_keycode(OB_KEY_RETURN
) && (state
== 0 ||
1626 state
== ControlMask
))
1628 /* Enter runs the active item or goes into the submenu.
1629 Control-Enter runs it without closing the menu. */
1631 menu_frame_select_next(frame
->child
);
1632 else if (frame
->selected
)
1633 menu_entry_frame_execute(frame
->selected
, state
, ev
->xkey
.time
);
1636 else if (keycode
== ob_keycode(OB_KEY_LEFT
) && ev
->xkey
.state
== 0) {
1637 /* Left goes to the parent menu */
1638 menu_frame_select(frame
, NULL
, TRUE
);
1641 else if (keycode
== ob_keycode(OB_KEY_RIGHT
) && ev
->xkey
.state
== 0) {
1642 /* Right goes to the selected submenu */
1643 if (frame
->child
) menu_frame_select_next(frame
->child
);
1646 else if (keycode
== ob_keycode(OB_KEY_UP
) && state
== 0) {
1647 menu_frame_select_previous(frame
);
1650 else if (keycode
== ob_keycode(OB_KEY_DOWN
) && state
== 0) {
1651 menu_frame_select_next(frame
);
1654 /* keyboard accelerator shortcuts. (allow controlmask) */
1655 else if ((ev
->xkey
.state
& ~ControlMask
) == 0 &&
1656 /* was it a valid key? */
1658 /* don't bother if the menu is empty. */
1663 ObMenuEntryFrame
*found
= NULL
;
1664 guint num_found
= 0;
1666 /* start after the selected one */
1667 start
= frame
->entries
;
1668 if (frame
->selected
) {
1669 for (it
= start
; frame
->selected
!= it
->data
; it
= g_list_next(it
))
1670 g_assert(it
!= NULL
); /* nothing was selected? */
1671 /* next with wraparound */
1672 start
= g_list_next(it
);
1673 if (start
== NULL
) start
= frame
->entries
;
1678 ObMenuEntryFrame
*e
= it
->data
;
1679 gunichar entrykey
= 0;
1681 if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
)
1682 entrykey
= e
->entry
->data
.normal
.shortcut
;
1683 else if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_SUBMENU
)
1684 entrykey
= e
->entry
->data
.submenu
.submenu
->shortcut
;
1686 if (unikey
== entrykey
) {
1687 if (found
== NULL
) found
= e
;
1691 /* next with wraparound */
1692 it
= g_list_next(it
);
1693 if (it
== NULL
) it
= frame
->entries
;
1694 } while (it
!= start
);
1697 if (found
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
&&
1700 menu_frame_select(frame
, found
, TRUE
);
1701 usleep(50000); /* highlight the item for a short bit so the
1702 user can see what happened */
1703 menu_entry_frame_execute(found
, state
, ev
->xkey
.time
);
1705 menu_frame_select(frame
, found
, TRUE
);
1707 menu_frame_select_next(frame
->child
);
1718 static gboolean
event_handle_menu(XEvent
*ev
)
1721 ObMenuEntryFrame
*e
;
1722 gboolean ret
= TRUE
;
1726 if (menu_hide_delay_reached() &&
1727 (ev
->xbutton
.button
< 4 || ev
->xbutton
.button
> 5))
1729 if ((e
= menu_entry_frame_under(ev
->xbutton
.x_root
,
1730 ev
->xbutton
.y_root
)))
1732 menu_frame_select(e
->frame
, e
, TRUE
);
1733 menu_entry_frame_execute(e
, ev
->xbutton
.state
,
1737 menu_frame_hide_all();
1741 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
))) {
1742 if (e
->ignore_enters
)
1744 else if (!(f
= find_active_menu()) ||
1746 f
->parent
== e
->frame
||
1747 f
->child
== e
->frame
)
1748 menu_frame_select(e
->frame
, e
, FALSE
);
1752 /*ignore leaves when we're already in the window */
1753 if (ev
->xcrossing
.detail
== NotifyInferior
)
1756 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
)) &&
1757 (f
= find_active_menu()) && f
->selected
== e
&&
1758 e
->entry
->type
!= OB_MENU_ENTRY_TYPE_SUBMENU
)
1760 menu_frame_select(e
->frame
, NULL
, FALSE
);
1764 if ((e
= menu_entry_frame_under(ev
->xmotion
.x_root
,
1765 ev
->xmotion
.y_root
)))
1766 if (!(f
= find_active_menu()) ||
1768 f
->parent
== e
->frame
||
1769 f
->child
== e
->frame
)
1770 menu_frame_select(e
->frame
, e
, FALSE
);
1773 ret
= event_handle_menu_keyboard(ev
);
1779 static void event_handle_user_input(ObClient
*client
, XEvent
*e
)
1781 g_assert(e
->type
== ButtonPress
|| e
->type
== ButtonRelease
||
1782 e
->type
== MotionNotify
|| e
->type
== KeyPress
||
1783 e
->type
== KeyRelease
);
1785 if (menu_frame_visible
) {
1786 if (event_handle_menu(e
))
1787 /* don't use the event if the menu used it, but if the menu
1788 didn't use it and it's a keypress that is bound, it will
1789 close the menu and be used */
1793 /* if the keyboard interactive action uses the event then dont
1794 use it for bindings. likewise is moveresize uses the event. */
1795 if (!keyboard_process_interactive_grab(e
, &client
) &&
1796 !(moveresize_in_progress
&& moveresize_event(e
)))
1798 if (moveresize_in_progress
)
1799 /* make further actions work on the client being
1801 client
= moveresize_client
;
1803 if (e
->type
== ButtonPress
||
1804 e
->type
== ButtonRelease
||
1805 e
->type
== MotionNotify
)
1807 /* the frame may not be "visible" but they can still click on it
1808 in the case where it is animating before disappearing */
1809 if (!client
|| !frame_iconify_animating(client
->frame
))
1810 mouse_event(client
, e
);
1812 keyboard_event((focus_cycle_target
? focus_cycle_target
:
1813 (client
? client
: focus_client
)), e
);
1817 static void focus_delay_dest(gpointer data
)
1822 static gboolean
focus_delay_cmp(gconstpointer d1
, gconstpointer d2
)
1824 const ObFocusDelayData
*f1
= d1
;
1825 return f1
->client
== d2
;
1828 static gboolean
focus_delay_func(gpointer data
)
1830 ObFocusDelayData
*d
= data
;
1831 Time old
= event_curtime
;
1833 event_curtime
= d
->time
;
1834 if (focus_client
!= d
->client
) {
1835 if (client_focus(d
->client
) && config_focus_raise
)
1836 stacking_raise(CLIENT_AS_WINDOW(d
->client
));
1838 event_curtime
= old
;
1839 return FALSE
; /* no repeat */
1842 static void focus_delay_client_dest(ObClient
*client
, gpointer data
)
1844 ob_main_loop_timeout_remove_data(ob_main_loop
, focus_delay_func
,
1848 void event_halt_focus_delay()
1850 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
1853 gulong
event_start_ignore_all_enters()
1855 XSync(ob_display
, FALSE
);
1856 return LastKnownRequestProcessed(ob_display
);
1859 void event_end_ignore_all_enters(gulong start
)
1863 g_assert(start
!= 0);
1864 XSync(ob_display
, FALSE
);
1866 r
= g_new(ObSerialRange
, 1);
1868 r
->end
= LastKnownRequestProcessed(ob_display
);
1869 ignore_serials
= g_slist_prepend(ignore_serials
, r
);
1871 /* increment the serial so we don't ignore events we weren't meant to */
1872 XSync(ob_display
, FALSE
);
1875 static gboolean
is_enter_focus_event_ignored(XEvent
*e
)
1879 g_assert(e
->type
== EnterNotify
&&
1880 !(e
->xcrossing
.mode
== NotifyGrab
||
1881 e
->xcrossing
.mode
== NotifyUngrab
||
1882 e
->xcrossing
.detail
== NotifyInferior
));
1884 for (it
= ignore_serials
; it
; it
= next
) {
1885 ObSerialRange
*r
= it
->data
;
1887 next
= g_slist_next(it
);
1889 if ((glong
)(e
->xany
.serial
- r
->end
) > 0) {
1891 ignore_serials
= g_slist_delete_link(ignore_serials
, it
);
1894 else if ((glong
)(e
->xany
.serial
- r
->start
) >= 0)
1900 void event_cancel_all_key_grabs()
1902 if (keyboard_interactively_grabbed()) {
1903 keyboard_interactive_cancel();
1904 ob_debug("KILLED interactive event\n");
1906 else if (menu_frame_visible
) {
1907 menu_frame_hide_all();
1908 ob_debug("KILLED open menus\n");
1910 else if (grab_on_keyboard()) {
1912 ob_debug("KILLED active grab on keyboard\n");
1915 ungrab_passive_key();
1918 gboolean
event_time_after(Time t1
, Time t2
)
1920 g_assert(t1
!= CurrentTime
);
1921 g_assert(t2
!= CurrentTime
);
1924 Timestamp values wrap around (after about 49.7 days). The server, given
1925 its current time is represented by timestamp T, always interprets
1926 timestamps from clients by treating half of the timestamp space as being
1927 later in time than T.
1928 - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
1931 /* TIME_HALF is half of the number space of a Time type variable */
1932 #define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
1934 if (t2
>= TIME_HALF
)
1935 /* t2 is in the second half so t1 might wrap around and be smaller than
1937 return t1
>= t2
|| t1
< (t2
+ TIME_HALF
);
1939 /* t2 is in the first half so t1 has to come after it */
1940 return t1
>= t2
&& t1
< (t2
+ TIME_HALF
);