Merge pull request #2005 from RyanDwyer/tabbed-layout

Implement tabbed layout

11 files changed, 520 insertions, 95 deletions

diff --git a/include/sway/input/seat.h b/include/sway/input/seat.h
index ff76841e..2e4da438 100644
--- a/include/sway/input/seat.h
+++ b/include/sway/input/seat.h
@@ -95,6 +95,12 @@ struct sway_container *seat_get_focus_inactive_view(struct sway_seat *seat,
                 struct sway_container *container);
 
 /**
+ * Return the immediate child of container which was most recently focused.
+ */
+struct sway_container *seat_get_active_child(struct sway_seat *seat,
+                struct sway_container *container);
+
+/**
  * Iterate over the focus-inactive children of the container calling the
  * function on each.
  */
diff --git a/include/sway/tree/container.h b/include/sway/tree/container.h
index e7e9d944..598a4f3d 100644
--- a/include/sway/tree/container.h
+++ b/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);
 
 /**
diff --git a/include/sway/tree/view.h b/include/sway/tree/view.h
index 951912d0..0fb8f1b3 100644
--- a/include/sway/tree/view.h
+++ b/include/sway/tree/view.h
@@ -274,4 +274,10 @@ bool view_has_mark(struct sway_view *view, char *mark);
 
 void view_update_marks_textures(struct sway_view *view);
 
+/**
+ * Returns true if there's a possibility the view may be rendered on screen.
+ * Intended for damage tracking.
+ */
+bool view_is_visible(struct sway_view *view);
+
 #endif
diff --git a/sway/commands/layout.c b/sway/commands/layout.c
index bb36bb18..8aa321ae 100644
--- a/sway/commands/layout.c
+++ b/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;
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index 51c1ffbe..551e96fc 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -599,12 +599,195 @@ 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) {
+        struct sway_container *con = parent->children->items[child_index];
+        float output_scale = output->wlr_output->scale;
+        float color[4];
+        struct wlr_box box;
+
+        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 (child_index == parent->children->length - 1) {
+                tab_width = parent->width - tab_width * child_index;
+        }
+
+        // Single pixel bar above title
+        memcpy(&color, colors->border, sizeof(float) * 4);
+        premultiply_alpha(color, con->alpha);
+        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
+        box.y = (parent->y + config->border_thickness * 2 + config->font_height - 1)
+                * output_scale;
+        render_rect(output->wlr_output, damage, &box, color);
+
+        // Single pixel bar on left
+        box.x = x;
+        box.y = parent->y + 1;
+        box.width = 1;
+        box.height = config->border_thickness * 2 + config->font_height - 2;
+        scale_box(&box, output_scale);
+        render_rect(output->wlr_output, damage, &box, color);
+
+        // Single pixel bar on right
+        box.x = (x + tab_width - 1) * 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 + 1 + 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 - 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);
+        premultiply_alpha(color, con->alpha);
+        box.x = x + 1;
+        box.y = parent->y + 1;
+        box.width = tab_width - 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 of text
+        box.x = x + 1;
+        box.y = parent->y + config->border_thickness;
+        box.width = config->border_thickness;
+        box.height = config->font_height;
+        scale_box(&box, output_scale);
+        render_rect(output->wlr_output, damage, &box, color);
+
+        // Title background - right of text
+        box.x = (x + 1 + 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 != B_NONE) {
+                if (view->border_left) {
+                        memcpy(&color, colors->child_border, sizeof(float) * 4);
+                        premultiply_alpha(color, 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);
+                        premultiply_alpha(color, 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);
+                        premultiply_alpha(color, 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_active_child(seat, con);
+        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 +811,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
@@ -896,9 +1079,7 @@ static void output_damage_view(struct sway_output *output,
                 return;
         }
 
-        struct sway_container *workspace = container_parent(view->swayc,
-                        C_WORKSPACE);
-        if (workspace->sway_workspace->fullscreen && !view->is_fullscreen) {
+        if (!view_is_visible(view)) {
                 return;
         }
 
diff --git a/sway/input/cursor.c b/sway/input/cursor.c
index b0ce8002..e0b987d2 100644
--- a/sway/input/cursor.c
+++ b/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;
         }
 
diff --git a/sway/input/seat.c b/sway/input/seat.c
index 7d541f6e..7a3e928a 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -718,6 +718,18 @@ struct sway_container *seat_get_focus_inactive(struct sway_seat *seat,
         return seat_get_focus_by_type(seat, container, C_TYPES);
 }
 
+struct sway_container *seat_get_active_child(struct sway_seat *seat,
+                struct sway_container *container) {
+        struct sway_container *focus = seat_get_focus_inactive(seat, container);
+        if (!focus) {
+                return NULL;
+        }
+        while (focus->parent != container) {
+                focus = focus->parent;
+        }
+        return focus;
+}
+
 struct sway_container *sway_seat_get_focus(struct sway_seat *seat) {
         if (!seat->has_focus) {
                 return NULL;
diff --git a/sway/tree/arrange.c b/sway/tree/arrange.c
index 83bb20fb..8aebc0cc 100644
--- a/sway/tree/arrange.c
+++ b/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);
diff --git a/sway/tree/container.c b/sway/tree/container.c
index feaf7647..5d88325f 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -452,79 +452,138 @@ 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) {
+        if (!sway_assert(swayc->type == C_VIEW, "Expected a view")) {
                 return NULL;
         }
+        struct sway_view *sview = swayc->sway_view;
+        double view_sx = ox - sview->x;
+        double view_sy = oy - sview->y;
 
-        list_add(queue, parent);
+        double _sx, _sy;
+        struct wlr_surface *_surface = NULL;
+        switch (sview->type) {
+        case SWAY_VIEW_XWAYLAND:
+                _surface = wlr_surface_surface_at(sview->surface,
+                                view_sx, view_sy, &_sx, &_sy);
+                break;
+        case SWAY_VIEW_XDG_SHELL_V6:
+                // the top left corner of the sway container is the
+                // coordinate of the top left corner of the window geometry
+                view_sx += sview->wlr_xdg_surface_v6->geometry.x;
+                view_sy += sview->wlr_xdg_surface_v6->geometry.y;
+
+                _surface = wlr_xdg_surface_v6_surface_at(
+                                sview->wlr_xdg_surface_v6,
+                                view_sx, view_sy, &_sx, &_sy);
+                break;
+        case SWAY_VIEW_XDG_SHELL:
+                // the top left corner of the sway container is the
+                // coordinate of the top left corner of the window geometry
+                view_sx += sview->wlr_xdg_surface->geometry.x;
+                view_sy += sview->wlr_xdg_surface->geometry.y;
+
+                _surface = wlr_xdg_surface_surface_at(
+                                sview->wlr_xdg_surface,
+                                view_sx, view_sy, &_sx, &_sy);
+                break;
+        }
+        if (_surface) {
+                *sx = _sx;
+                *sy = _sy;
+                *surface = _surface;
+        }
+        return swayc;
+}
 
-        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;
-                        switch (sview->type) {
-                        case SWAY_VIEW_XWAYLAND:
-                                _surface = wlr_surface_surface_at(sview->surface,
-                                        view_sx, view_sy, &_sx, &_sy);
-                                break;
-                        case SWAY_VIEW_XDG_SHELL_V6:
-                                // the top left corner of the sway container is the
-                                // coordinate of the top left corner of the window geometry
-                                view_sx += sview->wlr_xdg_surface_v6->geometry.x;
-                                view_sy += sview->wlr_xdg_surface_v6->geometry.y;
-
-                                _surface = wlr_xdg_surface_v6_surface_at(
-                                        sview->wlr_xdg_surface_v6,
-                                        view_sx, view_sy, &_sx, &_sy);
-                                break;
-                        case SWAY_VIEW_XDG_SHELL:
-                                // the top left corner of the sway container is the
-                                // coordinate of the top left corner of the window geometry
-                                view_sx += sview->wlr_xdg_surface->geometry.x;
-                                view_sy += sview->wlr_xdg_surface->geometry.y;
-
-                                _surface = wlr_xdg_surface_surface_at(
-                                        sview->wlr_xdg_surface,
-                                        view_sx, view_sy, &_sx, &_sy);
-                                break;
-                        }
-                        if (_surface) {
-                                *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,
-                        };
-                        if (wlr_box_contains_point(&swayc_box, ox, oy)) {
-                                return swayc;
-                        }
-                } else {
-                        list_cat(queue, swayc->children);
+/**
+ * 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_active_child(seat, 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(&box, ox, oy)) {
+                        return container_at(child, ox, oy, surface, sx, sy);
+                }
+        }
+        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,91 @@ 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, "D[");
+                        break;
+                }
+        }
+
+        for (int i = 0; i < parent->children->length; ++i) {
+                if (i != 0) {
+                        len += 1;
+                        if (buffer) {
+                                strcat(buffer, " ");
+                        }
+                }
+                struct sway_container *child = parent->children->items[i];
+                const char *identifier = NULL;
+                if (child->type == C_VIEW) {
+                        identifier = view_get_class(child->sway_view);
+                        if (!identifier) {
+                                identifier = view_get_app_id(child->sway_view);
+                        }
+                } else {
+                        identifier = child->name;
+                }
+                if (identifier) {
+                        len += strlen(identifier);
+                        if (buffer) {
+                                strcat(buffer, identifier);
+                        }
+                } 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);
diff --git a/sway/tree/layout.c b/sway/tree/layout.c
index ec1c6fe5..f8acdf6c 100644
--- a/sway/tree/layout.c
+++ b/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;
 }
 
diff --git a/sway/tree/view.c b/sway/tree/view.c
index 192a73c5..64597c02 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -167,32 +167,53 @@ void view_autoconfigure(struct sway_view *view) {
 
         double x, y, width, height;
         x = y = width = height = 0;
+        double y_offset = 0;
+
+        // In a tabbed or stacked container, the swayc's y is the top of the title
+        // area. We have to offset the surface y by the height of the title bar, and
+        // disable any top border because we'll always have the title bar.
+        if (view->swayc->parent->layout == L_TABBED) {
+                y_offset = config->border_thickness * 2 + config->font_height;
+                view->border_top = 0;
+        } else if (view->swayc->parent->layout == L_STACKED) {
+                y_offset = config->border_thickness * 2 + config->font_height;
+                y_offset *= view->swayc->parent->children->length;
+                view->border_top = 0;
+        }
+
         switch (view->border) {
         case B_NONE:
                 x = view->swayc->x;
-                y = view->swayc->y;
+                y = view->swayc->y + y_offset;
                 width = view->swayc->width;
-                height = view->swayc->height;
+                height = view->swayc->height - y_offset;
                 break;
         case B_PIXEL:
                 x = view->swayc->x + view->border_thickness * view->border_left;
-                y = view->swayc->y + view->border_thickness * view->border_top;
+                y = view->swayc->y + view->border_thickness * view->border_top + y_offset;
                 width = view->swayc->width
                         - view->border_thickness * view->border_left
                         - view->border_thickness * view->border_right;
-                height = view->swayc->height
+                height = view->swayc->height - y_offset
                         - view->border_thickness * view->border_top
                         - view->border_thickness * view->border_bottom;
                 break;
         case B_NORMAL:
                 // Height is: border + title height + border + view height + border
                 x = view->swayc->x + view->border_thickness * view->border_left;
-                y = view->swayc->y + config->font_height + view->border_thickness * 2;
                 width = view->swayc->width
                         - view->border_thickness * view->border_left
                         - view->border_thickness * view->border_right;
-                height = view->swayc->height - config->font_height
-                        - view->border_thickness * (2 + view->border_bottom);
+                if (y_offset) {
+                        y = view->swayc->y + y_offset;
+                        height = view->swayc->height - y_offset
+                                - view->border_thickness * view->border_bottom;
+                } else {
+                        y = view->swayc->y + config->font_height + view->border_thickness * 2
+                                + y_offset;
+                        height = view->swayc->height - config->font_height
+                                - view->border_thickness * (2 + view->border_bottom);
+                }
                 break;
         }
 
@@ -441,6 +462,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);
@@ -864,3 +886,28 @@ void view_update_marks_textures(struct sway_view *view) {
                         &config->border_colors.urgent);
         container_damage_whole(view->swayc);
 }
+
+bool view_is_visible(struct sway_view *view) {
+        if (!view->swayc) {
+                return false;
+        }
+        // Check view isn't in a tabbed or stacked container on an inactive tab
+        struct sway_seat *seat = input_manager_current_seat(input_manager);
+        struct sway_container *container = view->swayc;
+        while (container->type != C_WORKSPACE) {
+                if (container->parent->layout == L_TABBED ||
+                                container->parent->layout == L_STACKED) {
+                        if (seat_get_active_child(seat, container->parent) != container) {
+                                return false;
+                        }
+                }
+                container = container->parent;
+        }
+        // Check view isn't hidden by another fullscreen view
+        struct sway_container *workspace = container;
+        if (workspace->sway_workspace->fullscreen && !view->is_fullscreen) {
+                return false;
+        }
+        // Check the workspace is visible
+        return workspace_is_visible(workspace);
+}