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");