mirror of
https://github.com/hyprwm/wlroots-hyprland.git
synced 2024-11-22 12:55:58 +01:00
Merge branch 'master' into display-destroy
This commit is contained in:
emersion
commit
c67a5824b8
25 changed files with 326 additions and 116 deletions
|
|
@ -93,6 +93,12 @@ void parse_edid(struct wlr_output *restrict output, size_t len, const uint8_t *d
|
|||
uint16_t id = (data[8] << 8) | data[9];
|
||||
snprintf(output->make, sizeof(output->make), "%s", get_manufacturer(id));
|
||||
|
||||
uint16_t model = data[10] | (data[11] << 8);
|
||||
snprintf(output->model, sizeof(output->model), "0x%04X", model);
|
||||
|
||||
uint32_t serial = data[12] | (data[13] << 8) | (data[14] << 8) | (data[15] << 8);
|
||||
snprintf(output->serial, sizeof(output->serial), "0x%08X", serial);
|
||||
|
||||
output->phys_width = ((data[68] & 0xf0) << 4) | data[66];
|
||||
output->phys_height = ((data[68] & 0x0f) << 8) | data[67];
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,15 @@ static struct wl_callback_listener frame_listener = {
|
|||
.done = surface_frame_callback
|
||||
};
|
||||
|
||||
static bool wlr_wl_output_set_custom_mode(struct wlr_output *_output,
|
||||
int32_t width, int32_t height, int32_t refresh) {
|
||||
struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output;
|
||||
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
|
||||
wlr_output_update_size(&output->wlr_output, width, height);
|
||||
wl_signal_emit(&output->wlr_output.events.resolution, 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,
|
||||
|
|
@ -185,6 +194,7 @@ bool wlr_wl_output_move_cursor(struct wlr_output *_output, int x, int y) {
|
|||
}
|
||||
|
||||
static struct wlr_output_impl output_impl = {
|
||||
.set_custom_mode = wlr_wl_output_set_custom_mode,
|
||||
.transform = wlr_wl_output_transform,
|
||||
.destroy = wlr_wl_output_destroy,
|
||||
.make_current = wlr_wl_output_make_current,
|
||||
|
|
|
|||
|
|
@ -204,8 +204,8 @@ static bool wlr_x11_backend_start(struct wlr_backend *backend) {
|
|||
snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1");
|
||||
|
||||
output->win = xcb_generate_id(x11->xcb_conn);
|
||||
xcb_create_window(x11->xcb_conn, XCB_COPY_FROM_PARENT, output->win, x11->screen->root,
|
||||
0, 0, 1024, 768, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT,
|
||||
xcb_create_window(x11->xcb_conn, XCB_COPY_FROM_PARENT, output->win,
|
||||
x11->screen->root, 0, 0, 1024, 768, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT,
|
||||
x11->screen->root_visual, mask, values);
|
||||
|
||||
output->surf = wlr_egl_create_surface(&x11->egl, &output->win);
|
||||
|
|
@ -340,6 +340,17 @@ error_x11:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width,
|
||||
int32_t height, int32_t refresh) {
|
||||
struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
|
||||
struct wlr_x11_backend *x11 = output->x11;
|
||||
|
||||
const uint32_t values[] = { width, height };
|
||||
xcb_configure_window(x11->xcb_conn, output->win,
|
||||
XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) {
|
||||
struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
|
||||
output->wlr_output.transform = transform;
|
||||
|
|
@ -373,6 +384,7 @@ static void output_swap_buffers(struct wlr_output *wlr_output) {
|
|||
}
|
||||
|
||||
static struct wlr_output_impl output_impl = {
|
||||
.set_custom_mode = output_set_custom_mode,
|
||||
.transform = output_transform,
|
||||
.destroy = output_destroy,
|
||||
.make_current = output_make_current,
|
||||
|
|
|
|||
|
|
@ -42,6 +42,7 @@ struct roots_keyboard_config {
|
|||
char *layout;
|
||||
char *variant;
|
||||
char *options;
|
||||
int repeat_rate, repeat_delay;
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
|
|
@ -50,6 +51,7 @@ struct roots_cursor_config {
|
|||
char *mapped_output;
|
||||
struct wlr_box *mapped_box;
|
||||
char *theme;
|
||||
char *default_image;
|
||||
struct wl_list link;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -10,13 +10,6 @@ enum roots_cursor_mode {
|
|||
ROOTS_CURSOR_ROTATE = 3,
|
||||
};
|
||||
|
||||
enum roots_cursor_resize_edge {
|
||||
ROOTS_CURSOR_RESIZE_EDGE_TOP = 1,
|
||||
ROOTS_CURSOR_RESIZE_EDGE_BOTTOM = 2,
|
||||
ROOTS_CURSOR_RESIZE_EDGE_LEFT = 4,
|
||||
ROOTS_CURSOR_RESIZE_EDGE_RIGHT = 8,
|
||||
};
|
||||
|
||||
struct roots_input_event {
|
||||
uint32_t serial;
|
||||
struct wlr_cursor *cursor;
|
||||
|
|
@ -27,6 +20,8 @@ struct roots_cursor {
|
|||
struct roots_seat *seat;
|
||||
struct wlr_cursor *cursor;
|
||||
|
||||
const char *default_xcursor;
|
||||
|
||||
enum roots_cursor_mode mode;
|
||||
|
||||
// state from input (review if this is necessary)
|
||||
|
|
|
|||
|
|
@ -3,12 +3,10 @@
|
|||
|
||||
#include <stdint.h>
|
||||
|
||||
#define ROOTS_XCURSOR_SIZE 16
|
||||
#define ROOTS_XCURSOR_SIZE 24
|
||||
|
||||
#define ROOTS_XCURSOR_DEFAULT "left_ptr"
|
||||
#define ROOTS_XCURSOR_MOVE "grabbing"
|
||||
#define ROOTS_XCURSOR_ROTATE "grabbing"
|
||||
|
||||
const char *roots_xcursor_get_resize_name(uint32_t edges);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@
|
|||
struct wlr_output_impl {
|
||||
void (*enable)(struct wlr_output *output, bool enable);
|
||||
bool (*set_mode)(struct wlr_output *output, struct wlr_output_mode *mode);
|
||||
bool (*set_custom_mode)(struct wlr_output *output, int32_t width,
|
||||
int32_t height, int32_t refresh);
|
||||
void (*transform)(struct wlr_output *output,
|
||||
enum wl_output_transform transform);
|
||||
bool (*set_cursor)(struct wlr_output *output, const uint8_t *buf,
|
||||
|
|
|
|||
|
|
@ -51,10 +51,16 @@ struct wlr_keyboard {
|
|||
xkb_mod_mask_t group;
|
||||
} modifiers;
|
||||
|
||||
struct {
|
||||
int32_t rate;
|
||||
int32_t delay;
|
||||
} repeat_info;
|
||||
|
||||
struct {
|
||||
struct wl_signal key;
|
||||
struct wl_signal modifiers;
|
||||
struct wl_signal keymap;
|
||||
struct wl_signal repeat_info;
|
||||
} events;
|
||||
|
||||
void *data;
|
||||
|
|
@ -74,6 +80,12 @@ struct wlr_event_keyboard_key {
|
|||
|
||||
void wlr_keyboard_set_keymap(struct wlr_keyboard *kb,
|
||||
struct xkb_keymap *keymap);
|
||||
/**
|
||||
* Sets the keyboard repeat info. `rate` is in key repeats/second and delay is
|
||||
* in milliseconds.
|
||||
*/
|
||||
void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate,
|
||||
int32_t delay);
|
||||
void wlr_keyboard_led_update(struct wlr_keyboard *keyboard, uint32_t leds);
|
||||
uint32_t wlr_keyboard_get_modifiers(struct wlr_keyboard *keyboard);
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ struct wlr_output_cursor {
|
|||
struct wlr_output *output;
|
||||
double x, y;
|
||||
bool enabled;
|
||||
bool visible;
|
||||
uint32_t width, height;
|
||||
int32_t hotspot_x, hotspot_y;
|
||||
struct wl_list link;
|
||||
|
|
@ -84,6 +85,8 @@ struct wlr_surface;
|
|||
void wlr_output_enable(struct wlr_output *output, bool enable);
|
||||
bool wlr_output_set_mode(struct wlr_output *output,
|
||||
struct wlr_output_mode *mode);
|
||||
bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width,
|
||||
int32_t height, int32_t refresh);
|
||||
void wlr_output_transform(struct wlr_output *output,
|
||||
enum wl_output_transform transform);
|
||||
void wlr_output_set_position(struct wlr_output *output, int32_t lx, int32_t ly);
|
||||
|
|
@ -100,6 +103,9 @@ 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.
|
||||
*/
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -146,6 +146,7 @@ struct wlr_seat_keyboard_state {
|
|||
|
||||
struct wl_listener keyboard_destroy;
|
||||
struct wl_listener keyboard_keymap;
|
||||
struct wl_listener keyboard_repeat_info;
|
||||
|
||||
struct wl_listener surface_destroy;
|
||||
struct wl_listener resource_destroy;
|
||||
|
|
|
|||
12
include/wlr/util/edges.h
Normal file
12
include/wlr/util/edges.h
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
#ifndef WLR_UTIL_EDGES_H
|
||||
#define WLR_UTIL_EDGES_H
|
||||
|
||||
enum wlr_edges {
|
||||
WLR_EDGE_NONE = 0,
|
||||
WLR_EDGE_TOP = 1,
|
||||
WLR_EDGE_BOTTOM = 2,
|
||||
WLR_EDGE_LEFT = 4,
|
||||
WLR_EDGE_RIGHT = 8,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -32,6 +32,7 @@
|
|||
#define WLR_XCURSOR_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <wlr/util/edges.h>
|
||||
|
||||
struct wlr_xcursor_image {
|
||||
uint32_t width; /* actual width */
|
||||
|
|
@ -65,4 +66,9 @@ struct wlr_xcursor *wlr_xcursor_theme_get_cursor(
|
|||
|
||||
int wlr_xcursor_frame(struct wlr_xcursor *cursor, uint32_t time);
|
||||
|
||||
/**
|
||||
* Get the name of the resize cursor image for the given edges.
|
||||
*/
|
||||
const char *wlr_xcursor_get_resize_name(enum wlr_edges edges);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ void add_binding_config(struct wl_list *bindings, const char* combination,
|
|||
|
||||
xkb_keysym_t keysyms[ROOTS_KEYBOARD_PRESSED_KEYSYMS_CAP];
|
||||
char *symnames = strdup(combination);
|
||||
char* symname = strtok(symnames, "+");
|
||||
char *symname = strtok(symnames, "+");
|
||||
while (symname) {
|
||||
uint32_t modifier = parse_modifier(symname);
|
||||
if (modifier != 0) {
|
||||
|
|
@ -176,6 +176,9 @@ static void config_handle_cursor(struct roots_config *config,
|
|||
} else if (strcmp(name, "theme") == 0) {
|
||||
free(cc->theme);
|
||||
cc->theme = strdup(value);
|
||||
} else if (strcmp(name, "default-image") == 0) {
|
||||
free(cc->default_image);
|
||||
cc->default_image = strdup(value);
|
||||
} else {
|
||||
wlr_log(L_ERROR, "got unknown cursor config: %s", name);
|
||||
}
|
||||
|
|
@ -213,6 +216,10 @@ static void config_handle_keyboard(struct roots_config *config,
|
|||
kc->variant = strdup(value);
|
||||
} else if (strcmp(name, "options") == 0) {
|
||||
kc->options = strdup(value);
|
||||
} else if (strcmp(name, "repeat-rate") == 0) {
|
||||
kc->repeat_rate = strtol(value, NULL, 10);
|
||||
} else if (strcmp(name, "repeat-delay") == 0) {
|
||||
kc->repeat_delay = strtol(value, NULL, 10);
|
||||
} else {
|
||||
wlr_log(L_ERROR, "got unknown keyboard config: %s", name);
|
||||
}
|
||||
|
|
@ -450,6 +457,7 @@ void roots_config_destroy(struct roots_config *config) {
|
|||
free(cc->mapped_output);
|
||||
free(cc->mapped_box);
|
||||
free(cc->theme);
|
||||
free(cc->default_image);
|
||||
free(cc);
|
||||
}
|
||||
|
||||
|
|
@ -466,10 +474,15 @@ void roots_config_destroy(struct roots_config *config) {
|
|||
|
||||
struct roots_output_config *roots_config_get_output(struct roots_config *config,
|
||||
struct wlr_output *output) {
|
||||
struct roots_output_config *o_config;
|
||||
wl_list_for_each(o_config, &config->outputs, link) {
|
||||
if (strcmp(o_config->name, output->name) == 0) {
|
||||
return o_config;
|
||||
char name[83];
|
||||
snprintf(name, sizeof(name), "%s %s %s", output->make, output->model,
|
||||
output->serial);
|
||||
|
||||
struct roots_output_config *oc;
|
||||
wl_list_for_each(oc, &config->outputs, link) {
|
||||
if (strcmp(oc->name, output->name) == 0 ||
|
||||
strcmp(oc->name, name) == 0) {
|
||||
return oc;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#endif
|
||||
#include <wlr/types/wlr_xcursor_manager.h>
|
||||
#include <wlr/util/log.h>
|
||||
#include <wlr/util/edges.h>
|
||||
#include "rootston/xcursor.h"
|
||||
#include "rootston/cursor.h"
|
||||
|
||||
|
|
@ -21,6 +22,7 @@ struct roots_cursor *roots_cursor_create(struct roots_seat *seat) {
|
|||
free(cursor);
|
||||
return NULL;
|
||||
}
|
||||
cursor->default_xcursor = ROOTS_XCURSOR_DEFAULT;
|
||||
return cursor;
|
||||
}
|
||||
|
||||
|
|
@ -47,7 +49,7 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
|
|||
}
|
||||
if (set_compositor_cursor) {
|
||||
wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
|
||||
ROOTS_XCURSOR_DEFAULT, cursor->cursor);
|
||||
cursor->default_xcursor, cursor->cursor);
|
||||
cursor->cursor_client = NULL;
|
||||
}
|
||||
if (view) {
|
||||
|
|
@ -75,22 +77,22 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
|
|||
double y = view->y;
|
||||
int width = cursor->view_width;
|
||||
int height = cursor->view_height;
|
||||
if (cursor->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) {
|
||||
if (cursor->resize_edges & WLR_EDGE_TOP) {
|
||||
y = cursor->view_y + dy;
|
||||
height -= dy;
|
||||
if (height < 1) {
|
||||
y += height;
|
||||
}
|
||||
} else if (cursor->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
|
||||
} else if (cursor->resize_edges & WLR_EDGE_BOTTOM) {
|
||||
height += dy;
|
||||
}
|
||||
if (cursor->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
|
||||
if (cursor->resize_edges & WLR_EDGE_LEFT) {
|
||||
x = cursor->view_x + dx;
|
||||
width -= dx;
|
||||
if (width < 1) {
|
||||
x += width;
|
||||
}
|
||||
} else if (cursor->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
|
||||
} else if (cursor->resize_edges & WLR_EDGE_RIGHT) {
|
||||
width += dx;
|
||||
}
|
||||
|
||||
|
|
@ -147,14 +149,14 @@ static void roots_cursor_press_button(struct roots_cursor *cursor,
|
|||
case BTN_RIGHT:
|
||||
edges = 0;
|
||||
if (sx < view->wlr_surface->current->width/2) {
|
||||
edges |= ROOTS_CURSOR_RESIZE_EDGE_LEFT;
|
||||
edges |= WLR_EDGE_LEFT;
|
||||
} else {
|
||||
edges |= ROOTS_CURSOR_RESIZE_EDGE_RIGHT;
|
||||
edges |= WLR_EDGE_RIGHT;
|
||||
}
|
||||
if (sy < view->wlr_surface->current->height/2) {
|
||||
edges |= ROOTS_CURSOR_RESIZE_EDGE_TOP;
|
||||
edges |= WLR_EDGE_TOP;
|
||||
} else {
|
||||
edges |= ROOTS_CURSOR_RESIZE_EDGE_BOTTOM;
|
||||
edges |= WLR_EDGE_BOTTOM;
|
||||
}
|
||||
roots_seat_begin_resize(seat, view, edges);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -408,10 +408,14 @@ struct roots_desktop *desktop_create(struct roots_server *server,
|
|||
desktop->config = config;
|
||||
|
||||
const char *cursor_theme = NULL;
|
||||
const char *cursor_default = ROOTS_XCURSOR_DEFAULT;
|
||||
struct roots_cursor_config *cc =
|
||||
roots_config_get_cursor(config, ROOTS_CONFIG_DEFAULT_SEAT_NAME);
|
||||
if (cc != NULL) {
|
||||
cursor_theme = cc->theme;
|
||||
if (cc->default_image != NULL) {
|
||||
cursor_default = cc->default_image;
|
||||
}
|
||||
}
|
||||
|
||||
desktop->xcursor_manager = wlr_xcursor_manager_create(cursor_theme,
|
||||
|
|
@ -449,7 +453,7 @@ struct roots_desktop *desktop_create(struct roots_server *server,
|
|||
wlr_log(L_ERROR, "Cannot load XWayland XCursor theme");
|
||||
}
|
||||
struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(
|
||||
desktop->xcursor_manager, ROOTS_XCURSOR_DEFAULT, 1);
|
||||
desktop->xcursor_manager, cursor_default, 1);
|
||||
if (xcursor != NULL) {
|
||||
struct wlr_xcursor_image *image = xcursor->images[0];
|
||||
wlr_xwayland_set_cursor(desktop->xwayland, image->buffer,
|
||||
|
|
|
|||
|
|
@ -306,6 +306,12 @@ static void keyboard_config_merge(struct roots_keyboard_config *config,
|
|||
if (config->name == NULL) {
|
||||
config->name = fallback->name;
|
||||
}
|
||||
if (config->repeat_rate <= 0) {
|
||||
config->repeat_rate = fallback->repeat_rate;
|
||||
}
|
||||
if (config->repeat_delay <= 0) {
|
||||
config->repeat_delay = fallback->repeat_delay;
|
||||
}
|
||||
}
|
||||
|
||||
struct roots_keyboard *roots_keyboard_create(struct wlr_input_device *device,
|
||||
|
|
@ -337,8 +343,7 @@ struct roots_keyboard *roots_keyboard_create(struct wlr_input_device *device,
|
|||
keyboard_config_merge(config, &env_config);
|
||||
keyboard->config = config;
|
||||
|
||||
struct xkb_rule_names rules;
|
||||
memset(&rules, 0, sizeof(rules));
|
||||
struct xkb_rule_names rules = { 0 };
|
||||
rules.rules = config->rules;
|
||||
rules.model = config->model;
|
||||
rules.layout = config->layout;
|
||||
|
|
@ -353,6 +358,10 @@ struct roots_keyboard *roots_keyboard_create(struct wlr_input_device *device,
|
|||
&rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
|
||||
xkb_context_unref(context);
|
||||
|
||||
int repeat_rate = (config->repeat_rate > 0) ? config->repeat_rate : 25;
|
||||
int repeat_delay = (config->repeat_delay > 0) ? config->repeat_delay : 600;
|
||||
wlr_keyboard_set_repeat_info(device->keyboard, repeat_rate, repeat_delay);
|
||||
|
||||
return keyboard;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,6 @@ sources = [
|
|||
'main.c',
|
||||
'output.c',
|
||||
'seat.c',
|
||||
'xcursor.c',
|
||||
'xdg_shell_v6.c',
|
||||
'wl_shell.c',
|
||||
]
|
||||
|
|
|
|||
|
|
@ -6,7 +6,6 @@
|
|||
#include <wlr/types/wlr_output_layout.h>
|
||||
#include <wlr/types/wlr_compositor.h>
|
||||
#include <wlr/types/wlr_wl_shell.h>
|
||||
#include <wlr/types/wlr_xcursor_manager.h>
|
||||
#include <wlr/types/wlr_xdg_shell_v6.h>
|
||||
#include <wlr/render/matrix.h>
|
||||
#include <wlr/util/log.h>
|
||||
|
|
@ -264,8 +263,15 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
|
|||
|
||||
static void set_mode(struct wlr_output *output,
|
||||
struct roots_output_config *oc) {
|
||||
struct wlr_output_mode *mode, *best = NULL;
|
||||
int mhz = (int)(oc->mode.refresh_rate * 1000);
|
||||
|
||||
if (wl_list_empty(&output->modes)) {
|
||||
// Output has no mode, try setting a custom one
|
||||
wlr_output_set_custom_mode(output, oc->mode.width, oc->mode.height, mhz);
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_output_mode *mode, *best = NULL;
|
||||
wl_list_for_each(mode, &output->modes, link) {
|
||||
if (mode->width == oc->mode.width && mode->height == oc->mode.height) {
|
||||
if (mode->refresh == mhz) {
|
||||
|
|
@ -291,7 +297,7 @@ void output_add_notify(struct wl_listener *listener, void *data) {
|
|||
struct roots_config *config = desktop->config;
|
||||
|
||||
wlr_log(L_DEBUG, "Output '%s' added", wlr_output->name);
|
||||
wlr_log(L_DEBUG, "%s %s %s %"PRId32"mm x %"PRId32"mm", wlr_output->make,
|
||||
wlr_log(L_DEBUG, "'%s %s %s' %"PRId32"mm x %"PRId32"mm", wlr_output->make,
|
||||
wlr_output->model, wlr_output->serial, wlr_output->phys_width,
|
||||
wlr_output->phys_height);
|
||||
if (wl_list_length(&wlr_output->modes) > 0) {
|
||||
|
|
@ -324,12 +330,6 @@ void output_add_notify(struct wl_listener *listener, void *data) {
|
|||
|
||||
struct roots_seat *seat;
|
||||
wl_list_for_each(seat, &input->seats, link) {
|
||||
if (wlr_xcursor_manager_load(seat->cursor->xcursor_manager,
|
||||
wlr_output->scale)) {
|
||||
wlr_log(L_ERROR, "Cannot load xcursor theme for output '%s' "
|
||||
"with scale %d", wlr_output->name, wlr_output->scale);
|
||||
}
|
||||
|
||||
roots_seat_configure_cursor(seat);
|
||||
roots_seat_configure_xcursor(seat);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -442,8 +442,12 @@ void roots_seat_configure_xcursor(struct roots_seat *seat) {
|
|||
roots_config_get_cursor(seat->input->config, seat->seat->name);
|
||||
if (cc != NULL) {
|
||||
cursor_theme = cc->theme;
|
||||
if (cc->default_image != NULL) {
|
||||
seat->cursor->default_xcursor = cc->default_image;
|
||||
}
|
||||
}
|
||||
|
||||
if (!seat->cursor->xcursor_manager) {
|
||||
seat->cursor->xcursor_manager =
|
||||
wlr_xcursor_manager_create(cursor_theme, ROOTS_XCURSOR_SIZE);
|
||||
if (seat->cursor->xcursor_manager == NULL) {
|
||||
|
|
@ -451,6 +455,7 @@ void roots_seat_configure_xcursor(struct roots_seat *seat) {
|
|||
cursor_theme);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
struct roots_output *output;
|
||||
wl_list_for_each(output, &seat->input->server->desktop->outputs, link) {
|
||||
|
|
@ -463,7 +468,7 @@ void roots_seat_configure_xcursor(struct roots_seat *seat) {
|
|||
}
|
||||
|
||||
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
|
||||
ROOTS_XCURSOR_DEFAULT, seat->cursor->cursor);
|
||||
seat->cursor->default_xcursor, seat->cursor->cursor);
|
||||
wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
|
||||
seat->cursor->cursor->y);
|
||||
}
|
||||
|
|
@ -661,8 +666,9 @@ void roots_seat_begin_resize(struct roots_seat *seat, struct roots_view *view,
|
|||
view_maximize(view, false);
|
||||
wlr_seat_pointer_clear_focus(seat->seat);
|
||||
|
||||
const char *resize_name = wlr_xcursor_get_resize_name(edges);
|
||||
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
|
||||
roots_xcursor_get_resize_name(edges), seat->cursor->cursor);
|
||||
resize_name, seat->cursor->cursor);
|
||||
}
|
||||
|
||||
void roots_seat_begin_rotate(struct roots_seat *seat, struct roots_view *view) {
|
||||
|
|
|
|||
|
|
@ -1,28 +0,0 @@
|
|||
#define _POSIX_C_SOURCE 200809L
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "rootston/xcursor.h"
|
||||
#include "rootston/input.h"
|
||||
|
||||
const char *roots_xcursor_get_resize_name(uint32_t edges) {
|
||||
if (edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) {
|
||||
if (edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
|
||||
return "ne-resize";
|
||||
} else if (edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
|
||||
return "nw-resize";
|
||||
}
|
||||
return "n-resize";
|
||||
} else if (edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
|
||||
if (edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
|
||||
return "se-resize";
|
||||
} else if (edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
|
||||
return "sw-resize";
|
||||
}
|
||||
return "s-resize";
|
||||
} else if (edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
|
||||
return "e-resize";
|
||||
} else if (edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
|
||||
return "w-resize";
|
||||
}
|
||||
return "se-resize"; // fallback
|
||||
}
|
||||
|
|
@ -102,6 +102,11 @@ void wlr_keyboard_init(struct wlr_keyboard *kb,
|
|||
wl_signal_init(&kb->events.key);
|
||||
wl_signal_init(&kb->events.modifiers);
|
||||
wl_signal_init(&kb->events.keymap);
|
||||
wl_signal_init(&kb->events.repeat_info);
|
||||
|
||||
// Sane defaults
|
||||
kb->repeat_info.rate = 25;
|
||||
kb->repeat_info.delay = 600;
|
||||
}
|
||||
|
||||
void wlr_keyboard_destroy(struct wlr_keyboard *kb) {
|
||||
|
|
@ -167,6 +172,16 @@ void wlr_keyboard_set_keymap(struct wlr_keyboard *kb,
|
|||
wl_signal_emit(&kb->events.keymap, kb);
|
||||
}
|
||||
|
||||
void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate,
|
||||
int32_t delay) {
|
||||
if (kb->repeat_info.rate == rate && kb->repeat_info.delay == delay) {
|
||||
return;
|
||||
}
|
||||
kb->repeat_info.rate = rate;
|
||||
kb->repeat_info.delay = delay;
|
||||
wl_signal_emit(&kb->events.repeat_info, kb);
|
||||
}
|
||||
|
||||
uint32_t wlr_keyboard_get_modifiers(struct wlr_keyboard *kb) {
|
||||
xkb_mod_mask_t mask = kb->modifiers.depressed | kb->modifiers.latched;
|
||||
uint32_t modifiers = 0;
|
||||
|
|
|
|||
|
|
@ -175,6 +175,23 @@ bool wlr_output_set_mode(struct wlr_output *output,
|
|||
return result;
|
||||
}
|
||||
|
||||
bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width,
|
||||
int32_t height, int32_t refresh) {
|
||||
if (!output->impl || !output->impl->set_custom_mode) {
|
||||
return false;
|
||||
}
|
||||
bool result = output->impl->set_custom_mode(output, width, height, refresh);
|
||||
if (result) {
|
||||
wlr_output_update_matrix(output);
|
||||
|
||||
struct wl_resource *resource;
|
||||
wl_resource_for_each(resource, &output->wl_resources) {
|
||||
wlr_output_send_current_mode_to_resource(resource);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void wlr_output_update_size(struct wlr_output *output, int32_t width,
|
||||
int32_t height) {
|
||||
if (output->width == width && output->height == height) {
|
||||
|
|
@ -321,12 +338,20 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
|
|||
wlr_surface_send_frame_done(surface, when);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the cursor box, scaled for its output.
|
||||
*/
|
||||
static void output_cursor_get_box(struct wlr_output_cursor *cursor,
|
||||
struct wlr_box *box) {
|
||||
box->x = cursor->x - cursor->hotspot_x;
|
||||
box->y = cursor->y - cursor->hotspot_y;
|
||||
box->width = cursor->width;
|
||||
box->height = cursor->height;
|
||||
|
||||
if (cursor->surface != NULL) {
|
||||
box->x += cursor->surface->current->sx * cursor->output->scale;
|
||||
box->y += cursor->surface->current->sy * cursor->output->scale;
|
||||
}
|
||||
}
|
||||
|
||||
static void output_cursor_render(struct wlr_output_cursor *cursor,
|
||||
|
|
@ -342,36 +367,23 @@ static void output_cursor_render(struct wlr_output_cursor *cursor,
|
|||
return;
|
||||
}
|
||||
|
||||
struct wlr_box output_box;
|
||||
output_box.x = output_box.y = 0;
|
||||
wlr_output_effective_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);
|
||||
|
||||
struct wlr_box intersection;
|
||||
struct wlr_box *intersection_ptr = &intersection;
|
||||
if (!wlr_box_intersection(&output_box, &cursor_box, &intersection_ptr)) {
|
||||
return;
|
||||
}
|
||||
|
||||
glViewport(0, 0, cursor->output->width, cursor->output->height);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
|
||||
int x = cursor->x - cursor->hotspot_x;
|
||||
int y = cursor->y - cursor->hotspot_y;
|
||||
if (cursor->surface != NULL) {
|
||||
x += cursor->surface->current->sx;
|
||||
y += cursor->surface->current->sy;
|
||||
}
|
||||
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);
|
||||
|
||||
float matrix[16];
|
||||
wlr_texture_get_matrix(texture, &matrix, &cursor->output->transform_matrix,
|
||||
x, y);
|
||||
wlr_matrix_mul(&translate, &scale, &matrix);
|
||||
wlr_matrix_mul(&cursor->output->transform_matrix, &matrix, &matrix);
|
||||
|
||||
wlr_render_with_matrix(renderer, texture, &matrix);
|
||||
|
||||
if (cursor->surface != NULL) {
|
||||
|
|
@ -392,7 +404,8 @@ void wlr_output_swap_buffers(struct wlr_output *output) {
|
|||
|
||||
struct wlr_output_cursor *cursor;
|
||||
wl_list_for_each(cursor, &output->cursors, link) {
|
||||
if (!cursor->enabled || output->hardware_cursor == cursor) {
|
||||
if (!cursor->enabled || !cursor->visible ||
|
||||
output->hardware_cursor == cursor) {
|
||||
continue;
|
||||
}
|
||||
output_cursor_render(cursor, &now);
|
||||
|
|
@ -527,11 +540,39 @@ bool wlr_output_cursor_set_image(struct wlr_output_cursor *cursor,
|
|||
stride, width, height, pixels);
|
||||
}
|
||||
|
||||
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,
|
||||
&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);
|
||||
|
||||
struct wlr_box intersection;
|
||||
struct wlr_box *intersection_ptr = &intersection;
|
||||
bool visible =
|
||||
wlr_box_intersection(&output_box, &cursor_box, &intersection_ptr);
|
||||
|
||||
if (cursor->surface != NULL) {
|
||||
if (cursor->visible && !visible) {
|
||||
wlr_surface_send_leave(cursor->surface, cursor->output);
|
||||
}
|
||||
if (!cursor->visible && visible) {
|
||||
wlr_surface_send_enter(cursor->surface, cursor->output);
|
||||
}
|
||||
}
|
||||
|
||||
cursor->visible = visible;
|
||||
}
|
||||
|
||||
static void output_cursor_commit(struct wlr_output_cursor *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->height = cursor->surface->current->height;
|
||||
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;
|
||||
|
|
@ -564,8 +605,8 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor,
|
|||
return;
|
||||
}
|
||||
|
||||
cursor->hotspot_x = hotspot_x;
|
||||
cursor->hotspot_y = hotspot_y;
|
||||
cursor->hotspot_x = hotspot_x * cursor->output->scale;
|
||||
cursor->hotspot_y = hotspot_y * cursor->output->scale;
|
||||
|
||||
if (surface && surface == cursor->surface) {
|
||||
if (cursor->output->hardware_cursor == cursor &&
|
||||
|
|
@ -595,6 +636,9 @@ void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor,
|
|||
wl_signal_add(&surface->events.commit, &cursor->surface_commit);
|
||||
wl_signal_add(&surface->events.destroy, &cursor->surface_destroy);
|
||||
output_cursor_commit(cursor);
|
||||
|
||||
cursor->visible = false;
|
||||
output_cursor_update_visible(cursor);
|
||||
} else {
|
||||
cursor->enabled = false;
|
||||
cursor->width = 0;
|
||||
|
|
@ -610,6 +654,7 @@ bool wlr_output_cursor_move(struct wlr_output_cursor *cursor,
|
|||
y *= cursor->output->scale;
|
||||
cursor->x = x;
|
||||
cursor->y = y;
|
||||
output_cursor_update_visible(cursor);
|
||||
|
||||
if (cursor->output->hardware_cursor != cursor) {
|
||||
cursor->output->needs_swap = true;
|
||||
|
|
|
|||
|
|
@ -109,10 +109,18 @@ static void seat_client_send_keymap(struct wlr_seat_client *client,
|
|||
wl_keyboard_send_keymap(client->keyboard,
|
||||
WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, keyboard->keymap_fd,
|
||||
keyboard->keymap_size);
|
||||
}
|
||||
|
||||
static void seat_client_send_repeat_info(struct wlr_seat_client *client,
|
||||
struct wlr_keyboard *keyboard) {
|
||||
if (!keyboard || !client->keyboard) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (wl_resource_get_version(client->keyboard) >=
|
||||
WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
|
||||
wl_keyboard_send_repeat_info(client->keyboard, 25, 600);
|
||||
wl_keyboard_send_repeat_info(client->keyboard,
|
||||
keyboard->repeat_info.rate, keyboard->repeat_info.delay);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -138,8 +146,9 @@ static void wl_seat_get_keyboard(struct wl_client *client,
|
|||
wl_resource_set_implementation(seat_client->keyboard, &wl_keyboard_impl,
|
||||
seat_client, &wl_keyboard_destroy);
|
||||
|
||||
seat_client_send_keymap(seat_client,
|
||||
seat_client->seat->keyboard_state.keyboard);
|
||||
struct wlr_keyboard *keyboard = seat_client->seat->keyboard_state.keyboard;
|
||||
seat_client_send_keymap(seat_client, keyboard);
|
||||
seat_client_send_repeat_info(seat_client, keyboard);
|
||||
|
||||
// TODO possibly handle the case where this keyboard needs an enter
|
||||
// right away
|
||||
|
|
@ -706,6 +715,16 @@ static void handle_keyboard_keymap(struct wl_listener *listener, void *data) {
|
|||
}
|
||||
}
|
||||
|
||||
static void handle_keyboard_repeat_info(struct wl_listener *listener,
|
||||
void *data) {
|
||||
struct wlr_seat_keyboard_state *state =
|
||||
wl_container_of(listener, state, keyboard_repeat_info);
|
||||
struct wlr_seat_client *client;
|
||||
wl_list_for_each(client, &state->seat->clients, link) {
|
||||
seat_client_send_repeat_info(client, state->keyboard);
|
||||
}
|
||||
}
|
||||
|
||||
static void handle_keyboard_destroy(struct wl_listener *listener, void *data) {
|
||||
struct wlr_seat_keyboard_state *state =
|
||||
wl_container_of(listener, state, keyboard_destroy);
|
||||
|
|
@ -724,22 +743,28 @@ void wlr_seat_set_keyboard(struct wlr_seat *seat,
|
|||
if (seat->keyboard_state.keyboard) {
|
||||
wl_list_remove(&seat->keyboard_state.keyboard_destroy.link);
|
||||
wl_list_remove(&seat->keyboard_state.keyboard_keymap.link);
|
||||
wl_list_remove(&seat->keyboard_state.keyboard_repeat_info.link);
|
||||
seat->keyboard_state.keyboard = NULL;
|
||||
}
|
||||
|
||||
if (device) {
|
||||
assert(device->type == WLR_INPUT_DEVICE_KEYBOARD);
|
||||
|
||||
wl_signal_add(&device->events.destroy,
|
||||
&seat->keyboard_state.keyboard_destroy);
|
||||
seat->keyboard_state.keyboard_destroy.notify = handle_keyboard_destroy;
|
||||
|
||||
wl_signal_add(&device->keyboard->events.keymap,
|
||||
&seat->keyboard_state.keyboard_keymap);
|
||||
seat->keyboard_state.keyboard_keymap.notify = handle_keyboard_keymap;
|
||||
wl_signal_add(&device->keyboard->events.repeat_info,
|
||||
&seat->keyboard_state.keyboard_repeat_info);
|
||||
seat->keyboard_state.keyboard_repeat_info.notify =
|
||||
handle_keyboard_repeat_info;
|
||||
|
||||
struct wlr_seat_client *client;
|
||||
wl_list_for_each(client, &seat->clients, link) {
|
||||
seat_client_send_keymap(client, device->keyboard);
|
||||
seat_client_send_repeat_info(client, device->keyboard);
|
||||
}
|
||||
|
||||
seat->keyboard_state.keyboard = device->keyboard;
|
||||
|
|
@ -846,7 +871,6 @@ void wlr_seat_keyboard_enter(struct wlr_seat *seat,
|
|||
surface->resource, &keys);
|
||||
wl_array_release(&keys);
|
||||
|
||||
wlr_seat_keyboard_send_modifiers(seat);
|
||||
wlr_seat_client_send_selection(client);
|
||||
}
|
||||
|
||||
|
|
@ -868,6 +892,12 @@ void wlr_seat_keyboard_enter(struct wlr_seat *seat,
|
|||
|
||||
seat->keyboard_state.focused_client = client;
|
||||
seat->keyboard_state.focused_surface = surface;
|
||||
|
||||
if (client && client->keyboard && seat->keyboard_state.keyboard) {
|
||||
// tell new client about any modifier change last,
|
||||
// as it targets seat->keyboard_state.focused_client
|
||||
wlr_seat_keyboard_send_modifiers(seat);
|
||||
}
|
||||
}
|
||||
|
||||
void wlr_seat_keyboard_notify_enter(struct wlr_seat *seat, struct
|
||||
|
|
|
|||
|
|
@ -326,3 +326,26 @@ static int wlr_xcursor_frame_and_duration(struct wlr_xcursor *cursor,
|
|||
int wlr_xcursor_frame(struct wlr_xcursor *_cursor, uint32_t time) {
|
||||
return wlr_xcursor_frame_and_duration(_cursor, time, NULL);
|
||||
}
|
||||
|
||||
const char *wlr_xcursor_get_resize_name(enum wlr_edges edges) {
|
||||
if (edges & WLR_EDGE_TOP) {
|
||||
if (edges & WLR_EDGE_RIGHT) {
|
||||
return "ne-resize";
|
||||
} else if (edges & WLR_EDGE_LEFT) {
|
||||
return "nw-resize";
|
||||
}
|
||||
return "n-resize";
|
||||
} else if (edges & WLR_EDGE_BOTTOM) {
|
||||
if (edges & WLR_EDGE_RIGHT) {
|
||||
return "se-resize";
|
||||
} else if (edges & WLR_EDGE_LEFT) {
|
||||
return "sw-resize";
|
||||
}
|
||||
return "s-resize";
|
||||
} else if (edges & WLR_EDGE_RIGHT) {
|
||||
return "e-resize";
|
||||
} else if (edges & WLR_EDGE_LEFT) {
|
||||
return "w-resize";
|
||||
}
|
||||
return "se-resize"; // fallback
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include <xcb/xcb_image.h>
|
||||
#include <xcb/render.h>
|
||||
#include "wlr/util/log.h"
|
||||
#include "wlr/util/edges.h"
|
||||
#include "wlr/types/wlr_surface.h"
|
||||
#include "wlr/xwayland.h"
|
||||
#include "wlr/xcursor.h"
|
||||
|
|
@ -742,14 +743,43 @@ static void xwm_handle_surface_id_message(struct wlr_xwm *xwm,
|
|||
#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD 10 // move via keyboard
|
||||
#define _NET_WM_MOVERESIZE_CANCEL 11 // cancel operation
|
||||
|
||||
static enum wlr_edges net_wm_edges_to_wlr(uint32_t net_wm_edges) {
|
||||
enum wlr_edges edges = WLR_EDGE_NONE;
|
||||
|
||||
switch(net_wm_edges) {
|
||||
case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
|
||||
edges = WLR_EDGE_TOP | WLR_EDGE_LEFT;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_TOP:
|
||||
edges = WLR_EDGE_TOP;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
|
||||
edges = WLR_EDGE_TOP | WLR_EDGE_RIGHT;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_RIGHT:
|
||||
edges = WLR_EDGE_RIGHT;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
|
||||
edges = WLR_EDGE_BOTTOM | WLR_EDGE_RIGHT;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
|
||||
edges = WLR_EDGE_BOTTOM;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
|
||||
edges = WLR_EDGE_BOTTOM | WLR_EDGE_LEFT;
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_SIZE_LEFT:
|
||||
edges = WLR_EDGE_LEFT;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return edges;
|
||||
}
|
||||
|
||||
static void xwm_handle_net_wm_moveresize_message(struct wlr_xwm *xwm,
|
||||
xcb_client_message_event_t *ev) {
|
||||
// same as xdg-toplevel-v6
|
||||
// TODO need a common enum for this
|
||||
static const int map[] = {
|
||||
5, 1, 9, 8, 10, 2, 6, 4
|
||||
};
|
||||
|
||||
struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
|
||||
if (!xsurface) {
|
||||
return;
|
||||
|
|
@ -775,7 +805,7 @@ static void xwm_handle_net_wm_moveresize_message(struct wlr_xwm *xwm,
|
|||
case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
|
||||
case _NET_WM_MOVERESIZE_SIZE_LEFT:
|
||||
resize_event.surface = xsurface;
|
||||
resize_event.edges = map[detail];
|
||||
resize_event.edges = net_wm_edges_to_wlr(detail);
|
||||
wl_signal_emit(&xsurface->events.request_resize, &resize_event);
|
||||
break;
|
||||
case _NET_WM_MOVERESIZE_CANCEL:
|
||||
|
|
|
|||
Loading…
Reference in a new issue