put group members above the window when lowering it

[chaz/openbox] / openbox / stacking.c

diff --git a/openbox/stacking.c b/openbox/stacking.c
index 220399d45be824334f9b9e3b78ea5d19a54a0498..f8e66dd9526e38f065f7f3ec7b2d32be6a0fb3d1 100644 (file)
--- a/openbox/stacking.c
+++ b/openbox/stacking.c
@@ -11,9 +11,9 @@ GList  *stacking_list = NULL;
 
 void stacking_set_list()
 {
-    Window *windows, *win_it;
+    Window *windows = NULL;
     GList *it;
-    guint size = g_list_length(stacking_list);
+    guint i = 0;
 
     /* on shutdown, don't update the properties, so that we can read it back
        in on startup and re-stack the windows as they were before we shut down
@@ -22,23 +22,18 @@ void stacking_set_list()
 
     /* create an array of the window ids (from bottom to top,
        reverse order!) */
-    if (size > 0) {
-       windows = g_new(Window, size);
-       win_it = windows;
-       for (it = g_list_last(stacking_list); it != NULL;
-             it = it->prev)
-            if (WINDOW_IS_CLIENT(it->data)) {
-                *win_it = WINDOW_AS_CLIENT(it->data)->window;
-                ++win_it;
-            }
-    } else
-       windows = win_it = NULL;
+    if (stacking_list) {
+       windows = g_new(Window, g_list_length(stacking_list));
+        for (it = g_list_last(stacking_list); it; it = g_list_previous(it)) {
+            if (WINDOW_IS_CLIENT(it->data))
+                windows[i++] = WINDOW_AS_CLIENT(it->data)->window;
+        }
+    }
 
     PROP_SETA32(ob_root, net_client_list_stacking, window,
-                (guint32*)windows, win_it - windows);
+                (guint32*)windows, i);
 
-    if (windows)
-       g_free(windows);
+    g_free(windows);
 }
 
 static void do_restack(GList *wins, GList *before)
@@ -69,8 +64,17 @@ static void do_restack(GList *wins, GList *before)
         stacking_list = g_list_insert_before(stacking_list, before, it->data);
     }
 
+    /* XXX some debug checking of the stacking list's order */
+    for (it = stacking_list; ; it = next) {
+        next = g_list_next(it);
+        if (!next) break;
+        g_assert(window_layer(it->data) >= window_layer(next->data));
+    }
+
     XRestackWindows(ob_display, win, i);
     g_free(win);
+
+    stacking_set_list();
 }
 
 static void raise(GList *wins)
@@ -127,7 +131,7 @@ static void lower(GList *wins)
     }
 }
 
-static GList* pick_windows(ObWindow *win)
+static GList *pick_windows(ObWindow *win)
 {
     GList *ret = NULL;
     GList *it, *next;
@@ -140,8 +144,12 @@ static GList* pick_windows(ObWindow *win)
         stacking_list = g_list_remove(stacking_list, win);
         return ret;
     }
+
     c = WINDOW_AS_CLIENT(win);
 
+    /* remove first so we can't run into ourself */
+    stacking_list = g_list_remove(stacking_list, win);
+
     /* add transient children in their stacking order */
     i = 0;
     n = g_slist_length(c->transients);
@@ -150,49 +158,96 @@ static GList* pick_windows(ObWindow *win)
         if ((sit = g_slist_find(c->transients, it->data))) {
             ++i;
             ret = g_list_concat(ret, pick_windows(sit->data));
+            it = stacking_list;
         }
     }
 
     /* add itself */
-    if (g_list_find(stacking_list, win)) {
-        ret = g_list_append(ret, win);
-        stacking_list = g_list_remove(stacking_list, win);
-    }
+    ret = g_list_append(ret, win);
+
+    return ret;
+}
+
+static GList *pick_group_windows(ObWindow *win)
+{
+    GList *ret = NULL;
+    GList *it, *next;
+    GSList *sit;
+    Client *c;
+    int i, n;
+
+    if (!WINDOW_IS_CLIENT(win))
+        return NULL;
+
+    c = WINDOW_AS_CLIENT(win);
 
     /* add group members in their stacking order */
     if (c->group) {
-        for (it = stacking_list; it; it = next) {
+        i = 0;
+        n = g_slist_length(c->group->members) - 1;
+        for (it = stacking_list; i < n && it; it = next) {
             next = g_list_next(it);
             if ((sit = g_slist_find(c->group->members, it->data))) {
-                ret = g_list_append(ret, sit->data);
-                stacking_list = g_list_remove(stacking_list, sit->data);
+                ++i;
+                ret = g_list_concat(ret, pick_windows(sit->data)); 
+                it = stacking_list;
             }
         }
     }
+    return ret;
+}
 
-    if (c->transient_for && c->transient_for != TRAN_GROUP)
-        /* dont add it twice */
-        if (g_list_find(stacking_list, c->transient_for))
-            ret = g_list_concat(ret, pick_windows
-                                (CLIENT_AS_WINDOW(c->transient_for)));
+static ObWindow *top_transient(ObWindow *window)
+{
+    Client *client;
 
-    return ret;
+    if (!WINDOW_IS_CLIENT(window))
+        return window;
+
+    client = WINDOW_AS_CLIENT(window);
+
+    /* move up the transient chain as far as possible */
+    if (client->transient_for) {
+        if (client->transient_for != TRAN_GROUP) {
+            return top_transient(CLIENT_AS_WINDOW(client->transient_for));
+        } else {
+            GSList *it;
+
+            for (it = client->group->members; it; it = it->next) {
+                Client *c = it->data;
+
+                /* checking transient_for prevents infinate loops! */
+                if (c != client && !c->transient_for)
+                    break;
+            }
+            if (it)
+                return it->data;
+        }
+    }
+
+    return window;
 }
 
 void stacking_raise(ObWindow *window)
 {
     GList *wins;
 
+    window = top_transient(window);
     wins = pick_windows(window);
+    wins = g_list_concat(wins, pick_group_windows(window));
     raise(wins);
+    g_list_free(wins);
 }
 
 void stacking_lower(ObWindow *window)
 {
     GList *wins;
 
+    window = top_transient(window);
     wins = pick_windows(window);
+    wins = g_list_concat(pick_group_windows(window), wins);
     lower(wins);
+    g_list_free(wins);
 }
 
 void stacking_add(ObWindow *win)