X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fstacking.c;h=6ff01721061fbc63c3aa7e513d5f2ad049822619;hb=02c7f2e8afbfe5ebc589415a87a2ac156c9ef5af;hp=c251f17ba6f1f441ce2c735ee6c945397245da45;hpb=580795fe6a4b5d070f01065b309f1789cf0d0dbb;p=chaz%2Fopenbox

diff --git a/openbox/stacking.c b/openbox/stacking.c
index c251f17b..6ff01721 100644
--- a/openbox/stacking.c
+++ b/openbox/stacking.c
@@ -8,6 +8,24 @@
 
 GList  *stacking_list = NULL;
 
+static Window top_window = None;
+
+void stacking_startup()
+{
+    XSetWindowAttributes attrib;
+    attrib.override_redirect = TRUE;
+    top_window =  XCreateWindow(ob_display, ob_root,
+                                -100, -100, 1, 1, 0,
+                                CopyFromParent, InputOutput, CopyFromParent,
+                                CWOverrideRedirect, &attrib);
+    XMapWindow(ob_display, top_window);
+}
+
+void stacking_shutdown()
+{
+    XDestroyWindow(ob_display, top_window);
+}
+
 void stacking_set_list()
 {
     Window *windows, *win_it;
@@ -30,7 +48,8 @@ void stacking_set_list()
     } else
 	windows = NULL;
 
-    PROP_SET32A(ob_root, net_client_list_stacking, window, windows, size);
+    PROP_SETA32(ob_root, net_client_list_stacking, window,
+                (guint32*)windows, size);
 
     if (windows)
 	g_free(windows);
@@ -44,12 +63,11 @@ static GList *find_lowest_transient(Client *c)
     for (it = g_list_last(stacking_list); it; it = it->prev)
         for (sit = c->transients; sit; sit = sit->next)
             if (it->data == sit->data) /* found a transient */
-                if (((Client*)it->data)->layer == c->layer) /* same layer? */
-                    return it;
+                return it;
     return NULL;
 }
 
-void stacking_raise(Client *client)
+static void raise_recursive(Client *client)
 {
     Window wins[2];  /* only ever restack 2 windows. */
     GList *it;
@@ -57,20 +75,21 @@ void stacking_raise(Client *client)
 
     g_assert(stacking_list != NULL); /* this would be bad */
 
-    /* if we have a transients raise them */
+    /* remove the client before looking so we can't run into ourselves and our
+       transients can't either. */
+    stacking_list = g_list_remove(stacking_list, client);
+
+    /* raise transients first */
     for (sit = client->transients; sit; sit = sit->next)
-        stacking_raise(sit->data);
+        raise_recursive(sit->data);
 
-    /* remove the client before looking so we can't run into ourselves */
-    stacking_list = g_list_remove(stacking_list, client);
-  
     /* find 'it' where it is the positiion in the stacking order where
-       'client' will be inserted *after* */
+       'client' will be inserted *before* */
 
     it = find_lowest_transient(client);
-    if (it) {
+    if (it)
         it = it->next;
-    } else {
+    else {
         /* the stacking list is from highest to lowest */
         for (it = stacking_list; it; it = it->next) {
             if (client->layer >= ((Client*)it->data)->layer)
@@ -93,6 +112,35 @@ void stacking_raise(Client *client)
     stacking_list = g_list_insert_before(stacking_list, it, client);
 
     XRestackWindows(ob_display, wins, 2);
+}
+
+void stacking_raise(Client *client)
+{
+    g_assert(stacking_list != NULL); /* this would be bad */
+
+    /* move up the transient chain as far as possible first */
+    while (client->transient_for) {
+        if (client->transient_for != TRAN_GROUP) {
+            client = client->transient_for;
+        } else {
+            GSList *it;
+
+            /* the check for TRAN_GROUP is to prevent an infinate loop with
+               2 transients of the same group at the head of the group's
+               members list */
+            for (it = client->group->members; it; it = it->next) {
+                Client *c = it->data;
+
+                if (c != client && c->transient_for != TRAN_GROUP) {
+                    client = it->data;
+                    break;
+                }
+            }
+            if (it == NULL) break;
+        }
+    }
+
+    raise_recursive(client);
 
     stacking_set_list();
 }
@@ -103,33 +151,24 @@ static void lower_recursive(Client *client, Client *above)
     GList *it;
     GSList *sit;
 
-    it = g_list_last(stacking_list);
-
     /* find 'it' where 'it' is the position in the stacking_list where the
        'client' will be placed *after* */
 
-    while (it != stacking_list) {
-        Client *c = it->data;
-        if (client->layer <= c->layer && c != above)
+    for (it = g_list_last(stacking_list); it != stacking_list; it = it->prev)
+        if (client->layer <= ((Client*)it->data)->layer && it->data != above)
             break;
-        it = it->prev;
-    }
 
     if (it->data != client) { /* not already the bottom */
         wins[0] = ((Client*)it->data)->frame->window;
         wins[1] = client->frame->window;
 
         stacking_list = g_list_remove(stacking_list, client);
-        stacking_list = g_list_insert_before(stacking_list,
-                                         it->next, client);
+        stacking_list = g_list_insert_before(stacking_list, it->next, client);
         XRestackWindows(ob_display, wins, 2);
     }
 
     for (sit = client->transients; sit; sit = sit->next)
         lower_recursive(sit->data, client);
-
-    if (!above) /* only need to do this once */
-        stacking_set_list();
 }
 
 void stacking_lower(Client *client)
@@ -159,5 +198,16 @@ void stacking_lower(Client *client)
     }
 
     lower_recursive(client, NULL);
+
+    stacking_set_list();
 }
 
+void stacking_raise_internal(Window win)
+{
+    Window wins[2];  /* only ever restack 2 windows. */
+
+    wins[0] = top_window;
+    wins[1] = win;
+
+    XRestackWindows(ob_display, wins, 2);
+}