diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 754248cd3..c5084eccb 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -557,9 +557,15 @@ fn run_clear(s: &mut Session, _p: &Value) -> Result { fn run_selectall(s: &mut Session, _p: &Value) -> Result { let space = s.space(); let d = s.doc()?; + let frozen = s.viewport_frozen(); let hs: Vec = d .space(&space) - .map(|st| st.iter().filter(|e| d.is_visible(e) && d.layer(&e.common.layer).is_none_or(|l| !l.locked)).map(|e| e.handle).collect()) + .map(|st| { + st.iter() + .filter(|e| crate::select::selectable(d, e, frozen) && d.layer(&e.common.layer).is_none_or(|l| !l.locked)) + .map(|e| e.handle) + .collect() + }) .unwrap_or_default(); let n = hs.len(); s.set_selection(hs); @@ -580,16 +586,19 @@ fn run_select(s: &mut Session, p: &Value) -> Result { let add = bool_or(p, "add", false); let picked: Vec = if let Some(w) = points_param(p, "window") { let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("select", "window needs 2 corners")) }; - crate::select::select_window(s.doc()?, &space, Bounds2::new(*a, *b), bool_or(p, "crossing", false)) + crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), Bounds2::new(*a, *b), bool_or(p, "crossing", false)) } else if let Some(at) = point_param(p, "at") { let ap = f64_or(p, "aperture", s.pixel_size() * s.settings.pickbox * 1.5); - crate::select::pick(s.doc()?, &space, at, ap).into_iter().collect() + crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), at, ap).into_iter().collect() } else if let Some(f) = points_param(p, "fence") { - crate::select::select_fence(s.doc()?, &space, &f) - } else { + crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &f) + } else if ["handles", "handle"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null())) { targets(s, p)? + } else { + // Nothing to select with: the selection stays, also what the active viewport does not draw. + s.stored_selection() }; - let mut sel = if add { s.selection() } else { Vec::new() }; + let mut sel = if add { s.stored_selection() } else { Vec::new() }; sel.extend(picked); s.set_selection(sel); let sel = s.selection(); diff --git a/crates/engine/src/cmd/griphot.rs b/crates/engine/src/cmd/griphot.rs index df466aa1c..9234d981c 100644 --- a/crates/engine/src/cmd/griphot.rs +++ b/crates/engine/src/cmd/griphot.rs @@ -44,7 +44,7 @@ pub(crate) struct GripEdit { /// Typed `GRIP`: still collecting grips ("Select grips"). picking: bool, /// What MOVE/ROTATE/SCALE/MIRROR transform: the hot grips' objects and the objects of the - /// selection that the drawing shows. + /// selection that the view being edited shows. targets: Vec, base: Vec2, mode: GripMode, @@ -70,10 +70,11 @@ fn positive(v: Option) -> Result { v.filter(|f| f.is_finite() && *f > 1e-12).ok_or_else(|| other("Requires a positive number.")) } -/// Whether the drawing shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer) takes no -/// part in a grip edit, even when Undo or a selection command put it back into the selection. +/// Whether the view being edited shows `h`. A hidden object (HIDEOBJECTS, an off or frozen layer, +/// a layer frozen in the active MSPACE viewport) takes no part in a grip edit, even when Undo or +/// a selection command put it back into the selection. fn shown(s: &Session, h: Handle) -> bool { - s.doc().is_ok_and(|d| d.entity(h).is_some_and(|e| d.is_visible(e))) + s.state().is_ok_and(|st| st.doc.entity(h).is_some_and(|e| st.shows(e))) } impl GripEdit { @@ -95,7 +96,8 @@ impl GripEdit { } /// Make grip `index` of `h` hot (the first one becomes the base point). The grip of an object - /// the drawing does not show is left out, and so are the hidden objects of the selection. + /// the view being edited does not show is left out, and so are the hidden objects of the + /// selection. fn add_hot(&mut self, s: &Session, (h, i): (Handle, usize)) -> Result<()> { if self.hot.contains(&(h, i)) || self.hot.len() >= MAX_HOT { return Ok(()); @@ -119,13 +121,13 @@ impl GripEdit { /// The grips of the selected objects at `p` (typed `GRIP`): all objects with a grip there. fn grips_at(s: &Session, p: Vec2) -> Vec<(Handle, usize)> { let tol = (s.pixel_size() * (s.settings.gripsize + 3.0)).max(1e-9 * (1.0 + p.len())); - let Ok(d) = s.doc() else { return Vec::new() }; + let Ok(st) = s.state() else { return Vec::new() }; let mut out = Vec::new(); for h in s.selection().into_iter().take(MAX_HOT) { if super::curves::is_locked(s, h) { continue; } - let Some(e) = d.entity(h).filter(|e| d.is_visible(e)) else { continue }; + let Some(e) = st.doc.entity(h).filter(|e| st.shows(e)) else { continue }; let gs = e.kind.grips(); // The nearest grip of this object within the tolerance. let best = gs @@ -483,8 +485,8 @@ impl Session { /// Make grips hot and start editing them (the UI's click on a grip; Shift+click collects /// several first). `hot` lists (object, grip index); the first is the base grip. The grip /// modes and their options then run at the command line like any prompt. Grips of objects the - /// drawing does not show are left out (the first grip left is the base grip), and it is an - /// error when none is left. + /// view being edited does not show are left out (the first grip left is the base grip), and it + /// is an error when none is left. pub fn start_grip_edit(&mut self, hot: &[(Handle, usize)]) -> Result<()> { if self.running.is_some() { self.cancel(); diff --git a/crates/engine/src/cmd/groups/pick.rs b/crates/engine/src/cmd/groups/pick.rs index 7a9833876..10b1b332e 100644 --- a/crates/engine/src/cmd/groups/pick.rs +++ b/crates/engine/src/cmd/groups/pick.rs @@ -28,7 +28,8 @@ pub fn specs() -> Vec { const MEMBER_PICKS: &[&str] = &["groupedit", "-group"]; /// `hs` plus the other members of the selectable groups they belong to (in the space being -/// edited, visible), when PICKSTYLE has group selection on. Order: `hs` first. +/// edited, visible, and inside an MSPACE viewport not on a layer frozen in it), when PICKSTYLE +/// has group selection on. Order: `hs` first. pub(crate) fn expand(s: &Session, hs: Vec) -> Vec { if s.settings.pickstyle & 1 == 0 || hs.is_empty() || s.running.as_ref().is_some_and(|r| MEMBER_PICKS.contains(&r.id.as_str())) { return hs; @@ -39,6 +40,7 @@ pub(crate) fn expand(s: &Session, hs: Vec) -> Vec { } let space = s.space(); let Some(store) = d.space(&space) else { return hs }; + let frozen = s.viewport_frozen(); // Member → its selectable groups, built once (window selections may hold many objects). let mut of: HashMap> = HashMap::new(); for (i, g) in d.groups.iter().enumerate().filter(|(_, g)| g.selectable) { @@ -56,7 +58,7 @@ pub(crate) fn expand(s: &Session, hs: Vec) -> Vec { } let Some(g) = d.groups.get(*gi) else { continue }; for m in &g.members { - if store.get(*m).is_some_and(|e| d.is_visible(e)) && seen.insert(*m) { + if store.get(*m).is_some_and(|e| crate::select::selectable(d, e, frozen)) && seen.insert(*m) { out.push(*m); } } diff --git a/crates/engine/src/cmd/inquiry.rs b/crates/engine/src/cmd/inquiry.rs index 283551dfd..5d895f70d 100644 --- a/crates/engine/src/cmd/inquiry.rs +++ b/crates/engine/src/cmd/inquiry.rs @@ -591,7 +591,7 @@ fn run_inspect(s: &mut Session, p: &Value) -> Result { "dimStyles": d.dim_styles.iter().map(|l| l.name.clone()).collect::>(), "blocks": d.blocks.keys().filter(|k| !k.starts_with('*')).cloned().collect::>(), "layouts": d.layouts.iter().map(|l| l.name.clone()).collect::>(), - "selection": st.selection.iter().map(|h| h.hex()).collect::>(), + "selection": st.shown_selection().iter().map(|h| h.hex()).collect::>(), "undo": st.undo.iter().rev().take(20).map(|u| u.label.clone()).collect::>(), "view": { "center": [st.view().center.x, st.view().center.y], "height": st.view().height }, // Records of the file the drawing came from that the reader could not place. diff --git a/crates/engine/src/cmd/modify/stretch.rs b/crates/engine/src/cmd/modify/stretch.rs index a277f9774..262ec7105 100644 --- a/crates/engine/src/cmd/modify/stretch.rs +++ b/crates/engine/src/cmd/modify/stretch.rs @@ -21,14 +21,17 @@ impl StretchArea { } } -/// Add to `hs` the visible multilines in `space` with a control vertex inside `area`. A crossing -/// selection tests the drawn element lines, which sit away from the control vertices by the -/// multiline's scale, so a small area around a vertex alone would miss them. -fn add_mline_vertex_hits(d: &cadcraft_doc::Drawing, space: &cadcraft_doc::Space, area: &StretchArea, hs: &mut Vec) { - let Some(store) = d.space(space) else { return }; +/// Add to `hs` the multilines in the edit space that a selection can take there (visible, and +/// inside an MSPACE viewport not on a layer frozen in it) with a control vertex inside `area`. A +/// crossing selection tests the drawn element lines, which sit away from the control vertices by +/// the multiline's scale, so a small area around a vertex alone would miss them. +fn add_mline_vertex_hits(s: &Session, area: &StretchArea, hs: &mut Vec) { + let Ok(d) = s.doc() else { return }; + let Some(store) = d.space(&s.space()) else { return }; + let frozen = s.viewport_frozen(); for e in store.iter() { if let EntityKind::MLine(m) = &e.kind - && d.is_visible(e) + && crate::select::selectable(d, e, frozen) && !hs.contains(&e.handle) && m.vertices.iter().any(|v| area.contains(v.p.xy())) { @@ -94,19 +97,19 @@ pub(super) fn run_stretch(s: &mut Session, p: &Value) -> Result { }; // A fence marks no area: the objects it crosses move whole. if let Some(fence) = listed("fence", 2)? { - let hs = crate::select::select_fence(s.doc()?, &space, &fence); + let hs = crate::select::select_fence_in(s.doc()?, &space, s.viewport_frozen(), &fence); let moved = transform_entities(s, &hs, &Mat3::translate(d), false)?; return Ok(json!({ "stretched": moved.len() })); } let (mut hs, area) = if let Some(poly) = listed("polygon", 3)? { - (crate::select::select_polygon(s.doc()?, &space, &poly, true), StretchArea::Polygon(poly)) + (crate::select::select_polygon_in(s.doc()?, &space, s.viewport_frozen(), &poly, true), StretchArea::Polygon(poly)) } else { let w = points_param(p, "window").ok_or_else(|| bad("stretch", "`window` [[x,y],[x,y]], `polygon` or `fence` is required"))?; let (Some(a), Some(b)) = (w.first(), w.get(1)) else { return Err(bad("stretch", "window needs 2 corners")) }; let bx = cadcraft_geom::Bounds2::new(*a, *b); - (crate::select::select_window(s.doc()?, &space, bx, true), StretchArea::Box(bx)) + (crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, true), StretchArea::Box(bx)) }; - add_mline_vertex_hits(s.doc()?, &space, &area, &mut hs); + add_mline_vertex_hits(s, &area, &mut hs); hs.retain(|h| !crate::cmd::curves::is_locked(s, *h)); let doc = s.doc_mut()?; let areas = [area]; @@ -173,7 +176,7 @@ impl StretchM { /// of two) the mode is dropped. fn finish_mode(&mut self, s: &mut Session, m: SelectMode) -> Result<()> { let space = s.space(); - let Some(mut hs) = m.select(s.doc()?, &space) else { return Ok(()) }; + let Some(mut hs) = m.select_in(s.doc()?, &space, s.viewport_frozen()) else { return Ok(()) }; let crossing = match (m.kind, m.pts.first().zip(m.pts.get(1))) { (SelectKind::Crossing | SelectKind::CPolygon, _) => true, (SelectKind::Box, Some((a, b))) => b.x < a.x, @@ -189,7 +192,7 @@ impl StretchM { }; let whole = area.is_none(); if let (Some(a), true, false) = (&area, crossing, self.removing) { - add_mline_vertex_hits(s.doc()?, &space, a, &mut hs); + add_mline_vertex_hits(s, a, &mut hs); } if let (Some(a), false) = (area, self.removing) { self.windows.push(a); @@ -228,10 +231,10 @@ impl StretchM { Some(c) => { let bx = cadcraft_geom::Bounds2::new(c, p); let space = s.space(); - let mut hs = crate::select::select_window(s.doc()?, &space, bx, p.x < c.x); + let mut hs = crate::select::select_window_in(s.doc()?, &space, s.viewport_frozen(), bx, p.x < c.x); if !self.removing { if p.x < c.x { - add_mline_vertex_hits(s.doc()?, &space, &StretchArea::Box(bx), &mut hs); + add_mline_vertex_hits(s, &StretchArea::Box(bx), &mut hs); } self.windows.push(StretchArea::Box(bx)); } @@ -240,7 +243,7 @@ impl StretchM { None => { let aperture = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5; let space = s.space(); - match crate::select::pick(s.doc()?, &space, p, aperture) { + match crate::select::pick_in(s.doc()?, &space, s.viewport_frozen(), p, aperture) { Some(h) => self.add(s, vec![h], true), None => self.corner = Some(p), } @@ -251,6 +254,7 @@ impl StretchM { self.corner = None; let d = s.doc()?; let store = d.space(&s.space()); + let frozen = s.viewport_frozen(); let word = t.trim().to_ascii_lowercase(); // `_C`, `_L`: the English name, as scripts write it. let word = word.strip_prefix('_').unwrap_or(&word).to_string(); @@ -267,9 +271,14 @@ impl StretchM { self.removing = false; None } - "all" => Some(store.map(|st| st.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()).unwrap_or_default()), - "l" | "last" => Some(store.and_then(|st| st.last()).map(|e| vec![e.handle]).unwrap_or_default()), - "p" | "previous" => Some(s.state()?.previous_selection.clone()), + "all" => Some( + store.map(|st| st.iter().filter(|e| crate::select::selectable(d, e, frozen)).map(|e| e.handle).collect()).unwrap_or_default(), + ), + "l" | "last" => Some(store.and_then(|st| crate::select::last_in(st, frozen)).map(|h| vec![h]).unwrap_or_default()), + "p" | "previous" => { + let st = s.state()?; + Some(st.drawn_in_viewport(&st.previous_selection)) + } _ => { s.echo("*Invalid selection*"); None diff --git a/crates/engine/src/cmd/qselect.rs b/crates/engine/src/cmd/qselect.rs index 18959e197..236fb89c2 100644 --- a/crates/engine/src/cmd/qselect.rs +++ b/crates/engine/src/cmd/qselect.rs @@ -280,7 +280,7 @@ fn run_qselect(s: &mut Session, p: &Value) -> Result { let sel = match mode.as_str() { "exclude" => excluded, "append" => { - let mut cur = s.selection(); + let mut cur = s.stored_selection(); for h in matched { if !cur.contains(&h) { cur.push(h); diff --git a/crates/engine/src/cmd/selecttools.rs b/crates/engine/src/cmd/selecttools.rs index 1f742bb11..8dc011443 100644 --- a/crates/engine/src/cmd/selecttools.rs +++ b/crates/engine/src/cmd/selecttools.rs @@ -99,14 +99,21 @@ pub(crate) fn similar(e: &Entity, r: &Entity, mode: u32) -> bool { && (mode & NAME == 0 || same_text(object_name(e), object_name(r))) } -/// The visible objects of the current space like any of `refs`. +/// The objects of the current space like any of `refs` that a selection can take there: visible, +/// and inside an MSPACE viewport not on a layer frozen in it. fn similar_objects(s: &Session, d: &Drawing, refs: &[Handle], mode: u32) -> Vec { let refs: Vec<&Entity> = refs.iter().filter_map(|h| d.entity(*h).map(|e| e.as_ref())).collect(); if refs.is_empty() { return Vec::new(); } let Some(store) = d.space(&s.space()) else { return Vec::new() }; - store.iter().take(MAX_SCAN).filter(|e| d.is_visible(e) && refs.iter().any(|r| similar(e, r, mode))).map(|e| e.handle).collect() + let frozen = s.viewport_frozen(); + store + .iter() + .take(MAX_SCAN) + .filter(|e| crate::select::selectable(d, e, frozen) && refs.iter().any(|r| similar(e, r, mode))) + .map(|e| e.handle) + .collect() } fn mode_param(s: &Session, p: &Value) -> Result { diff --git a/crates/engine/src/cmd/trimextend.rs b/crates/engine/src/cmd/trimextend.rs index eab957589..09acfc140 100644 --- a/crates/engine/src/cmd/trimextend.rs +++ b/crates/engine/src/cmd/trimextend.rs @@ -59,7 +59,7 @@ fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bo let fb = Bounds2::from_points(pts.iter().copied()); let tol = crate::select::window_tol(&fb); let mut work: Vec<(Handle, Vec)> = Vec::new(); - for h in crate::select::select_fence(d, &space, pts) { + for h in crate::select::select_fence_in(d, &space, s.viewport_frozen(), pts) { let Some(e) = d.entity(h) else { continue }; let polys = crate::select::hit_polylines(d, e, tol); let mut xs: Vec = Vec::new(); @@ -96,7 +96,7 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu ]; let inside = |p: Vec2| bx.expand(tol).contains(p); let mut work: Vec<(Handle, Vec)> = Vec::new(); - for h in crate::select::select_window(d, &space, bx, true) { + for h in crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, true) { let Some(e) = d.entity(h) else { continue }; let mut best: Option = None; for pl in crate::select::hit_polylines(d, e, tol) { diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs index f3862f90a..2ab8054bf 100644 --- a/crates/engine/src/doc_state.rs +++ b/crates/engine/src/doc_state.rs @@ -8,6 +8,12 @@ pub struct Snapshot { pub selection: Vec, } +/// [`DocState::drawn_in_viewport`] looks its handles up one by one while there is fewer than one +/// of them for every `LOOKUP_COST` objects of model space, and passes over model space once +/// otherwise. Timed on drawings of 40,000 and of 200,000 lines, the two cost the same at about +/// one handle for every 47 and for every 18 objects. +const LOOKUP_COST: usize = 32; + /// One open drawing. #[derive(Clone, Debug)] pub struct DocState { @@ -119,13 +125,65 @@ impl DocState { } /// The active MSPACE viewport, if it still exists in the current layout. pub fn active_viewport(&self) -> Option<(Handle, cadcraft_doc::Viewport)> { + self.active_viewport_ref().map(|(h, v)| (h, v.clone())) + } + /// [`DocState::active_viewport`] without copying the viewport. + fn active_viewport_ref(&self) -> Option<(Handle, &cadcraft_doc::Viewport)> { let h = self.mspace?; let e = self.doc.space(&self.space)?.get(h)?; match &e.kind { - cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v.clone())), + cadcraft_doc::EntityKind::Viewport(v) if v.height > 1e-12 && v.view_height > 1e-12 => Some((h, v)), _ => None, } } + /// The layers frozen in the active MSPACE viewport (VPLAYER, "VP Freeze"): that viewport does + /// not draw their objects, so picks, selections and grips made through it leave them out. + /// Empty in paper space and on the Model tab. + pub fn viewport_frozen(&self) -> &[String] { + match self.active_viewport_ref() { + Some((_, v)) => &v.frozen_layers, + None => &[], + } + } + /// Whether `e` is a model-space object the active MSPACE viewport does not draw: it is on a + /// layer frozen in that viewport ([`DocState::viewport_frozen`]). Objects on the sheet are not + /// drawn through the viewport, so its frozen layers do not hide them. + pub fn hidden_in_viewport(&self, e: &cadcraft_doc::Entity) -> bool { + crate::select::on_frozen_layer(self.viewport_frozen(), e) && self.doc.model.contains(e.handle) + } + /// Whether the view being edited shows `e`: the drawing shows it ([`Drawing::is_visible`]), + /// and the active MSPACE viewport, if there is one, draws it + /// ([`DocState::hidden_in_viewport`]). + pub fn shows(&self, e: &cadcraft_doc::Entity) -> bool { + self.doc.is_visible(e) && !self.hidden_in_viewport(e) + } + /// `handles` without the objects the active MSPACE viewport does not draw + /// ([`DocState::hidden_in_viewport`]): a set of objects made earlier (the selection, the + /// Previous set) as that viewport takes it. All of them anywhere else. + pub(crate) fn drawn_in_viewport(&self, handles: &[Handle]) -> Vec { + let frozen = self.viewport_frozen(); + if frozen.is_empty() || handles.is_empty() { + return handles.to_vec(); + } + let model = &self.doc.model; + let hidden = |e: &Arc| crate::select::on_frozen_layer(frozen, e); + // The UI asks for the selection several times a frame. A few handles are looked up one + // by one; beyond that, one pass over model space costs less than the lookups. + if handles.len().saturating_mul(LOOKUP_COST) < model.len() { + return handles.iter().copied().filter(|h| !model.get(*h).is_some_and(hidden)).collect(); + } + let mut gone: Vec = model.iter().filter(|e| hidden(e)).map(|e| e.handle).collect(); + gone.sort_unstable(); + handles.iter().copied().filter(|h| gone.binary_search(h).is_err()).collect() + } + /// The selection as the view being edited has it: [`DocState::selection`] without the objects + /// the active MSPACE viewport does not draw. Those stay in [`DocState::selection`] until the + /// selection is replaced or cleared, and count as selected again once that viewport draws + /// them; until then nothing that starts from the selection (a command, a grip, a palette) + /// edits them through that viewport. + pub fn shown_selection(&self) -> Vec { + self.drawn_in_viewport(&self.selection) + } pub fn paper_view(&self) -> View { self.views.iter().find(|(s, _)| *s == self.space).map(|(_, v)| *v).unwrap_or_default() } diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 2e02831dd..a4d003de0 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -236,11 +236,25 @@ impl Session { pub fn space(&self) -> Space { self.state().map(DocState::edit_space).unwrap_or_default() } + /// The layers frozen in the active MSPACE viewport ([`DocState::viewport_frozen`]): what a + /// pick or a selection in [`Session::space`] leaves out. Empty with no drawing open. + pub fn viewport_frozen(&self) -> &[String] { + self.state().map(DocState::viewport_frozen).unwrap_or_default() + } /// The tab being displayed: Model or a layout, regardless of MSPACE. pub fn layout_space(&self) -> Space { self.state().map(|s| s.space.clone()).unwrap_or_default() } + /// The selected objects as the view being edited has them ([`DocState::shown_selection`]): + /// inside an MSPACE viewport, without the objects on layers frozen in that viewport. Commands, + /// grips and palettes start from this; [`DocState::selection`] holds every selected object. pub fn selection(&self) -> Vec { + self.state().map(DocState::shown_selection).unwrap_or_default() + } + /// Every selected object ([`DocState::selection`]), also the ones the active MSPACE viewport + /// does not draw, which [`Session::selection`] leaves out. Adding to the selection or removing + /// from it starts from this, so that it keeps them. + pub(crate) fn stored_selection(&self) -> Vec { self.state().map(|s| s.selection.clone()).unwrap_or_default() } pub fn set_selection(&mut self, sel: Vec) { diff --git a/crates/engine/src/lisp/drawing.rs b/crates/engine/src/lisp/drawing.rs index afef38483..2d1a088a7 100644 --- a/crates/engine/src/lisp/drawing.rs +++ b/crates/engine/src/lisp/drawing.rs @@ -651,15 +651,19 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec) -> Result { Some("X") => all(s, true), Some("L") => { let order = handles_in_order(ctx); - order.last().copied().into_iter().collect() + // Inside an MSPACE viewport, the objects that viewport does not draw are passed over. + let st = ctx.s.state().ok(); + let drawn = |h: &Handle| st.is_none_or(|st| st.doc.entity(*h).is_none_or(|e| !st.hidden_in_viewport(e))); + order.iter().rev().copied().find(drawn).into_iter().collect() } - Some("P") => ctx.s.state().map(|st| st.previous_selection.clone()).unwrap_or_default(), + Some("P") => ctx.s.state().map(|st| st.drawn_in_viewport(&st.previous_selection)).unwrap_or_default(), Some("I") => ctx.s.selection(), Some("W") | Some("C") => { let (p1, p2) = (point(0)?, point(1)?); let s = &*ctx.s; let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) }; - crate::select::select_window(d, &space, cadcraft_geom::Bounds2::from_points([p1, p2]), mode.as_deref() == Some("C")) + let bx = cadcraft_geom::Bounds2::from_points([p1, p2]); + crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, mode.as_deref() == Some("C")) } Some("F") | Some("WP") | Some("CP") => { let poly: Vec = @@ -667,8 +671,8 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec) -> Result { let s = &*ctx.s; let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) }; match mode.as_deref() { - Some("F") => crate::select::select_fence(d, &space, &poly), - m => crate::select::select_polygon(d, &space, &poly, m == Some("CP")), + Some("F") => crate::select::select_fence_in(d, &space, s.viewport_frozen(), &poly), + m => crate::select::select_polygon_in(d, &space, s.viewport_frozen(), &poly, m == Some("CP")), } } Some(":S") | Some("A") | None => { @@ -684,7 +688,7 @@ pub fn ssget(ctx: &mut Ctx<'_>, a: Vec) -> Result { let s = &*ctx.s; let ap = s.settings.pickbox.max(1.0) * s.pixel_size(); let Ok(d) = s.doc() else { return Ok(Flow::Value(Value::Nil)) }; - crate::select::pick(d, &space, p, ap).into_iter().collect() + crate::select::pick_in(d, &space, s.viewport_frozen(), p, ap).into_iter().collect() } } Some(m) => return Err(LispError::new(format!("bad argument value: ssget mode {m}"))), diff --git a/crates/engine/src/lisp/input.rs b/crates/engine/src/lisp/input.rs index bace2c0c0..13020ab2b 100644 --- a/crates/engine/src/lisp/input.rs +++ b/crates/engine/src/lisp/input.rs @@ -141,7 +141,7 @@ impl GetRequest { let ap = s.settings.pickbox.max(1.0) * s.pixel_size(); let space = s.state().map(|st| st.edit_space()).map_err(|e| Again::Msg(e.to_string()))?; let d = s.doc().map_err(|e| Again::Msg(e.to_string()))?; - match crate::select::pick(d, &space, Vec2::new(p[0], p[1]), ap) { + match crate::select::pick_in(d, &space, s.viewport_frozen(), Vec2::new(p[0], p[1]), ap) { Some(h) => Ok(Value::list(vec![Value::Ename(h), Value::point(&p)])), None => Err("Missed, try again.".into()), } diff --git a/crates/engine/src/select.rs b/crates/engine/src/select.rs index b5ef2dc9f..56403f8fa 100644 --- a/crates/engine/src/select.rs +++ b/crates/engine/src/select.rs @@ -152,8 +152,28 @@ fn in_box(pts: impl Iterator, angle: f64, p: Vec2) -> bool { !b.is_empty() && b.contains(turn(p)) } -fn selectable(d: &Drawing, e: &Entity) -> bool { - d.is_visible(e) +/// Whether `e` is on one of the layers in `frozen`: the layers frozen in a layout viewport, which +/// does not draw their objects. The names are compared as the renderer compares them. +pub(crate) fn on_frozen_layer(frozen: &[String], e: &Entity) -> bool { + frozen.iter().any(|l| l.eq_ignore_ascii_case(&e.common.layer)) +} + +/// The last object of `store`, in draw order, that is not on one of the layers in `frozen`, the +/// layers frozen in the layout viewport the selection is made through: what the Last option +/// takes there. With no such layers it is the last object, whether the drawing shows it or not. +pub(crate) fn last_in(store: &cadcraft_doc::EntityStore, frozen: &[String]) -> Option { + if frozen.is_empty() { + return store.last().map(|e| e.handle); + } + store.iter().filter(|e| !on_frozen_layer(frozen, e)).last().map(|e| e.handle) +} + +/// Whether a selection can take `e`: the drawing shows it ([`Drawing::is_visible`]) and it is not +/// on one of the layers in `frozen`, the layers frozen in the layout viewport the selection is +/// made through ([`crate::DocState::viewport_frozen`]; empty anywhere else). A viewport shows +/// model space, so `frozen` goes with a selection in model space only. +pub(crate) fn selectable(d: &Drawing, e: &Entity, frozen: &[String]) -> bool { + d.is_visible(e) && !on_frozen_layer(frozen, e) } /// Entities to test, in the order to test them, each with its bounds when already known. @@ -196,15 +216,28 @@ pub(crate) fn candidates<'a>( /// the nearest, as AutoCAD 2024 picks (two objects under the pickbox: the one drawn later is /// picked, and DRAWORDER changes which). pub fn pick(d: &Drawing, space: &Space, p: Vec2, aperture: f64) -> Option { - let ix = spatial::index(d, space); - pick_with(d, space, &ix, p, aperture) + pick_in(d, space, &[], p, aperture) } -pub(crate) fn pick_with(d: &Drawing, space: &Space, ix: &Option>, p: Vec2, aperture: f64) -> Option { +/// [`pick`] through a layout viewport: the objects on the layers in `frozen`, the layers frozen +/// in that viewport, are not drawn there and are not picked. +pub fn pick_in(d: &Drawing, space: &Space, frozen: &[String], p: Vec2, aperture: f64) -> Option { + let ix = spatial::index(d, space); + pick_with(d, space, &ix, frozen, p, aperture) +} + +pub(crate) fn pick_with( + d: &Drawing, + space: &Space, + ix: &Option>, + frozen: &[String], + p: Vec2, + aperture: f64, +) -> Option { let probe = Bounds2::new(p, p).expand(aperture); // Candidates come topmost first: the first within the aperture is the one. for (e, known) in candidates(d, space, ix, &probe.expand(aperture), true, true)? { - if !selectable(d, e) { + if !selectable(d, e, frozen) { continue; } let infinite = is_infinite(e); @@ -221,11 +254,16 @@ pub(crate) fn pick_with(d: &Drawing, space: &Space, ix: &Option Vec { + pick_all_in(d, space, &[], p, aperture) +} + +/// [`pick_all`] through a layout viewport that freezes the layers in `frozen` ([`pick_in`]). +pub fn pick_all_in(d: &Drawing, space: &Space, frozen: &[String], p: Vec2, aperture: f64) -> Vec { let ix = spatial::index(d, space); let probe = Bounds2::new(p, p).expand(aperture); let Some(cands) = candidates(d, space, &ix, &probe.expand(aperture), true, true) else { return Vec::new() }; cands - .filter(|(e, known)| selectable(d, e) && (is_infinite(e) || bounds_of(d, e, *known).expand(aperture).intersects(&probe))) + .filter(|(e, known)| selectable(d, e, frozen) && (is_infinite(e) || bounds_of(d, e, *known).expand(aperture).intersects(&probe))) .filter(|(e, _)| entity_distance(d, e, p, aperture / 4.0) <= aperture) .map(|(e, _)| e.handle) .collect() @@ -253,14 +291,27 @@ fn seg_hits_box(a: Vec2, b: Vec2, bx: &Bounds2) -> bool { /// Window selection (entirely inside) or crossing selection (inside or touching). pub fn select_window(d: &Drawing, space: &Space, bx: Bounds2, crossing: bool) -> Vec { - let ix = spatial::index(d, space); - select_window_with(d, space, &ix, bx, crossing) + select_window_in(d, space, &[], bx, crossing) } -pub(crate) fn select_window_with(d: &Drawing, space: &Space, ix: &Option>, bx: Bounds2, crossing: bool) -> Vec { +/// [`select_window`] through a layout viewport: the objects on the layers in `frozen`, the layers +/// frozen in that viewport, are not drawn there and are not selected. +pub fn select_window_in(d: &Drawing, space: &Space, frozen: &[String], bx: Bounds2, crossing: bool) -> Vec { + let ix = spatial::index(d, space); + select_window_with(d, space, &ix, frozen, bx, crossing) +} + +pub(crate) fn select_window_with( + d: &Drawing, + space: &Space, + ix: &Option>, + frozen: &[String], + bx: Bounds2, + crossing: bool, +) -> Vec { let Some(cands) = candidates(d, space, ix, &bx, crossing, false) else { return Vec::new() }; let tol = window_tol(&bx); - cands.filter(|(e, known)| selectable(d, e) && in_window(d, e, *known, &bx, crossing, tol)).map(|(e, _)| e.handle).collect() + cands.filter(|(e, known)| selectable(d, e, frozen) && in_window(d, e, *known, &bx, crossing, tol)).map(|(e, _)| e.handle).collect() } /// The tessellation tolerance window and crossing tests use for a box. @@ -306,11 +357,23 @@ pub(crate) fn in_window(d: &Drawing, e: &Entity, known: Option, bx: &Bo /// Fence selection: entities crossed by the fence polyline. pub fn select_fence(d: &Drawing, space: &Space, fence: &[Vec2]) -> Vec { - let ix = spatial::index(d, space); - select_fence_with(d, space, &ix, fence) + select_fence_in(d, space, &[], fence) } -pub(crate) fn select_fence_with(d: &Drawing, space: &Space, ix: &Option>, fence: &[Vec2]) -> Vec { +/// [`select_fence`] through a layout viewport that freezes the layers in `frozen` +/// ([`select_window_in`]). +pub fn select_fence_in(d: &Drawing, space: &Space, frozen: &[String], fence: &[Vec2]) -> Vec { + let ix = spatial::index(d, space); + select_fence_with(d, space, &ix, frozen, fence) +} + +pub(crate) fn select_fence_with( + d: &Drawing, + space: &Space, + ix: &Option>, + frozen: &[String], + fence: &[Vec2], +) -> Vec { let fb = Bounds2::from_points(fence.iter().copied()); let tol = (fb.width() + fb.height()).max(1e-9) / 2000.0; let probe = fb.expand(tol); @@ -318,7 +381,7 @@ pub(crate) fn select_fence_with(d: &Drawing, space: &Space, ix: &Option Vec { + select_polygon_in(d, space, &[], poly, crossing) +} + +/// [`select_polygon`] through a layout viewport that freezes the layers in `frozen` +/// ([`select_window_in`]). +pub fn select_polygon_in(d: &Drawing, space: &Space, frozen: &[String], poly: &[Vec2], crossing: bool) -> Vec { let (Some(first), true) = (poly.first(), poly.len() >= 3) else { return Vec::new() }; let ix = spatial::index(d, space); let pb = Bounds2::from_points(poly.iter().copied()); @@ -349,7 +418,7 @@ pub fn select_polygon(d: &Drawing, space: &Space, poly: &[Vec2], crossing: bool) let mut out = Vec::new(); for (e, known) in cands { let infinite = is_infinite(e); - if !selectable(d, e) || (infinite && !crossing) { + if !selectable(d, e, frozen) || (infinite && !crossing) { continue; } let eb = bounds_of(d, e, known); @@ -378,9 +447,15 @@ pub fn select_polygon(d: &Drawing, space: &Space, poly: &[Vec2], crossing: bool) /// The visible objects in `space` of the group called `name` (any case), or `None` when the /// drawing has no such group. pub fn select_group(d: &Drawing, space: &Space, name: &str) -> Option> { + select_group_in(d, space, &[], name) +} + +/// [`select_group`] through a layout viewport that freezes the layers in `frozen`: the group's +/// objects on those layers are left out. +pub fn select_group_in(d: &Drawing, space: &Space, frozen: &[String], name: &str) -> Option> { let g = d.groups.iter().find(|g| g.name.eq_ignore_ascii_case(name.trim()))?; let store = d.space(space)?; - Some(g.members.iter().copied().filter(|h| store.get(*h).is_some_and(|e| d.is_visible(e))).collect()) + Some(g.members.iter().copied().filter(|h| store.get(*h).is_some_and(|e| selectable(d, e, frozen))).collect()) } /// A selection mode typed at "Select objects", collecting its points before it selects. @@ -454,14 +529,19 @@ impl SelectMode { } /// The objects the mode selects, or `None` while it has too few points. pub fn select(&self, d: &Drawing, space: &Space) -> Option> { + self.select_in(d, space, &[]) + } + /// [`SelectMode::select`] through a layout viewport: the objects on the layers in `frozen`, + /// the layers frozen in that viewport, are not drawn there and are not selected. + pub fn select_in(&self, d: &Drawing, space: &Space, frozen: &[String]) -> Option> { match (self.kind, self.pts.as_slice()) { (SelectKind::Window | SelectKind::Crossing, [a, b, ..]) => { - Some(select_window(d, space, Bounds2::new(*a, *b), self.kind == SelectKind::Crossing)) + Some(select_window_in(d, space, frozen, Bounds2::new(*a, *b), self.kind == SelectKind::Crossing)) } - (SelectKind::Box, [a, b, ..]) => Some(select_window(d, space, Bounds2::new(*a, *b), b.x < a.x)), - (SelectKind::Fence, pts) if pts.len() >= 2 => Some(select_fence(d, space, pts)), + (SelectKind::Box, [a, b, ..]) => Some(select_window_in(d, space, frozen, Bounds2::new(*a, *b), b.x < a.x)), + (SelectKind::Fence, pts) if pts.len() >= 2 => Some(select_fence_in(d, space, frozen, pts)), (SelectKind::WPolygon | SelectKind::CPolygon, pts) if pts.len() >= 3 => { - Some(select_polygon(d, space, pts, self.kind == SelectKind::CPolygon)) + Some(select_polygon_in(d, space, frozen, pts, self.kind == SelectKind::CPolygon)) } _ => None, } diff --git a/crates/engine/src/session/interactive.rs b/crates/engine/src/session/interactive.rs index 273ce0890..f66ed8b8b 100644 --- a/crates/engine/src/session/interactive.rs +++ b/crates/engine/src/session/interactive.rs @@ -202,10 +202,10 @@ impl Session { let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5; if let Some(pw) = self.pending_window.take() { let crossing = self.window_is_crossing(pw.corner, p); - let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing); + let hs = select::select_window_in(self.doc()?, &space, self.viewport_frozen(), Bounds2::new(pw.corner, p), crossing); return Ok(Some(Input::Pick(cmd::groups::expand(self, hs)))); } - match select::pick(self.doc()?, &space, p, ap) { + match select::pick_in(self.doc()?, &space, self.viewport_frozen(), p, ap) { Some(h) => Ok(Some(Input::Pick(cmd::groups::expand(self, vec![h])))), None => { self.pending_window = Some(PendingWindow { corner: p, during_command: true }); @@ -217,10 +217,14 @@ impl Session { let tl = t.trim().to_ascii_lowercase(); let d = self.doc()?; let store = d.space(&space); + let frozen = self.viewport_frozen(); let picked = match tl.as_str() { - "all" => store.map(|s| s.iter().filter(|e| d.is_visible(e)).map(|e| e.handle).collect()), - "l" | "last" => store.and_then(|s| s.last()).map(|e| vec![e.handle]), - "p" | "previous" => Some(self.state()?.previous_selection.clone()), + "all" => store.map(|s| s.iter().filter(|e| select::selectable(d, e, frozen)).map(|e| e.handle).collect()), + "l" | "last" => store.and_then(|s| select::last_in(s, frozen)).map(|h| vec![h]), + "p" | "previous" => { + let st = self.state()?; + Some(st.drawn_in_viewport(&st.previous_selection)) + } _ => None, }; match picked { @@ -241,8 +245,9 @@ impl Session { fn select_mode_input(&mut self, input: Input) -> Result> { let Some(mut mode) = self.select_mode.take() else { return Ok(Some(input)) }; if mode.kind == select::SelectKind::Group { + let space = self.space(); return match input { - Input::Text(name) | Input::Keyword(name) => match select::select_group(self.doc()?, &self.space(), &name) { + Input::Text(name) | Input::Keyword(name) => match select::select_group_in(self.doc()?, &space, self.viewport_frozen(), &name) { Some(hs) => Ok(Some(Input::Pick(hs))), None => { self.echo(format!("No group named \"{}\".", name.trim())); @@ -262,14 +267,14 @@ impl Session { match input { Input::Point(p) => { if mode.push(p) { - return Ok(mode.select(self.doc()?, &self.space()).map(Input::Pick)); + return Ok(mode.select_in(self.doc()?, &self.space(), self.viewport_frozen()).map(Input::Pick)); } } Input::Keyword(k) if k == "Undo" => { mode.pts.pop(); } // Enter ends a fence or polygon; with too few points the mode is dropped. - Input::Enter => return Ok(mode.select(self.doc()?, &self.space()).map(Input::Pick)), + Input::Enter => return Ok(mode.select_in(self.doc()?, &self.space(), self.viewport_frozen()).map(Input::Pick)), Input::Cancel | Input::Pick(_) => return Ok(Some(input)), _ => self.echo("Invalid point."), } diff --git a/crates/engine/src/session/picking.rs b/crates/engine/src/session/picking.rs index db7a55f63..3ade47c76 100644 --- a/crates/engine/src/session/picking.rs +++ b/crates/engine/src/session/picking.rs @@ -32,9 +32,9 @@ impl Session { let pickadd = self.settings.pickadd; if let Some(pw) = self.pending_window.take() { let crossing = self.window_is_crossing(pw.corner, p); - let hs = select::select_window(self.doc()?, &space, Bounds2::new(pw.corner, p), crossing); + let hs = select::select_window_in(self.doc()?, &space, self.viewport_frozen(), Bounds2::new(pw.corner, p), crossing); let hs = cmd::groups::expand(self, hs); - let mut sel = if pickadd || shift { self.selection() } else { Vec::new() }; + let mut sel = if pickadd || shift { self.stored_selection() } else { Vec::new() }; if shift && pickadd { sel.retain(|h| !hs.contains(h)); } else { @@ -44,7 +44,7 @@ impl Session { return Ok(()); } let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5; - match select::pick(self.doc()?, &space, p, ap) { + match select::pick_in(self.doc()?, &space, self.viewport_frozen(), p, ap) { Some(h) => self.idle_pick(h, shift), None => self.pending_window = Some(PendingWindow { corner: p, during_command: false }), } @@ -56,7 +56,7 @@ impl Session { let pickadd = self.settings.pickadd; // With group selection the object's selectable groups come (or go) with it. let hs = cmd::groups::expand(self, vec![h]); - let mut sel = if pickadd || shift { self.selection() } else { Vec::new() }; + let mut sel = if pickadd || shift { self.stored_selection() } else { Vec::new() }; let had = sel.contains(&h); if shift && (pickadd || had) { sel.retain(|x| !hs.contains(x)); @@ -93,7 +93,7 @@ impl Session { return Vec::new(); } let ap = self.pixel_size() * self.settings.pickbox.max(1.0) * 1.5; - self.doc().map(|d| select::pick_all(d, &self.space(), p, ap)).unwrap_or_default() + self.doc().map(|d| select::pick_all_in(d, &self.space(), self.viewport_frozen(), p, ap)).unwrap_or_default() } /// Whether selection cycling marks `p` with its badge (SELECTIONCYCLING 1 or 2): overlapping @@ -155,7 +155,8 @@ impl Session { /// The object a prompt picking one object finds at `p` in `space`: the one named for that /// point ([`Session::input_object`]), which is none when it lies in another space, else the - /// object under `p` within `aperture`. + /// object under `p` within `aperture`. Inside an MSPACE viewport a pick in model space finds + /// what that viewport draws: not the objects on the layers frozen in it. pub fn pick_object(&self, space: &Space, p: Vec2, aperture: f64) -> Result> { let d = self.doc()?; if let Some((h, q)) = self.pick_hint @@ -163,7 +164,9 @@ impl Session { { return Ok((d.space_of(h).as_ref() == Some(space)).then_some(h)); } - Ok(select::pick(d, space, p, aperture)) + // The viewport shows model space only: its frozen layers hide nothing on the sheet. + let frozen = if *space == Space::Model { self.viewport_frozen() } else { &[] }; + Ok(select::pick_in(d, space, frozen, p, aperture)) } } diff --git a/crates/engine/src/spatial.rs b/crates/engine/src/spatial.rs index 6740707c0..10888f5cf 100644 --- a/crates/engine/src/spatial.rs +++ b/crates/engine/src/spatial.rs @@ -424,8 +424,8 @@ mod tests { for k in 0..400 { let p = Vec2::new(r.r(-5.0, 105.0), r.r(-5.0, 105.0)); let ap = [0.05, 0.3, 1.5][k % 3]; - let a = select::pick_with(&d, &Space::Model, &ix, p, ap); - let b = select::pick_with(&d, &Space::Model, &None, p, ap); + let a = select::pick_with(&d, &Space::Model, &ix, &[], p, ap); + let b = select::pick_with(&d, &Space::Model, &None, &[], p, ap); assert_eq!(a, b, "seed {seed} p {p:?} ap {ap}"); hits += usize::from(a.is_some()); } @@ -444,12 +444,15 @@ mod tests { let b = a + Vec2::new(r.r(-40.0, 40.0), r.r(-40.0, 40.0)); let bx = Bounds2::new(a, b); for crossing in [false, true] { - let x = select::select_window_with(&d, &Space::Model, &ix, bx, crossing); - let y = select::select_window_with(&d, &Space::Model, &None, bx, crossing); + let x = select::select_window_with(&d, &Space::Model, &ix, &[], bx, crossing); + let y = select::select_window_with(&d, &Space::Model, &None, &[], bx, crossing); assert_eq!(x, y, "seed {seed} box {bx:?} crossing {crossing}"); } let fence: Vec = (0..(2 + k % 3)).map(|_| Vec2::new(r.r(0.0, 100.0), r.r(0.0, 100.0))).collect(); - assert_eq!(select::select_fence_with(&d, &Space::Model, &ix, &fence), select::select_fence_with(&d, &Space::Model, &None, &fence)); + assert_eq!( + select::select_fence_with(&d, &Space::Model, &ix, &[], &fence), + select::select_fence_with(&d, &Space::Model, &None, &[], &fence) + ); } } } @@ -484,10 +487,13 @@ mod tests { for (p, ap) in [(Vec2::new(f64::NAN, 1.0), 1.0), (Vec2::new(1.0, 1.0), f64::NAN), (Vec2::new(f64::INFINITY, 0.0), 1.0), (Vec2::new(50.0, 50.0), 1e300)] { - assert_eq!(select::pick_with(&d, &Space::Model, &ix, p, ap), select::pick_with(&d, &Space::Model, &None, p, ap)); + assert_eq!(select::pick_with(&d, &Space::Model, &ix, &[], p, ap), select::pick_with(&d, &Space::Model, &None, &[], p, ap)); } let bx = Bounds2 { min: Vec2::new(f64::NEG_INFINITY, 0.0), max: Vec2::new(f64::INFINITY, 50.0) }; - assert_eq!(select::select_window_with(&d, &Space::Model, &ix, bx, true), select::select_window_with(&d, &Space::Model, &None, bx, true)); + assert_eq!( + select::select_window_with(&d, &Space::Model, &ix, &[], bx, true), + select::select_window_with(&d, &Space::Model, &None, &[], bx, true) + ); } #[test] diff --git a/crates/engine/tests/it/main.rs b/crates/engine/tests/it/main.rs index fc7edd4a3..2eb2a4df0 100644 --- a/crates/engine/tests/it/main.rs +++ b/crates/engine/tests/it/main.rs @@ -166,6 +166,7 @@ mod trim_extend_options; mod undo_count; mod undo_layout_tab; mod viewport_clip; +mod viewport_frozen_selection; mod vplayer_prompts; mod vports; mod wipeout_grips; diff --git a/crates/engine/tests/it/viewport_frozen_selection.rs b/crates/engine/tests/it/viewport_frozen_selection.rs new file mode 100644 index 000000000..317e1bc6e --- /dev/null +++ b/crates/engine/tests/it/viewport_frozen_selection.rs @@ -0,0 +1,783 @@ +//! Inside an MSPACE viewport an object on a layer frozen in that viewport (VPLAYER, "VP Freeze") +//! is not drawn there, so the selections made through that viewport leave it out: picks, windows, +//! the typed selection modes, the commands that select for themselves, and, for an object that is +//! already selected, its grips and the commands that start from the selection. In a viewport that +//! does not freeze the layer, in paper space and on the Model tab everything is as before. + +use cadcraft_engine::Session; +use cadcraft_engine::doc::{EntityKind, Handle, Space}; +use cadcraft_engine::geom::Vec2; +use serde_json::{Value, json}; + +/// Draws a line from `a` to `b` on the current layer and returns its handle. +fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle { + let r = s.execute("line", &json!({ "points": [a, b] })).unwrap(); + Handle::parse_hex(r["handles"][0].as_str().unwrap()).unwrap() +} + +/// Puts `h` on the layer "Hidden", which [`viewports`] freezes in its first viewport. +fn hide(s: &mut Session, h: Handle) { + if s.doc().unwrap().layer("Hidden").is_none() { + s.execute("layer.new", &json!({ "name": "Hidden" })).unwrap(); + } + s.execute("properties.set", &json!({ "handles": [h.hex()], "layer": "Hidden" })).unwrap(); + assert_eq!(s.doc().unwrap().entity(h).unwrap().common.layer, "Hidden"); +} + +/// Two viewports on Layout1: the first freezes the layer "Hidden", the second freezes nothing. +/// The session is left in paper space. +fn viewports(s: &mut Session) -> (String, String) { + if s.doc().unwrap().layer("Hidden").is_none() { + s.execute("layer.new", &json!({ "name": "Hidden" })).unwrap(); + } + s.execute("layout.set", &json!({ "name": "Layout1" })).unwrap(); + let r = s.execute("mview", &json!({ "count": 2, "p1": [20, 20], "p2": [220, 120] })).unwrap(); + let (a, b) = (r["viewports"][0].as_str().unwrap().to_string(), r["viewports"][1].as_str().unwrap().to_string()); + s.execute("vplayer", &json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + (a, b) +} + +/// Makes `viewport` the active MSPACE viewport. +fn enter(s: &mut Session, viewport: &str) { + s.execute("mspace", &json!({ "handle": viewport })).unwrap(); + assert_eq!(s.space(), Space::Model, "inside a viewport the edit space is model space"); +} + +/// What most tests draw: `shown` on layer 0 and, drawn after it and so on top of it, `hidden` on +/// the layer "Hidden", both from (0, 0) to (10, 0); and the two viewports of [`viewports`]. +struct Sheet { + s: Session, + shown: Handle, + hidden: Handle, + /// The viewport that freezes "Hidden". + a: String, + /// The viewport that freezes nothing. + b: String, +} + +/// The drawing of [`Sheet`], in paper space. +fn sheet() -> Sheet { + let mut s = Session::new(); + let shown = line(&mut s, [0.0, 0.0], [10.0, 0.0]); + let hidden = line(&mut s, [0.0, 0.0], [10.0, 0.0]); + hide(&mut s, hidden); + assert_eq!(s.doc().unwrap().entity(shown).unwrap().common.layer, "0"); + let (a, b) = viewports(&mut s); + Sheet { s, shown, hidden, a, b } +} + +/// The two ends of the line `h`. +fn ends(s: &Session, h: Handle) -> (Vec2, Vec2) { + match &s.doc().unwrap().entity(h).unwrap().kind { + EntityKind::Line(l) => (l.a.xy(), l.b.xy()), + k => panic!("not a line: {k:?}"), + } +} + +/// Whether the line `h` still runs from (0, 0) to (10, 0). +fn untouched(s: &Session, h: Handle) -> bool { + let (a, b) = ends(s, h); + a.near(Vec2::new(0.0, 0.0), 1e-9) && b.near(Vec2::new(10.0, 0.0), 1e-9) +} + +/// Whether the drawing still has the object `h`. +fn exists(s: &Session, h: Handle) -> bool { + s.doc().unwrap().entity(h).is_some() +} + +/// Every selected object, in handle order: the stored selection, which also holds the objects +/// the active viewport does not draw ([`Session::selection`] leaves those out). +fn selected(s: &Session) -> Vec { + let mut v = s.state().unwrap().selection.clone(); + v.sort(); + v +} + +/// Whether the line `h` was erased or no longer runs from (0, 0) to (10, 0). +fn edited(s: &Session, h: Handle) -> bool { + !exists(s, h) || !untouched(s, h) +} + +/// The index of the grip of `h` at the origin. +fn origin_grip(s: &Session, h: Handle) -> usize { + s.grips_of(h).unwrap().iter().position(|g| g.near(Vec2::new(0.0, 0.0), 1e-9)).unwrap() +} + +/// `hs` in handle order. +fn sorted(mut hs: Vec) -> Vec { + hs.sort(); + hs +} + +/// Runs `text` as a script and ends whatever prompt it leaves open with Enter. +fn run(s: &mut Session, text: &str) { + s.script(text).unwrap(); + for _ in 0..4 { + if s.running.is_none() { + break; + } + s.cmdline("").unwrap(); + } + assert!(s.running.is_none(), "`{text}` left a prompt open: {}", s.prompt_text()); +} + +/// The JSON `select` command replaces the selection with what `how` finds. +fn select(s: &mut Session, how: Value) -> Vec { + s.set_selection(Vec::new()); + s.execute("select", &how).unwrap(); + selected(s) +} + +/// A pick takes the topmost object the viewport draws: the frozen line lies on top of the other +/// one, and a pick at the same point finds the line under it. Where the layer is not frozen the +/// pick finds the line on top, as it always did. +#[test] +fn a_pick_finds_the_topmost_object_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + let at = json!({ "at": [5, 0], "aperture": 0.5 }); + enter(&mut s, &a); + assert_eq!(select(&mut s, at.clone()), [shown], "the viewport freezes the layer of the line on top"); + enter(&mut s, &b); + assert_eq!(select(&mut s, at.clone()), [hidden], "this viewport draws both: the one on top is picked"); + s.execute("layout.set", &json!({ "name": "Model" })).unwrap(); + assert_eq!(select(&mut s, at), [hidden], "the Model tab draws both"); +} + +/// Window, crossing and fence selection through the viewport leave the frozen line out, and take +/// both lines through the viewport that draws both. +#[test] +fn a_window_a_crossing_and_a_fence_leave_out_what_the_viewport_does_not_draw() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + let ways = + [json!({ "window": [[-1, -1], [11, 1]] }), json!({ "window": [[4, -1], [6, 1]], "crossing": true }), json!({ "fence": [[5, -1], [5, 1]] })]; + for how in &ways { + enter(&mut s, &a); + assert_eq!(select(&mut s, how.clone()), [shown], "{how}"); + enter(&mut s, &b); + assert_eq!(select(&mut s, how.clone()), sorted(vec![shown, hidden]), "{how}"); + } +} + +/// Clicks with no command running: a click on the two lines selects the one the viewport draws, +/// and a window dragged around them takes only that one. +#[test] +fn idle_clicks_and_windows_select_what_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.idle_click(Vec2::new(5.0, 0.0), false).unwrap(); + assert_eq!(selected(&s), [shown]); + s.set_selection(Vec::new()); + // A click on nothing opens a window; the next click closes it (left to right: a window). + s.idle_click(Vec2::new(-1.0, -1.0), false).unwrap(); + assert!(s.pending_window.is_some(), "the first click must be on nothing"); + s.idle_click(Vec2::new(11.0, 1.0), false).unwrap(); + assert_eq!(selected(&s), [shown]); + + enter(&mut s, &b); + s.idle_click(Vec2::new(5.0, 0.0), false).unwrap(); + assert_eq!(selected(&s), [hidden], "this viewport draws both: the one on top is picked"); + s.set_selection(Vec::new()); + s.idle_click(Vec2::new(-1.0, -1.0), false).unwrap(); + s.idle_click(Vec2::new(11.0, 1.0), false).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden])); +} + +/// Selection cycling lists the objects under the pick box that the viewport draws. +#[test] +fn selection_cycling_lists_what_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + assert_eq!(s.pick_candidates(Vec2::new(5.0, 0.0)), [shown]); + enter(&mut s, &b); + assert_eq!(s.pick_candidates(Vec2::new(5.0, 0.0)), [hidden, shown], "topmost first"); +} + +/// Every way of answering "Select objects" leaves the frozen line out: ERASE through the +/// viewport that freezes its layer erases the other line only, and through the other viewport +/// both. +#[test] +fn the_answers_to_select_objects_leave_out_what_the_viewport_does_not_draw() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.execute("group", &json!({ "name": "PAIR", "handles": [shown.hex(), hidden.hex()] })).unwrap(); + // Group selection off: a pick takes the object alone, so each answer is tested by itself. + s.settings.pickstyle = 0; + let answers = [ + "5,0", + "-1,-1 11,1", + "ALL", + "W -1,-1 11,1", + "C 6,1 4,-1", + "BOX 6,1 4,-1", + "F 5,-1 5,1\n", + "WP -1,-1 11,-1 11,1 -1,1\n", + "CP 4,-1 6,-1 5,1\n", + "G PAIR", + ]; + for answer in answers { + enter(&mut s, &a); + run(&mut s, &format!("ERASE {answer}\n")); + assert!(!exists(&s, shown), "`{answer}` must erase the line the viewport draws"); + assert!(exists(&s, hidden), "`{answer}` erased a line the viewport does not draw"); + s.execute("undo", &json!({})).unwrap(); + assert!(exists(&s, shown) && exists(&s, hidden)); + + enter(&mut s, &b); + run(&mut s, &format!("ERASE {answer}\n")); + // A pick takes one object, the one on top; every other answer takes both. + assert_eq!((exists(&s, shown), exists(&s, hidden)), (answer == "5,0", false), "`{answer}` where both are drawn"); + s.execute("undo", &json!({})).unwrap(); + assert!(exists(&s, shown) && exists(&s, hidden)); + } +} + +/// With group selection on, a pick brings the members of its group that the viewport draws. +#[test] +fn a_pick_brings_the_group_members_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.execute("group", &json!({ "name": "PAIR", "handles": [shown.hex(), hidden.hex()] })).unwrap(); + s.settings.pickstyle = 1; + s.set_selection(Vec::new()); + s.idle_click(Vec2::new(5.0, 0.0), false).unwrap(); + assert_eq!(selected(&s), [shown]); + enter(&mut s, &b); + s.idle_click(Vec2::new(5.0, 0.0), false).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden])); +} + +/// Select All and Select Similar take what the viewport draws. +#[test] +fn select_all_and_select_similar_take_what_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + // Mode 0: any object of the same type is similar, whatever its layer. + let similar = json!({ "handles": [shown.hex()], "mode": 0 }); + enter(&mut s, &a); + s.execute("selectall", &json!({})).unwrap(); + assert_eq!(selected(&s), [shown]); + s.execute("selectsimilar", &similar).unwrap(); + assert_eq!(selected(&s), [shown]); + enter(&mut s, &b); + s.execute("selectall", &json!({})).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden])); + s.execute("selectsimilar", &similar).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden])); +} + +/// STRETCH selects for itself: its crossing window, polygon and fence, called with JSON or +/// typed, and its typed All, Last and Previous, move the line the viewport draws and leave the +/// frozen one where it was. +#[test] +fn stretch_moves_what_the_viewport_draws() { + let calls = [ + json!({ "window": [[9, -1], [11, 1]], "delta": [0, 5] }), + json!({ "polygon": [[9, -1], [11, -1], [11, 1], [9, 1]], "delta": [0, 5] }), + json!({ "fence": [[5, -1], [5, 1]], "delta": [0, 5] }), + ]; + for call in &calls { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.execute("stretch", call).unwrap(); + assert!(!untouched(&s, shown), "{call}: the line the viewport draws must move"); + assert!(untouched(&s, hidden), "{call}: a line the viewport does not draw moved: {:?}", ends(&s, hidden)); + enter(&mut s, &b); + s.execute("stretch", call).unwrap(); + assert!(!untouched(&s, hidden), "{call}: where both are drawn both move"); + } + // Typed: a crossing window, named and implied, All, a pick, Last, and Previous (both lines). + for objects in ["C 11,1 9,-1", "11,1 9,-1", "ALL", "5,0", "L", "P"] { + let typed = format!("STRETCH {objects}\n\n0,0 0,5\n"); + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.remember_selection(&[shown, hidden]); + run(&mut s, &typed); + assert!(!untouched(&s, shown), "{typed:?}: the line the viewport draws must move"); + assert!(untouched(&s, hidden), "{typed:?}: a line the viewport does not draw moved: {:?}", ends(&s, hidden)); + enter(&mut s, &b); + s.remember_selection(&[shown, hidden]); + run(&mut s, &typed); + assert!(!untouched(&s, hidden), "{typed:?}: where both are drawn the one on top moves"); + } +} + +/// A multiline whose control vertex is inside STRETCH's crossing window is stretched although +/// the window misses its drawn lines, but not when the viewport does not draw it. +#[test] +fn stretch_leaves_a_multiline_the_viewport_does_not_draw() { + /// The control vertices of the multiline `h`. + fn vertices(s: &Session, h: Handle) -> Vec { + match &s.doc().unwrap().entity(h).unwrap().kind { + EntityKind::MLine(m) => m.vertices.iter().map(|v| v.p.xy()).collect(), + k => panic!("not a multiline: {k:?}"), + } + } + let mut s = Session::new(); + // Zero justification at scale 2: the element lines run one unit either side of the vertices. + let r = s.execute("mline", &json!({ "points": [[0, 0], [10, 0]], "scale": 2, "justification": "zero" })).unwrap(); + let mline = Handle::parse_hex(r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap()).unwrap(); + hide(&mut s, mline); + let (a, b) = viewports(&mut s); + let call = json!({ "window": [[9.9, -0.1], [10.1, 0.1]], "delta": [0, 5] }); + enter(&mut s, &a); + s.execute("stretch", &call).unwrap(); + assert!(vertices(&s, mline)[1].near(Vec2::new(10.0, 0.0), 1e-9), "a multiline the viewport does not draw was stretched"); + enter(&mut s, &b); + s.execute("stretch", &call).unwrap(); + assert!(vertices(&s, mline)[1].near(Vec2::new(10.0, 5.0), 1e-9), "{:?}", vertices(&s, mline)); +} + +/// TRIM's fence and crossing window trim the line the viewport draws and leave the frozen one. +#[test] +fn trim_by_fence_and_crossing_leaves_what_the_viewport_does_not_draw() { + for call in [json!({ "fence": [[8, -1], [8, 1]] }), json!({ "crossing": [[7.5, -1], [8.5, 1]] })] { + let mut s = Session::new(); + let shown = line(&mut s, [0.0, 0.0], [10.0, 0.0]); + let hidden = line(&mut s, [0.0, 0.0], [10.0, 0.0]); + // The cutting edge, on a layer every viewport draws. + line(&mut s, [5.0, -5.0], [5.0, 5.0]); + hide(&mut s, hidden); + let (a, b) = viewports(&mut s); + enter(&mut s, &a); + s.execute("trim", &call).unwrap(); + assert!(!untouched(&s, shown), "{call}: the line the viewport draws must be trimmed"); + assert!(untouched(&s, hidden), "{call}: a line the viewport does not draw was trimmed: {:?}", ends(&s, hidden)); + enter(&mut s, &b); + s.execute("trim", &call).unwrap(); + assert!(!untouched(&s, hidden), "{call}: where both are drawn both are trimmed"); + } +} + +/// A prompt that picks one object (BREAK's "Select object") finds the one the viewport draws. +#[test] +fn a_prompt_for_one_object_picks_what_the_viewport_draws() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + run(&mut s, "BREAK 4,0 6,0\n"); + assert!(untouched(&s, hidden), "a line the viewport does not draw was broken: {:?}", ends(&s, hidden)); + assert!(!untouched(&s, shown), "the line the viewport draws must be broken"); + enter(&mut s, &b); + run(&mut s, "BREAK 4,0 6,0\n"); + assert!(!untouched(&s, hidden), "where both are drawn the one on top is broken"); +} + +/// LEADER's Copy option picks the text to copy: at a point where two texts lie, the one the +/// viewport draws. +#[test] +fn leader_copies_the_text_the_viewport_draws() { + /// The contents of the multiline texts in model space: LEADER's copies. + fn copies(s: &Session) -> Vec { + s.doc().unwrap().model.iter().filter_map(|e| if let EntityKind::MText(m) = &e.kind { Some(m.contents.clone()) } else { None }).collect() + } + let mut s = Session::new(); + for text in ["SHOWN", "HIDDEN"] { + s.execute("text", &json!({ "at": [0, 0], "text": text, "height": 2.5 })).unwrap(); + } + // The text drawn last lies on top. + let hidden = *s.doc().unwrap().model.handles().last().unwrap(); + hide(&mut s, hidden); + let (a, b) = viewports(&mut s); + let leader = "(command \"_.LEADER\" '(20.0 20.0) '(30.0 25.0) \"\" \"\" \"_C\" '(1.0 1.0))"; + enter(&mut s, &a); + s.cmdline(leader).unwrap(); + assert!(s.running.is_none(), "{}", s.prompt_text()); + assert_eq!(copies(&s), ["SHOWN"], "the viewport freezes the layer of the text on top"); + s.execute("undo", &json!({})).unwrap(); + assert!(copies(&s).is_empty()); + enter(&mut s, &b); + s.cmdline(leader).unwrap(); + assert!(s.running.is_none(), "{}", s.prompt_text()); + assert_eq!(copies(&s), ["HIDDEN"], "this viewport draws both: the one on top is picked"); +} + +/// AutoLISP selects through the viewport too: `ssget` with a window, a crossing window, a fence, +/// a polygon, a crossing polygon or a point leaves the frozen line out, and `entsel` picks the +/// line the viewport draws. The sets made earlier (the implied selection, `ssgetfirst`, Previous) +/// come without the frozen line, and Last is the last object the viewport draws. +#[test] +fn lisp_selects_what_the_viewport_draws() { + use cadcraft_engine::lisp::value::Value as Lisp; + /// The objects of the selection set that `code` returns (none for nil), in handle order. + fn set(s: &mut Session, code: &str) -> Vec { + match s.lisp_eval(code, false, true, Vec::new()).unwrap() { + Some(Ok(Lisp::PickSet(set))) => sorted(set.items.lock().unwrap().clone()), + Some(Ok(Lisp::Nil)) => Vec::new(), + other => panic!("`{code}` returned {other:?}"), + } + } + /// The object `entsel` returns for a pick at (5, 0). + fn entsel(s: &mut Session) -> Handle { + s.cmdline("(setq picked (car (entsel)))").unwrap(); + s.input(cadcraft_engine::Input::Point(Vec2::new(5.0, 0.0))).unwrap(); + match s.lisp_var("picked") { + Lisp::Ename(h) => h, + other => panic!("entsel returned {other:?}: {}", s.prompt_text()), + } + } + let Sheet { mut s, shown, hidden, a, b } = sheet(); + let areas = [ + "(ssget \"W\" '(-1 -1) '(11 1))", + "(ssget \"C\" '(4 -1) '(6 1))", + "(ssget \"F\" '((5 -1) (5 1)))", + "(ssget \"WP\" '((-1 -1) (11 -1) (11 1) (-1 1)))", + "(ssget \"CP\" '((4 -1) (6 -1) (5 1)))", + ]; + enter(&mut s, &a); + for code in areas { + assert_eq!(set(&mut s, code), [shown], "{code}"); + } + assert_eq!(set(&mut s, "(ssget '(5 0))"), [shown], "a point picks the object the viewport draws"); + assert_eq!(entsel(&mut s), shown); + enter(&mut s, &b); + for code in areas { + assert_eq!(set(&mut s, code), sorted(vec![shown, hidden]), "{code}"); + } + assert_eq!(set(&mut s, "(ssget '(5 0))"), [hidden], "this viewport draws both: the one on top is picked"); + assert_eq!(entsel(&mut s), hidden); + + let earlier = ["(ssget \"I\")", "(ssget)", "(cadr (ssgetfirst))", "(ssget \"P\")"]; + for (viewport, expected) in [(&a, vec![shown]), (&b, sorted(vec![shown, hidden]))] { + enter(&mut s, viewport); + for code in earlier { + s.set_selection(vec![shown, hidden]); + s.remember_selection(&[shown, hidden]); + assert_eq!(set(&mut s, code), expected, "{code}"); + } + } + // Last: of two lines made after everything else, the later one is on the layer the first + // viewport freezes, so through that viewport Last is the earlier one. + s.set_selection(Vec::new()); + enter(&mut s, &b); + let drawn = line(&mut s, [0.0, 2.0], [10.0, 2.0]); + let last = line(&mut s, [0.0, 3.0], [10.0, 3.0]); + hide(&mut s, last); + assert_eq!(set(&mut s, "(ssget \"L\")"), [last]); + enter(&mut s, &a); + assert_eq!(set(&mut s, "(ssget \"L\")"), [drawn], "Last must pass over an object the viewport does not draw"); +} + +/// The grips of a selected object the viewport does not draw take no part in a grip edit: a +/// shared grip stretches only the line that is drawn. Through the other viewport both stretch. +#[test] +fn a_selected_line_the_viewport_does_not_draw_is_not_stretched_with_a_shared_grip() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, &a); + s.set_selection(vec![shown, hidden]); + let i = origin_grip(&s, shown); + s.start_grip_edit(&[(shown, i)]).unwrap(); + s.cmdline("3,4").unwrap(); + assert!(s.running.is_none(), "{}", s.prompt_text()); + assert!(ends(&s, shown).0.near(Vec2::new(3.0, 4.0), 1e-9), "{:?}", ends(&s, shown)); + assert!(untouched(&s, hidden), "a line the viewport does not draw moved: {:?}", ends(&s, hidden)); + // Its own grip starts no edit there. + let before = s.state().unwrap().doc.clone(); + let j = origin_grip(&s, hidden); + assert!(s.start_grip_edit(&[(hidden, j)]).is_err()); + assert!(s.running.is_none()); + assert!(std::sync::Arc::ptr_eq(&before, &s.state().unwrap().doc), "nothing may change"); + + s.execute("undo", &json!({})).unwrap(); + enter(&mut s, &b); + s.set_selection(vec![shown, hidden]); + s.start_grip_edit(&[(shown, i)]).unwrap(); + s.cmdline("3,4").unwrap(); + assert!(s.running.is_none(), "{}", s.prompt_text()); + assert!(ends(&s, shown).0.near(Vec2::new(3.0, 4.0), 1e-9), "{:?}", ends(&s, shown)); + assert!(ends(&s, hidden).0.near(Vec2::new(3.0, 4.0), 1e-9), "where both are drawn both stretch: {:?}", ends(&s, hidden)); +} + +/// A layer frozen in the viewport while its object is selected: from then on the object's grips +/// are not there, and thawing the layer in the viewport brings them back. +#[test] +fn freezing_a_layer_in_the_viewport_removes_the_grips_of_a_selected_object() { + let Sheet { mut s, hidden, b, .. } = sheet(); + enter(&mut s, &b); + s.set_selection(vec![hidden]); + // The typed GRIP command finds a grip of the selected line at its start. + let grip_there = |s: &mut Session| { + s.cmdline("grip").unwrap(); + s.cmdline("0,0").unwrap(); + let none = s.log.iter().any(|l| l.contains("No grip of a selected object there")); + s.input(cadcraft_engine::Input::Cancel).unwrap(); + s.log.clear(); + !none + }; + assert!(grip_there(&mut s), "the viewport draws the line: its grip is there"); + s.execute("vplayer", &json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + s.set_selection(vec![hidden]); + assert!(!grip_there(&mut s), "the viewport no longer draws the line"); + s.execute("vplayer", &json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + s.set_selection(vec![hidden]); + assert!(grip_there(&mut s), "thawed in the viewport: the grip is back"); +} + +/// What the edited view shows: the frozen layer hides its model-space objects inside that +/// viewport only, and never an object on the sheet. +#[test] +fn only_the_viewport_that_freezes_a_layer_hides_its_model_objects() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + // A line on the sheet, on the layer the first viewport freezes. + let on_sheet = line(&mut s, [1.0, 1.0], [2.0, 1.0]); + hide(&mut s, on_sheet); + assert_eq!(s.doc().unwrap().space_of(on_sheet), Some(Space::Paper("Layout1".into()))); + let shows = |s: &Session, h: Handle| { + let st = s.state().unwrap(); + st.shows(st.doc.entity(h).unwrap()) + }; + assert!(s.viewport_frozen().is_empty(), "paper space: no viewport is active"); + assert!(shows(&s, hidden) && shows(&s, shown) && shows(&s, on_sheet)); + enter(&mut s, &a); + assert_eq!(s.viewport_frozen(), ["Hidden".to_string()]); + assert!(!shows(&s, hidden), "frozen in the active viewport"); + assert!(shows(&s, shown)); + assert!(shows(&s, on_sheet), "the viewport draws model space: its frozen layers hide nothing on the sheet"); + // A prompt that picks one object on the sheet while the viewport is active finds it. + let sheet_space = Space::Paper("Layout1".into()); + assert_eq!(s.pick_object(&sheet_space, Vec2::new(1.5, 1.0), 0.5).unwrap(), Some(on_sheet)); + assert_eq!(s.pick_object(&Space::Model, Vec2::new(5.0, 0.0), 0.5).unwrap(), Some(shown), "in model space the frozen line is left out"); + enter(&mut s, &b); + assert!(s.viewport_frozen().is_empty()); + assert!(shows(&s, hidden)); + // Layer names are not case sensitive: frozen under another spelling, the line is hidden too. + s.execute("vplayer", &json!({ "handles": [b], "freeze": ["HIDDEN"] })).unwrap(); + assert_eq!(s.viewport_frozen(), ["HIDDEN".to_string()]); + assert!(!shows(&s, hidden)); + assert_eq!(select(&mut s, json!({ "at": [5, 0], "aperture": 0.5 })), [shown]); + s.execute("vplayer", &json!({ "handles": [b], "thaw": ["hidden"] })).unwrap(); + assert!(shows(&s, hidden)); + s.execute("layout.set", &json!({ "name": "Model" })).unwrap(); + assert!(s.viewport_frozen().is_empty(), "the Model tab has no layout viewport"); + assert!(shows(&s, hidden)); +} + +/// An object that is selected when its layer is frozen in the active viewport stays selected, but +/// nothing that starts from the selection takes it there: a typed command with the selection +/// made before it (PICKFIRST), a JSON command that names no objects, and Delete. +#[test] +fn a_command_leaves_out_a_selected_object_the_viewport_does_not_draw() { + /// One way of editing the selection. + type Edit = fn(&mut Session); + let edits: [(&str, Edit); 5] = [ + ("typed ERASE", |s: &mut Session| run(s, "ERASE\n")), + ("typed MOVE", |s: &mut Session| run(s, "MOVE 0,0 0,5\n")), + ("JSON erase", |s: &mut Session| drop(s.execute("erase", &json!({})).unwrap())), + ("JSON move", |s: &mut Session| drop(s.execute("move", &json!({ "delta": [0, 5] })).unwrap())), + ("Delete", |s: &mut Session| drop(s.execute("erase.selection", &json!({})).unwrap())), + ]; + for (name, edit) in edits { + // Where both lines are drawn, both are edited. + let Sheet { mut s, shown, hidden, b, .. } = sheet(); + enter(&mut s, &b); + s.set_selection(vec![shown, hidden]); + edit(&mut s); + assert!(edited(&s, shown) && edited(&s, hidden), "{name}: where both are drawn both are edited"); + + // The layer is frozen in the active viewport while both lines are selected. + let Sheet { mut s, shown, hidden, b, .. } = sheet(); + enter(&mut s, &b); + s.set_selection(vec![shown, hidden]); + s.execute("vplayer", &json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden]), "{name}: both lines must still be selected"); + assert_eq!(s.selection(), [shown], "{name}: the selection as the viewport has it"); + edit(&mut s); + assert!(edited(&s, shown), "{name}: the line the viewport draws must be edited"); + assert!(!edited(&s, hidden), "{name}: a line the viewport does not draw was edited: {:?}", ends(&s, hidden)); + } + + // With only that line selected there is nothing to start from. + let Sheet { mut s, hidden, a, b, .. } = sheet(); + enter(&mut s, &a); + s.set_selection(vec![hidden]); + assert!(s.selection().is_empty()); + assert!(s.execute("erase.selection", &json!({})).is_err(), "Delete must find nothing selected"); + s.script("ERASE\n").unwrap(); + assert!(s.running.is_some() && s.prompt_text().contains("Select objects"), "ERASE must ask for objects: {}", s.prompt_text()); + s.input(cadcraft_engine::Input::Cancel).unwrap(); + assert!(!edited(&s, hidden)); + // The line is still selected, and a viewport that draws it has it again. + s.set_selection(vec![hidden]); + s.execute("vplayer", &json!({ "handles": [a], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(s.selection(), [hidden], "thawed in the viewport: selected as before"); + s.execute("vplayer", &json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + assert!(s.selection().is_empty()); + enter(&mut s, &b); + s.set_selection(vec![hidden]); + run(&mut s, "ERASE\n"); + assert!(!exists(&s, hidden), "where the line is drawn the selection made before ERASE is erased"); +} + +/// The Previous and Last options of "Select objects" take what the viewport draws: of the set a +/// command used before, and the last object that is not frozen there. +#[test] +fn previous_and_last_leave_out_what_the_viewport_does_not_draw() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + for option in ["P", "L"] { + enter(&mut s, &a); + s.set_selection(Vec::new()); + s.remember_selection(&[shown, hidden]); + run(&mut s, &format!("ERASE {option}\n")); + assert!(!exists(&s, shown), "`{option}` must erase the line the viewport draws"); + assert!(exists(&s, hidden), "`{option}` erased a line the viewport does not draw"); + s.execute("undo", &json!({})).unwrap(); + assert!(exists(&s, shown) && exists(&s, hidden)); + + enter(&mut s, &b); + s.set_selection(Vec::new()); + s.remember_selection(&[shown, hidden]); + run(&mut s, &format!("ERASE {option}\n")); + // Previous is both lines; Last is the one made last, the line on the layer "Hidden". + assert_eq!((exists(&s, shown), exists(&s, hidden)), (option == "L", false), "`{option}` where both are drawn"); + s.execute("undo", &json!({})).unwrap(); + assert!(exists(&s, shown) && exists(&s, hidden)); + } +} + +/// The JSON grip edits that cover the selection (`grip.stretch` with hot grips, and +/// [`Session::grip_edit`]) drag the grips of the other selected objects on the same point, but +/// not the grip of a selected line the viewport does not draw. +#[test] +fn the_grip_edits_that_cover_the_selection_leave_out_what_the_viewport_does_not_draw() { + use cadcraft_engine::grips::GripMode; + /// Drags grip `i` of the line `h` to (3, 4). + type Edit = fn(&mut Session, Handle, usize); + let edits: [(&str, Edit); 2] = [ + ("grip.stretch", |s: &mut Session, h: Handle, i: usize| { + drop(s.execute("grip.stretch", &json!({ "grips": [[h.hex(), i]], "to": [3, 4] })).unwrap()) + }), + ("grip_edit", |s: &mut Session, h: Handle, i: usize| s.grip_edit(h, i, Vec2::new(3.0, 4.0), GripMode::Stretch).unwrap()), + ]; + for (name, edit) in edits { + for frozen in [true, false] { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + enter(&mut s, if frozen { &a } else { &b }); + s.set_selection(vec![shown, hidden]); + let i = origin_grip(&s, shown); + edit(&mut s, shown, i); + assert!(ends(&s, shown).0.near(Vec2::new(3.0, 4.0), 1e-9), "{name}: {:?}", ends(&s, shown)); + assert_eq!(untouched(&s, hidden), frozen, "{name}, layer frozen in the viewport: {frozen}: {:?}", ends(&s, hidden)); + } + } +} + +/// What the session reports as the selection is the selection as the viewport has it, while +/// every selected object stays in the stored selection. +#[test] +fn the_reported_selection_leaves_out_what_the_viewport_does_not_draw() { + /// The handles in `list`, a JSON array of hex strings, in handle order. + fn handles(list: &Value) -> Vec { + sorted(list.as_array().unwrap().iter().map(|h| Handle::parse_hex(h.as_str().unwrap()).unwrap()).collect()) + } + let Sheet { mut s, shown, hidden, a, b } = sheet(); + for (viewport, expected) in [(&a, vec![shown]), (&b, sorted(vec![shown, hidden]))] { + enter(&mut s, viewport); + s.set_selection(vec![shown, hidden]); + assert_eq!(selected(&s), sorted(vec![shown, hidden]), "both lines are selected"); + assert_eq!(sorted(s.selection()), expected); + assert_eq!(handles(&s.summary()["selection"]), expected); + let inspect = s.execute("drawing.inspect", &json!({})).unwrap(); + assert_eq!(handles(&inspect["selection"]), expected); + } + // A selected object on the sheet is never left out, whatever its layer. + s.execute("pspace", &json!({})).unwrap(); + let on_sheet = line(&mut s, [1.0, 1.0], [2.0, 1.0]); + hide(&mut s, on_sheet); + enter(&mut s, &a); + s.set_selection(vec![shown, hidden, on_sheet]); + assert_eq!(sorted(s.selection()), sorted(vec![shown, on_sheet])); + // Where no viewport is active nothing is left out: in paper space and on the Model tab. + s.execute("pspace", &json!({})).unwrap(); + s.set_selection(vec![shown, hidden, on_sheet]); + assert_eq!(sorted(s.selection()), sorted(vec![shown, hidden, on_sheet]), "paper space"); + s.execute("layout.set", &json!({ "name": "Model" })).unwrap(); + s.set_selection(vec![shown, hidden]); + assert_eq!(sorted(s.selection()), sorted(vec![shown, hidden]), "the Model tab"); +} + +/// Adding to the selection or removing from it inside the viewport keeps a selected object the +/// viewport does not draw: nothing drops it behind the user's back, and it counts again once its +/// layer is thawed there. +#[test] +fn changing_the_selection_keeps_a_selected_object_the_viewport_does_not_draw() { + let Sheet { mut s, shown, hidden, b, .. } = sheet(); + enter(&mut s, &b); + // A third line, on layer 0 like `shown`, away from the other two. + let other = line(&mut s, [0.0, 5.0], [10.0, 5.0]); + // Selects `hidden` where it is drawn, then freezes its layer in the active viewport. + let freeze = |s: &mut Session| { + s.execute("vplayer", &json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + s.set_selection(vec![hidden]); + s.execute("vplayer", &json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(selected(s), [hidden], "the line must still be selected"); + assert!(s.selection().is_empty(), "the viewport does not draw it"); + }; + + // A click adds (PICKADD), Shift+click removes. + freeze(&mut s); + s.idle_click(Vec2::new(5.0, 5.0), false).unwrap(); + assert_eq!(selected(&s), sorted(vec![hidden, other]), "a click dropped the selected line the viewport does not draw"); + assert_eq!(s.selection(), [other]); + s.idle_click(Vec2::new(5.0, 5.0), true).unwrap(); + assert_eq!(selected(&s), [hidden], "Shift+click must remove only the line clicked"); + + // A window adds. + freeze(&mut s); + s.idle_click(Vec2::new(-1.0, 4.0), false).unwrap(); + assert!(s.pending_window.is_some(), "the first click must be on nothing"); + s.idle_click(Vec2::new(11.0, 6.0), false).unwrap(); + assert_eq!(selected(&s), sorted(vec![hidden, other]), "a window dropped the selected line the viewport does not draw"); + + // The JSON `select` with `add`, and QSELECT appending the objects on layer 0. + freeze(&mut s); + s.execute("select", &json!({ "at": [5, 5], "aperture": 0.5, "add": true })).unwrap(); + assert_eq!(selected(&s), sorted(vec![hidden, other]), "`select` with `add`"); + // Given nothing to select with, `select` leaves the selection as it is. + s.execute("select", &json!({})).unwrap(); + assert_eq!(selected(&s), sorted(vec![hidden, other]), "`select` with nothing to select with"); + freeze(&mut s); + s.execute("qselect", &json!({ "layer": "0", "mode": "append" })).unwrap(); + assert_eq!(selected(&s), sorted(vec![shown, hidden, other]), "QSELECT appending"); + assert_eq!(sorted(s.selection()), sorted(vec![shown, other])); + + // Thawed in the viewport, the line counts as selected again. + s.execute("vplayer", &json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(sorted(s.selection()), sorted(vec![shown, hidden, other])); +} + +/// [`Session::selection`] looks a few selected objects up one by one and, when there are many, +/// passes over model space once. Both leave out the same objects and keep the order of the +/// selection: in a drawing of some hundreds of lines whose draw order is not the order of their +/// handles, a selection of a few lines and the selection of every line. +#[test] +fn a_small_and_a_large_selection_leave_out_the_same_objects() { + let Sheet { mut s, shown, hidden, a, b } = sheet(); + // A line on the sheet, on the layer the first viewport freezes: no viewport hides it. + let on_sheet = line(&mut s, [1.0, 1.0], [2.0, 1.0]); + hide(&mut s, on_sheet); + assert!(!s.doc().unwrap().model.contains(on_sheet), "the line must be on the sheet"); + enter(&mut s, &b); + let more: Vec = (0..400).map(|i| line(&mut s, [f64::from(i), 5.0], [f64::from(i), 6.0])).collect(); + // Every second one of them goes on the layer the first viewport freezes. + let frozen: Vec = more.iter().step_by(2).map(|h| h.hex()).collect(); + s.execute("properties.set", &json!({ "handles": frozen, "layer": "Hidden" })).unwrap(); + // The frozen line made last goes to the back: it is now the first object in draw order. + s.execute("draworder", &json!({ "handles": [more[398].hex()], "order": "back" })).unwrap(); + assert_eq!(s.doc().unwrap().model.iter().next().map(|e| e.handle), Some(more[398])); + let all: Vec = [shown, hidden].into_iter().chain(more.iter().copied()).collect(); + let drawn: Vec = std::iter::once(shown).chain(more.iter().copied().skip(1).step_by(2)).collect(); + assert_eq!(s.doc().unwrap().model.len(), all.len()); + + enter(&mut s, &a); + s.set_selection(vec![shown, hidden]); + assert_eq!(s.selection(), [shown], "two selected lines of some hundreds"); + s.set_selection(vec![hidden, on_sheet, more[0], more[1]]); + assert_eq!(s.selection(), [on_sheet, more[1]], "a line on the sheet is never left out"); + s.set_selection(all.clone()); + assert_eq!(s.selection(), drawn, "every line selected"); + assert_eq!(s.state().unwrap().selection, all, "every line must still be selected"); + + // The viewport that freezes nothing has them all, few or many. + enter(&mut s, &b); + s.set_selection(vec![shown, hidden]); + assert_eq!(s.selection(), [shown, hidden]); + s.set_selection(all.clone()); + assert_eq!(s.selection(), all); +} diff --git a/crates/ui-egui/src/bedit.rs b/crates/ui-egui/src/bedit.rs index e66430391..51816608b 100644 --- a/crates/ui-egui/src/bedit.rs +++ b/crates/ui-egui/src/bedit.rs @@ -96,8 +96,9 @@ pub fn route(app: &mut CadApp, id: &str, params: &Value) -> Option) { let gs = app.session.settings.gripsize as f32; for h in sel.iter().take(200) { if let Some(e) = st.doc.entity(*h) - && st.doc.is_visible(e) + && st.shows(e) { let grips = e.kind.grips(); let count = grips.len(); diff --git a/crates/ui-egui/src/canvas/grips.rs b/crates/ui-egui/src/canvas/grips.rs index ce3de5538..da4469b5d 100644 --- a/crates/ui-egui/src/canvas/grips.rs +++ b/crates/ui-egui/src/canvas/grips.rs @@ -3,10 +3,11 @@ use super::{CadApp, Handle, Input, Pos2, Rect, Xf, vec2}; /// A click on grip `g` (idle): Shift+click makes it hot or cold again; a plain click starts /// editing it, with the other hot grips when it is one of them. pub(super) fn click_grip(app: &mut CadApp, g: (Handle, usize), shift: bool) { - // A hot grip whose object was hidden since (a layer turned off, HIDEOBJECTS) is no longer - // painted, so it must not be stretched along with the visible ones. + // A hot grip whose object was hidden since (a layer turned off, HIDEOBJECTS, a layer frozen + // in the active viewport) is no longer painted, so it must not be stretched along with the + // visible ones. let Ok(st) = app.session.state() else { return }; - app.canvas.hot_grips.retain(|(h, _)| st.doc.entity(*h).is_some_and(|e| st.doc.is_visible(e))); + app.canvas.hot_grips.retain(|(h, _)| st.doc.entity(*h).is_some_and(|e| st.shows(e))); let hot = &mut app.canvas.hot_grips; if shift { match hot.iter().position(|x| *x == g) { @@ -89,7 +90,7 @@ pub(super) fn grip_at(app: &CadApp, xf: &Xf, hover: Option) -> Option<(Han } for h in sel.iter().take(200) { let e = st.doc.entity(*h)?; - if !st.doc.is_visible(e) || st.doc.layer(&e.common.layer).is_some_and(|l| l.locked) { + if !st.shows(e) || st.doc.layer(&e.common.layer).is_some_and(|l| l.locked) { continue; } let grips = e.kind.grips(); diff --git a/crates/ui-egui/src/canvas/pick.rs b/crates/ui-egui/src/canvas/pick.rs index 96e510df9..b75111716 100644 --- a/crates/ui-egui/src/canvas/pick.rs +++ b/crates/ui-egui/src/canvas/pick.rs @@ -52,7 +52,7 @@ pub(super) fn edit_text_at(app: &mut CadApp, p: Vec2) -> bool { pub(super) fn hatch_at(app: &CadApp, w: Vec2, scale: f64) -> Option { let st = app.session.state().ok()?; let aperture = app.session.settings.pickbox.max(1.0) * 1.5 / scale.max(1e-12); - let h = cadcraft_engine::select::pick(&st.doc, &st.edit_space(), w, aperture)?; + let h = cadcraft_engine::select::pick_in(&st.doc, &st.edit_space(), st.viewport_frozen(), w, aperture)?; matches!(st.doc.entity(h)?.kind, cadcraft_doc::EntityKind::Hatch(_)).then_some(h) } diff --git a/crates/ui-egui/src/canvas/tests.rs b/crates/ui-egui/src/canvas/tests.rs index 15d28b56c..7e20c083b 100644 --- a/crates/ui-egui/src/canvas/tests.rs +++ b/crates/ui-egui/src/canvas/tests.rs @@ -248,3 +248,121 @@ fn clicking_a_hot_grip_leaves_hidden_objects_out_of_the_stretch() { click_grip(&mut app, (shown, 0), false); assert_eq!(app.canvas.hot_grips, vec![(shown, 0)], "the hidden object's grip must leave the hot set"); } + +/// Makes the layer "Hidden" and, on Layout1, two viewports over the model: the first freezes +/// "Hidden", the second freezes nothing. The app is left in paper space. +fn viewports_freezing_hidden(app: &mut CadApp) -> (String, String) { + app.session.execute("layer.new", &serde_json::json!({ "name": "Hidden" })).unwrap(); + app.session.execute("layout.set", &serde_json::json!({ "name": "Layout1" })).unwrap(); + let made = app.session.execute("mview", &serde_json::json!({ "count": 2, "p1": [20, 20], "p2": [220, 120] })).unwrap(); + let viewport = |i: usize| made["viewports"][i].as_str().unwrap().to_string(); + let (a, b) = (viewport(0), viewport(1)); + app.session.execute("vplayer", &serde_json::json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + (a, b) +} + +/// An app with two model-space lines, the second on the layer "Hidden", and the two viewports of +/// [`viewports_freezing_hidden`]: (app, the first line, the second line, the viewport that +/// freezes "Hidden", the viewport that freezes nothing). +fn lines_in_two_viewports() -> (CadApp, Handle, Handle, String, String) { + let mut app = CadApp::new(cadcraft_engine::Session::new(), crate::Services::default()); + for y in [0, 30] { + app.run("line", serde_json::json!({ "points": [[0, y], [100, y]] })).unwrap(); + } + let handles = app.session.doc().unwrap().model.handles(); + let (shown, hidden) = (handles[0], handles[1]); + let (a, b) = viewports_freezing_hidden(&mut app); + app.session.execute("properties.set", &serde_json::json!({ "handles": [hidden.hex()], "layer": "Hidden" })).unwrap(); + assert_eq!(app.session.doc().unwrap().entity(hidden).unwrap().common.layer, "Hidden"); + (app, shown, hidden, a, b) +} + +/// A hot grip whose object is on a layer frozen in the active viewport is not painted there, so +/// clicking another hot grip must not stretch that object along with it. Through a viewport that +/// draws the layer both grips stay hot. +#[test] +fn clicking_a_hot_grip_leaves_out_objects_the_viewport_does_not_draw() { + let (mut app, shown, hidden, a, b) = lines_in_two_viewports(); + for (viewport, hot) in [(&a, vec![(shown, 0)]), (&b, vec![(shown, 0), (hidden, 0)])] { + app.session.execute("mspace", &serde_json::json!({ "handle": viewport })).unwrap(); + app.session.set_selection(vec![shown, hidden]); + app.canvas.hot_grips = vec![(shown, 0), (hidden, 0)]; + click_grip(&mut app, (shown, 0), false); + assert_eq!(app.canvas.hot_grips, hot); + app.session.cancel(); + } + // Frozen in the active viewport while both grips are hot. + app.session.set_selection(vec![shown, hidden]); + app.canvas.hot_grips = vec![(shown, 0), (hidden, 0)]; + app.session.execute("vplayer", &serde_json::json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + click_grip(&mut app, (shown, 0), false); + assert_eq!(app.canvas.hot_grips, vec![(shown, 0)], "the grip of the line the viewport no longer draws must leave the hot set"); +} + +/// The cursor finds no grip of a selected object the viewport does not draw; it finds the grips +/// of the other selected object there, and both through a viewport that draws both. +#[test] +fn the_cursor_finds_no_grip_of_an_object_the_viewport_does_not_draw() { + let (mut app, shown, hidden, a, b) = lines_in_two_viewports(); + let rect = Rect::from_min_size(Pos2::ZERO, vec2(400.0, 300.0)); + let xf = Xf { rect, center: Vec2::new(50.0, 15.0), scale: 2.0, twist: 0.0 }; + // The start of each line, where its first grip is. + let (on_shown, on_hidden) = (Some(xf.to_screen(Vec2::new(0.0, 0.0))), Some(xf.to_screen(Vec2::new(0.0, 30.0)))); + app.session.execute("mspace", &serde_json::json!({ "handle": a })).unwrap(); + app.session.set_selection(vec![shown, hidden]); + assert_eq!(grip_at(&app, &xf, on_shown), Some((shown, 0))); + assert_eq!(grip_at(&app, &xf, on_hidden), None, "a grip of a line the viewport does not draw was hit"); + app.session.execute("mspace", &serde_json::json!({ "handle": b })).unwrap(); + app.session.set_selection(vec![shown, hidden]); + assert_eq!(grip_at(&app, &xf, on_hidden), Some((hidden, 0))); + // Frozen in the active viewport while the line is selected, then thawed again. + app.session.execute("vplayer", &serde_json::json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(app.session.state().unwrap().selection, [shown, hidden], "both lines must still be selected"); + assert_eq!(grip_at(&app, &xf, on_hidden), None); + app.session.execute("vplayer", &serde_json::json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(grip_at(&app, &xf, on_hidden), Some((hidden, 0))); +} + +/// The hatch under the cursor, which a double-click edits, is one the viewport draws. +#[test] +fn the_cursor_finds_no_hatch_the_viewport_does_not_draw() { + let mut app = CadApp::new(cadcraft_engine::Session::new(), crate::Services::default()); + let handle = |v: &serde_json::Value| Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap(); + let square = app.session.execute("pline", &serde_json::json!({ "vertices": [[0, 0], [20, 0], [20, 20], [0, 20]], "closed": true })).unwrap(); + let hatch = handle(&app.session.execute("hatch", &serde_json::json!({ "handles": [handle(&square).hex()], "pattern": "SOLID" })).unwrap()); + let (a, b) = viewports_freezing_hidden(&mut app); + app.session.execute("properties.set", &serde_json::json!({ "handles": [hatch.hex()], "layer": "Hidden" })).unwrap(); + let inside = Vec2::new(10.0, 10.0); + app.session.execute("mspace", &serde_json::json!({ "handle": a })).unwrap(); + assert_eq!(hatch_at(&app, inside, 1.0), None, "a hatch the viewport does not draw was found"); + app.session.execute("mspace", &serde_json::json!({ "handle": b })).unwrap(); + assert_eq!(hatch_at(&app, inside, 1.0), Some(hatch)); +} + +/// The highlight of the selection inside the active viewport leaves out a selected object on a +/// layer frozen in that viewport, also when the layer is frozen while the object is selected, +/// and is built again for another viewport although the selection and the drawing are the same. +#[test] +fn the_viewport_highlight_leaves_out_objects_the_viewport_does_not_draw() { + let (mut app, shown, hidden, a, b) = lines_in_two_viewports(); + /// The objects `highlight` outlines for the selection of both lines. + fn outlined(app: &CadApp, highlight: &mut VpHighlight, both: [Handle; 2]) -> Vec { + highlight.update(app.session.state().unwrap(), &both, 10.0); + highlight.list.prims.iter().map(|p| p.handle).collect::>().into_iter().collect() + } + let both = [shown, hidden]; + let mut highlight = VpHighlight::default(); + app.session.execute("mspace", &serde_json::json!({ "handle": b })).unwrap(); + assert_eq!(outlined(&app, &mut highlight, both), both, "this viewport draws both lines"); + let revision = app.session.state().unwrap().revision; + app.session.execute("mspace", &serde_json::json!({ "handle": a })).unwrap(); + assert_eq!(app.session.state().unwrap().revision, revision, "entering a viewport must not look like a change of the drawing"); + assert_eq!(outlined(&app, &mut highlight, both), [shown], "a line the viewport does not draw was outlined"); + app.session.execute("mspace", &serde_json::json!({ "handle": b })).unwrap(); + assert_eq!(outlined(&app, &mut highlight, both), both, "the list built for the other viewport was reused"); + // Frozen in the active viewport while the line is selected, then thawed again. + app.session.execute("vplayer", &serde_json::json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(outlined(&app, &mut highlight, both), [shown]); + app.session.execute("vplayer", &serde_json::json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(outlined(&app, &mut highlight, both), both); +} diff --git a/crates/ui-egui/src/canvas/viewport.rs b/crates/ui-egui/src/canvas/viewport.rs index 202fab8c2..43471f61a 100644 --- a/crates/ui-egui/src/canvas/viewport.rs +++ b/crates/ui-egui/src/canvas/viewport.rs @@ -271,7 +271,9 @@ pub(super) fn viewport_highlight_tolerance(scale: f64) -> f64 { /// The selected or the hovered objects tessellated in model units for the active MSPACE /// viewport, whose contents can't be looked up by handle in the layout's lists. The selection and /// the hover are kept apart, so moving the cursor over objects doesn't tessellate the selection -/// again; each is rebuilt only when the drawing, the objects or the zoom band change. +/// again; each is rebuilt only when the drawing, the objects, the zoom band or the layers frozen +/// in the viewport change. An object on one of those layers is not drawn in the viewport, so it +/// is not highlighted there either. #[derive(Default)] pub(super) struct VpHighlight { key: Option, @@ -286,12 +288,14 @@ impl VpHighlight { let key = { use std::hash::{Hash, Hasher}; let mut h = std::collections::hash_map::DefaultHasher::new(); - (st.uid, st.revision, std::sync::Arc::as_ptr(&st.doc) as usize, tolerance.to_bits(), handles, super::list::font_generation()) + // Entering another viewport changes what is drawn without changing the drawing. + let frozen = st.viewport_frozen(); + (st.uid, st.revision, std::sync::Arc::as_ptr(&st.doc) as usize, tolerance.to_bits(), handles, frozen, super::list::font_generation()) .hash(&mut h); h.finish() }; if self.key != Some(key) { - let ents = handles.iter().filter_map(|h| st.doc.model.get(*h)).map(|e| e.as_ref()); + let ents = handles.iter().filter_map(|h| st.doc.model.get(*h)).filter(|e| !st.hidden_in_viewport(e)).map(|e| e.as_ref()); self.list = cadcraft_render::build_entities(&st.doc, ents, &cadcraft_render::Options { tolerance, ..Default::default() }); self.key = Some(key); self.list_gen = self.list_gen.wrapping_add(1); diff --git a/crates/ui-egui/src/dyngrips.rs b/crates/ui-egui/src/dyngrips.rs index ab118d379..b00335126 100644 --- a/crates/ui-egui/src/dyngrips.rs +++ b/crates/ui-egui/src/dyngrips.rs @@ -18,10 +18,12 @@ use cadcraft_engine::doc::dynblock::{DynGrip, GripShape}; /// Most selected references whose grips are shown. const MAX_REFERENCES: usize = 200; -/// The dynamic grips of the selection, worked out once per drawing revision and selection. +/// The dynamic grips of the selection, worked out once per drawing revision, selection and set +/// of layers frozen in the active viewport: entering another viewport changes which references +/// are shown without changing the drawing. #[derive(Clone, Default)] pub struct Cache { - key: (u64, u64, Vec), + key: (u64, u64, Vec, Vec), grips: Arc>, } @@ -29,12 +31,12 @@ pub struct Cache { pub(crate) fn of_selection(app: &mut CadApp) -> Arc> { let sel = app.session.selection(); let Ok(st) = app.session.state() else { return Arc::default() }; - let key = (st.uid, st.revision, sel.clone()); + let key = (st.uid, st.revision, sel.clone(), st.viewport_frozen().to_vec()); if app.canvas.dyn_grips.key != key { let grips: Vec<(Handle, DynGrip)> = sel .iter() .filter(|h| matches!(st.doc.entity(**h).map(|e| &e.kind), Some(cadcraft_engine::doc::EntityKind::Insert(_)))) - .filter(|h| st.doc.entity(**h).is_some_and(|e| st.doc.is_visible(e) && !st.doc.layer(&e.common.layer).is_some_and(|l| l.locked))) + .filter(|h| st.doc.entity(**h).is_some_and(|e| st.shows(e) && !st.doc.layer(&e.common.layer).is_some_and(|l| l.locked))) .take(MAX_REFERENCES) .flat_map(|h| cadcraft_engine::doc::dynblock::grips(&st.doc, *h).into_iter().map(move |g| (*h, g))) .collect(); @@ -195,6 +197,62 @@ mod tests { (s, h) } + /// An app with the reference of [`door`] on the layer "Hidden", and two viewports on Layout1 + /// over the model: the first freezes "Hidden", the second freezes nothing. Returns the app, + /// the reference and the two viewports, in paper space. + fn door_in_two_viewports() -> (CadApp, Handle, String, String) { + let (session, h) = door(); + let mut app = CadApp::new(session, Services::default()); + app.session.execute("layer.new", &json!({ "name": "Hidden" })).unwrap(); + app.session.execute("properties.set", &json!({ "handles": [h.hex()], "layer": "Hidden" })).unwrap(); + assert_eq!(app.session.doc().unwrap().entity(h).unwrap().common.layer, "Hidden"); + app.session.execute("layout.set", &json!({ "name": "Layout1" })).unwrap(); + let made = app.session.execute("mview", &json!({ "count": 2, "p1": [20, 20], "p2": [220, 120] })).unwrap(); + let viewport = |i: usize| made["viewports"][i].as_str().unwrap().to_string(); + let (a, b) = (viewport(0), viewport(1)); + app.session.execute("vplayer", &json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + (app, h, a, b) + } + + /// Makes `viewport` the active MSPACE viewport and selects `h` there (entering a viewport + /// clears the selection; Undo or another selection source can put the reference back). + fn enter_and_select(app: &mut CadApp, viewport: &str, h: Handle) { + app.session.execute("mspace", &json!({ "handle": viewport })).unwrap(); + app.session.set_selection(vec![h]); + } + + /// A selected reference shows its dynamic grips through a viewport that draws its layer. Once + /// the layer is frozen in that viewport the grips are gone although the reference is still + /// selected, and thawing the layer there brings them back. + #[test] + fn a_reference_the_viewport_does_not_draw_has_no_dynamic_grips() { + let (mut app, h, _, b) = door_in_two_viewports(); + enter_and_select(&mut app, &b, h); + assert_eq!(of_selection(&mut app).len(), 2, "this viewport draws the reference: its two grips"); + app.session.execute("vplayer", &json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(app.session.state().unwrap().selection, [h], "the reference must still be selected"); + assert!(of_selection(&mut app).is_empty(), "a reference the viewport no longer draws kept its dynamic grips"); + app.session.execute("vplayer", &json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(app.session.state().unwrap().selection, [h]); + assert_eq!(of_selection(&mut app).len(), 2, "thawed in the viewport: the grips are back"); + } + + /// Entering another viewport changes which references are drawn without changing the drawing, + /// so the cached grips of the same selection must not be reused from one viewport to the next. + #[test] + fn the_dynamic_grip_cache_follows_the_active_viewport() { + let (mut app, h, a, b) = door_in_two_viewports(); + enter_and_select(&mut app, &b, h); + assert_eq!(of_selection(&mut app).len(), 2); + let revision = app.session.state().unwrap().revision; + enter_and_select(&mut app, &a, h); + assert_eq!(app.session.state().unwrap().revision, revision, "entering a viewport must not look like a change of the drawing"); + assert!(of_selection(&mut app).is_empty(), "the grips cached in the other viewport were reused where the reference is not drawn"); + enter_and_select(&mut app, &b, h); + assert_eq!(app.session.state().unwrap().revision, revision); + assert_eq!(of_selection(&mut app).len(), 2, "the empty result cached in the other viewport was reused where the reference is drawn"); + } + /// A hidden reference restored to the selection (Undo, or another selection source) shows /// and takes no dynamic grips, as ordinary grips are not shown for it either. #[test] @@ -209,4 +267,17 @@ mod tests { assert!(!st.doc.is_visible(st.doc.entity(h).unwrap()), "the reference must be hidden"); assert!(of_selection(&mut app).is_empty(), "a hidden reference must not offer dynamic grips"); } + + /// BEDIT without a block name opens the editor on the one selected reference, and its dialog + /// when there is none. A selected reference the viewport does not draw is none to start from. + #[test] + fn bedit_opens_its_dialog_when_the_viewport_does_not_draw_the_selected_reference() { + let (mut app, h, a, b) = door_in_two_viewports(); + enter_and_select(&mut app, &b, h); + assert!(crate::bedit::route(&mut app, "bedit", &serde_json::Value::Null).is_none(), "one reference is selected: no dialog"); + assert_eq!(app.ui.dialog, None); + enter_and_select(&mut app, &a, h); + assert!(crate::bedit::route(&mut app, "bedit", &serde_json::Value::Null).is_some(), "the dialog must open"); + assert_eq!(app.ui.dialog.as_deref(), Some("bedit")); + } } diff --git a/crates/ui-egui/src/hatchdlg.rs b/crates/ui-egui/src/hatchdlg.rs index ff1c72251..053e85880 100644 --- a/crates/ui-egui/src/hatchdlg.rs +++ b/crates/ui-egui/src/hatchdlg.rs @@ -297,7 +297,7 @@ pub fn open_create(app: &mut CadApp, gradient: bool) { /// pick a hatch first. pub fn open_edit(app: &mut CadApp) { let Ok(st) = app.session.state() else { return }; - let (mut edit, mut create) = (edit_state(&st.doc, st.uid, st.selection.clone()), create_state(&st.doc, st.uid, false)); + let (mut edit, mut create) = (edit_state(&st.doc, st.uid, st.shown_selection()), create_state(&st.doc, st.uid, false)); create.space = st.edit_space(); if let Some(e) = edit.as_mut() { e.space = st.edit_space(); diff --git a/crates/ui-egui/src/hatchdlg/tests.rs b/crates/ui-egui/src/hatchdlg/tests.rs index 249c49812..b88a554e9 100644 --- a/crates/ui-egui/src/hatchdlg/tests.rs +++ b/crates/ui-egui/src/hatchdlg/tests.rs @@ -416,3 +416,35 @@ fn a_gradient_hatch_offers_the_current_pattern_on_the_pattern_tab() { k => panic!("{k:?}"), } } + +/// Edit mode opens on the selected hatches. A selected hatch on a layer frozen in the active +/// viewport is not drawn there, so it is not one of them and the command asks for a hatch. +#[test] +fn edit_mode_leaves_out_a_selected_hatch_the_viewport_does_not_draw() { + let (mut app, _) = app_with_rect(); + let hx = app.session.execute("hatch", &json!({ "points": [[5, 5]] })).unwrap()["handle"].as_str().unwrap().to_string(); + let hatch = Handle::parse_hex(&hx).unwrap(); + app.session.execute("layer.new", &json!({ "name": "Hidden" })).unwrap(); + app.session.execute("properties.set", &json!({ "handles": [hx], "layer": "Hidden" })).unwrap(); + app.session.execute("layout.set", &json!({ "name": "Layout1" })).unwrap(); + let made = app.session.execute("mview", &json!({ "count": 2, "p1": [20, 20], "p2": [220, 120] })).unwrap(); + let viewport = |i: usize| made["viewports"][i].as_str().unwrap().to_string(); + let (a, b) = (viewport(0), viewport(1)); + app.session.execute("vplayer", &json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + + // Through the viewport that draws the hatch, edit mode opens on it. + app.session.execute("mspace", &json!({ "handle": b })).unwrap(); + app.session.set_selection(vec![hatch]); + open_edit(&mut app); + assert_eq!(app.ui.dialog.as_deref(), Some("hatch")); + assert_eq!(app.hatch_dlg.as_ref().map(|d| d.edit.clone()), Some(vec![hatch])); + + // Through the viewport that freezes its layer there is no hatch to edit yet. + (app.ui.dialog, app.hatch_dlg) = (None, None); + app.session.execute("mspace", &json!({ "handle": a })).unwrap(); + app.session.set_selection(vec![hatch]); + open_edit(&mut app); + assert_eq!(app.ui.dialog, None, "no dialog: the command asks for a hatch first"); + assert_eq!(app.hatch_dlg.as_ref().map(|d| d.edit.clone()), Some(Vec::new()), "a hatch the viewport does not draw must not be edited"); + assert!(app.session.running.is_some(), "HATCHPICK must be asking for a hatch"); +} diff --git a/crates/ui-egui/tests/viewport_frozen_grips.rs b/crates/ui-egui/tests/viewport_frozen_grips.rs new file mode 100644 index 000000000..a8b28f412 --- /dev/null +++ b/crates/ui-egui/tests/viewport_frozen_grips.rs @@ -0,0 +1,145 @@ +//! Inside a layout viewport an object on a layer frozen in that viewport is not drawn: selected, +//! it paints no grips there, and the cursor does not highlight it. + +use cadcraft_engine::doc::Handle; +use cadcraft_engine::geom::Vec2; +use cadcraft_engine::{Session, View}; +use cadcraft_ui_egui::{CadApp, Services, theme::Tokens}; +use serde_json::json; + +/// What the tests draw: two model-space lines from (0, 0) to (100, 0), `shown` on layer 0 and, +/// drawn after it and so on top of it, `hidden` on the layer "Hidden"; and two viewports on +/// Layout1, `a` freezing "Hidden" and `b` freezing nothing. +struct Sheet { + app: CadApp, + shown: Handle, + hidden: Handle, + /// The viewport that freezes "Hidden". + a: String, + /// The viewport that freezes nothing. + b: String, +} + +/// The drawing of [`Sheet`], in paper space with nothing selected. +fn sheet() -> Sheet { + let mut app = CadApp::new(Session::new(), Services::default()); + app.ui.start_tab = false; + app.ui.in_window_menu = false; + app.integrated_titlebar = true; + // A third line gives the model a height for the viewports to fit. + for points in [[[0, 0], [100, 0]], [[0, 0], [100, 0]], [[0, 40], [100, 40]]] { + app.run("line", json!({ "points": points })).unwrap(); + } + let handles = app.session.doc().unwrap().model.handles(); + assert_eq!(handles.len(), 3); + let (shown, hidden) = (handles[0], handles[1]); + app.run("layer.new", json!({ "name": "Hidden" })).unwrap(); + app.run("properties.set", json!({ "handles": [hidden.hex()], "layer": "Hidden" })).unwrap(); + assert_eq!(app.session.doc().unwrap().entity(hidden).unwrap().common.layer, "Hidden"); + app.run("layout.set", json!({ "name": "Layout1" })).unwrap(); + let made = app.session.execute("mview", &json!({ "count": 2, "p1": [20, 20], "p2": [220, 120] })).unwrap(); + let viewport = |i: usize| made["viewports"][i].as_str().unwrap().to_string(); + let (a, b) = (viewport(0), viewport(1)); + app.run("vplayer", json!({ "handles": [a], "freeze": ["Hidden"] })).unwrap(); + // Show the part of the sheet that holds both viewports, with room around them. + assert!(app.session.state_mut().unwrap().set_view(View { center: Vec2::new(120.0, 70.0), height: 300.0, twist: 0.0 })); + app.session.set_selection(Vec::new()); + Sheet { app, shown, hidden, a, b } +} + +/// Makes `viewport` the active MSPACE viewport. That clears the selection. +fn enter(app: &mut CadApp, viewport: &str) { + app.run("mspace", json!({ "handle": viewport })).unwrap(); +} + +/// The grip rectangles (filled with `color`) inside `canvas` among the painted shapes. +fn count_grips(shape: &egui::Shape, canvas: egui::Rect, color: egui::Color32) -> usize { + match shape { + egui::Shape::Rect(rect) => usize::from(rect.fill == color && canvas.contains(rect.rect.center())), + egui::Shape::Vec(shapes) => shapes.iter().map(|shape| count_grips(shape, canvas, color)).sum(), + _ => 0, + } +} + +/// Runs one frame of the app with the pointer at `pointer` (none: away from the window) and +/// counts the grip rectangles painted on its canvas. +fn frame(app: &mut CadApp, ctx: &egui::Context, pointer: Option) -> usize { + app.logic(ctx); + let input = egui::RawInput { + screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1600.0, 1000.0))), + events: vec![pointer.map_or(egui::Event::PointerGone, egui::Event::PointerMoved)], + ..Default::default() + }; + let mut output = ctx.run_ui(input, |ui| app.ui(ui)); + output.textures_delta.clear(); + let canvas = app.canvas.rect.unwrap(); + let color = Tokens::get().grip; + output.shapes.iter().map(|shape| count_grips(&shape.shape, canvas, color)).sum() +} + +/// The grip rectangles painted once the frame has settled, with the pointer away. +fn painted_grips(app: &mut CadApp, ctx: &egui::Context) -> usize { + frame(app, ctx, None); + frame(app, ctx, None) +} + +/// Whether every grip of `h` is on the canvas, where it would be painted. +fn grips_on_canvas(app: &CadApp, h: Handle) -> bool { + let xf = app.canvas.xf.unwrap(); + let state = app.session.state().unwrap(); + state.doc.entity(h).unwrap().kind.grips().iter().all(|point| xf.rect.contains(xf.to_screen(*point))) +} + +/// A selected line paints its grips through a viewport that draws its layer. Once the layer is +/// frozen in that viewport the grips are gone although the line is still selected, the grips of +/// the other selected line stay, and thawing the layer brings them back. The same holds from one +/// viewport to the other. +#[test] +fn a_selected_object_the_viewport_does_not_draw_paints_no_grips() { + let Sheet { mut app, shown, hidden, a, b } = sheet(); + let ctx = egui::Context::default(); + // Settle the dock layout. + painted_grips(&mut app, &ctx); + enter(&mut app, &b); + app.session.set_selection(vec![shown]); + let one = painted_grips(&mut app, &ctx); + assert!(grips_on_canvas(&app, shown) && grips_on_canvas(&app, hidden), "the viewport must show both lines whole"); + assert!(one >= 2, "the counter must find the grips of one selected line, got {one}"); + app.session.set_selection(vec![shown, hidden]); + assert_eq!(painted_grips(&mut app, &ctx), 2 * one, "this viewport draws both lines"); + + // The layer is frozen in the active viewport while its line is selected. + app.run("vplayer", json!({ "handles": [b], "freeze": ["Hidden"] })).unwrap(); + assert_eq!(app.session.state().unwrap().selection, [shown, hidden], "both lines must still be selected"); + assert_eq!(painted_grips(&mut app, &ctx), one, "a line the viewport no longer draws kept its grips"); + app.run("vplayer", json!({ "handles": [b], "thaw": ["Hidden"] })).unwrap(); + assert_eq!(app.session.state().unwrap().selection, [shown, hidden]); + assert_eq!(painted_grips(&mut app, &ctx), 2 * one, "thawed in the viewport: the grips are back"); + + // The same selection through the viewport that freezes the layer, and back. + enter(&mut app, &a); + app.session.set_selection(vec![shown, hidden]); + assert_eq!(painted_grips(&mut app, &ctx), one, "a line the viewport does not draw painted grips"); + assert!(grips_on_canvas(&app, hidden), "its grips would be on the canvas"); + enter(&mut app, &b); + app.session.set_selection(vec![shown, hidden]); + assert_eq!(painted_grips(&mut app, &ctx), 2 * one); +} + +/// The cursor highlights the object a click would select: over the two lines, the one the +/// viewport draws. +#[test] +fn the_cursor_highlights_the_object_the_viewport_draws() { + let Sheet { mut app, shown, hidden, a, b } = sheet(); + let ctx = egui::Context::default(); + painted_grips(&mut app, &ctx); + for (viewport, under_cursor) in [(&a, shown), (&b, hidden)] { + enter(&mut app, viewport); + painted_grips(&mut app, &ctx); + let on_lines = app.canvas.xf.unwrap().to_screen(Vec2::new(50.0, 0.0)); + assert!(app.canvas.rect.unwrap().contains(on_lines), "the viewport must show the lines"); + frame(&mut app, &ctx, Some(on_lines)); + frame(&mut app, &ctx, Some(on_lines)); + assert_eq!(app.canvas.hover, Some(under_cursor)); + } +}