Implement tiling drag

Hold floating_modifier and drag a tiling view to a new location.

sway/input/cursor.c

@@ -228,6 +228,141 @@ static void handle_move_floating_motion(struct sway_seat *seat,
 	desktop_damage_whole_container(con);
 }
 
+static void resize_box(struct wlr_box *box, enum wlr_edges edge,
+		size_t thickness) {
+	switch (edge) {
+	case WLR_EDGE_TOP:
+		box->height = thickness;
+		break;
+	case WLR_EDGE_LEFT:
+		box->width = thickness;
+		break;
+	case WLR_EDGE_RIGHT:
+		box->x = box->x + box->width - thickness;
+		box->width = thickness;
+		break;
+	case WLR_EDGE_BOTTOM:
+		box->y = box->y + box->height - thickness;
+		box->height = thickness;
+		break;
+	case WLR_EDGE_NONE:
+		box->x += thickness;
+		box->y += thickness;
+		box->width -= thickness * 2;
+		box->height -= thickness * 2;
+		break;
+	}
+}
+
+static void handle_move_tiling_motion(struct sway_seat *seat,
+		struct sway_cursor *cursor) {
+	struct wlr_surface *surface = NULL;
+	double sx, sy;
+	struct sway_node *node = node_at_coords(seat,
+			cursor->cursor->x, cursor->cursor->y, &surface, &sx, &sy);
+	// Damage the old location
+	desktop_damage_box(&seat->op_drop_box);
+
+	if (!node) {
+		// Eg. hovered over a layer surface such as swaybar
+		seat->op_target_node = NULL;
+		seat->op_target_edge = WLR_EDGE_NONE;
+		return;
+	}
+
+	if (node->type == N_WORKSPACE) {
+		// Emtpy workspace
+		seat->op_target_node = node;
+		seat->op_target_edge = WLR_EDGE_NONE;
+		workspace_get_box(node->sway_workspace, &seat->op_drop_box);
+		desktop_damage_box(&seat->op_drop_box);
+		return;
+	}
+
+	// Deny moving within own workspace if this is the only child
+	struct sway_container *con = node->sway_container;
+	if (workspace_num_tiling_views(seat->op_container->workspace) == 1 &&
+			con->workspace == seat->op_container->workspace) {
+		seat->op_target_node = NULL;
+		seat->op_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.
+	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);
+		if (layout == L_HORIZ || layout == L_TABBED) {
+			if (cursor->cursor->y < parent.y + 30) {
+				edge = WLR_EDGE_TOP;
+			} else if (cursor->cursor->y > parent.y + parent.height - 30) {
+				edge = WLR_EDGE_BOTTOM;
+			}
+		} else if (layout == L_VERT || layout == L_STACKED) {
+			if (cursor->cursor->x < parent.x + 30) {
+				edge = WLR_EDGE_LEFT;
+			} else if (cursor->cursor->x > parent.x + parent.width - 30) {
+				edge = WLR_EDGE_RIGHT;
+			}
+		}
+		if (edge) {
+			seat->op_target_node = node_get_parent(&con->node);
+			seat->op_target_edge = edge;
+			node_get_box(seat->op_target_node, &seat->op_drop_box);
+			resize_box(&seat->op_drop_box, edge, 30);
+			desktop_damage_box(&seat->op_drop_box);
+			return;
+		}
+		con = con->parent;
+	}
+
+	// Use the hovered view - but we must be over the actual surface
+	con = node->sway_container;
+	if (!con->view->surface || node == &seat->op_container->node) {
+		seat->op_target_node = NULL;
+		seat->op_target_edge = WLR_EDGE_NONE;
+		return;
+	}
+
+	// Find the closest edge
+	size_t thickness = fmin(con->view->width, con->view->height) * 0.3;
+	size_t closest_dist = INT_MAX;
+	size_t dist;
+	seat->op_target_edge = WLR_EDGE_NONE;
+	if ((dist = cursor->cursor->y - con->y) < closest_dist) {
+		closest_dist = dist;
+		seat->op_target_edge = WLR_EDGE_TOP;
+	}
+	if ((dist = cursor->cursor->x - con->x) < closest_dist) {
+		closest_dist = dist;
+		seat->op_target_edge = WLR_EDGE_LEFT;
+	}
+	if ((dist = con->x + con->width - cursor->cursor->x) < closest_dist) {
+		closest_dist = dist;
+		seat->op_target_edge = WLR_EDGE_RIGHT;
+	}
+	if ((dist = con->y + con->height - cursor->cursor->y) < closest_dist) {
+		closest_dist = dist;
+		seat->op_target_edge = WLR_EDGE_BOTTOM;
+	}
+
+	if (closest_dist > thickness) {
+		seat->op_target_edge = WLR_EDGE_NONE;
+	}
+
+	seat->op_target_node = node;
+	seat->op_drop_box.x = con->view->x;
+	seat->op_drop_box.y = con->view->y;
+	seat->op_drop_box.width = con->view->width;
+	seat->op_drop_box.height = con->view->height;
+	resize_box(&seat->op_drop_box, seat->op_target_edge, thickness);
+	desktop_damage_box(&seat->op_drop_box);
+}
+
 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
@@ -405,6 +540,9 @@ void cursor_send_pointer_motion(struct sway_cursor *cursor, uint32_t time_msec,
 		case OP_MOVE_FLOATING:
 			handle_move_floating_motion(seat, cursor);
 			break;
+		case OP_MOVE_TILING:
+			handle_move_tiling_motion(seat, cursor);
+			break;
 		case OP_RESIZE_FLOATING:
 			handle_resize_floating_motion(seat, cursor);
 			break;
@@ -751,6 +889,14 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
 		}
 	}
 
+	// Handle moving a tiling container
+	if (config->tiling_drag && mod_pressed && !is_floating_or_child &&
+			!cont->is_fullscreen) {
+		seat_pointer_notify_button(seat, time_msec, button, state);
+		seat_begin_move_tiling(seat, cont, button);
+		return;
+	}
+
 	// Handle mousedown on a container surface
 	if (surface && cont && state == WLR_BUTTON_PRESSED) {
 		seat_set_focus_container(seat, cont);

sway/input/seat.c

@@ -975,6 +975,16 @@ void seat_begin_move_floating(struct sway_seat *seat,
 	cursor_set_image(seat->cursor, "grab", NULL);
 }
 
+void seat_begin_move_tiling(struct sway_seat *seat,
+		struct sway_container *con, uint32_t button) {
+	seat->operation = OP_MOVE_TILING;
+	seat->op_container = con;
+	seat->op_button = button;
+	seat->op_target_node = NULL;
+	seat->op_target_edge = 0;
+	cursor_set_image(seat->cursor, "grab", NULL);
+}
+
 void seat_begin_resize_floating(struct sway_seat *seat,
 		struct sway_container *con, uint32_t button, enum wlr_edges edge) {
 	if (!seat->cursor) {
@@ -1015,6 +1025,68 @@ void seat_begin_resize_tiling(struct sway_seat *seat,
 	seat->op_ref_height = con->height;
 }
 
+static bool is_parallel(enum sway_container_layout layout,
+		enum wlr_edges edge) {
+	bool layout_is_horiz = layout == L_HORIZ || layout == L_TABBED;
+	bool edge_is_horiz = edge == WLR_EDGE_LEFT || edge == WLR_EDGE_RIGHT;
+	return layout_is_horiz == edge_is_horiz;
+}
+
+static void seat_end_move_tiling(struct sway_seat *seat) {
+	struct sway_container *con = seat->op_container;
+	struct sway_container *old_parent = con->parent;
+	struct sway_workspace *old_ws = con->workspace;
+	struct sway_node *target_node = seat->op_target_node;
+	struct sway_workspace *new_ws = target_node->type == N_WORKSPACE ?
+		target_node->sway_workspace : target_node->sway_container->workspace;
+	enum wlr_edges edge = seat->op_target_edge;
+	int after = edge != WLR_EDGE_TOP && edge != WLR_EDGE_LEFT;
+
+	container_detach(con);
+	if (old_parent) {
+		container_reap_empty(old_parent);
+	}
+
+	// Moving container into empty workspace
+	if (target_node->type == N_WORKSPACE && edge == WLR_EDGE_NONE) {
+		workspace_add_tiling(new_ws, con);
+
+	// Moving container before/after another
+	} else if (target_node->type == N_CONTAINER) {
+		struct sway_container *target = target_node->sway_container;
+		enum sway_container_layout layout = container_parent_layout(target);
+		if (edge && !is_parallel(layout, edge)) {
+			enum sway_container_layout new_layout = edge == WLR_EDGE_TOP ||
+				edge == WLR_EDGE_BOTTOM ? L_VERT : L_HORIZ;
+			container_split(target, new_layout);
+		}
+		container_add_sibling(target, con, after);
+
+	// Target is a workspace which requires splitting
+	} else {
+		enum sway_container_layout new_layout = edge == WLR_EDGE_TOP ||
+			edge == WLR_EDGE_BOTTOM ? L_VERT : L_HORIZ;
+		workspace_split(new_ws, new_layout);
+		workspace_insert_tiling(new_ws, con, after);
+	}
+
+	// This is a bit dirty, but we'll set the dimensions to that of a sibling.
+	// I don't think there's any other way to make it consistent without
+	// changing how we auto-size containers.
+	list_t *siblings = container_get_siblings(con);
+	if (siblings->length > 1) {
+		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;
+	}
+
+	arrange_workspace(old_ws);
+	if (new_ws != old_ws) {
+		arrange_workspace(new_ws);
+	}
+}
+
 void seat_end_mouse_operation(struct sway_seat *seat) {
 	enum sway_seat_operation operation = seat->operation;
 	if (seat->operation == OP_MOVE_FLOATING) {
@@ -1022,6 +1094,8 @@ void seat_end_mouse_operation(struct sway_seat *seat) {
 		// output again.
 		struct sway_container *con = seat->op_container;
 		container_floating_move_to(con, con->x, con->y);
+	} else if (seat->operation == OP_MOVE_TILING && seat->op_target_node) {
+		seat_end_move_tiling(seat);
 	}
 	seat->operation = OP_NONE;
 	seat->op_container = NULL;