Allow FillToEdge to grow when all its edges are blocked.

This change points out how useless the return value from client_find_resize_directional()
was, so it also removes that.

When all edges are blocked, the FillToEdge action will try to grow all four edges agin
without blocking any of them on their current edge. This more closely matches the
behaviour of the GrowToEdge action.

diff --git a/openbox/actions/growtoedge.c b/openbox/actions/growtoedge.c
index 3a213806619fb9be16ec0202a885cf72beab9282..fa1b2c7ed1fa035f8e0602c9874fd62d8821f9ff 100644 (file)
--- a/openbox/actions/growtoedge.c
+++ b/openbox/actions/growtoedge.c
@@ -123,6 +123,58 @@ static gboolean do_grow(ObActionsData *data, gint x, gint y, gint w, gint h)
     return FALSE;
 }
 
+static gboolean do_grow_all_edges(ObActionsData* data,
+                                  ObClientDirectionalResizeType resize_type)
+{
+    gint x, y, w, h;
+    gint temp_x, temp_y, temp_w, temp_h;
+
+    client_find_resize_directional(data->client,
+                                   OB_DIRECTION_NORTH,
+                                   resize_type,
+                                   &temp_x, &temp_y, &temp_w, &temp_h);
+    y = temp_y;
+    h = temp_h;
+
+    client_find_resize_directional(data->client,
+                                   OB_DIRECTION_SOUTH,
+                                   resize_type,
+                                   &temp_x, &temp_y, &temp_w, &temp_h);
+    h += temp_h - data->client->area.height;
+
+
+    client_find_resize_directional(data->client,
+                                   OB_DIRECTION_WEST,
+                                   resize_type,
+                                   &temp_x, &temp_y, &temp_w, &temp_h);
+    x = temp_x;
+    w = temp_w;
+
+    client_find_resize_directional(data->client,
+                                   OB_DIRECTION_EAST,
+                                   resize_type,
+                                   &temp_x, &temp_y, &temp_w, &temp_h);
+    w += temp_w - data->client->area.width;
+
+    /* When filling, we allow the window to move to an arbitrary x/y
+       position, since we'll be growing the other edge as well. */
+    int lw, lh;
+    client_try_configure(data->client, &x, &y, &w, &h, &lw, &lh, TRUE);
+
+    if (x == data->client->area.x &&
+        y == data->client->area.y &&
+        w == data->client->area.width &&
+        h == data->client->area.height)
+    {
+        return FALSE;
+    }
+
+    actions_client_move(data, TRUE);
+    client_move_resize(data->client, x, y, w, h);
+    actions_client_move(data, FALSE);
+    return TRUE;
+}
+
 static void free_func(gpointer o)
 {
     g_slice_free(Options, o);
@@ -132,20 +184,16 @@ static void free_func(gpointer o)
 static gboolean run_func(ObActionsData *data, gpointer options)
 {
     Options *o = options;
-    gint x, y, w, h;
-
-    gint half;
 
     if (!data->client)
         return FALSE;
-    if (data->client->shaded) {
-        gboolean doing_verical_resize =
-            o->dir == OB_DIRECTION_NORTH ||
-            o->dir == OB_DIRECTION_SOUTH ||
-            o->fill;
-        if (doing_verical_resize)
+
+    gboolean doing_verical_resize =
+        o->dir == OB_DIRECTION_NORTH ||
+        o->dir == OB_DIRECTION_SOUTH ||
+        o->fill;
+    if (data->client->shaded && doing_verical_resize)
             return FALSE;
-    }
 
     if (o->fill) {
         if (o->shrink) {
@@ -154,53 +202,18 @@ static gboolean run_func(ObActionsData *data, gpointer options)
             return FALSE;
         }
 
-        ObClientDirectionalResizeType grow = CLIENT_RESIZE_GROW_IF_NOT_ON_EDGE;
-
-        gint temp_x;
-        gint temp_y;
-        gint temp_w;
-        gint temp_h;
-
-        client_find_resize_directional(data->client,
-                                       OB_DIRECTION_NORTH,
-                                       grow,
-                                       &temp_x, &temp_y, &temp_w, &temp_h);
-        y = temp_y;
-        h = temp_h;
-
-        client_find_resize_directional(data->client,
-                                       OB_DIRECTION_SOUTH,
-                                       grow,
-                                       &temp_x, &temp_y, &temp_w, &temp_h);
-        h += temp_h - data->client->area.height;
-
-
-        client_find_resize_directional(data->client,
-                                       OB_DIRECTION_WEST,
-                                       grow,
-                                       &temp_x, &temp_y, &temp_w, &temp_h);
-        x = temp_x;
-        w = temp_w;
+        if (do_grow_all_edges(data, CLIENT_RESIZE_GROW_IF_NOT_ON_EDGE))
+            return FALSE;
 
-        client_find_resize_directional(data->client,
-                                       OB_DIRECTION_EAST,
-                                       grow,
-                                       &temp_x, &temp_y, &temp_w, &temp_h);
-        w += temp_w - data->client->area.width;
-
-        /* When filling, we allow the window to move to an arbitrary x/y
-           position, since we'll be growing the other edge as well. */
-        if (x != data->client->area.x || y != data->client->area.y ||
-            w != data->client->area.width || h != data->client->area.height)
-        {
-            actions_client_move(data, TRUE);
-            client_move_resize(data->client, x, y, w, h);
-            actions_client_move(data, FALSE);
-        }
+        /* If all the edges are blocked, then allow them to jump past their
+           current block points. */
+        do_grow_all_edges(data, CLIENT_RESIZE_GROW);
         return FALSE;
     }
 
     if (!o->shrink) {
+        gint x, y, w, h;
+
         /* Try grow. */
         client_find_resize_directional(data->client,
                                        o->dir,
@@ -217,10 +230,15 @@ static gboolean run_func(ObActionsData *data, gpointer options)
          (o->dir == OB_DIRECTION_SOUTH ? OB_DIRECTION_NORTH :
           (o->dir == OB_DIRECTION_EAST ? OB_DIRECTION_WEST :
            OB_DIRECTION_EAST)));
+
+    gint x, y, w, h;
+    gint half;
+
     client_find_resize_directional(data->client,
                                    opposite,
                                    CLIENT_RESIZE_SHRINK,
                                    &x, &y, &w, &h);
+
     switch (opposite) {
     case OB_DIRECTION_NORTH:
         half = data->client->area.y + data->client->area.height / 2;

diff --git a/openbox/client.c b/openbox/client.c
index d7389a65dd41502980d7dab7fbc0fcf990304ea4..5e6569e0e3f832c8afdbb68345fe9c0d677a26f4 100644 (file)
--- a/openbox/client.c
+++ b/openbox/client.c
@@ -4535,19 +4535,16 @@ void client_find_move_directional(ObClient *self, ObDirection dir,
     frame_frame_gravity(self->frame, x, y);
 }
 
-gboolean client_find_resize_directional(
-    ObClient *self,
-    ObDirection side,
-    ObClientDirectionalResizeType resize_type,
-    gint *x, gint *y, gint *w, gint *h)
+void client_find_resize_directional(ObClient *self,
+                                    ObDirection side,
+                                    ObClientDirectionalResizeType resize_type,
+                                    gint *x, gint *y, gint *w, gint *h)
 {
     gint head;
     gint e, e_start, e_size, delta;
     gboolean near;
     ObDirection dir;
 
-    gboolean changed = FALSE;
-
     gboolean grow;
     switch (resize_type) {
     case CLIENT_RESIZE_GROW:
@@ -4647,27 +4644,23 @@ gboolean client_find_resize_directional(
         if (grow == near) --e;
         delta = e - RECT_RIGHT(self->frame->area);
         *w += delta;
-        changed = delta ? TRUE : changed;
         break;
     case OB_DIRECTION_WEST:
         if (grow == near) ++e;
         delta = RECT_LEFT(self->frame->area) - e;
         *x -= delta;
         *w += delta;
-        changed = delta ? TRUE : changed;
         break;
     case OB_DIRECTION_NORTH:
         if (grow == near) ++e;
         delta = RECT_TOP(self->frame->area) - e;
         *y -= delta;
         *h += delta;
-        changed = delta ? TRUE : changed;
         break;
     case OB_DIRECTION_SOUTH:
         if (grow == near) --e;
         delta = e - RECT_BOTTOM(self->frame->area);
         *h += delta;
-        changed = delta ? TRUE : changed;
        break;
     default:
         g_assert_not_reached();
@@ -4675,7 +4668,6 @@ gboolean client_find_resize_directional(
     frame_frame_gravity(self->frame, x, y);
     *w -= self->frame->size.left + self->frame->size.right;
     *h -= self->frame->size.top + self->frame->size.bottom;
-    return changed;
 }
 
 ObClient* client_under_pointer(void)

diff --git a/openbox/client.h b/openbox/client.h
index a753b123b1c45af351e024f4dab0892c5395cd5a..11a014000dfae1a6f31694707a23ddcc3a2881d5 100644 (file)
--- a/openbox/client.h
+++ b/openbox/client.h
@@ -496,14 +496,11 @@ typedef enum {
     CLIENT_RESIZE_SHRINK,
 } ObClientDirectionalResizeType;
 
-/*! Moves the client area passed in to grow/shrink the given edge.
-  @return TRUE if any change was made to the client area.
-*/
-gboolean client_find_resize_directional(
-    ObClient *self,
-    ObDirection side,
-    ObClientDirectionalResizeType resize_type,
-    gint *x, gint *y, gint *w, gint *h);
+/*! Moves the client area passed in to grow/shrink the given edge. */
+void client_find_resize_directional(ObClient *self,
+                                    ObDirection side,
+                                    ObClientDirectionalResizeType resize_type,
+                                    gint *x, gint *y, gint *w, gint *h);
 
 /*! Fullscreen's or unfullscreen's the client window
   @param fs true if the window should be made fullscreen; false if it should