fix pam_path variable assignment during build

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: AnErrupTion
-liberapay: ShiningLea

.github/ISSUE_TEMPLATE/bug.yml

@@ -11,15 +11,11 @@ body:
       options:
         - label: I have looked for any other duplicate issues
           required: true
-        - label: I have reproduced the issue on a fresh install of my OS & Ly with default settings, except ones I will mention
-          required: false
-        - label: I have confirmed this issue also occurs on the latest development version (found in the `master` branch)
-          required: true
   - type: input
     id: version
     attributes:
       label: Ly version
-      description: The output of `ly --version`. Please note that only Ly v1.2.0 and above are supported.
+      description: The output of `ly --version`
       placeholder: 1.1.0-dev.12+2b0301c
     validations:
       required: true
@@ -37,13 +33,6 @@ body:
       description: What did you expect to happen instead?
     validations:
       required: true
-  - type: input
-    id: desktop
-    attributes:
-      label: OS + Desktop environment/Window manager
-      description: Which OS and DE (or WM) did you use when observing the problem?
-    validations:
-      required: true
   - type: textarea
     id: reproduction
     attributes:
@@ -61,13 +50,5 @@ body:
     id: logs
     attributes:
       label: Relevant logs
-      description: |
+      description: Please copy and paste any relevant logs, error messages or any other output. This will be automatically formatted into code, so no need for backticks. Screenshots are accepted if they make life easier for you.
-        Please copy and paste (or attach) any relevant logs, error messages or any other output. This will be automatically formatted into code, so no need for backticks. Screenshots are accepted if they make life easier for you. The log files (located as specified by `/etc/ly/config.ini`) usually contain relevant information about the problem:
-         - The session log is located at `~/.local/state/ly-session.log` by default.
-         - The system log is located at `/var/log/ly.log` by default.
       render: shell
-  - type: textarea
-    id: moreinfo
-    attributes:
-      label: Additional information
-      description: If you have any additional information that might be helpful in reproducing the problem, please provide it here.

.github/pull_request_template.md

@@ -1,12 +0,0 @@
-## What are the changes about?
-
-_Replace this with a brief description of your changes_
-
-## What existing issue does this resolve?
-
-_Replace this with a reference to an existing issue, or N/A if there is none_
-
-## Pre-requisites
-
-- [ ] I have tested & confirmed the changes work locally
-- [ ] I have run `zig fmt` throughout my changes

.gitignore

@@ -3,4 +3,3 @@ zig-cache/
 zig-out/
 valgrind.log
 .zig-cache
-zig-pkg

build.zig

@@ -2,17 +2,8 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 const PatchMap = std.StringHashMap([]const u8);
-const InitSystem = enum {
-    systemd,
-    openrc,
-    runit,
-    s6,
-    dinit,
-    sysvinit,
-    freebsd,
-};
 
-const min_zig_string = "0.16.0";
+const min_zig_string = "0.12.0";
 const current_zig = builtin.zig_version;
 
 // Implementing zig version detection through compile time
@@ -23,39 +14,36 @@ comptime {
     }
 }
 
-const ly_version = std.SemanticVersion{ .major = 1, .minor = 4, .patch = 0 };
+const ly_version = std.SemanticVersion{ .major = 1, .minor = 1, .patch = 0 };
 
 var dest_directory: []const u8 = undefined;
 var config_directory: []const u8 = undefined;
 var prefix_directory: []const u8 = undefined;
 var executable_name: []const u8 = undefined;
-var init_system: InitSystem = undefined;
 var default_tty_str: []const u8 = undefined;
 
+const ProgressNode = if (current_zig.minor == 12) *std.Progress.Node else std.Progress.Node;
+
 pub fn build(b: *std.Build) !void {
     dest_directory = b.option([]const u8, "dest_directory", "Specify a destination directory for installation") orelse "";
     config_directory = b.option([]const u8, "config_directory", "Specify a default config directory (default is /etc). This path gets embedded into the binary") orelse "/etc";
     prefix_directory = b.option([]const u8, "prefix_directory", "Specify a default prefix directory (default is /usr)") orelse "/usr";
     executable_name = b.option([]const u8, "name", "Specify installed executable file name (default is ly)") orelse "ly";
-    init_system = b.option(InitSystem, "init_system", "Specify the target init system (default is systemd)") orelse .systemd;
+
+    const bin_directory = try b.allocator.dupe(u8, config_directory);
+    config_directory = try std.fs.path.join(b.allocator, &[_][]const u8{ dest_directory, config_directory });
 
     const build_options = b.addOptions();
     const version_str = try getVersionStr(b, "ly", ly_version);
     const enable_x11_support = b.option(bool, "enable_x11_support", "Enable X11 support (default is on)") orelse true;
     const default_tty = b.option(u8, "default_tty", "Set the TTY (default is 2)") orelse 2;
-    const fallback_tty = b.option(u8, "fallback_tty", "Set the fallback TTY (default is 2). This value gets embedded into the binary") orelse 2;
-    const fallback_uid_min = b.option(std.posix.uid_t, "fallback_uid_min", "Set the fallback minimum UID (default is 1000). This value gets embedded into the binary") orelse 1000;
-    const fallback_uid_max = b.option(std.posix.uid_t, "fallback_uid_max", "Set the fallback maximum UID (default is 60000). This value gets embedded into the binary") orelse 60000;
 
     default_tty_str = try std.fmt.allocPrint(b.allocator, "{d}", .{default_tty});
 
-    build_options.addOption([]const u8, "config_directory", config_directory);
+    build_options.addOption([]const u8, "config_directory", bin_directory);
     build_options.addOption([]const u8, "prefix_directory", prefix_directory);
     build_options.addOption([]const u8, "version", version_str);
     build_options.addOption(u8, "tty", default_tty);
-    build_options.addOption(u8, "fallback_tty", fallback_tty);
-    build_options.addOption(std.posix.uid_t, "fallback_uid_min", fallback_uid_min);
-    build_options.addOption(std.posix.uid_t, "fallback_uid_max", fallback_uid_max);
     build_options.addOption(bool, "enable_x11_support", enable_x11_support);
 
     const target = b.standardTargetOptions(.{});
@@ -63,25 +51,32 @@ pub fn build(b: *std.Build) !void {
 
     const exe = b.addExecutable(.{
         .name = "ly",
-        .root_module = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
-            .root_source_file = b.path("src/main.zig"),
+        .target = target,
-            .target = target,
+        .optimize = optimize,
-            .optimize = optimize,
-            .link_libc = true,
-        }),
-        .use_llvm = true,
     });
 
-    const ly_ui = b.dependency("ly_ui", .{ .target = target, .optimize = optimize });
+    const zigini = b.dependency("zigini", .{ .target = target, .optimize = optimize });
-    exe.root_module.addImport("ly-ui", ly_ui.module("ly-ui"));
+    exe.root_module.addImport("zigini", zigini.module("zigini"));
 
     exe.root_module.addOptions("build_options", build_options);
 
     const clap = b.dependency("clap", .{ .target = target, .optimize = optimize });
     exe.root_module.addImport("clap", clap.module("clap"));
 
-    exe.root_module.linkSystemLibrary("pam", .{});
+    exe.addIncludePath(b.path("include"));
-    if (enable_x11_support) exe.root_module.linkSystemLibrary("xcb", .{});
+    exe.linkSystemLibrary("pam");
+    if (enable_x11_support) exe.linkSystemLibrary("xcb");
+    exe.linkLibC();
+
+    const translate_c = b.addTranslateC(.{
+        .root_source_file = b.path("include/termbox2.h"),
+        .target = target,
+        .optimize = optimize,
+    });
+    translate_c.defineCMacroRaw("TB_IMPL");
+    const termbox2 = translate_c.addModule("termbox2");
+    exe.root_module.addImport("termbox2", termbox2);
 
     b.installArtifact(exe);
 
@@ -94,26 +89,57 @@ pub fn build(b: *std.Build) !void {
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const installexe_step = b.step("installexe", "Install Ly and the selected init system service");
+    const installexe_step = b.step("installexe", "Install Ly");
-    installexe_step.makeFn = Installer(true).make;
+    installexe_step.makeFn = ExeInstaller(true).make;
     installexe_step.dependOn(b.getInstallStep());
 
-    const installnoconf_step = b.step("installnoconf", "Install Ly and the selected init system service, but not the configuration file");
+    const installnoconf_step = b.step("installnoconf", "Install Ly without its configuration file");
-    installnoconf_step.makeFn = Installer(false).make;
+    installnoconf_step.makeFn = ExeInstaller(false).make;
     installnoconf_step.dependOn(b.getInstallStep());
 
-    const uninstallexe_step = b.step("uninstallexe", "Uninstall Ly and remove the selected init system service");
+    const installsystemd_step = b.step("installsystemd", "Install the Ly systemd service");
-    uninstallexe_step.makeFn = Uninstaller(true).make;
+    installsystemd_step.makeFn = ServiceInstaller(.Systemd).make;
+    installsystemd_step.dependOn(installexe_step);
 
-    const uninstallnoconf_step = b.step("uninstallnoconf", "Uninstall Ly and remove the selected init system service, but keep the configuration directory");
+    const installopenrc_step = b.step("installopenrc", "Install the Ly openrc service");
-    uninstallnoconf_step.makeFn = Uninstaller(false).make;
+    installopenrc_step.makeFn = ServiceInstaller(.Openrc).make;
+    installopenrc_step.dependOn(installexe_step);
+
+    const installrunit_step = b.step("installrunit", "Install the Ly runit service");
+    installrunit_step.makeFn = ServiceInstaller(.Runit).make;
+    installrunit_step.dependOn(installexe_step);
+
+    const installs6_step = b.step("installs6", "Install the Ly s6 service");
+    installs6_step.makeFn = ServiceInstaller(.S6).make;
+    installs6_step.dependOn(installexe_step);
+
+    const installdinit_step = b.step("installdinit", "Install the Ly dinit service");
+    installdinit_step.makeFn = ServiceInstaller(.Dinit).make;
+    installdinit_step.dependOn(installexe_step);
+
+    const uninstallall_step = b.step("uninstallall", "Uninstall Ly and all services");
+    uninstallall_step.makeFn = uninstallall;
 }
 
-pub fn Installer(install_config: bool) type {
+pub fn ExeInstaller(install_conf: bool) type {
     return struct {
-        pub fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) !void {
+        pub fn make(step: *std.Build.Step, _: ProgressNode) !void {
-            var threaded: std.Io.Threaded = .init_single_threaded;
+            try install_ly(step.owner.allocator, install_conf);
-            const io = threaded.io();
+        }
+    };
+}
+
+const InitSystem = enum {
+    Systemd,
+    Openrc,
+    Runit,
+    S6,
+    Dinit,
+};
+
+pub fn ServiceInstaller(comptime init_system: InitSystem) type {
+    return struct {
+        pub fn make(step: *std.Build.Step, _: ProgressNode) !void {
             const allocator = step.owner.allocator;
 
             var patch_map = PatchMap.init(allocator);
@@ -124,255 +150,187 @@ pub fn Installer(install_config: bool) type {
             try patch_map.put("$PREFIX_DIRECTORY", prefix_directory);
             try patch_map.put("$EXECUTABLE_NAME", executable_name);
 
-            // The "-a" argument doesn't exist on FreeBSD, so we use "-p"
+            switch (init_system) {
-            // instead to shutdown the system.
+                .Systemd => {
-            try patch_map.put("$PLATFORM_SHUTDOWN_ARG", if (init_system == .freebsd) "-p" else "-a");
+                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/lib/systemd/system" });
+                    std.fs.cwd().makePath(service_path) catch {};
+                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
+                    defer service_dir.close();
 
-            try install_ly(allocator, io, patch_map, install_config);
+                    const patched_service = try patchFile(allocator, "res/ly.service", patch_map);
-            try install_service(allocator, io, patch_map);
+                    try installText(patched_service, service_dir, service_path, "ly.service", .{ .mode = 0o644 });
+                },
+                .Openrc => {
+                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/init.d" });
+                    std.fs.cwd().makePath(service_path) catch {};
+                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
+                    defer service_dir.close();
+
+                    const patched_service = try patchFile(allocator, "res/ly-openrc", patch_map);
+                    try installText(patched_service, service_dir, service_path, executable_name, .{ .mode = 0o755 });
+                },
+                .Runit => {
+                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/sv/ly" });
+                    std.fs.cwd().makePath(service_path) catch {};
+                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
+                    defer service_dir.close();
+
+                    const supervise_path = try std.fs.path.join(allocator, &[_][]const u8{ service_path, "supervise" });
+
+                    const patched_conf = try patchFile(allocator, "res/ly-runit-service/conf", patch_map);
+                    try installText(patched_conf, service_dir, service_path, "conf", .{});
+
+                    try installFile("res/ly-runit-service/finish", service_dir, service_path, "finish", .{ .override_mode = 0o755 });
+
+                    const patched_run = try patchFile(allocator, "res/ly-runit-service/run", patch_map);
+                    try installText(patched_run, service_dir, service_path, "run", .{ .mode = 0o755 });
+
+                    try std.fs.cwd().symLink("/run/runit/supervise.ly", supervise_path, .{});
+                    std.debug.print("info: installed symlink /run/runit/supervise.ly\n", .{});
+                },
+                .S6 => {
+                    const admin_service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/s6/adminsv/default/contents.d" });
+                    std.fs.cwd().makePath(admin_service_path) catch {};
+                    var admin_service_dir = std.fs.cwd().openDir(admin_service_path, .{}) catch unreachable;
+                    defer admin_service_dir.close();
+
+                    const file = try admin_service_dir.createFile("ly-srv", .{});
+                    file.close();
+
+                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/s6/sv/ly-srv" });
+                    std.fs.cwd().makePath(service_path) catch {};
+                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
+                    defer service_dir.close();
+
+                    const patched_run = try patchFile(allocator, "res/ly-s6/run", patch_map);
+                    try installText(patched_run, service_dir, service_path, "run", .{ .mode = 0o755 });
+
+                    try installFile("res/ly-s6/type", service_dir, service_path, "type", .{});
+                },
+                .Dinit => {
+                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/dinit.d" });
+                    std.fs.cwd().makePath(service_path) catch {};
+                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
+                    defer service_dir.close();
+
+                    const patched_service = try patchFile(allocator, "res/ly-dinit", patch_map);
+                    try installText(patched_service, service_dir, service_path, "ly", .{});
+                },
+            }
         }
     };
 }
 
-fn install_ly(allocator: std.mem.Allocator, io: std.Io, patch_map: PatchMap, install_config: bool) !void {
+fn install_ly(allocator: std.mem.Allocator, install_config: bool) !void {
-    const ly_config_directory = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly" });
+    const ly_config_directory = try std.fs.path.join(allocator, &[_][]const u8{ config_directory, "/ly" });
 
-    std.Io.Dir.cwd().createDirPath(io, ly_config_directory) catch {
+    std.fs.cwd().makePath(ly_config_directory) catch {
         std.debug.print("warn: {s} already exists as a directory.\n", .{ly_config_directory});
     };
 
-    const ly_custom_sessions_directory = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly/custom-sessions" });
+    const ly_lang_path = try std.fs.path.join(allocator, &[_][]const u8{ config_directory, "/ly/lang" });
-
+    std.fs.cwd().makePath(ly_lang_path) catch {
-    std.Io.Dir.cwd().createDirPath(io, ly_custom_sessions_directory) catch {
+        std.debug.print("warn: {s} already exists as a directory.\n", .{config_directory});
-        std.debug.print("warn: {s} already exists as a directory.\n", .{ly_custom_sessions_directory});
-    };
-
-    const ly_lang_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly/lang" });
-    std.Io.Dir.cwd().createDirPath(io, ly_lang_path) catch {
-        std.debug.print("warn: {s} already exists as a directory.\n", .{ly_lang_path});
     };
 
     {
-        const exe_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin" });
+        const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin" });
-        std.Io.Dir.cwd().createDirPath(io, exe_path) catch {
+        if (!std.mem.eql(u8, dest_directory, "")) {
-            if (!std.mem.eql(u8, dest_directory, "")) {
+            std.fs.cwd().makePath(exe_path) catch {
                 std.debug.print("warn: {s} already exists as a directory.\n", .{exe_path});
-            }
+            };
-        };
+        }
 
-        var executable_dir = std.Io.Dir.cwd().openDir(io, exe_path, .{}) catch unreachable;
+        var executable_dir = std.fs.cwd().openDir(exe_path, .{}) catch unreachable;
-        defer executable_dir.close(io);
+        defer executable_dir.close();
 
-        try installFile(io, "zig-out/bin/ly", executable_dir, exe_path, executable_name, .{});
+        try installFile("zig-out/bin/ly", executable_dir, exe_path, executable_name, .{});
     }
 
     {
-        var config_dir = std.Io.Dir.cwd().openDir(io, ly_config_directory, .{}) catch unreachable;
+        var config_dir = std.fs.cwd().openDir(ly_config_directory, .{}) catch unreachable;
-        defer config_dir.close(io);
+        defer config_dir.close();
 
         if (install_config) {
-            const patched_config = try patchFile(allocator, io, "res/config.ini", patch_map);
+            var patch_map = PatchMap.init(allocator);
-            try installText(io, patched_config, config_dir, ly_config_directory, "config.ini", .{});
+            defer patch_map.deinit();
 
-            try installFile(io, "res/startup.sh", config_dir, ly_config_directory, "startup.sh", .{ .permissions = .fromMode(0o755) });
+            try patch_map.put("$DEFAULT_TTY", default_tty_str);
+            try patch_map.put("$CONFIG_DIRECTORY", config_directory);
+            try patch_map.put("$PREFIX_DIRECTORY", prefix_directory);
+
+            const patched_config = try patchFile(allocator, "res/config.ini", patch_map);
+            try installText(patched_config, config_dir, ly_config_directory, "config.ini", .{});
         }
 
-        const patched_example_config = try patchFile(allocator, io, "res/config.ini", patch_map);
+        {
-        try installText(io, patched_example_config, config_dir, ly_config_directory, "config.ini.example", .{});
+            var patch_map = PatchMap.init(allocator);
+            defer patch_map.deinit();
 
-        const patched_setup = try patchFile(allocator, io, "res/setup.sh", patch_map);
+            try patch_map.put("$CONFIG_DIRECTORY", config_directory);
-        try installText(io, patched_setup, config_dir, ly_config_directory, "setup.sh", .{ .permissions = .fromMode(0o755) });
 
-        try installFile(io, "res/example.dur", config_dir, ly_config_directory, "example.dur", .{ .permissions = .fromMode(0o755) });
+            const patched_setup = try patchFile(allocator, "res/setup.sh", patch_map);
-    }
+            try installText(patched_setup, config_dir, ly_config_directory, "setup.sh", .{ .mode = 0o755 });
-
-    {
-        var custom_sessions_dir = std.Io.Dir.cwd().openDir(io, ly_custom_sessions_directory, .{}) catch unreachable;
-        defer custom_sessions_dir.close(io);
-
-        const patched_readme = try patchFile(allocator, io, "res/custom-sessions/README", patch_map);
-        try installText(io, patched_readme, custom_sessions_dir, ly_custom_sessions_directory, "README", .{});
-    }
-
-    {
-        var lang_dir = std.Io.Dir.cwd().openDir(io, ly_lang_path, .{}) catch unreachable;
-        defer lang_dir.close(io);
-
-        const languages = [_][]const u8{
-            "ar.ini",
-            "cat.ini",
-            "cs.ini",
-            "de.ini",
-            "en.ini",
-            "es.ini",
-            "fr.ini",
-            "it.ini",
-            "ja_JP.ini",
-            "lv.ini",
-            "pl.ini",
-            "pt.ini",
-            "pt_BR.ini",
-            "ro.ini",
-            "ru.ini",
-            "sr.ini",
-            "sv.ini",
-            "tr.ini",
-            "uk.ini",
-            "zh_CN.ini",
-        };
-
-        inline for (languages) |language| {
-            try installFile(io, "res/lang/" ++ language, lang_dir, ly_lang_path, language, .{});
         }
     }
 
     {
-        const pam_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/pam.d" });
+        var lang_dir = std.fs.cwd().openDir(ly_lang_path, .{}) catch unreachable;
-        std.Io.Dir.cwd().createDirPath(io, pam_path) catch {
+        defer lang_dir.close();
-            if (!std.mem.eql(u8, dest_directory, "")) {
+
+        try installFile("res/lang/cat.ini", lang_dir, ly_lang_path, "cat.ini", .{});
+        try installFile("res/lang/cs.ini", lang_dir, ly_lang_path, "cs.ini", .{});
+        try installFile("res/lang/de.ini", lang_dir, ly_lang_path, "de.ini", .{});
+        try installFile("res/lang/en.ini", lang_dir, ly_lang_path, "en.ini", .{});
+        try installFile("res/lang/es.ini", lang_dir, ly_lang_path, "es.ini", .{});
+        try installFile("res/lang/fr.ini", lang_dir, ly_lang_path, "fr.ini", .{});
+        try installFile("res/lang/it.ini", lang_dir, ly_lang_path, "it.ini", .{});
+        try installFile("res/lang/pl.ini", lang_dir, ly_lang_path, "pl.ini", .{});
+        try installFile("res/lang/pt.ini", lang_dir, ly_lang_path, "pt.ini", .{});
+        try installFile("res/lang/pt_BR.ini", lang_dir, ly_lang_path, "pt_BR.ini", .{});
+        try installFile("res/lang/ro.ini", lang_dir, ly_lang_path, "ro.ini", .{});
+        try installFile("res/lang/ru.ini", lang_dir, ly_lang_path, "ru.ini", .{});
+        try installFile("res/lang/sr.ini", lang_dir, ly_lang_path, "sr.ini", .{});
+        try installFile("res/lang/sv.ini", lang_dir, ly_lang_path, "sv.ini", .{});
+        try installFile("res/lang/tr.ini", lang_dir, ly_lang_path, "tr.ini", .{});
+        try installFile("res/lang/uk.ini", lang_dir, ly_lang_path, "uk.ini", .{});
+    }
+
+    {
+        const pam_path = try std.fs.path.join(allocator, &[_][]const u8{ config_directory, "/pam.d" });
+        if (!std.mem.eql(u8, dest_directory, "")) {
+            std.fs.cwd().makePath(pam_path) catch {
                 std.debug.print("warn: {s} already exists as a directory.\n", .{pam_path});
-            }
-        };
-
-        var pam_dir = std.Io.Dir.cwd().openDir(io, pam_path, .{}) catch unreachable;
-        defer pam_dir.close(io);
-
-        try installFile(io, if (init_system == .freebsd) "res/pam.d/ly-freebsd" else "res/pam.d/ly-linux", pam_dir, pam_path, "ly", .{ .permissions = .fromMode(0o644) });
-        try installFile(io, if (init_system == .freebsd) "res/pam.d/ly-freebsd-autologin" else "res/pam.d/ly-linux-autologin", pam_dir, pam_path, "ly-autologin", .{ .permissions = .fromMode(0o644) });
-    }
-}
-
-fn install_service(allocator: std.mem.Allocator, io: std.Io, patch_map: PatchMap) !void {
-    switch (init_system) {
-        .systemd => {
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/lib/systemd/system" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const patched_service = try patchFile(allocator, io, "res/ly@.service", patch_map);
-            try installText(io, patched_service, service_dir, service_path, "ly@.service", .{ .permissions = .fromMode(0o644) });
-
-            const patched_kmsconvt_service = try patchFile(allocator, io, "res/ly-kmsconvt@.service", patch_map);
-            try installText(io, patched_kmsconvt_service, service_dir, service_path, "ly-kmsconvt@.service", .{ .permissions = .fromMode(0o644) });
-        },
-        .openrc => {
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/init.d" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const patched_service = try patchFile(allocator, io, "res/ly-openrc", patch_map);
-            try installText(io, patched_service, service_dir, service_path, executable_name, .{ .permissions = .fromMode(0o755) });
-        },
-        .runit => {
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/sv/ly" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const supervise_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ service_path, "supervise" });
-
-            const patched_conf = try patchFile(allocator, io, "res/ly-runit-service/conf", patch_map);
-            try installText(io, patched_conf, service_dir, service_path, "conf", .{});
-
-            try installFile(io, "res/ly-runit-service/finish", service_dir, service_path, "finish", .{ .permissions = .fromMode(0o755) });
-
-            const patched_run = try patchFile(allocator, io, "res/ly-runit-service/run", patch_map);
-            try installText(io, patched_run, service_dir, service_path, "run", .{ .permissions = .fromMode(0o755) });
-
-            std.Io.Dir.cwd().symLink(io, "/run/runit/supervise.ly", supervise_path, .{}) catch |err| {
-                if (err == error.PathAlreadyExists) {
-                    std.debug.print("warn: /run/runit/supervise.ly already exists as a symbolic link.\n", .{});
-                } else {
-                    return err;
-                }
             };
-            std.debug.print("info: installed symlink /run/runit/supervise.ly\n", .{});
-        },
-        .s6 => {
-            const admin_service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/s6/adminsv/default/contents.d" });
-            std.Io.Dir.cwd().createDirPath(io, admin_service_path) catch {};
-            var admin_service_dir = std.Io.Dir.cwd().openDir(io, admin_service_path, .{}) catch unreachable;
-            defer admin_service_dir.close(io);
-
-            const file = try admin_service_dir.createFile(io, "ly-srv", .{});
-            file.close(io);
-
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/s6/sv/ly-srv" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const patched_run = try patchFile(allocator, io, "res/ly-s6/run", patch_map);
-            try installText(io, patched_run, service_dir, service_path, "run", .{ .permissions = .fromMode(0o755) });
-
-            try installFile(io, "res/ly-s6/type", service_dir, service_path, "type", .{});
-        },
-        .dinit => {
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/dinit.d" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const patched_service = try patchFile(allocator, io, "res/ly-dinit", patch_map);
-            try installText(io, patched_service, service_dir, service_path, "ly", .{});
-        },
-        .sysvinit => {
-            const service_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/init.d" });
-            std.Io.Dir.cwd().createDirPath(io, service_path) catch {};
-            var service_dir = std.Io.Dir.cwd().openDir(io, service_path, .{}) catch unreachable;
-            defer service_dir.close(io);
-
-            const patched_service = try patchFile(allocator, io, "res/ly-sysvinit", patch_map);
-            try installText(io, patched_service, service_dir, service_path, "ly", .{ .permissions = .fromMode(0o755) });
-        },
-        .freebsd => {
-            const exe_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin" });
-            var executable_dir = std.Io.Dir.cwd().openDir(io, exe_path, .{}) catch unreachable;
-            defer executable_dir.close(io);
-
-            const patched_wrapper = try patchFile(allocator, io, "res/ly-freebsd-wrapper", patch_map);
-            try installText(io, patched_wrapper, executable_dir, exe_path, "ly_wrapper", .{ .permissions = .fromMode(0o755) });
-        },
-    }
-}
-
-pub fn Uninstaller(uninstall_config: bool) type {
-    return struct {
-        pub fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) !void {
-            var threaded: std.Io.Threaded = .init_single_threaded;
-            const io = threaded.io();
-            const allocator = step.owner.allocator;
-
-            if (uninstall_config) {
-                try deleteTree(allocator, io, config_directory, "/ly", "ly config directory not found");
-            }
-
-            const exe_path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ prefix_directory, "/bin/", executable_name });
-            var success = true;
-            std.Io.Dir.cwd().deleteFile(io, exe_path) catch {
-                std.debug.print("warn: ly executable not found\n", .{});
-                success = false;
-            };
-            if (success) std.debug.print("info: deleted {s}\n", .{exe_path});
-
-            try deleteFile(allocator, io, config_directory, "/pam.d/ly", "ly pam file not found");
-
-            switch (init_system) {
-                .systemd => try deleteFile(allocator, io, prefix_directory, "/lib/systemd/system/ly@.service", "systemd service not found"),
-                .openrc => try deleteFile(allocator, io, config_directory, "/init.d/ly", "openrc service not found"),
-                .runit => try deleteTree(allocator, io, config_directory, "/sv/ly", "runit service not found"),
-                .s6 => {
-                    try deleteTree(allocator, io, config_directory, "/s6/sv/ly-srv", "s6 service not found");
-                    try deleteFile(allocator, io, config_directory, "/s6/adminsv/default/contents.d/ly-srv", "s6 admin service not found");
-                },
-                .dinit => try deleteFile(allocator, io, config_directory, "/dinit.d/ly", "dinit service not found"),
-                .sysvinit => try deleteFile(allocator, io, config_directory, "/init.d/ly", "sysvinit service not found"),
-                .freebsd => try deleteFile(allocator, io, prefix_directory, "/bin/ly_wrapper", "freebsd wrapper not found"),
-            }
         }
+
+        var pam_dir = std.fs.cwd().openDir(pam_path, .{}) catch unreachable;
+        defer pam_dir.close();
+
+        try installFile("res/pam.d/ly", pam_dir, pam_path, "ly", .{ .override_mode = 0o644 });
+    }
+}
+
+pub fn uninstallall(step: *std.Build.Step, _: ProgressNode) !void {
+    const allocator = step.owner.allocator;
+
+    try deleteTree(allocator, config_directory, "/ly", "ly config directory not found");
+
+    const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin/", executable_name });
+    var success = true;
+    std.fs.cwd().deleteFile(exe_path) catch {
+        std.debug.print("warn: ly executable not found\n", .{});
+        success = false;
     };
+    if (success) std.debug.print("info: deleted {s}\n", .{exe_path});
+
+    try deleteFile(allocator, config_directory, "/pam.d/ly", "ly pam file not found");
+    try deleteFile(allocator, prefix_directory, "/lib/systemd/system/ly.service", "systemd service not found");
+    try deleteFile(allocator, config_directory, "/init.d/ly", "openrc service not found");
+    try deleteTree(allocator, config_directory, "/sv/ly", "runit service not found");
+    try deleteTree(allocator, config_directory, "/s6/sv/ly-srv", "s6 service not found");
+    try deleteFile(allocator, config_directory, "/s6/adminsv/default/contents.d/ly-srv", "s6 admin service not found");
+    try deleteFile(allocator, config_directory, "/dinit.d/ly", "dinit service not found");
 }
 
 fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion) ![]const u8 {
@@ -387,11 +345,11 @@ fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion)
         "--match",
         "*.*.*",
         "--tags",
-    }, &status, .ignore) catch {
+    }, &status, .Ignore) catch {
         return version_str;
     };
     var git_describe = std.mem.trim(u8, git_describe_raw, " \n\r");
-    git_describe = std.mem.trimStart(u8, git_describe, "v");
+    git_describe = std.mem.trimLeft(u8, git_describe, "v");
 
     switch (std.mem.count(u8, git_describe, "-")) {
         0 => {
@@ -404,13 +362,13 @@ fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion)
         2 => {
             // Untagged development build (e.g. 0.10.0-dev.2025+ecf0050a9).
             var it = std.mem.splitScalar(u8, git_describe, '-');
-            const tagged_ancestor = std.mem.trimStart(u8, it.first(), "v");
+            const tagged_ancestor = std.mem.trimLeft(u8, it.first(), "v");
             const commit_height = it.next().?;
             const commit_id = it.next().?;
 
             const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
             if (version.order(ancestor_ver) != .gt) {
-                std.debug.print("{s} version '{f}' must be greater than tagged ancestor '{f}'\n", .{ name, version, ancestor_ver });
+                std.debug.print("{s} version '{}' must be greater than tagged ancestor '{}'\n", .{ name, version, ancestor_ver });
                 std.process.exit(1);
             }
 
@@ -431,26 +389,22 @@ fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion)
 }
 
 fn installFile(
-    io: std.Io,
     source_file: []const u8,
-    destination_directory: std.Io.Dir,
+    destination_directory: std.fs.Dir,
     destination_directory_path: []const u8,
     destination_file: []const u8,
-    options: std.Io.Dir.CopyFileOptions,
+    options: std.fs.Dir.CopyFileOptions,
 ) !void {
-    try std.Io.Dir.cwd().copyFile(source_file, destination_directory, destination_file, io, options);
+    try std.fs.cwd().copyFile(source_file, destination_directory, destination_file, options);
     std.debug.print("info: installed {s}/{s}\n", .{ destination_directory_path, destination_file });
 }
 
-fn patchFile(allocator: std.mem.Allocator, io: std.Io, source_file: []const u8, patch_map: PatchMap) ![]const u8 {
+fn patchFile(allocator: std.mem.Allocator, source_file: []const u8, patch_map: PatchMap) ![]const u8 {
-    var file = try std.Io.Dir.cwd().openFile(io, source_file, .{});
+    var file = try std.fs.cwd().openFile(source_file, .{});
-    defer file.close(io);
+    defer file.close();
 
-    const stat = try file.stat(io);
+    const reader = file.reader();
-
+    var text = try reader.readAllAlloc(allocator, std.math.maxInt(u16));
-    var buffer: [4096]u8 = undefined;
-    var reader = file.reader(io, &buffer);
-    var text = try reader.interface.readAlloc(allocator, @intCast(stat.size));
 
     var iterator = patch_map.iterator();
     while (iterator.next()) |kv| {
@@ -463,34 +417,30 @@ fn patchFile(allocator: std.mem.Allocator, io: std.Io, source_file: []const u8,
 }
 
 fn installText(
-    io: std.Io,
     text: []const u8,
-    destination_directory: std.Io.Dir,
+    destination_directory: std.fs.Dir,
     destination_directory_path: []const u8,
     destination_file: []const u8,
-    options: std.Io.File.CreateFlags,
+    options: std.fs.File.CreateFlags,
 ) !void {
-    var file = try destination_directory.createFile(io, destination_file, options);
+    var file = try destination_directory.createFile(destination_file, options);
-    defer file.close(io);
+    defer file.close();
 
-    var buffer: [1024]u8 = undefined;
+    const writer = file.writer();
-    var writer = file.writer(io, &buffer);
+    try writer.writeAll(text);
-    try writer.interface.writeAll(text);
-    try writer.interface.flush();
 
     std.debug.print("info: installed {s}/{s}\n", .{ destination_directory_path, destination_file });
 }
 
 fn deleteFile(
     allocator: std.mem.Allocator,
-    io: std.Io,
     prefix: []const u8,
     file: []const u8,
     warning: []const u8,
 ) !void {
-    const path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, prefix, file });
+    const path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix, file });
 
-    std.Io.Dir.cwd().deleteFile(io, path) catch |err| {
+    std.fs.cwd().deleteFile(path) catch |err| {
         if (err == error.FileNotFound) {
             std.debug.print("warn: {s}\n", .{warning});
             return;
@@ -504,14 +454,13 @@ fn deleteFile(
 
 fn deleteTree(
     allocator: std.mem.Allocator,
-    io: std.Io,
     prefix: []const u8,
     directory: []const u8,
     warning: []const u8,
 ) !void {
-    const path = try std.Io.Dir.path.join(allocator, &[_][]const u8{ dest_directory, prefix, directory });
+    const path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix, directory });
 
-    var dir = std.Io.Dir.cwd().openDir(io, path, .{}) catch |err| {
+    var dir = std.fs.cwd().openDir(path, .{}) catch |err| {
         if (err == error.FileNotFound) {
             std.debug.print("warn: {s}\n", .{warning});
             return;
@@ -519,9 +468,9 @@ fn deleteTree(
 
         return err;
     };
-    dir.close(io);
+    dir.close();
 
-    try std.Io.Dir.cwd().deleteTree(io, path);
+    try std.fs.cwd().deleteTree(path);
 
     std.debug.print("info: deleted {s}\n", .{path});
 }

build.zig.zon

@@ -1,20 +1,16 @@
 .{
-    .name = .ly,
+    .name = "ly",
-    .version = "1.4.0",
+    .version = "1.0.0",
-    .fingerprint = 0xa148ffcc5dc2cb59,
+    .minimum_zig_version = "0.12.0",
-    .minimum_zig_version = "0.16.0",
     .dependencies = .{
-        .ly_ui = .{
-            .path = "ly-ui",
-        },
         .clap = .{
-            .url = "git+https://github.com/Hejsil/zig-clap#fc1e5cc3f6d9d3001112385ee6256d694e959d2f",
+            .url = "https://github.com/Hejsil/zig-clap/archive/refs/tags/0.9.1.tar.gz",
-            .hash = "clap-0.11.0-oBajB7foAQC3Iyn4IVCkUdYaOVVng5IZkSncySTjNig1",
+            .hash = "122062d301a203d003547b414237229b09a7980095061697349f8bef41be9c30266b",
+        },
+        .zigini = .{
+            .url = "https://github.com/Kawaii-Ash/zigini/archive/0bba97a12582928e097f4074cc746c43351ba4c8.tar.gz",
+            .hash = "12209b971367b4066d40ecad4728e6fdffc4cc4f19356d424c2de57f5b69ac7a619a",
         },
     },
-    .paths = .{
+    .paths = .{""},
-        "build.zig",
-        "build.zig.zon",
-        "src",
-    },
 }

create_vendor_tarball.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-tar --zstd -cvf vendor.tar.zst zig-pkg ly-ui/zig-pkg ly-core/zig-pkg

ly-core/build.zig

@@ -1,71 +0,0 @@
-const std = @import("std");
-const Translator = @import("translate_c").Translator;
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-    const mod = b.addModule("ly-core", .{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
-    const zigini = b.dependency("zigini", .{ .target = target, .optimize = optimize });
-    mod.addImport("zigini", zigini.module("zigini"));
-
-    const translate_c = b.dependency("translate_c", .{
-        .target = target,
-        .optimize = optimize,
-    });
-
-    addCImport(b, mod, translate_c, target, optimize, "pam", "#include <security/pam_appl.h>");
-    addCImport(b, mod, translate_c, target, optimize, "utmp", "#include <utmpx.h>");
-    addCImport(b, mod, translate_c, target, optimize, "xcb", "#include <xcb/xcb.h>");
-    if (target.result.os.tag == .freebsd) {
-        addCImport(b, mod, translate_c, target, optimize, "pwd",
-            \\#include <pwd.h>
-            \\#include <sys/types.h>
-            \\#include <login_cap.h>
-        );
-    } else {
-        addCImport(b, mod, translate_c, target, optimize, "pwd", "#include <pwd.h>");
-    }
-    addCImport(b, mod, translate_c, target, optimize, "stdlib", "#include <stdlib.h>");
-    addCImport(b, mod, translate_c, target, optimize, "unistd", "#include <unistd.h>");
-    addCImport(b, mod, translate_c, target, optimize, "grp", "#include <grp.h>");
-    addCImport(b, mod, translate_c, target, optimize, "system_time", "#include <sys/time.h>");
-    addCImport(b, mod, translate_c, target, optimize, "time", "#include <time.h>");
-
-    if (target.result.os.tag == .linux) {
-        addCImport(b, mod, translate_c, target, optimize, "kd", "#include <sys/kd.h>");
-        addCImport(b, mod, translate_c, target, optimize, "vt", "#include <sys/vt.h>");
-    } else if (target.result.os.tag == .freebsd) {
-        addCImport(b, mod, translate_c, target, optimize, "kbio", "#include <sys/kbio.h>");
-        addCImport(b, mod, translate_c, target, optimize, "consio", "#include <sys/consio.h>");
-    }
-
-    const mod_tests = b.addTest(.{
-        .root_module = mod,
-    });
-    const run_mod_tests = b.addRunArtifact(mod_tests);
-
-    const test_step = b.step("test", "Run tests");
-    test_step.dependOn(&run_mod_tests.step);
-}
-
-fn addCImport(
-    b: *std.Build,
-    mod: *std.Build.Module,
-    translate_c: *std.Build.Dependency,
-    target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
-    comptime name: []const u8,
-    comptime bytes: []const u8,
-) void {
-    const pam: Translator = .init(translate_c, .{
-        .c_source_file = b.addWriteFiles().add(name ++ ".h", bytes),
-        .target = target,
-        .optimize = optimize,
-    });
-    mod.addImport(name, pam.mod);
-}

ly-core/build.zig.zon

@@ -1,21 +0,0 @@
-.{
-    .name = .ly_core,
-    .version = "1.0.0",
-    .fingerprint = 0xddda7afda795472,
-    .minimum_zig_version = "0.16.0",
-    .dependencies = .{
-        .zigini = .{
-            .url = "git+https://github.com/AshAmetrine/zigini?ref=master#a665d081dda42664a96da2840ea09c5ccf9d0692",
-            .hash = "zigini-0.5.0-BSkB7e9WAACfyCBABNZiWL3gFMw18GKn3qBcPs8L1Ec1",
-        },
-        .translate_c = .{
-            .url = "git+https://codeberg.org/ziglang/translate-c#7a1a9fdc4ab00835748a6657ecbb835e3d5d45f7",
-            .hash = "translate_c-0.0.0-Q_BUWvP1BgCjAk6PWv5286tOlvzD9-X-NkuTzh0KxY0Q",
-        },
-    },
-    .paths = .{
-        "build.zig",
-        "build.zig.zon",
-        "src",
-    },
-}

ly-core/src/LogFile.zig

@@ -1,71 +0,0 @@
-const std = @import("std");
-const interop = @import("interop.zig");
-
-const LogFile = @This();
-
-path: []const u8,
-could_open_log_file: bool = undefined,
-file: std.Io.File = undefined,
-buffer: []u8,
-file_writer: std.Io.File.Writer = undefined,
-
-pub fn init(io: std.Io, path: []const u8, buffer: []u8) !LogFile {
-    var log_file = LogFile{ .path = path, .buffer = buffer };
-    log_file.could_open_log_file = try openLogFile(io, path, &log_file);
-    return log_file;
-}
-
-pub fn reinit(self: *LogFile, io: std.Io) !void {
-    self.could_open_log_file = try openLogFile(io, self.path, self);
-}
-
-pub fn deinit(self: *LogFile, io: std.Io) void {
-    self.file.close(io);
-}
-
-pub fn info(self: *LogFile, io: std.Io, category: []const u8, comptime message: []const u8, args: anytype) !void {
-    var buffer: [128:0]u8 = undefined;
-    const time = interop.timeAsString(io, &buffer, "%Y-%m-%d %H:%M:%S");
-
-    try self.file_writer.interface.print("{s} [info/{s}] ", .{ time, category });
-    try self.file_writer.interface.print(message, args);
-    try self.file_writer.interface.writeByte('\n');
-    try self.file_writer.interface.flush();
-}
-
-pub fn err(self: *LogFile, io: std.Io, category: []const u8, comptime message: []const u8, args: anytype) !void {
-    var buffer: [128:0]u8 = undefined;
-    const time = interop.timeAsString(io, &buffer, "%Y-%m-%d %H:%M:%S");
-
-    try self.file_writer.interface.print("{s} [err/{s}] ", .{ time, category });
-    try self.file_writer.interface.print(message, args);
-    try self.file_writer.interface.writeByte('\n');
-    try self.file_writer.interface.flush();
-}
-
-fn openLogFile(io: std.Io, path: []const u8, log_file: *LogFile) !bool {
-    var could_open_log_file = true;
-    open_log_file: {
-        log_file.file = std.Io.Dir.cwd().openFile(io, path, .{ .mode = .write_only }) catch std.Io.Dir.cwd().createFile(io, path, .{ .permissions = .fromMode(0o666) }) catch {
-            // If we could neither open an existing log file nor create a new
-            // one, abort.
-            could_open_log_file = false;
-            break :open_log_file;
-        };
-    }
-
-    if (!could_open_log_file) {
-        log_file.file = try std.Io.Dir.openFileAbsolute(io, "/dev/null", .{ .mode = .write_only });
-    }
-
-    var log_file_writer = log_file.file.writer(io, log_file.buffer);
-
-    // Seek to the end of the log file
-    if (could_open_log_file) {
-        const stat = try log_file.file.stat(io);
-        try log_file_writer.seekTo(stat.size);
-    }
-
-    log_file.file_writer = log_file_writer;
-    return could_open_log_file;
-}

ly-core/src/SharedError.zig

@@ -1,52 +0,0 @@
-const std = @import("std");
-
-const ErrInt = std.meta.Int(.unsigned, @bitSizeOf(anyerror));
-const PaddingInt = std.meta.Int(.unsigned, 8 - (@bitSizeOf(ErrInt) + @bitSizeOf(bool)) % 8);
-
-const ErrorHandler = packed struct {
-    has_error: bool = false,
-    err_int: ErrInt = 0,
-    padding: PaddingInt = 0,
-};
-
-const SharedError = @This();
-
-data: []align(std.heap.page_size_min) u8,
-write_error_event_fn: ?*const fn (anyerror, *anyopaque) anyerror!void,
-ctx: ?*anyopaque,
-
-pub fn init(
-    write_error_event_fn: ?*const fn (anyerror, *anyopaque) anyerror!void,
-    ctx: ?*anyopaque,
-) !SharedError {
-    const data = try std.posix.mmap(null, @sizeOf(ErrorHandler), .{ .READ = true, .WRITE = true }, .{ .TYPE = .SHARED, .ANONYMOUS = true }, -1, 0);
-
-    return .{
-        .data = data,
-        .write_error_event_fn = write_error_event_fn,
-        .ctx = ctx,
-    };
-}
-
-pub fn deinit(self: *SharedError) void {
-    std.posix.munmap(self.data);
-}
-
-pub fn writeError(self: SharedError, err: anyerror) void {
-    var writer: std.Io.Writer = .fixed(self.data);
-    writer.writeStruct(ErrorHandler{ .has_error = true, .err_int = @intFromError(err) }, .native) catch {};
-
-    if (self.write_error_event_fn) |write_error_event_fn| {
-        @call(.auto, write_error_event_fn, .{ err, self.ctx.? }) catch {};
-    }
-}
-
-pub fn readError(self: SharedError) ?anyerror {
-    var reader: std.Io.Reader = .fixed(self.data);
-    const err_handler = try reader.takeStruct(ErrorHandler, .native);
-
-    if (err_handler.has_error)
-        return @errorFromInt(err_handler.err_int);
-
-    return null;
-}

ly-core/src/UidRange.zig

@@ -1,6 +0,0 @@
-const std = @import("std");
-
-// We set both values to 0 by default so that, in case they aren't present in
-// the login.defs for some reason, then only the root username will be shown
-uid_min: std.posix.uid_t = 0,
-uid_max: std.posix.uid_t = 0,

ly-core/src/interop.zig

@@ -1,384 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const UidRange = @import("UidRange.zig");
-const pwd = @import("pwd");
-const stdlib = @import("stdlib");
-const unistd = @import("unistd");
-const grp = @import("grp");
-const system_time = @import("system_time");
-const time = @import("time");
-
-pub const pam = @import("pam");
-pub const utmp = @import("utmp");
-// Exists for X11 support only
-pub const xcb = @import("xcb");
-
-pub const TimeOfDay = struct {
-    seconds: i64,
-    microseconds: i64,
-};
-
-pub const UsernameEntry = struct {
-    username: ?[]const u8,
-    uid: std.posix.uid_t,
-    gid: std.posix.gid_t,
-    home: ?[]const u8,
-    shell: ?[]const u8,
-    passwd_struct: [*c]pwd.passwd,
-};
-
-// Contains the platform-specific code
-fn PlatformStruct() type {
-    return switch (builtin.os.tag) {
-        .linux => struct {
-            pub const kd = @import("kd");
-            pub const vt = @import("vt");
-
-            pub const LedState = c_char;
-            pub const get_led_state = kd.KDGKBLED;
-            pub const set_led_state = kd.KDSKBLED;
-            pub const numlock_led = kd.K_NUMLOCK;
-            pub const capslock_led = kd.K_CAPSLOCK;
-            pub const vt_activate = vt.VT_ACTIVATE;
-            pub const vt_waitactive = vt.VT_WAITACTIVE;
-
-            pub fn setUserContextImpl(username: [*:0]const u8, entry: UsernameEntry) !void {
-                const status = grp.initgroups(username, @intCast(entry.gid));
-                if (status != 0) return error.GroupInitializationFailed;
-
-                if (isError(std.posix.system.setgid(@intCast(entry.gid)))) return error.SetUserGidFailed;
-                if (isError(std.posix.system.setuid(@intCast(entry.uid)))) return error.SetUserUidFailed;
-            }
-
-            // Procedure:
-            // 1. Open /proc/self/stat to retrieve the tty_nr field
-            // 2. Parse the tty_nr field to extract the major and minor device
-            //    numbers
-            // 3. Then, read every /sys/class/tty/[dir]/dev, where [dir] is
-            //    every sub-directory
-            // 4. Finally, compare the major and minor device numbers with the
-            //    extracted values. If they correspond, parse [dir] to get the
-            //    TTY ID
-            pub fn getActiveTtyImpl(allocator: std.mem.Allocator, io: std.Io, use_kmscon_vt: bool) !u8 {
-                var file_buffer: [256]u8 = undefined;
-
-                if (use_kmscon_vt) {
-                    var file = try std.Io.Dir.openFileAbsolute(io, "/sys/class/tty/tty0/active", .{});
-                    defer file.close(io);
-
-                    var reader = file.reader(io, &file_buffer);
-                    var buffer: [16]u8 = undefined;
-                    const read = try readBuffer(&reader.interface, &buffer);
-
-                    const tty = buffer[0..(read - 1)];
-                    return std.fmt.parseInt(u8, tty["tty".len..], 10);
-                }
-
-                var tty_major: u16 = undefined;
-                var tty_minor: u16 = undefined;
-
-                {
-                    var file = try std.Io.Dir.openFileAbsolute(io, "/proc/self/stat", .{});
-                    defer file.close(io);
-
-                    var reader = file.reader(io, &file_buffer);
-                    var buffer: [1024]u8 = undefined;
-                    const read = try readBuffer(&reader.interface, &buffer);
-
-                    var iterator = std.mem.splitScalar(u8, buffer[0..read], ' ');
-                    var fields: [52][]const u8 = undefined;
-                    var index: usize = 0;
-
-                    while (iterator.next()) |field| {
-                        fields[index] = field;
-                        index += 1;
-                    }
-
-                    const tty_nr = try std.fmt.parseInt(u16, fields[6], 10);
-                    tty_major = tty_nr / 256;
-                    tty_minor = tty_nr % 256;
-                }
-
-                var directory = try std.Io.Dir.openDirAbsolute(io, "/sys/class/tty", .{ .iterate = true });
-                defer directory.close(io);
-
-                var iterator = directory.iterate();
-                while (try iterator.next(io)) |entry| {
-                    const path = try std.fmt.allocPrint(allocator, "/sys/class/tty/{s}/dev", .{entry.name});
-                    defer allocator.free(path);
-
-                    var file = try std.Io.Dir.openFileAbsolute(io, path, .{});
-                    defer file.close(io);
-
-                    var reader = file.reader(io, &file_buffer);
-                    var buffer: [16]u8 = undefined;
-                    const read = try readBuffer(&reader.interface, &buffer);
-
-                    var device_iterator = std.mem.splitScalar(u8, buffer[0..(read - 1)], ':');
-                    const device_major_str = device_iterator.next() orelse continue;
-                    const device_minor_str = device_iterator.next() orelse continue;
-
-                    const device_major = try std.fmt.parseInt(u8, device_major_str, 10);
-                    const device_minor = try std.fmt.parseInt(u8, device_minor_str, 10);
-
-                    if (device_major == tty_major and device_minor == tty_minor) {
-                        const tty_id_str = entry.name["tty".len..];
-                        return try std.fmt.parseInt(u8, tty_id_str, 10);
-                    }
-                }
-
-                return error.NoTtyFound;
-            }
-
-            // This is very bad parsing, but we only need to get 2 values..
-            // and the format of the file seems to be standard? So this should
-            // be fine...
-            pub fn getUserIdRange(allocator: std.mem.Allocator, io: std.Io, file_path: []const u8) !UidRange {
-                const login_defs_file = try std.Io.Dir.cwd().openFile(io, file_path, .{});
-                defer login_defs_file.close(io);
-
-                var buffer: [4096]u8 = undefined;
-                var reader = login_defs_file.reader(io, &buffer);
-
-                const login_defs_buffer = try reader.interface.allocRemaining(allocator, .unlimited);
-                defer allocator.free(login_defs_buffer);
-
-                var iterator = std.mem.splitScalar(u8, login_defs_buffer, '\n');
-                var uid_range = UidRange{};
-                var nameFound = false;
-
-                while (iterator.next()) |line| {
-                    const trimmed_line = std.mem.trim(u8, line, " \n\r\t");
-
-                    if (std.mem.startsWith(u8, trimmed_line, "UID_MIN")) {
-                        uid_range.uid_min = try parseValue(std.posix.uid_t, "UID_MIN", trimmed_line);
-                        nameFound = true;
-                    } else if (std.mem.startsWith(u8, trimmed_line, "UID_MAX")) {
-                        uid_range.uid_max = try parseValue(std.posix.uid_t, "UID_MAX", trimmed_line);
-                        nameFound = true;
-                    }
-                }
-
-                if (!nameFound) return error.UidNameNotFound;
-
-                return uid_range;
-            }
-
-            fn parseValue(comptime T: type, name: []const u8, buffer: []const u8) !T {
-                var iterator = std.mem.splitAny(u8, buffer, " \t");
-                var maybe_value: ?T = null;
-
-                while (iterator.next()) |slice| {
-                    // Skip the slice if it's empty (whitespace) or is the name of the
-                    // property (e.g. UID_MIN or UID_MAX)
-                    if (slice.len == 0 or std.mem.eql(u8, slice, name)) continue;
-                    maybe_value = std.fmt.parseInt(T, slice, 10) catch continue;
-                }
-
-                return maybe_value orelse error.ValueNotFound;
-            }
-
-            fn readBuffer(reader: *std.Io.Reader, buffer: []u8) !usize {
-                var bytes_read: usize = 0;
-                var byte: u8 = try reader.takeByte();
-
-                while (byte != 0 and bytes_read < buffer.len) {
-                    buffer[bytes_read] = byte;
-                    bytes_read += 1;
-                    byte = reader.takeByte() catch break;
-                }
-
-                return bytes_read;
-            }
-        },
-        .freebsd => struct {
-            pub const kbio = @import("kbio");
-            pub const consio = @import("consio");
-
-            pub const LedState = c_int;
-            pub const get_led_state = kbio.KDGETLED;
-            pub const set_led_state = kbio.KDSETLED;
-            pub const numlock_led = kbio.LED_NUM;
-            pub const capslock_led = kbio.LED_CAP;
-            pub const vt_activate = consio.VT_ACTIVATE;
-            pub const vt_waitactive = consio.VT_WAITACTIVE;
-
-            const FREEBSD_UID_MIN = 1000;
-            const FREEBSD_UID_MAX = 32000;
-
-            pub fn setUserContextImpl(username: [*:0]const u8, entry: UsernameEntry) !void {
-                // FreeBSD has initgroups() in unistd
-                const status = unistd.initgroups(username, @intCast(entry.gid));
-                if (status != 0) return error.GroupInitializationFailed;
-
-                // FreeBSD sets the GID and UID with setusercontext()
-                const result = pwd.setusercontext(null, entry.passwd_struct, @intCast(entry.uid), pwd.LOGIN_SETALL);
-                if (result != 0) return error.SetUserUidFailed;
-            }
-
-            pub fn getActiveTtyImpl(_: std.mem.Allocator, _: std.Io, _: bool) !u8 {
-                return error.FeatureUnimplemented;
-            }
-
-            pub fn getUserIdRange(_: std.mem.Allocator, _: std.Io, _: []const u8) !UidRange {
-                return .{
-                    // Hardcoded default values chosen from
-                    // /usr/src/usr.sbin/pw/pw_conf.c
-                    .uid_min = FREEBSD_UID_MIN,
-                    .uid_max = FREEBSD_UID_MAX,
-                };
-            }
-        },
-        else => @compileError("Unsupported target: " ++ builtin.os.tag),
-    };
-}
-
-const platform_struct = PlatformStruct();
-
-// TODO 0.16.0: Can we get away with this?
-pub fn isError(result: anytype) bool {
-    if (@typeInfo(@TypeOf(result)).int.signedness == .signed) {
-        return result < 0;
-    }
-
-    if (@typeInfo(@TypeOf(result)).int.signedness == .unsigned) {
-        return switch (builtin.os.tag) {
-            .linux => std.os.linux.errno(result) != .SUCCESS,
-            else => @compileError("interop.isError() not implemented for current target!"),
-        };
-    }
-
-    unreachable;
-}
-
-pub fn supportsUnicode() bool {
-    return builtin.os.tag == .linux or builtin.os.tag == .freebsd;
-}
-
-pub fn timeAsString(io: std.Io, buf: [:0]u8, format: [:0]const u8) []u8 {
-    const timer: isize = @intCast(std.Io.Timestamp.now(io, .real).toSeconds());
-    const tm_info = time.localtime(&timer);
-    const len = time.strftime(buf, buf.len, format, tm_info);
-
-    return buf[0..len];
-}
-
-pub fn getTimeOfDay() !TimeOfDay {
-    var tv: system_time.timeval = undefined;
-    const status = system_time.gettimeofday(&tv, null);
-
-    if (status != 0) return error.FailedToGetTimeOfDay;
-
-    return .{
-        .seconds = @intCast(tv.tv_sec),
-        .microseconds = @intCast(tv.tv_usec),
-    };
-}
-
-pub fn getActiveTty(allocator: std.mem.Allocator, io: std.Io, use_kmscon_vt: bool) !u8 {
-    return platform_struct.getActiveTtyImpl(allocator, io, use_kmscon_vt);
-}
-
-pub fn switchTty(tty: u8) !void {
-    var status = std.c.ioctl(std.posix.STDIN_FILENO, platform_struct.vt_activate, tty);
-    if (status != 0) return error.FailedToActivateTty;
-
-    status = std.c.ioctl(std.posix.STDIN_FILENO, platform_struct.vt_waitactive, tty);
-    if (status != 0) return error.FailedToWaitForActiveTty;
-}
-
-pub fn getLockState() !struct {
-    numlock: bool,
-    capslock: bool,
-} {
-    var led: platform_struct.LedState = undefined;
-    const status = std.c.ioctl(std.posix.STDIN_FILENO, platform_struct.get_led_state, &led);
-    if (status != 0) return error.FailedToGetLockState;
-
-    return .{
-        .numlock = (led & platform_struct.numlock_led) != 0,
-        .capslock = (led & platform_struct.capslock_led) != 0,
-    };
-}
-
-pub fn setNumlock(val: bool) !void {
-    var led: platform_struct.LedState = undefined;
-    var status = std.c.ioctl(std.posix.STDIN_FILENO, platform_struct.get_led_state, &led);
-    if (status != 0) return error.FailedToGetNumlock;
-
-    const numlock = (led & platform_struct.numlock_led) != 0;
-    if (numlock != val) {
-        status = std.c.ioctl(std.posix.STDIN_FILENO, platform_struct.set_led_state, led ^ platform_struct.numlock_led);
-        if (status != 0) return error.FailedToSetNumlock;
-    }
-}
-
-pub fn setUserContext(allocator: std.mem.Allocator, entry: UsernameEntry) !void {
-    const username_z = try allocator.dupeZ(u8, entry.username.?);
-    defer allocator.free(username_z);
-
-    return platform_struct.setUserContextImpl(username_z.ptr, entry);
-}
-
-pub fn setUserShell(entry: *UsernameEntry) void {
-    unistd.setusershell();
-
-    const shell = unistd.getusershell();
-    entry.shell = std.mem.span(shell);
-
-    unistd.endusershell();
-}
-
-pub fn setEnvironmentVariable(allocator: std.mem.Allocator, name: []const u8, value: []const u8, replace: bool) !void {
-    const name_z = try allocator.dupeZ(u8, name);
-    defer allocator.free(name_z);
-
-    const value_z = try allocator.dupeZ(u8, value);
-    defer allocator.free(value_z);
-
-    const status = stdlib.setenv(name_z.ptr, value_z.ptr, @intFromBool(replace));
-    if (status != 0) return error.SetEnvironmentVariableFailed;
-}
-
-pub fn putEnvironmentVariable(name_and_value: [*c]u8) !void {
-    const status = stdlib.putenv(name_and_value);
-    if (status != 0) return error.PutEnvironmentVariableFailed;
-}
-
-pub fn getNextUsernameEntry() ?UsernameEntry {
-    const entry = pwd.getpwent();
-    if (entry == null) return null;
-
-    return .{
-        .username = if (entry.*.pw_name) |name| std.mem.span(name) else null,
-        .uid = @intCast(entry.*.pw_uid),
-        .gid = @intCast(entry.*.pw_gid),
-        .home = if (entry.*.pw_dir) |dir| std.mem.span(dir) else null,
-        .shell = if (entry.*.pw_shell) |shell| std.mem.span(shell) else null,
-        .passwd_struct = entry,
-    };
-}
-
-pub fn getUsernameEntry(username: [:0]const u8) ?UsernameEntry {
-    const entry = pwd.getpwnam(username);
-    if (entry == null) return null;
-
-    return .{
-        .username = if (entry.*.pw_name) |name| std.mem.span(name) else null,
-        .uid = @intCast(entry.*.pw_uid),
-        .gid = @intCast(entry.*.pw_gid),
-        .home = if (entry.*.pw_dir) |dir| std.mem.span(dir) else null,
-        .shell = if (entry.*.pw_shell) |shell| std.mem.span(shell) else null,
-        .passwd_struct = entry,
-    };
-}
-
-pub fn closePasswordDatabase() void {
-    pwd.endpwent();
-}
-
-// This is very bad parsing, but we only need to get 2 values... and the format
-// of the file doesn't seem to be standard? So this should be fine...
-pub fn getUserIdRange(allocator: std.mem.Allocator, io: std.Io, file_path: []const u8) !UidRange {
-    return platform_struct.getUserIdRange(allocator, io, file_path);
-}

ly-core/src/root.zig

@@ -1,78 +0,0 @@
-const std = @import("std");
-
-pub const ini = @import("zigini");
-
-pub const interop = @import("interop.zig");
-pub const UidRange = @import("UidRange.zig");
-pub const LogFile = @import("LogFile.zig");
-pub const SharedError = @import("SharedError.zig");
-
-pub fn IniParser(comptime Struct: type) type {
-    return struct {
-        const Self = @This();
-        const temporary_allocator = std.heap.page_allocator;
-
-        pub const Error = struct {
-            type_name: []const u8,
-            key: []const u8,
-            value: []const u8,
-            error_name: []const u8,
-        };
-        pub var global_errors: std.ArrayList(Error) = .empty;
-
-        ini_struct: ini.Ini(Struct),
-        structure: Struct,
-        maybe_load_error: ?anyerror,
-        errors: std.ArrayList(Error),
-
-        pub fn init(
-            allocator: std.mem.Allocator,
-            io: std.Io,
-            path: []const u8,
-            field_handler: ?fn (allocator: std.mem.Allocator, field: ini.IniField) ?ini.IniField,
-        ) !Self {
-            var ini_struct = ini.Ini(Struct).init(allocator);
-            errdefer ini_struct.deinit();
-
-            var maybe_load_error: ?anyerror = null;
-
-            const structure = ini_struct.readFileToStruct(io, path, .{
-                .fieldHandler = field_handler,
-                .errorHandler = errorHandler,
-                .comment_characters = "#",
-            }) catch |err| load_error: {
-                maybe_load_error = err;
-                break :load_error Struct{};
-            };
-
-            return .{
-                .ini_struct = ini_struct,
-                .structure = structure,
-                .maybe_load_error = maybe_load_error,
-                .errors = global_errors,
-            };
-        }
-
-        pub fn deinit(self: *Self) void {
-            self.ini_struct.deinit();
-
-            for (0..global_errors.items.len) |i| {
-                const err = global_errors.items[i];
-                temporary_allocator.free(err.type_name);
-                temporary_allocator.free(err.key);
-                temporary_allocator.free(err.value);
-            }
-
-            global_errors.deinit(temporary_allocator);
-        }
-
-        fn errorHandler(type_name: []const u8, key: []const u8, value: []const u8, err: anyerror) void {
-            global_errors.append(temporary_allocator, .{
-                .type_name = temporary_allocator.dupe(u8, type_name) catch return,
-                .key = temporary_allocator.dupe(u8, key) catch return,
-                .value = temporary_allocator.dupe(u8, value) catch return,
-                .error_name = @errorName(err),
-            }) catch return;
-        }
-    };
-}

ly-ui/build.zig

@@ -1,53 +0,0 @@
-const std = @import("std");
-const Translator = @import("translate_c").Translator;
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-    const mod = b.addModule("ly-ui", .{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
-    const ly_core = b.dependency("ly_core", .{ .target = target, .optimize = optimize });
-    mod.addImport("ly-core", ly_core.module("ly-core"));
-
-    const termbox_dep = b.dependency("termbox2", .{
-        .target = target,
-        .optimize = optimize,
-    });
-
-    const translate_c_dep = b.dependency("translate_c", .{
-        .target = target,
-        .optimize = optimize,
-    });
-
-    const termbox2: Translator = .init(translate_c_dep, .{
-        .c_source_file = termbox_dep.path("termbox2.h"),
-        .target = target,
-        .optimize = optimize,
-    });
-    termbox2.defineCMacro("TB_IMPL", null);
-    // TODO 0.16.0: Workaround until Aro gets better...
-    // https://codeberg.org/ziglang/translate-c/issues/319
-    termbox2.defineCMacro("_XOPEN_SOURCE", "700");
-    termbox2.defineCMacro("TB_OPT_ATTR_W", "32"); // Enable 24-bit color support + styling (32-bit)
-    // TODO 0.16.0: Including <fcntl.h> with -OReleaseSafe causes
-    // __attribute__(__error__()) to be called. Below
-    // is the workaround.
-    termbox2.defineCMacro("_FORTIFY_SOURCE", "0");
-    // TODO 0.16.0: Needed for now
-    if (target.result.os.tag == .freebsd) {
-        termbox2.defineCMacro("__BSD_VISIBLE", "1");
-    }
-    mod.addImport("termbox2", termbox2.mod);
-
-    const mod_tests = b.addTest(.{
-        .root_module = mod,
-    });
-    const run_mod_tests = b.addRunArtifact(mod_tests);
-
-    const test_step = b.step("test", "Run tests");
-    test_step.dependOn(&run_mod_tests.step);
-}

ly-ui/build.zig.zon

@@ -1,24 +0,0 @@
-.{
-    .name = .ly_ui,
-    .version = "1.0.0",
-    .fingerprint = 0x8d11bf85a74ec803,
-    .minimum_zig_version = "0.16.0",
-    .dependencies = .{
-        .ly_core = .{
-            .path = "../ly-core",
-        },
-        .termbox2 = .{
-            .url = "git+https://github.com/AnErrupTion/termbox2?ref=master#c7f241e8888ce243e1748b05c26a42fcfaaad936",
-            .hash = "N-V-__8AAAUXBQD6Fwpi9m0MBqWXFFaqW5l1lVrJC2Ynj7a-",
-        },
-        .translate_c = .{
-            .url = "git+https://codeberg.org/ziglang/translate-c#7a1a9fdc4ab00835748a6657ecbb835e3d5d45f7",
-            .hash = "translate_c-0.0.0-Q_BUWvP1BgCjAk6PWv5286tOlvzD9-X-NkuTzh0KxY0Q",
-        },
-    },
-    .paths = .{
-        "build.zig",
-        "build.zig.zon",
-        "src",
-    },
-}

ly-ui/src/Cell.zig

@@ -1,21 +0,0 @@
-const TerminalBuffer = @import("TerminalBuffer.zig");
-
-const Cell = @This();
-
-ch: u32,
-fg: u32,
-bg: u32,
-
-pub fn init(ch: u32, fg: u32, bg: u32) Cell {
-    return .{
-        .ch = ch,
-        .fg = fg,
-        .bg = bg,
-    };
-}
-
-pub fn put(self: Cell, x: usize, y: usize) void {
-    if (self.ch == 0) return;
-
-    TerminalBuffer.setCell(x, y, self);
-}

ly-ui/src/Position.zig

@@ -1,221 +0,0 @@
-const Position = @This();
-
-x: usize,
-y: usize,
-
-pub fn init(x: usize, y: usize) Position {
-    return .{
-        .x = x,
-        .y = y,
-    };
-}
-
-pub fn add(self: Position, other: Position) Position {
-    return .{
-        .x = self.x + other.x,
-        .y = self.y + other.y,
-    };
-}
-
-pub fn addIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x + if (condition) other.x else 0,
-        .y = self.y + if (condition) other.y else 0,
-    };
-}
-
-pub fn addX(self: Position, x: usize) Position {
-    return .{
-        .x = self.x + x,
-        .y = self.y,
-    };
-}
-
-pub fn addY(self: Position, y: usize) Position {
-    return .{
-        .x = self.x,
-        .y = self.y + y,
-    };
-}
-
-pub fn addXIf(self: Position, x: usize, condition: bool) Position {
-    return .{
-        .x = self.x + if (condition) x else 0,
-        .y = self.y,
-    };
-}
-
-pub fn addYIf(self: Position, y: usize, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = self.y + if (condition) y else 0,
-    };
-}
-
-pub fn addXFrom(self: Position, other: Position) Position {
-    return .{
-        .x = self.x + other.x,
-        .y = self.y,
-    };
-}
-
-pub fn addYFrom(self: Position, other: Position) Position {
-    return .{
-        .x = self.x,
-        .y = self.y + other.y,
-    };
-}
-
-pub fn addXFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x + if (condition) other.x else 0,
-        .y = self.y,
-    };
-}
-
-pub fn addYFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = self.y + if (condition) other.y else 0,
-    };
-}
-
-pub fn remove(self: Position, other: Position) Position {
-    return .{
-        .x = self.x - other.x,
-        .y = self.y - other.y,
-    };
-}
-
-pub fn removeIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x - if (condition) other.x else 0,
-        .y = self.y - if (condition) other.y else 0,
-    };
-}
-
-pub fn removeX(self: Position, x: usize) Position {
-    return .{
-        .x = self.x - x,
-        .y = self.y,
-    };
-}
-
-pub fn removeY(self: Position, y: usize) Position {
-    return .{
-        .x = self.x,
-        .y = self.y - y,
-    };
-}
-
-pub fn removeXIf(self: Position, x: usize, condition: bool) Position {
-    return .{
-        .x = self.x - if (condition) x else 0,
-        .y = self.y,
-    };
-}
-
-pub fn removeYIf(self: Position, y: usize, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = self.y - if (condition) y else 0,
-    };
-}
-
-pub fn removeXFrom(self: Position, other: Position) Position {
-    return .{
-        .x = self.x - other.x,
-        .y = self.y,
-    };
-}
-
-pub fn removeYFrom(self: Position, other: Position) Position {
-    return .{
-        .x = self.x,
-        .y = self.y - other.y,
-    };
-}
-
-pub fn removeXFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x - if (condition) other.x else 0,
-        .y = self.y,
-    };
-}
-
-pub fn removeYFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = self.y - if (condition) other.y else 0,
-    };
-}
-
-pub fn invert(self: Position, other: Position) Position {
-    return .{
-        .x = other.x - self.x,
-        .y = other.y - self.y,
-    };
-}
-
-pub fn invertIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = if (condition) other.x - self.x else self.x,
-        .y = if (condition) other.y - self.y else self.y,
-    };
-}
-
-pub fn invertX(self: Position, width: usize) Position {
-    return .{
-        .x = width - self.x,
-        .y = self.y,
-    };
-}
-
-pub fn invertY(self: Position, height: usize) Position {
-    return .{
-        .x = self.x,
-        .y = height - self.y,
-    };
-}
-
-pub fn invertXIf(self: Position, width: usize, condition: bool) Position {
-    return .{
-        .x = if (condition) width - self.x else self.x,
-        .y = self.y,
-    };
-}
-
-pub fn invertYIf(self: Position, height: usize, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = if (condition) height - self.y else self.y,
-    };
-}
-
-pub fn resetXFrom(self: Position, other: Position) Position {
-    return .{
-        .x = other.x,
-        .y = self.y,
-    };
-}
-
-pub fn resetYFrom(self: Position, other: Position) Position {
-    return .{
-        .x = self.x,
-        .y = other.y,
-    };
-}
-
-pub fn resetXFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = if (condition) other.x else self.x,
-        .y = self.y,
-    };
-}
-
-pub fn resetYFromIf(self: Position, other: Position, condition: bool) Position {
-    return .{
-        .x = self.x,
-        .y = if (condition) other.y else self.y,
-    };
-}

ly-ui/src/TerminalBuffer.zig

@@ -1,632 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-const Random = std.Random;
-
-const ly_core = @import("ly-core");
-const interop = ly_core.interop;
-const LogFile = ly_core.LogFile;
-const SharedError = ly_core.SharedError;
-pub const termbox = @import("termbox2");
-
-const Cell = @import("Cell.zig");
-const keyboard = @import("keyboard.zig");
-const Position = @import("Position.zig");
-const Widget = @import("Widget.zig");
-
-const TerminalBuffer = @This();
-
-pub const KeybindCallbackFn = *const fn (*anyopaque) anyerror!bool;
-pub const KeybindMap = std.AutoHashMap(keyboard.Key, struct {
-    callback: KeybindCallbackFn,
-    context: *anyopaque,
-});
-
-pub const InitOptions = struct {
-    fg: u32,
-    bg: u32,
-    border_fg: u32,
-    full_color: bool,
-    is_tty: bool,
-};
-
-pub const Styling = struct {
-    pub const BOLD = termbox.TB_BOLD;
-    pub const UNDERLINE = termbox.TB_UNDERLINE;
-    pub const REVERSE = termbox.TB_REVERSE;
-    pub const ITALIC = termbox.TB_ITALIC;
-    pub const BLINK = termbox.TB_BLINK;
-    pub const HI_BLACK = termbox.TB_HI_BLACK;
-    pub const BRIGHT = termbox.TB_BRIGHT;
-    pub const DIM = termbox.TB_DIM;
-};
-
-pub const Color = struct {
-    pub const DEFAULT = 0x00000000;
-    pub const TRUE_BLACK = Styling.HI_BLACK;
-    pub const TRUE_RED = 0x00FF0000;
-    pub const TRUE_GREEN = 0x0000FF00;
-    pub const TRUE_YELLOW = 0x00FFFF00;
-    pub const TRUE_BLUE = 0x000000FF;
-    pub const TRUE_MAGENTA = 0x00FF00FF;
-    pub const TRUE_CYAN = 0x0000FFFF;
-    pub const TRUE_WHITE = 0x00FFFFFF;
-    pub const TRUE_DIM_RED = 0x00800000;
-    pub const TRUE_DIM_GREEN = 0x00008000;
-    pub const TRUE_DIM_YELLOW = 0x00808000;
-    pub const TRUE_DIM_BLUE = 0x00000080;
-    pub const TRUE_DIM_MAGENTA = 0x00800080;
-    pub const TRUE_DIM_CYAN = 0x00008080;
-    pub const TRUE_DIM_WHITE = 0x00C0C0C0;
-    pub const ECOL_BLACK = 1;
-    pub const ECOL_RED = 2;
-    pub const ECOL_GREEN = 3;
-    pub const ECOL_YELLOW = 4;
-    pub const ECOL_BLUE = 5;
-    pub const ECOL_MAGENTA = 6;
-    pub const ECOL_CYAN = 7;
-    pub const ECOL_WHITE = 8;
-};
-
-pub const START_POSITION = Position.init(0, 0);
-
-log_file: *LogFile,
-random: Random,
-width: usize,
-height: usize,
-fg: u32,
-bg: u32,
-border_fg: u32,
-box_chars: struct {
-    left_up: u32,
-    left_down: u32,
-    right_up: u32,
-    right_down: u32,
-    top: u32,
-    bottom: u32,
-    left: u32,
-    right: u32,
-},
-blank_cell: Cell,
-full_color: bool,
-termios: ?std.posix.termios,
-keybinds: KeybindMap,
-handlable_widgets: std.ArrayList(*Widget),
-run: bool,
-update: bool,
-active_widget_index: usize,
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    options: InitOptions,
-    log_file: *LogFile,
-    random: Random,
-) !TerminalBuffer {
-    // Initialize termbox
-    _ = termbox.tb_init();
-
-    if (options.full_color) {
-        _ = termbox.tb_set_output_mode(termbox.TB_OUTPUT_TRUECOLOR);
-        try log_file.info(io, "tui", "termbox2 set to 24-bit color output mode", .{});
-    } else {
-        try log_file.info(io, "tui", "termbox2 set to eight-color output mode", .{});
-    }
-
-    _ = termbox.tb_clear();
-
-    // Let's take some precautions here and clear the back buffer as well
-    try clearBackBuffer();
-
-    const width: usize = @intCast(termbox.tb_width());
-    const height: usize = @intCast(termbox.tb_height());
-
-    try log_file.info(io, "tui", "screen resolution is {d}x{d}", .{ width, height });
-
-    return .{
-        .log_file = log_file,
-        .random = random,
-        .width = width,
-        .height = height,
-        .fg = options.fg,
-        .bg = options.bg,
-        .border_fg = options.border_fg,
-        .box_chars = if (interop.supportsUnicode()) .{
-            .left_up = 0x250C,
-            .left_down = 0x2514,
-            .right_up = 0x2510,
-            .right_down = 0x2518,
-            .top = 0x2500,
-            .bottom = 0x2500,
-            .left = 0x2502,
-            .right = 0x2502,
-        } else .{
-            .left_up = '+',
-            .left_down = '+',
-            .right_up = '+',
-            .right_down = '+',
-            .top = '-',
-            .bottom = '-',
-            .left = '|',
-            .right = '|',
-        },
-        .blank_cell = Cell.init(' ', options.fg, options.bg),
-        .full_color = options.full_color,
-        // Needed to reclaim the TTY after giving up its control
-        .termios = try std.posix.tcgetattr(std.posix.STDIN_FILENO),
-        .keybinds = KeybindMap.init(allocator),
-        .handlable_widgets = .empty,
-        .run = true,
-        .update = true,
-        .active_widget_index = 0,
-    };
-}
-
-pub fn deinit(self: *TerminalBuffer) void {
-    self.keybinds.deinit();
-    TerminalBuffer.shutdown();
-}
-
-pub fn runEventLoop(
-    self: *TerminalBuffer,
-    allocator: Allocator,
-    io: std.Io,
-    shared_error: SharedError,
-    layers: [][]*Widget,
-    active_widget: *Widget,
-    inactivity_delay: u16,
-    position_widgets_fn: *const fn (*anyopaque) anyerror!void,
-    inactivity_event_fn: ?*const fn (*anyopaque) anyerror!void,
-    context: *anyopaque,
-) !void {
-    try self.registerGlobalKeybind(io, "Ctrl+K", &moveCursorUp, self);
-    try self.registerGlobalKeybind(io, "Up", &moveCursorUp, self);
-
-    try self.registerGlobalKeybind(io, "Ctrl+J", &moveCursorDown, self);
-    try self.registerGlobalKeybind(io, "Down", &moveCursorDown, self);
-
-    try self.registerGlobalKeybind(io, "Tab", &wrapCursor, self);
-    try self.registerGlobalKeybind(io, "Shift+Tab", &wrapCursorReverse, self);
-
-    defer self.handlable_widgets.deinit(allocator);
-
-    var i: usize = 0;
-    for (layers) |layer| {
-        for (layer) |widget| {
-            try widget.update(context);
-
-            if (widget.vtable.handle_fn != null) {
-                try self.handlable_widgets.append(allocator, widget);
-
-                if (widget.id == active_widget.id) self.active_widget_index = i;
-                i += 1;
-            }
-        }
-    }
-
-    try @call(.auto, position_widgets_fn, .{context});
-
-    var event: termbox.tb_event = undefined;
-    var inactivity_cmd_ran = false;
-    var inactivity_time_start = try interop.getTimeOfDay();
-
-    while (self.run) {
-        var maybe_timeout: ?usize = null;
-
-        if (self.update) {
-            try TerminalBuffer.clearScreen(false);
-
-            // Reset cursor
-            const current_widget = self.getActiveWidget();
-            current_widget.handle(null) catch |err| {
-                shared_error.writeError(error.SetCursorFailed);
-                try self.log_file.err(
-                    io,
-                    "tui",
-                    "failed to set cursor in active widget '{s}': {s}",
-                    .{ current_widget.display_name, @errorName(err) },
-                );
-            };
-
-            for (layers) |layer| {
-                for (layer) |widget| {
-                    try widget.update(context);
-                    widget.draw();
-
-                    if (try widget.calculateTimeout(context)) |widget_timeout| {
-                        if (maybe_timeout == null or widget_timeout < maybe_timeout.?) maybe_timeout = widget_timeout;
-                    }
-                }
-            }
-
-            TerminalBuffer.presentBuffer();
-        }
-
-        if (inactivity_event_fn) |inactivity_fn| {
-            const time = try interop.getTimeOfDay();
-
-            if (!inactivity_cmd_ran and time.seconds - inactivity_time_start.seconds > inactivity_delay) {
-                try @call(.auto, inactivity_fn, .{context});
-                inactivity_cmd_ran = true;
-            }
-        }
-
-        const event_error = if (maybe_timeout) |timeout| termbox.tb_peek_event(&event, @intCast(timeout)) else termbox.tb_poll_event(&event);
-
-        self.update = maybe_timeout != null or event_error >= 0;
-
-        if (event_error < 0) continue;
-
-        // Input of some kind was detected, so reset the inactivity timer
-        inactivity_time_start = try interop.getTimeOfDay();
-
-        if (event.type == termbox.TB_EVENT_RESIZE) {
-            self.width = TerminalBuffer.getWidth();
-            self.height = TerminalBuffer.getHeight();
-
-            try self.log_file.info(
-                io,
-                "tui",
-                "screen resolution updated to {d}x{d}",
-                .{ self.width, self.height },
-            );
-
-            for (layers) |layer| {
-                for (layer) |widget| {
-                    widget.realloc() catch |err| {
-                        shared_error.writeError(error.WidgetReallocationFailed);
-                        try self.log_file.err(
-                            io,
-                            "tui",
-                            "failed to reallocate widget '{s}': {s}",
-                            .{ widget.display_name, @errorName(err) },
-                        );
-                    };
-                }
-            }
-
-            try @call(.auto, position_widgets_fn, .{context});
-
-            self.update = true;
-            continue;
-        }
-
-        var maybe_keys = try self.handleKeybind(allocator, event);
-        if (maybe_keys) |*keys| {
-            defer keys.deinit(allocator);
-
-            const current_widget = self.getActiveWidget();
-            for (keys.items) |key| {
-                current_widget.handle(key) catch |err| {
-                    shared_error.writeError(error.CurrentWidgetHandlingFailed);
-                    try self.log_file.err(
-                        io,
-                        "tui",
-                        "failed to handle active widget '{s}': {s}",
-                        .{ current_widget.display_name, @errorName(err) },
-                    );
-                };
-            }
-
-            self.update = true;
-        }
-    }
-}
-
-pub fn stopEventLoop(self: *TerminalBuffer) void {
-    self.run = false;
-}
-
-pub fn drawNextFrame(self: *TerminalBuffer, value: bool) void {
-    self.update = value;
-}
-
-pub fn getActiveWidget(self: *TerminalBuffer) *Widget {
-    return self.handlable_widgets.items[self.active_widget_index];
-}
-
-pub fn setActiveWidget(self: *TerminalBuffer, widget: *Widget) void {
-    for (self.handlable_widgets.items, 0..) |widg, i| {
-        if (widg.id == widget.id) self.active_widget_index = i;
-    }
-}
-
-pub fn getWidth() usize {
-    return @intCast(termbox.tb_width());
-}
-
-pub fn getHeight() usize {
-    return @intCast(termbox.tb_height());
-}
-
-pub fn setCursor(x: usize, y: usize) void {
-    _ = termbox.tb_set_cursor(@intCast(x), @intCast(y));
-}
-
-pub fn clearScreen(clear_back_buffer: bool) !void {
-    _ = termbox.tb_clear();
-    if (clear_back_buffer) try clearBackBuffer();
-}
-
-pub fn shutdown() void {
-    _ = termbox.tb_shutdown();
-}
-
-pub fn presentBuffer() void {
-    _ = termbox.tb_present();
-}
-
-pub fn getCell(x: usize, y: usize) ?Cell {
-    var maybe_cell: ?*termbox.tb_cell = undefined;
-    _ = termbox.tb_get_cell(
-        @intCast(x),
-        @intCast(y),
-        1,
-        &maybe_cell,
-    );
-
-    if (maybe_cell) |cell| {
-        return Cell.init(cell.ch, cell.fg, cell.bg);
-    }
-
-    return null;
-}
-
-pub fn setCell(x: usize, y: usize, cell: Cell) void {
-    _ = termbox.tb_set_cell(
-        @intCast(x),
-        @intCast(y),
-        cell.ch,
-        cell.fg,
-        cell.bg,
-    );
-}
-
-pub fn reclaim(self: TerminalBuffer) !void {
-    if (self.termios) |termios| {
-        // Take back control of the TTY
-        _ = termbox.tb_init();
-
-        if (self.full_color) {
-            _ = termbox.tb_set_output_mode(termbox.TB_OUTPUT_TRUECOLOR);
-        }
-
-        try std.posix.tcsetattr(std.posix.STDIN_FILENO, .FLUSH, termios);
-    }
-}
-
-pub fn registerKeybind(
-    self: *TerminalBuffer,
-    io: std.Io,
-    keybinds: *KeybindMap,
-    keybind: []const u8,
-    callback: KeybindCallbackFn,
-    context: *anyopaque,
-) !void {
-    const key = try self.parseKeybind(io, keybind);
-
-    keybinds.put(key, .{
-        .callback = callback,
-        .context = context,
-    }) catch |err| {
-        try self.log_file.err(
-            io,
-            "tui",
-            "failed to register keybind {s}: {s}",
-            .{ keybind, @errorName(err) },
-        );
-    };
-}
-
-pub fn registerGlobalKeybind(
-    self: *TerminalBuffer,
-    io: std.Io,
-    keybind: []const u8,
-    callback: KeybindCallbackFn,
-    context: *anyopaque,
-) !void {
-    try self.registerKeybind(io, &self.keybinds, keybind, callback, context);
-}
-
-pub fn simulateKeybind(self: *TerminalBuffer, io: std.Io, keybind: []const u8) !bool {
-    const key = try self.parseKeybind(io, keybind);
-
-    if (self.keybinds.get(key)) |binding| {
-        return try @call(
-            .auto,
-            binding.callback,
-            .{binding.context},
-        );
-    }
-
-    const current_widget = self.getActiveWidget();
-    if (current_widget.keybinds) |keybinds| {
-        if (keybinds.get(key)) |binding| {
-            return try @call(
-                .auto,
-                binding.callback,
-                .{binding.context},
-            );
-        }
-    }
-
-    return true;
-}
-
-pub fn drawText(
-    text: []const u8,
-    x: usize,
-    y: usize,
-    fg: u32,
-    bg: u32,
-) void {
-    const yc: c_int = @intCast(y);
-    const utf8view = std.unicode.Utf8View.init(text) catch return;
-    var utf8 = utf8view.iterator();
-
-    var i: c_int = @intCast(x);
-    while (utf8.nextCodepoint()) |codepoint| : (i += termbox.tb_wcwidth(codepoint)) {
-        _ = termbox.tb_set_cell(i, yc, codepoint, fg, bg);
-    }
-}
-
-pub fn drawConfinedText(
-    text: []const u8,
-    x: usize,
-    y: usize,
-    max_length: usize,
-    fg: u32,
-    bg: u32,
-) void {
-    const yc: c_int = @intCast(y);
-    const utf8view = std.unicode.Utf8View.init(text) catch return;
-    var utf8 = utf8view.iterator();
-
-    var i: c_int = @intCast(x);
-    while (utf8.nextCodepoint()) |codepoint| : (i += termbox.tb_wcwidth(codepoint)) {
-        if (i - @as(c_int, @intCast(x)) >= max_length) break;
-        _ = termbox.tb_set_cell(i, yc, codepoint, fg, bg);
-    }
-}
-
-pub fn drawCharMultiple(
-    char: u32,
-    x: usize,
-    y: usize,
-    length: usize,
-    fg: u32,
-    bg: u32,
-) void {
-    const cell = Cell.init(char, fg, bg);
-    for (0..length) |xx| cell.put(x + xx, y);
-}
-
-// Every codepoint is assumed to have a width of 1.
-// Since Ly is normally running in a TTY, this should be fine.
-pub fn strWidth(str: []const u8) usize {
-    const utf8view = std.unicode.Utf8View.init(str) catch return str.len;
-    var utf8 = utf8view.iterator();
-    var length: c_int = 0;
-
-    while (utf8.nextCodepoint()) |codepoint| {
-        length += termbox.tb_wcwidth(codepoint);
-    }
-
-    return @intCast(length);
-}
-
-fn clearBackBuffer() !void {
-    // Clear the TTY because termbox2 doesn't seem to do it properly
-    const capability = termbox.global.caps[termbox.TB_CAP_CLEAR_SCREEN];
-    const capability_slice = std.mem.span(capability);
-    const result = std.posix.system.write(termbox.global.ttyfd, capability_slice.ptr, capability_slice.len);
-
-    if (result != capability_slice.len) return error.PartialClearBackBuffer;
-    if (result < 0) return error.ClearBackBufferFailed;
-}
-
-fn parseKeybind(self: *TerminalBuffer, io: std.Io, keybind: []const u8) !keyboard.Key {
-    var key = std.mem.zeroes(keyboard.Key);
-    var iterator = std.mem.splitScalar(u8, keybind, '+');
-
-    while (iterator.next()) |item| {
-        var found = false;
-
-        inline for (std.meta.fields(keyboard.Key)) |field| {
-            if (std.ascii.eqlIgnoreCase(field.name, item)) {
-                @field(key, field.name) = true;
-                found = true;
-                break;
-            }
-        }
-
-        if (!found) {
-            try self.log_file.err(
-                io,
-                "tui",
-                "failed to parse key {s} of keybind {s}",
-                .{ item, keybind },
-            );
-        }
-    }
-
-    return key;
-}
-
-fn handleKeybind(
-    self: *TerminalBuffer,
-    allocator: Allocator,
-    tb_event: termbox.tb_event,
-) !?std.ArrayList(keyboard.Key) {
-    var keys = try keyboard.getKeyList(allocator, tb_event);
-
-    for (keys.items) |key| {
-        if (self.keybinds.get(key)) |binding| {
-            const passthrough_event = try @call(
-                .auto,
-                binding.callback,
-                .{binding.context},
-            );
-
-            if (!passthrough_event) {
-                keys.deinit(allocator);
-                return null;
-            }
-
-            return keys;
-        }
-
-        const current_widget = self.getActiveWidget();
-        if (current_widget.keybinds) |keybinds| {
-            if (keybinds.get(key)) |binding| {
-                const passthrough_event = try @call(
-                    .auto,
-                    binding.callback,
-                    .{binding.context},
-                );
-
-                if (!passthrough_event) {
-                    keys.deinit(allocator);
-                    return null;
-                }
-
-                return keys;
-            }
-        }
-    }
-
-    return keys;
-}
-
-fn moveCursorUp(ptr: *anyopaque) !bool {
-    var state: *TerminalBuffer = @ptrCast(@alignCast(ptr));
-    if (state.active_widget_index == 0) return false;
-
-    state.active_widget_index -= 1;
-    state.update = true;
-    return false;
-}
-
-fn moveCursorDown(ptr: *anyopaque) !bool {
-    var state: *TerminalBuffer = @ptrCast(@alignCast(ptr));
-    if (state.active_widget_index == state.handlable_widgets.items.len - 1) return false;
-
-    state.active_widget_index += 1;
-    state.update = true;
-    return false;
-}
-
-fn wrapCursor(ptr: *anyopaque) !bool {
-    var state: *TerminalBuffer = @ptrCast(@alignCast(ptr));
-
-    state.active_widget_index = (state.active_widget_index + 1) % state.handlable_widgets.items.len;
-    state.update = true;
-    return false;
-}
-
-fn wrapCursorReverse(ptr: *anyopaque) !bool {
-    var state: *TerminalBuffer = @ptrCast(@alignCast(ptr));
-
-    state.active_widget_index = if (state.active_widget_index == 0) state.handlable_widgets.items.len - 1 else state.active_widget_index - 1;
-    state.update = true;
-    return false;
-}

ly-ui/src/Widget.zig

@@ -1,186 +0,0 @@
-const Widget = @This();
-
-const keyboard = @import("keyboard.zig");
-const TerminalBuffer = @import("TerminalBuffer.zig");
-
-const VTable = struct {
-    deinit_fn: ?*const fn (ptr: *anyopaque) void,
-    realloc_fn: ?*const fn (ptr: *anyopaque) anyerror!void,
-    draw_fn: *const fn (ptr: *anyopaque) void,
-    update_fn: ?*const fn (ptr: *anyopaque, ctx: *anyopaque) anyerror!void,
-    handle_fn: ?*const fn (ptr: *anyopaque, maybe_key: ?keyboard.Key) anyerror!void,
-    calculate_timeout_fn: ?*const fn (ptr: *anyopaque, ctx: *anyopaque) anyerror!?usize,
-};
-
-pub var idCounter: u64 = 0;
-
-id: u64,
-display_name: []const u8,
-keybinds: ?TerminalBuffer.KeybindMap,
-pointer: *anyopaque,
-vtable: VTable,
-
-pub fn init(
-    display_name: []const u8,
-    keybinds: ?TerminalBuffer.KeybindMap,
-    pointer: anytype,
-    comptime deinit_fn: ?fn (ptr: @TypeOf(pointer)) void,
-    comptime realloc_fn: ?fn (ptr: @TypeOf(pointer)) anyerror!void,
-    comptime draw_fn: fn (ptr: @TypeOf(pointer)) void,
-    comptime update_fn: ?fn (ptr: @TypeOf(pointer), ctx: *anyopaque) anyerror!void,
-    comptime handle_fn: ?fn (ptr: @TypeOf(pointer), maybe_key: ?keyboard.Key) anyerror!void,
-    comptime calculate_timeout_fn: ?fn (ptr: @TypeOf(pointer), ctx: *anyopaque) anyerror!?usize,
-) Widget {
-    const Pointer = @TypeOf(pointer);
-    const Impl = struct {
-        pub fn deinitImpl(ptr: *anyopaque) void {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                deinit_fn.?,
-                .{impl},
-            );
-        }
-
-        pub fn reallocImpl(ptr: *anyopaque) !void {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                realloc_fn.?,
-                .{impl},
-            );
-        }
-
-        pub fn drawImpl(ptr: *anyopaque) void {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                draw_fn,
-                .{impl},
-            );
-        }
-
-        pub fn updateImpl(ptr: *anyopaque, ctx: *anyopaque) !void {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                update_fn.?,
-                .{ impl, ctx },
-            );
-        }
-
-        pub fn handleImpl(ptr: *anyopaque, maybe_key: ?keyboard.Key) !void {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                handle_fn.?,
-                .{ impl, maybe_key },
-            );
-        }
-
-        pub fn calculateTimeoutImpl(ptr: *anyopaque, ctx: *anyopaque) !?usize {
-            const impl: Pointer = @ptrCast(@alignCast(ptr));
-
-            return @call(
-                .always_inline,
-                calculate_timeout_fn.?,
-                .{ impl, ctx },
-            );
-        }
-
-        const vtable = VTable{
-            .deinit_fn = if (deinit_fn != null) deinitImpl else null,
-            .realloc_fn = if (realloc_fn != null) reallocImpl else null,
-            .draw_fn = drawImpl,
-            .update_fn = if (update_fn != null) updateImpl else null,
-            .handle_fn = if (handle_fn != null) handleImpl else null,
-            .calculate_timeout_fn = if (calculate_timeout_fn != null) calculateTimeoutImpl else null,
-        };
-    };
-
-    idCounter += 1;
-    return .{
-        .id = idCounter,
-        .display_name = display_name,
-        .keybinds = keybinds,
-        .pointer = pointer,
-        .vtable = Impl.vtable,
-    };
-}
-
-pub fn deinit(self: *Widget) void {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    if (self.vtable.deinit_fn) |deinit_fn| {
-        return @call(
-            .auto,
-            deinit_fn,
-            .{impl},
-        );
-    }
-}
-
-pub fn realloc(self: *Widget) !void {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    if (self.vtable.realloc_fn) |realloc_fn| {
-        return @call(
-            .auto,
-            realloc_fn,
-            .{impl},
-        );
-    }
-}
-
-pub fn draw(self: *Widget) void {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    @call(
-        .auto,
-        self.vtable.draw_fn,
-        .{impl},
-    );
-}
-
-pub fn update(self: *Widget, ctx: *anyopaque) !void {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    if (self.vtable.update_fn) |update_fn| {
-        return @call(
-            .auto,
-            update_fn,
-            .{ impl, ctx },
-        );
-    }
-}
-
-pub fn handle(self: *Widget, maybe_key: ?keyboard.Key) !void {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    if (self.vtable.handle_fn) |handle_fn| {
-        return @call(
-            .auto,
-            handle_fn,
-            .{ impl, maybe_key },
-        );
-    }
-}
-
-pub fn calculateTimeout(self: *Widget, ctx: *anyopaque) !?usize {
-    const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
-
-    if (self.vtable.calculate_timeout_fn) |calculate_timeout_fn| {
-        return @call(
-            .auto,
-            calculate_timeout_fn,
-            .{ impl, ctx },
-        );
-    }
-
-    return null;
-}

ly-ui/src/components/BigLabel.zig

@@ -1,237 +0,0 @@
-const BigLabel = @This();
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ly_core = @import("ly-core");
-const interop = ly_core.interop;
-
-const en = @import("bigLabelLocales/en.zig");
-const fa = @import("bigLabelLocales/fa.zig");
-const Cell = @import("../Cell.zig");
-const Position = @import("../Position.zig");
-const TerminalBuffer = @import("../TerminalBuffer.zig");
-const Widget = @import("../Widget.zig");
-
-pub const CHAR_WIDTH = 5;
-pub const CHAR_HEIGHT = 5;
-pub const CHAR_SIZE = CHAR_WIDTH * CHAR_HEIGHT;
-pub const X: u32 = if (ly_core.interop.supportsUnicode()) 0x2593 else '#';
-pub const O: u32 = 0;
-
-// zig fmt: off
-pub const LocaleChars = struct {
-    ZERO:   [CHAR_SIZE]u21,
-    ONE:    [CHAR_SIZE]u21,
-    TWO:    [CHAR_SIZE]u21,
-    THREE:  [CHAR_SIZE]u21,
-    FOUR:   [CHAR_SIZE]u21,
-    FIVE:   [CHAR_SIZE]u21,
-    SIX:    [CHAR_SIZE]u21,
-    SEVEN:  [CHAR_SIZE]u21,
-    EIGHT:  [CHAR_SIZE]u21,
-    NINE:   [CHAR_SIZE]u21,
-    S:      [CHAR_SIZE]u21,
-    E:      [CHAR_SIZE]u21,
-    P:      [CHAR_SIZE]u21,
-    A:      [CHAR_SIZE]u21,
-    M:      [CHAR_SIZE]u21,
-};
-// zig fmt: on
-
-pub const BigLabelLocale = enum {
-    en,
-    fa,
-};
-
-instance: ?Widget = null,
-allocator: ?Allocator = null,
-buffer: *TerminalBuffer,
-text: []const u8,
-max_width: ?usize,
-fg: u32,
-bg: u32,
-locale: BigLabelLocale,
-update_fn: ?*const fn (*BigLabel, *anyopaque) anyerror!void,
-calculate_timeout_fn: ?*const fn (*BigLabel, *anyopaque) anyerror!?usize,
-component_pos: Position,
-children_pos: Position,
-
-pub fn init(
-    buffer: *TerminalBuffer,
-    text: []const u8,
-    max_width: ?usize,
-    fg: u32,
-    bg: u32,
-    locale: BigLabelLocale,
-    update_fn: ?*const fn (*BigLabel, *anyopaque) anyerror!void,
-    calculate_timeout_fn: ?*const fn (*BigLabel, *anyopaque) anyerror!?usize,
-) BigLabel {
-    return .{
-        .instance = null,
-        .allocator = null,
-        .buffer = buffer,
-        .text = text,
-        .max_width = max_width,
-        .fg = fg,
-        .bg = bg,
-        .locale = locale,
-        .update_fn = update_fn,
-        .calculate_timeout_fn = calculate_timeout_fn,
-        .component_pos = TerminalBuffer.START_POSITION,
-        .children_pos = TerminalBuffer.START_POSITION,
-    };
-}
-
-pub fn deinit(self: *BigLabel) void {
-    if (self.allocator) |allocator| allocator.free(self.text);
-}
-
-pub fn widget(self: *BigLabel) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "BigLabel",
-        null,
-        self,
-        deinit,
-        null,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-pub fn setTextAlloc(
-    self: *BigLabel,
-    allocator: Allocator,
-    comptime fmt: []const u8,
-    args: anytype,
-) !void {
-    self.text = try std.fmt.allocPrint(allocator, fmt, args);
-    self.allocator = allocator;
-}
-
-pub fn setTextBuf(
-    self: *BigLabel,
-    buffer: []u8,
-    comptime fmt: []const u8,
-    args: anytype,
-) !void {
-    self.text = try std.fmt.bufPrint(buffer, fmt, args);
-    self.allocator = null;
-}
-
-pub fn setText(self: *BigLabel, text: []const u8) void {
-    self.text = text;
-    self.allocator = null;
-}
-
-pub fn positionX(self: *BigLabel, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addX(TerminalBuffer.strWidth(self.text) * CHAR_WIDTH);
-}
-
-pub fn positionY(self: *BigLabel, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addY(CHAR_HEIGHT);
-}
-
-pub fn positionXY(self: *BigLabel, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = Position.init(
-        TerminalBuffer.strWidth(self.text) * CHAR_WIDTH,
-        CHAR_HEIGHT,
-    ).add(original_pos);
-}
-
-pub fn childrenPosition(self: BigLabel) Position {
-    return self.children_pos;
-}
-
-fn draw(self: *BigLabel) void {
-    for (self.text, 0..) |c, i| {
-        const clock_cell = clockCell(
-            c,
-            self.fg,
-            self.bg,
-            self.locale,
-        );
-
-        alphaBlit(
-            self.component_pos.x + i * (CHAR_WIDTH + 1),
-            self.component_pos.y,
-            self.buffer.width,
-            self.buffer.height,
-            clock_cell,
-        );
-    }
-}
-
-fn update(self: *BigLabel, context: *anyopaque) !void {
-    if (self.update_fn) |update_fn| {
-        return @call(
-            .auto,
-            update_fn,
-            .{ self, context },
-        );
-    }
-}
-
-fn calculateTimeout(self: *BigLabel, ctx: *anyopaque) !?usize {
-    if (self.calculate_timeout_fn) |calculate_timeout_fn| {
-        return @call(
-            .auto,
-            calculate_timeout_fn,
-            .{ self, ctx },
-        );
-    }
-
-    return null;
-}
-
-fn clockCell(char: u8, fg: u32, bg: u32, locale: BigLabelLocale) [CHAR_SIZE]Cell {
-    var cells: [CHAR_SIZE]Cell = undefined;
-
-    //@divTrunc(time.microseconds, 500000) != 0)
-    const clock_chars = toBigNumber(char, locale);
-    for (0..cells.len) |i| cells[i] = Cell.init(clock_chars[i], fg, bg);
-
-    return cells;
-}
-
-fn alphaBlit(x: usize, y: usize, tb_width: usize, tb_height: usize, cells: [CHAR_SIZE]Cell) void {
-    if (x + CHAR_WIDTH >= tb_width or y + CHAR_HEIGHT >= tb_height) return;
-
-    for (0..CHAR_HEIGHT) |yy| {
-        for (0..CHAR_WIDTH) |xx| {
-            const cell = cells[yy * CHAR_WIDTH + xx];
-            cell.put(x + xx, y + yy);
-        }
-    }
-}
-
-fn toBigNumber(char: u8, locale: BigLabelLocale) [CHAR_SIZE]u21 {
-    const locale_chars = switch (locale) {
-        .fa => fa.locale_chars,
-        .en => en.locale_chars,
-    };
-    return switch (char) {
-        '0' => locale_chars.ZERO,
-        '1' => locale_chars.ONE,
-        '2' => locale_chars.TWO,
-        '3' => locale_chars.THREE,
-        '4' => locale_chars.FOUR,
-        '5' => locale_chars.FIVE,
-        '6' => locale_chars.SIX,
-        '7' => locale_chars.SEVEN,
-        '8' => locale_chars.EIGHT,
-        '9' => locale_chars.NINE,
-        'p', 'P' => locale_chars.P,
-        'a', 'A' => locale_chars.A,
-        'm', 'M' => locale_chars.M,
-        ':' => locale_chars.S,
-        else => locale_chars.E,
-    };
-}

ly-ui/src/components/Box.zig

@@ -1,190 +0,0 @@
-const std = @import("std");
-
-const Cell = @import("../Cell.zig");
-const Position = @import("../Position.zig");
-const TerminalBuffer = @import("../TerminalBuffer.zig");
-const Widget = @import("../Widget.zig");
-
-const Box = @This();
-
-instance: ?Widget = null,
-buffer: *TerminalBuffer,
-horizontal_margin: usize,
-vertical_margin: usize,
-width: usize,
-height: usize,
-show_borders: bool,
-blank_box: bool,
-top_title: ?[]const u8,
-bottom_title: ?[]const u8,
-border_fg: u32,
-title_fg: u32,
-bg: u32,
-update_fn: ?*const fn (*Box, *anyopaque) anyerror!void,
-left_pos: Position,
-right_pos: Position,
-children_pos: Position,
-
-pub fn init(
-    buffer: *TerminalBuffer,
-    horizontal_margin: usize,
-    vertical_margin: usize,
-    width: usize,
-    height: usize,
-    show_borders: bool,
-    blank_box: bool,
-    top_title: ?[]const u8,
-    bottom_title: ?[]const u8,
-    border_fg: u32,
-    title_fg: u32,
-    bg: u32,
-    update_fn: ?*const fn (*Box, *anyopaque) anyerror!void,
-) Box {
-    return .{
-        .instance = null,
-        .buffer = buffer,
-        .horizontal_margin = horizontal_margin,
-        .vertical_margin = vertical_margin,
-        .width = width,
-        .height = height,
-        .show_borders = show_borders,
-        .blank_box = blank_box,
-        .top_title = top_title,
-        .bottom_title = bottom_title,
-        .border_fg = border_fg,
-        .title_fg = title_fg,
-        .bg = bg,
-        .update_fn = update_fn,
-        .left_pos = TerminalBuffer.START_POSITION,
-        .right_pos = TerminalBuffer.START_POSITION,
-        .children_pos = TerminalBuffer.START_POSITION,
-    };
-}
-
-pub fn widget(self: *Box) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Box",
-        null,
-        self,
-        null,
-        null,
-        draw,
-        update,
-        null,
-        null,
-    );
-    return &self.instance.?;
-}
-
-pub fn positionXY(self: *Box, original_pos: Position) void {
-    if (self.buffer.width < 2 or self.buffer.height < 2) return;
-
-    self.left_pos = original_pos;
-    self.right_pos = Position.init(
-        @min(self.buffer.width, self.width),
-        @min(self.buffer.height, self.height),
-    ).add(self.left_pos);
-
-    self.children_pos = Position.init(
-        self.horizontal_margin,
-        self.vertical_margin,
-    ).add(self.left_pos);
-}
-
-pub fn childrenPosition(self: Box) Position {
-    return self.children_pos;
-}
-
-fn draw(self: *Box) void {
-    if (self.show_borders) {
-        var left_up = Cell.init(
-            self.buffer.box_chars.left_up,
-            self.border_fg,
-            self.bg,
-        );
-        var right_up = Cell.init(
-            self.buffer.box_chars.right_up,
-            self.border_fg,
-            self.bg,
-        );
-        var left_down = Cell.init(
-            self.buffer.box_chars.left_down,
-            self.border_fg,
-            self.bg,
-        );
-        var right_down = Cell.init(
-            self.buffer.box_chars.right_down,
-            self.border_fg,
-            self.bg,
-        );
-        var top = Cell.init(
-            self.buffer.box_chars.top,
-            self.border_fg,
-            self.bg,
-        );
-        var bottom = Cell.init(
-            self.buffer.box_chars.bottom,
-            self.border_fg,
-            self.bg,
-        );
-
-        left_up.put(self.left_pos.x - 1, self.left_pos.y - 1);
-        right_up.put(self.right_pos.x, self.left_pos.y - 1);
-        left_down.put(self.left_pos.x - 1, self.right_pos.y);
-        right_down.put(self.right_pos.x, self.right_pos.y);
-
-        for (0..self.width) |i| {
-            top.put(self.left_pos.x + i, self.left_pos.y - 1);
-            bottom.put(self.left_pos.x + i, self.right_pos.y);
-        }
-
-        top.ch = self.buffer.box_chars.left;
-        bottom.ch = self.buffer.box_chars.right;
-
-        for (0..self.height) |i| {
-            top.put(self.left_pos.x - 1, self.left_pos.y + i);
-            bottom.put(self.right_pos.x, self.left_pos.y + i);
-        }
-    }
-
-    if (self.blank_box) {
-        for (0..self.height) |y| {
-            for (0..self.width) |x| {
-                self.buffer.blank_cell.put(self.left_pos.x + x, self.left_pos.y + y);
-            }
-        }
-    }
-
-    if (self.top_title) |title| {
-        TerminalBuffer.drawConfinedText(
-            title,
-            self.left_pos.x,
-            self.left_pos.y - 1,
-            self.width,
-            self.title_fg,
-            self.bg,
-        );
-    }
-
-    if (self.bottom_title) |title| {
-        TerminalBuffer.drawConfinedText(
-            title,
-            self.left_pos.x,
-            self.left_pos.y + self.height,
-            self.width,
-            self.title_fg,
-            self.bg,
-        );
-    }
-}
-
-fn update(self: *Box, ctx: *anyopaque) !void {
-    if (self.update_fn) |update_fn| {
-        return @call(
-            .auto,
-            update_fn,
-            .{ self, ctx },
-        );
-    }
-}

ly-ui/src/components/Label.zig

@@ -1,153 +0,0 @@
-const Label = @This();
-
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const Cell = @import("../Cell.zig");
-const Position = @import("../Position.zig");
-const TerminalBuffer = @import("../TerminalBuffer.zig");
-const Widget = @import("../Widget.zig");
-
-instance: ?Widget,
-allocator: ?Allocator,
-text: []const u8,
-max_width: ?usize,
-fg: u32,
-bg: u32,
-update_fn: ?*const fn (*Label, *anyopaque) anyerror!void,
-calculate_timeout_fn: ?*const fn (*Label, *anyopaque) anyerror!?usize,
-component_pos: Position,
-children_pos: Position,
-
-pub fn init(
-    text: []const u8,
-    max_width: ?usize,
-    fg: u32,
-    bg: u32,
-    update_fn: ?*const fn (*Label, *anyopaque) anyerror!void,
-    calculate_timeout_fn: ?*const fn (*Label, *anyopaque) anyerror!?usize,
-) Label {
-    return .{
-        .instance = null,
-        .allocator = null,
-        .text = text,
-        .max_width = max_width,
-        .fg = fg,
-        .bg = bg,
-        .update_fn = update_fn,
-        .calculate_timeout_fn = calculate_timeout_fn,
-        .component_pos = TerminalBuffer.START_POSITION,
-        .children_pos = TerminalBuffer.START_POSITION,
-    };
-}
-
-pub fn deinit(self: *Label) void {
-    if (self.allocator) |allocator| allocator.free(self.text);
-}
-
-pub fn widget(self: *Label) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Label",
-        null,
-        self,
-        deinit,
-        null,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-pub fn setTextAlloc(
-    self: *Label,
-    allocator: Allocator,
-    comptime fmt: []const u8,
-    args: anytype,
-) !void {
-    self.text = try std.fmt.allocPrint(allocator, fmt, args);
-    self.allocator = allocator;
-}
-
-pub fn setTextBuf(
-    self: *Label,
-    buffer: []u8,
-    comptime fmt: []const u8,
-    args: anytype,
-) !void {
-    self.text = try std.fmt.bufPrint(buffer, fmt, args);
-    self.allocator = null;
-}
-
-pub fn setText(self: *Label, text: []const u8) void {
-    self.text = text;
-    self.allocator = null;
-}
-
-pub fn positionX(self: *Label, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addX(TerminalBuffer.strWidth(self.text));
-}
-
-pub fn positionY(self: *Label, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addY(1);
-}
-
-pub fn positionXY(self: *Label, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = Position.init(
-        TerminalBuffer.strWidth(self.text),
-        1,
-    ).add(original_pos);
-}
-
-pub fn childrenPosition(self: Label) Position {
-    return self.children_pos;
-}
-
-fn draw(self: *Label) void {
-    if (self.max_width) |width| {
-        TerminalBuffer.drawConfinedText(
-            self.text,
-            self.component_pos.x,
-            self.component_pos.y,
-            width,
-            self.fg,
-            self.bg,
-        );
-        return;
-    }
-
-    TerminalBuffer.drawText(
-        self.text,
-        self.component_pos.x,
-        self.component_pos.y,
-        self.fg,
-        self.bg,
-    );
-}
-
-fn update(self: *Label, ctx: *anyopaque) !void {
-    if (self.update_fn) |update_fn| {
-        return @call(
-            .auto,
-            update_fn,
-            .{ self, ctx },
-        );
-    }
-}
-
-fn calculateTimeout(self: *Label, ctx: *anyopaque) !?usize {
-    if (self.calculate_timeout_fn) |calculate_timeout_fn| {
-        return @call(
-            .auto,
-            calculate_timeout_fn,
-            .{ self, ctx },
-        );
-    }
-
-    return null;
-}

ly-ui/src/components/Text.zig

@@ -1,246 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const keyboard = @import("../keyboard.zig");
-const TerminalBuffer = @import("../TerminalBuffer.zig");
-const Position = @import("../Position.zig");
-const Widget = @import("../Widget.zig");
-
-const DynamicString = std.ArrayListUnmanaged(u8);
-
-const Text = @This();
-
-instance: ?Widget,
-allocator: Allocator,
-buffer: *TerminalBuffer,
-text: DynamicString,
-end: usize,
-cursor: usize,
-visible_start: usize,
-width: usize,
-component_pos: Position,
-children_pos: Position,
-should_insert: bool,
-masked: bool,
-maybe_mask: ?u32,
-fg: u32,
-bg: u32,
-keybinds: TerminalBuffer.KeybindMap,
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    buffer: *TerminalBuffer,
-    should_insert: bool,
-    masked: bool,
-    maybe_mask: ?u32,
-    width: usize,
-    fg: u32,
-    bg: u32,
-) !*Text {
-    var self = try allocator.create(Text);
-    self.* = Text{
-        .instance = null,
-        .allocator = allocator,
-        .buffer = buffer,
-        .text = .empty,
-        .end = 0,
-        .cursor = 0,
-        .visible_start = 0,
-        .width = width,
-        .component_pos = TerminalBuffer.START_POSITION,
-        .children_pos = TerminalBuffer.START_POSITION,
-        .should_insert = should_insert,
-        .masked = masked,
-        .maybe_mask = maybe_mask,
-        .fg = fg,
-        .bg = bg,
-        .keybinds = .init(allocator),
-    };
-
-    try buffer.registerKeybind(io, &self.keybinds, "Left", &goLeft, self);
-    try buffer.registerKeybind(io, &self.keybinds, "Right", &goRight, self);
-    try buffer.registerKeybind(io, &self.keybinds, "Delete", &delete, self);
-    try buffer.registerKeybind(io, &self.keybinds, "Backspace", &backspace, self);
-    try buffer.registerKeybind(io, &self.keybinds, "Ctrl+U", &clearTextEntry, self);
-
-    return self;
-}
-
-pub fn deinit(self: *Text) void {
-    self.text.deinit(self.allocator);
-    self.keybinds.deinit();
-    self.allocator.destroy(self);
-}
-
-pub fn widget(self: *Text) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Text",
-        self.keybinds,
-        self,
-        deinit,
-        null,
-        draw,
-        null,
-        handle,
-        null,
-    );
-    return &self.instance.?;
-}
-
-pub fn positionX(self: *Text, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addX(self.width);
-}
-
-pub fn positionY(self: *Text, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = original_pos.addY(1);
-}
-
-pub fn positionXY(self: *Text, original_pos: Position) void {
-    self.component_pos = original_pos;
-    self.children_pos = Position.init(
-        self.width,
-        1,
-    ).add(original_pos);
-}
-
-pub fn childrenPosition(self: Text) Position {
-    return self.children_pos;
-}
-
-pub fn clear(self: *Text) void {
-    self.text.clearRetainingCapacity();
-    self.end = 0;
-    self.cursor = 0;
-    self.visible_start = 0;
-}
-
-pub fn toggleMask(self: *Text) void {
-    self.masked = !self.masked;
-}
-
-pub fn handle(self: *Text, maybe_key: ?keyboard.Key) !void {
-    if (maybe_key) |key| {
-        if (self.should_insert) {
-            const maybe_character = key.getEnabledPrintableAscii();
-            if (maybe_character) |character| try self.write(character);
-        }
-    }
-
-    if (self.masked and self.maybe_mask == null) {
-        TerminalBuffer.setCursor(
-            self.component_pos.x,
-            self.component_pos.y,
-        );
-        return;
-    }
-
-    TerminalBuffer.setCursor(
-        self.component_pos.x + (self.cursor - self.visible_start),
-        self.component_pos.y,
-    );
-}
-
-fn draw(self: *Text) void {
-    if (self.masked) {
-        if (self.maybe_mask) |mask| {
-            if (self.width < 1) return;
-
-            const length = @min(TerminalBuffer.strWidth(self.text.items), self.width - 1);
-            if (length == 0) return;
-
-            TerminalBuffer.drawCharMultiple(
-                mask,
-                self.component_pos.x,
-                self.component_pos.y,
-                length,
-                self.fg,
-                self.bg,
-            );
-        }
-        return;
-    }
-
-    const str_length = TerminalBuffer.strWidth(self.text.items);
-    const length = @min(str_length, self.width);
-    if (length == 0) return;
-
-    const visible_slice = vs: {
-        if (str_length > self.width and self.cursor < str_length) {
-            break :vs self.text.items[self.visible_start..(self.width + self.visible_start)];
-        } else {
-            break :vs self.text.items[self.visible_start..];
-        }
-    };
-
-    TerminalBuffer.drawText(
-        visible_slice,
-        self.component_pos.x,
-        self.component_pos.y,
-        self.fg,
-        self.bg,
-    );
-}
-
-fn goLeft(ptr: *anyopaque) !bool {
-    var self: *Text = @ptrCast(@alignCast(ptr));
-
-    if (self.cursor == 0) return false;
-    if (self.visible_start > 0) self.visible_start -= 1;
-
-    self.cursor -= 1;
-    return false;
-}
-
-fn goRight(ptr: *anyopaque) !bool {
-    var self: *Text = @ptrCast(@alignCast(ptr));
-
-    if (self.cursor >= self.end) return false;
-    if (self.cursor - self.visible_start == self.width - 1) self.visible_start += 1;
-
-    self.cursor += 1;
-    return false;
-}
-
-fn delete(ptr: *anyopaque) !bool {
-    var self: *Text = @ptrCast(@alignCast(ptr));
-
-    if (self.cursor >= self.end or !self.should_insert) return false;
-
-    _ = self.text.orderedRemove(self.cursor);
-
-    self.end -= 1;
-    return false;
-}
-
-fn backspace(ptr: *anyopaque) !bool {
-    const self: *Text = @ptrCast(@alignCast(ptr));
-
-    if (self.cursor == 0 or !self.should_insert) return false;
-
-    _ = try goLeft(ptr);
-    _ = try delete(ptr);
-    return false;
-}
-
-fn write(self: *Text, char: u8) !void {
-    if (char == 0) return;
-
-    try self.text.insert(self.allocator, self.cursor, char);
-
-    self.end += 1;
-    _ = try goRight(self);
-}
-
-fn clearTextEntry(ptr: *anyopaque) !bool {
-    var self: *Text = @ptrCast(@alignCast(ptr));
-
-    if (!self.should_insert) return false;
-
-    self.clear();
-    self.buffer.drawNextFrame(true);
-    return false;
-}

ly-ui/src/components/generic.zig

@@ -1,172 +0,0 @@
-const std = @import("std");
-
-const Cell = @import("../Cell.zig");
-const keyboard = @import("../keyboard.zig");
-const TerminalBuffer = @import("../TerminalBuffer.zig");
-const Position = @import("../Position.zig");
-
-pub fn CyclableLabel(comptime ItemType: type, comptime ChangeItemType: type) type {
-    return struct {
-        const Allocator = std.mem.Allocator;
-        const ItemList = std.ArrayListUnmanaged(ItemType);
-        const DrawItemFn = *const fn (*Self, ItemType, usize, usize, usize) void;
-        const ChangeItemFn = *const fn (ItemType, ?ChangeItemType) void;
-
-        const Self = @This();
-
-        allocator: Allocator,
-        buffer: *TerminalBuffer,
-        list: ItemList,
-        current: usize,
-        width: usize,
-        component_pos: Position,
-        children_pos: Position,
-        text_in_center: bool,
-        fg: u32,
-        bg: u32,
-        cursor: usize,
-        draw_item_fn: DrawItemFn,
-        change_item_fn: ?ChangeItemFn,
-        change_item_arg: ?ChangeItemType,
-        keybinds: TerminalBuffer.KeybindMap,
-
-        pub fn init(
-            allocator: Allocator,
-            io: std.Io,
-            buffer: *TerminalBuffer,
-            draw_item_fn: DrawItemFn,
-            change_item_fn: ?ChangeItemFn,
-            change_item_arg: ?ChangeItemType,
-            width: usize,
-            text_in_center: bool,
-            fg: u32,
-            bg: u32,
-        ) !*Self {
-            var self = try allocator.create(Self);
-            self.* = .{
-                .allocator = allocator,
-                .buffer = buffer,
-                .list = .empty,
-                .current = 0,
-                .width = width,
-                .component_pos = TerminalBuffer.START_POSITION,
-                .children_pos = TerminalBuffer.START_POSITION,
-                .text_in_center = text_in_center,
-                .fg = fg,
-                .bg = bg,
-                .cursor = 0,
-                .draw_item_fn = draw_item_fn,
-                .change_item_fn = change_item_fn,
-                .change_item_arg = change_item_arg,
-                .keybinds = .init(allocator),
-            };
-
-            try buffer.registerKeybind(io, &self.keybinds, "Left", &goLeft, self);
-            try buffer.registerKeybind(io, &self.keybinds, "Ctrl+H", &goLeft, self);
-            try buffer.registerKeybind(io, &self.keybinds, "Right", &goRight, self);
-            try buffer.registerKeybind(io, &self.keybinds, "Ctrl+L", &goRight, self);
-
-            return self;
-        }
-
-        pub fn deinit(self: *Self) void {
-            self.list.deinit(self.allocator);
-            self.keybinds.deinit();
-            self.allocator.destroy(self);
-        }
-
-        pub fn positionX(self: *Self, original_pos: Position) void {
-            self.component_pos = original_pos;
-            self.cursor = self.component_pos.x + 2;
-            self.children_pos = original_pos.addX(self.width);
-        }
-
-        pub fn positionY(self: *Self, original_pos: Position) void {
-            self.component_pos = original_pos;
-            self.cursor = self.component_pos.x + 2;
-            self.children_pos = original_pos.addY(1);
-        }
-
-        pub fn positionXY(self: *Self, original_pos: Position) void {
-            self.component_pos = original_pos;
-            self.cursor = self.component_pos.x + 2;
-            self.children_pos = Position.init(
-                self.width,
-                1,
-            ).add(original_pos);
-        }
-
-        pub fn childrenPosition(self: Self) Position {
-            return self.children_pos;
-        }
-
-        pub fn addItem(self: *Self, item: ItemType) !void {
-            try self.list.append(self.allocator, item);
-            self.current = self.list.items.len - 1;
-        }
-
-        pub fn handle(self: *Self, _: ?keyboard.Key) void {
-            TerminalBuffer.setCursor(
-                self.component_pos.x + self.cursor + 2,
-                self.component_pos.y,
-            );
-        }
-
-        pub fn draw(self: *Self) void {
-            if (self.list.items.len == 0) return;
-            if (self.width < 2) return;
-
-            var left_arrow = Cell.init('<', self.fg, self.bg);
-            var right_arrow = Cell.init('>', self.fg, self.bg);
-
-            left_arrow.put(self.component_pos.x, self.component_pos.y);
-            right_arrow.put(
-                self.component_pos.x + self.width - 1,
-                self.component_pos.y,
-            );
-
-            const current_item = self.list.items[self.current];
-            const x = self.component_pos.x + 2;
-            const y = self.component_pos.y;
-            const width = self.width - 2;
-
-            @call(
-                .auto,
-                self.draw_item_fn,
-                .{ self, current_item, x, y, width },
-            );
-        }
-
-        fn goLeft(ptr: *anyopaque) !bool {
-            var self: *Self = @ptrCast(@alignCast(ptr));
-
-            self.current = if (self.current == 0) self.list.items.len - 1 else self.current - 1;
-
-            if (self.change_item_fn) |change_item_fn| {
-                @call(
-                    .auto,
-                    change_item_fn,
-                    .{ self.list.items[self.current], self.change_item_arg },
-                );
-            }
-
-            return false;
-        }
-
-        fn goRight(ptr: *anyopaque) !bool {
-            var self: *Self = @ptrCast(@alignCast(ptr));
-
-            self.current = if (self.current == self.list.items.len - 1) 0 else self.current + 1;
-
-            if (self.change_item_fn) |change_item_fn| {
-                @call(
-                    .auto,
-                    change_item_fn,
-                    .{ self.list.items[self.current], self.change_item_arg },
-                );
-            }
-
-            return false;
-        }
-    };
-}

ly-ui/src/keyboard.zig

@@ -1,708 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-const KeyList = std.ArrayList(Key);
-
-const TerminalBuffer = @import("TerminalBuffer.zig");
-const termbox = TerminalBuffer.termbox;
-
-pub const Key = packed struct {
-    ctrl: bool,
-    shift: bool,
-    alt: bool,
-
-    f1: bool,
-    f2: bool,
-    f3: bool,
-    f4: bool,
-    f5: bool,
-    f6: bool,
-    f7: bool,
-    f8: bool,
-    f9: bool,
-    f10: bool,
-    f11: bool,
-    f12: bool,
-
-    insert: bool,
-    delete: bool,
-    home: bool,
-    end: bool,
-    pageup: bool,
-    pagedown: bool,
-    up: bool,
-    down: bool,
-    left: bool,
-    right: bool,
-    tab: bool,
-    backspace: bool,
-    enter: bool,
-
-    @" ": bool,
-    @"!": bool,
-    @"`": bool,
-    esc: bool,
-    @"[": bool,
-    @"\\": bool,
-    @"]": bool,
-    @"/": bool,
-    _: bool,
-    @"'": bool,
-    @"\"": bool,
-    @",": bool,
-    @"-": bool,
-    @".": bool,
-    @"#": bool,
-    @"$": bool,
-    @"%": bool,
-    @"&": bool,
-    @"*": bool,
-    @"(": bool,
-    @")": bool,
-    @"+": bool,
-    @"=": bool,
-    @":": bool,
-    @";": bool,
-    @"<": bool,
-    @">": bool,
-    @"?": bool,
-    @"@": bool,
-    @"^": bool,
-    @"~": bool,
-    @"{": bool,
-    @"}": bool,
-    @"|": bool,
-
-    @"0": bool,
-    @"1": bool,
-    @"2": bool,
-    @"3": bool,
-    @"4": bool,
-    @"5": bool,
-    @"6": bool,
-    @"7": bool,
-    @"8": bool,
-    @"9": bool,
-
-    a: bool,
-    b: bool,
-    c: bool,
-    d: bool,
-    e: bool,
-    f: bool,
-    g: bool,
-    h: bool,
-    i: bool,
-    j: bool,
-    k: bool,
-    l: bool,
-    m: bool,
-    n: bool,
-    o: bool,
-    p: bool,
-    q: bool,
-    r: bool,
-    s: bool,
-    t: bool,
-    u: bool,
-    v: bool,
-    w: bool,
-    x: bool,
-    y: bool,
-    z: bool,
-
-    pub fn getEnabledPrintableAscii(self: Key) ?u8 {
-        if (self.ctrl or self.alt) return null;
-
-        inline for (std.meta.fields(Key)) |field| {
-            if (field.name.len == 1 and std.ascii.isPrint(field.name[0]) and @field(self, field.name)) {
-                if (self.shift) {
-                    if (!std.ascii.isAlphanumeric(field.name[0])) return null;
-                    return std.ascii.toUpper(field.name[0]);
-                }
-
-                return field.name[0];
-            }
-        }
-
-        return null;
-    }
-};
-
-pub fn getKeyList(allocator: Allocator, tb_event: termbox.tb_event) !KeyList {
-    var keys: KeyList = .empty;
-    var key = std.mem.zeroes(Key);
-
-    if (tb_event.mod & termbox.TB_MOD_CTRL != 0) key.ctrl = true;
-    if (tb_event.mod & termbox.TB_MOD_SHIFT != 0) key.shift = true;
-    if (tb_event.mod & termbox.TB_MOD_ALT != 0) key.alt = true;
-
-    if (tb_event.key == termbox.TB_KEY_BACK_TAB) {
-        key.shift = true;
-        key.tab = true;
-    } else if (tb_event.key > termbox.TB_KEY_BACK_TAB) {
-        const code = 0xFFFF - tb_event.key;
-
-        switch (code) {
-            0 => key.f1 = true,
-            1 => key.f2 = true,
-            2 => key.f3 = true,
-            3 => key.f4 = true,
-            4 => key.f5 = true,
-            5 => key.f6 = true,
-            6 => key.f7 = true,
-            7 => key.f8 = true,
-            8 => key.f9 = true,
-            9 => key.f10 = true,
-            10 => key.f11 = true,
-            11 => key.f12 = true,
-            12 => key.insert = true,
-            13 => key.delete = true,
-            14 => key.home = true,
-            15 => key.end = true,
-            16 => key.pageup = true,
-            17 => key.pagedown = true,
-            18 => key.up = true,
-            19 => key.down = true,
-            20 => key.left = true,
-            21 => key.right = true,
-            else => {},
-        }
-    } else if (tb_event.ch < 128) {
-        const code = if (tb_event.ch == 0 and tb_event.key < 128) tb_event.key else tb_event.ch;
-
-        switch (code) {
-            0 => {
-                key.ctrl = true;
-                key.@"2" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"`" = true;
-            },
-            1 => {
-                key.ctrl = true;
-                key.a = true;
-            },
-            2 => {
-                key.ctrl = true;
-                key.b = true;
-            },
-            3 => {
-                key.ctrl = true;
-                key.c = true;
-            },
-            4 => {
-                key.ctrl = true;
-                key.d = true;
-            },
-            5 => {
-                key.ctrl = true;
-                key.e = true;
-            },
-            6 => {
-                key.ctrl = true;
-                key.f = true;
-            },
-            7 => {
-                key.ctrl = true;
-                key.g = true;
-            },
-            8 => {
-                key.ctrl = true;
-                key.h = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.backspace = true;
-            },
-            9 => {
-                key.ctrl = true;
-                key.i = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.tab = true;
-            },
-            10 => {
-                key.ctrl = true;
-                key.j = true;
-            },
-            11 => {
-                key.ctrl = true;
-                key.k = true;
-            },
-            12 => {
-                key.ctrl = true;
-                key.l = true;
-            },
-            13 => {
-                key.ctrl = true;
-                key.m = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.enter = true;
-            },
-            14 => {
-                key.ctrl = true;
-                key.n = true;
-            },
-            15 => {
-                key.ctrl = true;
-                key.o = true;
-            },
-            16 => {
-                key.ctrl = true;
-                key.p = true;
-            },
-            17 => {
-                key.ctrl = true;
-                key.q = true;
-            },
-            18 => {
-                key.ctrl = true;
-                key.r = true;
-            },
-            19 => {
-                key.ctrl = true;
-                key.s = true;
-            },
-            20 => {
-                key.ctrl = true;
-                key.t = true;
-            },
-            21 => {
-                key.ctrl = true;
-                key.u = true;
-            },
-            22 => {
-                key.ctrl = true;
-                key.v = true;
-            },
-            23 => {
-                key.ctrl = true;
-                key.w = true;
-            },
-            24 => {
-                key.ctrl = true;
-                key.x = true;
-            },
-            25 => {
-                key.ctrl = true;
-                key.y = true;
-            },
-            26 => {
-                key.ctrl = true;
-                key.z = true;
-            },
-            27 => {
-                key.ctrl = true;
-                key.@"3" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.esc = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"[" = true;
-            },
-            28 => {
-                key.ctrl = true;
-                key.@"4" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"\\" = true;
-            },
-            29 => {
-                key.ctrl = true;
-                key.@"5" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"]" = true;
-            },
-            30 => {
-                key.ctrl = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"6" = true;
-            },
-            31 => {
-                key.ctrl = true;
-                key.@"7" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"/" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key._ = true;
-            },
-            32 => {
-                key.@" " = true;
-            },
-            33 => {
-                key = std.mem.zeroes(Key);
-                key.@"!" = true;
-            },
-            34 => {
-                key = std.mem.zeroes(Key);
-                key.@"\"" = true;
-            },
-            35 => {
-                key = std.mem.zeroes(Key);
-                key.@"#" = true;
-            },
-            36 => {
-                key = std.mem.zeroes(Key);
-                key.@"$" = true;
-            },
-            37 => {
-                key = std.mem.zeroes(Key);
-                key.@"%" = true;
-            },
-            38 => {
-                key = std.mem.zeroes(Key);
-                key.@"&" = true;
-            },
-            39 => {
-                key.@"'" = true;
-            },
-            40 => {
-                key = std.mem.zeroes(Key);
-                key.@"(" = true;
-            },
-            41 => {
-                key = std.mem.zeroes(Key);
-                key.@")" = true;
-            },
-            42 => {
-                key = std.mem.zeroes(Key);
-                key.@"*" = true;
-            },
-            43 => {
-                key = std.mem.zeroes(Key);
-                key.@"+" = true;
-            },
-            44 => {
-                key.@"," = true;
-            },
-            45 => {
-                key.@"-" = true;
-            },
-            46 => {
-                key.@"." = true;
-            },
-            47 => {
-                key.@"/" = true;
-            },
-            48 => {
-                key.@"0" = true;
-            },
-            49 => {
-                key.@"1" = true;
-            },
-            50 => {
-                key.@"2" = true;
-            },
-            51 => {
-                key.@"3" = true;
-            },
-            52 => {
-                key.@"4" = true;
-            },
-            53 => {
-                key.@"5" = true;
-            },
-            54 => {
-                key.@"6" = true;
-            },
-            55 => {
-                key.@"7" = true;
-            },
-            56 => {
-                key.@"8" = true;
-            },
-            57 => {
-                key.@"9" = true;
-            },
-            58 => {
-                key.shift = true;
-                key.@":" = true;
-            },
-            59 => {
-                key.@";" = true;
-            },
-            60 => {
-                key.shift = true;
-                key.@"<" = true;
-            },
-            61 => {
-                key.@"=" = true;
-            },
-            62 => {
-                key.shift = true;
-                key.@">" = true;
-            },
-            63 => {
-                key.shift = true;
-                key.@"?" = true;
-            },
-            64 => {
-                key.shift = true;
-                key.@"2" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"@" = true;
-            },
-            65 => {
-                key.shift = true;
-                key.a = true;
-            },
-            66 => {
-                key.shift = true;
-                key.b = true;
-            },
-            67 => {
-                key.shift = true;
-                key.c = true;
-            },
-            68 => {
-                key.shift = true;
-                key.d = true;
-            },
-            69 => {
-                key.shift = true;
-                key.e = true;
-            },
-            70 => {
-                key.shift = true;
-                key.f = true;
-            },
-            71 => {
-                key.shift = true;
-                key.g = true;
-            },
-            72 => {
-                key.shift = true;
-                key.h = true;
-            },
-            73 => {
-                key.shift = true;
-                key.i = true;
-            },
-            74 => {
-                key.shift = true;
-                key.j = true;
-            },
-            75 => {
-                key.shift = true;
-                key.k = true;
-            },
-            76 => {
-                key.shift = true;
-                key.l = true;
-            },
-            77 => {
-                key.shift = true;
-                key.m = true;
-            },
-            78 => {
-                key.shift = true;
-                key.n = true;
-            },
-            79 => {
-                key.shift = true;
-                key.o = true;
-            },
-            80 => {
-                key.shift = true;
-                key.p = true;
-            },
-            81 => {
-                key.shift = true;
-                key.q = true;
-            },
-            82 => {
-                key.shift = true;
-                key.r = true;
-            },
-            83 => {
-                key.shift = true;
-                key.s = true;
-            },
-            84 => {
-                key.shift = true;
-                key.t = true;
-            },
-            85 => {
-                key.shift = true;
-                key.u = true;
-            },
-            86 => {
-                key.shift = true;
-                key.v = true;
-            },
-            87 => {
-                key.shift = true;
-                key.w = true;
-            },
-            88 => {
-                key.shift = true;
-                key.x = true;
-            },
-            89 => {
-                key.shift = true;
-                key.y = true;
-            },
-            90 => {
-                key.shift = true;
-                key.z = true;
-            },
-            91 => {
-                key.@"[" = true;
-            },
-            92 => {
-                key.@"\\" = true;
-            },
-            93 => {
-                key.@"]" = true;
-            },
-            94 => {
-                key = std.mem.zeroes(Key);
-                key.@"^" = true;
-            },
-            95 => {
-                key.shift = true;
-                key.@"-" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key._ = true;
-            },
-            96 => {
-                key.@"`" = true;
-            },
-            97 => {
-                key.a = true;
-            },
-            98 => {
-                key.b = true;
-            },
-            99 => {
-                key.c = true;
-            },
-            100 => {
-                key.d = true;
-            },
-            101 => {
-                key.e = true;
-            },
-            102 => {
-                key.f = true;
-            },
-            103 => {
-                key.g = true;
-            },
-            104 => {
-                key.h = true;
-            },
-            105 => {
-                key.i = true;
-            },
-            106 => {
-                key.j = true;
-            },
-            107 => {
-                key.k = true;
-            },
-            108 => {
-                key.l = true;
-            },
-            109 => {
-                key.m = true;
-            },
-            110 => {
-                key.n = true;
-            },
-            111 => {
-                key.o = true;
-            },
-            112 => {
-                key.p = true;
-            },
-            113 => {
-                key.q = true;
-            },
-            114 => {
-                key.r = true;
-            },
-            115 => {
-                key.s = true;
-            },
-            116 => {
-                key.t = true;
-            },
-            117 => {
-                key.u = true;
-            },
-            118 => {
-                key.v = true;
-            },
-            119 => {
-                key.w = true;
-            },
-            120 => {
-                key.x = true;
-            },
-            121 => {
-                key.y = true;
-            },
-            122 => {
-                key.z = true;
-            },
-            123 => {
-                key.shift = true;
-                key.@"{" = true;
-            },
-            124 => {
-                key.shift = true;
-                key.@"\\" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"|" = true;
-            },
-            125 => {
-                key.shift = true;
-                key.@"}" = true;
-            },
-            126 => {
-                key.shift = true;
-                key.@"`" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.@"~" = true;
-            },
-            127 => {
-                key.ctrl = true;
-                key.@"8" = true;
-                try keys.append(allocator, key);
-
-                key = std.mem.zeroes(Key);
-                key.backspace = true;
-            },
-            else => {},
-        }
-    }
-
-    try keys.append(allocator, key);
-
-    return keys;
-}

ly-ui/src/root.zig

@@ -1,13 +0,0 @@
-pub const ly_core = @import("ly-core");
-
-pub const Cell = @import("Cell.zig");
-pub const keyboard = @import("keyboard.zig");
-pub const Position = @import("Position.zig");
-pub const TerminalBuffer = @import("TerminalBuffer.zig");
-pub const Widget = @import("Widget.zig");
-
-pub const BigLabel = @import("components/BigLabel.zig");
-pub const Box = @import("components/Box.zig");
-pub const CyclableLabel = @import("components/generic.zig").CyclableLabel;
-pub const Label = @import("components/Label.zig");
-pub const Text = @import("components/Text.zig");

readme.md

@@ -1,262 +1,255 @@
-# The Ly display manager
 
+# Ly - a TUI display manager
 ![Ly screenshot](.github/screenshot.png "Ly screenshot")
 
-_Note: the above animation can be found [here](https://codeberg.org/attachments/f336d6ac-8331-4323-91fc-0e4619803401)!_
+Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD.
-
-Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD, designed with portability in mind and doesn't require systemd to run.
-
-Join us on Matrix over at [#ly-dm:matrix.org](https://matrix.to/#/#ly-dm:matrix.org)!
-
-> [!NOTE]
-> Development happens on [Codeberg](https://codeberg.org/fairyglade/ly) with a mirror on [GitHub](https://github.com/fairyglade/ly).
 
 ## Dependencies
-
 - Compile-time:
-  - zig 0.16.x
+  - zig >=0.12.0
-
   - libc
-
   - pam
-
   - xcb (optional, required by default; needed for X11 support)
-
 - Runtime (with default config):
   - xorg
-
   - xorg-xauth
-
   - shutdown
 
-  - brightnessctl
-
 ### Debian
-
 ```
-# apt install build-essential libpam0g-dev libxcb-xkb-dev xauth xserver-xorg brightnessctl
+# apt install build-essential libpam0g-dev libxcb-xkb-dev
 ```
 
 ### Fedora
-
+**Warning**: You may encounter issues with SELinux on Fedora.
-> [!WARNING]
+It is recommended to add a rule for Ly as it currently does not ship one.
-> You may encounter issues with SELinux on Fedora. It is recommended to add a rule for Ly as it currently does not ship one.
 
 ```
-# dnf install kernel-devel pam-devel libxcb-devel zig xorg-x11-xauth xorg-x11-server brightnessctl
+# dnf install kernel-devel pam-devel libxcb-devel zig
 ```
 
-### FreeBSD
-
-```
-# pkg install ca_root_nss libxcb git xorg xauth
-```
-
-## Availability
-
-[![Packaging status](https://repology.org/badge/vertical-allrepos/ly-display-manager.svg?exclude_unsupported=1)](https://repology.org/project/ly-display-manager/versions)
-
 ## Support
+The following desktop environments were tested with success:
+ - awesome
+ - bspwm
+ - budgie
+ - cinnamon
+ - cosmic
+ - deepin
+ - dwl
+ - dwm
+ - enlightenment
+ - gnome
+ - hyprland
+ - i3
+ - kde
+ - labwc
+ - lxde
+ - lxqt
+ - mate
+ - maxx
+ - pantheon
+ - qtile
+ - spectrwm
+ - sway
+ - windowmaker
+ - xfce
+ - xmonad
 
-Every environment that works on other login managers also should work on Ly.
+Ly should work with any X desktop environment, and provides
+basic wayland support (sway works very well, for example).
 
-- Unlike most login managers Ly has an xinitrc and shell entry.
+## systemd?
-
+Unlike what you may have heard, Ly does not require `systemd`,
-- If you installed your favorite environment and you don't see it, that's because Ly doesn't automatically refresh itself. To fix this you should restart Ly service (depends on your init system) or the easy way is to reboot your system.
+and was even specifically designed not to depend on `logind`.
-
+You should be able to make it work easily with a better init,
-- If your environment is still missing then check at `/usr/share/xsessions` or `/usr/share/wayland-sessions` to see if a .desktop file is present.
+changing the source code won't be necessary :)
-
-- If there isn't a .desktop file then create a new one at `/etc/ly/custom-sessions` that launches your favorite environment. These .desktop files can be only seen by Ly and if you want them system-wide you also can create at those directories instead.
-
-- If Xorg sessions don't work then check if your distro compiles Ly with Xorg.
-
-Logs are defined by `/etc/ly/config.ini`:
-
-- The session log is located at `~/.local/state/ly-session.log` by default.
-
-- The system log is located at `/var/log/ly.log` by default.
-
-## Manually building
-
-The procedure for manually building Ly is pretty standard:
 
+## Cloning and Compiling
+Clone the repository
+```
+$ git clone https://github.com/fairyglade/ly
+```
+
+Change the directory to ly
 ```
-$ git clone https://codeberg.org/fairyglade/ly.git
 $ cd ly
+```
+
+Compile
+```
 $ zig build
 ```
 
-After building, you can (optionally) test Ly in a terminal emulator, although authentication will **not** work:
+Test in the configured tty (tty2 by default)
-
+or a terminal emulator (but desktop environments won't start)
 ```
-$ zig build run
+# zig build run
 ```
 
-> [!IMPORTANT]
+Install Ly and the provided systemd service file
-> While you can run Ly in a terminal emulator as root, it is **not** recommended. If you want to test Ly, please enable its service (as described below) and reboot your machine.
-
-The next sections will explain how to use Ly with a variety of init systems. Detailed explanation is only given for systemd, but should be applicable for all.
-
-> [!NOTE]
-> All following sections will assume you are using LightDM for convenience sake.
-
-### systemd
-
-Now, you can install Ly on your system:
-
 ```
-# zig build installexe -Dinit_system=systemd
+# zig build installsystemd
 ```
 
-> [!NOTE]
+Enable the service
-> The `init_system` parameter is optional and defaults to `systemd`.
-
-Note that you also need to disable your current display manager. For example, if you are using LightDM, you can execute the following command:
-
 ```
-# systemctl disable lightdm.service
+# systemctl enable ly.service
 ```
 
-Then, similarly to the previous command, you need to enable the Ly service:
+If you need to switch between ttys after Ly's start you also have to
-
+disable getty on Ly's tty to prevent "login" from spawning on top of it
-```
-# systemctl enable ly@tty2.service
-```
-
-> [!IMPORTANT]
-> Because Ly runs in a TTY, you **must** disable the TTY service that Ly will run on, otherwise bad things will happen. For example, to disable `getty` spawning on TTY 2, you need to execute the following command:
-
 ```
 # systemctl disable getty@tty2.service
 ```
 
-On platforms that use systemd-logind to dynamically start `autovt@.service` instances when the switch to a new tty occurs, any ly instances for ttys _except the default tty_ need to be enabled using a different mechanism: To autostart ly on switch to `tty2`, do not enable any `ly` unit directly, instead symlink `autovt@tty2.service` to `ly@tty2.service` within `/usr/lib/systemd/system/` (analogous for every other tty you want to enable ly on).
-
-The target of the symlink, `ly@ttyN.service`, does not actually exist, but systemd nevertheless recognizes that the instanciation of `autovt@.service` with `%I` equal to `ttyN` now points to an instanciation of `ly@.service` with `%I` set to `ttyN`.
-
-Compare to `man 5 logind.conf`, especially regarding the `NAutoVTs=` and `ReserveVT=` parameters.
-
-On non-systemd systems, you can change the TTY Ly will run on by editing the corresponding service file for your platform.
-
 ### OpenRC
+**NOTE 1**: On Gentoo, Ly will disable the `display-manager-init` service in order to run.
 
+Clone, compile and test.
+
+Install Ly and the provided OpenRC service
+```
+# zig build installopenrc
+```
+
+Enable the service
 ```
-# zig build installexe -Dinit_system=openrc
-# rc-update del lightdm
 # rc-update add ly
+```
+
+You can edit which tty Ly will start on by editing the `tty` option in the configuration file.
+
+If you choose a tty that already has a login/getty running (has a basic login prompt),
+then you have to disable getty, so it doesn't respawn on top of ly
+```
 # rc-update del agetty.tty2
 ```
 
-> [!NOTE]
+**NOTE 2**: To avoid a console spawning on top on Ly, comment out the appropriate line from /etc/inittab (default is 2).
-> On Gentoo specifically, you also **must** comment out the appropriate line for the TTY in /etc/inittab.
 
 ### runit
+```
+# zig build installrunit
+# ln -s /etc/sv/ly /var/service/
+```
+
+By default, ly will run on tty2. To change the tty it must be set in `/etc/ly/config.ini`
+
+You should as well disable your existing display manager service if needed, e.g.:
+
+```
+# rm /var/service/lxdm
+```
+
+The agetty service for the tty console where you are running ly should be disabled.
+For instance, if you are running ly on tty2 (that's the default, check your `/etc/ly/config.ini`)
+you should disable the agetty-tty2 service like this:
 
 ```
-# zig build installexe -Dinit_system=runit
-# rm /var/service/lightdm
-# ln -s /etc/sv/ly /var/service/
 # rm /var/service/agetty-tty2
 ```
 
 ### s6
+```
+# zig build installs6
+```
+
+Then, edit `/etc/s6/config/ttyX.conf` and set `SPAWN="no"`, where X is the TTY ID (e.g. `2`).
+
+Finally, enable the service:
 
 ```
-# zig build installexe -Dinit_system=s6
-# s6-rc -d change lightdm
 # s6-service add default ly-srv
 # s6-db-reload
 # s6-rc -u change ly-srv
 ```
 
-To disable TTY 2, edit `/etc/s6/config/tty2.conf` and set `SPAWN="no"`.
-
 ### dinit
-
 ```
-# zig build installexe -Dinit_system=dinit
+# zig build installdinit
-# dinitctl disable lightdm
 # dinitctl enable ly
 ```
 
-To disable TTY 2, go to `/etc/dinit.d/config/console.conf` and modify `ACTIVE_CONSOLES`.
+In addition to the steps above, you will also have to keep a TTY free within `/etc/dinit.d/config/console.conf`.
 
-### sysvinit
+To do that, change `ACTIVE_CONSOLES` so that the tty that ly should use in `/etc/ly/config.ini` is free.
-
-```
-# zig build installexe -Dinit_system=sysvinit
-# update-rc.d lightdm disable
-# update-rc.d ly defaults
-```
-
-To disable TTY 2, go to `/etc/inittab` and comment out the line containing `tty2`.
-
-### FreeBSD
-
-```
-# zig build installexe -Dprefix_directory=/usr/local -Dconfig_directory=/usr/local/etc -Dinit_system=freebsd
-# sysrc lightdm_enable="NO"
-```
-
-To enable Ly, add the following entry to `/etc/gettytab`:
-
-```
-Ly:\
-	:lo=/usr/local/bin/ly_wrapper:\
-	:al=root:
-```
-
-Then, modify the command field of the `ttyv1` terminal entry in `/etc/ttys` (TTYs in FreeBSD start at 0):
-
-```
-ttyv1 "/usr/libexec/getty Ly" xterm on secure
-```
 
 ### Updating
-
+You can also install Ly without copying the system service and the configuration file. That's
-You can also install Ly without overrding the current configuration file. This is called **updating**. To update, simply run:
+called *updating*. To update, simply run:
 
 ```
 # zig build installnoconf
 ```
 
-You can, of course, still select the init system of your choice when using this command.
+If you want to also copy the default config file (but still not the system service), run:
+
+```
+# zig build installexe
+```
+
+## Arch Linux Installation
+You can install ly from the [`[extra]` repos](https://archlinux.org/packages/extra/x86_64/ly/):
+```
+$ sudo pacman -S ly
+```
+
+## Gentoo Installation
+You can install ly from the GURU repository:
+
+Note: If the package is masked, you may need to unmask it using ~amd64 keyword:
+```bash
+# echo 'x11-misc/ly ~amd64' >> /etc/portage/package.accept_keywords
+```
+
+1. Enable the GURU repository:
+```bash
+# eselect repository enable guru
+```
+
+2. Sync the GURU repository:
+```bash
+# emaint sync -r guru
+```
+
+3. Install ly from source:
+```bash
+# emerge --ask x11-misc/ly
+```
 
 ## Configuration
-
+You can find all the configuration in `/etc/ly/config.ini`.
-You can find all the configuration in `/etc/ly/config.ini`. The file is fully commented, and includes the default values.
+The file is commented, and includes the default values.
 
 ## Controls
+Use the up and down arrow keys to change the current field, and the
+left and right arrow keys to change the target desktop environment
+while on the desktop field (above the login field).
 
-Use the Up/Down arrow keys to change the current field, and the Left/Right arrow keys to scroll through the different fields (whether it be the info line, the desktop environment, or the username). The info line is where messages and errors are displayed.
+## .xinitrc
-
+If your .xinitrc doesn't work make sure it is executable and includes a shebang.
-## A note on .xinitrc
+This file is supposed to be a shell script! Quoting from xinit's man page:
-
-If your `.xinitrc` file doesn't work ,make sure it is executable and includes a shebang. This file is supposed to be a shell script! Quoting from `xinit`'s man page:
 
 > If no specific client program is given on the command line, xinit will look for a file in the user's home directory called .xinitrc to run as a shell script to start up client programs.
 
-A typical shebang for a shell script looks like this:
+On Arch Linux, the example .xinitrc (/etc/X11/xinit/xinitrc) starts like this:
-
 ```
 #!/bin/sh
 ```
 
 ## Tips
+The numlock and capslock state is printed in the top-right corner.
+Use the F1 and F2 keys to respectively shutdown and reboot.
+Take a look at your .xsession if X doesn't start, as it can interfere
+(this file is launched with X to configure the display properly).
 
-- The numlock and capslock state is printed in the top-right corner.
+## PSX DOOM fire animation
+To enable the famous PSX DOOM fire described by [Fabien Sanglard](http://fabiensanglard.net/doom_fire_psx/index.html),
+just set `animation = doom` in `/etc/ly/config.ini`. You may also
+disable the main box borders with `hide_borders = true`.
 
-- Use the F1 and F2 keys to respectively shutdown and reboot.
+## Additional Information
+The name "Ly" is a tribute to the fairy from the game Rayman.
+Ly was tested by oxodao, who is some seriously awesome dude.
 
-- Take a look at your `.xsession` file if X doesn't start, as it can interfere (this file is launched with X to configure the display properly).
-
-## A final note
-
-The name "Ly" is a tribute to the fairy from the game Rayman. Ly was tested by oxodao, who is some seriously awesome dude.
-
-Also, Ly wouldn't be there today without [ashametrine](https://github.com/ashametrine), who has done significant contributions to the project for the Zig rewrite, which lead to the release of Ly v1.0.0. Massive thanks, and sorry for not crediting you enough beforehand!
-
-### Donate
-
-If you like Ly and wish to support my work further, feel free to donate via my
-[Liberapay link](https://liberapay.com/ShiningLea)!

res/config.ini

@@ -1,82 +1,55 @@
-# Ly supports 24-bit true color with styling, which means each color is a 32-bit value.
+# The color settings in Ly take a digit 0-8 corresponding to:
-# The format is 0xSSRRGGBB, where SS is the styling, RR is red, GG is green, and BB is blue.
+#define TB_DEFAULT 0x00
-# Here are the possible styling options:
+#define TB_BLACK   0x01
-# TB_BOLD      0x01000000
+#define TB_RED     0x02
-# TB_UNDERLINE 0x02000000
+#define TB_GREEN   0x03
-# TB_REVERSE   0x04000000
+#define TB_YELLOW  0x04
-# TB_ITALIC    0x08000000
+#define TB_BLUE    0x05
-# TB_BLINK     0x10000000
+#define TB_MAGENTA 0x06
-# TB_HI_BLACK  0x20000000
+#define TB_CYAN    0x07
-# TB_BRIGHT    0x40000000
+#define TB_WHITE   0x08
-# TB_DIM       0x80000000
+# The default color varies, but usually it makes the background black and the foreground white.
-# Programmatically, you'd apply them using the bitwise OR operator (|), but because Ly's
+# You can also combine these colors with the following style attributes using bitwise OR:
-# configuration doesn't support using it, you have to manually compute the color value.
+#define TB_BOLD      0x0100
-# Note that, if you want to use the default color value of the terminal, you can use the
+#define TB_UNDERLINE 0x0200
-# special value 0x00000000. This means that, if you want to use black, you *must* use
+#define TB_REVERSE   0x0400
-# the styling option TB_HI_BLACK (the RGB values are ignored when using this option).
+#define TB_ITALIC    0x0800
-
+#define TB_BLINK     0x1000
-# Allow empty password or not when authenticating
+#define TB_HI_BLACK  0x2000
-allow_empty_password = true
+#define TB_BRIGHT    0x4000
+#define TB_DIM       0x8000
+# For example, to set the foreground color to red and bold, you would do 0x02 | 0x0100 = 0x0102.
+# Note that you must pre-calculate the value because Ly doesn't parse bitwise OR operations in its config.
+#
+# Moreover, to set the VT color palette, you are encouraged to use another tool such as
+# mkinitcpio-colors (https://github.com/evanpurkhiser/mkinitcpio-colors). Note that the color palette defined with
+# mkinitcpio-colors takes 16 colors (0-15), only values 0-8 are valid with Ly and these values do not correspond
+# exactly. For instance, in defining palettes with mkinitcpio-colors, the order is black, dark red, dark green, brown, dark
+# blue, dark purple, dark cyan, light gray, dark gray, bright red, bright green, yellow, bright blue, bright purple, bright
+# cyan, and white, indexed in that order 0 through 15. For example, the color defined for white (indexed at 15 in the mkinitcpio
+# config) will be used by Ly for fg = 0x0008.
 
 # The active animation
-# none     -> Nothing
+# none   -> Nothing
-# doom     -> PSX DOOM fire
+# doom   -> PSX DOOM fire
-# matrix   -> CMatrix
+# matrix -> CMatrix
-# colormix -> Color mixing shader
-# gameoflife -> John Conway's Game of Life
-# dur_file -> .dur file format (https://github.com/cmang/durdraw/tree/master)
 animation = none
 
-# Delay between each animation frame in milliseconds
-animation_frame_delay = 5
-
 # Stop the animation after some time
 # 0 -> Run forever
 # 1..2e12 -> Stop the animation after this many seconds
 animation_timeout_sec = 0
 
 # The character used to mask the password
-# You can either type it directly as a UTF-8 character (like *), or use a UTF-32
-# codepoint (for example 0x2022 for a bullet point)
 # If null, the password will be hidden
 # Note: you can use a # by escaping it like so: \#
 asterisk = *
 
 # The number of failed authentications before a special animation is played... ;)
-# If set to 0, the animation will never be played
 auth_fails = 10
 
-# Identifier for battery whose charge to display at top left
-# Primary battery is usually BAT0 or BAT1
-# If set to null, battery status won't be shown
-battery_id = null
-
-# Automatic login configuration
-# This feature allows Ly to automatically log in a user without password prompt.
-# IMPORTANT: Both auto_login_user and auto_login_session must be set for this to work.
-# Autologin only happens once at startup - it won't re-trigger after logout.
-
-# PAM service name to use for automatic login
-# The default service (ly-autologin) uses pam_permit to allow login without password
-# The appropriate platform-specific PAM configuration (ly-autologin) will be used automatically
-auto_login_service = ly-autologin
-
-# Session name to launch automatically
-# To find available session names, check the .desktop files in:
-#   - /usr/share/xsessions/ (for X11 sessions)
-#   - /usr/share/wayland-sessions/ (for Wayland sessions)
-# Use the filename without .desktop extension, the Name field inside the file or the value of the DesktopNames field
-# Examples: "i3", "sway", "gnome", "plasma", "xfce"
-# If null, automatic login is disabled
-auto_login_session = null
-
-# Username to automatically log in
-# Must be a valid user on the system
-# If null, automatic login is disabled
-auto_login_user = null
-
 # Background color id
-bg = 0x00000000
+bg = 0x0000
 
 # Change the state and language of the big clock
 # none -> Disabled (default)
@@ -84,33 +57,27 @@ bg = 0x00000000
 # fa   -> Farsi
 bigclock = none
 
-# Set bigclock to 12-hour notation.
-bigclock_12hr = false
-
-# Set bigclock to show the seconds.
-bigclock_seconds = false
-
 # Blank main box background
 # Setting to false will make it transparent
 blank_box = true
 
 # Border foreground color id
-border_fg = 0x00FFFFFF
+border_fg = 0x0008
 
 # Title to show at the top of the main box
 # If set to null, none will be shown
 box_title = null
 
-# Brightness decrease command
+# Brightness increase command
-brightness_down_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q -n s 10%-
+brightness_down_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q s 10%-
 
-# Brightness decrease key combination, or null to disable
+# Brightness decrease key
 brightness_down_key = F5
 
 # Brightness increase command
-brightness_up_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q -n s +10%
+brightness_up_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q s +10%
 
-# Brightness increase key combination, or null to disable
+# Brightness increase key
 brightness_up_key = F6
 
 # Erase password input on failure
@@ -121,128 +88,24 @@ clear_password = false
 clock = null
 
 # CMatrix animation foreground color id
-cmatrix_fg = 0x0000FF00
+cmatrix_fg = 0x0003
 
-# CMatrix animation character string head color id
+# Console path
-cmatrix_head_col = 0x01FFFFFF
+console_dev = /dev/console
-
-# CMatrix animation minimum codepoint. It uses a 16-bit integer
-# For Japanese characters for example, you can use 0x3000 here
-cmatrix_min_codepoint = 0x21
-
-# CMatrix animation maximum codepoint. It uses a 16-bit integer
-# For Japanese characters for example, you can use 0x30FF here
-cmatrix_max_codepoint = 0x7B
-
-# Color mixing animation first color id
-colormix_col1 = 0x00FF0000
-
-# Color mixing animation second color id
-colormix_col2 = 0x000000FF
-
-# Color mixing animation third color id
-colormix_col3 = 0x20000000
-
-# For custom binds: the horizontal limit in characters for each
-# line of custom binds before moving on to the next.
-# If null, defaults to the width of the terminal instead.
-custom_bind_width = null
-
-# Custom sessions directory
-# You can specify multiple directories,
-# e.g. $CONFIG_DIRECTORY/ly/custom-sessions:$PREFIX_DIRECTORY/share/custom-sessions
-custom_sessions = $CONFIG_DIRECTORY/ly/custom-sessions
 
 # Input box active by default on startup
 # Available inputs: info_line, session, login, password
 default_input = login
 
-# DOOM animation fire height (1 thru 9)
-doom_fire_height = 6
-
-# DOOM animation fire spread (0 thru 4)
-doom_fire_spread = 2
-
-# DOOM animation custom top color (low intensity flames)
-doom_top_color = 0x009F2707
-
-# DOOM animation custom middle color (medium intensity flames)
-doom_middle_color = 0x00C78F17
-
-# DOOM animation custom bottom color (high intensity flames)
-doom_bottom_color = 0x00FFFFFF
-
-# Dur file path
-dur_file_path = $CONFIG_DIRECTORY/ly/example.dur
-
-# Dur file alignment
-# The dur file can be aligned with a direction and centered easily with the flags below
-# Available inputs: topleft, topcenter, topright, centerleft, center, centerright, bottomleft, bottomcenter, bottomright
-dur_offset_alignment = center
-
-# Dur offset x direction (value is added to the current position determined by alignment, negatives are supported)
-dur_x_offset = 0
-
-# Dur offset y direction (value is added to the current position determined by alignment, negatives are supported)
-dur_y_offset = 0
-
-# Set margin to the edges of the DM (useful for curved monitors)
-edge_margin = 0
-
 # Error background color id
-error_bg = 0x00000000
+error_bg = 0x0000
 
 # Error foreground color id
-# Default is red and bold
+# Default is red and bold: TB_RED | TB_BOLD
-error_fg = 0x01FF0000
+error_fg = 0x0102
 
 # Foreground color id
-fg = 0x00FFFFFF
+fg = 0x0008
-
-# Render true colors (if supported)
-# If false, output will be in eight-color mode
-# All eight-color mode color codes:
-# TB_DEFAULT              0x0000
-# TB_BLACK                0x0001
-# TB_RED                  0x0002
-# TB_GREEN                0x0003
-# TB_YELLOW               0x0004
-# TB_BLUE                 0x0005
-# TB_MAGENTA              0x0006
-# TB_CYAN                 0x0007
-# TB_WHITE                0x0008
-# If full color is off, the styling options still work. The colors are
-# always 32-bit values with the styling in the most significant byte.
-# Note: If using the dur_file animation option and the dur file's color range
-# is saved as 256 with this option disabled, the file will not be drawn.
-full_color = true
-
-# Game of Life entropy interval (0 = disabled, >0 = add entropy every N generations)
-# 0 -> Pure Conway's Game of Life (will eventually stabilize)
-# 10 -> Add entropy every 10 generations (recommended for continuous activity)
-# 50+ -> Less frequent entropy for more natural evolution
-gameoflife_entropy_interval = 10
-
-# Game of Life animation foreground color id
-gameoflife_fg = 0x0000FF00
-
-# Game of Life frame delay (lower = faster animation, higher = slower)
-# 1-3 -> Very fast animation
-# 6 -> Default smooth animation speed
-# 10+ -> Slower, more contemplative speed
-gameoflife_frame_delay = 6
-
-# Game of Life initial cell density (0.0 to 1.0)
-# 0.1 -> Sparse, minimal activity
-# 0.4 -> Balanced activity (recommended)
-# 0.7+ -> Dense, chaotic patterns
-gameoflife_initial_density = 0.4
-
-# Command executed when pressing hibernate key (can be null)
-hibernate_cmd = null
-
-# Specifies the key combination used for hibernate
-hibernate_key = F4
 
 # Remove main box borders
 hide_borders = false
@@ -250,19 +113,6 @@ hide_borders = false
 # Remove power management command hints
 hide_key_hints = false
 
-# Remove keyboard lock states from the top right corner
-hide_keyboard_locks = false
-
-# Remove version number from the top left corner
-hide_version_string = false
-
-# Command executed when no input is detected for a certain time
-# If null, no command will be executed
-inactivity_cmd = null
-
-# Executes a command after a certain amount of seconds
-inactivity_delay = 0
-
 # Initial text to show on the info line
 # If set to null, the info line defaults to the hostname
 initial_info_text = null
@@ -274,93 +124,76 @@ input_len = 34
 # Available languages are found in $CONFIG_DIRECTORY/ly/lang/
 lang = en
 
+# Load the saved desktop and username
+load = true
+
 # Command executed when logging in
 # If null, no command will be executed
 # Important: the code itself must end with `exec "$@"` in order to launch the session!
 # You can also set environment variables in there, they'll persist until logout
 login_cmd = null
 
-# Path for login.defs file (used for listing all local users on the system on
-# Linux)
-login_defs_path = /etc/login.defs
-
 # Command executed when logging out
 # If null, no command will be executed
 # Important: the session will already be terminated when this command is executed, so
 # no need to add `exec "$@"` at the end
 logout_cmd = null
 
-# General log file path
-ly_log = /var/log/ly.log
-
 # Main box horizontal margin
 margin_box_h = 2
 
 # Main box vertical margin
 margin_box_v = 1
 
+# Event timeout in milliseconds
+min_refresh_delta = 5
+
 # Set numlock on/off at startup
 numlock = false
 
 # Default path
 # If null, ly doesn't set a path
-path = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+path = /sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
 
 # Command executed when pressing restart_key
 restart_cmd = /sbin/shutdown -r now
 
-# Specifies the key combination used for restart
+# Specifies the key used for restart (F1-F12)
 restart_key = F2
 
-# Save the current desktop and login as defaults, and load them on startup
+# Save the current desktop and login as defaults
 save = true
 
 # Service name (set to ly to use the provided pam config file)
 service_name = ly
 
 # Session log file path
-# This will contain stdout and stderr of Wayland sessions
+# This will contain stdout and stderr of X11 and Wayland sessions
 # By default it's saved in the user's home directory
-# Important: due to technical limitations, X11, shell sessions as well as
+# Note: this file won't be used in a shell session (due to the need of stdout and stderr)
-# launching session via KMSCON aren't supported, which means you won't get any
+session_log = ly-session.log
-# logs from those sessions.
-# If null, no session log will be created
-session_log = .local/state/ly-session.log
 
 # Setup command
 setup_cmd = $CONFIG_DIRECTORY/ly/setup.sh
 
-# Show the shell session in the session list
-# If false, the shell session will be hidden
-shell = true
-
-# Specifies the key combination used for showing the password
-show_password_key = F7
-
-# Display the active TTY number (e.g. tty3) to the right of the clock in the top right corner
-# If the clock is disabled, the TTY label occupies the top right corner on its own
-# If false, the TTY number will not be shown
-show_tty = false
-
 # Command executed when pressing shutdown_key
-shutdown_cmd = /sbin/shutdown $PLATFORM_SHUTDOWN_ARG now
+shutdown_cmd = /sbin/shutdown -a now
 
-# Specifies the key combination used for shutdown
+# Specifies the key used for shutdown (F1-F12)
 shutdown_key = F1
 
 # Command executed when pressing sleep key (can be null)
 sleep_cmd = null
 
-# Specifies the key combination used for sleep
+# Specifies the key used for sleep (F1-F12)
 sleep_key = F3
 
-# Command executed when starting Ly (before the TTY is taken control of)
-# See file at path below for an example of changing the default TTY colors
-start_cmd = $CONFIG_DIRECTORY/ly/startup.sh
-
 # Center the session name.
 text_in_center = false
 
+# TTY in use
+tty = $DEFAULT_TTY
+
 # Default vi mode
 # normal   -> normal mode
 # insert   -> insert mode
@@ -370,20 +203,11 @@ vi_default_mode = normal
 vi_mode = false
 
 # Wayland desktop environments
-# You can specify multiple directories,
-# e.g. $PREFIX_DIRECTORY/share/wayland-sessions:$PREFIX_DIRECTORY/local/share/wayland-sessions
-# If null, Wayland sessions will not be shown
 waylandsessions = $PREFIX_DIRECTORY/share/wayland-sessions
 
 # Xorg server command
-# Add the -quiet argument to hide startup logs from the server
 x_cmd = $PREFIX_DIRECTORY/bin/X
 
-# Xorg virtual terminal number
-# Mostly useful for FreeBSD where choosing the current TTY causes issues
-# If null, the current TTY will be chosen
-x_vt = null
-
 # Xorg xauthority edition tool
 xauth_cmd = $PREFIX_DIRECTORY/bin/xauth
 
@@ -392,31 +216,4 @@ xauth_cmd = $PREFIX_DIRECTORY/bin/xauth
 xinitrc = ~/.xinitrc
 
 # Xorg desktop environments
-# You can specify multiple directories,
-# e.g. $PREFIX_DIRECTORY/share/xsessions:$PREFIX_DIRECTORY/local/share/xsessions
-# If null, X11 sessions will not be shown
 xsessions = $PREFIX_DIRECTORY/share/xsessions
-
-# Custom Commands and Labels:
-# The following examples below give an outline for setting up custom commands and labels.
-# Unless specified as optional, an option is mandatory.
-
-# Comments preceding with '##' are for documentation.
-# Comments preceding with '#' comment out the example INI.
-
-## Declare a command with the F8 binding.
-#[cmd:F8]
-## The name of the command to show up in Ly.
-## Note: "$" in "$brightness_up" fetches the appropriate string from the specified locale file
-## and is replaced with the value representing "brightness_up".
-## You can see the list of keys in any locale file in $CONFIG_DIRECTORY/ly/lang.
-#cmd = touch /tmp/ly.gaming
-#name = custom command $brightness_up
-
-## Declare a label with an ID. This ID should be unique across all labels.
-#[lbl:kernel]
-#cmd = uname -srn
-## Optional, defaulting to 0.
-## In frames, the time to re-run the command and update the label.
-## If 0, only run once and do not refresh afterwards
-#refresh = 0

res/custom-sessions/README

@@ -1,23 +0,0 @@
-A custom session is just a desktop entry file, like for X11 and Wayland
-sessions. For example:
-
-[Desktop Entry]
-Name=Fish shell
-Exec=$PREFIX_DIRECTORY/bin/fish
-DesktopNames=null
-Terminal=true
-
-The DesktopNames value is optional and sets the XDG_SESSION_DESKTOP and
-XDG_CURRENT_DESKTOP environment variables. If equal to null or if not present,
-XDG_SESSION_DESKTOP and XDG_CURRENT_DESKTOP will not be set. Otherwise, the
-syntax is the same as described in the Freedesktop Desktop Entry Specification.
-
-The Terminal value specifies if standard output and standard error should be
-redirected to the session log file found in Ly's configuration file. If set to
-true, Ly will consider the program is going to run in a TTY, and thus will not
-redirect standard output & error. It is optional and defaults to false.
-
-Finally, do note that if the Terminal value is set to true, the
-XDG_SESSION_TYPE environment variable will be set to "tty". Otherwise, it will
-be set to "unspecified" (without quotes), which is behavior that at least
-systemd recognizes (see pam_systemd's man page).

res/lang/ar.ini

@@ -1,82 +0,0 @@
-authenticating = جاري المصادقة...
-brightness_down = خفض السطوع
-brightness_up = رفع السطوع
-capslock = capslock
-
-
-
-
-err_alloc = فشل في تخصيص الذاكرة
-
-
-err_bounds = out-of-bounds index
-err_brightness_change = فشل في تغيير سطوع الشاشة
-err_chdir = فشل في فتح مجلد المنزل
-
-err_config = فشل في تفسير ملف الإعدادات
-
-err_dgn_oob = رسالة سجل (Log)
-err_domain = اسم نطاق غير صالح
-err_empty_password = لا يُسمح بكلمة مرور فارغة
-err_envlist = فشل في جلب قائمة المتغيرات البيئية
-
-
-err_hostname = فشل في جلب اسم المضيف (Hostname)
-
-
-
-err_mlock = فشل في تأمين ذاكرة كلمة المرور (mlock)
-err_null = مؤشر فارغ (Null pointer)
-err_numlock = فشل في ضبط Num Lock
-err_pam = فشل في معاملة PAM
-err_pam_abort = تم إلغاء معاملة PAM
-err_pam_acct_expired = الحساب منتهي الصلاحية
-err_pam_auth = خطأ في المصادقة (Authentication error)
-err_pam_authinfo_unavail = فشل في الحصول على معلومات المستخدم
-err_pam_authok_reqd = انتهت صلاحية رمز المصادقة (Token)
-err_pam_buf = خطأ في ذاكرة التخزين المؤقت (Buffer)
-err_pam_cred_err = فشل في تعيين بيانات الاعتماد (Credentials)
-err_pam_cred_expired = بيانات الاعتماد منتهية الصلاحية
-err_pam_cred_insufficient = بيانات الاعتماد غير كافية
-err_pam_cred_unavail = فشل في الحصول على بيانات الاعتماد
-err_pam_maxtries = تم بلوغ الحد الأقصى لمحاولات المصادقة
-err_pam_perm_denied = تم رفض الوصول (Permission denied)
-err_pam_session = خطأ في جلسة المستخدم (Session error)
-err_pam_sys = خطأ في النظام (System error)
-err_pam_user_unknown = المستخدم غير موجود
-err_path = فشل في تعيين متغير PATH
-err_perm_dir = فشل في تغيير المجلد الحالي
-err_perm_group = فشل في تخفيض صلاحيات المجموعة (Group permissions)
-err_perm_user = فشل في تخفيض صلاحيات المستخدم (User permissions)
-err_pwnam = فشل في جلب معلومات المستخدم
-err_sleep = فشل في تنفيذ أمر sleep
-
-
-
-err_tty_ctrl = فشل في نقل تحكم الطرفية (TTY)
-
-
-err_user_gid = فشل في تعيين معرّف المجموعة (GID) للمستخدم
-err_user_init = فشل في تهيئة بيانات المستخدم
-err_user_uid = فشل في تعيين معرّف المستخدم (UID)
-err_xauth = فشل في تنفيذ أمر xauth
-err_xcb_conn = فشل في الاتصال بمكتبة XCB
-err_xsessions_dir = فشل في العثور على مجلد Xsessions
-err_xsessions_open = فشل في فتح مجلد Xsessions
-
-insert = ادخال
-login = تسجيل الدخول
-logout = تم تسجيل خروجك
-no_x11_support = تم تعطيل دعم x11 اثناء وقت الـ compile
-normal = عادي
-numlock = numlock
-other = اخر
-password = كلمة السر
-restart = اعادة التشغيل
-shell = shell
-shutdown = ايقاف التشغيل
-sleep = وضع السكون
-
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/lang/bg.ini

@@ -1,82 +0,0 @@
-authenticating = удостоверяване...
-brightness_down = намаляване на яркостта
-brightness_up = увеличаване на яркостта
-capslock = caps lock
-custom = персонализирано
-custom_info_err_output_long = резултатът е твърде дълъг
-custom_info_err_no_output = няма резултат
-custom_info_err_no_output_error = , възможна грешка
-err_alloc = неуспешно заделяне на памет
-err_args = неуспешен анализ на аргументите от командния ред
-err_autologin_session = сесията за автоматично влизане не е намерена
-err_bounds = индексът е извън границите
-err_brightness_change = неуспешна промяна на яркостта
-err_chdir = неуспешно отваряне на домашната папка
-err_clock_too_long = низът на часовника е твърде дълъг
-err_config = неуспешен анализ на конфигурационния файл
-err_crawl = неуспешно обхождане на папките със сесии
-err_dgn_oob = съобщение в дневника
-err_domain = невалиден домейн
-err_empty_password = не е позволена празна парола
-err_envlist = неуспешно получаване на списъка с променливи на средата
-err_get_active_tty = неуспешно откриване на активния TTY
-err_hibernate = неуспешно изпълнение на командата за хибернация
-err_hostname = неуспешно получаване на името на хоста
-err_inactivity = неуспешно изпълнение на командата за неактивност
-err_lock_state = неуспешно получаване на състоянието на заключване
-err_log = неуспешно отваряне на файла с дневника
-err_mlock = неуспешно заключване на паметта за паролата
-err_null = нулев указател
-err_numlock = неуспешно задаване на num lock
-err_pam = неуспешна транзакция
-err_pam_abort = прекратена транзакция
-err_pam_acct_expired = изтекъл профил
-err_pam_auth = грешка при удостоверяването
-err_pam_authinfo_unavail = неуспешно получаване на информация за потребителя
-err_pam_authok_reqd = изтекъл жетон
-err_pam_buf = грешка в буфера на паметта
-err_pam_cred_err = неуспешно задаване на удостоверения
-err_pam_cred_expired = изтекли удостоверения
-err_pam_cred_insufficient = недостатъчни удостоверения
-err_pam_cred_unavail = неуспешно получаване на удостоверения
-err_pam_maxtries = достигнат е максималният лимит на опитите
-err_pam_perm_denied = достъпът е отказан
-err_pam_session = грешка в сесията
-err_pam_sys = системна грешка
-err_pam_user_unknown = непознат потребител
-err_path = неуспешно задаване на пътя
-err_perm_dir = неуспешна смяна на текущата папка
-err_perm_group = неуспешно понижаване на правата на групата
-err_perm_user = неуспешно понижаване на правата на потребителя
-err_pwnam = неуспешно получаване на информация за потребителя
-err_sleep = неуспешно изпълнение на командата за заспиване
-err_start = неуспешно изпълнение на командата за стартиране
-err_battery = неуспешно зареждане на състоянието на батерията
-err_switch_tty = неуспешна смяна на TTY
-err_tty_ctrl = неуспешно прехвърляне на контрола над TTY
-err_no_users = не са намерени потребители
-err_uid_range = неуспешно динамично получаване на UID обхват
-err_user_gid = неуспешно задаване на потребителския GID
-err_user_init = неуспешна стартиране на потребителя
-err_user_uid = неуспешно задаване на потребителския UID
-err_xauth = неуспешна команда xauth
-err_xcb_conn = неуспешна xcb връзка
-err_xsessions_dir = папката със сесии не е намерена
-err_xsessions_open = неуспешно отваряне на папката със сесии
-hibernate = хибернация
-insert = вмъкване
-login = вход
-logout = излизане
-no_x11_support = поддръжката на x11 е изключена при компилирането
-normal = нормално
-numlock = num lock
-other = друго
-password = парола
-restart = рестартиране
-shell = обвивка
-shutdown = изключване
-sleep = заспиване
-toggle_password = превключване на паролата
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/lang/cat.ini

@@ -2,29 +2,15 @@ authenticating = autenticant...
 brightness_down = abaixar brillantor
 brightness_up = apujar brillantor
 capslock = Bloq Majús
-
-
-
-
 err_alloc = assignació de memòria fallida
-
-
 err_bounds = índex fora de límits
 err_brightness_change = error en canviar la brillantor
 err_chdir = error en obrir la carpeta home
-
+err_console_dev = error en accedir a la consola
-
-
 err_dgn_oob = missatge de registre
 err_domain = domini invàlid
-
 err_envlist = error en obtenir l'envlist
-
-
 err_hostname = error en obtenir el nom de l'amfitrió
-
-
-
 err_mlock = error en bloquejar la memòria de clau
 err_null = punter nul
 err_numlock = error en establir el Bloq num
@@ -49,13 +35,7 @@ err_perm_dir = error en canviar el directori actual
 err_perm_group = error en degradar els permisos de grup
 err_perm_user = error en degradar els permisos de l'usuari
 err_pwnam = error en obtenir la informació de l'usuari
-
+err_unknown = ha ocorregut un error desconegut
-
-
-
-
-
-
 err_user_gid = error en establir el GID de l'usuari
 err_user_init = error en inicialitzar usuari
 err_user_uid = error en establir l'UID de l'usuari
@@ -63,20 +43,18 @@ err_xauth = error en la comanda xauth
 err_xcb_conn = error en la connexió xcb
 err_xsessions_dir = error en trobar la carpeta de sessions
 err_xsessions_open = error en obrir la carpeta de sessions
-
 insert = inserir
 login = iniciar sessió
 logout = sessió tancada
+no_x11_support = x11 support disabled at compile-time
 no_x11_support = el suport per x11 ha estat desactivat en la compilació
 normal = normal
 numlock = Bloq Num
-
 password = Clau
 restart = reiniciar
 shell = shell
 shutdown = aturar
 sleep = suspendre
-
 wayland = wayland
 x11 = x11
 xinitrc = xinitrc

res/lang/cs.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = capslock
-
-
-
-
 err_alloc = alokace paměti selhala
-
-
 err_bounds = index je mimo hranice pole
-
 err_chdir = nelze otevřít domovský adresář
-
+err_console_dev = chyba při přístupu do konzole
-
-
 err_dgn_oob = zpráva protokolu
 err_domain = neplatná doména
-
-
-
-
 err_hostname = nelze získat název hostitele
-
-
-
 err_mlock = uzamčení paměti hesel selhalo
 err_null = nulový ukazatel
-
 err_pam = pam transakce selhala
 err_pam_abort = pam transakce přerušena
 err_pam_acct_expired = platnost účtu vypršela
@@ -49,34 +29,17 @@ err_perm_dir = nepodařilo se změnit adresář
 err_perm_group = nepodařilo se snížit skupinová oprávnění
 err_perm_user = nepodařilo se snížit uživatelská oprávnění
 err_pwnam = nelze získat informace o uživateli
-
-
-
-
-
-
-
 err_user_gid = nastavení GID uživatele selhalo
 err_user_init = inicializace uživatele selhala
 err_user_uid = nastavení UID uživateli selhalo
-
-
 err_xsessions_dir = nepodařilo se najít složku relací
 err_xsessions_open = nepodařilo se otevřít složku relací
-
-
 login = uživatel
 logout = odhlášen
-
-
 numlock = numlock
-
 password = heslo
 restart = restartovat
 shell = příkazový řádek
 shutdown = vypnout
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/de.ini

@@ -1,82 +1,45 @@
-authenticating = authentifizieren...
-brightness_down = Helligkeit-
-brightness_up = Helligkeit+
 capslock = Feststelltaste
-
-
-
-
 err_alloc = Speicherzuweisung fehlgeschlagen
-
+err_bounds = Listenindex ist außerhalb des Bereichs
-
+err_chdir = Fehler beim oeffnen des home-ordners
-err_bounds = Index ausserhalb des Bereichs
+err_console_dev = Zugriff auf die Konsole fehlgeschlagen
-err_brightness_change = Helligkeitsänderung fehlgeschlagen
+err_dgn_oob = Protokoll Nachricht
-err_chdir = Fehler beim Oeffnen des Home-Ordners
+err_domain = Unzulaessige domain
-
+err_hostname = Holen des Hostnames fehlgeschlagen
-err_config = Fehler beim Verarbeiten der Konfigurationsdatei
+err_mlock = Abschließen des Passwortspeichers fehlgeschlagen
-
+err_null = Null Zeiger
-err_dgn_oob = Diagnose-Nachricht
+err_pam = pam Transaktion fehlgeschlagen
-err_domain = Ungueltige Domain
+err_pam_abort = pam Transaktion abgebrochen
-err_empty_password = Leeres Passwort nicht zugelassen
-err_envlist = Fehler beim Abrufen der Umgebungs-Variablen
-
-
-err_hostname = Abrufen des Hostnames fehlgeschlagen
-
-
-
-err_mlock = Sperren des Passwortspeichers fehlgeschlagen
-err_null = Null Pointer
-err_numlock = Numlock konnte nicht aktiviert werden
-err_pam = PAM-Transaktion fehlgeschlagen
-err_pam_abort = PAM-Transaktion abgebrochen
 err_pam_acct_expired = Benutzerkonto abgelaufen
-err_pam_auth = Authentifizierungsfehler
+err_pam_auth = Authentifizierungs Fehler
-err_pam_authinfo_unavail = Abrufen der Benutzerinformationen fehlgeschlagen
+err_pam_authinfo_unavail = holen der Benutzerinformationen fehlgeschlagen
-err_pam_authok_reqd = Passwort abgelaufen
+err_pam_authok_reqd = Schluessel abgelaufen
 err_pam_buf = Speicherpufferfehler
-err_pam_cred_err = Fehler beim Setzen der Anmeldedaten
+err_pam_cred_err = Fehler beim setzen der Anmeldedaten
 err_pam_cred_expired = Anmeldedaten abgelaufen
 err_pam_cred_insufficient = Anmeldedaten unzureichend
-err_pam_cred_unavail = Fehler beim Abrufen der Anmeldedaten
+err_pam_cred_unavail = Fehler beim holen der Anmeldedaten
-err_pam_maxtries = Maximale Versuchsanzahl erreicht
+err_pam_maxtries = Maximale Versuche erreicht
-err_pam_perm_denied = Zugriff verweigert
+err_pam_perm_denied = Zugriff Verweigert
 err_pam_session = Sitzungsfehler
 err_pam_sys = Systemfehler
 err_pam_user_unknown = Unbekannter Nutzer
-err_path = Fehler beim Setzen des Pfades
+err_path = Fehler beim setzen des Pfades
-err_perm_dir = Ordnerwechsel fehlgeschlagen
+err_perm_dir = Fehler beim wechseln des Ordners
-err_perm_group = Fehler beim Heruntersetzen der Gruppenberechtigungen
+err_perm_group = Fehler beim heruntersetzen der Gruppen Berechtigungen
-err_perm_user = Fehler beim Heruntersetzen der Nutzerberechtigungen
+err_perm_user = Fehler beim heruntersetzen der Nutzer Berechtigungen
-err_pwnam = Abrufen der Benutzerinformationen fehlgeschlagen
+err_pwnam = Holen der Benutzerinformationen fehlgeschlagen
-err_sleep = Sleep-Befehl fehlgeschlagen
+err_user_gid = Fehler beim setzen der Gruppen Id des Nutzers
-
+err_user_init = Initialisierung des Nutzers fehlgeschlagen
-
+err_user_uid = Setzen der Benutzer Id fehlgeschlagen
-
+err_xsessions_dir = Fehler beim finden des Sitzungsordners
-err_tty_ctrl = Fehler bei der TTY-Uebergabe
+err_xsessions_open = Fehler beim öffnen des Sitzungsordners
-
+login = Anmelden
-
+logout = Abgemeldet
-err_user_gid = Fehler beim Setzen der Gruppen-ID
+numlock = Numtaste
-err_user_init = Nutzer-Initialisierung fehlgeschlagen
-err_user_uid = Setzen der Benutzer-ID fehlgeschlagen
-err_xauth = Xauth-Befehl fehlgeschlagen
-err_xcb_conn = xcb-Verbindung fehlgeschlagen
-err_xsessions_dir = Fehler beim Finden des Sitzungsordners
-err_xsessions_open = Fehler beim Oeffnen des Sitzungsordners
-
-insert = Einfügen
-login = Nutzer
-logout = Abmelden
-no_x11_support = X11-Support bei Kompilierung deaktiviert
-normal = Normal
-numlock = Numlock
-other = Andere
 password = Passwort
 restart = Neustarten
-shell = Shell
+shell = shell
 shutdown = Herunterfahren
-sleep = Sleep
-
 wayland = wayland
-x11 = X11
 xinitrc = xinitrc

res/lang/en.ini

@@ -2,29 +2,15 @@ authenticating = authenticating...
 brightness_down = decrease brightness
 brightness_up = increase brightness
 capslock = capslock
-custom = custom
-custom_info_err_output_long = output too long
-custom_info_err_no_output = no output
-custom_info_err_no_output_error = , possible error
 err_alloc = failed memory allocation
-err_args = unable to parse command line arguments
-err_autologin_session = autologin session not found
 err_bounds = out-of-bounds index
 err_brightness_change = failed to change brightness
 err_chdir = failed to open home folder
-err_clock_too_long = clock string too long
+err_console_dev = failed to access console
-err_config = unable to parse config file
-err_crawl = failed to crawl session directories
 err_dgn_oob = log message
 err_domain = invalid domain
-err_empty_password = empty password not allowed
 err_envlist = failed to get envlist
-err_get_active_tty = failed to get active tty
-err_hibernate = failed to execute hibernate command
 err_hostname = failed to get hostname
-err_inactivity = failed to execute inactivity command
-err_lock_state = failed to get lock state
-err_log = failed to open log file
 err_mlock = failed to lock password memory
 err_null = null pointer
 err_numlock = failed to set numlock
@@ -50,12 +36,7 @@ err_perm_group = failed to downgrade group permissions
 err_perm_user = failed to downgrade user permissions
 err_pwnam = failed to get user info
 err_sleep = failed to execute sleep command
-err_start = failed to execute start command
+err_unknown = an unknown error occurred
-err_battery = failed to load battery status
-err_switch_tty = failed to switch tty
-err_tty_ctrl = tty control transfer failed
-err_no_users = no users found
-err_uid_range = failed to dynamically get uid range
 err_user_gid = failed to set user GID
 err_user_init = failed to initialize user
 err_user_uid = failed to set user UID
@@ -63,20 +44,17 @@ err_xauth = xauth command failed
 err_xcb_conn = xcb connection failed
 err_xsessions_dir = failed to find sessions folder
 err_xsessions_open = failed to open sessions folder
-hibernate = hibernate
 insert = insert
 login = login
 logout = logged out
-no_x11_support = x11 support disabled at compile-time
 normal = normal
+no_x11_support = x11 support disabled at compile-time
 numlock = numlock
-other = other
 password = password
 restart = reboot
 shell = shell
 shutdown = shutdown
 sleep = sleep
-toggle_password = toggle password
 wayland = wayland
-x11 = x11
 xinitrc = xinitrc
+x11 = x11

res/lang/eo.ini

@@ -1,82 +0,0 @@
-authenticating = aŭtentigado...
-brightness_down = malpliigi helecon
-brightness_up = pliigi helecon
-capslock = majuskla baskulo
-custom = propra
-
-
-
-err_alloc = malsukcesis memorasignon
-err_args = ne povas analizi argumentojn de komanda linio
-err_autologin_session = aŭtomatan ensalutan seancon ne trovis
-err_bounds = indico estas ekster-intervala
-err_brightness_change = malsukcesis ŝanĝi la helecon
-err_chdir = malsukcesis malfermi hejman dosierujon
-err_clock_too_long = horloĝa ĉeno estas tro longa
-err_config = ne povas analizi agordan dosieron
-err_crawl = malsukcesis dum serĉado de seancaj dosierujoj
-err_dgn_oob = protokola mesaĝo
-err_domain = malvalida domajno
-err_empty_password = ne akceptas malplenan pasvorton
-err_envlist = malsukcesis preni la medivariablojn
-err_get_active_tty = malsukcesis preni la aktivan TTY-on
-err_hibernate = malsukcesis ruli la komandon por diskodormo
-err_hostname = malsukcesis preni la sistemnomon
-err_inactivity = malsukcesis ruli la agorditan komandon por malaktiveco
-err_lock_state = malsukcesis preni la ŝlosan staton
-err_log = malsukcesis malfermi la protokolan dosieron
-err_mlock = malsukcesis ŝlosi pasvortan memoron
-err_null = nula memorloko
-err_numlock = malsukcesis agordi numeran baskulon
-err_pam = PAM-a transakcio malsukcesis
-err_pam_abort = PAM-a transakcio malsukcesis
-err_pam_acct_expired = konto eksvalidiĝis
-err_pam_auth = aŭtentiga eraro
-err_pam_authinfo_unavail = malsukcesis preni uzantajn informojn
-err_pam_authok_reqd = memorsigno eksvalidiĝis
-err_pam_buf = bufra eraro
-err_pam_cred_err = malsukcesis agordi akreditaĵon
-err_pam_cred_expired = akreditaĵo eksvalidiĝis
-err_pam_cred_insufficient = nesufiĉa akreditaĵo
-err_pam_cred_unavail = malsukcesis preni akreditaĵon
-err_pam_maxtries = atingis maksimuman kvanton da provoj
-err_pam_perm_denied = permeso negis
-err_pam_session = seancan eraron
-err_pam_sys = sisteman eraron
-err_pam_user_unknown = ne konas uzanton
-err_path = malsukcesis agordi la median dosierindikon
-err_perm_dir = malsukcesis ŝanĝi la nunan dosierujon
-err_perm_group = malsukcesis redukti grupajn permesojn
-err_perm_user = malsukcesis redukti uzantajn permesojn
-err_pwnam = malsukcesis preni uzantajn informojn
-err_sleep = malsukcesis ruli memordorman komandon
-err_start = malsukcesis ruli startan komandon
-err_battery = malsukcesis ŝargi baterian staton
-err_switch_tty = malsukcesis ŝanĝi TTY-on
-err_tty_ctrl = TTY-an stiran transigon malsukcesis
-err_no_users = nul uzantojn trovas
-err_uid_range = malsukcesis dinamike preni UID-an intervalon
-err_user_gid = malsukcesis agordi uzantan GID-on
-err_user_init = malsukcesis iniciĝi uzanto
-err_user_uid = malsukcesis agordi uzantan UID-on
-err_xauth = malsukcesis plenumi je xauth
-err_xcb_conn = malsukcesis dum konectado al xcb
-err_xsessions_dir = malsukcesis trovi seancan dosierujon
-err_xsessions_open = malsukcesis malfermi seancan dosierujon
-hibernate = diskodormi
-insert = enmeti
-login = uzanto
-logout = elsalutis
-no_x11_support = x11 estas foriĝita de kompil-tempo
-normal = normala
-numlock = numera baskulo
-other = alia
-password = pasvorto
-restart = restartigi
-shell = ŝelo
-shutdown = malŝalti
-sleep = memordormi
-
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/lang/es.ini

@@ -2,32 +2,15 @@ authenticating = autenticando...
 brightness_down = bajar brillo
 brightness_up = subir brillo
 capslock = Bloq Mayús
-
-
-
-
 err_alloc = asignación de memoria fallida
-
-
 err_bounds = índice fuera de límites
-
 err_chdir = error al abrir la carpeta home
-
+err_console_dev = error al acceder a la consola
-
-
 err_dgn_oob = mensaje de registro
 err_domain = dominio inválido
-
-
-
-
 err_hostname = error al obtener el nombre de host
-
-
-
 err_mlock = error al bloquear la contraseña de memoria
 err_null = puntero nulo
-
 err_pam = error en la transacción pam
 err_pam_abort = transacción pam abortada
 err_pam_acct_expired = cuenta expirada
@@ -49,21 +32,11 @@ err_perm_dir = error al cambiar el directorio actual
 err_perm_group = error al degradar los permisos del grupo
 err_perm_user = error al degradar los permisos del usuario
 err_pwnam = error al obtener la información del usuario
-
-
-
-
-
-
-
 err_user_gid = error al establecer el GID del usuario
 err_user_init = error al inicializar usuario
 err_user_uid = error al establecer el UID del usuario
-
-
 err_xsessions_dir = error al buscar la carpeta de sesiones
 err_xsessions_open = error al abrir la carpeta de sesiones
-
 insert = insertar
 login = usuario
 logout = cerrar sesión
@@ -76,7 +49,5 @@ restart = reiniciar
 shell = shell
 shutdown = apagar
 sleep = suspender
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/fr.ini

@@ -1,30 +1,16 @@
-authenticating = authentification...
+authenticating = authentification...
 brightness_down = diminuer la luminosité
 brightness_up = augmenter la luminosité
 capslock = verr.maj
-custom = customisé
-custom_info_err_output_long = sortie trop longue
-custom_info_err_no_output = pas de sortie
-custom_info_err_no_output_error = , erreur possible
 err_alloc = échec d'allocation mémoire
-err_args = échec de l'analyse des arguments en lignes de commande
-err_autologin_session = session de connexion automatique introuvable
 err_bounds = indice hors-limite
 err_brightness_change = échec du changement de luminosité
 err_chdir = échec de l'ouverture du répertoire home
-err_clock_too_long = chaîne de formattage de l'horloge trop longue
+err_console_dev = échec d'accès à la console
-err_config = échec de lecture du fichier de configuration
-err_crawl = échec de la navigation des répertoires de session
 err_dgn_oob = message
 err_domain = domaine invalide
-err_empty_password = mot de passe vide non autorisé
 err_envlist = échec de lecture de la liste d'environnement
-err_get_active_tty = échec de lecture du terminal actif
-err_hibernate = échec de l'exécution de la commande de veille prolongée
 err_hostname = échec de lecture du nom d'hôte
-err_inactivity = échec de l'exécution de la commande d'inactivité
-err_lock_state = échec de lecture de l'état de verrouillage
-err_log = échec de l'ouverture du fichier de journal
 err_mlock = échec du verrouillage mémoire
 err_null = pointeur null
 err_numlock = échec de modification du verr.num
@@ -49,13 +35,7 @@ err_perm_dir = échec de changement de répertoire
 err_perm_group = échec du déclassement des permissions de groupe
 err_perm_user = échec du déclassement des permissions utilisateur
 err_pwnam = échec de lecture des infos utilisateur
-err_sleep = échec de l'exécution de la commande de veille
+err_unknown = une erreur inconnue est survenue
-err_start = échec de l'exécution de la commande de démarrage
-err_battery = échec de lecture de l'état de la batterie
-err_switch_tty = échec du changement de terminal
-err_tty_ctrl = échec du transfert de contrôle du terminal
-err_no_users = aucun utilisateur trouvé
-err_uid_range = échec de récupération dynamique de la plage d'UID
 err_user_gid = échec de modification du GID
 err_user_init = échec d'initialisation de l'utilisateur
 err_user_uid = échec de modification du UID
@@ -63,20 +43,17 @@ err_xauth = échec de la commande xauth
 err_xcb_conn = échec de la connexion xcb
 err_xsessions_dir = échec de la recherche du dossier de sessions
 err_xsessions_open = échec de l'ouverture du dossier de sessions
-hibernate = veille prolongée
 insert = insertion
 login = identifiant
 logout = déconnecté
-no_x11_support = support pour x11 désactivé lors de la compilation
 normal = normal
+no_x11_support = support pour x11 désactivé lors de la compilation
 numlock = verr.num
-other = autre
 password = mot de passe
 restart = redémarrer
 shell = shell
 shutdown = éteindre
 sleep = veille
-toggle_password = afficher le mot de passe
 wayland = wayland
-x11 = x11
 xinitrc = xinitrc
+x11 = x11

res/lang/it.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = capslock
-
-
-
-
 err_alloc = impossibile allocare memoria
-
-
 err_bounds = indice fuori limite
-
 err_chdir = impossibile aprire home directory
-
+err_console_dev = impossibile aprire console
-
-
 err_dgn_oob = messaggio log
 err_domain = dominio non valido
-
-
-
-
 err_hostname = impossibile ottenere hostname
-
-
-
 err_mlock = impossibile ottenere lock per la password in memoria
 err_null = puntatore nullo
-
 err_pam = transazione PAM fallita
 err_pam_abort = transazione PAM interrotta
 err_pam_acct_expired = account scaduto
@@ -49,34 +29,17 @@ err_perm_dir = impossibile cambiare directory corrente
 err_perm_group = impossibile ridurre permessi gruppo
 err_perm_user = impossibile ridurre permessi utente
 err_pwnam = impossibile ottenere dati utente
-
-
-
-
-
-
-
 err_user_gid = impossibile impostare GID utente
 err_user_init = impossibile inizializzare utente
 err_user_uid = impossible impostare UID utente
-
-
 err_xsessions_dir = impossibile localizzare cartella sessioni
 err_xsessions_open = impossibile aprire cartella sessioni
-
-
 login = username
 logout = scollegato
-
-
 numlock = numlock
-
 password = password
 restart = riavvio
 shell = shell
 shutdown = arresto
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/ja_JP.ini

@@ -1,82 +0,0 @@
-authenticating = 認証中...
-brightness_down = 明るさを下げる
-brightness_up = 明るさを上げる
-capslock = CapsLock
-
-
-
-
-err_alloc = メモリ割り当て失敗
-
-
-err_bounds = 境界外インデックス
-err_brightness_change = 明るさの変更に失敗しました
-err_chdir = ホームフォルダを開けませんでした
-
-err_config = 設定ファイルを解析できません
-
-err_dgn_oob = ログメッセージ
-err_domain = 無効なドメイン
-err_empty_password = 空のパスワードは許可されていません
-err_envlist = 環境変数リストの取得に失敗しました
-
-
-err_hostname = ホスト名の取得に失敗しました
-
-
-
-err_mlock = パスワードメモリのロックに失敗しました
-err_null = ヌルポインタ
-err_numlock = NumLockの設定に失敗しました
-err_pam = PAMトランザクション失敗
-err_pam_abort = PAMトランザクションが中断されました
-err_pam_acct_expired = アカウントの有効期限が切れています
-err_pam_auth = 認証エラー
-err_pam_authinfo_unavail = ユーザー情報の取得に失敗しました
-err_pam_authok_reqd = トークンの有効期限が切れています
-err_pam_buf = メモリバッファエラー
-err_pam_cred_err = 認証情報の設定に失敗しました
-err_pam_cred_expired = 認証情報の有効期限が切れています
-err_pam_cred_insufficient = 認証情報が不十分です
-err_pam_cred_unavail = 認証情報の取得に失敗しました
-err_pam_maxtries = 最大試行回数に到達しました
-err_pam_perm_denied = アクセスが拒否されました
-err_pam_session = セッションエラー
-err_pam_sys = システムエラー
-err_pam_user_unknown = 不明なユーザー
-err_path = パスの設定に失敗しました
-err_perm_dir = カレントディレクトリの変更に失敗しました
-err_perm_group = グループ権限のダウングレードに失敗しました
-err_perm_user = ユーザー権限のダウングレードに失敗しました
-err_pwnam = ユーザー情報の取得に失敗しました
-err_sleep = スリープコマンドの実行に失敗しました
-
-
-
-err_tty_ctrl = TTY制御の転送に失敗しました
-
-
-err_user_gid = ユーザーGIDの設定に失敗しました
-err_user_init = ユーザーの初期化に失敗しました
-err_user_uid = ユーザーUIDの設定に失敗しました
-err_xauth = xauthコマンドの実行に失敗しました
-err_xcb_conn = XCB接続に失敗しました
-err_xsessions_dir = セッションフォルダが見つかりませんでした
-err_xsessions_open = セッションフォルダを開けませんでした
-
-insert = 挿入
-login = ログイン
-logout = ログアウト済み
-no_x11_support = X11サポートはコンパイル時に無効化されています
-normal = 通常
-numlock = NumLock
-other = その他
-password = パスワード
-restart = 再起動
-shell = シェル
-shutdown = シャットダウン
-sleep = スリープ
-
-wayland = Wayland
-x11 = X11
-xinitrc = xinitrc

res/lang/ku.ini

@@ -1,82 +0,0 @@
-authenticating = tê piştrastkirin...
-brightness_down = ronahiyê kêm bike
-brightness_up = ronahiyê bilind bike
-capslock = tîpên girdek (capslock)
-custom = kesane
-
-
-
-err_alloc = veqetandina bîrê têk çû
-err_args = argumanên rêzika fermanê nehatin analîzkirin
-err_autologin_session = danişîna têketina xweber nehate dîtin
-err_bounds = îndeksa derveyî sînor
-err_brightness_change = guherandina ronahiyê têk çû
-err_chdir = vekirina peldanka malê têk çû
-err_clock_too_long = rêzika demjimêrê pir dirêj e
-err_config = pela rêkxistinê nehat analîzkirin
-err_crawl = gerandina pelrêçên danişînê têk çû
-err_dgn_oob = peyama têketinê
-err_domain = navpara nederbasdar
-err_empty_password = borînpeyv nabe ku vala be
-err_envlist = girtina lîsteya jîngehê (envlist) têk çû
-err_get_active_tty = girtina tty ya çalak têk çû
-err_hibernate = fermana cemidaninê nehat xebitandin
-err_hostname = girtina navê mêvandar têk çû
-err_inactivity = fermana neçalaktiyê nehat xebitandin
-err_lock_state = girtina rewşa kilîtkirinê têk çû
-err_log = vekirina pelê têkeinê têk çû
-err_mlock = kilîtkirina bîra borînpeyvê têk çû
-err_null = nîşandera null
-err_numlock = sazkirina numlock têk çû
-err_pam = danûstendina pam têk çû
-err_pam_abort = danûstendina pam hate têkbirin
-err_pam_acct_expired = dema jimarê derbas bûye
-err_pam_auth = şaşetiya piştrastkirinê
-err_pam_authinfo_unavail = zanyariyên bikarhêner nehatin girtin
-err_pam_authok_reqd = dema nîşandanê derbas bûye
-err_pam_buf = şaşetiya bîra demkî
-err_pam_cred_err = sazkirina rastkitinê têk çû
-err_pam_cred_expired = dema rastkitinê derbas bûye
-err_pam_cred_insufficient = rastkitinê kêm
-err_pam_cred_unavail = girtina rastkitinê têk çû
-err_pam_maxtries = sînorê hewldanên herî bilind hat gihîştin
-err_pam_perm_denied = mafdayîn hat paşguhkirin
-err_pam_session = şaşetiya danişînê
-err_pam_sys = şaşetiya pergalê
-err_pam_user_unknown = bikarhênerê nenas
-err_path = sazkirina rêgehê têk çû
-err_perm_dir = guhertina pelrêçê heyî têk çû
-err_perm_group = kêmkirina mafdayînên komê têk çû
-err_perm_user = kêmkirina mafdayînên bikarhêner têk çû
-err_pwnam = girtina zanyariyên bikarhêner têk çû
-err_sleep = fermana cemidaninê nehat xebitandin
-err_start = fermana destpêkirinê nehat xebitandin
-err_battery = barkirina rewşa betariyê têk çû
-err_switch_tty = guhertina tty têk çû
-err_tty_ctrl = guhertina kontrola tty têk çû
-err_no_users = tu bikarhêner nehatin dîtin
-err_uid_range = girtina rêjeya dînamîk a sînorê uid têk çû
-err_user_gid = sazkirina GID a bikarhêner têk çû
-err_user_init = destpêkirina bikarhêner têk çû
-err_user_uid = sazkirina UID a bikarhêner têk çû
-err_xauth = fermana xauth têk çû
-err_xcb_conn = girêdana xcb têk çû
-err_xsessions_dir = dîtina peldanka danişînan têk çû
-err_xsessions_open = vekirina peldanka danişînan têk çû
-hibernate = bicemidîne
-insert = têxîne
-login = têketin
-logout = derkeve
-no_x11_support = piştgiriya x11 di dema berhevkirinê de hatiye girtin
-normal = normal
-numlock = numlock
-other = ên din
-password = borînpeyv
-restart = ji nû ve bide destpêkirin
-shell = shell
-shutdown = vemirîne
-sleep = têxîne xewê
-
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/lang/lv.ini

@@ -1,82 +0,0 @@
-authenticating = autentificējas...
-brightness_down = samazināt spilgtumu
-brightness_up = palielināt spilgtumu
-capslock = caps lock
-custom = pielāgots
-
-
-
-err_alloc = neizdevās atmiņas piešķiršana
-
-
-err_bounds = indekss ārpus robežām
-err_brightness_change = neizdevās mainīt spilgtumu
-err_chdir = neizdevās atvērt mājas mapi
-err_clock_too_long = pulksteņa virkne pārāk gara
-err_config = neizdevās parsēt konfigurācijas failu
-
-err_dgn_oob = žurnāla ziņojums
-err_domain = nederīgs domēns
-err_empty_password = tukša parole nav atļauta
-err_envlist = neizdevās iegūt vides mainīgo sarakstu
-err_get_active_tty = neizdevās iegūt aktīvo tty
-
-err_hostname = neizdevās iegūt hostname
-
-err_lock_state = neizdevās iegūt bloķēšanas stāvokli
-err_log = neizdevās atvērt žurnāla failu
-err_mlock = neizdevās bloķēt paroles atmiņu
-err_null = null rādītājs
-err_numlock = neizdevās iestatīt numlock
-err_pam = pam transakcija neizdevās
-err_pam_abort = pam transakcija pārtraukta
-err_pam_acct_expired = konts novecojis
-err_pam_auth = autentifikācijas kļūda
-err_pam_authinfo_unavail = neizdevās iegūt lietotāja informāciju
-err_pam_authok_reqd = žetons beidzies
-err_pam_buf = atmiņas bufera kļūda
-err_pam_cred_err = neizdevās iestatīt akreditācijas datus
-err_pam_cred_expired = akreditācijas dati novecojuši
-err_pam_cred_insufficient = nepietiekami akreditācijas dati
-err_pam_cred_unavail = neizdevās iegūt akreditācijas datus
-err_pam_maxtries = sasniegts maksimālais mēģinājumu skaits
-err_pam_perm_denied = piekļuve liegta
-err_pam_session = sesijas kļūda
-err_pam_sys = sistēmas kļūda
-err_pam_user_unknown = nezināms lietotājs
-err_path = neizdevās iestatīt ceļu
-err_perm_dir = neizdevās mainīt pašreizējo mapi
-err_perm_group = neizdevās pazemināt grupas atļaujas
-err_perm_user = neizdevās pazemināt lietotāja atļaujas
-err_pwnam = neizdevās iegūt lietotāja informāciju
-err_sleep = neizdevās izpildīt miega komandu
-
-err_battery = neizdevās ielādēt akumulatora stāvokli
-err_switch_tty = neizdevās pārslēgt tty
-err_tty_ctrl = tty vadības nodošana neizdevās
-err_no_users = lietotāji nav atrasti
-
-err_user_gid = neizdevās iestatīt lietotāja GID
-err_user_init = neizdevās inicializēt lietotāju
-err_user_uid = neizdevās iestatīt lietotāja UID
-err_xauth = xauth komanda neizdevās
-err_xcb_conn = xcb savienojums neizdevās
-err_xsessions_dir = neizdevās atrast sesiju mapi
-err_xsessions_open = neizdevās atvērt sesiju mapi
-
-insert = ievietot
-login = lietotājs
-logout = iziet
-no_x11_support = x11 atbalsts atspējots kompilācijas laikā
-normal = parastais
-numlock = numlock
-other = cits
-password = parole
-restart = restartēt
-shell = terminālis
-shutdown = izslēgt
-sleep = snauda
-
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/lang/normalize_lang_files.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-
-from pathlib import Path
-from sys import stderr
-
-
-def process_lang_file(path: Path, lang_keys: list[str]) -> None:
-    # read key-value-pairs from lang file into dict
-    existing_entries = {}
-    with open(path, "r", encoding="UTF-8") as fh:
-        while line := fh.readline():
-            try:
-                key, value = line.split("=", 1)
-                existing_entries[key.strip()] = value.strip()
-            except ValueError:  # line does not contain '='
-                continue
-
-    # re-write current lang file with entries in order of occurence in `lang_keys`
-    # and with empty lines for missing translations
-    with open(path, "w", encoding="UTF-8") as fh:
-        for item in lang_keys:
-            try:
-                fh.write(f"{item} = {existing_entries[item]}\n")
-            except KeyError:  # no translation for `item` yet
-                fh.write("\n")
-
-
-def main() -> None:
-    zig_lang_file = Path(__file__).parent.joinpath("../../src/config/Lang.zig").resolve()
-    if not zig_lang_file.exists():
-        print(f"ERROR: File '{zig_lang_file.as_posix()}' does not exist. Exiting.", file=stderr)
-        exit(1)
-
-    # read "language keys" from `zig_lang_file` into list
-    lang_keys = []
-    with open(zig_lang_file, "r", encoding="UTF-8") as fh:
-        while line := fh.readline():
-            # only process lines that are not empty or no comments
-            if not (line.strip() == "" or line.startswith("//")):
-                lang_keys.append(line.split(":")[0].strip())
-
-    lang_files = [f for f in Path.iterdir(Path(__file__).parent) if f.name.endswith(".ini") and f.is_file()]
-
-    for file in lang_files:
-        process_lang_file(file, lang_keys)
-
-
-if __name__ == "__main__":
-    main()

res/lang/pl.ini

@@ -1,82 +1,45 @@
-authenticating = uwierzytelnianie...
-brightness_down = zmniejsz jasność
-brightness_up = zwiększ jasność
 capslock = capslock
-custom = własny
-
-
-
 err_alloc = nieudana alokacja pamięci
-
+err_bounds = indeks poza granicami
-err_autologin_session = nie znaleziono sesji autologowania
-err_bounds = indeks poza zakresem
-err_brightness_change = nie udało się zmienić jasności
 err_chdir = nie udało się otworzyć folderu domowego
-err_clock_too_long = ciąg znaków zegara jest za długi
+err_console_dev = nie udało się uzyskać dostępu do konsoli
-err_config = nie można przetworzyć pliku konfiguracyjnego
-
 err_dgn_oob = wiadomość loga
 err_domain = niepoprawna domena
-err_empty_password = puste hasło jest niedozwolone
-err_envlist = nie udało się pobrać listy zmiennych środowiskowych
-err_get_active_tty = nie udało się uzyskać aktywnego tty
-
 err_hostname = nie udało się uzyskać nazwy hosta
-
-err_lock_state = nie udało się uzyskać stanu blokady
-err_log = nie udało się otworzyć pliku logu
 err_mlock = nie udało się zablokować pamięci haseł
-err_null = pusty wskaźnik
+err_null = wskaźnik zerowy
-err_numlock = nie udało się ustawić numlock
 err_pam = transakcja pam nieudana
 err_pam_abort = transakcja pam przerwana
 err_pam_acct_expired = konto wygasło
-err_pam_auth = błąd uwierzytelniania
+err_pam_auth = błąd autentyfikacji
 err_pam_authinfo_unavail = nie udało się zdobyć informacji o użytkowniku
 err_pam_authok_reqd = token wygasł
 err_pam_buf = błąd bufora pamięci
-err_pam_cred_err = nie udało się ustawić uwierzytelnienia
+err_pam_cred_err = nie udało się ustawić uwierzytelnienia
 err_pam_cred_expired = uwierzytelnienie wygasło
 err_pam_cred_insufficient = niewystarczające uwierzytelnienie
-err_pam_cred_unavail = nie udało się uzyskać uwierzytelnienia
+err_pam_cred_unavail = nie udało się uzyskać uwierzytelnienia
 err_pam_maxtries = osiągnięto limit prób
-err_pam_perm_denied = odmowa dostępu
+err_pam_perm_denied = brak uprawnień
 err_pam_session = błąd sesji
 err_pam_sys = błąd systemu
 err_pam_user_unknown = nieznany użytkownik
-err_path = nie udało się ustawić ścieżki
+err_path = nie udało się ustawić ścieżki
-err_perm_dir = nie udało się zmienić obecnego katalogu
+err_perm_dir = nie udało się zmienić obecnego katalogu
-err_perm_group = nie udało się obniżyć uprawnień grupy
+err_perm_group = nie udało się obniżyć uprawnień grupy
-err_perm_user = nie udało się obniżyć uprawnień użytkownika
+err_perm_user = nie udało się obniżyć uprawnień użytkownika
-err_pwnam = nie udało się uzyskać informacji o użytkowniku
+err_pwnam = nie udało się uzyskać informacji o użytkowniku
-err_sleep = nie udało się wykonać polecenia sleep
-
-err_battery = nie udało się sprawdzić statusu baterii
-err_switch_tty = nie można przełączyć tty
-err_tty_ctrl = nie udało się przekazać kontroli tty
-err_no_users = nie znaleziono żadnego użytkownika
-
 err_user_gid = nie udało się ustawić GID użytkownika
-err_user_init = nie udało się zainicjalizować użytkownika
+err_user_init = nie udało się zainicjalizować użytkownika
 err_user_uid = nie udało się ustawić UID użytkownika
-err_xauth = polecenie xauth nie powiodło się
+err_xsessions_dir = nie udało się znaleźć folderu sesji
-err_xcb_conn = połączenie xcb nie powiodło się
+err_xsessions_open = nie udało się otworzyć folderu sesji
-err_xsessions_dir = nie udało się znaleźć folderu sesji
-err_xsessions_open = nie udało się otworzyć folderu sesji
-
-insert = wstaw
 login = login
 logout = wylogowano
-no_x11_support = wsparcie X11 wyłączone podczas kompilacji
-normal = normalny
 numlock = numlock
-other = inny
 password = hasło
 restart = uruchom ponownie
 shell = powłoka
 shutdown = wyłącz
-sleep = uśpij
-
 wayland = wayland
-x11 = x11
 xinitrc = xinitrc

res/lang/pt.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = capslock
-
-
-
-
 err_alloc = erro na atribuição de memória
-
-
 err_bounds = índice fora de limites
-
 err_chdir = erro ao abrir a pasta home
-
+err_console_dev = erro ao aceder à consola
-
-
 err_dgn_oob = mensagem de registo
 err_domain = domínio inválido
-
-
-
-
 err_hostname = erro ao obter o nome do host
-
-
-
 err_mlock = erro de bloqueio de memória
 err_null = ponteiro nulo
-
 err_pam = erro na transação pam
 err_pam_abort = transação pam abortada
 err_pam_acct_expired = conta expirada
@@ -49,34 +29,17 @@ err_perm_dir = erro ao alterar o diretório atual
 err_perm_group = erro ao reduzir as permissões do grupo
 err_perm_user = erro ao reduzir as permissões do utilizador
 err_pwnam = erro ao obter informação do utilizador
-
-
-
-
-
-
-
 err_user_gid = erro ao definir o GID do utilizador
 err_user_init = erro ao iniciar o utilizador
 err_user_uid = erro ao definir o UID do utilizador
-
-
 err_xsessions_dir = erro ao localizar a pasta das sessões
 err_xsessions_open = erro ao abrir a pasta das sessões
-
-
 login = iniciar sessão
 logout = terminar sessão
-
-
 numlock = numlock
-
 password = palavra-passe
 restart = reiniciar
 shell = shell
 shutdown = encerrar
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/pt_BR.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = caixa alta
-
-
-
-
 err_alloc = alocação de memória malsucedida
-
-
 err_bounds = índice fora de limites
-
 err_chdir = não foi possível abrir o diretório home
-
+err_console_dev = não foi possível acessar o console
-
-
 err_dgn_oob = mensagem de log
 err_domain = domínio inválido
-
-
-
-
 err_hostname = não foi possível obter o nome do host
-
-
-
 err_mlock = bloqueio da memória de senha malsucedido
 err_null = ponteiro nulo
-
 err_pam = transação pam malsucedida
 err_pam_abort = transação pam abortada
 err_pam_acct_expired = conta expirada
@@ -49,34 +29,17 @@ err_perm_dir = não foi possível alterar o diretório atual
 err_perm_group = não foi possível reduzir as permissões de grupo
 err_perm_user = não foi possível reduzir as permissões de usuário
 err_pwnam = não foi possível obter informações do usuário
-
-
-
-
-
-
-
 err_user_gid = não foi possível definir o GID do usuário
 err_user_init = não foi possível iniciar o usuário
 err_user_uid = não foi possível definir o UID do usuário
-
-
 err_xsessions_dir = não foi possível encontrar a pasta das sessões
 err_xsessions_open = não foi possível abrir a pasta das sessões
-
-
 login = conectar
 logout = desconectado
-
-
 numlock = numlock
-
 password = senha
 restart = reiniciar
 shell = shell
 shutdown = desligar
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/ro.ini

@@ -1,28 +1,8 @@
-
-
-
 capslock = capslock
 
 
 
-
+err_console_dev = nu s-a putut accesa consola
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 
@@ -54,29 +34,12 @@ err_perm_user = nu s-a putut face downgrade permisiunilor de utilizator
 
 
 
-
-
-
-
-
-
-
-
-
-
-
 login = utilizator
 logout = opreşte sesiunea
-
-
 numlock = numlock
-
 password = parolă
 restart = resetează
 shell = shell
 shutdown = opreşte sistemul
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/ru.ini

@@ -1,33 +1,13 @@
-authenticating = аутентификация...
-brightness_down = уменьшить яркость
-brightness_up = увеличить яркость
 capslock = capslock
-custom = пользовательский
-
-
-
 err_alloc = не удалось выделить память
-
-err_autologin_session = не найдена сессия с автологином
 err_bounds = за пределами индекса
-err_brightness_change = не удалось изменить яркость
 err_chdir = не удалось открыть домашнюю папку
-err_clock_too_long = строка часов слишком длинная
+err_console_dev = не удалось получить доступ к консоли
-err_config = не удалось разобрать файл конфигурации
-
 err_dgn_oob = отладочное сообщение (log)
 err_domain = неверный домен
-err_empty_password = пустой пароль не допустим
-err_envlist = не удалось получить список переменных среды
-err_get_active_tty = не удалось получить активный tty
-
 err_hostname = не удалось получить имя хоста
-
-err_lock_state = не удалось получить состояние lock
-err_log = не удалось открыть файл log
 err_mlock = сбой блокировки памяти
 err_null = нулевой указатель
-err_numlock = не удалось установить numlock
 err_pam = pam транзакция не удалась
 err_pam_abort = pam транзакция прервана
 err_pam_acct_expired = срок действия аккаунта истёк
@@ -49,34 +29,17 @@ err_perm_dir = не удалось изменить текущий катало
 err_perm_group = не удалось понизить права доступа группы
 err_perm_user = не удалось понизить права доступа пользователя
 err_pwnam = не удалось получить информацию о пользователе
-err_sleep = не удалось выполнить команду sleep
-
-err_battery = не удалось получить статус батареи
-err_switch_tty = не удалось переключить tty
-err_tty_ctrl = передача управления tty не удалась
-err_no_users = пользователи не найдены
-
 err_user_gid = не удалось установить GID пользователя
 err_user_init = не удалось инициализировать пользователя
 err_user_uid = не удалось установить UID пользователя
-err_xauth = команда xauth не выполнена
-err_xcb_conn = ошибка подключения xcb
 err_xsessions_dir = не удалось найти сессионную папку
 err_xsessions_open = не удалось открыть сессионную папку
-
-insert = вставка
 login = логин
-logout = вышел из системы
+logout = logged out
-no_x11_support = поддержка x11 отключена во время компиляции
-normal = обычный
 numlock = numlock
-other = прочие
 password = пароль
 restart = перезагрузить
-shell = оболочка
+shell = shell
 shutdown = выключить
-sleep = сон
-
 wayland = wayland
-x11 = x11
 xinitrc = xinitrc

res/lang/sr.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = capslock
-
-
-
-
 err_alloc = neuspijesna alokacija memorije
-
-
 err_bounds = izvan granica indeksa
-
 err_chdir = neuspijesno otvaranje home foldera
-
+err_console_dev = neuspijesno pristupanje konzoli
-
-
 err_dgn_oob = log poruka
 err_domain = nevazeci domen
-
-
-
-
 err_hostname = neuspijesno trazenje hostname-a
-
-
-
 err_mlock = neuspijesno zakljucavanje memorije lozinke
 err_null = null pokazivac
-
 err_pam = pam transakcija neuspijesna
 err_pam_abort = pam transakcija prekinuta
 err_pam_acct_expired = nalog istekao
@@ -45,38 +25,21 @@ err_pam_session = greska sesije
 err_pam_sys = greska sistema
 err_pam_user_unknown = nepoznat korisnik
 err_path = neuspjelo postavljanje path-a
-err_perm_dir = neuspjelo mijenjanje foldera
+err_perm_dir = neuspjelo mijenjanje foldera 
 err_perm_group = neuspjesno snizavanje dozvola grupe
 err_perm_user = neuspijesno snizavanje dozvola korisnika
 err_pwnam = neuspijesno skupljanje informacija o korisniku
-
-
-
-
-
-
-
 err_user_gid = neuspijesno postavljanje korisničkog GID-a
 err_user_init = neuspijensa inicijalizacija korisnika
 err_user_uid = neuspijesno postavljanje UID-a korisnika
-
-
 err_xsessions_dir = neuspijesno pronalazenje foldera sesija
-err_xsessions_open = neuspijesno otvaranje foldera sesija
+err_xsessions_open = neuspijesno otvaranje foldera sesija 
-
-
 login = korisnik
 logout = izlogovan
-
-
 numlock = numlock
-
 password = lozinka
 restart = ponovo pokreni
 shell = shell
 shutdown = ugasi
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/sv.ini

@@ -1,82 +1,45 @@
-authenticating = autentiserar...
-brightness_down = minska ljusstyrka
-brightness_up = öka ljusstyrka
 capslock = capslock
-custom = anpassad
+err_alloc = misslyckad minnesallokering
-
+err_bounds = utanför banan index
-
-
-err_alloc = minnesallokering misslyckades
-err_args = tolkning av kommandoargument misslyckades
-err_autologin_session = autologin-session hittades inte
-err_bounds = index-värde utanför intervallet
-err_brightness_change = ändring av ljusstyrka misslyckades
 err_chdir = misslyckades att öppna hemkatalog
-err_clock_too_long = klocksträng för lång
+err_console_dev = misslyckades att komma åt konsol
-err_config = tolkning av konfigfil misslyckades
-err_crawl = genomsökning av sessionskataloger misslyckades
 err_dgn_oob = loggmeddelande
-err_domain = ogitlig domän
+err_domain = okänd domän
-err_empty_password = tomt lösenord godtas ej
+err_hostname = misslyckades att hämta värdnamn
-err_envlist = hämtning av env-lista misslyckades
+err_mlock = misslyckades att låsa lösenordsminne
-err_get_active_tty = hämtning av aktiv tty misslyckades
+err_null = nullpekare
-err_hibernate = vilolägets kommando misslyckades
-err_hostname = hämtning av hostname misslyckades
-err_inactivity = inaktivitetslägets kommando misslyckades
-err_lock_state = hämtning av låsningsstatus misslyckades
-err_log = öppning av loggfil misslyckades
-err_mlock = låsning av lösenordsminne misslyckades
-err_null = null pointer
-err_numlock = inställning av numlock misslyckades
 err_pam = pam-transaktion misslyckades
 err_pam_abort = pam-transaktion avbröts
-err_pam_acct_expired = kontot har löpt ut
+err_pam_acct_expired = konto upphört
-err_pam_auth = autentisering misslyckades
+err_pam_auth = autentiseringsfel
-err_pam_authinfo_unavail = hämtning av användarinformation misslyckades
+err_pam_authinfo_unavail = misslyckades att hämta användarinfo
-err_pam_authok_reqd = token har löpt ut
+err_pam_authok_reqd = token utgången
-err_pam_buf = minnesbufferfel
+err_pam_buf = minnesbuffer fel
-err_pam_cred_err = inställning av inloggningsuppgifter misslyckades
+err_pam_cred_err = misslyckades att ställa in inloggningsuppgifter
-err_pam_cred_expired = inloggningsuppgifterna har löpt ut
+err_pam_cred_expired = inloggningsuppgifter upphörda
 err_pam_cred_insufficient = otillräckliga inloggningsuppgifter
-err_pam_cred_unavail = hämtning av inloggningsuppgifter misslyckades
+err_pam_cred_unavail = misslyckades att hämta inloggningsuppgifter
-err_pam_maxtries = gränsen för antal försök nådd
+err_pam_maxtries = nådde maximal försöksgräns
-err_pam_perm_denied = tillstånd nekas
+err_pam_perm_denied = åtkomst nekad
 err_pam_session = sessionsfel
 err_pam_sys = systemfel
 err_pam_user_unknown = okänd användare
-err_path = inställning av sökväg misslyckades
+err_path = misslyckades att ställa in sökväg
-err_perm_dir = byte av nuvarande katalog misslyckades
+err_perm_dir = misslyckades att ändra aktuell katalog
-err_perm_group = nedgradering av grupptillstånd misslyckades
+err_perm_group = misslyckades att nergradera gruppbehörigheter
-err_perm_user = nedgradering av användartillstånd misslyckades
+err_perm_user = misslyckades att nergradera användarbehörigheter
-err_pwnam = hämtning av användarinformation misslyckades
+err_pwnam = misslyckades att hämta användarinfo
-err_sleep = strömsparlägets kommando misslyckades
+err_user_gid = misslyckades att ställa in användar-GID
-err_start = startkommando misslyckades
+err_user_init = misslyckades att initialisera användaren
-err_battery = hämtning av batteristatus misslyckades
+err_user_uid = misslyckades att ställa in användar-UID
-err_switch_tty = byte av tty misslyckades
+err_xsessions_dir = misslyckades att hitta sessionskatalog
-err_tty_ctrl = överföring av tty-kontroll misslyckades
+err_xsessions_open = misslyckades att öppna sessionskatalog
-err_no_users = inga användare hittades
-err_uid_range = dynamisk hämtning av uid-intervall misslyckades
-err_user_gid = inställning av användarens GID misslyckades
-err_user_init = initiering av användare misslyckades
-err_user_uid = inställning av användarens UID misslyckades
-err_xauth = xauth-kommando misslyckades
-err_xcb_conn = xcb-anslutning misslyckades
-err_xsessions_dir = sessionskatalog hittades inte
-err_xsessions_open = öppning av sessionskatalog misslyckades
-hibernate = viloläge
-insert = infoga
 login = inloggning
 logout = utloggad
-no_x11_support = x11-stöd inaktiverat vid kompilering
-normal = normal
 numlock = numlock
-other = övrig
 password = lösenord
 restart = starta om
-shell = shell
+shell = skal
 shutdown = stäng av
-sleep = viloläge
-
 wayland = wayland
-x11 = x11
 xinitrc = xinitrc

res/lang/tr.ini

@@ -1,33 +1,13 @@
-
-brightness_down = parlakligi azalt
-brightness_up = parlakligi arttir
 capslock = capslock
-
-
-
-
 err_alloc = basarisiz bellek ayirma
-
-
 err_bounds = sinirlarin disinda dizin
-
 err_chdir = ev klasoru acilamadi
-
+err_console_dev = konsola erisilemedi
-
-
 err_dgn_oob = log mesaji
 err_domain = gecersiz etki alani
-
-
-
-
 err_hostname = ana bilgisayar adi alinamadi
-
-
-
 err_mlock = parola bellegi kilitlenemedi
 err_null = bos isaretci hatasi
-
 err_pam = pam islemi basarisiz oldu
 err_pam_abort = pam islemi durduruldu
 err_pam_acct_expired = hesabin suresi dolmus
@@ -49,34 +29,17 @@ err_perm_dir = gecerli dizin degistirilemedi
 err_perm_group = grup izinleri dusurulemedi
 err_perm_user = kullanici izinleri dusurulemedi
 err_pwnam = kullanici bilgileri alinamadi
-
-
-
-
-
-
-
 err_user_gid = kullanici icin GID ayarlanamadi
 err_user_init = kullanici oturumu baslatilamadi
 err_user_uid = kullanici icin UID ayarlanamadi
-
-
 err_xsessions_dir = oturumlar klasoru bulunamadi
 err_xsessions_open = oturumlar klasoru acilamadi
-hibernate = askiya al
-
 login = kullanici
 logout = oturumdan cikis yapildi
-
-
 numlock = numlock
-other = baska
 password = sifre
 restart = yeniden baslat
 shell = shell
 shutdown = makineyi kapat
-sleep = uykuya al
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/uk.ini

@@ -1,33 +1,13 @@
-
-
-
 capslock = capslock
-
-
-
-
 err_alloc = невдале виділення пам'яті
-
-
 err_bounds = поза межами індексу
-
 err_chdir = не вдалося відкрити домашній каталог
-
+err_console_dev = невдалий доступ до консолі
-
-
 err_dgn_oob = повідомлення журналу (log)
 err_domain = недійсний домен
-
-
-
-
 err_hostname = не вдалося отримати ім'я хосту
-
-
-
 err_mlock = збій блокування пам'яті
 err_null = нульовий вказівник
-
 err_pam = невдала pam транзакція
 err_pam_abort = pam транзакція перервана
 err_pam_acct_expired = термін дії акаунту вичерпано
@@ -49,34 +29,17 @@ err_perm_dir = не вдалося змінити поточний катало
 err_perm_group = не вдалося понизити права доступу групи
 err_perm_user = не вдалося понизити права доступу користувача
 err_pwnam = не вдалося отримати дані користувача
-
-
-
-
-
-
-
 err_user_gid = не вдалося змінити GID користувача
 err_user_init = не вдалося ініціалізувати користувача
 err_user_uid = не вдалося змінити UID користувача
-
-
 err_xsessions_dir = не вдалося знайти каталог сесій
 err_xsessions_open = не вдалося відкрити каталог сесій
-
-
 login = логін
 logout = вийти
-
-
 numlock = numlock
-
 password = пароль
 restart = перезавантажити
 shell = оболонка
 shutdown = вимкнути
-
-
 wayland = wayland
-
 xinitrc = xinitrc

res/lang/zh_CN.ini

@@ -1,82 +0,0 @@
-
-
-
-capslock = 大写锁定
-
-
-
-
-err_alloc = 内存分配失败
-
-
-err_bounds = 索引越界
-
-err_chdir = 无法打开home文件夹
-
-
-
-err_dgn_oob = 日志消息
-err_domain = 无效的域
-
-
-
-
-err_hostname = 获取主机名失败
-
-
-
-err_mlock = 锁定密码存储器失败
-err_null = 空指针
-
-err_pam = PAM事件失败
-err_pam_abort = PAM事务已中止
-err_pam_acct_expired = 帐户已过期
-err_pam_auth = 身份验证错误
-err_pam_authinfo_unavail = 获取用户信息失败
-err_pam_authok_reqd = 口令已过期
-err_pam_buf = 内存缓冲区错误
-err_pam_cred_err = 设置凭据失败
-err_pam_cred_expired = 凭据已过期
-err_pam_cred_insufficient = 凭据不足
-err_pam_cred_unavail = 无法获取凭据
-err_pam_maxtries = 已达到最大尝试次数限制
-err_pam_perm_denied = 拒绝访问
-err_pam_session = 会话错误
-err_pam_sys = 系统错误
-err_pam_user_unknown = 未知用户
-err_path = 无法设置路径
-err_perm_dir = 更改当前目录失败
-err_perm_group = 组权限降级失败
-err_perm_user = 用户权限降级失败
-err_pwnam = 获取用户信息失败
-
-
-
-
-
-
-
-err_user_gid = 设置用户GID失败
-err_user_init = 初始化用户失败
-err_user_uid = 设置用户UID失败
-
-
-err_xsessions_dir = 找不到会话文件夹
-err_xsessions_open = 无法打开会话文件夹
-
-
-login = 登录
-logout = 注销
-
-
-numlock = 数字锁定
-
-password = 密码
-
-shell = shell
-
-
-
-wayland = wayland
-x11 = x11
-xinitrc = xinitrc

res/ly-dinit

@@ -1,8 +1,8 @@
 type            = process
 restart         = true
 smooth-recovery = true
-command         = $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME
+command         = $PREFIX_DIRECTORY/bin/$EXE_NAME
-depends-on      = login.target
+depends-on      = loginready
 termsignal      = HUP
-# ly needs access to the console while login.target already occupies it
+# ly needs access to the console while loginready already occupies it
 options         = shares-console

res/ly-freebsd-wrapper

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-# On FreeBSD, even if we override the default login program, getty will still
-# try to append "login -fp root" as arguments to Ly, which is not supported.
-# To avoid this, we use a wrapper script that ignores these arguments before
-# actually executing Ly.
-exec $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME

res/ly-kmsconvt@.service

@@ -1,17 +0,0 @@
-[Unit]
-Description=TUI display manager using KMSCON
-After=systemd-user-sessions.service plymouth-quit-wait.service
-After=kmsconvt@%i.service
-Conflicts=kmsconvt@%i.service
-
-[Service]
-ExecStart=$PREFIX_DIRECTORY/bin/kmscon --font-engine unifont --vt=%I --seats=seat0 --login -- $PREFIX_DIRECTORY/bin/ly --use-kmscon-vt
-StandardInput=tty
-UtmpIdentifier=%I
-TTYPath=/dev/%I
-TTYReset=yes
-TTYVHangup=yes
-TTYVTDisallocate=yes
-
-[Install]
-WantedBy=multi-user.target

res/ly-openrc

@@ -19,8 +19,12 @@ then
     commandUL="/sbin/agetty"
 fi
 
+## Get the tty from the conf file
+CONFTTY=$(cat $CONFIG_DIRECTORY/ly/config.ini | sed -n 's/^tty.*=[^1-9]*// p')
+
 ## The execution vars
-TTY="tty$DEFAULT_TTY"
+# If CONFTTY is empty then default to $DEFAULT_TTY
+TTY="tty${CONFTTY:-$DEFAULT_TTY}"
 TERM=linux
 BAUD=38400
 # If we don't have getty then we should have agetty

res/ly-runit-service/conf

@@ -7,4 +7,6 @@ fi
 
 BAUD_RATE=38400
 TERM_NAME=linux
-TTY=tty$DEFAULT_TTY
+
+auxtty=$(/bin/cat $CONFIG_DIRECTORY/ly/config.ini 2>/dev/null 1| /bin/sed -n 's/\(^[[:space:]]*tty[[:space:]]*=[[:space:]]*\)\([[:digit:]][[:digit:]]*\)\(.*\)/\2/p')
+TTY=tty${auxtty:-$DEFAULT_TTY}

res/ly-s6/run

@@ -1,2 +1,2 @@
 #!/bin/execlineb -P
-exec agetty -L -8 -n -l $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME tty$DEFAULT_TTY 115200
+exec agetty -L -8 -n -l $PREFIX_DIRECTORY/bin/$EXE_NAME tty$DEFAULT_TTY 115200

res/ly-sysvinit

@@ -1,65 +0,0 @@
-#!/bin/sh
-### BEGIN INIT INFO
-# Provides:          ly
-# Required-Start:    $remote_fs $syslog
-# Required-Stop:     $remote_fs $syslog
-# Default-Start:     2 3 4 5
-# Default-Stop:      0 1 6
-# Short-Description: Ly display manager
-# Description:       Starts and stops the Ly display manager
-### END INIT INFO
-#
-# Author:       AnErrupTion <anerruption@disroot.org>
-#
-
-PATH=/sbin:/usr/sbin:/bin:/usr/bin
-DAEMON=/usr/bin/ly
-TTY=/dev/tty$DEFAULT_TTY
-PIDFILE=/var/run/ly.pid
-NAME=ly
-DESC="Ly display manager"
-
-. /lib/lsb/init-functions
-
-case "$1" in
-  start)
-    log_daemon_msg "Starting $DESC on $TTY..."
-    if [ -f "$PIDFILE" ]; then
-        log_progress_msg "$DESC is already running"
-        log_end_msg 0
-        return 0
-    fi
-
-    # Ensure TTY exists
-    [ -c "$TTY" ] || {
-        log_failure_msg "$TTY does not exist"
-        return 1
-    }
-
-    start-stop-daemon --start --background --make-pidfile --pidfile $PIDFILE \
-      --chdir / --exec /bin/sh -- -c "exec setsid sh -c 'exec <$TTY >$TTY 2>&1 $DAEMON'"
-    log_end_msg $?
-    ;;
-  stop)
-    log_daemon_msg "Stopping $DESC..."
-    start-stop-daemon --stop --pidfile $PIDFILE --retry 5
-    RETVAL=$?
-    [ $RETVAL -eq 0 ] && rm -f "$PIDFILE"
-    log_end_msg $RETVAL
-    ;;
-  restart)
-    echo "Restarting $DESC..."
-    $0 stop
-    sleep 1
-    $0 start
-    ;;
-  status)
-    status_of_proc -p $PIDFILE $DAEMON $NAME && exit 0 || exit $?
-    ;;
-  *)
-    echo "Usage: /etc/init.d/$NAME {start|stop|restart|status}"
-    exit 1
-    ;;
-esac
-
-exit 0

res/ly.service

@@ -1,16 +1,16 @@
 [Unit]
 Description=TUI display manager
 After=systemd-user-sessions.service plymouth-quit-wait.service
-After=getty@%i.service
+After=getty@tty$DEFAULT_TTY.service
-Conflicts=getty@%i.service
+Conflicts=getty@tty$DEFAULT_TTY.service
 
 [Service]
 Type=idle
 ExecStart=$PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME
 StandardInput=tty
-TTYPath=/dev/%I
+TTYPath=/dev/tty$DEFAULT_TTY
 TTYReset=yes
 TTYVHangup=yes
 
 [Install]
-WantedBy=multi-user.target
+Alias=display-manager.service

res/pam.d/ly-freebsd

@@ -1,8 +0,0 @@
-#%PAM-1.0
-
-# OpenPAM (used in FreeBSD) doesn't support prepending "-" for ignoring missing
-# modules.
-auth       include      login
-account    include      login
-password   include      login
-session    include      login

res/pam.d/ly-freebsd-autologin

@@ -1,9 +0,0 @@
-#%PAM-1.0
-
-# OpenPAM (used in FreeBSD) doesn't support prepending "-" for ignoring missing
-# modules.
-auth       required     pam_permit.so
-auth       include      login
-account    include      login
-password   include      login
-session    include      login

res/pam.d/ly-linux-autologin

@@ -1,16 +0,0 @@
-#%PAM-1.0
-
-auth       required     pam_permit.so
--auth      optional     pam_gnome_keyring.so
--auth      optional     pam_kwallet5.so
-
-account    include      login
-
-password   include      login
--password  optional     pam_gnome_keyring.so use_authtok
-
--session   optional     pam_systemd.so       class=greeter
--session   optional     pam_elogind.so
-session    include      login
--session   optional     pam_gnome_keyring.so auto_start
--session   optional     pam_kwallet5.so      auto_start

res/setup.sh

@@ -89,10 +89,6 @@ if [ "$XDG_SESSION_TYPE" = "x11" ]; then
         done
     fi
 
-    if [ -f "$USERXSESSION" ]; then
-        . "$USERXSESSION"
-    fi
-
     if [ -d "$CONFIG_DIRECTORY"/X11/Xresources ]; then
         for i in "$CONFIG_DIRECTORY"/X11/Xresources/*; do
             [ -f "$i" ] && xrdb -merge "$i"
@@ -102,6 +98,10 @@ if [ "$XDG_SESSION_TYPE" = "x11" ]; then
     fi
     [ -f "$HOME"/.Xresources ] && xrdb -merge "$HOME"/.Xresources
     [ -f "$XDG_CONFIG_HOME"/X11/Xresources ] && xrdb -merge "$XDG_CONFIG_HOME"/X11/Xresources
+
+    if [ -f "$USERXSESSION" ]; then
+        . "$USERXSESSION"
+    fi
 fi
 
 exec "$@"

res/startup.sh

@@ -1,37 +0,0 @@
-#!/bin/sh
-# This file is executed when starting Ly (before the TTY is taken control of)
-# Custom startup code can be placed in this file or the start_cmd var can be pointed to a different file
-
-
-# Uncomment the example below for an example of changing the default TTY colors to an alternitive palette on linux
-# Colors are in red/green/blue hex (the current colors are a brighter palette than default)
-#
-# if [ "$TERM" = "linux" ]; then
-# 	BLACK="232323"
-# 	DARK_RED="D75F5F"
-# 	DARK_GREEN="87AF5F"
-# 	DARK_YELLOW="D7AF87"
-# 	DARK_BLUE="8787AF"
-# 	DARK_MAGENTA="BD53A5"
-# 	DARK_CYAN="5FAFAF"
-# 	LIGHT_GRAY="E5E5E5"
-# 	DARK_GRAY="2B2B2B"
-# 	RED="E33636"
-# 	GREEN="98E34D"
-# 	YELLOW="FFD75F"
-# 	BLUE="7373C9"
-# 	MAGENTA="D633B2"
-# 	CYAN="44C9C9"
-# 	WHITE="FFFFFF"
-
-# 	COLORS="${BLACK} ${DARK_RED} ${DARK_GREEN} ${DARK_YELLOW} ${DARK_BLUE} ${DARK_MAGENTA} ${DARK_CYAN} ${LIGHT_GRAY} ${DARK_GRAY} ${RED} ${GREEN} ${YELLOW} ${BLUE} ${MAGENTA} ${CYAN} ${WHITE}"
-
-# 	i=0
-# 	while [ $i -lt 16 ]; do
-# 		printf "\033]P%x%s" ${i} "$(echo "$COLORS" | cut -d ' ' -f$(( i + 1)))"
-
-# 		i=$(( i + 1 ))
-# 	done
-
-# 	clear # for fixing background artifacting after changing color
-# fi

res/valgrind.supp

@@ -0,0 +1,31 @@
+{
+	pam
+	Memcheck:Leak
+	...
+	obj:/usr/lib/libpam.so.0.84.2
+	...
+}
+
+{
+	termbox
+	Memcheck:Leak
+	...
+	fun:tb_init
+	...
+}
+
+{
+	libc/dynamic
+	Memcheck:Leak
+	...
+	fun:_dl_catch_exception
+	...
+}
+
+{
+	libc/groups
+	Memcheck:Leak
+	...
+	fun:initgroups
+	...
+}

src/Environment.zig

@@ -1,24 +0,0 @@
-const ini = @import("ly-ui").ly_core.ini;
-const Ini = ini.Ini;
-
-const enums = @import("enums.zig");
-const DisplayServer = enums.DisplayServer;
-
-pub const DesktopEntry = struct {
-    Exec: []const u8 = "",
-    Name: []const u8 = "",
-    DesktopNames: ?[]u8 = null,
-    Terminal: ?bool = null,
-};
-
-pub const Entry = struct { @"Desktop Entry": DesktopEntry = .{} };
-
-entry_ini: ?Ini(Entry) = null,
-file_name: []const u8 = "",
-name: []const u8 = "",
-xdg_session_desktop: ?[]const u8 = null,
-xdg_desktop_names: ?[]const u8 = null,
-cmd: ?[]const u8 = null,
-specifier: []const u8 = "",
-display_server: DisplayServer = .wayland,
-is_terminal: bool = false,

src/SharedError.zig

@@ -0,0 +1,39 @@
+const std = @import("std");
+
+const ErrInt = std.meta.Int(.unsigned, @bitSizeOf(anyerror));
+
+const ErrorHandler = packed struct {
+    has_error: bool = false,
+    err_int: ErrInt = 0,
+};
+
+const SharedError = @This();
+
+data: []align(std.mem.page_size) u8,
+
+pub fn init() !SharedError {
+    const data = try std.posix.mmap(null, @sizeOf(ErrorHandler), std.posix.PROT.READ | std.posix.PROT.WRITE, .{ .TYPE = .SHARED, .ANONYMOUS = true }, -1, 0);
+
+    return .{ .data = data };
+}
+
+pub fn deinit(self: *SharedError) void {
+    std.posix.munmap(self.data);
+}
+
+pub fn writeError(self: SharedError, err: anyerror) void {
+    var buf_stream = std.io.fixedBufferStream(self.data);
+    const writer = buf_stream.writer();
+    writer.writeStruct(ErrorHandler{ .has_error = true, .err_int = @intFromError(err) }) catch {};
+}
+
+pub fn readError(self: SharedError) ?anyerror {
+    var buf_stream = std.io.fixedBufferStream(self.data);
+    const reader = buf_stream.reader();
+    const err_handler = try reader.readStruct(ErrorHandler);
+
+    if (err_handler.has_error)
+        return @errorFromInt(err_handler.err_int);
+
+    return null;
+}

src/animations/Cascade.zig

@@ -1,92 +0,0 @@
-const std = @import("std");
-const math = std.math;
-
-const ly_ui = @import("ly-ui");
-const Cell = ly_ui.Cell;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-
-const Cascade = @This();
-
-io: std.Io,
-instance: ?Widget = null,
-buffer: *TerminalBuffer,
-current_auth_fails: *u64,
-max_auth_fails: u64,
-
-pub fn init(
-    io: std.Io,
-    buffer: *TerminalBuffer,
-    current_auth_fails: *u64,
-    max_auth_fails: u64,
-) Cascade {
-    return .{
-        .io = io,
-        .instance = null,
-        .buffer = buffer,
-        .current_auth_fails = current_auth_fails,
-        .max_auth_fails = max_auth_fails,
-    };
-}
-
-pub fn widget(self: *Cascade) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Cascade",
-        null,
-        self,
-        null,
-        null,
-        draw,
-        null,
-        null,
-        null,
-    );
-    return &self.instance.?;
-}
-
-fn draw(self: *Cascade) void {
-    while (self.current_auth_fails.* >= self.max_auth_fails) {
-        self.io.sleep(.fromMilliseconds(10), .real) catch {};
-
-        var changed = false;
-        var y = self.buffer.height - 2;
-
-        while (y > 0) : (y -= 1) {
-            for (0..self.buffer.width) |x| {
-                const cell = TerminalBuffer.getCell(x, y - 1);
-                const cell_under = TerminalBuffer.getCell(x, y);
-
-                // This shouldn't happen under normal circumstances, but because
-                // this is a *secret* animation, there's no need to care that much
-                if (cell == null or cell_under == null) continue;
-
-                const char: u8 = @truncate(cell.?.ch);
-                if (std.ascii.isWhitespace(char)) continue;
-
-                const char_under: u8 = @truncate(cell_under.?.ch);
-                if (!std.ascii.isWhitespace(char_under)) continue;
-
-                changed = true;
-
-                if ((self.buffer.random.int(u16) % 10) > 7) continue;
-
-                cell.?.put(x, y);
-
-                var space = Cell.init(
-                    ' ',
-                    cell_under.?.fg,
-                    cell_under.?.bg,
-                );
-                space.put(x, y - 1);
-            }
-        }
-
-        if (!changed) {
-            self.io.sleep(.fromSeconds(7), .real) catch {};
-            self.current_auth_fails.* = 0;
-        }
-
-        TerminalBuffer.presentBuffer();
-    }
-}

src/animations/ColorMix.zig

@@ -1,132 +0,0 @@
-const std = @import("std");
-const math = std.math;
-
-const ly_ui = @import("ly-ui");
-const Cell = ly_ui.Cell;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-
-const ly_core = ly_ui.ly_core;
-const interop = ly_core.interop;
-const TimeOfDay = interop.TimeOfDay;
-
-const ColorMix = @This();
-
-const Vec2 = @Vector(2, f32);
-
-const time_scale: f32 = 0.01;
-const palette_len: usize = 12;
-
-fn length(vec: Vec2) f32 {
-    return math.sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
-}
-
-instance: ?Widget = null,
-start_time: TimeOfDay,
-terminal_buffer: *TerminalBuffer,
-animate: *bool,
-timeout_sec: u12,
-frame_delay: u16,
-frames: u64,
-pattern_cos_mod: f32,
-pattern_sin_mod: f32,
-palette: [palette_len]Cell,
-
-pub fn init(
-    terminal_buffer: *TerminalBuffer,
-    col1: u32,
-    col2: u32,
-    col3: u32,
-    animate: *bool,
-    timeout_sec: u12,
-    frame_delay: u16,
-) !ColorMix {
-    return .{
-        .instance = null,
-        .start_time = try interop.getTimeOfDay(),
-        .terminal_buffer = terminal_buffer,
-        .animate = animate,
-        .timeout_sec = timeout_sec,
-        .frame_delay = frame_delay,
-        .frames = 0,
-        .pattern_cos_mod = terminal_buffer.random.float(f32) * math.pi * 2.0,
-        .pattern_sin_mod = terminal_buffer.random.float(f32) * math.pi * 2.0,
-        .palette = [palette_len]Cell{
-            Cell.init(0x2588, col1, col2),
-            Cell.init(0x2593, col1, col2),
-            Cell.init(0x2592, col1, col2),
-            Cell.init(0x2591, col1, col2),
-            Cell.init(0x2588, col2, col3),
-            Cell.init(0x2593, col2, col3),
-            Cell.init(0x2592, col2, col3),
-            Cell.init(0x2591, col2, col3),
-            Cell.init(0x2588, col3, col1),
-            Cell.init(0x2593, col3, col1),
-            Cell.init(0x2592, col3, col1),
-            Cell.init(0x2591, col3, col1),
-        },
-    };
-}
-
-pub fn widget(self: *ColorMix) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "ColorMix",
-        null,
-        self,
-        null,
-        null,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-fn draw(self: *ColorMix) void {
-    if (!self.animate.*) return;
-
-    self.frames +%= 1;
-    const time: f32 = @as(f32, @floatFromInt(self.frames)) * time_scale;
-
-    for (0..self.terminal_buffer.width) |x| {
-        for (0..self.terminal_buffer.height) |y| {
-            const xi: i32 = @intCast(x);
-            const yi: i32 = @intCast(y);
-            const wi: i32 = @intCast(self.terminal_buffer.width);
-            const hi: i32 = @intCast(self.terminal_buffer.height);
-
-            var uv: Vec2 = .{
-                @as(f32, @floatFromInt(xi * 2 - wi)) / @as(f32, @floatFromInt(self.terminal_buffer.height * 2)),
-                @as(f32, @floatFromInt(yi * 2 - hi)) / @as(f32, @floatFromInt(self.terminal_buffer.height)),
-            };
-
-            var uv2: Vec2 = @splat(uv[0] + uv[1]);
-
-            for (0..3) |_| {
-                uv2 += uv + @as(Vec2, @splat(length(uv)));
-                uv += @as(Vec2, @splat(0.5)) * Vec2{
-                    math.cos(self.pattern_cos_mod + uv2[1] * 0.2 + time * 0.1),
-                    math.sin(self.pattern_sin_mod + uv2[0] - time * 0.1),
-                };
-                uv -= @splat(1.0 * math.cos(uv[0] + uv[1]) - math.sin(uv[0] * 0.7 - uv[1]));
-            }
-
-            const cell = self.palette[@as(usize, @trunc(math.floor(length(uv) * 5.0))) % palette_len];
-            cell.put(x, y);
-        }
-    }
-}
-
-fn update(self: *ColorMix, _: *anyopaque) !void {
-    const time = try interop.getTimeOfDay();
-
-    if (self.timeout_sec > 0 and time.seconds - self.start_time.seconds > self.timeout_sec) {
-        self.animate.* = false;
-    }
-}
-
-fn calculateTimeout(self: *ColorMix, _: *anyopaque) !?usize {
-    return self.frame_delay;
-}

src/animations/Doom.zig

@@ -1,141 +1,76 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
+const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
+const utils = @import("../tui/utils.zig");
 
-const ly_ui = @import("ly-ui");
+const interop = @import("../interop.zig");
-const Cell = ly_ui.Cell;
+const termbox = interop.termbox;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-
-const ly_core = ly_ui.ly_core;
-const interop = ly_core.interop;
-const TimeOfDay = interop.TimeOfDay;
 
 const Doom = @This();
 
-pub const STEPS = 12;
+pub const STEPS = 13;
-pub const HEIGHT_MAX = 9;
+pub const FIRE = [_]utils.Cell{
-pub const SPREAD_MAX = 4;
+    utils.initCell(' ', 9, 0),
+    utils.initCell(0x2591, 2, 0), // Red
+    utils.initCell(0x2592, 2, 0), // Red
+    utils.initCell(0x2593, 2, 0), // Red
+    utils.initCell(0x2588, 2, 0), // Red
+    utils.initCell(0x2591, 4, 2), // Yellow
+    utils.initCell(0x2592, 4, 2), // Yellow
+    utils.initCell(0x2593, 4, 2), // Yellow
+    utils.initCell(0x2588, 4, 2), // Yellow
+    utils.initCell(0x2591, 8, 4), // White
+    utils.initCell(0x2592, 8, 4), // White
+    utils.initCell(0x2593, 8, 4), // White
+    utils.initCell(0x2588, 8, 4), // White
+};
 
-instance: ?Widget = null,
-start_time: TimeOfDay,
 allocator: Allocator,
 terminal_buffer: *TerminalBuffer,
-animate: *bool,
-timeout_sec: u12,
-frame_delay: u16,
 buffer: []u8,
-height: u8,
-spread: u8,
-fire: [STEPS + 1]Cell,
 
-pub fn init(
+pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer) !Doom {
-    allocator: Allocator,
-    terminal_buffer: *TerminalBuffer,
-    top_color: u32,
-    middle_color: u32,
-    bottom_color: u32,
-    fire_height: u8,
-    fire_spread: u8,
-    animate: *bool,
-    timeout_sec: u12,
-    frame_delay: u16,
-) !Doom {
     const buffer = try allocator.alloc(u8, terminal_buffer.width * terminal_buffer.height);
     initBuffer(buffer, terminal_buffer.width);
 
-    const levels =
-        [_]Cell{
-            Cell.init(' ', terminal_buffer.bg, terminal_buffer.bg),
-            Cell.init(0x2591, top_color, terminal_buffer.bg),
-            Cell.init(0x2592, top_color, terminal_buffer.bg),
-            Cell.init(0x2593, top_color, terminal_buffer.bg),
-            Cell.init(0x2588, top_color, terminal_buffer.bg),
-            Cell.init(0x2591, middle_color, top_color),
-            Cell.init(0x2592, middle_color, top_color),
-            Cell.init(0x2593, middle_color, top_color),
-            Cell.init(0x2588, middle_color, top_color),
-            Cell.init(0x2591, bottom_color, middle_color),
-            Cell.init(0x2592, bottom_color, middle_color),
-            Cell.init(0x2593, bottom_color, middle_color),
-            Cell.init(0x2588, bottom_color, middle_color),
-        };
-
     return .{
-        .instance = null,
-        .start_time = try interop.getTimeOfDay(),
         .allocator = allocator,
         .terminal_buffer = terminal_buffer,
-        .animate = animate,
-        .timeout_sec = timeout_sec,
-        .frame_delay = frame_delay,
         .buffer = buffer,
-        .height = @min(HEIGHT_MAX, fire_height),
-        .spread = @min(SPREAD_MAX, fire_spread),
-        .fire = levels,
     };
 }
 
-pub fn widget(self: *Doom) *Widget {
+pub fn deinit(self: Doom) void {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Doom",
-        null,
-        self,
-        deinit,
-        realloc,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-fn deinit(self: *Doom) void {
     self.allocator.free(self.buffer);
 }
 
-fn realloc(self: *Doom) !void {
+pub fn realloc(self: *Doom) !void {
     const buffer = try self.allocator.realloc(self.buffer, self.terminal_buffer.width * self.terminal_buffer.height);
     initBuffer(buffer, self.terminal_buffer.width);
     self.buffer = buffer;
 }
 
-fn draw(self: *Doom) void {
+pub fn draw(self: Doom) void {
-    if (!self.animate.*) return;
-
     for (0..self.terminal_buffer.width) |x| {
-        // We start from 1 so that we always have the topmost line when spreading fire
         for (1..self.terminal_buffer.height) |y| {
-            // Get index of current cell in fire level buffer
+            const source = y * self.terminal_buffer.width + x;
-            const from = y * self.terminal_buffer.width + x;
+            const random = (self.terminal_buffer.random.int(u16) % 7) & 3;
 
-            // Generate random data for fire propagation
+            var dest = (source - @min(source, random)) + 1;
-            const rand_loss = self.terminal_buffer.random.intRangeAtMost(u8, 0, HEIGHT_MAX);
+            if (self.terminal_buffer.width > dest) dest = 0 else dest -= self.terminal_buffer.width;
-            const rand_spread = self.terminal_buffer.random.intRangeAtMost(u8, 0, self.spread * 2);
 
-            // Select semi-random target cell
+            const buffer_source = self.buffer[source];
-            const to = from -| self.terminal_buffer.width + self.spread -| rand_spread;
+            const buffer_dest_offset = random & 1;
-            const to_x = to % self.terminal_buffer.width;
-            const to_y = to / self.terminal_buffer.width;
 
-            // Get fire level of current cell
+            if (buffer_source < buffer_dest_offset) continue;
-            const level_buf_from = self.buffer[from];
 
-            // Choose new fire level and store in level buffer
+            var buffer_dest = buffer_source - buffer_dest_offset;
-            const level_buf_to = level_buf_from -| @intFromBool(rand_loss >= self.height);
+            if (buffer_dest > 12) buffer_dest = 0;
-            self.buffer[to] = level_buf_to;
+            self.buffer[dest] = @intCast(buffer_dest);
 
-            // Send known fire levels to terminal buffer
+            self.terminal_buffer.buffer[dest] = toTermboxCell(FIRE[buffer_dest]);
-            const from_cell = self.fire[level_buf_from];
+            self.terminal_buffer.buffer[source] = toTermboxCell(FIRE[buffer_source]);
-            const to_cell = self.fire[level_buf_to];
-            from_cell.put(x, y);
-            to_cell.put(to_x, to_y);
         }
-
-        // Draw bottom line (fire source)
-        const src_cell = self.fire[STEPS];
-        src_cell.put(x, self.terminal_buffer.height - 1);
     }
 }
 
@@ -144,20 +79,14 @@ fn initBuffer(buffer: []u8, width: usize) void {
     const slice_start = buffer[0..length];
     const slice_end = buffer[length..];
 
-    // Initialize the framebuffer in black, except for the "fire source" as the
-    // last color
     @memset(slice_start, 0);
-    @memset(slice_end, STEPS);
+    @memset(slice_end, STEPS - 1);
 }
 
-fn update(self: *Doom, _: *anyopaque) !void {
+fn toTermboxCell(cell: utils.Cell) termbox.tb_cell {
-    const time = try interop.getTimeOfDay();
+    return .{
-
+        .ch = cell.ch,
-    if (self.timeout_sec > 0 and time.seconds - self.start_time.seconds > self.timeout_sec) {
+        .fg = cell.fg,
-        self.animate.* = false;
+        .bg = cell.bg,
-    }
+    };
-}
-
-fn calculateTimeout(self: *Doom, _: *anyopaque) !?usize {
-    return self.frame_delay;
 }

src/animations/DurFile.zig

@@ -1,528 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-const Json = std.json;
-const eql = std.mem.eql;
-const flate = std.compress.flate;
-
-const ly_ui = @import("ly-ui");
-const Cell = ly_ui.Cell;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Color = TerminalBuffer.Color;
-const Styling = TerminalBuffer.Styling;
-const Widget = ly_ui.Widget;
-
-const ly_core = ly_ui.ly_core;
-const interop = ly_core.interop;
-const TimeOfDay = interop.TimeOfDay;
-const LogFile = ly_core.LogFile;
-
-const enums = @import("../enums.zig");
-const DurOffsetAlignment = enums.DurOffsetAlignment;
-
-fn read_decompress_file(allocator: Allocator, io: std.Io, file_path: []const u8) ![]u8 {
-    const file_buffer = std.Io.Dir.cwd().openFile(io, file_path, .{}) catch {
-        return error.FileNotFound;
-    };
-    defer file_buffer.close(io);
-
-    var file_reader_buffer: [4096]u8 = undefined;
-    var decompress_buffer: [flate.max_window_len]u8 = undefined;
-
-    var file_reader = file_buffer.reader(io, &file_reader_buffer);
-    var decompress: flate.Decompress = .init(&file_reader.interface, .gzip, &decompress_buffer);
-
-    const file_decompressed = decompress.reader.allocRemaining(allocator, .unlimited) catch {
-        return error.NotValidFile;
-    };
-
-    return file_decompressed;
-}
-
-const Frame = struct {
-    frameNumber: i32,
-    delay: f32,
-    contents: [][]u8,
-    colorMap: [][][]i32,
-
-    // allocator must be outside of struct as it will fail the json parser
-    pub fn deinit(self: *const Frame, allocator: Allocator) void {
-        for (self.contents) |con| {
-            allocator.free(con);
-        }
-        allocator.free(self.contents);
-
-        for (self.colorMap) |cm| {
-            for (cm) |int2| {
-                allocator.free(int2);
-            }
-            allocator.free(cm);
-        }
-        allocator.free(self.colorMap);
-    }
-};
-
-// https://github.com/cmang/durdraw/blob/0.29.0/durformat.md
-const DurFormat = struct {
-    allocator: Allocator,
-    formatVersion: ?i64 = null,
-    colorFormat: ?[]const u8 = null,
-    encoding: ?[]const u8 = null,
-    framerate: ?f64 = null,
-    columns: ?i64 = null,
-    lines: ?i64 = null,
-    frames: std.ArrayList(Frame) = undefined,
-
-    pub fn valid(self: *DurFormat) bool {
-        if (self.formatVersion != null and
-            self.colorFormat != null and
-            self.encoding != null and
-            self.framerate != null and
-            self.columns != null and
-            self.lines != null and
-            self.frames.items.len >= 1)
-        {
-            // v8 may have breaking changes like changing the colormap xy direction
-            // (https://github.com/cmang/durdraw/issues/24)
-            if (self.formatVersion.? != 7) return false;
-
-            // Code currently only supports 16 and 256 color format only
-            if (!(eql(u8, "16", self.colorFormat.?) or eql(u8, "256", self.colorFormat.?)))
-                return false;
-
-            // Code currently supports only utf-8 encoding
-            if (!eql(u8, self.encoding.?, "utf-8")) return false;
-
-            // Sanity check on file
-            if (self.columns.? <= 0) return false;
-            if (self.lines.? <= 0) return false;
-            if (self.framerate.? < 0) return false;
-
-            return true;
-        }
-
-        return false;
-    }
-
-    fn parse_dur_from_json(self: *DurFormat, allocator: Allocator, dur_json_root: Json.Value) !void {
-        var dur_movie = if (dur_json_root.object.get("DurMovie")) |dm| dm.object else return error.NotValidFile;
-
-        // Depending on the version, a dur file can have different json object names (ie: columns vs sizeX)
-        self.formatVersion = if (dur_movie.get("formatVersion")) |x| x.integer else null;
-        self.colorFormat = if (dur_movie.get("colorFormat")) |x| try allocator.dupe(u8, x.string) else null;
-        self.encoding = if (dur_movie.get("encoding")) |x| try allocator.dupe(u8, x.string) else null;
-        self.framerate = if (dur_movie.get("framerate")) |x| x.float else null;
-        self.columns = if (dur_movie.get("columns")) |x| x.integer else if (dur_movie.get("sizeX")) |x| x.integer else null;
-
-        self.lines = if (dur_movie.get("lines")) |x| x.integer else if (dur_movie.get("sizeY")) |x| x.integer else null;
-
-        const frames = dur_movie.get("frames") orelse return error.NotValidFile;
-
-        self.frames = try .initCapacity(allocator, frames.array.items.len);
-
-        for (frames.array.items) |json_frame| {
-            var parsed_frame = try Json.parseFromValue(Frame, allocator, json_frame, .{});
-            defer parsed_frame.deinit();
-
-            const frame_val = parsed_frame.value;
-
-            // copy all fields to own the ptrs for deallocation, the parsed_frame has some other
-            // allocated memory making it difficult to deallocate without leaks
-            const frame: Frame = .{ .frameNumber = frame_val.frameNumber, .delay = frame_val.delay, .contents = try allocator.alloc([]u8, frame_val.contents.len), .colorMap = try allocator.alloc([][]i32, frame_val.colorMap.len) };
-
-            for (0..frame.contents.len) |i| {
-                frame.contents[i] = try allocator.dupe(u8, frame_val.contents[i]);
-            }
-
-            // colorMap is stored as an 3d array where:
-            // the outer (i) most array is the horizontal position of the color
-            // the middle (j) is the vertical position of the color
-            // the inner (0/1) is the foreground/background color
-            for (0..frame.colorMap.len) |i| {
-                frame.colorMap[i] = try allocator.alloc([]i32, frame_val.colorMap[i].len);
-                for (0..frame.colorMap[i].len) |j| {
-                    frame.colorMap[i][j] = try allocator.alloc(i32, 2);
-                    frame.colorMap[i][j][0] = frame_val.colorMap[i][j][0];
-                    frame.colorMap[i][j][1] = frame_val.colorMap[i][j][1];
-                }
-            }
-
-            try self.frames.append(allocator, frame);
-        }
-    }
-
-    pub fn create_from_file(self: *DurFormat, allocator: Allocator, io: std.Io, file_path: []const u8) !void {
-        const file_decompressed = try read_decompress_file(allocator, io, file_path);
-        defer allocator.free(file_decompressed);
-
-        const parsed = try Json.parseFromSlice(Json.Value, allocator, file_decompressed, .{});
-        defer parsed.deinit();
-
-        try parse_dur_from_json(self, allocator, parsed.value);
-
-        if (!self.valid()) {
-            return error.NotValidFile;
-        }
-    }
-
-    pub fn init(allocator: Allocator) DurFormat {
-        return .{ .allocator = allocator };
-    }
-
-    pub fn deinit(self: *DurFormat) void {
-        if (self.colorFormat) |str| self.allocator.free(str);
-        if (self.encoding) |str| self.allocator.free(str);
-
-        for (self.frames.items) |frame| {
-            frame.deinit(self.allocator);
-        }
-        self.frames.deinit(self.allocator);
-    }
-};
-
-const tb_color_16 = [16]u32{
-    Color.ECOL_BLACK,
-    Color.ECOL_RED,
-    Color.ECOL_GREEN,
-    Color.ECOL_YELLOW,
-    Color.ECOL_BLUE,
-    Color.ECOL_MAGENTA,
-    Color.ECOL_CYAN,
-    Color.ECOL_WHITE,
-    Color.ECOL_BLACK | Styling.BOLD,
-    Color.ECOL_RED | Styling.BOLD,
-    Color.ECOL_GREEN | Styling.BOLD,
-    Color.ECOL_YELLOW | Styling.BOLD,
-    Color.ECOL_BLUE | Styling.BOLD,
-    Color.ECOL_MAGENTA | Styling.BOLD,
-    Color.ECOL_CYAN | Styling.BOLD,
-    Color.ECOL_WHITE | Styling.BOLD,
-};
-
-// Using bold for bright colors allows for all 16 colors to be rendered on tty term
-const rgb_color_16 = [16]u32{
-    Color.DEFAULT, // DEFAULT instead of TRUE_BLACK to not break compositors (the latter ignores transparency)
-    Color.TRUE_DIM_RED,
-    Color.TRUE_DIM_GREEN,
-    Color.TRUE_DIM_YELLOW,
-    Color.TRUE_DIM_BLUE,
-    Color.TRUE_DIM_MAGENTA,
-    Color.TRUE_DIM_CYAN,
-    Color.TRUE_DIM_WHITE,
-    Color.DEFAULT | Styling.BOLD,
-    Color.TRUE_RED | Styling.BOLD,
-    Color.TRUE_GREEN | Styling.BOLD,
-    Color.TRUE_YELLOW | Styling.BOLD,
-    Color.TRUE_BLUE | Styling.BOLD,
-    Color.TRUE_MAGENTA | Styling.BOLD,
-    Color.TRUE_CYAN | Styling.BOLD,
-    Color.TRUE_WHITE | Styling.BOLD,
-};
-
-// Made this table from looking at colormapping in dur source, not sure whats going on with the mapping logic
-// Array indexes are dur colormappings which value maps to indexes in table above. Only needed for dur 16 color
-const durcolor_table_to_color16 = [17]u32{
-    0, // 0 black
-    0, // 1 nothing?? dur source did not say why 1 is unused
-    4, // 2 blue
-    2, // 3 green
-    6, // 4 cyan
-    1, // 5 red
-    5, // 6 magenta
-    3, // 7 yellow
-    7, // 8 light gray
-    8, // 9 gray
-    12, // 10 bright blue
-    10, // 11 bright green
-    14, // 12 bright cyan
-    9, // 13 bright red
-    13, // 14 bright magenta
-    11, // 15 bright yellow
-    15, // 16 bright white
-};
-
-fn sixcube_to_channel(sixcube: u32) u32 {
-    // Although the range top for the extended range is 0xFF, 6 is not divisible into 0xFF,
-    // so we use 0xF0 instead with a scaler
-    const equal_divisions = 0xF0 / 6;
-
-    // Since the range is to 0xFF but 6 isn't divisible, we must add a scaler to get it to 0xFF at the last index (5)
-    const scaler = 0xFF - (equal_divisions * 5);
-
-    return if (sixcube > 0) (sixcube * equal_divisions) + scaler else 0;
-}
-
-fn convert_256_to_rgb(color_256: u32) u32 {
-    var rgb_color: u32 = 0;
-
-    // 0 - 15 is the standard color range, map to array table
-    if (color_256 < 16) {
-        rgb_color = rgb_color_16[color_256];
-    }
-    // 16 - 231 is the extended range
-    else if (color_256 < 232) {
-
-        // For extended term range we subtract by 16 to get it in a 0..(6x6x6) cube (range of 216)
-        // divide by 36 gets the depth of the cube (6x6x1)
-        // divide by 6 gets the width of the cube (6x1)
-        // divide by 1 gets the height of the cube (divide 1 for clarity for what we are doing)
-        // each channel can be 6 levels of brightness hence remander operation of 6
-        // finally bitshift to correct rgb channel (16 for red, 8 for green, 0 for blue)
-        rgb_color |= sixcube_to_channel(((color_256 - 16) / 36) % 6) << 16;
-        rgb_color |= sixcube_to_channel(((color_256 - 16) / 6) % 6) << 8;
-        rgb_color |= sixcube_to_channel(((color_256 - 16) / 1) % 6);
-    }
-    // 232 - 255 is the grayscale range
-    else {
-
-        // For grayscale we have a space of 232 - 255 (24)
-        // subtract by 232 to get it into the 0..23 range
-        // standard colors will contain white and black, so we do not use them in the grayscale range (0 is 0x08, 23 is 0xEE)
-        // this results in a skip of 0x08 for the first color and divisions of 0x0A
-        // example: term_col 232 = scaler + equal_divisions * (232 - 232) which becomes (scaler + 0x00) == 0x08
-        // example: term_col 255 = scaler + equal_divisions * (255 - 232) which becomes (scaler + 0xE6) == 0xEE
-        const scaler = 0x08;
-
-        // to get equal parts, the equation is:
-        // 0xEE = equal_divisions * 23 + scaler | top of range is 0xEE, 23 is last element value (255 minus 232)
-        // reordered to solve for equal_divisions:
-        const equal_divisions = (0xEE - scaler) / 23; // evals to 0x0A
-
-        const channel = scaler + equal_divisions * (color_256 - 232);
-
-        // gray is equal value of same channel color in rgb
-        rgb_color = channel | (channel << 8) | (channel << 16);
-    }
-
-    return rgb_color;
-}
-
-const UVec2 = @Vector(2, u32);
-const IVec2 = @Vector(2, i64);
-
-const VEC_X = 0;
-const VEC_Y = 1;
-
-const DurFile = @This();
-
-instance: ?Widget = null,
-start_time: TimeOfDay,
-allocator: Allocator,
-io: std.Io,
-terminal_buffer: *TerminalBuffer,
-dur_movie: DurFormat,
-frames: usize,
-frame_size: UVec2,
-start_pos: IVec2,
-full_color: bool,
-animate: *bool,
-timeout_sec: u12,
-frame_delay: u16,
-frame_time: u32,
-time_previous: i64,
-is_color_format_16: bool,
-offset_alignment: DurOffsetAlignment,
-offset: IVec2,
-
-// if the user has an even number of columns or rows, we will default to the left or higher position (e.g. 4 columns center = .x..)
-fn center(v: u32) i64 {
-    return @intCast((v / 2) + (v % 2));
-}
-
-fn calc_start_position(terminal_buffer: *TerminalBuffer, dur_movie: *DurFormat, offset_alignment: DurOffsetAlignment, offset: IVec2) IVec2 {
-    const buf_width: u32 = @intCast(terminal_buffer.width);
-    const buf_height: u32 = @intCast(terminal_buffer.height);
-
-    var movie_width: u32 = @intCast(dur_movie.columns.?);
-    var movie_height: u32 = @intCast(dur_movie.lines.?);
-
-    if (movie_width > buf_width) movie_width = buf_width;
-    if (movie_height > buf_height) movie_height = buf_height;
-
-    const start_pos: IVec2 = switch (offset_alignment) {
-        DurOffsetAlignment.center => .{ center(buf_width) - center(movie_width), center(buf_height) - center(movie_height) },
-        DurOffsetAlignment.topleft => .{ 0, 0 },
-        DurOffsetAlignment.topcenter => .{ center(buf_width) - center(movie_width), 0 },
-        DurOffsetAlignment.topright => .{ buf_width - movie_width, 0 },
-        DurOffsetAlignment.centerleft => .{ 0, center(buf_height) - center(movie_height) },
-        DurOffsetAlignment.centerright => .{ buf_width - movie_width, center(buf_height) - center(movie_height) },
-        DurOffsetAlignment.bottomleft => .{ 0, buf_height - movie_height },
-        DurOffsetAlignment.bottomcenter => .{ center(buf_width) - center(movie_width), buf_height - movie_height },
-        DurOffsetAlignment.bottomright => .{ buf_width - movie_width, buf_height - movie_height },
-    };
-
-    return start_pos + offset;
-}
-
-fn calc_frame_size(terminal_buffer: *TerminalBuffer, dur_movie: *DurFormat) UVec2 {
-    const buf_width: u32 = @intCast(terminal_buffer.width);
-    const buf_height: u32 = @intCast(terminal_buffer.height);
-
-    const movie_width: u32 = @intCast(dur_movie.columns.?);
-    const movie_height: u32 = @intCast(dur_movie.lines.?);
-
-    // Draw only the needed amount if movie smaller than screen. If movie is bigger, we will just draw entire screen
-    const frame_width = if (movie_width < buf_width) movie_width else buf_width;
-    const frame_height = if (movie_height < buf_height) movie_height else buf_height;
-
-    return .{ frame_width, frame_height };
-}
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    terminal_buffer: *TerminalBuffer,
-    log_file: *LogFile,
-    file_path: []const u8,
-    offset_alignment: DurOffsetAlignment,
-    x_offset: i32,
-    y_offset: i32,
-    full_color: bool,
-    animate: *bool,
-    timeout_sec: u12,
-    frame_delay: u16,
-) !DurFile {
-    var dur_movie: DurFormat = .init(allocator);
-
-    dur_movie.create_from_file(allocator, io, file_path) catch |err| switch (err) {
-        error.FileNotFound => {
-            try log_file.err(io, "tui", "dur_file was not found at: {s}", .{file_path});
-            return err;
-        },
-        error.NotValidFile => {
-            try log_file.err(io, "tui", "dur_file loaded was invalid or not a dur file!", .{});
-            return err;
-        },
-        else => return err,
-    };
-
-    // 4 bit mode with 256 color is unsupported
-    if (!full_color and eql(u8, dur_movie.colorFormat.?, "256")) {
-        try log_file.err(io, "tui", "dur_file can not be 256 color encoded when not using full_color option!", .{});
-        dur_movie.deinit();
-        return error.InvalidColorFormat;
-    }
-
-    const offset: IVec2 = .{ x_offset, y_offset };
-
-    const start_pos = calc_start_position(terminal_buffer, &dur_movie, offset_alignment, offset);
-    const frame_size = calc_frame_size(terminal_buffer, &dur_movie);
-
-    // Convert dur fps to frames per ms
-    const frame_time: u32 = @trunc(1000 / dur_movie.framerate.?);
-
-    return .{
-        .instance = null,
-        .start_time = try interop.getTimeOfDay(),
-        .allocator = allocator,
-        .io = io,
-        .terminal_buffer = terminal_buffer,
-        .frames = 0,
-        .time_previous = std.Io.Timestamp.now(io, .real).toMilliseconds(),
-        .frame_size = frame_size,
-        .start_pos = start_pos,
-        .full_color = full_color,
-        .animate = animate,
-        .timeout_sec = timeout_sec,
-        .frame_delay = frame_delay,
-        .dur_movie = dur_movie,
-        .frame_time = frame_time,
-        .is_color_format_16 = eql(u8, dur_movie.colorFormat.?, "16"),
-        .offset_alignment = offset_alignment,
-        .offset = offset,
-    };
-}
-
-pub fn widget(self: *DurFile) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "DurFile",
-        null,
-        self,
-        deinit,
-        realloc,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-fn deinit(self: *DurFile) void {
-    self.dur_movie.deinit();
-}
-
-fn realloc(self: *DurFile) !void {
-    // when terminal size changes, we need to recalculate the start_pos and frame_size based on the new size
-    self.start_pos = calc_start_position(self.terminal_buffer, &self.dur_movie, self.offset_alignment, self.offset);
-    self.frame_size = calc_frame_size(self.terminal_buffer, &self.dur_movie);
-}
-
-fn draw(self: *DurFile) void {
-    if (!self.animate.*) return;
-
-    const current_frame = self.dur_movie.frames.items[self.frames];
-
-    const buf_width: u32 = @intCast(self.terminal_buffer.width);
-    const buf_height: u32 = @intCast(self.terminal_buffer.height);
-
-    // y is used as an iterator in the durformat, while cell_y gives us the correct placement for the cell (same for x)
-    for (0..self.frame_size[VEC_Y]) |y| {
-        const y_offset_i = @as(i32, @intCast(y)) + self.start_pos[VEC_Y];
-        // we skip the pass if it falls outside of the draw window (ensure no int underflow)
-        const cell_y: u32 = if (y_offset_i >= 0 and y_offset_i < buf_height) @intCast(y_offset_i) else continue;
-
-        var iter = std.unicode.Utf8View.initUnchecked(current_frame.contents[y]).iterator();
-
-        for (0..self.frame_size[VEC_X]) |x| {
-            const x_offset_i = @as(i32, @intCast(x)) + self.start_pos[VEC_X];
-            // skip pass, same as y but also increment the codepoint iter to fetch correct values in later passes
-            const cell_x: u32 = if (x_offset_i >= 0 and x_offset_i < buf_width) @intCast(x_offset_i) else {
-                _ = iter.nextCodepoint().?;
-                continue;
-            };
-
-            const codepoint: u21 = iter.nextCodepoint().?;
-            const color_map = current_frame.colorMap[x][y];
-
-            var color_map_0: u32 = @intCast(if (color_map[0] == -1) 0 else color_map[0]);
-            var color_map_1: u32 = @intCast(if (color_map[1] == -1) 0 else color_map[1]);
-
-            if (self.is_color_format_16) {
-                color_map_0 = durcolor_table_to_color16[color_map_0];
-                color_map_1 = durcolor_table_to_color16[color_map_1 + 1]; // Add 1, dur source stores it like this for some reason
-            }
-
-            const fg_color = if (self.full_color) convert_256_to_rgb(color_map_0) else tb_color_16[color_map_0];
-            const bg_color = if (self.full_color) convert_256_to_rgb(color_map_1) else tb_color_16[color_map_1];
-
-            const cell = Cell{ .ch = @intCast(codepoint), .fg = fg_color, .bg = bg_color };
-
-            cell.put(cell_x, cell_y);
-        }
-    }
-
-    const time_current = std.Io.Timestamp.now(self.io, .real).toMilliseconds();
-    const delta_time = time_current - self.time_previous;
-
-    // Convert delay from sec to ms
-    const delay_time: u32 = @trunc(current_frame.delay * 1000);
-    if (delta_time > (self.frame_time + delay_time)) {
-        self.time_previous = time_current;
-
-        const frame_count = self.dur_movie.frames.items.len;
-        self.frames = (self.frames + 1) % frame_count;
-    }
-}
-
-fn update(self: *DurFile, _: *anyopaque) !void {
-    const time = try interop.getTimeOfDay();
-
-    if (self.timeout_sec > 0 and time.seconds - self.start_time.seconds > self.timeout_sec) {
-        self.animate.* = false;
-    }
-}
-
-fn calculateTimeout(self: *DurFile, _: *anyopaque) !?usize {
-    return self.frame_delay;
-}

src/animations/GameOfLife.zig

@@ -1,240 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ly_ui = @import("ly-ui");
-const Cell = ly_ui.Cell;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-
-const ly_core = ly_ui.ly_core;
-const interop = ly_core.interop;
-const TimeOfDay = interop.TimeOfDay;
-
-const GameOfLife = @This();
-
-// Visual styles - using block characters like other animations
-const ALIVE_CHAR: u21 = 0x2588; // Full block █
-const DEAD_CHAR: u21 = ' ';
-const NEIGHBOR_DIRS = [_][2]i8{
-    .{ -1, -1 }, .{ -1, 0 }, .{ -1, 1 },
-    .{ 0, -1 },  .{ 0, 1 },  .{ 1, -1 },
-    .{ 1, 0 },   .{ 1, 1 },
-};
-
-instance: ?Widget = null,
-start_time: TimeOfDay,
-allocator: Allocator,
-terminal_buffer: *TerminalBuffer,
-current_grid: []bool,
-next_grid: []bool,
-frame_counter: usize,
-generation: u64,
-fg_color: u32,
-entropy_interval: usize,
-frame_delay: usize,
-initial_density: f32,
-animate: *bool,
-timeout_sec: u12,
-animation_frame_delay: u16,
-dead_cell: Cell,
-width: usize,
-height: usize,
-
-pub fn init(
-    allocator: Allocator,
-    terminal_buffer: *TerminalBuffer,
-    fg_color: u32,
-    entropy_interval: usize,
-    frame_delay: usize,
-    initial_density: f32,
-    animate: *bool,
-    timeout_sec: u12,
-    animation_frame_delay: u16,
-) !GameOfLife {
-    const width = terminal_buffer.width;
-    const height = terminal_buffer.height;
-    const grid_size = width * height;
-
-    const current_grid = try allocator.alloc(bool, grid_size);
-    const next_grid = try allocator.alloc(bool, grid_size);
-
-    var game = GameOfLife{
-        .instance = null,
-        .start_time = try interop.getTimeOfDay(),
-        .allocator = allocator,
-        .terminal_buffer = terminal_buffer,
-        .current_grid = current_grid,
-        .next_grid = next_grid,
-        .frame_counter = 0,
-        .generation = 0,
-        .fg_color = fg_color,
-        .entropy_interval = entropy_interval,
-        .frame_delay = frame_delay,
-        .initial_density = initial_density,
-        .animate = animate,
-        .timeout_sec = timeout_sec,
-        .animation_frame_delay = animation_frame_delay,
-        .dead_cell = .{ .ch = DEAD_CHAR, .fg = @intCast(TerminalBuffer.Color.DEFAULT), .bg = terminal_buffer.bg },
-        .width = width,
-        .height = height,
-    };
-
-    // Initialize grid
-    game.initializeGrid();
-
-    return game;
-}
-
-pub fn widget(self: *GameOfLife) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "GameOfLife",
-        null,
-        self,
-        deinit,
-        realloc,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-fn deinit(self: *GameOfLife) void {
-    self.allocator.free(self.current_grid);
-    self.allocator.free(self.next_grid);
-}
-
-fn realloc(self: *GameOfLife) !void {
-    const new_width = self.terminal_buffer.width;
-    const new_height = self.terminal_buffer.height;
-    const new_size = new_width * new_height;
-
-    const current_grid = try self.allocator.realloc(self.current_grid, new_size);
-    const next_grid = try self.allocator.realloc(self.next_grid, new_size);
-
-    self.current_grid = current_grid;
-    self.next_grid = next_grid;
-    self.width = new_width;
-    self.height = new_height;
-
-    self.initializeGrid();
-    self.generation = 0;
-}
-
-fn draw(self: *GameOfLife) void {
-    if (!self.animate.*) return;
-
-    // Update game state at controlled frame rate
-    self.frame_counter += 1;
-    if (self.frame_counter >= self.frame_delay) {
-        self.frame_counter = 0;
-        self.updateGeneration();
-        self.generation += 1;
-
-        // Add entropy based on configuration (0 = disabled, >0 = interval)
-        if (self.entropy_interval > 0 and self.generation % self.entropy_interval == 0) {
-            self.addEntropy();
-        }
-    }
-
-    // Render with the configured color
-    const alive_cell = Cell{ .ch = ALIVE_CHAR, .fg = self.fg_color, .bg = self.terminal_buffer.bg };
-
-    for (0..self.height) |y| {
-        const row_offset = y * self.width;
-        for (0..self.width) |x| {
-            const cell = if (self.current_grid[row_offset + x]) alive_cell else self.dead_cell;
-            cell.put(x, y);
-        }
-    }
-}
-
-fn update(self: *GameOfLife, _: *anyopaque) !void {
-    const time = try interop.getTimeOfDay();
-
-    if (self.timeout_sec > 0 and time.seconds - self.start_time.seconds > self.timeout_sec) {
-        self.animate.* = false;
-    }
-}
-
-fn calculateTimeout(self: *GameOfLife, _: *anyopaque) !?usize {
-    return self.animation_frame_delay;
-}
-
-fn updateGeneration(self: *GameOfLife) void {
-    // Conway's Game of Life rules with optimized neighbor counting
-    for (0..self.height) |y| {
-        const row_offset = y * self.width;
-        for (0..self.width) |x| {
-            const index = row_offset + x;
-            const neighbors = self.countNeighborsOptimized(x, y);
-            const is_alive = self.current_grid[index];
-
-            // Optimized rule application
-            self.next_grid[index] = switch (neighbors) {
-                2 => is_alive,
-                3 => true,
-                else => false,
-            };
-        }
-    }
-
-    // Efficient grid swap
-    std.mem.swap([]bool, &self.current_grid, &self.next_grid);
-}
-
-fn countNeighborsOptimized(self: *GameOfLife, x: usize, y: usize) u8 {
-    var count: u8 = 0;
-
-    for (NEIGHBOR_DIRS) |dir| {
-        const neighbor_x = @as(i32, @intCast(x)) + dir[0];
-        const neighbor_y = @as(i32, @intCast(y)) + dir[1];
-        const width_i32: i32 = @intCast(self.width);
-        const height_i32: i32 = @intCast(self.height);
-
-        // Toroidal wrapping with modular arithmetic
-        const wx: usize = @intCast(@mod(neighbor_x + width_i32, width_i32));
-        const wy: usize = @intCast(@mod(neighbor_y + height_i32, height_i32));
-
-        if (self.current_grid[wy * self.width + wx]) {
-            count += 1;
-        }
-    }
-
-    return count;
-}
-
-fn initializeGrid(self: *GameOfLife) void {
-    const total_cells = self.width * self.height;
-
-    // Clear grid
-    @memset(self.current_grid, false);
-    @memset(self.next_grid, false);
-
-    // Random initialization with configurable density
-    for (0..total_cells) |i| {
-        self.current_grid[i] = self.terminal_buffer.random.float(f32) < self.initial_density;
-    }
-}
-
-fn addEntropy(self: *GameOfLife) void {
-    // Add fewer random cells but in clusters for more interesting patterns
-    const clusters = 2;
-    for (0..clusters) |_| {
-        const cx = self.terminal_buffer.random.intRangeAtMost(usize, 1, self.width - 2);
-        const cy = self.terminal_buffer.random.intRangeAtMost(usize, 1, self.height - 2);
-
-        // Small cluster around center point
-        for (0..3) |dy| {
-            for (0..3) |dx| {
-                if (self.terminal_buffer.random.float(f32) < 0.4) {
-                    const x = (cx + dx) % self.width;
-                    const y = (cy + dy) % self.height;
-                    self.current_grid[y * self.width + x] = true;
-                }
-            }
-        }
-    }
-}

src/animations/Matrix.zig

@@ -1,17 +1,16 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const Random = std.Random;
+const Random = std.rand.Random;
+const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
 
-const ly_ui = @import("ly-ui");
+const interop = @import("../interop.zig");
-const Cell = ly_ui.Cell;
+const termbox = interop.termbox;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
 
-const ly_core = ly_ui.ly_core;
+pub const FRAME_DELAY: u64 = 8;
-const interop = ly_core.interop;
-const TimeOfDay = interop.TimeOfDay;
 
-pub const FRAME_DELAY: usize = 8;
+// Allowed codepoints
+pub const MIN_CODEPOINT: isize = 33;
+pub const MAX_CODEPOINT: isize = 123 - MIN_CODEPOINT;
 
 // Characters change mid-scroll
 pub const MID_SCROLL_CHANGE = true;
@@ -19,91 +18,47 @@ pub const MID_SCROLL_CHANGE = true;
 const Matrix = @This();
 
 pub const Dot = struct {
-    value: ?usize,
+    value: isize,
     is_head: bool,
 };
 
 pub const Line = struct {
-    space: usize,
+    space: isize,
-    length: usize,
+    length: isize,
-    update: usize,
+    update: isize,
 };
 
-instance: ?Widget = null,
-start_time: TimeOfDay,
 allocator: Allocator,
 terminal_buffer: *TerminalBuffer,
 dots: []Dot,
 lines: []Line,
-frame: usize,
+frame: u64,
-count: usize,
+count: u64,
-fg: u32,
+fg_ini: u16,
-head_col: u32,
-min_codepoint: u16,
-max_codepoint: u16,
-animate: *bool,
-timeout_sec: u12,
-frame_delay: u16,
-default_cell: Cell,
 
-pub fn init(
+pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer, fg_ini: u16) !Matrix {
-    allocator: Allocator,
-    terminal_buffer: *TerminalBuffer,
-    fg: u32,
-    head_col: u32,
-    min_codepoint: u16,
-    max_codepoint: u16,
-    animate: *bool,
-    timeout_sec: u12,
-    frame_delay: u16,
-) !Matrix {
     const dots = try allocator.alloc(Dot, terminal_buffer.width * (terminal_buffer.height + 1));
     const lines = try allocator.alloc(Line, terminal_buffer.width);
 
     initBuffers(dots, lines, terminal_buffer.width, terminal_buffer.height, terminal_buffer.random);
 
     return .{
-        .instance = null,
-        .start_time = try interop.getTimeOfDay(),
         .allocator = allocator,
         .terminal_buffer = terminal_buffer,
         .dots = dots,
         .lines = lines,
         .frame = 3,
         .count = 0,
-        .fg = fg,
+        .fg_ini = fg_ini,
-        .head_col = head_col,
-        .min_codepoint = min_codepoint,
-        .max_codepoint = max_codepoint - min_codepoint,
-        .animate = animate,
-        .timeout_sec = timeout_sec,
-        .frame_delay = frame_delay,
-        .default_cell = .{ .ch = ' ', .fg = fg, .bg = terminal_buffer.bg },
     };
 }
 
-pub fn widget(self: *Matrix) *Widget {
+pub fn deinit(self: Matrix) void {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Matrix",
-        null,
-        self,
-        deinit,
-        realloc,
-        draw,
-        update,
-        null,
-        calculateTimeout,
-    );
-    return &self.instance.?;
-}
-
-fn deinit(self: *Matrix) void {
     self.allocator.free(self.dots);
     self.allocator.free(self.lines);
 }
 
-fn realloc(self: *Matrix) !void {
+pub fn realloc(self: *Matrix) !void {
     const dots = try self.allocator.realloc(self.dots, self.terminal_buffer.width * (self.terminal_buffer.height + 1));
     const lines = try self.allocator.realloc(self.lines, self.terminal_buffer.width);
 
@@ -113,9 +68,7 @@ fn realloc(self: *Matrix) !void {
     self.lines = lines;
 }
 
-fn draw(self: *Matrix) void {
+pub fn draw(self: *Matrix) void {
-    if (!self.animate.*) return;
-
     const buf_height = self.terminal_buffer.height;
     const buf_width = self.terminal_buffer.width;
     self.count += 1;
@@ -125,19 +78,19 @@ fn draw(self: *Matrix) void {
         self.count = 0;
 
         var x: usize = 0;
-        while (x < buf_width) : (x += 2) {
+        while (x < self.terminal_buffer.width) : (x += 2) {
             var tail: usize = 0;
             var line = &self.lines[x];
             if (self.frame <= line.update) continue;
 
-            if (self.dots[x].value == null and self.dots[buf_width + x].value == ' ') {
+            if (self.dots[x].value == -1 and self.dots[self.terminal_buffer.width + x].value == ' ') {
                 if (line.space > 0) {
                     line.space -= 1;
                 } else {
-                    const randint = self.terminal_buffer.random.int(u16);
+                    const randint = self.terminal_buffer.random.int(i16);
-                    const h = buf_height;
+                    const h: isize = @intCast(self.terminal_buffer.height);
                     line.length = @mod(randint, h - 3) + 3;
-                    self.dots[x].value = @mod(randint, self.max_codepoint) + self.min_codepoint;
+                    self.dots[x].value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                     line.space = @mod(randint, h + 1);
                 }
             }
@@ -148,7 +101,7 @@ fn draw(self: *Matrix) void {
             height_it: while (y <= buf_height) : (y += 1) {
                 var dot = &self.dots[buf_width * y + x];
                 // Skip over spaces
-                while (y <= buf_height and (dot.value == ' ' or dot.value == null)) {
+                while (y <= buf_height and (dot.value == ' ' or dot.value == -1)) {
                     y += 1;
                     if (y > buf_height) break :height_it;
                     dot = &self.dots[buf_width * y + x];
@@ -157,12 +110,12 @@ fn draw(self: *Matrix) void {
                 // Find the head of this column
                 tail = y;
                 seg_len = 0;
-                while (y <= buf_height and dot.value != ' ' and dot.value != null) {
+                while (y <= buf_height and dot.value != ' ' and dot.value != -1) {
                     dot.is_head = false;
                     if (MID_SCROLL_CHANGE) {
-                        const randint = self.terminal_buffer.random.int(u16);
+                        const randint = self.terminal_buffer.random.int(i16);
                         if (@mod(randint, 8) == 0) {
-                            dot.value = @mod(randint, self.max_codepoint) + self.min_codepoint;
+                            dot.value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                         }
                     }
 
@@ -176,13 +129,13 @@ fn draw(self: *Matrix) void {
                     dot = &self.dots[buf_width * y + x];
                 }
 
-                const randint = self.terminal_buffer.random.int(u16);
+                const randint = self.terminal_buffer.random.int(i16);
-                dot.value = @mod(randint, self.max_codepoint) + self.min_codepoint;
+                dot.value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                 dot.is_head = true;
 
                 if (seg_len > line.length or !first_col) {
                     self.dots[buf_width * tail + x].value = ' ';
-                    self.dots[x].value = null;
+                    self.dots[x].value = -1;
                 }
                 first_col = false;
             }
@@ -192,48 +145,38 @@ fn draw(self: *Matrix) void {
     var x: usize = 0;
     while (x < buf_width) : (x += 2) {
         var y: usize = 1;
-        while (y <= buf_height) : (y += 1) {
+        while (y <= self.terminal_buffer.height) : (y += 1) {
             const dot = self.dots[buf_width * y + x];
-            const cell = if (dot.value == null or dot.value == ' ') self.default_cell else Cell{
-                .ch = @intCast(dot.value.?),
-                .fg = if (dot.is_head) self.head_col else self.fg,
-                .bg = self.terminal_buffer.bg,
-            };
 
-            cell.put(x, y - 1);
+            var fg = self.fg_ini;
-            // Fill background in between columns
+
-            self.default_cell.put(x + 1, y - 1);
+            if (dot.value == -1 or dot.value == ' ') {
+                _ = termbox.tb_set_cell(@intCast(x), @intCast(y - 1), ' ', fg, termbox.TB_DEFAULT);
+                continue;
+            }
+
+            if (dot.is_head) fg = @intCast(termbox.TB_WHITE | termbox.TB_BOLD);
+            _ = termbox.tb_set_cell(@intCast(x), @intCast(y - 1), @intCast(dot.value), fg, termbox.TB_DEFAULT);
         }
     }
 }
 
-fn update(self: *Matrix, _: *anyopaque) !void {
-    const time = try interop.getTimeOfDay();
-
-    if (self.timeout_sec > 0 and time.seconds - self.start_time.seconds > self.timeout_sec) {
-        self.animate.* = false;
-    }
-}
-
-fn calculateTimeout(self: *Matrix, _: *anyopaque) !?usize {
-    return self.frame_delay;
-}
-
 fn initBuffers(dots: []Dot, lines: []Line, width: usize, height: usize, random: Random) void {
     var y: usize = 0;
     while (y <= height) : (y += 1) {
         var x: usize = 0;
         while (x < width) : (x += 2) {
-            dots[y * width + x].value = null;
+            dots[y * width + x].value = -1;
         }
     }
 
     var x: usize = 0;
     while (x < width) : (x += 2) {
         var line = lines[x];
-        line.space = @mod(random.int(u16), height) + 1;
+        const h: isize = @intCast(height);
-        line.length = @mod(random.int(u16), height - 3) + 3;
+        line.space = @mod(random.int(i16), h) + 1;
-        line.update = @mod(random.int(u16), 3) + 1;
+        line.length = @mod(random.int(i16), h - 3) + 3;
+        line.update = @mod(random.int(i16), 3) + 1;
         lines[x] = line;
 
         dots[width + x].value = ' ';

src/auth.zig

@@ -1,61 +1,41 @@
 const std = @import("std");
-const Md5 = std.crypto.hash.Md5;
-const builtin = @import("builtin");
 const build_options = @import("build_options");
-
+const builtin = @import("builtin");
-const ly_core = @import("ly-ui").ly_core;
+const enums = @import("enums.zig");
-const interop = ly_core.interop;
+const interop = @import("interop.zig");
-const SharedError = ly_core.SharedError;
+const TerminalBuffer = @import("tui/TerminalBuffer.zig");
-const LogFile = ly_core.LogFile;
+const Session = @import("tui/components/Session.zig");
+const Text = @import("tui/components/Text.zig");
+const Config = @import("config/Config.zig");
+const Allocator = std.mem.Allocator;
+const Md5 = std.crypto.hash.Md5;
 const utmp = interop.utmp;
 const Utmp = utmp.utmpx;
-
+const SharedError = @import("SharedError.zig");
-const Environment = @import("Environment.zig");
-
-pub const AuthOptions = struct {
-    tty: u8,
-    service_name: [:0]const u8,
-    path: ?[]const u8,
-    session_log: ?[]const u8,
-    xauth_cmd: []const u8,
-    setup_cmd: []const u8,
-    login_cmd: ?[]const u8,
-    x_cmd: []const u8,
-    x_vt: ?u8,
-    session_pid: std.posix.pid_t,
-    use_kmscon_vt: bool,
-};
 
 var xorg_pid: std.posix.pid_t = 0;
-pub fn xorgSignalHandler(sig: std.posix.SIG) callconv(.c) void {
+pub fn xorgSignalHandler(i: c_int) callconv(.C) void {
-    if (xorg_pid > 0) _ = std.c.kill(xorg_pid, sig);
+    if (xorg_pid > 0) _ = std.c.kill(xorg_pid, i);
 }
 
 var child_pid: std.posix.pid_t = 0;
-pub fn sessionSignalHandler(sig: std.posix.SIG) callconv(.c) void {
+pub fn sessionSignalHandler(i: c_int) callconv(.C) void {
-    if (child_pid > 0) _ = std.c.kill(child_pid, sig);
+    if (child_pid > 0) _ = std.c.kill(child_pid, i);
 }
 
-pub fn authenticate(allocator: std.mem.Allocator, io: std.Io, log_file: *LogFile, options: AuthOptions, current_environment: Environment, login: []const u8, password: []const u8) !void {
+pub fn authenticate(config: Config, current_environment: Session.Environment, login: [:0]const u8, password: [:0]const u8) !void {
     var tty_buffer: [3]u8 = undefined;
-    const tty_str = try std.fmt.bufPrint(&tty_buffer, "{d}", .{options.tty});
+    const tty_str = try std.fmt.bufPrintZ(&tty_buffer, "{d}", .{config.tty});
 
     var pam_tty_buffer: [6]u8 = undefined;
-    const pam_tty_str = try std.fmt.bufPrintZ(&pam_tty_buffer, "tty{d}", .{options.tty});
+    const pam_tty_str = try std.fmt.bufPrintZ(&pam_tty_buffer, "tty{d}", .{config.tty});
 
     // Set the XDG environment variables
-    try log_file.info(io, "auth/env", "setting xdg environment variables", .{});
+    setXdgSessionEnv(current_environment.display_server);
-    try setXdgEnv(allocator, tty_str, current_environment);
+    try setXdgEnv(tty_str, current_environment.xdg_session_desktop orelse "", current_environment.xdg_desktop_names orelse "");
 
     // Open the PAM session
-    try log_file.info(io, "auth/pam", "encoding credentials", .{});
+    var credentials = [_:null]?[*:0]const u8{ login, password };
-    const login_z = try allocator.dupeZ(u8, login);
-    defer allocator.free(login_z);
-
-    const password_z = try allocator.dupeZ(u8, password);
-    defer allocator.free(password_z);
-
-    var credentials = [_:null]?[*:0]const u8{ login_z, password_z };
 
     const conv = interop.pam.pam_conv{
         .conv = loginConv,
@@ -63,66 +43,53 @@ pub fn authenticate(allocator: std.mem.Allocator, io: std.Io, log_file: *LogFile
     };
     var handle: ?*interop.pam.pam_handle = undefined;
 
-    try log_file.info(io, "auth/pam", "starting session", .{});
+    var status = interop.pam.pam_start(config.service_name, null, &conv, &handle);
-    var status = interop.pam.pam_start(options.service_name, null, &conv, &handle);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
     defer _ = interop.pam.pam_end(handle, status);
 
     // Set PAM_TTY as the current TTY. This is required in case it isn't being set by another PAM module
-    try log_file.info(io, "auth/pam", "setting tty", .{});
     status = interop.pam.pam_set_item(handle, interop.pam.PAM_TTY, pam_tty_str.ptr);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
 
     // Do the PAM routine
-    try log_file.info(io, "auth/pam", "authenticating", .{});
     status = interop.pam.pam_authenticate(handle, 0);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
 
-    try log_file.info(io, "auth/pam", "validating account", .{});
     status = interop.pam.pam_acct_mgmt(handle, 0);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
 
-    try log_file.info(io, "auth/pam", "setting credentials", .{});
     status = interop.pam.pam_setcred(handle, interop.pam.PAM_ESTABLISH_CRED);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
     defer status = interop.pam.pam_setcred(handle, interop.pam.PAM_DELETE_CRED);
 
-    try log_file.info(io, "auth/pam", "opening session", .{});
     status = interop.pam.pam_open_session(handle, 0);
     if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
     defer status = interop.pam.pam_close_session(handle, 0);
 
-    try log_file.info(io, "auth/passwd", "getting struct", .{});
+    var pwd: *interop.pwd.passwd = undefined;
-    var user_entry: interop.UsernameEntry = undefined;
     {
-        defer interop.closePasswordDatabase();
+        defer interop.pwd.endpwent();
 
         // Get password structure from username
-        user_entry = interop.getUsernameEntry(login_z) orelse return error.GetPasswordNameFailed;
+        pwd = interop.pwd.getpwnam(login) orelse return error.GetPasswordNameFailed;
     }
 
     // Set user shell if it hasn't already been set
-    try log_file.info(io, "auth/passwd", "setting user shell", .{});
+    if (pwd.pw_shell == null) {
-    if (user_entry.shell == null) interop.setUserShell(&user_entry);
+        interop.unistd.setusershell();
+        pwd.pw_shell = interop.unistd.getusershell();
+        interop.unistd.endusershell();
+    }
 
-    var shared_err = try SharedError.init(null, null);
+    var shared_err = try SharedError.init();
     defer shared_err.deinit();
 
-    log_file.deinit(io);
+    child_pid = try std.posix.fork();
-
-    child_pid = std.posix.system.fork();
     if (child_pid == 0) {
-        try log_file.reinit(io);
+        startSession(config, pwd, handle, current_environment) catch |e| {
-        try log_file.info(io, "auth/sys", "starting session", .{});
-
-        startSession(log_file, allocator, io, options, tty_str, user_entry, handle, current_environment) catch |e| {
             shared_err.writeError(e);
-
-            log_file.deinit(io);
             std.process.exit(1);
         };
-
-        log_file.deinit(io);
         std.process.exit(0);
     }
 
@@ -131,134 +98,115 @@ pub fn authenticate(allocator: std.mem.Allocator, io: std.Io, log_file: *LogFile
     {
         // If an error occurs here, we can send SIGTERM to the session
         errdefer cleanup: {
-            std.posix.kill(child_pid, std.posix.SIG.TERM) catch break :cleanup;
+            _ = std.posix.kill(child_pid, std.posix.SIG.TERM) catch break :cleanup;
-            var child_status: c_int = undefined;
+            _ = std.posix.waitpid(child_pid, 0);
-            _ = std.posix.system.waitpid(child_pid, &child_status, 0);
         }
 
         // If we receive SIGTERM, forward it to child_pid
         const act = std.posix.Sigaction{
             .handler = .{ .handler = &sessionSignalHandler },
-            .mask = std.posix.sigemptyset(),
+            .mask = std.posix.empty_sigset,
             .flags = 0,
         };
-        std.posix.sigaction(std.posix.SIG.TERM, &act, null);
+        try std.posix.sigaction(std.posix.SIG.TERM, &act, null);
 
-        try addUtmpEntry(io, &entry, user_entry.username.?, child_pid);
+        try addUtmpEntry(&entry, pwd.pw_name.?, child_pid);
     }
     // Wait for the session to stop
-    var child_status: c_int = undefined;
+    _ = std.posix.waitpid(child_pid, 0);
-    _ = std.posix.system.waitpid(child_pid, &child_status, 0);
 
-    try log_file.reinit(io);
-
-    try log_file.info(io, "auth/utmp", "removing utmp entry", .{});
     removeUtmpEntry(&entry);
 
     if (shared_err.readError()) |err| return err;
 }
 
 fn startSession(
-    log_file: *LogFile,
+    config: Config,
-    allocator: std.mem.Allocator,
+    pwd: *interop.pwd.passwd,
-    io: std.Io,
-    options: AuthOptions,
-    tty_str: []u8,
-    user_entry: interop.UsernameEntry,
     handle: ?*interop.pam.pam_handle,
-    current_environment: Environment,
+    current_environment: Session.Environment,
 ) !void {
-    // Set the user's GID & PID
+    if (builtin.os.tag == .freebsd) {
-    try log_file.info(io, "auth/passwd", "setting user context", .{});
+        // FreeBSD has initgroups() in unistd
-    try interop.setUserContext(allocator, user_entry);
+        const status = interop.unistd.initgroups(pwd.pw_name, pwd.pw_gid);
+        if (status != 0) return error.GroupInitializationFailed;
+
+        // FreeBSD sets the GID and UID with setusercontext()
+        const result = interop.pwd.setusercontext(null, pwd, pwd.pw_uid, interop.pwd.LOGIN_SETALL);
+        if (result != 0) return error.SetUserUidFailed;
+    } else {
+        const status = interop.grp.initgroups(pwd.pw_name, pwd.pw_gid);
+        if (status != 0) return error.GroupInitializationFailed;
+
+        std.posix.setgid(pwd.pw_gid) catch return error.SetUserGidFailed;
+        std.posix.setuid(pwd.pw_uid) catch return error.SetUserUidFailed;
+    }
 
     // Set up the environment
-    try log_file.info(io, "auth/env", "setting environment variables", .{});
+    try initEnv(pwd, config.path);
-    try initEnv(allocator, user_entry, options.path);
-
-    // Reset the XDG environment variables
-    try log_file.info(io, "auth/env", "resetting xdg environment variables", .{});
-    try setXdgEnv(allocator, tty_str, current_environment);
-    try setXdgRuntimeDir(allocator);
 
     // Set the PAM variables
     const pam_env_vars: ?[*:null]?[*:0]u8 = interop.pam.pam_getenvlist(handle);
     if (pam_env_vars == null) return error.GetEnvListFailed;
 
     const env_list = std.mem.span(pam_env_vars.?);
-    for (env_list) |env_var| {
+    for (env_list) |env_var| _ = interop.stdlib.putenv(env_var);
-        if (env_var == null) continue;
-        try log_file.info(io, "auth/env", "setting pam environment variable: {s}", .{std.mem.span(env_var.?)});
-        try interop.putEnvironmentVariable(env_var);
-    }
-
-    const home_z = try allocator.dupeZ(u8, user_entry.home.?);
-    defer allocator.free(home_z);
 
     // Change to the user's home directory
-    try log_file.info(io, "auth/sys", "changing cwd to user home", .{});
+    std.posix.chdirZ(pwd.pw_dir.?) catch return error.ChangeDirectoryFailed;
-    if (std.posix.system.chdir(home_z.ptr) < 0) return error.ChangeDirectoryFailed;
-
-    // Signal to the session process to give up control on the TTY
-    try log_file.info(io, "auth/sys", "releasing tty", .{});
-    std.posix.kill(options.session_pid, std.posix.SIG.INT) catch return error.TtyControlTransferFailed;
 
     // Execute what the user requested
     switch (current_environment.display_server) {
-        .wayland, .shell, .custom => try executeCmd(log_file, allocator, io, user_entry.shell.?, options, current_environment.is_terminal, current_environment.cmd),
+        .wayland => try executeWaylandCmd(pwd.pw_shell.?, config, current_environment.cmd),
+        .shell => try executeShellCmd(pwd.pw_shell.?, config),
         .xinitrc, .x11 => if (build_options.enable_x11_support) {
             var vt_buf: [5]u8 = undefined;
-            const vt = try std.fmt.bufPrint(&vt_buf, "vt{d}", .{options.x_vt orelse options.tty});
+            const vt = try std.fmt.bufPrint(&vt_buf, "vt{d}", .{config.tty});
-
+            try executeX11Cmd(pwd.pw_shell.?, pwd.pw_dir.?, config, current_environment.cmd, vt);
-            try log_file.info(io, "auth/x11", "setting vt to {s}", .{vt});
-            try executeX11Cmd(log_file, allocator, io, user_entry.shell.?, user_entry.home.?, options, current_environment.cmd orelse "", vt);
         },
     }
 }
 
-fn initEnv(allocator: std.mem.Allocator, entry: interop.UsernameEntry, path_env: ?[]const u8) !void {
+fn initEnv(pwd: *interop.pwd.passwd, path_env: ?[:0]const u8) !void {
-    if (entry.home) |home| {
+    _ = interop.stdlib.setenv("HOME", pwd.pw_dir, 1);
-        try interop.setEnvironmentVariable(allocator, "HOME", home, true);
+    _ = interop.stdlib.setenv("PWD", pwd.pw_dir, 1);
-        try interop.setEnvironmentVariable(allocator, "PWD", home, true);
+    _ = interop.stdlib.setenv("SHELL", pwd.pw_shell, 1);
-    } else return error.NoHomeDirectory;
+    _ = interop.stdlib.setenv("USER", pwd.pw_name, 1);
-
+    _ = interop.stdlib.setenv("LOGNAME", pwd.pw_name, 1);
-    try interop.setEnvironmentVariable(allocator, "SHELL", entry.shell.?, true);
-    try interop.setEnvironmentVariable(allocator, "USER", entry.username.?, true);
-    try interop.setEnvironmentVariable(allocator, "LOGNAME", entry.username.?, true);
 
     if (path_env) |path| {
-        interop.setEnvironmentVariable(allocator, "PATH", path, true) catch return error.SetPathFailed;
+        const status = interop.stdlib.setenv("PATH", path, 1);
+        if (status != 0) return error.SetPathFailed;
     }
 }
 
-fn setXdgEnv(allocator: std.mem.Allocator, tty_str: []u8, environment: Environment) !void {
+fn setXdgSessionEnv(display_server: enums.DisplayServer) void {
-    try interop.setEnvironmentVariable(allocator, "XDG_SESSION_TYPE", switch (environment.display_server) {
+    _ = interop.stdlib.setenv("XDG_SESSION_TYPE", switch (display_server) {
         .wayland => "wayland",
         .shell => "tty",
         .xinitrc, .x11 => "x11",
-        .custom => if (environment.is_terminal) "tty" else "unspecified",
+    }, 0);
-    }, false);
-
-    if (environment.xdg_desktop_names) |xdg_desktop_names| try interop.setEnvironmentVariable(allocator, "XDG_CURRENT_DESKTOP", xdg_desktop_names, false);
-    try interop.setEnvironmentVariable(allocator, "XDG_SESSION_CLASS", "user", false);
-    try interop.setEnvironmentVariable(allocator, "XDG_SESSION_ID", "1", false);
-    if (environment.xdg_session_desktop) |desktop_name| try interop.setEnvironmentVariable(allocator, "XDG_SESSION_DESKTOP", desktop_name, false);
-    try interop.setEnvironmentVariable(allocator, "XDG_SEAT", "seat0", false);
-    try interop.setEnvironmentVariable(allocator, "XDG_VTNR", tty_str, false);
 }
 
-fn setXdgRuntimeDir(allocator: std.mem.Allocator) !void {
+fn setXdgEnv(tty_str: [:0]u8, desktop_name: [:0]const u8, xdg_desktop_names: [:0]const u8) !void {
     // The "/run/user/%d" directory is not available on FreeBSD. It is much
     // better to stick to the defaults and let applications using
     // XDG_RUNTIME_DIR to fall back to directories inside user's home
     // directory.
     if (builtin.os.tag != .freebsd) {
-        const uid = std.posix.system.getuid();
+        const uid = interop.unistd.getuid();
-        var uid_buffer: [32]u8 = undefined; // No UID can be larger than this
+        var uid_buffer: [10 + @sizeOf(u32) + 1]u8 = undefined;
-        const uid_str = try std.fmt.bufPrint(&uid_buffer, "/run/user/{d}", .{uid});
+        const uid_str = try std.fmt.bufPrintZ(&uid_buffer, "/run/user/{d}", .{uid});
 
-        try interop.setEnvironmentVariable(allocator, "XDG_RUNTIME_DIR", uid_str, false);
+        _ = interop.stdlib.setenv("XDG_RUNTIME_DIR", uid_str, 0);
     }
+
+    _ = interop.stdlib.setenv("XDG_CURRENT_DESKTOP", xdg_desktop_names, 0);
+    _ = interop.stdlib.setenv("XDG_SESSION_CLASS", "user", 0);
+    _ = interop.stdlib.setenv("XDG_SESSION_ID", "1", 0);
+    _ = interop.stdlib.setenv("XDG_SESSION_DESKTOP", desktop_name, 0);
+    _ = interop.stdlib.setenv("XDG_SEAT", "seat0", 0);
+    _ = interop.stdlib.setenv("XDG_VTNR", tty_str, 0);
 }
 
 fn loginConv(
@@ -266,7 +214,7 @@ fn loginConv(
     msg: ?[*]?*const interop.pam.pam_message,
     resp: ?*?[*]interop.pam.pam_response,
     appdata_ptr: ?*anyopaque,
-) callconv(.c) c_int {
+) callconv(.C) c_int {
     const message_count: u32 = @intCast(num_msg);
     const messages = msg.?;
 
@@ -310,8 +258,8 @@ fn loginConv(
     if (status != interop.pam.PAM_SUCCESS) {
         // Memory is freed by pam otherwise
         allocator.free(response);
-        if (username) |str| allocator.free(str);
+        if (username != null) allocator.free(username.?);
-        if (password) |str| allocator.free(str);
+        if (password != null) allocator.free(password.?);
     } else {
         resp.?.* = response.ptr;
     }
@@ -323,64 +271,60 @@ fn getFreeDisplay() !u8 {
     var buf: [15]u8 = undefined;
     var i: u8 = 0;
     while (i < 200) : (i += 1) {
-        const xlock = try std.fmt.bufPrintZ(&buf, "/tmp/.X{d}-lock", .{i});
+        const xlock = try std.fmt.bufPrint(&buf, "/tmp/.X{d}-lock", .{i});
-        if (interop.isError(std.posix.system.access(xlock.ptr, std.posix.F_OK))) break;
+        std.posix.access(xlock, std.posix.F_OK) catch break;
     }
     return i;
 }
 
-fn getXPid(io: std.Io, display_num: u8) !i32 {
+fn getXPid(display_num: u8) !i32 {
     var buf: [15]u8 = undefined;
     const file_name = try std.fmt.bufPrint(&buf, "/tmp/.X{d}-lock", .{display_num});
-    const file = try std.Io.Dir.openFileAbsolute(io, file_name, .{});
+    const file = try std.fs.openFileAbsolute(file_name, .{});
-    defer file.close(io);
+    defer file.close();
 
-    var file_buffer: [32]u8 = undefined;
+    var file_buf: [20]u8 = undefined;
-    var file_reader = file.reader(io, &file_buffer);
+    var fbs = std.io.fixedBufferStream(&file_buf);
-    var reader = &file_reader.interface;
 
-    var buffer: [20]u8 = undefined;
+    _ = try file.reader().streamUntilDelimiter(fbs.writer(), '\n', 20);
-    var writer = std.Io.Writer.fixed(&buffer);
+    const line = fbs.getWritten();
 
-    const written = try reader.streamDelimiter(&writer, '\n');
+    return std.fmt.parseInt(i32, std.mem.trim(u8, line, " "), 10);
-    return std.fmt.parseInt(i32, std.mem.trim(u8, buffer[0..written], " "), 10);
 }
 
-fn createXauthFile(log_file: *LogFile, io: std.Io, pwd: []const u8, buffer: []u8) ![]const u8 {
+fn createXauthFile(pwd: [:0]const u8) ![:0]const u8 {
     var xauth_buf: [100]u8 = undefined;
-    var xauth_dir: []const u8 = undefined;
+    var xauth_dir: [:0]const u8 = undefined;
-    const xdg_rt_dir = std.posix.system.getenv("XDG_RUNTIME_DIR");
+    const xdg_rt_dir = std.posix.getenv("XDG_RUNTIME_DIR");
     var xauth_file: []const u8 = "lyxauth";
 
-    if (xdg_rt_dir == null) no_rt_dir: {
+    if (xdg_rt_dir == null) {
-        const xdg_cfg_home = std.posix.system.getenv("XDG_CONFIG_HOME");
+        const xdg_cfg_home = std.posix.getenv("XDG_CONFIG_HOME");
-        if (xdg_cfg_home == null) no_cfg_home: {
+        var sb: std.c.Stat = undefined;
-            xauth_dir = try std.fmt.bufPrint(&xauth_buf, "{s}/.config", .{pwd});
+        if (xdg_cfg_home == null) {
-
+            xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/.config", .{pwd});
-            var dir = std.Io.Dir.cwd().openDir(io, xauth_dir, .{}) catch {
+            _ = std.c.stat(xauth_dir, &sb);
-                // xauth_dir isn't a directory
+            const mode = sb.mode & std.posix.S.IFMT;
+            if (mode == std.posix.S.IFDIR) {
+                xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/ly", .{xauth_dir});
+            } else {
                 xauth_dir = pwd;
                 xauth_file = ".lyxauth";
-                break :no_cfg_home;
+            }
-            };
-            dir.close(io);
-
-            // xauth_dir is a directory, use it to store Xauthority
-            xauth_dir = try std.fmt.bufPrint(&xauth_buf, "{s}/.config/ly", .{pwd});
         } else {
-            xauth_dir = try std.fmt.bufPrint(&xauth_buf, "{s}/ly", .{std.mem.span(xdg_cfg_home.?)});
+            xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/ly", .{xdg_cfg_home.?});
         }
 
-        const file = std.Io.Dir.cwd().openFile(io, xauth_dir, .{}) catch break :no_rt_dir;
+        _ = std.c.stat(xauth_dir, &sb);
-        file.close(io);
+        const mode = sb.mode & std.posix.S.IFMT;
-
+        if (mode != std.posix.S.IFDIR) {
-        // xauth_dir is a file, create the parent directory
+            std.posix.mkdir(xauth_dir, 777) catch {
-        std.Io.Dir.createDirAbsolute(io, xauth_dir, .fromMode(777)) catch {
+                xauth_dir = pwd;
-            xauth_dir = pwd;
+                xauth_file = ".lyxauth";
-            xauth_file = ".lyxauth";
+            };
-        };
+        }
     } else {
-        xauth_dir = std.mem.span(xdg_rt_dir.?);
+        xauth_dir = xdg_rt_dir.?;
     }
 
     // Trim trailing slashes
@@ -388,21 +332,17 @@ fn createXauthFile(log_file: *LogFile, io: std.Io, pwd: []const u8, buffer: []u8
     while (xauth_dir[i] == '/') i -= 1;
     const trimmed_xauth_dir = xauth_dir[0 .. i + 1];
 
-    const xauthority: []u8 = try std.fmt.bufPrint(buffer, "{s}/{s}", .{ trimmed_xauth_dir, xauth_file });
+    var buf: [256]u8 = undefined;
-
+    const xauthority: [:0]u8 = try std.fmt.bufPrintZ(&buf, "{s}/{s}", .{ trimmed_xauth_dir, xauth_file });
-    std.Io.Dir.cwd().createDirPath(io, trimmed_xauth_dir) catch {};
+    const file = try std.fs.createFileAbsoluteZ(xauthority, .{});
-
+    file.close();
-    try log_file.info(io, "auth/x11", "creating xauth file: {s}", .{xauthority});
-
-    const file = try std.Io.Dir.createFileAbsolute(io, xauthority, .{});
-    file.close(io);
 
     return xauthority;
 }
 
-fn mcookie(io: std.Io) [Md5.digest_length * 2]u8 {
+fn mcookie() [Md5.digest_length * 2]u8 {
     var buf: [4096]u8 = undefined;
-    io.random(&buf);
+    std.crypto.random.bytes(&buf);
 
     var out: [Md5.digest_length]u8 = undefined;
     Md5.hash(&buf, &out, .{});
@@ -410,189 +350,128 @@ fn mcookie(io: std.Io) [Md5.digest_length * 2]u8 {
     return std.fmt.bytesToHex(&out, .lower);
 }
 
-fn xauth(log_file: *LogFile, allocator: std.mem.Allocator, io: std.Io, display_name: []u8, shell: [*:0]const u8, home: []const u8, xauth_buffer: []u8, options: AuthOptions) ![]const u8 {
+fn xauth(display_name: [:0]u8, shell: [*:0]const u8, pw_dir: [*:0]const u8, config: Config) !void {
-    const xauthority = try createXauthFile(log_file, io, home, xauth_buffer);
+    var pwd_buf: [100]u8 = undefined;
-    try interop.setEnvironmentVariable(allocator, "XAUTHORITY", xauthority, true);
+    const pwd = try std.fmt.bufPrintZ(&pwd_buf, "{s}", .{pw_dir});
-    try interop.setEnvironmentVariable(allocator, "DISPLAY", display_name, true);
 
-    const magic_cookie = mcookie(io);
+    const xauthority = try createXauthFile(pwd);
+    _ = interop.stdlib.setenv("XAUTHORITY", xauthority, 1);
+    _ = interop.stdlib.setenv("DISPLAY", display_name, 1);
 
-    const pid = std.posix.system.fork();
+    const magic_cookie = mcookie();
+
+    const pid = try std.posix.fork();
     if (pid == 0) {
-        var cmd_buffer: [1024]u8 = undefined;
+        const log_file = try redirectStandardStreams(config.session_log, true);
-        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} add {s} . {s}", .{ options.xauth_cmd, display_name, magic_cookie }) catch std.process.exit(1);
+        defer log_file.close();
 
-        try log_file.info(io, "auth/x11", "executing: {s} -c {s}", .{ shell, cmd_str });
+        var cmd_buffer: [1024]u8 = undefined;
+        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} add {s} . {s}", .{ config.xauth_cmd, display_name, magic_cookie }) catch std.process.exit(1);
         const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
-        _ = std.posix.system.execve(shell, &args, std.c.environ);
+        std.posix.execveZ(shell, &args, std.c.environ) catch {};
         std.process.exit(1);
     }
 
-    var status: c_int = undefined;
+    const status = std.posix.waitpid(pid, 0);
-    const result = std.posix.system.waitpid(pid, &status, 0);
+    if (status.status != 0) return error.XauthFailed;
-    if (interop.isError(result) or status != 0) {
-        try log_file.err(
-            io,
-            "auth/x11",
-            "xauth command failed with status: {d}",
-            .{status},
-        );
-        return error.XauthFailed;
-    }
-
-    return xauthority;
 }
 
-fn executeX11Cmd(log_file: *LogFile, allocator: std.mem.Allocator, io: std.Io, shell: []const u8, home: []const u8, options: AuthOptions, desktop_cmd: []const u8, vt: []const u8) !void {
+fn executeShellCmd(shell: [*:0]const u8, config: Config) !void {
-    var xauth_buffer: [256]u8 = undefined;
+    // We don't want to redirect stdout and stderr in a shell session
 
-    try log_file.info(io, "auth/x11", "getting free display", .{});
+    var cmd_buffer: [1024]u8 = undefined;
+    const cmd_str = try std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ config.setup_cmd, config.login_cmd orelse "", shell });
+    const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
+    return std.posix.execveZ(shell, &args, std.c.environ);
+}
+
+fn executeWaylandCmd(shell: [*:0]const u8, config: Config, desktop_cmd: []const u8) !void {
+    const log_file = try redirectStandardStreams(config.session_log, true);
+    defer log_file.close();
+
+    var cmd_buffer: [1024]u8 = undefined;
+    const cmd_str = try std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ config.setup_cmd, config.login_cmd orelse "", desktop_cmd });
+    const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
+    return std.posix.execveZ(shell, &args, std.c.environ);
+}
+
+fn executeX11Cmd(shell: [*:0]const u8, pw_dir: [*:0]const u8, config: Config, desktop_cmd: []const u8, vt: []const u8) !void {
     const display_num = try getFreeDisplay();
-    var buf: [4]u8 = undefined;
+    var buf: [5]u8 = undefined;
-    const display_name = try std.fmt.bufPrint(&buf, ":{d}", .{display_num});
+    const display_name = try std.fmt.bufPrintZ(&buf, ":{d}", .{display_num});
-    try log_file.info(io, "auth/x11", "got free display: {d}", .{display_num});
+    try xauth(display_name, shell, pw_dir, config);
 
-    const shell_z = try allocator.dupeZ(u8, shell);
+    const pid = try std.posix.fork();
-    defer allocator.free(shell_z);
-
-    try log_file.info(io, "auth/x11", "creating xauth file", .{});
-    const xauthority = try xauth(log_file, allocator, io, display_name, shell_z, home, &xauth_buffer, options);
-
-    try log_file.info(io, "auth/x11", "starting x server", .{});
-    const pid = std.posix.system.fork();
     if (pid == 0) {
         var cmd_buffer: [1024]u8 = undefined;
-        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s} -auth {s}", .{ options.x_cmd, display_name, vt, xauthority }) catch std.process.exit(1);
+        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s} >{s} 2>&1", .{ config.x_cmd, display_name, vt, config.session_log }) catch std.process.exit(1);
-        try log_file.info(io, "auth/x11", "executing: {s} -c {s} -auth {s}", .{ shell, cmd_str, xauthority });
+        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
-
+        std.posix.execveZ(shell, &args, std.c.environ) catch {};
-        const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
-        _ = std.posix.system.execve(shell_z, &args, std.c.environ);
         std.process.exit(1);
     }
 
-    try log_file.info(io, "auth/x11", "waiting for xcb connection", .{});
+    var ok: c_int = undefined;
-    var ok: c_int = -1;
     var xcb: ?*interop.xcb.xcb_connection_t = null;
     while (ok != 0) {
         xcb = interop.xcb.xcb_connect(null, null);
         ok = interop.xcb.xcb_connection_has_error(xcb);
-        std.posix.kill(pid, @enumFromInt(0)) catch |e| {
+        std.posix.kill(pid, 0) catch |e| {
             if (e == error.ProcessNotFound and ok != 0) return error.XcbConnectionFailed;
         };
     }
 
     // X Server detaches from the process.
     // PID can be fetched from /tmp/X{d}.lock
-    try log_file.info(io, "auth/x11", "getting x server pid", .{});
+    const x_pid = try getXPid(display_num);
-    const x_pid = try getXPid(io, display_num);
-    try log_file.info(io, "auth/x11", "got x server pid: {d}", .{x_pid});
 
-    try log_file.info(io, "auth/x11", "launching environment", .{});
+    xorg_pid = try std.posix.fork();
-    xorg_pid = std.posix.system.fork();
     if (xorg_pid == 0) {
         var cmd_buffer: [1024]u8 = undefined;
-        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s} {s}", .{ if (options.use_kmscon_vt) "kmscon-launch-gui" else "", options.setup_cmd, options.login_cmd orelse "", desktop_cmd }) catch std.process.exit(1);
+        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s} >{s} 2>&1", .{ config.setup_cmd, config.login_cmd orelse "", desktop_cmd, config.session_log }) catch std.process.exit(1);
-        try log_file.info(io, "auth/x11", "executing: {s} -c {s}", .{ shell, cmd_str });
+        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
-
+        std.posix.execveZ(shell, &args, std.c.environ) catch {};
-        const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
-        _ = std.posix.system.execve(shell_z, &args, std.c.environ);
         std.process.exit(1);
     }
 
     // If we receive SIGTERM, clean up by killing the xorg_pid process
     const act = std.posix.Sigaction{
         .handler = .{ .handler = &xorgSignalHandler },
-        .mask = std.posix.sigemptyset(),
+        .mask = std.posix.empty_sigset,
         .flags = 0,
     };
-    std.posix.sigaction(std.posix.SIG.TERM, &act, null);
+    try std.posix.sigaction(std.posix.SIG.TERM, &act, null);
 
-    var xorg_status: c_int = undefined;
+    _ = std.posix.waitpid(xorg_pid, 0);
-    _ = std.posix.system.waitpid(xorg_pid, &xorg_status, 0);
-
-    try log_file.info(io, "auth/x11", "disconnecting xcb", .{});
     interop.xcb.xcb_disconnect(xcb);
 
-    // TODO: Find a more robust way to ensure that X has been terminated (pidfds?)
+    std.posix.kill(x_pid, 0) catch return;
     std.posix.kill(x_pid, std.posix.SIG.TERM) catch {};
-    io.sleep(.fromSeconds(1), .real) catch {}; // Wait 1 second before sending SIGKILL
-    std.posix.kill(x_pid, std.posix.SIG.KILL) catch return;
 
-    var x_status: c_int = undefined;
+    var status: c_int = 0;
-    _ = std.posix.system.waitpid(x_pid, &x_status, 0);
+    _ = std.c.waitpid(x_pid, &status, 0);
 }
 
-fn executeCmd(global_log_file: *LogFile, allocator: std.mem.Allocator, io: std.Io, shell: []const u8, options: AuthOptions, is_terminal: bool, exec_cmd: ?[]const u8) !void {
+fn redirectStandardStreams(session_log: []const u8, create: bool) !std.fs.File {
-    try global_log_file.info(io, "auth/sys", "launching wayland/shell/custom session", .{});
+    const log_file = if (create) (try std.fs.cwd().createFile(session_log, .{ .mode = 0o666 })) else (try std.fs.cwd().openFile(session_log, .{ .mode = .read_write }));
 
-    var maybe_log_file: ?std.Io.File = null;
+    try std.posix.dup2(std.posix.STDOUT_FILENO, std.posix.STDERR_FILENO);
-    if (!is_terminal) redirect_streams: {
+    try std.posix.dup2(log_file.handle, std.posix.STDOUT_FILENO);
-        if (options.use_kmscon_vt) {
-            try global_log_file.err(io, "auth/sys", "cannot redirect stdio & stderr with kmscon", .{});
-            break :redirect_streams;
-        }
-
-        // For custom desktop entries, the "Terminal" value here determines if
-        // we redirect standard output & error or not. That is, we redirect only
-        // if it's equal to false (so if it's not running in a TTY).
-        if (options.session_log) |log_path| {
-            try global_log_file.info(io, "auth/sys", "setting up stdio & stderr redirection", .{});
-            maybe_log_file = try redirectStandardStreams(global_log_file, io, log_path, true);
-        }
-    }
-    defer if (maybe_log_file) |log_file| log_file.close(io);
-
-    const shell_z = try allocator.dupeZ(u8, shell);
-    defer allocator.free(shell_z);
-
-    var cmd_buffer: [1024]u8 = undefined;
-    const cmd_str = try std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s} {s}", .{ if (!is_terminal and options.use_kmscon_vt) "kmscon-launch-gui" else "", options.setup_cmd, options.login_cmd orelse "", exec_cmd orelse shell });
-
-    try global_log_file.info(io, "auth/sys", "executing: {s} -c {s}", .{ shell, cmd_str });
-    const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
-    _ = std.posix.system.execve(shell_z, &args, std.c.environ);
-    return error.CmdExecveFailed;
-}
-
-fn redirectStandardStreams(global_log_file: *LogFile, io: std.Io, session_log: []const u8, create: bool) !std.Io.File {
-    create_session_log_dir: {
-        const session_log_dir = std.Io.Dir.path.dirname(session_log) orelse break :create_session_log_dir;
-        std.Io.Dir.cwd().createDirPath(io, session_log_dir) catch |err| {
-            try global_log_file.err(io, "auth/sys", "failed to create session log file directory: {s}", .{@errorName(err)});
-            return err;
-        };
-    }
-
-    const log_file = if (create) (std.Io.Dir.cwd().createFile(io, session_log, .{ .permissions = .fromMode(0o666) }) catch |err| {
-        try global_log_file.err(io, "auth/sys", "failed to create new session log file: {s}", .{@errorName(err)});
-        return err;
-    }) else (std.Io.Dir.cwd().openFile(io, session_log, .{ .mode = .read_write }) catch |err| {
-        try global_log_file.err(io, "auth/sys", "failed to open existing session log file: {s}", .{@errorName(err)});
-        return err;
-    });
-
-    if (interop.isError(std.posix.system.dup2(std.posix.STDOUT_FILENO, std.posix.STDERR_FILENO))) return error.StdoutDup2Failed;
-    if (interop.isError(std.posix.system.dup2(log_file.handle, std.posix.STDOUT_FILENO))) return error.LogFileDup2Failed;
 
     return log_file;
 }
 
-fn addUtmpEntry(io: std.Io, entry: *Utmp, username: []const u8, pid: c_int) !void {
+fn addUtmpEntry(entry: *Utmp, username: [*:0]const u8, pid: c_int) !void {
     entry.ut_type = utmp.USER_PROCESS;
     entry.ut_pid = pid;
 
-    var buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+    var buf: [4096]u8 = undefined;
-    const length = try std.Io.File.stdin().realPath(io, &buf);
+    const ttyname = try std.os.getFdPath(std.posix.STDIN_FILENO, &buf);
-    const tty_path = buf[0..length];
 
-    // Get the TTY name (i.e. without the /dev/ prefix)
     var ttyname_buf: [@sizeOf(@TypeOf(entry.ut_line))]u8 = undefined;
-    _ = try std.fmt.bufPrintZ(&ttyname_buf, "{s}", .{tty_path["/dev/".len..]});
+    _ = try std.fmt.bufPrintZ(&ttyname_buf, "{s}", .{ttyname["/dev/".len..]});
 
     entry.ut_line = ttyname_buf;
-    // Get the TTY ID (i.e. without the tty prefix) and truncate it to the size
+    entry.ut_id = ttyname_buf["tty".len..7].*;
-    // of ut_id if necessary
-    entry.ut_id = ttyname_buf["tty".len..(@sizeOf(@TypeOf(entry.ut_id)) + "tty".len)].*;
 
     var username_buf: [@sizeOf(@TypeOf(entry.ut_user))]u8 = undefined;
     _ = try std.fmt.bufPrintZ(&username_buf, "{s}", .{username});
@@ -603,17 +482,14 @@ fn addUtmpEntry(io: std.Io, entry: *Utmp, username: []const u8, pid: c_int) !voi
     host[0] = 0;
     entry.ut_host = host;
 
-    const time = try interop.getTimeOfDay();
+    var tv: interop.system_time.timeval = undefined;
+    _ = interop.system_time.gettimeofday(&tv, null);
 
     entry.ut_tv = .{
-        .tv_sec = @intCast(time.seconds),
+        .tv_sec = @intCast(tv.tv_sec),
-        .tv_usec = @intCast(time.microseconds),
+        .tv_usec = @intCast(tv.tv_usec),
     };
-
+    entry.ut_addr_v6[0] = 0;
-    // FreeBSD doesn't have this field
-    if (builtin.os.tag == .linux) {
-        entry.ut_addr_v6[0] = 0;
-    }
 
     utmp.setutxent();
     _ = utmp.pututxline(entry);

src/bigclock.zig

@@ -0,0 +1,58 @@
+const std = @import("std");
+const interop = @import("interop.zig");
+const utils = @import("tui/utils.zig");
+const enums = @import("enums.zig");
+const Lang  = @import("bigclock/Lang.zig");
+const en    = @import("bigclock/en.zig");
+const fa    = @import("bigclock/fa.zig");
+
+const termbox    = interop.termbox;
+const Bigclock   = enums.Bigclock;
+pub const WIDTH  = Lang.WIDTH;
+pub const HEIGHT = Lang.HEIGHT;
+pub const SIZE   = Lang.SIZE;
+
+pub fn clockCell(animate: bool, char: u8, fg: u16, bg: u16, bigclock: Bigclock) [SIZE]utils.Cell {
+    var cells: [SIZE]utils.Cell = undefined;
+
+    var tv: interop.system_time.timeval = undefined;
+    _ = interop.system_time.gettimeofday(&tv, null);
+
+    const clock_chars = toBigNumber(if (animate and char == ':' and @divTrunc(tv.tv_usec, 500000) != 0) ' ' else char, bigclock);
+    for (0..cells.len) |i| cells[i] = utils.initCell(clock_chars[i], fg, bg);
+
+    return cells;
+}
+
+pub fn alphaBlit(x: usize, y: usize, tb_width: usize, tb_height: usize, cells: [SIZE]utils.Cell) void {
+    if (x + WIDTH >= tb_width or y + HEIGHT >= tb_height) return;
+
+    for (0..HEIGHT) |yy| {
+        for (0..WIDTH) |xx| {
+            const cell = cells[yy * WIDTH + xx];
+            if (cell.ch != 0) utils.putCell(x + xx, y + yy, cell);
+        }
+    }
+}
+
+fn toBigNumber(char: u8, bigclock: Bigclock) []const u21 {
+    const locale_chars = switch (bigclock) {
+        .fa     => fa.locale_chars,
+        .en     => en.locale_chars,
+        .none   => unreachable,
+    };
+    return switch (char) {
+        '0' => &locale_chars.ZERO,
+        '1' => &locale_chars.ONE,
+        '2' => &locale_chars.TWO,
+        '3' => &locale_chars.THREE,
+        '4' => &locale_chars.FOUR,
+        '5' => &locale_chars.FIVE,
+        '6' => &locale_chars.SIX,
+        '7' => &locale_chars.SEVEN,
+        '8' => &locale_chars.EIGHT,
+        '9' => &locale_chars.NINE,
+        ':' => &locale_chars.S,
+        else => &locale_chars.E,
+    };
+}

src/bigclock/Lang.zig

@@ -0,0 +1,23 @@
+const builtin = @import("builtin");
+
+pub const WIDTH = 5;
+pub const HEIGHT = 5;
+pub const SIZE = WIDTH * HEIGHT;
+
+pub const X: u32 = if (builtin.os.tag == .linux or builtin.os.tag.isBSD()) 0x2593 else '#';
+pub const O: u32 = 0;
+
+pub const LocaleChars = struct {
+    ZERO:   [SIZE]u21,
+    ONE:    [SIZE]u21,
+    TWO:    [SIZE]u21,
+    THREE:  [SIZE]u21,
+    FOUR:   [SIZE]u21,
+    FIVE:   [SIZE]u21,
+    SIX:    [SIZE]u21,
+    SEVEN:  [SIZE]u21,
+    EIGHT:  [SIZE]u21,
+    NINE:   [SIZE]u21,
+    S:      [SIZE]u21,
+    E:      [SIZE]u21,
+};

src/bigclock/en.zig

@@ -1,7 +1,8 @@
-const BigLabel = @import("../BigLabel.zig");
+const Lang = @import("Lang.zig");
-const LocaleChars = BigLabel.LocaleChars;
+
-const X = BigLabel.X;
+const LocaleChars = Lang.LocaleChars;
-const O = BigLabel.O;
+const X = Lang.X;
+const O = Lang.O;
 
 // zig fmt: off
 pub const locale_chars = LocaleChars{
@@ -89,26 +90,5 @@ pub const locale_chars = LocaleChars{
         O,O,O,O,O,
         O,O,O,O,O,
     },
-    .P = [_]u21{
-        X,X,X,X,X,
-        X,X,O,X,X,
-        X,X,X,X,X,
-        X,X,O,O,O,
-        X,X,O,O,O,
-    },
-    .A = [_]u21{
-        X,X,X,X,X,
-        X,X,O,X,X,
-        X,X,X,X,X,
-        X,X,O,X,X,
-        X,X,O,X,X,
-    },
-    .M = [_]u21{
-        X,X,X,X,X,
-        X,O,X,O,X,
-        X,O,X,O,X,
-        X,O,O,O,X,
-        X,O,O,O,X,
-    },
 };
-// zig fmt: on
+// zig fmt: on

src/bigclock/fa.zig

@@ -1,7 +1,8 @@
-const BigLabel = @import("../BigLabel.zig");
+const Lang = @import("Lang.zig");
-const LocaleChars = BigLabel.LocaleChars;
+
-const X = BigLabel.X;
+const LocaleChars = Lang.LocaleChars;
-const O = BigLabel.O;
+const X = Lang.X;
+const O = Lang.O;
 
 // zig fmt: off
 pub const locale_chars = LocaleChars{
@@ -75,27 +76,6 @@ pub const locale_chars = LocaleChars{
         O,O,O,X,O,
         O,O,O,X,O,
     },
-    .P = [_]u21{
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-    },
-    .A = [_]u21{
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-    },
-    .M = [_]u21{
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-        O,O,O,O,O,
-    },
     .S = [_]u21{
         O,O,O,O,O,
         O,O,X,O,O,
@@ -111,4 +91,4 @@ pub const locale_chars = LocaleChars{
         O,O,O,O,O,
     },
 };
-// zig fmt: on
+// zig fmt: on

src/components/InfoLine.zig

@@ -1,118 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ly_ui = @import("ly-ui");
-const keyboard = ly_ui.keyboard;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-const CyclableLabel = ly_ui.CyclableLabel;
-
-const MessageLabel = CyclableLabel(Message, Message);
-
-const InfoLine = @This();
-
-const Message = struct {
-    width: usize,
-    text: []const u8,
-    bg: u32,
-    fg: u32,
-};
-
-instance: ?Widget = null,
-label: *MessageLabel,
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    buffer: *TerminalBuffer,
-    width: usize,
-    arrow_fg: u32,
-    arrow_bg: u32,
-) !InfoLine {
-    return .{
-        .instance = null,
-        .label = try MessageLabel.init(
-            allocator,
-            io,
-            buffer,
-            drawItem,
-            null,
-            null,
-            width,
-            true,
-            arrow_fg,
-            arrow_bg,
-        ),
-    };
-}
-
-pub fn deinit(self: *InfoLine) void {
-    self.label.deinit();
-}
-
-pub fn widget(self: *InfoLine) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "InfoLine",
-        self.label.keybinds,
-        self,
-        deinit,
-        null,
-        draw,
-        null,
-        handle,
-        null,
-    );
-    return &self.instance.?;
-}
-
-pub fn addMessage(self: *InfoLine, text: []const u8, bg: u32, fg: u32) !void {
-    if (text.len == 0) return;
-
-    try self.label.addItem(.{
-        .width = TerminalBuffer.strWidth(text),
-        .text = text,
-        .bg = bg,
-        .fg = fg,
-    });
-}
-
-pub fn clearRendered(self: InfoLine, allocator: Allocator) !void {
-    // Draw over the area
-    const spaces = try allocator.alloc(u8, self.label.width - 2);
-    defer allocator.free(spaces);
-
-    @memset(spaces, ' ');
-
-    TerminalBuffer.drawText(
-        spaces,
-        self.label.component_pos.x + 2,
-        self.label.component_pos.y,
-        TerminalBuffer.Color.DEFAULT,
-        TerminalBuffer.Color.DEFAULT,
-    );
-}
-
-fn draw(self: *InfoLine) void {
-    self.label.draw();
-}
-
-fn handle(self: *InfoLine, maybe_key: ?keyboard.Key) !void {
-    self.label.handle(maybe_key);
-}
-
-fn drawItem(label: *MessageLabel, message: Message, x: usize, y: usize, width: usize) void {
-    if (message.width == 0) return;
-
-    const x_offset = if (label.text_in_center and width >= message.width) (width - message.width) / 2 else 0;
-
-    label.cursor = message.width + x_offset;
-    TerminalBuffer.drawConfinedText(
-        message.text,
-        x + x_offset,
-        y,
-        width,
-        message.fg,
-        message.bg,
-    );
-}

src/components/Session.zig

@@ -1,123 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ly_ui = @import("ly-ui");
-const keyboard = ly_ui.keyboard;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-const CyclableLabel = ly_ui.CyclableLabel;
-
-const UserList = @import("UserList.zig");
-const Environment = @import("../Environment.zig");
-
-const Env = struct {
-    environment: Environment,
-    index: usize,
-};
-const EnvironmentLabel = CyclableLabel(Env, *UserList);
-
-const Session = @This();
-
-instance: ?Widget = null,
-label: *EnvironmentLabel,
-user_list: *UserList,
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    buffer: *TerminalBuffer,
-    user_list: *UserList,
-    width: usize,
-    text_in_center: bool,
-    fg: u32,
-    bg: u32,
-) !Session {
-    return .{
-        .instance = null,
-        .label = try EnvironmentLabel.init(
-            allocator,
-            io,
-            buffer,
-            drawItem,
-            sessionChanged,
-            user_list,
-            width,
-            text_in_center,
-            fg,
-            bg,
-        ),
-        .user_list = user_list,
-    };
-}
-
-pub fn deinit(self: *Session) void {
-    for (self.label.list.items) |*env| {
-        if (env.environment.entry_ini) |*entry_ini| entry_ini.deinit();
-        self.label.allocator.free(env.environment.file_name);
-    }
-
-    self.label.deinit();
-}
-
-pub fn widget(self: *Session) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "Session",
-        self.label.keybinds,
-        self,
-        deinit,
-        null,
-        draw,
-        null,
-        handle,
-        null,
-    );
-    return &self.instance.?;
-}
-
-pub fn addEnvironment(self: *Session, environment: Environment) !void {
-    const env = Env{ .environment = environment, .index = self.label.list.items.len };
-
-    try self.label.addItem(env);
-    addedSession(env, self.user_list);
-}
-
-fn draw(self: *Session) void {
-    self.label.draw();
-}
-
-fn handle(self: *Session, maybe_key: ?keyboard.Key) !void {
-    self.label.handle(maybe_key);
-}
-
-fn addedSession(env: Env, user_list: *UserList) void {
-    const user = user_list.label.list.items[user_list.label.current];
-    if (!user.first_run) return;
-
-    user.session_index.* = env.index;
-}
-
-fn sessionChanged(env: Env, maybe_user_list: ?*UserList) void {
-    if (maybe_user_list) |user_list| {
-        user_list.label.list.items[user_list.label.current].session_index.* = env.index;
-    }
-}
-
-fn drawItem(label: *EnvironmentLabel, env: Env, x: usize, y: usize, width: usize) void {
-    if (width < 3) return;
-
-    const length = @min(TerminalBuffer.strWidth(env.environment.name), width - 3);
-    if (length == 0) return;
-
-    const x_offset = if (label.text_in_center and width >= length) (width - length) / 2 else 0;
-
-    label.cursor = length + x_offset;
-    TerminalBuffer.drawConfinedText(
-        env.environment.name,
-        x + x_offset,
-        y,
-        width,
-        label.fg,
-        label.bg,
-    );
-}

src/components/UserList.zig

@@ -1,147 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-
-const ly_ui = @import("ly-ui");
-const keyboard = ly_ui.keyboard;
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Widget = ly_ui.Widget;
-const CyclableLabel = ly_ui.CyclableLabel;
-
-const Session = @import("Session.zig");
-const SavedUsers = @import("../config/SavedUsers.zig");
-
-const StringList = std.ArrayListUnmanaged([]const u8);
-pub const User = struct {
-    name: []const u8,
-    session_index: *usize,
-    allocated_index: bool,
-    first_run: bool,
-};
-const UserLabel = CyclableLabel(User, *Session);
-
-const UserList = @This();
-
-instance: ?Widget = null,
-label: *UserLabel,
-
-pub fn init(
-    allocator: Allocator,
-    io: std.Io,
-    buffer: *TerminalBuffer,
-    usernames: StringList,
-    saved_users: *SavedUsers,
-    session: *Session,
-    width: usize,
-    text_in_center: bool,
-    fg: u32,
-    bg: u32,
-) !UserList {
-    var user_list = UserList{
-        .instance = null,
-        .label = try UserLabel.init(
-            allocator,
-            io,
-            buffer,
-            drawItem,
-            usernameChanged,
-            session,
-            width,
-            text_in_center,
-            fg,
-            bg,
-        ),
-    };
-
-    for (usernames.items) |username| {
-        if (username.len == 0) continue;
-
-        var maybe_session_index: ?*usize = null;
-        var first_run = true;
-        for (saved_users.user_list.items) |*saved_user| {
-            if (std.mem.eql(u8, username, saved_user.username)) {
-                maybe_session_index = &saved_user.session_index;
-                first_run = saved_user.first_run;
-                break;
-            }
-        }
-
-        var allocated_index = false;
-        if (maybe_session_index == null) {
-            maybe_session_index = try allocator.create(usize);
-            maybe_session_index.?.* = 0;
-            allocated_index = true;
-        }
-
-        try user_list.label.addItem(.{
-            .name = username,
-            .session_index = maybe_session_index.?,
-            .allocated_index = allocated_index,
-            .first_run = first_run,
-        });
-    }
-
-    return user_list;
-}
-
-pub fn deinit(self: *UserList) void {
-    for (self.label.list.items) |user| {
-        if (user.allocated_index) {
-            self.label.allocator.destroy(user.session_index);
-        }
-    }
-
-    self.label.deinit();
-}
-
-pub fn widget(self: *UserList) *Widget {
-    if (self.instance) |*instance| return instance;
-    self.instance = Widget.init(
-        "UserList",
-        self.label.keybinds,
-        self,
-        deinit,
-        null,
-        draw,
-        null,
-        handle,
-        null,
-    );
-    return &self.instance.?;
-}
-
-pub fn getCurrentUsername(self: UserList) []const u8 {
-    return self.label.list.items[self.label.current].name;
-}
-
-fn draw(self: *UserList) void {
-    self.label.draw();
-}
-
-fn handle(self: *UserList, maybe_key: ?keyboard.Key) !void {
-    self.label.handle(maybe_key);
-}
-
-fn usernameChanged(user: User, maybe_session: ?*Session) void {
-    if (maybe_session) |session| {
-        session.label.current = @min(user.session_index.*, session.label.list.items.len - 1);
-    }
-}
-
-fn drawItem(label: *UserLabel, user: User, x: usize, y: usize, width: usize) void {
-    if (width < 3) return;
-
-    const length = @min(TerminalBuffer.strWidth(user.name), width - 3);
-    if (length == 0) return;
-
-    const x_offset = if (label.text_in_center and width >= length) (width - length) / 2 else 0;
-
-    label.cursor = length + x_offset;
-    TerminalBuffer.drawConfinedText(
-        user.name,
-        x + x_offset,
-        y,
-        width,
-        label.fg,
-        label.bg,
-    );
-}

src/config/Config.zig

@@ -1,102 +1,61 @@
 const build_options = @import("build_options");
-
 const enums = @import("../enums.zig");
+
 const Animation = enums.Animation;
 const Input = enums.Input;
 const ViMode = enums.ViMode;
 const Bigclock = enums.Bigclock;
-const DurOffsetAlignment = enums.DurOffsetAlignment;
 
-allow_empty_password: bool = true,
 animation: Animation = .none,
-animation_frame_delay: u16 = 5,
 animation_timeout_sec: u12 = 0,
-asterisk: ?u32 = '*',
+asterisk: ?u8 = '*',
 auth_fails: u64 = 10,
-battery_id: ?[]const u8 = null,
+bg: u16 = 0,
-auto_login_service: [:0]const u8 = "ly-autologin",
-auto_login_session: ?[]const u8 = null,
-auto_login_user: ?[]const u8 = null,
-bg: u32 = 0x00000000,
 bigclock: Bigclock = .none,
-bigclock_12hr: bool = false,
-bigclock_seconds: bool = false,
 blank_box: bool = true,
-border_fg: u32 = 0x00FFFFFF,
+border_fg: u16 = 8,
 box_title: ?[]const u8 = null,
-brightness_down_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q -n s 10%-",
+brightness_down_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q s 10%-",
-brightness_down_key: ?[]const u8 = "F5",
+brightness_down_key: []const u8 = "F5",
-brightness_up_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q -n s +10%",
+brightness_up_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q s +10%",
-brightness_up_key: ?[]const u8 = "F6",
+brightness_up_key: []const u8 = "F6",
 clear_password: bool = false,
 clock: ?[:0]const u8 = null,
-cmatrix_fg: u32 = 0x0000FF00,
+cmatrix_fg: u16 = 3,
-cmatrix_head_col: u32 = 0x01FFFFFF,
+console_dev: []const u8 = "/dev/console",
-cmatrix_min_codepoint: u16 = 0x21,
-cmatrix_max_codepoint: u16 = 0x7B,
-colormix_col1: u32 = 0x00FF0000,
-colormix_col2: u32 = 0x000000FF,
-colormix_col3: u32 = 0x20000000,
-custom_bind_width: ?u32 = null,
-custom_sessions: []const u8 = build_options.config_directory ++ "/ly/custom-sessions",
 default_input: Input = .login,
-doom_fire_height: u8 = 6,
+error_bg: u16 = 0,
-doom_fire_spread: u8 = 2,
+error_fg: u16 = 258,
-doom_top_color: u32 = 0x00FF0000,
+fg: u16 = 8,
-doom_middle_color: u32 = 0x00FFFF00,
-doom_bottom_color: u32 = 0x00FFFFFF,
-dur_file_path: []const u8 = build_options.config_directory ++ "/ly/example.dur",
-dur_offset_alignment: DurOffsetAlignment = .center,
-dur_x_offset: i32 = 0,
-dur_y_offset: i32 = 0,
-edge_margin: u8 = 0,
-error_bg: u32 = 0x00000000,
-error_fg: u32 = 0x01FF0000,
-fg: u32 = 0x00FFFFFF,
-full_color: bool = true,
-gameoflife_fg: u32 = 0x0000FF00,
-gameoflife_entropy_interval: usize = 10,
-gameoflife_frame_delay: usize = 6,
-gameoflife_initial_density: f32 = 0.4,
-hibernate_cmd: ?[]const u8 = null,
-hibernate_key: []const u8 = "F4",
 hide_borders: bool = false,
 hide_key_hints: bool = false,
-hide_keyboard_locks: bool = false,
-hide_version_string: bool = false,
-inactivity_cmd: ?[]const u8 = null,
-inactivity_delay: u16 = 0,
 initial_info_text: ?[]const u8 = null,
 input_len: u8 = 34,
 lang: []const u8 = "en",
+load: bool = true,
 login_cmd: ?[]const u8 = null,
-login_defs_path: []const u8 = "/etc/login.defs",
 logout_cmd: ?[]const u8 = null,
-ly_log: []const u8 = "/var/log/ly.log",
 margin_box_h: u8 = 2,
 margin_box_v: u8 = 1,
+min_refresh_delta: u16 = 5,
 numlock: bool = false,
-path: ?[]const u8 = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+path: ?[:0]const u8 = "/sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
 restart_cmd: []const u8 = "/sbin/shutdown -r now",
 restart_key: []const u8 = "F2",
 save: bool = true,
 service_name: [:0]const u8 = "ly",
-session_log: ?[]const u8 = "ly-session.log",
+session_log: []const u8 = "ly-session.log",
 setup_cmd: []const u8 = build_options.config_directory ++ "/ly/setup.sh",
-shell: bool = true,
-show_password_key: []const u8 = "F7",
-show_tty: bool = false,
 shutdown_cmd: []const u8 = "/sbin/shutdown -a now",
 shutdown_key: []const u8 = "F1",
 sleep_cmd: ?[]const u8 = null,
 sleep_key: []const u8 = "F3",
-start_cmd: ?[]const u8 = null,
 text_in_center: bool = false,
+tty: u8 = build_options.tty,
 vi_default_mode: ViMode = .normal,
 vi_mode: bool = false,
-waylandsessions: ?[]const u8 = build_options.prefix_directory ++ "/share/wayland-sessions",
+waylandsessions: []const u8 = build_options.prefix_directory ++ "/share/wayland-sessions",
 x_cmd: []const u8 = build_options.prefix_directory ++ "/bin/X",
-x_vt: ?u8 = null,
 xauth_cmd: []const u8 = build_options.prefix_directory ++ "/bin/xauth",
 xinitrc: ?[]const u8 = "~/.xinitrc",
-xsessions: ?[]const u8 = build_options.prefix_directory ++ "/share/xsessions",
+xsessions: []const u8 = build_options.prefix_directory ++ "/share/xsessions",

src/config/Lang.zig

@@ -1,35 +1,17 @@
-//
-// NOTE: After editing this file, please run `/res/lang/normalize_lang_files.py`
-//       to update all the language files accordingly.
-//
-
 authenticating: []const u8 = "authenticating...",
 brightness_down: []const u8 = "decrease brightness",
 brightness_up: []const u8 = "increase brightness",
 capslock: []const u8 = "capslock",
-custom: []const u8 = "custom",
-custom_info_err_output_long: []const u8 = "output too long",
-custom_info_err_no_output: []const u8 = "no output",
-custom_info_err_no_output_error: []const u8 = ", possible error",
 err_alloc: []const u8 = "failed memory allocation",
-err_args: []const u8 = "unable to parse command line arguments",
-err_autologin_session: []const u8 = "autologin session not found",
 err_bounds: []const u8 = "out-of-bounds index",
 err_brightness_change: []const u8 = "failed to change brightness",
 err_chdir: []const u8 = "failed to open home folder",
-err_clock_too_long: []const u8 = "clock string too long",
 err_config: []const u8 = "unable to parse config file",
-err_crawl: []const u8 = "failed to crawl session directories",
+err_console_dev: []const u8 = "failed to access console",
 err_dgn_oob: []const u8 = "log message",
 err_domain: []const u8 = "invalid domain",
-err_empty_password: []const u8 = "empty password not allowed",
 err_envlist: []const u8 = "failed to get envlist",
-err_get_active_tty: []const u8 = "failed to get active tty",
-err_hibernate: []const u8 = "failed to execute hibernate command",
 err_hostname: []const u8 = "failed to get hostname",
-err_inactivity: []const u8 = "failed to execute inactivity command",
-err_lock_state: []const u8 = "failed to get lock state",
-err_log: []const u8 = "failed to open log file",
 err_mlock: []const u8 = "failed to lock password memory",
 err_null: []const u8 = "null pointer",
 err_numlock: []const u8 = "failed to set numlock",
@@ -55,12 +37,7 @@ err_perm_group: []const u8 = "failed to downgrade group permissions",
 err_perm_user: []const u8 = "failed to downgrade user permissions",
 err_pwnam: []const u8 = "failed to get user info",
 err_sleep: []const u8 = "failed to execute sleep command",
-err_start: []const u8 = "failed to execute start command",
+err_unknown: []const u8 = "an unknown error occurred",
-err_battery: []const u8 = "failed to load battery status",
-err_switch_tty: []const u8 = "failed to switch tty",
-err_tty_ctrl: []const u8 = "tty control transfer failed",
-err_no_users: []const u8 = "no users found",
-err_uid_range: []const u8 = "failed to dynamically get uid range",
 err_user_gid: []const u8 = "failed to set user GID",
 err_user_init: []const u8 = "failed to initialize user",
 err_user_uid: []const u8 = "failed to set user UID",
@@ -68,20 +45,18 @@ err_xauth: []const u8 = "xauth command failed",
 err_xcb_conn: []const u8 = "xcb connection failed",
 err_xsessions_dir: []const u8 = "failed to find sessions folder",
 err_xsessions_open: []const u8 = "failed to open sessions folder",
-hibernate: []const u8 = "hibernate",
 insert: []const u8 = "insert",
-login: []const u8 = "login",
+login: []const u8 = "login:",
 logout: []const u8 = "logged out",
-no_x11_support: []const u8 = "x11 support disabled at compile-time",
 normal: []const u8 = "normal",
+no_x11_support: []const u8 = "x11 support disabled at compile-time",
 numlock: []const u8 = "numlock",
 other: []const u8 = "other",
-password: []const u8 = "password",
+password: []const u8 = "password:",
 restart: []const u8 = "reboot",
 shell: [:0]const u8 = "shell",
 shutdown: []const u8 = "shutdown",
 sleep: []const u8 = "sleep",
-toggle_password: []const u8 = "toggle password",
 wayland: []const u8 = "wayland",
-x11: []const u8 = "x11",
 xinitrc: [:0]const u8 = "xinitrc",
+x11: []const u8 = "x11",

src/config/SavedUsers.zig

@@ -1,28 +0,0 @@
-const std = @import("std");
-
-const SavedUsers = @This();
-
-const User = struct {
-    username: []const u8,
-    session_index: usize,
-    first_run: bool,
-    allocated_username: bool,
-};
-
-user_list: std.ArrayList(User),
-last_username_index: ?usize,
-
-pub fn init() SavedUsers {
-    return .{
-        .user_list = .empty,
-        .last_username_index = null,
-    };
-}
-
-pub fn deinit(self: *SavedUsers, allocator: std.mem.Allocator) void {
-    for (self.user_list.items) |user| {
-        if (user.allocated_username) allocator.free(user.username);
-    }
-
-    self.user_list.deinit(allocator);
-}

src/config/custom.zig

@@ -1,25 +0,0 @@
-const std = @import("std");
-
-const custom = @This();
-
-pub const CustomCommandBind = struct {
-    name: []const u8 = "",
-    cmd: []const u8 = "",
-};
-
-pub const UNDEFINED_CMD: []const u8 = "echo \"You forgot to define 'cmd'!\"";
-
-pub const CustomCommandInfo = struct {
-    name: []const u8 = "",
-    cmd: ?[]const u8 = null,
-    /// To be set to the label's widget ID
-    id: u64 = 0,
-
-    /// In frames, the refresh rate for the `cmd` to run again
-    /// If 0, only run once.
-    refresh: u32 = 0,
-    counter: u32 = 0,
-};
-
-pub var binds: std.array_hash_map.String(CustomCommandBind) = undefined;
-pub var labels: std.array_hash_map.String(CustomCommandInfo) = undefined;

src/config/migrator.zig

@@ -1,62 +1,23 @@
-// The migrator ensures compatibility with older configuration files
+// The migrator ensures compatibility with <=0.6.0 configuration files
-// Properties removed or changed since 0.6.0
-// Color codes interpreted differently since 1.1.0
 
 const std = @import("std");
+const ini = @import("zigini");
+const Save = @import("Save.zig");
+const enums = @import("../enums.zig");
+
 var temporary_allocator = std.heap.page_allocator;
 
-const ly_ui = @import("ly-ui");
-const TerminalBuffer = ly_ui.TerminalBuffer;
-const Color = TerminalBuffer.Color;
-const Styling = TerminalBuffer.Styling;
-const ly_core = ly_ui.ly_core;
-const IniParser = ly_core.IniParser;
-const ini = ly_core.ini;
-
-const Config = @import("Config.zig");
-const OldSave = @import("OldSave.zig");
-const SavedUsers = @import("SavedUsers.zig");
-const custom = @import("custom.zig");
-
-const color_properties = [_][]const u8{
-    "bg",
-    "border_fg",
-    "cmatrix_fg",
-    "colormix_col1",
-    "colormix_col2",
-    "colormix_col3",
-    "error_bg",
-    "error_fg",
-    "fg",
-};
-
-var set_color_properties =
-    [_]bool{ false, false, false, false, false, false, false, false, false };
-
-const removed_properties = [_][]const u8{
-    "wayland_specifier",
-    "max_desktop_len",
-    "max_login_len",
-    "max_password_len",
-    "mcookie_cmd",
-    "term_reset_cmd",
-    "term_restore_cursor_cmd",
-    "x_cmd_setup",
-    "wayland_cmd",
-    "console_dev",
-    "load",
-};
-
-pub var auto_eight_colors: bool = true;
-
 pub var maybe_animate: ?bool = null;
 pub var maybe_save_file: ?[]const u8 = null;
 
+pub var mapped_config_fields = false;
+
 pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniField {
     if (std.mem.eql(u8, field.key, "animate")) {
         // The option doesn't exist anymore, but we save its value for "animation"
         maybe_animate = std.mem.eql(u8, field.value, "true");
 
+        mapped_config_fields = true;
         return null;
     }
 
@@ -72,37 +33,16 @@ pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniFie
             else => "none",
         };
 
+        mapped_config_fields = true;
         return mapped_field;
     }
 
-    inline for (color_properties, &set_color_properties) |property, *status| {
-        if (std.mem.eql(u8, field.key, property)) {
-            // Color has been set; it won't be overwritten if we default to eight-color output
-            status.* = true;
-
-            // These options now uses a 32-bit RGB value instead of an arbitrary 16-bit integer
-            // If they're all using eight-color codes, we start in eight-color mode
-            const color = std.fmt.parseInt(u16, field.value, 0) catch {
-                auto_eight_colors = false;
-                return field;
-            };
-
-            const color_no_styling = color & 0x00FF;
-            const styling_only = color & 0xFF00;
-
-            // If color is "greater" than TB_WHITE, or the styling is "greater" than TB_DIM,
-            // we have an invalid color, so do not use eight-color mode
-            if (color_no_styling > 0x0008 or styling_only > 0x8000) auto_eight_colors = false;
-
-            return field;
-        }
-    }
-
     if (std.mem.eql(u8, field.key, "blank_password")) {
         // The option has simply been renamed
         var mapped_field = field;
         mapped_field.key = "clear_password";
 
+        mapped_config_fields = true;
         return mapped_field;
     }
 
@@ -118,6 +58,7 @@ pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniFie
             else => "login",
         };
 
+        mapped_config_fields = true;
         return mapped_field;
     }
 
@@ -125,14 +66,23 @@ pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniFie
         // The option doesn't exist anymore, but we save its value for migration later on
         maybe_save_file = temporary_allocator.dupe(u8, field.value) catch return null;
 
+        mapped_config_fields = true;
         return null;
     }
 
-    inline for (removed_properties) |property| {
+    if (std.mem.eql(u8, field.key, "wayland_specifier") or
-        if (std.mem.eql(u8, field.key, property)) {
+        std.mem.eql(u8, field.key, "max_desktop_len") or
-            // The options don't exist anymore
+        std.mem.eql(u8, field.key, "max_login_len") or
-            return null;
+        std.mem.eql(u8, field.key, "max_password_len") or
-        }
+        std.mem.eql(u8, field.key, "mcookie_cmd") or
+        std.mem.eql(u8, field.key, "term_reset_cmd") or
+        std.mem.eql(u8, field.key, "term_restore_cursor_cmd") or
+        std.mem.eql(u8, field.key, "x_cmd_setup") or
+        std.mem.eql(u8, field.key, "wayland_cmd"))
+    {
+        // The options don't exist anymore
+        mapped_config_fields = true;
+        return null;
     }
 
     if (std.mem.eql(u8, field.key, "bigclock")) {
@@ -140,176 +90,55 @@ pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniFie
         // It also includes the ability to change active bigclock's language
         var mapped_field = field;
 
-        if (std.mem.eql(u8, field.value, "true")) {
+        if (std.mem.eql(u8, field.value, "true")){
             mapped_field.value = "en";
-        } else if (std.mem.eql(u8, field.value, "false")) {
+            mapped_config_fields = true;
+        }else if (std.mem.eql(u8, field.value, "false")){
             mapped_field.value = "none";
+            mapped_config_fields = true;
         }
-
+        
         return mapped_field;
     }
 
-    if (std.mem.eql(u8, field.key, "full_color")) {
-        // If color mode is defined, definitely don't set it automatically
-        auto_eight_colors = false;
-        return field;
-    }
-
-    if (std.mem.eql(u8, field.key, "min_refresh_delta")) {
-        // The option has simply been renamed
-        var mapped_field = field;
-        mapped_field.key = "animation_frame_delay";
-
-        return mapped_field;
-    }
-
-    // TODO: Dearest Melpert,
-    //      I pray this message finds you well, as daylight dwindles and the witching hour
-    //      approaches, I find it more and more imperative as time continues that I place
-    //      this reminder here in such a format that you cannot ignore.
-    //      Do you know how long I have been waiting for this petition to be authorized
-    //      in regards to this particular segment of computerized instructions?
-    //      It has been many a moon since this particular audit has been
-    //      posted regarding the position of handling configurable literature
-    //      apparatuses and plans for a new feature to the configuration
-    //      interface and as time continues onwards I grow more restless
-    //      on the progress of said interface, only to find out afterwards
-    //      that you have PROCRASTINATED on the efforts meant to enhance
-    //      configuration. Thus the requirement for this reminder larger
-    //      compared to the two reminders regarding better methods of
-    //      X termination detection and new usernames with existing
-    //      save files.
-    //
-    //      Thus is my que to leave this TODO at thy request,
-    //
-    //      Forever Sullied,
-    //
-    //      Ly Contributor.
-    //
-    if (std.mem.startsWith(u8, field.header, "cmd:")) {
-        const key = field.header["cmd:".len..];
-        const keyZ = temporary_allocator.dupe(u8, key) catch "";
-        if (!custom.binds.contains(key)) {
-            custom.binds.put(temporary_allocator, keyZ, .{}) catch {};
-        }
-        if (custom.binds.getPtr(keyZ)) |command| {
-            if (std.mem.eql(u8, field.key, "name")) {
-                command.name = temporary_allocator.dupe(u8, field.value) catch "";
-            }
-            if (std.mem.eql(u8, field.key, "cmd")) {
-                command.cmd = temporary_allocator.dupe(u8, field.value) catch "";
-            }
-        }
-    }
-
-    if (std.mem.startsWith(u8, field.header, "lbl:")) {
-        const key = field.header["lbl:".len..];
-        const keyZ = temporary_allocator.dupe(u8, key) catch "";
-        if (!custom.labels.contains(keyZ)) {
-            custom.labels.put(temporary_allocator, keyZ, .{ .name = keyZ }) catch {};
-        }
-        if (custom.labels.getPtr(keyZ)) |label| {
-            if (std.mem.eql(u8, field.key, "cmd")) {
-                label.cmd = temporary_allocator.dupe(u8, field.value) catch "";
-            }
-            if (std.mem.eql(u8, field.key, "refresh")) {
-                label.refresh = std.fmt.parseInt(u32, field.value, 10) catch 0;
-            }
-        }
-    }
-
     return field;
 }
 
 // This is the stuff we only handle after reading the config.
 // For example, the "animate" field could come after "animation"
-pub fn lateConfigFieldHandler(config: *Config) void {
+pub fn lateConfigFieldHandler(animation: *enums.Animation) void {
     if (maybe_animate) |animate| {
-        if (!animate) config.*.animation = .none;
+        if (!animate) animation.* = .none;
-    }
-
-    if (auto_eight_colors) {
-        // Valid config file predates true-color mode
-        // Will use eight-color output instead
-        config.full_color = false;
-
-        // We cannot rely on Config defaults when in eight-color mode,
-        // because they will appear as undesired colors.
-        // Instead set color properties to matching eight-color codes
-        config.doom_top_color = Color.ECOL_RED;
-        config.doom_middle_color = Color.ECOL_YELLOW;
-        config.doom_bottom_color = Color.ECOL_WHITE;
-        config.cmatrix_head_col = Styling.BOLD | Color.ECOL_WHITE;
-
-        // These may be in the config, so only change those which were not set
-        if (!set_color_properties[0]) config.bg = Color.DEFAULT;
-        if (!set_color_properties[1]) config.border_fg = Color.ECOL_WHITE;
-        if (!set_color_properties[2]) config.cmatrix_fg = Color.ECOL_GREEN;
-        if (!set_color_properties[3]) config.colormix_col1 = Color.ECOL_RED;
-        if (!set_color_properties[4]) config.colormix_col2 = Color.ECOL_BLUE;
-        if (!set_color_properties[5]) config.colormix_col3 = Color.ECOL_BLACK;
-        if (!set_color_properties[6]) config.error_bg = Color.DEFAULT;
-        if (!set_color_properties[7]) config.error_fg = Styling.BOLD | Color.ECOL_RED;
-        if (!set_color_properties[8]) config.fg = Color.ECOL_WHITE;
     }
 }
 
-pub fn tryMigrateIniSaveFile(allocator: std.mem.Allocator, io: std.Io, path: []const u8, saved_users: *SavedUsers, usernames: [][]const u8) !?IniParser(OldSave) {
+pub fn tryMigrateSaveFile(user_buf: *[32]u8) Save {
-    var save_parser = try IniParser(OldSave).init(allocator, io, path, null);
+    var save = Save{};
-    errdefer save_parser.deinit();
 
-    var user_buf: [32]u8 = undefined;
-    const maybe_save = if (save_parser.maybe_load_error == null) save_parser.structure else tryMigrateFirstSaveFile(io, &user_buf);
-
-    if (maybe_save) |save| {
-        // Add all other users to the list
-        for (usernames, 0..) |username, i| {
-            if (save.user) |user| {
-                if (std.mem.eql(u8, user, username)) saved_users.last_username_index = i;
-            }
-
-            try saved_users.user_list.append(allocator, .{
-                .username = username,
-                .session_index = save.session_index orelse 0,
-                .first_run = false,
-                .allocated_username = false,
-            });
-        }
-
-        return save_parser;
-    }
-
-    return null;
-}
-
-fn tryMigrateFirstSaveFile(io: std.Io, user_buf: *[32]u8) ?OldSave {
     if (maybe_save_file) |path| {
         defer temporary_allocator.free(path);
 
-        var save = OldSave{};
+        var file = std.fs.openFileAbsolute(path, .{}) catch return save;
-        var file = std.Io.Dir.openFileAbsolute(io, path, .{}) catch return null;
+        defer file.close();
-        defer file.close(io);
 
-        var file_buffer: [64]u8 = undefined;
+        const reader = file.reader();
-        var file_reader = file.reader(io, &file_buffer);
-        var reader = &file_reader.interface;
 
-        var user_writer = std.Io.Writer.fixed(user_buf);
+        var user_fbs = std.io.fixedBufferStream(user_buf);
-        var written = reader.streamDelimiter(&user_writer, '\n') catch return null;
+        reader.streamUntilDelimiter(user_fbs.writer(), '\n', user_buf.len) catch return save;
-        if (written > 0) save.user = user_buf[0..written];
+        const user = user_fbs.getWritten();
+        if (user.len > 0) save.user = user;
 
         var session_buf: [20]u8 = undefined;
-        var session_writer = std.Io.Writer.fixed(&session_buf);
+        var session_fbs = std.io.fixedBufferStream(&session_buf);
-        written = reader.streamDelimiter(&session_writer, '\n') catch return null;
+        reader.streamUntilDelimiter(session_fbs.writer(), '\n', session_buf.len) catch return save;
 
+        const session_index_str = session_fbs.getWritten();
         var session_index: ?usize = null;
-        if (written > 0) {
+        if (session_index_str.len > 0) {
-            session_index = std.fmt.parseUnsigned(usize, session_buf[0..written], 10) catch return null;
+            session_index = std.fmt.parseUnsigned(usize, session_index_str, 10) catch return save;
         }
         save.session_index = session_index;
-
-        return save;
     }
 
-    return null;
+    return save;
 }

src/enums.zig

@@ -1,12 +1,7 @@
-const std = @import("std");
-
 pub const Animation = enum {
     none,
     doom,
     matrix,
-    colormix,
-    gameoflife,
-    dur_file,
 };
 
 pub const DisplayServer = enum {
@@ -14,7 +9,6 @@ pub const DisplayServer = enum {
     shell,
     xinitrc,
     x11,
-    custom,
 };
 
 pub const Input = enum {
@@ -22,26 +16,6 @@ pub const Input = enum {
     session,
     login,
     password,
-
-    /// Moves the current Input forwards by one entry. If `reverse`, then the Input
-    /// moves backwards. If `wrap` is true, then the entry will wrap back around
-    pub fn move(self: *Input, reverse: bool, wrap: bool) void {
-        const maxNum = @typeInfo(Input).@"enum".fields.len - 1;
-        const selfNum = @intFromEnum(self.*);
-        if (reverse) {
-            if (wrap) {
-                self.* = @enumFromInt(selfNum -% 1);
-            } else if (selfNum != 0) {
-                self.* = @enumFromInt(selfNum - 1);
-            }
-        } else {
-            if (wrap) {
-                self.* = @enumFromInt(selfNum +% 1);
-            } else if (selfNum != maxNum) {
-                self.* = @enumFromInt(selfNum + 1);
-            }
-        }
-    }
 };
 
 pub const ViMode = enum {
@@ -53,16 +27,4 @@ pub const Bigclock = enum {
     none,
     en,
     fa,
-};
+};
-
-pub const DurOffsetAlignment = enum {
-    topleft,
-    topcenter,
-    topright,
-    centerleft,
-    center,
-    centerright,
-    bottomleft,
-    bottomcenter,
-    bottomright,
-};

src/interop.zig

@@ -0,0 +1,111 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Allocator = std.mem.Allocator;
+
+pub const termbox = @import("termbox2");
+
+pub const pam = @cImport({
+    @cInclude("security/pam_appl.h");
+});
+
+pub const utmp = @cImport({
+    @cInclude("utmpx.h");
+});
+
+// Exists for X11 support only
+pub const xcb = @cImport({
+    @cInclude("xcb/xcb.h");
+});
+
+pub const unistd = @cImport({
+    @cInclude("unistd.h");
+});
+
+pub const time = @cImport({
+    @cInclude("time.h");
+});
+
+pub const system_time = @cImport({
+    @cInclude("sys/time.h");
+});
+
+pub const stdlib = @cImport({
+    @cInclude("stdlib.h");
+});
+
+pub const pwd = @cImport({
+    @cInclude("pwd.h");
+    // We include a FreeBSD-specific header here since login_cap.h references
+    // the passwd struct directly, so we can't import it separately'
+    if (builtin.os.tag == .freebsd) @cInclude("login_cap.h");
+});
+
+pub const grp = @cImport({
+    @cInclude("grp.h");
+});
+
+// BSD-specific headers
+pub const kbio = @cImport({
+    @cInclude("sys/kbio.h");
+});
+
+// Linux-specific headers
+pub const kd = @cImport({
+    @cInclude("sys/kd.h");
+});
+
+pub const vt = @cImport({
+    @cInclude("sys/vt.h");
+});
+
+// Used for getting & setting the lock state
+const LedState = if (builtin.os.tag.isBSD()) c_int else c_char;
+const get_led_state = if (builtin.os.tag.isBSD()) kbio.KDGETLED else kd.KDGKBLED;
+const set_led_state = if (builtin.os.tag.isBSD()) kbio.KDSETLED else kd.KDSKBLED;
+const numlock_led = if (builtin.os.tag.isBSD()) kbio.LED_NUM else kd.K_NUMLOCK;
+const capslock_led = if (builtin.os.tag.isBSD()) kbio.LED_CAP else kd.K_CAPSLOCK;
+
+pub fn timeAsString(buf: [:0]u8, format: [:0]const u8) ![]u8 {
+    const timer = std.time.timestamp();
+    const tm_info = time.localtime(&timer);
+
+    const len = time.strftime(buf, buf.len, format, tm_info);
+    if (len < 0) return error.CannotGetFormattedTime;
+
+    return buf[0..len];
+}
+
+pub fn switchTty(console_dev: []const u8, tty: u8) !void {
+    const fd = try std.posix.open(console_dev, .{ .ACCMODE = .WRONLY }, 0);
+    defer std.posix.close(fd);
+
+    _ = std.c.ioctl(fd, vt.VT_ACTIVATE, tty);
+    _ = std.c.ioctl(fd, vt.VT_WAITACTIVE, tty);
+}
+
+pub fn getLockState(console_dev: []const u8) !struct {
+    numlock: bool,
+    capslock: bool,
+} {
+    const fd = try std.posix.open(console_dev, .{ .ACCMODE = .RDONLY }, 0);
+    defer std.posix.close(fd);
+
+    var led: LedState = undefined;
+    _ = std.c.ioctl(fd, get_led_state, &led);
+
+    return .{
+        .numlock = (led & numlock_led) != 0,
+        .capslock = (led & capslock_led) != 0,
+    };
+}
+
+pub fn setNumlock(val: bool) !void {
+    var led: LedState = undefined;
+    _ = std.c.ioctl(0, get_led_state, &led);
+
+    const numlock = (led & numlock_led) != 0;
+    if (numlock != val) {
+        const status = std.c.ioctl(std.posix.STDIN_FILENO, set_led_state, led ^ numlock_led);
+        if (status != 0) return error.FailedToSetNumlock;
+    }
+}

src/tui/TerminalBuffer.zig

@@ -0,0 +1,199 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const interop = @import("../interop.zig");
+const utils = @import("utils.zig");
+const Config = @import("../config/Config.zig");
+
+const Random = std.Random;
+
+const termbox = interop.termbox;
+
+const TerminalBuffer = @This();
+
+random: Random,
+width: usize,
+height: usize,
+buffer: [*]termbox.tb_cell,
+fg: u16,
+bg: u16,
+border_fg: u16,
+box_chars: struct {
+    left_up: u32,
+    left_down: u32,
+    right_up: u32,
+    right_down: u32,
+    top: u32,
+    bottom: u32,
+    left: u32,
+    right: u32,
+},
+labels_max_length: usize,
+box_x: usize,
+box_y: usize,
+box_width: usize,
+box_height: usize,
+margin_box_v: u8,
+margin_box_h: u8,
+
+pub fn init(config: Config, labels_max_length: usize, random: Random) TerminalBuffer {
+    return .{
+        .random = random,
+        .width = @intCast(termbox.tb_width()),
+        .height = @intCast(termbox.tb_height()),
+        .buffer = termbox.tb_cell_buffer(),
+        .fg = config.fg,
+        .bg = config.bg,
+        .border_fg = config.border_fg,
+        .box_chars = if (builtin.os.tag == .linux or builtin.os.tag.isBSD()) .{
+            .left_up = 0x250C,
+            .left_down = 0x2514,
+            .right_up = 0x2510,
+            .right_down = 0x2518,
+            .top = 0x2500,
+            .bottom = 0x2500,
+            .left = 0x2502,
+            .right = 0x2502,
+        } else .{
+            .left_up = '+',
+            .left_down = '+',
+            .right_up = '+',
+            .right_down = '+',
+            .top = '-',
+            .bottom = '-',
+            .left = '|',
+            .right = '|',
+        },
+        .labels_max_length = labels_max_length,
+        .box_x = 0,
+        .box_y = 0,
+        .box_width = (2 * config.margin_box_h) + config.input_len + 1 + labels_max_length,
+        .box_height = 7 + (2 * config.margin_box_v),
+        .margin_box_v = config.margin_box_v,
+        .margin_box_h = config.margin_box_h,
+    };
+}
+
+pub fn cascade(self: TerminalBuffer) bool {
+    var changed = false;
+    var y = self.height - 2;
+
+    while (y > 0) : (y -= 1) {
+        for (0..self.width) |x| {
+            const cell = self.buffer[(y - 1) * self.width + x];
+            const cell_under = self.buffer[y * self.width + x];
+
+            const char: u8 = @truncate(cell.ch);
+            if (std.ascii.isWhitespace(char)) continue;
+
+            const char_under: u8 = @truncate(cell_under.ch);
+            if (!std.ascii.isWhitespace(char_under)) continue;
+
+            changed = true;
+
+            if ((self.random.int(u16) % 10) > 7) continue;
+
+            _ = termbox.tb_set_cell(@intCast(x), @intCast(y), cell.ch, cell.fg, cell.bg);
+            _ = termbox.tb_set_cell(@intCast(x), @intCast(y - 1), ' ', cell_under.fg, cell_under.bg);
+        }
+    }
+
+    return changed;
+}
+
+pub fn drawBoxCenter(self: *TerminalBuffer, show_borders: bool, blank_box: bool) void {
+    if (self.width < 2 or self.height < 2) return;
+    const x1 = (self.width - @min(self.width - 2, self.box_width)) / 2;
+    const y1 = (self.height - @min(self.height - 2, self.box_height)) / 2;
+    const x2 = (self.width + @min(self.width, self.box_width)) / 2;
+    const y2 = (self.height + @min(self.height, self.box_height)) / 2;
+
+    self.box_x = x1;
+    self.box_y = y1;
+
+    if (show_borders) {
+        _ = termbox.tb_set_cell(@intCast(x1 - 1), @intCast(y1 - 1), self.box_chars.left_up, self.border_fg, self.bg);
+        _ = termbox.tb_set_cell(@intCast(x2), @intCast(y1 - 1), self.box_chars.right_up, self.border_fg, self.bg);
+        _ = termbox.tb_set_cell(@intCast(x1 - 1), @intCast(y2), self.box_chars.left_down, self.border_fg, self.bg);
+        _ = termbox.tb_set_cell(@intCast(x2), @intCast(y2), self.box_chars.right_down, self.border_fg, self.bg);
+
+        var c1 = utils.initCell(self.box_chars.top, self.border_fg, self.bg);
+        var c2 = utils.initCell(self.box_chars.bottom, self.border_fg, self.bg);
+
+        for (0..self.box_width) |i| {
+            utils.putCell(x1 + i, y1 - 1, c1);
+            utils.putCell(x1 + i, y2, c2);
+        }
+
+        c1.ch = self.box_chars.left;
+        c2.ch = self.box_chars.right;
+
+        for (0..self.box_height) |i| {
+            utils.putCell(x1 - 1, y1 + i, c1);
+            utils.putCell(x2, y1 + i, c2);
+        }
+    }
+
+    if (blank_box) {
+        const blank = utils.initCell(' ', self.fg, self.bg);
+
+        for (0..self.box_height) |y| {
+            for (0..self.box_width) |x| {
+                utils.putCell(x1 + x, y1 + y, blank);
+            }
+        }
+    }
+}
+
+pub fn calculateComponentCoordinates(self: TerminalBuffer) struct {
+    start_x: usize,
+    x: usize,
+    y: usize,
+    full_visible_length: usize,
+    visible_length: usize,
+} {
+    const start_x = self.box_x + self.margin_box_h;
+    const x = start_x + self.labels_max_length + 1;
+    const y = self.box_y + self.margin_box_v;
+    const full_visible_length = self.box_x + self.box_width - self.margin_box_h - start_x;
+    const visible_length = self.box_x + self.box_width - self.margin_box_h - x;
+
+    return .{
+        .start_x = start_x,
+        .x = x,
+        .y = y,
+        .full_visible_length = full_visible_length,
+        .visible_length = visible_length,
+    };
+}
+
+pub fn drawLabel(self: TerminalBuffer, text: []const u8, x: usize, y: usize) void {
+    drawColorLabel(text, x, y, self.fg, self.bg);
+}
+
+pub fn drawColorLabel(text: []const u8, x: usize, y: usize, fg: u16, bg: u16) void {
+    const yc: c_int = @intCast(y);
+    const utf8view = std.unicode.Utf8View.init(text) catch return;
+    var utf8 = utf8view.iterator();
+
+    var i = x;
+    while (utf8.nextCodepoint()) |codepoint| : (i += 1) {
+        _ = termbox.tb_set_cell(@intCast(i), yc, codepoint, fg, bg);
+    }
+}
+
+pub fn drawConfinedLabel(self: TerminalBuffer, text: []const u8, x: usize, y: usize, max_length: usize) void {
+    const yc: c_int = @intCast(y);
+    const utf8view = std.unicode.Utf8View.init(text) catch return;
+    var utf8 = utf8view.iterator();
+
+    var i: usize = 0;
+    while (utf8.nextCodepoint()) |codepoint| : (i += 1) {
+        if (i >= max_length) break;
+        _ = termbox.tb_set_cell(@intCast(i + x), yc, codepoint, self.fg, self.bg);
+    }
+}
+
+pub fn drawCharMultiple(self: TerminalBuffer, char: u8, x: usize, y: usize, length: usize) void {
+    const cell = utils.initCell(char, self.fg, self.bg);
+    for (0..length) |xx| utils.putCell(x + xx, y, cell);
+}

src/tui/components/InfoLine.zig

@@ -0,0 +1,61 @@
+const std = @import("std");
+const TerminalBuffer = @import("../TerminalBuffer.zig");
+const generic = @import("generic.zig");
+const utils = @import("../utils.zig");
+
+const Allocator = std.mem.Allocator;
+
+const MessageLabel = generic.CyclableLabel(Message);
+
+const InfoLine = @This();
+
+const Message = struct {
+    width: u8,
+    text: []const u8,
+    bg: u16,
+    fg: u16,
+};
+
+label: MessageLabel,
+
+pub fn init(allocator: Allocator, buffer: *TerminalBuffer) InfoLine {
+    return .{
+        .label = MessageLabel.init(allocator, buffer, drawItem),
+    };
+}
+
+pub fn deinit(self: InfoLine) void {
+    self.label.deinit();
+}
+
+pub fn addMessage(self: *InfoLine, text: []const u8, bg: u16, fg: u16) !void {
+    if (text.len == 0) return;
+
+    try self.label.addItem(.{
+        .width = try utils.strWidth(text),
+        .text = text,
+        .bg = bg,
+        .fg = fg,
+    });
+}
+
+pub fn clearRendered(allocator: Allocator, buffer: TerminalBuffer) !void {
+    // Draw over the area
+    const y = buffer.box_y + buffer.margin_box_v;
+    const spaces = try allocator.alloc(u8, buffer.box_width);
+    defer allocator.free(spaces);
+
+    @memset(spaces, ' ');
+
+    buffer.drawLabel(spaces, buffer.box_x, y);
+}
+
+fn drawItem(label: *MessageLabel, message: Message, _: usize, _: usize) bool {
+    if (message.width == 0 or label.buffer.box_width <= message.width) return false;
+
+    const x = label.buffer.box_x + ((label.buffer.box_width - message.width) / 2);
+    label.first_char_x = x + message.width;
+
+    TerminalBuffer.drawColorLabel(message.text, x, label.y, message.fg, message.bg);
+    return true;
+}

src/tui/components/Session.zig

@@ -0,0 +1,142 @@
+const std = @import("std");
+const TerminalBuffer = @import("../TerminalBuffer.zig");
+const enums = @import("../../enums.zig");
+const generic = @import("generic.zig");
+const Ini = @import("zigini").Ini;
+const Lang = @import("../../config/Lang.zig");
+
+const Allocator = std.mem.Allocator;
+
+const DisplayServer = enums.DisplayServer;
+
+const EnvironmentLabel = generic.CyclableLabel(Environment);
+
+const Session = @This();
+
+pub const Environment = struct {
+    entry_ini: ?Ini(Entry) = null,
+    name: [:0]const u8 = "",
+    xdg_session_desktop: ?[:0]const u8 = null,
+    xdg_desktop_names: ?[:0]const u8 = null,
+    cmd: []const u8 = "",
+    specifier: []const u8 = "",
+    display_server: DisplayServer = .wayland,
+};
+
+const DesktopEntry = struct {
+    Exec: []const u8 = "",
+    Name: [:0]const u8 = "",
+    DesktopNames: ?[:0]u8 = null,
+};
+
+pub const Entry = struct { @"Desktop Entry": DesktopEntry = .{} };
+
+label: EnvironmentLabel,
+lang: Lang,
+
+pub fn init(allocator: Allocator, buffer: *TerminalBuffer, lang: Lang) Session {
+    return .{
+        .label = EnvironmentLabel.init(allocator, buffer, drawItem),
+        .lang = lang,
+    };
+}
+
+pub fn deinit(self: Session) void {
+    for (self.label.list.items) |*environment| {
+        if (environment.entry_ini) |*entry_ini| entry_ini.deinit();
+        if (environment.xdg_session_desktop) |session_desktop| self.label.allocator.free(session_desktop);
+    }
+
+    self.label.deinit();
+}
+
+pub fn addEnvironment(self: *Session, entry: DesktopEntry, xdg_session_desktop: ?[:0]const u8, display_server: DisplayServer) !void {
+    var xdg_desktop_names: ?[:0]const u8 = null;
+    if (entry.DesktopNames) |desktop_names| {
+        for (desktop_names) |*c| {
+            if (c.* == ';') c.* = ':';
+        }
+        xdg_desktop_names = desktop_names;
+    }
+
+    try self.label.addItem(.{
+        .entry_ini = null,
+        .name = entry.Name,
+        .xdg_session_desktop = xdg_session_desktop,
+        .xdg_desktop_names = xdg_desktop_names,
+        .cmd = entry.Exec,
+        .specifier = switch (display_server) {
+            .wayland => self.lang.wayland,
+            .x11 => self.lang.x11,
+            else => self.lang.other,
+        },
+        .display_server = display_server,
+    });
+}
+
+pub fn addEnvironmentWithIni(self: *Session, entry_ini: Ini(Entry), xdg_session_desktop: ?[:0]const u8, display_server: DisplayServer) !void {
+    const entry = entry_ini.data.@"Desktop Entry";
+    var xdg_desktop_names: ?[:0]const u8 = null;
+    if (entry.DesktopNames) |desktop_names| {
+        for (desktop_names) |*c| {
+            if (c.* == ';') c.* = ':';
+        }
+        xdg_desktop_names = desktop_names;
+    }
+
+    try self.label.addItem(.{
+        .entry_ini = entry_ini,
+        .name = entry.Name,
+        .xdg_session_desktop = xdg_session_desktop,
+        .xdg_desktop_names = xdg_desktop_names,
+        .cmd = entry.Exec,
+        .specifier = switch (display_server) {
+            .wayland => self.lang.wayland,
+            .x11 => self.lang.x11,
+            else => self.lang.other,
+        },
+        .display_server = display_server,
+    });
+}
+
+pub fn crawl(self: *Session, path: []const u8, display_server: DisplayServer) !void {
+    var iterable_directory = std.fs.openDirAbsolute(path, .{ .iterate = true }) catch return;
+    defer iterable_directory.close();
+
+    var iterator = iterable_directory.iterate();
+    while (try iterator.next()) |item| {
+        if (!std.mem.eql(u8, std.fs.path.extension(item.name), ".desktop")) continue;
+
+        const entry_path = try std.fmt.allocPrint(self.label.allocator, "{s}/{s}", .{ path, item.name });
+        defer self.label.allocator.free(entry_path);
+        var entry_ini = Ini(Entry).init(self.label.allocator);
+        _ = try entry_ini.readFileToStruct(entry_path, "#", null);
+        errdefer entry_ini.deinit();
+
+        var xdg_session_desktop: []const u8 = undefined;
+        const maybe_desktop_names = entry_ini.data.@"Desktop Entry".DesktopNames;
+        if (maybe_desktop_names) |desktop_names| {
+            xdg_session_desktop = std.mem.sliceTo(desktop_names, ';');
+        } else {
+            // if DesktopNames is empty, we'll take the name of the session file
+            xdg_session_desktop = std.fs.path.stem(item.name);
+        }
+
+        const session_desktop = try self.label.allocator.dupeZ(u8, xdg_session_desktop);
+        errdefer self.label.allocator.free(session_desktop);
+
+        try self.addEnvironmentWithIni(entry_ini, session_desktop, display_server);
+    }
+}
+
+fn drawItem(label: *EnvironmentLabel, environment: Environment, x: usize, y: usize) bool {
+    const length = @min(environment.name.len, label.visible_length - 3);
+    if (length == 0) return false;
+
+    const nx = if (label.text_in_center) (label.x + (label.visible_length - environment.name.len) / 2) else (label.x + 2);
+    label.first_char_x = nx + environment.name.len;
+
+    label.buffer.drawLabel(environment.specifier, x, y);
+    label.buffer.drawLabel(environment.name, nx, label.y);
+    return true;
+}