playing a bit with grabs
[dana/openbox.git] / openbox / grab.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    grab.c for the Openbox window manager
4    Copyright (c) 2006        Mikael Magnusson
5    Copyright (c) 2003-2007   Dana Jansens
6
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.
11
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.
16
17    See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "grab.h"
21 #include "openbox.h"
22 #include "event.h"
23 #include "xerror.h"
24 #include "screen.h"
25 #include "debug.h"
26
27 #include <glib.h>
28 #include <X11/Xlib.h>
29
30 #define GRAB_PTR_MASK (ButtonPressMask | ButtonReleaseMask | PointerMotionMask)
31 #define GRAB_KEY_MASK (KeyPressMask | KeyReleaseMask)
32
33 #define MASK_LIST_SIZE 8
34
35 /*! A list of all possible combinations of keyboard lock masks */
36 static guint mask_list[MASK_LIST_SIZE];
37 static guint kgrabs = 0;
38 static guint pgrabs = 0;
39 /*! The time at which the last grab was made */
40 static Time  grab_time = CurrentTime;
41
42 static Time ungrab_time()
43 {
44     Time t = event_curtime;
45     if (!(t == CurrentTime || event_time_after(t, grab_time)))
46         /* When the time moves backward on the server, then we can't use
47            the grab time because that will be in the future. So instead we
48            have to use CurrentTime.
49
50            "XUngrabPointer does not release the pointer if the specified time
51            is earlier than the last-pointer-grab time or is later than the
52            current X server time."
53         */
54         t = CurrentTime; /*grab_time;*/
55     return t;
56 }
57
58 gboolean grab_on_keyboard()
59 {
60     return kgrabs > 0;
61 }
62
63 gboolean grab_on_pointer()
64 {
65     return pgrabs > 0;
66 }
67
68 gboolean grab_keyboard(gboolean grab)
69 {
70     gboolean ret = FALSE;
71
72     if (grab) {
73         if (kgrabs++ == 0) {
74             ret = XGrabKeyboard(ob_display, RootWindow(ob_display, ob_screen),
75                                 False, GrabModeAsync, GrabModeAsync,
76                                 event_curtime) == Success;
77             if (!ret)
78                 --kgrabs;
79             else
80                 grab_time = event_curtime;
81         } else
82             ret = TRUE;
83     } else if (kgrabs > 0) {
84         if (--kgrabs == 0) {
85             XUngrabKeyboard(ob_display, ungrab_time());
86         }
87         ret = TRUE;
88     }
89
90     return ret;
91 }
92
93 gboolean grab_pointer(gboolean grab, gboolean owner_events, ObCursor cur)
94 {
95     gboolean ret = FALSE;
96
97     if (grab) {
98         if (pgrabs++ == 0) {
99             ret = XGrabPointer(ob_display, screen_support_win, owner_events,
100                                GRAB_PTR_MASK,
101                                GrabModeAsync, GrabModeAsync, None,
102                                ob_cursor(cur), event_curtime) == Success;
103             if (!ret)
104                 --pgrabs;
105             else
106                 grab_time = event_curtime;
107         } else
108             ret = TRUE;
109     } else if (pgrabs > 0) {
110         if (--pgrabs == 0) {
111             XUngrabPointer(ob_display, ungrab_time());
112         }
113         ret = TRUE;
114     }
115     return ret;
116 }
117
118 gint grab_server(gboolean grab)
119 {
120     static guint sgrabs = 0;
121     if (grab) {
122         if (sgrabs++ == 0) {
123             XGrabServer(ob_display);
124             XSync(ob_display, FALSE);
125         }
126     } else if (sgrabs > 0) {
127         if (--sgrabs == 0) {
128             XUngrabServer(ob_display);
129             XFlush(ob_display);
130         }
131     }
132     return sgrabs;
133 }
134
135 void grab_startup(gboolean reconfig)
136 {
137     guint i = 0;
138
139     if (reconfig) return;
140
141     mask_list[i++] = 0;
142     mask_list[i++] = LockMask;
143     mask_list[i++] = NumLockMask;
144     mask_list[i++] = LockMask | NumLockMask;
145     mask_list[i++] = ScrollLockMask;
146     mask_list[i++] = ScrollLockMask | LockMask;
147     mask_list[i++] = ScrollLockMask | NumLockMask;
148     mask_list[i++] = ScrollLockMask | LockMask | NumLockMask;
149     g_assert(i == MASK_LIST_SIZE);
150 }
151
152 void grab_shutdown(gboolean reconfig)
153 {
154     if (reconfig) return;
155
156     while (grab_keyboard(FALSE));
157     while (grab_pointer(FALSE, FALSE, OB_CURSOR_NONE));
158     while (grab_server(FALSE));
159 }
160
161 void grab_button_full(guint button, guint state, Window win, guint mask,
162                       gint pointer_mode, ObCursor cur)
163 {
164     guint i;
165
166     xerror_set_ignore(TRUE); /* can get BadAccess from these */
167     xerror_occured = FALSE;
168     for (i = 0; i < MASK_LIST_SIZE; ++i)
169         XGrabButton(ob_display, button, state | mask_list[i], win, False, mask,
170                     pointer_mode, GrabModeAsync, None, ob_cursor(cur));
171     xerror_set_ignore(FALSE);
172     if (xerror_occured)
173         ob_debug("Failed to grab button %d modifiers %d", button, state);
174 }
175
176 void ungrab_button(guint button, guint state, Window win)
177 {
178     guint i;
179
180     for (i = 0; i < MASK_LIST_SIZE; ++i)
181         XUngrabButton(ob_display, button, state | mask_list[i], win);
182 }
183
184 void grab_key(guint keycode, guint state, Window win, gint keyboard_mode)
185 {
186     guint i;
187
188     xerror_set_ignore(TRUE); /* can get BadAccess' from these */
189     xerror_occured = FALSE;
190     for (i = 0; i < MASK_LIST_SIZE; ++i)
191         XGrabKey(ob_display, keycode, state | mask_list[i], win, FALSE,
192                  GrabModeAsync, keyboard_mode);
193     xerror_set_ignore(FALSE);
194     if (xerror_occured)
195         ob_debug("Failed to grab keycode %d modifiers %d", keycode, state);
196 }
197
198 void ungrab_all_keys(Window win)
199 {
200     XUngrabKey(ob_display, AnyKey, AnyModifier, win);
201 }