diff --git a/docs/adr/0085-rebindable-engineering-controls.md b/docs/adr/0085-rebindable-engineering-controls.md index a83111d..8efac0d 100644 --- a/docs/adr/0085-rebindable-engineering-controls.md +++ b/docs/adr/0085-rebindable-engineering-controls.md @@ -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. diff --git a/docs/engineering/CLIENT_UI_STATE.md b/docs/engineering/CLIENT_UI_STATE.md index b78472a..43ce9b3 100644 --- a/docs/engineering/CLIENT_UI_STATE.md +++ b/docs/engineering/CLIENT_UI_STATE.md @@ -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. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 4bde568..1b10179 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -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. diff --git a/src/client/platform/application.cpp b/src/client/platform/application.cpp index cb68cf6..2970d2a 100644 --- a/src/client/platform/application.cpp +++ b/src/client/platform/application.cpp @@ -2,6 +2,7 @@ #include "render/sdl_renderer.hpp" #define SDL_MAIN_HANDLED #include +#include #include #include #include @@ -126,9 +127,10 @@ struct Application::Impl { bool backlogged{false}; bool key_capture{false}; // Binding capture armed. std::optional 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 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 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 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(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(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 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(); } diff --git a/tests/client_lifecycle.cpp b/tests/client_lifecycle.cpp index df014b6..6b2e303 100644 --- a/tests/client_lifecycle.cpp +++ b/tests/client_lifecycle.cpp @@ -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(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) {