diff --git a/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston-11.0.3.imx/0001-Restore-wl_shell-to-weston-11.patch b/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston-11.0.3.imx/0001-Restore-wl_shell-to-weston-11.patch new file mode 100644 index 000000000..0bc86f5ec --- /dev/null +++ b/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston-11.0.3.imx/0001-Restore-wl_shell-to-weston-11.patch @@ -0,0 +1,933 @@ +From: Gabriel Valcazar +Date: Fri, 19 Jan 2024 09:45:19 +0100 +Subject: [PATCH] Restore wl_shell to weston 11 + +This shell was deprecated some time ago and removed in weston 11, but it's the +default shell used by LVGL's wayland backend. Until we migrate said backend to +use xdg_shell, restore wl_shell in weston 11. + +This reverts the following commits: + + * d40cedc8af9a42e1f6746fb58f4556080c6ff133 + * 7cae2a1fb0aeec24ca33ac4c7cbb268f77095cb5 + * e6b8f5a5e40cd6c0b934e8ae079c86d5193efa96 + +Signed-off-by: Gabriel Valcazar +--- + desktop-shell/shell.c | 26 +- + libweston/backend-wayland/wayland.c | 87 ++++- + libweston/desktop/internal.h | 4 + + libweston/desktop/libweston-desktop.c | 19 + + libweston/desktop/meson.build | 1 + + libweston/desktop/wl-shell.c | 497 ++++++++++++++++++++++++++ + meson.build | 6 + + meson_options.txt | 7 + + 8 files changed, 630 insertions(+), 17 deletions(-) + create mode 100644 libweston/desktop/wl-shell.c + +diff --git a/desktop-shell/shell.c b/desktop-shell/shell.c +index 91fadd0b..fced4d76 100644 +--- a/desktop-shell/shell.c ++++ b/desktop-shell/shell.c +@@ -1163,16 +1163,16 @@ resize_grab_motion(struct weston_pointer_grab *grab, + pointer->x, pointer->y, &to_x, &to_y); + + width = resize->width; +- if (resize->edges & WESTON_DESKTOP_SURFACE_EDGE_LEFT) { ++ if (resize->edges & WL_SHELL_SURFACE_RESIZE_LEFT) { + width += wl_fixed_to_int(from_x - to_x); +- } else if (resize->edges & WESTON_DESKTOP_SURFACE_EDGE_RIGHT) { ++ } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_RIGHT) { + width += wl_fixed_to_int(to_x - from_x); + } + + height = resize->height; +- if (resize->edges & WESTON_DESKTOP_SURFACE_EDGE_TOP) { ++ if (resize->edges & WL_SHELL_SURFACE_RESIZE_TOP) { + height += wl_fixed_to_int(from_y - to_y); +- } else if (resize->edges & WESTON_DESKTOP_SURFACE_EDGE_BOTTOM) { ++ } else if (resize->edges & WL_SHELL_SURFACE_RESIZE_BOTTOM) { + height += wl_fixed_to_int(to_y - from_y); + } + +@@ -1250,9 +1250,9 @@ surface_resize(struct shell_surface *shsurf, + { + struct weston_resize_grab *resize; + const unsigned resize_topbottom = +- WESTON_DESKTOP_SURFACE_EDGE_TOP | WESTON_DESKTOP_SURFACE_EDGE_BOTTOM; ++ WL_SHELL_SURFACE_RESIZE_TOP | WL_SHELL_SURFACE_RESIZE_BOTTOM; + const unsigned resize_leftright = +- WESTON_DESKTOP_SURFACE_EDGE_LEFT | WESTON_DESKTOP_SURFACE_EDGE_RIGHT; ++ WL_SHELL_SURFACE_RESIZE_LEFT | WL_SHELL_SURFACE_RESIZE_RIGHT; + const unsigned resize_any = resize_topbottom | resize_leftright; + struct weston_geometry geometry; + +@@ -1262,7 +1262,7 @@ surface_resize(struct shell_surface *shsurf, + return 0; + + /* Check for invalid edge combinations. */ +- if (edges == WESTON_DESKTOP_SURFACE_EDGE_NONE || edges > resize_any || ++ if (edges == WL_SHELL_SURFACE_RESIZE_NONE || edges > resize_any || + (edges & resize_topbottom) == resize_topbottom || + (edges & resize_leftright) == resize_leftright) + return 0; +@@ -2123,9 +2123,9 @@ desktop_surface_committed(struct weston_desktop_surface *desktop_surface, + sy = 0; + } + +- if (shsurf->resize_edges & WESTON_DESKTOP_SURFACE_EDGE_LEFT) ++ if (shsurf->resize_edges & WL_SHELL_SURFACE_RESIZE_LEFT) + sx = shsurf->last_width - surface->width; +- if (shsurf->resize_edges & WESTON_DESKTOP_SURFACE_EDGE_TOP) ++ if (shsurf->resize_edges & WL_SHELL_SURFACE_RESIZE_TOP) + sy = shsurf->last_height - surface->height; + + weston_view_to_global_float(shsurf->view, 0, 0, &from_x, &from_y); +@@ -3084,18 +3084,18 @@ resize_binding(struct weston_pointer *pointer, const struct timespec *time, + &x, &y); + + if (x < surface->width / 3) +- edges |= WESTON_DESKTOP_SURFACE_EDGE_LEFT; ++ edges |= WL_SHELL_SURFACE_RESIZE_LEFT; + else if (x < 2 * surface->width / 3) + edges |= 0; + else +- edges |= WESTON_DESKTOP_SURFACE_EDGE_RIGHT; ++ edges |= WL_SHELL_SURFACE_RESIZE_RIGHT; + + if (y < surface->height / 3) +- edges |= WESTON_DESKTOP_SURFACE_EDGE_TOP; ++ edges |= WL_SHELL_SURFACE_RESIZE_TOP; + else if (y < 2 * surface->height / 3) + edges |= 0; + else +- edges |= WESTON_DESKTOP_SURFACE_EDGE_BOTTOM; ++ edges |= WL_SHELL_SURFACE_RESIZE_BOTTOM; + + surface_resize(shsurf, pointer, edges); + } +diff --git a/libweston/backend-wayland/wayland.c b/libweston/backend-wayland/wayland.c +index bb5648d5..3ba20ff7 100644 +--- a/libweston/backend-wayland/wayland.c ++++ b/libweston/backend-wayland/wayland.c +@@ -76,6 +76,7 @@ struct wayland_backend { + struct wl_display *wl_display; + struct wl_registry *registry; + struct wl_compositor *compositor; ++ struct wl_shell *shell; + struct xdg_wm_base *xdg_wm_base; + struct zwp_fullscreen_shell_v1 *fshell; + struct wl_shm *shm; +@@ -111,6 +112,7 @@ struct wayland_output { + struct wl_output *output; + uint32_t global_id; + ++ struct wl_shell_surface *shell_surface; + struct xdg_surface *xdg_surface; + struct xdg_toplevel *xdg_toplevel; + int configure_width, configure_height; +@@ -715,6 +717,11 @@ wayland_backend_destroy_output_surface(struct wayland_output *output) + output->parent.xdg_surface = NULL; + } + ++ if (output->parent.shell_surface) { ++ wl_shell_surface_destroy(output->parent.shell_surface); ++ output->parent.shell_surface = NULL; ++ } ++ + wl_surface_destroy(output->parent.surface); + output->parent.surface = NULL; + } +@@ -787,6 +794,8 @@ wayland_output_destroy(struct weston_output *base) + free(output); + } + ++static const struct wl_shell_surface_listener shell_surface_listener; ++ + #ifdef ENABLE_EGL + static int + wayland_output_init_gl_renderer(struct wayland_output *output) +@@ -940,6 +949,8 @@ wayland_output_set_windowed(struct wayland_output *output) + + if (output->parent.xdg_toplevel) { + xdg_toplevel_unset_fullscreen(output->parent.xdg_toplevel); ++ } else if (output->parent.shell_surface) { ++ wl_shell_surface_set_toplevel(output->parent.shell_surface); + } else { + abort(); + } +@@ -949,6 +960,7 @@ wayland_output_set_windowed(struct wayland_output *output) + + static void + wayland_output_set_fullscreen(struct wayland_output *output, ++ enum wl_shell_surface_fullscreen_method method, + uint32_t framerate, struct wl_output *target) + { + if (output->frame) { +@@ -960,6 +972,9 @@ wayland_output_set_fullscreen(struct wayland_output *output, + + if (output->parent.xdg_toplevel) { + xdg_toplevel_set_fullscreen(output->parent.xdg_toplevel, target); ++ } else if (output->parent.shell_surface) { ++ wl_shell_surface_set_fullscreen(output->parent.shell_surface, ++ method, framerate, target); + } else { + abort(); + } +@@ -1089,7 +1104,7 @@ wayland_output_switch_mode(struct weston_output *output_base, + + b = to_wayland_backend(output_base->compositor); + +- if (output->parent.xdg_surface || !b->parent.fshell) ++ if (output->parent.xdg_surface || output->parent.shell_surface || !b->parent.fshell) + return -1; + + mode = wayland_output_choose_mode(output, mode); +@@ -1230,6 +1245,20 @@ wayland_backend_create_output_surface(struct wayland_output *output) + + weston_log("wayland-backend: Using xdg_wm_base\n"); + } ++ else if (b->parent.shell) { ++ output->parent.shell_surface = ++ wl_shell_get_shell_surface(b->parent.shell, ++ output->parent.surface); ++ if (!output->parent.shell_surface) { ++ wl_surface_destroy(output->parent.surface); ++ return -1; ++ } ++ ++ wl_shell_surface_add_listener(output->parent.shell_surface, ++ &shell_surface_listener, output); ++ ++ weston_log("wayland-backend: Using wl_shell\n"); ++ } + + return 0; + } +@@ -1294,9 +1323,13 @@ wayland_output_enable(struct weston_output *base) + + output->parent.draw_initial_frame = true; + } ++ } else { ++ wayland_output_set_fullscreen(output, ++ WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER, ++ output->mode.refresh, output->parent.output); + } + } else if (b->fullscreen) { +- wayland_output_set_fullscreen(output, 0, NULL); ++ wayland_output_set_fullscreen(output, 0, 0, NULL); + } else { + wayland_output_set_windowed(output); + } +@@ -1578,10 +1611,13 @@ wayland_output_setup_fullscreen(struct wayland_output *output, + return -1; + + /* What should size be set if conditional is false? */ +- if (b->parent.xdg_wm_base) { ++ if (b->parent.xdg_wm_base || b->parent.shell) { + if (output->parent.xdg_toplevel) + xdg_toplevel_set_fullscreen(output->parent.xdg_toplevel, + output->parent.output); ++ else if (output->parent.shell_surface) ++ wl_shell_surface_set_fullscreen(output->parent.shell_surface, ++ 0, 0, NULL); + + wl_display_roundtrip(b->parent.wl_display); + +@@ -1605,6 +1641,36 @@ err_set_size: + return -1; + } + ++static void ++shell_surface_ping(void *data, struct wl_shell_surface *shell_surface, ++ uint32_t serial) ++{ ++ wl_shell_surface_pong(shell_surface, serial); ++} ++ ++static void ++shell_surface_configure(void *data, struct wl_shell_surface *shell_surface, ++ uint32_t edges, int32_t width, int32_t height) ++{ ++ struct wayland_output *output = data; ++ ++ output->parent.configure_width = width; ++ output->parent.configure_height = height; ++ ++ /* FIXME: implement resizing */ ++} ++ ++static void ++shell_surface_popup_done(void *data, struct wl_shell_surface *shell_surface) ++{ ++} ++ ++static const struct wl_shell_surface_listener shell_surface_listener = { ++ shell_surface_ping, ++ shell_surface_configure, ++ shell_surface_popup_done ++}; ++ + /* Events received from the wayland-server this compositor is client of: */ + + /* parent input interface */ +@@ -1782,6 +1848,9 @@ input_handle_button(void *data, struct wl_pointer *pointer, + if (input->output->parent.xdg_toplevel) + xdg_toplevel_move(input->output->parent.xdg_toplevel, + input->parent.seat, serial); ++ else if (input->output->parent.shell_surface) ++ wl_shell_surface_move(input->output->parent.shell_surface, ++ input->parent.seat, serial); + frame_status_clear(input->output->frame, + FRAME_STATUS_MOVE); + return; +@@ -2135,6 +2204,9 @@ input_handle_touch_down(void *data, struct wl_touch *wl_touch, + if (output->parent.xdg_toplevel) + xdg_toplevel_move(output->parent.xdg_toplevel, + input->parent.seat, serial); ++ else if (output->parent.shell_surface) ++ wl_shell_surface_move(output->parent.shell_surface, ++ input->parent.seat, serial); + frame_status_clear(output->frame, + FRAME_STATUS_MOVE); + return; +@@ -2647,6 +2719,10 @@ registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, + &xdg_wm_base_interface, 1); + xdg_wm_base_add_listener(b->parent.xdg_wm_base, + &wm_base_listener, b); ++ } else if (strcmp(interface, "wl_shell") == 0) { ++ b->parent.shell = ++ wl_registry_bind(registry, name, ++ &wl_shell_interface, 1); + } else if (strcmp(interface, "zwp_fullscreen_shell_v1") == 0) { + b->parent.fshell = + wl_registry_bind(registry, name, +@@ -2741,6 +2817,9 @@ wayland_destroy(struct weston_compositor *ec) + if (b->parent.xdg_wm_base) + xdg_wm_base_destroy(b->parent.xdg_wm_base); + ++ if (b->parent.shell) ++ wl_shell_destroy(b->parent.shell); ++ + if (b->parent.fshell) + zwp_fullscreen_shell_v1_release(b->parent.fshell); + +@@ -2808,7 +2887,7 @@ fullscreen_binding(struct weston_keyboard *keyboard, + return; + + if (input->output->frame) +- wayland_output_set_fullscreen(input->output, 0, NULL); ++ wayland_output_set_fullscreen(input->output, 0, 0, NULL); + else + wayland_output_set_windowed(input->output); + +diff --git a/libweston/desktop/internal.h b/libweston/desktop/internal.h +index 1d035d5c..93b15919 100644 +--- a/libweston/desktop/internal.h ++++ b/libweston/desktop/internal.h +@@ -241,6 +241,10 @@ weston_desktop_xdg_wm_base_create(struct weston_desktop *desktop, + struct wl_global * + weston_desktop_xdg_shell_v6_create(struct weston_desktop *desktop, + struct wl_display *display); ++struct wl_global * ++weston_desktop_wl_shell_create(struct weston_desktop *desktop, ++ struct wl_display *display); ++ + void + weston_desktop_xwayland_init(struct weston_desktop *desktop); + void +diff --git a/libweston/desktop/libweston-desktop.c b/libweston/desktop/libweston-desktop.c +index 0be9d717..cbe69942 100644 +--- a/libweston/desktop/libweston-desktop.c ++++ b/libweston/desktop/libweston-desktop.c +@@ -42,6 +42,7 @@ struct weston_desktop { + void *user_data; + struct wl_global *xdg_wm_base; /* Stable protocol xdg_shell replaces xdg_shell_unstable_v6 */ + struct wl_global *xdg_shell_v6; /* Unstable xdg_shell_unstable_v6 protocol. */ ++ struct wl_global *wl_shell; + }; + + void +@@ -76,6 +77,22 @@ weston_desktop_create(struct weston_compositor *compositor, + return NULL; + } + ++#ifdef HAVE_DEPRECATED_WL_SHELL ++ weston_log("Warning: support for deprecated wl_shell interface is " ++ "enabled. Please migrate legacy clients to xdg-shell.\n"); ++ desktop->wl_shell = ++ weston_desktop_wl_shell_create(desktop, display); ++ if (desktop->wl_shell == NULL) { ++ weston_desktop_destroy(desktop); ++ return NULL; ++ } ++#else ++ weston_log("Note: support for the deprecated wl_shell interface is " ++ "disabled. If a legacy client still needs it, it can be " ++ "re-enabled by passing -Ddeprecated-wl-shell=true to Meson " ++ "when building Weston.\n"); ++#endif ++ + weston_desktop_xwayland_init(desktop); + + return desktop; +@@ -89,6 +106,8 @@ weston_desktop_destroy(struct weston_desktop *desktop) + + weston_desktop_xwayland_fini(desktop); + ++ if (desktop->wl_shell != NULL) ++ wl_global_destroy(desktop->wl_shell); + if (desktop->xdg_shell_v6 != NULL) + wl_global_destroy(desktop->xdg_shell_v6); + if (desktop->xdg_wm_base != NULL) +diff --git a/libweston/desktop/meson.build b/libweston/desktop/meson.build +index 4588ad10..d8e1a709 100644 +--- a/libweston/desktop/meson.build ++++ b/libweston/desktop/meson.build +@@ -4,6 +4,7 @@ srcs_libweston += files([ + 'seat.c', + 'surface.c', + 'xwayland.c', ++ 'wl-shell.c', + 'xdg-shell.c', + 'xdg-shell-v6.c', + ]) +diff --git a/libweston/desktop/wl-shell.c b/libweston/desktop/wl-shell.c +new file mode 100644 +index 00000000..9efec89b +--- /dev/null ++++ b/libweston/desktop/wl-shell.c +@@ -0,0 +1,497 @@ ++/* ++ * Copyright © 2010-2012 Intel Corporation ++ * Copyright © 2011-2012 Collabora, Ltd. ++ * Copyright © 2013 Raspberry Pi Foundation ++ * Copyright © 2016 Quentin "Sardem FF7" Glidic ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the next ++ * paragraph) shall be included in all copies or substantial portions of the ++ * Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ * DEALINGS IN THE SOFTWARE. ++ */ ++ ++#include "config.h" ++ ++#include ++ ++#include ++ ++#include ++#include ++ ++#include ++#include "internal.h" ++ ++#define WD_WL_SHELL_PROTOCOL_VERSION 1 ++ ++enum weston_desktop_wl_shell_surface_state { ++ NONE, ++ TOPLEVEL, ++ MAXIMIZED, ++ FULLSCREEN, ++ TRANSIENT, ++ POPUP, ++}; ++ ++struct weston_desktop_wl_shell_surface { ++ struct wl_resource *resource; ++ struct weston_desktop *desktop; ++ struct wl_display *display; ++ struct weston_desktop_surface *surface; ++ struct weston_desktop_surface *parent; ++ bool added; ++ struct weston_desktop_seat *popup_seat; ++ enum weston_desktop_wl_shell_surface_state state; ++ struct wl_listener wl_surface_resource_destroy_listener; ++}; ++ ++static void ++weston_desktop_wl_shell_surface_set_size(struct weston_desktop_surface *dsurface, ++ void *user_data, ++ int32_t width, int32_t height) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ struct weston_surface *wsurface = ++ weston_desktop_surface_get_surface(surface->surface); ++ ++ if ((wsurface->width == width && wsurface->height == height) || ++ (width == 0 && height == 0)) ++ return; ++ ++ wl_shell_surface_send_configure(surface->resource, ++ WL_SHELL_SURFACE_RESIZE_NONE, ++ width, height); ++} ++ ++static void ++weston_desktop_wl_shell_surface_maybe_ungrab(struct weston_desktop_wl_shell_surface *surface) ++{ ++ if (surface->state != POPUP || ++ !weston_desktop_surface_get_grab(surface->surface)) ++ return; ++ ++ weston_desktop_surface_popup_ungrab(surface->surface, ++ surface->popup_seat); ++ surface->popup_seat = NULL; ++} ++ ++static void ++weston_desktop_wl_shell_surface_committed(struct weston_desktop_surface *dsurface, ++ void *user_data, ++ int32_t sx, int32_t sy) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ struct weston_surface *wsurface = ++ weston_desktop_surface_get_surface(dsurface); ++ ++ if (wsurface->buffer_ref.buffer == NULL) ++ weston_desktop_wl_shell_surface_maybe_ungrab(surface); ++ ++ if (surface->added) ++ weston_desktop_api_committed(surface->desktop, surface->surface, ++ sx, sy); ++} ++ ++static void ++weston_desktop_wl_shell_surface_ping(struct weston_desktop_surface *dsurface, ++ uint32_t serial, void *user_data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ ++ wl_shell_surface_send_ping(surface->resource, serial); ++} ++ ++static void ++weston_desktop_wl_shell_surface_close(struct weston_desktop_surface *dsurface, ++ void *user_data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ ++ if (surface->state == POPUP) ++ wl_shell_surface_send_popup_done(surface->resource); ++} ++ ++static bool ++weston_desktop_wl_shell_surface_get_maximized(struct weston_desktop_surface *dsurface, ++ void *user_data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ ++ return surface->state == MAXIMIZED; ++} ++ ++static bool ++weston_desktop_wl_shell_surface_get_fullscreen(struct weston_desktop_surface *dsurface, ++ void *user_data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ ++ return surface->state == FULLSCREEN; ++} ++ ++static void ++weston_desktop_wl_shell_change_state(struct weston_desktop_wl_shell_surface *surface, ++ enum weston_desktop_wl_shell_surface_state state, ++ struct weston_desktop_surface *parent, ++ int32_t x, int32_t y) ++{ ++ bool to_add = (parent == NULL); ++ ++ assert(state != NONE); ++ ++ if (to_add && surface->added) { ++ surface->state = state; ++ return; ++ } ++ ++ if (surface->state != state) { ++ if (surface->state == POPUP) ++ weston_desktop_wl_shell_surface_maybe_ungrab(surface); ++ ++ if (to_add) { ++ weston_desktop_surface_unset_relative_to(surface->surface); ++ weston_desktop_api_surface_added(surface->desktop, ++ surface->surface); ++ } else if (surface->added) { ++ weston_desktop_api_surface_removed(surface->desktop, ++ surface->surface); ++ } ++ ++ surface->state = state; ++ surface->added = to_add; ++ } ++ ++ if (parent != NULL) ++ weston_desktop_surface_set_relative_to(surface->surface, parent, ++ x, y, false); ++} ++ ++static void ++weston_desktop_wl_shell_surface_destroy(struct weston_desktop_surface *dsurface, ++ void *user_data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = user_data; ++ ++ wl_list_remove(&surface->wl_surface_resource_destroy_listener.link); ++ ++ weston_desktop_wl_shell_surface_maybe_ungrab(surface); ++ weston_desktop_surface_unset_relative_to(surface->surface); ++ if (surface->added) ++ weston_desktop_api_surface_removed(surface->desktop, ++ surface->surface); ++ ++ free(surface); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_pong(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ uint32_t serial) ++{ ++ struct weston_desktop_surface *surface = wl_resource_get_user_data(resource); ++ ++ weston_desktop_client_pong(weston_desktop_surface_get_client(surface), serial); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_move(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ struct wl_resource *seat_resource, ++ uint32_t serial) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_seat *seat = ++ wl_resource_get_user_data(seat_resource); ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ ++ if (seat == NULL) ++ return; ++ ++ weston_desktop_api_move(surface->desktop, dsurface, seat, serial); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_resize(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ struct wl_resource *seat_resource, ++ uint32_t serial, ++ enum wl_shell_surface_resize edges) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_seat *seat = wl_resource_get_user_data(seat_resource); ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ enum weston_desktop_surface_edge surf_edges = ++ (enum weston_desktop_surface_edge) edges; ++ ++ if (seat == NULL) ++ return; ++ ++ weston_desktop_api_resize(surface->desktop, dsurface, seat, serial, surf_edges); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_toplevel(struct wl_client *wl_client, ++ struct wl_resource *resource) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ ++ weston_desktop_wl_shell_change_state(surface, TOPLEVEL, NULL, 0, 0); ++ if (surface->parent == NULL) ++ return; ++ surface->parent = NULL; ++ weston_desktop_api_set_parent(surface->desktop, surface->surface, NULL); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_transient(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ struct wl_resource *parent_resource, ++ int32_t x, int32_t y, ++ enum wl_shell_surface_transient flags) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_surface *wparent = ++ wl_resource_get_user_data(parent_resource); ++ struct weston_desktop_surface *parent; ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ ++ if (!weston_surface_is_desktop_surface(wparent)) ++ return; ++ ++ parent = weston_surface_get_desktop_surface(wparent); ++ if (flags & WL_SHELL_SURFACE_TRANSIENT_INACTIVE) { ++ weston_desktop_wl_shell_change_state(surface, TRANSIENT, parent, ++ x, y); ++ } else { ++ weston_desktop_wl_shell_change_state(surface, TOPLEVEL, NULL, ++ 0, 0); ++ surface->parent = parent; ++ weston_desktop_api_set_parent(surface->desktop, ++ surface->surface, parent); ++ } ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_fullscreen(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ enum wl_shell_surface_fullscreen_method method, ++ uint32_t framerate, ++ struct wl_resource *output_resource) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ struct weston_output *output = NULL; ++ ++ if (output_resource != NULL) ++ output = weston_head_from_resource(output_resource)->output; ++ ++ weston_desktop_wl_shell_change_state(surface, FULLSCREEN, NULL, 0, 0); ++ weston_desktop_api_fullscreen_requested(surface->desktop, dsurface, ++ true, output); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_popup(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ struct wl_resource *seat_resource, ++ uint32_t serial, ++ struct wl_resource *parent_resource, ++ int32_t x, int32_t y, ++ enum wl_shell_surface_transient flags) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_seat *wseat = wl_resource_get_user_data(seat_resource); ++ struct weston_desktop_seat *seat = weston_desktop_seat_from_seat(wseat); ++ struct weston_surface *parent = ++ wl_resource_get_user_data(parent_resource); ++ struct weston_desktop_surface *parent_surface; ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ ++ /* Check that if we have a valid wseat we also got a valid desktop seat */ ++ if (wseat != NULL && seat == NULL) { ++ wl_client_post_no_memory(wl_client); ++ return; ++ } ++ ++ if (!weston_surface_is_desktop_surface(parent)) ++ return; ++ ++ parent_surface = weston_surface_get_desktop_surface(parent); ++ ++ weston_desktop_wl_shell_change_state(surface, POPUP, ++ parent_surface, x, y); ++ weston_desktop_surface_popup_grab(surface->surface, seat, serial); ++ surface->popup_seat = seat; ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_maximized(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ struct wl_resource *output_resource) ++{ ++ struct weston_desktop_surface *dsurface = ++ wl_resource_get_user_data(resource); ++ struct weston_desktop_wl_shell_surface *surface = ++ weston_desktop_surface_get_implementation_data(dsurface); ++ ++ weston_desktop_wl_shell_change_state(surface, MAXIMIZED, NULL, 0, 0); ++ weston_desktop_api_maximized_requested(surface->desktop, dsurface, true); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_title(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ const char *title) ++{ ++ struct weston_desktop_surface *surface = ++ wl_resource_get_user_data(resource); ++ ++ weston_desktop_surface_set_title(surface, title); ++} ++ ++static void ++weston_desktop_wl_shell_surface_protocol_set_class(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ const char *class_) ++{ ++ struct weston_desktop_surface *surface = ++ wl_resource_get_user_data(resource); ++ ++ weston_desktop_surface_set_app_id(surface, class_); ++} ++ ++ ++static const struct wl_shell_surface_interface weston_desktop_wl_shell_surface_implementation = { ++ .pong = weston_desktop_wl_shell_surface_protocol_pong, ++ .move = weston_desktop_wl_shell_surface_protocol_move, ++ .resize = weston_desktop_wl_shell_surface_protocol_resize, ++ .set_toplevel = weston_desktop_wl_shell_surface_protocol_set_toplevel, ++ .set_transient = weston_desktop_wl_shell_surface_protocol_set_transient, ++ .set_fullscreen = weston_desktop_wl_shell_surface_protocol_set_fullscreen, ++ .set_popup = weston_desktop_wl_shell_surface_protocol_set_popup, ++ .set_maximized = weston_desktop_wl_shell_surface_protocol_set_maximized, ++ .set_title = weston_desktop_wl_shell_surface_protocol_set_title, ++ .set_class = weston_desktop_wl_shell_surface_protocol_set_class, ++}; ++ ++static const struct weston_desktop_surface_implementation weston_desktop_wl_shell_surface_internal_implementation = { ++ .set_size = weston_desktop_wl_shell_surface_set_size, ++ .committed = weston_desktop_wl_shell_surface_committed, ++ .ping = weston_desktop_wl_shell_surface_ping, ++ .close = weston_desktop_wl_shell_surface_close, ++ ++ .get_maximized = weston_desktop_wl_shell_surface_get_maximized, ++ .get_fullscreen = weston_desktop_wl_shell_surface_get_fullscreen, ++ ++ .destroy = weston_desktop_wl_shell_surface_destroy, ++}; ++ ++static void ++wl_surface_resource_destroyed(struct wl_listener *listener, ++ void *data) ++{ ++ struct weston_desktop_wl_shell_surface *surface = ++ wl_container_of(listener, surface, ++ wl_surface_resource_destroy_listener); ++ ++ /* the wl_shell_surface spec says that wl_shell_surfaces are to be ++ * destroyed automatically when the wl_surface is destroyed. */ ++ weston_desktop_surface_destroy(surface->surface); ++} ++ ++static void ++weston_desktop_wl_shell_protocol_get_shell_surface(struct wl_client *wl_client, ++ struct wl_resource *resource, ++ uint32_t id, ++ struct wl_resource *surface_resource) ++{ ++ struct weston_desktop_client *client = wl_resource_get_user_data(resource); ++ struct weston_surface *wsurface = wl_resource_get_user_data(surface_resource); ++ struct weston_desktop_wl_shell_surface *surface; ++ ++ ++ if (weston_surface_set_role(wsurface, "wl_shell_surface", resource, WL_SHELL_ERROR_ROLE) < 0) ++ return; ++ ++ surface = zalloc(sizeof(struct weston_desktop_wl_shell_surface)); ++ if (surface == NULL) { ++ wl_client_post_no_memory(wl_client); ++ return; ++ } ++ ++ surface->desktop = weston_desktop_client_get_desktop(client); ++ surface->display = weston_desktop_get_display(surface->desktop); ++ ++ surface->surface = ++ weston_desktop_surface_create(surface->desktop, client, wsurface, ++ &weston_desktop_wl_shell_surface_internal_implementation, ++ surface); ++ if (surface->surface == NULL) { ++ free(surface); ++ return; ++ } ++ ++ surface->wl_surface_resource_destroy_listener.notify = ++ wl_surface_resource_destroyed; ++ wl_resource_add_destroy_listener(wsurface->resource, ++ &surface->wl_surface_resource_destroy_listener); ++ ++ surface->resource = ++ weston_desktop_surface_add_resource(surface->surface, ++ &wl_shell_surface_interface, ++ &weston_desktop_wl_shell_surface_implementation, ++ id, NULL); ++} ++ ++ ++static const struct wl_shell_interface weston_desktop_wl_shell_implementation = { ++ .get_shell_surface = weston_desktop_wl_shell_protocol_get_shell_surface, ++}; ++ ++static void ++weston_desktop_wl_shell_bind(struct wl_client *client, void *data, ++ uint32_t version, uint32_t id) ++{ ++ struct weston_desktop *desktop = data; ++ ++ weston_desktop_client_create(desktop, client, NULL, &wl_shell_interface, ++ &weston_desktop_wl_shell_implementation, ++ version, id); ++} ++ ++struct wl_global * ++weston_desktop_wl_shell_create(struct weston_desktop *desktop, ++ struct wl_display *display) ++{ ++ return wl_global_create(display, ++ &wl_shell_interface, ++ WD_WL_SHELL_PROTOCOL_VERSION, desktop, ++ weston_desktop_wl_shell_bind); ++} +diff --git a/meson.build b/meson.build +index 6452ca05..64575226 100644 +--- a/meson.build ++++ b/meson.build +@@ -141,6 +141,12 @@ if dep_xkbcommon.version().version_compare('>= 0.5.0') + config_h.set('HAVE_XKBCOMMON_COMPOSE', '1') + endif + ++if get_option('deprecated-wl-shell') ++ warning('Support for the deprecated wl_shell interface is enabled.') ++ warning('This feature will be removed in a future version.') ++ config_h.set('HAVE_DEPRECATED_WL_SHELL', '1') ++endif ++ + dep_wayland_server = dependency('wayland-server', version: '>= 1.20.0') + dep_wayland_client = dependency('wayland-client', version: '>= 1.20.0') + dep_pixman = dependency('pixman-1', version: '>= 0.25.2') +diff --git a/meson_options.txt b/meson_options.txt +index 695eb780..203fa12d 100644 +--- a/meson_options.txt ++++ b/meson_options.txt +@@ -132,6 +132,13 @@ option( + description: 'Weston desktop shell: default helper client selection' + ) + ++option( ++ 'deprecated-wl-shell', ++ type: 'boolean', ++ value: false, ++ description: 'Enable the deprecated wl_shell protocol' ++) ++ + option( + 'color-management-lcms', + type: 'boolean', + diff --git a/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston_11.0.3.imx.bbappend b/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston_11.0.3.imx.bbappend new file mode 100644 index 000000000..58dbf02b5 --- /dev/null +++ b/meta-digi-dey/dynamic-layers/freescale-layer/recipes-graphics/wayland/weston_11.0.3.imx.bbappend @@ -0,0 +1,5 @@ +# Copyright (C) 2024 Digi International Inc. + +SRC_URI += "file://0001-Restore-wl_shell-to-weston-11.patch" + +EXTRA_OEMESON += "-Ddeprecated-wl-shell=true"