X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fstacking.c;h=cb8eaf31a996fd72c29dce49d01dd275be80d908;hb=6372bd7c0d68793c2371ce7b6c1aa8017f913aee;hp=c715eae04d9ec40f0815a1a1389a190c14098ecf;hpb=174de91c343dfbdfe866e566393bf4790ae22596;p=chaz%2Fopenbox

diff --git a/openbox/stacking.c b/openbox/stacking.c
index c715eae0..cb8eaf31 100644
--- a/openbox/stacking.c
+++ b/openbox/stacking.c
@@ -1,6 +1,7 @@
 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
 
    stacking.c for the Openbox window manager
+   Copyright (c) 2006        Mikael Magnusson
    Copyright (c) 2003        Ben Jansens
 
    This program is free software; you can redistribute it and/or modify
@@ -41,7 +42,7 @@ void stacking_set_list()
     /* create an array of the window ids (from bottom to top,
        reverse order!) */
     if (stacking_list) {
-	windows = g_new(Window, g_list_length(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;
@@ -49,18 +50,19 @@ void stacking_set_list()
     }
 
     PROP_SETA32(RootWindow(ob_display, ob_screen),
-                net_client_list_stacking, window, (guint32*)windows, i);
+                net_client_list_stacking, window, (gulong*)windows, i);
 
     g_free(windows);
 }
 
 static void do_restack(GList *wins, GList *before)
 {
-    GList *it, *next;
+    GList *it;
     Window *win;
     gint i;
 
 #ifdef DEBUG
+    GList *next;
     /* pls only restack stuff in the same layer at a time */
     for (it = wins; it; it = next) {
         next = g_list_next(it);
@@ -156,157 +158,186 @@ static void do_lower(GList *wins)
     }
 }
 
-static GList *pick_windows(ObClient *top, ObClient *selected, gboolean raise)
+static void restack_windows(ObClient *selected, gboolean raise)
 {
-    GList *ret = NULL;
-    GList *it, *next, *prev;
-    GSList *sit;
-    gint i, n;
+    GList *it, *last, *below, *above, *next;
+    GList *wins = NULL;
+
+    GList *group_modals = NULL;
+    GList *group_trans = NULL;
     GList *modals = NULL;
     GList *trans = NULL;
-    GList *modal_sel = NULL; /* the selected guys if modal */
-    GList *trans_sel = NULL; /* the selected guys if not */
 
-    /* remove first so we can't run into ourself */
-    if ((it = g_list_find(stacking_list, top)))
-        stacking_list = g_list_delete_link(stacking_list, it);
-    else
-        return NULL;
+    if (!raise && selected->transient_for) {
+        GSList *top, *top_it;
+        GSList *top_reorder = NULL;
+        
+        /* if it's a transient lowering, lower its parents so that we can lower
+           this window, or it won't move */
+        top = client_search_all_top_parents(selected);
+
+        /* go thru stacking list backwards so we can use g_slist_prepend */
+        for (it = g_list_last(stacking_list); it && top;
+             it = g_list_previous(it))
+            if ((top_it = g_slist_find(top, it->data))) {
+                top_reorder = g_slist_prepend(top_reorder, top_it->data);
+                top = g_slist_delete_link(top, top_it);
+            }
+        g_assert(top == NULL);
 
-    i = 0;
-    n = g_slist_length(top->transients);
-    for (it = stacking_list; i < n && it; it = next) {
-        prev = g_list_previous(it);
-        next = g_list_next(it);
+        /* call restack for each of these to lower them */
+        for (top_it = top_reorder; top_it; top_it = g_slist_next(top_it))
+            restack_windows(top_it->data, raise);
+        return;
+    }
 
-        if ((sit = g_slist_find(top->transients, it->data))) {
-            ObClient *c = sit->data;
-            gboolean sel_child;
-
-            ++i;
-
-            if (c == selected)
-                sel_child = TRUE;
-            else
-                sel_child = client_search_transient(c, selected) != NULL;
-
-            if (!c->modal) {
-                if (!sel_child) {
-                    trans = g_list_concat(trans,
-                                          pick_windows(c, selected, raise));
-                } else {
-                    trans_sel = g_list_concat(trans_sel,
-                                                 pick_windows(c, selected,
-                                                              raise));
+    /* remove first so we can't run into ourself */
+    it = g_list_find(stacking_list, selected);
+    g_assert(it);
+    stacking_list = g_list_delete_link(stacking_list, it);
+
+    /* go from the bottom of the stacking list up */
+    for (it = g_list_last(stacking_list); it; it = next) {
+        next = g_list_previous(it);
+
+        if (WINDOW_IS_CLIENT(it->data)) {
+            ObClient *ch = it->data;
+
+            /* only move windows in the same stacking layer */
+            if (ch->layer == selected->layer &&
+                client_search_transient(selected, ch))
+            {
+                if (client_is_direct_child(selected, ch)) {
+                    if (ch->modal)
+                        modals = g_list_prepend(modals, ch);
+                    else
+                        trans = g_list_prepend(trans, ch);
                 }
-            } else {
-                if (!sel_child) {
-                    modals = g_list_concat(modals,
-                                           pick_windows(c, selected, raise));
-                } else {
-                    modal_sel = g_list_concat(modal_sel,
-                                                 pick_windows(c, selected,
-                                                              raise));
+                else {
+                    if (ch->modal)
+                        group_modals = g_list_prepend(group_modals, ch);
+                    else
+                        group_trans = g_list_prepend(group_trans, ch);
                 }
+                stacking_list = g_list_delete_link(stacking_list, it);
             }
-            /* if we dont have a prev then start back at the beginning,
-               otherwise skip back to the prev's next */
-            next = prev ? g_list_next(prev) : stacking_list;
         }
     }
 
-    ret = g_list_concat((raise ? modal_sel : modals),
-                        (raise ? modals : modal_sel));
+    /* put transients of the selected window right above it */
+    wins = g_list_concat(modals, trans);
+    wins = g_list_append(wins, selected);
 
-    ret = g_list_concat(ret, (raise ? trans_sel : trans));
-    ret = g_list_concat(ret, (raise ? trans : trans_sel));
+    /* if selected window is transient for group then raise it above others */
+    if (selected->transient_for == OB_TRAN_GROUP) {
+        /* if it's modal, raise it above those also */
+        if (selected->modal) {
+            wins = g_list_concat(wins, group_modals);
+            group_modals = NULL;
+        }
+        wins = g_list_concat(wins, group_trans);
+        group_trans = NULL;
+    }
 
+    /* find where to put the selected window, start from bottom of list,
+       this is the window below everything we are re-adding to the list */
+    last = NULL;
+    for (it = g_list_last(stacking_list); it; it = g_list_previous(it))
+    {
+        if (window_layer(it->data) < selected->layer) {
+            last = it;
+            continue;
+        }
+        /* if lowering, stop at the beginning of the layer */
+        if (!raise)
+            break;
+        /* if raising, stop at the end of the layer */
+        if (window_layer(it->data) > selected->layer)
+            break;
+
+        last = it;
+    }
 
-    /* add itself */
-    ret = g_list_append(ret, top);
+    /* save this position in the stacking list */
+    below = last;
+
+    /* find where to put the group transients, start from the top of list */
+    for (it = stacking_list; it; it = g_list_next(it)) {
+        /* skip past higher layers */
+        if (window_layer(it->data) > selected->layer)
+            continue;
+        /* if we reach the end of the layer (how?) then don't go further */
+        if (window_layer(it->data) < selected->layer)
+            break;
+        /* stop when we reach the first window in the group */
+        if (WINDOW_IS_CLIENT(it->data)) {
+            ObClient *c = it->data;
+            if (c->group == selected->group)
+                break;
+        }
+        /* if we don't hit any other group members, stop here because this
+           is where we are putting the selected window (and its children) */
+        if (it == below)
+            break;
+    }
 
-    return ret;
-}
+    /* save this position, this is the top of the group of windows between the
+       group transient ones we're restacking and the others up above that we're
+       restacking
 
-static GList *pick_group_windows(ObClient *top, ObClient *selected,
-                                 gboolean raise)
-{
-    GList *ret = NULL;
-    GList *it, *next, *prev;
-    GSList *sit;
-    gint i, n;
-
-    /* add group members in their stacking order */
-    if (top->group) {
-        i = 0;
-        n = g_slist_length(top->group->members) - 1;
-        for (it = stacking_list; i < n && it; it = next) {
-            prev = g_list_previous(it);
-            next = g_list_next(it);
-
-            if ((sit = g_slist_find(top->group->members, it->data))) {
-                ObClient *c;
-                ObClientType t;
-
-                ++i;
-                c = it->data;
-                t = c->type;
-
-                if ((c->desktop == selected->desktop ||
-                     c->desktop == DESKTOP_ALL) &&
-                    (t == OB_CLIENT_TYPE_TOOLBAR ||
-                     t == OB_CLIENT_TYPE_MENU ||
-                     t == OB_CLIENT_TYPE_UTILITY))
-                {
-                    ret = g_list_concat(ret,
-                                        pick_windows(sit->data,
-                                                     selected, raise)); 
-                    /* if we dont have a prev then start back at the beginning,
-                       otherwise skip back to the prev's next */
-                    next = prev ? g_list_next(prev) : stacking_list;
-                }
-            }
-        }
+       we actually want to save 1 position _above_ that, for for loops to work
+       nicely, so move back one position in the list while saving it
+    */
+    above = it ? g_list_previous(it) : g_list_last(stacking_list);
+
+    /* put the windows inside the gap to the other windows we're stacking
+       into the restacking list, go from the bottom up so that we can use
+       g_list_prepend */
+    if (below) it = g_list_previous(below);
+    else       it = g_list_last(stacking_list);
+    for (; it != above; it = next) {
+        next = g_list_previous(it);
+        wins = g_list_prepend(wins, it->data);
+        stacking_list = g_list_delete_link(stacking_list, it);
     }
-    return ret;
+
+    /* group transients go above the rest of the stuff acquired to now */
+    wins = g_list_concat(group_trans, wins);
+    /* group modals go on the very top */
+    wins = g_list_concat(group_modals, wins);
+
+    do_restack(wins, below);
+    g_list_free(wins);
 }
 
 void stacking_raise(ObWindow *window)
 {
-    GList *wins;
-
     if (WINDOW_IS_CLIENT(window)) {
-        ObClient *c;
         ObClient *selected;
         selected = WINDOW_AS_CLIENT(window);
-        c = client_search_top_transient(selected);
-        wins = pick_windows(c, selected, TRUE);
-        wins = g_list_concat(wins, pick_group_windows(c, selected, TRUE));
+        restack_windows(selected, TRUE);
     } else {
+        GList *wins;
         wins = g_list_append(NULL, window);
         stacking_list = g_list_remove(stacking_list, window);
+        do_raise(wins);
+        g_list_free(wins);
     }
-    do_raise(wins);
-    g_list_free(wins);
 }
 
 void stacking_lower(ObWindow *window)
 {
-    GList *wins;
-
     if (WINDOW_IS_CLIENT(window)) {
-        ObClient *c;
         ObClient *selected;
         selected = WINDOW_AS_CLIENT(window);
-        c = client_search_top_transient(selected);
-        wins = pick_windows(c, selected, FALSE);
-        wins = g_list_concat(pick_group_windows(c, selected, FALSE), wins);
+        restack_windows(selected, FALSE);
     } else {
+        GList *wins;
         wins = g_list_append(NULL, window);
         stacking_list = g_list_remove(stacking_list, window);
+        do_lower(wins);
+        g_list_free(wins);
     }
-    do_lower(wins);
-    g_list_free(wins);
 }
 
 void stacking_below(ObWindow *window, ObWindow *below)
@@ -325,14 +356,8 @@ void stacking_below(ObWindow *window, ObWindow *below)
 
 void stacking_add(ObWindow *win)
 {
-    ObStackingLayer l;
-    GList *wins;
-
     g_assert(screen_support_win != None); /* make sure I dont break this in the
-                                       future */
-
-    l = window_layer(win);
-    wins = g_list_append(NULL, win); /* list of 1 element */
+                                             future */
 
     stacking_list = g_list_append(stacking_list, win);
     stacking_raise(win);
@@ -342,7 +367,7 @@ void stacking_add_nonintrusive(ObWindow *win)
 {
     ObClient *client;
     ObClient *parent = NULL;
-    GList *it_before = NULL;
+    GList *it_below = NULL;
 
     if (!WINDOW_IS_CLIENT(win)) {
         stacking_add(win); /* no special rules for others */
@@ -374,20 +399,38 @@ void stacking_add_nonintrusive(ObWindow *win)
         }
     }
 
-    if (!(it_before = g_list_find(stacking_list, parent))) {
+    if (!(it_below = g_list_find(stacking_list, parent))) {
         /* no parent to put above, try find the focused client to go
            under */
         if (focus_client && focus_client->layer == client->layer) {
-            if ((it_before = g_list_find(stacking_list, focus_client)))
-                it_before = it_before->next;
+            if ((it_below = g_list_find(stacking_list, focus_client)))
+                it_below = it_below->next;
         }
     }
-    if (!it_before) {
+    if (!it_below) {
         /* out of ideas, just add it normally... */
         stacking_add(win);
     } else {
+        /* make sure it's not in the wrong layer though ! */
+        for (; it_below; it_below = g_list_next(it_below))
+        {
+            /* stop when the window is not in a higher layer than the window
+               it is going above (it_below) */
+            if (client->layer >= window_layer(it_below->data))
+                break;
+        }
+        for (; it_below != stacking_list;
+             it_below = g_list_previous(it_below))
+        {
+            /* stop when the window is not in a lower layer than the
+               window it is going under (it_above) */
+            GList *it_above = g_list_previous(it_below);
+            if (client->layer <= window_layer(it_above->data))
+                break;
+        }
+
         GList *wins = g_list_append(NULL, win);
-        do_restack(wins, it_before);
+        do_restack(wins, it_below);
         g_list_free(wins);
     }
 }