Merge e5ce6c1be0 into e1bbdd4f5f

.gitignore

@@ -102,3 +102,5 @@ tests/triangle-vulkan
 tests/window
 tests/windows
 
+#local test file
+run

README.md

@@ -120,6 +120,7 @@ information on what to include when reporting a bug.
 
 ## Changelog since 3.4
 
+ - [Wayland] Feature: Added wlr layer shell support for widgets creation
  - Added `GLFW_UNLIMITED_MOUSE_BUTTONS` input mode that allows mouse buttons beyond
    the limit of the mouse button tokens to be reported (#2423)
  - Added `glfwGetEGLConfig` function to query the `EGLConfig` of a window (#2045)

deps/wayland/wlr-layer-shell-unstable-v1.xml

@@ -0,0 +1,391 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_layer_shell_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.
+  </copyright>
+
+  <interface name="zwlr_layer_shell_v1" version="4">
+    <description summary="create surfaces that are layers of the desktop">
+      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.
+    </description>
+
+    <request name="get_layer_surface">
+      <description summary="create a layer_surface from a surface">
+        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.
+
+        After creating a layer_surface object and setting it up, the client
+        must perform an initial commit without any buffer attached.
+        The compositor will reply with a layer_surface.configure event.
+        The client must acknowledge it and is then allowed to attach a buffer
+        to map the surface.
+
+        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.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+      <arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
+      <arg name="useOfCXXKeywordsIsForFuckingMorons" type="string" summary="namespace for the layer surface"/>
+    </request>
+
+    <enum name="error">
+      <entry name="role" value="0" summary="wl_surface has another role"/>
+      <entry name="invalid_layer" value="1" summary="layer value is invalid"/>
+      <entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
+    </enum>
+
+    <enum name="layer">
+      <description summary="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.
+      </description>
+
+      <entry name="background" value="0"/>
+      <entry name="bottom" value="1"/>
+      <entry name="top" value="2"/>
+      <entry name="overlay" value="3"/>
+    </enum>
+
+    <!-- Version 3 additions -->
+
+    <request name="destroy" type="destructor" since="3">
+      <description summary="destroy the layer_shell object">
+        This request indicates that the client will not use the layer_shell
+        object any more. Objects that have been created through this instance
+        are not affected.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_layer_surface_v1" version="4">
+    <description summary="layer metadata 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 (layer, 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.
+
+      Attaching a null buffer to a layer surface unmaps it.
+
+      Unmapping a layer_surface means that the surface cannot be shown by the
+      compositor until it is explicitly mapped again. The layer_surface
+      returns to the state it had right after layer_shell.get_layer_surface.
+      The client can re-map the surface by performing a commit without any
+      buffer attached, waiting for a configure event and handling it as usual.
+    </description>
+
+    <request name="set_size">
+      <description summary="sets the size of the surface">
+        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.
+      </description>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </request>
+
+    <request name="set_anchor">
+      <description summary="configures the anchor point of the surface">
+        Requests that the compositor anchor the surface to the specified edges
+        and corners. If two orthogonal 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.
+      </description>
+      <arg name="anchor" type="uint" enum="anchor"/>
+    </request>
+
+    <request name="set_exclusive_zone">
+      <description summary="configures the exclusive geometry of this surface">
+        Requests that the compositor avoids occluding an area 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 one
+        edge or an edge and both perpendicular edges. If the surface is not
+        anchored, anchored to only two perpendicular edges (a corner), anchored
+        to only two parallel edges or anchored to all edges, a positive value
+        will be treated the same as zero.
+
+        A positive zone is the distance from the edge in surface-local
+        coordinates to consider 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 exclusive 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.
+      </description>
+      <arg name="zone" type="int"/>
+    </request>
+
+    <request name="set_margin">
+      <description summary="sets a margin from the anchor point">
+        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.
+      </description>
+      <arg name="top" type="int"/>
+      <arg name="right" type="int"/>
+      <arg name="bottom" type="int"/>
+      <arg name="left" type="int"/>
+    </request>
+
+    <enum name="keyboard_interactivity">
+      <description summary="types of keyboard interaction possible for a layer shell surface">
+        Types of keyboard interaction possible for layer shell surfaces. The
+        rationale for this is twofold: (1) some applications are not interested
+        in keyboard events and not allowing them to be focused can improve the
+        desktop experience; (2) some applications will want to take exclusive
+        keyboard focus.
+      </description>
+
+      <entry name="none" value="0">
+        <description summary="no keyboard focus is possible">
+          This value indicates that this surface is not interested in keyboard
+          events and the compositor should never assign it the keyboard focus.
+
+          This is the default value, set for newly created layer shell surfaces.
+
+          This is useful for e.g. desktop widgets that display information or
+          only have interaction with non-keyboard input devices.
+        </description>
+      </entry>
+      <entry name="exclusive" value="1">
+        <description summary="request exclusive keyboard focus">
+          Request exclusive keyboard focus if this surface is above the shell surface layer.
+
+          For the top and overlay layers, the seat will always give
+          exclusive keyboard focus to the top-most layer which has keyboard
+          interactivity set to exclusive. If this layer contains multiple
+          surfaces with keyboard interactivity set to exclusive, the compositor
+          determines the one receiving keyboard events in an implementation-
+          defined manner. In this case, no guarantee is made when this surface
+          will receive keyboard focus (if ever).
+
+          For the bottom and background layers, the compositor is allowed to use
+          normal focus semantics.
+
+          This setting is mainly intended for applications that need to ensure
+          they receive all keyboard events, such as a lock screen or a password
+          prompt.
+        </description>
+      </entry>
+      <entry name="on_demand" value="2" since="4">
+        <description summary="request regular keyboard focus semantics">
+          This requests the compositor to allow this surface to be focused and
+          unfocused by the user in an implementation-defined manner. The user
+          should be able to unfocus this surface even regardless of the layer
+          it is on.
+
+          Typically, the compositor will want to use its normal mechanism to
+          manage keyboard focus between layer shell surfaces with this setting
+          and regular toplevels on the desktop layer (e.g. click to focus).
+          Nevertheless, it is possible for a compositor to require a special
+          interaction to focus or unfocus layer shell surfaces (e.g. requiring
+          a click even if focus follows the mouse normally, or providing a
+          keybinding to switch focus between layers).
+
+          This setting is mainly intended for desktop shell components (e.g.
+          panels) that allow keyboard interaction. Using this option can allow
+          implementing a desktop shell that can be fully usable without the
+          mouse.
+        </description>
+      </entry>
+    </enum>
+
+    <request name="set_keyboard_interactivity">
+      <description summary="requests keyboard events">
+        Set how keyboard events are delivered to this surface. By default,
+        layer shell surfaces do not receive keyboard events; this request can
+        be used to change this.
+
+        This setting is inherited by child surfaces set by the get_popup
+        request.
+
+        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.
+
+        Keyboard interactivity is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="keyboard_interactivity" type="uint" enum="keyboard_interactivity"/>
+    </request>
+
+    <request name="get_popup">
+      <description summary="assign this layer_surface as an xdg_popup parent">
+        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.
+      </description>
+      <arg name="popup" type="object" interface="xdg_popup"/>
+    </request>
+
+    <request name="ack_configure">
+      <description summary="ack a 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 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.
+      </description>
+      <arg name="serial" type="uint" summary="the serial from the configure event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the layer_surface">
+        This request destroys the layer surface.
+      </description>
+    </request>
+
+    <event name="configure">
+      <description summary="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.
+      </description>
+      <arg name="serial" type="uint"/>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </event>
+
+    <event name="closed">
+      <description summary="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.
+      </description>
+    </event>
+
+    <enum name="error">
+      <entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
+      <entry name="invalid_size" value="1" summary="size is invalid"/>
+      <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
+      <entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/>
+    </enum>
+
+    <enum name="anchor" bitfield="true">
+      <entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
+      <entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
+      <entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
+      <entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
+    </enum>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_layer" since="2">
+      <description summary="change the layer of the surface">
+        Change the layer that the surface is rendered on.
+
+        Layer is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
+    </request>
+  </interface>
+</protocol>
+

docs/news.md

@@ -5,6 +5,16 @@
 
 ## New features {#features}
 
+### [ZWLR Layer Shell support for Wayland](https://wayland.app/protocols/wlr-layer-shell-unstable-v1)
+
+Create surfaces that are layers of the desktop
+
+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.
+
 ### Unlimited mouse buttons {#unlimited_mouse_buttons}
 
 GLFW now has an input mode which allows an unlimited number of mouse buttons to

docs/window.md

@@ -518,6 +518,14 @@ __GLFW_WAYLAND_APP_ID__ specifies the Wayland app_id for a window, used
 by window managers to identify types of windows. This is set with
 @ref glfwWindowHintString.
 
+@anchor GLFW_WAYLAND_USE_ZWLR_hint
+__GLFW_WAYLAND_USE_ZWLR__ Try to utilize
+[wlr layers system](https://wayland.app/protocols/wlr-layer-shell-unstable-v1)
+from your compositor.
+This is set by @ref glfwWindowHint with [special init layer](@ref GLFW_WAYLAND_USE_ZWLR).
+If success, you can control layer behavior with
+[<GLFW/glfw3native.h>](@ref glfwWaylandZwlrSetLayer) api.
+Example available [here](https://github.com/glfw/glfw/blob/master/examples/wayland-widget.c).
 
 #### X11 specific window hints {#window_hints_x11}
 
@@ -577,10 +585,10 @@ GLFW_WIN32_KEYBOARD_MENU      | `GLFW_FALSE`                | `GLFW_TRUE` or `GL
 GLFW_WIN32_SHOWDEFAULT        | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
 GLFW_COCOA_FRAME_NAME         | `""`                        | A UTF-8 encoded frame autosave name
 GLFW_COCOA_GRAPHICS_SWITCHING | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-GLFW_WAYLAND_APP_ID           | `""`                        | An ASCII encoded Wayland `app_id` name
 GLFW_X11_CLASS_NAME           | `""`                        | An ASCII encoded `WM_CLASS` class name
 GLFW_X11_INSTANCE_NAME        | `""`                        | An ASCII encoded `WM_CLASS` instance name
-
+GLFW_WAYLAND_APP_ID           | `""`                        | An ASCII encoded Wayland `app_id` name
+GLFW_WAYLAND_USE_ZWLR         | 0                           | `GLFW_WAYLAND_ZWLR_LAYER_BACKGROUD`, `GLFW_WAYLAND_ZWLR_LAYER_BOTTOM`, `GLFW_WAYLAND_ZWLR_LAYER_TOP` or `GLFW_WAYLAND_ZWLR_LAYER_OVERLAY`
 
 ## Window event processing {#window_events}
 

examples/CMakeLists.txt

@@ -36,6 +36,10 @@ add_executable(triangle-opengl WIN32 MACOSX_BUNDLE triangle-opengl.c ${ICON} ${G
 add_executable(triangle-opengles WIN32 MACOSX_BUNDLE triangle-opengles.c ${ICON} ${GLAD_GLES2})
 add_executable(wave WIN32 MACOSX_BUNDLE wave.c ${ICON} ${GLAD_GL})
 add_executable(windows WIN32 MACOSX_BUNDLE windows.c ${ICON} ${GLAD_GL})
+if (Wayland_FOUND)
+    add_executable(wayland-widget wayland-widget.c ${ICON} ${GLAD_GL})
+endif()
+
 
 target_link_libraries(particles Threads::Threads)
 if (RT_LIBRARY)

examples/wayland-widget.c

@@ -0,0 +1,198 @@
+
+#define GLAD_GL_IMPLEMENTATION
+#include <glad/gl.h>
+
+#define GLFW_INCLUDE_NONE
+#define GLFW_EXPOSE_NATIVE_WAYLAND
+#include <GLFW/glfw3.h>
+#include <GLFW/glfw3native.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#define NK_IMPLEMENTATION
+#define NK_INCLUDE_FIXED_TYPES
+#define NK_INCLUDE_FONT_BAKING
+#define NK_INCLUDE_DEFAULT_FONT
+#define NK_INCLUDE_DEFAULT_ALLOCATOR
+#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
+#define NK_INCLUDE_STANDARD_VARARGS
+#define NK_BUTTON_TRIGGER_ON_RELEASE
+#include <nuklear.h>
+
+#define NK_GLFW_GL2_IMPLEMENTATION
+#include <nuklear_glfw_gl2.h>
+
+
+
+#define WIN_HEIGHT 150
+
+
+void nk_process(GLFWwindow*, struct nk_context*, float, float);
+
+
+static void GLFW_DebugCallback(int err_code, const char* description)
+{
+    printf("GLFW error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+    { printf("Captured %i\n", key); }
+
+
+
+int main(int argc, char** argv)
+{
+    glfwSetErrorCallback(GLFW_DebugCallback);
+
+    if (!glfwInit()) return 1;
+
+    glfwWindowHint(GLFW_WAYLAND_USE_ZWLR, GLFW_WAYLAND_ZWLR_LAYER_TOP);
+
+    GLFWwindow* window = glfwCreateWindow(600, 400, "Don't Care", NULL, NULL);
+    if (!window) return 1;
+
+    //glfwWaylandZwlrSetExclusiveZone(window, WIN_HEIGHT + 50); // try to play with
+    //glfwWaylandZwlrSetMargin(window, 10, 10, 10, 10);
+
+    glfwMakeContextCurrent(window);
+    glfwSetKeyCallback    (window, key_callback);
+    gladLoadGL            (glfwGetProcAddress);
+
+
+    struct nk_context* nk = nk_glfw3_init(window, NK_GLFW3_INSTALL_CALLBACKS);
+
+    struct nk_font_atlas* atlas;
+    nk_glfw3_font_stash_begin(&atlas);
+    nk_glfw3_font_stash_end();
+
+
+    int width, height;
+    while (!glfwWindowShouldClose(window))
+    {
+        glfwGetWindowSize(window, &width, &height);
+
+        struct nk_rect area = nk_rect(0.f, 0.f, (float) width, (float) height);
+        nk_window_set_bounds(nk, "main", area);
+
+        nk_glfw3_new_frame();
+        if (nk_begin(nk, "main", area, 0))
+            nk_process(window, nk, width, height);
+
+        nk_end(nk);
+
+        glClear(GL_COLOR_BUFFER_BIT);
+        nk_glfw3_render(NK_ANTI_ALIASING_ON);
+
+        glfwSwapBuffers(window);
+        glfwWaitEvents();
+    }
+
+    nk_glfw3_shutdown();
+    glfwTerminate();
+
+    return 0;
+}
+
+
+void nk_process(GLFWwindow* window, struct nk_context* ctx, float width, float height)
+{
+    nk_flags events;
+    const nk_flags flags = NK_EDIT_FIELD |
+                           NK_EDIT_SIG_ENTER |
+                           NK_EDIT_GOTO_END_ON_ACTIVATE;
+
+    nk_layout_row_dynamic(ctx, 30, 4);
+    nk_spacing(ctx, 3);
+
+    if (nk_button_label(ctx, "Exit"))
+    {
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+    }
+
+    nk_layout_row_dynamic(ctx, (height / 3), 1);
+    nk_layout_row_dynamic(ctx, 30, 2);
+
+    {
+        static char exclusiveBuff[12];
+
+        nk_label(ctx, "Exclusive zone (anchor required):", NK_TEXT_LEFT);
+        events = nk_edit_string_zero_terminated(ctx, flags, exclusiveBuff,
+                                                sizeof(exclusiveBuff),
+                                                nk_filter_decimal);
+        if (events & NK_EDIT_COMMITED)
+        {
+            int zone = atoi(exclusiveBuff);
+            glfwWaylandZwlrSetExclusiveZone(window, zone);
+        }
+    }
+    {
+        static char exclusiveBuff[12];
+
+        nk_label(ctx, "Margin all edges (anchor required):", NK_TEXT_LEFT);
+        events = nk_edit_string_zero_terminated(ctx, flags, exclusiveBuff,
+                                                sizeof(exclusiveBuff),
+                                                nk_filter_decimal);
+        if (events & NK_EDIT_COMMITED)
+        {
+            int margin = atoi(exclusiveBuff);
+            glfwWaylandZwlrSetMargin(window, margin, margin, margin, margin);
+        }
+    }
+
+    nk_layout_row_dynamic(ctx, 30, 4);
+    nk_spacing(ctx, 1);
+
+    {
+        static int         pickedLayer  = 0;
+        static const char* layerItems[] = {
+            "Layer Top",    "Layer Overlay",
+            "Layer Bottom", "Layer Background"
+        };
+        static const int layerFlags[]   = {
+            GLFW_WAYLAND_ZWLR_LAYER_TOP,    GLFW_WAYLAND_ZWLR_LAYER_OVERLAY,
+            GLFW_WAYLAND_ZWLR_LAYER_BOTTOM, GLFW_WAYLAND_ZWLR_LAYER_BACKGROUND
+        };
+        if (nk_combo_begin_label(ctx, layerItems[pickedLayer], nk_vec2(200, 200)))
+        {
+            nk_layout_row_dynamic(ctx, 30, 1);
+            for (int i = 0; i < 4; i++)
+            {
+                if (nk_combo_item_label(ctx, layerItems[i], NK_TEXT_LEFT))
+                {
+                    pickedLayer = i;
+                    glfwWaylandZwlrSetLayer(window, layerFlags[i]);
+                }
+            }
+            nk_combo_end(ctx);
+        }
+    }
+    {
+        static int         pickedAnchor  = 0;
+        static const char* anchorItems[] = {
+            "Anchor Top" , "Anchor Bottom",
+            "Anchor Left", "Anchor Right"
+        };
+        static const int anchorFlags[]   = {
+            GLFW_WAYLAND_ZWLR_ANCHOR_TOP,  GLFW_WAYLAND_ZWLR_ANCHOR_BOTTOM,
+            GLFW_WAYLAND_ZWLR_ANCHOR_LEFT, GLFW_WAYLAND_ZWLR_ANCHOR_RIGHT
+        };
+        if (nk_combo_begin_label(ctx, anchorItems[pickedAnchor], nk_vec2(200, 200)))
+        {
+            nk_layout_row_dynamic(ctx, 30, 1);
+            for (int i = 0; i < 4; i++)
+            {
+                if (nk_combo_item_label(ctx, anchorItems[i], NK_TEXT_LEFT))
+                {
+                    pickedAnchor = i;
+                    glfwWaylandZwlrSetAnchor(window, anchorFlags[i]); // Flags can be combined, but..
+                }                                                     // ..it's pain in ass to implement here
+            }
+            nk_combo_end(ctx);
+        }
+    }
+}
+
+
+

include/GLFW/glfw3.h

@@ -1135,6 +1135,27 @@ extern "C" {
  *  Allows specification of the Wayland app_id.
  */
 #define GLFW_WAYLAND_APP_ID         0x00026001
+
+#define GLFW_WAYLAND_ZWLR_LAYER_BACKGROUND 0x00026002
+#define GLFW_WAYLAND_ZWLR_LAYER_BOTTOM     0x00026003
+#define GLFW_WAYLAND_ZWLR_LAYER_TOP        0x00026004
+#define GLFW_WAYLAND_ZWLR_LAYER_OVERLAY    0x00026005
+
+#define GLFW_WAYLAND_ZWLR_ANCHOR_TOP      0x1
+#define GLFW_WAYLAND_ZWLR_ANCHOR_BOTTOM   0x2
+#define GLFW_WAYLAND_ZWLR_ANCHOR_LEFT     0x4
+#define GLFW_WAYLAND_ZWLR_ANCHOR_RIGHT    0x8
+/*! @brief Wayland specific
+ *  [window hint](@ref GLFW_WAYLAND_USE_ZWLR_hint).
+ *
+ *  Available options are:
+ *    - GLFW_WAYLAND_ZWLR_BACKGROUND
+ *    - GLFW_WAYLAND_ZWLR_BOTTOM
+ *    - GLFW_WAYLAND_ZWLR_TOP
+ *    - GLFW_WAYLAND_ZWLR_OVERLAY
+ */
+#define GLFW_WAYLAND_USE_ZWLR 0x00026010
+
 /*! @} */
 
 #define GLFW_NO_API                          0

include/GLFW/glfw3native.h

@@ -554,6 +554,81 @@ GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
  *  @ingroup native
  */
 GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
+
+/*! @brief Change the layer that the surface is rendered on.
+ *
+ *  @errors Possible errors include @ref GLFW_FEATURE_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_UNAVAILABLE and @ref GLFW_INVALID_ENUM.
+ *
+ * @param[in] layer GLFW_WAYLAND_ZWLR_LAYER_BACKGROUD,
+ *                  GLFW_WAYLAND_ZWLR_LAYER_BOTTOM,
+ *                  GLFW_WAYLAND_ZWLR_LAYER_TOP,
+ *                  GLFW_WAYLAND_ZWLR_LAYER_OVERLAY.
+
+ *  @thread_safety This function should be called from main thread.
+ *
+ *  @since Added in version 3.5.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwWaylandZwlrSetLayer(GLFWwindow* window, int layer);
+
+/*! @brief Configures the anchor point of the surface.
+ *
+ *  Requests that the compositor anchor the surface to the specified
+ *  edges and corners. If two orthogonal 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.
+ *
+ * @param[in] anchor GLFW_WAYLAND_ZWLR_ANCHOR_TOP |
+ *                   GLFW_WAYLAND_ZWLR_ANCHOR_BOTTOM |
+ *                   GLFW_WAYLAND_ZWLR_ANCHOR_LEFT |
+ *                   GLFW_WAYLAND_ZWLR_ANCHOR_RIGHT
+ *
+ *  @errors Possible errors include @ref GLFW_FEATURE_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_UNAVAILABLE. Viewport is centered if you send incorrect anchor.
+ *
+ *  @thread_safety This function should be called from main thread.
+ *
+ *  @since Added in version 3.5.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwWaylandZwlrSetAnchor(GLFWwindow* window, int anchor);
+
+/*! @brief Requests that the compositor avoids occluding an area with other surfaces.
+ *
+ *  @note The compositor's use of this information is implementation-dependent.
+ *        Do not assume that this region will not actually be occluded.
+ *
+ *  @errors Possible errors include @ref GLFW_FEATURE_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_UNAVAILABLE.
+ *
+ *  @thread_safety This function should be called from main thread.
+ *
+ *  @since Added in version 3.5.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwWaylandZwlrSetExclusiveZone(GLFWwindow* window, int zone);
+
+/*! @brief 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.
+ *
+ *  @errors Possible errors include @ref GLFW_FEATURE_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_UNAVAILABLE.
+ *
+ *  @thread_safety This function should be called from main thread.
+ *
+ *  @since Added in version 3.5.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwWaylandZwlrSetMargin(GLFWwindow* window, int top, int right, int bottom, int left);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_EGL)

src/CMakeLists.txt

@@ -105,6 +105,7 @@ if (GLFW_BUILD_WAYLAND)
     generate_wayland_protocol("fractional-scale-v1.xml")
     generate_wayland_protocol("xdg-activation-v1.xml")
     generate_wayland_protocol("xdg-decoration-unstable-v1.xml")
+    generate_wayland_protocol("wlr-layer-shell-unstable-v1.xml")
 endif()
 
 if (WIN32 AND GLFW_BUILD_SHARED_LIBRARY)

src/init.c

@@ -33,7 +33,6 @@
 #include <stdarg.h>
 #include <assert.h>
 
-
 // NOTE: The global variables below comprise all mutable global data in GLFW
 //       Any other mutable global variable is a bug
 

src/internal.h

@@ -427,6 +427,7 @@ struct _GLFWwndconfig
     } win32;
     struct {
         char      appId[256];
+        GLFWbool  useZWLR;
     } wl;
 };
 

src/window.c

@@ -381,6 +381,9 @@ GLFWAPI void glfwWindowHint(int hint, int value)
         case GLFW_COCOA_GRAPHICS_SWITCHING:
             _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
             return;
+        case GLFW_WAYLAND_USE_ZWLR:
+            _glfw.hints.window.wl.useZWLR = value;
+            return;
         case GLFW_SCALE_TO_MONITOR:
             _glfw.hints.window.scaleToMonitor = value ? GLFW_TRUE : GLFW_FALSE;
             return;

src/wl_init.c

@@ -49,6 +49,7 @@
 #include "fractional-scale-v1-client-protocol.h"
 #include "xdg-activation-v1-client-protocol.h"
 #include "idle-inhibit-unstable-v1-client-protocol.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
 // NOTE: Versions of wayland-scanner prior to 1.17.91 named every global array of
 //       wl_interface pointers 'types', making it impossible to combine several unmodified
@@ -91,6 +92,11 @@
 #include "idle-inhibit-unstable-v1-client-protocol-code.h"
 #undef types
 
+#define types _glfw_zwlr_layer_shell_types
+#include "wlr-layer-shell-unstable-v1-client-protocol-code.h"
+#undef types
+
+
 static void wmBaseHandlePing(void* userData,
                              struct xdg_wm_base* wmBase,
                              uint32_t serial)
@@ -208,6 +214,13 @@ static void registryHandleGlobal(void* userData,
                              &wp_fractional_scale_manager_v1_interface,
                              1);
     }
+    else if (strcmp(interface, "zwlr_layer_shell_v1") == 0)
+    {
+        _glfw.wl.zwlrLayerShell =
+            wl_registry_bind(registry, name,
+                             &zwlr_layer_shell_v1_interface,
+                             5); // use the latest version, because why not? (since 2017)
+    }
 }
 
 static void registryHandleGlobalRemove(void* userData,
@@ -395,6 +408,8 @@ static void createKeyTables(void)
     }
 }
 
+
+
 static GLFWbool loadCursorTheme(void)
 {
     int cursorSize = 16;
@@ -424,6 +439,7 @@ static GLFWbool loadCursorTheme(void)
 
     _glfw.wl.cursorSurface = wl_compositor_create_surface(_glfw.wl.compositor);
     _glfw.wl.cursorTimerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
+
     return GLFW_TRUE;
 }
 
@@ -948,6 +964,8 @@ void _glfwTerminateWayland(void)
 
     _glfw_free(_glfw.wl.offers);
 
+    if(_glfw.wl.zwlrLayerShell)
+        zwlr_layer_shell_v1_destroy(_glfw.wl.zwlrLayerShell);
     if (_glfw.wl.cursorSurface)
         wl_surface_destroy(_glfw.wl.cursorSurface);
     if (_glfw.wl.subcompositor)

src/wl_platform.h

@@ -130,6 +130,7 @@ struct wl_output;
 #define xdg_activation_token_v1_interface _glfw_xdg_activation_token_v1_interface
 #define wl_surface_interface _glfw_wl_surface_interface
 #define wp_fractional_scale_v1_interface _glfw_wp_fractional_scale_v1_interface
+#define zwlr_layer_shell_v1_interface _glfw_zwlr_layer_shell_v1
 
 #define GLFW_WAYLAND_WINDOW_STATE         _GLFWwindowWayland  wl;
 #define GLFW_WAYLAND_LIBRARY_WINDOW_STATE _GLFWlibraryWayland wl;
@@ -381,6 +382,11 @@ typedef struct _GLFWwindowWayland
         uint32_t                decorationMode;
     } xdg;
 
+    struct {
+        struct zwlr_layer_surface_v1* surface;
+    } zwlr;
+
+
     struct {
         struct libdecor_frame*  frame;
     } libdecor;
@@ -440,6 +446,7 @@ typedef struct _GLFWlibraryWayland
     struct zwp_idle_inhibit_manager_v1*     idleInhibitManager;
     struct xdg_activation_v1*               activationManager;
     struct wp_fractional_scale_manager_v1*  fractionalScaleManager;
+    struct zwlr_layer_shell_v1*             zwlrLayerShell;
 
     _GLFWofferWayland*          offers;
     unsigned int                offerCount;

src/wl_window.c

@@ -51,6 +51,7 @@
 #include "xdg-activation-v1-client-protocol.h"
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "fractional-scale-v1-client-protocol.h"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
 #define GLFW_BORDER_SIZE    4
 #define GLFW_CAPTION_HEIGHT 24
@@ -495,6 +496,9 @@ static GLFWbool resizeWindow(_GLFWwindow* window, int width, int height)
     window->wl.width = width;
     window->wl.height = height;
 
+    if (window->wl.zwlr.surface)
+        zwlr_layer_surface_v1_set_size(window->wl.zwlr.surface, width, height);
+
     resizeFramebuffer(window);
 
     if (window->wl.scalingViewport)
@@ -1130,8 +1134,73 @@ static GLFWbool createXdgShellObjects(_GLFWwindow* window)
     return GLFW_TRUE;
 }
 
+static void zwlrSurfaceConfigure(void *data,
+                                 struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1,
+                                 uint32_t serial,
+                                 uint32_t width,
+                                 uint32_t height)
+{
+    _GLFWwindow* window = data;
+
+    window->wl.visible = GLFW_TRUE; // I'm not sure this belong here, but window not visible without
+    resizeWindow(window, width, height);
+
+    zwlr_layer_surface_v1_ack_configure(zwlr_layer_surface_v1, serial);
+}
+
+static void zwlrSurfaceClose(void *userData,
+                             struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1)
+{
+    _GLFWwindow* window = userData;
+    _glfwInputWindowCloseRequest(window);
+
+}
+
+static const struct zwlr_layer_surface_v1_listener zwlrSurfaceListener =
+{
+    .configure = zwlrSurfaceConfigure,
+    .closed    = zwlrSurfaceClose
+};
+
+static bool createZwlrShellObjects(_GLFWwindow* window)
+{
+    if (!_glfw.wl.zwlrLayerShell)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: zwlr protocol not supported on this system");
+        return GLFW_FALSE;
+    }
+
+    window->wl.zwlr.surface = zwlr_layer_shell_v1_get_layer_surface(_glfw.wl.zwlrLayerShell,
+        window->wl.surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_TOP, window->title);
+
+    if (!window->wl.zwlr.surface)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to create layer surface for window");
+        return GLFW_FALSE;
+    }
+    zwlr_layer_surface_v1_add_listener(window->wl.zwlr.surface, &zwlrSurfaceListener,
+                                       window);
+
+
+    zwlr_layer_surface_v1_set_anchor(window->wl.zwlr.surface, 0); // center
+    zwlr_layer_surface_v1_set_size(window->wl.zwlr.surface,
+                                   window->wl.fbWidth, window->wl.fbHeight);
+
+    glfwWaylandZwlrSetLayer((GLFWwindow*)window, _glfw.hints.window.wl.useZWLR);
+
+    wl_surface_commit(window->wl.surface);
+    wl_display_roundtrip(_glfw.wl.display);
+
+    return GLFW_TRUE;
+}
+
 static GLFWbool createShellObjects(_GLFWwindow* window)
 {
+    if (_glfw.hints.window.wl.useZWLR)         // I can't imagine why fallback to xdg needed..
+        return createZwlrShellObjects(window); // ..if user explicitly request zwlr.
+
     if (_glfw.wl.libdecor.context)
     {
         if (createLibdecorFrame(window))
@@ -1157,6 +1226,9 @@ static void destroyShellObjects(_GLFWwindow* window)
     if (window->wl.xdg.surface)
         xdg_surface_destroy(window->wl.xdg.surface);
 
+    if (window->wl.zwlr.surface)
+        zwlr_layer_surface_v1_destroy(window->wl.zwlr.surface);
+
     window->wl.libdecor.frame = NULL;
     window->wl.xdg.decoration = NULL;
     window->wl.xdg.decorationMode = 0;
@@ -1545,6 +1617,13 @@ static void pointerHandleEnter(void* userData,
             window->wl.cursorPosY = wl_fixed_to_double(sy);
             _glfwInputCursorPos(window, window->wl.cursorPosX, window->wl.cursorPosY);
         }
+
+        if (window->wl.zwlr.surface)
+        {
+            // mf don't receive keyboard events by default
+            zwlr_layer_surface_v1_set_keyboard_interactivity(window->wl.zwlr.surface,
+                                ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND);
+        }
     }
     else
     {
@@ -1574,6 +1653,12 @@ static void pointerHandleLeave(void* userData,
     _glfw.wl.serial = serial;
     _glfw.wl.pointerFocus = NULL;
 
+    if (window->wl.zwlr.surface) // TODO: find out why wl.hovered not fired
+    {
+        zwlr_layer_surface_v1_set_keyboard_interactivity(window->wl.zwlr.surface,
+                            ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE);
+    }
+
     if (window->wl.hovered)
     {
         window->wl.hovered = GLFW_FALSE;
@@ -2653,7 +2738,7 @@ void _glfwSetWindowDecoratedWayland(_GLFWwindow* window, GLFWbool enabled)
 void _glfwSetWindowFloatingWayland(_GLFWwindow* window, GLFWbool enabled)
 {
     _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
-                    "Wayland: Platform does not support making a window floating");
+                    "Wayland: hint GLFW_WAYLAND_USE_ZWLR for layer support");
 }
 
 void _glfwSetWindowMousePassthroughWayland(_GLFWwindow* window, GLFWbool enabled)
@@ -3360,5 +3445,111 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
     return window->wl.surface;
 }
 
+GLFWAPI void glfwWaylandZwlrSetLayer(GLFWwindow* handle, int layer)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
+    {
+        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
+                        "Wayland: Platform not initialized");
+        return;
+    }
+
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    if (!(window->wl.zwlr.surface))
+    {
+        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
+                        "Wayland: zwlr not supported or wasn't requested");
+        return;
+
+    }
+
+    switch (layer)
+    {
+        case GLFW_WAYLAND_ZWLR_LAYER_BACKGROUND: layer = ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND; break;
+        case GLFW_WAYLAND_ZWLR_LAYER_BOTTOM:     layer = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;     break;
+        case GLFW_WAYLAND_ZWLR_LAYER_TOP:        layer = ZWLR_LAYER_SHELL_V1_LAYER_TOP;        break;
+        case GLFW_WAYLAND_ZWLR_LAYER_OVERLAY:    layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;    break;
+        default:
+        {
+            _glfwInputError(GLFW_INVALID_ENUM,
+                            "Wayland: invalid zwlr layer received");
+            return;
+        }
+    }
+
+    zwlr_layer_surface_v1_set_layer(window->wl.zwlr.surface, layer);
+    if (layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM || layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND)
+        zwlr_layer_surface_v1_set_keyboard_interactivity(window->wl.zwlr.surface,
+                                            ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE);
+}
+
+GLFWAPI void glfwWaylandZwlrSetAnchor(GLFWwindow* handle, int anchor)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
+    {
+        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
+                        "Wayland: Platform not initialized");
+        return;
+    }
+
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    if (!(window->wl.zwlr.surface))
+    {
+        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
+                        "Wayland: zwlr not supported or wasn't requested");
+        return;
+    }
+
+    zwlr_layer_surface_v1_set_anchor(window->wl.zwlr.surface, anchor);
+}
+
+GLFWAPI void glfwWaylandZwlrSetExclusiveZone(GLFWwindow* handle, int zone)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
+    {
+        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
+                        "Wayland: Platform not initialized");
+        return;
+    }
+
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    if (!(window->wl.zwlr.surface))
+    {
+        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
+                        "Wayland: zwlr not supported or wasn't requested");
+        return;
+    }
+
+    zwlr_layer_surface_v1_set_exclusive_zone(window->wl.zwlr.surface, zone);
+}
+
+GLFWAPI void glfwWaylandZwlrSetMargin(GLFWwindow* handle, int top, int right, int bottom, int left)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
+    {
+        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE,
+                        "Wayland: Platform not initialized");
+        return;
+    }
+
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    if (!(window->wl.zwlr.surface))
+    {
+        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
+                        "Wayland: zwlr not supported or wasn't requested");
+        return;
+    }
+
+    zwlr_layer_surface_v1_set_margin(window->wl.zwlr.surface, top, right, bottom, left);
+}
+
 #endif // _GLFW_WAYLAND