Replace resize_axis with wlr_edges

This patch removes the resize_axis enum in favour of wlr_edges. As
wlr_edges has no `horizontal` or `vertical` value, it denotes these by
bitwise `or`ing the left/right and up/down values. Two constants are
defined to make it easier to refer to these.

This will allow the tiling resize seatop to utilise the functions in
this file. resize_axis was local to the resize command and couldn't be
exposed in function arguments.

1 files changed, 47 insertions, 114 deletions

diff --git a/sway/commands/resize.c b/sway/commands/resize.c
index cf5dea02..bcec2c9d 100644
--- a/sway/commands/resize.c
+++ b/sway/commands/resize.c
@@ -13,6 +13,9 @@
 #include "sway/tree/workspace.h"
 #include "log.h"
 
+#define AXIS_HORIZONTAL (WLR_EDGE_LEFT | WLR_EDGE_RIGHT)
+#define AXIS_VERTICAL   (WLR_EDGE_TOP | WLR_EDGE_BOTTOM)
+
 static const int MIN_SANE_W = 100, MIN_SANE_H = 60;
 
 enum resize_unit {
@@ -22,16 +25,6 @@ enum resize_unit {
         RESIZE_UNIT_INVALID,
 };
 
-enum resize_axis {
-        RESIZE_AXIS_HORIZONTAL,
-        RESIZE_AXIS_VERTICAL,
-        RESIZE_AXIS_UP,
-        RESIZE_AXIS_DOWN,
-        RESIZE_AXIS_LEFT,
-        RESIZE_AXIS_RIGHT,
-        RESIZE_AXIS_INVALID,
-};
-
 struct resize_amount {
         int amount;
         enum resize_unit unit;
@@ -111,61 +104,48 @@ static void calculate_constraints(int *min_width, int *max_width,
         }
 }
 
-static enum resize_axis parse_resize_axis(const char *axis) {
+static enum wlr_edges parse_resize_axis(const char *axis) {
         if (strcasecmp(axis, "width") == 0 || strcasecmp(axis, "horizontal") == 0) {
-                return RESIZE_AXIS_HORIZONTAL;
+                return AXIS_HORIZONTAL;
         }
         if (strcasecmp(axis, "height") == 0 || strcasecmp(axis, "vertical") == 0) {
-                return RESIZE_AXIS_VERTICAL;
+                return AXIS_VERTICAL;
         }
         if (strcasecmp(axis, "up") == 0) {
-                return RESIZE_AXIS_UP;
+                return WLR_EDGE_TOP;
         }
         if (strcasecmp(axis, "down") == 0) {
-                return RESIZE_AXIS_DOWN;
+                return WLR_EDGE_BOTTOM;
         }
         if (strcasecmp(axis, "left") == 0) {
-                return RESIZE_AXIS_LEFT;
+                return WLR_EDGE_LEFT;
         }
         if (strcasecmp(axis, "right") == 0) {
-                return RESIZE_AXIS_RIGHT;
+                return WLR_EDGE_RIGHT;
         }
-        return RESIZE_AXIS_INVALID;
+        return WLR_EDGE_NONE;
 }
 
-static enum resize_axis normalize_axis(enum resize_axis axis) {
-        switch (axis) {
-        case RESIZE_AXIS_HORIZONTAL:
-        case RESIZE_AXIS_LEFT:
-        case RESIZE_AXIS_RIGHT:
-                return RESIZE_AXIS_HORIZONTAL;
-        case RESIZE_AXIS_VERTICAL:
-        case RESIZE_AXIS_UP:
-        case RESIZE_AXIS_DOWN:
-                return RESIZE_AXIS_VERTICAL;
-        case RESIZE_AXIS_INVALID:
-                sway_assert(false, "Never reached");
-        }
-        sway_assert(false, "Never reached");
-        return RESIZE_AXIS_INVALID;
+static bool is_horizontal(enum wlr_edges axis) {
+        return axis & (WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
 }
 
-static int parallel_coord(struct sway_container *c, enum resize_axis a) {
-        return normalize_axis(a) == RESIZE_AXIS_HORIZONTAL ? c->x : c->y;
+static int parallel_coord(struct sway_container *c, enum wlr_edges axis) {
+        return is_horizontal(axis) ? c->x : c->y;
 }
 
-static int parallel_size(struct sway_container *c, enum resize_axis a) {
-        return normalize_axis(a) == RESIZE_AXIS_HORIZONTAL ? c->width : c->height;
+static int parallel_size(struct sway_container *c, enum wlr_edges axis) {
+        return is_horizontal(axis) ? c->width : c->height;
 }
 
 static void container_recursive_resize(struct sway_container *container,
                 double amount, enum wlr_edges edge) {
         bool layout_match = true;
         wlr_log(WLR_DEBUG, "Resizing %p with amount: %f", container, amount);
-        if (edge == WLR_EDGE_LEFT || edge == WLR_EDGE_RIGHT) {
+        if (edge & (WLR_EDGE_LEFT | WLR_EDGE_RIGHT)) {
                 container->width += amount;
                 layout_match = container->layout == L_HORIZ;
-        } else if (edge == WLR_EDGE_TOP || edge == WLR_EDGE_BOTTOM) {
+        } else if (edge & (WLR_EDGE_TOP | WLR_EDGE_BOTTOM)) {
                 container->height += amount;
                 layout_match = container->layout == L_VERT;
         }
@@ -180,14 +160,14 @@ static void container_recursive_resize(struct sway_container *container,
 }
 
 static void resize_tiled(struct sway_container *parent, int amount,
-                enum resize_axis axis) {
+                enum wlr_edges axis) {
         struct sway_container *focused = parent;
         if (!parent) {
                 return;
         }
 
         enum sway_container_layout parallel_layout =
-                normalize_axis(axis) == RESIZE_AXIS_HORIZONTAL ? L_HORIZ : L_VERT;
+                is_horizontal(axis) ? L_HORIZ : L_VERT;
         int minor_weight = 0;
         int major_weight = 0;
         while (parent) {
@@ -219,16 +199,15 @@ static void resize_tiled(struct sway_container *parent, int amount,
                 return;
         }
 
-        // Implement up/down/left/right direction by zeroing one of the weights,
-        // then setting the axis to be horizontal or vertical
-        if (axis == RESIZE_AXIS_UP || axis == RESIZE_AXIS_LEFT) {
+        // Implement up/down/left/right direction by zeroing one of the weights
+        if (axis == WLR_EDGE_TOP || axis == WLR_EDGE_LEFT) {
                 major_weight = 0;
-        } else if (axis == RESIZE_AXIS_RIGHT || axis == RESIZE_AXIS_DOWN) {
+        } else if (axis == WLR_EDGE_RIGHT || axis == WLR_EDGE_BOTTOM) {
                 minor_weight = 0;
         }
-        axis = normalize_axis(axis);
 
-        int min_sane = axis == RESIZE_AXIS_HORIZONTAL ? MIN_SANE_W : MIN_SANE_H;
+        bool horizontal = is_horizontal(axis);
+        int min_sane = horizontal ? MIN_SANE_W : MIN_SANE_H;
 
         //TODO: Ensure rounding is done in such a way that there are NO pixel leaks
         // ^ ?????
@@ -268,10 +247,8 @@ static void resize_tiled(struct sway_container *parent, int amount,
                 }
         }
 
-        enum wlr_edges minor_edge = axis == RESIZE_AXIS_HORIZONTAL ?
-                WLR_EDGE_LEFT : WLR_EDGE_TOP;
-        enum wlr_edges major_edge = axis == RESIZE_AXIS_HORIZONTAL ?
-                WLR_EDGE_RIGHT : WLR_EDGE_BOTTOM;
+        enum wlr_edges minor_edge = horizontal ? WLR_EDGE_LEFT : WLR_EDGE_TOP;
+        enum wlr_edges major_edge = horizontal ? WLR_EDGE_RIGHT : WLR_EDGE_BOTTOM;
 
         for (int i = 0; i < siblings->length; i++) {
                 struct sway_container *sibling = siblings->items[i];
@@ -321,47 +298,23 @@ static void resize_tiled(struct sway_container *parent, int amount,
 
 void container_resize_tiled(struct sway_container *parent,
                 enum wlr_edges edge, int amount) {
-        enum resize_axis axis = RESIZE_AXIS_INVALID;
-        switch (edge) {
-        case WLR_EDGE_TOP:
-                axis = RESIZE_AXIS_UP;
-                break;
-        case WLR_EDGE_RIGHT:
-                axis = RESIZE_AXIS_RIGHT;
-                break;
-        case WLR_EDGE_BOTTOM:
-                axis = RESIZE_AXIS_DOWN;
-                break;
-        case WLR_EDGE_LEFT:
-                axis = RESIZE_AXIS_LEFT;
-                break;
-        case WLR_EDGE_NONE:
-                break;
-        }
-        resize_tiled(parent, amount, axis);
+        resize_tiled(parent, amount, edge);
 }
 
 /**
  * Implement `resize <grow|shrink>` for a floating container.
  */
-static struct cmd_results *resize_adjust_floating(enum resize_axis axis,
+static struct cmd_results *resize_adjust_floating(enum wlr_edges axis,
                 struct resize_amount *amount) {
         struct sway_container *con = config->handler_context.container;
         int grow_width = 0, grow_height = 0;
-        switch (axis) {
-        case RESIZE_AXIS_HORIZONTAL:
-        case RESIZE_AXIS_LEFT:
-        case RESIZE_AXIS_RIGHT:
+
+        if (is_horizontal(axis)) {
                 grow_width = amount->amount;
-                break;
-        case RESIZE_AXIS_VERTICAL:
-        case RESIZE_AXIS_UP:
-        case RESIZE_AXIS_DOWN:
+        } else {
                 grow_height = amount->amount;
-                break;
-        case RESIZE_AXIS_INVALID:
-                return cmd_results_new(CMD_INVALID, "resize", "Invalid axis/direction");
         }
+
         // Make sure we're not adjusting beyond floating min/max size
         int min_width, max_width, min_height, max_height;
         calculate_constraints(&min_width, &max_width, &min_height, &max_height);
@@ -376,24 +329,15 @@ static struct cmd_results *resize_adjust_floating(enum resize_axis axis,
                 grow_height = max_height - con->height;
         }
         int grow_x = 0, grow_y = 0;
-        switch (axis) {
-        case RESIZE_AXIS_HORIZONTAL:
+
+        if (axis == AXIS_HORIZONTAL) {
                 grow_x = -grow_width / 2;
-                break;
-        case RESIZE_AXIS_VERTICAL:
+        } else if (axis == AXIS_VERTICAL) {
                 grow_y = -grow_height / 2;
-                break;
-        case RESIZE_AXIS_UP:
+        } else if (axis == WLR_EDGE_TOP) {
                 grow_y = -grow_height;
-                break;
-        case RESIZE_AXIS_LEFT:
+        } else if (axis == WLR_EDGE_LEFT) {
                 grow_x = -grow_width;
-                break;
-        case RESIZE_AXIS_DOWN:
-        case RESIZE_AXIS_RIGHT:
-                break;
-        case RESIZE_AXIS_INVALID:
-                return cmd_results_new(CMD_INVALID, "resize", "Invalid axis/direction");
         }
         if (grow_x == 0 && grow_y == 0) {
                 return cmd_results_new(CMD_INVALID, "resize",
@@ -417,7 +361,7 @@ static struct cmd_results *resize_adjust_floating(enum resize_axis axis,
 /**
  * Implement `resize <grow|shrink>` for a tiled container.
  */
-static struct cmd_results *resize_adjust_tiled(enum resize_axis axis,
+static struct cmd_results *resize_adjust_tiled(enum wlr_edges axis,
                 struct resize_amount *amount) {
         struct sway_container *current = config->handler_context.container;
 
@@ -426,20 +370,11 @@ static struct cmd_results *resize_adjust_tiled(enum resize_axis axis,
         }
         if (amount->unit == RESIZE_UNIT_PPT) {
                 float pct = amount->amount / 100.0f;
-                switch (axis) {
-                case RESIZE_AXIS_LEFT:
-                case RESIZE_AXIS_RIGHT:
-                case RESIZE_AXIS_HORIZONTAL:
+
+                if (is_horizontal(axis)) {
                         amount->amount = (float)current->width * pct;
-                        break;
-                case RESIZE_AXIS_UP:
-                case RESIZE_AXIS_DOWN:
-                case RESIZE_AXIS_VERTICAL:
+                } else {
                         amount->amount = (float)current->height * pct;
-                        break;
-                case RESIZE_AXIS_INVALID:
-                        return cmd_results_new(CMD_INVALID, "resize",
-                                        "Invalid resize axis/direction");
                 }
         }
 
@@ -474,8 +409,7 @@ static struct cmd_results *resize_set_tiled(struct sway_container *con,
                         width->unit = RESIZE_UNIT_PX;
                 }
                 if (width->unit == RESIZE_UNIT_PX) {
-                        resize_tiled(con, width->amount - con->width,
-                                        RESIZE_AXIS_HORIZONTAL);
+                        resize_tiled(con, width->amount - con->width, AXIS_HORIZONTAL);
                 }
         }
 
@@ -495,8 +429,7 @@ static struct cmd_results *resize_set_tiled(struct sway_container *con,
                         height->unit = RESIZE_UNIT_PX;
                 }
                 if (height->unit == RESIZE_UNIT_PX) {
-                        resize_tiled(con, height->amount - con->height,
-                                        RESIZE_AXIS_VERTICAL);
+                        resize_tiled(con, height->amount - con->height, AXIS_VERTICAL);
                 }
         }
 
@@ -631,8 +564,8 @@ static struct cmd_results *cmd_resize_adjust(int argc, char **argv,
                 int multiplier) {
         const char *usage = "Expected 'resize grow|shrink <direction> "
                 "[<amount> px|ppt [or <amount> px|ppt]]'";
-        enum resize_axis axis = parse_resize_axis(*argv);
-        if (axis == RESIZE_AXIS_INVALID) {
+        enum wlr_edges axis = parse_resize_axis(*argv);
+        if (axis == WLR_EDGE_NONE) {
                 return cmd_results_new(CMD_INVALID, "resize", usage);
         }
         --argc; ++argv;