aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/apprt/gtk/class
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-09-10 21:51:57 +0300
committerGitHub <noreply@github.com>2026-09-10 21:51:57 +0300
commit425c86179791cd32e2d4ce0ae7f269940b4b0663 (patch)
treee52c4383a6d69216cbe2a32638bf90841d7e2189 /vendor/libghostty-vt/src/apprt/gtk/class
parent90e947a6e26e02f10ec7f1694c4eb5b78a86406b (diff)
chore: upgrade libghostty and preserve terminal behavior (#3906)
Diffstat (limited to 'vendor/libghostty-vt/src/apprt/gtk/class')
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/application.zig756
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/clipboard_confirmation_dialog.zig5
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/command_palette.zig10
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/global_shortcuts.zig71
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/imgui_widget.zig19
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/split_tree.zig291
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/surface.zig524
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/surface_child_exited.zig4
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/surface_scrolled_window.zig12
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/tab.zig4
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/title_dialog.zig3
-rw-r--r--vendor/libghostty-vt/src/apprt/gtk/class/window.zig147
12 files changed, 1523 insertions, 323 deletions
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/application.zig b/vendor/libghostty-vt/src/apprt/gtk/class/application.zig
index a627086e..5b9d3bf2 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/application.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/application.zig
@@ -1,3 +1,4 @@
+const builtin = @import("builtin");
const std = @import("std");
const assert = @import("../../../quirks.zig").inlineAssert;
const Allocator = std.mem.Allocator;
@@ -5,25 +6,27 @@ const adw = @import("adw");
const gdk = @import("gdk");
const gio = @import("gio");
const glib = @import("glib");
+const glibunix = @import("glibunix");
const gobject = @import("gobject");
const gtk = @import("gtk");
const build_config = @import("../../../build_config.zig");
const build_info = @import("../build/info.zig");
-const state = &@import("../../../global.zig").state;
+const cli = @import("../../../cli.zig");
+const global = @import("../../../global.zig");
const i18n = @import("../../../os/main.zig").i18n;
const apprt = @import("../../../apprt.zig");
const CoreApp = @import("../../../App.zig");
+const compat_file = @import("../../../lib/compat/file.zig");
const configpkg = @import("../../../config.zig");
const input = @import("../../../input.zig");
const internal_os = @import("../../../os/main.zig");
const systemd = @import("../../../os/systemd.zig");
const terminal = @import("../../../terminal/main.zig");
-const xev = @import("../../../global.zig").xev;
+const xev = global.xev;
const Binding = @import("../../../input.zig").Binding;
const CoreConfig = configpkg.Config;
const CoreSurface = @import("../../../Surface.zig");
-const lib = @import("../../../lib/main.zig");
const ext = @import("../ext.zig");
const key = @import("../key.zig");
@@ -42,9 +45,12 @@ const CloseConfirmationDialog = @import("close_confirmation_dialog.zig").CloseCo
const ConfigErrorsDialog = @import("config_errors_dialog.zig").ConfigErrorsDialog;
const GlobalShortcuts = @import("global_shortcuts.zig").GlobalShortcuts;
const OpenURI = @import("../portal.zig").OpenURI;
+const media = @import("../media.zig");
const log = std.log.scoped(.gtk_ghostty_application);
+extern "c" fn setenv(name: ?[*]const u8, value: ?[*]const u8, overwrite: c_int) c_int;
+
/// Function used to funnel GLib/GObject/GTK log messages into Zig's logging
/// system rather than just getting dumped directly to stderr.
fn glibLogWriterFunction(
@@ -218,6 +224,12 @@ pub const Application = extern struct {
open_uri: OpenURI = undefined,
+ // The audio bell's MediaFile, reused across bells so we don't leak a
+ // GStreamer pipeline (and its GL threads) on every ring. Built lazily
+ // on the first audio bell and rebuilt when `bell-audio-path` changes;
+ // unref'd on dispose. See ringBell and media.zig.
+ bell_media: ?*gtk.MediaFile = null,
+
pub var offset: c_int = 0;
};
@@ -271,15 +283,17 @@ pub const Application = extern struct {
};
defer config.deinit();
+ // Set the old language,
const saved_language: ?[:0]const u8 = saved_language: {
const old_language = old_language: {
- const result = (internal_os.getenv(alloc, "LANG") catch break :old_language null) orelse break :old_language null;
- defer result.deinit(alloc);
- break :old_language alloc.dupeZ(u8, result.value) catch break :old_language null;
+ const lang = global.environ().getPosix("LANG") orelse break :old_language null;
+ break :old_language alloc.dupeSentinel(u8, @ptrCast(lang), 0) catch null;
};
-
- if (config.language) |language| _ = internal_os.setenv("LANG", language);
-
+ if (config.language) |language| {
+ // Override LANG if we need to (sync global environs if so)
+ _ = setenv("LANG", @ptrCast(language), 1);
+ global.syncEnviron();
+ }
break :saved_language old_language;
};
@@ -294,7 +308,7 @@ pub const Application = extern struct {
// Setup our GTK init env vars
setGtkEnv(&config) catch |err| switch (err) {
- error.NoSpaceLeft => {
+ error.WriteFailed => {
// If we fail to set GTK environment variables then we still
// try to start the application...
log.warn(
@@ -338,7 +352,7 @@ pub const Application = extern struct {
// I'm unsure of any scenario where this happens. Because we don't
// want to litter null checks everywhere, we just exit here.
log.warn("gdk display is null, exiting", .{});
- std.posix.exit(1);
+ std.process.exit(1);
};
// Setup our windowing protocol logic
@@ -696,6 +710,11 @@ pub const Application = extern struct {
.initial_size => return Action.initialSize(target, value),
.inspector => return Action.controlInspector(target, value),
+ .export_terminal_io => return try Action.exportTerminalIO(
+ self,
+ target,
+ value,
+ ),
.key_sequence => return Action.keySequence(target, value),
.key_table => return Action.keyTable(target, value),
@@ -705,10 +724,11 @@ pub const Application = extern struct {
.mouse_visibility => Action.mouseVisibility(target, value),
.move_tab => return Action.moveTab(target, value),
+ .move_tab_to_new_window => return Action.moveTabToNewWindow(target),
.new_split => return Action.newSplit(target, value),
- .new_tab => return Action.newTab(target),
+ .new_tab => return Action.newTab(target, .none),
.new_window => try Action.newWindow(
self,
@@ -719,7 +739,7 @@ pub const Application = extern struct {
.none,
),
- .open_config => return Action.openConfig(self),
+ .open_config => return Action.openConfig(self, value),
.open_url => Action.openUrl(self, value),
@@ -750,6 +770,7 @@ pub const Application = extern struct {
.set_title => Action.setTitle(target, value),
.set_tab_title => return Action.setTabTitle(target, value),
+ .set_window_title => return Action.setWindowTitle(target, value),
.show_child_exited => return Action.showChildExited(target, value),
@@ -1016,6 +1037,38 @@ pub const Application = extern struct {
\\}
\\
\\/*
+ \\ * Drag and Drop Overlay
+ \\ */
+ \\.drop-overlay.drop-left {
+ \\ background: linear-gradient(
+ \\ to left,
+ \\ transparent, 50%,
+ \\ color-mix(in srgb, var(--accent-bg-color), transparent 80%) 50%
+ \\ );
+ \\}
+ \\.drop-overlay.drop-right {
+ \\ background: linear-gradient(
+ \\ to right,
+ \\ transparent, 50%,
+ \\ color-mix(in srgb, var(--accent-bg-color), transparent 80%) 50%
+ \\ );
+ \\}
+ \\.drop-overlay.drop-top {
+ \\ background: linear-gradient(
+ \\ to top,
+ \\ transparent, 50%,
+ \\ color-mix(in srgb, var(--accent-bg-color), transparent 80%) 50%
+ \\ );
+ \\}
+ \\.drop-overlay.drop-bottom {
+ \\ background: linear-gradient(
+ \\ to bottom,
+ \\ transparent, 50%,
+ \\ color-mix(in srgb, var(--accent-bg-color), transparent 80%) 50%
+ \\ );
+ \\}
+ \\
+ \\/*
\\ * Splits
\\ */
\\
@@ -1063,7 +1116,11 @@ pub const Application = extern struct {
}
}
- fn loadCustomCss(self: *Self) (std.fs.File.ReadError || Allocator.Error)!void {
+ const LoadCustomCssError = std.Io.File.OpenError ||
+ compat_file.ReadToEndAllocError ||
+ std.mem.Allocator.Error;
+
+ fn loadCustomCss(self: *Self) LoadCustomCssError!void {
const priv: *Private = self.private();
const alloc = self.allocator();
const display = gdk.Display.getDefault() orelse {
@@ -1087,7 +1144,11 @@ pub const Application = extern struct {
.optional => |path| .{ path, true },
.required => |path| .{ path, false },
};
- const file = std.fs.openFileAbsolute(path, .{}) catch |err| {
+ const file = std.Io.Dir.openFileAbsolute(
+ global.io(),
+ path,
+ .{},
+ ) catch |err| {
if (err != error.FileNotFound or !optional) {
log.warn(
"error opening gtk-custom-css file {s}: {}",
@@ -1096,12 +1157,14 @@ pub const Application = extern struct {
}
continue;
};
- defer file.close();
+ defer file.close(global.io());
const css_file_size_limit = 5 * 1024 * 1024; // 5MB
log.info("loading gtk-custom-css path={s}", .{path});
- const contents = file.readToEndAlloc(
+
+ const contents = compat_file.readToEndAlloc(
+ file,
alloc,
css_file_size_limit,
) catch |err| switch (err) {
@@ -1111,6 +1174,7 @@ pub const Application = extern struct {
},
else => |e| return e,
};
+
defer alloc.free(contents);
const bytes = glib.Bytes.new(contents.ptr, contents.len);
@@ -1141,7 +1205,8 @@ pub const Application = extern struct {
fn syncActionAccelerators(self: *Self) void {
self.syncActionAccelerator("app.quit", .{ .quit = {} });
- self.syncActionAccelerator("app.open-config", .{ .open_config = {} });
+ self.syncActionAccelerator("app.open-config::os-open", .{ .open_config = .os_open });
+ self.syncActionAccelerator("app.open-config::new-window", .{ .open_config = .new_window });
self.syncActionAccelerator("app.reload-config", .{ .reload_config = {} });
self.syncActionAccelerator("win.toggle-inspector", .{ .inspector = .toggle });
self.syncActionAccelerator("app.show-gtk-inspector", .show_gtk_inspector);
@@ -1400,8 +1465,8 @@ pub const Application = extern struct {
fn startupSignals(self: *Self) void {
const priv = self.private();
assert(priv.signal_source == null);
- priv.signal_source = glib.unixSignalAdd(
- std.posix.SIG.USR2,
+ priv.signal_source = glibunix.signalAdd(
+ @intFromEnum(std.posix.SIG.USR2),
handleSigusr2,
self,
);
@@ -1415,14 +1480,22 @@ pub const Application = extern struct {
const as_variant_type = glib.VariantType.new("as");
defer as_variant_type.free();
+ const tas_variant_type = glib.VariantType.new("(tas)");
+ defer tas_variant_type.free();
+
+ const s_variant_type = glib.ext.VariantType.newFor([:0]const u8);
+ defer s_variant_type.free();
+
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("new-tab", actionNewTab, tas_variant_type),
+ .init("open-config", actionOpenConfig, s_variant_type),
.init("present-surface", actionPresentSurface, t_variant_type),
.init("quit", actionQuit, null),
.init("reload-config", actionReloadConfig, null),
.init("toggle-quick-terminal", actionToggleQuickTerminal, null),
+ .init("ring-bell", actionRingBell, null),
};
ext.actions.add(Self, self, &actions);
@@ -1454,6 +1527,14 @@ pub const Application = extern struct {
self,
.{},
);
+
+ _ = GlobalShortcuts.signals.@"bind-failed".connect(
+ priv.global_shortcuts,
+ *Application,
+ globalShortcutBindFailed,
+ self,
+ .{},
+ );
}
fn activate(self: *Self) callconv(.c) void {
@@ -1461,7 +1542,7 @@ pub const Application = extern struct {
// Queue a new window
const priv = self.private();
- _ = priv.core_app.mailbox.push(.{
+ _ = priv.core_app.mailbox.push(global.io(), .{
.new_window = .{},
}, .{ .forever = {} });
@@ -1478,7 +1559,7 @@ pub const Application = extern struct {
diag.close();
diag.unref(); // strong ref from get()
}
- priv.config_errors_dialog.set(null);
+ priv.config_errors_dialog.deinit();
if (priv.signal_source) |v| {
if (glib.Source.remove(v) == 0) {
log.warn("unable to remove signal source", .{});
@@ -1486,6 +1567,11 @@ pub const Application = extern struct {
priv.signal_source = null;
}
+ if (priv.bell_media) |v| {
+ v.unref();
+ priv.bell_media = null;
+ }
+
gobject.Object.virtual_methods.dispose.call(
Class.parent,
self.as(Parent),
@@ -1662,6 +1748,41 @@ pub const Application = extern struct {
};
}
+ /// May fire before any window exists, hence a desktop notification
+ /// rather than a toast.
+ fn globalShortcutBindFailed(
+ _: *GlobalShortcuts,
+ failure: *const GlobalShortcuts.BindFailed,
+ self: *Self,
+ ) callconv(.c) void {
+ var label_buf: [128]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&label_buf);
+ const label: []const u8 = label: {
+ const ok = key.labelFromTrigger(&writer, failure.trigger) catch false;
+ break :label if (ok) writer.buffered() else "?";
+ };
+
+ const detail: [*:0]const u8 = detail: {
+ if (failure.message[0] != 0) break :detail failure.message;
+ break :detail if (failure.revoked)
+ i18n._("The keybind was revoked by the system.")
+ else
+ i18n._("The keybind was denied by the system.");
+ };
+
+ var body_buf: [512]u8 = undefined;
+ const body = std.fmt.bufPrintZ(
+ &body_buf,
+ "{s}: {s}",
+ .{ label, detail },
+ ) catch return;
+
+ Action.desktopNotification(self, .app, .{
+ .title = std.mem.span(i18n._("Global keybind unavailable")),
+ .body = body,
+ });
+ }
+
fn actionReloadConfig(
_: *gio.SimpleAction,
_: ?*glib.Variant,
@@ -1703,93 +1824,227 @@ pub const Application = extern struct {
) callconv(.c) void {
log.debug("received new window action", .{});
- var arena: std.heap.ArenaAllocator = .init(Application.default().allocator());
+ var arena: std.heap.ArenaAllocator = .init(self.core().alloc);
defer arena.deinit();
const alloc = arena.allocator();
- var working_directory: ?[:0]const u8 = null;
- var title: ?[:0]const u8 = null;
- var command: ?configpkg.Command = null;
- var args: std.ArrayList([:0]const u8) = .empty;
-
- overrides: {
+ const overrides = overrides: {
// were we given a parameter?
- const parameter = parameter_ orelse break :overrides;
+ const arguments = parameter_ orelse break :overrides null;
const as_variant_type = glib.VariantType.new("as");
defer as_variant_type.free();
// ensure that the supplied parameter is an array of strings
- if (glib.Variant.isOfType(parameter, as_variant_type) == 0) {
+ if (glib.Variant.isOfType(arguments, as_variant_type) == 0) {
log.warn("parameter is of type '{s}', not '{s}'", .{
- parameter.getTypeString(),
+ arguments.getTypeString(),
as_variant_type.peekString()[0..as_variant_type.getStringLength()],
});
- break :overrides;
+ break :overrides null;
}
- const s_variant_type = glib.VariantType.new("s");
- defer s_variant_type.free();
+ var arguments_it: glib.VariantIter = undefined;
+ _ = arguments_it.init(arguments);
- var it: glib.VariantIter = undefined;
- _ = it.init(parameter);
+ break :overrides parseOverrides(alloc, &arguments_it) catch null;
+ };
- var e_seen: bool = false;
- var i: usize = 0;
+ Action.newWindow(
+ self,
+ null,
+ if (overrides) |o| .{
+ .command = o.command,
+ .shell_integration = o.shell_integration,
+ .working_directory = o.working_directory,
+ .title = o.title,
+ } else .none,
+ ) catch |err| {
+ log.warn("unable to create new window: {t}", .{err});
+ };
+ }
- while (it.nextValue()) |value| : (i += 1) {
- defer value.unref();
+ /// Handle `app.new-tab` GTK action
+ pub fn actionNewTab(
+ _: *gio.SimpleAction,
+ parameter_: ?*glib.Variant,
+ self: *Self,
+ ) callconv(.c) void {
+ log.debug("received new tab action", .{});
- // just to be sure
- if (value.isOfType(s_variant_type) == 0) continue;
+ const core_app = self.core();
- var len: usize = undefined;
- const buf = value.getString(&len);
- const str = buf[0..len];
+ var arena: std.heap.ArenaAllocator = .init(core_app.alloc);
+ defer arena.deinit();
- log.debug("new-window argument: {d} {s}", .{ i, str });
+ const alloc = arena.allocator();
- if (e_seen) {
- const duplicated = alloc.dupeZ(u8, str) catch |err| {
- log.warn("unable to duplicate argument {d} {s}: {t}", .{ i, str, err });
- break :overrides;
- };
- args.append(alloc, duplicated) catch |err| {
- log.warn("unable to append argument {d} {s}: {t}", .{ i, str, err });
- break :overrides;
- };
- continue;
- }
+ const surface_id_, const overrides = result: {
+ // were we given a parameter?
+ const parameter = parameter_ orelse {
+ log.warn("app.new-tab did not receive a parameter", .{});
+ return;
+ };
- if (std.mem.eql(u8, str, "-e")) {
- e_seen = true;
- continue;
- }
+ log.warn("got parameter: {s}", .{parameter.getTypeString()});
- if (lib.cutPrefix(u8, str, "--command=")) |v| {
- var cmd: configpkg.Command = undefined;
- cmd.parseCLI(alloc, v) catch |err| {
- log.warn("unable to parse command: {t}", .{err});
- continue;
- };
- command = cmd;
- continue;
- }
- if (lib.cutPrefix(u8, str, "--working-directory=")) |v| {
- working_directory = alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| wd: {
- log.warn("unable to duplicate working directory: {t}", .{err});
- break :wd null;
- };
- continue;
- }
- if (lib.cutPrefix(u8, str, "--title=")) |v| {
- title = alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| t: {
- log.warn("unable to duplicate title: {t}", .{err});
- break :t null;
- };
+ const tas_variant_type = glib.VariantType.new("(tas)");
+ defer tas_variant_type.free();
+
+ // ensure that the supplied parameter is an array of strings
+ if (glib.Variant.isOfType(parameter, tas_variant_type) == 0) {
+ log.warn("parameter is of type '{s}', not '{s}'", .{
+ parameter.getTypeString(),
+ tas_variant_type.peekString()[0..tas_variant_type.getStringLength()],
+ });
+ return;
+ }
+
+ var surface_id: u64 = 0;
+ var arguments_it_: ?*glib.VariantIter = null;
+ defer if (arguments_it_) |arguments_it| arguments_it.free();
+
+ parameter.get("(tas)", &surface_id, &arguments_it_);
+
+ const arguments_it = arguments_it_ orelse return;
+
+ const overrides = parseOverrides(alloc, arguments_it) catch return;
+
+ break :result .{ if (surface_id == 0) null else surface_id, overrides };
+ };
+
+ const surface_ = surface: {
+ if (surface_id_) |surface_id| find_by_id: {
+ break :surface core_app.findSurfaceByID(surface_id) orelse {
+ log.warn("new-tab: unable to find surface 0x{x:0>16}", .{surface_id});
+ break :find_by_id;
+ };
+ }
+ find_focused: {
+ break :surface core_app.focusedSurface() orelse {
+ log.warn("new-tab: unable to find surface", .{});
+ break :find_focused;
+ };
+ }
+ break :surface null;
+ };
+
+ if (surface_) |surface| {
+ if (!Action.newTab(
+ .{
+ .surface = surface,
+ },
+ .{
+ .command = overrides.command,
+ .shell_integration = overrides.shell_integration,
+ .working_directory = overrides.working_directory,
+ .title = overrides.title,
+ },
+ )) {
+ log.warn("new-tab: unable to create tab", .{});
+ }
+ } else {
+ Action.newWindow(
+ self,
+ null,
+ .{
+ .command = overrides.command,
+ .shell_integration = overrides.shell_integration,
+ .working_directory = overrides.working_directory,
+ .title = overrides.title,
+ },
+ ) catch |err| {
+ log.warn("new-tab: unable to create new window: {t}", .{err});
+ };
+ }
+ }
+
+ fn parseOverrides(arena_alloc: Allocator, arguments_it: *glib.VariantIter) (Allocator.Error || error{ValueRequired})!struct {
+ command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
+ working_directory: ?[:0]const u8 = null,
+ title: ?[:0]const u8 = null,
+ } {
+ var args: std.ArrayList([:0]const u8) = .empty;
+
+ var working_directory: ?[:0]const u8 = null;
+ var title: ?[:0]const u8 = null;
+ var command: ?configpkg.Command = null;
+ var parsed_shell_integration: struct {
+ @"shell-integration": ?configpkg.Config.ShellIntegration = null,
+ } = .{};
+
+ const s_variant_type = glib.VariantType.new("s");
+ defer s_variant_type.free();
+
+ var e_seen: bool = false;
+ var i: usize = 0;
+
+ while (arguments_it.nextValue()) |value| : (i += 1) {
+ defer value.unref();
+
+ // just to be sure
+ if (value.isOfType(s_variant_type) == 0) continue;
+
+ var len: usize = undefined;
+ const buf = value.getString(&len);
+ const str = buf[0..len];
+
+ log.debug("argument: {d} {s}", .{ i, str });
+
+ if (e_seen) {
+ const copy = arena_alloc.dupeZ(u8, str) catch |err| {
+ log.warn("unable to duplicate argument {d} {s}: {t}", .{ i, str, err });
+ return err;
+ };
+ args.append(arena_alloc, copy) catch |err| {
+ log.warn("unable to append argument {d} {s}: {t}", .{ i, str, err });
+ return err;
+ };
+ continue;
+ }
+
+ if (std.mem.eql(u8, str, "-e")) {
+ e_seen = true;
+ continue;
+ }
+
+ if (std.mem.cutPrefix(u8, str, "--command=")) |v| {
+ var cmd: configpkg.Command = undefined;
+ cmd.parseCLI(arena_alloc, v) catch |err| {
+ log.warn("unable to parse command: {t}", .{err});
+ return err;
+ };
+ command = cmd;
+ continue;
+ }
+ if (std.mem.cutPrefix(u8, str, "--shell-integration=")) |v| {
+ cli.args.parseIntoField(
+ @TypeOf(parsed_shell_integration),
+ arena_alloc,
+ &parsed_shell_integration,
+ "shell-integration",
+ std.mem.trim(u8, v, &std.ascii.whitespace),
+ ) catch |err| {
+ log.warn("unable to parse shell integration {s}: {t}", .{ v, err });
continue;
- }
+ };
+ continue;
+ }
+ if (std.mem.cutPrefix(u8, str, "--working-directory=")) |v| {
+ working_directory = arena_alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| {
+ log.warn("unable to duplicate working directory: {t}", .{err});
+ return err;
+ };
+ continue;
+ }
+ if (std.mem.cutPrefix(u8, str, "--title=")) |v| {
+ title = arena_alloc.dupeZ(u8, std.mem.trim(u8, v, &std.ascii.whitespace)) catch |err| {
+ log.warn("unable to duplicate title: {t}", .{err});
+ return err;
+ };
+ continue;
}
}
@@ -1799,21 +2054,52 @@ pub const Application = extern struct {
};
}
- Action.newWindow(self, null, .{
+ return .{
.command = command,
+ .shell_integration = parsed_shell_integration.@"shell-integration",
.working_directory = working_directory,
.title = title,
- }) catch |err| {
- log.warn("unable to create new window: {t}", .{err});
};
}
pub fn actionOpenConfig(
_: *gio.SimpleAction,
- _: ?*glib.Variant,
+ parameter_: ?*glib.Variant,
self: *Self,
) callconv(.c) void {
- _ = self.core().mailbox.push(.open_config, .forever);
+ const target: CoreApp.Message.OpenConfig = target: {
+ const target_map: std.StaticStringMap(CoreApp.Message.OpenConfig) = .initComptime(&.{
+ .{ "os-open", .os_open },
+ .{ "new-window", .new_window },
+ });
+
+ const parameter = parameter_ orelse {
+ log.warn("no parameter provided to app.open-config action", .{});
+ break :target .os_open;
+ };
+
+ const s_variant_type = glib.ext.VariantType.newFor([:0]const u8);
+ defer s_variant_type.free();
+
+ if (parameter.isOfType(s_variant_type) == 0) {
+ log.warn("parameter to app.open-config action is of type '{s}' not '{s}'", .{
+ parameter.getTypeString(),
+ s_variant_type.peekString()[0..s_variant_type.getStringLength()],
+ });
+ break :target .os_open;
+ }
+
+ var len: usize = undefined;
+ const buf = parameter.getString(&len);
+ const str = buf[0..len];
+
+ break :target target_map.get(str) orelse {
+ log.warn("'{s}' is not configured as a target for the app.open-config action", .{str});
+ break :target .os_open;
+ };
+ };
+
+ _ = self.core().mailbox.push(global.io(), .{ .open_config = target }, .forever);
}
fn actionPresentSurface(
@@ -1839,6 +2125,7 @@ pub const Application = extern struct {
const surface = self.core().findSurfaceByID(surface_id) orelse return;
_ = self.core().mailbox.push(
+ global.io(),
.{
.surface_message = .{
.surface = surface,
@@ -1849,6 +2136,40 @@ pub const Application = extern struct {
);
}
+ pub fn actionRingBell(
+ _: *gio.SimpleAction,
+ _: ?*glib.Variant,
+ self: *Self,
+ ) callconv(.c) void {
+ const priv: *Private = self.private();
+ const config = priv.config.get();
+
+ // Do our sound
+ if (config.@"bell-features".audio) audio: {
+ const config_path = config.@"bell-audio-path" orelse break :audio;
+ const path, const required = switch (config_path) {
+ .optional => |path| .{ path, false },
+ .required => |path| .{ path, true },
+ };
+
+ const volume = std.math.clamp(
+ config.@"bell-audio-volume",
+ 0.0,
+ 1.0,
+ );
+
+ // Reuse one MediaFile per application (rebuilt only when the path
+ // changes) so each bell replays the same pipeline instead of
+ // leaking a fresh one. Assign unconditionally: bellMediaFile frees
+ // any stale MediaFile and returns the current slot value (possibly
+ // null if the path is now inaccessible), so priv.bell_media never
+ // dangles.
+ priv.bell_media = media.bellMediaFile(priv.bell_media, path, required);
+ const media_file = priv.bell_media orelse break :audio;
+ media.playBell(media_file, volume);
+ }
+ }
+
//----------------------------------------------------------------
// Boilerplate/Noise
@@ -1866,11 +2187,8 @@ pub const Application = extern struct {
fn init(class: *Class) callconv(.c) void {
// Register our compiled resources exactly once.
{
- const c = @cImport({
- // generated header files
- @cInclude("ghostty_resources.h");
- });
- if (c.ghostty_get_resource()) |ptr| {
+ const ghostty_gtk_resources = @import("ghostty_gtk_resources");
+ if (ghostty_gtk_resources.ghostty_get_resource()) |ptr| {
gio.resourcesRegister(@ptrCast(@alignCast(ptr)));
} else {
// If we fail to load resources then things will
@@ -1894,11 +2212,11 @@ pub const Application = extern struct {
};
pub fn openUrlFallback(self: *Application, kind: apprt.action.OpenUrl.Kind, url: []const u8) void {
+ _ = self;
// Fallback to the minimal cross-platform way of opening a URL.
// This is always a safe fallback and enables for example Windows
// to open URLs (GTK on Windows via WSL is a thing).
internal_os.open(
- self.allocator(),
kind,
url,
) catch |err| log.warn("unable to open url: {}", .{err});
@@ -1938,6 +2256,98 @@ const Action = struct {
};
}
+ pub fn exportTerminalIO(
+ self: *Application,
+ target: apprt.Target,
+ value: apprt.Action.Value(.export_terminal_io),
+ ) Allocator.Error!bool {
+ const surface = switch (target) {
+ .app => return false,
+ .surface => |v| v.rt_surface.gobj(),
+ };
+
+ const alloc = self.allocator();
+ const contents = try alloc.dupe(u8, value.contents);
+ errdefer alloc.free(contents);
+ const request = try alloc.create(ExportTerminalIORequest);
+ errdefer alloc.destroy(request);
+ request.* = .{
+ .alloc = alloc,
+ .contents = contents,
+ };
+
+ const parent = ext.getAncestor(gtk.Window, surface.as(gtk.Widget));
+ const dialog = gtk.FileChooserNative.new(
+ i18n._("Export Terminal IO Events"),
+ parent,
+ .save,
+ i18n._("Export"),
+ i18n._("Cancel"),
+ );
+ const chooser = dialog.as(gtk.FileChooser);
+ chooser.setCreateFolders(1);
+ chooser.setCurrentName("ghostty-terminal-io.txt");
+
+ _ = gtk.NativeDialog.signals.response.connect(
+ dialog,
+ *ExportTerminalIORequest,
+ ExportTerminalIORequest.response,
+ request,
+ .{ .destroyData = ExportTerminalIORequest.destroy },
+ );
+ dialog.as(gtk.NativeDialog).show();
+ return true;
+ }
+
+ const ExportTerminalIORequest = struct {
+ alloc: Allocator,
+ contents: []u8,
+
+ fn destroy(self: *ExportTerminalIORequest) callconv(.c) void {
+ self.alloc.free(self.contents);
+ self.alloc.destroy(self);
+ }
+
+ fn response(
+ dialog: *gtk.FileChooserNative,
+ response_id: c_int,
+ self: *ExportTerminalIORequest,
+ ) callconv(.c) void {
+ defer dialog.unref();
+
+ if (response_id != @intFromEnum(gtk.ResponseType.accept)) return;
+
+ const file = dialog.as(gtk.FileChooser).getFile() orelse {
+ log.warn("inspector export dialog returned no file", .{});
+ return;
+ };
+ defer file.unref();
+
+ var gerr: ?*glib.Error = null;
+ const replaced = file.replaceContents(
+ self.contents.ptr,
+ self.contents.len,
+ null,
+ 0,
+ .{},
+ null,
+ null,
+ &gerr,
+ );
+ if (gerr) |err| {
+ defer err.free();
+ log.err(
+ "failed to export terminal IO events err={s}",
+ .{err.f_message orelse "(unknown)"},
+ );
+ return;
+ }
+ if (replaced == 0) {
+ log.err("failed to export terminal IO events", .{});
+ }
+ }
+ };
+
pub fn configChange(
self: *Application,
target: apprt.Target,
@@ -2202,6 +2612,26 @@ const Action = struct {
}
}
+ pub fn moveTabToNewWindow(
+ target: apprt.Target,
+ ) bool {
+ switch (target) {
+ .app => return false,
+ .surface => |core| {
+ const surface = core.rt_surface.surface;
+ const window = ext.getAncestor(
+ Window,
+ surface.as(gtk.Widget),
+ ) orelse {
+ log.warn("surface is not in a window, ignoring new_tab_to_new_window", .{});
+ return false;
+ };
+
+ return window.moveTabToNewWindow(surface);
+ },
+ }
+ }
+
pub fn newSplit(
target: apprt.Target,
direction: apprt.action.SplitDirection,
@@ -2224,7 +2654,17 @@ const Action = struct {
}
}
- pub fn newTab(target: apprt.Target) bool {
+ pub fn newTab(
+ target: apprt.Target,
+ overrides: struct {
+ command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
+ working_directory: ?[:0]const u8 = null,
+ title: ?[:0]const u8 = null,
+
+ pub const none: @This() = .{};
+ },
+ ) bool {
switch (target) {
.app => {
log.warn("new tab to app is unexpected", .{});
@@ -2243,7 +2683,12 @@ const Action = struct {
log.warn("surface is not in a window, ignoring new_tab", .{});
return false;
};
- window.newTab(core);
+ window.newTab(core, .{
+ .command = overrides.command,
+ .shell_integration = overrides.shell_integration,
+ .working_directory = overrides.working_directory,
+ .title = overrides.title,
+ });
return true;
},
}
@@ -2254,6 +2699,7 @@ const Action = struct {
parent: ?*CoreSurface,
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -2276,6 +2722,7 @@ const Action = struct {
parent,
.{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
},
@@ -2288,6 +2735,7 @@ const Action = struct {
parent: ?*CoreSurface,
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -2308,6 +2756,7 @@ const Action = struct {
// Create a new tab with window context (first tab in new window)
win.newTabForWindow(parent, .{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
});
@@ -2328,18 +2777,55 @@ const Action = struct {
gtk.Window.present(win.as(gtk.Window));
}
- pub fn openConfig(self: *Application) bool {
- // Get the config file path
+ pub fn openConfig(self: *Application, value: apprt.action.OpenConfig) bool {
const alloc = self.allocator();
+
+ // Get the config file path
const path = configpkg.edit.openPath(alloc) catch |err| {
- log.warn("error getting config file path: {}", .{err});
+ log.warn("error getting config file path: {t}", .{err});
return false;
};
defer alloc.free(path);
- // Open it using openURL. "path" isn't actually a URL but
- // at the time of writing that works just fine for GTK.
- openUrl(self, .{ .kind = .text, .url = path });
+ switch (value) {
+ .os_open => {
+ // Open it using openUrl. "path" isn't actually a URL but
+ // at the time of writing that works just fine for GTK.
+ openUrl(self, .{ .kind = .text, .url = path });
+ },
+
+ .new_window => {
+ const cmd = internal_os.getConfigEditCommand(alloc, path, .default) catch |err| {
+ log.warn("unable to get command to edit the config: {t}", .{err});
+ return false;
+ };
+ defer alloc.free(cmd);
+
+ const command: configpkg.Command = .{
+ .direct = &.{ "/bin/sh", "-c", cmd },
+ };
+
+ const title = std.fmt.allocPrintSentinel(
+ alloc,
+ "{s} {s}",
+ .{ i18n._("Editing configuration file"), path },
+ 0,
+ ) catch |err| t: {
+ log.warn("unable to format title: {t}", .{err});
+ break :t null;
+ };
+ defer if (title) |t| alloc.free(t);
+
+ Action.newWindow(self, null, .{
+ .command = command,
+ .title = title,
+ }) catch |err| {
+ log.warn("unable to create new window: {t}", .{err});
+ return false;
+ };
+ },
+ }
+
return true;
}
@@ -2434,6 +2920,23 @@ const Action = struct {
},
}
},
+ .window => {
+ switch (target) {
+ .app => return false,
+ .surface => |v| {
+ const surface = v.rt_surface.surface;
+ const win = ext.getAncestor(
+ Window,
+ surface.as(gtk.Widget),
+ ) orelse {
+ log.warn("surface is not in a window, ignoring prompt_window_title", .{});
+ return false;
+ };
+ win.promptWindowTitle();
+ return true;
+ },
+ }
+ },
}
}
@@ -2605,6 +3108,30 @@ const Action = struct {
}
}
+ pub fn setWindowTitle(
+ target: apprt.Target,
+ value: apprt.action.SetTitle,
+ ) bool {
+ switch (target) {
+ .app => {
+ log.warn("set_tab_title to app is unexpected", .{});
+ return false;
+ },
+ .surface => |core| {
+ const surface = core.rt_surface.surface;
+ const window = ext.getAncestor(
+ Window,
+ surface.as(gtk.Widget),
+ ) orelse {
+ log.warn("surface is not in a window, ignoring set_window_title", .{});
+ return false;
+ };
+ window.setTitleOverride(if (value.title.len == 0) null else value.title);
+ return true;
+ },
+ }
+ }
+
pub fn showChildExited(
target: apprt.Target,
value: apprt.surface.Message.ChildExited,
@@ -2846,7 +3373,7 @@ const Action = struct {
/// given the runtime environment or configuration.
///
/// This must be called BEFORE GTK initialization.
-fn setGtkEnv(config: *const CoreConfig) error{NoSpaceLeft}!void {
+fn setGtkEnv(config: *const CoreConfig) std.Io.Writer.Error!void {
assert(gtk.isInitialized() == 0);
var gdk_debug: struct {
@@ -2863,7 +3390,7 @@ fn setGtkEnv(config: *const CoreConfig) error{NoSpaceLeft}!void {
} = .{
// `gtk-opengl-debug` dumps logs directly to stderr so both must be true
// to enable OpenGL debugging.
- .opengl = state.logging.stderr and config.@"gtk-opengl-debug",
+ .opengl = global.logging().stderr and config.@"gtk-opengl-debug",
};
var gdk_disable: struct {
@@ -2915,8 +3442,7 @@ fn setGtkEnv(config: *const CoreConfig) error{NoSpaceLeft}!void {
{
var buf: [1024]u8 = undefined;
- var fmt = std.io.fixedBufferStream(&buf);
- const writer = fmt.writer();
+ var writer: std.Io.Writer = .fixed(&buf);
var first: bool = true;
inline for (@typeInfo(@TypeOf(gdk_debug)).@"struct".fields) |field| {
if (@field(gdk_debug, field.name)) {
@@ -2926,15 +3452,14 @@ fn setGtkEnv(config: *const CoreConfig) error{NoSpaceLeft}!void {
}
}
try writer.writeByte(0);
- const value = fmt.getWritten();
+ const value = writer.buffered();
log.warn("setting GDK_DEBUG={s}", .{value[0 .. value.len - 1]});
- _ = internal_os.setenv("GDK_DEBUG", value[0 .. value.len - 1 :0]);
+ _ = setenv("GDK_DEBUG", @ptrCast(value[0 .. value.len - 1 :0]), 1);
}
{
var buf: [1024]u8 = undefined;
- var fmt = std.io.fixedBufferStream(&buf);
- const writer = fmt.writer();
+ var writer: std.Io.Writer = .fixed(&buf);
var first: bool = true;
inline for (@typeInfo(@TypeOf(gdk_disable)).@"struct".fields) |field| {
if (@field(gdk_disable, field.name)) {
@@ -2944,10 +3469,13 @@ fn setGtkEnv(config: *const CoreConfig) error{NoSpaceLeft}!void {
}
}
try writer.writeByte(0);
- const value = fmt.getWritten();
+ const value = writer.buffered();
log.warn("setting GDK_DISABLE={s}", .{value[0 .. value.len - 1]});
- _ = internal_os.setenv("GDK_DISABLE", value[0 .. value.len - 1 :0]);
+ _ = setenv("GDK_DISABLE", @ptrCast(value[0 .. value.len - 1 :0]), 1);
}
+
+ // Sync environ after altering system env
+ global.syncEnviron();
}
fn findActiveWindow(data: ?*const anyopaque, _: ?*const anyopaque) callconv(.c) c_int {
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/clipboard_confirmation_dialog.zig b/vendor/libghostty-vt/src/apprt/gtk/class/clipboard_confirmation_dialog.zig
index d44d38a3..d993b55c 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/clipboard_confirmation_dialog.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/clipboard_confirmation_dialog.zig
@@ -193,11 +193,11 @@ pub const ClipboardConfirmationDialog = extern struct {
const priv = self.private();
const req = priv.request orelse return;
switch (req.*) {
- .osc_52_write => {
+ .osc_52_write, .kitty_write => {
self.as(Dialog.Parent).setHeading(i18n._("Authorize Clipboard Access"));
self.as(Dialog.Parent).setBody(i18n._("An application is attempting to write to the clipboard. The current clipboard contents are shown below."));
},
- .osc_52_read => {
+ .osc_52_read, .kitty_read => {
self.as(Dialog.Parent).setHeading(i18n._("Authorize Clipboard Access"));
self.as(Dialog.Parent).setBody(i18n._("An application is attempting to read from the clipboard. The current clipboard contents are shown below."));
},
@@ -205,6 +205,7 @@ pub const ClipboardConfirmationDialog = extern struct {
self.as(Dialog.Parent).setHeading(i18n._("Warning: Potentially Unsafe Paste"));
self.as(Dialog.Parent).setBody(i18n._("Pasting this text into the terminal may be dangerous as it looks like some commands may be executed."));
},
+ .list => unreachable,
}
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/command_palette.zig b/vendor/libghostty-vt/src/apprt/gtk/class/command_palette.zig
index 6101e82e..aaec0058 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/command_palette.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/command_palette.zig
@@ -153,7 +153,7 @@ pub const CommandPalette = extern struct {
priv.source.removeAll();
const alloc = Application.default().allocator();
- var commands: std.ArrayList(*Command) = .{};
+ var commands: std.ArrayList(*Command) = .empty;
defer {
for (commands.items) |cmd| cmd.unref();
commands.deinit(alloc);
@@ -581,10 +581,8 @@ const Command = extern struct {
const priv = self.private();
priv.data = .{
- .jump = .{
- // TODO: Replace with surface id whenever Ghostty adds one
- .sort_key = @intFromPtr(surface),
- },
+ // Surface should be initialized at this point.
+ .jump = .{ .sort_key = surface.core().?.id },
};
priv.data.jump.surface.set(surface);
@@ -611,7 +609,7 @@ const Command = extern struct {
switch (priv.data) {
.regular => {},
.jump => |*j| {
- j.surface.set(null);
+ j.surface.deinit();
},
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/global_shortcuts.zig b/vendor/libghostty-vt/src/apprt/gtk/class/global_shortcuts.zig
index 28987c25..88aaba9f 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/global_shortcuts.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/global_shortcuts.zig
@@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator;
const gio = @import("gio");
const glib = @import("glib");
const gobject = @import("gobject");
+const global = @import("../../../global.zig");
const Binding = @import("../../../input.zig").Binding;
const key = @import("../key.zig");
@@ -82,6 +83,24 @@ pub const GlobalShortcuts = extern struct {
pub var offset: c_int = 0;
};
+ /// A global shortcut that failed to bind or was revoked.
+ /// Only valid for the duration of the signal emission.
+ pub const BindFailed = struct {
+ trigger: Binding.Trigger,
+ action: Binding.Action,
+
+ /// May be empty.
+ message: [*:0]const u8,
+
+ /// Revoked after binding rather than denied up front.
+ revoked: bool,
+
+ pub const getGObjectType = gobject.ext.defineBoxed(
+ BindFailed,
+ .{ .name = "GhosttyGlobalShortcutsBindFailed" },
+ );
+ };
+
pub const signals = struct {
/// Emitted whenever a global shortcut is triggered.
pub const trigger = struct {
@@ -94,6 +113,18 @@ pub const GlobalShortcuts = extern struct {
void,
);
};
+
+ /// Emitted when a global shortcut fails to bind or is revoked.
+ pub const @"bind-failed" = struct {
+ pub const name = "bind-failed";
+ pub const connect = impl.connect;
+ const impl = gobject.ext.defineSignal(
+ name,
+ Self,
+ &.{*const BindFailed},
+ void,
+ );
+ };
};
fn init(self: *Self, _: *Class) callconv(.c) void {
@@ -109,6 +140,10 @@ pub const GlobalShortcuts = extern struct {
fn close(self: *Self) void {
const priv = self.private();
+ // This is safe to call even if the winproto was already
+ // deinitialized, which happens during application teardown.
+ Application.default().winproto().clearGlobalShortcuts();
+
if (priv.dbus_connection) |dbus| {
if (priv.response_subscription != 0) {
dbus.signalUnsubscribe(priv.response_subscription);
@@ -152,10 +187,19 @@ pub const GlobalShortcuts = extern struct {
const priv = self.private();
- // We need a dbus connection and configuration to proceed.
- if (priv.dbus_connection == null) return;
+ // We need a configuration to proceed.
const config = if (priv.config) |v| v.get() else return;
+ // Prefer a windowing protocol native mechanism over the
+ // XDG desktop portal when available.
+ if (Application.default().winproto().bindGlobalShortcuts(self, config)) {
+ log.debug("global shortcuts bound via winproto", .{});
+ return;
+ }
+
+ // The portal fallback requires a dbus connection.
+ if (priv.dbus_connection == null) return;
+
// Setup our new arena that we'll use for memory allocations.
assert(priv.arena == null);
var arena: std.heap.ArenaAllocator = .init(Application.default().allocator());
@@ -558,10 +602,25 @@ pub const GlobalShortcuts = extern struct {
log.debug("activated={s}", .{shortcut_id});
const action = self.private().map.get(std.mem.span(shortcut_id)) orelse return;
+ self.emitTrigger(&action);
+ }
+
+ /// Emit the trigger signal. Public for winproto shortcut backends.
+ pub fn emitTrigger(self: *Self, action: *const Binding.Action) void {
signals.trigger.impl.emit(
self,
null,
- .{&action},
+ .{action},
+ null,
+ );
+ }
+
+ /// Emit the bind-failed signal. Public for winproto shortcut backends.
+ pub fn emitBindFailed(self: *Self, failure: *const BindFailed) void {
+ signals.@"bind-failed".impl.emit(
+ self,
+ null,
+ .{failure},
null,
);
}
@@ -611,6 +670,7 @@ pub const GlobalShortcuts = extern struct {
// Signals
signals.trigger.impl.register(.{});
+ signals.@"bind-failed".impl.register(.{});
// Virtual methods
gobject.Object.virtual_methods.dispose.implement(class, &dispose);
@@ -630,6 +690,9 @@ fn generateToken(buf: *Token) [:0]const u8 {
return std.fmt.bufPrintZ(
buf,
"ghostty_{x:0<7}",
- .{std.crypto.random.int(u28)},
+ .{rand_int: {
+ const rng_impl: std.Random.IoSource = .{ .io = global.io() };
+ break :rand_int rng_impl.interface().int(u28);
+ }},
) catch unreachable;
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/imgui_widget.zig b/vendor/libghostty-vt/src/apprt/gtk/class/imgui_widget.zig
index 0ef753a8..50247fbf 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/imgui_widget.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/imgui_widget.zig
@@ -7,6 +7,7 @@ const adw = @import("adw");
const gdk = @import("gdk");
const gobject = @import("gobject");
const gtk = @import("gtk");
+const global = @import("../../../global.zig");
const input = @import("../../../input.zig");
const gresource = @import("../build/gresource.zig");
@@ -61,13 +62,13 @@ pub const ImguiWidget = extern struct {
ig_context: ?*cimgui.c.ImGuiContext = null,
/// Our previous instant used to calculate delta time for animations.
- instant: ?std.time.Instant = null,
+ instant: ?std.Io.Timestamp = null,
/// Tick callback ID for timed updates.
tick_callback_id: c_uint = 0,
/// Last render time for throttling to 30 FPS.
- last_render_time: ?std.time.Instant = null,
+ last_render_time: ?std.Io.Timestamp = null,
pub var offset: c_int = 0;
};
@@ -140,10 +141,11 @@ pub const ImguiWidget = extern struct {
const priv = self.private();
const io: *cimgui.c.ImGuiIO = cimgui.c.ImGui_GetIO();
+ const now: std.Io.Timestamp = .now(global.io(), .awake);
+
// Determine our delta time
- const now = std.time.Instant.now() catch unreachable;
io.DeltaTime = if (priv.instant) |prev| delta: {
- const since_ns: f64 = @floatFromInt(now.since(prev));
+ const since_ns: f64 = @floatFromInt(prev.durationTo(now).nanoseconds);
const ns_per_s: f64 = @floatFromInt(std.time.ns_per_s);
const since_s: f32 = @floatCast(since_ns / ns_per_s);
break :delta @max(0.00001, since_s);
@@ -298,7 +300,7 @@ pub const ImguiWidget = extern struct {
// Update last render time for tick callback throttling.
const priv = self.private();
- priv.last_render_time = std.time.Instant.now() catch null;
+ priv.last_render_time = .now(global.io(), .awake);
// Setup our frame. We render twice because some ImGui behaviors
// take multiple renders to process. I don't know how to make this
@@ -457,15 +459,10 @@ pub const ImguiWidget = extern struct {
const self: *Self = gobject.ext.cast(Self, widget) orelse return 0;
const priv = self.private();
- const now = std.time.Instant.now() catch {
- self.queueRender();
- return 1;
- };
-
// Throttle to 30 FPS (~33ms between frames)
const frame_time_ns: u64 = std.time.ns_per_s / 30;
const should_render = if (priv.last_render_time) |last|
- now.since(last) >= frame_time_ns
+ last.untilNow(global.io(), .awake).nanoseconds >= frame_time_ns
else
true;
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/split_tree.zig b/vendor/libghostty-vt/src/apprt/gtk/class/split_tree.zig
index 7a6b66de..ca743712 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/split_tree.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/split_tree.zig
@@ -214,6 +214,7 @@ pub const SplitTree = extern struct {
parent_: ?*Surface,
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -225,6 +226,7 @@ pub const SplitTree = extern struct {
// Create our new surface.
const surface: *Surface = .new(.{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
});
@@ -239,12 +241,7 @@ pub const SplitTree = extern struct {
}
// Bind is-split property for new surface
- _ = self.as(gobject.Object).bindProperty(
- "is-split",
- surface.as(gobject.Object),
- "is-split",
- .{ .sync_create = true },
- );
+ surface.bindIsSplit(self);
// Create our tree
var single_tree = try Surface.Tree.init(alloc, surface);
@@ -387,6 +384,77 @@ pub const SplitTree = extern struct {
return true;
}
+ /// Move the source split onto the target split in a given direction.
+ /// The target split must be located within this tree.
+ pub fn moveSplit(
+ self: *Self,
+ source: *Surface,
+ target: *Surface,
+ dir: Surface.Tree.Split.Direction,
+ ) Allocator.Error!void {
+ const alloc = Application.default().allocator();
+ const target_tree = self.getTree() orelse return;
+
+ // This really shouldn't fail, but just in case
+ const target_handle = target_tree.locate(target) orelse {
+ log.warn("target is not placed in a split tree", .{});
+ return;
+ };
+
+ // Try to find the source within the current tree.
+ // If it exists, then it's a local move; otherwise the logic gets more
+ // complicated
+ const source_handle = target_tree.locate(source);
+
+ // First add the source into this tree.
+ // We have to do this no matter what
+ var branch = try Surface.Tree.init(alloc, source);
+ defer branch.deinit();
+
+ var after_split = try target_tree.split(
+ alloc,
+ target_handle,
+ dir,
+ 0.5,
+ &branch,
+ );
+ defer after_split.deinit();
+
+ if (source_handle) |handle| {
+ // Happy path: source and target are located within the same tree.
+ // In that case, we just remove the existing source from this tree
+
+ var after_remove = try after_split.remove(alloc, handle);
+ defer after_remove.deinit();
+
+ self.setTree(&after_remove);
+ } else {
+ // :( Cross-tree moves are a bit more complicated.
+
+ // TODO: Find a better way to access the split tree from here
+ const source_tree_widget = ext.getAncestor(
+ SplitTree,
+ source.as(gtk.Widget),
+ ) orelse {
+ log.warn("source is not placed in a split tree", .{});
+ return;
+ };
+ const source_tree = source_tree_widget.getTree() orelse return;
+
+ // Remove the source from its own tree
+ const handle = source_tree.locate(source) orelse return;
+ var new_source_tree = try source_tree.remove(alloc, handle);
+ defer new_source_tree.deinit();
+
+ // Finally, set the final tree structures for both tree widgets
+ source_tree_widget.setTree(&new_source_tree);
+ self.setTree(&after_split);
+
+ // Re-bind vital properties like `is-split`
+ source.bindIsSplit(self);
+ }
+ }
+
fn disconnectSurfaceHandlers(self: *Self) void {
const tree = self.getTree() orelse return;
var it = tree.iterator();
@@ -579,7 +647,7 @@ pub const SplitTree = extern struct {
fn dispose(self: *Self) callconv(.c) void {
const priv = self.private();
- priv.last_focused.set(null);
+ priv.last_focused.deinit();
if (priv.rebuild_source) |v| {
if (glib.Source.remove(v) == 0) {
log.warn("unable to remove rebuild source", .{});
@@ -705,17 +773,8 @@ pub const SplitTree = extern struct {
// Find the surface in the tree to verify this is valid and
// set our pending close handle.
- priv.pending_close = handle: {
- const tree = self.getTree() orelse return;
- var it = tree.iterator();
- while (it.next()) |entry| {
- if (entry.view == surface) {
- break :handle entry.handle;
- }
- }
-
- return;
- };
+ const tree = self.getTree() orelse return;
+ priv.pending_close = tree.locate(surface) orelse return;
// If we don't need to confirm then just close immediately.
if (!core.needsConfirmQuit()) {
@@ -1115,12 +1174,17 @@ const SplitTreeSplit = extern struct {
/// Assumed to be correct.
handle: Surface.Tree.Node.Handle,
+ /// Cache the split ratio. Looking it up is relatively expensive
+ /// because we have to first walk the widget tree to find the
+ /// SplitTree widget.
+ ratio: f64,
+
/// Source to handle repositioning the split when properties change.
idle: ?c_uint = null,
/// Whether the max-position/position property of the gtk.Paned widget
/// changed. We use these to distinguish between a resize and the user
- /// manually moving the split divider. See the "on-idle" function.
+ /// manually moving the split divider. See the "onIdle" function.
max_changed: bool = false,
pos_changed: bool = false,
@@ -1144,6 +1208,7 @@ const SplitTreeSplit = extern struct {
const self = gobject.ext.newInstance(Self, .{});
const priv = self.private();
priv.handle = handle;
+ priv.ratio = split.ratio;
// Setup our paned fields
const paned = priv.paned;
@@ -1154,6 +1219,17 @@ const SplitTreeSplit = extern struct {
.vertical => .vertical,
});
+ // Request min width/height 1 for surfaces to prevent them from
+ // becoming temporarily invisible in nested layouts. Otherwise
+ // gtk.Paned might mark a surface as not visible and unmap it
+ // for a single frame. See the comments below in propMaxPosition.
+ if (gobject.ext.isA(start_child, SurfaceScrolledWindow)) {
+ start_child.setSizeRequest(1, 1);
+ }
+ if (gobject.ext.isA(end_child, SurfaceScrolledWindow)) {
+ end_child.setSizeRequest(1, 1);
+ }
+
// Signals and so on are setup in the template.
return self;
@@ -1163,49 +1239,18 @@ const SplitTreeSplit = extern struct {
gtk.Widget.initTemplate(self.as(gtk.Widget));
}
- // We need to keep the split ratios from the tree datastructure and
- // widget tree in sync. Using the max-position and position properties
- // of the gtk.Paned widget, we can distinguish a resize from a manual
- // update (e.g. the user dragging the divider).If max-position changes,
- // we always have a widget resize. Usually position will change as well
- // but it might not if the size change is small enough. If only position
- // changes, we have a manual human update.
- //
- // This is a hack, it relies on the timing of property notifcations.
- // From looking at the GTK source code, it should not be possible that
- // we interpret a position change from a resize as a manual update.
- // When a gtk.Paned is resized, internally the gtk_paned_calc_position
- // function will change both max-position and position and synchronously
- // call our propMaxPosition and propPosition functions. I.e. when the
- // widget is resized, it should not be possible for onIdle to run before
- // we have been notified of both property changes.
- fn onIdle(ud: ?*anyopaque) callconv(.c) c_int {
- const self: *Self = @ptrCast(@alignCast(ud orelse return 0));
+ const SyncDirection = enum {
+ // Update gtk.Paned widget to match ratio from split tree node.
+ tree_to_widget,
+ // Update split tree node to match ratio from gtk.Paned widget.
+ widget_to_tree,
+ };
+
+ // Sync split ratio between the gtk.Paned widget and the split tree.
+ fn syncSplitRatio(self: *Self, direction: SyncDirection) void {
const priv = self.private();
const paned = priv.paned;
- // Clear source and fields at the end. Otherwise if setPosition is
- // called below, propPosition is triggered and would add another
- // idle callback before this one is finished.
- defer priv.idle = null;
- defer priv.max_changed = false;
- defer priv.pos_changed = false;
-
- if (!priv.max_changed and !priv.pos_changed) {
- return 0;
- }
-
- // Get our split. This is the most dangerous part of this entire
- // widget. We assume that this widget is always a child of a
- // SplitTree, we assume that our handle is valid, and we assume
- // the handle is always a split node.
- const split_tree = ext.getAncestor(
- SplitTree,
- self.as(gtk.Widget),
- ) orelse return 0;
- const tree = split_tree.getTree() orelse return 0;
- const split: *const Surface.Tree.Split = &tree.nodes[priv.handle.idx()].split;
-
// Current, min, and max positions as pixels.
const pos = paned.getPosition();
const min = min: {
@@ -1236,7 +1281,7 @@ const SplitTreeSplit = extern struct {
// If our max is zero then we can't do any math. I don't know
// if this is possible but I suspect it can be if you make a nested
// split completely minimized.
- if (max == 0) return 0;
+ if (max == 0) return;
// Determine our current ratio.
const current_ratio: f64 = ratio: {
@@ -1244,7 +1289,7 @@ const SplitTreeSplit = extern struct {
const max_f64: f64 = @floatFromInt(max);
break :ratio pos_f64 / max_f64;
};
- const desired_ratio: f64 = @floatCast(split.ratio);
+ const desired_ratio: f64 = priv.ratio;
// If our ratio is close enough to our desired ratio, then
// we ignore the update. This is to avoid constant split updates
@@ -1255,24 +1300,85 @@ const SplitTreeSplit = extern struct {
desired_ratio,
0.001,
)) {
- return 0;
+ return;
+ }
+
+ switch (direction) {
+ .tree_to_widget => {
+ // Update position in gtk.Paned to match desired ratio. Note that if
+ // max-position is small, it might not be possible to accurately set
+ // the desired ratio. E.g. with max-position=2 you can only have
+ // ratios 0, 0.5 and 1.
+ const desired_pos: c_int = desired_pos: {
+ const max_f64: f64 = @floatFromInt(max);
+ break :desired_pos @intFromFloat(@round(max_f64 * desired_ratio));
+ };
+ paned.setPosition(desired_pos);
+ },
+ .widget_to_tree => {
+ // Update ratio of the split tree node. This is the most dangerous
+ // part of this widget. We assume that this widget is always a child
+ // of a SplitTree, we assume that our handle is valid, and we assume
+ // the handle is always a split node.
+ const split_tree = ext.getAncestor(
+ SplitTree,
+ self.as(gtk.Widget),
+ ) orelse {
+ log.warn("SplitTree ancestor not found", .{});
+ return;
+ };
+ const tree = split_tree.getTree() orelse {
+ log.warn("no tree data model set", .{});
+ return;
+ };
+ assert(priv.handle.idx() < tree.nodes.len);
+ assert(tree.nodes[priv.handle.idx()] == .split);
+ tree.resizeInPlace(priv.handle, @floatCast(current_ratio));
+ priv.ratio = current_ratio;
+ },
+ }
+ }
+
+ // We need to keep the split ratios from the tree datastructure and
+ // widget tree in sync. Using the max-position and position properties
+ // of the gtk.Paned widget, we can distinguish a resize from a manual
+ // update (e.g. the user dragging the divider). If max-position changes,
+ // we always have a widget resize and we sync the ratio directly from
+ // the propMaxPosition function. Usually position will change as well
+ // but it might not if the size change is small enough. If only position
+ // changes, we have a manual human update and we sync the ratio here.
+ //
+ // This is a hack, it relies on the timing of property notifcations.
+ // From looking at the GTK source code, it should not be possible that
+ // we interpret a position change from a resize as a manual update.
+ // When a gtk.Paned is resized, internally the gtk_paned_calc_position
+ // function will change both max-position and position and synchronously
+ // call our propMaxPosition and propPosition functions. I.e. when the
+ // widget is resized, it should not be possible for onIdle to run before
+ // we have been notified of both property changes.
+ fn onIdle(ud: ?*anyopaque) callconv(.c) c_int {
+ const self: *Self = @ptrCast(@alignCast(ud orelse return 0));
+ const priv = self.private();
+
+ // Clear source and fields.
+ defer {
+ priv.idle = null;
+ priv.max_changed = false;
+ priv.pos_changed = false;
}
if (priv.max_changed) {
- // Widget got resized, update position to match desired ratio.
- // Note that if max-position is small, it might not be possible
- // to accurately set the desired ratio. E.g. with max-position=2
- // you can only have ratios 0, 0.5 and 1.
- const desired_pos: c_int = desired_pos: {
- const max_f64: f64 = @floatFromInt(max);
- break :desired_pos @intFromFloat(@round(max_f64 * desired_ratio));
- };
- paned.setPosition(desired_pos);
- } else {
- // If only position changed, this is a manual human update and
- // we need to write our update back to the tree.
- tree.resizeInPlace(priv.handle, @floatCast(current_ratio));
+ // Nothing to do, syncSplitRatio was already called
+ // directly from propMaxPosition.
+ return 0;
+ }
+ if (!priv.pos_changed) {
+ return 0;
}
+
+ // If only position changed, this is a manual human update and
+ // we need to write our update back to the tree.
+ self.syncSplitRatio(.widget_to_tree);
return 0;
}
@@ -1286,6 +1392,41 @@ const SplitTreeSplit = extern struct {
) callconv(.c) void {
const priv = self.private();
priv.max_changed = true;
+
+ // Widget got resized, update position to match desired ratio.
+ //
+ // Syncing the split ratio directly here ensures that every surface
+ // gets the correct size allocated immediately. This works because
+ // this callback runs during size allocation, so that we update the
+ // divider position right after the gtk.Paned widget computes it and
+ // right before it will use the position to compute the sizes of its
+ // children. See the size_allocate and calc_position functions of the
+ // gtk.Paned widget.
+ //
+ // If we synced the ratio in an idle callback, there might be some
+ // flickering as surfaces are shown with the wrong size for a few
+ // frames until our idle callback runs. Depending on the split layout
+ // it might take multiple rounds of size allocation and idle callbacks
+ // for every widget to get the correct size.
+ //
+ // Note that gtk.Paned calls Widget.setChildVisible(true/false) for
+ // both children based on the initial divider position it computes.
+ // If we then update the position here, we might sometimes have to
+ // call setChildVisible again. This would be necessary if we updated
+ // the position from initially 0 (max), where start (end) child is
+ // invisible, to a value > 0 (< max). However, we can skip this because
+ // set_position already queues another round of size allocation, during
+ // which gtk.Paned will keep the correct position we set manually and
+ // then call setChildVisible again based on that. The only problematic
+ // situation is when we update the position from 0 to a value > 0,
+ // because setChildVisible(false) will unmap the start child widget.
+ // It will not be visible for a single frame which introduces some
+ // flickering. To prevent this from happening we set a min size request
+ // of 1 for all surfaces (see the "new" function above).
+ self.syncSplitRatio(.tree_to_widget);
+
+ // We still need the idle callback to clear the max_changed field
+ // later, because propPosition might or might not still get called.
if (priv.idle == null) priv.idle = glib.idleAdd(
onIdle,
self,
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/surface.zig b/vendor/libghostty-vt/src/apprt/gtk/class/surface.zig
index 54825ce0..9d45bc6c 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/surface.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/surface.zig
@@ -34,8 +34,10 @@ const ClipboardConfirmationDialog = @import("clipboard_confirmation_dialog.zig")
const TitleDialog = @import("title_dialog.zig").TitleDialog;
const Window = @import("window.zig").Window;
const InspectorWindow = @import("inspector_window.zig").InspectorWindow;
+const SplitTree = @import("split_tree.zig").SplitTree;
const i18n = @import("../../../os/i18n.zig");
-const media = @import("../media.zig");
+const global = @import("../../../global.zig");
+const gtk_version = @import("../gtk_version.zig");
const log = std.log.scoped(.gtk_ghostty_surface);
@@ -674,12 +676,6 @@ pub const Surface = extern struct {
// false by a parent widget.
bell_ringing: bool = false,
- // The audio bell's MediaFile, reused across bells so we don't leak a
- // GStreamer pipeline (and its GL threads) on every ring. Built lazily
- // on the first audio bell and rebuilt when `bell-audio-path` changes;
- // unref'd on dispose. See ringBell and media.zig.
- bell_media: ?*gtk.MediaFile = null,
-
/// True if this surface is in an error state. This is currently
/// a simple boolean with no additional information on WHAT the
/// error state is, because we don't yet need it or use it. For now,
@@ -695,6 +691,7 @@ pub const Surface = extern struct {
// True if the current surface is a split, this is used to apply
// unfocused-split-* options
is_split: bool = false,
+ is_split_binding: ?*gobject.Binding = null,
action_group: ?*gio.SimpleActionGroup = null,
@@ -713,6 +710,9 @@ pub const Surface = extern struct {
child_exited_overlay: *ChildExited,
context_menu: *gtk.PopoverMenu,
drop_target: *gtk.DropTarget,
+ surface_drop_target: *gtk.DropTarget,
+ drag_handle: *gtk.Widget,
+ drop_overlay: *gtk.Widget,
progress_bar_overlay: *gtk.ProgressBar,
error_page: *adw.StatusPage,
terminal_page: *gtk.Overlay,
@@ -736,6 +736,7 @@ pub const Surface = extern struct {
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
pub const none: @This() = .{};
@@ -746,6 +747,7 @@ pub const Surface = extern struct {
pub fn new(overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -758,6 +760,7 @@ pub const Surface = extern struct {
const priv: *Private = self.private();
priv.overrides = .{
.command = if (overrides.command) |c| c.clone(alloc) catch null else null,
+ .shell_integration = overrides.shell_integration,
.working_directory = if (overrides.working_directory) |wd| alloc.dupeZ(u8, wd) catch null else null,
};
return self;
@@ -848,6 +851,28 @@ pub const Surface = extern struct {
return @intFromBool(config.@"bell-features".border);
}
+ pub fn bindIsSplit(self: *Self, tree: *SplitTree) void {
+ const priv = self.private();
+ if (priv.is_split_binding) |binding| {
+ binding.unbind();
+ binding.unref();
+ priv.is_split_binding = null;
+ }
+
+ const binding = tree.as(gobject.Object).bindProperty(
+ "is-split",
+ self.as(gobject.Object),
+ "is-split",
+ .{ .sync_create = true },
+ );
+ // The ref created by bindProperty is owned by the binding itself.
+ // We need another ref to prevent the binding object from being
+ // freed if the source object (SplitTree) is finalized. Otherwise
+ // our pointer to the binding could become stale.
+ binding.ref();
+ priv.is_split_binding = binding;
+ }
+
/// Callback used to determine whether unfocused-split-fill / unfocused-split-opacity
/// should be applied to the surface
fn closureShouldUnfocusedSplitBeShown(
@@ -1363,19 +1388,11 @@ pub const Surface = extern struct {
if (entry.native == keycode) break :w3c entry.key;
} else .unidentified;
- // Consult the pre-remapped XKB keyval/keysym to get the (possibly)
- // remapped key. If the W3C key or the remapped key
- // is eligible for remapping, we use it.
- //
- // See the docs for `shouldBeRemappable` for why we even have to
- // do this in the first place.
- if (gtk_key.keyFromKeyval(keyval)) |remapped| {
- if (w3c_key.shouldBeRemappable() or remapped.shouldBeRemappable())
- break :keycode remapped;
- }
-
- // Return the original physical key
- break :keycode w3c_key;
+ break :keycode gtk_key.remapKey(
+ w3c_key,
+ keyval,
+ key_event.isModifier() != 0,
+ );
};
// Get our modifier for the event
@@ -1560,7 +1577,11 @@ pub const Surface = extern struct {
// https://gitlab.gnome.org/GNOME/libadwaita/-/commit/a7738a4d269bfdf4d8d5429ca73ccdd9b2450421
// https://gitlab.gnome.org/GNOME/libadwaita/-/commit/9759d3fd81129608dd78116001928f2aed974ead
if (gtk_xft_dpi <= 0) {
- log.warn("gtk-xft-dpi has invalid value ({}), using default", .{gtk_xft_dpi});
+ // -1 is a valid value which specifies default scale.
+ // https://docs.gtk.org/gtk4/property.Settings.gtk-xft-dpi.html
+ if (gtk_xft_dpi != -1) {
+ log.warn("gtk-xft-dpi has invalid value ({}), using default", .{gtk_xft_dpi});
+ }
break :xft_scale 1.0;
}
@@ -1589,32 +1610,35 @@ pub const Surface = extern struct {
return self.private().cursor_pos;
}
- pub fn defaultTermioEnv(self: *Self) !std.process.EnvMap {
+ pub fn defaultTermioEnv(self: *Self) !std.process.Environ.Map {
const app = Application.default();
const alloc = app.allocator();
- var env = try internal_os.getEnvMap(alloc);
+ var env = if (internal_os.isFlatpak())
+ std.process.Environ.Map.init(alloc)
+ else
+ try global.environMap();
errdefer env.deinit();
if (app.savedLanguage()) |language| {
try env.put("LANG", language);
} else {
- env.remove("LANG");
+ _ = env.orderedRemove("LANG");
}
// Don't leak these GTK environment variables to child processes.
- env.remove("GDK_DEBUG");
- env.remove("GDK_DISABLE");
- env.remove("GSK_RENDERER");
+ _ = env.orderedRemove("GDK_DEBUG");
+ _ = env.orderedRemove("GDK_DISABLE");
+ _ = env.orderedRemove("GSK_RENDERER");
// Remove some environment variables that are set when Ghostty is launched
// from a `.desktop` file, by D-Bus activation, or systemd.
- env.remove("GIO_LAUNCHED_DESKTOP_FILE");
- env.remove("GIO_LAUNCHED_DESKTOP_FILE_PID");
- env.remove("DBUS_STARTER_ADDRESS");
- env.remove("DBUS_STARTER_BUS_TYPE");
- env.remove("INVOCATION_ID");
- env.remove("JOURNAL_STREAM");
- env.remove("NOTIFY_SOCKET");
+ _ = env.orderedRemove("GIO_LAUNCHED_DESKTOP_FILE");
+ _ = env.orderedRemove("GIO_LAUNCHED_DESKTOP_FILE_PID");
+ _ = env.orderedRemove("DBUS_STARTER_ADDRESS");
+ _ = env.orderedRemove("DBUS_STARTER_BUS_TYPE");
+ _ = env.orderedRemove("INVOCATION_ID");
+ _ = env.orderedRemove("JOURNAL_STREAM");
+ _ = env.orderedRemove("NOTIFY_SOCKET");
// Unset environment varies set by snaps if we're running in a snap.
// This allows Ghostty to further launch additional snaps.
@@ -1641,7 +1665,7 @@ pub const Surface = extern struct {
}
/// Filter out environment variables that start with forbidden prefixes.
- fn filterSnapPaths(gpa: std.mem.Allocator, env_map: *std.process.EnvMap) !void {
+ fn filterSnapPaths(gpa: std.mem.Allocator, env_map: *std.process.Environ.Map) !void {
comptime assert(build_config.snap);
const snap_vars = [_][]const u8{
@@ -1708,14 +1732,14 @@ pub const Surface = extern struct {
item.key,
item.value,
);
- for (env_to_remove.items) |key| _ = env_map.remove(key);
+ for (env_to_remove.items) |key| _ = env_map.orderedRemove(key);
}
pub fn clipboardRequest(
self: *Self,
clipboard_type: apprt.Clipboard,
state: apprt.ClipboardRequest,
- ) !bool {
+ ) !apprt.ClipboardReadResult {
return try Clipboard.request(
self,
clipboard_type,
@@ -1825,8 +1849,19 @@ pub const Surface = extern struct {
};
priv.drop_target.setGtypes(&drop_target_types, drop_target_types.len);
+ // Also have to set up the surface drop target to accept other surfaces
+ // (in particular, their surface IDs)
+ var surface_drop_target_types = [_]gobject.Type{
+ gobject.ext.types.uint64,
+ };
+ priv.surface_drop_target.setGtypes(
+ &surface_drop_target_types,
+ surface_drop_target_types.len,
+ );
+
// Setup properties we can't set from our Blueprint file.
self.as(gtk.Widget).setCursorFromName("text");
+ priv.drag_handle.setCursorFromName("grab");
// Initialize our config
self.propConfig(undefined, null);
@@ -1860,9 +1895,10 @@ pub const Surface = extern struct {
priv.config = null;
}
- if (priv.bell_media) |v| {
- v.unref();
- priv.bell_media = null;
+ if (priv.is_split_binding) |binding| {
+ binding.unbind();
+ binding.unref();
+ priv.is_split_binding = null;
}
if (priv.vadj_signal_group) |group| {
@@ -1987,6 +2023,58 @@ pub const Surface = extern struct {
);
}
+ fn snapshot(self: *Self, snap: *gtk.Snapshot) callconv(.c) void {
+ const priv = self.private();
+
+ const blur = blur: {
+ // Native GTK blur is only available since GTK 4.23.3
+ if (gtk_version.runtimeUntil(4, 23, 3)) break :blur null;
+ const config = priv.config orelse break :blur null;
+
+ break :blur switch (config.get().@"background-blur") {
+ .radius => |v| @as(f32, v),
+ .true, .@"macos-glass-regular", .@"macos-glass-clear" => 20.0,
+ .false => null,
+ };
+ };
+
+ if (blur) |b| blur: {
+ // pushCopy and appendPaste are only supported since 4.22.
+ // These two functions are crucial for the blur function
+ // and it cannot be implemented otherwise, so if you compile
+ // Ghostty on an older GTK version, you won't get blur.
+ // Sorry.
+ if (comptime !gtk_version.atLeast(4, 22, 0)) break :blur;
+
+ const width = self.as(gtk.Widget).getWidth();
+ const height = self.as(gtk.Widget).getHeight();
+
+ // Push the current render state (background)
+ // to be appended below
+ snap.pushCopy();
+ defer snap.pop();
+
+ // Apply blur to the copied background
+ snap.pushBlur(b);
+ defer snap.pop();
+
+ snap.appendPaste(&.{
+ .f_origin = .{ .f_x = 0, .f_y = 0 },
+ .f_size = .{
+ .f_width = @floatFromInt(width),
+ .f_height = @floatFromInt(height),
+ },
+ }, 0);
+ }
+
+ // Draw the children normally
+ gtk.Widget.virtual_methods.snapshot.call(
+ Class.parent,
+ self.as(Parent),
+ snap,
+ );
+ }
+
//---------------------------------------------------------------
// Properties
@@ -2213,7 +2301,12 @@ pub const Surface = extern struct {
// Logic around bell reaction happens on every event even if we're
// already in the ringing state.
- if (ringing) self.ringBell();
+ if (ringing) {
+ self.ringBell();
+ // focus clears ringing state, so we should not change state to
+ // ringing if we're already focused
+ if (self.getFocused()) return;
+ }
// Property change only happens on actual state change
const priv = self.private();
@@ -2467,8 +2560,6 @@ pub const Surface = extern struct {
/// Handle bell features that need to happen every time a BEL is received
/// Currently this is audio and system but this could change in the future.
fn ringBell(self: *Self) void {
- const priv = self.private();
-
// Emit the signal
signals.bell.impl.emit(
self,
@@ -2480,33 +2571,7 @@ pub const Surface = extern struct {
// Activate actions if they exist
_ = self.as(gtk.Widget).activateAction("tab.ring-bell", null);
_ = self.as(gtk.Widget).activateAction("win.ring-bell", null);
-
- const config = if (priv.config) |c| c.get() else return;
-
- // Do our sound
- if (config.@"bell-features".audio) audio: {
- const config_path = config.@"bell-audio-path" orelse break :audio;
- const path, const required = switch (config_path) {
- .optional => |path| .{ path, false },
- .required => |path| .{ path, true },
- };
-
- const volume = std.math.clamp(
- config.@"bell-audio-volume",
- 0.0,
- 1.0,
- );
-
- // Reuse one MediaFile per surface (rebuilt only when the path
- // changes) so each bell replays the same pipeline instead of
- // leaking a fresh one. Assign unconditionally: bellMediaFile frees
- // any stale MediaFile and returns the current slot value (possibly
- // null if the path is now inaccessible), so priv.bell_media never
- // dangles.
- priv.bell_media = media.bellMediaFile(priv.bell_media, path, required);
- const media_file = priv.bell_media orelse break :audio;
- media.playBell(media_file, volume);
- }
+ _ = self.as(gtk.Widget).activateAction("app.ring-bell", null);
}
//---------------------------------------------------------------
@@ -2815,7 +2880,10 @@ pub const Surface = extern struct {
return;
}
- if (button == .middle and !priv.gtk_enable_primary_paste) {
+ if (button == .middle and
+ !priv.gtk_enable_primary_paste and
+ !core_surface.mouseReportingActive())
+ {
return;
}
@@ -2875,7 +2943,10 @@ pub const Surface = extern struct {
return;
}
- if (button == .middle and !priv.gtk_enable_primary_paste) {
+ if (button == .middle and
+ !priv.gtk_enable_primary_paste and
+ !surface.mouseReportingActive())
+ {
return;
}
@@ -3320,7 +3391,7 @@ pub const Surface = extern struct {
self: *Self,
) callconv(.c) void {
self.updateMapped(true);
- self.updateOcclusion(true);
+ self.updateOcclusion();
}
fn glareaUnmap(
@@ -3328,7 +3399,7 @@ pub const Surface = extern struct {
self: *Self,
) callconv(.c) void {
self.updateMapped(false);
- self.updateOcclusion(false);
+ self.updateOcclusion();
}
fn updateMapped(self: *Self, mapped: bool) void {
@@ -3337,13 +3408,23 @@ pub const Surface = extern struct {
self.as(gobject.Object).notifyByPspec(properties.mapped.impl.param_spec);
}
- fn updateOcclusion(self: *Self, visible: bool) void {
+ /// Update the core surface visibility based on both GTK widget and
+ /// toplevel state. This is public so the window can call it when its
+ /// suspended state changes.
+ pub fn updateOcclusion(self: *Self) void {
const surface = self.core() orelse return;
+ const visible = self.private().mapped and !self.windowSuspended();
surface.occlusionCallback(visible) catch |err| {
log.warn("error in occlusion callback err={}", .{err});
};
}
+ fn windowSuspended(self: *Self) bool {
+ const native = self.as(gtk.Widget).getNative() orelse return false;
+ const window = gobject.ext.cast(gtk.Window, native) orelse return false;
+ return window.isSuspended() != 0;
+ }
+
fn glareaRender(
_: *gtk.GLArea,
_: *gdk.GLContext,
@@ -3461,9 +3542,11 @@ pub const Surface = extern struct {
);
defer config.deinit();
- if (priv.overrides.command) |c| {
- config.command = try c.clone(config._arena.?.allocator());
- }
+ try applyCommandOverrides(
+ &config,
+ priv.overrides.command,
+ priv.overrides.shell_integration,
+ );
if (priv.overrides.working_directory) |wd| {
const config_alloc = config.arenaAlloc();
var wd_val: configpkg.WorkingDirectory = .{ .path = try config_alloc.dupe(u8, wd) };
@@ -3597,6 +3680,178 @@ pub const Surface = extern struct {
};
}
+ fn closureShouldDragHandleBeShown(
+ _: *Self,
+ config_: ?*Config,
+ is_split: c_int,
+ ) callconv(.c) c_int {
+ const config = config_ orelse return @intFromBool(false);
+
+ const shown = switch (config.get().@"drag-handle") {
+ .always => true,
+ .auto => is_split != 0,
+ .never => false,
+ };
+ return @intFromBool(shown);
+ }
+
+ fn surfaceDragPrepare(
+ src: *gtk.DragSource,
+ x: f64,
+ y: f64,
+ self: *Self,
+ ) callconv(.c) *gdk.ContentProvider {
+ // TODO: Use a static content provider once we make `self.core()`
+ // available immediately when constructing the surface widget
+ _ = src;
+ _ = x;
+ _ = y;
+ var val = gobject.ext.Value.newFrom(self.core().?.id);
+ return gdk.ContentProvider.newForValue(&val);
+ }
+
+ fn surfaceDragBegin(
+ src: *gtk.DragSource,
+ _: *gdk.Drag,
+ self: *Self,
+ ) callconv(.c) void {
+ // The scale of the preview
+ const preview_scale: f32 = 0.2;
+
+ // Snapshot the entire surface widget as the icon preview
+ const paintable = gtk.WidgetPaintable.new(self.as(gtk.Widget));
+ defer paintable.unref();
+
+ // Center the preview
+ const width = self.as(gtk.Widget).getWidth();
+ const height = self.as(gtk.Widget).getHeight();
+ const mid_x = @as(f32, @floatFromInt(width)) / 2;
+ const mid_y = @as(f32, @floatFromInt(height)) / 2;
+
+ // Create a snapshot to render the scaled paintable
+ const snap = gtk.Snapshot.new();
+ snap.scale(preview_scale, preview_scale);
+ paintable.as(gdk.Paintable).snapshot(
+ snap.as(gdk.Snapshot),
+ @floatFromInt(width),
+ @floatFromInt(height),
+ );
+
+ if (snap.freeToPaintable(null)) |scaled| {
+ defer scaled.unref();
+ src.setIcon(
+ scaled,
+ @intFromFloat(mid_x * preview_scale),
+ @intFromFloat(mid_y * preview_scale),
+ );
+ } else {
+ // The scaling process somehow failed.
+ // Use the original paintable as a fail-safe
+ log.warn("preview scaling failed - falling back to original paintable", .{});
+ src.setIcon(
+ paintable.as(gdk.Paintable),
+ @intFromFloat(mid_x),
+ @intFromFloat(mid_y),
+ );
+ }
+ }
+
+ fn surfaceDrop(
+ _: *gtk.DropTarget,
+ v: *const gobject.Value,
+ x: f64,
+ y: f64,
+ self: *Self,
+ ) callconv(.c) void {
+ const dropped_id = v.getUint64();
+ const dropped = self.core().?.app.findSurfaceByID(dropped_id) orelse return;
+ const from = dropped.rt_surface.gobj();
+
+ const st = ext.getAncestor(
+ SplitTree,
+ self.as(gtk.Widget),
+ ) orelse {
+ log.warn("surface is not placed in a split tree", .{});
+ return;
+ };
+
+ const dir = self.calcDropDirection(x, y);
+
+ // The only error that could happen here is an OOM,
+ // and in that case we're already milliseconds away from crashing, so...
+ st.moveSplit(from, self, dir) catch return;
+
+ // Clean up overlay state
+ self.setDropOverlayDirection(null);
+ }
+
+ fn surfaceDropLeave(
+ _: *gtk.DropTarget,
+ self: *Self,
+ ) callconv(.c) void {
+ // Hide overlay
+ self.setDropOverlayDirection(null);
+ }
+
+ fn surfaceDropMotion(
+ _: *gtk.DropTarget,
+ x: f64,
+ y: f64,
+ self: *Self,
+ ) callconv(.c) gdk.DragAction {
+ // Recalculate the drop region
+ const dir = self.calcDropDirection(x, y);
+ self.setDropOverlayDirection(dir);
+ return .{ .move = true };
+ }
+
+ fn propDropValue(
+ tgt: *gtk.DropTarget,
+ _: *gobject.ParamSpec,
+ self: *Self,
+ ) callconv(.c) void {
+ // Reject the drop if we're dropping a surface onto itself.
+ // Note that we cannot implement this via the `accept` signal,
+ // since the decision of whether to accept or deny a drop is dependent
+ // on the payload (i.e. the surface being dropped). This is
+ // well-documented in GTK docs.
+
+ const core_surface = self.core() orelse return;
+ const value = tgt.getValue() orelse return;
+ const surface_id = value.getUint64();
+ if (core_surface.id == surface_id) tgt.reject();
+ }
+
+ fn setDropOverlayDirection(self: *Self, dir: ?Tree.Split.Direction) void {
+ const priv = self.private();
+ inline for (&.{ "drop-top", "drop-left", "drop-right", "drop-bottom" }) |c| {
+ priv.drop_overlay.removeCssClass(c);
+ }
+
+ if (dir) |d| priv.drop_overlay.addCssClass(switch (d) {
+ .up => "drop-top",
+ .left => "drop-left",
+ .right => "drop-right",
+ .down => "drop-bottom",
+ });
+ }
+
+ fn calcDropDirection(self: *Self, x: f64, y: f64) Tree.Split.Direction {
+ const width: f64 = @floatFromInt(self.as(gtk.Widget).getWidth());
+ const height: f64 = @floatFromInt(self.as(gtk.Widget).getHeight());
+
+ const l_dist = x / width;
+ const t_dist = y / height;
+ const r_dist = 1 - l_dist;
+ const b_dist = 1 - t_dist;
+ const min = @min(l_dist, t_dist, r_dist, b_dist);
+
+ if (min == l_dist) return .left;
+ if (min == r_dist) return .right;
+ if (min == t_dist) return .up;
+ return .down;
+ }
+
const C = Common(Self, Private);
pub const as = C.as;
pub const ref = C.ref;
@@ -3636,6 +3891,9 @@ pub const Surface = extern struct {
class.bindTemplateChildPrivate("key_state_overlay", .{});
class.bindTemplateChildPrivate("terminal_page", .{});
class.bindTemplateChildPrivate("drop_target", .{});
+ class.bindTemplateChildPrivate("surface_drop_target", .{});
+ class.bindTemplateChildPrivate("drag_handle", .{});
+ class.bindTemplateChildPrivate("drop_overlay", .{});
class.bindTemplateChildPrivate("im_context", .{});
// Template Callbacks
@@ -3678,6 +3936,13 @@ pub const Surface = extern struct {
class.bindTemplateCallback("search_changed", &searchChanged);
class.bindTemplateCallback("search_next_match", &searchNextMatch);
class.bindTemplateCallback("search_previous_match", &searchPreviousMatch);
+ class.bindTemplateCallback("should_drag_handle_be_shown", &closureShouldDragHandleBeShown);
+ class.bindTemplateCallback("surface_drag_prepare", &surfaceDragPrepare);
+ class.bindTemplateCallback("surface_drag_begin", &surfaceDragBegin);
+ class.bindTemplateCallback("surface_drop", &surfaceDrop);
+ class.bindTemplateCallback("surface_drop_leave", &surfaceDropLeave);
+ class.bindTemplateCallback("surface_drop_motion", &surfaceDropMotion);
+ class.bindTemplateCallback("notify_drop_value", &propDropValue);
// Properties
gobject.ext.registerProperties(class, &.{
@@ -3723,6 +3988,7 @@ pub const Surface = extern struct {
// Virtual methods
gobject.Object.virtual_methods.dispose.implement(class, &dispose);
gobject.Object.virtual_methods.finalize.implement(class, &finalize);
+ gtk.Widget.virtual_methods.snapshot.implement(class, &snapshot);
}
pub const as = C.Class.as;
@@ -3865,22 +4131,25 @@ const Clipboard = struct {
);
}
- /// Request data from the clipboard (read the clipboard). This
- /// completes asynchronously and will call the `completeClipboardRequest`
- /// core surface API when done.
- ///
- /// Returns true if the request was started, false if the clipboard
- /// doesn't contain text (allowing performable keybinds to pass through).
+ /// Request data from the clipboard (read the clipboard). A started
+ /// request completes asynchronously and will call the
+ /// `completeClipboardRequest` core surface API when done.
pub fn request(
self: *Surface,
clipboard_type: apprt.Clipboard,
state: apprt.ClipboardRequest,
- ) Allocator.Error!bool {
+ ) Allocator.Error!apprt.ClipboardReadResult {
+ // The GTK apprt doesn't support the Kitty clipboard protocol
+ // yet.
+ if (state == .kitty_read or
+ state == .kitty_write or
+ state == .list) return .unsupported;
+
// Get our requested clipboard
const clipboard = get(
self.private().gl_area.as(gtk.Widget),
clipboard_type,
- ) orelse return false;
+ ) orelse return .unsupported;
// For paste requests, check if clipboard has text format available.
// This is a synchronous check that allows performable keybinds to
@@ -3889,7 +4158,7 @@ const Clipboard = struct {
const formats = clipboard.getFormats();
if (formats.containGtype(gobject.ext.types.string) == 0) {
log.debug("clipboard has no text format, not starting paste request", .{});
- return false;
+ return .unavailable;
}
}
@@ -3912,7 +4181,7 @@ const Clipboard = struct {
ud,
);
- return true;
+ return .started;
}
/// Paste explicit text directly into the surface, regardless of the
@@ -3925,16 +4194,15 @@ const Clipboard = struct {
const surface = self.private().core_surface orelse return;
surface.completeClipboardRequest(
- .paste,
- text,
- false,
+ .{ .paste = .standard },
+ .{ .contents = &.{.{ .mime = "text/plain", .data = text }} },
) catch |err| switch (err) {
error.UnsafePaste,
error.UnauthorizedPaste,
=> {
showClipboardConfirmation(
self,
- .paste,
+ .{ .paste = .standard },
text,
);
return;
@@ -3978,7 +4246,7 @@ const Clipboard = struct {
.request = &req,
.@"can-remember" = switch (req) {
.osc_52_read, .osc_52_write => true,
- .paste => false,
+ .paste, .list, .kitty_read, .kitty_write => false,
},
.@"clipboard-contents" = contents_buf,
},
@@ -4015,7 +4283,7 @@ const Clipboard = struct {
if (remember) switch (req.*) {
.osc_52_read => surface.config.clipboard_read = .allow,
.osc_52_write => surface.config.clipboard_write = .allow,
- .paste => {},
+ .paste, .list, .kitty_read, .kitty_write => {},
};
// Get our text
@@ -4032,11 +4300,10 @@ const Clipboard = struct {
?[:0]const u8,
) orelse return;
- surface.completeClipboardRequest(
- req.*,
- text,
- true,
- ) catch |err| {
+ surface.completeClipboardRequest(req.*, .{
+ .contents = &.{.{ .mime = "text/plain", .data = text }},
+ .confirmed = true,
+ }) catch |err| {
log.warn("failed to complete clipboard request: {}", .{err});
};
}
@@ -4054,7 +4321,7 @@ const Clipboard = struct {
if (remember) switch (req.*) {
.osc_52_read => surface.config.clipboard_read = .deny,
.osc_52_write => surface.config.clipboard_write = .deny,
- .paste => @panic("paste should not be able to be remembered"),
+ .paste, .list, .kitty_read, .kitty_write => @panic("request should not be able to be remembered"),
};
}
@@ -4092,8 +4359,7 @@ const Clipboard = struct {
const surface = self.private().core_surface orelse return;
surface.completeClipboardRequest(
req.state,
- str,
- false,
+ .{ .contents = &.{.{ .mime = "text/plain", .data = str }} },
) catch |err| switch (err) {
error.UnsafePaste,
error.UnauthorizedPaste,
@@ -4144,3 +4410,57 @@ test "computeFraction" {
try std.testing.expectEqual(0.0, computeFraction(0));
try std.testing.expectEqual(0.5, computeFraction(50));
}
+
+/// Apply command and shell integration overrides received from the CLI.
+/// Explicit commands should only receive shell integration when their
+/// executable can be detected as a supported shell. An explicit shell
+/// integration override is also valid without a command.
+fn applyCommandOverrides(
+ config: *configpkg.Config,
+ command: ?configpkg.Command,
+ shell_integration: ?configpkg.Config.ShellIntegration,
+) Allocator.Error!void {
+ if (command) |value| {
+ config.command = try value.clone(config.arenaAlloc());
+
+ if (shell_integration) |integration| {
+ config.@"shell-integration" = integration;
+ } else if (config.@"shell-integration" != .none) {
+ config.@"shell-integration" = .detect;
+ }
+ } else if (shell_integration) |value| {
+ config.@"shell-integration" = value;
+ }
+}
+
+test "command and shell integration overrides" {
+ const testing = std.testing;
+
+ var config = try configpkg.Config.default(testing.allocator);
+ defer config.deinit();
+
+ config.@"shell-integration" = .nushell;
+ try applyCommandOverrides(&config, .{ .shell = "vim" }, null);
+ try testing.expectEqual(.detect, config.@"shell-integration");
+
+ config.@"shell-integration" = .none;
+ try applyCommandOverrides(&config, .{ .shell = "vim" }, null);
+ try testing.expectEqual(.none, config.@"shell-integration");
+
+ try applyCommandOverrides(&config, .{ .shell = "nu" }, .nushell);
+ try testing.expectEqual(.nushell, config.@"shell-integration");
+
+ try applyCommandOverrides(&config, .{ .shell = "vim" }, .none);
+ try testing.expectEqual(.none, config.@"shell-integration");
+
+ config.@"shell-integration" = .nushell;
+ try applyCommandOverrides(&config, null, null);
+ try testing.expectEqual(.nushell, config.@"shell-integration");
+
+ config.@"shell-integration" = .none;
+ try applyCommandOverrides(&config, null, .nushell);
+ try testing.expectEqual(.nushell, config.@"shell-integration");
+
+ try applyCommandOverrides(&config, null, .none);
+ try testing.expectEqual(.none, config.@"shell-integration");
+}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/surface_child_exited.zig b/vendor/libghostty-vt/src/apprt/gtk/class/surface_child_exited.zig
index d7dd41bc..3c103d59 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/surface_child_exited.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/surface_child_exited.zig
@@ -106,11 +106,11 @@ const SurfaceChildExitedBanner = extern struct {
return;
};
if (data.exit_code == 0) {
- banner.as(adw.Banner).setTitle(i18n._("Command succeeded"));
+ banner.as(adw.Banner).setTitle(i18n._("Command Succeeded"));
self.as(gtk.Widget).addCssClass("normal");
self.as(gtk.Widget).removeCssClass("abnormal");
} else {
- banner.as(adw.Banner).setTitle(i18n._("Command failed"));
+ banner.as(adw.Banner).setTitle(i18n._("Command Failed"));
self.as(gtk.Widget).removeCssClass("normal");
self.as(gtk.Widget).addCssClass("abnormal");
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/surface_scrolled_window.zig b/vendor/libghostty-vt/src/apprt/gtk/class/surface_scrolled_window.zig
index 6ccb0a0d..ad9a4cc7 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/surface_scrolled_window.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/surface_scrolled_window.zig
@@ -89,7 +89,8 @@ pub const SurfaceScrolledWindow = extern struct {
const priv = self.private();
if (priv.config_binding) |binding| {
- binding.as(gobject.Object).unref();
+ binding.unbind();
+ binding.unref();
priv.config_binding = null;
}
@@ -168,18 +169,23 @@ pub const SurfaceScrolledWindow = extern struct {
// Unbind old config binding if it exists
if (priv.config_binding) |binding| {
- binding.as(gobject.Object).unref();
+ binding.unbind();
+ binding.unref();
priv.config_binding = null;
}
// Bind config from surface to our config property
if (priv.surface) |surface| {
- priv.config_binding = surface.as(gobject.Object).bindProperty(
+ const binding = surface.as(gobject.Object).bindProperty(
properties.config.name,
self.as(gobject.Object),
properties.config.name,
.{ .sync_create = true },
);
+ // Keep another ref, otherwise the binding would be freed and
+ // our pointer become stale if the surface gets finalized.
+ binding.ref();
+ priv.config_binding = binding;
}
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/tab.zig b/vendor/libghostty-vt/src/apprt/gtk/class/tab.zig
index 0c60c8cc..204be58f 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/tab.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/tab.zig
@@ -162,7 +162,7 @@ pub const Tab = extern struct {
/// The title of this tab. This is usually bound to the active surface.
title: ?[:0]const u8 = null,
- /// The manually overridden title from `promptTabTitle`.
+ /// The manually overridden title.
title_override: ?[:0]const u8 = null,
/// The tooltip of this tab. This is usually bound to the active surface.
@@ -189,6 +189,7 @@ pub const Tab = extern struct {
pub fn new(config: ?*Config, overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -212,6 +213,7 @@ pub const Tab = extern struct {
// Create our initial surface in the split tree.
priv.split_tree.newSplit(.right, null, .{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
}) catch |err| switch (err) {
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/title_dialog.zig b/vendor/libghostty-vt/src/apprt/gtk/class/title_dialog.zig
index ac95ae4b..057e9dee 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/title_dialog.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/title_dialog.zig
@@ -220,10 +220,13 @@ pub const TitleDialog = extern struct {
pub const Target = enum(c_int) {
surface,
tab,
+ window,
+
pub fn title(self: Target) [*:0]const u8 {
return switch (self) {
.surface => i18n._("Change Terminal Title"),
.tab => i18n._("Change Tab Title"),
+ .window => i18n._("Change Window Title"),
};
}
diff --git a/vendor/libghostty-vt/src/apprt/gtk/class/window.zig b/vendor/libghostty-vt/src/apprt/gtk/class/window.zig
index c34f2cb4..e2fe6403 100644
--- a/vendor/libghostty-vt/src/apprt/gtk/class/window.zig
+++ b/vendor/libghostty-vt/src/apprt/gtk/class/window.zig
@@ -29,6 +29,7 @@ const Tab = @import("tab.zig").Tab;
const DebugWarning = @import("debug_warning.zig").DebugWarning;
const CommandPalette = @import("command_palette.zig").CommandPalette;
const WeakRef = @import("../weak_ref.zig").WeakRef;
+const TitleDialog = @import("title_dialog.zig").TitleDialog;
const log = std.log.scoped(.gtk_ghostty_window);
@@ -213,6 +214,19 @@ pub const Window = extern struct {
},
);
};
+
+ pub const @"title-override" = struct {
+ pub const name = "title-override";
+ const impl = gobject.ext.defineProperty(
+ name,
+ Self,
+ ?[:0]const u8,
+ .{
+ .default = null,
+ .accessor = C.privateStringFieldAccessor("title_override"),
+ },
+ );
+ };
};
const Private = struct {
@@ -259,6 +273,9 @@ pub const Window = extern struct {
/// setup by `setup-menu`.
context_menu_page: ?*adw.TabPage = null,
+ /// The manually overridden title.
+ title_override: ?[:0]const u8 = null,
+
// Template bindings
tab_overview: *adw.TabOverview,
tab_bar: *adw.TabBar,
@@ -365,6 +382,7 @@ pub const Window = extern struct {
.init("prompt-surface-title", actionPromptSurfaceTitle, null),
.init("prompt-tab-title", actionPromptTabTitle, null),
.init("prompt-context-tab-title", actionPromptContextTabTitle, null),
+ .init("prompt-window-title", actionPromptWindowTitle, null),
.init("ring-bell", actionRingBell, null),
.init("split-right", actionSplitRight, null),
.init("split-left", actionSplitLeft, null),
@@ -390,8 +408,20 @@ pub const Window = extern struct {
/// Create a new tab with the given parent. The tab will be inserted
/// at the position dictated by the `window-new-tab-position` config.
/// The new tab will be selected.
- pub fn newTab(self: *Self, parent_: ?*CoreSurface) void {
- _ = self.newTabPage(parent_, .tab, .none);
+ pub fn newTab(self: *Self, parent_: ?*CoreSurface, overrides: struct {
+ command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
+ working_directory: ?[:0]const u8 = null,
+ title: ?[:0]const u8 = null,
+
+ pub const none: @This() = .{};
+ }) void {
+ _ = self.newTabPage(parent_, .tab, .{
+ .command = overrides.command,
+ .shell_integration = overrides.shell_integration,
+ .working_directory = overrides.working_directory,
+ .title = overrides.title,
+ });
}
pub fn newTabForWindow(
@@ -399,6 +429,7 @@ pub const Window = extern struct {
parent_: ?*CoreSurface,
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -410,6 +441,7 @@ pub const Window = extern struct {
.window,
.{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
},
@@ -422,6 +454,7 @@ pub const Window = extern struct {
context: apprt.surface.NewSurfaceContext,
overrides: struct {
command: ?configpkg.Command = null,
+ shell_integration: ?configpkg.Config.ShellIntegration = null,
working_directory: ?[:0]const u8 = null,
title: ?[:0]const u8 = null,
@@ -436,6 +469,7 @@ pub const Window = extern struct {
priv.config,
.{
.command = overrides.command,
+ .shell_integration = overrides.shell_integration,
.working_directory = overrides.working_directory,
.title = overrides.title,
},
@@ -604,6 +638,29 @@ pub const Window = extern struct {
return tab_view.reorderPage(page, desired_pos) != 0;
}
+ pub fn moveTabToNewWindow(self: *Self, surface: *Surface) bool {
+ const tab_view = self.private().tab_view;
+ const tab = ext.getAncestor(
+ Tab,
+ surface.as(gtk.Widget),
+ ) orelse return false;
+ const page = tab_view.getPage(tab.as(gtk.Widget));
+
+ // Skip if this is the only tab in the existing window
+ if (tab_view.getNPages() <= 1) return false;
+
+ const app = Application.default();
+ const window = Window.new(app, .none);
+
+ tab_view.transferPage(
+ page,
+ window.private().tab_view,
+ 0,
+ );
+ window.as(gtk.Window).present();
+ return true;
+ }
+
pub fn toggleTabOverview(self: *Self) void {
const priv = self.private();
const tab_overview = priv.tab_overview;
@@ -1268,6 +1325,57 @@ pub const Window = extern struct {
});
}
+ pub fn setTitleOverride(self: *Self, title: ?[]const u8) void {
+ const priv: *Private = self.private();
+
+ if (priv.title_override) |v| glib.free(@ptrCast(@constCast(v)));
+ priv.title_override = null;
+
+ if (title) |v| priv.title_override = glib.ext.dupeZ(u8, v);
+
+ self.as(gobject.Object).notifyByPspec(properties.@"title-override".impl.param_spec);
+ }
+
+ fn titleDialogSet(_: *TitleDialog, title_: [*:0]const u8, self: *Self) callconv(.c) void {
+ const title = std.mem.span(title_);
+ self.setTitleOverride(if (title.len == 0) null else title);
+ }
+
+ pub fn promptWindowTitle(self: *Self) void {
+ const priv: *Private = self.private();
+
+ var value = std.mem.zeroes(gobject.Value);
+ _ = value.init(gobject.ext.types.string);
+ defer value.unset();
+
+ self.as(gobject.Object).getProperty("title", &value);
+
+ const title_: ?[*:0]const u8 = value.getString();
+ const title: ?[:0]const u8 = if (title_) |v| std.mem.span(v) else null;
+
+ const dialog = TitleDialog.new(.window, priv.title_override orelse title);
+ _ = TitleDialog.signals.set.connect(
+ dialog,
+ *Self,
+ titleDialogSet,
+ self,
+ .{},
+ );
+
+ dialog.present(self.as(gtk.Widget));
+ }
+
+ fn closureTitle(
+ _: *Self,
+ _: ?*Config,
+ title_: ?[*:0]const u8,
+ title_override_: ?[*:0]const u8,
+ ) callconv(.c) ?[*:0]const u8 {
+ if (title_override_) |v| return glib.ext.dupeZ(u8, std.mem.span(v));
+ if (title_) |v| return glib.ext.dupeZ(u8, std.mem.span(v));
+ return glib.ext.dupeZ(u8, "Ghostty");
+ }
+
fn closureSubtitle(
_: *Self,
config_: ?*Config,
@@ -1296,7 +1404,7 @@ pub const Window = extern struct {
priv.handle_active_state_source = null;
}
- priv.command_palette.set(null);
+ priv.command_palette.deinit();
if (priv.config) |v| {
v.unref();
@@ -1320,6 +1428,7 @@ pub const Window = extern struct {
const priv = self.private();
priv.tab_bindings.unref();
priv.winproto.deinit();
+ if (priv.title_override) |v| glib.free(@ptrCast(@constCast(v)));
gobject.Object.virtual_methods.finalize.call(
Class.parent,
@@ -1374,11 +1483,33 @@ pub const Window = extern struct {
}
}
+ // Notify every displayed surface when the compositor changes the
+ // Wayland xdg_toplevel suspended state.
+ _ = gobject.Object.signals.notify.connect(
+ self.as(gtk.Window),
+ *Self,
+ propSuspended,
+ self,
+ .{ .detail = "suspended" },
+ );
+
// When we are realized we always setup our appearance since this
// calls some winproto functions.
self.syncAppearance();
}
+ fn propSuspended(
+ _: *gtk.Window,
+ _: *gobject.ParamSpec,
+ self: *Self,
+ ) callconv(.c) void {
+ const tab = self.getSelectedTab() orelse return;
+ const tree = tab.getSurfaceTree() orelse return;
+
+ var it = tree.iterator();
+ while (it.next()) |entry| entry.view.updateOcclusion();
+ }
+
fn btnNewTab(_: *adw.SplitButton, self: *Self) callconv(.c) void {
self.performBindingAction(.new_tab);
}
@@ -1954,6 +2085,14 @@ pub const Window = extern struct {
self.performBindingAction(.prompt_tab_title);
}
+ fn actionPromptWindowTitle(
+ _: *gio.SimpleAction,
+ _: ?*glib.Variant,
+ self: *Window,
+ ) callconv(.c) void {
+ self.performBindingAction(.prompt_window_title);
+ }
+
fn actionSplitRight(
_: *gio.SimpleAction,
_: ?*glib.Variant,
@@ -2161,6 +2300,7 @@ pub const Window = extern struct {
properties.@"tabs-wide".impl,
properties.@"toolbar-style".impl,
properties.@"titlebar-style".impl,
+ properties.@"title-override".impl,
});
// Bindings
@@ -2191,6 +2331,7 @@ pub const Window = extern struct {
class.bindTemplateCallback("notify_quick_terminal", &propQuickTerminal);
class.bindTemplateCallback("notify_scale_factor", &propScaleFactor);
class.bindTemplateCallback("titlebar_style_is_tabs", &closureTitlebarStyleIsTab);
+ class.bindTemplateCallback("computed_title", &closureTitle);
class.bindTemplateCallback("computed_subtitle", &closureSubtitle);
// Virtual methods