Merge branch 'red/ff' into fw/mac1

This commit is contained in:
aiongg
2026-11-17 08:21:16 +00:00
5 changed files with 80 additions and 20 deletions
+3 -2
View File
@@ -170,9 +170,10 @@ impl CommandDef {
#[non_exhaustive]
pub enum TypingRule {
/// Plain chords (no cmd, ctrl or alt) go to the text; function keys still fire.
#[default]
PlainKeysWait,
/// Only chords with the command modifier and function keys fire.
/// Only chords with the command modifier and function keys fire: Alt and Shift chords type characters on some
/// layouts (Option on the Mac), so they stay with the text, as in Photoshop.
#[default]
CommandKeysOnly,
/// Nothing fires.
AllWait,
+9 -1
View File
@@ -156,7 +156,8 @@ pub(crate) struct State {
pub(crate) press: press::PressState,
/// The frame whose begin hook ran last; a move in the end hook belongs to the next frame.
pub(super) frame: u64,
/// The stop focus moved onto and the frame whose passes see it.
/// The stop focus last moved onto, the frame whose passes see the move, and what moved it there. It stays until focus
/// moves again: while the stop keeps the focus, it is how the stop got it (`origin`).
pub(super) arrived: Option<(u64, StopKey, FocusOrigin)>,
/// The running pass's begin hook left a Tab to egui (`NavKeys::tab_to_egui`); its end hook takes it.
pub(super) tab_to_egui: bool,
@@ -671,6 +672,13 @@ pub(crate) fn facts(ctx: &Context, id: Id) -> Facts {
}
}
/// What moved focus onto the focused stop `rec`, for as long as it keeps the focus; `None` when the focus service did
/// not move it there (an app's own widget took egui focus).
pub(crate) fn origin(ctx: &Context, rec: &StopRec) -> Option<FocusOrigin> {
let key = rec.stop.key();
with(ctx, |state| state.arrived.filter(|(_, arrived, _)| *arrived == key).map(|(.., origin)| origin))
}
/// `is_focused` and focus arrived by keyboard, so the ring shows.
pub(crate) fn focus_visible(ctx: &Context, id: Id) -> bool {
is_focused(ctx, id) && with(ctx, |state| state.visible)
+25 -9
View File
@@ -370,16 +370,36 @@ pub(super) fn focused_claims(record: &focus::FocusedRecord, stage: &Stage) -> Ve
/// canvas (a stop with `KeyUse::chrome_key`) in its last pass; `layer` is what the layer stack says about the focus
/// and `focused` is the `KeyUse` of the focused component, `None` when nothing is focused.
///
/// `pressed` is whether a pointer press moved focus onto the focused component (`focus::origin`).
///
/// A modal or dialog layer never toggles: Tab moves focus inside it. In a window with a canvas the toggle is on when
/// nothing is focused or the canvas is; elsewhere it is on only when the canvas is focused. A component that keeps
/// Tab never reaches this function: the press is its own.
fn tab_toggles_chrome(enabled: bool, canvas: bool, layer: overlay::LayerKeys, focused: Option<&KeyUse>) -> bool {
/// nothing is focused, the canvas is, or a press focused the component, as clicking a panel's row and pressing Tab hides
/// the panels in Photoshop; Tab moves focus from a component the keyboard or a request focused. Elsewhere it is on only
/// when the canvas is focused. A component that keeps Tab never reaches this function: the press is its own.
fn tab_toggles_chrome(enabled: bool, canvas: bool, layer: overlay::LayerKeys, focused: Option<&KeyUse>, pressed: bool) -> bool {
let closed = matches!(layer, overlay::LayerKeys::Blocked | overlay::LayerKeys::Class(OwnerClass::Dialog));
if !enabled || closed {
return false;
}
let on_canvas = focused.is_some_and(|keys| keys.chrome_key);
if canvas { focused.is_none() || on_canvas } else { on_canvas }
if canvas { focused.is_none() || on_canvas || pressed } else { on_canvas }
}
/// Whether a bare Tab pressed now in the running viewport would toggle its panels rather than move focus, by
/// [`tab_toggles_chrome`] over the viewport's root env, canvas, layers and focus.
pub(super) fn tab_toggles_now(ctx: &Context) -> bool {
let viewport = crate::runtime::egui::pass::current_viewport(ctx);
let enabled = Env::root_for(ctx, viewport).is_some_and(|env| env.tab_toggles_chrome);
let focused = focus::focused_rec(ctx);
let canvas = focus::canvas_keys(ctx, viewport).is_some();
let layer = overlay::key_layer(ctx, &focused.as_ref().map(|rec| focus::scope_chain(ctx, rec)).unwrap_or_default(), None);
let pressed = focused.as_ref().is_some_and(|rec| focus::origin(ctx, rec) == Some(focus::FocusOrigin::Press));
tab_toggles_chrome(enabled, canvas, layer, focused.as_ref().map(|rec| &rec.stop.keys), pressed)
}
/// Whether `chord` is the key of a chrome command (`ChromeCommand`), as the window's keymap binds it.
pub(super) fn is_chrome_chord(ctx: &Context, chord: &Chord) -> bool {
commands::window_shortcuts(ctx).iter().any(|(key, bound)| matches!(key, WindowShortcut::Chrome(_)) && bound == chord)
}
/// The toggle of the chrome command whose bound chord `input` presses, when that command is enabled.
@@ -522,11 +542,7 @@ pub(crate) fn take_nav(ctx: &Context) -> NavKeys {
return nav;
}
let viewport = crate::runtime::egui::pass::current_viewport(ctx);
let enabled = Env::root_for(ctx, viewport).is_some_and(|env| env.tab_toggles_chrome);
let focused = focus::focused_rec(ctx);
let canvas = focus::canvas_keys(ctx, viewport).is_some();
let layer = overlay::key_layer(ctx, &focused.as_ref().map(|rec| focus::scope_chain(ctx, rec)).unwrap_or_default(), None);
let gate = tab_toggles_chrome(enabled, canvas, layer, focused.as_ref().map(|rec| &rec.stop.keys));
let gate = tab_toggles_now(ctx);
for press in tabs {
match gate.then(|| chrome_toggle_of(ctx, &press.input)).flatten() {
Some(toggle) if !press.repeat => request_chrome_toggle(ctx, viewport, toggle),
+6 -3
View File
@@ -297,8 +297,9 @@ fn text_of(chord: Chord) -> Option<&'static str> {
/// Whether the focused component of the running viewport holds a press of `chord`, as routing decides for the press:
/// it or its menu claims the chord, its routing takes the press or the text the press types (a list's type-ahead), or a
/// menu or recorder has the keys. No app command bound to the chord runs while the component has the focus, and the press
/// reaches egui's input only for the app's own widget (`Stop::host`), which reads its keys there.
/// menu or recorder has the keys, or the chord is a bare Tab that moves focus from it rather than toggling the panels
/// (`tab_toggles_now`). No app command bound to the chord runs while the component has the focus, and the press reaches
/// egui's input only for the app's own widget (`Stop::host`), which reads its keys there.
pub fn focus_holds(ctx: &Context, chord: Chord) -> bool {
let Some(rec) = focus::focused_rec(ctx) else { return false };
let viewport = crate::runtime::egui::pass::current_viewport(ctx);
@@ -312,7 +313,9 @@ pub fn focus_holds(ctx: &Context, chord: Chord) -> bool {
let taken = !matches!(route, PressRoute::Free);
let typed = text_of(chord).is_some_and(|text| !text_route(&rec, driven, text).is_empty());
let owner = owner_at(ctx, Some(&rec), &focus::scope_chain(ctx, &rec), None);
holds_press(owner, Some(&rec), &press, taken, typed)
let bare_tab = chord.key == Key::Tab && !chord.mods.cmd && !chord.mods.ctrl && !chord.mods.alt;
let traverses = bare_tab && !(super::input::tab_toggles_now(ctx) && super::input::is_chrome_chord(ctx, &chord));
holds_press(owner, Some(&rec), &press, taken, typed) || traverses
}
/// Takes what the framework handed to one taker out of the running pass's egui input, where the app and egui's text
+37 -5
View File
@@ -4,13 +4,16 @@ use crate::runtime::commands::{ChromeCommand, CommandInput, CommandSet as _};
use crate::runtime::env::RootEnv;
use crate::runtime::focus::{FocusTarget, KeyUse, request};
use crate::runtime::frame::{ChromeToggle, take_output};
use crate::runtime::keys::{intents_of, take_shortcuts};
use crate::testing::focus::{Stop, egui_focused, named_id, register_stop, widget};
use crate::runtime::keys::{focus_holds, intents_of, take_shortcuts};
use crate::testing::focus::{Stop, egui_focused, named_id, press_shape, register_stop, widget};
use crate::testing::input::{key_press, key_repeat};
use crate::testing::pointer::click;
use crate::testing::{Frames, trial};
use craft_behavior::{Input, Intent};
use craft_keymap::Overrides;
use egui::{Id, Key, Modifiers, Ui, ViewportId};
use craft_behavior::{Input, Intent, Sense};
use craft_keymap::{Chord, Overrides};
use egui::{Id, Key, Modifiers, Rect, Ui, ViewportId};
use std::cell::Cell;
use std::rc::Rc;
use std::sync::Arc;
fn id(name: &str) -> Id {
@@ -84,6 +87,35 @@ fn tab_in_a_window_with_a_canvas_moves_focus_off_a_control() {
assert!(press(&mut frames, &mut show, Key::Tab, Modifiers::NONE).is_empty(), "a text field never loses Tab");
}
/// In a window with a canvas, a component a press focused leaves Tab to the panels' toggle, as clicking a panel's row and
/// pressing Tab hides the panels in Photoshop; one the keyboard or a request focused moves focus on Tab. `focus_holds`
/// names the Tab as the component's exactly when it moves focus.
#[trial]
fn tab_toggles_from_a_pressed_component_and_moves_focus_from_a_requested_one() {
let at = Rc::new(Cell::new(Rect::NOTHING));
let seen = Rc::clone(&at);
let mut show = move |ui: &mut Ui| {
let rect = widget(ui, id("button"));
register_stop(ui.ctx(), Stop::new(id("button"), KeyUse::of(Input::Pointer)));
press_shape(ui, rect, Sense::CLICK | Sense::TAKE_FOCUS, id("button"));
seen.set(rect);
stop(ui, "other", KeyUse::of(Input::Pointer));
stop(ui, "canvas", KeyUse::CANVAS);
};
let mut frames = shown(true, &mut show);
click(&mut frames, at.get().center(), &mut show);
take_output(&frames.ctx);
assert_eq!(egui_focused(&frames.ctx), Some(id("button")), "the press focused the button");
let tab = Chord::plain(craft_keymap::Key::Tab);
assert!(!focus_holds(&frames.ctx, tab), "a pressed component leaves Tab to the toggle");
assert_eq!(press(&mut frames, &mut show, Key::Tab, Modifiers::NONE), [(ViewportId::ROOT, ChromeToggle::Panels)], "a pressed component");
assert_eq!(egui_focused(&frames.ctx), Some(id("button")), "the toggle moved no focus");
focus_on(&mut frames, &mut show, "other");
assert!(focus_holds(&frames.ctx, tab), "a requested component's Tab moves focus");
assert!(press(&mut frames, &mut show, Key::Tab, Modifiers::NONE).is_empty(), "a requested component");
assert_ne!(egui_focused(&frames.ctx), Some(id("other")), "focus left the component");
}
#[trial]
fn tab_in_a_window_without_a_canvas_moves_focus() {
let mut show = without_canvas;