Merge pull request #1700 from swaywm/move-cmd-full

Implement move [left|right|up|down]

12 files changed, 501 insertions, 48 deletions

diff --git a/include/sway/debug.h b/include/sway/debug.h
new file mode 100644
index 00000000..2430d319
--- /dev/null
+++ b/include/sway/debug.h
@@ -0,0 +1,7 @@
+#ifndef SWAY_DEBUG_H
+#define SWAY_DEBUG_H
+
+extern bool enable_debug_tree;
+void update_debug_tree();
+
+#endif
diff --git a/include/sway/tree/container.h b/include/sway/tree/container.h
index 4c60530f..2a8b8aba 100644
--- a/include/sway/tree/container.h
+++ b/include/sway/tree/container.h
@@ -182,4 +182,11 @@ void container_create_notify(struct sway_container *container);
 
 void container_damage_whole(struct sway_container *container);
 
+bool container_reap_empty(struct sway_container *con);
+
+struct sway_container *container_reap_empty_recursive(
+                struct sway_container *con);
+
+struct sway_container *container_flatten(struct sway_container *container);
+
 #endif
diff --git a/include/sway/tree/layout.h b/include/sway/tree/layout.h
index fc5ce21f..49ae00e4 100644
--- a/include/sway/tree/layout.h
+++ b/include/sway/tree/layout.h
@@ -1,7 +1,7 @@
 #ifndef _SWAY_LAYOUT_H
 #define _SWAY_LAYOUT_H
-
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/render/wlr_texture.h>
 #include "sway/tree/container.h"
 
 enum movement_direction {
@@ -29,6 +29,8 @@ struct sway_root {
 
         struct wl_list xwayland_unmanaged; // sway_xwayland_unmanaged::link
 
+        struct wlr_texture *debug_tree;
+
         struct {
                 struct wl_signal new_container;
         } events;
diff --git a/sway/commands/move.c b/sway/commands/move.c
index c954ab94..15a5ebc4 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -82,6 +82,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
                                 config->handler_context.seat, ws);
                 container_move_to(current, focus);
                 seat_set_focus(config->handler_context.seat, old_parent);
+                container_reap_empty(old_parent);
+                container_reap_empty(focus->parent);
                 return cmd_results_new(CMD_SUCCESS, NULL, NULL);
         } else if (strcasecmp(argv[1], "to") == 0
                         && strcasecmp(argv[2], "output") == 0) {
@@ -109,6 +111,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
                 struct sway_container *old_parent = current->parent;
                 container_move_to(current, focus);
                 seat_set_focus(config->handler_context.seat, old_parent);
+                container_reap_empty(old_parent);
+                container_reap_empty(focus->parent);
                 return cmd_results_new(CMD_SUCCESS, NULL, NULL);
         }
         return cmd_results_new(CMD_INVALID, "move", expected_syntax);
diff --git a/sway/debug-tree.c b/sway/debug-tree.c
new file mode 100644
index 00000000..ae0a1869
--- /dev/null
+++ b/sway/debug-tree.c
@@ -0,0 +1,119 @@
+#include <pango/pangocairo.h>
+#include <wlr/backend.h>
+#include <wlr/render/wlr_texture.h>
+#include <wlr/util/log.h>
+#include "config.h"
+#include "sway/input/input-manager.h"
+#include "sway/input/seat.h"
+#include "sway/server.h"
+#include "sway/tree/container.h"
+#include "sway/tree/layout.h"
+#include "cairo.h"
+#include "config.h"
+#include "pango.h"
+
+static const char *layout_to_str(enum sway_container_layout layout) {
+        switch (layout) {
+        case L_HORIZ:
+                return "L_HORIZ";
+        case L_VERT:
+                return "L_VERT";
+        case L_STACKED:
+                return "L_STACKED";
+        case L_TABBED:
+                return "L_TABBED";
+        case L_FLOATING:
+                return "L_FLOATING";
+        case L_NONE:
+        default:
+                return "L_NONE";
+        }
+}
+
+static int draw_container(cairo_t *cairo, struct sway_container *container,
+                struct sway_container *focus, int x, int y) {
+        int text_width, text_height;
+        get_text_size(cairo, "monospace", &text_width, &text_height,
+                1, false, "%s id:%zd '%s' %s %.fx%.f@%.f,%.f",
+                container_type_to_str(container->type), container->id, container->name,
+                layout_to_str(container->layout),
+                container->width, container->height, container->x, container->y);
+        cairo_save(cairo);
+        cairo_rectangle(cairo, x + 2, y, text_width - 2, text_height);
+        cairo_set_source_u32(cairo, 0xFFFFFFE0);
+        cairo_fill(cairo);
+        int height = text_height;
+        if (container->children) {
+                for (int i = 0; i < container->children->length; ++i) {
+                        struct sway_container *child = container->children->items[i];
+                        if (child->parent == container) {
+                                cairo_set_source_u32(cairo, 0x000000FF);
+                        } else {
+                                cairo_set_source_u32(cairo, 0xFF0000FF);
+                        }
+                        height += draw_container(cairo, child, focus, x + 10, y + height);
+                }
+        }
+        cairo_set_source_u32(cairo, 0xFFFFFFE0);
+        cairo_rectangle(cairo, x, y, 2, height);
+        cairo_fill(cairo);
+        cairo_restore(cairo);
+        cairo_move_to(cairo, x, y);
+        if (focus == container) {
+                cairo_set_source_u32(cairo, 0x0000FFFF);
+        }
+        pango_printf(cairo, "monospace", 1, false, "%s id:%zd '%s' %s %.fx%.f@%.f,%.f",
+                container_type_to_str(container->type), container->id, container->name,
+                layout_to_str(container->layout),
+                container->width, container->height, container->x, container->y);
+        return height;
+}
+
+bool enable_debug_tree = false;
+
+void update_debug_tree() {
+        if (!enable_debug_tree) {
+                return;
+        }
+
+        int width = 640, height = 480;
+        for (int i = 0; i < root_container.children->length; ++i) {
+                struct sway_container *container = root_container.children->items[i];
+                if (container->width > width) {
+                        width = container->width;
+                }
+                if (container->height > height) {
+                        height = container->height;
+                }
+        }
+        cairo_surface_t *surface =
+                cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+        cairo_t *cairo = cairo_create(surface);
+        PangoContext *pango = pango_cairo_create_context(cairo);
+
+        struct sway_seat *seat = NULL;
+        wl_list_for_each(seat, &input_manager->seats, link) {
+                break;
+        }
+
+        struct sway_container *focus = NULL;
+        if (seat != NULL) {
+                focus = seat_get_focus(seat);
+        }
+        cairo_set_source_u32(cairo, 0x000000FF);
+        draw_container(cairo, &root_container, focus, 0, 0);
+
+        cairo_surface_flush(surface);
+        struct wlr_renderer *renderer = wlr_backend_get_renderer(server.backend);
+        if (root_container.sway_root->debug_tree) {
+                wlr_texture_destroy(root_container.sway_root->debug_tree);
+        }
+        unsigned char *data = cairo_image_surface_get_data(surface);
+        int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
+        struct wlr_texture *texture = wlr_texture_from_pixels(renderer,
+                WL_SHM_FORMAT_ARGB8888, stride, width, height, data);
+        root_container.sway_root->debug_tree = texture;
+        cairo_surface_destroy(surface);
+        g_object_unref(pango);
+        cairo_destroy(cairo);
+}
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index aa18f1b8..ad777796 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -294,6 +294,11 @@ static void render_output(struct sway_output *output, struct timespec *when,
                 &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
 
 renderer_end:
+        if (root_container.sway_root->debug_tree) {
+                wlr_render_texture(renderer, root_container.sway_root->debug_tree,
+                        wlr_output->transform_matrix, 0, 0, 1);
+        }
+
         wlr_renderer_end(renderer);
         if (!wlr_output_damage_swap_buffers(output->damage, when, damage)) {
                 return;
diff --git a/sway/input/seat.c b/sway/input/seat.c
index ad3584a0..e8cf9824 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -5,6 +5,7 @@
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "sway/debug.h"
 #include "sway/tree/container.h"
 #include "sway/tree/workspace.h"
 #include "sway/input/seat.h"
@@ -432,6 +433,8 @@ void seat_set_focus_warp(struct sway_seat *seat,
         }
 
         seat->has_focus = (container != NULL);
+
+        update_debug_tree();
 }
 
 void seat_set_focus(struct sway_seat *seat,
diff --git a/sway/main.c b/sway/main.c
index e7f8ddd3..efb674b6 100644
--- a/sway/main.c
+++ b/sway/main.c
@@ -17,6 +17,7 @@
 #endif
 #include <wlr/util/log.h>
 #include "sway/config.h"
+#include "sway/debug.h"
 #include "sway/server.h"
 #include "sway/tree/layout.h"
 #include "sway/ipc-server.h"
@@ -288,7 +289,7 @@ int main(int argc, char **argv) {
         int c;
         while (1) {
                 int option_index = 0;
-                c = getopt_long(argc, argv, "hCdvVc:", long_options, &option_index);
+                c = getopt_long(argc, argv, "hCdDvVc:", long_options, &option_index);
                 if (c == -1) {
                         break;
                 }
@@ -306,6 +307,9 @@ int main(int argc, char **argv) {
                 case 'd': // debug
                         debug = 1;
                         break;
+                case 'D': // extended debug options
+                        enable_debug_tree = true;
+                        break;
                 case 'v': // version
                         fprintf(stdout, "sway version " SWAY_VERSION "\n");
                         exit(EXIT_SUCCESS);
diff --git a/sway/meson.build b/sway/meson.build
index 29aaa7b7..1fe0f29a 100644
--- a/sway/meson.build
+++ b/sway/meson.build
@@ -4,6 +4,7 @@ sway_sources = files(
         'commands.c',
         'config.c',
         'criteria.c',
+        'debug-tree.c',
         'ipc-json.c',
         'ipc-server.c',
         'security.c',
@@ -102,10 +103,13 @@ sway_sources = files(
 )
 
 sway_deps = [
+        cairo,
+        gdk_pixbuf,
         jsonc,
         libcap,
         libinput,
         math,
+        pango,
         pcre,
         pixman,
         server_protos,
diff --git a/sway/tree/container.c b/sway/tree/container.c
index ab8363bc..ea1c93bb 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -208,7 +208,7 @@ static void container_root_finish(struct sway_container *con) {
         wlr_log(L_ERROR, "TODO: destroy the root container");
 }
 
-static bool container_reap_empty(struct sway_container *con) {
+bool container_reap_empty(struct sway_container *con) {
         switch (con->type) {
         case C_ROOT:
         case C_OUTPUT:
@@ -225,14 +225,6 @@ static bool container_reap_empty(struct sway_container *con) {
                 if (con->children->length == 0) {
                         _container_destroy(con);
                         return true;
-                } else if (con->children->length == 1) {
-                        struct sway_container *child = con->children->items[0];
-                        if (child->type == C_CONTAINER) {
-                                container_remove_child(child);
-                                container_replace_child(con, child);
-                                _container_destroy(con);
-                                return true;
-                        }
                 }
         case C_VIEW:
                 break;
@@ -245,6 +237,29 @@ static bool container_reap_empty(struct sway_container *con) {
         return false;
 }
 
+struct sway_container *container_reap_empty_recursive(
+                struct sway_container *con) {
+        while (con) {
+                struct sway_container *next = con->parent;
+                if (!container_reap_empty(con)) {
+                        break;
+                }
+                con = next;
+        }
+        return con;
+}
+
+struct sway_container *container_flatten(struct sway_container *container) {
+        while (container->type == C_CONTAINER && container->children->length == 1) {
+                struct sway_container *child = container->children->items[0];
+                struct sway_container *parent = container->parent;
+                container_replace_child(container, child);
+                container_destroy(container);
+                container = parent;
+        }
+        return container;
+}
+
 struct sway_container *container_destroy(struct sway_container *con) {
         if (con == NULL) {
                 return NULL;
@@ -283,18 +298,7 @@ struct sway_container *container_destroy(struct sway_container *con) {
                         break;
         }
 
-        struct sway_container *tmp = parent;
-        while (parent) {
-                tmp = parent->parent;
-
-                if (!container_reap_empty(parent)) {
-                        break;
-                }
-
-                parent = tmp;
-        }
-
-        return tmp;
+        return container_reap_empty_recursive(parent);
 }
 
 static void container_close_func(struct sway_container *container, void *data) {
diff --git a/sway/tree/layout.c b/sway/tree/layout.c
index 343f349a..78af8b8c 100644
--- a/sway/tree/layout.c
+++ b/sway/tree/layout.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_output_layout.h>
+#include "sway/debug.h"
 #include "sway/tree/container.h"
 #include "sway/tree/layout.h"
 #include "sway/output.h"
@@ -100,13 +101,31 @@ static int index_child(const struct sway_container *child) {
         return i;
 }
 
+void container_insert_child(struct sway_container *parent,
+                struct sway_container *child, int i) {
+        struct sway_container *old_parent = child->parent;
+        if (old_parent) {
+                container_remove_child(child);
+        }
+        wlr_log(L_DEBUG, "Inserting id:%zd at index %d", child->id, i);
+        list_insert(parent->children, i, child);
+        child->parent = parent;
+        wl_signal_emit(&child->events.reparent, old_parent);
+}
+
 struct sway_container *container_add_sibling(struct sway_container *fixed,
                 struct sway_container *active) {
         // TODO handle floating
+        struct sway_container *old_parent = NULL;
+        if (active->parent) {
+                old_parent = active->parent;
+                container_remove_child(active);
+        }
         struct sway_container *parent = fixed->parent;
         int i = index_child(fixed);
         list_insert(parent->children, i + 1, active);
         active->parent = parent;
+        wl_signal_emit(&active->events.reparent, old_parent);
         return active->parent;
 }
 
@@ -166,9 +185,290 @@ void container_move_to(struct sway_container *container,
         arrange_windows(new_parent, -1, -1);
 }
 
+static bool sway_dir_to_wlr(enum movement_direction dir,
+                enum wlr_direction *out) {
+        switch (dir) {
+        case MOVE_UP:
+                *out = WLR_DIRECTION_UP;
+                break;
+        case MOVE_DOWN:
+                *out = WLR_DIRECTION_DOWN;
+                break;
+        case MOVE_LEFT:
+                *out = WLR_DIRECTION_LEFT;
+                break;
+        case MOVE_RIGHT:
+                *out = WLR_DIRECTION_RIGHT;
+                break;
+        default:
+                return false;
+        }
+
+        return true;
+}
+
+static bool is_parallel(enum sway_container_layout layout,
+                enum movement_direction dir) {
+        switch (layout) {
+        case L_TABBED:
+        case L_STACKED:
+        case L_HORIZ:
+                return dir == MOVE_LEFT || dir == MOVE_RIGHT;
+        case L_VERT:
+                return dir == MOVE_UP || dir == MOVE_DOWN;
+        default:
+                return false;
+        }
+}
+
+static enum movement_direction invert_movement(enum movement_direction dir) {
+        switch (dir) {
+        case MOVE_LEFT:
+                return MOVE_RIGHT;
+        case MOVE_RIGHT:
+                return MOVE_LEFT;
+        case MOVE_UP:
+                return MOVE_DOWN;
+        case MOVE_DOWN:
+                return MOVE_UP;
+        default:
+                sway_assert(0, "This function expects left|right|up|down");
+                return MOVE_LEFT;
+        }
+}
+
+static int move_offs(enum movement_direction move_dir) {
+        return move_dir == MOVE_LEFT || move_dir == MOVE_UP ? -1 : 1;
+}
+
+/* Gets the index of the most extreme member based on the movement offset */
+static int container_limit(struct sway_container *container,
+                enum movement_direction move_dir) {
+        return move_offs(move_dir) < 0 ? 0 : container->children->length;
+}
+
+/* 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_container *ws,
+                struct sway_container *child, enum movement_direction move_dir) {
+        struct sway_container *original_parent = child->parent;
+        struct sway_container *new_parent =
+                container_split(ws, ws->layout);
+
+        container_remove_child(child);
+        for (int i = 0; i < ws->children->length; ++i) {
+                struct sway_container *_child = ws->children->items[i];
+                container_move_to(new_parent, _child);
+        }
+
+        int index = move_offs(move_dir);
+        container_insert_child(ws, child, index < 0 ? 0 : 1);
+        container_set_layout(ws,
+                        move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT);
+
+        container_flatten(ws);
+        container_reap_empty_recursive(original_parent);
+        wl_signal_emit(&child->events.reparent, original_parent);
+        arrange_windows(ws, -1, -1);
+}
+
 void container_move(struct sway_container *container,
-                enum movement_direction dir, int move_amt) {
-        // TODO
+                enum movement_direction move_dir, int move_amt) {
+        if (!sway_assert(
+                                container->type != C_CONTAINER || container->type != C_VIEW,
+                                "Can only move containers and views")) {
+                return;
+        }
+        int offs = move_offs(move_dir);
+
+        struct sway_container *sibling = NULL;
+        struct sway_container *current = container;
+        struct sway_container *parent = current->parent;
+
+        if (parent != container_flatten(parent)) {
+                // Special case: we were the last one in this container, so flatten it
+                // and leave
+                update_debug_tree();
+                return;
+        }
+
+        while (!sibling) {
+                if (current->type == C_ROOT) {
+                        return;
+                }
+
+                parent = current->parent;
+                wlr_log(L_DEBUG, "Visiting %p %s '%s'", current,
+                                container_type_to_str(current->type), current->name);
+
+                int index = index_child(current);
+
+                switch (current->type) {
+                case C_OUTPUT: {
+                        enum wlr_direction wlr_dir;
+                        sway_dir_to_wlr(move_dir, &wlr_dir);
+                        double ref_lx = current->x + current->width / 2;
+                        double ref_ly = current->y + current->height / 2;
+                        struct wlr_output *next = wlr_output_layout_adjacent_output(
+                                root_container.sway_root->output_layout, wlr_dir,
+                                current->sway_output->wlr_output, ref_lx, ref_ly);
+                        if (!next) {
+                                wlr_log(L_DEBUG, "Hit edge of output, nowhere else to go");
+                                return;
+                        }
+                        struct sway_output *next_output = next->data;
+                        current = next_output->swayc;
+                        wlr_log(L_DEBUG, "Selected next output (%s)", current->name);
+                        // Select workspace and get outta here
+                        current = seat_get_focus_inactive(
+                                        config->handler_context.seat, current);
+                        if (current->type != C_WORKSPACE) {
+                                current = container_parent(current, C_WORKSPACE);
+                        }
+                        sibling = current;
+                        break;
+                }
+                case C_WORKSPACE:
+                        if (!is_parallel(current->layout, move_dir)) {
+                                if (current->children->length > 2) {
+                                        wlr_log(L_DEBUG, "Rejiggering the workspace (%d kiddos)",
+                                                        current->children->length);
+                                        workspace_rejigger(current, container, move_dir);
+                                } else if (current->children->length == 2) {
+                                        wlr_log(L_DEBUG, "Changing workspace layout");
+                                        container_set_layout(current,
+                                                move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ?
+                                                L_HORIZ : L_VERT);
+                                        container_insert_child(current, container, offs < 0 ? 0 : 1);
+                                        arrange_windows(current, -1, -1);
+                                }
+                                return;
+                        } else {
+                                wlr_log(L_DEBUG, "Selecting output");
+                                current = current->parent;
+                        }
+                        break;
+                case C_CONTAINER:
+                case C_VIEW:
+                        if (is_parallel(parent->layout, move_dir)) {
+                                if ((index == parent->children->length - 1 && offs > 0)
+                                                || (index == 0 && offs < 0)) {
+                                        if (current->parent == container->parent) {
+                                                wlr_log(L_DEBUG, "Hit limit, selecting parent");
+                                                current = current->parent;
+                                        } else {
+                                                wlr_log(L_DEBUG, "Hit limit, "
+                                                                "promoting descendant to sibling");
+                                                // Special case
+                                                struct sway_container *old_parent = container->parent;
+                                                container_insert_child(current->parent, container,
+                                                                index + (offs < 0 ? 0 : 1));
+                                                container->width = container->height = 0;
+                                                arrange_windows(current->parent, -1, -1);
+                                                arrange_windows(old_parent, -1, -1);
+                                                return;
+                                        }
+                                } else {
+                                        sibling = parent->children->items[index + offs];
+                                        wlr_log(L_DEBUG, "Selecting sibling id:%zd", sibling->id);
+                                }
+                        } else {
+                                wlr_log(L_DEBUG, "Moving up to find a parallel container");
+                                current = current->parent;
+                        }
+                        break;
+                default:
+                        sway_assert(0, "Not expecting to see container of type %s here",
+                                        container_type_to_str(current->type));
+                        return;
+                }
+        }
+
+        // Part two: move stuff around
+        int index = index_child(container);
+        struct sway_container *old_parent = container->parent;
+
+        while (sibling) {
+                switch (sibling->type) {
+                case C_VIEW:
+                        if (sibling->parent == container->parent) {
+                                wlr_log(L_DEBUG, "Swapping siblings");
+                                sibling->parent->children->items[index + offs] = container;
+                                sibling->parent->children->items[index] = sibling;
+                                arrange_windows(sibling->parent, -1, -1);
+                        } else {
+                                wlr_log(L_DEBUG, "Promoting to sibling of cousin");
+                                container_insert_child(sibling->parent, container,
+                                                index_child(sibling) + (offs > 0 ? 0 : 1));
+                                container->width = container->height = 0;
+                                arrange_windows(sibling->parent, -1, -1);
+                                arrange_windows(old_parent, -1, -1);
+                        }
+                        sibling = NULL;
+                        break;
+                case C_WORKSPACE: // Note: only in the case of moving between outputs
+                case C_CONTAINER:
+                        if (is_parallel(sibling->layout, move_dir)) {
+                                int limit = container_limit(sibling, invert_movement(move_dir));
+                                wlr_log(L_DEBUG, "limit: %d", limit);
+                                wlr_log(L_DEBUG,
+                                                "Reparenting container (parallel) to index %d "
+                                                "(move dir: %d)", limit, move_dir);
+                                container_insert_child(sibling, container, limit);
+                                container->width = container->height = 0;
+                                arrange_windows(sibling, -1, -1);
+                                arrange_windows(old_parent, -1, -1);
+                                sibling = NULL;
+                        } else {
+                                wlr_log(L_DEBUG, "Reparenting container (perpendicular)");
+                                container_remove_child(container);
+                                struct sway_container *focus_inactive = seat_get_focus_inactive(
+                                                config->handler_context.seat, sibling);
+                                if (focus_inactive) {
+                                        while (focus_inactive->parent != sibling) {
+                                                focus_inactive = focus_inactive->parent;
+                                        }
+                                        wlr_log(L_DEBUG, "Focus inactive: id:%zd",
+                                                        focus_inactive->id);
+                                        sibling = focus_inactive;
+                                        continue;
+                                } else if (sibling->children->length) {
+                                        wlr_log(L_DEBUG, "No focus-inactive, adding arbitrarily");
+                                        container_add_sibling(sibling->children->items[0], container);
+                                } else {
+                                        wlr_log(L_DEBUG, "No kiddos, adding container alone");
+                                        container_add_child(sibling, container);
+                                }
+                                container->width = container->height = 0;
+                                arrange_windows(sibling, -1, -1);
+                                arrange_windows(old_parent, -1, -1);
+                                sibling = NULL;
+                        }
+                        break;
+                default:
+                        sway_assert(0, "Not expecting to see container of type %s here",
+                                        container_type_to_str(sibling->type));
+                        return;
+                }
+        }
+
+        if (old_parent) {
+                seat_set_focus(config->handler_context.seat, old_parent);
+                seat_set_focus(config->handler_context.seat, container);
+        }
+
+        struct sway_container *last_ws = old_parent;
+        struct sway_container *next_ws = container->parent;
+        if (last_ws && last_ws->type != C_WORKSPACE) {
+                last_ws = container_parent(last_ws, C_WORKSPACE);
+        }
+        if (next_ws && next_ws->type != C_WORKSPACE) {
+                next_ws = container_parent(next_ws, C_WORKSPACE);
+        }
+        if (last_ws && next_ws && last_ws != next_ws) {
+                ipc_event_workspace(last_ws, container, "focus");
+        }
 }
 
 enum sway_container_layout container_get_default_layout(
@@ -320,6 +620,9 @@ void arrange_windows(struct sway_container *container,
                         container->children->length);
                 break;
         }
+        container_damage_whole(container);
+        // TODO: Make this less shitty
+        update_debug_tree();
 }
 
 static void apply_horiz_layout(struct sway_container *container,
@@ -512,28 +815,6 @@ static void get_layout_center_position(struct sway_container *container,
         }
 }
 
-static bool sway_dir_to_wlr(enum movement_direction dir,
-                enum wlr_direction *out) {
-        switch (dir) {
-        case MOVE_UP:
-                *out = WLR_DIRECTION_UP;
-                break;
-        case MOVE_DOWN:
-                *out = WLR_DIRECTION_DOWN;
-                break;
-        case MOVE_LEFT:
-                *out = WLR_DIRECTION_LEFT;
-                break;
-        case MOVE_RIGHT:
-                *out = WLR_DIRECTION_RIGHT;
-                break;
-        default:
-                return false;
-        }
-
-        return true;
-}
-
 static struct sway_container *sway_output_from_wlr(struct wlr_output *output) {
         if (output == NULL) {
                 return NULL;
@@ -673,6 +954,9 @@ struct sway_container *container_replace_child(struct sway_container *child,
         int i = index_child(child);
 
         // TODO floating
+        if (new_child->parent) {
+                container_remove_child(new_child);
+        }
         parent->children->items[i] = new_child;
         new_child->parent = parent;
         child->parent = NULL;
@@ -696,6 +980,14 @@ struct sway_container *container_split(struct sway_container *child,
         if (!sway_assert(child, "child cannot be null")) {
                 return NULL;
         }
+        if (child->type == C_WORKSPACE && child->children->length == 0) {
+                // Special case: this just behaves like splitt
+                child->prev_layout = child->layout;
+                child->layout = layout;
+                arrange_windows(child, -1, -1);
+                return child;
+        }
+
         struct sway_container *cont = container_create(C_CONTAINER);
 
         wlr_log(L_DEBUG, "creating container %p around %p", cont, child);
@@ -718,7 +1010,9 @@ struct sway_container *container_split(struct sway_container *child,
                 }
 
                 container_add_child(workspace, cont);
+                enum sway_container_layout old_layout = workspace->layout;
                 container_set_layout(workspace, layout);
+                cont->layout = old_layout;
 
                 if (set_focus) {
                         seat_set_focus(seat, cont);
diff --git a/swaybar/ipc.c b/swaybar/ipc.c
index 92dbb8ea..e6231bd2 100644
--- a/swaybar/ipc.c
+++ b/swaybar/ipc.c
@@ -331,7 +331,7 @@ bool handle_ipc_readable(struct swaybar *bar) {
         switch (resp->type) {
         case IPC_EVENT_WORKSPACE:
                 ipc_get_workspaces(bar);
-                break;
+                return true;
         case IPC_EVENT_MODE: {
                 json_object *result = json_tokener_parse(resp->payload);
                 if (!result) {