e83e5487be
This allows the title's texture to always be the full width of the text, and clipped at render time according to the desired width (eg. tabs...). As an added bonus, the texture no longer needs to be updated when containers are arranged.
825 lines
24 KiB
C
825 lines
24 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <strings.h>
|
|
#include <time.h>
|
|
#include <wayland-server.h>
|
|
#include <wlr/render/wlr_renderer.h>
|
|
#include <wlr/types/wlr_box.h>
|
|
#include <wlr/types/wlr_matrix.h>
|
|
#include <wlr/types/wlr_output_damage.h>
|
|
#include <wlr/types/wlr_output_layout.h>
|
|
#include <wlr/types/wlr_output.h>
|
|
#include <wlr/types/wlr_surface.h>
|
|
#include <wlr/types/wlr_wl_shell.h>
|
|
#include <wlr/util/region.h>
|
|
#include "log.h"
|
|
#include "sway/input/input-manager.h"
|
|
#include "sway/input/seat.h"
|
|
#include "sway/layers.h"
|
|
#include "sway/output.h"
|
|
#include "sway/server.h"
|
|
#include "sway/tree/arrange.h"
|
|
#include "sway/tree/container.h"
|
|
#include "sway/tree/layout.h"
|
|
#include "sway/tree/view.h"
|
|
#include "sway/tree/workspace.h"
|
|
|
|
struct sway_container *output_by_name(const char *name) {
|
|
for (int i = 0; i < root_container.children->length; ++i) {
|
|
struct sway_container *output = root_container.children->items[i];
|
|
if (strcasecmp(output->name, name) == 0) {
|
|
return output;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Rotate a child's position relative to a parent. The parent size is (pw, ph),
|
|
* the child position is (*sx, *sy) and its size is (sw, sh).
|
|
*/
|
|
static void rotate_child_position(double *sx, double *sy, double sw, double sh,
|
|
double pw, double ph, float rotation) {
|
|
if (rotation == 0.0f) {
|
|
return;
|
|
}
|
|
|
|
// Coordinates relative to the center of the subsurface
|
|
double ox = *sx - pw/2 + sw/2,
|
|
oy = *sy - ph/2 + sh/2;
|
|
// Rotated coordinates
|
|
double rx = cos(-rotation)*ox - sin(-rotation)*oy,
|
|
ry = cos(-rotation)*oy + sin(-rotation)*ox;
|
|
*sx = rx + pw/2 - sw/2;
|
|
*sy = ry + ph/2 - sh/2;
|
|
}
|
|
|
|
/**
|
|
* Contains a surface's root geometry information. For instance, when rendering
|
|
* a popup, this will contain the parent view's position and size.
|
|
*/
|
|
struct root_geometry {
|
|
double x, y;
|
|
int width, height;
|
|
float rotation;
|
|
};
|
|
|
|
static bool get_surface_box(struct root_geometry *geo,
|
|
struct sway_output *output, struct wlr_surface *surface, int sx, int sy,
|
|
struct wlr_box *surface_box) {
|
|
if (!wlr_surface_has_buffer(surface)) {
|
|
return false;
|
|
}
|
|
|
|
int sw = surface->current->width;
|
|
int sh = surface->current->height;
|
|
|
|
double _sx = sx, _sy = sy;
|
|
rotate_child_position(&_sx, &_sy, sw, sh, geo->width, geo->height,
|
|
geo->rotation);
|
|
|
|
struct wlr_box box = {
|
|
.x = geo->x + _sx,
|
|
.y = geo->y + _sy,
|
|
.width = sw,
|
|
.height = sh,
|
|
};
|
|
if (surface_box != NULL) {
|
|
memcpy(surface_box, &box, sizeof(struct wlr_box));
|
|
}
|
|
|
|
struct wlr_box rotated_box;
|
|
wlr_box_rotated_bounds(&box, geo->rotation, &rotated_box);
|
|
|
|
struct wlr_box output_box = {
|
|
.width = output->swayc->width,
|
|
.height = output->swayc->height,
|
|
};
|
|
|
|
struct wlr_box intersection;
|
|
return wlr_box_intersection(&output_box, &rotated_box, &intersection);
|
|
}
|
|
|
|
static void surface_for_each_surface(struct wlr_surface *surface,
|
|
double ox, double oy, struct root_geometry *geo,
|
|
wlr_surface_iterator_func_t iterator, void *user_data) {
|
|
geo->x = ox;
|
|
geo->y = oy;
|
|
geo->width = surface->current->width;
|
|
geo->height = surface->current->height;
|
|
geo->rotation = 0;
|
|
|
|
wlr_surface_for_each_surface(surface, iterator, user_data);
|
|
}
|
|
|
|
static void output_view_for_each_surface(struct sway_view *view,
|
|
struct root_geometry *geo, wlr_surface_iterator_func_t iterator,
|
|
void *user_data) {
|
|
geo->x = view->x;
|
|
geo->y = view->y;
|
|
geo->width = view->surface->current->width;
|
|
geo->height = view->surface->current->height;
|
|
geo->rotation = 0; // TODO
|
|
|
|
view_for_each_surface(view, iterator, user_data);
|
|
}
|
|
|
|
static void layer_for_each_surface(struct wl_list *layer_surfaces,
|
|
struct root_geometry *geo, wlr_surface_iterator_func_t iterator,
|
|
void *user_data) {
|
|
struct sway_layer_surface *layer_surface;
|
|
wl_list_for_each(layer_surface, layer_surfaces, link) {
|
|
struct wlr_layer_surface *wlr_layer_surface =
|
|
layer_surface->layer_surface;
|
|
surface_for_each_surface(wlr_layer_surface->surface,
|
|
layer_surface->geo.x, layer_surface->geo.y, geo, iterator,
|
|
user_data);
|
|
}
|
|
}
|
|
|
|
static void unmanaged_for_each_surface(struct wl_list *unmanaged,
|
|
struct sway_output *output, struct root_geometry *geo,
|
|
wlr_surface_iterator_func_t iterator, void *user_data) {
|
|
struct sway_xwayland_unmanaged *unmanaged_surface;
|
|
wl_list_for_each(unmanaged_surface, unmanaged, link) {
|
|
struct wlr_xwayland_surface *xsurface =
|
|
unmanaged_surface->wlr_xwayland_surface;
|
|
double ox = unmanaged_surface->lx - output->swayc->x;
|
|
double oy = unmanaged_surface->ly - output->swayc->y;
|
|
|
|
surface_for_each_surface(xsurface->surface, ox, oy, geo,
|
|
iterator, user_data);
|
|
}
|
|
}
|
|
|
|
static void scale_box(struct wlr_box *box, float scale) {
|
|
box->x *= scale;
|
|
box->y *= scale;
|
|
box->width *= scale;
|
|
box->height *= scale;
|
|
}
|
|
|
|
struct render_data {
|
|
struct root_geometry root_geo;
|
|
struct sway_output *output;
|
|
float alpha;
|
|
};
|
|
|
|
static void render_surface_iterator(struct wlr_surface *surface, int sx, int sy,
|
|
void *_data) {
|
|
struct render_data *data = _data;
|
|
struct wlr_output *wlr_output = data->output->wlr_output;
|
|
float rotation = data->root_geo.rotation;
|
|
float alpha = data->alpha;
|
|
|
|
if (!wlr_surface_has_buffer(surface)) {
|
|
return;
|
|
}
|
|
|
|
struct wlr_box box;
|
|
bool intersects = get_surface_box(&data->root_geo, data->output, surface,
|
|
sx, sy, &box);
|
|
if (!intersects) {
|
|
return;
|
|
}
|
|
|
|
struct wlr_renderer *renderer =
|
|
wlr_backend_get_renderer(wlr_output->backend);
|
|
if (!sway_assert(renderer != NULL,
|
|
"expected the output backend to have a renderer")) {
|
|
return;
|
|
}
|
|
|
|
scale_box(&box, wlr_output->scale);
|
|
|
|
float matrix[9];
|
|
enum wl_output_transform transform =
|
|
wlr_output_transform_invert(surface->current->transform);
|
|
wlr_matrix_project_box(matrix, &box, transform, rotation,
|
|
wlr_output->transform_matrix);
|
|
|
|
wlr_render_texture_with_matrix(renderer, surface->texture,
|
|
matrix, alpha);
|
|
}
|
|
|
|
static void render_layer(struct sway_output *output,
|
|
struct wl_list *layer_surfaces) {
|
|
struct render_data data = { .output = output, .alpha = 1.0f };
|
|
layer_for_each_surface(layer_surfaces, &data.root_geo,
|
|
render_surface_iterator, &data);
|
|
}
|
|
|
|
static void render_unmanaged(struct sway_output *output,
|
|
struct wl_list *unmanaged) {
|
|
struct render_data data = { .output = output, .alpha = 1.0f };
|
|
unmanaged_for_each_surface(unmanaged, output, &data.root_geo,
|
|
render_surface_iterator, &data);
|
|
}
|
|
|
|
static void render_view(struct sway_view *view, struct sway_output *output) {
|
|
struct render_data data = { .output = output, .alpha = view->swayc->alpha };
|
|
output_view_for_each_surface(
|
|
view, &data.root_geo, render_surface_iterator, &data);
|
|
}
|
|
|
|
/**
|
|
* Render decorations for a view with "border normal".
|
|
*/
|
|
static void render_container_simple_border_normal(struct sway_output *output,
|
|
struct sway_container *con, struct border_colors *colors,
|
|
struct wlr_texture *title_texture) {
|
|
struct wlr_renderer *renderer =
|
|
wlr_backend_get_renderer(output->wlr_output->backend);
|
|
struct wlr_box box;
|
|
float color[4];
|
|
|
|
// Child border - left edge
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
color[3] *= con->alpha;
|
|
box.x = con->x;
|
|
box.y = con->y + 1;
|
|
box.width = con->sway_view->border_thickness;
|
|
box.height = con->height - 1;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Child border - right edge
|
|
if (con->parent->children->length == 1 && con->parent->layout == L_HORIZ) {
|
|
memcpy(&color, colors->indicator, sizeof(float) * 4);
|
|
} else {
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
}
|
|
color[3] *= con->alpha;
|
|
box.x = con->x + con->width - con->sway_view->border_thickness;
|
|
box.y = con->y + 1;
|
|
box.width = con->sway_view->border_thickness;
|
|
box.height = con->height - 1;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Child border - bottom edge
|
|
if (con->parent->children->length == 1 && con->parent->layout == L_VERT) {
|
|
memcpy(&color, colors->indicator, sizeof(float) * 4);
|
|
} else {
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
}
|
|
color[3] *= con->alpha;
|
|
box.x = con->x;
|
|
box.y = con->y + con->height - con->sway_view->border_thickness;
|
|
box.width = con->width;
|
|
box.height = con->sway_view->border_thickness;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Single pixel bar above title
|
|
memcpy(&color, colors->border, sizeof(float) * 4);
|
|
color[3] *= con->alpha;
|
|
box.x = con->x;
|
|
box.y = con->y;
|
|
box.width = con->width;
|
|
box.height = 1;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Single pixel bar below title
|
|
box.x = con->x + con->sway_view->border_thickness;
|
|
box.y = con->sway_view->y - 1;
|
|
box.width = con->width - con->sway_view->border_thickness * 2;
|
|
box.height = 1;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Title background
|
|
memcpy(&color, colors->background, sizeof(float) * 4);
|
|
color[3] *= con->alpha;
|
|
box.x = con->x + con->sway_view->border_thickness;
|
|
box.y = con->y + 1;
|
|
box.width = con->width - con->sway_view->border_thickness * 2;
|
|
box.height = con->sway_view->y - con->y - 2;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Title text
|
|
if (title_texture) {
|
|
wlr_renderer_scissor(renderer, &box);
|
|
wlr_render_texture(renderer, title_texture,
|
|
output->wlr_output->transform_matrix, box.x, box.y, 1);
|
|
wlr_renderer_scissor(renderer, NULL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Render decorations for a view with "border pixel".
|
|
*/
|
|
static void render_container_simple_border_pixel(struct sway_output *output,
|
|
struct sway_container *con, struct border_colors *colors) {
|
|
struct wlr_renderer *renderer =
|
|
wlr_backend_get_renderer(output->wlr_output->backend);
|
|
struct wlr_box box;
|
|
float color[4];
|
|
|
|
// Child border - left edge
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
color[3] *= con->alpha;
|
|
box.x = con->x;
|
|
box.y = con->y;
|
|
box.width = con->sway_view->border_thickness;
|
|
box.height = con->height;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Child border - right edge
|
|
if (con->parent->children->length == 1 && con->parent->layout == L_HORIZ) {
|
|
memcpy(&color, colors->indicator, sizeof(float) * 4);
|
|
} else {
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
}
|
|
color[3] *= con->alpha;
|
|
box.x = con->x + con->width - con->sway_view->border_thickness;
|
|
box.y = con->y;
|
|
box.width = con->sway_view->border_thickness;
|
|
box.height = con->height;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Child border - top edge
|
|
box.x = con->x;
|
|
box.y = con->y;
|
|
box.width = con->width;
|
|
box.height = con->sway_view->border_thickness;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
|
|
// Child border - bottom edge
|
|
if (con->parent->children->length == 1 && con->parent->layout == L_VERT) {
|
|
memcpy(&color, colors->indicator, sizeof(float) * 4);
|
|
} else {
|
|
memcpy(&color, colors->child_border, sizeof(float) * 4);
|
|
}
|
|
color[3] *= con->alpha;
|
|
box.x = con->x;
|
|
box.y = con->y + con->height - con->sway_view->border_thickness;
|
|
box.width = con->width;
|
|
box.height = con->sway_view->border_thickness;
|
|
scale_box(&box, output->wlr_output->scale);
|
|
wlr_render_rect(renderer, &box, color,
|
|
output->wlr_output->transform_matrix);
|
|
}
|
|
|
|
static void render_container(struct sway_output *output,
|
|
struct sway_container *con);
|
|
|
|
/**
|
|
* Render a container's children using a L_HORIZ or L_VERT layout.
|
|
*
|
|
* Wrap child views in borders and leave child containers borderless because
|
|
* they'll apply their own borders to their children.
|
|
*/
|
|
static void render_container_simple(struct sway_output *output,
|
|
struct sway_container *con) {
|
|
struct sway_seat *seat = input_manager_current_seat(input_manager);
|
|
struct sway_container *focus = seat_get_focus(seat);
|
|
|
|
for (int i = 0; i < con->children->length; ++i) {
|
|
struct sway_container *child = con->children->items[i];
|
|
|
|
if (child->type == C_VIEW) {
|
|
if (child->sway_view->border != B_NONE) {
|
|
struct border_colors *colors;
|
|
struct wlr_texture *title_texture;
|
|
if (focus == child) {
|
|
colors = &config->border_colors.focused;
|
|
title_texture = child->title_focused;
|
|
} else if (seat_get_focus_inactive(seat, con) == child) {
|
|
colors = &config->border_colors.focused_inactive;
|
|
title_texture = child->title_focused_inactive;
|
|
} else {
|
|
colors = &config->border_colors.unfocused;
|
|
title_texture = child->title_unfocused;
|
|
}
|
|
|
|
if (child->sway_view->border == B_NORMAL) {
|
|
render_container_simple_border_normal(output, child,
|
|
colors, title_texture);
|
|
} else {
|
|
render_container_simple_border_pixel(output, child, colors);
|
|
}
|
|
}
|
|
render_view(child->sway_view, output);
|
|
} else {
|
|
render_container(output, child);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Render a container's children using the L_TABBED layout.
|
|
*/
|
|
static void render_container_tabbed(struct sway_output *output,
|
|
struct sway_container *con) {
|
|
// TODO
|
|
}
|
|
|
|
/**
|
|
* Render a container's children using the L_STACKED layout.
|
|
*/
|
|
static void render_container_stacked(struct sway_output *output,
|
|
struct sway_container *con) {
|
|
// TODO
|
|
}
|
|
|
|
static void render_container(struct sway_output *output,
|
|
struct sway_container *con) {
|
|
switch (con->layout) {
|
|
case L_NONE:
|
|
case L_HORIZ:
|
|
case L_VERT:
|
|
render_container_simple(output, con);
|
|
break;
|
|
case L_STACKED:
|
|
render_container_stacked(output, con);
|
|
break;
|
|
case L_TABBED:
|
|
render_container_tabbed(output, con);
|
|
break;
|
|
case L_FLOATING:
|
|
// TODO
|
|
break;
|
|
}
|
|
}
|
|
|
|
static struct sway_container *output_get_active_workspace(
|
|
struct sway_output *output) {
|
|
struct sway_seat *seat = input_manager_current_seat(input_manager);
|
|
struct sway_container *focus =
|
|
seat_get_focus_inactive(seat, output->swayc);
|
|
if (!focus) {
|
|
// We've never been to this output before
|
|
focus = output->swayc->children->items[0];
|
|
}
|
|
struct sway_container *workspace = focus;
|
|
if (workspace->type != C_WORKSPACE) {
|
|
workspace = container_parent(workspace, C_WORKSPACE);
|
|
}
|
|
return workspace;
|
|
}
|
|
|
|
static void render_output(struct sway_output *output, struct timespec *when,
|
|
pixman_region32_t *damage) {
|
|
struct wlr_output *wlr_output = output->wlr_output;
|
|
|
|
struct wlr_renderer *renderer =
|
|
wlr_backend_get_renderer(wlr_output->backend);
|
|
if (!sway_assert(renderer != NULL,
|
|
"expected the output backend to have a renderer")) {
|
|
return;
|
|
}
|
|
|
|
wlr_renderer_begin(renderer, wlr_output->width, wlr_output->height);
|
|
|
|
if (!pixman_region32_not_empty(damage)) {
|
|
// Output isn't damaged but needs buffer swap
|
|
goto renderer_end;
|
|
}
|
|
|
|
// TODO: don't damage the whole output
|
|
int width, height;
|
|
wlr_output_transformed_resolution(wlr_output, &width, &height);
|
|
pixman_region32_union_rect(damage, damage, 0, 0, width, height);
|
|
|
|
struct sway_container *workspace = output_get_active_workspace(output);
|
|
|
|
if (workspace->sway_workspace->fullscreen) {
|
|
float clear_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
|
|
wlr_renderer_clear(renderer, clear_color);
|
|
// TODO: handle views smaller than the output
|
|
render_view(workspace->sway_workspace->fullscreen, output);
|
|
|
|
if (workspace->sway_workspace->fullscreen->type == SWAY_VIEW_XWAYLAND) {
|
|
render_unmanaged(output,
|
|
&root_container.sway_root->xwayland_unmanaged);
|
|
}
|
|
} else {
|
|
float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f};
|
|
wlr_renderer_clear(renderer, clear_color);
|
|
|
|
render_layer(output,
|
|
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
|
|
render_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
|
|
|
|
render_container(output, workspace);
|
|
|
|
render_unmanaged(output, &root_container.sway_root->xwayland_unmanaged);
|
|
render_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
|
|
}
|
|
render_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
|
|
|
|
renderer_end:
|
|
if (root_container.sway_root->debug_tree) {
|
|
wlr_render_texture(renderer, root_container.sway_root->debug_tree,
|
|
wlr_output->transform_matrix, 0, 0, 1);
|
|
}
|
|
|
|
wlr_renderer_end(renderer);
|
|
if (!wlr_output_damage_swap_buffers(output->damage, when, damage)) {
|
|
return;
|
|
}
|
|
output->last_frame = *when;
|
|
}
|
|
|
|
struct send_frame_done_data {
|
|
struct root_geometry root_geo;
|
|
struct sway_output *output;
|
|
struct timespec *when;
|
|
};
|
|
|
|
static void send_frame_done_iterator(struct wlr_surface *surface,
|
|
int sx, int sy, void *_data) {
|
|
struct send_frame_done_data *data = _data;
|
|
|
|
bool intersects = get_surface_box(&data->root_geo, data->output, surface,
|
|
sx, sy, NULL);
|
|
if (intersects) {
|
|
wlr_surface_send_frame_done(surface, data->when);
|
|
}
|
|
}
|
|
|
|
static void send_frame_done_layer(struct send_frame_done_data *data,
|
|
struct wl_list *layer_surfaces) {
|
|
layer_for_each_surface(layer_surfaces, &data->root_geo,
|
|
send_frame_done_iterator, data);
|
|
}
|
|
|
|
static void send_frame_done_unmanaged(struct send_frame_done_data *data,
|
|
struct wl_list *unmanaged) {
|
|
unmanaged_for_each_surface(unmanaged, data->output, &data->root_geo,
|
|
send_frame_done_iterator, data);
|
|
}
|
|
|
|
static void send_frame_done_container_iterator(struct sway_container *con,
|
|
void *_data) {
|
|
struct send_frame_done_data *data = _data;
|
|
if (!sway_assert(con->type == C_VIEW, "expected a view")) {
|
|
return;
|
|
}
|
|
output_view_for_each_surface(con->sway_view, &data->root_geo,
|
|
send_frame_done_iterator, data);
|
|
}
|
|
|
|
static void send_frame_done_container(struct send_frame_done_data *data,
|
|
struct sway_container *con) {
|
|
container_descendants(con, C_VIEW,
|
|
send_frame_done_container_iterator, data);
|
|
}
|
|
|
|
static void send_frame_done(struct sway_output *output, struct timespec *when) {
|
|
struct send_frame_done_data data = {
|
|
.output = output,
|
|
.when = when,
|
|
};
|
|
|
|
send_frame_done_layer(&data,
|
|
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
|
|
send_frame_done_layer(&data,
|
|
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
|
|
|
|
struct sway_container *workspace = output_get_active_workspace(output);
|
|
send_frame_done_container(&data, workspace);
|
|
|
|
send_frame_done_unmanaged(&data,
|
|
&root_container.sway_root->xwayland_unmanaged);
|
|
|
|
send_frame_done_layer(&data,
|
|
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
|
|
send_frame_done_layer(&data,
|
|
&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
|
|
}
|
|
|
|
static void damage_handle_frame(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output =
|
|
wl_container_of(listener, output, damage_frame);
|
|
|
|
if (!output->wlr_output->enabled) {
|
|
return;
|
|
}
|
|
|
|
struct timespec now;
|
|
clock_gettime(CLOCK_MONOTONIC, &now);
|
|
|
|
bool needs_swap;
|
|
pixman_region32_t damage;
|
|
pixman_region32_init(&damage);
|
|
if (!wlr_output_damage_make_current(output->damage, &needs_swap, &damage)) {
|
|
return;
|
|
}
|
|
|
|
if (needs_swap) {
|
|
render_output(output, &now, &damage);
|
|
}
|
|
|
|
pixman_region32_fini(&damage);
|
|
|
|
// Send frame done to all visible surfaces
|
|
send_frame_done(output, &now);
|
|
}
|
|
|
|
void output_damage_whole(struct sway_output *output) {
|
|
wlr_output_damage_add_whole(output->damage);
|
|
}
|
|
|
|
struct damage_data {
|
|
struct root_geometry root_geo;
|
|
struct sway_output *output;
|
|
bool whole;
|
|
};
|
|
|
|
static void damage_surface_iterator(struct wlr_surface *surface, int sx, int sy,
|
|
void *_data) {
|
|
struct damage_data *data = _data;
|
|
struct sway_output *output = data->output;
|
|
float rotation = data->root_geo.rotation;
|
|
bool whole = data->whole;
|
|
|
|
struct wlr_box box;
|
|
bool intersects = get_surface_box(&data->root_geo, data->output, surface,
|
|
sx, sy, &box);
|
|
if (!intersects) {
|
|
return;
|
|
}
|
|
|
|
scale_box(&box, output->wlr_output->scale);
|
|
|
|
if (whole) {
|
|
wlr_box_rotated_bounds(&box, rotation, &box);
|
|
wlr_output_damage_add_box(output->damage, &box);
|
|
} else {
|
|
int center_x = box.x + box.width/2;
|
|
int center_y = box.y + box.height/2;
|
|
|
|
pixman_region32_t damage;
|
|
pixman_region32_init(&damage);
|
|
pixman_region32_copy(&damage, &surface->current->surface_damage);
|
|
wlr_region_scale(&damage, &damage, output->wlr_output->scale);
|
|
if (ceil(output->wlr_output->scale) > surface->current->scale) {
|
|
// When scaling up a surface, it'll become blurry so we need to
|
|
// expand the damage region
|
|
wlr_region_expand(&damage, &damage,
|
|
ceil(output->wlr_output->scale) - surface->current->scale);
|
|
}
|
|
pixman_region32_translate(&damage, box.x, box.y);
|
|
wlr_region_rotated_bounds(&damage, &damage, rotation,
|
|
center_x, center_y);
|
|
wlr_output_damage_add(output->damage, &damage);
|
|
pixman_region32_fini(&damage);
|
|
}
|
|
}
|
|
|
|
void output_damage_surface(struct sway_output *output, double ox, double oy,
|
|
struct wlr_surface *surface, bool whole) {
|
|
struct damage_data data = {
|
|
.output = output,
|
|
.whole = whole,
|
|
};
|
|
|
|
surface_for_each_surface(surface, ox, oy, &data.root_geo,
|
|
damage_surface_iterator, &data);
|
|
}
|
|
|
|
void output_damage_view(struct sway_output *output, struct sway_view *view,
|
|
bool whole) {
|
|
if (!sway_assert(view->swayc != NULL, "expected a view in the tree")) {
|
|
return;
|
|
}
|
|
|
|
struct sway_container *workspace = container_parent(view->swayc,
|
|
C_WORKSPACE);
|
|
if (workspace->sway_workspace->fullscreen && !view->is_fullscreen) {
|
|
return;
|
|
}
|
|
|
|
struct damage_data data = {
|
|
.output = output,
|
|
.whole = whole,
|
|
};
|
|
|
|
output_view_for_each_surface(view, &data.root_geo,
|
|
damage_surface_iterator, &data);
|
|
}
|
|
|
|
static void output_damage_whole_container_iterator(struct sway_container *con,
|
|
void *data) {
|
|
struct sway_output *output = data;
|
|
|
|
if (!sway_assert(con->type == C_VIEW, "expected a view")) {
|
|
return;
|
|
}
|
|
|
|
output_damage_view(output, con->sway_view, true);
|
|
}
|
|
|
|
void output_damage_whole_container(struct sway_output *output,
|
|
struct sway_container *con) {
|
|
float scale = output->wlr_output->scale;
|
|
struct wlr_box box = {
|
|
.x = con->x * scale,
|
|
.y = con->y * scale,
|
|
.width = con->width * scale,
|
|
.height = con->height * scale,
|
|
};
|
|
wlr_output_damage_add_box(output->damage, &box);
|
|
|
|
container_descendants(con, C_VIEW, output_damage_whole_container_iterator,
|
|
output);
|
|
}
|
|
|
|
static void damage_handle_destroy(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output =
|
|
wl_container_of(listener, output, damage_destroy);
|
|
container_destroy(output->swayc);
|
|
}
|
|
|
|
static void handle_destroy(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output = wl_container_of(listener, output, destroy);
|
|
container_destroy(output->swayc);
|
|
}
|
|
|
|
static void handle_mode(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output = wl_container_of(listener, output, mode);
|
|
arrange_layers(output);
|
|
arrange_output(output->swayc);
|
|
}
|
|
|
|
static void handle_transform(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output = wl_container_of(listener, output, transform);
|
|
arrange_layers(output);
|
|
arrange_output(output->swayc);
|
|
}
|
|
|
|
static void handle_scale(struct wl_listener *listener, void *data) {
|
|
struct sway_output *output = wl_container_of(listener, output, scale);
|
|
arrange_layers(output);
|
|
arrange_output(output->swayc);
|
|
}
|
|
|
|
void handle_new_output(struct wl_listener *listener, void *data) {
|
|
struct sway_server *server = wl_container_of(listener, server, new_output);
|
|
struct wlr_output *wlr_output = data;
|
|
wlr_log(L_DEBUG, "New output %p: %s", wlr_output, wlr_output->name);
|
|
|
|
struct sway_output *output = calloc(1, sizeof(struct sway_output));
|
|
if (!output) {
|
|
return;
|
|
}
|
|
output->wlr_output = wlr_output;
|
|
wlr_output->data = output;
|
|
output->server = server;
|
|
|
|
if (!wl_list_empty(&wlr_output->modes)) {
|
|
struct wlr_output_mode *mode =
|
|
wl_container_of(wlr_output->modes.prev, mode, link);
|
|
wlr_output_set_mode(wlr_output, mode);
|
|
}
|
|
|
|
output->damage = wlr_output_damage_create(wlr_output);
|
|
|
|
output->swayc = output_create(output);
|
|
if (!output->swayc) {
|
|
free(output);
|
|
return;
|
|
}
|
|
|
|
size_t len = sizeof(output->layers) / sizeof(output->layers[0]);
|
|
for (size_t i = 0; i < len; ++i) {
|
|
wl_list_init(&output->layers[i]);
|
|
}
|
|
|
|
input_manager_configure_xcursor(input_manager);
|
|
|
|
wl_signal_add(&wlr_output->events.destroy, &output->destroy);
|
|
output->destroy.notify = handle_destroy;
|
|
wl_signal_add(&wlr_output->events.mode, &output->mode);
|
|
output->mode.notify = handle_mode;
|
|
wl_signal_add(&wlr_output->events.transform, &output->transform);
|
|
output->transform.notify = handle_transform;
|
|
wl_signal_add(&wlr_output->events.scale, &output->scale);
|
|
output->scale.notify = handle_scale;
|
|
|
|
wl_signal_add(&output->damage->events.frame, &output->damage_frame);
|
|
output->damage_frame.notify = damage_handle_frame;
|
|
wl_signal_add(&output->damage->events.destroy, &output->damage_destroy);
|
|
output->damage_destroy.notify = damage_handle_destroy;
|
|
|
|
arrange_layers(output);
|
|
arrange_root();
|
|
}
|