diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h
index 5986c96f..5ff9f5e2 100644
--- a/include/rootston/desktop.h
+++ b/include/rootston/desktop.h
@@ -48,6 +48,7 @@ struct roots_desktop {
struct wlr_idle *idle;
struct wlr_idle_inhibit_manager_v1 *idle_inhibit;
struct wlr_linux_dmabuf *linux_dmabuf;
+ struct wlr_layer_shell *layer_shell;
struct wl_listener new_output;
struct wl_listener layout_change;
diff --git a/include/wlr/types/wlr_layer_shell.h b/include/wlr/types/wlr_layer_shell.h
new file mode 100644
index 00000000..fbea1334
--- /dev/null
+++ b/include/wlr/types/wlr_layer_shell.h
@@ -0,0 +1,29 @@
+#ifndef WLR_TYPES_WLR_LAYER_SHELL_H
+#define WLR_TYPES_WLR_LAYER_SHELL_H
+
+struct wlr_layer_shell {
+ struct wl_global *wl_global;
+ struct wl_list clients;
+
+ struct wl_listener display_destroy;
+
+ struct {
+ struct wl_signal new_surface;
+ } events;
+
+ void *data;
+};
+
+struct wlr_layer_client {
+ struct wlr_layer_shell *shell;
+ struct wl_resource *resource;
+ struct wl_client *client;
+ struct wl_list surfaces;
+
+ struct wl_list link; // wlr_layer_shell::clients
+};
+
+struct wlr_layer_shell *wlr_layer_shell_create(struct wl_display *display);
+void wlr_layer_shell_destroy(struct wlr_layer_shell *layer_shell);
+
+#endif
diff --git a/protocol/meson.build b/protocol/meson.build
index 638b0c46..8c8a7c0e 100644
--- a/protocol/meson.build
+++ b/protocol/meson.build
@@ -30,6 +30,7 @@ protocols = [
'idle.xml',
'screenshooter.xml',
'server-decoration.xml',
+ 'wlr-layer-shell-unstable-v1.xml',
]
client_protocols = [
diff --git a/protocol/wlr-layer-shell-unstable-v1.xml b/protocol/wlr-layer-shell-unstable-v1.xml
new file mode 100644
index 00000000..494b29ca
--- /dev/null
+++ b/protocol/wlr-layer-shell-unstable-v1.xml
@@ -0,0 +1,277 @@
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+ Clients can specify a namespace that defines the purpose of the layer
+ surface.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+
+ 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 (anchor, exclusive zone, margin) is double-buffered.
+ Protocol requests modify the pending state, as opposed to the current
+ state in use by the compositor. The wl_surface.commit request atomically
+ applies all pending state, replacing the current state. After commit, the
+ new pending state is as documented for each related request.
+
+
+
+
+ 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.
+
+
+
+
+
+
+ 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.
+
+ This value is only meaningful if the surface is anchored to an edge,
+ rather than a corner. The zone is the number of pixels from the edge
+ that are considered exclusive.
+
+ Exclusive zone is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+ Requests that the surface be placed some distance away from the anchor
+ point on the output, in pixels. Setting this value for edges you are
+ not anchored to has no effect.
+
+ Margin is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+ This creates a layer input for this layer surface. This can be used to
+ control input semantics for the layer surface on the specified wl_seat.
+
+
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+ This request destroys the layer surface.
+
+
+
+
+
+ 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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Clients can use this interface to specify input semantics for a layer
+ surface on a given seat. By default, layer surfaces are considered
+ non-interactive by seats, and will not participate in their focus
+ semantics or receive input events for them.
+
+ Input state is double-buffered. Protocol requests modify the pending
+ state, as opposed to the current state in use by the compositor. The
+ wl_surface.commit request for the associated layer surface atomically
+ applies all pending state, replacing the current state. After commit, the
+ new pending state is as documented for each related request.
+
+
+
+
+ Requests that the seat send input events for the specified input devices
+ to this layer surface.
+
+ Positional events (pointer and touch) will only be sent if the layer
+ surface is the top-most interactive surface, and only when the position
+ of these events are relative to the surface. Enter and leave events will
+ be signalled normally in these cases.
+
+ Keyboard events will treat the layer surface as the only focused surface
+ on the seat. Upon requesting keyboard events, the layer surface will
+ receive a keyboard enter event. A leave event is signalled when it
+ invokes set_events again without keyboard events specified.
+
+ Events is double-buffered, see wl_surface.commit.
+
+
+
+
+
+
+ This request destroys the layer input.
+
+
+
+
+
+
+
+
+
+
+
diff --git a/rootston/desktop.c b/rootston/desktop.c
index 65d9a280..dcf0b7b2 100644
--- a/rootston/desktop.c
+++ b/rootston/desktop.c
@@ -9,9 +9,10 @@
#include
#include
#include
+#include
+#include
#include
#include
-#include
#include
#include
#include
@@ -714,6 +715,9 @@ struct roots_desktop *desktop_create(struct roots_server *server,
&desktop->wl_shell_surface);
desktop->wl_shell_surface.notify = handle_wl_shell_surface;
+ desktop->layer_shell = wlr_layer_shell_create(server->wl_display);
+ // TODO: Pick up new surfaces
+
#ifdef WLR_HAS_XWAYLAND
const char *cursor_theme = NULL;
const char *cursor_default = ROOTS_XCURSOR_DEFAULT;
diff --git a/types/meson.build b/types/meson.build
index 94993b52..198563b1 100644
--- a/types/meson.build
+++ b/types/meson.build
@@ -8,8 +8,10 @@ lib_wlr_types = static_library(
'wlr_gamma_control.c',
'wlr_idle_inhibit_v1.c',
'wlr_idle.c',
+ 'wlr_idle_inhibit_v1.c',
'wlr_input_device.c',
'wlr_keyboard.c',
+ 'wlr_layer_shell.c',
'wlr_linux_dmabuf.c',
'wlr_list.c',
'wlr_matrix.c',
diff --git a/types/wlr_layer_shell.c b/types/wlr_layer_shell.c
new file mode 100644
index 00000000..51d50b17
--- /dev/null
+++ b/types/wlr_layer_shell.c
@@ -0,0 +1,104 @@
+#include
+#include
+#include
+#include
+#include "wlr-layer-shell-unstable-v1-protocol.h"
+
+static void layer_shell_handle_get_layer_surface(struct wl_client *client,
+ struct wl_resource *resource,
+ uint32_t id,
+ struct wl_resource *surface,
+ struct wl_resource *output,
+ uint32_t layer,
+ const char *namespace) {
+ // TODO
+}
+
+static struct zwlr_layer_shell_v1_interface layer_shell_impl = {
+ .get_layer_surface = layer_shell_handle_get_layer_surface,
+};
+
+static struct wlr_layer_client *layer_client_from_resource(
+ struct wl_resource *resource) {
+ assert(wl_resource_instance_of(resource, &zwlr_layer_shell_v1_interface,
+ &layer_shell_impl));
+ return wl_resource_get_user_data(resource);
+}
+
+static void wlr_layer_client_destroy(struct wl_resource *resource) {
+ struct wlr_layer_client *client = layer_client_from_resource(resource);
+
+ // TODO: Destroy surfaces
+
+ wl_list_remove(&client->link);
+ free(client);
+}
+
+static void layer_shell_bind(struct wl_client *wl_client, void *data,
+ uint32_t version, uint32_t id) {
+ struct wlr_layer_shell *layer_shell = data;
+ assert(wl_client && layer_shell);
+
+ struct wlr_layer_client *client =
+ calloc(1, sizeof(struct wlr_layer_client));
+ if (client == NULL) {
+ wl_client_post_no_memory(wl_client);
+ return;
+ }
+
+ wl_list_init(&client->surfaces);
+
+ client->resource = wl_resource_create(
+ wl_client, &zwlr_layer_shell_v1_interface, version, id);
+ if (client->resource == NULL) {
+ free(client);
+ wl_client_post_no_memory(wl_client);
+ return;
+ }
+ client->client = wl_client;
+ client->shell = layer_shell;
+
+ wl_resource_set_implementation(client->resource, &layer_shell_impl, client,
+ wlr_layer_client_destroy);
+ wl_list_insert(&layer_shell->clients, &client->link);
+}
+
+static void handle_display_destroy(struct wl_listener *listener, void *data) {
+ struct wlr_layer_shell *layer_shell =
+ wl_container_of(listener, layer_shell, display_destroy);
+ wlr_layer_shell_destroy(layer_shell);
+}
+
+struct wlr_layer_shell *wlr_layer_shell_create(struct wl_display *display) {
+ struct wlr_layer_shell *layer_shell =
+ calloc(1, sizeof(struct wlr_layer_shell));
+ if (!layer_shell) {
+ return NULL;
+ }
+
+ wl_list_init(&layer_shell->clients);
+
+ struct wl_global *wl_global = wl_global_create(display,
+ &zwlr_layer_shell_v1_interface, 1, layer_shell, layer_shell_bind);
+ if (!wl_global) {
+ free(layer_shell);
+ return NULL;
+ }
+ layer_shell->wl_global = wl_global;
+
+ wl_signal_init(&layer_shell->events.new_surface);
+
+ layer_shell->display_destroy.notify = handle_display_destroy;
+ wl_display_add_destroy_listener(display, &layer_shell->display_destroy);
+
+ return layer_shell;
+}
+
+void wlr_layer_shell_destroy(struct wlr_layer_shell *layer_shell) {
+ if (!layer_shell) {
+ return;
+ }
+ wl_list_remove(&layer_shell->display_destroy.link);
+ wl_global_destroy(layer_shell->wl_global);
+ free(layer_shell);
+}