bar and blocks

44 files changed, 5694 insertions, 1 deletions

diff --git a/wm/dwl/config.h b/wm/dwl/config.h
index 35f9dd7..a53bd90 100644
--- a/wm/dwl/config.h
+++ b/wm/dwl/config.h
@@ -133,7 +133,7 @@ static const Key keys[] = {
 	{ MODKEY,                    XKB_KEY_Tab,        view,           {0} },
 	{ MODKEY,                    XKB_KEY_x,          killclient,     {0} },
 	{ MODKEY,                    XKB_KEY_t,          setlayout,      {.v = &layouts[0]} },
-	{ MODKEY,                    XKB_KEY_f,          setlayout,      {.v = &layouts[1]} },
+	{ MODKEY,                    XKB_KEY_o,          setlayout,      {.v = &layouts[1]} },
 	{ MODKEY,                    XKB_KEY_m,          setlayout,      {.v = &layouts[2]} },
 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
diff --git a/wm/dwl/dwl b/wm/dwl/dwl
new file mode 100755
index 0000000..1349f93
--- /dev/null
+++ b/wm/dwl/dwl
diff --git a/wm/dwl/wlr-layer-shell-unstable-v1-protocol.h b/wm/dwl/wlr-layer-shell-unstable-v1-protocol.h
new file mode 100644
index 0000000..3b4d7e7
--- /dev/null
+++ b/wm/dwl/wlr-layer-shell-unstable-v1-protocol.h
@@ -0,0 +1,606 @@
+/* Generated by wayland-scanner 1.21.0 */
+
+#ifndef WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H
+#define WLR_LAYER_SHELL_UNSTABLE_V1_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_wlr_layer_shell_unstable_v1 The wlr_layer_shell_unstable_v1 protocol
+ * @section page_ifaces_wlr_layer_shell_unstable_v1 Interfaces
+ * - @subpage page_iface_zwlr_layer_shell_v1 - create surfaces that are layers of the desktop
+ * - @subpage page_iface_zwlr_layer_surface_v1 - layer metadata interface
+ * @section page_copyright_wlr_layer_shell_unstable_v1 Copyright
+ * <pre>
+ *
+ * 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.
+ * </pre>
+ */
+struct wl_output;
+struct wl_surface;
+struct xdg_popup;
+struct zwlr_layer_shell_v1;
+struct zwlr_layer_surface_v1;
+
+#ifndef ZWLR_LAYER_SHELL_V1_INTERFACE
+#define ZWLR_LAYER_SHELL_V1_INTERFACE
+/**
+ * @page page_iface_zwlr_layer_shell_v1 zwlr_layer_shell_v1
+ * @section page_iface_zwlr_layer_shell_v1_desc Description
+ *
+ * Clients can use this interface to assign the surface_layer role to
+ * wl_surfaces. Such surfaces are assigned to a "layer" of the output and
+ * rendered with a defined z-depth respective to each other. They may also be
+ * anchored to the edges and corners of a screen and specify input handling
+ * semantics. This interface should be suitable for the implementation of
+ * many desktop shell components, and a broad number of other applications
+ * that interact with the desktop.
+ * @section page_iface_zwlr_layer_shell_v1_api API
+ * See @ref iface_zwlr_layer_shell_v1.
+ */
+/**
+ * @defgroup iface_zwlr_layer_shell_v1 The zwlr_layer_shell_v1 interface
+ *
+ * Clients can use this interface to assign the surface_layer role to
+ * wl_surfaces. Such surfaces are assigned to a "layer" of the output and
+ * rendered with a defined z-depth respective to each other. They may also be
+ * anchored to the edges and corners of a screen and specify input handling
+ * semantics. This interface should be suitable for the implementation of
+ * many desktop shell components, and a broad number of other applications
+ * that interact with the desktop.
+ */
+extern const struct wl_interface zwlr_layer_shell_v1_interface;
+#endif
+#ifndef ZWLR_LAYER_SURFACE_V1_INTERFACE
+#define ZWLR_LAYER_SURFACE_V1_INTERFACE
+/**
+ * @page page_iface_zwlr_layer_surface_v1 zwlr_layer_surface_v1
+ * @section page_iface_zwlr_layer_surface_v1_desc Description
+ *
+ * An interface that may be implemented by a wl_surface, for surfaces that
+ * are designed to be rendered as a layer of a stacked desktop-like
+ * environment.
+ *
+ * Layer surface state (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.
+ * @section page_iface_zwlr_layer_surface_v1_api API
+ * See @ref iface_zwlr_layer_surface_v1.
+ */
+/**
+ * @defgroup iface_zwlr_layer_surface_v1 The zwlr_layer_surface_v1 interface
+ *
+ * An interface that may be implemented by a wl_surface, for surfaces that
+ * are designed to be rendered as a layer of a stacked desktop-like
+ * environment.
+ *
+ * Layer surface state (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.
+ */
+extern const struct wl_interface zwlr_layer_surface_v1_interface;
+#endif
+
+#ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM
+#define ZWLR_LAYER_SHELL_V1_ERROR_ENUM
+enum zwlr_layer_shell_v1_error {
+	/**
+	 * wl_surface has another role
+	 */
+	ZWLR_LAYER_SHELL_V1_ERROR_ROLE = 0,
+	/**
+	 * layer value is invalid
+	 */
+	ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER = 1,
+	/**
+	 * wl_surface has a buffer attached or committed
+	 */
+	ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED = 2,
+};
+#endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM */
+
+#ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM
+#define ZWLR_LAYER_SHELL_V1_LAYER_ENUM
+/**
+ * @ingroup iface_zwlr_layer_shell_v1
+ * available layers for surfaces
+ *
+ * These values indicate which layers a surface can be rendered in. They
+ * are ordered by z depth, bottom-most first. Traditional shell surfaces
+ * will typically be rendered between the bottom and top layers.
+ * Fullscreen shell surfaces are typically rendered at the top layer.
+ * Multiple surfaces can share a single layer, and ordering within a
+ * single layer is undefined.
+ */
+enum zwlr_layer_shell_v1_layer {
+	ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0,
+	ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM = 1,
+	ZWLR_LAYER_SHELL_V1_LAYER_TOP = 2,
+	ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY = 3,
+};
+#endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM */
+
+/**
+ * @ingroup iface_zwlr_layer_shell_v1
+ * @struct zwlr_layer_shell_v1_interface
+ */
+struct zwlr_layer_shell_v1_interface {
+	/**
+	 * 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.
+	 * @param layer layer to add this surface to
+	 * @param namespace namespace for the layer surface
+	 */
+	void (*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);
+	/**
+	 * 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.
+	 * @since 3
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+};
+
+
+/**
+ * @ingroup iface_zwlr_layer_shell_v1
+ */
+#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_shell_v1
+ */
+#define ZWLR_LAYER_SHELL_V1_DESTROY_SINCE_VERSION 3
+
+#ifndef ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM
+#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ * 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.
+ */
+enum zwlr_layer_surface_v1_keyboard_interactivity {
+	/**
+	 * 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.
+	 */
+	ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE = 0,
+	/**
+	 * 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.
+	 */
+	ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE = 1,
+	/**
+	 * 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.
+	 * @since 4
+	 */
+	ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND = 2,
+};
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND_SINCE_VERSION 4
+#endif /* ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM */
+
+#ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM
+#define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM
+enum zwlr_layer_surface_v1_error {
+	/**
+	 * provided surface state is invalid
+	 */
+	ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE = 0,
+	/**
+	 * size is invalid
+	 */
+	ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE = 1,
+	/**
+	 * anchor bitfield is invalid
+	 */
+	ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR = 2,
+	/**
+	 * keyboard interactivity is invalid
+	 */
+	ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_KEYBOARD_INTERACTIVITY = 3,
+};
+#endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM */
+
+#ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM
+#define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM
+enum zwlr_layer_surface_v1_anchor {
+	/**
+	 * the top edge of the anchor rectangle
+	 */
+	ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP = 1,
+	/**
+	 * the bottom edge of the anchor rectangle
+	 */
+	ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2,
+	/**
+	 * the left edge of the anchor rectangle
+	 */
+	ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT = 4,
+	/**
+	 * the right edge of the anchor rectangle
+	 */
+	ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT = 8,
+};
+#endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM */
+
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ * @struct zwlr_layer_surface_v1_interface
+ */
+struct zwlr_layer_surface_v1_interface {
+	/**
+	 * 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.
+	 */
+	void (*set_size)(struct wl_client *client,
+			 struct wl_resource *resource,
+			 uint32_t width,
+			 uint32_t height);
+	/**
+	 * 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.
+	 */
+	void (*set_anchor)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   uint32_t anchor);
+	/**
+	 * 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.
+	 */
+	void (*set_exclusive_zone)(struct wl_client *client,
+				   struct wl_resource *resource,
+				   int32_t zone);
+	/**
+	 * 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.
+	 */
+	void (*set_margin)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   int32_t top,
+			   int32_t right,
+			   int32_t bottom,
+			   int32_t left);
+	/**
+	 * 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.
+	 */
+	void (*set_keyboard_interactivity)(struct wl_client *client,
+					   struct wl_resource *resource,
+					   uint32_t keyboard_interactivity);
+	/**
+	 * 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.
+	 */
+	void (*get_popup)(struct wl_client *client,
+			  struct wl_resource *resource,
+			  struct wl_resource *popup);
+	/**
+	 * 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.
+	 * @param serial the serial from the configure event
+	 */
+	void (*ack_configure)(struct wl_client *client,
+			      struct wl_resource *resource,
+			      uint32_t serial);
+	/**
+	 * destroy the layer_surface
+	 *
+	 * This request destroys the layer surface.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * change the layer of the surface
+	 *
+	 * Change the layer that the surface is rendered on.
+	 *
+	 * Layer is double-buffered, see wl_surface.commit.
+	 * @param layer layer to move this surface to
+	 * @since 2
+	 */
+	void (*set_layer)(struct wl_client *client,
+			  struct wl_resource *resource,
+			  uint32_t layer);
+};
+
+#define ZWLR_LAYER_SURFACE_V1_CONFIGURE 0
+#define ZWLR_LAYER_SURFACE_V1_CLOSED 1
+
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_CLOSED_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_GET_POPUP_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ */
+#define ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION 2
+
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ * Sends an configure event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+zwlr_layer_surface_v1_send_configure(struct wl_resource *resource_, uint32_t serial, uint32_t width, uint32_t height)
+{
+	wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CONFIGURE, serial, width, height);
+}
+
+/**
+ * @ingroup iface_zwlr_layer_surface_v1
+ * Sends an closed event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+zwlr_layer_surface_v1_send_closed(struct wl_resource *resource_)
+{
+	wl_resource_post_event(resource_, ZWLR_LAYER_SURFACE_V1_CLOSED);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/wm/dwl/xdg-shell-protocol.h b/wm/dwl/xdg-shell-protocol.h
new file mode 100644
index 0000000..8db7e1c
--- /dev/null
+++ b/wm/dwl/xdg-shell-protocol.h
@@ -0,0 +1,1933 @@
+/* Generated by wayland-scanner 1.21.0 */
+
+#ifndef XDG_SHELL_SERVER_PROTOCOL_H
+#define XDG_SHELL_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_xdg_shell The xdg_shell protocol
+ * @section page_ifaces_xdg_shell Interfaces
+ * - @subpage page_iface_xdg_wm_base - create desktop-style surfaces
+ * - @subpage page_iface_xdg_positioner - child surface positioner
+ * - @subpage page_iface_xdg_surface - desktop user interface surface base interface
+ * - @subpage page_iface_xdg_toplevel - toplevel surface
+ * - @subpage page_iface_xdg_popup - short-lived, popup surfaces for menus
+ * @section page_copyright_xdg_shell Copyright
+ * <pre>
+ *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_output;
+struct wl_seat;
+struct wl_surface;
+struct xdg_popup;
+struct xdg_positioner;
+struct xdg_surface;
+struct xdg_toplevel;
+struct xdg_wm_base;
+
+#ifndef XDG_WM_BASE_INTERFACE
+#define XDG_WM_BASE_INTERFACE
+/**
+ * @page page_iface_xdg_wm_base xdg_wm_base
+ * @section page_iface_xdg_wm_base_desc Description
+ *
+ * The xdg_wm_base interface is exposed as a global object enabling clients
+ * to turn their wl_surfaces into windows in a desktop environment. It
+ * defines the basic functionality needed for clients and the compositor to
+ * create windows that can be dragged, resized, maximized, etc, as well as
+ * creating transient windows such as popup menus.
+ * @section page_iface_xdg_wm_base_api API
+ * See @ref iface_xdg_wm_base.
+ */
+/**
+ * @defgroup iface_xdg_wm_base The xdg_wm_base interface
+ *
+ * The xdg_wm_base interface is exposed as a global object enabling clients
+ * to turn their wl_surfaces into windows in a desktop environment. It
+ * defines the basic functionality needed for clients and the compositor to
+ * create windows that can be dragged, resized, maximized, etc, as well as
+ * creating transient windows such as popup menus.
+ */
+extern const struct wl_interface xdg_wm_base_interface;
+#endif
+#ifndef XDG_POSITIONER_INTERFACE
+#define XDG_POSITIONER_INTERFACE
+/**
+ * @page page_iface_xdg_positioner xdg_positioner
+ * @section page_iface_xdg_positioner_desc Description
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle. These positioner-created rules are
+ * constrained by the requirement that a child surface must intersect with or
+ * be at least partially adjacent to its parent surface.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an invalid_positioner error.
+ * @section page_iface_xdg_positioner_api API
+ * See @ref iface_xdg_positioner.
+ */
+/**
+ * @defgroup iface_xdg_positioner The xdg_positioner interface
+ *
+ * The xdg_positioner provides a collection of rules for the placement of a
+ * child surface relative to a parent surface. Rules can be defined to ensure
+ * the child surface remains within the visible area's borders, and to
+ * specify how the child surface changes its position, such as sliding along
+ * an axis, or flipping around a rectangle. These positioner-created rules are
+ * constrained by the requirement that a child surface must intersect with or
+ * be at least partially adjacent to its parent surface.
+ *
+ * See the various requests for details about possible rules.
+ *
+ * At the time of the request, the compositor makes a copy of the rules
+ * specified by the xdg_positioner. Thus, after the request is complete the
+ * xdg_positioner object can be destroyed or reused; further changes to the
+ * object will have no effect on previous usages.
+ *
+ * For an xdg_positioner object to be considered complete, it must have a
+ * non-zero size set by set_size, and a non-zero anchor rectangle set by
+ * set_anchor_rect. Passing an incomplete xdg_positioner object when
+ * positioning a surface raises an invalid_positioner error.
+ */
+extern const struct wl_interface xdg_positioner_interface;
+#endif
+#ifndef XDG_SURFACE_INTERFACE
+#define XDG_SURFACE_INTERFACE
+/**
+ * @page page_iface_xdg_surface xdg_surface
+ * @section page_iface_xdg_surface_desc Description
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * After creating a role-specific object and setting it up, the client must
+ * perform an initial commit without any buffer attached. The compositor
+ * will reply with an xdg_surface.configure event. The client must
+ * acknowledge it and is then allowed to attach a buffer to map the surface.
+ *
+ * Mapping an xdg_surface-based role surface is defined as making it
+ * possible for the surface to be shown by the compositor. Note that
+ * a mapped surface is not guaranteed to be visible once it is mapped.
+ *
+ * For an xdg_surface to be mapped by the compositor, the following
+ * conditions must be met:
+ * (1) the client has assigned an xdg_surface-based role to the surface
+ * (2) the client has set and committed the xdg_surface state and the
+ * role-dependent state to the surface
+ * (3) the client has committed a buffer to the surface
+ *
+ * A newly-unmapped surface is considered to have met condition (1) out
+ * of the 3 required conditions for mapping a surface if its role surface
+ * has not been destroyed, i.e. the client must perform the initial commit
+ * again before attaching a buffer.
+ * @section page_iface_xdg_surface_api API
+ * See @ref iface_xdg_surface.
+ */
+/**
+ * @defgroup iface_xdg_surface The xdg_surface interface
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides a base set of functionality required to construct user
+ * interface elements requiring management by the compositor, such as
+ * toplevel windows, menus, etc. The types of functionality are split into
+ * xdg_surface roles.
+ *
+ * Creating an xdg_surface does not set the role for a wl_surface. In order
+ * to map an xdg_surface, the client must create a role-specific object
+ * using, e.g., get_toplevel, get_popup. The wl_surface for any given
+ * xdg_surface can have at most one role, and may not be assigned any role
+ * not based on xdg_surface.
+ *
+ * A role must be assigned before any other requests are made to the
+ * xdg_surface object.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface state to take effect.
+ *
+ * Creating an xdg_surface from a wl_surface which has a buffer attached or
+ * committed is a client error, and any attempts by a client to attach or
+ * manipulate a buffer prior to the first xdg_surface.configure call must
+ * also be treated as errors.
+ *
+ * After creating a role-specific object and setting it up, the client must
+ * perform an initial commit without any buffer attached. The compositor
+ * will reply with an xdg_surface.configure event. The client must
+ * acknowledge it and is then allowed to attach a buffer to map the surface.
+ *
+ * Mapping an xdg_surface-based role surface is defined as making it
+ * possible for the surface to be shown by the compositor. Note that
+ * a mapped surface is not guaranteed to be visible once it is mapped.
+ *
+ * For an xdg_surface to be mapped by the compositor, the following
+ * conditions must be met:
+ * (1) the client has assigned an xdg_surface-based role to the surface
+ * (2) the client has set and committed the xdg_surface state and the
+ * role-dependent state to the surface
+ * (3) the client has committed a buffer to the surface
+ *
+ * A newly-unmapped surface is considered to have met condition (1) out
+ * of the 3 required conditions for mapping a surface if its role surface
+ * has not been destroyed, i.e. the client must perform the initial commit
+ * again before attaching a buffer.
+ */
+extern const struct wl_interface xdg_surface_interface;
+#endif
+#ifndef XDG_TOPLEVEL_INTERFACE
+#define XDG_TOPLEVEL_INTERFACE
+/**
+ * @page page_iface_xdg_toplevel xdg_toplevel
+ * @section page_iface_xdg_toplevel_desc Description
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ *
+ * Unmapping an xdg_toplevel means that the surface cannot be shown
+ * by the compositor until it is explicitly mapped again.
+ * All active operations (e.g., move, resize) are canceled and all
+ * attributes (e.g. title, state, stacking, ...) are discarded for
+ * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
+ * the state it had right after xdg_surface.get_toplevel. The client
+ * can re-map the toplevel by perfoming a commit without any buffer
+ * attached, waiting for a configure event and handling it as usual (see
+ * xdg_surface description).
+ *
+ * Attaching a null buffer to a toplevel unmaps the surface.
+ * @section page_iface_xdg_toplevel_api API
+ * See @ref iface_xdg_toplevel.
+ */
+/**
+ * @defgroup iface_xdg_toplevel The xdg_toplevel interface
+ *
+ * This interface defines an xdg_surface role which allows a surface to,
+ * among other things, set window-like properties such as maximize,
+ * fullscreen, and minimize, set application-specific metadata like title and
+ * id, and well as trigger user interactive operations such as interactive
+ * resize and move.
+ *
+ * Unmapping an xdg_toplevel means that the surface cannot be shown
+ * by the compositor until it is explicitly mapped again.
+ * All active operations (e.g., move, resize) are canceled and all
+ * attributes (e.g. title, state, stacking, ...) are discarded for
+ * an xdg_toplevel surface when it is unmapped. The xdg_toplevel returns to
+ * the state it had right after xdg_surface.get_toplevel. The client
+ * can re-map the toplevel by perfoming a commit without any buffer
+ * attached, waiting for a configure event and handling it as usual (see
+ * xdg_surface description).
+ *
+ * Attaching a null buffer to a toplevel unmaps the surface.
+ */
+extern const struct wl_interface xdg_toplevel_interface;
+#endif
+#ifndef XDG_POPUP_INTERFACE
+#define XDG_POPUP_INTERFACE
+/**
+ * @page page_iface_xdg_popup xdg_popup
+ * @section page_iface_xdg_popup_desc Description
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ * @section page_iface_xdg_popup_api API
+ * See @ref iface_xdg_popup.
+ */
+/**
+ * @defgroup iface_xdg_popup The xdg_popup interface
+ *
+ * A popup surface is a short-lived, temporary surface. It can be used to
+ * implement for example menus, popovers, tooltips and other similar user
+ * interface concepts.
+ *
+ * A popup can be made to take an explicit grab. See xdg_popup.grab for
+ * details.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out, and at
+ * the same time the surface will be unmapped. See the xdg_popup.popup_done
+ * event for details.
+ *
+ * Explicitly destroying the xdg_popup object will also dismiss the popup and
+ * unmap the surface. Clients that want to dismiss the popup when another
+ * surface of their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * A newly created xdg_popup will be stacked on top of all previously created
+ * xdg_popup surfaces associated with the same xdg_toplevel.
+ *
+ * The parent of an xdg_popup must be mapped (see the xdg_surface
+ * description) before the xdg_popup itself.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup state to take effect.
+ */
+extern const struct wl_interface xdg_popup_interface;
+#endif
+
+#ifndef XDG_WM_BASE_ERROR_ENUM
+#define XDG_WM_BASE_ERROR_ENUM
+enum xdg_wm_base_error {
+	/**
+	 * given wl_surface has another role
+	 */
+	XDG_WM_BASE_ERROR_ROLE = 0,
+	/**
+	 * xdg_wm_base was destroyed before children
+	 */
+	XDG_WM_BASE_ERROR_DEFUNCT_SURFACES = 1,
+	/**
+	 * the client tried to map or destroy a non-topmost popup
+	 */
+	XDG_WM_BASE_ERROR_NOT_THE_TOPMOST_POPUP = 2,
+	/**
+	 * the client specified an invalid popup parent surface
+	 */
+	XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT = 3,
+	/**
+	 * the client provided an invalid surface state
+	 */
+	XDG_WM_BASE_ERROR_INVALID_SURFACE_STATE = 4,
+	/**
+	 * the client provided an invalid positioner
+	 */
+	XDG_WM_BASE_ERROR_INVALID_POSITIONER = 5,
+	/**
+	 * the client didn’t respond to a ping event in time
+	 */
+	XDG_WM_BASE_ERROR_UNRESPONSIVE = 6,
+};
+#endif /* XDG_WM_BASE_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_wm_base
+ * @struct xdg_wm_base_interface
+ */
+struct xdg_wm_base_interface {
+	/**
+	 * destroy xdg_wm_base
+	 *
+	 * Destroy this xdg_wm_base object.
+	 *
+	 * Destroying a bound xdg_wm_base object while there are surfaces
+	 * still alive created by this xdg_wm_base object instance is
+	 * illegal and will result in a defunct_surfaces error.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * create a positioner object
+	 *
+	 * Create a positioner object. A positioner object is used to
+	 * position surfaces relative to some parent surface. See the
+	 * interface description and xdg_surface.get_popup for details.
+	 */
+	void (*create_positioner)(struct wl_client *client,
+				  struct wl_resource *resource,
+				  uint32_t id);
+	/**
+	 * create a shell surface from a surface
+	 *
+	 * This creates an xdg_surface for the given surface. While
+	 * xdg_surface itself is not a role, the corresponding surface may
+	 * only be assigned a role extending xdg_surface, such as
+	 * xdg_toplevel or xdg_popup. It is illegal to create an
+	 * xdg_surface for a wl_surface which already has an assigned role
+	 * and this will result in a role error.
+	 *
+	 * This creates an xdg_surface for the given surface. An
+	 * xdg_surface is used as basis to define a role to a given
+	 * surface, such as xdg_toplevel or xdg_popup. It also manages
+	 * functionality shared between xdg_surface based surface roles.
+	 *
+	 * See the documentation of xdg_surface for more details about what
+	 * an xdg_surface is and how it is used.
+	 */
+	void (*get_xdg_surface)(struct wl_client *client,
+				struct wl_resource *resource,
+				uint32_t id,
+				struct wl_resource *surface);
+	/**
+	 * respond to a ping event
+	 *
+	 * A client must respond to a ping event with a pong request or
+	 * the client may be deemed unresponsive. See xdg_wm_base.ping and
+	 * xdg_wm_base.error.unresponsive.
+	 * @param serial serial of the ping event
+	 */
+	void (*pong)(struct wl_client *client,
+		     struct wl_resource *resource,
+		     uint32_t serial);
+};
+
+#define XDG_WM_BASE_PING 0
+
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_PING_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_CREATE_POSITIONER_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_GET_XDG_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_wm_base
+ */
+#define XDG_WM_BASE_PONG_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_wm_base
+ * Sends an ping event to the client owning the resource.
+ * @param resource_ The client's resource
+ * @param serial pass this to the pong request
+ */
+static inline void
+xdg_wm_base_send_ping(struct wl_resource *resource_, uint32_t serial)
+{
+	wl_resource_post_event(resource_, XDG_WM_BASE_PING, serial);
+}
+
+#ifndef XDG_POSITIONER_ERROR_ENUM
+#define XDG_POSITIONER_ERROR_ENUM
+enum xdg_positioner_error {
+	/**
+	 * invalid input provided
+	 */
+	XDG_POSITIONER_ERROR_INVALID_INPUT = 0,
+};
+#endif /* XDG_POSITIONER_ERROR_ENUM */
+
+#ifndef XDG_POSITIONER_ANCHOR_ENUM
+#define XDG_POSITIONER_ANCHOR_ENUM
+enum xdg_positioner_anchor {
+	XDG_POSITIONER_ANCHOR_NONE = 0,
+	XDG_POSITIONER_ANCHOR_TOP = 1,
+	XDG_POSITIONER_ANCHOR_BOTTOM = 2,
+	XDG_POSITIONER_ANCHOR_LEFT = 3,
+	XDG_POSITIONER_ANCHOR_RIGHT = 4,
+	XDG_POSITIONER_ANCHOR_TOP_LEFT = 5,
+	XDG_POSITIONER_ANCHOR_BOTTOM_LEFT = 6,
+	XDG_POSITIONER_ANCHOR_TOP_RIGHT = 7,
+	XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT = 8,
+};
+#endif /* XDG_POSITIONER_ANCHOR_ENUM */
+
+#ifndef XDG_POSITIONER_GRAVITY_ENUM
+#define XDG_POSITIONER_GRAVITY_ENUM
+enum xdg_positioner_gravity {
+	XDG_POSITIONER_GRAVITY_NONE = 0,
+	XDG_POSITIONER_GRAVITY_TOP = 1,
+	XDG_POSITIONER_GRAVITY_BOTTOM = 2,
+	XDG_POSITIONER_GRAVITY_LEFT = 3,
+	XDG_POSITIONER_GRAVITY_RIGHT = 4,
+	XDG_POSITIONER_GRAVITY_TOP_LEFT = 5,
+	XDG_POSITIONER_GRAVITY_BOTTOM_LEFT = 6,
+	XDG_POSITIONER_GRAVITY_TOP_RIGHT = 7,
+	XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT = 8,
+};
+#endif /* XDG_POSITIONER_GRAVITY_ENUM */
+
+#ifndef XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
+#define XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM
+/**
+ * @ingroup iface_xdg_positioner
+ * constraint adjustments
+ *
+ * The constraint adjustment value define ways the compositor will adjust
+ * the position of the surface, if the unadjusted position would result
+ * in the surface being partly constrained.
+ *
+ * Whether a surface is considered 'constrained' is left to the compositor
+ * to determine. For example, the surface may be partly outside the
+ * compositor's defined 'work area', thus necessitating the child surface's
+ * position be adjusted until it is entirely inside the work area.
+ *
+ * The adjustments can be combined, according to a defined precedence: 1)
+ * Flip, 2) Slide, 3) Resize.
+ */
+enum xdg_positioner_constraint_adjustment {
+	/**
+	 * don't move the child surface when constrained
+	 *
+	 * Don't alter the surface position even if it is constrained on
+	 * some axis, for example partially outside the edge of an output.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_NONE = 0,
+	/**
+	 * move along the x axis until unconstrained
+	 *
+	 * Slide the surface along the x axis until it is no longer
+	 * constrained.
+	 *
+	 * First try to slide towards the direction of the gravity on the x
+	 * axis until either the edge in the opposite direction of the
+	 * gravity is unconstrained or the edge in the direction of the
+	 * gravity is constrained.
+	 *
+	 * Then try to slide towards the opposite direction of the gravity
+	 * on the x axis until either the edge in the direction of the
+	 * gravity is unconstrained or the edge in the opposite direction
+	 * of the gravity is constrained.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
+	/**
+	 * move along the y axis until unconstrained
+	 *
+	 * Slide the surface along the y axis until it is no longer
+	 * constrained.
+	 *
+	 * First try to slide towards the direction of the gravity on the y
+	 * axis until either the edge in the opposite direction of the
+	 * gravity is unconstrained or the edge in the direction of the
+	 * gravity is constrained.
+	 *
+	 * Then try to slide towards the opposite direction of the gravity
+	 * on the y axis until either the edge in the direction of the
+	 * gravity is unconstrained or the edge in the opposite direction
+	 * of the gravity is constrained.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
+	/**
+	 * invert the anchor and gravity on the x axis
+	 *
+	 * Invert the anchor and gravity on the x axis if the surface is
+	 * constrained on the x axis. For example, if the left edge of the
+	 * surface is constrained, the gravity is 'left' and the anchor is
+	 * 'left', change the gravity to 'right' and the anchor to 'right'.
+	 *
+	 * If the adjusted position also ends up being constrained, the
+	 * resulting position of the flip_x adjustment will be the one
+	 * before the adjustment.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
+	/**
+	 * invert the anchor and gravity on the y axis
+	 *
+	 * Invert the anchor and gravity on the y axis if the surface is
+	 * constrained on the y axis. For example, if the bottom edge of
+	 * the surface is constrained, the gravity is 'bottom' and the
+	 * anchor is 'bottom', change the gravity to 'top' and the anchor
+	 * to 'top'.
+	 *
+	 * The adjusted position is calculated given the original anchor
+	 * rectangle and offset, but with the new flipped anchor and
+	 * gravity values.
+	 *
+	 * If the adjusted position also ends up being constrained, the
+	 * resulting position of the flip_y adjustment will be the one
+	 * before the adjustment.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
+	/**
+	 * horizontally resize the surface
+	 *
+	 * Resize the surface horizontally so that it is completely
+	 * unconstrained.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
+	/**
+	 * vertically resize the surface
+	 *
+	 * Resize the surface vertically so that it is completely
+	 * unconstrained.
+	 */
+	XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
+};
+#endif /* XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_ENUM */
+
+/**
+ * @ingroup iface_xdg_positioner
+ * @struct xdg_positioner_interface
+ */
+struct xdg_positioner_interface {
+	/**
+	 * destroy the xdg_positioner object
+	 *
+	 * Notify the compositor that the xdg_positioner will no longer
+	 * be used.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * set the size of the to-be positioned rectangle
+	 *
+	 * Set the size of the surface that is to be positioned with the
+	 * positioner object. The size is in surface-local coordinates and
+	 * corresponds to the window geometry. See
+	 * xdg_surface.set_window_geometry.
+	 *
+	 * If a zero or negative size is set the invalid_input error is
+	 * raised.
+	 * @param width width of positioned rectangle
+	 * @param height height of positioned rectangle
+	 */
+	void (*set_size)(struct wl_client *client,
+			 struct wl_resource *resource,
+			 int32_t width,
+			 int32_t height);
+	/**
+	 * set the anchor rectangle within the parent surface
+	 *
+	 * Specify the anchor rectangle within the parent surface that
+	 * the child surface will be placed relative to. The rectangle is
+	 * relative to the window geometry as defined by
+	 * xdg_surface.set_window_geometry of the parent surface.
+	 *
+	 * When the xdg_positioner object is used to position a child
+	 * surface, the anchor rectangle may not extend outside the window
+	 * geometry of the positioned child's parent surface.
+	 *
+	 * If a negative size is set the invalid_input error is raised.
+	 * @param x x position of anchor rectangle
+	 * @param y y position of anchor rectangle
+	 * @param width width of anchor rectangle
+	 * @param height height of anchor rectangle
+	 */
+	void (*set_anchor_rect)(struct wl_client *client,
+				struct wl_resource *resource,
+				int32_t x,
+				int32_t y,
+				int32_t width,
+				int32_t height);
+	/**
+	 * set anchor rectangle anchor
+	 *
+	 * Defines the anchor point for the anchor rectangle. The
+	 * specified anchor is used derive an anchor point that the child
+	 * surface will be positioned relative to. If a corner anchor is
+	 * set (e.g. 'top_left' or 'bottom_right'), the anchor point will
+	 * be at the specified corner; otherwise, the derived anchor point
+	 * will be centered on the specified edge, or in the center of the
+	 * anchor rectangle if no edge is specified.
+	 * @param anchor anchor
+	 */
+	void (*set_anchor)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   uint32_t anchor);
+	/**
+	 * set child surface gravity
+	 *
+	 * Defines in what direction a surface should be positioned,
+	 * relative to the anchor point of the parent surface. If a corner
+	 * gravity is specified (e.g. 'bottom_right' or 'top_left'), then
+	 * the child surface will be placed towards the specified gravity;
+	 * otherwise, the child surface will be centered over the anchor
+	 * point on any axis that had no gravity specified. If the gravity
+	 * is not in the ‘gravity’ enum, an invalid_input error is
+	 * raised.
+	 * @param gravity gravity direction
+	 */
+	void (*set_gravity)(struct wl_client *client,
+			    struct wl_resource *resource,
+			    uint32_t gravity);
+	/**
+	 * set the adjustment to be done when constrained
+	 *
+	 * Specify how the window should be positioned if the originally
+	 * intended position caused the surface to be constrained, meaning
+	 * at least partially outside positioning boundaries set by the
+	 * compositor. The adjustment is set by constructing a bitmask
+	 * describing the adjustment to be made when the surface is
+	 * constrained on that axis.
+	 *
+	 * If no bit for one axis is set, the compositor will assume that
+	 * the child surface should not change its position on that axis
+	 * when constrained.
+	 *
+	 * If more than one bit for one axis is set, the order of how
+	 * adjustments are applied is specified in the corresponding
+	 * adjustment descriptions.
+	 *
+	 * The default adjustment is none.
+	 * @param constraint_adjustment bit mask of constraint adjustments
+	 */
+	void (*set_constraint_adjustment)(struct wl_client *client,
+					  struct wl_resource *resource,
+					  uint32_t constraint_adjustment);
+	/**
+	 * set surface position offset
+	 *
+	 * Specify the surface position offset relative to the position
+	 * of the anchor on the anchor rectangle and the anchor on the
+	 * surface. For example if the anchor of the anchor rectangle is at
+	 * (x, y), the surface has the gravity bottom|right, and the offset
+	 * is (ox, oy), the calculated surface position will be (x + ox, y
+	 * + oy). The offset position of the surface is the one used for
+	 * constraint testing. See set_constraint_adjustment.
+	 *
+	 * An example use case is placing a popup menu on top of a user
+	 * interface element, while aligning the user interface element of
+	 * the parent surface with some user interface element placed
+	 * somewhere in the popup surface.
+	 * @param x surface position x offset
+	 * @param y surface position y offset
+	 */
+	void (*set_offset)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   int32_t x,
+			   int32_t y);
+	/**
+	 * continuously reconstrain the surface
+	 *
+	 * When set reactive, the surface is reconstrained if the
+	 * conditions used for constraining changed, e.g. the parent window
+	 * moved.
+	 *
+	 * If the conditions changed and the popup was reconstrained, an
+	 * xdg_popup.configure event is sent with updated geometry,
+	 * followed by an xdg_surface.configure event.
+	 * @since 3
+	 */
+	void (*set_reactive)(struct wl_client *client,
+			     struct wl_resource *resource);
+	/**
+	 * 
+	 *
+	 * Set the parent window geometry the compositor should use when
+	 * positioning the popup. The compositor may use this information
+	 * to determine the future state the popup should be constrained
+	 * using. If this doesn't match the dimension of the parent the
+	 * popup is eventually positioned against, the behavior is
+	 * undefined.
+	 *
+	 * The arguments are given in the surface-local coordinate space.
+	 * @param parent_width future window geometry width of parent
+	 * @param parent_height future window geometry height of parent
+	 * @since 3
+	 */
+	void (*set_parent_size)(struct wl_client *client,
+				struct wl_resource *resource,
+				int32_t parent_width,
+				int32_t parent_height);
+	/**
+	 * set parent configure this is a response to
+	 *
+	 * Set the serial of an xdg_surface.configure event this
+	 * positioner will be used in response to. The compositor may use
+	 * this information together with set_parent_size to determine what
+	 * future state the popup should be constrained using.
+	 * @param serial serial of parent configure event
+	 * @since 3
+	 */
+	void (*set_parent_configure)(struct wl_client *client,
+				     struct wl_resource *resource,
+				     uint32_t serial);
+};
+
+
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_ANCHOR_RECT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_ANCHOR_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_GRAVITY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_OFFSET_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_REACTIVE_SINCE_VERSION 3
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_PARENT_SIZE_SINCE_VERSION 3
+/**
+ * @ingroup iface_xdg_positioner
+ */
+#define XDG_POSITIONER_SET_PARENT_CONFIGURE_SINCE_VERSION 3
+
+#ifndef XDG_SURFACE_ERROR_ENUM
+#define XDG_SURFACE_ERROR_ENUM
+enum xdg_surface_error {
+	/**
+	 * Surface was not fully constructed
+	 */
+	XDG_SURFACE_ERROR_NOT_CONSTRUCTED = 1,
+	/**
+	 * Surface was already constructed
+	 */
+	XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED = 2,
+	/**
+	 * Attaching a buffer to an unconfigured surface
+	 */
+	XDG_SURFACE_ERROR_UNCONFIGURED_BUFFER = 3,
+	/**
+	 * Invalid serial number when acking a configure event
+	 */
+	XDG_SURFACE_ERROR_INVALID_SERIAL = 4,
+	/**
+	 * Width or height was zero or negative
+	 */
+	XDG_SURFACE_ERROR_INVALID_SIZE = 5,
+	/**
+	 * Surface was destroyed before its role object
+	 */
+	XDG_SURFACE_ERROR_DEFUNCT_ROLE_OBJECT = 6,
+};
+#endif /* XDG_SURFACE_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_surface
+ * @struct xdg_surface_interface
+ */
+struct xdg_surface_interface {
+	/**
+	 * destroy the xdg_surface
+	 *
+	 * Destroy the xdg_surface object. An xdg_surface must only be
+	 * destroyed after its role object has been destroyed, otherwise a
+	 * defunct_role_object error is raised.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * assign the xdg_toplevel surface role
+	 *
+	 * This creates an xdg_toplevel object for the given xdg_surface
+	 * and gives the associated wl_surface the xdg_toplevel role.
+	 *
+	 * See the documentation of xdg_toplevel for more details about
+	 * what an xdg_toplevel is and how it is used.
+	 */
+	void (*get_toplevel)(struct wl_client *client,
+			     struct wl_resource *resource,
+			     uint32_t id);
+	/**
+	 * assign the xdg_popup surface role
+	 *
+	 * This creates an xdg_popup object for the given xdg_surface and
+	 * gives the associated wl_surface the xdg_popup role.
+	 *
+	 * If null is passed as a parent, a parent surface must be
+	 * specified using some other protocol, before committing the
+	 * initial state.
+	 *
+	 * See the documentation of xdg_popup for more details about what
+	 * an xdg_popup is and how it is used.
+	 */
+	void (*get_popup)(struct wl_client *client,
+			  struct wl_resource *resource,
+			  uint32_t id,
+			  struct wl_resource *parent,
+			  struct wl_resource *positioner);
+	/**
+	 * set the new window geometry
+	 *
+	 * The window geometry of a surface is its "visible bounds" from
+	 * the user's perspective. Client-side decorations often have
+	 * invisible portions like drop-shadows which should be ignored for
+	 * the purposes of aligning, placing and constraining windows.
+	 *
+	 * The window geometry is double buffered, and will be applied at
+	 * the time wl_surface.commit of the corresponding wl_surface is
+	 * called.
+	 *
+	 * When maintaining a position, the compositor should treat the (x,
+	 * y) coordinate of the window geometry as the top left corner of
+	 * the window. A client changing the (x, y) window geometry
+	 * coordinate should in general not alter the position of the
+	 * window.
+	 *
+	 * Once the window geometry of the surface is set, it is not
+	 * possible to unset it, and it will remain the same until
+	 * set_window_geometry is called again, even if a new subsurface or
+	 * buffer is attached.
+	 *
+	 * If never set, the value is the full bounds of the surface,
+	 * including any subsurfaces. This updates dynamically on every
+	 * commit. This unset is meant for extremely simple clients.
+	 *
+	 * The arguments are given in the surface-local coordinate space of
+	 * the wl_surface associated with this xdg_surface.
+	 *
+	 * The width and height must be greater than zero. Setting an
+	 * invalid size will raise an invalid_size error. When applied, the
+	 * effective window geometry will be the set window geometry
+	 * clamped to the bounding rectangle of the combined geometry of
+	 * the surface of the xdg_surface and the associated subsurfaces.
+	 */
+	void (*set_window_geometry)(struct wl_client *client,
+				    struct wl_resource *resource,
+				    int32_t x,
+				    int32_t y,
+				    int32_t width,
+				    int32_t height);
+	/**
+	 * 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.
+	 *
+	 * For instance, for toplevel surfaces the compositor might use
+	 * this information to move a surface to the top left only when the
+	 * client has drawn itself for the maximized or fullscreen state.
+	 *
+	 * If the client receives multiple configure events before it can
+	 * respond to one, it only has to ack the last configure event.
+	 * Acking a configure event that was never sent raises an
+	 * invalid_serial error.
+	 *
+	 * A client is not required to commit immediately after sending an
+	 * ack_configure request - it may even ack_configure several times
+	 * before its next surface commit.
+	 *
+	 * A client may send multiple ack_configure requests before
+	 * committing, but only the last request sent before a commit
+	 * indicates which configure event the client really is responding
+	 * to.
+	 *
+	 * Sending an ack_configure request consumes the serial number sent
+	 * with the request, as well as serial numbers sent by all
+	 * configure events sent on this xdg_surface prior to the configure
+	 * event referenced by the committed serial.
+	 *
+	 * It is an error to issue multiple ack_configure requests
+	 * referencing a serial from the same configure event, or to issue
+	 * an ack_configure request referencing a serial from a configure
+	 * event issued before the event identified by the last
+	 * ack_configure request for the same xdg_surface. Doing so will
+	 * raise an invalid_serial error.
+	 * @param serial the serial from the configure event
+	 */
+	void (*ack_configure)(struct wl_client *client,
+			      struct wl_resource *resource,
+			      uint32_t serial);
+};
+
+#define XDG_SURFACE_CONFIGURE 0
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_GET_TOPLEVEL_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_GET_POPUP_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_surface
+ * Sends an configure event to the client owning the resource.
+ * @param resource_ The client's resource
+ * @param serial serial of the configure event
+ */
+static inline void
+xdg_surface_send_configure(struct wl_resource *resource_, uint32_t serial)
+{
+	wl_resource_post_event(resource_, XDG_SURFACE_CONFIGURE, serial);
+}
+
+#ifndef XDG_TOPLEVEL_ERROR_ENUM
+#define XDG_TOPLEVEL_ERROR_ENUM
+enum xdg_toplevel_error {
+	/**
+	 * provided value is         not a valid variant of the resize_edge enum
+	 */
+	XDG_TOPLEVEL_ERROR_INVALID_RESIZE_EDGE = 0,
+	/**
+	 * invalid parent toplevel
+	 */
+	XDG_TOPLEVEL_ERROR_INVALID_PARENT = 1,
+	/**
+	 * client provided an invalid min or max size
+	 */
+	XDG_TOPLEVEL_ERROR_INVALID_SIZE = 2,
+};
+#endif /* XDG_TOPLEVEL_ERROR_ENUM */
+
+#ifndef XDG_TOPLEVEL_RESIZE_EDGE_ENUM
+#define XDG_TOPLEVEL_RESIZE_EDGE_ENUM
+/**
+ * @ingroup iface_xdg_toplevel
+ * edge values for resizing
+ *
+ * These values are used to indicate which edge of a surface
+ * is being dragged in a resize operation.
+ */
+enum xdg_toplevel_resize_edge {
+	XDG_TOPLEVEL_RESIZE_EDGE_NONE = 0,
+	XDG_TOPLEVEL_RESIZE_EDGE_TOP = 1,
+	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM = 2,
+	XDG_TOPLEVEL_RESIZE_EDGE_LEFT = 4,
+	XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT = 5,
+	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT = 6,
+	XDG_TOPLEVEL_RESIZE_EDGE_RIGHT = 8,
+	XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT = 9,
+	XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT = 10,
+};
+#endif /* XDG_TOPLEVEL_RESIZE_EDGE_ENUM */
+
+#ifndef XDG_TOPLEVEL_STATE_ENUM
+#define XDG_TOPLEVEL_STATE_ENUM
+/**
+ * @ingroup iface_xdg_toplevel
+ * types of state on the surface
+ *
+ * The different state values used on the surface. This is designed for
+ * state values like maximized, fullscreen. It is paired with the
+ * configure event to ensure that both the client and the compositor
+ * setting the state can be synchronized.
+ *
+ * States set in this way are double-buffered. They will get applied on
+ * the next commit.
+ */
+enum xdg_toplevel_state {
+	/**
+	 * the surface is maximized
+	 * the surface is maximized
+	 *
+	 * The surface is maximized. The window geometry specified in the
+	 * configure event must be obeyed by the client.
+	 *
+	 * The client should draw without shadow or other decoration
+	 * outside of the window geometry.
+	 */
+	XDG_TOPLEVEL_STATE_MAXIMIZED = 1,
+	/**
+	 * the surface is fullscreen
+	 * the surface is fullscreen
+	 *
+	 * The surface is fullscreen. The window geometry specified in
+	 * the configure event is a maximum; the client cannot resize
+	 * beyond it. For a surface to cover the whole fullscreened area,
+	 * the geometry dimensions must be obeyed by the client. For more
+	 * details, see xdg_toplevel.set_fullscreen.
+	 */
+	XDG_TOPLEVEL_STATE_FULLSCREEN = 2,
+	/**
+	 * the surface is being resized
+	 * the surface is being resized
+	 *
+	 * The surface is being resized. The window geometry specified in
+	 * the configure event is a maximum; the client cannot resize
+	 * beyond it. Clients that have aspect ratio or cell sizing
+	 * configuration can use a smaller size, however.
+	 */
+	XDG_TOPLEVEL_STATE_RESIZING = 3,
+	/**
+	 * the surface is now activated
+	 * the surface is now activated
+	 *
+	 * Client window decorations should be painted as if the window
+	 * is active. Do not assume this means that the window actually has
+	 * keyboard or pointer focus.
+	 */
+	XDG_TOPLEVEL_STATE_ACTIVATED = 4,
+	/**
+	 * the surface’s left edge is tiled
+	 *
+	 * The window is currently in a tiled layout and the left edge is
+	 * considered to be adjacent to another part of the tiling grid.
+	 * @since 2
+	 */
+	XDG_TOPLEVEL_STATE_TILED_LEFT = 5,
+	/**
+	 * the surface’s right edge is tiled
+	 *
+	 * The window is currently in a tiled layout and the right edge
+	 * is considered to be adjacent to another part of the tiling grid.
+	 * @since 2
+	 */
+	XDG_TOPLEVEL_STATE_TILED_RIGHT = 6,
+	/**
+	 * the surface’s top edge is tiled
+	 *
+	 * The window is currently in a tiled layout and the top edge is
+	 * considered to be adjacent to another part of the tiling grid.
+	 * @since 2
+	 */
+	XDG_TOPLEVEL_STATE_TILED_TOP = 7,
+	/**
+	 * the surface’s bottom edge is tiled
+	 *
+	 * The window is currently in a tiled layout and the bottom edge
+	 * is considered to be adjacent to another part of the tiling grid.
+	 * @since 2
+	 */
+	XDG_TOPLEVEL_STATE_TILED_BOTTOM = 8,
+};
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_LEFT_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_TOP_SINCE_VERSION 2
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION 2
+#endif /* XDG_TOPLEVEL_STATE_ENUM */
+
+#ifndef XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
+#define XDG_TOPLEVEL_WM_CAPABILITIES_ENUM
+enum xdg_toplevel_wm_capabilities {
+	/**
+	 * show_window_menu is available
+	 */
+	XDG_TOPLEVEL_WM_CAPABILITIES_WINDOW_MENU = 1,
+	/**
+	 * set_maximized and unset_maximized are available
+	 */
+	XDG_TOPLEVEL_WM_CAPABILITIES_MAXIMIZE = 2,
+	/**
+	 * set_fullscreen and unset_fullscreen are available
+	 */
+	XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN = 3,
+	/**
+	 * set_minimized is available
+	 */
+	XDG_TOPLEVEL_WM_CAPABILITIES_MINIMIZE = 4,
+};
+#endif /* XDG_TOPLEVEL_WM_CAPABILITIES_ENUM */
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * @struct xdg_toplevel_interface
+ */
+struct xdg_toplevel_interface {
+	/**
+	 * destroy the xdg_toplevel
+	 *
+	 * This request destroys the role surface and unmaps the surface;
+	 * see "Unmapping" behavior in interface section for details.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * set the parent of this surface
+	 *
+	 * Set the "parent" of this surface. This surface should be
+	 * stacked above the parent surface and all other ancestor
+	 * surfaces.
+	 *
+	 * Parent surfaces should be set on dialogs, toolboxes, or other
+	 * "auxiliary" surfaces, so that the parent is raised when the
+	 * dialog is raised.
+	 *
+	 * Setting a null parent for a child surface unsets its parent.
+	 * Setting a null parent for a surface which currently has no
+	 * parent is a no-op.
+	 *
+	 * Only mapped surfaces can have child surfaces. Setting a parent
+	 * which is not mapped is equivalent to setting a null parent. If a
+	 * surface becomes unmapped, its children's parent is set to the
+	 * parent of the now-unmapped surface. If the now-unmapped surface
+	 * has no parent, its children's parent is unset. If the
+	 * now-unmapped surface becomes mapped again, its parent-child
+	 * relationship is not restored.
+	 *
+	 * The parent toplevel must not be one of the child toplevel's
+	 * descendants, and the parent must be different from the child
+	 * toplevel, otherwise the invalid_parent protocol error is raised.
+	 */
+	void (*set_parent)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   struct wl_resource *parent);
+	/**
+	 * set surface title
+	 *
+	 * 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 application ID
+	 *
+	 * Set an application identifier for the surface.
+	 *
+	 * The app ID identifies the general class of applications to which
+	 * the surface belongs. The compositor can use this to group
+	 * multiple surfaces together, or to determine how to launch a new
+	 * application.
+	 *
+	 * For D-Bus activatable applications, the app ID is used as the
+	 * D-Bus service name.
+	 *
+	 * The compositor shell will try to group application surfaces
+	 * together by their app ID. As a best practice, it is suggested to
+	 * select app ID's that match the basename of the application's
+	 * .desktop file. For example, "org.freedesktop.FooViewer" where
+	 * the .desktop file is "org.freedesktop.FooViewer.desktop".
+	 *
+	 * Like other properties, a set_app_id request can be sent after
+	 * the xdg_toplevel has been mapped to update the property.
+	 *
+	 * See the desktop-entry specification [0] for more details on
+	 * application identifiers and how they relate to well-known D-Bus
+	 * names and .desktop files.
+	 *
+	 * [0] https://standards.freedesktop.org/desktop-entry-spec/
+	 */
+	void (*set_app_id)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   const char *app_id);
+	/**
+	 * show the window menu
+	 *
+	 * Clients implementing client-side decorations might want to
+	 * show a context menu when right-clicking on the decorations,
+	 * giving the user a menu that they can use to maximize or minimize
+	 * the window.
+	 *
+	 * This request asks the compositor to pop up such a window menu at
+	 * the given position, relative to the local surface coordinates of
+	 * the parent surface. There are no guarantees as to what menu
+	 * items the window menu contains, or even if a window menu will be
+	 * drawn at all.
+	 *
+	 * This request must be used in response to some sort of user
+	 * action like a button press, key press, or touch down event.
+	 * @param seat the wl_seat of the user event
+	 * @param serial the serial of the user event
+	 * @param x the x position to pop up the window menu at
+	 * @param y the y position to pop up the window menu at
+	 */
+	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);
+	/**
+	 * start an interactive move
+	 *
+	 * Start an interactive, user-driven move of the surface.
+	 *
+	 * This request must be used in response to some sort of user
+	 * action like a button press, key press, or touch down event. The
+	 * passed serial is used to determine the type of interactive move
+	 * (touch, pointer, etc).
+	 *
+	 * The server may ignore move requests depending on the state of
+	 * the surface (e.g. fullscreen or maximized), or if the passed
+	 * serial is no longer valid.
+	 *
+	 * If triggered, the surface will lose the focus of the device
+	 * (wl_pointer, wl_touch, etc) used for the move. It is up to the
+	 * compositor to visually indicate that the move is taking place,
+	 * such as updating a pointer cursor, during the move. There is no
+	 * guarantee that the device focus will return when the move is
+	 * completed.
+	 * @param seat the wl_seat of the user event
+	 * @param serial the serial of the user event
+	 */
+	void (*move)(struct wl_client *client,
+		     struct wl_resource *resource,
+		     struct wl_resource *seat,
+		     uint32_t serial);
+	/**
+	 * start an interactive resize
+	 *
+	 * Start a user-driven, interactive resize of the surface.
+	 *
+	 * This request must be used in response to some sort of user
+	 * action like a button press, key press, or touch down event. The
+	 * passed serial is used to determine the type of interactive
+	 * resize (touch, pointer, etc).
+	 *
+	 * The server may ignore resize requests depending on the state of
+	 * the surface (e.g. fullscreen or maximized).
+	 *
+	 * If triggered, the client will receive configure events with the
+	 * "resize" state enum value and the expected sizes. See the
+	 * "resize" enum value for more details about what is required. The
+	 * client must also acknowledge configure events using
+	 * "ack_configure". After the resize is completed, the client will
+	 * receive another "configure" event without the resize state.
+	 *
+	 * If triggered, the surface also will lose the focus of the device
+	 * (wl_pointer, wl_touch, etc) used for the resize. It is up to the
+	 * compositor to visually indicate that the resize is taking place,
+	 * such as updating a pointer cursor, during the resize. There is
+	 * no guarantee that the device focus will return when the resize
+	 * is completed.
+	 *
+	 * The edges parameter specifies how the surface should be resized,
+	 * and is one of the values of the resize_edge enum. Values not
+	 * matching a variant of the enum will cause a protocol error. The
+	 * compositor may use this information to update the surface
+	 * position for example when dragging the top left corner. The
+	 * compositor may also use this information to adapt its behavior,
+	 * e.g. choose an appropriate cursor image.
+	 * @param seat the wl_seat of the user event
+	 * @param serial the serial of the user event
+	 * @param edges which edge or corner is being dragged
+	 */
+	void (*resize)(struct wl_client *client,
+		       struct wl_resource *resource,
+		       struct wl_resource *seat,
+		       uint32_t serial,
+		       uint32_t edges);
+	/**
+	 * set the maximum size
+	 *
+	 * Set a maximum size for the window.
+	 *
+	 * The client can specify a maximum size so that the compositor
+	 * does not try to configure the window beyond this size.
+	 *
+	 * The width and height arguments are in window geometry
+	 * coordinates. See xdg_surface.set_window_geometry.
+	 *
+	 * Values set in this way are double-buffered. They will get
+	 * applied on the next commit.
+	 *
+	 * The compositor can use this information to allow or disallow
+	 * different states like maximize or fullscreen and draw accurate
+	 * animations.
+	 *
+	 * Similarly, a tiling window manager may use this information to
+	 * place and resize client windows in a more effective way.
+	 *
+	 * The client should not rely on the compositor to obey the maximum
+	 * size. The compositor may decide to ignore the values set by the
+	 * client and request a larger size.
+	 *
+	 * If never set, or a value of zero in the request, means that the
+	 * client has no expected maximum size in the given dimension. As a
+	 * result, a client wishing to reset the maximum size to an
+	 * unspecified state can use zero for width and height in the
+	 * request.
+	 *
+	 * Requesting a maximum size to be smaller than the minimum size of
+	 * a surface is illegal and will result in an invalid_size error.
+	 *
+	 * The width and height must be greater than or equal to zero.
+	 * Using strictly negative values for width or height will result
+	 * in a invalid_size error.
+	 */
+	void (*set_max_size)(struct wl_client *client,
+			     struct wl_resource *resource,
+			     int32_t width,
+			     int32_t height);
+	/**
+	 * set the minimum size
+	 *
+	 * Set a minimum size for the window.
+	 *
+	 * The client can specify a minimum size so that the compositor
+	 * does not try to configure the window below this size.
+	 *
+	 * The width and height arguments are in window geometry
+	 * coordinates. See xdg_surface.set_window_geometry.
+	 *
+	 * Values set in this way are double-buffered. They will get
+	 * applied on the next commit.
+	 *
+	 * The compositor can use this information to allow or disallow
+	 * different states like maximize or fullscreen and draw accurate
+	 * animations.
+	 *
+	 * Similarly, a tiling window manager may use this information to
+	 * place and resize client windows in a more effective way.
+	 *
+	 * The client should not rely on the compositor to obey the minimum
+	 * size. The compositor may decide to ignore the values set by the
+	 * client and request a smaller size.
+	 *
+	 * If never set, or a value of zero in the request, means that the
+	 * client has no expected minimum size in the given dimension. As a
+	 * result, a client wishing to reset the minimum size to an
+	 * unspecified state can use zero for width and height in the
+	 * request.
+	 *
+	 * Requesting a minimum size to be larger than the maximum size of
+	 * a surface is illegal and will result in an invalid_size error.
+	 *
+	 * The width and height must be greater than or equal to zero.
+	 * Using strictly negative values for width and height will result
+	 * in a invalid_size error.
+	 */
+	void (*set_min_size)(struct wl_client *client,
+			     struct wl_resource *resource,
+			     int32_t width,
+			     int32_t height);
+	/**
+	 * maximize the window
+	 *
+	 * Maximize the surface.
+	 *
+	 * After requesting that the surface should be maximized, the
+	 * compositor will respond by emitting a configure event. Whether
+	 * this configure actually sets the window maximized is subject to
+	 * compositor policies. The client must then update its content,
+	 * drawing in the configured state. The client must also
+	 * acknowledge the configure when committing the new content (see
+	 * ack_configure).
+	 *
+	 * It is up to the compositor to decide how and where to maximize
+	 * the surface, for example which output and what region of the
+	 * screen should be used.
+	 *
+	 * If the surface was already maximized, the compositor will still
+	 * emit a configure event with the "maximized" state.
+	 *
+	 * If the surface is in a fullscreen state, this request has no
+	 * direct effect. It may alter the state the surface is returned to
+	 * when unmaximized unless overridden by the compositor.
+	 */
+	void (*set_maximized)(struct wl_client *client,
+			      struct wl_resource *resource);
+	/**
+	 * unmaximize the window
+	 *
+	 * Unmaximize the surface.
+	 *
+	 * After requesting that the surface should be unmaximized, the
+	 * compositor will respond by emitting a configure event. Whether
+	 * this actually un-maximizes the window is subject to compositor
+	 * policies. If available and applicable, the compositor will
+	 * include the window geometry dimensions the window had prior to
+	 * being maximized in the configure event. The client must then
+	 * update its content, drawing it in the configured state. The
+	 * client must also acknowledge the configure when committing the
+	 * new content (see ack_configure).
+	 *
+	 * It is up to the compositor to position the surface after it was
+	 * unmaximized; usually the position the surface had before
+	 * maximizing, if applicable.
+	 *
+	 * If the surface was already not maximized, the compositor will
+	 * still emit a configure event without the "maximized" state.
+	 *
+	 * If the surface is in a fullscreen state, this request has no
+	 * direct effect. It may alter the state the surface is returned to
+	 * when unmaximized unless overridden by the compositor.
+	 */
+	void (*unset_maximized)(struct wl_client *client,
+				struct wl_resource *resource);
+	/**
+	 * set the window as fullscreen on an output
+	 *
+	 * Make the surface fullscreen.
+	 *
+	 * After requesting that the surface should be fullscreened, the
+	 * compositor will respond by emitting a configure event. Whether
+	 * the client is actually put into a fullscreen state is subject to
+	 * compositor policies. The client must also acknowledge the
+	 * configure when committing the new content (see ack_configure).
+	 *
+	 * The output passed by the request indicates the client's
+	 * preference as to which display it should be set fullscreen on.
+	 * If this value is NULL, it's up to the compositor to choose which
+	 * display will be used to map this surface.
+	 *
+	 * If the surface doesn't cover the whole output, the compositor
+	 * will position the surface in the center of the output and
+	 * compensate with with border fill covering the rest of the
+	 * output. The content of the border fill is undefined, but should
+	 * be assumed to be in some way that attempts to blend into the
+	 * surrounding area (e.g. solid black).
+	 *
+	 * If the fullscreened surface is not opaque, the compositor must
+	 * make sure that other screen content not part of the same surface
+	 * tree (made up of subsurfaces, popups or similarly coupled
+	 * surfaces) are not visible below the fullscreened surface.
+	 */
+	void (*set_fullscreen)(struct wl_client *client,
+			       struct wl_resource *resource,
+			       struct wl_resource *output);
+	/**
+	 * unset the window as fullscreen
+	 *
+	 * Make the surface no longer fullscreen.
+	 *
+	 * After requesting that the surface should be unfullscreened, the
+	 * compositor will respond by emitting a configure event. Whether
+	 * this actually removes the fullscreen state of the client is
+	 * subject to compositor policies.
+	 *
+	 * Making a surface unfullscreen sets states for the surface based
+	 * on the following: * the state(s) it may have had before becoming
+	 * fullscreen * any state(s) decided by the compositor * any
+	 * state(s) requested by the client while the surface was
+	 * fullscreen
+	 *
+	 * The compositor may include the previous window geometry
+	 * dimensions in the configure event, if applicable.
+	 *
+	 * The client must also acknowledge the configure when committing
+	 * the new content (see ack_configure).
+	 */
+	void (*unset_fullscreen)(struct wl_client *client,
+				 struct wl_resource *resource);
+	/**
+	 * 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_TOPLEVEL_CONFIGURE 0
+#define XDG_TOPLEVEL_CLOSE 1
+#define XDG_TOPLEVEL_CONFIGURE_BOUNDS 2
+#define XDG_TOPLEVEL_WM_CAPABILITIES 3
+
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CLOSE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION 4
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_WM_CAPABILITIES_SINCE_VERSION 5
+
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_PARENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_TITLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_APP_ID_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SHOW_WINDOW_MENU_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_MOVE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_RESIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MAX_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MIN_SIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_UNSET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_UNSET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_toplevel
+ */
+#define XDG_TOPLEVEL_SET_MINIMIZED_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * Sends an configure event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+xdg_toplevel_send_configure(struct wl_resource *resource_, int32_t width, int32_t height, struct wl_array *states)
+{
+	wl_resource_post_event(resource_, XDG_TOPLEVEL_CONFIGURE, width, height, states);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * Sends an close event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+xdg_toplevel_send_close(struct wl_resource *resource_)
+{
+	wl_resource_post_event(resource_, XDG_TOPLEVEL_CLOSE);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * Sends an configure_bounds event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+xdg_toplevel_send_configure_bounds(struct wl_resource *resource_, int32_t width, int32_t height)
+{
+	wl_resource_post_event(resource_, XDG_TOPLEVEL_CONFIGURE_BOUNDS, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_toplevel
+ * Sends an wm_capabilities event to the client owning the resource.
+ * @param resource_ The client's resource
+ * @param capabilities array of 32-bit capabilities
+ */
+static inline void
+xdg_toplevel_send_wm_capabilities(struct wl_resource *resource_, struct wl_array *capabilities)
+{
+	wl_resource_post_event(resource_, XDG_TOPLEVEL_WM_CAPABILITIES, capabilities);
+}
+
+#ifndef XDG_POPUP_ERROR_ENUM
+#define XDG_POPUP_ERROR_ENUM
+enum xdg_popup_error {
+	/**
+	 * tried to grab after being mapped
+	 */
+	XDG_POPUP_ERROR_INVALID_GRAB = 0,
+};
+#endif /* XDG_POPUP_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_popup
+ * @struct xdg_popup_interface
+ */
+struct xdg_popup_interface {
+	/**
+	 * 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);
+	/**
+	 * make the popup take an explicit grab
+	 *
+	 * This request makes the created popup take an explicit grab. An
+	 * explicit grab will be dismissed when the user dismisses the
+	 * popup, or when the client destroys the xdg_popup. This can be
+	 * done by the user clicking outside the surface, using the
+	 * keyboard, or even locking the screen through closing the lid or
+	 * a timeout.
+	 *
+	 * If the compositor denies the grab, the popup will be immediately
+	 * dismissed.
+	 *
+	 * This request must be used in response to some sort of user
+	 * action like a button press, key press, or touch down event. The
+	 * serial number of the event should be passed as 'serial'.
+	 *
+	 * The parent of a grabbing popup must either be an xdg_toplevel
+	 * surface or another xdg_popup with an explicit grab. If the
+	 * parent is another xdg_popup it means that the popups are nested,
+	 * with this popup now being the topmost popup.
+	 *
+	 * Nested popups must be destroyed in the reverse order they were
+	 * created in, e.g. the only popup you are allowed to destroy at
+	 * all times is the topmost one.
+	 *
+	 * When compositors choose to dismiss a popup, they may dismiss
+	 * every nested grabbing popup as well. When a compositor dismisses
+	 * popups, it will follow the same dismissing order as required
+	 * from the client.
+	 *
+	 * If the topmost grabbing popup is destroyed, the grab will be
+	 * returned to the parent of the popup, if that parent previously
+	 * had an explicit grab.
+	 *
+	 * If the parent is a grabbing popup which has already been
+	 * dismissed, this popup will be immediately dismissed. If the
+	 * parent is a popup that did not take an explicit grab, an error
+	 * will be raised.
+	 *
+	 * During a popup grab, the client owning the grab will receive
+	 * pointer and touch events for all their surfaces as normal
+	 * (similar to an "owner-events" grab in X11 parlance), while the
+	 * top most grabbing popup will always have keyboard focus.
+	 * @param seat the wl_seat of the user event
+	 * @param serial the serial of the user event
+	 */
+	void (*grab)(struct wl_client *client,
+		     struct wl_resource *resource,
+		     struct wl_resource *seat,
+		     uint32_t serial);
+	/**
+	 * recalculate the popup's location
+	 *
+	 * Reposition an already-mapped popup. The popup will be placed
+	 * given the details in the passed xdg_positioner object, and a
+	 * xdg_popup.repositioned followed by xdg_popup.configure and
+	 * xdg_surface.configure will be emitted in response. Any
+	 * parameters set by the previous positioner will be discarded.
+	 *
+	 * The passed token will be sent in the corresponding
+	 * xdg_popup.repositioned event. The new popup position will not
+	 * take effect until the corresponding configure event is
+	 * acknowledged by the client. See xdg_popup.repositioned for
+	 * details. The token itself is opaque, and has no other special
+	 * meaning.
+	 *
+	 * If multiple reposition requests are sent, the compositor may
+	 * skip all but the last one.
+	 *
+	 * If the popup is repositioned in response to a configure event
+	 * for its parent, the client should send an
+	 * xdg_positioner.set_parent_configure and possibly an
+	 * xdg_positioner.set_parent_size request to allow the compositor
+	 * to properly constrain the popup.
+	 *
+	 * If the popup is repositioned together with a parent that is
+	 * being resized, but not in response to a configure event, the
+	 * client should send an xdg_positioner.set_parent_size request.
+	 * @param token reposition request token
+	 * @since 3
+	 */
+	void (*reposition)(struct wl_client *client,
+			   struct wl_resource *resource,
+			   struct wl_resource *positioner,
+			   uint32_t token);
+};
+
+#define XDG_POPUP_CONFIGURE 0
+#define XDG_POPUP_POPUP_DONE 1
+#define XDG_POPUP_REPOSITIONED 2
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_REPOSITIONED_SINCE_VERSION 3
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_GRAB_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_REPOSITION_SINCE_VERSION 3
+
+/**
+ * @ingroup iface_xdg_popup
+ * Sends an configure event to the client owning the resource.
+ * @param resource_ The client's resource
+ * @param x x position relative to parent surface window geometry
+ * @param y y position relative to parent surface window geometry
+ * @param width window geometry width
+ * @param height window geometry height
+ */
+static inline void
+xdg_popup_send_configure(struct wl_resource *resource_, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+	wl_resource_post_event(resource_, XDG_POPUP_CONFIGURE, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ * Sends an popup_done event to the client owning the resource.
+ * @param resource_ The client's resource
+ */
+static inline void
+xdg_popup_send_popup_done(struct wl_resource *resource_)
+{
+	wl_resource_post_event(resource_, XDG_POPUP_POPUP_DONE);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ * Sends an repositioned event to the client owning the resource.
+ * @param resource_ The client's resource
+ * @param token reposition request token
+ */
+static inline void
+xdg_popup_send_repositioned(struct wl_resource *resource_, uint32_t token)
+{
+	wl_resource_post_event(resource_, XDG_POPUP_REPOSITIONED, token);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/wm/somebar/CHANGELOG.md b/wm/somebar/CHANGELOG.md
new file mode 100644
index 0000000..a24e7ab
--- /dev/null
+++ b/wm/somebar/CHANGELOG.md
@@ -0,0 +1,19 @@
+## [1.0.3] - 2022-12-11
+### Added
+- New patches: markup-in-status-messages, show-status-on-selected-monitor (benc)
+### Fixed
+- Fixed crash when an output disappears
+
+## [1.0.2] - 2022-11-27
+### Fixed
+- Fixed bug where hidden bar could not be shown anymore
+
+## [1.0.1] - 2022-11-25
+### Added
+- Manpage
+- New patches: indicator-size-props, hide-vacant-tags, colorless-status (medanisjbara)
+### Fixed
+- Remove spaces from title and layout symbol (benc)
+
+## [1.0.0] - 2022-04-23
+Initial release
diff --git a/wm/somebar/LICENSE b/wm/somebar/LICENSE
new file mode 100644
index 0000000..7bebc11
--- /dev/null
+++ b/wm/somebar/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2021 Raphael Robatsch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/wm/somebar/README.md b/wm/somebar/README.md
new file mode 100644
index 0000000..b61c935
--- /dev/null
+++ b/wm/somebar/README.md
@@ -0,0 +1,113 @@
+# somebar - dwm-like bar for dwl
+
+![Screenshot](screenshot.png)
+
+The mailing list for this project is
+[~raphi/public-inbox@lists.sr.ht](mailto:~raphi/public-inbox@lists.sr.ht).
+
+## Dependencies
+
+* c++ compiler, meson, and ninja
+* wayland-scanner
+* libwayland-client
+* libwayland-cursor
+* libcairo
+* libpango
+* libpangocairo
+
+```
+sudo apt install build-essential meson ninja-build \
+    libwayland-bin libwayland-client0 libwayland-cursor0 libwayland-dev \
+    libcairo2 libcairo2-dev \
+    libpango-1.0-0 libpango1.0-dev libpangocairo-1.0-0
+
+# or
+
+sudo pacman -S base-devel meson \
+    wayland wayland-protocols cairo pango
+```
+
+## Configuration
+
+Copy `src/config.def.hpp` to `src/config.hpp`, and adjust if needed.
+
+## Building
+
+```
+cp src/config.def.hpp src/config.hpp
+meson setup build
+ninja -C build
+sudo ninja -C build install
+```
+
+## Usage
+
+You must start somebar using dwl's `-s` flag, e.g. `dwl -s somebar`.
+
+Somebar can be controlled by writing to `$XDG_RUNTIME_DIR/somebar-0`
+or the path defined by `-s` argument.
+The following commands are supported:
+
+* `status TEXT`: Updates the status bar
+* `hide MONITOR` Hides somebar on the specified monitor
+* `show MONITOR` Shows somebar on the specified monitor
+* `toggle MONITOR` Toggles somebar on the specified monitor
+
+MONITOR is an zxdg_output_v1 name, which can be determined e.g. using `weston-info`.
+Additionally, MONITOR can be `all` (all monitors) or `selected` (the monitor with focus).
+
+Commands can be sent either by writing to the file name above, or equivalently by calling
+somebar with the `-c` argument. For example: `somebar -c toggle all`. This is recommended
+for shell scripts, as there is no race-free way to write to a file only if it exists.
+
+The maintainer of somebar also maintains
+[someblocks](https://git.sr.ht/~raphi/someblocks/),
+a fork of [dwmblocks](https://github.com/torrinfail/dwmblocks) that outputs
+to somebar instead of dwm's bar.
+
+## IPC
+
+Out of the box, somebar cannot control dwl. Clicking on the tag bar has no
+effect, because there is no communication channel from somebar back to dwl.
+
+If you apply the patch `contrib/ipc.patch`, then somebar will
+
+1. Not read stdin anymore, and instead use a wayland extension to read dwl's
+   state. This means you must close stdin yourself, if you choose to launch
+   somebar using dwl's -s flag.
+2. somebar can use the same wayland extension to send commands back to dwl.
+   This means that clicking on tags will switch to that tag (this can of course
+   be customized in config.h).
+
+If you apply the IPC patch to somebar, then
+**dwl must have the [wayland-ipc patch](https://git.sr.ht/~raphi/dwl/blob/master/patches/wayland-ipc.patch) applied too**,
+since dwl must implement the wayland extension too.
+
+## Other patches
+
+Like all suckless software, somebar can be customized via patches. You can find some patches in the contrib folder with descriptions written in them.
+
+## License
+
+somebar - dwm-like bar for dwl
+
+Copyright (c) 2021 Raphael Robatsch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/wm/somebar/contrib/colorless-status.patch b/wm/somebar/contrib/colorless-status.patch
new file mode 100644
index 0000000..f280070
--- /dev/null
+++ b/wm/somebar/contrib/colorless-status.patch
@@ -0,0 +1,15 @@
+From: medanisjbara anis2834133766619@gmail.com
+Date: Mon, 14 Nov 2022 10:28:00
+Description: sets the color of status component to inactive
+diff --git a/src/bar.cpp b/src/bar.cpp
+index fab5a8f..aebe28b 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -266,6 +266,7 @@ void Bar::renderStatus()
+ 	cairo_fill(_painter);
+ 
+ 	_x = start;
++	setColorScheme(colorInactive);
+ 	renderComponent(_statusCmp);
+ }
+ 
diff --git a/wm/somebar/contrib/disable-window-title.patch b/wm/somebar/contrib/disable-window-title.patch
new file mode 100644
index 0000000..b1dc9cd
--- /dev/null
+++ b/wm/somebar/contrib/disable-window-title.patch
@@ -0,0 +1,15 @@
+From: Sam Nystrom <samuel.l.nystrom@gmail.com>
+Date: Sat, 4 Mar 2023 17:38:12 -0500
+Description: disable window title
+diff --git a/src/bar.cpp b/src/bar.cpp
+index 507ce62..1b6f771 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -227,7 +227,6 @@ void Bar::render()
+ 	renderTags();
+ 	setColorScheme(_selected ? colorActive : colorInactive);
+ 	renderComponent(_layoutCmp);
+-	renderComponent(_titleCmp);
+ 	renderStatus();
+ 
+ 	_painter = nullptr;
diff --git a/wm/somebar/contrib/dwm-like-tag-indicator.patch b/wm/somebar/contrib/dwm-like-tag-indicator.patch
new file mode 100644
index 0000000..c4458e9
--- /dev/null
+++ b/wm/somebar/contrib/dwm-like-tag-indicator.patch
@@ -0,0 +1,34 @@
+From: Henrique Possatto <henriquempossatto@gmail.com>
+Date: Mon, 26 Dec 2022 18:01:35 -0300
+Subject: [PATCH somebar] patch to show square tag indicator like dwm
+diff --git a/src/bar.cpp b/src/bar.cpp
+index 507ce62..4fda8b0 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -245,12 +245,17 @@ void Bar::renderTags()
+ 			tag.state & TagState::Active ? colorActive : colorInactive,
+ 			tag.state & TagState::Urgent);
+ 		renderComponent(tag.component);
+-		auto indicators = std::min(tag.numClients, static_cast<int>(_bufs->height/2));
+-		for (auto ind = 0; ind < indicators; ind++) {
+-			auto w = ind == tag.focusedClient ? 7 : 1;
+-			cairo_move_to(_painter, tag.component.x, ind*2+0.5);
+-			cairo_rel_line_to(_painter, w, 0);
+-			cairo_close_path(_painter);
++
++		if(!tag.numClients)
++			continue;
++
++		int s = barfont.height / 9;
++		int w = barfont.height / 6 + 2;
++		if (tag.focusedClient != -1) {
++			cairo_rectangle(_painter, tag.component.x + s, s, w, w);
++			cairo_fill(_painter);
++		} else {
++			cairo_rectangle(_painter, (double)(tag.component.x + s) + 0.5, (double)(s) + 0.5, w, w);
+ 			cairo_set_line_width(_painter, 1);
+ 			cairo_stroke(_painter);
+ 		}
+--
+2.39.0
+
diff --git a/wm/somebar/contrib/hide-vacant-tags.patch b/wm/somebar/contrib/hide-vacant-tags.patch
new file mode 100644
index 0000000..055dd51
--- /dev/null
+++ b/wm/somebar/contrib/hide-vacant-tags.patch
@@ -0,0 +1,54 @@
+From: medanisjbara anis2834133766619@gmail.com
+Date: Mon, 14 Nov 2022 22:52:00
+Description: somebar equivalent of https://dwm.suckless.org/patches/hide_vacant_tags
+diff --git a/src/bar.cpp b/src/bar.cpp
+index fab5a8f..38e7b5f 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -240,13 +240,36 @@ void Bar::render()
+ 
+ void Bar::renderTags()
+ {
++	// Check if all tags are active (Mod+0)
++	bool allActive = true;
+ 	for (auto &tag : _tags) {
++		if (tag.state & TagState::Active){
++			if (!allActive){
++				allActive = true;
++				break;
++			}
++			allActive = false;
++		}
++	}
++
++	bool renderThis;
++	for (auto &tag : _tags) {
++		renderThis = false;
+ 		setColorScheme(
+ 			tag.state & TagState::Active ? colorActive : colorInactive,
+ 			tag.state & TagState::Urgent);
+-		renderComponent(tag.component);
++		// Reder active tag if it's the only one active
++		if (!allActive && tag.state & TagState::Active)
++			renderThis = true;
+ 		auto indicators = std::min(tag.numClients, static_cast<int>(_bufs->height/2));
+ 		for (auto ind = 0; ind < indicators; ind++) {
++			// render tags having indicators
++			if (tag.focusedClient == -1)
++				renderThis = true;
++			// render tags having the focused client
++			if (tag.focusedClient == 0){
++				renderThis = true;
++			}
+ 			auto w = ind == tag.focusedClient ? 7 : 1;
+ 			cairo_move_to(_painter, tag.component.x, ind*2+0.5);
+ 			cairo_rel_line_to(_painter, w, 0);
+@@ -254,6 +277,8 @@ void Bar::renderTags()
+ 			cairo_set_line_width(_painter, 1);
+ 			cairo_stroke(_painter);
+ 		}
++		if (renderThis)
++			renderComponent(tag.component);
+ 	}
+ }
+ 
diff --git a/wm/somebar/contrib/indicator-size-props.patch b/wm/somebar/contrib/indicator-size-props.patch
new file mode 100644
index 0000000..ac17520
--- /dev/null
+++ b/wm/somebar/contrib/indicator-size-props.patch
@@ -0,0 +1,54 @@
+From: medanisjbara anis2834133766619@gmail.com
+Date: Mon, 15 Nov 2022 08:16:00
+Description: lets config.h customize indicators sizes
+diff --git a/src/bar.cpp b/src/bar.cpp
+index fab5a8f..c0e070c 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -247,11 +247,11 @@ void Bar::renderTags()
+ 		renderComponent(tag.component);
+ 		auto indicators = std::min(tag.numClients, static_cast<int>(_bufs->height/2));
+ 		for (auto ind = 0; ind < indicators; ind++) {
+-			auto w = ind == tag.focusedClient ? 7 : 1;
++			auto w = ind == tag.focusedClient ? indprops.focused_width : indprops.width;
+ 			cairo_move_to(_painter, tag.component.x, ind*2+0.5);
+ 			cairo_rel_line_to(_painter, w, 0);
+ 			cairo_close_path(_painter);
+-			cairo_set_line_width(_painter, 1);
++			cairo_set_line_width(_painter, ind == tag.focusedClient ? indprops.focused_height : indprops.height);
+ 			cairo_stroke(_painter);
+ 		}
+ 	}
+diff --git a/src/common.hpp b/src/common.hpp
+index aed4480..acdca1b 100644
+--- a/src/common.hpp
++++ b/src/common.hpp
+@@ -34,6 +34,13 @@ struct Button {
+ 	const Arg arg;
+ };
+ 
++struct IndicatorProps {
++  int width;
++  int height;
++  int focused_width;
++  int focused_height;
++};
++
+ extern wl_display* display;
+ extern wl_compositor* compositor;
+ extern wl_shm* shm;
+diff --git a/src/config.def.hpp b/src/config.def.hpp
+index 40a8c95..d51fee8 100644
+--- a/src/config.def.hpp
++++ b/src/config.def.hpp
+@@ -25,3 +25,10 @@ static std::vector<std::string> tagNames = {
+ constexpr Button buttons[] = {
+ 	{ ClkStatusText,   BTN_RIGHT,  spawn,      {.v = termcmd} },
+ };
++
++constexpr IndicatorProps indprops = {
++	5, /* unfocused indicator width  */
++	5, /* unfocused indicator height */
++	7, /*  focused indicator width   */
++	1  /*  focused indicator height  */
++};
diff --git a/wm/somebar/contrib/ipc.patch b/wm/somebar/contrib/ipc.patch
new file mode 100644
index 0000000..80c1a56
--- /dev/null
+++ b/wm/somebar/contrib/ipc.patch
@@ -0,0 +1,506 @@
+Replaces somebar's channel to dwl from stdin to a wayland extension.
+
+Normally, somebar reads dwl's state by reading from stdin. This requires
+that somebar is started from dwl, and does not allow sending commands back
+to dwl.
+
+This patch replaces this channel with a wayland protocol extension. somebar
+can use this protocol extension to observe and update the dwl window management
+state.
+
+Important! dwl must have the wayland-ipc patch applied for this to work!
+https://git.sr.ht/~raphi/dwl/blob/master/patches/wayland-ipc.patch
+diff --git a/protocols/meson.build b/protocols/meson.build
+index 7bd222b..5752608 100644
+--- a/protocols/meson.build
++++ b/protocols/meson.build
+@@ -15,6 +15,7 @@ wayland_xmls = [
+ 	wl_protocol_dir + '/stable/xdg-shell/xdg-shell.xml',
+ 	wl_protocol_dir + '/unstable/xdg-output/xdg-output-unstable-v1.xml',
+ 	'wlr-layer-shell-unstable-v1.xml',
++	'net-tapesoftware-dwl-wm-unstable-v1.xml',
+ ]
+ wayland_sources = [
+ 	wayland_scanner_code.process(wayland_xmls),
+diff --git a/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml b/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
+new file mode 100644
+index 0000000..390f5a1
+--- /dev/null
++++ b/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
+@@ -0,0 +1,164 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<protocol name="net_tapesoftware_dwl_wm_unstable_v1">
++	<copyright>
++		Copyright (c) 2021 Raphael Robatsch
++
++		Permission is hereby granted, free of charge, to any person obtaining a
++		copy of this software and associated documentation files (the
++		"Software"), to deal in the Software without restriction, including
++		without limitation the rights to use, copy, modify, merge, publish,
++		distribute, sublicense, and/or sell copies of the Software, and to
++		permit persons to whom the Software is furnished to do so, subject to
++		the following conditions:
++
++		The above copyright notice and this permission notice (including the
++		next paragraph) shall be included in all copies or substantial portions
++		of the Software.
++
++		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++		OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++		MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++		IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++		CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++		TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++		SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++	</copyright>
++
++	<interface name="znet_tapesoftware_dwl_wm_v1" version="1">
++		<description summary="control the dwl state">
++			This interface is exposed as a global in the wl_registry.
++
++			Clients can use this protocol to receive updates of the window manager
++			state (active tags, active layout, and focused window).
++			Clients can also control this state.
++
++			After binding, the client will receive the available tags and layouts
++			with the 'tag' and 'layout' events. These can be used in subsequent
++			dwl_wm_monitor_v1.set_tags/set_layout requests, and to interpret the
++			dwl_wm_monitor_v1.layout/tag events.
++		</description>
++
++		<request name="release" type="destructor">
++			<description summary="release dwl_wm">
++				This request indicates that the client will not use the dwl_wm
++				object any more. Objects that have been created through this instance
++				are not affected.
++			</description>
++		</request>
++
++		<request name="get_monitor">
++			<description summary="gets a dwl monitor from an output">
++				Gets a dwl monitor for the specified output. The window manager
++				state on the output can be controlled using the monitor.
++			</description>
++			<arg name="id" type="new_id" interface="znet_tapesoftware_dwl_wm_monitor_v1" />
++			<arg name="output" type="object" interface="wl_output" />
++		</request>
++
++		<event name="tag">
++			<description summary="announces the presence of a tag">
++				This event is sent immediately after binding.
++				A roundtrip after binding guarantees that the client has received all tags.
++			</description>
++			<arg name="name" type="string"/>
++		</event>
++
++		<event name="layout">
++			<description summary="announces the presence of a layout">
++				This event is sent immediately after binding.
++				A roundtrip after binding guarantees that the client has received all layouts.
++			</description>
++			<arg name="name" type="string"/>
++		</event>
++	</interface>
++
++	<interface name="znet_tapesoftware_dwl_wm_monitor_v1" version="1">
++		<description summary="control one monitor">
++			Observes and controls one monitor.
++
++			Events are double-buffered: Clients should cache all events and only
++			redraw themselves once the 'frame' event is sent.
++
++			Requests are not double-buffered: The compositor will update itself
++			immediately.
++		</description>
++
++		<enum name="tag_state">
++			<entry name="none" value="0" summary="no state"/>
++			<entry name="active" value="1" summary="tag is active"/>
++			<entry name="urgent" value="2" summary="tag has at least one urgent client"/>
++		</enum>
++
++		<request name="release" type="destructor">
++			<description summary="release dwl_monitor">
++				This request indicates that the client is done with this dwl_monitor.
++				All further requests are ignored.
++			</description>
++		</request>
++
++		<event name="selected">
++			<description summary="updates the selected state of the monitor">
++				If 'selected' is nonzero, this monitor is the currently selected one.
++			</description>
++			<arg name="selected" type="uint"/>
++		</event>
++
++		<event name="tag">
++			<description summary="updates the state of one tag">
++				Announces the update of a tag. num_clients and focused_client can be
++				used to draw client indicators.
++			</description>
++			<arg name="tag" type="uint" summary="index of a tag received by the dwl_wm_v1.tag event." />
++			<arg name="state" type="uint" enum="tag_state"/>
++			<arg name="num_clients" type="uint" summary="number of clients on this tag"/>
++			<arg name="focused_client" type="int" summary="out of num_clients. -1 if there is no focused client"/>
++		</event>
++
++		<event name="layout">
++			<description summary="updates the selected layout">
++				Announces the update of the selected layout.
++			</description>
++			<arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
++		</event>
++
++		<event name="title">
++			<description summary="updates the focused client">
++				Announces the update of the selected client.
++			</description>
++			<arg name="title" type="string"/>
++		</event>
++
++		<event name="frame">
++			<description summary="end of status update sequence">
++				Sent after all other events belonging to the status update has been sent.
++				Clients should redraw themselves now.
++			</description>
++		</event>
++
++		<request name="set_tags">
++			<description summary="sets the active tags on this monitor.">
++				Changes are applied immediately.
++			</description>
++			<arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
++			<arg name="toggle_tagset" type="uint"/>
++		</request>
++
++		<request name="set_client_tags">
++			<description summary="updates the tags of the focused client.">
++				tags are updated as follows:
++				new_tags = (current_tags AND and_tags) XOR xor_tags
++
++				Changes are applied immediately.
++			</description>
++			<arg name="and_tags" type="uint"/>
++			<arg name="xor_tags" type="uint"/>
++		</request>
++
++		<request name="set_layout">
++			<description summary="sets the active layout on this monitor.">
++				Changes are applied immediately.
++			</description>
++			<arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
++		</request>
++	</interface>
++</protocol>
+diff --git a/src/common.hpp b/src/common.hpp
+index c905358..9b62a94 100644
+--- a/src/common.hpp
++++ b/src/common.hpp
+@@ -10,6 +10,7 @@
+ #include <cairo/cairo.h>
+ #include <pango/pango.h>
+ #include "wlr-layer-shell-unstable-v1-client-protocol.h"
++#include "net-tapesoftware-dwl-wm-unstable-v1-client-protocol.h"
+ 
+ struct Color {
+ 	Color() {}
+@@ -38,7 +39,14 @@ extern wl_display* display;
+ extern wl_compositor* compositor;
+ extern wl_shm* shm;
+ extern zwlr_layer_shell_v1* wlrLayerShell;
++extern std::vector<std::string> tagNames;
++extern std::vector<std::string> layoutNames;
+ 
++void view(Monitor& m, const Arg& arg);
++void toggleview(Monitor& m, const Arg& arg);
++void setlayout(Monitor& m, const Arg& arg);
++void tag(Monitor& m, const Arg& arg);
++void toggletag(Monitor& m, const Arg& arg);
+ void spawn(Monitor&, const Arg& arg);
+ void setCloexec(int fd);
+ [[noreturn]] void die(const char* why);
+@@ -65,6 +73,7 @@ WL_DELETER(wl_output, wl_output_release_checked);
+ WL_DELETER(wl_pointer, wl_pointer_release);
+ WL_DELETER(wl_seat, wl_seat_release);
+ WL_DELETER(wl_surface, wl_surface_destroy);
++WL_DELETER(znet_tapesoftware_dwl_wm_monitor_v1, znet_tapesoftware_dwl_wm_monitor_v1_release);
+ WL_DELETER(zwlr_layer_surface_v1, zwlr_layer_surface_v1_destroy);
+ 
+ WL_DELETER(cairo_t, cairo_destroy);
+diff --git a/src/config.def.hpp b/src/config.def.hpp
+index 40a8c95..a9560cb 100644
+--- a/src/config.def.hpp
++++ b/src/config.def.hpp
+@@ -16,12 +16,11 @@ constexpr ColorScheme colorInactive = {Color(0xbb, 0xbb, 0xbb), Color(0x22, 0x22
+ constexpr ColorScheme colorActive = {Color(0xee, 0xee, 0xee), Color(0x00, 0x55, 0x77)};
+ constexpr const char* termcmd[] = {"foot", nullptr};
+ 
+-static std::vector<std::string> tagNames = {
+-	"1", "2", "3",
+-	"4", "5", "6",
+-	"7", "8", "9",
+-};
+-
+ constexpr Button buttons[] = {
++	{ ClkTagBar,       BTN_LEFT,   view,       {0} },
++	{ ClkTagBar,       BTN_RIGHT,  tag,        {0} },
++	{ ClkTagBar,       BTN_MIDDLE, toggletag,  {0} },
++	{ ClkLayoutSymbol, BTN_LEFT,   setlayout,  {.ui = 0} },
++	{ ClkLayoutSymbol, BTN_RIGHT,  setlayout,  {.ui = 2} },
+ 	{ ClkStatusText,   BTN_RIGHT,  spawn,      {.v = termcmd} },
+ };
+diff --git a/src/main.cpp b/src/main.cpp
+index 6274959..01be870 100644
+--- a/src/main.cpp
++++ b/src/main.cpp
+@@ -3,7 +3,6 @@
+ 
+ #include <algorithm>
+ #include <cstdio>
+-#include <sstream>
+ #include <list>
+ #include <optional>
+ #include <utility>
+@@ -21,8 +20,8 @@
+ #include "wlr-layer-shell-unstable-v1-client-protocol.h"
+ #include "xdg-output-unstable-v1-client-protocol.h"
+ #include "xdg-shell-client-protocol.h"
++#include "net-tapesoftware-dwl-wm-unstable-v1-client-protocol.h"
+ #include "common.hpp"
+-#include "config.hpp"
+ #include "bar.hpp"
+ #include "line_buffer.hpp"
+ 
+@@ -34,6 +33,7 @@ struct Monitor {
+ 	bool desiredVisibility {true};
+ 	bool hasData;
+ 	uint32_t tags;
++	wl_unique_ptr<znet_tapesoftware_dwl_wm_monitor_v1> dwlMonitor;
+ };
+ 
+ struct SeatPointer {
+@@ -54,8 +54,6 @@ static void updatemon(Monitor &mon);
+ static void onReady();
+ static void setupStatusFifo();
+ static void onStatus();
+-static void onStdin();
+-static void handleStdin(const std::string& line);
+ static void updateVisibility(const std::string& name, bool(*updater)(bool));
+ static void onGlobalAdd(void*, wl_registry* registry, uint32_t name, const char* interface, uint32_t version);
+ static void onGlobalRemove(void*, wl_registry* registry, uint32_t name);
+@@ -67,6 +65,9 @@ wl_display* display;
+ wl_compositor* compositor;
+ wl_shm* shm;
+ zwlr_layer_shell_v1* wlrLayerShell;
++znet_tapesoftware_dwl_wm_v1* dwlWm;
++std::vector<std::string> tagNames;
++std::vector<std::string> layoutNames;
+ static xdg_wm_base* xdgWmBase;
+ static zxdg_output_manager_v1* xdgOutputManager;
+ static wl_surface* cursorSurface;
+@@ -85,6 +86,26 @@ static int statusFifoFd {-1};
+ static int statusFifoWriter {-1};
+ static bool quitting {false};
+ 
++void view(Monitor& m, const Arg& arg)
++{
++	znet_tapesoftware_dwl_wm_monitor_v1_set_tags(m.dwlMonitor.get(), arg.ui, 1);
++}
++void toggleview(Monitor& m, const Arg& arg)
++{
++	znet_tapesoftware_dwl_wm_monitor_v1_set_tags(m.dwlMonitor.get(), m.tags ^ arg.ui, 0);
++}
++void setlayout(Monitor& m, const Arg& arg)
++{
++	znet_tapesoftware_dwl_wm_monitor_v1_set_layout(m.dwlMonitor.get(), arg.ui);
++}
++void tag(Monitor& m, const Arg& arg)
++{
++	znet_tapesoftware_dwl_wm_monitor_v1_set_client_tags(m.dwlMonitor.get(), 0, arg.ui);
++}
++void toggletag(Monitor& m, const Arg& arg)
++{
++	znet_tapesoftware_dwl_wm_monitor_v1_set_client_tags(m.dwlMonitor.get(), ~0, arg.ui);
++}
+ void spawn(Monitor&, const Arg& arg)
+ {
+ 	if (fork() == 0) {
+@@ -189,11 +210,62 @@ static const struct wl_seat_listener seatListener = {
+ 	.name = [](void*, wl_seat*, const char* name) { }
+ };
+ 
++static const struct znet_tapesoftware_dwl_wm_v1_listener dwlWmListener = {
++	.tag = [](void*, znet_tapesoftware_dwl_wm_v1*, const char* name) {
++		tagNames.push_back(name);
++	},
++	.layout = [](void*, znet_tapesoftware_dwl_wm_v1*, const char* name) {
++		layoutNames.push_back(name);
++	},
++};
++
++static const struct znet_tapesoftware_dwl_wm_monitor_v1_listener dwlWmMonitorListener {
++	.selected = [](void* mv, znet_tapesoftware_dwl_wm_monitor_v1*, uint32_t selected) {
++		auto mon = static_cast<Monitor*>(mv);
++		if (selected) {
++			selmon = mon;
++		} else if (selmon == mon) {
++			selmon = nullptr;
++		}
++		mon->bar.setSelected(selected);
++	},
++	.tag = [](void* mv, znet_tapesoftware_dwl_wm_monitor_v1*, uint32_t tag, uint32_t state, uint32_t numClients, int32_t focusedClient) {
++		auto mon = static_cast<Monitor*>(mv);
++		int tagState = TagState::None;
++		if (state & ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_ACTIVE)
++			tagState |= TagState::Active;
++		if (state & ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_URGENT)
++			tagState |= TagState::Urgent;
++		mon->bar.setTag(tag, tagState, numClients, focusedClient);
++		uint32_t mask = 1 << tag;
++		if (tagState & TagState::Active) {
++			mon->tags |= mask;
++		} else {
++			mon->tags &= ~mask;
++		}
++	},
++	.layout = [](void* mv, znet_tapesoftware_dwl_wm_monitor_v1*, uint32_t layout) {
++		auto mon = static_cast<Monitor*>(mv);
++		mon->bar.setLayout(layoutNames[layout]);
++	},
++	.title = [](void* mv, znet_tapesoftware_dwl_wm_monitor_v1*, const char* title) {
++		auto mon = static_cast<Monitor*>(mv);
++		mon->bar.setTitle(title);
++	},
++	.frame = [](void* mv, znet_tapesoftware_dwl_wm_monitor_v1*) {
++		auto mon = static_cast<Monitor*>(mv);
++		mon->hasData = true;
++		updatemon(*mon);
++	}
++};
++
+ void setupMonitor(uint32_t name, wl_output* output) {
+ 	auto& monitor = monitors.emplace_back(Monitor {name, {}, wl_unique_ptr<wl_output> {output}});
+ 	monitor.bar.setStatus(lastStatus);
+ 	auto xdgOutput = zxdg_output_manager_v1_get_xdg_output(xdgOutputManager, monitor.wlOutput.get());
+ 	zxdg_output_v1_add_listener(xdgOutput, &xdgOutputListener, &monitor);
++	monitor.dwlMonitor.reset(znet_tapesoftware_dwl_wm_v1_get_monitor(dwlWm, monitor.wlOutput.get()));
++	znet_tapesoftware_dwl_wm_monitor_v1_add_listener(monitor.dwlMonitor.get(), &dwlWmMonitorListener, &monitor);
+ }
+ 
+ void updatemon(Monitor& mon)
+@@ -219,6 +291,7 @@ void onReady()
+ 	requireGlobal(shm, "wl_shm");
+ 	requireGlobal(wlrLayerShell, "zwlr_layer_shell_v1");
+ 	requireGlobal(xdgOutputManager, "zxdg_output_manager_v1");
++	requireGlobal(dwlWm, "znet_tapesoftware_dwl_wm_v1");
+ 	setupStatusFifo();
+ 	wl_display_roundtrip(display); // roundtrip so we receive all dwl tags etc.
+ 
+@@ -226,7 +299,6 @@ void onReady()
+ 	for (auto output : uninitializedOutputs) {
+ 		setupMonitor(output.first, output.second);
+ 	}
+-	wl_display_roundtrip(display); // wait for xdg_output names before we read stdin
+ }
+ 
+ bool createFifo(std::string path)
+@@ -273,68 +345,6 @@ void setupStatusFifo()
+ 	}
+ }
+ 
+-static LineBuffer<512> stdinBuffer;
+-static void onStdin()
+-{
+-	auto res = stdinBuffer.readLines(
+-		[](void* p, size_t size) { return read(0, p, size); },
+-		[](char* p, size_t size) { handleStdin({p, size}); });
+-	if (res == 0) {
+-		quitting = true;
+-	}
+-}
+-
+-static void handleStdin(const std::string& line)
+-{
+-	// this parses the lines that dwl sends in printstatus()
+-	std::string monName, command;
+-	auto stream = std::istringstream {line};
+-	stream >> monName >> command;
+-	if (!stream.good()) {
+-		return;
+-	}
+-	auto mon = std::find_if(begin(monitors), end(monitors), [&](const Monitor& mon) {
+-		return mon.xdgName == monName;
+-	});
+-	if (mon == end(monitors))
+-		return;
+-	if (command == "title") {
+-		auto title = std::string {};
+-		stream >> std::ws;
+-		std::getline(stream, title);
+-		mon->bar.setTitle(title);
+-	} else if (command == "selmon") {
+-		uint32_t selected;
+-		stream >> selected;
+-		mon->bar.setSelected(selected);
+-		if (selected) {
+-			selmon = &*mon;
+-		} else if (selmon == &*mon) {
+-			selmon = nullptr;
+-		}
+-	} else if (command == "tags") {
+-		uint32_t occupied, tags, clientTags, urgent;
+-		stream >> occupied >> tags >> clientTags >> urgent;
+-		for (auto i=0u; i<tagNames.size(); i++) {
+-			auto tagMask = 1 << i;
+-			int state = TagState::None;
+-			if (tags & tagMask)
+-				state |= TagState::Active;
+-			if (urgent & tagMask)
+-				state |= TagState::Urgent;
+-			mon->bar.setTag(i, state, occupied & tagMask ? 1 : 0, clientTags & tagMask ? 0 : -1);
+-		}
+-		mon->tags = tags;
+-	} else if (command == "layout") {
+-		auto layout = std::string {};
+-		stream >> std::ws;
+-		std::getline(stream, layout);
+-		mon->bar.setLayout(layout);
+-	}
+-	mon->hasData = true;
+-	updatemon(*mon);
+-}
+-
+ const std::string prefixStatus = "status ";
+ const std::string prefixShow = "show ";
+ const std::string prefixHide = "hide ";
+@@ -409,6 +419,10 @@ void onGlobalAdd(void*, wl_registry* registry, uint32_t name, const char* interf
+ 		xdg_wm_base_add_listener(xdgWmBase, &xdgWmBaseListener, nullptr);
+ 		return;
+ 	}
++	if (reg.handle(dwlWm, znet_tapesoftware_dwl_wm_v1_interface, 1)) {
++		znet_tapesoftware_dwl_wm_v1_add_listener(dwlWm, &dwlWmListener, nullptr);
++		return;
++	}
+ 	if (wl_seat* wlSeat; reg.handle(wlSeat, wl_seat_interface, 7)) {
+ 		auto& seat = seats.emplace_back(Seat {name, wl_unique_ptr<wl_seat> {wlSeat}});
+ 		wl_seat_add_listener(wlSeat, &seatListener, &seat);
+@@ -522,10 +536,6 @@ int main(int argc, char* argv[])
+ 		.fd = displayFd,
+ 		.events = POLLIN,
+ 	});
+-	pollfds.push_back({
+-		.fd = STDIN_FILENO,
+-		.events = POLLIN,
+-	});
+ 	if (fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK) < 0) {
+ 		diesys("fcntl F_SETFL");
+ 	}
+@@ -550,8 +560,6 @@ int main(int argc, char* argv[])
+ 						ev.events = POLLIN;
+ 						waylandFlush();
+ 					}
+-				} else if (ev.fd == STDIN_FILENO && (ev.revents & POLLIN)) {
+-					onStdin();
+ 				} else if (ev.fd == statusFifoFd && (ev.revents & POLLIN)) {
+ 					onStatus();
+ 				} else if (ev.fd == signalSelfPipe[0] && (ev.revents & POLLIN)) {
diff --git a/wm/somebar/contrib/markup-in-status-messages.patch b/wm/somebar/contrib/markup-in-status-messages.patch
new file mode 100644
index 0000000..ab7e998
--- /dev/null
+++ b/wm/somebar/contrib/markup-in-status-messages.patch
@@ -0,0 +1,65 @@
+From: Ben Collerson <benc@benc.cc>
+Date: Tue, 29 Nov 2022 11:29:15 +1000
+Subject: [PATCH] markup in status messages
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Allows pango markup to be used in status messages which allow colours to
+be used to highlight parts of status bar messages. eg:
+
+battery: full <span color="#ffff00">🔇0</span> Tue 11-20 20:10
+---
+ src/bar.cpp | 16 +++++++++++++++-
+ src/bar.hpp |  1 +
+ 2 files changed, 16 insertions(+), 1 deletion(-)
+
+diff --git a/src/bar.cpp b/src/bar.cpp
+index 507ce62..a96c547 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -81,6 +81,11 @@ void BarComponent::setText(const std::string& text)
+ 	pango_layout_set_text(pangoLayout.get(), _text->c_str(), _text->size());
+ }
+ 
++void BarComponent::setAttributes(PangoAttrList *attrs)
++{
++	pango_layout_set_attributes(pangoLayout.get(), attrs);
++}
++
+ Bar::Bar()
+ {
+ 	_pangoContext.reset(pango_font_map_create_context(pango_cairo_font_map_get_default()));
+@@ -156,7 +161,16 @@ void Bar::setTitle(const std::string& title)
+ }
+ void Bar::setStatus(const std::string& status)
+ {
+-	_statusCmp.setText(status);
++	char *buf;
++	GError *error = NULL;
++	PangoAttrList *attrs;
++	if (pango_parse_markup(status.c_str(), -1, 0, &attrs, &buf, NULL, &error)) {
++		_statusCmp.setText(buf);
++		_statusCmp.setAttributes(attrs);
++	}
++	else {
++		_statusCmp.setText(error->message);
++	}
+ }
+ 
+ void Bar::invalidate()
+diff --git a/src/bar.hpp b/src/bar.hpp
+index 176a1bc..dfc2043 100644
+--- a/src/bar.hpp
++++ b/src/bar.hpp
+@@ -17,6 +17,7 @@ public:
+ 	explicit BarComponent(wl_unique_ptr<PangoLayout> layout);
+ 	int width() const;
+ 	void setText(const std::string& text);
++	void setAttributes(PangoAttrList *attrs);
+ 	wl_unique_ptr<PangoLayout> pangoLayout;
+ 	int x {0};
+ };
+-- 
+2.38.1
+
diff --git a/wm/somebar/contrib/show-status-on-selected-monitor.patch b/wm/somebar/contrib/show-status-on-selected-monitor.patch
new file mode 100644
index 0000000..ab26835
--- /dev/null
+++ b/wm/somebar/contrib/show-status-on-selected-monitor.patch
@@ -0,0 +1,43 @@
+From 1ca4603b79e888980fb46d5dc6aa0d6f8afa2b3c Mon Sep 17 00:00:00 2001
+From: Ben Collerson <benc@benc.cc>
+Date: Mon, 28 Nov 2022 13:22:16 +1000
+Subject: [PATCH] show status on selected monitor
+
+---
+ src/bar.cpp  | 7 ++++++-
+ src/main.cpp | 1 +
+ 2 files changed, 7 insertions(+), 1 deletion(-)
+
+diff --git a/src/bar.cpp b/src/bar.cpp
+index 507ce62..f962927 100644
+--- a/src/bar.cpp
++++ b/src/bar.cpp
+@@ -156,7 +156,12 @@ void Bar::setTitle(const std::string& title)
+ }
+ void Bar::setStatus(const std::string& status)
+ {
+-	_statusCmp.setText(status);
++	if (_selected) {
++		_statusCmp.setText(status);
++	}
++	else {
++		_statusCmp.setText("");
++	}
+ }
+ 
+ void Bar::invalidate()
+diff --git a/src/main.cpp b/src/main.cpp
+index 6274959..c6fd401 100644
+--- a/src/main.cpp
++++ b/src/main.cpp
+@@ -307,6 +307,7 @@ static void handleStdin(const std::string& line)
+ 		uint32_t selected;
+ 		stream >> selected;
+ 		mon->bar.setSelected(selected);
++		mon->bar.setStatus(lastStatus);
+ 		if (selected) {
+ 			selmon = &*mon;
+ 		} else if (selmon == &*mon) {
+-- 
+2.38.1
+
diff --git a/wm/somebar/meson.build b/wm/somebar/meson.build
new file mode 100644
index 0000000..6ad5a0f
--- /dev/null
+++ b/wm/somebar/meson.build
@@ -0,0 +1,31 @@
+project('somebar', ['c', 'cpp'],
+	version: '0.1.0',
+	default_options: [
+	    'cpp_std=c++17',
+	    'cpp_args=-Wno-parentheses',
+	])
+
+wayland_dep = dependency('wayland-client')
+wayland_cursor_dep = dependency('wayland-cursor')
+cairo_dep = dependency('cairo')
+pango_dep = dependency('pango')
+pangocairo_dep = dependency('pangocairo')
+
+subdir('protocols')
+
+executable('somebar',
+	'src/main.cpp',
+	'src/shm_buffer.cpp',
+	'src/bar.cpp',
+	wayland_sources,
+	dependencies: [
+	    wayland_dep,
+	    wayland_cursor_dep,
+	    cairo_dep,
+	    pango_dep,
+	    pangocairo_dep,
+	],
+	install: true,
+	cpp_args: '-DSOMEBAR_VERSION="@0@"'.format(meson.project_version()))
+
+install_man('somebar.1')
diff --git a/wm/somebar/protocols/meson.build b/wm/somebar/protocols/meson.build
new file mode 100644
index 0000000..7bd222b
--- /dev/null
+++ b/wm/somebar/protocols/meson.build
@@ -0,0 +1,22 @@
+# adapted from https://github.com/swaywm/swayidle/blob/0467c1e03a5780ed8e3ba611f099a838822ab550/meson.build
+wayland_scanner = find_program('wayland-scanner')
+wayland_protos_dep = dependency('wayland-protocols')
+wl_protocol_dir = wayland_protos_dep.get_pkgconfig_variable('pkgdatadir')
+wayland_scanner_code = generator(
+	wayland_scanner,
+	output: '@BASENAME@-protocol.c',
+	arguments: ['private-code', '@INPUT@', '@OUTPUT@'])
+wayland_scanner_client = generator(
+	wayland_scanner,
+	output: '@BASENAME@-client-protocol.h',
+	arguments: ['client-header', '@INPUT@', '@OUTPUT@'])
+
+wayland_xmls = [
+	wl_protocol_dir + '/stable/xdg-shell/xdg-shell.xml',
+	wl_protocol_dir + '/unstable/xdg-output/xdg-output-unstable-v1.xml',
+	'wlr-layer-shell-unstable-v1.xml',
+]
+wayland_sources = [
+	wayland_scanner_code.process(wayland_xmls),
+	wayland_scanner_client.process(wayland_xmls),
+]
diff --git a/wm/somebar/protocols/wlr-layer-shell-unstable-v1.xml b/wm/somebar/protocols/wlr-layer-shell-unstable-v1.xml
new file mode 100644
index 0000000..78ba050
--- /dev/null
+++ b/wm/somebar/protocols/wlr-layer-shell-unstable-v1.xml
@@ -0,0 +1,390 @@
+<?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="name_space" 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>
diff --git a/wm/somebar/screenshot.png b/wm/somebar/screenshot.png
new file mode 100644
index 0000000..7a800fb
--- /dev/null
+++ b/wm/somebar/screenshot.png
diff --git a/wm/somebar/somebar.1 b/wm/somebar/somebar.1
new file mode 100644
index 0000000..d822770
--- /dev/null
+++ b/wm/somebar/somebar.1
@@ -0,0 +1,55 @@
+.TH somebar 1 somebar\-1.0
+.SH NAME
+somebar \- dwm-like bar for dwl
+.SH SYNOPSIS
+.B somebar
+.RB [ \-h ]
+.RB [ \-v ]
+.RB [ \-s
+.IR path ]
+.RB [ \-c
+.IR command
+arguments... ]
+.SH DESCRIPTION
+somebar is a status bar for dwl, visually and functionally resembling the
+dwm bar.
+.SH USAGE
+You must start somebar using dwl's `-s` flag, e.g. `dwl -s somebar`.
+
+Somebar can be controlled by writing to $XDG_RUNTIME_DIR/somebar-0, or the path
+defined by the `-s` argument. The following commands are supported:
+.TP
+.B status TEXT
+Updates the status bar
+.TP
+.B hide MONITOR
+Hides somebar on the specified monitor
+.TP
+.B show MONITOR
+Shows somebar on the specified monitor
+.TP
+.B toggle MONITOR
+Toggles somebar on the specified monitor
+.P
+MONITOR is an zxdg_output_v1 name, which can be determined e.g. using `weston-info`.
+Additionally, MONITOR can be `all` (all monitors) or `selected` (the monitor with focus).
+
+Commands can be sent either by writing to the file name above, or equivalently by calling
+somebar with the `-c` argument. For example: `somebar -c toggle all`. This is recommended
+for shell scripts, as there is no race-free way to write to a file only if it exists.
+.SH OPTIONS
+.TP
+.B \-h
+Displays a short help text and exits
+.TP
+.B \-v
+Displays version information and exits
+.TP
+.B \-s
+Sets the path to the somebar control FIFO. The default value is
+$XDG_RUNTIME_DIR/somebar-0
+.TP
+.B \-c
+Sends a command to the control FIFO. See the USAGE section.
+.SH BUGS
+Send bug reports to ~raphi/public-inbox@lists.sr.ht
diff --git a/wm/somebar/src/bar.cpp b/wm/somebar/src/bar.cpp
new file mode 100644
index 0000000..507ce62
--- /dev/null
+++ b/wm/somebar/src/bar.cpp
@@ -0,0 +1,315 @@
+// somebar - dwl barbar
+// See LICENSE file for copyright and license details.
+
+#include <wayland-client-protocol.h>
+#include <pango/pangocairo.h>
+#include "bar.hpp"
+#include "cairo.h"
+#include "config.hpp"
+#include "pango/pango-font.h"
+#include "pango/pango-fontmap.h"
+#include "pango/pango-layout.h"
+
+const zwlr_layer_surface_v1_listener Bar::_layerSurfaceListener = {
+	[](void* owner, zwlr_layer_surface_v1*, uint32_t serial, uint32_t width, uint32_t height)
+	{
+		static_cast<Bar*>(owner)->layerSurfaceConfigure(serial, width, height);
+	}
+};
+const wl_callback_listener Bar::_frameListener = {
+	[](void* owner, wl_callback* cb, uint32_t)
+	{
+		static_cast<Bar*>(owner)->render();
+		wl_callback_destroy(cb);
+	}
+};
+
+struct Font {
+	PangoFontDescription* description;
+	int height {0};
+};
+static Font getFont()
+{
+	auto fontMap = pango_cairo_font_map_get_default();
+	if (!fontMap) {
+		die("pango_cairo_font_map_get_default");
+	}
+	auto fontDesc = pango_font_description_from_string(font);
+	if (!fontDesc) {
+		die("pango_font_description_from_string");
+	}
+	auto tempContext = pango_font_map_create_context(fontMap);
+	if (!tempContext) {
+		die("pango_font_map_create_context");
+	}
+	auto font = pango_font_map_load_font(fontMap, tempContext, fontDesc);
+	if (!font) {
+		die("pango_font_map_load_font");
+	}
+	auto metrics = pango_font_get_metrics(font, pango_language_get_default());
+	if (!metrics) {
+		die("pango_font_get_metrics");
+	}
+
+	auto res = Font {};
+	res.description = fontDesc;
+	res.height = PANGO_PIXELS(pango_font_metrics_get_height(metrics));
+
+	pango_font_metrics_unref(metrics);
+	g_object_unref(font);
+	g_object_unref(tempContext);
+	return res;
+}
+static Font barfont = getFont();
+
+BarComponent::BarComponent() { }
+BarComponent::BarComponent(wl_unique_ptr<PangoLayout> layout)
+	: pangoLayout {std::move(layout)}
+{
+}
+
+int BarComponent::width() const
+{
+	int w, h;
+	pango_layout_get_size(pangoLayout.get(), &w, &h);
+	return PANGO_PIXELS(w);
+}
+
+void BarComponent::setText(const std::string& text)
+{
+	_text = std::make_unique<std::string>(text);
+	pango_layout_set_text(pangoLayout.get(), _text->c_str(), _text->size());
+}
+
+Bar::Bar()
+{
+	_pangoContext.reset(pango_font_map_create_context(pango_cairo_font_map_get_default()));
+	if (!_pangoContext) {
+		die("pango_font_map_create_context");
+	}
+	for (const auto& tagName : tagNames) {
+		_tags.push_back({ TagState::None, 0, 0, createComponent(tagName) });
+	}
+	_layoutCmp = createComponent();
+	_titleCmp = createComponent();
+	_statusCmp = createComponent();
+}
+
+const wl_surface* Bar::surface() const
+{
+	return _surface.get();
+}
+
+bool Bar::visible() const
+{
+	return _surface.get();
+}
+
+void Bar::show(wl_output* output)
+{
+	if (visible()) {
+		return;
+	}
+	_surface.reset(wl_compositor_create_surface(compositor));
+	_layerSurface.reset(zwlr_layer_shell_v1_get_layer_surface(wlrLayerShell,
+		_surface.get(), output, ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM, "net.tapesoftware.Somebar"));
+	zwlr_layer_surface_v1_add_listener(_layerSurface.get(), &_layerSurfaceListener, this);
+	auto anchor = topbar ? ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP : ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+	zwlr_layer_surface_v1_set_anchor(_layerSurface.get(),
+		anchor | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
+
+	auto barSize = barfont.height + paddingY * 2;
+	zwlr_layer_surface_v1_set_size(_layerSurface.get(), 0, barSize);
+	zwlr_layer_surface_v1_set_exclusive_zone(_layerSurface.get(), barSize);
+	wl_surface_commit(_surface.get());
+}
+
+void Bar::hide()
+{
+	if (!visible()) {
+		return;
+	}
+	_layerSurface.reset();
+	_surface.reset();
+	_bufs.reset();
+}
+
+void Bar::setTag(int tag, int state, int numClients, int focusedClient)
+{
+	auto& t = _tags[tag];
+	t.state = state;
+	t.numClients = numClients;
+	t.focusedClient = focusedClient;
+}
+
+void Bar::setSelected(bool selected)
+{
+	_selected = selected;
+}
+void Bar::setLayout(const std::string& layout)
+{
+	_layoutCmp.setText(layout);
+}
+void Bar::setTitle(const std::string& title)
+{
+	_titleCmp.setText(title);
+}
+void Bar::setStatus(const std::string& status)
+{
+	_statusCmp.setText(status);
+}
+
+void Bar::invalidate()
+{
+	if (_invalid || !visible()) {
+		return;
+	}
+	_invalid = true;
+	auto frame = wl_surface_frame(_surface.get());
+	wl_callback_add_listener(frame, &_frameListener, this);
+	wl_surface_commit(_surface.get());
+}
+
+void Bar::click(Monitor* mon, int x, int, int btn)
+{
+	Arg arg = {0};
+	Arg* argp = nullptr;
+	int control = ClkNone;
+	if (x > _statusCmp.x) {
+		control = ClkStatusText;
+	} else if (x > _titleCmp.x) {
+		control = ClkWinTitle;
+	} else if (x > _layoutCmp.x) {
+		control = ClkLayoutSymbol;
+	} else for (auto tag = _tags.size()-1; tag >= 0; tag--) {
+		if (x > _tags[tag].component.x) {
+			control = ClkTagBar;
+			arg.ui = 1<<tag;
+			argp = &arg;
+			break;
+		}
+	}
+	for (const auto& button : buttons) {
+		if (button.control == control && button.btn == btn) {
+			button.func(*mon, *(argp ? argp : &button.arg));
+			return;
+		}
+	}
+}
+
+void Bar::layerSurfaceConfigure(uint32_t serial, uint32_t width, uint32_t height)
+{
+	zwlr_layer_surface_v1_ack_configure(_layerSurface.get(), serial);
+	if (_bufs && width == _bufs->width && height == _bufs->height) {
+		return;
+	}
+	_bufs.emplace(width, height, WL_SHM_FORMAT_XRGB8888);
+	render();
+}
+
+void Bar::render()
+{
+	if (!_bufs) {
+		return;
+	}
+	auto img = wl_unique_ptr<cairo_surface_t> {cairo_image_surface_create_for_data(
+		_bufs->data(),
+		CAIRO_FORMAT_ARGB32,
+		_bufs->width,
+		_bufs->height,
+		_bufs->stride
+		)};
+	auto painter = wl_unique_ptr<cairo_t> {cairo_create(img.get())};
+	_painter = painter.get();
+	pango_cairo_update_context(_painter, _pangoContext.get());
+	_x = 0;
+
+	renderTags();
+	setColorScheme(_selected ? colorActive : colorInactive);
+	renderComponent(_layoutCmp);
+	renderComponent(_titleCmp);
+	renderStatus();
+
+	_painter = nullptr;
+	wl_surface_attach(_surface.get(), _bufs->buffer(), 0, 0);
+	wl_surface_damage(_surface.get(), 0, 0, _bufs->width, _bufs->height);
+	wl_surface_commit(_surface.get());
+	_bufs->flip();
+	_invalid = false;
+}
+
+void Bar::renderTags()
+{
+	for (auto &tag : _tags) {
+		setColorScheme(
+			tag.state & TagState::Active ? colorActive : colorInactive,
+			tag.state & TagState::Urgent);
+		renderComponent(tag.component);
+		auto indicators = std::min(tag.numClients, static_cast<int>(_bufs->height/2));
+		for (auto ind = 0; ind < indicators; ind++) {
+			auto w = ind == tag.focusedClient ? 7 : 1;
+			cairo_move_to(_painter, tag.component.x, ind*2+0.5);
+			cairo_rel_line_to(_painter, w, 0);
+			cairo_close_path(_painter);
+			cairo_set_line_width(_painter, 1);
+			cairo_stroke(_painter);
+		}
+	}
+}
+
+void Bar::renderStatus()
+{
+	pango_cairo_update_layout(_painter, _statusCmp.pangoLayout.get());
+	beginBg();
+	auto start = _bufs->width - _statusCmp.width() - paddingX*2;
+	cairo_rectangle(_painter, _x, 0, _bufs->width-_x+start, _bufs->height);
+	cairo_fill(_painter);
+
+	_x = start;
+	renderComponent(_statusCmp);
+}
+
+void Bar::setColorScheme(const ColorScheme& scheme, bool invert)
+{
+	_colorScheme = invert
+		? ColorScheme {scheme.bg, scheme.fg}
+		: ColorScheme {scheme.fg, scheme.bg};
+}
+static void setColor(cairo_t* painter, const Color& color)
+{
+	cairo_set_source_rgba(painter,
+		color.r/255.0, color.g/255.0, color.b/255.0, color.a/255.0);
+}
+void Bar::beginFg()
+{
+	setColor(_painter, _colorScheme.fg);
+}
+void Bar::beginBg()
+{
+	setColor(_painter, _colorScheme.bg);
+}
+
+void Bar::renderComponent(BarComponent& component)
+{
+	pango_cairo_update_layout(_painter, component.pangoLayout.get());
+	auto size = component.width() + paddingX*2;
+	component.x = _x;
+
+	beginBg();
+	cairo_rectangle(_painter, _x, 0, size, _bufs->height);
+	cairo_fill(_painter);
+	cairo_move_to(_painter, _x+paddingX, paddingY);
+
+	beginFg();
+	pango_cairo_show_layout(_painter, component.pangoLayout.get());
+	_x += size;
+}
+
+BarComponent Bar::createComponent(const std::string &initial)
+{
+	auto layout = pango_layout_new(_pangoContext.get());
+	pango_layout_set_font_description(layout, barfont.description);
+	auto res = BarComponent {wl_unique_ptr<PangoLayout> {layout}};
+	res.setText(initial);
+	return res;
+}
diff --git a/wm/somebar/src/bar.hpp b/wm/somebar/src/bar.hpp
new file mode 100644
index 0000000..176a1bc
--- /dev/null
+++ b/wm/somebar/src/bar.hpp
@@ -0,0 +1,74 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include <optional>
+#include <string>
+#include <vector>
+#include <wayland-client.h>
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+#include "common.hpp"
+#include "shm_buffer.hpp"
+
+class BarComponent {
+	std::unique_ptr<std::string> _text;
+public:
+	BarComponent();
+	explicit BarComponent(wl_unique_ptr<PangoLayout> layout);
+	int width() const;
+	void setText(const std::string& text);
+	wl_unique_ptr<PangoLayout> pangoLayout;
+	int x {0};
+};
+
+struct Tag {
+	int state;
+	int numClients;
+	int focusedClient;
+	BarComponent component;
+};
+
+struct Monitor;
+class Bar {
+	static const zwlr_layer_surface_v1_listener _layerSurfaceListener;
+	static const wl_callback_listener _frameListener;
+
+	wl_unique_ptr<wl_surface> _surface;
+	wl_unique_ptr<zwlr_layer_surface_v1> _layerSurface;
+	wl_unique_ptr<PangoContext> _pangoContext;
+	std::optional<ShmBuffer> _bufs;
+	std::vector<Tag> _tags;
+	BarComponent _layoutCmp, _titleCmp, _statusCmp;
+	bool _selected;
+	bool _invalid {false};
+
+	// only vaild during render()
+	cairo_t* _painter {nullptr};
+	int _x;
+	ColorScheme _colorScheme;
+
+	void layerSurfaceConfigure(uint32_t serial, uint32_t width, uint32_t height);
+	void render();
+	void renderTags();
+	void renderStatus();
+
+	// low-level rendering
+	void setColorScheme(const ColorScheme& scheme, bool invert = false);
+	void beginFg();
+	void beginBg();
+	void renderComponent(BarComponent& component);
+	BarComponent createComponent(const std::string& initial = {});
+public:
+	Bar();
+	const wl_surface* surface() const;
+	bool visible() const;
+	void show(wl_output* output);
+	void hide();
+	void setTag(int tag, int state, int numClients, int focusedClient);
+	void setSelected(bool selected);
+	void setLayout(const std::string& layout);
+	void setTitle(const std::string& title);
+	void setStatus(const std::string& status);
+	void invalidate();
+	void click(Monitor* mon, int x, int y, int btn);
+};
diff --git a/wm/somebar/src/common.hpp b/wm/somebar/src/common.hpp
new file mode 100644
index 0000000..c905358
--- /dev/null
+++ b/wm/somebar/src/common.hpp
@@ -0,0 +1,76 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include <memory>
+#include <string>
+#include <vector>
+#include <wayland-client.h>
+#include <linux/input-event-codes.h>
+#include <cairo/cairo.h>
+#include <pango/pango.h>
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+
+struct Color {
+	Color() {}
+	constexpr Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a=255) : r(r), g(g), b(b), a(a) { }
+	uint8_t r, g, b, a {255};
+};
+struct ColorScheme {
+	Color fg, bg;
+};
+union Arg {
+	unsigned int ui;
+	const void* v;
+};
+struct Monitor;
+
+enum TagState { None, Active = 0x01, Urgent = 0x02 };
+enum Control { ClkNone, ClkTagBar, ClkLayoutSymbol, ClkWinTitle, ClkStatusText };
+struct Button {
+	int control;
+	int btn; // <linux/input-event-codes.h>
+	void (*func)(Monitor& mon, const Arg& arg);
+	const Arg arg;
+};
+
+extern wl_display* display;
+extern wl_compositor* compositor;
+extern wl_shm* shm;
+extern zwlr_layer_shell_v1* wlrLayerShell;
+
+void spawn(Monitor&, const Arg& arg);
+void setCloexec(int fd);
+[[noreturn]] void die(const char* why);
+[[noreturn]] void diesys(const char* why);
+
+// wayland smart pointers
+template<typename T>
+struct WlDeleter;
+#define WL_DELETER(type, fn) template<> struct WlDeleter<type> { \
+	void operator()(type* v) { if(v) fn(v); } \
+	}
+
+template<typename T>
+using wl_unique_ptr = std::unique_ptr<T, WlDeleter<T>>;
+
+inline void wl_output_release_checked(wl_output* output) {
+	if (wl_output_get_version(output) >= WL_OUTPUT_RELEASE_SINCE_VERSION) {
+		wl_output_release(output);
+	}
+}
+
+WL_DELETER(wl_buffer, wl_buffer_destroy);
+WL_DELETER(wl_output, wl_output_release_checked);
+WL_DELETER(wl_pointer, wl_pointer_release);
+WL_DELETER(wl_seat, wl_seat_release);
+WL_DELETER(wl_surface, wl_surface_destroy);
+WL_DELETER(zwlr_layer_surface_v1, zwlr_layer_surface_v1_destroy);
+
+WL_DELETER(cairo_t, cairo_destroy);
+WL_DELETER(cairo_surface_t, cairo_surface_destroy);
+
+WL_DELETER(PangoContext, g_object_unref);
+WL_DELETER(PangoLayout, g_object_unref);
+
+#undef WL_DELETER
diff --git a/wm/somebar/src/config.def.hpp b/wm/somebar/src/config.def.hpp
new file mode 100644
index 0000000..40a8c95
--- /dev/null
+++ b/wm/somebar/src/config.def.hpp
@@ -0,0 +1,27 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include "common.hpp"
+
+constexpr bool topbar = true;
+
+constexpr int paddingX = 10;
+constexpr int paddingY = 3;
+
+// See https://docs.gtk.org/Pango/type_func.FontDescription.from_string.html
+constexpr const char* font = "Sans 12";
+
+constexpr ColorScheme colorInactive = {Color(0xbb, 0xbb, 0xbb), Color(0x22, 0x22, 0x22)};
+constexpr ColorScheme colorActive = {Color(0xee, 0xee, 0xee), Color(0x00, 0x55, 0x77)};
+constexpr const char* termcmd[] = {"foot", nullptr};
+
+static std::vector<std::string> tagNames = {
+	"1", "2", "3",
+	"4", "5", "6",
+	"7", "8", "9",
+};
+
+constexpr Button buttons[] = {
+	{ ClkStatusText,   BTN_RIGHT,  spawn,      {.v = termcmd} },
+};
diff --git a/wm/somebar/src/config.hpp b/wm/somebar/src/config.hpp
new file mode 100644
index 0000000..9a3df80
--- /dev/null
+++ b/wm/somebar/src/config.hpp
@@ -0,0 +1,27 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include "common.hpp"
+
+constexpr bool topbar = true;
+
+constexpr int paddingX = 10;
+constexpr int paddingY = 3;
+
+// See https://docs.gtk.org/Pango/type_func.FontDescription.from_string.html
+constexpr const char* font = "Source Code Pro 9";
+
+constexpr ColorScheme colorInactive = {Color(0xbb, 0xbb, 0xbb), Color(0x22, 0x22, 0x22)};
+constexpr ColorScheme colorActive = {Color(0xee, 0xee, 0xee), Color(0x00, 0x55, 0x77)};
+constexpr const char* termcmd[] = {"foot", nullptr};
+
+static std::vector<std::string> tagNames = {
+	"1", "2", "3",
+	"4", "5", "6",
+	"7", "8", "9",
+};
+
+constexpr Button buttons[] = {
+	{ ClkStatusText,   BTN_RIGHT,  spawn,      {.v = termcmd} },
+};
diff --git a/wm/somebar/src/line_buffer.hpp b/wm/somebar/src/line_buffer.hpp
new file mode 100644
index 0000000..a5497bf
--- /dev/null
+++ b/wm/somebar/src/line_buffer.hpp
@@ -0,0 +1,71 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include <array>
+#include <algorithm>
+#include <sys/types.h>
+
+// reads data from Reader, and passes complete lines to Consumer.
+template<size_t BufSize>
+class LineBuffer {
+	using Iterator = typename std::array<char, BufSize>::iterator;
+	std::array<char, BufSize> _buffer;
+	Iterator _bufferedTo;
+	Iterator _consumedTo;
+	bool _discardLine {false};
+public:
+	LineBuffer()
+		: _bufferedTo {_buffer.begin()}
+		, _consumedTo {_buffer.begin()}
+	{
+	}
+
+	template<typename Reader, typename Consumer>
+	ssize_t readLines(const Reader& reader, const Consumer& consumer)
+	{
+		while (true) {
+			auto bytesRead = reader(_bufferedTo, _buffer.end() - _bufferedTo);
+			if (bytesRead <= 0) {
+				return bytesRead;
+			}
+			_bufferedTo += bytesRead;
+			dispatchLines(consumer);
+			resetBuffer();
+		}
+	}
+private:
+	template<typename Consumer>
+	void dispatchLines(const Consumer& consumer)
+	{
+		while (true) {
+			auto separator = std::find(_consumedTo, _bufferedTo, '\n');
+			if (separator == _bufferedTo) {
+				break;
+			}
+			size_t lineLength = separator - _consumedTo;
+			if (!_discardLine) {
+				consumer(_consumedTo, lineLength);
+			}
+			_consumedTo = separator + 1;
+			_discardLine = false;
+		}
+	}
+
+	void resetBuffer()
+	{
+		size_t bytesRemaining = _bufferedTo - _consumedTo;
+		if (bytesRemaining == _buffer.size()) {
+			// line too long
+			_discardLine = true;
+			_consumedTo = _buffer.begin();
+			_bufferedTo = _buffer.begin();
+		} else {
+			// move the last partial message to the front of the buffer, so a full-sized
+			// message will fit
+			std::copy(_consumedTo, _bufferedTo, _buffer.begin());
+			_consumedTo = _buffer.begin();
+			_bufferedTo = _consumedTo + bytesRemaining;
+		}
+	}
+};
diff --git a/wm/somebar/src/main.cpp b/wm/somebar/src/main.cpp
new file mode 100644
index 0000000..6274959
--- /dev/null
+++ b/wm/somebar/src/main.cpp
@@ -0,0 +1,613 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#include <algorithm>
+#include <cstdio>
+#include <sstream>
+#include <list>
+#include <optional>
+#include <utility>
+#include <vector>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <linux/input-event-codes.h>
+#include <wayland-client.h>
+#include <wayland-cursor.h>
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+#include "xdg-shell-client-protocol.h"
+#include "common.hpp"
+#include "config.hpp"
+#include "bar.hpp"
+#include "line_buffer.hpp"
+
+struct Monitor {
+	uint32_t registryName;
+	std::string xdgName;
+	wl_unique_ptr<wl_output> wlOutput;
+	Bar bar;
+	bool desiredVisibility {true};
+	bool hasData;
+	uint32_t tags;
+};
+
+struct SeatPointer {
+	wl_unique_ptr<wl_pointer> wlPointer;
+	Monitor* focusedMonitor;
+	int x, y;
+	std::vector<int> btns;
+};
+struct Seat {
+	uint32_t name;
+	wl_unique_ptr<wl_seat> wlSeat;
+	std::optional<SeatPointer> pointer;
+};
+
+static Monitor* monitorFromSurface(const wl_surface* surface);
+static void setupMonitor(uint32_t name, wl_output* output);
+static void updatemon(Monitor &mon);
+static void onReady();
+static void setupStatusFifo();
+static void onStatus();
+static void onStdin();
+static void handleStdin(const std::string& line);
+static void updateVisibility(const std::string& name, bool(*updater)(bool));
+static void onGlobalAdd(void*, wl_registry* registry, uint32_t name, const char* interface, uint32_t version);
+static void onGlobalRemove(void*, wl_registry* registry, uint32_t name);
+static void requireGlobal(const void* p, const char* name);
+static void waylandFlush();
+static void cleanup();
+
+wl_display* display;
+wl_compositor* compositor;
+wl_shm* shm;
+zwlr_layer_shell_v1* wlrLayerShell;
+static xdg_wm_base* xdgWmBase;
+static zxdg_output_manager_v1* xdgOutputManager;
+static wl_surface* cursorSurface;
+static wl_cursor_image* cursorImage;
+static bool ready;
+static std::list<Monitor> monitors;
+static std::vector<std::pair<uint32_t, wl_output*>> uninitializedOutputs;
+static std::list<Seat> seats;
+static Monitor* selmon;
+static std::string lastStatus;
+static std::string statusFifoName;
+static std::vector<pollfd> pollfds;
+static std::array<int, 2> signalSelfPipe;
+static int displayFd {-1};
+static int statusFifoFd {-1};
+static int statusFifoWriter {-1};
+static bool quitting {false};
+
+void spawn(Monitor&, const Arg& arg)
+{
+	if (fork() == 0) {
+		auto argv = static_cast<char* const*>(arg.v);
+		setsid();
+		execvp(argv[0], argv);
+		fprintf(stderr, "somebar: execvp %s ", argv[0]);
+		perror(" failed");
+		exit(1);
+	}
+}
+
+static const struct xdg_wm_base_listener xdgWmBaseListener = {
+	[](void*, xdg_wm_base* sender, uint32_t serial) {
+		xdg_wm_base_pong(sender, serial);
+	}
+};
+
+static const struct zxdg_output_v1_listener xdgOutputListener = {
+	.logical_position = [](void*, zxdg_output_v1*, int, int) { },
+	.logical_size = [](void*, zxdg_output_v1*, int, int) { },
+	.done = [](void*, zxdg_output_v1*) { },
+	.name = [](void* mp, zxdg_output_v1* xdgOutput, const char* name) {
+		auto& monitor = *static_cast<Monitor*>(mp);
+		monitor.xdgName = name;
+		zxdg_output_v1_destroy(xdgOutput);
+	},
+	.description = [](void*, zxdg_output_v1*, const char*) { },
+};
+
+Monitor* monitorFromSurface(const wl_surface* surface)
+{
+	auto mon = std::find_if(begin(monitors), end(monitors), [surface](const Monitor& mon) {
+		return mon.bar.surface() == surface;
+	});
+	return mon != end(monitors) ? &*mon : nullptr;
+}
+static const struct wl_pointer_listener pointerListener = {
+	.enter = [](void* sp, wl_pointer* pointer, uint32_t serial,
+	wl_surface* surface, wl_fixed_t x, wl_fixed_t y)
+	{
+		auto& seat = *static_cast<Seat*>(sp);
+		seat.pointer->focusedMonitor = monitorFromSurface(surface);
+		if (!cursorImage) {
+			auto cursorTheme = wl_cursor_theme_load(nullptr, 24, shm);
+			cursorImage = wl_cursor_theme_get_cursor(cursorTheme, "left_ptr")->images[0];
+			cursorSurface = wl_compositor_create_surface(compositor);
+			wl_surface_attach(cursorSurface, wl_cursor_image_get_buffer(cursorImage), 0, 0);
+			wl_surface_commit(cursorSurface);
+		}
+		wl_pointer_set_cursor(pointer, serial, cursorSurface,
+			cursorImage->hotspot_x, cursorImage->hotspot_y);
+	},
+	.leave = [](void* sp, wl_pointer*, uint32_t serial, wl_surface*) {
+		auto& seat = *static_cast<Seat*>(sp);
+		seat.pointer->focusedMonitor = nullptr;
+	},
+	.motion = [](void* sp, wl_pointer*, uint32_t, wl_fixed_t x, wl_fixed_t y) {
+		auto& seat = *static_cast<Seat*>(sp);
+		seat.pointer->x = wl_fixed_to_int(x);
+		seat.pointer->y = wl_fixed_to_int(y);
+	},
+	.button = [](void* sp, wl_pointer*, uint32_t, uint32_t, uint32_t button, uint32_t pressed) {
+		auto& seat = *static_cast<Seat*>(sp);
+		auto it = std::find(begin(seat.pointer->btns), end(seat.pointer->btns), button);
+		if (pressed == WL_POINTER_BUTTON_STATE_PRESSED && it == end(seat.pointer->btns)) {
+			seat.pointer->btns.push_back(button);
+		} else if (pressed == WL_POINTER_BUTTON_STATE_RELEASED && it != end(seat.pointer->btns)) {
+			seat.pointer->btns.erase(it);
+		}
+	},
+	.axis = [](void* sp, wl_pointer*, uint32_t, uint32_t, wl_fixed_t) { },
+	.frame = [](void* sp, wl_pointer*) {
+		auto& seat = *static_cast<Seat*>(sp);
+		auto mon = seat.pointer->focusedMonitor;
+		if (!mon) {
+			return;
+		}
+		for (auto btn : seat.pointer->btns) {
+			mon->bar.click(mon, seat.pointer->x, seat.pointer->y, btn);
+		}
+		seat.pointer->btns.clear();
+	},
+	.axis_source = [](void*, wl_pointer*, uint32_t) { },
+	.axis_stop = [](void*, wl_pointer*, uint32_t, uint32_t) { },
+	.axis_discrete = [](void*, wl_pointer*, uint32_t, int32_t) { },
+};
+
+static const struct wl_seat_listener seatListener = {
+	.capabilities = [](void* sp, wl_seat*, uint32_t cap)
+	{
+		auto& seat = *static_cast<Seat*>(sp);
+		auto hasPointer = cap & WL_SEAT_CAPABILITY_POINTER;
+		if (!seat.pointer && hasPointer) {
+			auto &pointer = seat.pointer.emplace();
+			pointer.wlPointer = wl_unique_ptr<wl_pointer> {wl_seat_get_pointer(seat.wlSeat.get())};
+			wl_pointer_add_listener(seat.pointer->wlPointer.get(), &pointerListener, &seat);
+		} else if (seat.pointer && !hasPointer) {
+			seat.pointer.reset();
+		}
+	},
+	.name = [](void*, wl_seat*, const char* name) { }
+};
+
+void setupMonitor(uint32_t name, wl_output* output) {
+	auto& monitor = monitors.emplace_back(Monitor {name, {}, wl_unique_ptr<wl_output> {output}});
+	monitor.bar.setStatus(lastStatus);
+	auto xdgOutput = zxdg_output_manager_v1_get_xdg_output(xdgOutputManager, monitor.wlOutput.get());
+	zxdg_output_v1_add_listener(xdgOutput, &xdgOutputListener, &monitor);
+}
+
+void updatemon(Monitor& mon)
+{
+	if (!mon.hasData) {
+		return;
+	}
+	if (mon.desiredVisibility) {
+		if (mon.bar.visible()) {
+			mon.bar.invalidate();
+		} else {
+			mon.bar.show(mon.wlOutput.get());
+		}
+	} else if (mon.bar.visible()) {
+		mon.bar.hide();
+	}
+}
+
+// called after we have received the initial batch of globals
+void onReady()
+{
+	requireGlobal(compositor, "wl_compositor");
+	requireGlobal(shm, "wl_shm");
+	requireGlobal(wlrLayerShell, "zwlr_layer_shell_v1");
+	requireGlobal(xdgOutputManager, "zxdg_output_manager_v1");
+	setupStatusFifo();
+	wl_display_roundtrip(display); // roundtrip so we receive all dwl tags etc.
+
+	ready = true;
+	for (auto output : uninitializedOutputs) {
+		setupMonitor(output.first, output.second);
+	}
+	wl_display_roundtrip(display); // wait for xdg_output names before we read stdin
+}
+
+bool createFifo(std::string path)
+{
+	auto result = mkfifo(path.c_str(), 0666);
+	if (result == 0) {
+		auto fd = open(path.c_str(), O_CLOEXEC | O_NONBLOCK | O_RDONLY);
+		if (fd < 0) {
+			diesys("open status fifo reader");
+		}
+		statusFifoName = path;
+		statusFifoFd = fd;
+
+		fd = open(path.c_str(), O_CLOEXEC | O_WRONLY);
+		if (fd < 0) {
+			diesys("open status fifo writer");
+		}
+		statusFifoWriter = fd;
+
+		pollfds.push_back({
+			.fd = statusFifoFd,
+			.events = POLLIN,
+		});
+		return true;
+	} else if (errno != EEXIST) {
+		diesys("mkfifo");
+	}
+
+	return false;
+}
+
+void setupStatusFifo()
+{
+	if (!statusFifoName.empty()) {
+		createFifo(statusFifoName);
+		return;
+	}
+
+	for (auto i=0; i<100; i++) {
+		auto path = std::string{getenv("XDG_RUNTIME_DIR")} + "/somebar-" + std::to_string(i);
+		if (createFifo(path)) {
+			return;
+		}
+	}
+}
+
+static LineBuffer<512> stdinBuffer;
+static void onStdin()
+{
+	auto res = stdinBuffer.readLines(
+		[](void* p, size_t size) { return read(0, p, size); },
+		[](char* p, size_t size) { handleStdin({p, size}); });
+	if (res == 0) {
+		quitting = true;
+	}
+}
+
+static void handleStdin(const std::string& line)
+{
+	// this parses the lines that dwl sends in printstatus()
+	std::string monName, command;
+	auto stream = std::istringstream {line};
+	stream >> monName >> command;
+	if (!stream.good()) {
+		return;
+	}
+	auto mon = std::find_if(begin(monitors), end(monitors), [&](const Monitor& mon) {
+		return mon.xdgName == monName;
+	});
+	if (mon == end(monitors))
+		return;
+	if (command == "title") {
+		auto title = std::string {};
+		stream >> std::ws;
+		std::getline(stream, title);
+		mon->bar.setTitle(title);
+	} else if (command == "selmon") {
+		uint32_t selected;
+		stream >> selected;
+		mon->bar.setSelected(selected);
+		if (selected) {
+			selmon = &*mon;
+		} else if (selmon == &*mon) {
+			selmon = nullptr;
+		}
+	} else if (command == "tags") {
+		uint32_t occupied, tags, clientTags, urgent;
+		stream >> occupied >> tags >> clientTags >> urgent;
+		for (auto i=0u; i<tagNames.size(); i++) {
+			auto tagMask = 1 << i;
+			int state = TagState::None;
+			if (tags & tagMask)
+				state |= TagState::Active;
+			if (urgent & tagMask)
+				state |= TagState::Urgent;
+			mon->bar.setTag(i, state, occupied & tagMask ? 1 : 0, clientTags & tagMask ? 0 : -1);
+		}
+		mon->tags = tags;
+	} else if (command == "layout") {
+		auto layout = std::string {};
+		stream >> std::ws;
+		std::getline(stream, layout);
+		mon->bar.setLayout(layout);
+	}
+	mon->hasData = true;
+	updatemon(*mon);
+}
+
+const std::string prefixStatus = "status ";
+const std::string prefixShow = "show ";
+const std::string prefixHide = "hide ";
+const std::string prefixToggle = "toggle ";
+const std::string argAll = "all";
+const std::string argSelected = "selected";
+
+static LineBuffer<512> statusBuffer;
+void onStatus()
+{
+	statusBuffer.readLines(
+	[](void* p, size_t size) {
+		return read(statusFifoFd, p, size);
+	},
+	[](const char* buffer, size_t n) {
+		auto str = std::string {buffer, n};
+		if (str.rfind(prefixStatus, 0) == 0) {
+			lastStatus = str.substr(prefixStatus.size());
+			for (auto &monitor : monitors) {
+				monitor.bar.setStatus(lastStatus);
+				monitor.bar.invalidate();
+			}
+		} else if (str.rfind(prefixShow, 0) == 0) {
+			updateVisibility(str.substr(prefixShow.size()), [](bool) { return true; });
+		} else if (str.rfind(prefixHide, 0) == 0) {
+			updateVisibility(str.substr(prefixHide.size()), [](bool) { return false; });
+		} else if (str.rfind(prefixToggle, 0) == 0) {
+			updateVisibility(str.substr(prefixToggle.size()), [](bool vis) { return !vis; });
+		}
+	});
+}
+
+void updateVisibility(const std::string& name, bool(*updater)(bool))
+{
+	auto isCurrent = name == argSelected;
+	auto isAll = name == argAll;
+	for (auto& mon : monitors) {
+		if (isAll ||
+			isCurrent && &mon == selmon ||
+			mon.xdgName == name) {
+			auto newVisibility = updater(mon.desiredVisibility);
+			if (newVisibility != mon.desiredVisibility) {
+				mon.desiredVisibility = newVisibility;
+				updatemon(mon);
+			}
+		}
+	}
+}
+
+struct HandleGlobalHelper {
+	wl_registry* registry;
+	uint32_t name;
+	const char* interface;
+
+	template<typename T>
+	bool handle(T& store, const wl_interface& iface, int version) {
+		if (strcmp(interface, iface.name)) {
+			return false;
+		}
+		store = static_cast<T>(wl_registry_bind(registry, name, &iface, version));
+		return true;
+	}
+};
+void onGlobalAdd(void*, wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
+{
+	auto reg = HandleGlobalHelper { registry, name, interface };
+	if (reg.handle(compositor, wl_compositor_interface, 4)) return;
+	if (reg.handle(shm, wl_shm_interface, 1)) return;
+	if (reg.handle(wlrLayerShell, zwlr_layer_shell_v1_interface, 4)) return;
+	if (reg.handle(xdgOutputManager, zxdg_output_manager_v1_interface, 3)) return;
+	if (reg.handle(xdgWmBase, xdg_wm_base_interface, 2)) {
+		xdg_wm_base_add_listener(xdgWmBase, &xdgWmBaseListener, nullptr);
+		return;
+	}
+	if (wl_seat* wlSeat; reg.handle(wlSeat, wl_seat_interface, 7)) {
+		auto& seat = seats.emplace_back(Seat {name, wl_unique_ptr<wl_seat> {wlSeat}});
+		wl_seat_add_listener(wlSeat, &seatListener, &seat);
+		return;
+	}
+	if (wl_output* output; reg.handle(output, wl_output_interface, 1)) {
+		if (ready) {
+			setupMonitor(name, output);
+		} else {
+			uninitializedOutputs.push_back({name, output});
+		}
+		return;
+	}
+}
+void onGlobalRemove(void*, wl_registry* registry, uint32_t name)
+{
+	monitors.remove_if([name](const Monitor &mon) { return mon.registryName == name; });
+	seats.remove_if([name](const Seat &seat) { return seat.name == name; });
+}
+static const struct wl_registry_listener registry_listener = {
+	.global = onGlobalAdd,
+	.global_remove = onGlobalRemove,
+};
+
+int main(int argc, char* argv[])
+{
+	int opt;
+	while ((opt = getopt(argc, argv, "chvs:")) != -1) {
+		switch (opt) {
+			case 's':
+				statusFifoName = optarg;
+				break;
+			case 'h':
+				printf("Usage: %s [-h] [-v] [-s path to the fifo] [-c command]\n", argv[0]);
+				printf("  -h: Show this help\n");
+				printf("  -v: Show somebar version\n");
+				printf("  -s: Change path to the fifo (default is \"$XDG_RUNTIME_DIR/somebar-0\")\n");
+				printf("  -c: Sends a command to sombar. See README for details.\n");
+				printf("If any of these are specified (except -s), somebar exits after the action.\n");
+				printf("Otherwise, somebar will display itself.\n");
+				exit(0);
+			case 'v':
+				printf("somebar " SOMEBAR_VERSION "\n");
+				exit(0);
+			case 'c':
+				if (optind >= argc) {
+					die("Expected command");
+				}
+				if (statusFifoName.empty()) {
+					statusFifoName = std::string {getenv("XDG_RUNTIME_DIR")} + "/somebar-0";
+				}
+				statusFifoWriter = open(statusFifoName.c_str(), O_WRONLY | O_CLOEXEC);
+				if (statusFifoWriter < 0) {
+					fprintf(stderr, "could not open %s: ", statusFifoName.c_str());
+					perror("");
+					exit(1);
+				}
+				auto str = std::string {};
+				for (auto i = optind; i<argc; i++) {
+					if (i > optind) str += " ";
+					str += argv[i];
+				}
+				str += "\n";
+				write(statusFifoWriter, str.c_str(), str.size());
+				exit(0);
+		}
+	}
+	
+	if (pipe(signalSelfPipe.data()) < 0) {
+		diesys("pipe");
+	}
+	setCloexec(signalSelfPipe[0]);
+	setCloexec(signalSelfPipe[1]);
+
+	struct sigaction sighandler = {};
+	sighandler.sa_handler = [](int) {
+		if (write(signalSelfPipe[1], "0", 1) < 0) {
+			diesys("write");
+		}
+	};
+	if (sigaction(SIGTERM, &sighandler, nullptr) < 0) {
+		diesys("sigaction");
+	}
+	if (sigaction(SIGINT, &sighandler, nullptr) < 0) {
+		diesys("sigaction");
+	}
+
+	struct sigaction chld_handler = {};
+	chld_handler.sa_handler = SIG_IGN;
+	if (sigaction(SIGCHLD, &chld_handler, nullptr) < 0) {
+		die("sigaction");
+	}
+
+	pollfds.push_back({
+		.fd = signalSelfPipe[0],
+		.events = POLLIN,
+	});
+
+	display = wl_display_connect(nullptr);
+	if (!display) {
+		die("Failed to connect to Wayland display");
+	}
+	displayFd = wl_display_get_fd(display);
+
+	auto registry = wl_display_get_registry(display);
+	wl_registry_add_listener(registry, &registry_listener, nullptr);
+	wl_display_roundtrip(display);
+	onReady();
+
+	pollfds.push_back({
+		.fd = displayFd,
+		.events = POLLIN,
+	});
+	pollfds.push_back({
+		.fd = STDIN_FILENO,
+		.events = POLLIN,
+	});
+	if (fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK) < 0) {
+		diesys("fcntl F_SETFL");
+	}
+
+	while (!quitting) {
+		waylandFlush();
+		if (poll(pollfds.data(), pollfds.size(), -1) < 0) {
+			if (errno != EINTR) {
+				diesys("poll");
+			}
+		} else {
+			for (auto& ev : pollfds) {
+				if (ev.revents & POLLNVAL) {
+					die("poll revents contains POLLNVAL");
+				} else if (ev.fd == displayFd) {
+					if (ev.revents & POLLIN) {
+						if (wl_display_dispatch(display) < 0) {
+							die("wl_display_dispatch");
+						}
+					}
+					if (ev.revents & POLLOUT) {
+						ev.events = POLLIN;
+						waylandFlush();
+					}
+				} else if (ev.fd == STDIN_FILENO && (ev.revents & POLLIN)) {
+					onStdin();
+				} else if (ev.fd == statusFifoFd && (ev.revents & POLLIN)) {
+					onStatus();
+				} else if (ev.fd == signalSelfPipe[0] && (ev.revents & POLLIN)) {
+					quitting = true;
+				}
+			}
+		}
+	}
+	cleanup();
+}
+
+void requireGlobal(const void* p, const char* name)
+{
+	if (p) return;
+	fprintf(stderr, "Wayland compositor does not export required global %s, aborting.\n", name);
+	cleanup();
+	exit(1);
+}
+
+void waylandFlush()
+{
+	wl_display_dispatch_pending(display);
+	if (wl_display_flush(display) < 0 && errno == EAGAIN) {
+		for (auto& ev : pollfds) {
+			if (ev.fd == displayFd) {
+				ev.events |= POLLOUT;
+			}
+		}
+	}
+}
+
+void setCloexec(int fd)
+{
+	int flags = fcntl(fd, F_GETFD);
+	if (flags == -1) {
+		diesys("fcntl FD_GETFD");
+	}
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
+		diesys("fcntl FD_SETFD");
+	}
+}
+
+void cleanup() {
+	if (!statusFifoName.empty()) {
+		unlink(statusFifoName.c_str());
+	}
+}
+
+void die(const char* why) {
+	fprintf(stderr, "error: %s failed, aborting\n", why);
+	cleanup();
+	exit(1);
+}
+
+void diesys(const char* why) {
+	perror(why);
+	cleanup();
+	exit(1);
+}
diff --git a/wm/somebar/src/shm_buffer.cpp b/wm/somebar/src/shm_buffer.cpp
new file mode 100644
index 0000000..59baf6f
--- /dev/null
+++ b/wm/somebar/src/shm_buffer.cpp
@@ -0,0 +1,85 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "shm_buffer.hpp"
+#include "common.hpp"
+
+static int createAnonShm();
+constexpr int n = 2;
+
+ShmBuffer::ShmBuffer(int w, int h, wl_shm_format format)
+	: width(w)
+	, height(h)
+	, stride(w*4)
+{
+	auto oneSize = stride*size_t(h);
+	auto totalSize = oneSize * n;
+	auto fd = createAnonShm();
+	if (fd < 0) {
+		diesys("memfd_create");
+	}
+	if (ftruncate(fd, totalSize) < 0) {
+		diesys("ftruncate");
+	}
+	auto pool = wl_shm_create_pool(shm, fd, totalSize);
+	auto ptr = reinterpret_cast<uint8_t*>(mmap(nullptr, totalSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+	if (!ptr) {
+		diesys("mmap");
+	}
+	_mapping = MemoryMapping {ptr, totalSize};
+	close(fd);
+	for (auto i=0; i<n; i++) {
+		auto offset = oneSize*i;
+		_buffers[i] = {
+			ptr+offset,
+			wl_unique_ptr<wl_buffer> { wl_shm_pool_create_buffer(pool, offset, width, height, stride, format) },
+		};
+	}
+	wl_shm_pool_destroy(pool);
+}
+
+uint8_t* ShmBuffer::data()
+{
+	return _buffers[_current].data;
+}
+
+wl_buffer* ShmBuffer::buffer()
+{
+	return _buffers[_current].buffer.get();
+}
+
+void ShmBuffer::flip()
+{
+	_current = 1-_current;
+}
+
+#if defined(__linux__)
+int createAnonShm() {
+	return memfd_create("wl_shm", MFD_CLOEXEC);
+}
+#elif defined(__FreeBSD__)
+int createAnonShm() {
+	auto fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0600);
+	setCloexec(fd);
+	return fd;
+}
+#elif defined(__OpenBSD__)
+int createAnonShm() {
+	char name[] = "/wl_shm-XXXXXX";
+	auto fd = shm_mkstemp(name);
+	if (fd >= 0) {
+		auto res = shm_unlink(name);
+		if (res < 0) {
+			return res;
+		}
+	}
+	setCloexec(fd);
+	return fd;
+}
+#else
+#error "your system has no sane method of creating an anonymous shared memory object. no, calling shm_open in a loop is not sane."
+#endif
diff --git a/wm/somebar/src/shm_buffer.hpp b/wm/somebar/src/shm_buffer.hpp
new file mode 100644
index 0000000..f6927dd
--- /dev/null
+++ b/wm/somebar/src/shm_buffer.hpp
@@ -0,0 +1,45 @@
+// somebar - dwl bar
+// See LICENSE file for copyright and license details.
+
+#pragma once
+#include <array>
+#include <sys/mman.h>
+#include <wayland-client.h>
+#include "common.hpp"
+
+class MemoryMapping {
+	void* _ptr {nullptr};
+	size_t _size {0};
+public:
+	MemoryMapping() { }
+	explicit MemoryMapping(void* ptr, size_t size) : _ptr(ptr), _size(size) { }
+	MemoryMapping(const MemoryMapping&) = delete;
+	MemoryMapping(MemoryMapping&& other) { swap(other); }
+	MemoryMapping& operator=(const MemoryMapping& other) = delete;
+	MemoryMapping& operator=(MemoryMapping&& other) { swap(other); return *this; }
+	~MemoryMapping() { if (_ptr) munmap(_ptr, _size); }
+	void swap(MemoryMapping &other) {
+		using std::swap;
+		swap(_ptr, other._ptr);
+		swap(_size, other._size);
+	}
+};
+
+// double buffered shm
+// format is must be 32-bit
+class ShmBuffer {
+	struct Buf {
+		uint8_t* data {nullptr};
+		wl_unique_ptr<wl_buffer> buffer;
+	};
+	std::array<Buf, 2> _buffers;
+	int _current {0};
+	MemoryMapping _mapping;
+public:
+	const uint32_t width, height, stride;
+
+	explicit ShmBuffer(int width, int height, wl_shm_format format);
+	uint8_t* data();
+	wl_buffer* buffer();
+	void flip();
+};
diff --git a/wm/someblocks/CHANGELOG.md b/wm/someblocks/CHANGELOG.md
new file mode 100644
index 0000000..e4bfdde
--- /dev/null
+++ b/wm/someblocks/CHANGELOG.md
@@ -0,0 +1,6 @@
+## [1.0.1] - 2022-12-11
+### Fixed
+- Fixed crashes due to bad signal handling
+
+## [1.0.0] - 2022-04-20
+Initial release
diff --git a/wm/someblocks/LICENSE b/wm/someblocks/LICENSE
new file mode 100644
index 0000000..603a997
--- /dev/null
+++ b/wm/someblocks/LICENSE
@@ -0,0 +1,8 @@
+ISC License (ISC)
+
+Copyright 2020 torrinfail
+Copyright 2021 Raphael Robatsch
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 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.
diff --git a/wm/someblocks/Makefile b/wm/someblocks/Makefile
new file mode 100644
index 0000000..f0c027b
--- /dev/null
+++ b/wm/someblocks/Makefile
@@ -0,0 +1,20 @@
+PREFIX ?= /usr/local
+MANPREFIX ?= $(PREFIX)/share/man
+CC ?= cc
+
+output: someblocks.c blocks.def.h blocks.h
+	${CC}  someblocks.c $(LDFLAGS) -o someblocks
+blocks.h:
+	cp blocks.def.h $@
+
+
+clean:
+	rm -f *.o *.gch someblocks
+install: output
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	install -m 0755 someblocks $(DESTDIR)$(PREFIX)/bin/someblocks
+	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
+	install -m 0644 someblocks.1 $(DESTDIR)$(MANPREFIX)/man1/someblocks.1
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/bin/someblocks
+	rm -f $(DESTDIR)$(MANPREFIX)/man1/someblocks.1
diff --git a/wm/someblocks/README.md b/wm/someblocks/README.md
new file mode 100644
index 0000000..f96c944
--- /dev/null
+++ b/wm/someblocks/README.md
@@ -0,0 +1,19 @@
+# someblocks
+Modular status bar for [somebar](https://git.sr.ht/~raphi/somebar) written in c.
+
+This is a fork of [dwmblocks](https://github.com/torrinfail/dwmblocks), modified
+to connect to somebar instead of dwm.
+
+The mailing list for this project is
+[~raphi/public-inbox@lists.sr.ht](mailto:~raphi/public-inbox@lists.sr.ht).
+# usage
+To use someblocks first run 'make' and then install it with 'sudo make install'.
+After that you can put someblocks in your startup script to have it start with dwl/somebar.
+# modifying blocks
+The statusbar is made from text output from commandline programs.
+Blocks are added and removed by editing the blocks.h header file.
+By default the blocks.h header file is created the first time you run make which copies the default config from blocks.def.h.
+This is so you can edit your status bar commands and they will not get overwritten in a future update.
+# patches
+Here are some patches to someblocks that add features that I either don't want to merge in, or that require a dwl/somebar patch to work.
+I do not maintain these but I will take pull requests to update them.
diff --git a/wm/someblocks/blocks.def.h b/wm/someblocks/blocks.def.h
new file mode 100644
index 0000000..9c22d68
--- /dev/null
+++ b/wm/someblocks/blocks.def.h
@@ -0,0 +1,11 @@
+//Modify this file to change what commands output to your statusbar, and recompile using the make command.
+static const Block blocks[] = {
+	/*Icon*/	/*Command*/		/*Update Interval*/	/*Update Signal*/
+	{"Mem:", "free -h | awk '/^Mem/ { print $3\"/\"$2 }' | sed s/i//g",	30,		0},
+
+	{"", "date '+%b %d (%a) %I:%M%p'",					5,		0},
+};
+
+//sets delimeter between status commands. NULL character ('\0') means no delimeter.
+static char delim[] = " | ";
+static unsigned int delimLen = 5;
diff --git a/wm/someblocks/blocks.h b/wm/someblocks/blocks.h
new file mode 100644
index 0000000..2b7566c
--- /dev/null
+++ b/wm/someblocks/blocks.h
@@ -0,0 +1,15 @@
+//Modify this file to change what commands output to your statusbar, and recompile using the make command.
+static const Block blocks[] = {
+
+	/*Icon*/	/*Command*/		/*Update Interval*/	/*Update Signal*/
+	{"",		"dwmblocks-mpc",					2,		2},
+	{"",		"dwmblocks-du",						60,		0},
+	{"",		"dwmblocks-volume",					0,		10},
+	{"",		"dwmblocks-battery",					1,		0},
+	{"🕗 ", "date '+%k:%M'",						1,		0},
+	{"📅 ", "date '+%A, %B %d %G'",					1,		0},
+};
+
+//sets delimeter between status commands. NULL character ('\0') means no delimeter.
+static char delim[] = " | ";
+static unsigned int delimLen = 5;
diff --git a/wm/someblocks/dwmblocks-battery b/wm/someblocks/dwmblocks-battery
new file mode 100755
index 0000000..66f1d1f
--- /dev/null
+++ b/wm/someblocks/dwmblocks-battery
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+BAT_FILE=/sys/class/power_supply/BAT0
+
+for battery in $BAT_FILE; do
+	# If non-first battery, print a space separator.
+	[ -n "${capacity+x}" ] && printf " "
+	# Sets up the status and capacity
+	case "$(cat "$battery/status" 2>&1)" in
+		"Full") status="🔋" ;;
+		"Discharging") status="🔋-" ;;
+		"Charging") status="🔋+" ;;
+		"Not charging") status="🛑" ;;
+		*) exit 1 ;;
+	esac
+	capacity="$(cat "$battery/capacity" 2>&1)"
+	# Will make a warn variable if discharging and low
+	[ "$status" = "🔋" ] && [ "$capacity" -le 25 ] && warn="❗"
+	# Prints the info
+	printf "%s%s%d%%" "$status " "$warn" " $capacity"; unset warn
+done && printf "\\n"
diff --git a/wm/someblocks/dwmblocks-brightness b/wm/someblocks/dwmblocks-brightness
new file mode 100755
index 0000000..420518d
--- /dev/null
+++ b/wm/someblocks/dwmblocks-brightness
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+CMD=$(light | sed 's/...$//')
+ICON=💡
+
+echo "$ICON $CMD%"
diff --git a/wm/someblocks/dwmblocks-du b/wm/someblocks/dwmblocks-du
new file mode 100755
index 0000000..ed5f791
--- /dev/null
+++ b/wm/someblocks/dwmblocks-du
@@ -0,0 +1,5 @@
+#!/bin/sh
+icon='💾'
+cmd=$(df -h --output='pcent' /home | sed 1g | tr -d '\n ')
+
+echo $icon $cmd
diff --git a/wm/someblocks/dwmblocks-forecast b/wm/someblocks/dwmblocks-forecast
new file mode 100755
index 0000000..3c2482e
--- /dev/null
+++ b/wm/someblocks/dwmblocks-forecast
@@ -0,0 +1,18 @@
+#!/bin/sh
+
+weatherreport="$HOME/.cache/dwmblocks_forecast"
+getforecast() { curl -sf "wttr.in/" > "$weatherreport" || exit 1 ;}
+
+# Some very particular and terse stream manipulation. We get the maximum
+# precipitation chance and the daily high and low from the downloaded file and
+# display them with coresponding emojis.
+showweather() { printf "%s" "$(sed '16q;d' "$weatherreport" |
+	grep -wo "[0-9]*%" | sort -rn | sed "s/^/☔ /g;1q" | tr -d '\n')"
+sed '13q;d' "$weatherreport" | grep -o "m\\([-+]\\)*[0-9]\\+" | sed 's/+//g' | sort -n -t 'm' -k 2n | sed -e 1b -e '$!d' | tr '\n|m' ' ' | awk '{print "  🥶 " $1 "°","🌞 " $2 "°"}' ;}
+
+# The test if our forcecast is updated to the day. If it isn't download a new
+# weather report from wttr.in with the above function.
+[ "$(stat -c %y "$weatherreport" 2>/dev/null | cut -d' ' -f1)" = "$(date '+%Y-%m-%d')" ] ||
+	getforecast
+
+showweather
diff --git a/wm/someblocks/dwmblocks-mpc b/wm/someblocks/dwmblocks-mpc
new file mode 100755
index 0000000..c468ec8
--- /dev/null
+++ b/wm/someblocks/dwmblocks-mpc
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+SONG=$(mpc --format "%title% - %artist%" | mpc --format "%title% - %artist%" | sed "/^volume:/d;s/\\&/&amp;/g;s/\\[paused\\].*/⏸/g;/\\[playing\\].*/d;/^ERROR/Q" | sed 1q;)
+ICON="🎵"
+
+echo "$ICON $SONG"
diff --git a/wm/someblocks/dwmblocks-volume b/wm/someblocks/dwmblocks-volume
new file mode 100755
index 0000000..048fa04
--- /dev/null
+++ b/wm/someblocks/dwmblocks-volume
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+case $BLOCK_BUTTON in
+	4) pamixer --allow-boost -i 1;;
+	5) pamixer --allow-boost -d 1;;
+esac
+ICON="🔉"
+VOL=$(pamixer --get-volume)
+
+if [ $(pamixer --get-mute) = 'true' ]; then
+	ICON="🔇"
+fi
+echo "$ICON $VOL%"
diff --git a/wm/someblocks/someblocks b/wm/someblocks/someblocks
new file mode 100755
index 0000000..d3fed0f
--- /dev/null
+++ b/wm/someblocks/someblocks
diff --git a/wm/someblocks/someblocks.1 b/wm/someblocks/someblocks.1
new file mode 100644
index 0000000..4b5cf6e
--- /dev/null
+++ b/wm/someblocks/someblocks.1
@@ -0,0 +1,22 @@
+.TH someblocks 1 someblocks\-1.0
+.SH NAME
+someblocks \- Modular status bar for somebar
+.SH SYNOPSIS
+.B someblocks
+.RB [ \-d
+.IR delimiter ]
+.RB [ \-s
+.IR path ]
+.RB [ \-p ]
+.SH DESCRIPTION
+Modular status bar for somebar written in c.
+.SH OPTIONS
+.TP
+.B \-d
+Sets the delimiter between blocks
+.TP
+.B \-s
+Sets the path to the somebar control FIFO. The default value is
+$XDG_RUNTIME_DIR/somebar-0
+.SH BUGS
+Send bug reports to ~raphi/public-inbox@lists.sr.ht
diff --git a/wm/someblocks/someblocks.c b/wm/someblocks/someblocks.c
new file mode 100644
index 0000000..f149896
--- /dev/null
+++ b/wm/someblocks/someblocks.c
@@ -0,0 +1,215 @@
+#define _POSIX_C_SOURCE 200809L
+#include<stdlib.h>
+#include<stdio.h>
+#include<string.h>
+#include<unistd.h>
+#include<fcntl.h>
+#include<errno.h>
+#include<signal.h>
+#ifdef __OpenBSD__
+#define SIGPLUS			SIGUSR1+1
+#define SIGMINUS		SIGUSR1-1
+#else
+#define SIGPLUS			SIGRTMIN
+#define SIGMINUS		SIGRTMIN
+#endif
+#define LENGTH(X)               (sizeof(X) / sizeof (X[0]))
+#define CMDLENGTH		50
+#define MIN( a, b ) ( ( a < b) ? a : b )
+#define STATUSLENGTH (LENGTH(blocks) * CMDLENGTH + 1)
+
+typedef struct {
+	char* icon;
+	char* command;
+	unsigned int interval;
+	unsigned int signal;
+} Block;
+#ifndef __OpenBSD__
+void dummysighandler(int num);
+#endif
+void sighandler(int num);
+void getcmds(int time);
+void getsigcmds(unsigned int signal);
+void setupsignals();
+void sighandler(int signum);
+int getstatus(char *str, char *last);
+void statusloop();
+void termhandler();
+void pstdout();
+void psomebar();
+static void (*writestatus) () = psomebar;
+
+#include "blocks.h"
+
+static char statusbar[LENGTH(blocks)][CMDLENGTH] = {0};
+static char statusstr[2][STATUSLENGTH];
+static int statusContinue = 1;
+static int returnStatus = 0;
+static char somebarPath[128];
+static int somebarFd = -1;
+
+//opens process *cmd and stores output in *output
+void getcmd(const Block *block, char *output)
+{
+	strcpy(output, block->icon);
+	FILE *cmdf = popen(block->command, "r");
+	if (!cmdf)
+		return;
+	int i = strlen(block->icon);
+	fgets(output+i, CMDLENGTH-i-delimLen, cmdf);
+	i = strlen(output);
+	if (i == 0) {
+		//return if block and command output are both empty
+		pclose(cmdf);
+		return;
+	}
+	if (delim[0] != '\0') {
+		//only chop off newline if one is present at the end
+		i = output[i-1] == '\n' ? i-1 : i;
+		strncpy(output+i, delim, delimLen); 
+	}
+	else
+		output[i++] = '\0';
+	pclose(cmdf);
+}
+
+void getcmds(int time)
+{
+	const Block* current;
+	for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+		current = blocks + i;
+		if ((current->interval != 0 && time % current->interval == 0) || time == -1)
+			getcmd(current,statusbar[i]);
+	}
+}
+
+void getsigcmds(unsigned int signal)
+{
+	const Block *current;
+	for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+		current = blocks + i;
+		if (current->signal == signal)
+			getcmd(current,statusbar[i]);
+	}
+}
+
+void setupsignals()
+{
+	struct sigaction sa = {0};
+#ifndef __OpenBSD__
+	/* initialize all real time signals with dummy handler */
+	sa.sa_handler = dummysighandler;
+	for (int i = SIGRTMIN; i <= SIGRTMAX; i++)
+		sigaction(i, &sa, NULL);
+#endif
+
+	sa.sa_handler = sighandler;
+	for (unsigned int i = 0; i < LENGTH(blocks); i++) {
+		if (blocks[i].signal > 0)
+			sigaction(SIGMINUS+blocks[i].signal, &sa, NULL);
+	}
+
+}
+
+int getstatus(char *str, char *last)
+{
+	strcpy(last, str);
+	str[0] = '\0';
+	for (unsigned int i = 0; i < LENGTH(blocks); i++)
+		strcat(str, statusbar[i]);
+	str[strlen(str)-strlen(delim)] = '\0';
+	return strcmp(str, last);//0 if they are the same
+}
+
+void pstdout()
+{
+	if (!getstatus(statusstr[0], statusstr[1]))//Only write out if text has changed.
+		return;
+	printf("%s\n",statusstr[0]);
+	fflush(stdout);
+}
+
+
+void psomebar()
+{
+	if (!getstatus(statusstr[0], statusstr[1]))//Only write out if text has changed.
+		return;
+	if (somebarFd < 0) {
+		somebarFd = open(somebarPath, O_WRONLY|O_CLOEXEC);
+		if (somebarFd < 0 && errno == ENOENT) {
+			// assume somebar is not ready yet
+			sleep(1);
+			somebarFd = open(somebarPath, O_WRONLY|O_CLOEXEC);
+		}
+		if (somebarFd < 0) {
+			perror("open");
+			return;
+		}
+	}
+	dprintf(somebarFd, "status %s\n", statusstr[0]);
+}
+
+
+void statusloop()
+{
+	setupsignals();
+	int i = 0;
+	getcmds(-1);
+	while (1) {
+		getcmds(i++);
+		writestatus();
+		if (!statusContinue)
+			break;
+		sleep(1.0);
+	}
+}
+
+#ifndef __OpenBSD__
+/* this signal handler should do nothing */
+void dummysighandler(int signum)
+{
+    return;
+}
+#endif
+
+void sighandler(int signum)
+{
+	getsigcmds(signum-SIGPLUS);
+	writestatus();
+}
+
+void termhandler()
+{
+	statusContinue = 0;
+}
+
+void sigpipehandler()
+{
+	close(somebarFd);
+	somebarFd = -1;
+}
+
+int main(int argc, char** argv)
+{
+	for (int i = 0; i < argc; i++) {//Handle command line arguments
+		if (!strcmp("-d",argv[i]))
+			strncpy(delim, argv[++i], delimLen);
+		else if (!strcmp("-p",argv[i]))
+			writestatus = pstdout;
+		else if (!strcmp("-s",argv[i]))
+			strcpy(somebarPath, argv[++i]);
+	}
+
+	if (!strlen(somebarPath)) {
+		strcpy(somebarPath, getenv("XDG_RUNTIME_DIR"));
+		strcat(somebarPath, "/somebar-0");
+	}
+
+	delimLen = MIN(delimLen, strlen(delim));
+	delim[delimLen++] = '\0';
+	signal(SIGTERM, termhandler);
+	signal(SIGINT, termhandler);
+	signal(SIGPIPE, sigpipehandler);
+	statusloop();
+	return 0;
+}