Merge branch 'red/t3' into fw/mac1

This commit is contained in:
aiongg
2026-11-16 21:35:40 +00:00
11 changed files with 250 additions and 37 deletions
+2
View File
@@ -155,6 +155,8 @@ pub enum PressCancel {
Disabled,
/// The owner was not drawn for a pass.
Removed,
/// The host ended what the press acted on (`primitives::cancel_press_of`).
Host,
}
/// One part's press state in one pass.
+67 -34
View File
@@ -14,8 +14,8 @@ mod words;
use craft_behavior::geometry::{SelectionOperation, axis_or_diagonal};
use craft_behavior::kurbo::{Point, Rect as DocRect, Vec2};
use craft_behavior::{
Axis, CanvasView, CursorPriority, EditCommand, Granularity, HitLevel, HitPriority, HitShape, Intent, MoveMods, NavMove, NavShape, PartKey,
PartRef, PointerButton, PressPhase, PressStart, Roving, Sense,
Axis, CanvasView, CursorPriority, EditCommand, GesturePhase, Granularity, HitLevel, HitPriority, HitShape, Intent, MoveMods, NavMove, NavShape,
PartKey, PartRef, PointerButton, PressPhase, PressStart, Roving, Sense,
};
use craft_keymap::{Chord, Key, Mods};
use craft_theme::Srgba;
@@ -257,6 +257,9 @@ struct Held {
start: Vec<EditPath>,
/// Past the click slop: the gesture began.
began: bool,
/// The tool the press began under: the overlay's parts and handling stay that tool's until the press ends,
/// whatever the host's tool becomes.
tool: BezierTool,
}
/// Where a press is in a pass: the view and snap it maps through, the press, the pointer and the modifiers held.
@@ -424,6 +427,13 @@ impl<'a> BezierOverlay<'a> {
/// The parts a pass declares for `paths`: the anchors and shown handles inside `rect` grown by `reach`, and the
/// segments that tool takes and that cross it.
/// An open press keeps the tool it began under: the parts and the handling of every pass of the press follow it.
fn press_tool(&mut self, held: Option<&Held>) {
if let Some(held) = held {
self.tool = held.tool;
}
}
fn scene(&self, paths: &[EditPath], view: &CanvasView, rect: Rect, reach: f32) -> Scene {
let limited = self.anchors == AnchorsShown::Hidden || paths.iter().map(EditPath::anchor_count).sum::<usize>() > MAX_ANCHORS;
let mut items = Vec::new();
@@ -704,6 +714,24 @@ impl<'a> BezierOverlay<'a> {
}
}
/// The selection with no anchor or segment selected: the path stays the one being edited.
fn deselected(&self) -> PathSelection {
match self.selection.path {
Some(path) => self.selecting(path, Vec::new(), None),
None => PathSelection::default(),
}
}
/// A one-shot `edit` of `paths` that is reported even when it changes nothing: a Convert Point click on an anchor
/// that already is a corner is still the click's edit, and the host decides what it makes of it (a live shape
/// becomes a path, the click is a History step).
fn set_always(&mut self, cx: &mut Cx<'_, Self>, paths: &[EditPath], edit: PathEdit) {
let mut next = paths.to_vec();
edit.apply_all(&mut next);
cx.set(next);
self.report.change = Some(edit);
}
/// The selection a marquee over `rect` makes with `mods`: the anchors inside it on the frontmost path that has
/// any, combined with the selection as ⇧, ⌥ and ⇧⌥ say (Photoshop's add, subtract and intersect).
fn marquee_selection(&self, paths: &[EditPath], rect: DocRect, mods: Mods) -> Option<PathSelection> {
@@ -713,7 +741,7 @@ impl<'a> BezierOverlay<'a> {
});
let operation = SelectionOperation::from_mods(mods);
let Some((path, knots)) = inside else {
return (operation == SelectionOperation::New).then(PathSelection::default);
return (operation == SelectionOperation::New).then(|| self.deselected());
};
let current: Vec<KnotRef> = if self.selection.path == Some(path) { self.selection.anchors.clone() } else { Vec::new() };
let anchors = match operation {
@@ -730,12 +758,14 @@ impl<'a> BezierOverlay<'a> {
let snap = canvas_snap(&cx.env);
let view = &space.view;
let mut hovered: Option<(u8, BezierHit, Mods)> = None;
let mut pressed = false;
for item in &scene.items {
if !self.takes(item) {
continue;
}
let Some(result) = cx.part_if_declared(item.part()) else { continue };
let (press, hover) = (result.press, result.hover_pos);
pressed |= press.phase.is_press();
if let Some(at) = hover {
let rank = match item.kind {
Kind::Handle(_) => 2,
@@ -758,7 +788,7 @@ impl<'a> BezierOverlay<'a> {
tools::anchor_click(self.tool, hit, press.mods, self.selection, &mut self.report);
*cx.press_slot::<Held>() = None;
} else {
*cx.press_slot::<Held>() = Some(Held { origin: start.origin, target, start: paths.to_vec(), began: false });
*cx.press_slot::<Held>() = Some(Held { origin: start.origin, target, start: paths.to_vec(), began: false, tool: self.tool });
}
}
PressPhase::DragStart { start, pos, .. } | PressPhase::Drag { start, pos, .. } if start.button == PointerButton::Primary => {
@@ -766,8 +796,9 @@ impl<'a> BezierOverlay<'a> {
self.drag(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, Some(item), paths, first);
}
PressPhase::Release { start, pos, click, .. } if start.button == PointerButton::Primary => {
self.release(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, Some(item), click, paths);
self.release(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, click, paths);
}
PressPhase::Cancel { .. } => *cx.press_slot::<Held>() = None,
_ => {}
}
}
@@ -775,21 +806,27 @@ impl<'a> BezierOverlay<'a> {
&& let Some(result) = cx.part_if_declared(MARQUEE)
{
let press = result.press;
pressed |= press.phase.is_press();
match press.phase {
PressPhase::Down { start, .. } if start.button == PointerButton::Primary => {
self.report.pressed_empty = true;
*cx.press_slot::<Held>() = Some(Held { origin: start.origin, target: Target::Marquee, start: Vec::new(), began: false });
*cx.press_slot::<Held>() = Some(Held { origin: start.origin, target: Target::Marquee, start: Vec::new(), began: false, tool: self.tool });
}
PressPhase::DragStart { start, pos, .. } | PressPhase::Drag { start, pos, .. } if start.button == PointerButton::Primary => {
let first = matches!(press.phase, PressPhase::DragStart { .. });
self.drag(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, None, paths, first);
}
PressPhase::Release { start, pos, click, .. } if start.button == PointerButton::Primary => {
self.release(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, None, click, paths);
self.release(cx, Pointing { view, snap: snap.as_ref(), start, pos, mods: press.mods }, click, paths);
}
PressPhase::Cancel { .. } => *cx.press_slot::<Held>() = None,
_ => {}
}
}
// A press none of the parts carries any more (its part went with the paths) is over for the overlay.
if !pressed && cx.press_slot::<Held>().is_some() {
*cx.press_slot::<Held>() = None;
}
if let Some((_, hit, mods)) = hovered {
self.report.hover = Some(hit);
self.hover_mark = tools::hover_mark(self.tool, hit, mods, self.selection);
@@ -807,9 +844,9 @@ impl<'a> BezierOverlay<'a> {
(Some(held), _) => held,
(None, Some(item)) => {
let target = self.press_target(item.hit(paths, view, start.origin), start, mods, paths);
Held { origin: start.origin, target, start: paths.to_vec(), began: false }
Held { origin: start.origin, target, start: paths.to_vec(), began: false, tool: self.tool }
}
(None, None) => Held { origin: start.origin, target: Target::Marquee, start: Vec::new(), began: false },
(None, None) => Held { origin: start.origin, target: Target::Marquee, start: Vec::new(), began: false, tool: self.tool },
};
let moves = !matches!(held.target, Target::Nothing | Target::Toggle { .. } | Target::Pick { .. });
if first && moves {
@@ -817,13 +854,16 @@ impl<'a> BezierOverlay<'a> {
if let Target::CurvatureInsert { path, segment, .. } | Target::Insert { path, segment, .. } = held.target {
self.report.select = Some(self.inserted(path, segment));
}
if held.target != Target::Marquee {
cx.begin();
}
cx.begin();
}
if held.began {
match held.target {
Target::Marquee => self.marquee = Some(DocRect::from_points(view.to_doc(start.origin), view.to_doc(pos))),
// A marquee is a gesture like the other drags: Escape cancels it and the cancelled one selects nothing.
Target::Marquee => {
if matches!(cx.gesture(), Some(GesturePhase::Begin | GesturePhase::Update)) {
self.marquee = Some(DocRect::from_points(view.to_doc(start.origin), view.to_doc(pos)));
}
}
_ => {
if let Some(edit) = Self::edit(view, snap, self.tool, &held.target, start.origin, pos, mods) {
self.propose(cx, &held.start, edit);
@@ -835,29 +875,20 @@ impl<'a> BezierOverlay<'a> {
}
/// The release of a press at `pos`: a drag commits, a click does what its tool's click does.
fn release(&mut self, cx: &mut Cx<'_, Self>, at: Pointing<'_>, item: Option<&Item>, click: bool, paths: &[EditPath]) {
fn release(&mut self, cx: &mut Cx<'_, Self>, at: Pointing<'_>, click: bool, paths: &[EditPath]) {
let Pointing { view, snap, start, pos, mods } = at;
let Some(held) = cx.press_slot::<Held>().take().filter(|held| held.origin == start.origin) else {
// A press and its drag in one pass: one edit from the press.
if !click && let Some(item) = item {
let target = self.press_target(item.hit(paths, view, start.origin), start, mods, paths);
if let Some(edit) = Self::edit(view, snap, self.tool, &target, start.origin, pos, mods) {
self.set(cx, paths, edit);
match target {
Target::Insert { path, segment, .. } => self.report.select = Some(self.inserted(path, segment)),
Target::Duplicate { path, subpath, .. } => self.report.select = Some(self.copied(paths, path, subpath)),
_ => {}
}
}
}
return;
};
// A press reports its Down, and its drag start, before its release, and the overlay holds the press from
// either: a release with nothing held is of a press the overlay let go (a cancelled one), and does nothing.
let Some(held) = cx.press_slot::<Held>().take().filter(|held| held.origin == start.origin) else { return };
if held.target == Target::Marquee {
if held.began {
let rect = DocRect::from_points(view.to_doc(start.origin), view.to_doc(pos));
self.report.select = self.marquee_selection(paths, rect, mods);
} else if *self.selection != PathSelection::default() {
self.report.select = Some(PathSelection::default());
if matches!(cx.gesture(), Some(GesturePhase::Begin | GesturePhase::Update)) {
let rect = DocRect::from_points(view.to_doc(start.origin), view.to_doc(pos));
self.report.select = self.marquee_selection(paths, rect, mods);
cx.commit();
}
} else if !self.selection.anchors.is_empty() || self.selection.segment.is_some() {
self.report.select = Some(self.deselected());
}
return;
}
@@ -873,7 +904,7 @@ impl<'a> BezierOverlay<'a> {
return;
}
match held.target {
Target::Convert { path, knot } => self.set(cx, &held.start, PathEdit::Convert { path, knot, out: None }),
Target::Convert { path, knot } => self.set_always(cx, &held.start, PathEdit::Convert { path, knot, out: None }),
Target::Toggle { path, knot } => self.set(cx, &held.start, PathEdit::ToggleCurvature { path, knot }),
Target::CurvatureInsert { path, segment, t, .. } => {
self.set(cx, &held.start, PathEdit::InsertCurvature { path, segment, t, by: Vec2::ZERO });
@@ -1126,6 +1157,7 @@ impl Component for BezierOverlay<'_> {
/// below them all for the marquee. The anchors and handles are one roving group in keyboard order: one Tab stop,
/// arriving at the first selected anchor. The Page keys, Home and End are the overlay's own moves.
fn parts(&mut self, rect: egui::Rect, cx: &mut PartsCx<'_, Self>) {
self.press_tool(cx.press_slot::<Held>().as_ref());
let Some(space) = canvas_space(&cx.env) else { return };
let reach = cx.style.reach;
let Some(scene) = cx.value().map(|paths| self.scene(paths, &space.view, rect, reach)) else { return };
@@ -1163,6 +1195,7 @@ impl Component for BezierOverlay<'_> {
fn update(&mut self, cx: &mut Cx<'_, Self>) {
let Some(space) = canvas_space(&cx.env) else { return };
let Some(paths) = cx.value().cloned() else { return };
self.press_tool(cx.press_slot::<Held>().as_ref());
let scene = self.scene(&paths, &space.view, cx.rect, cx.style.reach);
self.run_pointer(cx, &space, &scene, &paths);
self.run_keys(cx, &space, &scene, &paths);
+126
View File
@@ -9,6 +9,7 @@ use craft_draw::ui::{
use craft_ui::canvas::{Canvas, Guide, ToolHost};
use craft_ui::canvas_controls::Guides;
use craft_ui::contract::{Bind, Props as _, Show as _, ShowContainer as _};
use craft_ui::primitives::cancel_press_of;
use craft_ui::testing::{Fixture, pointer, trial};
use egui::{Id, Pos2, Vec2 as ScreenVec, vec2};
use std::cell::RefCell;
@@ -797,3 +798,128 @@ fn the_anchor_tools_take_no_press_off_the_paths_and_show_their_own_cursor() {
});
assert_eq!(cursor_at(&mut h, egui::Modifiers::NONE), Some(Cursor::Painted(PaintedCursor::Crosshair)));
}
// A Direct Selection marquee is a gesture like the other drags: it begins with its drag, a release commits it with the
// anchors inside selected, and Escape cancels it and selects nothing.
#[trial]
fn a_marquee_is_one_gesture_that_escape_cancels() {
let from = |h: &Harness| h.screen(p(30.0, 30.0));
let to = |h: &Harness| h.screen(p(180.0, 80.0));
let mut h = two_paths();
let (start, end) = (from(&h), to(&h));
h.drag(start, end - start);
{
let st = h.state.borrow();
assert_eq!(st.selection, sel(1, &[(0, 0), (0, 1)]));
assert_eq!((st.seen.first(), st.seen.last()), (Some(&Seen::Begin), Some(&Seen::Commit)), "{:?}", st.seen);
}
let mut h = two_paths();
h.update(|st| st.selection = sel(2, &[(0, 0)]));
let (start, end) = (from(&h), to(&h));
h.press_at(start);
h.move_to(start + (end - start) * 0.5);
h.move_to(end);
h.fixture.key(egui::Key::Escape, egui::Modifiers::NONE).settle();
h.release_at(end);
let st = h.state.borrow();
assert!(st.seen.contains(&Seen::Cancel) && !st.seen.contains(&Seen::Commit), "{:?}", st.seen);
assert_eq!(st.selection, sel(2, &[(0, 0)]), "the cancelled marquee selects nothing");
}
// A click on empty canvas deselects the anchors and keeps the path they belong to as the one being edited.
#[trial]
fn a_click_on_empty_canvas_deselects_the_anchors_and_keeps_the_path() {
let mut h = two_paths();
h.update(|st| st.selection = sel(1, &[(0, 1)]));
let empty = h.screen(p(30.0, 30.0));
h.press_at(empty);
h.release_at(empty);
assert_eq!(h.state.borrow().selection, sel(1, &[]));
}
// Convert Point on an anchor that already is a corner still reports the click's edit: the host decides what it makes
// of it.
#[trial]
fn a_convert_click_on_a_corner_reports_its_edit() {
let mut h = two_paths();
h.update(|st| st.tool = BezierTool::Convert);
let corner = h.screen(p(60.0, 60.0));
h.press_at(corner);
h.release_at(corner);
let st = h.state.borrow();
assert!(matches!(st.changes.last(), Some(PathEdit::Convert { path: 1, out: None, .. })), "{:?}", st.changes);
assert!(st.seen.contains(&Seen::Set), "{:?}", st.seen);
}
// The arrow keys nudge the selected anchors, ⇧ by a larger step; each press is one edit, and with no anchor selected
// they move nothing.
#[trial]
fn arrow_keys_nudge_the_selected_anchors_and_shift_nudges_farther() {
let mut h = two_paths();
// The canvas, then the overlay.
h.fixture.key(egui::Key::Tab, egui::Modifiers::NONE).key(egui::Key::Tab, egui::Modifiers::NONE).settle();
h.fixture.key(egui::Key::ArrowRight, egui::Modifiers::NONE).settle();
assert!(h.state.borrow().changes.is_empty(), "nothing selected, nothing moves: {:?}", h.state.borrow().changes);
h.update(|st| st.selection = sel(1, &[(0, 1), (0, 2)]));
h.fixture.key(egui::Key::ArrowRight, egui::Modifiers::NONE).settle();
let Some(PathEdit::MoveAnchors { anchors, by: small, .. }) = h.last_change() else { panic!("{:?}", h.last_change()) };
assert_eq!(anchors, vec![kr(1), kr(2)]);
assert!(small.x > 0.0 && small.y == 0.0, "{small:?}");
h.fixture.key(egui::Key::ArrowRight, egui::Modifiers::SHIFT).settle();
let Some(PathEdit::MoveAnchors { by: far, .. }) = h.last_change() else { panic!("{:?}", h.last_change()) };
assert!(far.x > small.x, "{small:?} {far:?}");
assert_eq!(h.state.borrow().changes.len(), 2, "one edit per press");
}
// A press belongs to the tool it began under: switching the host's tool in the middle of a drag leaves the drag its
// own, and it commits as that tool's edit.
#[trial]
fn a_press_keeps_the_tool_it_began_under_across_a_tool_switch() {
let mut h = two_paths();
let anchor = h.screen(p(160.0, 60.0));
h.press_at(anchor);
h.move_to(anchor + vec2(FAR * 0.5, FAR * 0.5));
h.update(|st| st.tool = BezierTool::Anchors);
h.move_to(anchor + vec2(FAR, FAR));
h.release_at(anchor + vec2(FAR, FAR));
let st = h.state.borrow();
assert_eq!(st.seen.last(), Some(&Seen::Commit), "{:?}", st.seen);
assert!(matches!(st.changes.last(), Some(PathEdit::MoveAnchors { path: 1, .. })), "{:?}", st.changes);
}
// The parts follow the press's tool too: a marquee begun under Direct Selection keeps its part when the host switches
// to a tool that declares none, and its release selects the anchors it encloses.
#[trial]
fn a_tool_switch_mid_press_keeps_the_parts_the_press_began_with() {
let mut h = two_paths();
let (start, end) = (h.screen(p(30.0, 30.0)), h.screen(p(180.0, 80.0)));
h.press_at(start);
h.move_to(start + (end - start) * 0.5);
h.update(|st| st.tool = BezierTool::Anchors);
h.move_to(end);
h.release_at(end);
let st = h.state.borrow();
assert_eq!(st.seen.last(), Some(&Seen::Commit), "{:?}", st.seen);
assert_eq!(st.selection, sel(1, &[(0, 0), (0, 1)]));
}
// A press the host cancels (its target went away) ends as Escape ends one: the gesture is cancelled, its release
// reports nothing, and the paths stay.
#[trial]
fn a_cancelled_press_reports_nothing_on_release() {
let mut h = two_paths();
let before = h.state.borrow().paths.clone();
let anchor = h.screen(p(160.0, 60.0));
h.press_at(anchor);
h.move_to(anchor + vec2(FAR * 0.5, FAR * 0.5));
let overlay = h.state.borrow().id;
cancel_press_of(h.fixture.ctx(), overlay);
h.move_to(anchor + vec2(FAR, FAR));
h.release_at(anchor + vec2(FAR, FAR));
let st = h.state.borrow();
assert!(st.seen.contains(&Seen::Cancel), "{:?}", st.seen);
assert!(!st.seen.contains(&Seen::Commit) && !st.seen.contains(&Seen::Set), "{:?}", st.seen);
assert_eq!(st.paths, before);
}
+1
View File
@@ -857,6 +857,7 @@ fn cancel_reason(reason: PressCancel) -> CancelReason {
PressCancel::Escape => CancelReason::Escape,
PressCancel::FocusLost => CancelReason::Blur,
PressCancel::Disabled => CancelReason::Dismissed,
PressCancel::Host => CancelReason::HostChanged,
_ => CancelReason::Removed,
}
}
@@ -4,6 +4,7 @@ use super::measure::MeasureCx;
use super::scroll::{ScrollDecl, THUMB, thumb_covers_centre};
use crate::contract::{Component, Tooltip};
use crate::primitives::sensing::PartDecl;
use crate::runtime::memory::{MemoryStage, Slot};
use crate::runtime::focus::FocusShape;
use craft_behavior::{Axis, Cursor, CursorIcon, Flow, HitLevel, HitPriority, HitShape, PartKey, PartRef, Roving, ScrollSpan, Sense};
use craft_theme::Flags;
@@ -277,6 +278,8 @@ pub struct PartsCx<'a, C: Component> {
/// What the shape laid out before `parts`: a collection's rows as the item step places them this pass, a
/// container's header slots.
pub(crate) items: Option<std::rc::Rc<dyn std::any::Any>>,
/// The component's memory and id, for `press_slot`; none for a collection's member.
pub(crate) stage: Option<(&'a MemoryStage, Id)>,
}
impl<C: crate::contract::Container> PartsCx<'_, C> {
@@ -348,6 +351,12 @@ impl<C: Component> PartsCx<'_, C> {
self.gesture_running
}
/// A copy of the component's press slot as `update` left it (`Remember::press_slot`), so the parts can follow
/// the open press as its handling does. `None` with nothing held, and for a collection's member.
pub fn press_slot<T: Slot>(&self) -> Option<T> {
self.stage.and_then(|(stage, id)| stage.recall_press::<T>(id))
}
/// Declares a part; a repeated part is named with its index: `cx.part(POINT.at(id), shape)`.
pub fn part(&mut self, part: impl Into<PartRef>, shape: impl Into<HitShape>) -> PartBuilder<'_> {
let part = part.into();
@@ -286,6 +286,7 @@ impl<'a, C: Component> ErasedPass<'a> for TypedPass<'_, 'a, C> {
gesture_running: self.cx.core.memory.recall::<Gesture<ValueOf<C>>>(gesture_key(id)).is_running(),
measure,
items: geometry,
stage: Some((&*self.cx.core.memory, id)),
};
self.comp.parts(rect, &mut pcx);
self.hooks.parts(self.comp, rect, &mut pcx);
@@ -754,6 +755,7 @@ pub(crate) fn member_prepare<C: Show>(ui: &Ui, env: &Env, id: Id, row: Rect, hov
gesture_running: false,
measure: steps::measure_cx::<C>(&input, &style, &resolved, shown.as_deref()),
items: None,
stage: None,
};
item.parts(row, &mut pcx);
}
@@ -55,6 +55,7 @@ pub(crate) fn edit_intents<C: Component>(comp: &mut C, cx: &mut Cx<'_, C>) {
cx.core.press_cancelled().map(|reason| match reason {
PressCancel::Escape => CancelReason::Escape,
PressCancel::Removed => CancelReason::Removed,
PressCancel::Host => CancelReason::HostChanged,
_ => CancelReason::Blur,
})
};
+1 -1
View File
@@ -48,7 +48,7 @@ pub use paint_slot::PaintSlot;
pub use reset_mark::ResetMark;
pub use rule::{RectSide, Rule, RuleKind};
pub use scroll_bar::{HiddenContent, ScrollBar};
pub use sensing::{PartResult, TextOutcome, member_gesture_running};
pub use sensing::{PartResult, TextOutcome, cancel_press_of, member_gesture_running};
pub use state_layer::{StateLayer, StateLayerKind};
pub use surface::Surface;
pub(crate) use surface::SurfaceSlot;
+23 -2
View File
@@ -239,6 +239,8 @@ struct ArenaState {
/// egui widgets lie over the members shown before them; a member shown after one of them over its rect gets an
/// egui widget of its own, so egui's press target there is the member's (8.3).
nested: Vec<Rect>,
/// The host asked to end the open press (`cancel_press_of`): the arena's next lifecycle run ends it.
host_cancel: bool,
}
#[derive(Default)]
@@ -381,6 +383,20 @@ pub fn member_gesture_running(ctx: &Context, viewport: ViewportId, arena: Id) ->
.any(|member| MemoryStage::peek_with::<RemovalWatch, _>(ctx, gesture_key(member), RemovalWatch::armed))
}
/// Ends the press `owner` holds open the way Escape ends a captured press: the next lifecycle run of the arena it is
/// open in reports `PressPhase::Cancel` with `PressCancel::Host`, and step 9 cancels the gesture the press carries
/// (`CancelReason::HostChanged`). For a host whose own state no longer matches what the press acts on; it may ask
/// inside or outside a pass. Nothing happens when `owner` holds no open press.
pub fn cancel_press_of(ctx: &Context, owner: Id) {
PerViewport::<Arenas>::each(ctx, |arenas| {
for state in arenas.by_root.values_mut() {
if state.machine.target().is_some_and(|target| target.owner == owner) {
state.host_cancel = true;
}
}
});
}
/// Notes a root shown in the body of `arena` that is not one of its members and takes a press, over `rect`: the
/// members shown after it over that rect stack above it.
pub(crate) fn note_nested(ctx: &Context, arena: ArenaId, rect: Rect) {
@@ -751,8 +767,12 @@ fn outcome_in(ctx: &Context, read: &PassRead, arena: ArenaId, layer: Layer, enab
pass_pointer.frame.as_ref().map_or((0.0, egui::Vec2::ZERO, None, craft_behavior::Buttons::empty(), 0.0), |frame| {
(frame.slop, frame.delta, frame.pos, frame.buttons, frame.target)
});
let cancel = if enabled { pointer::cancel_of_pass(ctx) } else { Some(craft_behavior::PressCancel::Disabled) };
let body_layer = with_arena(ctx, arena, pass_nr, |state| state.layer);
let (body_layer, host_cancel) = with_arena(ctx, arena, pass_nr, |state| (state.layer, std::mem::take(&mut state.host_cancel)));
let cancel = if enabled {
pointer::cancel_of_pass(ctx).or(host_cancel.then_some(craft_behavior::PressCancel::Host))
} else {
Some(craft_behavior::PressCancel::Disabled)
};
let xf = body_layer.and_then(|layer| areas::layer_map(ctx, layer));
// Hover needs the root's layer on top under the pointer, or egui's layer cover (a popup) would be ignored.
let top = pass_pointer.hover.and_then(|at| areas::layer_at(ctx, at));
@@ -844,6 +864,7 @@ fn sweep_undrawn(ctx: &Context) {
};
if orphaned(state) {
state.machine = PressMachine::default();
state.host_cancel = false;
gone = true;
}
}
+5
View File
@@ -240,6 +240,11 @@ impl<T: Stored> PerViewport<T> {
out
}
/// Runs `f` on the record of every viewport that has one.
pub(crate) fn each(ctx: &Context, mut f: impl FnMut(&mut T)) {
T::records(ctx, |records| records.records.iter_mut().for_each(|(_, record)| f(record)));
}
fn register_prune(ctx: &Context) {
fn prune<T: Stored>(ctx: &Context, live: &[ViewportId]) {
T::records(ctx, |records| records.records.retain(|(viewport, _)| live.contains(viewport)));
+13
View File
@@ -605,6 +605,19 @@ impl MemoryStage {
}
}
/// A read-only copy of the press slot of `id`, as `recall` reads a shown one.
pub(crate) fn recall_press<T: Slot>(&self, id: Id) -> Option<T> {
let open = self
.entries
.iter()
.find(|entry| entry.key == (PRESS, TypeId::of::<Option<T>>(), id))
.and_then(|entry| entry.value.downcast_ref::<Wrapped<PRESS, Option<T>>>());
match open {
Some(wrapped) => wrapped.0.clone(),
None => store::peek_clone::<Wrapped<PRESS, Option<T>>>(&self.ctx, id).and_then(|wrapped| wrapped.0),
}
}
/// Step 17, after `finish` returned: every slot goes back to context data, and the registry gains a record
/// for each slot and `Seen` mark it lacks. A slot the stage found in context data is recorded already; a stage
/// owned by another component than its base records everything it wrote under that owner.