dont kill interactive actions when the client dies, just remove teh client pointer.
[mikachu/openbox.git] / openbox / keyboard.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    keyboard.c for the Openbox window manager
4    Copyright (c) 2003        Ben Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "mainloop.h"
20 #include "focus.h"
21 #include "screen.h"
22 #include "frame.h"
23 #include "openbox.h"
24 #include "event.h"
25 #include "grab.h"
26 #include "client.h"
27 #include "action.h"
28 #include "prop.h"
29 #include "config.h"
30 #include "keytree.h"
31 #include "keyboard.h"
32 #include "translate.h"
33 #include "moveresize.h"
34
35 #include <glib.h>
36
37 KeyBindingTree *keyboard_firstnode;
38
39 typedef struct {
40     guint state;
41     ObClient *client;
42     GSList *actions;
43     ObFrameContext context;
44 } ObInteractiveState;
45
46 static GSList *interactive_states;
47
48 static KeyBindingTree *curpos;
49
50 static void grab_for_window(Window win, gboolean grab)
51 {
52     KeyBindingTree *p;
53
54     ungrab_all_keys(win);
55
56     if (grab) {
57         p = curpos ? curpos->first_child : keyboard_firstnode;
58         while (p) {
59             grab_key(p->key, p->state, win, GrabModeAsync);
60             p = p->next_sibling;
61         }
62         if (curpos)
63             grab_key(config_keyboard_reset_keycode,
64                      config_keyboard_reset_state,
65                      win, GrabModeAsync);
66     }
67 }
68
69 void keyboard_grab_for_client(ObClient *c, gboolean grab)
70 {
71     grab_for_window(c->window, grab);
72 }
73
74 static void grab_keys(gboolean grab)
75 {
76     GList *it;
77
78     grab_for_window(screen_support_win, grab);
79     for (it = client_list; it; it = g_list_next(it))
80         grab_for_window(((ObClient*)it->data)->window, grab);
81 }
82
83 static gboolean chain_timeout(gpointer data)
84 {
85     keyboard_reset_chains();
86
87     return FALSE; /* don't repeat */
88 }
89
90 void keyboard_reset_chains()
91 {
92     ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
93
94     if (curpos) {
95         grab_keys(FALSE);
96         curpos = NULL;
97         grab_keys(TRUE);
98     }
99 }
100
101 void keyboard_unbind_all()
102 {
103     tree_destroy(keyboard_firstnode);
104     keyboard_firstnode = NULL;
105     grab_keys(FALSE);
106     curpos = NULL;
107 }
108
109 gboolean keyboard_bind(GList *keylist, ObAction *action)
110 {
111     KeyBindingTree *tree, *t;
112     gboolean conflict;
113     gboolean mods = TRUE;
114
115     g_assert(keylist != NULL);
116     g_assert(action != NULL);
117
118     if (!(tree = tree_build(keylist)))
119         return FALSE;
120
121     if ((t = tree_find(tree, &conflict)) != NULL) {
122         /* already bound to something, use the existing tree */
123         tree_destroy(tree);
124         tree = NULL;
125     } else
126         t = tree;
127
128     if (conflict) {
129         g_warning("conflict with binding");
130         tree_destroy(tree);
131         return FALSE;
132     }
133
134     /* find if every key in this chain has modifiers, and also find the
135        bottom node of the tree */
136     while (t->first_child) {
137         if (!t->state)
138             mods = FALSE;
139         t = t->first_child;
140     }
141
142     /* when there are no modifiers in the binding, then the action cannot
143        be interactive */
144     if (!mods && action->data.any.interactive) {
145         action->data.any.interactive = FALSE;
146         action->data.inter.final = TRUE;
147     }
148
149     /* set the action */
150     t->actions = g_slist_append(t->actions, action);
151     /* assimilate this built tree into the main tree. assimilation
152        destroys/uses the tree */
153     if (tree) tree_assimilate(tree);
154
155     return TRUE;
156 }
157
158 void keyboard_interactive_grab(guint state, ObClient *client,
159                                ObAction *action)
160 {
161     ObInteractiveState *s;
162
163     g_assert(action->data.any.interactive);
164
165     if (moveresize_in_progress)
166         moveresize_end(FALSE);
167
168     if (!interactive_states) {
169         if (!grab_keyboard(TRUE))
170             return;
171         if (!grab_pointer(TRUE, OB_CURSOR_NONE)) {
172             grab_keyboard(FALSE);
173             return;
174         }
175     }
176
177     s = g_new(ObInteractiveState, 1);
178
179     s->state = state;
180     s->client = client;
181     s->actions = g_slist_append(NULL, action);
182
183     interactive_states = g_slist_append(interactive_states, s);
184 }
185
186 void keyboard_interactive_end(ObInteractiveState *s,
187                               guint state, gboolean cancel)
188 {
189     action_run_interactive(s->actions, s->client, state, cancel, TRUE);
190
191     g_slist_free(s->actions);
192     g_free(s);
193
194     interactive_states = g_slist_remove(interactive_states, s);
195
196     if (!interactive_states) {
197         grab_keyboard(FALSE);
198         grab_pointer(FALSE, OB_CURSOR_NONE);
199         keyboard_reset_chains();
200     }
201 }
202
203 void keyboard_interactive_end_client(gpointer data)
204 {
205     GSList *it, *next;
206     ObClient *c = data;
207
208     for (it = interactive_states; it; it = next) {
209         ObInteractiveState *s = it->data;
210
211         next = g_slist_next(it);
212
213         if (s->client == c)
214             s->client = NULL;
215     }
216 }
217
218 gboolean keyboard_process_interactive_grab(const XEvent *e, ObClient **client)
219 {
220     GSList *it, *next;
221     gboolean handled = FALSE;
222     gboolean done = FALSE;
223     gboolean cancel = FALSE;
224
225     for (it = interactive_states; it; it = next) {
226         ObInteractiveState *s = it->data;
227
228         next = g_slist_next(it);
229         
230         if ((e->type == KeyRelease && 
231              !(s->state & e->xkey.state)))
232             done = TRUE;
233         else if (e->type == KeyPress) {
234             if (e->xkey.keycode == ob_keycode(OB_KEY_RETURN))
235                 done = TRUE;
236             else if (e->xkey.keycode == ob_keycode(OB_KEY_ESCAPE))
237                 cancel = done = TRUE;
238         }
239         if (done) {
240             keyboard_interactive_end(s, e->xkey.state, cancel);
241
242             handled = TRUE;
243         } else
244             *client = s->client;
245     }
246
247     return handled;
248 }
249
250 void keyboard_event(ObClient *client, const XEvent *e)
251 {
252     KeyBindingTree *p;
253
254     g_assert(e->type == KeyPress);
255
256     if (e->xkey.keycode == config_keyboard_reset_keycode &&
257         e->xkey.state == config_keyboard_reset_state)
258     {
259         keyboard_reset_chains();
260         return;
261     }
262
263     if (curpos == NULL)
264         p = keyboard_firstnode;
265     else
266         p = curpos->first_child;
267     while (p) {
268         if (p->key == e->xkey.keycode &&
269             p->state == e->xkey.state)
270         {
271             if (p->first_child != NULL) { /* part of a chain */
272                 ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
273                 /* 5 second timeout for chains */
274                 ob_main_loop_timeout_add(ob_main_loop, 5 * G_USEC_PER_SEC,
275                                          chain_timeout, NULL, NULL);
276                 grab_keys(FALSE);
277                 curpos = p;
278                 grab_keys(TRUE);
279             } else {
280
281                 keyboard_reset_chains();
282
283                 action_run_key(p->actions, client, e->xkey.state,
284                                e->xkey.x_root, e->xkey.y_root);
285             }
286             break;
287         }
288         p = p->next_sibling;
289     }
290 }
291
292 void keyboard_startup(gboolean reconfig)
293 {
294     grab_keys(TRUE);
295
296     if (!reconfig)
297         client_add_destructor(keyboard_interactive_end_client);
298 }
299
300 void keyboard_shutdown(gboolean reconfig)
301 {
302     GSList *it;
303
304     if (!reconfig)
305         client_remove_destructor(keyboard_interactive_end_client);
306
307     for (it = interactive_states; it; it = g_slist_next(it))
308         g_free(it->data);
309     g_slist_free(interactive_states);
310     interactive_states = NULL;
311
312     ob_main_loop_timeout_remove(ob_main_loop, chain_timeout);
313
314     keyboard_unbind_all();
315 }
316