From 69a1a0ff99171f15c7842bfde23ed90f09a37256 Mon Sep 17 00:00:00 2001 From: Brian Ashworth Date: Sun, 31 Mar 2019 23:27:18 -0400 Subject: 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. --- include/sway/input/seat.h | 5 +++ sway/commands/floating.c | 5 +++ sway/commands/focus.c | 4 ++ sway/commands/fullscreen.c | 7 ++++ sway/commands/layout.c | 6 ++- sway/commands/move.c | 9 +++++ sway/commands/split.c | 3 +- sway/desktop/output.c | 9 ++--- sway/desktop/render.c | 3 -- sway/input/seat.c | 50 +++++++++++++++++++++---- sway/tree/container.c | 92 +++++++++++++++++++++++++++++++++++++--------- sway/tree/node.c | 8 ++++ sway/tree/root.c | 14 +++++++ sway/tree/view.c | 62 ++++++++++++++++++++----------- 14 files changed, 220 insertions(+), 57 deletions(-) diff --git a/include/sway/input/seat.h b/include/sway/input/seat.h index f2af1066..eb6c09a1 100644 --- a/include/sway/input/seat.h +++ b/include/sway/input/seat.h @@ -143,6 +143,11 @@ struct sway_node *seat_get_focus(struct sway_seat *seat); struct sway_workspace *seat_get_focused_workspace(struct sway_seat *seat); +// If a scratchpad container is fullscreen global, this can be used to try to +// determine the last focused workspace. Otherwise, this should yield the same +// results as seat_get_focused_workspace. +struct sway_workspace *seat_get_last_known_workspace(struct sway_seat *seat); + struct sway_container *seat_get_focused_container(struct sway_seat *seat); /** 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 -- cgit v1.2.3-54-g00ecf