1 files changed, 225 insertions, 384 deletions

diff --git a/sway/tree/view.c b/sway/tree/view.c
index fcdd06f7..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) {
@@ -57,11 +75,10 @@ void view_destroy(struct sway_view *view) {
                 return;
         }
         wl_list_remove(&view->events.unmap.listener_list);
-        if (!wl_list_empty(&view->saved_buffers)) {
-                view_remove_saved_buffer(view);
-        }
         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) {
@@ -362,17 +379,17 @@ void view_set_activated(struct sway_view *view, bool activated) {
         }
 }
 
-void view_request_activate(struct sway_view *view) {
+void view_request_activate(struct sway_view *view, struct sway_seat *seat) {
         struct sway_workspace *ws = view->container->pending.workspace;
-        if (!ws) { // hidden scratchpad container
-                return;
+        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);
                 }
@@ -381,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) {
@@ -432,52 +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_child_init_subsurfaces(struct sway_view_child *view_child,
-        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) {
@@ -519,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
@@ -532,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();
 
@@ -567,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;
         }
 
@@ -591,6 +589,14 @@ 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);
@@ -716,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
@@ -729,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);
@@ -749,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);
@@ -764,11 +796,6 @@ 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);
         }
@@ -812,9 +839,8 @@ 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);
+        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;
         }
@@ -824,6 +850,10 @@ 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) {
@@ -834,15 +864,20 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
 }
 
 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;
@@ -889,293 +924,47 @@ void view_update_size(struct sway_view *view) {
         container_set_geometry_from_content(con);
 }
 
-void view_center_surface(struct sway_view *view) {
+void view_center_and_clip_surface(struct sway_view *view) {
         struct sway_container *con = view->container;
-        // We always center the current coordinates rather than the next, as the
-        // geometry immediately affects the currently active rendering.
-        con->surface_x = fmax(con->current.content_x, con->current.content_x +
-                        (con->current.content_width - view->geometry.width) / 2);
-        con->surface_y = fmax(con->current.content_y, con->current.content_y +
-                        (con->current.content_height - view->geometry.height) / 2);
-}
-
-static const struct sway_view_child_impl subsurface_impl;
 
-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 bool view_child_is_mapped(struct sway_view_child *child) {
-        while (child) {
-                if (!child->mapped) {
-                        return false;
-                }
-                child = child->parent;
-        }
-        return true;
-}
-
-static void view_child_damage(struct sway_view_child *child, bool whole) {
-        if (!child || !view_child_is_mapped(child) || !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->pending.content_x + sx,
-                        child->view->container->pending.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_below, parent_link) {
-                view_subsurface_create(view, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->subsurfaces_above, parent_link) {
-                view_subsurface_create(view, subsurface);
-        }
-}
-
-static void view_child_init_subsurfaces(struct sway_view_child *view_child,
-                struct wlr_surface *surface) {
-        struct wlr_subsurface *subsurface;
-        wl_list_for_each(subsurface, &surface->subsurfaces_below, parent_link) {
-                view_child_subsurface_create(view_child, subsurface);
-        }
-        wl_list_for_each(subsurface, &surface->subsurfaces_above, parent_link) {
-                view_child_subsurface_create(view_child, 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->pending.workspace;
-        if (workspace) {
-                wlr_surface_send_enter(child->surface, workspace->output->wlr_output);
-        }
-
-        view_child_init_subsurfaces(child, surface);
-}
-
-void view_child_destroy(struct sway_view_child *child) {
-        if (view_child_is_mapped(child) && 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;
-                // The subchild lost its parent link, so it cannot see that the parent
-                // is unmapped. Unmap it directly.
-                subchild->mapped = false;
-        }
-
-        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);
-                if (xdg_surface == NULL) {
-                        return NULL;
-                }
+        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);
-                if (xsurface == NULL) {
-                        return NULL;
-                }
+        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);
-                if (subsurface == NULL) {
-                        return NULL;
-                }
+        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;
         }
 
@@ -1256,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);
 
@@ -1271,31 +1072,41 @@ 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) {
@@ -1356,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) {
@@ -1363,7 +1175,6 @@ 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");
 
@@ -1377,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 = view->container->surface_x + sx;
-                saved_buffer->y = view->container->surface_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,
@@ -1418,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);
+        }
+}