Fix scratchpad fullscreen behavior and crash

When setting fullscreen on a hidden scratchpad container, there was a
check to see if there was an existing fullscreen container on the
workspace so it could be fullscreen disabled first. Since the workspace
is NULL, it would cause a SIGSEGV. This adds a NULL check to avoid the
crash.

This also changes the behavior of how fullscreen is handled when adding
a container to the scratchpad or changing visibility of a scratchpad
container to match i3's. The behavior is as follows:
- When adding a container to the scratchpad or hiding a container back
  into the scratchpad, there is an implicit fullscreen disable
- When setting fullscreen on a container that is hidden in the
  scratchpad, it will be fullscreen when shown (and fullscreen disabled
  when hidden as stated above)
- When setting fullscreen global on a container that is hidden in the
  scratchpad, it will be shown immediately as fullscreen global. The
  container is not moved to a workspace and remains in the
  scratchpad. The container will be visible until fullscreen disabled
  or killed. Since the container is in the scratchpad, running
  `scratchpad show` or `move container to scratchpad` will have no
  effect

This also changes `container_replace` to transfer fullscreen and
scratchpad status.

13 files changed, 215 insertions, 57 deletions

diff --git a/sway/commands/floating.c b/sway/commands/floating.c
index 5df9b1bf..ce123345 100644
--- a/sway/commands/floating.c
+++ b/sway/commands/floating.c
@@ -32,6 +32,11 @@ struct cmd_results *cmd_floating(int argc, char **argv) {
                 seat_set_focus_container(config->handler_context.seat, container);
         }
 
+        if (container_is_scratchpad_hidden(container)) {
+                return cmd_results_new(CMD_INVALID,
+                                "Can't change floating on hidden scratchpad container");
+        }
+
         // If the container is in a floating split container,
         // operate on the split container instead of the child.
         if (container_is_floating_or_child(container)) {
diff --git a/sway/commands/focus.c b/sway/commands/focus.c
index 14e90955..8baa616d 100644
--- a/sway/commands/focus.c
+++ b/sway/commands/focus.c
@@ -182,6 +182,10 @@ static struct sway_node *node_get_in_direction_floating(
         double closest_distance = DBL_MAX;
         struct sway_container *closest_con = NULL;
 
+        if (!con->workspace) {
+                return NULL;
+        }
+
         for (int i = 0; i < con->workspace->floating->length; i++) {
                 struct sway_container *floater = con->workspace->floating->items[i];
                 if (floater == con) {
diff --git a/sway/commands/fullscreen.c b/sway/commands/fullscreen.c
index 52248ce4..a268ba03 100644
--- a/sway/commands/fullscreen.c
+++ b/sway/commands/fullscreen.c
@@ -26,6 +26,13 @@ struct cmd_results *cmd_fullscreen(int argc, char **argv) {
                                 "Can't fullscreen an empty workspace");
         }
 
+        // If in the scratchpad, operate on the highest container
+        if (container && !container->workspace) {
+                while (container->parent) {
+                        container = container->parent;
+                }
+        }
+
         bool is_fullscreen = container &&
                 container->fullscreen_mode != FULLSCREEN_NONE;
         bool global = false;
diff --git a/sway/commands/layout.c b/sway/commands/layout.c
index 7d61c3be..32f8fb52 100644
--- a/sway/commands/layout.c
+++ b/sway/commands/layout.c
@@ -147,7 +147,11 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
                         workspace->layout = new_layout;
                         workspace_update_representation(workspace);
                 }
-                arrange_workspace(workspace);
+                if (root->fullscreen_global) {
+                        arrange_root();
+                } else {
+                        arrange_workspace(workspace);
+                }
         }
 
         return cmd_results_new(CMD_SUCCESS, NULL);
diff --git a/sway/commands/move.c b/sway/commands/move.c
index f642f023..4ebc949b 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -395,6 +395,11 @@ static struct cmd_results *cmd_move_container(int argc, char **argv) {
                 container = workspace_wrap_children(workspace);
         }
 
+        if (container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                return cmd_results_new(CMD_FAILURE,
+                                "Can't move fullscreen global container");
+        }
+
         bool no_auto_back_and_forth = false;
         while (strcasecmp(argv[0], "--no-auto-back-and-forth") == 0) {
                 no_auto_back_and_forth = true;
@@ -646,6 +651,10 @@ static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
         }
 
         struct sway_workspace *workspace = config->handler_context.workspace;
+        if (!workspace) {
+                return cmd_results_new(CMD_FAILURE, "No workspace to move");
+        }
+
         struct sway_output *old_output = workspace->output;
         int center_x = workspace->width / 2 + workspace->x,
                 center_y = workspace->height / 2 + workspace->y;
diff --git a/sway/commands/split.c b/sway/commands/split.c
index e9670722..8702f39e 100644
--- a/sway/commands/split.c
+++ b/sway/commands/split.c
@@ -13,7 +13,8 @@ static struct cmd_results *do_split(int layout) {
         struct sway_container *con = config->handler_context.container;
         struct sway_workspace *ws = config->handler_context.workspace;
         if (con) {
-                if (container_is_scratchpad_hidden(con)) {
+                if (container_is_scratchpad_hidden(con) &&
+                                con->fullscreen_mode != FULLSCREEN_GLOBAL) {
                         return cmd_results_new(CMD_FAILURE,
                                         "Cannot split a hidden scratchpad container");
                 }
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index 0b3e1edb..b1e3464a 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -251,14 +251,11 @@ static void output_for_each_surface(struct sway_output *output,
         };
 
         struct sway_workspace *workspace = output_get_active_workspace(output);
-        if (!workspace) {
-                return;
-        }
         struct sway_container *fullscreen_con = root->fullscreen_global;
-        if (fullscreen_con && container_is_scratchpad_hidden(fullscreen_con)) {
-                fullscreen_con = NULL;
-        }
         if (!fullscreen_con) {
+                if (!workspace) {
+                        return;
+                }
                 fullscreen_con = workspace->current.fullscreen;
         }
         if (fullscreen_con) {
diff --git a/sway/desktop/render.c b/sway/desktop/render.c
index 7216e30b..771bd908 100644
--- a/sway/desktop/render.c
+++ b/sway/desktop/render.c
@@ -997,9 +997,6 @@ void output_render(struct sway_output *output, struct timespec *when,
         }
 
         struct sway_container *fullscreen_con = root->fullscreen_global;
-        if (fullscreen_con && container_is_scratchpad_hidden(fullscreen_con)) {
-                fullscreen_con = NULL;
-        }
         if (!fullscreen_con) {
                 fullscreen_con = workspace->current.fullscreen;
         }
diff --git a/sway/input/seat.c b/sway/input/seat.c
index bdab8b81..ce009d7e 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -172,14 +172,14 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
 
         seat_node_destroy(seat_node);
 
-        if (!parent) {
+        if (!parent && !needs_new_focus) {
                 // Destroying a container that is no longer in the tree
                 return;
         }
 
         // Find new focus_inactive (ie. sibling, or workspace if no siblings left)
         struct sway_node *next_focus = NULL;
-        while (next_focus == NULL) {
+        while (next_focus == NULL && parent != NULL) {
                 struct sway_container *con =
                         seat_get_focus_inactive_view(seat, parent);
                 next_focus = con ? &con->node : NULL;
@@ -192,6 +192,16 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                 parent = node_get_parent(parent);
         }
 
+        if (!next_focus) {
+                struct sway_workspace *ws = seat_get_last_known_workspace(seat);
+                if (!ws) {
+                        return;
+                }
+                struct sway_container *con =
+                        seat_get_focus_inactive_view(seat, &ws->node);
+                next_focus = con ? &(con->node) : &(ws->node);
+        }
+
         if (next_focus->type == N_WORKSPACE &&
                         !workspace_is_visible(next_focus->sway_workspace)) {
                 // Do not change focus to a non-visible workspace
@@ -199,6 +209,10 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
         }
 
         if (needs_new_focus) {
+                // Make sure the workspace IPC event gets sent
+                if (node->type == N_CONTAINER && node->sway_container->scratchpad) {
+                        seat_set_focus(seat, NULL);
+                }
                 // The structure change might have caused it to move up to the top of
                 // the focus stack without sending focus notifications to the view
                 seat_send_focus(next_focus, seat);
@@ -207,7 +221,7 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                 // Setting focus_inactive
                 focus = seat_get_focus_inactive(seat, &root->node);
                 seat_set_raw_focus(seat, next_focus);
-                if (focus->type == N_CONTAINER) {
+                if (focus->type == N_CONTAINER && focus->sway_container->workspace) {
                         seat_set_raw_focus(seat, &focus->sway_container->workspace->node);
                 }
                 seat_set_raw_focus(seat, focus);
@@ -795,7 +809,13 @@ void seat_set_raw_focus(struct sway_seat *seat, struct sway_node *node) {
         wl_list_remove(&seat_node->link);
         wl_list_insert(&seat->focus_stack, &seat_node->link);
         node_set_dirty(node);
-        node_set_dirty(node_get_parent(node));
+
+        // If focusing a scratchpad container that is fullscreen global, parent
+        // will be NULL
+        struct sway_node *parent = node_get_parent(node);
+        if (parent) {
+                node_set_dirty(parent);
+        }
 }
 
 void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
@@ -850,7 +870,8 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
                 }
         }
 
-        struct sway_output *new_output = new_workspace->output;
+        struct sway_output *new_output =
+                new_workspace ? new_workspace->output : NULL;
 
         if (last_workspace != new_workspace && new_output) {
                 node_set_dirty(&new_output->node);
@@ -894,7 +915,8 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         }
 
         // Move sticky containers to new workspace
-        if (new_output_last_ws && new_workspace != new_output_last_ws) {
+        if (new_workspace && new_output_last_ws
+                        && new_workspace != new_output_last_ws) {
                 for (int i = 0; i < new_output_last_ws->floating->length; ++i) {
                         struct sway_container *floater =
                                 new_output_last_ws->floating->items[i];
@@ -940,7 +962,7 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
 
         seat->has_focus = true;
 
-        if (config->smart_gaps) {
+        if (config->smart_gaps && new_workspace) {
                 // When smart gaps is on, gaps may change when the focus changes so
                 // the workspace needs to be arranged
                 arrange_workspace(new_workspace);
@@ -1134,6 +1156,20 @@ struct sway_workspace *seat_get_focused_workspace(struct sway_seat *seat) {
         return NULL; // output doesn't have a workspace yet
 }
 
+struct sway_workspace *seat_get_last_known_workspace(struct sway_seat *seat) {
+        struct sway_seat_node *current;
+        wl_list_for_each(current, &seat->focus_stack, link) {
+                struct sway_node *node = current->node;
+                if (node->type == N_CONTAINER &&
+                                node->sway_container->workspace) {
+                        return node->sway_container->workspace;
+                } else if (node->type == N_WORKSPACE) {
+                        return node->sway_workspace;
+                }
+        }
+        return NULL;
+}
+
 struct sway_container *seat_get_focused_container(struct sway_seat *seat) {
         struct sway_node *focus = seat_get_focus(seat);
         if (focus && focus->type == N_CONTAINER) {
diff --git a/sway/tree/container.c b/sway/tree/container.c
index 02b4d1b0..11ed4f98 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -95,6 +95,10 @@ void container_begin_destroy(struct sway_container *con) {
         if (con->fullscreen_mode == FULLSCREEN_WORKSPACE && con->workspace) {
                 con->workspace->fullscreen = NULL;
         }
+        if (con->scratchpad && con->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                container_fullscreen_disable(con);
+        }
+
         wl_signal_emit(&con->node.events.destroy, &con->node);
 
         container_end_mouse_operation(con);
@@ -128,7 +132,9 @@ void container_reap_empty(struct sway_container *con) {
                 container_begin_destroy(con);
                 con = parent;
         }
-        workspace_consider_destroy(ws);
+        if (ws) {
+                workspace_consider_destroy(ws);
+        }
 }
 
 struct sway_container *container_flatten(struct sway_container *container) {
@@ -954,18 +960,20 @@ static void container_fullscreen_workspace(struct sway_container *con) {
         set_fullscreen_iterator(con, &enable);
         container_for_each_child(con, set_fullscreen_iterator, &enable);
 
-        con->workspace->fullscreen = con;
         con->saved_x = con->x;
         con->saved_y = con->y;
         con->saved_width = con->width;
         con->saved_height = con->height;
 
-        struct sway_seat *seat;
-        struct sway_workspace *focus_ws;
-        wl_list_for_each(seat, &server.input->seats, link) {
-                focus_ws = seat_get_focused_workspace(seat);
-                if (focus_ws == con->workspace) {
-                        seat_set_focus_container(seat, con);
+        if (con->workspace) {
+                con->workspace->fullscreen = con;
+                struct sway_seat *seat;
+                struct sway_workspace *focus_ws;
+                wl_list_for_each(seat, &server.input->seats, link) {
+                        focus_ws = seat_get_focused_workspace(seat);
+                        if (focus_ws == con->workspace) {
+                                seat_set_focus_container(seat, con);
+                        }
                 }
         }
 
@@ -1019,11 +1027,14 @@ void container_fullscreen_disable(struct sway_container *con) {
         con->height = con->saved_height;
 
         if (con->fullscreen_mode == FULLSCREEN_WORKSPACE) {
-                con->workspace->fullscreen = NULL;
-                if (container_is_floating(con)) {
-                        struct sway_output *output = container_floating_find_output(con);
-                        if (con->workspace->output != output) {
-                                container_floating_move_to_center(con);
+                if (con->workspace) {
+                        con->workspace->fullscreen = NULL;
+                        if (container_is_floating(con)) {
+                                struct sway_output *output =
+                                        container_floating_find_output(con);
+                                if (con->workspace->output != output) {
+                                        container_floating_move_to_center(con);
+                                }
                         }
                 }
         } else {
@@ -1040,6 +1051,17 @@ void container_fullscreen_disable(struct sway_container *con) {
         con->fullscreen_mode = FULLSCREEN_NONE;
         container_end_mouse_operation(con);
         ipc_event_window(con, "fullscreen_mode");
+
+        if (con->scratchpad) {
+                struct sway_seat *seat;
+                wl_list_for_each(seat, &server.input->seats, link) {
+                        struct sway_container *focus = seat_get_focused_container(seat);
+                        if (focus == con || container_has_ancestor(focus, con)) {
+                                seat_set_focus(seat,
+                                                seat_get_focus_inactive(seat, &root->node));
+                        }
+                }
+        }
 }
 
 void container_set_fullscreen(struct sway_container *con,
@@ -1056,7 +1078,7 @@ void container_set_fullscreen(struct sway_container *con,
                 if (root->fullscreen_global) {
                         container_fullscreen_disable(root->fullscreen_global);
                 }
-                if (con->workspace->fullscreen) {
+                if (con->workspace && con->workspace->fullscreen) {
                         container_fullscreen_disable(con->workspace->fullscreen);
                 }
                 container_fullscreen_workspace(con);
@@ -1171,6 +1193,11 @@ void container_add_gaps(struct sway_container *c) {
                         c->current_gaps.bottom > 0 || c->current_gaps.left > 0) {
                 return;
         }
+        // Fullscreen global scratchpad containers cannot have gaps
+        struct sway_workspace *ws = c->workspace;
+        if (!ws) {
+                return;
+        }
         // Linear containers don't have gaps because it'd create double gaps
         if (!c->view && c->layout != L_TABBED && c->layout != L_STACKED) {
                 return;
@@ -1199,8 +1226,6 @@ void container_add_gaps(struct sway_container *c) {
                 }
         }
 
-        struct sway_workspace *ws = c->workspace;
-
         c->current_gaps.top = c->y == ws->y ? ws->gaps_inner : 0;
         c->current_gaps.right = ws->gaps_inner;
         c->current_gaps.bottom = ws->gaps_inner;
@@ -1308,6 +1333,10 @@ void container_add_child(struct sway_container *parent,
         child->parent = parent;
         child->workspace = parent->workspace;
         container_for_each_child(child, set_workspace, NULL);
+        bool fullscreen = child->fullscreen_mode != FULLSCREEN_NONE ||
+                parent->fullscreen_mode != FULLSCREEN_NONE;
+        set_fullscreen_iterator(child, &fullscreen);
+        container_for_each_child(child, set_fullscreen_iterator, &fullscreen);
         container_handle_fullscreen_reparent(child);
         container_update_representation(parent);
         node_set_dirty(&child->node);
@@ -1347,8 +1376,31 @@ void container_detach(struct sway_container *child) {
 
 void container_replace(struct sway_container *container,
                 struct sway_container *replacement) {
+        enum sway_fullscreen_mode fullscreen = container->fullscreen_mode;
+        bool scratchpad = container->scratchpad;
+        if (fullscreen != FULLSCREEN_NONE) {
+                container_fullscreen_disable(container);
+        }
+        if (scratchpad) {
+                root_scratchpad_show(container);
+                root_scratchpad_remove_container(container);
+        }
         container_add_sibling(container, replacement, 1);
         container_detach(container);
+        if (scratchpad) {
+                root_scratchpad_add_container(replacement);
+        }
+        switch (fullscreen) {
+        case FULLSCREEN_WORKSPACE:
+                container_fullscreen_workspace(replacement);
+                break;
+        case FULLSCREEN_GLOBAL:
+                container_fullscreen_global(replacement);
+                break;
+        case FULLSCREEN_NONE:
+                // noop
+                break;
+        }
 }
 
 struct sway_container *container_split(struct sway_container *child,
@@ -1369,7 +1421,11 @@ struct sway_container *container_split(struct sway_container *child,
 
         if (set_focus) {
                 seat_set_raw_focus(seat, &cont->node);
-                seat_set_raw_focus(seat, &child->node);
+                if (cont->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                        seat_set_focus(seat, &child->node);
+                } else {
+                        seat_set_raw_focus(seat, &child->node);
+                }
         }
 
         return cont;
@@ -1529,7 +1585,7 @@ void container_raise_floating(struct sway_container *con) {
         while (floater->parent) {
                 floater = floater->parent;
         }
-        if (container_is_floating(floater)) {
+        if (container_is_floating(floater) && floater->workspace) {
                 list_move_to_end(floater->workspace->floating, floater);
                 node_set_dirty(&floater->workspace->node);
         }
diff --git a/sway/tree/node.c b/sway/tree/node.c
index dcab1c9b..ffa7f2cc 100644
--- a/sway/tree/node.c
+++ b/sway/tree/node.c
@@ -142,11 +142,19 @@ list_t *node_get_children(struct sway_node *node) {
 }
 
 bool node_has_ancestor(struct sway_node *node, struct sway_node *ancestor) {
+        if (ancestor->type == N_ROOT && node->type == N_CONTAINER &&
+                        node->sway_container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                return true;
+        }
         struct sway_node *parent = node_get_parent(node);
         while (parent) {
                 if (parent == ancestor) {
                         return true;
                 }
+                if (ancestor->type == N_ROOT && parent->type == N_CONTAINER &&
+                                parent->sway_container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                        return true;
+                }
                 parent = node_get_parent(parent);
         }
         return false;
diff --git a/sway/tree/root.c b/sway/tree/root.c
index a9d306a4..1dabc287 100644
--- a/sway/tree/root.c
+++ b/sway/tree/root.c
@@ -62,6 +62,11 @@ void root_scratchpad_add_container(struct sway_container *con) {
         struct sway_container *parent = con->parent;
         struct sway_workspace *workspace = con->workspace;
 
+        // Clear the fullscreen mode when sending to the scratchpad
+        if (con->fullscreen_mode != FULLSCREEN_NONE) {
+                container_fullscreen_disable(con);
+        }
+
         // When a tiled window is sent to scratchpad, center and resize it.
         if (!container_is_floating(con)) {
                 container_set_floating(con, true);
@@ -143,6 +148,15 @@ void root_scratchpad_hide(struct sway_container *con) {
         struct sway_node *focus = seat_get_focus_inactive(seat, &root->node);
         struct sway_workspace *ws = con->workspace;
 
+        if (con->fullscreen_mode == FULLSCREEN_GLOBAL && !con->workspace) {
+                // If the container was made fullscreen global while in the scratchpad,
+                // it should be shown until fullscreen has been disabled
+                return;
+        }
+
+        if (con->fullscreen_mode != FULLSCREEN_NONE) {
+                container_fullscreen_disable(con);
+        }
         container_detach(con);
         arrange_workspace(ws);
         if (&con->node == focus || node_has_ancestor(focus, &con->node)) {
diff --git a/sway/tree/view.c b/sway/tree/view.c
index 2c8839f5..c241b2b3 100644
--- a/sway/tree/view.c
+++ b/sway/tree/view.c
@@ -197,10 +197,11 @@ static bool gaps_to_edge(struct sway_view *view) {
 
 void view_autoconfigure(struct sway_view *view) {
         struct sway_container *con = view->container;
-        if (container_is_scratchpad_hidden(con)) {
+        if (container_is_scratchpad_hidden(con) &&
+                        con->fullscreen_mode != FULLSCREEN_GLOBAL) {
                 return;
         }
-        struct sway_output *output = con->workspace->output;
+        struct sway_output *output = con->workspace ? con->workspace->output : NULL;
 
         if (con->fullscreen_mode == FULLSCREEN_WORKSPACE) {
                 con->content_x = output->lx;
@@ -226,19 +227,21 @@ void view_autoconfigure(struct sway_view *view) {
 
         con->border_top = con->border_bottom = true;
         con->border_left = con->border_right = true;
-        if (config->hide_edge_borders == E_BOTH
-                        || config->hide_edge_borders == E_VERTICAL
-                        || (smart && !other_views && no_gaps)) {
-                con->border_left = con->x - con->current_gaps.left != ws->x;
-                int right_x = con->x + con->width + con->current_gaps.right;
-                con->border_right = right_x != ws->x + ws->width;
-        }
-        if (config->hide_edge_borders == E_BOTH
-                        || config->hide_edge_borders == E_HORIZONTAL
-                        || (smart && !other_views && no_gaps)) {
-                con->border_top = con->y - con->current_gaps.top != ws->y;
-                int bottom_y = con->y + con->height + con->current_gaps.bottom;
-                con->border_bottom = bottom_y != ws->y + ws->height;
+        if (ws) {
+                if (config->hide_edge_borders == E_BOTH
+                                || config->hide_edge_borders == E_VERTICAL
+                                || (smart && !other_views && no_gaps)) {
+                        con->border_left = con->x - con->current_gaps.left != ws->x;
+                        int right_x = con->x + con->width + con->current_gaps.right;
+                        con->border_right = right_x != ws->x + ws->width;
+                }
+                if (config->hide_edge_borders == E_BOTH
+                                || config->hide_edge_borders == E_HORIZONTAL
+                                || (smart && !other_views && no_gaps)) {
+                        con->border_top = con->y - con->current_gaps.top != ws->y;
+                        int bottom_y = con->y + con->height + con->current_gaps.bottom;
+                        con->border_bottom = bottom_y != ws->y + ws->height;
+                }
         }
 
         double y_offset = 0;
@@ -247,7 +250,8 @@ void view_autoconfigure(struct sway_view *view) {
         // 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.
         list_t *siblings = container_get_siblings(con);
-        bool show_titlebar = siblings->length > 1 || !config->hide_lone_tab;
+        bool show_titlebar = (siblings && siblings->length > 1)
+                || !config->hide_lone_tab;
         if (show_titlebar && !container_is_floating(con)) {
                 enum sway_container_layout layout = container_parent_layout(con);
                 if (layout == L_TABBED) {
@@ -538,6 +542,10 @@ static bool should_focus(struct sway_view *view) {
         struct sway_workspace *prev_ws = seat_get_focused_workspace(seat);
         struct sway_workspace *map_ws = view->container->workspace;
 
+        if (view->container->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                return true;
+        }
+
         // Views can only take focus if they are mapped into the active workspace
         if (prev_ws != map_ws) {
                 return false;
@@ -581,7 +589,8 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         }
 
         struct sway_seat *seat = input_manager_current_seat();
-        struct sway_node *node = seat_get_focus_inactive(seat, &ws->node);
+        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;
 
@@ -589,12 +598,13 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface,
         // 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);
         }
 
         view->container = container_create(view);
         if (target_sibling) {
                 container_add_sibling(target_sibling, view->container, 1);
-        } else {
+        } else if (ws) {
                 workspace_add_tiling(ws, view->container);
         }
         ipc_event_window(view->container, "new");
@@ -1032,8 +1042,18 @@ bool view_is_visible(struct sway_view *view) {
                 return false;
         }
         struct sway_workspace *workspace = view->container->workspace;
-        if (!workspace) {
-                return false;
+        if (!workspace && view->container->fullscreen_mode != FULLSCREEN_GLOBAL) {
+                bool fs_global_descendant = false;
+                struct sway_container *parent = view->container->parent;
+                while (parent) {
+                        if (parent->fullscreen_mode == FULLSCREEN_GLOBAL) {
+                                fs_global_descendant = true;
+                        }
+                        parent = parent->parent;
+                }
+                if (!fs_global_descendant) {
+                        return false;
+                }
         }
         // Determine if view is nested inside a floating container which is sticky
         struct sway_container *floater = view->container;
@@ -1041,7 +1061,7 @@ bool view_is_visible(struct sway_view *view) {
                 floater = floater->parent;
         }
         bool is_sticky = container_is_floating(floater) && floater->is_sticky;
-        if (!is_sticky && !workspace_is_visible(workspace)) {
+        if (!is_sticky && workspace && !workspace_is_visible(workspace)) {
                 return false;
         }
         // Check view isn't in a tabbed or stacked container on an inactive tab