gtk: add option to always display the tab bar

Also fixes crashes in both vanilla GTK and Adwaita implementations of
`closeTab`, which erroneously close windows twice when there are no
more tabs left (we probably already handle it somewhere else).

Author: pluiedev

src/apprt/gtk/Window.zig

@@ -285,81 +285,94 @@ pub fn init(self: *Window, app: *App) !void {
     // Our actions for the menu
     initActions(self);
 
-    if ((comptime adwaita.versionAtLeast(1, 4, 0)) and adwaita.versionAtLeast(1, 4, 0) and adwaita.enabled(&self.app.config)) {
-        const toolbar_view: *c.AdwToolbarView = @ptrCast(c.adw_toolbar_view_new());
+    tab_bar: {
+        if ((comptime !adwaita.versionAtLeast(0, 0, 0)) or !adwaita.enabled(&self.app.config)) {
+            // Directly place the headerbar in the window when Adwaita is disabled,
+            // since the tab bar is a part of the headerbar/GtkNotebook
+            c.gtk_window_set_titlebar(gtk_window, self.headerbar.asWidget());
+            c.gtk_window_set_child(gtk_window, box);
+            break :tab_bar;
+        }
 
-        c.adw_toolbar_view_add_top_bar(toolbar_view, self.headerbar.asWidget());
+        const tab_bar = c.adw_tab_bar_new();
+        c.adw_tab_bar_set_view(tab_bar, self.notebook.adw.tab_view);
 
-        if (self.app.config.@"gtk-tabs-location" != .hidden) {
-            const tab_bar = c.adw_tab_bar_new();
-            c.adw_tab_bar_set_view(tab_bar, self.notebook.adw.tab_view);
+        if (!app.config.@"gtk-wide-tabs") c.adw_tab_bar_set_expand_tabs(tab_bar, 0);
 
-            if (!app.config.@"gtk-wide-tabs") c.adw_tab_bar_set_expand_tabs(tab_bar, 0);
+        c.adw_tab_bar_set_autohide(
+            tab_bar,
+            @intFromBool(switch (app.config.@"window-show-tab-bar") {
+                .always => false,
+                .auto, .never => true,
+            }),
+        );
+
+        const tab_bar_widget: *c.GtkWidget = @ptrCast(@alignCast(tab_bar));
+
+        c.gtk_widget_set_visible(
+            tab_bar_widget,
+            @intFromBool(switch (app.config.@"window-show-tab-bar") {
+                .always, .auto => true,
+                .never => false,
+            }),
+        );
+
+        // Can we use ToolbarView (libadw 1.4+)? If so, put both the headerbar
+        // and the tab bar as sub-bars of the toolbar view
+        if ((comptime adwaita.versionAtLeast(1, 4, 0)) and adwaita.versionAtLeast(1, 4, 0)) {
+            const toolbar_view: *c.AdwToolbarView = @ptrCast(c.adw_toolbar_view_new());
+
+            c.adw_toolbar_view_add_top_bar(toolbar_view, self.headerbar.asWidget());
 
-            const tab_bar_widget: *c.GtkWidget = @ptrCast(@alignCast(tab_bar));
             switch (self.app.config.@"gtk-tabs-location") {
                 // left and right are not supported in libadwaita.
                 .top, .left, .right => c.adw_toolbar_view_add_top_bar(toolbar_view, tab_bar_widget),
                 .bottom => c.adw_toolbar_view_add_bottom_bar(toolbar_view, tab_bar_widget),
-                .hidden => unreachable,
+                .hidden => {},
+            }
+            c.adw_toolbar_view_set_content(toolbar_view, box);
+
+            const toolbar_style: c.AdwToolbarStyle = switch (self.app.config.@"adw-toolbar-style") {
+                .flat => c.ADW_TOOLBAR_FLAT,
+                .raised => c.ADW_TOOLBAR_RAISED,
+                .@"raised-border" => c.ADW_TOOLBAR_RAISED_BORDER,
+            };
+            c.adw_toolbar_view_set_top_bar_style(toolbar_view, toolbar_style);
+            c.adw_toolbar_view_set_bottom_bar_style(toolbar_view, toolbar_style);
+
+            // Set our application window content.
+            c.adw_tab_overview_set_child(
+                @ptrCast(self.tab_overview),
+                @ptrCast(@alignCast(toolbar_view)),
+            );
+            c.adw_application_window_set_content(
+                @ptrCast(gtk_window),
+                @ptrCast(@alignCast(self.tab_overview)),
+            );
+        } else {
+            // Older libadwaita versions don't support toolbar views.
+            // We have to add the tab bar directly to the main box, either
+            // as the last child of the box (bottom) or right after the
+            // header bar (every other option except hidden)
+            switch (app.config.@"gtk-tabs-location") {
+                .top,
+                .left,
+                .right,
+                => c.gtk_box_insert_child_after(@ptrCast(box), @ptrCast(@alignCast(tab_bar)), @ptrCast(@alignCast(self.headerbar.asWidget()))),
+
+                .bottom => c.gtk_box_append(
+                    @ptrCast(box),
+                    @ptrCast(@alignCast(tab_bar)),
+                ),
+                .hidden => {},
             }
-        }
-        c.adw_toolbar_view_set_content(toolbar_view, box);
-
-        const toolbar_style: c.AdwToolbarStyle = switch (self.app.config.@"adw-toolbar-style") {
-            .flat => c.ADW_TOOLBAR_FLAT,
-            .raised => c.ADW_TOOLBAR_RAISED,
-            .@"raised-border" => c.ADW_TOOLBAR_RAISED_BORDER,
-        };
-        c.adw_toolbar_view_set_top_bar_style(toolbar_view, toolbar_style);
-        c.adw_toolbar_view_set_bottom_bar_style(toolbar_view, toolbar_style);
-
-        // Set our application window content.
-        c.adw_tab_overview_set_child(
-            @ptrCast(self.tab_overview),
-            @ptrCast(@alignCast(toolbar_view)),
-        );
-        c.adw_application_window_set_content(
-            @ptrCast(gtk_window),
-            @ptrCast(@alignCast(self.tab_overview)),
-        );
-    } else tab_bar: {
-        switch (self.notebook) {
-            .adw => |*adw| if (comptime adwaita.versionAtLeast(0, 0, 0)) {
-                if (app.config.@"gtk-tabs-location" == .hidden) break :tab_bar;
-                // In earlier adwaita versions, we need to add the tabbar manually since we do not use
-                // an AdwToolbarView.
-                const tab_bar: *c.AdwTabBar = c.adw_tab_bar_new().?;
-                c.gtk_widget_add_css_class(@ptrCast(@alignCast(tab_bar)), "inline");
-                switch (app.config.@"gtk-tabs-location") {
-                    .top,
-                    .left,
-                    .right,
-                    => c.gtk_box_insert_child_after(@ptrCast(box), @ptrCast(@alignCast(tab_bar)), @ptrCast(@alignCast(self.headerbar.asWidget()))),
-
-                    .bottom => c.gtk_box_append(
-                        @ptrCast(box),
-                        @ptrCast(@alignCast(tab_bar)),
-                    ),
-                    .hidden => unreachable,
-                }
-                c.adw_tab_bar_set_view(tab_bar, adw.tab_view);
-
-                if (!app.config.@"gtk-wide-tabs") c.adw_tab_bar_set_expand_tabs(tab_bar, 0);
-            },
 
-            .gtk => {},
-        }
+            c.gtk_widget_add_css_class(@ptrCast(@alignCast(tab_bar)), "inline");
 
-        // The box is our main child
-        if (!adwaita.versionAtLeast(1, 4, 0) and adwaita.enabled(&self.app.config)) {
             c.adw_application_window_set_content(
                 @ptrCast(gtk_window),
                 box,
             );
-        } else {
-            c.gtk_window_set_titlebar(gtk_window, self.headerbar.asWidget());
-            c.gtk_window_set_child(gtk_window, box);
         }
     }
 

src/apprt/gtk/notebook_adw.zig

@@ -134,26 +134,6 @@ pub const NotebookAdw = struct {
 
         const page = c.adw_tab_view_get_page(self.tab_view, @ptrCast(tab.box)) orelse return;
         c.adw_tab_view_close_page(self.tab_view, page);
-
-        // If we have no more tabs we close the window
-        if (self.nPages() == 0) {
-            const window = tab.window.window;
-
-            // libadw versions <= 1.3.x leak the final page view
-            // which causes our surface to not properly cleanup. We
-            // unref to force the cleanup. This will trigger a critical
-            // warning from GTK, but I don't know any other workaround.
-            // Note: I'm not actually sure if 1.4.0 contains the fix,
-            // I just know that 1.3.x is broken and 1.5.1 is fixed.
-            // If we know that 1.4.0 is fixed, we can change this.
-            if (!adwaita.versionAtLeast(1, 4, 0)) {
-                c.g_object_unref(tab.box);
-            }
-
-            // `self` will become invalid after this call because it will have
-            // been freed up as part of the process of closing the window.
-            c.gtk_window_destroy(window);
-        }
     }
 };
 

src/apprt/gtk/notebook_gtk.zig

@@ -31,7 +31,6 @@ pub const NotebookGtk = struct {
         };
         c.gtk_notebook_set_tab_pos(gtk_notebook, notebook_tab_pos);
         c.gtk_notebook_set_scrollable(gtk_notebook, 1);
-        c.gtk_notebook_set_show_tabs(gtk_notebook, 0);
         c.gtk_notebook_set_show_border(gtk_notebook, 0);
 
         // This enables all Ghostty terminal tabs to be exchanged across windows.
@@ -81,6 +80,7 @@ pub const NotebookGtk = struct {
         log.warn("currentTab", .{});
         const page = self.currentPage() orelse return null;
         const child = c.gtk_notebook_get_nth_page(self.notebook, page);
+
         return @ptrCast(@alignCast(
             c.g_object_get_data(@ptrCast(child), Tab.GHOSTTY_TAB) orelse return null,
         ));
@@ -164,9 +164,7 @@ pub const NotebookGtk = struct {
         c.gtk_notebook_set_tab_reorderable(self.notebook, box_widget, 1);
         c.gtk_notebook_set_tab_detachable(self.notebook, box_widget, 1);
 
-        if (self.nPages() > 1) {
-            c.gtk_notebook_set_show_tabs(self.notebook, 1);
-        }
+        self.updateShowTabs(window);
 
         // Switch to the new tab
         c.gtk_notebook_set_current_page(self.notebook, page_idx);
@@ -183,20 +181,21 @@ pub const NotebookGtk = struct {
         c.gtk_notebook_remove_page(self.notebook, page_idx);
 
         const remaining = self.nPages();
-        switch (remaining) {
-            // If we have no more tabs we close the window
-            0 => c.gtk_window_destroy(tab.window.window),
-
-            // If we have one more tab we hide the tab bar
-            1 => c.gtk_notebook_set_show_tabs(self.notebook, 0),
-
-            else => {},
-        }
 
         // If we have remaining tabs, we need to make sure we grab focus.
         if (remaining > 0)
             (self.currentTab() orelse return).window.focusCurrentTab();
     }
+
+    fn updateShowTabs(self: *NotebookGtk, window: *Window) void {
+        const show_tabs = switch (window.app.config.@"window-show-tab-bar") {
+            .always => true,
+            .auto => self.nPages() > 1,
+            .never => false,
+        };
+
+        c.gtk_notebook_set_show_tabs(self.notebook, @intFromBool(show_tabs));
+    }
 };
 
 fn getNotebookPageIndex(page: *c.GtkNotebookPage) c_int {
@@ -245,12 +244,7 @@ fn gtkPageRemoved(
     log.warn("gtkPageRemoved", .{});
     const window: *Window = @ptrCast(@alignCast(ud.?));
 
-    // Hide the tab bar if we only have one tab after removal
-    const remaining = c.gtk_notebook_get_n_pages(window.notebook.gtk.notebook);
-
-    if (remaining == 1) {
-        c.gtk_notebook_set_show_tabs(window.notebook.gtk.notebook, 0);
-    }
+    window.notebook.gtk.updateShowTabs(window);
 }
 
 fn gtkSwitchPage(_: *c.GtkNotebook, page: *c.GtkWidget, _: usize, ud: ?*anyopaque) callconv(.C) void {

src/config/Config.zig

@@ -1336,6 +1336,26 @@ keybind: Keybinds = .{},
 ///   * `end` - Insert the new tab at the end of the tab list.
 @"window-new-tab-position": WindowNewTabPosition = .current,
 
+/// Whether to show the tab bar.
+/// Currently only supported on Linux (GTK).
+///
+/// Valid values:
+///
+///  - `always`
+///
+///    Always display the tab bar, even when there's only one tab.
+///
+///  - `auto` *(default)*
+///
+///    Automatically show and hide the tab bar. The tab bar is only
+///    shown when there are two or more tabs present.
+///
+///  - `never`
+///
+///    Never show the tab bar. Tabs are only accessible via the tab
+///    overview or by keybind actions.
+@"window-show-tab-bar": WindowShowTabBar = .auto,
+
 /// Background color for the window titlebar. This only takes effect if
 /// window-theme is set to ghostty. Currently only supported in the GTK app
 /// runtime.
@@ -5786,6 +5806,13 @@ pub const WindowNewTabPosition = enum {
     end,
 };
 
+/// See window-show-tab-bar
+pub const WindowShowTabBar = enum {
+    always,
+    auto,
+    never,
+};
+
 /// See resize-overlay
 pub const ResizeOverlay = enum {
     always,