mirror of
https://github.com/fairyglade/ly.git
synced 2025-12-21 11:44:55 +00:00
Compare commits
2 Commits
v1.3.0
...
mookums/mu
| Author | SHA1 | Date | |
|---|---|---|---|
|
ab462e91c2 | ||
|
|
6d3808553e |
73
.github/ISSUE_TEMPLATE/bug.yml
vendored
73
.github/ISSUE_TEMPLATE/bug.yml
vendored
@@ -1,73 +0,0 @@
|
||||
name: Bug report
|
||||
description: File a bug report.
|
||||
title: "[Bug] "
|
||||
labels: ["bug"]
|
||||
body:
|
||||
- type: checkboxes
|
||||
id: prerequisites
|
||||
attributes:
|
||||
label: Pre-requisites
|
||||
description: By submitting this issue, you agree to have done the following.
|
||||
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: true
|
||||
- label: I have confirmed this issue also occurs on the latest development version
|
||||
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.
|
||||
placeholder: 1.1.0-dev.12+2b0301c
|
||||
validations:
|
||||
required: true
|
||||
- type: textarea
|
||||
id: observed
|
||||
attributes:
|
||||
label: Observed behavior
|
||||
description: What happened?
|
||||
validations:
|
||||
required: true
|
||||
- type: textarea
|
||||
id: expected
|
||||
attributes:
|
||||
label: Expected behavior
|
||||
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:
|
||||
label: Steps to reproduce
|
||||
description: What **exactly** can someone else do in order to observe the problem you observed?
|
||||
placeholder: |
|
||||
1. Authenticate with ...
|
||||
2. Go to ...
|
||||
3. Create file ...
|
||||
4. Log out and log back in
|
||||
5. Observe error
|
||||
validations:
|
||||
required: true
|
||||
- type: textarea
|
||||
id: logs
|
||||
attributes:
|
||||
label: Relevant logs
|
||||
description: |
|
||||
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.
|
||||
22
.github/ISSUE_TEMPLATE/feature.yml
vendored
22
.github/ISSUE_TEMPLATE/feature.yml
vendored
@@ -1,22 +0,0 @@
|
||||
name: Feature request
|
||||
description: Request a new feature or enhancement.
|
||||
title: "[Feature] "
|
||||
labels: ["feature"]
|
||||
body:
|
||||
- type: checkboxes
|
||||
id: prerequisites
|
||||
attributes:
|
||||
label: Pre-requisites
|
||||
description: By submitting this issue, you agree to have done the following.
|
||||
options:
|
||||
- label: I have looked for any other duplicate issues
|
||||
required: true
|
||||
- label: I have confirmed the requested feature doesn't exist in the latest version in development
|
||||
required: true
|
||||
- type: textarea
|
||||
id: wanted
|
||||
attributes:
|
||||
label: Wanted behavior
|
||||
description: What do you want to be added? Describe the behavior clearly.
|
||||
validations:
|
||||
required: true
|
||||
11
.github/pull_request_template.md
vendored
11
.github/pull_request_template.md
vendored
@@ -1,11 +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
|
||||
BIN
.github/screenshot.png
vendored
BIN
.github/screenshot.png
vendored
Binary file not shown.
|
Before Width: | Height: | Size: 34 KiB |
1
.gitignore
vendored
1
.gitignore
vendored
@@ -2,4 +2,3 @@
|
||||
zig-cache/
|
||||
zig-out/
|
||||
valgrind.log
|
||||
.zig-cache
|
||||
|
||||
591
build.zig
591
build.zig
@@ -1,75 +1,37 @@
|
||||
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 ly_version = std.SemanticVersion{ .major = 1, .minor = 0, .patch = 0, .build = "dev" };
|
||||
|
||||
const min_zig_string = "0.15.0";
|
||||
const current_zig = builtin.zig_version;
|
||||
|
||||
// Implementing zig version detection through compile time
|
||||
comptime {
|
||||
const min_zig = std.SemanticVersion.parse(min_zig_string) catch unreachable;
|
||||
if (current_zig.order(min_zig) == .lt) {
|
||||
@compileError(std.fmt.comptimePrint("Your Zig version v{} does not meet the minimum build requirement of v{}", .{ current_zig, min_zig }));
|
||||
}
|
||||
}
|
||||
|
||||
const ly_version = std.SemanticVersion{ .major = 1, .minor = 3, .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;
|
||||
|
||||
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;
|
||||
pub fn build(b: *std.Build) void {
|
||||
const data_directory = b.option([]const u8, "data_directory", "Specify a default data directory (default is /etc/ly)");
|
||||
|
||||
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;
|
||||
build_options.addOption([]const u8, "data_directory", data_directory orelse "/etc/ly");
|
||||
const version_str = b.fmt("{d}.{d}.{d}-{s}", .{ ly_version.major, ly_version.minor, ly_version.patch, ly_version.build.? });
|
||||
|
||||
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, "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(.{});
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
const c_args = [_][]const u8{
|
||||
"-std=c99",
|
||||
"-pedantic",
|
||||
"-g",
|
||||
"-Wall",
|
||||
"-Wextra",
|
||||
"-Werror=vla",
|
||||
"-Wno-unused-parameter",
|
||||
"-D_DEFAULT_SOURCE",
|
||||
"-D_POSIX_C_SOURCE=200809L",
|
||||
"-D_XOPEN_SOURCE",
|
||||
};
|
||||
|
||||
const exe = b.addExecutable(.{
|
||||
.name = "ly",
|
||||
.root_module = b.createModule(.{
|
||||
.root_source_file = b.path("src/main.zig"),
|
||||
.root_source_file = .{ .path = "src/main.zig" },
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
}),
|
||||
// Here until the native backend matures in terms of performance
|
||||
.use_llvm = true,
|
||||
});
|
||||
|
||||
const zigini = b.dependency("zigini", .{ .target = target, .optimize = optimize });
|
||||
@@ -80,24 +42,18 @@ pub fn build(b: *std.Build) !void {
|
||||
const clap = b.dependency("clap", .{ .target = target, .optimize = optimize });
|
||||
exe.root_module.addImport("clap", clap.module("clap"));
|
||||
|
||||
const termbox_dep = b.dependency("termbox2", .{
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
exe.linkSystemLibrary("pam");
|
||||
if (enable_x11_support) exe.linkSystemLibrary("xcb");
|
||||
exe.linkSystemLibrary("xcb");
|
||||
exe.linkLibC();
|
||||
|
||||
const translate_c = b.addTranslateC(.{
|
||||
.root_source_file = termbox_dep.path("termbox2.h"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
translate_c.defineCMacroRaw("TB_IMPL");
|
||||
translate_c.defineCMacro("TB_OPT_ATTR_W", "32"); // Enable 24-bit color support + styling (32-bit)
|
||||
const termbox2 = translate_c.addModule("termbox2");
|
||||
exe.root_module.addImport("termbox2", termbox2);
|
||||
exe.addIncludePath(.{ .path = "dep/termbox_next/src" });
|
||||
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/input.c" }, .flags = &c_args });
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/memstream.c" }, .flags = &c_args });
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/ringbuffer.c" }, .flags = &c_args });
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/term.c" }, .flags = &c_args });
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/termbox.c" }, .flags = &c_args });
|
||||
exe.addCSourceFile(.{ .file = .{ .path = "dep/termbox_next/src/utf8.c" }, .flags = &c_args });
|
||||
|
||||
b.installArtifact(exe);
|
||||
|
||||
@@ -110,419 +66,156 @@ 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");
|
||||
installexe_step.makeFn = Installer(true).make;
|
||||
const installexe_step = b.step("installexe", "Install Ly");
|
||||
installexe_step.makeFn = installexe;
|
||||
installexe_step.dependOn(b.getInstallStep());
|
||||
|
||||
const installnoconf_step = b.step("installnoconf", "Install Ly and the selected init system service, but not the configuration file");
|
||||
installnoconf_step.makeFn = Installer(false).make;
|
||||
const installnoconf_step = b.step("installnoconf", "Install Ly without its configuration file");
|
||||
installnoconf_step.makeFn = installnoconf;
|
||||
installnoconf_step.dependOn(b.getInstallStep());
|
||||
|
||||
const uninstallexe_step = b.step("uninstallexe", "Uninstall Ly and remove the selected init system service");
|
||||
uninstallexe_step.makeFn = Uninstaller(true).make;
|
||||
const installsystemd_step = b.step("installsystemd", "Install the Ly systemd service");
|
||||
installsystemd_step.makeFn = installsystemd;
|
||||
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");
|
||||
uninstallnoconf_step.makeFn = Uninstaller(false).make;
|
||||
const installopenrc_step = b.step("installopenrc", "Install the Ly openrc service");
|
||||
installopenrc_step.makeFn = installopenrc;
|
||||
installopenrc_step.dependOn(installexe_step);
|
||||
|
||||
const installrunit_step = b.step("installrunit", "Install the Ly runit service");
|
||||
installrunit_step.makeFn = installrunit;
|
||||
installrunit_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 {
|
||||
return struct {
|
||||
pub fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) !void {
|
||||
const allocator = step.owner.allocator;
|
||||
fn installexe(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
var patch_map = PatchMap.init(allocator);
|
||||
defer patch_map.deinit();
|
||||
|
||||
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);
|
||||
try patch_map.put("$EXECUTABLE_NAME", executable_name);
|
||||
|
||||
// The "-a" argument doesn't exist on FreeBSD, so we use "-p"
|
||||
// instead to shutdown the system.
|
||||
try patch_map.put("$PLATFORM_SHUTDOWN_ARG", if (init_system == .freebsd) "-p" else "-a");
|
||||
|
||||
try install_ly(allocator, patch_map, install_config);
|
||||
try install_service(allocator, patch_map);
|
||||
try install_ly(true);
|
||||
}
|
||||
|
||||
fn installnoconf(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
try install_ly(false);
|
||||
}
|
||||
|
||||
fn installsystemd(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
var service_dir = std.fs.openDirAbsolute("/usr/lib/systemd/system", .{}) catch unreachable;
|
||||
defer service_dir.close();
|
||||
|
||||
try std.fs.cwd().copyFile("res/ly@.service", service_dir, "ly@.service", .{ .override_mode = 644 });
|
||||
}
|
||||
|
||||
fn installopenrc(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
var service_dir = std.fs.openDirAbsolute("/etc/init.d", .{}) catch unreachable;
|
||||
defer service_dir.close();
|
||||
|
||||
try std.fs.cwd().copyFile("res/ly-openrc", service_dir, "ly", .{ .override_mode = 755 });
|
||||
}
|
||||
|
||||
fn installrunit(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
var service_dir = std.fs.openDirAbsolute("/etc/sv", .{}) catch unreachable;
|
||||
defer service_dir.close();
|
||||
|
||||
std.fs.makeDirAbsolute("/etc/sv/ly") catch {
|
||||
std.debug.print("warn: /etc/sv/ly already exists as a directory.\n", .{});
|
||||
};
|
||||
|
||||
var ly_service_dir = std.fs.openDirAbsolute("/etc/sv/ly", .{}) catch unreachable;
|
||||
defer ly_service_dir.close();
|
||||
|
||||
try std.fs.cwd().copyFile("res/ly-runit-service/conf", ly_service_dir, "conf", .{});
|
||||
try std.fs.cwd().copyFile("res/ly-runit-service/finish", ly_service_dir, "finish", .{});
|
||||
try std.fs.cwd().copyFile("res/ly-runit-service/run", ly_service_dir, "run", .{});
|
||||
}
|
||||
|
||||
fn uninstallall(self: *std.Build.Step, progress: *std.Progress.Node) !void {
|
||||
_ = progress;
|
||||
_ = self;
|
||||
|
||||
try std.fs.deleteTreeAbsolute("/etc/ly");
|
||||
try std.fs.deleteFileAbsolute("/usr/bin/ly");
|
||||
try std.fs.deleteFileAbsolute("/etc/pam.d/ly");
|
||||
std.fs.deleteFileAbsolute("/usr/lib/systemd/system/ly.service") catch {
|
||||
std.debug.print("warn: systemd service not found.\n", .{});
|
||||
};
|
||||
std.fs.deleteFileAbsolute("/etc/init.d/ly") catch {
|
||||
std.debug.print("warn: openrc service not found.\n", .{});
|
||||
};
|
||||
std.fs.deleteTreeAbsolute("/etc/sv/ly") catch {
|
||||
std.debug.print("warn: runit service not found.\n", .{});
|
||||
};
|
||||
}
|
||||
|
||||
fn install_ly(allocator: std.mem.Allocator, patch_map: PatchMap, install_config: bool) !void {
|
||||
const ly_config_directory = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly" });
|
||||
|
||||
std.fs.cwd().makePath(ly_config_directory) catch {
|
||||
std.debug.print("warn: {s} already exists as a directory.\n", .{ly_config_directory});
|
||||
fn install_ly(install_config: bool) !void {
|
||||
std.fs.makeDirAbsolute("/etc/ly") catch {
|
||||
std.debug.print("warn: /etc/ly already exists as a directory.\n", .{});
|
||||
};
|
||||
|
||||
const ly_custom_sessions_directory = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly/custom-sessions" });
|
||||
|
||||
std.fs.cwd().makePath(ly_custom_sessions_directory) catch {
|
||||
std.debug.print("warn: {s} already exists as a directory.\n", .{ly_custom_sessions_directory});
|
||||
std.fs.makeDirAbsolute("/etc/ly/lang") catch {
|
||||
std.debug.print("warn: /etc/ly/lang already exists as a directory.\n", .{});
|
||||
};
|
||||
|
||||
const ly_lang_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/ly/lang" });
|
||||
std.fs.cwd().makePath(ly_lang_path) catch {
|
||||
std.debug.print("warn: {s} already exists as a directory.\n", .{ly_lang_path});
|
||||
};
|
||||
var current_dir = std.fs.cwd();
|
||||
|
||||
{
|
||||
const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin" });
|
||||
std.fs.cwd().makePath(exe_path) catch {
|
||||
if (!std.mem.eql(u8, dest_directory, "")) {
|
||||
std.debug.print("warn: {s} already exists as a directory.\n", .{exe_path});
|
||||
}
|
||||
};
|
||||
|
||||
var executable_dir = std.fs.cwd().openDir(exe_path, .{}) catch unreachable;
|
||||
var executable_dir = std.fs.openDirAbsolute("/usr/bin", .{}) catch unreachable;
|
||||
defer executable_dir.close();
|
||||
|
||||
try installFile("zig-out/bin/ly", executable_dir, exe_path, executable_name, .{});
|
||||
try current_dir.copyFile("zig-out/bin/ly", executable_dir, "ly", .{});
|
||||
}
|
||||
|
||||
{
|
||||
var config_dir = std.fs.cwd().openDir(ly_config_directory, .{}) catch unreachable;
|
||||
var config_dir = std.fs.openDirAbsolute("/etc/ly", .{}) catch unreachable;
|
||||
defer config_dir.close();
|
||||
|
||||
if (install_config) {
|
||||
const patched_config = try patchFile(allocator, "res/config.ini", patch_map);
|
||||
try installText(patched_config, config_dir, ly_config_directory, "config.ini", .{});
|
||||
try current_dir.copyFile("res/config.ini", config_dir, "config.ini", .{});
|
||||
}
|
||||
|
||||
const patched_example_config = try patchFile(allocator, "res/config.ini", patch_map);
|
||||
try installText(patched_example_config, config_dir, ly_config_directory, "config.ini.example", .{});
|
||||
|
||||
const patched_setup = try patchFile(allocator, "res/setup.sh", patch_map);
|
||||
try installText(patched_setup, config_dir, ly_config_directory, "setup.sh", .{ .mode = 0o755 });
|
||||
try current_dir.copyFile("res/xsetup.sh", config_dir, "xsetup.sh", .{});
|
||||
try current_dir.copyFile("res/wsetup.sh", config_dir, "wsetup.sh", .{});
|
||||
}
|
||||
|
||||
{
|
||||
var custom_sessions_dir = std.fs.cwd().openDir(ly_custom_sessions_directory, .{}) catch unreachable;
|
||||
defer custom_sessions_dir.close();
|
||||
|
||||
const patched_readme = try patchFile(allocator, "res/custom-sessions/README", patch_map);
|
||||
try installText(patched_readme, custom_sessions_dir, ly_custom_sessions_directory, "README", .{});
|
||||
}
|
||||
|
||||
{
|
||||
var lang_dir = std.fs.cwd().openDir(ly_lang_path, .{}) catch unreachable;
|
||||
var lang_dir = std.fs.openDirAbsolute("/etc/ly/lang", .{}) catch unreachable;
|
||||
defer lang_dir.close();
|
||||
|
||||
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("res/lang/" ++ language, lang_dir, ly_lang_path, language, .{});
|
||||
}
|
||||
try current_dir.copyFile("res/lang/cat.ini", lang_dir, "cat.ini", .{});
|
||||
try current_dir.copyFile("res/lang/cs.ini", lang_dir, "cs.ini", .{});
|
||||
try current_dir.copyFile("res/lang/de.ini", lang_dir, "de.ini", .{});
|
||||
try current_dir.copyFile("res/lang/en.ini", lang_dir, "en.ini", .{});
|
||||
try current_dir.copyFile("res/lang/es.ini", lang_dir, "es.ini", .{});
|
||||
try current_dir.copyFile("res/lang/fr.ini", lang_dir, "fr.ini", .{});
|
||||
try current_dir.copyFile("res/lang/it.ini", lang_dir, "it.ini", .{});
|
||||
try current_dir.copyFile("res/lang/pl.ini", lang_dir, "pl.ini", .{});
|
||||
try current_dir.copyFile("res/lang/pt.ini", lang_dir, "pt.ini", .{});
|
||||
try current_dir.copyFile("res/lang/pt_BR.ini", lang_dir, "pt_BR.ini", .{});
|
||||
try current_dir.copyFile("res/lang/ro.ini", lang_dir, "ro.ini", .{});
|
||||
try current_dir.copyFile("res/lang/ru.ini", lang_dir, "ru.ini", .{});
|
||||
try current_dir.copyFile("res/lang/sr.ini", lang_dir, "sr.ini", .{});
|
||||
try current_dir.copyFile("res/lang/sv.ini", lang_dir, "sv.ini", .{});
|
||||
try current_dir.copyFile("res/lang/tr.ini", lang_dir, "tr.ini", .{});
|
||||
try current_dir.copyFile("res/lang/uk.ini", lang_dir, "uk.ini", .{});
|
||||
}
|
||||
|
||||
{
|
||||
const pam_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, config_directory, "/pam.d" });
|
||||
std.fs.cwd().makePath(pam_path) catch {
|
||||
if (!std.mem.eql(u8, dest_directory, "")) {
|
||||
std.debug.print("warn: {s} already exists as a directory.\n", .{pam_path});
|
||||
}
|
||||
};
|
||||
|
||||
var pam_dir = std.fs.cwd().openDir(pam_path, .{}) catch unreachable;
|
||||
var pam_dir = std.fs.openDirAbsolute("/etc/pam.d", .{}) catch unreachable;
|
||||
defer pam_dir.close();
|
||||
|
||||
try installFile(if (init_system == .freebsd) "res/pam.d/ly-freebsd" else "res/pam.d/ly-linux", pam_dir, pam_path, "ly", .{ .override_mode = 0o644 });
|
||||
try installFile(if (init_system == .freebsd) "res/pam.d/ly-freebsd-autologin" else "res/pam.d/ly-linux-autologin", pam_dir, pam_path, "ly-autologin", .{ .override_mode = 0o644 });
|
||||
try current_dir.copyFile("res/pam.d/ly", pam_dir, "ly", .{ .override_mode = 644 });
|
||||
}
|
||||
}
|
||||
|
||||
fn install_service(allocator: std.mem.Allocator, patch_map: PatchMap) !void {
|
||||
switch (init_system) {
|
||||
.systemd => {
|
||||
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();
|
||||
|
||||
const patched_service = try patchFile(allocator, "res/ly@.service", 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 });
|
||||
|
||||
std.fs.cwd().symLink("/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.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", .{});
|
||||
},
|
||||
.sysvinit => {
|
||||
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-sysvinit", patch_map);
|
||||
try installText(patched_service, service_dir, service_path, "ly", .{ .mode = 0o755 });
|
||||
},
|
||||
.freebsd => {
|
||||
const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix_directory, "/bin" });
|
||||
var executable_dir = std.fs.cwd().openDir(exe_path, .{}) catch unreachable;
|
||||
defer executable_dir.close();
|
||||
|
||||
const patched_wrapper = try patchFile(allocator, "res/ly-freebsd-wrapper", patch_map);
|
||||
try installText(patched_wrapper, executable_dir, exe_path, "ly_wrapper", .{ .mode = 0o755 });
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn Uninstaller(uninstall_config: bool) type {
|
||||
return struct {
|
||||
pub fn make(step: *std.Build.Step, _: std.Build.Step.MakeOptions) !void {
|
||||
const allocator = step.owner.allocator;
|
||||
|
||||
if (uninstall_config) {
|
||||
try deleteTree(allocator, config_directory, "/ly", "ly config directory not found");
|
||||
}
|
||||
|
||||
const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ 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");
|
||||
|
||||
switch (init_system) {
|
||||
.systemd => try deleteFile(allocator, prefix_directory, "/lib/systemd/system/ly@.service", "systemd service not found"),
|
||||
.openrc => try deleteFile(allocator, config_directory, "/init.d/ly", "openrc service not found"),
|
||||
.runit => try deleteTree(allocator, config_directory, "/sv/ly", "runit service not found"),
|
||||
.s6 => {
|
||||
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");
|
||||
},
|
||||
.dinit => try deleteFile(allocator, config_directory, "/dinit.d/ly", "dinit service not found"),
|
||||
.sysvinit => try deleteFile(allocator, config_directory, "/init.d/ly", "sysvinit service not found"),
|
||||
.freebsd => try deleteFile(allocator, prefix_directory, "/bin/ly_wrapper", "freebsd wrapper not found"),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion) ![]const u8 {
|
||||
const version_str = b.fmt("{d}.{d}.{d}", .{ version.major, version.minor, version.patch });
|
||||
|
||||
var status: u8 = undefined;
|
||||
const git_describe_raw = b.runAllowFail(&[_][]const u8{
|
||||
"git",
|
||||
"-C",
|
||||
b.build_root.path orelse ".",
|
||||
"describe",
|
||||
"--match",
|
||||
"*.*.*",
|
||||
"--tags",
|
||||
}, &status, .Ignore) catch {
|
||||
return version_str;
|
||||
};
|
||||
var git_describe = std.mem.trim(u8, git_describe_raw, " \n\r");
|
||||
git_describe = std.mem.trimLeft(u8, git_describe, "v");
|
||||
|
||||
switch (std.mem.count(u8, git_describe, "-")) {
|
||||
0 => {
|
||||
if (!std.mem.eql(u8, version_str, git_describe)) {
|
||||
std.debug.print("{s} version '{s}' does not match git tag: '{s}'\n", .{ name, version_str, git_describe });
|
||||
std.process.exit(1);
|
||||
}
|
||||
return version_str;
|
||||
},
|
||||
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.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.process.exit(1);
|
||||
}
|
||||
|
||||
// Check that the commit hash is prefixed with a 'g' (a Git convention).
|
||||
if (commit_id.len < 1 or commit_id[0] != 'g') {
|
||||
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
|
||||
return version_str;
|
||||
}
|
||||
|
||||
// The version is reformatted in accordance with the https://semver.org specification.
|
||||
return b.fmt("{s}-dev.{s}+{s}", .{ version_str, commit_height, commit_id[1..] });
|
||||
},
|
||||
else => {
|
||||
std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
|
||||
return version_str;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn installFile(
|
||||
source_file: []const u8,
|
||||
destination_directory: std.fs.Dir,
|
||||
destination_directory_path: []const u8,
|
||||
destination_file: []const u8,
|
||||
options: std.fs.Dir.CopyFileOptions,
|
||||
) !void {
|
||||
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, source_file: []const u8, patch_map: PatchMap) ![]const u8 {
|
||||
var file = try std.fs.cwd().openFile(source_file, .{});
|
||||
defer file.close();
|
||||
|
||||
const stat = try file.stat();
|
||||
|
||||
var buffer: [4096]u8 = undefined;
|
||||
var reader = file.reader(&buffer);
|
||||
var text = try reader.interface.readAlloc(allocator, stat.size);
|
||||
|
||||
var iterator = patch_map.iterator();
|
||||
while (iterator.next()) |kv| {
|
||||
const new_text = try std.mem.replaceOwned(u8, allocator, text, kv.key_ptr.*, kv.value_ptr.*);
|
||||
allocator.free(text);
|
||||
text = new_text;
|
||||
}
|
||||
|
||||
return text;
|
||||
}
|
||||
|
||||
fn installText(
|
||||
text: []const u8,
|
||||
destination_directory: std.fs.Dir,
|
||||
destination_directory_path: []const u8,
|
||||
destination_file: []const u8,
|
||||
options: std.fs.File.CreateFlags,
|
||||
) !void {
|
||||
var file = try destination_directory.createFile(destination_file, options);
|
||||
defer file.close();
|
||||
|
||||
var buffer: [1024]u8 = undefined;
|
||||
var writer = file.writer(&buffer);
|
||||
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,
|
||||
prefix: []const u8,
|
||||
file: []const u8,
|
||||
warning: []const u8,
|
||||
) !void {
|
||||
const path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix, file });
|
||||
|
||||
std.fs.cwd().deleteFile(path) catch |err| {
|
||||
if (err == error.FileNotFound) {
|
||||
std.debug.print("warn: {s}\n", .{warning});
|
||||
return;
|
||||
}
|
||||
|
||||
return err;
|
||||
};
|
||||
|
||||
std.debug.print("info: deleted {s}\n", .{path});
|
||||
}
|
||||
|
||||
fn deleteTree(
|
||||
allocator: std.mem.Allocator,
|
||||
prefix: []const u8,
|
||||
directory: []const u8,
|
||||
warning: []const u8,
|
||||
) !void {
|
||||
const path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, prefix, directory });
|
||||
|
||||
var dir = std.fs.cwd().openDir(path, .{}) catch |err| {
|
||||
if (err == error.FileNotFound) {
|
||||
std.debug.print("warn: {s}\n", .{warning});
|
||||
return;
|
||||
}
|
||||
|
||||
return err;
|
||||
};
|
||||
dir.close();
|
||||
|
||||
try std.fs.cwd().deleteTree(path);
|
||||
|
||||
std.debug.print("info: deleted {s}\n", .{path});
|
||||
}
|
||||
|
||||
@@ -1,20 +1,14 @@
|
||||
.{
|
||||
.name = .ly,
|
||||
.version = "1.3.0",
|
||||
.fingerprint = 0xa148ffcc5dc2cb59,
|
||||
.minimum_zig_version = "0.15.0",
|
||||
.name = "ly",
|
||||
.version = "1.0.0",
|
||||
.dependencies = .{
|
||||
.clap = .{
|
||||
.url = "git+https://github.com/Hejsil/zig-clap#5289e0753cd274d65344bef1c114284c633536ea",
|
||||
.hash = "clap-0.11.0-oBajB-HnAQDPCKYzwF7rO3qDFwRcD39Q0DALlTSz5H7e",
|
||||
.url = "https://github.com/Hejsil/zig-clap/archive/8c98e6404b22aafc0184e999d8f068b81cc22fa1.tar.gz",
|
||||
.hash = "122014e73fd712190e109950837b97f6143f02d7e2b6986e1db70b6f4aadb5ba6a0d",
|
||||
},
|
||||
.zigini = .{
|
||||
.url = "git+https://github.com/AnErrupTion/zigini?ref=zig-0.15.0#9281f47702b57779e831d7618e158abb8eb4d4a2",
|
||||
.hash = "zigini-0.3.3-36M0FRJJAADZVq5HPm-hYKMpFFTr0OgjbEYcK2ijKZ5n",
|
||||
},
|
||||
.termbox2 = .{
|
||||
.url = "git+https://github.com/AnErrupTion/termbox2?ref=master#290ac6b8225aacfd16851224682b851b65fcb918",
|
||||
.hash = "N-V-__8AAGcUBQAa5vov1Yi_9AXEffFQ1e2KsXaK4dgygRKq",
|
||||
.url = "https://github.com/Kawaii-Ash/zigini/archive/ce1f322482099db058f5d9fdd05fbfa255d79723.tar.gz",
|
||||
.hash = "1220e7a99793a0430e0a7c0b938cb3c98321035bc297e21cd0e2413cf740b4923b9f",
|
||||
},
|
||||
},
|
||||
.paths = .{""},
|
||||
|
||||
47
changelog.md
Normal file
47
changelog.md
Normal file
@@ -0,0 +1,47 @@
|
||||
# Zig Rewrite (Version 1.0.0)
|
||||
|
||||
## Config Options
|
||||
|
||||
res/config.ini contains all of the available config options and their default values.
|
||||
|
||||
### Additions
|
||||
|
||||
+ `border_fg` has been introduced to change the color of the borders.
|
||||
+ `term_restore_cursor_cmd` should restore the cursor to it's usual state.
|
||||
+ `vi_mode` to enable vi keybindings.
|
||||
+ `sleep_key` and `sleep_cmd`.
|
||||
|
||||
Note: `sleep_cmd` is unset by default, meaning it's hidden and has no effect.
|
||||
|
||||
### Changes
|
||||
|
||||
+ xinitrc can be set to null to hide it.
|
||||
+ `blank_password` has been renamed to `clear_password`.
|
||||
+ `save_file` has been deprecated and will be removed in a future version.
|
||||
|
||||
### Removals
|
||||
|
||||
+ `wayland_specifier` has been removed.
|
||||
|
||||
## Save File
|
||||
|
||||
The save file is now in .ini format and stored in the same directory as the config.
|
||||
Older save files will be migrated to the new format.
|
||||
|
||||
Example:
|
||||
|
||||
```ini
|
||||
user = ash
|
||||
session_index = 0
|
||||
```
|
||||
|
||||
## Misc
|
||||
|
||||
+ Display server name added next to selected session.
|
||||
+ getty@tty2 has been added as a conflict in res/ly.service, so if it is running, ly should still be able to start.
|
||||
+ `XDG_CURRENT_DESKTOP` is now set by ly.
|
||||
+ LANG is no longer set by ly.
|
||||
+ X Server PID is fetched from /tmp/X{d}.lock to be able to kill the process since it detaches.
|
||||
+ Non .desktop files are now ignored in sessions directory.
|
||||
+ PAM auth is now done in a child process. (Fixes some issues with logging out and back in).
|
||||
+ When ly receives SIGTERM, the terminal is now cleared and existing child processes are cleaned up.
|
||||
7
dep/termbox_next/.gitignore
vendored
Normal file
7
dep/termbox_next/.gitignore
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
bin
|
||||
obj
|
||||
src/demo/*.o
|
||||
src/demo/keyboard
|
||||
src/demo/output
|
||||
src/demo/paint
|
||||
src/demo/truecolor
|
||||
19
dep/termbox_next/license
Normal file
19
dep/termbox_next/license
Normal file
@@ -0,0 +1,19 @@
|
||||
Copyright (C) 2010-2013 nsf <no.smile.face@gmail.com>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
57
dep/termbox_next/readme.md
Normal file
57
dep/termbox_next/readme.md
Normal file
@@ -0,0 +1,57 @@
|
||||
# Termbox
|
||||
[Termbox](https://github.com/nsf/termbox)
|
||||
was a promising Text User Interface (TUI) library.
|
||||
Unfortunately, its original author
|
||||
[changed his mind](https://github.com/nsf/termbox/issues/37#issuecomment-261075481)
|
||||
about consoles and despite the
|
||||
[community's efforts](https://github.com/nsf/termbox/pull/104#issuecomment-300308156)
|
||||
to keep the library's development going, preferred to let it die. Before it happened,
|
||||
[some people](https://wiki.musl-libc.org/alternatives.html)
|
||||
already noticed the robustness of the initial architecture
|
||||
[became compromised](https://github.com/nsf/termbox/commit/66c3f91b14e24510319bce6b5cc2fecf8cf5abff#commitcomment-3790714)
|
||||
in a nonsensical refactoring frenzy. Now, the author refuses to merge features
|
||||
like true-color support, invoking some
|
||||
[spurious correlations](https://github.com/nsf/termbox/pull/104#issuecomment-300292223)
|
||||
we will discuss no further.
|
||||
|
||||
## The new Termbox-next
|
||||
This fork was made to restore the codebase to its original quality (before
|
||||
[66c3f91](https://github.com/nsf/termbox/commit/66c3f91b14e24510319bce6b5cc2fecf8cf5abff))
|
||||
while providing all the functionnalities of the current implementation.
|
||||
This was achieved by branching at
|
||||
[a2e217f](https://github.com/nsf/termbox/commit/a2e217f0fb97e6bbd589136ea3945f9d5a123d81)
|
||||
and cherry-picking all the commits up to
|
||||
[d63b83a](https://github.com/nsf/termbox/commit/d63b83af04e0fd6da836bb8f37e5cec72a1dc95a)
|
||||
if they weren't harmful.
|
||||
|
||||
## Changes
|
||||
A lot of things changed during the process:
|
||||
- *waf*, the original build system, was completely removed from the
|
||||
project and replaced by make.
|
||||
- anything related to python was removed as well
|
||||
|
||||
## Getting started
|
||||
Termbox's interface only consists of 12 functions:
|
||||
```
|
||||
tb_init() // initialization
|
||||
tb_shutdown() // shutdown
|
||||
|
||||
tb_width() // width of the terminal screen
|
||||
tb_height() // height of the terminal screen
|
||||
|
||||
tb_clear() // clear buffer
|
||||
tb_present() // sync internal buffer with terminal
|
||||
|
||||
tb_put_cell()
|
||||
tb_change_cell()
|
||||
tb_blit() // drawing functions
|
||||
|
||||
tb_select_input_mode() // change input mode
|
||||
tb_peek_event() // peek a keyboard event
|
||||
tb_poll_event() // wait for a keyboard event
|
||||
```
|
||||
See src/termbox.h header file for full detail.
|
||||
|
||||
## TL;DR
|
||||
`make` to build a static version of the lib under bin/termbox.a
|
||||
`cd src/demo && make` to build the example programs in src/demo/
|
||||
827
dep/termbox_next/src/demo/keyboard.c
Normal file
827
dep/termbox_next/src/demo/keyboard.c
Normal file
@@ -0,0 +1,827 @@
|
||||
#include <assert.h>
|
||||
#include <stdint.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include "termbox.h"
|
||||
|
||||
struct key
|
||||
{
|
||||
unsigned char x;
|
||||
unsigned char y;
|
||||
uint32_t ch;
|
||||
};
|
||||
|
||||
#define STOP {0,0,0}
|
||||
struct key K_ESC[] = {{1, 1, 'E'}, {2, 1, 'S'}, {3, 1, 'C'}, STOP};
|
||||
struct key K_F1[] = {{6, 1, 'F'}, {7, 1, '1'}, STOP};
|
||||
struct key K_F2[] = {{9, 1, 'F'}, {10, 1, '2'}, STOP};
|
||||
struct key K_F3[] = {{12, 1, 'F'}, {13, 1, '3'}, STOP};
|
||||
struct key K_F4[] = {{15, 1, 'F'}, {16, 1, '4'}, STOP};
|
||||
struct key K_F5[] = {{19, 1, 'F'}, {20, 1, '5'}, STOP};
|
||||
struct key K_F6[] = {{22, 1, 'F'}, {23, 1, '6'}, STOP};
|
||||
struct key K_F7[] = {{25, 1, 'F'}, {26, 1, '7'}, STOP};
|
||||
struct key K_F8[] = {{28, 1, 'F'}, {29, 1, '8'}, STOP};
|
||||
struct key K_F9[] = {{33, 1, 'F'}, {34, 1, '9'}, STOP};
|
||||
struct key K_F10[] = {{36, 1, 'F'}, {37, 1, '1'}, {38, 1, '0'}, STOP};
|
||||
struct key K_F11[] = {{40, 1, 'F'}, {41, 1, '1'}, {42, 1, '1'}, STOP};
|
||||
struct key K_F12[] = {{44, 1, 'F'}, {45, 1, '1'}, {46, 1, '2'}, STOP};
|
||||
struct key K_PRN[] = {{50, 1, 'P'}, {51, 1, 'R'}, {52, 1, 'N'}, STOP};
|
||||
struct key K_SCR[] = {{54, 1, 'S'}, {55, 1, 'C'}, {56, 1, 'R'}, STOP};
|
||||
struct key K_BRK[] = {{58, 1, 'B'}, {59, 1, 'R'}, {60, 1, 'K'}, STOP};
|
||||
struct key K_LED1[] = {{66, 1, '-'}, STOP};
|
||||
struct key K_LED2[] = {{70, 1, '-'}, STOP};
|
||||
struct key K_LED3[] = {{74, 1, '-'}, STOP};
|
||||
|
||||
struct key K_TILDE[] = {{1, 4, '`'}, STOP};
|
||||
struct key K_TILDE_SHIFT[] = {{1, 4, '~'}, STOP};
|
||||
struct key K_1[] = {{4, 4, '1'}, STOP};
|
||||
struct key K_1_SHIFT[] = {{4, 4, '!'}, STOP};
|
||||
struct key K_2[] = {{7, 4, '2'}, STOP};
|
||||
struct key K_2_SHIFT[] = {{7, 4, '@'}, STOP};
|
||||
struct key K_3[] = {{10, 4, '3'}, STOP};
|
||||
struct key K_3_SHIFT[] = {{10, 4, '#'}, STOP};
|
||||
struct key K_4[] = {{13, 4, '4'}, STOP};
|
||||
struct key K_4_SHIFT[] = {{13, 4, '$'}, STOP};
|
||||
struct key K_5[] = {{16, 4, '5'}, STOP};
|
||||
struct key K_5_SHIFT[] = {{16, 4, '%'}, STOP};
|
||||
struct key K_6[] = {{19, 4, '6'}, STOP};
|
||||
struct key K_6_SHIFT[] = {{19, 4, '^'}, STOP};
|
||||
struct key K_7[] = {{22, 4, '7'}, STOP};
|
||||
struct key K_7_SHIFT[] = {{22, 4, '&'}, STOP};
|
||||
struct key K_8[] = {{25, 4, '8'}, STOP};
|
||||
struct key K_8_SHIFT[] = {{25, 4, '*'}, STOP};
|
||||
struct key K_9[] = {{28, 4, '9'}, STOP};
|
||||
struct key K_9_SHIFT[] = {{28, 4, '('}, STOP};
|
||||
struct key K_0[] = {{31, 4, '0'}, STOP};
|
||||
struct key K_0_SHIFT[] = {{31, 4, ')'}, STOP};
|
||||
struct key K_MINUS[] = {{34, 4, '-'}, STOP};
|
||||
struct key K_MINUS_SHIFT[] = {{34, 4, '_'}, STOP};
|
||||
struct key K_EQUALS[] = {{37, 4, '='}, STOP};
|
||||
struct key K_EQUALS_SHIFT[] = {{37, 4, '+'}, STOP};
|
||||
struct key K_BACKSLASH[] = {{40, 4, '\\'}, STOP};
|
||||
struct key K_BACKSLASH_SHIFT[] = {{40, 4, '|'}, STOP};
|
||||
struct key K_BACKSPACE[] = {{44, 4, 0x2190}, {45, 4, 0x2500}, {46, 4, 0x2500}, STOP};
|
||||
struct key K_INS[] = {{50, 4, 'I'}, {51, 4, 'N'}, {52, 4, 'S'}, STOP};
|
||||
struct key K_HOM[] = {{54, 4, 'H'}, {55, 4, 'O'}, {56, 4, 'M'}, STOP};
|
||||
struct key K_PGU[] = {{58, 4, 'P'}, {59, 4, 'G'}, {60, 4, 'U'}, STOP};
|
||||
struct key K_K_NUMLOCK[] = {{65, 4, 'N'}, STOP};
|
||||
struct key K_K_SLASH[] = {{68, 4, '/'}, STOP};
|
||||
struct key K_K_STAR[] = {{71, 4, '*'}, STOP};
|
||||
struct key K_K_MINUS[] = {{74, 4, '-'}, STOP};
|
||||
|
||||
struct key K_TAB[] = {{1, 6, 'T'}, {2, 6, 'A'}, {3, 6, 'B'}, STOP};
|
||||
struct key K_q[] = {{6, 6, 'q'}, STOP};
|
||||
struct key K_Q[] = {{6, 6, 'Q'}, STOP};
|
||||
struct key K_w[] = {{9, 6, 'w'}, STOP};
|
||||
struct key K_W[] = {{9, 6, 'W'}, STOP};
|
||||
struct key K_e[] = {{12, 6, 'e'}, STOP};
|
||||
struct key K_E[] = {{12, 6, 'E'}, STOP};
|
||||
struct key K_r[] = {{15, 6, 'r'}, STOP};
|
||||
struct key K_R[] = {{15, 6, 'R'}, STOP};
|
||||
struct key K_t[] = {{18, 6, 't'}, STOP};
|
||||
struct key K_T[] = {{18, 6, 'T'}, STOP};
|
||||
struct key K_y[] = {{21, 6, 'y'}, STOP};
|
||||
struct key K_Y[] = {{21, 6, 'Y'}, STOP};
|
||||
struct key K_u[] = {{24, 6, 'u'}, STOP};
|
||||
struct key K_U[] = {{24, 6, 'U'}, STOP};
|
||||
struct key K_i[] = {{27, 6, 'i'}, STOP};
|
||||
struct key K_I[] = {{27, 6, 'I'}, STOP};
|
||||
struct key K_o[] = {{30, 6, 'o'}, STOP};
|
||||
struct key K_O[] = {{30, 6, 'O'}, STOP};
|
||||
struct key K_p[] = {{33, 6, 'p'}, STOP};
|
||||
struct key K_P[] = {{33, 6, 'P'}, STOP};
|
||||
struct key K_LSQB[] = {{36, 6, '['}, STOP};
|
||||
struct key K_LCUB[] = {{36, 6, '{'}, STOP};
|
||||
struct key K_RSQB[] = {{39, 6, ']'}, STOP};
|
||||
struct key K_RCUB[] = {{39, 6, '}'}, STOP};
|
||||
struct key K_ENTER[] =
|
||||
{
|
||||
{43, 6, 0x2591}, {44, 6, 0x2591}, {45, 6, 0x2591}, {46, 6, 0x2591},
|
||||
{43, 7, 0x2591}, {44, 7, 0x2591}, {45, 7, 0x21B5}, {46, 7, 0x2591},
|
||||
{41, 8, 0x2591}, {42, 8, 0x2591}, {43, 8, 0x2591}, {44, 8, 0x2591},
|
||||
{45, 8, 0x2591}, {46, 8, 0x2591}, STOP
|
||||
};
|
||||
struct key K_DEL[] = {{50, 6, 'D'}, {51, 6, 'E'}, {52, 6, 'L'}, STOP};
|
||||
struct key K_END[] = {{54, 6, 'E'}, {55, 6, 'N'}, {56, 6, 'D'}, STOP};
|
||||
struct key K_PGD[] = {{58, 6, 'P'}, {59, 6, 'G'}, {60, 6, 'D'}, STOP};
|
||||
struct key K_K_7[] = {{65, 6, '7'}, STOP};
|
||||
struct key K_K_8[] = {{68, 6, '8'}, STOP};
|
||||
struct key K_K_9[] = {{71, 6, '9'}, STOP};
|
||||
struct key K_K_PLUS[] = {{74, 6, ' '}, {74, 7, '+'}, {74, 8, ' '}, STOP};
|
||||
|
||||
struct key K_CAPS[] = {{1, 8, 'C'}, {2, 8, 'A'}, {3, 8, 'P'}, {4, 8, 'S'}, STOP};
|
||||
struct key K_a[] = {{7, 8, 'a'}, STOP};
|
||||
struct key K_A[] = {{7, 8, 'A'}, STOP};
|
||||
struct key K_s[] = {{10, 8, 's'}, STOP};
|
||||
struct key K_S[] = {{10, 8, 'S'}, STOP};
|
||||
struct key K_d[] = {{13, 8, 'd'}, STOP};
|
||||
struct key K_D[] = {{13, 8, 'D'}, STOP};
|
||||
struct key K_f[] = {{16, 8, 'f'}, STOP};
|
||||
struct key K_F[] = {{16, 8, 'F'}, STOP};
|
||||
struct key K_g[] = {{19, 8, 'g'}, STOP};
|
||||
struct key K_G[] = {{19, 8, 'G'}, STOP};
|
||||
struct key K_h[] = {{22, 8, 'h'}, STOP};
|
||||
struct key K_H[] = {{22, 8, 'H'}, STOP};
|
||||
struct key K_j[] = {{25, 8, 'j'}, STOP};
|
||||
struct key K_J[] = {{25, 8, 'J'}, STOP};
|
||||
struct key K_k[] = {{28, 8, 'k'}, STOP};
|
||||
struct key K_K[] = {{28, 8, 'K'}, STOP};
|
||||
struct key K_l[] = {{31, 8, 'l'}, STOP};
|
||||
struct key K_L[] = {{31, 8, 'L'}, STOP};
|
||||
struct key K_SEMICOLON[] = {{34, 8, ';'}, STOP};
|
||||
struct key K_PARENTHESIS[] = {{34, 8, ':'}, STOP};
|
||||
struct key K_QUOTE[] = {{37, 8, '\''}, STOP};
|
||||
struct key K_DOUBLEQUOTE[] = {{37, 8, '"'}, STOP};
|
||||
struct key K_K_4[] = {{65, 8, '4'}, STOP};
|
||||
struct key K_K_5[] = {{68, 8, '5'}, STOP};
|
||||
struct key K_K_6[] = {{71, 8, '6'}, STOP};
|
||||
|
||||
struct key K_LSHIFT[] = {{1, 10, 'S'}, {2, 10, 'H'}, {3, 10, 'I'}, {4, 10, 'F'}, {5, 10, 'T'}, STOP};
|
||||
struct key K_z[] = {{9, 10, 'z'}, STOP};
|
||||
struct key K_Z[] = {{9, 10, 'Z'}, STOP};
|
||||
struct key K_x[] = {{12, 10, 'x'}, STOP};
|
||||
struct key K_X[] = {{12, 10, 'X'}, STOP};
|
||||
struct key K_c[] = {{15, 10, 'c'}, STOP};
|
||||
struct key K_C[] = {{15, 10, 'C'}, STOP};
|
||||
struct key K_v[] = {{18, 10, 'v'}, STOP};
|
||||
struct key K_V[] = {{18, 10, 'V'}, STOP};
|
||||
struct key K_b[] = {{21, 10, 'b'}, STOP};
|
||||
struct key K_B[] = {{21, 10, 'B'}, STOP};
|
||||
struct key K_n[] = {{24, 10, 'n'}, STOP};
|
||||
struct key K_N[] = {{24, 10, 'N'}, STOP};
|
||||
struct key K_m[] = {{27, 10, 'm'}, STOP};
|
||||
struct key K_M[] = {{27, 10, 'M'}, STOP};
|
||||
struct key K_COMMA[] = {{30, 10, ','}, STOP};
|
||||
struct key K_LANB[] = {{30, 10, '<'}, STOP};
|
||||
struct key K_PERIOD[] = {{33, 10, '.'}, STOP};
|
||||
struct key K_RANB[] = {{33, 10, '>'}, STOP};
|
||||
struct key K_SLASH[] = {{36, 10, '/'}, STOP};
|
||||
struct key K_QUESTION[] = {{36, 10, '?'}, STOP};
|
||||
struct key K_RSHIFT[] = {{42, 10, 'S'}, {43, 10, 'H'}, {44, 10, 'I'}, {45, 10, 'F'}, {46, 10, 'T'}, STOP};
|
||||
struct key K_ARROW_UP[] = {{54, 10, '('}, {55, 10, 0x2191}, {56, 10, ')'}, STOP};
|
||||
struct key K_K_1[] = {{65, 10, '1'}, STOP};
|
||||
struct key K_K_2[] = {{68, 10, '2'}, STOP};
|
||||
struct key K_K_3[] = {{71, 10, '3'}, STOP};
|
||||
struct key K_K_ENTER[] = {{74, 10, 0x2591}, {74, 11, 0x2591}, {74, 12, 0x2591}, STOP};
|
||||
|
||||
struct key K_LCTRL[] = {{1, 12, 'C'}, {2, 12, 'T'}, {3, 12, 'R'}, {4, 12, 'L'}, STOP};
|
||||
struct key K_LWIN[] = {{6, 12, 'W'}, {7, 12, 'I'}, {8, 12, 'N'}, STOP};
|
||||
struct key K_LALT[] = {{10, 12, 'A'}, {11, 12, 'L'}, {12, 12, 'T'}, STOP};
|
||||
struct key K_SPACE[] =
|
||||
{
|
||||
{14, 12, ' '}, {15, 12, ' '}, {16, 12, ' '}, {17, 12, ' '}, {18, 12, ' '},
|
||||
{19, 12, 'S'}, {20, 12, 'P'}, {21, 12, 'A'}, {22, 12, 'C'}, {23, 12, 'E'},
|
||||
{24, 12, ' '}, {25, 12, ' '}, {26, 12, ' '}, {27, 12, ' '}, {28, 12, ' '},
|
||||
STOP
|
||||
};
|
||||
struct key K_RALT[] = {{30, 12, 'A'}, {31, 12, 'L'}, {32, 12, 'T'}, STOP};
|
||||
struct key K_RWIN[] = {{34, 12, 'W'}, {35, 12, 'I'}, {36, 12, 'N'}, STOP};
|
||||
struct key K_RPROP[] = {{38, 12, 'P'}, {39, 12, 'R'}, {40, 12, 'O'}, {41, 12, 'P'}, STOP};
|
||||
struct key K_RCTRL[] = {{43, 12, 'C'}, {44, 12, 'T'}, {45, 12, 'R'}, {46, 12, 'L'}, STOP};
|
||||
struct key K_ARROW_LEFT[] = {{50, 12, '('}, {51, 12, 0x2190}, {52, 12, ')'}, STOP};
|
||||
struct key K_ARROW_DOWN[] = {{54, 12, '('}, {55, 12, 0x2193}, {56, 12, ')'}, STOP};
|
||||
struct key K_ARROW_RIGHT[] = {{58, 12, '('}, {59, 12, 0x2192}, {60, 12, ')'}, STOP};
|
||||
struct key K_K_0[] = {{65, 12, ' '}, {66, 12, '0'}, {67, 12, ' '}, {68, 12, ' '}, STOP};
|
||||
struct key K_K_PERIOD[] = {{71, 12, '.'}, STOP};
|
||||
|
||||
struct combo
|
||||
{
|
||||
struct key* keys[6];
|
||||
};
|
||||
|
||||
struct combo combos[] =
|
||||
{
|
||||
{{K_TILDE, K_2, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_A, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_B, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_C, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_D, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_E, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_F, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_G, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_H, K_BACKSPACE, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_I, K_TAB, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_J, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_K, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_L, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_M, K_ENTER, K_K_ENTER, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_N, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_O, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_P, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_Q, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_R, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_S, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_T, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_U, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_V, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_W, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_X, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_Y, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_Z, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_LSQB, K_ESC, K_3, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_4, K_BACKSLASH, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_RSQB, K_5, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_6, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_7, K_SLASH, K_MINUS_SHIFT, K_LCTRL, K_RCTRL, 0}},
|
||||
{{K_SPACE, 0}},
|
||||
{{K_1_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_DOUBLEQUOTE, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_3_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_4_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_5_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_7_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_QUOTE, 0}},
|
||||
{{K_9_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_0_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_8_SHIFT, K_K_STAR, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_EQUALS_SHIFT, K_K_PLUS, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_COMMA, 0}},
|
||||
{{K_MINUS, K_K_MINUS, 0}},
|
||||
{{K_PERIOD, K_K_PERIOD, 0}},
|
||||
{{K_SLASH, K_K_SLASH, 0}},
|
||||
{{K_0, K_K_0, 0}},
|
||||
{{K_1, K_K_1, 0}},
|
||||
{{K_2, K_K_2, 0}},
|
||||
{{K_3, K_K_3, 0}},
|
||||
{{K_4, K_K_4, 0}},
|
||||
{{K_5, K_K_5, 0}},
|
||||
{{K_6, K_K_6, 0}},
|
||||
{{K_7, K_K_7, 0}},
|
||||
{{K_8, K_K_8, 0}},
|
||||
{{K_9, K_K_9, 0}},
|
||||
{{K_PARENTHESIS, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_SEMICOLON, 0}},
|
||||
{{K_LANB, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_EQUALS, 0}},
|
||||
{{K_RANB, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_QUESTION, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_2_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_A, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_B, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_C, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_D, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_E, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_F, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_G, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_H, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_I, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_J, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_K, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_L, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_M, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_N, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_O, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_P, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_Q, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_R, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_S, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_T, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_U, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_V, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_W, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_X, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_Y, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_Z, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_LSQB, 0}},
|
||||
{{K_BACKSLASH, 0}},
|
||||
{{K_RSQB, 0}},
|
||||
{{K_6_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_MINUS_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_TILDE, 0}},
|
||||
{{K_a, 0}},
|
||||
{{K_b, 0}},
|
||||
{{K_c, 0}},
|
||||
{{K_d, 0}},
|
||||
{{K_e, 0}},
|
||||
{{K_f, 0}},
|
||||
{{K_g, 0}},
|
||||
{{K_h, 0}},
|
||||
{{K_i, 0}},
|
||||
{{K_j, 0}},
|
||||
{{K_k, 0}},
|
||||
{{K_l, 0}},
|
||||
{{K_m, 0}},
|
||||
{{K_n, 0}},
|
||||
{{K_o, 0}},
|
||||
{{K_p, 0}},
|
||||
{{K_q, 0}},
|
||||
{{K_r, 0}},
|
||||
{{K_s, 0}},
|
||||
{{K_t, 0}},
|
||||
{{K_u, 0}},
|
||||
{{K_v, 0}},
|
||||
{{K_w, 0}},
|
||||
{{K_x, 0}},
|
||||
{{K_y, 0}},
|
||||
{{K_z, 0}},
|
||||
{{K_LCUB, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_BACKSLASH_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_RCUB, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_TILDE_SHIFT, K_LSHIFT, K_RSHIFT, 0}},
|
||||
{{K_8, K_BACKSPACE, K_LCTRL, K_RCTRL, 0}}
|
||||
};
|
||||
|
||||
struct combo func_combos[] =
|
||||
{
|
||||
{{K_F1, 0}},
|
||||
{{K_F2, 0}},
|
||||
{{K_F3, 0}},
|
||||
{{K_F4, 0}},
|
||||
{{K_F5, 0}},
|
||||
{{K_F6, 0}},
|
||||
{{K_F7, 0}},
|
||||
{{K_F8, 0}},
|
||||
{{K_F9, 0}},
|
||||
{{K_F10, 0}},
|
||||
{{K_F11, 0}},
|
||||
{{K_F12, 0}},
|
||||
{{K_INS, 0}},
|
||||
{{K_DEL, 0}},
|
||||
{{K_HOM, 0}},
|
||||
{{K_END, 0}},
|
||||
{{K_PGU, 0}},
|
||||
{{K_PGD, 0}},
|
||||
{{K_ARROW_UP, 0}},
|
||||
{{K_ARROW_DOWN, 0}},
|
||||
{{K_ARROW_LEFT, 0}},
|
||||
{{K_ARROW_RIGHT, 0}}
|
||||
};
|
||||
|
||||
void print_tb(const char* str, int x, int y, uint32_t fg, uint32_t bg)
|
||||
{
|
||||
while (*str)
|
||||
{
|
||||
uint32_t uni;
|
||||
str += utf8_char_to_unicode(&uni, str);
|
||||
tb_change_cell(x, y, uni, fg, bg);
|
||||
x++;
|
||||
}
|
||||
}
|
||||
|
||||
void printf_tb(int x, int y, uint32_t fg, uint32_t bg, const char* fmt, ...)
|
||||
{
|
||||
char buf[4096];
|
||||
va_list vl;
|
||||
va_start(vl, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, vl);
|
||||
va_end(vl);
|
||||
print_tb(buf, x, y, fg, bg);
|
||||
}
|
||||
|
||||
void draw_key(struct key* k, uint32_t fg, uint32_t bg)
|
||||
{
|
||||
while (k->x)
|
||||
{
|
||||
tb_change_cell(k->x + 2, k->y + 4, k->ch, fg, bg);
|
||||
k++;
|
||||
}
|
||||
}
|
||||
|
||||
void draw_keyboard()
|
||||
{
|
||||
int i;
|
||||
tb_change_cell(0, 0, 0x250C, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(79, 0, 0x2510, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(0, 23, 0x2514, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(79, 23, 0x2518, TB_WHITE, TB_DEFAULT);
|
||||
|
||||
for (i = 1; i < 79; ++i)
|
||||
{
|
||||
tb_change_cell(i, 0, 0x2500, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(i, 23, 0x2500, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(i, 17, 0x2500, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(i, 4, 0x2500, TB_WHITE, TB_DEFAULT);
|
||||
}
|
||||
|
||||
for (i = 1; i < 23; ++i)
|
||||
{
|
||||
tb_change_cell(0, i, 0x2502, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(79, i, 0x2502, TB_WHITE, TB_DEFAULT);
|
||||
}
|
||||
|
||||
tb_change_cell(0, 17, 0x251C, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(79, 17, 0x2524, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(0, 4, 0x251C, TB_WHITE, TB_DEFAULT);
|
||||
tb_change_cell(79, 4, 0x2524, TB_WHITE, TB_DEFAULT);
|
||||
|
||||
for (i = 5; i < 17; ++i)
|
||||
{
|
||||
tb_change_cell(1, i, 0x2588, TB_YELLOW, TB_YELLOW);
|
||||
tb_change_cell(78, i, 0x2588, TB_YELLOW, TB_YELLOW);
|
||||
}
|
||||
|
||||
draw_key(K_ESC, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F1, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F2, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F3, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F4, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F5, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F6, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F7, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F8, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F9, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F10, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F11, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_F12, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_PRN, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_SCR, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_BRK, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LED1, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LED2, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LED3, TB_WHITE, TB_BLUE);
|
||||
|
||||
draw_key(K_TILDE, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_1, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_2, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_3, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_4, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_5, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_6, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_7, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_8, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_9, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_0, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_MINUS, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_EQUALS, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_BACKSLASH, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_BACKSPACE, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_INS, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_HOM, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_PGU, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_NUMLOCK, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_SLASH, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_STAR, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_MINUS, TB_WHITE, TB_BLUE);
|
||||
|
||||
draw_key(K_TAB, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_q, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_w, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_e, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_r, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_t, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_y, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_u, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_i, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_o, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_p, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LSQB, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RSQB, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_ENTER, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_DEL, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_END, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_PGD, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_7, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_8, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_9, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_PLUS, TB_WHITE, TB_BLUE);
|
||||
|
||||
draw_key(K_CAPS, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_a, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_s, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_d, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_f, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_g, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_h, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_j, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_k, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_l, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_SEMICOLON, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_QUOTE, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_4, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_5, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_6, TB_WHITE, TB_BLUE);
|
||||
|
||||
draw_key(K_LSHIFT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_z, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_x, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_c, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_v, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_b, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_n, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_m, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_COMMA, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_PERIOD, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_SLASH, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RSHIFT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_ARROW_UP, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_1, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_2, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_3, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_ENTER, TB_WHITE, TB_BLUE);
|
||||
|
||||
draw_key(K_LCTRL, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LWIN, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_LALT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_SPACE, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RCTRL, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RPROP, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RWIN, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_RALT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_ARROW_LEFT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_ARROW_DOWN, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_ARROW_RIGHT, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_0, TB_WHITE, TB_BLUE);
|
||||
draw_key(K_K_PERIOD, TB_WHITE, TB_BLUE);
|
||||
|
||||
printf_tb(33, 1, TB_MAGENTA | TB_BOLD, TB_DEFAULT, "Keyboard demo!");
|
||||
printf_tb(21, 2, TB_MAGENTA, TB_DEFAULT,
|
||||
"(press CTRL+X and then CTRL+Q to exit)");
|
||||
printf_tb(15, 3, TB_MAGENTA, TB_DEFAULT,
|
||||
"(press CTRL+X and then CTRL+C to change input mode)");
|
||||
|
||||
int inputmode = tb_select_input_mode(0);
|
||||
char inputmode_str[64];
|
||||
|
||||
if (inputmode & TB_INPUT_ESC)
|
||||
{
|
||||
sprintf(inputmode_str, "TB_INPUT_ESC");
|
||||
}
|
||||
|
||||
if (inputmode & TB_INPUT_ALT)
|
||||
{
|
||||
sprintf(inputmode_str, "TB_INPUT_ALT");
|
||||
}
|
||||
|
||||
if (inputmode & TB_INPUT_MOUSE)
|
||||
{
|
||||
sprintf(inputmode_str + 12, " | TB_INPUT_MOUSE");
|
||||
}
|
||||
|
||||
printf_tb(3, 18, TB_WHITE, TB_DEFAULT, "Input mode: %s", inputmode_str);
|
||||
}
|
||||
|
||||
const char* funckeymap(int k)
|
||||
{
|
||||
static const char* fcmap[] =
|
||||
{
|
||||
"CTRL+2, CTRL+~",
|
||||
"CTRL+A",
|
||||
"CTRL+B",
|
||||
"CTRL+C",
|
||||
"CTRL+D",
|
||||
"CTRL+E",
|
||||
"CTRL+F",
|
||||
"CTRL+G",
|
||||
"CTRL+H, BACKSPACE",
|
||||
"CTRL+I, TAB",
|
||||
"CTRL+J",
|
||||
"CTRL+K",
|
||||
"CTRL+L",
|
||||
"CTRL+M, ENTER",
|
||||
"CTRL+N",
|
||||
"CTRL+O",
|
||||
"CTRL+P",
|
||||
"CTRL+Q",
|
||||
"CTRL+R",
|
||||
"CTRL+S",
|
||||
"CTRL+T",
|
||||
"CTRL+U",
|
||||
"CTRL+V",
|
||||
"CTRL+W",
|
||||
"CTRL+X",
|
||||
"CTRL+Y",
|
||||
"CTRL+Z",
|
||||
"CTRL+3, ESC, CTRL+[",
|
||||
"CTRL+4, CTRL+\\",
|
||||
"CTRL+5, CTRL+]",
|
||||
"CTRL+6",
|
||||
"CTRL+7, CTRL+/, CTRL+_",
|
||||
"SPACE"
|
||||
};
|
||||
static const char* fkmap[] =
|
||||
{
|
||||
"F1",
|
||||
"F2",
|
||||
"F3",
|
||||
"F4",
|
||||
"F5",
|
||||
"F6",
|
||||
"F7",
|
||||
"F8",
|
||||
"F9",
|
||||
"F10",
|
||||
"F11",
|
||||
"F12",
|
||||
"INSERT",
|
||||
"DELETE",
|
||||
"HOME",
|
||||
"END",
|
||||
"PGUP",
|
||||
"PGDN",
|
||||
"ARROW UP",
|
||||
"ARROW DOWN",
|
||||
"ARROW LEFT",
|
||||
"ARROW RIGHT"
|
||||
};
|
||||
|
||||
if (k == TB_KEY_CTRL_8)
|
||||
{
|
||||
return "CTRL+8, BACKSPACE 2"; // 0x7F
|
||||
}
|
||||
else if (k >= TB_KEY_ARROW_RIGHT && k <= 0xFFFF)
|
||||
{
|
||||
return fkmap[0xFFFF - k];
|
||||
}
|
||||
else if (k <= TB_KEY_SPACE)
|
||||
{
|
||||
return fcmap[k];
|
||||
}
|
||||
|
||||
return "UNKNOWN";
|
||||
}
|
||||
|
||||
void pretty_print_press(struct tb_event* ev)
|
||||
{
|
||||
char buf[7];
|
||||
buf[utf8_unicode_to_char(buf, ev->ch)] = '\0';
|
||||
printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Key: ");
|
||||
printf_tb(8, 19, TB_YELLOW, TB_DEFAULT, "decimal: %d", ev->key);
|
||||
printf_tb(8, 20, TB_GREEN, TB_DEFAULT, "hex: 0x%X", ev->key);
|
||||
printf_tb(8, 21, TB_CYAN, TB_DEFAULT, "octal: 0%o", ev->key);
|
||||
printf_tb(8, 22, TB_RED, TB_DEFAULT, "string: %s", funckeymap(ev->key));
|
||||
|
||||
printf_tb(54, 19, TB_WHITE, TB_DEFAULT, "Char: ");
|
||||
printf_tb(60, 19, TB_YELLOW, TB_DEFAULT, "decimal: %d", ev->ch);
|
||||
printf_tb(60, 20, TB_GREEN, TB_DEFAULT, "hex: 0x%X", ev->ch);
|
||||
printf_tb(60, 21, TB_CYAN, TB_DEFAULT, "octal: 0%o", ev->ch);
|
||||
printf_tb(60, 22, TB_RED, TB_DEFAULT, "string: %s", buf);
|
||||
|
||||
printf_tb(54, 18, TB_WHITE, TB_DEFAULT, "Modifier: %s",
|
||||
(ev->mod) ? "TB_MOD_ALT" : "none");
|
||||
|
||||
}
|
||||
|
||||
void pretty_print_resize(struct tb_event* ev)
|
||||
{
|
||||
printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Resize event: %d x %d", ev->w, ev->h);
|
||||
}
|
||||
|
||||
int counter = 0;
|
||||
|
||||
void pretty_print_mouse(struct tb_event* ev)
|
||||
{
|
||||
printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Mouse event: %d x %d", ev->x, ev->y);
|
||||
char* btn = "";
|
||||
|
||||
switch (ev->key)
|
||||
{
|
||||
case TB_KEY_MOUSE_LEFT:
|
||||
btn = "MouseLeft: %d";
|
||||
break;
|
||||
|
||||
case TB_KEY_MOUSE_MIDDLE:
|
||||
btn = "MouseMiddle: %d";
|
||||
break;
|
||||
|
||||
case TB_KEY_MOUSE_RIGHT:
|
||||
btn = "MouseRight: %d";
|
||||
break;
|
||||
|
||||
case TB_KEY_MOUSE_WHEEL_UP:
|
||||
btn = "MouseWheelUp: %d";
|
||||
break;
|
||||
|
||||
case TB_KEY_MOUSE_WHEEL_DOWN:
|
||||
btn = "MouseWheelDown: %d";
|
||||
break;
|
||||
|
||||
case TB_KEY_MOUSE_RELEASE:
|
||||
btn = "MouseRelease: %d";
|
||||
}
|
||||
|
||||
counter++;
|
||||
printf_tb(43, 19, TB_WHITE, TB_DEFAULT, "Key: ");
|
||||
printf_tb(48, 19, TB_YELLOW, TB_DEFAULT, btn, counter);
|
||||
}
|
||||
|
||||
void dispatch_press(struct tb_event* ev)
|
||||
{
|
||||
if (ev->mod & TB_MOD_ALT)
|
||||
{
|
||||
draw_key(K_LALT, TB_WHITE, TB_RED);
|
||||
draw_key(K_RALT, TB_WHITE, TB_RED);
|
||||
}
|
||||
|
||||
struct combo* k = 0;
|
||||
|
||||
if (ev->key >= TB_KEY_ARROW_RIGHT)
|
||||
{
|
||||
k = &func_combos[0xFFFF - ev->key];
|
||||
}
|
||||
else if (ev->ch < 128)
|
||||
{
|
||||
if (ev->ch == 0 && ev->key < 128)
|
||||
{
|
||||
k = &combos[ev->key];
|
||||
}
|
||||
else
|
||||
{
|
||||
k = &combos[ev->ch];
|
||||
}
|
||||
}
|
||||
|
||||
if (!k)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
struct key** keys = k->keys;
|
||||
|
||||
while (*keys)
|
||||
{
|
||||
draw_key(*keys, TB_WHITE, TB_RED);
|
||||
keys++;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
(void) argc;
|
||||
(void) argv;
|
||||
int ret;
|
||||
|
||||
ret = tb_init();
|
||||
|
||||
if (ret)
|
||||
{
|
||||
fprintf(stderr, "tb_init() failed with error code %d\n", ret);
|
||||
return 1;
|
||||
}
|
||||
|
||||
tb_select_input_mode(TB_INPUT_ESC | TB_INPUT_MOUSE);
|
||||
struct tb_event ev;
|
||||
|
||||
tb_clear();
|
||||
draw_keyboard();
|
||||
tb_present();
|
||||
int inputmode = 0;
|
||||
int ctrlxpressed = 0;
|
||||
|
||||
while (tb_poll_event(&ev))
|
||||
{
|
||||
switch (ev.type)
|
||||
{
|
||||
case TB_EVENT_KEY:
|
||||
if (ev.key == TB_KEY_CTRL_Q && ctrlxpressed)
|
||||
{
|
||||
tb_shutdown();
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ev.key == TB_KEY_CTRL_C && ctrlxpressed)
|
||||
{
|
||||
static int chmap[] =
|
||||
{
|
||||
TB_INPUT_ESC | TB_INPUT_MOUSE, // 101
|
||||
TB_INPUT_ALT | TB_INPUT_MOUSE, // 110
|
||||
TB_INPUT_ESC, // 001
|
||||
TB_INPUT_ALT, // 010
|
||||
};
|
||||
inputmode++;
|
||||
|
||||
if (inputmode >= 4)
|
||||
{
|
||||
inputmode = 0;
|
||||
}
|
||||
|
||||
tb_select_input_mode(chmap[inputmode]);
|
||||
}
|
||||
|
||||
if (ev.key == TB_KEY_CTRL_X)
|
||||
{
|
||||
ctrlxpressed = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ctrlxpressed = 0;
|
||||
}
|
||||
|
||||
tb_clear();
|
||||
draw_keyboard();
|
||||
dispatch_press(&ev);
|
||||
pretty_print_press(&ev);
|
||||
tb_present();
|
||||
break;
|
||||
|
||||
case TB_EVENT_RESIZE:
|
||||
tb_clear();
|
||||
draw_keyboard();
|
||||
pretty_print_resize(&ev);
|
||||
tb_present();
|
||||
break;
|
||||
|
||||
case TB_EVENT_MOUSE:
|
||||
tb_clear();
|
||||
draw_keyboard();
|
||||
pretty_print_mouse(&ev);
|
||||
tb_present();
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
tb_shutdown();
|
||||
return 0;
|
||||
}
|
||||
30
dep/termbox_next/src/demo/makefile
Normal file
30
dep/termbox_next/src/demo/makefile
Normal file
@@ -0,0 +1,30 @@
|
||||
CC=gcc
|
||||
FLAGS=-std=c99 -pedantic -Wall -Werror -g -static
|
||||
INCL=-I../
|
||||
BIND=../../bin
|
||||
|
||||
%.o:%.c
|
||||
@echo "building source object $@"
|
||||
@$(CC) $(INCL) $(FLAGS) -c -o $@ $<
|
||||
|
||||
all:keyboard output paint truecolor
|
||||
|
||||
keyboard:keyboard.o
|
||||
@echo "compiling $@"
|
||||
@$(CC) $(INCL) $(FLAGS) -o $@ $@.o $(BIND)/termbox.a
|
||||
|
||||
output:output.o
|
||||
@echo "compiling $@"
|
||||
@$(CC) $(INCL) $(FLAGS) -o $@ $@.o $(BIND)/termbox.a
|
||||
|
||||
paint:paint.o
|
||||
@echo "compiling $@"
|
||||
@$(CC) $(INCL) $(FLAGS) -o $@ $@.o $(BIND)/termbox.a
|
||||
|
||||
truecolor:truecolor.o
|
||||
@echo "compiling $@"
|
||||
@$(CC) $(INCL) $(FLAGS) -o $@ $@.o $(BIND)/termbox.a
|
||||
|
||||
clean:
|
||||
@echo "cleaning workspace"
|
||||
@rm -rf *.o keyboard output paint truecolor
|
||||
156
dep/termbox_next/src/demo/output.c
Normal file
156
dep/termbox_next/src/demo/output.c
Normal file
@@ -0,0 +1,156 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "../termbox.h"
|
||||
|
||||
static const char chars[] = "nnnnnnnnnbbbbbbbbbuuuuuuuuuBBBBBBBBB";
|
||||
|
||||
static const uint32_t all_attrs[] =
|
||||
{
|
||||
0,
|
||||
TB_BOLD,
|
||||
TB_UNDERLINE,
|
||||
TB_BOLD | TB_UNDERLINE,
|
||||
};
|
||||
|
||||
static int next_char(int current)
|
||||
{
|
||||
current++;
|
||||
|
||||
if (!chars[current])
|
||||
{
|
||||
current = 0;
|
||||
}
|
||||
|
||||
return current;
|
||||
}
|
||||
|
||||
static void draw_line(int x, int y, uint32_t bg)
|
||||
{
|
||||
int a, c;
|
||||
int current_char = 0;
|
||||
|
||||
for (a = 0; a < 4; a++)
|
||||
{
|
||||
for (c = TB_DEFAULT; c <= TB_WHITE; c++)
|
||||
{
|
||||
uint32_t fg = all_attrs[a] | c;
|
||||
tb_change_cell(x, y, chars[current_char], fg, bg);
|
||||
current_char = next_char(current_char);
|
||||
x++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void print_combinations_table(int sx, int sy, const uint32_t* attrs,
|
||||
int attrs_n)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
for (i = 0; i < attrs_n; i++)
|
||||
{
|
||||
for (c = TB_DEFAULT; c <= TB_WHITE; c++)
|
||||
{
|
||||
uint32_t bg = attrs[i] | c;
|
||||
draw_line(sx, sy, bg);
|
||||
sy++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void draw_all()
|
||||
{
|
||||
tb_clear();
|
||||
|
||||
tb_select_output_mode(TB_OUTPUT_NORMAL);
|
||||
static const uint32_t col1[] = {0, TB_BOLD};
|
||||
static const uint32_t col2[] = {TB_REVERSE};
|
||||
print_combinations_table(1, 1, col1, 2);
|
||||
print_combinations_table(2 + strlen(chars), 1, col2, 1);
|
||||
tb_present();
|
||||
|
||||
tb_select_output_mode(TB_OUTPUT_GRAYSCALE);
|
||||
int c, x, y;
|
||||
|
||||
for (x = 0, y = 23; x < 24; ++x)
|
||||
{
|
||||
tb_change_cell(x, y, '@', x, 0);
|
||||
tb_change_cell(x + 25, y, ' ', 0, x);
|
||||
}
|
||||
|
||||
tb_present();
|
||||
|
||||
tb_select_output_mode(TB_OUTPUT_216);
|
||||
y++;
|
||||
|
||||
for (c = 0, x = 0; c < 216; ++c, ++x)
|
||||
{
|
||||
if (!(x % 24))
|
||||
{
|
||||
x = 0;
|
||||
++y;
|
||||
}
|
||||
|
||||
tb_change_cell(x, y, '@', c, 0);
|
||||
tb_change_cell(x + 25, y, ' ', 0, c);
|
||||
}
|
||||
|
||||
tb_present();
|
||||
|
||||
tb_select_output_mode(TB_OUTPUT_256);
|
||||
y++;
|
||||
|
||||
for (c = 0, x = 0; c < 256; ++c, ++x)
|
||||
{
|
||||
if (!(x % 24))
|
||||
{
|
||||
x = 0;
|
||||
++y;
|
||||
}
|
||||
|
||||
tb_change_cell(x, y, '+', c | ((y & 1) ? TB_UNDERLINE : 0), 0);
|
||||
tb_change_cell(x + 25, y, ' ', 0, c);
|
||||
}
|
||||
|
||||
tb_present();
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
int ret = tb_init();
|
||||
|
||||
if (ret)
|
||||
{
|
||||
fprintf(stderr, "tb_init() failed with error code %d\n", ret);
|
||||
return 1;
|
||||
}
|
||||
|
||||
draw_all();
|
||||
|
||||
struct tb_event ev;
|
||||
|
||||
while (tb_poll_event(&ev))
|
||||
{
|
||||
switch (ev.type)
|
||||
{
|
||||
case TB_EVENT_KEY:
|
||||
switch (ev.key)
|
||||
{
|
||||
case TB_KEY_ESC:
|
||||
goto done;
|
||||
break;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case TB_EVENT_RESIZE:
|
||||
draw_all();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
tb_shutdown();
|
||||
return 0;
|
||||
}
|
||||
183
dep/termbox_next/src/demo/paint.c
Normal file
183
dep/termbox_next/src/demo/paint.c
Normal file
@@ -0,0 +1,183 @@
|
||||
#include "../termbox.h"
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
static int curCol = 0;
|
||||
static int curRune = 0;
|
||||
static struct tb_cell* backbuf;
|
||||
static int bbw = 0, bbh = 0;
|
||||
|
||||
static const uint32_t runes[] =
|
||||
{
|
||||
0x20, // ' '
|
||||
0x2591, // '░'
|
||||
0x2592, // '▒'
|
||||
0x2593, // '▓'
|
||||
0x2588, // '█'
|
||||
};
|
||||
|
||||
#define len(a) (sizeof(a)/sizeof(a[0]))
|
||||
|
||||
static const uint32_t colors[] =
|
||||
{
|
||||
TB_BLACK,
|
||||
TB_RED,
|
||||
TB_GREEN,
|
||||
TB_YELLOW,
|
||||
TB_BLUE,
|
||||
TB_MAGENTA,
|
||||
TB_CYAN,
|
||||
TB_WHITE,
|
||||
};
|
||||
|
||||
void updateAndDrawButtons(int* current, int x, int y, int mx, int my, int n,
|
||||
void (*attrFunc)(int, uint32_t*, uint32_t*, uint32_t*))
|
||||
{
|
||||
int lx = x;
|
||||
int ly = y;
|
||||
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
if (lx <= mx && mx <= lx + 3 && ly <= my && my <= ly + 1)
|
||||
{
|
||||
*current = i;
|
||||
}
|
||||
|
||||
uint32_t r;
|
||||
uint32_t fg, bg;
|
||||
(*attrFunc)(i, &r, &fg, &bg);
|
||||
tb_change_cell(lx + 0, ly + 0, r, fg, bg);
|
||||
tb_change_cell(lx + 1, ly + 0, r, fg, bg);
|
||||
tb_change_cell(lx + 2, ly + 0, r, fg, bg);
|
||||
tb_change_cell(lx + 3, ly + 0, r, fg, bg);
|
||||
tb_change_cell(lx + 0, ly + 1, r, fg, bg);
|
||||
tb_change_cell(lx + 1, ly + 1, r, fg, bg);
|
||||
tb_change_cell(lx + 2, ly + 1, r, fg, bg);
|
||||
tb_change_cell(lx + 3, ly + 1, r, fg, bg);
|
||||
lx += 4;
|
||||
}
|
||||
|
||||
lx = x;
|
||||
ly = y;
|
||||
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
if (*current == i)
|
||||
{
|
||||
uint32_t fg = TB_RED | TB_BOLD;
|
||||
uint32_t bg = TB_DEFAULT;
|
||||
tb_change_cell(lx + 0, ly + 2, '^', fg, bg);
|
||||
tb_change_cell(lx + 1, ly + 2, '^', fg, bg);
|
||||
tb_change_cell(lx + 2, ly + 2, '^', fg, bg);
|
||||
tb_change_cell(lx + 3, ly + 2, '^', fg, bg);
|
||||
}
|
||||
|
||||
lx += 4;
|
||||
}
|
||||
}
|
||||
|
||||
void runeAttrFunc(int i, uint32_t* r, uint32_t* fg, uint32_t* bg)
|
||||
{
|
||||
*r = runes[i];
|
||||
*fg = TB_DEFAULT;
|
||||
*bg = TB_DEFAULT;
|
||||
}
|
||||
|
||||
void colorAttrFunc(int i, uint32_t* r, uint32_t* fg, uint32_t* bg)
|
||||
{
|
||||
*r = ' ';
|
||||
*fg = TB_DEFAULT;
|
||||
*bg = colors[i];
|
||||
}
|
||||
|
||||
void updateAndRedrawAll(int mx, int my)
|
||||
{
|
||||
tb_clear();
|
||||
|
||||
if (mx != -1 && my != -1)
|
||||
{
|
||||
backbuf[bbw * my + mx].ch = runes[curRune];
|
||||
backbuf[bbw * my + mx].fg = colors[curCol];
|
||||
}
|
||||
|
||||
memcpy(tb_cell_buffer(), backbuf, sizeof(struct tb_cell)*bbw * bbh);
|
||||
int h = tb_height();
|
||||
updateAndDrawButtons(&curRune, 0, 0, mx, my, len(runes), runeAttrFunc);
|
||||
updateAndDrawButtons(&curCol, 0, h - 3, mx, my, len(colors), colorAttrFunc);
|
||||
tb_present();
|
||||
}
|
||||
|
||||
void reallocBackBuffer(int w, int h)
|
||||
{
|
||||
bbw = w;
|
||||
bbh = h;
|
||||
|
||||
if (backbuf)
|
||||
{
|
||||
free(backbuf);
|
||||
}
|
||||
|
||||
backbuf = calloc(sizeof(struct tb_cell), w * h);
|
||||
}
|
||||
|
||||
int main(int argv, char** argc)
|
||||
{
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
int code = tb_init();
|
||||
|
||||
if (code < 0)
|
||||
{
|
||||
fprintf(stderr, "termbox init failed, code: %d\n", code);
|
||||
return -1;
|
||||
}
|
||||
|
||||
tb_select_input_mode(TB_INPUT_ESC | TB_INPUT_MOUSE);
|
||||
int w = tb_width();
|
||||
int h = tb_height();
|
||||
reallocBackBuffer(w, h);
|
||||
updateAndRedrawAll(-1, -1);
|
||||
|
||||
for (;;)
|
||||
{
|
||||
struct tb_event ev;
|
||||
int mx = -1;
|
||||
int my = -1;
|
||||
int t = tb_poll_event(&ev);
|
||||
|
||||
if (t == -1)
|
||||
{
|
||||
tb_shutdown();
|
||||
fprintf(stderr, "termbox poll event error\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
switch (t)
|
||||
{
|
||||
case TB_EVENT_KEY:
|
||||
if (ev.key == TB_KEY_ESC)
|
||||
{
|
||||
tb_shutdown();
|
||||
return 0;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case TB_EVENT_MOUSE:
|
||||
if (ev.key == TB_KEY_MOUSE_LEFT)
|
||||
{
|
||||
mx = ev.x;
|
||||
my = ev.y;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case TB_EVENT_RESIZE:
|
||||
reallocBackBuffer(ev.w, ev.h);
|
||||
break;
|
||||
}
|
||||
|
||||
updateAndRedrawAll(mx, my);
|
||||
}
|
||||
}
|
||||
69
dep/termbox_next/src/demo/truecolor.c
Normal file
69
dep/termbox_next/src/demo/truecolor.c
Normal file
@@ -0,0 +1,69 @@
|
||||
#include "termbox.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
tb_init();
|
||||
tb_select_output_mode(TB_OUTPUT_TRUECOLOR);
|
||||
int w = tb_width();
|
||||
int h = tb_height();
|
||||
uint32_t bg = 0x000000, fg = 0x000000;
|
||||
tb_clear();
|
||||
int z = 0;
|
||||
|
||||
for (int y = 1; y < h; y++)
|
||||
{
|
||||
for (int x = 1; x < w; x++)
|
||||
{
|
||||
uint32_t ch;
|
||||
utf8_char_to_unicode(&ch, "x");
|
||||
fg = 0;
|
||||
|
||||
if (z % 2 == 0)
|
||||
{
|
||||
fg |= TB_BOLD;
|
||||
}
|
||||
|
||||
if (z % 3 == 0)
|
||||
{
|
||||
fg |= TB_UNDERLINE;
|
||||
}
|
||||
|
||||
if (z % 5 == 0)
|
||||
{
|
||||
fg |= TB_REVERSE;
|
||||
}
|
||||
|
||||
tb_change_cell(x, y, ch, fg, bg);
|
||||
bg += 0x000101;
|
||||
z++;
|
||||
}
|
||||
|
||||
bg += 0x080000;
|
||||
|
||||
if (bg > 0xFFFFFF)
|
||||
{
|
||||
bg = 0;
|
||||
}
|
||||
}
|
||||
|
||||
tb_present();
|
||||
|
||||
while (1)
|
||||
{
|
||||
struct tb_event ev;
|
||||
int t = tb_poll_event(&ev);
|
||||
|
||||
if (t == -1)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (t == TB_EVENT_KEY)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
tb_shutdown();
|
||||
return 0;
|
||||
}
|
||||
319
dep/termbox_next/src/input.c
Normal file
319
dep/termbox_next/src/input.c
Normal file
@@ -0,0 +1,319 @@
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "term.h"
|
||||
|
||||
#define BUFFER_SIZE_MAX 16
|
||||
|
||||
// if s1 starts with s2 returns 1, else 0
|
||||
static int starts_with(const char* s1, const char* s2)
|
||||
{
|
||||
// nice huh?
|
||||
while (*s2)
|
||||
{
|
||||
if (*s1++ != *s2++)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int parse_mouse_event(struct tb_event* event, const char* buf, int len)
|
||||
{
|
||||
if ((len >= 6) && starts_with(buf, "\033[M"))
|
||||
{
|
||||
// X10 mouse encoding, the simplest one
|
||||
// \033 [ M Cb Cx Cy
|
||||
int b = buf[3] - 32;
|
||||
|
||||
switch (b & 3)
|
||||
{
|
||||
case 0:
|
||||
if ((b & 64) != 0)
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_WHEEL_UP;
|
||||
}
|
||||
else
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_LEFT;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if ((b & 64) != 0)
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_WHEEL_DOWN;
|
||||
}
|
||||
else
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_MIDDLE;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 2:
|
||||
event->key = TB_KEY_MOUSE_RIGHT;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
event->key = TB_KEY_MOUSE_RELEASE;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -6;
|
||||
}
|
||||
|
||||
event->type = TB_EVENT_MOUSE; // TB_EVENT_KEY by default
|
||||
|
||||
if ((b & 32) != 0)
|
||||
{
|
||||
event->mod |= TB_MOD_MOTION;
|
||||
}
|
||||
|
||||
// the coord is 1,1 for upper left
|
||||
event->x = (uint8_t)buf[4] - 1 - 32;
|
||||
event->y = (uint8_t)buf[5] - 1 - 32;
|
||||
return 6;
|
||||
}
|
||||
else if (starts_with(buf, "\033[<") || starts_with(buf, "\033["))
|
||||
{
|
||||
// xterm 1006 extended mode or urxvt 1015 extended mode
|
||||
// xterm: \033 [ < Cb ; Cx ; Cy (M or m)
|
||||
// urxvt: \033 [ Cb ; Cx ; Cy M
|
||||
int i, mi = -1, starti = -1;
|
||||
int isM, isU, s1 = -1, s2 = -1;
|
||||
int n1 = 0, n2 = 0, n3 = 0;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
// We search the first (s1) and the last (s2) ';'
|
||||
if (buf[i] == ';')
|
||||
{
|
||||
if (s1 == -1)
|
||||
{
|
||||
s1 = i;
|
||||
}
|
||||
|
||||
s2 = i;
|
||||
}
|
||||
|
||||
// We search for the first 'm' or 'M'
|
||||
if ((buf[i] == 'm' || buf[i] == 'M') && mi == -1)
|
||||
{
|
||||
mi = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (mi == -1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// whether it's a capital M or not
|
||||
isM = (buf[mi] == 'M');
|
||||
|
||||
if (buf[2] == '<')
|
||||
{
|
||||
isU = 0;
|
||||
starti = 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
isU = 1;
|
||||
starti = 2;
|
||||
}
|
||||
|
||||
if (s1 == -1 || s2 == -1 || s1 == s2)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
n1 = strtoul(&buf[starti], NULL, 10);
|
||||
n2 = strtoul(&buf[s1 + 1], NULL, 10);
|
||||
n3 = strtoul(&buf[s2 + 1], NULL, 10);
|
||||
|
||||
if (isU)
|
||||
{
|
||||
n1 -= 32;
|
||||
}
|
||||
|
||||
switch (n1 & 3)
|
||||
{
|
||||
case 0:
|
||||
if ((n1 & 64) != 0)
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_WHEEL_UP;
|
||||
}
|
||||
else
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_LEFT;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if ((n1 & 64) != 0)
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_WHEEL_DOWN;
|
||||
}
|
||||
else
|
||||
{
|
||||
event->key = TB_KEY_MOUSE_MIDDLE;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 2:
|
||||
event->key = TB_KEY_MOUSE_RIGHT;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
event->key = TB_KEY_MOUSE_RELEASE;
|
||||
break;
|
||||
|
||||
default:
|
||||
return mi + 1;
|
||||
}
|
||||
|
||||
if (!isM)
|
||||
{
|
||||
// on xterm mouse release is signaled by lowercase m
|
||||
event->key = TB_KEY_MOUSE_RELEASE;
|
||||
}
|
||||
|
||||
event->type = TB_EVENT_MOUSE; // TB_EVENT_KEY by default
|
||||
|
||||
if ((n1 & 32) != 0)
|
||||
{
|
||||
event->mod |= TB_MOD_MOTION;
|
||||
}
|
||||
|
||||
event->x = (uint8_t)n2 - 1;
|
||||
event->y = (uint8_t)n3 - 1;
|
||||
return mi + 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// convert escape sequence to event, and return consumed bytes on success (failure == 0)
|
||||
static int parse_escape_seq(struct tb_event* event, const char* buf, int len)
|
||||
{
|
||||
int mouse_parsed = parse_mouse_event(event, buf, len);
|
||||
|
||||
if (mouse_parsed != 0)
|
||||
{
|
||||
return mouse_parsed;
|
||||
}
|
||||
|
||||
// it's pretty simple here, find 'starts_with' match and return success, else return failure
|
||||
int i;
|
||||
|
||||
for (i = 0; keys[i]; i++)
|
||||
{
|
||||
if (starts_with(buf, keys[i]))
|
||||
{
|
||||
event->ch = 0;
|
||||
event->key = 0xFFFF - i;
|
||||
return strlen(keys[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool extract_event(struct tb_event* event, struct ringbuffer* inbuf,
|
||||
int inputmode)
|
||||
{
|
||||
char buf[BUFFER_SIZE_MAX + 1];
|
||||
int nbytes = ringbuffer_data_size(inbuf);
|
||||
|
||||
if (nbytes > BUFFER_SIZE_MAX)
|
||||
{
|
||||
nbytes = BUFFER_SIZE_MAX;
|
||||
}
|
||||
|
||||
if (nbytes == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
ringbuffer_read(inbuf, buf, nbytes);
|
||||
buf[nbytes] = '\0';
|
||||
|
||||
if (buf[0] == '\033')
|
||||
{
|
||||
int n = parse_escape_seq(event, buf, nbytes);
|
||||
|
||||
if (n != 0)
|
||||
{
|
||||
bool success = true;
|
||||
|
||||
if (n < 0)
|
||||
{
|
||||
success = false;
|
||||
n = -n;
|
||||
}
|
||||
|
||||
ringbuffer_pop(inbuf, 0, n);
|
||||
return success;
|
||||
}
|
||||
else
|
||||
{
|
||||
// it's not escape sequence, then it's ALT or ESC, check inputmode
|
||||
if (inputmode & TB_INPUT_ESC)
|
||||
{
|
||||
// if we're in escape mode, fill ESC event, pop buffer, return success
|
||||
event->ch = 0;
|
||||
event->key = TB_KEY_ESC;
|
||||
event->mod = 0;
|
||||
ringbuffer_pop(inbuf, 0, 1);
|
||||
return true;
|
||||
}
|
||||
else if (inputmode & TB_INPUT_ALT)
|
||||
{
|
||||
// if we're in alt mode, set ALT modifier to event and redo parsing
|
||||
event->mod = TB_MOD_ALT;
|
||||
ringbuffer_pop(inbuf, 0, 1);
|
||||
return extract_event(event, inbuf, inputmode);
|
||||
}
|
||||
|
||||
assert(!"never got here");
|
||||
}
|
||||
}
|
||||
|
||||
// if we're here, this is not an escape sequence and not an alt sequence
|
||||
// so, it's a FUNCTIONAL KEY or a UNICODE character
|
||||
|
||||
// first of all check if it's a functional key*/
|
||||
if ((unsigned char)buf[0] <= TB_KEY_SPACE ||
|
||||
(unsigned char)buf[0] == TB_KEY_BACKSPACE2)
|
||||
{
|
||||
// fill event, pop buffer, return success
|
||||
event->ch = 0;
|
||||
event->key = (uint16_t)buf[0];
|
||||
ringbuffer_pop(inbuf, 0, 1);
|
||||
return true;
|
||||
}
|
||||
|
||||
// feh... we got utf8 here
|
||||
|
||||
// check if there is all bytes
|
||||
if (nbytes >= utf8_char_length(buf[0]))
|
||||
{
|
||||
// everything ok, fill event, pop buffer, return success
|
||||
utf8_char_to_unicode(&event->ch, buf);
|
||||
event->key = 0;
|
||||
ringbuffer_pop(inbuf, 0, utf8_char_length(buf[0]));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
36
dep/termbox_next/src/memstream.c
Normal file
36
dep/termbox_next/src/memstream.c
Normal file
@@ -0,0 +1,36 @@
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include "memstream.h"
|
||||
|
||||
void memstream_init(struct memstream* s, int fd, void* buffer, size_t len)
|
||||
{
|
||||
s->file = fd;
|
||||
s->data = buffer;
|
||||
s->pos = 0;
|
||||
s->capa = len;
|
||||
}
|
||||
|
||||
void memstream_flush(struct memstream* s)
|
||||
{
|
||||
write(s->file, s->data, s->pos);
|
||||
s->pos = 0;
|
||||
}
|
||||
|
||||
void memstream_write(struct memstream* s, void* source, size_t len)
|
||||
{
|
||||
unsigned char* data = source;
|
||||
|
||||
if (s->pos + len > s->capa)
|
||||
{
|
||||
memstream_flush(s);
|
||||
}
|
||||
|
||||
memcpy(s->data + s->pos, data, len);
|
||||
s->pos += len;
|
||||
}
|
||||
|
||||
void memstream_puts(struct memstream* s, const char* str)
|
||||
{
|
||||
memstream_write(s, (void*) str, strlen(str));
|
||||
}
|
||||
20
dep/termbox_next/src/memstream.h
Normal file
20
dep/termbox_next/src/memstream.h
Normal file
@@ -0,0 +1,20 @@
|
||||
#ifndef H_MEMSTREAM
|
||||
#define H_MEMSTREAM
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
|
||||
struct memstream
|
||||
{
|
||||
size_t pos;
|
||||
size_t capa;
|
||||
int file;
|
||||
unsigned char* data;
|
||||
};
|
||||
|
||||
void memstream_init(struct memstream* s, int fd, void* buffer, size_t len);
|
||||
void memstream_flush(struct memstream* s);
|
||||
void memstream_write(struct memstream* s, void* source, size_t len);
|
||||
void memstream_puts(struct memstream* s, const char* str);
|
||||
|
||||
#endif
|
||||
195
dep/termbox_next/src/ringbuffer.c
Normal file
195
dep/termbox_next/src/ringbuffer.c
Normal file
@@ -0,0 +1,195 @@
|
||||
#include "ringbuffer.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stddef.h> // for ptrdiff_t
|
||||
|
||||
int init_ringbuffer(struct ringbuffer* r, size_t size)
|
||||
{
|
||||
r->buf = (char*)malloc(size);
|
||||
|
||||
if (!r->buf)
|
||||
{
|
||||
return ERINGBUFFER_ALLOC_FAIL;
|
||||
}
|
||||
|
||||
r->size = size;
|
||||
clear_ringbuffer(r);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void free_ringbuffer(struct ringbuffer* r)
|
||||
{
|
||||
free(r->buf);
|
||||
}
|
||||
|
||||
void clear_ringbuffer(struct ringbuffer* r)
|
||||
{
|
||||
r->begin = 0;
|
||||
r->end = 0;
|
||||
}
|
||||
|
||||
size_t ringbuffer_free_space(struct ringbuffer* r)
|
||||
{
|
||||
if (r->begin == 0 && r->end == 0)
|
||||
{
|
||||
return r->size;
|
||||
}
|
||||
|
||||
if (r->begin < r->end)
|
||||
{
|
||||
return r->size - (r->end - r->begin) - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return r->begin - r->end - 1;
|
||||
}
|
||||
}
|
||||
|
||||
size_t ringbuffer_data_size(struct ringbuffer* r)
|
||||
{
|
||||
if (r->begin == 0 && r->end == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (r->begin <= r->end)
|
||||
{
|
||||
return r->end - r->begin + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return r->size - (r->begin - r->end) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ringbuffer_push(struct ringbuffer* r, const void* data, size_t size)
|
||||
{
|
||||
if (ringbuffer_free_space(r) < size)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (r->begin == 0 && r->end == 0)
|
||||
{
|
||||
memcpy(r->buf, data, size);
|
||||
r->begin = r->buf;
|
||||
r->end = r->buf + size - 1;
|
||||
return;
|
||||
}
|
||||
|
||||
r->end++;
|
||||
|
||||
if (r->begin < r->end)
|
||||
{
|
||||
if ((size_t)(r->buf + (ptrdiff_t)r->size - r->begin) >= size)
|
||||
{
|
||||
// we can fit without cut
|
||||
memcpy(r->end, data, size);
|
||||
r->end += size - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// make a cut
|
||||
size_t s = r->buf + r->size - r->end;
|
||||
memcpy(r->end, data, s);
|
||||
size -= s;
|
||||
memcpy(r->buf, (char*)data + s, size);
|
||||
r->end = r->buf + size - 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(r->end, data, size);
|
||||
r->end += size - 1;
|
||||
}
|
||||
}
|
||||
|
||||
void ringbuffer_pop(struct ringbuffer* r, void* data, size_t size)
|
||||
{
|
||||
if (ringbuffer_data_size(r) < size)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int need_clear = 0;
|
||||
|
||||
if (ringbuffer_data_size(r) == size)
|
||||
{
|
||||
need_clear = 1;
|
||||
}
|
||||
|
||||
if (r->begin < r->end)
|
||||
{
|
||||
if (data)
|
||||
{
|
||||
memcpy(data, r->begin, size);
|
||||
}
|
||||
|
||||
r->begin += size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((size_t)(r->buf + (ptrdiff_t)r->size - r->begin) >= size)
|
||||
{
|
||||
if (data)
|
||||
{
|
||||
memcpy(data, r->begin, size);
|
||||
}
|
||||
|
||||
r->begin += size;
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t s = r->buf + r->size - r->begin;
|
||||
|
||||
if (data)
|
||||
{
|
||||
memcpy(data, r->begin, s);
|
||||
}
|
||||
|
||||
size -= s;
|
||||
|
||||
if (data)
|
||||
{
|
||||
memcpy((char*)data + s, r->buf, size);
|
||||
}
|
||||
|
||||
r->begin = r->buf + size;
|
||||
}
|
||||
}
|
||||
|
||||
if (need_clear)
|
||||
{
|
||||
clear_ringbuffer(r);
|
||||
}
|
||||
}
|
||||
|
||||
void ringbuffer_read(struct ringbuffer* r, void* data, size_t size)
|
||||
{
|
||||
if (ringbuffer_data_size(r) < size)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (r->begin < r->end)
|
||||
{
|
||||
memcpy(data, r->begin, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((size_t)(r->buf + (ptrdiff_t)r->size - r->begin) >= size)
|
||||
{
|
||||
memcpy(data, r->begin, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t s = r->buf + r->size - r->begin;
|
||||
memcpy(data, r->begin, s);
|
||||
size -= s;
|
||||
memcpy((char*)data + s, r->buf, size);
|
||||
}
|
||||
}
|
||||
}
|
||||
26
dep/termbox_next/src/ringbuffer.h
Normal file
26
dep/termbox_next/src/ringbuffer.h
Normal file
@@ -0,0 +1,26 @@
|
||||
#ifndef H_RINGBUFFER
|
||||
#define H_RINGBUFFER
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#define ERINGBUFFER_ALLOC_FAIL -1
|
||||
|
||||
struct ringbuffer
|
||||
{
|
||||
char* buf;
|
||||
size_t size;
|
||||
|
||||
char* begin;
|
||||
char* end;
|
||||
};
|
||||
|
||||
int init_ringbuffer(struct ringbuffer* r, size_t size);
|
||||
void free_ringbuffer(struct ringbuffer* r);
|
||||
void clear_ringbuffer(struct ringbuffer* r);
|
||||
size_t ringbuffer_free_space(struct ringbuffer* r);
|
||||
size_t ringbuffer_data_size(struct ringbuffer* r);
|
||||
void ringbuffer_push(struct ringbuffer* r, const void* data, size_t size);
|
||||
void ringbuffer_pop(struct ringbuffer* r, void* data, size_t size);
|
||||
void ringbuffer_read(struct ringbuffer* r, void* data, size_t size);
|
||||
|
||||
#endif
|
||||
412
dep/termbox_next/src/term.c
Normal file
412
dep/termbox_next/src/term.c
Normal file
@@ -0,0 +1,412 @@
|
||||
#include <sys/stat.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "term.h"
|
||||
#define ENTER_MOUSE_SEQ "\x1b[?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h"
|
||||
#define EXIT_MOUSE_SEQ "\x1b[?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l"
|
||||
|
||||
#define EUNSUPPORTED_TERM -1
|
||||
|
||||
// rxvt-256color
|
||||
static const char* rxvt_256color_keys[] =
|
||||
{
|
||||
"\033[11~", "\033[12~", "\033[13~", "\033[14~", "\033[15~", "\033[17~",
|
||||
"\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~",
|
||||
"\033[2~", "\033[3~", "\033[7~", "\033[8~", "\033[5~", "\033[6~",
|
||||
"\033[A", "\033[B", "\033[D", "\033[C", NULL
|
||||
};
|
||||
static const char* rxvt_256color_funcs[] =
|
||||
{
|
||||
"\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l",
|
||||
"\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m",
|
||||
"\033=", "\033>", ENTER_MOUSE_SEQ, EXIT_MOUSE_SEQ,
|
||||
};
|
||||
|
||||
// Eterm
|
||||
static const char* eterm_keys[] =
|
||||
{
|
||||
"\033[11~", "\033[12~", "\033[13~", "\033[14~", "\033[15~", "\033[17~",
|
||||
"\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~",
|
||||
"\033[2~", "\033[3~", "\033[7~", "\033[8~", "\033[5~", "\033[6~",
|
||||
"\033[A", "\033[B", "\033[D", "\033[C", NULL
|
||||
};
|
||||
static const char* eterm_funcs[] =
|
||||
{
|
||||
"\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l",
|
||||
"\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m",
|
||||
"", "", "", "",
|
||||
};
|
||||
|
||||
// screen
|
||||
static const char* screen_keys[] =
|
||||
{
|
||||
"\033OP", "\033OQ", "\033OR", "\033OS", "\033[15~", "\033[17~",
|
||||
"\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~",
|
||||
"\033[2~", "\033[3~", "\033[1~", "\033[4~", "\033[5~", "\033[6~",
|
||||
"\033OA", "\033OB", "\033OD", "\033OC", NULL
|
||||
};
|
||||
static const char* screen_funcs[] =
|
||||
{
|
||||
"\033[?1049h", "\033[?1049l", "\033[34h\033[?25h", "\033[?25l",
|
||||
"\033[H\033[J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m",
|
||||
"\033[?1h\033=", "\033[?1l\033>", ENTER_MOUSE_SEQ, EXIT_MOUSE_SEQ,
|
||||
};
|
||||
|
||||
// rxvt-unicode
|
||||
static const char* rxvt_unicode_keys[] =
|
||||
{
|
||||
"\033[11~", "\033[12~", "\033[13~", "\033[14~", "\033[15~", "\033[17~",
|
||||
"\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~",
|
||||
"\033[2~", "\033[3~", "\033[7~", "\033[8~", "\033[5~", "\033[6~",
|
||||
"\033[A", "\033[B", "\033[D", "\033[C", NULL
|
||||
};
|
||||
static const char* rxvt_unicode_funcs[] =
|
||||
{
|
||||
"\033[?1049h", "\033[r\033[?1049l", "\033[?25h", "\033[?25l",
|
||||
"\033[H\033[2J", "\033[m\033(B", "\033[4m", "\033[1m", "\033[5m",
|
||||
"\033[7m", "\033=", "\033>", ENTER_MOUSE_SEQ, EXIT_MOUSE_SEQ,
|
||||
};
|
||||
|
||||
// linux
|
||||
static const char* linux_keys[] =
|
||||
{
|
||||
"\033[[A", "\033[[B", "\033[[C", "\033[[D", "\033[[E", "\033[17~",
|
||||
"\033[18~", "\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~",
|
||||
"\033[2~", "\033[3~", "\033[1~", "\033[4~", "\033[5~", "\033[6~",
|
||||
"\033[A", "\033[B", "\033[D", "\033[C", NULL
|
||||
};
|
||||
static const char* linux_funcs[] =
|
||||
{
|
||||
"", "", "\033[?25h\033[?0c", "\033[?25l\033[?1c", "\033[H\033[J",
|
||||
"\033[0;10m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "", "", "", "",
|
||||
};
|
||||
|
||||
// xterm
|
||||
static const char* xterm_keys[] =
|
||||
{
|
||||
"\033OP", "\033OQ", "\033OR", "\033OS", "\033[15~", "\033[17~", "\033[18~",
|
||||
"\033[19~", "\033[20~", "\033[21~", "\033[23~", "\033[24~", "\033[2~",
|
||||
"\033[3~", "\033OH", "\033OF", "\033[5~", "\033[6~", "\033OA", "\033OB",
|
||||
"\033OD", "\033OC", NULL
|
||||
};
|
||||
static const char* xterm_funcs[] =
|
||||
{
|
||||
"\033[?1049h", "\033[?1049l", "\033[?12l\033[?25h", "\033[?25l",
|
||||
"\033[H\033[2J", "\033(B\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m",
|
||||
"\033[?1h\033=", "\033[?1l\033>", ENTER_MOUSE_SEQ, EXIT_MOUSE_SEQ,
|
||||
};
|
||||
|
||||
struct term
|
||||
{
|
||||
const char* name;
|
||||
const char** keys;
|
||||
const char** funcs;
|
||||
};
|
||||
|
||||
static struct term terms[] =
|
||||
{
|
||||
{"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs},
|
||||
{"Eterm", eterm_keys, eterm_funcs},
|
||||
{"screen", screen_keys, screen_funcs},
|
||||
{"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs},
|
||||
{"linux", linux_keys, linux_funcs},
|
||||
{"xterm", xterm_keys, xterm_funcs},
|
||||
{0, 0, 0},
|
||||
};
|
||||
|
||||
static int init_from_terminfo = 0;
|
||||
const char** keys;
|
||||
const char** funcs;
|
||||
|
||||
static int try_compatible(const char* term, const char* name,
|
||||
const char** tkeys, const char** tfuncs)
|
||||
{
|
||||
if (strstr(term, name))
|
||||
{
|
||||
keys = tkeys;
|
||||
funcs = tfuncs;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return EUNSUPPORTED_TERM;
|
||||
}
|
||||
|
||||
static int init_term_builtin(void)
|
||||
{
|
||||
int i;
|
||||
const char* term = getenv("TERM");
|
||||
|
||||
if (term)
|
||||
{
|
||||
for (i = 0; terms[i].name; i++)
|
||||
{
|
||||
if (!strcmp(terms[i].name, term))
|
||||
{
|
||||
keys = terms[i].keys;
|
||||
funcs = terms[i].funcs;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// let's do some heuristic, maybe it's a compatible terminal
|
||||
if (try_compatible(term, "xterm", xterm_keys, xterm_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (try_compatible(term, "rxvt", rxvt_unicode_keys, rxvt_unicode_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (try_compatible(term, "linux", linux_keys, linux_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (try_compatible(term, "Eterm", eterm_keys, eterm_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (try_compatible(term, "screen", screen_keys, screen_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// let's assume that 'cygwin' is xterm compatible
|
||||
if (try_compatible(term, "cygwin", xterm_keys, xterm_funcs) == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return EUNSUPPORTED_TERM;
|
||||
}
|
||||
|
||||
// terminfo
|
||||
static char* read_file(const char* file)
|
||||
{
|
||||
FILE* f = fopen(file, "rb");
|
||||
|
||||
if (!f)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct stat st;
|
||||
|
||||
if (fstat(fileno(f), &st) != 0)
|
||||
{
|
||||
fclose(f);
|
||||
return 0;
|
||||
}
|
||||
|
||||
char* data = malloc(st.st_size);
|
||||
|
||||
if (!data)
|
||||
{
|
||||
fclose(f);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (fread(data, 1, st.st_size, f) != (size_t)st.st_size)
|
||||
{
|
||||
fclose(f);
|
||||
free(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
return data;
|
||||
}
|
||||
|
||||
static char* terminfo_try_path(const char* path, const char* term)
|
||||
{
|
||||
char tmp[4096];
|
||||
snprintf(tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term);
|
||||
tmp[sizeof(tmp) - 1] = '\0';
|
||||
char* data = read_file(tmp);
|
||||
|
||||
if (data)
|
||||
{
|
||||
return data;
|
||||
}
|
||||
|
||||
// fallback to darwin specific dirs structure
|
||||
snprintf(tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term);
|
||||
tmp[sizeof(tmp) - 1] = '\0';
|
||||
return read_file(tmp);
|
||||
}
|
||||
|
||||
static char* load_terminfo(void)
|
||||
{
|
||||
char tmp[4096];
|
||||
const char* term = getenv("TERM");
|
||||
|
||||
if (!term)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// if TERMINFO is set, no other directory should be searched
|
||||
const char* terminfo = getenv("TERMINFO");
|
||||
|
||||
if (terminfo)
|
||||
{
|
||||
return terminfo_try_path(terminfo, term);
|
||||
}
|
||||
|
||||
// next, consider ~/.terminfo
|
||||
const char* home = getenv("HOME");
|
||||
|
||||
if (home)
|
||||
{
|
||||
snprintf(tmp, sizeof(tmp), "%s/.terminfo", home);
|
||||
tmp[sizeof(tmp) - 1] = '\0';
|
||||
char* data = terminfo_try_path(tmp, term);
|
||||
|
||||
if (data)
|
||||
{
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
// next, TERMINFO_DIRS
|
||||
const char* dirs = getenv("TERMINFO_DIRS");
|
||||
|
||||
if (dirs)
|
||||
{
|
||||
snprintf(tmp, sizeof(tmp), "%s", dirs);
|
||||
tmp[sizeof(tmp) - 1] = '\0';
|
||||
char* dir = strtok(tmp, ":");
|
||||
|
||||
while (dir)
|
||||
{
|
||||
const char* cdir = dir;
|
||||
|
||||
if (strcmp(cdir, "") == 0)
|
||||
{
|
||||
cdir = "/usr/share/terminfo";
|
||||
}
|
||||
|
||||
char* data = terminfo_try_path(cdir, term);
|
||||
|
||||
if (data)
|
||||
{
|
||||
return data;
|
||||
}
|
||||
|
||||
dir = strtok(0, ":");
|
||||
}
|
||||
}
|
||||
|
||||
// fallback to /usr/share/terminfo
|
||||
return terminfo_try_path("/usr/share/terminfo", term);
|
||||
}
|
||||
|
||||
#define TI_MAGIC 0432
|
||||
#define TI_ALT_MAGIC 542
|
||||
#define TI_HEADER_LENGTH 12
|
||||
#define TB_KEYS_NUM 22
|
||||
|
||||
static const char* terminfo_copy_string(char* data, int str, int table)
|
||||
{
|
||||
const int16_t off = *(int16_t*)(data + str);
|
||||
const char* src = data + table + off;
|
||||
int len = strlen(src);
|
||||
char* dst = malloc(len + 1);
|
||||
strcpy(dst, src);
|
||||
return dst;
|
||||
}
|
||||
|
||||
const int16_t ti_funcs[] =
|
||||
{
|
||||
28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88,
|
||||
};
|
||||
|
||||
const int16_t ti_keys[] =
|
||||
{
|
||||
// apparently not a typo; 67 is F10 for whatever reason
|
||||
66, 68, 69, 70, 71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82,
|
||||
81, 87, 61, 79, 83,
|
||||
};
|
||||
|
||||
int init_term(void)
|
||||
{
|
||||
int i;
|
||||
char* data = load_terminfo();
|
||||
|
||||
if (!data)
|
||||
{
|
||||
init_from_terminfo = 0;
|
||||
return init_term_builtin();
|
||||
}
|
||||
|
||||
int16_t* header = (int16_t*)data;
|
||||
|
||||
const int number_sec_len = header[0] == TI_ALT_MAGIC ? 4 : 2;
|
||||
|
||||
if ((header[1] + header[2]) % 2)
|
||||
{
|
||||
// old quirk to align everything on word boundaries
|
||||
header[2] += 1;
|
||||
}
|
||||
|
||||
const int str_offset = TI_HEADER_LENGTH +
|
||||
header[1] + header[2] + number_sec_len * header[3];
|
||||
const int table_offset = str_offset + 2 * header[4];
|
||||
|
||||
keys = malloc(sizeof(const char*) * (TB_KEYS_NUM + 1));
|
||||
|
||||
for (i = 0; i < TB_KEYS_NUM; i++)
|
||||
{
|
||||
keys[i] = terminfo_copy_string(data,
|
||||
str_offset + 2 * ti_keys[i], table_offset);
|
||||
}
|
||||
|
||||
keys[i] = NULL;
|
||||
|
||||
funcs = malloc(sizeof(const char*) * T_FUNCS_NUM);
|
||||
|
||||
// the last two entries are reserved for mouse. because the table offset is
|
||||
// not there, the two entries have to fill in manually
|
||||
for (i = 0; i < T_FUNCS_NUM - 2; i++)
|
||||
{
|
||||
funcs[i] = terminfo_copy_string(data,
|
||||
str_offset + 2 * ti_funcs[i], table_offset);
|
||||
}
|
||||
|
||||
funcs[T_FUNCS_NUM - 2] = ENTER_MOUSE_SEQ;
|
||||
funcs[T_FUNCS_NUM - 1] = EXIT_MOUSE_SEQ;
|
||||
init_from_terminfo = 1;
|
||||
free(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void shutdown_term(void)
|
||||
{
|
||||
if (init_from_terminfo)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < TB_KEYS_NUM; i++)
|
||||
{
|
||||
free((void*)keys[i]);
|
||||
}
|
||||
|
||||
// the last two entries are reserved for mouse. because the table offset
|
||||
// is not there, the two entries have to fill in manually and do not
|
||||
// need to be freed.
|
||||
for (i = 0; i < T_FUNCS_NUM - 2; i++)
|
||||
{
|
||||
free((void*)funcs[i]);
|
||||
}
|
||||
|
||||
free(keys);
|
||||
free(funcs);
|
||||
}
|
||||
}
|
||||
38
dep/termbox_next/src/term.h
Normal file
38
dep/termbox_next/src/term.h
Normal file
@@ -0,0 +1,38 @@
|
||||
#ifndef H_TERM
|
||||
#define H_TERM
|
||||
|
||||
#include "termbox.h"
|
||||
#include "ringbuffer.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
#define EUNSUPPORTED_TERM -1
|
||||
|
||||
enum
|
||||
{
|
||||
T_ENTER_CA,
|
||||
T_EXIT_CA,
|
||||
T_SHOW_CURSOR,
|
||||
T_HIDE_CURSOR,
|
||||
T_CLEAR_SCREEN,
|
||||
T_SGR0,
|
||||
T_UNDERLINE,
|
||||
T_BOLD,
|
||||
T_BLINK,
|
||||
T_REVERSE,
|
||||
T_ENTER_KEYPAD,
|
||||
T_EXIT_KEYPAD,
|
||||
T_ENTER_MOUSE,
|
||||
T_EXIT_MOUSE,
|
||||
T_FUNCS_NUM,
|
||||
};
|
||||
|
||||
extern const char** keys;
|
||||
extern const char** funcs;
|
||||
|
||||
// true on success, false on failure
|
||||
bool extract_event(struct tb_event* event, struct ringbuffer* inbuf,
|
||||
int inputmode);
|
||||
int init_term(void);
|
||||
void shutdown_term(void);
|
||||
|
||||
#endif
|
||||
885
dep/termbox_next/src/termbox.c
Normal file
885
dep/termbox_next/src/termbox.c
Normal file
@@ -0,0 +1,885 @@
|
||||
#include "term.h"
|
||||
#include "termbox.h"
|
||||
#include "memstream.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/select.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/time.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#include <wchar.h>
|
||||
|
||||
struct cellbuf
|
||||
{
|
||||
int width;
|
||||
int height;
|
||||
struct tb_cell* cells;
|
||||
};
|
||||
|
||||
#define CELL(buf, x, y) (buf)->cells[(y) * (buf)->width + (x)]
|
||||
#define IS_CURSOR_HIDDEN(cx, cy) (cx == -1 || cy == -1)
|
||||
#define LAST_COORD_INIT -1
|
||||
|
||||
static struct termios orig_tios;
|
||||
|
||||
static struct cellbuf back_buffer;
|
||||
static struct cellbuf front_buffer;
|
||||
static unsigned char write_buffer_data[32 * 1024];
|
||||
static struct memstream write_buffer;
|
||||
|
||||
static int termw = -1;
|
||||
static int termh = -1;
|
||||
|
||||
static int inputmode = TB_INPUT_ESC;
|
||||
static int outputmode = TB_OUTPUT_NORMAL;
|
||||
|
||||
static struct ringbuffer inbuf;
|
||||
|
||||
static int out;
|
||||
static FILE* in;
|
||||
|
||||
static int out_fileno;
|
||||
static int in_fileno;
|
||||
|
||||
static int winch_fds[2];
|
||||
|
||||
static int lastx = LAST_COORD_INIT;
|
||||
static int lasty = LAST_COORD_INIT;
|
||||
static int cursor_x = -1;
|
||||
static int cursor_y = -1;
|
||||
|
||||
static uint32_t background = TB_DEFAULT;
|
||||
static uint32_t foreground = TB_DEFAULT;
|
||||
|
||||
static void write_cursor(int x, int y);
|
||||
static void write_sgr(uint32_t fg, uint32_t bg);
|
||||
|
||||
static void cellbuf_init(struct cellbuf* buf, int width, int height);
|
||||
static void cellbuf_resize(struct cellbuf* buf, int width, int height);
|
||||
static void cellbuf_clear(struct cellbuf* buf);
|
||||
static void cellbuf_free(struct cellbuf* buf);
|
||||
|
||||
static void update_size(void);
|
||||
static void update_term_size(void);
|
||||
static void send_attr(uint32_t fg, uint32_t bg);
|
||||
static void send_char(int x, int y, uint32_t c);
|
||||
static void send_clear(void);
|
||||
static void sigwinch_handler(int xxx);
|
||||
static int wait_fill_event(struct tb_event* event, struct timeval* timeout);
|
||||
|
||||
// may happen in a different thread
|
||||
static volatile int buffer_size_change_request;
|
||||
|
||||
int tb_init_file(const char* name)
|
||||
{
|
||||
out = open(name, O_WRONLY);
|
||||
in = fopen(name, "r");
|
||||
|
||||
if (out == -1 || !in)
|
||||
{
|
||||
if (out != -1)
|
||||
{
|
||||
close(out);
|
||||
}
|
||||
|
||||
if (in)
|
||||
{
|
||||
fclose(in);
|
||||
}
|
||||
|
||||
return TB_EFAILED_TO_OPEN_TTY;
|
||||
}
|
||||
|
||||
out_fileno = out;
|
||||
in_fileno = fileno(in);
|
||||
|
||||
if (init_term() < 0)
|
||||
{
|
||||
close(out);
|
||||
fclose(in);
|
||||
|
||||
return TB_EUNSUPPORTED_TERMINAL;
|
||||
}
|
||||
|
||||
if (pipe(winch_fds) < 0)
|
||||
{
|
||||
close(out);
|
||||
fclose(in);
|
||||
|
||||
return TB_EPIPE_TRAP_ERROR;
|
||||
}
|
||||
|
||||
struct sigaction sa;
|
||||
|
||||
memset(&sa, 0, sizeof(sa));
|
||||
sa.sa_handler = sigwinch_handler;
|
||||
sa.sa_flags = 0;
|
||||
sigaction(SIGWINCH, &sa, 0);
|
||||
tcgetattr(out_fileno, &orig_tios);
|
||||
|
||||
struct termios tios;
|
||||
|
||||
memcpy(&tios, &orig_tios, sizeof(tios));
|
||||
tios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
|
||||
| INLCR | IGNCR | ICRNL | IXON);
|
||||
tios.c_oflag &= ~OPOST;
|
||||
tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
|
||||
tios.c_cflag &= ~(CSIZE | PARENB);
|
||||
tios.c_cflag |= CS8;
|
||||
tios.c_cc[VMIN] = 0;
|
||||
tios.c_cc[VTIME] = 0;
|
||||
tcsetattr(out_fileno, TCSAFLUSH, &tios);
|
||||
|
||||
memstream_init(&write_buffer, out_fileno, write_buffer_data,
|
||||
sizeof(write_buffer_data));
|
||||
memstream_puts(&write_buffer, funcs[T_ENTER_CA]);
|
||||
memstream_puts(&write_buffer, funcs[T_ENTER_KEYPAD]);
|
||||
memstream_puts(&write_buffer, funcs[T_HIDE_CURSOR]);
|
||||
send_clear();
|
||||
|
||||
update_term_size();
|
||||
cellbuf_init(&back_buffer, termw, termh);
|
||||
cellbuf_init(&front_buffer, termw, termh);
|
||||
cellbuf_clear(&back_buffer);
|
||||
cellbuf_clear(&front_buffer);
|
||||
init_ringbuffer(&inbuf, 4096);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int tb_init(void)
|
||||
{
|
||||
return tb_init_file("/dev/tty");
|
||||
}
|
||||
|
||||
void tb_shutdown(void)
|
||||
{
|
||||
if (termw == -1)
|
||||
{
|
||||
fputs("tb_shutdown() should not be called twice.", stderr);
|
||||
abort();
|
||||
}
|
||||
|
||||
memstream_puts(&write_buffer, funcs[T_SHOW_CURSOR]);
|
||||
memstream_puts(&write_buffer, funcs[T_SGR0]);
|
||||
memstream_puts(&write_buffer, funcs[T_CLEAR_SCREEN]);
|
||||
memstream_puts(&write_buffer, funcs[T_EXIT_CA]);
|
||||
memstream_puts(&write_buffer, funcs[T_EXIT_KEYPAD]);
|
||||
memstream_puts(&write_buffer, funcs[T_EXIT_MOUSE]);
|
||||
memstream_flush(&write_buffer);
|
||||
tcsetattr(out_fileno, TCSAFLUSH, &orig_tios);
|
||||
|
||||
shutdown_term();
|
||||
close(out);
|
||||
fclose(in);
|
||||
close(winch_fds[0]);
|
||||
close(winch_fds[1]);
|
||||
|
||||
cellbuf_free(&back_buffer);
|
||||
cellbuf_free(&front_buffer);
|
||||
free_ringbuffer(&inbuf);
|
||||
termw = termh = -1;
|
||||
}
|
||||
|
||||
void tb_present(void)
|
||||
{
|
||||
int x, y, w, i;
|
||||
struct tb_cell* back, *front;
|
||||
|
||||
// invalidate cursor position
|
||||
lastx = LAST_COORD_INIT;
|
||||
lasty = LAST_COORD_INIT;
|
||||
|
||||
if (buffer_size_change_request)
|
||||
{
|
||||
update_size();
|
||||
buffer_size_change_request = 0;
|
||||
}
|
||||
|
||||
for (y = 0; y < front_buffer.height; ++y)
|
||||
{
|
||||
for (x = 0; x < front_buffer.width;)
|
||||
{
|
||||
back = &CELL(&back_buffer, x, y);
|
||||
front = &CELL(&front_buffer, x, y);
|
||||
w = wcwidth(back->ch);
|
||||
|
||||
if (w < 1)
|
||||
{
|
||||
w = 1;
|
||||
}
|
||||
|
||||
if (memcmp(back, front, sizeof(struct tb_cell)) == 0)
|
||||
{
|
||||
x += w;
|
||||
continue;
|
||||
}
|
||||
|
||||
memcpy(front, back, sizeof(struct tb_cell));
|
||||
send_attr(back->fg, back->bg);
|
||||
|
||||
if (w > 1 && x >= front_buffer.width - (w - 1))
|
||||
{
|
||||
// Not enough room for wide ch, so send spaces
|
||||
for (i = x; i < front_buffer.width; ++i)
|
||||
{
|
||||
send_char(i, y, ' ');
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
send_char(x, y, back->ch);
|
||||
|
||||
for (i = 1; i < w; ++i)
|
||||
{
|
||||
front = &CELL(&front_buffer, x + i, y);
|
||||
front->ch = 0;
|
||||
front->fg = back->fg;
|
||||
front->bg = back->bg;
|
||||
}
|
||||
}
|
||||
|
||||
x += w;
|
||||
}
|
||||
}
|
||||
|
||||
if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y))
|
||||
{
|
||||
write_cursor(cursor_x, cursor_y);
|
||||
}
|
||||
|
||||
memstream_flush(&write_buffer);
|
||||
}
|
||||
|
||||
void tb_set_cursor(int cx, int cy)
|
||||
{
|
||||
if (IS_CURSOR_HIDDEN(cursor_x, cursor_y) && !IS_CURSOR_HIDDEN(cx, cy))
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_SHOW_CURSOR]);
|
||||
}
|
||||
|
||||
if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y) && IS_CURSOR_HIDDEN(cx, cy))
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_HIDE_CURSOR]);
|
||||
}
|
||||
|
||||
cursor_x = cx;
|
||||
cursor_y = cy;
|
||||
|
||||
if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y))
|
||||
{
|
||||
write_cursor(cursor_x, cursor_y);
|
||||
}
|
||||
}
|
||||
|
||||
void tb_put_cell(int x, int y, const struct tb_cell* cell)
|
||||
{
|
||||
if ((unsigned)x >= (unsigned)back_buffer.width)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ((unsigned)y >= (unsigned)back_buffer.height)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
CELL(&back_buffer, x, y) = *cell;
|
||||
}
|
||||
|
||||
void tb_change_cell(int x, int y, uint32_t ch, uint32_t fg, uint32_t bg)
|
||||
{
|
||||
struct tb_cell c = {ch, fg, bg};
|
||||
tb_put_cell(x, y, &c);
|
||||
}
|
||||
|
||||
void tb_blit(int x, int y, int w, int h, const struct tb_cell* cells)
|
||||
{
|
||||
if (x + w < 0 || x >= back_buffer.width)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (y + h < 0 || y >= back_buffer.height)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int xo = 0, yo = 0, ww = w, hh = h;
|
||||
|
||||
if (x < 0)
|
||||
{
|
||||
xo = -x;
|
||||
ww -= xo;
|
||||
x = 0;
|
||||
}
|
||||
|
||||
if (y < 0)
|
||||
{
|
||||
yo = -y;
|
||||
hh -= yo;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
if (ww > back_buffer.width - x)
|
||||
{
|
||||
ww = back_buffer.width - x;
|
||||
}
|
||||
|
||||
if (hh > back_buffer.height - y)
|
||||
{
|
||||
hh = back_buffer.height - y;
|
||||
}
|
||||
|
||||
int sy;
|
||||
struct tb_cell* dst = &CELL(&back_buffer, x, y);
|
||||
const struct tb_cell* src = cells + yo * w + xo;
|
||||
size_t size = sizeof(struct tb_cell) * ww;
|
||||
|
||||
for (sy = 0; sy < hh; ++sy)
|
||||
{
|
||||
memcpy(dst, src, size);
|
||||
dst += back_buffer.width;
|
||||
src += w;
|
||||
}
|
||||
}
|
||||
|
||||
struct tb_cell* tb_cell_buffer(void)
|
||||
{
|
||||
return back_buffer.cells;
|
||||
}
|
||||
|
||||
int tb_poll_event(struct tb_event* event)
|
||||
{
|
||||
return wait_fill_event(event, 0);
|
||||
}
|
||||
|
||||
int tb_peek_event(struct tb_event* event, int timeout)
|
||||
{
|
||||
struct timeval tv;
|
||||
tv.tv_sec = timeout / 1000;
|
||||
tv.tv_usec = (timeout - (tv.tv_sec * 1000)) * 1000;
|
||||
return wait_fill_event(event, &tv);
|
||||
}
|
||||
|
||||
int tb_width(void)
|
||||
{
|
||||
return termw;
|
||||
}
|
||||
|
||||
int tb_height(void)
|
||||
{
|
||||
return termh;
|
||||
}
|
||||
|
||||
void tb_clear(void)
|
||||
{
|
||||
if (buffer_size_change_request)
|
||||
{
|
||||
update_size();
|
||||
buffer_size_change_request = 0;
|
||||
}
|
||||
|
||||
cellbuf_clear(&back_buffer);
|
||||
}
|
||||
|
||||
int tb_select_input_mode(int mode)
|
||||
{
|
||||
if (mode)
|
||||
{
|
||||
if ((mode & (TB_INPUT_ESC | TB_INPUT_ALT)) == 0)
|
||||
{
|
||||
mode |= TB_INPUT_ESC;
|
||||
}
|
||||
|
||||
// technically termbox can handle that, but let's be nice
|
||||
// and show here what mode is actually used
|
||||
if ((mode & (TB_INPUT_ESC | TB_INPUT_ALT)) == (TB_INPUT_ESC | TB_INPUT_ALT))
|
||||
{
|
||||
mode &= ~TB_INPUT_ALT;
|
||||
}
|
||||
|
||||
inputmode = mode;
|
||||
|
||||
if (mode & TB_INPUT_MOUSE)
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_ENTER_MOUSE]);
|
||||
memstream_flush(&write_buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_EXIT_MOUSE]);
|
||||
memstream_flush(&write_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
return inputmode;
|
||||
}
|
||||
|
||||
int tb_select_output_mode(int mode)
|
||||
{
|
||||
if (mode)
|
||||
{
|
||||
outputmode = mode;
|
||||
}
|
||||
|
||||
return outputmode;
|
||||
}
|
||||
|
||||
void tb_set_clear_attributes(uint32_t fg, uint32_t bg)
|
||||
{
|
||||
foreground = fg;
|
||||
background = bg;
|
||||
}
|
||||
|
||||
static unsigned convertnum(uint32_t num, char* buf)
|
||||
{
|
||||
unsigned i, l = 0;
|
||||
int ch;
|
||||
|
||||
do
|
||||
{
|
||||
buf[l++] = '0' + (num % 10);
|
||||
num /= 10;
|
||||
}
|
||||
while (num);
|
||||
|
||||
for (i = 0; i < l / 2; i++)
|
||||
{
|
||||
ch = buf[i];
|
||||
buf[i] = buf[l - 1 - i];
|
||||
buf[l - 1 - i] = ch;
|
||||
}
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
#define WRITE_LITERAL(X) memstream_write(&write_buffer, (X), sizeof(X) -1)
|
||||
#define WRITE_INT(X) memstream_write(&write_buffer, buf, convertnum((X), buf))
|
||||
|
||||
static void write_cursor(int x, int y)
|
||||
{
|
||||
char buf[32];
|
||||
WRITE_LITERAL("\033[");
|
||||
WRITE_INT(y + 1);
|
||||
WRITE_LITERAL(";");
|
||||
WRITE_INT(x + 1);
|
||||
WRITE_LITERAL("H");
|
||||
}
|
||||
|
||||
static void write_sgr(uint32_t fg, uint32_t bg)
|
||||
{
|
||||
char buf[32];
|
||||
|
||||
if (outputmode != TB_OUTPUT_TRUECOLOR && fg == TB_DEFAULT && bg == TB_DEFAULT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
switch (outputmode)
|
||||
{
|
||||
case TB_OUTPUT_TRUECOLOR:
|
||||
WRITE_LITERAL("\033[38;2;");
|
||||
WRITE_INT(fg >> 16 & 0xFF);
|
||||
WRITE_LITERAL(";");
|
||||
WRITE_INT(fg >> 8 & 0xFF);
|
||||
WRITE_LITERAL(";");
|
||||
WRITE_INT(fg & 0xFF);
|
||||
WRITE_LITERAL(";48;2;");
|
||||
WRITE_INT(bg >> 16 & 0xFF);
|
||||
WRITE_LITERAL(";");
|
||||
WRITE_INT(bg >> 8 & 0xFF);
|
||||
WRITE_LITERAL(";");
|
||||
WRITE_INT(bg & 0xFF);
|
||||
WRITE_LITERAL("m");
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_256:
|
||||
case TB_OUTPUT_216:
|
||||
case TB_OUTPUT_GRAYSCALE:
|
||||
WRITE_LITERAL("\033[");
|
||||
|
||||
if (fg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL("38;5;");
|
||||
WRITE_INT(fg);
|
||||
|
||||
if (bg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL(";");
|
||||
}
|
||||
}
|
||||
|
||||
if (bg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL("48;5;");
|
||||
WRITE_INT(bg);
|
||||
}
|
||||
|
||||
WRITE_LITERAL("m");
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_NORMAL:
|
||||
default:
|
||||
WRITE_LITERAL("\033[");
|
||||
|
||||
if (fg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL("3");
|
||||
WRITE_INT(fg - 1);
|
||||
|
||||
if (bg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL(";");
|
||||
}
|
||||
}
|
||||
|
||||
if (bg != TB_DEFAULT)
|
||||
{
|
||||
WRITE_LITERAL("4");
|
||||
WRITE_INT(bg - 1);
|
||||
}
|
||||
|
||||
WRITE_LITERAL("m");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void cellbuf_init(struct cellbuf* buf, int width, int height)
|
||||
{
|
||||
buf->cells = (struct tb_cell*)malloc(sizeof(struct tb_cell) * width * height);
|
||||
assert(buf->cells);
|
||||
buf->width = width;
|
||||
buf->height = height;
|
||||
}
|
||||
|
||||
static void cellbuf_resize(struct cellbuf* buf, int width, int height)
|
||||
{
|
||||
if (buf->width == width && buf->height == height)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int oldw = buf->width;
|
||||
int oldh = buf->height;
|
||||
struct tb_cell* oldcells = buf->cells;
|
||||
|
||||
cellbuf_init(buf, width, height);
|
||||
cellbuf_clear(buf);
|
||||
|
||||
int minw = (width < oldw) ? width : oldw;
|
||||
int minh = (height < oldh) ? height : oldh;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < minh; ++i)
|
||||
{
|
||||
struct tb_cell* csrc = oldcells + (i * oldw);
|
||||
struct tb_cell* cdst = buf->cells + (i * width);
|
||||
memcpy(cdst, csrc, sizeof(struct tb_cell) * minw);
|
||||
}
|
||||
|
||||
free(oldcells);
|
||||
}
|
||||
|
||||
static void cellbuf_clear(struct cellbuf* buf)
|
||||
{
|
||||
int i;
|
||||
int ncells = buf->width * buf->height;
|
||||
|
||||
for (i = 0; i < ncells; ++i)
|
||||
{
|
||||
buf->cells[i].ch = ' ';
|
||||
buf->cells[i].fg = foreground;
|
||||
buf->cells[i].bg = background;
|
||||
}
|
||||
}
|
||||
|
||||
static void cellbuf_free(struct cellbuf* buf)
|
||||
{
|
||||
free(buf->cells);
|
||||
}
|
||||
|
||||
static void get_term_size(int* w, int* h)
|
||||
{
|
||||
struct winsize sz;
|
||||
memset(&sz, 0, sizeof(sz));
|
||||
|
||||
ioctl(out_fileno, TIOCGWINSZ, &sz);
|
||||
|
||||
if (w)
|
||||
{
|
||||
*w = sz.ws_col;
|
||||
}
|
||||
|
||||
if (h)
|
||||
{
|
||||
*h = sz.ws_row;
|
||||
}
|
||||
}
|
||||
|
||||
static void send_attr(uint32_t fg, uint32_t bg)
|
||||
{
|
||||
#define LAST_ATTR_INIT 0xFFFFFFFF
|
||||
static uint32_t lastfg = LAST_ATTR_INIT, lastbg = LAST_ATTR_INIT;
|
||||
|
||||
if (fg != lastfg || bg != lastbg)
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_SGR0]);
|
||||
uint32_t fgcol;
|
||||
uint32_t bgcol;
|
||||
|
||||
switch (outputmode)
|
||||
{
|
||||
case TB_OUTPUT_TRUECOLOR:
|
||||
fgcol = fg;
|
||||
bgcol = bg;
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_256:
|
||||
fgcol = fg & 0xFF;
|
||||
bgcol = bg & 0xFF;
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_216:
|
||||
fgcol = fg & 0xFF;
|
||||
|
||||
if (fgcol > 215)
|
||||
{
|
||||
fgcol = 7;
|
||||
}
|
||||
|
||||
bgcol = bg & 0xFF;
|
||||
|
||||
if (bgcol > 215)
|
||||
{
|
||||
bgcol = 0;
|
||||
}
|
||||
|
||||
fgcol += 0x10;
|
||||
bgcol += 0x10;
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_GRAYSCALE:
|
||||
fgcol = fg & 0xFF;
|
||||
|
||||
if (fgcol > 23)
|
||||
{
|
||||
fgcol = 23;
|
||||
}
|
||||
|
||||
bgcol = bg & 0xFF;
|
||||
|
||||
if (bgcol > 23)
|
||||
{
|
||||
bgcol = 0;
|
||||
}
|
||||
|
||||
fgcol += 0xe8;
|
||||
bgcol += 0xe8;
|
||||
break;
|
||||
|
||||
case TB_OUTPUT_NORMAL:
|
||||
default:
|
||||
fgcol = fg & 0x0F;
|
||||
bgcol = bg & 0x0F;
|
||||
}
|
||||
|
||||
if (fg & TB_BOLD)
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_BOLD]);
|
||||
}
|
||||
|
||||
if (bg & TB_BOLD)
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_BLINK]);
|
||||
}
|
||||
|
||||
if (fg & TB_UNDERLINE)
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_UNDERLINE]);
|
||||
}
|
||||
|
||||
if ((fg & TB_REVERSE) || (bg & TB_REVERSE))
|
||||
{
|
||||
memstream_puts(&write_buffer, funcs[T_REVERSE]);
|
||||
}
|
||||
|
||||
write_sgr(fgcol, bgcol);
|
||||
|
||||
lastfg = fg;
|
||||
lastbg = bg;
|
||||
}
|
||||
}
|
||||
|
||||
static void send_char(int x, int y, uint32_t c)
|
||||
{
|
||||
char buf[7];
|
||||
int bw = utf8_unicode_to_char(buf, c);
|
||||
buf[bw] = '\0';
|
||||
|
||||
if (x - 1 != lastx || y != lasty)
|
||||
{
|
||||
write_cursor(x, y);
|
||||
}
|
||||
|
||||
lastx = x;
|
||||
lasty = y;
|
||||
|
||||
if (!c)
|
||||
{
|
||||
buf[0] = ' '; // replace 0 with whitespace
|
||||
}
|
||||
|
||||
memstream_puts(&write_buffer, buf);
|
||||
}
|
||||
|
||||
static void send_clear(void)
|
||||
{
|
||||
send_attr(foreground, background);
|
||||
memstream_puts(&write_buffer, funcs[T_CLEAR_SCREEN]);
|
||||
|
||||
if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y))
|
||||
{
|
||||
write_cursor(cursor_x, cursor_y);
|
||||
}
|
||||
|
||||
memstream_flush(&write_buffer);
|
||||
|
||||
// we need to invalidate cursor position too and these two vars are
|
||||
// used only for simple cursor positioning optimization, cursor
|
||||
// actually may be in the correct place, but we simply discard
|
||||
// optimization once and it gives us simple solution for the case when
|
||||
// cursor moved
|
||||
lastx = LAST_COORD_INIT;
|
||||
lasty = LAST_COORD_INIT;
|
||||
}
|
||||
|
||||
static void sigwinch_handler(int xxx)
|
||||
{
|
||||
(void) xxx;
|
||||
const int zzz = 1;
|
||||
write(winch_fds[1], &zzz, sizeof(int));
|
||||
}
|
||||
|
||||
static void update_size(void)
|
||||
{
|
||||
update_term_size();
|
||||
cellbuf_resize(&back_buffer, termw, termh);
|
||||
cellbuf_resize(&front_buffer, termw, termh);
|
||||
cellbuf_clear(&front_buffer);
|
||||
send_clear();
|
||||
}
|
||||
|
||||
static void update_term_size(void)
|
||||
{
|
||||
struct winsize sz;
|
||||
memset(&sz, 0, sizeof(sz));
|
||||
|
||||
ioctl(out_fileno, TIOCGWINSZ, &sz);
|
||||
|
||||
termw = sz.ws_col;
|
||||
termh = sz.ws_row;
|
||||
}
|
||||
|
||||
static int wait_fill_event(struct tb_event* event, struct timeval* timeout)
|
||||
{
|
||||
#define ENOUGH_DATA_FOR_INPUT_PARSING 128
|
||||
int result;
|
||||
char buf[ENOUGH_DATA_FOR_INPUT_PARSING];
|
||||
fd_set events;
|
||||
memset(event, 0, sizeof(struct tb_event));
|
||||
|
||||
// try to extract event from input buffer, return on success
|
||||
event->type = TB_EVENT_KEY;
|
||||
|
||||
if (extract_event(event, &inbuf, inputmode))
|
||||
{
|
||||
return event->type;
|
||||
}
|
||||
|
||||
// it looks like input buffer is incomplete, let's try the short path
|
||||
size_t r = fread(buf, 1, ENOUGH_DATA_FOR_INPUT_PARSING, in);
|
||||
|
||||
if (r < ENOUGH_DATA_FOR_INPUT_PARSING && feof(in))
|
||||
{
|
||||
clearerr(in);
|
||||
}
|
||||
|
||||
if (r > 0)
|
||||
{
|
||||
if (ringbuffer_free_space(&inbuf) < r)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
ringbuffer_push(&inbuf, buf, r);
|
||||
|
||||
if (extract_event(event, &inbuf, inputmode))
|
||||
{
|
||||
return event->type;
|
||||
}
|
||||
}
|
||||
|
||||
// no stuff in FILE's internal buffer, block in select
|
||||
while (1)
|
||||
{
|
||||
FD_ZERO(&events);
|
||||
FD_SET(in_fileno, &events);
|
||||
FD_SET(winch_fds[0], &events);
|
||||
int maxfd = (winch_fds[0] > in_fileno) ? winch_fds[0] : in_fileno;
|
||||
result = select(maxfd + 1, &events, 0, 0, timeout);
|
||||
|
||||
if (!result)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (FD_ISSET(in_fileno, &events))
|
||||
{
|
||||
event->type = TB_EVENT_KEY;
|
||||
size_t r = fread(buf, 1, ENOUGH_DATA_FOR_INPUT_PARSING, in);
|
||||
|
||||
if (r < ENOUGH_DATA_FOR_INPUT_PARSING && feof(in))
|
||||
{
|
||||
clearerr(in);
|
||||
}
|
||||
|
||||
if (r == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// if there is no free space in input buffer, return error
|
||||
if (ringbuffer_free_space(&inbuf) < r)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
// fill buffer
|
||||
ringbuffer_push(&inbuf, buf, r);
|
||||
|
||||
if (extract_event(event, &inbuf, inputmode))
|
||||
{
|
||||
return event->type;
|
||||
}
|
||||
}
|
||||
|
||||
if (FD_ISSET(winch_fds[0], &events))
|
||||
{
|
||||
event->type = TB_EVENT_RESIZE;
|
||||
int zzz = 0;
|
||||
read(winch_fds[0], &zzz, sizeof(int));
|
||||
buffer_size_change_request = 1;
|
||||
get_term_size(&event->w, &event->h);
|
||||
return TB_EVENT_RESIZE;
|
||||
}
|
||||
}
|
||||
}
|
||||
307
dep/termbox_next/src/termbox.h
Normal file
307
dep/termbox_next/src/termbox.h
Normal file
@@ -0,0 +1,307 @@
|
||||
#ifndef H_TERMBOX
|
||||
#define H_TERMBOX
|
||||
#include <stdint.h>
|
||||
|
||||
// shared objects
|
||||
#if __GNUC__ >= 4
|
||||
#define SO_IMPORT __attribute__((visibility("default")))
|
||||
#else
|
||||
#define SO_IMPORT
|
||||
#endif
|
||||
|
||||
// c++
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Key constants. See also struct tb_event's key field.
|
||||
// These are a safe subset of terminfo keys, which exist on all popular
|
||||
// terminals. Termbox uses only them to stay truly portable.
|
||||
#define TB_KEY_F1 (0xFFFF-0)
|
||||
#define TB_KEY_F2 (0xFFFF-1)
|
||||
#define TB_KEY_F3 (0xFFFF-2)
|
||||
#define TB_KEY_F4 (0xFFFF-3)
|
||||
#define TB_KEY_F5 (0xFFFF-4)
|
||||
#define TB_KEY_F6 (0xFFFF-5)
|
||||
#define TB_KEY_F7 (0xFFFF-6)
|
||||
#define TB_KEY_F8 (0xFFFF-7)
|
||||
#define TB_KEY_F9 (0xFFFF-8)
|
||||
#define TB_KEY_F10 (0xFFFF-9)
|
||||
#define TB_KEY_F11 (0xFFFF-10)
|
||||
#define TB_KEY_F12 (0xFFFF-11)
|
||||
#define TB_KEY_INSERT (0xFFFF-12)
|
||||
#define TB_KEY_DELETE (0xFFFF-13)
|
||||
#define TB_KEY_HOME (0xFFFF-14)
|
||||
#define TB_KEY_END (0xFFFF-15)
|
||||
#define TB_KEY_PGUP (0xFFFF-16)
|
||||
#define TB_KEY_PGDN (0xFFFF-17)
|
||||
#define TB_KEY_ARROW_UP (0xFFFF-18)
|
||||
#define TB_KEY_ARROW_DOWN (0xFFFF-19)
|
||||
#define TB_KEY_ARROW_LEFT (0xFFFF-20)
|
||||
#define TB_KEY_ARROW_RIGHT (0xFFFF-21)
|
||||
#define TB_KEY_MOUSE_LEFT (0xFFFF-22)
|
||||
#define TB_KEY_MOUSE_RIGHT (0xFFFF-23)
|
||||
#define TB_KEY_MOUSE_MIDDLE (0xFFFF-24)
|
||||
#define TB_KEY_MOUSE_RELEASE (0xFFFF-25)
|
||||
#define TB_KEY_MOUSE_WHEEL_UP (0xFFFF-26)
|
||||
#define TB_KEY_MOUSE_WHEEL_DOWN (0xFFFF-27)
|
||||
|
||||
// These are all ASCII code points below SPACE character and a BACKSPACE key.
|
||||
#define TB_KEY_CTRL_TILDE 0x00
|
||||
#define TB_KEY_CTRL_2 0x00 // clash with 'CTRL_TILDE'
|
||||
#define TB_KEY_CTRL_A 0x01
|
||||
#define TB_KEY_CTRL_B 0x02
|
||||
#define TB_KEY_CTRL_C 0x03
|
||||
#define TB_KEY_CTRL_D 0x04
|
||||
#define TB_KEY_CTRL_E 0x05
|
||||
#define TB_KEY_CTRL_F 0x06
|
||||
#define TB_KEY_CTRL_G 0x07
|
||||
#define TB_KEY_BACKSPACE 0x08
|
||||
#define TB_KEY_CTRL_H 0x08 // clash with 'CTRL_BACKSPACE'
|
||||
#define TB_KEY_TAB 0x09
|
||||
#define TB_KEY_CTRL_I 0x09 // clash with 'TAB'
|
||||
#define TB_KEY_CTRL_J 0x0A
|
||||
#define TB_KEY_CTRL_K 0x0B
|
||||
#define TB_KEY_CTRL_L 0x0C
|
||||
#define TB_KEY_ENTER 0x0D
|
||||
#define TB_KEY_CTRL_M 0x0D // clash with 'ENTER'
|
||||
#define TB_KEY_CTRL_N 0x0E
|
||||
#define TB_KEY_CTRL_O 0x0F
|
||||
#define TB_KEY_CTRL_P 0x10
|
||||
#define TB_KEY_CTRL_Q 0x11
|
||||
#define TB_KEY_CTRL_R 0x12
|
||||
#define TB_KEY_CTRL_S 0x13
|
||||
#define TB_KEY_CTRL_T 0x14
|
||||
#define TB_KEY_CTRL_U 0x15
|
||||
#define TB_KEY_CTRL_V 0x16
|
||||
#define TB_KEY_CTRL_W 0x17
|
||||
#define TB_KEY_CTRL_X 0x18
|
||||
#define TB_KEY_CTRL_Y 0x19
|
||||
#define TB_KEY_CTRL_Z 0x1A
|
||||
#define TB_KEY_ESC 0x1B
|
||||
#define TB_KEY_CTRL_LSQ_BRACKET 0x1B // clash with 'ESC'
|
||||
#define TB_KEY_CTRL_3 0x1B // clash with 'ESC'
|
||||
#define TB_KEY_CTRL_4 0x1C
|
||||
#define TB_KEY_CTRL_BACKSLASH 0x1C // clash with 'CTRL_4'
|
||||
#define TB_KEY_CTRL_5 0x1D
|
||||
#define TB_KEY_CTRL_RSQ_BRACKET 0x1D // clash with 'CTRL_5'
|
||||
#define TB_KEY_CTRL_6 0x1E
|
||||
#define TB_KEY_CTRL_7 0x1F
|
||||
#define TB_KEY_CTRL_SLASH 0x1F // clash with 'CTRL_7'
|
||||
#define TB_KEY_CTRL_UNDERSCORE 0x1F // clash with 'CTRL_7'
|
||||
#define TB_KEY_SPACE 0x20
|
||||
#define TB_KEY_BACKSPACE2 0x7F
|
||||
#define TB_KEY_CTRL_8 0x7F // clash with 'BACKSPACE2'
|
||||
|
||||
// These are non-existing ones.
|
||||
// #define TB_KEY_CTRL_1 clash with '1'
|
||||
// #define TB_KEY_CTRL_9 clash with '9'
|
||||
// #define TB_KEY_CTRL_0 clash with '0'
|
||||
|
||||
// Alt modifier constant, see tb_event.mod field and tb_select_input_mode function.
|
||||
// Mouse-motion modifier
|
||||
#define TB_MOD_ALT 0x01
|
||||
#define TB_MOD_MOTION 0x02
|
||||
|
||||
// Colors (see struct tb_cell's fg and bg fields).
|
||||
#define TB_DEFAULT 0x00
|
||||
#define TB_BLACK 0x01
|
||||
#define TB_RED 0x02
|
||||
#define TB_GREEN 0x03
|
||||
#define TB_YELLOW 0x04
|
||||
#define TB_BLUE 0x05
|
||||
#define TB_MAGENTA 0x06
|
||||
#define TB_CYAN 0x07
|
||||
#define TB_WHITE 0x08
|
||||
|
||||
// Attributes, it is possible to use multiple attributes by combining them
|
||||
// using bitwise OR ('|'). Although, colors cannot be combined. But you can
|
||||
// combine attributes and a single color. See also struct tb_cell's fg and bg
|
||||
// fields.
|
||||
#define TB_BOLD 0x01000000
|
||||
#define TB_UNDERLINE 0x02000000
|
||||
#define TB_REVERSE 0x04000000
|
||||
|
||||
// A cell, single conceptual entity on the terminal screen. The terminal screen
|
||||
// is basically a 2d array of cells. It has the following fields:
|
||||
// - 'ch' is a unicode character
|
||||
// - 'fg' foreground color and attributes
|
||||
// - 'bg' background color and attributes
|
||||
struct tb_cell
|
||||
{
|
||||
uint32_t ch;
|
||||
uint32_t fg;
|
||||
uint32_t bg;
|
||||
};
|
||||
|
||||
#define TB_EVENT_KEY 1
|
||||
#define TB_EVENT_RESIZE 2
|
||||
#define TB_EVENT_MOUSE 3
|
||||
|
||||
// An event, single interaction from the user. The 'mod' and 'ch' fields are
|
||||
// valid if 'type' is TB_EVENT_KEY. The 'w' and 'h' fields are valid if 'type'
|
||||
// is TB_EVENT_RESIZE. The 'x' and 'y' fields are valid if 'type' is
|
||||
// TB_EVENT_MOUSE. The 'key' field is valid if 'type' is either TB_EVENT_KEY
|
||||
// or TB_EVENT_MOUSE. The fields 'key' and 'ch' are mutually exclusive; only
|
||||
// one of them can be non-zero at a time.
|
||||
struct tb_event
|
||||
{
|
||||
uint8_t type;
|
||||
uint8_t mod; // modifiers to either 'key' or 'ch' below
|
||||
uint16_t key; // one of the TB_KEY_* constants
|
||||
uint32_t ch; // unicode character
|
||||
int32_t w;
|
||||
int32_t h;
|
||||
int32_t x;
|
||||
int32_t y;
|
||||
};
|
||||
|
||||
// Error codes returned by tb_init(). All of them are self-explanatory, except
|
||||
// the pipe trap error. Termbox uses unix pipes in order to deliver a message
|
||||
// from a signal handler (SIGWINCH) to the main event reading loop. Honestly in
|
||||
// most cases you should just check the returned code as < 0.
|
||||
#define TB_EUNSUPPORTED_TERMINAL -1
|
||||
#define TB_EFAILED_TO_OPEN_TTY -2
|
||||
#define TB_EPIPE_TRAP_ERROR -3
|
||||
|
||||
// Initializes the termbox library. This function should be called before any
|
||||
// other functions. Function tb_init is same as tb_init_file("/dev/tty"). After successful initialization, the library must be
|
||||
// finalized using the tb_shutdown() function.
|
||||
SO_IMPORT int tb_init(void);
|
||||
SO_IMPORT int tb_init_file(const char* name);
|
||||
SO_IMPORT void tb_shutdown(void);
|
||||
|
||||
// Returns the size of the internal back buffer (which is the same as
|
||||
// terminal's window size in characters). The internal buffer can be resized
|
||||
// after tb_clear() or tb_present() function calls. Both dimensions have an
|
||||
// unspecified negative value when called before tb_init() or after
|
||||
// tb_shutdown().
|
||||
SO_IMPORT int tb_width(void);
|
||||
SO_IMPORT int tb_height(void);
|
||||
|
||||
// Clears the internal back buffer using TB_DEFAULT color or the
|
||||
// color/attributes set by tb_set_clear_attributes() function.
|
||||
SO_IMPORT void tb_clear(void);
|
||||
SO_IMPORT void tb_set_clear_attributes(uint32_t fg, uint32_t bg);
|
||||
|
||||
// Synchronizes the internal back buffer with the terminal.
|
||||
SO_IMPORT void tb_present(void);
|
||||
|
||||
#define TB_HIDE_CURSOR -1
|
||||
|
||||
// Sets the position of the cursor. Upper-left character is (0, 0). If you pass
|
||||
// TB_HIDE_CURSOR as both coordinates, then the cursor will be hidden. Cursor
|
||||
// is hidden by default.
|
||||
SO_IMPORT void tb_set_cursor(int cx, int cy);
|
||||
|
||||
// Changes cell's parameters in the internal back buffer at the specified
|
||||
// position.
|
||||
SO_IMPORT void tb_put_cell(int x, int y, const struct tb_cell* cell);
|
||||
SO_IMPORT void tb_change_cell(int x, int y, uint32_t ch, uint32_t fg,
|
||||
uint32_t bg);
|
||||
|
||||
// Copies the buffer from 'cells' at the specified position, assuming the
|
||||
// buffer is a two-dimensional array of size ('w' x 'h'), represented as a
|
||||
// one-dimensional buffer containing lines of cells starting from the top.
|
||||
// (DEPRECATED: use tb_cell_buffer() instead and copy memory on your own)
|
||||
SO_IMPORT void tb_blit(int x, int y, int w, int h, const struct tb_cell* cells);
|
||||
|
||||
// Returns a pointer to internal cell back buffer. You can get its dimensions
|
||||
// using tb_width() and tb_height() functions. The pointer stays valid as long
|
||||
// as no tb_clear() and tb_present() calls are made. The buffer is
|
||||
// one-dimensional buffer containing lines of cells starting from the top.
|
||||
SO_IMPORT struct tb_cell* tb_cell_buffer(void);
|
||||
|
||||
#define TB_INPUT_CURRENT 0 // 000
|
||||
#define TB_INPUT_ESC 1 // 001
|
||||
#define TB_INPUT_ALT 2 // 010
|
||||
#define TB_INPUT_MOUSE 4 // 100
|
||||
|
||||
// Sets the termbox input mode. Termbox has two input modes:
|
||||
// 1. Esc input mode.
|
||||
// When ESC sequence is in the buffer and it doesn't match any known
|
||||
// ESC sequence => ESC means TB_KEY_ESC.
|
||||
// 2. Alt input mode.
|
||||
// When ESC sequence is in the buffer and it doesn't match any known
|
||||
// sequence => ESC enables TB_MOD_ALT modifier for the next keyboard event.
|
||||
//
|
||||
// You can also apply TB_INPUT_MOUSE via bitwise OR operation to either of the
|
||||
// modes (e.g. TB_INPUT_ESC | TB_INPUT_MOUSE). If none of the main two modes
|
||||
// were set, but the mouse mode was, TB_INPUT_ESC mode is used. If for some
|
||||
// reason you've decided to use (TB_INPUT_ESC | TB_INPUT_ALT) combination, it
|
||||
// will behave as if only TB_INPUT_ESC was selected.
|
||||
//
|
||||
// If 'mode' is TB_INPUT_CURRENT, it returns the current input mode.
|
||||
//
|
||||
// Default termbox input mode is TB_INPUT_ESC.
|
||||
SO_IMPORT int tb_select_input_mode(int mode);
|
||||
|
||||
#define TB_OUTPUT_CURRENT 0
|
||||
#define TB_OUTPUT_NORMAL 1
|
||||
#define TB_OUTPUT_256 2
|
||||
#define TB_OUTPUT_216 3
|
||||
#define TB_OUTPUT_GRAYSCALE 4
|
||||
#define TB_OUTPUT_TRUECOLOR 5
|
||||
|
||||
// Sets the termbox output mode. Termbox has three output options:
|
||||
// 1. TB_OUTPUT_NORMAL => [1..8]
|
||||
// This mode provides 8 different colors:
|
||||
// black, red, green, yellow, blue, magenta, cyan, white
|
||||
// Shortcut: TB_BLACK, TB_RED, ...
|
||||
// Attributes: TB_BOLD, TB_UNDERLINE, TB_REVERSE
|
||||
//
|
||||
// Example usage:
|
||||
// tb_change_cell(x, y, '@', TB_BLACK | TB_BOLD, TB_RED);
|
||||
//
|
||||
// 2. TB_OUTPUT_256 => [0..256]
|
||||
// In this mode you can leverage the 256 terminal mode:
|
||||
// 0x00 - 0x07: the 8 colors as in TB_OUTPUT_NORMAL
|
||||
// 0x08 - 0x0f: TB_* | TB_BOLD
|
||||
// 0x10 - 0xe7: 216 different colors
|
||||
// 0xe8 - 0xff: 24 different shades of grey
|
||||
//
|
||||
// Example usage:
|
||||
// tb_change_cell(x, y, '@', 184, 240);
|
||||
// tb_change_cell(x, y, '@', 0xb8, 0xf0);
|
||||
//
|
||||
// 3. TB_OUTPUT_216 => [0..216]
|
||||
// This mode supports the 3rd range of the 256 mode only.
|
||||
// But you don't need to provide an offset.
|
||||
//
|
||||
// 4. TB_OUTPUT_GRAYSCALE => [0..23]
|
||||
// This mode supports the 4th range of the 256 mode only.
|
||||
// But you dont need to provide an offset.
|
||||
//
|
||||
// 5. TB_OUTPUT_TRUECOLOR => [0x000000..0xFFFFFF]
|
||||
// This mode supports 24-bit true color. Format is 0xRRGGBB.
|
||||
//
|
||||
// Execute build/src/demo/output to see its impact on your terminal.
|
||||
//
|
||||
// If 'mode' is TB_OUTPUT_CURRENT, it returns the current output mode.
|
||||
//
|
||||
// Default termbox output mode is TB_OUTPUT_NORMAL.
|
||||
SO_IMPORT int tb_select_output_mode(int mode);
|
||||
|
||||
// Wait for an event up to 'timeout' milliseconds and fill the 'event'
|
||||
// structure with it, when the event is available. Returns the type of the
|
||||
// event (one of TB_EVENT_* constants) or -1 if there was an error or 0 in case
|
||||
// there were no event during 'timeout' period.
|
||||
SO_IMPORT int tb_peek_event(struct tb_event* event, int timeout);
|
||||
|
||||
// Wait for an event forever and fill the 'event' structure with it, when the
|
||||
// event is available. Returns the type of the event (one of TB_EVENT_
|
||||
// constants) or -1 if there was an error.
|
||||
SO_IMPORT int tb_poll_event(struct tb_event* event);
|
||||
|
||||
// Utility utf8 functions.
|
||||
#define TB_EOF -1
|
||||
SO_IMPORT int utf8_char_length(char c);
|
||||
SO_IMPORT int utf8_char_to_unicode(uint32_t* out, const char* c);
|
||||
SO_IMPORT int utf8_unicode_to_char(char* out, uint32_t c);
|
||||
|
||||
// c++
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
106
dep/termbox_next/src/utf8.c
Normal file
106
dep/termbox_next/src/utf8.c
Normal file
@@ -0,0 +1,106 @@
|
||||
#include "termbox.h"
|
||||
|
||||
static const unsigned char utf8_length[256] =
|
||||
{
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1
|
||||
};
|
||||
|
||||
static const unsigned char utf8_mask[6] =
|
||||
{
|
||||
0x7F,
|
||||
0x1F,
|
||||
0x0F,
|
||||
0x07,
|
||||
0x03,
|
||||
0x01
|
||||
};
|
||||
|
||||
int utf8_char_length(char c)
|
||||
{
|
||||
return utf8_length[(unsigned char)c];
|
||||
}
|
||||
|
||||
int utf8_char_to_unicode(uint32_t* out, const char* c)
|
||||
{
|
||||
if (*c == 0)
|
||||
{
|
||||
return TB_EOF;
|
||||
}
|
||||
|
||||
int i;
|
||||
unsigned char len = utf8_char_length(*c);
|
||||
unsigned char mask = utf8_mask[len - 1];
|
||||
uint32_t result = c[0] & mask;
|
||||
|
||||
for (i = 1; i < len; ++i)
|
||||
{
|
||||
result <<= 6;
|
||||
result |= c[i] & 0x3f;
|
||||
}
|
||||
|
||||
*out = result;
|
||||
return (int)len;
|
||||
}
|
||||
|
||||
int utf8_unicode_to_char(char* out, uint32_t c)
|
||||
{
|
||||
int len = 0;
|
||||
int first;
|
||||
int i;
|
||||
|
||||
if (c < 0x80)
|
||||
{
|
||||
first = 0;
|
||||
len = 1;
|
||||
}
|
||||
else if (c < 0x800)
|
||||
{
|
||||
first = 0xc0;
|
||||
len = 2;
|
||||
}
|
||||
else if (c < 0x10000)
|
||||
{
|
||||
first = 0xe0;
|
||||
len = 3;
|
||||
}
|
||||
else if (c < 0x200000)
|
||||
{
|
||||
first = 0xf0;
|
||||
len = 4;
|
||||
}
|
||||
else if (c < 0x4000000)
|
||||
{
|
||||
first = 0xf8;
|
||||
len = 5;
|
||||
}
|
||||
else
|
||||
{
|
||||
first = 0xfc;
|
||||
len = 6;
|
||||
}
|
||||
|
||||
for (i = len - 1; i > 0; --i)
|
||||
{
|
||||
out[i] = (c & 0x3f) | 0x80;
|
||||
c >>= 6;
|
||||
}
|
||||
|
||||
out[0] = c | first;
|
||||
|
||||
return len;
|
||||
}
|
||||
27
dep/termbox_next/tools/astylerc
Normal file
27
dep/termbox_next/tools/astylerc
Normal file
@@ -0,0 +1,27 @@
|
||||
--style=break
|
||||
--indent=force-tab=4
|
||||
--indent-classes
|
||||
--indent-switches
|
||||
--indent-namespaces
|
||||
--indent-after-parens
|
||||
--indent-continuation=1
|
||||
--indent-preproc-block
|
||||
--indent-preproc-define
|
||||
--indent-preproc-cond
|
||||
--indent-col1-comments
|
||||
--min-conditional-indent=0
|
||||
--max-continuation-indent=40
|
||||
--break-blocks
|
||||
--pad-oper
|
||||
--pad-comma
|
||||
--pad-header
|
||||
--unpad-paren
|
||||
--align-pointer=type
|
||||
--align-reference=type
|
||||
--break-one-line-headers
|
||||
--add-braces
|
||||
--attach-return-type
|
||||
--attach-return-type-decl
|
||||
--remove-comment-prefix
|
||||
--max-code-length=80
|
||||
--mode=c
|
||||
108
dep/termbox_next/tools/collect_terminfo.py
Executable file
108
dep/termbox_next/tools/collect_terminfo.py
Executable file
@@ -0,0 +1,108 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import sys, os, subprocess
|
||||
|
||||
def escaped(s):
|
||||
return s.replace("\033", "\\033")
|
||||
|
||||
def tput(term, name):
|
||||
try:
|
||||
return subprocess.check_output(['tput', '-T%s' % term, name]).decode()
|
||||
except subprocess.CalledProcessError as e:
|
||||
return e.output.decode()
|
||||
|
||||
|
||||
def w(s):
|
||||
if s == None:
|
||||
return
|
||||
sys.stdout.write(s)
|
||||
|
||||
terminals = {
|
||||
'xterm' : 'xterm',
|
||||
'rxvt-256color' : 'rxvt_256color',
|
||||
'rxvt-unicode' : 'rxvt_unicode',
|
||||
'linux' : 'linux',
|
||||
'Eterm' : 'eterm',
|
||||
'screen' : 'screen'
|
||||
}
|
||||
|
||||
keys = [
|
||||
"F1", "kf1",
|
||||
"F2", "kf2",
|
||||
"F3", "kf3",
|
||||
"F4", "kf4",
|
||||
"F5", "kf5",
|
||||
"F6", "kf6",
|
||||
"F7", "kf7",
|
||||
"F8", "kf8",
|
||||
"F9", "kf9",
|
||||
"F10", "kf10",
|
||||
"F11", "kf11",
|
||||
"F12", "kf12",
|
||||
"INSERT", "kich1",
|
||||
"DELETE", "kdch1",
|
||||
"HOME", "khome",
|
||||
"END", "kend",
|
||||
"PGUP", "kpp",
|
||||
"PGDN", "knp",
|
||||
"KEY_UP", "kcuu1",
|
||||
"KEY_DOWN", "kcud1",
|
||||
"KEY_LEFT", "kcub1",
|
||||
"KEY_RIGHT", "kcuf1"
|
||||
]
|
||||
|
||||
funcs = [
|
||||
"T_ENTER_CA", "smcup",
|
||||
"T_EXIT_CA", "rmcup",
|
||||
"T_SHOW_CURSOR", "cnorm",
|
||||
"T_HIDE_CURSOR", "civis",
|
||||
"T_CLEAR_SCREEN", "clear",
|
||||
"T_SGR0", "sgr0",
|
||||
"T_UNDERLINE", "smul",
|
||||
"T_BOLD", "bold",
|
||||
"T_BLINK", "blink",
|
||||
"T_REVERSE", "rev",
|
||||
"T_ENTER_KEYPAD", "smkx",
|
||||
"T_EXIT_KEYPAD", "rmkx"
|
||||
]
|
||||
|
||||
def iter_pairs(iterable):
|
||||
iterable = iter(iterable)
|
||||
while True:
|
||||
yield (next(iterable), next(iterable))
|
||||
|
||||
def do_term(term, nick):
|
||||
w("// %s\n" % term)
|
||||
w("static const char *%s_keys[] = {\n\t" % nick)
|
||||
for k, v in iter_pairs(keys):
|
||||
w('"')
|
||||
w(escaped(tput(term, v)))
|
||||
w('",')
|
||||
w(" 0\n};\n")
|
||||
w("static const char *%s_funcs[] = {\n\t" % nick)
|
||||
for k,v in iter_pairs(funcs):
|
||||
w('"')
|
||||
if v == "sgr":
|
||||
w("\\033[3%d;4%dm")
|
||||
elif v == "cup":
|
||||
w("\\033[%d;%dH")
|
||||
else:
|
||||
w(escaped(tput(term, v)))
|
||||
w('", ')
|
||||
w("\n};\n\n")
|
||||
|
||||
def do_terms(d):
|
||||
w("static struct term {\n")
|
||||
w("\tconst char *name;\n")
|
||||
w("\tconst char **keys;\n")
|
||||
w("\tconst char **funcs;\n")
|
||||
w("} terms[] = {\n")
|
||||
for k, v in d.items():
|
||||
w('\t{"%s", %s_keys, %s_funcs},\n' % (k, v, v))
|
||||
w("\t{0, 0, 0},\n")
|
||||
w("};\n")
|
||||
|
||||
for k,v in terminals.items():
|
||||
do_term(k, v)
|
||||
|
||||
do_terms(terminals)
|
||||
338
readme.md
338
readme.md
@@ -1,290 +1,210 @@
|
||||
# The Ly display manager
|
||||
|
||||
|
||||
# Ly - a TUI display manager
|
||||
|
||||
|
||||
Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD,
|
||||
designed with portability in mind (e.g. it does not require systemd to run).
|
||||
|
||||
Join us on Matrix over at [#ly:envs.net](https://matrix.to/#/#ly:envs.net)!
|
||||
|
||||
**Note**: Development happens on [Codeberg](https://codeberg.org/fairyglade/ly)
|
||||
with a mirror on [GitHub](https://github.com/fairyglade/ly).
|
||||
Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD.
|
||||
|
||||
## Dependencies
|
||||
|
||||
- Compile-time:
|
||||
- zig 0.15.x
|
||||
- libc
|
||||
- zig 0.12.0
|
||||
- a C standard library
|
||||
- pam
|
||||
- xcb (optional, required by default; needed for X11 support)
|
||||
- xcb
|
||||
- Runtime (with default config):
|
||||
- xorg
|
||||
- xorg-xauth
|
||||
- mcookie
|
||||
- tput
|
||||
- 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.
|
||||
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
|
||||
```
|
||||
|
||||
### FreeBSD
|
||||
|
||||
```
|
||||
# pkg install ca_root_nss libxcb git xorg xauth
|
||||
```
|
||||
|
||||
## Availability
|
||||
|
||||
[](https://repology.org/project/ly-display-manager/versions)
|
||||
|
||||
## Support
|
||||
The following desktop environments were tested with success:
|
||||
- awesome
|
||||
- bspwm
|
||||
- budgie
|
||||
- cinnamon
|
||||
- deepin
|
||||
- dwl
|
||||
- dwm
|
||||
- enlightenment
|
||||
- gnome
|
||||
- i3
|
||||
- kde
|
||||
- labwc
|
||||
- lxde
|
||||
- lxqt
|
||||
- mate
|
||||
- maxx
|
||||
- pantheon
|
||||
- qtile
|
||||
- spectrwm
|
||||
- sway
|
||||
- windowmaker
|
||||
- xfce
|
||||
- xmonad
|
||||
|
||||
Ly has been tested with a wide variety of desktop environments and window
|
||||
managers, all of which you can find in the sections below:
|
||||
Ly should work with any X desktop environment, and provides
|
||||
basic wayland support (sway works very well, for example).
|
||||
|
||||
[Wayland environments](#supported-wayland-environments)
|
||||
|
||||
[X11 environments](#supported-x11-environments)
|
||||
|
||||
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:
|
||||
## systemd?
|
||||
Unlike what you may have heard, Ly does not require `systemd`,
|
||||
and was even specifically designed not to depend on `logind`.
|
||||
You should be able to make it work easily with a better init,
|
||||
changing the source code won't be necessary :)
|
||||
|
||||
## 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**: While you can also run Ly in a terminal emulator as root, it is
|
||||
**not** recommended either. If you want to properly test Ly, please enable its
|
||||
service (as described below) and reboot your machine.
|
||||
|
||||
The following sections show how to install Ly for a particular init system.
|
||||
Because the procedure is very similar for all of them, the commands will only
|
||||
be detailed for the first section (which is about systemd).
|
||||
|
||||
**Note**: All following sections will assume you are using LightDM for
|
||||
convenience sake.
|
||||
|
||||
### systemd
|
||||
|
||||
Now, you can install Ly on your system:
|
||||
|
||||
Install Ly and the provided systemd service file
|
||||
```
|
||||
# zig build installexe -Dinit_system=systemd
|
||||
# zig build installsystemd
|
||||
```
|
||||
|
||||
**Note**: The `init_system` parameter is optional and defaults to `systemd`.
|
||||
|
||||
Note that you also need to disable your current display manager. For example,
|
||||
if LightDM is the current display manager, you can execute the following
|
||||
command:
|
||||
|
||||
```
|
||||
# systemctl disable lightdm.service
|
||||
```
|
||||
|
||||
Then, similarly to the previous command, you need to enable the Ly service:
|
||||
|
||||
Enable the service (this will spawn on tty2 and tty9)
|
||||
```
|
||||
# systemctl enable ly@tty2.service
|
||||
# systemctl enable ly@tty9.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:
|
||||
|
||||
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 disable getty@tty2.service
|
||||
```
|
||||
|
||||
You can change the TTY Ly will run on by editing the corresponding
|
||||
service file for your platform, or on systemd, by enabling the service on
|
||||
different TTYs, as is done above.
|
||||
If you have multiple ttys setup with systemd, the tty option will be used as your default tty.
|
||||
|
||||
### OpenRC
|
||||
**NOTE**: 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**: 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 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
|
||||
# dinitctl disable lightdm
|
||||
# dinitctl enable ly
|
||||
```
|
||||
|
||||
To disable TTY 2, go to `/etc/dinit.d/config/console.conf` and modify
|
||||
`ACTIVE_CONSOLES`.
|
||||
|
||||
### sysvinit
|
||||
|
||||
```
|
||||
# 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 overrding the current configuration file. This
|
||||
is called **updating**. To update, simply run:
|
||||
You can also install Ly without copying the system service and the configuration file. That's
|
||||
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
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
You can find all the configuration in `/etc/ly/config.ini`. The file is fully
|
||||
commented, and includes the default values.
|
||||
You can find all the configuration in `/etc/ly/config.ini`.
|
||||
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.
|
||||
This file is supposed to be a shell script! Quoting from xinit's man page:
|
||||
|
||||
## A note on .xinitrc
|
||||
|
||||
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:
|
||||
> 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.
|
||||
|
||||
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` file if X doesn't start, as it can interfere
|
||||
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).
|
||||
|
||||
## Supported Wayland environments
|
||||
## PSX DOOM fire animation
|
||||
To enable the famous PSX DOOM fire described by [Fabien Sanglard](http://fabiensanglard.net/doom_fire_psx/index.html),
|
||||
just uncomment `animate = true` in `/etc/ly/config.ini`. You may also
|
||||
disable the main box borders with `hide_borders = true`.
|
||||
|
||||
- budgie
|
||||
- cosmic
|
||||
- deepin
|
||||
- enlightenment
|
||||
- gnome
|
||||
- hyprland
|
||||
- kde
|
||||
- labwc
|
||||
- niri
|
||||
- pantheon
|
||||
- sway
|
||||
- weston
|
||||
## 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.
|
||||
|
||||
## Supported X11 environments
|
||||
|
||||
- awesome
|
||||
- bspwm
|
||||
- budgie
|
||||
- cinnamon
|
||||
- dwm
|
||||
- enlightenment
|
||||
- gnome
|
||||
- kde
|
||||
- leftwm
|
||||
- lxde
|
||||
- mate
|
||||
- maxx
|
||||
- pantheon
|
||||
- qwm
|
||||
- spectrwm
|
||||
- windowmaker
|
||||
- xfce
|
||||
- xmonad
|
||||
|
||||
## 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.
|
||||
## Gentoo (OpenRC) installation tip
|
||||
To avoid a console spawning on top on Ly, comment out the appropriate line from /etc/inittab (default is 2).
|
||||
|
||||
420
res/config.ini
420
res/config.ini
@@ -1,367 +1,153 @@
|
||||
# Ly supports 24-bit true color with styling, which means each color is a 32-bit value.
|
||||
# The format is 0xSSRRGGBB, where SS is the styling, RR is red, GG is green, and BB is blue.
|
||||
# Here are the possible styling options:
|
||||
# TB_BOLD 0x01000000
|
||||
# TB_UNDERLINE 0x02000000
|
||||
# TB_REVERSE 0x04000000
|
||||
# TB_ITALIC 0x08000000
|
||||
# TB_BLINK 0x10000000
|
||||
# TB_HI_BLACK 0x20000000
|
||||
# TB_BRIGHT 0x40000000
|
||||
# TB_DIM 0x80000000
|
||||
# Programmatically, you'd apply them using the bitwise OR operator (|), but because Ly's
|
||||
# configuration doesn't support using it, you have to manually compute the color value.
|
||||
# Note that, if you want to use the default color value of the terminal, you can use the
|
||||
# special value 0x00000000. This means that, if you want to use black, you *must* use
|
||||
# the styling option TB_HI_BLACK (the RGB values are ignored when using this option).
|
||||
|
||||
# Allow empty password or not when authenticating
|
||||
allow_empty_password = true
|
||||
|
||||
# The active animation
|
||||
# none -> Nothing
|
||||
# none -> Nothing (default)
|
||||
# doom -> PSX DOOM fire
|
||||
# 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
|
||||
|
||||
# Stop the animation after some time
|
||||
# 0 -> Run forever
|
||||
# 1..2e12 -> Stop the animation after this many seconds
|
||||
animation_timeout_sec = 0
|
||||
# Format string for clock in top right corner (see strftime specification). Example: %c
|
||||
clock = null
|
||||
|
||||
# Enable/disable big clock
|
||||
bigclock = false
|
||||
|
||||
# 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
|
||||
# Erase password input on failure
|
||||
clear_password = false
|
||||
|
||||
# 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
|
||||
# Enable vi keybindings
|
||||
vi_mode = false
|
||||
|
||||
# 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, or the value of 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
|
||||
# The `fg` and `bg` color settings take a digit 0-8 corresponding to:
|
||||
#define TB_DEFAULT 0x00
|
||||
#define TB_BLACK 0x01
|
||||
#define TB_RED 0x02
|
||||
#define TB_GREEN 0x03
|
||||
#define TB_YELLOW 0x04
|
||||
#define TB_BLUE 0x05
|
||||
#define TB_MAGENTA 0x06
|
||||
#define TB_CYAN 0x07
|
||||
#define TB_WHITE 0x08
|
||||
#
|
||||
# Setting both to zero makes `bg` black and `fg` white. To set the actual 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 for `ly` config 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 = 8`.
|
||||
|
||||
# Background color id
|
||||
bg = 0x00000000
|
||||
bg = 0
|
||||
|
||||
# Change the state and language of the big clock
|
||||
# none -> Disabled (default)
|
||||
# en -> English
|
||||
# fa -> Farsi
|
||||
bigclock = none
|
||||
# Foreground color id
|
||||
fg = 8
|
||||
|
||||
# Set bigclock to 12-hour notation.
|
||||
bigclock_12hr = false
|
||||
|
||||
# Set bigclock to show the seconds.
|
||||
bigclock_seconds = false
|
||||
# Border color
|
||||
border_fg = 8
|
||||
|
||||
# Blank main box background
|
||||
# Setting to false will make it transparent
|
||||
blank_box = true
|
||||
|
||||
# Border foreground color id
|
||||
border_fg = 0x00FFFFFF
|
||||
|
||||
# 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_down_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q -n s 10%-
|
||||
|
||||
# Brightness decrease key, or null to disable
|
||||
brightness_down_key = F5
|
||||
|
||||
# Brightness increase command
|
||||
brightness_up_cmd = $PREFIX_DIRECTORY/bin/brightnessctl -q -n s +10%
|
||||
|
||||
# Brightness increase key, or null to disable
|
||||
brightness_up_key = F6
|
||||
|
||||
# Erase password input on failure
|
||||
clear_password = false
|
||||
|
||||
# Format string for clock in top right corner (see strftime specification). Example: %c
|
||||
# If null, the clock won't be shown
|
||||
clock = null
|
||||
|
||||
# CMatrix animation foreground color id
|
||||
cmatrix_fg = 0x0000FF00
|
||||
|
||||
# CMatrix animation character string head color id
|
||||
cmatrix_head_col = 0x01FFFFFF
|
||||
|
||||
# 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
|
||||
|
||||
# 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 offset x direction
|
||||
dur_x_offset = 0
|
||||
|
||||
# Dur offset y direction
|
||||
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 foreground color id
|
||||
# Default is red and bold
|
||||
error_fg = 0x01FF0000
|
||||
|
||||
# Foreground color id
|
||||
fg = 0x00FFFFFF
|
||||
|
||||
# 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 used for hibernate (F1-F12)
|
||||
hibernate_key = F4
|
||||
|
||||
# Remove main box borders
|
||||
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
|
||||
# Main box margins
|
||||
margin_box_h = 2
|
||||
margin_box_v = 1
|
||||
|
||||
# Input boxes length
|
||||
input_len = 34
|
||||
|
||||
# Active language
|
||||
# Available languages are found in $CONFIG_DIRECTORY/ly/lang/
|
||||
lang = en
|
||||
# Max input sizes
|
||||
max_desktop_len = 100
|
||||
max_login_len = 255
|
||||
max_password_len = 255
|
||||
|
||||
# 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
|
||||
# Input box active by default on startup
|
||||
# Available inputs: session, login, password
|
||||
default_input = login
|
||||
|
||||
# Path for login.defs file (used for listing all local users on the system on
|
||||
# Linux)
|
||||
login_defs_path = /etc/login.defs
|
||||
# Load the saved desktop and username
|
||||
load = true
|
||||
|
||||
# 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
|
||||
|
||||
# Command executed when pressing restart_key
|
||||
restart_cmd = /sbin/shutdown -r now
|
||||
|
||||
# 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
|
||||
# Deprecated - Will be removed in a future version
|
||||
# New save files are now loaded from the same directory as the config
|
||||
# Currently used to migrate old save files to the new version
|
||||
# File in which to save and load the default desktop and login
|
||||
save_file = /etc/ly/save
|
||||
|
||||
# Session log file path
|
||||
# This will contain stdout and stderr of Wayland sessions
|
||||
# By default it's saved in the user's home directory
|
||||
# Important: due to technical limitations, X11 and shell sessions aren't supported, which
|
||||
# means you won't get any 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
|
||||
|
||||
# Command executed when pressing shutdown_key
|
||||
shutdown_cmd = /sbin/shutdown $PLATFORM_SHUTDOWN_ARG now
|
||||
# Remove power management command hints
|
||||
hide_key_hints = false
|
||||
|
||||
# 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 used for restart (F1-F12)
|
||||
restart_key = F2
|
||||
|
||||
# Specifies the key used for sleep (F1-F12)
|
||||
sleep_key = F3
|
||||
|
||||
# Command executed when starting Ly (before the TTY is taken control of)
|
||||
# If null, no command will be executed
|
||||
start_cmd = null
|
||||
# Command executed when pressing shutdown_key
|
||||
shutdown_cmd = /sbin/shutdown -a now
|
||||
|
||||
# Center the session name.
|
||||
text_in_center = false
|
||||
# Command executed when pressing restart_key
|
||||
restart_cmd = /sbin/shutdown -r now
|
||||
|
||||
# Default vi mode
|
||||
# normal -> normal mode
|
||||
# insert -> insert mode
|
||||
vi_default_mode = normal
|
||||
# Command executed when pressing sleep key (can be null)
|
||||
sleep_cmd = null
|
||||
|
||||
# Enable vi keybindings
|
||||
vi_mode = false
|
||||
# Active language
|
||||
# Available languages are found in /etc/ly/lang/
|
||||
lang = en
|
||||
|
||||
# TTY in use
|
||||
tty = 2
|
||||
|
||||
# Console path
|
||||
console_dev = /dev/console
|
||||
|
||||
# Default path. If null, ly doesn't set a path.
|
||||
path = /sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin
|
||||
|
||||
# Event timeout in milliseconds
|
||||
min_refresh_delta = 5
|
||||
|
||||
# Service name (set to ly to use the provided pam config file)
|
||||
service_name = ly
|
||||
|
||||
# Terminal reset command (tput is faster)
|
||||
term_reset_cmd = /usr/bin/tput reset
|
||||
|
||||
# Terminal restore cursor command
|
||||
term_restore_cursor_cmd = /usr/bin/tput cnorm
|
||||
|
||||
# Cookie generator
|
||||
mcookie_cmd = /usr/bin/mcookie
|
||||
|
||||
# Wayland setup command
|
||||
wayland_cmd = /etc/ly/wsetup.sh
|
||||
|
||||
# Wayland desktop environments
|
||||
# You can specify multiple directories,
|
||||
# e.g. $PREFIX_DIRECTORY/share/wayland-sessions:$PREFIX_DIRECTORY/local/share/wayland-sessions
|
||||
waylandsessions = $PREFIX_DIRECTORY/share/wayland-sessions
|
||||
waylandsessions = /usr/share/wayland-sessions
|
||||
|
||||
# Xorg server command
|
||||
x_cmd = $PREFIX_DIRECTORY/bin/X
|
||||
|
||||
# Xorg xauthority edition tool
|
||||
xauth_cmd = $PREFIX_DIRECTORY/bin/xauth
|
||||
|
||||
# xinitrc
|
||||
# If null, the xinitrc session will be hidden
|
||||
# xinitrc (hidden if null)
|
||||
xinitrc = ~/.xinitrc
|
||||
|
||||
# Xorg server command
|
||||
x_cmd = /usr/bin/X
|
||||
|
||||
# Xorg setup command
|
||||
x_cmd_setup = /etc/ly/xsetup.sh
|
||||
|
||||
# Xorg xauthority edition tool
|
||||
xauth_cmd = /usr/bin/xauth
|
||||
|
||||
# Xorg desktop environments
|
||||
# You can specify multiple directories,
|
||||
# e.g. $PREFIX_DIRECTORY/share/xsessions:$PREFIX_DIRECTORY/local/share/xsessions
|
||||
xsessions = $PREFIX_DIRECTORY/share/xsessions
|
||||
xsessions = /usr/share/xsessions
|
||||
|
||||
@@ -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).
|
||||
@@ -1,78 +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
|
||||
@@ -1,78 +0,0 @@
|
||||
authenticating = удостоверяване...
|
||||
brightness_down = намаляване на яркостта
|
||||
brightness_up = увеличаване на яркостта
|
||||
capslock = caps lock
|
||||
custom = персонализирано
|
||||
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 = заспиване
|
||||
wayland = wayland
|
||||
x11 = x11
|
||||
xinitrc = xinitrc
|
||||
@@ -1,78 +1,45 @@
|
||||
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_alloc = falla d'assignació de memòria
|
||||
err_bounds = índex fora de límit
|
||||
err_chdir = error al obrir carpeta home
|
||||
err_console_dev = error al 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_hostname = error al obtenir el nom del host
|
||||
err_mlock = error al bloquejar la clau de memòria
|
||||
err_null = punter nul
|
||||
err_numlock = error en establir el Bloq num
|
||||
err_pam = error en la transacció pam
|
||||
err_pam_abort = transacció pam avortada
|
||||
err_pam_acct_expired = compte expirat
|
||||
err_pam_auth = error d'autenticació
|
||||
err_pam_authinfo_unavail = error en obtenir la informació de l'usuari
|
||||
err_pam_authinfo_unavail = error al obtenir informació de l'usuari
|
||||
err_pam_authok_reqd = token expirat
|
||||
err_pam_buf = error en la memòria intermèdia
|
||||
err_pam_cred_err = error en establir les credencials
|
||||
err_pam_buf = error de la memòria intermitja
|
||||
err_pam_cred_err = error al establir les credencials
|
||||
err_pam_cred_expired = credencials expirades
|
||||
err_pam_cred_insufficient = credencials insuficients
|
||||
err_pam_cred_unavail = error en obtenir credencials
|
||||
err_pam_maxtries = s'ha assolit al nombre màxim d'intents
|
||||
err_pam_cred_unavail = error al obtenir credencials
|
||||
err_pam_maxtries = s'ha assolit al màxim nombre d'intents
|
||||
err_pam_perm_denied = permís denegat
|
||||
err_pam_session = error de sessió
|
||||
err_pam_sys = error de sistema
|
||||
err_pam_user_unknown = usuari desconegut
|
||||
err_path = error en establir la ruta
|
||||
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_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
|
||||
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
|
||||
err_path = error al establir la ruta
|
||||
err_perm_dir = error al canviar de directori actual
|
||||
err_perm_group = error al degradar els permisos de grup
|
||||
err_perm_user = error al degradar els permisos de l'usuari
|
||||
err_pwnam = error al obtenir la informació de l'usuari
|
||||
err_user_gid = error al establir el GID de l'usuari
|
||||
err_user_init = error al inicialitzar usuari
|
||||
err_user_uid = error al establir el UID de l'usuari
|
||||
err_xsessions_dir = error al cercar la carpeta de sessions
|
||||
err_xsessions_open = error al obrir la carpeta de sessions
|
||||
login = iniciar sessió
|
||||
logout = sessió tancada
|
||||
no_x11_support = el suport per x11 ha estat desactivat en la compilació
|
||||
normal = normal
|
||||
logout = tancar sessió
|
||||
numlock = Bloq Num
|
||||
|
||||
password = Clau
|
||||
restart = reiniciar
|
||||
shell = shell
|
||||
shutdown = aturar
|
||||
sleep = suspendre
|
||||
wayland = wayland
|
||||
x11 = x11
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +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
|
||||
@@ -46,33 +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
|
||||
|
||||
@@ -1,78 +1,45 @@
|
||||
authenticating = authentifizieren...
|
||||
brightness_down = Helligkeit-
|
||||
brightness_up = Helligkeit+
|
||||
capslock = Feststelltaste
|
||||
|
||||
err_alloc = Speicherzuweisung fehlgeschlagen
|
||||
|
||||
|
||||
err_bounds = Index ausserhalb des Bereichs
|
||||
err_brightness_change = Helligkeitsänderung fehlgeschlagen
|
||||
err_chdir = Fehler beim Oeffnen des Home-Ordners
|
||||
|
||||
err_config = Fehler beim Verarbeiten der Konfigurationsdatei
|
||||
|
||||
err_dgn_oob = Diagnose-Nachricht
|
||||
err_domain = Ungueltige Domain
|
||||
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_bounds = Listenindex ist außerhalb des Bereichs
|
||||
err_chdir = Fehler beim oeffnen des home-ordners
|
||||
err_console_dev = Zugriff auf die Konsole fehlgeschlagen
|
||||
err_dgn_oob = Protokoll Nachricht
|
||||
err_domain = Unzulaessige domain
|
||||
err_hostname = Holen des Hostnames fehlgeschlagen
|
||||
err_mlock = Abschließen des Passwortspeichers fehlgeschlagen
|
||||
err_null = Null Zeiger
|
||||
err_pam = pam Transaktion fehlgeschlagen
|
||||
err_pam_abort = pam Transaktion abgebrochen
|
||||
err_pam_acct_expired = Benutzerkonto abgelaufen
|
||||
err_pam_auth = Authentifizierungsfehler
|
||||
err_pam_authinfo_unavail = Abrufen der Benutzerinformationen fehlgeschlagen
|
||||
err_pam_authok_reqd = Passwort abgelaufen
|
||||
err_pam_auth = Authentifizierungs Fehler
|
||||
err_pam_authinfo_unavail = holen der Benutzerinformationen fehlgeschlagen
|
||||
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_maxtries = Maximale Versuchsanzahl erreicht
|
||||
err_pam_perm_denied = Zugriff verweigert
|
||||
err_pam_cred_unavail = Fehler beim holen der Anmeldedaten
|
||||
err_pam_maxtries = Maximale Versuche erreicht
|
||||
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_perm_dir = Ordnerwechsel fehlgeschlagen
|
||||
err_perm_group = Fehler beim Heruntersetzen der Gruppenberechtigungen
|
||||
err_perm_user = Fehler beim Heruntersetzen der Nutzerberechtigungen
|
||||
err_pwnam = Abrufen der Benutzerinformationen fehlgeschlagen
|
||||
err_sleep = Sleep-Befehl fehlgeschlagen
|
||||
|
||||
|
||||
|
||||
err_tty_ctrl = Fehler bei der TTY-Uebergabe
|
||||
|
||||
|
||||
err_user_gid = Fehler beim Setzen der Gruppen-ID
|
||||
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
|
||||
err_path = Fehler beim setzen des Pfades
|
||||
err_perm_dir = Fehler beim wechseln des Ordners
|
||||
err_perm_group = Fehler beim heruntersetzen der Gruppen Berechtigungen
|
||||
err_perm_user = Fehler beim heruntersetzen der Nutzer Berechtigungen
|
||||
err_pwnam = Holen der Benutzerinformationen 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_xsessions_open = Fehler beim öffnen des Sitzungsordners
|
||||
login = Anmelden
|
||||
logout = Abgemeldet
|
||||
numlock = Numtaste
|
||||
password = Passwort
|
||||
restart = Neustarten
|
||||
shell = Shell
|
||||
shell = shell
|
||||
shutdown = Herunterfahren
|
||||
sleep = Sleep
|
||||
wayland = wayland
|
||||
x11 = X11
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +1,13 @@
|
||||
authenticating = authenticating...
|
||||
brightness_down = decrease brightness
|
||||
brightness_up = increase brightness
|
||||
capslock = capslock
|
||||
custom = custom
|
||||
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_config = unable to parse config file
|
||||
err_crawl = failed to crawl session directories
|
||||
err_console_dev = failed to access console
|
||||
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
|
||||
err_pam = pam transaction failed
|
||||
err_pam_abort = pam transaction aborted
|
||||
err_pam_acct_expired = account expired
|
||||
@@ -46,33 +29,22 @@ err_perm_dir = failed to change current directory
|
||||
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_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_unknown = an unknown error occurred
|
||||
err_user_gid = failed to set user GID
|
||||
err_user_init = failed to initialize user
|
||||
err_user_uid = failed to set user UID
|
||||
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
|
||||
numlock = numlock
|
||||
other = other
|
||||
password = password
|
||||
restart = reboot
|
||||
shell = shell
|
||||
shutdown = shutdown
|
||||
sleep = sleep
|
||||
wayland = wayland
|
||||
x11 = x11
|
||||
xinitrc = xinitrc
|
||||
x11 = x11
|
||||
|
||||
@@ -1,30 +1,13 @@
|
||||
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
|
||||
@@ -46,33 +29,17 @@ 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
|
||||
login = iniciar sesión
|
||||
logout = cerrar sesión
|
||||
no_x11_support = soporte para x11 deshabilitado en tiempo de compilación
|
||||
normal = normal
|
||||
numlock = Bloq Num
|
||||
other = otro
|
||||
password = contraseña
|
||||
restart = reiniciar
|
||||
shell = shell
|
||||
shutdown = apagar
|
||||
sleep = suspender
|
||||
wayland = wayland
|
||||
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,36 +1,19 @@
|
||||
authenticating = authentification...
|
||||
brightness_down = diminuer la luminosité
|
||||
brightness_up = augmenter la luminosité
|
||||
capslock = verr.maj
|
||||
custom = customisé
|
||||
capslock = verr.maj
|
||||
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_config = échec de lecture du fichier de configuration
|
||||
err_crawl = échec de la navigation des répertoires de session
|
||||
err_console_dev = échec d'accès à la console
|
||||
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
|
||||
err_pam = échec de la transaction pam
|
||||
err_pam_abort = transaction pam avortée
|
||||
err_pam_acct_expired = compte expiré
|
||||
err_pam_auth = erreur d'authentification
|
||||
err_pam_authinfo_unavail = échec de l'obtention des infos utilisateur
|
||||
err_pam_authok_reqd = tiquet expiré
|
||||
err_pam_authinfo_unavail = échec de l'obtention des infos utilisateur
|
||||
err_pam_buf = erreur de mémoire tampon
|
||||
err_pam_cred_err = échec de la modification des identifiants
|
||||
err_pam_cred_expired = identifiants expirés
|
||||
@@ -46,33 +29,17 @@ 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_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
|
||||
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
|
||||
logout = déconnection
|
||||
numlock = verr.num
|
||||
other = autre
|
||||
password = mot de passe
|
||||
restart = redémarrer
|
||||
shell = shell
|
||||
shutdown = éteindre
|
||||
sleep = veille
|
||||
wayland = wayland
|
||||
x11 = x11
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +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
|
||||
@@ -46,33 +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
|
||||
|
||||
@@ -1,78 +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
|
||||
@@ -1,78 +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
|
||||
@@ -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()
|
||||
@@ -1,78 +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_autologin_session = nie znaleziono sesji autologowania
|
||||
err_bounds = indeks poza zakresem
|
||||
err_brightness_change = nie udało się zmienić jasności
|
||||
err_bounds = indeks poza granicami
|
||||
err_chdir = nie udało się otworzyć folderu domowego
|
||||
err_clock_too_long = ciąg znaków zegara jest za długi
|
||||
err_config = nie można przetworzyć pliku konfiguracyjnego
|
||||
|
||||
err_console_dev = nie udało się uzyskać dostępu do konsoli
|
||||
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_numlock = nie udało się ustawić numlock
|
||||
err_null = wskaźnik zerowy
|
||||
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_perm_dir = nie udało się zmienić obecnego katalogu
|
||||
err_perm_group = nie udało się obniżyć uprawnień grupy
|
||||
err_perm_user = nie udało się obniżyć uprawnień użytkownika
|
||||
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_path = nie udało się ustawić ścieżki
|
||||
err_perm_dir = nie udało się zmienić obecnego katalogu
|
||||
err_perm_group = nie udało się obniżyć uprawnień grupy
|
||||
err_perm_user = nie udało się obniżyć uprawnień użytkownika
|
||||
err_pwnam = nie udało się uzyskać informacji o użytkowniku
|
||||
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_xcb_conn = połączenie xcb nie powiodło się
|
||||
err_xsessions_dir = nie udało się znaleźć folderu sesji
|
||||
err_xsessions_open = nie udało się otworzyć folderu sesji
|
||||
|
||||
insert = wstaw
|
||||
err_xsessions_dir = nie udało się znaleźć folderu sesji
|
||||
err_xsessions_open = nie udało się otworzyć folderu sesji
|
||||
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
|
||||
|
||||
@@ -1,30 +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
|
||||
@@ -46,33 +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
|
||||
|
||||
@@ -1,30 +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
|
||||
@@ -46,33 +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
|
||||
|
||||
@@ -1,25 +1,8 @@
|
||||
|
||||
|
||||
|
||||
capslock = capslock
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
err_console_dev = nu s-a putut accesa consola
|
||||
|
||||
|
||||
|
||||
@@ -51,28 +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
|
||||
|
||||
@@ -1,30 +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_config = не удалось разобрать файл конфигурации
|
||||
|
||||
err_console_dev = не удалось получить доступ к консоли
|
||||
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 = срок действия аккаунта истёк
|
||||
@@ -46,33 +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 = вышел из системы
|
||||
no_x11_support = поддержка x11 отключена во время компиляции
|
||||
normal = обычный
|
||||
logout = logged out
|
||||
numlock = numlock
|
||||
other = прочие
|
||||
password = пароль
|
||||
restart = перезагрузить
|
||||
shell = оболочка
|
||||
shell = shell
|
||||
shutdown = выключить
|
||||
sleep = сон
|
||||
wayland = wayland
|
||||
x11 = x11
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +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
|
||||
@@ -46,33 +29,17 @@ 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
|
||||
|
||||
|
||||
login = korisnik
|
||||
logout = izlogovan
|
||||
|
||||
|
||||
numlock = numlock
|
||||
|
||||
password = lozinka
|
||||
restart = ponovo pokreni
|
||||
shell = shell
|
||||
shutdown = ugasi
|
||||
|
||||
wayland = wayland
|
||||
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +1,13 @@
|
||||
|
||||
|
||||
|
||||
capslock = capslock
|
||||
|
||||
err_alloc = misslyckad minnesallokering
|
||||
|
||||
|
||||
err_bounds = utanför banan index
|
||||
|
||||
err_chdir = misslyckades att öppna hemkatalog
|
||||
|
||||
|
||||
|
||||
err_console_dev = misslyckades att komma åt konsol
|
||||
err_dgn_oob = loggmeddelande
|
||||
err_domain = okänd domän
|
||||
|
||||
|
||||
|
||||
|
||||
err_hostname = misslyckades att hämta värdnamn
|
||||
|
||||
|
||||
|
||||
err_mlock = misslyckades att låsa lösenordsminne
|
||||
err_null = nullpekare
|
||||
|
||||
err_pam = pam-transaktion misslyckades
|
||||
err_pam_abort = pam-transaktion avbröts
|
||||
err_pam_acct_expired = konto upphört
|
||||
@@ -46,33 +29,17 @@ err_perm_dir = misslyckades att ändra aktuell katalog
|
||||
err_perm_group = misslyckades att nergradera gruppbehörigheter
|
||||
err_perm_user = misslyckades att nergradera användarbehörigheter
|
||||
err_pwnam = misslyckades att hämta användarinfo
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
err_user_gid = misslyckades att ställa in användar-GID
|
||||
err_user_init = misslyckades att initialisera användaren
|
||||
err_user_uid = misslyckades att ställa in användar-UID
|
||||
|
||||
|
||||
err_xsessions_dir = misslyckades att hitta sessionskatalog
|
||||
err_xsessions_open = misslyckades att öppna sessionskatalog
|
||||
|
||||
|
||||
login = inloggning
|
||||
logout = utloggad
|
||||
|
||||
|
||||
numlock = numlock
|
||||
|
||||
password = lösenord
|
||||
restart = starta om
|
||||
shell = skal
|
||||
shutdown = stäng av
|
||||
|
||||
wayland = wayland
|
||||
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +1,13 @@
|
||||
|
||||
|
||||
|
||||
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
|
||||
@@ -46,33 +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
|
||||
|
||||
|
||||
login = kullanici
|
||||
logout = oturumdan cikis yapildi
|
||||
|
||||
|
||||
numlock = numlock
|
||||
|
||||
password = sifre
|
||||
restart = yeniden baslat
|
||||
shell = shell
|
||||
shutdown = makineyi kapat
|
||||
|
||||
wayland = wayland
|
||||
|
||||
xinitrc = xinitrc
|
||||
|
||||
@@ -1,30 +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 = термін дії акаунту вичерпано
|
||||
@@ -46,33 +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
|
||||
|
||||
@@ -1,78 +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
|
||||
@@ -1,8 +0,0 @@
|
||||
type = process
|
||||
restart = true
|
||||
smooth-recovery = true
|
||||
command = $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME
|
||||
depends-on = login.target
|
||||
termsignal = HUP
|
||||
# ly needs access to the console while login.target already occupies it
|
||||
options = shares-console
|
||||
@@ -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
|
||||
@@ -19,13 +19,17 @@ then
|
||||
commandUL="/sbin/agetty"
|
||||
fi
|
||||
|
||||
## Get the tty from the conf file
|
||||
CONFTTY=$(cat /etc/ly/config.ini | sed -n 's/^tty.*=[^1-9]*// p')
|
||||
|
||||
## The execution vars
|
||||
TTY="tty$DEFAULT_TTY"
|
||||
# If CONFTTY is empty then default to 2
|
||||
TTY="tty${CONFTTY:-2}"
|
||||
TERM=linux
|
||||
BAUD=38400
|
||||
# If we don't have getty then we should have agetty
|
||||
command=${commandB:-$commandUL}
|
||||
command_args_foreground="-nl $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME $TTY $BAUD $TERM"
|
||||
command_args_foreground="-nl /usr/bin/ly $TTY $BAUD $TERM"
|
||||
|
||||
depend() {
|
||||
after agetty
|
||||
|
||||
@@ -7,4 +7,6 @@ fi
|
||||
|
||||
BAUD_RATE=38400
|
||||
TERM_NAME=linux
|
||||
TTY=tty$DEFAULT_TTY
|
||||
|
||||
auxtty=$(/bin/cat /etc/ly/config.ini 2>/dev/null 1| /bin/sed -n 's/\(^[[:space:]]*tty[[:space:]]*=[[:space:]]*\)\([[:digit:]][[:digit:]]*\)\(.*\)/\2/p')
|
||||
TTY=tty${auxtty:-2}
|
||||
|
||||
@@ -10,4 +10,4 @@ elif [ -x /sbin/agetty -o -x /bin/agetty ]; then
|
||||
GETTY=agetty
|
||||
fi
|
||||
|
||||
exec setsid ${GETTY} ${GETTY_ARGS} -nl $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME "${TTY}" "${BAUD_RATE}" "${TERM_NAME}"
|
||||
exec setsid ${GETTY} ${GETTY_ARGS} -nl /usr/bin/ly "${TTY}" "${BAUD_RATE}" "${TERM_NAME}"
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
#!/bin/execlineb -P
|
||||
exec agetty -L -8 -n -l $PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME tty$DEFAULT_TTY 115200
|
||||
@@ -1 +0,0 @@
|
||||
longrun
|
||||
@@ -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
|
||||
@@ -1,12 +1,13 @@
|
||||
[Unit]
|
||||
Description=TUI display manager
|
||||
Description=TUI display manager (on %I)
|
||||
After=systemd-user-sessions.service plymouth-quit-wait.service
|
||||
After=getty@%I.service
|
||||
Conflicts=getty@%I.service
|
||||
|
||||
[Service]
|
||||
Type=idle
|
||||
ExecStart=$PREFIX_DIRECTORY/bin/$EXECUTABLE_NAME
|
||||
ExecStart=/usr/bin/ly
|
||||
StandardError=journal
|
||||
StandardInput=tty
|
||||
TTYPath=/dev/%I
|
||||
TTYReset=yes
|
||||
@@ -14,3 +15,4 @@ TTYVHangup=yes
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
# Alias=display-manager.service
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
#%PAM-1.0
|
||||
|
||||
# OpenPAM (used in FreeBSD) doesn't support prepending "-" for ignoring missing
|
||||
# modules.
|
||||
auth include login
|
||||
account include login
|
||||
password include login
|
||||
@@ -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
|
||||
@@ -1,16 +0,0 @@
|
||||
#%PAM-1.0
|
||||
|
||||
auth include login
|
||||
-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
|
||||
@@ -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
|
||||
107
res/setup.sh
107
res/setup.sh
@@ -1,107 +0,0 @@
|
||||
#!/bin/sh
|
||||
# Shell environment setup after login
|
||||
# Copyright (C) 2015-2016 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
|
||||
|
||||
# This file is extracted from kde-workspace (kdm/kfrontend/genkdmconf.c)
|
||||
# Copyright (C) 2001-2005 Oswald Buddenhagen <ossi@kde.org>
|
||||
|
||||
# Copyright (C) 2024 The Fairy Glade
|
||||
# This work is free. You can redistribute it and/or modify it under the
|
||||
# terms of the Do What The Fuck You Want To Public License, Version 2,
|
||||
# as published by Sam Hocevar. See the LICENSE file for more details.
|
||||
|
||||
# Note that the respective logout scripts are not sourced.
|
||||
case $SHELL in
|
||||
*/bash)
|
||||
[ -z "$BASH" ] && exec $SHELL "$0" "$@"
|
||||
set +o posix
|
||||
[ -f "$CONFIG_DIRECTORY"/profile ] && . "$CONFIG_DIRECTORY"/profile
|
||||
if [ -f "$HOME"/.bash_profile ]; then
|
||||
. "$HOME"/.bash_profile
|
||||
elif [ -f "$HOME"/.bash_login ]; then
|
||||
. "$HOME"/.bash_login
|
||||
elif [ -f "$HOME"/.profile ]; then
|
||||
. "$HOME"/.profile
|
||||
fi
|
||||
;;
|
||||
*/zsh)
|
||||
[ -z "$ZSH_NAME" ] && exec $SHELL "$0" "$@"
|
||||
[ -d "$CONFIG_DIRECTORY"/zsh ] && zdir="$CONFIG_DIRECTORY"/zsh || zdir="$CONFIG_DIRECTORY"
|
||||
zhome=${ZDOTDIR:-"$HOME"}
|
||||
# zshenv is always sourced automatically.
|
||||
[ -f "$zdir"/zprofile ] && . "$zdir"/zprofile
|
||||
[ -f "$zhome"/.zprofile ] && . "$zhome"/.zprofile
|
||||
[ -f "$zdir"/zlogin ] && . "$zdir"/zlogin
|
||||
[ -f "$zhome"/.zlogin ] && . "$zhome"/.zlogin
|
||||
emulate -R sh
|
||||
;;
|
||||
*/csh|*/tcsh)
|
||||
# [t]cshrc is always sourced automatically.
|
||||
# Note that sourcing csh.login after .cshrc is non-standard.
|
||||
sess_tmp=$(mktemp /tmp/sess-env-XXXXXX)
|
||||
$SHELL -c "if (-f $CONFIG_DIRECTORY/csh.login) source $CONFIG_DIRECTORY/csh.login; if (-f ~/.login) source ~/.login; /bin/sh -c 'export -p' >! $sess_tmp"
|
||||
. "$sess_tmp"
|
||||
rm -f "$sess_tmp"
|
||||
;;
|
||||
*/fish)
|
||||
[ -f "$CONFIG_DIRECTORY"/profile ] && . "$CONFIG_DIRECTORY"/profile
|
||||
[ -f "$HOME"/.profile ] && . "$HOME"/.profile
|
||||
sess_tmp=$(mktemp /tmp/sess-env-XXXXXX)
|
||||
$SHELL --login -c "/bin/sh -c 'export -p' > $sess_tmp"
|
||||
. "$sess_tmp"
|
||||
rm -f "$sess_tmp"
|
||||
;;
|
||||
*) # Plain sh, ksh, and anything we do not know.
|
||||
[ -f "$CONFIG_DIRECTORY"/profile ] && . "$CONFIG_DIRECTORY"/profile
|
||||
[ -f "$HOME"/.profile ] && . "$HOME"/.profile
|
||||
;;
|
||||
esac
|
||||
|
||||
if [ "$XDG_SESSION_TYPE" = "x11" ]; then
|
||||
[ -f "$CONFIG_DIRECTORY"/xprofile ] && . "$CONFIG_DIRECTORY"/xprofile
|
||||
[ -f "$HOME"/.xprofile ] && . "$HOME"/.xprofile
|
||||
|
||||
# run all system xinitrc shell scripts.
|
||||
if [ -d "$CONFIG_DIRECTORY"/X11/xinit/xinitrc.d ]; then
|
||||
for i in "$CONFIG_DIRECTORY"/X11/xinit/xinitrc.d/* ; do
|
||||
if [ -x "$i" ]; then
|
||||
. "$i"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# Load Xsession scripts
|
||||
# OPTIONFILE, USERXSESSION, USERXSESSIONRC and ALTUSERXSESSION are required
|
||||
# by the scripts to work
|
||||
xsessionddir="$CONFIG_DIRECTORY"/X11/Xsession.d
|
||||
export OPTIONFILE="$CONFIG_DIRECTORY"/X11/Xsession.options
|
||||
export USERXSESSION="$HOME"/.xsession
|
||||
export USERXSESSIONRC="$HOME"/.xsessionrc
|
||||
export ALTUSERXSESSION="$HOME"/.Xsession
|
||||
|
||||
if [ -d "$xsessionddir" ]; then
|
||||
for i in $(ls "$xsessionddir"); do
|
||||
script="$xsessionddir/$i"
|
||||
echo "Loading X session script $script"
|
||||
if [ -r "$script" ] && [ -f "$script" ] && expr "$i" : '^[[:alnum:]_-]\+$' > /dev/null; then
|
||||
. "$script"
|
||||
fi
|
||||
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"
|
||||
done
|
||||
elif [ -f "$CONFIG_DIRECTORY"/X11/Xresources ]; then
|
||||
xrdb -merge "$CONFIG_DIRECTORY"/X11/Xresources
|
||||
fi
|
||||
[ -f "$HOME"/.Xresources ] && xrdb -merge "$HOME"/.Xresources
|
||||
[ -f "$XDG_CONFIG_HOME"/X11/Xresources ] && xrdb -merge "$XDG_CONFIG_HOME"/X11/Xresources
|
||||
fi
|
||||
|
||||
exec "$@"
|
||||
31
res/valgrind.supp
Normal file
31
res/valgrind.supp
Normal file
@@ -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
|
||||
...
|
||||
}
|
||||
54
res/wsetup.sh
Executable file
54
res/wsetup.sh
Executable file
@@ -0,0 +1,54 @@
|
||||
#!/bin/sh
|
||||
# wayland-session - run as user
|
||||
# Copyright (C) 2015-2016 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
|
||||
|
||||
# This file is extracted from kde-workspace (kdm/kfrontend/genkdmconf.c)
|
||||
# Copyright (C) 2001-2005 Oswald Buddenhagen <ossi@kde.org>
|
||||
|
||||
# Note that the respective logout scripts are not sourced.
|
||||
case $SHELL in
|
||||
*/bash)
|
||||
[ -z "$BASH" ] && exec $SHELL $0 "$@"
|
||||
set +o posix
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
if [ -f $HOME/.bash_profile ]; then
|
||||
. $HOME/.bash_profile
|
||||
elif [ -f $HOME/.bash_login ]; then
|
||||
. $HOME/.bash_login
|
||||
elif [ -f $HOME/.profile ]; then
|
||||
. $HOME/.profile
|
||||
fi
|
||||
;;
|
||||
*/zsh)
|
||||
[ -z "$ZSH_NAME" ] && exec $SHELL $0 "$@"
|
||||
[ -d /etc/zsh ] && zdir=/etc/zsh || zdir=/etc
|
||||
zhome=${ZDOTDIR:-$HOME}
|
||||
# zshenv is always sourced automatically.
|
||||
[ -f $zdir/zprofile ] && . $zdir/zprofile
|
||||
[ -f $zhome/.zprofile ] && . $zhome/.zprofile
|
||||
[ -f $zdir/zlogin ] && . $zdir/zlogin
|
||||
[ -f $zhome/.zlogin ] && . $zhome/.zlogin
|
||||
emulate -R sh
|
||||
;;
|
||||
*/csh|*/tcsh)
|
||||
# [t]cshrc is always sourced automatically.
|
||||
# Note that sourcing csh.login after .cshrc is non-standard.
|
||||
wlsess_tmp=`mktemp /tmp/wlsess-env-XXXXXX`
|
||||
$SHELL -c "if (-f /etc/csh.login) source /etc/csh.login; if (-f ~/.login) source ~/.login; /bin/sh -c 'export -p' >! $wlsess_tmp"
|
||||
. $wlsess_tmp
|
||||
rm -f $wlsess_tmp
|
||||
;;
|
||||
*/fish)
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
xsess_tmp=`mktemp /tmp/xsess-env-XXXXXX`
|
||||
$SHELL --login -c "/bin/sh -c 'export -p' > $xsess_tmp"
|
||||
. $xsess_tmp
|
||||
rm -f $xsess_tmp
|
||||
;;
|
||||
*) # Plain sh, ksh, and anything we do not know.
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
[ -f $HOME/.profile ] && . $HOME/.profile
|
||||
;;
|
||||
esac
|
||||
|
||||
exec "$@"
|
||||
103
res/xsetup.sh
Executable file
103
res/xsetup.sh
Executable file
@@ -0,0 +1,103 @@
|
||||
#! /bin/sh
|
||||
# Xsession - run as user
|
||||
# Copyright (C) 2016 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
|
||||
|
||||
# This file is extracted from kde-workspace (kdm/kfrontend/genkdmconf.c)
|
||||
# Copyright (C) 2001-2005 Oswald Buddenhagen <ossi@kde.org>
|
||||
|
||||
# Note that the respective logout scripts are not sourced.
|
||||
case $SHELL in
|
||||
*/bash)
|
||||
[ -z "$BASH" ] && exec $SHELL $0 "$@"
|
||||
set +o posix
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
if [ -f $HOME/.bash_profile ]; then
|
||||
. $HOME/.bash_profile
|
||||
elif [ -f $HOME/.bash_login ]; then
|
||||
. $HOME/.bash_login
|
||||
elif [ -f $HOME/.profile ]; then
|
||||
. $HOME/.profile
|
||||
fi
|
||||
;;
|
||||
*/zsh)
|
||||
[ -z "$ZSH_NAME" ] && exec $SHELL $0 "$@"
|
||||
[ -d /etc/zsh ] && zdir=/etc/zsh || zdir=/etc
|
||||
zhome=${ZDOTDIR:-$HOME}
|
||||
# zshenv is always sourced automatically.
|
||||
[ -f $zdir/zprofile ] && . $zdir/zprofile
|
||||
[ -f $zhome/.zprofile ] && . $zhome/.zprofile
|
||||
[ -f $zdir/zlogin ] && . $zdir/zlogin
|
||||
[ -f $zhome/.zlogin ] && . $zhome/.zlogin
|
||||
emulate -R sh
|
||||
;;
|
||||
*/csh|*/tcsh)
|
||||
# [t]cshrc is always sourced automatically.
|
||||
# Note that sourcing csh.login after .cshrc is non-standard.
|
||||
xsess_tmp=`mktemp /tmp/xsess-env-XXXXXX`
|
||||
$SHELL -c "if (-f /etc/csh.login) source /etc/csh.login; if (-f ~/.login) source ~/.login; /bin/sh -c 'export -p' >! $xsess_tmp"
|
||||
. $xsess_tmp
|
||||
rm -f $xsess_tmp
|
||||
;;
|
||||
*/fish)
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
xsess_tmp=`mktemp /tmp/xsess-env-XXXXXX`
|
||||
$SHELL --login -c "/bin/sh -c 'export -p' > $xsess_tmp"
|
||||
. $xsess_tmp
|
||||
rm -f $xsess_tmp
|
||||
;;
|
||||
*) # Plain sh, ksh, and anything we do not know.
|
||||
[ -f /etc/profile ] && . /etc/profile
|
||||
[ -f $HOME/.profile ] && . $HOME/.profile
|
||||
;;
|
||||
esac
|
||||
|
||||
[ -f /etc/xprofile ] && . /etc/xprofile
|
||||
[ -f $HOME/.xprofile ] && . $HOME/.xprofile
|
||||
|
||||
# run all system xinitrc shell scripts.
|
||||
if [ -d /etc/X11/xinit/xinitrc.d ]; then
|
||||
for i in /etc/X11/xinit/xinitrc.d/* ; do
|
||||
if [ -x "$i" ]; then
|
||||
. "$i"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# Load Xsession scripts
|
||||
# OPTIONFILE, USERXSESSION, USERXSESSIONRC and ALTUSERXSESSION are required
|
||||
# by the scripts to work
|
||||
xsessionddir="/etc/X11/Xsession.d"
|
||||
OPTIONFILE=/etc/X11/Xsession.options
|
||||
USERXSESSION=$HOME/.xsession
|
||||
USERXSESSIONRC=$HOME/.xsessionrc
|
||||
ALTUSERXSESSION=$HOME/.Xsession
|
||||
|
||||
if [ -d "$xsessionddir" ]; then
|
||||
for i in `ls $xsessionddir`; do
|
||||
script="$xsessionddir/$i"
|
||||
echo "Loading X session script $script"
|
||||
if [ -r "$script" -a -f "$script" ] && expr "$i" : '^[[:alnum:]_-]\+$' > /dev/null; then
|
||||
. "$script"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
if [ -d /etc/X11/Xresources ]; then
|
||||
for i in /etc/X11/Xresources/*; do
|
||||
[ -f $i ] && xrdb -merge $i
|
||||
done
|
||||
elif [ -f /etc/X11/Xresources ]; then
|
||||
xrdb -merge /etc/X11/Xresources
|
||||
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
|
||||
|
||||
if [ -z "$*" ]; then
|
||||
exec xmessage -center -buttons OK:0 -default OK "Sorry, $DESKTOP_SESSION is no valid session."
|
||||
else
|
||||
exec $@
|
||||
fi
|
||||
@@ -1,24 +0,0 @@
|
||||
const enums = @import("enums.zig");
|
||||
const ini = @import("zigini");
|
||||
|
||||
const DisplayServer = enums.DisplayServer;
|
||||
const Ini = ini.Ini;
|
||||
|
||||
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,
|
||||
name: []const u8 = "",
|
||||
xdg_session_desktop: ?[]const u8 = null,
|
||||
xdg_session_desktop_owned: bool = false,
|
||||
xdg_desktop_names: ?[]const u8 = null,
|
||||
cmd: ?[]const u8 = null,
|
||||
specifier: []const u8 = "",
|
||||
display_server: DisplayServer = .wayland,
|
||||
is_terminal: bool = false,
|
||||
@@ -1,51 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const LogFile = @This();
|
||||
|
||||
path: []const u8,
|
||||
could_open_log_file: bool = undefined,
|
||||
file: std.fs.File = undefined,
|
||||
buffer: []u8,
|
||||
file_writer: std.fs.File.Writer = undefined,
|
||||
|
||||
pub fn init(path: []const u8, buffer: []u8) !LogFile {
|
||||
var log_file = LogFile{ .path = path, .buffer = buffer };
|
||||
log_file.could_open_log_file = try openLogFile(path, &log_file);
|
||||
return log_file;
|
||||
}
|
||||
|
||||
pub fn reinit(self: *LogFile) !void {
|
||||
self.could_open_log_file = try openLogFile(self.path, self);
|
||||
}
|
||||
|
||||
pub fn deinit(self: *LogFile) void {
|
||||
self.file_writer.interface.flush() catch {};
|
||||
self.file.close();
|
||||
}
|
||||
|
||||
fn openLogFile(path: []const u8, log_file: *LogFile) !bool {
|
||||
var could_open_log_file = true;
|
||||
open_log_file: {
|
||||
log_file.file = std.fs.cwd().openFile(path, .{ .mode = .write_only }) catch std.fs.cwd().createFile(path, .{ .mode = 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.fs.openFileAbsolute("/dev/null", .{ .mode = .write_only });
|
||||
}
|
||||
|
||||
var log_file_writer = log_file.file.writer(log_file.buffer);
|
||||
|
||||
// Seek to the end of the log file
|
||||
if (could_open_log_file) {
|
||||
const stat = try log_file.file.stat();
|
||||
try log_file_writer.seekTo(stat.size);
|
||||
}
|
||||
|
||||
log_file.file_writer = log_file_writer;
|
||||
return could_open_log_file;
|
||||
}
|
||||
@@ -9,7 +9,7 @@ const ErrorHandler = packed struct {
|
||||
|
||||
const SharedError = @This();
|
||||
|
||||
data: []align(std.heap.page_size_min) u8,
|
||||
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);
|
||||
|
||||
@@ -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,
|
||||
@@ -1,86 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
const Cell = @import("../tui/Cell.zig");
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
|
||||
const ColorMix = @This();
|
||||
|
||||
const math = std.math;
|
||||
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]);
|
||||
}
|
||||
|
||||
terminal_buffer: *TerminalBuffer,
|
||||
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) ColorMix {
|
||||
return .{
|
||||
.terminal_buffer = terminal_buffer,
|
||||
.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 animation(self: *ColorMix) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(_: *ColorMix) void {}
|
||||
|
||||
fn realloc(_: *ColorMix) anyerror!void {}
|
||||
|
||||
fn draw(self: *ColorMix) void {
|
||||
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, @intFromFloat(math.floor(length(uv) * 5.0))) % palette_len];
|
||||
cell.put(x, y);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,110 +1,84 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
const Cell = @import("../tui/Cell.zig");
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
const utils = @import("../tui/utils.zig");
|
||||
|
||||
const interop = @import("../interop.zig");
|
||||
const termbox = interop.termbox;
|
||||
|
||||
const Doom = @This();
|
||||
|
||||
pub const STEPS = 12;
|
||||
pub const HEIGHT_MAX = 9;
|
||||
pub const SPREAD_MAX = 4;
|
||||
pub const STEPS = 13;
|
||||
pub const FIRE = [_]termbox.tb_cell{
|
||||
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
|
||||
};
|
||||
|
||||
allocator: Allocator,
|
||||
terminal_buffer: *TerminalBuffer,
|
||||
buffer: []u8,
|
||||
height: u8,
|
||||
spread: u8,
|
||||
fire: [STEPS + 1]Cell,
|
||||
|
||||
pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer, top_color: u32, middle_color: u32, bottom_color: u32, fire_height: u8, fire_spread: u8) !Doom {
|
||||
pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer) !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 .{
|
||||
.allocator = allocator,
|
||||
.terminal_buffer = terminal_buffer,
|
||||
.buffer = buffer,
|
||||
.height = @min(HEIGHT_MAX, fire_height),
|
||||
.spread = @min(SPREAD_MAX, fire_spread),
|
||||
.fire = levels,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn animation(self: *Doom) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(self: *Doom) void {
|
||||
pub fn deinit(self: Doom) void {
|
||||
self.allocator.free(self.buffer);
|
||||
}
|
||||
|
||||
fn realloc(self: *Doom) anyerror!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 {
|
||||
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 from = y * self.terminal_buffer.width + x;
|
||||
const source = y * self.terminal_buffer.width + x;
|
||||
const random = (self.terminal_buffer.random.int(u16) % 7) & 3;
|
||||
|
||||
// Generate random data for fire propagation
|
||||
const rand_loss = self.terminal_buffer.random.intRangeAtMost(u8, 0, HEIGHT_MAX);
|
||||
const rand_spread = self.terminal_buffer.random.intRangeAtMost(u8, 0, self.spread * 2);
|
||||
var dest = source - random + 1;
|
||||
if (self.terminal_buffer.width > dest) dest = 0 else dest -= self.terminal_buffer.width;
|
||||
|
||||
// Select semi-random target cell
|
||||
const to = from -| self.terminal_buffer.width + self.spread -| rand_spread;
|
||||
const to_x = to % self.terminal_buffer.width;
|
||||
const to_y = to / self.terminal_buffer.width;
|
||||
const buffer_source = self.buffer[source];
|
||||
const buffer_dest_offset = random & 1;
|
||||
|
||||
// Get fire level of current cell
|
||||
const level_buf_from = self.buffer[from];
|
||||
if (buffer_source < buffer_dest_offset) continue;
|
||||
|
||||
// Choose new fire level and store in level buffer
|
||||
const level_buf_to = level_buf_from -| @intFromBool(rand_loss >= self.height);
|
||||
self.buffer[to] = level_buf_to;
|
||||
var buffer_dest = buffer_source - buffer_dest_offset;
|
||||
if (buffer_dest > 12) buffer_dest = 0;
|
||||
self.buffer[dest] = @intCast(buffer_dest);
|
||||
|
||||
// Send known fire levels to terminal buffer
|
||||
const from_cell = self.fire[level_buf_from];
|
||||
const to_cell = self.fire[level_buf_to];
|
||||
from_cell.put(x, y);
|
||||
to_cell.put(to_x, to_y);
|
||||
self.terminal_buffer.buffer[dest] = FIRE[buffer_dest];
|
||||
self.terminal_buffer.buffer[source] = FIRE[buffer_source];
|
||||
}
|
||||
|
||||
// Draw bottom line (fire source)
|
||||
const src_cell = self.fire[STEPS];
|
||||
src_cell.put(x, self.terminal_buffer.height - 1);
|
||||
}
|
||||
}
|
||||
|
||||
fn initBuffer(buffer: []u8, width: usize) void {
|
||||
fn initBuffer(buffer: []u8, width: u64) void {
|
||||
const length = buffer.len - width;
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
|
||||
const Dummy = @This();
|
||||
|
||||
pub fn animation(self: *Dummy) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(_: *Dummy) void {}
|
||||
|
||||
fn realloc(_: *Dummy) anyerror!void {}
|
||||
|
||||
fn draw(_: *Dummy) void {}
|
||||
@@ -1,408 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
const Cell = @import("../tui/Cell.zig");
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
const Color = TerminalBuffer.Color;
|
||||
const Styling = TerminalBuffer.Styling;
|
||||
const Allocator = std.mem.Allocator;
|
||||
const Json = std.json;
|
||||
const eql = std.mem.eql;
|
||||
const flate = std.compress.flate;
|
||||
|
||||
fn read_decompress_file(allocator: Allocator, file_path: []const u8) ![]u8 {
|
||||
const file_buffer = std.fs.cwd().openFile(file_path, .{}) catch {
|
||||
return error.FileNotFound;
|
||||
};
|
||||
defer file_buffer.close();
|
||||
|
||||
var file_reader_buffer: [4096]u8 = undefined;
|
||||
var decompress_buffer: [flate.max_window_len]u8 = undefined;
|
||||
|
||||
var file_reader = file_buffer.reader(&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, file_path: []const u8) !void {
|
||||
const file_decompressed = try read_decompress_file(allocator, 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 DurFile = @This();
|
||||
|
||||
allocator: Allocator,
|
||||
terminal_buffer: *TerminalBuffer,
|
||||
frames: u64,
|
||||
time_previous: i64,
|
||||
x_offset: u32,
|
||||
y_offset: u32,
|
||||
full_color: bool,
|
||||
dur_movie: DurFormat,
|
||||
frame_width: u32,
|
||||
frame_height: u32,
|
||||
frame_time: u32,
|
||||
is_color_format_16: bool,
|
||||
|
||||
pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer, log_writer: *std.io.Writer, file_path: []const u8, x_offset: u32, y_offset: u32, full_color: bool) !DurFile {
|
||||
var dur_movie: DurFormat = .init(allocator);
|
||||
|
||||
// error state is recoverable when thrown to main and results in no background with Dummy in main
|
||||
dur_movie.create_from_file(allocator, file_path) catch |err| switch (err) {
|
||||
error.FileNotFound => {
|
||||
try log_writer.print("error: dur_file was not found at: {s}\n", .{file_path});
|
||||
return err;
|
||||
},
|
||||
error.NotValidFile => {
|
||||
try log_writer.print("error: dur_file loaded was invalid or not a dur file!\n", .{});
|
||||
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_writer.print("error: dur_file can not be 256 color encoded when not using full_color option!\n", .{});
|
||||
dur_movie.deinit();
|
||||
return error.InvalidColorFormat;
|
||||
}
|
||||
|
||||
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.?);
|
||||
|
||||
// Clamp to prevent user from exceeding draw window
|
||||
const x_offset_clamped = std.math.clamp(x_offset, 0, buf_width - 1);
|
||||
const y_offset_clamped = std.math.clamp(y_offset, 0, buf_height - 1);
|
||||
|
||||
// Ensure if user offsets and frame goes offscreen, it will not overflow draw
|
||||
const frame_width = if ((movie_width + x_offset_clamped) < buf_width) movie_width else buf_width - x_offset_clamped;
|
||||
const frame_height = if ((movie_height + y_offset_clamped) < buf_height) movie_height else buf_height - y_offset_clamped;
|
||||
|
||||
// Convert dur fps to frames per ms
|
||||
const frame_time: u32 = @intFromFloat(1000 / dur_movie.framerate.?);
|
||||
|
||||
return .{
|
||||
.allocator = allocator,
|
||||
.terminal_buffer = terminal_buffer,
|
||||
.frames = 0,
|
||||
.time_previous = std.time.milliTimestamp(),
|
||||
.x_offset = x_offset_clamped,
|
||||
.y_offset = y_offset_clamped,
|
||||
.full_color = full_color,
|
||||
.dur_movie = dur_movie,
|
||||
.frame_width = frame_width,
|
||||
.frame_height = frame_height,
|
||||
.frame_time = frame_time,
|
||||
.is_color_format_16 = eql(u8, dur_movie.colorFormat.?, "16"),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn animation(self: *DurFile) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(self: *DurFile) void {
|
||||
self.dur_movie.deinit();
|
||||
}
|
||||
|
||||
fn realloc(_: *DurFile) anyerror!void {}
|
||||
|
||||
fn draw(self: *DurFile) void {
|
||||
const current_frame = self.dur_movie.frames.items[self.frames];
|
||||
|
||||
for (0..self.frame_height) |y| {
|
||||
var iter = std.unicode.Utf8View.initUnchecked(current_frame.contents[y]).iterator();
|
||||
|
||||
for (0..self.frame_width) |x| {
|
||||
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(x + self.x_offset, y + self.y_offset);
|
||||
}
|
||||
}
|
||||
|
||||
const time_current = std.time.milliTimestamp();
|
||||
const delta_time = time_current - self.time_previous;
|
||||
|
||||
// Convert delay from sec to ms
|
||||
const delay_time: u32 = @intFromFloat(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;
|
||||
}
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
const Cell = @import("../tui/Cell.zig");
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
|
||||
const Allocator = std.mem.Allocator;
|
||||
|
||||
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 },
|
||||
};
|
||||
|
||||
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,
|
||||
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) !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{
|
||||
.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,
|
||||
.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 animation(self: *GameOfLife) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(self: *GameOfLife) void {
|
||||
self.allocator.free(self.current_grid);
|
||||
self.allocator.free(self.next_grid);
|
||||
}
|
||||
|
||||
fn realloc(self: *GameOfLife) anyerror!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 {
|
||||
// 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 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,12 +1,16 @@
|
||||
const std = @import("std");
|
||||
const Animation = @import("../tui/Animation.zig");
|
||||
const Cell = @import("../tui/Cell.zig");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const Random = std.rand.Random;
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
|
||||
const Allocator = std.mem.Allocator;
|
||||
const Random = std.Random;
|
||||
const interop = @import("../interop.zig");
|
||||
const termbox = interop.termbox;
|
||||
|
||||
pub const FRAME_DELAY: usize = 8;
|
||||
pub const FRAME_DELAY: u64 = 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;
|
||||
@@ -14,29 +18,24 @@ 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,
|
||||
length: usize,
|
||||
update: usize,
|
||||
space: isize,
|
||||
length: isize,
|
||||
update: isize,
|
||||
};
|
||||
|
||||
allocator: Allocator,
|
||||
terminal_buffer: *TerminalBuffer,
|
||||
dots: []Dot,
|
||||
lines: []Line,
|
||||
frame: usize,
|
||||
count: usize,
|
||||
fg: u32,
|
||||
head_col: u32,
|
||||
min_codepoint: u16,
|
||||
max_codepoint: u16,
|
||||
default_cell: Cell,
|
||||
frame: u64,
|
||||
count: u64,
|
||||
|
||||
pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer, fg: u32, head_col: u32, min_codepoint: u16, max_codepoint: u16) !Matrix {
|
||||
pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer) !Matrix {
|
||||
const dots = try allocator.alloc(Dot, terminal_buffer.width * (terminal_buffer.height + 1));
|
||||
const lines = try allocator.alloc(Line, terminal_buffer.width);
|
||||
|
||||
@@ -49,24 +48,15 @@ pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer, fg: u32, hea
|
||||
.lines = lines,
|
||||
.frame = 3,
|
||||
.count = 0,
|
||||
.fg = fg,
|
||||
.head_col = head_col,
|
||||
.min_codepoint = min_codepoint,
|
||||
.max_codepoint = max_codepoint - min_codepoint,
|
||||
.default_cell = .{ .ch = ' ', .fg = fg, .bg = terminal_buffer.bg },
|
||||
};
|
||||
}
|
||||
|
||||
pub fn animation(self: *Matrix) Animation {
|
||||
return Animation.init(self, deinit, realloc, draw);
|
||||
}
|
||||
|
||||
fn deinit(self: *Matrix) void {
|
||||
pub fn deinit(self: Matrix) void {
|
||||
self.allocator.free(self.dots);
|
||||
self.allocator.free(self.lines);
|
||||
}
|
||||
|
||||
fn realloc(self: *Matrix) anyerror!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);
|
||||
|
||||
@@ -76,7 +66,7 @@ fn realloc(self: *Matrix) anyerror!void {
|
||||
self.lines = lines;
|
||||
}
|
||||
|
||||
fn draw(self: *Matrix) void {
|
||||
pub fn draw(self: *Matrix) void {
|
||||
const buf_height = self.terminal_buffer.height;
|
||||
const buf_width = self.terminal_buffer.width;
|
||||
self.count += 1;
|
||||
@@ -85,31 +75,31 @@ fn draw(self: *Matrix) void {
|
||||
if (self.frame > 4) self.frame = 1;
|
||||
self.count = 0;
|
||||
|
||||
var x: usize = 0;
|
||||
var x: u64 = 0;
|
||||
while (x < self.terminal_buffer.width) : (x += 2) {
|
||||
var tail: usize = 0;
|
||||
var tail: u64 = 0;
|
||||
var line = &self.lines[x];
|
||||
if (self.frame <= line.update) continue;
|
||||
|
||||
if (self.dots[x].value == null and self.dots[self.terminal_buffer.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 h = self.terminal_buffer.height;
|
||||
const randint = self.terminal_buffer.random.int(i16);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
var y: usize = 0;
|
||||
var y: u64 = 0;
|
||||
var first_col = true;
|
||||
var seg_len: u64 = 0;
|
||||
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];
|
||||
@@ -118,12 +108,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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -137,52 +127,53 @@ fn draw(self: *Matrix) void {
|
||||
dot = &self.dots[buf_width * y + x];
|
||||
}
|
||||
|
||||
const randint = self.terminal_buffer.random.int(u16);
|
||||
dot.value = @mod(randint, self.max_codepoint) + self.min_codepoint;
|
||||
const randint = self.terminal_buffer.random.int(i16);
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var x: usize = 0;
|
||||
var x: u64 = 0;
|
||||
while (x < buf_width) : (x += 2) {
|
||||
var y: usize = 1;
|
||||
var y: u64 = 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,
|
||||
};
|
||||
var fg: u32 = @intCast(termbox.TB_GREEN);
|
||||
|
||||
cell.put(x, y - 1);
|
||||
// Fill background in between columns
|
||||
self.default_cell.put(x + 1, y - 1);
|
||||
if (dot.value == -1 or dot.value == ' ') {
|
||||
termbox.tb_change_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_change_cell(@intCast(x), @intCast(y - 1), @intCast(dot.value), fg, termbox.TB_DEFAULT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn initBuffers(dots: []Dot, lines: []Line, width: usize, height: usize, random: Random) void {
|
||||
var y: usize = 0;
|
||||
fn initBuffers(dots: []Dot, lines: []Line, width: u64, height: u64, random: Random) void {
|
||||
var y: u64 = 0;
|
||||
while (y <= height) : (y += 1) {
|
||||
var x: usize = 0;
|
||||
var x: u64 = 0;
|
||||
while (x < width) : (x += 2) {
|
||||
dots[y * width + x].value = null;
|
||||
dots[y * width + x].value = -1;
|
||||
}
|
||||
}
|
||||
|
||||
var x: usize = 0;
|
||||
var x: u64 = 0;
|
||||
while (x < width) : (x += 2) {
|
||||
var line = lines[x];
|
||||
line.space = @mod(random.int(u16), height) + 1;
|
||||
line.length = @mod(random.int(u16), height - 3) + 3;
|
||||
line.update = @mod(random.int(u16), 3) + 1;
|
||||
const h: isize = @intCast(height);
|
||||
line.space = @mod(random.int(i16), h) + 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 = ' ';
|
||||
|
||||
475
src/auth.zig
475
src/auth.zig
@@ -1,56 +1,36 @@
|
||||
const std = @import("std");
|
||||
const build_options = @import("build_options");
|
||||
const builtin = @import("builtin");
|
||||
const enums = @import("enums.zig");
|
||||
const Environment = @import("Environment.zig");
|
||||
const interop = @import("interop.zig");
|
||||
const SharedError = @import("SharedError.zig");
|
||||
const LogFile = @import("LogFile.zig");
|
||||
|
||||
const Md5 = std.crypto.hash.Md5;
|
||||
const TerminalBuffer = @import("tui/TerminalBuffer.zig");
|
||||
const Desktop = @import("tui/components/Desktop.zig");
|
||||
const Text = @import("tui/components/Text.zig");
|
||||
const Config = @import("config/Config.zig");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const utmp = interop.utmp;
|
||||
const Utmp = utmp.utmpx;
|
||||
|
||||
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,
|
||||
session_pid: std.posix.pid_t,
|
||||
};
|
||||
const Utmp = utmp.utmp;
|
||||
const SharedError = @import("SharedError.zig");
|
||||
|
||||
var xorg_pid: std.posix.pid_t = 0;
|
||||
pub fn xorgSignalHandler(i: c_int) callconv(.c) void {
|
||||
pub fn xorgSignalHandler(i: c_int) callconv(.C) void {
|
||||
if (xorg_pid > 0) _ = std.c.kill(xorg_pid, i);
|
||||
}
|
||||
|
||||
var child_pid: std.posix.pid_t = 0;
|
||||
pub fn sessionSignalHandler(i: c_int) callconv(.c) void {
|
||||
pub fn sessionSignalHandler(i: c_int) callconv(.C) void {
|
||||
if (child_pid > 0) _ = std.c.kill(child_pid, i);
|
||||
}
|
||||
|
||||
pub fn authenticate(allocator: std.mem.Allocator, log_file: *LogFile, options: AuthOptions, current_environment: Environment, login: []const u8, password: []const u8) !void {
|
||||
var tty_buffer: [3]u8 = undefined;
|
||||
const tty_str = try std.fmt.bufPrint(&tty_buffer, "{d}", .{options.tty});
|
||||
|
||||
var pam_tty_buffer: [6]u8 = undefined;
|
||||
const pam_tty_str = try std.fmt.bufPrintZ(&pam_tty_buffer, "tty{d}", .{options.tty});
|
||||
pub fn authenticate(config: Config, desktop: Desktop, login: [:0]const u8, password: [:0]const u8) !void {
|
||||
var tty_buffer: [2]u8 = undefined;
|
||||
const tty_str = try std.fmt.bufPrintZ(&tty_buffer, "{d}", .{config.tty});
|
||||
const current_environment = desktop.environments.items[desktop.current];
|
||||
|
||||
// Set the XDG environment variables
|
||||
try setXdgEnv(allocator, tty_str, current_environment);
|
||||
setXdgSessionEnv(current_environment.display_server);
|
||||
try setXdgEnv(tty_str, current_environment.xdg_session_desktop, current_environment.xdg_desktop_names orelse "");
|
||||
|
||||
// Open the PAM session
|
||||
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 };
|
||||
var credentials = [_:null]?[*:0]const u8{ login, password };
|
||||
|
||||
const conv = interop.pam.pam_conv{
|
||||
.conv = loginConv,
|
||||
@@ -58,183 +38,159 @@ pub fn authenticate(allocator: std.mem.Allocator, log_file: *LogFile, options: A
|
||||
};
|
||||
var handle: ?*interop.pam.pam_handle = undefined;
|
||||
|
||||
var log_writer = &log_file.file_writer.interface;
|
||||
|
||||
try log_writer.writeAll("[pam] starting session\n");
|
||||
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_writer.writeAll("[pam] setting tty\n");
|
||||
status = interop.pam.pam_set_item(handle, interop.pam.PAM_TTY, pam_tty_str.ptr);
|
||||
var status = interop.pam.pam_start(config.service_name.ptr, null, &conv, &handle);
|
||||
if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
|
||||
|
||||
// Do the PAM routine
|
||||
try log_writer.writeAll("[pam] authenticating\n");
|
||||
status = interop.pam.pam_authenticate(handle, 0);
|
||||
if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
|
||||
|
||||
try log_writer.writeAll("[pam] validating account\n");
|
||||
status = interop.pam.pam_acct_mgmt(handle, 0);
|
||||
if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
|
||||
|
||||
try log_writer.writeAll("[pam] setting credentials\n");
|
||||
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_writer.writeAll("[pam] opening session\n");
|
||||
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);
|
||||
|
||||
var user_entry: interop.UsernameEntry = undefined;
|
||||
var pwd: *interop.passwd = undefined;
|
||||
{
|
||||
defer interop.closePasswordDatabase();
|
||||
defer interop.endpwent();
|
||||
|
||||
// Get password structure from username
|
||||
user_entry = interop.getUsernameEntry(login_z) orelse return error.GetPasswordNameFailed;
|
||||
pwd = interop.getpwnam(login.ptr) orelse return error.GetPasswordNameFailed;
|
||||
}
|
||||
|
||||
// Set user shell if it hasn't already been set
|
||||
if (user_entry.shell == null) interop.setUserShell(&user_entry);
|
||||
if (pwd.pw_shell[0] == 0) {
|
||||
interop.setusershell();
|
||||
pwd.pw_shell = interop.getusershell();
|
||||
interop.endusershell();
|
||||
}
|
||||
|
||||
var shared_err = try SharedError.init();
|
||||
defer shared_err.deinit();
|
||||
|
||||
log_file.deinit();
|
||||
|
||||
child_pid = try std.posix.fork();
|
||||
if (child_pid == 0) {
|
||||
try log_file.reinit();
|
||||
log_writer = &log_file.file_writer.interface;
|
||||
|
||||
try log_writer.writeAll("starting session\n");
|
||||
|
||||
startSession(log_file, allocator, options, tty_str, user_entry, handle, current_environment) catch |e| {
|
||||
startSession(config, pwd, handle, current_environment) catch |e| {
|
||||
shared_err.writeError(e);
|
||||
|
||||
log_file.deinit();
|
||||
std.process.exit(1);
|
||||
};
|
||||
|
||||
log_file.deinit();
|
||||
std.process.exit(0);
|
||||
}
|
||||
|
||||
var entry = std.mem.zeroes(Utmp);
|
||||
|
||||
{
|
||||
// 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.waitpid(child_pid, 0);
|
||||
}
|
||||
var entry: Utmp = std.mem.zeroes(Utmp);
|
||||
addUtmpEntry(&entry, pwd.pw_name, child_pid) catch {};
|
||||
|
||||
// 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(&entry, user_entry.username.?, child_pid);
|
||||
}
|
||||
// Wait for the session to stop
|
||||
_ = std.posix.waitpid(child_pid, 0);
|
||||
|
||||
try log_file.reinit();
|
||||
|
||||
removeUtmpEntry(&entry);
|
||||
|
||||
try resetTerminal(pwd.pw_shell, config.term_reset_cmd);
|
||||
|
||||
// Close the PAM session
|
||||
status = interop.pam.pam_close_session(handle, 0);
|
||||
if (status != 0) return pamDiagnose(status);
|
||||
|
||||
status = interop.pam.pam_setcred(handle, interop.pam.PAM_DELETE_CRED);
|
||||
if (status != 0) return pamDiagnose(status);
|
||||
|
||||
status = interop.pam.pam_end(handle, status);
|
||||
if (status != 0) return pamDiagnose(status);
|
||||
|
||||
if (shared_err.readError()) |err| return err;
|
||||
}
|
||||
|
||||
fn startSession(
|
||||
log_file: *LogFile,
|
||||
allocator: std.mem.Allocator,
|
||||
options: AuthOptions,
|
||||
tty_str: []u8,
|
||||
user_entry: interop.UsernameEntry,
|
||||
config: Config,
|
||||
pwd: *interop.passwd,
|
||||
handle: ?*interop.pam.pam_handle,
|
||||
current_environment: Environment,
|
||||
current_environment: Desktop.Environment,
|
||||
) !void {
|
||||
// Set the user's GID & PID
|
||||
try interop.setUserContext(allocator, user_entry);
|
||||
var status: c_int = 0;
|
||||
status = interop.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 initEnv(allocator, user_entry, options.path);
|
||||
|
||||
// Reset the XDG environment variables
|
||||
try setXdgEnv(allocator, tty_str, current_environment);
|
||||
try initEnv(pwd, config.path);
|
||||
|
||||
// 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 pam_env_vars = interop.pam.pam_getenvlist(handle);
|
||||
|
||||
const env_list = std.mem.span(pam_env_vars.?);
|
||||
for (env_list) |env_var| try interop.putEnvironmentVariable(env_var);
|
||||
var index: usize = 0;
|
||||
while (true) : (index += 1) {
|
||||
const pam_env_var = pam_env_vars[index];
|
||||
if (pam_env_var == null) break;
|
||||
|
||||
// Change to the user's home directory
|
||||
std.posix.chdir(user_entry.home.?) catch return error.ChangeDirectoryFailed;
|
||||
|
||||
// Signal to the session process to give up control on the TTY
|
||||
std.posix.kill(options.session_pid, std.posix.SIG.CHLD) catch return error.TtyControlTransferFailed;
|
||||
_ = interop.putenv(pam_env_var);
|
||||
}
|
||||
|
||||
// Execute what the user requested
|
||||
std.posix.chdirZ(pwd.pw_dir) catch return error.ChangeDirectoryFailed;
|
||||
|
||||
try resetTerminal(pwd.pw_shell, config.term_reset_cmd);
|
||||
|
||||
switch (current_environment.display_server) {
|
||||
.wayland, .shell, .custom => try executeCmd(log_file, allocator, user_entry.shell.?, options, current_environment.is_terminal, current_environment.cmd),
|
||||
.xinitrc, .x11 => if (build_options.enable_x11_support) {
|
||||
.wayland => try executeWaylandCmd(pwd.pw_shell, config.wayland_cmd, current_environment.cmd),
|
||||
.shell => try executeShellCmd(pwd.pw_shell),
|
||||
.xinitrc, .x11 => {
|
||||
var vt_buf: [5]u8 = undefined;
|
||||
const vt = try std.fmt.bufPrint(&vt_buf, "vt{d}", .{options.tty});
|
||||
try executeX11Cmd(log_file, allocator, user_entry.shell.?, user_entry.home.?, options, current_environment.cmd orelse "", vt);
|
||||
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);
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn initEnv(allocator: std.mem.Allocator, entry: interop.UsernameEntry, path_env: ?[]const u8) !void {
|
||||
if (entry.home) |home| {
|
||||
try interop.setEnvironmentVariable(allocator, "HOME", home, true);
|
||||
try interop.setEnvironmentVariable(allocator, "PWD", home, true);
|
||||
} else return error.NoHomeDirectory;
|
||||
fn initEnv(pwd: *interop.passwd, path_env: ?[:0]const u8) !void {
|
||||
const term_env = std.posix.getenv("TERM");
|
||||
|
||||
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 (term_env) |term| _ = interop.setenv("TERM", term, 1);
|
||||
_ = interop.setenv("HOME", pwd.pw_dir, 1);
|
||||
_ = interop.setenv("PWD", pwd.pw_dir, 1);
|
||||
_ = interop.setenv("SHELL", pwd.pw_shell, 1);
|
||||
_ = interop.setenv("USER", pwd.pw_name, 1);
|
||||
_ = interop.setenv("LOGNAME", pwd.pw_name, 1);
|
||||
|
||||
if (path_env) |path| {
|
||||
interop.setEnvironmentVariable(allocator, "PATH", path, true) catch return error.SetPathFailed;
|
||||
const status = interop.setenv("PATH", path, 1);
|
||||
if (status != 0) return error.SetPathFailed;
|
||||
}
|
||||
}
|
||||
|
||||
fn setXdgEnv(allocator: std.mem.Allocator, tty_str: []u8, environment: Environment) !void {
|
||||
try interop.setEnvironmentVariable(allocator, "XDG_SESSION_TYPE", switch (environment.display_server) {
|
||||
fn setXdgSessionEnv(display_server: enums.DisplayServer) void {
|
||||
_ = interop.setenv("XDG_SESSION_TYPE", switch (display_server) {
|
||||
.wayland => "wayland",
|
||||
.shell => "tty",
|
||||
.xinitrc, .x11 => "x11",
|
||||
.custom => if (environment.is_terminal) "tty" else "unspecified",
|
||||
}, false);
|
||||
|
||||
// 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.getuid();
|
||||
var uid_buffer: [32]u8 = undefined; // No UID can be larger than this
|
||||
const uid_str = try std.fmt.bufPrint(&uid_buffer, "/run/user/{d}", .{uid});
|
||||
|
||||
try interop.setEnvironmentVariable(allocator, "XDG_RUNTIME_DIR", uid_str, false);
|
||||
}, 0);
|
||||
}
|
||||
|
||||
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 setXdgEnv(tty_str: [:0]u8, desktop_name: [:0]const u8, xdg_desktop_names: [:0]const u8) !void {
|
||||
const uid = interop.getuid();
|
||||
var uid_buffer: [10 + @sizeOf(u32) + 1]u8 = undefined;
|
||||
const uid_str = try std.fmt.bufPrintZ(&uid_buffer, "/run/user/{d}", .{uid});
|
||||
|
||||
_ = interop.setenv("XDG_CURRENT_DESKTOP", xdg_desktop_names.ptr, 0);
|
||||
_ = interop.setenv("XDG_RUNTIME_DIR", uid_str.ptr, 0);
|
||||
_ = interop.setenv("XDG_SESSION_CLASS", "user", 0);
|
||||
_ = interop.setenv("XDG_SESSION_ID", "1", 0);
|
||||
_ = interop.setenv("XDG_SESSION_DESKTOP", desktop_name.ptr, 0);
|
||||
_ = interop.setenv("XDG_SEAT", "seat0", 0);
|
||||
_ = interop.setenv("XDG_VTNR", tty_str.ptr, 0);
|
||||
}
|
||||
|
||||
fn loginConv(
|
||||
@@ -242,7 +198,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.?;
|
||||
|
||||
@@ -251,7 +207,7 @@ fn loginConv(
|
||||
|
||||
// Initialise allocated memory to 0
|
||||
// This ensures memory can be freed by pam on success
|
||||
@memset(response, std.mem.zeroes(interop.pam.pam_response));
|
||||
for (response) |*r| r.* = std.mem.zeroes(interop.pam.pam_response);
|
||||
|
||||
var username: ?[:0]u8 = null;
|
||||
var password: ?[:0]u8 = null;
|
||||
@@ -265,7 +221,7 @@ fn loginConv(
|
||||
status = interop.pam.PAM_BUF_ERR;
|
||||
break :set_credentials;
|
||||
};
|
||||
response[i].resp = username.?;
|
||||
response[i].resp = username.?.ptr;
|
||||
},
|
||||
interop.pam.PAM_PROMPT_ECHO_OFF => {
|
||||
const data: [*][*:0]u8 = @ptrCast(@alignCast(appdata_ptr));
|
||||
@@ -273,7 +229,7 @@ fn loginConv(
|
||||
status = interop.pam.PAM_BUF_ERR;
|
||||
break :set_credentials;
|
||||
};
|
||||
response[i].resp = password.?;
|
||||
response[i].resp = password.?.ptr;
|
||||
},
|
||||
interop.pam.PAM_ERROR_MSG => {
|
||||
status = interop.pam.PAM_CONV_ERR;
|
||||
@@ -286,8 +242,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 (password) |str| allocator.free(str);
|
||||
if (username != null) allocator.free(username.?);
|
||||
if (password != null) allocator.free(password.?);
|
||||
} else {
|
||||
resp.?.* = response.ptr;
|
||||
}
|
||||
@@ -295,6 +251,17 @@ fn loginConv(
|
||||
return status;
|
||||
}
|
||||
|
||||
fn resetTerminal(shell: [*:0]const u8, term_reset_cmd: [:0]const u8) !void {
|
||||
const pid = try std.posix.fork();
|
||||
if (pid == 0) {
|
||||
const args = [_:null]?[*:0]const u8{ shell, "-c", term_reset_cmd };
|
||||
std.posix.execveZ(shell, &args, std.c.environ) catch {};
|
||||
std.process.exit(1);
|
||||
}
|
||||
|
||||
_ = std.posix.waitpid(pid, 0);
|
||||
}
|
||||
|
||||
fn getFreeDisplay() !u8 {
|
||||
var buf: [15]u8 = undefined;
|
||||
var i: u8 = 0;
|
||||
@@ -311,50 +278,46 @@ fn getXPid(display_num: u8) !i32 {
|
||||
const file = try std.fs.openFileAbsolute(file_name, .{});
|
||||
defer file.close();
|
||||
|
||||
var file_buffer: [32]u8 = undefined;
|
||||
var file_reader = file.reader(&file_buffer);
|
||||
var reader = &file_reader.interface;
|
||||
var file_buf: [20]u8 = undefined;
|
||||
var fbs = std.io.fixedBufferStream(&file_buf);
|
||||
|
||||
var buffer: [20]u8 = undefined;
|
||||
var writer = std.Io.Writer.fixed(&buffer);
|
||||
_ = try file.reader().streamUntilDelimiter(fbs.writer(), '\n', 20);
|
||||
const line = fbs.getWritten();
|
||||
|
||||
const written = try reader.streamDelimiter(&writer, '\n');
|
||||
return std.fmt.parseInt(i32, std.mem.trim(u8, buffer[0..written], " "), 10);
|
||||
return std.fmt.parseInt(i32, std.mem.trim(u8, line, " "), 10);
|
||||
}
|
||||
|
||||
fn createXauthFile(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.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.getenv("XDG_CONFIG_HOME");
|
||||
if (xdg_cfg_home == null) no_cfg_home: {
|
||||
xauth_dir = try std.fmt.bufPrint(&xauth_buf, "{s}/.config", .{pwd});
|
||||
|
||||
var dir = std.fs.cwd().openDir(xauth_dir, .{}) catch {
|
||||
// xauth_dir isn't a directory
|
||||
var sb: std.c.Stat = undefined;
|
||||
if (xdg_cfg_home == null) {
|
||||
xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/.config", .{pwd});
|
||||
_ = std.c.stat(xauth_dir, &sb);
|
||||
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();
|
||||
|
||||
// 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", .{xdg_cfg_home.?});
|
||||
xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/ly", .{xdg_cfg_home.?});
|
||||
}
|
||||
|
||||
const file = std.fs.cwd().openFile(xauth_dir, .{}) catch break :no_rt_dir;
|
||||
file.close();
|
||||
|
||||
// xauth_dir is a file, create the parent directory
|
||||
_ = std.c.stat(xauth_dir, &sb);
|
||||
const mode = sb.mode & std.posix.S.IFMT;
|
||||
if (mode != std.posix.S.IFDIR) {
|
||||
std.posix.mkdir(xauth_dir, 777) catch {
|
||||
xauth_dir = pwd;
|
||||
xauth_file = ".lyxauth";
|
||||
};
|
||||
}
|
||||
} else {
|
||||
xauth_dir = xdg_rt_dir.?;
|
||||
}
|
||||
@@ -364,73 +327,58 @@ fn createXauthFile(pwd: []const u8, buffer: []u8) ![]const 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 });
|
||||
|
||||
std.fs.makeDirAbsolute(trimmed_xauth_dir) catch {};
|
||||
|
||||
const file = try std.fs.createFileAbsolute(xauthority, .{});
|
||||
var buf: [256]u8 = undefined;
|
||||
const xauthority: [:0]u8 = try std.fmt.bufPrintZ(&buf, "{s}/{s}", .{ trimmed_xauth_dir, xauth_file });
|
||||
const file = try std.fs.createFileAbsoluteZ(xauthority, .{});
|
||||
file.close();
|
||||
|
||||
return xauthority;
|
||||
}
|
||||
|
||||
fn mcookie() [Md5.digest_length * 2]u8 {
|
||||
var buf: [4096]u8 = undefined;
|
||||
std.crypto.random.bytes(&buf);
|
||||
fn xauth(display_name: [:0]u8, shell: [*:0]const u8, pw_dir: [*:0]const u8, xauth_cmd: []const u8, mcookie_cmd: []const u8) !void {
|
||||
var pwd_buf: [100]u8 = undefined;
|
||||
const pwd = try std.fmt.bufPrintZ(&pwd_buf, "{s}", .{pw_dir});
|
||||
|
||||
var out: [Md5.digest_length]u8 = undefined;
|
||||
Md5.hash(&buf, &out, .{});
|
||||
|
||||
return std.fmt.bytesToHex(&out, .lower);
|
||||
}
|
||||
|
||||
fn xauth(log_file: *LogFile, allocator: std.mem.Allocator, display_name: []u8, shell: [*:0]const u8, home: []const u8, xauth_buffer: []u8, options: AuthOptions) !void {
|
||||
const xauthority = try createXauthFile(home, xauth_buffer);
|
||||
try interop.setEnvironmentVariable(allocator, "XAUTHORITY", xauthority, true);
|
||||
try interop.setEnvironmentVariable(allocator, "DISPLAY", display_name, true);
|
||||
|
||||
const magic_cookie = mcookie();
|
||||
const xauthority = try createXauthFile(pwd);
|
||||
_ = interop.setenv("XAUTHORITY", xauthority, 1);
|
||||
_ = interop.setenv("DISPLAY", display_name, 1);
|
||||
|
||||
const pid = try std.posix.fork();
|
||||
if (pid == 0) {
|
||||
var cmd_buffer: [1024]u8 = undefined;
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} add {s} . {s}", .{ options.xauth_cmd, display_name, magic_cookie }) catch std.process.exit(1);
|
||||
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} add {s} . $({s})", .{ xauth_cmd, display_name, mcookie_cmd }) catch std.process.exit(1);
|
||||
const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
|
||||
std.posix.execveZ(shell, &args, std.c.environ) catch {};
|
||||
std.process.exit(1);
|
||||
}
|
||||
|
||||
const status = std.posix.waitpid(pid, 0);
|
||||
if (status.status != 0) {
|
||||
try log_file.file_writer.interface.print("xauth command failed with status {d}\n", .{status.status});
|
||||
return error.XauthFailed;
|
||||
}
|
||||
_ = std.posix.waitpid(pid, 0);
|
||||
}
|
||||
|
||||
fn executeX11Cmd(log_file: *LogFile, allocator: std.mem.Allocator, shell: []const u8, home: []const u8, options: AuthOptions, desktop_cmd: []const u8, vt: []const u8) !void {
|
||||
var log_writer = &log_file.file_writer.interface;
|
||||
var xauth_buffer: [256]u8 = undefined;
|
||||
fn executeShellCmd(shell: [*:0]const u8) !void {
|
||||
const args = [_:null]?[*:0]const u8{shell};
|
||||
return std.posix.execveZ(shell, &args, std.c.environ);
|
||||
}
|
||||
|
||||
try log_writer.writeAll("[x11] getting free display\n");
|
||||
fn executeWaylandCmd(shell: [*:0]const u8, wayland_cmd: []const u8, desktop_cmd: []const u8) !void {
|
||||
var cmd_buffer: [1024]u8 = undefined;
|
||||
const cmd_str = try std.fmt.bufPrintZ(&cmd_buffer, "{s} {s}", .{ wayland_cmd, 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;
|
||||
const display_name = try std.fmt.bufPrint(&buf, ":{d}", .{display_num});
|
||||
var buf: [5]u8 = undefined;
|
||||
const display_name = try std.fmt.bufPrintZ(&buf, ":{d}", .{display_num});
|
||||
try xauth(display_name, shell, pw_dir, config.xauth_cmd, config.mcookie_cmd);
|
||||
|
||||
const shell_z = try allocator.dupeZ(u8, shell);
|
||||
defer allocator.free(shell_z);
|
||||
|
||||
try log_writer.writeAll("[x11] creating xauth file\n");
|
||||
try xauth(log_file, allocator, display_name, shell_z, home, &xauth_buffer, options);
|
||||
|
||||
try log_writer.writeAll("[x11] starting x server\n");
|
||||
const pid = try std.posix.fork();
|
||||
if (pid == 0) {
|
||||
var cmd_buffer: [1024]u8 = undefined;
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ options.x_cmd, display_name, vt }) catch std.process.exit(1);
|
||||
|
||||
const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
|
||||
std.posix.execveZ(shell_z, &args, std.c.environ) catch {};
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ config.x_cmd, display_name, vt }) catch std.process.exit(1);
|
||||
const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
|
||||
std.posix.execveZ(shell, &args, std.c.environ) catch {};
|
||||
std.process.exit(1);
|
||||
}
|
||||
|
||||
@@ -440,131 +388,84 @@ fn executeX11Cmd(log_file: *LogFile, allocator: std.mem.Allocator, shell: []cons
|
||||
xcb = interop.xcb.xcb_connect(null, null);
|
||||
ok = interop.xcb.xcb_connection_has_error(xcb);
|
||||
std.posix.kill(pid, 0) catch |e| {
|
||||
if (e == error.ProcessNotFound and ok != 0) return error.XcbConnectionFailed;
|
||||
if (e == error.ProcessNotFound and ok != 0) return;
|
||||
};
|
||||
}
|
||||
|
||||
// X Server detaches from the process.
|
||||
// PID can be fetched from /tmp/X{d}.lock
|
||||
try log_writer.writeAll("[x11] getting x server pid\n");
|
||||
const x_pid = try getXPid(display_num);
|
||||
|
||||
try log_writer.writeAll("[x11] launching environment\n");
|
||||
xorg_pid = try std.posix.fork();
|
||||
if (xorg_pid == 0) {
|
||||
var cmd_buffer: [1024]u8 = undefined;
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ options.setup_cmd, options.login_cmd orelse "", desktop_cmd }) catch std.process.exit(1);
|
||||
|
||||
const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
|
||||
std.posix.execveZ(shell_z, &args, std.c.environ) catch {};
|
||||
const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s}", .{ config.x_cmd_setup, desktop_cmd }) catch std.process.exit(1);
|
||||
const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
|
||||
std.posix.execveZ(shell, &args, std.c.environ) catch {};
|
||||
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);
|
||||
|
||||
_ = std.posix.waitpid(xorg_pid, 0);
|
||||
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 {};
|
||||
std.Thread.sleep(std.time.ns_per_s * 1); // Wait 1 second before sending SIGKILL
|
||||
std.posix.kill(x_pid, std.posix.SIG.KILL) catch return;
|
||||
|
||||
_ = std.posix.waitpid(x_pid, 0);
|
||||
var status: c_int = 0;
|
||||
_ = std.c.waitpid(x_pid, &status, 0);
|
||||
}
|
||||
|
||||
fn executeCmd(global_log_file: *LogFile, allocator: std.mem.Allocator, shell: []const u8, options: AuthOptions, is_terminal: bool, exec_cmd: ?[]const u8) !void {
|
||||
var maybe_log_file: ?std.fs.File = null;
|
||||
if (!is_terminal) {
|
||||
// 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| {
|
||||
maybe_log_file = try redirectStandardStreams(global_log_file, log_path, true);
|
||||
}
|
||||
}
|
||||
defer if (maybe_log_file) |log_file| log_file.close();
|
||||
|
||||
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}", .{ options.setup_cmd, options.login_cmd orelse "", exec_cmd orelse shell });
|
||||
|
||||
const args = [_:null]?[*:0]const u8{ shell_z, "-c", cmd_str };
|
||||
return std.posix.execveZ(shell_z, &args, std.c.environ);
|
||||
}
|
||||
|
||||
fn redirectStandardStreams(global_log_file: *LogFile, session_log: []const u8, create: bool) !std.fs.File {
|
||||
const log_file = if (create) (std.fs.cwd().createFile(session_log, .{ .mode = 0o666 }) catch |err| {
|
||||
try global_log_file.file_writer.interface.print("failed to create new session log file: {s}\n", .{@errorName(err)});
|
||||
return err;
|
||||
}) else (std.fs.cwd().openFile(session_log, .{ .mode = .read_write }) catch |err| {
|
||||
try global_log_file.file_writer.interface.print("failed to open existing session log file: {s}\n", .{@errorName(err)});
|
||||
return err;
|
||||
});
|
||||
|
||||
try std.posix.dup2(std.posix.STDOUT_FILENO, std.posix.STDERR_FILENO);
|
||||
try std.posix.dup2(log_file.handle, std.posix.STDOUT_FILENO);
|
||||
|
||||
return log_file;
|
||||
}
|
||||
|
||||
fn addUtmpEntry(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.fs.max_path_bytes]u8 = undefined;
|
||||
const tty_path = try std.os.getFdPath(std.posix.STDIN_FILENO, &buf);
|
||||
var buf: [4096]u8 = undefined;
|
||||
const ttyname = try std.os.getFdPath(0, &buf);
|
||||
|
||||
// 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..]});
|
||||
var ttyname_buf: [32]u8 = undefined;
|
||||
_ = 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
|
||||
// of ut_id if necessary
|
||||
entry.ut_id = ttyname_buf["tty".len..(@sizeOf(@TypeOf(entry.ut_id)) + "tty".len)].*;
|
||||
entry.ut_id = ttyname_buf["tty".len..7].*;
|
||||
|
||||
var username_buf: [@sizeOf(@TypeOf(entry.ut_user))]u8 = undefined;
|
||||
var username_buf: [32]u8 = undefined;
|
||||
_ = try std.fmt.bufPrintZ(&username_buf, "{s}", .{username});
|
||||
|
||||
entry.ut_user = username_buf;
|
||||
|
||||
var host: [@sizeOf(@TypeOf(entry.ut_host))]u8 = undefined;
|
||||
var host: [256]u8 = undefined;
|
||||
host[0] = 0;
|
||||
entry.ut_host = host;
|
||||
|
||||
const time = try interop.getTimeOfDay();
|
||||
var tv: std.c.timeval = undefined;
|
||||
_ = std.c.gettimeofday(&tv, null);
|
||||
|
||||
entry.ut_tv = .{
|
||||
.tv_sec = @intCast(time.seconds),
|
||||
.tv_usec = @intCast(time.microseconds),
|
||||
.tv_sec = @intCast(tv.tv_sec),
|
||||
.tv_usec = @intCast(tv.tv_usec),
|
||||
};
|
||||
|
||||
// FreeBSD doesn't have this field
|
||||
if (builtin.os.tag == .linux) {
|
||||
entry.ut_addr_v6[0] = 0;
|
||||
}
|
||||
|
||||
utmp.setutxent();
|
||||
_ = utmp.pututxline(entry);
|
||||
utmp.endutxent();
|
||||
utmp.setutent();
|
||||
_ = utmp.pututline(entry);
|
||||
utmp.endutent();
|
||||
}
|
||||
|
||||
fn removeUtmpEntry(entry: *Utmp) void {
|
||||
entry.ut_type = utmp.DEAD_PROCESS;
|
||||
entry.ut_line[0] = 0;
|
||||
entry.ut_user[0] = 0;
|
||||
utmp.setutxent();
|
||||
_ = utmp.pututxline(entry);
|
||||
utmp.endutxent();
|
||||
utmp.setutent();
|
||||
_ = utmp.pututline(entry);
|
||||
utmp.endutent();
|
||||
}
|
||||
|
||||
fn pamDiagnose(status: c_int) anyerror {
|
||||
|
||||
156
src/bigclock.zig
156
src/bigclock.zig
@@ -1,58 +1,140 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const interop = @import("interop.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 Cell = @import("tui/Cell.zig");
|
||||
const utils = @import("tui/utils.zig");
|
||||
|
||||
const Bigclock = enums.Bigclock;
|
||||
pub const WIDTH = Lang.WIDTH;
|
||||
pub const HEIGHT = Lang.HEIGHT;
|
||||
pub const SIZE = Lang.SIZE;
|
||||
const termbox = interop.termbox;
|
||||
|
||||
pub fn clockCell(animate: bool, char: u8, fg: u32, bg: u32, bigclock: Bigclock) ![SIZE]Cell {
|
||||
var cells: [SIZE]Cell = undefined;
|
||||
const X: u32 = if (builtin.os.tag == .linux or builtin.os.tag.isBSD()) 0x2593 else '#';
|
||||
const O: u32 = 0;
|
||||
|
||||
const time = try interop.getTimeOfDay();
|
||||
const clock_chars = toBigNumber(if (animate and char == ':' and @divTrunc(time.microseconds, 500000) != 0) ' ' else char, bigclock);
|
||||
for (0..cells.len) |i| cells[i] = Cell.init(clock_chars[i], fg, bg);
|
||||
pub const WIDTH: u64 = 5;
|
||||
pub const HEIGHT: u64 = 5;
|
||||
pub const SIZE = WIDTH * HEIGHT;
|
||||
|
||||
// zig fmt: off
|
||||
const ZERO = [_]u32{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const ONE = [_]u32{
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
};
|
||||
const TWO = [_]u32{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const THREE = [_]u32{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const FOUR = [_]u32{
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
};
|
||||
const FIVE = [_]u32{
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const SIX = [_]u32{
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const SEVEN = [_]u32{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
};
|
||||
const EIGHT = [_]u32{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const NINE = [_]u32{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
};
|
||||
const S = [_]u32{
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
};
|
||||
const E = [_]u32{
|
||||
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,
|
||||
};
|
||||
// zig fmt: on
|
||||
|
||||
pub fn clockCell(animate: bool, char: u8, fg: u8, bg: u8) [SIZE]termbox.tb_cell {
|
||||
var cells: [SIZE]termbox.tb_cell = undefined;
|
||||
|
||||
var tv: std.c.timeval = undefined;
|
||||
_ = std.c.gettimeofday(&tv, null);
|
||||
|
||||
const clock_chars = toBigNumber(if (animate and char == ':' and @divTrunc(tv.tv_usec, 500000) != 0) ' ' else char);
|
||||
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]Cell) void {
|
||||
pub fn alphaBlit(buffer: [*]termbox.tb_cell, x: u64, y: u64, tb_width: u64, tb_height: u64, cells: [SIZE]termbox.tb_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];
|
||||
cell.put(x + xx, y + yy);
|
||||
if (cell.ch != 0) buffer[(y + yy) * tb_width + (x + xx)] = cell;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn toBigNumber(char: u8, bigclock: Bigclock) [SIZE]u21 {
|
||||
const locale_chars = switch (bigclock) {
|
||||
.fa => fa.locale_chars,
|
||||
.en => en.locale_chars,
|
||||
.none => unreachable,
|
||||
};
|
||||
fn toBigNumber(char: u8) []const u32 {
|
||||
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,
|
||||
'0' => &ZERO,
|
||||
'1' => &ONE,
|
||||
'2' => &TWO,
|
||||
'3' => &THREE,
|
||||
'4' => &FOUR,
|
||||
'5' => &FIVE,
|
||||
'6' => &SIX,
|
||||
'7' => &SEVEN,
|
||||
'8' => &EIGHT,
|
||||
'9' => &NINE,
|
||||
':' => &S,
|
||||
else => &E,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
const interop = @import("../interop.zig");
|
||||
|
||||
pub const WIDTH = 5;
|
||||
pub const HEIGHT = 5;
|
||||
pub const SIZE = WIDTH * HEIGHT;
|
||||
|
||||
pub const X: u32 = if (interop.supportsUnicode()) 0x2593 else '#';
|
||||
pub const O: u32 = 0;
|
||||
|
||||
// zig fmt: off
|
||||
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,
|
||||
P: [SIZE]u21,
|
||||
A: [SIZE]u21,
|
||||
M: [SIZE]u21,
|
||||
};
|
||||
// zig fmt: on
|
||||
@@ -1,115 +0,0 @@
|
||||
const Lang = @import("Lang.zig");
|
||||
|
||||
const LocaleChars = Lang.LocaleChars;
|
||||
const X = Lang.X;
|
||||
const O = Lang.O;
|
||||
|
||||
// zig fmt: off
|
||||
pub const locale_chars = LocaleChars{
|
||||
.ZERO = [_]u21{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.ONE = [_]u21{
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
},
|
||||
.TWO = [_]u21{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.THREE = [_]u21{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.FOUR = [_]u21{
|
||||
X,X,O,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
},
|
||||
.FIVE = [_]u21{
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.SIX = [_]u21{
|
||||
X,X,X,X,X,
|
||||
X,X,O,O,O,
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.SEVEN = [_]u21{
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
O,O,O,X,X,
|
||||
},
|
||||
.EIGHT = [_]u21{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.NINE = [_]u21{
|
||||
X,X,X,X,X,
|
||||
X,X,O,X,X,
|
||||
X,X,X,X,X,
|
||||
O,O,O,X,X,
|
||||
X,X,X,X,X,
|
||||
},
|
||||
.S = [_]u21{
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
},
|
||||
.E = [_]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,
|
||||
},
|
||||
.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
|
||||
@@ -1,115 +0,0 @@
|
||||
const Lang = @import("Lang.zig");
|
||||
|
||||
const LocaleChars = Lang.LocaleChars;
|
||||
const X = Lang.X;
|
||||
const O = Lang.O;
|
||||
|
||||
// zig fmt: off
|
||||
pub const locale_chars = LocaleChars{
|
||||
.ZERO = [_]u21{
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,X,O,X,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
},
|
||||
.ONE = [_]u21{
|
||||
O,O,X,O,O,
|
||||
O,X,X,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,X,O,O,
|
||||
},
|
||||
.TWO = [_]u21{
|
||||
O,X,O,X,O,
|
||||
O,X,X,X,O,
|
||||
O,X,O,O,O,
|
||||
O,X,O,O,O,
|
||||
O,X,O,O,O,
|
||||
},
|
||||
.THREE = [_]u21{
|
||||
X,O,X,O,X,
|
||||
X,X,X,X,X,
|
||||
X,O,O,O,O,
|
||||
X,O,O,O,O,
|
||||
X,O,O,O,O,
|
||||
},
|
||||
.FOUR = [_]u21{
|
||||
O,X,O,X,X,
|
||||
O,X,X,O,O,
|
||||
O,X,X,X,X,
|
||||
O,X,O,O,O,
|
||||
O,X,O,O,O,
|
||||
},
|
||||
.FIVE = [_]u21{
|
||||
O,O,X,X,O,
|
||||
O,X,O,O,X,
|
||||
X,O,O,O,X,
|
||||
X,O,X,O,X,
|
||||
O,X,O,X,O,
|
||||
},
|
||||
.SIX = [_]u21{
|
||||
O,X,X,O,O,
|
||||
O,X,O,O,X,
|
||||
O,O,X,O,O,
|
||||
O,X,O,O,O,
|
||||
X,O,O,O,O,
|
||||
},
|
||||
.SEVEN = [_]u21{
|
||||
X,O,O,O,X,
|
||||
X,O,O,O,X,
|
||||
O,X,O,X,O,
|
||||
O,X,O,X,O,
|
||||
O,O,X,O,O,
|
||||
},
|
||||
.EIGHT = [_]u21{
|
||||
O,O,O,X,O,
|
||||
O,O,X,O,X,
|
||||
O,O,X,O,X,
|
||||
O,X,O,O,X,
|
||||
O,X,O,O,X,
|
||||
},
|
||||
.NINE = [_]u21{
|
||||
O,X,X,X,O,
|
||||
O,X,O,X,O,
|
||||
O,X,X,X,O,
|
||||
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,
|
||||
O,O,O,O,O,
|
||||
O,O,X,O,O,
|
||||
O,O,O,O,O,
|
||||
},
|
||||
.E = [_]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,
|
||||
},
|
||||
};
|
||||
// zig fmt: on
|
||||
@@ -3,93 +3,48 @@ const enums = @import("../enums.zig");
|
||||
|
||||
const Animation = enums.Animation;
|
||||
const Input = enums.Input;
|
||||
const ViMode = enums.ViMode;
|
||||
const Bigclock = enums.Bigclock;
|
||||
|
||||
allow_empty_password: bool = true,
|
||||
animation: Animation = .none,
|
||||
animation_timeout_sec: u12 = 0,
|
||||
asterisk: ?u32 = '*',
|
||||
auth_fails: u64 = 10,
|
||||
battery_id: ?[]const u8 = null,
|
||||
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,
|
||||
asterisk: u8 = '*',
|
||||
bg: u8 = 0,
|
||||
bigclock: bool = false,
|
||||
blank_box: bool = true,
|
||||
border_fg: u32 = 0x00FFFFFF,
|
||||
box_title: ?[]const u8 = null,
|
||||
brightness_down_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q -n s 10%-",
|
||||
brightness_down_key: ?[]const u8 = "F5",
|
||||
brightness_up_cmd: [:0]const u8 = build_options.prefix_directory ++ "/bin/brightnessctl -q -n s +10%",
|
||||
brightness_up_key: ?[]const u8 = "F6",
|
||||
border_fg: u8 = 8,
|
||||
clear_password: bool = false,
|
||||
clock: ?[:0]const u8 = null,
|
||||
cmatrix_fg: u32 = 0x0000FF00,
|
||||
cmatrix_head_col: u32 = 0x01FFFFFF,
|
||||
cmatrix_min_codepoint: u16 = 0x21,
|
||||
cmatrix_max_codepoint: u16 = 0x7B,
|
||||
colormix_col1: u32 = 0x00FF0000,
|
||||
colormix_col2: u32 = 0x000000FF,
|
||||
colormix_col3: u32 = 0x20000000,
|
||||
custom_sessions: []const u8 = build_options.config_directory ++ "/ly/custom-sessions",
|
||||
console_dev: [:0]const u8 = "/dev/console",
|
||||
default_input: Input = .login,
|
||||
doom_fire_height: u8 = 6,
|
||||
doom_fire_spread: u8 = 2,
|
||||
doom_top_color: u32 = 0x00FF0000,
|
||||
doom_middle_color: u32 = 0x00FFFF00,
|
||||
doom_bottom_color: u32 = 0x00FFFFFF,
|
||||
dur_file_path: []const u8 = build_options.config_directory ++ "/ly/example.dur",
|
||||
dur_x_offset: u32 = 0,
|
||||
dur_y_offset: u32 = 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",
|
||||
fg: u8 = 8,
|
||||
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",
|
||||
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",
|
||||
load: bool = true,
|
||||
margin_box_h: u8 = 2,
|
||||
margin_box_v: u8 = 1,
|
||||
max_desktop_len: u8 = 100,
|
||||
max_login_len: u8 = 255,
|
||||
max_password_len: u8 = 255,
|
||||
mcookie_cmd: []const u8 = "/usr/bin/mcookie",
|
||||
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/bin:/usr/sbin",
|
||||
restart_cmd: []const u8 = "/sbin/shutdown -r now",
|
||||
restart_key: []const u8 = "F2",
|
||||
save: bool = true,
|
||||
save_file: []const u8 = "/etc/ly/save",
|
||||
service_name: [:0]const u8 = "ly",
|
||||
session_log: ?[]const u8 = "ly-session.log",
|
||||
setup_cmd: []const u8 = build_options.config_directory ++ "/ly/setup.sh",
|
||||
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,
|
||||
vi_default_mode: ViMode = .normal,
|
||||
term_reset_cmd: [:0]const u8 = "/usr/bin/tput reset",
|
||||
term_restore_cursor_cmd: []const u8 = "/usr/bin/tput cnorm",
|
||||
tty: u8 = 2,
|
||||
vi_mode: bool = false,
|
||||
waylandsessions: []const u8 = build_options.prefix_directory ++ "/share/wayland-sessions",
|
||||
x_cmd: []const u8 = build_options.prefix_directory ++ "/bin/X",
|
||||
xauth_cmd: []const u8 = build_options.prefix_directory ++ "/bin/xauth",
|
||||
wayland_cmd: []const u8 = build_options.data_directory ++ "/wsetup.sh",
|
||||
waylandsessions: []const u8 = "/usr/share/wayland-sessions",
|
||||
x_cmd: []const u8 = "/usr/bin/X",
|
||||
xinitrc: ?[]const u8 = "~/.xinitrc",
|
||||
xsessions: []const u8 = build_options.prefix_directory ++ "/share/xsessions",
|
||||
x_cmd_setup: []const u8 = build_options.data_directory ++ "/xsetup.sh",
|
||||
xauth_cmd: []const u8 = "/usr/bin/xauth",
|
||||
xsessions: []const u8 = "/usr/share/xsessions",
|
||||
|
||||
@@ -1,35 +1,13 @@
|
||||
//
|
||||
// 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",
|
||||
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",
|
||||
err_pam: []const u8 = "pam transaction failed",
|
||||
err_pam_abort: []const u8 = "pam transaction aborted",
|
||||
err_pam_acct_expired: []const u8 = "account expired",
|
||||
@@ -51,33 +29,23 @@ err_perm_dir: []const u8 = "failed to change current directory",
|
||||
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_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_unknown: []const u8 = "an unknown error occurred",
|
||||
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",
|
||||
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",
|
||||
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",
|
||||
wayland: []const u8 = "wayland",
|
||||
x11: []const u8 = "x11",
|
||||
xinitrc: [:0]const u8 = "xinitrc",
|
||||
x11: []const u8 = "x11",
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
user: ?[]const u8 = null,
|
||||
session_index: ?usize = null,
|
||||
2
src/config/Save.zig
Normal file
2
src/config/Save.zig
Normal file
@@ -0,0 +1,2 @@
|
||||
user: ?[]const u8 = null,
|
||||
session_index: ?u64 = null,
|
||||
@@ -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);
|
||||
}
|
||||
@@ -1,250 +1,30 @@
|
||||
// The migrator ensures compatibility with older 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 Config = @import("Config.zig");
|
||||
const OldSave = @import("OldSave.zig");
|
||||
const SavedUsers = @import("SavedUsers.zig");
|
||||
const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
|
||||
const Save = @import("Save.zig");
|
||||
|
||||
const Color = TerminalBuffer.Color;
|
||||
const Styling = TerminalBuffer.Styling;
|
||||
|
||||
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",
|
||||
};
|
||||
|
||||
var temporary_allocator = std.heap.page_allocator;
|
||||
|
||||
pub var auto_eight_colors: bool = true;
|
||||
|
||||
pub var maybe_animate: ?bool = null;
|
||||
pub var maybe_save_file: ?[]const u8 = null;
|
||||
|
||||
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");
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
if (std.mem.eql(u8, field.key, "animation")) {
|
||||
// The option now uses a string (which then gets converted into an enum) instead of an integer
|
||||
// It also combines the previous "animate" and "animation" options
|
||||
const animation = std.fmt.parseInt(u8, field.value, 10) catch return field;
|
||||
var mapped_field = field;
|
||||
|
||||
mapped_field.value = switch (animation) {
|
||||
0 => "doom",
|
||||
1 => "matrix",
|
||||
else => "none",
|
||||
};
|
||||
|
||||
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";
|
||||
|
||||
return mapped_field;
|
||||
}
|
||||
|
||||
if (std.mem.eql(u8, field.key, "default_input")) {
|
||||
// The option now uses a string (which then gets converted into an enum) instead of an integer
|
||||
const default_input = std.fmt.parseInt(u8, field.value, 10) catch return field;
|
||||
var mapped_field = field;
|
||||
|
||||
mapped_field.value = switch (default_input) {
|
||||
0 => "session",
|
||||
1 => "login",
|
||||
2 => "password",
|
||||
else => "login",
|
||||
};
|
||||
|
||||
return mapped_field;
|
||||
}
|
||||
|
||||
if (std.mem.eql(u8, field.key, "save_file")) {
|
||||
// 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;
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
inline for (removed_properties) |property| {
|
||||
if (std.mem.eql(u8, field.key, property)) {
|
||||
// The options don't exist anymore
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
if (std.mem.eql(u8, field.key, "bigclock")) {
|
||||
// The option now uses a string (which then gets converted into an enum) instead of an boolean
|
||||
// It also includes the ability to change active bigclock's language
|
||||
var mapped_field = field;
|
||||
|
||||
if (std.mem.eql(u8, field.value, "true")) {
|
||||
mapped_field.value = "en";
|
||||
} else if (std.mem.eql(u8, field.value, "false")) {
|
||||
mapped_field.value = "none";
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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 {
|
||||
if (maybe_animate) |animate| {
|
||||
if (!animate) config.*.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 tryMigrateFirstSaveFile(user_buf: *[32]u8) OldSave {
|
||||
var save = OldSave{};
|
||||
|
||||
if (maybe_save_file) |path| {
|
||||
defer temporary_allocator.free(path);
|
||||
pub fn tryMigrateSaveFile(user_buf: *[32]u8, path: []const u8) Save {
|
||||
var save = Save{};
|
||||
|
||||
var file = std.fs.openFileAbsolute(path, .{}) catch return save;
|
||||
defer file.close();
|
||||
|
||||
var file_buffer: [64]u8 = undefined;
|
||||
var file_reader = file.reader(&file_buffer);
|
||||
var reader = &file_reader.interface;
|
||||
const reader = file.reader();
|
||||
|
||||
var user_writer = std.Io.Writer.fixed(user_buf);
|
||||
var written = reader.streamDelimiter(&user_writer, '\n') catch return save;
|
||||
if (written > 0) save.user = user_buf[0..written];
|
||||
var user_fbs = std.io.fixedBufferStream(user_buf);
|
||||
reader.streamUntilDelimiter(user_fbs.writer(), '\n', 32) catch return save;
|
||||
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);
|
||||
written = reader.streamDelimiter(&session_writer, '\n') catch return save;
|
||||
var session_fbs = std.io.fixedBufferStream(&session_buf);
|
||||
reader.streamUntilDelimiter(session_fbs.writer(), '\n', 20) catch {};
|
||||
|
||||
var session_index: ?usize = null;
|
||||
if (written > 0) {
|
||||
session_index = std.fmt.parseUnsigned(usize, session_buf[0..written], 10) catch return save;
|
||||
const session_index_str = session_fbs.getWritten();
|
||||
var session_index: ?u64 = null;
|
||||
if (session_index_str.len > 0) {
|
||||
session_index = std.fmt.parseUnsigned(u64, session_index_str, 10) catch return save;
|
||||
}
|
||||
save.session_index = session_index;
|
||||
}
|
||||
|
||||
return save;
|
||||
}
|
||||
|
||||
pub fn tryMigrateIniSaveFile(allocator: std.mem.Allocator, save_ini: *ini.Ini(OldSave), path: []const u8, saved_users: *SavedUsers, usernames: [][]const u8) !bool {
|
||||
var old_save_file_exists = true;
|
||||
|
||||
var user_buf: [32]u8 = undefined;
|
||||
const save = save_ini.readFileToStruct(path, .{
|
||||
.fieldHandler = null,
|
||||
.comment_characters = "#",
|
||||
}) catch no_save_file: {
|
||||
old_save_file_exists = false;
|
||||
break :no_save_file tryMigrateFirstSaveFile(&user_buf);
|
||||
};
|
||||
|
||||
if (!old_save_file_exists) return false;
|
||||
|
||||
// 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 true;
|
||||
}
|
||||
|
||||
@@ -1,11 +1,7 @@
|
||||
const std = @import("std");
|
||||
pub const Animation = enum {
|
||||
none,
|
||||
doom,
|
||||
matrix,
|
||||
colormix,
|
||||
gameoflife,
|
||||
dur_file,
|
||||
};
|
||||
|
||||
pub const DisplayServer = enum {
|
||||
@@ -13,43 +9,10 @@ pub const DisplayServer = enum {
|
||||
shell,
|
||||
xinitrc,
|
||||
x11,
|
||||
custom,
|
||||
};
|
||||
|
||||
pub const Input = enum {
|
||||
info_line,
|
||||
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 {
|
||||
normal,
|
||||
insert,
|
||||
};
|
||||
|
||||
pub const Bigclock = enum {
|
||||
none,
|
||||
en,
|
||||
fa,
|
||||
};
|
||||
|
||||
455
src/interop.zig
455
src/interop.zig
@@ -1,412 +1,113 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const UidRange = @import("UidRange.zig");
|
||||
const Allocator = std.mem.Allocator;
|
||||
|
||||
pub const termbox = @import("termbox2");
|
||||
pub const termbox = @cImport({
|
||||
@cInclude("termbox.h");
|
||||
});
|
||||
|
||||
pub const vt = @cImport({
|
||||
@cInclude("linux/vt.h");
|
||||
});
|
||||
|
||||
pub const pam = @cImport({
|
||||
@cInclude("security/pam_appl.h");
|
||||
});
|
||||
|
||||
pub const utmp = @cImport({
|
||||
@cInclude("utmpx.h");
|
||||
@cInclude("utmp.h");
|
||||
});
|
||||
|
||||
// Exists for X11 support only
|
||||
pub const xcb = @cImport({
|
||||
@cInclude("xcb/xcb.h");
|
||||
});
|
||||
|
||||
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("sys/types.h");
|
||||
@cInclude("login_cap.h");
|
||||
}
|
||||
});
|
||||
pub const c_size = u64;
|
||||
pub const c_uid = u32;
|
||||
pub const c_gid = u32;
|
||||
pub const c_time = c_long;
|
||||
pub const tm = extern struct {
|
||||
tm_sec: c_int,
|
||||
tm_min: c_int,
|
||||
tm_hour: c_int,
|
||||
tm_mday: c_int,
|
||||
tm_mon: c_int,
|
||||
tm_year: c_int,
|
||||
tm_wday: c_int,
|
||||
tm_yday: c_int,
|
||||
tm_isdst: c_int,
|
||||
};
|
||||
pub const passwd = extern struct {
|
||||
pw_name: [*:0]u8,
|
||||
pw_passwd: [*:0]u8,
|
||||
|
||||
const stdlib = @cImport({
|
||||
@cInclude("stdlib.h");
|
||||
});
|
||||
|
||||
const unistd = @cImport({
|
||||
@cInclude("unistd.h");
|
||||
});
|
||||
|
||||
const grp = @cImport({
|
||||
@cInclude("grp.h");
|
||||
});
|
||||
|
||||
const system_time = @cImport({
|
||||
@cInclude("sys/time.h");
|
||||
});
|
||||
|
||||
const time = @cImport({
|
||||
@cInclude("time.h");
|
||||
});
|
||||
|
||||
pub const TimeOfDay = struct {
|
||||
seconds: i64,
|
||||
microseconds: i64,
|
||||
pw_uid: c_uid,
|
||||
pw_gid: c_gid,
|
||||
pw_gecos: [*:0]u8,
|
||||
pw_dir: [*:0]u8,
|
||||
pw_shell: [*:0]u8,
|
||||
};
|
||||
|
||||
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,
|
||||
};
|
||||
pub const VT_GETSTATE: c_int = 0x5603;
|
||||
pub const VT_ACTIVATE: c_int = 0x5606;
|
||||
pub const VT_WAITACTIVE: c_int = 0x5607;
|
||||
|
||||
// Contains the platform-specific code
|
||||
fn PlatformStruct() type {
|
||||
return switch (builtin.os.tag) {
|
||||
.linux => struct {
|
||||
pub const kd = @cImport({
|
||||
@cInclude("sys/kd.h");
|
||||
});
|
||||
pub const KDGETLED: c_int = 0x4B31;
|
||||
pub const KDGKBLED: c_int = 0x4B64;
|
||||
|
||||
pub const vt = @cImport({
|
||||
@cInclude("sys/vt.h");
|
||||
});
|
||||
pub const LED_NUM: c_int = 0x02;
|
||||
pub const LED_CAP: c_int = 0x04;
|
||||
|
||||
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 const K_NUMLOCK: c_int = 0x02;
|
||||
pub const K_CAPSLOCK: c_int = 0x04;
|
||||
|
||||
const SYSTEMD_HOMED_UID_MIN = 60001;
|
||||
const SYSTEMD_HOMED_UID_MAX = 60513;
|
||||
pub extern "c" fn localtime(timer: *const c_time) *tm;
|
||||
pub extern "c" fn strftime(str: [*:0]u8, maxsize: c_size, format: [*:0]const u8, timeptr: *const tm) c_size;
|
||||
pub extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
|
||||
pub extern "c" fn putenv(name: [*:0]u8) c_int;
|
||||
pub extern "c" fn getuid() c_uid;
|
||||
pub extern "c" fn getpwnam(name: [*:0]const u8) ?*passwd;
|
||||
pub extern "c" fn endpwent() void;
|
||||
pub extern "c" fn setusershell() void;
|
||||
pub extern "c" fn getusershell() [*:0]u8;
|
||||
pub extern "c" fn endusershell() void;
|
||||
pub extern "c" fn initgroups(user: [*:0]const u8, group: c_gid) c_int;
|
||||
|
||||
pub fn setUserContextImpl(username: [*:0]const u8, entry: UsernameEntry) !void {
|
||||
const status = grp.initgroups(username, @intCast(entry.gid));
|
||||
if (status != 0) return error.GroupInitializationFailed;
|
||||
|
||||
std.posix.setgid(@intCast(entry.gid)) catch return error.SetUserGidFailed;
|
||||
std.posix.setuid(@intCast(entry.uid)) catch 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) !u8 {
|
||||
var file_buffer: [256]u8 = undefined;
|
||||
var tty_major: u16 = undefined;
|
||||
var tty_minor: u16 = undefined;
|
||||
|
||||
{
|
||||
var file = try std.fs.openFileAbsolute("/proc/self/stat", .{});
|
||||
defer file.close();
|
||||
|
||||
var reader = file.reader(&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.fs.openDirAbsolute("/sys/class/tty", .{ .iterate = true });
|
||||
defer directory.close();
|
||||
|
||||
var iterator = directory.iterate();
|
||||
while (try iterator.next()) |entry| {
|
||||
const path = try std.fmt.allocPrint(allocator, "/sys/class/tty/{s}/dev", .{entry.name});
|
||||
defer allocator.free(path);
|
||||
|
||||
var file = try std.fs.openFileAbsolute(path, .{});
|
||||
defer file.close();
|
||||
|
||||
var reader = file.reader(&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, file_path: []const u8) !UidRange {
|
||||
const login_defs_file = try std.fs.cwd().openFile(file_path, .{});
|
||||
defer login_defs_file.close();
|
||||
|
||||
const login_defs_buffer = try login_defs_file.readToEndAlloc(allocator, std.math.maxInt(u16));
|
||||
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;
|
||||
|
||||
// This code assumes the OS has a login.defs file with UID_MIN
|
||||
// and UID_MAX values defined in it, which should be the case
|
||||
// for most systemd-based Linux distributions out there.
|
||||
// This should be a good enough safeguard for now, as there's
|
||||
// no reliable (and clean) way to check for systemd support
|
||||
if (uid_range.uid_min > SYSTEMD_HOMED_UID_MIN) {
|
||||
uid_range.uid_min = SYSTEMD_HOMED_UID_MIN;
|
||||
}
|
||||
|
||||
if (uid_range.uid_max < SYSTEMD_HOMED_UID_MAX) {
|
||||
uid_range.uid_max = SYSTEMD_HOMED_UID_MAX;
|
||||
}
|
||||
|
||||
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 = @cImport({
|
||||
@cInclude("sys/kbio.h");
|
||||
});
|
||||
|
||||
pub const consio = @cImport({
|
||||
@cInclude("sys/consio.h");
|
||||
});
|
||||
|
||||
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) !u8 {
|
||||
return error.FeatureUnimplemented;
|
||||
}
|
||||
|
||||
pub fn getUserIdRange(_: std.mem.Allocator, _: []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();
|
||||
|
||||
pub fn supportsUnicode() bool {
|
||||
return builtin.os.tag == .linux or builtin.os.tag == .freebsd;
|
||||
}
|
||||
|
||||
pub fn timeAsString(buf: [:0]u8, format: [:0]const u8) []u8 {
|
||||
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);
|
||||
const tm_info = localtime(&timer);
|
||||
|
||||
const len = strftime(buf, buf.len, format, tm_info);
|
||||
if (len < 0) return error.CannotGetFormattedTime;
|
||||
|
||||
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) !u8 {
|
||||
return platform_struct.getActiveTtyImpl(allocator);
|
||||
}
|
||||
|
||||
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 {
|
||||
pub fn getLockState(console_dev: [:0]const u8) !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;
|
||||
const fd = std.c.open(console_dev, .{ .ACCMODE = .RDONLY });
|
||||
if (fd < 0) return error.CannotOpenConsoleDev;
|
||||
defer _ = std.c.close(fd);
|
||||
|
||||
var numlock = false;
|
||||
var capslock = false;
|
||||
|
||||
if (builtin.os.tag.isBSD()) {
|
||||
var led: c_int = undefined;
|
||||
_ = std.c.ioctl(fd, KDGETLED, &led);
|
||||
numlock = (led & LED_NUM) != 0;
|
||||
capslock = (led & LED_CAP) != 0;
|
||||
} else {
|
||||
var led: c_char = undefined;
|
||||
_ = std.c.ioctl(fd, KDGKBLED, &led);
|
||||
numlock = (led & K_NUMLOCK) != 0;
|
||||
capslock = (led & K_CAPSLOCK) != 0;
|
||||
}
|
||||
|
||||
return .{
|
||||
.numlock = (led & platform_struct.numlock_led) != 0,
|
||||
.capslock = (led & platform_struct.capslock_led) != 0,
|
||||
.numlock = numlock,
|
||||
.capslock = capslock,
|
||||
};
|
||||
}
|
||||
|
||||
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, file_path: []const u8) !UidRange {
|
||||
return platform_struct.getUserIdRange(allocator, file_path);
|
||||
}
|
||||
|
||||
1307
src/main.zig
1307
src/main.zig
File diff suppressed because it is too large
Load Diff
@@ -1,61 +0,0 @@
|
||||
const Animation = @This();
|
||||
|
||||
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,
|
||||
};
|
||||
|
||||
pointer: *anyopaque,
|
||||
vtable: VTable,
|
||||
|
||||
pub fn init(
|
||||
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,
|
||||
) Animation {
|
||||
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) anyerror!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});
|
||||
}
|
||||
|
||||
const vtable = VTable{
|
||||
.deinit_fn = deinitImpl,
|
||||
.realloc_fn = reallocImpl,
|
||||
.draw_fn = drawImpl,
|
||||
};
|
||||
};
|
||||
|
||||
return .{
|
||||
.pointer = pointer,
|
||||
.vtable = Impl.vtable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Animation) void {
|
||||
const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
|
||||
return @call(.auto, self.vtable.deinit_fn, .{impl});
|
||||
}
|
||||
|
||||
pub fn realloc(self: *Animation) anyerror!void {
|
||||
const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
|
||||
return @call(.auto, self.vtable.realloc_fn, .{impl});
|
||||
}
|
||||
|
||||
pub fn draw(self: *Animation) void {
|
||||
const impl: @TypeOf(self.pointer) = @ptrCast(@alignCast(self.pointer));
|
||||
return @call(.auto, self.vtable.draw_fn, .{impl});
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
const interop = @import("../interop.zig");
|
||||
|
||||
const termbox = interop.termbox;
|
||||
|
||||
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;
|
||||
|
||||
_ = termbox.tb_set_cell(@intCast(x), @intCast(y), self.ch, self.fg, self.bg);
|
||||
}
|
||||
@@ -1,66 +1,22 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const interop = @import("../interop.zig");
|
||||
const Cell = @import("Cell.zig");
|
||||
const utils = @import("utils.zig");
|
||||
const Config = @import("../config/Config.zig");
|
||||
|
||||
const Random = std.Random;
|
||||
const Random = std.rand.Random;
|
||||
|
||||
const termbox = interop.termbox;
|
||||
|
||||
const TerminalBuffer = @This();
|
||||
|
||||
pub const InitOptions = struct {
|
||||
fg: u32,
|
||||
bg: u32,
|
||||
border_fg: u32,
|
||||
margin_box_h: u8,
|
||||
margin_box_v: u8,
|
||||
input_len: u8,
|
||||
};
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
random: Random,
|
||||
width: usize,
|
||||
height: usize,
|
||||
fg: u32,
|
||||
bg: u32,
|
||||
border_fg: u32,
|
||||
width: u64,
|
||||
height: u64,
|
||||
buffer: [*]termbox.tb_cell,
|
||||
fg: u8,
|
||||
bg: u8,
|
||||
border_fg: u8,
|
||||
box_chars: struct {
|
||||
left_up: u32,
|
||||
left_down: u32,
|
||||
@@ -71,24 +27,26 @@ box_chars: struct {
|
||||
left: u32,
|
||||
right: u32,
|
||||
},
|
||||
labels_max_length: usize,
|
||||
box_x: usize,
|
||||
box_y: usize,
|
||||
box_width: usize,
|
||||
box_height: usize,
|
||||
labels_max_length: u64,
|
||||
box_x: u64,
|
||||
box_y: u64,
|
||||
box_width: u64,
|
||||
box_height: u64,
|
||||
margin_box_v: u8,
|
||||
margin_box_h: u8,
|
||||
blank_cell: Cell,
|
||||
|
||||
pub fn init(options: InitOptions, labels_max_length: usize, random: Random) TerminalBuffer {
|
||||
pub fn init(config: Config, labels_max_length: u64) TerminalBuffer {
|
||||
var prng = std.rand.Isaac64.init(@intCast(std.time.timestamp()));
|
||||
|
||||
return .{
|
||||
.random = random,
|
||||
.random = prng.random(),
|
||||
.width = @intCast(termbox.tb_width()),
|
||||
.height = @intCast(termbox.tb_height()),
|
||||
.fg = options.fg,
|
||||
.bg = options.bg,
|
||||
.border_fg = options.border_fg,
|
||||
.box_chars = if (interop.supportsUnicode()) .{
|
||||
.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,
|
||||
@@ -110,151 +68,110 @@ pub fn init(options: InitOptions, labels_max_length: usize, random: Random) Term
|
||||
.labels_max_length = labels_max_length,
|
||||
.box_x = 0,
|
||||
.box_y = 0,
|
||||
.box_width = (2 * options.margin_box_h) + options.input_len + 1 + labels_max_length,
|
||||
.box_height = 7 + (2 * options.margin_box_v),
|
||||
.margin_box_v = options.margin_box_v,
|
||||
.margin_box_h = options.margin_box_h,
|
||||
.blank_cell = Cell.init(' ', options.fg, options.bg),
|
||||
.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;
|
||||
var changes = false;
|
||||
|
||||
var y = self.height - 2;
|
||||
while (y > 0) : (y -= 1) {
|
||||
for (0..self.width) |x| {
|
||||
var cell: ?*termbox.tb_cell = undefined;
|
||||
var cell_under: ?*termbox.tb_cell = undefined;
|
||||
const c: u8 = @truncate(self.buffer[(y - 1) * self.width + x].ch);
|
||||
if (std.ascii.isWhitespace(c)) continue;
|
||||
|
||||
_ = termbox.tb_get_cell(@intCast(x), @intCast(y - 1), 1, &cell);
|
||||
_ = termbox.tb_get_cell(@intCast(x), @intCast(y), 1, &cell_under);
|
||||
const c_under: u8 = @truncate(self.buffer[y * self.width + x].ch);
|
||||
if (!std.ascii.isWhitespace(c_under)) continue;
|
||||
|
||||
// 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;
|
||||
changes = 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);
|
||||
self.buffer[y * self.width + x] = self.buffer[(y - 1) * self.width + x];
|
||||
self.buffer[(y - 1) * self.width + x].ch = ' ';
|
||||
}
|
||||
}
|
||||
|
||||
return changed;
|
||||
return changes;
|
||||
}
|
||||
|
||||
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;
|
||||
const x1 = (self.width - self.box_width) / 2;
|
||||
const y1 = (self.height - self.box_height) / 2;
|
||||
const x2 = (self.width + self.box_width) / 2;
|
||||
const y2 = (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);
|
||||
termbox.tb_change_cell(@intCast(x1 - 1), @intCast(y1 - 1), self.box_chars.left_up, self.border_fg, self.bg);
|
||||
termbox.tb_change_cell(@intCast(x2), @intCast(y1 - 1), self.box_chars.right_up, self.border_fg, self.bg);
|
||||
termbox.tb_change_cell(@intCast(x1 - 1), @intCast(y2), self.box_chars.left_down, self.border_fg, self.bg);
|
||||
termbox.tb_change_cell(@intCast(x2), @intCast(y2), self.box_chars.right_down, self.border_fg, self.bg);
|
||||
|
||||
var c1 = Cell.init(self.box_chars.top, self.border_fg, self.bg);
|
||||
var c2 = Cell.init(self.box_chars.bottom, 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| {
|
||||
c1.put(x1 + i, y1 - 1);
|
||||
c2.put(x1 + i, y2);
|
||||
termbox.tb_put_cell(@intCast(x1 + i), @intCast(y1 - 1), &c1);
|
||||
termbox.tb_put_cell(@intCast(x1 + i), @intCast(y2), &c2);
|
||||
}
|
||||
|
||||
c1.ch = self.box_chars.left;
|
||||
c2.ch = self.box_chars.right;
|
||||
|
||||
for (0..self.box_height) |i| {
|
||||
c1.put(x1 - 1, y1 + i);
|
||||
c2.put(x2, y1 + i);
|
||||
termbox.tb_put_cell(@intCast(x1 - 1), @intCast(y1 + i), &c1);
|
||||
termbox.tb_put_cell(@intCast(x2), @intCast(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| {
|
||||
self.blank_cell.put(x1 + x, y1 + y);
|
||||
termbox.tb_put_cell(@intCast(x1 + x), @intCast(y1 + y), &blank);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn calculateComponentCoordinates(self: TerminalBuffer) struct {
|
||||
start_x: usize,
|
||||
x: usize,
|
||||
y: usize,
|
||||
full_visible_length: usize,
|
||||
visible_length: usize,
|
||||
x: u64,
|
||||
y: u64,
|
||||
visible_length: u64,
|
||||
} {
|
||||
const start_x = self.box_x + self.margin_box_h;
|
||||
const x = start_x + self.labels_max_length + 1;
|
||||
const x = self.box_x + self.margin_box_h + 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: u32, bg: u32) void {
|
||||
pub fn drawLabel(self: TerminalBuffer, text: []const u8, x: u64, y: u64) 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);
|
||||
var i = x;
|
||||
while (utf8.nextCodepoint()) |codepoint| : (i += 1) {
|
||||
termbox.tb_change_cell(@intCast(i), yc, codepoint, self.fg, self.bg);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn drawConfinedLabel(self: TerminalBuffer, text: []const u8, x: usize, y: usize, max_length: usize) void {
|
||||
pub fn drawCharMultiple(self: TerminalBuffer, char: u8, x: u64, y: u64, length: u64) void {
|
||||
const yc: c_int = @intCast(y);
|
||||
const utf8view = std.unicode.Utf8View.init(text) catch return;
|
||||
var utf8 = utf8view.iterator();
|
||||
const cell = utils.initCell(char, self.fg, self.bg);
|
||||
|
||||
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, self.fg, self.bg);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn drawCharMultiple(self: TerminalBuffer, char: u32, x: usize, y: usize, length: usize) void {
|
||||
const cell = Cell.init(char, self.fg, self.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) !u8 {
|
||||
const utf8view = try std.unicode.Utf8View.init(str);
|
||||
var utf8 = utf8view.iterator();
|
||||
var i: c_int = 0;
|
||||
while (utf8.nextCodepoint()) |codepoint| i += termbox.tb_wcwidth(codepoint);
|
||||
|
||||
return @intCast(i);
|
||||
for (0..length) |xx| termbox.tb_put_cell(@intCast(x + xx), yc, &cell);
|
||||
}
|
||||
|
||||
223
src/tui/components/Desktop.zig
Normal file
223
src/tui/components/Desktop.zig
Normal file
@@ -0,0 +1,223 @@
|
||||
const std = @import("std");
|
||||
const enums = @import("../../enums.zig");
|
||||
const interop = @import("../../interop.zig");
|
||||
const TerminalBuffer = @import("../TerminalBuffer.zig");
|
||||
const Ini = @import("zigini").Ini;
|
||||
const Lang = @import("../../config/Lang.zig");
|
||||
|
||||
const Allocator = std.mem.Allocator;
|
||||
const EnvironmentList = std.ArrayList(Environment);
|
||||
|
||||
const DisplayServer = enums.DisplayServer;
|
||||
|
||||
const termbox = interop.termbox;
|
||||
|
||||
const Desktop = @This();
|
||||
|
||||
pub const Environment = struct {
|
||||
entry_ini: ?Ini(Entry) = null,
|
||||
name: [:0]const u8 = "",
|
||||
xdg_session_desktop: [:0]const u8 = "",
|
||||
xdg_desktop_names: ?[:0]const u8 = "",
|
||||
cmd: []const u8 = "",
|
||||
specifier: []const u8 = "",
|
||||
display_server: DisplayServer = .wayland,
|
||||
};
|
||||
|
||||
const DesktopEntry = struct {
|
||||
Exec: []const u8 = "",
|
||||
Name: [:0]const u8 = "",
|
||||
DesktopNames: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
pub const Entry = struct { @"Desktop Entry": DesktopEntry = DesktopEntry{} };
|
||||
|
||||
allocator: Allocator,
|
||||
buffer: *TerminalBuffer,
|
||||
environments: EnvironmentList,
|
||||
current: u64,
|
||||
visible_length: u64,
|
||||
x: u64,
|
||||
y: u64,
|
||||
lang: Lang,
|
||||
|
||||
pub fn init(allocator: Allocator, buffer: *TerminalBuffer, max_length: u64, lang: Lang) !Desktop {
|
||||
return .{
|
||||
.allocator = allocator,
|
||||
.buffer = buffer,
|
||||
.environments = try EnvironmentList.initCapacity(allocator, max_length),
|
||||
.current = 0,
|
||||
.visible_length = 0,
|
||||
.x = 0,
|
||||
.y = 0,
|
||||
.lang = lang,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: Desktop) void {
|
||||
for (self.environments.items) |*environment| {
|
||||
if (environment.entry_ini) |*entry_ini| entry_ini.deinit();
|
||||
if (environment.xdg_desktop_names) |desktop_name| self.allocator.free(desktop_name);
|
||||
self.allocator.free(environment.xdg_session_desktop);
|
||||
}
|
||||
|
||||
self.environments.deinit();
|
||||
}
|
||||
|
||||
pub fn position(self: *Desktop, x: u64, y: u64, visible_length: u64) void {
|
||||
self.x = x;
|
||||
self.y = y;
|
||||
self.visible_length = visible_length;
|
||||
}
|
||||
|
||||
pub fn addEnvironment(self: *Desktop, entry: DesktopEntry, xdg_session_desktop: []const u8, display_server: DisplayServer) !void {
|
||||
var xdg_desktop_names: ?[:0]const u8 = null;
|
||||
if (entry.DesktopNames) |desktop_names| {
|
||||
const desktop_names_z = try self.allocator.dupeZ(u8, desktop_names);
|
||||
for (desktop_names_z) |*c| {
|
||||
if (c.* == ';') c.* = ':';
|
||||
}
|
||||
xdg_desktop_names = desktop_names_z;
|
||||
}
|
||||
|
||||
errdefer {
|
||||
if (xdg_desktop_names) |desktop_names| self.allocator.free(desktop_names);
|
||||
}
|
||||
|
||||
const session_desktop = try self.allocator.dupeZ(u8, xdg_session_desktop);
|
||||
errdefer self.allocator.free(session_desktop);
|
||||
|
||||
try self.environments.append(.{
|
||||
.entry_ini = null,
|
||||
.name = entry.Name,
|
||||
.xdg_session_desktop = 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,
|
||||
});
|
||||
|
||||
self.current = self.environments.items.len - 1;
|
||||
}
|
||||
|
||||
pub fn addEnvironmentWithIni(self: *Desktop, entry_ini: Ini(Entry), xdg_session_desktop: []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| {
|
||||
const desktop_names_z = try self.allocator.dupeZ(u8, desktop_names);
|
||||
for (desktop_names_z) |*c| {
|
||||
if (c.* == ';') c.* = ':';
|
||||
}
|
||||
xdg_desktop_names = desktop_names_z;
|
||||
}
|
||||
|
||||
errdefer {
|
||||
if (xdg_desktop_names) |desktop_names| self.allocator.free(desktop_names);
|
||||
}
|
||||
|
||||
const session_desktop = try self.allocator.dupeZ(u8, xdg_session_desktop);
|
||||
errdefer self.allocator.free(session_desktop);
|
||||
|
||||
try self.environments.append(.{
|
||||
.entry_ini = entry_ini,
|
||||
.name = entry.Name,
|
||||
.xdg_session_desktop = 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,
|
||||
});
|
||||
|
||||
self.current = self.environments.items.len - 1;
|
||||
}
|
||||
|
||||
pub fn crawl(self: *Desktop, 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.allocator, "{s}/{s}", .{ path, item.name });
|
||||
defer self.allocator.free(entry_path);
|
||||
var entry_ini = Ini(Entry).init(self.allocator);
|
||||
_ = try entry_ini.readFileToStruct(entry_path);
|
||||
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);
|
||||
}
|
||||
|
||||
try self.addEnvironmentWithIni(entry_ini, xdg_session_desktop, display_server);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn handle(self: *Desktop, maybe_event: ?*termbox.tb_event, insert_mode: bool) void {
|
||||
if (maybe_event) |event| blk: {
|
||||
if (event.type != termbox.TB_EVENT_KEY) break :blk;
|
||||
|
||||
switch (event.key) {
|
||||
termbox.TB_KEY_ARROW_LEFT, termbox.TB_KEY_CTRL_H => self.goLeft(),
|
||||
termbox.TB_KEY_ARROW_RIGHT, termbox.TB_KEY_CTRL_L => self.goRight(),
|
||||
else => {
|
||||
if (!insert_mode) {
|
||||
switch (event.ch) {
|
||||
'h' => self.goLeft(),
|
||||
'l' => self.goRight(),
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
termbox.tb_set_cursor(@intCast(self.x + 2), @intCast(self.y));
|
||||
}
|
||||
|
||||
pub fn draw(self: Desktop) void {
|
||||
const environment = self.environments.items[self.current];
|
||||
|
||||
const length = @min(environment.name.len, self.visible_length - 3);
|
||||
if (length == 0) return;
|
||||
|
||||
const x = self.buffer.box_x + self.buffer.margin_box_h;
|
||||
const y = self.buffer.box_y + self.buffer.margin_box_v + 2;
|
||||
self.buffer.drawLabel(environment.specifier, x, y);
|
||||
|
||||
termbox.tb_change_cell(@intCast(self.x), @intCast(self.y), '<', self.buffer.fg, self.buffer.bg);
|
||||
termbox.tb_change_cell(@intCast(self.x + self.visible_length - 1), @intCast(self.y), '>', self.buffer.fg, self.buffer.bg);
|
||||
|
||||
self.buffer.drawLabel(environment.name, self.x + 2, self.y);
|
||||
}
|
||||
|
||||
fn goLeft(self: *Desktop) void {
|
||||
if (self.current == 0) {
|
||||
self.current = self.environments.items.len - 1;
|
||||
return;
|
||||
}
|
||||
|
||||
self.current -= 1;
|
||||
}
|
||||
|
||||
fn goRight(self: *Desktop) void {
|
||||
if (self.current == self.environments.items.len - 1) {
|
||||
self.current = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
self.current += 1;
|
||||
}
|
||||
@@ -1,60 +1,11 @@
|
||||
const std = @import("std");
|
||||
const TerminalBuffer = @import("../TerminalBuffer.zig");
|
||||
const generic = @import("generic.zig");
|
||||
|
||||
const Allocator = std.mem.Allocator;
|
||||
|
||||
const MessageLabel = generic.CyclableLabel(Message, Message);
|
||||
const utils = @import("../utils.zig");
|
||||
|
||||
const InfoLine = @This();
|
||||
|
||||
const Message = struct {
|
||||
width: u8,
|
||||
text: []const u8,
|
||||
bg: u32,
|
||||
fg: u32,
|
||||
};
|
||||
text: []const u8 = "",
|
||||
width: u8 = 0,
|
||||
|
||||
label: MessageLabel,
|
||||
|
||||
pub fn init(allocator: Allocator, buffer: *TerminalBuffer) InfoLine {
|
||||
return .{
|
||||
.label = MessageLabel.init(allocator, buffer, drawItem, null, null),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *InfoLine) void {
|
||||
self.label.deinit();
|
||||
}
|
||||
|
||||
pub fn addMessage(self: *InfoLine, text: []const u8, bg: u32, fg: u32) !void {
|
||||
if (text.len == 0) return;
|
||||
|
||||
try self.label.addItem(.{
|
||||
.width = try TerminalBuffer.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;
|
||||
pub fn setText(self: *InfoLine, text: []const u8) !void {
|
||||
self.width = if (text.len > 0) try utils.strWidth(text) else 0;
|
||||
self.text = text;
|
||||
}
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
const std = @import("std");
|
||||
const TerminalBuffer = @import("../TerminalBuffer.zig");
|
||||
const enums = @import("../../enums.zig");
|
||||
const Environment = @import("../../Environment.zig");
|
||||
const generic = @import("generic.zig");
|
||||
const UserList = @import("UserList.zig");
|
||||
|
||||
const Allocator = std.mem.Allocator;
|
||||
const DisplayServer = enums.DisplayServer;
|
||||
|
||||
const Env = struct {
|
||||
environment: Environment,
|
||||
index: usize,
|
||||
};
|
||||
const EnvironmentLabel = generic.CyclableLabel(Env, *UserList);
|
||||
|
||||
const Session = @This();
|
||||
|
||||
label: EnvironmentLabel,
|
||||
user_list: *UserList,
|
||||
|
||||
pub fn init(allocator: Allocator, buffer: *TerminalBuffer, user_list: *UserList) Session {
|
||||
return .{
|
||||
.label = EnvironmentLabel.init(allocator, buffer, drawItem, sessionChanged, user_list),
|
||||
.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();
|
||||
if (env.environment.xdg_session_desktop_owned) {
|
||||
self.label.allocator.free(env.environment.xdg_session_desktop.?);
|
||||
}
|
||||
}
|
||||
|
||||
self.label.deinit();
|
||||
}
|
||||
|
||||
pub fn addEnvironment(self: *Session, environment: Environment) !void {
|
||||
const env = Env{ .environment = environment, .index = self.label.list.items.len };
|
||||
|
||||
try self.label.addItem(env);
|
||||
sessionChanged(env, self.user_list);
|
||||
}
|
||||
|
||||
fn sessionChanged(env: Env, maybe_user_list: ?*UserList) void {
|
||||
if (maybe_user_list) |user_list| {
|
||||
const user = user_list.label.list.items[user_list.label.current];
|
||||
if (!user.first_run) return;
|
||||
|
||||
user.session_index.* = env.index;
|
||||
}
|
||||
}
|
||||
|
||||
fn drawItem(label: *EnvironmentLabel, env: Env, x: usize, y: usize) bool {
|
||||
const length = @min(env.environment.name.len, label.visible_length - 3);
|
||||
if (length == 0) return false;
|
||||
|
||||
const nx = if (label.text_in_center) (label.x + (label.visible_length - env.environment.name.len) / 2) else (label.x + 2);
|
||||
label.first_char_x = nx + env.environment.name.len;
|
||||
|
||||
label.buffer.drawLabel(env.environment.specifier, x, y);
|
||||
label.buffer.drawLabel(env.environment.name, nx, label.y);
|
||||
return true;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user