X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fstacking.c;h=2c80ada00cc42712e3d384b2eb8e5828a86311f5;hb=f869ec5121afaf74ff3a7a420923878c093f9c08;hp=18747b9c80512a8bba55e78788085e7f7ca0cca2;hpb=277db2822d79a6000d31b93ec963ae87286d6ade;p=chaz%2Fopenbox

diff --git a/openbox/stacking.c b/openbox/stacking.c
index 18747b9c..2c80ada0 100644
--- a/openbox/stacking.c
+++ b/openbox/stacking.c
@@ -25,6 +25,7 @@
 #include "group.h"
 #include "frame.h"
 #include "window.h"
+#include "debug.h"
 
 GList  *stacking_list = NULL;
 
@@ -381,8 +382,14 @@ static GList *find_highest_relative(ObClient *client)
         for (it = stacking_list; !ret && it; it = g_list_next(it)) {
             if (WINDOW_IS_CLIENT(it->data)) {
                 ObClient *c = it->data;
-                /* only look at windows in the same layer */
-                if (c->layer == client->layer) {
+                /* only look at windows in the same layer and that are
+                   visible */
+                if (c->layer == client->layer &&
+                    !c->iconic && 
+                    (c->desktop == client->desktop ||
+                     c->desktop == DESKTOP_ALL ||
+                     client->desktop == DESKTOP_ALL))
+                {
                     GSList *sit;
 
                     /* go through each top level parent and see it this window
@@ -404,7 +411,8 @@ static GList *find_highest_relative(ObClient *client)
 void stacking_add_nonintrusive(ObWindow *win)
 {
     ObClient *client;
-    GList *it_below = NULL;
+    GList *it_below = NULL; /* this client will be below us */
+    GList *it_above;
 
     if (!WINDOW_IS_CLIENT(win)) {
         stacking_add(win); /* no special rules for others */
@@ -417,39 +425,217 @@ void stacking_add_nonintrusive(ObWindow *win)
     it_below = find_highest_relative(client);
 
     if (!it_below) {
-        /* nothing to put it directly above, so try find the focused client to
-           put it underneath it */
-        if (focus_client && focus_client->layer == client->layer) {
-            if ((it_below = g_list_find(stacking_list, focus_client)))
-                it_below = it_below->next;
+        /* nothing to put it directly above, so try find the focused client
+           to put it underneath it */
+        if (focus_client && client != focus_client &&
+            focus_client->layer == client->layer)
+        {
+            it_below = g_list_find(stacking_list, focus_client);
+            /* this can give NULL, but it means the focused window is on the
+               bottom of the stacking order, so go to the bottom in that case,
+               below it */
+            it_below = g_list_next(it_below);
+        }
+        else {
+            /* There is no window to put this directly above, so put it at the
+               top, so you know it is there.
+
+               It used to do this only if the window was focused and lower
+               it otherwise.
+
+               We also put it at the top not the bottom to fix a bug with
+               fullscreen windows. When focusLast is off and followsMouse is
+               on, when you switch desktops, the fullscreen window loses
+               focus and goes into its lower layer. If this puts it at the
+               bottom then when you come back to the desktop, the window is
+               at the bottom and won't get focus back.
+            */
+            it_below = stacking_list;
         }
     }
-    if (!it_below) {
-        /* there is no window to put this directly above, so put it at the
-           bottom */
-        stacking_list = g_list_prepend(stacking_list, win);
-        stacking_lower(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;
+
+    /* 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 = it_above) {
+        /* stop when the window is not in a lower layer than the
+           window it is going under (it_above) */
+        it_above = it_below ?
+            g_list_previous(it_below) : g_list_last(stacking_list);
+        if (client->layer <= window_layer(it_above->data))
+            break;
+    }
+
+    GList *wins = g_list_append(NULL, win);
+    do_restack(wins, it_below);
+    g_list_free(wins);
+}
+
+/*! Returns TRUE if client is occluded by the sibling. If sibling is NULL it
+  tries against all other clients.
+*/
+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)))
+        if (WINDOW_IS_CLIENT(it->data)) {
+            ObClient *c = it->data;
+            if (found && !c->iconic &&
+                (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
+                 c->desktop == client->desktop))
+            {
+                if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
+                {
+                    if (sibling != NULL) {
+                        if (c == sibling) {
+                            occluded = TRUE;
+                            break;
+                        }
+                    }
+                    else if (c->layer == client->layer) {
+                        occluded = TRUE;
+                        break;
+                    }
+                    else if (c->layer > client->layer)
+                        break; /* we past its layer */
+                }
+            }
+            else if (c == client)
+                found = TRUE;
         }
-        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;
+    return occluded;
+}
+
+/*! Returns TRUE if client occludes the sibling. If sibling is NULL it tries
+  against all other clients.
+*/
+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))
+        if (WINDOW_IS_CLIENT(it->data)) {
+            ObClient *c = it->data;
+            if (found && !c->iconic &&
+                (c->desktop == DESKTOP_ALL || client->desktop == DESKTOP_ALL ||
+                 c->desktop == client->desktop))
+            {
+                if (RECT_INTERSECTS_RECT(c->frame->area, client->frame->area))
+                {
+                    if (sibling != NULL) {
+                        if (c == sibling) {
+                            occludes = TRUE;
+                            break;
+                        }
+                    }
+                    else if (c->layer == client->layer) {
+                        occludes = TRUE;
+                        break;
+                    }
+                    else if (c->layer < client->layer)
+                        break; /* we past its layer */
+                }
+            }
+            else if (c == client)
+                found = TRUE;
         }
+    return occludes;
+}
 
-        GList *wins = g_list_append(NULL, win);
-        do_restack(wins, it_below);
-        g_list_free(wins);
+gboolean stacking_restack_request(ObClient *client, ObClient *sibling,
+                                  gint detail, gboolean activate)
+{
+    gboolean ret = FALSE;
+
+    if (sibling && ((client->desktop != sibling->desktop &&
+                     client->desktop != DESKTOP_ALL &&
+                     sibling->desktop != DESKTOP_ALL) ||
+                    sibling->iconic))
+    {
+        ob_debug("Setting restack sibling to NULL, they are not on the same "
+                 "desktop or it is iconified\n");
+        sibling = NULL;
     }
+
+    switch (detail) {
+    case Below:
+        ob_debug("Restack request Below for client %s sibling %s\n",
+                 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",
+                 client->title, sibling ? sibling->title : "(all)");
+        /* if this client occludes sibling (or anything if NULL), then
+           lower it to the bottom */
+        if (stacking_occludes(client, sibling)) {
+            stacking_lower(CLIENT_AS_WINDOW(client));
+            ret = TRUE;
+        }
+        break;
+    case Above:
+        ob_debug("Restack request Above for client %s sibling %s\n",
+                 client->title, sibling ? sibling->title : "(all)");
+        if (activate && !client->iconic && client_normal(client))
+            /* use user=TRUE because it is impossible to get a timestamp
+               for this */
+            client_activate(client, FALSE, TRUE);
+        else
+            stacking_raise(CLIENT_AS_WINDOW(client));
+        ret = TRUE;
+        break;
+    case TopIf:
+        ob_debug("Restack request TopIf for client %s sibling %s\n",
+                 client->title, sibling ? sibling->title : "(all)");
+        if (stacking_occluded(client, sibling)) {
+            if (activate && !client->iconic && client_normal(client))
+                /* use user=TRUE because it is impossible to get a timestamp
+                   for this */
+                client_activate(client, FALSE, TRUE);
+            else
+                stacking_raise(CLIENT_AS_WINDOW(client));
+            ret = TRUE;
+        }
+        break;
+    case Opposite:
+        ob_debug("Restack request Opposite for client %s sibling "
+                 "%s\n",
+                 client->title, sibling ? sibling->title : "(all)");
+        if (stacking_occluded(client, sibling)) {
+            if (activate && !client->iconic && client_normal(client))
+                /* use user=TRUE because it is impossible to get a timestamp
+                   for this */
+                client_activate(client, FALSE, TRUE);
+            else
+                stacking_raise(CLIENT_AS_WINDOW(client));
+            ret = TRUE;
+        }
+        else if (stacking_occludes(client, sibling)) {
+            stacking_lower(CLIENT_AS_WINDOW(client));
+            ret = TRUE;
+        }
+        break;
+    }
+    return ret;
 }