ft was uninitialized
[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) 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 "debug.h"
20 #include "event.h"
21 #include "openbox.h"
22 #include "grab.h"
23 #include "framerender.h"
24 #include "client.h"
25 #include "config.h"
26 #include "frame.h"
27 #include "screen.h"
28 #include "group.h"
29 #include "prop.h"
30 #include "focus.h"
31 #include "stacking.h"
32 #include "popup.h"
33
34 #include <X11/Xlib.h>
35 #include <glib.h>
36 #include <assert.h>
37
38 ObClient *focus_client;
39 GList **focus_order; /* these lists are created when screen_startup
40                         sets the number of desktops */
41 ObClient *focus_cycle_target;
42
43 static ObIconPopup *focus_cycle_popup;
44
45 static void focus_cycle_destructor(ObClient *c)
46 {
47     /* end cycling if the target disappears */
48     if (focus_cycle_target == c)
49         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE);
50 }
51
52 void focus_startup(gboolean reconfig)
53 {
54     focus_cycle_popup = icon_popup_new(TRUE);
55
56     if (!reconfig) {
57         client_add_destructor((GDestroyNotify) focus_cycle_destructor);
58
59         /* start with nothing focused */
60         focus_set_client(NULL);
61     }
62 }
63
64 void focus_shutdown(gboolean reconfig)
65 {
66     guint i;
67
68     icon_popup_free(focus_cycle_popup);
69
70     if (!reconfig) {
71         client_remove_destructor((GDestroyNotify) focus_cycle_destructor);
72
73         for (i = 0; i < screen_num_desktops; ++i)
74             g_list_free(focus_order[i]);
75         g_free(focus_order);
76
77         /* reset focus to root */
78         XSetInputFocus(ob_display, PointerRoot, RevertToPointerRoot,
79                        event_lasttime);
80     }
81 }
82
83 static void push_to_top(ObClient *client)
84 {
85     guint desktop;
86
87     desktop = client->desktop;
88     if (desktop == DESKTOP_ALL) desktop = screen_desktop;
89     focus_order[desktop] = g_list_remove(focus_order[desktop], client);
90     focus_order[desktop] = g_list_prepend(focus_order[desktop], client);
91 }
92
93 void focus_set_client(ObClient *client)
94 {
95     Window active;
96     ObClient *old;
97
98 #ifdef DEBUG_FOCUS
99     ob_debug("focus_set_client 0x%lx\n", client ? client->window : 0);
100 #endif
101
102     /* uninstall the old colormap, and install the new one */
103     screen_install_colormap(focus_client, FALSE);
104     screen_install_colormap(client, TRUE);
105
106     if (client == NULL) {
107         /* when nothing will be focused, send focus to the backup target */
108         XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot,
109                        event_lasttime);
110         XSync(ob_display, FALSE);
111     }
112
113     /* in the middle of cycling..? kill it. */
114     if (focus_cycle_target)
115         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE);
116
117     old = focus_client;
118     focus_client = client;
119
120     /* move to the top of the list */
121     if (client != NULL)
122         push_to_top(client);
123
124     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
125     if (ob_state() != OB_STATE_EXITING) {
126         active = client ? client->window : None;
127         PROP_SET32(RootWindow(ob_display, ob_screen),
128                    net_active_window, window, active);
129     }
130 }
131
132 static gboolean focus_under_pointer()
133 {
134     ObClient *c;
135
136     if ((c = client_under_pointer()))
137         return client_normal(c) && client_focus(c);
138     return FALSE;
139 }
140
141 /* finds the first transient that isn't 'skip' and ensure's that client_normal
142  is true for it */
143 static ObClient *find_transient_recursive(ObClient *c, ObClient *top, ObClient *skip)
144 {
145     GSList *it;
146     ObClient *ret;
147
148     for (it = c->transients; it; it = it->next) {
149         if (it->data == top) return NULL;
150         ret = find_transient_recursive(it->data, top, skip);
151         if (ret && ret != skip && client_normal(ret)) return ret;
152         if (it->data != skip && client_normal(it->data)) return it->data;
153     }
154     return NULL;
155 }
156
157 static gboolean focus_fallback_transient(ObClient *top, ObClient *old)
158 {
159     ObClient *target = find_transient_recursive(top, top, old);
160     if (!target) {
161         /* make sure client_normal is true always */
162         if (!client_normal(top))
163             return FALSE;
164         target = top; /* no transient, keep the top */
165     }
166     return client_focus(target);
167 }
168
169 void focus_fallback(ObFocusFallbackType type)
170 {
171     GList *it;
172     ObClient *old = NULL;
173
174     old = focus_client;
175
176     /* unfocus any focused clients.. they can be focused by Pointer events
177        and such, and then when I try focus them, I won't get a FocusIn event
178        at all for them.
179     */
180     focus_set_client(NULL);
181
182     if (!config_focus_last && config_focus_follow)
183         if (focus_under_pointer())
184             return;
185
186     if (type == OB_FOCUS_FALLBACK_UNFOCUSING && old) {
187         /* try for transient relations */
188         if (old->transient_for) {
189             if (old->transient_for == OB_TRAN_GROUP) {
190                 for (it = focus_order[screen_desktop]; it; it = it->next) {
191                     GSList *sit;
192
193                     for (sit = old->group->members; sit; sit = sit->next)
194                         if (sit->data == it->data)
195                             if (focus_fallback_transient(sit->data, old))
196                                 return;
197                 }
198             } else {
199                 if (focus_fallback_transient(old->transient_for, old))
200                     return;
201             }
202         }
203
204 #if 0
205         /* try for group relations */
206         if (old->group) {
207             GSList *sit;
208
209             for (it = focus_order[screen_desktop]; it != NULL; it = it->next)
210                 for (sit = old->group->members; sit; sit = sit->next)
211                     if (sit->data == it->data)
212                         if (sit->data != old && client_normal(sit->data))
213                             if (client_can_focus(sit->data)) {
214                                 gboolean r = client_focus(sit->data);
215                                 assert(r);
216                                 return;
217                             }
218         }
219 #endif
220     }
221
222     for (it = focus_order[screen_desktop]; it != NULL; it = it->next)
223         if (type != OB_FOCUS_FALLBACK_UNFOCUSING || it->data != old)
224             if (client_normal(it->data) &&
225                 /* dont fall back to 'anonymous' fullscreen windows. theres no
226                    checks for this is in transient/group fallbacks, so they can
227                    be fallback targets there. */
228                 !((ObClient*)it->data)->fullscreen &&
229                 client_can_focus(it->data)) {
230                 gboolean r = client_focus(it->data);
231                 assert(r);
232                 return;
233             }
234
235     /* nothing to focus, and already set it to none above */
236 }
237
238 static void popup_cycle(ObClient *c, gboolean show)
239 {
240     if (!show) {
241         icon_popup_hide(focus_cycle_popup);
242     } else {
243         Rect *a;
244         ObClient *p = c;
245         char *title;
246
247         a = screen_physical_area_monitor(0);
248         icon_popup_position(focus_cycle_popup, CenterGravity,
249                             a->x + a->width / 2, a->y + a->height / 2);
250 /*        icon_popup_size(focus_cycle_popup, a->height/2, a->height/16);
251         icon_popup_show(focus_cycle_popup, c->title,
252                         client_icon(c, a->height/16, a->height/16));
253 */
254         /* XXX the size and the font extents need to be related on some level
255          */
256         icon_popup_size(focus_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT);
257
258         /* use the transient's parent's title/icon */
259         while (p->transient_for && p->transient_for != OB_TRAN_GROUP)
260             p = p->transient_for;
261
262         if (p == c)
263             title = NULL;
264         else
265             title = g_strconcat((c->iconic ? c->icon_title : c->title),
266                                 " - ",
267                                 (p->iconic ? p->icon_title : p->title),
268                                 NULL);
269
270         icon_popup_show(focus_cycle_popup,
271                         (title ? title :
272                          (c->iconic ? c->icon_title : c->title)),
273                         client_icon(p, 48, 48));
274         g_free(title);
275     }
276 }
277
278 static gboolean valid_focus_target(ObClient *ft)
279 {
280     /* we don't use client_can_focus here, because that doesn't let you
281        focus an iconic window, but we want to be able to, so we just check
282        if the focus flags on the window allow it, and its on the current
283        desktop */
284     return (ft->transients == NULL && client_normal(ft) &&
285             ((ft->can_focus || ft->focus_notify) &&
286              !ft->skip_taskbar &&
287              (ft->desktop == screen_desktop || ft->desktop == DESKTOP_ALL)));
288 }
289
290 void focus_cycle(gboolean forward, gboolean linear,
291                  gboolean dialog, gboolean done, gboolean cancel)
292 {
293     static ObClient *first = NULL;
294     static ObClient *t = NULL;
295     static GList *order = NULL;
296     GList *it, *start, *list;
297     ObClient *ft = NULL;
298
299     if (cancel) {
300         if (focus_cycle_target)
301             frame_adjust_focus(focus_cycle_target->frame, FALSE);
302         if (focus_client)
303             frame_adjust_focus(focus_client->frame, TRUE);
304         focus_cycle_target = NULL;
305         goto done_cycle;
306     } else if (done && dialog) {
307         goto done_cycle;
308     }
309
310     if (!focus_order[screen_desktop])
311         goto done_cycle;
312
313     if (!first) first = focus_client;
314     if (!focus_cycle_target) focus_cycle_target = focus_client;
315
316     if (linear) list = client_list;
317     else        list = focus_order[screen_desktop];
318
319     start = it = g_list_find(list, focus_cycle_target);
320     if (!start) /* switched desktops or something? */
321         start = it = forward ? g_list_last(list) : g_list_first(list);
322     if (!start) goto done_cycle;
323
324     do {
325         if (forward) {
326             it = it->next;
327             if (it == NULL) it = g_list_first(list);
328         } else {
329             it = it->prev;
330             if (it == NULL) it = g_list_last(list);
331         }
332         /*ft = client_focus_target(it->data);*/
333         ft = it->data;
334         if (valid_focus_target(ft)) {
335             if (ft != focus_cycle_target) { /* prevents flicker */
336                 if (focus_cycle_target)
337                     frame_adjust_focus(focus_cycle_target->frame, FALSE);
338                 focus_cycle_target = ft;
339                 frame_adjust_focus(focus_cycle_target->frame, TRUE);
340             }
341             popup_cycle(ft, dialog);
342             return;
343         }
344     } while (it != start);
345
346 done_cycle:
347     if (done && focus_cycle_target)
348         client_activate(focus_cycle_target, FALSE);
349
350     t = NULL;
351     first = NULL;
352     focus_cycle_target = NULL;
353     g_list_free(order);
354     order = NULL;
355
356     popup_cycle(ft, FALSE);
357
358     return;
359 }
360
361 void focus_directional_cycle(ObDirection dir,
362                              gboolean dialog, gboolean done, gboolean cancel)
363 {
364     static ObClient *first = NULL;
365     ObClient *ft = NULL;
366
367     if (cancel) {
368         if (focus_cycle_target)
369             frame_adjust_focus(focus_cycle_target->frame, FALSE);
370         if (focus_client)
371             frame_adjust_focus(focus_client->frame, TRUE);
372         focus_cycle_target = NULL;
373         goto done_cycle;
374     } else if (done && dialog) {
375         goto done_cycle;
376     }
377
378     if (!focus_order[screen_desktop])
379         goto done_cycle;
380
381     if (!first) first = focus_client;
382     if (!focus_cycle_target) focus_cycle_target = focus_client;
383
384     if (focus_cycle_target)
385         ft = client_find_directional(focus_cycle_target, dir);
386     else {
387         GList *it;
388
389         for (it = focus_order[screen_desktop]; it; it = g_list_next(it))
390             if (valid_focus_target(it->data))
391                 ft = it->data;
392     }
393         
394     if (ft) {
395         if (ft != focus_cycle_target) {/* prevents flicker */
396             if (focus_cycle_target)
397                 frame_adjust_focus(focus_cycle_target->frame, FALSE);
398             focus_cycle_target = ft;
399             frame_adjust_focus(focus_cycle_target->frame, TRUE);
400         }
401     }
402     if (focus_cycle_target) {
403         popup_cycle(focus_cycle_target, dialog);
404         if (dialog)
405             return;
406     }
407
408
409 done_cycle:
410     if (done && focus_cycle_target)
411         client_activate(focus_cycle_target, FALSE);
412
413     first = NULL;
414     focus_cycle_target = NULL;
415
416     popup_cycle(ft, FALSE);
417
418     return;
419 }
420
421 void focus_order_add_new(ObClient *c)
422 {
423     guint d, i;
424
425     if (c->iconic)
426         focus_order_to_top(c);
427     else {
428         d = c->desktop;
429         if (d == DESKTOP_ALL) {
430             for (i = 0; i < screen_num_desktops; ++i) {
431                 if (focus_order[i] && ((ObClient*)focus_order[i]->data)->iconic)
432                     focus_order[i] = g_list_insert(focus_order[i], c, 0);
433                 else
434                     focus_order[i] = g_list_insert(focus_order[i], c, 1);
435             }
436         } else
437              if (focus_order[d] && ((ObClient*)focus_order[d]->data)->iconic)
438                 focus_order[d] = g_list_insert(focus_order[d], c, 0);
439             else
440                 focus_order[d] = g_list_insert(focus_order[d], c, 1);
441     }
442 }
443
444 void focus_order_remove(ObClient *c)
445 {
446     guint d, i;
447
448     d = c->desktop;
449     if (d == DESKTOP_ALL) {
450         for (i = 0; i < screen_num_desktops; ++i)
451             focus_order[i] = g_list_remove(focus_order[i], c);
452     } else
453         focus_order[d] = g_list_remove(focus_order[d], c);
454 }
455
456 static void to_top(ObClient *c, guint d)
457 {
458     focus_order[d] = g_list_remove(focus_order[d], c);
459     if (!c->iconic) {
460         focus_order[d] = g_list_prepend(focus_order[d], c);
461     } else {
462         GList *it;
463
464         /* insert before first iconic window */
465         for (it = focus_order[d];
466              it && !((ObClient*)it->data)->iconic; it = it->next);
467         focus_order[d] = g_list_insert_before(focus_order[d], it, c);
468     }
469 }
470
471 void focus_order_to_top(ObClient *c)
472 {
473     guint d, i;
474
475     d = c->desktop;
476     if (d == DESKTOP_ALL) {
477         for (i = 0; i < screen_num_desktops; ++i)
478             to_top(c, i);
479     } else
480         to_top(c, d);
481 }
482
483 static void to_bottom(ObClient *c, guint d)
484 {
485     focus_order[d] = g_list_remove(focus_order[d], c);
486     if (c->iconic) {
487         focus_order[d] = g_list_append(focus_order[d], c);
488     } else {
489         GList *it;
490
491         /* insert before first iconic window */
492         for (it = focus_order[d];
493              it && !((ObClient*)it->data)->iconic; it = it->next);
494         g_list_insert_before(focus_order[d], it, c);
495     }
496 }
497
498 void focus_order_to_bottom(ObClient *c)
499 {
500     guint d, i;
501
502     d = c->desktop;
503     if (d == DESKTOP_ALL) {
504         for (i = 0; i < screen_num_desktops; ++i)
505             to_bottom(c, i);
506     } else
507         to_bottom(c, d);
508 }