swayfx/sway/desktop/output.c

321 lines
11 KiB
C
Raw Normal View History

2017-11-12 06:41:18 +11:00
#define _POSIX_C_SOURCE 200809L
2018-01-15 02:35:56 +11:00
#include <assert.h>
2017-11-12 06:41:18 +11:00
#include <stdlib.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.h>
#include <wlr/types/wlr_output_layout.h>
2017-11-23 13:06:08 +11:00
#include <wlr/types/wlr_surface.h>
2018-01-15 03:47:48 +11:00
#include <wlr/types/wlr_wl_shell.h>
#include "log.h"
2017-11-20 09:04:28 +11:00
#include "sway/container.h"
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/layers.h"
2017-11-26 02:59:49 +11:00
#include "sway/layout.h"
2017-11-19 03:22:02 +11:00
#include "sway/output.h"
#include "sway/server.h"
2017-11-23 13:06:08 +11:00
#include "sway/view.h"
2018-01-15 02:35:56 +11:00
/**
* 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.0) {
// 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;
}
}
static void render_surface(struct wlr_surface *surface,
struct wlr_output *wlr_output, struct timespec *when,
double lx, double ly, float rotation) {
2017-11-23 13:06:08 +11:00
if (!wlr_surface_has_buffer(surface)) {
return;
}
2018-01-15 02:35:56 +11:00
struct wlr_output_layout *layout = root_container.sway_root->output_layout;
int width = surface->current->width;
int height = surface->current->height;
2017-11-23 13:06:08 +11:00
int render_width = width * wlr_output->scale;
int render_height = height * wlr_output->scale;
int owidth, oheight;
wlr_output_effective_resolution(wlr_output, &owidth, &oheight);
2017-12-11 00:48:44 +11:00
// FIXME: view coords are inconsistently assumed to be in output or layout coords
2018-02-18 08:30:32 +11:00
struct wlr_box layout_box = {
.x = lx + wlr_output->lx, .y = ly + wlr_output->ly,
2018-01-15 02:35:56 +11:00
.width = render_width, .height = render_height,
};
2018-02-18 08:30:32 +11:00
if (wlr_output_layout_intersects(layout, wlr_output, &layout_box)) {
struct wlr_box render_box = {
.x = lx, .y = ly,
2018-02-18 08:30:32 +11:00
.width = render_width, .height = render_height
};
float matrix[9];
wlr_matrix_project_box(matrix, &render_box, surface->current->transform,
0, wlr_output->transform_matrix);
wlr_render_texture_with_matrix(server.renderer, surface->texture,
matrix, 1.0f); // TODO: configurable alpha
2018-01-15 02:35:56 +11:00
wlr_surface_send_frame_done(surface, when);
}
2017-11-23 13:06:08 +11:00
2018-01-15 02:35:56 +11:00
struct wlr_subsurface *subsurface;
wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
struct wlr_surface_state *state = subsurface->surface->current;
double sx = state->subsurface_position.x;
double sy = state->subsurface_position.y;
double sw = state->buffer_width / state->scale;
double sh = state->buffer_height / state->scale;
rotate_child_position(&sx, &sy, sw, sh, width, height, rotation);
render_surface(subsurface->surface, wlr_output, when,
2018-03-29 09:10:43 +11:00
lx + sx, ly + sy, rotation);
2018-01-15 02:35:56 +11:00
}
}
2018-01-15 02:47:19 +11:00
static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface,
struct wlr_output *wlr_output, struct timespec *when, double base_x,
double base_y, float rotation) {
double width = surface->surface->current->width;
double height = surface->surface->current->height;
2018-02-11 07:49:07 +11:00
struct wlr_xdg_popup_v6 *popup_state;
wl_list_for_each(popup_state, &surface->popups, link) {
struct wlr_xdg_surface_v6 *popup = popup_state->base;
2018-01-15 02:47:19 +11:00
if (!popup->configured) {
continue;
}
double popup_width = popup->surface->current->width;
double popup_height = popup->surface->current->height;
double popup_sx, popup_sy;
wlr_xdg_surface_v6_popup_get_position(popup, &popup_sx, &popup_sy);
rotate_child_position(&popup_sx, &popup_sy, popup_width, popup_height,
width, height, rotation);
render_surface(popup->surface, wlr_output, when,
base_x + popup_sx, base_y + popup_sy, rotation);
render_xdg_v6_popups(popup, wlr_output, when,
base_x + popup_sx, base_y + popup_sy, rotation);
}
}
2018-01-15 03:47:48 +11:00
static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface,
struct wlr_output *wlr_output, struct timespec *when,
double lx, double ly, float rotation,
bool is_child) {
if (is_child || surface->state != WLR_WL_SHELL_SURFACE_STATE_POPUP) {
render_surface(surface->surface, wlr_output, when,
lx, ly, rotation);
double width = surface->surface->current->width;
double height = surface->surface->current->height;
struct wlr_wl_shell_surface *popup;
wl_list_for_each(popup, &surface->popups, popup_link) {
double popup_width = popup->surface->current->width;
double popup_height = popup->surface->current->height;
double popup_x = popup->transient_state->x;
double popup_y = popup->transient_state->y;
rotate_child_position(&popup_x, &popup_y, popup_width, popup_height,
width, height, rotation);
render_wl_shell_surface(popup, wlr_output, when,
lx + popup_x, ly + popup_y, rotation, true);
}
}
}
2018-03-29 09:10:43 +11:00
struct render_data {
struct sway_output *output;
struct timespec *now;
};
2018-01-15 03:47:48 +11:00
2018-01-15 02:35:56 +11:00
static void output_frame_view(swayc_t *view, void *data) {
2018-03-29 09:10:43 +11:00
struct render_data *rdata = data;
struct sway_output *output = rdata->output;
struct timespec *now = rdata->now;
2018-01-15 02:35:56 +11:00
struct wlr_output *wlr_output = output->wlr_output;
struct sway_view *sway_view = view->sway_view;
struct wlr_surface *surface = sway_view->surface;
2018-01-16 01:38:05 +11:00
if (!surface) {
return;
}
2018-01-15 02:35:56 +11:00
switch (sway_view->type) {
case SWAY_XDG_SHELL_V6_VIEW: {
int window_offset_x = view->sway_view->wlr_xdg_surface_v6->geometry.x;
int window_offset_y = view->sway_view->wlr_xdg_surface_v6->geometry.y;
2018-03-29 09:10:43 +11:00
render_surface(surface, wlr_output, now,
view->x - window_offset_x, view->y - window_offset_y, 0);
2018-01-15 02:47:19 +11:00
render_xdg_v6_popups(sway_view->wlr_xdg_surface_v6, wlr_output,
2018-03-29 09:10:43 +11:00
now, view->x - window_offset_x, view->y - window_offset_y, 0);
2018-01-15 02:35:56 +11:00
break;
}
case SWAY_WL_SHELL_VIEW:
2018-01-15 03:47:48 +11:00
render_wl_shell_surface(sway_view->wlr_wl_shell_surface, wlr_output,
2018-03-29 09:10:43 +11:00
now, view->x, view->y, 0, false);
2018-01-15 02:35:56 +11:00
break;
case SWAY_XWAYLAND_VIEW:
2018-03-29 09:10:43 +11:00
render_surface(surface, wlr_output, now, view->x, view->y, 0);
2018-01-15 02:35:56 +11:00
break;
2018-01-15 03:47:48 +11:00
default:
2018-01-15 02:35:56 +11:00
break;
}
2017-11-23 13:06:08 +11:00
}
static void render_layer(struct sway_output *output,
const struct wlr_box *output_layout_box,
struct timespec *when,
struct wl_list *layer) {
struct sway_layer_surface *sway_layer;
wl_list_for_each(sway_layer, layer, link) {
struct wlr_layer_surface *layer = sway_layer->layer_surface;
render_surface(layer->surface, output->wlr_output, when,
sway_layer->geo.x + output_layout_box->x,
sway_layer->geo.y + output_layout_box->y, 0);
wlr_surface_send_frame_done(layer->surface, when);
}
}
2017-11-12 06:41:18 +11:00
static void output_frame_notify(struct wl_listener *listener, void *data) {
2017-12-13 06:02:01 +11:00
struct sway_output *soutput = wl_container_of(listener, soutput, frame);
2017-11-12 06:41:18 +11:00
struct wlr_output *wlr_output = data;
struct sway_server *server = soutput->server;
2018-02-11 07:49:07 +11:00
struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
int buffer_age = -1;
wlr_output_make_current(wlr_output, &buffer_age);
2018-03-28 04:28:43 +11:00
wlr_renderer_begin(server->renderer, wlr_output->width, wlr_output->height);
2017-11-12 06:41:18 +11:00
2018-03-30 12:38:14 +11:00
float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f};
wlr_renderer_clear(renderer, clear_color);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct wlr_output_layout *layout = root_container.sway_root->output_layout;
const struct wlr_box *output_box = wlr_output_layout_get_box(
layout, wlr_output);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
2018-02-11 11:53:50 +11:00
struct sway_seat *seat = input_manager_current_seat(input_manager);
swayc_t *focus = sway_seat_get_focus_inactive(seat, soutput->swayc);
swayc_t *workspace = (focus->type == C_WORKSPACE ?
focus :
swayc_parent_by_type(focus, C_WORKSPACE));
2018-03-29 09:10:43 +11:00
struct render_data rdata = {
.output = soutput,
.now = &now,
};
swayc_descendants_of_type(workspace, C_VIEW, output_frame_view, &rdata);
2017-11-23 13:06:08 +11:00
2018-01-15 05:19:21 +11:00
// render unmanaged views on top
struct sway_view *view;
wl_list_for_each(view, &root_container.sway_root->unmanaged_views,
unmanaged_view_link) {
if (view->type == SWAY_XWAYLAND_VIEW) {
// the only kind of unamanged view right now is xwayland override redirect
int view_x = view->wlr_xwayland_surface->x;
int view_y = view->wlr_xwayland_surface->y;
render_surface(view->surface, wlr_output, &soutput->last_frame,
view_x, view_y, 0);
}
}
// TODO: Consider revising this when fullscreen windows are supported
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
2017-11-12 06:41:18 +11:00
wlr_renderer_end(server->renderer);
2018-03-29 09:10:43 +11:00
wlr_output_swap_buffers(wlr_output, &now, NULL);
2017-11-12 06:41:18 +11:00
soutput->last_frame = now;
}
2018-02-21 11:06:56 +11:00
static void handle_output_destroy(struct wl_listener *listener, void *data) {
struct sway_output *output = wl_container_of(listener, output, destroy);
2018-02-21 11:06:56 +11:00
struct wlr_output *wlr_output = data;
wlr_log(L_DEBUG, "Output %p %s removed", wlr_output, wlr_output->name);
destroy_output(output->swayc);
2018-02-21 11:06:56 +11:00
}
static void handle_output_mode(struct wl_listener *listener, void *data) {
struct sway_output *output = wl_container_of(listener, output, mode);
arrange_layers(output);
arrange_windows(output->swayc, -1, -1);
}
static void handle_output_transform(struct wl_listener *listener, void *data) {
struct sway_output *output = wl_container_of(listener, output, transform);
arrange_layers(output);
arrange_windows(output->swayc, -1, -1);
}
2018-02-15 06:51:51 +11:00
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;
2018-01-06 08:32:51 +11:00
wlr_log(L_DEBUG, "New output %p: %s", wlr_output, wlr_output->name);
2017-11-12 06:41:18 +11:00
struct sway_output *output = calloc(1, sizeof(struct sway_output));
if (!output) {
return;
}
2017-11-12 06:41:18 +11:00
output->wlr_output = wlr_output;
2018-03-29 06:47:22 +11:00
wlr_output->data = output;
2017-11-12 06:41:18 +11:00
output->server = server;
if (!wl_list_empty(&wlr_output->modes)) {
struct wlr_output_mode *mode =
wl_container_of(wlr_output->modes.prev, mode, link);
2017-11-28 20:46:22 +11:00
wlr_output_set_mode(wlr_output, mode);
}
2017-11-20 09:04:28 +11:00
output->swayc = new_output(output);
if (!output->swayc) {
free(output);
return;
}
2018-03-29 06:47:22 +11:00
size_t len = sizeof(output->layers) / sizeof(output->layers[0]);
for (size_t i = 0; i < len; ++i) {
wl_list_init(&output->layers[i]);
}
2017-12-13 00:29:37 +11:00
sway_input_manager_configure_xcursor(input_manager);
2017-12-10 06:06:00 +11:00
2017-11-12 06:41:18 +11:00
wl_signal_add(&wlr_output->events.frame, &output->frame);
2018-02-15 06:51:51 +11:00
output->frame.notify = output_frame_notify;
wl_signal_add(&wlr_output->events.destroy, &output->destroy);
output->destroy.notify = handle_output_destroy;
wl_signal_add(&wlr_output->events.mode, &output->mode);
output->mode.notify = handle_output_mode;
wl_signal_add(&wlr_output->events.transform, &output->transform);
output->transform.notify = handle_output_transform;
2018-02-15 06:51:51 +11:00
arrange_layers(output);
2018-02-18 05:32:04 +11:00
arrange_windows(&root_container, -1, -1);
2017-11-12 06:41:18 +11:00
}