feat: finish ghostty pane backend integration

1 files changed, 70 insertions, 0 deletions

diff --git a/vendor/libghostty-vt/src/apprt/gtk/ext.zig b/vendor/libghostty-vt/src/apprt/gtk/ext.zig
new file mode 100644
index 00000000..df9ab4ea
--- /dev/null
+++ b/vendor/libghostty-vt/src/apprt/gtk/ext.zig
@@ -0,0 +1,70 @@
+//! Extensions/helpers for GTK objects, following a similar naming
+//! style to zig-gobject. These should, wherever possible, be Zig-friendly
+//! wrappers around existing GTK functionality, rather than complex new
+//! helpers.
+
+const std = @import("std");
+const assert = @import("../../quirks.zig").inlineAssert;
+const testing = std.testing;
+
+const glib = @import("glib");
+const gobject = @import("gobject");
+const gtk = @import("gtk");
+
+pub const actions = @import("ext/actions.zig");
+const slice = @import("ext/slice.zig");
+pub const StringList = slice.StringList;
+
+/// Wrapper around `gobject.boxedCopy` to copy a boxed type `T`.
+pub fn boxedCopy(comptime T: type, ptr: *const T) *T {
+    const copy = gobject.boxedCopy(T.getGObjectType(), ptr);
+    return @ptrCast(@alignCast(copy));
+}
+
+/// Wrapper around `gobject.boxedFree` to free a boxed type `T`.
+pub fn boxedFree(comptime T: type, ptr: ?*T) void {
+    if (ptr) |p| gobject.boxedFree(
+        T.getGObjectType(),
+        p,
+    );
+}
+
+/// A wrapper around `glib.List.findCustom` to find an element in the list.
+/// The type `T` must be the guaranteed type of every list element.
+pub fn listFind(
+    comptime T: type,
+    list: *glib.List,
+    comptime func: *const fn (*T) bool,
+) ?*T {
+    const elem_: ?*glib.List = list.findCustom(null, struct {
+        fn callback(data: ?*const anyopaque, _: ?*const anyopaque) callconv(.c) c_int {
+            const ptr = data orelse return 1;
+            const v: *T = @ptrCast(@alignCast(@constCast(ptr)));
+            return if (func(v)) 0 else 1;
+        }
+    }.callback);
+    const elem = elem_ orelse return null;
+    return @ptrCast(@alignCast(elem.f_data));
+}
+
+/// Wrapper around `gtk.Widget.getAncestor` to get the widget ancestor
+/// of the given type `T`, or null if it doesn't exist.
+pub fn getAncestor(comptime T: type, widget: *gtk.Widget) ?*T {
+    const ancestor_ = widget.getAncestor(gobject.ext.typeFor(T));
+    const ancestor = ancestor_ orelse return null;
+    // We can assert the unwrap because getAncestor above
+    return gobject.ext.cast(T, ancestor).?;
+}
+
+/// Check a gobject.Value to see what type it is wrapping. This is equivalent to GTK's
+/// `G_VALUE_HOLDS()` macro but Zig's C translator does not like it.
+pub fn gValueHolds(value_: ?*const gobject.Value, g_type: gobject.Type) bool {
+    const value = value_ orelse return false;
+    if (value.f_g_type == g_type) return true;
+    return gobject.typeCheckValueHolds(value, g_type) != 0;
+}
+
+test {
+    _ = actions;
+    _ = slice;
+}