]>
Dogcows Code - chaz/openbox/blob - openbox/stacking.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 stacking.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003 Ben Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
29 GList
*stacking_list
= NULL
;
31 void stacking_set_list()
33 Window
*windows
= NULL
;
37 /* on shutdown, don't update the properties, so that we can read it back
38 in on startup and re-stack the windows as they were before we shut down
40 if (ob_state() == OB_STATE_EXITING
) return;
42 /* create an array of the window ids (from bottom to top,
45 windows
= g_new(Window
, g_list_length(stacking_list
));
46 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
47 if (WINDOW_IS_CLIENT(it
->data
))
48 windows
[i
++] = WINDOW_AS_CLIENT(it
->data
)->window
;
52 PROP_SETA32(RootWindow(ob_display
, ob_screen
),
53 net_client_list_stacking
, window
, (gulong
*)windows
, i
);
58 static void do_restack(GList
*wins
, GList
*before
)
66 /* pls only restack stuff in the same layer at a time */
67 for (it
= wins
; it
; it
= next
) {
68 next
= g_list_next(it
);
70 g_assert (window_layer(it
->data
) == window_layer(next
->data
));
73 g_assert(window_layer(it
->data
) >= window_layer(before
->data
));
76 win
= g_new(Window
, g_list_length(wins
) + 1);
78 if (before
== stacking_list
)
79 win
[0] = screen_support_win
;
81 win
[0] = window_top(g_list_last(stacking_list
)->data
);
83 win
[0] = window_top(g_list_previous(before
)->data
);
85 for (i
= 1, it
= wins
; it
; ++i
, it
= g_list_next(it
)) {
86 win
[i
] = window_top(it
->data
);
87 g_assert(win
[i
] != None
); /* better not call stacking shit before
88 setting your top level window value */
89 stacking_list
= g_list_insert_before(stacking_list
, before
, it
->data
);
93 /* some debug checking of the stacking list's order */
94 for (it
= stacking_list
; ; it
= next
) {
95 next
= g_list_next(it
);
97 g_assert(window_layer(it
->data
) >= window_layer(next
->data
));
101 XRestackWindows(ob_display
, win
, i
);
107 static void do_raise(GList
*wins
)
110 GList
*layer
[OB_NUM_STACKING_LAYERS
] = {NULL
};
113 for (it
= wins
; it
; it
= g_list_next(it
)) {
116 l
= window_layer(it
->data
);
117 layer
[l
] = g_list_append(layer
[l
], it
->data
);
121 for (i
= OB_NUM_STACKING_LAYERS
- 1; i
>= 0; --i
) {
123 for (; it
; it
= g_list_next(it
)) {
124 /* look for the top of the layer */
125 if (window_layer(it
->data
) <= (ObStackingLayer
) i
)
128 do_restack(layer
[i
], it
);
129 g_list_free(layer
[i
]);
134 static void do_lower(GList
*wins
)
137 GList
*layer
[OB_NUM_STACKING_LAYERS
] = {NULL
};
140 for (it
= wins
; it
; it
= g_list_next(it
)) {
143 l
= window_layer(it
->data
);
144 layer
[l
] = g_list_append(layer
[l
], it
->data
);
148 for (i
= OB_NUM_STACKING_LAYERS
- 1; i
>= 0; --i
) {
150 for (; it
; it
= g_list_next(it
)) {
151 /* look for the top of the next layer down */
152 if (window_layer(it
->data
) < (ObStackingLayer
) i
)
155 do_restack(layer
[i
], it
);
156 g_list_free(layer
[i
]);
161 static GList
*pick_windows_recur(ObClient
*top
, ObClient
*selected
,
165 GList
*it
, *next
, *prev
;
168 GList
*modals
= NULL
;
170 GList
*modal_sel
= NULL
; /* the selected guys if modal */
171 GList
*trans_sel
= NULL
; /* the selected guys if not */
173 /* remove first so we can't run into ourself */
174 if ((it
= g_list_find(stacking_list
, top
)))
175 stacking_list
= g_list_delete_link(stacking_list
, it
);
180 n
= g_slist_length(top
->transients
);
181 for (it
= stacking_list
; i
< n
&& it
; it
= next
) {
182 prev
= g_list_previous(it
);
183 next
= g_list_next(it
);
185 if ((sit
= g_slist_find(top
->transients
, it
->data
))) {
186 ObClient
*c
= sit
->data
;
194 sel_child
= client_search_transient(c
, selected
) != NULL
;
198 trans
= g_list_concat
199 (trans
, pick_windows_recur(c
, selected
, raise
));
201 trans_sel
= g_list_concat
202 (trans_sel
, pick_windows_recur(c
, selected
, raise
));
206 modals
= g_list_concat
207 (modals
, pick_windows_recur(c
, selected
, raise
));
209 modal_sel
= g_list_concat
210 (modal_sel
, pick_windows_recur(c
, selected
, raise
));
213 /* if we dont have a prev then start back at the beginning,
214 otherwise skip back to the prev's next */
215 next
= prev
? g_list_next(prev
) : stacking_list
;
219 ret
= g_list_concat((raise
? modal_sel
: modals
),
220 (raise
? modals
: modal_sel
));
222 ret
= g_list_concat(ret
, (raise
? trans_sel
: trans
));
223 ret
= g_list_concat(ret
, (raise
? trans
: trans_sel
));
227 ret
= g_list_append(ret
, top
);
232 static GList
*pick_group_windows_recur(ObClient
*top
, ObClient
*selected
,
233 gboolean raise
, gboolean normal
)
236 GList
*it
, *next
, *prev
;
240 /* add group members in their stacking order */
243 n
= g_slist_length(top
->group
->members
) - 1;
244 for (it
= stacking_list
; i
< n
&& it
; it
= next
) {
245 prev
= g_list_previous(it
);
246 next
= g_list_next(it
);
248 if ((sit
= g_slist_find(top
->group
->members
, it
->data
))) {
256 if ((c
->desktop
== selected
->desktop
||
257 c
->desktop
== DESKTOP_ALL
) &&
258 (t
== OB_CLIENT_TYPE_TOOLBAR
||
259 t
== OB_CLIENT_TYPE_MENU
||
260 t
== OB_CLIENT_TYPE_UTILITY
||
261 (normal
&& t
== OB_CLIENT_TYPE_NORMAL
)))
263 ret
= g_list_concat(ret
,
264 pick_windows_recur(sit
->data
,
266 /* if we dont have a prev then start back at the beginning,
267 otherwise skip back to the prev's next */
268 next
= prev
? g_list_next(prev
) : stacking_list
;
276 static GList
*pick_windows(ObClient
*selected
, gboolean raise
, gboolean group
)
279 GSList
*top
, *top_it
;
280 GSList
*top_reorder
= NULL
;
283 top
= client_search_top_transients(selected
);
285 /* go thru stacking list backwords so we can use g_slist_prepend */
286 for (it
= g_list_last(stacking_list
); it
&& top
;
287 it
= g_list_previous(it
))
288 if ((top_it
= g_slist_find(top
, it
->data
))) {
289 top_reorder
= g_slist_prepend(top_reorder
, top_it
->data
);
290 top
= g_slist_delete_link(top
, top_it
);
292 g_assert(top
== NULL
);
294 for (top_it
= top_reorder
; top_it
; top_it
= g_slist_next(top_it
))
295 ret
= g_list_concat(ret
,
296 pick_windows_recur(top_it
->data
, selected
, raise
));
298 for (top_it
= top_reorder
; top_it
; top_it
= g_slist_next(top_it
))
299 ret
= g_list_concat(ret
,
300 pick_group_windows_recur(top_it
->data
,
301 selected
, raise
, group
));
305 void stacking_raise(ObWindow
*window
, gboolean group
)
309 if (WINDOW_IS_CLIENT(window
)) {
311 selected
= WINDOW_AS_CLIENT(window
);
312 wins
= pick_windows(selected
, TRUE
, group
);
314 wins
= g_list_append(NULL
, window
);
315 stacking_list
= g_list_remove(stacking_list
, window
);
321 void stacking_lower(ObWindow
*window
, gboolean group
)
325 if (WINDOW_IS_CLIENT(window
)) {
327 selected
= WINDOW_AS_CLIENT(window
);
328 wins
= pick_windows(selected
, FALSE
, group
);
330 wins
= g_list_append(NULL
, window
);
331 stacking_list
= g_list_remove(stacking_list
, window
);
337 void stacking_below(ObWindow
*window
, ObWindow
*below
)
339 GList
*wins
, *before
;
341 if (window_layer(window
) != window_layer(below
))
344 wins
= g_list_append(NULL
, window
);
345 stacking_list
= g_list_remove(stacking_list
, window
);
346 before
= g_list_next(g_list_find(stacking_list
, below
));
347 do_restack(wins
, before
);
351 void stacking_add(ObWindow
*win
)
353 g_assert(screen_support_win
!= None
); /* make sure I dont break this in the
356 stacking_list
= g_list_append(stacking_list
, win
);
357 stacking_raise(win
, FALSE
);
360 void stacking_add_nonintrusive(ObWindow
*win
)
363 ObClient
*parent
= NULL
;
364 GList
*it_below
= NULL
;
366 if (!WINDOW_IS_CLIENT(win
)) {
367 stacking_add(win
); /* no special rules for others */
371 client
= WINDOW_AS_CLIENT(win
);
373 /* insert above its highest parent */
374 if (client
->transient_for
) {
375 if (client
->transient_for
!= OB_TRAN_GROUP
) {
376 parent
= client
->transient_for
;
382 for (it
= stacking_list
; !parent
&& it
; it
= g_list_next(it
)) {
383 if ((sit
= g_slist_find(client
->group
->members
, it
->data
)))
384 for (sit
= client
->group
->members
; !parent
&& sit
;
385 sit
= g_slist_next(sit
))
387 ObClient
*c
= sit
->data
;
388 /* checking transient_for prevents infinate loops! */
389 if (sit
->data
== it
->data
&& !c
->transient_for
)
396 if (!(it_below
= g_list_find(stacking_list
, parent
))) {
397 /* no parent to put above, try find the focused client to go
399 if (focus_client
&& focus_client
->layer
== client
->layer
) {
400 if ((it_below
= g_list_find(stacking_list
, focus_client
)))
401 it_below
= it_below
->next
;
405 /* out of ideas, just add it normally... */
408 /* make sure it's not in the wrong layer though ! */
409 for (; it_below
; it_below
= g_list_next(it_below
))
411 /* stop when the window is not in a higher layer than the window
412 it is going above (it_below) */
413 if (client
->layer
>= window_layer(it_below
->data
))
416 for (; it_below
!= stacking_list
;
417 it_below
= g_list_previous(it_below
))
419 /* stop when the window is not in a lower layer than the
420 window it is going under (it_above) */
421 GList
*it_above
= g_list_previous(it_below
);
422 if (client
->layer
<= window_layer(it_above
->data
))
426 GList
*wins
= g_list_append(NULL
, win
);
427 do_restack(wins
, it_below
);
This page took 0.052806 seconds and 4 git commands to generate.