1 files changed, 357 insertions, 456 deletions

diff --git a/sway/tree/view.c b/sway/tree/view.c
index 7afcdf31..35b4b73f 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -1,11 +1,13 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <strings.h>
 #include <wayland-server-core.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_buffer.h>
+#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_xdg_decoration_v1.h>
 #include "config.h"
 #if HAVE_XWAYLAND
@@ -15,14 +17,16 @@
 #include "log.h"
 #include "sway/criteria.h"
 #include "sway/commands.h"
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/desktop/idle_inhibit_v1.h"
+#include "sway/desktop/launcher.h"
 #include "sway/input/cursor.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
 #include "sway/input/seat.h"
+#include "sway/scene_descriptor.h"
 #include "sway/server.h"
+#include "sway/sway_text_node.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/view.h"
@@ -32,15 +36,29 @@
 #include "pango.h"
 #include "stringop.h"
 
-void view_init(struct sway_view *view, enum sway_view_type type,
+bool view_init(struct sway_view *view, enum sway_view_type type,
                 const struct sway_view_impl *impl) {
+        bool failed = false;
+        view->scene_tree = alloc_scene_tree(root->staging, &failed);
+        view->content_tree = alloc_scene_tree(view->scene_tree, &failed);
+
+        if (!failed && !scene_descriptor_assign(&view->scene_tree->node,
+                        SWAY_SCENE_DESC_VIEW, view)) {
+                failed = true;
+        }
+
+        if (failed) {
+                wlr_scene_node_destroy(&view->scene_tree->node);
+                return false;
+        }
+
         view->type = type;
         view->impl = impl;
         view->executed_criteria = create_list();
-        wl_list_init(&view->saved_buffers);
         view->allow_request_urgent = true;
         view->shortcuts_inhibit = SHORTCUTS_INHIBIT_DEFAULT;
         wl_signal_init(&view->events.unmap);
+        return true;
 }
 
 void view_destroy(struct sway_view *view) {
@@ -56,11 +74,11 @@ void view_destroy(struct sway_view *view) {
                                 "(might have a pending transaction?)")) {
                 return;
         }
-        if (!wl_list_empty(&view->saved_buffers)) {
-                view_remove_saved_buffer(view);
-        }
+        wl_list_remove(&view->events.unmap.listener_list);
         list_free(view->executed_criteria);
 
+        view_assign_ctx(view, NULL);
+        wlr_scene_node_destroy(&view->scene_tree->node);
         free(view->title_format);
 
         if (view->impl->destroy) {
@@ -206,7 +224,7 @@ bool view_ancestor_is_only_visible(struct sway_view *view) {
                 } else {
                         only_visible = true;
                 }
-                con = con->parent;
+                con = con->pending.parent;
         }
         return only_visible;
 }
@@ -222,72 +240,73 @@ static bool view_is_only_visible(struct sway_view *view) {
                         }
                 }
 
-                con = con->parent;
+                con = con->pending.parent;
         }
 
         return true;
 }
 
 static bool gaps_to_edge(struct sway_view *view) {
-        struct side_gaps gaps = view->container->workspace->current_gaps;
+        struct side_gaps gaps = view->container->pending.workspace->current_gaps;
         return gaps.top > 0 || gaps.right > 0 || gaps.bottom > 0 || gaps.left > 0;
 }
 
 void view_autoconfigure(struct sway_view *view) {
         struct sway_container *con = view->container;
-        struct sway_workspace *ws = con->workspace;
+        struct sway_workspace *ws = con->pending.workspace;
 
         if (container_is_scratchpad_hidden(con) &&
-                        con->fullscreen_mode != FULLSCREEN_GLOBAL) {
+                        con->pending.fullscreen_mode != FULLSCREEN_GLOBAL) {
                 return;
         }
         struct sway_output *output = ws ? ws->output : NULL;
 
-        if (con->fullscreen_mode == FULLSCREEN_WORKSPACE) {
-                con->content_x = output->lx;
-                con->content_y = output->ly;
-                con->content_width = output->width;
-                con->content_height = output->height;
+        if (con->pending.fullscreen_mode == FULLSCREEN_WORKSPACE) {
+                con->pending.content_x = output->lx;
+                con->pending.content_y = output->ly;
+                con->pending.content_width = output->width;
+                con->pending.content_height = output->height;
                 return;
-        } else if (con->fullscreen_mode == FULLSCREEN_GLOBAL) {
-                con->content_x = root->x;
-                con->content_y = root->y;
-                con->content_width = root->width;
-                con->content_height = root->height;
+        } else if (con->pending.fullscreen_mode == FULLSCREEN_GLOBAL) {
+                con->pending.content_x = root->x;
+                con->pending.content_y = root->y;
+                con->pending.content_width = root->width;
+                con->pending.content_height = root->height;
                 return;
         }
 
-        con->border_top = con->border_bottom = true;
-        con->border_left = con->border_right = true;
+        con->pending.border_top = con->pending.border_bottom = true;
+        con->pending.border_left = con->pending.border_right = true;
         double y_offset = 0;
 
-        if (!container_is_floating(con) && ws) {
+        if (!container_is_floating_or_child(con) && ws) {
                 if (config->hide_edge_borders == E_BOTH
                                 || config->hide_edge_borders == E_VERTICAL) {
-                        con->border_left = con->x != ws->x;
-                        int right_x = con->x + con->width;
-                        con->border_right = right_x != ws->x + ws->width;
+                        con->pending.border_left = con->pending.x != ws->x;
+                        int right_x = con->pending.x + con->pending.width;
+                        con->pending.border_right = right_x != ws->x + ws->width;
                 }
 
                 if (config->hide_edge_borders == E_BOTH
                                 || config->hide_edge_borders == E_HORIZONTAL) {
-                        con->border_top = con->y != ws->y;
-                        int bottom_y = con->y + con->height;
-                        con->border_bottom = bottom_y != ws->y + ws->height;
+                        con->pending.border_top = con->pending.y != ws->y;
+                        int bottom_y = con->pending.y + con->pending.height;
+                        con->pending.border_bottom = bottom_y != ws->y + ws->height;
                 }
 
                 bool smart = config->hide_edge_borders_smart == ESMART_ON ||
                         (config->hide_edge_borders_smart == ESMART_NO_GAPS &&
                         !gaps_to_edge(view));
                 if (smart) {
-                        bool show_border = container_is_floating_or_child(con) ||
-                                !view_is_only_visible(view);
-                        con->border_left &= show_border;
-                        con->border_right &= show_border;
-                        con->border_top &= show_border;
-                        con->border_bottom &= show_border;
+                        bool show_border = !view_is_only_visible(view);
+                        con->pending.border_left &= show_border;
+                        con->pending.border_right &= show_border;
+                        con->pending.border_top &= show_border;
+                        con->pending.border_bottom &= show_border;
                 }
+        }
 
+        if (!container_is_floating(con)) {
                 // In a tabbed or stacked container, the container'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.
@@ -298,56 +317,56 @@ void view_autoconfigure(struct sway_view *view) {
                         enum sway_container_layout layout = container_parent_layout(con);
                         if (layout == L_TABBED) {
                                 y_offset = container_titlebar_height();
-                                con->border_top = false;
+                                con->pending.border_top = false;
                         } else if (layout == L_STACKED) {
                                 y_offset = container_titlebar_height() * siblings->length;
-                                con->border_top = false;
+                                con->pending.border_top = false;
                         }
                 }
         }
 
         double x, y, width, height;
-        switch (con->border) {
+        switch (con->pending.border) {
         default:
         case B_CSD:
         case B_NONE:
-                x = con->x;
-                y = con->y + y_offset;
-                width = con->width;
-                height = con->height - y_offset;
+                x = con->pending.x;
+                y = con->pending.y + y_offset;
+                width = con->pending.width;
+                height = con->pending.height - y_offset;
                 break;
         case B_PIXEL:
-                x = con->x + con->border_thickness * con->border_left;
-                y = con->y + con->border_thickness * con->border_top + y_offset;
-                width = con->width
-                        - con->border_thickness * con->border_left
-                        - con->border_thickness * con->border_right;
-                height = con->height - y_offset
-                        - con->border_thickness * con->border_top
-                        - con->border_thickness * con->border_bottom;
+                x = con->pending.x + con->pending.border_thickness * con->pending.border_left;
+                y = con->pending.y + con->pending.border_thickness * con->pending.border_top + y_offset;
+                width = con->pending.width
+                        - con->pending.border_thickness * con->pending.border_left
+                        - con->pending.border_thickness * con->pending.border_right;
+                height = con->pending.height - y_offset
+                        - con->pending.border_thickness * con->pending.border_top
+                        - con->pending.border_thickness * con->pending.border_bottom;
                 break;
         case B_NORMAL:
                 // Height is: 1px border + 3px pad + title height + 3px pad + 1px border
-                x = con->x + con->border_thickness * con->border_left;
-                width = con->width
-                        - con->border_thickness * con->border_left
-                        - con->border_thickness * con->border_right;
+                x = con->pending.x + con->pending.border_thickness * con->pending.border_left;
+                width = con->pending.width
+                        - con->pending.border_thickness * con->pending.border_left
+                        - con->pending.border_thickness * con->pending.border_right;
                 if (y_offset) {
-                        y = con->y + y_offset;
-                        height = con->height - y_offset
-                                - con->border_thickness * con->border_bottom;
+                        y = con->pending.y + y_offset;
+                        height = con->pending.height - y_offset
+                                - con->pending.border_thickness * con->pending.border_bottom;
                 } else {
-                        y = con->y + container_titlebar_height();
-                        height = con->height - container_titlebar_height()
-                                - con->border_thickness * con->border_bottom;
+                        y = con->pending.y + container_titlebar_height();
+                        height = con->pending.height - container_titlebar_height()
+                                - con->pending.border_thickness * con->pending.border_bottom;
                 }
                 break;
         }
 
-        con->content_x = x;
-        con->content_y = y;
-        con->content_width = width;
-        con->content_height = height;
+        con->pending.content_x = x;
+        con->pending.content_y = y;
+        con->pending.content_width = width;
+        con->pending.content_height = height;
 }
 
 void view_set_activated(struct sway_view *view, bool activated) {
@@ -360,17 +379,17 @@ void view_set_activated(struct sway_view *view, bool activated) {
         }
 }
 
-void view_request_activate(struct sway_view *view) {
-        struct sway_workspace *ws = view->container->workspace;
-        if (!ws) { // hidden scratchpad container
-                return;
+void view_request_activate(struct sway_view *view, struct sway_seat *seat) {
+        struct sway_workspace *ws = view->container->pending.workspace;
+        if (!seat) {
+                seat = input_manager_current_seat();
         }
-        struct sway_seat *seat = input_manager_current_seat();
 
         switch (config->focus_on_window_activation) {
         case FOWA_SMART:
-                if (workspace_is_visible(ws)) {
+                if (ws && workspace_is_visible(ws)) {
                         seat_set_focus_container(seat, view->container);
+                        container_raise_floating(view->container);
                 } else {
                         view_set_urgent(view, true);
                 }
@@ -379,11 +398,23 @@ void view_request_activate(struct sway_view *view) {
                 view_set_urgent(view, true);
                 break;
         case FOWA_FOCUS:
-                seat_set_focus_container(seat, view->container);
+                if (container_is_scratchpad_hidden_or_child(view->container)) {
+                        root_scratchpad_show(view->container);
+                } else {
+                        seat_set_focus_container(seat, view->container);
+                        container_raise_floating(view->container);
+                }
                 break;
         case FOWA_NONE:
                 break;
         }
+        transaction_commit_dirty();
+}
+
+void view_request_urgent(struct sway_view *view) {
+        if (config->focus_on_window_activation != FOWA_NONE) {
+                view_set_urgent(view, true);
+        }
 }
 
 void view_set_csd_from_server(struct sway_view *view, bool enabled) {
@@ -401,13 +432,13 @@ void view_set_csd_from_server(struct sway_view *view, bool enabled) {
 void view_update_csd_from_client(struct sway_view *view, bool enabled) {
         sway_log(SWAY_DEBUG, "View %p updated CSD to %i", view, enabled);
         struct sway_container *con = view->container;
-        if (enabled && con && con->border != B_CSD) {
-                con->saved_border = con->border;
+        if (enabled && con && con->pending.border != B_CSD) {
+                con->saved_border = con->pending.border;
                 if (container_is_floating(con)) {
-                        con->border = B_CSD;
+                        con->pending.border = B_CSD;
                 }
-        } else if (!enabled && con && con->border == B_CSD) {
-                con->border = con->saved_border;
+        } else if (!enabled && con && con->pending.border == B_CSD) {
+                con->pending.border = con->saved_border;
         }
         view->using_csd = enabled;
 }
@@ -430,49 +461,6 @@ void view_close_popups(struct sway_view *view) {
         }
 }
 
-void view_damage_from(struct sway_view *view) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_from_view(output, view);
-        }
-}
-
-void view_for_each_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (!view->surface) {
-                return;
-        }
-        if (view->impl->for_each_surface) {
-                view->impl->for_each_surface(view, iterator, user_data);
-        } else {
-                wlr_surface_for_each_surface(view->surface, iterator, user_data);
-        }
-}
-
-void view_for_each_popup_surface(struct sway_view *view,
-                wlr_surface_iterator_func_t iterator, void *user_data) {
-        if (!view->surface) {
-                return;
-        }
-        if (view->impl->for_each_popup_surface) {
-                view->impl->for_each_popup_surface(view, iterator, user_data);
-        }
-}
-
-static void view_subsurface_create(struct sway_view *view,
-        struct wlr_subsurface *subsurface);
-
-static void view_init_subsurfaces(struct sway_view *view,
-        struct wlr_surface *surface);
-
-static void view_handle_surface_new_subsurface(struct wl_listener *listener,
-                void *data) {
-        struct sway_view *view =
-                wl_container_of(listener, view, surface_new_subsurface);
-        struct wlr_subsurface *subsurface = data;
-        view_subsurface_create(view, subsurface);
-}
-
 static bool view_has_executed_criteria(struct sway_view *view,
                 struct criteria *criteria) {
         for (int i = 0; i < view->executed_criteria->length; ++i) {
@@ -514,7 +502,7 @@ static void view_populate_pid(struct sway_view *view) {
 #if HAVE_XWAYLAND
         case SWAY_VIEW_XWAYLAND:;
                 struct wlr_xwayland_surface *surf =
-                        wlr_xwayland_surface_from_wlr_surface(view->surface);
+                        wlr_xwayland_surface_try_from_wlr_surface(view->surface);
                 pid = surf->pid;
                 break;
 #endif
@@ -527,6 +515,20 @@ static void view_populate_pid(struct sway_view *view) {
         view->pid = pid;
 }
 
+void view_assign_ctx(struct sway_view *view, struct launcher_ctx *ctx) {
+        if (view->ctx) {
+                // This ctx has been replaced
+                launcher_ctx_destroy(view->ctx);
+                view->ctx = NULL;
+        }
+        if (ctx == NULL) {
+                return;
+        }
+        launcher_ctx_consume(ctx);
+
+        view->ctx = ctx;
+}
+
 static struct sway_workspace *select_workspace(struct sway_view *view) {
         struct sway_seat *seat = input_manager_current_seat();
 
@@ -562,13 +564,14 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
         }
         list_free(criterias);
         if (ws) {
-                root_remove_workspace_pid(view->pid);
+                view_assign_ctx(view, NULL);
                 return ws;
         }
 
         // Check if there's a PID mapping
-        ws = root_workspace_for_pid(view->pid);
+        ws = view->ctx ? launcher_ctx_get_workspace(view->ctx) : NULL;
         if (ws) {
+                view_assign_ctx(view, NULL);
                 return ws;
         }
 
@@ -577,7 +580,7 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
         if (node && node->type == N_WORKSPACE) {
                 return node->sway_workspace;
         } else if (node && node->type == N_CONTAINER) {
-                return node->sway_container->workspace;
+                return node->sway_container->pending.workspace;
         }
 
         // When there's no outputs connected, the above should match a workspace on
@@ -586,16 +589,29 @@ static struct sway_workspace *select_workspace(struct sway_view *view) {
         return NULL;
 }
 
+static void update_ext_foreign_toplevel(struct sway_view *view) {
+        struct wlr_ext_foreign_toplevel_handle_v1_state toplevel_state = {
+                .app_id = view_get_app_id(view),
+                .title = view_get_title(view),
+        };
+        wlr_ext_foreign_toplevel_handle_v1_update_state(view->ext_foreign_toplevel, &toplevel_state);
+}
+
 static bool should_focus(struct sway_view *view) {
         struct sway_seat *seat = input_manager_current_seat();
         struct sway_container *prev_con = seat_get_focused_container(seat);
         struct sway_workspace *prev_ws = seat_get_focused_workspace(seat);
-        struct sway_workspace *map_ws = view->container->workspace;
+        struct sway_workspace *map_ws = view->container->pending.workspace;
 
-        if (view->container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+        if (view->container->pending.fullscreen_mode == FULLSCREEN_GLOBAL) {
                 return true;
         }
 
+        // View opened "under" fullscreen view should not be given focus.
+        if (root->fullscreen_global || !map_ws || map_ws->fullscreen) {
+                return false;
+        }
+
         // Views can only take focus if they are mapped into the active workspace
         if (prev_ws != map_ws) {
                 return false;
@@ -603,9 +619,9 @@ static bool should_focus(struct sway_view *view) {
 
         // If the view is the only one in the focused workspace, it'll get focus
         // regardless of any no_focus criteria.
-        if (!view->container->parent && !prev_con) {
-                size_t num_children = view->container->workspace->tiling->length +
-                        view->container->workspace->floating->length;
+        if (!view->container->pending.parent && !prev_con) {
+                size_t num_children = view->container->pending.workspace->tiling->length +
+                        view->container->pending.workspace->floating->length;
                 if (num_children == 1) {
                         return true;
                 }
@@ -635,6 +651,7 @@ static void handle_foreign_activate_request(
                         break;
                 }
         }
+        transaction_commit_dirty();
 }
 
 static void handle_foreign_fullscreen_request(
@@ -645,9 +662,21 @@ static void handle_foreign_fullscreen_request(
 
         // Match fullscreen command behavior for scratchpad hidden views
         struct sway_container *container = view->container;
-        if (!container->workspace) {
-                while (container->parent) {
-                        container = container->parent;
+        if (!container->pending.workspace) {
+                while (container->pending.parent) {
+                        container = container->pending.parent;
+                }
+        }
+
+        if (event->fullscreen && event->output && event->output->data) {
+                struct sway_output *output = event->output->data;
+                struct sway_workspace *ws = output_get_active_workspace(output);
+                if (ws && !container_is_scratchpad_hidden(view->container)) {
+                        if (container_is_floating(view->container)) {
+                                workspace_add_floating(ws, view->container);
+                        } else {
+                                workspace_add_tiling(ws, view->container);
+                        }
                 }
         }
 
@@ -656,12 +685,13 @@ static void handle_foreign_fullscreen_request(
         if (event->fullscreen) {
                 arrange_root();
         } else {
-                if (container->parent) {
-                        arrange_container(container->parent);
-                } else if (container->workspace) {
-                        arrange_workspace(container->workspace);
+                if (container->pending.parent) {
+                        arrange_container(container->pending.parent);
+                } else if (container->pending.workspace) {
+                        arrange_workspace(container->pending.workspace);
                 }
         }
+        transaction_commit_dirty();
 }
 
 static void handle_foreign_close_request(
@@ -692,6 +722,13 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         view_populate_pid(view);
         view->container = container_create(view);
 
+        if (view->ctx == NULL) {
+                struct launcher_ctx *ctx = launcher_ctx_find_pid(view->pid);
+                if (ctx != NULL) {
+                        view_assign_ctx(view, ctx);
+                }
+        }
+
         // If there is a request to be opened fullscreen on a specific output, try
         // to honor that request. Otherwise, fallback to assigns, pid mappings,
         // focused workspace, etc
@@ -705,10 +742,36 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         }
 
         struct sway_seat *seat = input_manager_current_seat();
-        struct sway_node *node = ws ? seat_get_focus_inactive(seat, &ws->node)
-                : seat_get_focus_inactive(seat, &root->node);
-        struct sway_container *target_sibling = node->type == N_CONTAINER ?
-                node->sway_container : NULL;
+        struct sway_node *node =
+                seat_get_focus_inactive(seat, ws ? &ws->node : &root->node);
+        struct sway_container *target_sibling = NULL;
+        if (node && node->type == N_CONTAINER) {
+                if (container_is_floating(node->sway_container)) {
+                        // If we're about to launch the view into the floating container, then
+                        // launch it as a tiled view instead.
+                        if (ws) {
+                                target_sibling = seat_get_focus_inactive_tiling(seat, ws);
+                                if (target_sibling) {
+                                        struct sway_container *con =
+                                                seat_get_focus_inactive_view(seat, &target_sibling->node);
+                                        if (con)  {
+                                                target_sibling = con;
+                                        }
+                                }
+                        } else {
+                                ws = seat_get_last_known_workspace(seat);
+                        }
+                } else {
+                        target_sibling = node->sway_container;
+                }
+        }
+
+        struct wlr_ext_foreign_toplevel_handle_v1_state foreign_toplevel_state = {
+                .app_id = view_get_app_id(view),
+                .title = view_get_title(view),
+        };
+        view->ext_foreign_toplevel =
+                wlr_ext_foreign_toplevel_handle_v1_create(server.foreign_toplevel_list, &foreign_toplevel_state);
 
         view->foreign_toplevel =
                 wlr_foreign_toplevel_handle_v1_create(server.foreign_toplevel_manager);
@@ -725,13 +788,6 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         wl_signal_add(&view->foreign_toplevel->events.destroy,
                         &view->foreign_destroy);
 
-        // If we're about to launch the view into the floating container, then
-        // launch it as a tiled view in the root of the workspace instead.
-        if (target_sibling && container_is_floating(target_sibling)) {
-                target_sibling = NULL;
-                ws = seat_get_last_known_workspace(seat);
-        }
-
         struct sway_container *container = view->container;
         if (target_sibling) {
                 container_add_sibling(target_sibling, container, 1);
@@ -740,30 +796,25 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         }
         ipc_event_window(view->container, "new");
 
-        view_init_subsurfaces(view, wlr_surface);
-        wl_signal_add(&wlr_surface->events.new_subsurface,
-                &view->surface_new_subsurface);
-        view->surface_new_subsurface.notify = view_handle_surface_new_subsurface;
-
         if (decoration) {
                 view_update_csd_from_client(view, decoration);
         }
 
         if (view->impl->wants_floating && view->impl->wants_floating(view)) {
-                view->container->border = config->floating_border;
-                view->container->border_thickness = config->floating_border_thickness;
+                view->container->pending.border = config->floating_border;
+                view->container->pending.border_thickness = config->floating_border_thickness;
                 container_set_floating(view->container, true);
         } else {
-                view->container->border = config->border;
-                view->container->border_thickness = config->border_thickness;
+                view->container->pending.border = config->border;
+                view->container->pending.border_thickness = config->border_thickness;
                 view_set_tiled(view, true);
         }
 
         if (config->popup_during_fullscreen == POPUP_LEAVE &&
-                        container->workspace &&
-                        container->workspace->fullscreen &&
-                        container->workspace->fullscreen->view) {
-                struct sway_container *fs = container->workspace->fullscreen;
+                        container->pending.workspace &&
+                        container->pending.workspace->fullscreen &&
+                        container->pending.workspace->fullscreen->view) {
+                struct sway_container *fs = container->pending.workspace->fullscreen;
                 if (view_is_transient_for(view, fs->view)) {
                         container_set_fullscreen(fs, false);
                 }
@@ -774,12 +825,12 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
 
         if (fullscreen) {
                 container_set_fullscreen(view->container, true);
-                arrange_workspace(view->container->workspace);
+                arrange_workspace(view->container->pending.workspace);
         } else {
-                if (container->parent) {
-                        arrange_container(container->parent);
-                } else if (container->workspace) {
-                        arrange_workspace(container->workspace);
+                if (container->pending.parent) {
+                        arrange_container(container->pending.parent);
+                } else if (container->pending.workspace) {
+                        arrange_workspace(container->pending.workspace);
                 }
         }
 
@@ -788,11 +839,10 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         bool set_focus = should_focus(view);
 
 #if HAVE_XWAYLAND
-        if (wlr_surface_is_xwayland_surface(wlr_surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                        wlr_xwayland_surface_from_wlr_surface(wlr_surface);
-        set_focus = (wlr_xwayland_icccm_input_model(xsurface) !=
-                        WLR_ICCCM_INPUT_MODEL_NONE) && set_focus;
+        struct wlr_xwayland_surface *xsurface;
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
+                set_focus &= wlr_xwayland_icccm_input_model(xsurface) !=
+                                WLR_ICCCM_INPUT_MODEL_NONE;
         }
 #endif
 
@@ -800,34 +850,41 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
                 input_manager_set_focus(&view->container->node);
         }
 
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
+
         const char *app_id;
         const char *class;
         if ((app_id = view_get_app_id(view)) != NULL) {
-                wlr_foreign_toplevel_handle_v1_set_app_id(
-                                view->foreign_toplevel, app_id);
+                wlr_foreign_toplevel_handle_v1_set_app_id(view->foreign_toplevel, app_id);
         } else if ((class = view_get_class(view)) != NULL) {
-                wlr_foreign_toplevel_handle_v1_set_app_id(
-                                view->foreign_toplevel, class);
+                wlr_foreign_toplevel_handle_v1_set_app_id(view->foreign_toplevel, class);
         }
 }
 
 void view_unmap(struct sway_view *view) {
-        wl_signal_emit(&view->events.unmap, view);
+        wl_signal_emit_mutable(&view->events.unmap, view);
 
-        wl_list_remove(&view->surface_new_subsurface.link);
+        view->executed_criteria->length = 0;
 
         if (view->urgent_timer) {
                 wl_event_source_remove(view->urgent_timer);
                 view->urgent_timer = NULL;
         }
 
+        if (view->ext_foreign_toplevel) {
+                wlr_ext_foreign_toplevel_handle_v1_destroy(view->ext_foreign_toplevel);
+                view->ext_foreign_toplevel = NULL;
+        }
+
         if (view->foreign_toplevel) {
                 wlr_foreign_toplevel_handle_v1_destroy(view->foreign_toplevel);
                 view->foreign_toplevel = NULL;
         }
 
-        struct sway_container *parent = view->container->parent;
-        struct sway_workspace *ws = view->container->workspace;
+        struct sway_container *parent = view->container->pending.parent;
+        struct sway_workspace *ws = view->container->pending.workspace;
         container_begin_destroy(view->container);
         if (parent) {
                 container_reap_empty(parent);
@@ -860,262 +917,54 @@ void view_unmap(struct sway_view *view) {
         view->surface = NULL;
 }
 
-void view_update_size(struct sway_view *view, int width, int height) {
+void view_update_size(struct sway_view *view) {
         struct sway_container *con = view->container;
-
-        if (container_is_floating(con)) {
-                con->content_width = width;
-                con->content_height = height;
-                container_set_geometry_from_content(con);
-        } else {
-                con->surface_x = con->content_x + (con->content_width - width) / 2;
-                con->surface_y = con->content_y + (con->content_height - height) / 2;
-                con->surface_x = fmax(con->surface_x, con->content_x);
-                con->surface_y = fmax(con->surface_y, con->content_y);
-        }
+        con->pending.content_width = view->geometry.width;
+        con->pending.content_height = view->geometry.height;
+        container_set_geometry_from_content(con);
 }
 
-static const struct sway_view_child_impl subsurface_impl;
+void view_center_and_clip_surface(struct sway_view *view) {
+        struct sway_container *con = view->container;
 
-static void subsurface_get_root_coords(struct sway_view_child *child,
-                int *root_sx, int *root_sy) {
-        struct wlr_surface *surface = child->surface;
-        *root_sx = -child->view->geometry.x;
-        *root_sy = -child->view->geometry.y;
+        if (container_is_floating(con)) {
+                // We always center the current coordinates rather than the next, as the
+                // geometry immediately affects the currently active rendering.
+                int x = (int) fmax(0, (con->current.content_width - view->geometry.width) / 2);
+                int y = (int) fmax(0, (con->current.content_height - view->geometry.height) / 2);
 
-        if (child->parent && child->parent->impl &&
-                        child->parent->impl->get_root_coords) {
-                int sx, sy;
-                child->parent->impl->get_root_coords(child->parent, &sx, &sy);
-                *root_sx += sx;
-                *root_sy += sy;
+                wlr_scene_node_set_position(&view->content_tree->node, x, y);
         } else {
-                while (surface && wlr_surface_is_subsurface(surface)) {
-                        struct wlr_subsurface *subsurface =
-                                wlr_subsurface_from_wlr_surface(surface);
-                        if (subsurface == NULL) {
-                                break;
-                        }
-                        *root_sx += subsurface->current.x;
-                        *root_sy += subsurface->current.y;
-                        surface = subsurface->parent;
-                }
+                wlr_scene_node_set_position(&view->content_tree->node, 0, 0);
         }
-}
 
-static void subsurface_destroy(struct sway_view_child *child) {
-        if (!sway_assert(child->impl == &subsurface_impl,
-                        "Expected a subsurface")) {
-                return;
-        }
-        struct sway_subsurface *subsurface = (struct sway_subsurface *)child;
-        wl_list_remove(&subsurface->destroy.link);
-        free(subsurface);
-}
-
-static const struct sway_view_child_impl subsurface_impl = {
-        .get_root_coords = subsurface_get_root_coords,
-        .destroy = subsurface_destroy,
-};
-
-static void subsurface_handle_destroy(struct wl_listener *listener,
-                void *data) {
-        struct sway_subsurface *subsurface =
-                wl_container_of(listener, subsurface, destroy);
-        struct sway_view_child *child = &subsurface->child;
-        view_child_destroy(child);
-}
-
-static void view_child_damage(struct sway_view_child *child, bool whole);
-
-static void view_subsurface_create(struct sway_view *view,
-                struct wlr_subsurface *wlr_subsurface) {
-        struct sway_subsurface *subsurface =
-                calloc(1, sizeof(struct sway_subsurface));
-        if (subsurface == NULL) {
-                sway_log(SWAY_ERROR, "Allocation failed");
-                return;
-        }
-        view_child_init(&subsurface->child, &subsurface_impl, view,
-                wlr_subsurface->surface);
-
-        wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
-        subsurface->destroy.notify = subsurface_handle_destroy;
-
-        subsurface->child.mapped = true;
-
-        view_child_damage(&subsurface->child, true);
-}
-
-static void view_child_subsurface_create(struct sway_view_child *child,
-                struct wlr_subsurface *wlr_subsurface) {
-        struct sway_subsurface *subsurface =
-                calloc(1, sizeof(struct sway_subsurface));
-        if (subsurface == NULL) {
-                sway_log(SWAY_ERROR, "Allocation failed");
-                return;
-        }
-        subsurface->child.parent = child;
-        wl_list_insert(&child->children, &subsurface->child.link);
-        view_child_init(&subsurface->child, &subsurface_impl, child->view,
-                wlr_subsurface->surface);
-
-        wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
-        subsurface->destroy.notify = subsurface_handle_destroy;
-
-        subsurface->child.mapped = true;
-
-        view_child_damage(&subsurface->child, true);
-}
-
-static void view_child_damage(struct sway_view_child *child, bool whole) {
-        if (!child || !child->mapped || !child->view || !child->view->container) {
-                return;
-        }
-        int sx, sy;
-        child->impl->get_root_coords(child, &sx, &sy);
-        desktop_damage_surface(child->surface,
-                        child->view->container->content_x + sx,
-                        child->view->container->content_y + sy, whole);
-}
-
-static void view_child_handle_surface_commit(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_commit);
-        view_child_damage(child, false);
-}
-
-static void view_child_handle_surface_new_subsurface(
-                struct wl_listener *listener, void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_new_subsurface);
-        struct wlr_subsurface *subsurface = data;
-        view_child_subsurface_create(child, subsurface);
-}
-
-static void view_child_handle_surface_destroy(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_destroy);
-        view_child_destroy(child);
-}
-
-static void view_init_subsurfaces(struct sway_view *view,
-                struct wlr_surface *surface) {
-        struct wlr_subsurface *subsurface;
-        wl_list_for_each(subsurface, &surface->subsurfaces, parent_link) {
-                view_subsurface_create(view, subsurface);
-        }
-}
-
-static void view_child_handle_surface_map(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_map);
-        child->mapped = true;
-        view_child_damage(child, true);
-}
-
-static void view_child_handle_surface_unmap(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, surface_unmap);
-        view_child_damage(child, true);
-        child->mapped = false;
-}
-
-static void view_child_handle_view_unmap(struct wl_listener *listener,
-                void *data) {
-        struct sway_view_child *child =
-                wl_container_of(listener, child, view_unmap);
-        view_child_damage(child, true);
-        child->mapped = false;
-}
-
-void view_child_init(struct sway_view_child *child,
-                const struct sway_view_child_impl *impl, struct sway_view *view,
-                struct wlr_surface *surface) {
-        child->impl = impl;
-        child->view = view;
-        child->surface = surface;
-        wl_list_init(&child->children);
-
-        wl_signal_add(&surface->events.commit, &child->surface_commit);
-        child->surface_commit.notify = view_child_handle_surface_commit;
-        wl_signal_add(&surface->events.new_subsurface,
-                &child->surface_new_subsurface);
-        child->surface_new_subsurface.notify =
-                view_child_handle_surface_new_subsurface;
-        wl_signal_add(&surface->events.destroy, &child->surface_destroy);
-        child->surface_destroy.notify = view_child_handle_surface_destroy;
-
-        // Not all child views have a map/unmap event
-        child->surface_map.notify = view_child_handle_surface_map;
-        wl_list_init(&child->surface_map.link);
-        child->surface_unmap.notify = view_child_handle_surface_unmap;
-        wl_list_init(&child->surface_unmap.link);
-
-        wl_signal_add(&view->events.unmap, &child->view_unmap);
-        child->view_unmap.notify = view_child_handle_view_unmap;
-
-        struct sway_workspace *workspace = child->view->container->workspace;
-        if (workspace) {
-                wlr_surface_send_enter(child->surface, workspace->output->wlr_output);
-        }
-
-        view_init_subsurfaces(child->view, surface);
-}
-
-void view_child_destroy(struct sway_view_child *child) {
-        if (child->mapped && child->view->container != NULL) {
-                view_child_damage(child, true);
-        }
-
-        if (child->parent != NULL) {
-                wl_list_remove(&child->link);
-                child->parent = NULL;
-        }
-
-        struct sway_view_child *subchild, *tmpchild;
-        wl_list_for_each_safe(subchild, tmpchild, &child->children, link) {
-                wl_list_remove(&subchild->link);
-                subchild->parent = NULL;
-        }
-
-        wl_list_remove(&child->surface_commit.link);
-        wl_list_remove(&child->surface_destroy.link);
-        wl_list_remove(&child->surface_map.link);
-        wl_list_remove(&child->surface_unmap.link);
-        wl_list_remove(&child->view_unmap.link);
-        wl_list_remove(&child->surface_new_subsurface.link);
-
-        if (child->impl && child->impl->destroy) {
-                child->impl->destroy(child);
-        } else {
-                free(child);
+        // only make sure to clip the content if there is content to clip
+        if (!wl_list_empty(&con->view->content_tree->children)) {
+                wlr_scene_subsurface_tree_set_clip(&con->view->content_tree->node, &(struct wlr_box){
+                        .x = con->view->geometry.x,
+                        .y = con->view->geometry.y,
+                        .width = con->current.content_width,
+                        .height = con->current.content_height,
+                });
         }
 }
 
 struct sway_view *view_from_wlr_surface(struct wlr_surface *wlr_surface) {
-        if (wlr_surface_is_xdg_surface(wlr_surface)) {
-                struct wlr_xdg_surface *xdg_surface =
-                        wlr_xdg_surface_from_wlr_surface(wlr_surface);
+        struct wlr_xdg_surface *xdg_surface;
+        if ((xdg_surface = wlr_xdg_surface_try_from_wlr_surface(wlr_surface))) {
                 return view_from_wlr_xdg_surface(xdg_surface);
         }
 #if HAVE_XWAYLAND
-        if (wlr_surface_is_xwayland_surface(wlr_surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                        wlr_xwayland_surface_from_wlr_surface(wlr_surface);
+        struct wlr_xwayland_surface *xsurface;
+        if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(wlr_surface))) {
                 return view_from_wlr_xwayland_surface(xsurface);
         }
 #endif
-        if (wlr_surface_is_subsurface(wlr_surface)) {
-                struct wlr_subsurface *subsurface =
-                        wlr_subsurface_from_wlr_surface(wlr_surface);
+        struct wlr_subsurface *subsurface;
+        if ((subsurface = wlr_subsurface_try_from_wlr_surface(wlr_surface))) {
                 return view_from_wlr_surface(subsurface->parent);
         }
-        if (wlr_surface_is_layer_surface(wlr_surface)) {
+        if (wlr_layer_surface_v1_try_from_wlr_surface(wlr_surface) != NULL) {
                 return NULL;
         }
 
@@ -1196,6 +1045,18 @@ static size_t parse_title_format(struct sway_view *view, char *buffer) {
         return len;
 }
 
+void view_update_app_id(struct sway_view *view) {
+        const char *app_id = view_get_app_id(view);
+
+        if (view->foreign_toplevel && app_id) {
+                wlr_foreign_toplevel_handle_v1_set_app_id(view->foreign_toplevel, app_id);
+        }
+
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
+}
+
 void view_update_title(struct sway_view *view, bool force) {
         const char *title = view_get_title(view);
 
@@ -1211,46 +1072,56 @@ void view_update_title(struct sway_view *view, bool force) {
 
         free(view->container->title);
         free(view->container->formatted_title);
-        if (title) {
-                size_t len = parse_title_format(view, NULL);
+
+        size_t len = parse_title_format(view, NULL);
+
+        if (len) {
                 char *buffer = calloc(len + 1, sizeof(char));
                 if (!sway_assert(buffer, "Unable to allocate title string")) {
                         return;
                 }
-                parse_title_format(view, buffer);
 
-                view->container->title = strdup(title);
+                parse_title_format(view, buffer);
                 view->container->formatted_title = buffer;
         } else {
-                view->container->title = NULL;
                 view->container->formatted_title = NULL;
         }
-        container_calculate_title_height(view->container);
-        config_update_font_height(false);
+
+        view->container->title = title ? strdup(title) : NULL;
 
         // Update title after the global font height is updated
-        container_update_title_textures(view->container);
+        if (view->container->title_bar.title_text && len) {
+                sway_text_node_set_text(view->container->title_bar.title_text,
+                        view->container->formatted_title);
+                container_arrange_title_bar(view->container);
+        } else {
+                container_update_title_bar(view->container);
+        }
 
         ipc_event_window(view->container, "title");
 
         if (view->foreign_toplevel && title) {
                 wlr_foreign_toplevel_handle_v1_set_title(view->foreign_toplevel, title);
         }
+
+        if (view->ext_foreign_toplevel) {
+                update_ext_foreign_toplevel(view);
+        }
 }
 
 bool view_is_visible(struct sway_view *view) {
         if (view->container->node.destroying) {
                 return false;
         }
-        struct sway_workspace *workspace = view->container->workspace;
-        if (!workspace && view->container->fullscreen_mode != FULLSCREEN_GLOBAL) {
+        struct sway_workspace *workspace = view->container->pending.workspace;
+        if (!workspace && view->container->pending.fullscreen_mode != FULLSCREEN_GLOBAL) {
                 bool fs_global_descendant = false;
-                struct sway_container *parent = view->container->parent;
+                struct sway_container *parent = view->container->pending.parent;
                 while (parent) {
-                        if (parent->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                        if (parent->pending.fullscreen_mode == FULLSCREEN_GLOBAL) {
                                 fs_global_descendant = true;
                         }
-                        parent = parent->parent;
+                        parent = parent->pending.parent;
                 }
                 if (!fs_global_descendant) {
                         return false;
@@ -1268,13 +1139,13 @@ bool view_is_visible(struct sway_view *view) {
                 enum sway_container_layout layout = container_parent_layout(con);
                 if ((layout == L_TABBED || layout == L_STACKED)
                                 && !container_is_floating(con)) {
-                        struct sway_node *parent = con->parent ?
-                                &con->parent->node : &con->workspace->node;
+                        struct sway_node *parent = con->pending.parent ?
+                                &con->pending.parent->node : &con->pending.workspace->node;
                         if (seat_get_active_tiling_child(seat, parent) != &con->node) {
                                 return false;
                         }
                 }
-                con = con->parent;
+                con = con->pending.parent;
         }
         // Check view isn't hidden by another fullscreen view
         struct sway_container *fs = root->fullscreen_global ?
@@ -1296,6 +1167,7 @@ void view_set_urgent(struct sway_view *view, bool enable) {
                         return;
                 }
                 clock_gettime(CLOCK_MONOTONIC, &view->urgent);
+                container_update_itself_and_parents(view->container);
         } else {
                 view->urgent = (struct timespec){ 0 };
                 if (view->urgent_timer) {
@@ -1303,12 +1175,11 @@ void view_set_urgent(struct sway_view *view, bool enable) {
                         view->urgent_timer = NULL;
                 }
         }
-        container_damage_whole(view->container);
 
         ipc_event_window(view->container, "urgent");
 
         if (!container_is_scratchpad_hidden(view->container)) {
-                workspace_detect_urgent(view->container->workspace);
+                workspace_detect_urgent(view->container->pending.workspace);
         }
 }
 
@@ -1317,40 +1188,54 @@ bool view_is_urgent(struct sway_view *view) {
 }
 
 void view_remove_saved_buffer(struct sway_view *view) {
-        if (!sway_assert(!wl_list_empty(&view->saved_buffers), "Expected a saved buffer")) {
+        if (!sway_assert(view->saved_surface_tree, "Expected a saved buffer")) {
                 return;
         }
-        struct sway_saved_buffer *saved_buf, *tmp;
-        wl_list_for_each_safe(saved_buf, tmp, &view->saved_buffers, link) {
-                wlr_buffer_unlock(&saved_buf->buffer->base);
-                wl_list_remove(&saved_buf->link);
-                free(saved_buf);
-        }
+
+        wlr_scene_node_destroy(&view->saved_surface_tree->node);
+        view->saved_surface_tree = NULL;
+        wlr_scene_node_set_enabled(&view->content_tree->node, true);
 }
 
-static void view_save_buffer_iterator(struct wlr_surface *surface,
+static void view_save_buffer_iterator(struct wlr_scene_buffer *buffer,
                 int sx, int sy, void *data) {
-        struct sway_view *view = data;
-
-        if (surface && wlr_surface_has_buffer(surface)) {
-                wlr_buffer_lock(&surface->buffer->base);
-                struct sway_saved_buffer *saved_buffer = calloc(1, sizeof(struct sway_saved_buffer));
-                saved_buffer->buffer = surface->buffer;
-                saved_buffer->width = surface->current.width;
-                saved_buffer->height = surface->current.height;
-                saved_buffer->x = sx;
-                saved_buffer->y = sy;
-                saved_buffer->transform = surface->current.transform;
-                wlr_surface_get_buffer_source_box(surface, &saved_buffer->source_box);
-                wl_list_insert(&view->saved_buffers, &saved_buffer->link);
+        struct wlr_scene_tree *tree = data;
+
+        struct wlr_scene_buffer *sbuf = wlr_scene_buffer_create(tree, NULL);
+        if (!sbuf) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene buffer when saving a surface");
+                return;
         }
+
+        wlr_scene_buffer_set_dest_size(sbuf,
+                buffer->dst_width, buffer->dst_height);
+        wlr_scene_buffer_set_opaque_region(sbuf, &buffer->opaque_region);
+        wlr_scene_buffer_set_source_box(sbuf, &buffer->src_box);
+        wlr_scene_node_set_position(&sbuf->node, sx, sy);
+        wlr_scene_buffer_set_transform(sbuf, buffer->transform);
+        wlr_scene_buffer_set_buffer(sbuf, buffer->buffer);
 }
 
 void view_save_buffer(struct sway_view *view) {
-        if (!sway_assert(wl_list_empty(&view->saved_buffers), "Didn't expect saved buffer")) {
+        if (!sway_assert(!view->saved_surface_tree, "Didn't expect saved buffer")) {
                 view_remove_saved_buffer(view);
         }
-        view_for_each_surface(view, view_save_buffer_iterator, view);
+
+        view->saved_surface_tree = wlr_scene_tree_create(view->scene_tree);
+        if (!view->saved_surface_tree) {
+                sway_log(SWAY_ERROR, "Could not allocate a scene tree node when saving a surface");
+                return;
+        }
+
+        // Enable and disable the saved surface tree like so to atomitaclly update
+        // the tree. This will prevent over damaging or other weirdness.
+        wlr_scene_node_set_enabled(&view->saved_surface_tree->node, false);
+
+        wlr_scene_node_for_each_buffer(&view->content_tree->node,
+                view_save_buffer_iterator, view->saved_surface_tree);
+
+        wlr_scene_node_set_enabled(&view->content_tree->node, false);
+        wlr_scene_node_set_enabled(&view->saved_surface_tree->node, true);
 }
 
 bool view_is_transient_for(struct sway_view *child,
@@ -1358,3 +1243,19 @@ bool view_is_transient_for(struct sway_view *child,
         return child->impl->is_transient_for &&
                 child->impl->is_transient_for(child, ancestor);
 }
+
+static void send_frame_done_iterator(struct wlr_scene_buffer *scene_buffer,
+                int x, int y, void *data) {
+        struct timespec *when = data;
+        wl_signal_emit_mutable(&scene_buffer->events.frame_done, when);
+}
+
+void view_send_frame_done(struct sway_view *view) {
+        struct timespec when;
+        clock_gettime(CLOCK_MONOTONIC, &when);
+
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &view->content_tree->children, link) {
+                wlr_scene_node_for_each_buffer(node, send_frame_done_iterator, &when);
+        }
+}