Mezzaluna/src/Server.zig

const Server = @This();

const std = @import("std");
const wl = @import("wayland").server.wl;
const wlr = @import("wlroots");

const Root             = @import("Root.zig");
const Seat             = @import("Seat.zig");
const Cursor           = @import("Cursor.zig");
const Keyboard         = @import("Keyboard.zig");
const LayerSurface     = @import("LayerSurface.zig");
const Output           = @import("Output.zig");
const View             = @import("View.zig");
const Keymap           = @import("types/Keymap.zig");
const Hook             = @import("types/Hook.zig");
const Events           = @import("types/Events.zig");
const Popup            = @import("Popup.zig");
const RemoteLua        = @import("RemoteLua.zig");
const RemoteLuaManager = @import("RemoteLuaManager.zig");
const Utils            = @import("Utils.zig");
const SceneNodeData    = @import("SceneNodeData.zig").SceneNodeData;

const gpa = std.heap.c_allocator;
const server = &@import("main.zig").server;

wl_server: *wl.Server,
compositor: *wlr.Compositor,
renderer: *wlr.Renderer,
backend: *wlr.Backend,
event_loop: *wl.EventLoop,
session: ?*wlr.Session,
remote_lua_manager: ?*RemoteLuaManager,

shm: *wlr.Shm,
xdg_shell: *wlr.XdgShell,
layer_shell: *wlr.LayerShellV1,
xdg_toplevel_decoration_manager: *wlr.XdgDecorationManagerV1,
xdg_activation: *wlr.XdgActivationV1,

allocator: *wlr.Allocator,

root: Root,
seat: Seat,
cursor: Cursor,

// Lua data
keymaps: std.AutoHashMap(u64, Keymap),
hooks: std.ArrayList(*Hook),
events: Events,
remote_lua_clients: std.DoublyLinkedList,

// Backend listeners
new_input: wl.Listener(*wlr.InputDevice) = .init(handleNewInput),
new_output: wl.Listener(*wlr.Output) = .init(handleNewOutput),
// backend.events.destroy
new_xdg_toplevel: wl.Listener(*wlr.XdgToplevel) = .init(handleNewXdgToplevel),
new_xdg_popup: wl.Listener(*wlr.XdgPopup) = .init(handleNewXdgPopup),
new_xdg_toplevel_decoration: wl.Listener(*wlr.XdgToplevelDecorationV1) = .init(handleNewXdgToplevelDecoration),
new_layer_surface: wl.Listener(*wlr.LayerSurfaceV1) = .init(handleNewLayerSurface),
request_activate: wl.Listener(*wlr.XdgActivationV1.event.RequestActivate) = .init(handleRequestActivate),

pub fn init(self: *Server) void {
  errdefer Utils.oomPanic();

  const wl_server = wl.Server.create() catch {
    std.log.err("Server create failed, exiting with 2", .{});
    std.process.exit(2);
  };

  const event_loop = wl_server.getEventLoop();

  var session: ?*wlr.Session = undefined;
  const backend = wlr.Backend.autocreate(event_loop, &session) catch {
    std.log.err("Backend create failed, exiting with 3", .{});
    std.process.exit(3);
  };

  const renderer = wlr.Renderer.autocreate(backend) catch {
    std.log.err("Renderer create failed, exiting with 4", .{});
    std.process.exit(4);
  };

  self.* = .{
    .wl_server = wl_server,
    .backend = backend,
    .renderer = renderer,
    .allocator = wlr.Allocator.autocreate(backend, renderer) catch {
      std.log.err("Allocator create failed, exiting with 5", .{});
      std.process.exit(5);
    },
    .xdg_shell = try wlr.XdgShell.create(wl_server, 2),
    .layer_shell = try wlr.LayerShellV1.create(wl_server, 4),
    .xdg_toplevel_decoration_manager = try wlr.XdgDecorationManagerV1.create(self.wl_server),
    .xdg_activation = try wlr.XdgActivationV1.create(self.wl_server),
    .event_loop = event_loop,
    .session = session,
    .compositor = try wlr.Compositor.create(wl_server, 6, renderer),
    .shm = try wlr.Shm.createWithRenderer(wl_server, 1, renderer),
    // TODO: let the user configure a cursor theme and side lua
    .root = undefined,
    .seat = undefined,
    .cursor = undefined,
    .remote_lua_manager = RemoteLuaManager.init() catch Utils.oomPanic(),
    .keymaps = .init(gpa),
    .hooks = try .initCapacity(gpa, 10), // TODO: choose how many slots to start with
    .events = try .init(gpa),
    .remote_lua_clients = .{},
  };

  self.renderer.initServer(wl_server) catch {
      std.log.err("Renderer init failed, exiting with 6", .{});
      std.process.exit(6);
  };

  self.root.init();
  self.seat.init();
  self.cursor.init();

  _ = try wlr.Subcompositor.create(self.wl_server);
  _ = try wlr.DataDeviceManager.create(self.wl_server);
  _ = try wlr.ExportDmabufManagerV1.create(self.wl_server);
  _ = try wlr.Viewporter.create(self.wl_server);
  _ = try wlr.Presentation.create(self.wl_server, self.backend, 2);
  _ = try wlr.ScreencopyManagerV1.create(self.wl_server);
  _ = try wlr.AlphaModifierV1.create(self.wl_server);
  _ = try wlr.DataControlManagerV1.create(self.wl_server);
  _ = try wlr.PrimarySelectionDeviceManagerV1.create(self.wl_server);
  _ = try wlr.SinglePixelBufferManagerV1.create(self.wl_server);
  _ = try wlr.FractionalScaleManagerV1.create(self.wl_server, 1);
  _ = try wlr.XdgOutputManagerV1.create(self.wl_server, self.root.output_layout);
  self.root.scene.setGammaControlManagerV1(try wlr.GammaControlManagerV1.create(self.wl_server));

  // Add event listeners to events
  self.backend.events.new_input.add(&self.new_input);
  self.backend.events.new_output.add(&self.new_output);
  self.xdg_shell.events.new_toplevel.add(&self.new_xdg_toplevel);
  self.xdg_shell.events.new_popup.add(&self.new_xdg_popup);
  self.xdg_toplevel_decoration_manager.events.new_toplevel_decoration.add(&self.new_xdg_toplevel_decoration);
  self.layer_shell.events.new_surface.add(&self.new_layer_surface);
  self.xdg_activation.events.request_activate.add(&self.request_activate);

  self.events.exec("ServerStartPost", .{});
}

pub fn deinit(self: *Server) noreturn {
  self.new_input.link.remove();
  self.new_output.link.remove();
  self.new_xdg_toplevel.link.remove();
  self.new_xdg_popup.link.remove();
  self.new_xdg_toplevel_decoration.link.remove();
  self.new_layer_surface.link.remove();

  self.seat.deinit();
  self.root.deinit();
  self.cursor.deinit();

  self.backend.destroy();

  self.wl_server.destroyClients();
  self.wl_server.destroy();

  std.log.debug("Exiting mez succesfully", .{});
  std.process.exit(0);
}

// --------- Backend event handlers ---------
fn handleNewInput(
  _: *wl.Listener(*wlr.InputDevice),
  device: *wlr.InputDevice
) void {
  switch (device.type) {
    .keyboard => _ = Keyboard.init(device),
    .pointer => server.cursor.wlr_cursor.attachInputDevice(device),
    else => {
      std.log.err(
        "New input request for input that is not a keyboard or pointer: {s}",
        .{device.name orelse "(null)"}
      );
    },
  }

  // We should really only set true capabilities
  server.seat.wlr_seat.setCapabilities(.{
    .pointer = true,
    .keyboard = true,
  });
}

fn handleNewOutput(
  _: *wl.Listener(*wlr.Output),
  wlr_output: *wlr.Output
) void {
  _ = Output.init(wlr_output);
}

fn handleNewXdgToplevel(
  _: *wl.Listener(*wlr.XdgToplevel),
  xdg_toplevel: *wlr.XdgToplevel
) void {
  _ = View.initFromTopLevel(xdg_toplevel);
}

fn handleNewXdgToplevelDecoration(
  _: *wl.Listener(*wlr.XdgToplevelDecorationV1),
  decoration: *wlr.XdgToplevelDecorationV1
) void {
  if(server.root.viewById(@intFromPtr(decoration.toplevel))) |view| {
    view.xdg_toplevel_decoration = decoration;
  }
}

fn handleNewXdgPopup(_: *wl.Listener(*wlr.XdgPopup), _: *wlr.XdgPopup) void {
  std.log.debug("Unimplemented Server.handleNewXdgPopup\n", .{});
}

fn handleNewLayerSurface(
  _: *wl.Listener(*wlr.LayerSurfaceV1),
  layer_surface: *wlr.LayerSurfaceV1
) void {
  std.log.debug("requested layer shell\n", .{});
  if (layer_surface.output == null) {
    if (server.seat.focused_output == null) {
      std.log.err("No output available for new layer surface", .{});
      layer_surface.destroy();
      return;
    }

    layer_surface.output = server.seat.focused_output.?.wlr_output;
  }

  _ = LayerSurface.init(layer_surface);
}

fn handleRequestActivate(
    _: *wl.Listener(*wlr.XdgActivationV1.event.RequestActivate),
    event: *wlr.XdgActivationV1.event.RequestActivate,
) void {
  if(event.surface.data == null) return;

  const scene_node_data: *SceneNodeData = @ptrCast(@alignCast(event.surface.data.?));

  if(scene_node_data.* == .view) {
    if(server.seat.focused_output) |output| {
      if(output.fullscreen) |fullscreen| {
        server.seat.focusSurface(.{ .view = fullscreen });
        return;
      }
    }
    server.seat.focusSurface(Seat.FocusData{ .view = scene_node_data.view });
  } else {
    std.log.warn("Ignoring request to activate non-view", .{});
  }
}