1 files changed, 93 insertions, 81 deletions

diff --git a/sway/tree/workspace.c b/sway/tree/workspace.c
index 921b7d19..40d33435 100644
--- a/sway/tree/workspace.c
+++ b/sway/tree/workspace.c
@@ -48,14 +48,16 @@ struct sway_output *workspace_get_initial_output(const char *name) {
         if (focus && focus->type == N_WORKSPACE) {
                 return focus->sway_workspace->output;
         } else if (focus && focus->type == N_CONTAINER) {
-                return focus->sway_container->workspace->output;
+                return focus->sway_container->pending.workspace->output;
         }
-        // Fallback to the first output or noop output for headless
-        return root->outputs->length ? root->outputs->items[0] : root->noop_output;
+        // Fallback to the first output or the headless output
+        return root->outputs->length ? root->outputs->items[0] : root->fallback_output;
 }
 
 struct sway_workspace *workspace_create(struct sway_output *output,
                 const char *name) {
+        sway_assert(name, "NULL name given to workspace_create");
+
         if (output == NULL) {
                 output = workspace_get_initial_output(name);
         }
@@ -69,7 +71,19 @@ struct sway_workspace *workspace_create(struct sway_output *output,
                 return NULL;
         }
         node_init(&ws->node, N_WORKSPACE, ws);
-        ws->name = name ? strdup(name) : NULL;
+
+        bool failed = false;
+        ws->layers.tiling = alloc_scene_tree(root->staging, &failed);
+        ws->layers.fullscreen = alloc_scene_tree(root->staging, &failed);
+
+        if (failed) {
+                wlr_scene_node_destroy(&ws->layers.tiling->node);
+                wlr_scene_node_destroy(&ws->layers.fullscreen->node);
+                free(ws);
+                return NULL;
+        }
+
+        ws->name = strdup(name);
         ws->prev_split_layout = L_NONE;
         ws->layout = output_get_default_layout(output);
         ws->floating = create_list();
@@ -114,7 +128,7 @@ struct sway_workspace *workspace_create(struct sway_output *output,
         output_sort_workspaces(output);
 
         ipc_event_workspace(NULL, ws, "init");
-        wl_signal_emit(&root->events.new_node, &ws->node);
+        wl_signal_emit_mutable(&root->events.new_node, &ws->node);
 
         return ws;
 }
@@ -129,6 +143,11 @@ void workspace_destroy(struct sway_workspace *workspace) {
                 return;
         }
 
+        scene_node_disown_children(workspace->layers.tiling);
+        scene_node_disown_children(workspace->layers.fullscreen);
+        wlr_scene_node_destroy(&workspace->layers.tiling->node);
+        wlr_scene_node_destroy(&workspace->layers.fullscreen->node);
+
         free(workspace->name);
         free(workspace->representation);
         list_free_items_and_destroy(workspace->output_priority);
@@ -142,7 +161,7 @@ void workspace_destroy(struct sway_workspace *workspace) {
 void workspace_begin_destroy(struct sway_workspace *workspace) {
         sway_log(SWAY_DEBUG, "Destroying workspace '%s'", workspace->name);
         ipc_event_workspace(NULL, workspace, "empty"); // intentional
-        wl_signal_emit(&workspace->node.events.destroy, &workspace->node);
+        wl_signal_emit_mutable(&workspace->node.events.destroy, &workspace->node);
 
         if (workspace->output) {
                 workspace_detach(workspace);
@@ -174,22 +193,16 @@ void workspace_consider_destroy(struct sway_workspace *ws) {
 static bool workspace_valid_on_output(const char *output_name,
                 const char *ws_name) {
         struct workspace_config *wsc = workspace_find_config(ws_name);
-        char identifier[128];
         struct sway_output *output = output_by_name_or_id(output_name);
         if (!output) {
                 return false;
         }
-        output_name = output->wlr_output->name;
-        output_get_identifier(identifier, sizeof(identifier), output);
-
         if (!wsc) {
                 return true;
         }
 
         for (int i = 0; i < wsc->outputs->length; i++) {
-                if (strcmp(wsc->outputs->items[i], "*") == 0 ||
-                                strcmp(wsc->outputs->items[i], output_name) == 0 ||
-                                strcmp(wsc->outputs->items[i], identifier) == 0) {
+                if (output_match_name_or_id(output, wsc->outputs->items[i])) {
                         return true;
                 }
         }
@@ -222,10 +235,8 @@ static void workspace_name_from_binding(const struct sway_binding * binding,
                 // not a command about workspaces
                 if (strcmp(_target, "next") == 0 ||
                                 strcmp(_target, "prev") == 0 ||
-                                strncmp(_target, "next_on_output",
-                                        strlen("next_on_output")) == 0 ||
-                                strncmp(_target, "prev_on_output",
-                                        strlen("next_on_output")) == 0 ||
+                                strcmp(_target, "next_on_output") == 0 ||
+                                strcmp(_target, "prev_on_output") == 0 ||
                                 strcmp(_target, "number") == 0 ||
                                 strcmp(_target, "back_and_forth") == 0 ||
                                 strcmp(_target, "current") == 0) {
@@ -286,13 +297,10 @@ char *workspace_next_name(const char *output_name) {
         // assignments primarily, falling back to bindings and numbers.
         struct sway_mode *mode = config->current_mode;
 
-        char identifier[128];
         struct sway_output *output = output_by_name_or_id(output_name);
         if (!output) {
                 return NULL;
         }
-        output_name = output->wlr_output->name;
-        output_get_identifier(identifier, sizeof(identifier), output);
 
         int order = INT_MAX;
         char *target = NULL;
@@ -312,9 +320,7 @@ char *workspace_next_name(const char *output_name) {
                 }
                 bool found = false;
                 for (int j = 0; j < wsc->outputs->length; ++j) {
-                        if (strcmp(wsc->outputs->items[j], "*") == 0 ||
-                                        strcmp(wsc->outputs->items[j], output_name) == 0 ||
-                                        strcmp(wsc->outputs->items[j], identifier) == 0) {
+                        if (output_match_name_or_id(output, wsc->outputs->items[j])) {
                                 found = true;
                                 free(target);
                                 target = strdup(wsc->workspace);
@@ -363,11 +369,11 @@ struct sway_workspace *workspace_by_name(const char *name) {
         if (current && strcmp(name, "prev") == 0) {
                 return workspace_prev(current);
         } else if (current && strcmp(name, "prev_on_output") == 0) {
-                return workspace_output_prev(current, false);
+                return workspace_output_prev(current);
         } else if (current && strcmp(name, "next") == 0) {
                 return workspace_next(current);
         } else if (current && strcmp(name, "next_on_output") == 0) {
-                return workspace_output_next(current, false);
+                return workspace_output_next(current);
         } else if (strcmp(name, "current") == 0) {
                 return current;
         } else if (strcasecmp(name, "back_and_forth") == 0) {
@@ -530,7 +536,7 @@ struct sway_workspace *workspace_next(struct sway_workspace *workspace) {
  * otherwise the next one is returned.
  */
 static struct sway_workspace *workspace_output_prev_next_impl(
-                struct sway_output *output, int dir, bool create) {
+                struct sway_output *output, int dir) {
         struct sway_seat *seat = input_manager_current_seat();
         struct sway_workspace *workspace = seat_get_focused_workspace(seat);
         if (!workspace) {
@@ -540,46 +546,43 @@ static struct sway_workspace *workspace_output_prev_next_impl(
         }
 
         int index = list_find(output->workspaces, workspace);
-        if (!workspace_is_empty(workspace) && create &&
-                        (index + dir < 0 || index + dir == output->workspaces->length)) {
-                struct sway_output *output = workspace->output;
-                char *next = workspace_next_name(output->wlr_output->name);
-                workspace_create(output, next);
-                free(next);
-        }
         size_t new_index = wrap(index + dir, output->workspaces->length);
         return output->workspaces->items[new_index];
 }
 
-struct sway_workspace *workspace_output_next(
-                struct sway_workspace *current, bool create) {
-        return workspace_output_prev_next_impl(current->output, 1, create);
+
+struct sway_workspace *workspace_output_next(struct sway_workspace *current) {
+        return workspace_output_prev_next_impl(current->output, 1);
 }
 
-struct sway_workspace *workspace_output_prev(
-                struct sway_workspace *current, bool create) {
-        return workspace_output_prev_next_impl(current->output, -1, create);
+struct sway_workspace *workspace_output_prev(struct sway_workspace *current) {
+        return workspace_output_prev_next_impl(current->output, -1);
 }
 
-bool workspace_switch(struct sway_workspace *workspace,
-                bool no_auto_back_and_forth) {
+struct sway_workspace *workspace_auto_back_and_forth(
+                struct sway_workspace *workspace) {
         struct sway_seat *seat = input_manager_current_seat();
         struct sway_workspace *active_ws = NULL;
         struct sway_node *focus = seat_get_focus_inactive(seat, &root->node);
         if (focus && focus->type == N_WORKSPACE) {
                 active_ws = focus->sway_workspace;
         } else if (focus && focus->type == N_CONTAINER) {
-                active_ws = focus->sway_container->workspace;
+                active_ws = focus->sway_container->pending.workspace;
         }
 
-        if (!no_auto_back_and_forth && config->auto_back_and_forth && active_ws
-                        && active_ws == workspace && seat->prev_workspace_name) {
+        if (config->auto_back_and_forth && active_ws && active_ws == workspace &&
+                        seat->prev_workspace_name) {
                 struct sway_workspace *new_ws =
                         workspace_by_name(seat->prev_workspace_name);
                 workspace = new_ws ?
                         new_ws :
                         workspace_create(NULL, seat->prev_workspace_name);
         }
+        return workspace;
+}
+
+bool workspace_switch(struct sway_workspace *workspace) {
+        struct sway_seat *seat = input_manager_current_seat();
 
         sway_log(SWAY_DEBUG, "Switching to workspace %p:%s",
                 workspace, workspace->name);
@@ -657,15 +660,9 @@ void workspace_output_add_priority(struct sway_workspace *workspace,
 
 struct sway_output *workspace_output_get_highest_available(
                 struct sway_workspace *ws, struct sway_output *exclude) {
-        char exclude_id[128] = {'\0'};
-        if (exclude) {
-                output_get_identifier(exclude_id, sizeof(exclude_id), exclude);
-        }
-
         for (int i = 0; i < ws->output_priority->length; i++) {
-                char *name = ws->output_priority->items[i];
-                if (exclude && (strcmp(name, exclude->wlr_output->name) == 0
-                                        || strcmp(name, exclude_id) == 0)) {
+                const char *name = ws->output_priority->items[i];
+                if (exclude && output_match_name_or_id(exclude, name)) {
                         continue;
                 }
 
@@ -689,7 +686,6 @@ void workspace_detect_urgent(struct sway_workspace *workspace) {
         if (workspace->urgent != new_urgent) {
                 workspace->urgent = new_urgent;
                 ipc_event_workspace(NULL, workspace, "urgent");
-                output_damage_whole(workspace->output);
         }
 }
 
@@ -736,13 +732,13 @@ struct sway_container *workspace_find_container(struct sway_workspace *ws,
 }
 
 static void set_workspace(struct sway_container *container, void *data) {
-        container->workspace = container->parent->workspace;
+        container->pending.workspace = container->pending.parent->pending.workspace;
 }
 
 static void workspace_attach_tiling(struct sway_workspace *ws,
                 struct sway_container *con) {
         list_add(ws->tiling, con);
-        con->workspace = ws;
+        con->pending.workspace = ws;
         container_for_each_child(con, set_workspace, NULL);
         container_handle_fullscreen_reparent(con);
         workspace_update_representation(ws);
@@ -753,7 +749,7 @@ static void workspace_attach_tiling(struct sway_workspace *ws,
 struct sway_container *workspace_wrap_children(struct sway_workspace *ws) {
         struct sway_container *fs = ws->fullscreen;
         struct sway_container *middle = container_create(NULL);
-        middle->layout = ws->layout;
+        middle->pending.layout = ws->layout;
         while (ws->tiling->length) {
                 struct sway_container *child = ws->tiling->items[0];
                 container_detach(child);
@@ -771,9 +767,9 @@ void workspace_unwrap_children(struct sway_workspace *ws,
                 return;
         }
 
-        ws->layout = wrap->layout;
-        while (wrap->children->length) {
-                struct sway_container *child = wrap->children->items[0];
+        ws->layout = wrap->pending.layout;
+        while (wrap->pending.children->length) {
+                struct sway_container *child = wrap->pending.children->items[0];
                 container_detach(child);
                 workspace_add_tiling(ws, child);
         }
@@ -793,14 +789,18 @@ void workspace_detach(struct sway_workspace *workspace) {
 
 struct sway_container *workspace_add_tiling(struct sway_workspace *workspace,
                 struct sway_container *con) {
-        if (con->workspace) {
+        if (con->pending.workspace) {
+                struct sway_container *old_parent = con->pending.parent;
                 container_detach(con);
+                if (old_parent) {
+                        container_reap_empty(old_parent);
+                }
         }
         if (config->default_layout != L_NONE) {
                 con = container_split(con, config->default_layout);
         }
         list_add(workspace->tiling, con);
-        con->workspace = workspace;
+        con->pending.workspace = workspace;
         container_for_each_child(con, set_workspace, NULL);
         container_handle_fullscreen_reparent(con);
         workspace_update_representation(workspace);
@@ -811,11 +811,11 @@ struct sway_container *workspace_add_tiling(struct sway_workspace *workspace,
 
 void workspace_add_floating(struct sway_workspace *workspace,
                 struct sway_container *con) {
-        if (con->workspace) {
+        if (con->pending.workspace) {
                 container_detach(con);
         }
         list_add(workspace->floating, con);
-        con->workspace = workspace;
+        con->pending.workspace = workspace;
         container_for_each_child(con, set_workspace, NULL);
         container_handle_fullscreen_reparent(con);
         node_set_dirty(&workspace->node);
@@ -825,7 +825,7 @@ void workspace_add_floating(struct sway_workspace *workspace,
 void workspace_insert_tiling_direct(struct sway_workspace *workspace,
                 struct sway_container *con, int index) {
         list_insert(workspace->tiling, index, con);
-        con->workspace = workspace;
+        con->pending.workspace = workspace;
         container_for_each_child(con, set_workspace, NULL);
         container_handle_fullscreen_reparent(con);
         workspace_update_representation(workspace);
@@ -835,7 +835,7 @@ void workspace_insert_tiling_direct(struct sway_workspace *workspace,
 
 struct sway_container *workspace_insert_tiling(struct sway_workspace *workspace,
                 struct sway_container *con, int index) {
-        if (con->workspace) {
+        if (con->pending.workspace) {
                 container_detach(con);
         }
         if (config->default_layout != L_NONE) {
@@ -845,24 +845,36 @@ struct sway_container *workspace_insert_tiling(struct sway_workspace *workspace,
         return con;
 }
 
+bool workspace_has_single_visible_container(struct sway_workspace *ws) {
+        struct sway_seat *seat = input_manager_get_default_seat();
+        struct sway_container *focus =
+                seat_get_focus_inactive_tiling(seat, ws);
+        if (focus && !focus->view) {
+                focus = seat_get_focus_inactive_view(seat, &focus->node);
+        }
+        return (focus && focus->view && view_ancestor_is_only_visible(focus->view));
+}
+
 void workspace_add_gaps(struct sway_workspace *ws) {
-        if (config->smart_gaps) {
-                struct sway_seat *seat = input_manager_get_default_seat();
-                struct sway_container *focus =
-                        seat_get_focus_inactive_tiling(seat, ws);
-                if (focus && !focus->view) {
-                        focus = seat_get_focus_inactive_view(seat, &focus->node);
-                }
-                if (focus && focus->view && view_ancestor_is_only_visible(focus->view)) {
-                        ws->current_gaps.top = 0;
-                        ws->current_gaps.right = 0;
-                        ws->current_gaps.bottom = 0;
-                        ws->current_gaps.left = 0;
-                        return;
-                }
+        if (config->smart_gaps == SMART_GAPS_ON
+                        && workspace_has_single_visible_container(ws)) {
+                ws->current_gaps.top = 0;
+                ws->current_gaps.right = 0;
+                ws->current_gaps.bottom = 0;
+                ws->current_gaps.left = 0;
+                return;
+        }
+
+        if (config->smart_gaps == SMART_GAPS_INVERSE_OUTER
+                        && !workspace_has_single_visible_container(ws)) {
+                ws->current_gaps.top = 0;
+                ws->current_gaps.right = 0;
+                ws->current_gaps.bottom = 0;
+                ws->current_gaps.left = 0;
+        } else {
+                ws->current_gaps = ws->gaps_outer;
         }
 
-        ws->current_gaps = ws->gaps_outer;
         // Add inner gaps and make sure we don't turn out negative
         ws->current_gaps.top = fmax(0, ws->current_gaps.top + ws->gaps_inner);
         ws->current_gaps.right = fmax(0, ws->current_gaps.right + ws->gaps_inner);
@@ -905,7 +917,7 @@ struct sway_container *workspace_split(struct sway_workspace *workspace,
         enum sway_container_layout old_layout = workspace->layout;
         struct sway_container *middle = workspace_wrap_children(workspace);
         workspace->layout = layout;
-        middle->layout = old_layout;
+        middle->pending.layout = old_layout;
 
         struct sway_seat *seat;
         wl_list_for_each(seat, &server.input->seats, link) {