Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-16 08:46:08 +03:00
Code Issues Packages Projects Releases Wiki Activity

apprt/glfw: convert to new key2callback

Browse Source
This commit is contained in:
Mitchell Hashimoto
2023-08-16 13:34:31 -07:00
parent cd90b2a716
commit dd385cc633
1 changed files with 37 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/apprt/glfw.zig
View File

@ -282,10 +282,11 @@ pub const Surface = struct {
/// A core surface
core_surface: CoreSurface,
/// This is set to true when keyCallback consumes the input, suppressing
/// the charCallback from being fired.
key_consumed: bool = false,
key_mods: input.Mods = .{},
/// This is the key event that was processed in keyCallback. This is only
/// non-null if the event was NOT consumed in keyCallback. This lets us
/// know in charCallback whether we should populate it and call it again.
/// (GLFW guarantees that charCallback is called after keyCallback).
key_event: ?input.KeyEvent = null,
pub const Options = struct {};
@ -592,14 +593,21 @@ pub const Surface = struct {
const core_win = window.getUserPointer(CoreSurface) orelse return;
// If our keyCallback consumed the key input, don't emit a char.
if (core_win.rt_surface.key_consumed) {
core_win.rt_surface.key_consumed = false;
return;
}
// We need a key event in order to process the charcallback. If it
// isn't set then the key event was consumed.
var key_event = core_win.rt_surface.key_event orelse return;
core_win.rt_surface.key_event = null;
core_win.charCallback(codepoint, core_win.rt_surface.key_mods) catch |err| {
log.err("error in char callback err={}", .{err});
// Populate the utf8 value for the event
var buf: [4]u8 = undefined;
const len = std.unicode.utf8Encode(codepoint, &buf) catch |err| {
log.err("error encoding codepoint={} err={}", .{ codepoint, err });
return;
};
key_event.utf8 = buf[0..len];
_ = core_win.key2Callback(key_event) catch |err| {
log.err("error in key callback err={}", .{err});
return;
};
}
@ -755,18 +763,28 @@ pub const Surface = struct {
=> .invalid,
};
// TODO: we need to do mapped keybindings
const key_event: input.KeyEvent = .{
.action = action,
.key = key,
.physical_key = key,
.mods = mods,
.consumed_mods = .{},
.composing = false,
.utf8 = "",
};
core_win.rt_surface.key_mods = mods;
core_win.rt_surface.key_consumed = core_win.keyCallback(
action,
key,
key,
mods,
) catch |err| {
const consumed = core_win.key2Callback(key_event) catch |err| {
log.err("error in key callback err={}", .{err});
return;
};
// If it wasn't consumed, we set it on our self so that charcallback
// can make another attempt. Otherwise, we set null so the charcallback
// is ignored.
core_win.rt_surface.key_event = null;
if (!consumed and (action == .press or action == .repeat)) {
core_win.rt_surface.key_event = key_event;
}
}
fn focusCallback(window: glfw.Window, focused: bool) void {