mirror of
https://github.com/swaywm/sway.git
synced 2025-11-14 06:59:47 -05:00
Implement floating
This commit is contained in:
Ryan Dwyer
parent
1132efe42e
commit
1f2e399ade
21 changed files with 572 additions and 169 deletions
|
|
@ -247,6 +247,18 @@ void arrange_children_of(struct sway_container *parent) {
|
|||
arrange_children_of(child);
|
||||
}
|
||||
}
|
||||
|
||||
// If container is a workspace, process floating containers too
|
||||
if (parent->type == C_WORKSPACE) {
|
||||
struct sway_workspace *ws = workspace->sway_workspace;
|
||||
for (int i = 0; i < ws->floating->children->length; ++i) {
|
||||
struct sway_container *child = ws->floating->children->items[i];
|
||||
if (child->type != C_VIEW) {
|
||||
arrange_children_of(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
container_damage_whole(parent);
|
||||
update_debug_tree();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -123,6 +123,7 @@ struct sway_container *container_create(enum sway_container_type type) {
|
|||
c->layout = L_NONE;
|
||||
c->type = type;
|
||||
c->alpha = 1.0f;
|
||||
c->reapable = true;
|
||||
|
||||
if (type != C_VIEW) {
|
||||
c->children = create_list();
|
||||
|
|
@ -189,14 +190,13 @@ static struct sway_container *container_workspace_destroy(
|
|||
}
|
||||
|
||||
struct sway_container *parent = workspace->parent;
|
||||
if (workspace->children->length == 0) {
|
||||
// destroy the WS if there are no children (TODO check for floating)
|
||||
if (workspace_is_empty(workspace)) {
|
||||
// destroy the WS if there are no children
|
||||
wlr_log(L_DEBUG, "destroying workspace '%s'", workspace->name);
|
||||
ipc_event_workspace(workspace, NULL, "empty");
|
||||
} else if (output) {
|
||||
// Move children to a different workspace on this output
|
||||
struct sway_container *new_workspace = NULL;
|
||||
// TODO move floating
|
||||
for (int i = 0; i < output->children->length; i++) {
|
||||
if (output->children->items[i] != workspace) {
|
||||
new_workspace = output->children->items[i];
|
||||
|
|
@ -209,6 +209,11 @@ static struct sway_container *container_workspace_destroy(
|
|||
for (int i = 0; i < workspace->children->length; i++) {
|
||||
container_move_to(workspace->children->items[i], new_workspace);
|
||||
}
|
||||
struct sway_container *floating = workspace->sway_workspace->floating;
|
||||
for (int i = 0; i < floating->children->length; i++) {
|
||||
container_move_to(floating->children->items[i],
|
||||
new_workspace->sway_workspace->floating);
|
||||
}
|
||||
}
|
||||
|
||||
free(workspace->sway_workspace);
|
||||
|
|
@ -275,13 +280,16 @@ static void container_root_finish(struct sway_container *con) {
|
|||
}
|
||||
|
||||
bool container_reap_empty(struct sway_container *con) {
|
||||
if (!con->reapable) {
|
||||
return false;
|
||||
}
|
||||
switch (con->type) {
|
||||
case C_ROOT:
|
||||
case C_OUTPUT:
|
||||
// dont reap these
|
||||
break;
|
||||
case C_WORKSPACE:
|
||||
if (!workspace_is_visible(con) && con->children->length == 0) {
|
||||
if (!workspace_is_visible(con) && workspace_is_empty(con)) {
|
||||
wlr_log(L_DEBUG, "Destroying workspace via reaper");
|
||||
container_workspace_destroy(con);
|
||||
return true;
|
||||
|
|
@ -436,7 +444,6 @@ struct sway_container *container_find(struct sway_container *container,
|
|||
if (!container->children) {
|
||||
return NULL;
|
||||
}
|
||||
// TODO: floating windows
|
||||
for (int i = 0; i < container->children->length; ++i) {
|
||||
struct sway_container *child = container->children->items[i];
|
||||
if (test(child, data)) {
|
||||
|
|
@ -448,6 +455,9 @@ struct sway_container *container_find(struct sway_container *container,
|
|||
}
|
||||
}
|
||||
}
|
||||
if (container->type == C_WORKSPACE) {
|
||||
return container_find(container->sway_workspace->floating, test, data);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -608,8 +618,6 @@ struct sway_container *container_at(struct sway_container *parent,
|
|||
return container_at_tabbed(parent, ox, oy, surface, sx, sy);
|
||||
case L_STACKED:
|
||||
return container_at_stacked(parent, ox, oy, surface, sx, sy);
|
||||
case L_FLOATING:
|
||||
return NULL; // TODO
|
||||
case L_NONE:
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -617,6 +625,34 @@ struct sway_container *container_at(struct sway_container *parent,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
struct sway_container *floating_container_at(double lx, double ly,
|
||||
struct wlr_surface **surface, double *sx, double *sy) {
|
||||
for (int i = 0; i < root_container.children->length; ++i) {
|
||||
struct sway_container *output = root_container.children->items[i];
|
||||
for (int j = 0; j < output->children->length; ++j) {
|
||||
struct sway_container *workspace = output->children->items[j];
|
||||
struct sway_workspace *ws = workspace->sway_workspace;
|
||||
bool ws_is_visible = workspace_is_visible(workspace);
|
||||
for (int k = 0; k < ws->floating->children->length; ++k) {
|
||||
struct sway_container *floater =
|
||||
ws->floating->children->items[k];
|
||||
if (ws_is_visible || floater->is_sticky) {
|
||||
struct wlr_box box = {
|
||||
.x = floater->x,
|
||||
.y = floater->y,
|
||||
.width = floater->width,
|
||||
.height = floater->height,
|
||||
};
|
||||
if (wlr_box_contains_point(&box, lx, ly)) {
|
||||
return container_at(floater, lx, ly, surface, sx, sy);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void container_for_each_descendant_dfs(struct sway_container *container,
|
||||
void (*f)(struct sway_container *container, void *data),
|
||||
void *data) {
|
||||
|
|
@ -674,7 +710,7 @@ static bool find_child_func(struct sway_container *con, void *data) {
|
|||
|
||||
bool container_has_child(struct sway_container *con,
|
||||
struct sway_container *child) {
|
||||
if (con == NULL || con->type == C_VIEW || con->children->length == 0) {
|
||||
if (con == NULL || con->type == C_VIEW) {
|
||||
return false;
|
||||
}
|
||||
return container_find(con, find_child_func, child);
|
||||
|
|
@ -806,9 +842,6 @@ static size_t get_tree_representation(struct sway_container *parent, char *buffe
|
|||
case L_STACKED:
|
||||
lenient_strcat(buffer, "S[");
|
||||
break;
|
||||
case L_FLOATING:
|
||||
lenient_strcat(buffer, "F[");
|
||||
break;
|
||||
case L_NONE:
|
||||
lenient_strcat(buffer, "D[");
|
||||
break;
|
||||
|
|
@ -866,3 +899,81 @@ void container_notify_subtree_changed(struct sway_container *container) {
|
|||
size_t container_titlebar_height() {
|
||||
return config->font_height + TITLEBAR_V_PADDING * 2;
|
||||
}
|
||||
|
||||
static void configure_floating_view(struct sway_view *view) {
|
||||
struct sway_container *ws = container_parent(view->swayc, C_WORKSPACE);
|
||||
int max_width = ws->width * 0.6666;
|
||||
int max_height = ws->height * 0.6666;
|
||||
int width =
|
||||
view->natural_width > max_width ? max_width : view->natural_width;
|
||||
int height =
|
||||
view->natural_height > max_height ? max_height : view->natural_height;
|
||||
struct sway_container *output = ws->parent;
|
||||
int lx = output->x + (ws->width - width) / 2;
|
||||
int ly = output->y + (ws->height - height) / 2;
|
||||
|
||||
view->border_left = view->border_right = view->border_bottom = true;
|
||||
view_set_maximized(view, false);
|
||||
view_configure(view, lx, ly, width, height);
|
||||
}
|
||||
|
||||
void container_set_floating(struct sway_container *container, bool enable) {
|
||||
if (container->is_floating == enable) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct sway_container *workspace = container_parent(container, C_WORKSPACE);
|
||||
struct sway_seat *seat = input_manager_current_seat(input_manager);
|
||||
container_damage_whole(container);
|
||||
|
||||
if (enable) {
|
||||
container_remove_child(container);
|
||||
container_add_child(workspace->sway_workspace->floating, container);
|
||||
container->is_floating = true;
|
||||
if (container->type == C_VIEW) {
|
||||
configure_floating_view(container->sway_view);
|
||||
}
|
||||
seat_set_focus(seat, seat_get_focus_inactive(seat, container));
|
||||
container_reap_empty_recursive(workspace);
|
||||
} else {
|
||||
// Returning to tiled
|
||||
container_remove_child(container);
|
||||
container_add_child(workspace, container);
|
||||
container->width = container->parent->width;
|
||||
container->height = container->parent->height;
|
||||
if (container->type == C_VIEW) {
|
||||
view_set_maximized(container->sway_view, true);
|
||||
}
|
||||
container->is_floating = false;
|
||||
container->is_sticky = false;
|
||||
container_reap_empty_recursive(workspace->sway_workspace->floating);
|
||||
}
|
||||
arrange_workspace(workspace);
|
||||
container_damage_whole(container);
|
||||
}
|
||||
|
||||
void container_set_geometry_from_view(struct sway_container *container) {
|
||||
if (!sway_assert(container->type == C_VIEW, "Expected a view")) {
|
||||
return;
|
||||
}
|
||||
if (!sway_assert(container->is_floating, "Expected a floating view")) {
|
||||
return;
|
||||
}
|
||||
struct sway_view *view = container->sway_view;
|
||||
size_t border_width = view->border_thickness * (view->border != B_NONE);
|
||||
size_t top =
|
||||
view->border == B_NORMAL ? container_titlebar_height() : border_width;
|
||||
|
||||
container->x = view->x - border_width;
|
||||
container->y = view->y - top;
|
||||
container->width = view->width + border_width * 2;
|
||||
container->height = top + view->height + border_width;
|
||||
}
|
||||
|
||||
bool container_self_or_parent_floating(struct sway_container *container) {
|
||||
while (container->parent->type != C_WORKSPACE
|
||||
&& container->parent->parent->type != C_WORKSPACE) {
|
||||
container = container->parent;
|
||||
}
|
||||
return container->is_floating;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,20 +45,14 @@ void layout_init(void) {
|
|||
}
|
||||
|
||||
static int index_child(const struct sway_container *child) {
|
||||
// TODO handle floating
|
||||
struct sway_container *parent = child->parent;
|
||||
int i, len;
|
||||
len = parent->children->length;
|
||||
for (i = 0; i < len; ++i) {
|
||||
for (int i = 0; i < parent->children->length; ++i) {
|
||||
if (parent->children->items[i] == child) {
|
||||
break;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
if (!sway_assert(i < len, "Stray container")) {
|
||||
return -1;
|
||||
}
|
||||
return i;
|
||||
// This happens if the child is a floating container
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void container_handle_fullscreen_reparent(struct sway_container *viewcon,
|
||||
|
|
@ -142,26 +136,11 @@ struct sway_container *container_remove_child(struct sway_container *child) {
|
|||
}
|
||||
|
||||
struct sway_container *parent = child->parent;
|
||||
if (!child->is_floating) {
|
||||
for (int i = 0; i < parent->children->length; ++i) {
|
||||
if (parent->children->items[i] == child) {
|
||||
list_del(parent->children, i);
|
||||
break;
|
||||
}
|
||||
for (int i = 0; i < parent->children->length; ++i) {
|
||||
if (parent->children->items[i] == child) {
|
||||
list_del(parent->children, i);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (!sway_assert(parent->type == C_WORKSPACE && child->type == C_VIEW,
|
||||
"Found floating non-view and/or in non-workspace")) {
|
||||
return parent;
|
||||
}
|
||||
struct sway_workspace *ws = parent->sway_workspace;
|
||||
for (int i = 0; i < ws->floating->length; ++i) {
|
||||
if (ws->floating->items[i] == child) {
|
||||
list_del(ws->floating, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
child->is_floating = false;
|
||||
}
|
||||
child->parent = NULL;
|
||||
container_notify_subtree_changed(parent);
|
||||
|
|
@ -169,32 +148,16 @@ struct sway_container *container_remove_child(struct sway_container *child) {
|
|||
return parent;
|
||||
}
|
||||
|
||||
void container_add_floating(struct sway_container *workspace,
|
||||
struct sway_container *child) {
|
||||
if (!sway_assert(workspace->type == C_WORKSPACE && child->type == C_VIEW,
|
||||
"Attempted to float non-view and/or in non-workspace")) {
|
||||
return;
|
||||
}
|
||||
if (!sway_assert(!child->parent,
|
||||
"child already has a parent (invalid call)")) {
|
||||
return;
|
||||
}
|
||||
if (!sway_assert(!child->is_floating,
|
||||
"child is already floating (invalid state)")) {
|
||||
return;
|
||||
}
|
||||
struct sway_workspace *ws = workspace->sway_workspace;
|
||||
list_add(ws->floating, child);
|
||||
child->parent = workspace;
|
||||
child->is_floating = true;
|
||||
}
|
||||
|
||||
void container_move_to(struct sway_container *container,
|
||||
struct sway_container *destination) {
|
||||
if (container == destination
|
||||
|| container_has_ancestor(container, destination)) {
|
||||
return;
|
||||
}
|
||||
if (container->is_floating) {
|
||||
// TODO
|
||||
return;
|
||||
}
|
||||
struct sway_container *old_parent = container_remove_child(container);
|
||||
container->width = container->height = 0;
|
||||
container->saved_width = container->saved_height = 0;
|
||||
|
|
@ -207,8 +170,9 @@ void container_move_to(struct sway_container *container,
|
|||
}
|
||||
wl_signal_emit(&container->events.reparent, old_parent);
|
||||
if (container->type == C_WORKSPACE) {
|
||||
struct sway_seat *seat = input_manager_get_default_seat(
|
||||
input_manager);
|
||||
// If moving a workspace to a new output, maybe create a new workspace
|
||||
// on the previous output
|
||||
struct sway_seat *seat = input_manager_get_default_seat(input_manager);
|
||||
if (old_parent->children->length == 0) {
|
||||
char *ws_name = workspace_next_name(old_parent->name);
|
||||
struct sway_container *ws =
|
||||
|
|
@ -754,6 +718,10 @@ struct sway_container *container_get_in_direction(
|
|||
enum movement_direction dir) {
|
||||
struct sway_container *parent = container->parent;
|
||||
|
||||
if (container->is_floating) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (container->type == C_VIEW && container->sway_view->is_fullscreen) {
|
||||
if (dir == MOVE_PARENT || dir == MOVE_CHILD) {
|
||||
return NULL;
|
||||
|
|
@ -778,6 +746,9 @@ struct sway_container *container_get_in_direction(
|
|||
bool can_move = false;
|
||||
int desired;
|
||||
int idx = index_child(container);
|
||||
if (idx == -1) {
|
||||
return NULL;
|
||||
}
|
||||
if (parent->type == C_ROOT) {
|
||||
enum wlr_direction wlr_dir = 0;
|
||||
if (!sway_assert(sway_dir_to_wlr(dir, &wlr_dir),
|
||||
|
|
|
|||
|
|
@ -158,21 +158,19 @@ void view_autoconfigure(struct sway_view *view) {
|
|||
|
||||
view->border_top = view->border_bottom = true;
|
||||
view->border_left = view->border_right = true;
|
||||
if (view->swayc->layout != L_FLOATING) {
|
||||
if (config->hide_edge_borders == E_BOTH
|
||||
|| config->hide_edge_borders == E_VERTICAL
|
||||
|| (config->hide_edge_borders == E_SMART && !other_views)) {
|
||||
view->border_left = view->swayc->x != ws->x;
|
||||
int right_x = view->swayc->x + view->swayc->width;
|
||||
view->border_right = right_x != ws->x + ws->width;
|
||||
}
|
||||
if (config->hide_edge_borders == E_BOTH
|
||||
|| config->hide_edge_borders == E_HORIZONTAL
|
||||
|| (config->hide_edge_borders == E_SMART && !other_views)) {
|
||||
view->border_top = view->swayc->y != ws->y;
|
||||
int bottom_y = view->swayc->y + view->swayc->height;
|
||||
view->border_bottom = bottom_y != ws->y + ws->height;
|
||||
}
|
||||
if (config->hide_edge_borders == E_BOTH
|
||||
|| config->hide_edge_borders == E_VERTICAL
|
||||
|| (config->hide_edge_borders == E_SMART && !other_views)) {
|
||||
view->border_left = view->swayc->x != ws->x;
|
||||
int right_x = view->swayc->x + view->swayc->width;
|
||||
view->border_right = right_x != ws->x + ws->width;
|
||||
}
|
||||
if (config->hide_edge_borders == E_BOTH
|
||||
|| config->hide_edge_borders == E_HORIZONTAL
|
||||
|| (config->hide_edge_borders == E_SMART && !other_views)) {
|
||||
view->border_top = view->swayc->y != ws->y;
|
||||
int bottom_y = view->swayc->y + view->swayc->height;
|
||||
view->border_bottom = bottom_y != ws->y + ws->height;
|
||||
}
|
||||
|
||||
double x, y, width, height;
|
||||
|
|
@ -184,11 +182,11 @@ void view_autoconfigure(struct sway_view *view) {
|
|||
// disable any top border because we'll always have the title bar.
|
||||
if (view->swayc->parent->layout == L_TABBED) {
|
||||
y_offset = container_titlebar_height();
|
||||
view->border_top = 0;
|
||||
view->border_top = false;
|
||||
} else if (view->swayc->parent->layout == L_STACKED) {
|
||||
y_offset = container_titlebar_height()
|
||||
* view->swayc->parent->children->length;
|
||||
view->border_top = 0;
|
||||
view->border_top = false;
|
||||
}
|
||||
|
||||
switch (view->border) {
|
||||
|
|
@ -237,6 +235,12 @@ void view_set_activated(struct sway_view *view, bool activated) {
|
|||
}
|
||||
}
|
||||
|
||||
void view_set_maximized(struct sway_view *view, bool maximized) {
|
||||
if (view->impl->set_maximized) {
|
||||
view->impl->set_maximized(view, maximized);
|
||||
}
|
||||
}
|
||||
|
||||
// Set fullscreen, but without IPC events or arranging windows.
|
||||
void view_set_fullscreen_raw(struct sway_view *view, bool fullscreen) {
|
||||
if (view->is_fullscreen == fullscreen) {
|
||||
|
|
@ -452,6 +456,11 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface) {
|
|||
// TODO: CT_ASSIGN_OUTPUT
|
||||
}
|
||||
}
|
||||
// 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 (focus->is_floating) {
|
||||
focus = focus->parent->parent;
|
||||
}
|
||||
free(criterias);
|
||||
cont = container_view_create(focus, view);
|
||||
|
||||
|
|
@ -468,7 +477,12 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface) {
|
|||
wl_signal_add(&view->swayc->events.reparent, &view->container_reparent);
|
||||
view->container_reparent.notify = view_handle_container_reparent;
|
||||
|
||||
arrange_children_of(cont->parent);
|
||||
if (view->impl->wants_floating && view->impl->wants_floating(view)) {
|
||||
container_set_floating(view->swayc, true);
|
||||
} else {
|
||||
arrange_children_of(cont->parent);
|
||||
}
|
||||
|
||||
input_manager_set_focus(input_manager, cont);
|
||||
if (workspace) {
|
||||
workspace_switch(workspace);
|
||||
|
|
@ -516,16 +530,14 @@ void view_unmap(struct sway_view *view) {
|
|||
}
|
||||
}
|
||||
|
||||
void view_update_position(struct sway_view *view, double ox, double oy) {
|
||||
if (view->swayc->x == ox && view->swayc->y == oy) {
|
||||
void view_update_position(struct sway_view *view, double lx, double ly) {
|
||||
if (!view->swayc->is_floating) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Only allow this if the view is floating (this function will only be
|
||||
// called in response to wayland clients wanting to reposition themselves).
|
||||
container_damage_whole(view->swayc);
|
||||
view->swayc->x = ox;
|
||||
view->swayc->y = oy;
|
||||
view->x = lx;
|
||||
view->y = ly;
|
||||
container_set_geometry_from_view(view->swayc);
|
||||
container_damage_whole(view->swayc);
|
||||
}
|
||||
|
||||
|
|
@ -533,15 +545,15 @@ void view_update_size(struct sway_view *view, int width, int height) {
|
|||
if (view->width == width && view->height == height) {
|
||||
return;
|
||||
}
|
||||
|
||||
container_damage_whole(view->swayc);
|
||||
// Should we update the swayc width/height here too?
|
||||
view->width = width;
|
||||
view->height = height;
|
||||
if (view->swayc->is_floating) {
|
||||
container_set_geometry_from_view(view->swayc);
|
||||
}
|
||||
container_damage_whole(view->swayc);
|
||||
}
|
||||
|
||||
|
||||
static void view_subsurface_create(struct sway_view *view,
|
||||
struct wlr_subsurface *subsurface) {
|
||||
struct sway_view_child *child = calloc(1, sizeof(struct sway_view_child));
|
||||
|
|
@ -888,6 +900,19 @@ bool view_is_visible(struct sway_view *view) {
|
|||
if (!view->swayc) {
|
||||
return false;
|
||||
}
|
||||
struct sway_container *workspace =
|
||||
container_parent(view->swayc, C_WORKSPACE);
|
||||
// Determine if view is nested inside a floating container which is sticky.
|
||||
// A simple floating view will have this ancestry:
|
||||
// C_VIEW (is_floating=true) -> floating -> workspace
|
||||
// A more complex ancestry could be:
|
||||
// C_VIEW -> C_CONTAINER (tabbed and is_floating) -> floating -> workspace
|
||||
struct sway_container *floater = view->swayc;
|
||||
while (floater->parent->type != C_WORKSPACE
|
||||
&& floater->parent->parent->type != C_WORKSPACE) {
|
||||
floater = floater->parent;
|
||||
}
|
||||
bool is_sticky = floater->is_floating && floater->is_sticky;
|
||||
// Check view isn't in a tabbed or stacked container on an inactive tab
|
||||
struct sway_seat *seat = input_manager_current_seat(input_manager);
|
||||
struct sway_container *container = view->swayc;
|
||||
|
|
@ -901,10 +926,12 @@ bool view_is_visible(struct sway_view *view) {
|
|||
container = container->parent;
|
||||
}
|
||||
// Check view isn't hidden by another fullscreen view
|
||||
struct sway_container *workspace = container;
|
||||
if (workspace->sway_workspace->fullscreen && !view->is_fullscreen) {
|
||||
return false;
|
||||
}
|
||||
// Check the workspace is visible
|
||||
return workspace_is_visible(workspace);
|
||||
if (!is_sticky) {
|
||||
return workspace_is_visible(workspace);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,7 +65,9 @@ struct sway_container *workspace_create(struct sway_container *output,
|
|||
return NULL;
|
||||
}
|
||||
swayws->swayc = workspace;
|
||||
swayws->floating = create_list();
|
||||
swayws->floating = container_create(C_CONTAINER);
|
||||
swayws->floating->parent = swayws->swayc;
|
||||
swayws->floating->reapable = false;
|
||||
workspace->sway_workspace = swayws;
|
||||
|
||||
container_add_child(output, workspace);
|
||||
|
|
@ -408,3 +410,16 @@ bool workspace_is_visible(struct sway_container *ws) {
|
|||
}
|
||||
return focus == ws;
|
||||
}
|
||||
|
||||
bool workspace_is_empty(struct sway_container *ws) {
|
||||
if (!sway_assert(ws->type == C_WORKSPACE, "Expected a workspace")) {
|
||||
return false;
|
||||
}
|
||||
if (ws->children->length) {
|
||||
return false;
|
||||
}
|
||||
if (ws->sway_workspace->floating->children->length) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue