From fb8817ebf90994ea5f77a7d2b43f64b54acd5bb2 Mon Sep 17 00:00:00 2001 From: Ben Buhse Date: Fri, 6 Feb 2026 16:37:33 -0600 Subject: [PATCH] Begin work to add wallpaper support to beansprout Added pixman and zigimg dependencies Set up in build.zig, added to both exe and exe_check Add new protocols: river-layer-shell-v1 wlr-layer-shell-unstable-v1 xdg-shell (dep of wlr-layer-shell-unstable-v1) Update Context.zig to hold wl_output, wl_shm, and a WallpaperImage Also re-ordered all of its fields into alphabetical order Context.create() now takes a Context.Options struct so that it takes one arg instead of many smaller args. Added new WallpaperImage.zig, but it's not yet actually used --- build.zig | 17 +- build.zig.zon | 8 + protocol/river-layer-shell-v1.xml | 192 +++++++++++ protocol/wlr-layer-shell-unstable-v1.xml | 390 +++++++++++++++++++++++ src/Context.zig | 42 ++- src/WallpaperImage.zig | 60 ++++ src/main.zig | 35 +- 7 files changed, 718 insertions(+), 26 deletions(-) create mode 100644 protocol/river-layer-shell-v1.xml create mode 100644 protocol/wlr-layer-shell-unstable-v1.xml create mode 100644 src/WallpaperImage.zig diff --git a/build.zig b/build.zig index f51a5d7..434e9bf 100644 --- a/build.zig +++ b/build.zig @@ -18,16 +18,23 @@ pub fn build(b: *std.Build) void { // Rest of the deps const kdl = b.dependency("kdl", .{}).module("kdl"); const known_folders = b.dependency("known_folders", .{}).module("known-folders"); + const pixman = b.dependency("pixman", .{}).module("pixman"); const xkbcommon = b.dependency("xkbcommon", .{}).module("xkbcommon"); + const zigimg = b.dependency("zigimg", .{}).module("zigimg"); scanner.addCustomProtocol(b.path("protocol/river-window-management-v1.xml")); scanner.addCustomProtocol(b.path("protocol/river-xkb-bindings-v1.xml")); + scanner.addCustomProtocol(b.path("protocol/river-layer-shell-v1.xml")); + scanner.addSystemProtocol("stable/xdg-shell/xdg-shell.xml"); // dep of wlr-layer-shell-unstable-v1 + scanner.addCustomProtocol(b.path("protocol/wlr-layer-shell-unstable-v1.xml")); scanner.generate("wl_compositor", 4); scanner.generate("wl_shm", 1); scanner.generate("wl_output", 4); scanner.generate("river_window_manager_v1", 3); scanner.generate("river_xkb_bindings_v1", 2); + scanner.generate("river_layer_shell_v1", 1); + scanner.generate("zwlr_layer_shell_v1", 3); const exe = b.addExecutable(.{ .name = "beansprout", @@ -42,12 +49,15 @@ pub fn build(b: *std.Build) void { // Make sure to also add new imports to the exe_check step exe.root_module.addImport("wayland", wayland); - exe.root_module.addImport("xkbcommon", xkbcommon); exe.root_module.addImport("kdl", kdl); exe.root_module.addImport("known_folders", known_folders); + exe.root_module.addImport("pixman", pixman); + exe.root_module.addImport("xkbcommon", xkbcommon); + exe.root_module.addImport("zigimg", zigimg); exe.linkLibC(); exe.linkSystemLibrary("wayland-client"); + exe.linkSystemLibrary("pixman-1"); exe.linkSystemLibrary("xkbcommon"); b.installArtifact(exe); @@ -90,12 +100,15 @@ pub fn build(b: *std.Build) void { }); exe_check.root_module.addImport("wayland", wayland); - exe_check.root_module.addImport("xkbcommon", xkbcommon); exe_check.root_module.addImport("kdl", kdl); exe_check.root_module.addImport("known_folders", known_folders); + exe_check.root_module.addImport("pixman", pixman); + exe_check.root_module.addImport("xkbcommon", xkbcommon); + exe_check.root_module.addImport("zigimg", zigimg); exe_check.linkLibC(); exe_check.linkSystemLibrary("wayland-client"); + exe_check.linkSystemLibrary("pixman-1"); exe_check.linkSystemLibrary("xkbcommon"); const check = b.step("check", "Check if beanbag compiles"); diff --git a/build.zig.zon b/build.zig.zon index 24164a5..d06c22e 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -24,6 +24,14 @@ .url = "https://github.com/ziglibs/known-folders/archive/83d39161eac2ed6f37ad3cb4d9dd518696ce90bb.tar.gz", .hash = "known_folders-0.0.0-Fy-PJv3LAAABBRVoZWVrKZdyLoUfl5VRY5fqRRRdnF5L", }, + .pixman = .{ + .url = "https://codeberg.org/ifreund/zig-pixman/archive/387f04a0289a69d159c88b5f70396ec12a8ddb00.tar.gz", + .hash = "pixman-0.4.0-dev-LClMn0eVAAAlXnMK-MVBZkOG0urNdOPGVQdaGecXPM5O", + }, + .zigimg = .{ + .url = "https://github.com/zigimg/zigimg/archive/fb74dfb7c6d83f2bd01a229826669451525a4ba8.tar.gz", + .hash = "zigimg-0.1.0-8_eo2kSGFwADIkeZYTgfnLOV-khh6ZRoGmK6F2-s_QbY", + }, }, .paths = .{ diff --git a/protocol/river-layer-shell-v1.xml b/protocol/river-layer-shell-v1.xml new file mode 100644 index 0000000..0a9a437 --- /dev/null +++ b/protocol/river-layer-shell-v1.xml @@ -0,0 +1,192 @@ + + + + SPDX-FileCopyrightText: © 2025 Isaac Freund + SPDX-License-Identifier: MIT + + 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 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. + + + + This protocol allows the river-window-management-v1 window manager to + support the wlr-layer-shell-v1 protocol. + + The key words "must", "must not", "required", "shall", "shall not", + "should", "should not", "recommended", "may", and "optional" in this + document are to be interpreted as described in IETF RFC 2119. + + Warning! The protocol described in this file is currently in the testing + phase. Backward compatible changes may be added together with the + corresponding interface version bump. Backward incompatible changes can only + be done by creating a new major version of the extension. + + + + + This global interface should only be advertised to the client if the + river_window_manager_v1 global is also advertised. Binding this interface + indicates that the window manager supports layer shell. + + If the window manager does not bind this interface, the compositor should + not allow clients to map layer surfaces. This can be achieved by + closing layer surfaces immediately. + + + + + + + + + This request indicates that the client will no longer use the + river_layer_shell_v1 object. + + + + + + It is a protocol error to make this request more than once for a given + river_output_v1 object. + + + + + + + + It is a protocol error to make this request more than once for a given + river_seat_v1 object. + + + + + + + + + The lifetime of this object is tied to the corresponding river_output_v1. + This object is made inert when the river_output_v1.removed event is sent + and should be destroyed. + + + + + This request indicates that the client will no longer use the + river_layer_shell_output_v1 object and that it may be safely destroyed. + + This request should be made after the river_output_v1.removed event is + received to complete destruction of the output. + + + + + + This event indicates the area of the output remaining after subtracting + the exclusive zones of layer surfaces. Exclusive zones are a hint, the + window manager is free to ignore this area hint if it wishes. + + The x and y values are in the global coordinate space, not relative to + the position of the output. + + This event will be followed by a manage_start event after all other new + state has been sent by the server. + + + + + + + + + + Mark this output as the default for new layer surfaces which do not + request a specific output themselves. This request overrides any + previous set_default request on any river_layer_shell_output_v1 object. + + If no set_default request is made or if the default output is destroyed, + the default output is undefined until the next set_default request. + + This request modifies window management state and may only be made as + part of a manage sequence, see the river_window_manager_v1 description. + + + + + + + The lifetime of this object is tied to the corresponding river_seat_v1. + This object is made inert when the river_seat_v1.removed event is sent and + should be destroyed. + + + + + This request indicates that the client will no longer use the + river_layer_shell_seat_v1 object and that it may be safely destroyed. + + This request should be made after the river_seat_v1.removed event is + received to complete destruction of the seat. + + + + + + A layer shell surface will be given exclusive keyboard focus at the end + of the manage sequence in which this event is sent. The window manager + may want to update window decorations or similar to indicate that no + window is focused. + + Until the focus_non_exclusive or focus_none event is sent, all window + manager requests to change focus are ignored. + + This event will be followed by a manage_start event after all other new + state has been sent by the server. + + + + + + A layer shell surface will be given non-exclusive keyboard focus at the + end of the manage sequence in which this event is sent. The window + manager may want to update window decorations or similar to indicate + that no window is focused. + + The window manager continues to control focus and may choose to focus a + different window/shell surface at any time. If the window manager sets + focus during the same manage sequence in which this event is sent, the + layer surface will not be focused. + + This event will be followed by a manage_start event after all other new + state has been sent by the server. + + + + + + No layer shell surface will have keyboard focus at the end of the manage + sequence in which this event is sent. The window manager may want to + return focus to whichever window last had focus, for example. + + This event will be followed by a manage_start event after all other new + state has been sent by the server. + + + + diff --git a/protocol/wlr-layer-shell-unstable-v1.xml b/protocol/wlr-layer-shell-unstable-v1.xml new file mode 100644 index 0000000..d62fd51 --- /dev/null +++ b/protocol/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/Context.zig b/src/Context.zig index 552ab66..c578592 100644 --- a/src/Context.zig +++ b/src/Context.zig @@ -10,11 +10,14 @@ const Context = @This(); initialized: bool, // Wayland globals -wl_display: *wl.Display, -wl_registry: *wl.Registry, wl_compositor: *wl.Compositor, +wl_display: *wl.Display, +wl_output: *wl.Output, +wl_registry: *wl.Registry, +wl_shm: *wl.Shm, -// Wayland globals that we have structs for +// Wayland globals that we have special structs for +wallpaper_image: *WallpaperImage, wm: *WindowManager, xkb_bindings: *XkbBindings, @@ -28,25 +31,36 @@ pub const PendingManage = struct { config: ?*Config = null, }; -pub fn create( - wl_display: *wl.Display, - wl_registry: *wl.Registry, +// I use this because otherwise create() takes +// a LOT of arguments. +pub const Options = struct { wl_compositor: *wl.Compositor, + wl_display: *wl.Display, + wl_output: *wl.Output, + wl_registry: *wl.Registry, + wl_shm: *wl.Shm, + river_layer_shell_v1: *river.LayerShellV1, river_window_manager_v1: *river.WindowManagerV1, river_xkb_bindings_v1: *river.XkbBindingsV1, + zwlr_layer_shell_v1: *zwlr.LayerShellV1, config: *Config, -) !*Context { +}; + +pub fn create(options: Options) !*Context { const context = try utils.allocator.create(Context); errdefer context.destroy(); context.* = .{ .initialized = false, - .wl_display = wl_display, - .wl_registry = wl_registry, - .wl_compositor = wl_compositor, - .wm = try WindowManager.create(context, river_window_manager_v1), - .xkb_bindings = try XkbBindings.create(context, river_xkb_bindings_v1), - .config = config, + .wl_compositor = options.wl_compositor, + .wl_display = options.wl_display, + .wl_output = options.wl_output, + .wl_registry = options.wl_registry, + .wl_shm = options.wl_shm, + .wallpaper_image = try WallpaperImage.create("FIXME"), // FIXME: TODO: Get this from Config + .wm = try WindowManager.create(context, options.river_window_manager_v1), + .xkb_bindings = try XkbBindings.create(context, options.river_xkb_bindings_v1), + .config = options.config, }; return context; @@ -80,9 +94,11 @@ const std = @import("std"); const wayland = @import("wayland"); const river = wayland.client.river; const wl = wayland.client.wl; +const zwlr = wayland.client.zwlr; const utils = @import("utils.zig"); const Config = @import("Config.zig"); +const WallpaperImage = @import("WallpaperImage.zig"); const WindowManager = @import("WindowManager.zig"); const XkbBindings = @import("XkbBindings.zig"); diff --git a/src/WallpaperImage.zig b/src/WallpaperImage.zig new file mode 100644 index 0000000..7245084 --- /dev/null +++ b/src/WallpaperImage.zig @@ -0,0 +1,60 @@ +// SPDX-FileCopyrightText: 2026 Ben Buhse +// +// SPDX-License-Identifier: GPL-3.0-or-later + +const WallpaperImage = @This(); + +image: *pixman.Image, +pixels: std.ArrayList(u32), + +// TODO: Make image_path nullable, if null, do a single color with a single_pixel_buffer instead(?) +pub fn create(image_path: []const u8) !*WallpaperImage { + var wallpaper_image = try utils.allocator.create(WallpaperImage); + errdefer utils.allocator.destroy(wallpaper_image); + + var read_buf: [zigimg.io.DEFAULT_BUFFER_SIZE]u8 = undefined; + var image = try zigimg.Image.fromFilePath(utils.allocator, image_path, &read_buf); + defer image.deinit(utils.allocator); + + // We don't want to deal with all the possible formats, + // so let's just convert to one we can use with pixman. + if (image.pixelFormat() != .rgba32) { + try image.convert(utils.allocator, .rgba32); + } + + log.debug("image loaded ({}x{})", .{ image.width, image.height }); + + const pixels = image.pixels.rgba32; + // We have to manually convert to argb -- + // It's only guaranteed that Wayland compositors will have xrgb and argb support but zigimg doesn't have either of those. + wallpaper_image.pixels = try std.ArrayList(u32).initCapacity(utils.allocator, pixels.len); + errdefer wallpaper_image.pixels.deinit(utils.allocator); + for (0..pixels.len) |i| { + const a: u32 = @intCast(pixels[i].a); + const r: u32 = @intCast(pixels[i].r); + const g: u32 = @intCast(pixels[i].g); + const b: u32 = @intCast(pixels[i].b); + const new_val: u32 = (a << 24) + (r << 16) + (g << 8) + b; + try wallpaper_image.pixels.append(utils.allocator, new_val); + } + + wallpaper_image.image = pixman.Image.createBits(.a8r8g8b8, @intCast(image.width), @intCast(image.height), @ptrCast(@alignCast(wallpaper_image.pixels.items.ptr)), @intCast(image.width * image.pixelFormat().pixelStride())) orelse return error.FailedToCreatePixmanImage; + + return wallpaper_image; +} + +pub fn destroy(wallpaper_image: *WallpaperImage) void { + _ = wallpaper_image.image.unref(); + wallpaper_image.pixels.deinit(utils.allocator); + + utils.allocator.destroy(wallpaper_image); +} + +const std = @import("std"); + +const pixman = @import("pixman"); +const zigimg = @import("zigimg"); + +const utils = @import("utils.zig"); + +const log = std.log.scoped(.WallpaperImage); diff --git a/src/main.zig b/src/main.zig index 22f63cd..2237899 100644 --- a/src/main.zig +++ b/src/main.zig @@ -2,11 +2,15 @@ // // SPDX-License-Identifier: GPL-3.0-or-later -/// Wayland globals that we need to bind to +/// Wayland globals that we need to bind listen in alphabetical order const Globals = struct { - wl_compositor: ?*wl.Compositor = null, + river_layer_shell_v1: ?*river.LayerShellV1 = null, river_window_manager_v1: ?*river.WindowManagerV1 = null, river_xkb_bindings_v1: ?*river.XkbBindingsV1 = null, + wl_compositor: ?*wl.Compositor = null, + wl_output: ?*wl.Output = null, + wl_shm: ?*wl.Shm = null, + zwlr_layer_shell_v1: ?*zwlr.LayerShellV1 = null, }; pub fn main() !void { @@ -30,20 +34,28 @@ pub fn main() !void { fatal("Initial roundtrip failed: E{s}", .{@tagName(errno)}); } - const wl_compositor = globals.wl_compositor orelse utils.interfaceNotAdvertised(wl.Compositor); + const river_layer_shell_v1 = globals.river_layer_shell_v1 orelse utils.interfaceNotAdvertised(river.LayerShellV1); const river_window_manager_v1 = globals.river_window_manager_v1 orelse utils.interfaceNotAdvertised(river.WindowManagerV1); const river_xkb_bindings_v1 = globals.river_xkb_bindings_v1 orelse utils.interfaceNotAdvertised(river.XkbBindingsV1); + const wl_compositor = globals.wl_compositor orelse utils.interfaceNotAdvertised(wl.Compositor); + const wl_output = globals.wl_output orelse utils.interfaceNotAdvertised(wl.Output); + const wl_shm = globals.wl_shm orelse utils.interfaceNotAdvertised(wl.Shm); + const zwlr_layer_shell_v1 = globals.zwlr_layer_shell_v1 orelse utils.interfaceNotAdvertised(zwlr.LayerShellV1); const config = try Config.create(); defer config.destroy(); - const context = try Context.create( - wl_display, - wl_registry, - wl_compositor, - river_window_manager_v1, - river_xkb_bindings_v1, - config, - ); + const context = try Context.create(.{ + .wl_compositor = wl_compositor, + .wl_display = wl_display, + .wl_output = wl_output, + .wl_registry = wl_registry, + .wl_shm = wl_shm, + .river_layer_shell_v1 = river_layer_shell_v1, + .river_window_manager_v1 = river_window_manager_v1, + .river_xkb_bindings_v1 = river_xkb_bindings_v1, + .zwlr_layer_shell_v1 = zwlr_layer_shell_v1, + .config = config, + }); defer context.destroy(); while (true) { @@ -86,6 +98,7 @@ const process = std.process; const wayland = @import("wayland"); const river = wayland.client.river; const wl = wayland.client.wl; +const zwlr = wayland.client.zwlr; const utils = @import("utils.zig"); const Config = @import("Config.zig");