Keep every captured key owned until its own release
Binding capture tracked one owned key, so a second capture could overwrite an unreleased earlier choice and leak its repeats. Ownership is now a bitset over scancodes, released per key or on focus loss, with successive-capture, release order, cancel and focus-loss regressions. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -72,3 +72,8 @@ is suppressed while it is held). The adapter runs an idle toolkit frame when not
|
||||
is drawn and bounds the toolkit input queue at 512 events (dropped with every
|
||||
toolkit key/button released). The Controls host logic lives in
|
||||
`apps/evo-client/controls_flow.hpp` and is rehearsed with the real adapter.
|
||||
|
||||
Follow-up: ownership is a set (one bit per SDL scancode), not a single key. Each
|
||||
chosen key is released only by its own key-up or by focus loss; a later capture,
|
||||
or cancelling it, never transfers or drops earlier ownership; text stays
|
||||
suppressed while any owned key is held.
|
||||
|
||||
@@ -85,7 +85,8 @@ the keys in force. `client-panels` checks the panel geometry and that a slot cli
|
||||
requests capture without a world click.
|
||||
|
||||
Capture and toolkit (M9.8d review): arming binding capture clears the toolkit's held
|
||||
keys/modifiers and its queued keyboard/text input; the chosen key is consumed until
|
||||
released (repeats, text, release), and focus loss frees it. With no overlay or a
|
||||
keys/modifiers and its queued keyboard/text input; every chosen key is consumed
|
||||
until its own release (repeats, text, release), across successive captures; focus
|
||||
loss frees them all. With no overlay or a
|
||||
paused window the adapter still runs idle toolkit frames; more than 512 queued
|
||||
toolkit events are dropped with all toolkit keys/buttons released.
|
||||
|
||||
@@ -3831,3 +3831,22 @@ repository format check.
|
||||
|
||||
Limits: physical keyboards, non-US layouts and IME remain unqualified; the Apply
|
||||
rehearsal is automated with synthetic events, not a manual session.
|
||||
|
||||
|
||||
## 2026-10-02 — M9.8d follow-up (.cache/reviews/m98d-followup-review.md)
|
||||
|
||||
Owned capture keys are now a bounded set (bitset over SDL scancodes) instead of one
|
||||
optional key, so a second capture cannot overwrite an unreleased earlier choice.
|
||||
Lifecycle regressions in `capture_balances_toolkit`: W then K chosen with K released
|
||||
first (W repeat/text reach neither toolkit nor world until W's release, then a
|
||||
fresh W moves and reaches the toolkit); reverse release order (K stays owned after
|
||||
J's release; text flows again only when nothing is owned); cancel during a second
|
||||
capture keeps the first key owned; focus loss frees both; positive controls after
|
||||
each. Negative check: restoring single-key ownership fails the W repeat check.
|
||||
|
||||
Executed: Windows MSVC client 9/9 and client-network 10/10 (final, after
|
||||
formatting). Linux: clang-19 client-probe with clang-tidy (keep-going, no owned
|
||||
diagnostics) CTest 13/13; Xvfb lifecycle and panels; Clang ASan/UBSan CTest 13/13
|
||||
plus Xvfb lifecycle/panels; GCC 14 client-network CTest 10/10; clang-tidy app
|
||||
main/panels; format check. Synthetic event sequences only: physical OS repeat with
|
||||
several held keys, non-US layouts and IME remain unqualified.
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
#include "render/sdl_renderer.hpp"
|
||||
#define SDL_MAIN_HANDLED
|
||||
#include <SDL3/SDL_main.h>
|
||||
#include <bitset>
|
||||
#include <cmath>
|
||||
#include <imgui.h>
|
||||
#include <imgui_impl_sdl3.h>
|
||||
@@ -126,9 +127,10 @@ struct Application::Impl {
|
||||
bool backlogged{false};
|
||||
bool key_capture{false}; // Binding capture armed.
|
||||
std::optional<KeyCode> captured_key; // Taken once by the host.
|
||||
// The chosen physical key stays owned by capture until its release (or focus loss):
|
||||
// its repeats, text and release reach neither the toolkit nor the world.
|
||||
std::optional<SDL_Scancode> owned_key;
|
||||
// Every chosen physical key stays owned by capture until its own release (or focus
|
||||
// loss), across successive captures: its repeats and release reach neither the
|
||||
// toolkit nor the world, and text is suppressed while any is held.
|
||||
std::bitset<SDL_SCANCODE_COUNT> owned_keys;
|
||||
// Capture sources: an external modal/launcher, the legacy Tab toggle and the
|
||||
// toolkit's own keyboard focus. World actions run only when none applies.
|
||||
bool external_capture{false}, tab_capture{false}, toolkit_capture{false};
|
||||
@@ -304,16 +306,19 @@ std::expected<void, Error> Application::poll_events() {
|
||||
: event.type == SDL_EVENT_TEXT_INPUT ? event.text.windowID == id
|
||||
: event.type == SDL_EVENT_TEXT_EDITING ? event.edit.windowID == id
|
||||
: false;
|
||||
const auto code = key_event ? static_cast<std::size_t>(event.key.scancode) : 0;
|
||||
const bool known = key_event && code < p.owned_keys.size();
|
||||
const bool owned =
|
||||
keyboard && p.owned_key && (!key_event || event.key.scancode == *p.owned_key);
|
||||
keyboard && (key_event ? known && p.owned_keys.test(code) : p.owned_keys.any());
|
||||
if (keyboard && (p.key_capture || owned)) {
|
||||
if (p.key_capture && event.type == SDL_EVENT_KEY_DOWN && !event.key.repeat) {
|
||||
p.captured_key = static_cast<KeyCode>(event.key.scancode);
|
||||
p.owned_key = event.key.scancode;
|
||||
if (known)
|
||||
p.owned_keys.set(code);
|
||||
p.key_capture = false;
|
||||
p.update_capture(); // Drains the rest of this batch before world input.
|
||||
} else if (owned && event.type == SDL_EVENT_KEY_UP) {
|
||||
p.owned_key.reset();
|
||||
p.owned_keys.reset(code); // Only that key; others stay owned.
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -355,8 +360,8 @@ std::expected<void, Error> Application::poll_events() {
|
||||
if (!p.state.accepts_input()) {
|
||||
p.press.reset(); // A release may never arrive for this window.
|
||||
p.ui_press = false;
|
||||
p.owned_key.reset(); // The toolkit clears its own keys on focus loss.
|
||||
if (p.key_capture) { // Focus loss cancels binding capture without a key.
|
||||
p.owned_keys.reset(); // The toolkit clears its own keys on focus loss.
|
||||
if (p.key_capture) { // Focus loss cancels binding capture without a key.
|
||||
p.key_capture = false;
|
||||
p.update_capture();
|
||||
}
|
||||
|
||||
@@ -667,6 +667,76 @@ void capture_balances_toolkit() {
|
||||
// World input still works with fresh presses.
|
||||
push(SDL_SCANCODE_W, true);
|
||||
CHECK(app->poll_events() && move_y() == 1000);
|
||||
push(SDL_SCANCODE_W, false);
|
||||
CHECK(app->poll_events() && move_y() == 0);
|
||||
// Successive captures (follow-up review): every chosen key stays owned until its
|
||||
// own release; a second capture never overwrites the first.
|
||||
const auto choose = [&](SDL_Scancode scancode) {
|
||||
app->begin_key_capture();
|
||||
push(scancode, true);
|
||||
CHECK(app->poll_events() && app->take_captured_key() == static_cast<KeyCode>(scancode));
|
||||
};
|
||||
const auto quiet = [&](SDL_Scancode repeated) { // Repeat + text: nothing reaches anyone.
|
||||
push(repeated, true, true);
|
||||
text("x");
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0 && move_y() == 0);
|
||||
CHECK(app->present(frame) == Step::rendered);
|
||||
};
|
||||
const auto fresh = [&](SDL_Scancode scancode, ImGuiKey toolkit_key) { // Positive control.
|
||||
push(scancode, true);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() > 0);
|
||||
CHECK(app->present(frame) == Step::rendered && ImGui::IsKeyDown(toolkit_key));
|
||||
push(scancode, false);
|
||||
frame_once();
|
||||
CHECK(!ImGui::IsKeyDown(toolkit_key));
|
||||
};
|
||||
// a) W (a world key) then K chosen while W is held; K released first.
|
||||
app->set_ui_capture(true);
|
||||
choose(SDL_SCANCODE_W);
|
||||
choose(SDL_SCANCODE_K);
|
||||
app->set_ui_capture(false);
|
||||
push(SDL_SCANCODE_K, false);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0);
|
||||
quiet(SDL_SCANCODE_W);
|
||||
CHECK(!ImGui::IsKeyDown(ImGuiKey_W) && !ImGui::IsKeyDown(ImGuiKey_K));
|
||||
push(SDL_SCANCODE_W, false);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0);
|
||||
push(SDL_SCANCODE_W, true); // Fresh press: world and toolkit both see it.
|
||||
CHECK(app->poll_events() && move_y() == 1000);
|
||||
CHECK(app->present(frame) == Step::rendered && ImGui::IsKeyDown(ImGuiKey_W));
|
||||
push(SDL_SCANCODE_W, false);
|
||||
frame_once();
|
||||
fresh(SDL_SCANCODE_K, ImGuiKey_K);
|
||||
// b) Reverse release order: J then K chosen; J released first, K still owned.
|
||||
choose(SDL_SCANCODE_J);
|
||||
choose(SDL_SCANCODE_K);
|
||||
push(SDL_SCANCODE_J, false);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0);
|
||||
quiet(SDL_SCANCODE_K);
|
||||
push(SDL_SCANCODE_K, false);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0);
|
||||
text("x"); // Nothing owned any more: text flows again.
|
||||
CHECK(app->poll_events() && queued_keyboard_events() > 0);
|
||||
frame_once();
|
||||
fresh(SDL_SCANCODE_J, ImGuiKey_J);
|
||||
fresh(SDL_SCANCODE_K, ImGuiKey_K);
|
||||
// c) Cancel during the second capture keeps the first key owned.
|
||||
choose(SDL_SCANCODE_J);
|
||||
app->begin_key_capture();
|
||||
app->cancel_key_capture();
|
||||
quiet(SDL_SCANCODE_J);
|
||||
push(SDL_SCANCODE_J, false);
|
||||
CHECK(app->poll_events() && queued_keyboard_events() == 0);
|
||||
fresh(SDL_SCANCODE_J, ImGuiKey_J);
|
||||
// d) Focus loss frees every owned key.
|
||||
choose(SDL_SCANCODE_J);
|
||||
choose(SDL_SCANCODE_K);
|
||||
send(SDL_EVENT_WINDOW_FOCUS_LOST, id);
|
||||
send(SDL_EVENT_WINDOW_FOCUS_GAINED, id);
|
||||
CHECK(app->poll_events() && app->poll_events());
|
||||
frame_once();
|
||||
fresh(SDL_SCANCODE_J, ImGuiKey_J);
|
||||
fresh(SDL_SCANCODE_K, ImGuiKey_K);
|
||||
// While paused (hidden) nothing is drawn, yet the toolkit queue stays bounded.
|
||||
send(SDL_EVENT_WINDOW_HIDDEN, id);
|
||||
for (int round = 0; round < 20; ++round) {
|
||||
|
||||
Reference in New Issue
Block a user