aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--examples/shared.c42
-rw-r--r--examples/shared.h3
-rw-r--r--include/rootston/desktop.h3
-rw-r--r--include/rootston/input.h13
-rw-r--r--include/rootston/view.h4
-rw-r--r--include/wlr/types/wlr_surface.h49
-rw-r--r--include/wlr/xwayland.h3
-rw-r--r--rootston/cursor.c54
-rw-r--r--rootston/desktop.c77
-rw-r--r--rootston/input.c11
-rw-r--r--rootston/keyboard.c5
-rw-r--r--rootston/main.c2
-rw-r--r--rootston/meson.build1
-rw-r--r--rootston/output.c64
-rw-r--r--rootston/tablet_tool.c24
-rw-r--r--rootston/wl_shell.c27
-rw-r--r--rootston/xdg_shell_v6.c30
-rw-r--r--rootston/xwayland.c19
-rw-r--r--types/wlr_compositor.c101
-rw-r--r--types/wlr_surface.c576
-rw-r--r--types/wlr_xdg_shell_v6.c33
-rw-r--r--xwayland/xwm.c18
22 files changed, 921 insertions, 238 deletions
diff --git a/examples/shared.c b/examples/shared.c
index 3fa7cd05..bb1d2737 100644
--- a/examples/shared.c
+++ b/examples/shared.c
@@ -1,4 +1,5 @@
#define _POSIX_C_SOURCE 200112L
+#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
@@ -18,27 +19,15 @@
#include <wlr/util/log.h>
#include "shared.h"
-
-static void keyboard_led_update(struct keyboard_state *kbstate) {
- uint32_t leds = 0;
- for (uint32_t i = 0; i < WLR_LED_LAST; ++i) {
- if (xkb_state_led_index_is_active(kbstate->xkb_state, kbstate->leds[i])) {
- leds |= (1 << i);
- }
- }
- wlr_keyboard_led_update(kbstate->device->keyboard, leds);
-}
-
static void keyboard_key_notify(struct wl_listener *listener, void *data) {
struct wlr_event_keyboard_key *event = data;
struct keyboard_state *kbstate = wl_container_of(listener, kbstate, key);
uint32_t keycode = event->keycode + 8;
enum wlr_key_state key_state = event->state;
const xkb_keysym_t *syms;
- int nsyms = xkb_state_key_get_syms(kbstate->xkb_state, keycode, &syms);
- xkb_state_update_key(kbstate->xkb_state, keycode,
- event->state == WLR_KEY_PRESSED ? XKB_KEY_DOWN : XKB_KEY_UP);
- keyboard_led_update(kbstate);
+ int nsyms = xkb_state_key_get_syms(kbstate->device->keyboard->xkb_state,
+ keycode, &syms);
+
for (int i = 0; i < nsyms; ++i) {
xkb_keysym_t sym = syms[i];
char name[64];
@@ -88,26 +77,9 @@ static void keyboard_add(struct wlr_input_device *device, struct compositor_stat
wlr_log(L_ERROR, "Failed to create XKB context");
exit(1);
}
- kbstate->keymap = xkb_map_new_from_names(
- context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
- if (!kbstate->keymap) {
- wlr_log(L_ERROR, "Failed to create XKB keymap");
- exit(1);
- }
+ wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(context,
+ &rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_context_unref(context);
- kbstate->xkb_state = xkb_state_new(kbstate->keymap);
- if (!kbstate->xkb_state) {
- wlr_log(L_ERROR, "Failed to create XKB state");
- exit(1);
- }
- const char *led_names[3] = {
- XKB_LED_NAME_NUM,
- XKB_LED_NAME_CAPS,
- XKB_LED_NAME_SCROLL
- };
- for (uint32_t i = 0; i < 3; ++i) {
- kbstate->leds[i] = xkb_map_led_get_index(kbstate->keymap, led_names[i]);
- }
}
static void pointer_motion_notify(struct wl_listener *listener, void *data) {
@@ -320,8 +292,6 @@ static void keyboard_remove(struct wlr_input_device *device, struct compositor_s
if (!kbstate) {
return;
}
- xkb_state_unref(kbstate->xkb_state);
- xkb_map_unref(kbstate->keymap);
wl_list_remove(&kbstate->link);
wl_list_remove(&kbstate->key.link);
free(kbstate);
diff --git a/examples/shared.h b/examples/shared.h
index f564bffa..cf75f5fe 100644
--- a/examples/shared.h
+++ b/examples/shared.h
@@ -27,9 +27,6 @@ struct keyboard_state {
struct wlr_input_device *device;
struct wl_listener key;
struct wl_list link;
- struct xkb_keymap *keymap;
- struct xkb_state *xkb_state;
- xkb_led_index_t leds[WLR_LED_LAST];
void *data;
};
diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h
index 392b0271..91ac87b7 100644
--- a/include/rootston/desktop.h
+++ b/include/rootston/desktop.h
@@ -52,7 +52,8 @@ struct roots_desktop *desktop_create(struct roots_server *server,
void desktop_destroy(struct roots_desktop *desktop);
void view_destroy(struct roots_view *view);
-struct roots_view *view_at(struct roots_desktop *desktop, int x, int y);
+struct roots_view *view_at(struct roots_desktop *desktop, double lx, double ly,
+ struct wlr_surface **surface, double *sx, double *sy);
void view_activate(struct roots_view *view, bool activate);
void output_add_notify(struct wl_listener *listener, void *data);
diff --git a/include/rootston/input.h b/include/rootston/input.h
index aeab9c0d..ecd53f3b 100644
--- a/include/rootston/input.h
+++ b/include/rootston/input.h
@@ -53,6 +53,13 @@ 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;
@@ -71,6 +78,8 @@ struct roots_input {
enum roots_cursor_mode mode;
struct roots_view *active_view;
int offs_x, offs_y;
+ int view_x, view_y, view_width, view_height;
+ uint32_t resize_edges;
// Ring buffer of input events that could trigger move/resize/rotate
int input_events_idx;
@@ -100,6 +109,8 @@ void pointer_add(struct wlr_input_device *device, struct roots_input *input);
void pointer_remove(struct wlr_input_device *device, struct roots_input *input);
void keyboard_add(struct wlr_input_device *device, struct roots_input *input);
void keyboard_remove(struct wlr_input_device *device, struct roots_input *input);
+void tablet_tool_add(struct wlr_input_device *device, struct roots_input *input);
+void tablet_tool_remove(struct wlr_input_device *device, struct roots_input *input);
void cursor_initialize(struct roots_input *input);
void cursor_load_config(struct roots_config *config,
@@ -110,5 +121,7 @@ const struct roots_input_event *get_input_event(struct roots_input *input,
uint32_t serial);
void view_begin_move(struct roots_input *input, struct wlr_cursor *cursor,
struct roots_view *view);
+void view_begin_resize(struct roots_input *input, struct wlr_cursor *cursor,
+ struct roots_view *view, uint32_t edges);
#endif
diff --git a/include/rootston/view.h b/include/rootston/view.h
index 2bd71104..39ff80db 100644
--- a/include/rootston/view.h
+++ b/include/rootston/view.h
@@ -61,11 +61,15 @@ struct roots_view {
// configure event from the xdg_shell
// If not then this should follow the typical type/impl pattern we use
// elsewhere
+ void (*get_size)(struct roots_view *view, struct wlr_box *box);
void (*get_input_bounds)(struct roots_view *view, struct wlr_box *box);
void (*activate)(struct roots_view *view, bool active);
+ void (*resize)(struct roots_view *view, uint32_t width, uint32_t height);
};
+void view_get_size(struct roots_view *view, struct wlr_box *box);
void view_get_input_bounds(struct roots_view *view, struct wlr_box *box);
void view_activate(struct roots_view *view, bool active);
+void view_resize(struct roots_view *view, uint32_t width, uint32_t height);
#endif
diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h
index 87d421e3..ae278815 100644
--- a/include/wlr/types/wlr_surface.h
+++ b/include/wlr/types/wlr_surface.h
@@ -18,6 +18,8 @@ struct wlr_frame_callback {
#define WLR_SURFACE_INVALID_INPUT_REGION 16
#define WLR_SURFACE_INVALID_TRANSFORM 32
#define WLR_SURFACE_INVALID_SCALE 64
+#define WLR_SURFACE_INVALID_SUBSURFACE_POSITION 128
+#define WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST 256
struct wlr_surface_state {
uint32_t invalid;
@@ -29,13 +31,36 @@ struct wlr_surface_state {
int32_t scale;
int width, height;
int buffer_width, buffer_height;
+
+ struct {
+ int32_t x, y;
+ } subsurface_position;
+
+ struct wl_list frame_callback_list; // wl_surface.frame
+};
+
+struct wlr_subsurface {
+ struct wl_resource *resource;
+ struct wlr_surface *surface;
+ struct wlr_surface *parent;
+
+ struct wlr_surface_state *cached;
+ bool has_cache;
+
+ bool synchronized;
+ bool reordered;
+
+ struct wl_list parent_link;
+ struct wl_list parent_pending_link;
+
+ struct wl_listener parent_destroy_listener;
};
struct wlr_surface {
struct wl_resource *resource;
struct wlr_renderer *renderer;
struct wlr_texture *texture;
- struct wlr_surface_state current, pending;
+ struct wlr_surface_state *current, *pending;
const char *role; // the lifetime-bound role or null
float buffer_to_surface_matrix[16];
@@ -47,11 +72,16 @@ struct wlr_surface {
struct wl_signal destroy;
} signals;
- struct wl_list frame_callback_list; // wl_surface.frame
-
- struct wl_listener compositor_listener; // destroy listener used by compositor
+ // destroy listener used by compositor
+ struct wl_listener compositor_listener;
void *compositor_data;
+ // subsurface properties
+ struct wlr_subsurface *subsurface;
+ struct wl_list subsurface_list; // wlr_subsurface::parent_link
+
+ // wlr_subsurface::parent_pending_link
+ struct wl_list subsurface_pending_list;
void *data;
};
@@ -80,4 +110,15 @@ void wlr_surface_get_matrix(struct wlr_surface *surface,
int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
struct wl_resource *error_resource, uint32_t error_code);
+/**
+ * Create the subsurface implementation for this surface.
+ */
+void wlr_surface_make_subsurface(struct wlr_surface *surface,
+ struct wlr_surface *parent, uint32_t id);
+
+/**
+ * Get the top of the subsurface tree for this surface.
+ */
+struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface);
+
#endif
diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 43133567..3525ff3b 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -81,7 +81,8 @@ struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display,
void wlr_xwayland_surface_activate(struct wlr_xwayland *wlr_xwayland,
struct wlr_xwayland_surface *surface);
void wlr_xwayland_surface_configure(struct wlr_xwayland *wlr_xwayland,
- struct wlr_xwayland_surface *surface);
+ struct wlr_xwayland_surface *surface, int16_t x, int16_t y,
+ uint16_t width, uint16_t height);
void wlr_xwayland_surface_close(struct wlr_xwayland *wlr_xwayland,
struct wlr_xwayland_surface *surface);
diff --git a/rootston/cursor.c b/rootston/cursor.c
index 2742e7cd..c24e6989 100644
--- a/rootston/cursor.c
+++ b/rootston/cursor.c
@@ -29,18 +29,33 @@ void view_begin_move(struct roots_input *input, struct wlr_cursor *cursor,
wlr_seat_pointer_clear_focus(input->wl_seat);
}
+void view_begin_resize(struct roots_input *input, struct wlr_cursor *cursor,
+ struct roots_view *view, uint32_t edges) {
+ input->mode = ROOTS_CURSOR_RESIZE;
+ wlr_log(L_DEBUG, "begin resize");
+ input->offs_x = cursor->x;
+ input->offs_y = cursor->y;
+ input->view_x = view->x;
+ input->view_y = view->y;
+ struct wlr_box size;
+ view_get_size(view, &size);
+ input->view_width = size.width;
+ input->view_height = size.height;
+ input->resize_edges = edges;
+ wlr_seat_pointer_clear_focus(input->wl_seat);
+}
+
void cursor_update_position(struct roots_input *input, uint32_t time) {
struct roots_desktop *desktop = input->server->desktop;
struct roots_view *view;
+ struct wlr_surface *surface;
+ double sx, sy;
switch (input->mode) {
case ROOTS_CURSOR_PASSTHROUGH:
- view = view_at(desktop, input->cursor->x, input->cursor->y);
+ view = view_at(desktop, input->cursor->x, input->cursor->y, &surface,
+ &sx, &sy);
if (view) {
- struct wlr_box box;
- view_get_input_bounds(view, &box);
- double sx = input->cursor->x - view->x;
- double sy = input->cursor->y - view->y;
- wlr_seat_pointer_enter(input->wl_seat, view->wlr_surface, sx, sy);
+ wlr_seat_pointer_enter(input->wl_seat, surface, sx, sy);
wlr_seat_pointer_send_motion(input->wl_seat, time, sx, sy);
} else {
wlr_seat_pointer_clear_focus(input->wl_seat);
@@ -53,6 +68,27 @@ void cursor_update_position(struct roots_input *input, uint32_t time) {
}
break;
case ROOTS_CURSOR_RESIZE:
+ if (input->active_view) {
+ int dx = input->cursor->x - input->offs_x;
+ int dy = input->cursor->y - input->offs_y;
+ int width = input->view_width;
+ int height = input->view_height;
+ if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_TOP) {
+ input->active_view->y = input->view_y + dy;
+ height -= dy;
+ }
+ if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_BOTTOM) {
+ height += dy;
+ }
+ if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_LEFT) {
+ input->active_view->x = input->view_x + dx;
+ width -= dx;
+ }
+ if (input->resize_edges & ROOTS_CURSOR_RESIZE_EDGE_RIGHT) {
+ width += dx;
+ }
+ view_resize(input->active_view, width, height);
+ }
break;
case ROOTS_CURSOR_ROTATE:
break;
@@ -109,8 +145,10 @@ static void do_cursor_button_press(struct roots_input *input,
struct wlr_cursor *cursor, struct wlr_input_device *device,
uint32_t time, uint32_t button, uint32_t state) {
struct roots_desktop *desktop = input->server->desktop;
+ struct wlr_surface *surface;
+ double sx, sy;
struct roots_view *view = view_at(desktop,
- input->cursor->x, input->cursor->y);
+ input->cursor->x, input->cursor->y, &surface, &sx, &sy);
uint32_t serial = wlr_seat_pointer_send_button(
input->wl_seat, time, button, state);
int i;
@@ -128,7 +166,7 @@ static void do_cursor_button_press(struct roots_input *input,
% (sizeof(input->input_events) / sizeof(input->input_events[0]));
set_view_focus(input, desktop, view);
if (view) {
- wlr_seat_keyboard_enter(input->wl_seat, view->wlr_surface);
+ wlr_seat_keyboard_enter(input->wl_seat, surface);
}
break;
}
diff --git a/rootston/desktop.c b/rootston/desktop.c
index cd417755..8d1d34d6 100644
--- a/rootston/desktop.c
+++ b/rootston/desktop.c
@@ -25,14 +25,24 @@ void view_destroy(struct roots_view *view) {
free(view);
}
+void view_get_size(struct roots_view *view, struct wlr_box *box) {
+ if (view->get_size) {
+ view->get_size(view, box);
+ return;
+ }
+ box->x = box->y = 0;
+ box->width = view->wlr_surface->current->width;
+ box->height = view->wlr_surface->current->height;
+}
+
void view_get_input_bounds(struct roots_view *view, struct wlr_box *box) {
if (view->get_input_bounds) {
view->get_input_bounds(view, box);
return;
}
box->x = box->y = 0;
- box->width = view->wlr_surface->current.width;
- box->height = view->wlr_surface->current.height;
+ box->width = view->wlr_surface->current->width;
+ box->height = view->wlr_surface->current->height;
}
void view_activate(struct roots_view *view, bool activate) {
@@ -41,14 +51,66 @@ void view_activate(struct roots_view *view, bool activate) {
}
}
-struct roots_view *view_at(struct roots_desktop *desktop, int x, int y) {
- for (size_t i = 0; i < desktop->views->length; ++i) {
+void view_resize(struct roots_view *view, uint32_t width, uint32_t height) {
+ if (view->resize) {
+ view->resize(view, width, height);
+ }
+}
+
+static struct wlr_subsurface *subsurface_at(struct wlr_surface *surface,
+ double sx, double sy, double *sub_x, double *sub_y) {
+ struct wlr_subsurface *subsurface;
+ wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
+ double _sub_x = subsurface->surface->current->subsurface_position.x;
+ double _sub_y = subsurface->surface->current->subsurface_position.y;
+ struct wlr_subsurface *sub =
+ subsurface_at(subsurface->surface, _sub_x + sx, _sub_y + sy,
+ sub_x, sub_y);
+ if (sub) {
+ // TODO: convert sub_x and sub_y to the parent coordinate system
+ return sub;
+ }
+
+ int sub_width = subsurface->surface->current->buffer_width;
+ int sub_height = subsurface->surface->current->buffer_height;
+ if ((sx > _sub_x && sx < _sub_x + sub_width) &&
+ (sy > _sub_y && sub_y < sub_y + sub_height)) {
+ *sub_x = _sub_x;
+ *sub_y = _sub_y;
+ return subsurface;
+ }
+ }
+
+ return NULL;
+}
+
+struct roots_view *view_at(struct roots_desktop *desktop, double lx, double ly,
+ struct wlr_surface **surface, double *sx, double *sy) {
+ for (int i = desktop->views->length - 1; i >= 0; --i) {
struct roots_view *view = desktop->views->items[i];
+
+ double view_sx = lx - view->x;
+ double view_sy = ly - view->y;
+
+ double sub_x, sub_y;
+ struct wlr_subsurface *subsurface =
+ subsurface_at(view->wlr_surface, view_sx, view_sy, &sub_x, &sub_y);
+
+ if (subsurface) {
+ *sx = view_sx - sub_x;
+ *sy = view_sy - sub_y;
+ *surface = subsurface->surface;
+ return view;
+ }
+
struct wlr_box box;
view_get_input_bounds(view, &box);
box.x += view->x;
box.y += view->y;
- if (wlr_box_contains_point(&box, x, y)) {
+ if (wlr_box_contains_point(&box, lx, ly)) {
+ *sx = view_sx;
+ *sy = view_sy;
+ *surface = view->wlr_surface;
return view;
}
}
@@ -78,11 +140,6 @@ struct roots_desktop *desktop_create(struct roots_server *server,
desktop->compositor = wlr_compositor_create(
server->wl_display, server->renderer);
- wlr_cursor_attach_output_layout(server->input->cursor, desktop->layout);
- wlr_cursor_map_to_region(server->input->cursor, config->cursor.mapped_box);
- cursor_load_config(config, server->input->cursor,
- server->input, desktop);
-
desktop->xdg_shell_v6 = wlr_xdg_shell_v6_create(server->wl_display);
wl_signal_add(&desktop->xdg_shell_v6->events.new_surface,
&desktop->xdg_shell_v6_surface);
diff --git a/rootston/input.c b/rootston/input.c
index b4427212..9700b840 100644
--- a/rootston/input.c
+++ b/rootston/input.c
@@ -40,7 +40,7 @@ static void input_add_notify(struct wl_listener *listener, void *data) {
//touch_add(device, input);
break;
case WLR_INPUT_DEVICE_TABLET_TOOL:
- //tablet_tool_add(device, input);
+ tablet_tool_add(device, input);
break;
default:
break;
@@ -61,7 +61,7 @@ static void input_remove_notify(struct wl_listener *listener, void *data) {
//touch_remove(device, input);
break;
case WLR_INPUT_DEVICE_TABLET_TOOL:
- //tablet_tool_remove(device, input);
+ tablet_tool_remove(device, input);
break;
default:
break;
@@ -71,6 +71,8 @@ static void input_remove_notify(struct wl_listener *listener, void *data) {
struct roots_input *input_create(struct roots_server *server,
struct roots_config *config) {
wlr_log(L_DEBUG, "Initializing roots input");
+ assert(server->desktop);
+
struct roots_input *input = calloc(1, sizeof(struct roots_input));
assert(input);
@@ -104,6 +106,11 @@ struct roots_input *input_create(struct roots_server *server,
cursor_initialize(input);
wlr_cursor_set_xcursor(input->cursor, input->xcursor);
+ wlr_cursor_attach_output_layout(input->cursor, server->desktop->layout);
+ wlr_cursor_map_to_region(input->cursor, config->cursor.mapped_box);
+ cursor_load_config(config, input->cursor,
+ input, server->desktop);
+
return input;
}
diff --git a/rootston/keyboard.c b/rootston/keyboard.c
index c4c98c91..003aab98 100644
--- a/rootston/keyboard.c
+++ b/rootston/keyboard.c
@@ -59,9 +59,8 @@ void keyboard_add(struct wlr_input_device *device, struct roots_input *input) {
rules.options = getenv("XKB_DEFAULT_OPTIONS");
struct xkb_context *context;
assert(context = xkb_context_new(XKB_CONTEXT_NO_FLAGS));
- wlr_keyboard_set_keymap(device->keyboard,
- xkb_map_new_from_names(context, &rules,
- XKB_KEYMAP_COMPILE_NO_FLAGS));
+ wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(context,
+ &rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_context_unref(context);
wlr_seat_attach_keyboard(input->wl_seat, device);
}
diff --git a/rootston/main.c b/rootston/main.c
index c8ec1249..7b1ca298 100644
--- a/rootston/main.c
+++ b/rootston/main.c
@@ -20,8 +20,8 @@ int main(int argc, char **argv) {
assert(server.renderer = wlr_gles2_renderer_create(server.backend));
wl_display_init_shm(server.wl_display);
- server.input = input_create(&server, server.config);
server.desktop = desktop_create(&server, server.config);
+ server.input = input_create(&server, server.config);
server.data_device_manager = wlr_data_device_manager_create(
server.wl_display);
diff --git a/rootston/meson.build b/rootston/meson.build
index 59f73e96..1eb0704d 100644
--- a/rootston/meson.build
+++ b/rootston/meson.build
@@ -9,6 +9,7 @@ executable(
'main.c',
'output.c',
'pointer.c',
+ 'tablet_tool.c',
'xdg_shell_v6.c',
'xwayland.c',
'wl_shell.c',
diff --git a/rootston/output.c b/rootston/output.c
index 5aeb71b1..14d1783e 100644
--- a/rootston/output.c
+++ b/rootston/output.c
@@ -16,28 +16,49 @@ static inline int64_t timespec_to_msec(const struct timespec *a) {
return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000;
}
-static void render_view(struct roots_desktop *desktop,
- struct wlr_output *wlr_output, struct timespec *when,
- struct roots_view *view, double ox, double oy) {
- struct wlr_surface *surface = view->wlr_surface;
- float matrix[16];
- float transform[16];
+static void render_surface(struct wlr_surface *surface,
+ struct roots_desktop *desktop, struct wlr_output *wlr_output,
+ struct timespec *when, double lx, double ly) {
wlr_surface_flush_damage(surface);
if (surface->texture->valid) {
- wlr_matrix_translate(&transform, ox, oy, 0);
- wlr_surface_get_matrix(surface, &matrix,
- &wlr_output->transform_matrix, &transform);
- wlr_render_with_matrix(desktop->server->renderer,
- surface->texture, &matrix);
-
- struct wlr_frame_callback *cb, *cnext;
- wl_list_for_each_safe(cb, cnext, &surface->frame_callback_list, link) {
- wl_callback_send_done(cb->resource, timespec_to_msec(when));
- wl_resource_destroy(cb->resource);
+ int width = surface->current->buffer_width;
+ int height = surface->current->buffer_height;
+ double ox = lx, oy = ly;
+ wlr_output_layout_output_coords(desktop->layout, wlr_output, &ox, &oy);
+
+ if (wlr_output_layout_intersects(desktop->layout, wlr_output,
+ lx, ly, lx + width, ly + height)) {
+ float matrix[16];
+ float transform[16];
+ wlr_matrix_translate(&transform, ox, oy, 0);
+ wlr_surface_get_matrix(surface, &matrix,
+ &wlr_output->transform_matrix, &transform);
+ wlr_render_with_matrix(desktop->server->renderer,
+ surface->texture, &matrix);
+
+ struct wlr_frame_callback *cb, *cnext;
+ wl_list_for_each_safe(cb, cnext,
+ &surface->current->frame_callback_list, link) {
+ wl_callback_send_done(cb->resource, timespec_to_msec(when));
+ wl_resource_destroy(cb->resource);
+ }
+ }
+
+ struct wlr_subsurface *subsurface;
+ wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
+ render_surface(subsurface->surface, desktop, wlr_output, when,
+ lx + subsurface->surface->current->subsurface_position.x,
+ ly + subsurface->surface->current->subsurface_position.y);
}
}
}
+static void render_view(struct roots_view *view, struct roots_desktop *desktop,
+ struct wlr_output *wlr_output, struct timespec *when) {
+ render_surface(view->wlr_surface, desktop, wlr_output, when,
+ view->x, view->y);
+}
+
static void output_frame_notify(struct wl_listener *listener, void *data) {
struct wlr_output *wlr_output = data;
struct roots_output *output = wl_container_of(listener, output, frame);
@@ -52,16 +73,7 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
for (size_t i = 0; i < desktop->views->length; ++i) {
struct roots_view *view = desktop->views->items[i];
- int width = view->wlr_surface->current.buffer_width;
- int height = view->wlr_surface->current.buffer_height;
-
- if (wlr_output_layout_intersects(desktop->layout, wlr_output,
- view->x, view->y, view->x + width, view->y + height)) {
- double ox = view->x, oy = view->y;
- wlr_output_layout_output_coords(
- desktop->layout, wlr_output, &ox, &oy);
- render_view(desktop, wlr_output, &now, view, ox, oy);
- }
+ render_view(view, desktop, wlr_output, &now);
}
wlr_renderer_end(server->renderer);
diff --git a/rootston/tablet_tool.c b/rootston/tablet_tool.c
new file mode 100644
index 00000000..a612e683
--- /dev/null
+++ b/rootston/tablet_tool.c
@@ -0,0 +1,24 @@
+#include <stdlib.h>
+#include <wayland-server.h>
+#include <wlr/types/wlr_input_device.h>
+#include <wlr/types/wlr_pointer.h>
+#include <wlr/util/log.h>
+#include "rootston/input.h"
+
+void tablet_tool_add(struct wlr_input_device *device, struct roots_input *input) {
+ struct roots_tablet_tool *tool = calloc(sizeof(struct roots_tablet_tool), 1);
+ device->data = tool;
+ tool->device = device;
+ tool->input = input;
+ wl_list_insert(&input->tablet_tools, &tool->link);
+ wlr_cursor_attach_input_device(input->cursor, device);
+ cursor_load_config(input->server->config, input->cursor,
+ input, input->server->desktop);
+}
+
+void tablet_tool_remove(struct wlr_input_device *device, struct roots_input *input) {
+ struct roots_tablet_tool *tablet_tool = device->data;
+ wlr_cursor_detach_input_device(input->cursor, device);
+ wl_list_remove(&tablet_tool->link);
+ free(tablet_tool);
+}
diff --git a/rootston/wl_shell.c b/rootston/wl_shell.c
index 4189e910..1991d332 100644
--- a/rootston/wl_shell.c
+++ b/rootston/wl_shell.c
@@ -10,7 +10,14 @@
#include "rootston/server.h"
#include "rootston/input.h"
-static void handle_move(struct wl_listener *listener, void *data) {
+static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+ assert(view->type == ROOTS_WL_SHELL_VIEW);
+ struct wlr_wl_shell_surface *surf = view->wl_shell_surface;
+ wlr_wl_shell_surface_configure(surf, WL_SHELL_SURFACE_RESIZE_NONE, width,
+ height);
+}
+
+static void handle_request_move(struct wl_listener *listener, void *data) {
struct roots_wl_shell_surface *roots_surface =
wl_container_of(listener, roots_surface, request_move);
struct roots_view *view = roots_surface->view;
@@ -23,6 +30,19 @@ static void handle_move(struct wl_listener *listener, void *data) {
view_begin_move(input, event->cursor, view);
}
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+ struct roots_wl_shell_surface *roots_surface =
+ wl_container_of(listener, roots_surface, request_resize);
+ struct roots_view *view = roots_surface->view;
+ struct roots_input *input = view->desktop->server->input;
+ struct wlr_wl_shell_surface_resize_event *e = data;
+ const struct roots_input_event *event = get_input_event(input, e->serial);
+ if (!event || input->mode != ROOTS_CURSOR_PASSTHROUGH) {
+ return;
+ }
+ view_begin_resize(input, event->cursor, view, e->edges);
+}
+
static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_wl_shell_surface *roots_surface =
wl_container_of(listener, roots_surface, destroy);
@@ -53,9 +73,11 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
wl_list_init(&roots_surface->ping_timeout.link);
wl_list_init(&roots_surface->request_move.link);
- roots_surface->request_move.notify = handle_move;
+ roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
wl_list_init(&roots_surface->request_resize.link);
+ roots_surface->request_resize.notify = handle_request_resize;
+ wl_signal_add(&surface->events.request_resize, &roots_surface->request_resize);
wl_list_init(&roots_surface->request_set_fullscreen.link);
wl_list_init(&roots_surface->request_set_maximized.link);
@@ -65,6 +87,7 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
view->wl_shell_surface = surface;
view->roots_wl_shell_surface = roots_surface;
view->wlr_surface = surface->surface;
+ view->resize = resize;
view->desktop = desktop;
roots_surface->view = view;
list_add(desktop->views, view);
diff --git a/rootston/xdg_shell_v6.c b/rootston/xdg_shell_v6.c
index e8edaa8f..ab34f52a 100644
--- a/rootston/xdg_shell_v6.c
+++ b/rootston/xdg_shell_v6.c
@@ -10,9 +10,10 @@
#include "rootston/server.h"
#include "rootston/input.h"
-static void get_input_bounds(struct roots_view *view, struct wlr_box *box) {
+static void get_size(struct roots_view *view, struct wlr_box *box) {
assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
+ // TODO: surf->geometry can be NULL
memcpy(box, surf->geometry, sizeof(struct wlr_box));
}
@@ -24,6 +25,14 @@ static void activate(struct roots_view *view, bool active) {
}
}
+static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+ assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
+ struct wlr_xdg_surface_v6 *surf = view->xdg_surface_v6;
+ if (surf->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+ wlr_xdg_toplevel_v6_set_size(surf, width, height);
+ }
+}
+
static void handle_request_move(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, request_move);
@@ -37,6 +46,19 @@ static void handle_request_move(struct wl_listener *listener, void *data) {
view_begin_move(input, event->cursor, view);
}
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+ struct roots_xdg_surface_v6 *roots_xdg_surface =
+ wl_container_of(listener, roots_xdg_surface, request_resize);
+ struct roots_view *view = roots_xdg_surface->view;
+ struct roots_input *input = view->desktop->server->input;
+ struct wlr_xdg_toplevel_v6_resize_event *e = data;
+ const struct roots_input_event *event = get_input_event(input, e->serial);
+ if (!event || input->mode != ROOTS_CURSOR_PASSTHROUGH) {
+ return;
+ }
+ view_begin_resize(input, event->cursor, view, e->edges);
+}
+
static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, destroy);
@@ -71,6 +93,9 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
wl_list_init(&roots_surface->request_resize.link);
+ roots_surface->request_resize.notify = handle_request_resize;
+ wl_signal_add(&surface->events.request_resize,
+ &roots_surface->request_resize);
wl_list_init(&roots_surface->request_show_window_menu.link);
struct roots_view *view = calloc(1, sizeof(struct roots_view));
@@ -79,8 +104,9 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
view->xdg_surface_v6 = surface;
view->roots_xdg_surface_v6 = roots_surface;
view->wlr_surface = surface->surface;
- view->get_input_bounds = get_input_bounds;
+ view->get_size = get_size;
view->activate = activate;
+ view->resize = resize;
view->desktop = desktop;
roots_surface->view = view;
list_add(desktop->views, view);
diff --git a/rootston/xwayland.c b/rootston/xwayland.c
index 181b959d..7ecc4d4f 100644
--- a/rootston/xwayland.c
+++ b/rootston/xwayland.c
@@ -9,6 +9,13 @@
#include "rootston/desktop.h"
#include "rootston/server.h"
+static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
+ assert(view->type == ROOTS_XWAYLAND_VIEW);
+ struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
+ wlr_xwayland_surface_configure(view->desktop->xwayland, xwayland_surface,
+ xwayland_surface->x, xwayland_surface->y, width, height);
+}
+
static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xwayland_surface *roots_surface =
wl_container_of(listener, roots_surface, destroy);
@@ -17,23 +24,18 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
free(roots_surface);
}
-static void handle_configure(struct wl_listener *listener, void *data) {
+static void handle_request_configure(struct wl_listener *listener, void *data) {
struct roots_xwayland_surface *roots_surface =
wl_container_of(listener, roots_surface, request_configure);
struct wlr_xwayland_surface *xwayland_surface =
roots_surface->view->xwayland_surface;
struct wlr_xwayland_surface_configure_event *event = data;
- xwayland_surface->x = event->x;
- xwayland_surface->y = event->y;
- xwayland_surface->width = event->width;
- xwayland_surface->height = event->height;
-
roots_surface->view->x = (double)event->x;
roots_surface->view->y = (double)event->y;
wlr_xwayland_surface_configure(roots_surface->view->desktop->xwayland,
- xwayland_surface);
+ xwayland_surface, event->x, event->y, event->width, event->height);
}
static void activate(struct roots_view *view, bool active) {
@@ -58,7 +60,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
wl_list_init(&roots_surface->request_configure.link);
- roots_surface->request_configure.notify = handle_configure;
+ roots_surface->request_configure.notify = handle_request_configure;
wl_signal_add(&surface->events.request_configure,
&roots_surface->request_configure);
@@ -75,6 +77,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
view->wlr_surface = surface->surface;
view->desktop = desktop;
view->activate = activate;
+ view->resize = resize;
roots_surface->view = view;
list_add(desktop->views, view);
}
diff --git a/types/wlr_compositor.c b/types/wlr_compositor.c
index 0658f65e..12903cda 100644
--- a/types/wlr_compositor.c
+++ b/types/wlr_compositor.c
@@ -19,9 +19,11 @@ static void wl_compositor_create_surface(struct wl_client *client,
compositor->renderer);
surface->compositor_data = compositor;
surface->compositor_listener.notify = &destroy_surface_listener;
- wl_resource_add_destroy_listener(surface_resource, &surface->compositor_listener);
+ wl_resource_add_destroy_listener(surface_resource,
+ &surface->compositor_listener);
- wl_list_insert(&compositor->surfaces, wl_resource_get_link(surface_resource));
+ wl_list_insert(&compositor->surfaces,
+ wl_resource_get_link(surface_resource));
wl_signal_emit(&compositor->events.create_surface, surface);
}
@@ -52,15 +54,17 @@ static void wl_compositor_bind(struct wl_client *wl_client, void *_compositor,
struct wlr_compositor *compositor = _compositor;
assert(wl_client && compositor);
if (version > 4) {
- wlr_log(L_ERROR, "Client requested unsupported wl_compositor version, disconnecting");
+ wlr_log(L_ERROR, "Client requested unsupported wl_compositor version, "
+ "disconnecting");
wl_client_destroy(wl_client);
return;
}
- struct wl_resource *wl_resource = wl_resource_create(
- wl_client, &wl_compositor_interface, version, id);
+ struct wl_resource *wl_resource =
+ wl_resource_create(wl_client, &wl_compositor_interface, version, id);
wl_resource_set_implementation(wl_resource, &wl_compositor_impl,
- compositor, wl_compositor_destroy);
- wl_list_insert(&compositor->wl_resources, wl_resource_get_link(wl_resource));
+ compositor, wl_compositor_destroy);
+ wl_list_insert(&compositor->wl_resources,
+ wl_resource_get_link(wl_resource));
}
void wlr_compositor_destroy(struct wlr_compositor *compositor) {
@@ -68,19 +72,96 @@ void wlr_compositor_destroy(struct wlr_compositor *compositor) {
free(compositor);
}
+static void subcompositor_destroy(struct wl_client *client,
+ struct wl_resource *resource) {
+ wl_resource_destroy(resource);
+}
+
+static void subcompositor_get_subsurface(struct wl_client *client,
+ struct wl_resource *resource, uint32_t id,
+ struct wl_resource *surface_resource,
+ struct wl_resource *parent_resource) {
+ struct wlr_surface *surface = wl_resource_get_user_data(surface_resource);
+ struct wlr_surface *parent = wl_resource_get_user_data(parent_resource);
+
+ static const char msg[] = "get_subsurface: wl_subsurface@";
+
+ if (surface == parent) {
+ wl_resource_post_error(resource,
+ WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
+ "%s%d: wl_surface@%d cannot be its own parent",
+ msg, id, wl_resource_get_id(surface_resource));
+ return;
+ }
+
+ if (surface->subsurface) {
+ wl_resource_post_error(resource,
+ WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
+ "%s%d: wl_surface@%d is already a sub-surface",
+ msg, id, wl_resource_get_id(surface_resource));
+ return;
+ }
+
+ if (wlr_surface_get_main_surface(parent) == surface) {
+ wl_resource_post_error(resource,
+ WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
+ "%s%d: wl_surface@%d is an ancestor of parent",
+ msg, id, wl_resource_get_id(surface_resource));
+ return;
+ }
+
+ if (wlr_surface_set_role(surface, "wl_subsurface", resource,
+ WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE) < 0) {
+ return;
+ }
+
+ wlr_surface_make_subsurface(surface, parent, id);
+ if (!surface->subsurface) {
+ wl_resource_post_no_memory(resource);
+ return;
+ }
+}
+
+
+static const struct wl_subcompositor_interface subcompositor_interface = {
+ .destroy = subcompositor_destroy,
+ .get_subsurface = subcompositor_get_subsurface,
+};
+
+static void subcompositor_bind(struct wl_client *client, void *data,
+ uint32_t version, uint32_t id) {
+ struct wlr_compositor *compositor = data;
+ struct wl_resource *resource =
+ wl_resource_create(client, &wl_subcompositor_interface, 1, id);
+ if (resource == NULL) {
+ wl_client_post_no_memory(client);
+ return;
+ }
+ wl_resource_set_implementation(resource, &subcompositor_interface,
+ compositor, NULL);
+}
+
struct wlr_compositor *wlr_compositor_create(struct wl_display *display,
struct wlr_renderer *renderer) {
- struct wlr_compositor *compositor = calloc(1, sizeof(struct wlr_compositor));
+ struct wlr_compositor *compositor =
+ calloc(1, sizeof(struct wlr_compositor));
if (!compositor) {
wlr_log_errno(L_ERROR, "Could not allocate wlr compositor");
return NULL;
}
- struct wl_global *wl_global = wl_global_create(display,
+
+ struct wl_global *compositor_global = wl_global_create(display,
&wl_compositor_interface, 4, compositor, wl_compositor_bind);
- compositor->wl_global = wl_global;
+
+ compositor->wl_global = compositor_global;
compositor->renderer = renderer;
+
+ wl_global_create(display, &wl_subcompositor_interface, 1, compositor,
+ subcompositor_bind);
+
wl_list_init(&compositor->wl_resources);
wl_list_init(&compositor->surfaces);
wl_signal_init(&compositor->events.create_surface);
+
return compositor;
}
diff --git a/types/wlr_surface.c b/types/wlr_surface.c
index a9a54abe..e44ea9fc 100644
--- a/types/wlr_surface.c
+++ b/types/wlr_surface.c
@@ -7,7 +7,8 @@
#include <wlr/types/wlr_surface.h>
#include <wlr/render/matrix.h>
-static void surface_destroy(struct wl_client *client, struct wl_resource *resource) {
+static void surface_destroy(struct wl_client *client,
+ struct wl_resource *resource) {
wl_resource_destroy(resource);
}
@@ -15,8 +16,9 @@ static void surface_attach(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *buffer, int32_t sx, int32_t sy) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
- surface->pending.invalid |= WLR_SURFACE_INVALID_BUFFER;
- surface->pending.buffer = buffer;
+
+ surface->pending->invalid |= WLR_SURFACE_INVALID_BUFFER;
+ surface->pending->buffer = buffer;
}
static void surface_damage(struct wl_client *client,
@@ -26,9 +28,9 @@ static void surface_damage(struct wl_client *client,
if (width < 0 || height < 0) {
return;
}
- surface->pending.invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE;
- pixman_region32_union_rect(&surface->pending.surface_damage,
- &surface->pending.surface_damage,
+ surface->pending->invalid |= WLR_SURFACE_INVALID_SURFACE_DAMAGE;
+ pixman_region32_union_rect(&surface->pending->surface_damage,
+ &surface->pending->surface_damage,
x, y, width, height);
}
@@ -60,22 +62,24 @@ static void surface_frame(struct wl_client *client,
wl_resource_set_implementation(cb->resource,
NULL, cb, destroy_frame_callback);
- wl_list_insert(surface->frame_callback_list.prev, &cb->link);
+ wl_list_insert(surface->pending->frame_callback_list.prev, &cb->link);
+
+ surface->pending->invalid |= WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST;
}
static void surface_set_opaque_region(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region_resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
- pixman_region32_clear(&surface->pending.opaque);
+ if ((surface->pending->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
+ pixman_region32_clear(&surface->pending->opaque);
}
- surface->pending.invalid |= WLR_SURFACE_INVALID_OPAQUE_REGION;
+ surface->pending->invalid |= WLR_SURFACE_INVALID_OPAQUE_REGION;
if (region_resource) {
pixman_region32_t *region = wl_resource_get_user_data(region_resource);
- pixman_region32_copy(&surface->pending.opaque, region);
+ pixman_region32_copy(&surface->pending->opaque, region);
} else {
- pixman_region32_clear(&surface->pending.opaque);
+ pixman_region32_clear(&surface->pending->opaque);
}
}
@@ -83,28 +87,28 @@ static void surface_set_input_region(struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region_resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_INPUT_REGION)) {
- pixman_region32_clear(&surface->pending.input);
+ if ((surface->pending->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) {
+ pixman_region32_clear(&surface->pending->input);
}
- surface->pending.invalid |= WLR_SURFACE_INVALID_INPUT_REGION;
+ surface->pending->invalid |= WLR_SURFACE_INVALID_INPUT_REGION;
if (region_resource) {
pixman_region32_t *region = wl_resource_get_user_data(region_resource);
- pixman_region32_copy(&surface->pending.input, region);
+ pixman_region32_copy(&surface->pending->input, region);
} else {
- pixman_region32_init_rect(&surface->pending.input,
+ pixman_region32_init_rect(&surface->pending->input,
INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
}
}
-static void wlr_surface_update_size(struct wlr_surface *surface) {
- int scale = surface->current.scale;
- enum wl_output_transform transform = surface->current.transform;
+static void wlr_surface_update_size(struct wlr_surface *surface, struct wlr_surface_state *state) {
+ int scale = state->scale;
+ enum wl_output_transform transform = state->transform;
- wlr_texture_get_buffer_size(surface->texture, surface->current.buffer,
- &surface->current.buffer_width, &surface->current.buffer_height);
+ wlr_texture_get_buffer_size(surface->texture, state->buffer,
+ &state->buffer_width, &state->buffer_height);
- int _width = surface->current.buffer_width / scale;
- int _height = surface->current.buffer_height / scale;
+ int _width = state->buffer_width / scale;
+ int _height = state->buffer_height / scale;
if (transform == WL_OUTPUT_TRANSFORM_90 ||
transform == WL_OUTPUT_TRANSFORM_270 ||
@@ -115,17 +119,18 @@ static void wlr_surface_update_size(struct wlr_surface *surface) {
_height = tmp;
}
- surface->current.width = _width;
- surface->current.height = _height;
+ wl_list_init(&state->frame_callback_list);
+
+ state->width = _width;
+ state->height = _height;
}
-static void wlr_surface_to_buffer_region(struct wlr_surface *surface,
- pixman_region32_t *surface_region, pixman_region32_t *buffer_region,
+static void wlr_surface_to_buffer_region(int scale,
+ enum wl_output_transform transform, pixman_region32_t *surface_region,
+ pixman_region32_t *buffer_region,
int width, int height) {
pixman_box32_t *src_rects, *dest_rects;
int nrects, i;
- int scale = surface->current.scale;
- enum wl_output_transform transform = surface->current.transform;
src_rects = pixman_region32_rectangles(surface_region, &nrects);
dest_rects = malloc(nrects * sizeof(*dest_rects));
@@ -201,89 +206,227 @@ static void wlr_surface_to_buffer_region(struct wlr_surface *surface,
free(dest_rects);
}
-static void surface_commit(struct wl_client *client,
- struct wl_resource *resource) {
- struct wlr_surface *surface = wl_resource_get_user_data(resource);
- bool update_size = false;
+/**
+ * Append pending state to current state and clear pending state.
+ */
+static void wlr_surface_move_state(struct wlr_surface *surface, struct wlr_surface_state *next,
+ struct wlr_surface_state *state) {
bool update_damage = false;
+ bool update_size = false;
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_SCALE)) {
- surface->current.scale = surface->pending.scale;
+ if ((next->invalid & WLR_SURFACE_INVALID_SCALE)) {
+ state->scale = next->scale;
update_size = true;
}
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_TRANSFORM)) {
- surface->current.transform = surface->pending.transform;
+ if ((next->invalid & WLR_SURFACE_INVALID_TRANSFORM)) {
+ state->transform = next->transform;
update_size = true;
}
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER)) {
- surface->current.buffer = surface->pending.buffer;
+ if ((next->invalid & WLR_SURFACE_INVALID_BUFFER)) {
+ if (state->buffer) {
+ wl_resource_post_event(state->buffer, WL_BUFFER_RELEASE);
+ }
+
+ state->buffer = next->buffer;
+ next->buffer = NULL;
update_size = true;
}
if (update_size) {
- int32_t oldw = surface->current.buffer_width;
- int32_t oldh = surface->current.buffer_height;
- wlr_surface_update_size(surface);
-
- surface->reupload_buffer = oldw != surface->current.buffer_width ||
- oldh != surface->current.buffer_height;
- }
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) {
- pixman_region32_union(&surface->current.surface_damage,
- &surface->current.surface_damage,
- &surface->pending.surface_damage);
- pixman_region32_intersect_rect(&surface->current.surface_damage,
- &surface->current.surface_damage, 0, 0, surface->current.width,
- surface->current.height);
-
- pixman_region32_clear(&surface->pending.surface_damage);
+ wlr_surface_update_size(surface, state);
+ }
+ if ((next->invalid & WLR_SURFACE_INVALID_SURFACE_DAMAGE)) {
+ pixman_region32_union(&state->surface_damage,
+ &state->surface_damage,
+ &next->surface_damage);
+ pixman_region32_intersect_rect(&state->surface_damage,
+ &state->surface_damage, 0, 0, state->width,
+ state->height);
+
+ pixman_region32_clear(&next->surface_damage);
update_damage = true;
}
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) {
- pixman_region32_union(&surface->current.buffer_damage,
- &surface->current.buffer_damage,
- &surface->pending.buffer_damage);
+ if ((next->invalid & WLR_SURFACE_INVALID_BUFFER_DAMAGE)) {
+ pixman_region32_union(&state->buffer_damage,
+ &state->buffer_damage,
+ &next->buffer_damage);
- pixman_region32_clear(&surface->pending.buffer_damage);
+ pixman_region32_clear(&next->buffer_damage);
update_damage = true;
}
if (update_damage) {
pixman_region32_t buffer_damage;
pixman_region32_init(&buffer_damage);
- wlr_surface_to_buffer_region(surface, &surface->current.surface_damage,
- &buffer_damage, surface->current.width, surface->current.height);
- pixman_region32_union(&surface->current.buffer_damage,
- &surface->current.buffer_damage, &buffer_damage);
+ wlr_surface_to_buffer_region(state->scale, state->transform,
+ &state->surface_damage, &buffer_damage, state->width,
+ state->height);
+ pixman_region32_union(&state->buffer_damage,
+ &state->buffer_damage, &buffer_damage);
pixman_region32_fini(&buffer_damage);
- pixman_region32_intersect_rect(&surface->current.buffer_damage,
- &surface->current.buffer_damage, 0, 0,
- surface->current.buffer_width, surface->current.buffer_height);
+ pixman_region32_intersect_rect(&state->buffer_damage,
+ &state->buffer_damage, 0, 0,
+ state->buffer_width, state->buffer_height);
}
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
+ if ((next->invalid & WLR_SURFACE_INVALID_OPAQUE_REGION)) {
// TODO: process buffer
- pixman_region32_clear(&surface->pending.opaque);
+ pixman_region32_clear(&next->opaque);
}
- if ((surface->pending.invalid & WLR_SURFACE_INVALID_INPUT_REGION)) {
+ if ((next->invalid & WLR_SURFACE_INVALID_INPUT_REGION)) {
// TODO: process buffer
- pixman_region32_clear(&surface->pending.input);
+ pixman_region32_clear(&next->input);
+ }
+ if ((next->invalid & WLR_SURFACE_INVALID_SUBSURFACE_POSITION)) {
+ state->subsurface_position.x = next->subsurface_position.x;
+ state->subsurface_position.y = next->subsurface_position.y;
+ next->subsurface_position.x = 0;
+ next->subsurface_position.y = 0;
+ }
+ if ((next->invalid & WLR_SURFACE_INVALID_FRAME_CALLBACK_LIST)) {
+ wl_list_insert_list(&state->frame_callback_list, &next->frame_callback_list);
+ wl_list_init(&next->frame_callback_list);
+ }
+
+ state->invalid |= next->invalid;
+ next->invalid = 0;
+}
+
+static void wlr_surface_damage_subsurfaces(struct wlr_subsurface *subsurface) {
+ // XXX: This is probably the wrong way to do it, because this damage should
+ // come from the client, but weston doesn't do it correctly either and it
+ // seems to work ok. See the comment on weston_surface_damage for more info
+ // about a better approach.
+ struct wlr_surface *surface = subsurface->surface;
+ pixman_region32_union_rect(&surface->current->surface_damage,
+ &surface->current->surface_damage,
+ 0, 0, surface->current->width,
+ surface->current->height);
+
+ subsurface->reordered = false;
+
+ struct wlr_subsurface *child;
+ wl_list_for_each(child, &subsurface->surface->subsurface_list, parent_link) {
+ wlr_surface_damage_subsurfaces(child);
+ }
+}
+
+static void wlr_surface_commit_pending(struct wlr_surface *surface) {
+ int32_t oldw = surface->current->buffer_width;
+ int32_t oldh = surface->current->buffer_height;
+
+ wlr_surface_move_state(surface, surface->pending, surface->current);
+
+ // commit subsurface order
+ struct wlr_subsurface *subsurface;
+ wl_list_for_each_reverse(subsurface, &surface->subsurface_pending_list,
+ parent_pending_link) {
+ wl_list_remove(&subsurface->parent_link);
+ wl_list_insert(&surface->subsurface_list, &subsurface->parent_link);
+
+ if (subsurface->reordered) {
+ // TODO: damage all the subsurfaces
+ wlr_surface_damage_subsurfaces(subsurface);
+ }
}
- surface->pending.invalid = 0;
+ surface->reupload_buffer = oldw != surface->current->buffer_width ||
+ oldh != surface->current->buffer_height;
+
// TODO: add the invalid bitfield to this callback
wl_signal_emit(&surface->signals.commit, surface);
}
+static bool wlr_subsurface_is_synchronized(struct wlr_subsurface *subsurface) {
+ while (subsurface) {
+ if (subsurface->synchronized) {
+ return true;
+ }
+
+ if (!subsurface->parent) {
+ return false;
+ }
+
+ subsurface = subsurface->parent->subsurface;
+ }
+
+ return false;
+}
+
+/**
+ * Recursive function to commit the effectively synchronized children.
+ */
+static void wlr_subsurface_parent_commit(struct wlr_subsurface *subsurface,
+ bool synchronized) {
+ struct wlr_surface *surface = subsurface->surface;
+ if (synchronized || subsurface->synchronized) {
+
+ if (subsurface->has_cache) {
+ wlr_surface_move_state(surface, subsurface->cached, surface->pending);
+ wlr_surface_commit_pending(surface);
+ subsurface->has_cache = false;
+ subsurface->cached->invalid = 0;
+ }
+
+ struct wlr_subsurface *tmp;
+ wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
+ wlr_subsurface_parent_commit(tmp, true);
+ }
+ }
+}
+
+static void wlr_subsurface_commit(struct wlr_subsurface *subsurface) {
+ struct wlr_surface *surface = subsurface->surface;
+
+ if (wlr_subsurface_is_synchronized(subsurface)) {
+ wlr_surface_move_state(surface, surface->pending, subsurface->cached);
+ subsurface->has_cache = true;
+ } else {
+ if (subsurface->has_cache) {
+ wlr_surface_move_state(surface, subsurface->cached, surface->pending);
+ wlr_surface_commit_pending(surface);
+ subsurface->has_cache = false;
+
+ } else {
+ wlr_surface_commit_pending(surface);
+ }
+
+ struct wlr_subsurface *tmp;
+ wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
+ wlr_subsurface_parent_commit(tmp, false);
+ }
+ }
+
+}
+
+static void surface_commit(struct wl_client *client,
+ struct wl_resource *resource) {
+ struct wlr_surface *surface = wl_resource_get_user_data(resource);
+ struct wlr_subsurface *subsurface = surface->subsurface;
+
+ if (subsurface) {
+ wlr_subsurface_commit(subsurface);
+ return;
+ }
+
+ wlr_surface_commit_pending(surface);
+
+ struct wlr_subsurface *tmp;
+ wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
+ wlr_subsurface_parent_commit(tmp, false);
+ }
+}
+
void wlr_surface_flush_damage(struct wlr_surface *surface) {
- if (!surface->current.buffer) {
+ if (!surface->current->buffer) {
if (surface->texture->valid) {
// TODO: Detach buffers
}
return;
}
- struct wl_shm_buffer *buffer = wl_shm_buffer_get(surface->current.buffer);
+ struct wl_shm_buffer *buffer = wl_shm_buffer_get(surface->current->buffer);
if (!buffer) {
- if (wlr_renderer_buffer_is_drm(surface->renderer, surface->pending.buffer)) {
- wlr_texture_upload_drm(surface->texture, surface->pending.buffer);
+ if (wlr_renderer_buffer_is_drm(surface->renderer,
+ surface->current->buffer)) {
+ wlr_texture_upload_drm(surface->texture, surface->current->buffer);
goto release;
} else {
wlr_log(L_INFO, "Unknown buffer handle attached");
@@ -295,7 +438,7 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) {
if (surface->reupload_buffer) {
wlr_texture_upload_shm(surface->texture, format, buffer);
} else {
- pixman_region32_t damage = surface->current.buffer_damage;
+ pixman_region32_t damage = surface->current->buffer_damage;
if (!pixman_region32_not_empty(&damage)) {
goto release;
}
@@ -314,26 +457,26 @@ void wlr_surface_flush_damage(struct wlr_surface *surface) {
}
release:
- pixman_region32_clear(&surface->current.surface_damage);
- pixman_region32_clear(&surface->current.buffer_damage);
+ pixman_region32_clear(&surface->current->surface_damage);
+ pixman_region32_clear(&surface->current->buffer_damage);
- wl_resource_post_event(surface->current.buffer, WL_BUFFER_RELEASE);
- surface->current.buffer = NULL;
+ wl_resource_post_event(surface->current->buffer, WL_BUFFER_RELEASE);
+ surface->current->buffer = NULL;
}
static void surface_set_buffer_transform(struct wl_client *client,
struct wl_resource *resource, int transform) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
- surface->pending.invalid |= WLR_SURFACE_INVALID_TRANSFORM;
- surface->pending.transform = transform;
+ surface->pending->invalid |= WLR_SURFACE_INVALID_TRANSFORM;
+ surface->pending->transform = transform;
}
static void surface_set_buffer_scale(struct wl_client *client,
struct wl_resource *resource,
int32_t scale) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
- surface->pending.invalid |= WLR_SURFACE_INVALID_SCALE;
- surface->pending.scale = scale;
+ surface->pending->invalid |= WLR_SURFACE_INVALID_SCALE;
+ surface->pending->scale = scale;
}
static void surface_damage_buffer(struct wl_client *client,
@@ -344,9 +487,9 @@ static void surface_damage_buffer(struct wl_client *client,
if (width < 0 || height < 0) {
return;
}
- surface->pending.invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE;
- pixman_region32_union_rect(&surface->pending.buffer_damage,
- &surface->pending.buffer_damage,
+ surface->pending->invalid |= WLR_SURFACE_INVALID_BUFFER_DAMAGE;
+ pixman_region32_union_rect(&surface->pending->buffer_damage,
+ &surface->pending->buffer_damage,
x, y, width, height);
}
@@ -363,19 +506,62 @@ const struct wl_surface_interface surface_interface = {
.damage_buffer = surface_damage_buffer
};
+static struct wlr_surface_state *wlr_surface_state_create() {
+ struct wlr_surface_state *state = calloc(1, sizeof(struct wlr_surface_state));
+ state->scale = 1;
+ state->transform = WL_OUTPUT_TRANSFORM_NORMAL;
+
+ wl_list_init(&state->frame_callback_list);
+
+ pixman_region32_init(&state->surface_damage);
+ pixman_region32_init(&state->buffer_damage);
+ pixman_region32_init(&state->opaque);
+ pixman_region32_init(&state->input);
+
+ return state;
+}
+
+static void wlr_surface_state_destroy(struct wlr_surface_state *state) {
+ struct wlr_frame_callback *cb, *tmp;
+ wl_list_for_each_safe(cb, tmp, &state->frame_callback_list, link) {
+ wl_resource_destroy(cb->resource);
+ }
+
+ pixman_region32_fini(&state->surface_damage);
+ pixman_region32_fini(&state->buffer_damage);
+ pixman_region32_fini(&state->opaque);
+ pixman_region32_fini(&state->input);
+
+ free(state);
+}
+
+void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) {
+ wlr_surface_state_destroy(subsurface->cached);
+
+ if (subsurface->parent) {
+ wl_list_remove(&subsurface->parent_link);
+ wl_list_remove(&subsurface->parent_pending_link);
+ wl_list_remove(&subsurface->parent_destroy_listener.link);
+ }
+
+ wl_resource_set_user_data(subsurface->resource, NULL);
+ if (subsurface->surface) {
+ subsurface->surface->subsurface = NULL;
+ }
+ free(subsurface);
+}
+
static void destroy_surface(struct wl_resource *resource) {
struct wlr_surface *surface = wl_resource_get_user_data(resource);
wl_signal_emit(&surface->signals.destroy, surface);
- wlr_texture_destroy(surface->texture);
- struct wlr_frame_callback *cb, *next;
- wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link) {
- wl_resource_destroy(cb->resource);
+ if (surface->subsurface) {
+ wlr_subsurface_destroy(surface->subsurface);
}
- pixman_region32_fini(&surface->pending.surface_damage);
- pixman_region32_fini(&surface->pending.buffer_damage);
- pixman_region32_fini(&surface->pending.opaque);
- pixman_region32_fini(&surface->pending.input);
+
+ wlr_texture_destroy(surface->texture);
+ wlr_surface_state_destroy(surface->pending);
+ wlr_surface_state_destroy(surface->current);
free(surface);
}
@@ -391,17 +577,14 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
surface->renderer = renderer;
surface->texture = wlr_render_texture_create(renderer);
surface->resource = res;
- surface->current.scale = 1;
- surface->pending.scale = 1;
- surface->current.transform = WL_OUTPUT_TRANSFORM_NORMAL;
- surface->pending.transform = WL_OUTPUT_TRANSFORM_NORMAL;
- pixman_region32_init(&surface->pending.surface_damage);
- pixman_region32_init(&surface->pending.buffer_damage);
- pixman_region32_init(&surface->pending.opaque);
- pixman_region32_init(&surface->pending.input);
+
+ surface->current = wlr_surface_state_create();
+ surface->pending = wlr_surface_state_create();
+
wl_signal_init(&surface->signals.commit);
wl_signal_init(&surface->signals.destroy);
- wl_list_init(&surface->frame_callback_list);
+ wl_list_init(&surface->subsurface_list);
+ wl_list_init(&surface->subsurface_pending_list);
wl_resource_set_implementation(res, &surface_interface,
surface, destroy_surface);
return surface;
@@ -411,8 +594,8 @@ void wlr_surface_get_matrix(struct wlr_surface *surface,
float (*matrix)[16],
const float (*projection)[16],
const float (*transform)[16]) {
- int width = surface->texture->width / surface->current.scale;
- int height = surface->texture->height / surface->current.scale;
+ int width = surface->texture->width / surface->current->scale;
+ int height = surface->texture->height / surface->current->scale;
float scale[16];
wlr_matrix_identity(matrix);
if (transform) {
@@ -443,3 +626,180 @@ int wlr_surface_set_role(struct wlr_surface *surface, const char *role,
return -1;
}
+
+static void subsurface_resource_destroy(struct wl_resource *resource) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+
+ if (subsurface) {
+ wlr_subsurface_destroy(subsurface);
+ }
+}
+
+static void subsurface_destroy(struct wl_client *client,
+ struct wl_resource *resource) {
+ wl_resource_destroy(resource);
+}
+
+static void subsurface_set_position(struct wl_client *client,
+ struct wl_resource *resource, int32_t x, int32_t y) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+ struct wlr_surface *surface = subsurface->surface;
+
+ surface->pending->invalid |= WLR_SURFACE_INVALID_SUBSURFACE_POSITION;
+
+ surface->pending->subsurface_position.x = x;
+ surface->pending->subsurface_position.y = y;
+}
+
+static struct wlr_subsurface *subsurface_find_sibling(
+ struct wlr_subsurface *subsurface, struct wlr_surface *surface) {
+ struct wlr_surface *parent = subsurface->parent;
+
+ struct wlr_subsurface *sibling;
+ wl_list_for_each(sibling, &parent->subsurface_list, parent_link) {
+ if (sibling->surface == surface && sibling != subsurface)
+ return sibling;
+ }
+
+ return NULL;
+}
+
+static void subsurface_place_above(struct wl_client *client,
+ struct wl_resource *resource, struct wl_resource *sibling_resource) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+
+ if (!subsurface) {
+ return;
+ }
+
+ struct wlr_surface *sibling_surface =
+ wl_resource_get_user_data(sibling_resource);
+ struct wlr_subsurface *sibling =
+ subsurface_find_sibling(subsurface, sibling_surface);
+
+ if (!sibling) {
+ wl_resource_post_error(subsurface->resource,
+ WL_SUBSURFACE_ERROR_BAD_SURFACE,
+ "%s: wl_surface@%d is not a parent or sibling",
+ "place_above", wl_resource_get_id(sibling_surface->resource));
+ return;
+ }
+
+ wl_list_remove(&subsurface->parent_pending_link);
+ wl_list_insert(sibling->parent_pending_link.prev,
+ &subsurface->parent_pending_link);
+
+ subsurface->reordered = true;
+}
+
+static void subsurface_place_below(struct wl_client *client,
+ struct wl_resource *resource, struct wl_resource *sibling_resource) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+
+ struct wlr_surface *sibling_surface =
+ wl_resource_get_user_data(sibling_resource);
+ struct wlr_subsurface *sibling =
+ subsurface_find_sibling(subsurface, sibling_surface);
+
+ if (!sibling) {
+ wl_resource_post_error(subsurface->resource,
+ WL_SUBSURFACE_ERROR_BAD_SURFACE,
+ "%s: wl_surface@%d is not a parent or sibling",
+ "place_below", wl_resource_get_id(sibling_surface->resource));
+ return;
+ }
+
+ wl_list_remove(&subsurface->parent_pending_link);
+ wl_list_insert(&sibling->parent_pending_link,
+ &subsurface->parent_pending_link);
+
+ subsurface->reordered = true;
+}
+
+static void subsurface_set_sync(struct wl_client *client,
+ struct wl_resource *resource) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+
+ if (subsurface) {
+ subsurface->synchronized = true;
+ }
+}
+
+static void subsurface_set_desync(struct wl_client *client,
+ struct wl_resource *resource) {
+ struct wlr_subsurface *subsurface = wl_resource_get_user_data(resource);
+
+ if (subsurface && subsurface->synchronized) {
+ subsurface->synchronized = false;
+
+ if (!wlr_subsurface_is_synchronized(subsurface)) {
+ // TODO: do a synchronized commit to flush the cache
+ wlr_subsurface_parent_commit(subsurface, true);
+ }
+ }
+}
+
+static const struct wl_subsurface_interface subsurface_implementation = {
+ .destroy = subsurface_destroy,
+ .set_position = subsurface_set_position,
+ .place_above = subsurface_place_above,
+ .place_below = subsurface_place_below,
+ .set_sync = subsurface_set_sync,
+ .set_desync = subsurface_set_desync,
+};
+
+static void subsurface_handle_parent_destroy(struct wl_listener *listener,
+ void *data) {
+ struct wlr_subsurface *subsurface =
+ wl_container_of(listener, subsurface, parent_destroy_listener);
+ wl_list_remove(&subsurface->parent_link);
+ wl_list_remove(&subsurface->parent_pending_link);
+ wl_list_remove(&subsurface->parent_destroy_listener.link);
+ subsurface->parent = NULL;
+}
+
+void wlr_surface_make_subsurface(struct wlr_surface *surface,
+ struct wlr_surface *parent, uint32_t id) {
+ assert(surface->subsurface == NULL);
+
+ struct wlr_subsurface *subsurface =
+ calloc(1, sizeof(struct wlr_subsurface));
+ if (!subsurface) {
+ return;
+ }
+ subsurface->cached = wlr_surface_state_create();
+ subsurface->synchronized = true;
+ subsurface->surface = surface;
+
+ // link parent
+ subsurface->parent = parent;
+ wl_signal_add(&parent->signals.destroy,
+ &subsurface->parent_destroy_listener);
+ subsurface->parent_destroy_listener.notify =
+ subsurface_handle_parent_destroy;
+ wl_list_insert(&parent->subsurface_list, &subsurface->parent_link);
+ wl_list_insert(&parent->subsurface_pending_list,
+ &subsurface->parent_pending_link);
+
+ struct wl_client *client = wl_resource_get_client(surface->resource);
+
+ subsurface->resource =
+ wl_resource_create(client, &wl_subsurface_interface, 1, id);
+
+ wl_resource_set_implementation(subsurface->resource,
+ &subsurface_implementation, subsurface,
+ subsurface_resource_destroy);
+
+ surface->subsurface = subsurface;
+}
+
+
+struct wlr_surface *wlr_surface_get_main_surface(struct wlr_surface *surface) {
+ struct wlr_subsurface *sub;
+
+ while (surface && (sub = surface->subsurface)) {
+ surface = sub->parent;
+ }
+
+ return surface;
+}
diff --git a/types/wlr_xdg_shell_v6.c b/types/wlr_xdg_shell_v6.c
index a7450add..ea8d7976 100644
--- a/types/wlr_xdg_shell_v6.c
+++ b/types/wlr_xdg_shell_v6.c
@@ -219,6 +219,21 @@ static const struct zxdg_toplevel_v6_interface zxdg_toplevel_v6_implementation =
static void xdg_surface_destroy(struct wlr_xdg_surface_v6 *surface) {
wl_signal_emit(&surface->events.destroy, surface);
wl_resource_set_user_data(surface->resource, NULL);
+
+ if (surface->configure_idle) {
+ wl_event_source_remove(surface->configure_idle);
+ }
+
+ struct wlr_xdg_surface_v6_configure *configure, *tmp;
+ wl_list_for_each_safe(configure, tmp, &surface->configure_list, link) {
+ free(configure);
+ }
+
+ if (surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
+ wl_resource_set_user_data(surface->toplevel_state->resource, NULL);
+ free(surface->toplevel_state);
+ }
+
wl_list_remove(&surface->link);
wl_list_remove(&surface->surface_destroy_listener.link);
wl_list_remove(&surface->surface_commit_listener.link);
@@ -236,6 +251,13 @@ static void xdg_surface_resource_destroy(struct wl_resource *resource) {
}
}
+static void xdg_toplevel_resource_destroy(struct wl_resource *resource) {
+ struct wlr_xdg_surface_v6 *surface = wl_resource_get_user_data(resource);
+ if (surface != NULL) {
+ xdg_surface_destroy(surface);
+ }
+}
+
static void xdg_surface_get_toplevel(struct wl_client *client,
struct wl_resource *resource, uint32_t id) {
struct wlr_xdg_surface_v6 *surface = wl_resource_get_user_data(resource);
@@ -260,7 +282,8 @@ static void xdg_surface_get_toplevel(struct wl_client *client,
surface->toplevel_state->resource = toplevel_resource;
wl_resource_set_implementation(toplevel_resource,
- &zxdg_toplevel_v6_implementation, surface, NULL);
+ &zxdg_toplevel_v6_implementation, surface,
+ xdg_toplevel_resource_destroy);
}
static void xdg_surface_get_popup(struct wl_client *client,
@@ -496,7 +519,7 @@ static void wlr_xdg_surface_v6_toplevel_committed(
struct wlr_xdg_surface_v6 *surface) {
assert(surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL);
- if (!surface->surface->current.buffer && !surface->toplevel_state->added) {
+ if (!surface->surface->current->buffer && !surface->toplevel_state->added) {
// on the first commit, send a configure request to tell the client it
// is added
wlr_xdg_surface_v6_schedule_configure(surface, true);
@@ -504,7 +527,7 @@ static void wlr_xdg_surface_v6_toplevel_committed(
return;
}
- if (!surface->surface->current.buffer) {
+ if (!surface->surface->current->buffer) {
return;
}
@@ -516,7 +539,7 @@ static void handle_wlr_surface_committed(struct wl_listener *listener,
struct wlr_xdg_surface_v6 *surface =
wl_container_of(listener, surface, surface_commit_listener);
- if (surface->surface->current.buffer && !surface->configured) {
+ if (surface->surface->current->buffer && !surface->configured) {
wl_resource_post_error(surface->resource,
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
"xdg_surface has never been configured");
@@ -580,7 +603,7 @@ static void xdg_shell_get_xdg_surface(struct wl_client *wl_client,
&zxdg_surface_v6_interface, wl_resource_get_version(client_resource),
id);
- if (surface->surface->current.buffer != NULL) {
+ if (surface->surface->current->buffer != NULL) {
wl_resource_post_error(surface->resource,
ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER,
"xdg_surface must not have a buffer at creation");
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index d7816bcd..2038ff0f 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -355,11 +355,8 @@ static void handle_configure_request(struct wlr_xwm *xwm,
if (surface->surface == NULL) {
// Surface has not been mapped yet
- surface->x = ev->x;
- surface->y = ev->y;
- surface->width = ev->width;
- surface->height = ev->height;
- wlr_xwayland_surface_configure(xwm->xwayland, surface);
+ wlr_xwayland_surface_configure(xwm->xwayland, surface, ev->x, ev->y,
+ ev->width, ev->height);
} else {
struct wlr_xwayland_surface_configure_event *wlr_event =
calloc(1, sizeof(struct wlr_xwayland_surface_configure_event));
@@ -610,13 +607,18 @@ void wlr_xwayland_surface_activate(struct wlr_xwayland *wlr_xwayland,
}
void wlr_xwayland_surface_configure(struct wlr_xwayland *wlr_xwayland,
- struct wlr_xwayland_surface *surface) {
+ struct wlr_xwayland_surface *surface, int16_t x, int16_t y,
+ uint16_t width, uint16_t height) {
+ surface->x = x;
+ surface->y = y;
+ surface->width = width;
+ surface->height = height;
+
struct wlr_xwm *xwm = wlr_xwayland->xwm;
uint32_t mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
XCB_CONFIG_WINDOW_BORDER_WIDTH;
- uint32_t values[] = {surface->x, surface->y, surface->width,
- surface->height, 0};
+ uint32_t values[] = {x, y, width, height, 0};
xcb_configure_window(xwm->xcb_conn, surface->window_id, mask, values);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 12:19:43 +0000