skip enter events caused by temporarily raising windows during alt-tab. also caused...
[dana/openbox.git] / openbox / stacking.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    stacking.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 "openbox.h"
21 #include "prop.h"
22 #include "screen.h"
23 #include "focus.h"
24 #include "client.h"
25 #include "group.h"
26 #include "frame.h"
27 #include "window.h"
28 #include "debug.h"
29
30 GList  *stacking_list = NULL;
31 /*! When true, stacking changes will not be reflected on the screen.  This is
32   to freeze the on-screen stacking order while a window is being temporarily
33   raised during focus cycling */
34 static gboolean pause_changes = FALSE;
35
36 void stacking_set_list(void)
37 {
38     Window *windows = NULL;
39     GList *it;
40     guint i = 0;
41
42     /* on shutdown, don't update the properties, so that we can read it back
43        in on startup and re-stack the windows as they were before we shut down
44     */
45     if (ob_state() == OB_STATE_EXITING) return;
46
47     /* create an array of the window ids (from bottom to top,
48        reverse order!) */
49     if (stacking_list) {
50         windows = g_new(Window, g_list_length(stacking_list));
51         for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
52             if (WINDOW_IS_CLIENT(it->data))
53                 windows[i++] = WINDOW_AS_CLIENT(it->data)->window;
54         }
55     }
56
57     PROP_SETA32(RootWindow(ob_display, ob_screen),
58                 net_client_list_stacking, window, (gulong*)windows, i);
59
60     g_free(windows);
61 }
62
63 static void do_restack(GList *wins, GList *before)
64 {
65     GList *it;
66     Window *win;
67     gint i;
68
69 #ifdef DEBUG
70     GList *next;
71     /* pls only restack stuff in the same layer at a time */
72     for (it = wins; it; it = next) {
73         next = g_list_next(it);
74         if (!next) break;
75         g_assert (window_layer(it->data) == window_layer(next->data));
76     }
77     if (before)
78         g_assert(window_layer(it->data) >= window_layer(before->data));
79 #endif
80
81     win = g_new(Window, g_list_length(wins) + 1);
82
83     if (before == stacking_list)
84         win[0] = screen_support_win;
85     else if (!before)
86         win[0] = window_top(g_list_last(stacking_list)->data);
87     else
88         win[0] = window_top(g_list_previous(before)->data);
89
90     for (i = 1, it = wins; it; ++i, it = g_list_next(it)) {
91         win[i] = window_top(it->data);
92         g_assert(win[i] != None); /* better not call stacking shit before
93                                      setting your top level window value */
94         stacking_list = g_list_insert_before(stacking_list, before, it->data);
95     }
96
97 #ifdef DEBUG
98     /* some debug checking of the stacking list's order */
99     for (it = stacking_list; ; it = next) {
100         next = g_list_next(it);
101         if (!next) break;
102         g_assert(window_layer(it->data) >= window_layer(next->data));
103     }
104 #endif
105
106     if (!pause_changes)
107         XRestackWindows(ob_display, win, i);
108     g_free(win);
109
110     stacking_set_list();
111 }
112
113 void stacking_temp_raise(ObWindow *window)
114 {
115     Window win[2];
116     GList *it;
117     gulong start;
118
119     /* don't use this for internal windows..! it would lower them.. */
120     g_assert(window_layer(window) < OB_STACKING_LAYER_INTERNAL);
121
122     /* find the window to drop it underneath */
123     win[0] = screen_support_win;
124     for (it = stacking_list; it; it = g_list_next(it)) {
125         ObWindow *w = it->data;
126         if (window_layer(w) >= OB_STACKING_LAYER_INTERNAL)
127             win[0] = window_top(w);
128         else
129             break;
130     }
131
132     win[1] = window_top(window);
133     start = event_start_ignore_all_enters();
134     XRestackWindows(ob_display, win, 2);
135     event_end_ignore_all_enters(start);
136
137     pause_changes = TRUE;
138 }
139
140 void stacking_restore(void)
141 {
142     Window *win;
143     GList *it;
144     gint i;
145     gulong start;
146
147     win = g_new(Window, g_list_length(stacking_list) + 1);
148     win[0] = screen_support_win;
149     for (i = 1, it = stacking_list; it; ++i, it = g_list_next(it))
150         win[i] = window_top(it->data);
151     start = event_start_ignore_all_enters();
152     XRestackWindows(ob_display, win, i);
153     event_end_ignore_all_enters(start);
154     g_free(win);
155
156     pause_changes = FALSE;
157 }
158
159 static void do_raise(GList *wins)
160 {
161     GList *it;
162     GList *layer[OB_NUM_STACKING_LAYERS] = {NULL};
163     gint i;
164
165     for (it = wins; it; it = g_list_next(it)) {
166         ObStackingLayer l;
167
168         l = window_layer(it->data);
169         layer[l] = g_list_append(layer[l], it->data);
170     }
171
172     it = stacking_list;
173     for (i = OB_NUM_STACKING_LAYERS - 1; i >= 0; --i) {
174         if (layer[i]) {
175             for (; it; it = g_list_next(it)) {
176                 /* look for the top of the layer */
177                 if (window_layer(it->data) <= (ObStackingLayer) i)
178                     break;
179             }
180             do_restack(layer[i], it);
181             g_list_free(layer[i]);
182         }
183     }
184 }
185
186 static void do_lower(GList *wins)
187 {
188     GList *it;
189     GList *layer[OB_NUM_STACKING_LAYERS] = {NULL};
190     gint i;
191
192     for (it = wins; it; it = g_list_next(it)) {
193         ObStackingLayer l;
194
195         l = window_layer(it->data);
196         layer[l] = g_list_append(layer[l], it->data);
197     }
198
199     it = stacking_list;
200     for (i = OB_NUM_STACKING_LAYERS - 1; i >= 0; --i) {
201         if (layer[i]) {
202             for (; it; it = g_list_next(it)) {
203                 /* look for the top of the next layer down */
204                 if (window_layer(it->data) < (ObStackingLayer) i)
205                     break;
206             }
207             do_restack(layer[i], it);
208             g_list_free(layer[i]);
209         }
210     }
211 }
212
213 static void restack_windows(ObClient *selected, gboolean raise)
214 {
215     GList *it, *last, *below, *above, *next;
216     GList *wins = NULL;
217
218     GList *group_modals = NULL;
219     GList *group_trans = NULL;
220     GList *modals = NULL;
221     GList *trans = NULL;
222
223     /* remove first so we can't run into ourself */
224     it = g_list_find(stacking_list, selected);
225     g_assert(it);
226     stacking_list = g_list_delete_link(stacking_list, it);
227
228     /* go from the bottom of the stacking list up. don't move any other windows
229        when lowering, we call this for each window independently */
230     if (raise) {
231         for (it = g_list_last(stacking_list); it; it = next) {
232             next = g_list_previous(it);
233
234             if (WINDOW_IS_CLIENT(it->data)) {
235                 ObClient *ch = it->data;
236
237                 /* only move windows in the same stacking layer */
238                 if (ch->layer == selected->layer &&
239                     client_search_transient(selected, ch))
240                 {
241                     if (client_is_direct_child(selected, ch)) {
242                         if (ch->modal)
243                             modals = g_list_prepend(modals, ch);
244                         else
245                             trans = g_list_prepend(trans, ch);
246                     }
247                     else {
248                         if (ch->modal)
249                             group_modals = g_list_prepend(group_modals, ch);
250                         else
251                             group_trans = g_list_prepend(group_trans, ch);
252                     }
253                     stacking_list = g_list_delete_link(stacking_list, it);
254                 }
255             }
256         }
257     }
258
259     /* put transients of the selected window right above it */
260     wins = g_list_concat(modals, trans);
261     wins = g_list_append(wins, selected);
262
263     /* if selected window is transient for group then raise it above others */
264     if (selected->transient_for_group) {
265         /* if it's modal, raise it above those also */
266         if (selected->modal) {
267             wins = g_list_concat(wins, group_modals);
268             group_modals = NULL;
269         }
270         wins = g_list_concat(wins, group_trans);
271         group_trans = NULL;
272     }
273
274     /* find where to put the selected window, start from bottom of list,
275        this is the window below everything we are re-adding to the list */
276     last = NULL;
277     for (it = g_list_last(stacking_list); it; it = g_list_previous(it))
278     {
279         if (window_layer(it->data) < selected->layer) {
280             last = it;
281             continue;
282         }
283         /* if lowering, stop at the beginning of the layer */
284         if (!raise)
285             break;
286         /* if raising, stop at the end of the layer */
287         if (window_layer(it->data) > selected->layer)
288             break;
289
290         last = it;
291     }
292
293     /* save this position in the stacking list */
294     below = last;
295
296     /* find where to put the group transients, start from the top of list */
297     for (it = stacking_list; it; it = g_list_next(it)) {
298         /* skip past higher layers */
299         if (window_layer(it->data) > selected->layer)
300             continue;
301         /* if we reach the end of the layer (how?) then don't go further */
302         if (window_layer(it->data) < selected->layer)
303             break;
304         /* stop when we reach the first window in the group */
305         if (WINDOW_IS_CLIENT(it->data)) {
306             ObClient *c = it->data;
307             if (c->group == selected->group)
308                 break;
309         }
310         /* if we don't hit any other group members, stop here because this
311            is where we are putting the selected window (and its children) */
312         if (it == below)
313             break;
314     }
315
316     /* save this position, this is the top of the group of windows between the
317        group transient ones we're restacking and the others up above that we're
318        restacking
319
320        we actually want to save 1 position _above_ that, for for loops to work
321        nicely, so move back one position in the list while saving it
322     */
323     above = it ? g_list_previous(it) : g_list_last(stacking_list);
324
325     /* put the windows inside the gap to the other windows we're stacking
326        into the restacking list, go from the bottom up so that we can use
327        g_list_prepend */
328     if (below) it = g_list_previous(below);
329     else       it = g_list_last(stacking_list);
330     for (; it != above; it = next) {
331         next = g_list_previous(it);
332         wins = g_list_prepend(wins, it->data);
333         stacking_list = g_list_delete_link(stacking_list, it);
334     }
335
336     /* group transients go above the rest of the stuff acquired to now */
337     wins = g_list_concat(group_trans, wins);
338     /* group modals go on the very top */
339     wins = g_list_concat(group_modals, wins);
340
341     do_restack(wins, below);
342     g_list_free(wins);
343
344     /* lower our parents after us, so they go below us */
345     if (!raise && selected->parents) {
346         GSList *parents_copy, *sit;
347         GSList *reorder = NULL;
348
349         parents_copy = g_slist_copy(selected->parents);
350
351         /* go thru stacking list backwards so we can use g_slist_prepend */
352         for (it = g_list_last(stacking_list); it && parents_copy;
353              it = g_list_previous(it))
354             if ((sit = g_slist_find(parents_copy, it->data))) {
355                 reorder = g_slist_prepend(reorder, sit->data);
356                 parents_copy = g_slist_delete_link(parents_copy, sit);
357             }
358         g_assert(parents_copy == NULL);
359
360         /* call restack for each of these to lower them */
361         for (sit = reorder; sit; sit = g_slist_next(sit))
362             restack_windows(sit->data, raise);
363     }
364 }
365
366 void stacking_raise(ObWindow *window)
367 {
368     if (WINDOW_IS_CLIENT(window)) {
369         ObClient *selected;
370         selected = WINDOW_AS_CLIENT(window);
371         restack_windows(selected, TRUE);
372     } else {
373         GList *wins;
374         wins = g_list_append(NULL, window);
375         stacking_list = g_list_remove(stacking_list, window);
376         do_raise(wins);
377         g_list_free(wins);
378     }
379 }
380
381 void stacking_lower(ObWindow *window)
382 {
383     if (WINDOW_IS_CLIENT(window)) {
384         ObClient *selected;
385         selected = WINDOW_AS_CLIENT(window);
386         restack_windows(selected, FALSE);
387     } else {
388         GList *wins;
389         wins = g_list_append(NULL, window);
390         stacking_list = g_list_remove(stacking_list, window);
391         do_lower(wins);
392         g_list_free(wins);
393     }
394 }
395
396 void stacking_below(ObWindow *window, ObWindow *below)
397 {
398     GList *wins, *before;
399
400     if (window_layer(window) != window_layer(below))
401         return;
402
403     wins = g_list_append(NULL, window);
404     stacking_list = g_list_remove(stacking_list, window);
405     before = g_list_next(g_list_find(stacking_list, below));
406     do_restack(wins, before);
407     g_list_free(wins);
408 }
409
410 void stacking_add(ObWindow *win)
411 {
412     g_assert(screen_support_win != None); /* make sure I dont break this in the
413                                              future */
414
415     stacking_list = g_list_append(stacking_list, win);
416     stacking_raise(win);
417 }
418
419 static GList *find_highest_relative(ObClient *client)
420 {
421     GList *ret = NULL;
422
423     if (client->parents) {
424         GList *it;
425         GSList *top;
426
427         /* get all top level relatives of this client */
428         top = client_search_all_top_parents_layer(client);
429
430         /* go from the top of the stacking order down */
431         for (it = stacking_list; !ret && it; it = g_list_next(it)) {
432             if (WINDOW_IS_CLIENT(it->data)) {
433                 ObClient *c = it->data;
434                 /* only look at windows in the same layer and that are
435                    visible */
436                 if (c->layer == client->layer &&
437                     !c->iconic &&
438                     (c->desktop == client->desktop ||
439                      c->desktop == DESKTOP_ALL ||
440                      client->desktop == DESKTOP_ALL))
441                 {
442                     GSList *sit;
443
444                     /* go through each top level parent and see it this window
445                        is related to them */
446                     for (sit = top; !ret && sit; sit = g_slist_next(sit)) {
447                         ObClient *topc = sit->data;
448
449                         /* are they related ? */
450                         if (topc == c || client_search_transient(topc, c))
451                             ret = it;
452                     }
453                 }
454             }
455         }
456     }
457     return ret;
458 }
459
460 void stacking_add_nonintrusive(ObWindow *win)
461 {
462     ObClient *client;
463     GList *it_below = NULL; /* this client will be below us */
464     GList *it_above;
465     GList *wins;
466
467     if (!WINDOW_IS_CLIENT(win)) {
468         stacking_add(win); /* no special rules for others */
469         return;
470     }
471
472     client = WINDOW_AS_CLIENT(win);
473
474     /* insert above its highest parent (or its highest child !) */
475     it_below = find_highest_relative(client);
476
477     if (!it_below) {
478         /* nothing to put it directly above, so try find the focused client
479            to put it underneath it */
480         if (focus_client && client != focus_client &&
481             focus_client->layer == client->layer)
482         {
483             it_below = g_list_find(stacking_list, focus_client);
484             /* this can give NULL, but it means the focused window is on the
485                bottom of the stacking order, so go to the bottom in that case,
486                below it */
487             it_below = g_list_next(it_below);
488         }
489         else {
490             /* There is no window to put this directly above, so put it at the
491                top, so you know it is there.
492
493                It used to do this only if the window was focused and lower
494                it otherwise.
495
496                We also put it at the top not the bottom to fix a bug with
497                fullscreen windows. When focusLast is off and followsMouse is
498                on, when you switch desktops, the fullscreen window loses
499                focus and goes into its lower layer. If this puts it at the
500                bottom then when you come back to the desktop, the window is
501                at the bottom and won't get focus back.
502             */
503             it_below = stacking_list;
504         }
505     }
506
507     /* make sure it's not in the wrong layer though ! */
508     for (; it_below; it_below = g_list_next(it_below)) {
509         /* stop when the window is not in a higher layer than the window
510            it is going above (it_below) */
511         if (client->layer >= window_layer(it_below->data))
512             break;
513     }
514     for (; it_below != stacking_list; it_below = it_above) {
515         /* stop when the window is not in a lower layer than the
516            window it is going under (it_above) */
517         it_above = it_below ?
518             g_list_previous(it_below) : g_list_last(stacking_list);
519         if (client->layer <= window_layer(it_above->data))
520             break;
521     }
522
523     wins = g_list_append(NULL, win);
524     do_restack(wins, it_below);
525     g_list_free(wins);
526 }
527
528 /*! Returns TRUE if client is occluded by the sibling. If sibling is NULL it
529   tries against all other clients.
530 */
531 static gboolean stacking_occluded(ObClient *client, ObClient *sibling)
532 {
533     GList *it;
534     gboolean occluded = FALSE;
535     gboolean found = FALSE;
536
537     /* no need for any looping in this case */
538     if (sibling && client->layer != sibling->layer)
539         return occluded;
540
541     for (it = stacking_list; it;
542          it = (found ? g_list_previous(it) :g_list_next(it)))
543         if (WINDOW_IS_CLIENT(it->data)) {
544             ObClient *c = it->data;
545             if (found && !c->iconic &&
546                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
547                  c->desktop == client->desktop) &&
548                 !client_search_transient(client, c))
549             {
550                 if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
551                 {
552                     if (sibling != NULL) {
553                         if (c == sibling) {
554                             occluded = TRUE;
555                             break;
556                         }
557                     }
558                     else if (c->layer == client->layer) {
559                         occluded = TRUE;
560                         break;
561                     }
562                     else if (c->layer > client->layer)
563                         break; /* we past its layer */
564                 }
565             }
566             else if (c == client)
567                 found = TRUE;
568         }
569     return occluded;
570 }
571
572 /*! Returns TRUE if client occludes the sibling. If sibling is NULL it tries
573   against all other clients.
574 */
575 static gboolean stacking_occludes(ObClient *client, ObClient *sibling)
576 {
577     GList *it;
578     gboolean occludes = FALSE;
579     gboolean found = FALSE;
580
581     /* no need for any looping in this case */
582     if (sibling && client->layer != sibling->layer)
583         return occludes;
584
585     for (it = stacking_list; it; it = g_list_next(it))
586         if (WINDOW_IS_CLIENT(it->data)) {
587             ObClient *c = it->data;
588             if (found && !c->iconic &&
589                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
590                  c->desktop == client->desktop) &&
591                 !client_search_transient(c, client))
592             {
593                 if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
594                 {
595                     if (sibling != NULL) {
596                         if (c == sibling) {
597                             occludes = TRUE;
598                             break;
599                         }
600                     }
601                     else if (c->layer == client->layer) {
602                         occludes = TRUE;
603                         break;
604                     }
605                     else if (c->layer < client->layer)
606                         break; /* we past its layer */
607                 }
608             }
609             else if (c == client)
610                 found = TRUE;
611         }
612     return occludes;
613 }
614
615 gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
616                                   gint detail)
617 {
618     gboolean ret = FALSE;
619
620     if (sibling && ((client->desktop != sibling->desktop &&
621                      client->desktop != DESKTOP_ALL &&
622                      sibling->desktop != DESKTOP_ALL) ||
623                     sibling->iconic))
624     {
625         ob_debug("Setting restack sibling to NULL, they are not on the same "
626                  "desktop or it is iconified\n");
627         sibling = NULL;
628     }
629
630     switch (detail) {
631     case Below:
632         ob_debug("Restack request Below for client %s sibling %s\n",
633                  client->title, sibling ? sibling->title : "(all)");
634         /* just lower it */
635         stacking_lower(CLIENT_AS_WINDOW(client));
636         ret = TRUE;
637         break;
638     case BottomIf:
639         ob_debug("Restack request BottomIf for client %s sibling "
640                  "%s\n",
641                  client->title, sibling ? sibling->title : "(all)");
642         /* if this client occludes sibling (or anything if NULL), then
643            lower it to the bottom */
644         if (stacking_occludes(client, sibling)) {
645             stacking_lower(CLIENT_AS_WINDOW(client));
646             ret = TRUE;
647         }
648         break;
649     case Above:
650         ob_debug("Restack request Above for client %s sibling %s\n",
651                  client->title, sibling ? sibling->title : "(all)");
652         stacking_raise(CLIENT_AS_WINDOW(client));
653         ret = TRUE;
654         break;
655     case TopIf:
656         ob_debug("Restack request TopIf for client %s sibling %s\n",
657                  client->title, sibling ? sibling->title : "(all)");
658         if (stacking_occluded(client, sibling)) {
659             stacking_raise(CLIENT_AS_WINDOW(client));
660             ret = TRUE;
661         }
662         break;
663     case Opposite:
664         ob_debug("Restack request Opposite for client %s sibling "
665                  "%s\n",
666                  client->title, sibling ? sibling->title : "(all)");
667         if (stacking_occluded(client, sibling)) {
668             stacking_raise(CLIENT_AS_WINDOW(client));
669             ret = TRUE;
670         }
671         else if (stacking_occludes(client, sibling)) {
672             stacking_lower(CLIENT_AS_WINDOW(client));
673             ret = TRUE;
674         }
675         break;
676     }
677     return ret;
678 }