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);