From 732063375a924190e4a42bba3c1b4d57761adbd7 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Mon, 1 Jan 2024 08:34:19 -0800 Subject: [PATCH] apprt/gtk: stylistic changes --- src/apprt/gtk/App.zig | 19 ++++++++++++------- src/apprt/gtk/Surface.zig | 21 +++++++-------------- src/apprt/gtk/x11.zig | 18 ++++++++---------- 3 files changed, 27 insertions(+), 31 deletions(-) diff --git a/src/apprt/gtk/App.zig b/src/apprt/gtk/App.zig index e9b377ec7..3d30d9ba5 100644 --- a/src/apprt/gtk/App.zig +++ b/src/apprt/gtk/App.zig @@ -57,7 +57,7 @@ clipboard_confirmation_window: ?*ClipboardConfirmationWindow = null, running: bool = true, /// Xkb state (X11 only). Will be null on Wayland. -x11_xkb: ?x11.X11Xkb = null, +x11_xkb: ?x11.Xkb = null, pub fn init(core_app: *CoreApp, opts: Options) !App { _ = opts; @@ -173,9 +173,13 @@ pub fn init(core_app: *CoreApp, opts: Options) !App { return error.GtkApplicationRegisterFailed; } - var x11_xkb: ?x11.X11Xkb = null; - const display = c.gdk_display_get_default(); - if (x11.is_display(display)) { + // Perform all X11 initialization. This ultimately returns the X11 + // keyboard state but the block does more than that (i.e. setting up + // WM_CLASS). + const x11_xkb: ?x11.Xkb = x11_xkb: { + const display = c.gdk_display_get_default(); + if (!x11.is_display(display)) break :x11_xkb null; + // Set the X11 window class property (WM_CLASS) if are are on an X11 // display. // @@ -203,8 +207,8 @@ pub fn init(core_app: *CoreApp, opts: Options) !App { c.gdk_x11_display_set_program_class(display, app_id); // Set up Xkb - x11_xkb = try x11.X11Xkb.init(c.gdk_display_get_default()); - } + 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: @@ -586,5 +590,6 @@ test "isValidAppId" { /// Loads keyboard state from Xkb if there is an event pending and Xkb is /// loaded (X11 only). Returns null otherwise. pub fn modifier_state_from_xkb(self: *App, display_: ?*c.GdkDisplay) ?input.Mods { - return (self.x11_xkb orelse return null).modifier_state_from_notify(display_); + const x11_xkb = self.x11_xkb orelse return null; + return x11_xkb.modifier_state_from_notify(display_); } diff --git a/src/apprt/gtk/Surface.zig b/src/apprt/gtk/Surface.zig index a0f2091bb..37c5155f0 100644 --- a/src/apprt/gtk/Surface.zig +++ b/src/apprt/gtk/Surface.zig @@ -1333,22 +1333,15 @@ fn keyEvent( // was presssed (i.e. left control) const mods = mods: { _ = gtk_mods; - const device = c.gdk_event_get_device(event); - var mods = init_mods: { - // Add any modifier state events from Xkb if we have them (X11 only). - if (self.app.modifier_state_from_xkb(display)) |xkb_mods| { - break :init_mods xkb_mods; - } - - // 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. - - break :init_mods translateMods(c.gdk_device_get_modifier_state(device)); - }; + // 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. + var mods = self.app.modifier_state_from_xkb(display) orelse + translateMods(c.gdk_device_get_modifier_state(device)); mods.num_lock = c.gdk_device_get_num_lock_state(device) == 1; switch (physical_key) { diff --git a/src/apprt/gtk/x11.zig b/src/apprt/gtk/x11.zig index a188df8bb..8965a72e0 100644 --- a/src/apprt/gtk/x11.zig +++ b/src/apprt/gtk/x11.zig @@ -13,13 +13,13 @@ pub fn is_display(display: ?*c.GdkDisplay) bool { ) != 0; } -pub const X11Xkb = struct { +pub const Xkb = struct { base_event_code: c_int, funcs: Funcs, - /// Initialize an X11Xkb struct, for the given GDK display. If the display + /// Initialize an Xkb struct, for the given GDK display. If the display /// isn't backed by X then this will return null. - pub fn init(display_: ?*c.GdkDisplay) !?X11Xkb { + pub fn init(display_: ?*c.GdkDisplay) !?Xkb { // Display should never be null but we just treat that as a non-X11 // display so that the caller can just ignore it and not unwrap it. const display = display_ orelse return null; @@ -27,14 +27,14 @@ pub const X11Xkb = struct { // If the display isn't X11, then we don't need to do anything. if (!is_display(display)) return null; - log.debug("X11Xkb.init: initializing Xkb", .{}); + log.debug("Xkb.init: initializing Xkb", .{}); const xdisplay = c.gdk_x11_display_get_xdisplay(display); - var result: X11Xkb = .{ + var result: Xkb = .{ .base_event_code = 0, .funcs = try Funcs.init(), }; - log.debug("X11Xkb.init: running XkbQueryExtension", .{}); + log.debug("Xkb.init: running XkbQueryExtension", .{}); var opcode: c_int = 0; var base_error_code: c_int = 0; var major = c.XkbMajorVersion; @@ -51,7 +51,7 @@ pub const X11Xkb = struct { return error.XkbInitializationError; } - log.debug("X11Xkb.init: running XkbSelectEventDetails", .{}); + log.debug("Xkb.init: running XkbSelectEventDetails", .{}); if (result.funcs.XkbSelectEventDetails( xdisplay, c.XkbUseCoreKbd, @@ -76,7 +76,7 @@ pub const X11Xkb = struct { /// Returns null if there is no event. In this case, the caller should fall /// back to the standard GDK modifier state (this likely means the key /// event did not result in a modifier change). - pub fn modifier_state_from_notify(self: X11Xkb, display_: ?*c.GdkDisplay) ?input.Mods { + pub fn modifier_state_from_notify(self: Xkb, display_: ?*c.GdkDisplay) ?input.Mods { const display = display_ orelse return null; // Shoutout to Mozilla for figuring out a clean way to do this, this is @@ -114,8 +114,6 @@ const Funcs = struct { XEventsQueued: XEventsQueuedType, XPeekEvent: XPeekEventType, - // X11 Function types. We load these dynamically at runtime to avoid having to - // link against X11. const XkbQueryExtensionType = *const fn (?*c.struct__XDisplay, [*c]c_int, [*c]c_int, [*c]c_int, [*c]c_int, [*c]c_int) callconv(.C) c_int; const XkbSelectEventDetailsType = *const fn (?*c.struct__XDisplay, c_uint, c_uint, c_ulong, c_ulong) callconv(.C) c_int; const XEventsQueuedType = *const fn (?*c.struct__XDisplay, c_int) callconv(.C) c_int;