Merge pull request #2296 from RyanDwyer/floating-modifier

Implement floating_modifier and mouse operations for floating views

19 files changed, 592 insertions, 33 deletions

diff --git a/include/sway/commands.h b/include/sway/commands.h
index e71a7228..f53d335a 100644
--- a/include/sway/commands.h
+++ b/include/sway/commands.h
@@ -106,7 +106,7 @@ sway_cmd cmd_exit;
 sway_cmd cmd_floating;
 sway_cmd cmd_floating_maximum_size;
 sway_cmd cmd_floating_minimum_size;
-sway_cmd cmd_floating_mod;
+sway_cmd cmd_floating_modifier;
 sway_cmd cmd_floating_scroll;
 sway_cmd cmd_focus;
 sway_cmd cmd_focus_follows_mouse;
diff --git a/include/sway/input/cursor.h b/include/sway/input/cursor.h
index 5dd109ca..b0a3a7c5 100644
--- a/include/sway/input/cursor.h
+++ b/include/sway/input/cursor.h
@@ -11,6 +11,7 @@ struct sway_cursor {
         } previous;
         struct wlr_xcursor_manager *xcursor_manager;
 
+        const char *image;
         struct wl_client *image_client;
 
         struct wl_listener motion;
@@ -37,4 +38,7 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
 void dispatch_cursor_button(struct sway_cursor *cursor, uint32_t time_msec,
         uint32_t button, enum wlr_button_state state);
 
+void cursor_set_image(struct sway_cursor *cursor, const char *image,
+                struct wl_client *client);
+
 #endif
diff --git a/include/sway/input/seat.h b/include/sway/input/seat.h
index eac1626b..ab25788f 100644
--- a/include/sway/input/seat.h
+++ b/include/sway/input/seat.h
@@ -3,6 +3,7 @@
 
 #include <wlr/types/wlr_layer_shell.h>
 #include <wlr/types/wlr_seat.h>
+#include <wlr/util/edges.h>
 #include "sway/input/input-manager.h"
 
 struct sway_seat_device {
@@ -52,6 +53,24 @@ struct sway_seat {
         int32_t touch_id;
         double touch_x, touch_y;
 
+        // Operations (drag and resize)
+        enum {
+                OP_NONE,
+                OP_MOVE,
+                OP_RESIZE,
+        } operation;
+
+        struct sway_container *op_container;
+        enum wlr_edges op_resize_edge;
+        uint32_t op_button;
+        bool op_resize_preserve_ratio;
+        double op_ref_lx, op_ref_ly;         // cursor's x/y at start of op
+        double op_ref_width, op_ref_height;  // container's size at start of op
+        double op_ref_con_lx, op_ref_con_ly; // container's x/y at start of op
+
+        uint32_t last_button;
+        uint32_t last_button_serial;
+
         struct wl_listener focus_destroy;
         struct wl_listener new_container;
         struct wl_listener new_drag_icon;
@@ -134,4 +153,15 @@ bool seat_is_input_allowed(struct sway_seat *seat, struct wlr_surface *surface);
 
 void drag_icon_update_position(struct sway_drag_icon *icon);
 
+void seat_begin_move(struct sway_seat *seat, struct sway_container *con,
+                uint32_t button);
+
+void seat_begin_resize(struct sway_seat *seat, struct sway_container *con,
+                uint32_t button, enum wlr_edges edge);
+
+void seat_end_mouse_operation(struct sway_seat *seat);
+
+void seat_pointer_notify_button(struct sway_seat *seat, uint32_t time_msec,
+                uint32_t button, enum wlr_button_state state);
+
 #endif
diff --git a/include/sway/tree/container.h b/include/sway/tree/container.h
index ca7a3288..59c5b4c7 100644
--- a/include/sway/tree/container.h
+++ b/include/sway/tree/container.h
@@ -305,6 +305,12 @@ bool container_is_floating(struct sway_container *container);
 void container_get_box(struct sway_container *container, struct wlr_box *box);
 
 /**
+ * Move a floating container by the specified amount.
+ */
+void container_floating_translate(struct sway_container *con,
+                double x_amount, double y_amount);
+
+/**
  * Move a floating container to a new layout-local position.
  */
 void container_floating_move_to(struct sway_container *con,
@@ -318,4 +324,10 @@ void container_set_dirty(struct sway_container *container);
 
 bool container_has_urgent_child(struct sway_container *container);
 
+/**
+ * If the container is involved in a drag or resize operation via a mouse, this
+ * ends the operation.
+ */
+void container_end_mouse_operation(struct sway_container *container);
+
 #endif
diff --git a/include/sway/tree/layout.h b/include/sway/tree/layout.h
index ba265623..5a78fd58 100644
--- a/include/sway/tree/layout.h
+++ b/include/sway/tree/layout.h
@@ -14,10 +14,11 @@ enum movement_direction {
 };
 
 enum resize_edge {
-        RESIZE_EDGE_LEFT,
-        RESIZE_EDGE_RIGHT,
-        RESIZE_EDGE_TOP,
-        RESIZE_EDGE_BOTTOM,
+        RESIZE_EDGE_NONE   = 0,
+        RESIZE_EDGE_LEFT   = 1,
+        RESIZE_EDGE_RIGHT  = 2,
+        RESIZE_EDGE_TOP    = 4,
+        RESIZE_EDGE_BOTTOM = 8,
 };
 
 struct sway_container;
diff --git a/include/sway/tree/view.h b/include/sway/tree/view.h
index 068d92c6..1dfb218b 100644
--- a/include/sway/tree/view.h
+++ b/include/sway/tree/view.h
@@ -26,6 +26,8 @@ enum sway_view_prop {
 };
 
 struct sway_view_impl {
+        void (*get_constraints)(struct sway_view *view, double *min_width,
+                        double *max_width, double *min_height, double *max_height);
         const char *(*get_string_prop)(struct sway_view *view,
                         enum sway_view_prop prop);
         uint32_t (*get_int_prop)(struct sway_view *view, enum sway_view_prop prop);
@@ -215,6 +217,9 @@ uint32_t view_get_window_type(struct sway_view *view);
 
 const char *view_get_shell(struct sway_view *view);
 
+void view_get_constraints(struct sway_view *view, double *min_width,
+                double *max_width, double *min_height, double *max_height);
+
 uint32_t view_configure(struct sway_view *view, double lx, double ly, int width,
         int height);
 
diff --git a/sway/commands.c b/sway/commands.c
index f1f03574..f40f0e9d 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -103,6 +103,7 @@ static struct cmd_handler handlers[] = {
         { "exec_always", cmd_exec_always },
         { "floating_maximum_size", cmd_floating_maximum_size },
         { "floating_minimum_size", cmd_floating_minimum_size },
+        { "floating_modifier", cmd_floating_modifier },
         { "focus", cmd_focus },
         { "focus_follows_mouse", cmd_focus_follows_mouse },
         { "focus_wrapping", cmd_focus_wrapping },
diff --git a/sway/commands/floating_modifier.c b/sway/commands/floating_modifier.c
new file mode 100644
index 00000000..9432c9f1
--- /dev/null
+++ b/sway/commands/floating_modifier.c
@@ -0,0 +1,20 @@
+#include "sway/commands.h"
+#include "sway/config.h"
+#include "util.h"
+
+struct cmd_results *cmd_floating_modifier(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "floating_modifier", EXPECTED_EQUAL_TO, 1))) {
+                return error;
+        }
+
+        uint32_t mod = get_modifier_mask_by_name(argv[0]);
+        if (!mod) {
+                return cmd_results_new(CMD_INVALID, "floating_modifier",
+                                "Invalid modifier");
+        }
+
+        config->floating_mod = mod;
+
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index a9808406..a206ac6b 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -463,11 +463,12 @@ static void output_damage_whole_container_iterator(struct sway_container *con,
 
 void output_damage_whole_container(struct sway_output *output,
                 struct sway_container *con) {
+        // Pad the box by 1px, because the width is a double and might be a fraction
         struct wlr_box box = {
-                .x = con->current.swayc_x - output->wlr_output->lx,
-                .y = con->current.swayc_y - output->wlr_output->ly,
-                .width = con->current.swayc_width,
-                .height = con->current.swayc_height,
+                .x = con->current.swayc_x - output->wlr_output->lx - 1,
+                .y = con->current.swayc_y - output->wlr_output->ly - 1,
+                .width = con->current.swayc_width + 2,
+                .height = con->current.swayc_height + 2,
         };
         scale_box(&box, output->wlr_output->scale);
         wlr_output_damage_add_box(output->damage, &box);
diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index 19f41efc..2a89880a 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -222,24 +222,16 @@ static void transaction_apply(struct sway_transaction *transaction) {
         }
 }
 
-/**
- * For simplicity, we only progress the queue if it can be completely flushed.
- */
 static void transaction_progress_queue() {
-        // We iterate this list in reverse because we're more likely to find a
-        // waiting transactions at the end of the list.
-        for (int i = server.transactions->length - 1; i >= 0; --i) {
-                struct sway_transaction *transaction = server.transactions->items[i];
+        while (server.transactions->length) {
+                struct sway_transaction *transaction = server.transactions->items[0];
                 if (transaction->num_waiting) {
                         return;
                 }
-        }
-        for (int i = 0; i < server.transactions->length; ++i) {
-                struct sway_transaction *transaction = server.transactions->items[i];
                 transaction_apply(transaction);
                 transaction_destroy(transaction);
+                list_del(server.transactions, 0);
         }
-        server.transactions->length = 0;
         idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
 }
 
diff --git a/sway/desktop/xdg_shell.c b/sway/desktop/xdg_shell.c
index 98c16faf..706b35c3 100644
--- a/sway/desktop/xdg_shell.c
+++ b/sway/desktop/xdg_shell.c
@@ -1,4 +1,5 @@
 #define _POSIX_C_SOURCE 199309L
+#include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <wayland-server.h>
@@ -95,6 +96,16 @@ static struct sway_xdg_shell_view *xdg_shell_view_from_view(
         return (struct sway_xdg_shell_view *)view;
 }
 
+static void get_constraints(struct sway_view *view, double *min_width,
+                double *max_width, double *min_height, double *max_height) {
+        struct wlr_xdg_toplevel_state *state =
+                &view->wlr_xdg_surface->toplevel->current;
+        *min_width = state->min_width > 0 ? state->min_width : DBL_MIN;
+        *max_width = state->max_width > 0 ? state->max_width : DBL_MAX;
+        *min_height = state->min_height > 0 ? state->min_height : DBL_MIN;
+        *max_height = state->max_height > 0 ? state->max_height : DBL_MAX;
+}
+
 static const char *get_string_prop(struct sway_view *view, enum sway_view_prop prop) {
         if (xdg_shell_view_from_view(view) == NULL) {
                 return NULL;
@@ -188,6 +199,7 @@ static void destroy(struct sway_view *view) {
 }
 
 static const struct sway_view_impl view_impl = {
+        .get_constraints = get_constraints,
         .get_string_prop = get_string_prop,
         .configure = configure,
         .set_activated = set_activated,
@@ -248,6 +260,34 @@ static void handle_request_fullscreen(struct wl_listener *listener, void *data)
         transaction_commit_dirty();
 }
 
+static void handle_request_move(struct wl_listener *listener, void *data) {
+        struct sway_xdg_shell_view *xdg_shell_view =
+                wl_container_of(listener, xdg_shell_view, request_move);
+        struct sway_view *view = &xdg_shell_view->view;
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct wlr_xdg_toplevel_move_event *e = data;
+        struct sway_seat *seat = e->seat->seat->data;
+        if (e->serial == seat->last_button_serial) {
+                seat_begin_move(seat, view->swayc, seat->last_button);
+        }
+}
+
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+        struct sway_xdg_shell_view *xdg_shell_view =
+                wl_container_of(listener, xdg_shell_view, request_resize);
+        struct sway_view *view = &xdg_shell_view->view;
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct wlr_xdg_toplevel_resize_event *e = data;
+        struct sway_seat *seat = e->seat->seat->data;
+        if (e->serial == seat->last_button_serial) {
+                seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
+        }
+}
+
 static void handle_unmap(struct wl_listener *listener, void *data) {
         struct sway_xdg_shell_view *xdg_shell_view =
                 wl_container_of(listener, xdg_shell_view, unmap);
@@ -262,6 +302,8 @@ static void handle_unmap(struct wl_listener *listener, void *data) {
         wl_list_remove(&xdg_shell_view->commit.link);
         wl_list_remove(&xdg_shell_view->new_popup.link);
         wl_list_remove(&xdg_shell_view->request_fullscreen.link);
+        wl_list_remove(&xdg_shell_view->request_move.link);
+        wl_list_remove(&xdg_shell_view->request_resize.link);
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -299,6 +341,14 @@ static void handle_map(struct wl_listener *listener, void *data) {
         xdg_shell_view->request_fullscreen.notify = handle_request_fullscreen;
         wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen,
                         &xdg_shell_view->request_fullscreen);
+
+        xdg_shell_view->request_move.notify = handle_request_move;
+        wl_signal_add(&xdg_surface->toplevel->events.request_move,
+                        &xdg_shell_view->request_move);
+
+        xdg_shell_view->request_resize.notify = handle_request_resize;
+        wl_signal_add(&xdg_surface->toplevel->events.request_resize,
+                        &xdg_shell_view->request_resize);
 }
 
 static void handle_destroy(struct wl_listener *listener, void *data) {
diff --git a/sway/desktop/xdg_shell_v6.c b/sway/desktop/xdg_shell_v6.c
index 4d76f0a7..201b5b1e 100644
--- a/sway/desktop/xdg_shell_v6.c
+++ b/sway/desktop/xdg_shell_v6.c
@@ -1,4 +1,5 @@
 #define _POSIX_C_SOURCE 199309L
+#include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <wayland-server.h>
@@ -94,6 +95,16 @@ static struct sway_xdg_shell_v6_view *xdg_shell_v6_view_from_view(
         return (struct sway_xdg_shell_v6_view *)view;
 }
 
+static void get_constraints(struct sway_view *view, double *min_width,
+                double *max_width, double *min_height, double *max_height) {
+        struct wlr_xdg_toplevel_v6_state *state =
+                &view->wlr_xdg_surface_v6->toplevel->current;
+        *min_width = state->min_width > 0 ? state->min_width : DBL_MIN;
+        *max_width = state->max_width > 0 ? state->max_width : DBL_MAX;
+        *min_height = state->min_height > 0 ? state->min_height : DBL_MIN;
+        *max_height = state->max_height > 0 ? state->max_height : DBL_MAX;
+}
+
 static const char *get_string_prop(struct sway_view *view, enum sway_view_prop prop) {
         if (xdg_shell_v6_view_from_view(view) == NULL) {
                 return NULL;
@@ -184,6 +195,7 @@ static void destroy(struct sway_view *view) {
 }
 
 static const struct sway_view_impl view_impl = {
+        .get_constraints = get_constraints,
         .get_string_prop = get_string_prop,
         .configure = configure,
         .set_activated = set_activated,
@@ -243,6 +255,34 @@ static void handle_request_fullscreen(struct wl_listener *listener, void *data)
         transaction_commit_dirty();
 }
 
+static void handle_request_move(struct wl_listener *listener, void *data) {
+        struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
+                wl_container_of(listener, xdg_shell_v6_view, request_move);
+        struct sway_view *view = &xdg_shell_v6_view->view;
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct wlr_xdg_toplevel_v6_move_event *e = data;
+        struct sway_seat *seat = e->seat->seat->data;
+        if (e->serial == seat->last_button_serial) {
+                seat_begin_move(seat, view->swayc, seat->last_button);
+        }
+}
+
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+        struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
+                wl_container_of(listener, xdg_shell_v6_view, request_resize);
+        struct sway_view *view = &xdg_shell_v6_view->view;
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct wlr_xdg_toplevel_v6_resize_event *e = data;
+        struct sway_seat *seat = e->seat->seat->data;
+        if (e->serial == seat->last_button_serial) {
+                seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
+        }
+}
+
 static void handle_unmap(struct wl_listener *listener, void *data) {
         struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
                 wl_container_of(listener, xdg_shell_v6_view, unmap);
@@ -257,6 +297,8 @@ static void handle_unmap(struct wl_listener *listener, void *data) {
         wl_list_remove(&xdg_shell_v6_view->commit.link);
         wl_list_remove(&xdg_shell_v6_view->new_popup.link);
         wl_list_remove(&xdg_shell_v6_view->request_fullscreen.link);
+        wl_list_remove(&xdg_shell_v6_view->request_move.link);
+        wl_list_remove(&xdg_shell_v6_view->request_resize.link);
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -294,6 +336,14 @@ static void handle_map(struct wl_listener *listener, void *data) {
         xdg_shell_v6_view->request_fullscreen.notify = handle_request_fullscreen;
         wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen,
                         &xdg_shell_v6_view->request_fullscreen);
+
+        xdg_shell_v6_view->request_move.notify = handle_request_move;
+        wl_signal_add(&xdg_surface->toplevel->events.request_move,
+                        &xdg_shell_v6_view->request_move);
+
+        xdg_shell_v6_view->request_resize.notify = handle_request_resize;
+        wl_signal_add(&xdg_surface->toplevel->events.request_resize,
+                        &xdg_shell_v6_view->request_resize);
 }
 
 static void handle_destroy(struct wl_listener *listener, void *data) {
diff --git a/sway/desktop/xwayland.c b/sway/desktop/xwayland.c
index bce0a37b..2546168b 100644
--- a/sway/desktop/xwayland.c
+++ b/sway/desktop/xwayland.c
@@ -305,6 +305,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
         wl_list_remove(&xwayland_view->destroy.link);
         wl_list_remove(&xwayland_view->request_configure.link);
         wl_list_remove(&xwayland_view->request_fullscreen.link);
+        wl_list_remove(&xwayland_view->request_move.link);
+        wl_list_remove(&xwayland_view->request_resize.link);
         wl_list_remove(&xwayland_view->set_title.link);
         wl_list_remove(&xwayland_view->set_class.link);
         wl_list_remove(&xwayland_view->set_window_type.link);
@@ -400,6 +402,37 @@ static void handle_request_fullscreen(struct wl_listener *listener, void *data)
         transaction_commit_dirty();
 }
 
+static void handle_request_move(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view =
+                wl_container_of(listener, xwayland_view, request_move);
+        struct sway_view *view = &xwayland_view->view;
+        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
+        if (!xsurface->mapped) {
+                return;
+        }
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct sway_seat *seat = input_manager_current_seat(input_manager);
+        seat_begin_move(seat, view->swayc, seat->last_button);
+}
+
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+        struct sway_xwayland_view *xwayland_view =
+                wl_container_of(listener, xwayland_view, request_resize);
+        struct sway_view *view = &xwayland_view->view;
+        struct wlr_xwayland_surface *xsurface = view->wlr_xwayland_surface;
+        if (!xsurface->mapped) {
+                return;
+        }
+        if (!container_is_floating(view->swayc)) {
+                return;
+        }
+        struct wlr_xwayland_resize_event *e = data;
+        struct sway_seat *seat = input_manager_current_seat(input_manager);
+        seat_begin_resize(seat, view->swayc, seat->last_button, e->edges);
+}
+
 static void handle_set_title(struct wl_listener *listener, void *data) {
         struct sway_xwayland_view *xwayland_view =
                 wl_container_of(listener, xwayland_view, set_title);
@@ -495,6 +528,14 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
                 &xwayland_view->request_fullscreen);
         xwayland_view->request_fullscreen.notify = handle_request_fullscreen;
 
+        wl_signal_add(&xsurface->events.request_move,
+                &xwayland_view->request_move);
+        xwayland_view->request_move.notify = handle_request_move;
+
+        wl_signal_add(&xsurface->events.request_resize,
+                &xwayland_view->request_resize);
+        xwayland_view->request_resize.notify = handle_request_resize;
+
         wl_signal_add(&xsurface->events.set_title, &xwayland_view->set_title);
         xwayland_view->set_title.notify = handle_set_title;
 
diff --git a/sway/input/cursor.c b/sway/input/cursor.c
index c76c20b3..771ad01d 100644
--- a/sway/input/cursor.c
+++ b/sway/input/cursor.c
@@ -5,15 +5,19 @@
 #elif __FreeBSD__
 #include <dev/evdev/input-event-codes.h>
 #endif
+#include <limits.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_xcursor_manager.h>
 #include <wlr/types/wlr_idle.h>
 #include "list.h"
 #include "log.h"
+#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
+#include "sway/input/keyboard.h"
 #include "sway/layers.h"
 #include "sway/output.h"
+#include "sway/tree/arrange.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
 #include "wlr-layer-shell-unstable-v1-protocol.h"
@@ -127,7 +131,7 @@ static struct sway_container *container_at_coords(
                 return ws;
         }
 
-        c = seat_get_focus_inactive(seat, output->swayc);
+        c = seat_get_active_child(seat, output->swayc);
         if (c) {
                 return c;
         }
@@ -139,6 +143,171 @@ static struct sway_container *container_at_coords(
         return output->swayc;
 }
 
+static enum wlr_edges find_resize_edge(struct sway_container *cont,
+                struct sway_cursor *cursor) {
+        if (cont->type != C_VIEW) {
+                return WLR_EDGE_NONE;
+        }
+        struct sway_view *view = cont->sway_view;
+        if (view->border == B_NONE || !view->border_thickness || view->using_csd) {
+                return WLR_EDGE_NONE;
+        }
+
+        enum wlr_edges edge = 0;
+        if (cursor->cursor->x < cont->x + view->border_thickness) {
+                edge |= WLR_EDGE_LEFT;
+        }
+        if (cursor->cursor->y < cont->y + view->border_thickness) {
+                edge |= WLR_EDGE_TOP;
+        }
+        if (cursor->cursor->x >= cont->x + cont->width - view->border_thickness) {
+                edge |= WLR_EDGE_RIGHT;
+        }
+        if (cursor->cursor->y >= cont->y + cont->height - view->border_thickness) {
+                edge |= WLR_EDGE_BOTTOM;
+        }
+        return edge;
+}
+
+static void handle_move_motion(struct sway_seat *seat,
+                struct sway_cursor *cursor) {
+        struct sway_container *con = seat->op_container;
+        desktop_damage_whole_container(con);
+        container_floating_translate(con,
+                        cursor->cursor->x - cursor->previous.x,
+                        cursor->cursor->y - cursor->previous.y);
+        desktop_damage_whole_container(con);
+}
+
+static void calculate_floating_constraints(struct sway_container *con,
+                int *min_width, int *max_width, int *min_height, int *max_height) {
+        if (config->floating_minimum_width == -1) { // no minimum
+                *min_width = 0;
+        } else if (config->floating_minimum_width == 0) { // automatic
+                *min_width = 75;
+        } else {
+                *min_width = config->floating_minimum_width;
+        }
+
+        if (config->floating_minimum_height == -1) { // no minimum
+                *min_height = 0;
+        } else if (config->floating_minimum_height == 0) { // automatic
+                *min_height = 50;
+        } else {
+                *min_height = config->floating_minimum_height;
+        }
+
+        if (config->floating_maximum_width == -1) { // no maximum
+                *max_width = INT_MAX;
+        } else if (config->floating_maximum_width == 0) { // automatic
+                struct sway_container *ws = container_parent(con, C_WORKSPACE);
+                *max_width = ws->width;
+        } else {
+                *max_width = config->floating_maximum_width;
+        }
+
+        if (config->floating_maximum_height == -1) { // no maximum
+                *max_height = INT_MAX;
+        } else if (config->floating_maximum_height == 0) { // automatic
+                struct sway_container *ws = container_parent(con, C_WORKSPACE);
+                *max_height = ws->height;
+        } else {
+                *max_height = config->floating_maximum_height;
+        }
+}
+
+static void handle_resize_motion(struct sway_seat *seat,
+                struct sway_cursor *cursor) {
+        struct sway_container *con = seat->op_container;
+        enum wlr_edges edge = seat->op_resize_edge;
+
+        // The amount the mouse has moved since the start of the resize operation
+        // Positive is down/right
+        double mouse_move_x = cursor->cursor->x - seat->op_ref_lx;
+        double mouse_move_y = cursor->cursor->y - seat->op_ref_ly;
+
+        if (edge == WLR_EDGE_TOP || edge == WLR_EDGE_BOTTOM) {
+                mouse_move_x = 0;
+        }
+        if (edge == WLR_EDGE_LEFT || edge == WLR_EDGE_RIGHT) {
+                mouse_move_y = 0;
+        }
+
+        double grow_width = edge & WLR_EDGE_LEFT ? -mouse_move_x : mouse_move_x;
+        double grow_height = edge & WLR_EDGE_TOP ? -mouse_move_y : mouse_move_y;
+
+        if (seat->op_resize_preserve_ratio) {
+                double x_multiplier = grow_width / seat->op_ref_width;
+                double y_multiplier = grow_height / seat->op_ref_height;
+                double max_multiplier = fmax(x_multiplier, y_multiplier);
+                grow_width = seat->op_ref_width * max_multiplier;
+                grow_height = seat->op_ref_height * max_multiplier;
+        }
+
+        // Determine new width/height, and accommodate for floating min/max values
+        double width = seat->op_ref_width + grow_width;
+        double height = seat->op_ref_height + grow_height;
+        int min_width, max_width, min_height, max_height;
+        calculate_floating_constraints(con, &min_width, &max_width,
+                        &min_height, &max_height);
+        width = fmax(min_width, fmin(width, max_width));
+        height = fmax(min_height, fmin(height, max_height));
+
+        // Apply the view's min/max size
+        if (con->type == C_VIEW) {
+                double view_min_width, view_max_width, view_min_height, view_max_height;
+                view_get_constraints(con->sway_view, &view_min_width, &view_max_width,
+                                &view_min_height, &view_max_height);
+                width = fmax(view_min_width, fmin(width, view_max_width));
+                height = fmax(view_min_height, fmin(height, view_max_height));
+        }
+
+        // Recalculate these, in case we hit a min/max limit
+        grow_width = width - seat->op_ref_width;
+        grow_height = height - seat->op_ref_height;
+
+        // Determine grow x/y values - these are relative to the container's x/y at
+        // the start of the resize operation.
+        double grow_x = 0, grow_y = 0;
+        if (edge & WLR_EDGE_LEFT) {
+                grow_x = -grow_width;
+        } else if (edge & WLR_EDGE_RIGHT) {
+                grow_x = 0;
+        } else {
+                grow_x = -grow_width / 2;
+        }
+        if (edge & WLR_EDGE_TOP) {
+                grow_y = -grow_height;
+        } else if (edge & WLR_EDGE_BOTTOM) {
+                grow_y = 0;
+        } else {
+                grow_y = -grow_height / 2;
+        }
+
+        // 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 = (seat->op_ref_con_lx + grow_x) - con->x;
+        int relative_grow_y = (seat->op_ref_con_ly + grow_y) - con->y;
+
+        // Actually resize stuff
+        con->x += relative_grow_x;
+        con->y += relative_grow_y;
+        con->width += relative_grow_width;
+        con->height += relative_grow_height;
+
+        if (con->type == C_VIEW) {
+                struct sway_view *view = con->sway_view;
+                view->x += relative_grow_x;
+                view->y += relative_grow_y;
+                view->width += relative_grow_width;
+                view->height += relative_grow_height;
+        }
+
+        arrange_windows(con);
+}
+
 void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
                 bool allow_refocusing) {
         if (time_msec == 0) {
@@ -146,6 +315,18 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
         }
 
         struct sway_seat *seat = cursor->seat;
+
+        if (seat->operation != OP_NONE) {
+                if (seat->operation == OP_MOVE) {
+                        handle_move_motion(seat, cursor);
+                } else {
+                        handle_resize_motion(seat, cursor);
+                }
+                cursor->previous.x = cursor->cursor->x;
+                cursor->previous.y = cursor->cursor->y;
+                return;
+        }
+
         struct wlr_seat *wlr_seat = seat->wlr_seat;
         struct wlr_surface *surface = NULL;
         double sx, sy;
@@ -194,15 +375,21 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
                 }
         }
 
-        // reset cursor if switching between clients
-        struct wl_client *client = NULL;
-        if (surface != NULL) {
-                client = wl_resource_get_client(surface->resource);
-        }
-        if (client != cursor->image_client) {
-                wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
-                        "left_ptr", cursor->cursor);
-                cursor->image_client = client;
+        // Handle cursor image
+        if (surface) {
+                // Reset cursor if switching between clients
+                struct wl_client *client = wl_resource_get_client(surface->resource);
+                if (client != cursor->image_client) {
+                        cursor_set_image(cursor, "left_ptr", client);
+                }
+        } else if (c && container_is_floating(c)) {
+                // Try a floating container's resize edge
+                enum wlr_edges edge = find_resize_edge(c, cursor);
+                const char *image = edge == WLR_EDGE_NONE ?
+                        "left_ptr" : wlr_xcursor_get_resize_name(edge);
+                cursor_set_image(cursor, image, NULL);
+        } else {
+                cursor_set_image(cursor, "left_ptr", NULL);
         }
 
         // send pointer enter/leave
@@ -243,8 +430,53 @@ static void handle_cursor_motion_absolute(
         transaction_commit_dirty();
 }
 
+static void dispatch_cursor_button_floating(struct sway_cursor *cursor,
+                uint32_t time_msec, uint32_t button, enum wlr_button_state state,
+                struct wlr_surface *surface, double sx, double sy,
+                struct sway_container *cont) {
+        struct sway_seat *seat = cursor->seat;
+
+        // Deny moving or resizing a fullscreen view
+        if (cont->type == C_VIEW && cont->sway_view->is_fullscreen) {
+                seat_pointer_notify_button(seat, time_msec, button, state);
+                return;
+        }
+
+        struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
+        bool mod_pressed = keyboard &&
+                (wlr_keyboard_get_modifiers(keyboard) & config->floating_mod);
+        enum wlr_edges edge = find_resize_edge(cont, cursor);
+        bool over_title = edge == WLR_EDGE_NONE && !surface;
+
+        // Check for beginning move
+        if (button == BTN_LEFT && state == WLR_BUTTON_PRESSED &&
+                        (mod_pressed || over_title)) {
+                seat_begin_move(seat, cont, BTN_LEFT);
+                return;
+        }
+
+        // Check for beginning resize
+        bool resizing_via_border = button == BTN_LEFT && edge != WLR_EDGE_NONE;
+        bool resizing_via_mod = button == BTN_RIGHT && mod_pressed;
+        if ((resizing_via_border || resizing_via_mod) &&
+                        state == WLR_BUTTON_PRESSED) {
+                seat_begin_resize(seat, cont, button, edge);
+                return;
+        }
+
+        // Send event to surface
+        seat_set_focus(seat, cont);
+        seat_pointer_notify_button(seat, time_msec, button, state);
+}
+
 void dispatch_cursor_button(struct sway_cursor *cursor,
                 uint32_t time_msec, uint32_t button, enum wlr_button_state state) {
+        if (cursor->seat->operation != OP_NONE &&
+                        button == cursor->seat->op_button && state == WLR_BUTTON_RELEASED) {
+                seat_end_mouse_operation(cursor->seat);
+                seat_pointer_notify_button(cursor->seat, time_msec, button, state);
+                return;
+        }
         if (time_msec == 0) {
                 time_msec = get_current_time_msec();
         }
@@ -259,6 +491,10 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
                 if (layer->current.keyboard_interactive) {
                         seat_set_focus_layer(cursor->seat, layer);
                 }
+                seat_pointer_notify_button(cursor->seat, time_msec, button, state);
+        } else if (cont && container_is_floating(cont)) {
+                dispatch_cursor_button_floating(cursor, time_msec, button, state,
+                                surface, sx, sy, cont);
         } else if (surface && cont && cont->type != C_VIEW) {
                 // Avoid moving keyboard focus from a surface that accepts it to one
                 // that does not unless the change would move us to a new workspace.
@@ -275,12 +511,14 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
                 if (new_ws != old_ws) {
                         seat_set_focus(cursor->seat, cont);
                 }
+                seat_pointer_notify_button(cursor->seat, time_msec, button, state);
         } else if (cont) {
                 seat_set_focus(cursor->seat, cont);
+                seat_pointer_notify_button(cursor->seat, time_msec, button, state);
+        } else {
+                seat_pointer_notify_button(cursor->seat, time_msec, button, state);
         }
 
-        wlr_seat_pointer_notify_button(cursor->seat->wlr_seat,
-                        time_msec, button, state);
         transaction_commit_dirty();
 }
 
@@ -467,6 +705,9 @@ static void handle_request_set_cursor(struct wl_listener *listener,
                 void *data) {
         struct sway_cursor *cursor =
                 wl_container_of(listener, cursor, request_set_cursor);
+        if (cursor->seat->operation != OP_NONE) {
+                return;
+        }
         struct wlr_seat_pointer_request_set_cursor_event *event = data;
 
         struct wl_client *focused_client = NULL;
@@ -488,6 +729,16 @@ static void handle_request_set_cursor(struct wl_listener *listener,
         cursor->image_client = focused_client;
 }
 
+void cursor_set_image(struct sway_cursor *cursor, const char *image,
+                struct wl_client *client) {
+        if (!cursor->image || strcmp(cursor->image, image) != 0) {
+                wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager, image,
+                                cursor->cursor);
+                cursor->image = image;
+        }
+        cursor->image_client = client;
+}
+
 void sway_cursor_destroy(struct sway_cursor *cursor) {
         if (!cursor) {
                 return;
diff --git a/sway/input/seat.c b/sway/input/seat.c
index e77d88a8..273223db 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -1,6 +1,11 @@
 #define _XOPEN_SOURCE 700
 #define _POSIX_C_SOURCE 199309L
 #include <assert.h>
+#ifdef __linux__
+#include <linux/input-event-codes.h>
+#elif __FreeBSD__
+#include <dev/evdev/input-event-codes.h>
+#endif
 #include <strings.h>
 #include <time.h>
 #include <wlr/types/wlr_cursor.h>
@@ -348,6 +353,7 @@ struct sway_seat *seat_create(struct sway_input_manager *input,
                 free(seat);
                 return NULL;
         }
+        seat->wlr_seat->data = seat;
 
         seat->cursor = sway_cursor_create(seat);
         if (!seat->cursor) {
@@ -894,3 +900,68 @@ struct seat_config *seat_get_config(struct sway_seat *seat) {
 
         return NULL;
 }
+
+void seat_begin_move(struct sway_seat *seat, struct sway_container *con,
+                uint32_t button) {
+        if (!seat->cursor) {
+                wlr_log(WLR_DEBUG, "Ignoring move request due to no cursor device");
+                return;
+        }
+        seat->operation = OP_MOVE;
+        seat->op_container = con;
+        seat->op_button = button;
+        cursor_set_image(seat->cursor, "grab", NULL);
+}
+
+void seat_begin_resize(struct sway_seat *seat, struct sway_container *con,
+                uint32_t button, enum wlr_edges edge) {
+        if (!seat->cursor) {
+                wlr_log(WLR_DEBUG, "Ignoring resize request due to no cursor device");
+                return;
+        }
+        struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
+        seat->operation = OP_RESIZE;
+        seat->op_container = con;
+        seat->op_resize_preserve_ratio = keyboard &&
+                (wlr_keyboard_get_modifiers(keyboard) & WLR_MODIFIER_SHIFT);
+        seat->op_resize_edge = edge == WLR_EDGE_NONE ?
+                RESIZE_EDGE_BOTTOM | RESIZE_EDGE_RIGHT : edge;
+        seat->op_button = button;
+        seat->op_ref_lx = seat->cursor->cursor->x;
+        seat->op_ref_ly = seat->cursor->cursor->y;
+        seat->op_ref_con_lx = con->x;
+        seat->op_ref_con_ly = con->y;
+        seat->op_ref_width = con->width;
+        seat->op_ref_height = con->height;
+
+        const char *image = edge == WLR_EDGE_NONE ?
+                "se-resize" : wlr_xcursor_get_resize_name(edge);
+        cursor_set_image(seat->cursor, image, NULL);
+}
+
+void seat_end_mouse_operation(struct sway_seat *seat) {
+        switch (seat->operation) {
+        case OP_MOVE:
+                {
+                        // We "move" the container to its own location so it discovers its
+                        // output again.
+                        struct sway_container *con = seat->op_container;
+                        container_floating_move_to(con, con->x, con->y);
+                }
+        case OP_RESIZE:
+                // Don't need to do anything here.
+                break;
+        case OP_NONE:
+                break;
+        }
+        seat->operation = OP_NONE;
+        seat->op_container = NULL;
+        cursor_set_image(seat->cursor, "left_ptr", NULL);
+}
+
+void seat_pointer_notify_button(struct sway_seat *seat, uint32_t time_msec,
+                uint32_t button, enum wlr_button_state state) {
+        seat->last_button = button;
+        seat->last_button_serial = wlr_seat_pointer_notify_button(seat->wlr_seat,
+                        time_msec, button, state);
+}
diff --git a/sway/meson.build b/sway/meson.build
index 09bc40b8..f4fdc8ea 100644
--- a/sway/meson.build
+++ b/sway/meson.build
@@ -42,6 +42,7 @@ sway_sources = files(
         'commands/exec_always.c',
         'commands/floating.c',
         'commands/floating_minmax_size.c',
+        'commands/floating_modifier.c',
         'commands/focus.c',
         'commands/focus_follows_mouse.c',
         'commands/focus_wrapping.c',
diff --git a/sway/tree/container.c b/sway/tree/container.c
index 4dbfbb29..42c1d024 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -323,6 +323,8 @@ static struct sway_container *container_destroy_noreaping(
                 }
         }
 
+        container_end_mouse_operation(con);
+
         con->destroying = true;
         container_set_dirty(con);
 
@@ -964,6 +966,8 @@ void container_set_floating(struct sway_container *container, bool enable) {
                 container_reap_empty_recursive(workspace->sway_workspace->floating);
         }
 
+        container_end_mouse_operation(container);
+
         ipc_event_window(container, "floating");
 }
 
@@ -1009,7 +1013,7 @@ void container_get_box(struct sway_container *container, struct wlr_box *box) {
 /**
  * Translate the container's position as well as all children.
  */
-static void container_floating_translate(struct sway_container *con,
+void container_floating_translate(struct sway_container *con,
                 double x_amount, double y_amount) {
         con->x += x_amount;
         con->y += y_amount;
@@ -1105,3 +1109,12 @@ static bool find_urgent_iterator(struct sway_container *con,
 bool container_has_urgent_child(struct sway_container *container) {
         return container_find(container, find_urgent_iterator, NULL);
 }
+
+void container_end_mouse_operation(struct sway_container *container) {
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &input_manager->seats, link) {
+                if (seat->op_container == container) {
+                        seat_end_mouse_operation(seat);
+                }
+        }
+}
diff --git a/sway/tree/layout.c b/sway/tree/layout.c
index 1f898f8a..533906fa 100644
--- a/sway/tree/layout.c
+++ b/sway/tree/layout.c
@@ -562,6 +562,7 @@ void container_move(struct sway_container *container,
                 workspace_detect_urgent(last_ws);
                 workspace_detect_urgent(next_ws);
         }
+        container_end_mouse_operation(container);
 }
 
 enum sway_container_layout container_get_default_layout(
diff --git a/sway/tree/view.c b/sway/tree/view.c
index 7881e6d7..89150a69 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -141,6 +141,19 @@ const char *view_get_shell(struct sway_view *view) {
         return "unknown";
 }
 
+void view_get_constraints(struct sway_view *view, double *min_width,
+                double *max_width, double *min_height, double *max_height) {
+        if (view->impl->get_constraints) {
+                view->impl->get_constraints(view,
+                                min_width, max_width, min_height, max_height);
+        } else {
+                *min_width = DBL_MIN;
+                *max_width = DBL_MAX;
+                *min_height = DBL_MIN;
+                *max_height = DBL_MAX;
+        }
+}
+
 uint32_t view_configure(struct sway_view *view, double lx, double ly, int width,
                 int height) {
         if (view->impl->configure) {
@@ -387,6 +400,8 @@ void view_set_fullscreen(struct sway_view *view, bool fullscreen) {
                 }
         }
 
+        container_end_mouse_operation(view->swayc);
+
         ipc_event_window(view->swayc, "fullscreen_mode");
 }