Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Use Preview Bounds: a clip group is measured where its clipping path's stroke paints

dotCooCood532e6d341b2
diff --git a/crates/effects/src/preview.rs b/crates/effects/src/preview.rs
index ca379e570..a2f0daef6 100644
--- a/crates/effects/src/preview.rs
+++ b/crates/effects/src/preview.rs
@@ -8,7 +8,9 @@
//! their own, or with a fill or stroke of their own that has geometry effects or paints members
//! with geometry effects, are given as their evaluated art ([`evaluate_container`]). Blends,
//! envelopes and repeats whose objects have geometry effects are given as their evaluated art
-//! ([`expanded_live_group`]), with each of those objects given as its own art. Fills and
+//! ([`expanded_live_group`]), with each of those objects given as its own art. A clip group or
+//! layer whose clipping path has strokes with geometry effects is given as that path's geometry
+//! before its effects, which the renderer clips by, and those strokes as drawn. Fills and
//! strokes that paint nothing (hidden, or painted None) are left out. [`bounds_of`],
//! [`oriented_bounds`] and [`anchor_bounds`] measure the visual bounds of that art, strokes
//! included, where [`Document::bounds_of`], [`Document::oriented_bounds`] and
@@ -20,6 +22,7 @@ use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::sync::Arc;
+use vectorcraft_doc::color::Paint;
use vectorcraft_doc::{Appearance, AppearanceItem, Document, Node, NodeId, NodeKind, OrientedBox, Selection, SymbolBoxes};
use vectorcraft_geom::{Affine, PathData, Rect, Shape, union_opt};
@@ -85,8 +88,9 @@ pub fn bounds_in(symbols: &SymbolBoxes, n: &Node, a: Affine) -> Option<Rect> {
/// `n` as plain art with the geometry effects in it applied, at every depth, symbol instances
/// measured by `symbols`. Raster effects stay on the art. A group, layer or intertwine without a
-/// clip is rebuilt with the drawn art of each member that has one. `None` when no geometry effect
-/// in `n` changes what it draws.
+/// clip is rebuilt with the drawn art of each member that has one. A clip group or layer becomes a
+/// group of its clipping path without strokes and the drawn art of the path's strokes, when they
+/// have one. `None` when no geometry effect in `n` changes what it draws.
pub fn drawn_art(symbols: &SymbolBoxes, n: &Node) -> Option<Node> {
Drawn::new(symbols).drawn_art(n)
}
@@ -137,10 +141,11 @@ impl<'s, 'd> Drawn<'s, 'd> {
/// See [`drawn_art`].
fn drawn_art(&self, n: &Node) -> Option<Node> {
- let Some(mut art) = self.own_art(n) else { return self.with_drawn_members(n) };
+ let Some(mut art) = self.own_art(n) else { return self.clip_art(n).or_else(|| self.with_drawn_members(n)) };
// The art's members can carry geometry effects of their own: type's fills and strokes, the
- // members of an evaluated group and the objects in a symbol's art.
- if let Some(m) = self.with_drawn_members(&art) {
+ // members of an evaluated group, the clipping path of an evaluated clip group and the
+ // objects in a symbol's art.
+ if let Some(m) = self.clip_art(&art).or_else(|| self.with_drawn_members(&art)) {
art = m;
}
Some(art)
@@ -220,6 +225,33 @@ impl<'s, 'd> Drawn<'s, 'd> {
}
Some(m)
}
+
+ /// Clip group or layer `n` as its clipping path's strokes draw it: a group of the clipping path
+ /// without its strokes, measured as the region it clips to, and its strokes ([`Node::clip_paint`])
+ /// as their [`Self::drawn_art`]. The renderer clips by the clipping path's geometry before its
+ /// geometry effects ([`crate::clip_outline`]) and paints the path's fills inside that region and
+ /// its strokes over the clipped art, unclipped. `None` for any other object, when the clipping
+ /// path is hidden and when its strokes have no drawn art.
+ fn clip_art(&self, n: &Node) -> Option<Node> {
+ if !n.clips() {
+ return None;
+ }
+ let clip = n.children()?.first().filter(|c| c.visible)?;
+ let strokes = self.drawn_art(&clip.clip_paint().stroke?)?;
+ Some(Node::group(n.id, vec![Arc::new(unstroked(clip)), Arc::new(strokes)]))
+ }
+}
+
+/// Clipping path `clip` without its strokes or its characters' strokes.
+fn unstroked(clip: &Node) -> Node {
+ let mut n = clip.clone();
+ n.appearance.items.retain(AppearanceItem::is_fill);
+ if let NodeKind::Text(t) = &mut n.kind {
+ for r in &mut t.runs {
+ r.style.stroke = Paint::None;
+ }
+ }
+ n
}
/// Whether `n` itself has a geometry effect that [`Drawn::own_art`] applies, its own or one of its
diff --git a/crates/engine/src/tests_previewbounds.rs b/crates/engine/src/tests_previewbounds.rs
index d35ef0e30..a8ffe4ee0 100644
--- a/crates/engine/src/tests_previewbounds.rs
+++ b/crates/engine/src/tests_previewbounds.rs
@@ -171,6 +171,46 @@ fn a_groups_own_fill_is_measured_on_its_members_where_they_are() {
assert!(near(s.transform_bounds(&[g]).unwrap(), Rect::new(100.0, 100.0, 300.0, 200.0), 1e-6), "{:?}", s.transform_bounds(&[g]));
}
+#[test]
+fn a_clip_group_is_measured_where_its_clipping_paths_stroke_paints() {
+ // A 200 pt square clipped by a 100 pt square at (100, 100) with Offset Path 20. The clipped art
+ // is clipped by the square without the offset, so the group is measured by that square.
+ let mut s = session();
+ let content = NodeId(run(&mut s, "shape.rectangle", json!({"x": 50, "y": 50, "width": 200, "height": 200}))["id"].as_u64().unwrap());
+ let path = NodeId(run(&mut s, "shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100}))["id"].as_u64().unwrap());
+ run(&mut s, "select.set", json!({"ids": [content.0, path.0]}));
+ let clip = NodeId(run(&mut s, "object.clippingMask.make", json!({}))["id"].as_u64().unwrap());
+ run(&mut s, "effect.apply", json!({"effect": "path.offsetPath", "params": {"offset": 20}, "ids": [path.0], "item": null}));
+ preview(&mut s, true);
+ let square = Rect::new(100.0, 100.0, 200.0, 200.0);
+ assert!(near(s.transform_bounds(&[clip]).unwrap(), square, 1e-6), "{:?}", s.transform_bounds(&[clip]));
+ // A 4 pt stroke on the clipping path paints along the offset shape, over the clipped art, from
+ // 78 to 222.
+ run(&mut s, "paint.setStroke", json!({"ids": [path.0], "color": "#000000"}));
+ run(&mut s, "stroke.set", json!({"ids": [path.0], "weight": 4}));
+ let stroked = Rect::new(78.0, 78.0, 222.0, 222.0);
+ assert!(near(s.transform_bounds(&[clip]).unwrap(), stroked, 1e-6), "{:?}", s.transform_bounds(&[clip]));
+ // A fill of the clip group's own keeps that box.
+ run(&mut s, "appearance.addFill", json!({"ids": [clip.0]}));
+ run(&mut s, "paint.setFill", json!({"ids": [clip.0], "item": 0, "color": "#000000"}));
+ assert!(near(s.transform_bounds(&[clip]).unwrap(), stroked, 1e-6), "with a fill: {:?}", s.transform_bounds(&[clip]));
+ // Turned 30°, the box keeps that size.
+ run(&mut s, "select.set", json!({"ids": [clip.0]}));
+ run(&mut s, "object.rotate", json!({"angle": 30}));
+ let turned = s.transform_box(&[clip]).unwrap();
+ assert!(
+ (turned.angle - 30.0).abs() < 1e-9 && (turned.rect.width() - 144.0).abs() < 1e-6 && (turned.rect.height() - 144.0).abs() < 1e-6,
+ "{turned:?}"
+ );
+ // In a group, the clip group is measured the same way.
+ run(&mut s, "object.rotate", json!({"angle": -30}));
+ let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
+ assert!(near(s.transform_bounds(&[group]).unwrap(), stroked, 1e-6), "{:?}", s.transform_bounds(&[group]));
+ // Without Use Preview Bounds, the clipping path's geometry is measured.
+ preview(&mut s, false);
+ assert!(near(s.transform_bounds(&[clip]).unwrap(), square, 1e-6), "{:?}", s.transform_bounds(&[clip]));
+}
+
#[test]
fn only_fills_and_strokes_that_paint_are_measured() {
let item = |s: &Session, id: NodeId, fill: bool| {