make focuslast only apply to switching desktops, like 3.3.1
[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 "focus_cycle.h"
27 #include "screen.h"
28 #include "prop.h"
29 #include "keyboard.h"
30 #include "focus.h"
31 #include "stacking.h"
32
33 #include <X11/Xlib.h>
34 #include <glib.h>
35
36 #define FOCUS_INDICATOR_WIDTH 6
37
38 ObClient *focus_client = NULL;
39 GList *focus_order = NULL;
40
41 void focus_startup(gboolean reconfig)
42 {
43     if (reconfig) return;
44
45     /* start with nothing focused */
46     focus_nothing();
47 }
48
49 void focus_shutdown(gboolean reconfig)
50 {
51     if (reconfig) return;
52
53     /* reset focus to root */
54     XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime);
55 }
56
57 static void push_to_top(ObClient *client)
58 {
59     focus_order = g_list_remove(focus_order, client);
60     focus_order = g_list_prepend(focus_order, client);
61 }
62
63 void focus_set_client(ObClient *client)
64 {
65     Window active;
66
67     ob_debug_type(OB_DEBUG_FOCUS,
68                   "focus_set_client 0x%lx\n", client ? client->window : 0);
69
70     if (focus_client == client)
71         return;
72
73     /* uninstall the old colormap, and install the new one */
74     screen_install_colormap(focus_client, FALSE);
75     screen_install_colormap(client, TRUE);
76
77     /* in the middle of cycling..? kill it. */
78     focus_cycle_stop(focus_client);
79     focus_cycle_stop(client);
80
81     focus_client = client;
82
83     if (client != NULL) {
84         /* move to the top of the list */
85         push_to_top(client);
86         /* remove hiliting from the window when it gets focused */
87         client_hilite(client, FALSE);
88     }
89
90     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
91     if (ob_state() != OB_STATE_EXITING) {
92         active = client ? client->window : None;
93         PROP_SET32(RootWindow(ob_display, ob_screen),
94                    net_active_window, window, active);
95     }
96 }
97
98 static ObClient* focus_fallback_target(gboolean allow_refocus,
99                                        gboolean allow_pointer,
100                                        ObClient *old)
101 {
102     GList *it;
103     ObClient *c;
104
105     ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff\n");
106     if (allow_pointer && config_focus_follow)
107         if ((c = client_under_pointer()) &&
108             (allow_refocus || c != old) &&
109             (client_normal(c) &&
110              client_focus(c)))
111         {
112             ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff\n");
113             return c;
114         }
115
116     ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order\n");
117     for (it = focus_order; it; it = g_list_next(it)) {
118         c = it->data;
119         /* fallback focus to a window if:
120            1. it is on the current desktop. this ignores omnipresent
121            windows, which are problematic in their own rite.
122            2. it is a normal type window, don't fall back onto a dock or
123            a splashscreen or a desktop window (save the desktop as a
124            backup fallback though)
125         */
126         if (c->desktop == screen_desktop &&
127             client_normal(c) &&
128             (allow_refocus || c != old) &&
129             client_focus(c))
130         {
131             ob_debug_type(OB_DEBUG_FOCUS, "found in focus order\n");
132             return c;
133         }
134     }
135
136     ob_debug_type(OB_DEBUG_FOCUS, "trying a desktop window\n");
137     for (it = focus_order; it; it = g_list_next(it)) {
138         c = it->data;
139         /* fallback focus to a window if:
140            1. it is on the current desktop. this ignores omnipresent
141            windows, which are problematic in their own rite.
142            2. it is a normal type window, don't fall back onto a dock or
143            a splashscreen or a desktop window (save the desktop as a
144            backup fallback though)
145         */
146         if (c->type == OB_CLIENT_TYPE_DESKTOP &&
147             (allow_refocus || c != old) &&
148             client_focus(c))
149         {
150             ob_debug_type(OB_DEBUG_FOCUS, "found a desktop window\n");
151             return c;
152         }
153     }
154
155     return NULL;
156 }
157
158 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer)
159 {
160     ObClient *new;
161     ObClient *old = focus_client;
162
163     /* unfocus any focused clients.. they can be focused by Pointer events
164        and such, and then when we try focus them, we won't get a FocusIn
165        event at all for them. */
166     focus_nothing();
167
168     new = focus_fallback_target(allow_refocus, allow_pointer, old);
169
170     return new;
171 }
172
173 void focus_nothing()
174 {
175     /* Install our own colormap */
176     if (focus_client != NULL) {
177         screen_install_colormap(focus_client, FALSE);
178         screen_install_colormap(NULL, TRUE);
179     }
180
181     /* nothing is focused, update the colormap and _the root property_ */
182     focus_set_client(NULL);
183
184     /* if there is a grab going on, then we need to cancel it. if we move
185        focus during the grab, applications will get NotifyWhileGrabbed events
186        and ignore them !
187
188        actions should not rely on being able to move focus during an
189        interactive grab.
190     */
191     if (keyboard_interactively_grabbed())
192         keyboard_interactive_cancel();
193
194     /* when nothing will be focused, send focus to the backup target */
195     XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot,
196                    event_curtime);
197 }
198
199 void focus_order_add_new(ObClient *c)
200 {
201     if (c->iconic)
202         focus_order_to_top(c);
203     else {
204         g_assert(!g_list_find(focus_order, c));
205         /* if there are any iconic windows, put this above them in the order,
206            but if there are not, then put it under the currently focused one */
207         if (focus_order && ((ObClient*)focus_order->data)->iconic)
208             focus_order = g_list_insert(focus_order, c, 0);
209         else
210             focus_order = g_list_insert(focus_order, c, 1);
211     }
212
213     /* in the middle of cycling..? kill it. */
214     focus_cycle_stop(c);
215 }
216
217 void focus_order_remove(ObClient *c)
218 {
219     focus_order = g_list_remove(focus_order, c);
220
221     /* in the middle of cycling..? kill it. */
222     focus_cycle_stop(c);
223 }
224
225 void focus_order_to_top(ObClient *c)
226 {
227     focus_order = g_list_remove(focus_order, c);
228     if (!c->iconic) {
229         focus_order = g_list_prepend(focus_order, c);
230     } else {
231         GList *it;
232
233         /* insert before first iconic window */
234         for (it = focus_order;
235              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
236         focus_order = g_list_insert_before(focus_order, it, c);
237     }
238 }
239
240 void focus_order_to_bottom(ObClient *c)
241 {
242     focus_order = g_list_remove(focus_order, c);
243     if (c->iconic) {
244         focus_order = g_list_append(focus_order, c);
245     } else {
246         GList *it;
247
248         /* insert before first iconic window */
249         for (it = focus_order;
250              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
251         focus_order = g_list_insert_before(focus_order, it, c);
252     }
253 }
254
255 ObClient *focus_order_find_first(guint desktop)
256 {
257     GList *it;
258     for (it = focus_order; it; it = g_list_next(it)) {
259         ObClient *c = it->data;
260         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
261             return c;
262     }
263     return NULL;
264 }