Implement tabbed layout

include/sway/tree/container.h

@@ -162,7 +162,7 @@ struct sway_container *container_parent(struct sway_container *container,
  * is a view and the view contains a surface at those coordinates.
  */
 struct sway_container *container_at(struct sway_container *container,
-		double lx, double ly, struct wlr_surface **surface,
+		double ox, double oy, struct wlr_surface **surface,
 		double *sx, double *sy);
 
 /**

sway/commands/layout.c

@@ -39,6 +39,8 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
 			parent->layout = L_HORIZ;
 		} else if (strcasecmp(argv[0], "splitv") == 0) {
 			parent->layout = L_VERT;
+		} else if (strcasecmp(argv[0], "tabbed") == 0) {
+			parent->layout = L_TABBED;
 		} else if (strcasecmp(argv[0], "toggle") == 0 && argc == 2 && strcasecmp(argv[1], "split") == 0) {
 			if (parent->layout == L_HORIZ) {
 				parent->layout = L_VERT;

sway/desktop/output.c

@@ -599,12 +599,198 @@ static void render_container_simple(struct sway_output *output,
 	}
 }
 
+static void render_tab(struct sway_output *output, pixman_region32_t *damage,
+		struct sway_container *parent, int child_index,
+		struct border_colors *colors, struct wlr_texture *title_texture) {
+	float output_scale = output->wlr_output->scale;
+	float color[4];
+	struct wlr_box box;
+	bool is_first = (child_index == 0);
+	bool is_last = (child_index == parent->children->length - 1);
+
+	int tab_width = parent->width / parent->children->length;
+	int x = parent->x + tab_width * child_index;
+	// Make last tab use the remaining width of the parent
+	if (is_last) {
+		tab_width = parent->width - tab_width * child_index;
+	}
+
+	// Single pixel bar above title
+	memcpy(&color, colors->border, sizeof(float) * 4);
+	box.x = x;
+	box.y = parent->y;
+	box.width = tab_width;
+	box.height = 1;
+	scale_box(&box, output_scale);
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Single pixel bar below title
+	memcpy(&color, colors->border, sizeof(float) * 4);
+	box.x = x + config->border_thickness * is_first;
+	box.y = parent->y + config->border_thickness * 2 + config->font_height - 1;
+	box.width = tab_width - config->border_thickness * is_first
+		- config->border_thickness * is_last;
+	box.height = 1;
+	scale_box(&box, output_scale);
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Title text
+	size_t title_width = 0;
+	if (title_texture) {
+		struct wlr_box texture_box;
+		wlr_texture_get_size(title_texture,
+			&texture_box.width, &texture_box.height);
+		texture_box.x = (x + config->border_thickness) * output_scale;
+		texture_box.y = (parent->y + config->border_thickness) * output_scale;
+
+		float matrix[9];
+		wlr_matrix_project_box(matrix, &texture_box,
+			WL_OUTPUT_TRANSFORM_NORMAL,
+			0.0, output->wlr_output->transform_matrix);
+
+		int available = (tab_width - config->border_thickness * 2)
+			* output_scale;
+		if (texture_box.width > available) {
+			texture_box.width = available;
+		}
+		render_texture(output->wlr_output, damage, title_texture,
+			&texture_box, matrix, 1.0);
+		title_width = texture_box.width;
+	}
+
+	// Title background - above the text
+	memcpy(&color, colors->background, sizeof(float) * 4);
+	box.x = x + config->border_thickness;
+	box.y = parent->y + 1;
+	box.width = tab_width - config->border_thickness * 2;
+	box.height = config->border_thickness - 1;
+	scale_box(&box, output_scale);
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Title background - below the text
+	box.y = (parent->y + config->border_thickness + config->font_height)
+		* output_scale;
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Title background - left border
+	box.x = x;
+	box.y = parent->y + 1;
+	box.width = config->border_thickness;
+	box.height = config->border_thickness * 2
+		+ config->font_height - 1 - !is_first;
+	scale_box(&box, output_scale);
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Title background - right border
+	box.x = x + tab_width - config->border_thickness;
+	box.y = parent->y + 1;
+	box.width = config->border_thickness;
+	box.height = config->border_thickness * 2
+		+ config->font_height - 1 - !is_last;
+	scale_box(&box, output_scale);
+	render_rect(output->wlr_output, damage, &box, color);
+
+	// Title background - right of text
+	box.x = (x + config->border_thickness) * output_scale + title_width;
+	box.y = (parent->y + config->border_thickness) * output_scale;
+	box.width = (tab_width - config->border_thickness * 2) * output_scale
+		- title_width;
+	box.height = config->font_height * output_scale;
+	render_rect(output->wlr_output, damage, &box, color);
+}
+
+static void render_tab_content(struct sway_output *output,
+		pixman_region32_t *damage, struct sway_container *con,
+		struct border_colors *colors) {
+	struct sway_view *view = con->sway_view;
+	render_view(view, output, damage);
+
+	struct wlr_box box;
+	float output_scale = output->wlr_output->scale;
+	float color[4];
+
+	if (view->border_left) {
+		memcpy(&color, colors->child_border, sizeof(float) * 4);
+		color[3] *= con->alpha;
+		box.x = con->x;
+		box.y = con->y + config->border_thickness * 2 + config->font_height;
+		box.width = view->border_thickness;
+		box.height = view->height;
+		scale_box(&box, output_scale);
+		render_rect(output->wlr_output, damage, &box, color);
+	}
+
+	if (view->border_right) {
+		memcpy(&color, colors->child_border, sizeof(float) * 4);
+		color[3] *= con->alpha;
+		box.x = view->x + view->width;
+		box.y = con->y + config->border_thickness * 2 + config->font_height;
+		box.width = view->border_thickness;
+		box.height = view->height;
+		scale_box(&box, output_scale);
+		render_rect(output->wlr_output, damage, &box, color);
+	}
+
+	if (view->border_bottom) {
+		memcpy(&color, colors->child_border, sizeof(float) * 4);
+		color[3] *= con->alpha;
+		box.x = con->x;
+		box.y = view->y + view->height;
+		box.width = con->width;
+		box.height = view->border_thickness;
+		scale_box(&box, output_scale);
+		render_rect(output->wlr_output, damage, &box, color);
+	}
+}
+
 /**
  * Render a container's children using the L_TABBED layout.
  */
 static void render_container_tabbed(struct sway_output *output,
-		pixman_region32_t *damage, struct sway_container *con) {
-	// TODO
+		pixman_region32_t *damage, struct sway_container *con,
+		bool parent_focused) {
+	if (!con->children->length) {
+		return;
+	}
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+	struct sway_container *focus = seat_get_focus(seat);
+	struct sway_container *current = seat_get_focus_inactive(seat, con);
+	while (current->parent != con) {
+		current = current->parent;
+	}
+	struct border_colors *current_colors = NULL;
+
+	// Render tabs
+	for (int i = 0; i < con->children->length; ++i) {
+		struct sway_container *child = con->children->items[i];
+		struct border_colors *colors;
+		struct wlr_texture *title_texture;
+
+		if (focus == child || parent_focused) {
+			colors = &config->border_colors.focused;
+			title_texture = child->title_focused;
+		} else if (child == current) {
+			colors = &config->border_colors.focused_inactive;
+			title_texture = child->title_focused_inactive;
+		} else {
+			colors = &config->border_colors.unfocused;
+			title_texture = child->title_unfocused;
+		}
+
+		render_tab(output, damage, con, i, colors, title_texture);
+
+		if (child == current) {
+			current_colors = colors;
+		}
+	}
+
+	// Render surface and left/right/bottom borders
+	if (current->type == C_VIEW) {
+		render_tab_content(output, damage, current, current_colors);
+	} else {
+		render_container(output, damage, current,
+				parent_focused || current == focus);
+	}
 }
 
 /**
@@ -628,7 +814,7 @@ static void render_container(struct sway_output *output,
 		render_container_stacked(output, damage, con);
 		break;
 	case L_TABBED:
-		render_container_tabbed(output, damage, con);
+		render_container_tabbed(output, damage, con, parent_focused);
 		break;
 	case L_FLOATING:
 		// TODO

sway/input/cursor.c

@@ -108,7 +108,7 @@ static struct sway_container *container_at_coords(
 	}
 
 	struct sway_container *c;
-	if ((c = container_at(ws, x, y, surface, sx, sy))) {
+	if ((c = container_at(ws, ox, oy, surface, sx, sy))) {
 		return c;
 	}
 

sway/tree/arrange.c

@@ -86,6 +86,13 @@ static void apply_horiz_layout(struct sway_container *parent) {
 	if (!num_children) {
 		return;
 	}
+	size_t parent_height = parent->height;
+	size_t parent_offset = 0;
+	if (parent->parent->layout == L_TABBED) {
+		parent_offset = config->border_thickness * 2 + config->font_height;
+		parent_height -= parent_offset;
+	}
+
 	// Calculate total width of children
 	double total_width = 0;
 	for (size_t i = 0; i < num_children; ++i) {
@@ -111,9 +118,9 @@ static void apply_horiz_layout(struct sway_container *parent) {
 				"Calculating arrangement for %p:%d (will scale %f by %f)",
 				child, child->type, child->width, scale);
 		child->x = child_x;
-		child->y = parent->y;
+		child->y = parent->y + parent_offset;
 		child->width = floor(child->width * scale);
-		child->height = parent->height;
+		child->height = parent_height;
 		child_x += child->width;
 	}
 	// Make last child use remaining width of parent
@@ -125,24 +132,31 @@ static void apply_vert_layout(struct sway_container *parent) {
 	if (!num_children) {
 		return;
 	}
+	size_t parent_height = parent->height;
+	size_t parent_offset = 0;
+	if (parent->parent->layout == L_TABBED) {
+		parent_offset = config->border_thickness * 2 + config->font_height;
+		parent_height -= parent_offset;
+	}
+
 	// Calculate total height of children
 	double total_height = 0;
 	for (size_t i = 0; i < num_children; ++i) {
 		struct sway_container *child = parent->children->items[i];
 		if (child->height <= 0) {
 			if (num_children > 1) {
-				child->height = parent->height / (num_children - 1);
+				child->height = parent_height / (num_children - 1);
 			} else {
-				child->height = parent->height;
+				child->height = parent_height;
 			}
 		}
 		total_height += child->height;
 	}
-	double scale = parent->height / total_height;
+	double scale = parent_height / total_height;
 
 	// Resize
 	wlr_log(L_DEBUG, "Arranging %p vertically", parent);
-	double child_y = parent->y;
+	double child_y = parent->y + parent_offset;
 	struct sway_container *child;
 	for (size_t i = 0; i < num_children; ++i) {
 		child = parent->children->items[i];
@@ -156,7 +170,20 @@ static void apply_vert_layout(struct sway_container *parent) {
 		child_y += child->height;
 	}
 	// Make last child use remaining height of parent
-	child->height = parent->y + parent->height - child->y;
+	child->height = parent->y + parent_offset + parent_height - child->y;
+}
+
+static void apply_tabbed_layout(struct sway_container *parent) {
+	if (!parent->children->length) {
+		return;
+	}
+	for (int i = 0; i < parent->children->length; ++i) {
+		struct sway_container *child = parent->children->items[i];
+		child->x = parent->x;
+		child->y = parent->y;
+		child->width = parent->width;
+		child->height = parent->height;
+	}
 }
 
 void arrange_children_of(struct sway_container *parent) {
@@ -189,6 +216,9 @@ void arrange_children_of(struct sway_container *parent) {
 	case L_VERT:
 		apply_vert_layout(parent);
 		break;
+	case L_TABBED:
+		apply_tabbed_layout(parent);
+		break;
 	default:
 		wlr_log(L_DEBUG, "TODO: arrange layout type %d", parent->layout);
 		apply_horiz_layout(parent);

sway/tree/container.c

@@ -452,34 +452,15 @@ struct sway_container *container_parent(struct sway_container *container,
 	return container;
 }
 
-struct sway_container *container_at(struct sway_container *parent,
-		double lx, double ly,
+static struct sway_container *container_at_view(struct sway_container *swayc,
+		double ox, double oy,
 		struct wlr_surface **surface, double *sx, double *sy) {
-	list_t *queue = get_bfs_queue();
-	if (!queue) {
-		return NULL;
-	}
-
-	list_add(queue, parent);
-
-	struct sway_container *swayc = NULL;
-	while (queue->length) {
-		swayc = queue->items[0];
-		list_del(queue, 0);
-		if (swayc->type == C_VIEW) {
 	struct sway_view *sview = swayc->sway_view;
-			struct sway_container *soutput = container_parent(swayc, C_OUTPUT);
-			struct wlr_box *output_box =
-				wlr_output_layout_get_box(
-					root_container.sway_root->output_layout,
-					soutput->sway_output->wlr_output);
-			double ox = lx - output_box->x;
-			double oy = ly - output_box->y;
 	double view_sx = ox - sview->x;
 	double view_sy = oy - sview->y;
 
 	double _sx, _sy;
-			struct wlr_surface *_surface;
+	struct wlr_surface *_surface = NULL;
 	switch (sview->type) {
 	case SWAY_VIEW_XWAYLAND:
 		_surface = wlr_surface_surface_at(sview->surface,
@@ -510,21 +491,99 @@ struct sway_container *container_at(struct sway_container *parent,
 		*sx = _sx;
 		*sy = _sy;
 		*surface = _surface;
+	}
 	return swayc;
 }
-			// Check the view's decorations
-			struct wlr_box swayc_box = {
-				.x = swayc->x,
-				.y = swayc->y,
-				.width = swayc->width,
-				.height = swayc->height,
+
+/**
+ * container_at for a container with layout L_TABBED.
+ */
+static struct sway_container *container_at_tabbed(struct sway_container *parent,
+		double ox, double oy,
+		struct wlr_surface **surface, double *sx, double *sy) {
+	if (oy < parent->y || oy > parent->y + parent->height) {
+		return NULL;
+	}
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+
+	// Tab titles
+	int title_height = config->border_thickness * 2 + config->font_height;
+	if (oy < parent->y + title_height) {
+		int tab_width = parent->width / parent->children->length;
+		int child_index = (ox - parent->x) / tab_width;
+		if (child_index >= parent->children->length) {
+			child_index = parent->children->length - 1;
+		}
+		struct sway_container *child = parent->children->items[child_index];
+		return seat_get_focus_inactive(seat, child);
+	}
+
+	// Surfaces
+	struct sway_container *current = seat_get_focus_inactive(seat, parent);
+	while (current->parent != parent) {
+		current = current->parent;
+	}
+
+	return container_at(current, ox, oy, surface, sx, sy);
+}
+
+/**
+ * container_at for a container with layout L_STACKED.
+ */
+static struct sway_container *container_at_stacked(
+		struct sway_container *parent, double ox, double oy,
+		struct wlr_surface **surface, double *sx, double *sy) {
+	// TODO
+	return NULL;
+}
+
+/**
+ * container_at for a container with layout L_HORIZ or L_VERT.
+ */
+static struct sway_container *container_at_linear(struct sway_container *parent,
+		double ox, double oy,
+		struct wlr_surface **surface, double *sx, double *sy) {
+	for (int i = 0; i < parent->children->length; ++i) {
+		struct sway_container *child = parent->children->items[i];
+		struct wlr_box box = {
+			.x = child->x,
+			.y = child->y,
+			.width = child->width,
+			.height = child->height,
 		};
-			if (wlr_box_contains_point(&swayc_box, ox, oy)) {
-				return swayc;
+		if (wlr_box_contains_point(&box, ox, oy)) {
+			return container_at(child, ox, oy, surface, sx, sy);
 		}
-		} else {
-			list_cat(queue, swayc->children);
 	}
+	return NULL;
+}
+
+struct sway_container *container_at(struct sway_container *parent,
+		double ox, double oy,
+		struct wlr_surface **surface, double *sx, double *sy) {
+	if (!sway_assert(parent->type >= C_WORKSPACE,
+				"Expected workspace or deeper")) {
+		return NULL;
+	}
+	if (parent->type == C_VIEW) {
+		return container_at_view(parent, ox, oy, surface, sx, sy);
+	}
+	if (!parent->children->length) {
+		return NULL;
+	}
+
+	switch (parent->layout) {
+	case L_HORIZ:
+	case L_VERT:
+		return container_at_linear(parent, ox, oy, surface, sx, sy);
+	case L_TABBED:
+		return container_at_tabbed(parent, ox, oy, surface, sx, sy);
+	case L_STACKED:
+		return container_at_stacked(parent, ox, oy, surface, sx, sy);
+	case L_FLOATING:
+		return NULL; // TODO
+	case L_NONE:
+		return NULL;
 	}
 
 	return NULL;
@@ -699,18 +758,82 @@ void container_calculate_title_height(struct sway_container *container) {
 	container->title_height = height;
 }
 
+/**
+ * Calculate and return the length of the concatenated child titles.
+ * An example concatenated title is: V[Terminal, Firefox]
+ * If buffer is not NULL, also populate the buffer with the concatenated title.
+ */
+static size_t concatenate_child_titles(struct sway_container *parent,
+		char *buffer) {
+	size_t len = 2; // V[
+	if (buffer) {
+		switch (parent->layout) {
+		case L_VERT:
+			strcpy(buffer, "V[");
+			break;
+		case L_HORIZ:
+			strcpy(buffer, "H[");
+			break;
+		case L_TABBED:
+			strcpy(buffer, "T[");
+			break;
+		case L_STACKED:
+			strcpy(buffer, "S[");
+			break;
+		case L_FLOATING:
+			strcpy(buffer, "F[");
+			break;
+		case L_NONE:
+			strcpy(buffer, "?[");
+			break;
+		}
+	}
+
+	for (int i = 0; i < parent->children->length; ++i) {
+		if (i != 0) {
+			len += 2;
+			if (buffer) {
+				strcat(buffer, ", ");
+			}
+		}
+		struct sway_container *child = parent->children->items[i];
+		if (child->name) {
+			len += strlen(child->name);
+			if (buffer) {
+				strcat(buffer, child->name);
+			}
+		} else {
+			len += 6;
+			if (buffer) {
+				strcat(buffer, "(null)");
+			}
+		}
+	}
+
+	len += 1;
+	if (buffer) {
+		strcat(buffer, "]");
+	}
+	return len;
+}
+
 void container_notify_child_title_changed(struct sway_container *container) {
 	if (!container || container->type != C_CONTAINER) {
 		return;
 	}
-	if (container->layout != L_TABBED && container->layout != L_STACKED) {
-		return;
-	}
 	if (container->formatted_title) {
 		free(container->formatted_title);
 	}
-	// TODO: iterate children and concatenate their titles
-	container->formatted_title = strdup("");
+
+	size_t len = concatenate_child_titles(container, NULL);
+	char *buffer = calloc(len + 1, sizeof(char));
+	if (!sway_assert(buffer, "Unable to allocate title string")) {
+		return;
+	}
+	concatenate_child_titles(container, buffer);
+
+	container->name = buffer;
+	container->formatted_title = buffer;
 	container_calculate_title_height(container);
 	container_update_title_textures(container);
 	container_notify_child_title_changed(container->parent);

sway/tree/layout.c

@@ -149,6 +149,8 @@ struct sway_container *container_remove_child(struct sway_container *child) {
 		}
 	}
 	child->parent = NULL;
+	container_notify_child_title_changed(parent);
+
 	return parent;
 }
 
@@ -182,6 +184,8 @@ void container_move_to(struct sway_container *container,
 		container_sort_workspaces(new_parent);
 		seat_set_focus(seat, new_parent);
 	}
+	container_notify_child_title_changed(old_parent);
+	container_notify_child_title_changed(new_parent);
 	if (old_parent) {
 		arrange_children_of(old_parent);
 	}
@@ -234,9 +238,9 @@ static bool is_parallel(enum sway_container_layout layout,
 		enum movement_direction dir) {
 	switch (layout) {
 	case L_TABBED:
-	case L_STACKED:
 	case L_HORIZ:
 		return dir == MOVE_LEFT || dir == MOVE_RIGHT;
+	case L_STACKED:
 	case L_VERT:
 		return dir == MOVE_UP || dir == MOVE_DOWN;
 	default:
@@ -485,6 +489,9 @@ void container_move(struct sway_container *container,
 		}
 	}
 
+	container_notify_child_title_changed(old_parent);
+	container_notify_child_title_changed(container->parent);
+
 	if (old_parent) {
 		seat_set_focus(config->handler_context.seat, old_parent);
 		seat_set_focus(config->handler_context.seat, container);
@@ -832,6 +839,8 @@ struct sway_container *container_split(struct sway_container *child,
 		container_add_child(cont, child);
 	}
 
+	container_notify_child_title_changed(cont);
+
 	return cont;
 }
 

sway/tree/view.c

@@ -441,6 +441,7 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface) {
 	input_manager_set_focus(input_manager, cont);
 
 	view_update_title(view, false);
+	container_notify_child_title_changed(view->swayc->parent);
 	view_execute_criteria(view);
 
 	container_damage_whole(cont);