raise menus above clients.
[mikachu/openbox.git] / openbox / stacking.c
1 #include "openbox.h"
2 #include "prop.h"
3 #include "focus.h"
4 #include "client.h"
5 #include "group.h"
6 #include "frame.h"
7 #include <glib.h>
8
9 GList  *stacking_list = NULL;
10
11 static Window top_window = None;
12
13 void stacking_startup()
14 {
15     XSetWindowAttributes attrib;
16     attrib.override_redirect = TRUE;
17     top_window =  XCreateWindow(ob_display, ob_root,
18                                 -100, -100, 1, 1, 0,
19                                 CopyFromParent, InputOutput, CopyFromParent,
20                                 CWOverrideRedirect, &attrib);
21     XMapWindow(ob_display, top_window);
22 }
23
24 void stacking_shutdown()
25 {
26     XDestroyWindow(ob_display, top_window);
27 }
28
29 void stacking_set_list()
30 {
31     Window *windows, *win_it;
32     GList *it;
33     guint size = g_list_length(stacking_list);
34
35     /* on shutdown, don't update the properties, so that we can read it back
36        in on startup and re-stack the windows as they were before we shut down
37     */
38     if (ob_state == State_Exiting) return;
39
40     /* create an array of the window ids (from bottom to top,
41        reverse order!) */
42     if (size > 0) {
43         windows = g_new(Window, size);
44         win_it = windows;
45         for (it = g_list_last(stacking_list); it != NULL;
46              it = it->prev, ++win_it)
47             *win_it = ((Client*)it->data)->window;
48     } else
49         windows = NULL;
50
51     PROP_SETA32(ob_root, net_client_list_stacking, window,
52                 (guint32*)windows, size);
53
54     if (windows)
55         g_free(windows);
56 }
57
58 static GList *find_lowest_transient(Client *c)
59 {
60     GList *it;
61     GSList *sit;
62
63     for (it = g_list_last(stacking_list); it; it = it->prev)
64         for (sit = c->transients; sit; sit = sit->next)
65             if (it->data == sit->data) /* found a transient */
66                 return it;
67     return NULL;
68 }
69
70 static void raise_recursive(Client *client)
71 {
72     Window wins[2];  /* only ever restack 2 windows. */
73     GList *it;
74     GSList *sit;
75
76     g_assert(stacking_list != NULL); /* this would be bad */
77
78     /* remove the client before looking so we can't run into ourselves and our
79        transients can't either. */
80     stacking_list = g_list_remove(stacking_list, client);
81
82     /* raise transients first */
83     for (sit = client->transients; sit; sit = sit->next)
84         raise_recursive(sit->data);
85
86     /* find 'it' where it is the positiion in the stacking order where
87        'client' will be inserted *before* */
88
89     it = find_lowest_transient(client);
90     if (it)
91         it = it->next;
92     else {
93         /* the stacking list is from highest to lowest */
94         for (it = stacking_list; it; it = it->next) {
95             if (client->layer >= ((Client*)it->data)->layer)
96                 break;
97         }
98     }
99
100     /*
101       if our new position is the top, we want to stack under the focus_backup.
102       otherwise, we want to stack under the previous window in the stack.
103     */
104     if (it == stacking_list)
105         wins[0] = focus_backup;
106     else if (it != NULL)
107         wins[0] = ((Client*)it->prev->data)->frame->window;
108     else
109         wins[0] = ((Client*)g_list_last(stacking_list)->data)->frame->window;
110     wins[1] = client->frame->window;
111
112     stacking_list = g_list_insert_before(stacking_list, it, client);
113
114     XRestackWindows(ob_display, wins, 2);
115 }
116
117 void stacking_raise(Client *client)
118 {
119     g_assert(stacking_list != NULL); /* this would be bad */
120
121     /* move up the transient chain as far as possible first */
122     while (client->transient_for) {
123         if (client->transient_for != TRAN_GROUP) {
124             client = client->transient_for;
125         } else {
126             GSList *it;
127
128             /* the check for TRAN_GROUP is to prevent an infinate loop with
129                2 transients of the same group at the head of the group's
130                members list */
131             for (it = client->group->members; it; it = it->next) {
132                 Client *c = it->data;
133
134                 if (c != client && c->transient_for != TRAN_GROUP) {
135                     client = it->data;
136                     break;
137                 }
138             }
139             if (it == NULL) break;
140         }
141     }
142
143     raise_recursive(client);
144
145     stacking_set_list();
146 }
147
148 static void lower_recursive(Client *client, Client *above)
149 {
150     Window wins[2];  /* only ever restack 2 windows. */
151     GList *it;
152     GSList *sit;
153
154     /* find 'it' where 'it' is the position in the stacking_list where the
155        'client' will be placed *after* */
156
157     for (it = g_list_last(stacking_list); it != stacking_list; it = it->prev)
158         if (client->layer <= ((Client*)it->data)->layer && it->data != above)
159             break;
160
161     if (it->data != client) { /* not already the bottom */
162         wins[0] = ((Client*)it->data)->frame->window;
163         wins[1] = client->frame->window;
164
165         stacking_list = g_list_remove(stacking_list, client);
166         stacking_list = g_list_insert_before(stacking_list, it->next, client);
167         XRestackWindows(ob_display, wins, 2);
168     }
169
170     for (sit = client->transients; sit; sit = sit->next)
171         lower_recursive(sit->data, client);
172 }
173
174 void stacking_lower(Client *client)
175 {
176     g_assert(stacking_list != NULL); /* this would be bad */
177
178     /* move up the transient chain as far as possible first */
179     while (client->transient_for) {
180         if (client->transient_for != TRAN_GROUP) {
181             client = client->transient_for;
182         } else {
183             GSList *it;
184
185             /* the check for TRAN_GROUP is to prevent an infinate loop with
186                2 transients of the same group at the head of the group's
187                members list */
188             for (it = client->group->members; it; it = it->next) {
189                 Client *c = it->data;
190
191                 if (c != client && c->transient_for != TRAN_GROUP) {
192                     client = it->data;
193                     break;
194                 }
195             }
196             if (it == NULL) break;
197         }
198     }
199
200     lower_recursive(client, NULL);
201
202     stacking_set_list();
203 }
204
205 void stacking_raise_internal(Window win)
206 {
207     Window wins[2];  /* only ever restack 2 windows. */
208
209     wins[0] = top_window;
210     wins[1] = win;
211
212     XRestackWindows(ob_display, wins, 2);
213 }