aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig')
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig140
1 files changed, 140 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig b/vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig
new file mode 100644
index 00000000..71edb076
--- /dev/null
+++ b/vendor/libghostty-vt/src/apprt/gtk/gtk_version.zig
@@ -0,0 +1,140 @@
+const std = @import("std");
+
+// Until the gobject bindings are built at the same time we are building
+// Ghostty, we need to import `gtk/gtk.h` directly to ensure that the version
+// macros match the version of `gtk4` that we are building/linking against.
+const c = @cImport({
+ @cInclude("gtk/gtk.h");
+});
+
+const gtk = @import("gtk");
+
+const log = std.log.scoped(.gtk);
+
+pub const comptime_version: std.SemanticVersion = .{
+ .major = c.GTK_MAJOR_VERSION,
+ .minor = c.GTK_MINOR_VERSION,
+ .patch = c.GTK_MICRO_VERSION,
+};
+
+pub fn getRuntimeVersion() std.SemanticVersion {
+ return .{
+ .major = gtk.getMajorVersion(),
+ .minor = gtk.getMinorVersion(),
+ .patch = gtk.getMicroVersion(),
+ };
+}
+
+pub fn logVersion() void {
+ log.info("GTK version build={f} runtime={f}", .{
+ comptime_version,
+ getRuntimeVersion(),
+ });
+}
+
+/// Verifies that the GTK version is at least the given version.
+///
+/// This can be run in both a comptime and runtime context. If it is run in a
+/// comptime context, it will only check the version in the headers. If it is
+/// run in a runtime context, it will check the actual version of the library we
+/// are linked against.
+///
+/// This function should be used in cases where the version check would affect
+/// code generation, such as using symbols that are only available beyond a
+/// certain version. For checks which only depend on GTK's runtime behavior,
+/// use `runtimeAtLeast`.
+///
+/// This is inlined so that the comptime checks will disable the runtime checks
+/// if the comptime checks fail.
+pub inline fn atLeast(
+ comptime major: u16,
+ comptime minor: u16,
+ comptime micro: u16,
+) bool {
+ // If our header has lower versions than the given version,
+ // we can return false immediately. This prevents us from
+ // compiling against unknown symbols and makes runtime checks
+ // very slightly faster.
+ if (comptime comptime_version.order(.{
+ .major = major,
+ .minor = minor,
+ .patch = micro,
+ }) == .lt) return false;
+
+ // If we're in comptime then we can't check the runtime version.
+ if (@inComptime()) return true;
+
+ return runtimeAtLeast(major, minor, micro);
+}
+
+/// Verifies that the GTK version at runtime is at least the given version.
+///
+/// This function should be used in cases where the only the runtime behavior
+/// is affected by the version check. For checks which would affect code
+/// generation, use `atLeast`.
+pub inline fn runtimeAtLeast(
+ comptime major: u16,
+ comptime minor: u16,
+ comptime micro: u16,
+) bool {
+ // We use the functions instead of the constants such as c.GTK_MINOR_VERSION
+ // because the function gets the actual runtime version.
+ const runtime_version = getRuntimeVersion();
+ return runtime_version.order(.{
+ .major = major,
+ .minor = minor,
+ .patch = micro,
+ }) != .lt;
+}
+
+pub inline fn runtimeUntil(
+ comptime major: u16,
+ comptime minor: u16,
+ comptime micro: u16,
+) bool {
+ const runtime_version = getRuntimeVersion();
+ return runtime_version.order(.{
+ .major = major,
+ .minor = minor,
+ .patch = micro,
+ }) == .lt;
+}
+
+test "atLeast" {
+ const testing = std.testing;
+
+ const funs = &.{ atLeast, runtimeAtLeast };
+ inline for (funs) |fun| {
+ try testing.expect(fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION + 1));
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION + 1, c.GTK_MICRO_VERSION));
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION + 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+
+ try testing.expect(fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+ try testing.expect(fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION + 1, c.GTK_MICRO_VERSION));
+ try testing.expect(fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION + 1));
+
+ try testing.expect(fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION - 1, c.GTK_MICRO_VERSION + 1));
+ }
+}
+
+test "runtimeUntil" {
+ const testing = std.testing;
+
+ // This is an array in case we add a comptime variant.
+ const funs = &.{runtimeUntil};
+ inline for (funs) |fun| {
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+
+ try testing.expect(fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION + 1));
+ try testing.expect(fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION + 1, c.GTK_MICRO_VERSION));
+ try testing.expect(fun(c.GTK_MAJOR_VERSION + 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION));
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION + 1, c.GTK_MICRO_VERSION));
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION - 1, c.GTK_MINOR_VERSION, c.GTK_MICRO_VERSION + 1));
+
+ try testing.expect(!fun(c.GTK_MAJOR_VERSION, c.GTK_MINOR_VERSION - 1, c.GTK_MICRO_VERSION + 1));
+ }
+}