2017-06-20 18:27:05 +02:00
|
|
|
#include <assert.h>
|
2017-06-19 22:36:40 +02:00
|
|
|
#include <stdint.h>
|
2018-02-12 21:29:23 +01:00
|
|
|
#include <stdio.h>
|
2017-06-19 22:36:40 +02:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2017-08-14 18:19:42 +02:00
|
|
|
#include <sys/mman.h>
|
2018-02-12 21:29:23 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
2018-11-11 06:14:48 +01:00
|
|
|
|
2017-06-19 22:36:40 +02:00
|
|
|
#include <wayland-client.h>
|
2018-11-11 06:14:48 +01:00
|
|
|
|
2017-06-21 16:27:45 +02:00
|
|
|
#include <wlr/interfaces/wlr_output.h>
|
2018-03-20 23:10:42 +01:00
|
|
|
#include <wlr/render/wlr_renderer.h>
|
2018-05-01 22:38:04 +02:00
|
|
|
#include <wlr/types/wlr_matrix.h>
|
2017-06-21 18:10:07 +02:00
|
|
|
#include <wlr/util/log.h>
|
2018-11-11 06:14:48 +01:00
|
|
|
|
2017-06-19 22:36:40 +02:00
|
|
|
#include "backend/wayland.h"
|
2018-02-12 21:29:23 +01:00
|
|
|
#include "util/signal.h"
|
2019-09-24 14:33:15 +02:00
|
|
|
#include "linux-dmabuf-unstable-v1-client-protocol.h"
|
2019-11-16 21:05:46 +01:00
|
|
|
#include "presentation-time-client-protocol.h"
|
2019-05-06 18:06:31 +02:00
|
|
|
#include "xdg-decoration-unstable-v1-client-protocol.h"
|
2019-01-10 15:17:14 +01:00
|
|
|
#include "xdg-shell-client-protocol.h"
|
2017-06-19 22:36:40 +02:00
|
|
|
|
2018-09-17 22:10:34 +02:00
|
|
|
static struct wlr_wl_output *get_wl_output_from_output(
|
|
|
|
struct wlr_output *wlr_output) {
|
|
|
|
assert(wlr_output_is_wl(wlr_output));
|
|
|
|
return (struct wlr_wl_output *)wlr_output;
|
|
|
|
}
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-01-26 22:39:23 +01:00
|
|
|
static void surface_frame_callback(void *data, struct wl_callback *cb,
|
|
|
|
uint32_t time) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output = data;
|
2018-01-26 22:39:23 +01:00
|
|
|
assert(output);
|
2017-06-26 17:34:22 +02:00
|
|
|
wl_callback_destroy(cb);
|
2018-01-18 13:06:57 +01:00
|
|
|
output->frame_callback = NULL;
|
2018-01-30 14:45:02 +01:00
|
|
|
|
|
|
|
wlr_output_send_frame(&output->wlr_output);
|
2017-06-26 17:34:22 +02:00
|
|
|
}
|
|
|
|
|
2019-11-16 21:05:46 +01:00
|
|
|
static const struct wl_callback_listener frame_listener = {
|
2017-06-26 17:34:22 +02:00
|
|
|
.done = surface_frame_callback
|
|
|
|
};
|
|
|
|
|
2019-11-16 21:05:46 +01:00
|
|
|
static void presentation_feedback_destroy(
|
|
|
|
struct wlr_wl_presentation_feedback *feedback) {
|
|
|
|
wl_list_remove(&feedback->link);
|
|
|
|
wp_presentation_feedback_destroy(feedback->feedback);
|
|
|
|
free(feedback);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void presentation_feedback_handle_sync_output(void *data,
|
|
|
|
struct wp_presentation_feedback *feedback, struct wl_output *output) {
|
|
|
|
// This space is intentionally left blank
|
|
|
|
}
|
|
|
|
|
|
|
|
static void presentation_feedback_handle_presented(void *data,
|
|
|
|
struct wp_presentation_feedback *wp_feedback, uint32_t tv_sec_hi,
|
|
|
|
uint32_t tv_sec_lo, uint32_t tv_nsec, uint32_t refresh_ns,
|
|
|
|
uint32_t seq_hi, uint32_t seq_lo, uint32_t flags) {
|
|
|
|
struct wlr_wl_presentation_feedback *feedback = data;
|
|
|
|
|
|
|
|
struct timespec t = {
|
|
|
|
.tv_sec = ((uint64_t)tv_sec_hi << 32) | tv_sec_lo,
|
|
|
|
.tv_nsec = tv_nsec,
|
|
|
|
};
|
|
|
|
struct wlr_output_event_present event = {
|
|
|
|
.commit_seq = feedback->commit_seq,
|
|
|
|
.when = &t,
|
|
|
|
.seq = ((uint64_t)seq_hi << 32) | seq_lo,
|
|
|
|
.refresh = refresh_ns,
|
|
|
|
.flags = flags,
|
|
|
|
};
|
|
|
|
wlr_output_send_present(&feedback->output->wlr_output, &event);
|
|
|
|
|
|
|
|
presentation_feedback_destroy(feedback);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void presentation_feedback_handle_discarded(void *data,
|
|
|
|
struct wp_presentation_feedback *wp_feedback) {
|
|
|
|
struct wlr_wl_presentation_feedback *feedback = data;
|
|
|
|
|
|
|
|
wlr_output_send_present(&feedback->output->wlr_output, NULL);
|
|
|
|
|
|
|
|
presentation_feedback_destroy(feedback);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct wp_presentation_feedback_listener
|
|
|
|
presentation_feedback_listener = {
|
|
|
|
.sync_output = presentation_feedback_handle_sync_output,
|
|
|
|
.presented = presentation_feedback_handle_presented,
|
|
|
|
.discarded = presentation_feedback_handle_discarded,
|
|
|
|
};
|
|
|
|
|
2018-09-17 22:10:34 +02:00
|
|
|
static bool output_set_custom_mode(struct wlr_output *wlr_output,
|
2017-12-11 12:14:23 +01:00
|
|
|
int32_t width, int32_t height, int32_t refresh) {
|
2018-09-17 22:10:34 +02:00
|
|
|
struct wlr_wl_output *output = get_wl_output_from_output(wlr_output);
|
2019-01-22 20:27:23 +01:00
|
|
|
wlr_egl_swap_buffers(&output->backend->egl, output->egl_surface, NULL);
|
2017-12-11 12:14:23 +01:00
|
|
|
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
|
2017-12-17 18:02:55 +01:00
|
|
|
wlr_output_update_custom_mode(&output->wlr_output, width, height, 0);
|
2019-01-22 20:27:23 +01:00
|
|
|
|
2017-12-11 12:14:23 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-04-23 18:26:21 +02:00
|
|
|
static bool output_attach_render(struct wlr_output *wlr_output,
|
2018-01-21 00:06:35 +01:00
|
|
|
int *buffer_age) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output =
|
2018-09-17 22:10:34 +02:00
|
|
|
get_wl_output_from_output(wlr_output);
|
2018-01-21 00:06:35 +01:00
|
|
|
return wlr_egl_make_current(&output->backend->egl, output->egl_surface,
|
|
|
|
buffer_age);
|
2017-06-26 17:34:22 +02:00
|
|
|
}
|
2017-06-20 18:27:05 +02:00
|
|
|
|
2020-01-09 15:34:34 +01:00
|
|
|
static void destroy_wl_buffer(struct wlr_wl_buffer *buffer) {
|
|
|
|
if (buffer == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
wl_buffer_destroy(buffer->wl_buffer);
|
2020-02-28 13:25:05 +01:00
|
|
|
wlr_buffer_unlock(buffer->buffer);
|
2020-01-09 15:34:34 +01:00
|
|
|
free(buffer);
|
|
|
|
}
|
2019-09-24 14:33:15 +02:00
|
|
|
|
2020-01-09 15:34:34 +01:00
|
|
|
static void buffer_handle_release(void *data, struct wl_buffer *wl_buffer) {
|
|
|
|
struct wlr_wl_buffer *buffer = data;
|
|
|
|
destroy_wl_buffer(buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct wl_buffer_listener buffer_listener = {
|
|
|
|
.release = buffer_handle_release,
|
|
|
|
};
|
|
|
|
|
2020-04-02 14:12:26 +02:00
|
|
|
static bool test_buffer(struct wlr_wl_backend *wl,
|
2020-01-09 15:34:34 +01:00
|
|
|
struct wlr_buffer *wlr_buffer,
|
|
|
|
int required_width, int required_height) {
|
2019-09-24 14:33:15 +02:00
|
|
|
struct wlr_dmabuf_attributes attribs;
|
2020-01-09 15:34:34 +01:00
|
|
|
if (!wlr_buffer_get_dmabuf(wlr_buffer, &attribs)) {
|
2020-04-02 14:12:26 +02:00
|
|
|
return false;
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
|
|
|
|
2020-01-09 15:34:34 +01:00
|
|
|
if (attribs.width != required_width || attribs.height != required_height) {
|
2020-04-02 14:12:26 +02:00
|
|
|
return false;
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!wlr_drm_format_set_has(&wl->linux_dmabuf_v1_formats,
|
|
|
|
attribs.format, attribs.modifier)) {
|
2020-04-02 14:12:26 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct wlr_wl_buffer *create_wl_buffer(struct wlr_wl_backend *wl,
|
|
|
|
struct wlr_buffer *wlr_buffer,
|
|
|
|
int required_width, int required_height) {
|
|
|
|
if (!test_buffer(wl, wlr_buffer, required_width, required_height)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct wlr_dmabuf_attributes attribs;
|
|
|
|
if (!wlr_buffer_get_dmabuf(wlr_buffer, &attribs)) {
|
2020-01-09 15:34:34 +01:00
|
|
|
return NULL;
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t modifier_hi = attribs.modifier >> 32;
|
|
|
|
uint32_t modifier_lo = (uint32_t)attribs.modifier;
|
|
|
|
struct zwp_linux_buffer_params_v1 *params =
|
|
|
|
zwp_linux_dmabuf_v1_create_params(wl->zwp_linux_dmabuf_v1);
|
|
|
|
for (int i = 0; i < attribs.n_planes; i++) {
|
|
|
|
zwp_linux_buffer_params_v1_add(params, attribs.fd[i], i,
|
|
|
|
attribs.offset[i], attribs.stride[i], modifier_hi, modifier_lo);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t flags = 0;
|
|
|
|
if (attribs.flags & WLR_DMABUF_ATTRIBUTES_FLAGS_Y_INVERT) {
|
|
|
|
flags |= ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_Y_INVERT;
|
|
|
|
}
|
|
|
|
if (attribs.flags & WLR_DMABUF_ATTRIBUTES_FLAGS_INTERLACED) {
|
|
|
|
flags |= ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_INTERLACED;
|
|
|
|
}
|
|
|
|
if (attribs.flags & WLR_DMABUF_ATTRIBUTES_FLAGS_BOTTOM_FIRST) {
|
|
|
|
flags |= ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_BOTTOM_FIRST;
|
|
|
|
}
|
|
|
|
struct wl_buffer *wl_buffer = zwp_linux_buffer_params_v1_create_immed(
|
|
|
|
params, attribs.width, attribs.height, attribs.format, flags);
|
|
|
|
// TODO: handle create() errors
|
|
|
|
|
2020-01-09 15:34:34 +01:00
|
|
|
struct wlr_wl_buffer *buffer = calloc(1, sizeof(struct wlr_wl_buffer));
|
|
|
|
if (buffer == NULL) {
|
|
|
|
wl_buffer_destroy(wl_buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
buffer->wl_buffer = wl_buffer;
|
2020-02-28 13:25:05 +01:00
|
|
|
buffer->buffer = wlr_buffer_lock(wlr_buffer);
|
2019-09-24 14:33:15 +02:00
|
|
|
|
2020-01-09 15:34:34 +01:00
|
|
|
wl_buffer_add_listener(wl_buffer, &buffer_listener, buffer);
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2020-04-02 12:41:19 +02:00
|
|
|
static bool output_test(struct wlr_output *wlr_output) {
|
|
|
|
if (wlr_output->pending.committed & WLR_OUTPUT_STATE_ENABLED) {
|
|
|
|
wlr_log(WLR_DEBUG, "Cannot disable a Wayland output");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wlr_output->pending.committed & WLR_OUTPUT_STATE_MODE) {
|
|
|
|
assert(wlr_output->pending.mode_type == WLR_OUTPUT_STATE_MODE_CUSTOM);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-04-23 18:26:21 +02:00
|
|
|
static bool output_commit(struct wlr_output *wlr_output) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output =
|
2018-09-17 22:10:34 +02:00
|
|
|
get_wl_output_from_output(wlr_output);
|
2018-01-21 00:06:35 +01:00
|
|
|
|
2020-04-02 12:41:19 +02:00
|
|
|
if (!output_test(wlr_output)) {
|
2018-01-30 14:45:02 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
if (wlr_output->pending.committed & WLR_OUTPUT_STATE_MODE) {
|
|
|
|
if (!output_set_custom_mode(wlr_output,
|
|
|
|
wlr_output->pending.custom_mode.width,
|
|
|
|
wlr_output->pending.custom_mode.height,
|
|
|
|
wlr_output->pending.custom_mode.refresh)) {
|
|
|
|
return false;
|
|
|
|
}
|
2019-08-07 08:11:38 +02:00
|
|
|
}
|
2019-07-18 20:38:12 +02:00
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
if (wlr_output->pending.committed & WLR_OUTPUT_STATE_BUFFER) {
|
|
|
|
struct wp_presentation_feedback *wp_feedback = NULL;
|
|
|
|
if (output->backend->presentation != NULL) {
|
|
|
|
wp_feedback = wp_presentation_feedback(output->backend->presentation,
|
|
|
|
output->surface);
|
|
|
|
}
|
2019-11-16 21:05:46 +01:00
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
pixman_region32_t *damage = NULL;
|
|
|
|
if (wlr_output->pending.committed & WLR_OUTPUT_STATE_DAMAGE) {
|
|
|
|
damage = &wlr_output->pending.damage;
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
2019-08-16 18:41:56 +02:00
|
|
|
|
2020-01-02 20:39:41 +01:00
|
|
|
if (output->frame_callback != NULL) {
|
|
|
|
wlr_log(WLR_ERROR, "Skipping buffer swap");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
output->frame_callback = wl_surface_frame(output->surface);
|
|
|
|
wl_callback_add_listener(output->frame_callback, &frame_listener, output);
|
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
switch (wlr_output->pending.buffer_type) {
|
|
|
|
case WLR_OUTPUT_STATE_BUFFER_RENDER:
|
|
|
|
if (!wlr_egl_swap_buffers(&output->backend->egl,
|
|
|
|
output->egl_surface, damage)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
2020-04-02 14:12:26 +02:00
|
|
|
case WLR_OUTPUT_STATE_BUFFER_SCANOUT:;
|
|
|
|
struct wlr_wl_buffer *buffer = create_wl_buffer(output->backend,
|
|
|
|
wlr_output->pending.buffer, wlr_output->width, wlr_output->height);
|
|
|
|
if (buffer == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
wl_surface_attach(output->surface, buffer->wl_buffer, 0, 0);
|
2020-01-09 15:34:34 +01:00
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
if (damage == NULL) {
|
|
|
|
wl_surface_damage_buffer(output->surface,
|
|
|
|
0, 0, INT32_MAX, INT32_MAX);
|
|
|
|
} else {
|
|
|
|
int rects_len;
|
|
|
|
pixman_box32_t *rects =
|
|
|
|
pixman_region32_rectangles(damage, &rects_len);
|
|
|
|
for (int i = 0; i < rects_len; i++) {
|
|
|
|
pixman_box32_t *r = &rects[i];
|
|
|
|
wl_surface_damage_buffer(output->surface, r->x1, r->y1,
|
|
|
|
r->x2 - r->x1, r->y2 - r->y1);
|
|
|
|
}
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
2019-08-16 18:41:56 +02:00
|
|
|
wl_surface_commit(output->surface);
|
|
|
|
break;
|
2019-09-24 14:33:15 +02:00
|
|
|
}
|
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
if (wp_feedback != NULL) {
|
|
|
|
struct wlr_wl_presentation_feedback *feedback =
|
|
|
|
calloc(1, sizeof(*feedback));
|
|
|
|
if (feedback == NULL) {
|
|
|
|
wp_presentation_feedback_destroy(wp_feedback);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
feedback->output = output;
|
|
|
|
feedback->feedback = wp_feedback;
|
|
|
|
feedback->commit_seq = output->wlr_output.commit_seq + 1;
|
|
|
|
wl_list_insert(&output->presentation_feedbacks, &feedback->link);
|
2018-10-01 11:07:58 +02:00
|
|
|
|
2019-08-16 18:41:56 +02:00
|
|
|
wp_presentation_feedback_add_listener(wp_feedback,
|
|
|
|
&presentation_feedback_listener, feedback);
|
|
|
|
} else {
|
|
|
|
wlr_output_send_present(wlr_output, NULL);
|
2019-11-16 21:05:46 +01:00
|
|
|
}
|
|
|
|
}
|
2019-09-24 14:33:15 +02:00
|
|
|
|
2018-10-01 11:07:58 +02:00
|
|
|
return true;
|
2017-06-20 18:27:05 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 20:58:18 +02:00
|
|
|
static bool output_set_cursor(struct wlr_output *wlr_output,
|
|
|
|
struct wlr_texture *texture, int32_t scale,
|
2018-09-17 22:10:34 +02:00
|
|
|
enum wl_output_transform transform,
|
|
|
|
int32_t hotspot_x, int32_t hotspot_y, bool update_texture) {
|
|
|
|
struct wlr_wl_output *output = get_wl_output_from_output(wlr_output);
|
2017-08-14 18:19:42 +02:00
|
|
|
struct wlr_wl_backend *backend = output->backend;
|
2017-10-08 21:21:06 +02:00
|
|
|
|
2018-05-09 20:58:18 +02:00
|
|
|
struct wlr_box hotspot = { .x = hotspot_x, .y = hotspot_y };
|
2018-12-21 19:56:10 +01:00
|
|
|
wlr_box_transform(&hotspot, &hotspot,
|
2018-09-17 22:10:34 +02:00
|
|
|
wlr_output_transform_invert(wlr_output->transform),
|
2018-12-21 19:56:10 +01:00
|
|
|
output->cursor.width, output->cursor.height);
|
2018-05-09 20:58:18 +02:00
|
|
|
|
2017-11-01 14:25:41 +01:00
|
|
|
// TODO: use output->wlr_output.transform to transform pixels and hotpot
|
2018-05-09 20:58:18 +02:00
|
|
|
output->cursor.hotspot_x = hotspot.x;
|
|
|
|
output->cursor.hotspot_y = hotspot.y;
|
2017-10-29 17:43:26 +01:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
if (!update_texture) {
|
2017-10-12 09:40:51 +02:00
|
|
|
// Update hotspot without changing cursor image
|
2018-04-26 00:24:58 +02:00
|
|
|
update_wl_output_cursor(output);
|
2017-10-12 09:40:51 +02:00
|
|
|
return true;
|
|
|
|
}
|
2017-10-08 21:21:06 +02:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
if (output->cursor.surface == NULL) {
|
2017-10-29 17:43:26 +01:00
|
|
|
output->cursor.surface =
|
2018-05-01 22:38:04 +02:00
|
|
|
wl_compositor_create_surface(backend->compositor);
|
2017-08-14 18:19:42 +02:00
|
|
|
}
|
2018-05-01 22:38:04 +02:00
|
|
|
struct wl_surface *surface = output->cursor.surface;
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
if (texture != NULL) {
|
|
|
|
int width, height;
|
|
|
|
wlr_texture_get_size(texture, &width, &height);
|
2018-05-09 20:58:18 +02:00
|
|
|
width = width * wlr_output->scale / scale;
|
|
|
|
height = height * wlr_output->scale / scale;
|
|
|
|
|
|
|
|
output->cursor.width = width;
|
|
|
|
output->cursor.height = height;
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
if (output->cursor.egl_window == NULL) {
|
|
|
|
output->cursor.egl_window =
|
|
|
|
wl_egl_window_create(surface, width, height);
|
2017-08-14 18:19:42 +02:00
|
|
|
}
|
2018-05-01 22:38:04 +02:00
|
|
|
wl_egl_window_resize(output->cursor.egl_window, width, height, 0, 0);
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
EGLSurface egl_surface =
|
|
|
|
wlr_egl_create_surface(&backend->egl, output->cursor.egl_window);
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
wlr_egl_make_current(&backend->egl, egl_surface, NULL);
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-05-09 20:58:18 +02:00
|
|
|
struct wlr_box cursor_box = {
|
|
|
|
.width = width,
|
|
|
|
.height = height,
|
|
|
|
};
|
|
|
|
|
|
|
|
float projection[9];
|
|
|
|
wlr_matrix_projection(projection, width, height, wlr_output->transform);
|
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
float matrix[9];
|
2018-05-09 20:58:18 +02:00
|
|
|
wlr_matrix_project_box(matrix, &cursor_box, transform, 0, projection);
|
2018-05-01 22:38:04 +02:00
|
|
|
|
|
|
|
wlr_renderer_begin(backend->renderer, width, height);
|
|
|
|
wlr_renderer_clear(backend->renderer, (float[]){ 0.0, 0.0, 0.0, 0.0 });
|
2018-05-09 20:58:18 +02:00
|
|
|
wlr_render_texture_with_matrix(backend->renderer, texture, matrix, 1.0);
|
2018-05-01 22:38:04 +02:00
|
|
|
wlr_renderer_end(backend->renderer);
|
|
|
|
|
|
|
|
wlr_egl_swap_buffers(&backend->egl, egl_surface, NULL);
|
|
|
|
wlr_egl_destroy_surface(&backend->egl, egl_surface);
|
|
|
|
} else {
|
|
|
|
wl_surface_attach(surface, NULL, 0, 0);
|
|
|
|
wl_surface_commit(surface);
|
|
|
|
}
|
2017-08-14 18:19:42 +02:00
|
|
|
|
2018-04-26 00:24:58 +02:00
|
|
|
update_wl_output_cursor(output);
|
2017-08-14 18:19:42 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-26 00:51:00 +02:00
|
|
|
static void output_destroy(struct wlr_output *wlr_output) {
|
2018-09-17 22:10:34 +02:00
|
|
|
struct wlr_wl_output *output = get_wl_output_from_output(wlr_output);
|
2018-01-30 19:45:57 +01:00
|
|
|
if (output == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2017-10-29 17:43:26 +01:00
|
|
|
|
2017-12-13 21:48:59 +01:00
|
|
|
wl_list_remove(&output->link);
|
|
|
|
|
2018-05-01 22:38:04 +02:00
|
|
|
if (output->cursor.egl_window != NULL) {
|
|
|
|
wl_egl_window_destroy(output->cursor.egl_window);
|
2017-08-14 18:19:42 +02:00
|
|
|
}
|
2017-10-29 17:43:26 +01:00
|
|
|
if (output->cursor.surface) {
|
|
|
|
wl_surface_destroy(output->cursor.surface);
|
2017-08-14 18:19:42 +02:00
|
|
|
}
|
|
|
|
|
2017-08-12 17:43:36 +02:00
|
|
|
if (output->frame_callback) {
|
|
|
|
wl_callback_destroy(output->frame_callback);
|
|
|
|
}
|
2017-12-13 21:48:59 +01:00
|
|
|
|
2019-11-16 21:05:46 +01:00
|
|
|
struct wlr_wl_presentation_feedback *feedback, *feedback_tmp;
|
|
|
|
wl_list_for_each_safe(feedback, feedback_tmp,
|
|
|
|
&output->presentation_feedbacks, link) {
|
|
|
|
presentation_feedback_destroy(feedback);
|
|
|
|
}
|
|
|
|
|
2018-04-25 00:44:43 +02:00
|
|
|
wlr_egl_destroy_surface(&output->backend->egl, output->egl_surface);
|
2017-06-20 19:01:20 +02:00
|
|
|
wl_egl_window_destroy(output->egl_window);
|
2019-05-06 18:06:31 +02:00
|
|
|
if (output->zxdg_toplevel_decoration_v1) {
|
|
|
|
zxdg_toplevel_decoration_v1_destroy(output->zxdg_toplevel_decoration_v1);
|
|
|
|
}
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_toplevel_destroy(output->xdg_toplevel);
|
|
|
|
xdg_surface_destroy(output->xdg_surface);
|
2017-06-19 22:36:40 +02:00
|
|
|
wl_surface_destroy(output->surface);
|
|
|
|
free(output);
|
|
|
|
}
|
|
|
|
|
2018-04-29 13:16:31 +02:00
|
|
|
void update_wl_output_cursor(struct wlr_wl_output *output) {
|
2017-10-29 17:43:26 +01:00
|
|
|
if (output->backend->pointer && output->enter_serial) {
|
|
|
|
wl_pointer_set_cursor(output->backend->pointer, output->enter_serial,
|
|
|
|
output->cursor.surface, output->cursor.hotspot_x,
|
|
|
|
output->cursor.hotspot_y);
|
2017-08-14 18:19:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-05 16:14:22 +02:00
|
|
|
static bool output_move_cursor(struct wlr_output *_output, int x, int y) {
|
2017-08-14 18:19:42 +02:00
|
|
|
// TODO: only return true if x == current x and y == current y
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-26 00:51:00 +02:00
|
|
|
static const struct wlr_output_impl output_impl = {
|
|
|
|
.destroy = output_destroy,
|
2019-04-23 18:26:21 +02:00
|
|
|
.attach_render = output_attach_render,
|
2020-04-02 12:41:19 +02:00
|
|
|
.test = output_test,
|
2019-04-23 18:26:21 +02:00
|
|
|
.commit = output_commit,
|
2018-04-26 00:51:00 +02:00
|
|
|
.set_cursor = output_set_cursor,
|
|
|
|
.move_cursor = output_move_cursor,
|
2017-06-19 22:36:40 +02:00
|
|
|
};
|
|
|
|
|
2017-12-19 19:55:18 +01:00
|
|
|
bool wlr_output_is_wl(struct wlr_output *wlr_output) {
|
|
|
|
return wlr_output->impl == &output_impl;
|
|
|
|
}
|
|
|
|
|
2019-01-10 15:17:14 +01:00
|
|
|
static void xdg_surface_handle_configure(void *data,
|
|
|
|
struct xdg_surface *xdg_surface, uint32_t serial) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output = data;
|
2017-08-16 19:19:31 +02:00
|
|
|
assert(output && output->xdg_surface == xdg_surface);
|
|
|
|
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_surface_ack_configure(xdg_surface, serial);
|
2017-08-16 19:19:31 +02:00
|
|
|
|
|
|
|
// nothing else?
|
2017-06-20 18:27:05 +02:00
|
|
|
}
|
|
|
|
|
2019-01-10 15:17:14 +01:00
|
|
|
static struct xdg_surface_listener xdg_surface_listener = {
|
2017-08-16 19:19:31 +02:00
|
|
|
.configure = xdg_surface_handle_configure,
|
|
|
|
};
|
|
|
|
|
2018-09-17 22:10:34 +02:00
|
|
|
static void xdg_toplevel_handle_configure(void *data,
|
2019-01-10 15:17:14 +01:00
|
|
|
struct xdg_toplevel *xdg_toplevel,
|
2017-08-16 19:19:31 +02:00
|
|
|
int32_t width, int32_t height, struct wl_array *states) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output = data;
|
2017-08-16 19:19:31 +02:00
|
|
|
assert(output && output->xdg_toplevel == xdg_toplevel);
|
|
|
|
|
2018-06-30 04:08:49 +02:00
|
|
|
if (width == 0 || height == 0) {
|
2017-08-17 10:22:54 +02:00
|
|
|
return;
|
|
|
|
}
|
2017-08-16 19:19:31 +02:00
|
|
|
// loop over states for maximized etc?
|
2019-01-22 20:27:23 +01:00
|
|
|
output_set_custom_mode(&output->wlr_output, width, height, 0);
|
2017-06-20 18:27:05 +02:00
|
|
|
}
|
|
|
|
|
2018-09-17 22:10:34 +02:00
|
|
|
static void xdg_toplevel_handle_close(void *data,
|
2019-01-10 15:17:14 +01:00
|
|
|
struct xdg_toplevel *xdg_toplevel) {
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output = data;
|
2017-11-01 20:14:52 +01:00
|
|
|
assert(output && output->xdg_toplevel == xdg_toplevel);
|
2017-08-16 19:19:31 +02:00
|
|
|
|
2017-12-13 21:48:59 +01:00
|
|
|
wlr_output_destroy((struct wlr_output *)output);
|
2017-06-20 18:27:05 +02:00
|
|
|
}
|
|
|
|
|
2019-01-10 15:17:14 +01:00
|
|
|
static struct xdg_toplevel_listener xdg_toplevel_listener = {
|
2017-08-16 19:19:31 +02:00
|
|
|
.configure = xdg_toplevel_handle_configure,
|
|
|
|
.close = xdg_toplevel_handle_close,
|
2017-06-20 18:27:05 +02:00
|
|
|
};
|
|
|
|
|
2018-09-17 22:10:34 +02:00
|
|
|
struct wlr_output *wlr_wl_output_create(struct wlr_backend *wlr_backend) {
|
|
|
|
struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend);
|
2017-09-23 06:29:53 +02:00
|
|
|
if (!backend->started) {
|
2017-06-21 00:22:21 +02:00
|
|
|
++backend->requested_outputs;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-04-29 13:16:31 +02:00
|
|
|
struct wlr_wl_output *output;
|
|
|
|
if (!(output = calloc(sizeof(struct wlr_wl_output), 1))) {
|
2018-07-09 23:49:54 +02:00
|
|
|
wlr_log(WLR_ERROR, "Failed to allocate wlr_wl_output");
|
2017-06-19 22:36:40 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2018-01-04 12:46:15 +01:00
|
|
|
wlr_output_init(&output->wlr_output, &backend->backend, &output_impl,
|
|
|
|
backend->local_display);
|
2017-08-13 16:51:50 +02:00
|
|
|
struct wlr_output *wlr_output = &output->wlr_output;
|
2017-06-19 22:36:40 +02:00
|
|
|
|
2017-12-17 18:02:55 +01:00
|
|
|
wlr_output_update_custom_mode(wlr_output, 1280, 720, 0);
|
2017-06-20 21:29:27 +02:00
|
|
|
strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
|
|
|
|
strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
|
2019-04-08 20:49:25 +02:00
|
|
|
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%zd",
|
2019-03-15 08:18:06 +01:00
|
|
|
++backend->last_output_num);
|
2017-06-19 22:36:40 +02:00
|
|
|
|
2019-12-26 16:09:05 +01:00
|
|
|
char description[128];
|
|
|
|
snprintf(description, sizeof(description),
|
|
|
|
"Wayland output %zd", backend->last_output_num);
|
|
|
|
wlr_output_set_description(wlr_output, description);
|
|
|
|
|
2017-08-13 16:51:50 +02:00
|
|
|
output->backend = backend;
|
2019-11-16 21:05:46 +01:00
|
|
|
wl_list_init(&output->presentation_feedbacks);
|
2017-06-20 18:27:05 +02:00
|
|
|
|
2017-08-13 16:51:50 +02:00
|
|
|
output->surface = wl_compositor_create_surface(backend->compositor);
|
2017-08-16 19:33:16 +02:00
|
|
|
if (!output->surface) {
|
2018-07-09 23:49:54 +02:00
|
|
|
wlr_log_errno(WLR_ERROR, "Could not create output surface");
|
2017-08-16 19:33:16 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2018-04-29 14:37:29 +02:00
|
|
|
wl_surface_set_user_data(output->surface, output);
|
2017-08-16 19:19:31 +02:00
|
|
|
output->xdg_surface =
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_wm_base_get_xdg_surface(backend->xdg_wm_base, output->surface);
|
2017-08-16 19:33:16 +02:00
|
|
|
if (!output->xdg_surface) {
|
2018-07-09 23:49:54 +02:00
|
|
|
wlr_log_errno(WLR_ERROR, "Could not get xdg surface");
|
2017-08-16 19:33:16 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2017-08-16 19:19:31 +02:00
|
|
|
output->xdg_toplevel =
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_surface_get_toplevel(output->xdg_surface);
|
2017-08-16 19:33:16 +02:00
|
|
|
if (!output->xdg_toplevel) {
|
2018-07-09 23:49:54 +02:00
|
|
|
wlr_log_errno(WLR_ERROR, "Could not get xdg toplevel");
|
2017-08-16 19:33:16 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2017-08-16 19:19:31 +02:00
|
|
|
|
2019-05-06 18:06:31 +02:00
|
|
|
if (backend->zxdg_decoration_manager_v1) {
|
|
|
|
output->zxdg_toplevel_decoration_v1 =
|
|
|
|
zxdg_decoration_manager_v1_get_toplevel_decoration(
|
|
|
|
backend->zxdg_decoration_manager_v1, output->xdg_toplevel);
|
2019-08-09 16:23:10 +02:00
|
|
|
if (!output->zxdg_toplevel_decoration_v1) {
|
2019-05-06 18:06:31 +02:00
|
|
|
wlr_log_errno(WLR_ERROR, "Could not get xdg toplevel decoration");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
zxdg_toplevel_decoration_v1_set_mode(output->zxdg_toplevel_decoration_v1,
|
|
|
|
ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
|
|
|
|
}
|
|
|
|
|
2019-01-24 13:48:26 +01:00
|
|
|
wlr_wl_output_set_title(wlr_output, NULL);
|
2018-05-15 01:16:18 +02:00
|
|
|
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_toplevel_set_app_id(output->xdg_toplevel, "wlroots");
|
|
|
|
xdg_surface_add_listener(output->xdg_surface,
|
2017-08-16 19:19:31 +02:00
|
|
|
&xdg_surface_listener, output);
|
2019-01-10 15:17:14 +01:00
|
|
|
xdg_toplevel_add_listener(output->xdg_toplevel,
|
2017-08-16 19:19:31 +02:00
|
|
|
&xdg_toplevel_listener, output);
|
2017-08-17 00:52:01 +02:00
|
|
|
wl_surface_commit(output->surface);
|
2017-06-20 18:27:05 +02:00
|
|
|
|
2017-08-13 16:51:50 +02:00
|
|
|
output->egl_window = wl_egl_window_create(output->surface,
|
2017-06-20 23:51:45 +02:00
|
|
|
wlr_output->width, wlr_output->height);
|
2018-03-20 23:10:42 +01:00
|
|
|
output->egl_surface = wlr_egl_create_surface(&backend->egl,
|
|
|
|
output->egl_window);
|
2017-06-19 22:36:40 +02:00
|
|
|
|
2017-08-17 10:22:54 +02:00
|
|
|
wl_display_roundtrip(output->backend->remote_display);
|
|
|
|
|
2017-06-20 23:51:45 +02:00
|
|
|
// start rendering loop per callbacks by rendering first frame
|
2018-03-20 23:10:42 +01:00
|
|
|
if (!wlr_egl_make_current(&output->backend->egl, output->egl_surface,
|
|
|
|
NULL)) {
|
2017-08-16 19:33:16 +02:00
|
|
|
goto error;
|
2017-06-20 23:51:45 +02:00
|
|
|
}
|
|
|
|
|
2018-03-20 23:10:42 +01:00
|
|
|
wlr_renderer_begin(backend->renderer, wlr_output->width, wlr_output->height);
|
|
|
|
wlr_renderer_clear(backend->renderer, (float[]){ 1.0, 1.0, 1.0, 1.0 });
|
|
|
|
wlr_renderer_end(backend->renderer);
|
2017-06-20 23:51:45 +02:00
|
|
|
|
2017-08-13 16:51:50 +02:00
|
|
|
output->frame_callback = wl_surface_frame(output->surface);
|
|
|
|
wl_callback_add_listener(output->frame_callback, &frame_listener, output);
|
2017-06-20 23:51:45 +02:00
|
|
|
|
2018-03-20 23:10:42 +01:00
|
|
|
if (!wlr_egl_swap_buffers(&output->backend->egl, output->egl_surface,
|
|
|
|
NULL)) {
|
2017-08-16 19:33:16 +02:00
|
|
|
goto error;
|
2017-06-20 23:51:45 +02:00
|
|
|
}
|
|
|
|
|
2017-10-14 22:33:00 +02:00
|
|
|
wl_list_insert(&backend->outputs, &output->link);
|
2018-01-04 12:46:15 +01:00
|
|
|
wlr_output_update_enabled(wlr_output, true);
|
2018-04-29 13:16:31 +02:00
|
|
|
|
2018-02-12 10:36:43 +01:00
|
|
|
wlr_signal_emit_safe(&backend->backend.events.new_output, wlr_output);
|
2018-04-29 13:16:31 +02:00
|
|
|
|
|
|
|
if (backend->pointer != NULL) {
|
|
|
|
create_wl_pointer(backend->pointer, output);
|
|
|
|
}
|
|
|
|
|
2017-06-19 22:36:40 +02:00
|
|
|
return wlr_output;
|
2017-08-16 19:33:16 +02:00
|
|
|
|
|
|
|
error:
|
|
|
|
wlr_output_destroy(&output->wlr_output);
|
|
|
|
return NULL;
|
2017-06-19 22:36:40 +02:00
|
|
|
}
|
2019-01-11 03:53:32 +01:00
|
|
|
|
|
|
|
void wlr_wl_output_set_title(struct wlr_output *output, const char *title) {
|
|
|
|
struct wlr_wl_output *wl_output = get_wl_output_from_output(output);
|
2019-01-24 13:48:26 +01:00
|
|
|
|
|
|
|
char wl_title[32];
|
|
|
|
if (title == NULL) {
|
|
|
|
if (snprintf(wl_title, sizeof(wl_title), "wlroots - %s", output->name) <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
title = wl_title;
|
|
|
|
}
|
|
|
|
|
2019-01-11 03:53:32 +01:00
|
|
|
xdg_toplevel_set_title(wl_output->xdg_toplevel, title);
|
|
|
|
}
|
2019-11-12 17:56:57 +01:00
|
|
|
|
|
|
|
struct wl_surface *wlr_wl_output_get_surface(struct wlr_output *output) {
|
|
|
|
struct wlr_wl_output *wl_output = get_wl_output_from_output(output);
|
|
|
|
return wl_output->surface;
|
|
|
|
}
|