From 143e503d4325fe72074e85d8cf6f0a54ef99bf80 Mon Sep 17 00:00:00 2001 From: "Jeffrey C. Ollie" Date: Thu, 1 Aug 2024 01:25:17 -0500 Subject: [PATCH] gtk: allow running in the background This patch fixes #2010 by implementing `quit-after-last-window-closed` for the GTK apprt. It also adds the ability for the GTK apprt to exit after a delay once all surfaces have been closed and adds the ability to start Ghostty without opening an initial window. --- src/apprt/gtk/App.zig | 71 ++++++++++-- src/config/Config.zig | 264 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 317 insertions(+), 18 deletions(-) diff --git a/src/apprt/gtk/App.zig b/src/apprt/gtk/App.zig index 60fefc6de..ef500fe44 100644 --- a/src/apprt/gtk/App.zig +++ b/src/apprt/gtk/App.zig @@ -253,10 +253,14 @@ pub fn init(core_app: *CoreApp, opts: Options) !App { break :x11_xkb try x11.Xkb.init(display); }; - // This just calls the "activate" signal but its part of the normal - // startup routine so we just call it: + // This just calls the `activate` signal but its part of the normal startup + // routine so we just call it, but only if the config allows it (this allows + // for launching Ghostty in the "background" without immediately opening + // a window) + // // https://gitlab.gnome.org/GNOME/glib/-/blob/bd2ccc2f69ecfd78ca3f34ab59e42e2b462bad65/gio/gapplication.c#L2302 - c.g_application_activate(gapp); + if (config.@"initial-window") + c.g_application_activate(gapp); // Register for dbus events if (c.g_application_get_dbus_connection(gapp)) |dbus_connection| { @@ -277,6 +281,10 @@ pub fn init(core_app: *CoreApp, opts: Options) !App { const css_provider = c.gtk_css_provider_new(); try loadRuntimeCss(&config, css_provider); + // Run a small no-op function every 500 milliseconds so that we don't get + // stuck in g_main_context_iteration forever if there are no open surfaces. + _ = c.g_timeout_add(500, gtkTimeout, null); + return .{ .core_app = core_app, .app = app, @@ -293,6 +301,12 @@ pub fn init(core_app: *CoreApp, opts: Options) !App { }; } +// This timeout function is run periodically so that we don't get stuck in +// g_main_context_iteration forever if there are no open surfaces. +pub fn gtkTimeout(_: ?*anyopaque) callconv(.C) c.gboolean { + return 1; +} + // Terminate the application. The application will not be restarted after // this so all global state can be cleaned up. pub fn terminate(self: *App) void { @@ -463,6 +477,9 @@ pub fn run(self: *App) !void { self.transient_cgroup_base = path; } else log.debug("cgroup isoation disabled config={}", .{self.config.@"linux-cgroup"}); + // The last instant that one or more surfaces were open + var last_one = try std.time.Instant.now(); + // Setup our menu items self.initActions(); self.initMenu(); @@ -478,9 +495,48 @@ pub fn run(self: *App) !void { while (self.running) { _ = c.g_main_context_iteration(self.ctx, 1); - // Tick the terminal app + // Tick the terminal app and see if we should quit. const should_quit = try self.core_app.tick(self); - if (should_quit or self.core_app.surfaces.items.len == 0) self.quit(); + + // If there are one or more surfaces open, update the timer. + if (self.core_app.surfaces.items.len > 0) last_one = try std.time.Instant.now(); + + const q = q: { + // If we've been told by GTK that we should quit, do so regardless + // of any other setting. + if (should_quit) break :q true; + + // If there are no surfaces check to see if we should stay in the + // background or not. + if (self.core_app.surfaces.items.len == 0) { + if (self.config.@"quit-after-last-window-closed") { + // If the background timeout is not zero, check to see if + // the timeout has elapsed. + if (self.config.@"quit-after-last-window-closed-delay".duration != 0) { + const now = try std.time.Instant.now(); + + if (now.since(last_one) > self.config.@"quit-after-last-window-closed-delay".duration) { + log.info("timeout elapsed", .{}); + // The timeout has elapsed, quit. + break :q true; + } + + // Not enough time has elapsed, don't quit. + break :q false; + } + + // `quit-after-last-window-closed-delay` is zero, don't quit. + break :q false; + } + + break :q false; + } + + // there's at least one surface open, don't quit. + break :q false; + }; + + if (q) self.quit(); } } @@ -598,9 +654,8 @@ fn gtkQuitConfirmation( self.quitNow(); } -/// This is called by the "activate" signal. This is sent on program -/// startup and also when a secondary instance launches and requests -/// a new window. +/// This is called by the `activate` signal. This is sent on program startup and +/// also when a secondary instance launches and requests a new window. fn gtkActivate(app: *c.GtkApplication, ud: ?*anyopaque) callconv(.C) void { _ = app; diff --git a/src/config/Config.zig b/src/config/Config.zig index 81799d167..50fdafd44 100644 --- a/src/config/Config.zig +++ b/src/config/Config.zig @@ -880,11 +880,46 @@ keybind: Keybinds = .{}, /// true. If set to false, surfaces will close without any confirmation. @"confirm-close-surface": bool = true, -/// Whether or not to quit after the last window is closed. This defaults to -/// false. Currently only supported on macOS. On Linux, the process always exits -/// after the last window is closed. +/// Whether or not to quit after the last surface is closed. This +/// defaults to `false`. On Linux, if this is `true`, Ghostty can delay +/// quitting fully for a configurable amount. See the documentation of +/// `quit-after-last-window-closed-delay` for more information. @"quit-after-last-window-closed": bool = false, +/// If `quit-after-last-window-closed` is `true`, this controls how long +/// Ghostty will stay running after the last open surface has been closed. If +/// `quit-after-last-window-closed-delay` is set to 0 ns Ghostty will remain +/// running indefinitely. The duration should be at least long enough to allow +/// Ghostty to initialize and open it's first window, but this is not enforced +/// nor will a warning be issued. The duration is specified as a series of +/// numbers followed by time units. Whitespace is allowed between numbers and +/// units. The allowed time units are as follows: +/// +/// * `y` - 365 SI days, or 8760 hours, or 31536000 seconds. No adjustments +/// are made for leap years or leap seconds. +/// * `d` - one SI day, or 86400 seconds. +/// * `h` - one hour, or 3600 seconds. +/// * `m` - one minute, or 60 seconds. +/// * `s` - one second. +/// * `ms` - one millisecond, or 0.001 second. +/// * `us` or `µs` - one microsecond, or 0.000001 second. +/// * `ns` - one nanosecond, or 0.000000001 second. +/// +/// Examples: +/// * `1h30m` +/// * `45s` +/// +/// The maximum value is `584y 49w 23h 34m 33s 709ms 551µs 615ns`. +/// +/// By default `quit-after-last-window-closed-delay` is set to `0 ns`. +/// +/// Only implemented on Linux. +@"quit-after-last-window-closed-delay": Duration = .{ .duration = 0 }, + +/// This controls whether an initial window is created when Ghostty is run. Only +/// implemented on Linux. +@"initial-window": bool = true, + /// Whether to enable shell integration auto-injection or not. Shell integration /// greatly enhances the terminal experience by enabling a number of features: /// @@ -1109,15 +1144,16 @@ keybind: Keybinds = .{}, /// must always be able to move themselves into an isolated cgroup. @"linux-cgroup-hard-fail": bool = false, -/// If true, the Ghostty GTK application will run in single-instance mode: -/// each new `ghostty` process launched will result in a new window if there -/// is already a running process. +/// If `true`, the Ghostty GTK application will run in single-instance mode: +/// each new `ghostty` process launched will result in a new window if there is +/// already a running process. /// -/// If false, each new ghostty process will launch a separate application. +/// If `false`, each new ghostty process will launch a separate application. /// -/// The default value is `desktop` which will default to `true` if Ghostty -/// detects it was launched from the `.desktop` file such as an app launcher. -/// If Ghostty is launched from the command line, it will default to `false`. +/// The default value is `detect` which will default to `true` if Ghostty +/// detects that it was launched from the `.desktop` file such as an app +/// launcher (like Gnome Shell) or by D-Bus activation. If Ghostty is launched +/// from the command line, it will default to `false`. /// /// Note that debug builds of Ghostty have a separate single-instance ID /// so you can test single instance without conflicting with release builds. @@ -3753,3 +3789,211 @@ pub const LinuxCgroup = enum { always, @"single-instance", }; + +pub const Duration = struct { + duration: u64 = 0, + + pub fn clone(self: *const @This(), _: Allocator) !@This() { + return .{ .duration = self.duration }; + } + + pub fn equal(self: @This(), other: @This()) bool { + return self.duration == other.duration; + } + + pub fn parseCLI(self: *@This(), _: Allocator, input: ?[]const u8) !void { + var remaining = input orelse { + self.duration = 0; + return; + }; + + const units = [_]struct { + name: []const u8, + factor: u64, + }{ + .{ .name = "y", .factor = 365 * std.time.ns_per_day }, + .{ .name = "w", .factor = std.time.ns_per_week }, + .{ .name = "d", .factor = std.time.ns_per_day }, + .{ .name = "h", .factor = std.time.ns_per_hour }, + .{ .name = "m", .factor = std.time.ns_per_min }, + .{ .name = "s", .factor = std.time.ns_per_s }, + .{ .name = "ms", .factor = std.time.ns_per_ms }, + .{ .name = "us", .factor = std.time.ns_per_us }, + .{ .name = "µs", .factor = std.time.ns_per_us }, + .{ .name = "ns", .factor = 1 }, + }; + + var value: ?u64 = null; + + while (remaining.len > 0) { + // Skip over whitespace before the number + while (remaining.len > 0 and std.ascii.isWhitespace(remaining[0])) { + remaining = remaining[1..]; + } + // There was whitespace at the end, that's OK + if (remaining.len == 0) break; + + // Find the longest number + const number = number: { + var prev_number: ?u64 = null; + var prev_remaining: ?[]const u8 = null; + for (1..remaining.len + 1) |index| { + prev_number = std.fmt.parseUnsigned(u64, remaining[0..index], 10) catch { + if (prev_remaining) |prev| remaining = prev; + break :number prev_number; + }; + prev_remaining = remaining[index..]; + } + if (prev_remaining) |prev| remaining = prev; + break :number prev_number; + } orelse return error.InvalidValue; + + // Skip over any whitespace between the number and the unit + while (remaining.len > 0 and std.ascii.isWhitespace(remaining[0])) { + remaining = remaining[1..]; + } + + // A number without a unit is invalid + if (remaining.len == 0) return error.InvalidValue; + + // Find the longest matching unit. Needs to be the longest matching + // to distinguish 'm' from 'ms'. + const factor = factor: { + var prev_factor: ?u64 = null; + var prev_index: ?usize = null; + for (1..remaining.len + 1) |index| { + const next_factor = next: { + for (units) |unit| { + if (std.mem.eql(u8, unit.name, remaining[0..index])) { + break :next unit.factor; + } + } + break :next null; + }; + if (next_factor) |next| { + prev_factor = next; + prev_index = index; + } + } + if (prev_index) |index| { + remaining = remaining[index..]; + } + break :factor prev_factor; + } orelse return error.InvalidValue; + + if (value) |v| + value = v + number * factor + else + value = number * factor; + } + + self.duration = value orelse 0; + } + + pub fn formatEntry(self: @This(), formatter: anytype) !void { + var buf: [64]u8 = undefined; + var fbs = std.io.fixedBufferStream(&buf); + const writer = fbs.writer(); + + var value = self.duration; + + const units = [_]struct { + name: []const u8, + factor: u64, + }{ + .{ .name = "y", .factor = 365 * std.time.ns_per_day }, + .{ .name = "w", .factor = std.time.ns_per_week }, + .{ .name = "d", .factor = std.time.ns_per_day }, + .{ .name = "h", .factor = std.time.ns_per_hour }, + .{ .name = "m", .factor = std.time.ns_per_min }, + .{ .name = "s", .factor = std.time.ns_per_s }, + .{ .name = "ms", .factor = std.time.ns_per_ms }, + .{ .name = "µs", .factor = std.time.ns_per_us }, + .{ .name = "ns", .factor = 1 }, + }; + + var i: usize = 0; + for (units) |unit| { + if (value > unit.factor) { + if (i > 0) writer.writeAll(" ") catch unreachable; + const remainder = value % unit.factor; + const quotient = (value - remainder) / unit.factor; + writer.print("{d}{s}", .{ quotient, unit.name }) catch unreachable; + value = remainder; + i += 1; + } + } + + try formatter.formatEntry([]const u8, fbs.getWritten()); + } +}; + +test "parse duration" { + var d: Duration = undefined; + + try d.parseCLI(std.testing.allocator, ""); + try std.testing.expectEqual(@as(u64, 0), d.duration); + + try d.parseCLI(std.testing.allocator, "0ns"); + try std.testing.expectEqual(@as(u64, 0), d.duration); + + try d.parseCLI(std.testing.allocator, "1ns"); + try std.testing.expectEqual(@as(u64, 1), d.duration); + + try d.parseCLI(std.testing.allocator, "100ns"); + try std.testing.expectEqual(@as(u64, 100), d.duration); + + try d.parseCLI(std.testing.allocator, "1µs"); + try std.testing.expectEqual(@as(u64, 1000), d.duration); + + try d.parseCLI(std.testing.allocator, "1µs1ns"); + try std.testing.expectEqual(@as(u64, 1001), d.duration); + + try d.parseCLI(std.testing.allocator, "1µs 1ns"); + try std.testing.expectEqual(@as(u64, 1001), d.duration); + + try d.parseCLI(std.testing.allocator, " 1µs1ns"); + try std.testing.expectEqual(@as(u64, 1001), d.duration); + + try d.parseCLI(std.testing.allocator, "1µs1ns "); + try std.testing.expectEqual(@as(u64, 1001), d.duration); + + try d.parseCLI(std.testing.allocator, "1y"); + try std.testing.expectEqual(@as(u64, 365 * std.time.ns_per_day), d.duration); + + try d.parseCLI(std.testing.allocator, "1d"); + try std.testing.expectEqual(@as(u64, std.time.ns_per_day), d.duration); + + try d.parseCLI(std.testing.allocator, "1h"); + try std.testing.expectEqual(@as(u64, std.time.ns_per_hour), d.duration); + + try d.parseCLI(std.testing.allocator, "1m"); + try std.testing.expectEqual(@as(u64, std.time.ns_per_min), d.duration); + + try d.parseCLI(std.testing.allocator, "1s"); + try std.testing.expectEqual(@as(u64, std.time.ns_per_s), d.duration); + + try d.parseCLI(std.testing.allocator, "1ms"); + try std.testing.expectEqual(@as(u64, std.time.ns_per_ms), d.duration); + + try d.parseCLI(std.testing.allocator, "30s"); + try std.testing.expectEqual(@as(u64, 30 * std.time.ns_per_s), d.duration); + + try d.parseCLI(std.testing.allocator, "584y 49w 23h 34m 33s 709ms 551µs 615ns"); + try std.testing.expectEqual(std.math.maxInt(u64), d.duration); + + try std.testing.expectError(error.InvalidValue, d.parseCLI(std.testing.allocator, "1")); + try std.testing.expectError(error.InvalidValue, d.parseCLI(std.testing.allocator, "s")); + try std.testing.expectError(error.InvalidValue, d.parseCLI(std.testing.allocator, "1x")); + try std.testing.expectError(error.InvalidValue, d.parseCLI(std.testing.allocator, "1 ")); +} + +test "format duration" { + const testing = std.testing; + var buf = std.ArrayList(u8).init(testing.allocator); + defer buf.deinit(); + + var p: Duration = .{ .duration = std.math.maxInt(u64) }; + try p.formatEntry(formatterpkg.entryFormatter("a", buf.writer())); + try std.testing.expectEqualStrings("a = 584y 49w 23h 34m 33s 709ms 551µs 615ns\n", buf.items); +}