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"
39 #include "framerender.h"
41 #include "focus_cycle.h"
42 #include "moveresize.h"
45 #include "extensions.h"
46 #include "translate.h"
49 #include <X11/Xatom.h>
52 #ifdef HAVE_SYS_SELECT_H
53 # include <sys/select.h>
59 # include <unistd.h> /* for usleep() */
62 # include <X11/XKBlib.h>
66 #include <X11/ICE/ICElib.h>
82 gulong start
; /* inclusive */
83 gulong end
; /* inclusive */
86 static void event_process(const XEvent
*e
, gpointer data
);
87 static void event_handle_root(XEvent
*e
);
88 static gboolean
event_handle_menu_keyboard(XEvent
*e
);
89 static gboolean
event_handle_menu(XEvent
*e
);
90 static void event_handle_dock(ObDock
*s
, XEvent
*e
);
91 static void event_handle_dockapp(ObDockApp
*app
, XEvent
*e
);
92 static void event_handle_client(ObClient
*c
, XEvent
*e
);
93 static void event_handle_user_time_window_clients(GSList
*l
, XEvent
*e
);
94 static void event_handle_user_input(ObClient
*client
, XEvent
*e
);
95 static gboolean
is_enter_focus_event_ignored(XEvent
*e
);
97 static void focus_delay_dest(gpointer data
);
98 static gboolean
focus_delay_cmp(gconstpointer d1
, gconstpointer d2
);
99 static gboolean
focus_delay_func(gpointer data
);
100 static void focus_delay_client_dest(ObClient
*client
, gpointer data
);
102 /* The time for the current event being processed */
103 Time event_curtime
= CurrentTime
;
105 static gboolean focus_left_screen
= FALSE
;
106 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
107 static GSList
*ignore_serials
= NULL
;
110 static void ice_handler(gint fd
, gpointer conn
)
113 IceProcessMessages(conn
, NULL
, &b
);
116 static void ice_watch(IceConn conn
, IcePointer data
, Bool opening
,
117 IcePointer
*watch_data
)
122 fd
= IceConnectionNumber(conn
);
123 ob_main_loop_fd_add(ob_main_loop
, fd
, ice_handler
, conn
, NULL
);
125 ob_main_loop_fd_remove(ob_main_loop
, fd
);
131 void event_startup(gboolean reconfig
)
133 if (reconfig
) return;
135 ob_main_loop_x_add(ob_main_loop
, event_process
, NULL
, NULL
);
138 IceAddConnectionWatch(ice_watch
, NULL
);
141 client_add_destroy_notify(focus_delay_client_dest
, NULL
);
144 void event_shutdown(gboolean reconfig
)
146 if (reconfig
) return;
149 IceRemoveConnectionWatch(ice_watch
, NULL
);
152 client_remove_destroy_notify(focus_delay_client_dest
);
155 static Window
event_get_window(XEvent
*e
)
162 window
= RootWindow(ob_display
, ob_screen
);
165 window
= e
->xmap
.window
;
168 window
= e
->xunmap
.window
;
171 window
= e
->xdestroywindow
.window
;
173 case ConfigureRequest
:
174 window
= e
->xconfigurerequest
.window
;
176 case ConfigureNotify
:
177 window
= e
->xconfigure
.window
;
181 if (extensions_xkb
&& e
->type
== extensions_xkb_event_basep
) {
182 switch (((XkbAnyEvent
*)e
)->xkb_type
) {
184 window
= ((XkbBellNotifyEvent
*)e
)->window
;
191 if (extensions_sync
&&
192 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
197 window
= e
->xany
.window
;
202 static void event_set_curtime(XEvent
*e
)
204 Time t
= CurrentTime
;
206 /* grab the lasttime and hack up the state */
222 t
= e
->xproperty
.time
;
226 t
= e
->xcrossing
.time
;
230 if (extensions_sync
&&
231 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
233 t
= ((XSyncAlarmNotifyEvent
*)e
)->time
;
236 /* if more event types are anticipated, get their timestamp
244 static void event_hack_mods(XEvent
*e
)
247 XkbStateRec xkb_state
;
253 e
->xbutton
.state
= modkeys_only_modifier_masks(e
->xbutton
.state
);
256 e
->xkey
.state
= modkeys_only_modifier_masks(e
->xkey
.state
);
259 e
->xkey
.state
= modkeys_only_modifier_masks(e
->xkey
.state
);
261 if (XkbGetState(ob_display
, XkbUseCoreKbd
, &xkb_state
) == Success
) {
262 e
->xkey
.state
= xkb_state
.compat_state
;
266 /* remove from the state the mask of the modifier key being released,
267 if it is a modifier key being released that is */
268 e
->xkey
.state
&= ~modkeys_keycode_to_mask(e
->xkey
.keycode
);
271 e
->xmotion
.state
= modkeys_only_modifier_masks(e
->xmotion
.state
);
272 /* compress events */
275 while (XCheckTypedWindowEvent(ob_display
, e
->xmotion
.window
,
277 e
->xmotion
.x
= ce
.xmotion
.x
;
278 e
->xmotion
.y
= ce
.xmotion
.y
;
279 e
->xmotion
.x_root
= ce
.xmotion
.x_root
;
280 e
->xmotion
.y_root
= ce
.xmotion
.y_root
;
287 static gboolean
wanted_focusevent(XEvent
*e
, gboolean in_client_only
)
289 gint mode
= e
->xfocus
.mode
;
290 gint detail
= e
->xfocus
.detail
;
291 Window win
= e
->xany
.window
;
293 if (e
->type
== FocusIn
) {
294 /* These are ones we never want.. */
296 /* This means focus was given by a keyboard/mouse grab. */
297 if (mode
== NotifyGrab
)
299 /* This means focus was given back from a keyboard/mouse grab. */
300 if (mode
== NotifyUngrab
)
303 /* These are the ones we want.. */
305 if (win
== RootWindow(ob_display
, ob_screen
)) {
306 /* If looking for a focus in on a client, then always return
307 FALSE for focus in's to the root window */
310 /* This means focus reverted off of a client */
311 else if (detail
== NotifyPointerRoot
||
312 detail
== NotifyDetailNone
||
313 detail
== NotifyInferior
||
314 /* This means focus got here from another screen */
315 detail
== NotifyNonlinear
)
321 /* It was on a client, was it a valid one?
322 It's possible to get a FocusIn event for a client that was managed
325 if (in_client_only
) {
326 ObWindow
*w
= g_hash_table_lookup(window_map
, &e
->xfocus
.window
);
327 if (!w
|| !WINDOW_IS_CLIENT(w
))
331 /* This means focus reverted to parent from the client (this
332 happens often during iconify animation) */
333 if (detail
== NotifyInferior
)
337 /* This means focus moved from the root window to a client */
338 if (detail
== NotifyVirtual
)
340 /* This means focus moved from one client to another */
341 if (detail
== NotifyNonlinearVirtual
)
347 g_assert(e
->type
== FocusOut
);
349 /* These are ones we never want.. */
351 /* This means focus was taken by a keyboard/mouse grab. */
352 if (mode
== NotifyGrab
)
354 /* This means focus was grabbed on a window and it was released. */
355 if (mode
== NotifyUngrab
)
358 /* Focus left the root window revertedto state */
359 if (win
== RootWindow(ob_display
, ob_screen
))
362 /* These are the ones we want.. */
364 /* This means focus moved from a client to the root window */
365 if (detail
== NotifyVirtual
)
367 /* This means focus moved from one client to another */
368 if (detail
== NotifyNonlinearVirtual
)
376 static Bool
event_look_for_focusin(Display
*d
, XEvent
*e
, XPointer arg
)
378 return e
->type
== FocusIn
&& wanted_focusevent(e
, FALSE
);
381 static Bool
event_look_for_focusin_client(Display
*d
, XEvent
*e
, XPointer arg
)
383 return e
->type
== FocusIn
&& wanted_focusevent(e
, TRUE
);
386 static void print_focusevent(XEvent
*e
)
388 gint mode
= e
->xfocus
.mode
;
389 gint detail
= e
->xfocus
.detail
;
390 Window win
= e
->xany
.window
;
391 const gchar
*modestr
, *detailstr
;
394 case NotifyNormal
: modestr
="NotifyNormal"; break;
395 case NotifyGrab
: modestr
="NotifyGrab"; break;
396 case NotifyUngrab
: modestr
="NotifyUngrab"; break;
397 case NotifyWhileGrabbed
: modestr
="NotifyWhileGrabbed"; break;
400 case NotifyAncestor
: detailstr
="NotifyAncestor"; break;
401 case NotifyVirtual
: detailstr
="NotifyVirtual"; break;
402 case NotifyInferior
: detailstr
="NotifyInferior"; break;
403 case NotifyNonlinear
: detailstr
="NotifyNonlinear"; break;
404 case NotifyNonlinearVirtual
: detailstr
="NotifyNonlinearVirtual"; break;
405 case NotifyPointer
: detailstr
="NotifyPointer"; break;
406 case NotifyPointerRoot
: detailstr
="NotifyPointerRoot"; break;
407 case NotifyDetailNone
: detailstr
="NotifyDetailNone"; break;
410 if (mode
== NotifyGrab
|| mode
== NotifyUngrab
)
415 ob_debug_type(OB_DEBUG_FOCUS
, "Focus%s 0x%x mode=%s detail=%s\n",
416 (e
->xfocus
.type
== FocusIn
? "In" : "Out"),
422 static gboolean
event_ignore(XEvent
*e
, ObClient
*client
)
427 if (!wanted_focusevent(e
, FALSE
))
432 if (!wanted_focusevent(e
, FALSE
))
439 static void event_process(const XEvent
*ec
, gpointer data
)
442 ObClient
*client
= NULL
;
444 ObDockApp
*dockapp
= NULL
;
445 ObWindow
*obwin
= NULL
;
446 GSList
*timewinclients
= NULL
;
448 ObEventData
*ed
= data
;
450 /* make a copy we can mangle */
454 window
= event_get_window(e
);
455 if (e
->type
!= PropertyNotify
||
456 !(timewinclients
= propwin_get_clients(window
,
457 OB_PROPWIN_USER_TIME
)))
458 if ((obwin
= g_hash_table_lookup(window_map
, &window
))) {
459 switch (obwin
->type
) {
461 dock
= WINDOW_AS_DOCK(obwin
);
464 dockapp
= WINDOW_AS_DOCKAPP(obwin
);
467 client
= WINDOW_AS_CLIENT(obwin
);
470 case Window_Internal
:
471 /* not to be used for events */
472 g_assert_not_reached();
477 event_set_curtime(e
);
479 if (event_ignore(e
, client
)) {
486 /* deal with it in the kernel */
488 if (menu_frame_visible
&&
489 (e
->type
== EnterNotify
|| e
->type
== LeaveNotify
))
491 /* crossing events for menu */
492 event_handle_menu(e
);
493 } else if (e
->type
== FocusIn
) {
495 e
->xfocus
.detail
== NotifyInferior
)
497 ob_debug_type(OB_DEBUG_FOCUS
,
498 "Focus went to the frame window");
500 focus_left_screen
= FALSE
;
502 focus_fallback(FALSE
, config_focus_under_mouse
, TRUE
);
504 /* We don't get a FocusOut for this case, because it's just moving
505 from our Inferior up to us. This happens when iconifying a
506 window with RevertToParent focus */
507 frame_adjust_focus(client
->frame
, FALSE
);
508 /* focus_set_client(NULL) has already been called */
509 client_calc_layer(client
);
511 if (e
->xfocus
.detail
== NotifyPointerRoot
||
512 e
->xfocus
.detail
== NotifyDetailNone
||
513 e
->xfocus
.detail
== NotifyInferior
||
514 e
->xfocus
.detail
== NotifyNonlinear
)
518 ob_debug_type(OB_DEBUG_FOCUS
,
519 "Focus went to root or pointer root/none\n");
521 if (e
->xfocus
.detail
== NotifyInferior
||
522 e
->xfocus
.detail
== NotifyNonlinear
)
524 focus_left_screen
= FALSE
;
527 /* If another FocusIn is in the queue then don't fallback yet. This
528 fixes the fun case of:
529 window map -> send focusin
530 window unmap -> get focusout
531 window map -> send focusin
532 get first focus out -> fall back to something (new window
533 hasn't received focus yet, so something else) -> send focusin
534 which means the "something else" is the last thing to get a
535 focusin sent to it, so the new window doesn't end up with focus.
537 But if the other focus in is something like PointerRoot then we
538 still want to fall back.
540 if (XCheckIfEvent(ob_display
, &ce
, event_look_for_focusin_client
,
543 XPutBackEvent(ob_display
, &ce
);
544 ob_debug_type(OB_DEBUG_FOCUS
,
545 " but another FocusIn is coming\n");
547 /* Focus has been reverted.
549 FocusOut events come after UnmapNotify, so we don't need to
550 worry about focusing an invalid window
553 if (!focus_left_screen
)
554 focus_fallback(FALSE
, config_focus_under_mouse
, TRUE
);
559 ob_debug_type(OB_DEBUG_FOCUS
,
560 "Focus went to a window that is already gone\n");
562 /* If you send focus to a window and then it disappears, you can
563 get the FocusIn for it, after it is unmanaged.
564 Just wait for the next FocusOut/FocusIn pair, but make note that
565 the window that was focused no longer is. */
566 focus_set_client(NULL
);
568 else if (client
!= focus_client
) {
569 focus_left_screen
= FALSE
;
570 frame_adjust_focus(client
->frame
, TRUE
);
571 focus_set_client(client
);
572 client_calc_layer(client
);
573 client_bring_helper_windows(client
);
575 } else if (e
->type
== FocusOut
) {
578 /* Look for the followup FocusIn */
579 if (!XCheckIfEvent(ob_display
, &ce
, event_look_for_focusin
, NULL
)) {
580 /* There is no FocusIn, this means focus went to a window that
581 is not being managed, or a window on another screen. */
585 xerror_set_ignore(TRUE
);
586 if (XGetInputFocus(ob_display
, &win
, &i
) != 0 &&
587 XGetGeometry(ob_display
, win
, &root
, &i
,&i
,&u
,&u
,&u
,&u
) != 0 &&
588 root
!= RootWindow(ob_display
, ob_screen
))
590 ob_debug_type(OB_DEBUG_FOCUS
,
591 "Focus went to another screen !\n");
592 focus_left_screen
= TRUE
;
595 ob_debug_type(OB_DEBUG_FOCUS
,
596 "Focus went to a black hole !\n");
597 xerror_set_ignore(FALSE
);
598 /* nothing is focused */
599 focus_set_client(NULL
);
601 /* Focus moved, so process the FocusIn event */
602 ObEventData ed
= { .ignored
= FALSE
};
603 event_process(&ce
, &ed
);
605 /* The FocusIn was ignored, this means it was on a window
606 that isn't a client. */
607 ob_debug_type(OB_DEBUG_FOCUS
,
608 "Focus went to an unmanaged window 0x%x !\n",
610 focus_fallback(TRUE
, config_focus_under_mouse
, TRUE
);
614 if (client
&& client
!= focus_client
) {
615 frame_adjust_focus(client
->frame
, FALSE
);
616 /* focus_set_client(NULL) has already been called in this
617 section or by focus_fallback */
618 client_calc_layer(client
);
620 } else if (timewinclients
)
621 event_handle_user_time_window_clients(timewinclients
, e
);
623 event_handle_client(client
, e
);
625 event_handle_dockapp(dockapp
, e
);
627 event_handle_dock(dock
, e
);
628 else if (window
== RootWindow(ob_display
, ob_screen
))
629 event_handle_root(e
);
630 else if (e
->type
== MapRequest
)
631 client_manage(window
);
632 else if (e
->type
== ClientMessage
) {
633 /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
634 windows that are not managed yet. */
635 if (e
->xclient
.message_type
== prop_atoms
.net_request_frame_extents
) {
636 /* Pretend to manage the client, getting information used to
637 determine its decorations */
638 ObClient
*c
= client_fake_manage(e
->xclient
.window
);
641 /* set the frame extents on the window */
642 vals
[0] = c
->frame
->size
.left
;
643 vals
[1] = c
->frame
->size
.right
;
644 vals
[2] = c
->frame
->size
.top
;
645 vals
[3] = c
->frame
->size
.bottom
;
646 PROP_SETA32(e
->xclient
.window
, net_frame_extents
,
649 /* Free the pretend client */
650 client_fake_unmanage(c
);
653 else if (e
->type
== ConfigureRequest
) {
654 /* unhandled configure requests must be used to configure the
658 xwc
.x
= e
->xconfigurerequest
.x
;
659 xwc
.y
= e
->xconfigurerequest
.y
;
660 xwc
.width
= e
->xconfigurerequest
.width
;
661 xwc
.height
= e
->xconfigurerequest
.height
;
662 xwc
.border_width
= e
->xconfigurerequest
.border_width
;
663 xwc
.sibling
= e
->xconfigurerequest
.above
;
664 xwc
.stack_mode
= e
->xconfigurerequest
.detail
;
666 /* we are not to be held responsible if someone sends us an
668 xerror_set_ignore(TRUE
);
669 XConfigureWindow(ob_display
, window
,
670 e
->xconfigurerequest
.value_mask
, &xwc
);
671 xerror_set_ignore(FALSE
);
674 else if (extensions_sync
&&
675 e
->type
== extensions_sync_event_basep
+ XSyncAlarmNotify
)
677 XSyncAlarmNotifyEvent
*se
= (XSyncAlarmNotifyEvent
*)e
;
678 if (se
->alarm
== moveresize_alarm
&& moveresize_in_progress
)
683 if (e
->type
== ButtonPress
|| e
->type
== ButtonRelease
||
684 e
->type
== MotionNotify
|| e
->type
== KeyPress
||
685 e
->type
== KeyRelease
)
687 event_handle_user_input(client
, e
);
690 /* if something happens and it's not from an XEvent, then we don't know
692 event_curtime
= CurrentTime
;
695 static void event_handle_root(XEvent
*e
)
701 ob_debug("Another WM has requested to replace us. Exiting.\n");
706 if (e
->xclient
.format
!= 32) break;
708 msgtype
= e
->xclient
.message_type
;
709 if (msgtype
== prop_atoms
.net_current_desktop
) {
710 guint d
= e
->xclient
.data
.l
[0];
711 if (d
< screen_num_desktops
) {
712 event_curtime
= e
->xclient
.data
.l
[1];
713 if (event_curtime
== 0)
714 ob_debug_type(OB_DEBUG_APP_BUGS
,
715 "_NET_CURRENT_DESKTOP message is missing "
717 screen_set_desktop(d
, TRUE
);
719 } else if (msgtype
== prop_atoms
.net_number_of_desktops
) {
720 guint d
= e
->xclient
.data
.l
[0];
721 if (d
> 0 && d
<= 1000)
722 screen_set_num_desktops(d
);
723 } else if (msgtype
== prop_atoms
.net_showing_desktop
) {
724 screen_show_desktop(e
->xclient
.data
.l
[0] != 0, NULL
);
725 } else if (msgtype
== prop_atoms
.ob_control
) {
726 ob_debug("OB_CONTROL: %d\n", e
->xclient
.data
.l
[0]);
727 if (e
->xclient
.data
.l
[0] == 1)
729 else if (e
->xclient
.data
.l
[0] == 2)
734 if (e
->xproperty
.atom
== prop_atoms
.net_desktop_names
) {
735 ob_debug("UPDATE DESKTOP NAMES\n");
736 screen_update_desktop_names();
738 else if (e
->xproperty
.atom
== prop_atoms
.net_desktop_layout
)
739 screen_update_layout();
741 case ConfigureNotify
:
743 XRRUpdateConfiguration(e
);
752 void event_enter_client(ObClient
*client
)
754 g_assert(config_focus_follow
);
756 if (client_enter_focusable(client
) && client_can_focus(client
)) {
757 if (config_focus_delay
) {
758 ObFocusDelayData
*data
;
760 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
762 data
= g_new(ObFocusDelayData
, 1);
763 data
->client
= client
;
764 data
->time
= event_curtime
;
766 ob_main_loop_timeout_add(ob_main_loop
,
769 data
, focus_delay_cmp
, focus_delay_dest
);
771 ObFocusDelayData data
;
772 data
.client
= client
;
773 data
.time
= event_curtime
;
774 focus_delay_func(&data
);
779 static void event_handle_user_time_window_clients(GSList
*l
, XEvent
*e
)
781 g_assert(e
->type
== PropertyNotify
);
782 if (e
->xproperty
.atom
== prop_atoms
.net_wm_user_time
) {
783 for (; l
; l
= g_slist_next(l
))
784 client_update_user_time(l
->data
);
788 static void event_handle_client(ObClient
*client
, XEvent
*e
)
793 static gint px
= -1, py
= -1;
798 /* save where the press occured for the first button pressed */
800 pb
= e
->xbutton
.button
;
805 /* Wheel buttons don't draw because they are an instant click, so it
806 is a waste of resources to go drawing it.
807 if the user is doing an intereactive thing, or has a menu open then
808 the mouse is grabbed (possibly) and if we get these events we don't
809 want to deal with them
811 if (!(e
->xbutton
.button
== 4 || e
->xbutton
.button
== 5) &&
812 !keyboard_interactively_grabbed() &&
815 /* use where the press occured */
816 con
= frame_context(client
, e
->xbutton
.window
, px
, py
);
817 con
= mouse_button_frame_context(con
, e
->xbutton
.button
,
820 if (e
->type
== ButtonRelease
&& e
->xbutton
.button
== pb
)
821 pb
= 0, px
= py
= -1;
824 case OB_FRAME_CONTEXT_MAXIMIZE
:
825 client
->frame
->max_press
= (e
->type
== ButtonPress
);
826 framerender_frame(client
->frame
);
828 case OB_FRAME_CONTEXT_CLOSE
:
829 client
->frame
->close_press
= (e
->type
== ButtonPress
);
830 framerender_frame(client
->frame
);
832 case OB_FRAME_CONTEXT_ICONIFY
:
833 client
->frame
->iconify_press
= (e
->type
== ButtonPress
);
834 framerender_frame(client
->frame
);
836 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
837 client
->frame
->desk_press
= (e
->type
== ButtonPress
);
838 framerender_frame(client
->frame
);
840 case OB_FRAME_CONTEXT_SHADE
:
841 client
->frame
->shade_press
= (e
->type
== ButtonPress
);
842 framerender_frame(client
->frame
);
845 /* nothing changes with clicks for any other contexts */
851 /* when there is a grab on the pointer, we won't get enter/leave
852 notifies, but we still get motion events */
853 if (grab_on_pointer()) break;
855 con
= frame_context(client
, e
->xmotion
.window
,
856 e
->xmotion
.x
, e
->xmotion
.y
);
858 case OB_FRAME_CONTEXT_TITLEBAR
:
859 case OB_FRAME_CONTEXT_TLCORNER
:
860 case OB_FRAME_CONTEXT_TRCORNER
:
861 /* we've left the button area inside the titlebar */
862 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
863 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
864 client
->frame
->close_hover
)
866 client
->frame
->max_hover
= FALSE
;
867 client
->frame
->desk_hover
= FALSE
;
868 client
->frame
->shade_hover
= FALSE
;
869 client
->frame
->iconify_hover
= FALSE
;
870 client
->frame
->close_hover
= FALSE
;
871 frame_adjust_state(client
->frame
);
874 case OB_FRAME_CONTEXT_MAXIMIZE
:
875 if (!client
->frame
->max_hover
) {
876 client
->frame
->max_hover
= TRUE
;
877 frame_adjust_state(client
->frame
);
880 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
881 if (!client
->frame
->desk_hover
) {
882 client
->frame
->desk_hover
= TRUE
;
883 frame_adjust_state(client
->frame
);
886 case OB_FRAME_CONTEXT_SHADE
:
887 if (!client
->frame
->shade_hover
) {
888 client
->frame
->shade_hover
= TRUE
;
889 frame_adjust_state(client
->frame
);
892 case OB_FRAME_CONTEXT_ICONIFY
:
893 if (!client
->frame
->iconify_hover
) {
894 client
->frame
->iconify_hover
= TRUE
;
895 frame_adjust_state(client
->frame
);
898 case OB_FRAME_CONTEXT_CLOSE
:
899 if (!client
->frame
->close_hover
) {
900 client
->frame
->close_hover
= TRUE
;
901 frame_adjust_state(client
->frame
);
909 con
= frame_context(client
, e
->xcrossing
.window
,
910 e
->xcrossing
.x
, e
->xcrossing
.y
);
912 case OB_FRAME_CONTEXT_TITLEBAR
:
913 case OB_FRAME_CONTEXT_TLCORNER
:
914 case OB_FRAME_CONTEXT_TRCORNER
:
915 /* we've left the button area inside the titlebar */
916 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
917 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
918 client
->frame
->close_hover
)
920 client
->frame
->max_hover
= FALSE
;
921 client
->frame
->desk_hover
= FALSE
;
922 client
->frame
->shade_hover
= FALSE
;
923 client
->frame
->iconify_hover
= FALSE
;
924 client
->frame
->close_hover
= FALSE
;
925 frame_adjust_state(client
->frame
);
928 case OB_FRAME_CONTEXT_MAXIMIZE
:
929 client
->frame
->max_hover
= FALSE
;
930 frame_adjust_state(client
->frame
);
932 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
933 client
->frame
->desk_hover
= FALSE
;
934 frame_adjust_state(client
->frame
);
936 case OB_FRAME_CONTEXT_SHADE
:
937 client
->frame
->shade_hover
= FALSE
;
938 frame_adjust_state(client
->frame
);
940 case OB_FRAME_CONTEXT_ICONIFY
:
941 client
->frame
->iconify_hover
= FALSE
;
942 frame_adjust_state(client
->frame
);
944 case OB_FRAME_CONTEXT_CLOSE
:
945 client
->frame
->close_hover
= FALSE
;
946 frame_adjust_state(client
->frame
);
948 case OB_FRAME_CONTEXT_FRAME
:
949 /* When the mouse leaves an animating window, don't use the
950 corresponding enter events. Pretend like the animating window
951 doesn't even exist..! */
952 if (frame_iconify_animating(client
->frame
))
953 event_end_ignore_all_enters(event_start_ignore_all_enters());
955 ob_debug_type(OB_DEBUG_FOCUS
,
956 "%sNotify mode %d detail %d on %lx\n",
957 (e
->type
== EnterNotify
? "Enter" : "Leave"),
959 e
->xcrossing
.detail
, (client
?client
->window
:0));
960 if (keyboard_interactively_grabbed())
962 if (config_focus_follow
&& config_focus_delay
&&
963 /* leave inferior events can happen when the mouse goes onto
964 the window's border and then into the window before the
966 e
->xcrossing
.detail
!= NotifyInferior
)
968 ob_main_loop_timeout_remove_data(ob_main_loop
,
979 con
= frame_context(client
, e
->xcrossing
.window
,
980 e
->xcrossing
.x
, e
->xcrossing
.y
);
982 case OB_FRAME_CONTEXT_MAXIMIZE
:
983 client
->frame
->max_hover
= TRUE
;
984 frame_adjust_state(client
->frame
);
986 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
987 client
->frame
->desk_hover
= TRUE
;
988 frame_adjust_state(client
->frame
);
990 case OB_FRAME_CONTEXT_SHADE
:
991 client
->frame
->shade_hover
= TRUE
;
992 frame_adjust_state(client
->frame
);
994 case OB_FRAME_CONTEXT_ICONIFY
:
995 client
->frame
->iconify_hover
= TRUE
;
996 frame_adjust_state(client
->frame
);
998 case OB_FRAME_CONTEXT_CLOSE
:
999 client
->frame
->close_hover
= TRUE
;
1000 frame_adjust_state(client
->frame
);
1002 case OB_FRAME_CONTEXT_FRAME
:
1003 if (keyboard_interactively_grabbed())
1005 if (e
->xcrossing
.mode
== NotifyGrab
||
1006 e
->xcrossing
.mode
== NotifyUngrab
||
1007 /*ignore enters when we're already in the window */
1008 e
->xcrossing
.detail
== NotifyInferior
||
1009 is_enter_focus_event_ignored(e
))
1011 ob_debug_type(OB_DEBUG_FOCUS
,
1012 "%sNotify mode %d detail %d on %lx IGNORED\n",
1013 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1015 e
->xcrossing
.detail
, client
?client
->window
:0);
1018 ob_debug_type(OB_DEBUG_FOCUS
,
1019 "%sNotify mode %d detail %d on %lx, "
1020 "focusing window\n",
1021 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1023 e
->xcrossing
.detail
, (client
?client
->window
:0));
1024 if (config_focus_follow
)
1025 event_enter_client(client
);
1033 case ConfigureRequest
:
1035 /* dont compress these unless you're going to watch for property
1036 notifies in between (these can change what the configure would
1038 also you can't compress stacking events
1042 gboolean move
= FALSE
;
1043 gboolean resize
= FALSE
;
1045 /* get the current area */
1046 RECT_TO_DIMS(client
->area
, x
, y
, w
, h
);
1048 ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1050 " x %d y %d w %d h %d b %d\n",
1052 screen_desktop
, client
->wmstate
, client
->frame
->visible
,
1053 x
, y
, w
, h
, client
->border_width
);
1055 if (e
->xconfigurerequest
.value_mask
& CWBorderWidth
)
1056 if (client
->border_width
!= e
->xconfigurerequest
.border_width
) {
1057 client
->border_width
= e
->xconfigurerequest
.border_width
;
1059 /* if the border width is changing then that is the same
1060 as requesting a resize, but we don't actually change
1061 the client's border, so it will change their root
1062 coordiantes (since they include the border width) and
1063 we need to a notify then */
1068 if (e
->xconfigurerequest
.value_mask
& CWStackMode
) {
1069 ObClient
*sibling
= NULL
;
1070 gulong ignore_start
;
1072 /* get the sibling */
1073 if (e
->xconfigurerequest
.value_mask
& CWSibling
) {
1075 win
= g_hash_table_lookup(window_map
,
1076 &e
->xconfigurerequest
.above
);
1077 if (WINDOW_IS_CLIENT(win
) && WINDOW_AS_CLIENT(win
) != client
)
1078 sibling
= WINDOW_AS_CLIENT(win
);
1081 /* activate it rather than just focus it */
1082 if (!config_focus_under_mouse
)
1083 ignore_start
= event_start_ignore_all_enters();
1084 stacking_restack_request(client
, sibling
,
1085 e
->xconfigurerequest
.detail
,
1087 if (!config_focus_under_mouse
)
1088 event_end_ignore_all_enters(ignore_start
);
1090 /* if a stacking change moves the window without resizing */
1094 if ((e
->xconfigurerequest
.value_mask
& CWX
) ||
1095 (e
->xconfigurerequest
.value_mask
& CWY
) ||
1096 (e
->xconfigurerequest
.value_mask
& CWWidth
) ||
1097 (e
->xconfigurerequest
.value_mask
& CWHeight
))
1099 if (e
->xconfigurerequest
.value_mask
& CWX
) {
1100 /* don't allow clients to move shaded windows (fvwm does this)
1102 if (!client
->shaded
)
1103 x
= e
->xconfigurerequest
.x
;
1106 if (e
->xconfigurerequest
.value_mask
& CWY
) {
1107 /* don't allow clients to move shaded windows (fvwm does this)
1109 if (!client
->shaded
)
1110 y
= e
->xconfigurerequest
.y
;
1114 if (e
->xconfigurerequest
.value_mask
& CWWidth
) {
1115 w
= e
->xconfigurerequest
.width
;
1118 if (e
->xconfigurerequest
.value_mask
& CWHeight
) {
1119 h
= e
->xconfigurerequest
.height
;
1124 ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1125 "move %d resize %d\n",
1126 e
->xconfigurerequest
.value_mask
& CWX
, x
,
1127 e
->xconfigurerequest
.value_mask
& CWY
, y
,
1128 e
->xconfigurerequest
.value_mask
& CWWidth
, w
,
1129 e
->xconfigurerequest
.value_mask
& CWHeight
, h
,
1132 /* check for broken apps moving to their root position
1134 XXX remove this some day...that would be nice. right now all
1135 kde apps do this when they try activate themselves on another
1136 desktop. eg. open amarok window on desktop 1, switch to desktop
1137 2, click amarok tray icon. it will move by its decoration size.
1139 if (x
!= client
->area
.x
&&
1140 x
== (client
->frame
->area
.x
+ client
->frame
->size
.left
-
1141 (gint
)client
->border_width
) &&
1142 y
!= client
->area
.y
&&
1143 y
== (client
->frame
->area
.y
+ client
->frame
->size
.top
-
1144 (gint
)client
->border_width
) &&
1145 w
== client
->area
.width
&&
1146 h
== client
->area
.height
)
1148 ob_debug_type(OB_DEBUG_APP_BUGS
,
1149 "Application %s is trying to move via "
1150 "ConfigureRequest to it's root window position "
1151 "but it is not using StaticGravity\n",
1157 /* they still requested a move, so don't change whether a
1158 notify is sent or not */
1164 client_try_configure(client
, &x
, &y
, &w
, &h
, &lw
, &lh
, FALSE
);
1166 /* if x was not given, then use gravity to figure out the new
1167 x. the reference point should not be moved */
1168 if ((e
->xconfigurerequest
.value_mask
& CWWidth
&&
1169 !(e
->xconfigurerequest
.value_mask
& CWX
)))
1170 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1171 /* if y was not given, then use gravity to figure out the new
1172 y. the reference point should not be moved */
1173 if ((e
->xconfigurerequest
.value_mask
& CWHeight
&&
1174 !(e
->xconfigurerequest
.value_mask
& CWY
)))
1175 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1177 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1179 ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
1181 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
, TRUE
);
1186 if (client
->ignore_unmaps
) {
1187 client
->ignore_unmaps
--;
1190 ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1191 "ignores left %d\n",
1192 client
->window
, e
->xunmap
.event
, e
->xunmap
.from_configure
,
1193 client
->ignore_unmaps
);
1194 client_unmanage(client
);
1197 ob_debug("DestroyNotify for window 0x%x\n", client
->window
);
1198 client_unmanage(client
);
1200 case ReparentNotify
:
1201 /* this is when the client is first taken captive in the frame */
1202 if (e
->xreparent
.parent
== client
->frame
->window
) break;
1205 This event is quite rare and is usually handled in unmapHandler.
1206 However, if the window is unmapped when the reparent event occurs,
1207 the window manager never sees it because an unmap event is not sent
1208 to an already unmapped window.
1211 /* we don't want the reparent event, put it back on the stack for the
1212 X server to deal with after we unmanage the window */
1213 XPutBackEvent(ob_display
, e
);
1215 ob_debug("ReparentNotify for window 0x%x\n", client
->window
);
1216 client_unmanage(client
);
1219 ob_debug("MapRequest for 0x%lx\n", client
->window
);
1220 if (!client
->iconic
) break; /* this normally doesn't happen, but if it
1221 does, we don't want it!
1222 it can happen now when the window is on
1223 another desktop, but we still don't
1225 client_activate(client
, FALSE
, TRUE
);
1228 /* validate cuz we query stuff off the client here */
1229 if (!client_validate(client
)) break;
1231 if (e
->xclient
.format
!= 32) return;
1233 msgtype
= e
->xclient
.message_type
;
1234 if (msgtype
== prop_atoms
.wm_change_state
) {
1235 /* compress changes into a single change */
1236 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1238 /* XXX: it would be nice to compress ALL messages of a
1239 type, not just messages in a row without other
1240 message types between. */
1241 if (ce
.xclient
.message_type
!= msgtype
) {
1242 XPutBackEvent(ob_display
, &ce
);
1245 e
->xclient
= ce
.xclient
;
1247 client_set_wm_state(client
, e
->xclient
.data
.l
[0]);
1248 } else if (msgtype
== prop_atoms
.net_wm_desktop
) {
1249 /* compress changes into a single change */
1250 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1252 /* XXX: it would be nice to compress ALL messages of a
1253 type, not just messages in a row without other
1254 message types between. */
1255 if (ce
.xclient
.message_type
!= msgtype
) {
1256 XPutBackEvent(ob_display
, &ce
);
1259 e
->xclient
= ce
.xclient
;
1261 if ((unsigned)e
->xclient
.data
.l
[0] < screen_num_desktops
||
1262 (unsigned)e
->xclient
.data
.l
[0] == DESKTOP_ALL
)
1263 client_set_desktop(client
, (unsigned)e
->xclient
.data
.l
[0],
1265 } else if (msgtype
== prop_atoms
.net_wm_state
) {
1266 gulong ignore_start
;
1268 /* can't compress these */
1269 ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
1270 (e
->xclient
.data
.l
[0] == 0 ? "Remove" :
1271 e
->xclient
.data
.l
[0] == 1 ? "Add" :
1272 e
->xclient
.data
.l
[0] == 2 ? "Toggle" : "INVALID"),
1273 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2],
1276 /* ignore enter events caused by these like ob actions do */
1277 if (!config_focus_under_mouse
)
1278 ignore_start
= event_start_ignore_all_enters();
1279 client_set_state(client
, e
->xclient
.data
.l
[0],
1280 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2]);
1281 if (!config_focus_under_mouse
)
1282 event_end_ignore_all_enters(ignore_start
);
1283 } else if (msgtype
== prop_atoms
.net_close_window
) {
1284 ob_debug("net_close_window for 0x%lx\n", client
->window
);
1285 client_close(client
);
1286 } else if (msgtype
== prop_atoms
.net_active_window
) {
1287 ob_debug("net_active_window for 0x%lx source=%s\n",
1289 (e
->xclient
.data
.l
[0] == 0 ? "unknown" :
1290 (e
->xclient
.data
.l
[0] == 1 ? "application" :
1291 (e
->xclient
.data
.l
[0] == 2 ? "user" : "INVALID"))));
1292 /* XXX make use of data.l[2] !? */
1293 if (e
->xclient
.data
.l
[0] == 1 || e
->xclient
.data
.l
[0] == 2) {
1294 event_curtime
= e
->xclient
.data
.l
[1];
1295 if (event_curtime
== 0)
1296 ob_debug_type(OB_DEBUG_APP_BUGS
,
1297 "_NET_ACTIVE_WINDOW message for window %s is"
1298 " missing a timestamp\n", client
->title
);
1300 ob_debug_type(OB_DEBUG_APP_BUGS
,
1301 "_NET_ACTIVE_WINDOW message for window %s is "
1302 "missing source indication\n");
1303 client_activate(client
, FALSE
,
1304 (e
->xclient
.data
.l
[0] == 0 ||
1305 e
->xclient
.data
.l
[0] == 2));
1306 } else if (msgtype
== prop_atoms
.net_wm_moveresize
) {
1307 ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
1308 client
->window
, e
->xclient
.data
.l
[2]);
1309 if ((Atom
)e
->xclient
.data
.l
[2] ==
1310 prop_atoms
.net_wm_moveresize_size_topleft
||
1311 (Atom
)e
->xclient
.data
.l
[2] ==
1312 prop_atoms
.net_wm_moveresize_size_top
||
1313 (Atom
)e
->xclient
.data
.l
[2] ==
1314 prop_atoms
.net_wm_moveresize_size_topright
||
1315 (Atom
)e
->xclient
.data
.l
[2] ==
1316 prop_atoms
.net_wm_moveresize_size_right
||
1317 (Atom
)e
->xclient
.data
.l
[2] ==
1318 prop_atoms
.net_wm_moveresize_size_right
||
1319 (Atom
)e
->xclient
.data
.l
[2] ==
1320 prop_atoms
.net_wm_moveresize_size_bottomright
||
1321 (Atom
)e
->xclient
.data
.l
[2] ==
1322 prop_atoms
.net_wm_moveresize_size_bottom
||
1323 (Atom
)e
->xclient
.data
.l
[2] ==
1324 prop_atoms
.net_wm_moveresize_size_bottomleft
||
1325 (Atom
)e
->xclient
.data
.l
[2] ==
1326 prop_atoms
.net_wm_moveresize_size_left
||
1327 (Atom
)e
->xclient
.data
.l
[2] ==
1328 prop_atoms
.net_wm_moveresize_move
||
1329 (Atom
)e
->xclient
.data
.l
[2] ==
1330 prop_atoms
.net_wm_moveresize_size_keyboard
||
1331 (Atom
)e
->xclient
.data
.l
[2] ==
1332 prop_atoms
.net_wm_moveresize_move_keyboard
) {
1334 moveresize_start(client
, e
->xclient
.data
.l
[0],
1335 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[3],
1336 e
->xclient
.data
.l
[2]);
1338 else if ((Atom
)e
->xclient
.data
.l
[2] ==
1339 prop_atoms
.net_wm_moveresize_cancel
)
1340 moveresize_end(TRUE
);
1341 } else if (msgtype
== prop_atoms
.net_moveresize_window
) {
1342 gint ograv
, x
, y
, w
, h
;
1344 ograv
= client
->gravity
;
1346 if (e
->xclient
.data
.l
[0] & 0xff)
1347 client
->gravity
= e
->xclient
.data
.l
[0] & 0xff;
1349 if (e
->xclient
.data
.l
[0] & 1 << 8)
1350 x
= e
->xclient
.data
.l
[1];
1353 if (e
->xclient
.data
.l
[0] & 1 << 9)
1354 y
= e
->xclient
.data
.l
[2];
1358 if (e
->xclient
.data
.l
[0] & 1 << 10) {
1359 w
= e
->xclient
.data
.l
[3];
1361 /* if x was not given, then use gravity to figure out the new
1362 x. the reference point should not be moved */
1363 if (!(e
->xclient
.data
.l
[0] & 1 << 8))
1364 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1367 w
= client
->area
.width
;
1369 if (e
->xclient
.data
.l
[0] & 1 << 11) {
1370 h
= e
->xclient
.data
.l
[4];
1372 /* if y was not given, then use gravity to figure out the new
1373 y. the reference point should not be moved */
1374 if (!(e
->xclient
.data
.l
[0] & 1 << 9))
1375 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1378 h
= client
->area
.height
;
1380 ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
1381 e
->xclient
.data
.l
[0] & 1 << 8, x
,
1382 e
->xclient
.data
.l
[0] & 1 << 9, y
,
1385 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1387 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
, FALSE
);
1389 client
->gravity
= ograv
;
1390 } else if (msgtype
== prop_atoms
.net_restack_window
) {
1391 if (e
->xclient
.data
.l
[0] != 2) {
1392 ob_debug_type(OB_DEBUG_APP_BUGS
,
1393 "_NET_RESTACK_WINDOW sent for window %s with "
1394 "invalid source indication %ld\n",
1395 client
->title
, e
->xclient
.data
.l
[0]);
1397 ObClient
*sibling
= NULL
;
1398 if (e
->xclient
.data
.l
[1]) {
1399 ObWindow
*win
= g_hash_table_lookup
1400 (window_map
, &e
->xclient
.data
.l
[1]);
1401 if (WINDOW_IS_CLIENT(win
) &&
1402 WINDOW_AS_CLIENT(win
) != client
)
1404 sibling
= WINDOW_AS_CLIENT(win
);
1406 if (sibling
== NULL
)
1407 ob_debug_type(OB_DEBUG_APP_BUGS
,
1408 "_NET_RESTACK_WINDOW sent for window %s "
1409 "with invalid sibling 0x%x\n",
1410 client
->title
, e
->xclient
.data
.l
[1]);
1412 if (e
->xclient
.data
.l
[2] == Below
||
1413 e
->xclient
.data
.l
[2] == BottomIf
||
1414 e
->xclient
.data
.l
[2] == Above
||
1415 e
->xclient
.data
.l
[2] == TopIf
||
1416 e
->xclient
.data
.l
[2] == Opposite
)
1418 gulong ignore_start
;
1420 if (!config_focus_under_mouse
)
1421 ignore_start
= event_start_ignore_all_enters();
1422 /* just raise, don't activate */
1423 stacking_restack_request(client
, sibling
,
1424 e
->xclient
.data
.l
[2], FALSE
);
1425 if (!config_focus_under_mouse
)
1426 event_end_ignore_all_enters(ignore_start
);
1428 /* send a synthetic ConfigureNotify, cuz this is supposed
1429 to be like a ConfigureRequest. */
1430 client_reconfigure(client
, TRUE
);
1432 ob_debug_type(OB_DEBUG_APP_BUGS
,
1433 "_NET_RESTACK_WINDOW sent for window %s "
1434 "with invalid detail %d\n",
1435 client
->title
, e
->xclient
.data
.l
[2]);
1439 case PropertyNotify
:
1440 /* validate cuz we query stuff off the client here */
1441 if (!client_validate(client
)) break;
1443 /* compress changes to a single property into a single change */
1444 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1448 /* XXX: it would be nice to compress ALL changes to a property,
1449 not just changes in a row without other props between. */
1451 a
= ce
.xproperty
.atom
;
1452 b
= e
->xproperty
.atom
;
1456 if ((a
== prop_atoms
.net_wm_name
||
1457 a
== prop_atoms
.wm_name
||
1458 a
== prop_atoms
.net_wm_icon_name
||
1459 a
== prop_atoms
.wm_icon_name
)
1461 (b
== prop_atoms
.net_wm_name
||
1462 b
== prop_atoms
.wm_name
||
1463 b
== prop_atoms
.net_wm_icon_name
||
1464 b
== prop_atoms
.wm_icon_name
)) {
1467 if (a
== prop_atoms
.net_wm_icon
&&
1468 b
== prop_atoms
.net_wm_icon
)
1471 XPutBackEvent(ob_display
, &ce
);
1475 msgtype
= e
->xproperty
.atom
;
1476 if (msgtype
== XA_WM_NORMAL_HINTS
) {
1477 ob_debug("Update NORMAL hints\n");
1478 client_update_normal_hints(client
);
1479 /* normal hints can make a window non-resizable */
1480 client_setup_decor_and_functions(client
, FALSE
);
1482 /* make sure the client's sizes are within its bounds, but only
1483 reconfigure the window if it needs to. emacs will update its
1484 normal hints every time it receives a conigurenotify */
1485 client_reconfigure(client
, FALSE
);
1486 } else if (msgtype
== XA_WM_HINTS
) {
1487 client_update_wmhints(client
);
1488 } else if (msgtype
== XA_WM_TRANSIENT_FOR
) {
1489 client_update_transient_for(client
);
1490 client_get_type_and_transientness(client
);
1491 /* type may have changed, so update the layer */
1492 client_calc_layer(client
);
1493 client_setup_decor_and_functions(client
, TRUE
);
1494 } else if (msgtype
== prop_atoms
.net_wm_name
||
1495 msgtype
== prop_atoms
.wm_name
||
1496 msgtype
== prop_atoms
.net_wm_icon_name
||
1497 msgtype
== prop_atoms
.wm_icon_name
) {
1498 client_update_title(client
);
1499 } else if (msgtype
== prop_atoms
.wm_protocols
) {
1500 client_update_protocols(client
);
1501 client_setup_decor_and_functions(client
, TRUE
);
1503 else if (msgtype
== prop_atoms
.net_wm_strut
) {
1504 client_update_strut(client
);
1506 else if (msgtype
== prop_atoms
.net_wm_strut_partial
) {
1507 client_update_strut(client
);
1509 else if (msgtype
== prop_atoms
.net_wm_icon
) {
1510 client_update_icons(client
);
1512 else if (msgtype
== prop_atoms
.net_wm_icon_geometry
) {
1513 client_update_icon_geometry(client
);
1515 else if (msgtype
== prop_atoms
.net_wm_user_time
) {
1516 client_update_user_time(client
);
1518 else if (msgtype
== prop_atoms
.net_wm_user_time_window
) {
1519 client_update_user_time_window(client
);
1522 else if (msgtype
== prop_atoms
.net_wm_sync_request_counter
) {
1523 client_update_sync_request_counter(client
);
1527 case ColormapNotify
:
1528 client_update_colormap(client
, e
->xcolormap
.colormap
);
1533 if (extensions_shape
&& e
->type
== extensions_shape_event_basep
) {
1534 client
->shaped
= ((XShapeEvent
*)e
)->shaped
;
1535 frame_adjust_shape(client
->frame
);
1541 static void event_handle_dock(ObDock
*s
, XEvent
*e
)
1545 if (e
->xbutton
.button
== 1)
1546 stacking_raise(DOCK_AS_WINDOW(s
));
1547 else if (e
->xbutton
.button
== 2)
1548 stacking_lower(DOCK_AS_WINDOW(s
));
1554 /* don't hide when moving into a dock app */
1555 if (e
->xcrossing
.detail
!= NotifyInferior
)
1561 static void event_handle_dockapp(ObDockApp
*app
, XEvent
*e
)
1565 dock_app_drag(app
, &e
->xmotion
);
1568 if (app
->ignore_unmaps
) {
1569 app
->ignore_unmaps
--;
1572 dock_remove(app
, TRUE
);
1575 dock_remove(app
, FALSE
);
1577 case ReparentNotify
:
1578 dock_remove(app
, FALSE
);
1580 case ConfigureNotify
:
1581 dock_app_configure(app
, e
->xconfigure
.width
, e
->xconfigure
.height
);
1586 static ObMenuFrame
* find_active_menu()
1589 ObMenuFrame
*ret
= NULL
;
1591 for (it
= menu_frame_visible
; it
; it
= g_list_next(it
)) {
1600 static ObMenuFrame
* find_active_or_last_menu()
1602 ObMenuFrame
*ret
= NULL
;
1604 ret
= find_active_menu();
1605 if (!ret
&& menu_frame_visible
)
1606 ret
= menu_frame_visible
->data
;
1610 static gboolean
event_handle_menu_keyboard(XEvent
*ev
)
1612 guint keycode
, state
;
1615 gboolean ret
= TRUE
;
1617 keycode
= ev
->xkey
.keycode
;
1618 state
= ev
->xkey
.state
;
1619 unikey
= translate_unichar(keycode
);
1621 frame
= find_active_or_last_menu();
1625 else if (keycode
== ob_keycode(OB_KEY_ESCAPE
) && state
== 0)
1626 menu_frame_hide_all();
1628 else if (keycode
== ob_keycode(OB_KEY_RETURN
) && (state
== 0 ||
1629 state
== ControlMask
))
1631 /* Enter runs the active item or goes into the submenu.
1632 Control-Enter runs it without closing the menu. */
1634 menu_frame_select_next(frame
->child
);
1635 else if (frame
->selected
)
1636 menu_entry_frame_execute(frame
->selected
, state
, ev
->xkey
.time
);
1639 else if (keycode
== ob_keycode(OB_KEY_LEFT
) && ev
->xkey
.state
== 0) {
1640 /* Left goes to the parent menu */
1641 menu_frame_select(frame
, NULL
, TRUE
);
1644 else if (keycode
== ob_keycode(OB_KEY_RIGHT
) && ev
->xkey
.state
== 0) {
1645 /* Right goes to the selected submenu */
1646 if (frame
->child
) menu_frame_select_next(frame
->child
);
1649 else if (keycode
== ob_keycode(OB_KEY_UP
) && state
== 0) {
1650 menu_frame_select_previous(frame
);
1653 else if (keycode
== ob_keycode(OB_KEY_DOWN
) && state
== 0) {
1654 menu_frame_select_next(frame
);
1657 /* keyboard accelerator shortcuts. (allow controlmask) */
1658 else if ((ev
->xkey
.state
& ~ControlMask
) == 0 &&
1659 /* was it a valid key? */
1661 /* don't bother if the menu is empty. */
1666 ObMenuEntryFrame
*found
= NULL
;
1667 guint num_found
= 0;
1669 /* start after the selected one */
1670 start
= frame
->entries
;
1671 if (frame
->selected
) {
1672 for (it
= start
; frame
->selected
!= it
->data
; it
= g_list_next(it
))
1673 g_assert(it
!= NULL
); /* nothing was selected? */
1674 /* next with wraparound */
1675 start
= g_list_next(it
);
1676 if (start
== NULL
) start
= frame
->entries
;
1681 ObMenuEntryFrame
*e
= it
->data
;
1682 gunichar entrykey
= 0;
1684 if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
)
1685 entrykey
= e
->entry
->data
.normal
.shortcut
;
1686 else if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_SUBMENU
)
1687 entrykey
= e
->entry
->data
.submenu
.submenu
->shortcut
;
1689 if (unikey
== entrykey
) {
1690 if (found
== NULL
) found
= e
;
1694 /* next with wraparound */
1695 it
= g_list_next(it
);
1696 if (it
== NULL
) it
= frame
->entries
;
1697 } while (it
!= start
);
1700 if (found
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
&&
1703 menu_frame_select(frame
, found
, TRUE
);
1704 usleep(50000); /* highlight the item for a short bit so the
1705 user can see what happened */
1706 menu_entry_frame_execute(found
, state
, ev
->xkey
.time
);
1708 menu_frame_select(frame
, found
, TRUE
);
1710 menu_frame_select_next(frame
->child
);
1721 static gboolean
event_handle_menu(XEvent
*ev
)
1724 ObMenuEntryFrame
*e
;
1725 gboolean ret
= TRUE
;
1729 if (menu_hide_delay_reached() &&
1730 (ev
->xbutton
.button
< 4 || ev
->xbutton
.button
> 5))
1732 if ((e
= menu_entry_frame_under(ev
->xbutton
.x_root
,
1733 ev
->xbutton
.y_root
)))
1735 menu_frame_select(e
->frame
, e
, TRUE
);
1736 menu_entry_frame_execute(e
, ev
->xbutton
.state
,
1740 menu_frame_hide_all();
1744 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
))) {
1745 if (e
->ignore_enters
)
1747 else if (!(f
= find_active_menu()) ||
1749 f
->parent
== e
->frame
||
1750 f
->child
== e
->frame
)
1751 menu_frame_select(e
->frame
, e
, FALSE
);
1755 /*ignore leaves when we're already in the window */
1756 if (ev
->xcrossing
.detail
== NotifyInferior
)
1759 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
)) &&
1760 (f
= find_active_menu()) && f
->selected
== e
&&
1761 e
->entry
->type
!= OB_MENU_ENTRY_TYPE_SUBMENU
)
1763 menu_frame_select(e
->frame
, NULL
, FALSE
);
1767 if ((e
= menu_entry_frame_under(ev
->xmotion
.x_root
,
1768 ev
->xmotion
.y_root
)))
1769 if (!(f
= find_active_menu()) ||
1771 f
->parent
== e
->frame
||
1772 f
->child
== e
->frame
)
1773 menu_frame_select(e
->frame
, e
, FALSE
);
1776 ret
= event_handle_menu_keyboard(ev
);
1782 static void event_handle_user_input(ObClient
*client
, XEvent
*e
)
1784 g_assert(e
->type
== ButtonPress
|| e
->type
== ButtonRelease
||
1785 e
->type
== MotionNotify
|| e
->type
== KeyPress
||
1786 e
->type
== KeyRelease
);
1788 if (menu_frame_visible
) {
1789 if (event_handle_menu(e
))
1790 /* don't use the event if the menu used it, but if the menu
1791 didn't use it and it's a keypress that is bound, it will
1792 close the menu and be used */
1796 /* if the keyboard interactive action uses the event then dont
1797 use it for bindings. likewise is moveresize uses the event. */
1798 if (!keyboard_process_interactive_grab(e
, &client
) &&
1799 !(moveresize_in_progress
&& moveresize_event(e
)))
1801 if (moveresize_in_progress
)
1802 /* make further actions work on the client being
1804 client
= moveresize_client
;
1806 if (e
->type
== ButtonPress
||
1807 e
->type
== ButtonRelease
||
1808 e
->type
== MotionNotify
)
1810 /* the frame may not be "visible" but they can still click on it
1811 in the case where it is animating before disappearing */
1812 if (!client
|| !frame_iconify_animating(client
->frame
))
1813 mouse_event(client
, e
);
1815 keyboard_event((focus_cycle_target
? focus_cycle_target
:
1816 (client
? client
: focus_client
)), e
);
1820 static void focus_delay_dest(gpointer data
)
1825 static gboolean
focus_delay_cmp(gconstpointer d1
, gconstpointer d2
)
1827 const ObFocusDelayData
*f1
= d1
;
1828 return f1
->client
== d2
;
1831 static gboolean
focus_delay_func(gpointer data
)
1833 ObFocusDelayData
*d
= data
;
1834 Time old
= event_curtime
;
1836 event_curtime
= d
->time
;
1837 if (focus_client
!= d
->client
) {
1838 if (client_focus(d
->client
) && config_focus_raise
)
1839 stacking_raise(CLIENT_AS_WINDOW(d
->client
));
1841 event_curtime
= old
;
1842 return FALSE
; /* no repeat */
1845 static void focus_delay_client_dest(ObClient
*client
, gpointer data
)
1847 ob_main_loop_timeout_remove_data(ob_main_loop
, focus_delay_func
,
1851 void event_halt_focus_delay()
1853 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
1856 gulong
event_start_ignore_all_enters()
1858 XSync(ob_display
, FALSE
);
1859 return LastKnownRequestProcessed(ob_display
);
1862 void event_end_ignore_all_enters(gulong start
)
1866 g_assert(start
!= 0);
1867 XSync(ob_display
, FALSE
);
1869 r
= g_new(ObSerialRange
, 1);
1871 r
->end
= LastKnownRequestProcessed(ob_display
);
1872 ignore_serials
= g_slist_prepend(ignore_serials
, r
);
1874 /* increment the serial so we don't ignore events we weren't meant to */
1875 XSync(ob_display
, FALSE
);
1878 static gboolean
is_enter_focus_event_ignored(XEvent
*e
)
1882 g_assert(e
->type
== EnterNotify
&&
1883 !(e
->xcrossing
.mode
== NotifyGrab
||
1884 e
->xcrossing
.mode
== NotifyUngrab
||
1885 e
->xcrossing
.detail
== NotifyInferior
));
1887 for (it
= ignore_serials
; it
; it
= next
) {
1888 ObSerialRange
*r
= it
->data
;
1890 next
= g_slist_next(it
);
1892 if ((glong
)(e
->xany
.serial
- r
->end
) > 0) {
1894 ignore_serials
= g_slist_delete_link(ignore_serials
, it
);
1897 else if ((glong
)(e
->xany
.serial
- r
->start
) >= 0)
1903 void event_cancel_all_key_grabs()
1905 if (keyboard_interactively_grabbed()) {
1906 keyboard_interactive_cancel();
1907 ob_debug("KILLED interactive event\n");
1909 else if (menu_frame_visible
) {
1910 menu_frame_hide_all();
1911 ob_debug("KILLED open menus\n");
1913 else if (grab_on_keyboard()) {
1915 ob_debug("KILLED active grab on keyboard\n");
1918 ungrab_passive_key();
1921 gboolean
event_time_after(Time t1
, Time t2
)
1923 g_assert(t1
!= CurrentTime
);
1924 g_assert(t2
!= CurrentTime
);
1927 Timestamp values wrap around (after about 49.7 days). The server, given
1928 its current time is represented by timestamp T, always interprets
1929 timestamps from clients by treating half of the timestamp space as being
1930 later in time than T.
1931 - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
1934 /* TIME_HALF is half of the number space of a Time type variable */
1935 #define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
1937 if (t2
>= TIME_HALF
)
1938 /* t2 is in the second half so t1 might wrap around and be smaller than
1940 return t1
>= t2
|| t1
< (t2
+ TIME_HALF
);
1942 /* t2 is in the first half so t1 has to come after it */
1943 return t1
>= t2
&& t1
< (t2
+ TIME_HALF
);