superrob1500
/
mirror-ghostty
mirror of https://github.com/ghostty-org/ghostty
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gtk-ng: add a helper for creating GTK actions (#8228) 

- Reduces boilerplate.
- Adds type safety.
- Adds comptime checks for action and group names which
  otherwise could cause panics at runtime.
pull/8235/head
Mitchell Hashimoto 2025-08-14 12:26:39 -07:00 committed by GitHub
parent 4740242bb9 d251695fa2
commit b7913f09ad
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 225 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/apprt/gtk-ng.zig
View File

@ -11,4 +11,5 @@ pub const WeakRef = @import("gtk-ng/weak_ref.zig").WeakRef;
test {
@import("std").testing.refAllDecls(@This());
_ = @import("gtk-ng/ext.zig");
}

38
src/apprt/gtk-ng/class/application.zig
View File

@ -1112,38 +1112,16 @@ pub const Application = extern struct {
const as_variant_type = glib.VariantType.new("as");
defer as_variant_type.free();
// The set of actions. Each action has (in order):
// [0] The action name
// [1] The callback function
// [2] The glib.VariantType of the parameter
//
// For action names:
// https://docs.gtk.org/gio/type_func.Action.name_is_valid.html
const actions = .{
.{ "new-window", actionNewWindow, null },
.{ "new-window-command", actionNewWindow, as_variant_type },
.{ "open-config", actionOpenConfig, null },
.{ "present-surface", actionPresentSurface, t_variant_type },
.{ "quit", actionQuit, null },
.{ "reload-config", actionReloadConfig, null },
const actions = [_]ext.actions.Action(Self){
.init("new-window", actionNewWindow, null),
.init("new-window-command", actionNewWindow, as_variant_type),
.init("open-config", actionOpenConfig, null),
.init("present-surface", actionPresentSurface, t_variant_type),
.init("quit", actionQuit, null),
.init("reload-config", actionReloadConfig, null),
};
const action_map = self.as(gio.ActionMap);
inline for (actions) |entry| {
const action = gio.SimpleAction.new(
entry[0],
entry[2],
);
defer action.unref();
_ = gio.SimpleAction.signals.activate.connect(
action,
*Self,
entry[1],
self,
.{},
);
action_map.addAction(action.as(gio.Action));
}
ext.actions.add(Self, self, &actions);
}
/// Setup our global shortcuts.

56
src/apprt/gtk-ng/class/split_tree.zig
View File

@ -160,62 +160,26 @@ pub const SplitTree = extern struct {
gtk.Widget.initTemplate(self.as(gtk.Widget));
// Initialize our actions
self.initActions();
self.initActionMap();
// Initialize some basic state
const priv = self.private();
priv.pending_close = null;
}
fn initActions(self: *Self) void {
// The set of actions. Each action has (in order):
// [0] The action name
// [1] The callback function
// [2] The glib.VariantType of the parameter
//
// For action names:
// https://docs.gtk.org/gio/type_func.Action.name_is_valid.html
const actions: []const struct {
[:0]const u8,
*const fn (*gio.SimpleAction, ?*glib.Variant, *Self) callconv(.c) void,
?*glib.VariantType,
} = &.{
fn initActionMap(self: *Self) void {
const s_variant_type = glib.ext.VariantType.newFor([:0]const u8);
defer s_variant_type.free();
const actions = [_]ext.actions.Action(Self){
// All of these will eventually take a target surface parameter.
// For now all our targets originate from the focused surface.
.{ "new-split", &actionNewSplit, glib.ext.VariantType.newFor([:0]const u8) },
.{ "equalize", &actionEqualize, null },
.{ "zoom", &actionZoom, null },
.init("new-split", actionNewSplit, s_variant_type),
.init("equalize", actionEqualize, null),
.init("zoom", actionZoom, null),
};
// We need to collect our actions into a group since we're just
// a plain widget that doesn't implement ActionGroup directly.
const group = gio.SimpleActionGroup.new();
errdefer group.unref();
const map = group.as(gio.ActionMap);
for (actions) |entry| {
const action = gio.SimpleAction.new(
entry[0],
entry[2],
);
defer {
action.unref();
if (entry[2]) |ptype| ptype.free();
}
_ = gio.SimpleAction.signals.activate.connect(
action,
*Self,
entry[1],
self,
.{},
);
map.addAction(action.as(gio.Action));
}
self.as(gtk.Widget).insertActionGroup(
"split-tree",
group.as(gio.ActionGroup),
);
ext.actions.addAsGroup(Self, self, "split-tree", &actions);
}
/// Create a new split in the given direction from the currently

60
src/apprt/gtk-ng/class/surface.zig
View File

@ -1233,7 +1233,7 @@ pub const Surface = extern struct {
gtk.Widget.initTemplate(self.as(gtk.Widget));
// Initialize our actions
self.initActions();
self.initActionMap();
const priv = self.private();
@ -1281,43 +1281,12 @@ pub const Surface = extern struct {
self.propConfig(undefined, null);
}
fn initActions(self: *Self) void {
// The set of actions. Each action has (in order):
// [0] The action name
// [1] The callback function
// [2] The glib.VariantType of the parameter
//
// For action names:
// https://docs.gtk.org/gio/type_func.Action.name_is_valid.html
const actions = .{
.{ "prompt-title", actionPromptTitle, null },
fn initActionMap(self: *Self) void {
const actions = [_]ext.actions.Action(Self){
.init("prompt-title", actionPromptTitle, null),
};
// We need to collect our actions into a group since we're just
// a plain widget that doesn't implement ActionGroup directly.
const group = gio.SimpleActionGroup.new();
errdefer group.unref();
const map = group.as(gio.ActionMap);
inline for (actions) |entry| {
const action = gio.SimpleAction.new(
entry[0],
entry[2],
);
defer action.unref();
_ = gio.SimpleAction.signals.activate.connect(
action,
*Self,
entry[1],
self,
.{},
);
map.addAction(action.as(gio.Action));
}
self.as(gtk.Widget).insertActionGroup(
"surface",
group.as(gio.ActionGroup),
);
ext.actions.addAsGroup(Self, self, "surface", &actions);
}
fn dispose(self: *Self) callconv(.c) void {
@ -1780,10 +1749,7 @@ pub const Surface = extern struct {
) callconv(.c) c_int {
const alloc = Application.default().allocator();
if (g_value_holds(
value,
gdk.FileList.getGObjectType(),
)) {
if (ext.gValueHolds(value, gdk.FileList.getGObjectType())) {
var data = std.ArrayList(u8).init(alloc);
defer data.deinit();
@ -1827,7 +1793,7 @@ pub const Surface = extern struct {
return 1;
}
if (g_value_holds(value, gio.File.getGObjectType())) {
if (ext.gValueHolds(value, gio.File.getGObjectType())) {
const object = value.getObject() orelse return 0;
const file = gobject.ext.cast(gio.File, object) orelse return 0;
const path = file.getPath() orelse return 0;
@ -1855,7 +1821,7 @@ pub const Surface = extern struct {
return 1;
}
if (g_value_holds(value, gobject.ext.types.string)) {
if (ext.gValueHolds(value, gobject.ext.types.string)) {
if (value.getString()) |string| {
Clipboard.paste(self, std.mem.span(string));
}
@ -3039,16 +3005,6 @@ const Clipboard = struct {
};
};
/// Check a GValue to see what's type its wrapping. This is equivalent to GTK's
/// `G_VALUE_HOLDS` macro but Zig's C translator does not like it.
fn g_value_holds(value_: ?*gobject.Value, g_type: gobject.Type) bool {
if (value_) |value| {
if (value.f_g_type == g_type) return true;
return gobject.typeCheckValueHolds(value, g_type) != 0;
}
return false;
}
/// Compute a fraction [0.0, 1.0] from the supplied progress, which is clamped
/// to [0, 100].
fn computeFraction(progress: u8) f64 {

44
src/apprt/gtk-ng/class/tab.zig
View File

@ -177,7 +177,7 @@ pub const Tab = extern struct {
gtk.Widget.initTemplate(self.as(gtk.Widget));
// Init our actions
self.initActions();
self.initActionMap();
// If our configuration is null then we get the configuration
// from the application.
@ -198,45 +198,13 @@ pub const Tab = extern struct {
};
}
/// Setup our action map.
fn initActions(self: *Self) void {
// The set of actions. Each action has (in order):
// [0] The action name
// [1] The callback function
// [2] The glib.VariantType of the parameter
//
// For action names:
// https://docs.gtk.org/gio/type_func.Action.name_is_valid.html
const actions = .{
.{ "close", actionClose, null },
.{ "ring-bell", actionRingBell, null },
fn initActionMap(self: *Self) void {
const actions = [_]ext.actions.Action(Self){
.init("close", actionClose, null),
.init("ring-bell", actionRingBell, null),
};
// We need to collect our actions into a group since we're just
// a plain widget that doesn't implement ActionGroup directly.
const group = gio.SimpleActionGroup.new();
errdefer group.unref();
const map = group.as(gio.ActionMap);
inline for (actions) |entry| {
const action = gio.SimpleAction.new(
entry[0],
entry[2],
);
defer action.unref();
_ = gio.SimpleAction.signals.activate.connect(
action,
*Self,
entry[1],
self,
.{},
);
map.addAction(action.as(gio.Action));
}
self.as(gtk.Widget).insertActionGroup(
"tab",
group.as(gio.ActionGroup),
);
ext.actions.addAsGroup(Self, self, "tab", &actions);
}
//---------------------------------------------------------------

51
src/apprt/gtk-ng/class/window.zig
View File

@ -331,42 +331,27 @@ pub const Window = extern struct {
/// Setup our action map.
fn initActionMap(self: *Self) void {
const actions = .{
.{ "about", actionAbout, null },
.{ "close", actionClose, null },
.{ "close-tab", actionCloseTab, null },
.{ "new-tab", actionNewTab, null },
.{ "new-window", actionNewWindow, null },
.{ "ring-bell", actionRingBell, null },
.{ "split-right", actionSplitRight, null },
.{ "split-left", actionSplitLeft, null },
.{ "split-up", actionSplitUp, null },
.{ "split-down", actionSplitDown, null },
.{ "copy", actionCopy, null },
.{ "paste", actionPaste, null },
.{ "reset", actionReset, null },
.{ "clear", actionClear, null },
const actions = [_]ext.actions.Action(Self){
.init("about", actionAbout, null),
.init("close", actionClose, null),
.init("close-tab", actionCloseTab, null),
.init("new-tab", actionNewTab, null),
.init("new-window", actionNewWindow, null),
.init("ring-bell", actionRingBell, null),
.init("split-right", actionSplitRight, null),
.init("split-left", actionSplitLeft, null),
.init("split-up", actionSplitUp, null),
.init("split-down", actionSplitDown, null),
.init("copy", actionCopy, null),
.init("paste", actionPaste, null),
.init("reset", actionReset, null),
.init("clear", actionClear, null),
// TODO: accept the surface that toggled the command palette
.{ "toggle-command-palette", actionToggleCommandPalette, null },
.{ "toggle-inspector", actionToggleInspector, null },
.init("toggle-command-palette", actionToggleCommandPalette, null),
.init("toggle-inspector", actionToggleInspector, null),
};
const action_map = self.as(gio.ActionMap);
inline for (actions) |entry| {
const action = gio.SimpleAction.new(
entry[0],
entry[2],
);
defer action.unref();
_ = gio.SimpleAction.signals.activate.connect(
action,
*Self,
entry[1],
self,
.{},
);
action_map.addAction(action.as(gio.Action));
}
ext.actions.add(Self, self, &actions);
}
/// Winproto backend for this window.

16
src/apprt/gtk-ng/ext.zig
View File

@ -5,11 +5,15 @@
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const gio = @import("gio");
const glib = @import("glib");
const gobject = @import("gobject");
const gtk = @import("gtk");
pub const actions = @import("ext/actions.zig");
/// 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);
@ -50,3 +54,15 @@ pub fn getAncestor(comptime T: type, widget: *gtk.Widget) ?*T {
// 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;
}

158
src/apprt/gtk-ng/ext/actions.zig Normal file
View File

@ -0,0 +1,158 @@
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const gio = @import("gio");
const glib = @import("glib");
const gobject = @import("gobject");
const gtk = @import("gtk");
const gValueHolds = @import("../ext.zig").gValueHolds;
/// Check that an action name is valid.
///
/// Reimplementation of `g_action_name_is_valid()` so that it can be
/// used at comptime.
///
/// See:
/// https://docs.gtk.org/gio/type_func.Action.name_is_valid.html
fn gActionNameIsValid(name: [:0]const u8) bool {
if (name.len == 0) return false;
for (name) |c| switch (c) {
'-' => continue,
'.' => continue,
'0'...'9' => continue,
'a'...'z' => continue,
'A'...'Z' => continue,
else => return false,
};
return true;
}
test "gActionNameIsValid" {
try testing.expect(gActionNameIsValid("ring-bell"));
try testing.expect(!gActionNameIsValid("ring_bell"));
}
/// Function to create a structure for describing an action.
pub fn Action(comptime T: type) type {
return struct {
pub const Callback = *const fn (*gio.SimpleAction, ?*glib.Variant, *T) callconv(.c) void;
name: [:0]const u8,
callback: Callback,
parameter_type: ?*const glib.VariantType,
/// Function to initialize a new action so that we can comptime check the name.
pub fn init(comptime name: [:0]const u8, callback: Callback, parameter_type: ?*const glib.VariantType) @This() {
comptime assert(gActionNameIsValid(name));
return .{
.name = name,
.callback = callback,
.parameter_type = parameter_type,
};
}
};
}
/// Add actions to a widget that implements gio.ActionMap.
pub fn add(comptime T: type, self: *T, actions: []const Action(T)) void {
addToMap(T, self, self.as(gio.ActionMap), actions);
}
/// Add actions to the given map.
pub fn addToMap(comptime T: type, self: *T, map: *gio.ActionMap, actions: []const Action(T)) void {
for (actions) |entry| {
assert(gActionNameIsValid(entry.name));
const action = gio.SimpleAction.new(
entry.name,
entry.parameter_type,
);
defer action.unref();
_ = gio.SimpleAction.signals.activate.connect(
action,
*T,
entry.callback,
self,
.{},
);
map.addAction(action.as(gio.Action));
}
}
/// Add actions to a widget that doesn't implement ActionGroup directly.
pub fn addAsGroup(comptime T: type, self: *T, comptime name: [:0]const u8, actions: []const Action(T)) void {
comptime assert(gActionNameIsValid(name));
// Collect our actions into a group since we're just a plain widget that
// doesn't implement ActionGroup directly.
const group = gio.SimpleActionGroup.new();
errdefer group.unref();
addToMap(T, self, group.as(gio.ActionMap), actions);
self.as(gtk.Widget).insertActionGroup(
name,
group.as(gio.ActionGroup),
);
}
test "adding actions to an object" {
// This test requires a connection to an active display environment.
if (gtk.initCheck() == 0) return;
const callbacks = struct {
fn callback(_: *gio.SimpleAction, variant_: ?*glib.Variant, self: *gtk.Box) callconv(.c) void {
const i32_variant_type = glib.ext.VariantType.newFor(i32);
defer i32_variant_type.free();
const variant = variant_ orelse return;
assert(variant.isOfType(i32_variant_type) != 0);
var value = std.mem.zeroes(gobject.Value);
_ = value.init(gobject.ext.types.int);
defer value.unset();
value.setInt(variant.getInt32());
self.as(gobject.Object).setProperty("spacing", &value);
}
};
const box = gtk.Box.new(.vertical, 0);
_ = box.as(gobject.Object).refSink();
defer box.unref();
{
const i32_variant_type = glib.ext.VariantType.newFor(i32);
defer i32_variant_type.free();
const actions = [_]Action(gtk.Box){
.init("test", callbacks.callback, i32_variant_type),
};
addAsGroup(gtk.Box, box, "test", &actions);
}
const expected = std.crypto.random.intRangeAtMost(i32, 1, std.math.maxInt(u31));
const parameter = glib.Variant.newInt32(expected);
try testing.expect(box.as(gtk.Widget).activateActionVariant("test.test", parameter) != 0);
_ = glib.MainContext.iteration(null, @intFromBool(true));
var value = std.mem.zeroes(gobject.Value);
_ = value.init(gobject.ext.types.int);
defer value.unset();
box.as(gobject.Object).getProperty("spacing", &value);
try testing.expect(gValueHolds(&value, gobject.ext.types.int));
const actual = value.getInt();
try testing.expectEqual(expected, actual);
}