Use mix-in design for interface abstraction.HEADmaster

1 files changed, 16 insertions, 28 deletions

diff --git a/src/wl/shm/root.zig b/src/wl/shm/root.zig
index 741c7df..46388ad 100644
--- a/src/wl/shm/root.zig
+++ b/src/wl/shm/root.zig
@@ -13,46 +13,34 @@ pub const Request = union(enum) {
     create_pool: struct { wayland.Object.Ref, wayland.types.Fd, u32 },
 };
 
-pub var instances: std.ArrayListUnmanaged(*Self) = .empty;
-
-handle: wayland.Object.Ref,
+handle: wayland.Object.Ref = .null,
+init: wayland.Object.interface.Init(Self) = .{},
 formats: std.EnumSet(Format) = .initEmpty(),
 
-pub fn init(
-    self: *Self,
-    ctx: wayland.Context,
-) !void {
-    self.* = .{
-        .handle = try ctx.display.registry.add_object(
-            ctx.allocator,
-            wayland.Object.from_self(self),
-        ),
-    };
-}
-
-fn announce_format(self: * Self, ctx: wayland.Context, fmt: Format) void {
-    _ = ctx;
-    self.formats.insert(fmt);
-}
-
+pub var globals: wayland.Object.interface.Global(Self) = .init;
 pub const handler: wl.Registry.GlobalHandler = .{
     .interface = "wl_shm",
     .version = 1,
-    .handler = register,
+    .handler = globals.register,
 };
 
-fn register(ctx: wayland.Context) ?wayland.Object.Ref {
-    const shm = ctx.allocator.create(Self) catch return null;
-    shm.init(ctx) catch return null;
-
-    instances.append(ctx.allocator, shm) catch return null;
-    return shm.handle;
+fn announce_format(self: * Self, ctx: wayland.Context, fmt: Format) void {
+    _ = ctx;
+    self.formats.insert(fmt);
 }
 
 pub fn create_pool(self: *Self, ctx: wayland.Context, size: usize) !*Pool {
     const pool = try ctx.allocator.create(Pool);
     errdefer ctx.allocator.destroy(pool);
-    try pool.init(ctx, size);
+
+    var file = try AnonymousFile.init_random();
+    errdefer file.close();
+    try file.truncate(size);
+
+    try pool.init.with(ctx, .{
+        .file = file,
+        .buffer = try file.mmap(),
+    });
 
     try ctx.display.request(self, .{ .create_pool = .{
         pool.handle,