commands/move: rework container_move_in_direction

This changes the move command to better match i3
behavior after the layout changes.

workspace_rejigger handled the case where containers would
escape their workspace in an orthogonal move by changing
the layout to accomodate them, but this case is now handled
within the loop.

1 files changed, 112 insertions, 97 deletions

diff --git a/sway/commands/move.c b/sway/commands/move.c
index 32adf0bf..ecad9863 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -263,126 +263,141 @@ static void container_move_to_container(struct sway_container *container,
         }
 }
 
-/* Takes one child, sets it aside, wraps the rest of the children in a new
- * container, switches the layout of the workspace, and drops the child back in.
- * In other words, rejigger it. */
-static void workspace_rejigger(struct sway_workspace *ws,
-                struct sway_container *child, enum wlr_direction move_dir) {
-        if (!child->parent && ws->tiling->length == 1) {
-                ws->layout =
-                        move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_RIGHT ?
-                        L_HORIZ : L_VERT;
-                workspace_update_representation(ws);
-                return;
+static bool container_move_to_next_output(struct sway_container *container,
+                struct sway_output *output, enum wlr_direction move_dir) {
+        struct sway_output *next_output =
+                output_get_in_direction(output, move_dir);
+        if (next_output) {
+                struct sway_workspace *ws = output_get_active_workspace(next_output);
+                if (!sway_assert(ws, "Expected output to have a workspace")) {
+                        return false;
+                }
+                switch (container->fullscreen_mode) {
+                case FULLSCREEN_NONE:
+                        container_move_to_workspace_from_direction(container, ws, move_dir);
+                        return true;
+                case FULLSCREEN_WORKSPACE:
+                        container_move_to_workspace(container, ws);
+                        return true;
+                case FULLSCREEN_GLOBAL:
+                        return false;
+                }
         }
-        container_detach(child);
-        struct sway_container *new_parent = workspace_wrap_children(ws);
-
-        int index =
-                move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_UP ? 0 : 1;
-        workspace_insert_tiling(ws, child, index);
-        container_flatten(new_parent);
-        ws->layout =
-                move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_RIGHT ?
-                L_HORIZ : L_VERT;
-        workspace_update_representation(ws);
-        child->width = child->height = 0;
+        return false;
 }
 
 // Returns true if moved
 static bool container_move_in_direction(struct sway_container *container,
                 enum wlr_direction move_dir) {
         // If moving a fullscreen view, only consider outputs
-        if (container->fullscreen_mode == FULLSCREEN_WORKSPACE) {
-                struct sway_output *new_output =
-                        output_get_in_direction(container->workspace->output, move_dir);
-                if (!new_output) {
-                        return false;
-                }
-                struct sway_workspace *ws = output_get_active_workspace(new_output);
-                if (!sway_assert(ws, "Expected output to have a workspace")) {
-                        return false;
-                }
-                container_move_to_workspace(container, ws);
-                return true;
-        }
-        if (container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+        switch (container->fullscreen_mode) {
+        case FULLSCREEN_NONE:
+                break;
+        case FULLSCREEN_WORKSPACE:
+                return container_move_to_next_output(container,
+                                container->workspace->output, move_dir);
+        case FULLSCREEN_GLOBAL:
                 return false;
         }
 
-        // Look for a suitable *container* sibling or parent.
-        // The below loop stops once we hit the workspace because current->parent
-        // is NULL for the topmost containers in a workspace.
-        struct sway_container *current = container;
         int offs =
                 move_dir == WLR_DIRECTION_LEFT || move_dir == WLR_DIRECTION_UP ? -1 : 1;
+        int index = -1;
+        int     desired = -1;
+        list_t *siblings = NULL;
+        struct sway_container *target = NULL;
+
+        // Look for a suitable ancestor of the container to move within
+        struct sway_container *ancestor = NULL;
+        struct sway_container *current = container;
+        bool wrapped = false;
+        while (!ancestor) {
+                // Don't allow containers to move out of their
+                // fullscreen or floating parent
+                if (current->fullscreen_mode || container_is_floating(current)) {
+                        return false;
+                }
 
-        while (current) {
-                list_t *siblings = container_get_siblings(current);
-                if (siblings) {
-                        enum sway_container_layout layout = container_parent_layout(current);
-                        int index = list_find(siblings, current);
-                        int desired = index + offs;
-
-                        // Don't allow containers to move out of their
-                        // fullscreen or floating parent
-                        if (current->fullscreen_mode || container_is_floating(current)) {
-                                return false;
+                enum sway_container_layout parent_layout = container_parent_layout(current);
+                if (!is_parallel(parent_layout, move_dir)) {
+                        if (!current->parent) {
+                                // No parallel parent, so we reorient the workspace
+                                current = workspace_wrap_children(current->workspace);
+                                current->workspace->layout =
+                                        move_dir == WLR_DIRECTION_LEFT ||
+                                        move_dir == WLR_DIRECTION_RIGHT ?
+                                        L_HORIZ : L_VERT;
+                                container->height = container->width = 0;
+                                container->height_fraction = container->width_fraction = 0;
+                                workspace_update_representation(current->workspace);
+                                wrapped = true;
+                        } else {
+                                // Keep looking for a parallel parent
+                                current = current->parent;
                         }
+                        continue;
+                }
 
-                        if (is_parallel(layout, move_dir)) {
-                                if (desired == -1 || desired == siblings->length) {
-                                        if (current->parent == container->parent) {
-                                                current = current->parent;
-                                                continue;
-                                        } else {
-                                                // Reparenting
-                                                if (current->parent) {
-                                                        container_insert_child(current->parent, container,
-                                                                        index + (offs < 0 ? 0 : 1));
-                                                } else {
-                                                        workspace_insert_tiling(current->workspace, container,
-                                                                        index + (offs < 0 ? 0 : 1));
-                                                }
-                                                return true;
-                                        }
-                                } else {
-                                        // Container can move within its siblings
-                                        container_move_to_container_from_direction(container,
-                                                        siblings->items[desired], move_dir);
-                                        return true;
-                                }
+                // Only scratchpad hidden containers don't have siblings
+                // so siblings != NULL here
+                siblings = container_get_siblings(current);
+                index = list_find(siblings, current);
+                desired = index + offs;
+                target = desired == -1 || desired == siblings->length ?
+                                NULL : siblings->items[desired];
+
+                // If the move is simple we can complete it here early
+                if (current == container) {
+                        if (target) {
+                                // Container will swap with or descend into its neighbor
+                                container_move_to_container_from_direction(container,
+                                                target, move_dir);
+                                return true;
+                        } else if (!container->parent) {
+                                // Container is at workspace level so we move it to the
+                                // next workspace if possible
+                                return container_move_to_next_output(container,
+                                                current->workspace->output, move_dir);
+                        } else {
+                                // Container has escaped its immediate parallel parent
+                                current = current->parent;
+                                continue;
                         }
                 }
 
-                current = current->parent;
+                // We found a suitable ancestor, the loop will end
+                ancestor = current;
         }
 
-        // Maybe rejigger the workspace
-        struct sway_workspace *ws = container->workspace;
-        if (ws) {
-                if (!is_parallel(ws->layout, move_dir)) {
-                        workspace_rejigger(ws, container, move_dir);
-                        return true;
-                } else if (ws->layout == L_TABBED || ws->layout == L_STACKED) {
-                        workspace_rejigger(ws, container, move_dir);
-                        return true;
+        if (target) {
+                // Container will move in with its cousin
+                container_move_to_container_from_direction(container,
+                                target, move_dir);
+                return true;
+        } else if (!wrapped && !container->parent->parent &&
+                        container->parent->children->length == 1) {
+                // Treat singleton children as if they are at workspace level like i3
+                // https://github.com/i3/i3/blob/1d9160f2d247dbaa83fb62f02fd7041dec767fc2/src/move.c#L367
+                return container_move_to_next_output(container,
+                                ancestor->workspace->output, move_dir);
+        } else {
+                // Container will be promoted
+                struct sway_container *old_parent = container->parent;
+                if (ancestor->parent) {
+                        // Container will move in with its parent
+                        container_insert_child(ancestor->parent, container,
+                                        index + (offs < 0 ? 0 : 1));
+                } else {
+                        // Container will move to workspace level,
+                        // may be re-split by workspace_layout
+                        workspace_insert_tiling(ancestor->workspace, container,
+                                        index + (offs < 0 ? 0 : 1));
                 }
-
-                // Try adjacent output
-                struct sway_output *output =
-                        output_get_in_direction(container->workspace->output, move_dir);
-                if (output) {
-                        struct sway_workspace *ws = output_get_active_workspace(output);
-                        if (!sway_assert(ws, "Expected output to have a workspace")) {
-                                return false;
-                        }
-                        container_move_to_workspace_from_direction(container, ws, move_dir);
-                        return true;
+                if (old_parent) {
+                        container_reap_empty(old_parent);
                 }
-                sway_log(SWAY_DEBUG, "Hit edge of output, nowhere else to go");
+                return true;
         }
-        return false;
 }
 
 static struct cmd_results *cmd_move_to_scratchpad(void);