gtk: implement audio bell

Author: jcollie

include/ghostty.h

@@ -597,6 +597,7 @@ typedef enum {
   GHOSTTY_ACTION_COLOR_CHANGE,
   GHOSTTY_ACTION_RELOAD_CONFIG,
   GHOSTTY_ACTION_CONFIG_CHANGE,
+  GHOSTTY_ACTION_BELL,
 } ghostty_action_tag_e;
 
 typedef union {

src/Surface.zig

@@ -943,6 +943,8 @@ pub fn handleMessage(self: *Surface, msg: Message) !void {
         .present_surface => try self.presentSurface(),
 
         .password_input => |v| try self.passwordInput(v),
+
+        .bell => self.bell(),
     }
 }
 
@@ -4694,3 +4696,15 @@ fn presentSurface(self: *Surface) !void {
         {},
     );
 }
+
+fn bell(self: *Surface) void {
+    self.rt_app.performAction(
+        .{ .surface = self },
+        .bell,
+        {},
+    ) catch |err| {
+        // We ignore this error because we don't want to fail this entire
+        // operation just because the apprt failed to activate the bell.
+        log.warn("apprt failed to activate the bell err={}", .{err});
+    };
+}

src/apprt/action.zig

@@ -226,6 +226,9 @@ pub const Action = union(Key) {
     /// for changes.
     config_change: ConfigChange,
 
+    /// The system has received a request to activate the bell.
+    bell: void,
+
     /// Sync with: ghostty_action_tag_e
     pub const Key = enum(c_int) {
         quit,
@@ -266,6 +269,7 @@ pub const Action = union(Key) {
         color_change,
         reload_config,
         config_change,
+        bell,
     };
 
     /// Sync with: ghostty_action_u

src/apprt/glfw.zig

@@ -238,6 +238,7 @@ pub const App = struct {
             .pwd,
             .config_change,
             .toggle_maximize,
+            .bell,
             => log.info("unimplemented action={}", .{action}),
         }
     }

src/apprt/gtk/App.zig

@@ -548,6 +548,7 @@ pub fn performAction(
         .toggle_split_zoom => self.toggleSplitZoom(target),
         .toggle_window_decorations => self.toggleWindowDecorations(target),
         .quit_timer => self.quitTimer(value),
+        .bell => self.bell(target),
 
         // Unimplemented
         .close_all_windows,
@@ -1007,6 +1008,16 @@ pub fn reloadConfig(
     self.config = config;
 }
 
+fn bell(
+    _: *App,
+    target: apprt.Target,
+) void {
+    switch (target) {
+        .app => {},
+        .surface => |surface| surface.rt_surface.bell(),
+    }
+}
+
 /// Call this anytime the configuration changes.
 fn syncConfigChanges(self: *App) !void {
     try self.updateConfigErrors();

src/apprt/gtk/Surface.zig

@@ -1293,6 +1293,82 @@ fn showContextMenu(self: *Surface, x: f32, y: f32) void {
     c.gtk_popover_popup(@ptrCast(@alignCast(window.context_menu)));
 }
 
+pub fn bell(self: *Surface) void {
+    inline for (std.meta.fields(configpkg.Config.BellFeatures.Features)) |field| {
+        const feature = std.meta.stringToEnum(configpkg.Config.BellFeatures.Features, field.name) orelse unreachable;
+        const enabled = @field(self.app.config.@"bell-features", field.name);
+        if (enabled) {
+            switch (feature) {
+                .system => system: {
+                    const native = c.gtk_widget_get_native(@ptrCast(@alignCast(self.overlay))) orelse break :system;
+                    const surface = c.gtk_native_get_surface(native) orelse break :system;
+                    c.gdk_surface_beep(surface);
+                },
+                .audio => audio: {
+                    var arena = std.heap.ArenaAllocator.init(self.app.core_app.alloc);
+                    defer arena.deinit();
+                    const alloc = arena.allocator();
+                    const filename = self.app.config.@"bell-audio" orelse break :audio;
+                    const pathname = pathname: {
+                        if (std.fs.path.isAbsolute(filename))
+                            break :pathname alloc.dupeZ(u8, filename) catch |err| {
+                                log.warn("unable to allocate space for bell audio pathname: {}", .{err});
+                                break :audio;
+                            }
+                        else
+                            break :pathname std.fs.path.joinZ(alloc, &.{
+                                internal_os.xdg.config(alloc, .{ .subdir = "ghostty/media" }) catch |err| {
+                                    log.warn("unable to determine media config subdir: {}", .{err});
+                                    break :audio;
+                                },
+                                filename,
+                            }) catch |err| {
+                                log.warn("unable to allocate space for bell audio pathname: {}", .{err});
+                                break :audio;
+                            };
+                    };
+                    std.fs.accessAbsoluteZ(pathname, .{ .mode = .read_only }) catch {
+                        log.warn("unable to find sound file: {s}", .{filename});
+                        break :audio;
+                    };
+                    const stream = c.gtk_media_file_new_for_filename(pathname);
+                    _ = c.g_signal_connect_data(
+                        stream,
+                        "notify::error",
+                        c.G_CALLBACK(&gtkStreamError),
+                        stream,
+                        null,
+                        c.G_CONNECT_DEFAULT,
+                    );
+                    _ = c.g_signal_connect_data(
+                        stream,
+                        "notify::ended",
+                        c.G_CALLBACK(&gtkStreamEnded),
+                        stream,
+                        null,
+                        c.G_CONNECT_DEFAULT,
+                    );
+                    c.gtk_media_stream_set_volume(stream, 1.0);
+                    c.gtk_media_stream_play(stream);
+                },
+                // inline else => {
+                //     log.warn("bell feature '{s}' is not supported", .{field.name});
+                // },
+            }
+        }
+    }
+}
+
+fn gtkStreamError(stream: ?*c.GObject) callconv(.C) void {
+    const err = c.gtk_media_stream_get_error(@ptrCast(stream));
+    if (err) |e|
+        log.err("error playing bell: {s} {d} {s}", .{ c.g_quark_to_string(e.*.domain), e.*.code, e.*.message });
+}
+
+fn gtkStreamEnded(stream: ?*c.GObject) callconv(.C) void {
+    c.g_object_unref(stream);
+}
+
 fn gtkRealize(area: *c.GtkGLArea, ud: ?*anyopaque) callconv(.C) void {
     log.debug("gl surface realized", .{});
 

src/apprt/surface.zig

@@ -81,6 +81,9 @@ pub const Message = union(enum) {
     /// The terminal has reported a change in the working directory.
     pwd_change: WriteReq,
 
+    /// Bell
+    bell: void,
+
     pub const ReportTitleStyle = enum {
         csi_21_t,
 

src/config/Config.zig

@@ -2247,6 +2247,30 @@ term: []const u8 = "xterm-ghostty",
 /// This only works on macOS since only macOS has an auto-update feature.
 @"auto-update-channel": ?build_config.ReleaseChannel = null,
 
+/// Bell features to enable if bell support is available in your runtime. The
+/// format of this is a list of features to enable separated by commas. If you
+/// prefix a feature with `no-` then it is disabled. If you omit a feature, its
+/// default value is used, so you must explicitly disable features you don't
+/// want.
+///
+/// Available features:
+///
+///   * `system` - Use a system function to play an audible sound. This differs
+///     from the `audio` feature in that the sound played is not customizable
+///     from within Ghostty. Your system may allow for the sound to be
+///     customized externally to Ghostty.
+///   * `audio` - Play a custom sound. (GTK only).
+///
+/// Example: `audio`, `no-audio`, `system`, `no-system`:
+///
+/// By default, no bell features are enabled.
+@"bell-features": BellFeatures = .{},
+
+/// If `audio` is an enabled bell feature, this is a path to an audio file.
+/// If the path is not absolute, it is considered relative to the `media`
+/// subdirectory of the Ghostty configuration directory.
+@"bell-audio": ?[:0]const u8 = null,
+
 /// This is set by the CLI parser for deinit.
 _arena: ?ArenaAllocator = null,
 
@@ -6881,3 +6905,11 @@ test "theme specifying light/dark sets theme usage in conditional state" {
         try testing.expect(cfg._conditional_set.contains(.theme));
     }
 }
+
+/// Bell features
+pub const BellFeatures = packed struct {
+    system: bool = false,
+    audio: bool = false,
+
+    pub const Features = std.meta.FieldEnum(@This());
+};

src/termio/stream_handler.zig

@@ -325,9 +325,8 @@ pub const StreamHandler = struct {
         try self.terminal.printRepeat(count);
     }
 
-    pub fn bell(self: StreamHandler) !void {
-        _ = self;
-        log.info("BELL", .{});
+    pub fn bell(self: *StreamHandler) !void {
+        self.surfaceMessageWriter(.{ .bell = {} });
     }
 
     pub fn backspace(self: *StreamHandler) !void {