daylin/hyprman
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

zig

Browse source
This commit is contained in:
Daylin Morgan 2024-04-29 10:58:14 -05:00
parent e2e5e2162c
commit d96f0d8b2d
Signed by: daylin
GPG key ID: 950D13E9719334AD
7 changed files with 502 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
zig-cache
zig-out

33
build.zig Normal file
View file

@ -0,0 +1,33 @@
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 {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "hyprman",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
b.installArtifact(exe);
const run_cmd = b.addRunArtifact(exe);
run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| run_cmd.addArgs(args);
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
// const exe_unit_tests = b.addTest(.{
// .root_source_file = b.path("src/main.zig"),
// .target = target,
// .optimize = optimize,
// });
//
// const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
// const test_step = b.step("test", "Run unit tests");
// test_step.dependOn(&run_exe_unit_tests.step);
}

67
build.zig.zon Normal file
View file

@ -0,0 +1,67 @@
.{
.name = "hyprman",
// This is a [Semantic Version](https://semver.org/).
// In a future version of Zig it will be used for package deduplication.
.version = "0.0.0",
// This field is optional.
// This is currently advisory only; Zig does not yet do anything
// with this value.
//.minimum_zig_version = "0.11.0",
// This field is optional.
// Each dependency must either provide a `url` and `hash`, or a `path`.
// `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
// Once all dependencies are fetched, `zig build` no longer requires
// internet connectivity.
.dependencies = .{
// See `zig fetch --save <url>` for a command-line interface for adding dependencies.
//.example = .{
// // When updating this field to a new URL, be sure to delete the corresponding
// // `hash`, otherwise you are communicating that you expect to find the old hash at
// // the new URL.
// .url = "https://example.com/foo.tar.gz",
//
// // This is computed from the file contents of the directory of files that is
// // obtained after fetching `url` and applying the inclusion rules given by
// // `paths`.
// //
// // This field is the source of truth; packages do not come from a `url`; they
// // come from a `hash`. `url` is just one of many possible mirrors for how to
// // obtain a package matching this `hash`.
// //
// // Uses the [multihash](https://multiformats.io/multihash/) format.
// .hash = "...",
//
// // When this is provided, the package is found in a directory relative to the
// // build root. In this case the package's hash is irrelevant and therefore not
// // computed. This field and `url` are mutually exclusive.
// .path = "foo",
// // When this is set to `true`, a package is declared to be lazily
// // fetched. This makes the dependency only get fetched if it is
// // actually used.
// .lazy = false,
//},
},
// Specifies the set of files and directories that are included in this package.
// Only files and directories listed here are included in the `hash` that
// is computed for this package.
// Paths are relative to the build root. Use the empty string (`""`) to refer to
// the build root itself.
// A directory listed here means that all files within, recursively, are included.
.paths = .{
// This makes *all* files, recursively, included in this package. It is generally
// better to explicitly list the files and directories instead, to insure that
// fetching from tarballs, file system paths, and version control all result
// in the same contents hash.
"",
// For example...
//"build.zig",
//"build.zig.zon",
//"src",
//"LICENSE",
//"README.md",
},
}

95
flake.lock Normal file
View file

@ -0,0 +1,95 @@
{
"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": 1714314149,
"narHash": "sha256-yNAevSKF4krRWacmLUsLK7D7PlfuY3zF0lYnGYNi9vQ=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "cf8cc1201be8bc71b7cbbbdaf349b22f4f99c7ae",
"type": "github"
},
"original": {
"owner": "nixos",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_2": {
"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": {
"nixpkgs": "nixpkgs",
"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_2"
},
"locked": {
"lastModified": 1714441187,
"narHash": "sha256-ZxbKh27jHGbzF0JM6l80jSzpTMhYrzkg75g9RnVPPiE=",
"owner": "Cloudef",
"repo": "zig2nix",
"rev": "d2e6a19c4c97df944142ad9d6f8b661f8bb6a716",
"type": "github"
},
"original": {
"owner": "Cloudef",
"repo": "zig2nix",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

42
flake.nix Normal file
View file

@ -0,0 +1,42 @@
{
description = "hyprman";
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
zig2nix.url = "github:Cloudef/zig2nix";
};
outputs =
inputs@{
self,
nixpkgs,
zig2nix,
...
}:
let
inherit (nixpkgs.lib) genAttrs;
supportedSystems = [
"x86_64-linux"
"x86_64-darwin"
"aarch64-linux"
"aarch64-darwin"
];
forAllSystems = f: genAttrs supportedSystems (system: f nixpkgs.legacyPackages.${system});
zig-env =
system:
zig2nix.outputs.zig-env.${system} { zig = zig2nix.outputs.packages.${system}.zig.default.bin; };
in
{
devShells = forAllSystems (pkgs: {
default = (zig-env pkgs.system).mkShell { };
});
packages = forAllSystems (pkgs: {
hyprman = (zig-env pkgs.system).package {
name = "hyprman";
version = "2023.1001";
src = nixpkgs.lib.cleanSource ./.;
};
default = self.packages.${pkgs.system}.hyprman;
});
formatter = forAllSystems (pkgs: pkgs.nixfmt-rfc-style);
};
}

99
src/hyprland.zig Normal file
View file

@ -0,0 +1,99 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
pub const Workspace = struct {
id: u8,
name: []const u8,
};
pub const Client = struct {
workspace: Workspace,
class: []const u8,
title: []const u8,
};
pub const Monitor = struct { id: u8, activeWorkspace: Workspace };
pub fn getSocketPath(allocator: Allocator, path: []const u8) ![]const u8 {
const runtime_dir = std.posix.getenv("XDG_RUNTIME_DIR").?;
const hyprland_instance = std.posix.getenv("HYPRLAND_INSTANCE_SIGNATURE").?;
return try std.fmt.allocPrint(
allocator,
"{s}/hypr/{s}/{s}",
.{ runtime_dir, hyprland_instance, path },
);
}
pub fn getDataFromSocket(allocator: Allocator, comptime msg: []const u8, comptime T: type) ![]T {
const sock = try std.net.connectUnixSocket(
try getSocketPath(allocator, ".socket.sock"),
);
defer sock.close();
_ = try sock.write(msg);
const out = try sock.reader().readAllAlloc(allocator, std.math.maxInt(u32));
const value = try std.json.parseFromSliceLeaky(
[]T,
allocator,
out,
.{ .ignore_unknown_fields = true },
);
return value;
}
const Event = enum {
monitoradded,
monitorremoved,
};
pub fn runEwwCommand(event: Event, allocator: Allocator) !void {
std.time.sleep(1 * std.time.ns_per_s);
std.log.debug("reacting to monitor change", .{});
var p = std.ChildProcess.init(
&.{
"eww",
switch (event) {
.monitoradded => "open",
.monitorremoved => "close",
},
"bar1",
},
allocator,
);
_ = try p.spawnAndWait();
}
pub fn startEww(allocator: Allocator) !void {
const monitors = try getDataFromSocket(allocator, "[-j]/monitors", Monitor);
std.log.debug("starting eww", .{});
for (0..monitors.len) |i| {
const bar = try std.fmt.allocPrint(allocator, "bar{d}", .{i});
defer allocator.free(bar);
var p = std.ChildProcess.init(
&.{ "eww", "open", bar },
allocator,
);
_ = try p.spawnAndWait();
}
}
pub fn watchMonitors(allocator: Allocator) !void {
try startEww(allocator);
const sock = try std.net.connectUnixSocket(
try getSocketPath(allocator, ".socket2.sock"),
);
defer sock.close();
while (true) {
const out = try sock.reader().readUntilDelimiterAlloc(
allocator,
'\n',
std.math.maxInt(u32),
);
defer allocator.free(out);
var iterator = std.mem.split(u8, out, ">>");
if (std.meta.stringToEnum(Event, iterator.next().?)) |event| {
try runEwwCommand(event, allocator);
}
}
}

164
src/main.zig Normal file
View file

@ -0,0 +1,164 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
const hypr = @import("hyprland.zig");
const Client = hypr.Client;
const Monitor = hypr.Monitor;
const Icons = struct {
allocator: Allocator,
map: std.ArrayHashMapUnmanaged([]const u8, []const u8, std.array_hash_map.StringContext, true),
pub fn init(allocator: Allocator) !Icons {
var config_dir: ?[]const u8 = std.posix.getenv("XDG_CONFIG_DIR");
if (config_dir == null) {
config_dir = try std.fmt.allocPrint(
allocator,
"{s}/.config",
.{std.posix.getenv("HOME").?},
);
}
defer {
if (config_dir) |cd| allocator.free(cd);
}
const icon_path = try std.fmt.allocPrint(allocator, "{s}/hyprman/icons.json", .{config_dir.?});
defer allocator.free(icon_path);
const file = try std.fs.openFileAbsolute(icon_path, .{});
defer file.close();
const buffer = try file.readToEndAlloc(allocator, (try file.stat()).size);
defer allocator.free(buffer);
const icons = (try std.json.ArrayHashMap([]const u8).jsonParseFromValue(
allocator,
try std.json.parseFromSliceLeaky(std.json.Value, allocator, buffer, .{}),
.{},
)).map;
return Icons{
.allocator = allocator,
.map = icons,
};
}
pub fn get(self: *const Icons, k: []const u8) []const u8 {
return self.map.get(k) orelse "";
}
};
const WorkspaceIcon = struct {
id: u8,
icon: []const u8,
class: []const u8,
};
pub fn allocWorkspaces(
allocator: Allocator,
len_monitors: usize,
len_workspaces: usize,
) ![][]WorkspaceIcon {
var list = std.ArrayList([]WorkspaceIcon).init(allocator);
errdefer {
for (list.items) |slice| allocator.free(slice);
list.deinit();
}
for (0..len_monitors) |_| {
var workspaces = std.ArrayList(WorkspaceIcon).init(allocator);
errdefer workspaces.deinit();
for (0..len_workspaces) |i| {
var id: u8 = @intCast(i);
id += 1;
try workspaces.append(WorkspaceIcon{
.id = id,
.class = try std.fmt.allocPrint(allocator, "ws-button-{d}", .{id}),
.icon = "",
});
}
try list.append(try workspaces.toOwnedSlice());
}
return list.toOwnedSlice();
}
pub fn listenWorkspaces(child_allocator: Allocator, iconLookup: Icons) !void {
var arena = std.heap.ArenaAllocator.init(child_allocator);
while (true) {
defer _ = arena.reset(.free_all);
const allocator = arena.allocator();
const clients = try hypr.getDataFromSocket(allocator, "[-j]/clients", Client);
const monitors = try hypr.getDataFromSocket(allocator, "[-j]/monitors", Monitor);
const workspaces = try allocWorkspaces(allocator, monitors.len, 9);
for (clients) |c| {
for (0..monitors.len) |i| {
var ws = &workspaces[i][c.workspace.id - 1];
ws.icon = try std.fmt.allocPrint(allocator, "{s}{s}", .{
ws.icon,
iconLookup.get(c.class),
});
}
}
for (workspaces, 0..) |ws_list, i| {
for (ws_list) |*ws| {
if (monitors[i].activeWorkspace.id == ws.id)
ws.*.class =
try std.fmt.allocPrint(
allocator,
"{s} {s}",
.{ ws.class, "ws-button-open" },
);
if (std.mem.eql(u8, ws.icon, ""))
ws.*.icon = "";
}
}
const stderr = std.io.getStdOut().writer();
try std.json.stringify(workspaces, .{}, stderr);
try stderr.writeAll("\n");
std.time.sleep(500 * std.time.ns_per_ms);
}
}
const Cmd = enum {
workspaces,
monitors,
};
const Context = struct {
allocator: Allocator,
cmd: Cmd,
pub fn init(allocator: Allocator) !Context {
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
if ((args.len == 1) or (args.len > 3)) {
std.debug.print("please provide one of: workspaces, monitors\n", .{});
std.process.exit(1);
}
const cmd = std.meta.stringToEnum(Cmd, args[1]);
if (cmd == null) {
std.debug.print("unknown cmd: {s}\n", .{args[1]});
std.process.exit(1);
}
return .{ .allocator = allocator, .cmd = cmd.? };
}
};
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const ctx = try Context.init(allocator);
switch (ctx.cmd) {
.workspaces => {
const iconLookup = try Icons.init(allocator);
try listenWorkspaces(allocator, iconLookup);
},
.monitors => {
try hypr.watchMonitors(allocator);
},
}
}