X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fstacking.c;h=58551b5da28d17474c294cb0f31b81e291207e7c;hb=HEAD;hp=6b3c955a713c71866efa737ebb4d294e69ca93b4;hpb=73c9a0e06b0248d430aac1c2c91f44a6a9dbac04;p=chaz%2Fopenbox

diff --git a/openbox/stacking.c b/openbox/stacking.c
index 6b3c955a..58551b5d 100644
--- a/openbox/stacking.c
+++ b/openbox/stacking.c
@@ -24,10 +24,12 @@
 #include "group.h"
 #include "frame.h"
 #include "window.h"
+#include "event.h"
 #include "debug.h"
 #include "obt/prop.h"
 
 GList  *stacking_list = NULL;
+GList  *stacking_list_tail = NULL;
 /*! When true, stacking changes will not be reflected on the screen.  This is
   to freeze the on-screen stacking order while a window is being temporarily
   raised during focus cycling */
@@ -68,6 +70,8 @@ static void do_restack(GList *wins, GList *before)
 
 #ifdef DEBUG
     GList *next;
+
+    g_assert(wins);
     /* pls only restack stuff in the same layer at a time */
     for (it = wins; it; it = next) {
         next = g_list_next(it);
@@ -114,6 +118,7 @@ void stacking_temp_raise(ObWindow *window)
 {
     Window win[2];
     GList *it;
+    gulong start;
 
     /* don't use this for internal windows..! it would lower them.. */
     g_assert(window_layer(window) < OB_STACKING_LAYER_INTERNAL);
@@ -129,7 +134,9 @@ void stacking_temp_raise(ObWindow *window)
     }
 
     win[1] = window_top(window);
+    start = event_start_ignore_all_enters();
     XRestackWindows(obt_display, win, 2);
+    event_end_ignore_all_enters(start);
 
     pause_changes = TRUE;
 }
@@ -139,12 +146,15 @@ void stacking_restore(void)
     Window *win;
     GList *it;
     gint i;
+    gulong start;
 
     win = g_new(Window, g_list_length(stacking_list) + 1);
     win[0] = screen_support_win;
     for (i = 1, it = stacking_list; it; ++i, it = g_list_next(it))
         win[i] = window_top(it->data);
+    start = event_start_ignore_all_enters();
     XRestackWindows(obt_display, win, i);
+    event_end_ignore_all_enters(start);
     g_free(win);
 
     pause_changes = FALSE;
@@ -209,11 +219,21 @@ static void restack_windows(ObClient *selected, gboolean raise)
     GList *it, *last, *below, *above, *next;
     GList *wins = NULL;
 
+    GList *group_helpers = NULL;
     GList *group_modals = NULL;
     GList *group_trans = NULL;
     GList *modals = NULL;
     GList *trans = NULL;
 
+    if (raise) {
+        ObClient *p;
+
+        /* if a window is modal for another single window, then raise it to the
+           top too, the same is done with the focus order */
+        while (selected->modal && (p = client_direct_parent(selected)))
+            selected = p;
+    }
+
     /* remove first so we can't run into ourself */
     it = g_list_find(stacking_list, selected);
     g_assert(it);
@@ -230,6 +250,8 @@ static void restack_windows(ObClient *selected, gboolean raise)
 
                 /* only move windows in the same stacking layer */
                 if (ch->layer == selected->layer &&
+                    /* looking for windows that are transients, and so would
+                       remain above the selected window */
                     client_search_transient(selected, ch))
                 {
                     if (client_is_direct_child(selected, ch)) {
@@ -238,6 +260,13 @@ static void restack_windows(ObClient *selected, gboolean raise)
                         else
                             trans = g_list_prepend(trans, ch);
                     }
+                    else if (client_helper(ch)) {
+                        if (selected->transient) {
+                            /* helpers do not stay above transient windows */
+                            continue;
+                        }
+                        group_helpers = g_list_prepend(group_helpers, ch);
+                    }
                     else {
                         if (ch->modal)
                             group_modals = g_list_prepend(group_modals, ch);
@@ -250,8 +279,13 @@ static void restack_windows(ObClient *selected, gboolean raise)
         }
     }
 
-    /* put transients of the selected window right above it */
+    /* put modals above other direct transients */
     wins = g_list_concat(modals, trans);
+
+    /* put helpers below direct transients */
+    wins = g_list_concat(wins, group_helpers);
+
+    /* put the selected window right below these children */
     wins = g_list_append(wins, selected);
 
     /* if selected window is transient for group then raise it above others */
@@ -370,6 +404,7 @@ void stacking_raise(ObWindow *window)
         do_raise(wins);
         g_list_free(wins);
     }
+    stacking_list_tail = g_list_last(stacking_list);
 }
 
 void stacking_lower(ObWindow *window)
@@ -385,6 +420,7 @@ void stacking_lower(ObWindow *window)
         do_lower(wins);
         g_list_free(wins);
     }
+    stacking_list_tail = g_list_last(stacking_list);
 }
 
 void stacking_below(ObWindow *window, ObWindow *below)
@@ -399,15 +435,20 @@ void stacking_below(ObWindow *window, ObWindow *below)
     before = g_list_next(g_list_find(stacking_list, below));
     do_restack(wins, before);
     g_list_free(wins);
+    stacking_list_tail = g_list_last(stacking_list);
 }
 
 void stacking_add(ObWindow *win)
 {
     g_assert(screen_support_win != None); /* make sure I dont break this in the
                                              future */
+    /* don't add windows that are being unmanaged ! */
+    if (WINDOW_IS_CLIENT(win)) g_assert(WINDOW_AS_CLIENT(win)->managed);
 
     stacking_list = g_list_append(stacking_list, win);
+
     stacking_raise(win);
+    /* stacking_list_tail set by stacking_raise() */
 }
 
 static GList *find_highest_relative(ObClient *client)
@@ -465,6 +506,9 @@ void stacking_add_nonintrusive(ObWindow *win)
 
     client = WINDOW_AS_CLIENT(win);
 
+    /* don't add windows that are being unmanaged ! */
+    g_assert(client->managed);
+
     /* insert above its highest parent (or its highest child !) */
     it_below = find_highest_relative(client);
 
@@ -517,6 +561,7 @@ void stacking_add_nonintrusive(ObWindow *win)
     wins = g_list_append(NULL, win);
     do_restack(wins, it_below);
     g_list_free(wins);
+    stacking_list_tail = g_list_last(stacking_list);
 }
 
 /*! Returns TRUE if client is occluded by the sibling. If sibling is NULL it
@@ -526,17 +571,16 @@ static gboolean stacking_occluded(ObClient *client, ObClient *sibling)
 {
     GList *it;
     gboolean occluded = FALSE;
-    gboolean found = FALSE;
 
     /* no need for any looping in this case */
     if (sibling && client->layer != sibling->layer)
         return occluded;
 
-    for (it = stacking_list; it;
-         it = (found ? g_list_previous(it) :g_list_next(it)))
+    for (it = g_list_previous(g_list_find(stacking_list, client)); it;
+         it = g_list_previous(it))
         if (WINDOW_IS_CLIENT(it->data)) {
             ObClient *c = it->data;
-            if (found && !c->iconic &&
+            if (!c->iconic &&
                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
                  c->desktop == client->desktop) &&
                 !client_search_transient(client, c))
@@ -557,8 +601,6 @@ static gboolean stacking_occluded(ObClient *client, ObClient *sibling)
                         break; /* we past its layer */
                 }
             }
-            else if (c == client)
-                found = TRUE;
         }
     return occluded;
 }
@@ -570,16 +612,16 @@ static gboolean stacking_occludes(ObClient *client, ObClient *sibling)
 {
     GList *it;
     gboolean occludes = FALSE;
-    gboolean found = FALSE;
 
     /* no need for any looping in this case */
     if (sibling && client->layer != sibling->layer)
         return occludes;
 
-    for (it = stacking_list; it; it = g_list_next(it))
+    for (it = g_list_next(g_list_find(stacking_list, client));
+         it; it = g_list_next(it))
         if (WINDOW_IS_CLIENT(it->data)) {
             ObClient *c = it->data;
-            if (found && !c->iconic &&
+            if (!c->iconic &&
                 (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
                  c->desktop == client->desktop) &&
                 !client_search_transient(c, client))
@@ -600,8 +642,6 @@ static gboolean stacking_occludes(ObClient *client, ObClient *sibling)
                         break; /* we past its layer */
                 }
             }
-            else if (c == client)
-                found = TRUE;
         }
     return occludes;
 }
@@ -617,21 +657,20 @@ gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
                     sibling->iconic))
     {
         ob_debug("Setting restack sibling to NULL, they are not on the same "
-                 "desktop or it is iconified\n");
+                 "desktop or it is iconified");
         sibling = NULL;
     }
 
     switch (detail) {
     case Below:
-        ob_debug("Restack request Below for client %s sibling %s\n",
+        ob_debug("Restack request Below for client %s sibling %s",
                  client->title, sibling ? sibling->title : "(all)");
         /* just lower it */
         stacking_lower(CLIENT_AS_WINDOW(client));
         ret = TRUE;
         break;
     case BottomIf:
-        ob_debug("Restack request BottomIf for client %s sibling "
-                 "%s\n",
+        ob_debug("Restack request BottomIf for client %s sibling %s",
                  client->title, sibling ? sibling->title : "(all)");
         /* if this client occludes sibling (or anything if NULL), then
            lower it to the bottom */
@@ -641,13 +680,13 @@ gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
         }
         break;
     case Above:
-        ob_debug("Restack request Above for client %s sibling %s\n",
+        ob_debug("Restack request Above for client %s sibling %s",
                  client->title, sibling ? sibling->title : "(all)");
         stacking_raise(CLIENT_AS_WINDOW(client));
         ret = TRUE;
         break;
     case TopIf:
-        ob_debug("Restack request TopIf for client %s sibling %s\n",
+        ob_debug("Restack request TopIf for client %s sibling %s",
                  client->title, sibling ? sibling->title : "(all)");
         if (stacking_occluded(client, sibling)) {
             stacking_raise(CLIENT_AS_WINDOW(client));
@@ -655,8 +694,7 @@ gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
         }
         break;
     case Opposite:
-        ob_debug("Restack request Opposite for client %s sibling "
-                 "%s\n",
+        ob_debug("Restack request Opposite for client %s sibling %s",
                  client->title, sibling ? sibling->title : "(all)");
         if (stacking_occluded(client, sibling)) {
             stacking_raise(CLIENT_AS_WINDOW(client));