From 4e4b82e4785992623b3bf13ce891188e02d51b77 Mon Sep 17 00:00:00 2001 From: Raphael Robatsch Date: Tue, 19 Oct 2021 22:46:46 +0200 Subject: [PATCH] initial --- .gitignore | 3 + meson.build | 15 + protocols/meson.build | 23 ++ protocols/wlr-layer-shell-unstable-v1.xml | 390 ++++++++++++++++++++++ src/main.cpp | 176 ++++++++++ 5 files changed, 607 insertions(+) create mode 100644 .gitignore create mode 100644 meson.build create mode 100644 protocols/meson.build create mode 100644 protocols/wlr-layer-shell-unstable-v1.xml create mode 100644 src/main.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..02f9372 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +compile_commands.json +build +.cache diff --git a/meson.build b/meson.build new file mode 100644 index 0000000..d89d15b --- /dev/null +++ b/meson.build @@ -0,0 +1,15 @@ +project('somebar', ['c', 'cpp'], + default_options: ['cpp_std=c++17']) + +wayland_dep = dependency('wayland-client') +qt5 = import('qt5') +qt5_dep = dependency('qt5', modules: ['Core', 'Widgets']) +#moc = qt5.compile_moc(headers: [ 'src/.hpp', ]) + +subdir('protocols') + +executable('somebar', + 'src/main.cpp', + wayland_sources, + #moc, + dependencies: [qt5_dep, wayland_dep]) diff --git a/protocols/meson.build b/protocols/meson.build new file mode 100644 index 0000000..4fb3011 --- /dev/null +++ b/protocols/meson.build @@ -0,0 +1,23 @@ +# 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_sources = [ + wayland_scanner_code.process( + wl_protocol_dir + '/stable/xdg-shell/xdg-shell.xml', + 'wlr-layer-shell-unstable-v1.xml', + ), + wayland_scanner_client.process( + wl_protocol_dir + '/stable/xdg-shell/xdg-shell.xml', + 'wlr-layer-shell-unstable-v1.xml', + ), + ] diff --git a/protocols/wlr-layer-shell-unstable-v1.xml b/protocols/wlr-layer-shell-unstable-v1.xml new file mode 100644 index 0000000..78ba050 --- /dev/null +++ b/protocols/wlr-layer-shell-unstable-v1.xml @@ -0,0 +1,390 @@ + + + + Copyright © 2017 Drew DeVault + + Permission to use, copy, modify, distribute, and sell this + software and its documentation for any purpose is hereby granted + without fee, provided that the above copyright notice appear in + all copies and that both that copyright notice and this permission + notice appear in supporting documentation, and that the name of + the copyright holders not be used in advertising or publicity + pertaining to distribution of the software without specific, + written prior permission. The copyright holders make no + representations about the suitability of this software for any + purpose. It is provided "as is" without express or implied + warranty. + + THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + THIS SOFTWARE. + + + + + Clients can use this interface to assign the surface_layer role to + wl_surfaces. Such surfaces are assigned to a "layer" of the output and + rendered with a defined z-depth respective to each other. They may also be + anchored to the edges and corners of a screen and specify input handling + semantics. This interface should be suitable for the implementation of + many desktop shell components, and a broad number of other applications + that interact with the desktop. + + + + + Create a layer surface for an existing surface. This assigns the role of + layer_surface, or raises a protocol error if another role is already + assigned. + + Creating a layer surface from a wl_surface which has a buffer attached + or committed is a client error, and any attempts by a client to attach + or manipulate a buffer prior to the first layer_surface.configure call + must also be treated as errors. + + 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. + + + + + + + + + + + + + + + + + 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. + + + + + + + + + + + + + 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. + + + + + + + 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. + + + + + 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. + + + + + + + + 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. + + + + + + + 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. + + + + + + + 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. + + + + + + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + + + 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. + + + + + + + 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. + + + + + + + When a configure event is received, if a client commits the + surface in response to the configure event, then the client + must make an ack_configure request sometime before the commit + request, passing along the serial of the configure event. + + If the client receives multiple configure events before it + can respond to one, it only has to ack the last configure event. + + A client is not required to commit immediately after sending + an ack_configure request - it may even ack_configure several times + before its next surface commit. + + A client may send multiple ack_configure requests before committing, but + only the last request sent before a commit indicates which configure + event the client really is responding to. + + + + + + + This request destroys the layer surface. + + + + + + The configure event asks the client to resize its surface. + + Clients should arrange their surface for the new states, and then send + an ack_configure request with the serial sent in this configure event at + some point before committing the new surface. + + The client is free to dismiss all but the last configure event it + received. + + The width and height arguments specify the size of the window in + surface-local coordinates. + + The size is a hint, in the sense that the client is free to ignore it if + it doesn't resize, pick a smaller size (to satisfy aspect ratio or + resize in steps of NxM pixels). If the client picks a smaller size and + is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the + surface will be centered on this axis. + + If the width or height arguments are zero, it means the client should + decide its own window dimension. + + + + + + + + + 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. + + + + + + + + + + + + + + + + + + + + + + Change the layer that the surface is rendered on. + + Layer is double-buffered, see wl_surface.commit. + + + + + diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..cdca028 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,176 @@ +// somebar - dwl bar +// See LICENSE file for copyright and license details. + +#include +#include +#include +#include +#include +#include +#include +#include "qnamespace.h" +#include "wlr-layer-shell-unstable-v1-client-protocol.h" +#include "xdg-shell-client-protocol.h" + +constexpr uint32_t barSize = 20; + +static void waylandFlush(); +static void waylandWriteReady(); +static void requireGlobal(const void *p, const char *name); + +// wayland globals +static wl_display *display; +static wl_compositor *compositor; +static wl_shm *shm; +static zwlr_layer_shell_v1 *wlrLayerShell; +static QSocketNotifier *displayWriteNotifier; + +static xdg_wm_base *xdgWmBase; +static const struct xdg_wm_base_listener xdgWmBaseListener = { + [](void*, xdg_wm_base *sender, uint32_t serial) { + xdg_wm_base_pong(sender, serial); + waylandFlush(); + } +}; + +static const struct wl_buffer_listener wlBufferListener { + [](void*, wl_buffer *buffer) { + wl_buffer_destroy(buffer); + } +}; + +// app globals +static wl_surface *surface; +static zwlr_layer_surface_v1 *layerSurface; +static const struct wl_surface_listener surfaceListener = { + // todo +}; +static const struct zwlr_layer_surface_v1_listener layerSurfaceListener = { + [](void*, zwlr_layer_surface_v1 *layerSurface, uint32_t serial, uint32_t width, uint32_t height) { + zwlr_layer_surface_v1_ack_configure(layerSurface, serial); + printf("configured to %d x %d\n", width, height); + auto stride = width * 4; + auto size = stride * height; + auto fd = memfd_create("somebar-surface", MFD_CLOEXEC); + ftruncate(fd, size); + auto buffer = reinterpret_cast(mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); + auto pool = wl_shm_create_pool(shm, fd, size); + auto wlBuffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888); + wl_shm_pool_destroy(pool); + close(fd); + + auto w = 2*M_PI/(width / 10); + for (auto x = 0; x < width; x++) { + auto val = 255*(sin(x*w)/2+0.5); + for (auto y = 0; y < height; y++) { + auto p = &buffer[y*stride+x*4]; + *p++ = 0; + *p++ = 0; + *p++ = val; + *p++ = val; + } + } + + wl_buffer_add_listener(wlBuffer, &wlBufferListener, nullptr); + wl_surface_attach(surface, wlBuffer, 0, 0); + wl_surface_commit(surface); + waylandFlush(); + } +}; + +// called after we have received the initial batch of globals +static void onReady() +{ + requireGlobal(compositor, "wl_compositor"); + requireGlobal(shm, "wl_shm"); + requireGlobal(wlrLayerShell, "zwlr_layer_shell_v1"); + surface = wl_compositor_create_surface(compositor); + layerSurface = zwlr_layer_shell_v1_get_layer_surface(wlrLayerShell, surface, nullptr, ZWLR_LAYER_SHELL_V1_LAYER_TOP, "net.tapesoftware.Somebar"); + zwlr_layer_surface_v1_add_listener(layerSurface, &layerSurfaceListener, nullptr); + zwlr_layer_surface_v1_set_anchor(layerSurface, ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT); + zwlr_layer_surface_v1_set_size(layerSurface, 0, barSize); + zwlr_layer_surface_v1_set_exclusive_zone(layerSurface, barSize); + wl_surface_commit(surface); + waylandFlush(); +} + +struct HandleGlobalHelper { + wl_registry *registry; + uint32_t name; + const char *interface; + + template + bool handle(T &store, const wl_interface &iface, int version) { + if (strcmp(interface, iface.name)) return false; + store = static_cast(wl_registry_bind(registry, name, &iface, version)); + return true; + } +}; +static void registryHandleGlobal(void*, wl_registry *registry, uint32_t name, const char *interface, uint32_t version) +{ + auto reg = HandleGlobalHelper { registry, name, interface }; + printf("got global: %s v%d\n", interface, version); + 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(xdgWmBase, xdg_wm_base_interface, 2)) { + xdg_wm_base_add_listener(xdgWmBase, &xdgWmBaseListener, nullptr); + return; + } +} +static const struct wl_registry_listener registry_listener = { registryHandleGlobal, nullptr }; + +int main(int argc, char **argv) +{ + QCoreApplication app(argc, argv); + QCoreApplication::setOrganizationName("tape software"); + QCoreApplication::setOrganizationDomain("tapesoftware.net"); + QCoreApplication::setApplicationName("somebar"); + + display = wl_display_connect(NULL); + if (!display) { + fprintf(stderr, "Failed to connect to Wayland display\n"); + return 1; + } + + auto registry = wl_display_get_registry(display); + wl_registry_add_listener(registry, ®istry_listener, nullptr); + + auto initialSync = wl_display_sync(display); + auto initialSyncListener = wl_callback_listener { + [](void*, wl_callback *cb, uint32_t) { + onReady(); + wl_callback_destroy(cb); + } + }; + wl_callback_add_listener(initialSync, &initialSyncListener, nullptr); + + QSocketNotifier displayReadNotifier(wl_display_get_fd(display), QSocketNotifier::Read); + displayReadNotifier.setEnabled(true); + QObject::connect(&displayReadNotifier, &QSocketNotifier::activated, [=]() { wl_display_dispatch(display); }); + displayWriteNotifier = new QSocketNotifier(wl_display_get_fd(display), QSocketNotifier::Write); + displayWriteNotifier->setEnabled(false); + QObject::connect(displayWriteNotifier, &QSocketNotifier::activated, waylandWriteReady); + waylandFlush(); + + return app.exec(); +} + +static void waylandFlush() +{ + wl_display_dispatch_pending(display); + if (wl_display_flush(display) < 0 && errno == EAGAIN) { + displayWriteNotifier->setEnabled(true); + } +} +static void waylandWriteReady() +{ + displayWriteNotifier->setEnabled(false); + waylandFlush(); +} +static void requireGlobal(const void *p, const char *name) +{ + if (p) return; + fprintf(stderr, "Wayland compositor does not export required global %s, aborting.\n", name); + exit(1); +}