initial commit

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.gitignore

@@ -0,0 +1,18 @@
+# This file is for zig-specific build artifacts.
+# If you have OS-specific or editor-specific files to ignore,
+# such as *.swp or .DS_Store, put those in your global
+# ~/.gitignore and put this in your ~/.gitconfig:
+#
+# [core]
+#     excludesfile = ~/.gitignore
+#
+# Cheers!
+# -andrewrk
+
+zig-cache/
+zig-out/
+/release/
+/debug/
+/build/
+/build-*/
+/docgen_tmp/

build.zig

@@ -0,0 +1,70 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "default",
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const unit_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_unit_tests = b.addRunArtifact(unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_unit_tests.step);
+}

flake.lock

@@ -0,0 +1,78 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1706063522,
+        "narHash": "sha256-o1m9en7ovSjyktXgX3n/6GJEwG06WYa/9Mfx5hTTf5g=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "95c1439b205d507f3cb88aae76e02cd6a01ac504",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "zig2nix": "zig2nix"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "zig2nix": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1710206277,
+        "narHash": "sha256-LHQaQsSaH6IZ1YPF25gMWxFK7DWOn1wMkdH5WQNvEvU=",
+        "owner": "Cloudef",
+        "repo": "zig2nix",
+        "rev": "a9b2a0546e6dc330042aa5d19269ab9c1cb6fb5f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Cloudef",
+        "repo": "zig2nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,82 @@
+{
+  description = "Zig project flake";
+
+  inputs = {
+    zig2nix.url = "github:Cloudef/zig2nix";
+  };
+
+  outputs = { zig2nix, ... }: let
+    flake-utils = zig2nix.inputs.flake-utils;
+  in (flake-utils.lib.eachDefaultSystem (system: let
+      # Zig flake helper
+      # Check the flake.nix in zig2nix project for more options:
+      # <https://github.com/Cloudef/zig2nix/blob/master/flake.nix>
+      env = zig2nix.outputs.zig-env.${system} {};
+      system-triple = env.lib.zigTripleFromString system;
+    in with builtins; with env.lib; with env.pkgs.lib; rec {
+      # nix build .#target.{zig-target}
+      # e.g. nix build .#target.x86_64-linux-gnu
+      packages.target = genAttrs allTargetTriples (target: env.packageForTarget target ({
+        src = cleanSource ./.;
+
+        nativeBuildInputs = with env.pkgs; [];
+        buildInputs = with env.pkgsForTarget target; [];
+
+        # Smaller binaries and avoids shipping glibc.
+        zigPreferMusl = true;
+
+        # This disables LD_LIBRARY_PATH mangling, binary patching etc...
+        # The package won't be usable inside nix.
+        zigDisableWrap = true;
+      } // optionalAttrs (!pathExists ./build.zig.zon) {
+        pname = "my-zig-project";
+        version = "0.0.0";
+      }));
+
+      # nix build .
+      packages.default = packages.target.${system-triple}.override {
+        # Prefer nix friendly settings.
+        zigPreferMusl = false;
+        zigDisableWrap = false;
+      };
+
+      # For bundling with nix bundle for running outside of nix
+      # example: https://github.com/ralismark/nix-appimage
+      apps.bundle.target = genAttrs allTargetTriples (target: let
+        pkg = packages.target.${target};
+      in {
+        type = "app";
+        program = "${pkg}/bin/default";
+      });
+
+      # default bundle
+      apps.bundle.default = apps.bundle.target.${system-triple};
+
+      # nix run .
+      apps.default = env.app [] "zig build run -- \"$@\"";
+
+      # nix run .#build
+      apps.build = env.app [] "zig build \"$@\"";
+
+      # nix run .#test
+      apps.test = env.app [] "zig build test -- \"$@\"";
+
+      # nix run .#docs
+      apps.docs = env.app [] "zig build docs -- \"$@\"";
+
+      # nix run .#deps
+      apps.deps = env.showExternalDeps;
+
+      # nix run .#zon2json
+      apps.zon2json = env.app [env.zon2json] "zon2json \"$@\"";
+
+      # nix run .#zon2json-lock
+      apps.zon2json-lock = env.app [env.zon2json-lock] "zon2json-lock \"$@\"";
+
+      # nix run .#zon2nix
+      apps.zon2nix = env.app [env.zon2nix] "zon2nix \"$@\"";
+
+      # nix develop
+      devShells.default = env.mkShell {};
+    }));
+}

result

@@ -0,0 +1 @@
+/nix/store/lj5v0m03905nm4v3n1ln8q8hj50hlm69-my-zig-project-0.0.0

src/main.zig

@@ -0,0 +1,50 @@
+const std = @import("std");
+const io = std.io;
+const heap = std.heap;
+const json = std.json;
+
+const battery = @import("modules/battery.zig");
+const calendar = @import("modules/calendar.zig");
+const display = @import("modules/display.zig");
+const uptime = @import("modules/uptime.zig");
+const Module = @import("module.zig");
+
+pub fn main() !void {
+    var arena = heap.ArenaAllocator.init(heap.page_allocator);
+    defer arena.deinit();
+
+    const stdout_file = std.io.getStdOut().writer();
+    var bw = std.io.bufferedWriter(stdout_file);
+    const stdout = bw.writer();
+
+    try stdout.print("{{\"version\":1}}\n[\n", .{});
+    try bw.flush();
+
+    var _display = display.init(arena.allocator());
+    var _battery = battery.init(arena.allocator());
+    var _calendar = calendar.init(arena.allocator());
+    var modules = [_]Module{
+        _display.module,
+        _battery.module,
+        _calendar.module,
+    };
+
+    while (true) {
+        try stdout.print("[", .{});
+        for (modules) |module| {
+            try json.stringify(try module.getJson(), .{ .emit_null_optional_fields = false }, stdout);
+            try stdout.print(",", .{});
+        }
+        // try stdout.print("[", .{});
+        // try json.stringify(battery_json, .{ .emit_null_optional_fields = false }, stdout);
+        // try stdout.print(",", .{});
+        // try json.stringify(calendar_json, .{ .emit_null_optional_fields = false }, stdout);
+        // try stdout.print(",", .{});
+        // try stdout.print("{{\"full_text\":\"test\"}}", .{});
+        try stdout.print("],\n", .{});
+
+        try bw.flush();
+        _ = arena.reset(.retain_capacity);
+        std.time.sleep(1000_000_000);
+    }
+}

src/module.zig

@@ -0,0 +1,30 @@
+const std = @import("std");
+
+pub const JSON = struct {
+    full_text: []const u8,
+    short_text: ?[]const u8 = null,
+    color: ?[]const u8 = null,
+    background: ?[]const u8 = null,
+    border: ?[]const u8 = null,
+    border_top: ?u16 = null,
+    border_right: ?u16 = null,
+    border_bottom: ?u16 = null,
+    border_left: ?u16 = null,
+    min_width: ?u16 = null,
+    @"align": ?[]const u8 = null,
+    name: ?[]const u8 = null,
+    instance: ?[]const u8 = null,
+    urgent: ?bool = null,
+    separator: ?bool = null,
+    separator_block_width: ?u16 = null,
+    markup: ?[]const u8 = null,
+};
+
+const Self = @This();
+
+allocator: std.mem.Allocator,
+getJsonFn: *const fn (*const Self) anyerror!JSON,
+
+pub fn getJson(self: *const Self) anyerror!JSON {
+    return self.getJsonFn(self);
+}

src/modules/battery.zig

@@ -0,0 +1,45 @@
+const std = @import("std");
+const Module = @import("../module.zig");
+const Self = @This();
+
+module: Module,
+
+pub fn init(allocator: std.mem.Allocator) Self {
+    return .{
+        .module = .{
+            .allocator = allocator,
+            .getJsonFn = getJson,
+        },
+    };
+}
+
+pub fn getJson(module: *const Module) !Module.JSON {
+    const self = @fieldParentPtr(Self, "module", module);
+
+    var energy_full_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/energy_full", .{});
+    defer energy_full_file.close();
+    var energy_now_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/energy_now", .{});
+    defer energy_now_file.close();
+    var status_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/status", .{});
+    defer status_file.close();
+
+    const energy_full_string = try energy_full_file.reader().readAllAlloc(self.module.allocator, 32);
+    const energy_now_string = try energy_now_file.reader().readAllAlloc(self.module.allocator, 32);
+    const status_string = try status_file.reader().readAllAlloc(self.module.allocator, 32);
+    const energy_full = try std.fmt.parseInt(u32, energy_full_string[0 .. energy_full_string.len - 1], 10);
+    const energy_now = try std.fmt.parseInt(u32, energy_now_string[0 .. energy_now_string.len - 1], 10);
+
+    const status = if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Full"))
+        "="
+    else if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Discharging"))
+        "v"
+    else if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Charging"))
+        "^"
+    else
+        "?";
+    const percent_left = @as(f32, @floatFromInt(energy_now)) / @as(f32, @floatFromInt(energy_full)) * 100;
+
+    return .{
+        .full_text = try std.fmt.allocPrint(self.module.allocator, "{s} {d:.2}%", .{ status, percent_left }),
+    };
+}

src/modules/calendar.zig

@@ -0,0 +1,42 @@
+const std = @import("std");
+const Module = @import("../module.zig");
+const Self = @This();
+
+module: Module,
+
+pub fn init(allocator: std.mem.Allocator) Self {
+    return .{
+        .module = .{
+            .allocator = allocator,
+            .getJsonFn = getJson,
+        },
+    };
+}
+
+pub fn getJson(module: *const Module) !Module.JSON {
+    const self = @fieldParentPtr(Self, "module", module);
+    var tz_file = try std.fs.openFileAbsolute("/etc/localtime", .{});
+    defer tz_file.close();
+    var tz = try std.tz.Tz.parse(self.module.allocator, tz_file.reader());
+    defer tz.deinit();
+    // std.debug.print("{any}\n", .{tz.timetypes});
+
+    const timestamp = std.time.timestamp() + tz.timetypes[tz.timetypes.len - 1].offset + std.time.s_per_day;
+
+    const epoch_seconds = std.time.epoch.EpochSeconds{ .secs = @intCast(timestamp) };
+    const day_seconds = epoch_seconds.getDaySeconds();
+    const epoch_day = epoch_seconds.getEpochDay();
+    const year_day = epoch_day.calculateYearDay();
+    const month_day = year_day.calculateMonthDay();
+
+    return .{
+        .full_text = try std.fmt.allocPrint(self.module.allocator, "{d}-{d:0>2}-{d:0>2} {d:0>2}:{d:0>2}:{d:0>2}", .{
+            year_day.year,
+            @intFromEnum(month_day.month),
+            month_day.day_index,
+            day_seconds.getHoursIntoDay(),
+            day_seconds.getMinutesIntoHour(),
+            day_seconds.getSecondsIntoMinute(),
+        }),
+    };
+}

src/modules/display.zig

@@ -0,0 +1,34 @@
+const std = @import("std");
+const Module = @import("../module.zig");
+const Self = @This();
+
+module: Module,
+
+pub fn init(allocator: std.mem.Allocator) Self {
+    return .{
+        .module = .{
+            .allocator = allocator,
+            .getJsonFn = getJson,
+        },
+    };
+}
+
+pub fn getJson(module: *const Module) !Module.JSON {
+    const self = @fieldParentPtr(Self, "module", module);
+
+    var brightness_full_file = try std.fs.openFileAbsolute("/sys/class/backlight/acpi_video0/max_brightness", .{});
+    defer brightness_full_file.close();
+    var brightness_now_file = try std.fs.openFileAbsolute("/sys/class/backlight/acpi_video0/actual_brightness", .{});
+    defer brightness_now_file.close();
+
+    const brightness_full_string = try brightness_full_file.reader().readAllAlloc(self.module.allocator, 32);
+    const brightness_now_string = try brightness_now_file.reader().readAllAlloc(self.module.allocator, 32);
+    const brightness_full = try std.fmt.parseInt(u32, brightness_full_string[0 .. brightness_full_string.len - 1], 10);
+    const brightness_now = try std.fmt.parseInt(u32, brightness_now_string[0 .. brightness_now_string.len - 1], 10);
+
+    const percent = @as(f32, @floatFromInt(brightness_now)) / @as(f32, @floatFromInt(brightness_full)) * 100;
+
+    return .{
+        .full_text = try std.fmt.allocPrint(self.module.allocator, "{d:.2}%", .{percent}),
+    };
+}

src/modules/uptime.zig

@@ -0,0 +1,45 @@
+const std = @import("std");
+const Module = @import("../module.zig");
+const Self = @This();
+
+module: Module,
+
+pub fn init(allocator: std.mem.Allocator) Module {
+    return .{
+        .module = .{
+            .allocator = allocator,
+            .getJsonFn = getJson,
+        },
+    };
+}
+
+pub fn getJson(module: *const Module) !Module.JSON {
+    const self = @fieldParentPtr(Self, "module", module);
+
+    var energy_full_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/energy_full", .{});
+    defer energy_full_file.close();
+    var energy_now_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/energy_now", .{});
+    defer energy_now_file.close();
+    var status_file = try std.fs.openFileAbsolute("/sys/class/power_supply/BAT0/status", .{});
+    defer status_file.close();
+
+    const energy_full_string = try energy_full_file.reader().readAllAlloc(self.module.allocator, 32);
+    const energy_now_string = try energy_now_file.reader().readAllAlloc(self.module.allocator, 32);
+    const status_string = try status_file.reader().readAllAlloc(self.module.allocator, 32);
+    const energy_full = try std.fmt.parseInt(u32, energy_full_string[0 .. energy_full_string.len - 1], 10);
+    const energy_now = try std.fmt.parseInt(u32, energy_now_string[0 .. energy_now_string.len - 1], 10);
+
+    const status = if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Full"))
+        "="
+    else if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Discharging"))
+        "v"
+    else if (std.mem.eql(u8, status_string[0 .. status_string.len - 1], "Charging"))
+        "^"
+    else
+        "?";
+    const percent_left = @as(f32, @floatFromInt(energy_now)) / @as(f32, @floatFromInt(energy_full)) * 100;
+
+    return .{
+        .full_text = try std.fmt.allocPrint(self.module.allocator, "{s} {d:.2}%", .{ status, percent_left }),
+    };
+}