]>
Dogcows Code - chaz/openbox/blob - openbox/stacking.c
11 GList
*stacking_list
= NULL
;
13 void stacking_set_list()
15 Window
*windows
= NULL
;
19 /* on shutdown, don't update the properties, so that we can read it back
20 in on startup and re-stack the windows as they were before we shut down
22 if (ob_state
== OB_STATE_EXITING
) return;
24 /* create an array of the window ids (from bottom to top,
27 windows
= g_new(Window
, g_list_length(stacking_list
));
28 for (it
= g_list_last(stacking_list
); it
; it
= g_list_previous(it
)) {
29 if (WINDOW_IS_CLIENT(it
->data
))
30 windows
[i
++] = WINDOW_AS_CLIENT(it
->data
)->window
;
34 PROP_SETA32(ob_root
, net_client_list_stacking
, window
,
35 (guint32
*)windows
, i
);
40 static void do_restack(GList
*wins
, GList
*before
)
46 /* pls only restack stuff in the same layer at a time */
47 for (it
= wins
; it
; it
= next
) {
48 next
= g_list_next(it
);
50 g_assert (window_layer(it
->data
) == window_layer(next
->data
));
54 win
= g_new(Window
, g_list_length(wins
) + 1);
56 if (before
== stacking_list
)
57 win
[0] = screen_support_win
;
59 win
[0] = window_top(g_list_last(stacking_list
)->data
);
61 win
[0] = window_top(g_list_previous(before
)->data
);
63 for (i
= 1, it
= wins
; it
; ++i
, it
= g_list_next(it
)) {
64 win
[i
] = window_top(it
->data
);
65 g_assert(win
[i
] != None
); /* better not call stacking shit before
66 setting your top level window value */
67 stacking_list
= g_list_insert_before(stacking_list
, before
, it
->data
);
70 /* XXX some debug checking of the stacking list's order */
71 for (it
= stacking_list
; ; it
= next
) {
72 next
= g_list_next(it
);
74 g_assert(window_layer(it
->data
) >= window_layer(next
->data
));
77 XRestackWindows(ob_display
, win
, i
);
83 static void do_raise(GList
*wins
)
86 GList
*layer
[OB_NUM_STACKING_LAYERS
] = {NULL
};
89 for (it
= wins
; it
; it
= g_list_next(it
)) {
92 l
= window_layer(it
->data
);
93 layer
[l
] = g_list_append(layer
[l
], it
->data
);
97 for (i
= OB_NUM_STACKING_LAYERS
- 1; i
>= 0; --i
) {
99 for (; it
; it
= g_list_next(it
)) {
100 /* look for the top of the layer */
101 if (window_layer(it
->data
) <= (ObStackingLayer
) i
)
104 do_restack(layer
[i
], it
);
105 g_list_free(layer
[i
]);
110 static void do_lower(GList
*wins
)
113 GList
*layer
[OB_NUM_STACKING_LAYERS
] = {NULL
};
116 for (it
= wins
; it
; it
= g_list_next(it
)) {
119 l
= window_layer(it
->data
);
120 layer
[l
] = g_list_append(layer
[l
], it
->data
);
124 for (i
= OB_NUM_STACKING_LAYERS
- 1; i
>= 0; --i
) {
126 for (; it
; it
= g_list_next(it
)) {
127 /* look for the top of the next layer down */
128 if (window_layer(it
->data
) < (ObStackingLayer
) i
)
131 do_restack(layer
[i
], it
);
132 g_list_free(layer
[i
]);
137 static GList
*pick_windows(ObClient
*top
, ObClient
*selected
, gboolean raise
)
140 GList
*it
, *next
, *prev
;
143 GList
*modals
= NULL
;
145 GList
*modal_sel_it
= NULL
; /* the selected guy if modal */
146 GList
*trans_sel_it
= NULL
; /* the selected guy if not */
148 /* remove first so we can't run into ourself */
149 stacking_list
= g_list_remove(stacking_list
, top
);
152 n
= g_slist_length(top
->transients
);
153 for (it
= stacking_list
; i
< n
&& it
; it
= next
) {
154 prev
= g_list_previous(it
);
155 next
= g_list_next(it
);
157 if ((sit
= g_slist_find(top
->transients
, it
->data
))) {
158 ObClient
*c
= sit
->data
;
164 trans
= g_list_concat(trans
,
165 pick_windows(c
, selected
, raise
));
167 g_assert(modal_sel_it
== NULL
);
168 g_assert(trans_sel_it
== NULL
);
169 trans_sel_it
= pick_windows(c
, selected
, raise
);
173 modals
= g_list_concat(modals
,
174 pick_windows(c
, selected
, raise
));
176 g_assert(modal_sel_it
== NULL
);
177 g_assert(trans_sel_it
== NULL
);
178 modal_sel_it
= pick_windows(c
, selected
, raise
);
181 /* if we dont have a prev then start back at the beginning,
182 otherwise skip back to the prev's next */
183 next
= prev
? g_list_next(prev
) : stacking_list
;
187 ret
= g_list_concat((raise
? modal_sel_it
: modals
),
188 (raise
? modals
: modal_sel_it
));
190 ret
= g_list_concat(ret
, (raise
? trans_sel_it
: trans
));
191 ret
= g_list_concat(ret
, (raise
? trans
: trans_sel_it
));
195 ret
= g_list_append(ret
, top
);
200 static GList
*pick_group_windows(ObClient
*top
, ObClient
*selected
, gboolean raise
)
203 GList
*it
, *next
, *prev
;
207 /* add group members in their stacking order */
210 n
= g_slist_length(top
->group
->members
) - 1;
211 for (it
= stacking_list
; i
< n
&& it
; it
= next
) {
212 prev
= g_list_previous(it
);
213 next
= g_list_next(it
);
215 if ((sit
= g_slist_find(top
->group
->members
, it
->data
))) {
217 ret
= g_list_concat(ret
,
218 pick_windows(sit
->data
, selected
, raise
));
219 /* if we dont have a prev then start back at the beginning,
220 otherwise skip back to the prev's next */
221 next
= prev
? g_list_next(prev
) : stacking_list
;
228 void stacking_raise(ObWindow
*window
)
232 if (WINDOW_IS_CLIENT(window
)) {
235 selected
= WINDOW_AS_CLIENT(window
);
236 c
= client_search_top_transient(selected
);
237 wins
= pick_windows(c
, selected
, TRUE
);
238 wins
= g_list_concat(wins
, pick_group_windows(c
, selected
, TRUE
));
240 wins
= g_list_append(NULL
, window
);
241 stacking_list
= g_list_remove(stacking_list
, window
);
247 void stacking_lower(ObWindow
*window
)
251 if (WINDOW_IS_CLIENT(window
)) {
254 selected
= WINDOW_AS_CLIENT(window
);
255 c
= client_search_top_transient(selected
);
256 wins
= pick_windows(c
, selected
, FALSE
);
257 wins
= g_list_concat(pick_group_windows(c
, selected
, FALSE
), wins
);
259 wins
= g_list_append(NULL
, window
);
260 stacking_list
= g_list_remove(stacking_list
, window
);
266 void stacking_add(ObWindow
*win
)
271 g_assert(screen_support_win
!= None
); /* make sure I dont break this in the
274 l
= window_layer(win
);
275 wins
= g_list_append(NULL
, win
); /* list of 1 element */
277 stacking_list
= g_list_append(stacking_list
, win
);
281 void stacking_add_nonintrusive(ObWindow
*win
)
284 ObClient
*parent
= NULL
;
285 GList
*it_before
= NULL
;
287 if (!WINDOW_IS_CLIENT(win
)) {
288 stacking_add(win
); /* no special rules for others */
292 client
= WINDOW_AS_CLIENT(win
);
294 /* insert above its highest parent */
295 if (client
->transient_for
) {
296 if (client
->transient_for
!= OB_TRAN_GROUP
) {
297 parent
= client
->transient_for
;
303 for (it
= stacking_list
; !parent
&& it
; it
= it
->next
) {
304 if ((sit
= g_slist_find(client
->group
->members
, it
->data
)))
305 for (sit
= client
->group
->members
; !parent
&& sit
;
307 ObClient
*c
= sit
->data
;
308 /* checking transient_for prevents infinate loops! */
309 if (sit
->data
== it
->data
&& !c
->transient_for
)
316 if (!(it_before
= g_list_find(stacking_list
, parent
))) {
317 /* no parent to put above, try find the focused client to go
319 if (focus_client
&& focus_client
->layer
== client
->layer
) {
320 if ((it_before
= g_list_find(stacking_list
, focus_client
)))
321 it_before
= it_before
->next
;
325 /* out of ideas, just add it normally... */
328 GList
*wins
= g_list_append(NULL
, win
);
329 do_restack(wins
, it_before
);
This page took 0.049747 seconds and 4 git commands to generate.