Merge pull request #8564 from Hassan1305/fix-8538-locked-guides

Lock Guides: a marquee skips guides in groups, and a group's transform leaves them in place
This commit is contained in:
BFlat
2026-11-18 19:33:51 +07:00
committed by GitHub
12 changed files with 283 additions and 62 deletions
+65 -41
View File
@@ -2106,20 +2106,39 @@ pub fn compound_part_at(n: &Node, p: Point, tol: f64) -> Option<NodeId> {
/// the members of a group or layer with geometry effects of its own, are touched where the art those
/// effects draw lies ([`set_drawn_art`]), as clicks hit them.
pub fn marquee(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool) -> Vec<NodeId> {
marquee_with(doc, r, scope, leaves, false, false)
marquee_with(doc, r, scope, leaves, false, false, false)
}
/// [`marquee`] in the view the canvas shows: with `outline` (Outline view), and below a layer
/// whose Preview is off, a clipping path counts by its plain shapes, without its live effects, as
/// the clicks of [`HitOptions::outline`] do.
pub fn marquee_in_view(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, outline: bool) -> Vec<NodeId> {
marquee_with(doc, r, scope, leaves, false, outline)
/// the clicks of [`HitOptions::outline`] do. With `skip_guides` (Lock Guides is on or the guides
/// are hidden, as [`HitOptions::skip_guides`]), the paths made into guides are not touched, at the
/// top or inside a group, so a group is not taken for a guide in it (#8538).
pub fn marquee_in_view(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, outline: bool, skip_guides: bool) -> Vec<NodeId> {
marquee_with(doc, r, scope, leaves, false, outline, skip_guides)
}
/// Candidates for whole-object enclosure by a loop bounded by `r`. Eligibility and group
/// traversal follow [`marquee_in_view`]; compounds contribute the complete path they paint.
pub fn enclosure_candidates(doc: &Document, r: Rect, scope: Option<NodeId>, outline: bool) -> Vec<NodeId> {
marquee_with(doc, r, scope, true, true, outline)
pub fn enclosure_candidates(doc: &Document, r: Rect, scope: Option<NodeId>, outline: bool, skip_guides: bool) -> Vec<NodeId> {
marquee_with(doc, r, scope, true, true, outline, skip_guides)
}
/// What a marquee ([`marquee_with`]) takes, besides where it is: whether a compound path is
/// touched by every path it paints (`whole_compounds`, for an enclosing loop's candidates), and
/// whether the paths made into guides are left out (`skip_guides`: Lock Guides is on or the
/// guides are hidden, [`HitOptions::skip_guides`] for the marquee).
#[derive(Clone, Copy)]
struct Rules {
whole_compounds: bool,
skip_guides: bool,
}
impl Rules {
/// Is `n` a path made into a guide that the marquee leaves out?
fn skips(self, n: &Node) -> bool {
self.skip_guides && matches!(n.kind, NodeKind::Path { guide: true, .. })
}
}
/// Is `n` a layer whose Preview is off (its art is drawn and clicked in outline)?
@@ -2127,8 +2146,17 @@ fn previews_off(n: &Node) -> bool {
matches!(n.kind, NodeKind::Layer { preview: false, .. })
}
fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, whole_compounds: bool, outline: bool) -> Vec<NodeId> {
fn marquee_with(
doc: &Document,
r: Rect,
scope: Option<NodeId>,
leaves: bool,
whole_compounds: bool,
outline: bool,
skip_guides: bool,
) -> Vec<NodeId> {
let _walk = ArtWalk::open();
let rules = Rules { whole_compounds, skip_guides };
let mut out = Vec::new();
// The locks first: they copy the kept art boxes that `symbols` takes, and `symbols` keeps theirs.
let locks = doc.locked_artboards_kept();
@@ -2142,7 +2170,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
Some(c) => {
// In an isolated clip group, its members by their own geometry, as clicks take
// them ([`edits_inside`]).
let drawn = if s.clips() { None } else { touched_in_art(s, &symbols, r, whole_compounds, outline || previews_off(s)) };
let drawn = if s.clips() { None } else { touched_in_art(s, &symbols, r, rules, outline || previews_off(s)) };
c.iter()
.enumerate()
.filter(|(i, c)| !c.is_ruler_guide() && !shaper_hides(s, *i, scope))
@@ -2164,7 +2192,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
.layers
.iter()
.filter(|l| l.visible && !l.locked && !l.is_template() && doc.pattern_edit.as_ref().is_none_or(|e| e.layer == l.id))
.flat_map(|l| layer_objects(l, &symbols, r, outline, whole_compounds, None))
.flat_map(|l| layer_objects(l, &symbols, r, outline, rules, None))
.collect(),
};
/// The objects of layer `l`, each with the part of `r` that the clipping masks of `l` and of
@@ -2173,17 +2201,10 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
/// shapes ([`mask_marquee`]). In a layer whose own geometry effects reshape its art, each object
/// comes with the objects that art touches ([`touched_in_art`]), `drawn` when a layer around
/// `l` has such effects.
fn layer_objects<'a>(
l: &'a Node,
s: &SymbolBoxes,
r: Rect,
outline: bool,
whole_compounds: bool,
drawn: Option<Rc<HashSet<NodeId>>>,
) -> Vec<Top<'a>> {
fn layer_objects<'a>(l: &'a Node, s: &SymbolBoxes, r: Rect, outline: bool, rules: Rules, drawn: Option<Rc<HashSet<NodeId>>>) -> Vec<Top<'a>> {
let mut out = vec![];
let outline = outline || previews_off(l);
let drawn = drawn.or_else(|| touched_in_art(l, s, r, whole_compounds, outline));
let drawn = drawn.or_else(|| touched_in_art(l, s, r, rules, outline));
let inner = marquee_in_parent(l, r, outline);
for (i, c) in l.children().into_iter().flatten().enumerate() {
if c.is_layer() {
@@ -2192,7 +2213,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
&& !c.locked
&& !c.is_template()
{
out.extend(layer_objects(c, s, inner, outline, whole_compounds, drawn.clone()));
out.extend(layer_objects(c, s, inner, outline, rules, drawn.clone()));
}
} else if !c.is_ruler_guide() {
if drawn.is_some() {
@@ -2209,12 +2230,12 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
/// The ids of the objects of the art that group or layer `n` draws with its own geometry
/// effects ([`drawn_art`]) that the marquee `r` touches, as [`collect_leaves`] collects them.
/// `None` in outline and when it has no such effects.
fn touched_in_art(n: &Node, s: &SymbolBoxes, r: Rect, whole_compounds: bool, outline: bool) -> Option<Rc<HashSet<NodeId>>> {
fn touched_in_art(n: &Node, s: &SymbolBoxes, r: Rect, rules: Rules, outline: bool) -> Option<Rc<HashSet<NodeId>>> {
let art = drawn_art(s, n, outline)?;
let _off = DrawnOff::set();
let mut ids = vec![];
for a in art.iter().filter(|a| a.visible) {
collect_leaves(a, s, r, None, whole_compounds, false, &mut ids);
collect_leaves(a, s, r, None, rules, false, &mut ids);
}
Some(Rc::new(ids.into_iter().collect()))
}
@@ -2271,12 +2292,16 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
/// instance also where its fills and strokes paint outside it ([`painted_touches`]). A clipping
/// path is touched by its own geometry ([`mask_marquee`]) and on the edge of its region
/// ([`clip_edge_touches`]).
fn touches(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, whole_compounds: bool, outline: bool) -> bool {
fn touches(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, rules: Rules, outline: bool) -> bool {
// Locked or hidden guides are not touched ([`Rules::skips`]).
if rules.skips(n) {
return false;
}
// A path or compound path whose geometry effects reshape it, or a group or layer whose own
// geometry effects reshape its members, is touched where that art is drawn ([`drawn_art`]).
if let Some(art) = drawn_art(s, n, outline || previews_off(n)) {
let _off = DrawnOff::set();
return art.iter().any(|a| a.visible && touches(a, s, r, None, whole_compounds, false));
return art.iter().any(|a| a.visible && touches(a, s, r, None, rules, false));
}
match &n.kind {
NodeKind::Path { path, .. } => vectorcraft_geom::hit::intersects_rect(path, r),
@@ -2287,25 +2312,26 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
c.visible
&& !shaper_hides(n, i, scope)
&& if i == 0 && n.clips() {
plain(true, || mask_marquee(n, r).is_some_and(|r| touches(c, s, r, scope, whole_compounds, outline)))
plain(true, || mask_marquee(n, r).is_some_and(|r| touches(c, s, r, scope, rules, outline)))
|| clip_edge_touches(c, r, outline)
} else {
inner.is_some_and(|r| touches(c, s, r, scope, whole_compounds, outline))
inner.is_some_and(|r| touches(c, s, r, scope, rules, outline))
}
})
}
NodeKind::Compound { children, .. } if whole_compounds => {
children.iter().filter_map(|c| c.path_data()).any(|path| vectorcraft_geom::hit::intersects_rect(path, r))
NodeKind::Compound { children, .. } if rules.whole_compounds => {
// Guide contours left out ([`Rules::skips`]) don't make the compound a candidate.
children.iter().filter(|c| !rules.skips(c)).filter_map(|c| c.path_data()).any(|path| vectorcraft_geom::hit::intersects_rect(path, r))
}
NodeKind::Compound { children, .. } => children.iter().any(|c| c.visible && touches(c, s, r, scope, whole_compounds, outline)),
NodeKind::Repeat(spec) => spec.expand(Some(s.document())).iter().any(|copy| touches(copy, s, r, scope, whole_compounds, outline)),
NodeKind::Compound { children, .. } => children.iter().any(|c| c.visible && touches(c, s, r, scope, rules, outline)),
NodeKind::Repeat(spec) => spec.expand(Some(s.document())).iter().any(|copy| touches(copy, s, r, scope, rules, outline)),
// A symbol instance is touched by its box, and outside it where the live geometry
// effects of a clipping path in its art show the art, or where the geometry effects of
// its active fill or stroke reshape the art ([`painted_touches`]). In the art of another
// instance walked outside that instance's box, it is touched only by its own art
// ([`ArtOnly`]) and those shapes.
NodeKind::SymbolInstance { .. } => {
!ArtOnly::on() && box_touches(n, s, r) || !outline && (instance_art_touches(n, s, r, whole_compounds) || painted_touches(n, s, r))
!ArtOnly::on() && box_touches(n, s, r) || !outline && (instance_art_touches(n, s, r, rules) || painted_touches(n, s, r))
}
// An image is touched by its box, and outside it where its own fills and strokes paint.
NodeKind::Image(_) => box_touches(n, s, r) || !outline && painted_touches(n, s, r),
@@ -2334,7 +2360,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
/// ([`SymbolBoxes::art`]), or for any art while [`ArtOnly`] is on, and only when `r` meets the
/// instance's reach ([`Node::reach_bounds_with`]): elsewhere the art lies within the instance's
/// box. Not once the marquee has placed as many objects of symbol art as [`ArtWalk`] allows.
fn instance_art_touches(n: &Node, s: &SymbolBoxes, r: Rect, whole_compounds: bool) -> bool {
fn instance_art_touches(n: &Node, s: &SymbolBoxes, r: Rect, rules: Rules) -> bool {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return false };
let meets = |b: Rect| b.x0 <= r.x1 && r.x0 <= b.x1 && b.y0 <= r.y1 && r.y0 <= b.y1;
if s.art(symbol).is_none_or(|a| a.reshaped.is_none() && !ArtOnly::on()) || !n.reach_bounds_with(s).is_some_and(meets) {
@@ -2351,15 +2377,15 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
#[cfg(test)]
ARTS_WALKED.with(|c| c.set(c.get() + 1));
let _art_only = ArtOnly::set();
art.place(&art.art, None).is_some_and(|placed| placed.visible && touches(&placed, s, r, None, whole_compounds, false))
art.place(&art.art, None).is_some_and(|placed| placed.visible && touches(&placed, s, r, None, rules, false))
}
fn collect_leaves(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, whole_compounds: bool, outline: bool, out: &mut Vec<NodeId>) {
fn collect_leaves(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, rules: Rules, outline: bool, out: &mut Vec<NodeId>) {
match &n.kind {
NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } | NodeKind::Intertwine { children } => {
let outline = outline || previews_off(n);
// The members that the art its own geometry effects draw touches, and a group whose
// own fills and strokes that art paints, as clicks hit it ([`member_chain`]).
if let Some(drawn) = touched_in_art(n, s, r, whole_compounds, outline) {
if let Some(drawn) = touched_in_art(n, s, r, rules, outline) {
if drawn.contains(&n.id) && !n.is_layer() {
out.push(n.id);
}
@@ -2374,18 +2400,18 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
if i == 0 && n.clips() {
let before = out.len();
if let Some(r) = mask_marquee(n, r) {
plain(true, || collect_leaves(c, s, r, scope, whole_compounds, outline, out));
plain(true, || collect_leaves(c, s, r, scope, rules, outline, out));
}
if out.len() == before && is_leaf(c) && clip_edge_touches(c, r, outline) {
out.push(c.id);
}
} else if let Some(r) = inner {
collect_leaves(c, s, r, scope, whole_compounds, outline, out);
collect_leaves(c, s, r, scope, rules, outline, out);
}
}
}
_ => {
if touches(n, s, r, scope, whole_compounds, outline) {
if touches(n, s, r, scope, rules, outline) {
out.push(n.id);
}
}
@@ -2420,14 +2446,12 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
if leaves {
let before = out.len();
if let Some(r) = r {
collect_leaves(t, &symbols, r, scope, whole_compounds, outline, &mut out);
collect_leaves(t, &symbols, r, scope, rules, outline, &mut out);
}
if edge.is_some_and(|e| out.len() == before && is_leaf(t) && clip_edge_touches(t, e, outline)) {
out.push(t.id);
}
} else if r.is_some_and(|r| touches(t, &symbols, r, scope, whole_compounds, outline))
|| edge.is_some_and(|e| clip_edge_touches(t, e, outline))
{
} else if r.is_some_and(|r| touches(t, &symbols, r, scope, rules, outline)) || edge.is_some_and(|e| clip_edge_touches(t, e, outline)) {
out.push(t.id);
}
}
+67 -5
View File
@@ -164,8 +164,8 @@ fn clicks_in_a_clip_group_evaluate_its_clipping_paths_region_once_until_it_chang
// So with a marquee across the art's left edge: in the view, only in Outline view. The
// clipping path's own left edge lies there too, and counts in both.
let edge = Rect::new(-5.0, 40.0, 5.0, 60.0);
assert_eq!(marquee_in_view(&d, edge, None, true, false), [mask_id]);
assert_eq!(marquee_in_view(&d, edge, None, true, true), [mask_id, art_id]);
assert_eq!(marquee_in_view(&d, edge, None, true, false, false), [mask_id]);
assert_eq!(marquee_in_view(&d, edge, None, true, true, false), [mask_id, art_id]);
// `marquee_in` measures by the plain shapes, as its callers clip by them.
assert!(marquee_in(d.node(g).unwrap(), edge).is_some());
// Hidden, the effect no longer moves the region.
@@ -489,8 +489,8 @@ fn a_marquee_touches_a_paths_shifted_art_not_its_source() {
for leaves in [false, true] {
assert_eq!(marquee(&d, drawn, None, leaves), [a], "where it is drawn");
assert!(marquee(&d, own, None, leaves).is_empty(), "its own place");
assert!(marquee_in_view(&d, drawn, None, leaves, true).is_empty(), "outline: no drawn art");
assert_eq!(marquee_in_view(&d, own, None, leaves, true), [a], "outline: its own place");
assert!(marquee_in_view(&d, drawn, None, leaves, true, false).is_empty(), "outline: no drawn art");
assert_eq!(marquee_in_view(&d, own, None, leaves, true, false), [a], "outline: its own place");
}
}
@@ -870,6 +870,68 @@ fn a_selected_guide_hidden_by_a_mask_counts_only_while_guides_can_be_clicked() {
assert_eq!(selected_hidden_at(&d, hidden, HitOptions { skip_guides: true, ..opt }, &[guide_id]), None);
}
/// #8538: while guides are locked or hidden (`skip_guides`), a marquee touches no guide path, at
/// the top of a layer or in a group (the group is not taken for it), nor in a group in a group,
/// with leaves or without. The group's other members still take it, and with the guides unlocked
/// the guide does.
#[test]
fn a_marquee_skips_guide_paths_in_groups_while_guides_are_locked() {
let mut d = Document::new(300.0, 200.0);
let l = d.layers[0].id;
let guide = |d: &mut Document, r: Rect| {
let mut n = Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art());
if let NodeKind::Path { guide, .. } = &mut n.kind {
*guide = true;
}
n
};
let top = guide(&mut d, Rect::new(0.0, 0.0, 20.0, 20.0));
let inner = guide(&mut d, Rect::new(100.0, 0.0, 120.0, 20.0));
let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(200.0, 0.0, 220.0, 20.0)), Appearance::default_art());
let (top_id, inner_id, art_id) = (top.id, inner.id, art.id);
let (outer_id, nested_id) = (d.alloc_id(), d.alloc_id());
let nested = Node::group(nested_id, vec![Arc::new(inner)]);
d.insert(Some(l), 0, top).unwrap();
d.insert(Some(l), 1, Node::group(outer_id, vec![Arc::new(nested), Arc::new(art)])).unwrap();
let (on_top, on_inner, on_art) = (Rect::new(-5.0, 5.0, 5.0, 10.0), Rect::new(95.0, 5.0, 105.0, 10.0), Rect::new(195.0, 5.0, 205.0, 10.0));
for leaves in [false, true] {
let m = |r: Rect, skip: bool| marquee_in_view(&d, r, None, leaves, false, skip);
assert!(m(on_top, true).is_empty(), "a guide at the top, leaves {leaves}");
assert!(m(on_inner, true).is_empty(), "a guide in a group in a group, leaves {leaves}");
assert!(m(Rect::new(0.0, 0.0, 300.0, 200.0), true).iter().all(|id| ![top_id, inner_id].contains(id)), "all, leaves {leaves}");
assert_eq!(m(on_art, true), [if leaves { art_id } else { outer_id }], "the group's art, leaves {leaves}");
// Unlocked: the guides are touched.
assert_eq!(m(on_top, false), [top_id], "unlocked, leaves {leaves}");
assert_eq!(m(on_inner, false), [if leaves { inner_id } else { outer_id }], "unlocked, leaves {leaves}");
}
// An enclosing loop's candidates leave them out alike.
assert!(enclosure_candidates(&d, on_inner, None, false, true).is_empty());
assert_eq!(enclosure_candidates(&d, on_inner, None, false, false), [inner_id]);
}
/// #8538: an enclosing loop's candidates leave out a compound path whose touched contours are all
/// locked or hidden guides, as the marquee does.
#[test]
fn guide_contours_do_not_make_a_compound_an_enclosure_candidate() {
let mut d = Document::new(300.0, 200.0);
let l = d.layers[0].id;
let part = |d: &mut Document, r: Rect| {
let mut n = Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art());
if let NodeKind::Path { guide, .. } = &mut n.kind {
*guide = true;
}
Arc::new(n)
};
let (a, b) = (part(&mut d, Rect::new(10.0, 10.0, 50.0, 50.0)), part(&mut d, Rect::new(20.0, 20.0, 40.0, 40.0)));
let id = d.alloc_id();
let mut compound = Node::group(id, vec![]);
compound.kind = NodeKind::Compound { children: vec![a, b], rule: Default::default() };
d.insert(Some(l), 0, compound).unwrap();
let r = Rect::new(0.0, 0.0, 60.0, 60.0);
assert!(enclosure_candidates(&d, r, None, false, true).is_empty(), "locked or hidden");
assert_eq!(enclosure_candidates(&d, r, None, false, false), [id], "shown and unlocked");
}
/// A selected path in a Shaper group's original shapes, where an outer mask hides it, counts only
/// while those shapes can be clicked (Construction mode, with them isolated), however deep it
/// lies in them.
@@ -2674,7 +2736,7 @@ fn a_symbol_instance_is_hit_where_a_moved_clipping_path_in_its_art_shows_the_art
assert_eq!(marquee(&d, edge, None, false), [g], "layer {layer}");
assert_eq!(marquee(&d, edge, None, true), [inst], "layer {layer}");
assert!(marquee(&d, past, None, false).is_empty());
assert!(marquee_in_view(&d, edge, None, false, true).is_empty(), "Outline view");
assert!(marquee_in_view(&d, edge, None, false, true, false).is_empty(), "Outline view");
}
// Preview off for the layer the instance is on.
let (mut d, _, _) = build("test.move", Affine::IDENTITY, false, true, false);
+36
View File
@@ -90,6 +90,42 @@ impl Node {
matches!(self.kind, NodeKind::RulerGuide { .. } | NodeKind::Path { guide: true, .. })
}
/// This object without the paths made into guides among the members of its groups, layers,
/// Intertwine groups and compound paths, at any depth, for measuring the art around them while
/// Lock Guides or Hide Guides leaves them out (#8538). The clipping path of a clip group or
/// layer and the original shapes of a Shaper group stay, guides or not, so the object keeps
/// its structure. `None` when it holds no such guide.
pub fn without_guides(&self) -> Option<Node> {
let (NodeKind::Layer { children, .. }
| NodeKind::Group { children, .. }
| NodeKind::Intertwine { children }
| NodeKind::Compound { children, .. }) = &self.kind
else {
return None;
};
let keep = usize::from(self.clips() || self.extras().shaper.is_some());
let mut changed = false;
let mut out = Vec::with_capacity(children.len());
for (i, c) in children.iter().enumerate() {
if i >= keep && matches!(c.kind, NodeKind::Path { guide: true, .. }) {
changed = true;
} else if let Some(stripped) = c.without_guides() {
changed = true;
out.push(Arc::new(stripped));
} else {
out.push(c.clone());
}
}
if !changed {
return None;
}
let mut n = self.clone();
if let Some(c) = n.children_mut() {
*c = out;
}
Some(n)
}
/// A template layer (Layer Options → Template).
pub fn is_template(&self) -> bool {
matches!(self.kind, NodeKind::Layer { template: true, .. })
+1 -1
View File
@@ -407,7 +407,7 @@ fn image_with_shaped_fill(s: &mut Session) -> NodeId {
/// outline with `outline`.
fn marquee_at(s: &Session, x0: f64, x1: f64, outline: bool) -> Vec<NodeId> {
let r = vectorcraft_geom::Rect::new(x0, 90.0, x1, 110.0);
vectorcraft_doc::hit::marquee_in_view(&s.doc().unwrap().doc, r, None, true, outline)
vectorcraft_doc::hit::marquee_in_view(&s.doc().unwrap().doc, r, None, true, outline, false)
}
/// A marquee touches a symbol instance where the geometry effects of its fill or stroke paint its
+1 -1
View File
@@ -134,7 +134,7 @@ impl Tool for EnclosingLassoTool {
let symbols = cx.doc.symbol_boxes();
let region = (points.len() >= 3).then(|| Region::new(polygon(&points, true))).flatten();
let mut ids = if let Some(region) = region {
enclosure_candidates(cx.doc, region.path.bounding_box(), cx.isolation, cx.outline)
enclosure_candidates(cx.doc, region.path.bounding_box(), cx.isolation, cx.outline, !cx.guides)
.into_iter()
.filter(|id| cx.doc.node(*id).is_some_and(|n| node_inside(n, &symbols, &region)))
.collect()
+8 -4
View File
@@ -1674,7 +1674,7 @@ impl DirectSelectionTool {
// marquee or an Alt-marquee, every object it touches, each whole (#8047).
if enclosed || whole || self.group {
(self.spine, self.spine_more) = (None, vec![]);
let mut touched = vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline);
let mut touched = vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline, !cx.guides);
let editable = cx.doc.editable();
touched.retain(|id| editable(*id));
let picked = if enclosed { crate::select::inside(cx, r, touched) } else { touched };
@@ -1684,8 +1684,11 @@ impl DirectSelectionTool {
}
// Anchors inside the rect, on editable paths inside isolation mode.
let mut sel: Vec<(NodeId, Vec<AnchorRef>)> = vec![];
// Guide paths only while guides can be picked: not while they are locked or hidden (#8538).
walk_pickable(cx.doc, cx.isolation, |n| {
if let NodeKind::Path { path, .. } = &n.kind {
if let NodeKind::Path { path, guide, .. } = &n.kind
&& (cx.guides || !*guide)
{
let v: Vec<AnchorRef> = path.anchors().filter(|(_, _, a)| r.contains(a.p)).map(|(s, i, _)| (s, i)).collect();
if !v.is_empty() {
sel.push((n.id, v));
@@ -1773,7 +1776,7 @@ impl DirectSelectionTool {
}
// Objects without anchors to pick (type, images, symbols…) are selected whole when
// the marquee touches them, as with the Selection tool (#927).
for id in vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline) {
for id in vectorcraft_doc::hit::marquee_in_view(cx.doc, r, cx.isolation, true, cx.outline, !cx.guides) {
let whole = cx.doc.node(id).is_some_and(|n| !matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }));
if whole && !sel.iter().any(|(s, _)| *s == id) && !framed.iter().any(|(f, _)| *f == id) && !meshed.contains(&id) && spined != Some(id) {
sel.push((id, vec![]));
@@ -1785,7 +1788,8 @@ impl DirectSelectionTool {
let mut crossed: Vec<(NodeId, Vec<AnchorRef>)> = vec![];
if !self.group {
walk_pickable(cx.doc, cx.isolation, |n| {
if let NodeKind::Path { path, .. } = &n.kind
if let NodeKind::Path { path, guide, .. } = &n.kind
&& (cx.guides || !*guide)
&& editable(n.id)
{
let segs = crossed_segments(path, r);
+27
View File
@@ -2767,3 +2767,30 @@ fn outline_view_marquees_measure_clipped_art_by_the_plain_clipping_path() {
let a = marquee(false);
assert!(!selects(&a), "preview: {a:?}");
}
/// #8538: while guides are locked or hidden (`guides` off), a Direct Selection marquee takes
/// neither the anchors nor the crossed segments of a guide path; while guides can be picked, it
/// takes them as on any path.
#[test]
fn a_marquee_skips_the_anchors_and_segments_of_guides_that_cannot_be_picked() {
let (mut d, id) = doc_with_rect();
if let Some(NodeKind::Path { guide, .. }) = d.node_mut(id).map(|n| &mut n.kind) {
*guide = true;
}
let (s, p) = (Selection::default(), paint());
let marquee = |guides: bool, from: (f64, f64), to: (f64, f64)| {
let cx = ToolContext { guides, ..cx(&d, &s, &p) };
let mut t = DirectSelectionTool::new(false);
t.pointer(&cx, &PointerEvent::new(PointerKind::Down, from.0, from.1));
t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, to.0, to.1));
t.pointer(&cx, &PointerEvent::new(PointerKind::Up, to.0, to.1))
};
let anchors = |items: Value| vec![Action::Exec("select.anchorsMany".into(), json!({"items": items, "mode": "set"}))];
// Over the corner at (200, 100).
assert_eq!(marquee(false, (150.0, 50.0), (250.0, 150.0)), anchors(json!([])), "locked or hidden: no anchor");
assert_eq!(marquee(true, (150.0, 50.0), (250.0, 150.0)), anchors(json!([{"id": id.0, "anchors": [[0, 1]]}])), "shown and unlocked");
// Across the middle of the top edge.
let crossed = |a: &[Action]| a.iter().any(|a| matches!(a, Action::Exec(c, _) if c == "select.segments"));
assert!(!crossed(&marquee(false, (140.0, 80.0), (160.0, 120.0))), "locked or hidden: no segment");
assert!(crossed(&marquee(true, (140.0, 80.0), (160.0, 120.0))), "shown and unlocked");
}
+7 -2
View File
@@ -596,7 +596,12 @@ fn with_object_bounds<R>(cx: &ToolContext, walk: impl FnOnce(&mut dyn FnMut(Node
pub(crate) fn inside(cx: &ToolContext, r: Rect, ids: Vec<NodeId>) -> Vec<NodeId> {
let symbols = cx.doc.symbol_boxes();
let within = |b: Rect| r.min_x() <= b.min_x() && b.max_x() <= r.max_x() && r.min_y() <= b.min_y() && b.max_y() <= r.max_y();
ids.into_iter().filter(|id| cx.doc.node(*id).and_then(|n| n.geometric_bounds_with(&symbols)).is_some_and(within)).collect()
// Locked or hidden guides, which the marquee leaves out, don't count toward a group's box (#8538).
let measure = |n: &vectorcraft_doc::Node| match n.without_guides().filter(|_| !cx.guides) {
Some(art) => art.geometric_bounds_with(&symbols),
None => n.geometric_bounds_with(&symbols),
};
ids.into_iter().filter(|id| cx.doc.node(*id).and_then(measure).is_some_and(within)).collect()
}
/// What of the bounding box is under the pointer.
@@ -1199,7 +1204,7 @@ impl Tool for SelectionTool {
if r.width() < Self::drag_threshold(cx) && r.height() < Self::drag_threshold(cx) {
return if toggle { vec![] } else { vec![Action::Exec("select.none".into(), json!({}))] };
}
let touched = marquee_in_view(cx.doc, r, cx.isolation, false, cx.outline);
let touched = marquee_in_view(cx.doc, r, cx.isolation, false, cx.outline, !cx.guides);
let enclosed = marquee_enclosed(cx, enclosed, marquee_direction(cx, start, p, directional_inside));
let ids = if enclosed { inside(cx, r, touched) } else { touched };
let art = Action::Exec(if toggle { "select.toggle" } else { "select.set" }.into(), json!({ "ids": json_ids(&ids) }));
+61 -1
View File
@@ -1,6 +1,6 @@
use super::*;
use crate::testutil::*;
use vectorcraft_doc::Selection;
use vectorcraft_doc::{Document, NodeKind, Selection};
/// While an opacity mask is edited, a press on a selected Shaper original shape moves it, over the
/// art the group shows and over a part of the shape the group does not show. A press on an original
@@ -146,6 +146,66 @@ fn a_press_where_a_mask_hides_a_selected_object_drags_it() {
assert!(a.iter().any(|a| matches!(a, Action::Exec(c, v) if c == "select.set" && v["ids"] == json!([front.0]))), "{a:?}");
}
/// #8538: while guides are locked or hidden (`guides` off), a Selection tool marquee that touches
/// only a guide path in a group selects nothing, so a drag can't move the guide; one that touches
/// the group's other member selects the group. With guides unlocked, the guide takes the group.
#[test]
fn a_marquee_over_a_locked_guide_in_a_group_selects_nothing() {
let mut d = Document::new(800.0, 600.0);
let l = d.layers[0].id;
let (gid, guide_id, art_id) = (d.alloc_id(), d.alloc_id(), d.alloc_id());
let mut guide = vectorcraft_doc::Node::path(
guide_id,
vectorcraft_geom::shapes::rectangle(Rect::new(100.0, 100.0, 120.0, 120.0)),
vectorcraft_doc::Appearance::default_art(),
);
if let NodeKind::Path { guide, .. } = &mut guide.kind {
*guide = true;
}
let art = vectorcraft_doc::Node::path(
art_id,
vectorcraft_geom::shapes::rectangle(Rect::new(300.0, 100.0, 320.0, 120.0)),
vectorcraft_doc::Appearance::default_art(),
);
d.insert(Some(l), 0, vectorcraft_doc::Node::group(gid, vec![std::sync::Arc::new(guide), std::sync::Arc::new(art)])).unwrap();
let (none, p) = (Selection::default(), paint());
let marquee = |guides: bool, x0: f64, x1: f64| {
let c = ToolContext { guides, ..cx(&d, &none, &p) };
let mut t = SelectionTool::default();
t.pointer(&c, &ev(PointerKind::Down, x0, 50.0));
t.pointer(&c, &ev(PointerKind::Drag, x1, 110.0));
let up = t.pointer(&c, &ev(PointerKind::Up, x1, 110.0));
up.iter().find_map(|a| match a {
Action::Exec(c, v) if c == "select.set" => Some(v["ids"].clone()),
_ => None,
})
};
assert_eq!(marquee(false, 90.0, 130.0), Some(json!([])), "locked: only the guide");
assert_eq!(marquee(false, 290.0, 330.0), Some(json!([gid.0])), "locked: the group's art");
assert_eq!(marquee(true, 90.0, 130.0), Some(json!([gid.0])), "unlocked: the guide");
}
/// #8538: an enclosing marquee measures a group without the locked or hidden guides in it, as the
/// marquee leaves them out: a group whose art lies inside is taken though a guide in it reaches
/// past the marquee. While guides can be picked, the guide counts.
#[test]
fn an_enclosing_marquee_measures_a_group_without_its_locked_guides() {
let mut d = Document::new(800.0, 600.0);
let l = d.layers[0].id;
let (gid, guide_id, art_id) = (d.alloc_id(), d.alloc_id(), d.alloc_id());
let square = |id, r| vectorcraft_doc::Node::path(id, vectorcraft_geom::shapes::rectangle(r), vectorcraft_doc::Appearance::default_art());
let mut guide = square(guide_id, Rect::new(500.0, 100.0, 520.0, 120.0));
if let NodeKind::Path { guide, .. } = &mut guide.kind {
*guide = true;
}
let art = square(art_id, Rect::new(100.0, 100.0, 120.0, 120.0));
d.insert(Some(l), 0, vectorcraft_doc::Node::group(gid, vec![std::sync::Arc::new(guide), std::sync::Arc::new(art)])).unwrap();
let (none, p) = (Selection::default(), paint());
let r = Rect::new(50.0, 50.0, 200.0, 200.0);
assert_eq!(crate::select::inside(&ToolContext { guides: false, ..cx(&d, &none, &p) }, r, vec![gid]), [gid], "locked or hidden");
assert!(crate::select::inside(&ToolContext { guides: true, ..cx(&d, &none, &p) }, r, vec![gid]).is_empty(), "shown and unlocked");
}
/// #955: grabbed by an anchor and dropped near another object's anchor, the anchor lands
/// exactly on it with Smart Guides, even where lining the bounds up would leave it beside it.
#[test]
+3 -2
View File
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+3 -2
View File
File diff suppressed because one or more lines are too long