From 42d5d9a17779710e83f4ebb2d7e8c893ad91dfe6 Mon Sep 17 00:00:00 2001
From: taiyu <taiyu.len@gmail.com>
Date: Sat, 22 Aug 2015 21:03:45 -0700
Subject: [PATCH] mouse tile resize mode done

---
 include/input_state.h |  46 +++-----
 include/resize.h      |   2 +-
 sway/handlers.c       | 122 +++++++-------------
 sway/input_state.c    | 230 +++++++++++++++++++------------------
 sway/resize.c         | 261 ------------------------------------------
 5 files changed, 175 insertions(+), 486 deletions(-)

diff --git a/include/input_state.h b/include/input_state.h
index 3a246e0c..747a3563 100644
--- a/include/input_state.h
+++ b/include/input_state.h
@@ -37,52 +37,34 @@ enum pointer_mode {
 	M_RESIZING = 1 << 3,
 };
 
+struct pointer_button_state {
+	bool held;
+	// state at the point it was pressed
+	int x, y;
+	swayc_t *view;
+};
+
 extern struct pointer_state {
 	// mouse clicks
-	bool l_held : 1;
-	bool r_held : 1;
-
-	// scroll wheel
-	bool s_held : 1;
-	bool s_up : 1;
-	bool s_down :1;
+	struct pointer_button_state left;
+	struct pointer_button_state right;
+	struct pointer_button_state scroll;
 
 	// pointer position
 	struct mouse_origin{
 		int x, y;
 	} origin;
+
+	// change in pointer position
 	struct {
 		int x, y;
 	} delta;
 
-	// view pointer is over
+	// view pointer is currently over
 	swayc_t *view;
 
 	// Pointer mode
 	int mode;
-
-	// OLD
-	struct pointer_floating {
-		bool drag;
-		bool resize;
-	} floating;
-	struct pointer_tiling {
-		bool resize;
-		swayc_t *init_view;
-		struct wlc_origin lock_pos;
-	} tiling;
-	struct pointer_lock {
-		// Lock movement for certain edges
-		bool left;
-		bool right;
-		bool top;
-		bool bottom;
-		// Lock movement in certain directions
-		bool temp_left;
-		bool temp_right;
-		bool temp_up;
-		bool temp_down;
-	} lock;
 } pointer_state;
 
 // on button release unset mode depending on the button.
@@ -95,8 +77,6 @@ void pointer_mode_update(void);
 // Reset mode on any keypress;
 void pointer_mode_reset(void);
 
-void start_floating(swayc_t *view);
-void reset_floating(swayc_t *view);
 void input_init(void);
 
 #endif
diff --git a/include/resize.h b/include/resize.h
index 4ace1815..04209983 100644
--- a/include/resize.h
+++ b/include/resize.h
@@ -1,8 +1,8 @@
 #ifndef _SWAY_RESIZE_H
 #define _SWAY_RESIZE_H
+#include <stdbool.h>
 
 bool mouse_resize_tiled(struct wlc_origin prev_pos);
-bool resize_floating(struct wlc_origin prev_pos);
 bool resize_tiled(int amount, bool use_width);
 
 #endif
diff --git a/sway/handlers.c b/sway/handlers.c
index 7d1e4cde..896caa10 100644
--- a/sway/handlers.c
+++ b/sway/handlers.c
@@ -359,35 +359,53 @@ static bool handle_pointer_button(wlc_handle view, uint32_t time, const struct w
 		uint32_t button, enum wlc_button_state state, const struct wlc_origin *origin) {
 	enum { DONT_SEND_CLICK = true, SEND_CLICK = false };
 
-	// Update pointer_state
-	switch (button) {
-	case M_LEFT_CLICK:
-		pointer_state.l_held = state == WLC_BUTTON_STATE_PRESSED;
-		break;
-
-	case M_RIGHT_CLICK:
-		pointer_state.r_held = state == WLC_BUTTON_STATE_PRESSED;
-		break;
-
-	case M_SCROLL_CLICK:
-		pointer_state.s_held = state == WLC_BUTTON_STATE_PRESSED;
-		break;
-
-	case M_SCROLL_UP:
-		pointer_state.s_up = state == WLC_BUTTON_STATE_PRESSED;
-		break;
-
-	case M_SCROLL_DOWN:
-		pointer_state.s_down = state == WLC_BUTTON_STATE_PRESSED;
-		break;
-	}
+	// Update view pointer is on
+	pointer_state.view = container_under_pointer();
 
 	// Update pointer origin
 	pointer_state.origin.x = origin->x;
 	pointer_state.origin.y = origin->y;
 
-	// Update view pointer is on
-	pointer_state.view = container_under_pointer();
+	// Update pointer_state
+	switch (button) {
+	case M_LEFT_CLICK:
+		if (state == WLC_BUTTON_STATE_PRESSED) {
+			pointer_state.left.held = true;
+			pointer_state.left.x = origin->x;
+			pointer_state.left.y = origin->y;
+			pointer_state.left.view = pointer_state.view;
+		} else {
+			pointer_state.left.held = false;
+		}
+		break;
+
+	case M_RIGHT_CLICK:
+		if (state == WLC_BUTTON_STATE_PRESSED) {
+			pointer_state.right.held = true;
+			pointer_state.right.x = origin->x;
+			pointer_state.right.y = origin->y;
+			pointer_state.right.view = pointer_state.view;
+		} else {
+			pointer_state.right.held = false;
+		}
+		break;
+
+	case M_SCROLL_CLICK:
+		if (state == WLC_BUTTON_STATE_PRESSED) {
+			pointer_state.scroll.held = true;
+			pointer_state.scroll.x = origin->x;
+			pointer_state.scroll.y = origin->y;
+			pointer_state.scroll.view = pointer_state.view;
+		} else {
+			pointer_state.scroll.held = false;
+		}
+		break;
+
+		//TODO scrolling behavior
+	case M_SCROLL_UP:
+	case M_SCROLL_DOWN:
+		break;
+	}
 
 	// set pointer mode
 	pointer_mode_set(button,
@@ -431,62 +449,6 @@ static bool handle_pointer_button(wlc_handle view, uint32_t time, const struct w
 
 	// Finally send click
 	return SEND_CLICK;
-
-	/* OLD */
-	if (state == WLC_BUTTON_STATE_PRESSED) {
-		sway_log(L_DEBUG, "Mouse button %u pressed", button);
-		if (button == M_LEFT_CLICK) {
-			pointer_state.l_held = true;
-		}
-		if (button == M_RIGHT_CLICK) {
-			pointer_state.r_held = true;
-		}
-		swayc_t *pointer = container_under_pointer();
-		if (pointer) {
-			set_focused_container(pointer);
-			int midway_x = pointer->x + pointer->width/2;
-			int midway_y = pointer->y + pointer->height/2;
-			pointer_state.lock.bottom = origin->y < midway_y;
-			pointer_state.lock.top = !pointer_state.lock.bottom;
-			pointer_state.lock.right = origin->x < midway_x;
-			pointer_state.lock.left = !pointer_state.lock.right;
-		}
-
-		if (pointer->is_floating) {
-			if (modifiers->mods & config->floating_mod) {
-				pointer_state.floating.drag = pointer_state.l_held;
-				pointer_state.floating.resize = pointer_state.r_held;
-				start_floating(pointer);
-			}
-			// Dont want pointer sent to window while dragging or resizing
-			return (pointer_state.floating.drag || pointer_state.floating.resize);
-		} else {
-			if (modifiers->mods & config->floating_mod) {
-				pointer_state.floating.drag = pointer_state.l_held;
-				pointer_state.tiling.resize = pointer_state.r_held;
-				pointer_state.tiling.init_view = pointer;
-				// Dont want pointer sent when resizing
-				return (pointer_state.tiling.resize);
-			}
-		}
-		return (pointer && pointer != focused);
-	} else {
-		sway_log(L_DEBUG, "Mouse button %u released", button);
-		if (button == M_LEFT_CLICK) {
-			pointer_state.l_held = false;
-			pointer_state.floating.drag = false;
-			pointer_state.tiling.init_view = NULL;
-		}
-		if (button == M_RIGHT_CLICK) {
-			pointer_state.r_held = false;
-			pointer_state.floating.resize = false;
-			pointer_state.tiling.resize = false;
-			pointer_state.tiling.init_view = NULL;
-			pointer_state.lock = (struct pointer_lock){false ,false ,false ,false, false, false, false, false};
-		}
-	}
-	/* OLD */
-	return false;
 }
 
 static void handle_wlc_ready(void) {
diff --git a/sway/input_state.c b/sway/input_state.c
index 3db78167..a63fc01c 100644
--- a/sway/input_state.c
+++ b/sway/input_state.c
@@ -48,75 +48,81 @@ void release_key(keycode key) {
 	}
 }
 
+// Pointer state and mode
+
 struct pointer_state pointer_state;
 
-// Pointer mode values
 static struct mode_state {
-	// Initial view state
+	// initial view state
+	double x, y, w, h;
+	swayc_t *ptr;
+	// containers resized with tiling resize
 	struct {
-		double x, y, w, h;
+		double x, w;
 		swayc_t *ptr;
-	} view;
-	// Initial pointer state
+	} lr;
 	struct {
-		int x, y;
-	} coor;
+		double y, h;
+		swayc_t *ptr;
+	} tb;
 } initial;
 
 static struct {
-	enum { LEFT=1, RIGHT=0 } lr;
-	enum { TOP=1, BOTTOM=0 } tb;
+	bool left;
+	bool top;
 } lock;
 
 // Floating set/unset
 
-static void pointer_mode_set_floating(void) {
-	initial.view.x = initial.view.ptr->x;
-	initial.view.y = initial.view.ptr->y;
-	initial.view.w = initial.view.ptr->width;
-	initial.view.h = initial.view.ptr->height;
-	// setup initial cooridinates
-	initial.coor.x = pointer_state.origin.x;
-	initial.coor.y = pointer_state.origin.y;
+static void set_initial_view(swayc_t *view) {
+	initial.ptr = view;
+	initial.x = view->x;
+	initial.y = view->y;
+	initial.w = view->width;
+	initial.h = view->height;
 }
 
-static void pointer_mode_reset_floating(void) {
-	initial.view.ptr->x = initial.view.x;
-	initial.view.ptr->y = initial.view.y;
-	initial.view.ptr->width = initial.view.w;
-	initial.view.ptr->height = initial.view.h;
-	arrange_windows(initial.view.ptr, -1, -1);
+static void reset_initial_view(void) {
+	initial.ptr->x = initial.x;
+	initial.ptr->y = initial.y;
+	initial.ptr->width = initial.w;
+	initial.ptr->height = initial.h;
+	arrange_windows(initial.ptr, -1, -1);
 	pointer_state.mode = 0;
 }
 
 // Mode set left/right click
 
 static void pointer_mode_set_left(void) {
-	swayc_t *view = pointer_state.view;
-	initial.view.ptr = view;
-	if (view->is_floating) {
+	set_initial_view(pointer_state.left.view);
+	if (initial.ptr->is_floating) {
 		pointer_state.mode = M_DRAGGING | M_FLOATING;
-		pointer_mode_set_floating();
 	} else {
 		pointer_state.mode = M_DRAGGING | M_TILING;
 	}
 }
 
 static void pointer_mode_set_right(void) {
-	swayc_t *view = pointer_state.view;
-	initial.view.ptr = view;
+	set_initial_view(pointer_state.right.view);
 	// Setup locking information
-	int midway_x = view->x + view->width/2;
-	int midway_y = view->y + view->height/2;
+	int midway_x = initial.ptr->x + initial.ptr->width/2;
+	int midway_y = initial.ptr->y + initial.ptr->height/2;
 
-	lock.lr = pointer_state.origin.x > midway_x;
-	lock.tb = pointer_state.origin.y > midway_y;
+	lock.left = pointer_state.origin.x > midway_x;
+	lock.top = pointer_state.origin.y > midway_y;
 
-	if (view->is_floating) {
+	if (initial.ptr->is_floating) {
 		pointer_state.mode = M_RESIZING | M_FLOATING;
-		pointer_mode_set_floating();
 	} else {
 		pointer_state.mode = M_RESIZING | M_TILING;
+		if ((initial.lr.ptr = get_swayc_in_direction(initial.ptr, lock.left ? MOVE_RIGHT: MOVE_LEFT))) {
+			initial.lr.x = initial.lr.ptr->x;
+			initial.lr.w = initial.lr.ptr->width;
+		}
+		if ((initial.tb.ptr = get_swayc_in_direction(initial.ptr, lock.top ? MOVE_DOWN: MOVE_UP))) {
+			initial.tb.y = initial.tb.ptr->y;
+			initial.tb.h = initial.tb.ptr->height;
+		}
 	}
 }
 
@@ -127,14 +133,14 @@ void pointer_mode_set(uint32_t button, bool condition) {
 	switch (pointer_state.mode & (M_DRAGGING | M_RESIZING)) {
 	case M_DRAGGING:
 	// end drag mode when left click is unpressed
-		if (!pointer_state.l_held) {
+		if (!pointer_state.left.held) {
 			pointer_state.mode = 0;
 		}
 		break;
 
 	case M_RESIZING:
 	// end resize mode when right click is unpressed
-		if (!pointer_state.r_held) {
+		if (!pointer_state.right.held) {
 			pointer_state.mode = 0;
 		}
 		break;
@@ -145,12 +151,13 @@ void pointer_mode_set(uint32_t button, bool condition) {
 		if (!condition || !pointer_state.view) {
 			break;
 		}
+
 		// Set mode depending on current button press
 		switch (button) {
 		// Start dragging mode
 		case M_LEFT_CLICK:
 			// if button release dont do anything
-			if (pointer_state.l_held) {
+			if (pointer_state.left.held) {
 				pointer_mode_set_left();
 			}
 			break;
@@ -158,106 +165,131 @@ void pointer_mode_set(uint32_t button, bool condition) {
 		// Start resize mode
 		case M_RIGHT_CLICK:
 			// if button release dont do anyhting
-			if (pointer_state.r_held) {
+			if (pointer_state.right.held) {
 				pointer_mode_set_right();
 			}
 			break;
-
-		case M_SCROLL_UP:
-		case M_SCROLL_DOWN:
-			//TODO add scrolling behavior here
-			;
 		}
 	}
 }
 
 void pointer_mode_update(void) {
-	swayc_t *view = initial.view.ptr;
-	if (view->type != C_VIEW) {
+	if (initial.ptr->type != C_VIEW) {
 		pointer_state.mode = 0;
 		return;
 	}
-	int dx = pointer_state.origin.x - initial.coor.x;
-	int dy = pointer_state.origin.y - initial.coor.y;
+	int dx = pointer_state.origin.x;
+	int dy = pointer_state.origin.y;
 	bool changed = false;
 
 	switch (pointer_state.mode) {
 	case M_FLOATING | M_DRAGGING:
 		// Update position
-		if (initial.view.x + dx != view->x) {
-			view->x = initial.view.x + dx;
+		dx -= pointer_state.left.x;
+		dy -= pointer_state.left.y;
+		if (initial.x + dx != initial.ptr->x) {
+			initial.ptr->x = initial.x + dx;
 			changed = true;
 		}
-		if (initial.view.y + dy != view->y) {
-			view->y = initial.view.y + dy;
+		if (initial.y + dy != initial.ptr->y) {
+			initial.ptr->y = initial.y + dy;
 			changed = true;
 		}
+		update_geometry(initial.ptr);
 		break;
 
 	case M_FLOATING | M_RESIZING:
-		if (lock.lr) {
-			if (initial.view.w + dx > min_sane_w) {
-				if (initial.view.w + dx != view->width) {
-					view->width = initial.view.w + dx;
-					changed = true;
-				}
+		dx -= pointer_state.right.x;
+		dy -= pointer_state.right.y;
+		initial.ptr = pointer_state.right.view;
+		if (lock.left) {
+			if (initial.w + dx > min_sane_w) {
+				initial.ptr->width = initial.w + dx;
 			}
 		} else { //lock.right
-			if (initial.view.w - dx > min_sane_w) {
-				if (initial.view.w - dx != view->width) {
-					view->width = initial.view.w - dx;
-					view->x = initial.view.x + dx;
-					changed = true;
-				}
+			if (initial.w - dx > min_sane_w) {
+				initial.ptr->width = initial.w - dx;
+				initial.ptr->x = initial.x + dx;
 			}
 		}
-		if (lock.tb) {
-			if (initial.view.h + dy > min_sane_h) {
-				if (initial.view.y - dy != view->height) {
-					view->height = initial.view.h + dy;
-					changed = true;
-				}
+		if (lock.top) {
+			if (initial.h + dy > min_sane_h) {
+				initial.ptr->height = initial.h + dy;
 			}
 		} else { //lock.bottom
-			if (initial.view.h - dy > min_sane_h) {
-				if (initial.view.h - dy != view->height) {
-					view->height = initial.view.h - dy;
-					view->y = initial.view.y + dy;
-					changed = true;
-				}
+			if (initial.h - dy > min_sane_h) {
+				initial.ptr->height = initial.h - dy;
+				initial.ptr->y = initial.y + dy;
 			}
 		}
+		update_geometry(initial.ptr);
 		break;
 
 	case M_TILING | M_DRAGGING:
 		// swap current view under pointer with dragged view
-		if (pointer_state.view && pointer_state.view != initial.view.ptr) {
+		if (pointer_state.view && pointer_state.view != initial.ptr) {
 			// Swap them around
-			swap_container(pointer_state.view, initial.view.ptr);
+			swap_container(pointer_state.view, initial.ptr);
 			update_geometry(pointer_state.view);
-			update_geometry(initial.view.ptr);
+			update_geometry(initial.ptr);
 			// Set focus back to initial view
-			set_focused_container(initial.view.ptr);
+			set_focused_container(initial.ptr);
 		}
 		break;
 
 	case M_TILING | M_RESIZING:
-		
-		
-
+		dx -= pointer_state.right.x;
+		dy -= pointer_state.right.y;
+		// resize if we can
+		if (initial.lr.ptr) {
+			if (lock.left) {
+				// Check whether its fine to resize
+				if (initial.w + dx > min_sane_w && initial.lr.w - dx > min_sane_w) {
+					initial.ptr->width = initial.w + dx;
+					initial.lr.ptr->width = initial.lr.w - dx;
+					initial.lr.ptr->x = initial.lr.x + dx;
+				}
+			} else { //lock.right
+				if (initial.w - dx > min_sane_w && initial.lr.w + dx > min_sane_w) {
+					initial.ptr->width = initial.w - dx;
+					initial.ptr->x = initial.x + dx;
+					initial.lr.ptr->width = initial.lr.w + dx;
+				}
+				changed = true;
+			}
+			arrange_windows(initial.lr.ptr->parent, -1, -1);
+		}
+		if (initial.tb.ptr) {
+			if (lock.top) {
+				if (initial.h + dy > min_sane_h && initial.tb.h - dy > min_sane_h) {
+					initial.ptr->height = initial.h + dy;
+					initial.tb.ptr->height = initial.tb.h - dy;
+					initial.tb.ptr->y = initial.tb.y + dy;
+				}
+			} else { //lock.bottom
+				if (initial.h - dy > min_sane_h && initial.tb.h + dy > min_sane_h) {
+					initial.ptr->height = initial.h - dy;
+					initial.ptr->y = initial.y + dy;
+					initial.tb.ptr->height = initial.tb.h + dy;
+				}
+				changed = true;
+			}
+			arrange_windows(initial.tb.ptr->parent, -1, -1);
+		}
+		if (changed) {
+			arrange_windows(initial.ptr->parent, -1, -1);
+		}
+		changed = false;
 	default:
 		return;
 	}
-	if (changed) {
-		update_geometry(view);
-	}
 }
 
 void pointer_mode_reset(void) {
 	switch (pointer_state.mode) {
 	case M_FLOATING | M_DRAGGING:
 	case M_FLOATING | M_RESIZING:
-		pointer_mode_reset_floating();
+		reset_initial_view();
 		break;
 
 	case M_TILING | M_DRAGGING:
@@ -267,27 +299,3 @@ void pointer_mode_reset(void) {
 	}
 }
 
-
-static struct wlc_geometry saved_floating;
-
-void start_floating(swayc_t *view) {
-	if (view->is_floating) {
-		saved_floating.origin.x = view->x;
-		saved_floating.origin.y = view->y;
-		saved_floating.size.w = view->width;
-		saved_floating.size.h = view->height;
-	}
-}
-
-void reset_floating(swayc_t *view) {
-	if (view->is_floating) {
-		view->x = saved_floating.origin.x;
-		view->y = saved_floating.origin.y;
-		view->width = saved_floating.size.w;
-		view->height = saved_floating.size.h;
-		arrange_windows(view->parent, -1, -1);
-	}
-	pointer_state.floating = (struct pointer_floating){0, 0};
-	pointer_state.lock = (struct pointer_lock){0, 0, 0, 0, 0, 0, 0, 0};
-}
-
diff --git a/sway/resize.c b/sway/resize.c
index 31cd66e8..22d520af 100644
--- a/sway/resize.c
+++ b/sway/resize.c
@@ -6,267 +6,6 @@
 #include "input_state.h"
 #include "handlers.h"
 
-bool mouse_resize_tiled(struct wlc_origin prev_pos) {
-	swayc_t *view = container_under_pointer();
-	bool valid = true;
-	bool changed_tiling = false;
-	double dx = pointer_state.origin.x - prev_pos.x;
-	double dy = pointer_state.origin.y - prev_pos.y;
-	if (view != pointer_state.tiling.init_view) {
-		changed_tiling = true;
-		valid = false;
-		if (view->type != C_WORKSPACE) {
-			if (get_swayc_in_direction(pointer_state.tiling.init_view, MOVE_LEFT) == view) {
-				pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + 20;
-				pointer_state.lock.temp_left = true;
-			} else if (get_swayc_in_direction(pointer_state.tiling.init_view, MOVE_RIGHT) == view) {
-				pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + pointer_state.tiling.init_view->width - 20;
-				pointer_state.lock.temp_right = true;
-			} else if (get_swayc_in_direction(pointer_state.tiling.init_view, MOVE_UP) == view) {
-				pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + 20;
-				pointer_state.lock.temp_up = true;
-			} else if (get_swayc_in_direction(pointer_state.tiling.init_view, MOVE_DOWN) == view) {
-				pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + pointer_state.tiling.init_view->height - 20;
-				pointer_state.lock.temp_down = true;
-			}
-		}
-	}
-
-	if ((dx < 0 || pointer_state.origin.x < pointer_state.tiling.lock_pos.x) && pointer_state.lock.temp_left) {
-		changed_tiling = true;
-		valid = false;
-	} else if (dx > 0 && pointer_state.lock.temp_left) {
-		pointer_state.lock.temp_left = false;
-		pointer_state.tiling.lock_pos.x = 0;
-	}
-
-	if ((dx > 0 || pointer_state.origin.x > pointer_state.tiling.lock_pos.x) && pointer_state.lock.temp_right) {
-		changed_tiling = true;
-		valid = false;
-	} else if (dx < 0 && pointer_state.lock.temp_right) {
-		pointer_state.lock.temp_right = false;
-		pointer_state.tiling.lock_pos.x = 0;
-	}
-
-	if ((dy < 0 || pointer_state.origin.y < pointer_state.tiling.lock_pos.y) && pointer_state.lock.temp_up) {
-		changed_tiling = true;
-		valid = false;
-	} else if (dy > 0 && pointer_state.lock.temp_up) {
-		pointer_state.lock.temp_up = false;
-		pointer_state.tiling.lock_pos.y = 0;
-	}
-
-	if ((dy > 0 || pointer_state.origin.y > pointer_state.tiling.lock_pos.y) && pointer_state.lock.temp_down) {
-		changed_tiling = true;
-		valid = false;
-	} else if (dy < 0 && pointer_state.lock.temp_down) {
-		pointer_state.lock.temp_down = false;
-		pointer_state.tiling.lock_pos.y = 0;
-	}
-
-	if (!view->is_floating && valid) {
-		// Handle layout resizes -- Find the biggest parent container then apply resizes to that
-		// and its bordering siblings
-		swayc_t *parent = view;
-		if (!pointer_state.lock.bottom) {
-			while (parent->type != C_WORKSPACE) {
-				// TODO: Absolute value is a bad hack here to compensate for rounding. Find a better
-				// way of doing this.
-				if (fabs(parent->parent->y + parent->parent->height - (view->y + view->height)) <= 1) {
-					parent = parent->parent;
-				} else {
-					break;
-				}
-			}
-			if (parent->parent->children->length > 1 && parent->parent->layout == L_VERT) {
-				swayc_t *sibling = get_swayc_in_direction(parent, MOVE_DOWN);
-				if (sibling) {
-					if ((parent->height > min_sane_h || dy > 0) && (sibling->height > min_sane_h || dy < 0)) {
-						recursive_resize(parent, dy, WLC_RESIZE_EDGE_BOTTOM);
-						recursive_resize(sibling, -1 * dy, WLC_RESIZE_EDGE_TOP);
-						changed_tiling = true;
-					} else {
-						if (parent->height < min_sane_h) {
-							//pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + 20;
-							pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + pointer_state.tiling.init_view->height - 20;
-							pointer_state.lock.temp_up = true;
-						} else if (sibling->height < min_sane_h) {
-							pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + pointer_state.tiling.init_view->height - 20;
-							pointer_state.lock.temp_down = true;
-						}
-					}
-				}
-			}
-		} else if (!pointer_state.lock.top) {
-			while (parent->type != C_WORKSPACE) {
-				if (fabs(parent->parent->y - view->y) <= 1) {
-					parent = parent->parent;
-				} else {
-					break;
-				}
-			}
-			if (parent->parent->children->length > 1 && parent->parent->layout == L_VERT) {
-				swayc_t *sibling = get_swayc_in_direction(parent, MOVE_UP);
-				if (sibling) {
-					if ((parent->height > min_sane_h || dy < 0) && (sibling->height > min_sane_h || dy > 0)) {
-						recursive_resize(parent, -1 * dy, WLC_RESIZE_EDGE_TOP);
-						recursive_resize(sibling, dy, WLC_RESIZE_EDGE_BOTTOM);
-						changed_tiling = true;
-					} else {
-						if (parent->height < min_sane_h) {
-							//pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + pointer_state.tiling.init_view->height - 20;
-							pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + 20;
-							pointer_state.lock.temp_down = true;
-						} else if (sibling->height < min_sane_h) {
-							pointer_state.tiling.lock_pos.y = pointer_state.tiling.init_view->y + 20;
-							pointer_state.lock.temp_up = true;
-						}
-					}
-				}
-			}
-		}
-
-		parent = view;
-		if (!pointer_state.lock.right) {
-			while (parent->type != C_WORKSPACE) {
-				if (fabs(parent->parent->x + parent->parent->width - (view->x + view->width)) <= 1) {
-					parent = parent->parent;
-				} else {
-					sway_log(L_DEBUG, "view: %f vs parent: %f", view->x + view->width, parent->parent->x + parent->parent->width);
-					break;
-				}
-			}
-			if (parent->parent->children->length > 1 && parent->parent->layout == L_HORIZ) {
-				swayc_t *sibling = get_swayc_in_direction(parent, MOVE_RIGHT);
-				if (sibling) {
-					if ((parent->width > min_sane_w || dx > 0) && (sibling->width > min_sane_w || dx < 0)) {
-						recursive_resize(parent, dx, WLC_RESIZE_EDGE_RIGHT);
-						recursive_resize(sibling, -1 * dx, WLC_RESIZE_EDGE_LEFT);
-						changed_tiling = true;
-					} else {
-						if (parent->width < min_sane_w) {
-							pointer_state.lock.temp_left = true;
-							pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + pointer_state.tiling.init_view->width - 20;
-						} else if (sibling->width < min_sane_w) {
-							pointer_state.lock.temp_right = true;
-							pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + pointer_state.tiling.init_view->width - 20;
-						}
-					}
-				}
-			}
-		} else if (!pointer_state.lock.left) {
-			while (parent->type != C_WORKSPACE) {
-				if (fabs(parent->parent->x - view->x) <= 1 && parent->parent) {
-					parent = parent->parent;
-				} else {
-					break;
-				}
-			}
-			if (parent->parent->children->length > 1 && parent->parent->layout == L_HORIZ) {
-				swayc_t *sibling = get_swayc_in_direction(parent, MOVE_LEFT);
-				if (sibling) {
-					if ((parent->width > min_sane_w || dx < 0) && (sibling->width > min_sane_w || dx > 0)) {
-						recursive_resize(parent, -1 * dx, WLC_RESIZE_EDGE_LEFT);
-						recursive_resize(sibling, dx, WLC_RESIZE_EDGE_RIGHT);
-						changed_tiling = true;
-					} else {
-						if (parent->width < min_sane_w) {
-							pointer_state.lock.temp_right = true;
-							pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + 20;
-						} else if (sibling->width < min_sane_w) {
-							pointer_state.lock.temp_left = true;
-							pointer_state.tiling.lock_pos.x = pointer_state.tiling.init_view->x + 20;
-						}
-					}
-				}
-			}
-		}
-		arrange_windows(swayc_active_workspace(), -1, -1);
-	}
-	return changed_tiling;
-}
-
-bool resize_floating(struct wlc_origin prev_pos) {
-	bool changed = false;
-	swayc_t *view = container_under_pointer();
-	uint32_t edge = 0;
-	int dx = pointer_state.origin.x - prev_pos.x;
-	int dy = pointer_state.origin.y - prev_pos.y;
-
-	// Move and resize the view based on the dx/dy and mouse position
-	int midway_x = view->x + view->width/2;
-	int midway_y = view->y + view->height/2;
-	if (dx < 0) {
-		if (!pointer_state.lock.right) {
-			if (view->width > min_sane_w) {
-				changed = true;
-				view->width += dx;
-				edge += WLC_RESIZE_EDGE_RIGHT;
-			}
-		} else if (pointer_state.origin.x < midway_x && !pointer_state.lock.left) {
-			changed = true;
-			view->x += dx;
-			view->width -= dx;
-			edge += WLC_RESIZE_EDGE_LEFT;
-		}
-	} else if (dx > 0) {
-		if (pointer_state.origin.x > midway_x && !pointer_state.lock.right) {
-			changed = true;
-			view->width += dx;
-			edge += WLC_RESIZE_EDGE_RIGHT;
-		} else if (!pointer_state.lock.left) {
-			if (view->width > min_sane_w) {
-				changed = true;
-				view->x += dx;
-				view->width -= dx;
-				edge += WLC_RESIZE_EDGE_LEFT;
-			}
-		}
-	}
-
-	if (dy < 0) {
-		if (!pointer_state.lock.bottom) {
-			if (view->height > min_sane_h) {
-				changed = true;
-				view->height += dy;
-				edge += WLC_RESIZE_EDGE_BOTTOM;
-			}
-		} else if (pointer_state.origin.y < midway_y && !pointer_state.lock.top) {
-			changed = true;
-			view->y += dy;
-			view->height -= dy;
-			edge += WLC_RESIZE_EDGE_TOP;
-		}
-	} else if (dy > 0) {
-		if (pointer_state.origin.y > midway_y && !pointer_state.lock.bottom) {
-			changed = true;
-			view->height += dy;
-			edge += WLC_RESIZE_EDGE_BOTTOM;
-		} else if (!pointer_state.lock.top) {
-			if (view->height > min_sane_h) {
-				changed = true;
-				view->y += dy;
-				view->height -= dy;
-				edge += WLC_RESIZE_EDGE_TOP;
-			}
-		}
-	}
-	if (changed) {
-		struct wlc_geometry geometry = {
-			.origin = {
-				.x = view->x,
-				.y = view->y
-			},
-			.size = {
-				.w = view->width,
-				.h = view->height
-			}
-		};
-		wlc_view_set_geometry(view->handle, edge, &geometry);
-	}
-	return changed;
-}
-
 bool resize_tiled(int amount, bool use_width) {
 	swayc_t *parent = get_focused_view(swayc_active_workspace());
 	swayc_t *focused = parent;