#define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include #include #include "cairo.h" #include "pango.h" #include "sway/config.h" #include "sway/desktop.h" #include "sway/desktop/transaction.h" #include "sway/input/input-manager.h" #include "sway/input/seat.h" #include "sway/ipc-server.h" #include "sway/output.h" #include "sway/server.h" #include "sway/tree/arrange.h" #include "sway/tree/view.h" #include "sway/tree/workspace.h" #include "list.h" #include "log.h" #include "stringop.h" struct sway_container *container_create(struct sway_view *view) { struct sway_container *c = calloc(1, sizeof(struct sway_container)); if (!c) { sway_log(SWAY_ERROR, "Unable to allocate sway_container"); return NULL; } node_init(&c->node, N_CONTAINER, c); c->layout = L_NONE; c->view = view; c->alpha = 1.0f; if (!view) { c->children = create_list(); c->current.children = create_list(); } c->marks = create_list(); c->outputs = create_list(); wl_signal_init(&c->events.destroy); wl_signal_emit(&root->events.new_node, &c->node); return c; } void container_destroy(struct sway_container *con) { if (!sway_assert(con->node.destroying, "Tried to free container which wasn't marked as destroying")) { return; } if (!sway_assert(con->node.ntxnrefs == 0, "Tried to free container " "which is still referenced by transactions")) { return; } free(con->title); free(con->formatted_title); wlr_texture_destroy(con->title_focused); wlr_texture_destroy(con->title_focused_inactive); wlr_texture_destroy(con->title_unfocused); wlr_texture_destroy(con->title_urgent); list_free(con->children); list_free(con->current.children); list_free(con->outputs); list_free_items_and_destroy(con->marks); wlr_texture_destroy(con->marks_focused); wlr_texture_destroy(con->marks_focused_inactive); wlr_texture_destroy(con->marks_unfocused); wlr_texture_destroy(con->marks_urgent); if (con->view) { if (con->view->container == con) { con->view->container = NULL; } if (con->view->destroying) { view_destroy(con->view); } } free(con); } void container_begin_destroy(struct sway_container *con) { if (con->view) { ipc_event_window(con, "close"); } // The workspace must have the fullscreen pointer cleared so that the // seat code can find an appropriate new focus. if (con->fullscreen_mode == FULLSCREEN_WORKSPACE && con->workspace) { con->workspace->fullscreen = NULL; } wl_signal_emit(&con->node.events.destroy, &con->node); container_end_mouse_operation(con); con->node.destroying = true; node_set_dirty(&con->node); if (con->scratchpad) { root_scratchpad_remove_container(con); } if (con->fullscreen_mode == FULLSCREEN_GLOBAL) { container_fullscreen_disable(con); } if (con->parent || con->workspace) { container_detach(con); } } void container_reap_empty(struct sway_container *con) { if (con->view) { return; } struct sway_workspace *ws = con->workspace; while (con) { if (con->children->length) { return; } struct sway_container *parent = con->parent; container_begin_destroy(con); con = parent; } workspace_consider_destroy(ws); } struct sway_container *container_flatten(struct sway_container *container) { if (container->view) { return NULL; } while (container && container->children->length == 1) { struct sway_container *child = container->children->items[0]; struct sway_container *parent = container->parent; container_replace(container, child); container_begin_destroy(container); container = parent; } return container; } struct sway_container *container_find_child(struct sway_container *container, bool (*test)(struct sway_container *con, void *data), void *data) { if (!container->children) { return NULL; } for (int i = 0; i < container->children->length; ++i) { struct sway_container *child = container->children->items[i]; if (test(child, data)) { return child; } struct sway_container *res = container_find_child(child, test, data); if (res) { return res; } } return NULL; } static struct sway_container *surface_at_view(struct sway_container *con, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { if (!sway_assert(con->view, "Expected a view")) { return NULL; } struct sway_view *view = con->view; double view_sx = lx - con->surface_x + view->geometry.x; double view_sy = ly - con->surface_y + view->geometry.y; double _sx, _sy; struct wlr_surface *_surface = NULL; switch (view->type) { #if HAVE_XWAYLAND case SWAY_VIEW_XWAYLAND: _surface = wlr_surface_surface_at(view->surface, view_sx, view_sy, &_sx, &_sy); break; #endif case SWAY_VIEW_XDG_SHELL_V6: _surface = wlr_xdg_surface_v6_surface_at( view->wlr_xdg_surface_v6, view_sx, view_sy, &_sx, &_sy); break; case SWAY_VIEW_XDG_SHELL: _surface = wlr_xdg_surface_surface_at( view->wlr_xdg_surface, view_sx, view_sy, &_sx, &_sy); break; } if (_surface) { *sx = _sx; *sy = _sy; *surface = _surface; return con; } return NULL; } /** * container_at for a container with layout L_TABBED. */ static struct sway_container *container_at_tabbed(struct sway_node *parent, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { struct wlr_box box; node_get_box(parent, &box); if (ly < box.y || ly > box.y + box.height) { return NULL; } struct sway_seat *seat = input_manager_current_seat(); list_t *children = node_get_children(parent); if (!children->length) { return NULL; } // Tab titles int title_height = container_titlebar_height(); if (ly < box.y + title_height) { int tab_width = box.width / children->length; int child_index = (lx - box.x) / tab_width; if (child_index >= children->length) { child_index = children->length - 1; } struct sway_container *child = children->items[child_index]; return child; } // Surfaces struct sway_node *current = seat_get_active_tiling_child(seat, parent); return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL; } /** * container_at for a container with layout L_STACKED. */ static struct sway_container *container_at_stacked(struct sway_node *parent, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { struct wlr_box box; node_get_box(parent, &box); if (ly < box.y || ly > box.y + box.height) { return NULL; } struct sway_seat *seat = input_manager_current_seat(); list_t *children = node_get_children(parent); // Title bars int title_height = container_titlebar_height(); int child_index = (ly - box.y) / title_height; if (child_index < children->length) { struct sway_container *child = children->items[child_index]; return child; } // Surfaces struct sway_node *current = seat_get_active_tiling_child(seat, parent); return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL; } /** * container_at for a container with layout L_HORIZ or L_VERT. */ static struct sway_container *container_at_linear(struct sway_node *parent, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { list_t *children = node_get_children(parent); for (int i = 0; i < children->length; ++i) { struct sway_container *child = children->items[i]; struct wlr_box box = { .x = child->x, .y = child->y, .width = child->width, .height = child->height, }; if (wlr_box_contains_point(&box, lx, ly)) { return tiling_container_at(&child->node, lx, ly, surface, sx, sy); } } return NULL; } static struct sway_container *floating_container_at(double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { for (int i = 0; i < root->outputs->length; ++i) { struct sway_output *output = root->outputs->items[i]; for (int j = 0; j < output->workspaces->length; ++j) { struct sway_workspace *ws = output->workspaces->items[j]; if (!workspace_is_visible(ws)) { continue; } // Items at the end of the list are on top, so iterate the list in // reverse. for (int k = ws->floating->length - 1; k >= 0; --k) { struct sway_container *floater = ws->floating->items[k]; 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 tiling_container_at(&floater->node, lx, ly, surface, sx, sy); } } } } return NULL; } struct sway_container *tiling_container_at(struct sway_node *parent, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { if (node_is_view(parent)) { surface_at_view(parent->sway_container, lx, ly, surface, sx, sy); return parent->sway_container; } if (!node_get_children(parent)) { return NULL; } switch (node_get_layout(parent)) { case L_HORIZ: case L_VERT: return container_at_linear(parent, lx, ly, surface, sx, sy); case L_TABBED: return container_at_tabbed(parent, lx, ly, surface, sx, sy); case L_STACKED: return container_at_stacked(parent, lx, ly, surface, sx, sy); case L_NONE: return NULL; } return NULL; } static bool surface_is_popup(struct wlr_surface *surface) { if (wlr_surface_is_xdg_surface(surface)) { struct wlr_xdg_surface *xdg_surface = wlr_xdg_surface_from_wlr_surface(surface); while (xdg_surface) { if (xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP) { return true; } xdg_surface = xdg_surface->toplevel->parent; } return false; } if (wlr_surface_is_xdg_surface_v6(surface)) { struct wlr_xdg_surface_v6 *xdg_surface_v6 = wlr_xdg_surface_v6_from_wlr_surface(surface); while (xdg_surface_v6) { if (xdg_surface_v6->role == WLR_XDG_SURFACE_V6_ROLE_POPUP) { return true; } xdg_surface_v6 = xdg_surface_v6->toplevel->parent; } return false; } return false; } struct sway_container *container_at(struct sway_workspace *workspace, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy) { struct sway_container *c; struct sway_seat *seat = input_manager_current_seat(); struct sway_container *focus = seat_get_focused_container(seat); bool is_floating = focus && container_is_floating_or_child(focus); // Focused view's popups if (focus && focus->view) { c = surface_at_view(focus, lx, ly, surface, sx, sy); if (c && surface_is_popup(*surface)) { return c; } *surface = NULL; } // Floating if ((c = floating_container_at(lx, ly, surface ,sx ,sy))) { return c; } // Tiling (focused) if (focus && focus->view && !is_floating) { if ((c = surface_at_view(focus, lx, ly, surface, sx, sy))) { return c; } } // Tiling (non-focused) if ((c = tiling_container_at(&workspace->node, lx, ly, surface, sx, sy))) { return c; } return NULL; } void container_for_each_child(struct sway_container *container, void (*f)(struct sway_container *container, void *data), void *data) { if (container->children) { for (int i = 0; i < container->children->length; ++i) { struct sway_container *child = container->children->items[i]; f(child, data); container_for_each_child(child, f, data); } } } bool container_has_ancestor(struct sway_container *descendant, struct sway_container *ancestor) { while (descendant) { descendant = descendant->parent; if (descendant == ancestor) { return true; } } return false; } void container_damage_whole(struct sway_container *container) { for (int i = 0; i < root->outputs->length; ++i) { struct sway_output *output = root->outputs->items[i]; output_damage_whole_container(output, container); } } /** * Return the output which will be used for scale purposes. * This is the most recently entered output. */ struct sway_output *container_get_effective_output(struct sway_container *con) { if (con->outputs->length == 0) { return NULL; } return con->outputs->items[con->outputs->length - 1]; } static void update_title_texture(struct sway_container *con, struct wlr_texture **texture, struct border_colors *class) { struct sway_output *output = container_get_effective_output(con); if (!output) { return; } if (*texture) { wlr_texture_destroy(*texture); *texture = NULL; } if (!con->formatted_title) { return; } double scale = output->wlr_output->scale; int width = 0; int height = con->title_height * scale; // We must use a non-nil cairo_t for cairo_set_font_options to work. // Therefore, we cannot use cairo_create(NULL). cairo_surface_t *dummy_surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, 0, 0); cairo_t *c = cairo_create(dummy_surface); cairo_set_antialias(c, CAIRO_ANTIALIAS_BEST); cairo_font_options_t *fo = cairo_font_options_create(); cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL); cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_SUBPIXEL); cairo_font_options_set_subpixel_order(fo, to_cairo_subpixel_order(output->wlr_output->subpixel)); cairo_set_font_options(c, fo); get_text_size(c, config->font, &width, NULL, NULL, scale, config->pango_markup, "%s", con->formatted_title); cairo_surface_destroy(dummy_surface); cairo_destroy(c); cairo_surface_t *surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, width, height); cairo_t *cairo = cairo_create(surface); cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST); cairo_set_font_options(cairo, fo); cairo_font_options_destroy(fo); cairo_set_source_rgba(cairo, class->background[0], class->background[1], class->background[2], class->background[3]); cairo_paint(cairo); PangoContext *pango = pango_cairo_create_context(cairo); cairo_set_source_rgba(cairo, class->text[0], class->text[1], class->text[2], class->text[3]); cairo_move_to(cairo, 0, 0); pango_printf(cairo, config->font, scale, config->pango_markup, "%s", con->formatted_title); cairo_surface_flush(surface); unsigned char *data = cairo_image_surface_get_data(surface); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); struct wlr_renderer *renderer = wlr_backend_get_renderer( output->wlr_output->backend); *texture = wlr_texture_from_pixels( renderer, WL_SHM_FORMAT_ARGB8888, stride, width, height, data); cairo_surface_destroy(surface); g_object_unref(pango); cairo_destroy(cairo); } void container_update_title_textures(struct sway_container *container) { update_title_texture(container, &container->title_focused, &config->border_colors.focused); update_title_texture(container, &container->title_focused_inactive, &config->border_colors.focused_inactive); update_title_texture(container, &container->title_unfocused, &config->border_colors.unfocused); update_title_texture(container, &container->title_urgent, &config->border_colors.urgent); container_damage_whole(container); } void container_calculate_title_height(struct sway_container *container) { if (!container->formatted_title) { container->title_height = 0; return; } cairo_t *cairo = cairo_create(NULL); int height; int baseline; get_text_size(cairo, config->font, NULL, &height, &baseline, 1, config->pango_markup, "%s", container->formatted_title); cairo_destroy(cairo); container->title_height = height; container->title_baseline = baseline; } /** * Calculate and return the length of the tree representation. * An example tree representation is: V[Terminal, Firefox] * If buffer is not NULL, also populate the buffer with the representation. */ size_t container_build_representation(enum sway_container_layout layout, list_t *children, char *buffer) { size_t len = 2; switch (layout) { case L_VERT: lenient_strcat(buffer, "V["); break; case L_HORIZ: lenient_strcat(buffer, "H["); break; case L_TABBED: lenient_strcat(buffer, "T["); break; case L_STACKED: lenient_strcat(buffer, "S["); break; case L_NONE: lenient_strcat(buffer, "D["); break; } for (int i = 0; i < children->length; ++i) { if (i != 0) { ++len; lenient_strcat(buffer, " "); } struct sway_container *child = children->items[i]; const char *identifier = NULL; if (child->view) { identifier = view_get_class(child->view); if (!identifier) { identifier = view_get_app_id(child->view); } } else { identifier = child->formatted_title; } if (identifier) { len += strlen(identifier); lenient_strcat(buffer, identifier); } else { len += 6; lenient_strcat(buffer, "(null)"); } } ++len; lenient_strcat(buffer, "]"); return len; } void container_update_representation(struct sway_container *con) { if (!con->view) { size_t len = container_build_representation(con->layout, con->children, NULL); free(con->formatted_title); con->formatted_title = calloc(len + 1, sizeof(char)); if (!sway_assert(con->formatted_title, "Unable to allocate title string")) { return; } container_build_representation(con->layout, con->children, con->formatted_title); container_calculate_title_height(con); container_update_title_textures(con); } if (con->parent) { container_update_representation(con->parent); } else if (con->workspace) { workspace_update_representation(con->workspace); } } size_t container_titlebar_height(void) { return config->font_height + config->titlebar_v_padding * 2; } void container_init_floating(struct sway_container *con) { struct sway_workspace *ws = con->workspace; int min_width, min_height; int max_width, max_height; if (config->floating_minimum_width == -1) { // no minimum min_width = 0; } else if (config->floating_minimum_width == 0) { // automatic min_width = 75; } else { min_width = config->floating_minimum_width; } if (config->floating_minimum_height == -1) { // no minimum min_height = 0; } else if (config->floating_minimum_height == 0) { // automatic min_height = 50; } else { min_height = config->floating_minimum_height; } if (config->floating_maximum_width == -1) { // no maximum max_width = INT_MAX; } else if (config->floating_maximum_width == 0) { // automatic max_width = ws->width * 0.6666; } else { max_width = config->floating_maximum_width; } if (config->floating_maximum_height == -1) { // no maximum max_height = INT_MAX; } else if (config->floating_maximum_height == 0) { // automatic max_height = ws->height * 0.6666; } else { max_height = config->floating_maximum_height; } if (!con->view) { con->width = max_width; con->height = max_height; con->x = ws->x + (ws->width - con->width) / 2; con->y = ws->y + (ws->height - con->height) / 2; } else { struct sway_view *view = con->view; con->content_width = fmax(min_width, fmin(view->natural_width, max_width)); con->content_height = fmax(min_height, fmin(view->natural_height, max_height)); con->content_x = ws->x + (ws->width - con->content_width) / 2; con->content_y = ws->y + (ws->height - con->content_height) / 2; // If the view's border is B_NONE then these properties are ignored. con->border_top = con->border_bottom = true; con->border_left = con->border_right = true; container_set_geometry_from_content(con); } } void container_set_floating(struct sway_container *container, bool enable) { if (container_is_floating(container) == enable) { return; } struct sway_seat *seat = input_manager_current_seat(); struct sway_workspace *workspace = container->workspace; if (enable) { struct sway_container *old_parent = container->parent; container_detach(container); workspace_add_floating(workspace, container); container_init_floating(container); if (container->view) { view_set_tiled(container->view, false); if (container->view->using_csd) { container->border = B_CSD; } } if (old_parent) { container_reap_empty(old_parent); } } else { // Returning to tiled if (container->scratchpad) { root_scratchpad_remove_container(container); } container_detach(container); struct sway_container *reference = seat_get_focus_inactive_tiling(seat, workspace); if (reference) { container_add_sibling(reference, container, 1); container->width = reference->width; container->height = reference->height; } else { workspace_add_tiling(workspace, container); container->width = workspace->width; container->height = workspace->height; } if (container->view) { view_set_tiled(container->view, true); if (container->view->using_csd) { container->border = container->saved_border; } } } container_end_mouse_operation(container); ipc_event_window(container, "floating"); } void container_set_geometry_from_content(struct sway_container *con) { if (!sway_assert(con->view, "Expected a view")) { return; } if (!sway_assert(container_is_floating(con), "Expected a floating view")) { return; } size_t border_width = 0; size_t top = 0; if (con->border != B_CSD) { border_width = con->border_thickness * (con->border != B_NONE); top = con->border == B_NORMAL ? container_titlebar_height() : border_width; } con->x = con->content_x - border_width; con->y = con->content_y - top; con->width = con->content_width + border_width * 2; con->height = top + con->content_height + border_width; node_set_dirty(&con->node); } bool container_is_floating(struct sway_container *container) { if (!container->parent && container->workspace && list_find(container->workspace->floating, container) != -1) { return true; } if (container->scratchpad) { return true; } return false; } void container_get_box(struct sway_container *container, struct wlr_box *box) { box->x = container->x; box->y = container->y; box->width = container->width; box->height = container->height; } /** * Translate the container's position as well as all children. */ void container_floating_translate(struct sway_container *con, double x_amount, double y_amount) { con->x += x_amount; con->y += y_amount; con->content_x += x_amount; con->content_y += y_amount; if (con->children) { for (int i = 0; i < con->children->length; ++i) { struct sway_container *child = con->children->items[i]; container_floating_translate(child, x_amount, y_amount); } } node_set_dirty(&con->node); } /** * Choose an output for the floating container's new position. * * If the center of the container intersects an output then we'll choose that * one, otherwise we'll choose whichever output is closest to the container's * center. */ struct sway_output *container_floating_find_output(struct sway_container *con) { double center_x = con->x + con->width / 2; double center_y = con->y + con->height / 2; struct sway_output *closest_output = NULL; double closest_distance = DBL_MAX; for (int i = 0; i < root->outputs->length; ++i) { struct sway_output *output = root->outputs->items[i]; struct wlr_box output_box; double closest_x, closest_y; output_get_box(output, &output_box); wlr_box_closest_point(&output_box, center_x, center_y, &closest_x, &closest_y); if (center_x == closest_x && center_y == closest_y) { // The center of the floating container is on this output return output; } double x_dist = closest_x - center_x; double y_dist = closest_y - center_y; double distance = x_dist * x_dist + y_dist * y_dist; if (distance < closest_distance) { closest_output = output; closest_distance = distance; } } return closest_output; } void container_floating_move_to(struct sway_container *con, double lx, double ly) { if (!sway_assert(container_is_floating(con), "Expected a floating container")) { return; } container_floating_translate(con, lx - con->x, ly - con->y); struct sway_workspace *old_workspace = con->workspace; struct sway_output *new_output = container_floating_find_output(con); if (!sway_assert(new_output, "Unable to find any output")) { return; } struct sway_workspace *new_workspace = output_get_active_workspace(new_output); if (old_workspace != new_workspace) { container_detach(con); workspace_add_floating(new_workspace, con); arrange_workspace(old_workspace); arrange_workspace(new_workspace); workspace_detect_urgent(old_workspace); workspace_detect_urgent(new_workspace); } } void container_floating_move_to_center(struct sway_container *con) { if (!sway_assert(container_is_floating(con), "Expected a floating container")) { return; } struct sway_workspace *ws = con->workspace; enum sway_fullscreen_mode fullscreen_mode = con->fullscreen_mode; if (fullscreen_mode) { container_fullscreen_disable(con); } double new_lx = ws->x + (ws->width - con->width) / 2; double new_ly = ws->y + (ws->height - con->height) / 2; container_floating_translate(con, new_lx - con->x, new_ly - con->y); if (fullscreen_mode) { container_set_fullscreen(con, fullscreen_mode); } } static bool find_urgent_iterator(struct sway_container *con, void *data) { return con->view && view_is_urgent(con->view); } bool container_has_urgent_child(struct sway_container *container) { return container_find_child(container, find_urgent_iterator, NULL); } void container_end_mouse_operation(struct sway_container *container) { struct sway_seat *seat; wl_list_for_each(seat, &server.input->seats, link) { seatop_unref(seat, container); } } static void set_fullscreen_iterator(struct sway_container *con, void *data) { if (!con->view) { return; } if (con->view->impl->set_fullscreen) { bool *enable = data; con->view->impl->set_fullscreen(con->view, *enable); } } static void container_fullscreen_workspace(struct sway_container *con) { if (!sway_assert(con->fullscreen_mode == FULLSCREEN_NONE, "Expected a non-fullscreen container")) { return; } bool enable = true; 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); } } con->fullscreen_mode = FULLSCREEN_WORKSPACE; container_end_mouse_operation(con); ipc_event_window(con, "fullscreen_mode"); } static void container_fullscreen_global(struct sway_container *con) { if (!sway_assert(con->fullscreen_mode == FULLSCREEN_NONE, "Expected a non-fullscreen container")) { return; } bool enable = true; set_fullscreen_iterator(con, &enable); container_for_each_child(con, set_fullscreen_iterator, &enable); root->fullscreen_global = 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; wl_list_for_each(seat, &server.input->seats, link) { struct sway_container *focus = seat_get_focused_container(seat); if (focus && focus != con) { seat_set_focus_container(seat, con); } } con->fullscreen_mode = FULLSCREEN_GLOBAL; container_end_mouse_operation(con); ipc_event_window(con, "fullscreen_mode"); } void container_fullscreen_disable(struct sway_container *con) { if (!sway_assert(con->fullscreen_mode != FULLSCREEN_NONE, "Expected a fullscreen container")) { return; } bool enable = false; set_fullscreen_iterator(con, &enable); container_for_each_child(con, set_fullscreen_iterator, &enable); if (container_is_floating(con)) { con->x = con->saved_x; con->y = con->saved_y; } con->width = con->saved_width; 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); } } } else { root->fullscreen_global = NULL; } con->fullscreen_mode = FULLSCREEN_NONE; container_end_mouse_operation(con); ipc_event_window(con, "fullscreen_mode"); } void container_set_fullscreen(struct sway_container *con, enum sway_fullscreen_mode mode) { if (con->fullscreen_mode == mode) { return; } switch (mode) { case FULLSCREEN_NONE: container_fullscreen_disable(con); break; case FULLSCREEN_WORKSPACE: if (root->fullscreen_global) { container_fullscreen_disable(root->fullscreen_global); } if (con->workspace->fullscreen) { container_fullscreen_disable(con->workspace->fullscreen); } container_fullscreen_workspace(con); break; case FULLSCREEN_GLOBAL: if (root->fullscreen_global) { container_fullscreen_disable(root->fullscreen_global); } if (con->fullscreen_mode == FULLSCREEN_WORKSPACE) { container_fullscreen_disable(con); } container_fullscreen_global(con); break; } } bool container_is_floating_or_child(struct sway_container *container) { while (container->parent) { container = container->parent; } return container_is_floating(container); } bool container_is_fullscreen_or_child(struct sway_container *container) { do { if (container->fullscreen_mode) { return true; } container = container->parent; } while (container); return false; } static void surface_send_enter_iterator(struct wlr_surface *surface, int x, int y, void *data) { struct wlr_output *wlr_output = data; wlr_surface_send_enter(surface, wlr_output); } static void surface_send_leave_iterator(struct wlr_surface *surface, int x, int y, void *data) { struct wlr_output *wlr_output = data; wlr_surface_send_leave(surface, wlr_output); } void container_discover_outputs(struct sway_container *con) { struct wlr_box con_box = { .x = con->current.x, .y = con->current.y, .width = con->current.width, .height = con->current.height, }; struct sway_output *old_output = container_get_effective_output(con); for (int i = 0; i < root->outputs->length; ++i) { struct sway_output *output = root->outputs->items[i]; struct wlr_box output_box; output_get_box(output, &output_box); struct wlr_box intersection; bool intersects = wlr_box_intersection(&intersection, &con_box, &output_box); int index = list_find(con->outputs, output); if (intersects && index == -1) { // Send enter sway_log(SWAY_DEBUG, "Container %p entered output %p", con, output); if (con->view) { view_for_each_surface(con->view, surface_send_enter_iterator, output->wlr_output); } list_add(con->outputs, output); } else if (!intersects && index != -1) { // Send leave sway_log(SWAY_DEBUG, "Container %p left output %p", con, output); if (con->view) { view_for_each_surface(con->view, surface_send_leave_iterator, output->wlr_output); } list_del(con->outputs, index); } } struct sway_output *new_output = container_get_effective_output(con); double old_scale = old_output && old_output->enabled ? old_output->wlr_output->scale : -1; double new_scale = new_output ? new_output->wlr_output->scale : -1; if (old_scale != new_scale) { container_update_title_textures(con); container_update_marks_textures(con); } } void container_remove_gaps(struct sway_container *c) { if (c->current_gaps.top == 0 && c->current_gaps.right == 0 && c->current_gaps.bottom == 0 && c->current_gaps.left == 0) { return; } c->width += c->current_gaps.left + c->current_gaps.right; c->height += c->current_gaps.top + c->current_gaps.bottom; c->x -= c->current_gaps.left; c->y -= c->current_gaps.top; c->current_gaps.top = 0; c->current_gaps.right = 0; c->current_gaps.bottom = 0; c->current_gaps.left = 0; } void container_add_gaps(struct sway_container *c) { if (c->current_gaps.top > 0 || c->current_gaps.right > 0 || c->current_gaps.bottom > 0 || c->current_gaps.left > 0) { 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; } // Descendants of tabbed/stacked containers re-use the gaps of the container struct sway_container *temp = c; while (temp) { enum sway_container_layout layout = container_parent_layout(temp); if (layout == L_TABBED || layout == L_STACKED) { return; } temp = temp->parent; } // If smart gaps is on, don't add gaps if there is only one view visible if (config->smart_gaps) { struct sway_view *view = c->view; if (!view) { struct sway_seat *seat = input_manager_get_default_seat(); struct sway_container *focus = seat_get_focus_inactive_view(seat, &c->node); view = focus ? focus->view : NULL; } if (view && view_is_only_visible(view)) { return; } } 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; c->current_gaps.left = c->x == ws->x ? ws->gaps_inner : 0; c->x += c->current_gaps.left; c->y += c->current_gaps.top; c->width -= c->current_gaps.left + c->current_gaps.right; c->height -= c->current_gaps.top + c->current_gaps.bottom; } enum sway_container_layout container_parent_layout(struct sway_container *con) { if (con->parent) { return con->parent->layout; } return con->workspace->layout; } enum sway_container_layout container_current_parent_layout( struct sway_container *con) { if (con->current.parent) { return con->current.parent->current.layout; } return con->current.workspace->current.layout; } list_t *container_get_siblings(struct sway_container *container) { if (container->parent) { return container->parent->children; } if (container_is_scratchpad_hidden(container)) { return NULL; } if (list_find(container->workspace->tiling, container) != -1) { return container->workspace->tiling; } return container->workspace->floating; } int container_sibling_index(struct sway_container *child) { return list_find(container_get_siblings(child), child); } list_t *container_get_current_siblings(struct sway_container *container) { if (container->current.parent) { return container->current.parent->current.children; } return container->current.workspace->current.tiling; } void container_handle_fullscreen_reparent(struct sway_container *con) { if (!sway_assert(con->workspace, "Expected con to have a workspace")) { return; } if (con->fullscreen_mode != FULLSCREEN_WORKSPACE || con->workspace->fullscreen == con) { return; } if (con->workspace->fullscreen) { container_fullscreen_disable(con->workspace->fullscreen); } con->workspace->fullscreen = con; arrange_workspace(con->workspace); } static void set_workspace(struct sway_container *container, void *data) { container->workspace = container->parent->workspace; } void container_insert_child(struct sway_container *parent, struct sway_container *child, int i) { if (child->workspace) { container_detach(child); } list_insert(parent->children, i, child); child->parent = parent; child->workspace = parent->workspace; container_for_each_child(child, set_workspace, NULL); container_handle_fullscreen_reparent(child); container_update_representation(parent); } void container_add_sibling(struct sway_container *fixed, struct sway_container *active, bool after) { if (active->workspace) { container_detach(active); } list_t *siblings = container_get_siblings(fixed); int index = list_find(siblings, fixed); list_insert(siblings, index + after, active); active->parent = fixed->parent; active->workspace = fixed->workspace; container_for_each_child(active, set_workspace, NULL); container_handle_fullscreen_reparent(active); container_update_representation(active); } void container_add_child(struct sway_container *parent, struct sway_container *child) { if (child->workspace) { container_detach(child); } list_add(parent->children, child); child->parent = parent; child->workspace = parent->workspace; container_for_each_child(child, set_workspace, NULL); container_handle_fullscreen_reparent(child); container_update_representation(parent); node_set_dirty(&child->node); node_set_dirty(&parent->node); } void container_detach(struct sway_container *child) { if (child->fullscreen_mode == FULLSCREEN_WORKSPACE) { child->workspace->fullscreen = NULL; } if (child->fullscreen_mode == FULLSCREEN_GLOBAL) { root->fullscreen_global = NULL; } struct sway_container *old_parent = child->parent; struct sway_workspace *old_workspace = child->workspace; list_t *siblings = container_get_siblings(child); if (siblings) { int index = list_find(siblings, child); if (index != -1) { list_del(siblings, index); } } child->parent = NULL; child->workspace = NULL; container_for_each_child(child, set_workspace, NULL); if (old_parent) { container_update_representation(old_parent); node_set_dirty(&old_parent->node); } else if (old_workspace) { workspace_update_representation(old_workspace); node_set_dirty(&old_workspace->node); } node_set_dirty(&child->node); } void container_replace(struct sway_container *container, struct sway_container *replacement) { container_add_sibling(container, replacement, 1); container_detach(container); } struct sway_container *container_split(struct sway_container *child, enum sway_container_layout layout) { struct sway_seat *seat = input_manager_get_default_seat(); bool set_focus = (seat_get_focus(seat) == &child->node); struct sway_container *cont = container_create(NULL); cont->width = child->width; cont->height = child->height; cont->x = child->x; cont->y = child->y; cont->current_gaps = child->current_gaps; cont->layout = layout; container_replace(child, cont); container_add_child(cont, child); if (set_focus) { seat_set_raw_focus(seat, &cont->node); seat_set_raw_focus(seat, &child->node); } return cont; } bool container_is_transient_for(struct sway_container *child, struct sway_container *ancestor) { return config->popup_during_fullscreen == POPUP_SMART && child->view && ancestor->view && view_is_transient_for(child->view, ancestor->view); } static bool find_by_mark_iterator(struct sway_container *con, void *data) { char *mark = data; return container_has_mark(con, mark); } struct sway_container *container_find_mark(char *mark) { return root_find_container(find_by_mark_iterator, mark); } bool container_find_and_unmark(char *mark) { struct sway_container *con = root_find_container( find_by_mark_iterator, mark); if (!con) { return false; } for (int i = 0; i < con->marks->length; ++i) { char *con_mark = con->marks->items[i]; if (strcmp(con_mark, mark) == 0) { free(con_mark); list_del(con->marks, i); container_update_marks_textures(con); ipc_event_window(con, "mark"); return true; } } return false; } void container_clear_marks(struct sway_container *con) { for (int i = 0; i < con->marks->length; ++i) { free(con->marks->items[i]); } con->marks->length = 0; ipc_event_window(con, "mark"); } bool container_has_mark(struct sway_container *con, char *mark) { for (int i = 0; i < con->marks->length; ++i) { char *item = con->marks->items[i]; if (strcmp(item, mark) == 0) { return true; } } return false; } void container_add_mark(struct sway_container *con, char *mark) { list_add(con->marks, strdup(mark)); ipc_event_window(con, "mark"); } static void update_marks_texture(struct sway_container *con, struct wlr_texture **texture, struct border_colors *class) { struct sway_output *output = container_get_effective_output(con); if (!output) { return; } if (*texture) { wlr_texture_destroy(*texture); *texture = NULL; } if (!con->marks->length) { return; } size_t len = 0; for (int i = 0; i < con->marks->length; ++i) { char *mark = con->marks->items[i]; if (mark[0] != '_') { len += strlen(mark) + 2; } } char *buffer = calloc(len + 1, 1); char *part = malloc(len + 1); if (!sway_assert(buffer && part, "Unable to allocate memory")) { free(buffer); return; } for (int i = 0; i < con->marks->length; ++i) { char *mark = con->marks->items[i]; if (mark[0] != '_') { sprintf(part, "[%s]", mark); strcat(buffer, part); } } free(part); double scale = output->wlr_output->scale; int width = 0; int height = con->title_height * scale; cairo_t *c = cairo_create(NULL); get_text_size(c, config->font, &width, NULL, NULL, scale, false, "%s", buffer); cairo_destroy(c); cairo_surface_t *surface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, width, height); cairo_t *cairo = cairo_create(surface); cairo_set_source_rgba(cairo, class->background[0], class->background[1], class->background[2], class->background[3]); cairo_paint(cairo); PangoContext *pango = pango_cairo_create_context(cairo); cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST); cairo_set_source_rgba(cairo, class->text[0], class->text[1], class->text[2], class->text[3]); cairo_move_to(cairo, 0, 0); pango_printf(cairo, config->font, scale, false, "%s", buffer); cairo_surface_flush(surface); unsigned char *data = cairo_image_surface_get_data(surface); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); struct wlr_renderer *renderer = wlr_backend_get_renderer( output->wlr_output->backend); *texture = wlr_texture_from_pixels( renderer, WL_SHM_FORMAT_ARGB8888, stride, width, height, data); cairo_surface_destroy(surface); g_object_unref(pango); cairo_destroy(cairo); free(buffer); } void container_update_marks_textures(struct sway_container *con) { if (!config->show_marks) { return; } update_marks_texture(con, &con->marks_focused, &config->border_colors.focused); update_marks_texture(con, &con->marks_focused_inactive, &config->border_colors.focused_inactive); update_marks_texture(con, &con->marks_unfocused, &config->border_colors.unfocused); update_marks_texture(con, &con->marks_urgent, &config->border_colors.urgent); container_damage_whole(con); } void container_raise_floating(struct sway_container *con) { // Bring container to front by putting it at the end of the floating list. struct sway_container *floater = con; while (floater->parent) { floater = floater->parent; } if (container_is_floating(floater)) { list_move_to_end(floater->workspace->floating, floater); node_set_dirty(&floater->workspace->node); } } bool container_is_scratchpad_hidden(struct sway_container *con) { return con->scratchpad && !con->workspace; }