From df936b9dac7fd6e94a43ed889a9b1c377926fd14 Mon Sep 17 00:00:00 2001 From: Andri Yngvason Date: Fri, 24 Jan 2020 20:08:57 +0000 Subject: [PATCH] Add xdg_output_v1 for more output info --- include/output.h | 17 ++- protocols/meson.build | 1 + protocols/xdg-output-unstable-v1.xml | 220 +++++++++++++++++++++++++++ src/main.c | 25 ++- src/output.c | 65 ++++++-- 5 files changed, 317 insertions(+), 11 deletions(-) create mode 100644 protocols/xdg-output-unstable-v1.xml diff --git a/include/output.h b/include/output.h index 6f75d8b..78cebcb 100644 --- a/include/output.h +++ b/include/output.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Andri Yngvason + * Copyright (c) 2019 - 2020 Andri Yngvason * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -16,19 +16,34 @@ #pragma once +#include +#include + +struct zxdg_output_v1; + struct output { struct wl_output* wl_output; + struct zxdg_output_v1* xdg_output; struct wl_list link; uint32_t id; + uint32_t width; uint32_t height; + + uint32_t x; + uint32_t y; + char make[256]; char model[256]; + char name[256]; + char description[256]; }; struct output* output_new(struct wl_output* wl_output, uint32_t id); void output_destroy(struct output* output); +void output_set_xdg_output(struct output* output, + struct zxdg_output_v1* xdg_output); void output_list_destroy(struct wl_list* list); struct output* output_find_by_id(struct wl_list* list, uint32_t id); struct output* output_first(struct wl_list* list); diff --git a/protocols/meson.build b/protocols/meson.build index 60092a2..363b092 100644 --- a/protocols/meson.build +++ b/protocols/meson.build @@ -18,6 +18,7 @@ client_protocols = [ 'wlr-screencopy-unstable-v1.xml', 'wlr-virtual-pointer-unstable-v1.xml', 'virtual-keyboard-unstable-v1.xml', + 'xdg-output-unstable-v1.xml', ] client_protos_src = [] diff --git a/protocols/xdg-output-unstable-v1.xml b/protocols/xdg-output-unstable-v1.xml new file mode 100644 index 0000000..fe3a70a --- /dev/null +++ b/protocols/xdg-output-unstable-v1.xml @@ -0,0 +1,220 @@ + + + + + Copyright © 2017 Red Hat Inc. + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + + + This protocol aims at describing outputs in a way which is more in line + with the concept of an output on desktop oriented systems. + + Some information are more specific to the concept of an output for + a desktop oriented system and may not make sense in other applications, + such as IVI systems for example. + + Typically, the global compositor space on a desktop system is made of + a contiguous or overlapping set of rectangular regions. + + Some of the information provided in this protocol might be identical + to their counterparts already available from wl_output, in which case + the information provided by this protocol should be preferred to their + equivalent in wl_output. The goal is to move the desktop specific + concepts (such as output location within the global compositor space, + the connector name and types, etc.) out of the core wl_output protocol. + + Warning! The protocol described in this file is experimental and + backward incompatible changes may be made. Backward compatible + changes may be added together with the corresponding interface + version bump. + Backward incompatible changes are done by bumping the version + number in the protocol and interface names and resetting the + interface version. Once the protocol is to be declared stable, + the 'z' prefix and the version number in the protocol and + interface names are removed and the interface version number is + reset. + + + + + A global factory interface for xdg_output objects. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output_manager object anymore. + + Any objects already created through this instance are not affected. + + + + + + This creates a new xdg_output object for the given wl_output. + + + + + + + + + An xdg_output describes part of the compositor geometry. + + This typically corresponds to a monitor that displays part of the + compositor space. + + For objects version 3 onwards, after all xdg_output properties have been + sent (when the object is created and when properties are updated), a + wl_output.done event is sent. This allows changes to the output + properties to be seen as atomic, even if they happen via multiple events. + + + + + Using this request a client can tell the server that it is not + going to use the xdg_output object anymore. + + + + + + The position event describes the location of the wl_output within + the global compositor space. + + The logical_position event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the location + of the output changes within the global compositor space. + + + + + + + + The logical_size event describes the size of the output in the + global compositor space. + + For example, a surface without any buffer scale, transformation + nor rotation set, with the size matching the logical_size will + have the same size as the corresponding output when displayed. + + Most regular Wayland clients should not pay attention to the + logical size and would rather rely on xdg_shell interfaces. + + Some clients such as Xwayland, however, need this to configure + their surfaces in the global compositor space as the compositor + may apply a different scale from what is advertised by the output + scaling property (to achieve fractional scaling, for example). + + For example, for a wl_output mode 3840×2160 and a scale factor 2: + + - A compositor not scaling the surface buffers will advertise a + logical size of 3840×2160, + + - A compositor automatically scaling the surface buffers will + advertise a logical size of 1920×1080, + + - A compositor using a fractional scale of 1.5 will advertise a + logical size to 2560×1620. + + For example, for a wl_output mode 1920×1080 and a 90 degree rotation, + the compositor will advertise a logical size of 1080x1920. + + The logical_size event is sent after creating an xdg_output + (see xdg_output_manager.get_xdg_output) and whenever the logical + size of the output changes, either as a result of a change in the + applied scale or because of a change in the corresponding output + mode(see wl_output.mode) or transform (see wl_output.transform). + + + + + + + + This event is sent after all other properties of an xdg_output + have been sent. + + This allows changes to the xdg_output properties to be seen as + atomic, even if they happen via multiple events. + + For objects version 3 onwards, this event is deprecated. Compositors + are not required to send it anymore and must send wl_output.done + instead. + + + + + + + + Many compositors will assign names to their outputs, show them to the + user, allow them to be configured by name, etc. The client may wish to + know this name as well to offer the user similar behaviors. + + The naming convention is compositor defined, but limited to + alphanumeric characters and dashes (-). Each name is unique among all + wl_output globals, but if a wl_output global is destroyed the same name + may be reused later. The names will also remain consistent across + sessions with the same hardware and software configuration. + + Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do + not assume that the name is a reflection of an underlying DRM + connector, X11 connection, etc. + + The name event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output). This event is only sent once per + xdg_output, and the name does not change over the lifetime of the + wl_output global. + + + + + + + Many compositors can produce human-readable descriptions of their + outputs. The client may wish to know this description as well, to + communicate the user for various purposes. + + The description is a UTF-8 string with no convention defined for its + contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 + output via :1'. + + The description event is sent after creating an xdg_output (see + xdg_output_manager.get_xdg_output) and whenever the description + changes. The description is optional, and may not be sent at all. + + For objects of version 2 and lower, this event is only sent once per + xdg_output, and the description does not change over the lifetime of + the wl_output global. + + + + + + diff --git a/src/main.c b/src/main.c index d3d40bb..fea5401 100644 --- a/src/main.c +++ b/src/main.c @@ -36,6 +36,7 @@ #include "wlr-screencopy-unstable-v1.h" #include "wlr-virtual-pointer-unstable-v1.h" #include "virtual-keyboard-unstable-v1.h" +#include "xdg-output-unstable-v1.h" #include "render.h" #include "dmabuf.h" #include "screencopy.h" @@ -63,6 +64,7 @@ struct wayvnc { struct wl_list seats; struct cfg cfg; + struct zxdg_output_manager_v1* xdg_output_manager; struct zwp_virtual_keyboard_manager_v1* keyboard_manager; struct renderer renderer; @@ -126,6 +128,13 @@ static void registry_add(void* data, struct wl_registry* registry, return; } + if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) { + self->xdg_output_manager = + wl_registry_bind(registry, id, + &zxdg_output_manager_v1_interface, 3); + return; + } + if (strcmp(interface, wl_shm_interface.name) == 0) { self->screencopy_backend.wl_shm = wl_registry_bind(registry, id, &wl_shm_interface, 1); @@ -212,6 +221,8 @@ void wayvnc_destroy(struct wayvnc* self) output_list_destroy(&self->outputs); seat_list_destroy(&self->seats); + zxdg_output_manager_v1_destroy(self->xdg_output_manager); + wl_shm_destroy(self->screencopy_backend.wl_shm); zwp_virtual_keyboard_v1_destroy(self->keyboard_backend.virtual_keyboard); @@ -250,8 +261,8 @@ static int init_wayland(struct wayvnc* self) wl_registry_add_listener(self->registry, ®istry_listener, self); - wl_display_roundtrip(self->display); wl_display_dispatch(self->display); + wl_display_roundtrip(self->display); if (!self->dmabuf_backend.manager && !self->screencopy_backend.manager) { log_error("Compositor supports neither screencopy nor export-dmabuf! Exiting.\n"); @@ -264,6 +275,18 @@ static int init_wayland(struct wayvnc* self) self->screencopy_backend.frame_capture.on_done = on_capture_done; self->screencopy_backend.frame_capture.userdata = self; + struct output* output; + wl_list_for_each(output, &self->outputs, link) { + struct zxdg_output_v1* xdg_output = + zxdg_output_manager_v1_get_xdg_output( + self->xdg_output_manager, output->wl_output); + + output_set_xdg_output(output, xdg_output); + } + + wl_display_dispatch(self->display); + wl_display_roundtrip(self->display); + return 0; failure: diff --git a/src/output.c b/src/output.c index 8d3a57d..7127497 100644 --- a/src/output.c +++ b/src/output.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Andri Yngvason + * Copyright (c) 2019 - 2020 Andri Yngvason * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -23,6 +23,8 @@ #include "strlcpy.h" #include "logging.h" +#include "xdg-output-unstable-v1.h" + static void output_handle_geometry(void* data, struct wl_output* wl_output, int32_t x, int32_t y, int32_t phys_width, int32_t phys_height, int32_t subpixel, @@ -32,20 +34,13 @@ static void output_handle_geometry(void* data, struct wl_output* wl_output, struct output* output = data; strlcpy(output->make, make, sizeof(output->make)); - strlcpy(output->model, model, sizeof(output->make)); + strlcpy(output->model, model, sizeof(output->model)); } static void output_handle_mode(void* data, struct wl_output* wl_output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) { - struct output* output = data; - - if (!(flags & WL_OUTPUT_MODE_CURRENT)) - return; - - output->width = width; - output->height = height; } static void output_handle_done(void* data, struct wl_output* wl_output) @@ -66,6 +61,7 @@ static const struct wl_output_listener output_listener = { void output_destroy(struct output* output) { + zxdg_output_v1_destroy(output->xdg_output); wl_output_destroy(output->wl_output); free(output); } @@ -98,6 +94,57 @@ struct output* output_new(struct wl_output* wl_output, uint32_t id) return output; } +void output_logical_position(void* data, struct zxdg_output_v1* xdg_output, + int32_t x, int32_t y) +{ + struct output* self = data; + + self->x = x; + self->y = y; +} + +void output_logical_size(void* data, struct zxdg_output_v1* xdg_output, + int32_t width, int32_t height) +{ + struct output* self = data; + + self->width = width; + self->height = height; +} + +void output_name(void* data, struct zxdg_output_v1* xdg_output, + const char* name) +{ + struct output* self = data; + + strlcpy(self->name, name, sizeof(self->name)); +} + +void output_description(void* data, struct zxdg_output_v1* xdg_output, + const char* description) +{ + struct output* self = data; + + strlcpy(self->description, description, sizeof(self->description)); +} + +static const struct zxdg_output_v1_listener xdg_output_listener = { + .logical_position = output_logical_position, + .logical_size = output_logical_size, + .done = NULL, /* Deprecated */ + .name = output_name, + .description = output_description, +}; + +void output_set_xdg_output(struct output* self, + struct zxdg_output_v1* xdg_output) +{ + self->xdg_output = xdg_output; + + zxdg_output_v1_add_listener(self->xdg_output, &xdg_output_listener, + self); +} + struct output* output_find_by_id(struct wl_list* list, uint32_t id) { struct output* output;