Don't need to explicitly check for xft.
[mikachu/openbox.git] / openbox / focus.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    focus.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 "debug.h"
21 #include "event.h"
22 #include "openbox.h"
23 #include "grab.h"
24 #include "client.h"
25 #include "config.h"
26 #include "group.h"
27 #include "focus_cycle.h"
28 #include "screen.h"
29 #include "keyboard.h"
30 #include "hooks.h"
31 #include "focus.h"
32 #include "stacking.h"
33 #include "obt/prop.h"
34
35 #include <X11/Xlib.h>
36 #include <glib.h>
37
38 #define FOCUS_INDICATOR_WIDTH 6
39
40 ObClient *focus_client = NULL;
41 GList *focus_order = NULL;
42
43 void focus_startup(gboolean reconfig)
44 {
45     if (reconfig) return;
46
47     /* start with nothing focused */
48     focus_nothing();
49 }
50
51 void focus_shutdown(gboolean reconfig)
52 {
53     if (reconfig) return;
54
55     /* reset focus to root */
56     XSetInputFocus(obt_display, PointerRoot, RevertToNone, CurrentTime);
57 }
58
59 static void push_to_top(ObClient *client)
60 {
61     ObClient *p;
62
63     /* if it is modal for a single window, then put that window at the top
64        of the focus order first, so it will be right after ours. the same is
65        done with stacking */
66     if (client->modal && (p = client_direct_parent(client)))
67         push_to_top(p);
68
69     focus_order = g_list_remove(focus_order, client);
70     focus_order = g_list_prepend(focus_order, client);
71 }
72
73 void focus_set_client(ObClient *client)
74 {
75     Window active;
76     ObClient *old;
77
78     ob_debug_type(OB_DEBUG_FOCUS,
79                   "focus_set_client 0x%lx", client ? client->window : 0);
80
81     if (focus_client == client)
82         return;
83
84     /* uninstall the old colormap, and install the new one */
85     screen_install_colormap(focus_client, FALSE);
86     screen_install_colormap(client, TRUE);
87
88     /* in the middle of cycling..? kill it. */
89     focus_cycle_stop(focus_client);
90     focus_cycle_stop(client);
91
92     old = focus_client;
93     focus_client = client;
94
95     if (client != NULL) {
96         /* move to the top of the list */
97         push_to_top(client);
98         /* remove hiliting from the window when it gets focused */
99         client_hilite(client, FALSE);
100     }
101
102     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
103     if (ob_state() != OB_STATE_EXITING) {
104         active = client ? client->window : None;
105         OBT_PROP_SET32(obt_root(ob_screen), NET_ACTIVE_WINDOW, WINDOW, active);
106     }
107
108     hooks_queue(OB_HOOK_WIN_UNFOCUS, old);
109     hooks_queue(OB_HOOK_WIN_FOCUS, client);
110 }
111
112 static ObClient* focus_fallback_target(gboolean allow_refocus,
113                                        gboolean allow_pointer,
114                                        gboolean allow_omnipresent,
115                                        ObClient *old)
116 {
117     GList *it;
118     ObClient *c;
119
120     ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff");
121     if (allow_pointer && config_focus_follow)
122         if ((c = client_under_pointer()) &&
123             (allow_refocus || client_focus_target(c) != old) &&
124             (client_normal(c) &&
125              client_focus(c)))
126         {
127             ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff");
128             return c;
129         }
130
131     ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order");
132     for (it = focus_order; it; it = g_list_next(it)) {
133         c = it->data;
134         /* fallback focus to a window if:
135            1. it is on the current desktop. this ignores omnipresent
136            windows, which are problematic in their own rite, unless they are
137            specifically allowed
138            2. it is a valid auto-focus target
139            3. it is not shaded
140         */
141         if ((allow_omnipresent || c->desktop == screen_desktop) &&
142             focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, FALSE) &&
143             !c->shaded &&
144             (allow_refocus || client_focus_target(c) != old) &&
145             client_focus(c))
146         {
147             ob_debug_type(OB_DEBUG_FOCUS, "found in focus order");
148             return c;
149         }
150     }
151
152     ob_debug_type(OB_DEBUG_FOCUS, "trying a desktop window");
153     for (it = focus_order; it; it = g_list_next(it)) {
154         c = it->data;
155         /* fallback focus to a window if:
156            1. it is on the current desktop. this ignores omnipresent
157            windows, which are problematic in their own rite.
158            2. it is a normal type window, don't fall back onto a dock or
159            a splashscreen or a desktop window (save the desktop as a
160            backup fallback though)
161         */
162         if (focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, TRUE) &&
163             (allow_refocus || client_focus_target(c) != old) &&
164             client_focus(c))
165         {
166             ob_debug_type(OB_DEBUG_FOCUS, "found a desktop window");
167             return c;
168         }
169     }
170
171     return NULL;
172 }
173
174 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
175                          gboolean allow_omnipresent, gboolean focus_lost)
176 {
177     ObClient *new;
178     ObClient *old = focus_client;
179
180     /* unfocus any focused clients.. they can be focused by Pointer events
181        and such, and then when we try focus them, we won't get a FocusIn
182        event at all for them. */
183     if (focus_lost)
184         focus_nothing();
185
186     new = focus_fallback_target(allow_refocus, allow_pointer,
187                                 allow_omnipresent, old);
188     /* get what was really focused */
189     if (new) new = client_focus_target(new);
190
191     return new;
192 }
193
194 void focus_nothing(void)
195 {
196     /* Install our own colormap */
197     if (focus_client != NULL) {
198         screen_install_colormap(focus_client, FALSE);
199         screen_install_colormap(NULL, TRUE);
200     }
201
202     /* nothing is focused, update the colormap and _the root property_ */
203     focus_set_client(NULL);
204
205     event_cancel_all_key_grabs();
206
207     /* when nothing will be focused, send focus to the backup target */
208     XSetInputFocus(obt_display, screen_support_win, RevertToPointerRoot,
209                    event_curtime);
210 }
211
212 void focus_order_add_new(ObClient *c)
213 {
214     if (c->iconic)
215         focus_order_to_top(c);
216     else {
217         g_assert(!g_list_find(focus_order, c));
218         /* if there are any iconic windows, put this above them in the order,
219            but if there are not, then put it under the currently focused one */
220         if (focus_order && ((ObClient*)focus_order->data)->iconic)
221             focus_order = g_list_insert(focus_order, c, 0);
222         else
223             focus_order = g_list_insert(focus_order, c, 1);
224     }
225
226     /* in the middle of cycling..? kill it. */
227     focus_cycle_stop(c);
228 }
229
230 void focus_order_remove(ObClient *c)
231 {
232     focus_order = g_list_remove(focus_order, c);
233
234     /* in the middle of cycling..? kill it. */
235     focus_cycle_stop(c);
236 }
237
238 void focus_order_to_top(ObClient *c)
239 {
240     focus_order = g_list_remove(focus_order, c);
241     if (!c->iconic) {
242         focus_order = g_list_prepend(focus_order, c);
243     } else {
244         GList *it;
245
246         /* insert before first iconic window */
247         for (it = focus_order;
248              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
249         focus_order = g_list_insert_before(focus_order, it, c);
250     }
251 }
252
253 void focus_order_to_bottom(ObClient *c)
254 {
255     focus_order = g_list_remove(focus_order, c);
256     if (c->iconic) {
257         focus_order = g_list_append(focus_order, c);
258     } else {
259         GList *it;
260
261         /* insert before first iconic window */
262         for (it = focus_order;
263              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
264         focus_order = g_list_insert_before(focus_order, it, c);
265     }
266 }
267
268 ObClient *focus_order_find_first(guint desktop)
269 {
270     GList *it;
271     for (it = focus_order; it; it = g_list_next(it)) {
272         ObClient *c = it->data;
273         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
274             return c;
275     }
276     return NULL;
277 }
278
279 /*! Returns if a focus target has valid group siblings that can be cycled
280   to in its place */
281 static gboolean focus_target_has_siblings(ObClient *ft,
282                                           gboolean iconic_windows,
283                                           gboolean all_desktops)
284
285 {
286     GSList *it;
287
288     if (!ft->group) return FALSE;
289
290     for (it = ft->group->members; it; it = g_slist_next(it)) {
291         ObClient *c = it->data;
292         /* check that it's not a helper window to avoid infinite recursion */
293         if (c != ft && c->type == OB_CLIENT_TYPE_NORMAL &&
294             focus_valid_target(c, TRUE, iconic_windows, all_desktops,
295                                FALSE, FALSE))
296         {
297             return TRUE;
298         }
299     }
300     return FALSE;
301 }
302
303 gboolean focus_valid_target(ObClient *ft,
304                             gboolean helper_windows,
305                             gboolean iconic_windows,
306                             gboolean all_desktops,
307                             gboolean dock_windows,
308                             gboolean desktop_windows)
309 {
310     gboolean ok = FALSE;
311
312     /* it's on this desktop unless you want all desktops.
313
314        do this check first because it will usually filter out the most
315        windows */
316     ok = (all_desktops || ft->desktop == screen_desktop ||
317           ft->desktop == DESKTOP_ALL);
318
319     /* the window can receive focus somehow */
320     ok = ok && (ft->can_focus || ft->focus_notify);
321
322     /* the window is not iconic, or we're allowed to go to iconic ones */
323     ok = ok && (iconic_windows || !ft->iconic);
324
325     /* it's the right type of window */
326     if (dock_windows || desktop_windows)
327         ok = ok && ((dock_windows && ft->type == OB_CLIENT_TYPE_DOCK) ||
328                     (desktop_windows && ft->type == OB_CLIENT_TYPE_DESKTOP));
329     /* modal windows are important and can always get focus if they are
330        visible and stuff, so don't change 'ok' based on their type */
331     else if (!ft->modal)
332         /* normal non-helper windows are valid targets */
333         ok = ok &&
334             ((client_normal(ft) && !client_helper(ft))
335              ||
336              /* helper windows are valid targets if... */
337              (client_helper(ft) &&
338               /* ...a window in its group already has focus and we want to
339                  include helper windows ... */
340               ((focus_client && ft->group == focus_client->group &&
341                 helper_windows) ||
342                /* ... or if there are no other windows in its group
343                   that can be focused instead */
344                !focus_target_has_siblings(ft, iconic_windows, all_desktops))));
345
346     /* it's not set to skip the taskbar (but this only applies to normal typed
347        windows, and is overridden if the window is modal) */
348     ok = ok && (ft->type != OB_CLIENT_TYPE_NORMAL ||
349                 ft->modal ||
350                 !ft->skip_taskbar);
351
352     /* it's not going to just send focus off somewhere else (modal window),
353        unless that modal window is not one of our valid targets, then let
354        you choose this window and bring the modal one here */
355     {
356         ObClient *cft = client_focus_target(ft);
357         ok = ok && (ft == cft || !focus_valid_target(cft,
358                                                      TRUE,
359                                                      iconic_windows,
360                                                      all_desktops,
361                                                      dock_windows,
362                                                      desktop_windows));
363     }
364
365     return ok;
366 }