Canvas wheel: a line pans Photoshop's 16 points (Component::wheel_notch), Alt with the Control key zooms as Alt does; a focused field takes the field's share of the wheel wherever the pointer is; FrameOutput.delivered records the commands components took

This commit is contained in:
aiongg
2026-11-13 18:44:56 +00:00
parent 7399b2124d
commit e1ae7a64a4
14 changed files with 289 additions and 42 deletions
+1 -1
View File
@@ -111,7 +111,7 @@ pub use sizing::{ControlMetrics, Metrics, Proposal};
pub use typing::{EditRun, Ended, EscapeRule, Escaped, Typed, TypingRun};
pub use value::{Applied, CancelReason, EditEvent, EditEvents, EditPolicy, Gesture, GestureId, GesturePhase, Mixed, Validity, Value};
pub use value_drag::{DragWarp, ValueDrag, wrap_value};
pub use wheel::{Wheel, WheelNotch, WheelPhase, WheelRoom, WheelTaker, WheelUnit};
pub use wheel::{Wheel, WheelFocus, WheelNotch, WheelPhase, WheelRoom, WheelTaker, WheelUnit};
#[cfg(test)]
extern crate self as craft_behavior;
+87 -6
View File
@@ -98,6 +98,9 @@ pub struct WheelTaker<O> {
/// A zoom zone: a vertical wheel over it goes to the innermost enclosing open taker of the zoom share, with
/// `Wheel::zooms` set. A zone that takes no axis itself never takes a share.
pub zooms_view: bool,
/// A value field: while it holds key focus it takes the field's share of the wheel wherever the pointer is
/// (`split`).
pub field: bool,
}
/// The scroll left in a region, in points of wheel scroll: `positive` is what a wheel with positive `scroll` can
@@ -155,6 +158,7 @@ impl<O> WheelTaker<O> {
notch: WheelNotch::DEFAULT,
room: None,
zooms_view: false,
field: false,
}
}
@@ -178,6 +182,13 @@ impl<O> WheelTaker<O> {
self
}
/// Whether it is a value field (`WheelTaker::field`).
#[must_use]
pub const fn field(mut self, on: bool) -> Self {
self.field = on;
self
}
/// Whether it takes horizontal scroll.
pub const fn horizontal(mut self, on: bool) -> Self {
self.horizontal = on;
@@ -241,12 +252,63 @@ impl<O> WheelTaker<O> {
}
}
/// The split rule: each axis of `wheel` goes to the innermost taker under `at` that takes it; a share no taker
/// Who holds key focus, as the split reads it.
#[derive(Clone, Copy, Debug, PartialEq, Default)]
#[non_exhaustive]
pub struct WheelFocus<O> {
/// The taker that holds key focus.
pub taker: Option<O>,
/// Key focus is in a text field the app drew itself, which reads its own wheel: its share goes to no taker.
pub app_field: bool,
}
impl<O> WheelFocus<O> {
/// Focus on `taker`, or on nothing that takes the wheel.
pub const fn new(taker: Option<O>) -> Self {
WheelFocus { taker, app_field: false }
}
/// The same focus, in a text field the app drew itself when `on`.
#[must_use]
pub const fn app_field(mut self, on: bool) -> Self {
self.app_field = on;
self
}
}
/// Whether `wheel` is a field's: a vertical scroll, or Shift's (which some devices send sideways), without Alt or
/// Cmd/Ctrl, which stay the view's.
fn for_field(wheel: &Wheel) -> bool {
let mods = wheel.mods;
!(mods.alt || mods.cmd || mods.ctrl) && (wheel.scroll.y != 0.0 || (mods.shift && wheel.scroll.x != 0.0))
}
/// The split rule. A focused field (a `WheelTaker::field` taker that holds `focus`, or an app's own text field) takes
/// the field's share of the scroll wherever the pointer is: a vertical or Shift wheel without Alt or Cmd/Ctrl; an app's
/// field reads it itself, so no taker gets it. The rest splits by position: each axis of `wheel` goes to the innermost
/// taker under `at` that takes it; a share no taker
/// takes, or that a scroll region at its end in that direction cannot move, passes to the next enclosing one. A gated taker takes no axis unless it is `focused` or
/// `armed`. Shift turns a vertical wheel sideways when its vertical owner is a scroll region. When the innermost open
/// taker under `at` for the vertical share is a zoom zone, the share goes to the innermost open zoom taker enclosing it,
/// with `Wheel::zooms` set; without one the zone is passed over. Shares of one owner merge.
pub fn split<O: Copy + PartialEq>(takers: &[WheelTaker<O>], at: Pos2, wheel: Wheel, focused: Option<O>, armed: Option<O>) -> Vec<(O, Wheel)> {
pub fn split<O: Copy + PartialEq>(takers: &[WheelTaker<O>], at: Pos2, wheel: Wheel, focus: WheelFocus<O>, armed: Option<O>) -> Vec<(O, Wheel)> {
let field = focus.taker.filter(|focused| takers.iter().any(|taker| taker.field && taker.owner == *focused));
if (field.is_some() || focus.app_field) && wheel.scroll != Vec2::ZERO && for_field(&wheel) {
let mut shares = if wheel.zoom == 1.0 { Vec::new() } else { split_at(takers, at, Wheel { scroll: Vec2::ZERO, ..wheel }, focus.taker, armed) };
if let Some(owner) = field {
let scroll = Wheel { zoom: 1.0, ..wheel };
match shares.iter_mut().find(|(o, _)| *o == owner) {
Some((_, share)) => share.scroll += scroll.scroll,
None => shares.push((owner, scroll)),
}
}
return shares;
}
split_at(takers, at, wheel, focus.taker, armed)
}
/// The split by position.
fn split_at<O: Copy + PartialEq>(takers: &[WheelTaker<O>], at: Pos2, wheel: Wheel, focused: Option<O>, armed: Option<O>) -> Vec<(O, Wheel)> {
// Takers register outer first, so among equal areas the later one is the deeper (or the upper) and goes first.
let mut under: Vec<&WheelTaker<O>> = takers.iter().rev().filter(|taker| taker.rect.contains(at)).collect();
under.sort_by(|a, b| a.rect.area().total_cmp(&b.rect.area()));
@@ -308,23 +370,42 @@ mod tests {
let outer = WheelTaker::new(1u8, rect(200.0)).vertical(true).scrolls(true).room(WheelRoom::new(Vec2::splat(50.0), Vec2::splat(50.0)));
let inner = WheelTaker::new(2u8, rect(100.0)).vertical(true).scrolls(true).room(WheelRoom::new(Vec2::ZERO, Vec2::splat(30.0)));
let at = pos2(10.0, 10.0);
let owner = |y| split(&[outer, inner], at, wheel(0.0, y), None, None).first().map(|(o, _)| *o);
let owner = |y| split(&[outer, inner], at, wheel(0.0, y), WheelFocus::new(None), None).first().map(|(o, _)| *o);
assert_eq!(owner(7.0), Some(1), "no room toward positive: the outer takes it");
assert_eq!(owner(-7.0), Some(2), "room toward negative: the inner keeps it");
}
#[test]
fn a_focused_field_takes_the_plain_wheel_wherever_the_pointer_is() {
let canvas = WheelTaker::new(1u8, rect(300.0)).horizontal(true).vertical(true).zoom(true);
let field = WheelTaker::new(2u8, Rect::from_min_size(pos2(400.0, 0.0), Vec2::splat(20.0))).vertical(true).gated(true).field(true);
let at = pos2(10.0, 10.0);
let owners =
|wheel: Wheel, focus: WheelFocus<u8>| split(&[canvas, field], at, wheel, focus, None).iter().map(|(o, _)| *o).collect::<Vec<_>>();
let focused = WheelFocus::new(Some(2));
assert_eq!(owners(wheel(0.0, 5.0), WheelFocus::new(None)), [1], "no focus: the canvas under the pointer");
assert_eq!(owners(wheel(0.0, 5.0), focused), [2], "the focused field, away from the pointer");
let alt = Wheel { mods: Mods::ALT, ..wheel(0.0, 5.0) };
let cmd = Wheel { mods: Mods::CMD, ..wheel(0.0, 5.0) };
assert_eq!(owners(alt, focused), [1], "Alt stays the view's");
assert_eq!(owners(cmd, focused), [1], "Cmd/Ctrl stays the view's");
assert_eq!(owners(wheel(5.0, 0.0), focused), [1], "a sideways swipe stays the view's");
assert_eq!(owners(wheel(0.0, 5.0), WheelFocus::new(None).app_field(true)), [] as [u8; 0], "an app's field reads its own");
assert_eq!(owners(alt, WheelFocus::new(None).app_field(true)), [1]);
}
#[test]
fn a_vertical_wheel_over_a_zoom_zone_zooms_the_enclosing_view() {
let region = WheelTaker::new(1u8, rect(300.0)).vertical(true).scrolls(true);
let view = WheelTaker::new(2u8, rect(200.0)).horizontal(true).zoom(true);
let zone = WheelTaker::new(3u8, rect(100.0)).zooms_view(true);
let at = pos2(10.0, 10.0);
let shares = split(&[region, view, zone], at, wheel(0.0, 5.0), None, None);
let shares = split(&[region, view, zone], at, wheel(0.0, 5.0), WheelFocus::new(None), None);
assert_eq!(shares.len(), 1);
assert_eq!((shares[0].0, shares[0].1.scroll.y, shares[0].1.zooms), (2, 5.0, true), "the view zooms by the vertical share");
let shares = split(&[region, zone], at, wheel(0.0, 5.0), None, None);
let shares = split(&[region, zone], at, wheel(0.0, 5.0), WheelFocus::new(None), None);
assert_eq!(shares.iter().map(|(o, w)| (*o, w.zooms)).collect::<Vec<_>>(), [(1, false)], "no zoom taker: the zone is passed over");
let shares = split(&[region, view, zone], at, wheel(4.0, 0.0), None, None);
let shares = split(&[region, view, zone], at, wheel(4.0, 0.0), WheelFocus::new(None), None);
assert_eq!(shares.iter().map(|(o, w)| (*o, w.zooms)).collect::<Vec<_>>(), [(2, false)], "the horizontal share passes the zone");
}
}
+6 -1
View File
@@ -110,6 +110,7 @@ use crate::style::{ComponentStyle, StyleCx, SurfaceKind};
use craft_behavior::kurbo::{Point, Rect as DocRect, Size};
use craft_behavior::{
CanvasTransform, CanvasView, EditEvent, HitLevel, HitPriority, Intent, Metrics, Mixed, PartKey, PointerButton, PressPhase, PressState, Sense,
WheelNotch,
};
use egui::{Pos2, Rect, Response, Vec2};
use zoom_motion::{Steer, ViewMotion};
@@ -336,7 +337,7 @@ impl<'a> Canvas<'a> {
}
let mut jumped = false;
if let Some(wheel) = cx.take_wheel()
&& let Some(action) = motion.wheel.read(&wheel, &self.navigation)
&& let Some(action) = motion.wheel.read(&wheel, WheelNavigation::LINE, cx.env.shell().os, &self.navigation)
{
let at = cx.response.hover_pos().unwrap_or_else(|| view.rect.center());
jumped |= WheelNavigation::apply(&mut view, action, at, size, pixels_per_point);
@@ -510,6 +511,10 @@ impl Component for Canvas<'_> {
Sense::FOCUS | Sense::TAKE_FOCUS | Sense::WHEEL
}
fn wheel_notch(&self) -> WheelNotch {
WheelNotch::Points(WheelNavigation::LINE)
}
/// The view of this pass, kept for the body and `finish`.
fn update(&mut self, cx: &mut Cx<'_, Self>) {
// Left untaken: the canvas's generic context request is recorded as for a secondary click.
+28 -15
View File
@@ -8,8 +8,8 @@
use super::NavigationOptions;
use craft_behavior::canvas::zoom;
use craft_behavior::kurbo::Size;
use craft_behavior::{CanvasView, Wheel, WheelNotch, ZoomLadder};
use craft_keymap::Mods;
use craft_behavior::{CanvasView, Wheel, WheelNotch, WheelUnit, ZoomLadder};
use craft_keymap::{Mods, Platform};
use egui::{Pos2, Vec2};
/// What the wheel or a pinch does to the view this pass.
@@ -34,18 +34,19 @@ pub struct WheelInput {
pub zoom: f32,
/// The modifiers held.
pub mods: Mods,
/// Points per wheel notch.
/// Points per zoom notch.
pub notch: f32,
/// The OS, which decides where the Control key is among the modifiers.
pub os: Platform,
}
impl WheelInput {
/// The input of `wheel`, whose notch is the service's default distance.
pub fn of(wheel: &Wheel) -> Self {
let notch = match WheelNotch::DEFAULT {
WheelNotch::Points(points) => points,
_ => 1.0,
};
WheelInput { scroll: wheel.scroll, zoom: wheel.zoom, mods: wheel.mods, notch }
/// The input of `wheel` for a taker whose wheel line is `line` points, on `os`. A line is one zoom notch; a
/// device that scrolls in points zooms a notch every default line ([`WheelNotch::DEFAULT`]), whatever the taker's
/// line.
pub fn of(wheel: &Wheel, line: f32, os: Platform) -> Self {
let notch = if wheel.unit == WheelUnit::Line { line } else { WheelNotch::DEFAULT.points(0.0) };
WheelInput { scroll: wheel.scroll, zoom: wheel.zoom, mods: wheel.mods, notch, os }
}
/// The scroll along the wheel's axis whichever one the device reported it on (some systems send a modified wheel
@@ -58,7 +59,9 @@ impl WheelInput {
/// Mouse wheel and trackpad navigation, as in Photoshop:
///
/// - The wheel scrolls up and down; Shift or Cmd/Ctrl + wheel scrolls sideways.
/// - Alt + wheel zooms about the pointer, 1.1 a notch; Shift + Alt + wheel steps the ladder.
/// - Alt + wheel zooms about the pointer, 1.1 a notch; Shift + Alt + wheel steps the ladder. Alt with the Control
/// key is the same zoom: on macOS Control may join it, elsewhere Ctrl (cmd) without Shift (production's #10488).
/// - A wheel line pans the canvas [`WheelNavigation::LINE`] points.
/// - Zoom with Scroll Wheel swaps them: the wheel zooms, Alt + wheel scrolls, Shift + wheel steps the ladder.
/// - A trackpad pinch zooms about the pointer (Zoom with Trackpad Pinch).
///
@@ -72,12 +75,22 @@ impl WheelNavigation {
/// The zoom factor of one wheel notch.
pub const NOTCH: f64 = 1.1;
/// The points one wheel line pans the canvas: Photoshop's 16 (production's #12028).
pub const LINE: f32 = 16.0;
/// The most ladder steps one pass takes.
const MOST_STEPS: f32 = 10.0;
/// The view change for `wheel` under `options`, if any.
pub fn read(&mut self, wheel: &Wheel, options: &NavigationOptions) -> Option<WheelAction> {
self.classify(WheelInput::of(wheel), options)
/// The view change for `wheel`, given to a taker whose wheel line is `line` points, on `os`, under `options`, if
/// any.
pub fn read(&mut self, wheel: &Wheel, line: f32, os: Platform, options: &NavigationOptions) -> Option<WheelAction> {
self.classify(WheelInput::of(wheel, line, os), options)
}
/// Whether `mods` make the Alt zoom gesture on `os`: Alt, with the Control key allowed, which is `ctrl` on macOS
/// (⌘ keeps the wheel out of it) and `cmd` elsewhere, where Shift with it keeps the wheel a scroll.
fn alt_gesture(mods: Mods, os: Platform) -> bool {
mods.alt && (!mods.cmd || (!os.is_mac() && !mods.shift))
}
/// The view change for one pass of `input` under `options`, if any.
@@ -90,7 +103,7 @@ impl WheelNavigation {
}
let scroll_finite = input.scroll.x.is_finite() && input.scroll.y.is_finite();
let plain = !input.mods.cmd && !input.mods.ctrl;
let zooms = plain && input.mods.alt != options.zoom_with_wheel;
let zooms = if options.zoom_with_wheel { plain && !input.mods.alt } else { Self::alt_gesture(input.mods, input.os) };
if zooms && input.mods.shift {
return scroll_finite.then(|| self.snap(input.along(), notch)).flatten().map(WheelAction::SnapZoom);
}
@@ -406,7 +406,8 @@ impl Component for Navigator<'_> {
&& !running
{
let options = NavigationOptions { zoom_with_wheel: true, ..self.navigation };
let action = cx.memory::<WheelNavigation>().read(&wheel, &options);
let (line, os) = (craft_behavior::WheelNotch::DEFAULT.points(0.0), cx.env.shell().os);
let action = cx.memory::<WheelNavigation>().read(&wheel, line, os, &options);
if let Some(action @ (WheelAction::Zoom(_) | WheelAction::SnapZoom(_))) = action {
let before = next;
WheelNavigation::apply(&mut next, action, before.rect.center(), document, ppp);
+116 -3
View File
@@ -3,12 +3,16 @@
use craft_behavior::kurbo::{Point, Size};
use craft_behavior::{Axis, CanvasView, Wheel, WheelPhase, WheelUnit};
use craft_keymap::{Mods, Platform};
use craft_ui::canvas::{Canvas, Guide, GuideKey, Momentary, MomentaryCommands, MomentaryTool, NavigationOptions, TouchpadGlide};
use craft_ui::canvas::{
Canvas, Guide, GuideKey, Momentary, MomentaryCommands, MomentaryTool, NavigationOptions, TouchpadGlide, ViewCommands, WheelNavigation,
};
use craft_ui::canvas_controls::Guides;
use craft_ui::contract::{Bind, Show as _, ShowContainer as _};
use craft_ui::runtime::access::Role;
use craft_ui::runtime::commands::FirePhase;
use craft_ui::testing::{Fixture, trial};
use craft_ui::runtime::commands::{self, CommandRef, FirePhase, FireSource};
use craft_ui::runtime::frame;
use craft_ui::testing::{Fixture, pointer, trial};
use craft_ui::text::NumberField;
use egui::{Key, Modifiers, Vec2};
use std::cell::Cell;
use std::rc::Rc;
@@ -162,3 +166,112 @@ fn at_a_whole_device_zoom_with_no_rotation_the_shown_view_puts_document_pixels_o
let p = set.view.to_screen(Point::new(17.0, 29.0)) * set.pixels_per_point;
assert!((p.x - p.x.round()).abs() < 1e-3 && (p.y - p.y.round()).abs() < 1e-3, "a view set at a whole zoom is shown aligned: {p:?}");
}
/// A canvas over a large document at zoom 1 below a framework number field and an app's own text field, on `os`: the
/// fixture, the view it shows, the number and where the app's field is.
fn wheel_rig(os: Platform) -> (Fixture, Rc<Cell<CanvasView>>, Rc<Cell<Option<f64>>>, Rc<Cell<egui::Rect>>) {
let view = Rc::new(Cell::new(CanvasView::new(egui::Rect::ZERO, Point::new(2000.0, 2000.0), 1.0)));
let number = Rc::new(Cell::new(Some(10.0)));
let app_field = Rc::new(Cell::new(egui::Rect::NOTHING));
let (shown, value, field_at) = (Rc::clone(&view), Rc::clone(&number), Rc::clone(&app_field));
let mut text = String::from("Layer 1");
let mut fixture = Fixture::new(move |ui| {
let mut current = value.get();
NumberField::new("Smoothing", Bind::bound(&mut current)).show(ui);
value.set(current);
field_at.set(ui.add(egui::TextEdit::singleline(&mut text)).rect);
let mut given = shown.get();
given.rect = ui.available_rect_before_wrap();
let canvas = Canvas::new("Document").document(Size::new(4000.0, 4000.0)).view(given).show(ui, |_, _| {});
shown.set(canvas.output.view.unwrap_or(given));
});
fixture.os(os);
// As an app that gives ⌘/Ctrl + wheel to the canvas sets egui: no wheel modifier is egui's own zoom.
fixture.ctx().options_mut(|options| options.input_options.zoom_modifier = Modifiers::NONE);
fixture.settle();
(fixture, view, number, app_field)
}
/// One wheel line of `dy` with `modifiers` over the middle of the canvas.
fn wheel_line(fixture: &mut Fixture, view: &Cell<CanvasView>, dy: f32, modifiers: Modifiers) {
let at = view.get().rect.center();
fixture.frame(vec![pointer::moved(at)]);
fixture.frame(vec![egui::Event::MouseWheel {
unit: egui::MouseWheelUnit::Line,
delta: Vec2::new(0.0, dy),
phase: egui::TouchPhase::Move,
modifiers,
source: egui::MouseWheelSource::Wheel,
}]);
}
#[trial]
fn a_wheel_line_pans_the_canvas_photoshops_line_and_ctrl_alt_zooms_as_alt_does() {
for os in [Platform::Mac, Platform::Windows, Platform::Linux] {
let (mut fixture, view, _, _) = wheel_rig(os);
let before = view.get();
wheel_line(&mut fixture, &view, -1.0, Modifiers::NONE);
let panned = view.get();
assert!((panned.center.y - before.center.y - f64::from(WheelNavigation::LINE)).abs() < 1e-3, "{os:?}: {before:?} -> {panned:?}");
wheel_line(&mut fixture, &view, 1.0, Modifiers::ALT);
let alt = view.get().zoom / panned.zoom;
assert!((alt - WheelNavigation::NOTCH).abs() < 1e-3, "{os:?}: Alt + a line zooms a notch: {alt}");
// egui reports Ctrl as `ctrl` with `command` off macOS, and the Control key as `ctrl` alone on macOS.
let ctrl_alt = if os.is_mac() {
Modifiers { alt: true, ctrl: true, ..Modifiers::NONE }
} else {
Modifiers { alt: true, ctrl: true, command: true, ..Modifiers::NONE }
};
let at = view.get();
wheel_line(&mut fixture, &view, 1.0, ctrl_alt);
assert!((view.get().zoom / at.zoom - WheelNavigation::NOTCH).abs() < 1e-3, "{os:?}: Ctrl + Alt zooms as Alt does");
if os.is_mac() {
let at = view.get();
wheel_line(&mut fixture, &view, 1.0, Modifiers { alt: true, mac_cmd: true, command: true, ..Modifiers::NONE });
assert_eq!(view.get().zoom, at.zoom, "⌘ + ⌥ is no zoom");
}
}
}
#[trial]
fn a_focused_field_takes_the_plain_wheel_over_the_canvas_and_leaves_it_the_view_keys() {
let (mut fixture, view, number, _) = wheel_rig(Platform::Linux);
let field = fixture.by_label("Smoothing").expect("the number field");
fixture.click(&field);
let before = view.get();
wheel_line(&mut fixture, &view, 1.0, Modifiers::NONE);
assert_eq!(view.get(), before, "the canvas neither pans nor zooms");
assert_eq!(number.get(), Some(11.0), "the field stepped");
wheel_line(&mut fixture, &view, 1.0, Modifiers::ALT);
assert!(view.get().zoom > before.zoom, "Alt + wheel is still the view's zoom");
let zoomed = view.get();
wheel_line(&mut fixture, &view, 1.0, Modifiers::COMMAND);
assert!(view.get().center.x != zoomed.center.x, "Cmd/Ctrl + wheel still scrolls the view sideways");
assert_eq!(number.get(), Some(11.0), "the view's wheel does not step the field");
let (mut fixture, view, _, app_field) = wheel_rig(Platform::Linux);
fixture.click_at(app_field.get().center());
let before = view.get();
wheel_line(&mut fixture, &view, 1.0, Modifiers::NONE);
assert_eq!(view.get(), before, "an app's own focused text field keeps the plain wheel from the canvas");
wheel_line(&mut fixture, &view, 1.0, Modifiers::ALT);
assert!(view.get().zoom > before.zoom, "Alt + wheel is still the view's zoom");
}
#[trial]
fn the_view_commands_a_canvas_runs_are_in_the_frame_output_whatever_fired_them() {
let (mut fixture, view, _, _) = wheel_rig(Platform::Linux);
let canvas = fixture.by_role(Role::CANVAS)[0];
fixture.click(&canvas);
frame::take_output(fixture.ctx());
let before = view.get();
fixture.key(Key::Num0, Modifiers::COMMAND);
assert!(commands::fire(fixture.ctx(), ViewCommands::ZoomIn, FireSource::Menu), "a menu row fires the canvas's command");
fixture.frame(vec![]);
assert_ne!(view.get(), before, "the canvas ran them");
let delivered: Vec<_> = frame::take_output(fixture.ctx()).delivered.into_iter().map(|fired| (fired.command, fired.source)).collect();
assert_eq!(
delivered,
[(CommandRef::from(ViewCommands::FitOnScreen), FireSource::Key), (CommandRef::from(ViewCommands::ZoomIn), FireSource::Menu)]
);
}
+6
View File
@@ -408,6 +408,12 @@ pub trait Component: Meta + Sized {
if Self::CANVAS_CONTROL { Sense::empty() } else { <Self::Shape as ShowShape>::DEFAULT_SENSE }
}
/// The distance one wheel line scrolls the component when it senses the wheel itself: the service converts the
/// device's lines to points with it. A scroll region and a collection state theirs in their props.
fn wheel_notch(&self) -> craft_behavior::WheelNotch {
craft_behavior::WheelNotch::DEFAULT
}
/// Named sub-rects: thumbs, chevrons, handles, segments and the roving groups over them.
fn parts(&mut self, _rect: Rect, _cx: &mut PartsCx<'_, Self>) {}
+4 -1
View File
@@ -523,6 +523,8 @@ pub(crate) trait ErasedPass<'a> {
fn sense(&self) -> Sense;
/// The component's own sense.
fn comp_sense(&self) -> Sense;
/// `Component::wheel_notch`.
fn wheel_notch(&self) -> craft_behavior::WheelNotch;
/// Whether the component is bound, and whether its binding has a reset value.
fn bound(&mut self) -> (bool, bool);
fn paint_outset(&self, tokens: &crate::style::UiTokens) -> f32;
@@ -901,7 +903,8 @@ fn run_in_host(p: &mut Pass<'_, '_, '_>, ui: &mut Ui, host_at: Option<ShowAt>, h
ShapeKind::Item => !own.intersects(Sense::WHEELS),
};
if !inert && registers {
steps::register_wheel(&ctx, id, rect, own, e.bound().0 && !facts.binds_view, env.wheel);
let sensed = craft_behavior::WheelTaker::for_sense(id, rect, own).map(|taker| taker.notch(e.wheel_notch()));
steps::register_wheel(&ctx, id, rect, sensed, e.bound().0 && !facts.binds_view, facts.text(), env.wheel);
}
// 8 sense
p.trace.mark(Step::Sense);
@@ -244,6 +244,10 @@ impl<'a, C: Component> ErasedPass<'a> for TypedPass<'_, 'a, C> {
self.comp.sense()
}
fn wheel_notch(&self) -> craft_behavior::WheelNotch {
self.comp.wheel_notch()
}
fn bound(&mut self) -> (bool, bool) {
self.comp.bind().map_or((false, false), |bind| (true, bind.reset_value().is_some()))
}
+12 -5
View File
@@ -3,22 +3,29 @@
use crate::runtime::env::WheelScope;
use crate::runtime::wheel;
use crate::style::{Flags, StateSet};
use craft_behavior::Sense;
use craft_theme::{State, StateMix};
use egui::{Context, Id, Rect};
/// Registers a wheel taker for next pass's split (8.6) from the wheel bits of `sense` (`WheelTaker::for_sense`). A
/// Registers a wheel taker for next pass's split (8.6): `sensed`, the taker the wheel bits of the component's sense
/// make (`WheelTaker::for_sense`). A value control with a text part is a field (`WheelTaker::field`). A
/// value control takes the wheel only while focused or armed, on the axes it senses (the vertical one when it senses
/// none); inside a `WheelScope::Free` scope one that senses the wheel takes it without focus. Inside a
/// `WheelScope::Gated` scope every taker waits for focus or arming. A zoom zone that takes no axis itself waits only
/// for a gated scope: its wheel goes to the view around it.
pub(crate) fn register_wheel(ctx: &Context, id: Id, rect: Rect, sense: Sense, value_control: bool, scope: WheelScope) {
let sensed = craft_behavior::WheelTaker::for_sense(id, rect, sense);
pub(crate) fn register_wheel(
ctx: &Context,
id: Id,
rect: Rect,
sensed: Option<craft_behavior::WheelTaker<Id>>,
value_control: bool,
text: bool,
scope: WheelScope,
) {
let free = sensed.is_some() && scope == WheelScope::Free;
let zone = sensed.is_some_and(|taker| taker.zooms_view && !(taker.horizontal || taker.vertical || taker.zoom));
let taker = sensed.or_else(|| value_control.then(|| craft_behavior::WheelTaker::new(id, rect).vertical(true)));
if let Some(taker) = taker {
wheel::register(ctx, taker.gated(scope == WheelScope::Gated || (value_control && !free && !zone)));
wheel::register(ctx, taker.field(value_control && text).gated(scope == WheelScope::Gated || (value_control && !free && !zone)));
}
}
@@ -74,6 +74,8 @@ pub(crate) struct Board {
queue: Vec<Fired>,
/// App-scope commands for the next `FrameOutput`.
out: Vec<Fired>,
/// The commands instances took since the last `FrameOutput`, in order.
delivered: Vec<Fired>,
instances: Vec<Instance>,
/// The focused component of each viewport's last step 12 and the instances around it.
chains: HashMap<ViewportId, (Id, CommandChain)>,
@@ -502,6 +504,11 @@ pub(crate) fn take_fired(ctx: &Context) -> Vec<Fired> {
with(ctx, |board| std::mem::take(&mut board.out))
}
/// The commands instances took since the last call.
pub(crate) fn take_delivered(ctx: &Context) -> Vec<Fired> {
with(ctx, |board| std::mem::take(&mut board.delivered))
}
/// Whether the component that holds key focus sits inside the instance `id`.
#[doc(hidden)]
pub fn focus_within(ctx: &Context, id: Id) -> bool {
@@ -776,13 +783,14 @@ pub(crate) fn take<S>(ctx: &Context, instance: Option<Id>, app: bool, from_ref:
return None;
}
with(ctx, |board| {
if app {
let fired = if app {
let at = board.out.iter().position(|fired| from_ref(&fired.command).is_some())?;
let fired = board.out.remove(at);
return Some((from_ref(&fired.command)?, fired));
}
let at = board.queue.iter().position(|fired| fired.target == Some(instance) && from_ref(&fired.command).is_some())?;
let fired = board.queue.remove(at);
board.out.remove(at)
} else {
let at = board.queue.iter().position(|fired| fired.target == Some(instance) && from_ref(&fired.command).is_some())?;
board.queue.remove(at)
};
board.delivered.push(fired.clone());
Some((from_ref(&fired.command)?, fired))
})
}
@@ -24,7 +24,7 @@ pub(crate) use board::take as take_for_instance;
#[doc(hidden)]
pub use board::take_around;
pub(crate) use board::{
begin, binds_scoped, edit_chords, end, install, note_focus, platform, register_instance, set_input, take_fired, window_shortcuts,
begin, binds_scoped, edit_chords, end, install, note_focus, platform, register_instance, set_input, take_delivered, take_fired, window_shortcuts,
};
pub(crate) use board::{fire_bound, fire_resolved, resolve_bound, resolve_scoped};
+4
View File
@@ -92,6 +92,9 @@ pub enum OuterEdit {
pub struct FrameOutput {
/// The app-scope commands fired since the last call, in order.
pub fired: Vec<Fired>,
/// The commands components took since the last call, in order, whatever fired them (a key, a menu row, the
/// palette): what ran inside the framework, for an app that records the commands it runs (an action recorder).
pub delivered: Vec<Fired>,
/// Text for the live announcement region.
pub announcements: Vec<String>,
/// The chrome toggles the windows asked for since the last call, in order: each names its viewport and whether the
@@ -335,6 +338,7 @@ pub(crate) fn in_pass(ctx: &Context) -> bool {
pub fn take_output(ctx: &Context) -> FrameOutput {
let mut output = pass_state::with::<FrameState, _>(ctx, |state| std::mem::take(&mut state.output));
output.fired = commands::take_fired(ctx);
output.delivered = commands::take_delivered(ctx);
// The menu, palette and automation fires of the chrome and nav commands reach the app as ordinary fires with no
// window: the focused window's shell takes a toggle, and its focus service a pane move, in the next pass. A key fire
// already acted in the key stage.
+4 -2
View File
@@ -8,7 +8,7 @@ use crate::runtime::frame::PerViewport;
use crate::runtime::pointer;
use crate::runtime::sampler;
use craft_behavior::wheel::split;
use craft_behavior::{PointerButton, PointerEvent, Wheel, WheelPhase, WheelTaker, WheelUnit};
use craft_behavior::{PointerButton, PointerEvent, Wheel, WheelFocus, WheelPhase, WheelTaker, WheelUnit};
use egui::{Context, Id, Pos2, Rect, Vec2};
#[derive(Default)]
@@ -50,6 +50,8 @@ pub(crate) fn begin(ctx: &Context) {
let frame = pass_pointer.frame.clone();
let wheel_in = input::wheel_read(ctx, 1.0, 1.0);
let focused = focus::focused_stop(ctx).map(|(owner, _)| owner);
// A text field the app drew itself holds key focus: it reads its own wheel.
let app_field = wheel_in.is_some() && focus::record(ctx, viewport).host_focus && ctx.text_edit_focused();
let hover = pass_pointer.hover.or(frame.as_ref().and_then(|frame| frame.pos));
let pressed_on = pass_pointer
.events
@@ -89,7 +91,7 @@ pub(crate) fn begin(ctx: &Context) {
}
let share = Wheel::new(scroll, mods, unit, phase).zoom(frame.zoom).at(at);
// The device's lines and pages become points of each taker: the notch is the scroll owner's to choose.
let shares = split(&state.last, at, share, focused, state.armed);
let shares = split(&state.last, at, share, WheelFocus::new(focused).app_field(app_field), state.armed);
state.shares = shares
.into_iter()
.map(|(owner, mut share)| {