12 files changed, 421 insertions, 143 deletions

diff --git a/sway/input/cursor.c b/sway/input/cursor.c
index fa604426..cbb5c6e9 100644
--- a/sway/input/cursor.c
+++ b/sway/input/cursor.c
@@ -20,7 +20,6 @@
 #include "util.h"
 #include "sway/commands.h"
 #include "sway/desktop.h"
-#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/keyboard.h"
 #include "sway/input/tablet.h"
@@ -383,7 +382,6 @@ static void handle_pointer_motion_relative(
 
         pointer_motion(cursor, e->time_msec, e->device, e->delta_x, e->delta_y,
                         e->unaccel_dx, e->unaccel_dy);
-        transaction_commit_dirty();
 }
 
 static void handle_pointer_motion_absolute(
@@ -401,7 +399,6 @@ static void handle_pointer_motion_absolute(
         double dy = ly - cursor->cursor->y;
 
         pointer_motion(cursor, event->time_msec, event->device, dx, dy, dx, dy);
-        transaction_commit_dirty();
 }
 
 void dispatch_cursor_button(struct sway_cursor *cursor,
@@ -431,7 +428,6 @@ static void handle_pointer_button(struct wl_listener *listener, void *data) {
         cursor_handle_activity_from_device(cursor, event->device);
         dispatch_cursor_button(cursor, event->device,
                         event->time_msec, event->button, event->state);
-        transaction_commit_dirty();
 }
 
 void dispatch_cursor_axis(struct sway_cursor *cursor,
@@ -444,7 +440,6 @@ static void handle_pointer_axis(struct wl_listener *listener, void *data) {
         struct wlr_event_pointer_axis *event = data;
         cursor_handle_activity_from_device(cursor, event->device);
         dispatch_cursor_axis(cursor, event);
-        transaction_commit_dirty();
 }
 
 static void handle_pointer_frame(struct wl_listener *listener, void *data) {
@@ -495,7 +490,6 @@ static void handle_touch_down(struct wl_listener *listener, void *data) {
                 dispatch_cursor_button(cursor, event->device, event->time_msec,
                                 BTN_LEFT, WLR_BUTTON_PRESSED);
                 wlr_seat_pointer_notify_frame(wlr_seat);
-                transaction_commit_dirty();
         }
 }
 
@@ -512,7 +506,6 @@ static void handle_touch_up(struct wl_listener *listener, void *data) {
                         dispatch_cursor_button(cursor, event->device, event->time_msec,
                                         BTN_LEFT, WLR_BUTTON_RELEASED);
                         wlr_seat_pointer_notify_frame(wlr_seat);
-                        transaction_commit_dirty();
                 }
         } else {
                 wlr_seat_touch_notify_up(wlr_seat, event->time_msec, event->touch_id);
@@ -553,7 +546,6 @@ static void handle_touch_motion(struct wl_listener *listener, void *data) {
                         dx = lx - cursor->cursor->x;
                         dy = ly - cursor->cursor->y;
                         pointer_motion(cursor, event->time_msec, event->device, dx, dy, dx, dy);
-                        transaction_commit_dirty();
                 }
         } else if (surface) {
                 wlr_seat_touch_notify_motion(wlr_seat, event->time_msec,
@@ -639,8 +631,6 @@ static void handle_tablet_tool_position(struct sway_cursor *cursor,
                 wlr_tablet_v2_tablet_tool_notify_proximity_out(tool->tablet_v2_tool);
                 pointer_motion(cursor, time_msec, input_device->wlr_device, dx, dy, dx, dy);
         }
-
-        transaction_commit_dirty();
 }
 
 static void handle_tool_axis(struct wl_listener *listener, void *data) {
@@ -720,7 +710,6 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) {
                 dispatch_cursor_button(cursor, event->device, event->time_msec,
                         BTN_LEFT, WLR_BUTTON_RELEASED);
                 wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
-                transaction_commit_dirty();
         } else if (!surface || !wlr_surface_accepts_tablet_v2(tablet_v2, surface)) {
                 // If we started holding the tool tip down on a surface that accepts
                 // tablet v2, we should notify that surface if it gets released over a
@@ -733,7 +722,6 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) {
                         dispatch_cursor_button(cursor, event->device, event->time_msec,
                                 BTN_LEFT, WLR_BUTTON_PRESSED);
                         wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
-                        transaction_commit_dirty();
                 }
         } else {
                 seatop_tablet_tool_tip(seat, sway_tool, event->time_msec, event->state);
@@ -820,7 +808,6 @@ static void handle_tool_button(struct wl_listener *listener, void *data) {
                         break;
                 }
                 wlr_seat_pointer_notify_frame(cursor->seat->wlr_seat);
-                transaction_commit_dirty();
                 return;
         }
 
@@ -837,8 +824,8 @@ static void check_constraint_region(struct sway_cursor *cursor) {
 
                 struct sway_container *con = view->container;
 
-                double sx = cursor->cursor->x - con->content_x + view->geometry.x;
-                double sy = cursor->cursor->y - con->content_y + view->geometry.y;
+                double sx = cursor->cursor->x - con->pending.content_x + view->geometry.x;
+                double sy = cursor->cursor->y - con->pending.content_y + view->geometry.y;
 
                 if (!pixman_region32_contains_point(region,
                                 floor(sx), floor(sy), NULL)) {
@@ -849,8 +836,8 @@ static void check_constraint_region(struct sway_cursor *cursor) {
                                 double sy = (boxes[0].y1 + boxes[0].y2) / 2.;
 
                                 wlr_cursor_warp_closest(cursor->cursor, NULL,
-                                        sx + con->content_x - view->geometry.x,
-                                        sy + con->content_y - view->geometry.y);
+                                        sx + con->pending.content_x - view->geometry.x,
+                                        sy + con->pending.content_y - view->geometry.y);
 
                                 cursor_rebase(cursor);
                         }
@@ -1170,8 +1157,8 @@ void cursor_warp_to_container(struct sway_cursor *cursor,
                 return;
         }
 
-        double x = container->x + container->width / 2.0;
-        double y = container->y + container->height / 2.0;
+        double x = container->pending.x + container->pending.width / 2.0;
+        double y = container->pending.y + container->pending.height / 2.0;
 
         wlr_cursor_warp(cursor->cursor, NULL, x, y);
         cursor_unhide(cursor);
@@ -1284,8 +1271,8 @@ static void warp_to_constraint_cursor_hint(struct sway_cursor *cursor) {
                 struct sway_view *view = view_from_wlr_surface(constraint->surface);
                 struct sway_container *con = view->container;
 
-                double lx = sx + con->content_x - view->geometry.x;
-                double ly = sy + con->content_y - view->geometry.y;
+                double lx = sx + con->pending.content_x - view->geometry.x;
+                double ly = sy + con->pending.content_y - view->geometry.y;
 
                 wlr_cursor_warp(cursor->cursor, NULL, lx, ly);
 
diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c
index ce259eb2..f258ac7d 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -9,7 +9,6 @@
 #include <wlr/types/wlr_keyboard_group.h>
 #include <xkbcommon/xkbcommon-names.h>
 #include "sway/commands.h"
-#include "sway/desktop/transaction.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
 #include "sway/input/seat.h"
@@ -379,6 +378,28 @@ static void update_keyboard_state(struct sway_keyboard *keyboard,
         }
 }
 
+/**
+ * Get keyboard grab of the seat from sway_keyboard if we should forward events
+ * to it.
+ *
+ * Returns NULL if the keyboard is not grabbed by an input method,
+ * or if event is from virtual keyboard of the same client as grab.
+ * TODO: see swaywm/wlroots#2322
+ */
+static struct wlr_input_method_keyboard_grab_v2 *keyboard_get_im_grab(
+                struct sway_keyboard *keyboard) {
+        struct wlr_input_method_v2 *input_method = keyboard->seat_device->
+                sway_seat->im_relay.input_method;
+        struct wlr_virtual_keyboard_v1 *virtual_keyboard =
+                wlr_input_device_get_virtual_keyboard(keyboard->seat_device->input_device->wlr_device);
+        if (!input_method || !input_method->keyboard_grab || (virtual_keyboard &&
+                                wl_resource_get_client(virtual_keyboard->resource) ==
+                                wl_resource_get_client(input_method->keyboard_grab->resource))) {
+                return NULL;
+        }
+        return input_method->keyboard_grab;
+}
+
 static void handle_key_event(struct sway_keyboard *keyboard,
                 struct wlr_event_keyboard_key *event) {
         struct sway_seat *seat = keyboard->seat_device->sway_seat;
@@ -489,18 +510,42 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                                 keyinfo.raw_keysyms_len);
         }
 
-        if (!handled || event->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
+        if (event->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
+                // If the pressed event was sent to a client, also send the released
+                // event. In particular, don't send the released event to the IM grab.
                 bool pressed_sent = update_shortcut_state(
-                                &keyboard->state_pressed_sent, event->keycode, event->state,
-                                keyinfo.keycode, 0);
-                if (pressed_sent || event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+                        &keyboard->state_pressed_sent, event->keycode,
+                        event->state, keyinfo.keycode, 0);
+                if (pressed_sent) {
                         wlr_seat_set_keyboard(wlr_seat, wlr_device);
                         wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
-                                        event->keycode, event->state);
+                                event->keycode, event->state);
+                        handled = true;
+                }
+        }
+
+        if (!handled) {
+                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
+
+                if (kb_grab) {
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab,
+                                wlr_device->keyboard);
+                        wlr_input_method_keyboard_grab_v2_send_key(kb_grab,
+                                event->time_msec, event->keycode, event->state);
+                        handled = true;
                 }
         }
 
-        transaction_commit_dirty();
+        if (!handled && event->state != WL_KEYBOARD_KEY_STATE_RELEASED) {
+                // If a released event failed pressed sent test, and not in sent to
+                // keyboard grab, it is still not handled. Don't handle released here.
+                update_shortcut_state(
+                        &keyboard->state_pressed_sent, event->keycode, event->state,
+                        keyinfo.keycode, 0);
+                wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
+                                event->keycode, event->state);
+        }
 
         free(device_identifier);
 }
@@ -587,7 +632,6 @@ static int handle_keyboard_repeat(void *data) {
 
                 seat_execute_command(keyboard->seat_device->sway_seat,
                                 keyboard->repeat_binding);
-                transaction_commit_dirty();
         }
         return 0;
 }
@@ -617,10 +661,19 @@ static void handle_modifier_event(struct sway_keyboard *keyboard) {
         struct wlr_input_device *wlr_device =
                 keyboard->seat_device->input_device->wlr_device;
         if (!wlr_device->keyboard->group) {
-                struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
-                wlr_seat_set_keyboard(wlr_seat, wlr_device);
-                wlr_seat_keyboard_notify_modifiers(wlr_seat,
-                                &wlr_device->keyboard->modifiers);
+                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
+
+                if (kb_grab) {
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab,
+                                        wlr_device->keyboard);
+                        wlr_input_method_keyboard_grab_v2_send_modifiers(kb_grab,
+                                        &wlr_device->keyboard->modifiers);
+                } else {
+                        struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
+                        wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                        wlr_seat_keyboard_notify_modifiers(wlr_seat,
+                                        &wlr_device->keyboard->modifiers);
+                }
 
                 uint32_t modifiers = wlr_keyboard_get_modifiers(wlr_device->keyboard);
                 determine_bar_visibility(modifiers);
diff --git a/sway/input/libinput.c b/sway/input/libinput.c
index 54520f9e..060a584a 100644
--- a/sway/input/libinput.c
+++ b/sway/input/libinput.c
@@ -1,5 +1,6 @@
 #include <float.h>
 #include <libinput.h>
+#include <libudev.h>
 #include <limits.h>
 #include <wlr/backend/libinput.h>
 #include "log.h"
@@ -312,3 +313,25 @@ void sway_input_reset_libinput_device(struct sway_input_device *input_device) {
                 ipc_event_input("libinput_config", input_device);
         }
 }
+
+bool sway_libinput_device_is_builtin(struct sway_input_device *sway_device) {
+        if (!wlr_input_device_is_libinput(sway_device->wlr_device)) {
+                return false;
+        }
+
+        struct libinput_device *device =
+                wlr_libinput_get_device_handle(sway_device->wlr_device);
+        struct udev_device *udev_device =
+                libinput_device_get_udev_device(device);
+        if (!udev_device) {
+                return false;
+        }
+
+        const char *id_path = udev_device_get_property_value(udev_device, "ID_PATH");
+        if (!id_path) {
+                return false;
+        }
+
+        const char prefix[] = "platform-";
+        return strncmp(id_path, prefix, strlen(prefix)) == 0;
+}
diff --git a/sway/input/seat.c b/sway/input/seat.c
index 1f5865ee..2d714acd 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -20,6 +20,7 @@
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
+#include "sway/input/libinput.h"
 #include "sway/input/seat.h"
 #include "sway/input/switch.h"
 #include "sway/input/tablet.h"
@@ -309,8 +310,8 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                 // Setting focus_inactive
                 focus = seat_get_focus_inactive(seat, &root->node);
                 seat_set_raw_focus(seat, next_focus);
-                if (focus->type == N_CONTAINER && focus->sway_container->workspace) {
-                        seat_set_raw_focus(seat, &focus->sway_container->workspace->node);
+                if (focus->type == N_CONTAINER && focus->sway_container->pending.workspace) {
+                        seat_set_raw_focus(seat, &focus->sway_container->pending.workspace->node);
                 }
                 seat_set_raw_focus(seat, focus);
         }
@@ -666,6 +667,40 @@ static void seat_reset_input_config(struct sway_seat *seat,
                 sway_device->input_device->wlr_device, NULL);
 }
 
+static bool has_prefix(const char *str, const char *prefix) {
+        return strncmp(str, prefix, strlen(prefix)) == 0;
+}
+
+/**
+ * Get the name of the built-in output, if any. Returns NULL if there isn't
+ * exactly one built-in output.
+ */
+static const char *get_builtin_output_name(void) {
+        const char *match = NULL;
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                const char *name = output->wlr_output->name;
+                if (has_prefix(name, "eDP-") || has_prefix(name, "LVDS-") ||
+                                has_prefix(name, "DSI-")) {
+                        if (match != NULL) {
+                                return NULL;
+                        }
+                        match = name;
+                }
+        }
+        return match;
+}
+
+static bool is_touch_or_tablet_tool(struct sway_seat_device *seat_device) {
+        switch (seat_device->input_device->wlr_device->type) {
+        case WLR_INPUT_DEVICE_TOUCH:
+        case WLR_INPUT_DEVICE_TABLET_TOOL:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static void seat_apply_input_config(struct sway_seat *seat,
                 struct sway_seat_device *sway_device) {
         struct input_config *ic =
@@ -681,7 +716,21 @@ static void seat_apply_input_config(struct sway_seat *seat,
 
         switch (mapped_to) {
         case MAPPED_TO_DEFAULT:
+                /*
+                 * If the wlroots backend provides an output name, use that.
+                 *
+                 * Otherwise, try to map built-in touch and tablet tool devices to the
+                 * built-in output.
+                 */
                 mapped_to_output = sway_device->input_device->wlr_device->output_name;
+                if (mapped_to_output == NULL && is_touch_or_tablet_tool(sway_device) &&
+                                sway_libinput_device_is_builtin(sway_device->input_device)) {
+                        mapped_to_output = get_builtin_output_name();
+                        if (mapped_to_output) {
+                                sway_log(SWAY_DEBUG, "Auto-detected output '%s' for device '%s'",
+                                        mapped_to_output, sway_device->input_device->identifier);
+                        }
+                }
                 if (mapped_to_output == NULL) {
                         return;
                 }
@@ -1086,30 +1135,19 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         }
 
         struct sway_workspace *new_workspace = node->type == N_WORKSPACE ?
-                node->sway_workspace : node->sway_container->workspace;
+                node->sway_workspace : node->sway_container->pending.workspace;
         struct sway_container *container = node->type == N_CONTAINER ?
                 node->sway_container : NULL;
 
-        // Deny setting focus to a view which is hidden by a fullscreen container
-        if (new_workspace && new_workspace->fullscreen && container &&
-                        !container_is_fullscreen_or_child(container)) {
-                // Unless it's a transient container
-                if (!container_is_transient_for(container, new_workspace->fullscreen)) {
-                        return;
-                }
+        // Deny setting focus to a view which is hidden by a fullscreen container or global
+        if (container && container_obstructing_fullscreen_container(container)) {
+                return;
         }
+
         // Deny setting focus to a workspace node when using fullscreen global
         if (root->fullscreen_global && !container && new_workspace) {
                 return;
         }
-        // Deny setting focus to a view which is hidden by a fullscreen global
-        if (root->fullscreen_global && container != root->fullscreen_global &&
-                                !container_has_ancestor(container, root->fullscreen_global)) {
-                // Unless it's a transient container
-                if (!container_is_transient_for(container, root->fullscreen_global)) {
-                        return;
-                }
-        }
 
         struct sway_output *new_output =
                 new_workspace ? new_workspace->output : NULL;
@@ -1135,10 +1173,10 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         // Put the container parents on the focus stack, then the workspace, then
         // the focused container.
         if (container) {
-                struct sway_container *parent = container->parent;
+                struct sway_container *parent = container->pending.parent;
                 while (parent) {
                         seat_set_raw_focus(seat, &parent->node);
-                        parent = parent->parent;
+                        parent = parent->pending.parent;
                 }
         }
         if (new_workspace) {
@@ -1234,6 +1272,7 @@ void seat_set_focus_surface(struct sway_seat *seat,
                 wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
         }
 
+        sway_input_method_relay_set_focus(&seat->im_relay, surface);
         seat_tablet_pads_notify_enter(seat, surface);
 }
 
@@ -1326,7 +1365,7 @@ struct sway_container *seat_get_focus_inactive_tiling(struct sway_seat *seat,
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
                                 !container_is_floating_or_child(node->sway_container) &&
-                                node->sway_container->workspace == workspace) {
+                                node->sway_container->pending.workspace == workspace) {
                         return node->sway_container;
                 }
         }
@@ -1343,7 +1382,7 @@ struct sway_container *seat_get_focus_inactive_floating(struct sway_seat *seat,
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
                                 container_is_floating_or_child(node->sway_container) &&
-                                node->sway_container->workspace == workspace) {
+                                node->sway_container->pending.workspace == workspace) {
                         return node->sway_container;
                 }
         }
@@ -1391,7 +1430,7 @@ struct sway_workspace *seat_get_focused_workspace(struct sway_seat *seat) {
                 return NULL;
         }
         if (focus->type == N_CONTAINER) {
-                return focus->sway_container->workspace;
+                return focus->sway_container->pending.workspace;
         }
         if (focus->type == N_WORKSPACE) {
                 return focus->sway_workspace;
@@ -1404,8 +1443,8 @@ struct sway_workspace *seat_get_last_known_workspace(struct sway_seat *seat) {
         wl_list_for_each(current, &seat->focus_stack, link) {
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
-                                node->sway_container->workspace) {
-                        return node->sway_container->workspace;
+                                node->sway_container->pending.workspace) {
+                        return node->sway_container->pending.workspace;
                 } else if (node->type == N_WORKSPACE) {
                         return node->sway_workspace;
                 }
diff --git a/sway/input/seatop_default.c b/sway/input/seatop_default.c
index a583ed62..f9eb8c8a 100644
--- a/sway/input/seatop_default.c
+++ b/sway/input/seatop_default.c
@@ -4,6 +4,7 @@
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/input/tablet.h"
@@ -59,7 +60,7 @@ static bool edge_is_external(struct sway_container *cont, enum wlr_edges edge) {
                                 return false;
                         }
                 }
-                cont = cont->parent;
+                cont = cont->pending.parent;
         }
         return true;
 }
@@ -69,25 +70,25 @@ static enum wlr_edges find_edge(struct sway_container *cont,
         if (!cont->view || (surface && cont->view->surface != surface)) {
                 return WLR_EDGE_NONE;
         }
-        if (cont->border == B_NONE || !cont->border_thickness ||
-                        cont->border == B_CSD) {
+        if (cont->pending.border == B_NONE || !cont->pending.border_thickness ||
+                        cont->pending.border == B_CSD) {
                 return WLR_EDGE_NONE;
         }
-        if (cont->fullscreen_mode) {
+        if (cont->pending.fullscreen_mode) {
                 return WLR_EDGE_NONE;
         }
 
         enum wlr_edges edge = 0;
-        if (cursor->cursor->x < cont->x + cont->border_thickness) {
+        if (cursor->cursor->x < cont->pending.x + cont->pending.border_thickness) {
                 edge |= WLR_EDGE_LEFT;
         }
-        if (cursor->cursor->y < cont->y + cont->border_thickness) {
+        if (cursor->cursor->y < cont->pending.y + cont->pending.border_thickness) {
                 edge |= WLR_EDGE_TOP;
         }
-        if (cursor->cursor->x >= cont->x + cont->width - cont->border_thickness) {
+        if (cursor->cursor->x >= cont->pending.x + cont->pending.width - cont->pending.border_thickness) {
                 edge |= WLR_EDGE_RIGHT;
         }
-        if (cursor->cursor->y >= cont->y + cont->height - cont->border_thickness) {
+        if (cursor->cursor->y >= cont->pending.y + cont->pending.height - cont->pending.border_thickness) {
                 edge |= WLR_EDGE_BOTTOM;
         }
 
@@ -231,6 +232,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
                                 wlr_layer_surface_v1_from_wlr_surface(surface);
                 if (layer->current.keyboard_interactive) {
                         seat_set_focus_layer(seat, layer);
+                        transaction_commit_dirty();
                 }
         } else if (cont) {
                 bool is_floating_or_child = container_is_floating_or_child(cont);
@@ -249,7 +251,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
 
                 // Handle moving a tiling container
                 if (config->tiling_drag && mod_pressed && !is_floating_or_child &&
-                                cont->fullscreen_mode == FULLSCREEN_NONE) {
+                                cont->pending.fullscreen_mode == FULLSCREEN_NONE) {
                         seatop_begin_move_tiling(seat, cont);
                         return;
                 }
@@ -268,6 +270,7 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
                         struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
                         wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
                         seat_set_focus_surface(seat, xsurface->surface, false);
+                        transaction_commit_dirty();
                 }
         }
 #endif
@@ -356,6 +359,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         if (node && node->type == N_WORKSPACE) {
                 if (state == WLR_BUTTON_PRESSED) {
                         seat_set_focus(seat, node);
+                        transaction_commit_dirty();
                 }
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
@@ -367,6 +371,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                         wlr_layer_surface_v1_from_wlr_surface(surface);
                 if (layer->current.keyboard_interactive) {
                         seat_set_focus_layer(seat, layer);
+                        transaction_commit_dirty();
                 }
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
@@ -381,7 +386,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 struct sway_container *cont_to_focus = cont;
                 enum sway_container_layout layout = container_parent_layout(cont);
                 if (layout == L_TABBED || layout == L_STACKED) {
-                        cont_to_focus = seat_get_focus_inactive_view(seat, &cont->parent->node);
+                        cont_to_focus = seat_get_focus_inactive_view(seat, &cont->pending.parent->node);
                 }
 
                 seat_set_focus_container(seat, cont_to_focus);
@@ -397,9 +402,9 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                         BTN_LEFT : BTN_RIGHT;
                 if (button == btn_resize) {
                         edge = 0;
-                        edge |= cursor->cursor->x > cont->x + cont->width / 2 ?
+                        edge |= cursor->cursor->x > cont->pending.x + cont->pending.width / 2 ?
                                 WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
-                        edge |= cursor->cursor->y > cont->y + cont->height / 2 ?
+                        edge |= cursor->cursor->y > cont->pending.y + cont->pending.height / 2 ?
                                 WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
 
                         const char *image = NULL;
@@ -446,9 +451,9 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 if (mod_pressed && button == btn_resize) {
                         struct sway_container *floater = container_toplevel_ancestor(cont);
                         edge = 0;
-                        edge |= cursor->cursor->x > floater->x + floater->width / 2 ?
+                        edge |= cursor->cursor->x > floater->pending.x + floater->pending.width / 2 ?
                                 WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
-                        edge |= cursor->cursor->y > floater->y + floater->height / 2 ?
+                        edge |= cursor->cursor->y > floater->pending.y + floater->pending.height / 2 ?
                                 WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
                         seatop_begin_resize_floating(seat, floater, edge);
                         return;
@@ -458,7 +463,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         // Handle moving a tiling container
         if (config->tiling_drag && (mod_pressed || on_titlebar) &&
                         state == WLR_BUTTON_PRESSED && !is_floating_or_child &&
-                        cont && cont->fullscreen_mode == FULLSCREEN_NONE) {
+                        cont && cont->pending.fullscreen_mode == FULLSCREEN_NONE) {
                 struct sway_container *focus = seat_get_focused_container(seat);
                 bool focused = focus == cont || container_has_ancestor(focus, cont);
                 if (on_titlebar && !focused) {
@@ -487,6 +492,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         if (cont && state == WLR_BUTTON_PRESSED) {
                 node = seat_get_focus_inactive(seat, &cont->node);
                 seat_set_focus(seat, node);
+                transaction_commit_dirty();
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
         }
@@ -501,6 +507,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                         struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
                         wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
                         seat_set_focus_surface(seat, xsurface->surface, false);
+                        transaction_commit_dirty();
                         seat_pointer_notify_button(seat, time_msec, button, state);
                         return;
                 }
@@ -530,6 +537,7 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 if (focus && hovered_output != node_get_output(focus)) {
                         struct sway_workspace *ws = output_get_active_workspace(hovered_output);
                         seat_set_focus(seat, &ws->node);
+                        transaction_commit_dirty();
                 }
                 return;
         }
@@ -541,6 +549,7 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 struct sway_output *hovered_output = node_get_output(hovered_node);
                 if (hovered_output != focused_output) {
                         seat_set_focus(seat, seat_get_focus_inactive(seat, hovered_node));
+                        transaction_commit_dirty();
                 }
                 return;
         }
@@ -556,6 +565,7 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 if (hovered_node != e->previous_node ||
                                 config->focus_follows_mouse == FOLLOWS_ALWAYS) {
                         seat_set_focus(seat, hovered_node);
+                        transaction_commit_dirty();
                 }
         }
 }
@@ -664,7 +674,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
         bool on_border = edge != WLR_EDGE_NONE;
         bool on_titlebar = cont && !on_border && !surface;
         bool on_titlebar_border = cont && on_border &&
-                cursor->cursor->y < cont->content_y;
+                cursor->cursor->y < cont->pending.content_y;
         bool on_contents = cont && !on_border && surface;
         bool on_workspace = node && node->type == N_WORKSPACE;
         float scroll_factor =
@@ -714,6 +724,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
                         // Use the focused child of the tabbed/stacked container, not the
                         // container the user scrolled on.
                         seat_set_focus(seat, new_focus);
+                        transaction_commit_dirty();
                         handled = true;
                 }
         }
diff --git a/sway/input/seatop_down.c b/sway/input/seatop_down.c
index 17f619e3..844cf5ab 100644
--- a/sway/input/seatop_down.c
+++ b/sway/input/seatop_down.c
@@ -5,6 +5,7 @@
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/tree/view.h"
+#include "sway/desktop/transaction.h"
 #include "log.h"
 
 struct seatop_down_event {
@@ -107,4 +108,5 @@ void seatop_begin_down(struct sway_seat *seat, struct sway_container *con,
         seat->seatop_data = e;
 
         container_raise_floating(con);
+        transaction_commit_dirty();
 }
diff --git a/sway/input/seatop_move_floating.c b/sway/input/seatop_move_floating.c
index 7f501fc9..ddcd4c53 100644
--- a/sway/input/seatop_move_floating.c
+++ b/sway/input/seatop_move_floating.c
@@ -1,6 +1,7 @@
 #define _POSIX_C_SOURCE 200809L
 #include <wlr/types/wlr_cursor.h>
 #include "sway/desktop.h"
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 
@@ -14,7 +15,8 @@ static void finalize_move(struct sway_seat *seat) {
 
         // We "move" the container to its own location
         // so it discovers its output again.
-        container_floating_move_to(e->con, e->con->x, e->con->y);
+        container_floating_move_to(e->con, e->con->pending.x, e->con->pending.y);
+        transaction_commit_dirty();
 
         seatop_begin_default(seat);
 }
@@ -40,6 +42,7 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
         desktop_damage_whole_container(e->con);
         container_floating_move_to(e->con, cursor->x - e->dx, cursor->y - e->dy);
         desktop_damage_whole_container(e->con);
+        transaction_commit_dirty();
 }
 
 static void handle_unref(struct sway_seat *seat, struct sway_container *con) {
@@ -67,13 +70,14 @@ void seatop_begin_move_floating(struct sway_seat *seat,
                 return;
         }
         e->con = con;
-        e->dx = cursor->cursor->x - con->x;
-        e->dy = cursor->cursor->y - con->y;
+        e->dx = cursor->cursor->x - con->pending.x;
+        e->dy = cursor->cursor->y - con->pending.y;
 
         seat->seatop_impl = &seatop_impl;
         seat->seatop_data = e;
 
         container_raise_floating(con);
+        transaction_commit_dirty();
 
         cursor_set_image(cursor, "grab", NULL);
         wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
diff --git a/sway/input/seatop_move_tiling.c b/sway/input/seatop_move_tiling.c
index 704e7270..223c6c08 100644
--- a/sway/input/seatop_move_tiling.c
+++ b/sway/input/seatop_move_tiling.c
@@ -3,6 +3,7 @@
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/util/edges.h>
 #include "sway/desktop.h"
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
@@ -15,6 +16,10 @@
 // Thickness of the dropzone when dragging to the edge of a layout container
 #define DROP_LAYOUT_BORDER 30
 
+// Thickness of indicator when dropping onto a titlebar.  This should be a
+// multiple of 2.
+#define DROP_SPLIT_INDICATOR 10
+
 struct seatop_move_tiling_event {
         struct sway_container *con;
         struct sway_node *target_node;
@@ -22,6 +27,8 @@ struct seatop_move_tiling_event {
         struct wlr_box drop_box;
         double ref_lx, ref_ly; // cursor's x/y at start of op
         bool threshold_reached;
+        bool split_target;
+        bool insert_after_target;
 };
 
 static void handle_render(struct sway_seat *seat,
@@ -91,8 +98,76 @@ static void resize_box(struct wlr_box *box, enum wlr_edges edge,
         }
 }
 
+static void split_border(double pos, int offset, int len, int n_children,
+                int avoid, int *out_pos, bool *out_after) {
+        int region = 2 * n_children * (pos - offset) / len;
+        // If the cursor is over the right side of a left-adjacent titlebar, or the
+        // left side of a right-adjacent titlebar, it's position when dropped will
+        // be the same.  To avoid this, shift the region for adjacent containers.
+        if (avoid >= 0) {
+                if (region == 2 * avoid - 1 || region == 2 * avoid) {
+                        region--;
+                } else if (region == 2 * avoid + 1 || region == 2 * avoid + 2) {
+                        region++;
+                }
+        }
+
+        int child_index = (region + 1) / 2;
+        *out_after = region % 2;
+        // When dropping at the beginning or end of a container, show the drop
+        // region within the container boundary, otherwise show it on top of the
+        // border between two titlebars.
+        if (child_index == 0) {
+                *out_pos = offset;
+        } else if (child_index == n_children) {
+                *out_pos = offset + len - DROP_SPLIT_INDICATOR;
+        } else {
+                *out_pos = offset + child_index * len / n_children -
+                        DROP_SPLIT_INDICATOR / 2;
+        }
+}
+
+static bool split_titlebar(struct sway_node *node, struct sway_container *avoid,
+                struct wlr_cursor *cursor, struct wlr_box *title_box, bool *after) {
+        struct sway_container *con = node->sway_container;
+        struct sway_node *parent = &con->pending.parent->node;
+        int title_height = container_titlebar_height();
+        struct wlr_box box;
+        int n_children, avoid_index;
+        enum sway_container_layout layout =
+                parent ? node_get_layout(parent) : L_NONE;
+        if (layout == L_TABBED || layout == L_STACKED) {
+                node_get_box(parent, &box);
+                n_children = node_get_children(parent)->length;
+                avoid_index = list_find(node_get_children(parent), avoid);
+        } else {
+                node_get_box(node, &box);
+                n_children = 1;
+                avoid_index = -1;
+        }
+        if (layout == L_STACKED && cursor->y < box.y + title_height * n_children) {
+                // Drop into stacked titlebars.
+                title_box->width = box.width;
+                title_box->height = DROP_SPLIT_INDICATOR;
+                title_box->x = box.x;
+                split_border(cursor->y, box.y, title_height * n_children,
+                        n_children, avoid_index, &title_box->y, after);
+                return true;
+        } else if (layout != L_STACKED && cursor->y < box.y + title_height) {
+                // Drop into side-by-side titlebars.
+                title_box->width = DROP_SPLIT_INDICATOR;
+                title_box->height = title_height;
+                title_box->y = box.y;
+                split_border(cursor->x, box.x, box.width, n_children,
+                        avoid_index, &title_box->x, after);
+                return true;
+        }
+        return false;
+}
+
 static void handle_motion_postthreshold(struct sway_seat *seat) {
         struct seatop_move_tiling_event *e = seat->seatop_data;
+        e->split_target = false;
         struct wlr_surface *surface = NULL;
         double sx, sy;
         struct sway_cursor *cursor = seat->cursor;
@@ -119,34 +194,60 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
 
         // Deny moving within own workspace if this is the only child
         struct sway_container *con = node->sway_container;
-        if (workspace_num_tiling_views(e->con->workspace) == 1 &&
-                        con->workspace == e->con->workspace) {
+        if (workspace_num_tiling_views(e->con->pending.workspace) == 1 &&
+                        con->pending.workspace == e->con->pending.workspace) {
                 e->target_node = NULL;
                 e->target_edge = WLR_EDGE_NONE;
                 return;
         }
 
+        // Check if the cursor is over a tilebar only if the destination
+        // container is not a descendant of the source container.
+        if (!surface && !container_has_ancestor(con, e->con) &&
+                        split_titlebar(node, e->con, cursor->cursor,
+                                &e->drop_box, &e->insert_after_target)) {
+                // Don't allow dropping over the source container's titlebar
+                // to give users a chance to cancel a drag operation.
+                if (con == e->con) {
+                        e->target_node = NULL;
+                } else {
+                        e->target_node = node;
+                        e->split_target = true;
+                }
+                e->target_edge = WLR_EDGE_NONE;
+                return;
+        }
+
         // Traverse the ancestors, trying to find a layout container perpendicular
         // to the edge. Eg. close to the top or bottom of a horiz layout.
+        int thresh_top = con->pending.content_y + DROP_LAYOUT_BORDER;
+        int thresh_bottom = con->pending.content_y +
+                con->pending.content_height - DROP_LAYOUT_BORDER;
+        int thresh_left = con->pending.content_x + DROP_LAYOUT_BORDER;
+        int thresh_right = con->pending.content_x +
+                con->pending.content_width - DROP_LAYOUT_BORDER;
         while (con) {
                 enum wlr_edges edge = WLR_EDGE_NONE;
                 enum sway_container_layout layout = container_parent_layout(con);
-                struct wlr_box parent;
-                con->parent ? container_get_box(con->parent, &parent) :
-                        workspace_get_box(con->workspace, &parent);
+                struct wlr_box box;
+                node_get_box(node_get_parent(&con->node), &box);
                 if (layout == L_HORIZ || layout == L_TABBED) {
-                        if (cursor->cursor->y < parent.y + DROP_LAYOUT_BORDER) {
+                        if (cursor->cursor->y < thresh_top) {
                                 edge = WLR_EDGE_TOP;
-                        } else if (cursor->cursor->y > parent.y + parent.height
-                                        - DROP_LAYOUT_BORDER) {
+                                box.height = thresh_top - box.y;
+                        } else if (cursor->cursor->y > thresh_bottom) {
                                 edge = WLR_EDGE_BOTTOM;
+                                box.height = box.y + box.height - thresh_bottom;
+                                box.y = thresh_bottom;
                         }
                 } else if (layout == L_VERT || layout == L_STACKED) {
-                        if (cursor->cursor->x < parent.x + DROP_LAYOUT_BORDER) {
+                        if (cursor->cursor->x < thresh_left) {
                                 edge = WLR_EDGE_LEFT;
-                        } else if (cursor->cursor->x > parent.x + parent.width
-                                        - DROP_LAYOUT_BORDER) {
+                                box.width = thresh_left - box.x;
+                        } else if (cursor->cursor->x > thresh_right) {
                                 edge = WLR_EDGE_RIGHT;
+                                box.width = box.x + box.width - thresh_right;
+                                box.x = thresh_right;
                         }
                 }
                 if (edge) {
@@ -155,12 +256,11 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
                                 e->target_node = node_get_parent(e->target_node);
                         }
                         e->target_edge = edge;
-                        node_get_box(e->target_node, &e->drop_box);
-                        resize_box(&e->drop_box, edge, DROP_LAYOUT_BORDER);
+                        e->drop_box = box;
                         desktop_damage_box(&e->drop_box);
                         return;
                 }
-                con = con->parent;
+                con = con->pending.parent;
         }
 
         // Use the hovered view - but we must be over the actual surface
@@ -173,23 +273,23 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
         }
 
         // Find the closest edge
-        size_t thickness = fmin(con->content_width, con->content_height) * 0.3;
+        size_t thickness = fmin(con->pending.content_width, con->pending.content_height) * 0.3;
         size_t closest_dist = INT_MAX;
         size_t dist;
         e->target_edge = WLR_EDGE_NONE;
-        if ((dist = cursor->cursor->y - con->y) < closest_dist) {
+        if ((dist = cursor->cursor->y - con->pending.y) < closest_dist) {
                 closest_dist = dist;
                 e->target_edge = WLR_EDGE_TOP;
         }
-        if ((dist = cursor->cursor->x - con->x) < closest_dist) {
+        if ((dist = cursor->cursor->x - con->pending.x) < closest_dist) {
                 closest_dist = dist;
                 e->target_edge = WLR_EDGE_LEFT;
         }
-        if ((dist = con->x + con->width - cursor->cursor->x) < closest_dist) {
+        if ((dist = con->pending.x + con->pending.width - cursor->cursor->x) < closest_dist) {
                 closest_dist = dist;
                 e->target_edge = WLR_EDGE_RIGHT;
         }
-        if ((dist = con->y + con->height - cursor->cursor->y) < closest_dist) {
+        if ((dist = con->pending.y + con->pending.height - cursor->cursor->y) < closest_dist) {
                 closest_dist = dist;
                 e->target_edge = WLR_EDGE_BOTTOM;
         }
@@ -199,10 +299,10 @@ static void handle_motion_postthreshold(struct sway_seat *seat) {
         }
 
         e->target_node = node;
-        e->drop_box.x = con->content_x;
-        e->drop_box.y = con->content_y;
-        e->drop_box.width = con->content_width;
-        e->drop_box.height = con->content_height;
+        e->drop_box.x = con->pending.content_x;
+        e->drop_box.y = con->pending.content_y;
+        e->drop_box.width = con->pending.content_width;
+        e->drop_box.height = con->pending.content_height;
         resize_box(&e->drop_box, e->target_edge, thickness);
         desktop_damage_box(&e->drop_box);
 }
@@ -214,6 +314,7 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
         } else {
                 handle_motion_prethreshold(seat);
         }
+        transaction_commit_dirty();
 }
 
 static bool is_parallel(enum sway_container_layout layout,
@@ -232,14 +333,15 @@ static void finalize_move(struct sway_seat *seat) {
         }
 
         struct sway_container *con = e->con;
-        struct sway_container *old_parent = con->parent;
-        struct sway_workspace *old_ws = con->workspace;
+        struct sway_container *old_parent = con->pending.parent;
+        struct sway_workspace *old_ws = con->pending.workspace;
         struct sway_node *target_node = e->target_node;
         struct sway_workspace *new_ws = target_node->type == N_WORKSPACE ?
-                target_node->sway_workspace : target_node->sway_container->workspace;
+                target_node->sway_workspace : target_node->sway_container->pending.workspace;
         enum wlr_edges edge = e->target_edge;
         int after = edge != WLR_EDGE_TOP && edge != WLR_EDGE_LEFT;
-        bool swap = edge == WLR_EDGE_NONE && target_node->type == N_CONTAINER;
+        bool swap = edge == WLR_EDGE_NONE && target_node->type == N_CONTAINER &&
+                !e->split_target;
 
         if (!swap) {
                 container_detach(con);
@@ -248,6 +350,14 @@ static void finalize_move(struct sway_seat *seat) {
         // Moving container into empty workspace
         if (target_node->type == N_WORKSPACE && edge == WLR_EDGE_NONE) {
                 con = workspace_add_tiling(new_ws, con);
+        } else if (e->split_target) {
+                struct sway_container *target = target_node->sway_container;
+                enum sway_container_layout layout = container_parent_layout(target);
+                if (layout != L_TABBED && layout != L_STACKED) {
+                        container_split(target, L_TABBED);
+                }
+                container_add_sibling(target, con, e->insert_after_target);
+                ipc_event_window(con, "move");
         } else if (target_node->type == N_CONTAINER) {
                 // Moving container before/after another
                 struct sway_container *target = target_node->sway_container;
@@ -283,8 +393,8 @@ static void finalize_move(struct sway_seat *seat) {
                 int index = list_find(siblings, con);
                 struct sway_container *sibling = index == 0 ?
                         siblings->items[1] : siblings->items[index - 1];
-                con->width = sibling->width;
-                con->height = sibling->height;
+                con->pending.width = sibling->pending.width;
+                con->pending.height = sibling->pending.height;
                 con->width_fraction = sibling->width_fraction;
                 con->height_fraction = sibling->height_fraction;
         }
@@ -294,6 +404,7 @@ static void finalize_move(struct sway_seat *seat) {
                 arrange_workspace(new_ws);
         }
 
+        transaction_commit_dirty();
         seatop_begin_default(seat);
 }
 
@@ -348,6 +459,7 @@ void seatop_begin_move_tiling_threshold(struct sway_seat *seat,
         seat->seatop_data = e;
 
         container_raise_floating(con);
+        transaction_commit_dirty();
         wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
 }
 
diff --git a/sway/input/seatop_resize_floating.c b/sway/input/seatop_resize_floating.c
index 5da22e47..8400a4b3 100644
--- a/sway/input/seatop_resize_floating.c
+++ b/sway/input/seatop_resize_floating.c
@@ -2,6 +2,7 @@
 #include <limits.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/tree/arrange.h"
@@ -27,6 +28,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         if (seat->cursor->pressed_button_count == 0) {
                 container_set_resizing(con, false);
                 arrange_container(con); // Send configure w/o resizing hint
+                transaction_commit_dirty();
                 seatop_begin_default(seat);
         }
 }
@@ -116,23 +118,24 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
 
         // Determine the amounts we need to bump everything relative to the current
         // size.
-        int relative_grow_width = width - con->width;
-        int relative_grow_height = height - con->height;
-        int relative_grow_x = (e->ref_con_lx + grow_x) - con->x;
-        int relative_grow_y = (e->ref_con_ly + grow_y) - con->y;
+        int relative_grow_width = width - con->pending.width;
+        int relative_grow_height = height - con->pending.height;
+        int relative_grow_x = (e->ref_con_lx + grow_x) - con->pending.x;
+        int relative_grow_y = (e->ref_con_ly + grow_y) - con->pending.y;
 
         // Actually resize stuff
-        con->x += relative_grow_x;
-        con->y += relative_grow_y;
-        con->width += relative_grow_width;
-        con->height += relative_grow_height;
+        con->pending.x += relative_grow_x;
+        con->pending.y += relative_grow_y;
+        con->pending.width += relative_grow_width;
+        con->pending.height += relative_grow_height;
 
-        con->content_x += relative_grow_x;
-        con->content_y += relative_grow_y;
-        con->content_width += relative_grow_width;
-        con->content_height += relative_grow_height;
+        con->pending.content_x += relative_grow_x;
+        con->pending.content_y += relative_grow_y;
+        con->pending.content_width += relative_grow_width;
+        con->pending.content_height += relative_grow_height;
 
         arrange_container(con);
+        transaction_commit_dirty();
 }
 
 static void handle_unref(struct sway_seat *seat, struct sway_container *con) {
@@ -166,16 +169,17 @@ void seatop_begin_resize_floating(struct sway_seat *seat,
         e->edge = edge == WLR_EDGE_NONE ? WLR_EDGE_BOTTOM | WLR_EDGE_RIGHT : edge;
         e->ref_lx = seat->cursor->cursor->x;
         e->ref_ly = seat->cursor->cursor->y;
-        e->ref_con_lx = con->x;
-        e->ref_con_ly = con->y;
-        e->ref_width = con->width;
-        e->ref_height = con->height;
+        e->ref_con_lx = con->pending.x;
+        e->ref_con_ly = con->pending.y;
+        e->ref_width = con->pending.width;
+        e->ref_height = con->pending.height;
 
         seat->seatop_impl = &seatop_impl;
         seat->seatop_data = e;
 
         container_set_resizing(con, true);
         container_raise_floating(con);
+        transaction_commit_dirty();
 
         const char *image = edge == WLR_EDGE_NONE ?
                 "se-resize" : wlr_xcursor_get_resize_name(edge);
diff --git a/sway/input/seatop_resize_tiling.c b/sway/input/seatop_resize_tiling.c
index 2cca805d..869d11b5 100644
--- a/sway/input/seatop_resize_tiling.c
+++ b/sway/input/seatop_resize_tiling.c
@@ -2,6 +2,7 @@
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/util/edges.h>
 #include "sway/commands.h"
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/tree/arrange.h"
@@ -52,21 +53,22 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 if (e->h_con) {
                         container_set_resizing(e->h_con, false);
                         container_set_resizing(e->h_sib, false);
-                        if (e->h_con->parent) {
-                                arrange_container(e->h_con->parent);
+                        if (e->h_con->pending.parent) {
+                                arrange_container(e->h_con->pending.parent);
                         } else {
-                                arrange_workspace(e->h_con->workspace);
+                                arrange_workspace(e->h_con->pending.workspace);
                         }
                 }
                 if (e->v_con) {
                         container_set_resizing(e->v_con, false);
                         container_set_resizing(e->v_sib, false);
-                        if (e->v_con->parent) {
-                                arrange_container(e->v_con->parent);
+                        if (e->v_con->pending.parent) {
+                                arrange_container(e->v_con->pending.parent);
                         } else {
-                                arrange_workspace(e->v_con->workspace);
+                                arrange_workspace(e->v_con->pending.workspace);
                         }
                 }
+                transaction_commit_dirty();
                 seatop_begin_default(seat);
         }
 }
@@ -80,16 +82,16 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
 
         if (e->h_con) {
                 if (e->edge & WLR_EDGE_LEFT) {
-                        amount_x = (e->h_con_orig_width - moved_x) - e->h_con->width;
+                        amount_x = (e->h_con_orig_width - moved_x) - e->h_con->pending.width;
                 } else if (e->edge & WLR_EDGE_RIGHT) {
-                        amount_x = (e->h_con_orig_width + moved_x) - e->h_con->width;
+                        amount_x = (e->h_con_orig_width + moved_x) - e->h_con->pending.width;
                 }
         }
         if (e->v_con) {
                 if (e->edge & WLR_EDGE_TOP) {
-                        amount_y = (e->v_con_orig_height - moved_y) - e->v_con->height;
+                        amount_y = (e->v_con_orig_height - moved_y) - e->v_con->pending.height;
                 } else if (e->edge & WLR_EDGE_BOTTOM) {
-                        amount_y = (e->v_con_orig_height + moved_y) - e->v_con->height;
+                        amount_y = (e->v_con_orig_height + moved_y) - e->v_con->pending.height;
                 }
         }
 
@@ -99,6 +101,7 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
         if (amount_y != 0) {
                 container_resize_tiled(e->v_con, e->edge_y, amount_y);
         }
+        transaction_commit_dirty();
 }
 
 static void handle_unref(struct sway_seat *seat, struct sway_container *con) {
@@ -140,7 +143,7 @@ void seatop_begin_resize_tiling(struct sway_seat *seat,
                 if (e->h_con) {
                         container_set_resizing(e->h_con, true);
                         container_set_resizing(e->h_sib, true);
-                        e->h_con_orig_width = e->h_con->width;
+                        e->h_con_orig_width = e->h_con->pending.width;
                 }
         }
         if (edge & (WLR_EDGE_TOP | WLR_EDGE_BOTTOM)) {
@@ -151,12 +154,13 @@ void seatop_begin_resize_tiling(struct sway_seat *seat,
                 if (e->v_con) {
                         container_set_resizing(e->v_con, true);
                         container_set_resizing(e->v_sib, true);
-                        e->v_con_orig_height = e->v_con->height;
+                        e->v_con_orig_height = e->v_con->pending.height;
                 }
         }
 
         seat->seatop_impl = &seatop_impl;
         seat->seatop_data = e;
 
+        transaction_commit_dirty();
         wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
 }
diff --git a/sway/input/switch.c b/sway/input/switch.c
index b7c28df1..9ea87a1a 100644
--- a/sway/input/switch.c
+++ b/sway/input/switch.c
@@ -1,5 +1,4 @@
 #include "sway/config.h"
-#include "sway/desktop/transaction.h"
 #include "sway/input/switch.h"
 #include <wlr/types/wlr_idle.h>
 #include "log.h"
@@ -61,9 +60,6 @@ static void execute_binding(struct sway_switch *sway_switch) {
                 seat_execute_command(seat, dummy_binding);
                 free(dummy_binding);
         }
-
-        transaction_commit_dirty();
-
 }
 
 static void handle_switch_toggle(struct wl_listener *listener, void *data) {
diff --git a/sway/input/text_input.c b/sway/input/text_input.c
index f83726ee..b8c19c17 100644
--- a/sway/input/text_input.c
+++ b/sway/input/text_input.c
@@ -55,6 +55,37 @@ static void handle_im_commit(struct wl_listener *listener, void *data) {
         wlr_text_input_v3_send_done(text_input->input);
 }
 
+static void handle_im_keyboard_grab_destroy(struct wl_listener *listener, void *data) {
+        struct sway_input_method_relay *relay = wl_container_of(listener, relay,
+                input_method_keyboard_grab_destroy);
+        struct wlr_input_method_keyboard_grab_v2 *keyboard_grab = data;
+        wl_list_remove(&relay->input_method_keyboard_grab_destroy.link);
+
+        if (keyboard_grab->keyboard) {
+                // send modifier state to original client
+                wlr_seat_keyboard_notify_modifiers(keyboard_grab->input_method->seat,
+                        &keyboard_grab->keyboard->modifiers);
+        }
+}
+
+static void handle_im_grab_keyboard(struct wl_listener *listener, void *data) {
+        struct sway_input_method_relay *relay = wl_container_of(listener, relay,
+                input_method_grab_keyboard);
+        struct wlr_input_method_keyboard_grab_v2 *keyboard_grab = data;
+
+        // send modifier state to grab
+        struct wlr_keyboard *active_keyboard = wlr_seat_get_keyboard(relay->seat->wlr_seat);
+        wlr_input_method_keyboard_grab_v2_set_keyboard(keyboard_grab,
+                active_keyboard);
+        wlr_input_method_keyboard_grab_v2_send_modifiers(keyboard_grab,
+                &active_keyboard->modifiers);
+
+        wl_signal_add(&keyboard_grab->events.destroy,
+                &relay->input_method_keyboard_grab_destroy);
+        relay->input_method_keyboard_grab_destroy.notify =
+                handle_im_keyboard_grab_destroy;
+}
+
 static void text_input_set_pending_focused_surface(
                 struct sway_text_input *text_input, struct wlr_surface *surface) {
         wl_list_remove(&text_input->pending_focused_surface_destroy.link);
@@ -92,13 +123,18 @@ static void relay_send_im_state(struct sway_input_method_relay *relay,
                 return;
         }
         // TODO: only send each of those if they were modified
-        wlr_input_method_v2_send_surrounding_text(input_method,
-                input->current.surrounding.text, input->current.surrounding.cursor,
-                input->current.surrounding.anchor);
+        if (input->active_features & WLR_TEXT_INPUT_V3_FEATURE_SURROUNDING_TEXT) {
+                wlr_input_method_v2_send_surrounding_text(input_method,
+                        input->current.surrounding.text, input->current.surrounding.cursor,
+                        input->current.surrounding.anchor);
+        }
         wlr_input_method_v2_send_text_change_cause(input_method,
                 input->current.text_change_cause);
-        wlr_input_method_v2_send_content_type(input_method,
-                input->current.content_type.hint, input->current.content_type.purpose);
+        if (input->active_features & WLR_TEXT_INPUT_V3_FEATURE_CONTENT_TYPE) {
+                wlr_input_method_v2_send_content_type(input_method,
+                        input->current.content_type.hint,
+                        input->current.content_type.purpose);
+        }
         wlr_input_method_v2_send_done(input_method);
         // TODO: pass intent, display popup size
 }
@@ -144,6 +180,10 @@ static void handle_text_input_disable(struct wl_listener *listener,
                 void *data) {
         struct sway_text_input *text_input = wl_container_of(listener, text_input,
                 text_input_disable);
+        if (text_input->input->focused_surface == NULL) {
+                sway_log(SWAY_DEBUG, "Disabling text input, but no longer focused");
+                return;
+        }
         relay_disable_text_input(text_input->relay, text_input);
 }
 
@@ -236,6 +276,9 @@ static void relay_handle_input_method(struct wl_listener *listener,
         wl_signal_add(&relay->input_method->events.commit,
                 &relay->input_method_commit);
         relay->input_method_commit.notify = handle_im_commit;
+        wl_signal_add(&relay->input_method->events.grab_keyboard,
+                &relay->input_method_grab_keyboard);
+        relay->input_method_grab_keyboard.notify = handle_im_grab_keyboard;
         wl_signal_add(&relay->input_method->events.destroy,
                 &relay->input_method_destroy);
         relay->input_method_destroy.notify = handle_im_destroy;