mirrors/sway
1
0
Fork 0
mirror of https://github.com/swaywm/sway.git synced 2024-09-24 06:31:34 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2005 from RyanDwyer/tabbed-layout

Browse Source 
Implement tabbed layout
This commit is contained in:
emersion 2018-05-21 11:24:05 +01:00 committed by GitHub
commit a7adbf4b79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 522 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/sway/input/seat.h
View File

@ -94,6 +94,12 @@ struct sway_container *seat_get_focus_inactive(struct sway_seat *seat,
struct sway_container *seat_get_focus_inactive_view(struct sway_seat *seat,
struct sway_container *container);
/**
* Return the immediate child of container which was most recently focused.
*/
struct sway_container *seat_get_active_child(struct sway_seat *seat,
struct sway_container *container);
/**
* Iterate over the focus-inactive children of the container calling the
* function on each.

2
include/sway/tree/container.h
View File

@ -162,7 +162,7 @@ struct sway_container *container_parent(struct sway_container *container,
* is a view and the view contains a surface at those coordinates.
*/
struct sway_container *container_at(struct sway_container *container,
double lx, double ly, struct wlr_surface **surface,
double ox, double oy, struct wlr_surface **surface,
double *sx, double *sy);
/**

6
include/sway/tree/view.h
View File

@ -274,4 +274,10 @@ bool view_has_mark(struct sway_view *view, char *mark);
void view_update_marks_textures(struct sway_view *view);
/**
* Returns true if there's a possibility the view may be rendered on screen.
* Intended for damage tracking.
*/
bool view_is_visible(struct sway_view *view);
#endif

2
sway/commands/layout.c
View File

@ -39,6 +39,8 @@ struct cmd_results *cmd_layout(int argc, char **argv) {
parent->layout = L_HORIZ;
} else if (strcasecmp(argv[0], "splitv") == 0) {
parent->layout = L_VERT;
} else if (strcasecmp(argv[0], "tabbed") == 0) {
parent->layout = L_TABBED;
} else if (strcasecmp(argv[0], "toggle") == 0 && argc == 2 && strcasecmp(argv[1], "split") == 0) {
if (parent->layout == L_HORIZ) {
parent->layout = L_VERT;

193
sway/desktop/output.c
View File

@ -599,12 +599,195 @@ static void render_container_simple(struct sway_output *output,
}
}
static void render_tab(struct sway_output *output, pixman_region32_t *damage,
struct sway_container *parent, int child_index,
struct border_colors *colors, struct wlr_texture *title_texture) {
struct sway_container *con = parent->children->items[child_index];
float output_scale = output->wlr_output->scale;
float color[4];
struct wlr_box box;
int tab_width = parent->width / parent->children->length;
int x = parent->x + tab_width * child_index;
// Make last tab use the remaining width of the parent
if (child_index == parent->children->length - 1) {
tab_width = parent->width - tab_width * child_index;
}
// Single pixel bar above title
memcpy(&color, colors->border, sizeof(float) * 4);
premultiply_alpha(color, con->alpha);
box.x = x;
box.y = parent->y;
box.width = tab_width;
box.height = 1;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
// Single pixel bar below title
box.y = (parent->y + config->border_thickness * 2 + config->font_height - 1)
* output_scale;
render_rect(output->wlr_output, damage, &box, color);
// Single pixel bar on left
box.x = x;
box.y = parent->y + 1;
box.width = 1;
box.height = config->border_thickness * 2 + config->font_height - 2;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
// Single pixel bar on right
box.x = (x + tab_width - 1) * output_scale;
render_rect(output->wlr_output, damage, &box, color);
// Title text
size_t title_width = 0;
if (title_texture) {
struct wlr_box texture_box;
wlr_texture_get_size(title_texture,
&texture_box.width, &texture_box.height);
texture_box.x = (x + 1 + config->border_thickness) * output_scale;
texture_box.y = (parent->y + config->border_thickness) * output_scale;
float matrix[9];
wlr_matrix_project_box(matrix, &texture_box,
WL_OUTPUT_TRANSFORM_NORMAL,
0.0, output->wlr_output->transform_matrix);
int available = (tab_width - config->border_thickness * 2 - 2)
* output_scale;
if (texture_box.width > available) {
texture_box.width = available;
}
render_texture(output->wlr_output, damage, title_texture,
&texture_box, matrix, 1.0);
title_width = texture_box.width;
}
// Title background - above the text
memcpy(&color, colors->background, sizeof(float) * 4);
premultiply_alpha(color, con->alpha);
box.x = x + 1;
box.y = parent->y + 1;
box.width = tab_width - 2;
box.height = config->border_thickness - 1;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
// Title background - below the text
box.y = (parent->y + config->border_thickness + config->font_height)
* output_scale;
render_rect(output->wlr_output, damage, &box, color);
// Title background - left of text
box.x = x + 1;
box.y = parent->y + config->border_thickness;
box.width = config->border_thickness;
box.height = config->font_height;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
// Title background - right of text
box.x = (x + 1 + config->border_thickness) * output_scale + title_width;
box.y = (parent->y + config->border_thickness) * output_scale;
box.width = (tab_width - config->border_thickness - 2) * output_scale
- title_width;
box.height = config->font_height * output_scale;
render_rect(output->wlr_output, damage, &box, color);
}
static void render_tab_content(struct sway_output *output,
pixman_region32_t *damage, struct sway_container *con,
struct border_colors *colors) {
struct sway_view *view = con->sway_view;
render_view(view, output, damage);
struct wlr_box box;
float output_scale = output->wlr_output->scale;
float color[4];
if (view->border != B_NONE) {
if (view->border_left) {
memcpy(&color, colors->child_border, sizeof(float) * 4);
premultiply_alpha(color, con->alpha);
box.x = con->x;
box.y = con->y + config->border_thickness * 2 + config->font_height;
box.width = view->border_thickness;
box.height = view->height;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
}
if (view->border_right) {
memcpy(&color, colors->child_border, sizeof(float) * 4);
premultiply_alpha(color, con->alpha);
box.x = view->x + view->width;
box.y = con->y + config->border_thickness * 2 + config->font_height;
box.width = view->border_thickness;
box.height = view->height;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
}
if (view->border_bottom) {
memcpy(&color, colors->child_border, sizeof(float) * 4);
premultiply_alpha(color, con->alpha);
box.x = con->x;
box.y = view->y + view->height;
box.width = con->width;
box.height = view->border_thickness;
scale_box(&box, output_scale);
render_rect(output->wlr_output, damage, &box, color);
}
}
}
/**
* Render a container's children using the L_TABBED layout.
*/
static void render_container_tabbed(struct sway_output *output,
pixman_region32_t *damage, struct sway_container *con) {
// TODO
pixman_region32_t *damage, struct sway_container *con,
bool parent_focused) {
if (!con->children->length) {
return;
}
struct sway_seat *seat = input_manager_current_seat(input_manager);
struct sway_container *focus = seat_get_focus(seat);
struct sway_container *current = seat_get_active_child(seat, con);
struct border_colors *current_colors = NULL;
// Render tabs
for (int i = 0; i < con->children->length; ++i) {
struct sway_container *child = con->children->items[i];
struct border_colors *colors;
struct wlr_texture *title_texture;
if (focus == child || parent_focused) {
colors = &config->border_colors.focused;
title_texture = child->title_focused;
} else if (child == current) {
colors = &config->border_colors.focused_inactive;
title_texture = child->title_focused_inactive;
} else {
colors = &config->border_colors.unfocused;
title_texture = child->title_unfocused;
}
render_tab(output, damage, con, i, colors, title_texture);
if (child == current) {
current_colors = colors;
}
}
// Render surface and left/right/bottom borders
if (current->type == C_VIEW) {
render_tab_content(output, damage, current, current_colors);
} else {
render_container(output, damage, current,
parent_focused || current == focus);
}
}
/**
@ -628,7 +811,7 @@ static void render_container(struct sway_output *output,
render_container_stacked(output, damage, con);
break;
case L_TABBED:
render_container_tabbed(output, damage, con);
render_container_tabbed(output, damage, con, parent_focused);
break;
case L_FLOATING:
// TODO
@ -896,9 +1079,7 @@ static void output_damage_view(struct sway_output *output,
return;
}
struct sway_container *workspace = container_parent(view->swayc,
C_WORKSPACE);
if (workspace->sway_workspace->fullscreen && !view->is_fullscreen) {
if (!view_is_visible(view)) {
return;
}

2
sway/input/cursor.c
View File

@ -108,7 +108,7 @@ static struct sway_container *container_at_coords(
}
struct sway_container *c;
if ((c = container_at(ws, x, y, surface, sx, sy))) {
if ((c = container_at(ws, ox, oy, surface, sx, sy))) {
return c;
}

12
sway/input/seat.c
View File

@ -718,6 +718,18 @@ struct sway_container *seat_get_focus_inactive(struct sway_seat *seat,
return seat_get_focus_by_type(seat, container, C_TYPES);
}
struct sway_container *seat_get_active_child(struct sway_seat *seat,
struct sway_container *container) {
struct sway_container *focus = seat_get_focus_inactive(seat, container);
if (!focus) {
return NULL;
}
while (focus->parent != container) {
focus = focus->parent;
}
return focus;
}
struct sway_container *sway_seat_get_focus(struct sway_seat *seat) {
if (!seat->has_focus) {
return NULL;

44
sway/tree/arrange.c
View File

@ -86,6 +86,13 @@ static void apply_horiz_layout(struct sway_container *parent) {
if (!num_children) {
return;
}
size_t parent_height = parent->height;
size_t parent_offset = 0;
if (parent->parent->layout == L_TABBED) {
parent_offset = config->border_thickness * 2 + config->font_height;
parent_height -= parent_offset;
}
// Calculate total width of children
double total_width = 0;
for (size_t i = 0; i < num_children; ++i) {
@ -111,9 +118,9 @@ static void apply_horiz_layout(struct sway_container *parent) {
"Calculating arrangement for %p:%d (will scale %f by %f)",
child, child->type, child->width, scale);
child->x = child_x;
child->y = parent->y;
child->y = parent->y + parent_offset;
child->width = floor(child->width * scale);
child->height = parent->height;
child->height = parent_height;
child_x += child->width;
}
// Make last child use remaining width of parent
@ -125,24 +132,31 @@ static void apply_vert_layout(struct sway_container *parent) {
if (!num_children) {
return;
}
size_t parent_height = parent->height;
size_t parent_offset = 0;
if (parent->parent->layout == L_TABBED) {
parent_offset = config->border_thickness * 2 + config->font_height;
parent_height -= parent_offset;
}
// Calculate total height of children
double total_height = 0;
for (size_t i = 0; i < num_children; ++i) {
struct sway_container *child = parent->children->items[i];
if (child->height <= 0) {
if (num_children > 1) {
child->height = parent->height / (num_children - 1);
child->height = parent_height / (num_children - 1);
} else {
child->height = parent->height;
child->height = parent_height;
}
}
total_height += child->height;
}
double scale = parent->height / total_height;
double scale = parent_height / total_height;
// Resize
wlr_log(L_DEBUG, "Arranging %p vertically", parent);
double child_y = parent->y;
double child_y = parent->y + parent_offset;
struct sway_container *child;
for (size_t i = 0; i < num_children; ++i) {
child = parent->children->items[i];
@ -156,7 +170,20 @@ static void apply_vert_layout(struct sway_container *parent) {
child_y += child->height;
}
// Make last child use remaining height of parent
child->height = parent->y + parent->height - child->y;
child->height = parent->y + parent_offset + parent_height - child->y;
}
static void apply_tabbed_layout(struct sway_container *parent) {
if (!parent->children->length) {
return;
}
for (int i = 0; i < parent->children->length; ++i) {
struct sway_container *child = parent->children->items[i];
child->x = parent->x;
child->y = parent->y;
child->width = parent->width;
child->height = parent->height;
}
}
void arrange_children_of(struct sway_container *parent) {
@ -189,6 +216,9 @@ void arrange_children_of(struct sway_container *parent) {
case L_VERT:
apply_vert_layout(parent);
break;
case L_TABBED:
apply_tabbed_layout(parent);
break;
default:
wlr_log(L_DEBUG, "TODO: arrange layout type %d", parent->layout);
apply_horiz_layout(parent);

204
sway/tree/container.c
View File

@ -452,34 +452,18 @@ struct sway_container *container_parent(struct sway_container *container,
return container;
}
struct sway_container *container_at(struct sway_container *parent,
double lx, double ly,
static struct sway_container *container_at_view(struct sway_container *swayc,
double ox, double oy,
struct wlr_surface **surface, double *sx, double *sy) {
list_t *queue = get_bfs_queue();
if (!queue) {
if (!sway_assert(swayc->type == C_VIEW, "Expected a view")) {
return NULL;
}
list_add(queue, parent);
struct sway_container *swayc = NULL;
while (queue->length) {
swayc = queue->items[0];
list_del(queue, 0);
if (swayc->type == C_VIEW) {
struct sway_view *sview = swayc->sway_view;
struct sway_container *soutput = container_parent(swayc, C_OUTPUT);
struct wlr_box *output_box =
wlr_output_layout_get_box(
root_container.sway_root->output_layout,
soutput->sway_output->wlr_output);
double ox = lx - output_box->x;
double oy = ly - output_box->y;
double view_sx = ox - sview->x;
double view_sy = oy - sview->y;
double _sx, _sy;
struct wlr_surface *_surface;
struct wlr_surface *_surface = NULL;
switch (sview->type) {
case SWAY_VIEW_XWAYLAND:
_surface = wlr_surface_surface_at(sview->surface,
@ -510,21 +494,96 @@ struct sway_container *container_at(struct sway_container *parent,
*sx = _sx;
*sy = _sy;
*surface = _surface;
return swayc;
}
// Check the view's decorations
struct wlr_box swayc_box = {
.x = swayc->x,
.y = swayc->y,
.width = swayc->width,
.height = swayc->height,
return swayc;
}
/**
* container_at for a container with layout L_TABBED.
*/
static struct sway_container *container_at_tabbed(struct sway_container *parent,
double ox, double oy,
struct wlr_surface **surface, double *sx, double *sy) {
if (oy < parent->y || oy > parent->y + parent->height) {
return NULL;
}
struct sway_seat *seat = input_manager_current_seat(input_manager);
// Tab titles
int title_height = config->border_thickness * 2 + config->font_height;
if (oy < parent->y + title_height) {
int tab_width = parent->width / parent->children->length;
int child_index = (ox - parent->x) / tab_width;
if (child_index >= parent->children->length) {
child_index = parent->children->length - 1;
}
struct sway_container *child = parent->children->items[child_index];
return seat_get_focus_inactive(seat, child);
}
// Surfaces
struct sway_container *current = seat_get_active_child(seat, parent);
return container_at(current, ox, oy, surface, sx, sy);
}
/**
* container_at for a container with layout L_STACKED.
*/
static struct sway_container *container_at_stacked(
struct sway_container *parent, double ox, double oy,
struct wlr_surface **surface, double *sx, double *sy) {
// TODO
return NULL;
}
/**
* container_at for a container with layout L_HORIZ or L_VERT.
*/
static struct sway_container *container_at_linear(struct sway_container *parent,
double ox, double oy,
struct wlr_surface **surface, double *sx, double *sy) {
for (int i = 0; i < parent->children->length; ++i) {
struct sway_container *child = parent->children->items[i];
struct wlr_box box = {
.x = child->x,
.y = child->y,
.width = child->width,
.height = child->height,
};
if (wlr_box_contains_point(&swayc_box, ox, oy)) {
return swayc;
if (wlr_box_contains_point(&box, ox, oy)) {
return container_at(child, ox, oy, surface, sx, sy);
}
} else {
list_cat(queue, swayc->children);
}
return NULL;
}
struct sway_container *container_at(struct sway_container *parent,
double ox, double oy,
struct wlr_surface **surface, double *sx, double *sy) {
if (!sway_assert(parent->type >= C_WORKSPACE,
"Expected workspace or deeper")) {
return NULL;
}
if (parent->type == C_VIEW) {
return container_at_view(parent, ox, oy, surface, sx, sy);
}
if (!parent->children->length) {
return NULL;
}
switch (parent->layout) {
case L_HORIZ:
case L_VERT:
return container_at_linear(parent, ox, oy, surface, sx, sy);
case L_TABBED:
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;
}
return NULL;
@ -699,18 +758,91 @@ void container_calculate_title_height(struct sway_container *container) {
container->title_height = height;
}
/**
* Calculate and return the length of the concatenated child titles.
* An example concatenated title is: V[Terminal, Firefox]
* If buffer is not NULL, also populate the buffer with the concatenated title.
*/
static size_t concatenate_child_titles(struct sway_container *parent,
char *buffer) {
size_t len = 2; // V[
if (buffer) {
switch (parent->layout) {
case L_VERT:
strcpy(buffer, "V[");
break;
case L_HORIZ:
strcpy(buffer, "H[");
break;
case L_TABBED:
strcpy(buffer, "T[");
break;
case L_STACKED:
strcpy(buffer, "S[");
break;
case L_FLOATING:
strcpy(buffer, "F[");
break;
case L_NONE:
strcpy(buffer, "D[");
break;
}
}
for (int i = 0; i < parent->children->length; ++i) {
if (i != 0) {
len += 1;
if (buffer) {
strcat(buffer, " ");
}
}
struct sway_container *child = parent->children->items[i];
const char *identifier = NULL;
if (child->type == C_VIEW) {
identifier = view_get_class(child->sway_view);
if (!identifier) {
identifier = view_get_app_id(child->sway_view);
}
} else {
identifier = child->name;
}
if (identifier) {
len += strlen(identifier);
if (buffer) {
strcat(buffer, identifier);
}
} else {
len += 6;
if (buffer) {
strcat(buffer, "(null)");
}
}
}
len += 1;
if (buffer) {
strcat(buffer, "]");
}
return len;
}
void container_notify_child_title_changed(struct sway_container *container) {
if (!container || container->type != C_CONTAINER) {
return;
}
if (container->layout != L_TABBED && container->layout != L_STACKED) {
return;
}
if (container->formatted_title) {
free(container->formatted_title);
}
// TODO: iterate children and concatenate their titles
container->formatted_title = strdup("");
size_t len = concatenate_child_titles(container, NULL);
char *buffer = calloc(len + 1, sizeof(char));
if (!sway_assert(buffer, "Unable to allocate title string")) {
return;
}
concatenate_child_titles(container, buffer);
container->name = buffer;
container->formatted_title = buffer;
container_calculate_title_height(container);
container_update_title_textures(container);
container_notify_child_title_changed(container->parent);

11
sway/tree/layout.c
View File

@ -149,6 +149,8 @@ struct sway_container *container_remove_child(struct sway_container *child) {
}
}
child->parent = NULL;
container_notify_child_title_changed(parent);
return parent;
}
@ -182,6 +184,8 @@ void container_move_to(struct sway_container *container,
container_sort_workspaces(new_parent);
seat_set_focus(seat, new_parent);
}
container_notify_child_title_changed(old_parent);
container_notify_child_title_changed(new_parent);
if (old_parent) {
arrange_children_of(old_parent);
}
@ -234,9 +238,9 @@ static bool is_parallel(enum sway_container_layout layout,
enum movement_direction dir) {
switch (layout) {
case L_TABBED:
case L_STACKED:
case L_HORIZ:
return dir == MOVE_LEFT || dir == MOVE_RIGHT;
case L_STACKED:
case L_VERT:
return dir == MOVE_UP || dir == MOVE_DOWN;
default:
@ -485,6 +489,9 @@ void container_move(struct sway_container *container,
}
}
container_notify_child_title_changed(old_parent);
container_notify_child_title_changed(container->parent);
if (old_parent) {
seat_set_focus(config->handler_context.seat, old_parent);
seat_set_focus(config->handler_context.seat, container);
@ -832,6 +839,8 @@ struct sway_container *container_split(struct sway_container *child,
container_add_child(cont, child);
}
container_notify_child_title_changed(cont);
return cont;
}

57
sway/tree/view.c
View File

@ -167,32 +167,53 @@ void view_autoconfigure(struct sway_view *view) {
double x, y, width, height;
x = y = width = height = 0;
double y_offset = 0;
// In a tabbed or stacked container, the swayc's y is the top of the 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.
if (view->swayc->parent->layout == L_TABBED) {
y_offset = config->border_thickness * 2 + config->font_height;
view->border_top = 0;
} else if (view->swayc->parent->layout == L_STACKED) {
y_offset = config->border_thickness * 2 + config->font_height;
y_offset *= view->swayc->parent->children->length;
view->border_top = 0;
}
switch (view->border) {
case B_NONE:
x = view->swayc->x;
y = view->swayc->y;
y = view->swayc->y + y_offset;
width = view->swayc->width;
height = view->swayc->height;
height = view->swayc->height - y_offset;
break;
case B_PIXEL:
x = view->swayc->x + view->border_thickness * view->border_left;
y = view->swayc->y + view->border_thickness * view->border_top;
y = view->swayc->y + view->border_thickness * view->border_top + y_offset;
width = view->swayc->width
- view->border_thickness * view->border_left
- view->border_thickness * view->border_right;
height = view->swayc->height
height = view->swayc->height - y_offset
- view->border_thickness * view->border_top
- view->border_thickness * view->border_bottom;
break;
case B_NORMAL:
// Height is: border + title height + border + view height + border
x = view->swayc->x + view->border_thickness * view->border_left;
y = view->swayc->y + config->font_height + view->border_thickness * 2;
width = view->swayc->width
- view->border_thickness * view->border_left
- view->border_thickness * view->border_right;
if (y_offset) {
y = view->swayc->y + y_offset;
height = view->swayc->height - y_offset
- view->border_thickness * view->border_bottom;
} else {
y = view->swayc->y + config->font_height + view->border_thickness * 2
+ y_offset;
height = view->swayc->height - config->font_height
- view->border_thickness * (2 + view->border_bottom);
}
break;
}
@ -441,6 +462,7 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface) {
input_manager_set_focus(input_manager, cont);
view_update_title(view, false);
container_notify_child_title_changed(view->swayc->parent);
view_execute_criteria(view);
container_damage_whole(cont);
@ -864,3 +886,28 @@ void view_update_marks_textures(struct sway_view *view) {
&config->border_colors.urgent);
container_damage_whole(view->swayc);
}
bool view_is_visible(struct sway_view *view) {
if (!view->swayc) {
return false;
}
// 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;
while (container->type != C_WORKSPACE) {
if (container->parent->layout == L_TABBED ||
container->parent->layout == L_STACKED) {
if (seat_get_active_child(seat, container->parent) != container) {
return false;
}
}
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);
}