+#include "wayland-client.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_shell The xdg_shell protocol
+ * @section page_ifaces_xdg_shell Interfaces
+ * - @subpage page_iface_xdg_wm_base - create desktop-style surfaces
+ * - @subpage page_iface_xdg_positioner - child surface positioner
+ * - @subpage page_iface_xdg_surface - desktop user interface surface base interface
+ * - @subpage page_iface_xdg_toplevel - toplevel surface
+ * - @subpage page_iface_xdg_popup - short-lived, popup surfaces for menus
+ * @section page_copyright_xdg_shell Copyright
+ *
+ *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013 Rafael Antognolli
+ * Copyright © 2013 Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+struct wl_output;
+struct wl_seat;
+struct wl_surface;
+struct xdg_popup;
+struct xdg_positioner;
+struct xdg_surface;
+struct xdg_toplevel;
+struct xdg_wm_base;
+
+#ifndef XDG_WM_BASE_INTERFACE
+#define XDG_WM_BASE_INTERFACE
+/**
+ * @page page_iface_xdg_wm_base xdg_wm_base
+ * @section page_iface_xdg_wm_base_desc Description
+ *
+ * The xdg_wm_base interface is exposed as a global object enabling clients
+ * to turn their wl_surfaces into windows in a desktop environment. It
+ * defines the basic functionality needed for clients and the compositor to
+ * create windows that can be dragged, resized, maximized, etc, as well as
+ * creating transient windows such as popup menus.
+ * @section page_iface_xdg_wm_base_api API
+ * See @ref iface_xdg_wm_base.
+ */
+/**
+ * @defgroup iface_xdg_wm_base The xdg_wm_base interface
+ *
+ * The xdg_wm_base interface is exposed as a global object enabling clients
+ * to turn their wl_surfaces into windows in a desktop environment. It
+ * defines the basic functionality needed for clients and the compositor to
+ * create windows that can be dragged, resized, maximized, etc, as well as
+ * creating transient windows such as popup menus.
+ */
+extern const struct wl_interface xdg_wm_base_interface;
+#endif
+#ifndef XDG_POSITIONER_INTERFACE
+#define XDG_POSITIONER_INTERFACE
+/**
+ * @page page_iface_xdg_positioner xdg_positioner
+ * @section page_iface_xdg_positioner_desc Description
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle. These positioner-created rules are
+ * constrained by the requirement that a child surface must intersect with or
+ * be at least partially adjacent to its parent surface.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an invalid_positioner error.
+ * @section page_iface_xdg_positioner_api API
+ * See @ref iface_xdg_positioner.
+ */
+/**
+ * @defgroup iface_xdg_positioner The xdg_positioner interface
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle. These positioner-created rules are
+ * constrained by the requirement that a child surface must intersect with or
+ * be at least partially adjacent to its parent surface.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an invalid_positioner error.
+ */
+extern const struct wl_interface xdg_positioner_interface;
+#endif
+#ifndef XDG_SURFACE_INTERFACE
+#define XDG_SURFACE_INTERFACE
+/**
+ * @page page_iface_xdg_surface xdg_surface
+ * @section page_iface_xdg_surface_desc Description
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * After creating a role-specific object and setting it up, the client must
+ * perform an initial commit without any buffer attached. The compositor
+ * will reply with an xdg_surface.configure event. The client must
+ * acknowledge it and is then allowed to attach a buffer to map the surface.
+ *
+ * Mapping an xdg_surface-based role surface is defined as making it
+ * possible for the surface to be shown by the compositor. Note that
+ * a mapped surface is not guaranteed to be visible once it is mapped.
+ *
+ * For an xdg_surface to be mapped by the compositor, the following
+ * conditions must be met:
+ * (1) the client has assigned an xdg_surface-based role to the surface
+ * (2) the client has set and committed the xdg_surface state and the
+ * role-dependent state to the surface
+ * (3) the client has committed a buffer to the surface
+ *
+ * A newly-unmapped surface is considered to have met condition (1) out
+ * of the 3 required conditions for mapping a surface if its role surface
+ * has not been destroyed, i.e. the client must perform the initial commit
+ * again before attaching a buffer.
+ * @section page_iface_xdg_surface_api API
+ * See @ref iface_xdg_surface.
+ */
+/**
+ * @defgroup iface_xdg_surface The xdg_surface interface
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * After creating a role-specific object and setting it up, the client must
+ * perform an initial commit without any buffer attached. The compositor
+ * will reply with an xdg_surface.configure event. The client must
+ * acknowledge it and is then allowed to attach a buffer to map the surface.
+ *
+ * Mapping an xdg_surface-based role surface is defined as making it
+ * possible for the surface to be shown by the compositor. Note that
+ * a mapped surface is not guaranteed to be visible once it is mapped.
+ *
+ * For an xdg_surface to be mapped by the compositor, the following
+ * conditions must be met:
+ * (1) the client has assigned an xdg_surface-based role to the surface
+ * (2) the client has set and committed the xdg_surface state and the
+ * role-dependent state to the surface
+ * (3) the client has committed a buffer to the surface
+ *
+ * A newly-unmapped surface is considered to have met condition (1) out
+ * of the 3 required conditions for mapping a surface if its role surface
+ * has not been destroyed, i.e. the client must perform the initial commit
+ * again before attaching a buffer.
+ */
+extern const struct wl_interface xdg_surface_interface;
+#endif
+#ifndef XDG_TOPLEVEL_INTERFACE
+#define XDG_TOPLEVEL_INTERFACE
+/**
+ * @page page_iface_xdg_toplevel xdg_toplevel
+ * @section page_iface_xdg_toplevel_desc Description
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ *
+ * Unmapping an xdg_toplevel means that the surface cannot be shown
+ * by the compositor until it is explicitly mapped again.
+ * All active operations (e.g., move, resize) are canceled and all
+ * attributes (e.g. title, state, stacking, ...) are discarded for
+ * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
+ * the state it had right after xdg_surface.get_toplevel. The client
+ * can re-map the toplevel by perfoming a commit without any buffer
+ * attached, waiting for a configure event and handling it as usual (see
+ * xdg_surface description).
+ *
+ * Attaching a null buffer to a toplevel unmaps the surface.
+ * @section page_iface_xdg_toplevel_api API
+ * See @ref iface_xdg_toplevel.
+ */
+/**
+ * @defgroup iface_xdg_toplevel The xdg_toplevel interface
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ *
+ * Unmapping an xdg_toplevel means that the surface cannot be shown
+ * by the compositor until it is explicitly mapped again.
+ * All active operations (e.g., move, resize) are canceled and all
+ * attributes (e.g. title, state, stacking, ...) are discarded for
+ * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
+ * the state it had right after xdg_surface.get_toplevel. The client
+ * can re-map the toplevel by perfoming a commit without any buffer
+ * attached, waiting for a configure event and handling it as usual (see
+ * xdg_surface description).
+ *
+ * Attaching a null buffer to a toplevel unmaps the surface.
+ */
+extern const struct wl_interface xdg_toplevel_interface;
+#endif
+#ifndef XDG_POPUP_INTERFACE
+#define XDG_POPUP_INTERFACE
+/**
+ * @page page_iface_xdg_popup xdg_popup
+ * @section page_iface_xdg_popup_desc Description
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ * @section page_iface_xdg_popup_api API
+ * See @ref iface_xdg_popup.
+ */
+/**
+ * @defgroup iface_xdg_popup The xdg_popup interface
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ */
+extern const struct wl_interface xdg_popup_interface;
+#endif
+
+#ifndef XDG_WM_BASE_ERROR_ENUM
+#define XDG_WM_BASE_ERROR_ENUM
+enum xdg_wm_base_error {
+ /**
+ * given wl_surface has another role
+ */
+ XDG_WM_BASE_ERROR_ROLE = 0,
+ /**
+ * xdg_wm_base was destroyed before children
+ */
+ XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1,
+ /**
+ * the client tried to map or destroy a non-topmost popup
+ */
+ XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2,
+ /**
+ * the client specified an invalid popup parent surface
+ */
+ XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3,
+ /**
+ * the client provided an invalid surface state
+ */
+ XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4,
+ /**
+ * the client provided an invalid positioner
+ */
+ XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5,
+ /**
+ * the client didn’t respond to a ping event in time
+ */
+ XDG_WM_BASE_ERROR_UNRESPONSIVE = 6,
+};
+#endif /* XDG_WM_BASE_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_wm_base
+ * @struct xdg_wm_base_listener
+ */
+struct xdg_wm_base_listener {
+ /**
+ * check if the client is alive
+ *
+ * The ping event asks the client if it's still alive. Pass the
+ * serial specified in the event back to the compositor by sending
+ * a "pong" request back with the specified serial. See
+ * xdg_wm_base.pong.
+ *
+ * Compositors can use this to determine if the client is still
+ * alive. It's unspecified what will happen if the client doesn't
+ * respond to the ping request, or in what timeframe. Clients
+ * should try to respond in a reasonable amount of time. The
+ * “unresponsive” error is provided for compositors that wish
+ * to disconnect unresponsive clients.
+ *
+ * A compositor is free to ping in any way it wants, but a client
+ * must always respond to any xdg_wm_base object it created.
+ * @param serial pass this to the pong request
+ */
+ void (*ping)(void *data,
+ struct xdg_wm_base *xdg_wm_base,
+ uint32_t serial);
+};
+
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+static inline int
+xdg_wm_base_add_listener(struct xdg_wm_base *xdg_wm_base,
+ const struct xdg_wm_base_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) xdg_wm_base,
+ (void (**)(void)) listener, data);
+}
+
+#define XDG_WM_BASE_DESTROY 0
+#define XDG_WM_BASE_CREATE_POSITIONER 1
+#define XDG_WM_BASE_GET_XDG_SURFACE 2
+#define XDG_WM_BASE_PONG 3
+
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_PING_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_PONG_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_wm_base */
+static inline void
+xdg_wm_base_set_user_data(struct xdg_wm_base *xdg_wm_base, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) xdg_wm_base, user_data);
+}
+
+/** @ingroup iface_xdg_wm_base */
+static inline void *
+xdg_wm_base_get_user_data(struct xdg_wm_base *xdg_wm_base)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) xdg_wm_base);
+}
+
+static inline uint32_t
+xdg_wm_base_get_version(struct xdg_wm_base *xdg_wm_base)
+{
+ return wl_proxy_get_version((struct wl_proxy *) xdg_wm_base);
+}
+
+/**
+ * @ingroup iface_xdg_wm_base
+ *
+ * Destroy this xdg_wm_base object.
+ *
+ * Destroying a bound xdg_wm_base object while there are surfaces
+ * still alive created by this xdg_wm_base object instance is illegal
+ * and will result in a defunct_surfaces error.
+ */
+static inline void
+xdg_wm_base_destroy(struct xdg_wm_base *xdg_wm_base)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
+ XDG_WM_BASE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_wm_base
+ *
+ * Create a positioner object. A positioner object is used to position
+ * surfaces relative to some parent surface. See the interface description
+ * and xdg_surface.get_popup for details.
+ */
+static inline struct xdg_positioner *
+xdg_wm_base_create_positioner(struct xdg_wm_base *xdg_wm_base)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
+ XDG_WM_BASE_CREATE_POSITIONER, &xdg_positioner_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL);
+
+ return (struct xdg_positioner *) id;
+}
+
+/**
+ * @ingroup iface_xdg_wm_base
+ *
+ * This creates an xdg_surface for the given surface. While xdg_surface
+ * itself is not a role, the corresponding surface may only be assigned
+ * a role extending xdg_surface, such as xdg_toplevel or xdg_popup. It is
+ * illegal to create an xdg_surface for a wl_surface which already has an
+ * assigned role and this will result in a role error.
+ *
+ * This creates an xdg_surface for the given surface. An xdg_surface is
+ * used as basis to define a role to a given surface, such as xdg_toplevel
+ * or xdg_popup. It also manages functionality shared between xdg_surface
+ * based surface roles.
+ *
+ * See the documentation of xdg_surface for more details about what an
+ * xdg_surface is and how it is used.
+ */
+static inline struct xdg_surface *
+xdg_wm_base_get_xdg_surface(struct xdg_wm_base *xdg_wm_base, struct wl_surface *surface)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
+ XDG_WM_BASE_GET_XDG_SURFACE, &xdg_surface_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL, surface);
+
+ return (struct xdg_surface *) id;
+}
+
+/**
+ * @ingroup iface_xdg_wm_base
+ *
+ * A client must respond to a ping event with a pong request or
+ * the client may be deemed unresponsive. See xdg_wm_base.ping
+ * and xdg_wm_base.error.unresponsive.
+ */
+static inline void
+xdg_wm_base_pong(struct xdg_wm_base *xdg_wm_base, uint32_t serial)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
+ XDG_WM_BASE_PONG, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, serial);
+}
+
+#ifndef XDG_POSITIONER_ERROR_ENUM
+#define XDG_POSITIONER_ERROR_ENUM
+enum xdg_positioner_error {
+ /**
+ * invalid input provided
+ */
+ XDG_POSITIONER_ERROR_INVALID_INPUT = 0,
+};
+#endif /* XDG_POSITIONER_ERROR_ENUM */
+
+#ifndef XDG_POSITIONER_ANCHOR_ENUM
+#define XDG_POSITIONER_ANCHOR_ENUM
+enum xdg_positioner_anchor {
+ XDG_POSITIONER_ANCHOR_NONE = 0,
+ XDG_POSITIONER_ANCHOR_TOP = 1,
+ XDG_POSITIONER_ANCHOR_BOTTOM = 2,
+ XDG_POSITIONER_ANCHOR_LEFT = 3,
+ XDG_POSITIONER_ANCHOR_RIGHT = 4,
+ XDG_POSITIONER_ANCHOR_TOP_LEFT = 5,
+ XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6,
+ XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7,
+ XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8,
+};
+#endif /* XDG_POSITIONER_ANCHOR_ENUM */
+
+#ifndef XDG_POSITIONER_GRAVITY_ENUM
+#define XDG_POSITIONER_GRAVITY_ENUM
+enum xdg_positioner_gravity {
+ XDG_POSITIONER_GRAVITY_NONE = 0,
+ XDG_POSITIONER_GRAVITY_TOP = 1,
+ XDG_POSITIONER_GRAVITY_BOTTOM = 2,
+ XDG_POSITIONER_GRAVITY_LEFT = 3,
+ XDG_POSITIONER_GRAVITY_RIGHT = 4,
+ XDG_POSITIONER_GRAVITY_TOP_LEFT = 5,
+ XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6,
+ XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7,
+ XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8,
+};
+#endif /* XDG_POSITIONER_GRAVITY_ENUM */
+
+#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
+#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
+/**
+ * @ingroup iface_xdg_positioner
+ * constraint adjustments
+ *
+ * The constraint adjustment value define ways the compositor will adjust
+ * the position of the surface, if the unadjusted position would result
+ * in the surface being partly constrained.
+ *
+ * Whether a surface is considered 'constrained' is left to the compositor
+ * to determine. For example, the surface may be partly outside the
+ * compositor's defined 'work area', thus necessitating the child surface's
+ * position be adjusted until it is entirely inside the work area.
+ *
+ * The adjustments can be combined, according to a defined precedence: 1)
+ * Flip, 2) Slide, 3) Resize.
+ */
+enum xdg_positioner_constraint_adjustment {
+ /**
+ * don't move the child surface when constrained
+ *
+ * Don't alter the surface position even if it is constrained on
+ * some axis, for example partially outside the edge of an output.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0,
+ /**
+ * move along the x axis until unconstrained
+ *
+ * Slide the surface along the x axis until it is no longer
+ * constrained.
+ *
+ * First try to slide towards the direction of the gravity on the x
+ * axis until either the edge in the opposite direction of the
+ * gravity is unconstrained or the edge in the direction of the
+ * gravity is constrained.
+ *
+ * Then try to slide towards the opposite direction of the gravity
+ * on the x axis until either the edge in the direction of the
+ * gravity is unconstrained or the edge in the opposite direction
+ * of the gravity is constrained.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
+ /**
+ * move along the y axis until unconstrained
+ *
+ * Slide the surface along the y axis until it is no longer
+ * constrained.
+ *
+ * First try to slide towards the direction of the gravity on the y
+ * axis until either the edge in the opposite direction of the
+ * gravity is unconstrained or the edge in the direction of the
+ * gravity is constrained.
+ *
+ * Then try to slide towards the opposite direction of the gravity
+ * on the y axis until either the edge in the direction of the
+ * gravity is unconstrained or the edge in the opposite direction
+ * of the gravity is constrained.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
+ /**
+ * invert the anchor and gravity on the x axis
+ *
+ * Invert the anchor and gravity on the x axis if the surface is
+ * constrained on the x axis. For example, if the left edge of the
+ * surface is constrained, the gravity is 'left' and the anchor is
+ * 'left', change the gravity to 'right' and the anchor to 'right'.
+ *
+ * If the adjusted position also ends up being constrained, the
+ * resulting position of the flip_x adjustment will be the one
+ * before the adjustment.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
+ /**
+ * invert the anchor and gravity on the y axis
+ *
+ * Invert the anchor and gravity on the y axis if the surface is
+ * constrained on the y axis. For example, if the bottom edge of
+ * the surface is constrained, the gravity is 'bottom' and the
+ * anchor is 'bottom', change the gravity to 'top' and the anchor
+ * to 'top'.
+ *
+ * The adjusted position is calculated given the original anchor
+ * rectangle and offset, but with the new flipped anchor and
+ * gravity values.
+ *
+ * If the adjusted position also ends up being constrained, the
+ * resulting position of the flip_y adjustment will be the one
+ * before the adjustment.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
+ /**
+ * horizontally resize the surface
+ *
+ * Resize the surface horizontally so that it is completely
+ * unconstrained.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
+ /**
+ * vertically resize the surface
+ *
+ * Resize the surface vertically so that it is completely
+ * unconstrained.
+ */
+ XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
+};
+#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM */
+
+#define XDG_POSITIONER_DESTROY 0
+#define XDG_POSITIONER_SET_SIZE 1
+#define XDG_POSITIONER_SET_ANCHOR_RECT 2
+#define XDG_POSITIONER_SET_ANCHOR 3
+#define XDG_POSITIONER_SET_GRAVITY 4
+#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT 5
+#define XDG_POSITIONER_SET_OFFSET 6
+#define XDG_POSITIONER_SET_REACTIVE 7
+#define XDG_POSITIONER_SET_PARENT_SIZE 8
+#define XDG_POSITIONER_SET_PARENT_CONFIGURE 9
+
+
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3
+
+/** @ingroup iface_xdg_positioner */
+static inline void
+xdg_positioner_set_user_data(struct xdg_positioner *xdg_positioner, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) xdg_positioner, user_data);
+}
+
+/** @ingroup iface_xdg_positioner */
+static inline void *
+xdg_positioner_get_user_data(struct xdg_positioner *xdg_positioner)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) xdg_positioner);
+}
+
+static inline uint32_t
+xdg_positioner_get_version(struct xdg_positioner *xdg_positioner)
+{
+ return wl_proxy_get_version((struct wl_proxy *) xdg_positioner);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Notify the compositor that the xdg_positioner will no longer be used.
+ */
+static inline void
+xdg_positioner_destroy(struct xdg_positioner *xdg_positioner)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Set the size of the surface that is to be positioned with the positioner
+ * object. The size is in surface-local coordinates and corresponds to the
+ * window geometry. See xdg_surface.set_window_geometry.
+ *
+ * If a zero or negative size is set the invalid_input error is raised.
+ */
+static inline void
+xdg_positioner_set_size(struct xdg_positioner *xdg_positioner, int32_t width, int32_t height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Specify the anchor rectangle within the parent surface that the child
+ * surface will be placed relative to. The rectangle is relative to the
+ * window geometry as defined by xdg_surface.set_window_geometry of the
+ * parent surface.
+ *
+ * When the xdg_positioner object is used to position a child surface, the
+ * anchor rectangle may not extend outside the window geometry of the
+ * positioned child's parent surface.
+ *
+ * If a negative size is set the invalid_input error is raised.
+ */
+static inline void
+xdg_positioner_set_anchor_rect(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_ANCHOR_RECT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Defines the anchor point for the anchor rectangle. The specified anchor
+ * is used derive an anchor point that the child surface will be
+ * positioned relative to. If a corner anchor is set (e.g. 'top_left' or
+ * 'bottom_right'), the anchor point will be at the specified corner;
+ * otherwise, the derived anchor point will be centered on the specified
+ * edge, or in the center of the anchor rectangle if no edge is specified.
+ */
+static inline void
+xdg_positioner_set_anchor(struct xdg_positioner *xdg_positioner, uint32_t anchor)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_ANCHOR, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, anchor);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Defines in what direction a surface should be positioned, relative to
+ * the anchor point of the parent surface. If a corner gravity is
+ * specified (e.g. 'bottom_right' or 'top_left'), then the child surface
+ * will be placed towards the specified gravity; otherwise, the child
+ * surface will be centered over the anchor point on any axis that had no
+ * gravity specified. If the gravity is not in the ‘gravity’ enum, an
+ * invalid_input error is raised.
+ */
+static inline void
+xdg_positioner_set_gravity(struct xdg_positioner *xdg_positioner, uint32_t gravity)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_GRAVITY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, gravity);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Specify how the window should be positioned if the originally intended
+ * position caused the surface to be constrained, meaning at least
+ * partially outside positioning boundaries set by the compositor. The
+ * adjustment is set by constructing a bitmask describing the adjustment to
+ * be made when the surface is constrained on that axis.
+ *
+ * If no bit for one axis is set, the compositor will assume that the child
+ * surface should not change its position on that axis when constrained.
+ *
+ * If more than one bit for one axis is set, the order of how adjustments
+ * are applied is specified in the corresponding adjustment descriptions.
+ *
+ * The default adjustment is none.
+ */
+static inline void
+xdg_positioner_set_constraint_adjustment(struct xdg_positioner *xdg_positioner, uint32_t constraint_adjustment)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, constraint_adjustment);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Specify the surface position offset relative to the position of the
+ * anchor on the anchor rectangle and the anchor on the surface. For
+ * example if the anchor of the anchor rectangle is at (x, y), the surface
+ * has the gravity bottom|right, and the offset is (ox, oy), the calculated
+ * surface position will be (x + ox, y + oy). The offset position of the
+ * surface is the one used for constraint testing. See
+ * set_constraint_adjustment.
+ *
+ * An example use case is placing a popup menu on top of a user interface
+ * element, while aligning the user interface element of the parent surface
+ * with some user interface element placed somewhere in the popup surface.
+ */
+static inline void
+xdg_positioner_set_offset(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_OFFSET, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * When set reactive, the surface is reconstrained if the conditions used
+ * for constraining changed, e.g. the parent window moved.
+ *
+ * If the conditions changed and the popup was reconstrained, an
+ * xdg_popup.configure event is sent with updated geometry, followed by an
+ * xdg_surface.configure event.
+ */
+static inline void
+xdg_positioner_set_reactive(struct xdg_positioner *xdg_positioner)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_REACTIVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Set the parent window geometry the compositor should use when
+ * positioning the popup. The compositor may use this information to
+ * determine the future state the popup should be constrained using. If
+ * this doesn't match the dimension of the parent the popup is eventually
+ * positioned against, the behavior is undefined.
+ *
+ * The arguments are given in the surface-local coordinate space.
+ */
+static inline void
+xdg_positioner_set_parent_size(struct xdg_positioner *xdg_positioner, int32_t parent_width, int32_t parent_height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_PARENT_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, parent_width, parent_height);
+}
+
+/**
+ * @ingroup iface_xdg_positioner
+ *
+ * Set the serial of an xdg_surface.configure event this positioner will be
+ * used in response to. The compositor may use this information together
+ * with set_parent_size to determine what future state the popup should be
+ * constrained using.
+ */
+static inline void
+xdg_positioner_set_parent_configure(struct xdg_positioner *xdg_positioner, uint32_t serial)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
+ XDG_POSITIONER_SET_PARENT_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, serial);
+}
+
+#ifndef XDG_SURFACE_ERROR_ENUM
+#define XDG_SURFACE_ERROR_ENUM
+enum xdg_surface_error {
+ /**
+ * Surface was not fully constructed
+ */
+ XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1,
+ /**
+ * Surface was already constructed
+ */
+ XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2,
+ /**
+ * Attaching a buffer to an unconfigured surface
+ */
+ XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3,
+ /**
+ * Invalid serial number when acking a configure event
+ */
+ XDG_SURFACE_ERROR_INVALID_SERIAL = 4,
+ /**
+ * Width or height was zero or negative
+ */
+ XDG_SURFACE_ERROR_INVALID_SIZE = 5,
+};
+#endif /* XDG_SURFACE_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_surface
+ * @struct xdg_surface_listener
+ */
+struct xdg_surface_listener {
+ /**
+ * suggest a surface change
+ *
+ * The configure event marks the end of a configure sequence. A
+ * configure sequence is a set of one or more events configuring
+ * the state of the xdg_surface, including the final
+ * xdg_surface.configure event.
+ *
+ * Where applicable, xdg_surface surface roles will during a
+ * configure sequence extend this event as a latched state sent as
+ * events before the xdg_surface.configure event. Such events
+ * should be considered to make up a set of atomically applied
+ * configuration states, where the xdg_surface.configure commits
+ * the accumulated state.
+ *
+ * Clients should arrange their surface for the new states, and
+ * then send an ack_configure request with the serial sent in this
+ * configure event at some point before committing the new surface.
+ *
+ * If the client receives multiple configure events before it can
+ * respond to one, it is free to discard all but the last event it
+ * received.
+ * @param serial serial of the configure event
+ */
+ void (*configure)(void *data,
+ struct xdg_surface *xdg_surface,
+ uint32_t serial);
+};
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+static inline int
+xdg_surface_add_listener(struct xdg_surface *xdg_surface,
+ const struct xdg_surface_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) xdg_surface,
+ (void (**)(void)) listener, data);
+}
+
+#define XDG_SURFACE_DESTROY 0
+#define XDG_SURFACE_GET_TOPLEVEL 1
+#define XDG_SURFACE_GET_POPUP 2
+#define XDG_SURFACE_SET_WINDOW_GEOMETRY 3
+#define XDG_SURFACE_ACK_CONFIGURE 4
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_surface */
+static inline void
+xdg_surface_set_user_data(struct xdg_surface *xdg_surface, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) xdg_surface, user_data);
+}
+
+/** @ingroup iface_xdg_surface */
+static inline void *
+xdg_surface_get_user_data(struct xdg_surface *xdg_surface)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) xdg_surface);
+}
+
+static inline uint32_t
+xdg_surface_get_version(struct xdg_surface *xdg_surface)
+{
+ return wl_proxy_get_version((struct wl_proxy *) xdg_surface);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Destroy the xdg_surface object. An xdg_surface must only be destroyed
+ * after its role object has been destroyed.
+ */
+static inline void
+xdg_surface_destroy(struct xdg_surface *xdg_surface)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
+ XDG_SURFACE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * This creates an xdg_toplevel object for the given xdg_surface and gives
+ * the associated wl_surface the xdg_toplevel role.
+ *
+ * See the documentation of xdg_toplevel for more details about what an
+ * xdg_toplevel is and how it is used.
+ */
+static inline struct xdg_toplevel *
+xdg_surface_get_toplevel(struct xdg_surface *xdg_surface)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
+ XDG_SURFACE_GET_TOPLEVEL, &xdg_toplevel_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL);
+
+ return (struct xdg_toplevel *) id;
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * This creates an xdg_popup object for the given xdg_surface and gives
+ * the associated wl_surface the xdg_popup role.
+ *
+ * If null is passed as a parent, a parent surface must be specified using
+ * some other protocol, before committing the initial state.
+ *
+ * See the documentation of xdg_popup for more details about what an
+ * xdg_popup is and how it is used.
+ */
+static inline struct xdg_popup *
+xdg_surface_get_popup(struct xdg_surface *xdg_surface, struct xdg_surface *parent, struct xdg_positioner *positioner)
+{
+ struct wl_proxy *id;
+
+ id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
+ XDG_SURFACE_GET_POPUP, &xdg_popup_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL, parent, positioner);
+
+ return (struct xdg_popup *) id;
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * The window geometry of a surface is its "visible bounds" from the
+ * user's perspective. Client-side decorations often have invisible
+ * portions like drop-shadows which should be ignored for the
+ * purposes of aligning, placing and constraining windows.
+ *
+ * The window geometry is double buffered, and will be applied at the
+ * time wl_surface.commit of the corresponding wl_surface is called.
+ *
+ * When maintaining a position, the compositor should treat the (x, y)
+ * coordinate of the window geometry as the top left corner of the window.
+ * A client changing the (x, y) window geometry coordinate should in
+ * general not alter the position of the window.
+ *
+ * Once the window geometry of the surface is set, it is not possible to
+ * unset it, and it will remain the same until set_window_geometry is
+ * called again, even if a new subsurface or buffer is attached.
+ *
+ * If never set, the value is the full bounds of the surface,
+ * including any subsurfaces. This updates dynamically on every
+ * commit. This unset is meant for extremely simple clients.
+ *
+ * The arguments are given in the surface-local coordinate space of
+ * the wl_surface associated with this xdg_surface.
+ *
+ * The width and height must be greater than zero. Setting an invalid size
+ * will raise an invalid_size error. When applied, the effective window
+ * geometry will be the set window geometry clamped to the bounding
+ * rectangle of the combined geometry of the surface of the xdg_surface and
+ * the associated subsurfaces.
+ */
+static inline void
+xdg_surface_set_window_geometry(struct xdg_surface *xdg_surface, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
+ XDG_SURFACE_SET_WINDOW_GEOMETRY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * When a configure event is received, if a client commits the
+ * surface in response to the configure event, then the client
+ * must make an ack_configure request sometime before the commit
+ * request, passing along the serial of the configure event.
+ *
+ * For instance, for toplevel surfaces the compositor might use this
+ * information to move a surface to the top left only when the client has
+ * drawn itself for the maximized or fullscreen state.
+ *
+ * If the client receives multiple configure events before it
+ * can respond to one, it only has to ack the last configure event.
+ * Acking a configure event that was never sent raises an invalid_serial
+ * error.
+ *
+ * A client is not required to commit immediately after sending
+ * an ack_configure request - it may even ack_configure several times
+ * before its next surface commit.
+ *
+ * A client may send multiple ack_configure requests before committing, but
+ * only the last request sent before a commit indicates which configure
+ * event the client really is responding to.
+ *
+ * Sending an ack_configure request consumes the serial number sent with
+ * the request, as well as serial numbers sent by all configure events
+ * sent on this xdg_surface prior to the configure event referenced by
+ * the committed serial.
+ *
+ * It is an error to issue multiple ack_configure requests referencing a
+ * serial from the same configure event, or to issue an ack_configure
+ * request referencing a serial from a configure event issued before the
+ * event identified by the last ack_configure request for the same
+ * xdg_surface. Doing so will raise an invalid_serial error.
+ */
+static inline void
+xdg_surface_ack_configure(struct xdg_surface *xdg_surface, uint32_t serial)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
+ XDG_SURFACE_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, serial);
+}
+
+#ifndef XDG_TOPLEVEL_ERROR_ENUM
+#define XDG_TOPLEVEL_ERROR_ENUM
+enum xdg_toplevel_error {
+ /**
+ * provided value is not a valid variant of the resize_edge enum
+ */
+ XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE = 0,
+ /**
+ * invalid parent toplevel
+ */
+ XDG_TOPLEVEL_ERROR_INVALID_PARENT = 1,
+ /**
+ * client provided an invalid min or max size
+ */
+ XDG_TOPLEVEL_ERROR_INVALID_SIZE = 2,
+};
+#endif /* XDG_TOPLEVEL_ERROR_ENUM */
+
+#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM
+#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM
+/**
+ * @ingroup iface_xdg_toplevel
+ * edge values for resizing
+ *
+ * These values are used to indicate which edge of a surface
+ * is being dragged in a resize operation.
+ */
+enum xdg_toplevel_resize_edge {
+ XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0,
+ XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1,
+ XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2,
+ XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4,
+ XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5,
+ XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6,
+ XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8,
+ XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9,
+ XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10,
+};
+#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM */
+
+#ifndef XDG_TOPLEVEL_STATE_ENUM
+#define XDG_TOPLEVEL_STATE_ENUM
+/**
+ * @ingroup iface_xdg_toplevel
+ * types of state on the surface
+ *
+ * The different state values used on the surface. This is designed for
+ * state values like maximized, fullscreen. It is paired with the
+ * configure event to ensure that both the client and the compositor
+ * setting the state can be synchronized.
+ *
+ * States set in this way are double-buffered. They will get applied on
+ * the next commit.
+ */
+enum xdg_toplevel_state {
+ /**
+ * the surface is maximized
+ * the surface is maximized
+ *
+ * The surface is maximized. The window geometry specified in the
+ * configure event must be obeyed by the client.
+ *
+ * The client should draw without shadow or other decoration
+ * outside of the window geometry.
+ */
+ XDG_TOPLEVEL_STATE_MAXIMIZED = 1,
+ /**
+ * the surface is fullscreen
+ * the surface is fullscreen
+ *
+ * The surface is fullscreen. The window geometry specified in
+ * the configure event is a maximum; the client cannot resize
+ * beyond it. For a surface to cover the whole fullscreened area,
+ * the geometry dimensions must be obeyed by the client. For more
+ * details, see xdg_toplevel.set_fullscreen.
+ */
+ XDG_TOPLEVEL_STATE_FULLSCREEN = 2,
+ /**
+ * the surface is being resized
+ * the surface is being resized
+ *
+ * The surface is being resized. The window geometry specified in
+ * the configure event is a maximum; the client cannot resize
+ * beyond it. Clients that have aspect ratio or cell sizing
+ * configuration can use a smaller size, however.
+ */
+ XDG_TOPLEVEL_STATE_RESIZING = 3,
+ /**
+ * the surface is now activated
+ * the surface is now activated
+ *
+ * Client window decorations should be painted as if the window
+ * is active. Do not assume this means that the window actually has
+ * keyboard or pointer focus.
+ */
+ XDG_TOPLEVEL_STATE_ACTIVATED = 4,
+ /**
+ * the surface’s left edge is tiled
+ *
+ * The window is currently in a tiled layout and the left edge is
+ * considered to be adjacent to another part of the tiling grid.
+ * @since 2
+ */
+ XDG_TOPLEVEL_STATE_TILED_LEFT = 5,
+ /**
+ * the surface’s right edge is tiled
+ *
+ * The window is currently in a tiled layout and the right edge
+ * is considered to be adjacent to another part of the tiling grid.
+ * @since 2
+ */
+ XDG_TOPLEVEL_STATE_TILED_RIGHT = 6,
+ /**
+ * the surface’s top edge is tiled
+ *
+ * The window is currently in a tiled layout and the top edge is
+ * considered to be adjacent to another part of the tiling grid.
+ * @since 2
+ */
+ XDG_TOPLEVEL_STATE_TILED_TOP = 7,
+ /**
+ * the surface’s bottom edge is tiled
+ *
+ * The window is currently in a tiled layout and the bottom edge
+ * is considered to be adjacent to another part of the tiling grid.
+ * @since 2
+ */
+ XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8,
+};
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2
+#endif /* XDG_TOPLEVEL_STATE_ENUM */
+
+#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
+#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
+enum xdg_toplevel_wm_capabilities {
+ /**
+ * show_window_menu is available
+ */
+ XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU = 1,
+ /**
+ * set_maximized and unset_maximized are available
+ */
+ XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE = 2,
+ /**
+ * set_fullscreen and unset_fullscreen are available
+ */
+ XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN = 3,
+ /**
+ * set_minimized is available
+ */
+ XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE = 4,
+};
+#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM */
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * @struct xdg_toplevel_listener
+ */
+struct xdg_toplevel_listener {
+ /**
+ * suggest a surface change
+ *
+ * This configure event asks the client to resize its toplevel
+ * surface or to change its state. The configured state should not
+ * be applied immediately. See xdg_surface.configure for details.
+ *
+ * The width and height arguments specify a hint to the window
+ * about how its surface should be resized in window geometry
+ * coordinates. See set_window_geometry.
+ *
+ * If the width or height arguments are zero, it means the client
+ * should decide its own window dimension. This may happen when the
+ * compositor needs to configure the state of the surface but
+ * doesn't have any information about any previous or expected
+ * dimension.
+ *
+ * The states listed in the event specify how the width/height
+ * arguments should be interpreted, and possibly how it should be
+ * drawn.
+ *
+ * Clients must send an ack_configure in response to this event.
+ * See xdg_surface.configure and xdg_surface.ack_configure for
+ * details.
+ */
+ void (*configure)(void *data,
+ struct xdg_toplevel *xdg_toplevel,
+ int32_t width,
+ int32_t height,
+ struct wl_array *states);
+ /**
+ * surface wants to be closed
+ *
+ * The close event is sent by the compositor when the user wants
+ * the surface to be closed. This should be equivalent to the user
+ * clicking the close button in client-side decorations, if your
+ * application has any.
+ *
+ * This is only a request that the user intends to close the
+ * window. The client may choose to ignore this request, or show a
+ * dialog to ask the user to save their data, etc.
+ */
+ void (*close)(void *data,
+ struct xdg_toplevel *xdg_toplevel);
+ /**
+ * recommended window geometry bounds
+ *
+ * The configure_bounds event may be sent prior to a
+ * xdg_toplevel.configure event to communicate the bounds a window
+ * geometry size is recommended to constrain to.
+ *
+ * The passed width and height are in surface coordinate space. If
+ * width and height are 0, it means bounds is unknown and
+ * equivalent to as if no configure_bounds event was ever sent for
+ * this surface.
+ *
+ * The bounds can for example correspond to the size of a monitor
+ * excluding any panels or other shell components, so that a
+ * surface isn't created in a way that it cannot fit.
+ *
+ * The bounds may change at any point, and in such a case, a new
+ * xdg_toplevel.configure_bounds will be sent, followed by
+ * xdg_toplevel.configure and xdg_surface.configure.
+ * @since 4
+ */
+ void (*configure_bounds)(void *data,
+ struct xdg_toplevel *xdg_toplevel,
+ int32_t width,
+ int32_t height);
+ /**
+ * compositor capabilities
+ *
+ * This event advertises the capabilities supported by the
+ * compositor. If a capability isn't supported, clients should hide
+ * or disable the UI elements that expose this functionality. For
+ * instance, if the compositor doesn't advertise support for
+ * minimized toplevels, a button triggering the set_minimized
+ * request should not be displayed.
+ *
+ * The compositor will ignore requests it doesn't support. For
+ * instance, a compositor which doesn't advertise support for
+ * minimized will ignore set_minimized requests.
+ *
+ * Compositors must send this event once before the first
+ * xdg_surface.configure event. When the capabilities change,
+ * compositors must send this event again and then send an
+ * xdg_surface.configure event.
+ *
+ * The configured state should not be applied immediately. See
+ * xdg_surface.configure for details.
+ *
+ * The capabilities are sent as an array of 32-bit unsigned
+ * integers in native endianness.
+ * @param capabilities array of 32-bit capabilities
+ * @since 5
+ */
+ void (*wm_capabilities)(void *data,
+ struct xdg_toplevel *xdg_toplevel,
+ struct wl_array *capabilities);
+};
+
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+static inline int
+xdg_toplevel_add_listener(struct xdg_toplevel *xdg_toplevel,
+ const struct xdg_toplevel_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) xdg_toplevel,
+ (void (**)(void)) listener, data);
+}
+
+#define XDG_TOPLEVEL_DESTROY 0
+#define XDG_TOPLEVEL_SET_PARENT 1
+#define XDG_TOPLEVEL_SET_TITLE 2
+#define XDG_TOPLEVEL_SET_APP_ID 3
+#define XDG_TOPLEVEL_SHOW_WINDOW_MENU 4
+#define XDG_TOPLEVEL_MOVE 5
+#define XDG_TOPLEVEL_RESIZE 6
+#define XDG_TOPLEVEL_SET_MAX_SIZE 7
+#define XDG_TOPLEVEL_SET_MIN_SIZE 8
+#define XDG_TOPLEVEL_SET_MAXIMIZED 9
+#define XDG_TOPLEVEL_UNSET_MAXIMIZED 10
+#define XDG_TOPLEVEL_SET_FULLSCREEN 11
+#define XDG_TOPLEVEL_UNSET_FULLSCREEN 12
+#define XDG_TOPLEVEL_SET_MINIMIZED 13
+
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION 4
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION 5
+
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_toplevel */
+static inline void
+xdg_toplevel_set_user_data(struct xdg_toplevel *xdg_toplevel, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) xdg_toplevel, user_data);
+}
+
+/** @ingroup iface_xdg_toplevel */
+static inline void *
+xdg_toplevel_get_user_data(struct xdg_toplevel *xdg_toplevel)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) xdg_toplevel);
+}
+
+static inline uint32_t
+xdg_toplevel_get_version(struct xdg_toplevel *xdg_toplevel)
+{
+ return wl_proxy_get_version((struct wl_proxy *) xdg_toplevel);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * This request destroys the role surface and unmaps the surface;
+ * see "Unmapping" behavior in interface section for details.
+ */
+static inline void
+xdg_toplevel_destroy(struct xdg_toplevel *xdg_toplevel)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Set the "parent" of this surface. This surface should be stacked
+ * above the parent surface and all other ancestor surfaces.
+ *
+ * Parent surfaces should be set on dialogs, toolboxes, or other
+ * "auxiliary" surfaces, so that the parent is raised when the dialog
+ * is raised.
+ *
+ * Setting a null parent for a child surface unsets its parent. Setting
+ * a null parent for a surface which currently has no parent is a no-op.
+ *
+ * Only mapped surfaces can have child surfaces. Setting a parent which
+ * is not mapped is equivalent to setting a null parent. If a surface
+ * becomes unmapped, its children's parent is set to the parent of
+ * the now-unmapped surface. If the now-unmapped surface has no parent,
+ * its children's parent is unset. If the now-unmapped surface becomes
+ * mapped again, its parent-child relationship is not restored.
+ *
+ * The parent toplevel must not be one of the child toplevel's
+ * descendants, and the parent must be different from the child toplevel,
+ * otherwise the invalid_parent protocol error is raised.
+ */
+static inline void
+xdg_toplevel_set_parent(struct xdg_toplevel *xdg_toplevel, struct xdg_toplevel *parent)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_PARENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, parent);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Set a short title for the surface.
+ *
+ * This string may be used to identify the surface in a task bar,
+ * window list, or other user interface elements provided by the
+ * compositor.
+ *
+ * The string must be encoded in UTF-8.
+ */
+static inline void
+xdg_toplevel_set_title(struct xdg_toplevel *xdg_toplevel, const char *title)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_TITLE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, title);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Set an application identifier for the surface.
+ *
+ * The app ID identifies the general class of applications to which
+ * the surface belongs. The compositor can use this to group multiple
+ * surfaces together, or to determine how to launch a new application.
+ *
+ * For D-Bus activatable applications, the app ID is used as the D-Bus
+ * service name.
+ *
+ * The compositor shell will try to group application surfaces together
+ * by their app ID. As a best practice, it is suggested to select app
+ * ID's that match the basename of the application's .desktop file.
+ * For example, "org.freedesktop.FooViewer" where the .desktop file is
+ * "org.freedesktop.FooViewer.desktop".
+ *
+ * Like other properties, a set_app_id request can be sent after the
+ * xdg_toplevel has been mapped to update the property.
+ *
+ * See the desktop-entry specification [0] for more details on
+ * application identifiers and how they relate to well-known D-Bus
+ * names and .desktop files.
+ *
+ * [0] https://standards.freedesktop.org/desktop-entry-spec/
+ */
+static inline void
+xdg_toplevel_set_app_id(struct xdg_toplevel *xdg_toplevel, const char *app_id)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_APP_ID, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, app_id);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Clients implementing client-side decorations might want to show
+ * a context menu when right-clicking on the decorations, giving the
+ * user a menu that they can use to maximize or minimize the window.
+ *
+ * This request asks the compositor to pop up such a window menu at
+ * the given position, relative to the local surface coordinates of
+ * the parent surface. There are no guarantees as to what menu items
+ * the window menu contains, or even if a window menu will be drawn
+ * at all.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event.
+ */
+static inline void
+xdg_toplevel_show_window_menu(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SHOW_WINDOW_MENU, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, x, y);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Start an interactive, user-driven move of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive move (touch,
+ * pointer, etc).
+ *
+ * The server may ignore move requests depending on the state of
+ * the surface (e.g. fullscreen or maximized), or if the passed serial
+ * is no longer valid.
+ *
+ * If triggered, the surface will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the move. It is up to the
+ * compositor to visually indicate that the move is taking place, such as
+ * updating a pointer cursor, during the move. There is no guarantee
+ * that the device focus will return when the move is completed.
+ */
+static inline void
+xdg_toplevel_move(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_MOVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Start a user-driven, interactive resize of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive resize (touch,
+ * pointer, etc).
+ *
+ * The server may ignore resize requests depending on the state of
+ * the surface (e.g. fullscreen or maximized).
+ *
+ * If triggered, the client will receive configure events with the
+ * "resize" state enum value and the expected sizes. See the "resize"
+ * enum value for more details about what is required. The client
+ * must also acknowledge configure events using "ack_configure". After
+ * the resize is completed, the client will receive another "configure"
+ * event without the resize state.
+ *
+ * If triggered, the surface also will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the resize. It is up to the
+ * compositor to visually indicate that the resize is taking place,
+ * such as updating a pointer cursor, during the resize. There is no
+ * guarantee that the device focus will return when the resize is
+ * completed.
+ *
+ * The edges parameter specifies how the surface should be resized, and
+ * is one of the values of the resize_edge enum. Values not matching
+ * a variant of the enum will cause a protocol error. The compositor
+ * may use this information to update the surface position for example
+ * when dragging the top left corner. The compositor may also use
+ * this information to adapt its behavior, e.g. choose an appropriate
+ * cursor image.
+ */
+static inline void
+xdg_toplevel_resize(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, uint32_t edges)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_RESIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, edges);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Set a maximum size for the window.
+ *
+ * The client can specify a maximum size so that the compositor does
+ * not try to configure the window beyond this size.
+ *
+ * The width and height arguments are in window geometry coordinates.
+ * See xdg_surface.set_window_geometry.
+ *
+ * Values set in this way are double-buffered. They will get applied
+ * on the next commit.
+ *
+ * The compositor can use this information to allow or disallow
+ * different states like maximize or fullscreen and draw accurate
+ * animations.
+ *
+ * Similarly, a tiling window manager may use this information to
+ * place and resize client windows in a more effective way.
+ *
+ * The client should not rely on the compositor to obey the maximum
+ * size. The compositor may decide to ignore the values set by the
+ * client and request a larger size.
+ *
+ * If never set, or a value of zero in the request, means that the
+ * client has no expected maximum size in the given dimension.
+ * As a result, a client wishing to reset the maximum size
+ * to an unspecified state can use zero for width and height in the
+ * request.
+ *
+ * Requesting a maximum size to be smaller than the minimum size of
+ * a surface is illegal and will result in an invalid_size error.
+ *
+ * The width and height must be greater than or equal to zero. Using
+ * strictly negative values for width or height will result in a
+ * invalid_size error.
+ */
+static inline void
+xdg_toplevel_set_max_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_MAX_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Set a minimum size for the window.
+ *
+ * The client can specify a minimum size so that the compositor does
+ * not try to configure the window below this size.
+ *
+ * The width and height arguments are in window geometry coordinates.
+ * See xdg_surface.set_window_geometry.
+ *
+ * Values set in this way are double-buffered. They will get applied
+ * on the next commit.
+ *
+ * The compositor can use this information to allow or disallow
+ * different states like maximize or fullscreen and draw accurate
+ * animations.
+ *
+ * Similarly, a tiling window manager may use this information to
+ * place and resize client windows in a more effective way.
+ *
+ * The client should not rely on the compositor to obey the minimum
+ * size. The compositor may decide to ignore the values set by the
+ * client and request a smaller size.
+ *
+ * If never set, or a value of zero in the request, means that the
+ * client has no expected minimum size in the given dimension.
+ * As a result, a client wishing to reset the minimum size
+ * to an unspecified state can use zero for width and height in the
+ * request.
+ *
+ * Requesting a minimum size to be larger than the maximum size of
+ * a surface is illegal and will result in an invalid_size error.
+ *
+ * The width and height must be greater than or equal to zero. Using
+ * strictly negative values for width and height will result in a
+ * invalid_size error.
+ */
+static inline void
+xdg_toplevel_set_min_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_MIN_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Maximize the surface.
+ *
+ * After requesting that the surface should be maximized, the compositor
+ * will respond by emitting a configure event. Whether this configure
+ * actually sets the window maximized is subject to compositor policies.
+ * The client must then update its content, drawing in the configured
+ * state. The client must also acknowledge the configure when committing
+ * the new content (see ack_configure).
+ *
+ * It is up to the compositor to decide how and where to maximize the
+ * surface, for example which output and what region of the screen should
+ * be used.
+ *
+ * If the surface was already maximized, the compositor will still emit
+ * a configure event with the "maximized" state.
+ *
+ * If the surface is in a fullscreen state, this request has no direct
+ * effect. It may alter the state the surface is returned to when
+ * unmaximized unless overridden by the compositor.
+ */
+static inline void
+xdg_toplevel_set_maximized(struct xdg_toplevel *xdg_toplevel)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Unmaximize the surface.
+ *
+ * After requesting that the surface should be unmaximized, the compositor
+ * will respond by emitting a configure event. Whether this actually
+ * un-maximizes the window is subject to compositor policies.
+ * If available and applicable, the compositor will include the window
+ * geometry dimensions the window had prior to being maximized in the
+ * configure event. The client must then update its content, drawing it in
+ * the configured state. The client must also acknowledge the configure
+ * when committing the new content (see ack_configure).
+ *
+ * It is up to the compositor to position the surface after it was
+ * unmaximized; usually the position the surface had before maximizing, if
+ * applicable.
+ *
+ * If the surface was already not maximized, the compositor will still
+ * emit a configure event without the "maximized" state.
+ *
+ * If the surface is in a fullscreen state, this request has no direct
+ * effect. It may alter the state the surface is returned to when
+ * unmaximized unless overridden by the compositor.
+ */
+static inline void
+xdg_toplevel_unset_maximized(struct xdg_toplevel *xdg_toplevel)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_UNSET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Make the surface fullscreen.
+ *
+ * After requesting that the surface should be fullscreened, the
+ * compositor will respond by emitting a configure event. Whether the
+ * client is actually put into a fullscreen state is subject to compositor
+ * policies. The client must also acknowledge the configure when
+ * committing the new content (see ack_configure).
+ *
+ * The output passed by the request indicates the client's preference as
+ * to which display it should be set fullscreen on. If this value is NULL,
+ * it's up to the compositor to choose which display will be used to map
+ * this surface.
+ *
+ * If the surface doesn't cover the whole output, the compositor will
+ * position the surface in the center of the output and compensate with
+ * with border fill covering the rest of the output. The content of the
+ * border fill is undefined, but should be assumed to be in some way that
+ * attempts to blend into the surrounding area (e.g. solid black).
+ *
+ * If the fullscreened surface is not opaque, the compositor must make
+ * sure that other screen content not part of the same surface tree (made
+ * up of subsurfaces, popups or similarly coupled surfaces) are not
+ * visible below the fullscreened surface.
+ */
+static inline void
+xdg_toplevel_set_fullscreen(struct xdg_toplevel *xdg_toplevel, struct wl_output *output)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, output);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Make the surface no longer fullscreen.
+ *
+ * After requesting that the surface should be unfullscreened, the
+ * compositor will respond by emitting a configure event.
+ * Whether this actually removes the fullscreen state of the client is
+ * subject to compositor policies.
+ *
+ * Making a surface unfullscreen sets states for the surface based on the following:
+ * * the state(s) it may have had before becoming fullscreen
+ * * any state(s) decided by the compositor
+ * * any state(s) requested by the client while the surface was fullscreen
+ *
+ * The compositor may include the previous window geometry dimensions in
+ * the configure event, if applicable.
+ *
+ * The client must also acknowledge the configure when committing the new
+ * content (see ack_configure).
+ */
+static inline void
+xdg_toplevel_unset_fullscreen(struct xdg_toplevel *xdg_toplevel)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_UNSET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ *
+ * Request that the compositor minimize your surface. There is no
+ * way to know if the surface is currently minimized, nor is there
+ * any way to unset minimization on this surface.
+ *
+ * If you are looking to throttle redrawing when minimized, please
+ * instead use the wl_surface.frame event for this, as this will
+ * also work with live previews on windows in Alt-Tab, Expose or
+ * similar compositor features.
+ */
+static inline void
+xdg_toplevel_set_minimized(struct xdg_toplevel *xdg_toplevel)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
+ XDG_TOPLEVEL_SET_MINIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
+}
+
+#ifndef XDG_POPUP_ERROR_ENUM
+#define XDG_POPUP_ERROR_ENUM
+enum xdg_popup_error {
+ /**
+ * tried to grab after being mapped
+ */
+ XDG_POPUP_ERROR_INVALID_GRAB = 0,
+};
+#endif /* XDG_POPUP_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_popup
+ * @struct xdg_popup_listener
+ */
+struct xdg_popup_listener {
+ /**
+ * configure the popup surface
+ *
+ * This event asks the popup surface to configure itself given
+ * the configuration. The configured state should not be applied
+ * immediately. See xdg_surface.configure for details.
+ *
+ * The x and y arguments represent the position the popup was
+ * placed at given the xdg_positioner rule, relative to the upper
+ * left corner of the window geometry of the parent surface.
+ *
+ * For version 2 or older, the configure event for an xdg_popup is
+ * only ever sent once for the initial configuration. Starting with
+ * version 3, it may be sent again if the popup is setup with an
+ * xdg_positioner with set_reactive requested, or in response to
+ * xdg_popup.reposition requests.
+ * @param x x position relative to parent surface window geometry
+ * @param y y position relative to parent surface window geometry
+ * @param width window geometry width
+ * @param height window geometry height
+ */
+ void (*configure)(void *data,
+ struct xdg_popup *xdg_popup,
+ int32_t x,
+ int32_t y,
+ int32_t width,
+ int32_t height);
+ /**
+ * popup interaction is done
+ *
+ * The popup_done event is sent out when a popup is dismissed by
+ * the compositor. The client should destroy the xdg_popup object
+ * at this point.
+ */
+ void (*popup_done)(void *data,
+ struct xdg_popup *xdg_popup);
+ /**
+ * signal the completion of a repositioned request
+ *
+ * The repositioned event is sent as part of a popup
+ * configuration sequence, together with xdg_popup.configure and
+ * lastly xdg_surface.configure to notify the completion of a
+ * reposition request.
+ *
+ * The repositioned event is to notify about the completion of a
+ * xdg_popup.reposition request. The token argument is the token
+ * passed in the xdg_popup.reposition request.
+ *
+ * Immediately after this event is emitted, xdg_popup.configure and
+ * xdg_surface.configure will be sent with the updated size and
+ * position, as well as a new configure serial.
+ *
+ * The client should optionally update the content of the popup,
+ * but must acknowledge the new popup configuration for the new
+ * position to take effect. See xdg_surface.ack_configure for
+ * details.
+ * @param token reposition request token
+ * @since 3
+ */
+ void (*repositioned)(void *data,
+ struct xdg_popup *xdg_popup,
+ uint32_t token);
+};
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+static inline int
+xdg_popup_add_listener(struct xdg_popup *xdg_popup,
+ const struct xdg_popup_listener *listener, void *data)
+{
+ return wl_proxy_add_listener((struct wl_proxy *) xdg_popup,
+ (void (**)(void)) listener, data);
+}
+
+#define XDG_POPUP_DESTROY 0
+#define XDG_POPUP_GRAB 1
+#define XDG_POPUP_REPOSITION 2
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_GRAB_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_REPOSITION_SINCE_VERSION 3
+
+/** @ingroup iface_xdg_popup */
+static inline void
+xdg_popup_set_user_data(struct xdg_popup *xdg_popup, void *user_data)
+{
+ wl_proxy_set_user_data((struct wl_proxy *) xdg_popup, user_data);
+}
+
+/** @ingroup iface_xdg_popup */
+static inline void *
+xdg_popup_get_user_data(struct xdg_popup *xdg_popup)
+{
+ return wl_proxy_get_user_data((struct wl_proxy *) xdg_popup);
+}
+
+static inline uint32_t
+xdg_popup_get_version(struct xdg_popup *xdg_popup)
+{
+ return wl_proxy_get_version((struct wl_proxy *) xdg_popup);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ *
+ * This destroys the popup. Explicitly destroying the xdg_popup
+ * object will also dismiss the popup, and unmap the surface.
+ *
+ * If this xdg_popup is not the "topmost" popup, a protocol error
+ * will be sent.
+ */
+static inline void
+xdg_popup_destroy(struct xdg_popup *xdg_popup)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
+ XDG_POPUP_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), WL_MARSHAL_FLAG_DESTROY);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ *
+ * This request makes the created popup take an explicit grab. An explicit
+ * grab will be dismissed when the user dismisses the popup, or when the
+ * client destroys the xdg_popup. This can be done by the user clicking
+ * outside the surface, using the keyboard, or even locking the screen
+ * through closing the lid or a timeout.
+ *
+ * If the compositor denies the grab, the popup will be immediately
+ * dismissed.
+ *
+ * This request must be used in response to some sort of user action like a
+ * button press, key press, or touch down event. The serial number of the
+ * event should be passed as 'serial'.
+ *
+ * The parent of a grabbing popup must either be an xdg_toplevel surface or
+ * another xdg_popup with an explicit grab. If the parent is another
+ * xdg_popup it means that the popups are nested, with this popup now being
+ * the topmost popup.
+ *
+ * Nested popups must be destroyed in the reverse order they were created
+ * in, e.g. the only popup you are allowed to destroy at all times is the
+ * topmost one.
+ *
+ * When compositors choose to dismiss a popup, they may dismiss every
+ * nested grabbing popup as well. When a compositor dismisses popups, it
+ * will follow the same dismissing order as required from the client.
+ *
+ * If the topmost grabbing popup is destroyed, the grab will be returned to
+ * the parent of the popup, if that parent previously had an explicit grab.
+ *
+ * If the parent is a grabbing popup which has already been dismissed, this
+ * popup will be immediately dismissed. If the parent is a popup that did
+ * not take an explicit grab, an error will be raised.
+ *
+ * During a popup grab, the client owning the grab will receive pointer
+ * and touch events for all their surfaces as normal (similar to an
+ * "owner-events" grab in X11 parlance), while the top most grabbing popup
+ * will always have keyboard focus.
+ */
+static inline void
+xdg_popup_grab(struct xdg_popup *xdg_popup, struct wl_seat *seat, uint32_t serial)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
+ XDG_POPUP_GRAB, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, seat, serial);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ *
+ * Reposition an already-mapped popup. The popup will be placed given the
+ * details in the passed xdg_positioner object, and a
+ * xdg_popup.repositioned followed by xdg_popup.configure and
+ * xdg_surface.configure will be emitted in response. Any parameters set
+ * by the previous positioner will be discarded.
+ *
+ * The passed token will be sent in the corresponding
+ * xdg_popup.repositioned event. The new popup position will not take
+ * effect until the corresponding configure event is acknowledged by the
+ * client. See xdg_popup.repositioned for details. The token itself is
+ * opaque, and has no other special meaning.
+ *
+ * If multiple reposition requests are sent, the compositor may skip all
+ * but the last one.
+ *
+ * If the popup is repositioned in response to a configure event for its
+ * parent, the client should send an xdg_positioner.set_parent_configure
+ * and possibly an xdg_positioner.set_parent_size request to allow the
+ * compositor to properly constrain the popup.
+ *
+ * If the popup is repositioned together with a parent that is being
+ * resized, but not in response to a configure event, the client should
+ * send an xdg_positioner.set_parent_size request.
+ */
+static inline void
+xdg_popup_reposition(struct xdg_popup *xdg_popup, struct xdg_positioner *positioner, uint32_t token)
+{
+ wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
+ XDG_POPUP_REPOSITION, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, positioner, token);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/xdg-shell-protocol.o b/xdg-shell-protocol.o
new file mode 100644
index 0000000000000000000000000000000000000000..c9a26c151d79f5e4ede555237d0916adce656fef
GIT binary patch
literal 11824
zcmeI2Yjjgp7ROHsk0KO;Kq)XIDM+a-TMGzc5r~#Y1*`>xsXR>5ByFN;67rxa=n(Co
z1r|~U)(BX!B997#Q$ZPQ1&W}8=&~yE5Ou0N7B8i|v`|Lo?3=yY-LvX^nE5ix@vN1e
zy?%qZ2+`;f6(S|E(Kc$PQN)REjqq1u+3fy+&r=|T
z)n~T^>?W_r?+iFSZo5yoMXo(y3fXc^{-7_%VzmpmM|eH%ToDvrr>vkUKhKnH@!N%8
zhWedz?852PY>V6K@c2wVyEPzD6R5T4`Yf}Zfdb98dfYMzi_;x2S!|C7{ee8YJD|0A
za&n}wX3F%e0q1PH7^Jygi%$kch8%?Q$fR73GdJjyp+PN2c1&G5c?`A)aZlW)qkd-Ci7UxBb#pD;D*HClXD;LsyOi;)qPfHUBdQ=%zayk3*j
zCj1U5i|X?5g2EG&S?77=0eOPLXV>P=6AWs7@+_gqk%4rc)6E=9$eAan*(QQ+t+Bxe
zFDK}7`Q?eUyRn%8l)~Olr$ty@9(m##j>(km3A$~5aktD%o>i;GYsq%HHb?oT44VdnSSZp9aRAQeve7x@dE>Bj@
zo%{Bp1q-uA{i)nAuE(xUd7Hm)*=~{fmBovv70r(Ay|-8K`x$LlB}8A>O}gIsnWCbi
zw?@X-eRJ&CLtFmt_2iz)IrZZY>$`+oFBPv3=+QTBTJJl`W6vC4=C^&haQ4>t_@ljh
zS1vfRa8A){sXcr5JheIf)l1dy?|*0TH&M^^>OS36IjxIWR+{`^s&D_7m9Z=9t%=vV
ze^P&<+wohEUpVS~+;U^jocR~;I@kJOyY~|G{SLlZ{YG7@*aZWpU2+_Kwd<0p!>3(#
zyp%a%-G)%tjfo$J*ADCHZ&SAR!>3NJSbaE<(CTdK0mJei8g$`&YQH%zzvTZ%U~GxK
z$CjO?m#^(Su%Yzl89!HF8C!B@$Y)y(Z};75Yq>FD>xudC1vR#d{fA~$6kbU!dt!UV
zz@JTj$bX{8wTjA`VQc56Uns0ty=htLH#5FocIM={)TdXtv%fwU-ZQeoJ+Oq&_clBy
zjq^SF`N|IOrgTYrs`G78pNk6JsPhWCy7kXp
zUE)~%&Y;)sZLuwFlKIetrw^J9DK}reSQ2ReH*x2vKaV^0!hpl>?*8d16>GAt);V6O
z{BGu^tcR!C1MBwen6cxtZ5w9iiy^zFcW|svI&^Ws@)0|OQ5|)^lR34}@`}dnnpVT4
z+e$>sCpUTBL`Btih=B@@Kz^jrE7Do|Eu`JC@lvCMj6}-6Ld?flY6_L)P1@}%H0V!G
zu8SI!w|?1cZ5|$e<%F?P
zeeRlB<^V+bh<=MQ-g+p=*j>V>YxYgZ%)kkGZ`;?o#r`x|d
z(6?Wt?>2t^bkxYQ(DKKwethMR8#6rboDI!CIAr7NlhNM`HeC((>C%YX;D<_{`e=7d
z*wEfMG4`2^@AenwPU;aqb=)n9t_v;pUY>WYPsz41+1p01YkSMEyY(j%LN}`0ey}aA
zWc2uV7hSpM>c--MzK*u{&(>exKcdaC>Dk>5pVIZea`y=_HZ3jHkT^DD${mIQ1Cs|P
zr{J*Kvz9?Ru&&5vdA&qc@ijFHeLAnyPpzT7rMP%g<>2d@JkdoWVr3P@cy$D8e|4fY
z^BPT^Xw&GRl_2XV#?8p#+6GR39P$k0Rp{4Zor4^27!g7~7kL=3Z_;@lc@6SRoS?PH
zjW~&B=|kBrKafui@^p;~aR9jyA8Lq0vre?dsHT-pv}+2`(>3{KYz)x}eWSxHo#@28
zi20SQI<;scs_=MdyL}aTDIPEJb~3Ixb%W%fQ;Nq+@%IqN<0U@+7j$O+0-uFC;Yiwo
zbYNSPY}deZZjMd1X
zzkK(=I!odS2E0Me_*6Fb6$U&n@-&GqXhTKk33yk=Q_uzuYXg;`XaMJLd5nzHJqakC
zaju`qIL{}GajtJ>ygS-Zh0%t5I4}MMUdDJ2w4o|zoaxGtp^jJKTabqs
z=Q?4=LFY}3FH-nk>I_wQYdjt!<6s&wKAmyUf#)A6
znF_Z>u*hN@O|8YuIOz039f!i{y7e;7b;68;P7>-ADV%hQ8Rt5sjDrq5r$H%aTwC|h
zuTnVWQNuXsP&ut|I`6fNqp5YNV;pqSFdusP0WRx;r5InVa9TfCFwW3XhX9CXU$M=Q`-7U&M<
z5!8uRIOU^foaYnAIGATp$DnZ1No1Vs7#RnX)}M5R|AhLPjB}kV#=)$|c(cMO9|z-H
z$ICdFQP>z#_^rspjB}kL#=(rm#$tshAYZ{a*C}Nj%sa5LoN-uJY2B<+xDovt#?h3$
zggC8mnx9(6c|LWFgE@p6wZ*;hx}tR>nsEp%he2i0GY&e#P$y2|V~`sd2UI0LQ0Tn}
zoNmx*xPDkXaGU%<$z&X*HJ-&d#E-*9v%+b99E@`vFXNyy1sg*Or{|?G<6NhdanQ-e
z#&X8Nr1M&(a3lJZFZ@qWFF#ab&;Wj`{QMQ~7qFoK@2pvoKeVSN-WA(uPYS#fi;qW}
z^y&NME`?X1KSbe+&>yaFZQ+t^l)^_~{^J$i1NkI{cR>EA!fD@UR=5@8T?(I%zF*<=
zJRMT_3#e15@Ot!@D0~gZzo>9}UZs5i&GQkA+o8mh{(gniIsQW7o6-MP;R3J2?-gEv
z{xyYP!~E$yP@XF>?sjY^PS01#3O|AVP=zO9J`X6|g?xg-PvW>!72Xeh+GkNd(Wvtz
zwnK$TQ(C3y>_PqYEFNz~t!1wgKLz8}eUKUXQ6-+9_f9c=x)z{IOH7XPzaM=)*3b>|
zsgfTk2FCgOq7jM??W1U2BpsTJ$x3`gT?iA?hjGK`dl;v+1o|vibmCEHC5s208uZsF
z@%Ll=>q@*47ExJtGS1)EeWmC;iay_WXyc;JMJ3)5kr)4D`Vdd+a147Mi^Eu`TB8l;
zt0US_^+p>w+@mSzCn%iOJ8GwR+P@4|;`7i?Rrr(Wi)4R6UO@f|C|Uk=D^fei3fMyd
zk!-UBEFwAE?-$8FyUU{aU`f{#X={QdO?G*#7HHSP?b*Rx`A#^;Bc(LklAZ0d&u-Fe
z@mbut@;y86;&RGgAYm7o5t)EZns4>wX+JPac6$Q$WckmiB!58u&Pzo6Tz4>8zR~yE
zee&07|9ydb4(=EmO+3xF&ok*eV@^(Qb-8cK><(t728D~mf)HT+fk!*j3Jzab)GJcidDJ(p24jZ5_&>`(1f&%*xXQ%(KI
z|6CeyU90zB2>a9b3B^
Date: Wed, 19 Apr 2023 20:24:15 +0100
Subject: [PATCH 02/43] fix monitor geom
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 5db5f9d..bbc0c93 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -26,7 +26,8 @@ void geometry(void* data, wl_output* output, int32_t x, int32_t y, int32_t width
}
void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
- // ignored
+ const auto PMONITOR = (SWaylandOutput*)data;
+ PMONITOR->size = {width, height};
}
void done(void* data, wl_output* wl_output) {
From d14442fd7f8e9f1bff57603697ac0f46c5b16cc7 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Wed, 19 Apr 2023 20:26:09 +0100
Subject: [PATCH 03/43] fix full size
---
.../Render/Drivers/Output/CWaylandOutput.cpp | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index 07024f3..c447200 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -9,9 +9,15 @@ CWaylandOutput::CWaylandOutput (CApplicationContext& context, CVideoDriver& driv
m_driver (driver)
{
const auto PDRIVER = (CWaylandOpenGLDriver*)&driver;
+ glm::ivec2 fullw = {0,0};
for (auto& o : PDRIVER->m_outputs) {
m_viewports[o->name] = {{0, 0, o->size.x, o->size.y}, o->name};
+
+ fullw = fullw + glm::ivec2{o->size.x, o->size.y};
}
+
+ m_fullWidth = fullw.x;
+ m_fullHeight = fullw.y;
}
CWaylandOutput::~CWaylandOutput ()
From 5b1ea68164b90f84b0a91310a52dfeca6b03595a Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Wed, 19 Apr 2023 20:52:35 +0100
Subject: [PATCH 04/43] fix egl config
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index bbc0c93..e9a9eca 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -132,8 +132,8 @@ void CWaylandOpenGLDriver::initEGL() {
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
- EGL_ALPHA_SIZE, 1,
- EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL_SAMPLES, 4,
+ EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE,
};
if (!eglChooseConfig(eglContext.display, CONFIG_ATTRIBUTES, &eglContext.config, 1, &matchedConfigs)) {
@@ -328,6 +328,8 @@ void CWaylandOpenGLDriver::swapBuffers () {
wl_surface_set_buffer_scale(waylandContext.layerSurface.surface, 1);
wl_surface_damage_buffer(waylandContext.layerSurface.surface, 0, 0, INT32_MAX, INT32_MAX);
wl_surface_commit(waylandContext.layerSurface.surface);
+
+ m_frameCounter++;
}
uint32_t CWaylandOpenGLDriver::getFrameCounter () const {
From b505db103c3f7f0d7720b1f16376ca122f45f9e5 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Wed, 19 Apr 2023 21:02:44 +0100
Subject: [PATCH 05/43] allow specifying outputs with a flag
---
.../Application/CApplicationContext.cpp | 47 ++++++++++++-------
.../Application/CWallpaperApplication.cpp | 3 +-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 15 +++++-
3 files changed, 45 insertions(+), 20 deletions(-)
diff --git a/src/WallpaperEngine/Application/CApplicationContext.cpp b/src/WallpaperEngine/Application/CApplicationContext.cpp
index e22b497..fe53369 100644
--- a/src/WallpaperEngine/Application/CApplicationContext.cpp
+++ b/src/WallpaperEngine/Application/CApplicationContext.cpp
@@ -12,22 +12,23 @@
using namespace WallpaperEngine::Application;
struct option long_options[] = {
- { "screen-root", required_argument, nullptr, 'r' },
- { "bg", required_argument, nullptr, 'b' },
- { "window", required_argument, nullptr, 'w' },
- { "pkg", required_argument, nullptr, 'p' },
- { "dir", required_argument, nullptr, 'd' },
- { "silent", no_argument, nullptr, 's' },
- { "volume", required_argument, nullptr, 'v' },
- { "help", no_argument, nullptr, 'h' },
- { "fps", required_argument, nullptr, 'f' },
- { "assets-dir", required_argument, nullptr, 'a' },
- { "screenshot", required_argument, nullptr, 'c' },
- { "list-properties", no_argument, nullptr, 'l' },
- { "set-property", required_argument, nullptr, 'o' },
- { "noautomute", no_argument, nullptr, 'm' },
- { "no-fullscreen-pause", no_argument,nullptr, 'n' },
- { nullptr, 0, nullptr, 0 }
+ { "screen-root", required_argument, nullptr, 'r' },
+ { "wayland-display", required_argument, nullptr, 'i' },
+ { "bg", required_argument, nullptr, 'b' },
+ { "window", required_argument, nullptr, 'w' },
+ { "pkg", required_argument, nullptr, 'p' },
+ { "dir", required_argument, nullptr, 'd' },
+ { "silent", no_argument, nullptr, 's' },
+ { "volume", required_argument, nullptr, 'v' },
+ { "help", no_argument, nullptr, 'h' },
+ { "fps", required_argument, nullptr, 'f' },
+ { "assets-dir", required_argument, nullptr, 'a' },
+ { "screenshot", required_argument, nullptr, 'c' },
+ { "list-properties", no_argument, nullptr, 'l' },
+ { "set-property", required_argument, nullptr, 'o' },
+ { "noautomute", no_argument, nullptr, 'm' },
+ { "no-fullscreen-pause", no_argument, nullptr, 'n' },
+ { nullptr, 0, nullptr, 0 }
};
std::string stringPathFixes (const std::string& s)
@@ -84,7 +85,7 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
std::string lastScreen;
- while ((c = getopt_long (argc, argv, "b:r:p:d:shf:a:w:mn", long_options, nullptr)) != -1)
+ while ((c = getopt_long (argc, argv, "b:ri:p:d:shf:a:w:mn", long_options, nullptr)) != -1)
{
switch (c)
{
@@ -129,6 +130,18 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
this->settings.general.screenBackgrounds[lastScreen] = "";
break;
+ case 'i':
+ if (this->settings.general.screenBackgrounds.find (optarg) != this->settings.general.screenBackgrounds.end ())
+ sLog.exception ("Cannot specify the same screen more than once: ", optarg);
+ if (this->settings.render.mode == EXPLICIT_WINDOW)
+ sLog.exception ("Cannot run in both background and window mode");
+
+ this->settings.render.mode = WAYLAND_LAYER_SHELL;
+ lastScreen = optarg;
+ this->settings.general.screenBackgrounds[lastScreen] = "";
+
+ break;
+
case 'w':
if (this->settings.render.mode == X11_BACKGROUND)
sLog.exception ("Cannot run in both background and window mode");
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index 5481b7f..0653d27 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -263,11 +263,10 @@ namespace WallpaperEngine::Application
void CWallpaperApplication::show ()
{
// initialize OpenGL driver
- const bool WAYLAND = getenv("WAYLAND_DISPLAY");
+ const bool WAYLAND = getenv("WAYLAND_DISPLAY") && this->m_context.settings.render.mode == CApplicationContext::WAYLAND_LAYER_SHELL;
if (WAYLAND) {
videoDriver = std::make_unique("wallpaperengine", this->m_context, this);
inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver*)videoDriver.get());
- this->m_context.settings.render.mode = CApplicationContext::WAYLAND_LAYER_SHELL;
} else {
videoDriver = std::make_unique("wallpaperengine", this->m_context);
inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CX11OpenGLDriver*)videoDriver.get());
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index e9a9eca..67a6a7a 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -229,6 +229,19 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
if (!waylandContext.compositor || !waylandContext.shm || !waylandContext.layerShell || m_outputs.empty())
sLog.exception("Failed to bind to required interfaces");
+ SWaylandOutput* outputToUse = nullptr;
+ for (auto& o : m_outputs) {
+ if (std::find_if(context.settings.general.screenBackgrounds.begin(), context.settings.general.screenBackgrounds.end(), [&] (const auto& e) { return e.first == o->name; }) != context.settings.general.screenBackgrounds.end()) {
+ outputToUse = o.get();
+ break;
+ }
+ }
+
+ if (!outputToUse) {
+ sLog.debug("Failed to find any output, using first");
+ outputToUse = m_outputs[0].get();
+ }
+
const auto XCURSORSIZE = getenv("XCURSOR_SIZE") ? std::stoi(getenv("XCURSOR_SIZE")) : 24;
const auto PRCURSORTHEME = wl_cursor_theme_load(NULL, XCURSORSIZE, waylandContext.shm);
@@ -244,7 +257,7 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
initEGL();
waylandContext.layerSurface.surface = wl_compositor_create_surface(waylandContext.compositor);
- waylandContext.layerSurface.layerSurface = zwlr_layer_shell_v1_get_layer_surface(waylandContext.layerShell, waylandContext.layerSurface.surface, m_outputs[0]->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
+ waylandContext.layerSurface.layerSurface = zwlr_layer_shell_v1_get_layer_surface(waylandContext.layerShell, waylandContext.layerSurface.surface, outputToUse->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
if (!waylandContext.layerSurface.layerSurface) {
finishEGL();
From e473516bb76d8a2cacc850c32bd023c45f898f68 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Wed, 19 Apr 2023 22:10:08 +0100
Subject: [PATCH 06/43] fix rendertime inaccuracy
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 67a6a7a..b10abce 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -307,7 +307,7 @@ void* CWaylandOpenGLDriver::getWindowHandle () const {
}
float CWaylandOpenGLDriver::getRenderTime () const {
- return std::chrono::duration_cast(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000000;
+ return (float)std::chrono::duration_cast(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000000.0;
}
bool CWaylandOpenGLDriver::closeRequested () {
From 244722387b7bde5679e50a32c90b785e6b9624d7 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 13:00:03 +0100
Subject: [PATCH 07/43] flip v in LS output
---
src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index c447200..cb2ed2f 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -29,7 +29,7 @@ void CWaylandOutput::reset () {
}
bool CWaylandOutput::renderVFlip () const {
- return false;
+ return true;
}
bool CWaylandOutput::renderMultiple () const {
From 43409229a981f820428a51c52b6a38443a5b28e8 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 13:28:36 +0100
Subject: [PATCH 08/43] proper scaling + recalc on geom change
---
.../Application/CWallpaperApplication.cpp | 4 ++
.../Application/CWallpaperApplication.h | 4 ++
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 40 +++++++++++++++++--
.../Render/Drivers/CWaylandOpenGLDriver.h | 6 +++
.../Render/Drivers/Output/CWaylandOutput.cpp | 27 ++++++++-----
.../Render/Drivers/Output/CWaylandOutput.h | 2 +
6 files changed, 68 insertions(+), 15 deletions(-)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index 0653d27..84fd23b 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -388,4 +388,8 @@ namespace WallpaperEngine::Application
{
return this->m_context;
}
+
+ WallpaperEngine::Render::Drivers::Output::COutput* CWallpaperApplication::getOutput() const {
+ return this->output;
+ }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.h b/src/WallpaperEngine/Application/CWallpaperApplication.h
index a9293e0..3abd1a9 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.h
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.h
@@ -60,6 +60,10 @@ namespace WallpaperEngine::Application
* Renders a frame
*/
void renderFrame();
+ /**
+ * Gets the output
+ */
+ WallpaperEngine::Render::Drivers::Output::COutput* getOutput() const;
private:
/**
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index b10abce..fc19f0c 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -28,16 +28,29 @@ void geometry(void* data, wl_output* output, int32_t x, int32_t y, int32_t width
void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
const auto PMONITOR = (SWaylandOutput*)data;
PMONITOR->size = {width, height};
+ PMONITOR->lsSize = {width, height};
+
+ PMONITOR->driver->resizeLSSurfaceEGL();
+
+ if (PMONITOR->initialized)
+ PMONITOR->driver->wallpaperApplication->getOutput()->reset();
}
void done(void* data, wl_output* wl_output) {
const auto PMONITOR = (SWaylandOutput*)data;
+
+ PMONITOR->initialized = true;
}
void scale(void* data, wl_output* wl_output, int32_t scale) {
const auto PMONITOR = (SWaylandOutput*)data;
PMONITOR->scale = scale;
+
+ PMONITOR->driver->resizeLSSurfaceEGL();
+
+ if (PMONITOR->initialized)
+ PMONITOR->driver->wallpaperApplication->getOutput()->reset();
}
void name(void* data, wl_output* wl_output, const char* name) {
@@ -66,6 +79,7 @@ static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name
POUTPUT->name = "";
POUTPUT->size = {0, 0};
POUTPUT->waylandName = name;
+ POUTPUT->driver = PDRIVER;
wl_output_add_listener(POUTPUT->output, &outputListener, POUTPUT);
} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
PDRIVER->waylandContext.layerShell = (zwlr_layer_shell_v1*)wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
@@ -178,8 +192,7 @@ static void handleLSConfigure(void *data, zwlr_layer_surface_v1 *surface, uint32
const auto PDRIVER = (CWaylandOpenGLDriver*)data;
PDRIVER->waylandContext.layerSurface.size = {w, h};
- if (PDRIVER->waylandContext.layerSurface.eglWindow)
- wl_egl_window_resize(PDRIVER->waylandContext.layerSurface.eglWindow, w, h, 0, 0);
+ PDRIVER->resizeLSSurfaceEGL();
zwlr_layer_surface_v1_ack_configure(surface, serial);
}
@@ -258,6 +271,7 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
waylandContext.layerSurface.surface = wl_compositor_create_surface(waylandContext.compositor);
waylandContext.layerSurface.layerSurface = zwlr_layer_shell_v1_get_layer_surface(waylandContext.layerShell, waylandContext.layerSurface.surface, outputToUse->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
+ waylandContext.layerSurface.output = outputToUse;
if (!waylandContext.layerSurface.layerSurface) {
finishEGL();
@@ -275,8 +289,9 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
wl_surface_commit(waylandContext.layerSurface.surface);
wl_display_roundtrip(waylandContext.display);
- waylandContext.layerSurface.eglWindow = wl_egl_window_create(waylandContext.layerSurface.surface, waylandContext.layerSurface.size.x, waylandContext.layerSurface.size.y);
+ waylandContext.layerSurface.eglWindow = wl_egl_window_create(waylandContext.layerSurface.surface, waylandContext.layerSurface.size.x * outputToUse->scale, waylandContext.layerSurface.size.y * outputToUse->scale);
waylandContext.layerSurface.eglSurface = eglContext.eglCreatePlatformWindowSurfaceEXT(eglContext.display, eglContext.config, waylandContext.layerSurface.eglWindow, nullptr);
+ outputToUse->lsSize = waylandContext.layerSurface.size;
wl_surface_commit(waylandContext.layerSurface.surface);
wl_display_roundtrip(waylandContext.display);
wl_display_flush(waylandContext.display);
@@ -338,13 +353,30 @@ void CWaylandOpenGLDriver::swapBuffers () {
waylandContext.layerSurface.frameCallback = wl_surface_frame(waylandContext.layerSurface.surface);
wl_callback_add_listener(waylandContext.layerSurface.frameCallback, &frameListener, this);
eglSwapBuffers(eglContext.display, waylandContext.layerSurface.eglSurface);
- wl_surface_set_buffer_scale(waylandContext.layerSurface.surface, 1);
+ wl_surface_set_buffer_scale(waylandContext.layerSurface.surface, waylandContext.layerSurface.output->scale);
wl_surface_damage_buffer(waylandContext.layerSurface.surface, 0, 0, INT32_MAX, INT32_MAX);
wl_surface_commit(waylandContext.layerSurface.surface);
m_frameCounter++;
}
+void CWaylandOpenGLDriver::resizeLSSurfaceEGL() {
+ if (waylandContext.layerSurface.eglWindow) {
+ waylandContext.layerSurface.output->lsSize = waylandContext.layerSurface.size;
+
+ wl_egl_window_resize(waylandContext.layerSurface.eglWindow, waylandContext.layerSurface.size.x * waylandContext.layerSurface.output->scale, waylandContext.layerSurface.size.y * waylandContext.layerSurface.output->scale, 0, 0);
+
+ if (waylandContext.layerSurface.frameCallback) {
+ wl_callback_destroy(waylandContext.layerSurface.frameCallback);
+ waylandContext.layerSurface.frameCallback = nullptr;
+ }
+
+ wallpaperApplication->getOutput()->reset();
+
+ wallpaperApplication->renderFrame();
+ }
+}
+
uint32_t CWaylandOpenGLDriver::getFrameCounter () const {
return m_frameCounter;
}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 2024a02..6ec5bc4 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -24,13 +24,17 @@ struct zwlr_layer_surface_v1;
namespace WallpaperEngine::Render::Drivers
{
using namespace WallpaperEngine::Application;
+ class CWaylandOpenGLDriver;
struct SWaylandOutput {
wl_output* output;
std::string name;
glm::ivec2 size;
+ glm::ivec2 lsSize;
uint32_t waylandName;
int scale = 1;
+ CWaylandOpenGLDriver* driver = nullptr;
+ bool initialized = false;
};
class CWaylandOpenGLDriver : public CVideoDriver
@@ -70,10 +74,12 @@ namespace WallpaperEngine::Render::Drivers
zwlr_layer_surface_v1* layerSurface = nullptr;
glm::ivec2 size;
wl_callback* frameCallback = nullptr;
+ SWaylandOutput* output = nullptr;
} layerSurface;
} waylandContext;
void onLayerClose();
+ void resizeLSSurfaceEGL();
std::vector> m_outputs;
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index cb2ed2f..d4f16b8 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -8,24 +8,29 @@ CWaylandOutput::CWaylandOutput (CApplicationContext& context, CVideoDriver& driv
COutput (context, detector),
m_driver (driver)
{
- const auto PDRIVER = (CWaylandOpenGLDriver*)&driver;
- glm::ivec2 fullw = {0,0};
- for (auto& o : PDRIVER->m_outputs) {
- m_viewports[o->name] = {{0, 0, o->size.x, o->size.y}, o->name};
-
- fullw = fullw + glm::ivec2{o->size.x, o->size.y};
- }
-
- m_fullWidth = fullw.x;
- m_fullHeight = fullw.y;
+ updateViewports();
}
CWaylandOutput::~CWaylandOutput ()
{
}
+void CWaylandOutput::updateViewports() {
+ m_viewports.clear();
+ const auto PDRIVER = (CWaylandOpenGLDriver*)&m_driver;
+ glm::ivec2 fullw = {0,0};
+ for (auto& o : PDRIVER->m_outputs) {
+ m_viewports[o->name] = {{0, 0, o->lsSize.x * o->scale, o->lsSize.y * o->scale}, o->name};
+
+ fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, o->lsSize.y * o->scale};
+ }
+
+ m_fullWidth = fullw.x;
+ m_fullHeight = fullw.y;
+}
+
void CWaylandOutput::reset () {
- ;
+ updateViewports();
}
bool CWaylandOutput::renderVFlip () const {
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
index df738f8..1ab26bf 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
@@ -24,6 +24,8 @@ namespace WallpaperEngine::Render::Drivers::Output
void updateRender () const override;
private:
+ void updateViewports();
+
CVideoDriver& m_driver;
};
}
\ No newline at end of file
From ffeec7f1dd1954a61b47e094bd31ae34cfcf7adc Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 13:52:25 +0100
Subject: [PATCH 09/43] make wayland impl optional
---
CMakeLists.txt | 38 +++++++++++--------
.../Application/CWallpaperApplication.cpp | 11 +++++-
.../Application/CWallpaperApplication.h | 6 +++
src/WallpaperEngine/Input/CInputContext.cpp | 2 +
src/WallpaperEngine/Input/CInputContext.h | 4 ++
5 files changed, 45 insertions(+), 16 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 56f289f..ae3fdfb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,6 +44,15 @@ include_directories(
${CMAKE_SOURCE_DIR}
include)
+if (ENABLE_WAYLAND)
+ message(STATUS "Wayland support is enabled!")
+ add_compile_definitions(ENABLE_WAYLAND)
+ set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
+ "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h")
+else()
+ set(WAYLAND_SOURCES "")
+endif()
+
add_executable(
linux-wallpaperengine
main.cpp
@@ -130,21 +139,15 @@ add_executable(
src/WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h
src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
- src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp
- src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h
src/WallpaperEngine/Render/Drivers/Output/COutput.cpp
src/WallpaperEngine/Render/Drivers/Output/COutput.h
src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
- src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
- src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h
src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp
- src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
- src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
src/WallpaperEngine/Render/Drivers/CVideoDriver.h
src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
src/WallpaperEngine/Render/CRenderContext.h
@@ -275,6 +278,8 @@ add_executable(
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
+
+ ${WAYLAND_SOURCES}
)
target_link_libraries(linux-wallpaperengine
@@ -291,15 +296,18 @@ target_link_libraries(linux-wallpaperengine
${FREEIMAGE_LIBRARIES}
${MPV_LIBRARY}
${PULSEAUDIO_LIBRARY}
- ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1.o
- ${CMAKE_SOURCE_DIR}/xdg-shell-protocol.o
- glfw
- GLESv2
- pthread
- wayland-cursor
- /usr/lib/libEGL.so.1
- wayland-client
- wayland-egl)
+ glfw)
+
+if (ENABLE_WAYLAND)
+ target_link_libraries(linux-wallpaperengine ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1.o
+ ${CMAKE_SOURCE_DIR}/xdg-shell-protocol.o
+ GLESv2
+ pthread
+ wayland-cursor
+ /usr/lib/libEGL.so.1
+ wayland-client
+ wayland-egl)
+endif()
file(CREATE_LINK linux-wallpaperengine wallengine SYMBOLIC)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index 84fd23b..88175c4 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -263,18 +263,22 @@ namespace WallpaperEngine::Application
void CWallpaperApplication::show ()
{
// initialize OpenGL driver
+#ifdef ENABLE_WAYLAND
const bool WAYLAND = getenv("WAYLAND_DISPLAY") && this->m_context.settings.render.mode == CApplicationContext::WAYLAND_LAYER_SHELL;
if (WAYLAND) {
videoDriver = std::make_unique("wallpaperengine", this->m_context, this);
inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver*)videoDriver.get());
} else {
+#endif
videoDriver = std::make_unique("wallpaperengine", this->m_context);
inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CX11OpenGLDriver*)videoDriver.get());
+#ifdef ENABLE_WAYLAND
}
if (WAYLAND)
fullscreenDetector = std::make_unique(this->m_context, *(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver*)videoDriver.get());
else
+#endif
fullscreenDetector = std::make_unique(this->m_context, *videoDriver);
// stereo mix recorder for audio processing
WallpaperEngine::Audio::Drivers::Recorders::CPulseAudioPlaybackRecorder audioRecorder;
@@ -296,10 +300,11 @@ namespace WallpaperEngine::Application
case CApplicationContext::X11_BACKGROUND:
output = new WallpaperEngine::Render::Drivers::Output::CX11Output (this->m_context, *videoDriver, *fullscreenDetector);
break;
-
+#ifdef ENABLE_WAYLAND
case CApplicationContext::WAYLAND_LAYER_SHELL:
output = new WallpaperEngine::Render::Drivers::Output::CWaylandOutput (this->m_context, *videoDriver, *fullscreenDetector);
break;
+#endif
}
// initialize render context
@@ -318,6 +323,7 @@ namespace WallpaperEngine::Application
this->m_defaultBackground->getWallpaper (), *context, *audioContext
));
+#ifdef ENABLE_WAYLAND
if (WAYLAND) {
renderFrame();
@@ -325,10 +331,13 @@ namespace WallpaperEngine::Application
videoDriver->dispatchEventQueue();
}
} else {
+#endif
while (!videoDriver->closeRequested () && this->m_context.state.general.keepRunning) {
renderFrame();
}
+#ifdef ENABLE_WAYLAND
}
+#endif
// ensure this is updated as sometimes it might not come from a signal
this->m_context.state.general.keepRunning = false;
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.h b/src/WallpaperEngine/Application/CWallpaperApplication.h
index 3abd1a9..454cab0 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.h
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.h
@@ -9,14 +9,20 @@
#include "WallpaperEngine/Render/CWallpaper.h"
#include "WallpaperEngine/Render/CRenderContext.h"
#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
+#ifdef ENABLE_WAYLAND
#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
+#endif
#include "WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h"
+#ifdef ENABLE_WAYLAND
#include "WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h"
+#endif
#include "WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h"
#include "WallpaperEngine/Render/Drivers/Output/CX11Output.h"
+#ifdef ENABLE_WAYLAND
#include "WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
+#endif
#include "WallpaperEngine/Audio/Drivers/CSDLAudioDriver.h"
diff --git a/src/WallpaperEngine/Input/CInputContext.cpp b/src/WallpaperEngine/Input/CInputContext.cpp
index 49a2437..f0b2126 100644
--- a/src/WallpaperEngine/Input/CInputContext.cpp
+++ b/src/WallpaperEngine/Input/CInputContext.cpp
@@ -10,11 +10,13 @@ CInputContext::CInputContext (CX11OpenGLDriver& videoDriver) :
{
}
+#ifdef ENABLE_WAYLAND
CInputContext::CInputContext (CWaylandOpenGLDriver& videoDriver) :
m_mouse (nullptr)
{
// todo
}
+#endif
void CInputContext::update ()
{
diff --git a/src/WallpaperEngine/Input/CInputContext.h b/src/WallpaperEngine/Input/CInputContext.h
index 6bf3834..4a74e03 100644
--- a/src/WallpaperEngine/Input/CInputContext.h
+++ b/src/WallpaperEngine/Input/CInputContext.h
@@ -1,7 +1,9 @@
#pragma once
#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
+#ifdef ENABLE_WAYLAND
#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
+#endif
#include "CMouseInput.h"
namespace WallpaperEngine::Render::Drivers
@@ -15,7 +17,9 @@ namespace WallpaperEngine::Input
{
public:
explicit CInputContext (Render::Drivers::CX11OpenGLDriver& videoDriver);
+ #ifdef ENABLE_WAYLAND
explicit CInputContext (Render::Drivers::CWaylandOpenGLDriver& videoDriver);
+ #endif
void update ();
[[nodiscard]] const CMouseInput& getMouseInput () const;
From d13918697a33e52c62e998955b72c0528768b785 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 14:11:56 +0100
Subject: [PATCH 10/43] added protocol making
---
.gitignore | 6 +-
CMakeLists.txt | 8 +-
protocols.sh | 9 +
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 2 +-
wlr-layer-shell-unstable-v1.c | 91 -
wlr-layer-shell-unstable-v1.h | 563 ----
wlr-layer-shell-unstable-v1.o | Bin 6496 -> 0 bytes
xdg-shell-protocol.c | 183 --
xdg-shell-protocol.h | 2275 -----------------
xdg-shell-protocol.o | Bin 11824 -> 0 bytes
10 files changed, 22 insertions(+), 3115 deletions(-)
create mode 100755 protocols.sh
delete mode 100644 wlr-layer-shell-unstable-v1.c
delete mode 100644 wlr-layer-shell-unstable-v1.h
delete mode 100644 wlr-layer-shell-unstable-v1.o
delete mode 100644 xdg-shell-protocol.c
delete mode 100644 xdg-shell-protocol.h
delete mode 100644 xdg-shell-protocol.o
diff --git a/.gitignore b/.gitignore
index baaa9f3..cbaea3c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,8 @@
cmake-build-debug*
.idea
build/
-.vscode/
\ No newline at end of file
+.vscode/
+
+*-protocol.o
+*-protocol.c
+*-protocol.h
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae3fdfb..1c439e5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,6 +46,12 @@ include_directories(
if (ENABLE_WAYLAND)
message(STATUS "Wayland support is enabled!")
+
+ message(STATUS "Building protocols...")
+ execute_process(
+ COMMAND ./protocols.sh
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
add_compile_definitions(ENABLE_WAYLAND)
set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
"src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h")
@@ -299,7 +305,7 @@ target_link_libraries(linux-wallpaperengine
glfw)
if (ENABLE_WAYLAND)
- target_link_libraries(linux-wallpaperengine ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1.o
+ target_link_libraries(linux-wallpaperengine ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1-protocol.o
${CMAKE_SOURCE_DIR}/xdg-shell-protocol.o
GLESv2
pthread
diff --git a/protocols.sh b/protocols.sh
new file mode 100755
index 0000000..605edf8
--- /dev/null
+++ b/protocols.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+$(pkg-config --variable=wayland_scanner wayland-scanner) client-header protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.h
+$(pkg-config --variable=wayland_scanner wayland-scanner) private-code protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.c
+$(pkg-config --variable=wayland_scanner wayland-scanner) client-header $(pkg-config --variable=pkgdatadir wayland-protocols)/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.h
+$(pkg-config --variable=wayland_scanner wayland-scanner) private-code $(pkg-config --variable=pkgdatadir wayland-protocols)/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.c
+
+cc -c -I. -std=c99 -lwayland-client -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wdeclaration-after-statement wlr-layer-shell-unstable-v1-protocol.c -o wlr-layer-shell-unstable-v1-protocol.o
+cc -c -I. -std=c99 -lwayland-client -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wdeclaration-after-statement xdg-shell-protocol.c -o xdg-shell-protocol.o
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index fc19f0c..5090717 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -10,7 +10,7 @@
#define static
extern "C" {
#include "xdg-shell-protocol.h"
-#include "wlr-layer-shell-unstable-v1.h"
+#include "wlr-layer-shell-unstable-v1-protocol.h"
}
#undef class
#undef namespace
diff --git a/wlr-layer-shell-unstable-v1.c b/wlr-layer-shell-unstable-v1.c
deleted file mode 100644
index 14097ae..0000000
--- a/wlr-layer-shell-unstable-v1.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/* Generated by wayland-scanner 1.22.0 */
-
-/*
- * Copyright © 2017 Drew DeVault
- *
- * Permission to use, copy, modify, distribute, and sell this
- * software and its documentation for any purpose is hereby granted
- * without fee, provided that the above copyright notice appear in
- * all copies and that both that copyright notice and this permission
- * notice appear in supporting documentation, and that the name of
- * the copyright holders not be used in advertising or publicity
- * pertaining to distribution of the software without specific,
- * written prior permission. The copyright holders make no
- * representations about the suitability of this software for any
- * purpose. It is provided "as is" without express or implied
- * warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
- * THIS SOFTWARE.
- */
-
-#include
-#include
-#include "wayland-util.h"
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
-#endif
-
-#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
-#define WL_PRIVATE __attribute__ ((visibility("hidden")))
-#else
-#define WL_PRIVATE
-#endif
-
-extern const struct wl_interface wl_output_interface;
-extern const struct wl_interface wl_surface_interface;
-extern const struct wl_interface xdg_popup_interface;
-extern const struct wl_interface zwlr_layer_surface_v1_interface;
-
-static const struct wl_interface *wlr_layer_shell_v1_unstable_v1_types[] = {
- NULL,
- NULL,
- NULL,
- NULL,
- &zwlr_layer_surface_v1_interface,
- &wl_surface_interface,
- &wl_output_interface,
- NULL,
- NULL,
- &xdg_popup_interface,
-};
-
-static const struct wl_message zwlr_layer_shell_v1_requests[] = {
- { "get_layer_surface", "no?ous", wlr_layer_shell_v1_unstable_v1_types + 4 },
-};
-
-WL_PRIVATE const struct wl_interface zwlr_layer_shell_v1_interface = {
- "zwlr_layer_shell_v1", 1,
- 1, zwlr_layer_shell_v1_requests,
- 0, NULL,
-};
-
-static const struct wl_message zwlr_layer_surface_v1_requests[] = {
- { "set_size", "uu", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "set_anchor", "u", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "set_exclusive_zone", "i", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "set_margin", "iiii", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "set_keyboard_interactivity", "u", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "get_popup", "o", wlr_layer_shell_v1_unstable_v1_types + 9 },
- { "ack_configure", "u", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "destroy", "", wlr_layer_shell_v1_unstable_v1_types + 0 },
-};
-
-static const struct wl_message zwlr_layer_surface_v1_events[] = {
- { "configure", "uuu", wlr_layer_shell_v1_unstable_v1_types + 0 },
- { "closed", "", wlr_layer_shell_v1_unstable_v1_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface zwlr_layer_surface_v1_interface = {
- "zwlr_layer_surface_v1", 1,
- 8, zwlr_layer_surface_v1_requests,
- 2, zwlr_layer_surface_v1_events,
-};
-
diff --git a/wlr-layer-shell-unstable-v1.h b/wlr-layer-shell-unstable-v1.h
deleted file mode 100644
index 65d5fcb..0000000
--- a/wlr-layer-shell-unstable-v1.h
+++ /dev/null
@@ -1,563 +0,0 @@
-/* Generated by wayland-scanner 1.22.0 */
-
-#ifndef WLR_LAYER_SHELL_V1_UNSTABLE_V1_CLIENT_PROTOCOL_H
-#define WLR_LAYER_SHELL_V1_UNSTABLE_V1_CLIENT_PROTOCOL_H
-
-#include
-#include
-#include "wayland-client.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @page page_wlr_layer_shell_v1_unstable_v1 The wlr_layer_shell_v1_unstable_v1 protocol
- * @section page_ifaces_wlr_layer_shell_v1_unstable_v1 Interfaces
- * - @subpage page_iface_zwlr_layer_shell_v1 - create surfaces that are layers of the desktop
- * - @subpage page_iface_zwlr_layer_surface_v1 - layer metadata interface
- * @section page_copyright_wlr_layer_shell_v1_unstable_v1 Copyright
- *
- *
- * Copyright © 2017 Drew DeVault
- *
- * Permission to use, copy, modify, distribute, and sell this
- * software and its documentation for any purpose is hereby granted
- * without fee, provided that the above copyright notice appear in
- * all copies and that both that copyright notice and this permission
- * notice appear in supporting documentation, and that the name of
- * the copyright holders not be used in advertising or publicity
- * pertaining to distribution of the software without specific,
- * written prior permission. The copyright holders make no
- * representations about the suitability of this software for any
- * purpose. It is provided "as is" without express or implied
- * warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
- * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
- * THIS SOFTWARE.
- *
- */
-struct wl_output;
-struct wl_surface;
-struct xdg_popup;
-struct zwlr_layer_shell_v1;
-struct zwlr_layer_surface_v1;
-
-#ifndef ZWLR_LAYER_SHELL_V1_INTERFACE
-#define ZWLR_LAYER_SHELL_V1_INTERFACE
-/**
- * @page page_iface_zwlr_layer_shell_v1 zwlr_layer_shell_v1
- * @section page_iface_zwlr_layer_shell_v1_desc Description
- *
- * Clients can use this interface to assign the surface_layer role to
- * wl_surfaces. Such surfaces are assigned to a "layer" of the output and
- * rendered with a defined z-depth respective to each other. They may also be
- * anchored to the edges and corners of a screen and specify input handling
- * semantics. This interface should be suitable for the implementation of
- * many desktop shell components, and a broad number of other applications
- * that interact with the desktop.
- * @section page_iface_zwlr_layer_shell_v1_api API
- * See @ref iface_zwlr_layer_shell_v1.
- */
-/**
- * @defgroup iface_zwlr_layer_shell_v1 The zwlr_layer_shell_v1 interface
- *
- * Clients can use this interface to assign the surface_layer role to
- * wl_surfaces. Such surfaces are assigned to a "layer" of the output and
- * rendered with a defined z-depth respective to each other. They may also be
- * anchored to the edges and corners of a screen and specify input handling
- * semantics. This interface should be suitable for the implementation of
- * many desktop shell components, and a broad number of other applications
- * that interact with the desktop.
- */
-extern const struct wl_interface zwlr_layer_shell_v1_interface;
-#endif
-#ifndef ZWLR_LAYER_SURFACE_V1_INTERFACE
-#define ZWLR_LAYER_SURFACE_V1_INTERFACE
-/**
- * @page page_iface_zwlr_layer_surface_v1 zwlr_layer_surface_v1
- * @section page_iface_zwlr_layer_surface_v1_desc Description
- *
- * An interface that may be implemented by a wl_surface, for surfaces that
- * are designed to be rendered as a layer of a stacked desktop-like
- * environment.
- *
- * Layer surface state (size, anchor, exclusive zone, margin, interactivity)
- * is double-buffered, and will be applied at the time wl_surface.commit of
- * the corresponding wl_surface is called.
- * @section page_iface_zwlr_layer_surface_v1_api API
- * See @ref iface_zwlr_layer_surface_v1.
- */
-/**
- * @defgroup iface_zwlr_layer_surface_v1 The zwlr_layer_surface_v1 interface
- *
- * An interface that may be implemented by a wl_surface, for surfaces that
- * are designed to be rendered as a layer of a stacked desktop-like
- * environment.
- *
- * Layer surface state (size, anchor, exclusive zone, margin, interactivity)
- * is double-buffered, and will be applied at the time wl_surface.commit of
- * the corresponding wl_surface is called.
- */
-extern const struct wl_interface zwlr_layer_surface_v1_interface;
-#endif
-
-#ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM
-#define ZWLR_LAYER_SHELL_V1_ERROR_ENUM
-enum zwlr_layer_shell_v1_error {
- /**
- * wl_surface has another role
- */
- ZWLR_LAYER_SHELL_V1_ERROR_ROLE = 0,
- /**
- * layer value is invalid
- */
- ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER = 1,
- /**
- * wl_surface has a buffer attached or committed
- */
- ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED = 2,
-};
-#endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM */
-
-#ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM
-#define ZWLR_LAYER_SHELL_V1_LAYER_ENUM
-/**
- * @ingroup iface_zwlr_layer_shell_v1
- * available layers for surfaces
- *
- * These values indicate which layers a surface can be rendered in. They
- * are ordered by z depth, bottom-most first. Traditional shell surfaces
- * will typically be rendered between the bottom and top layers.
- * Fullscreen shell surfaces are typically rendered at the top layer.
- * Multiple surfaces can share a single layer, and ordering within a
- * single layer is undefined.
- */
-enum zwlr_layer_shell_v1_layer {
- ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0,
- ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM = 1,
- ZWLR_LAYER_SHELL_V1_LAYER_TOP = 2,
- ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY = 3,
-};
-#endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM */
-
-#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE 0
-
-
-/**
- * @ingroup iface_zwlr_layer_shell_v1
- */
-#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE_SINCE_VERSION 1
-
-/** @ingroup iface_zwlr_layer_shell_v1 */
-static inline void
-zwlr_layer_shell_v1_set_user_data(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) zwlr_layer_shell_v1, user_data);
-}
-
-/** @ingroup iface_zwlr_layer_shell_v1 */
-static inline void *
-zwlr_layer_shell_v1_get_user_data(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) zwlr_layer_shell_v1);
-}
-
-static inline uint32_t
-zwlr_layer_shell_v1_get_version(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1)
-{
- return wl_proxy_get_version((struct wl_proxy *) zwlr_layer_shell_v1);
-}
-
-/** @ingroup iface_zwlr_layer_shell_v1 */
-static inline void
-zwlr_layer_shell_v1_destroy(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1)
-{
- wl_proxy_destroy((struct wl_proxy *) zwlr_layer_shell_v1);
-}
-
-/**
- * @ingroup iface_zwlr_layer_shell_v1
- *
- * Create a layer surface for an existing surface. This assigns the role of
- * layer_surface, or raises a protocol error if another role is already
- * assigned.
- *
- * Creating a layer surface from a wl_surface which has a buffer attached
- * or committed is a client error, and any attempts by a client to attach
- * or manipulate a buffer prior to the first layer_surface.configure call
- * must also be treated as errors.
- *
- * You may pass NULL for output to allow the compositor to decide which
- * output to use. Generally this will be the one that the user most
- * recently interacted with.
- *
- * Clients can specify a namespace that defines the purpose of the layer
- * surface.
- */
-static inline struct zwlr_layer_surface_v1 *
-zwlr_layer_shell_v1_get_layer_surface(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1, struct wl_surface *surface, struct wl_output *output, uint32_t layer, const char *namespace)
-{
- struct wl_proxy *id;
-
- id = wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_shell_v1,
- ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE, &zwlr_layer_surface_v1_interface, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_shell_v1), 0, NULL, surface, output, layer, namespace);
-
- return (struct zwlr_layer_surface_v1 *) id;
-}
-
-#ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM
-#define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM
-enum zwlr_layer_surface_v1_error {
- /**
- * provided surface state is invalid
- */
- ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE = 0,
- /**
- * size is invalid
- */
- ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE = 1,
- /**
- * anchor bitfield is invalid
- */
- ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR = 2,
-};
-#endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM */
-
-#ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM
-#define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM
-enum zwlr_layer_surface_v1_anchor {
- /**
- * the top edge of the anchor rectangle
- */
- ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP = 1,
- /**
- * the bottom edge of the anchor rectangle
- */
- ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2,
- /**
- * the left edge of the anchor rectangle
- */
- ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT = 4,
- /**
- * the right edge of the anchor rectangle
- */
- ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT = 8,
-};
-#endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM */
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- * @struct zwlr_layer_surface_v1_listener
- */
-struct zwlr_layer_surface_v1_listener {
- /**
- * suggest a surface change
- *
- * The configure event asks the client to resize its surface.
- *
- * Clients should arrange their surface for the new states, and
- * then send an ack_configure request with the serial sent in this
- * configure event at some point before committing the new surface.
- *
- * The client is free to dismiss all but the last configure event
- * it received.
- *
- * The width and height arguments specify the size of the window in
- * surface-local coordinates.
- *
- * The size is a hint, in the sense that the client is free to
- * ignore it if it doesn't resize, pick a smaller size (to satisfy
- * aspect ratio or resize in steps of NxM pixels). If the client
- * picks a smaller size and is anchored to two opposite anchors
- * (e.g. 'top' and 'bottom'), the surface will be centered on this
- * axis.
- *
- * If the width or height arguments are zero, it means the client
- * should decide its own window dimension.
- */
- void (*configure)(void *data,
- struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1,
- uint32_t serial,
- uint32_t width,
- uint32_t height);
- /**
- * surface should be closed
- *
- * The closed event is sent by the compositor when the surface
- * will no longer be shown. The output may have been destroyed or
- * the user may have asked for it to be removed. Further changes to
- * the surface will be ignored. The client should destroy the
- * resource after receiving this event, and create a new surface if
- * they so choose.
- */
- void (*closed)(void *data,
- struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1);
-};
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-static inline int
-zwlr_layer_surface_v1_add_listener(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1,
- const struct zwlr_layer_surface_v1_listener *listener, void *data)
-{
- return wl_proxy_add_listener((struct wl_proxy *) zwlr_layer_surface_v1,
- (void (**)(void)) listener, data);
-}
-
-#define ZWLR_LAYER_SURFACE_V1_SET_SIZE 0
-#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR 1
-#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE 2
-#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN 3
-#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY 4
-#define ZWLR_LAYER_SURFACE_V1_GET_POPUP 5
-#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE 6
-#define ZWLR_LAYER_SURFACE_V1_DESTROY 7
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_CONFIGURE_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_CLOSED_SINCE_VERSION 1
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_SET_SIZE_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_GET_POPUP_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- */
-#define ZWLR_LAYER_SURFACE_V1_DESTROY_SINCE_VERSION 1
-
-/** @ingroup iface_zwlr_layer_surface_v1 */
-static inline void
-zwlr_layer_surface_v1_set_user_data(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) zwlr_layer_surface_v1, user_data);
-}
-
-/** @ingroup iface_zwlr_layer_surface_v1 */
-static inline void *
-zwlr_layer_surface_v1_get_user_data(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) zwlr_layer_surface_v1);
-}
-
-static inline uint32_t
-zwlr_layer_surface_v1_get_version(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1)
-{
- return wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * Sets the size of the surface in surface-local coordinates. The
- * compositor will display the surface centered with respect to its
- * anchors.
- *
- * If you pass 0 for either value, the compositor will assign it and
- * inform you of the assignment in the configure event. You must set your
- * anchor to opposite edges in the dimensions you omit; not doing so is a
- * protocol error. Both values are 0 by default.
- *
- * Size is double-buffered, see wl_surface.commit.
- */
-static inline void
-zwlr_layer_surface_v1_set_size(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t width, uint32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_SET_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, width, height);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * Requests that the compositor anchor the surface to the specified edges
- * and corners. If two orthoginal edges are specified (e.g. 'top' and
- * 'left'), then the anchor point will be the intersection of the edges
- * (e.g. the top left corner of the output); otherwise the anchor point
- * will be centered on that edge, or in the center if none is specified.
- *
- * Anchor is double-buffered, see wl_surface.commit.
- */
-static inline void
-zwlr_layer_surface_v1_set_anchor(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t anchor)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_SET_ANCHOR, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, anchor);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * Requests that the compositor avoids occluding an area of the surface
- * with other surfaces. The compositor's use of this information is
- * implementation-dependent - do not assume that this region will not
- * actually be occluded.
- *
- * A positive value is only meaningful if the surface is anchored to an
- * edge, rather than a corner. The zone is the number of surface-local
- * coordinates from the edge that are considered exclusive.
- *
- * Surfaces that do not wish to have an exclusive zone may instead specify
- * how they should interact with surfaces that do. If set to zero, the
- * surface indicates that it would like to be moved to avoid occluding
- * surfaces with a positive excluzive zone. If set to -1, the surface
- * indicates that it would not like to be moved to accommodate for other
- * surfaces, and the compositor should extend it all the way to the edges
- * it is anchored to.
- *
- * For example, a panel might set its exclusive zone to 10, so that
- * maximized shell surfaces are not shown on top of it. A notification
- * might set its exclusive zone to 0, so that it is moved to avoid
- * occluding the panel, but shell surfaces are shown underneath it. A
- * wallpaper or lock screen might set their exclusive zone to -1, so that
- * they stretch below or over the panel.
- *
- * The default value is 0.
- *
- * Exclusive zone is double-buffered, see wl_surface.commit.
- */
-static inline void
-zwlr_layer_surface_v1_set_exclusive_zone(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, int32_t zone)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, zone);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * Requests that the surface be placed some distance away from the anchor
- * point on the output, in surface-local coordinates. Setting this value
- * for edges you are not anchored to has no effect.
- *
- * The exclusive zone includes the margin.
- *
- * Margin is double-buffered, see wl_surface.commit.
- */
-static inline void
-zwlr_layer_surface_v1_set_margin(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, int32_t top, int32_t right, int32_t bottom, int32_t left)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_SET_MARGIN, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, top, right, bottom, left);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * Set to 1 to request that the seat send keyboard events to this layer
- * surface. For layers below the shell surface layer, the seat will use
- * normal focus semantics. For layers above the shell surface layers, the
- * seat will always give exclusive keyboard focus to the top-most layer
- * which has keyboard interactivity set to true.
- *
- * Layer surfaces receive pointer, touch, and tablet events normally. If
- * you do not want to receive them, set the input region on your surface
- * to an empty region.
- *
- * Events is double-buffered, see wl_surface.commit.
- */
-static inline void
-zwlr_layer_surface_v1_set_keyboard_interactivity(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t keyboard_interactivity)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, keyboard_interactivity);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * This assigns an xdg_popup's parent to this layer_surface. This popup
- * should have been created via xdg_surface::get_popup with the parent set
- * to NULL, and this request must be invoked before committing the popup's
- * initial state.
- *
- * See the documentation of xdg_popup for more details about what an
- * xdg_popup is and how it is used.
- */
-static inline void
-zwlr_layer_surface_v1_get_popup(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, struct xdg_popup *popup)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_GET_POPUP, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, popup);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * When a configure event is received, if a client commits the
- * surface in response to the configure event, then the client
- * must make an ack_configure request sometime before the commit
- * request, passing along the serial of the configure event.
- *
- * If the client receives multiple configure events before it
- * can respond to one, it only has to ack the last configure event.
- *
- * A client is not required to commit immediately after sending
- * an ack_configure request - it may even ack_configure several times
- * before its next surface commit.
- *
- * A client may send multiple ack_configure requests before committing, but
- * only the last request sent before a commit indicates which configure
- * event the client really is responding to.
- */
-static inline void
-zwlr_layer_surface_v1_ack_configure(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, serial);
-}
-
-/**
- * @ingroup iface_zwlr_layer_surface_v1
- *
- * This request destroys the layer surface.
- */
-static inline void
-zwlr_layer_surface_v1_destroy(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1,
- ZWLR_LAYER_SURFACE_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), WL_MARSHAL_FLAG_DESTROY);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/wlr-layer-shell-unstable-v1.o b/wlr-layer-shell-unstable-v1.o
deleted file mode 100644
index 473e218028c6fb767730ed956e202b87380c0a9d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6496
zcmd^DdsLLi6`y5!KjdLm5=~fbjMT`w5F3F+T@`^EAE41lQQ2kpV_8{taUZyFd_XYK
z_&|vD8A3E3616!kja6e3?HaXUkLE;CYnwI?jZ};ee57DC+PS-Tc876o&uRTHbI!N-
z{(kq)o%_u<^UeKs$%ILn0Wuk3O-4o&A7U&an%+KL?N-$!p7isPk4Q5}_5zc(Lb4Xv
z9M&SOP9kQ@7>mP3Di@fn%u+0wOa-YFXg)`T$e*m4pK~aUCz?X4^!OD+-y5gs;_Qi@fgY?RX
z);vvgarK9q_0Kgl$qgN^%rYrTtJTMpA>~h`=G7x7pmUb?YazE3+Z
zR2EDE;}Vv#dDxBf#jvwsLhZg@0m+dWEn!)jv&1TkJu)=3*tqBGxcqnS-j9yGHt57(
z8oM&r_ii1zC~&qsAtA5vlU)~ASN&m2qAIT@?d*sv!G~u&m9X-k9qXz#W#{hbc;V%{
zzue#1GH>k{@`yeOM}IdeWZQ=Pw5%pe^p&EJ&aP}Sv*xoCSJ&R2yll;15B6Osdp@;S
z%K(~{=YjFh7E`6-d3puW=l(2}GMVg7uP6|35A>o+f_E7NP(4~s4W7ns)4MMEKCmuI
z>-L+Ms$!OQ<=zcwsLFURC#NZUgL3zUjiYMxrgL*_W2PpkHjud0yZ0Ez96xq`Ud`_>
z)sCGO*{>eO~#)T3l}bay=!OOgo>e4UroGuWAN~s
zPYp8C!6|Z*Ej>8S>FH1CE3X-&GO`5
zO={b;Z-1k@-_`pyZy!-_|6uIqyujIQ6St{MADicWKKuHSfpO-S-an_)mrPys)z#~j
zA2+O7cBd-tbc8-GuUM;Fl=*{m=n~u1*K&tkcTK*RzIjKukrZsR-(1rjmAigs70DVu
zK3$QRHD$)n6v-*d6lJm^MV0cbDn;de83)pQ74!>LSP0#f<2I2
zzc0{kD5n;&B~U`f@j0A>oCI^or^-o)51^JorHtd_k=G)xLF__VMJ4zv@P<^#gOHOj
z4*66$iSPkVlapQ?@~LtX;{%)~C$SvzsBcjb8xTS?m`@^l?5EOSl#>tP+aJRJi}Da(
zK_xU6pU^TQ$z5P1*`SO_a+qy)ZJ|j@Don=^)rO*NstBO4J3L`BJdzr(|aZbI#Q@?PWp8|@rD%`UKYlQT8
zx@_Knk47I5Z2bVwKd)@`0sg_K?upOuicroU_&CHYCd7ePuL5}{fd~J`kmvJ(J`ta*pTY)Nwq-$wa(S;PVh~;dnmIc8-TQ
z`G}hZz6kM$9M8vbaXiE+LEI|v?7lwdcs|Zqj)yp}A^uw6+5KPSc!-mYxRc`{&Krok
z1)k;OUa-{0)(N_iP#|by&wYy<(X}e@Y#!q|p1&^z$3s3lFixVt??PV1@qCtBO>mB6$62}OH2m2j~Zg$i(y^m1T-wl9HaKH%CH
zerRL-lO9MOM+rQCiVWm{w9GRkJu*gI`nr6{5<4q1pYUO*9iO`^nX*}hamny;I|@%^A#Gq
zFBbo(hxYPNr$9UH5ng^J;%@~0ZROcVTvA)bp81i!x)3jW72&T`J5KVRwv|8B&MoIl$;5b6`bAH$PY&Y$1E?Sg+e
z;v0fL+t+fu88GuzS}+a-^ApAfrE(C*!@iz__-TP}K&%q@9f*G}@GXeb1^x_TqO?_%
z(!z^MyVWC$nP!)qcB0g4?OLKNwAqN#Dw(uy3>t+NkF5tyS*6LM(}LaYE)_Zqw7@B{
z&`@q&TUcn7%6pi#R;}4UD>}Z5$w>b#!Y(u;rUG5y#yU%BDJ|EC(rmFyO8W7TL@P*L
z31WlUp)9jn$|NiOAL;*Z{b>kzmhAblh-#(?5|@RS9Y{6ce4n-+liDL5_!axZ`vlI4
z|Fu7SaQ&z8bA${O0v<*&oO5b{4~2zHo5uZ1NFOS}kDY7r$iqJXFh0M>!Nls2QvkRo
z-hVc=`OCiw9oc(Oz0xcf)3d!Kq@DTOPpviXQBPzLnJO
zFaL}9al!J0`Gb0bjnDYCl=CQI044{I8iIJkRTCk`a;A2EMe
SX8!s+@lbE~M)W9R|9=D3f9}Nq
diff --git a/xdg-shell-protocol.c b/xdg-shell-protocol.c
deleted file mode 100644
index 417410f..0000000
--- a/xdg-shell-protocol.c
+++ /dev/null
@@ -1,183 +0,0 @@
-/* Generated by wayland-scanner 1.21.90 */
-
-/*
- * Copyright © 2008-2013 Kristian Høgsberg
- * Copyright © 2013 Rafael Antognolli
- * Copyright © 2013 Jasper St. Pierre
- * Copyright © 2010-2013 Intel Corporation
- * Copyright © 2015-2017 Samsung Electronics Co., Ltd
- * Copyright © 2015-2017 Red Hat Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include
-#include
-#include "wayland-util.h"
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
-#endif
-
-#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
-#define WL_PRIVATE __attribute__ ((visibility("hidden")))
-#else
-#define WL_PRIVATE
-#endif
-
-extern const struct wl_interface wl_output_interface;
-extern const struct wl_interface wl_seat_interface;
-extern const struct wl_interface wl_surface_interface;
-extern const struct wl_interface xdg_popup_interface;
-extern const struct wl_interface xdg_positioner_interface;
-extern const struct wl_interface xdg_surface_interface;
-extern const struct wl_interface xdg_toplevel_interface;
-
-static const struct wl_interface *xdg_shell_types[] = {
- NULL,
- NULL,
- NULL,
- NULL,
- &xdg_positioner_interface,
- &xdg_surface_interface,
- &wl_surface_interface,
- &xdg_toplevel_interface,
- &xdg_popup_interface,
- &xdg_surface_interface,
- &xdg_positioner_interface,
- &xdg_toplevel_interface,
- &wl_seat_interface,
- NULL,
- NULL,
- NULL,
- &wl_seat_interface,
- NULL,
- &wl_seat_interface,
- NULL,
- NULL,
- &wl_output_interface,
- &wl_seat_interface,
- NULL,
- &xdg_positioner_interface,
- NULL,
-};
-
-static const struct wl_message xdg_wm_base_requests[] = {
- { "destroy", "", xdg_shell_types + 0 },
- { "create_positioner", "n", xdg_shell_types + 4 },
- { "get_xdg_surface", "no", xdg_shell_types + 5 },
- { "pong", "u", xdg_shell_types + 0 },
-};
-
-static const struct wl_message xdg_wm_base_events[] = {
- { "ping", "u", xdg_shell_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface xdg_wm_base_interface = {
- "xdg_wm_base", 5,
- 4, xdg_wm_base_requests,
- 1, xdg_wm_base_events,
-};
-
-static const struct wl_message xdg_positioner_requests[] = {
- { "destroy", "", xdg_shell_types + 0 },
- { "set_size", "ii", xdg_shell_types + 0 },
- { "set_anchor_rect", "iiii", xdg_shell_types + 0 },
- { "set_anchor", "u", xdg_shell_types + 0 },
- { "set_gravity", "u", xdg_shell_types + 0 },
- { "set_constraint_adjustment", "u", xdg_shell_types + 0 },
- { "set_offset", "ii", xdg_shell_types + 0 },
- { "set_reactive", "3", xdg_shell_types + 0 },
- { "set_parent_size", "3ii", xdg_shell_types + 0 },
- { "set_parent_configure", "3u", xdg_shell_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface xdg_positioner_interface = {
- "xdg_positioner", 5,
- 10, xdg_positioner_requests,
- 0, NULL,
-};
-
-static const struct wl_message xdg_surface_requests[] = {
- { "destroy", "", xdg_shell_types + 0 },
- { "get_toplevel", "n", xdg_shell_types + 7 },
- { "get_popup", "n?oo", xdg_shell_types + 8 },
- { "set_window_geometry", "iiii", xdg_shell_types + 0 },
- { "ack_configure", "u", xdg_shell_types + 0 },
-};
-
-static const struct wl_message xdg_surface_events[] = {
- { "configure", "u", xdg_shell_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface xdg_surface_interface = {
- "xdg_surface", 5,
- 5, xdg_surface_requests,
- 1, xdg_surface_events,
-};
-
-static const struct wl_message xdg_toplevel_requests[] = {
- { "destroy", "", xdg_shell_types + 0 },
- { "set_parent", "?o", xdg_shell_types + 11 },
- { "set_title", "s", xdg_shell_types + 0 },
- { "set_app_id", "s", xdg_shell_types + 0 },
- { "show_window_menu", "ouii", xdg_shell_types + 12 },
- { "move", "ou", xdg_shell_types + 16 },
- { "resize", "ouu", xdg_shell_types + 18 },
- { "set_max_size", "ii", xdg_shell_types + 0 },
- { "set_min_size", "ii", xdg_shell_types + 0 },
- { "set_maximized", "", xdg_shell_types + 0 },
- { "unset_maximized", "", xdg_shell_types + 0 },
- { "set_fullscreen", "?o", xdg_shell_types + 21 },
- { "unset_fullscreen", "", xdg_shell_types + 0 },
- { "set_minimized", "", xdg_shell_types + 0 },
-};
-
-static const struct wl_message xdg_toplevel_events[] = {
- { "configure", "iia", xdg_shell_types + 0 },
- { "close", "", xdg_shell_types + 0 },
- { "configure_bounds", "4ii", xdg_shell_types + 0 },
- { "wm_capabilities", "5a", xdg_shell_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface xdg_toplevel_interface = {
- "xdg_toplevel", 5,
- 14, xdg_toplevel_requests,
- 4, xdg_toplevel_events,
-};
-
-static const struct wl_message xdg_popup_requests[] = {
- { "destroy", "", xdg_shell_types + 0 },
- { "grab", "ou", xdg_shell_types + 22 },
- { "reposition", "3ou", xdg_shell_types + 24 },
-};
-
-static const struct wl_message xdg_popup_events[] = {
- { "configure", "iiii", xdg_shell_types + 0 },
- { "popup_done", "", xdg_shell_types + 0 },
- { "repositioned", "3u", xdg_shell_types + 0 },
-};
-
-WL_PRIVATE const struct wl_interface xdg_popup_interface = {
- "xdg_popup", 5,
- 3, xdg_popup_requests,
- 3, xdg_popup_events,
-};
-
diff --git a/xdg-shell-protocol.h b/xdg-shell-protocol.h
deleted file mode 100644
index d68adae..0000000
--- a/xdg-shell-protocol.h
+++ /dev/null
@@ -1,2275 +0,0 @@
-/* Generated by wayland-scanner 1.21.90 */
-
-#ifndef XDG_SHELL_CLIENT_PROTOCOL_H
-#define XDG_SHELL_CLIENT_PROTOCOL_H
-
-#include
-#include
-#include "wayland-client.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @page page_xdg_shell The xdg_shell protocol
- * @section page_ifaces_xdg_shell Interfaces
- * - @subpage page_iface_xdg_wm_base - create desktop-style surfaces
- * - @subpage page_iface_xdg_positioner - child surface positioner
- * - @subpage page_iface_xdg_surface - desktop user interface surface base interface
- * - @subpage page_iface_xdg_toplevel - toplevel surface
- * - @subpage page_iface_xdg_popup - short-lived, popup surfaces for menus
- * @section page_copyright_xdg_shell Copyright
- *
- *
- * Copyright © 2008-2013 Kristian Høgsberg
- * Copyright © 2013 Rafael Antognolli
- * Copyright © 2013 Jasper St. Pierre
- * Copyright © 2010-2013 Intel Corporation
- * Copyright © 2015-2017 Samsung Electronics Co., Ltd
- * Copyright © 2015-2017 Red Hat Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- */
-struct wl_output;
-struct wl_seat;
-struct wl_surface;
-struct xdg_popup;
-struct xdg_positioner;
-struct xdg_surface;
-struct xdg_toplevel;
-struct xdg_wm_base;
-
-#ifndef XDG_WM_BASE_INTERFACE
-#define XDG_WM_BASE_INTERFACE
-/**
- * @page page_iface_xdg_wm_base xdg_wm_base
- * @section page_iface_xdg_wm_base_desc Description
- *
- * The xdg_wm_base interface is exposed as a global object enabling clients
- * to turn their wl_surfaces into windows in a desktop environment. It
- * defines the basic functionality needed for clients and the compositor to
- * create windows that can be dragged, resized, maximized, etc, as well as
- * creating transient windows such as popup menus.
- * @section page_iface_xdg_wm_base_api API
- * See @ref iface_xdg_wm_base.
- */
-/**
- * @defgroup iface_xdg_wm_base The xdg_wm_base interface
- *
- * The xdg_wm_base interface is exposed as a global object enabling clients
- * to turn their wl_surfaces into windows in a desktop environment. It
- * defines the basic functionality needed for clients and the compositor to
- * create windows that can be dragged, resized, maximized, etc, as well as
- * creating transient windows such as popup menus.
- */
-extern const struct wl_interface xdg_wm_base_interface;
-#endif
-#ifndef XDG_POSITIONER_INTERFACE
-#define XDG_POSITIONER_INTERFACE
-/**
- * @page page_iface_xdg_positioner xdg_positioner
- * @section page_iface_xdg_positioner_desc Description
- *
- * The xdg_positioner provides a collection of rules for the placement of a
- * child surface relative to a parent surface. Rules can be defined to ensure
- * the child surface remains within the visible area's borders, and to
- * specify how the child surface changes its position, such as sliding along
- * an axis, or flipping around a rectangle. These positioner-created rules are
- * constrained by the requirement that a child surface must intersect with or
- * be at least partially adjacent to its parent surface.
- *
- * See the various requests for details about possible rules.
- *
- * At the time of the request, the compositor makes a copy of the rules
- * specified by the xdg_positioner. Thus, after the request is complete the
- * xdg_positioner object can be destroyed or reused; further changes to the
- * object will have no effect on previous usages.
- *
- * For an xdg_positioner object to be considered complete, it must have a
- * non-zero size set by set_size, and a non-zero anchor rectangle set by
- * set_anchor_rect. Passing an incomplete xdg_positioner object when
- * positioning a surface raises an invalid_positioner error.
- * @section page_iface_xdg_positioner_api API
- * See @ref iface_xdg_positioner.
- */
-/**
- * @defgroup iface_xdg_positioner The xdg_positioner interface
- *
- * The xdg_positioner provides a collection of rules for the placement of a
- * child surface relative to a parent surface. Rules can be defined to ensure
- * the child surface remains within the visible area's borders, and to
- * specify how the child surface changes its position, such as sliding along
- * an axis, or flipping around a rectangle. These positioner-created rules are
- * constrained by the requirement that a child surface must intersect with or
- * be at least partially adjacent to its parent surface.
- *
- * See the various requests for details about possible rules.
- *
- * At the time of the request, the compositor makes a copy of the rules
- * specified by the xdg_positioner. Thus, after the request is complete the
- * xdg_positioner object can be destroyed or reused; further changes to the
- * object will have no effect on previous usages.
- *
- * For an xdg_positioner object to be considered complete, it must have a
- * non-zero size set by set_size, and a non-zero anchor rectangle set by
- * set_anchor_rect. Passing an incomplete xdg_positioner object when
- * positioning a surface raises an invalid_positioner error.
- */
-extern const struct wl_interface xdg_positioner_interface;
-#endif
-#ifndef XDG_SURFACE_INTERFACE
-#define XDG_SURFACE_INTERFACE
-/**
- * @page page_iface_xdg_surface xdg_surface
- * @section page_iface_xdg_surface_desc Description
- *
- * An interface that may be implemented by a wl_surface, for
- * implementations that provide a desktop-style user interface.
- *
- * It provides a base set of functionality required to construct user
- * interface elements requiring management by the compositor, such as
- * toplevel windows, menus, etc. The types of functionality are split into
- * xdg_surface roles.
- *
- * Creating an xdg_surface does not set the role for a wl_surface. In order
- * to map an xdg_surface, the client must create a role-specific object
- * using, e.g., get_toplevel, get_popup. The wl_surface for any given
- * xdg_surface can have at most one role, and may not be assigned any role
- * not based on xdg_surface.
- *
- * A role must be assigned before any other requests are made to the
- * xdg_surface object.
- *
- * The client must call wl_surface.commit on the corresponding wl_surface
- * for the xdg_surface state to take effect.
- *
- * Creating an xdg_surface from a wl_surface which has a buffer attached or
- * committed is a client error, and any attempts by a client to attach or
- * manipulate a buffer prior to the first xdg_surface.configure call must
- * also be treated as errors.
- *
- * After creating a role-specific object and setting it up, the client must
- * perform an initial commit without any buffer attached. The compositor
- * will reply with an xdg_surface.configure event. The client must
- * acknowledge it and is then allowed to attach a buffer to map the surface.
- *
- * Mapping an xdg_surface-based role surface is defined as making it
- * possible for the surface to be shown by the compositor. Note that
- * a mapped surface is not guaranteed to be visible once it is mapped.
- *
- * For an xdg_surface to be mapped by the compositor, the following
- * conditions must be met:
- * (1) the client has assigned an xdg_surface-based role to the surface
- * (2) the client has set and committed the xdg_surface state and the
- * role-dependent state to the surface
- * (3) the client has committed a buffer to the surface
- *
- * A newly-unmapped surface is considered to have met condition (1) out
- * of the 3 required conditions for mapping a surface if its role surface
- * has not been destroyed, i.e. the client must perform the initial commit
- * again before attaching a buffer.
- * @section page_iface_xdg_surface_api API
- * See @ref iface_xdg_surface.
- */
-/**
- * @defgroup iface_xdg_surface The xdg_surface interface
- *
- * An interface that may be implemented by a wl_surface, for
- * implementations that provide a desktop-style user interface.
- *
- * It provides a base set of functionality required to construct user
- * interface elements requiring management by the compositor, such as
- * toplevel windows, menus, etc. The types of functionality are split into
- * xdg_surface roles.
- *
- * Creating an xdg_surface does not set the role for a wl_surface. In order
- * to map an xdg_surface, the client must create a role-specific object
- * using, e.g., get_toplevel, get_popup. The wl_surface for any given
- * xdg_surface can have at most one role, and may not be assigned any role
- * not based on xdg_surface.
- *
- * A role must be assigned before any other requests are made to the
- * xdg_surface object.
- *
- * The client must call wl_surface.commit on the corresponding wl_surface
- * for the xdg_surface state to take effect.
- *
- * Creating an xdg_surface from a wl_surface which has a buffer attached or
- * committed is a client error, and any attempts by a client to attach or
- * manipulate a buffer prior to the first xdg_surface.configure call must
- * also be treated as errors.
- *
- * After creating a role-specific object and setting it up, the client must
- * perform an initial commit without any buffer attached. The compositor
- * will reply with an xdg_surface.configure event. The client must
- * acknowledge it and is then allowed to attach a buffer to map the surface.
- *
- * Mapping an xdg_surface-based role surface is defined as making it
- * possible for the surface to be shown by the compositor. Note that
- * a mapped surface is not guaranteed to be visible once it is mapped.
- *
- * For an xdg_surface to be mapped by the compositor, the following
- * conditions must be met:
- * (1) the client has assigned an xdg_surface-based role to the surface
- * (2) the client has set and committed the xdg_surface state and the
- * role-dependent state to the surface
- * (3) the client has committed a buffer to the surface
- *
- * A newly-unmapped surface is considered to have met condition (1) out
- * of the 3 required conditions for mapping a surface if its role surface
- * has not been destroyed, i.e. the client must perform the initial commit
- * again before attaching a buffer.
- */
-extern const struct wl_interface xdg_surface_interface;
-#endif
-#ifndef XDG_TOPLEVEL_INTERFACE
-#define XDG_TOPLEVEL_INTERFACE
-/**
- * @page page_iface_xdg_toplevel xdg_toplevel
- * @section page_iface_xdg_toplevel_desc Description
- *
- * This interface defines an xdg_surface role which allows a surface to,
- * among other things, set window-like properties such as maximize,
- * fullscreen, and minimize, set application-specific metadata like title and
- * id, and well as trigger user interactive operations such as interactive
- * resize and move.
- *
- * Unmapping an xdg_toplevel means that the surface cannot be shown
- * by the compositor until it is explicitly mapped again.
- * All active operations (e.g., move, resize) are canceled and all
- * attributes (e.g. title, state, stacking, ...) are discarded for
- * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
- * the state it had right after xdg_surface.get_toplevel. The client
- * can re-map the toplevel by perfoming a commit without any buffer
- * attached, waiting for a configure event and handling it as usual (see
- * xdg_surface description).
- *
- * Attaching a null buffer to a toplevel unmaps the surface.
- * @section page_iface_xdg_toplevel_api API
- * See @ref iface_xdg_toplevel.
- */
-/**
- * @defgroup iface_xdg_toplevel The xdg_toplevel interface
- *
- * This interface defines an xdg_surface role which allows a surface to,
- * among other things, set window-like properties such as maximize,
- * fullscreen, and minimize, set application-specific metadata like title and
- * id, and well as trigger user interactive operations such as interactive
- * resize and move.
- *
- * Unmapping an xdg_toplevel means that the surface cannot be shown
- * by the compositor until it is explicitly mapped again.
- * All active operations (e.g., move, resize) are canceled and all
- * attributes (e.g. title, state, stacking, ...) are discarded for
- * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
- * the state it had right after xdg_surface.get_toplevel. The client
- * can re-map the toplevel by perfoming a commit without any buffer
- * attached, waiting for a configure event and handling it as usual (see
- * xdg_surface description).
- *
- * Attaching a null buffer to a toplevel unmaps the surface.
- */
-extern const struct wl_interface xdg_toplevel_interface;
-#endif
-#ifndef XDG_POPUP_INTERFACE
-#define XDG_POPUP_INTERFACE
-/**
- * @page page_iface_xdg_popup xdg_popup
- * @section page_iface_xdg_popup_desc Description
- *
- * A popup surface is a short-lived, temporary surface. It can be used to
- * implement for example menus, popovers, tooltips and other similar user
- * interface concepts.
- *
- * A popup can be made to take an explicit grab. See xdg_popup.grab for
- * details.
- *
- * When the popup is dismissed, a popup_done event will be sent out, and at
- * the same time the surface will be unmapped. See the xdg_popup.popup_done
- * event for details.
- *
- * Explicitly destroying the xdg_popup object will also dismiss the popup and
- * unmap the surface. Clients that want to dismiss the popup when another
- * surface of their own is clicked should dismiss the popup using the destroy
- * request.
- *
- * A newly created xdg_popup will be stacked on top of all previously created
- * xdg_popup surfaces associated with the same xdg_toplevel.
- *
- * The parent of an xdg_popup must be mapped (see the xdg_surface
- * description) before the xdg_popup itself.
- *
- * The client must call wl_surface.commit on the corresponding wl_surface
- * for the xdg_popup state to take effect.
- * @section page_iface_xdg_popup_api API
- * See @ref iface_xdg_popup.
- */
-/**
- * @defgroup iface_xdg_popup The xdg_popup interface
- *
- * A popup surface is a short-lived, temporary surface. It can be used to
- * implement for example menus, popovers, tooltips and other similar user
- * interface concepts.
- *
- * A popup can be made to take an explicit grab. See xdg_popup.grab for
- * details.
- *
- * When the popup is dismissed, a popup_done event will be sent out, and at
- * the same time the surface will be unmapped. See the xdg_popup.popup_done
- * event for details.
- *
- * Explicitly destroying the xdg_popup object will also dismiss the popup and
- * unmap the surface. Clients that want to dismiss the popup when another
- * surface of their own is clicked should dismiss the popup using the destroy
- * request.
- *
- * A newly created xdg_popup will be stacked on top of all previously created
- * xdg_popup surfaces associated with the same xdg_toplevel.
- *
- * The parent of an xdg_popup must be mapped (see the xdg_surface
- * description) before the xdg_popup itself.
- *
- * The client must call wl_surface.commit on the corresponding wl_surface
- * for the xdg_popup state to take effect.
- */
-extern const struct wl_interface xdg_popup_interface;
-#endif
-
-#ifndef XDG_WM_BASE_ERROR_ENUM
-#define XDG_WM_BASE_ERROR_ENUM
-enum xdg_wm_base_error {
- /**
- * given wl_surface has another role
- */
- XDG_WM_BASE_ERROR_ROLE = 0,
- /**
- * xdg_wm_base was destroyed before children
- */
- XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1,
- /**
- * the client tried to map or destroy a non-topmost popup
- */
- XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2,
- /**
- * the client specified an invalid popup parent surface
- */
- XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3,
- /**
- * the client provided an invalid surface state
- */
- XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4,
- /**
- * the client provided an invalid positioner
- */
- XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5,
- /**
- * the client didn’t respond to a ping event in time
- */
- XDG_WM_BASE_ERROR_UNRESPONSIVE = 6,
-};
-#endif /* XDG_WM_BASE_ERROR_ENUM */
-
-/**
- * @ingroup iface_xdg_wm_base
- * @struct xdg_wm_base_listener
- */
-struct xdg_wm_base_listener {
- /**
- * check if the client is alive
- *
- * The ping event asks the client if it's still alive. Pass the
- * serial specified in the event back to the compositor by sending
- * a "pong" request back with the specified serial. See
- * xdg_wm_base.pong.
- *
- * Compositors can use this to determine if the client is still
- * alive. It's unspecified what will happen if the client doesn't
- * respond to the ping request, or in what timeframe. Clients
- * should try to respond in a reasonable amount of time. The
- * “unresponsive” error is provided for compositors that wish
- * to disconnect unresponsive clients.
- *
- * A compositor is free to ping in any way it wants, but a client
- * must always respond to any xdg_wm_base object it created.
- * @param serial pass this to the pong request
- */
- void (*ping)(void *data,
- struct xdg_wm_base *xdg_wm_base,
- uint32_t serial);
-};
-
-/**
- * @ingroup iface_xdg_wm_base
- */
-static inline int
-xdg_wm_base_add_listener(struct xdg_wm_base *xdg_wm_base,
- const struct xdg_wm_base_listener *listener, void *data)
-{
- return wl_proxy_add_listener((struct wl_proxy *) xdg_wm_base,
- (void (**)(void)) listener, data);
-}
-
-#define XDG_WM_BASE_DESTROY 0
-#define XDG_WM_BASE_CREATE_POSITIONER 1
-#define XDG_WM_BASE_GET_XDG_SURFACE 2
-#define XDG_WM_BASE_PONG 3
-
-/**
- * @ingroup iface_xdg_wm_base
- */
-#define XDG_WM_BASE_PING_SINCE_VERSION 1
-
-/**
- * @ingroup iface_xdg_wm_base
- */
-#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_wm_base
- */
-#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_wm_base
- */
-#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_wm_base
- */
-#define XDG_WM_BASE_PONG_SINCE_VERSION 1
-
-/** @ingroup iface_xdg_wm_base */
-static inline void
-xdg_wm_base_set_user_data(struct xdg_wm_base *xdg_wm_base, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) xdg_wm_base, user_data);
-}
-
-/** @ingroup iface_xdg_wm_base */
-static inline void *
-xdg_wm_base_get_user_data(struct xdg_wm_base *xdg_wm_base)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) xdg_wm_base);
-}
-
-static inline uint32_t
-xdg_wm_base_get_version(struct xdg_wm_base *xdg_wm_base)
-{
- return wl_proxy_get_version((struct wl_proxy *) xdg_wm_base);
-}
-
-/**
- * @ingroup iface_xdg_wm_base
- *
- * Destroy this xdg_wm_base object.
- *
- * Destroying a bound xdg_wm_base object while there are surfaces
- * still alive created by this xdg_wm_base object instance is illegal
- * and will result in a defunct_surfaces error.
- */
-static inline void
-xdg_wm_base_destroy(struct xdg_wm_base *xdg_wm_base)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
- XDG_WM_BASE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), WL_MARSHAL_FLAG_DESTROY);
-}
-
-/**
- * @ingroup iface_xdg_wm_base
- *
- * Create a positioner object. A positioner object is used to position
- * surfaces relative to some parent surface. See the interface description
- * and xdg_surface.get_popup for details.
- */
-static inline struct xdg_positioner *
-xdg_wm_base_create_positioner(struct xdg_wm_base *xdg_wm_base)
-{
- struct wl_proxy *id;
-
- id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
- XDG_WM_BASE_CREATE_POSITIONER, &xdg_positioner_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL);
-
- return (struct xdg_positioner *) id;
-}
-
-/**
- * @ingroup iface_xdg_wm_base
- *
- * This creates an xdg_surface for the given surface. While xdg_surface
- * itself is not a role, the corresponding surface may only be assigned
- * a role extending xdg_surface, such as xdg_toplevel or xdg_popup. It is
- * illegal to create an xdg_surface for a wl_surface which already has an
- * assigned role and this will result in a role error.
- *
- * This creates an xdg_surface for the given surface. An xdg_surface is
- * used as basis to define a role to a given surface, such as xdg_toplevel
- * or xdg_popup. It also manages functionality shared between xdg_surface
- * based surface roles.
- *
- * See the documentation of xdg_surface for more details about what an
- * xdg_surface is and how it is used.
- */
-static inline struct xdg_surface *
-xdg_wm_base_get_xdg_surface(struct xdg_wm_base *xdg_wm_base, struct wl_surface *surface)
-{
- struct wl_proxy *id;
-
- id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
- XDG_WM_BASE_GET_XDG_SURFACE, &xdg_surface_interface, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, NULL, surface);
-
- return (struct xdg_surface *) id;
-}
-
-/**
- * @ingroup iface_xdg_wm_base
- *
- * A client must respond to a ping event with a pong request or
- * the client may be deemed unresponsive. See xdg_wm_base.ping
- * and xdg_wm_base.error.unresponsive.
- */
-static inline void
-xdg_wm_base_pong(struct xdg_wm_base *xdg_wm_base, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_wm_base,
- XDG_WM_BASE_PONG, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_wm_base), 0, serial);
-}
-
-#ifndef XDG_POSITIONER_ERROR_ENUM
-#define XDG_POSITIONER_ERROR_ENUM
-enum xdg_positioner_error {
- /**
- * invalid input provided
- */
- XDG_POSITIONER_ERROR_INVALID_INPUT = 0,
-};
-#endif /* XDG_POSITIONER_ERROR_ENUM */
-
-#ifndef XDG_POSITIONER_ANCHOR_ENUM
-#define XDG_POSITIONER_ANCHOR_ENUM
-enum xdg_positioner_anchor {
- XDG_POSITIONER_ANCHOR_NONE = 0,
- XDG_POSITIONER_ANCHOR_TOP = 1,
- XDG_POSITIONER_ANCHOR_BOTTOM = 2,
- XDG_POSITIONER_ANCHOR_LEFT = 3,
- XDG_POSITIONER_ANCHOR_RIGHT = 4,
- XDG_POSITIONER_ANCHOR_TOP_LEFT = 5,
- XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6,
- XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7,
- XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8,
-};
-#endif /* XDG_POSITIONER_ANCHOR_ENUM */
-
-#ifndef XDG_POSITIONER_GRAVITY_ENUM
-#define XDG_POSITIONER_GRAVITY_ENUM
-enum xdg_positioner_gravity {
- XDG_POSITIONER_GRAVITY_NONE = 0,
- XDG_POSITIONER_GRAVITY_TOP = 1,
- XDG_POSITIONER_GRAVITY_BOTTOM = 2,
- XDG_POSITIONER_GRAVITY_LEFT = 3,
- XDG_POSITIONER_GRAVITY_RIGHT = 4,
- XDG_POSITIONER_GRAVITY_TOP_LEFT = 5,
- XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6,
- XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7,
- XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8,
-};
-#endif /* XDG_POSITIONER_GRAVITY_ENUM */
-
-#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
-#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
-/**
- * @ingroup iface_xdg_positioner
- * constraint adjustments
- *
- * The constraint adjustment value define ways the compositor will adjust
- * the position of the surface, if the unadjusted position would result
- * in the surface being partly constrained.
- *
- * Whether a surface is considered 'constrained' is left to the compositor
- * to determine. For example, the surface may be partly outside the
- * compositor's defined 'work area', thus necessitating the child surface's
- * position be adjusted until it is entirely inside the work area.
- *
- * The adjustments can be combined, according to a defined precedence: 1)
- * Flip, 2) Slide, 3) Resize.
- */
-enum xdg_positioner_constraint_adjustment {
- /**
- * don't move the child surface when constrained
- *
- * Don't alter the surface position even if it is constrained on
- * some axis, for example partially outside the edge of an output.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0,
- /**
- * move along the x axis until unconstrained
- *
- * Slide the surface along the x axis until it is no longer
- * constrained.
- *
- * First try to slide towards the direction of the gravity on the x
- * axis until either the edge in the opposite direction of the
- * gravity is unconstrained or the edge in the direction of the
- * gravity is constrained.
- *
- * Then try to slide towards the opposite direction of the gravity
- * on the x axis until either the edge in the direction of the
- * gravity is unconstrained or the edge in the opposite direction
- * of the gravity is constrained.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
- /**
- * move along the y axis until unconstrained
- *
- * Slide the surface along the y axis until it is no longer
- * constrained.
- *
- * First try to slide towards the direction of the gravity on the y
- * axis until either the edge in the opposite direction of the
- * gravity is unconstrained or the edge in the direction of the
- * gravity is constrained.
- *
- * Then try to slide towards the opposite direction of the gravity
- * on the y axis until either the edge in the direction of the
- * gravity is unconstrained or the edge in the opposite direction
- * of the gravity is constrained.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
- /**
- * invert the anchor and gravity on the x axis
- *
- * Invert the anchor and gravity on the x axis if the surface is
- * constrained on the x axis. For example, if the left edge of the
- * surface is constrained, the gravity is 'left' and the anchor is
- * 'left', change the gravity to 'right' and the anchor to 'right'.
- *
- * If the adjusted position also ends up being constrained, the
- * resulting position of the flip_x adjustment will be the one
- * before the adjustment.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
- /**
- * invert the anchor and gravity on the y axis
- *
- * Invert the anchor and gravity on the y axis if the surface is
- * constrained on the y axis. For example, if the bottom edge of
- * the surface is constrained, the gravity is 'bottom' and the
- * anchor is 'bottom', change the gravity to 'top' and the anchor
- * to 'top'.
- *
- * The adjusted position is calculated given the original anchor
- * rectangle and offset, but with the new flipped anchor and
- * gravity values.
- *
- * If the adjusted position also ends up being constrained, the
- * resulting position of the flip_y adjustment will be the one
- * before the adjustment.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
- /**
- * horizontally resize the surface
- *
- * Resize the surface horizontally so that it is completely
- * unconstrained.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
- /**
- * vertically resize the surface
- *
- * Resize the surface vertically so that it is completely
- * unconstrained.
- */
- XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
-};
-#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM */
-
-#define XDG_POSITIONER_DESTROY 0
-#define XDG_POSITIONER_SET_SIZE 1
-#define XDG_POSITIONER_SET_ANCHOR_RECT 2
-#define XDG_POSITIONER_SET_ANCHOR 3
-#define XDG_POSITIONER_SET_GRAVITY 4
-#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT 5
-#define XDG_POSITIONER_SET_OFFSET 6
-#define XDG_POSITIONER_SET_REACTIVE 7
-#define XDG_POSITIONER_SET_PARENT_SIZE 8
-#define XDG_POSITIONER_SET_PARENT_CONFIGURE 9
-
-
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3
-/**
- * @ingroup iface_xdg_positioner
- */
-#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3
-
-/** @ingroup iface_xdg_positioner */
-static inline void
-xdg_positioner_set_user_data(struct xdg_positioner *xdg_positioner, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) xdg_positioner, user_data);
-}
-
-/** @ingroup iface_xdg_positioner */
-static inline void *
-xdg_positioner_get_user_data(struct xdg_positioner *xdg_positioner)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) xdg_positioner);
-}
-
-static inline uint32_t
-xdg_positioner_get_version(struct xdg_positioner *xdg_positioner)
-{
- return wl_proxy_get_version((struct wl_proxy *) xdg_positioner);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Notify the compositor that the xdg_positioner will no longer be used.
- */
-static inline void
-xdg_positioner_destroy(struct xdg_positioner *xdg_positioner)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), WL_MARSHAL_FLAG_DESTROY);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Set the size of the surface that is to be positioned with the positioner
- * object. The size is in surface-local coordinates and corresponds to the
- * window geometry. See xdg_surface.set_window_geometry.
- *
- * If a zero or negative size is set the invalid_input error is raised.
- */
-static inline void
-xdg_positioner_set_size(struct xdg_positioner *xdg_positioner, int32_t width, int32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, width, height);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Specify the anchor rectangle within the parent surface that the child
- * surface will be placed relative to. The rectangle is relative to the
- * window geometry as defined by xdg_surface.set_window_geometry of the
- * parent surface.
- *
- * When the xdg_positioner object is used to position a child surface, the
- * anchor rectangle may not extend outside the window geometry of the
- * positioned child's parent surface.
- *
- * If a negative size is set the invalid_input error is raised.
- */
-static inline void
-xdg_positioner_set_anchor_rect(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y, int32_t width, int32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_ANCHOR_RECT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y, width, height);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Defines the anchor point for the anchor rectangle. The specified anchor
- * is used derive an anchor point that the child surface will be
- * positioned relative to. If a corner anchor is set (e.g. 'top_left' or
- * 'bottom_right'), the anchor point will be at the specified corner;
- * otherwise, the derived anchor point will be centered on the specified
- * edge, or in the center of the anchor rectangle if no edge is specified.
- */
-static inline void
-xdg_positioner_set_anchor(struct xdg_positioner *xdg_positioner, uint32_t anchor)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_ANCHOR, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, anchor);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Defines in what direction a surface should be positioned, relative to
- * the anchor point of the parent surface. If a corner gravity is
- * specified (e.g. 'bottom_right' or 'top_left'), then the child surface
- * will be placed towards the specified gravity; otherwise, the child
- * surface will be centered over the anchor point on any axis that had no
- * gravity specified. If the gravity is not in the ‘gravity’ enum, an
- * invalid_input error is raised.
- */
-static inline void
-xdg_positioner_set_gravity(struct xdg_positioner *xdg_positioner, uint32_t gravity)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_GRAVITY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, gravity);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Specify how the window should be positioned if the originally intended
- * position caused the surface to be constrained, meaning at least
- * partially outside positioning boundaries set by the compositor. The
- * adjustment is set by constructing a bitmask describing the adjustment to
- * be made when the surface is constrained on that axis.
- *
- * If no bit for one axis is set, the compositor will assume that the child
- * surface should not change its position on that axis when constrained.
- *
- * If more than one bit for one axis is set, the order of how adjustments
- * are applied is specified in the corresponding adjustment descriptions.
- *
- * The default adjustment is none.
- */
-static inline void
-xdg_positioner_set_constraint_adjustment(struct xdg_positioner *xdg_positioner, uint32_t constraint_adjustment)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, constraint_adjustment);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Specify the surface position offset relative to the position of the
- * anchor on the anchor rectangle and the anchor on the surface. For
- * example if the anchor of the anchor rectangle is at (x, y), the surface
- * has the gravity bottom|right, and the offset is (ox, oy), the calculated
- * surface position will be (x + ox, y + oy). The offset position of the
- * surface is the one used for constraint testing. See
- * set_constraint_adjustment.
- *
- * An example use case is placing a popup menu on top of a user interface
- * element, while aligning the user interface element of the parent surface
- * with some user interface element placed somewhere in the popup surface.
- */
-static inline void
-xdg_positioner_set_offset(struct xdg_positioner *xdg_positioner, int32_t x, int32_t y)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_OFFSET, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, x, y);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * When set reactive, the surface is reconstrained if the conditions used
- * for constraining changed, e.g. the parent window moved.
- *
- * If the conditions changed and the popup was reconstrained, an
- * xdg_popup.configure event is sent with updated geometry, followed by an
- * xdg_surface.configure event.
- */
-static inline void
-xdg_positioner_set_reactive(struct xdg_positioner *xdg_positioner)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_REACTIVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Set the parent window geometry the compositor should use when
- * positioning the popup. The compositor may use this information to
- * determine the future state the popup should be constrained using. If
- * this doesn't match the dimension of the parent the popup is eventually
- * positioned against, the behavior is undefined.
- *
- * The arguments are given in the surface-local coordinate space.
- */
-static inline void
-xdg_positioner_set_parent_size(struct xdg_positioner *xdg_positioner, int32_t parent_width, int32_t parent_height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_PARENT_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, parent_width, parent_height);
-}
-
-/**
- * @ingroup iface_xdg_positioner
- *
- * Set the serial of an xdg_surface.configure event this positioner will be
- * used in response to. The compositor may use this information together
- * with set_parent_size to determine what future state the popup should be
- * constrained using.
- */
-static inline void
-xdg_positioner_set_parent_configure(struct xdg_positioner *xdg_positioner, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_positioner,
- XDG_POSITIONER_SET_PARENT_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_positioner), 0, serial);
-}
-
-#ifndef XDG_SURFACE_ERROR_ENUM
-#define XDG_SURFACE_ERROR_ENUM
-enum xdg_surface_error {
- /**
- * Surface was not fully constructed
- */
- XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1,
- /**
- * Surface was already constructed
- */
- XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2,
- /**
- * Attaching a buffer to an unconfigured surface
- */
- XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3,
- /**
- * Invalid serial number when acking a configure event
- */
- XDG_SURFACE_ERROR_INVALID_SERIAL = 4,
- /**
- * Width or height was zero or negative
- */
- XDG_SURFACE_ERROR_INVALID_SIZE = 5,
-};
-#endif /* XDG_SURFACE_ERROR_ENUM */
-
-/**
- * @ingroup iface_xdg_surface
- * @struct xdg_surface_listener
- */
-struct xdg_surface_listener {
- /**
- * suggest a surface change
- *
- * The configure event marks the end of a configure sequence. A
- * configure sequence is a set of one or more events configuring
- * the state of the xdg_surface, including the final
- * xdg_surface.configure event.
- *
- * Where applicable, xdg_surface surface roles will during a
- * configure sequence extend this event as a latched state sent as
- * events before the xdg_surface.configure event. Such events
- * should be considered to make up a set of atomically applied
- * configuration states, where the xdg_surface.configure commits
- * the accumulated state.
- *
- * Clients should arrange their surface for the new states, and
- * then send an ack_configure request with the serial sent in this
- * configure event at some point before committing the new surface.
- *
- * If the client receives multiple configure events before it can
- * respond to one, it is free to discard all but the last event it
- * received.
- * @param serial serial of the configure event
- */
- void (*configure)(void *data,
- struct xdg_surface *xdg_surface,
- uint32_t serial);
-};
-
-/**
- * @ingroup iface_xdg_surface
- */
-static inline int
-xdg_surface_add_listener(struct xdg_surface *xdg_surface,
- const struct xdg_surface_listener *listener, void *data)
-{
- return wl_proxy_add_listener((struct wl_proxy *) xdg_surface,
- (void (**)(void)) listener, data);
-}
-
-#define XDG_SURFACE_DESTROY 0
-#define XDG_SURFACE_GET_TOPLEVEL 1
-#define XDG_SURFACE_GET_POPUP 2
-#define XDG_SURFACE_SET_WINDOW_GEOMETRY 3
-#define XDG_SURFACE_ACK_CONFIGURE 4
-
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
-
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_DESTROY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_surface
- */
-#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1
-
-/** @ingroup iface_xdg_surface */
-static inline void
-xdg_surface_set_user_data(struct xdg_surface *xdg_surface, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) xdg_surface, user_data);
-}
-
-/** @ingroup iface_xdg_surface */
-static inline void *
-xdg_surface_get_user_data(struct xdg_surface *xdg_surface)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) xdg_surface);
-}
-
-static inline uint32_t
-xdg_surface_get_version(struct xdg_surface *xdg_surface)
-{
- return wl_proxy_get_version((struct wl_proxy *) xdg_surface);
-}
-
-/**
- * @ingroup iface_xdg_surface
- *
- * Destroy the xdg_surface object. An xdg_surface must only be destroyed
- * after its role object has been destroyed.
- */
-static inline void
-xdg_surface_destroy(struct xdg_surface *xdg_surface)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
- XDG_SURFACE_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), WL_MARSHAL_FLAG_DESTROY);
-}
-
-/**
- * @ingroup iface_xdg_surface
- *
- * This creates an xdg_toplevel object for the given xdg_surface and gives
- * the associated wl_surface the xdg_toplevel role.
- *
- * See the documentation of xdg_toplevel for more details about what an
- * xdg_toplevel is and how it is used.
- */
-static inline struct xdg_toplevel *
-xdg_surface_get_toplevel(struct xdg_surface *xdg_surface)
-{
- struct wl_proxy *id;
-
- id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
- XDG_SURFACE_GET_TOPLEVEL, &xdg_toplevel_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL);
-
- return (struct xdg_toplevel *) id;
-}
-
-/**
- * @ingroup iface_xdg_surface
- *
- * This creates an xdg_popup object for the given xdg_surface and gives
- * the associated wl_surface the xdg_popup role.
- *
- * If null is passed as a parent, a parent surface must be specified using
- * some other protocol, before committing the initial state.
- *
- * See the documentation of xdg_popup for more details about what an
- * xdg_popup is and how it is used.
- */
-static inline struct xdg_popup *
-xdg_surface_get_popup(struct xdg_surface *xdg_surface, struct xdg_surface *parent, struct xdg_positioner *positioner)
-{
- struct wl_proxy *id;
-
- id = wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
- XDG_SURFACE_GET_POPUP, &xdg_popup_interface, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, NULL, parent, positioner);
-
- return (struct xdg_popup *) id;
-}
-
-/**
- * @ingroup iface_xdg_surface
- *
- * The window geometry of a surface is its "visible bounds" from the
- * user's perspective. Client-side decorations often have invisible
- * portions like drop-shadows which should be ignored for the
- * purposes of aligning, placing and constraining windows.
- *
- * The window geometry is double buffered, and will be applied at the
- * time wl_surface.commit of the corresponding wl_surface is called.
- *
- * When maintaining a position, the compositor should treat the (x, y)
- * coordinate of the window geometry as the top left corner of the window.
- * A client changing the (x, y) window geometry coordinate should in
- * general not alter the position of the window.
- *
- * Once the window geometry of the surface is set, it is not possible to
- * unset it, and it will remain the same until set_window_geometry is
- * called again, even if a new subsurface or buffer is attached.
- *
- * If never set, the value is the full bounds of the surface,
- * including any subsurfaces. This updates dynamically on every
- * commit. This unset is meant for extremely simple clients.
- *
- * The arguments are given in the surface-local coordinate space of
- * the wl_surface associated with this xdg_surface.
- *
- * The width and height must be greater than zero. Setting an invalid size
- * will raise an invalid_size error. When applied, the effective window
- * geometry will be the set window geometry clamped to the bounding
- * rectangle of the combined geometry of the surface of the xdg_surface and
- * the associated subsurfaces.
- */
-static inline void
-xdg_surface_set_window_geometry(struct xdg_surface *xdg_surface, int32_t x, int32_t y, int32_t width, int32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
- XDG_SURFACE_SET_WINDOW_GEOMETRY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, x, y, width, height);
-}
-
-/**
- * @ingroup iface_xdg_surface
- *
- * When a configure event is received, if a client commits the
- * surface in response to the configure event, then the client
- * must make an ack_configure request sometime before the commit
- * request, passing along the serial of the configure event.
- *
- * For instance, for toplevel surfaces the compositor might use this
- * information to move a surface to the top left only when the client has
- * drawn itself for the maximized or fullscreen state.
- *
- * If the client receives multiple configure events before it
- * can respond to one, it only has to ack the last configure event.
- * Acking a configure event that was never sent raises an invalid_serial
- * error.
- *
- * A client is not required to commit immediately after sending
- * an ack_configure request - it may even ack_configure several times
- * before its next surface commit.
- *
- * A client may send multiple ack_configure requests before committing, but
- * only the last request sent before a commit indicates which configure
- * event the client really is responding to.
- *
- * Sending an ack_configure request consumes the serial number sent with
- * the request, as well as serial numbers sent by all configure events
- * sent on this xdg_surface prior to the configure event referenced by
- * the committed serial.
- *
- * It is an error to issue multiple ack_configure requests referencing a
- * serial from the same configure event, or to issue an ack_configure
- * request referencing a serial from a configure event issued before the
- * event identified by the last ack_configure request for the same
- * xdg_surface. Doing so will raise an invalid_serial error.
- */
-static inline void
-xdg_surface_ack_configure(struct xdg_surface *xdg_surface, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_surface,
- XDG_SURFACE_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_surface), 0, serial);
-}
-
-#ifndef XDG_TOPLEVEL_ERROR_ENUM
-#define XDG_TOPLEVEL_ERROR_ENUM
-enum xdg_toplevel_error {
- /**
- * provided value is not a valid variant of the resize_edge enum
- */
- XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE = 0,
- /**
- * invalid parent toplevel
- */
- XDG_TOPLEVEL_ERROR_INVALID_PARENT = 1,
- /**
- * client provided an invalid min or max size
- */
- XDG_TOPLEVEL_ERROR_INVALID_SIZE = 2,
-};
-#endif /* XDG_TOPLEVEL_ERROR_ENUM */
-
-#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM
-#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM
-/**
- * @ingroup iface_xdg_toplevel
- * edge values for resizing
- *
- * These values are used to indicate which edge of a surface
- * is being dragged in a resize operation.
- */
-enum xdg_toplevel_resize_edge {
- XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0,
- XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1,
- XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2,
- XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4,
- XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5,
- XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6,
- XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8,
- XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9,
- XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10,
-};
-#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM */
-
-#ifndef XDG_TOPLEVEL_STATE_ENUM
-#define XDG_TOPLEVEL_STATE_ENUM
-/**
- * @ingroup iface_xdg_toplevel
- * types of state on the surface
- *
- * The different state values used on the surface. This is designed for
- * state values like maximized, fullscreen. It is paired with the
- * configure event to ensure that both the client and the compositor
- * setting the state can be synchronized.
- *
- * States set in this way are double-buffered. They will get applied on
- * the next commit.
- */
-enum xdg_toplevel_state {
- /**
- * the surface is maximized
- * the surface is maximized
- *
- * The surface is maximized. The window geometry specified in the
- * configure event must be obeyed by the client.
- *
- * The client should draw without shadow or other decoration
- * outside of the window geometry.
- */
- XDG_TOPLEVEL_STATE_MAXIMIZED = 1,
- /**
- * the surface is fullscreen
- * the surface is fullscreen
- *
- * The surface is fullscreen. The window geometry specified in
- * the configure event is a maximum; the client cannot resize
- * beyond it. For a surface to cover the whole fullscreened area,
- * the geometry dimensions must be obeyed by the client. For more
- * details, see xdg_toplevel.set_fullscreen.
- */
- XDG_TOPLEVEL_STATE_FULLSCREEN = 2,
- /**
- * the surface is being resized
- * the surface is being resized
- *
- * The surface is being resized. The window geometry specified in
- * the configure event is a maximum; the client cannot resize
- * beyond it. Clients that have aspect ratio or cell sizing
- * configuration can use a smaller size, however.
- */
- XDG_TOPLEVEL_STATE_RESIZING = 3,
- /**
- * the surface is now activated
- * the surface is now activated
- *
- * Client window decorations should be painted as if the window
- * is active. Do not assume this means that the window actually has
- * keyboard or pointer focus.
- */
- XDG_TOPLEVEL_STATE_ACTIVATED = 4,
- /**
- * the surface’s left edge is tiled
- *
- * The window is currently in a tiled layout and the left edge is
- * considered to be adjacent to another part of the tiling grid.
- * @since 2
- */
- XDG_TOPLEVEL_STATE_TILED_LEFT = 5,
- /**
- * the surface’s right edge is tiled
- *
- * The window is currently in a tiled layout and the right edge
- * is considered to be adjacent to another part of the tiling grid.
- * @since 2
- */
- XDG_TOPLEVEL_STATE_TILED_RIGHT = 6,
- /**
- * the surface’s top edge is tiled
- *
- * The window is currently in a tiled layout and the top edge is
- * considered to be adjacent to another part of the tiling grid.
- * @since 2
- */
- XDG_TOPLEVEL_STATE_TILED_TOP = 7,
- /**
- * the surface’s bottom edge is tiled
- *
- * The window is currently in a tiled layout and the bottom edge
- * is considered to be adjacent to another part of the tiling grid.
- * @since 2
- */
- XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8,
-};
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2
-#endif /* XDG_TOPLEVEL_STATE_ENUM */
-
-#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
-#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
-enum xdg_toplevel_wm_capabilities {
- /**
- * show_window_menu is available
- */
- XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU = 1,
- /**
- * set_maximized and unset_maximized are available
- */
- XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE = 2,
- /**
- * set_fullscreen and unset_fullscreen are available
- */
- XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN = 3,
- /**
- * set_minimized is available
- */
- XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE = 4,
-};
-#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM */
-
-/**
- * @ingroup iface_xdg_toplevel
- * @struct xdg_toplevel_listener
- */
-struct xdg_toplevel_listener {
- /**
- * suggest a surface change
- *
- * This configure event asks the client to resize its toplevel
- * surface or to change its state. The configured state should not
- * be applied immediately. See xdg_surface.configure for details.
- *
- * The width and height arguments specify a hint to the window
- * about how its surface should be resized in window geometry
- * coordinates. See set_window_geometry.
- *
- * If the width or height arguments are zero, it means the client
- * should decide its own window dimension. This may happen when the
- * compositor needs to configure the state of the surface but
- * doesn't have any information about any previous or expected
- * dimension.
- *
- * The states listed in the event specify how the width/height
- * arguments should be interpreted, and possibly how it should be
- * drawn.
- *
- * Clients must send an ack_configure in response to this event.
- * See xdg_surface.configure and xdg_surface.ack_configure for
- * details.
- */
- void (*configure)(void *data,
- struct xdg_toplevel *xdg_toplevel,
- int32_t width,
- int32_t height,
- struct wl_array *states);
- /**
- * surface wants to be closed
- *
- * The close event is sent by the compositor when the user wants
- * the surface to be closed. This should be equivalent to the user
- * clicking the close button in client-side decorations, if your
- * application has any.
- *
- * This is only a request that the user intends to close the
- * window. The client may choose to ignore this request, or show a
- * dialog to ask the user to save their data, etc.
- */
- void (*close)(void *data,
- struct xdg_toplevel *xdg_toplevel);
- /**
- * recommended window geometry bounds
- *
- * The configure_bounds event may be sent prior to a
- * xdg_toplevel.configure event to communicate the bounds a window
- * geometry size is recommended to constrain to.
- *
- * The passed width and height are in surface coordinate space. If
- * width and height are 0, it means bounds is unknown and
- * equivalent to as if no configure_bounds event was ever sent for
- * this surface.
- *
- * The bounds can for example correspond to the size of a monitor
- * excluding any panels or other shell components, so that a
- * surface isn't created in a way that it cannot fit.
- *
- * The bounds may change at any point, and in such a case, a new
- * xdg_toplevel.configure_bounds will be sent, followed by
- * xdg_toplevel.configure and xdg_surface.configure.
- * @since 4
- */
- void (*configure_bounds)(void *data,
- struct xdg_toplevel *xdg_toplevel,
- int32_t width,
- int32_t height);
- /**
- * compositor capabilities
- *
- * This event advertises the capabilities supported by the
- * compositor. If a capability isn't supported, clients should hide
- * or disable the UI elements that expose this functionality. For
- * instance, if the compositor doesn't advertise support for
- * minimized toplevels, a button triggering the set_minimized
- * request should not be displayed.
- *
- * The compositor will ignore requests it doesn't support. For
- * instance, a compositor which doesn't advertise support for
- * minimized will ignore set_minimized requests.
- *
- * Compositors must send this event once before the first
- * xdg_surface.configure event. When the capabilities change,
- * compositors must send this event again and then send an
- * xdg_surface.configure event.
- *
- * The configured state should not be applied immediately. See
- * xdg_surface.configure for details.
- *
- * The capabilities are sent as an array of 32-bit unsigned
- * integers in native endianness.
- * @param capabilities array of 32-bit capabilities
- * @since 5
- */
- void (*wm_capabilities)(void *data,
- struct xdg_toplevel *xdg_toplevel,
- struct wl_array *capabilities);
-};
-
-/**
- * @ingroup iface_xdg_toplevel
- */
-static inline int
-xdg_toplevel_add_listener(struct xdg_toplevel *xdg_toplevel,
- const struct xdg_toplevel_listener *listener, void *data)
-{
- return wl_proxy_add_listener((struct wl_proxy *) xdg_toplevel,
- (void (**)(void)) listener, data);
-}
-
-#define XDG_TOPLEVEL_DESTROY 0
-#define XDG_TOPLEVEL_SET_PARENT 1
-#define XDG_TOPLEVEL_SET_TITLE 2
-#define XDG_TOPLEVEL_SET_APP_ID 3
-#define XDG_TOPLEVEL_SHOW_WINDOW_MENU 4
-#define XDG_TOPLEVEL_MOVE 5
-#define XDG_TOPLEVEL_RESIZE 6
-#define XDG_TOPLEVEL_SET_MAX_SIZE 7
-#define XDG_TOPLEVEL_SET_MIN_SIZE 8
-#define XDG_TOPLEVEL_SET_MAXIMIZED 9
-#define XDG_TOPLEVEL_UNSET_MAXIMIZED 10
-#define XDG_TOPLEVEL_SET_FULLSCREEN 11
-#define XDG_TOPLEVEL_UNSET_FULLSCREEN 12
-#define XDG_TOPLEVEL_SET_MINIMIZED 13
-
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION 4
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION 5
-
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_toplevel
- */
-#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1
-
-/** @ingroup iface_xdg_toplevel */
-static inline void
-xdg_toplevel_set_user_data(struct xdg_toplevel *xdg_toplevel, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) xdg_toplevel, user_data);
-}
-
-/** @ingroup iface_xdg_toplevel */
-static inline void *
-xdg_toplevel_get_user_data(struct xdg_toplevel *xdg_toplevel)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) xdg_toplevel);
-}
-
-static inline uint32_t
-xdg_toplevel_get_version(struct xdg_toplevel *xdg_toplevel)
-{
- return wl_proxy_get_version((struct wl_proxy *) xdg_toplevel);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * This request destroys the role surface and unmaps the surface;
- * see "Unmapping" behavior in interface section for details.
- */
-static inline void
-xdg_toplevel_destroy(struct xdg_toplevel *xdg_toplevel)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), WL_MARSHAL_FLAG_DESTROY);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Set the "parent" of this surface. This surface should be stacked
- * above the parent surface and all other ancestor surfaces.
- *
- * Parent surfaces should be set on dialogs, toolboxes, or other
- * "auxiliary" surfaces, so that the parent is raised when the dialog
- * is raised.
- *
- * Setting a null parent for a child surface unsets its parent. Setting
- * a null parent for a surface which currently has no parent is a no-op.
- *
- * Only mapped surfaces can have child surfaces. Setting a parent which
- * is not mapped is equivalent to setting a null parent. If a surface
- * becomes unmapped, its children's parent is set to the parent of
- * the now-unmapped surface. If the now-unmapped surface has no parent,
- * its children's parent is unset. If the now-unmapped surface becomes
- * mapped again, its parent-child relationship is not restored.
- *
- * The parent toplevel must not be one of the child toplevel's
- * descendants, and the parent must be different from the child toplevel,
- * otherwise the invalid_parent protocol error is raised.
- */
-static inline void
-xdg_toplevel_set_parent(struct xdg_toplevel *xdg_toplevel, struct xdg_toplevel *parent)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_PARENT, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, parent);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Set a short title for the surface.
- *
- * This string may be used to identify the surface in a task bar,
- * window list, or other user interface elements provided by the
- * compositor.
- *
- * The string must be encoded in UTF-8.
- */
-static inline void
-xdg_toplevel_set_title(struct xdg_toplevel *xdg_toplevel, const char *title)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_TITLE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, title);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Set an application identifier for the surface.
- *
- * The app ID identifies the general class of applications to which
- * the surface belongs. The compositor can use this to group multiple
- * surfaces together, or to determine how to launch a new application.
- *
- * For D-Bus activatable applications, the app ID is used as the D-Bus
- * service name.
- *
- * The compositor shell will try to group application surfaces together
- * by their app ID. As a best practice, it is suggested to select app
- * ID's that match the basename of the application's .desktop file.
- * For example, "org.freedesktop.FooViewer" where the .desktop file is
- * "org.freedesktop.FooViewer.desktop".
- *
- * Like other properties, a set_app_id request can be sent after the
- * xdg_toplevel has been mapped to update the property.
- *
- * See the desktop-entry specification [0] for more details on
- * application identifiers and how they relate to well-known D-Bus
- * names and .desktop files.
- *
- * [0] https://standards.freedesktop.org/desktop-entry-spec/
- */
-static inline void
-xdg_toplevel_set_app_id(struct xdg_toplevel *xdg_toplevel, const char *app_id)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_APP_ID, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, app_id);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Clients implementing client-side decorations might want to show
- * a context menu when right-clicking on the decorations, giving the
- * user a menu that they can use to maximize or minimize the window.
- *
- * This request asks the compositor to pop up such a window menu at
- * the given position, relative to the local surface coordinates of
- * the parent surface. There are no guarantees as to what menu items
- * the window menu contains, or even if a window menu will be drawn
- * at all.
- *
- * This request must be used in response to some sort of user action
- * like a button press, key press, or touch down event.
- */
-static inline void
-xdg_toplevel_show_window_menu(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SHOW_WINDOW_MENU, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, x, y);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Start an interactive, user-driven move of the surface.
- *
- * This request must be used in response to some sort of user action
- * like a button press, key press, or touch down event. The passed
- * serial is used to determine the type of interactive move (touch,
- * pointer, etc).
- *
- * The server may ignore move requests depending on the state of
- * the surface (e.g. fullscreen or maximized), or if the passed serial
- * is no longer valid.
- *
- * If triggered, the surface will lose the focus of the device
- * (wl_pointer, wl_touch, etc) used for the move. It is up to the
- * compositor to visually indicate that the move is taking place, such as
- * updating a pointer cursor, during the move. There is no guarantee
- * that the device focus will return when the move is completed.
- */
-static inline void
-xdg_toplevel_move(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_MOVE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Start a user-driven, interactive resize of the surface.
- *
- * This request must be used in response to some sort of user action
- * like a button press, key press, or touch down event. The passed
- * serial is used to determine the type of interactive resize (touch,
- * pointer, etc).
- *
- * The server may ignore resize requests depending on the state of
- * the surface (e.g. fullscreen or maximized).
- *
- * If triggered, the client will receive configure events with the
- * "resize" state enum value and the expected sizes. See the "resize"
- * enum value for more details about what is required. The client
- * must also acknowledge configure events using "ack_configure". After
- * the resize is completed, the client will receive another "configure"
- * event without the resize state.
- *
- * If triggered, the surface also will lose the focus of the device
- * (wl_pointer, wl_touch, etc) used for the resize. It is up to the
- * compositor to visually indicate that the resize is taking place,
- * such as updating a pointer cursor, during the resize. There is no
- * guarantee that the device focus will return when the resize is
- * completed.
- *
- * The edges parameter specifies how the surface should be resized, and
- * is one of the values of the resize_edge enum. Values not matching
- * a variant of the enum will cause a protocol error. The compositor
- * may use this information to update the surface position for example
- * when dragging the top left corner. The compositor may also use
- * this information to adapt its behavior, e.g. choose an appropriate
- * cursor image.
- */
-static inline void
-xdg_toplevel_resize(struct xdg_toplevel *xdg_toplevel, struct wl_seat *seat, uint32_t serial, uint32_t edges)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_RESIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, seat, serial, edges);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Set a maximum size for the window.
- *
- * The client can specify a maximum size so that the compositor does
- * not try to configure the window beyond this size.
- *
- * The width and height arguments are in window geometry coordinates.
- * See xdg_surface.set_window_geometry.
- *
- * Values set in this way are double-buffered. They will get applied
- * on the next commit.
- *
- * The compositor can use this information to allow or disallow
- * different states like maximize or fullscreen and draw accurate
- * animations.
- *
- * Similarly, a tiling window manager may use this information to
- * place and resize client windows in a more effective way.
- *
- * The client should not rely on the compositor to obey the maximum
- * size. The compositor may decide to ignore the values set by the
- * client and request a larger size.
- *
- * If never set, or a value of zero in the request, means that the
- * client has no expected maximum size in the given dimension.
- * As a result, a client wishing to reset the maximum size
- * to an unspecified state can use zero for width and height in the
- * request.
- *
- * Requesting a maximum size to be smaller than the minimum size of
- * a surface is illegal and will result in an invalid_size error.
- *
- * The width and height must be greater than or equal to zero. Using
- * strictly negative values for width or height will result in a
- * invalid_size error.
- */
-static inline void
-xdg_toplevel_set_max_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_MAX_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Set a minimum size for the window.
- *
- * The client can specify a minimum size so that the compositor does
- * not try to configure the window below this size.
- *
- * The width and height arguments are in window geometry coordinates.
- * See xdg_surface.set_window_geometry.
- *
- * Values set in this way are double-buffered. They will get applied
- * on the next commit.
- *
- * The compositor can use this information to allow or disallow
- * different states like maximize or fullscreen and draw accurate
- * animations.
- *
- * Similarly, a tiling window manager may use this information to
- * place and resize client windows in a more effective way.
- *
- * The client should not rely on the compositor to obey the minimum
- * size. The compositor may decide to ignore the values set by the
- * client and request a smaller size.
- *
- * If never set, or a value of zero in the request, means that the
- * client has no expected minimum size in the given dimension.
- * As a result, a client wishing to reset the minimum size
- * to an unspecified state can use zero for width and height in the
- * request.
- *
- * Requesting a minimum size to be larger than the maximum size of
- * a surface is illegal and will result in an invalid_size error.
- *
- * The width and height must be greater than or equal to zero. Using
- * strictly negative values for width and height will result in a
- * invalid_size error.
- */
-static inline void
-xdg_toplevel_set_min_size(struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_MIN_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, width, height);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Maximize the surface.
- *
- * After requesting that the surface should be maximized, the compositor
- * will respond by emitting a configure event. Whether this configure
- * actually sets the window maximized is subject to compositor policies.
- * The client must then update its content, drawing in the configured
- * state. The client must also acknowledge the configure when committing
- * the new content (see ack_configure).
- *
- * It is up to the compositor to decide how and where to maximize the
- * surface, for example which output and what region of the screen should
- * be used.
- *
- * If the surface was already maximized, the compositor will still emit
- * a configure event with the "maximized" state.
- *
- * If the surface is in a fullscreen state, this request has no direct
- * effect. It may alter the state the surface is returned to when
- * unmaximized unless overridden by the compositor.
- */
-static inline void
-xdg_toplevel_set_maximized(struct xdg_toplevel *xdg_toplevel)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Unmaximize the surface.
- *
- * After requesting that the surface should be unmaximized, the compositor
- * will respond by emitting a configure event. Whether this actually
- * un-maximizes the window is subject to compositor policies.
- * If available and applicable, the compositor will include the window
- * geometry dimensions the window had prior to being maximized in the
- * configure event. The client must then update its content, drawing it in
- * the configured state. The client must also acknowledge the configure
- * when committing the new content (see ack_configure).
- *
- * It is up to the compositor to position the surface after it was
- * unmaximized; usually the position the surface had before maximizing, if
- * applicable.
- *
- * If the surface was already not maximized, the compositor will still
- * emit a configure event without the "maximized" state.
- *
- * If the surface is in a fullscreen state, this request has no direct
- * effect. It may alter the state the surface is returned to when
- * unmaximized unless overridden by the compositor.
- */
-static inline void
-xdg_toplevel_unset_maximized(struct xdg_toplevel *xdg_toplevel)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_UNSET_MAXIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Make the surface fullscreen.
- *
- * After requesting that the surface should be fullscreened, the
- * compositor will respond by emitting a configure event. Whether the
- * client is actually put into a fullscreen state is subject to compositor
- * policies. The client must also acknowledge the configure when
- * committing the new content (see ack_configure).
- *
- * The output passed by the request indicates the client's preference as
- * to which display it should be set fullscreen on. If this value is NULL,
- * it's up to the compositor to choose which display will be used to map
- * this surface.
- *
- * If the surface doesn't cover the whole output, the compositor will
- * position the surface in the center of the output and compensate with
- * with border fill covering the rest of the output. The content of the
- * border fill is undefined, but should be assumed to be in some way that
- * attempts to blend into the surrounding area (e.g. solid black).
- *
- * If the fullscreened surface is not opaque, the compositor must make
- * sure that other screen content not part of the same surface tree (made
- * up of subsurfaces, popups or similarly coupled surfaces) are not
- * visible below the fullscreened surface.
- */
-static inline void
-xdg_toplevel_set_fullscreen(struct xdg_toplevel *xdg_toplevel, struct wl_output *output)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0, output);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Make the surface no longer fullscreen.
- *
- * After requesting that the surface should be unfullscreened, the
- * compositor will respond by emitting a configure event.
- * Whether this actually removes the fullscreen state of the client is
- * subject to compositor policies.
- *
- * Making a surface unfullscreen sets states for the surface based on the following:
- * * the state(s) it may have had before becoming fullscreen
- * * any state(s) decided by the compositor
- * * any state(s) requested by the client while the surface was fullscreen
- *
- * The compositor may include the previous window geometry dimensions in
- * the configure event, if applicable.
- *
- * The client must also acknowledge the configure when committing the new
- * content (see ack_configure).
- */
-static inline void
-xdg_toplevel_unset_fullscreen(struct xdg_toplevel *xdg_toplevel)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_UNSET_FULLSCREEN, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
-}
-
-/**
- * @ingroup iface_xdg_toplevel
- *
- * Request that the compositor minimize your surface. There is no
- * way to know if the surface is currently minimized, nor is there
- * any way to unset minimization on this surface.
- *
- * If you are looking to throttle redrawing when minimized, please
- * instead use the wl_surface.frame event for this, as this will
- * also work with live previews on windows in Alt-Tab, Expose or
- * similar compositor features.
- */
-static inline void
-xdg_toplevel_set_minimized(struct xdg_toplevel *xdg_toplevel)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel,
- XDG_TOPLEVEL_SET_MINIMIZED, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_toplevel), 0);
-}
-
-#ifndef XDG_POPUP_ERROR_ENUM
-#define XDG_POPUP_ERROR_ENUM
-enum xdg_popup_error {
- /**
- * tried to grab after being mapped
- */
- XDG_POPUP_ERROR_INVALID_GRAB = 0,
-};
-#endif /* XDG_POPUP_ERROR_ENUM */
-
-/**
- * @ingroup iface_xdg_popup
- * @struct xdg_popup_listener
- */
-struct xdg_popup_listener {
- /**
- * configure the popup surface
- *
- * This event asks the popup surface to configure itself given
- * the configuration. The configured state should not be applied
- * immediately. See xdg_surface.configure for details.
- *
- * The x and y arguments represent the position the popup was
- * placed at given the xdg_positioner rule, relative to the upper
- * left corner of the window geometry of the parent surface.
- *
- * For version 2 or older, the configure event for an xdg_popup is
- * only ever sent once for the initial configuration. Starting with
- * version 3, it may be sent again if the popup is setup with an
- * xdg_positioner with set_reactive requested, or in response to
- * xdg_popup.reposition requests.
- * @param x x position relative to parent surface window geometry
- * @param y y position relative to parent surface window geometry
- * @param width window geometry width
- * @param height window geometry height
- */
- void (*configure)(void *data,
- struct xdg_popup *xdg_popup,
- int32_t x,
- int32_t y,
- int32_t width,
- int32_t height);
- /**
- * popup interaction is done
- *
- * The popup_done event is sent out when a popup is dismissed by
- * the compositor. The client should destroy the xdg_popup object
- * at this point.
- */
- void (*popup_done)(void *data,
- struct xdg_popup *xdg_popup);
- /**
- * signal the completion of a repositioned request
- *
- * The repositioned event is sent as part of a popup
- * configuration sequence, together with xdg_popup.configure and
- * lastly xdg_surface.configure to notify the completion of a
- * reposition request.
- *
- * The repositioned event is to notify about the completion of a
- * xdg_popup.reposition request. The token argument is the token
- * passed in the xdg_popup.reposition request.
- *
- * Immediately after this event is emitted, xdg_popup.configure and
- * xdg_surface.configure will be sent with the updated size and
- * position, as well as a new configure serial.
- *
- * The client should optionally update the content of the popup,
- * but must acknowledge the new popup configuration for the new
- * position to take effect. See xdg_surface.ack_configure for
- * details.
- * @param token reposition request token
- * @since 3
- */
- void (*repositioned)(void *data,
- struct xdg_popup *xdg_popup,
- uint32_t token);
-};
-
-/**
- * @ingroup iface_xdg_popup
- */
-static inline int
-xdg_popup_add_listener(struct xdg_popup *xdg_popup,
- const struct xdg_popup_listener *listener, void *data)
-{
- return wl_proxy_add_listener((struct wl_proxy *) xdg_popup,
- (void (**)(void)) listener, data);
-}
-
-#define XDG_POPUP_DESTROY 0
-#define XDG_POPUP_GRAB 1
-#define XDG_POPUP_REPOSITION 2
-
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3
-
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_DESTROY_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_GRAB_SINCE_VERSION 1
-/**
- * @ingroup iface_xdg_popup
- */
-#define XDG_POPUP_REPOSITION_SINCE_VERSION 3
-
-/** @ingroup iface_xdg_popup */
-static inline void
-xdg_popup_set_user_data(struct xdg_popup *xdg_popup, void *user_data)
-{
- wl_proxy_set_user_data((struct wl_proxy *) xdg_popup, user_data);
-}
-
-/** @ingroup iface_xdg_popup */
-static inline void *
-xdg_popup_get_user_data(struct xdg_popup *xdg_popup)
-{
- return wl_proxy_get_user_data((struct wl_proxy *) xdg_popup);
-}
-
-static inline uint32_t
-xdg_popup_get_version(struct xdg_popup *xdg_popup)
-{
- return wl_proxy_get_version((struct wl_proxy *) xdg_popup);
-}
-
-/**
- * @ingroup iface_xdg_popup
- *
- * This destroys the popup. Explicitly destroying the xdg_popup
- * object will also dismiss the popup, and unmap the surface.
- *
- * If this xdg_popup is not the "topmost" popup, a protocol error
- * will be sent.
- */
-static inline void
-xdg_popup_destroy(struct xdg_popup *xdg_popup)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
- XDG_POPUP_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), WL_MARSHAL_FLAG_DESTROY);
-}
-
-/**
- * @ingroup iface_xdg_popup
- *
- * This request makes the created popup take an explicit grab. An explicit
- * grab will be dismissed when the user dismisses the popup, or when the
- * client destroys the xdg_popup. This can be done by the user clicking
- * outside the surface, using the keyboard, or even locking the screen
- * through closing the lid or a timeout.
- *
- * If the compositor denies the grab, the popup will be immediately
- * dismissed.
- *
- * This request must be used in response to some sort of user action like a
- * button press, key press, or touch down event. The serial number of the
- * event should be passed as 'serial'.
- *
- * The parent of a grabbing popup must either be an xdg_toplevel surface or
- * another xdg_popup with an explicit grab. If the parent is another
- * xdg_popup it means that the popups are nested, with this popup now being
- * the topmost popup.
- *
- * Nested popups must be destroyed in the reverse order they were created
- * in, e.g. the only popup you are allowed to destroy at all times is the
- * topmost one.
- *
- * When compositors choose to dismiss a popup, they may dismiss every
- * nested grabbing popup as well. When a compositor dismisses popups, it
- * will follow the same dismissing order as required from the client.
- *
- * If the topmost grabbing popup is destroyed, the grab will be returned to
- * the parent of the popup, if that parent previously had an explicit grab.
- *
- * If the parent is a grabbing popup which has already been dismissed, this
- * popup will be immediately dismissed. If the parent is a popup that did
- * not take an explicit grab, an error will be raised.
- *
- * During a popup grab, the client owning the grab will receive pointer
- * and touch events for all their surfaces as normal (similar to an
- * "owner-events" grab in X11 parlance), while the top most grabbing popup
- * will always have keyboard focus.
- */
-static inline void
-xdg_popup_grab(struct xdg_popup *xdg_popup, struct wl_seat *seat, uint32_t serial)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
- XDG_POPUP_GRAB, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, seat, serial);
-}
-
-/**
- * @ingroup iface_xdg_popup
- *
- * Reposition an already-mapped popup. The popup will be placed given the
- * details in the passed xdg_positioner object, and a
- * xdg_popup.repositioned followed by xdg_popup.configure and
- * xdg_surface.configure will be emitted in response. Any parameters set
- * by the previous positioner will be discarded.
- *
- * The passed token will be sent in the corresponding
- * xdg_popup.repositioned event. The new popup position will not take
- * effect until the corresponding configure event is acknowledged by the
- * client. See xdg_popup.repositioned for details. The token itself is
- * opaque, and has no other special meaning.
- *
- * If multiple reposition requests are sent, the compositor may skip all
- * but the last one.
- *
- * If the popup is repositioned in response to a configure event for its
- * parent, the client should send an xdg_positioner.set_parent_configure
- * and possibly an xdg_positioner.set_parent_size request to allow the
- * compositor to properly constrain the popup.
- *
- * If the popup is repositioned together with a parent that is being
- * resized, but not in response to a configure event, the client should
- * send an xdg_positioner.set_parent_size request.
- */
-static inline void
-xdg_popup_reposition(struct xdg_popup *xdg_popup, struct xdg_positioner *positioner, uint32_t token)
-{
- wl_proxy_marshal_flags((struct wl_proxy *) xdg_popup,
- XDG_POPUP_REPOSITION, NULL, wl_proxy_get_version((struct wl_proxy *) xdg_popup), 0, positioner, token);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/xdg-shell-protocol.o b/xdg-shell-protocol.o
deleted file mode 100644
index c9a26c151d79f5e4ede555237d0916adce656fef..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 11824
zcmeI2Yjjgp7ROHsk0KO;Kq)XIDM+a-TMGzc5r~#Y1*`>xsXR>5ByFN;67rxa=n(Co
z1r|~U)(BX!B997#Q$ZPQ1&W}8=&~yE5Ou0N7B8i|v`|Lo?3=yY-LvX^nE5ix@vN1e
zy?%qZ2+`;f6(S|E(Kc$PQN)REjqq1u+3fy+&r=|T
z)n~T^>?W_r?+iFSZo5yoMXo(y3fXc^{-7_%VzmpmM|eH%ToDvrr>vkUKhKnH@!N%8
zhWedz?852PY>V6K@c2wVyEPzD6R5T4`Yf}Zfdb98dfYMzi_;x2S!|C7{ee8YJD|0A
za&n}wX3F%e0q1PH7^Jygi%$kch8%?Q$fR73GdJjyp+PN2c1&G5c?`A)aZlW)qkd-Ci7UxBb#pD;D*HClXD;LsyOi;)qPfHUBdQ=%zayk3*j
zCj1U5i|X?5g2EG&S?77=0eOPLXV>P=6AWs7@+_gqk%4rc)6E=9$eAan*(QQ+t+Bxe
zFDK}7`Q?eUyRn%8l)~Olr$ty@9(m##j>(km3A$~5aktD%o>i;GYsq%HHb?oT44VdnSSZp9aRAQeve7x@dE>Bj@
zo%{Bp1q-uA{i)nAuE(xUd7Hm)*=~{fmBovv70r(Ay|-8K`x$LlB}8A>O}gIsnWCbi
zw?@X-eRJ&CLtFmt_2iz)IrZZY>$`+oFBPv3=+QTBTJJl`W6vC4=C^&haQ4>t_@ljh
zS1vfRa8A){sXcr5JheIf)l1dy?|*0TH&M^^>OS36IjxIWR+{`^s&D_7m9Z=9t%=vV
ze^P&<+wohEUpVS~+;U^jocR~;I@kJOyY~|G{SLlZ{YG7@*aZWpU2+_Kwd<0p!>3(#
zyp%a%-G)%tjfo$J*ADCHZ&SAR!>3NJSbaE<(CTdK0mJei8g$`&YQH%zzvTZ%U~GxK
z$CjO?m#^(Su%Yzl89!HF8C!B@$Y)y(Z};75Yq>FD>xudC1vR#d{fA~$6kbU!dt!UV
zz@JTj$bX{8wTjA`VQc56Uns0ty=htLH#5FocIM={)TdXtv%fwU-ZQeoJ+Oq&_clBy
zjq^SF`N|IOrgTYrs`G78pNk6JsPhWCy7kXp
zUE)~%&Y;)sZLuwFlKIetrw^J9DK}reSQ2ReH*x2vKaV^0!hpl>?*8d16>GAt);V6O
z{BGu^tcR!C1MBwen6cxtZ5w9iiy^zFcW|svI&^Ws@)0|OQ5|)^lR34}@`}dnnpVT4
z+e$>sCpUTBL`Btih=B@@Kz^jrE7Do|Eu`JC@lvCMj6}-6Ld?flY6_L)P1@}%H0V!G
zu8SI!w|?1cZ5|$e<%F?P
zeeRlB<^V+bh<=MQ-g+p=*j>V>YxYgZ%)kkGZ`;?o#r`x|d
z(6?Wt?>2t^bkxYQ(DKKwethMR8#6rboDI!CIAr7NlhNM`HeC((>C%YX;D<_{`e=7d
z*wEfMG4`2^@AenwPU;aqb=)n9t_v;pUY>WYPsz41+1p01YkSMEyY(j%LN}`0ey}aA
zWc2uV7hSpM>c--MzK*u{&(>exKcdaC>Dk>5pVIZea`y=_HZ3jHkT^DD${mIQ1Cs|P
zr{J*Kvz9?Ru&&5vdA&qc@ijFHeLAnyPpzT7rMP%g<>2d@JkdoWVr3P@cy$D8e|4fY
z^BPT^Xw&GRl_2XV#?8p#+6GR39P$k0Rp{4Zor4^27!g7~7kL=3Z_;@lc@6SRoS?PH
zjW~&B=|kBrKafui@^p;~aR9jyA8Lq0vre?dsHT-pv}+2`(>3{KYz)x}eWSxHo#@28
zi20SQI<;scs_=MdyL}aTDIPEJb~3Ixb%W%fQ;Nq+@%IqN<0U@+7j$O+0-uFC;Yiwo
zbYNSPY}deZZjMd1X
zzkK(=I!odS2E0Me_*6Fb6$U&n@-&GqXhTKk33yk=Q_uzuYXg;`XaMJLd5nzHJqakC
zaju`qIL{}GajtJ>ygS-Zh0%t5I4}MMUdDJ2w4o|zoaxGtp^jJKTabqs
z=Q?4=LFY}3FH-nk>I_wQYdjt!<6s&wKAmyUf#)A6
znF_Z>u*hN@O|8YuIOz039f!i{y7e;7b;68;P7>-ADV%hQ8Rt5sjDrq5r$H%aTwC|h
zuTnVWQNuXsP&ut|I`6fNqp5YNV;pqSFdusP0WRx;r5InVa9TfCFwW3XhX9CXU$M=Q`-7U&M<
z5!8uRIOU^foaYnAIGATp$DnZ1No1Vs7#RnX)}M5R|AhLPjB}kV#=)$|c(cMO9|z-H
z$ICdFQP>z#_^rspjB}kL#=(rm#$tshAYZ{a*C}Nj%sa5LoN-uJY2B<+xDovt#?h3$
zggC8mnx9(6c|LWFgE@p6wZ*;hx}tR>nsEp%he2i0GY&e#P$y2|V~`sd2UI0LQ0Tn}
zoNmx*xPDkXaGU%<$z&X*HJ-&d#E-*9v%+b99E@`vFXNyy1sg*Or{|?G<6NhdanQ-e
z#&X8Nr1M&(a3lJZFZ@qWFF#ab&;Wj`{QMQ~7qFoK@2pvoKeVSN-WA(uPYS#fi;qW}
z^y&NME`?X1KSbe+&>yaFZQ+t^l)^_~{^J$i1NkI{cR>EA!fD@UR=5@8T?(I%zF*<=
zJRMT_3#e15@Ot!@D0~gZzo>9}UZs5i&GQkA+o8mh{(gniIsQW7o6-MP;R3J2?-gEv
z{xyYP!~E$yP@XF>?sjY^PS01#3O|AVP=zO9J`X6|g?xg-PvW>!72Xeh+GkNd(Wvtz
zwnK$TQ(C3y>_PqYEFNz~t!1wgKLz8}eUKUXQ6-+9_f9c=x)z{IOH7XPzaM=)*3b>|
zsgfTk2FCgOq7jM??W1U2BpsTJ$x3`gT?iA?hjGK`dl;v+1o|vibmCEHC5s208uZsF
z@%Ll=>q@*47ExJtGS1)EeWmC;iay_WXyc;JMJ3)5kr)4D`Vdd+a147Mi^Eu`TB8l;
zt0US_^+p>w+@mSzCn%iOJ8GwR+P@4|;`7i?Rrr(Wi)4R6UO@f|C|Uk=D^fei3fMyd
zk!-UBEFwAE?-$8FyUU{aU`f{#X={QdO?G*#7HHSP?b*Rx`A#^;Bc(LklAZ0d&u-Fe
z@mbut@;y86;&RGgAYm7o5t)EZns4>wX+JPac6$Q$WckmiB!58u&Pzo6Tz4>8zR~yE
zee&07|9ydb4(=EmO+3xF&ok*eV@^(Qb-8cK><(t728D~mf)HT+fk!*j3Jzab)GJcidDJ(p24jZ5_&>`(1f&%*xXQ%(KI
z|6CeyU90zB2>a9b3B^
Date: Thu, 20 Apr 2023 14:22:03 +0100
Subject: [PATCH 11/43] better searching for egl
---
CMakeLists.txt | 10 +++++++---
1 file changed, 7 insertions(+), 3 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1c439e5..278307e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -305,14 +305,18 @@ target_link_libraries(linux-wallpaperengine
glfw)
if (ENABLE_WAYLAND)
+ # finding EGL is a bit troublesome
+ pkg_check_modules(PKG_EGL QUIET egl)
+ find_library(EGL_LIBRARY NAMES EGL libEGL HINTS ${PKG_EGL_LIBRARY_DIRS})
+ add_library(EGL::EGL UNKNOWN IMPORTED)
+
target_link_libraries(linux-wallpaperengine ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1-protocol.o
${CMAKE_SOURCE_DIR}/xdg-shell-protocol.o
- GLESv2
pthread
wayland-cursor
- /usr/lib/libEGL.so.1
wayland-client
- wayland-egl)
+ wayland-egl
+ ${EGL_LIBRARY})
endif()
file(CREATE_LINK linux-wallpaperengine wallengine SYMBOLIC)
From 0838ea2b0017d0102949e63d5752e234ef990966 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 14:23:39 +0100
Subject: [PATCH 12/43] check for wayland modules
---
CMakeLists.txt | 2 ++
1 file changed, 2 insertions(+)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 278307e..5d8cca7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -52,6 +52,8 @@ if (ENABLE_WAYLAND)
COMMAND ./protocols.sh
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+ pkg_check_modules(wayland-cursor wayland-protocols egl wayland-egl)
+
add_compile_definitions(ENABLE_WAYLAND)
set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
"src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h")
From 4e03774cf8c0c43f8a2a1ab8298e364e70af1902 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 21:17:45 +0100
Subject: [PATCH 13/43] use egl from cmake find opengl
---
CMakeLists.txt | 11 ++---------
1 file changed, 2 insertions(+), 9 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5d8cca7..8de531f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -307,18 +307,11 @@ target_link_libraries(linux-wallpaperengine
glfw)
if (ENABLE_WAYLAND)
- # finding EGL is a bit troublesome
- pkg_check_modules(PKG_EGL QUIET egl)
- find_library(EGL_LIBRARY NAMES EGL libEGL HINTS ${PKG_EGL_LIBRARY_DIRS})
- add_library(EGL::EGL UNKNOWN IMPORTED)
-
- target_link_libraries(linux-wallpaperengine ${CMAKE_SOURCE_DIR}/wlr-layer-shell-unstable-v1-protocol.o
- ${CMAKE_SOURCE_DIR}/xdg-shell-protocol.o
- pthread
+ target_link_libraries(linux-wallpaperengine pthread
wayland-cursor
wayland-client
wayland-egl
- ${EGL_LIBRARY})
+ ${OPENGL_egl_LIBRARY})
endif()
file(CREATE_LINK linux-wallpaperengine wallengine SYMBOLIC)
From c84ec9aeddb1ed794d30f83bed9d14db4c5247aa Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 21:27:47 +0100
Subject: [PATCH 14/43] Build protocols in cmake
---
CMakeLists.txt | 27 +++++++++++++++++++++++----
protocols.sh | 9 ---------
2 files changed, 23 insertions(+), 13 deletions(-)
delete mode 100755 protocols.sh
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8de531f..1a6f12d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,16 +47,35 @@ include_directories(
if (ENABLE_WAYLAND)
message(STATUS "Wayland support is enabled!")
+ pkg_check_modules(wayland-cursor wayland-protocols egl wayland-egl)
+
+ find_program(WaylandScanner NAMES wayland-scanner)
+ message(STATUS "Found WaylandScanner at ${WaylandScanner}")
+ execute_process(
+ COMMAND pkg-config --variable=pkgdatadir wayland-protocols
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+ OUTPUT_VARIABLE WAYLAND_PROTOCOLS_DIR
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+ message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
+
message(STATUS "Building protocols...")
execute_process(
- COMMAND ./protocols.sh
+ COMMAND ${WaylandScanner} client-header ${CMAKE_SOURCE_DIR}/protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.h
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+ execute_process(
+ COMMAND ${WaylandScanner} private-code ${CMAKE_SOURCE_DIR}/protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.c
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+ execute_process(
+ COMMAND ${WaylandScanner} client-header ${WAYLAND_PROTOCOLS_DIR}/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.h
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+ execute_process(
+ COMMAND ${WaylandScanner} private-code ${WAYLAND_PROTOCOLS_DIR}/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.c
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-
- pkg_check_modules(wayland-cursor wayland-protocols egl wayland-egl)
add_compile_definitions(ENABLE_WAYLAND)
set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
- "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h")
+ "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
+ "xdg-shell-protocol.c" "wlr-layer-shell-unstable-v1-protocol.c")
else()
set(WAYLAND_SOURCES "")
endif()
diff --git a/protocols.sh b/protocols.sh
deleted file mode 100755
index 605edf8..0000000
--- a/protocols.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-$(pkg-config --variable=wayland_scanner wayland-scanner) client-header protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.h
-$(pkg-config --variable=wayland_scanner wayland-scanner) private-code protocols/wlr-layer-shell-unstable-v1.xml wlr-layer-shell-unstable-v1-protocol.c
-$(pkg-config --variable=wayland_scanner wayland-scanner) client-header $(pkg-config --variable=pkgdatadir wayland-protocols)/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.h
-$(pkg-config --variable=wayland_scanner wayland-scanner) private-code $(pkg-config --variable=pkgdatadir wayland-protocols)/stable/xdg-shell/xdg-shell.xml xdg-shell-protocol.c
-
-cc -c -I. -std=c99 -lwayland-client -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wdeclaration-after-statement wlr-layer-shell-unstable-v1-protocol.c -o wlr-layer-shell-unstable-v1-protocol.o
-cc -c -I. -std=c99 -lwayland-client -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wdeclaration-after-statement xdg-shell-protocol.c -o xdg-shell-protocol.o
\ No newline at end of file
From ce2dc8395f02d11ad1a195badaf3e66298bede4c Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 22:02:47 +0100
Subject: [PATCH 15/43] move ls to a class
---
src/WallpaperEngine/Render/CRenderContext.cpp | 2 +
.../Render/Drivers/CVideoDriver.cpp | 2 +-
.../Render/Drivers/CVideoDriver.h | 3 +-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 145 ++++++++++--------
.../Render/Drivers/CWaylandOpenGLDriver.h | 42 ++---
5 files changed, 110 insertions(+), 84 deletions(-)
diff --git a/src/WallpaperEngine/Render/CRenderContext.cpp b/src/WallpaperEngine/Render/CRenderContext.cpp
index 22803f9..d740797 100644
--- a/src/WallpaperEngine/Render/CRenderContext.cpp
+++ b/src/WallpaperEngine/Render/CRenderContext.cpp
@@ -29,6 +29,8 @@ namespace WallpaperEngine::Render
for (const auto& cur : this->m_output->getViewports ())
{
+ this->m_driver.makeCurrent(cur.first);
+
#if !NDEBUG
std::string str = "Rendering to output " + cur.first;
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
index aa6e6db..df41c8e 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
@@ -6,6 +6,6 @@ void CVideoDriver::dispatchEventQueue() const {
// intentionally left blank
}
-void CVideoDriver::makeCurrent() const {
+void CVideoDriver::makeCurrent(const std::string& outputName) const {
// intentionally left blank
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
index 784873e..06fd057 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
@@ -2,6 +2,7 @@
#include
#include
+#include
namespace WallpaperEngine::Render::Drivers
{
@@ -55,6 +56,6 @@ namespace WallpaperEngine::Render::Drivers
/**
* Wayland only: make EGL current
*/
- void makeCurrent() const;
+ void makeCurrent(const std::string& outputName) const;
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 5090717..2b401f4 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -30,7 +30,8 @@ void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t
PMONITOR->size = {width, height};
PMONITOR->lsSize = {width, height};
- PMONITOR->driver->resizeLSSurfaceEGL();
+ if (PMONITOR->layerSurface.get())
+ PMONITOR->driver->resizeLSSurfaceEGL(PMONITOR->layerSurface.get());
if (PMONITOR->initialized)
PMONITOR->driver->wallpaperApplication->getOutput()->reset();
@@ -47,7 +48,8 @@ void scale(void* data, wl_output* wl_output, int32_t scale) {
PMONITOR->scale = scale;
- PMONITOR->driver->resizeLSSurfaceEGL();
+ if (PMONITOR->layerSurface.get())
+ PMONITOR->driver->resizeLSSurfaceEGL(PMONITOR->layerSurface.get());
if (PMONITOR->initialized)
PMONITOR->driver->wallpaperApplication->getOutput()->reset();
@@ -189,24 +191,24 @@ void CWaylandOpenGLDriver::finishEGL() {
static void handleLSConfigure(void *data, zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t w, uint32_t h) {
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
- PDRIVER->waylandContext.layerSurface.size = {w, h};
+ const auto PLS = (CLayerSurface*)data;
+ PLS->size = {w, h};
- PDRIVER->resizeLSSurfaceEGL();
+ PLS->output->driver->resizeLSSurfaceEGL(PLS);
zwlr_layer_surface_v1_ack_configure(surface, serial);
}
static void handleLSClosed(void *data, zwlr_layer_surface_v1 *surface) {
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
- PDRIVER->onLayerClose();
+ const auto PLS = (CLayerSurface*)data;
+ PLS->output->driver->onLayerClose(PLS);
}
-void CWaylandOpenGLDriver::onLayerClose() {
- eglDestroySurface(eglContext.display, waylandContext.layerSurface.eglSurface);
- wl_egl_window_destroy(waylandContext.layerSurface.eglWindow);
- zwlr_layer_surface_v1_destroy(waylandContext.layerSurface.layerSurface);
- wl_surface_destroy(waylandContext.layerSurface.surface);
+void CWaylandOpenGLDriver::onLayerClose(CLayerSurface* layerSurface) {
+ eglDestroySurface(eglContext.display, layerSurface->eglSurface);
+ wl_egl_window_destroy(layerSurface->eglWindow);
+ zwlr_layer_surface_v1_destroy(layerSurface->layerSurface);
+ wl_surface_destroy(layerSurface->surface);
sLog.exception("Compositor closed our LS!"); // todo: handle this?
}
@@ -216,16 +218,50 @@ const struct zwlr_layer_surface_v1_listener layerSurfaceListener = {
};
static void surfaceFrameCallback(void *data, struct wl_callback *cb, uint32_t time) {
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
+ const auto PLS = (CLayerSurface*)data;
wl_callback_destroy(cb);
- PDRIVER->waylandContext.layerSurface.frameCallback = nullptr;
- PDRIVER->wallpaperApplication->renderFrame();
+ PLS->frameCallback = nullptr;
+ PLS->output->driver->wallpaperApplication->renderFrame();
}
const struct wl_callback_listener frameListener = {
.done = surfaceFrameCallback
};
+CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOutput) {
+ surface = wl_compositor_create_surface(pDriver->waylandContext.compositor);
+ layerSurface = zwlr_layer_shell_v1_get_layer_surface(pDriver->waylandContext.layerShell, surface, output->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
+ output = pOutput;
+
+ if (!layerSurface)
+ sLog.exception("Failed to get a layer surface");
+
+ wl_region* region = wl_compositor_create_region(pDriver->waylandContext.compositor);
+
+ zwlr_layer_surface_v1_set_size(layerSurface, 0, 0);
+ zwlr_layer_surface_v1_set_anchor(layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
+ zwlr_layer_surface_v1_set_keyboard_interactivity(layerSurface, false);
+ zwlr_layer_surface_v1_add_listener(layerSurface, &layerSurfaceListener, this);
+ zwlr_layer_surface_v1_set_exclusive_zone(layerSurface, -1);
+ wl_surface_set_input_region(surface, region);
+ wl_surface_commit(surface);
+ wl_display_roundtrip(pDriver->waylandContext.display);
+
+ eglWindow = wl_egl_window_create(surface, size.x * output->scale, size.y * output->scale);
+ eglSurface = pDriver->eglContext.eglCreatePlatformWindowSurfaceEXT(pDriver->eglContext.display, pDriver->eglContext.config, eglWindow, nullptr);
+ output->lsSize = size;
+ wl_surface_commit(surface);
+ wl_display_roundtrip(pDriver->waylandContext.display);
+ wl_display_flush(pDriver->waylandContext.display);
+
+ if (eglMakeCurrent(pDriver->eglContext.display, eglSurface, eglSurface, pDriver->eglContext.context) == EGL_FALSE)
+ sLog.exception("Failed to make egl current");
+}
+
+CLayerSurface::~CLayerSurface() {
+ ;
+}
+
CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplicationContext& context, CWallpaperApplication* app) : m_frameCounter(0) {
wallpaperApplication = app;
waylandContext.display = wl_display_connect(NULL);
@@ -268,38 +304,8 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
sLog.exception("Failed to get a cursor surface");
initEGL();
-
- waylandContext.layerSurface.surface = wl_compositor_create_surface(waylandContext.compositor);
- waylandContext.layerSurface.layerSurface = zwlr_layer_shell_v1_get_layer_surface(waylandContext.layerShell, waylandContext.layerSurface.surface, outputToUse->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
- waylandContext.layerSurface.output = outputToUse;
- if (!waylandContext.layerSurface.layerSurface) {
- finishEGL();
- sLog.exception("Failed to get a layer surface");
- }
-
- wl_region* region = wl_compositor_create_region(waylandContext.compositor);
-
- zwlr_layer_surface_v1_set_size(waylandContext.layerSurface.layerSurface, 0, 0);
- zwlr_layer_surface_v1_set_anchor(waylandContext.layerSurface.layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
- zwlr_layer_surface_v1_set_keyboard_interactivity(waylandContext.layerSurface.layerSurface, false);
- zwlr_layer_surface_v1_add_listener(waylandContext.layerSurface.layerSurface, &layerSurfaceListener, this);
- zwlr_layer_surface_v1_set_exclusive_zone(waylandContext.layerSurface.layerSurface, -1);
- wl_surface_set_input_region(waylandContext.layerSurface.surface, region);
- wl_surface_commit(waylandContext.layerSurface.surface);
- wl_display_roundtrip(waylandContext.display);
-
- waylandContext.layerSurface.eglWindow = wl_egl_window_create(waylandContext.layerSurface.surface, waylandContext.layerSurface.size.x * outputToUse->scale, waylandContext.layerSurface.size.y * outputToUse->scale);
- waylandContext.layerSurface.eglSurface = eglContext.eglCreatePlatformWindowSurfaceEXT(eglContext.display, eglContext.config, waylandContext.layerSurface.eglWindow, nullptr);
- outputToUse->lsSize = waylandContext.layerSurface.size;
- wl_surface_commit(waylandContext.layerSurface.surface);
- wl_display_roundtrip(waylandContext.display);
- wl_display_flush(waylandContext.display);
-
- if (eglMakeCurrent(eglContext.display, waylandContext.layerSurface.eglSurface, waylandContext.layerSurface.eglSurface, eglContext.context) == EGL_FALSE) {
- finishEGL();
- sLog.exception("Failed to make egl current");
- }
+ const auto PLS = (outputToUse->layerSurface = std::make_unique(this, outputToUse)).get();
GLenum result = glewInit ();
@@ -346,29 +352,35 @@ void CWaylandOpenGLDriver::hideWindow () {
}
glm::ivec2 CWaylandOpenGLDriver::getFramebufferSize () const {
- return waylandContext.layerSurface.size;
+ return glm::ivec2{0, 0};
}
void CWaylandOpenGLDriver::swapBuffers () {
- waylandContext.layerSurface.frameCallback = wl_surface_frame(waylandContext.layerSurface.surface);
- wl_callback_add_listener(waylandContext.layerSurface.frameCallback, &frameListener, this);
- eglSwapBuffers(eglContext.display, waylandContext.layerSurface.eglSurface);
- wl_surface_set_buffer_scale(waylandContext.layerSurface.surface, waylandContext.layerSurface.output->scale);
- wl_surface_damage_buffer(waylandContext.layerSurface.surface, 0, 0, INT32_MAX, INT32_MAX);
- wl_surface_commit(waylandContext.layerSurface.surface);
+ for (auto& o : m_outputs) {
+ if (!o->layerSurface.get())
+ continue;
- m_frameCounter++;
+ eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context);
+ o->layerSurface->frameCallback = wl_surface_frame(o->layerSurface->surface);
+ wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, this);
+ eglSwapBuffers(eglContext.display, o->layerSurface->eglSurface);
+ wl_surface_set_buffer_scale(o->layerSurface->surface, o->scale);
+ wl_surface_damage_buffer(o->layerSurface->surface, 0, 0, INT32_MAX, INT32_MAX);
+ wl_surface_commit(o->layerSurface->surface);
+
+ m_frameCounter++;
+ }
}
-void CWaylandOpenGLDriver::resizeLSSurfaceEGL() {
- if (waylandContext.layerSurface.eglWindow) {
- waylandContext.layerSurface.output->lsSize = waylandContext.layerSurface.size;
+void CWaylandOpenGLDriver::resizeLSSurfaceEGL(CLayerSurface* layerSurface) {
+ if (layerSurface->eglWindow) {
+ layerSurface->output->lsSize = layerSurface->size;
- wl_egl_window_resize(waylandContext.layerSurface.eglWindow, waylandContext.layerSurface.size.x * waylandContext.layerSurface.output->scale, waylandContext.layerSurface.size.y * waylandContext.layerSurface.output->scale, 0, 0);
+ wl_egl_window_resize(layerSurface->eglWindow, layerSurface->size.x * layerSurface->output->scale, layerSurface->size.y * layerSurface->output->scale, 0, 0);
- if (waylandContext.layerSurface.frameCallback) {
- wl_callback_destroy(waylandContext.layerSurface.frameCallback);
- waylandContext.layerSurface.frameCallback = nullptr;
+ if (layerSurface->frameCallback) {
+ wl_callback_destroy(layerSurface->frameCallback);
+ layerSurface->frameCallback = nullptr;
}
wallpaperApplication->getOutput()->reset();
@@ -387,8 +399,13 @@ GLFWwindow* CWaylandOpenGLDriver::getWindow () {
#include
-void CWaylandOpenGLDriver::makeCurrent() const {
- if (eglMakeCurrent(eglContext.display, waylandContext.layerSurface.eglSurface, waylandContext.layerSurface.eglSurface, eglContext.context) == EGL_FALSE) {
- std::cerr << "Couldn't make egl current";
+void CWaylandOpenGLDriver::makeCurrent(const std::string& outputName) const {
+ for (auto& o : m_outputs) {
+ if (o->name != outputName)
+ continue;
+
+ if (eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context) == EGL_FALSE) {
+ std::cerr << "Couldn't make egl current";
+ }
}
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 6ec5bc4..0498720 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -25,6 +25,7 @@ namespace WallpaperEngine::Render::Drivers
{
using namespace WallpaperEngine::Application;
class CWaylandOpenGLDriver;
+ class CLayerSurface;
struct SWaylandOutput {
wl_output* output;
@@ -35,6 +36,21 @@ namespace WallpaperEngine::Render::Drivers
int scale = 1;
CWaylandOpenGLDriver* driver = nullptr;
bool initialized = false;
+ std::unique_ptr layerSurface;
+ };
+
+ class CLayerSurface {
+ public:
+ CLayerSurface(CWaylandOpenGLDriver*, SWaylandOutput*);
+ ~CLayerSurface();
+
+ wl_egl_window* eglWindow = nullptr;
+ EGLSurface eglSurface = nullptr;
+ wl_surface* surface = nullptr;
+ zwlr_layer_surface_v1* layerSurface = nullptr;
+ glm::ivec2 size;
+ wl_callback* frameCallback = nullptr;
+ SWaylandOutput* output = nullptr;
};
class CWaylandOpenGLDriver : public CVideoDriver
@@ -54,7 +70,7 @@ namespace WallpaperEngine::Render::Drivers
void swapBuffers () override;
uint32_t getFrameCounter () const override;
void dispatchEventQueue() const override;
- void makeCurrent() const;
+ void makeCurrent(const std::string& outputName) const;
GLFWwindow* getWindow ();
@@ -66,30 +82,15 @@ namespace WallpaperEngine::Render::Drivers
zwlr_layer_shell_v1* layerShell = nullptr;
wl_cursor* pointer = nullptr;
wl_surface* cursorSurface = nullptr;
-
- struct {
- wl_egl_window* eglWindow = nullptr;
- EGLSurface eglSurface = nullptr;
- wl_surface* surface = nullptr;
- zwlr_layer_surface_v1* layerSurface = nullptr;
- glm::ivec2 size;
- wl_callback* frameCallback = nullptr;
- SWaylandOutput* output = nullptr;
- } layerSurface;
} waylandContext;
- void onLayerClose();
- void resizeLSSurfaceEGL();
+ void onLayerClose(CLayerSurface*);
+ void resizeLSSurfaceEGL(CLayerSurface*);
std::vector> m_outputs;
CWallpaperApplication* wallpaperApplication;
- private:
-
- void initEGL();
- void finishEGL();
-
struct {
EGLDisplay display = nullptr;
EGLConfig config = nullptr;
@@ -97,6 +98,11 @@ namespace WallpaperEngine::Render::Drivers
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC eglCreatePlatformWindowSurfaceEXT = nullptr;
} eglContext;
+ private:
+
+ void initEGL();
+ void finishEGL();
+
uint32_t m_frameCounter;
std::chrono::high_resolution_clock::time_point renderStart = std::chrono::high_resolution_clock::now();
From ebc80b28e15c383f463e990b39eba8fd4da9aa05 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 22:07:59 +0100
Subject: [PATCH 16/43] fix minor oopsies with the ls move
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 2b401f4..f5ac50c 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -230,7 +230,7 @@ const struct wl_callback_listener frameListener = {
CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOutput) {
surface = wl_compositor_create_surface(pDriver->waylandContext.compositor);
- layerSurface = zwlr_layer_shell_v1_get_layer_surface(pDriver->waylandContext.layerShell, surface, output->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
+ layerSurface = zwlr_layer_shell_v1_get_layer_surface(pDriver->waylandContext.layerShell, surface, pOutput->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
output = pOutput;
if (!layerSurface)
@@ -362,7 +362,7 @@ void CWaylandOpenGLDriver::swapBuffers () {
eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context);
o->layerSurface->frameCallback = wl_surface_frame(o->layerSurface->surface);
- wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, this);
+ wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, o->layerSurface.get());
eglSwapBuffers(eglContext.display, o->layerSurface->eglSurface);
wl_surface_set_buffer_scale(o->layerSurface->surface, o->scale);
wl_surface_damage_buffer(o->layerSurface->surface, 0, 0, INT32_MAX, INT32_MAX);
From 75bb8cc1562321322d2d6a6535c9fd2a4d99168a Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 22:54:18 +0100
Subject: [PATCH 17/43] Mouse handling
---
src/WallpaperEngine/Input/CInputContext.cpp | 3 +-
src/WallpaperEngine/Input/CMouseInput.cpp | 12 ++-
src/WallpaperEngine/Input/CMouseInput.h | 13 ++-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 93 +++++++++++++++----
.../Render/Drivers/CWaylandOpenGLDriver.h | 9 +-
5 files changed, 105 insertions(+), 25 deletions(-)
diff --git a/src/WallpaperEngine/Input/CInputContext.cpp b/src/WallpaperEngine/Input/CInputContext.cpp
index f0b2126..e495357 100644
--- a/src/WallpaperEngine/Input/CInputContext.cpp
+++ b/src/WallpaperEngine/Input/CInputContext.cpp
@@ -12,9 +12,8 @@ CInputContext::CInputContext (CX11OpenGLDriver& videoDriver) :
#ifdef ENABLE_WAYLAND
CInputContext::CInputContext (CWaylandOpenGLDriver& videoDriver) :
- m_mouse (nullptr)
+ m_mouse (&videoDriver)
{
- // todo
}
#endif
diff --git a/src/WallpaperEngine/Input/CMouseInput.cpp b/src/WallpaperEngine/Input/CMouseInput.cpp
index e258f91..657efa1 100644
--- a/src/WallpaperEngine/Input/CMouseInput.cpp
+++ b/src/WallpaperEngine/Input/CMouseInput.cpp
@@ -5,10 +5,20 @@ using namespace WallpaperEngine::Input;
CMouseInput::CMouseInput (GLFWwindow* window) : position (), m_mousePosition (), m_window (window) {}
+CMouseInput::CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) {
+ waylandDriver = driver;
+}
+
void CMouseInput::update ()
{
- if (!m_window)
+ if (!m_window) {
+ if (!waylandDriver || !waylandDriver->lastLSInFocus)
+ return;
+
+ this->position = waylandDriver->lastLSInFocus->mousePos;
+
return;
+ }
// update current mouse position
glfwGetCursorPos (this->m_window, &this->m_mousePosition.x, &this->m_mousePosition.y);
diff --git a/src/WallpaperEngine/Input/CMouseInput.h b/src/WallpaperEngine/Input/CMouseInput.h
index 7909081..5b77d4b 100644
--- a/src/WallpaperEngine/Input/CMouseInput.h
+++ b/src/WallpaperEngine/Input/CMouseInput.h
@@ -1,8 +1,11 @@
#pragma once
+#include "../Render/Drivers/CWaylandOpenGLDriver.h"
+
#include
#include "GLFW/glfw3.h"
+
namespace WallpaperEngine::Input
{
/**
@@ -13,6 +16,9 @@ namespace WallpaperEngine::Input
public:
explicit CMouseInput(GLFWwindow* window);
+ explicit CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver);
+
+
/**
* Takes current mouse position and updates it
*/
@@ -27,12 +33,17 @@ namespace WallpaperEngine::Input
/**
* The GLFW window to get mouse position from
*/
- GLFWwindow* m_window;
+ GLFWwindow* m_window = nullptr;
/**
* The current mouse position
*/
glm::dvec2 m_mousePosition;
+
+ /**
+ * Wayland: Driver
+ */
+ WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* waylandDriver = nullptr;
};
}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index f5ac50c..d64ee1e 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -20,12 +20,54 @@ extern "C" {
using namespace WallpaperEngine::Render::Drivers;
-void geometry(void* data, wl_output* output, int32_t x, int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel, const char* make, const char* model,
+static void handlePointerEnter(void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
+ const auto PDRIVER = (CWaylandOpenGLDriver*)data;
+ const auto PLS = PDRIVER->surfaceToLS(surface);
+ PDRIVER->lastLSInFocus = PLS;
+ wl_surface_set_buffer_scale(PLS->cursorSurface, PLS->output->scale);
+ wl_surface_attach(PLS->cursorSurface, wl_cursor_image_get_buffer(PLS->pointer->images[0]), 0, 0);
+ wl_pointer_set_cursor(wl_pointer, serial, PLS->cursorSurface, PLS->pointer->images[0]->hotspot_x, PLS->pointer->images[0]->hotspot_y);
+ wl_surface_commit(PLS->cursorSurface);
+}
+
+static void handlePointerLeave(void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface) {
+ // ignored
+}
+
+static void handlePointerAxis(void* data, wl_pointer* wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {
+ // ignored
+}
+
+static void handlePointerMotion(void* data, struct wl_pointer* wl_pointer, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
+ auto x = wl_fixed_to_double(surface_x);
+ auto y = wl_fixed_to_double(surface_y);
+
+ const auto PDRIVER = (CWaylandOpenGLDriver*)data;
+ if (!PDRIVER->lastLSInFocus)
+ return;
+
+ PDRIVER->lastLSInFocus->mousePos = {x, y};
+}
+
+static void handlePointerButton(void* data, struct wl_pointer* wl_pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t button_state) {
+ // ignored
+}
+
+const struct wl_pointer_listener pointerListener = { .enter = handlePointerEnter, .leave = handlePointerLeave, .motion = handlePointerMotion, .button = handlePointerButton, .axis = handlePointerAxis };
+
+static void handleCapabilities(void* data, wl_seat* wl_seat, uint32_t capabilities) {
+ if (capabilities & WL_SEAT_CAPABILITY_POINTER)
+ wl_pointer_add_listener(wl_seat_get_pointer(wl_seat), &pointerListener, data);
+}
+
+const struct wl_seat_listener seatListener = { .capabilities = handleCapabilities };
+
+static void geometry(void* data, wl_output* output, int32_t x, int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel, const char* make, const char* model,
int32_t transform) {
// ignored
}
-void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
+static void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
const auto PMONITOR = (SWaylandOutput*)data;
PMONITOR->size = {width, height};
PMONITOR->lsSize = {width, height};
@@ -37,13 +79,13 @@ void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t
PMONITOR->driver->wallpaperApplication->getOutput()->reset();
}
-void done(void* data, wl_output* wl_output) {
+static void done(void* data, wl_output* wl_output) {
const auto PMONITOR = (SWaylandOutput*)data;
PMONITOR->initialized = true;
}
-void scale(void* data, wl_output* wl_output, int32_t scale) {
+static void scale(void* data, wl_output* wl_output, int32_t scale) {
const auto PMONITOR = (SWaylandOutput*)data;
PMONITOR->scale = scale;
@@ -55,14 +97,14 @@ void scale(void* data, wl_output* wl_output, int32_t scale) {
PMONITOR->driver->wallpaperApplication->getOutput()->reset();
}
-void name(void* data, wl_output* wl_output, const char* name) {
+static void name(void* data, wl_output* wl_output, const char* name) {
const auto PMONITOR = (SWaylandOutput*)data;
if (name)
PMONITOR->name = name;
}
-void description(void* data, wl_output* wl_output, const char* description) {
+static void description(void* data, wl_output* wl_output, const char* description) {
// ignored
}
@@ -85,6 +127,9 @@ static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name
wl_output_add_listener(POUTPUT->output, &outputListener, POUTPUT);
} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
PDRIVER->waylandContext.layerShell = (zwlr_layer_shell_v1*)wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
+ } else if (strcmp(interface, wl_seat_interface.name) == 0) {
+ PDRIVER->waylandContext.seat = (wl_seat*)wl_registry_bind(registry, name, &wl_seat_interface, 1);
+ wl_seat_add_listener(PDRIVER->waylandContext.seat, &seatListener, PDRIVER);
}
}
@@ -237,6 +282,7 @@ CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOut
sLog.exception("Failed to get a layer surface");
wl_region* region = wl_compositor_create_region(pDriver->waylandContext.compositor);
+ wl_region_add(region, 0, 0, INT32_MAX, INT32_MAX);
zwlr_layer_surface_v1_set_size(layerSurface, 0, 0);
zwlr_layer_surface_v1_set_anchor(layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
@@ -254,6 +300,18 @@ CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOut
wl_display_roundtrip(pDriver->waylandContext.display);
wl_display_flush(pDriver->waylandContext.display);
+ static const auto XCURSORSIZE = getenv("XCURSOR_SIZE") ? std::stoi(getenv("XCURSOR_SIZE")) : 24;
+ const auto PRCURSORTHEME = wl_cursor_theme_load(getenv("XCURSOR_THEME"), XCURSORSIZE * output->scale, pDriver->waylandContext.shm);
+
+ if (!PRCURSORTHEME)
+ sLog.exception("Failed to get a cursor theme");
+
+ pointer = wl_cursor_theme_get_cursor(PRCURSORTHEME, "left_ptr");
+ cursorSurface = wl_compositor_create_surface(pDriver->waylandContext.compositor);
+
+ if (!cursorSurface)
+ sLog.exception("Failed to get a cursor surface");
+
if (eglMakeCurrent(pDriver->eglContext.display, eglSurface, eglSurface, pDriver->eglContext.context) == EGL_FALSE)
sLog.exception("Failed to make egl current");
}
@@ -291,18 +349,6 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
outputToUse = m_outputs[0].get();
}
- const auto XCURSORSIZE = getenv("XCURSOR_SIZE") ? std::stoi(getenv("XCURSOR_SIZE")) : 24;
- const auto PRCURSORTHEME = wl_cursor_theme_load(NULL, XCURSORSIZE, waylandContext.shm);
-
- if (!PRCURSORTHEME)
- sLog.exception("Failed to get a cursor theme");
-
- waylandContext.pointer = wl_cursor_theme_get_cursor(PRCURSORTHEME, "left_ptr");
- waylandContext.cursorSurface = wl_compositor_create_surface(waylandContext.compositor);
-
- if (!waylandContext.cursorSurface)
- sLog.exception("Failed to get a cursor surface");
-
initEGL();
const auto PLS = (outputToUse->layerSurface = std::make_unique(this, outputToUse)).get();
@@ -408,4 +454,13 @@ void CWaylandOpenGLDriver::makeCurrent(const std::string& outputName) const {
std::cerr << "Couldn't make egl current";
}
}
-}
\ No newline at end of file
+}
+
+CLayerSurface* CWaylandOpenGLDriver::surfaceToLS(wl_surface* surface) {
+ for (auto& o : m_outputs) {
+ if (o->layerSurface->surface == surface)
+ return o->layerSurface.get();
+ }
+
+ return nullptr;
+}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 0498720..34c0278 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -51,6 +51,9 @@ namespace WallpaperEngine::Render::Drivers
glm::ivec2 size;
wl_callback* frameCallback = nullptr;
SWaylandOutput* output = nullptr;
+ glm::dvec2 mousePos = {0, 0};
+ wl_cursor* pointer = nullptr;
+ wl_surface* cursorSurface = nullptr;
};
class CWaylandOpenGLDriver : public CVideoDriver
@@ -80,12 +83,12 @@ namespace WallpaperEngine::Render::Drivers
wl_compositor* compositor = nullptr;
wl_shm* shm = nullptr;
zwlr_layer_shell_v1* layerShell = nullptr;
- wl_cursor* pointer = nullptr;
- wl_surface* cursorSurface = nullptr;
+ wl_seat* seat = nullptr;
} waylandContext;
void onLayerClose(CLayerSurface*);
void resizeLSSurfaceEGL(CLayerSurface*);
+ CLayerSurface* surfaceToLS(wl_surface*);
std::vector> m_outputs;
@@ -98,6 +101,8 @@ namespace WallpaperEngine::Render::Drivers
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC eglCreatePlatformWindowSurfaceEXT = nullptr;
} eglContext;
+ CLayerSurface* lastLSInFocus = nullptr;
+
private:
void initEGL();
From 5c8992bafc590b2cc7b1f61d5e8a1fbdade65901 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 23:04:32 +0100
Subject: [PATCH 18/43] better handling of monitors
---
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 19 ++++++++++---------
1 file changed, 10 insertions(+), 9 deletions(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index d64ee1e..80b79d1 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -336,22 +336,23 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
if (!waylandContext.compositor || !waylandContext.shm || !waylandContext.layerShell || m_outputs.empty())
sLog.exception("Failed to bind to required interfaces");
- SWaylandOutput* outputToUse = nullptr;
+ initEGL();
+
+ bool any = false;
for (auto& o : m_outputs) {
if (std::find_if(context.settings.general.screenBackgrounds.begin(), context.settings.general.screenBackgrounds.end(), [&] (const auto& e) { return e.first == o->name; }) != context.settings.general.screenBackgrounds.end()) {
- outputToUse = o.get();
- break;
+ o->layerSurface = std::make_unique(this, o.get());
+ any = true;
}
}
- if (!outputToUse) {
- sLog.debug("Failed to find any output, using first");
- outputToUse = m_outputs[0].get();
+ if (!any && std::find_if(context.settings.general.screenBackgrounds.begin(), context.settings.general.screenBackgrounds.end(), [&] (const auto& e) { return e.first == "auto"; }) != context.settings.general.screenBackgrounds.end()) {
+ m_outputs[0]->layerSurface = std::make_unique(this, m_outputs[0].get());
+ any = true;
}
- initEGL();
-
- const auto PLS = (outputToUse->layerSurface = std::make_unique(this, outputToUse)).get();
+ if (!any)
+ sLog.exception("No outputs could be initialized!");
GLenum result = glewInit ();
From bab0e7b65f790fca581ddf0167c1a636f682e0f3 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Thu, 20 Apr 2023 23:05:13 +0100
Subject: [PATCH 19/43] ifdef mouse wayland impl
---
src/WallpaperEngine/Input/CMouseInput.cpp | 6 ++++--
src/WallpaperEngine/Input/CMouseInput.h | 8 ++++++--
2 files changed, 10 insertions(+), 4 deletions(-)
diff --git a/src/WallpaperEngine/Input/CMouseInput.cpp b/src/WallpaperEngine/Input/CMouseInput.cpp
index 657efa1..4ac21a7 100644
--- a/src/WallpaperEngine/Input/CMouseInput.cpp
+++ b/src/WallpaperEngine/Input/CMouseInput.cpp
@@ -4,19 +4,21 @@
using namespace WallpaperEngine::Input;
CMouseInput::CMouseInput (GLFWwindow* window) : position (), m_mousePosition (), m_window (window) {}
-
+#ifdef ENABLE_WAYLAND
CMouseInput::CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) {
waylandDriver = driver;
}
+#endif
void CMouseInput::update ()
{
if (!m_window) {
+#ifdef ENABLE_WAYLAND
if (!waylandDriver || !waylandDriver->lastLSInFocus)
return;
this->position = waylandDriver->lastLSInFocus->mousePos;
-
+#endif
return;
}
diff --git a/src/WallpaperEngine/Input/CMouseInput.h b/src/WallpaperEngine/Input/CMouseInput.h
index 5b77d4b..3281116 100644
--- a/src/WallpaperEngine/Input/CMouseInput.h
+++ b/src/WallpaperEngine/Input/CMouseInput.h
@@ -1,6 +1,8 @@
#pragma once
+#ifdef ENABLE_WAYLAND
#include "../Render/Drivers/CWaylandOpenGLDriver.h"
+#endif
#include
#include "GLFW/glfw3.h"
@@ -15,9 +17,9 @@ namespace WallpaperEngine::Input
{
public:
explicit CMouseInput(GLFWwindow* window);
-
+#ifdef ENABLE_WAYLAND
explicit CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver);
-
+#endif
/**
* Takes current mouse position and updates it
@@ -40,10 +42,12 @@ namespace WallpaperEngine::Input
*/
glm::dvec2 m_mousePosition;
+#ifdef ENABLE_WAYLAND
/**
* Wayland: Driver
*/
WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* waylandDriver = nullptr;
+#endif
};
}
From c5b27cd3dcae4ca5fabf7d48997a4daf27c7e65b Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 00:17:55 +0100
Subject: [PATCH 20/43] split mouse input by backend
---
CMakeLists.txt | 4 +-
src/WallpaperEngine/Input/CGLFWMouseInput.cpp | 21 ++++++++++
src/WallpaperEngine/Input/CGLFWMouseInput.h | 41 +++++++++++++++++++
src/WallpaperEngine/Input/CInputContext.cpp | 16 +++++---
src/WallpaperEngine/Input/CInputContext.h | 2 +-
src/WallpaperEngine/Input/CMouseInput.cpp | 27 +-----------
src/WallpaperEngine/Input/CMouseInput.h | 27 +-----------
.../Input/CWaylandMouseInput.cpp | 20 +++++++++
.../Input/CWaylandMouseInput.h | 39 ++++++++++++++++++
src/WallpaperEngine/Render/CScene.cpp | 2 +-
10 files changed, 139 insertions(+), 60 deletions(-)
create mode 100644 src/WallpaperEngine/Input/CGLFWMouseInput.cpp
create mode 100644 src/WallpaperEngine/Input/CGLFWMouseInput.h
create mode 100644 src/WallpaperEngine/Input/CWaylandMouseInput.cpp
create mode 100644 src/WallpaperEngine/Input/CWaylandMouseInput.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1a6f12d..260532a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,7 +75,7 @@ if (ENABLE_WAYLAND)
add_compile_definitions(ENABLE_WAYLAND)
set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
"src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
- "xdg-shell-protocol.c" "wlr-layer-shell-unstable-v1-protocol.c")
+ "src/WallpaperEngine/Input/CWaylandMouseInput.cpp" "src/WallpaperEngine/Input/CWaylandMouseInput.h" "xdg-shell-protocol.c" "wlr-layer-shell-unstable-v1-protocol.c")
else()
set(WAYLAND_SOURCES "")
endif()
@@ -142,6 +142,8 @@ add_executable(
src/WallpaperEngine/Input/CInputContext.h
src/WallpaperEngine/Input/CMouseInput.cpp
src/WallpaperEngine/Input/CMouseInput.h
+ src/WallpaperEngine/Input/CGLFWMouseInput.cpp
+ src/WallpaperEngine/Input/CGLFWMouseInput.h
src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.cpp
diff --git a/src/WallpaperEngine/Input/CGLFWMouseInput.cpp b/src/WallpaperEngine/Input/CGLFWMouseInput.cpp
new file mode 100644
index 0000000..83b62cf
--- /dev/null
+++ b/src/WallpaperEngine/Input/CGLFWMouseInput.cpp
@@ -0,0 +1,21 @@
+#include
+#include "CGLFWMouseInput.h"
+
+using namespace WallpaperEngine::Input;
+
+CGLFWMouseInput::CGLFWMouseInput (GLFWwindow* window) : m_reportedPosition (), m_mousePosition (), m_window (window) {}
+
+void CGLFWMouseInput::update ()
+{
+ if (!m_window)
+ return;
+
+ // update current mouse position
+ glfwGetCursorPos (this->m_window, &this->m_mousePosition.x, &this->m_mousePosition.y);
+ // interpolate to the new position
+ this->m_reportedPosition = glm::mix (this->m_reportedPosition, this->m_mousePosition, 1.0);
+}
+
+glm::dvec2 CGLFWMouseInput::position() const {
+ return this->m_reportedPosition;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CGLFWMouseInput.h b/src/WallpaperEngine/Input/CGLFWMouseInput.h
new file mode 100644
index 0000000..90cb46b
--- /dev/null
+++ b/src/WallpaperEngine/Input/CGLFWMouseInput.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "CMouseInput.h"
+
+#include
+#include "GLFW/glfw3.h"
+
+namespace WallpaperEngine::Input
+{
+ /**
+ * Handles mouse input for the background
+ */
+ class CGLFWMouseInput : public CMouseInput
+ {
+ public:
+ explicit CGLFWMouseInput(GLFWwindow* window);
+
+ /**
+ * Takes current mouse position and updates it
+ */
+ void update () override;
+
+ /**
+ * The virtual pointer's position
+ */
+ glm::dvec2 position () const override;
+
+ private:
+ /**
+ * The GLFW window to get mouse position from
+ */
+ GLFWwindow* m_window = nullptr;
+
+ /**
+ * The current mouse position
+ */
+ glm::dvec2 m_mousePosition;
+ glm::dvec2 m_reportedPosition;
+ };
+}
+
diff --git a/src/WallpaperEngine/Input/CInputContext.cpp b/src/WallpaperEngine/Input/CInputContext.cpp
index e495357..22509d5 100644
--- a/src/WallpaperEngine/Input/CInputContext.cpp
+++ b/src/WallpaperEngine/Input/CInputContext.cpp
@@ -1,28 +1,32 @@
#include "CInputContext.h"
#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
+#include "WallpaperEngine/Input/CGLFWMouseInput.h"
+#ifdef ENABLE_WAYLAND
#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
+#include "WallpaperEngine/Input/CWaylandMouseInput.h"
+#endif
using namespace WallpaperEngine::Input;
using namespace WallpaperEngine::Render::Drivers;
-CInputContext::CInputContext (CX11OpenGLDriver& videoDriver) :
- m_mouse (videoDriver.getWindow ())
+CInputContext::CInputContext (CX11OpenGLDriver& videoDriver)
{
+ m_mouse = std::make_unique(videoDriver.getWindow());
}
#ifdef ENABLE_WAYLAND
-CInputContext::CInputContext (CWaylandOpenGLDriver& videoDriver) :
- m_mouse (&videoDriver)
+CInputContext::CInputContext (CWaylandOpenGLDriver& videoDriver)
{
+ m_mouse = std::make_unique(&videoDriver);
}
#endif
void CInputContext::update ()
{
- this->m_mouse.update ();
+ this->m_mouse->update ();
}
const CMouseInput& CInputContext::getMouseInput () const
{
- return this->m_mouse;
+ return *this->m_mouse.get();
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CInputContext.h b/src/WallpaperEngine/Input/CInputContext.h
index 4a74e03..3d51423 100644
--- a/src/WallpaperEngine/Input/CInputContext.h
+++ b/src/WallpaperEngine/Input/CInputContext.h
@@ -25,6 +25,6 @@ namespace WallpaperEngine::Input
[[nodiscard]] const CMouseInput& getMouseInput () const;
private:
- CMouseInput m_mouse;
+ std::unique_ptr m_mouse;
};
}
diff --git a/src/WallpaperEngine/Input/CMouseInput.cpp b/src/WallpaperEngine/Input/CMouseInput.cpp
index 4ac21a7..2998032 100644
--- a/src/WallpaperEngine/Input/CMouseInput.cpp
+++ b/src/WallpaperEngine/Input/CMouseInput.cpp
@@ -1,29 +1,4 @@
#include
#include "CMouseInput.h"
-using namespace WallpaperEngine::Input;
-
-CMouseInput::CMouseInput (GLFWwindow* window) : position (), m_mousePosition (), m_window (window) {}
-#ifdef ENABLE_WAYLAND
-CMouseInput::CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) {
- waylandDriver = driver;
-}
-#endif
-
-void CMouseInput::update ()
-{
- if (!m_window) {
-#ifdef ENABLE_WAYLAND
- if (!waylandDriver || !waylandDriver->lastLSInFocus)
- return;
-
- this->position = waylandDriver->lastLSInFocus->mousePos;
-#endif
- return;
- }
-
- // update current mouse position
- glfwGetCursorPos (this->m_window, &this->m_mousePosition.x, &this->m_mousePosition.y);
- // interpolate to the new position
- this->position = glm::mix (this->position, this->m_mousePosition, 1.0);
-}
\ No newline at end of file
+using namespace WallpaperEngine::Input;
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CMouseInput.h b/src/WallpaperEngine/Input/CMouseInput.h
index 3281116..2b07d4b 100644
--- a/src/WallpaperEngine/Input/CMouseInput.h
+++ b/src/WallpaperEngine/Input/CMouseInput.h
@@ -16,38 +16,15 @@ namespace WallpaperEngine::Input
class CMouseInput
{
public:
- explicit CMouseInput(GLFWwindow* window);
-#ifdef ENABLE_WAYLAND
- explicit CMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver);
-#endif
-
/**
* Takes current mouse position and updates it
*/
- void update ();
+ virtual void update () = 0;
/**
* The virtual pointer's position
*/
- glm::dvec2 position;
-
- private:
- /**
- * The GLFW window to get mouse position from
- */
- GLFWwindow* m_window = nullptr;
-
- /**
- * The current mouse position
- */
- glm::dvec2 m_mousePosition;
-
-#ifdef ENABLE_WAYLAND
- /**
- * Wayland: Driver
- */
- WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* waylandDriver = nullptr;
-#endif
+ virtual glm::dvec2 position () const = 0;
};
}
diff --git a/src/WallpaperEngine/Input/CWaylandMouseInput.cpp b/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
new file mode 100644
index 0000000..85a520c
--- /dev/null
+++ b/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
@@ -0,0 +1,20 @@
+#include
+#include "CWaylandMouseInput.h"
+
+using namespace WallpaperEngine::Input;
+
+CWaylandMouseInput::CWaylandMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) {
+ waylandDriver = driver;
+}
+
+void CWaylandMouseInput::update ()
+{
+ ;
+}
+
+glm::dvec2 CWaylandMouseInput::position() const {
+ if (!waylandDriver || !waylandDriver->lastLSInFocus)
+ return {0, 0};
+
+ return waylandDriver->lastLSInFocus->mousePos;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CWaylandMouseInput.h b/src/WallpaperEngine/Input/CWaylandMouseInput.h
new file mode 100644
index 0000000..50ace5a
--- /dev/null
+++ b/src/WallpaperEngine/Input/CWaylandMouseInput.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "CMouseInput.h"
+#include "../Render/Drivers/CWaylandOpenGLDriver.h"
+
+#include
+#include "GLFW/glfw3.h"
+
+
+namespace WallpaperEngine::Input
+{
+ /**
+ * Handles mouse input for the background
+ */
+ class CWaylandMouseInput : public CMouseInput
+ {
+ public:
+ explicit CWaylandMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver);
+
+ /**
+ * Takes current mouse position and updates it
+ */
+ void update () override;
+
+ /**
+ * The virtual pointer's position
+ */
+ glm::dvec2 position () const override;
+
+ private:
+ /**
+ * Wayland: Driver
+ */
+ WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* waylandDriver = nullptr;
+
+ glm::dvec2 pos;
+ };
+}
+
diff --git a/src/WallpaperEngine/Render/CScene.cpp b/src/WallpaperEngine/Render/CScene.cpp
index c345ede..3f8f80c 100644
--- a/src/WallpaperEngine/Render/CScene.cpp
+++ b/src/WallpaperEngine/Render/CScene.cpp
@@ -248,7 +248,7 @@ void CScene::renderFrame (glm::ivec4 viewport)
void CScene::updateMouse (glm::ivec4 viewport)
{
// update virtual mouse position first
- glm::dvec2 position = this->getContext ().getInputContext ().getMouseInput ().position;
+ glm::dvec2 position = this->getContext ().getInputContext ().getMouseInput ().position();
// TODO: PROPERLY TRANSLATE THESE TO WHAT'S VISIBLE ON SCREEN (FOR BACKGROUNDS THAT DO NOT EXACTLY FIT ON SCREEN)
// rollover the position to the last
From ee3f000ab14911accf729baeef5bfda0b03b8ec1 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 01:45:01 +0100
Subject: [PATCH 21/43] multimon improvements part 1
---
src/WallpaperEngine/Render/CRenderContext.cpp | 9 +++-
.../Render/Drivers/CVideoDriver.cpp | 12 +++++
.../Render/Drivers/CVideoDriver.h | 14 ++++-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 51 ++++++++++++++-----
.../Render/Drivers/CWaylandOpenGLDriver.h | 7 ++-
5 files changed, 76 insertions(+), 17 deletions(-)
diff --git a/src/WallpaperEngine/Render/CRenderContext.cpp b/src/WallpaperEngine/Render/CRenderContext.cpp
index d740797..c871c90 100644
--- a/src/WallpaperEngine/Render/CRenderContext.cpp
+++ b/src/WallpaperEngine/Render/CRenderContext.cpp
@@ -29,6 +29,9 @@ namespace WallpaperEngine::Render
for (const auto& cur : this->m_output->getViewports ())
{
+ if (!this->m_driver.shouldRenderOutput(cur.first))
+ continue;
+
this->m_driver.makeCurrent(cur.first);
#if !NDEBUG
@@ -53,6 +56,9 @@ namespace WallpaperEngine::Render
#if !NDEBUG
glPopDebugGroup ();
#endif /* DEBUG */
+
+ if (this->m_driver.requiresSeparateFlips())
+ this->m_driver.swapOutputBuffer(cur.first);
}
// read the full texture into the image
@@ -65,7 +71,8 @@ namespace WallpaperEngine::Render
// update the output with the given image
this->m_output->updateRender ();
// finally swap buffers
- this->m_driver.swapBuffers ();
+ if (!this->m_driver.requiresSeparateFlips())
+ this->m_driver.swapBuffers ();
}
void CRenderContext::setDefaultWallpaper (CWallpaper* wallpaper)
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
index df41c8e..268091f 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
@@ -8,4 +8,16 @@ void CVideoDriver::dispatchEventQueue() const {
void CVideoDriver::makeCurrent(const std::string& outputName) const {
// intentionally left blank
+}
+
+bool CVideoDriver::shouldRenderOutput(const std::string& outputName) const {
+ return true;
+}
+
+bool CVideoDriver::requiresSeparateFlips() const {
+ return false;
+}
+
+void CVideoDriver::swapOutputBuffer(const std::string& outputName) {
+ // intentionally left blank
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
index 06fd057..a5e0c64 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
@@ -56,6 +56,18 @@ namespace WallpaperEngine::Render::Drivers
/**
* Wayland only: make EGL current
*/
- void makeCurrent(const std::string& outputName) const;
+ virtual void makeCurrent(const std::string& outputName) const;
+ /**
+ * Wayland only: whether an output should be rendered
+ */
+ virtual bool shouldRenderOutput(const std::string& outputName) const;
+ /**
+ * Wayland only: whether requires separate buffer flips on monitors
+ */
+ virtual bool requiresSeparateFlips() const;
+ /**
+ * Wayland only: flip output
+ */
+ virtual void swapOutputBuffer(const std::string& outputName);
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 80b79d1..578a0ac 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -266,7 +266,9 @@ static void surfaceFrameCallback(void *data, struct wl_callback *cb, uint32_t ti
const auto PLS = (CLayerSurface*)data;
wl_callback_destroy(cb);
PLS->frameCallback = nullptr;
+ PLS->output->rendering = true;
PLS->output->driver->wallpaperApplication->renderFrame();
+ PLS->output->rendering = false;
}
const struct wl_callback_listener frameListener = {
@@ -403,20 +405,7 @@ glm::ivec2 CWaylandOpenGLDriver::getFramebufferSize () const {
}
void CWaylandOpenGLDriver::swapBuffers () {
- for (auto& o : m_outputs) {
- if (!o->layerSurface.get())
- continue;
-
- eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context);
- o->layerSurface->frameCallback = wl_surface_frame(o->layerSurface->surface);
- wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, o->layerSurface.get());
- eglSwapBuffers(eglContext.display, o->layerSurface->eglSurface);
- wl_surface_set_buffer_scale(o->layerSurface->surface, o->scale);
- wl_surface_damage_buffer(o->layerSurface->surface, 0, 0, INT32_MAX, INT32_MAX);
- wl_surface_commit(o->layerSurface->surface);
-
- m_frameCounter++;
- }
+ ;
}
void CWaylandOpenGLDriver::resizeLSSurfaceEGL(CLayerSurface* layerSurface) {
@@ -432,7 +421,9 @@ void CWaylandOpenGLDriver::resizeLSSurfaceEGL(CLayerSurface* layerSurface) {
wallpaperApplication->getOutput()->reset();
+ layerSurface->output->rendering = true;
wallpaperApplication->renderFrame();
+ layerSurface->output->rendering = false;
}
}
@@ -465,3 +456,35 @@ CLayerSurface* CWaylandOpenGLDriver::surfaceToLS(wl_surface* surface) {
return nullptr;
}
+
+bool CWaylandOpenGLDriver::shouldRenderOutput(const std::string& outputName) const {
+ for (auto& o : m_outputs) {
+ if (o->name == outputName)
+ return o->layerSurface.get() && (o->rendering || !o->layerSurface->callbackInitialized);
+ }
+
+ return false;
+}
+
+bool CWaylandOpenGLDriver::requiresSeparateFlips() const {
+ return true;
+}
+
+void CWaylandOpenGLDriver::swapOutputBuffer(const std::string& outputName) {
+ for (auto& o : m_outputs) {
+ if (o->name != outputName)
+ continue;
+
+ o->layerSurface->callbackInitialized = true;
+
+ eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context);
+ o->layerSurface->frameCallback = wl_surface_frame(o->layerSurface->surface);
+ wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, o->layerSurface.get());
+ eglSwapBuffers(eglContext.display, o->layerSurface->eglSurface);
+ wl_surface_set_buffer_scale(o->layerSurface->surface, o->scale);
+ wl_surface_damage_buffer(o->layerSurface->surface, 0, 0, INT32_MAX, INT32_MAX);
+ wl_surface_commit(o->layerSurface->surface);
+
+ m_frameCounter++;
+ }
+}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 34c0278..8eb02b0 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -37,6 +37,7 @@ namespace WallpaperEngine::Render::Drivers
CWaylandOpenGLDriver* driver = nullptr;
bool initialized = false;
std::unique_ptr layerSurface;
+ bool rendering = false;
};
class CLayerSurface {
@@ -54,6 +55,7 @@ namespace WallpaperEngine::Render::Drivers
glm::dvec2 mousePos = {0, 0};
wl_cursor* pointer = nullptr;
wl_surface* cursorSurface = nullptr;
+ bool callbackInitialized = false;
};
class CWaylandOpenGLDriver : public CVideoDriver
@@ -73,7 +75,10 @@ namespace WallpaperEngine::Render::Drivers
void swapBuffers () override;
uint32_t getFrameCounter () const override;
void dispatchEventQueue() const override;
- void makeCurrent(const std::string& outputName) const;
+ void makeCurrent(const std::string& outputName) const override;
+ bool shouldRenderOutput(const std::string& outputName) const override;
+ bool requiresSeparateFlips() const override;
+ void swapOutputBuffer(const std::string& outputName) override;
GLFWwindow* getWindow ();
From 997f780f4c3ecade29146fe73299f4584d13d52f Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 02:07:27 +0100
Subject: [PATCH 22/43] minor improvements to pointer handling
---
src/WallpaperEngine/Input/CWaylandMouseInput.cpp | 9 ++++++++-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 2 +-
2 files changed, 9 insertions(+), 2 deletions(-)
diff --git a/src/WallpaperEngine/Input/CWaylandMouseInput.cpp b/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
index 85a520c..7e1011d 100644
--- a/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
+++ b/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
@@ -16,5 +16,12 @@ glm::dvec2 CWaylandMouseInput::position() const {
if (!waylandDriver || !waylandDriver->lastLSInFocus)
return {0, 0};
- return waylandDriver->lastLSInFocus->mousePos;
+ for (auto& o : waylandDriver->m_outputs) {
+ if (!o->rendering)
+ continue;
+
+ return o->layerSurface.get() == waylandDriver->lastLSInFocus ? o->layerSurface->mousePos : glm::dvec2{-1337, -1337};
+ }
+
+ return {0, 0};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 578a0ac..13369d9 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -46,7 +46,7 @@ static void handlePointerMotion(void* data, struct wl_pointer* wl_pointer, uint3
if (!PDRIVER->lastLSInFocus)
return;
- PDRIVER->lastLSInFocus->mousePos = {x, y};
+ PDRIVER->lastLSInFocus->mousePos = {x * PDRIVER->lastLSInFocus->output->scale, y * PDRIVER->lastLSInFocus->output->scale};
}
static void handlePointerButton(void* data, struct wl_pointer* wl_pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t button_state) {
From 997b9b8ec4637e132df502809e067f04cd5a0df8 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 15:10:20 +0100
Subject: [PATCH 23/43] fix videos
---
src/WallpaperEngine/Render/CVideo.cpp | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/src/WallpaperEngine/Render/CVideo.cpp b/src/WallpaperEngine/Render/CVideo.cpp
index d3fe4a6..274664f 100644
--- a/src/WallpaperEngine/Render/CVideo.cpp
+++ b/src/WallpaperEngine/Render/CVideo.cpp
@@ -6,11 +6,18 @@
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
-void* get_proc_address (void* ctx, const char* name)
+void* get_proc_address_glfw (void* ctx, const char* name)
{
return reinterpret_cast (glfwGetProcAddress (name));
}
+#ifdef ENABLE_WAYLAND
+#include
+void* get_proc_address_wayland(void* ctx, const char* name) {
+ return reinterpret_cast (eglGetProcAddress (name));
+}
+#endif
+
CVideo::CVideo (Core::CVideo* video, CRenderContext& context, CAudioContext& audioContext) :
CWallpaper (video, Type, context, audioContext),
m_width (16),
@@ -40,7 +47,7 @@ CVideo::CVideo (Core::CVideo* video, CRenderContext& context, CAudioContext& aud
mpv_set_option (this->m_mpv, "volume", MPV_FORMAT_DOUBLE, &volume);
// initialize gl context for mpv
- mpv_opengl_init_params gl_init_params {get_proc_address, nullptr};
+ mpv_opengl_init_params gl_init_params {this->getContext().getDriver().getWindowHandle() ? get_proc_address_glfw : get_proc_address_wayland, nullptr};
mpv_render_param params[] {
{MPV_RENDER_PARAM_API_TYPE, const_cast (MPV_RENDER_API_TYPE_OPENGL)},
{MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &gl_init_params},
From 87b765e618f04701faf8792dd28d872184276b31 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 15:23:10 +0100
Subject: [PATCH 24/43] properly adhere to fps limits
---
.../Application/CWallpaperApplication.cpp | 28 +++++++++----------
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 9 ++++++
.../Render/Drivers/CWaylandOpenGLDriver.h | 1 +
3 files changed, 24 insertions(+), 14 deletions(-)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index 38119b7..a5a7e78 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -334,7 +334,16 @@ namespace WallpaperEngine::Application
} else {
#endif
while (!videoDriver->closeRequested () && this->m_context.state.general.keepRunning) {
+ static float startTime, endTime, minimumTime = 1.0f / this->m_context.settings.render.maximumFPS;
+ // get the start time of the frame
+ startTime = videoDriver->getRenderTime ();
renderFrame();
+ // get the end time of the frame
+ endTime = videoDriver->getRenderTime ();
+
+ // ensure the frame time is correct to not overrun FPS
+ if ((endTime - startTime) < minimumTime)
+ usleep ((minimumTime - (endTime - startTime)) * CLOCKS_PER_SEC);
}
#ifdef ENABLE_WAYLAND
}
@@ -349,8 +358,6 @@ namespace WallpaperEngine::Application
}
void CWallpaperApplication::renderFrame() {
-
- static float startTime, endTime, minimumTime = 1.0f / this->m_context.settings.render.maximumFPS;
static time_t seconds;
static struct tm* timeinfo;
@@ -359,24 +366,17 @@ namespace WallpaperEngine::Application
timeinfo = localtime(&seconds);
g_Daytime = ((timeinfo->tm_hour * 60) + timeinfo->tm_min) / (24.0 * 60.0);
- // update audio recorder
- audioDriver->update ();
- // update input information
- inputContext->update ();
// keep track of the previous frame's time
g_TimeLast = g_Time;
// calculate the current time value
g_Time = videoDriver->getRenderTime ();
- // get the start time of the frame
- startTime = g_Time;
+
+ // update audio recorder
+ audioDriver->update ();
+ // update input information
+ inputContext->update ();
// render the scene
context->render ();
- // get the end time of the frame
- endTime = videoDriver->getRenderTime ();
-
- // ensure the frame time is correct to not overrun FPS
- if ((endTime - startTime) < minimumTime)
- usleep ((minimumTime - (endTime - startTime)) * CLOCKS_PER_SEC);
if (!this->m_context.settings.screenshot.take || videoDriver->getFrameCounter () != 5)
return;
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 13369d9..2cfe536 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -269,6 +269,13 @@ static void surfaceFrameCallback(void *data, struct wl_callback *cb, uint32_t ti
PLS->output->rendering = true;
PLS->output->driver->wallpaperApplication->renderFrame();
PLS->output->rendering = false;
+
+ float renderTime = PLS->output->driver->getRenderTime();
+
+ if ((renderTime - PLS->lastTime) < PLS->minimumTime)
+ usleep ((PLS->minimumTime - (renderTime - PLS->lastTime)) * CLOCKS_PER_SEC);
+
+ PLS->lastTime = renderTime;
}
const struct wl_callback_listener frameListener = {
@@ -316,6 +323,8 @@ CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOut
if (eglMakeCurrent(pDriver->eglContext.display, eglSurface, eglSurface, pDriver->eglContext.context) == EGL_FALSE)
sLog.exception("Failed to make egl current");
+
+ minimumTime = 1.0f / pDriver->wallpaperApplication->getContext().settings.render.maximumFPS;
}
CLayerSurface::~CLayerSurface() {
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 8eb02b0..2ffb1ca 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -56,6 +56,7 @@ namespace WallpaperEngine::Render::Drivers
wl_cursor* pointer = nullptr;
wl_surface* cursorSurface = nullptr;
bool callbackInitialized = false;
+ float lastTime, minimumTime;
};
class CWaylandOpenGLDriver : public CVideoDriver
From ea158959162eabb7ff34cc918becbf9fc63f6231 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 15:25:13 +0100
Subject: [PATCH 25/43] remove newline after private
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 2ffb1ca..931bc03 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -110,7 +110,6 @@ namespace WallpaperEngine::Render::Drivers
CLayerSurface* lastLSInFocus = nullptr;
private:
-
void initEGL();
void finishEGL();
From a782fdd1f290840b30e5d1b2f5f8d0657708afb8 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 16:11:48 +0100
Subject: [PATCH 26/43] fix crash on 1 wp
---
src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 2cfe536..516e4b4 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -459,6 +459,9 @@ void CWaylandOpenGLDriver::makeCurrent(const std::string& outputName) const {
CLayerSurface* CWaylandOpenGLDriver::surfaceToLS(wl_surface* surface) {
for (auto& o : m_outputs) {
+ if (!o->layerSurface.get())
+ continue;
+
if (o->layerSurface->surface == surface)
return o->layerSurface.get();
}
From 8684c8d60f6203b074444d223e5d7d74bed97589 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 17:33:19 +0100
Subject: [PATCH 27/43] calculate full size more reasonably
---
src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index d4f16b8..726a291 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -22,7 +22,7 @@ void CWaylandOutput::updateViewports() {
for (auto& o : PDRIVER->m_outputs) {
m_viewports[o->name] = {{0, 0, o->lsSize.x * o->scale, o->lsSize.y * o->scale}, o->name};
- fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, o->lsSize.y * o->scale};
+ fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, 0};
}
m_fullWidth = fullw.x;
From 280ef714489d45a9de0e63ed02b3b07f81ec0181 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 17:33:57 +0100
Subject: [PATCH 28/43] calculate full size more reasonably part 2
---
src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index 726a291..b91de73 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -23,6 +23,8 @@ void CWaylandOutput::updateViewports() {
m_viewports[o->name] = {{0, 0, o->lsSize.x * o->scale, o->lsSize.y * o->scale}, o->name};
fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, 0};
+ if (o->lsSize.y > fullw.y)
+ fullw.y = o->lsSize.y;
}
m_fullWidth = fullw.x;
From 723be5af7094ce86d05e16d7bdecf04f14dddf72 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 17:59:13 +0100
Subject: [PATCH 29/43] ignore empty viewports in geom
---
src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index b91de73..a55ed71 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -20,6 +20,9 @@ void CWaylandOutput::updateViewports() {
const auto PDRIVER = (CWaylandOpenGLDriver*)&m_driver;
glm::ivec2 fullw = {0,0};
for (auto& o : PDRIVER->m_outputs) {
+ if (!o->layerSurface.get())
+ continue;
+
m_viewports[o->name] = {{0, 0, o->lsSize.x * o->scale, o->lsSize.y * o->scale}, o->name};
fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, 0};
From 031ed01c4211c7e628e6849b48a9fcd53a7fe100 Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 18:03:08 +0100
Subject: [PATCH 30/43] properly flip screenshots
---
src/WallpaperEngine/Application/CWallpaperApplication.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index a5a7e78..e7ff1ba 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -248,7 +248,7 @@ namespace WallpaperEngine::Application
color.rgbBlue = *pixel++;
// set the pixel in the destination
- FreeImage_SetPixelColor (bitmap, x, y, &color);
+ FreeImage_SetPixelColor (bitmap, x, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
}
}
From 2b7367662f3e8076fb11c9e0849f817ef5f4d50d Mon Sep 17 00:00:00 2001
From: vaxerski <43317083+vaxerski@users.noreply.github.com>
Date: Fri, 21 Apr 2023 18:24:19 +0100
Subject: [PATCH 31/43] Fix multi-bg screenshots
---
.../Application/CWallpaperApplication.cpp | 84 ++++++++++++++-----
.../Application/CWallpaperApplication.h | 2 +
.../Render/Drivers/CVideoDriver.cpp | 4 +
.../Render/Drivers/CVideoDriver.h | 4 +
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 9 ++
.../Render/Drivers/CWaylandOpenGLDriver.h | 1 +
6 files changed, 83 insertions(+), 21 deletions(-)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index e7ff1ba..d28420d 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -235,30 +235,71 @@ namespace WallpaperEngine::Application
glReadPixels (0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
// build the output file with FreeImage
- FIBITMAP* bitmap = FreeImage_Allocate (width, height, 24);
+ static FIBITMAP* bitmap = FreeImage_Allocate (width, height, 24);
RGBQUAD color;
- // now get access to the pixels
- for (int y = height; y > 0; y--)
- {
- for (int x = 0; x < width; x++)
+ if (!context.getDriver().requiresSeparateFlips()) {
+ // now get access to the pixels
+ for (int y = height; y > 0; y--)
{
- color.rgbRed = *pixel++;
- color.rgbGreen = *pixel++;
- color.rgbBlue = *pixel++;
+ for (int x = 0; x < width; x++)
+ {
+ color.rgbRed = *pixel++;
+ color.rgbGreen = *pixel++;
+ color.rgbBlue = *pixel++;
- // set the pixel in the destination
- FreeImage_SetPixelColor (bitmap, x, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
+ // set the pixel in the destination
+ FreeImage_SetPixelColor (bitmap, x, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
+ }
+ }
+
+ // finally save the file
+ FreeImage_Save (format, bitmap, filename.c_str (), 0);
+
+ // free all the used memory
+ delete[] buffer;
+
+ FreeImage_Unload (bitmap);
+
+ const_cast(&context.getApp())->getContext().settings.screenshot.take = false;
+ } else {
+ const auto RENDERING = context.getDriver().getCurrentlyRendered();
+ static int xoff = 0;
+
+ for (int y = height; y > 0; y--)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ color.rgbRed = *pixel++;
+ color.rgbGreen = *pixel++;
+ color.rgbBlue = *pixel++;
+
+ // set the pixel in the destination
+ FreeImage_SetPixelColor (bitmap, x + xoff, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
+ }
+ }
+
+ for (auto& [name, data] : context.getOutput()->getViewports()) {
+ if (name == RENDERING) {
+ xoff += data.viewport.z;
+ break;
+ }
+ }
+
+ const_cast(&context.getApp())->screenshotOutputsDone.push_back(RENDERING);
+
+ if (const_cast(&context.getApp())->screenshotOutputsDone.size() >= context.getOutput()->getViewports().size()) {
+ // finally save the file
+ FreeImage_Save (format, bitmap, filename.c_str (), 0);
+
+ // free all the used memory
+ delete[] buffer;
+
+ FreeImage_Unload (bitmap);
+
+ const_cast(&context.getApp())->getContext().settings.screenshot.take = false;
}
}
-
- // finally save the file
- FreeImage_Save (format, bitmap, filename.c_str (), 0);
-
- // free all the used memory
- delete[] buffer;
-
- FreeImage_Unload (bitmap);
}
void CWallpaperApplication::show ()
@@ -378,12 +419,13 @@ namespace WallpaperEngine::Application
// render the scene
context->render ();
- if (!this->m_context.settings.screenshot.take || videoDriver->getFrameCounter () != 5)
+ if (!this->m_context.settings.screenshot.take || videoDriver->getFrameCounter () < 5)
+ return;
+
+ if (std::find_if(screenshotOutputsDone.begin(), screenshotOutputsDone.end(), [&] (const auto& other) { return other == context->getDriver().getCurrentlyRendered(); }) != screenshotOutputsDone.end())
return;
this->takeScreenshot (*context, this->m_context.settings.screenshot.path, this->m_context.settings.screenshot.format);
- // disable screenshot just in case the counter overflows
- this->m_context.settings.screenshot.take = false;
}
void CWallpaperApplication::signal (int signal)
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.h b/src/WallpaperEngine/Application/CWallpaperApplication.h
index 454cab0..2b401db 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.h
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.h
@@ -123,5 +123,7 @@ namespace WallpaperEngine::Application
std::unique_ptr audioDriver;
std::unique_ptr context;
std::unique_ptr audioContext;
+
+ std::vector screenshotOutputsDone;
};
}
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
index 268091f..b3e0cd3 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
@@ -20,4 +20,8 @@ bool CVideoDriver::requiresSeparateFlips() const {
void CVideoDriver::swapOutputBuffer(const std::string& outputName) {
// intentionally left blank
+}
+
+std::string CVideoDriver::getCurrentlyRendered() const {
+ return "";
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
index a5e0c64..6336930 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
@@ -69,5 +69,9 @@ namespace WallpaperEngine::Render::Drivers
* Wayland only: flip output
*/
virtual void swapOutputBuffer(const std::string& outputName);
+ /**
+ * Wayland only: gets currently rendered output
+ */
+ virtual std::string getCurrentlyRendered() const;
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index 516e4b4..f41d168 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -500,3 +500,12 @@ void CWaylandOpenGLDriver::swapOutputBuffer(const std::string& outputName) {
m_frameCounter++;
}
}
+
+std::string CWaylandOpenGLDriver::getCurrentlyRendered() const {
+ for (auto& o : m_outputs) {
+ if (o->rendering)
+ return o->name;
+ }
+
+ return "";
+}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index 931bc03..b49c84e 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -80,6 +80,7 @@ namespace WallpaperEngine::Render::Drivers
bool shouldRenderOutput(const std::string& outputName) const override;
bool requiresSeparateFlips() const override;
void swapOutputBuffer(const std::string& outputName) override;
+ std::string getCurrentlyRendered() const override;
GLFWwindow* getWindow ();
From f21a6e64a7c7b9d167e1912d1d892f8b2100497f Mon Sep 17 00:00:00 2001
From: Alexis Maiquez
Date: Sat, 22 Apr 2023 05:51:27 +0200
Subject: [PATCH 32/43] Wayland implementation cleanup
Removed wayland-display in favour of screen-root, it should automatically switch between X11 and Wayland implementations
Removed all the window-server-specific code from CWallpaperApplication
Moved COutput from CWallpaperApplication to each CVideoDriver as the output is tied to the driver
Moved CFullScreenDetector from CWallpaperApplication to each CVideoDriver as the detection is tied to the video driver
Applied the Driver treatment to the Input, this way CInputContext doesn't depend on the driver used
Updated CRenderContext to be aware of viewport-specific context updates
Viewport information is now held inside COutputViewport instead of being a simple map
Merged CLayerSurface and SWaylandOutput, inheriting from the new COutputViewport to standarize the minimum requirements of a viewport
(makeCurrent and swapOutput are common requirements, X11 was the outlier not needing these per-viewport)
Moved all the viewport-specific code of Wayland from CWaylandOpenGLDriver to It's own class CWaylandOutputViewport
Fixed an issue under Wayland where sometimes the background surfaces wouldn't get anything drawn because the CWaylandOutput wasn't reset
Updated screenshot-taking code to be standard for all drivers again
Signed-off-by: Alexis Maiquez
---
CMakeLists.txt | 24 +-
.../Application/CApplicationContext.cpp | 19 +-
.../Application/CApplicationContext.h | 6 +-
.../Application/CWallpaperApplication.cpp | 189 +++----
.../Application/CWallpaperApplication.h | 14 +-
.../Detectors/CAudioPlayingDetector.cpp | 4 +-
.../Drivers/Detectors/CAudioPlayingDetector.h | 6 +-
.../Detectors/CPulseAudioPlayingDetector.cpp | 2 +-
.../Detectors/CPulseAudioPlayingDetector.h | 2 +-
src/WallpaperEngine/Input/CGLFWMouseInput.cpp | 21 -
src/WallpaperEngine/Input/CInputContext.cpp | 19 +-
src/WallpaperEngine/Input/CInputContext.h | 17 +-
src/WallpaperEngine/Input/CMouseInput.cpp | 4 -
src/WallpaperEngine/Input/CMouseInput.h | 6 -
.../Input/CWaylandMouseInput.cpp | 27 -
.../Input/Drivers/CGLFWMouseInput.cpp | 24 +
.../Input/{ => Drivers}/CGLFWMouseInput.h | 17 +-
.../Input/Drivers/CWaylandMouseInput.cpp | 29 ++
.../Input/{ => Drivers}/CWaylandMouseInput.h | 6 +-
src/WallpaperEngine/Render/CRenderContext.cpp | 33 +-
src/WallpaperEngine/Render/CRenderContext.h | 8 +-
src/WallpaperEngine/Render/CVideo.cpp | 3 +-
.../Render/Drivers/CVideoDriver.cpp | 26 +-
.../Render/Drivers/CVideoDriver.h | 57 ++-
.../Render/Drivers/CWaylandOpenGLDriver.cpp | 479 ++++++------------
.../Render/Drivers/CWaylandOpenGLDriver.h | 120 ++---
.../Render/Drivers/CX11OpenGLDriver.cpp | 42 +-
.../Render/Drivers/CX11OpenGLDriver.h | 20 +-
.../Detectors/CWaylandFullScreenDetector.cpp | 4 +-
.../Detectors/CWaylandFullScreenDetector.h | 24 +-
.../Detectors/CX11FullScreenDetector.cpp | 5 +-
.../Detectors/CX11FullScreenDetector.h | 51 +-
.../Drivers/Output/CGLFWWindowOutput.cpp | 12 +-
.../Render/Drivers/Output/CGLFWWindowOutput.h | 4 +-
.../Render/Drivers/Output/COutput.cpp | 6 +-
.../Render/Drivers/Output/COutput.h | 61 +--
.../Render/Drivers/Output/COutputViewport.cpp | 16 +
.../Render/Drivers/Output/COutputViewport.h | 30 ++
.../Render/Drivers/Output/CWaylandOutput.cpp | 34 +-
.../Render/Drivers/Output/CWaylandOutput.h | 35 +-
.../Drivers/Output/CWaylandOutputViewport.cpp | 236 +++++++++
.../Drivers/Output/CWaylandOutputViewport.h | 75 +++
.../Render/Drivers/Output/CX11Output.cpp | 18 +-
.../Render/Drivers/Output/CX11Output.h | 5 +-
.../Drivers/Output/CX11OutputViewport.cpp | 18 +
.../Drivers/Output/CX11OutputViewport.h | 15 +
46 files changed, 1031 insertions(+), 842 deletions(-)
delete mode 100644 src/WallpaperEngine/Input/CGLFWMouseInput.cpp
delete mode 100644 src/WallpaperEngine/Input/CWaylandMouseInput.cpp
create mode 100644 src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp
rename src/WallpaperEngine/Input/{ => Drivers}/CGLFWMouseInput.h (65%)
create mode 100644 src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp
rename src/WallpaperEngine/Input/{ => Drivers}/CWaylandMouseInput.h (82%)
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/CX11OutputViewport.cpp
create mode 100644 src/WallpaperEngine/Render/Drivers/Output/CX11OutputViewport.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 260532a..20c58c2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,9 +73,19 @@ if (ENABLE_WAYLAND)
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
add_compile_definitions(ENABLE_WAYLAND)
- set(WAYLAND_SOURCES "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h" "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp" "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
- "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp" "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
- "src/WallpaperEngine/Input/CWaylandMouseInput.cpp" "src/WallpaperEngine/Input/CWaylandMouseInput.h" "xdg-shell-protocol.c" "wlr-layer-shell-unstable-v1-protocol.c")
+ set(WAYLAND_SOURCES
+ "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
+ "src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp"
+ "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp"
+ "src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h"
+ "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp"
+ "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
+ "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp"
+ "src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h"
+ "src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp"
+ "src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.h"
+ "xdg-shell-protocol.c"
+ "wlr-layer-shell-unstable-v1-protocol.c")
else()
set(WAYLAND_SOURCES "")
endif()
@@ -142,8 +152,8 @@ add_executable(
src/WallpaperEngine/Input/CInputContext.h
src/WallpaperEngine/Input/CMouseInput.cpp
src/WallpaperEngine/Input/CMouseInput.h
- src/WallpaperEngine/Input/CGLFWMouseInput.cpp
- src/WallpaperEngine/Input/CGLFWMouseInput.h
+ src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp
+ src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.h
src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.cpp
@@ -175,6 +185,10 @@ add_executable(
src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
+ src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp
+ src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h
+ src/WallpaperEngine/Render/Drivers/Output/CX11OutputViewport.cpp
+ src/WallpaperEngine/Render/Drivers/Output/CX11OutputViewport.h
src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h
src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp
src/WallpaperEngine/Render/Drivers/CVideoDriver.h
diff --git a/src/WallpaperEngine/Application/CApplicationContext.cpp b/src/WallpaperEngine/Application/CApplicationContext.cpp
index fe53369..857a995 100644
--- a/src/WallpaperEngine/Application/CApplicationContext.cpp
+++ b/src/WallpaperEngine/Application/CApplicationContext.cpp
@@ -13,7 +13,6 @@ using namespace WallpaperEngine::Application;
struct option long_options[] = {
{ "screen-root", required_argument, nullptr, 'r' },
- { "wayland-display", required_argument, nullptr, 'i' },
{ "bg", required_argument, nullptr, 'b' },
{ "window", required_argument, nullptr, 'w' },
{ "pkg", required_argument, nullptr, 'p' },
@@ -85,7 +84,7 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
std::string lastScreen;
- while ((c = getopt_long (argc, argv, "b:ri:p:d:shf:a:w:mn", long_options, nullptr)) != -1)
+ while ((c = getopt_long (argc, argv, "b:r:p:d:shf:a:w:mn", long_options, nullptr)) != -1)
{
switch (c)
{
@@ -125,25 +124,13 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
if (this->settings.render.mode == EXPLICIT_WINDOW)
sLog.exception ("Cannot run in both background and window mode");
- this->settings.render.mode = X11_BACKGROUND;
+ this->settings.render.mode = DESKTOP_BACKGROUND;
lastScreen = optarg;
this->settings.general.screenBackgrounds[lastScreen] = "";
break;
- case 'i':
- if (this->settings.general.screenBackgrounds.find (optarg) != this->settings.general.screenBackgrounds.end ())
- sLog.exception ("Cannot specify the same screen more than once: ", optarg);
- if (this->settings.render.mode == EXPLICIT_WINDOW)
- sLog.exception ("Cannot run in both background and window mode");
-
- this->settings.render.mode = WAYLAND_LAYER_SHELL;
- lastScreen = optarg;
- this->settings.general.screenBackgrounds[lastScreen] = "";
-
- break;
-
case 'w':
- if (this->settings.render.mode == X11_BACKGROUND)
+ if (this->settings.render.mode == DESKTOP_BACKGROUND)
sLog.exception ("Cannot run in both background and window mode");
if (optarg != nullptr)
diff --git a/src/WallpaperEngine/Application/CApplicationContext.h b/src/WallpaperEngine/Application/CApplicationContext.h
index cb3badd..5d37fbf 100644
--- a/src/WallpaperEngine/Application/CApplicationContext.h
+++ b/src/WallpaperEngine/Application/CApplicationContext.h
@@ -25,12 +25,10 @@ namespace WallpaperEngine::Application
{
/** Default window mode */
NORMAL_WINDOW = 0,
- /** Draw to X11 background */
- X11_BACKGROUND = 1,
+ /** Draw to the window server desktop */
+ DESKTOP_BACKGROUND = 1,
/** Explicit window mode with specified geometry */
EXPLICIT_WINDOW = 2,
- /** Wayland mode - zwlr_layer_shell_v1 */
- WAYLAND_LAYER_SHELL = 3,
};
struct
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index d28420d..0371ec0 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -8,6 +8,11 @@
#include "WallpaperEngine/Render/CRenderContext.h"
#include "WallpaperEngine/Application/CApplicationState.h"
#include "WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h"
+#include "WallpaperEngine/Input/Drivers/CWaylandMouseInput.h"
+#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
+#include "WallpaperEngine/Input/Drivers/CGLFWMouseInput.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h"
+#include "WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
#include
@@ -223,134 +228,87 @@ namespace WallpaperEngine::Application
)
{
// this should be getting called at the end of the frame, so the right thing should be bound already
-
- int width = context.getOutput ()->getFullWidth ();
- int height = context.getOutput ()->getFullHeight ();
-
- // make room for storing the pixel data
- uint8_t* buffer = new uint8_t[width * height * sizeof (uint8_t) * 3];
- uint8_t* pixel = buffer;
-
- // read the image into the buffer
- glReadPixels (0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
+ int width = context.getOutput ().getFullWidth ();
+ int height = context.getOutput ().getFullHeight ();
// build the output file with FreeImage
static FIBITMAP* bitmap = FreeImage_Allocate (width, height, 24);
RGBQUAD color;
+ int xoffset = 0;
+
+ for (const auto& viewport : context.getOutput ().getViewports ())
+ {
+ // activate opengl context so we can read from the framebuffer
+ viewport.second->makeCurrent ();
+ // make room for storing the pixel of this viewport
+ uint8_t* buffer = new uint8_t[viewport.second->viewport.z * viewport.second->viewport.w * sizeof (uint8_t) * 3];
+ uint8_t* pixel = buffer;
+
+ // read the viewport data into the pixel buffer
+ glReadPixels (
+ viewport.second->viewport.x, viewport.second->viewport.y,
+ viewport.second->viewport.z, viewport.second->viewport.w,
+ GL_RGB, GL_UNSIGNED_BYTE, buffer
+ );
- if (!context.getDriver().requiresSeparateFlips()) {
// now get access to the pixels
- for (int y = height; y > 0; y--)
+ for (int y = viewport.second->viewport.w; y > 0; y--)
{
- for (int x = 0; x < width; x++)
+ for (int x = 0; x < viewport.second->viewport.z; x++)
{
color.rgbRed = *pixel++;
color.rgbGreen = *pixel++;
color.rgbBlue = *pixel++;
// set the pixel in the destination
- FreeImage_SetPixelColor (bitmap, x, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
+ FreeImage_SetPixelColor (bitmap, x + xoffset, context.getOutput ().renderVFlip() ? (viewport.second->viewport.w - y) : y, &color);
}
}
- // finally save the file
- FreeImage_Save (format, bitmap, filename.c_str (), 0);
+ if (viewport.second->single)
+ xoffset += viewport.second->viewport.z;
- // free all the used memory
+ // free the buffer allocated for the viewport
delete[] buffer;
-
- FreeImage_Unload (bitmap);
-
- const_cast(&context.getApp())->getContext().settings.screenshot.take = false;
- } else {
- const auto RENDERING = context.getDriver().getCurrentlyRendered();
- static int xoff = 0;
-
- for (int y = height; y > 0; y--)
- {
- for (int x = 0; x < width; x++)
- {
- color.rgbRed = *pixel++;
- color.rgbGreen = *pixel++;
- color.rgbBlue = *pixel++;
-
- // set the pixel in the destination
- FreeImage_SetPixelColor (bitmap, x + xoff, (context.getOutput()->renderVFlip() ? (height - y) : y), &color);
- }
- }
-
- for (auto& [name, data] : context.getOutput()->getViewports()) {
- if (name == RENDERING) {
- xoff += data.viewport.z;
- break;
- }
- }
-
- const_cast(&context.getApp())->screenshotOutputsDone.push_back(RENDERING);
-
- if (const_cast(&context.getApp())->screenshotOutputsDone.size() >= context.getOutput()->getViewports().size()) {
- // finally save the file
- FreeImage_Save (format, bitmap, filename.c_str (), 0);
-
- // free all the used memory
- delete[] buffer;
-
- FreeImage_Unload (bitmap);
-
- const_cast(&context.getApp())->getContext().settings.screenshot.take = false;
- }
}
+
+ // finally save the file
+ FreeImage_Save (format, bitmap, filename.c_str (), 0);
+
+ FreeImage_Unload (bitmap);
}
void CWallpaperApplication::show ()
{
- // initialize OpenGL driver
-#ifdef ENABLE_WAYLAND
- const bool WAYLAND = getenv("WAYLAND_DISPLAY") && this->m_context.settings.render.mode == CApplicationContext::WAYLAND_LAYER_SHELL;
- if (WAYLAND) {
- videoDriver = std::make_unique("wallpaperengine", this->m_context, this);
- inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver*)videoDriver.get());
- } else {
-#endif
- videoDriver = std::make_unique("wallpaperengine", this->m_context);
- inputContext = std::make_unique(*(WallpaperEngine::Render::Drivers::CX11OpenGLDriver*)videoDriver.get());
-#ifdef ENABLE_WAYLAND
+ const bool WAYLAND_DISPLAY = getenv ("WAYLAND_DISPLAY");
+
+ // setup the right video driver based on the environment and the startup mode requested
+ if (WAYLAND_DISPLAY && this->m_context.settings.render.mode == CApplicationContext::DESKTOP_BACKGROUND)
+ {
+ auto waylandDriver = new WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver (this->m_context, *this);
+ inputContext = new WallpaperEngine::Input::CInputContext (new WallpaperEngine::Input::Drivers::CWaylandMouseInput (waylandDriver));
+
+ videoDriver = waylandDriver;
+ }
+ else
+ {
+ auto x11Driver = new WallpaperEngine::Render::Drivers::CX11OpenGLDriver ("wallpaperengine", this->m_context, *this);
+ // no wayland detected, try the old X11 method
+ inputContext = new WallpaperEngine::Input::CInputContext (new WallpaperEngine::Input::Drivers::CGLFWMouseInput (x11Driver));
+
+ videoDriver = x11Driver;
}
- if (WAYLAND)
- fullscreenDetector = std::make_unique(this->m_context, *(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver*)videoDriver.get());
- else
-#endif
- fullscreenDetector = std::make_unique(this->m_context, *videoDriver);
// stereo mix recorder for audio processing
WallpaperEngine::Audio::Drivers::Recorders::CPulseAudioPlaybackRecorder audioRecorder;
// audio playing detector
- WallpaperEngine::Audio::Drivers::Detectors::CPulseAudioPlayingDetector audioDetector (this->m_context, *fullscreenDetector);
+ WallpaperEngine::Audio::Drivers::Detectors::CPulseAudioPlayingDetector audioDetector (this->m_context, videoDriver->getFullscreenDetector ());
// initialize sdl audio driver
- audioDriver = std::make_unique (this->m_context, audioDetector, audioRecorder);
+ audioDriver = new WallpaperEngine::Audio::Drivers::CSDLAudioDriver (this->m_context, audioDetector, audioRecorder);
// initialize audio context
- audioContext = std::make_unique (*audioDriver);
-
- // initialize the requested output
- switch (this->m_context.settings.render.mode)
- {
- case CApplicationContext::EXPLICIT_WINDOW:
- case CApplicationContext::NORMAL_WINDOW:
- output = new WallpaperEngine::Render::Drivers::Output::CGLFWWindowOutput (this->m_context, *videoDriver, *fullscreenDetector);
- break;
-
- case CApplicationContext::X11_BACKGROUND:
- output = new WallpaperEngine::Render::Drivers::Output::CX11Output (this->m_context, *videoDriver, *fullscreenDetector);
- break;
-#ifdef ENABLE_WAYLAND
- case CApplicationContext::WAYLAND_LAYER_SHELL:
- output = new WallpaperEngine::Render::Drivers::Output::CWaylandOutput (this->m_context, *videoDriver, *fullscreenDetector);
- break;
-#endif
- }
-
+ audioContext = new WallpaperEngine::Audio::CAudioContext (*audioDriver);
// initialize render context
- context = std::make_unique (output, *videoDriver, *inputContext, *this);
+ context = new WallpaperEngine::Render::CRenderContext (*videoDriver, *inputContext, *this);
// set all the specific wallpapers required
for (const auto& it : this->m_backgrounds)
@@ -365,30 +323,8 @@ namespace WallpaperEngine::Application
this->m_defaultBackground->getWallpaper (), *context, *audioContext
));
-#ifdef ENABLE_WAYLAND
- if (WAYLAND) {
- renderFrame();
-
- while (this->m_context.state.general.keepRunning && !videoDriver->closeRequested ()) {
- videoDriver->dispatchEventQueue();
- }
- } else {
-#endif
- while (!videoDriver->closeRequested () && this->m_context.state.general.keepRunning) {
- static float startTime, endTime, minimumTime = 1.0f / this->m_context.settings.render.maximumFPS;
- // get the start time of the frame
- startTime = videoDriver->getRenderTime ();
- renderFrame();
- // get the end time of the frame
- endTime = videoDriver->getRenderTime ();
-
- // ensure the frame time is correct to not overrun FPS
- if ((endTime - startTime) < minimumTime)
- usleep ((minimumTime - (endTime - startTime)) * CLOCKS_PER_SEC);
- }
-#ifdef ENABLE_WAYLAND
- }
-#endif
+ while (this->m_context.state.general.keepRunning && !videoDriver->closeRequested ())
+ videoDriver->dispatchEventQueue ();
// ensure this is updated as sometimes it might not come from a signal
this->m_context.state.general.keepRunning = false;
@@ -398,7 +334,8 @@ namespace WallpaperEngine::Application
SDL_Quit ();
}
- void CWallpaperApplication::renderFrame() {
+ void CWallpaperApplication::update()
+ {
static time_t seconds;
static struct tm* timeinfo;
@@ -422,10 +359,8 @@ namespace WallpaperEngine::Application
if (!this->m_context.settings.screenshot.take || videoDriver->getFrameCounter () < 5)
return;
- if (std::find_if(screenshotOutputsDone.begin(), screenshotOutputsDone.end(), [&] (const auto& other) { return other == context->getDriver().getCurrentlyRendered(); }) != screenshotOutputsDone.end())
- return;
-
this->takeScreenshot (*context, this->m_context.settings.screenshot.path, this->m_context.settings.screenshot.format);
+ this->m_context.settings.screenshot.take = false;
}
void CWallpaperApplication::signal (int signal)
@@ -447,8 +382,4 @@ namespace WallpaperEngine::Application
{
return this->m_context;
}
-
- WallpaperEngine::Render::Drivers::Output::COutput* CWallpaperApplication::getOutput() const {
- return this->output;
- }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.h b/src/WallpaperEngine/Application/CWallpaperApplication.h
index 2b401db..81048ee 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.h
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.h
@@ -65,7 +65,7 @@ namespace WallpaperEngine::Application
/**
* Renders a frame
*/
- void renderFrame();
+ void update();
/**
* Gets the output
*/
@@ -116,13 +116,11 @@ namespace WallpaperEngine::Application
/** Maps screens to backgrounds */
std::map m_backgrounds;
- std::unique_ptr videoDriver;
- std::unique_ptr inputContext;
- WallpaperEngine::Render::Drivers::Output::COutput* output;
- std::unique_ptr fullscreenDetector;
- std::unique_ptr audioDriver;
- std::unique_ptr context;
- std::unique_ptr audioContext;
+ WallpaperEngine::Render::Drivers::CVideoDriver* videoDriver;
+ WallpaperEngine::Input::CInputContext* inputContext;
+ WallpaperEngine::Audio::Drivers::CSDLAudioDriver* audioDriver;
+ WallpaperEngine::Render::CRenderContext* context;
+ WallpaperEngine::Audio::CAudioContext* audioContext;
std::vector screenshotOutputsDone;
};
diff --git a/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp b/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp
index b02c740..ba0962a 100644
--- a/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp
+++ b/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp
@@ -4,7 +4,7 @@ namespace WallpaperEngine::Audio::Drivers::Detectors
{
CAudioPlayingDetector::CAudioPlayingDetector (
Application::CApplicationContext& appContext,
- Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
+ const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
m_applicationContext (appContext),
m_fullscreenDetector (fullscreenDetector),
m_isPlaying (false)
@@ -21,7 +21,7 @@ namespace WallpaperEngine::Audio::Drivers::Detectors
return this->m_applicationContext;
}
- Render::Drivers::Detectors::CFullScreenDetector& CAudioPlayingDetector::getFullscreenDetector ()
+ const Render::Drivers::Detectors::CFullScreenDetector& CAudioPlayingDetector::getFullscreenDetector () const
{
return this->m_fullscreenDetector;
}
diff --git a/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h b/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h
index 28bfde2..cec3341 100644
--- a/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h
+++ b/src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h
@@ -23,7 +23,7 @@ namespace WallpaperEngine
class CAudioPlayingDetector
{
public:
- CAudioPlayingDetector (Application::CApplicationContext& appContext, Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector);
+ CAudioPlayingDetector (Application::CApplicationContext& appContext, const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector);
/**
* @return If any kind of sound is currently playing on the default audio device
@@ -48,13 +48,13 @@ namespace WallpaperEngine
/**
* @return The fullscreen detector used
*/
- [[nodiscard]] Render::Drivers::Detectors::CFullScreenDetector& getFullscreenDetector ();
+ [[nodiscard]] const Render::Drivers::Detectors::CFullScreenDetector& getFullscreenDetector () const;
private:
bool m_isPlaying;
Application::CApplicationContext& m_applicationContext;
- Render::Drivers::Detectors::CFullScreenDetector& m_fullscreenDetector;
+ const Render::Drivers::Detectors::CFullScreenDetector& m_fullscreenDetector;
};
}
}
diff --git a/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp b/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp
index 2e16cfe..fdff128 100644
--- a/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp
+++ b/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp
@@ -34,7 +34,7 @@ namespace WallpaperEngine::Audio::Drivers::Detectors
CPulseAudioPlayingDetector::CPulseAudioPlayingDetector (
Application::CApplicationContext& appContext,
- Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
+ const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
CAudioPlayingDetector (appContext, fullscreenDetector),
m_mainloop (nullptr),
m_mainloopApi (nullptr),
diff --git a/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h b/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h
index f48a0b7..b4628c2 100644
--- a/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h
+++ b/src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h
@@ -10,7 +10,7 @@ namespace WallpaperEngine::Audio::Drivers::Detectors
class CPulseAudioPlayingDetector : public CAudioPlayingDetector
{
public:
- explicit CPulseAudioPlayingDetector (Application::CApplicationContext& appContext, Render::Drivers::Detectors::CFullScreenDetector&);
+ explicit CPulseAudioPlayingDetector (Application::CApplicationContext& appContext, const Render::Drivers::Detectors::CFullScreenDetector&);
~CPulseAudioPlayingDetector ();
void update () override;
diff --git a/src/WallpaperEngine/Input/CGLFWMouseInput.cpp b/src/WallpaperEngine/Input/CGLFWMouseInput.cpp
deleted file mode 100644
index 83b62cf..0000000
--- a/src/WallpaperEngine/Input/CGLFWMouseInput.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include
-#include "CGLFWMouseInput.h"
-
-using namespace WallpaperEngine::Input;
-
-CGLFWMouseInput::CGLFWMouseInput (GLFWwindow* window) : m_reportedPosition (), m_mousePosition (), m_window (window) {}
-
-void CGLFWMouseInput::update ()
-{
- if (!m_window)
- return;
-
- // update current mouse position
- glfwGetCursorPos (this->m_window, &this->m_mousePosition.x, &this->m_mousePosition.y);
- // interpolate to the new position
- this->m_reportedPosition = glm::mix (this->m_reportedPosition, this->m_mousePosition, 1.0);
-}
-
-glm::dvec2 CGLFWMouseInput::position() const {
- return this->m_reportedPosition;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CInputContext.cpp b/src/WallpaperEngine/Input/CInputContext.cpp
index 22509d5..7c3970b 100644
--- a/src/WallpaperEngine/Input/CInputContext.cpp
+++ b/src/WallpaperEngine/Input/CInputContext.cpp
@@ -1,26 +1,13 @@
#include "CInputContext.h"
-#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
-#include "WallpaperEngine/Input/CGLFWMouseInput.h"
-#ifdef ENABLE_WAYLAND
-#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
-#include "WallpaperEngine/Input/CWaylandMouseInput.h"
-#endif
using namespace WallpaperEngine::Input;
using namespace WallpaperEngine::Render::Drivers;
-CInputContext::CInputContext (CX11OpenGLDriver& videoDriver)
+CInputContext::CInputContext (CMouseInput* mouseInput) :
+ m_mouse (mouseInput)
{
- m_mouse = std::make_unique(videoDriver.getWindow());
}
-#ifdef ENABLE_WAYLAND
-CInputContext::CInputContext (CWaylandOpenGLDriver& videoDriver)
-{
- m_mouse = std::make_unique(&videoDriver);
-}
-#endif
-
void CInputContext::update ()
{
this->m_mouse->update ();
@@ -28,5 +15,5 @@ void CInputContext::update ()
const CMouseInput& CInputContext::getMouseInput () const
{
- return *this->m_mouse.get();
+ return *this->m_mouse;
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CInputContext.h b/src/WallpaperEngine/Input/CInputContext.h
index 3d51423..40e0394 100644
--- a/src/WallpaperEngine/Input/CInputContext.h
+++ b/src/WallpaperEngine/Input/CInputContext.h
@@ -1,14 +1,10 @@
#pragma once
-#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
-#ifdef ENABLE_WAYLAND
-#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
-#endif
#include "CMouseInput.h"
namespace WallpaperEngine::Render::Drivers
{
- class CX11OpenGLDriver;
+ class CVideoDriver;
}
namespace WallpaperEngine::Input
@@ -16,15 +12,16 @@ namespace WallpaperEngine::Input
class CInputContext
{
public:
- explicit CInputContext (Render::Drivers::CX11OpenGLDriver& videoDriver);
- #ifdef ENABLE_WAYLAND
- explicit CInputContext (Render::Drivers::CWaylandOpenGLDriver& videoDriver);
- #endif
+ explicit CInputContext (CMouseInput* mouseInput);
+
+ /**
+ * Updates input information
+ */
void update ();
[[nodiscard]] const CMouseInput& getMouseInput () const;
private:
- std::unique_ptr m_mouse;
+ CMouseInput* m_mouse;
};
}
diff --git a/src/WallpaperEngine/Input/CMouseInput.cpp b/src/WallpaperEngine/Input/CMouseInput.cpp
index 2998032..e69de29 100644
--- a/src/WallpaperEngine/Input/CMouseInput.cpp
+++ b/src/WallpaperEngine/Input/CMouseInput.cpp
@@ -1,4 +0,0 @@
-#include
-#include "CMouseInput.h"
-
-using namespace WallpaperEngine::Input;
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CMouseInput.h b/src/WallpaperEngine/Input/CMouseInput.h
index 2b07d4b..06021f6 100644
--- a/src/WallpaperEngine/Input/CMouseInput.h
+++ b/src/WallpaperEngine/Input/CMouseInput.h
@@ -1,12 +1,6 @@
#pragma once
-#ifdef ENABLE_WAYLAND
-#include "../Render/Drivers/CWaylandOpenGLDriver.h"
-#endif
-
#include
-#include "GLFW/glfw3.h"
-
namespace WallpaperEngine::Input
{
diff --git a/src/WallpaperEngine/Input/CWaylandMouseInput.cpp b/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
deleted file mode 100644
index 7e1011d..0000000
--- a/src/WallpaperEngine/Input/CWaylandMouseInput.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include
-#include "CWaylandMouseInput.h"
-
-using namespace WallpaperEngine::Input;
-
-CWaylandMouseInput::CWaylandMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) {
- waylandDriver = driver;
-}
-
-void CWaylandMouseInput::update ()
-{
- ;
-}
-
-glm::dvec2 CWaylandMouseInput::position() const {
- if (!waylandDriver || !waylandDriver->lastLSInFocus)
- return {0, 0};
-
- for (auto& o : waylandDriver->m_outputs) {
- if (!o->rendering)
- continue;
-
- return o->layerSurface.get() == waylandDriver->lastLSInFocus ? o->layerSurface->mousePos : glm::dvec2{-1337, -1337};
- }
-
- return {0, 0};
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp b/src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp
new file mode 100644
index 0000000..ffc8836
--- /dev/null
+++ b/src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp
@@ -0,0 +1,24 @@
+#include
+#include "CGLFWMouseInput.h"
+
+#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
+
+using namespace WallpaperEngine::Input::Drivers;
+
+CGLFWMouseInput::CGLFWMouseInput (Render::Drivers::CX11OpenGLDriver* driver) :
+ m_reportedPosition (),
+ m_mousePosition (),
+ m_driver (driver) {}
+
+void CGLFWMouseInput::update ()
+{
+ // update current mouse position
+ glfwGetCursorPos (this->m_driver->getWindow (), &this->m_mousePosition.x, &this->m_mousePosition.y);
+ // interpolate to the new position
+ this->m_reportedPosition = glm::mix (this->m_reportedPosition, this->m_mousePosition, 1.0);
+}
+
+glm::dvec2 CGLFWMouseInput::position() const
+{
+ return this->m_reportedPosition;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CGLFWMouseInput.h b/src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.h
similarity index 65%
rename from src/WallpaperEngine/Input/CGLFWMouseInput.h
rename to src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.h
index 90cb46b..73bf9d1 100644
--- a/src/WallpaperEngine/Input/CGLFWMouseInput.h
+++ b/src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.h
@@ -1,11 +1,15 @@
#pragma once
-#include "CMouseInput.h"
+#include "WallpaperEngine/Input/CMouseInput.h"
#include
-#include "GLFW/glfw3.h"
-namespace WallpaperEngine::Input
+namespace WallpaperEngine::Render::Drivers
+{
+ class CX11OpenGLDriver;
+}
+
+namespace WallpaperEngine::Input::Drivers
{
/**
* Handles mouse input for the background
@@ -13,7 +17,7 @@ namespace WallpaperEngine::Input
class CGLFWMouseInput : public CMouseInput
{
public:
- explicit CGLFWMouseInput(GLFWwindow* window);
+ explicit CGLFWMouseInput(Render::Drivers::CX11OpenGLDriver* driver);
/**
* Takes current mouse position and updates it
@@ -26,10 +30,7 @@ namespace WallpaperEngine::Input
glm::dvec2 position () const override;
private:
- /**
- * The GLFW window to get mouse position from
- */
- GLFWwindow* m_window = nullptr;
+ Render::Drivers::CX11OpenGLDriver* m_driver;
/**
* The current mouse position
diff --git a/src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp b/src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp
new file mode 100644
index 0000000..da6a3c2
--- /dev/null
+++ b/src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp
@@ -0,0 +1,29 @@
+#include
+#include "CWaylandMouseInput.h"
+
+using namespace WallpaperEngine::Input::Drivers;
+
+CWaylandMouseInput::CWaylandMouseInput(WallpaperEngine::Render::Drivers::CWaylandOpenGLDriver* driver) :
+ waylandDriver (driver)
+{
+}
+
+void CWaylandMouseInput::update ()
+{
+}
+
+glm::dvec2 CWaylandMouseInput::position() const
+{
+ if (!waylandDriver->viewportInFocus)
+ return {0, 0};
+
+ for (auto& o : waylandDriver->m_screens)
+ {
+ if (!o->rendering)
+ continue;
+
+ return o == waylandDriver->viewportInFocus ? o->mousePos : glm::dvec2{-1337, -1337};
+ }
+
+ return {0, 0};
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Input/CWaylandMouseInput.h b/src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.h
similarity index 82%
rename from src/WallpaperEngine/Input/CWaylandMouseInput.h
rename to src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.h
index 50ace5a..69ebece 100644
--- a/src/WallpaperEngine/Input/CWaylandMouseInput.h
+++ b/src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.h
@@ -1,13 +1,13 @@
#pragma once
-#include "CMouseInput.h"
-#include "../Render/Drivers/CWaylandOpenGLDriver.h"
+#include "WallpaperEngine/Input/CMouseInput.h"
+#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
#include
#include "GLFW/glfw3.h"
-namespace WallpaperEngine::Input
+namespace WallpaperEngine::Input::Drivers
{
/**
* Handles mouse input for the background
diff --git a/src/WallpaperEngine/Render/CRenderContext.cpp b/src/WallpaperEngine/Render/CRenderContext.cpp
index c871c90..37506f0 100644
--- a/src/WallpaperEngine/Render/CRenderContext.cpp
+++ b/src/WallpaperEngine/Render/CRenderContext.cpp
@@ -10,11 +10,10 @@
namespace WallpaperEngine::Render
{
CRenderContext::CRenderContext (
- const Drivers::Output::COutput* output, Drivers::CVideoDriver& driver, Input::CInputContext& input,
+ Drivers::CVideoDriver& driver, Input::CInputContext& input,
CWallpaperApplication& app
) :
m_defaultWallpaper (nullptr),
- m_output (output),
m_driver (driver),
m_app (app),
m_input (input),
@@ -27,28 +26,24 @@ namespace WallpaperEngine::Render
bool firstFrame = true;
bool renderFrame = true;
- for (const auto& cur : this->m_output->getViewports ())
+ for (const auto& cur : this->getOutput ().getViewports ())
{
- if (!this->m_driver.shouldRenderOutput(cur.first))
- continue;
-
- this->m_driver.makeCurrent(cur.first);
+ cur.second->makeCurrent ();
#if !NDEBUG
std::string str = "Rendering to output " + cur.first;
glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, str.c_str ());
#endif /* DEBUG */
-
// search the background in the viewport selection
auto ref = this->m_wallpapers.find (cur.first);
// render the background
if (ref != this->m_wallpapers.end ())
- ref->second->render (cur.second.viewport, this->m_output->renderVFlip (), renderFrame, firstFrame);
+ ref->second->render (cur.second->viewport, this->getOutput ().renderVFlip (), renderFrame, firstFrame);
else
this->m_defaultWallpaper->render (
- cur.second.viewport, this->m_output->renderVFlip (), renderFrame, firstFrame
+ cur.second->viewport, this->getOutput ().renderVFlip (), renderFrame, firstFrame
);
// scenes need to render a new frame for each viewport as they produce different results
// but videos should only be rendered once per group of viewports
@@ -57,22 +52,20 @@ namespace WallpaperEngine::Render
glPopDebugGroup ();
#endif /* DEBUG */
- if (this->m_driver.requiresSeparateFlips())
- this->m_driver.swapOutputBuffer(cur.first);
+ cur.second->swapOutput ();
}
// read the full texture into the image
- if (this->m_output->haveImageBuffer ())
+ if (this->getOutput ().haveImageBuffer ())
glReadPixels (
- 0, 0, this->m_output->getFullWidth (), this->m_output->getFullHeight (), GL_BGRA, GL_UNSIGNED_BYTE,
- this->m_output->getImageBuffer ()
+ 0, 0, this->getOutput ().getFullWidth (), this->getOutput ().getFullHeight (), GL_BGRA, GL_UNSIGNED_BYTE,
+ this->getOutput ().getImageBuffer ()
);
// update the output with the given image
- this->m_output->updateRender ();
+ this->getOutput ().updateRender ();
// finally swap buffers
- if (!this->m_driver.requiresSeparateFlips())
- this->m_driver.swapBuffers ();
+ this->m_driver.swapBuffers ();
}
void CRenderContext::setDefaultWallpaper (CWallpaper* wallpaper)
@@ -100,9 +93,9 @@ namespace WallpaperEngine::Render
return this->m_driver;
}
- const Drivers::Output::COutput* CRenderContext::getOutput () const
+ const Drivers::Output::COutput& CRenderContext::getOutput () const
{
- return this->m_output;
+ return this->m_driver.getOutput ();
}
const ITexture* CRenderContext::resolveTexture (const std::string& name)
diff --git a/src/WallpaperEngine/Render/CRenderContext.h b/src/WallpaperEngine/Render/CRenderContext.h
index 87d4b31..c74e4b4 100644
--- a/src/WallpaperEngine/Render/CRenderContext.h
+++ b/src/WallpaperEngine/Render/CRenderContext.h
@@ -9,6 +9,7 @@
#include "WallpaperEngine/Input/CMouseInput.h"
#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
#include "WallpaperEngine/Render/Drivers/Output/COutput.h"
+#include "WallpaperEngine/Render/Drivers/Output/COutputViewport.h"
namespace WallpaperEngine
{
@@ -26,6 +27,7 @@ namespace WallpaperEngine
namespace Output
{
class COutput;
+ class COutputViewport;
}
}
@@ -35,7 +37,7 @@ namespace WallpaperEngine
class CRenderContext
{
public:
- CRenderContext (const Drivers::Output::COutput* output, Drivers::CVideoDriver& driver, Input::CInputContext& input, CWallpaperApplication& app);
+ CRenderContext (Drivers::CVideoDriver& driver, Input::CInputContext& input, CWallpaperApplication& app);
void render ();
void setDefaultWallpaper (CWallpaper* wallpaper);
@@ -43,7 +45,7 @@ namespace WallpaperEngine
[[nodiscard]] Input::CInputContext& getInputContext () const;
[[nodiscard]] const CWallpaperApplication& getApp () const;
[[nodiscard]] const Drivers::CVideoDriver& getDriver () const;
- [[nodiscard]] const Drivers::Output::COutput* getOutput () const;
+ [[nodiscard]] const Drivers::Output::COutput& getOutput () const;
const ITexture* resolveTexture (const std::string& name);
private:
@@ -59,8 +61,6 @@ namespace WallpaperEngine
CWallpaperApplication& m_app;
/** Texture cache for the render */
CTextureCache* m_textureCache;
- /** Output driver that describes how the wallpapers are rendered */
- const Drivers::Output::COutput* m_output;
};
}
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CVideo.cpp b/src/WallpaperEngine/Render/CVideo.cpp
index 274664f..ab56c59 100644
--- a/src/WallpaperEngine/Render/CVideo.cpp
+++ b/src/WallpaperEngine/Render/CVideo.cpp
@@ -47,7 +47,8 @@ CVideo::CVideo (Core::CVideo* video, CRenderContext& context, CAudioContext& aud
mpv_set_option (this->m_mpv, "volume", MPV_FORMAT_DOUBLE, &volume);
// initialize gl context for mpv
- mpv_opengl_init_params gl_init_params {this->getContext().getDriver().getWindowHandle() ? get_proc_address_glfw : get_proc_address_wayland, nullptr};
+ mpv_opengl_init_params gl_init_params {get_proc_address_wayland, nullptr};
+ // mpv_opengl_init_params gl_init_params {this->getContext().getDriver().getWindowHandle() ? get_proc_address_glfw : get_proc_address_wayland, nullptr};
mpv_render_param params[] {
{MPV_RENDER_PARAM_API_TYPE, const_cast (MPV_RENDER_API_TYPE_OPENGL)},
{MPV_RENDER_PARAM_OPENGL_INIT_PARAMS, &gl_init_params},
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
index b3e0cd3..8d47bc1 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
@@ -2,26 +2,12 @@
using namespace WallpaperEngine::Render::Drivers;
-void CVideoDriver::dispatchEventQueue() const {
- // intentionally left blank
+CVideoDriver::CVideoDriver (CWallpaperApplication& app) :
+ m_app (app)
+{
}
-void CVideoDriver::makeCurrent(const std::string& outputName) const {
- // intentionally left blank
-}
-
-bool CVideoDriver::shouldRenderOutput(const std::string& outputName) const {
- return true;
-}
-
-bool CVideoDriver::requiresSeparateFlips() const {
- return false;
-}
-
-void CVideoDriver::swapOutputBuffer(const std::string& outputName) {
- // intentionally left blank
-}
-
-std::string CVideoDriver::getCurrentlyRendered() const {
- return "";
+CWallpaperApplication& CVideoDriver::getApp () const
+{
+ return this->m_app;
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
index 6336930..fb35c96 100644
--- a/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CVideoDriver.h
@@ -3,20 +3,37 @@
#include
#include
#include
+#include "WallpaperEngine/Render/Drivers/Output/COutput.h"
+
+namespace WallpaperEngine::Application
+{
+ class CWallpaperApplication;
+}
namespace WallpaperEngine::Render::Drivers
{
+ namespace Detectors
+ {
+ class CFullScreenDetector;
+ }
+
class CVideoDriver
{
public:
+ CVideoDriver (CWallpaperApplication& app);
+
/**
- * @return The window handle used by this video driver
+ * @return The fullscreen detector this video driver uses
*/
- virtual void* getWindowHandle () const = 0;
+ [[nodiscard]] virtual Detectors::CFullScreenDetector& getFullscreenDetector () = 0;
+ /**
+ * @return The current output in use
+ */
+ [[nodiscard]] virtual Output::COutput& getOutput () = 0;
/**
* @return The time that has passed since the driver started
*/
- virtual float getRenderTime () const = 0;
+ [[nodiscard]] virtual float getRenderTime () const = 0;
/**
* @return If a close was requested by the OS
*/
@@ -40,7 +57,7 @@ namespace WallpaperEngine::Render::Drivers
/**
* @return The size of the framebuffer available for the driver
*/
- virtual glm::ivec2 getFramebufferSize () const = 0;
+ [[nodiscard]] virtual glm::ivec2 getFramebufferSize () const = 0;
/**
* Performs buffer swapping
*/
@@ -48,30 +65,18 @@ namespace WallpaperEngine::Render::Drivers
/**
* @return The number of rendered frames since the start of the driver
*/
- virtual uint32_t getFrameCounter () const = 0;
+ [[nodiscard]] virtual uint32_t getFrameCounter () const = 0;
/**
- * Wayland only: dispatch wayland event queue
+ * Process events on the driver and renders a frame
*/
- virtual void dispatchEventQueue() const;
+ virtual void dispatchEventQueue() const = 0;
/**
- * Wayland only: make EGL current
- */
- virtual void makeCurrent(const std::string& outputName) const;
- /**
- * Wayland only: whether an output should be rendered
- */
- virtual bool shouldRenderOutput(const std::string& outputName) const;
- /**
- * Wayland only: whether requires separate buffer flips on monitors
- */
- virtual bool requiresSeparateFlips() const;
- /**
- * Wayland only: flip output
- */
- virtual void swapOutputBuffer(const std::string& outputName);
- /**
- * Wayland only: gets currently rendered output
- */
- virtual std::string getCurrentlyRendered() const;
+ * @return The app that owns this driver
+ */
+ [[nodiscard]] CWallpaperApplication& getApp () const;
+
+ private:
+ /** App that owns this driver */
+ CWallpaperApplication& m_app;
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
index f41d168..5307130 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
@@ -20,129 +20,97 @@ extern "C" {
using namespace WallpaperEngine::Render::Drivers;
-static void handlePointerEnter(void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
- const auto PLS = PDRIVER->surfaceToLS(surface);
- PDRIVER->lastLSInFocus = PLS;
- wl_surface_set_buffer_scale(PLS->cursorSurface, PLS->output->scale);
- wl_surface_attach(PLS->cursorSurface, wl_cursor_image_get_buffer(PLS->pointer->images[0]), 0, 0);
- wl_pointer_set_cursor(wl_pointer, serial, PLS->cursorSurface, PLS->pointer->images[0]->hotspot_x, PLS->pointer->images[0]->hotspot_y);
- wl_surface_commit(PLS->cursorSurface);
+static void handlePointerEnter (
+ void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface,
+ wl_fixed_t surface_x, wl_fixed_t surface_y)
+{
+ const auto driver = static_cast (data);
+ const auto viewport = driver->surfaceToViewport (surface);
+ driver->viewportInFocus = viewport;
+ wl_surface_set_buffer_scale(viewport->cursorSurface, viewport->scale);
+ wl_surface_attach(viewport->cursorSurface, wl_cursor_image_get_buffer(viewport->pointer->images[0]), 0, 0);
+ wl_pointer_set_cursor(wl_pointer, serial, viewport->cursorSurface, viewport->pointer->images[0]->hotspot_x, viewport->pointer->images[0]->hotspot_y);
+ wl_surface_commit(viewport->cursorSurface);
}
-static void handlePointerLeave(void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface) {
- // ignored
+static void handlePointerLeave(void* data, struct wl_pointer* wl_pointer, uint32_t serial, struct wl_surface* surface)
+{
}
-static void handlePointerAxis(void* data, wl_pointer* wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {
- // ignored
+static void handlePointerAxis(void* data, wl_pointer* wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value)
+{
}
-static void handlePointerMotion(void* data, struct wl_pointer* wl_pointer, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
+static void handlePointerMotion(
+ void* data, struct wl_pointer* wl_pointer, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
+{
+ const auto driver = static_cast (data);
+
auto x = wl_fixed_to_double(surface_x);
auto y = wl_fixed_to_double(surface_y);
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
- if (!PDRIVER->lastLSInFocus)
+ if (!driver->viewportInFocus)
return;
- PDRIVER->lastLSInFocus->mousePos = {x * PDRIVER->lastLSInFocus->output->scale, y * PDRIVER->lastLSInFocus->output->scale};
+ driver->viewportInFocus->mousePos = {x * driver->viewportInFocus->scale, y * driver->viewportInFocus->scale};
}
-static void handlePointerButton(void* data, struct wl_pointer* wl_pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t button_state) {
- // ignored
+static void handlePointerButton(
+ void* data, struct wl_pointer* wl_pointer, uint32_t serial, uint32_t time, uint32_t button, uint32_t button_state)
+{
}
-const struct wl_pointer_listener pointerListener = { .enter = handlePointerEnter, .leave = handlePointerLeave, .motion = handlePointerMotion, .button = handlePointerButton, .axis = handlePointerAxis };
+const struct wl_pointer_listener pointerListener =
+{
+ .enter = handlePointerEnter,
+ .leave = handlePointerLeave,
+ .motion = handlePointerMotion,
+ .button = handlePointerButton,
+ .axis = handlePointerAxis
+};
-static void handleCapabilities(void* data, wl_seat* wl_seat, uint32_t capabilities) {
+static void handleCapabilities(void* data, wl_seat* wl_seat, uint32_t capabilities)
+{
if (capabilities & WL_SEAT_CAPABILITY_POINTER)
wl_pointer_add_listener(wl_seat_get_pointer(wl_seat), &pointerListener, data);
}
-const struct wl_seat_listener seatListener = { .capabilities = handleCapabilities };
+const struct wl_seat_listener seatListener =
+{
+ .capabilities = handleCapabilities
+};
-static void geometry(void* data, wl_output* output, int32_t x, int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel, const char* make, const char* model,
- int32_t transform) {
- // ignored
-}
-
-static void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
- const auto PMONITOR = (SWaylandOutput*)data;
- PMONITOR->size = {width, height};
- PMONITOR->lsSize = {width, height};
-
- if (PMONITOR->layerSurface.get())
- PMONITOR->driver->resizeLSSurfaceEGL(PMONITOR->layerSurface.get());
-
- if (PMONITOR->initialized)
- PMONITOR->driver->wallpaperApplication->getOutput()->reset();
-}
-
-static void done(void* data, wl_output* wl_output) {
- const auto PMONITOR = (SWaylandOutput*)data;
-
- PMONITOR->initialized = true;
-}
-
-static void scale(void* data, wl_output* wl_output, int32_t scale) {
- const auto PMONITOR = (SWaylandOutput*)data;
-
- PMONITOR->scale = scale;
-
- if (PMONITOR->layerSurface.get())
- PMONITOR->driver->resizeLSSurfaceEGL(PMONITOR->layerSurface.get());
-
- if (PMONITOR->initialized)
- PMONITOR->driver->wallpaperApplication->getOutput()->reset();
-}
-
-static void name(void* data, wl_output* wl_output, const char* name) {
- const auto PMONITOR = (SWaylandOutput*)data;
-
- if (name)
- PMONITOR->name = name;
-}
-
-static void description(void* data, wl_output* wl_output, const char* description) {
- // ignored
-}
-
-const wl_output_listener outputListener = {.geometry = geometry, .mode = mode, .done = done, .scale = scale, .name = name, .description = description};
-
-static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
- const auto PDRIVER = (CWaylandOpenGLDriver*)data;
+static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version)
+{
+ const auto driver = static_cast (data);
if (strcmp(interface, wl_compositor_interface.name) == 0) {
- PDRIVER->waylandContext.compositor = (wl_compositor*)wl_registry_bind(registry, name, &wl_compositor_interface, 4);
+ driver->getWaylandContext()->compositor = (wl_compositor*)wl_registry_bind(registry, name, &wl_compositor_interface, 4);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
- PDRIVER->waylandContext.shm = (wl_shm*)wl_registry_bind(registry, name, &wl_shm_interface, 1);
+ driver->getWaylandContext()->shm = (wl_shm*)wl_registry_bind(registry, name, &wl_shm_interface, 1);
} else if (strcmp(interface, wl_output_interface.name) == 0) {
- const auto POUTPUT = PDRIVER->m_outputs.emplace_back(std::make_unique()).get();
- POUTPUT->output = (wl_output*)wl_registry_bind(registry, name, &wl_output_interface, 4);
- POUTPUT->name = "";
- POUTPUT->size = {0, 0};
- POUTPUT->waylandName = name;
- POUTPUT->driver = PDRIVER;
- wl_output_add_listener(POUTPUT->output, &outputListener, POUTPUT);
+ driver->m_screens.emplace_back (new WallpaperEngine::Render::Drivers::Output::CWaylandOutputViewport (driver, name, registry));
} else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
- PDRIVER->waylandContext.layerShell = (zwlr_layer_shell_v1*)wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
+ driver->getWaylandContext()->layerShell = (zwlr_layer_shell_v1*)wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
- PDRIVER->waylandContext.seat = (wl_seat*)wl_registry_bind(registry, name, &wl_seat_interface, 1);
- wl_seat_add_listener(PDRIVER->waylandContext.seat, &seatListener, PDRIVER);
+ driver->getWaylandContext()->seat = (wl_seat*)wl_registry_bind(registry, name, &wl_seat_interface, 1);
+ wl_seat_add_listener(driver->getWaylandContext()->seat, &seatListener, driver);
}
}
-static void handleGlobalRemoved(void *data, struct wl_registry *registry, uint32_t id) {
+static void handleGlobalRemoved(void *data, struct wl_registry *registry, uint32_t id)
+{
// todo: outputs
}
-const struct wl_registry_listener registryListener = {
+const struct wl_registry_listener registryListener =
+{
.global = handleGlobal,
.global_remove = handleGlobalRemoved,
};
-void CWaylandOpenGLDriver::initEGL() {
+void CWaylandOpenGLDriver::initEGL()
+{
const char* CLIENT_EXTENSIONS = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
if (!CLIENT_EXTENSIONS)
sLog.exception("Failed to query EGL Extensions");
@@ -156,31 +124,31 @@ void CWaylandOpenGLDriver::initEGL() {
sLog.exception("EGL_EXT_platform_wayland not supported by EGL!");
PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
- eglContext.eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT");
+ m_eglContext.eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT");
- if (!eglGetPlatformDisplayEXT || !eglContext.eglCreatePlatformWindowSurfaceEXT)
+ if (!eglGetPlatformDisplayEXT || !m_eglContext.eglCreatePlatformWindowSurfaceEXT)
sLog.exception("EGL did not return EXT proc pointers!");
auto deinitEGL = [&] () -> void {
eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- if (eglContext.display)
- eglTerminate(eglContext.display);
+ if (m_eglContext.display)
+ eglTerminate(m_eglContext.display);
eglReleaseThread();
};
- eglContext.display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, waylandContext.display, nullptr);
+ m_eglContext.display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_waylandContext.display, nullptr);
- if (eglContext.display == EGL_NO_DISPLAY) {
+ if (m_eglContext.display == EGL_NO_DISPLAY) {
deinitEGL();
sLog.exception("eglGetPlatformDisplayEXT failed!");
}
- if (!eglInitialize(eglContext.display, nullptr, nullptr)) {
+ if (!eglInitialize(m_eglContext.display, nullptr, nullptr)) {
deinitEGL();
sLog.exception("eglInitialize failed!");
}
- const std::string CLIENTEXTENSIONSPOSTINIT = std::string(eglQueryString(eglContext.display, EGL_EXTENSIONS));
+ const std::string CLIENTEXTENSIONSPOSTINIT = std::string(eglQueryString(m_eglContext.display, EGL_EXTENSIONS));
if (CLIENTEXTENSIONSPOSTINIT.find("EGL_KHR_create_context") == std::string::npos) {
deinitEGL();
@@ -197,7 +165,8 @@ void CWaylandOpenGLDriver::initEGL() {
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE,
};
- if (!eglChooseConfig(eglContext.display, CONFIG_ATTRIBUTES, &eglContext.config, 1, &matchedConfigs)) {
+
+ if (!eglChooseConfig(m_eglContext.display, CONFIG_ATTRIBUTES, &m_eglContext.config, 1, &matchedConfigs)) {
deinitEGL();
sLog.exception("eglChooseConfig failed!");
}
@@ -218,148 +187,91 @@ void CWaylandOpenGLDriver::initEGL() {
EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR,
EGL_NONE,
};
- eglContext.context = eglCreateContext(eglContext.display, eglContext.config, EGL_NO_CONTEXT, CONTEXT_ATTRIBUTES);
+ m_eglContext.context = eglCreateContext(m_eglContext.display, m_eglContext.config, EGL_NO_CONTEXT, CONTEXT_ATTRIBUTES);
- if (eglContext.context == EGL_NO_CONTEXT) {
+ if (m_eglContext.context == EGL_NO_CONTEXT) {
sLog.error("eglCreateContext error " + std::to_string(eglGetError()));
deinitEGL();
sLog.exception("eglCreateContext failed!");
}
}
-void CWaylandOpenGLDriver::finishEGL() {
- eglMakeCurrent(eglContext.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- eglDestroyContext(eglContext.display, eglContext.context);
- eglTerminate(eglContext.display);
+void CWaylandOpenGLDriver::finishEGL()
+{
+ eglMakeCurrent(m_eglContext.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ eglDestroyContext(m_eglContext.display, m_eglContext.context);
+ eglTerminate(m_eglContext.display);
eglReleaseThread();
}
+void CWaylandOpenGLDriver::onLayerClose(Output::CWaylandOutputViewport* viewport)
+{
+ sLog.error ("Compositor closed our LS, freeing data...");
-static void handleLSConfigure(void *data, zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t w, uint32_t h) {
- const auto PLS = (CLayerSurface*)data;
- PLS->size = {w, h};
+ if (viewport->eglSurface)
+ eglDestroySurface (m_eglContext.display, viewport->eglSurface);
- PLS->output->driver->resizeLSSurfaceEGL(PLS);
+ if (viewport->eglWindow)
+ wl_egl_window_destroy(viewport->eglWindow);
- zwlr_layer_surface_v1_ack_configure(surface, serial);
+ if (viewport->layerSurface)
+ zwlr_layer_surface_v1_destroy(viewport->layerSurface);
+
+ if (viewport->surface)
+ wl_surface_destroy(viewport->surface);
+
+ // remove the output from the list
+ std::remove (this->m_screens.begin (), this->m_screens.end (), viewport);
+ // TODO: DELETE FROM VIEWPORT LIST
+
+ delete viewport;
}
-static void handleLSClosed(void *data, zwlr_layer_surface_v1 *surface) {
- const auto PLS = (CLayerSurface*)data;
- PLS->output->driver->onLayerClose(PLS);
-}
+CWaylandOpenGLDriver::CWaylandOpenGLDriver(CApplicationContext& context, CWallpaperApplication& app) :
+ m_frameCounter(0),
+ m_fullscreenDetector (context, *this),
+ m_output (context, *this),
+ CVideoDriver (app)
+{
+ m_waylandContext.display = wl_display_connect (nullptr);
-void CWaylandOpenGLDriver::onLayerClose(CLayerSurface* layerSurface) {
- eglDestroySurface(eglContext.display, layerSurface->eglSurface);
- wl_egl_window_destroy(layerSurface->eglWindow);
- zwlr_layer_surface_v1_destroy(layerSurface->layerSurface);
- wl_surface_destroy(layerSurface->surface);
- sLog.exception("Compositor closed our LS!"); // todo: handle this?
-}
+ if (!m_waylandContext.display)
+ sLog.exception ("Failed to query wayland display");
-const struct zwlr_layer_surface_v1_listener layerSurfaceListener = {
- .configure = handleLSConfigure,
- .closed = handleLSClosed,
-};
+ m_waylandContext.registry = wl_display_get_registry(m_waylandContext.display);
+ wl_registry_add_listener(m_waylandContext.registry, ®istryListener, this);
-static void surfaceFrameCallback(void *data, struct wl_callback *cb, uint32_t time) {
- const auto PLS = (CLayerSurface*)data;
- wl_callback_destroy(cb);
- PLS->frameCallback = nullptr;
- PLS->output->rendering = true;
- PLS->output->driver->wallpaperApplication->renderFrame();
- PLS->output->rendering = false;
+ wl_display_dispatch(m_waylandContext.display);
+ wl_display_roundtrip(m_waylandContext.display);
- float renderTime = PLS->output->driver->getRenderTime();
-
- if ((renderTime - PLS->lastTime) < PLS->minimumTime)
- usleep ((PLS->minimumTime - (renderTime - PLS->lastTime)) * CLOCKS_PER_SEC);
-
- PLS->lastTime = renderTime;
-}
-
-const struct wl_callback_listener frameListener = {
- .done = surfaceFrameCallback
-};
-
-CLayerSurface::CLayerSurface(CWaylandOpenGLDriver* pDriver, SWaylandOutput* pOutput) {
- surface = wl_compositor_create_surface(pDriver->waylandContext.compositor);
- layerSurface = zwlr_layer_shell_v1_get_layer_surface(pDriver->waylandContext.layerShell, surface, pOutput->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
- output = pOutput;
-
- if (!layerSurface)
- sLog.exception("Failed to get a layer surface");
-
- wl_region* region = wl_compositor_create_region(pDriver->waylandContext.compositor);
- wl_region_add(region, 0, 0, INT32_MAX, INT32_MAX);
-
- zwlr_layer_surface_v1_set_size(layerSurface, 0, 0);
- zwlr_layer_surface_v1_set_anchor(layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
- zwlr_layer_surface_v1_set_keyboard_interactivity(layerSurface, false);
- zwlr_layer_surface_v1_add_listener(layerSurface, &layerSurfaceListener, this);
- zwlr_layer_surface_v1_set_exclusive_zone(layerSurface, -1);
- wl_surface_set_input_region(surface, region);
- wl_surface_commit(surface);
- wl_display_roundtrip(pDriver->waylandContext.display);
-
- eglWindow = wl_egl_window_create(surface, size.x * output->scale, size.y * output->scale);
- eglSurface = pDriver->eglContext.eglCreatePlatformWindowSurfaceEXT(pDriver->eglContext.display, pDriver->eglContext.config, eglWindow, nullptr);
- output->lsSize = size;
- wl_surface_commit(surface);
- wl_display_roundtrip(pDriver->waylandContext.display);
- wl_display_flush(pDriver->waylandContext.display);
-
- static const auto XCURSORSIZE = getenv("XCURSOR_SIZE") ? std::stoi(getenv("XCURSOR_SIZE")) : 24;
- const auto PRCURSORTHEME = wl_cursor_theme_load(getenv("XCURSOR_THEME"), XCURSORSIZE * output->scale, pDriver->waylandContext.shm);
-
- if (!PRCURSORTHEME)
- sLog.exception("Failed to get a cursor theme");
-
- pointer = wl_cursor_theme_get_cursor(PRCURSORTHEME, "left_ptr");
- cursorSurface = wl_compositor_create_surface(pDriver->waylandContext.compositor);
-
- if (!cursorSurface)
- sLog.exception("Failed to get a cursor surface");
-
- if (eglMakeCurrent(pDriver->eglContext.display, eglSurface, eglSurface, pDriver->eglContext.context) == EGL_FALSE)
- sLog.exception("Failed to make egl current");
-
- minimumTime = 1.0f / pDriver->wallpaperApplication->getContext().settings.render.maximumFPS;
-}
-
-CLayerSurface::~CLayerSurface() {
- ;
-}
-
-CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplicationContext& context, CWallpaperApplication* app) : m_frameCounter(0) {
- wallpaperApplication = app;
- waylandContext.display = wl_display_connect(NULL);
-
- if (!waylandContext.display)
- sLog.exception("Failed to query wayland display");
-
- waylandContext.registry = wl_display_get_registry(waylandContext.display);
- wl_registry_add_listener(waylandContext.registry, ®istryListener, this);
-
- wl_display_dispatch(waylandContext.display);
- wl_display_roundtrip(waylandContext.display);
-
- if (!waylandContext.compositor || !waylandContext.shm || !waylandContext.layerShell || m_outputs.empty())
- sLog.exception("Failed to bind to required interfaces");
+ if (!m_waylandContext.compositor || !m_waylandContext.shm || !m_waylandContext.layerShell || this->m_screens.empty())
+ sLog.exception ("Failed to bind to required interfaces");
initEGL();
bool any = false;
- for (auto& o : m_outputs) {
- if (std::find_if(context.settings.general.screenBackgrounds.begin(), context.settings.general.screenBackgrounds.end(), [&] (const auto& e) { return e.first == o->name; }) != context.settings.general.screenBackgrounds.end()) {
- o->layerSurface = std::make_unique(this, o.get());
- any = true;
- }
+
+ for (auto& o : this->m_screens)
+ {
+ const auto cur = context.settings.general.screenBackgrounds.find (o->name);
+
+ if (cur == context.settings.general.screenBackgrounds.end ())
+ continue;
+
+ o->setupLS ();
+ any = true;
}
- if (!any && std::find_if(context.settings.general.screenBackgrounds.begin(), context.settings.general.screenBackgrounds.end(), [&] (const auto& e) { return e.first == "auto"; }) != context.settings.general.screenBackgrounds.end()) {
- m_outputs[0]->layerSurface = std::make_unique(this, m_outputs[0].get());
- any = true;
+ if (!any)
+ {
+ const auto cur = context.settings.general.screenBackgrounds.find ("auto");
+
+ if (cur != context.settings.general.screenBackgrounds.end ())
+ {
+ // initializes the default screen only...
+ m_screens [0]->setupLS ();
+ any = true;
+ }
}
if (!any)
@@ -373,139 +285,82 @@ CWaylandOpenGLDriver::CWaylandOpenGLDriver(const char* windowTitle, CApplication
FreeImage_Initialise (TRUE);
}
-CWaylandOpenGLDriver::~CWaylandOpenGLDriver() {
- ;
+void CWaylandOpenGLDriver::dispatchEventQueue() const
+{
+ // render one frame to force drawing the screens
+ this->getApp ().update ();
+
+ wl_display_dispatch(m_waylandContext.display);
}
-void CWaylandOpenGLDriver::dispatchEventQueue() const {
- wl_display_dispatch(waylandContext.display);
+Detectors::CFullScreenDetector& CWaylandOpenGLDriver::getFullscreenDetector ()
+{
+ return this->m_fullscreenDetector;
}
-void* CWaylandOpenGLDriver::getWindowHandle () const {
- return nullptr;
+Output::COutput& CWaylandOpenGLDriver::getOutput ()
+{
+ return this->m_output;
}
-float CWaylandOpenGLDriver::getRenderTime () const {
+float CWaylandOpenGLDriver::getRenderTime () const
+{
return (float)std::chrono::duration_cast(std::chrono::high_resolution_clock::now() - renderStart).count() / 1000000.0;
}
-bool CWaylandOpenGLDriver::closeRequested () {
+bool CWaylandOpenGLDriver::closeRequested ()
+{
return false;
}
-void CWaylandOpenGLDriver::resizeWindow (glm::ivec2 size) {
- ;
+void CWaylandOpenGLDriver::resizeWindow (glm::ivec2 size)
+{
}
-void CWaylandOpenGLDriver::resizeWindow (glm::ivec4 sizeandpos) {
- ;
+void CWaylandOpenGLDriver::resizeWindow (glm::ivec4 sizeandpos)
+{
}
-void CWaylandOpenGLDriver::showWindow () {
- ;
+void CWaylandOpenGLDriver::showWindow ()
+{
}
-void CWaylandOpenGLDriver::hideWindow () {
- ;
+void CWaylandOpenGLDriver::hideWindow ()
+{
}
-glm::ivec2 CWaylandOpenGLDriver::getFramebufferSize () const {
+glm::ivec2 CWaylandOpenGLDriver::getFramebufferSize () const
+{
return glm::ivec2{0, 0};
}
-void CWaylandOpenGLDriver::swapBuffers () {
- ;
+void CWaylandOpenGLDriver::swapBuffers ()
+{
+ m_frameCounter ++;
}
-void CWaylandOpenGLDriver::resizeLSSurfaceEGL(CLayerSurface* layerSurface) {
- if (layerSurface->eglWindow) {
- layerSurface->output->lsSize = layerSurface->size;
-
- wl_egl_window_resize(layerSurface->eglWindow, layerSurface->size.x * layerSurface->output->scale, layerSurface->size.y * layerSurface->output->scale, 0, 0);
-
- if (layerSurface->frameCallback) {
- wl_callback_destroy(layerSurface->frameCallback);
- layerSurface->frameCallback = nullptr;
- }
-
- wallpaperApplication->getOutput()->reset();
-
- layerSurface->output->rendering = true;
- wallpaperApplication->renderFrame();
- layerSurface->output->rendering = false;
- }
-}
-
-uint32_t CWaylandOpenGLDriver::getFrameCounter () const {
+uint32_t CWaylandOpenGLDriver::getFrameCounter () const
+{
return m_frameCounter;
}
-GLFWwindow* CWaylandOpenGLDriver::getWindow () {
- return nullptr;
+CWaylandOpenGLDriver::SEGLContext* CWaylandOpenGLDriver::getEGLContext ()
+{
+ return &this->m_eglContext;
}
-#include
-
-void CWaylandOpenGLDriver::makeCurrent(const std::string& outputName) const {
- for (auto& o : m_outputs) {
- if (o->name != outputName)
- continue;
-
- if (eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context) == EGL_FALSE) {
- std::cerr << "Couldn't make egl current";
- }
- }
+CWaylandOpenGLDriver::SWaylandContext* CWaylandOpenGLDriver::getWaylandContext ()
+{
+ return &this->m_waylandContext;
}
-CLayerSurface* CWaylandOpenGLDriver::surfaceToLS(wl_surface* surface) {
- for (auto& o : m_outputs) {
- if (!o->layerSurface.get())
- continue;
-
- if (o->layerSurface->surface == surface)
- return o->layerSurface.get();
+Output::CWaylandOutputViewport* CWaylandOpenGLDriver::surfaceToViewport(wl_surface* surface)
+{
+ for (auto& o : m_screens)
+ {
+ if (o->surface == surface)
+ return o;
}
return nullptr;
}
-
-bool CWaylandOpenGLDriver::shouldRenderOutput(const std::string& outputName) const {
- for (auto& o : m_outputs) {
- if (o->name == outputName)
- return o->layerSurface.get() && (o->rendering || !o->layerSurface->callbackInitialized);
- }
-
- return false;
-}
-
-bool CWaylandOpenGLDriver::requiresSeparateFlips() const {
- return true;
-}
-
-void CWaylandOpenGLDriver::swapOutputBuffer(const std::string& outputName) {
- for (auto& o : m_outputs) {
- if (o->name != outputName)
- continue;
-
- o->layerSurface->callbackInitialized = true;
-
- eglMakeCurrent(eglContext.display, o->layerSurface->eglSurface, o->layerSurface->eglSurface, eglContext.context);
- o->layerSurface->frameCallback = wl_surface_frame(o->layerSurface->surface);
- wl_callback_add_listener(o->layerSurface->frameCallback, &frameListener, o->layerSurface.get());
- eglSwapBuffers(eglContext.display, o->layerSurface->eglSurface);
- wl_surface_set_buffer_scale(o->layerSurface->surface, o->scale);
- wl_surface_damage_buffer(o->layerSurface->surface, 0, 0, INT32_MAX, INT32_MAX);
- wl_surface_commit(o->layerSurface->surface);
-
- m_frameCounter++;
- }
-}
-
-std::string CWaylandOpenGLDriver::getCurrentlyRendered() const {
- for (auto& o : m_outputs) {
- if (o->rendering)
- return o->name;
- }
-
- return "";
-}
diff --git a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
index b49c84e..6e181a4 100644
--- a/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
@@ -9,6 +9,9 @@
#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
#include "WallpaperEngine/Application/CApplicationContext.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h"
+#include "WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h"
+#include "WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h"
namespace WallpaperEngine::Application
{
@@ -16,56 +19,54 @@ namespace WallpaperEngine::Application
class CWallpaperApplication;
}
-struct GLFWwindow;
-typedef GLFWwindow GLFWWindow;
+namespace WallpaperEngine::Input::Drivers
+{
+ class CWaylandMouseInput;
+}
+
struct zwlr_layer_shell_v1;
struct zwlr_layer_surface_v1;
namespace WallpaperEngine::Render::Drivers
{
using namespace WallpaperEngine::Application;
+ using namespace WallpaperEngine::Input::Drivers;
class CWaylandOpenGLDriver;
- class CLayerSurface;
- struct SWaylandOutput {
- wl_output* output;
- std::string name;
- glm::ivec2 size;
- glm::ivec2 lsSize;
- uint32_t waylandName;
- int scale = 1;
- CWaylandOpenGLDriver* driver = nullptr;
- bool initialized = false;
- std::unique_ptr layerSurface;
- bool rendering = false;
- };
-
- class CLayerSurface {
- public:
- CLayerSurface(CWaylandOpenGLDriver*, SWaylandOutput*);
- ~CLayerSurface();
-
- wl_egl_window* eglWindow = nullptr;
- EGLSurface eglSurface = nullptr;
- wl_surface* surface = nullptr;
- zwlr_layer_surface_v1* layerSurface = nullptr;
- glm::ivec2 size;
- wl_callback* frameCallback = nullptr;
- SWaylandOutput* output = nullptr;
- glm::dvec2 mousePos = {0, 0};
- wl_cursor* pointer = nullptr;
- wl_surface* cursorSurface = nullptr;
- bool callbackInitialized = false;
- float lastTime, minimumTime;
- };
+ namespace Output
+ {
+ class CWaylandOutputViewport;
+ class CWaylandOutput;
+ }
class CWaylandOpenGLDriver : public CVideoDriver
{
+ friend class Output::CWaylandOutput;
+ friend class CWaylandMouseInput;
public:
- explicit CWaylandOpenGLDriver (const char* windowTitle, CApplicationContext& context, CWallpaperApplication* app);
+ struct SEGLContext
+ {
+ EGLDisplay display = nullptr;
+ EGLConfig config = nullptr;
+ EGLContext context = nullptr;
+ PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC eglCreatePlatformWindowSurfaceEXT = nullptr;
+ };
+
+ struct SWaylandContext
+ {
+ wl_display* display = nullptr;
+ wl_registry* registry = nullptr;
+ wl_compositor* compositor = nullptr;
+ wl_shm* shm = nullptr;
+ zwlr_layer_shell_v1* layerShell = nullptr;
+ wl_seat* seat = nullptr;
+ };
+
+ explicit CWaylandOpenGLDriver (CApplicationContext& context, CWallpaperApplication& app);
~CWaylandOpenGLDriver();
- void* getWindowHandle () const;
+ [[nodiscard]] Detectors::CFullScreenDetector& getFullscreenDetector () override;
+ [[nodiscard]] Output::COutput& getOutput () override;
float getRenderTime () const override;
bool closeRequested () override;
void resizeWindow (glm::ivec2 size) override;
@@ -76,49 +77,34 @@ namespace WallpaperEngine::Render::Drivers
void swapBuffers () override;
uint32_t getFrameCounter () const override;
void dispatchEventQueue() const override;
- void makeCurrent(const std::string& outputName) const override;
- bool shouldRenderOutput(const std::string& outputName) const override;
- bool requiresSeparateFlips() const override;
- void swapOutputBuffer(const std::string& outputName) override;
- std::string getCurrentlyRendered() const override;
- GLFWwindow* getWindow ();
+ void onLayerClose(Output::CWaylandOutputViewport*);
+ Output::CWaylandOutputViewport* surfaceToViewport(wl_surface*);
- struct {
- wl_display* display = nullptr;
- wl_registry* registry = nullptr;
- wl_compositor* compositor = nullptr;
- wl_shm* shm = nullptr;
- zwlr_layer_shell_v1* layerShell = nullptr;
- wl_seat* seat = nullptr;
- } waylandContext;
+ Output::CWaylandOutputViewport* viewportInFocus = nullptr;
- void onLayerClose(CLayerSurface*);
- void resizeLSSurfaceEGL(CLayerSurface*);
- CLayerSurface* surfaceToLS(wl_surface*);
+ [[nodiscard]] SEGLContext* getEGLContext ();
+ [[nodiscard]] SWaylandContext* getWaylandContext ();
- std::vector> m_outputs;
- CWallpaperApplication* wallpaperApplication;
-
- struct {
- EGLDisplay display = nullptr;
- EGLConfig config = nullptr;
- EGLContext context = nullptr;
- PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC eglCreatePlatformWindowSurfaceEXT = nullptr;
- } eglContext;
-
- CLayerSurface* lastLSInFocus = nullptr;
+ /** List of available screens */
+ std::vector m_screens;
private:
+ /** Fullscreen detection used by this driver */
+ Detectors::CWaylandFullScreenDetector m_fullscreenDetector;
+ /** The output used by the driver */
+ Output::CWaylandOutput m_output;
+ /** The EGL context in use */
+ SEGLContext m_eglContext;
+ /** The Wayland context in use */
+ SWaylandContext m_waylandContext;
+
void initEGL();
void finishEGL();
uint32_t m_frameCounter;
std::chrono::high_resolution_clock::time_point renderStart = std::chrono::high_resolution_clock::now();
-
- friend class CWaylandOutput;
- friend class CWallpaperApplication;
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp b/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp
index 28038a6..3abe372 100644
--- a/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp
+++ b/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.cpp
@@ -1,5 +1,6 @@
#include "CX11OpenGLDriver.h"
#include "common.h"
+#include "WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h"
#include
#define GLFW_EXPOSE_NATIVE_X11
@@ -12,8 +13,11 @@ void CustomGLFWErrorHandler (int errorCode, const char* reason)
sLog.error ("GLFW error ", errorCode, ": ", reason);
}
-CX11OpenGLDriver::CX11OpenGLDriver (const char* windowTitle, CApplicationContext& context) :
- m_frameCounter (0)
+CX11OpenGLDriver::CX11OpenGLDriver (const char* windowTitle, CApplicationContext& context, CWallpaperApplication& app) :
+ m_frameCounter (0),
+ m_fullscreenDetector (context, *this),
+ m_context (context),
+ CVideoDriver (app)
{
glfwSetErrorCallback (CustomGLFWErrorHandler);
@@ -60,6 +64,17 @@ CX11OpenGLDriver::CX11OpenGLDriver (const char* windowTitle, CApplicationContext
// initialize free image
FreeImage_Initialise (TRUE);
+
+ // setup output
+ if (context.settings.render.mode == CApplicationContext::EXPLICIT_WINDOW ||
+ context.settings.render.mode == CApplicationContext::NORMAL_WINDOW)
+ {
+ m_output = new WallpaperEngine::Render::Drivers::Output::CGLFWWindowOutput (context, *this);
+ }
+ else
+ {
+ m_output = new WallpaperEngine::Render::Drivers::Output::CX11Output (context, *this);
+ }
}
CX11OpenGLDriver::~CX11OpenGLDriver ()
@@ -68,9 +83,14 @@ CX11OpenGLDriver::~CX11OpenGLDriver ()
FreeImage_DeInitialise();
}
-void* CX11OpenGLDriver::getWindowHandle () const
+Detectors::CFullScreenDetector& CX11OpenGLDriver::getFullscreenDetector ()
{
- return reinterpret_cast (glfwGetX11Window (this->m_window));
+ return this->m_fullscreenDetector;
+}
+
+Output::COutput& CX11OpenGLDriver::getOutput ()
+{
+ return *this->m_output;
}
float CX11OpenGLDriver::getRenderTime () const
@@ -128,6 +148,20 @@ uint32_t CX11OpenGLDriver::getFrameCounter () const
return this->m_frameCounter;
}
+void CX11OpenGLDriver::dispatchEventQueue() const
+{
+ static float startTime, endTime, minimumTime = 1.0f / this->m_context.settings.render.maximumFPS;
+ // get the start time of the frame
+ startTime = this->getRenderTime ();
+ this->getApp ().update ();
+ // get the end time of the frame
+ endTime = this->getRenderTime ();
+
+ // ensure the frame time is correct to not overrun FPS
+ if ((endTime - startTime) < minimumTime)
+ usleep ((minimumTime - (endTime - startTime)) * CLOCKS_PER_SEC);
+}
+
GLFWwindow* CX11OpenGLDriver::getWindow ()
{
return this->m_window;
diff --git a/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h b/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h
index 99ca118..bcae385 100644
--- a/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h
+++ b/src/WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h
@@ -4,10 +4,15 @@
#include
#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
#include "WallpaperEngine/Application/CApplicationContext.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h"
+#include "WallpaperEngine/Render/Drivers/Output/CX11Output.h"
+#include "WallpaperEngine/Application/CWallpaperApplication.h"
namespace WallpaperEngine::Application
{
class CApplicationContext;
+ class CWallpaperApplication;
}
namespace WallpaperEngine::Render::Drivers
@@ -17,23 +22,28 @@ namespace WallpaperEngine::Render::Drivers
class CX11OpenGLDriver : public CVideoDriver
{
public:
- explicit CX11OpenGLDriver (const char* windowTitle, CApplicationContext& context);
+ explicit CX11OpenGLDriver (const char* windowTitle, CApplicationContext& context, CWallpaperApplication& app);
~CX11OpenGLDriver();
- void* getWindowHandle () const;
- float getRenderTime () const override;
+ [[nodiscard]] Detectors::CFullScreenDetector& getFullscreenDetector () override;
+ [[nodiscard]] Output::COutput& getOutput () override;
+ [[nodiscard]] float getRenderTime () const override;
bool closeRequested () override;
void resizeWindow (glm::ivec2 size) override;
void resizeWindow (glm::ivec4 sizeandpos) override;
void showWindow () override;
void hideWindow () override;
- glm::ivec2 getFramebufferSize () const override;
+ [[nodiscard]] glm::ivec2 getFramebufferSize () const override;
void swapBuffers () override;
- uint32_t getFrameCounter () const override;
+ [[nodiscard]] uint32_t getFrameCounter () const override;
+ void dispatchEventQueue() const override;
GLFWwindow* getWindow ();
private:
+ Detectors::CX11FullScreenDetector m_fullscreenDetector;
+ CApplicationContext& m_context;
+ Output::COutput* m_output;
GLFWwindow* m_window;
uint32_t m_frameCounter;
};
diff --git a/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp b/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp
index 3896c18..2625e91 100644
--- a/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp
@@ -3,8 +3,8 @@
using namespace WallpaperEngine::Render::Drivers::Detectors;
CWaylandFullScreenDetector::CWaylandFullScreenDetector (Application::CApplicationContext& appContext, CWaylandOpenGLDriver& driver) :
- CFullScreenDetector (appContext) {
- ;
+ CFullScreenDetector (appContext)
+{
}
CWaylandFullScreenDetector::~CWaylandFullScreenDetector () {
diff --git a/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h b/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h
index d4ec1e7..edd06f1 100644
--- a/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h
+++ b/src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h
@@ -6,19 +6,21 @@
#include "CFullScreenDetector.h"
#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
-#include "WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h"
-namespace WallpaperEngine::Render::Drivers::Detectors
+namespace WallpaperEngine::Render::Drivers
{
- class CWaylandFullScreenDetector : public CFullScreenDetector
+ class CWaylandOpenGLDriver;
+
+ namespace Detectors
{
- public:
- CWaylandFullScreenDetector (Application::CApplicationContext& appContext, CWaylandOpenGLDriver& driver);
- ~CWaylandFullScreenDetector ();
+ class CWaylandFullScreenDetector : public CFullScreenDetector
+ {
+ public:
+ CWaylandFullScreenDetector (Application::CApplicationContext& appContext, CWaylandOpenGLDriver& driver);
+ ~CWaylandFullScreenDetector ();
- [[nodiscard]] bool anythingFullscreen () const override;
- void reset () override;
-
- private:
- };
+ [[nodiscard]] bool anythingFullscreen () const override;
+ void reset () override;
+ };
+ }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp b/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
index 849e368..2ce526f 100644
--- a/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
@@ -4,6 +4,7 @@
#include
#include
+#include "WallpaperEngine/Render/Drivers/CX11OpenGLDriver.h"
namespace WallpaperEngine::Render::Drivers::Detectors
{
@@ -31,7 +32,7 @@ namespace WallpaperEngine::Render::Drivers::Detectors
return 0;
}
- CX11FullScreenDetector::CX11FullScreenDetector (Application::CApplicationContext& appContext, CVideoDriver& driver) :
+ CX11FullScreenDetector::CX11FullScreenDetector (Application::CApplicationContext& appContext, CX11OpenGLDriver& driver) :
CFullScreenDetector (appContext),
m_driver (driver)
{
@@ -67,7 +68,7 @@ namespace WallpaperEngine::Render::Drivers::Detectors
if (!XQueryTree (this->m_display, this->m_root, &_, &_, &children, &nchildren))
return false;
- auto ourWindow = reinterpret_cast (this->m_driver.getWindowHandle ());
+ auto ourWindow = reinterpret_cast (this->m_driver.getWindow ());
Window parentWindow;
{
diff --git a/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h b/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
index 272e680..dd5b73a 100644
--- a/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
+++ b/src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
@@ -5,34 +5,37 @@
#include
#include "CFullScreenDetector.h"
-#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
-
#include
-namespace WallpaperEngine::Render::Drivers::Detectors
+namespace WallpaperEngine::Render::Drivers
{
- class CX11FullScreenDetector : public CFullScreenDetector
+ class CX11OpenGLDriver;
+
+ namespace Detectors
{
- public:
- CX11FullScreenDetector (Application::CApplicationContext& appContext, CVideoDriver& driver);
- ~CX11FullScreenDetector ();
-
- [[nodiscard]] bool anythingFullscreen () const override;
- void reset () override;
-
- private:
- void initialize ();
- void stop ();
-
- struct ScreenInfo
+ class CX11FullScreenDetector : public CFullScreenDetector
{
- glm::ivec4 viewport;
- std::string name;
- };
+ public:
+ CX11FullScreenDetector (Application::CApplicationContext& appContext, CX11OpenGLDriver& driver);
+ ~CX11FullScreenDetector ();
- Display* m_display;
- Window m_root;
- std::vector m_screens;
- CVideoDriver& m_driver;
- };
+ [[nodiscard]] bool anythingFullscreen () const override;
+ void reset () override;
+
+ private:
+ void initialize ();
+ void stop ();
+
+ struct ScreenInfo
+ {
+ glm::ivec4 viewport;
+ std::string name;
+ };
+
+ Display* m_display;
+ Window m_root;
+ std::vector m_screens;
+ CX11OpenGLDriver& m_driver;
+ };
+ }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
index 4b10aa4..7994f4f 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
@@ -1,6 +1,7 @@
#include
#include "CGLFWWindowOutput.h"
#include "WallpaperEngine/Logging/CLog.h"
+#include "CX11OutputViewport.h"
#include
@@ -8,9 +9,8 @@
using namespace WallpaperEngine::Render::Drivers::Output;
-CGLFWWindowOutput::CGLFWWindowOutput (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector) :
- COutput (context, detector),
- m_driver (driver)
+CGLFWWindowOutput::CGLFWWindowOutput (CApplicationContext& context, CVideoDriver& driver) :
+ COutput (context, driver)
{
if (
this->m_context.settings.render.mode != Application::CApplicationContext::NORMAL_WINDOW &&
@@ -34,7 +34,7 @@ CGLFWWindowOutput::CGLFWWindowOutput (CApplicationContext& context, CVideoDriver
}
// register the default viewport
- this->m_viewports ["default"] = {{0, 0, this->m_fullWidth, this->m_fullHeight}, "default"};
+ this->m_viewports ["default"] = new CX11OutputViewport {{0, 0, this->m_fullWidth, this->m_fullHeight}, "default"};
}
void CGLFWWindowOutput::repositionWindow ()
@@ -78,9 +78,9 @@ void CGLFWWindowOutput::updateRender () const
this->m_fullHeight = this->m_driver.getFramebufferSize ().y;
// update the default viewport
- this->m_viewports ["default"] = {{0, 0, this->m_fullWidth, this->m_fullHeight}, "default"};
+ this->m_viewports ["default"]->viewport = {0, 0, this->m_fullWidth, this->m_fullHeight};
// check for fullscreen windows and wait until there's none fullscreen
- while (this->m_detector.anythingFullscreen () && this->m_context.state.general.keepRunning)
+ while (this->m_driver.getFullscreenDetector ().anythingFullscreen () && this->m_context.state.general.keepRunning)
usleep (FULLSCREEN_CHECK_WAIT_TIME);
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h b/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
index 7486cc6..099903a 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
+++ b/src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
@@ -8,7 +8,7 @@ namespace WallpaperEngine::Render::Drivers::Output
class CGLFWWindowOutput : public COutput
{
public:
- CGLFWWindowOutput (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector);
+ CGLFWWindowOutput (CApplicationContext& context, CVideoDriver& driver);
void reset () override;
bool renderVFlip () const override;
@@ -19,7 +19,5 @@ namespace WallpaperEngine::Render::Drivers::Output
private:
void repositionWindow ();
-
- CVideoDriver& m_driver;
};
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/COutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/COutput.cpp
index ab3a4e7..6b514dc 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/COutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/COutput.cpp
@@ -2,13 +2,13 @@
using namespace WallpaperEngine::Render::Drivers::Output;
-COutput::COutput (CApplicationContext& context, Detectors::CFullScreenDetector& detector) :
+COutput::COutput (CApplicationContext& context, CVideoDriver& driver) :
m_context (context),
- m_detector (detector)
+ m_driver (driver)
{
}
-const std::map & COutput::getViewports () const
+const std::map & COutput::getViewports () const
{
return this->m_viewports;
}
diff --git a/src/WallpaperEngine/Render/Drivers/Output/COutput.h b/src/WallpaperEngine/Render/Drivers/Output/COutput.h
index 79330fd..cabf9d2 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/COutput.h
+++ b/src/WallpaperEngine/Render/Drivers/Output/COutput.h
@@ -14,41 +14,42 @@ namespace WallpaperEngine::Application
class CApplicationContext;
}
-namespace WallpaperEngine::Render::Drivers::Detectors
+namespace WallpaperEngine::Render::Drivers
{
- class CFullScreenDetector;
-}
+ class CVideoDriver;
-namespace WallpaperEngine::Render::Drivers::Output
-{
- class COutput
+ namespace Detectors
{
- public:
- COutput (CApplicationContext& context, Detectors::CFullScreenDetector& detector);
+ class CFullScreenDetector;
+ }
- virtual void reset () = 0;
+ namespace Output
+ {
+ class COutputViewport;
- int getFullWidth () const;
- int getFullHeight () const;
-
- struct ScreenInfo
+ class COutput
{
- glm::ivec4 viewport;
- std::string name;
+ public:
+ COutput (CApplicationContext& context, CVideoDriver& driver);
+
+ virtual void reset () = 0;
+
+ int getFullWidth () const;
+ int getFullHeight () const;
+
+ virtual bool renderVFlip () const = 0;
+ virtual bool renderMultiple () const = 0;
+ virtual bool haveImageBuffer () const = 0;
+ const std::map & getViewports () const;
+ virtual void* getImageBuffer () const = 0;
+ virtual void updateRender () const = 0;
+
+ protected:
+ mutable int m_fullWidth;
+ mutable int m_fullHeight;
+ mutable std::map m_viewports;
+ CApplicationContext& m_context;
+ CVideoDriver& m_driver;
};
-
- virtual bool renderVFlip () const = 0;
- virtual bool renderMultiple () const = 0;
- virtual bool haveImageBuffer () const = 0;
- const std::map & getViewports () const;
- virtual void* getImageBuffer () const = 0;
- virtual void updateRender () const = 0;
-
- protected:
- mutable int m_fullWidth;
- mutable int m_fullHeight;
- mutable std::map m_viewports;
- CApplicationContext& m_context;
- Detectors::CFullScreenDetector& m_detector;
- };
+ }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp b/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp
new file mode 100644
index 0000000..11abc8b
--- /dev/null
+++ b/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp
@@ -0,0 +1,16 @@
+#include "COutputViewport.h"
+
+#include
+
+using namespace WallpaperEngine::Render::Drivers::Output;
+
+COutputViewport::COutputViewport (glm::ivec4 viewport, std::string name, bool single) :
+ viewport (viewport),
+ name (std::move(name)),
+ single (single)
+{
+}
+
+COutputViewport::~COutputViewport ()
+{
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h b/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h
new file mode 100644
index 0000000..3e5ce4a
--- /dev/null
+++ b/src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include
+#include
+
+namespace WallpaperEngine::Render::Drivers::Output
+{
+ class COutputViewport
+ {
+ public:
+ COutputViewport (glm::ivec4 viewport, std::string name, bool single = false);
+ virtual ~COutputViewport ();
+
+ glm::ivec4 viewport;
+ std::string name;
+
+ /** Whether this viewport is single in the framebuffer or shares space with more viewports */
+ bool single;
+
+ /**
+ * Activates output's context for drawing
+ */
+ virtual void makeCurrent () = 0;
+
+ /**
+ * Swaps buffers to present data on the viewport
+ */
+ virtual void swapOutput () = 0;
+ };
+}
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
index a55ed71..2d846b9 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
@@ -4,9 +4,8 @@
using namespace WallpaperEngine::Render::Drivers::Output;
-CWaylandOutput::CWaylandOutput (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector) :
- COutput (context, detector),
- m_driver (driver)
+CWaylandOutput::CWaylandOutput (CApplicationContext& context, CWaylandOpenGLDriver& driver) :
+ COutput (context, driver)
{
updateViewports();
}
@@ -15,15 +14,17 @@ CWaylandOutput::~CWaylandOutput ()
{
}
-void CWaylandOutput::updateViewports() {
+void CWaylandOutput::updateViewports()
+{
m_viewports.clear();
const auto PDRIVER = (CWaylandOpenGLDriver*)&m_driver;
glm::ivec2 fullw = {0,0};
- for (auto& o : PDRIVER->m_outputs) {
- if (!o->layerSurface.get())
+ for (auto& o : PDRIVER->m_screens)
+ {
+ if (!o->layerSurface)
continue;
- m_viewports[o->name] = {{0, 0, o->lsSize.x * o->scale, o->lsSize.y * o->scale}, o->name};
+ m_viewports[o->name] = o;
fullw = fullw + glm::ivec2{o->lsSize.x * o->scale, 0};
if (o->lsSize.y > fullw.y)
@@ -34,26 +35,31 @@ void CWaylandOutput::updateViewports() {
m_fullHeight = fullw.y;
}
-void CWaylandOutput::reset () {
+void CWaylandOutput::reset ()
+{
updateViewports();
}
-bool CWaylandOutput::renderVFlip () const {
+bool CWaylandOutput::renderVFlip () const
+{
return true;
}
-bool CWaylandOutput::renderMultiple () const {
+bool CWaylandOutput::renderMultiple () const
+{
return false; // todo
}
-bool CWaylandOutput::haveImageBuffer () const {
+bool CWaylandOutput::haveImageBuffer () const
+{
return false;
}
-void* CWaylandOutput::getImageBuffer () const {
+void* CWaylandOutput::getImageBuffer () const
+{
return nullptr;
}
-void CWaylandOutput::updateRender () const {
- ;
+void CWaylandOutput::updateRender () const
+{
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
index 1ab26bf..43ad220 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
@@ -7,25 +7,28 @@
#include "WallpaperEngine/Render/Drivers/CVideoDriver.h"
#include "COutput.h"
-namespace WallpaperEngine::Render::Drivers::Output
+namespace WallpaperEngine::Render::Drivers
{
- class CWaylandOutput : public COutput
+ class CWaylandOpenGLDriver;
+
+ namespace Output
{
- public:
- CWaylandOutput (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector);
- ~CWaylandOutput ();
+ class CWaylandOutput : public COutput
+ {
+ public:
+ CWaylandOutput (CApplicationContext& context, CWaylandOpenGLDriver& driver);
+ ~CWaylandOutput ();
- void reset () override;
+ void reset () override;
- bool renderVFlip () const override;
- bool renderMultiple () const override;
- bool haveImageBuffer () const override;
- void* getImageBuffer () const override;
- void updateRender () const override;
+ bool renderVFlip () const override;
+ bool renderMultiple () const override;
+ bool haveImageBuffer () const override;
+ void* getImageBuffer () const override;
+ void updateRender () const override;
- private:
- void updateViewports();
-
- CVideoDriver& m_driver;
- };
+ private:
+ void updateViewports();
+ };
+ }
}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp
new file mode 100644
index 0000000..54a7e6f
--- /dev/null
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp
@@ -0,0 +1,236 @@
+#include "WallpaperEngine/Application/CWallpaperApplication.h"
+#include "CWaylandOutputViewport.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+#define class _class
+#define namespace _namespace
+#define static
+extern "C" {
+#include "xdg-shell-protocol.h"
+#include "wlr-layer-shell-unstable-v1-protocol.h"
+}
+#undef class
+#undef namespace
+#undef static
+
+using namespace WallpaperEngine::Render::Drivers;
+using namespace WallpaperEngine::Render::Drivers::Output;
+
+static void handleLSConfigure(void *data, zwlr_layer_surface_v1 *surface, uint32_t serial, uint32_t w, uint32_t h)
+{
+ const auto viewport = static_cast (data);
+ viewport->size = {w, h};
+ viewport->viewport = {0, 0, viewport->size.x * viewport->scale, viewport->size.y * viewport->scale};
+ viewport->resize ();
+
+ zwlr_layer_surface_v1_ack_configure(surface, serial);
+}
+
+static void handleLSClosed(void *data, zwlr_layer_surface_v1 *surface)
+{
+ const auto viewport = static_cast (data);
+
+ viewport->getDriver ()->onLayerClose(viewport);
+}
+
+static void geometry(
+ void* data, wl_output* output, int32_t x, int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel,
+ const char* make, const char* model, int32_t transform
+)
+{
+ // ignored
+}
+
+static void mode(void* data, wl_output* output, uint32_t flags, int32_t width, int32_t height, int32_t refresh)
+{
+ const auto viewport = static_cast (data);
+
+ // update viewport size too
+ viewport->size = {width, height};
+ viewport->viewport = {0, 0, viewport->size.x * viewport->scale, viewport->size.y * viewport->scale};
+
+ if (viewport->layerSurface)
+ viewport->resize ();
+
+ if (viewport->initialized)
+ viewport->getDriver ()->getOutput ().reset ();
+}
+
+static void done(void* data, wl_output* wl_output)
+{
+ static_cast (data)->initialized = true;
+}
+
+static void scale(void* data, wl_output* wl_output, int32_t scale)
+{
+ const auto viewport = static_cast (data);
+
+ viewport->scale = scale;
+
+ if (viewport->layerSurface)
+ viewport->resize ();
+
+ if (viewport->initialized)
+ viewport->getDriver ()->getOutput ().reset ();
+}
+
+static void name(void* data, wl_output* wl_output, const char* name)
+{
+ const auto viewport = static_cast (data);
+
+ if (name)
+ viewport->name = name;
+
+ // ensure the output is updated with the new name too
+ viewport->getDriver ()->getOutput ().reset ();
+}
+
+static void description(void* data, wl_output* wl_output, const char* description)
+{
+ // ignored
+}
+
+static void surfaceFrameCallback(void *data, struct wl_callback *cb, uint32_t time)
+{
+ const auto viewport = static_cast (data);
+
+ wl_callback_destroy(cb);
+
+ viewport->frameCallback = nullptr;
+ viewport->rendering = true;
+ viewport->getDriver ()->getApp ().update ();
+ viewport->rendering = false;
+
+ float renderTime = viewport->getDriver ()->getRenderTime();
+
+ if ((renderTime - viewport->lastTime) < viewport->minimumTime)
+ usleep ((viewport->minimumTime - (renderTime - viewport->lastTime)) * CLOCKS_PER_SEC);
+
+ viewport->lastTime = renderTime;
+}
+
+const struct wl_callback_listener frameListener = {
+ .done = surfaceFrameCallback
+};
+
+const wl_output_listener outputListener =
+{
+ .geometry = geometry,
+ .mode = mode,
+ .done = done,
+ .scale = scale,
+ .name = name,
+ .description = description
+};
+
+const struct zwlr_layer_surface_v1_listener layerSurfaceListener = {
+ .configure = handleLSConfigure,
+ .closed = handleLSClosed,
+};
+
+CWaylandOutputViewport::CWaylandOutputViewport (CWaylandOpenGLDriver* driver, uint32_t waylandName, struct wl_registry *registry) :
+ m_driver (driver),
+ waylandName (waylandName),
+ COutputViewport ({0,0,0,0}, "", true)
+{
+ // setup output listener
+ this->output = (wl_output*) wl_registry_bind(registry, waylandName, &wl_output_interface, 4);
+ this->name = "";
+ this->size = {0, 0};
+ wl_output_add_listener(output, &outputListener, this);
+}
+
+void CWaylandOutputViewport::setupLS ()
+{
+ surface = wl_compositor_create_surface(m_driver->getWaylandContext()->compositor);
+ layerSurface = zwlr_layer_shell_v1_get_layer_surface(m_driver->getWaylandContext()->layerShell, surface, this->output, ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "linux-wallpaperengine");
+
+ if (!layerSurface)
+ sLog.exception("Failed to get a layer surface");
+
+ wl_region* region = wl_compositor_create_region(m_driver->getWaylandContext()->compositor);
+ wl_region_add(region, 0, 0, INT32_MAX, INT32_MAX);
+
+ zwlr_layer_surface_v1_set_size(layerSurface, 0, 0);
+ zwlr_layer_surface_v1_set_anchor(layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
+ zwlr_layer_surface_v1_set_keyboard_interactivity(layerSurface, false);
+ zwlr_layer_surface_v1_add_listener(layerSurface, &layerSurfaceListener, this);
+ zwlr_layer_surface_v1_set_exclusive_zone(layerSurface, -1);
+ wl_surface_set_input_region(surface, region);
+ wl_surface_commit(surface);
+ wl_display_roundtrip(m_driver->getWaylandContext()->display);
+
+ eglWindow = wl_egl_window_create(surface, size.x * scale, size.y * scale);
+ eglSurface = m_driver->getEGLContext ()->eglCreatePlatformWindowSurfaceEXT(m_driver->getEGLContext ()->display, m_driver->getEGLContext ()->config, eglWindow, nullptr);
+ lsSize = size;
+ wl_surface_commit(surface);
+ wl_display_roundtrip(m_driver->getWaylandContext()->display);
+ wl_display_flush(m_driver->getWaylandContext()->display);
+
+ static const auto XCURSORSIZE = getenv("XCURSOR_SIZE") ? std::stoi(getenv("XCURSOR_SIZE")) : 24;
+ const auto PRCURSORTHEME = wl_cursor_theme_load(getenv("XCURSOR_THEME"), XCURSORSIZE * scale, m_driver->getWaylandContext()->shm);
+
+ if (!PRCURSORTHEME)
+ sLog.exception("Failed to get a cursor theme");
+
+ pointer = wl_cursor_theme_get_cursor(PRCURSORTHEME, "left_ptr");
+ cursorSurface = wl_compositor_create_surface(m_driver->getWaylandContext()->compositor);
+
+ if (!cursorSurface)
+ sLog.exception("Failed to get a cursor surface");
+
+ if (eglMakeCurrent(m_driver->getEGLContext ()->display, eglSurface, eglSurface, m_driver->getEGLContext ()->context) == EGL_FALSE)
+ sLog.exception("Failed to make egl current");
+
+ minimumTime = 1.0f / m_driver->getApp ().getContext().settings.render.maximumFPS;
+
+ // reset the output to notice the new viewport
+ m_driver->getOutput ().reset ();
+}
+
+CWaylandOpenGLDriver* CWaylandOutputViewport::getDriver ()
+{
+ return this->m_driver;
+}
+
+void CWaylandOutputViewport::makeCurrent ()
+{
+ EGLBoolean result = eglMakeCurrent (
+ m_driver->getEGLContext ()->display,
+ eglSurface,
+ eglSurface,
+ m_driver->getEGLContext ()->context
+ );
+
+ if (result == EGL_FALSE)
+ sLog.error ("Couldn't make egl current");
+}
+
+void CWaylandOutputViewport::swapOutput ()
+{
+ this->callbackInitialized = true;
+
+ this->makeCurrent ();
+ frameCallback = wl_surface_frame (surface);
+ wl_callback_add_listener (frameCallback, &frameListener, this);
+ eglSwapBuffers (m_driver->getEGLContext ()->display, this->eglSurface);
+ wl_surface_set_buffer_scale(surface, scale);
+ wl_surface_damage_buffer(surface, 0, 0, INT32_MAX, INT32_MAX);
+ wl_surface_commit(surface);
+}
+
+void CWaylandOutputViewport::resize ()
+{
+ if (!this->eglWindow)
+ return;
+
+ wl_egl_window_resize(this->eglWindow, this->size.x * this->scale, this->size.y * this->scale, 0, 0);
+
+ if (this->frameCallback)
+ {
+ wl_callback_destroy(this->frameCallback);
+ this->frameCallback = nullptr;
+ }
+
+ this->getDriver ()->getOutput().reset();
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h
new file mode 100644
index 0000000..a62cb60
--- /dev/null
+++ b/src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include "COutputViewport.h"
+#include "../CWaylandOpenGLDriver.h"
+
+struct zwlr_layer_shell_v1;
+struct zwlr_layer_surface_v1;
+
+namespace WallpaperEngine::Render::Drivers
+{
+ class CWaylandOpenGLDriver;
+
+ namespace Output
+ {
+ class COutputViewport;
+
+ class CWaylandOutputViewport : public COutputViewport
+ {
+ public:
+ CWaylandOutputViewport (CWaylandOpenGLDriver* driver, uint32_t waylandName, struct wl_registry *registry);
+
+ /**
+ * @return The wayland driver
+ */
+ CWaylandOpenGLDriver* getDriver ();
+
+ wl_output* output;
+ glm::ivec2 size;
+ glm::ivec2 lsSize;
+ uint32_t waylandName;
+ int scale = 1;
+ bool initialized = false;
+ bool rendering = false;
+
+ wl_egl_window* eglWindow = nullptr;
+ EGLSurface eglSurface = nullptr;
+ wl_surface* surface = nullptr;
+ zwlr_layer_surface_v1* layerSurface = nullptr;
+ wl_callback* frameCallback = nullptr;
+ glm::dvec2 mousePos = {0, 0};
+ wl_cursor* pointer = nullptr;
+ wl_surface* cursorSurface = nullptr;
+ bool callbackInitialized = false;
+ float lastTime, minimumTime;
+
+ void setupLS ();
+
+ /**
+ * Activates output's context for drawing
+ */
+ void makeCurrent () override;
+
+ /**
+ * Swaps buffers to present data on the viewport
+ */
+ void swapOutput () override;
+
+ /**
+ * Updates the viewport size
+ */
+ void resize ();
+
+ private:
+ CWaylandOpenGLDriver* m_driver;
+ };
+ }
+}
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp b/src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
index aadfa0d..79be24b 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
+++ b/src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
@@ -1,5 +1,6 @@
#include "common.h"
#include "CX11Output.h"
+#include "CX11OutputViewport.h"
#include
#include
@@ -34,9 +35,8 @@ int CustomXIOErrorHandler (Display* dsp)
return 0;
}
-CX11Output::CX11Output (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector) :
- COutput (context, detector),
- m_driver (driver)
+CX11Output::CX11Output (CApplicationContext& context, CVideoDriver& driver) :
+ COutput (context, driver)
{
// do not use previous handler, it might stop the app under weird circumstances
XSetErrorHandler (CustomXErrorHandler);
@@ -57,11 +57,17 @@ void CX11Output::reset ()
// re-load screen info
this->loadScreenInfo ();
// do the same for the detector
- this->m_detector.reset ();
+ this->m_driver.getFullscreenDetector ().reset ();
}
void CX11Output::free ()
{
+ // go through all the viewports and free them
+ for(const auto& cur : this->m_viewports)
+ delete cur.second;
+
+ this->m_viewports.clear ();
+
// free all the resources we've got
XDestroyImage (this->m_image);
XFreeGC (this->m_display, this->m_gc);
@@ -132,6 +138,7 @@ void CX11Output::loadScreenInfo ()
// add the screen to the list of screens
this->m_screens.push_back (
+ new CX11OutputViewport
{
{crtc->x, crtc->y, crtc->width, crtc->height},
info->name
@@ -144,6 +151,7 @@ void CX11Output::loadScreenInfo ()
sLog.out ("Found requested screen: ", info->name, " -> ", crtc->x, "x", crtc->y, ":", crtc->width, "x", crtc->height);
this->m_viewports[info->name] =
+ new CX11OutputViewport
{
{crtc->x, crtc->y, crtc->width, crtc->height},
info->name
@@ -187,6 +195,6 @@ void CX11Output::updateRender () const
XFlush(this->m_display);
// check for fullscreen windows and wait until there's none fullscreen
- while (this->m_detector.anythingFullscreen () && this->m_context.state.general.keepRunning)
+ while (this->m_driver.getFullscreenDetector ().anythingFullscreen () && this->m_context.state.general.keepRunning)
usleep (FULLSCREEN_CHECK_WAIT_TIME);
}
diff --git a/src/WallpaperEngine/Render/Drivers/Output/CX11Output.h b/src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
index 7bbd88e..e6be9c8 100644
--- a/src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
+++ b/src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
@@ -14,7 +14,7 @@ namespace WallpaperEngine::Render::Drivers::Output
class CX11Output : public COutput
{
public:
- CX11Output (CApplicationContext& context, CVideoDriver& driver, Detectors::CFullScreenDetector& detector);
+ CX11Output (CApplicationContext& context, CVideoDriver& driver);
~CX11Output ();
void reset () override;
@@ -35,7 +35,6 @@ namespace WallpaperEngine::Render::Drivers::Output
GC m_gc;
char* m_imageData;
XImage* m_image;
- CVideoDriver& m_driver;
- std::vector m_screens;
+ std::vector