mirror of
https://github.com/swaywm/sway.git
synced 2025-04-03 19:07:45 +03:00
c324feeee3
If far too many containers are created, they can become so small that their size calculations come out negative, leading to crashes on asserts. Instead, set a lower bound for sizes and disable the container entirely if it goes below it, giving whatever space it used to the last container. The splits are not recalculated, so currently the effect is that if all containers have the same width fraction, they keep getting narrower until at some point they all round to zero and the last container will be given all the available space. A better behavior would have been if the additional container did not contribute to size and fraction calculations at all, but it's an extreme edge-case, anything is better than crashing, and this is easier to implement.
379 lines
11 KiB
C
379 lines
11 KiB
C
#include <ctype.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wlr/types/wlr_output.h>
|
|
#include <wlr/types/wlr_output_layout.h>
|
|
#include "sway/tree/arrange.h"
|
|
#include "sway/tree/container.h"
|
|
#include "sway/output.h"
|
|
#include "sway/tree/workspace.h"
|
|
#include "sway/tree/view.h"
|
|
#include "list.h"
|
|
#include "log.h"
|
|
|
|
static void apply_horiz_layout(list_t *children, struct wlr_box *parent) {
|
|
if (!children->length) {
|
|
return;
|
|
}
|
|
|
|
// Count the number of new windows we are resizing, and how much space
|
|
// is currently occupied
|
|
int new_children = 0;
|
|
double current_width_fraction = 0;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
current_width_fraction += child->width_fraction;
|
|
if (child->width_fraction <= 0) {
|
|
new_children += 1;
|
|
}
|
|
}
|
|
|
|
// Calculate each width fraction
|
|
double total_width_fraction = 0;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
if (child->width_fraction <= 0) {
|
|
if (current_width_fraction <= 0) {
|
|
child->width_fraction = 1.0;
|
|
} else if (children->length > new_children) {
|
|
child->width_fraction = current_width_fraction /
|
|
(children->length - new_children);
|
|
} else {
|
|
child->width_fraction = current_width_fraction;
|
|
}
|
|
}
|
|
total_width_fraction += child->width_fraction;
|
|
}
|
|
// Normalize width fractions so the sum is 1.0
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
child->width_fraction /= total_width_fraction;
|
|
}
|
|
|
|
// Calculate gap size
|
|
double inner_gap = 0;
|
|
struct sway_container *child = children->items[0];
|
|
struct sway_workspace *ws = child->pending.workspace;
|
|
if (ws) {
|
|
inner_gap = ws->gaps_inner;
|
|
}
|
|
// Descendants of tabbed/stacked containers don't have gaps
|
|
struct sway_container *temp = child;
|
|
while (temp) {
|
|
enum sway_container_layout layout = container_parent_layout(temp);
|
|
if (layout == L_TABBED || layout == L_STACKED) {
|
|
inner_gap = 0;
|
|
}
|
|
temp = temp->pending.parent;
|
|
}
|
|
double total_gap = fmin(inner_gap * (children->length - 1),
|
|
fmax(0, parent->width - MIN_SANE_W * children->length));
|
|
double child_total_width = parent->width - total_gap;
|
|
inner_gap = floor(total_gap / (children->length - 1));
|
|
|
|
// Resize windows
|
|
sway_log(SWAY_DEBUG, "Arranging %p horizontally", parent);
|
|
double child_x = parent->x;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
child->child_total_width = child_total_width;
|
|
child->pending.x = child_x;
|
|
child->pending.y = parent->y;
|
|
child->pending.width = round(child->width_fraction * child_total_width);
|
|
child->pending.height = parent->height;
|
|
|
|
// Make last child use remaining width of parent
|
|
if (i == children->length - 1) {
|
|
child->pending.width = parent->x + parent->width - child->pending.x;
|
|
}
|
|
|
|
// Arbitrary lower bound for window size
|
|
if (child->pending.width < 10 || child->pending.height < 10) {
|
|
child->pending.width = 0;
|
|
child->pending.height = 0;
|
|
}
|
|
child_x += child->pending.width + inner_gap;
|
|
}
|
|
}
|
|
|
|
static void apply_vert_layout(list_t *children, struct wlr_box *parent) {
|
|
if (!children->length) {
|
|
return;
|
|
}
|
|
|
|
// Count the number of new windows we are resizing, and how much space
|
|
// is currently occupied
|
|
int new_children = 0;
|
|
double current_height_fraction = 0;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
current_height_fraction += child->height_fraction;
|
|
if (child->height_fraction <= 0) {
|
|
new_children += 1;
|
|
}
|
|
}
|
|
|
|
// Calculate each height fraction
|
|
double total_height_fraction = 0;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
if (child->height_fraction <= 0) {
|
|
if (current_height_fraction <= 0) {
|
|
child->height_fraction = 1.0;
|
|
} else if (children->length > new_children) {
|
|
child->height_fraction = current_height_fraction /
|
|
(children->length - new_children);
|
|
} else {
|
|
child->height_fraction = current_height_fraction;
|
|
}
|
|
}
|
|
total_height_fraction += child->height_fraction;
|
|
}
|
|
// Normalize height fractions so the sum is 1.0
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
child->height_fraction /= total_height_fraction;
|
|
}
|
|
|
|
// Calculate gap size
|
|
double inner_gap = 0;
|
|
struct sway_container *child = children->items[0];
|
|
struct sway_workspace *ws = child->pending.workspace;
|
|
if (ws) {
|
|
inner_gap = ws->gaps_inner;
|
|
}
|
|
// Descendants of tabbed/stacked containers don't have gaps
|
|
struct sway_container *temp = child;
|
|
while (temp) {
|
|
enum sway_container_layout layout = container_parent_layout(temp);
|
|
if (layout == L_TABBED || layout == L_STACKED) {
|
|
inner_gap = 0;
|
|
}
|
|
temp = temp->pending.parent;
|
|
}
|
|
double total_gap = fmin(inner_gap * (children->length - 1),
|
|
fmax(0, parent->height - MIN_SANE_H * children->length));
|
|
double child_total_height = parent->height - total_gap;
|
|
inner_gap = floor(total_gap / (children->length - 1));
|
|
|
|
// Resize windows
|
|
sway_log(SWAY_DEBUG, "Arranging %p vertically", parent);
|
|
double child_y = parent->y;
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
child->child_total_height = child_total_height;
|
|
child->pending.x = parent->x;
|
|
child->pending.y = child_y;
|
|
child->pending.width = parent->width;
|
|
child->pending.height = round(child->height_fraction * child_total_height);
|
|
|
|
// Make last child use remaining height of parent
|
|
if (i == children->length - 1) {
|
|
child->pending.height = parent->y + parent->height - child->pending.y;
|
|
}
|
|
|
|
// Arbitrary lower bound for window size
|
|
if (child->pending.width < 10 || child->pending.height < 10) {
|
|
child->pending.width = 0;
|
|
child->pending.height = 0;
|
|
}
|
|
child_y += child->pending.height + inner_gap;
|
|
}
|
|
}
|
|
|
|
static void apply_tabbed_layout(list_t *children, struct wlr_box *parent) {
|
|
if (!children->length) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
int parent_offset = child->view ? 0 : container_titlebar_height();
|
|
child->pending.x = parent->x;
|
|
child->pending.y = parent->y + parent_offset;
|
|
child->pending.width = parent->width;
|
|
child->pending.height = parent->height - parent_offset;
|
|
}
|
|
}
|
|
|
|
static void apply_stacked_layout(list_t *children, struct wlr_box *parent) {
|
|
if (!children->length) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
int parent_offset = child->view ? 0 :
|
|
container_titlebar_height() * children->length;
|
|
child->pending.x = parent->x;
|
|
child->pending.y = parent->y + parent_offset;
|
|
child->pending.width = parent->width;
|
|
child->pending.height = parent->height - parent_offset;
|
|
}
|
|
}
|
|
|
|
static void arrange_floating(list_t *floating) {
|
|
for (int i = 0; i < floating->length; ++i) {
|
|
struct sway_container *floater = floating->items[i];
|
|
arrange_container(floater);
|
|
}
|
|
}
|
|
|
|
static void arrange_children(list_t *children,
|
|
enum sway_container_layout layout, struct wlr_box *parent) {
|
|
// Calculate x, y, width and height of children
|
|
switch (layout) {
|
|
case L_HORIZ:
|
|
apply_horiz_layout(children, parent);
|
|
break;
|
|
case L_VERT:
|
|
apply_vert_layout(children, parent);
|
|
break;
|
|
case L_TABBED:
|
|
apply_tabbed_layout(children, parent);
|
|
break;
|
|
case L_STACKED:
|
|
apply_stacked_layout(children, parent);
|
|
break;
|
|
case L_NONE:
|
|
apply_horiz_layout(children, parent);
|
|
break;
|
|
}
|
|
|
|
// Recurse into child containers
|
|
for (int i = 0; i < children->length; ++i) {
|
|
struct sway_container *child = children->items[i];
|
|
arrange_container(child);
|
|
}
|
|
}
|
|
|
|
void arrange_container(struct sway_container *container) {
|
|
if (config->reloading) {
|
|
return;
|
|
}
|
|
if (container->view) {
|
|
view_autoconfigure(container->view);
|
|
node_set_dirty(&container->node);
|
|
return;
|
|
}
|
|
struct wlr_box box;
|
|
container_get_box(container, &box);
|
|
arrange_children(container->pending.children, container->pending.layout, &box);
|
|
node_set_dirty(&container->node);
|
|
}
|
|
|
|
void arrange_workspace(struct sway_workspace *workspace) {
|
|
if (config->reloading) {
|
|
return;
|
|
}
|
|
if (!workspace->output) {
|
|
// Happens when there are no outputs connected
|
|
return;
|
|
}
|
|
struct sway_output *output = workspace->output;
|
|
struct wlr_box *area = &output->usable_area;
|
|
sway_log(SWAY_DEBUG, "Usable area for ws: %dx%d@%d,%d",
|
|
area->width, area->height, area->x, area->y);
|
|
|
|
bool first_arrange = workspace->width == 0 && workspace->height == 0;
|
|
struct wlr_box prev_box;
|
|
workspace_get_box(workspace, &prev_box);
|
|
|
|
double prev_x = workspace->x - workspace->current_gaps.left;
|
|
double prev_y = workspace->y - workspace->current_gaps.top;
|
|
workspace->width = area->width;
|
|
workspace->height = area->height;
|
|
workspace->x = output->lx + area->x;
|
|
workspace->y = output->ly + area->y;
|
|
|
|
// Adjust any floating containers
|
|
double diff_x = workspace->x - prev_x;
|
|
double diff_y = workspace->y - prev_y;
|
|
if (!first_arrange && (diff_x != 0 || diff_y != 0)) {
|
|
for (int i = 0; i < workspace->floating->length; ++i) {
|
|
struct sway_container *floater = workspace->floating->items[i];
|
|
struct wlr_box workspace_box;
|
|
workspace_get_box(workspace, &workspace_box);
|
|
floating_fix_coordinates(floater, &prev_box, &workspace_box);
|
|
// Set transformation for scratchpad windows.
|
|
if (floater->scratchpad) {
|
|
struct wlr_box output_box;
|
|
output_get_box(output, &output_box);
|
|
floater->transform = output_box;
|
|
}
|
|
}
|
|
}
|
|
|
|
workspace_add_gaps(workspace);
|
|
node_set_dirty(&workspace->node);
|
|
sway_log(SWAY_DEBUG, "Arranging workspace '%s' at %f, %f", workspace->name,
|
|
workspace->x, workspace->y);
|
|
if (workspace->fullscreen) {
|
|
struct sway_container *fs = workspace->fullscreen;
|
|
fs->pending.x = output->lx;
|
|
fs->pending.y = output->ly;
|
|
fs->pending.width = output->width;
|
|
fs->pending.height = output->height;
|
|
arrange_container(fs);
|
|
} else {
|
|
struct wlr_box box;
|
|
workspace_get_box(workspace, &box);
|
|
arrange_children(workspace->tiling, workspace->layout, &box);
|
|
arrange_floating(workspace->floating);
|
|
}
|
|
}
|
|
|
|
void arrange_output(struct sway_output *output) {
|
|
if (config->reloading) {
|
|
return;
|
|
}
|
|
if (!output->wlr_output->enabled) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < output->workspaces->length; ++i) {
|
|
struct sway_workspace *workspace = output->workspaces->items[i];
|
|
arrange_workspace(workspace);
|
|
}
|
|
}
|
|
|
|
void arrange_root(void) {
|
|
if (config->reloading) {
|
|
return;
|
|
}
|
|
struct wlr_box layout_box;
|
|
wlr_output_layout_get_box(root->output_layout, NULL, &layout_box);
|
|
root->x = layout_box.x;
|
|
root->y = layout_box.y;
|
|
root->width = layout_box.width;
|
|
root->height = layout_box.height;
|
|
|
|
if (root->fullscreen_global) {
|
|
struct sway_container *fs = root->fullscreen_global;
|
|
fs->pending.x = root->x;
|
|
fs->pending.y = root->y;
|
|
fs->pending.width = root->width;
|
|
fs->pending.height = root->height;
|
|
arrange_container(fs);
|
|
} else {
|
|
for (int i = 0; i < root->outputs->length; ++i) {
|
|
struct sway_output *output = root->outputs->items[i];
|
|
arrange_output(output);
|
|
}
|
|
}
|
|
}
|
|
|
|
void arrange_node(struct sway_node *node) {
|
|
switch (node->type) {
|
|
case N_ROOT:
|
|
arrange_root();
|
|
break;
|
|
case N_OUTPUT:
|
|
arrange_output(node->sway_output);
|
|
break;
|
|
case N_WORKSPACE:
|
|
arrange_workspace(node->sway_workspace);
|
|
break;
|
|
case N_CONTAINER:
|
|
arrange_container(node->sway_container);
|
|
break;
|
|
}
|
|
}
|