Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348const std = @import("std");const span = std.mem.span;const posix = std.posix;const utils = @import("utils.zig");
const wayland = @import("wayland");const wl = wayland.client.wl;const xdg = wayland.client.xdg;const zxdg = wayland.client.zxdg;
const z2d = @import("z2d");
const Client = @This();
alloc: std.mem.Allocator,display: *wl.Display,shm: ?*wl.Shm = null,compositor: ?*wl.Compositor = null,wm_base: ?*xdg.WmBase = null,decoration_manager: ?*zxdg.DecorationManagerV1 = null,
supported_formats: std.ArrayList(wl.Shm.Format) = .empty,
// TODO: Allow multiple windows?window: Window,
pub fn init(client: *Client, alloc: std.mem.Allocator) !void { client.alloc = alloc; client.display = try wl.Display.connect(null); client.supported_formats = .empty; const registry = try client.display.getRegistry();
registry.setListener(*Client, registryListener, client); if (client.display.roundtrip() != .SUCCESS) return error.RoundtripFailed;
_ = client.shm orelse return error.NoWlShm; _ = client.compositor orelse return error.NoWlCompositor; _ = client.wm_base orelse return error.NoXdgWmBase; client.shm.?.setListener(*Client, shmListener, client); client.wm_base.?.setListener(*Client, wmBaseListener, client); if (client.display.roundtrip() != .SUCCESS) return error.RoundtripFailed;}
pub fn createWindow(client: *Client, title: [:0]const u8) *Window { const window: *Window = &client.window; window.* = .{ .client = client, .alloc = client.alloc, .title = title, }; return window;}
pub const Window = struct { client: *Client = undefined, alloc: std.mem.Allocator = undefined, title: [:0]const u8 = "", width: u32 = 0, height: u32 = 0, wl_surface: ?*wl.Surface = null, xdg_toplevel: ?*xdg.Toplevel = null, xgd_surface: ?*xdg.Surface = null, pool: ?*wl.ShmPool = null, decoration: Decoration = .{},
wl_buffer: ?*wl.Buffer = null, z2d_surface: ?z2d.Surface = null,
buffer_data: ?[]align(std.heap.page_size_min) u8 = null, wl_buffers: [2]?*wl.Buffer = .{ null, null }, z2d_surfaces: [2]?z2d.Surface = .{ null, null }, buffer_swapped: bool = false,
/// In miliseconds. last_frame: u32 = 0, is_open: bool = false, need_redraw: bool = false,
/// Returns a z2d context pub fn context(window: *Window) z2d.Context { return .init(window.alloc, &window.surfaces[window.sel]); }
// Returns a z2d surface to the window. pub fn surface(window: *Window) ?z2d.Surface { if (window.buffer_data) |data| { return z2d.Surface.initBuffer( .image_surface_rgb, .fromClamped(1, 1, 1), @ptrCast(@alignCast(data[window.dataOffset(true)..])), @intCast(window.width), @intCast(window.height), ); } return null; }
pub fn deinit(window: *Window) void { if (window.decoration.xdg_decoration) |d| d.destroy(); if (window.xdg_toplevel) |t| t.destroy(); if (window.xgd_surface) |s| s.destroy(); if (window.wl_buffer) |b| b.destroy(); if (window.pool) |p| p.destroy(); if (window.wl_surface) |s| s.destroy(); if (window.z2d_surface) |z| posix.munmap(@ptrCast(@alignCast(z.image_surface_rgb.buf))); }
fn commit(window: *Window) void { window.wl_surface.?.attach(window.wl_buffer, 0, 0);
window.wl_surface.?.damage(0, 0, std.math.maxInt(i32), std.math.maxInt(i32)); window.wl_surface.?.commit(); }
pub fn submit(window: *Window) !void { window.buffer_swapped = !window.buffer_swapped;
const buffer = try window.pool.?.createBuffer( @intCast(window.dataOffset(false)), @intCast(window.width), @intCast(window.height), @intCast(window.width * @sizeOf(z2d.pixel.RGB)), .xrgb8888, ); if (window.wl_buffer) |b| b.destroy(); window.wl_buffer = buffer;
window.commit(); window.need_redraw = false; }
pub fn show(window: *Window, width: u32, height: u32) !void { const client = window.client;
const wl_surface = try client.compositor.?.createSurface(); errdefer wl_surface.destroy(); const xdg_surface = try client.wm_base.?.getXdgSurface(wl_surface); errdefer xdg_surface.destroy(); const xdg_toplevel = try xdg_surface.getToplevel(); errdefer xdg_toplevel.destroy(); if (window.client.decoration_manager) |manager| { window.decoration.xdg_decoration = try manager.getToplevelDecoration(xdg_toplevel); window.decoration.xdg_decoration.?.setListener(*Window, xdgDecorationListener, window); window.decoration.xdg_decoration.?.setMode(.server_side); }
const cb = try wl_surface.frame(); cb.setListener(*Window, surfaceCbListener, window);
window.wl_surface = wl_surface; window.xgd_surface = xdg_surface; window.xdg_toplevel = xdg_toplevel;
window.xgd_surface.?.setListener(*Window, xdgSurfaceListener, window); window.xdg_toplevel.?.setListener(*Window, xdgToplevelListener, window); window.xdg_toplevel.?.setTitle(window.title.ptr); window.xdg_toplevel.?.setAppId("dev.jeremia.GuiApp");
window.wl_surface.?.commit(); if (client.display.roundtrip() != .SUCCESS) return error.RoundtripFailed; window.commit(); try window.resize(width, height); window.is_open = true; }
pub fn resize(window: *Window, width: u32, height: u32) !void { try window.onSize(width, height); window.commit(); window.width = width; window.height = height; }
pub fn setTitle(window: *Window, title: [:0]const u8) void { window.title = title; if (window.xdg_toplevel) |toplevel| toplevel.setTitle(title.ptr); }
fn newPool(window: *Window, size: u32) !void { if (size == 0) return; if (window.buffer_data) |b| if (b.len >= size) return error.OldShmIsLarger; window.pool, const data = try window.client.createShmPool(size * 2); if (window.buffer_data) |b| posix.munmap(b); window.buffer_data = data; }
/// If `next_frame` is false, it returns the frame that should currently be displayed. /// If true, it returns the next frame's offset. fn dataOffset(window: *Window, next_frame: bool) usize { const size = window.buffer_data.?.len; var b: bool = window.buffer_swapped; if (next_frame) b = !b; return if (b) @intCast(size / 2) else 0; }
// Called when the window needs to be resized. // Creates a wl_shm_pool if the one the Window currently has is not big enough. // The pool is allocated enough memory for two frames, given the size. // Two wl_buffer are created with half the memory each. fn onSize(window: *Window, width: u32, height: u32) !void { const size = width * height * @sizeOf(z2d.pixel.RGB) * 2; std.log.debug("(wayland) onSize: {d}x{d} ({d})", .{ width, height, size }); if (size == 0) return;
window.newPool(size) catch |err| switch (err) { error.OldShmIsLarger => { std.log.debug("(wayland): Old pool is larger!", .{}); }, else => |e| return e, };
const pool: *wl.ShmPool = window.pool orelse return;
std.log.debug("(wayland): createBuffer(s) {d}x{d} ({d})", .{ width, height, width * @sizeOf(z2d.pixel.RGB) }); const buffer = try pool.createBuffer( @intCast(window.dataOffset(false)), @intCast(width), @intCast(height), @intCast(width * @sizeOf(z2d.pixel.RGB)), .xrgb8888, );
if (window.wl_buffer) |b| b.destroy();
window.wl_buffer = buffer; }};
/// Creates a shared memory pool, and returns both the pool, and its underlying data.fn createShmPool(client: *Client, size: u32) !struct { *wl.ShmPool, []align(std.heap.page_size_min) u8 } { var buf: [100]u8 = undefined; var retries: u8 = 0; var fd: i32 = 0; while (retries < 100) { retries += 1; const name = try std.fmt.bufPrint(&buf, "wayland-window-{d}", .{std.crypto.random.int(u32)}); fd = posix.memfd_create(name, 0) catch continue; } errdefer posix.close(fd);
try posix.ftruncate(fd, size);
const data = try posix.mmap(null, size, posix.PROT.READ | posix.PROT.WRITE, .{ .TYPE = .SHARED }, fd, 0); errdefer posix.munmap(data);
const pool = try client.shm.?.createPool(fd, @intCast(size));
return .{ pool, data };}
const Decoration = struct { xdg_decoration: ?*zxdg.ToplevelDecorationV1 = null, // TODO(wayland): Handle client-side decorations? fn onMode(decoration: *Decoration, _: zxdg.ToplevelDecorationV1.Mode) void { const window: *Window = @fieldParentPtr("decoration", decoration); _ = window; }};
//-----------------------------------------------------------------------------// Listeners.//-----------------------------------------------------------------------------
// This might be a tad excessive.const GlobalsEnum = utils.Enum(&.{ span(wl.Compositor.interface.name), span(wl.Shm.interface.name), span(xdg.WmBase.interface.name), span(zxdg.DecorationManagerV1.interface.name),});
fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, client: *Client) void { switch (event) { .global => |global| { std.log.debug("(wayland): registry: {s} (v{d})", .{ global.interface, global.version }); const val = std.meta.stringToEnum(GlobalsEnum, span(global.interface)) orelse return; switch (val) { .wl_compositor => client.compositor = registry.bind(global.name, wl.Compositor, 1) catch return, .wl_shm => client.shm = registry.bind(global.name, wl.Shm, 1) catch return, .xdg_wm_base => client.wm_base = registry.bind(global.name, xdg.WmBase, 1) catch return, .zxdg_decoration_manager_v1 => client.decoration_manager = registry.bind(global.name, zxdg.DecorationManagerV1, 1) catch return, } }, .global_remove => {}, }}
fn shmListener(_: *wl.Shm, event: wl.Shm.Event, client: *Client) void { switch (event) { .format => |format| { std.log.debug("(wayland): shm format: {t}", .{format.format}); client.supported_formats.append(client.alloc, format.format) catch return; }, }}
fn wmBaseListener(base: *xdg.WmBase, event: xdg.WmBase.Event, _: *Client) void { switch (event) { .ping => |ping| { base.pong(ping.serial); }, }}
fn surfaceCbListener(_: *wl.Callback, event: wl.Callback.Event, window: *Window) void { std.log.debug("(wayland): wl_surface callback", .{});
const cb = window.wl_surface.?.frame() catch return; cb.setListener(*Window, surfaceCbListener, window);
// window.commit();
window.onSize(window.width, window.height) catch return; // window.need_redraw = true; window.last_frame = event.done.callback_data;}
fn xdgSurfaceListener(xdg_surface: *xdg.Surface, event: xdg.Surface.Event, window: *Window) void { std.log.debug("(wayland): xdgSurfaceListener {}", .{event}); switch (event) { .configure => |configure| { xdg_surface.ackConfigure(configure.serial); window.wl_surface.?.commit(); }, }}fn xdgToplevelListener(_: *xdg.Toplevel, event: xdg.Toplevel.Event, window: *Window) void { std.log.debug("(wayland): xdgToplevelListener {}", .{event}); switch (event) { .configure => |conf| { if (window.height != @as(u32, @intCast(conf.height)) or window.width != @as(u32, @intCast(conf.width))) window.need_redraw = true; window.height = @intCast(conf.height); window.width = @intCast(conf.width); }, .close => window.is_open = false, }}
pub fn xdgDecorationListener(_: *zxdg.ToplevelDecorationV1, event: zxdg.ToplevelDecorationV1.Event, window: *Window) void { std.log.debug("(wayland): xdgDecorationListener {}", .{event}); switch (event) { .configure => |conf| { window.decoration.onMode(conf.mode); }, }}