GHOST/wayland: adapt window and cursor surface scale to support HiDPI screens
This commit is contained in:
parent
8b78510fc4
commit
870bcf6e1a
|
@ -53,15 +53,6 @@
|
|||
|
||||
#include <cstring>
|
||||
|
||||
struct output_t {
|
||||
struct wl_output *output;
|
||||
int32_t width, height;
|
||||
int transform;
|
||||
int scale;
|
||||
std::string make;
|
||||
std::string model;
|
||||
};
|
||||
|
||||
struct buffer_t {
|
||||
void *data;
|
||||
size_t size;
|
||||
|
@ -73,6 +64,12 @@ struct cursor_t {
|
|||
struct wl_buffer *buffer;
|
||||
struct wl_cursor_image image;
|
||||
struct buffer_t *file_buffer = nullptr;
|
||||
struct wl_cursor_theme *theme = nullptr;
|
||||
int size;
|
||||
std::string theme_name;
|
||||
// outputs on which the cursor is visible
|
||||
std::unordered_set<const output_t *> outputs;
|
||||
int scale = 1;
|
||||
};
|
||||
|
||||
struct data_offer_t {
|
||||
|
@ -146,7 +143,10 @@ struct display_t {
|
|||
struct wl_shm *shm = nullptr;
|
||||
std::vector<output_t *> outputs;
|
||||
std::vector<input_t *> inputs;
|
||||
struct wl_cursor_theme *cursor_theme = nullptr;
|
||||
struct {
|
||||
std::string theme;
|
||||
int size;
|
||||
} cursor;
|
||||
struct wl_data_device_manager *data_device_manager = nullptr;
|
||||
struct zwp_relative_pointer_manager_v1 *relative_pointer_manager = nullptr;
|
||||
struct zwp_pointer_constraints_v1 *pointer_constraints = nullptr;
|
||||
|
@ -155,6 +155,8 @@ struct display_t {
|
|||
std::vector<struct wl_egl_window *> os_egl_windows;
|
||||
};
|
||||
|
||||
static GHOST_WindowManager *window_manager = nullptr;
|
||||
|
||||
static void display_destroy(display_t *d)
|
||||
{
|
||||
if (d->data_device_manager) {
|
||||
|
@ -189,6 +191,9 @@ static void display_destroy(display_t *d)
|
|||
if (input->cursor.surface) {
|
||||
wl_surface_destroy(input->cursor.surface);
|
||||
}
|
||||
if (input->cursor.theme) {
|
||||
wl_cursor_theme_destroy(input->cursor.theme);
|
||||
}
|
||||
if (input->pointer) {
|
||||
wl_pointer_destroy(input->pointer);
|
||||
}
|
||||
|
@ -211,10 +216,6 @@ static void display_destroy(display_t *d)
|
|||
delete input;
|
||||
}
|
||||
|
||||
if (d->cursor_theme) {
|
||||
wl_cursor_theme_destroy(d->cursor_theme);
|
||||
}
|
||||
|
||||
if (d->shm) {
|
||||
wl_shm_destroy(d->shm);
|
||||
}
|
||||
|
@ -801,6 +802,69 @@ const struct wl_buffer_listener cursor_buffer_listener = {
|
|||
cursor_buffer_release,
|
||||
};
|
||||
|
||||
static GHOST_IWindow *get_window(struct wl_surface *surface)
|
||||
{
|
||||
if (!surface) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
for (GHOST_IWindow *win : window_manager->getWindows()) {
|
||||
if (surface == static_cast<const GHOST_WindowWayland *>(win)->surface()) {
|
||||
return win;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static bool update_cursor_scale(cursor_t &cursor, wl_shm *shm)
|
||||
{
|
||||
int scale = 0;
|
||||
for (const output_t *output : cursor.outputs) {
|
||||
if (output->scale > scale)
|
||||
scale = output->scale;
|
||||
}
|
||||
|
||||
if (scale > 0 && cursor.scale != scale) {
|
||||
cursor.scale = scale;
|
||||
wl_surface_set_buffer_scale(cursor.surface, scale);
|
||||
wl_cursor_theme_destroy(cursor.theme);
|
||||
cursor.theme = wl_cursor_theme_load(cursor.theme_name.c_str(), scale * cursor.size, shm);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void cursor_surface_enter(void *data,
|
||||
struct wl_surface * /*wl_surface*/,
|
||||
struct wl_output *output)
|
||||
{
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
for (const output_t *reg_output : input->system->outputs()) {
|
||||
if (reg_output->output == output) {
|
||||
input->cursor.outputs.insert(reg_output);
|
||||
}
|
||||
}
|
||||
update_cursor_scale(input->cursor, input->system->shm());
|
||||
}
|
||||
|
||||
static void cursor_surface_leave(void *data,
|
||||
struct wl_surface * /*wl_surface*/,
|
||||
struct wl_output *output)
|
||||
{
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
for (const output_t *reg_output : input->system->outputs()) {
|
||||
if (reg_output->output == output) {
|
||||
input->cursor.outputs.erase(reg_output);
|
||||
}
|
||||
}
|
||||
update_cursor_scale(input->cursor, input->system->shm());
|
||||
}
|
||||
|
||||
struct wl_surface_listener cursor_surface_listener = {
|
||||
cursor_surface_enter,
|
||||
cursor_surface_leave,
|
||||
};
|
||||
|
||||
static void pointer_enter(void *data,
|
||||
struct wl_pointer * /*wl_pointer*/,
|
||||
uint32_t serial,
|
||||
|
@ -808,22 +872,28 @@ static void pointer_enter(void *data,
|
|||
wl_fixed_t surface_x,
|
||||
wl_fixed_t surface_y)
|
||||
{
|
||||
if (!surface) {
|
||||
GHOST_WindowWayland *win = static_cast<GHOST_WindowWayland *>(get_window(surface));
|
||||
|
||||
if (!win) {
|
||||
return;
|
||||
}
|
||||
|
||||
win->activate();
|
||||
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
input->pointer_serial = serial;
|
||||
input->x = wl_fixed_to_int(surface_x);
|
||||
input->y = wl_fixed_to_int(surface_y);
|
||||
input->x = win->scale() * wl_fixed_to_int(surface_x);
|
||||
input->y = win->scale() * wl_fixed_to_int(surface_y);
|
||||
input->focus_pointer = surface;
|
||||
|
||||
input->system->pushEvent(
|
||||
new GHOST_EventCursor(input->system->getMilliSeconds(),
|
||||
GHOST_kEventCursorMove,
|
||||
static_cast<GHOST_WindowWayland *>(wl_surface_get_user_data(surface)),
|
||||
input->x,
|
||||
input->y,
|
||||
GHOST_TABLET_DATA_NONE));
|
||||
win->setCursorShape(win->getCursorShape());
|
||||
|
||||
input->system->pushEvent(new GHOST_EventCursor(input->system->getMilliSeconds(),
|
||||
GHOST_kEventCursorMove,
|
||||
static_cast<GHOST_WindowWayland *>(win),
|
||||
input->x,
|
||||
input->y,
|
||||
GHOST_TABLET_DATA_NONE));
|
||||
}
|
||||
|
||||
static void pointer_leave(void *data,
|
||||
|
@ -831,9 +901,14 @@ static void pointer_leave(void *data,
|
|||
uint32_t /*serial*/,
|
||||
struct wl_surface *surface)
|
||||
{
|
||||
if (surface != nullptr) {
|
||||
static_cast<input_t *>(data)->focus_pointer = nullptr;
|
||||
GHOST_IWindow *win = get_window(surface);
|
||||
|
||||
if (!win) {
|
||||
return;
|
||||
}
|
||||
|
||||
static_cast<input_t *>(data)->focus_pointer = nullptr;
|
||||
static_cast<GHOST_WindowWayland *>(win)->deactivate();
|
||||
}
|
||||
|
||||
static void pointer_motion(void *data,
|
||||
|
@ -844,21 +919,20 @@ static void pointer_motion(void *data,
|
|||
{
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
|
||||
GHOST_IWindow *win = static_cast<GHOST_WindowWayland *>(
|
||||
wl_surface_get_user_data(input->focus_pointer));
|
||||
GHOST_WindowWayland *win = static_cast<GHOST_WindowWayland *>(get_window(input->focus_pointer));
|
||||
|
||||
if (!win) {
|
||||
return;
|
||||
}
|
||||
|
||||
input->x = wl_fixed_to_int(surface_x);
|
||||
input->y = wl_fixed_to_int(surface_y);
|
||||
input->x = win->scale() * wl_fixed_to_int(surface_x);
|
||||
input->y = win->scale() * wl_fixed_to_int(surface_y);
|
||||
|
||||
input->system->pushEvent(new GHOST_EventCursor(input->system->getMilliSeconds(),
|
||||
GHOST_kEventCursorMove,
|
||||
win,
|
||||
wl_fixed_to_int(surface_x),
|
||||
wl_fixed_to_int(surface_y),
|
||||
input->x,
|
||||
input->y,
|
||||
GHOST_TABLET_DATA_NONE));
|
||||
}
|
||||
|
||||
|
@ -869,6 +943,14 @@ static void pointer_button(void *data,
|
|||
uint32_t button,
|
||||
uint32_t state)
|
||||
{
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
|
||||
GHOST_IWindow *win = get_window(input->focus_pointer);
|
||||
|
||||
if (!win) {
|
||||
return;
|
||||
}
|
||||
|
||||
GHOST_TEventType etype = GHOST_kEventUnknown;
|
||||
switch (state) {
|
||||
case WL_POINTER_BUTTON_STATE_RELEASED:
|
||||
|
@ -892,9 +974,6 @@ static void pointer_button(void *data,
|
|||
break;
|
||||
}
|
||||
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
GHOST_IWindow *win = static_cast<GHOST_WindowWayland *>(
|
||||
wl_surface_get_user_data(input->focus_pointer));
|
||||
input->data_source->source_serial = serial;
|
||||
input->buttons.set(ebutton, state == WL_POINTER_BUTTON_STATE_PRESSED);
|
||||
input->system->pushEvent(new GHOST_EventButton(
|
||||
|
@ -907,12 +986,18 @@ static void pointer_axis(void *data,
|
|||
uint32_t axis,
|
||||
wl_fixed_t value)
|
||||
{
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
|
||||
GHOST_IWindow *win = get_window(input->focus_pointer);
|
||||
|
||||
if (!win) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL) {
|
||||
return;
|
||||
}
|
||||
input_t *input = static_cast<input_t *>(data);
|
||||
GHOST_IWindow *win = static_cast<GHOST_WindowWayland *>(
|
||||
wl_surface_get_user_data(input->focus_pointer));
|
||||
|
||||
input->system->pushEvent(
|
||||
new GHOST_EventWheel(input->system->getMilliSeconds(), win, std::signbit(value) ? +1 : -1));
|
||||
}
|
||||
|
@ -1142,7 +1227,12 @@ static void seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t capa
|
|||
input->cursor.visible = true;
|
||||
input->cursor.buffer = nullptr;
|
||||
input->cursor.file_buffer = new buffer_t;
|
||||
if (!get_cursor_settings(input->cursor.theme_name, input->cursor.size)) {
|
||||
input->cursor.theme_name = std::string();
|
||||
input->cursor.size = default_cursor_size;
|
||||
}
|
||||
wl_pointer_add_listener(input->pointer, &pointer_listener, data);
|
||||
wl_surface_add_listener(input->cursor.surface, &cursor_surface_listener, data);
|
||||
}
|
||||
|
||||
if (capabilities & WL_SEAT_CAPABILITY_KEYBOARD) {
|
||||
|
@ -1165,8 +1255,8 @@ static void output_geometry(void *data,
|
|||
struct wl_output * /*wl_output*/,
|
||||
int32_t /*x*/,
|
||||
int32_t /*y*/,
|
||||
int32_t /*physical_width*/,
|
||||
int32_t /*physical_height*/,
|
||||
int32_t physical_width,
|
||||
int32_t physical_height,
|
||||
int32_t /*subpixel*/,
|
||||
const char *make,
|
||||
const char *model,
|
||||
|
@ -1176,6 +1266,8 @@ static void output_geometry(void *data,
|
|||
output->transform = transform;
|
||||
output->make = std::string(make);
|
||||
output->model = std::string(model);
|
||||
output->width_mm = physical_width;
|
||||
output->height_mm = physical_height;
|
||||
}
|
||||
|
||||
static void output_mode(void *data,
|
||||
|
@ -1186,8 +1278,8 @@ static void output_mode(void *data,
|
|||
int32_t /*refresh*/)
|
||||
{
|
||||
output_t *output = static_cast<output_t *>(data);
|
||||
output->width = width;
|
||||
output->height = height;
|
||||
output->width_pxl = width;
|
||||
output->height_pxl = height;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1232,7 +1324,7 @@ static void global_add(void *data,
|
|||
struct display_t *display = static_cast<struct display_t *>(data);
|
||||
if (!strcmp(interface, wl_compositor_interface.name)) {
|
||||
display->compositor = static_cast<wl_compositor *>(
|
||||
wl_registry_bind(wl_registry, name, &wl_compositor_interface, 1));
|
||||
wl_registry_bind(wl_registry, name, &wl_compositor_interface, 3));
|
||||
}
|
||||
else if (!strcmp(interface, xdg_wm_base_interface.name)) {
|
||||
display->xdg_shell = static_cast<xdg_wm_base *>(
|
||||
|
@ -1340,19 +1432,6 @@ GHOST_SystemWayland::GHOST_SystemWayland() : GHOST_System(), d(new display_t)
|
|||
wl_data_device_add_listener(input->data_device, &data_device_listener, input);
|
||||
}
|
||||
}
|
||||
|
||||
std::string theme;
|
||||
int size;
|
||||
if (!get_cursor_settings(theme, size)) {
|
||||
theme = std::string();
|
||||
size = default_cursor_size;
|
||||
}
|
||||
|
||||
d->cursor_theme = wl_cursor_theme_load(theme.c_str(), size, d->shm);
|
||||
if (!d->cursor_theme) {
|
||||
display_destroy(d);
|
||||
throw std::runtime_error("Wayland: unable to access cursor themes!");
|
||||
}
|
||||
}
|
||||
|
||||
GHOST_SystemWayland::~GHOST_SystemWayland()
|
||||
|
@ -1479,8 +1558,8 @@ void GHOST_SystemWayland::getMainDisplayDimensions(GHOST_TUns32 &width, GHOST_TU
|
|||
{
|
||||
if (getNumDisplays() > 0) {
|
||||
/* We assume first output as main. */
|
||||
width = uint32_t(d->outputs[0]->width);
|
||||
height = uint32_t(d->outputs[0]->height);
|
||||
width = uint32_t(d->outputs[0]->width_pxl) / d->outputs[0]->scale;
|
||||
height = uint32_t(d->outputs[0]->height_pxl) / d->outputs[0]->scale;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1538,6 +1617,11 @@ GHOST_IWindow *GHOST_SystemWayland::createWindow(const char *title,
|
|||
const bool is_dialog,
|
||||
const GHOST_IWindow *parentWindow)
|
||||
{
|
||||
/* globally store pointer to window manager */
|
||||
if (!window_manager) {
|
||||
window_manager = getWindowManager();
|
||||
}
|
||||
|
||||
GHOST_WindowWayland *window = new GHOST_WindowWayland(
|
||||
this,
|
||||
title,
|
||||
|
@ -1582,6 +1666,16 @@ xdg_wm_base *GHOST_SystemWayland::shell()
|
|||
return d->xdg_shell;
|
||||
}
|
||||
|
||||
const std::vector<output_t *> &GHOST_SystemWayland::outputs() const
|
||||
{
|
||||
return d->outputs;
|
||||
}
|
||||
|
||||
wl_shm *GHOST_SystemWayland::shm() const
|
||||
{
|
||||
return d->shm;
|
||||
}
|
||||
|
||||
void GHOST_SystemWayland::setSelection(const std::string &selection)
|
||||
{
|
||||
this->selection = selection;
|
||||
|
@ -1603,8 +1697,8 @@ static void set_cursor_buffer(input_t *input, wl_buffer *buffer)
|
|||
wl_pointer_set_cursor(input->pointer,
|
||||
input->pointer_serial,
|
||||
input->cursor.surface,
|
||||
int32_t(input->cursor.image.hotspot_x),
|
||||
int32_t(input->cursor.image.hotspot_y));
|
||||
int32_t(input->cursor.image.hotspot_x) / input->cursor.scale,
|
||||
int32_t(input->cursor.image.hotspot_y) / input->cursor.scale);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1616,7 +1710,15 @@ GHOST_TSuccess GHOST_SystemWayland::setCursorShape(GHOST_TStandardCursor shape)
|
|||
const std::string cursor_name = cursors.count(shape) ? cursors.at(shape) :
|
||||
cursors.at(GHOST_kStandardCursorDefault);
|
||||
|
||||
wl_cursor *cursor = wl_cursor_theme_get_cursor(d->cursor_theme, cursor_name.c_str());
|
||||
input_t *input = d->inputs[0];
|
||||
cursor_t *c = &input->cursor;
|
||||
|
||||
if (!c->theme) {
|
||||
/* The cursor surface hasn't entered an output yet. Initialise theme with scale 1. */
|
||||
c->theme = wl_cursor_theme_load(c->theme_name.c_str(), c->size, d->inputs[0]->system->shm());
|
||||
}
|
||||
|
||||
wl_cursor *cursor = wl_cursor_theme_get_cursor(c->theme, cursor_name.c_str());
|
||||
|
||||
if (!cursor) {
|
||||
GHOST_PRINT("cursor '" << cursor_name << "' does not exist" << std::endl);
|
||||
|
@ -1628,11 +1730,11 @@ GHOST_TSuccess GHOST_SystemWayland::setCursorShape(GHOST_TStandardCursor shape)
|
|||
if (!buffer) {
|
||||
return GHOST_kFailure;
|
||||
}
|
||||
cursor_t *c = &d->inputs[0]->cursor;
|
||||
|
||||
c->buffer = buffer;
|
||||
c->image = *image;
|
||||
|
||||
set_cursor_buffer(d->inputs[0], buffer);
|
||||
set_cursor_buffer(input, buffer);
|
||||
|
||||
return GHOST_kSuccess;
|
||||
}
|
||||
|
|
|
@ -34,6 +34,16 @@ class GHOST_WindowWayland;
|
|||
|
||||
struct display_t;
|
||||
|
||||
struct output_t {
|
||||
struct wl_output *output;
|
||||
int32_t width_pxl, height_pxl; // dimensions in pixel
|
||||
int32_t width_mm, height_mm; // dimensions in millimeter
|
||||
int transform;
|
||||
int scale;
|
||||
std::string make;
|
||||
std::string model;
|
||||
};
|
||||
|
||||
class GHOST_SystemWayland : public GHOST_System {
|
||||
public:
|
||||
GHOST_SystemWayland();
|
||||
|
@ -84,6 +94,10 @@ class GHOST_SystemWayland : public GHOST_System {
|
|||
|
||||
xdg_wm_base *shell();
|
||||
|
||||
const std::vector<output_t *> &outputs() const;
|
||||
|
||||
wl_shm *shm() const;
|
||||
|
||||
void setSelection(const std::string &selection);
|
||||
|
||||
GHOST_TSuccess setCursorShape(GHOST_TStandardCursor shape);
|
||||
|
|
|
@ -29,9 +29,15 @@
|
|||
|
||||
#include <wayland-egl.h>
|
||||
|
||||
static constexpr size_t base_dpi = 96;
|
||||
|
||||
struct window_t {
|
||||
GHOST_WindowWayland *w;
|
||||
wl_surface *surface;
|
||||
// outputs on which the window is currently shown on
|
||||
std::unordered_set<const output_t *> outputs;
|
||||
GHOST_TUns16 dpi = 0;
|
||||
int scale = 1;
|
||||
struct xdg_surface *xdg_surface;
|
||||
struct xdg_toplevel *xdg_toplevel;
|
||||
wl_egl_window *egl_window;
|
||||
|
@ -97,13 +103,14 @@ static void surface_configure(void *data, xdg_surface *xdg_surface, uint32_t ser
|
|||
{
|
||||
window_t *win = static_cast<window_t *>(data);
|
||||
|
||||
int w, h;
|
||||
wl_egl_window_get_attached_size(win->egl_window, &w, &h);
|
||||
if (win->pending_width != 0 && win->pending_height != 0 && win->pending_width != w &&
|
||||
win->pending_height != h) {
|
||||
win->width = win->pending_width;
|
||||
win->height = win->pending_height;
|
||||
wl_egl_window_resize(win->egl_window, win->pending_width, win->pending_height, 0, 0);
|
||||
if (win->xdg_surface != xdg_surface) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (win->pending_width != 0 && win->pending_height != 0) {
|
||||
win->width = win->scale * win->pending_width;
|
||||
win->height = win->scale * win->pending_height;
|
||||
wl_egl_window_resize(win->egl_window, win->width, win->height, 0, 0);
|
||||
win->pending_width = 0;
|
||||
win->pending_height = 0;
|
||||
win->w->notify_size();
|
||||
|
@ -123,6 +130,52 @@ static const xdg_surface_listener surface_listener = {
|
|||
surface_configure,
|
||||
};
|
||||
|
||||
static bool update_scale(GHOST_WindowWayland *window)
|
||||
{
|
||||
int scale = 0;
|
||||
for (const output_t *output : window->outputs_active()) {
|
||||
if (output->scale > scale)
|
||||
scale = output->scale;
|
||||
}
|
||||
|
||||
if (scale > 0 && window->scale() != scale) {
|
||||
window->scale() = scale;
|
||||
// using the real DPI will cause wrong scaling of the UI
|
||||
// use a multiplier for the default DPI as workaround
|
||||
window->dpi() = scale * base_dpi;
|
||||
wl_surface_set_buffer_scale(window->surface(), scale);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void surface_enter(void *data, struct wl_surface * /*wl_surface*/, struct wl_output *output)
|
||||
{
|
||||
GHOST_WindowWayland *w = static_cast<GHOST_WindowWayland *>(data);
|
||||
for (const output_t *reg_output : w->outputs()) {
|
||||
if (reg_output->output == output) {
|
||||
w->outputs_active().insert(reg_output);
|
||||
}
|
||||
}
|
||||
update_scale(w);
|
||||
}
|
||||
|
||||
static void surface_leave(void *data, struct wl_surface * /*wl_surface*/, struct wl_output *output)
|
||||
{
|
||||
GHOST_WindowWayland *w = static_cast<GHOST_WindowWayland *>(data);
|
||||
for (const output_t *reg_output : w->outputs()) {
|
||||
if (reg_output->output == output) {
|
||||
w->outputs_active().erase(reg_output);
|
||||
}
|
||||
}
|
||||
update_scale(w);
|
||||
}
|
||||
|
||||
struct wl_surface_listener wl_surface_listener = {
|
||||
surface_enter,
|
||||
surface_leave,
|
||||
};
|
||||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
@ -161,6 +214,8 @@ GHOST_WindowWayland::GHOST_WindowWayland(GHOST_SystemWayland *system,
|
|||
|
||||
/* Window surfaces. */
|
||||
w->surface = wl_compositor_create_surface(m_system->compositor());
|
||||
wl_surface_add_listener(w->surface, &wl_surface_listener, this);
|
||||
|
||||
w->egl_window = wl_egl_window_create(w->surface, int(width), int(height));
|
||||
|
||||
w->xdg_surface = xdg_wm_base_get_xdg_surface(m_system->shell(), w->surface);
|
||||
|
@ -229,6 +284,31 @@ GHOST_TSuccess GHOST_WindowWayland::notify_size()
|
|||
new GHOST_Event(m_system->getMilliSeconds(), GHOST_kEventWindowSize, this));
|
||||
}
|
||||
|
||||
wl_surface *GHOST_WindowWayland::surface() const
|
||||
{
|
||||
return w->surface;
|
||||
}
|
||||
|
||||
const std::vector<output_t *> &GHOST_WindowWayland::outputs() const
|
||||
{
|
||||
return m_system->outputs();
|
||||
}
|
||||
|
||||
std::unordered_set<const output_t *> &GHOST_WindowWayland::outputs_active()
|
||||
{
|
||||
return w->outputs;
|
||||
}
|
||||
|
||||
uint16_t &GHOST_WindowWayland::dpi()
|
||||
{
|
||||
return w->dpi;
|
||||
}
|
||||
|
||||
int &GHOST_WindowWayland::scale()
|
||||
{
|
||||
return w->scale;
|
||||
}
|
||||
|
||||
GHOST_TSuccess GHOST_WindowWayland::setWindowCursorGrab(GHOST_TGrabCursorMode mode)
|
||||
{
|
||||
return m_system->setCursorGrab(mode, w->surface);
|
||||
|
@ -320,6 +400,11 @@ GHOST_WindowWayland::~GHOST_WindowWayland()
|
|||
delete w;
|
||||
}
|
||||
|
||||
GHOST_TUns16 GHOST_WindowWayland::getDPIHint()
|
||||
{
|
||||
return w->dpi;
|
||||
}
|
||||
|
||||
GHOST_TSuccess GHOST_WindowWayland::setWindowCursorVisibility(bool visible)
|
||||
{
|
||||
return m_system->setCursorVisibility(visible);
|
||||
|
|
|
@ -24,9 +24,14 @@
|
|||
|
||||
#include "GHOST_Window.h"
|
||||
|
||||
#include <unordered_set>
|
||||
#include <vector>
|
||||
|
||||
class GHOST_SystemWayland;
|
||||
|
||||
struct window_t;
|
||||
struct wl_surface;
|
||||
struct output_t;
|
||||
|
||||
class GHOST_WindowWayland : public GHOST_Window {
|
||||
public:
|
||||
|
@ -47,6 +52,8 @@ class GHOST_WindowWayland : public GHOST_Window {
|
|||
|
||||
~GHOST_WindowWayland() override;
|
||||
|
||||
GHOST_TUns16 getDPIHint() override;
|
||||
|
||||
GHOST_TSuccess close();
|
||||
|
||||
GHOST_TSuccess activate();
|
||||
|
@ -55,6 +62,16 @@ class GHOST_WindowWayland : public GHOST_Window {
|
|||
|
||||
GHOST_TSuccess notify_size();
|
||||
|
||||
wl_surface *surface() const;
|
||||
|
||||
const std::vector<output_t *> &outputs() const;
|
||||
|
||||
std::unordered_set<const output_t *> &outputs_active();
|
||||
|
||||
uint16_t &dpi();
|
||||
|
||||
int &scale();
|
||||
|
||||
protected:
|
||||
GHOST_TSuccess setWindowCursorGrab(GHOST_TGrabCursorMode mode) override;
|
||||
|
||||
|
|
Loading…
Reference in New Issue