only refocus the omnipresent window if its allowed
[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 "framerender.h"
25 #include "client.h"
26 #include "config.h"
27 #include "frame.h"
28 #include "screen.h"
29 #include "group.h"
30 #include "prop.h"
31 #include "focus.h"
32 #include "stacking.h"
33 #include "popup.h"
34 #include "render/render.h"
35
36 #include <X11/Xlib.h>
37 #include <glib.h>
38 #include <assert.h>
39
40 ObClient *focus_client, *focus_hilite;
41 GList *focus_order;
42 ObClient *focus_cycle_target;
43
44 struct {
45     InternalWindow top;
46     InternalWindow left;
47     InternalWindow right;
48     InternalWindow bottom;
49 } focus_indicator;
50
51 RrAppearance *a_focus_indicator;
52 RrColor *color_white;
53
54 static ObIconPopup *focus_cycle_popup;
55
56 static void focus_cycle_destructor(ObClient *client, gpointer data)
57 {
58     /* end cycling if the target disappears. CurrentTime is fine, time won't
59        be used
60     */
61     if (focus_cycle_target == client)
62         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, CurrentTime);
63 }
64
65 static Window createWindow(Window parent, gulong mask,
66                            XSetWindowAttributes *attrib)
67 {
68     return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
69                          RrDepth(ob_rr_inst), InputOutput,
70                          RrVisual(ob_rr_inst), mask, attrib);
71                        
72 }
73
74 void focus_startup(gboolean reconfig)
75 {
76     focus_cycle_popup = icon_popup_new(TRUE);
77
78     if (!reconfig) {
79         XSetWindowAttributes attr;
80
81         client_add_destructor(focus_cycle_destructor, NULL);
82
83         /* start with nothing focused */
84         focus_set_client(NULL);
85
86         focus_indicator.top.obwin.type = Window_Internal;
87         focus_indicator.left.obwin.type = Window_Internal;
88         focus_indicator.right.obwin.type = Window_Internal;
89         focus_indicator.bottom.obwin.type = Window_Internal;
90
91         attr.override_redirect = True;
92         attr.background_pixel = BlackPixel(ob_display, ob_screen);
93         focus_indicator.top.win =
94             createWindow(RootWindow(ob_display, ob_screen),
95                          CWOverrideRedirect | CWBackPixel, &attr);
96         focus_indicator.left.win =
97             createWindow(RootWindow(ob_display, ob_screen),
98                          CWOverrideRedirect | CWBackPixel, &attr);
99         focus_indicator.right.win =
100             createWindow(RootWindow(ob_display, ob_screen),
101                          CWOverrideRedirect | CWBackPixel, &attr);
102         focus_indicator.bottom.win =
103             createWindow(RootWindow(ob_display, ob_screen),
104                          CWOverrideRedirect | CWBackPixel, &attr);
105
106         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.top));
107         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.left));
108         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.right));
109         stacking_add(INTERNAL_AS_WINDOW(&focus_indicator.bottom));
110
111         color_white = RrColorNew(ob_rr_inst, 0xff, 0xff, 0xff);
112
113         a_focus_indicator = RrAppearanceNew(ob_rr_inst, 4);
114         a_focus_indicator->surface.grad = RR_SURFACE_SOLID;
115         a_focus_indicator->surface.relief = RR_RELIEF_FLAT;
116         a_focus_indicator->surface.primary = RrColorNew(ob_rr_inst,
117                                                         0, 0, 0);
118         a_focus_indicator->texture[0].type = RR_TEXTURE_LINE_ART;
119         a_focus_indicator->texture[0].data.lineart.color = color_white;
120         a_focus_indicator->texture[1].type = RR_TEXTURE_LINE_ART;
121         a_focus_indicator->texture[1].data.lineart.color = color_white;
122         a_focus_indicator->texture[2].type = RR_TEXTURE_LINE_ART;
123         a_focus_indicator->texture[2].data.lineart.color = color_white;
124         a_focus_indicator->texture[3].type = RR_TEXTURE_LINE_ART;
125         a_focus_indicator->texture[3].data.lineart.color = color_white;
126     }
127 }
128
129 void focus_shutdown(gboolean reconfig)
130 {
131     icon_popup_free(focus_cycle_popup);
132
133     if (!reconfig) {
134         client_remove_destructor(focus_cycle_destructor);
135
136         /* reset focus to root */
137         XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime);
138
139         RrColorFree(color_white);
140
141         RrAppearanceFree(a_focus_indicator);
142
143         XDestroyWindow(ob_display, focus_indicator.top.win);
144         XDestroyWindow(ob_display, focus_indicator.left.win);
145         XDestroyWindow(ob_display, focus_indicator.right.win);
146         XDestroyWindow(ob_display, focus_indicator.bottom.win);
147     }
148 }
149
150 static void push_to_top(ObClient *client)
151 {
152     focus_order = g_list_remove(focus_order, client);
153     focus_order = g_list_prepend(focus_order, client);
154 }
155
156 void focus_set_client(ObClient *client)
157 {
158     Window active;
159     ObClient *old;
160
161 #ifdef DEBUG_FOCUS
162     ob_debug("focus_set_client 0x%lx\n", client ? client->window : 0);
163 #endif
164
165     /* uninstall the old colormap, and install the new one */
166     screen_install_colormap(focus_client, FALSE);
167     screen_install_colormap(client, TRUE);
168
169     if (client == NULL) {
170 #ifdef DEBUG_FOCUS
171         ob_debug("actively focusing NONWINDOW\n");
172 #endif
173         /* when nothing will be focused, send focus to the backup target */
174         XSetInputFocus(ob_display, screen_support_win, RevertToNone,
175                        event_curtime);
176         XSync(ob_display, FALSE);
177     }
178
179     /* in the middle of cycling..? kill it. CurrentTime is fine, time won't
180        be used.
181     */
182     if (focus_cycle_target)
183         focus_cycle(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, CurrentTime);
184
185     old = focus_client;
186     focus_client = client;
187
188     /* move to the top of the list */
189     if (client != NULL)
190         push_to_top(client);
191
192     /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
193     if (ob_state() != OB_STATE_EXITING) {
194         active = client ? client->window : None;
195         PROP_SET32(RootWindow(ob_display, ob_screen),
196                    net_active_window, window, active);
197
198         /* remove hiliting from the window when it gets focused */
199         if (client != NULL)
200             client_hilite(client, FALSE);
201     }
202 }
203
204 ObClient* focus_fallback_target(gboolean allow_refocus, ObClient *old)
205 {
206     GList *it;
207     ObClient *target = NULL;
208     ObClient *desktop = NULL;
209
210     ob_debug("trying pointer stuff\n");
211     if (config_focus_follow && !config_focus_last)
212     {
213         if ((target = client_under_pointer()))
214             if (allow_refocus || target != old)
215                 if (client_normal(target) && client_can_focus(target) &&
216                     client_validate(target)) {
217                     ob_debug("found in pointer stuff\n");
218                     return target;
219                 }
220     }
221
222 #if 0
223         /* try for group relations */
224         if (old->group) {
225             GSList *sit;
226
227             for (it = focus_order[screen_desktop]; it; it = g_list_next(it))
228                 for (sit = old->group->members; sit; sit = g_slist_next(sit))
229                     if (sit->data == it->data)
230                         if (sit->data != old && client_normal(sit->data))
231                             if (client_can_focus(sit->data))
232                                 return sit->data;
233         }
234 #endif
235
236     ob_debug("trying omnipresentness\n");
237     if (allow_refocus && old && old->desktop == DESKTOP_ALL)
238         return old;
239
240
241     ob_debug("trying  the focus order\n");
242     for (it = focus_order; it; it = g_list_next(it))
243         if (allow_refocus || it->data != old) {
244             ObClient *c = it->data;
245             /* fallback focus to a window if:
246                1. it is actually focusable, cuz if it's not then we're sending
247                focus off to nothing
248                2. it is validated. if the window is about to disappear, then
249                don't try focus it.
250                3. it is visible on the current desktop. this ignores
251                omnipresent windows, which are problematic in their own rite.
252                4. it's not iconic
253                5. it is a normal type window, don't fall back onto a dock or
254                a splashscreen or a desktop window (save the desktop as a
255                backup fallback though)
256             */
257             if (client_can_focus(c) && client_validate(c) &&
258                 c->desktop == screen_desktop && !c->iconic)
259             {
260                 if (client_normal(c)) {
261                     ob_debug("found in focus order\n");
262                     return it->data;
263                 } else if (c->type == OB_CLIENT_TYPE_DESKTOP && !desktop)
264                     desktop = c;
265             }
266         }
267
268     /* as a last resort fallback to the desktop window if there is one.
269        (if there's more than one, then the one most recently focused.)
270     */
271     return desktop;   
272 }
273
274 void focus_fallback(gboolean allow_refocus)
275 {
276     ObClient *new;
277     ObClient *old;
278
279     /* save this before moving focus away to nothing */
280     old = focus_client;
281
282     /* unfocus any focused clients.. they can be focused by Pointer events
283        and such, and then when I try focus them, I won't get a FocusIn event
284        at all for them.
285     */
286     focus_set_client(NULL);
287
288     if ((new = focus_fallback_target(allow_refocus, old)))
289         client_focus(new);
290 }
291
292 static void popup_cycle(ObClient *c, gboolean show)
293 {
294     if (!show) {
295         icon_popup_hide(focus_cycle_popup);
296     } else {
297         Rect *a;
298         ObClient *p = c;
299         gchar *title = NULL;
300
301         a = screen_physical_area_monitor(0);
302         icon_popup_position(focus_cycle_popup, CenterGravity,
303                             a->x + a->width / 2, a->y + a->height / 2);
304 /*        icon_popup_size(focus_cycle_popup, a->height/2, a->height/16);
305         icon_popup_show(focus_cycle_popup, c->title,
306                         client_icon(c, a->height/16, a->height/16));
307 */
308         /* XXX the size and the font extents need to be related on some level
309          */
310         icon_popup_size(focus_cycle_popup, POPUP_WIDTH, POPUP_HEIGHT);
311
312         /* use the transient's parent's title/icon */
313         while (p->transient_for && p->transient_for != OB_TRAN_GROUP)
314             p = p->transient_for;
315
316         if (p != c && !strcmp("", (c->iconic ? c->icon_title : c->title)))
317             title = g_strdup(p->iconic ? p->icon_title : p->title);
318             /*title = g_strconcat((c->iconic ? c->icon_title : c->title),
319                                 " - ",
320                                 (p->iconic ? p->icon_title : p->title),
321                                 NULL);
322             */
323         icon_popup_show(focus_cycle_popup,
324                         (title ? title :
325                          (c->iconic ? c->icon_title : c->title)),
326                         client_icon(p, 48, 48));
327         g_free(title);
328     }
329 }
330
331 void focus_cycle_draw_indicator()
332 {
333     if (!focus_cycle_target) {
334         XUnmapWindow(ob_display, focus_indicator.top.win);
335         XUnmapWindow(ob_display, focus_indicator.left.win);
336         XUnmapWindow(ob_display, focus_indicator.right.win);
337         XUnmapWindow(ob_display, focus_indicator.bottom.win);
338     } else {
339         /*
340           if (focus_cycle_target)
341               frame_adjust_focus(focus_cycle_target->frame, FALSE);
342           frame_adjust_focus(focus_cycle_target->frame, TRUE);
343         */
344         gint x, y, w, h;
345         gint wt, wl, wr, wb;
346
347         wt = wl = wr = wb = MAX(3,
348                                 MAX(1, MAX(ob_rr_theme->paddingx,
349                                            ob_rr_theme->paddingy)) * 2 +
350                                 ob_rr_theme->fbwidth * 2);
351
352         x = focus_cycle_target->frame->area.x;
353         y = focus_cycle_target->frame->area.y;
354         w = focus_cycle_target->frame->area.width;
355         h = wt;
356
357         XMoveResizeWindow(ob_display, focus_indicator.top.win,
358                           x, y, w, h);
359         a_focus_indicator->texture[0].data.lineart.x1 = 0;
360         a_focus_indicator->texture[0].data.lineart.y1 = h-1;
361         a_focus_indicator->texture[0].data.lineart.x2 = 0;
362         a_focus_indicator->texture[0].data.lineart.y2 = 0;
363         a_focus_indicator->texture[1].data.lineart.x1 = 0;
364         a_focus_indicator->texture[1].data.lineart.y1 = 0;
365         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
366         a_focus_indicator->texture[1].data.lineart.y2 = 0;
367         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
368         a_focus_indicator->texture[2].data.lineart.y1 = 0;
369         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
370         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
371         a_focus_indicator->texture[3].data.lineart.x1 = (wl-1);
372         a_focus_indicator->texture[3].data.lineart.y1 = h-1;
373         a_focus_indicator->texture[3].data.lineart.x2 = w - wr;
374         a_focus_indicator->texture[3].data.lineart.y2 = h-1;
375         RrPaint(a_focus_indicator, focus_indicator.top.win,
376                 w, h);
377
378         x = focus_cycle_target->frame->area.x;
379         y = focus_cycle_target->frame->area.y;
380         w = wl;
381         h = focus_cycle_target->frame->area.height;
382
383         XMoveResizeWindow(ob_display, focus_indicator.left.win,
384                           x, y, w, h);
385         a_focus_indicator->texture[0].data.lineart.x1 = w-1;
386         a_focus_indicator->texture[0].data.lineart.y1 = 0;
387         a_focus_indicator->texture[0].data.lineart.x2 = 0;
388         a_focus_indicator->texture[0].data.lineart.y2 = 0;
389         a_focus_indicator->texture[1].data.lineart.x1 = 0;
390         a_focus_indicator->texture[1].data.lineart.y1 = 0;
391         a_focus_indicator->texture[1].data.lineart.x2 = 0;
392         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
393         a_focus_indicator->texture[2].data.lineart.x1 = 0;
394         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
395         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
396         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
397         a_focus_indicator->texture[3].data.lineart.x1 = w-1;
398         a_focus_indicator->texture[3].data.lineart.y1 = wt-1;
399         a_focus_indicator->texture[3].data.lineart.x2 = w-1;
400         a_focus_indicator->texture[3].data.lineart.y2 = h - wb;
401         RrPaint(a_focus_indicator, focus_indicator.left.win,
402                 w, h);
403
404         x = focus_cycle_target->frame->area.x +
405             focus_cycle_target->frame->area.width - wr;
406         y = focus_cycle_target->frame->area.y;
407         w = wr;
408         h = focus_cycle_target->frame->area.height ;
409
410         XMoveResizeWindow(ob_display, focus_indicator.right.win,
411                           x, y, w, h);
412         a_focus_indicator->texture[0].data.lineart.x1 = 0;
413         a_focus_indicator->texture[0].data.lineart.y1 = 0;
414         a_focus_indicator->texture[0].data.lineart.x2 = w-1;
415         a_focus_indicator->texture[0].data.lineart.y2 = 0;
416         a_focus_indicator->texture[1].data.lineart.x1 = w-1;
417         a_focus_indicator->texture[1].data.lineart.y1 = 0;
418         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
419         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
420         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
421         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
422         a_focus_indicator->texture[2].data.lineart.x2 = 0;
423         a_focus_indicator->texture[2].data.lineart.y2 = h-1;
424         a_focus_indicator->texture[3].data.lineart.x1 = 0;
425         a_focus_indicator->texture[3].data.lineart.y1 = wt-1;
426         a_focus_indicator->texture[3].data.lineart.x2 = 0;
427         a_focus_indicator->texture[3].data.lineart.y2 = h - wb;
428         RrPaint(a_focus_indicator, focus_indicator.right.win,
429                 w, h);
430
431         x = focus_cycle_target->frame->area.x;
432         y = focus_cycle_target->frame->area.y +
433             focus_cycle_target->frame->area.height - wb;
434         w = focus_cycle_target->frame->area.width;
435         h = wb;
436
437         XMoveResizeWindow(ob_display, focus_indicator.bottom.win,
438                           x, y, w, h);
439         a_focus_indicator->texture[0].data.lineart.x1 = 0;
440         a_focus_indicator->texture[0].data.lineart.y1 = 0;
441         a_focus_indicator->texture[0].data.lineart.x2 = 0;
442         a_focus_indicator->texture[0].data.lineart.y2 = h-1;
443         a_focus_indicator->texture[1].data.lineart.x1 = 0;
444         a_focus_indicator->texture[1].data.lineart.y1 = h-1;
445         a_focus_indicator->texture[1].data.lineart.x2 = w-1;
446         a_focus_indicator->texture[1].data.lineart.y2 = h-1;
447         a_focus_indicator->texture[2].data.lineart.x1 = w-1;
448         a_focus_indicator->texture[2].data.lineart.y1 = h-1;
449         a_focus_indicator->texture[2].data.lineart.x2 = w-1;
450         a_focus_indicator->texture[2].data.lineart.y2 = 0;
451         a_focus_indicator->texture[3].data.lineart.x1 = wl-1;
452         a_focus_indicator->texture[3].data.lineart.y1 = 0;
453         a_focus_indicator->texture[3].data.lineart.x2 = w - wr;
454         a_focus_indicator->texture[3].data.lineart.y2 = 0;
455         RrPaint(a_focus_indicator, focus_indicator.bottom.win,
456                 w, h);
457
458         XMapWindow(ob_display, focus_indicator.top.win);
459         XMapWindow(ob_display, focus_indicator.left.win);
460         XMapWindow(ob_display, focus_indicator.right.win);
461         XMapWindow(ob_display, focus_indicator.bottom.win);
462     }
463 }
464
465 static gboolean valid_focus_target(ObClient *ft)
466 {
467     /* we don't use client_can_focus here, because that doesn't let you
468        focus an iconic window, but we want to be able to, so we just check
469        if the focus flags on the window allow it, and its on the current
470        desktop */
471     if ((ft->type == OB_CLIENT_TYPE_NORMAL ||
472          ft->type == OB_CLIENT_TYPE_DIALOG ||
473          (!client_has_group_siblings(ft) &&
474           (ft->type == OB_CLIENT_TYPE_TOOLBAR ||
475            ft->type == OB_CLIENT_TYPE_MENU ||
476            ft->type == OB_CLIENT_TYPE_UTILITY))) &&
477         ((ft->can_focus || ft->focus_notify) &&
478          !ft->skip_pager &&
479          (ft->desktop == screen_desktop || ft->desktop == DESKTOP_ALL)) &&
480         ft == client_focus_target(ft))
481         return TRUE;
482 /*
483     {
484         GSList *it;
485
486         for (it = ft->transients; it; it = g_slist_next(it)) {
487             ObClient *c = it->data;
488
489             if (c->frame->visible)
490                 return FALSE;
491         }
492         return TRUE;
493     }
494 */
495
496     return FALSE;
497 }
498
499 void focus_cycle(gboolean forward, gboolean linear, gboolean interactive,
500                  gboolean dialog, gboolean done, gboolean cancel, Time time)
501 {
502     static ObClient *first = NULL;
503     static ObClient *t = NULL;
504     static GList *order = NULL;
505     GList *it, *start, *list;
506     ObClient *ft = NULL;
507
508     if (interactive) {
509         if (cancel) {
510             focus_cycle_target = NULL;
511             goto done_cycle;
512         } else if (done)
513             goto done_cycle;
514
515         if (!focus_order)
516             goto done_cycle;
517
518         if (!first) first = focus_client;
519
520         if (linear) list = client_list;
521         else        list = focus_order;
522     } else {
523         if (!focus_order)
524             goto done_cycle;
525         list = client_list;
526     }
527     if (!focus_cycle_target) focus_cycle_target = focus_client;
528
529     start = it = g_list_find(list, focus_cycle_target);
530     if (!start) /* switched desktops or something? */
531         start = it = forward ? g_list_last(list) : g_list_first(list);
532     if (!start) goto done_cycle;
533
534     do {
535         if (forward) {
536             it = it->next;
537             if (it == NULL) it = g_list_first(list);
538         } else {
539             it = it->prev;
540             if (it == NULL) it = g_list_last(list);
541         }
542         ft = it->data;
543         if (valid_focus_target(ft)) {
544             if (interactive) {
545                 if (ft != focus_cycle_target) { /* prevents flicker */
546                     focus_cycle_target = ft;
547                     focus_cycle_draw_indicator();
548                 }
549                 popup_cycle(ft, dialog);
550                 return;
551             } else if (ft != focus_cycle_target) {
552                 focus_cycle_target = ft;
553                 done = TRUE;
554                 break;
555             }
556         }
557     } while (it != start);
558
559 done_cycle:
560     if (done && focus_cycle_target)
561         client_activate(focus_cycle_target, FALSE, TRUE, time);
562
563     t = NULL;
564     first = NULL;
565     focus_cycle_target = NULL;
566     g_list_free(order);
567     order = NULL;
568
569     if (interactive) {
570         focus_cycle_draw_indicator();
571         popup_cycle(ft, FALSE);
572     }
573
574     return;
575 }
576
577 void focus_directional_cycle(ObDirection dir, gboolean interactive,
578                              gboolean dialog, gboolean done, gboolean cancel,
579                              Time time)
580 {
581     static ObClient *first = NULL;
582     ObClient *ft = NULL;
583
584     if (!interactive)
585         return;
586
587     if (cancel) {
588         focus_cycle_target = NULL;
589         goto done_cycle;
590     } else if (done)
591         goto done_cycle;
592
593     if (!focus_order)
594         goto done_cycle;
595
596     if (!first) first = focus_client;
597     if (!focus_cycle_target) focus_cycle_target = focus_client;
598
599     if (focus_cycle_target)
600         ft = client_find_directional(focus_cycle_target, dir);
601     else {
602         GList *it;
603
604         for (it = focus_order; it; it = g_list_next(it))
605             if (valid_focus_target(it->data))
606                 ft = it->data;
607     }
608         
609     if (ft) {
610         if (ft != focus_cycle_target) {/* prevents flicker */
611             focus_cycle_target = ft;
612             focus_cycle_draw_indicator();
613         }
614     }
615     if (focus_cycle_target) {
616         popup_cycle(focus_cycle_target, dialog);
617         if (dialog)
618             return;
619     }
620
621
622 done_cycle:
623     if (done && focus_cycle_target)
624         client_activate(focus_cycle_target, FALSE, TRUE, time);
625
626     first = NULL;
627     focus_cycle_target = NULL;
628
629     focus_cycle_draw_indicator();
630     popup_cycle(ft, FALSE);
631
632     return;
633 }
634
635 void focus_order_add_new(ObClient *c)
636 {
637     if (c->iconic)
638         focus_order_to_top(c);
639     else {
640         g_assert(!g_list_find(focus_order, c));
641         /* if there are any iconic windows, put this above them in the order,
642            but if there are not, then put it under the currently focused one */
643         if (focus_order && ((ObClient*)focus_order->data)->iconic)
644             focus_order = g_list_insert(focus_order, c, 0);
645         else
646             focus_order = g_list_insert(focus_order, c, 1);
647     }
648 }
649
650 void focus_order_remove(ObClient *c)
651 {
652     focus_order = g_list_remove(focus_order, c);
653 }
654
655 void focus_order_to_top(ObClient *c)
656 {
657     focus_order = g_list_remove(focus_order, c);
658     if (!c->iconic) {
659         focus_order = g_list_prepend(focus_order, c);
660     } else {
661         GList *it;
662
663         /* insert before first iconic window */
664         for (it = focus_order;
665              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
666         focus_order = g_list_insert_before(focus_order, it, c);
667     }
668 }
669
670 void focus_order_to_bottom(ObClient *c)
671 {
672     focus_order = g_list_remove(focus_order, c);
673     if (c->iconic) {
674         focus_order = g_list_append(focus_order, c);
675     } else {
676         GList *it;
677
678         /* insert before first iconic window */
679         for (it = focus_order;
680              it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
681         focus_order = g_list_insert_before(focus_order, it, c);
682     }
683 }
684
685 ObClient *focus_order_find_first(guint desktop)
686 {
687     GList *it;
688     for (it = focus_order; it; it = g_list_next(it)) {
689         ObClient *c = it->data;
690         if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
691             return c;
692     }
693     return NULL;
694 }