gtk: add option to not link against libX11

src/apprt/gtk/App.zig

@@ -15,6 +15,7 @@ const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const builtin = @import("builtin");
 const build_config = @import("../../build_config.zig");
+const build_options = @import("build_options");
 const apprt = @import("../../apprt.zig");
 const configpkg = @import("../../config.zig");
 const input = @import("../../input.zig");
@@ -360,6 +361,7 @@ pub fn init(core_app: *CoreApp, opts: Options) !App {
     // keyboard state but the block does more than that (i.e. setting up
     // WM_CLASS).
     const x11_xkb: ?x11.Xkb = x11_xkb: {
+        if (comptime !build_options.x11) break :x11_xkb null;
         if (!x11.is_display(display)) break :x11_xkb null;
 
         // Set the X11 window class property (WM_CLASS) if are are on an X11

src/apprt/gtk/Surface.zig

@@ -6,6 +6,7 @@ const Surface = @This();
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const build_config = @import("../../build_config.zig");
+const build_options = @import("build_options");
 const configpkg = @import("../../config.zig");
 const apprt = @import("../../apprt.zig");
 const font = @import("../../font/main.zig");
@@ -1183,7 +1184,7 @@ fn showContextMenu(self: *Surface, x: f32, y: f32) void {
         @ptrCast(window.window),
         &c.GRAPHENE_POINT_INIT(point.x, point.y),
         @ptrCast(&point),
-    ) == c.False) {
+    ) == 0) {
         log.warn("failed computing point for context menu", .{});
         return;
     }
@@ -1899,7 +1900,7 @@ pub fn dimSurface(self: *Surface) void {
     // Don't dim surface if context menu is open.
     // This means we got unfocused due to it opening.
     const context_menu_open = c.gtk_widget_get_visible(window.context_menu);
-    if (context_menu_open == c.True) return;
+    if (context_menu_open == 1) return;
 
     if (self.unfocused_widget != null) return;
     self.unfocused_widget = c.gtk_drawing_area_new();

src/apprt/gtk/Window.zig

@@ -257,7 +257,7 @@ pub fn init(self: *Window, app: *App) !void {
 
     self.context_menu = c.gtk_popover_menu_new_from_model(@ptrCast(@alignCast(self.app.context_menu)));
     c.gtk_widget_set_parent(self.context_menu, window);
-    c.gtk_popover_set_has_arrow(@ptrCast(@alignCast(self.context_menu)), c.False);
+    c.gtk_popover_set_has_arrow(@ptrCast(@alignCast(self.context_menu)), 0);
     c.gtk_widget_set_halign(self.context_menu, c.GTK_ALIGN_START);
 
     // If we are in fullscreen mode, new windows start fullscreen.

src/apprt/gtk/c.zig

@@ -1,15 +1,19 @@
+const build_options = @import("build_options");
+
 /// Imported C API directly from header files
 pub const c = @cImport({
     @cInclude("gtk/gtk.h");
-    if (@import("build_options").adwaita) {
+    if (build_options.adwaita) {
         @cInclude("libadwaita-1/adwaita.h");
     }
 
-    // Add in X11-specific GDK backend which we use for specific things
-    // (e.g. X11 window class).
-    @cInclude("gdk/x11/gdkx.h");
-    // Xkb for X11 state handling
-    @cInclude("X11/XKBlib.h");
+    if (build_options.x11) {
+        // Add in X11-specific GDK backend which we use for specific things
+        // (e.g. X11 window class).
+        @cInclude("gdk/x11/gdkx.h");
+        // Xkb for X11 state handling
+        @cInclude("X11/XKBlib.h");
+    }
 
     // generated header files
     @cInclude("ghostty_resources.h");

src/apprt/gtk/key.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const build_options = @import("build_options");
 const input = @import("../../input.zig");
 const c = @import("c.zig").c;
 const x11 = @import("x11.zig");
@@ -111,21 +112,25 @@ pub fn eventMods(
     x11_xkb: ?*x11.Xkb,
 ) input.Mods {
     const device = c.gdk_event_get_device(event);
-    const display = c.gtk_widget_get_display(widget);
 
-    var mods = if (x11_xkb) |xkb|
-        // Add any modifier state events from Xkb if we have them (X11
-        // only). Null back from the Xkb call means there was no modifier
-        // event to read. This likely means that the key event did not
-        // result in a modifier change and we can safely rely on the GDK
-        // state.
-        xkb.modifier_state_from_notify(display) orelse
-            translateMods(gtk_mods)
-    else
+    var mods = mods: {
+        if (comptime build_options.x11) {
+            const display = c.gtk_widget_get_display(widget);
+            if (x11_xkb) |xkb| {
+                // Add any modifier state events from Xkb if we have them (X11
+                // only). Null back from the Xkb call means there was no modifier
+                // event to read. This likely means that the key event did not
+                // result in a modifier change and we can safely rely on the GDK
+                // state.
+                if (xkb.modifier_state_from_notify(display)) |x11_mods| break :mods x11_mods;
+                break :mods translateMods(gtk_mods);
+            }
+        }
         // On Wayland, we have to use the GDK device because the mods sent
         // to this event do not have the modifier key applied if it was
         // presssed (i.e. left control).
-        translateMods(c.gdk_device_get_modifier_state(device));
+        break :mods translateMods(c.gdk_device_get_modifier_state(device));
+    };
 
     mods.num_lock = c.gdk_device_get_num_lock_state(device) == 1;
 

src/apprt/gtk/x11.zig

@@ -1,5 +1,6 @@
 /// Utility functions for X11 handling.
 const std = @import("std");
+const build_options = @import("build_options");
 const c = @import("c.zig").c;
 const input = @import("../../input.zig");
 
@@ -7,6 +8,7 @@ const log = std.log.scoped(.gtk_x11);
 
 /// Returns true if the passed in display is an X11 display.
 pub fn is_display(display: ?*c.GdkDisplay) bool {
+    if (comptime !build_options.x11) return false;
     return c.g_type_check_instance_is_a(
         @ptrCast(@alignCast(display orelse return false)),
         c.gdk_x11_display_get_type(),
@@ -15,11 +17,12 @@ pub fn is_display(display: ?*c.GdkDisplay) bool {
 
 /// Returns true if the app is running on X11
 pub fn is_current_display_server() bool {
+    if (comptime !build_options.x11) return false;
     const display = c.gdk_display_get_default();
     return is_display(display);
 }
 
-pub const Xkb = struct {
+pub const Xkb = if (build_options.x11) struct {
     base_event_code: c_int,
     funcs: Funcs,
 
@@ -111,7 +114,7 @@ pub const Xkb = struct {
 
         return mods;
     }
-};
+} else struct {};
 
 /// The functions that we load dynamically from libX11.so.
 const Funcs = struct {

src/build_config.zig

@@ -22,6 +22,7 @@ pub const BuildConfig = struct {
     version: std.SemanticVersion = .{ .major = 0, .minor = 0, .patch = 0 },
     flatpak: bool = false,
     adwaita: bool = false,
+    x11: bool = false,
     app_runtime: apprt.Runtime = .none,
     renderer: rendererpkg.Impl = .opengl,
     font_backend: font.Backend = .freetype,
@@ -41,6 +42,7 @@ pub const BuildConfig = struct {
         // support all types.
         step.addOption(bool, "flatpak", self.flatpak);
         step.addOption(bool, "adwaita", self.adwaita);
+        step.addOption(bool, "x11", self.x11);
         step.addOption(apprt.Runtime, "app_runtime", self.app_runtime);
         step.addOption(font.Backend, "font_backend", self.font_backend);
         step.addOption(rendererpkg.Impl, "renderer", self.renderer);

src/cli/version.zig

@@ -61,6 +61,11 @@ pub fn run(alloc: Allocator) !u8 {
         } else {
             try stdout.print("  - libadwaita : disabled\n", .{});
         }
+        if (comptime build_options.x11) {
+            try stdout.print("  - libX11     : enabled\n", .{});
+        } else {
+            try stdout.print("  - libX11     : disabled\n", .{});
+        }
     }
     return 0;
 }