]>
Dogcows Code - chaz/openbox/blob - openbox/stacking.c
10 GList
*stacking_list
= NULL
;
12 void stacking_set_list()
14 Window
*windows
, *win_it
;
16 guint size
= g_list_length(stacking_list
);
18 /* on shutdown, don't update the properties, so that we can read it back
19 in on startup and re-stack the windows as they were before we shut down
21 if (ob_state
== State_Exiting
) return;
23 /* create an array of the window ids (from bottom to top,
26 windows
= g_new(Window
, size
);
28 for (it
= g_list_last(stacking_list
); it
!= NULL
;
30 if (WINDOW_IS_CLIENT(it
->data
)) {
31 *win_it
= WINDOW_AS_CLIENT(it
->data
)->window
;
35 windows
= win_it
= NULL
;
37 PROP_SETA32(ob_root
, net_client_list_stacking
, window
,
38 (guint32
*)windows
, win_it
- windows
);
44 static GList
*find_lowest_transient(Client
*c
)
49 for (it
= g_list_last(stacking_list
); it
; it
= it
->prev
)
50 for (sit
= c
->transients
; sit
; sit
= sit
->next
)
51 if (it
->data
== sit
->data
) /* found a transient */
56 static void raise_recursive(ObWindow
*window
)
58 Window wins
[2]; /* only ever restack 2 windows. */
62 g_assert(stacking_list
!= NULL
); /* this would be bad */
64 /* remove the window before looking so we can't run into ourselves and our
65 transients can't either. */
66 stacking_list
= g_list_remove(stacking_list
, window
);
68 /* raise transients first */
69 if (WINDOW_IS_CLIENT(window
)) {
70 Client
*client
= WINDOW_AS_CLIENT(window
);
71 for (sit
= client
->transients
; sit
; sit
= sit
->next
)
72 raise_recursive(sit
->data
);
75 /* find 'it' where it is the positiion in the stacking order where
76 'window' will be inserted *before* */
78 if (WINDOW_IS_CLIENT(window
))
79 low
= find_lowest_transient(WINDOW_AS_CLIENT(window
));
82 /* the stacking list is from highest to lowest */
83 for (it
= g_list_last(stacking_list
); it
; it
= it
->prev
) {
84 if (it
== low
|| window_layer(window
) < window_layer(it
->data
)) {
88 if (it
== stacking_list
)
93 if our new position is the top, we want to stack under the focus_backup.
94 otherwise, we want to stack under the previous window in the stack.
96 if (it
== stacking_list
)
97 wins
[0] = focus_backup
;
99 wins
[0] = window_top(it
->prev
->data
);
101 wins
[0] = window_top(g_list_last(stacking_list
)->data
);
102 wins
[1] = window_top(window
);
104 stacking_list
= g_list_insert_before(stacking_list
, it
, window
);
106 XRestackWindows(ob_display
, wins
, 2);
109 void stacking_raise(ObWindow
*window
)
111 g_assert(stacking_list
!= NULL
); /* this would be bad */
113 g_message("RAISING");
115 if (WINDOW_IS_CLIENT(window
)) {
116 Client
*client
= WINDOW_AS_CLIENT(window
);
118 /* move up the transient chain as far as possible first */
119 if (client
->transient_for
) {
120 if (client
->transient_for
!= TRAN_GROUP
) {
121 stacking_raise(CLIENT_AS_WINDOW(client
->transient_for
));
125 gboolean raised
= FALSE
;
127 for (it
= client
->group
->members
; it
; it
= it
->next
) {
128 Client
*c
= it
->data
;
130 /* checking transient_for prevents infinate loops! */
131 if (c
!= client
&& !c
->transient_for
) {
132 stacking_raise(it
->data
);
141 raise_recursive(window
);
146 static void lower_recursive(ObWindow
*window
, ObWindow
*above
)
148 Window wins
[2]; /* only ever restack 2 windows. */
152 /* find 'it' where 'it' is the position in the stacking_list where the
153 'window' will be placed *after* */
155 for (it
= g_list_last(stacking_list
); it
!= stacking_list
; it
= it
->prev
)
156 if (window_layer(window
) <= window_layer(it
->data
) &&
160 if (it
->data
!= window
) { /* not already the bottom */
161 wins
[0] = window_top(it
->data
);
162 wins
[1] = window_top(window
);
164 stacking_list
= g_list_remove(stacking_list
, window
);
165 stacking_list
= g_list_insert_before(stacking_list
, it
->next
, window
);
166 XRestackWindows(ob_display
, wins
, 2);
169 if (WINDOW_IS_CLIENT(window
)) {
170 Client
*client
= WINDOW_AS_CLIENT(window
);
171 for (sit
= client
->transients
; sit
; sit
= sit
->next
)
172 lower_recursive(CLIENT_AS_WINDOW(sit
->data
), window
);
176 void stacking_lower(ObWindow
*window
)
178 g_assert(stacking_list
!= NULL
); /* this would be bad */
180 if (WINDOW_IS_CLIENT(window
)) {
181 Client
*client
= WINDOW_AS_CLIENT(window
);
182 /* move up the transient chain as far as possible first */
183 while (client
->transient_for
) {
184 if (client
->transient_for
!= TRAN_GROUP
) {
185 stacking_lower(CLIENT_AS_WINDOW(client
->transient_for
));
190 for (it
= client
->group
->members
; it
; it
= it
->next
) {
191 Client
*c
= it
->data
;
193 /* checking transient_for prevents infinate loops! */
194 if (c
!= client
&& !c
->transient_for
)
195 stacking_lower(it
->data
);
197 if (it
== NULL
) return;
200 window
= CLIENT_AS_WINDOW(client
);
203 lower_recursive(window
, NULL
);
208 void stacking_add(ObWindow
*win
)
210 stacking_list
= g_list_append(stacking_list
, win
);
214 void stacking_add_nonintrusive(ObWindow
*win
)
216 Window wins
[2]; /* only ever restack 2 windows. */
218 if (!WINDOW_IS_CLIENT(win
))
219 stacking_add(win
); /* no special rules for others */
221 Client
*client
= WINDOW_AS_CLIENT(win
);
222 Client
*parent
= NULL
;
223 GList
*it_before
= NULL
;
225 /* insert above its highest parent */
226 if (client
->transient_for
) {
227 if (client
->transient_for
!= TRAN_GROUP
) {
228 parent
= client
->transient_for
;
233 for (it
= stacking_list
; !parent
&& it
; it
= it
->next
) {
234 for (sit
= client
->group
->members
; !parent
&& sit
;
236 Client
*c
= sit
->data
;
237 /* checking transient_for prevents infinate loops! */
238 if (sit
->data
== it
->data
&& !c
->transient_for
)
245 if (!(it_before
= g_list_find(stacking_list
, parent
))) {
246 /* no parent to put above, try find the focused client to go
248 if (focus_client
&& focus_client
->layer
== client
->layer
) {
249 if ((it_before
= g_list_find(stacking_list
, focus_client
)))
250 it_before
= it_before
->next
;
254 /* out of ideas, just add it normally... */
257 stacking_list
= g_list_insert_before(stacking_list
, it_before
,win
);
259 it_before
= g_list_find(stacking_list
, win
)->prev
;
261 wins
[0] = focus_backup
;
263 wins
[0] = window_top(it_before
->data
);
264 wins
[1] = window_top(win
);
266 XRestackWindows(ob_display
, wins
, 2);
This page took 0.043877 seconds and 4 git commands to generate.