Rework gaps code to be simpler and correct

Instead of tracking gaps per child apply gaps in two logical places:

1. In tiled containers use the layout code to add the gaps between
windows. This is much simpler and guarantees that the sizing of children
is correct.
2. In the workspace itself apply all the gaps around the edge. Here
we're in the correct position to size inner and outer gaps correctly and
decide on smart gaps in a single location.

Fixes #4296

include/sway/tree/container.h

@@ -116,14 +116,6 @@ struct sway_container {
 	bool border_left;
 	bool border_right;
 
-	// The gaps currently applied to the container.
-	struct {
-		int top;
-		int right;
-		int bottom;
-		int left;
-	} current_gaps;
-
 	struct sway_workspace *workspace; // NULL when hidden in the scratchpad
 	struct sway_container *parent;    // NULL if container in root of workspace
 	list_t *children;                 // struct sway_container
@@ -296,10 +288,6 @@ struct sway_output *container_get_effective_output(struct sway_container *con);
 
 void container_discover_outputs(struct sway_container *con);
 
-void container_remove_gaps(struct sway_container *container);
-
-void container_add_gaps(struct sway_container *container);
-
 enum sway_container_layout container_parent_layout(struct sway_container *con);
 
 enum sway_container_layout container_current_parent_layout(

sway/commands/move.c

@@ -235,7 +235,6 @@ static void container_move_to_container(struct sway_container *container,
 	struct sway_workspace *old_workspace = container->workspace;
 
 	container_detach(container);
-	container_remove_gaps(container);
 	container->width = container->height = 0;
 	container->width_fraction = container->height_fraction = 0;
 

sway/tree/arrange.c

@@ -52,23 +52,39 @@ static void apply_horiz_layout(list_t *children, struct wlr_box *parent) {
 		child->width_fraction /= total_width_fraction;
 	}
 
+	// Calculate gap size
+	double inner_gap = 0;
+	struct sway_container *child = children->items[0];
+	struct sway_workspace *ws = child->workspace;
+	if (ws) {
+		inner_gap = ws->gaps_inner;
+	}
+	// Descendants of tabbed/stacked containers don't have gaps
+	struct sway_container *temp = child;
+	while (temp) {
+		enum sway_container_layout layout = container_parent_layout(temp);
+		if (layout == L_TABBED || layout == L_STACKED) {
+			inner_gap = 0;
+		}
+		temp = temp->parent;
+	}
+	double child_total_width = parent->width - inner_gap * (children->length - 1);
+
 	// Resize windows
 	sway_log(SWAY_DEBUG, "Arranging %p horizontally", parent);
 	double child_x = parent->x;
 	for (int i = 0; i < children->length; ++i) {
 		struct sway_container *child = children->items[i];
-		container_remove_gaps(child);
 		child->x = child_x;
 		child->y = parent->y;
-		child->width = floor(child->width_fraction * parent->width);
+		child->width = floor(child->width_fraction * child_total_width);
 		child->height = parent->height;
-		child_x += child->width;
+		child_x += child->width + inner_gap;
 
 		// Make last child use remaining width of parent
 		if (i == children->length - 1) {
 			child->width = parent->x + parent->width - child->x;
 		}
-		container_add_gaps(child);
 	}
 }
 
@@ -111,23 +127,39 @@ static void apply_vert_layout(list_t *children, struct wlr_box *parent) {
 		child->height_fraction /= total_height_fraction;
 	}
 
-	// Resize
+	// Calculate gap size
+	double inner_gap = 0;
+	struct sway_container *child = children->items[0];
+	struct sway_workspace *ws = child->workspace;
+	if (ws) {
+		inner_gap = ws->gaps_inner;
+	}
+	// Descendants of tabbed/stacked containers don't have gaps
+	struct sway_container *temp = child;
+	while (temp) {
+		enum sway_container_layout layout = container_parent_layout(temp);
+		if (layout == L_TABBED || layout == L_STACKED) {
+			inner_gap = 0;
+		}
+		temp = temp->parent;
+	}
+	double child_total_height = parent->height - inner_gap * (children->length - 1);
+
+	// Resize windows
 	sway_log(SWAY_DEBUG, "Arranging %p vertically", parent);
 	double child_y = parent->y;
 	for (int i = 0; i < children->length; ++i) {
 		struct sway_container *child = children->items[i];
-		container_remove_gaps(child);
 		child->x = parent->x;
 		child->y = child_y;
 		child->width = parent->width;
-		child->height = floor(child->height_fraction * parent->height);
+		child->height = floor(child->height_fraction * child_total_height);
-		child_y += child->height;
+		child_y += child->height + inner_gap;
 
 		// Make last child use remaining height of parent
 		if (i == children->length - 1) {
 			child->height = parent->y + parent->height - child->y;
 		}
-		container_add_gaps(child);
 	}
 }
 
@@ -138,12 +170,10 @@ static void apply_tabbed_layout(list_t *children, struct wlr_box *parent) {
 	for (int i = 0; i < children->length; ++i) {
 		struct sway_container *child = children->items[i];
 		int parent_offset = child->view ? 0 : container_titlebar_height();
-		container_remove_gaps(child);
 		child->x = parent->x;
 		child->y = parent->y + parent_offset;
 		child->width = parent->width;
 		child->height = parent->height - parent_offset;
-		container_add_gaps(child);
 	}
 }
 
@@ -155,12 +185,10 @@ static void apply_stacked_layout(list_t *children, struct wlr_box *parent) {
 		struct sway_container *child = children->items[i];
 		int parent_offset = child->view ?  0 :
 			container_titlebar_height() * children->length;
-		container_remove_gaps(child);
 		child->x = parent->x;
 		child->y = parent->y + parent_offset;
 		child->width = parent->width;
 		child->height = parent->height - parent_offset;
-		container_add_gaps(child);
 	}
 }
 
@@ -226,7 +254,6 @@ void arrange_workspace(struct sway_workspace *workspace) {
 	struct wlr_box *area = &output->usable_area;
 	sway_log(SWAY_DEBUG, "Usable area for ws: %dx%d@%d,%d",
 			area->width, area->height, area->x, area->y);
-	workspace_remove_gaps(workspace);
 
 	bool first_arrange = workspace->width == 0 && workspace->height == 0;
 	double prev_x = workspace->x;

sway/tree/container.c

@@ -1173,72 +1173,6 @@ void container_discover_outputs(struct sway_container *con) {
 	}
 }
 
-void container_remove_gaps(struct sway_container *c) {
-	if (c->current_gaps.top == 0 && c->current_gaps.right == 0 &&
-			c->current_gaps.bottom == 0 && c->current_gaps.left == 0) {
-		return;
-	}
-
-	c->width += c->current_gaps.left + c->current_gaps.right;
-	c->height += c->current_gaps.top + c->current_gaps.bottom;
-	c->x -= c->current_gaps.left;
-	c->y -= c->current_gaps.top;
-
-	c->current_gaps.top = 0;
-	c->current_gaps.right = 0;
-	c->current_gaps.bottom = 0;
-	c->current_gaps.left = 0;
-}
-
-void container_add_gaps(struct sway_container *c) {
-	if (c->current_gaps.top > 0 || c->current_gaps.right > 0 ||
-			c->current_gaps.bottom > 0 || c->current_gaps.left > 0) {
-		return;
-	}
-	// Fullscreen global scratchpad containers cannot have gaps
-	struct sway_workspace *ws = c->workspace;
-	if (!ws) {
-		return;
-	}
-	// Linear containers don't have gaps because it'd create double gaps
-	if (!c->view && c->layout != L_TABBED && c->layout != L_STACKED) {
-		return;
-	}
-	// Descendants of tabbed/stacked containers re-use the gaps of the container
-	struct sway_container *temp = c;
-	while (temp) {
-		enum sway_container_layout layout = container_parent_layout(temp);
-		if (layout == L_TABBED || layout == L_STACKED) {
-			return;
-		}
-		temp = temp->parent;
-	}
-	// If smart gaps is on, don't add gaps if there is only one view visible
-	if (config->smart_gaps) {
-		struct sway_view *view = c->view;
-		if (!view) {
-			struct sway_seat *seat =
-				input_manager_get_default_seat();
-			struct sway_container *focus =
-				seat_get_focus_inactive_view(seat, &c->node);
-			view = focus ? focus->view : NULL;
-		}
-		if (view && view_is_only_visible(view)) {
-			return;
-		}
-	}
-
-	c->current_gaps.top = c->y == ws->y ? ws->gaps_inner : 0;
-	c->current_gaps.right = ws->gaps_inner;
-	c->current_gaps.bottom = ws->gaps_inner;
-	c->current_gaps.left = c->x == ws->x ? ws->gaps_inner : 0;
-
-	c->x += c->current_gaps.left;
-	c->y += c->current_gaps.top;
-	c->width -= c->current_gaps.left + c->current_gaps.right;
-	c->height -= c->current_gaps.top + c->current_gaps.bottom;
-}
-
 enum sway_container_layout container_parent_layout(struct sway_container *con) {
 	if (con->parent) {
 		return con->parent->layout;
@@ -1421,7 +1355,6 @@ struct sway_container *container_split(struct sway_container *child,
 	cont->height_fraction = child->height_fraction;
 	cont->x = child->x;
 	cont->y = child->y;
-	cont->current_gaps = child->current_gaps;
 	cont->layout = layout;
 
 	container_replace(child, cont);

sway/tree/view.c

@@ -183,14 +183,6 @@ bool view_is_only_visible(struct sway_view *view) {
 }
 
 static bool gaps_to_edge(struct sway_view *view) {
-	struct sway_container *con = view->container;
-	while (con) {
-		if (con->current_gaps.top > 0 || con->current_gaps.right > 0 ||
-				con->current_gaps.bottom > 0 || con->current_gaps.left > 0) {
-			return true;
-		}
-		con = con->parent;
-	}
 	struct side_gaps gaps = view->container->workspace->current_gaps;
 	return gaps.top > 0 || gaps.right > 0 || gaps.bottom > 0 || gaps.left > 0;
 }
@@ -232,14 +224,14 @@ void view_autoconfigure(struct sway_view *view) {
 
 		if (config->hide_edge_borders == E_BOTH
 				|| config->hide_edge_borders == E_VERTICAL || hide_smart) {
-			con->border_left = con->x - con->current_gaps.left != ws->x;
+			con->border_left = con->x != ws->x;
-			int right_x = con->x + con->width + con->current_gaps.right;
+			int right_x = con->x + con->width;
 			con->border_right = right_x != ws->x + ws->width;
 		}
 		if (config->hide_edge_borders == E_BOTH
 				|| config->hide_edge_borders == E_HORIZONTAL || hide_smart) {
-			con->border_top = con->y - con->current_gaps.top != ws->y;
+			con->border_top = con->y != ws->y;
-			int bottom_y = con->y + con->height + con->current_gaps.bottom;
+			int bottom_y = con->y + con->height;
 			con->border_bottom = bottom_y != ws->y + ws->height;
 		}
 

sway/tree/workspace.c

@@ -700,28 +700,7 @@ void workspace_insert_tiling(struct sway_workspace *workspace,
 	node_set_dirty(&con->node);
 }
 
-void workspace_remove_gaps(struct sway_workspace *ws) {
-	if (ws->current_gaps.top == 0 && ws->current_gaps.right == 0 &&
-			ws->current_gaps.bottom == 0 && ws->current_gaps.left == 0) {
-		return;
-	}
-
-	ws->width += ws->current_gaps.left + ws->current_gaps.right;
-	ws->height += ws->current_gaps.top + ws->current_gaps.bottom;
-	ws->x -= ws->current_gaps.left;
-	ws->y -= ws->current_gaps.top;
-
-	ws->current_gaps.top = 0;
-	ws->current_gaps.right = 0;
-	ws->current_gaps.bottom = 0;
-	ws->current_gaps.left = 0;
-}
-
 void workspace_add_gaps(struct sway_workspace *ws) {
-	if (ws->current_gaps.top > 0 || ws->current_gaps.right > 0 ||
-			ws->current_gaps.bottom > 0 || ws->current_gaps.left > 0) {
-		return;
-	}
 	if (config->smart_gaps) {
 		struct sway_seat *seat = input_manager_get_default_seat();
 		struct sway_container *focus =
@@ -730,20 +709,19 @@ void workspace_add_gaps(struct sway_workspace *ws) {
 			focus = seat_get_focus_inactive_view(seat, &focus->node);
 		}
 		if (focus && focus->view && view_is_only_visible(focus->view)) {
+			ws->current_gaps.top = 0;
+			ws->current_gaps.right = 0;
+			ws->current_gaps.bottom = 0;
+			ws->current_gaps.left = 0;
 			return;
 		}
 	}
 
 	ws->current_gaps = ws->gaps_outer;
-	if (ws->layout == L_TABBED || ws->layout == L_STACKED) {
-		// We have to add inner gaps for this, because children of tabbed and
-		// stacked containers don't apply their own gaps - they assume the
-		// tabbed/stacked container is using gaps.
 	ws->current_gaps.top += ws->gaps_inner;
 	ws->current_gaps.right += ws->gaps_inner;
 	ws->current_gaps.bottom += ws->gaps_inner;
 	ws->current_gaps.left += ws->gaps_inner;
-	}
 
 	ws->x += ws->current_gaps.left;
 	ws->y += ws->current_gaps.top;