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
, FALSE
);
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
, FALSE
);
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
, FALSE
);
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 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 screen_update_desktop_names();
735 else if (e
->xproperty
.atom
== prop_atoms
.net_desktop_layout
)
736 screen_update_layout();
738 case ConfigureNotify
:
740 XRRUpdateConfiguration(e
);
749 void event_enter_client(ObClient
*client
)
751 g_assert(config_focus_follow
);
753 if (client_enter_focusable(client
) && client_can_focus(client
)) {
754 if (config_focus_delay
) {
755 ObFocusDelayData
*data
;
757 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
759 data
= g_new(ObFocusDelayData
, 1);
760 data
->client
= client
;
761 data
->time
= event_curtime
;
763 ob_main_loop_timeout_add(ob_main_loop
,
766 data
, focus_delay_cmp
, focus_delay_dest
);
768 ObFocusDelayData data
;
769 data
.client
= client
;
770 data
.time
= event_curtime
;
771 focus_delay_func(&data
);
776 static void event_handle_user_time_window_clients(GSList
*l
, XEvent
*e
)
778 g_assert(e
->type
== PropertyNotify
);
779 if (e
->xproperty
.atom
== prop_atoms
.net_wm_user_time
) {
780 for (; l
; l
= g_slist_next(l
))
781 client_update_user_time(l
->data
);
785 static void event_handle_client(ObClient
*client
, XEvent
*e
)
790 static gint px
= -1, py
= -1;
795 /* save where the press occured for the first button pressed */
797 pb
= e
->xbutton
.button
;
802 /* Wheel buttons don't draw because they are an instant click, so it
803 is a waste of resources to go drawing it.
804 if the user is doing an intereactive thing, or has a menu open then
805 the mouse is grabbed (possibly) and if we get these events we don't
806 want to deal with them
808 if (!(e
->xbutton
.button
== 4 || e
->xbutton
.button
== 5) &&
809 !keyboard_interactively_grabbed() &&
812 /* use where the press occured */
813 con
= frame_context(client
, e
->xbutton
.window
, px
, py
);
814 con
= mouse_button_frame_context(con
, e
->xbutton
.button
,
817 if (e
->type
== ButtonRelease
&& e
->xbutton
.button
== pb
)
818 pb
= 0, px
= py
= -1;
821 case OB_FRAME_CONTEXT_MAXIMIZE
:
822 client
->frame
->max_press
= (e
->type
== ButtonPress
);
823 framerender_frame(client
->frame
);
825 case OB_FRAME_CONTEXT_CLOSE
:
826 client
->frame
->close_press
= (e
->type
== ButtonPress
);
827 framerender_frame(client
->frame
);
829 case OB_FRAME_CONTEXT_ICONIFY
:
830 client
->frame
->iconify_press
= (e
->type
== ButtonPress
);
831 framerender_frame(client
->frame
);
833 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
834 client
->frame
->desk_press
= (e
->type
== ButtonPress
);
835 framerender_frame(client
->frame
);
837 case OB_FRAME_CONTEXT_SHADE
:
838 client
->frame
->shade_press
= (e
->type
== ButtonPress
);
839 framerender_frame(client
->frame
);
842 /* nothing changes with clicks for any other contexts */
848 /* when there is a grab on the pointer, we won't get enter/leave
849 notifies, but we still get motion events */
850 if (grab_on_pointer()) break;
852 con
= frame_context(client
, e
->xmotion
.window
,
853 e
->xmotion
.x
, e
->xmotion
.y
);
855 case OB_FRAME_CONTEXT_TITLEBAR
:
856 case OB_FRAME_CONTEXT_TLCORNER
:
857 case OB_FRAME_CONTEXT_TRCORNER
:
858 /* we've left the button area inside the titlebar */
859 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
860 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
861 client
->frame
->close_hover
)
863 client
->frame
->max_hover
= FALSE
;
864 client
->frame
->desk_hover
= FALSE
;
865 client
->frame
->shade_hover
= FALSE
;
866 client
->frame
->iconify_hover
= FALSE
;
867 client
->frame
->close_hover
= FALSE
;
868 frame_adjust_state(client
->frame
);
871 case OB_FRAME_CONTEXT_MAXIMIZE
:
872 if (!client
->frame
->max_hover
) {
873 client
->frame
->max_hover
= TRUE
;
874 frame_adjust_state(client
->frame
);
877 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
878 if (!client
->frame
->desk_hover
) {
879 client
->frame
->desk_hover
= TRUE
;
880 frame_adjust_state(client
->frame
);
883 case OB_FRAME_CONTEXT_SHADE
:
884 if (!client
->frame
->shade_hover
) {
885 client
->frame
->shade_hover
= TRUE
;
886 frame_adjust_state(client
->frame
);
889 case OB_FRAME_CONTEXT_ICONIFY
:
890 if (!client
->frame
->iconify_hover
) {
891 client
->frame
->iconify_hover
= TRUE
;
892 frame_adjust_state(client
->frame
);
895 case OB_FRAME_CONTEXT_CLOSE
:
896 if (!client
->frame
->close_hover
) {
897 client
->frame
->close_hover
= TRUE
;
898 frame_adjust_state(client
->frame
);
906 con
= frame_context(client
, e
->xcrossing
.window
,
907 e
->xcrossing
.x
, e
->xcrossing
.y
);
909 case OB_FRAME_CONTEXT_TITLEBAR
:
910 case OB_FRAME_CONTEXT_TLCORNER
:
911 case OB_FRAME_CONTEXT_TRCORNER
:
912 /* we've left the button area inside the titlebar */
913 if (client
->frame
->max_hover
|| client
->frame
->desk_hover
||
914 client
->frame
->shade_hover
|| client
->frame
->iconify_hover
||
915 client
->frame
->close_hover
)
917 client
->frame
->max_hover
= FALSE
;
918 client
->frame
->desk_hover
= FALSE
;
919 client
->frame
->shade_hover
= FALSE
;
920 client
->frame
->iconify_hover
= FALSE
;
921 client
->frame
->close_hover
= FALSE
;
922 frame_adjust_state(client
->frame
);
925 case OB_FRAME_CONTEXT_MAXIMIZE
:
926 client
->frame
->max_hover
= FALSE
;
927 frame_adjust_state(client
->frame
);
929 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
930 client
->frame
->desk_hover
= FALSE
;
931 frame_adjust_state(client
->frame
);
933 case OB_FRAME_CONTEXT_SHADE
:
934 client
->frame
->shade_hover
= FALSE
;
935 frame_adjust_state(client
->frame
);
937 case OB_FRAME_CONTEXT_ICONIFY
:
938 client
->frame
->iconify_hover
= FALSE
;
939 frame_adjust_state(client
->frame
);
941 case OB_FRAME_CONTEXT_CLOSE
:
942 client
->frame
->close_hover
= FALSE
;
943 frame_adjust_state(client
->frame
);
945 case OB_FRAME_CONTEXT_FRAME
:
946 /* When the mouse leaves an animating window, don't use the
947 corresponding enter events. Pretend like the animating window
948 doesn't even exist..! */
949 if (frame_iconify_animating(client
->frame
))
950 event_end_ignore_all_enters(event_start_ignore_all_enters());
952 ob_debug_type(OB_DEBUG_FOCUS
,
953 "%sNotify mode %d detail %d on %lx\n",
954 (e
->type
== EnterNotify
? "Enter" : "Leave"),
956 e
->xcrossing
.detail
, (client
?client
->window
:0));
957 if (keyboard_interactively_grabbed())
959 if (config_focus_follow
&& config_focus_delay
&&
960 /* leave inferior events can happen when the mouse goes onto
961 the window's border and then into the window before the
963 e
->xcrossing
.detail
!= NotifyInferior
)
965 ob_main_loop_timeout_remove_data(ob_main_loop
,
976 con
= frame_context(client
, e
->xcrossing
.window
,
977 e
->xcrossing
.x
, e
->xcrossing
.y
);
979 case OB_FRAME_CONTEXT_MAXIMIZE
:
980 client
->frame
->max_hover
= TRUE
;
981 frame_adjust_state(client
->frame
);
983 case OB_FRAME_CONTEXT_ALLDESKTOPS
:
984 client
->frame
->desk_hover
= TRUE
;
985 frame_adjust_state(client
->frame
);
987 case OB_FRAME_CONTEXT_SHADE
:
988 client
->frame
->shade_hover
= TRUE
;
989 frame_adjust_state(client
->frame
);
991 case OB_FRAME_CONTEXT_ICONIFY
:
992 client
->frame
->iconify_hover
= TRUE
;
993 frame_adjust_state(client
->frame
);
995 case OB_FRAME_CONTEXT_CLOSE
:
996 client
->frame
->close_hover
= TRUE
;
997 frame_adjust_state(client
->frame
);
999 case OB_FRAME_CONTEXT_FRAME
:
1000 if (keyboard_interactively_grabbed())
1002 if (e
->xcrossing
.mode
== NotifyGrab
||
1003 e
->xcrossing
.mode
== NotifyUngrab
||
1004 /*ignore enters when we're already in the window */
1005 e
->xcrossing
.detail
== NotifyInferior
||
1006 is_enter_focus_event_ignored(e
))
1008 ob_debug_type(OB_DEBUG_FOCUS
,
1009 "%sNotify mode %d detail %d on %lx IGNORED\n",
1010 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1012 e
->xcrossing
.detail
, client
?client
->window
:0);
1015 ob_debug_type(OB_DEBUG_FOCUS
,
1016 "%sNotify mode %d detail %d on %lx, "
1017 "focusing window\n",
1018 (e
->type
== EnterNotify
? "Enter" : "Leave"),
1020 e
->xcrossing
.detail
, (client
?client
->window
:0));
1021 if (config_focus_follow
)
1022 event_enter_client(client
);
1030 case ConfigureRequest
:
1032 /* dont compress these unless you're going to watch for property
1033 notifies in between (these can change what the configure would
1035 also you can't compress stacking events
1039 gboolean move
= FALSE
;
1040 gboolean resize
= FALSE
;
1042 /* get the current area */
1043 RECT_TO_DIMS(client
->area
, x
, y
, w
, h
);
1045 ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1047 " x %d y %d w %d h %d b %d\n",
1049 screen_desktop
, client
->wmstate
, client
->frame
->visible
,
1050 x
, y
, w
, h
, client
->border_width
);
1052 if (e
->xconfigurerequest
.value_mask
& CWBorderWidth
)
1053 if (client
->border_width
!= e
->xconfigurerequest
.border_width
) {
1054 client
->border_width
= e
->xconfigurerequest
.border_width
;
1056 /* if the border width is changing then that is the same
1057 as requesting a resize, but we don't actually change
1058 the client's border, so it will change their root
1059 coordiantes (since they include the border width) and
1060 we need to a notify then */
1065 if (e
->xconfigurerequest
.value_mask
& CWStackMode
) {
1066 ObClient
*sibling
= NULL
;
1068 /* get the sibling */
1069 if (e
->xconfigurerequest
.value_mask
& CWSibling
) {
1071 win
= g_hash_table_lookup(window_map
,
1072 &e
->xconfigurerequest
.above
);
1073 if (WINDOW_IS_CLIENT(win
) && WINDOW_AS_CLIENT(win
) != client
)
1074 sibling
= WINDOW_AS_CLIENT(win
);
1077 /* activate it rather than just focus it */
1078 stacking_restack_request(client
, sibling
,
1079 e
->xconfigurerequest
.detail
,
1082 /* if a stacking change moves the window without resizing */
1086 if ((e
->xconfigurerequest
.value_mask
& CWX
) ||
1087 (e
->xconfigurerequest
.value_mask
& CWY
) ||
1088 (e
->xconfigurerequest
.value_mask
& CWWidth
) ||
1089 (e
->xconfigurerequest
.value_mask
& CWHeight
))
1091 if (e
->xconfigurerequest
.value_mask
& CWX
) {
1092 /* don't allow clients to move shaded windows (fvwm does this)
1094 if (!client
->shaded
)
1095 x
= e
->xconfigurerequest
.x
;
1098 if (e
->xconfigurerequest
.value_mask
& CWY
) {
1099 /* don't allow clients to move shaded windows (fvwm does this)
1101 if (!client
->shaded
)
1102 y
= e
->xconfigurerequest
.y
;
1106 if (e
->xconfigurerequest
.value_mask
& CWWidth
) {
1107 w
= e
->xconfigurerequest
.width
;
1110 if (e
->xconfigurerequest
.value_mask
& CWHeight
) {
1111 h
= e
->xconfigurerequest
.height
;
1116 ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1117 "move %d resize %d\n",
1118 e
->xconfigurerequest
.value_mask
& CWX
, x
,
1119 e
->xconfigurerequest
.value_mask
& CWY
, y
,
1120 e
->xconfigurerequest
.value_mask
& CWWidth
, w
,
1121 e
->xconfigurerequest
.value_mask
& CWHeight
, h
,
1124 /* check for broken apps moving to their root position
1126 XXX remove this some day...that would be nice. right now all
1127 kde apps do this when they try activate themselves on another
1128 desktop. eg. open amarok window on desktop 1, switch to desktop
1129 2, click amarok tray icon. it will move by its decoration size.
1131 if (x
!= client
->area
.x
&&
1132 x
== (client
->frame
->area
.x
+ client
->frame
->size
.left
-
1133 (gint
)client
->border_width
) &&
1134 y
!= client
->area
.y
&&
1135 y
== (client
->frame
->area
.y
+ client
->frame
->size
.top
-
1136 (gint
)client
->border_width
) &&
1137 w
== client
->area
.width
&&
1138 h
== client
->area
.height
)
1140 ob_debug_type(OB_DEBUG_APP_BUGS
,
1141 "Application %s is trying to move via "
1142 "ConfigureRequest to it's root window position "
1143 "but it is not using StaticGravity\n",
1149 /* they still requested a move, so don't change whether a
1150 notify is sent or not */
1153 if (move
|| resize
) {
1156 client_try_configure(client
, &x
, &y
, &w
, &h
, &lw
, &lh
, FALSE
);
1158 /* if x was not given, then use gravity to figure out the new
1159 x. the reference point should not be moved */
1160 if ((e
->xconfigurerequest
.value_mask
& CWWidth
&&
1161 !(e
->xconfigurerequest
.value_mask
& CWX
)))
1162 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1163 /* if y was not given, then use gravity to figure out the new
1164 y. the reference point should not be moved */
1165 if ((e
->xconfigurerequest
.value_mask
& CWHeight
&&
1166 !(e
->xconfigurerequest
.value_mask
& CWY
)))
1167 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1169 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1171 /* if they requested something that moves the window, or if
1172 the window is actually being changed then configure it and
1173 send a configure notify to them */
1174 if (move
|| !RECT_EQUAL_DIMS(client
->area
, x
, y
, w
, h
)) {
1175 gulong ignore_start
;
1177 ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
1179 ignore_start
= event_start_ignore_all_enters();
1180 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
);
1181 event_end_ignore_all_enters(ignore_start
);
1187 if (client
->ignore_unmaps
) {
1188 client
->ignore_unmaps
--;
1191 ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1192 "ignores left %d\n",
1193 client
->window
, e
->xunmap
.event
, e
->xunmap
.from_configure
,
1194 client
->ignore_unmaps
);
1195 client_unmanage(client
);
1198 ob_debug("DestroyNotify for window 0x%x\n", client
->window
);
1199 client_unmanage(client
);
1201 case ReparentNotify
:
1202 /* this is when the client is first taken captive in the frame */
1203 if (e
->xreparent
.parent
== client
->frame
->window
) break;
1206 This event is quite rare and is usually handled in unmapHandler.
1207 However, if the window is unmapped when the reparent event occurs,
1208 the window manager never sees it because an unmap event is not sent
1209 to an already unmapped window.
1212 /* we don't want the reparent event, put it back on the stack for the
1213 X server to deal with after we unmanage the window */
1214 XPutBackEvent(ob_display
, e
);
1216 ob_debug("ReparentNotify for window 0x%x\n", client
->window
);
1217 client_unmanage(client
);
1220 ob_debug("MapRequest for 0x%lx\n", client
->window
);
1221 if (!client
->iconic
) break; /* this normally doesn't happen, but if it
1222 does, we don't want it!
1223 it can happen now when the window is on
1224 another desktop, but we still don't
1226 client_activate(client
, FALSE
, TRUE
);
1229 /* validate cuz we query stuff off the client here */
1230 if (!client_validate(client
)) break;
1232 if (e
->xclient
.format
!= 32) return;
1234 msgtype
= e
->xclient
.message_type
;
1235 if (msgtype
== prop_atoms
.wm_change_state
) {
1236 /* compress changes into a single change */
1237 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1239 /* XXX: it would be nice to compress ALL messages of a
1240 type, not just messages in a row without other
1241 message types between. */
1242 if (ce
.xclient
.message_type
!= msgtype
) {
1243 XPutBackEvent(ob_display
, &ce
);
1246 e
->xclient
= ce
.xclient
;
1248 client_set_wm_state(client
, e
->xclient
.data
.l
[0]);
1249 } else if (msgtype
== prop_atoms
.net_wm_desktop
) {
1250 /* compress changes into a single change */
1251 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1253 /* XXX: it would be nice to compress ALL messages of a
1254 type, not just messages in a row without other
1255 message types between. */
1256 if (ce
.xclient
.message_type
!= msgtype
) {
1257 XPutBackEvent(ob_display
, &ce
);
1260 e
->xclient
= ce
.xclient
;
1262 if ((unsigned)e
->xclient
.data
.l
[0] < screen_num_desktops
||
1263 (unsigned)e
->xclient
.data
.l
[0] == DESKTOP_ALL
)
1264 client_set_desktop(client
, (unsigned)e
->xclient
.data
.l
[0],
1266 } else if (msgtype
== prop_atoms
.net_wm_state
) {
1267 gulong ignore_start
;
1269 /* can't compress these */
1270 ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
1271 (e
->xclient
.data
.l
[0] == 0 ? "Remove" :
1272 e
->xclient
.data
.l
[0] == 1 ? "Add" :
1273 e
->xclient
.data
.l
[0] == 2 ? "Toggle" : "INVALID"),
1274 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2],
1277 /* ignore enter events caused by these like ob actions do */
1278 if (!config_focus_under_mouse
)
1279 ignore_start
= event_start_ignore_all_enters();
1280 client_set_state(client
, e
->xclient
.data
.l
[0],
1281 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[2]);
1282 if (!config_focus_under_mouse
)
1283 event_end_ignore_all_enters(ignore_start
);
1284 } else if (msgtype
== prop_atoms
.net_close_window
) {
1285 ob_debug("net_close_window for 0x%lx\n", client
->window
);
1286 client_close(client
);
1287 } else if (msgtype
== prop_atoms
.net_active_window
) {
1288 ob_debug("net_active_window for 0x%lx source=%s\n",
1290 (e
->xclient
.data
.l
[0] == 0 ? "unknown" :
1291 (e
->xclient
.data
.l
[0] == 1 ? "application" :
1292 (e
->xclient
.data
.l
[0] == 2 ? "user" : "INVALID"))));
1293 /* XXX make use of data.l[2] !? */
1294 if (e
->xclient
.data
.l
[0] == 1 || e
->xclient
.data
.l
[0] == 2) {
1295 event_curtime
= e
->xclient
.data
.l
[1];
1296 if (event_curtime
== 0)
1297 ob_debug_type(OB_DEBUG_APP_BUGS
,
1298 "_NET_ACTIVE_WINDOW message for window %s is"
1299 " missing a timestamp\n", client
->title
);
1301 ob_debug_type(OB_DEBUG_APP_BUGS
,
1302 "_NET_ACTIVE_WINDOW message for window %s is "
1303 "missing source indication\n");
1304 client_activate(client
, FALSE
,
1305 (e
->xclient
.data
.l
[0] == 0 ||
1306 e
->xclient
.data
.l
[0] == 2));
1307 } else if (msgtype
== prop_atoms
.net_wm_moveresize
) {
1308 ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
1309 client
->window
, e
->xclient
.data
.l
[2]);
1310 if ((Atom
)e
->xclient
.data
.l
[2] ==
1311 prop_atoms
.net_wm_moveresize_size_topleft
||
1312 (Atom
)e
->xclient
.data
.l
[2] ==
1313 prop_atoms
.net_wm_moveresize_size_top
||
1314 (Atom
)e
->xclient
.data
.l
[2] ==
1315 prop_atoms
.net_wm_moveresize_size_topright
||
1316 (Atom
)e
->xclient
.data
.l
[2] ==
1317 prop_atoms
.net_wm_moveresize_size_right
||
1318 (Atom
)e
->xclient
.data
.l
[2] ==
1319 prop_atoms
.net_wm_moveresize_size_right
||
1320 (Atom
)e
->xclient
.data
.l
[2] ==
1321 prop_atoms
.net_wm_moveresize_size_bottomright
||
1322 (Atom
)e
->xclient
.data
.l
[2] ==
1323 prop_atoms
.net_wm_moveresize_size_bottom
||
1324 (Atom
)e
->xclient
.data
.l
[2] ==
1325 prop_atoms
.net_wm_moveresize_size_bottomleft
||
1326 (Atom
)e
->xclient
.data
.l
[2] ==
1327 prop_atoms
.net_wm_moveresize_size_left
||
1328 (Atom
)e
->xclient
.data
.l
[2] ==
1329 prop_atoms
.net_wm_moveresize_move
||
1330 (Atom
)e
->xclient
.data
.l
[2] ==
1331 prop_atoms
.net_wm_moveresize_size_keyboard
||
1332 (Atom
)e
->xclient
.data
.l
[2] ==
1333 prop_atoms
.net_wm_moveresize_move_keyboard
) {
1335 moveresize_start(client
, e
->xclient
.data
.l
[0],
1336 e
->xclient
.data
.l
[1], e
->xclient
.data
.l
[3],
1337 e
->xclient
.data
.l
[2]);
1339 else if ((Atom
)e
->xclient
.data
.l
[2] ==
1340 prop_atoms
.net_wm_moveresize_cancel
)
1341 moveresize_end(TRUE
);
1342 } else if (msgtype
== prop_atoms
.net_moveresize_window
) {
1343 gint ograv
, x
, y
, w
, h
;
1344 gulong ignore_start
;
1346 ograv
= client
->gravity
;
1348 if (e
->xclient
.data
.l
[0] & 0xff)
1349 client
->gravity
= e
->xclient
.data
.l
[0] & 0xff;
1351 if (e
->xclient
.data
.l
[0] & 1 << 8)
1352 x
= e
->xclient
.data
.l
[1];
1355 if (e
->xclient
.data
.l
[0] & 1 << 9)
1356 y
= e
->xclient
.data
.l
[2];
1360 if (e
->xclient
.data
.l
[0] & 1 << 10) {
1361 w
= e
->xclient
.data
.l
[3];
1363 /* if x was not given, then use gravity to figure out the new
1364 x. the reference point should not be moved */
1365 if (!(e
->xclient
.data
.l
[0] & 1 << 8))
1366 client_gravity_resize_w(client
, &x
, client
->area
.width
, w
);
1369 w
= client
->area
.width
;
1371 if (e
->xclient
.data
.l
[0] & 1 << 11) {
1372 h
= e
->xclient
.data
.l
[4];
1374 /* if y was not given, then use gravity to figure out the new
1375 y. the reference point should not be moved */
1376 if (!(e
->xclient
.data
.l
[0] & 1 << 9))
1377 client_gravity_resize_h(client
, &y
, client
->area
.height
,h
);
1380 h
= client
->area
.height
;
1382 ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
1383 e
->xclient
.data
.l
[0] & 1 << 8, x
,
1384 e
->xclient
.data
.l
[0] & 1 << 9, y
,
1387 client_find_onscreen(client
, &x
, &y
, w
, h
, FALSE
);
1389 /* ignore enter events caused by these like ob actions do */
1390 ignore_start
= event_start_ignore_all_enters();
1391 client_configure(client
, x
, y
, w
, h
, FALSE
, TRUE
);
1392 event_end_ignore_all_enters(ignore_start
);
1394 client
->gravity
= ograv
;
1395 } else if (msgtype
== prop_atoms
.net_restack_window
) {
1396 if (e
->xclient
.data
.l
[0] != 2) {
1397 ob_debug_type(OB_DEBUG_APP_BUGS
,
1398 "_NET_RESTACK_WINDOW sent for window %s with "
1399 "invalid source indication %ld\n",
1400 client
->title
, e
->xclient
.data
.l
[0]);
1402 ObClient
*sibling
= NULL
;
1403 if (e
->xclient
.data
.l
[1]) {
1404 ObWindow
*win
= g_hash_table_lookup
1405 (window_map
, &e
->xclient
.data
.l
[1]);
1406 if (WINDOW_IS_CLIENT(win
) &&
1407 WINDOW_AS_CLIENT(win
) != client
)
1409 sibling
= WINDOW_AS_CLIENT(win
);
1411 if (sibling
== NULL
)
1412 ob_debug_type(OB_DEBUG_APP_BUGS
,
1413 "_NET_RESTACK_WINDOW sent for window %s "
1414 "with invalid sibling 0x%x\n",
1415 client
->title
, e
->xclient
.data
.l
[1]);
1417 if (e
->xclient
.data
.l
[2] == Below
||
1418 e
->xclient
.data
.l
[2] == BottomIf
||
1419 e
->xclient
.data
.l
[2] == Above
||
1420 e
->xclient
.data
.l
[2] == TopIf
||
1421 e
->xclient
.data
.l
[2] == Opposite
)
1423 /* just raise, don't activate */
1424 stacking_restack_request(client
, sibling
,
1425 e
->xclient
.data
.l
[2], FALSE
);
1426 /* send a synthetic ConfigureNotify, cuz this is supposed
1427 to be like a ConfigureRequest. */
1428 client_reconfigure(client
);
1430 ob_debug_type(OB_DEBUG_APP_BUGS
,
1431 "_NET_RESTACK_WINDOW sent for window %s "
1432 "with invalid detail %d\n",
1433 client
->title
, e
->xclient
.data
.l
[2]);
1437 case PropertyNotify
:
1438 /* validate cuz we query stuff off the client here */
1439 if (!client_validate(client
)) break;
1441 /* compress changes to a single property into a single change */
1442 while (XCheckTypedWindowEvent(ob_display
, client
->window
,
1446 /* XXX: it would be nice to compress ALL changes to a property,
1447 not just changes in a row without other props between. */
1449 a
= ce
.xproperty
.atom
;
1450 b
= e
->xproperty
.atom
;
1454 if ((a
== prop_atoms
.net_wm_name
||
1455 a
== prop_atoms
.wm_name
||
1456 a
== prop_atoms
.net_wm_icon_name
||
1457 a
== prop_atoms
.wm_icon_name
)
1459 (b
== prop_atoms
.net_wm_name
||
1460 b
== prop_atoms
.wm_name
||
1461 b
== prop_atoms
.net_wm_icon_name
||
1462 b
== prop_atoms
.wm_icon_name
)) {
1465 if (a
== prop_atoms
.net_wm_icon
&&
1466 b
== prop_atoms
.net_wm_icon
)
1469 XPutBackEvent(ob_display
, &ce
);
1473 msgtype
= e
->xproperty
.atom
;
1474 if (msgtype
== XA_WM_NORMAL_HINTS
) {
1475 client_update_normal_hints(client
);
1476 /* normal hints can make a window non-resizable */
1477 client_setup_decor_and_functions(client
, TRUE
);
1478 } else if (msgtype
== XA_WM_HINTS
) {
1479 client_update_wmhints(client
);
1480 } else if (msgtype
== XA_WM_TRANSIENT_FOR
) {
1481 client_update_transient_for(client
);
1482 client_get_type_and_transientness(client
);
1483 /* type may have changed, so update the layer */
1484 client_calc_layer(client
);
1485 client_setup_decor_and_functions(client
, TRUE
);
1486 } else if (msgtype
== prop_atoms
.net_wm_name
||
1487 msgtype
== prop_atoms
.wm_name
||
1488 msgtype
== prop_atoms
.net_wm_icon_name
||
1489 msgtype
== prop_atoms
.wm_icon_name
) {
1490 client_update_title(client
);
1491 } else if (msgtype
== prop_atoms
.wm_protocols
) {
1492 client_update_protocols(client
);
1493 client_setup_decor_and_functions(client
, TRUE
);
1495 else if (msgtype
== prop_atoms
.net_wm_strut
) {
1496 client_update_strut(client
);
1498 else if (msgtype
== prop_atoms
.net_wm_strut_partial
) {
1499 client_update_strut(client
);
1501 else if (msgtype
== prop_atoms
.net_wm_icon
) {
1502 client_update_icons(client
);
1504 else if (msgtype
== prop_atoms
.net_wm_icon_geometry
) {
1505 client_update_icon_geometry(client
);
1507 else if (msgtype
== prop_atoms
.net_wm_user_time
) {
1508 client_update_user_time(client
);
1510 else if (msgtype
== prop_atoms
.net_wm_user_time_window
) {
1511 client_update_user_time_window(client
);
1514 else if (msgtype
== prop_atoms
.net_wm_sync_request_counter
) {
1515 client_update_sync_request_counter(client
);
1519 case ColormapNotify
:
1520 client_update_colormap(client
, e
->xcolormap
.colormap
);
1525 if (extensions_shape
&& e
->type
== extensions_shape_event_basep
) {
1526 client
->shaped
= ((XShapeEvent
*)e
)->shaped
;
1527 frame_adjust_shape(client
->frame
);
1533 static void event_handle_dock(ObDock
*s
, XEvent
*e
)
1537 if (e
->xbutton
.button
== 1)
1538 stacking_raise(DOCK_AS_WINDOW(s
));
1539 else if (e
->xbutton
.button
== 2)
1540 stacking_lower(DOCK_AS_WINDOW(s
));
1546 /* don't hide when moving into a dock app */
1547 if (e
->xcrossing
.detail
!= NotifyInferior
)
1553 static void event_handle_dockapp(ObDockApp
*app
, XEvent
*e
)
1557 dock_app_drag(app
, &e
->xmotion
);
1560 if (app
->ignore_unmaps
) {
1561 app
->ignore_unmaps
--;
1564 dock_remove(app
, TRUE
);
1567 dock_remove(app
, FALSE
);
1569 case ReparentNotify
:
1570 dock_remove(app
, FALSE
);
1572 case ConfigureNotify
:
1573 dock_app_configure(app
, e
->xconfigure
.width
, e
->xconfigure
.height
);
1578 static ObMenuFrame
* find_active_menu()
1581 ObMenuFrame
*ret
= NULL
;
1583 for (it
= menu_frame_visible
; it
; it
= g_list_next(it
)) {
1592 static ObMenuFrame
* find_active_or_last_menu()
1594 ObMenuFrame
*ret
= NULL
;
1596 ret
= find_active_menu();
1597 if (!ret
&& menu_frame_visible
)
1598 ret
= menu_frame_visible
->data
;
1602 static gboolean
event_handle_menu_keyboard(XEvent
*ev
)
1604 guint keycode
, state
;
1607 gboolean ret
= TRUE
;
1609 keycode
= ev
->xkey
.keycode
;
1610 state
= ev
->xkey
.state
;
1611 unikey
= translate_unichar(keycode
);
1613 frame
= find_active_or_last_menu();
1617 else if (keycode
== ob_keycode(OB_KEY_ESCAPE
) && state
== 0)
1618 menu_frame_hide_all();
1620 else if (keycode
== ob_keycode(OB_KEY_RETURN
) && (state
== 0 ||
1621 state
== ControlMask
))
1623 /* Enter runs the active item or goes into the submenu.
1624 Control-Enter runs it without closing the menu. */
1626 menu_frame_select_next(frame
->child
);
1627 else if (frame
->selected
)
1628 menu_entry_frame_execute(frame
->selected
, state
, ev
->xkey
.time
);
1631 else if (keycode
== ob_keycode(OB_KEY_LEFT
) && ev
->xkey
.state
== 0) {
1632 /* Left goes to the parent menu */
1633 menu_frame_select(frame
, NULL
, TRUE
);
1636 else if (keycode
== ob_keycode(OB_KEY_RIGHT
) && ev
->xkey
.state
== 0) {
1637 /* Right goes to the selected submenu */
1638 if (frame
->child
) menu_frame_select_next(frame
->child
);
1641 else if (keycode
== ob_keycode(OB_KEY_UP
) && state
== 0) {
1642 menu_frame_select_previous(frame
);
1645 else if (keycode
== ob_keycode(OB_KEY_DOWN
) && state
== 0) {
1646 menu_frame_select_next(frame
);
1649 /* keyboard accelerator shortcuts. (allow controlmask) */
1650 else if ((ev
->xkey
.state
& ~ControlMask
) == 0 &&
1651 /* was it a valid key? */
1653 /* don't bother if the menu is empty. */
1658 ObMenuEntryFrame
*found
= NULL
;
1659 guint num_found
= 0;
1661 /* start after the selected one */
1662 start
= frame
->entries
;
1663 if (frame
->selected
) {
1664 for (it
= start
; frame
->selected
!= it
->data
; it
= g_list_next(it
))
1665 g_assert(it
!= NULL
); /* nothing was selected? */
1666 /* next with wraparound */
1667 start
= g_list_next(it
);
1668 if (start
== NULL
) start
= frame
->entries
;
1673 ObMenuEntryFrame
*e
= it
->data
;
1674 gunichar entrykey
= 0;
1676 if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
)
1677 entrykey
= e
->entry
->data
.normal
.shortcut
;
1678 else if (e
->entry
->type
== OB_MENU_ENTRY_TYPE_SUBMENU
)
1679 entrykey
= e
->entry
->data
.submenu
.submenu
->shortcut
;
1681 if (unikey
== entrykey
) {
1682 if (found
== NULL
) found
= e
;
1686 /* next with wraparound */
1687 it
= g_list_next(it
);
1688 if (it
== NULL
) it
= frame
->entries
;
1689 } while (it
!= start
);
1692 if (found
->entry
->type
== OB_MENU_ENTRY_TYPE_NORMAL
&&
1695 menu_frame_select(frame
, found
, TRUE
);
1696 usleep(50000); /* highlight the item for a short bit so the
1697 user can see what happened */
1698 menu_entry_frame_execute(found
, state
, ev
->xkey
.time
);
1700 menu_frame_select(frame
, found
, TRUE
);
1702 menu_frame_select_next(frame
->child
);
1713 static gboolean
event_handle_menu(XEvent
*ev
)
1716 ObMenuEntryFrame
*e
;
1717 gboolean ret
= TRUE
;
1721 if (menu_hide_delay_reached() &&
1722 (ev
->xbutton
.button
< 4 || ev
->xbutton
.button
> 5))
1724 if ((e
= menu_entry_frame_under(ev
->xbutton
.x_root
,
1725 ev
->xbutton
.y_root
)))
1727 menu_frame_select(e
->frame
, e
, TRUE
);
1728 menu_entry_frame_execute(e
, ev
->xbutton
.state
,
1732 menu_frame_hide_all();
1736 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
))) {
1737 if (e
->ignore_enters
)
1739 else if (!(f
= find_active_menu()) ||
1741 f
->parent
== e
->frame
||
1742 f
->child
== e
->frame
)
1743 menu_frame_select(e
->frame
, e
, FALSE
);
1747 /*ignore leaves when we're already in the window */
1748 if (ev
->xcrossing
.detail
== NotifyInferior
)
1751 if ((e
= g_hash_table_lookup(menu_frame_map
, &ev
->xcrossing
.window
)) &&
1752 (f
= find_active_menu()) && f
->selected
== e
&&
1753 e
->entry
->type
!= OB_MENU_ENTRY_TYPE_SUBMENU
)
1755 menu_frame_select(e
->frame
, NULL
, FALSE
);
1759 if ((e
= menu_entry_frame_under(ev
->xmotion
.x_root
,
1760 ev
->xmotion
.y_root
)))
1761 if (!(f
= find_active_menu()) ||
1763 f
->parent
== e
->frame
||
1764 f
->child
== e
->frame
)
1765 menu_frame_select(e
->frame
, e
, FALSE
);
1768 ret
= event_handle_menu_keyboard(ev
);
1774 static void event_handle_user_input(ObClient
*client
, XEvent
*e
)
1776 g_assert(e
->type
== ButtonPress
|| e
->type
== ButtonRelease
||
1777 e
->type
== MotionNotify
|| e
->type
== KeyPress
||
1778 e
->type
== KeyRelease
);
1780 if (menu_frame_visible
) {
1781 if (event_handle_menu(e
))
1782 /* don't use the event if the menu used it, but if the menu
1783 didn't use it and it's a keypress that is bound, it will
1784 close the menu and be used */
1788 /* if the keyboard interactive action uses the event then dont
1789 use it for bindings. likewise is moveresize uses the event. */
1790 if (!keyboard_process_interactive_grab(e
, &client
) &&
1791 !(moveresize_in_progress
&& moveresize_event(e
)))
1793 if (moveresize_in_progress
)
1794 /* make further actions work on the client being
1796 client
= moveresize_client
;
1798 if (e
->type
== ButtonPress
||
1799 e
->type
== ButtonRelease
||
1800 e
->type
== MotionNotify
)
1802 /* the frame may not be "visible" but they can still click on it
1803 in the case where it is animating before disappearing */
1804 if (!client
|| !frame_iconify_animating(client
->frame
))
1805 mouse_event(client
, e
);
1806 } else if (e
->type
== KeyPress
) {
1807 keyboard_event((focus_cycle_target
? focus_cycle_target
:
1808 (client
? client
: focus_client
)), e
);
1813 static void focus_delay_dest(gpointer data
)
1818 static gboolean
focus_delay_cmp(gconstpointer d1
, gconstpointer d2
)
1820 const ObFocusDelayData
*f1
= d1
;
1821 return f1
->client
== d2
;
1824 static gboolean
focus_delay_func(gpointer data
)
1826 ObFocusDelayData
*d
= data
;
1827 Time old
= event_curtime
;
1829 event_curtime
= d
->time
;
1830 if (focus_client
!= d
->client
) {
1831 if (client_focus(d
->client
) && config_focus_raise
)
1832 stacking_raise(CLIENT_AS_WINDOW(d
->client
));
1834 event_curtime
= old
;
1835 return FALSE
; /* no repeat */
1838 static void focus_delay_client_dest(ObClient
*client
, gpointer data
)
1840 ob_main_loop_timeout_remove_data(ob_main_loop
, focus_delay_func
,
1844 void event_halt_focus_delay()
1846 ob_main_loop_timeout_remove(ob_main_loop
, focus_delay_func
);
1849 gulong
event_start_ignore_all_enters()
1851 XSync(ob_display
, FALSE
);
1852 return LastKnownRequestProcessed(ob_display
);
1855 void event_end_ignore_all_enters(gulong start
)
1859 g_assert(start
!= 0);
1860 XSync(ob_display
, FALSE
);
1862 r
= g_new(ObSerialRange
, 1);
1864 r
->end
= LastKnownRequestProcessed(ob_display
);
1865 ignore_serials
= g_slist_prepend(ignore_serials
, r
);
1866 ob_debug("ignoring serials %u-%u\n", r
->start
, r
->end
);
1868 /* increment the serial so we don't ignore events we weren't meant to */
1869 XSync(ob_display
, FALSE
);
1870 ob_debug("now last serial %u\n", LastKnownRequestProcessed(ob_display
));
1873 static gboolean
is_enter_focus_event_ignored(XEvent
*e
)
1877 g_assert(e
->type
== EnterNotify
&&
1878 !(e
->xcrossing
.mode
== NotifyGrab
||
1879 e
->xcrossing
.mode
== NotifyUngrab
||
1880 e
->xcrossing
.detail
== NotifyInferior
));
1882 ob_debug("checking serial %u\n", e
->xany
.serial
);
1883 for (it
= ignore_serials
; it
; it
= next
) {
1884 ObSerialRange
*r
= it
->data
;
1886 next
= g_slist_next(it
);
1888 /* XXX wraparound... */
1889 ob_debug(" ignore range %u-%u\n", r
->start
, r
->end
);
1890 if (e
->xany
.serial
> r
->end
) {
1891 ignore_serials
= g_slist_delete_link(ignore_serials
, it
);
1894 else if (e
->xany
.serial
>= r
->start
)
1900 void event_cancel_all_key_grabs()
1902 if (keyboard_interactively_grabbed())
1903 keyboard_interactive_cancel();
1904 else if (menu_frame_visible
)
1905 menu_frame_hide_all();
1906 else if (grab_on_keyboard())
1909 /* If we don't have the keyboard grabbed, then ungrab it with
1910 XUngrabKeyboard, so that there is not a passive grab left
1911 on from the KeyPress. If the grab is left on, and focus
1912 moves during that time, it will be NotifyWhileGrabbed, and
1913 applications like to ignore those! */
1914 if (!keyboard_interactively_grabbed())
1915 XUngrabKeyboard(ob_display
, CurrentTime
);
1919 gboolean
event_time_after(Time t1
, Time t2
)
1921 g_assert(t1
!= CurrentTime
);
1922 g_assert(t2
!= CurrentTime
);
1925 Timestamp values wrap around (after about 49.7 days). The server, given
1926 its current time is represented by timestamp T, always interprets
1927 timestamps from clients by treating half of the timestamp space as being
1928 later in time than T.
1929 - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
1932 /* TIME_HALF is half of the number space of a Time type variable */
1933 #define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
1935 if (t2
>= TIME_HALF
)
1936 /* t2 is in the second half so t1 might wrap around and be smaller than
1938 return t1
>= t2
|| t1
< (t2
+ TIME_HALF
);
1940 /* t2 is in the first half so t1 has to come after it */
1941 return t1
>= t2
&& t1
< (t2
+ TIME_HALF
);