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

core: centralize key sequence ending in one function

Browse Source
This commit is contained in:
Mitchell Hashimoto
2024-08-19 12:41:10 -07:00
parent 99b3e2e844
commit 295ef384a6
1 changed files with 36 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/Surface.zig
View File

@ -891,10 +891,7 @@ fn changeConfig(self: *Surface, config: *const configpkg.Config) !void {
// If we are in the middle of a key sequence, clear it. // If we are in the middle of a key sequence, clear it.
self.keyboard.bindings = null; self.keyboard.bindings = null;
if (self.keyboard.queued.items.len > 0) { self.endKeySequence(.drop, .free);
for (self.keyboard.queued.items) |req| req.deinit();
self.keyboard.queued.clearAndFree(self.alloc);
}
// Before sending any other config changes, we give the renderer a new font // Before sending any other config changes, we give the renderer a new font
// grid. We could check to see if there was an actual change to the font, // grid. We could check to see if there was an actual change to the font,
@ -1545,14 +1542,7 @@ fn maybeHandleBinding(
self.keyboard.bindings = null; self.keyboard.bindings = null;
// Encode everything up to this point // Encode everything up to this point
for (self.keyboard.queued.items) |write_req| { self.endKeySequence(.flush, .retain);
self.io.queueMessage(switch (write_req) {
.small => |v| .{ .write_small = v },
.stable => |v| .{ .write_stable = v },
.alloc => |v| .{ .write_alloc = v },
}, .unlocked);
}
self.keyboard.queued.clearRetainingCapacity();
} }
return null; return null;
@ -1603,10 +1593,7 @@ fn maybeHandleBinding(
// encodings, too. // encodings, too.
if (performed and consumed) { if (performed and consumed) {
// If we had queued events, we deinit them since we consumed // If we had queued events, we deinit them since we consumed
if (self.keyboard.queued.items.len > 0) { self.endKeySequence(.drop, .retain);
for (self.keyboard.queued.items) |req| req.deinit();
self.keyboard.queued.clearRetainingCapacity();
}
// Store our last trigger so we don't encode the release event // Store our last trigger so we don't encode the release event
self.keyboard.last_trigger = event.bindingHash(); self.keyboard.last_trigger = event.bindingHash();
@ -1617,20 +1604,43 @@ fn maybeHandleBinding(
// If we didn't perform OR we didn't consume, then we want to // If we didn't perform OR we didn't consume, then we want to
// encode any queued events for a sequence. // encode any queued events for a sequence.
if (self.keyboard.queued.items.len > 0) { self.endKeySequence(.flush, .retain);
for (self.keyboard.queued.items) |write_req| {
self.io.queueMessage(switch (write_req) {
.small => |v| .{ .write_small = v },
.stable => |v| .{ .write_stable = v },
.alloc => |v| .{ .write_alloc = v },
}, .unlocked);
}
self.keyboard.queued.clearRetainingCapacity();
}
return null; return null;
} }
const KeySequenceQueued = enum { flush, drop };
const KeySequenceMemory = enum { retain, free };
/// End a key sequence. Safe to call if no key sequence is active.
///
/// Action and mem determine the behavior of the queued inputs up to this
/// point.
fn endKeySequence(
self: *Surface,
action: KeySequenceQueued,
mem: KeySequenceMemory,
) void {
if (self.keyboard.queued.items.len > 0) {
switch (action) {
.flush => for (self.keyboard.queued.items) |write_req| {
self.io.queueMessage(switch (write_req) {
.small => |v| .{ .write_small = v },
.stable => |v| .{ .write_stable = v },
.alloc => |v| .{ .write_alloc = v },
}, .unlocked);
},
.drop => for (self.keyboard.queued.items) |req| req.deinit(),
}
switch (mem) {
.free => self.keyboard.queued.clearAndFree(self.alloc),
.retain => self.keyboard.queued.clearRetainingCapacity(),
}
}
}
/// Encodes the key event into a write request. The write request will /// Encodes the key event into a write request. The write request will
/// always copy or allocate so the caller can safely free the event. /// always copy or allocate so the caller can safely free the event.
fn encodeKey( fn encodeKey(