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