hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-12-23 02:19:49 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #571 from emersion/output-damage

Browse source 
Output damage tracking
This commit is contained in:
Drew DeVault 2018-02-09 09:38:48 -05:00 committed by GitHub
commit 34489dca16
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
65 changed files with 2090 additions and 667 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
backend/backend.c
View file

@ -37,7 +37,6 @@ void wlr_backend_destroy(struct wlr_backend *backend) {
return;
}
wl_signal_emit(&backend->events.destroy, backend);
if (backend->impl && backend->impl->destroy) {
backend->impl->destroy(backend);
} else {

4
backend/drm/backend.c
View file

@ -34,6 +34,8 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
wlr_output_destroy(&conn->output);
}
wl_signal_emit(&backend->events.destroy, backend);
wl_list_remove(&drm->display_destroy.link);
wl_list_remove(&drm->session_signal.link);
wl_list_remove(&drm->drm_invalidated.link);
@ -89,6 +91,8 @@ static void session_signal(struct wl_listener *listener, void *data) {
struct wlr_drm_plane *plane = conn->crtc->cursor;
drm->iface->crtc_set_cursor(drm, conn->crtc,
(plane && plane->cursor_enabled) ? plane->cursor_bo : NULL);
drm->iface->crtc_move_cursor(drm, conn->crtc, conn->cursor_x,
conn->cursor_y);
}
} else {
wlr_log(L_INFO, "DRM fd paused");

90
backend/drm/drm.c
View file

@ -184,18 +184,22 @@ void wlr_drm_resources_free(struct wlr_drm_backend *drm) {
free(drm->planes);
}
static void wlr_drm_connector_make_current(struct wlr_output *output) {
static bool wlr_drm_connector_make_current(struct wlr_output *output,
int *buffer_age) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
wlr_drm_surface_make_current(&conn->crtc->primary->surf);
return wlr_drm_surface_make_current(&conn->crtc->primary->surf, buffer_age);
}
static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
static bool wlr_drm_connector_swap_buffers(struct wlr_output *output) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
if (!drm->session->active) {
return false;
}
struct wlr_drm_crtc *crtc = conn->crtc;
if (!crtc) {
return;
return false;
}
struct wlr_drm_plane *plane = crtc->primary;
@ -203,16 +207,20 @@ static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
if (drm->parent) {
bo = wlr_drm_surface_mgpu_copy(&plane->mgpu_surf, bo);
}
uint32_t fb_id = get_fb_for_bo(bo);
if (drm->iface->crtc_pageflip(drm, conn, crtc, fb_id, NULL)) {
conn->pageflip_pending = true;
wlr_output_update_enabled(output, true);
} else {
wl_event_source_timer_update(conn->retry_pageflip,
1000.0f / conn->output.current_mode->refresh);
if (conn->pageflip_pending) {
wlr_log(L_ERROR, "Skipping pageflip");
return false;
}
if (!drm->iface->crtc_pageflip(drm, conn, crtc, fb_id, NULL)) {
return false;
}
conn->pageflip_pending = true;
wlr_output_update_enabled(output, true);
return true;
}
static void wlr_drm_connector_set_gamma(struct wlr_output *output,
@ -250,7 +258,7 @@ void wlr_drm_connector_start_renderer(struct wlr_drm_connector *conn) {
wlr_output_update_enabled(&conn->output, true);
} else {
wl_event_source_timer_update(conn->retry_pageflip,
1000.0f / conn->output.current_mode->refresh);
1000000.0f / conn->output.current_mode->refresh);
}
}
@ -531,6 +539,9 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
if (!buf && update_pixels) {
// Hide the cursor
plane->cursor_enabled = false;
if (!drm->session->active) {
return true;
}
return drm->iface->crtc_set_cursor(drm, crtc, NULL);
}
plane->cursor_enabled = true;
@ -577,17 +588,15 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
}
struct wlr_box hotspot = {
.width = plane->surf.width,
.height = plane->surf.height,
.x = hotspot_x,
.y = hotspot_y,
};
enum wl_output_transform transform =
wlr_output_transform_invert(output->transform);
struct wlr_box transformed_hotspot;
wlr_box_transform(&hotspot, transform, &transformed_hotspot);
plane->cursor_hotspot_x = transformed_hotspot.x;
plane->cursor_hotspot_y = transformed_hotspot.y;
wlr_box_transform(&hotspot, transform,
plane->surf.width, plane->surf.height, &hotspot);
plane->cursor_hotspot_x = hotspot.x;
plane->cursor_hotspot_y = hotspot.y;
if (!update_pixels) {
// Only update the cursor hotspot
@ -606,7 +615,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
return false;
}
wlr_drm_surface_make_current(&plane->surf);
wlr_drm_surface_make_current(&plane->surf, NULL);
wlr_texture_upload_pixels(plane->wlr_tex, WL_SHM_FORMAT_ARGB8888,
stride, width, height, buf);
@ -630,35 +639,52 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
gbm_bo_unmap(bo, bo_data);
return drm->iface->crtc_set_cursor(drm, crtc, bo);
if (!drm->session->active) {
return true;
}
bool ok = drm->iface->crtc_set_cursor(drm, crtc, bo);
if (ok) {
wlr_output_update_needs_swap(output);
}
return ok;
}
static bool wlr_drm_connector_move_cursor(struct wlr_output *output,
int x, int y) {
struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
if (!conn || !conn->crtc) {
if (!conn->crtc) {
return false;
}
struct wlr_drm_plane *plane = conn->crtc->cursor;
struct wlr_box box;
box.x = x;
box.y = y;
wlr_output_effective_resolution(output, &box.width, &box.height);
struct wlr_box box = { .x = x, .y = y };
int width, height;
wlr_output_transformed_resolution(output, &width, &height);
enum wl_output_transform transform =
wlr_output_transform_invert(output->transform);
struct wlr_box transformed_box;
wlr_box_transform(&box, transform, &transformed_box);
wlr_box_transform(&box, transform, width, height, &box);
if (plane != NULL) {
transformed_box.x -= plane->cursor_hotspot_x;
transformed_box.y -= plane->cursor_hotspot_y;
box.x -= plane->cursor_hotspot_x;
box.y -= plane->cursor_hotspot_y;
}
return drm->iface->crtc_move_cursor(drm, conn->crtc, transformed_box.x,
transformed_box.y);
conn->cursor_x = box.x;
conn->cursor_y = box.y;
if (!drm->session->active) {
return true;
}
bool ok = drm->iface->crtc_move_cursor(drm, conn->crtc, box.x, box.y);
if (ok) {
wlr_output_update_needs_swap(output);
}
return ok;
}
static void wlr_drm_connector_destroy(struct wlr_output *output) {
@ -874,7 +900,7 @@ static void page_flip_handler(int fd, unsigned seq,
}
if (drm->session->active) {
wl_signal_emit(&conn->output.events.frame, &conn->output);
wlr_output_send_frame(&conn->output);
}
}

17
backend/drm/renderer.c
View file

@ -128,9 +128,9 @@ void wlr_drm_surface_finish(struct wlr_drm_surface *surf) {
memset(surf, 0, sizeof(*surf));
}
void wlr_drm_surface_make_current(struct wlr_drm_surface *surf) {
eglMakeCurrent(surf->renderer->egl.display, surf->egl, surf->egl,
surf->renderer->egl.context);
bool wlr_drm_surface_make_current(struct wlr_drm_surface *surf,
int *buffer_damage) {
return wlr_egl_make_current(&surf->renderer->egl, surf->egl, buffer_damage);
}
struct gbm_bo *wlr_drm_surface_swap_buffers(struct wlr_drm_surface *surf) {
@ -138,7 +138,9 @@ struct gbm_bo *wlr_drm_surface_swap_buffers(struct wlr_drm_surface *surf) {
gbm_surface_release_buffer(surf->gbm, surf->front);
}
eglSwapBuffers(surf->renderer->egl.display, surf->egl);
if (!eglSwapBuffers(surf->renderer->egl.display, surf->egl)) {
wlr_log(L_ERROR, "eglSwapBuffers failed");
}
surf->front = surf->back;
surf->back = gbm_surface_lock_front_buffer(surf->gbm);
@ -150,7 +152,7 @@ struct gbm_bo *wlr_drm_surface_get_front(struct wlr_drm_surface *surf) {
return surf->front;
}
wlr_drm_surface_make_current(surf);
wlr_drm_surface_make_current(surf, NULL);
glViewport(0, 0, surf->width, surf->height);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
@ -222,8 +224,9 @@ static struct wlr_texture *get_tex_for_bo(struct wlr_drm_renderer *renderer, str
return tex->tex;
}
struct gbm_bo *wlr_drm_surface_mgpu_copy(struct wlr_drm_surface *dest, struct gbm_bo *src) {
wlr_drm_surface_make_current(dest);
struct gbm_bo *wlr_drm_surface_mgpu_copy(struct wlr_drm_surface *dest,
struct gbm_bo *src) {
wlr_drm_surface_make_current(dest, NULL);
struct wlr_texture *tex = get_tex_for_bo(dest->renderer, src);

2
backend/headless/backend.c
View file

@ -51,6 +51,8 @@ static void backend_destroy(struct wlr_backend *wlr_backend) {
wlr_input_device_destroy(&input_device->wlr_input_device);
}
wl_signal_emit(&wlr_backend->events.destroy, backend);
wlr_egl_finish(&backend->egl);
free(backend);
}

17
backend/headless/output.c
View file

@ -48,25 +48,20 @@ static void output_transform(struct wlr_output *wlr_output,
output->wlr_output.transform = transform;
}
static void output_make_current(struct wlr_output *wlr_output) {
static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) {
struct wlr_headless_output *output =
(struct wlr_headless_output *)wlr_output;
if (!eglMakeCurrent(output->backend->egl.display,
output->egl_surface, output->egl_surface,
output->backend->egl.context)) {
wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
}
return wlr_egl_make_current(&output->backend->egl, output->egl_surface,
buffer_age);
}
static void output_swap_buffers(struct wlr_output *wlr_output) {
// No-op
static bool output_swap_buffers(struct wlr_output *wlr_output) {
return true; // No-op
}
static void output_destroy(struct wlr_output *wlr_output) {
struct wlr_headless_output *output =
(struct wlr_headless_output *)wlr_output;
wl_signal_emit(&output->backend->backend.events.output_remove,
&output->wlr_output);
wl_list_remove(&output->link);
@ -88,7 +83,7 @@ bool wlr_output_is_headless(struct wlr_output *wlr_output) {
static int signal_frame(void *data) {
struct wlr_headless_output *output = data;
wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output);
wlr_output_send_frame(&output->wlr_output);
wl_event_source_timer_update(output->frame_timer, output->frame_delay);
return 0;
}

8
backend/libinput/backend.c
View file

@ -95,12 +95,12 @@ static bool wlr_libinput_backend_start(struct wlr_backend *_backend) {
return true;
}
static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
if (!_backend) {
static void wlr_libinput_backend_destroy(struct wlr_backend *wlr_backend) {
if (!wlr_backend) {
return;
}
struct wlr_libinput_backend *backend =
(struct wlr_libinput_backend *)_backend;
(struct wlr_libinput_backend *)wlr_backend;
for (size_t i = 0; i < backend->wlr_device_lists.length; i++) {
struct wl_list *wlr_devices = backend->wlr_device_lists.items[i];
@ -112,6 +112,8 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
free(wlr_devices);
}
wl_signal_emit(&wlr_backend->events.destroy, wlr_backend);
wl_list_remove(&backend->display_destroy.link);
wl_list_remove(&backend->session_signal.link);

13
backend/meson.build
View file

@ -45,5 +45,16 @@ lib_wlr_backend = static_library(
'wlr_backend',
backend_files,
include_directories: wlr_inc,
dependencies: [wayland_server, egl, gbm, libinput, systemd, elogind, wlr_render, wlr_protos, drm],
dependencies: [
wayland_server,
egl,
gbm,
libinput,
systemd,
elogind,
wlr_render,
wlr_protos,
drm,
pixman,
],
)

5
backend/multi/backend.c
View file

@ -42,11 +42,16 @@ static void subbackend_state_destroy(struct subbackend_state *sub) {
static void multi_backend_destroy(struct wlr_backend *wlr_backend) {
struct wlr_multi_backend *backend = (struct wlr_multi_backend *)wlr_backend;
wl_list_remove(&backend->display_destroy.link);
struct subbackend_state *sub, *next;
wl_list_for_each_safe(sub, next, &backend->backends, link) {
wlr_backend_destroy(sub->backend);
}
// Destroy this backend only after removing all sub-backends
wl_signal_emit(&wlr_backend->events.destroy, backend);
free(backend);
}

8
backend/wayland/backend.c
View file

@ -64,9 +64,9 @@ static bool wlr_wl_backend_start(struct wlr_backend *_backend) {
return true;
}
static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
if (!_backend) {
static void wlr_wl_backend_destroy(struct wlr_backend *wlr_backend) {
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)wlr_backend;
if (backend == NULL) {
return;
}
@ -80,6 +80,8 @@ static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
wlr_input_device_destroy(input_device);
}
wl_signal_emit(&wlr_backend->events.destroy, wlr_backend);
wl_list_remove(&backend->local_display_destroy.link);
free(backend->seat_name);

48
backend/wayland/output.c
View file

@ -17,11 +17,14 @@ int os_create_anonymous_file(off_t size);
static struct wl_callback_listener frame_listener;
static void surface_frame_callback(void *data, struct wl_callback *cb, uint32_t time) {
struct wlr_output *wlr_output = data;
assert(wlr_output);
wl_signal_emit(&wlr_output->events.frame, wlr_output);
static void surface_frame_callback(void *data, struct wl_callback *cb,
uint32_t time) {
struct wlr_wl_backend_output *output = data;
assert(output);
wl_callback_destroy(cb);
output->frame_callback = NULL;
wlr_output_send_frame(&output->wlr_output);
}
static struct wl_callback_listener frame_listener = {
@ -36,22 +39,32 @@ static bool wlr_wl_output_set_custom_mode(struct wlr_output *_output,
return true;
}
static void wlr_wl_output_make_current(struct wlr_output *_output) {
struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output;
if (!eglMakeCurrent(output->backend->egl.display,
output->egl_surface, output->egl_surface,
output->backend->egl.context)) {
wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
}
static bool wlr_wl_output_make_current(struct wlr_output *wlr_output,
int *buffer_age) {
struct wlr_wl_backend_output *output =
(struct wlr_wl_backend_output *)wlr_output;
return wlr_egl_make_current(&output->backend->egl, output->egl_surface,
buffer_age);
}
static void wlr_wl_output_swap_buffers(struct wlr_output *_output) {
struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output;
static bool wlr_wl_output_swap_buffers(struct wlr_output *wlr_output) {
struct wlr_wl_backend_output *output =
(struct wlr_wl_backend_output *)wlr_output;
if (output->frame_callback != NULL) {
wlr_log(L_ERROR, "Skipping buffer swap");
return false;
}
output->frame_callback = wl_surface_frame(output->surface);
wl_callback_add_listener(output->frame_callback, &frame_listener, output);
if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) {
wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
return false;
}
return true;
}
static void wlr_wl_output_transform(struct wlr_output *_output,
@ -148,11 +161,12 @@ static bool wlr_wl_output_set_cursor(struct wlr_output *_output,
return true;
}
static void wlr_wl_output_destroy(struct wlr_output *_output) {
static void wlr_wl_output_destroy(struct wlr_output *wlr_output) {
struct wlr_wl_backend_output *output =
(struct wlr_wl_backend_output *)_output;
wl_signal_emit(&output->backend->backend.events.output_remove,
&output->wlr_output);
(struct wlr_wl_backend_output *)wlr_output;
if (output == NULL) {
return;
}
wl_list_remove(&output->link);

12
backend/wayland/wl_seat.c
View file

@ -54,14 +54,16 @@ static void pointer_handle_motion(void *data, struct wl_pointer *wl_pointer,
struct wlr_output *wlr_output = &wlr_wl_pointer->current_output->wlr_output;
struct wlr_box box;
int width, height;
wl_egl_window_get_attached_size(wlr_wl_pointer->current_output->egl_window,
&box.width, &box.height);
box.x = wl_fixed_to_int(surface_x);
box.y = wl_fixed_to_int(surface_y);
&width, &height);
struct wlr_box box = {
.x = wl_fixed_to_int(surface_x),
.y = wl_fixed_to_int(surface_y),
};
struct wlr_box transformed;
wlr_box_transform(&box, wlr_output->transform, &transformed);
wlr_box_transform(&box, wlr_output->transform, width, height, &transformed);
transformed.x /= wlr_output->scale;
transformed.y /= wlr_output->scale;

17
backend/x11/backend.c
View file

@ -45,7 +45,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e
switch (event->response_type) {
case XCB_EXPOSE: {
wl_signal_emit(&output->wlr_output.events.frame, output);
wlr_output_send_frame(&output->wlr_output);
break;
}
case XCB_KEY_PRESS:
@ -175,7 +175,7 @@ static int x11_event(int fd, uint32_t mask, void *data) {
static int signal_frame(void *data) {
struct wlr_x11_backend *x11 = data;
wl_signal_emit(&x11->output.wlr_output.events.frame, &x11->output);
wlr_output_send_frame(&x11->output.wlr_output);
wl_event_source_timer_update(x11->frame_timer, 16);
return 0;
}
@ -259,6 +259,8 @@ static void wlr_x11_backend_destroy(struct wlr_backend *backend) {
xkb_state_unref(x11->keyboard_dev.keyboard->xkb_state);
}
wl_signal_emit(&backend->events.destroy, backend);
wl_list_remove(&x11->display_destroy.link);
wl_event_source_remove(x11->frame_timer);
@ -392,22 +394,23 @@ static void output_destroy(struct wlr_output *wlr_output) {
// output has been allocated on the stack, do not free it
}
static void output_make_current(struct wlr_output *wlr_output) {
static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) {
struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
struct wlr_x11_backend *x11 = output->x11;
if (!eglMakeCurrent(x11->egl.display, output->surf, output->surf, x11->egl.context)) {
wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
}
return wlr_egl_make_current(&x11->egl, output->surf, buffer_age);
}
static void output_swap_buffers(struct wlr_output *wlr_output) {
static bool output_swap_buffers(struct wlr_output *wlr_output) {
struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
struct wlr_x11_backend *x11 = output->x11;
if (!eglSwapBuffers(x11->egl.display, output->surf)) {
wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
return false;
}
return true;
}
static struct wlr_output_impl output_impl = {

4
examples/multi-pointer.c
View file

@ -56,13 +56,13 @@ static void handle_output_frame(struct output_state *output,
struct sample_state *sample = state->data;
struct wlr_output *wlr_output = output->output;
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
glClearColor(sample->clear_color[0], sample->clear_color[1],
sample->clear_color[2], sample->clear_color[3]);
glClear(GL_COLOR_BUFFER_BIT);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
}
static void handle_output_add(struct output_state *ostate) {

5
examples/output-layout.c
View file

@ -100,8 +100,9 @@ static void handle_output_frame(struct output_state *output,
struct sample_state *sample = state->data;
struct wlr_output *wlr_output = output->output;
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, &(float[]){0.25f, 0.25f, 0.25f, 1});
animate_cat(sample, output->output);
@ -125,7 +126,7 @@ static void handle_output_frame(struct output_state *output,
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
}
static void handle_output_add(struct output_state *ostate) {

4
examples/pointer.c
View file

@ -85,13 +85,13 @@ static void handle_output_frame(struct output_state *output,
struct sample_state *sample = state->data;
struct wlr_output *wlr_output = output->output;
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
glClearColor(sample->clear_color[0], sample->clear_color[1],
sample->clear_color[2], sample->clear_color[3]);
glClear(GL_COLOR_BUFFER_BIT);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
}
static void handle_output_add(struct output_state *ostate) {

5
examples/rotation.c
View file

@ -42,8 +42,9 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, &(float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16];
for (int y = -128 + (int)odata->y_offs; y < height; y += 128) {
@ -56,7 +57,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
long ms = (ts->tv_sec - output->last_frame.tv_sec) * 1000 +
(ts->tv_nsec - output->last_frame.tv_nsec) / 1000000;

4
examples/simple.c
View file

@ -35,12 +35,12 @@ void handle_output_frame(struct output_state *output, struct timespec *ts) {
sample->dec = inc;
}
wlr_output_make_current(output->output);
wlr_output_make_current(output->output, NULL);
glClearColor(sample->color[0], sample->color[1], sample->color[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_output_swap_buffers(output->output);
wlr_output_swap_buffers(output->output, NULL, NULL);
}
int main() {

5
examples/tablet.c
View file

@ -42,8 +42,9 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, &(float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16], view[16];
float distance = 0.8f * (1 - sample->distance);
@ -76,7 +77,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
}
static void handle_tool_axis(struct tablet_tool_state *tstate,

5
examples/touch.c
View file

@ -41,8 +41,9 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_output_make_current(wlr_output, NULL);
wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, &(float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16];
struct touch_point *p;
@ -56,7 +57,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
wlr_output_swap_buffers(wlr_output, NULL, NULL);
}
static void handle_touch_down(struct touch_state *tstate, int32_t touch_id,

4
include/backend/drm/drm.h
View file

@ -123,8 +123,8 @@ struct wlr_drm_connector {
union wlr_drm_connector_props props;
uint32_t width;
uint32_t height;
uint32_t width, height;
int32_t cursor_x, cursor_y;
drmModeCrtc *old_crtc;

2
include/backend/drm/renderer.h
View file

@ -45,7 +45,7 @@ bool wlr_drm_plane_surfaces_init(struct wlr_drm_plane *plane, struct wlr_drm_bac
int32_t width, uint32_t height, uint32_t format);
void wlr_drm_surface_finish(struct wlr_drm_surface *surf);
void wlr_drm_surface_make_current(struct wlr_drm_surface *surf);
bool wlr_drm_surface_make_current(struct wlr_drm_surface *surf, int *buffer_age);
struct gbm_bo *wlr_drm_surface_swap_buffers(struct wlr_drm_surface *surf);
struct gbm_bo *wlr_drm_surface_get_front(struct wlr_drm_surface *surf);
void wlr_drm_surface_post(struct wlr_drm_surface *surf);

21
include/rootston/desktop.h
View file

@ -16,15 +16,7 @@
#include <wlr/types/wlr_idle.h>
#include "rootston/view.h"
#include "rootston/config.h"
struct roots_output {
struct roots_desktop *desktop;
struct wlr_output *wlr_output;
struct wl_listener frame;
struct timespec last_frame;
struct wl_list link; // roots_desktop:outputs
struct roots_view *fullscreen_view;
};
#include "rootston/output.h"
struct roots_desktop {
struct wl_list views; // roots_view::link
@ -64,7 +56,7 @@ struct roots_desktop {
struct roots_server;
struct roots_desktop *desktop_create(struct roots_server *server,
struct roots_config *config);
struct roots_config *config);
void desktop_destroy(struct roots_desktop *desktop);
struct roots_output *desktop_output_from_wlr_output(
struct roots_desktop *desktop, struct wlr_output *output);
@ -72,11 +64,12 @@ struct roots_view *desktop_view_at(struct roots_desktop *desktop, double lx,
double ly, struct wlr_surface **surface, double *sx, double *sy);
void view_init(struct roots_view *view, struct roots_desktop *desktop);
void view_destroy(struct roots_view *view);
void view_finish(struct roots_view *view);
void view_activate(struct roots_view *view, bool activate);
void output_add_notify(struct wl_listener *listener, void *data);
void output_remove_notify(struct wl_listener *listener, void *data);
void view_apply_damage(struct roots_view *view);
void view_damage_whole(struct roots_view *view);
void view_update_position(struct roots_view *view, double x, double y);
void view_update_size(struct roots_view *view, uint32_t width, uint32_t height);
void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data);
void handle_wl_shell_surface(struct wl_listener *listener, void *data);

50
include/rootston/output.h Normal file
View file

@ -0,0 +1,50 @@
#ifndef _ROOTSTON_OUTPUT_H
#define _ROOTSTON_OUTPUT_H
#include <time.h>
#include <pixman.h>
#include <wayland-server.h>
/**
* Damage tracking requires to keep track of previous frames' damage. To allow
* damage tracking to work with triple buffering, a history of two frames is
* required.
*/
#define ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN 2
struct roots_desktop;
struct roots_output {
struct roots_desktop *desktop;
struct wlr_output *wlr_output;
struct wl_list link; // roots_desktop:outputs
struct roots_view *fullscreen_view;
struct timespec last_frame;
pixman_region32_t damage; // in ouput-local coordinates
// circular queue for previous damage
pixman_region32_t previous_damage[ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN];
size_t previous_damage_idx;
struct wl_listener frame;
struct wl_listener mode;
struct wl_listener needs_swap;
};
void output_add_notify(struct wl_listener *listener, void *data);
void output_remove_notify(struct wl_listener *listener, void *data);
struct roots_view;
struct roots_drag_icon;
void output_damage_whole(struct roots_output *output);
void output_damage_whole_view(struct roots_output *output,
struct roots_view *view);
void output_damage_from_view(struct roots_output *output,
struct roots_view *view);
void output_damage_whole_drag_icon(struct roots_output *output,
struct roots_drag_icon *icon);
#endif

23
include/rootston/seat.h
View file

@ -17,12 +17,15 @@ struct roots_seat {
struct wl_list views; // roots_seat_view::link
bool has_focus;
struct wl_list drag_icons; // roots_drag_icon::link
struct wl_list keyboards;
struct wl_list pointers;
struct wl_list touch;
struct wl_list tablet_tools;
struct wl_listener seat_destroy;
struct wl_listener new_drag_icon;
struct wl_listener destroy;
};
struct roots_seat_view {
@ -38,6 +41,18 @@ struct roots_seat_view {
struct wl_listener view_destroy;
};
struct roots_drag_icon {
struct roots_seat *seat;
struct wlr_drag_icon *wlr_drag_icon;
struct wl_list link;
double x, y;
struct wl_listener surface_commit;
struct wl_listener map;
struct wl_listener destroy;
};
struct roots_pointer {
struct roots_seat *seat;
struct wlr_input_device *device;
@ -92,6 +107,10 @@ void roots_seat_begin_rotate(struct roots_seat *seat, struct roots_view *view);
void roots_seat_end_compositor_grab(struct roots_seat *seat);
struct roots_seat_view *roots_seat_view_from_view( struct roots_seat *seat,
struct roots_view *view);
struct roots_view *view);
void roots_drag_icon_update_position(struct roots_drag_icon *icon);
void roots_drag_icon_damage_whole(struct roots_drag_icon *icon);
#endif

56
include/rootston/view.h
View file

@ -11,6 +11,7 @@ struct roots_wl_shell_surface {
struct roots_view *view;
struct wl_listener destroy;
struct wl_listener new_popup;
struct wl_listener request_move;
struct wl_listener request_resize;
struct wl_listener request_maximize;
@ -23,13 +24,15 @@ struct roots_wl_shell_surface {
struct roots_xdg_surface_v6 {
struct roots_view *view;
struct wl_listener commit;
struct wl_listener destroy;
struct wl_listener new_popup;
struct wl_listener request_move;
struct wl_listener request_resize;
struct wl_listener request_maximize;
struct wl_listener request_fullscreen;
struct wl_listener surface_commit;
uint32_t pending_move_resize_configure_serial;
};
@ -61,6 +64,7 @@ struct roots_view {
struct wl_list link; // roots_desktop::views
double x, y;
uint32_t width, height;
float rotation;
bool decorated;
@ -97,17 +101,17 @@ struct roots_view {
struct roots_xwayland_surface *roots_xwayland_surface;
#endif
};
struct wlr_surface *wlr_surface;
struct wl_list children; // roots_view_child::link
struct wl_listener new_subsurface;
struct {
struct wl_signal destroy;
} events;
// TODO: This would probably be better as a field that's updated on a
// configure event from the xdg_shell
// If not then this should follow the typical type/impl pattern we use
// elsewhere
void (*get_size)(const struct roots_view *view, struct wlr_box *box);
// TODO: this should follow the typical type/impl pattern we use elsewhere
void (*activate)(struct roots_view *view, bool active);
void (*move)(struct roots_view *view, double x, double y);
void (*resize)(struct roots_view *view, uint32_t width, uint32_t height);
@ -118,6 +122,38 @@ struct roots_view {
void (*close)(struct roots_view *view);
};
struct roots_view_child {
struct roots_view *view;
struct wlr_surface *wlr_surface;
struct wl_list link;
struct wl_listener commit;
struct wl_listener new_subsurface;
void (*destroy)(struct roots_view_child *child);
};
struct roots_subsurface {
struct roots_view_child view_child;
struct wlr_subsurface *wlr_subsurface;
struct wl_listener destroy;
};
struct roots_wl_shell_popup {
struct roots_view_child view_child;
struct wlr_wl_shell_surface *wlr_wl_shell_surface;
struct wl_listener destroy;
struct wl_listener set_state;
struct wl_listener new_popup;
};
struct roots_xdg_popup_v6 {
struct roots_view_child view_child;
struct wlr_xdg_popup_v6 *wlr_popup;
struct wl_listener destroy;
struct wl_listener new_popup;
};
void view_get_box(const struct roots_view *view, struct wlr_box *box);
void view_activate(struct roots_view *view, bool active);
void view_move(struct roots_view *view, double x, double y);
@ -127,6 +163,7 @@ void view_move_resize(struct roots_view *view, double x, double y,
void view_maximize(struct roots_view *view, bool maximized);
void view_set_fullscreen(struct roots_view *view, bool fullscreen,
struct wlr_output *output);
void view_rotate(struct roots_view *view, float rotation);
void view_close(struct roots_view *view);
bool view_center(struct roots_view *view);
void view_setup(struct roots_view *view);
@ -145,4 +182,11 @@ enum roots_deco_part {
enum roots_deco_part view_get_deco_part(struct roots_view *view, double sx, double sy);
void view_child_init(struct roots_view_child *child, struct roots_view *view,
struct wlr_surface *wlr_surface);
void view_child_finish(struct roots_view_child *child);
struct roots_subsurface *subsurface_create(struct roots_view *view,
struct wlr_subsurface *wlr_subsurface);
#endif

6
include/wlr/interfaces/wlr_output.h
View file

@ -18,8 +18,8 @@ struct wlr_output_impl {
int32_t hotspot_x, int32_t hotspot_y, bool update_pixels);
bool (*move_cursor)(struct wlr_output *output, int x, int y);
void (*destroy)(struct wlr_output *output);
void (*make_current)(struct wlr_output *output);
void (*swap_buffers)(struct wlr_output *output);
bool (*make_current)(struct wlr_output *output, int *buffer_age);
bool (*swap_buffers)(struct wlr_output *output);
void (*set_gamma)(struct wlr_output *output,
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b);
uint32_t (*get_gamma_size)(struct wlr_output *output);
@ -32,5 +32,7 @@ void wlr_output_update_mode(struct wlr_output *output,
void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width,
int32_t height, int32_t refresh);
void wlr_output_update_enabled(struct wlr_output *output, bool enabled);
void wlr_output_update_needs_swap(struct wlr_output *output);
void wlr_output_send_frame(struct wlr_output *output);
#endif

8
include/wlr/render.h
View file

@ -5,6 +5,7 @@
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <wayland-server-protocol.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
struct wlr_texture;
@ -12,6 +13,13 @@ struct wlr_renderer;
void wlr_renderer_begin(struct wlr_renderer *r, struct wlr_output *output);
void wlr_renderer_end(struct wlr_renderer *r);
void wlr_renderer_clear(struct wlr_renderer *r, const float (*color)[4]);
/**
* Defines a scissor box. Only pixels that lie within the scissor box can be
* modified by drawing functions. Providing a NULL `box` disables the scissor
* box.
*/
void wlr_renderer_scissor(struct wlr_renderer *r, struct wlr_box *box);
/**
* Requests a texture handle from this renderer.
*/

11
include/wlr/render/egl.h
View file

@ -11,8 +11,12 @@ struct wlr_egl {
EGLConfig config;
EGLContext context;
const char *egl_exts;
const char *gl_exts;
const char *egl_exts_str;
const char *gl_exts_str;
struct {
bool buffer_age;
} egl_exts;
struct wl_display *wl_display;
};
@ -65,4 +69,7 @@ bool wlr_egl_destroy_image(struct wlr_egl *egl, EGLImageKHR image);
*/
const char *egl_error(void);
bool wlr_egl_make_current(struct wlr_egl *egl, EGLSurface surface,
int *buffer_age);
#endif

3
include/wlr/render/interface.h
View file

@ -6,6 +6,7 @@
#include <EGL/eglext.h>
#include <stdbool.h>
#include <wlr/render.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
struct wlr_renderer_impl;
@ -17,6 +18,8 @@ struct wlr_renderer {
struct wlr_renderer_impl {
void (*begin)(struct wlr_renderer *renderer, struct wlr_output *output);
void (*end)(struct wlr_renderer *renderer);
void (*clear)(struct wlr_renderer *renderer, const float (*color)[4]);
void (*scissor)(struct wlr_renderer *renderer, struct wlr_box *box);
struct wlr_texture *(*texture_create)(struct wlr_renderer *renderer);
bool (*render_with_matrix)(struct wlr_renderer *renderer,
struct wlr_texture *texture, const float (*matrix)[16]);

14
include/wlr/types/wlr_box.h
View file

@ -2,6 +2,7 @@
#define WLR_TYPES_WLR_BOX_H
#include <stdbool.h>
#include <wayland-server.h>
struct wlr_box {
int x, y;
@ -18,8 +19,17 @@ bool wlr_box_contains_point(const struct wlr_box *box, double x, double y);
bool wlr_box_empty(const struct wlr_box *box);
enum wl_output_transform;
/**
* Transforms a box inside a `width` x `height` box.
*/
void wlr_box_transform(const struct wlr_box *box,
enum wl_output_transform transform, struct wlr_box *dest);
enum wl_output_transform transform, int width, int height,
struct wlr_box *dest);
/**
* Creates the smallest box that contains a rotated box.
*/
void wlr_box_rotated_bounds(const struct wlr_box *box, float rotation,
struct wlr_box *dest);
#endif

2
include/wlr/types/wlr_compositor.h
View file

@ -13,7 +13,7 @@ struct wlr_compositor {
struct wl_listener display_destroy;
struct {
struct wl_signal create_surface;
struct wl_signal new_surface;
} events;
};

4
include/wlr/types/wlr_data_device.h
View file

@ -71,10 +71,10 @@ struct wlr_drag_icon {
bool is_pointer;
int32_t touch_id;
int32_t sx;
int32_t sy;
int32_t sx, sy;
struct {
struct wl_signal map; // emitted when mapped or unmapped
struct wl_signal destroy;
} events;

60
include/wlr/types/wlr_output.h
View file

@ -2,6 +2,8 @@
#define WLR_TYPES_WLR_OUTPUT_H
#include <stdbool.h>
#include <time.h>
#include <pixman.h>
#include <wayland-util.h>
#include <wayland-server.h>
@ -22,7 +24,6 @@ struct wlr_output_cursor {
struct wl_list link;
// only when using a software cursor without a surface
struct wlr_renderer *renderer;
struct wlr_texture *texture;
// only when using a cursor surface
@ -51,22 +52,26 @@ struct wlr_output {
char serial[16];
int32_t phys_width, phys_height; // mm
bool enabled;
float scale;
enum wl_output_subpixel subpixel;
enum wl_output_transform transform;
bool needs_swap;
float transform_matrix[16];
// Note: some backends may have zero modes
struct wl_list modes;
struct wlr_output_mode *current_mode;
int32_t width, height;
int32_t refresh; // mHz
int32_t refresh; // mHz, may be zero
bool enabled;
float scale;
enum wl_output_subpixel subpixel;
enum wl_output_transform transform;
bool needs_swap;
// damage for cursors and fullscreen surface, in output-local coordinates
pixman_region32_t damage;
bool frame_pending;
float transform_matrix[16];
struct {
struct wl_signal frame;
struct wl_signal needs_swap;
struct wl_signal swap_buffers;
struct wl_signal enable;
struct wl_signal mode;
@ -75,9 +80,12 @@ struct wlr_output {
struct wl_signal destroy;
} events;
struct wl_event_source *idle_frame;
struct wlr_surface *fullscreen_surface;
struct wl_listener fullscreen_surface_commit;
struct wl_listener fullscreen_surface_destroy;
int fullscreen_width, fullscreen_height;
struct wl_list cursors; // wlr_output_cursor::link
struct wlr_output_cursor *hardware_cursor;
@ -104,16 +112,44 @@ void wlr_output_set_transform(struct wlr_output *output,
void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly);
void wlr_output_set_scale(struct wlr_output *output, float scale);
void wlr_output_destroy(struct wlr_output *output);
/**
* Computes the transformed output resolution.
*/
void wlr_output_transformed_resolution(struct wlr_output *output,
int *width, int *height);
/**
* Computes the transformed and scaled output resolution.
*/
void wlr_output_effective_resolution(struct wlr_output *output,
int *width, int *height);
void wlr_output_make_current(struct wlr_output *output);
void wlr_output_swap_buffers(struct wlr_output *output);
/**
* Makes the output rendering context current.
*
* `buffer_age` is set to the drawing buffer age in number of frames or -1 if
* unknown. This is useful for damage tracking.
*/
bool wlr_output_make_current(struct wlr_output *output, int *buffer_age);
/**
* Swaps the output buffers. If the time of the frame isn't known, set `when` to
* NULL. If the compositor doesn't support damage tracking, set `damage` to
* NULL.
*
* Swapping buffers schedules a `frame` event.
*/
bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when,
pixman_region32_t *damage);
/**
* Manually schedules a `frame` event. If a `frame` event is already pending,
* it is a no-op.
*/
void wlr_output_schedule_frame(struct wlr_output *output);
void wlr_output_set_gamma(struct wlr_output *output,
uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b);
uint32_t wlr_output_get_gamma_size(struct wlr_output *output);
void wlr_output_set_fullscreen_surface(struct wlr_output *output,
struct wlr_surface *surface);
struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output);
/**
* Sets the cursor image. The image must be already scaled for the output.

2
include/wlr/types/wlr_seat.h
View file

@ -209,6 +209,8 @@ struct wlr_seat {
struct wl_signal selection;
struct wl_signal primary_selection;
struct wl_signal new_drag_icon;
struct wl_signal destroy;
} events;

5
include/wlr/types/wlr_surface.h
View file

@ -56,6 +56,10 @@ struct wlr_subsurface {
struct wl_list parent_pending_link;
struct wl_listener parent_destroy_listener;
struct {
struct wl_signal destroy;
} events;
};
struct wlr_surface {
@ -70,6 +74,7 @@ struct wlr_surface {
struct {
struct wl_signal commit;
struct wl_signal new_subsurface;
struct wl_signal destroy;
} events;

1
include/wlr/types/wlr_wl_shell.h
View file

@ -79,6 +79,7 @@ struct wlr_wl_shell_surface {
struct {
struct wl_signal destroy;
struct wl_signal ping_timeout;
struct wl_signal new_popup;
struct wl_signal request_move;
struct wl_signal request_resize;

5
include/wlr/types/wlr_xdg_shell_v6.h
View file

@ -34,6 +34,7 @@ struct wlr_xdg_client_v6 {
struct wlr_xdg_popup_v6 {
struct wlr_xdg_surface_v6 *base;
struct wl_list link;
struct wl_resource *resource;
bool committed;
@ -104,8 +105,7 @@ struct wlr_xdg_surface_v6 {
struct wlr_xdg_popup_v6 *popup_state;
};
struct wl_list popups;
struct wl_list popup_link;
struct wl_list popups; // wlr_xdg_popup_v6::link
bool configured;
bool added;
@ -126,6 +126,7 @@ struct wlr_xdg_surface_v6 {
struct {
struct wl_signal destroy;
struct wl_signal ping_timeout;
struct wl_signal new_popup;
struct wl_signal request_maximize;
struct wl_signal request_fullscreen;

29
include/wlr/util/region.h Normal file
View file

@ -0,0 +1,29 @@
#ifndef WLR_UTIL_REGION_H
#define WLR_UTIL_REGION_H
#include <pixman.h>
#include <wayland-server.h>
/**
* Scales a region, ie. multiplies all its coordinates by `scale`.
*
* The resulting coordinates are rounded up or down so that the new region is
* at least as big as the original one.
*/
void wlr_region_scale(pixman_region32_t *dst, pixman_region32_t *src,
float scale);
/**
* Applies a transform to a region inside a box of size `width` x `height`.
*/
void wlr_region_transform(pixman_region32_t *dst, pixman_region32_t *src,
enum wl_output_transform transform, int width, int height);
/**
* Expands the region of `distance`. If `distance` is negative, it shrinks the
* region.
*/
void wlr_region_expand(pixman_region32_t *dst, pixman_region32_t *src,
int distance);
#endif

50
render/egl.c
View file

@ -127,18 +127,23 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display,
}
eglMakeCurrent(egl->display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl->context);
egl->egl_exts = eglQueryString(egl->display, EGL_EXTENSIONS);
if (strstr(egl->egl_exts, "EGL_WL_bind_wayland_display") == NULL ||
strstr(egl->egl_exts, "EGL_KHR_image_base") == NULL) {
egl->egl_exts_str = eglQueryString(egl->display, EGL_EXTENSIONS);
egl->gl_exts_str = (const char*) glGetString(GL_EXTENSIONS);
wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor);
wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts_str);
wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION));
wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts_str);
if (strstr(egl->egl_exts_str, "EGL_WL_bind_wayland_display") == NULL ||
strstr(egl->egl_exts_str, "EGL_KHR_image_base") == NULL) {
wlr_log(L_ERROR, "Required egl extensions not supported");
goto error;
}
egl->gl_exts = (const char*) glGetString(GL_EXTENSIONS);
wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor);
wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts);
wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION));
wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts);
egl->egl_exts.buffer_age =
strstr(egl->egl_exts_str, "EGL_EXT_buffer_age") != NULL;
return true;
error:
@ -208,3 +213,32 @@ EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window) {
}
return surf;
}
int wlr_egl_get_buffer_age(struct wlr_egl *egl, EGLSurface surface) {
if (!egl->egl_exts.buffer_age) {
return -1;
}
EGLint buffer_age;
EGLBoolean ok = eglQuerySurface(egl->display, surface,
EGL_BUFFER_AGE_EXT, &buffer_age);
if (!ok) {
wlr_log(L_ERROR, "Failed to get EGL surface buffer age: %s", egl_error());
return -1;
}
return buffer_age;
}
bool wlr_egl_make_current(struct wlr_egl *egl, EGLSurface surface,
int *buffer_age) {
if (!eglMakeCurrent(egl->display, surface, surface, egl->context)) {
wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
return false;
}
if (buffer_age != NULL) {
*buffer_age = wlr_egl_get_buffer_age(egl, surface);
}
return true;
}

43
render/gles2/renderer.c
View file

@ -105,14 +105,9 @@ static void init_globals() {
init_default_shaders();
}
static void wlr_gles2_begin(struct wlr_renderer *_renderer,
static void wlr_gles2_begin(struct wlr_renderer *wlr_renderer,
struct wlr_output *output) {
// TODO: let users customize the clear color?
GL_CALL(glClearColor(0.25f, 0.25f, 0.25f, 1));
GL_CALL(glClear(GL_COLOR_BUFFER_BIT));
int32_t width = output->width;
int32_t height = output->height;
GL_CALL(glViewport(0, 0, width, height));
GL_CALL(glViewport(0, 0, output->width, output->height));
// enable transparency
GL_CALL(glEnable(GL_BLEND));
@ -122,14 +117,30 @@ static void wlr_gles2_begin(struct wlr_renderer *_renderer,
// for users to sling matricies themselves
}
static void wlr_gles2_end(struct wlr_renderer *renderer) {
static void wlr_gles2_end(struct wlr_renderer *wlr_renderer) {
// no-op
}
static void wlr_gles2_clear(struct wlr_renderer *wlr_renderer,
const float (*color)[4]) {
glClearColor((*color)[0], (*color)[1], (*color)[2], (*color)[3]);
glClear(GL_COLOR_BUFFER_BIT);
}
static void wlr_gles2_scissor(struct wlr_renderer *wlr_renderer,
struct wlr_box *box) {
if (box != NULL) {
glScissor(box->x, box->y, box->width, box->height);
glEnable(GL_SCISSOR_TEST);
} else {
glDisable(GL_SCISSOR_TEST);
}
}
static struct wlr_texture *wlr_gles2_texture_create(
struct wlr_renderer *_renderer) {
struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer =
(struct wlr_gles2_renderer *)_renderer;
(struct wlr_gles2_renderer *)wlr_renderer;
return gles2_texture_create(renderer->egl);
}
@ -159,7 +170,7 @@ static void draw_quad() {
GL_CALL(glDisableVertexAttribArray(1));
}
static bool wlr_gles2_render_texture(struct wlr_renderer *_renderer,
static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer,
struct wlr_texture *texture, const float (*matrix)[16]) {
if (!texture || !texture->valid) {
wlr_log(L_ERROR, "attempt to render invalid texture");
@ -174,7 +185,7 @@ static bool wlr_gles2_render_texture(struct wlr_renderer *_renderer,
return true;
}
static void wlr_gles2_render_quad(struct wlr_renderer *renderer,
static void wlr_gles2_render_quad(struct wlr_renderer *wlr_renderer,
const float (*color)[4], const float (*matrix)[16]) {
GL_CALL(glUseProgram(shaders.quad));
GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, *matrix));
@ -182,7 +193,7 @@ static void wlr_gles2_render_quad(struct wlr_renderer *renderer,
draw_quad();
}
static void wlr_gles2_render_ellipse(struct wlr_renderer *renderer,
static void wlr_gles2_render_ellipse(struct wlr_renderer *wlr_renderer,
const float (*color)[4], const float (*matrix)[16]) {
GL_CALL(glUseProgram(shaders.ellipse));
GL_CALL(glUniformMatrix4fv(0, 1, GL_TRUE, *matrix));
@ -202,10 +213,10 @@ static const enum wl_shm_format *wlr_gles2_formats(
return formats;
}
static bool wlr_gles2_buffer_is_drm(struct wlr_renderer *_renderer,
static bool wlr_gles2_buffer_is_drm(struct wlr_renderer *wlr_renderer,
struct wl_resource *buffer) {
struct wlr_gles2_renderer *renderer =
(struct wlr_gles2_renderer *)_renderer;
(struct wlr_gles2_renderer *)wlr_renderer;
EGLint format;
return wlr_egl_query_buffer(renderer->egl, buffer,
EGL_TEXTURE_FORMAT, &format);
@ -243,6 +254,8 @@ static bool wlr_gles2_format_supported(struct wlr_renderer *r,
static struct wlr_renderer_impl wlr_renderer_impl = {
.begin = wlr_gles2_begin,
.end = wlr_gles2_end,
.clear = wlr_gles2_clear,
.scissor = wlr_gles2_scissor,
.texture_create = wlr_gles2_texture_create,
.render_with_matrix = wlr_gles2_render_texture,
.render_quad = wlr_gles2_render_quad,

33
render/matrix.c
View file

@ -169,22 +169,26 @@ void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
int width = box->width;
int height = box->height;
float translate_center[16];
wlr_matrix_translate(&translate_center,
(int)x + width / 2, (int)y + height / 2, 0);
wlr_matrix_translate(mat, x, y, 0);
float rotate[16];
wlr_matrix_rotate(&rotate, rotation);
if (rotation != 0) {
float translate_center[16];
wlr_matrix_translate(&translate_center, width/2, height/2, 0);
float translate_origin[16];
wlr_matrix_translate(&translate_origin, -width / 2,
-height / 2, 0);
float rotate[16];
wlr_matrix_rotate(&rotate, rotation);
float translate_origin[16];
wlr_matrix_translate(&translate_origin, -width/2, -height/2, 0);
wlr_matrix_mul(mat, &translate_center, mat);
wlr_matrix_mul(mat, &rotate, mat);
wlr_matrix_mul(mat, &translate_origin, mat);
}
float scale[16];
wlr_matrix_scale(&scale, width, height, 1);
wlr_matrix_mul(&translate_center, &rotate, mat);
wlr_matrix_mul(mat, &translate_origin, mat);
wlr_matrix_mul(mat, &scale, mat);
if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
@ -192,17 +196,14 @@ void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
wlr_matrix_translate(&surface_translate_center, 0.5, 0.5, 0);
float surface_transform[16];
wlr_matrix_transform(surface_transform,
wlr_output_transform_invert(transform));
wlr_matrix_transform(surface_transform, transform);
float surface_translate_origin[16];
wlr_matrix_translate(&surface_translate_origin, -0.5, -0.5, 0);
wlr_matrix_mul(mat, &surface_translate_center,
mat);
wlr_matrix_mul(mat, &surface_translate_center, mat);
wlr_matrix_mul(mat, &surface_transform, mat);
wlr_matrix_mul(mat, &surface_translate_origin,
mat);
wlr_matrix_mul(mat, &surface_translate_origin, mat);
}
wlr_matrix_mul(projection, mat, mat);

2
render/meson.build
View file

@ -22,7 +22,7 @@ lib_wlr_render = static_library(
glapi[0],
glapi[1],
include_directories: wlr_inc,
dependencies: [glesv2, egl],
dependencies: [glesv2, egl, pixman],
)
wlr_render = declare_dependency(

8
render/wlr_renderer.c
View file

@ -23,6 +23,14 @@ void wlr_renderer_end(struct wlr_renderer *r) {
r->impl->end(r);
}
void wlr_renderer_clear(struct wlr_renderer *r, const float (*color)[4]) {
r->impl->clear(r, color);
}
void wlr_renderer_scissor(struct wlr_renderer *r, struct wlr_box *box) {
r->impl->scissor(r, box);
}
struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r) {
return r->impl->texture_create(r);
}

7
rootston/cursor.c
View file

@ -138,6 +138,11 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
} else {
wlr_seat_pointer_clear_focus(seat->seat);
}
struct roots_drag_icon *drag_icon;
wl_list_for_each(drag_icon, &seat->drag_icons, link) {
roots_drag_icon_update_position(drag_icon);
}
break;
case ROOTS_CURSOR_MOVE:
view = roots_seat_get_focus(seat);
@ -198,7 +203,7 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
float angle = atan2(vx*uy - vy*ux, vx*ux + vy*uy);
int steps = 12;
angle = round(angle/M_PI*steps) / (steps/M_PI);
view->rotation = cursor->view_rotation + angle;
view_rotate(view, cursor->view_rotation + angle);
}
break;
}

178
rootston/desktop.c
View file

@ -24,12 +24,8 @@
void view_get_box(const struct roots_view *view, struct wlr_box *box) {
box->x = view->x;
box->y = view->y;
if (view->get_size) {
view->get_size(view, box);
} else {
box->width = view->wlr_surface->current->width;
box->height = view->wlr_surface->current->height;
}
box->width = view->width;
box->height = view->height;
}
void view_get_deco_box(const struct roots_view *view, struct wlr_box *box) {
@ -111,8 +107,7 @@ void view_move(struct roots_view *view, double x, double y) {
if (view->move) {
view->move(view, x, y);
} else {
view->x = x;
view->y = y;
view_update_position(view, x, y);
}
view_update_output(view, &before);
}
@ -195,7 +190,7 @@ void view_maximize(struct roots_view *view, bool maximized) {
view_move_resize(view, output_box->x, output_box->y, output_box->width,
output_box->height);
view->rotation = 0;
view_rotate(view, 0);
}
if (view->maximized && !maximized) {
@ -203,7 +198,7 @@ void view_maximize(struct roots_view *view, bool maximized) {
view_move_resize(view, view->saved.x, view->saved.y, view->saved.width,
view->saved.height);
view->rotation = view->saved.rotation;
view_rotate(view, view->saved.rotation);
}
}
@ -244,22 +239,34 @@ void view_set_fullscreen(struct roots_view *view, bool fullscreen,
wlr_output_layout_get_box(view->desktop->layout, output);
view_move_resize(view, output_box->x, output_box->y, output_box->width,
output_box->height);
view->rotation = 0;
view_rotate(view, 0);
roots_output->fullscreen_view = view;
view->fullscreen_output = roots_output;
output_damage_whole(roots_output);
}
if (was_fullscreen && !fullscreen) {
view_move_resize(view, view->saved.x, view->saved.y, view->saved.width,
view->saved.height);
view->rotation = view->saved.rotation;
view_rotate(view, view->saved.rotation);
output_damage_whole(view->fullscreen_output);
view->fullscreen_output->fullscreen_view = NULL;
view->fullscreen_output = NULL;
}
}
void view_rotate(struct roots_view *view, float rotation) {
if (view->rotation == rotation) {
return;
}
view_damage_whole(view);
view->rotation = rotation;
view_damage_whole(view);
}
void view_close(struct roots_view *view) {
if (view->close) {
view->close(view);
@ -305,19 +312,116 @@ bool view_center(struct roots_view *view) {
return true;
}
void view_destroy(struct roots_view *view) {
void view_child_finish(struct roots_view_child *child) {
if (child == NULL) {
return;
}
view_damage_whole(child->view);
wl_list_remove(&child->link);
wl_list_remove(&child->commit.link);
wl_list_remove(&child->new_subsurface.link);
}
static void view_child_handle_commit(struct wl_listener *listener,
void *data) {
struct roots_view_child *child = wl_container_of(listener, child, commit);
view_apply_damage(child->view);
}
static void view_child_handle_new_subsurface(struct wl_listener *listener,
void *data) {
struct roots_view_child *child =
wl_container_of(listener, child, new_subsurface);
struct wlr_subsurface *wlr_subsurface = data;
subsurface_create(child->view, wlr_subsurface);
}
void view_child_init(struct roots_view_child *child, struct roots_view *view,
struct wlr_surface *wlr_surface) {
assert(child->destroy);
child->view = view;
child->wlr_surface = wlr_surface;
child->commit.notify = view_child_handle_commit;
wl_signal_add(&wlr_surface->events.commit, &child->commit);
child->new_subsurface.notify = view_child_handle_new_subsurface;
wl_signal_add(&wlr_surface->events.new_subsurface, &child->new_subsurface);
wl_list_insert(&view->children, &child->link);
}
static void subsurface_destroy(struct roots_view_child *child) {
assert(child->destroy == subsurface_destroy);
struct roots_subsurface *subsurface = (struct roots_subsurface *)child;
if (subsurface == NULL) {
return;
}
wl_list_remove(&subsurface->destroy.link);
view_child_finish(&subsurface->view_child);
free(subsurface);
}
static void subsurface_handle_destroy(struct wl_listener *listener,
void *data) {
struct roots_subsurface *subsurface =
wl_container_of(listener, subsurface, destroy);
subsurface_destroy((struct roots_view_child *)subsurface);
}
struct roots_subsurface *subsurface_create(struct roots_view *view,
struct wlr_subsurface *wlr_subsurface) {
struct roots_subsurface *subsurface =
calloc(1, sizeof(struct roots_subsurface));
if (subsurface == NULL) {
return NULL;
}
subsurface->wlr_subsurface = wlr_subsurface;
subsurface->view_child.destroy = subsurface_destroy;
view_child_init(&subsurface->view_child, view, wlr_subsurface->surface);
subsurface->destroy.notify = subsurface_handle_destroy;
wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
return subsurface;
}
void view_finish(struct roots_view *view) {
view_damage_whole(view);
wl_signal_emit(&view->events.destroy, view);
wl_list_remove(&view->new_subsurface.link);
struct roots_view_child *child, *tmp;
wl_list_for_each_safe(child, tmp, &view->children, link) {
child->destroy(child);
}
if (view->fullscreen_output) {
view->fullscreen_output->fullscreen_view = NULL;
}
}
free(view);
static void view_handle_new_subsurface(struct wl_listener *listener,
void *data) {
struct roots_view *view = wl_container_of(listener, view, new_subsurface);
struct wlr_subsurface *wlr_subsurface = data;
subsurface_create(view, wlr_subsurface);
}
void view_init(struct roots_view *view, struct roots_desktop *desktop) {
assert(view->wlr_surface);
view->desktop = desktop;
wl_signal_init(&view->events.destroy);
wl_list_init(&view->children);
struct wlr_subsurface *subsurface;
wl_list_for_each(subsurface, &view->wlr_surface->subsurface_list,
parent_link) {
subsurface_create(view, subsurface);
}
view->new_subsurface.notify = view_handle_new_subsurface;
wl_signal_add(&view->wlr_surface->events.new_subsurface,
&view->new_subsurface);
view_damage_whole(view);
}
void view_setup(struct roots_view *view) {
@ -332,6 +436,42 @@ void view_setup(struct roots_view *view) {
view_update_output(view, NULL);
}
void view_apply_damage(struct roots_view *view) {
struct roots_output *output;
wl_list_for_each(output, &view->desktop->outputs, link) {
output_damage_from_view(output, view);
}
}
void view_damage_whole(struct roots_view *view) {
struct roots_output *output;
wl_list_for_each(output, &view->desktop->outputs, link) {
output_damage_whole_view(output, view);
}
}
void view_update_position(struct roots_view *view, double x, double y) {
if (view->x == x && view->y == y) {
return;
}
view_damage_whole(view);
view->x = x;
view->y = y;
view_damage_whole(view);
}
void view_update_size(struct roots_view *view, uint32_t width, uint32_t height) {
if (view->width == width && view->height == height) {
return;
}
view_damage_whole(view);
view->width = width;
view->height = height;
view_damage_whole(view);
}
static bool view_at(struct roots_view *view, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy) {
if (view->type == ROOTS_WL_SHELL_VIEW &&
@ -569,11 +709,11 @@ void desktop_destroy(struct roots_desktop *desktop) {
}
struct roots_output *desktop_output_from_wlr_output(
struct roots_desktop *desktop, struct wlr_output *output) {
struct roots_output *roots_output;
wl_list_for_each(roots_output, &desktop->outputs, link) {
if (roots_output->wlr_output == output) {
return roots_output;
struct roots_desktop *desktop, struct wlr_output *wlr_output) {
struct roots_output *output;
wl_list_for_each(output, &desktop->outputs, link) {
if (output->wlr_output == wlr_output) {
return output;
}
}
return NULL;

2
rootston/meson.build
View file

@ -15,5 +15,5 @@ if get_option('enable_xwayland')
sources += ['xwayland.c']
endif
executable(
'rootston', sources, dependencies: [wlroots, wlr_protos]
'rootston', sources, dependencies: [wlroots, wlr_protos, pixman]
)

683
rootston/output.c
View file

@ -2,17 +2,21 @@
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
#include <GLES2/gl2.h>
#include <assert.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_wl_shell.h>
#include <wlr/types/wlr_xdg_shell_v6.h>
#include <wlr/render/matrix.h>
#include <wlr/util/log.h>
#include <wlr/util/region.h>
#include "rootston/server.h"
#include "rootston/desktop.h"
#include "rootston/output.h"
#include "rootston/config.h"
typedef void (*surface_iterator_func_t)(struct wlr_surface *surface,
double lx, double ly, float rotation, void *data);
/**
* 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).
@ -31,66 +35,33 @@ static void rotate_child_position(double *sx, double *sy, double sw, double sh,
}
}
static void render_surface(struct wlr_surface *surface,
struct roots_desktop *desktop, struct wlr_output *wlr_output,
struct timespec *when, double lx, double ly, float rotation) {
if (!wlr_surface_has_buffer(surface)) {
return;
}
int width = surface->current->width;
int height = surface->current->height;
int render_width = width * wlr_output->scale;
int render_height = height * wlr_output->scale;
double ox = lx, oy = ly;
wlr_output_layout_output_coords(desktop->layout, wlr_output, &ox, &oy);
ox *= wlr_output->scale;
oy *= wlr_output->scale;
struct wlr_box render_box = {
.x = lx, .y = ly,
.width = render_width, .height = render_height,
};
if (wlr_output_layout_intersects(desktop->layout, wlr_output, &render_box)) {
struct wlr_box project_box = {
.x = ox,
.y = oy,
.width = render_width,
.height = render_height,
};
float matrix[16];
wlr_matrix_project_box(&matrix, &project_box, surface->current->transform,
rotation, &wlr_output->transform_matrix);
wlr_render_with_matrix(desktop->server->renderer, surface->texture,
&matrix);
wlr_surface_send_frame_done(surface, when);
}
static void surface_for_each_surface(struct wlr_surface *surface, double lx,
double ly, float rotation, surface_iterator_func_t iterator,
void *user_data) {
iterator(surface, lx, ly, rotation, user_data);
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);
rotate_child_position(&sx, &sy, state->width, state->height,
surface->current->width, surface->current->height, rotation);
render_surface(subsurface->surface, desktop, wlr_output, when,
lx + sx,
ly + sy,
rotation);
surface_for_each_surface(subsurface->surface, lx + sx, ly + sy,
rotation, iterator, user_data);
}
}
static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface,
struct roots_desktop *desktop, struct wlr_output *wlr_output,
struct timespec *when, double base_x, double base_y, float rotation) {
static void xdg_surface_v6_for_each_surface(struct wlr_xdg_surface_v6 *surface,
double base_x, double base_y, float rotation,
surface_iterator_func_t iterator, void *user_data) {
double width = surface->surface->current->width;
double height = surface->surface->current->height;
struct wlr_xdg_surface_v6 *popup;
wl_list_for_each(popup, &surface->popups, popup_link) {
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;
if (!popup->configured) {
continue;
}
@ -103,20 +74,20 @@ static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface,
rotate_child_position(&popup_sx, &popup_sy, popup_width, popup_height,
width, height, rotation);
render_surface(popup->surface, desktop, wlr_output, when,
base_x + popup_sx, base_y + popup_sy, rotation);
render_xdg_v6_popups(popup, desktop, wlr_output, when,
base_x + popup_sx, base_y + popup_sy, rotation);
surface_for_each_surface(popup->surface, base_x + popup_sx,
base_y + popup_sy, rotation, iterator, user_data);
xdg_surface_v6_for_each_surface(popup, base_x + popup_sx,
base_y + popup_sy, rotation, iterator, user_data);
}
}
static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface,
struct roots_desktop *desktop, struct wlr_output *wlr_output,
struct timespec *when, double lx, double ly, float rotation,
bool is_child) {
static void wl_shell_surface_for_each_surface(
struct wlr_wl_shell_surface *surface, double lx, double ly,
float rotation, bool is_child, surface_iterator_func_t iterator,
void *user_data) {
if (is_child || surface->state != WLR_WL_SHELL_SURFACE_STATE_POPUP) {
render_surface(surface->surface, desktop, wlr_output, when,
lx, ly, rotation);
surface_for_each_surface(surface->surface, lx, ly, rotation, iterator,
user_data);
double width = surface->surface->current->width;
double height = surface->surface->current->height;
@ -131,32 +102,160 @@ static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface,
rotate_child_position(&popup_x, &popup_y, popup_width, popup_height,
width, height, rotation);
render_wl_shell_surface(popup, desktop, wlr_output, when,
lx + popup_x, ly + popup_y, rotation, true);
wl_shell_surface_for_each_surface(popup, lx + popup_x, ly + popup_y,
rotation, true, iterator, user_data);
}
}
}
static void view_for_each_surface(struct roots_view *view,
surface_iterator_func_t iterator, void *user_data) {
switch (view->type) {
case ROOTS_XDG_SHELL_V6_VIEW:
surface_for_each_surface(view->wlr_surface, view->x, view->y,
view->rotation, iterator, user_data);
xdg_surface_v6_for_each_surface(view->xdg_surface_v6, view->x, view->y,
view->rotation, iterator, user_data);
break;
case ROOTS_WL_SHELL_VIEW:
wl_shell_surface_for_each_surface(view->wl_shell_surface, view->x,
view->y, view->rotation, false, iterator, user_data);
break;
#ifdef WLR_HAS_XWAYLAND
case ROOTS_XWAYLAND_VIEW:
if (view->wlr_surface != NULL) {
surface_for_each_surface(view->wlr_surface, view->x, view->y,
view->rotation, iterator, user_data);
}
break;
#endif
}
}
#ifdef WLR_HAS_XWAYLAND
static void render_xwayland_children(struct wlr_xwayland_surface *surface,
struct roots_desktop *desktop, struct wlr_output *wlr_output,
struct timespec *when) {
static void xwayland_children_for_each_surface(
struct wlr_xwayland_surface *surface,
surface_iterator_func_t iterator, void *user_data) {
struct wlr_xwayland_surface *child;
wl_list_for_each(child, &surface->children, parent_link) {
if (child->surface != NULL && child->added) {
render_surface(child->surface, desktop, wlr_output, when,
child->x, child->y, 0);
surface_for_each_surface(child->surface, child->x, child->y, 0,
iterator, user_data);
}
render_xwayland_children(child, desktop, wlr_output, when);
xwayland_children_for_each_surface(child, iterator, user_data);
}
}
#endif
static void render_decorations(struct roots_view *view,
struct roots_desktop *desktop, struct wlr_output *output) {
if (!view->decorated) {
struct render_data {
struct roots_output *output;
struct timespec *when;
pixman_region32_t *damage;
};
/**
* Checks whether a surface at (lx, ly) intersects an output. Sets `box` to the
* surface box in the output, in output-local coordinates.
*/
static bool surface_intersect_output(struct wlr_surface *surface,
struct wlr_output_layout *output_layout, struct wlr_output *wlr_output,
double lx, double ly, float rotation, struct wlr_box *box) {
double ox = lx, oy = ly;
wlr_output_layout_output_coords(output_layout, wlr_output, &ox, &oy);
box->x = ox * wlr_output->scale;
box->y = oy * wlr_output->scale;
box->width = surface->current->width * wlr_output->scale;
box->height = surface->current->height * wlr_output->scale;
struct wlr_box layout_box = {
.x = lx, .y = ly,
.width = surface->current->width, .height = surface->current->height,
};
wlr_box_rotated_bounds(&layout_box, -rotation, &layout_box);
return wlr_output_layout_intersects(output_layout, wlr_output, &layout_box);
}
static void scissor_output(struct roots_output *output, pixman_box32_t *rect) {
struct wlr_output *wlr_output = output->wlr_output;
struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
assert(renderer);
struct wlr_box box = {
.x = rect->x1,
.y = rect->y1,
.width = rect->x2 - rect->x1,
.height = rect->y2 - rect->y1,
};
int ow, oh;
wlr_output_transformed_resolution(output->wlr_output, &ow, &oh);
// Scissor is in renderer coordinates, ie. upside down
enum wl_output_transform transform = wlr_output_transform_compose(
wlr_output_transform_invert(wlr_output->transform),
WL_OUTPUT_TRANSFORM_FLIPPED_180);
wlr_box_transform(&box, transform, ow, oh, &box);
wlr_renderer_scissor(renderer, &box);
}
static void render_surface(struct wlr_surface *surface, double lx, double ly,
float rotation, void *_data) {
struct render_data *data = _data;
struct roots_output *output = data->output;
struct timespec *when = data->when;
struct wlr_renderer *renderer =
wlr_backend_get_renderer(output->wlr_output->backend);
assert(renderer);
if (!wlr_surface_has_buffer(surface)) {
return;
}
struct wlr_box box;
bool intersects = surface_intersect_output(surface, output->desktop->layout,
output->wlr_output, lx, ly, rotation, &box);
if (!intersects) {
return;
}
struct wlr_box rotated;
wlr_box_rotated_bounds(&box, -rotation, &rotated);
pixman_region32_t damage;
pixman_region32_init(&damage);
pixman_region32_union_rect(&damage, &damage, rotated.x, rotated.y,
rotated.width, rotated.height);
pixman_region32_intersect(&damage, &damage, data->damage);
bool damaged = pixman_region32_not_empty(&damage);
if (!damaged) {
goto damage_finish;
}
float matrix[16];
enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(&matrix, &box, transform, rotation,
&output->wlr_output->transform_matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]);
wlr_render_with_matrix(renderer, surface->texture, &matrix);
}
wlr_surface_send_frame_done(surface, when);
damage_finish:
pixman_region32_fini(&damage);
}
static void get_decoration_box(struct roots_view *view,
struct roots_output *output, struct wlr_box *box) {
struct wlr_output *wlr_output = output->wlr_output;
struct wlr_box deco_box;
view_get_deco_box(view, &deco_box);
double sx = deco_box.x - view->x;
@ -164,49 +263,70 @@ static void render_decorations(struct roots_view *view,
rotate_child_position(&sx, &sy, deco_box.width, deco_box.height,
view->wlr_surface->current->width,
view->wlr_surface->current->height, view->rotation);
double ox = sx + view->x;
double oy = sy + view->y;
double x = sx + view->x;
double y = sy + view->y;
wlr_output_layout_output_coords(desktop->layout, output, &ox, &oy);
ox *= output->scale;
oy *= output->scale;
wlr_output_layout_output_coords(output->desktop->layout, wlr_output, &x, &y);
struct wlr_box project_box = {
.x = ox,
.y = oy,
.width = deco_box.width,
.height = deco_box.height,
};
float matrix[16];
wlr_matrix_project_box(&matrix, &project_box, WL_OUTPUT_TRANSFORM_NORMAL,
view->rotation, &output->transform_matrix);
float color[4] = { 0.2, 0.2, 0.2, 1 };
wlr_render_colored_quad(desktop->server->renderer, &color, &matrix);
box->x = x * wlr_output->scale;
box->y = y * wlr_output->scale;
box->width = deco_box.width * wlr_output->scale;
box->height = deco_box.height * wlr_output->scale;
}
static void render_view(struct roots_view *view, struct roots_desktop *desktop,
struct wlr_output *wlr_output, struct timespec *when) {
render_decorations(view, desktop, wlr_output);
switch (view->type) {
case ROOTS_XDG_SHELL_V6_VIEW:
render_surface(view->wlr_surface, desktop, wlr_output, when,
view->x, view->y, view->rotation);
render_xdg_v6_popups(view->xdg_surface_v6, desktop, wlr_output,
when, view->x, view->y, view->rotation);
break;
case ROOTS_WL_SHELL_VIEW:
render_wl_shell_surface(view->wl_shell_surface, desktop, wlr_output,
when, view->x, view->y, view->rotation, false);
break;
#ifdef WLR_HAS_XWAYLAND
case ROOTS_XWAYLAND_VIEW:
render_surface(view->wlr_surface, desktop, wlr_output, when,
view->x, view->y, view->rotation);
break;
#endif
static void render_decorations(struct roots_view *view,
struct render_data *data) {
if (!view->decorated || view->wlr_surface == NULL) {
return;
}
struct roots_output *output = data->output;
struct wlr_renderer *renderer =
wlr_backend_get_renderer(output->wlr_output->backend);
assert(renderer);
struct wlr_box box;
get_decoration_box(view, output, &box);
struct wlr_box rotated;
wlr_box_rotated_bounds(&box, -view->rotation, &rotated);
pixman_region32_t damage;
pixman_region32_init(&damage);
pixman_region32_union_rect(&damage, &damage, rotated.x, rotated.y,
rotated.width, rotated.height);
pixman_region32_intersect(&damage, &damage, data->damage);
bool damaged = pixman_region32_not_empty(&damage);
if (!damaged) {
goto damage_finish;
}
float matrix[16];
wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
view->rotation, &output->wlr_output->transform_matrix);
float color[] = { 0.2, 0.2, 0.2, 1 };
int nrects;
pixman_box32_t *rects =
pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]);
wlr_render_colored_quad(renderer, &color, &matrix);
}
damage_finish:
pixman_region32_fini(&damage);
}
static void render_view(struct roots_view *view, struct render_data *data) {
// Do not render views fullscreened on other outputs
if (view->fullscreen_output != NULL &&
view->fullscreen_output != data->output) {
return;
}
render_decorations(view, data);
view_for_each_surface(view, render_surface, data);
}
static bool has_standalone_surface(struct roots_view *view) {
@ -227,11 +347,12 @@ static bool has_standalone_surface(struct roots_view *view) {
return true;
}
static void output_frame_notify(struct wl_listener *listener, void *data) {
struct wlr_output *wlr_output = data;
struct roots_output *output = wl_container_of(listener, output, frame);
static void render_output(struct roots_output *output) {
struct wlr_output *wlr_output = output->wlr_output;
struct roots_desktop *desktop = output->desktop;
struct roots_server *server = desktop->server;
struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
assert(renderer);
if (!wlr_output->enabled) {
return;
@ -240,9 +361,9 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
wlr_output_make_current(wlr_output);
wlr_renderer_begin(server->renderer, wlr_output);
float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f};
// Check if we can delegate the fullscreen surface to the output
if (output->fullscreen_view != NULL) {
struct roots_view *view = output->fullscreen_view;
@ -261,65 +382,292 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
wlr_output_set_fullscreen_surface(wlr_output, view->wlr_surface);
} else {
wlr_output_set_fullscreen_surface(wlr_output, NULL);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
render_view(view, desktop, wlr_output, &now);
// During normal rendering the xwayland window tree isn't traversed
// because all windows are rendered. Here we only want to render
// the fullscreen window's children so we have to traverse the tree.
#ifdef WLR_HAS_XWAYLAND
if (view->type == ROOTS_XWAYLAND_VIEW) {
render_xwayland_children(view->xwayland_surface, desktop,
wlr_output, &now);
}
#endif
}
wlr_renderer_end(server->renderer);
wlr_output_swap_buffers(wlr_output);
output->last_frame = desktop->last_frame = now;
return;
// Fullscreen views are rendered on a black background
clear_color[0] = clear_color[1] = clear_color[2] = 0;
} else {
wlr_output_set_fullscreen_surface(wlr_output, NULL);
}
struct roots_view *view;
wl_list_for_each_reverse(view, &desktop->views, link) {
render_view(view, desktop, wlr_output, &now);
int buffer_age = -1;
if (!wlr_output_make_current(wlr_output, &buffer_age)) {
return;
}
struct wlr_drag_icon *drag_icon = NULL;
int width, height;
wlr_output_transformed_resolution(output->wlr_output, &width, &height);
// Check if we can use damage tracking
pixman_region32_t damage;
pixman_region32_init(&damage);
if (buffer_age <= 0 || buffer_age - 1 > ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN) {
// Buffer new or too old, damage the whole output
pixman_region32_union_rect(&damage, &damage, 0, 0, width, height);
} else {
pixman_region32_copy(&damage, &output->damage);
// Accumulate damage from old buffers
size_t idx = output->previous_damage_idx;
for (int i = 0; i < buffer_age - 1; ++i) {
int j = (idx + i) % ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN;
pixman_region32_union(&damage, &damage, &output->previous_damage[j]);
}
}
pixman_region32_intersect_rect(&damage, &damage, 0, 0, width, height);
if (!pixman_region32_not_empty(&damage) && !wlr_output->needs_swap) {
// Output doesn't need swap and isn't damaged, skip rendering completely
goto damage_finish;
}
struct render_data data = {
.output = output,
.when = &now,
.damage = &damage,
};
wlr_renderer_begin(renderer, wlr_output);
if (!pixman_region32_not_empty(&damage)) {
// Output isn't damaged but needs buffer swap
goto renderer_end;
}
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]);
wlr_renderer_clear(renderer, &clear_color);
}
// If a view is fullscreen on this output, render it
if (output->fullscreen_view != NULL) {
struct roots_view *view = output->fullscreen_view;
if (wlr_output->fullscreen_surface == view->wlr_surface) {
// The output will render the fullscreen view
goto renderer_end;
}
view_for_each_surface(view, render_surface, &data);
// During normal rendering the xwayland window tree isn't traversed
// because all windows are rendered. Here we only want to render
// the fullscreen window's children so we have to traverse the tree.
#ifdef WLR_HAS_XWAYLAND
if (view->type == ROOTS_XWAYLAND_VIEW) {
xwayland_children_for_each_surface(view->xwayland_surface,
render_surface, &data);
}
#endif
goto renderer_end;
}
// Render all views
struct roots_view *view;
wl_list_for_each_reverse(view, &desktop->views, link) {
render_view(view, &data);
}
// Render drag icons
struct roots_drag_icon *drag_icon = NULL;
struct roots_seat *seat = NULL;
wl_list_for_each(seat, &server->input->seats, link) {
wl_list_for_each(drag_icon, &seat->seat->drag_icons, link) {
if (!drag_icon->mapped) {
wl_list_for_each(drag_icon, &seat->drag_icons, link) {
if (!drag_icon->wlr_drag_icon->mapped) {
continue;
}
struct wlr_surface *icon = drag_icon->surface;
struct wlr_cursor *cursor = seat->cursor->cursor;
double icon_x = 0, icon_y = 0;
if (drag_icon->is_pointer) {
icon_x = cursor->x + drag_icon->sx;
icon_y = cursor->y + drag_icon->sy;
render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0);
} else {
struct wlr_touch_point *point =
wlr_seat_touch_get_point(seat->seat, drag_icon->touch_id);
if (point) {
icon_x = seat->touch_x + drag_icon->sx;
icon_y = seat->touch_y + drag_icon->sy;
render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0);
}
}
render_surface(drag_icon->wlr_drag_icon->surface,
drag_icon->x, drag_icon->y, 0, &data);
}
}
wlr_renderer_end(server->renderer);
wlr_output_swap_buffers(wlr_output);
renderer_end:
wlr_renderer_scissor(renderer, NULL);
wlr_renderer_end(renderer);
if (!wlr_output_swap_buffers(wlr_output, &now, &damage)) {
goto damage_finish;
}
// same as decrementing, but works on unsigned integers
output->previous_damage_idx += ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN - 1;
output->previous_damage_idx %= ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN;
pixman_region32_copy(&output->previous_damage[output->previous_damage_idx],
&output->damage);
pixman_region32_clear(&output->damage);
output->last_frame = desktop->last_frame = now;
damage_finish:
pixman_region32_fini(&damage);
}
static void output_handle_frame(struct wl_listener *listener, void *data) {
struct roots_output *output = wl_container_of(listener, output, frame);
render_output(output);
}
void output_damage_whole(struct roots_output *output) {
int width, height;
wlr_output_transformed_resolution(output->wlr_output, &width, &height);
pixman_region32_union_rect(&output->damage, &output->damage, 0, 0,
width, height);
wlr_output_schedule_frame(output->wlr_output);
}
static bool view_accept_damage(struct roots_output *output,
struct roots_view *view) {
if (output->fullscreen_view == NULL) {
return true;
}
if (output->fullscreen_view == view) {
return true;
}
#ifdef WLR_HAS_XWAYLAND
if (output->fullscreen_view->type == ROOTS_XWAYLAND_VIEW &&
view->type == ROOTS_XWAYLAND_VIEW) {
// Special case: accept damage from children
struct wlr_xwayland_surface *xsurface = view->xwayland_surface;
while (xsurface != NULL) {
if (output->fullscreen_view->xwayland_surface == xsurface) {
return true;
}
xsurface = xsurface->parent;
}
}
#endif
return false;
}
static void damage_whole_surface(struct wlr_surface *surface,
double lx, double ly, float rotation, void *data) {
struct roots_output *output = data;
if (!wlr_surface_has_buffer(surface)) {
return;
}
int ow, oh;
wlr_output_transformed_resolution(output->wlr_output, &ow, &oh);
struct wlr_box box;
bool intersects = surface_intersect_output(surface, output->desktop->layout,
output->wlr_output, lx, ly, rotation, &box);
if (!intersects) {
return;
}
wlr_box_rotated_bounds(&box, -rotation, &box);
pixman_region32_union_rect(&output->damage, &output->damage,
box.x, box.y, box.width, box.height);
wlr_output_schedule_frame(output->wlr_output);
}
static void damage_whole_decoration(struct roots_view *view,
struct roots_output *output) {
if (!view->decorated || view->wlr_surface == NULL) {
return;
}
struct wlr_box box;
get_decoration_box(view, output, &box);
wlr_box_rotated_bounds(&box, -view->rotation, &box);
pixman_region32_union_rect(&output->damage, &output->damage,
box.x, box.y, box.width, box.height);
}
void output_damage_whole_view(struct roots_output *output,
struct roots_view *view) {
if (!view_accept_damage(output, view)) {
return;
}
damage_whole_decoration(view, output);
view_for_each_surface(view, damage_whole_surface, output);
}
void output_damage_whole_drag_icon(struct roots_output *output,
struct roots_drag_icon *icon) {
surface_for_each_surface(icon->wlr_drag_icon->surface, icon->x, icon->y, 0,
damage_whole_surface, output);
}
static void damage_from_surface(struct wlr_surface *surface,
double lx, double ly, float rotation, void *data) {
struct roots_output *output = data;
struct wlr_output *wlr_output = output->wlr_output;
if (!wlr_surface_has_buffer(surface)) {
return;
}
int ow, oh;
wlr_output_transformed_resolution(wlr_output, &ow, &oh);
struct wlr_box box;
surface_intersect_output(surface, output->desktop->layout,
wlr_output, lx, ly, rotation, &box);
if (rotation == 0) {
pixman_region32_t damage;
pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->surface_damage);
wlr_region_scale(&damage, &damage, wlr_output->scale);
if (ceil(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(wlr_output->scale) - surface->current->scale);
}
pixman_region32_translate(&damage, box.x, box.y);
pixman_region32_union(&output->damage, &output->damage, &damage);
pixman_region32_fini(&damage);
} else {
pixman_box32_t *extents =
pixman_region32_extents(&surface->current->surface_damage);
struct wlr_box damage_box = {
.x = box.x + extents->x1 * wlr_output->scale,
.y = box.y + extents->y1 * wlr_output->scale,
.width = (extents->x2 - extents->x1) * wlr_output->scale,
.height = (extents->y2 - extents->y1) * wlr_output->scale,
};
wlr_box_rotated_bounds(&damage_box, -rotation, &damage_box);
pixman_region32_union_rect(&output->damage, &output->damage,
damage_box.x, damage_box.y, damage_box.width, damage_box.height);
}
pixman_region32_intersect_rect(&output->damage, &output->damage, 0, 0,
ow, oh);
wlr_output_schedule_frame(wlr_output);
}
void output_damage_from_view(struct roots_output *output,
struct roots_view *view) {
if (!view_accept_damage(output, view)) {
return;
}
view_for_each_surface(view, damage_from_surface, output);
}
static void output_handle_mode(struct wl_listener *listener, void *data) {
struct roots_output *output = wl_container_of(listener, output, mode);
output_damage_whole(output);
}
static void output_handle_needs_swap(struct wl_listener *listener, void *data) {
struct roots_output *output =
wl_container_of(listener, output, needs_swap);
pixman_region32_union(&output->damage, &output->damage,
&output->wlr_output->damage);
wlr_output_schedule_frame(output->wlr_output);
}
static void set_mode(struct wlr_output *output,
@ -372,9 +720,18 @@ void output_add_notify(struct wl_listener *listener, void *data) {
clock_gettime(CLOCK_MONOTONIC, &output->last_frame);
output->desktop = desktop;
output->wlr_output = wlr_output;
output->frame.notify = output_frame_notify;
wl_signal_add(&wlr_output->events.frame, &output->frame);
wl_list_insert(&desktop->outputs, &output->link);
pixman_region32_init(&output->damage);
for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) {
pixman_region32_init(&output->previous_damage[i]);
}
output->frame.notify = output_handle_frame;
wl_signal_add(&wlr_output->events.frame, &output->frame);
output->mode.notify = output_handle_mode;
wl_signal_add(&wlr_output->events.mode, &output->mode);
output->needs_swap.notify = output_handle_needs_swap;
wl_signal_add(&wlr_output->events.needs_swap, &output->needs_swap);
struct roots_output_config *output_config =
roots_config_get_output(config, wlr_output);
@ -399,6 +756,8 @@ void output_add_notify(struct wl_listener *listener, void *data) {
roots_seat_configure_cursor(seat);
roots_seat_configure_xcursor(seat);
}
output_damage_whole(output);
}
void output_remove_notify(struct wl_listener *listener, void *data) {
@ -423,7 +782,13 @@ void output_remove_notify(struct wl_listener *listener, void *data) {
//example_config_configure_cursor(sample->config, sample->cursor,
// sample->compositor);
pixman_region32_fini(&output->damage);
for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) {
pixman_region32_fini(&output->previous_damage[i]);
}
wl_list_remove(&output->link);
wl_list_remove(&output->frame.link);
wl_list_remove(&output->mode.link);
wl_list_remove(&output->needs_swap.link);
free(output);
}

99
rootston/seat.c
View file

@ -241,19 +241,97 @@ static void roots_seat_init_cursor(struct roots_seat *seat) {
seat->cursor->tool_tip.notify = handle_tool_tip;
wl_signal_add(&seat->seat->events.request_set_cursor,
&seat->cursor->request_set_cursor);
&seat->cursor->request_set_cursor);
seat->cursor->request_set_cursor.notify = handle_request_set_cursor;
}
static void roots_drag_icon_handle_surface_commit(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, surface_commit);
roots_drag_icon_damage_whole(icon);
}
static void roots_drag_icon_handle_map(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, map);
roots_drag_icon_damage_whole(icon);
}
static void roots_drag_icon_handle_destroy(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, destroy);
roots_drag_icon_damage_whole(icon);
wl_list_remove(&icon->link);
wl_list_remove(&icon->surface_commit.link);
wl_list_remove(&icon->map.link);
wl_list_remove(&icon->destroy.link);
free(icon);
}
static void roots_seat_handle_new_drag_icon(struct wl_listener *listener,
void *data) {
struct roots_seat *seat = wl_container_of(listener, seat, new_drag_icon);
struct wlr_drag_icon *wlr_drag_icon = data;
struct roots_drag_icon *icon = calloc(1, sizeof(struct roots_drag_icon));
if (icon == NULL) {
return;
}
icon->seat = seat;
icon->wlr_drag_icon = wlr_drag_icon;
icon->surface_commit.notify = roots_drag_icon_handle_surface_commit;
wl_signal_add(&wlr_drag_icon->surface->events.commit, &icon->surface_commit);
icon->map.notify = roots_drag_icon_handle_map;
wl_signal_add(&wlr_drag_icon->events.map, &icon->map);
icon->destroy.notify = roots_drag_icon_handle_destroy;
wl_signal_add(&wlr_drag_icon->events.destroy, &icon->destroy);
wl_list_insert(&seat->drag_icons, &icon->link);
}
void roots_drag_icon_update_position(struct roots_drag_icon *icon) {
roots_drag_icon_damage_whole(icon);
struct wlr_drag_icon *wlr_icon = icon->wlr_drag_icon;
struct roots_seat *seat = icon->seat;
struct wlr_cursor *cursor = seat->cursor->cursor;
if (wlr_icon->is_pointer) {
icon->x = cursor->x + wlr_icon->sx;
icon->y = cursor->y + wlr_icon->sy;
} else {
struct wlr_touch_point *point =
wlr_seat_touch_get_point(seat->seat, wlr_icon->touch_id);
if (point == NULL) {
return;
}
icon->x = seat->touch_x + wlr_icon->sx;
icon->y = seat->touch_y + wlr_icon->sy;
}
roots_drag_icon_damage_whole(icon);
}
void roots_drag_icon_damage_whole(struct roots_drag_icon *icon) {
struct roots_output *output;
wl_list_for_each(output, &icon->seat->input->server->desktop->outputs,
link) {
output_damage_whole_drag_icon(output, icon);
}
}
static void seat_view_destroy(struct roots_seat_view *seat_view);
static void roots_seat_handle_seat_destroy(struct wl_listener *listener,
static void roots_seat_handle_destroy(struct wl_listener *listener,
void *data) {
struct roots_seat *seat =
wl_container_of(listener, seat, seat_destroy);
struct roots_seat *seat = wl_container_of(listener, seat, destroy);
// TODO: probably more to be freed here
wl_list_remove(&seat->seat_destroy.link);
wl_list_remove(&seat->destroy.link);
struct roots_seat_view *view, *nview;
wl_list_for_each_safe(view, nview, &seat->views, link) {
@ -262,7 +340,7 @@ static void roots_seat_handle_seat_destroy(struct wl_listener *listener,
}
void roots_seat_destroy(struct roots_seat *seat) {
roots_seat_handle_seat_destroy(&seat->seat_destroy, seat->seat);
roots_seat_handle_destroy(&seat->destroy, seat->seat);
wlr_seat_destroy(seat->seat);
}
@ -277,6 +355,7 @@ struct roots_seat *roots_seat_create(struct roots_input *input, char *name) {
wl_list_init(&seat->touch);
wl_list_init(&seat->tablet_tools);
wl_list_init(&seat->views);
wl_list_init(&seat->drag_icons);
seat->input = input;
@ -295,8 +374,10 @@ struct roots_seat *roots_seat_create(struct roots_input *input, char *name) {
wl_list_insert(&input->seats, &seat->link);
seat->seat_destroy.notify = roots_seat_handle_seat_destroy;
wl_signal_add(&seat->seat->events.destroy, &seat->seat_destroy);
seat->new_drag_icon.notify = roots_seat_handle_new_drag_icon;
wl_signal_add(&seat->seat->events.new_drag_icon, &seat->new_drag_icon);
seat->destroy.notify = roots_seat_handle_destroy;
wl_signal_add(&seat->seat->events.destroy, &seat->destroy);
return seat;
}
@ -683,6 +764,8 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) {
wl_list_remove(&seat_view->link);
wl_list_insert(&seat->views, &seat_view->link);
view_damage_whole(view);
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->seat);
if (keyboard != NULL) {
wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface,

92
rootston/wl_shell.c
View file

@ -10,6 +10,61 @@
#include "rootston/server.h"
#include "rootston/input.h"
static void popup_destroy(struct roots_view_child *child) {
assert(child->destroy == popup_destroy);
struct roots_wl_shell_popup *popup = (struct roots_wl_shell_popup *)child;
if (popup == NULL) {
return;
}
wl_list_remove(&popup->destroy.link);
wl_list_remove(&popup->set_state.link);
wl_list_remove(&popup->new_popup.link);
view_child_finish(&popup->view_child);
free(popup);
}
static void popup_handle_destroy(struct wl_listener *listener, void *data) {
struct roots_wl_shell_popup *popup =
wl_container_of(listener, popup, destroy);
popup_destroy((struct roots_view_child *)popup);
}
static void popup_handle_set_state(struct wl_listener *listener, void *data) {
struct roots_wl_shell_popup *popup =
wl_container_of(listener, popup, set_state);
popup_destroy((struct roots_view_child *)popup);
}
static struct roots_wl_shell_popup *popup_create(struct roots_view *view,
struct wlr_wl_shell_surface *wlr_wl_shell_surface);
static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
struct roots_wl_shell_popup *popup =
wl_container_of(listener, popup, new_popup);
struct wlr_wl_shell_surface *wlr_wl_shell_surface = data;
popup_create(popup->view_child.view, wlr_wl_shell_surface);
}
static struct roots_wl_shell_popup *popup_create(struct roots_view *view,
struct wlr_wl_shell_surface *wlr_wl_shell_surface) {
struct roots_wl_shell_popup *popup =
calloc(1, sizeof(struct roots_wl_shell_popup));
if (popup == NULL) {
return NULL;
}
popup->wlr_wl_shell_surface = wlr_wl_shell_surface;
popup->view_child.destroy = popup_destroy;
view_child_init(&popup->view_child, view, wlr_wl_shell_surface->surface);
popup->destroy.notify = popup_handle_destroy;
wl_signal_add(&wlr_wl_shell_surface->events.destroy, &popup->destroy);
popup->set_state.notify = popup_handle_set_state;
wl_signal_add(&wlr_wl_shell_surface->events.set_state, &popup->set_state);
popup->new_popup.notify = popup_handle_new_popup;
wl_signal_add(&wlr_wl_shell_surface->events.new_popup, &popup->new_popup);
return popup;
}
static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
assert(view->type == ROOTS_WL_SHELL_VIEW);
struct wlr_wl_shell_surface *surf = view->wl_shell_surface;
@ -88,19 +143,32 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_view *view = roots_surface->view;
struct wlr_surface *wlr_surface = view->wlr_surface;
view_apply_damage(view);
int width = wlr_surface->current->width;
int height = wlr_surface->current->height;
view_update_size(view, width, height);
double x = view->x;
double y = view->y;
if (view->pending_move_resize.update_x) {
view->x = view->pending_move_resize.x +
view->pending_move_resize.width - width;
x = view->pending_move_resize.x + view->pending_move_resize.width -
width;
view->pending_move_resize.update_x = false;
}
if (view->pending_move_resize.update_y) {
view->y = view->pending_move_resize.y +
view->pending_move_resize.height - height;
y = view->pending_move_resize.y + view->pending_move_resize.height -
height;
view->pending_move_resize.update_y = false;
}
view_update_position(view, x, y);
}
static void handle_new_popup(struct wl_listener *listener, void *data) {
struct roots_wl_shell_surface *roots_surface =
wl_container_of(listener, roots_surface, new_popup);
struct wlr_wl_shell_surface *wlr_wl_shell_surface = data;
popup_create(roots_surface->view, wlr_wl_shell_surface);
}
static void handle_destroy(struct wl_listener *listener, void *data) {
@ -114,16 +182,22 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
wl_list_remove(&roots_surface->set_state.link);
wl_list_remove(&roots_surface->surface_commit.link);
wl_list_remove(&roots_surface->view->link);
view_destroy(roots_surface->view);
view_finish(roots_surface->view);
free(roots_surface->view);
free(roots_surface);
}
void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
struct roots_desktop *desktop =
wl_container_of(listener, desktop, wl_shell_surface);
struct wlr_wl_shell_surface *surface = data;
wlr_log(L_DEBUG, "new shell surface: title=%s, class=%s",
if (surface->state == WLR_WL_SHELL_SURFACE_STATE_POPUP) {
wlr_log(L_DEBUG, "new wl shell popup");
return;
}
wlr_log(L_DEBUG, "new wl shell surface: title=%s, class=%s",
surface->title, surface->class);
wlr_wl_shell_surface_ping(surface);
@ -134,6 +208,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
}
roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
roots_surface->new_popup.notify = handle_new_popup;
wl_signal_add(&surface->events.new_popup, &roots_surface->new_popup);
roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
roots_surface->request_resize.notify = handle_request_resize;
@ -157,6 +233,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
return;
}
view->type = ROOTS_WL_SHELL_VIEW;
view->width = surface->surface->current->width;
view->height = surface->surface->current->height;
view->wl_shell_surface = surface;
view->roots_wl_shell_surface = roots_surface;

103
rootston/xdg_shell_v6.c
View file

@ -10,6 +10,52 @@
#include "rootston/server.h"
#include "rootston/input.h"
static void popup_destroy(struct roots_view_child *child) {
assert(child->destroy == popup_destroy);
struct roots_xdg_popup_v6 *popup = (struct roots_xdg_popup_v6 *)child;
if (popup == NULL) {
return;
}
wl_list_remove(&popup->destroy.link);
wl_list_remove(&popup->new_popup.link);
view_child_finish(&popup->view_child);
free(popup);
}
static void popup_handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xdg_popup_v6 *popup =
wl_container_of(listener, popup, destroy);
popup_destroy((struct roots_view_child *)popup);
}
static struct roots_xdg_popup_v6 *popup_create(struct roots_view *view,
struct wlr_xdg_popup_v6 *wlr_popup);
static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
struct roots_xdg_popup_v6 *popup =
wl_container_of(listener, popup, new_popup);
struct wlr_xdg_popup_v6 *wlr_popup = data;
popup_create(popup->view_child.view, wlr_popup);
}
static struct roots_xdg_popup_v6 *popup_create(struct roots_view *view,
struct wlr_xdg_popup_v6 *wlr_popup) {
struct roots_xdg_popup_v6 *popup =
calloc(1, sizeof(struct roots_xdg_popup_v6));
if (popup == NULL) {
return NULL;
}
popup->wlr_popup = wlr_popup;
popup->view_child.destroy = popup_destroy;
view_child_init(&popup->view_child, view, wlr_popup->base->surface);
popup->destroy.notify = popup_handle_destroy;
wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy);
popup->new_popup.notify = popup_handle_new_popup;
wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup);
return popup;
}
static void get_size(const struct roots_view *view, struct wlr_box *box) {
assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
struct wlr_xdg_surface_v6 *surface = view->xdg_surface_v6;
@ -102,8 +148,7 @@ static void move_resize(struct roots_view *view, double x, double y,
if (serial > 0) {
roots_surface->pending_move_resize_configure_serial = serial;
} else if (roots_surface->pending_move_resize_configure_serial == 0) {
view->x = x;
view->y = y;
view_update_position(view, x, y);
}
}
@ -192,26 +237,32 @@ static void handle_request_fullscreen(struct wl_listener *listener,
view_set_fullscreen(view, e->fullscreen, e->output);
}
static void handle_commit(struct wl_listener *listener, void *data) {
static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_surface =
wl_container_of(listener, roots_surface, commit);
wl_container_of(listener, roots_surface, surface_commit);
struct roots_view *view = roots_surface->view;
struct wlr_xdg_surface_v6 *surface = view->xdg_surface_v6;
view_apply_damage(view);
struct wlr_box size;
get_size(view, &size);
view_update_size(view, size.width, size.height);
uint32_t pending_serial =
roots_surface->pending_move_resize_configure_serial;
if (pending_serial > 0 && pending_serial >= surface->configure_serial) {
struct wlr_box size;
get_size(view, &size);
double x = view->x;
double y = view->y;
if (view->pending_move_resize.update_x) {
view->x = view->pending_move_resize.x +
view->pending_move_resize.width - size.width;
x = view->pending_move_resize.x + view->pending_move_resize.width -
size.width;
}
if (view->pending_move_resize.update_y) {
view->y = view->pending_move_resize.y +
view->pending_move_resize.height - size.height;
y = view->pending_move_resize.y + view->pending_move_resize.height -
size.height;
}
view_update_position(view, x, y);
if (pending_serial == surface->configure_serial) {
roots_surface->pending_move_resize_configure_serial = 0;
@ -219,15 +270,26 @@ static void handle_commit(struct wl_listener *listener, void *data) {
}
}
static void handle_new_popup(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, new_popup);
struct wlr_xdg_popup_v6 *wlr_popup = data;
popup_create(roots_xdg_surface->view, wlr_popup);
}
static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, destroy);
wl_list_remove(&roots_xdg_surface->commit.link);
wl_list_remove(&roots_xdg_surface->surface_commit.link);
wl_list_remove(&roots_xdg_surface->destroy.link);
wl_list_remove(&roots_xdg_surface->new_popup.link);
wl_list_remove(&roots_xdg_surface->request_move.link);
wl_list_remove(&roots_xdg_surface->request_resize.link);
wl_list_remove(&roots_xdg_surface->request_maximize.link);
wl_list_remove(&roots_xdg_surface->request_fullscreen.link);
wl_list_remove(&roots_xdg_surface->view->link);
view_destroy(roots_xdg_surface->view);
view_finish(roots_xdg_surface->view);
free(roots_xdg_surface->view);
free(roots_xdg_surface);
}
@ -252,8 +314,9 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
if (!roots_surface) {
return;
}
roots_surface->commit.notify = handle_commit;
wl_signal_add(&surface->surface->events.commit, &roots_surface->commit);
roots_surface->surface_commit.notify = handle_surface_commit;
wl_signal_add(&surface->surface->events.commit,
&roots_surface->surface_commit);
roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
roots_surface->request_move.notify = handle_request_move;
@ -267,6 +330,8 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
roots_surface->request_fullscreen.notify = handle_request_fullscreen;
wl_signal_add(&surface->events.request_fullscreen,
&roots_surface->request_fullscreen);
roots_surface->new_popup.notify = handle_new_popup;
wl_signal_add(&surface->events.new_popup, &roots_surface->new_popup);
struct roots_view *view = calloc(1, sizeof(struct roots_view));
if (!view) {
@ -274,10 +339,10 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
return;
}
view->type = ROOTS_XDG_SHELL_V6_VIEW;
view->xdg_surface_v6 = surface;
view->roots_xdg_surface_v6 = roots_surface;
view->wlr_surface = surface->surface;
view->get_size = get_size;
view->activate = activate;
view->resize = resize;
view->move_resize = move_resize;
@ -285,6 +350,12 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
view->set_fullscreen = set_fullscreen;
view->close = close;
roots_surface->view = view;
struct wlr_box box;
get_size(view, &box);
view->width = box.width;
view->height = box.height;
view_init(view, desktop);
wl_list_insert(&desktop->views, &view->link);

61
rootston/xwayland.c
View file

@ -18,8 +18,7 @@ static void activate(struct roots_view *view, bool active) {
static void move(struct roots_view *view, double x, double y) {
assert(view->type == ROOTS_XWAYLAND_VIEW);
struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
view->x = x;
view->y = y;
view_update_position(view, x, y);
wlr_xwayland_surface_configure(xwayland_surface, x, y,
xwayland_surface->width, xwayland_surface->height);
}
@ -122,7 +121,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
if (xwayland_surface->mapped) {
wl_list_remove(&roots_surface->view->link);
}
view_destroy(roots_surface->view);
view_finish(roots_surface->view);
free(roots_surface->view);
free(roots_surface);
}
@ -133,8 +133,7 @@ static void handle_request_configure(struct wl_listener *listener, void *data) {
roots_surface->view->xwayland_surface;
struct wlr_xwayland_surface_configure_event *event = data;
roots_surface->view->x = (double)event->x;
roots_surface->view->y = (double)event->y;
view_update_position(roots_surface->view, event->x, event->y);
wlr_xwayland_surface_configure(xwayland_surface, event->x, event->y,
event->width, event->height);
@ -206,19 +205,25 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_view *view = roots_surface->view;
struct wlr_surface *wlr_surface = view->wlr_surface;
view_apply_damage(view);
int width = wlr_surface->current->width;
int height = wlr_surface->current->height;
view_update_size(view, width, height);
double x = view->x;
double y = view->y;
if (view->pending_move_resize.update_x) {
view->x = view->pending_move_resize.x +
view->pending_move_resize.width - width;
x = view->pending_move_resize.x + view->pending_move_resize.width -
width;
view->pending_move_resize.update_x = false;
}
if (view->pending_move_resize.update_y) {
view->y = view->pending_move_resize.y +
view->pending_move_resize.height - height;
y = view->pending_move_resize.y + view->pending_move_resize.height -
height;
view->pending_move_resize.update_y = false;
}
view_update_position(view, x, y);
}
static void handle_map_notify(struct wl_listener *listener, void *data) {
@ -229,24 +234,48 @@ static void handle_map_notify(struct wl_listener *listener, void *data) {
struct roots_desktop *desktop = view->desktop;
view->wlr_surface = xsurface->surface;
view->x = (double)xsurface->x;
view->y = (double)xsurface->y;
view->x = xsurface->x;
view->y = xsurface->y;
view->width = xsurface->surface->current->width;
view->height = xsurface->surface->current->height;
wl_list_insert(&desktop->views, &view->link);
struct wlr_subsurface *subsurface;
wl_list_for_each(subsurface, &view->wlr_surface->subsurface_list,
parent_link) {
subsurface_create(view, subsurface);
}
view_damage_whole(view);
roots_surface->surface_commit.notify = handle_surface_commit;
wl_signal_add(&xsurface->surface->events.commit,
&roots_surface->surface_commit);
wl_list_insert(&desktop->views, &view->link);
}
static void handle_unmap_notify(struct wl_listener *listener, void *data) {
struct roots_xwayland_surface *roots_surface =
wl_container_of(listener, roots_surface, unmap_notify);
roots_surface->view->wlr_surface = NULL;
struct roots_view *view = roots_surface->view;
wl_list_remove(&roots_surface->surface_commit.link);
wl_list_remove(&roots_surface->view->link);
view_damage_whole(view);
struct roots_view_child *child, *tmp;
wl_list_for_each_safe(child, tmp, &view->children, link) {
child->destroy(child);
}
if (view->fullscreen_output != NULL) {
output_damage_whole(view->fullscreen_output);
view->fullscreen_output->fullscreen_view = NULL;
view->fullscreen_output = NULL;
}
view->wlr_surface = NULL;
view->width = view->height = 0;
wl_list_remove(&view->link);
}
void handle_xwayland_surface(struct wl_listener *listener, void *data) {
@ -296,6 +325,8 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
view->type = ROOTS_XWAYLAND_VIEW;
view->x = (double)surface->x;
view->y = (double)surface->y;
view->width = surface->surface->current->width;
view->height = surface->surface->current->height;
view->xwayland_surface = surface;
view->roots_xwayland_surface = roots_surface;

74
types/wlr_box.c
View file

@ -67,47 +67,79 @@ bool wlr_box_contains_point(const struct wlr_box *box, double x, double y) {
}
void wlr_box_transform(const struct wlr_box *box,
enum wl_output_transform transform, struct wlr_box *dest) {
enum wl_output_transform transform, int width, int height,
struct wlr_box *dest) {
struct wlr_box src = *box;
if (transform % 2 == 0) {
dest->width = box->width;
dest->height = box->height;
dest->width = src.width;
dest->height = src.height;
} else {
dest->width = box->height;
dest->height = box->width;
dest->width = src.height;
dest->height = src.width;
}
switch (transform) {
case WL_OUTPUT_TRANSFORM_NORMAL:
dest->x = box->x;
dest->y = box->y;
dest->x = src.x;
dest->y = src.y;
break;
case WL_OUTPUT_TRANSFORM_90:
dest->x = box->y;
dest->y = box->width - box->x;
dest->x = src.y;
dest->y = width - src.x - src.width;
break;
case WL_OUTPUT_TRANSFORM_180:
dest->x = box->width - box->x;
dest->y = box->height - box->y;
dest->x = width - src.x - src.width;
dest->y = height - src.y - src.height;
break;
case WL_OUTPUT_TRANSFORM_270:
dest->x = box->height - box->y;
dest->y = box->x;
dest->x = height - src.y - src.height;
dest->y = src.x;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
dest->x = box->width - box->x;
dest->y = box->y;
dest->x = width - src.x - src.width;
dest->y = src.y;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
dest->x = box->height - box->y;
dest->y = box->width - box->x;
dest->x = height - src.y - src.height;
dest->y = width - src.x - src.width;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
dest->x = box->x;
dest->y = box->height - box->y;
dest->x = src.x;
dest->y = height - src.y - src.height;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
dest->x = box->y;
dest->y = box->x;
dest->x = src.y;
dest->y = src.x;
break;
}
}
void wlr_box_rotated_bounds(const struct wlr_box *box, float rotation,
struct wlr_box *dest) {
if (rotation == 0) {
*dest = *box;
return;
}
double ox = box->x + (double)box->width/2;
double oy = box->y + (double)box->height/2;
double c = fabs(cos(rotation));
double s = fabs(sin(rotation));
double x1 = ox + (box->x - ox) * c + (box->y - oy) * s;
double x2 = ox +
(box->x + box->width - ox) * c +
(box->y + box->height - oy) * s;
double y1 = oy + (box->x - ox) * s + (box->y - oy) * c;
double y2 = oy +
(box->x + box->width - ox) * s +
(box->y + box->height - oy) * c;
dest->x = floor(fmin(x1, x2));
dest->width = ceil(fmax(x1, x2) - fmin(x1, x2));
dest->y = floor(fmin(y1, y2));
dest->height = ceil(fmax(y1, y2) - fmin(y1, y2));
}

4
types/wlr_compositor.c
View file

@ -35,7 +35,7 @@ static void wl_compositor_create_surface(struct wl_client *client,
wl_list_insert(&compositor->surfaces,
wl_resource_get_link(surface_resource));
wl_signal_emit(&compositor->events.create_surface, surface);
wl_signal_emit(&compositor->events.new_surface, surface);
}
static void wl_compositor_create_region(struct wl_client *client,
@ -185,7 +185,7 @@ struct wlr_compositor *wlr_compositor_create(struct wl_display *display,
wl_list_init(&compositor->wl_resources);
wl_list_init(&compositor->surfaces);
wl_signal_init(&compositor->events.create_surface);
wl_signal_init(&compositor->events.new_surface);
compositor->display_destroy.notify = handle_display_destroy;
wl_display_add_destroy_listener(display, &compositor->display_destroy);

6
types/wlr_data_device.c
View file

@ -457,6 +457,7 @@ static void wlr_drag_end(struct wlr_drag *drag) {
if (drag->icon) {
drag->icon->mapped = false;
wl_list_remove(&drag->icon_destroy.link);
wl_signal_emit(&drag->icon->events.map, drag->icon);
}
free(drag);
@ -676,8 +677,8 @@ static struct wlr_drag_icon *wlr_drag_icon_create(
icon->is_pointer = is_pointer;
icon->touch_id = touch_id;
icon->mapped = true;
wl_list_insert(&client->seat->drag_icons, &icon->link);
wl_signal_init(&icon->events.map);
wl_signal_init(&icon->events.destroy);
wl_signal_add(&icon->surface->events.destroy, &icon->surface_destroy);
@ -689,6 +690,9 @@ static struct wlr_drag_icon *wlr_drag_icon_create(
wl_signal_add(&client->events.destroy, &icon->seat_client_destroy);
icon->seat_client_destroy.notify = handle_drag_icon_seat_client_destroy;
wl_list_insert(&client->seat->drag_icons, &icon->link);
wl_signal_emit(&client->seat->events.new_drag_icon, icon);
return icon;
}

348
types/wlr_output.c
View file

@ -10,10 +10,9 @@
#include <wlr/types/wlr_surface.h>
#include <wlr/interfaces/wlr_output.h>
#include <wlr/util/log.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/util/region.h>
static void wl_output_send_to_resource(struct wl_resource *resource) {
assert(resource);
@ -183,11 +182,6 @@ void wlr_output_update_mode(struct wlr_output *output,
void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width,
int32_t height, int32_t refresh) {
if (output->width == width && output->height == height &&
output->refresh == refresh) {
return;
}
output->width = width;
output->height = height;
wlr_output_update_matrix(output);
@ -266,15 +260,19 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
wl_list_init(&output->cursors);
wl_list_init(&output->wl_resources);
wl_signal_init(&output->events.frame);
wl_signal_init(&output->events.needs_swap);
wl_signal_init(&output->events.swap_buffers);
wl_signal_init(&output->events.enable);
wl_signal_init(&output->events.mode);
wl_signal_init(&output->events.scale);
wl_signal_init(&output->events.transform);
wl_signal_init(&output->events.destroy);
pixman_region32_init(&output->damage);
output->display_destroy.notify = handle_display_destroy;
wl_display_add_destroy_listener(display, &output->display_destroy);
output->frame_pending = true;
}
void wlr_output_destroy(struct wlr_output *output) {
@ -286,6 +284,7 @@ void wlr_output_destroy(struct wlr_output *output) {
wlr_output_destroy_global(output);
wlr_output_set_fullscreen_surface(output, NULL);
wl_signal_emit(&output->backend->events.output_remove, output);
wl_signal_emit(&output->events.destroy, output);
struct wlr_output_mode *mode, *tmp_mode;
@ -299,6 +298,8 @@ void wlr_output_destroy(struct wlr_output *output) {
wlr_output_cursor_destroy(cursor);
}
pixman_region32_fini(&output->damage);
if (output->impl && output->impl->destroy) {
output->impl->destroy(output);
} else {
@ -306,55 +307,93 @@ void wlr_output_destroy(struct wlr_output *output) {
}
}
void wlr_output_effective_resolution(struct wlr_output *output,
void wlr_output_transformed_resolution(struct wlr_output *output,
int *width, int *height) {
if (output->transform % 2 == 1) {
*width = output->height;
*height = output->width;
} else {
if (output->transform % 2 == 0) {
*width = output->width;
*height = output->height;
} else {
*width = output->height;
*height = output->width;
}
}
void wlr_output_effective_resolution(struct wlr_output *output,
int *width, int *height) {
wlr_output_transformed_resolution(output, width, height);
*width /= output->scale;
*height /= output->scale;
}
void wlr_output_make_current(struct wlr_output *output) {
output->impl->make_current(output);
bool wlr_output_make_current(struct wlr_output *output, int *buffer_age) {
return output->impl->make_current(output, buffer_age);
}
static void output_fullscreen_surface_render(struct wlr_output *output,
struct wlr_surface *surface, const struct timespec *when) {
static void output_scissor(struct wlr_output *output, pixman_box32_t *rect) {
struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend);
assert(renderer);
struct wlr_box box = {
.x = rect->x1,
.y = rect->y1,
.width = rect->x2 - rect->x1,
.height = rect->y2 - rect->y1,
};
int ow, oh;
wlr_output_transformed_resolution(output, &ow, &oh);
// Scissor is in renderer coordinates, ie. upside down
enum wl_output_transform transform = wlr_output_transform_compose(
wlr_output_transform_invert(output->transform),
WL_OUTPUT_TRANSFORM_FLIPPED_180);
wlr_box_transform(&box, transform, ow, oh, &box);
wlr_renderer_scissor(renderer, &box);
}
static void output_fullscreen_surface_get_box(struct wlr_output *output,
struct wlr_surface *surface, struct wlr_box *box) {
int width, height;
wlr_output_effective_resolution(output, &width, &height);
int x = (width - surface->current->width) / 2;
int y = (height - surface->current->height) / 2;
int render_x = x * output->scale;
int render_y = y * output->scale;
int render_width = surface->current->width * output->scale;
int render_height = surface->current->height * output->scale;
box->x = x * output->scale;
box->y = y * output->scale;
box->width = surface->current->width * output->scale;
box->height = surface->current->height * output->scale;
}
glViewport(0, 0, output->width, output->height);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
static void output_fullscreen_surface_render(struct wlr_output *output,
struct wlr_surface *surface, const struct timespec *when,
pixman_region32_t *damage) {
struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend);
assert(renderer);
if (!wlr_surface_has_buffer(surface)) {
wlr_renderer_clear(renderer, &(float[]){0, 0, 0, 0});
return;
}
float translate[16];
wlr_matrix_translate(&translate, render_x, render_y, 0);
float scale[16];
wlr_matrix_scale(&scale, render_width, render_height, 1);
struct wlr_box box;
output_fullscreen_surface_get_box(output, surface, &box);
float matrix[16];
wlr_matrix_mul(&translate, &scale, &matrix);
wlr_matrix_mul(&output->transform_matrix, &matrix, &matrix);
enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(&matrix, &box, transform, 0,
&output->transform_matrix);
wlr_render_with_matrix(surface->renderer, surface->texture, &matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects);
for (int i = 0; i < nrects; ++i) {
output_scissor(output, &rects[i]);
wlr_renderer_clear(renderer, &(float[]){0, 0, 0, 0});
wlr_render_with_matrix(surface->renderer, surface->texture, &matrix);
}
wlr_renderer_scissor(renderer, NULL);
wlr_surface_send_frame_done(surface, when);
}
@ -376,64 +415,133 @@ static void output_cursor_get_box(struct wlr_output_cursor *cursor,
}
static void output_cursor_render(struct wlr_output_cursor *cursor,
const struct timespec *when) {
const struct timespec *when, pixman_region32_t *damage) {
struct wlr_renderer *renderer =
wlr_backend_get_renderer(cursor->output->backend);
assert(renderer);
struct wlr_texture *texture = cursor->texture;
struct wlr_renderer *renderer = cursor->renderer;
if (cursor->surface != NULL) {
texture = cursor->surface->texture;
renderer = cursor->surface->renderer;
}
if (texture == NULL || renderer == NULL) {
if (texture == NULL) {
return;
}
glViewport(0, 0, cursor->output->width, cursor->output->height);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
struct wlr_box box;
output_cursor_get_box(cursor, &box);
struct wlr_box cursor_box;
output_cursor_get_box(cursor, &cursor_box);
float translate[16];
wlr_matrix_translate(&translate, cursor_box.x, cursor_box.y, 0);
float scale[16];
wlr_matrix_scale(&scale, cursor_box.width, cursor_box.height, 1);
pixman_region32_t surface_damage;
pixman_region32_init(&surface_damage);
pixman_region32_union_rect(&surface_damage, &surface_damage, box.x, box.y,
box.width, box.height);
pixman_region32_intersect(&surface_damage, &surface_damage, damage);
if (!pixman_region32_not_empty(&surface_damage)) {
goto surface_damage_finish;
}
float matrix[16];
wlr_matrix_mul(&translate, &scale, &matrix);
wlr_matrix_mul(&cursor->output->transform_matrix, &matrix, &matrix);
wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
&cursor->output->transform_matrix);
wlr_render_with_matrix(renderer, texture, &matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects);
for (int i = 0; i < nrects; ++i) {
output_scissor(cursor->output, &rects[i]);
wlr_render_with_matrix(renderer, texture, &matrix);
}
wlr_renderer_scissor(renderer, NULL);
if (cursor->surface != NULL) {
wlr_surface_send_frame_done(cursor->surface, when);
}
surface_damage_finish:
pixman_region32_fini(&surface_damage);
}
void wlr_output_swap_buffers(struct wlr_output *output) {
wl_signal_emit(&output->events.swap_buffers, &output);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
if (output->fullscreen_surface != NULL) {
output_fullscreen_surface_render(output, output->fullscreen_surface,
&now);
bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when,
pixman_region32_t *damage) {
if (output->frame_pending) {
wlr_log(L_ERROR, "Tried to swap buffers when a frame is pending");
return false;
}
if (output->idle_frame != NULL) {
wl_event_source_remove(output->idle_frame);
output->idle_frame = NULL;
}
struct wlr_output_cursor *cursor;
wl_list_for_each(cursor, &output->cursors, link) {
if (!cursor->enabled || !cursor->visible ||
output->hardware_cursor == cursor) {
continue;
wl_signal_emit(&output->events.swap_buffers, damage);
int width, height;
wlr_output_transformed_resolution(output, &width, &height);
pixman_region32_t render_damage;
pixman_region32_init(&render_damage);
pixman_region32_union_rect(&render_damage, &render_damage, 0, 0,
width, height);
if (damage != NULL) {
// Damage tracking supported
pixman_region32_intersect(&render_damage, &render_damage, damage);
}
if (when == NULL) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
when = &now;
}
if (pixman_region32_not_empty(&render_damage)) {
if (output->fullscreen_surface != NULL) {
output_fullscreen_surface_render(output, output->fullscreen_surface,
when, &render_damage);
}
struct wlr_output_cursor *cursor;
wl_list_for_each(cursor, &output->cursors, link) {
if (!cursor->enabled || !cursor->visible ||
output->hardware_cursor == cursor) {
continue;
}
output_cursor_render(cursor, when, &render_damage);
}
output_cursor_render(cursor, &now);
}
output->impl->swap_buffers(output);
// TODO: provide `damage` (not `render_damage`) to backend
if (!output->impl->swap_buffers(output)) {
return false;
}
output->frame_pending = true;
output->needs_swap = false;
pixman_region32_clear(&output->damage);
pixman_region32_fini(&render_damage);
return true;
}
void wlr_output_send_frame(struct wlr_output *output) {
output->frame_pending = false;
wl_signal_emit(&output->events.frame, output);
}
static void schedule_frame_handle_idle_timer(void *data) {
struct wlr_output *output = data;
output->idle_frame = NULL;
if (!output->frame_pending) {
wlr_output_send_frame(output);
}
}
void wlr_output_schedule_frame(struct wlr_output *output) {
if (output->frame_pending || output->idle_frame != NULL) {
return;
}
// TODO: ask the backend to send a frame event when appropriate instead
struct wl_event_loop *ev = wl_display_get_event_loop(output->display);
output->idle_frame =
wl_event_loop_add_idle(ev, schedule_frame_handle_idle_timer, output);
}
void wlr_output_set_gamma(struct wlr_output *output,
@ -450,12 +558,26 @@ uint32_t wlr_output_get_gamma_size(struct wlr_output *output) {
return output->impl->get_gamma_size(output);
}
void wlr_output_update_needs_swap(struct wlr_output *output) {
output->needs_swap = true;
wl_signal_emit(&output->events.needs_swap, output);
}
static void output_damage_whole(struct wlr_output *output) {
int width, height;
wlr_output_transformed_resolution(output, &width, &height);
pixman_region32_union_rect(&output->damage, &output->damage, 0, 0,
width, height);
wlr_output_update_needs_swap(output);
}
static void output_fullscreen_surface_reset(struct wlr_output *output) {
if (output->fullscreen_surface != NULL) {
wl_list_remove(&output->fullscreen_surface_commit.link);
wl_list_remove(&output->fullscreen_surface_destroy.link);
output->fullscreen_surface = NULL;
output->needs_swap = true;
output_damage_whole(output);
}
}
@ -463,7 +585,28 @@ static void output_fullscreen_surface_handle_commit(
struct wl_listener *listener, void *data) {
struct wlr_output *output = wl_container_of(listener, output,
fullscreen_surface_commit);
output->needs_swap = true;
struct wlr_surface *surface = output->fullscreen_surface;
if (output->fullscreen_width != surface->current->width ||
output->fullscreen_height != surface->current->height) {
output->fullscreen_width = surface->current->width;
output->fullscreen_height = surface->current->height;
output_damage_whole(output);
return;
}
struct wlr_box box;
output_fullscreen_surface_get_box(output, surface, &box);
pixman_region32_t damage;
pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->surface_damage);
wlr_region_scale(&damage, &damage, output->scale);
pixman_region32_translate(&damage, box.x, box.y);
pixman_region32_union(&output->damage, &output->damage, &damage);
pixman_region32_fini(&damage);
wlr_output_update_needs_swap(output);
}
static void output_fullscreen_surface_handle_destroy(
@ -484,7 +627,7 @@ void wlr_output_set_fullscreen_surface(struct wlr_output *output,
output_fullscreen_surface_reset(output);
output->fullscreen_surface = surface;
output->needs_swap = true;
output_damage_whole(output);
if (surface == NULL) {
return;
@ -500,9 +643,17 @@ void wlr_output_set_fullscreen_surface(struct wlr_output *output,
}
static void output_cursor_damage_whole(struct wlr_output_cursor *cursor) {
struct wlr_box box;
output_cursor_get_box(cursor, &box);
pixman_region32_union_rect(&cursor->output->damage, &cursor->output->damage,
box.x, box.y, box.width, box.height);
wlr_output_update_needs_swap(cursor->output);
}
static void output_cursor_reset(struct wlr_output_cursor *cursor) {
if (cursor->output->hardware_cursor != cursor) {
cursor->output->needs_swap = true;
output_cursor_damage_whole(cursor);
}
if (cursor->surface != NULL) {
wl_list_remove(&cursor->surface_commit.link);
@ -514,6 +665,10 @@ static void output_cursor_reset(struct wlr_output_cursor *cursor) {
bool wlr_output_cursor_set_image(struct wlr_output_cursor *cursor,
const uint8_t *pixels, int32_t stride, uint32_t width, uint32_t height,
int32_t hotspot_x, int32_t hotspot_y) {
struct wlr_renderer *renderer =
wlr_backend_get_renderer(cursor->output->backend);
assert(renderer);
output_cursor_reset(cursor);
cursor->width = width;
@ -536,22 +691,15 @@ bool wlr_output_cursor_set_image(struct wlr_output_cursor *cursor,
}
wlr_log(L_DEBUG, "Falling back to software cursor");
cursor->output->needs_swap = true;
output_cursor_damage_whole(cursor);
cursor->enabled = pixels != NULL;
if (!cursor->enabled) {
return true;
}
if (cursor->renderer == NULL) {
cursor->renderer = wlr_gles2_renderer_create(cursor->output->backend);
if (cursor->renderer == NULL) {
return false;
}
}
if (cursor->texture == NULL) {
cursor->texture = wlr_render_texture_create(cursor->renderer);
cursor->texture = wlr_render_texture_create(renderer);
if (cursor->texture == NULL) {
return false;
}
@ -564,10 +712,8 @@ bool wlr_output_cursor_set_image(struct wlr_output_cursor *cursor,
static void output_cursor_update_visible(struct wlr_output_cursor *cursor) {
struct wlr_box output_box;
output_box.x = output_box.y = 0;
wlr_output_effective_resolution(cursor->output, &output_box.width,
wlr_output_transformed_resolution(cursor->output, &output_box.width,
&output_box.height);
output_box.width *= cursor->output->scale;
output_box.height *= cursor->output->scale;
struct wlr_box cursor_box;
output_cursor_get_box(cursor, &cursor_box);
@ -589,13 +735,17 @@ static void output_cursor_update_visible(struct wlr_output_cursor *cursor) {
}
static void output_cursor_commit(struct wlr_output_cursor *cursor) {
if (cursor->output->hardware_cursor != cursor) {
output_cursor_damage_whole(cursor);
}
// Some clients commit a cursor surface with a NULL buffer to hide it.
cursor->enabled = wlr_surface_has_buffer(cursor->surface);
cursor->width = cursor->surface->current->width * cursor->output->scale;
cursor->height = cursor->surface->current->height * cursor->output->scale;
if (cursor->output->hardware_cursor != cursor) {
cursor->output->needs_swap = true;
output_cursor_damage_whole(cursor);
} else {
// TODO: upload pixels
@ -625,14 +775,23 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor,
return;
}
cursor->hotspot_x = hotspot_x * cursor->output->scale;
cursor->hotspot_y = hotspot_y * cursor->output->scale;
hotspot_x *= cursor->output->scale;
hotspot_y *= cursor->output->scale;
if (surface && surface == cursor->surface) {
// Only update the hotspot: surface hasn't changed
if (cursor->output->hardware_cursor != cursor) {
output_cursor_damage_whole(cursor);
}
cursor->hotspot_x = hotspot_x;
cursor->hotspot_y = hotspot_y;
if (cursor->output->hardware_cursor != cursor) {
output_cursor_damage_whole(cursor);
}
if (cursor->output->hardware_cursor == cursor &&
cursor->output->impl->set_cursor) {
// If the surface hasn't changed and it's an hardware cursor, only
// update the hotspot
cursor->output->impl->set_cursor(cursor->output, NULL, 0, 0, 0,
hotspot_x, hotspot_y, false);
}
@ -651,6 +810,8 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor,
}
cursor->surface = surface;
cursor->hotspot_x = hotspot_x;
cursor->hotspot_y = hotspot_y;
if (surface != NULL) {
wl_signal_add(&surface->events.commit, &cursor->surface_commit);
@ -670,6 +831,14 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor,
bool wlr_output_cursor_move(struct wlr_output_cursor *cursor,
double x, double y) {
if (cursor->x == x && cursor->y == y) {
return true;
}
if (cursor->output->hardware_cursor != cursor) {
output_cursor_damage_whole(cursor);
}
x *= cursor->output->scale;
y *= cursor->output->scale;
cursor->x = x;
@ -677,7 +846,7 @@ bool wlr_output_cursor_move(struct wlr_output_cursor *cursor,
output_cursor_update_visible(cursor);
if (cursor->output->hardware_cursor != cursor) {
cursor->output->needs_swap = true;
output_cursor_damage_whole(cursor);
return true;
}
@ -720,9 +889,6 @@ void wlr_output_cursor_destroy(struct wlr_output_cursor *cursor) {
if (cursor->texture != NULL) {
wlr_texture_destroy(cursor->texture);
}
if (cursor->renderer != NULL) {
wlr_renderer_destroy(cursor->renderer);
}
wl_list_remove(&cursor->link);
free(cursor);
}

6
types/wlr_screenshooter.c
View file

@ -41,8 +41,8 @@ static void output_handle_frame(struct wl_listener *listener, void *_data) {
int32_t width = wl_shm_buffer_get_width(shm_buffer);
int32_t height = wl_shm_buffer_get_height(shm_buffer);
int32_t stride = wl_shm_buffer_get_stride(shm_buffer);
void *data = wl_shm_buffer_get_data(shm_buffer);
wl_shm_buffer_begin_access(shm_buffer);
void *data = wl_shm_buffer_get_data(shm_buffer);
bool ok = wlr_renderer_read_pixels(renderer, format, stride, width, height,
0, 0, 0, 0, data);
wl_shm_buffer_end_access(shm_buffer);
@ -127,6 +127,10 @@ static void screenshooter_shoot(struct wl_client *client,
state->screenshot = screenshot;
state->frame_listener.notify = output_handle_frame;
wl_signal_add(&output->events.swap_buffers, &state->frame_listener);
// Schedule a buffer swap
output->needs_swap = true;
wlr_output_schedule_frame(output);
}
static struct orbital_screenshooter_interface screenshooter_impl = {

3
types/wlr_seat.c
View file

@ -454,7 +454,10 @@ struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) {
wl_list_init(&wlr_seat->clients);
wl_list_init(&wlr_seat->drag_icons);
wl_signal_init(&wlr_seat->events.new_drag_icon);
wl_signal_init(&wlr_seat->events.request_set_cursor);
wl_signal_init(&wlr_seat->events.selection);
wl_signal_init(&wlr_seat->events.primary_selection);

214
types/wlr_surface.c
View file

@ -2,6 +2,7 @@
#include <stdlib.h>
#include <wayland-server.h>
#include <wlr/util/log.h>
#include <wlr/util/region.h>
#include <wlr/render/interface.h>
#include <wlr/types/wlr_surface.h>
#include <wlr/render/egl.h>
@ -133,11 +134,14 @@ static void surface_set_input_region(struct wl_client *client,
}
}
static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surface_state *state) {
static bool wlr_surface_update_size(struct wlr_surface *surface,
struct wlr_surface_state *state) {
if (!state->buffer) {
pixman_region32_union_rect(&state->surface_damage,
&state->surface_damage, 0, 0, state->width, state->height);
state->height = 0;
state->width = 0;
return;
return true;
}
int scale = state->scale;
@ -146,16 +150,16 @@ static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surf
wlr_texture_get_buffer_size(surface->texture, state->buffer,
&state->buffer_width, &state->buffer_height);
int _width = state->buffer_width / scale;
int _height = state->buffer_height / scale;
int width = state->buffer_width / scale;
int height = state->buffer_height / scale;
if (transform == WL_OUTPUT_TRANSFORM_90 ||
transform == WL_OUTPUT_TRANSFORM_270 ||
transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
transform == WL_OUTPUT_TRANSFORM_FLIPPED_270) {
int tmp = _width;
_width = _height;
_height = tmp;
int tmp = width;
width = height;
height = tmp;
}
struct wlr_frame_callback *cb, *tmp;
@ -164,99 +168,34 @@ static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surf
}
wl_list_init(&state->frame_callback_list);
state->width = _width;
state->height = _height;
}
static void wlr_surface_to_buffer_region(int scale,
enum wl_output_transform transform, pixman_region32_t *surface_region,
pixman_region32_t *buffer_region,
int width, int height) {
pixman_box32_t *src_rects, *dest_rects;
int nrects, i;
src_rects = pixman_region32_rectangles(surface_region, &nrects);
dest_rects = malloc(nrects * sizeof(*dest_rects));
if (!dest_rects) {
return;
bool update_damage = false;
if (width != state->width || height != state->height) {
// Damage the whole surface on resize
// This isn't in the spec, but Weston does it and QT expects it
pixman_region32_union_rect(&state->surface_damage,
&state->surface_damage, 0, 0, state->width, state->height);
pixman_region32_union_rect(&state->surface_damage,
&state->surface_damage, 0, 0, width, height);
update_damage = true;
}
for (i = 0; i < nrects; i++) {
switch (transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
dest_rects[i].x1 = src_rects[i].x1;
dest_rects[i].y1 = src_rects[i].y1;
dest_rects[i].x2 = src_rects[i].x2;
dest_rects[i].y2 = src_rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_90:
dest_rects[i].x1 = height - src_rects[i].y2;
dest_rects[i].y1 = src_rects[i].x1;
dest_rects[i].x2 = height - src_rects[i].y1;
dest_rects[i].y2 = src_rects[i].x2;
break;
case WL_OUTPUT_TRANSFORM_180:
dest_rects[i].x1 = width - src_rects[i].x2;
dest_rects[i].y1 = height - src_rects[i].y2;
dest_rects[i].x2 = width - src_rects[i].x1;
dest_rects[i].y2 = height - src_rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_270:
dest_rects[i].x1 = src_rects[i].y1;
dest_rects[i].y1 = width - src_rects[i].x2;
dest_rects[i].x2 = src_rects[i].y2;
dest_rects[i].y2 = width - src_rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
dest_rects[i].x1 = width - src_rects[i].x2;
dest_rects[i].y1 = src_rects[i].y1;
dest_rects[i].x2 = width - src_rects[i].x1;
dest_rects[i].y2 = src_rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
dest_rects[i].x1 = height - src_rects[i].y2;
dest_rects[i].y1 = width - src_rects[i].x2;
dest_rects[i].x2 = height - src_rects[i].y1;
dest_rects[i].y2 = width - src_rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
dest_rects[i].x1 = src_rects[i].x1;
dest_rects[i].y1 = height - src_rects[i].y2;
dest_rects[i].x2 = src_rects[i].x2;
dest_rects[i].y2 = height - src_rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
dest_rects[i].x1 = src_rects[i].y1;
dest_rects[i].y1 = src_rects[i].x1;
dest_rects[i].x2 = src_rects[i].y2;
dest_rects[i].y2 = src_rects[i].x2;
break;
}
}
state->width = width;
state->height = height;
if (scale != 1) {
for (i = 0; i < nrects; i++) {
dest_rects[i].x1 *= scale;
dest_rects[i].x2 *= scale;
dest_rects[i].y1 *= scale;
dest_rects[i].y2 *= scale;
}
}
pixman_region32_fini(buffer_region);
pixman_region32_init_rects(buffer_region, dest_rects, nrects);
free(dest_rects);
return update_damage;
}
/**
* Append pending state to current state and clear pending state.
*/
static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surface_state *next,
struct wlr_surface_state *state) {
static void wlr_surface_move_state(struct wlr_surface *surface,
struct wlr_surface_state *next, struct wlr_surface_state *state) {
bool update_damage = false;
bool update_size = false;
int oldw = state->width;
int oldh = state->height;
if ((next->invalid & WLR_SURFACE_INVALID_SCALE)) {
state->scale = next->scale;
update_size = true;
@ -274,40 +213,50 @@ static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surfa
update_size = true;
}
if (update_size) {
wlr_surface_update_size(surface, state);
update_damage = wlr_surface_update_size(surface, state);
}
if ((next->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) {
pixman_region32_union(&state->surface_damage,
&state->surface_damage,
pixman_region32_intersect_rect(&next->surface_damage,
&next->surface_damage, 0, 0, state->width, state->height);
pixman_region32_union(&state->surface_damage, &state->surface_damage,
&next->surface_damage);
pixman_region32_intersect_rect(&state->surface_damage,
&state->surface_damage, 0, 0, state->width,
state->height);
pixman_region32_clear(&next->surface_damage);
update_damage = true;
}
if ((next->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) {
pixman_region32_union(&state->buffer_damage,
&state->buffer_damage,
pixman_region32_intersect_rect(&next->buffer_damage,
&next->buffer_damage, 0, 0, state->buffer_width,
state->buffer_height);
pixman_region32_union(&state->buffer_damage, &state->buffer_damage,
&next->buffer_damage);
pixman_region32_clear(&next->buffer_damage);
update_damage = true;
}
if (update_damage) {
pixman_region32_t buffer_damage;
pixman_region32_t buffer_damage, surface_damage;
pixman_region32_init(&buffer_damage);
wlr_surface_to_buffer_region(state->scale, state->transform,
&state->surface_damage, &buffer_damage, state->width,
state->height);
pixman_region32_union(&state->buffer_damage,
&state->buffer_damage, &buffer_damage);
pixman_region32_fini(&buffer_damage);
pixman_region32_init(&surface_damage);
pixman_region32_intersect_rect(&state->buffer_damage,
&state->buffer_damage, 0, 0,
// Surface to buffer damage
pixman_region32_copy(&buffer_damage, &state->surface_damage);
wlr_region_transform(&buffer_damage, &buffer_damage,
wlr_output_transform_invert(state->transform),
state->width, state->height);
wlr_region_scale(&buffer_damage, &buffer_damage, state->scale);
// Buffer to surface damage
pixman_region32_copy(&surface_damage, &state->buffer_damage);
wlr_region_transform(&surface_damage, &surface_damage, state->transform,
state->buffer_width, state->buffer_height);
wlr_region_scale(&surface_damage, &surface_damage, 1.0f/state->scale);
pixman_region32_union(&state->buffer_damage, &state->buffer_damage,
&buffer_damage);
pixman_region32_union(&state->surface_damage, &state->surface_damage,
&surface_damage);
pixman_region32_fini(&buffer_damage);
pixman_region32_fini(&surface_damage);
}
if ((next->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
// TODO: process buffer
@ -318,13 +267,25 @@ static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surfa
pixman_region32_copy(&state->input, &next->input);
}
if ((next->invalid & WLR_SURFACE_INVALID_SUBSURFACE_POSITION)) {
// Subsurface has moved
int dx = state->subsurface_position.x - next->subsurface_position.x;
int dy = state->subsurface_position.y - next->subsurface_position.y;
state->subsurface_position.x = next->subsurface_position.x;
state->subsurface_position.y = next->subsurface_position.y;
next->subsurface_position.x = 0;
next->subsurface_position.y = 0;
if (dx != 0 || dy != 0) {
pixman_region32_union_rect(&state->surface_damage,
&state->surface_damage, dx, dy, oldw, oldh);
pixman_region32_union_rect(&state->surface_damage,
&state->surface_damage, 0, 0, state->width, state->height);
}
}
if ((next->invalid & WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST)) {
wl_list_insert_list(&state->frame_callback_list, &next->frame_callback_list);
wl_list_insert_list(&state->frame_callback_list,
&next->frame_callback_list);
wl_list_init(&next->frame_callback_list);
}
@ -351,7 +312,7 @@ static void wlr_surface_damage_subsurfaces(struct wlr_subsurface *subsurface) {
}
}
static void wlr_surface_flush_damage(struct wlr_surface *surface,
static void wlr_surface_apply_damage(struct wlr_surface *surface,
bool reupload_buffer) {
if (!surface->current->buffer) {
return;
@ -372,10 +333,12 @@ static void wlr_surface_flush_damage(struct wlr_surface *surface,
if (reupload_buffer) {
wlr_texture_upload_shm(surface->texture, format, buffer);
} else {
pixman_region32_t damage = surface->current->buffer_damage;
if (!pixman_region32_not_empty(&damage)) {
goto release;
}
pixman_region32_t damage;
pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current->buffer_damage);
pixman_region32_intersect_rect(&damage, &damage, 0, 0,
surface->current->buffer_width, surface->current->buffer_height);
int n;
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &n);
for (int i = 0; i < n; ++i) {
@ -388,12 +351,11 @@ static void wlr_surface_flush_damage(struct wlr_surface *surface,
break;
}
}
pixman_region32_fini(&damage);
}
release:
pixman_region32_clear(&surface->current->surface_damage);
pixman_region32_clear(&surface->current->buffer_damage);
wlr_surface_state_release_buffer(surface->current);
}
@ -413,12 +375,12 @@ static void wlr_surface_commit_pending(struct wlr_surface *surface) {
bool reupload_buffer = oldw != surface->current->buffer_width ||
oldh != surface->current->buffer_height;
wlr_surface_flush_damage(surface, reupload_buffer);
wlr_surface_apply_damage(surface, reupload_buffer);
// commit subsurface order
struct wlr_subsurface *subsurface;
wl_list_for_each_reverse(subsurface, &surface->subsurface_pending_list,
parent_pending_link) {
parent_pending_link) {
wl_list_remove(&subsurface->parent_link);
wl_list_insert(&surface->subsurface_list, &subsurface->parent_link);
@ -434,6 +396,9 @@ static void wlr_surface_commit_pending(struct wlr_surface *surface) {
// TODO: add the invalid bitfield to this callback
wl_signal_emit(&surface->events.commit, surface);
pixman_region32_clear(&surface->current->surface_damage);
pixman_region32_clear(&surface->current->buffer_damage);
}
static bool wlr_subsurface_is_synchronized(struct wlr_subsurface *subsurface) {
@ -459,7 +424,6 @@ static void wlr_subsurface_parent_commit(struct wlr_subsurface *subsurface,
bool synchronized) {
struct wlr_surface *surface = subsurface->surface;
if (synchronized || subsurface->synchronized) {
if (subsurface->has_cache) {
wlr_surface_move_state(surface, subsurface->cached, surface->pending);
wlr_surface_commit_pending(surface);
@ -595,6 +559,8 @@ static void wlr_surface_state_destroy(struct wlr_surface_state *state) {
}
void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) {
wl_signal_emit(&subsurface->events.destroy, subsurface);
wlr_surface_state_destroy(subsurface->cached);
if (subsurface->parent) {
@ -642,6 +608,7 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
wl_signal_init(&surface->events.commit);
wl_signal_init(&surface->events.destroy);
wl_signal_init(&surface->events.new_subsurface);
wl_list_init(&surface->subsurface_list);
wl_list_init(&surface->subsurface_pending_list);
wl_resource_set_implementation(res, &surface_interface,
@ -732,10 +699,6 @@ static void subsurface_place_above(struct wl_client *client,
struct wl_resource *resource, struct wl_resource *sibling_resource) {
struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
if (!subsurface) {
return;
}
struct wlr_surface *sibling_surface =
wl_resource_get_user_data(sibling_resource);
struct wlr_subsurface *sibling =
@ -841,6 +804,7 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
}
subsurface->synchronized = true;
subsurface->surface = surface;
wl_signal_init(&subsurface->events.destroy);
// link parent
subsurface->parent = parent;
@ -866,6 +830,8 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
subsurface_resource_destroy);
surface->subsurface = subsurface;
wl_signal_emit(&parent->events.new_subsurface, subsurface);
}

2
types/wlr_wl_shell.c
View file

@ -221,6 +221,7 @@ static void shell_surface_popup_set_parent(struct wlr_wl_shell_surface *surface,
if (parent) {
wl_list_remove(&surface->popup_link);
wl_list_insert(&parent->popups, &surface->popup_link);
wl_signal_emit(&parent->events.new_popup, surface);
}
}
@ -519,6 +520,7 @@ static void shell_protocol_get_shell_surface(struct wl_client *client,
wl_signal_init(&wl_surface->events.destroy);
wl_signal_init(&wl_surface->events.ping_timeout);
wl_signal_init(&wl_surface->events.new_popup);
wl_signal_init(&wl_surface->events.request_move);
wl_signal_init(&wl_surface->events.request_resize);
wl_signal_init(&wl_surface->events.request_fullscreen);

22
types/wlr_xdg_shell_v6.c
View file

@ -206,7 +206,7 @@ static void xdg_surface_destroy(struct wlr_xdg_surface_v6 *surface) {
}
}
wl_list_remove(&surface->popup_link);
wl_list_remove(&surface->popup_state->link);
free(surface->popup_state);
}
@ -505,12 +505,13 @@ static void xdg_surface_get_popup(struct wl_client *client,
surface->popup_state->parent = parent;
surface->popup_state->geometry =
xdg_positioner_get_geometry(positioner, surface, parent);
wl_list_insert(&surface->popup_state->parent->popups,
&surface->popup_link);
wl_list_insert(&parent->popups, &surface->popup_state->link);
wl_resource_set_implementation(surface->popup_state->resource,
&zxdg_popup_v6_implementation, surface,
xdg_popup_resource_destroy);
wl_signal_emit(&parent->events.new_popup, surface->popup_state);
}
@ -1187,6 +1188,7 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client,
wl_signal_init(&surface->events.request_show_window_menu);
wl_signal_init(&surface->events.destroy);
wl_signal_init(&surface->events.ping_timeout);
wl_signal_init(&surface->events.new_popup);
wl_signal_add(&surface->surface->events.destroy,
&surface->surface_destroy_listener);
@ -1404,14 +1406,16 @@ struct wlr_xdg_surface_v6 *wlr_xdg_surface_v6_popup_at(
// XXX: I think this is so complicated because we're mixing geometry
// coordinates with surface coordinates. Input handling should only deal
// with surface coordinates.
struct wlr_xdg_surface_v6 *popup;
wl_list_for_each(popup, &surface->popups, popup_link) {
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;
double _popup_sx =
surface->geometry->x + popup->popup_state->geometry.x;
surface->geometry->x + popup_state->geometry.x;
double _popup_sy =
surface->geometry->y + popup->popup_state->geometry.y;
int popup_width = popup->popup_state->geometry.width;
int popup_height = popup->popup_state->geometry.height;
surface->geometry->y + popup_state->geometry.y;
int popup_width = popup_state->geometry.width;
int popup_height = popup_state->geometry.height;
struct wlr_xdg_surface_v6 *_popup =
wlr_xdg_surface_v6_popup_at(popup,

2
util/meson.build
View file

@ -3,6 +3,8 @@ lib_wlr_util = static_library(
files(
'log.c',
'os-compatibility.c',
'region.c',
),
include_directories: wlr_inc,
dependencies: [wayland_server, pixman],
)

130
util/region.c Normal file
View file

@ -0,0 +1,130 @@
#include <stdlib.h>
#include <math.h>
#include <wlr/util/region.h>
void wlr_region_scale(pixman_region32_t *dst, pixman_region32_t *src,
float scale) {
if (scale == 1) {
pixman_region32_copy(dst, src);
return;
}
int nrects;
pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
if (dst_rects == NULL) {
return;
}
for (int i = 0; i < nrects; ++i) {
dst_rects[i].x1 = floor(src_rects[i].x1 * scale);
dst_rects[i].x2 = ceil(src_rects[i].x2 * scale);
dst_rects[i].y1 = floor(src_rects[i].y1 * scale);
dst_rects[i].y2 = ceil(src_rects[i].y2 * scale);
}
pixman_region32_fini(dst);
pixman_region32_init_rects(dst, dst_rects, nrects);
free(dst_rects);
}
void wlr_region_transform(pixman_region32_t *dst, pixman_region32_t *src,
enum wl_output_transform transform, int width, int height) {
if (transform == WL_OUTPUT_TRANSFORM_NORMAL) {
pixman_region32_copy(dst, src);
return;
}
int nrects;
pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
if (dst_rects == NULL) {
return;
}
for (int i = 0; i < nrects; ++i) {
switch (transform) {
case WL_OUTPUT_TRANSFORM_NORMAL:
dst_rects[i].x1 = src_rects[i].x1;
dst_rects[i].y1 = src_rects[i].y1;
dst_rects[i].x2 = src_rects[i].x2;
dst_rects[i].y2 = src_rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_90:
dst_rects[i].x1 = src_rects[i].y1;
dst_rects[i].y1 = width - src_rects[i].x2;
dst_rects[i].x2 = src_rects[i].y2;
dst_rects[i].y2 = width - src_rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_180:
dst_rects[i].x1 = width - src_rects[i].x2;
dst_rects[i].y1 = height - src_rects[i].y2;
dst_rects[i].x2 = width - src_rects[i].x1;
dst_rects[i].y2 = height - src_rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_270:
dst_rects[i].x1 = height - src_rects[i].y2;
dst_rects[i].y1 = src_rects[i].x1;
dst_rects[i].x2 = height - src_rects[i].y1;
dst_rects[i].y2 = src_rects[i].x2;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
dst_rects[i].x1 = width - src_rects[i].x2;
dst_rects[i].y1 = src_rects[i].y1;
dst_rects[i].x2 = width - src_rects[i].x1;
dst_rects[i].y2 = src_rects[i].y2;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
dst_rects[i].x1 = height - src_rects[i].y2;
dst_rects[i].y1 = width - src_rects[i].x2;
dst_rects[i].x2 = height - src_rects[i].y1;
dst_rects[i].y2 = width - src_rects[i].x1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
dst_rects[i].x1 = src_rects[i].x1;
dst_rects[i].y1 = height - src_rects[i].y2;
dst_rects[i].x2 = src_rects[i].x2;
dst_rects[i].y2 = height - src_rects[i].y1;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
dst_rects[i].x1 = src_rects[i].y1;
dst_rects[i].y1 = src_rects[i].x1;
dst_rects[i].x2 = src_rects[i].y2;
dst_rects[i].y2 = src_rects[i].x2;
break;
}
}
pixman_region32_fini(dst);
pixman_region32_init_rects(dst, dst_rects, nrects);
free(dst_rects);
}
void wlr_region_expand(pixman_region32_t *dst, pixman_region32_t *src,
int distance) {
if (distance == 0) {
pixman_region32_copy(dst, src);
return;
}
int nrects;
pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
if (dst_rects == NULL) {
return;
}
for (int i = 0; i < nrects; ++i) {
dst_rects[i].x1 = src_rects[i].x1 - distance;
dst_rects[i].x2 = src_rects[i].x2 + distance;
dst_rects[i].y1 = src_rects[i].y1 - distance;
dst_rects[i].y2 = src_rects[i].y2 + distance;
}
pixman_region32_fini(dst);
pixman_region32_init_rects(dst, dst_rects, nrects);
free(dst_rects);
}

1
xcursor/wlr_xcursor.c
View file

@ -24,7 +24,6 @@
*/
#define _XOPEN_SOURCE 500
#include <wlr/render.h>
#include <wlr/xcursor.h>
#include <wlr/util/log.h>
#include <stdio.h>

4
xwayland/xwm.c
View file

@ -315,7 +315,7 @@ static void read_surface_parent(struct wlr_xwm *xwm,
wl_list_init(&xsurface->parent_link);
}
wlr_log(L_DEBUG, "XCB_ATOM_WM_TRANSIENT_FOR: %p", xid);
wlr_log(L_DEBUG, "XCB_ATOM_WM_TRANSIENT_FOR: %p", xsurface->parent);
wl_signal_emit(&xsurface->events.set_parent, xsurface);
}
@ -1407,7 +1407,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
xwm_selection_init(xwm);
xwm->compositor_surface_create.notify = handle_compositor_surface_create;
wl_signal_add(&wlr_xwayland->compositor->events.create_surface,
wl_signal_add(&wlr_xwayland->compositor->events.new_surface,
&xwm->compositor_surface_create);
xwm_create_wm_window(xwm);