wl-desktop-shell: Fix T2357: Update xdg_shell for version 5
Summary: This fixes the Enlightenment wayland desktop shell by updating it to support xdg_shell version 5. Fixes T2357 where gtk apps would not work. Confirmed working now. @fix Signed-off-by: Chris Michael <cp.michael@samsung.com>
This commit is contained in:
Chris Michael
parent
73340169e8
commit
db66433374
|
|
@ -1,9 +1,34 @@
|
|||
/*
|
||||
* Copyright © 2008-2013 Kristian Høgsberg
|
||||
* Copyright © 2013 Rafael Antognolli
|
||||
* Copyright © 2013 Jasper St. Pierre
|
||||
* Copyright © 2010-2013 Intel Corporation
|
||||
*
|
||||
* 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 <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <wayland-util.h>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wredundant-decls"
|
||||
#include "wayland-util.h"
|
||||
|
||||
extern const struct wl_interface wl_output_interface;
|
||||
extern const struct wl_interface wl_seat_interface;
|
||||
|
|
@ -11,101 +36,90 @@ extern const struct wl_interface wl_surface_interface;
|
|||
extern const struct wl_interface xdg_popup_interface;
|
||||
extern const struct wl_interface xdg_surface_interface;
|
||||
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
static const struct wl_interface *types[] =
|
||||
{
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&xdg_surface_interface,
|
||||
&wl_surface_interface,
|
||||
&xdg_popup_interface,
|
||||
&wl_surface_interface,
|
||||
&wl_surface_interface,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&wl_surface_interface,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
&wl_output_interface,
|
||||
static const struct wl_interface *types[] = {
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&xdg_surface_interface,
|
||||
&wl_surface_interface,
|
||||
&xdg_popup_interface,
|
||||
&wl_surface_interface,
|
||||
&wl_surface_interface,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&xdg_surface_interface,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
&wl_seat_interface,
|
||||
NULL,
|
||||
NULL,
|
||||
&wl_output_interface,
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_shell_requests[] =
|
||||
{
|
||||
{ "use_unstable_version", "i", types + 0 },
|
||||
{ "get_xdg_surface", "no", types + 4 },
|
||||
{ "get_xdg_popup", "nooouiiu", types + 6 },
|
||||
{ "pong", "u", types + 0 },
|
||||
static const struct wl_message xdg_shell_requests[] = {
|
||||
{ "destroy", "", types + 0 },
|
||||
{ "use_unstable_version", "i", types + 0 },
|
||||
{ "get_xdg_surface", "no", types + 4 },
|
||||
{ "get_xdg_popup", "nooouii", types + 6 },
|
||||
{ "pong", "u", types + 0 },
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_shell_events[] =
|
||||
{
|
||||
{ "ping", "u", types + 0 },
|
||||
static const struct wl_message xdg_shell_events[] = {
|
||||
{ "ping", "u", types + 0 },
|
||||
};
|
||||
|
||||
WL_EXPORT const struct wl_interface xdg_shell_interface =
|
||||
{
|
||||
"xdg_shell", 1,
|
||||
4, xdg_shell_requests,
|
||||
1, xdg_shell_events,
|
||||
WL_EXPORT const struct wl_interface xdg_shell_interface = {
|
||||
"xdg_shell", 1,
|
||||
5, xdg_shell_requests,
|
||||
1, xdg_shell_events,
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_surface_requests[] =
|
||||
{
|
||||
{ "destroy", "", types + 0 },
|
||||
{ "set_parent", "?o", types + 14 },
|
||||
{ "set_title", "s", types + 0 },
|
||||
{ "set_app_id", "s", types + 0 },
|
||||
{ "show_window_menu", "ouii", types + 15 },
|
||||
{ "move", "ou", types + 19 },
|
||||
{ "resize", "ouu", types + 21 },
|
||||
{ "ack_configure", "u", types + 0 },
|
||||
{ "set_window_geometry", "iiii", types + 0 },
|
||||
{ "set_maximized", "", types + 0 },
|
||||
{ "unset_maximized", "", types + 0 },
|
||||
{ "set_fullscreen", "?o", types + 24 },
|
||||
{ "unset_fullscreen", "", types + 0 },
|
||||
{ "set_minimized", "", types + 0 },
|
||||
static const struct wl_message xdg_surface_requests[] = {
|
||||
{ "destroy", "", types + 0 },
|
||||
{ "set_parent", "?o", types + 13 },
|
||||
{ "set_title", "s", types + 0 },
|
||||
{ "set_app_id", "s", types + 0 },
|
||||
{ "show_window_menu", "ouii", types + 14 },
|
||||
{ "move", "ou", types + 18 },
|
||||
{ "resize", "ouu", types + 20 },
|
||||
{ "ack_configure", "u", types + 0 },
|
||||
{ "set_window_geometry", "iiii", types + 0 },
|
||||
{ "set_maximized", "", types + 0 },
|
||||
{ "unset_maximized", "", types + 0 },
|
||||
{ "set_fullscreen", "?o", types + 23 },
|
||||
{ "unset_fullscreen", "", types + 0 },
|
||||
{ "set_minimized", "", types + 0 },
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_surface_events[] =
|
||||
{
|
||||
{ "configure", "iiau", types + 0 },
|
||||
{ "close", "", types + 0 },
|
||||
static const struct wl_message xdg_surface_events[] = {
|
||||
{ "configure", "iiau", types + 0 },
|
||||
{ "close", "", types + 0 },
|
||||
};
|
||||
|
||||
WL_EXPORT const struct wl_interface xdg_surface_interface =
|
||||
{
|
||||
"xdg_surface", 1,
|
||||
14, xdg_surface_requests,
|
||||
2, xdg_surface_events,
|
||||
WL_EXPORT const struct wl_interface xdg_surface_interface = {
|
||||
"xdg_surface", 1,
|
||||
14, xdg_surface_requests,
|
||||
2, xdg_surface_events,
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_popup_requests[] =
|
||||
{
|
||||
{ "destroy", "", types + 0 },
|
||||
static const struct wl_message xdg_popup_requests[] = {
|
||||
{ "destroy", "", types + 0 },
|
||||
};
|
||||
|
||||
static const struct wl_message xdg_popup_events[] =
|
||||
{
|
||||
{ "popup_done", "u", types + 0 },
|
||||
static const struct wl_message xdg_popup_events[] = {
|
||||
{ "popup_done", "", types + 0 },
|
||||
};
|
||||
|
||||
WL_EXPORT const struct wl_interface xdg_popup_interface =
|
||||
{
|
||||
"xdg_popup", 1,
|
||||
1, xdg_popup_requests,
|
||||
1, xdg_popup_events,
|
||||
WL_EXPORT const struct wl_interface xdg_popup_interface = {
|
||||
"xdg_popup", 1,
|
||||
1, xdg_popup_requests,
|
||||
1, xdg_popup_events,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,128 +1,661 @@
|
|||
#ifndef E_DESKTOP_SHELL_PROTOCOL_H
|
||||
# define E_DESKTOP_SHELL_PROTOCOL_H
|
||||
/*
|
||||
* Copyright © 2008-2013 Kristian Høgsberg
|
||||
* Copyright © 2013 Rafael Antognolli
|
||||
* Copyright © 2013 Jasper St. Pierre
|
||||
* Copyright © 2010-2013 Intel Corporation
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
# ifdef __cplusplus
|
||||
#ifndef XDG_SHELL_SERVER_PROTOCOL_H
|
||||
#define XDG_SHELL_SERVER_PROTOCOL_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
# endif
|
||||
#endif
|
||||
|
||||
# include <stdint.h>
|
||||
# include <stddef.h>
|
||||
# include <wayland-util.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "wayland-server.h"
|
||||
|
||||
struct wl_client;
|
||||
struct wl_resource;
|
||||
|
||||
struct wl_output;
|
||||
struct wl_seat;
|
||||
struct wl_surface;
|
||||
struct xdg_popup;
|
||||
struct xdg_shell;
|
||||
struct xdg_surface;
|
||||
struct xdg_popup;
|
||||
|
||||
extern const struct wl_interface xdg_shell_interface;
|
||||
extern const struct wl_interface xdg_surface_interface;
|
||||
extern const struct wl_interface xdg_popup_interface;
|
||||
|
||||
# ifndef XDG_SHELL_VERSION_ENUM
|
||||
# define XDG_SHELL_VERSION_ENUM
|
||||
enum xdg_shell_version
|
||||
{
|
||||
XDG_SHELL_VERSION_CURRENT = 4,
|
||||
#ifndef XDG_SHELL_VERSION_ENUM
|
||||
#define XDG_SHELL_VERSION_ENUM
|
||||
/**
|
||||
* xdg_shell_version - latest protocol version
|
||||
* @XDG_SHELL_VERSION_CURRENT: Always the latest version
|
||||
*
|
||||
* The 'current' member of this enum gives the version of the protocol.
|
||||
* Implementations can compare this to the version they implement using
|
||||
* static_assert to ensure the protocol and implementation versions match.
|
||||
*/
|
||||
enum xdg_shell_version {
|
||||
XDG_SHELL_VERSION_CURRENT = 5,
|
||||
};
|
||||
# endif
|
||||
#endif /* XDG_SHELL_VERSION_ENUM */
|
||||
|
||||
struct xdg_shell_interface
|
||||
{
|
||||
void (*use_unstable_version)(struct wl_client *client, struct wl_resource *resource, int32_t version);
|
||||
void (*xdg_surface_get)(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface_resource);
|
||||
void (*xdg_popup_get)(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *surface_resource, struct wl_resource *parent_resource, struct wl_resource *seat_resource, uint32_t serial, int32_t x, int32_t y, uint32_t flags);
|
||||
void (*pong)(struct wl_client *client, struct wl_resource *resource, uint32_t serial);
|
||||
#ifndef XDG_SHELL_ERROR_ENUM
|
||||
#define XDG_SHELL_ERROR_ENUM
|
||||
enum xdg_shell_error {
|
||||
XDG_SHELL_ERROR_ROLE = 0,
|
||||
XDG_SHELL_ERROR_DEFUNCT_SURFACES = 1,
|
||||
XDG_SHELL_ERROR_NOT_THE_TOPMOST_POPUP = 2,
|
||||
XDG_SHELL_ERROR_INVALID_POPUP_PARENT = 3,
|
||||
};
|
||||
#endif /* XDG_SHELL_ERROR_ENUM */
|
||||
|
||||
/**
|
||||
* xdg_shell - create desktop-style surfaces
|
||||
* @destroy: destroy xdg_shell
|
||||
* @use_unstable_version: enable use of this unstable version
|
||||
* @get_xdg_surface: create a shell surface from a surface
|
||||
* @get_xdg_popup: create a popup for a surface
|
||||
* @pong: respond to a ping event
|
||||
*
|
||||
* xdg_shell allows clients to turn a wl_surface into a "real window"
|
||||
* which can be dragged, resized, stacked, and moved around by the user.
|
||||
* Everything about this interface is suited towards traditional desktop
|
||||
* environments.
|
||||
*/
|
||||
struct xdg_shell_interface {
|
||||
/**
|
||||
* destroy - destroy xdg_shell
|
||||
*
|
||||
* Destroy this xdg_shell object.
|
||||
*
|
||||
* Destroying a bound xdg_shell object while there are surfaces
|
||||
* still alive created by this xdg_shell object instance is illegal
|
||||
* and will result in a protocol error.
|
||||
*/
|
||||
void (*destroy)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
/**
|
||||
* use_unstable_version - enable use of this unstable version
|
||||
* @version: (none)
|
||||
*
|
||||
* Negotiate the unstable version of the interface. This
|
||||
* mechanism is in place to ensure client and server agree on the
|
||||
* unstable versions of the protocol that they speak or exit
|
||||
* cleanly if they don't agree. This request will go away once the
|
||||
* xdg-shell protocol is stable.
|
||||
*/
|
||||
void (*use_unstable_version)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
int32_t version);
|
||||
/**
|
||||
* get_xdg_surface - create a shell surface from a surface
|
||||
* @id: (none)
|
||||
* @surface: (none)
|
||||
*
|
||||
* This creates an xdg_surface for the given surface and gives it
|
||||
* the xdg_surface role. A wl_surface can only be given an
|
||||
* xdg_surface role once. If get_xdg_surface is called with a
|
||||
* wl_surface that already has an active xdg_surface associated
|
||||
* with it, or if it had any other role, an error is raised.
|
||||
*
|
||||
* See the documentation of xdg_surface for more details about what
|
||||
* an xdg_surface is and how it is used.
|
||||
*/
|
||||
void (*get_xdg_surface)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
uint32_t id,
|
||||
struct wl_resource *surface);
|
||||
/**
|
||||
* get_xdg_popup - create a popup for a surface
|
||||
* @id: (none)
|
||||
* @surface: (none)
|
||||
* @parent: (none)
|
||||
* @seat: the wl_seat of the user event
|
||||
* @serial: the serial of the user event
|
||||
* @x: (none)
|
||||
* @y: (none)
|
||||
*
|
||||
* This creates an xdg_popup for the given surface and gives it
|
||||
* the xdg_popup role. A wl_surface can only be given an xdg_popup
|
||||
* role once. If get_xdg_popup is called with a wl_surface that
|
||||
* already has an active xdg_popup associated with it, or if it had
|
||||
* any other role, an error is raised.
|
||||
*
|
||||
* This request must be used in response to some sort of user
|
||||
* action like a button press, key press, or touch down event.
|
||||
*
|
||||
* See the documentation of xdg_popup for more details about what
|
||||
* an xdg_popup is and how it is used.
|
||||
*/
|
||||
void (*get_xdg_popup)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
uint32_t id,
|
||||
struct wl_resource *surface,
|
||||
struct wl_resource *parent,
|
||||
struct wl_resource *seat,
|
||||
uint32_t serial,
|
||||
int32_t x,
|
||||
int32_t y);
|
||||
/**
|
||||
* pong - respond to a ping event
|
||||
* @serial: serial of the ping event
|
||||
*
|
||||
* A client must respond to a ping event with a pong request or
|
||||
* the client may be deemed unresponsive.
|
||||
*/
|
||||
void (*pong)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
uint32_t serial);
|
||||
};
|
||||
|
||||
# define XDG_SHELL_PING 0
|
||||
# define XDG_SHELL_PING_SINCE_VERSION 1
|
||||
#define XDG_SHELL_PING 0
|
||||
|
||||
#define XDG_SHELL_PING_SINCE_VERSION 1
|
||||
|
||||
static inline void
|
||||
xdg_shell_send_ping(struct wl_resource *resource_, uint32_t serial)
|
||||
{
|
||||
wl_resource_post_event(resource_, XDG_SHELL_PING, serial);
|
||||
wl_resource_post_event(resource_, XDG_SHELL_PING, serial);
|
||||
}
|
||||
|
||||
# ifndef XDG_SURFACE_RESIZE_EDGE_ENUM
|
||||
# define XDG_SURFACE_RESIZE_EDGE_ENUM
|
||||
enum xdg_surface_resize_edge
|
||||
{
|
||||
XDG_SURFACE_RESIZE_EDGE_NONE = 0,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP = 1,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM = 2,
|
||||
XDG_SURFACE_RESIZE_EDGE_LEFT = 4,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP_LEFT = 5,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM_LEFT = 6,
|
||||
XDG_SURFACE_RESIZE_EDGE_RIGHT = 8,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP_RIGHT = 9,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM_RIGHT = 10,
|
||||
#ifndef XDG_SURFACE_RESIZE_EDGE_ENUM
|
||||
#define XDG_SURFACE_RESIZE_EDGE_ENUM
|
||||
/**
|
||||
* xdg_surface_resize_edge - edge values for resizing
|
||||
* @XDG_SURFACE_RESIZE_EDGE_NONE: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_TOP: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_BOTTOM: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_LEFT: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_TOP_LEFT: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_BOTTOM_LEFT: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_RIGHT: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_TOP_RIGHT: (none)
|
||||
* @XDG_SURFACE_RESIZE_EDGE_BOTTOM_RIGHT: (none)
|
||||
*
|
||||
* These values are used to indicate which edge of a surface is being
|
||||
* dragged in a resize operation. The server may use this information to
|
||||
* adapt its behavior, e.g. choose an appropriate cursor image.
|
||||
*/
|
||||
enum xdg_surface_resize_edge {
|
||||
XDG_SURFACE_RESIZE_EDGE_NONE = 0,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP = 1,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM = 2,
|
||||
XDG_SURFACE_RESIZE_EDGE_LEFT = 4,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP_LEFT = 5,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM_LEFT = 6,
|
||||
XDG_SURFACE_RESIZE_EDGE_RIGHT = 8,
|
||||
XDG_SURFACE_RESIZE_EDGE_TOP_RIGHT = 9,
|
||||
XDG_SURFACE_RESIZE_EDGE_BOTTOM_RIGHT = 10,
|
||||
};
|
||||
# endif
|
||||
#endif /* XDG_SURFACE_RESIZE_EDGE_ENUM */
|
||||
|
||||
# ifndef XDG_SURFACE_STATE_ENUM
|
||||
# define XDG_SURFACE_STATE_ENUM
|
||||
enum xdg_surface_state
|
||||
{
|
||||
XDG_SURFACE_STATE_MAXIMIZED = 1,
|
||||
XDG_SURFACE_STATE_FULLSCREEN = 2,
|
||||
XDG_SURFACE_STATE_RESIZING = 3,
|
||||
XDG_SURFACE_STATE_ACTIVATED = 4,
|
||||
#ifndef XDG_SURFACE_STATE_ENUM
|
||||
#define XDG_SURFACE_STATE_ENUM
|
||||
/**
|
||||
* xdg_surface_state - types of state on the surface
|
||||
* @XDG_SURFACE_STATE_MAXIMIZED: the surface is maximized
|
||||
* @XDG_SURFACE_STATE_FULLSCREEN: the surface is fullscreen
|
||||
* @XDG_SURFACE_STATE_RESIZING: (none)
|
||||
* @XDG_SURFACE_STATE_ACTIVATED: (none)
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Desktop environments may extend this enum by taking up a range of values
|
||||
* and documenting the range they chose in this description. They are not
|
||||
* required to document the values for the range that they chose. Ideally,
|
||||
* any good extensions from a desktop environment should make its way into
|
||||
* standardization into this enum.
|
||||
*
|
||||
* The current reserved ranges are:
|
||||
*
|
||||
* 0x0000 - 0x0FFF: xdg-shell core values, documented below. 0x1000 -
|
||||
* 0x1FFF: GNOME
|
||||
*/
|
||||
enum xdg_surface_state {
|
||||
XDG_SURFACE_STATE_MAXIMIZED = 1,
|
||||
XDG_SURFACE_STATE_FULLSCREEN = 2,
|
||||
XDG_SURFACE_STATE_RESIZING = 3,
|
||||
XDG_SURFACE_STATE_ACTIVATED = 4,
|
||||
};
|
||||
# endif
|
||||
#endif /* XDG_SURFACE_STATE_ENUM */
|
||||
|
||||
struct xdg_surface_interface
|
||||
{
|
||||
void (*destroy)(struct wl_client *client, struct wl_resource *resource);
|
||||
void (*parent_set)(struct wl_client *client, struct wl_resource *resource, struct wl_resource *parent_resource);
|
||||
void (*title_set)(struct wl_client *client, struct wl_resource *resource, const char *title);
|
||||
void (*app_id_set)(struct wl_client *client, struct wl_resource *resource, const char *id);
|
||||
void (*window_menu_show)(struct wl_client *client, struct wl_resource *resource, struct wl_resource *seat, uint32_t serial, int32_t x, int32_t y);
|
||||
void (*move)(struct wl_client *client, struct wl_resource *resource, struct wl_resource *seat_resource, uint32_t serial);
|
||||
void (*resize)(struct wl_client *client, struct wl_resource *resource, struct wl_resource *seat_resource, uint32_t serial, uint32_t edges);
|
||||
void (*ack_configure)(struct wl_client *client, struct wl_resource *resource, uint32_t serial);
|
||||
void (*window_geometry_set)(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y, int32_t w, int32_t h);
|
||||
void (*maximized_set)(struct wl_client *client, struct wl_resource *resource);
|
||||
void (*maximized_unset)(struct wl_client *client, struct wl_resource *resource);
|
||||
void (*fullscreen_set)(struct wl_client *client, struct wl_resource *resource, struct wl_resource *output);
|
||||
void (*fullscreen_unset)(struct wl_client *client, struct wl_resource *resource);
|
||||
void (*minimized_set)(struct wl_client *client, struct wl_resource *resource);
|
||||
/**
|
||||
* xdg_surface - A desktop window
|
||||
* @destroy: Destroy the xdg_surface
|
||||
* @set_parent: set the parent of this surface
|
||||
* @set_title: set surface title
|
||||
* @set_app_id: set application ID
|
||||
* @show_window_menu: show the window menu
|
||||
* @move: start an interactive move
|
||||
* @resize: start an interactive resize
|
||||
* @ack_configure: ack a configure event
|
||||
* @set_window_geometry: set the new window geometry
|
||||
* @set_maximized: maximize the window
|
||||
* @unset_maximized: unmaximize the window
|
||||
* @set_fullscreen: set the window as fullscreen on a monitor
|
||||
* @unset_fullscreen: (none)
|
||||
* @set_minimized: set the window as minimized
|
||||
*
|
||||
* An interface that may be implemented by a wl_surface, for
|
||||
* implementations that provide a desktop-style user interface.
|
||||
*
|
||||
* It provides requests to treat surfaces like windows, allowing to set
|
||||
* properties like maximized, fullscreen, minimized, and to move and resize
|
||||
* them, and associate metadata like title and app id.
|
||||
*
|
||||
* The client must call wl_surface.commit on the corresponding wl_surface
|
||||
* for the xdg_surface state to take effect. Prior to committing the new
|
||||
* state, it can set up initial configuration, such as maximizing or
|
||||
* setting a window geometry.
|
||||
*
|
||||
* Even without attaching a buffer the compositor must respond to initial
|
||||
* committed configuration, for instance sending a configure event with
|
||||
* expected window geometry if the client maximized its surface during
|
||||
* initialization.
|
||||
*
|
||||
* For a surface to be mapped by the compositor the client must have
|
||||
* committed both an xdg_surface state and a buffer.
|
||||
*/
|
||||
struct xdg_surface_interface {
|
||||
/**
|
||||
* destroy - Destroy the xdg_surface
|
||||
*
|
||||
* Unmap and destroy the window. The window will be effectively
|
||||
* hidden from the user's point of view, and all state like
|
||||
* maximization, fullscreen, and so on, will be lost.
|
||||
*/
|
||||
void (*destroy)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
/**
|
||||
* set_parent - set the parent of this surface
|
||||
* @parent: (none)
|
||||
*
|
||||
* Set the "parent" of this surface. This window should be
|
||||
* stacked above a parent. The parent surface must be mapped as
|
||||
* long as this surface is mapped.
|
||||
*
|
||||
* Parent windows should be set on dialogs, toolboxes, or other
|
||||
* "auxiliary" surfaces, so that the parent is raised when the
|
||||
* dialog is raised.
|
||||
*/
|
||||
void (*set_parent)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
struct wl_resource *parent);
|
||||
/**
|
||||
* set_title - set surface title
|
||||
* @title: (none)
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
void (*set_title)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
const char *title);
|
||||
/**
|
||||
* set_app_id - set application ID
|
||||
* @app_id: (none)
|
||||
*
|
||||
* 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".
|
||||
*
|
||||
* 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] http://standards.freedesktop.org/desktop-entry-spec/
|
||||
*/
|
||||
void (*set_app_id)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
const char *app_id);
|
||||
/**
|
||||
* show_window_menu - show the window menu
|
||||
* @seat: the wl_seat of the user event
|
||||
* @serial: the serial of the user event
|
||||
* @x: the x position to pop up the window menu at
|
||||
* @y: the y position to pop up the window menu at
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* This request must be used in response to some sort of user
|
||||
* action like a button press, key press, or touch down event.
|
||||
*/
|
||||
void (*show_window_menu)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
struct wl_resource *seat,
|
||||
uint32_t serial,
|
||||
int32_t x,
|
||||
int32_t y);
|
||||
/**
|
||||
* move - start an interactive move
|
||||
* @seat: the wl_seat of the user event
|
||||
* @serial: the serial of the user event
|
||||
*
|
||||
* 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 server may ignore move requests depending on the state of
|
||||
* the surface (e.g. fullscreen or maximized).
|
||||
*/
|
||||
void (*move)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
struct wl_resource *seat,
|
||||
uint32_t serial);
|
||||
/**
|
||||
* resize - start an interactive resize
|
||||
* @seat: the wl_seat of the user event
|
||||
* @serial: the serial of the user event
|
||||
* @edges: which edge or corner is being dragged
|
||||
*
|
||||
* 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 server may ignore resize requests depending on the state of
|
||||
* the surface (e.g. fullscreen or maximized).
|
||||
*/
|
||||
void (*resize)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
struct wl_resource *seat,
|
||||
uint32_t serial,
|
||||
uint32_t edges);
|
||||
/**
|
||||
* ack_configure - ack a configure event
|
||||
* @serial: the serial from the configure event
|
||||
*
|
||||
* When a configure event is received, if a client commits the
|
||||
* surface in response to the configure event, then the client must
|
||||
* make a ack_configure request before the commit request, passing
|
||||
* along the serial of the configure event.
|
||||
*
|
||||
* For instance, 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.
|
||||
*/
|
||||
void (*ack_configure)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
uint32_t serial);
|
||||
/**
|
||||
* set_window_geometry - set the new window geometry
|
||||
* @x: (none)
|
||||
* @y: (none)
|
||||
* @width: (none)
|
||||
* @height: (none)
|
||||
*
|
||||
* The window geometry of a window 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.
|
||||
*
|
||||
* Once the window geometry of the surface is set once, 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 mode is meant for extremely simple clients.
|
||||
*
|
||||
* If responding to a configure event, the window geometry in here
|
||||
* must respect the sizing negotiations specified by the states in
|
||||
* the configure event.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
void (*set_window_geometry)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
int32_t x,
|
||||
int32_t y,
|
||||
int32_t width,
|
||||
int32_t height);
|
||||
/**
|
||||
* set_maximized - maximize the window
|
||||
*
|
||||
* Maximize the surface.
|
||||
*
|
||||
* After requesting that the surface should be maximized, the
|
||||
* compositor will respond by emitting a configure event with the
|
||||
* "maximized" state and the required window geometry. The client
|
||||
* should then update its content, drawing it in a maximized state,
|
||||
* i.e. without shadow or other decoration outside of the window
|
||||
* geometry. 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.
|
||||
*/
|
||||
void (*set_maximized)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
/**
|
||||
* unset_maximized - unmaximize the window
|
||||
*
|
||||
* Unmaximize the surface.
|
||||
*
|
||||
* After requesting that the surface should be unmaximized, the
|
||||
* compositor will respond by emitting a configure event without
|
||||
* the "maximized" state. If available, the compositor will include
|
||||
* the window geometry dimensions the window had prior to being
|
||||
* maximized in the configure request. The client must then update
|
||||
* its content, drawing it in a regular state, i.e. potentially
|
||||
* with shadow, etc. 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.
|
||||
*/
|
||||
void (*unset_maximized)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
/**
|
||||
* set_fullscreen - set the window as fullscreen on a monitor
|
||||
* @output: (none)
|
||||
*
|
||||
* Make the surface fullscreen.
|
||||
*
|
||||
* You can specify an output that you would prefer to be
|
||||
* fullscreen. 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 black borders filling the rest of the output.
|
||||
*/
|
||||
void (*set_fullscreen)(struct wl_client *client,
|
||||
struct wl_resource *resource,
|
||||
struct wl_resource *output);
|
||||
/**
|
||||
* unset_fullscreen - (none)
|
||||
*/
|
||||
void (*unset_fullscreen)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
/**
|
||||
* set_minimized - set the window as minimized
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
void (*set_minimized)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
};
|
||||
|
||||
# define XDG_SURFACE_CONFIGURE 0
|
||||
# define XDG_SURFACE_CLOSE 1
|
||||
# define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
|
||||
# define XDG_SURFACE_CLOSE_SINCE_VERSION 1
|
||||
#define XDG_SURFACE_CONFIGURE 0
|
||||
#define XDG_SURFACE_CLOSE 1
|
||||
|
||||
#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
|
||||
#define XDG_SURFACE_CLOSE_SINCE_VERSION 1
|
||||
|
||||
static inline void
|
||||
xdg_surface_send_configure(struct wl_resource *resource_, int32_t w, int32_t h, struct wl_array *states, uint32_t serial)
|
||||
xdg_surface_send_configure(struct wl_resource *resource_, int32_t width, int32_t height, struct wl_array *states, uint32_t serial)
|
||||
{
|
||||
wl_resource_post_event(resource_, XDG_SURFACE_CONFIGURE, w, h, states, serial);
|
||||
wl_resource_post_event(resource_, XDG_SURFACE_CONFIGURE, width, height, states, serial);
|
||||
}
|
||||
|
||||
static inline void
|
||||
xdg_surface_send_close(struct wl_resource *resource_)
|
||||
{
|
||||
wl_resource_post_event(resource_, XDG_SURFACE_CLOSE);
|
||||
wl_resource_post_event(resource_, XDG_SURFACE_CLOSE);
|
||||
}
|
||||
|
||||
/**
|
||||
* xdg_popup - short-lived, popup surfaces for menus
|
||||
* @destroy: remove xdg_popup interface
|
||||
*
|
||||
* A popup surface is a short-lived, temporary surface that can be used
|
||||
* to implement menus. It takes an explicit grab on the surface that will
|
||||
* be dismissed when the user dismisses the 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.
|
||||
*
|
||||
* When the popup is dismissed, a popup_done event will be sent out, and at
|
||||
* the same time the surface will be unmapped. The xdg_popup object is now
|
||||
* inert and cannot be reactivated, so clients should destroy it.
|
||||
* Explicitly destroying the xdg_popup object will also dismiss the popup
|
||||
* and unmap the surface.
|
||||
*
|
||||
* Clients will receive events for all their surfaces during this grab
|
||||
* (which is an "owner-events" grab in X11 parlance). This is done so that
|
||||
* users can navigate through submenus and other "nested" popup windows
|
||||
* without having to dismiss the topmost popup.
|
||||
*
|
||||
* Clients that want to dismiss the popup when another surface of their own
|
||||
* is clicked should dismiss the popup using the destroy request.
|
||||
*
|
||||
* The parent surface must have either an xdg_surface or xdg_popup role.
|
||||
*
|
||||
* Specifying an xdg_popup for the parent 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.
|
||||
*
|
||||
* If there is an existing popup when creating a new popup, the parent must
|
||||
* be the current topmost popup.
|
||||
*
|
||||
* A parent surface must be mapped before the new popup is mapped.
|
||||
*
|
||||
* When compositors choose to dismiss a popup, they will likely dismiss
|
||||
* every nested popup as well. When a compositor dismisses popups, it will
|
||||
* follow the same dismissing order as required from the client.
|
||||
*
|
||||
* The x and y arguments passed when creating the popup object specify
|
||||
* where the top left of the popup should be placed, relative to the local
|
||||
* surface coordinates of the parent surface. See xdg_shell.get_xdg_popup.
|
||||
*
|
||||
* The client must call wl_surface.commit on the corresponding wl_surface
|
||||
* for the xdg_popup state to take effect.
|
||||
*
|
||||
* For a surface to be mapped by the compositor the client must have
|
||||
* committed both the xdg_popup state and a buffer.
|
||||
*/
|
||||
struct xdg_popup_interface {
|
||||
/**
|
||||
* destroy - remove xdg_popup interface
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
void (*destroy)(struct wl_client *client,
|
||||
struct wl_resource *resource);
|
||||
};
|
||||
|
||||
struct xdg_popup_interface
|
||||
{
|
||||
void (*destroy)(struct wl_client *client, struct wl_resource *resource);
|
||||
};
|
||||
#define XDG_POPUP_POPUP_DONE 0
|
||||
|
||||
# define XDG_POPUP_POPUP_DONE 0
|
||||
# define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
|
||||
#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
|
||||
|
||||
static inline void
|
||||
xdg_popup_send_popup_done(struct wl_resource *resource_, uint32_t serial)
|
||||
xdg_popup_send_popup_done(struct wl_resource *resource_)
|
||||
{
|
||||
wl_resource_post_event(resource_, XDG_POPUP_POPUP_DONE, serial);
|
||||
};
|
||||
|
||||
# ifdef __cplusplus
|
||||
wl_resource_post_event(resource_, XDG_POPUP_POPUP_DONE);
|
||||
}
|
||||
# endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
#include "e.h"
|
||||
#include "e_desktop_shell_protocol.h"
|
||||
|
||||
#define XDG_SERVER_VERSION 4
|
||||
#define XDG_SERVER_VERSION 5
|
||||
|
||||
static void
|
||||
_e_shell_surface_parent_set(E_Client *ec, struct wl_resource *parent_resource)
|
||||
|
|
@ -949,6 +949,12 @@ static const struct xdg_surface_interface _e_xdg_surface_interface =
|
|||
_e_xdg_shell_surface_cb_minimized_set,
|
||||
};
|
||||
|
||||
static void
|
||||
_e_xdg_shell_cb_destroy(struct wl_client *client EINA_UNUSED, struct wl_resource *resource)
|
||||
{
|
||||
wl_resource_destroy(resource);
|
||||
}
|
||||
|
||||
static void
|
||||
_e_xdg_shell_cb_unstable_version(struct wl_client *client EINA_UNUSED, struct wl_resource *resource, int32_t version)
|
||||
{
|
||||
|
|
@ -1147,7 +1153,7 @@ static const struct xdg_popup_interface _e_xdg_popup_interface =
|
|||
};
|
||||
|
||||
static void
|
||||
_e_xdg_shell_cb_popup_get(struct wl_client *client, struct wl_resource *resource EINA_UNUSED, uint32_t id, struct wl_resource *surface_resource, struct wl_resource *parent_resource, struct wl_resource *seat_resource EINA_UNUSED, uint32_t serial EINA_UNUSED, int32_t x, int32_t y, uint32_t flags EINA_UNUSED)
|
||||
_e_xdg_shell_cb_popup_get(struct wl_client *client, struct wl_resource *resource EINA_UNUSED, uint32_t id, struct wl_resource *surface_resource, struct wl_resource *parent_resource, struct wl_resource *seat_resource EINA_UNUSED, uint32_t serial EINA_UNUSED, int32_t x, int32_t y)
|
||||
{
|
||||
E_Client *ec;
|
||||
E_Comp_Client_Data *cdata;
|
||||
|
|
@ -1263,6 +1269,7 @@ static const struct wl_shell_interface _e_shell_interface =
|
|||
|
||||
static const struct xdg_shell_interface _e_xdg_shell_interface =
|
||||
{
|
||||
_e_xdg_shell_cb_destroy,
|
||||
_e_xdg_shell_cb_unstable_version,
|
||||
_e_xdg_shell_cb_surface_get,
|
||||
_e_xdg_shell_cb_popup_get,
|
||||
|
|
@ -1282,7 +1289,7 @@ _e_xdg_shell_cb_dispatch(const void *implementation EINA_UNUSED, void *target, u
|
|||
|
||||
if (!(res = target)) return 0;
|
||||
|
||||
if (opcode != 0)
|
||||
if (opcode != 1)
|
||||
{
|
||||
wl_resource_post_error(res, WL_DISPLAY_ERROR_INVALID_OBJECT,
|
||||
"Must call use_unstable_version first");
|
||||
|
|
|
|||
Loading…
Reference in New Issue