GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! Symbolism tools (Symbol Sprayer, Shifter, Scruncher, Sizer, Spinner, Stainer, Screener,
//! Styler) and the brush-aware Paintbrush.
//!
//! Symbolism gestures preview one command (`symbol.spray` / `symbol.adjust`) with every point of
//! the drag so far, re-applied on the interaction snapshot, and commit on release — one undo
//! step, replayable from the journal. The Paintbrush wraps the freehand gesture tool and turns its
//! `path.freehand` previews into `brush.freehand` when a brush is current (tool option `brush`,
//! else the document's current brush).

use serde_json::{Value, json};
use vectorcraft_geom::{Point, Shape};

use crate::draw2::{FEEDBACK, GestureTool, points_json};
use crate::{Action, Cursor, MAX_STROKE_SAMPLES, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey, previews_at};

/// Create a symbolism tool or the brush-aware Paintbrush (None = not one of ours).
pub fn create(id: &str) -> Option<Box<dyn Tool>> {
    Some(match id {
        "paintbrush" => Box::new(BrushPaintTool::default()),
        "symbolSprayer" | "symbolShifter" | "symbolScruncher" | "symbolSizer" | "symbolSpinner" | "symbolStainer" | "symbolScreener"
        | "symbolStyler" => Box::new(SymbolismTool::new(id)),
        _ => return None,
    })
}

/// The values of Method in the Symbolism Tools Options.
pub const METHODS: [&str; 3] = ["userDefined", "average", "random"];

/// The values of each Symbol Sprayer option in the Symbolism Tools Options.
pub const SPRAY_MODES: [&str; 2] = ["average", "userDefined"];

/// The Symbol Sprayer options: (tool option, key in `symbol.spray`'s `attributes`).
pub const SPRAY_ATTRIBUTES: [(&str, &str); 6] = [
    ("sprayScrunch", "scrunch"),
    ("spraySize", "size"),
    ("spraySpin", "spin"),
    ("sprayScreen", "screen"),
    ("sprayStain", "stain"),
    ("sprayStyle", "style"),
];

pub struct SymbolismTool {
    id: &'static str,
    /// The drag's points, each with its pen pressure (0..1).
    points: Vec<(Point, f64)>,
    /// How many points the last preview had ([`previews_at`] thins previews of a long drag).
    previewed: usize,
    active: bool,
    hover: Option<Point>,
    alt: bool,
    /// Brush diameter in points.
    pub diameter: f64,
    /// 1..10.
    pub intensity: f64,
    /// Symbol set density 1..10 (Sprayer).
    pub density: f64,
    /// Symbol to spray (None = the document's current symbol).
    pub symbol: Option<String>,
    /// Graphic style for the Styler (None = the document's first non-default style).
    pub style: Option<String>,
    /// Use Pressure Pen: each point's pen pressure is the intensity there.
    pub use_pressure: bool,
    /// Method of the Scruncher, Sizer, Spinner, Stainer, Screener and Styler: one of [`METHODS`].
    pub method: &'static str,
    /// Show Brush Size and Intensity: the brush outline follows the pointer.
    pub show_brush: bool,
    /// The Symbol Sprayer options, in the order of [`SPRAY_ATTRIBUTES`]: each one of [`SPRAY_MODES`].
    pub spray: [&'static str; 6],
    /// Symbol Sizer: Proportional Resizing.
    pub proportional: bool,
    /// Symbol Sizer: Resizing Affects Density.
    pub affects_density: bool,
}

/// Checks the Symbolism Tools Options in `values` before `tool.setOption` sets any, when `tool` is
/// a symbolism tool, with the tool's own checks ([`Tool::check_option`]): a number out of its
/// range, `method` that is not one of [`METHODS`], a Symbol Sprayer option that is not one of
/// [`SPRAY_MODES`], and `usePressure`, `showBrush`, `proportional` or `affectsDensity` that is not
/// true or false are errors. Ok for every other tool, and for a key the tool does not report
/// (`tool.setOption` refuses that one as an unknown option). Saved settings go to the tool's
/// `set_option` instead, which skips a value it cannot read.
pub fn check_options(tool: &str, values: &serde_json::Map<String, Value>) -> Result<(), String> {
    if !tool.starts_with("symbol") || create(tool).is_none() {
        return Ok(());
    }
    let tool = SymbolismTool::new(tool);
    let known = tool.options();
    values.iter().filter(|(key, _)| known.get(key.as_str()).is_some()).try_for_each(|(key, v)| tool.check_option(key, v))
}

/// `v` as one of `allowed`, when it is one.
fn one_of(v: &Value, allowed: &[&'static str]) -> Option<&'static str> {
    let s = v.as_str()?;
    allowed.iter().copied().find(|a| *a == s)
}

impl SymbolismTool {
    pub fn new(id: &str) -> Self {
        let id: &'static str = match id {
            "symbolShifter" => "symbolShifter",
            "symbolScruncher" => "symbolScruncher",
            "symbolSizer" => "symbolSizer",
            "symbolSpinner" => "symbolSpinner",
            "symbolStainer" => "symbolStainer",
            "symbolScreener" => "symbolScreener",
            "symbolStyler" => "symbolStyler",
            _ => "symbolSprayer",
        };
        Self {
            id,
            points: vec![],
            previewed: 0,
            active: false,
            hover: None,
            alt: false,
            diameter: 80.0,
            intensity: 5.0,
            density: 5.0,
            symbol: None,
            style: None,
            use_pressure: false,
            method: "userDefined",
            show_brush: true,
            spray: ["average"; 6],
            proportional: true,
            affects_density: false,
        }
    }

    fn label(&self) -> &'static str {
        match self.id {
            "symbolShifter" => "Symbol Shifter",
            "symbolScruncher" => "Symbol Scruncher",
            "symbolSizer" => "Symbol Sizer",
            "symbolSpinner" => "Symbol Spinner",
            "symbolStainer" => "Symbol Stainer",
            "symbolScreener" => "Symbol Screener",
            "symbolStyler" => "Symbol Styler",
            _ => "Symbol Sprayer",
        }
    }

    /// The command + params for the gesture so far.
    pub fn command(&self, cx: &ToolContext) -> (String, Value) {
        let radius = self.diameter / 2.0;
        if self.id == "symbolSprayer" {
            let pts = points_json(&self.points.iter().map(|(p, _)| *p).collect::<Vec<_>>());
            let attributes: serde_json::Map<String, Value> =
                SPRAY_ATTRIBUTES.iter().zip(self.spray).map(|((_, key), mode)| (key.to_string(), json!(mode))).collect();
            let mut v = json!({"points": pts, "radius": radius, "density": self.density, "alt": self.alt, "attributes": attributes});
            if let Some(s) = &self.symbol {
                v["name"] = json!(s);
            }
            // Stain: User Defined stains the new instances with the fill color in its own model.
            if self.spray[4] == "userDefined"
                && let Some(c) = cx.paint.fill.color()
            {
                v["color"] = serde_json::to_value(c).unwrap_or(Value::Null);
                v["keepModel"] = json!(true);
            }
            // A style the document no longer has (a deleted one) is left out: the default style applies.
            if let Some(s) = self.style.as_ref().filter(|s| cx.doc.graphic_styles.iter().any(|g| g.name == **s)) {
                v["style"] = json!(s);
            }
            return ("symbol.spray".into(), v);
        }
        let pressure = self.use_pressure;
        let pts = Value::Array(self.points.iter().map(|(p, f)| if pressure { json!([p.x, p.y, f]) } else { json!([p.x, p.y]) }).collect());
        let tool = match self.id {
            "symbolShifter" => "shift",
            "symbolScruncher" => "scrunch",
            "symbolSizer" => "size",
            "symbolSpinner" => "spin",
            "symbolStainer" => "stain",
            "symbolScreener" => "screen",
            _ => "style",
        };
        let mut v = json!({"tool": tool, "points": pts, "radius": radius, "intensity": self.intensity, "alt": self.alt});
        if tool == "stain"
            && let Some(c) = cx.paint.fill.color()
        {
            v["color"] = serde_json::to_value(c).unwrap_or(Value::Null);
            v["keepModel"] = json!(true);
        }
        if let Some(s) = &self.style {
            v["style"] = json!(s);
        }
        if pressure {
            v["usePressure"] = json!(true);
        }
        // The Symbol Shifter has no Method.
        if tool != "shift" {
            v["method"] = json!(self.method);
        }
        if tool == "size" {
            v["proportional"] = json!(self.proportional);
            v["affectsDensity"] = json!(self.affects_density);
        }
        ("symbol.adjust".into(), v)
    }
}

impl SymbolismTool {
    /// Ends the drag: what is committed is the last preview, so the whole drag is shown first.
    fn finish(&mut self, cx: &ToolContext) -> Vec<Action> {
        self.active = false;
        let stale = (self.previewed != self.points.len()).then(|| {
            let (c, v) = self.command(cx);
            Action::Preview(c, v)
        });
        self.points.clear();
        stale.into_iter().chain([Action::Commit]).collect()
    }
}

impl Tool for SymbolismTool {
    fn id(&self) -> &'static str {
        self.id
    }
    fn busy(&self) -> bool {
        self.active
    }
    fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
        let p = ev.pos;
        self.hover = Some(p);
        let sample = (p, f64::from(ev.pressure).clamp(0.0, 1.0));
        match ev.kind {
            PointerKind::Down => {
                self.points = vec![sample];
                self.previewed = 1;
                self.active = true;
                self.alt = ev.mods.alt;
                let (c, v) = self.command(cx);
                vec![Action::Begin(self.label().into()), Action::Preview(c, v)]
            }
            PointerKind::Drag if self.active => {
                // Sprayer: thin the samples to a fraction of the brush; others: every few pixels.
                let step = if self.id == "symbolSprayer" { (self.diameter * 0.15).max(cx.tol(3.0)) } else { cx.tol(3.0) };
                // With Use Pressure Pen a change of pressure of at least 0.05 is kept where the pen
                // stays (the Sprayer does not use the pressure).
                let pressed = self.use_pressure && self.id != "symbolSprayer";
                let thinned = self.points.last().is_some_and(|(l, f)| l.distance(p) < step && !(pressed && (sample.1 - f).abs() >= 0.05));
                // Each preview carries every point so far: a long drag stops growing and previews less often.
                if self.points.len() >= MAX_STROKE_SAMPLES || thinned {
                    return vec![];
                }
                self.points.push(sample);
                if !previews_at(self.points.len()) {
                    return vec![];
                }
                self.previewed = self.points.len();
                let (c, v) = self.command(cx);
                vec![Action::Preview(c, v)]
            }
            PointerKind::Up if self.active => self.finish(cx),
            _ => vec![],
        }
    }
    fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
        matches!(key, ToolKey::BracketLeft | ToolKey::BracketRight)
    }
    fn key(&mut self, _cx: &ToolContext, key: ToolKey, m: Mods) -> Vec<Action> {
        match key {
            ToolKey::BracketLeft if m.shift => self.intensity = (self.intensity - 1.0).max(1.0),
            ToolKey::BracketRight if m.shift => self.intensity = (self.intensity + 1.0).min(10.0),
            ToolKey::BracketLeft => self.diameter = (self.diameter - 10.0).max(2.0),
            ToolKey::BracketRight => self.diameter = (self.diameter + 10.0).min(2000.0),
            ToolKey::Escape if self.active => {
                self.active = false;
                self.points.clear();
                return vec![Action::Cancel];
            }
            _ => {}
        }
        vec![]
    }
    fn deactivate(&mut self, cx: &ToolContext) -> Vec<Action> {
        if self.active {
            return self.finish(cx);
        }
        vec![]
    }
    fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {
        let Some(p) = self.hover.filter(|_| self.show_brush) else { return vec![] };
        let ring = |radius: f64, dashed| Overlay::Path { path: kurbo::Circle::new(p, radius).to_path(0.1), color: FEEDBACK, width: 1.0, dashed };
        let mut v = vec![ring(self.diameter / 2.0, false)];
        // The intensity: a dashed ring that fills the brush at 10. A pen's pressure sets it instead
        // with Use Pressure Pen, so no ring is drawn then. The Symbol Sprayer uses neither, so it
        // draws no ring.
        if self.id != "symbolSprayer" && !self.use_pressure && self.intensity < 10.0 {
            v.push(ring(self.diameter / 2.0 * self.intensity / 10.0, true));
        }
        v
    }
    fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {
        match self.id {
            "symbolShifter" => Cursor::SymbolShifter,
            "symbolScruncher" => Cursor::SymbolScruncher,
            "symbolSizer" => Cursor::SymbolSizer,
            "symbolSpinner" => Cursor::SymbolSpinner,
            "symbolStainer" => Cursor::SymbolStainer,
            "symbolScreener" => Cursor::SymbolScreener,
            "symbolStyler" => Cursor::SymbolStyler,
            _ => Cursor::SymbolSprayer,
        }
    }
    fn options(&self) -> Value {
        let mut v = json!({
            "diameter": self.diameter,
            "intensity": self.intensity,
            "density": self.density,
            "symbol": self.symbol,
            "style": self.style,
            "usePressure": self.use_pressure,
            "method": self.method,
            "showBrush": self.show_brush,
            "proportional": self.proportional,
            "affectsDensity": self.affects_density,
        });
        for ((key, _), mode) in SPRAY_ATTRIBUTES.iter().zip(self.spray) {
            v[*key] = json!(mode);
        }
        v
    }
    fn set_option(&mut self, key: &str, v: &Value) {
        match key {
            "diameter" => self.diameter = v.as_f64().unwrap_or(self.diameter).clamp(2.0, 2000.0),
            "intensity" => self.intensity = v.as_f64().unwrap_or(self.intensity).clamp(1.0, 10.0),
            "density" => self.density = v.as_f64().unwrap_or(self.density).clamp(1.0, 10.0),
            "symbol" => self.symbol = v.as_str().map(str::to_string),
            "style" => self.style = v.as_str().map(str::to_string),
            "usePressure" => self.use_pressure = v.as_bool().unwrap_or(self.use_pressure),
            "method" => self.method = one_of(v, &METHODS).unwrap_or(self.method),
            "showBrush" => self.show_brush = v.as_bool().unwrap_or(self.show_brush),
            "proportional" => self.proportional = v.as_bool().unwrap_or(self.proportional),
            "affectsDensity" => self.affects_density = v.as_bool().unwrap_or(self.affects_density),
            _ => {
                if let Some(i) = SPRAY_ATTRIBUTES.iter().position(|(k, _)| *k == key) {
                    self.spray[i] = one_of(v, &SPRAY_MODES).unwrap_or(self.spray[i]);
                }
            }
        }
    }
    fn check_option(&self, key: &str, v: &Value) -> Result<(), String> {
        use crate::option_check as c;
        let must_be = |names: &[&str]| format!("`{key}` must be one of {}", names.join(", "));
        match key {
            "diameter" => c::number(key, v, 2.0, 2000.0),
            "intensity" | "density" => c::number(key, v, 1.0, 10.0),
            "symbol" | "style" => c::string_or_null(key, v),
            "usePressure" | "showBrush" | "proportional" | "affectsDensity" => c::boolean(key, v),
            "method" => one_of(v, &METHODS).map(drop).ok_or_else(|| must_be(&METHODS)),
            k if SPRAY_ATTRIBUTES.iter().any(|(a, _)| *a == k) => one_of(v, &SPRAY_MODES).map(drop).ok_or_else(|| must_be(&SPRAY_MODES)),
            _ => Err(c::unknown(key)),
        }
    }
}

/// Paintbrush: the freehand gesture, painting with the current brush.
pub struct BrushPaintTool {
    inner: GestureTool,
    /// Brush override (None = the document's current brush, if any).
    pub brush: Option<String>,
}

impl Default for BrushPaintTool {
    fn default() -> Self {
        Self { inner: GestureTool::new("paintbrush"), brush: None }
    }
}

impl BrushPaintTool {
    /// The tool's brush, else the document's current brush, skipping a name the document's brush
    /// library no longer has (a deleted brush), so the stroke is drawn without it.
    fn brush_name(&self, cx: &ToolContext) -> Option<String> {
        [self.brush.clone(), vectorcraft_brush::current(cx.doc)].into_iter().flatten().find(|n| vectorcraft_brush::find(cx.doc, n).is_some())
    }
    fn map(&self, cx: &ToolContext, acts: Vec<Action>) -> Vec<Action> {
        if !acts.iter().any(|a| matches!(a, Action::Preview(c, _) if c == "path.freehand")) {
            return acts;
        }
        let Some(b) = self.brush_name(cx) else { return acts };
        acts.into_iter()
            .map(|a| match a {
                Action::Preview(c, mut v) if c == "path.freehand" => {
                    v["brush"] = json!(b);
                    Action::Preview("brush.freehand".into(), v)
                }
                o => o,
            })
            .collect()
    }
}

impl Tool for BrushPaintTool {
    fn id(&self) -> &'static str {
        "paintbrush"
    }
    fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
        let acts = self.inner.pointer(cx, ev);
        self.map(cx, acts)
    }
    fn claims_key(&self, cx: &ToolContext, key: ToolKey) -> bool {
        self.inner.claims_key(cx, key)
    }
    fn key(&mut self, cx: &ToolContext, key: ToolKey, m: Mods) -> Vec<Action> {
        let acts = self.inner.key(cx, key, m);
        self.map(cx, acts)
    }
    fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
        self.inner.overlays(cx)
    }
    fn cursor(&self, cx: &ToolContext, p: Point, m: Mods) -> Cursor {
        self.inner.cursor(cx, p, m)
    }
    fn options(&self) -> Value {
        let mut v = self.inner.options();
        v["brush"] = json!(self.brush);
        v
    }
    fn set_option(&mut self, key: &str, v: &Value) {
        if key == "brush" {
            self.brush = v.as_str().map(str::to_string);
        } else {
            self.inner.set_option(key, v);
        }
    }
    fn check_option(&self, key: &str, v: &Value) -> Result<(), String> {
        if key == "brush" { crate::option_check::string_or_null(key, v) } else { self.inner.check_option(key, v) }
    }
    fn wants_samples(&self) -> bool {
        self.inner.wants_samples()
    }
    fn busy(&self) -> bool {
        self.inner.busy()
    }
    fn readout(&self, cx: &ToolContext) -> Option<crate::Readout> {
        Some(crate::Readout::Brush { name: self.brush_name(cx) })
    }
    fn deactivate(&mut self, cx: &ToolContext) -> Vec<Action> {
        let acts = self.inner.deactivate(cx);
        self.map(cx, acts)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testutil::*;
    use vectorcraft_doc::Selection;

    #[test]
    fn sprayer_previews_all_points_and_commits() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolSprayer");
        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
        assert_eq!(a[0], Action::Begin("Symbol Sprayer".into()));
        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 50.0, 0.0));
        assert!(matches!(&a[0], Action::Preview(c, v) if c == "symbol.spray" && v["points"].as_array().unwrap().len() == 2));
        assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 51.0, 0.0)).is_empty(), "thinned");
        assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 51.0, 0.0)), vec![Action::Commit]);
        assert!(!t.busy());
    }

    #[test]
    fn a_long_drag_previews_less_often_and_commits_all_of_it() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolShifter");
        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
        let n = 7 * crate::PREVIEW_ALL_UNTIL + 1; // not a point that previews
        let previews = (1..n).filter(|&i| !t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 50.0 * i as f64, 0.0)).is_empty()).count();
        assert!(previews < n * 3 / 4, "{previews} previews of {n} points");
        let up = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 0.0, 0.0));
        let last = up.iter().rev().nth(1);
        assert!(matches!(last, Some(Action::Preview(_, v)) if v["points"].as_array().unwrap().len() == n), "{up:?}");
        assert_eq!(up.last(), Some(&Action::Commit));
    }

    #[test]
    fn switching_tools_mid_drag_previews_the_whole_drag_before_committing() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolShifter");
        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
        let n = 7 * crate::PREVIEW_ALL_UNTIL + 1; // not a point that previews
        for i in 1..n {
            t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 50.0 * i as f64, 0.0));
        }
        let a = t.deactivate(&cx);
        assert!(matches!(a.first(), Some(Action::Preview(_, v)) if v["points"].as_array().unwrap().len() == n), "{a:?}");
        assert_eq!(a.last(), Some(&Action::Commit));
        assert!(!t.busy());
    }

    #[test]
    fn adjust_tools_map_to_symbol_adjust() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        for (id, tool) in [("symbolShifter", "shift"), ("symbolSizer", "size"), ("symbolStainer", "stain"), ("symbolStyler", "style")] {
            let mut t = create(id).unwrap();
            assert_eq!(t.id(), id);
            let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 5.0, 5.0).with_mods(Mods { alt: true, ..Default::default() }));
            assert!(matches!(&a[1], Action::Preview(c, v) if c == "symbol.adjust" && v["tool"] == tool && v["alt"] == true), "{a:?}");
        }
        // The Symbol Stainer sends the fill color in its own model.
        let fill = serde_json::to_value(p.fill.color().unwrap()).unwrap();
        let a = create("symbolStainer").unwrap().pointer(&cx, &PointerEvent::new(PointerKind::Down, 5.0, 5.0));
        assert!(matches!(&a[1], Action::Preview(_, v) if v["color"] == fill && v["keepModel"] == true), "{a:?}");
    }

    /// The Symbolism Tools Options the tools keep, with what each is before it is set.
    #[test]
    fn the_options_dialog_fields_are_tool_options() {
        let mut t = SymbolismTool::new("symbolSizer");
        let o = t.options();
        assert_eq!((o["usePressure"].clone(), o["method"].clone(), o["showBrush"].clone()), (json!(false), json!("userDefined"), json!(true)));
        assert_eq!((o["proportional"].clone(), o["affectsDensity"].clone()), (json!(true), json!(false)));
        for (key, _) in SPRAY_ATTRIBUTES {
            assert_eq!(o[key], "average", "{key}");
        }
        for (key, v) in [
            ("usePressure", json!(true)),
            ("method", json!("random")),
            ("showBrush", json!(false)),
            ("proportional", json!(false)),
            ("affectsDensity", json!(true)),
            ("sprayStain", json!("userDefined")),
        ] {
            t.set_option(key, &v);
            assert_eq!(t.options()[key], v, "{key}");
        }
        // A value that is none of an option's choices leaves it as it was.
        for (key, v) in [("method", json!("smooth")), ("method", json!(2)), ("sprayStain", json!("random")), ("usePressure", json!("yes"))] {
            let before = t.options();
            t.set_option(key, &v);
            assert_eq!(t.options(), before, "{key}: {v}");
        }
    }

    /// The adjusting tools send the Method (the Shifter has none), the Sizer its two options, and
    /// with Use Pressure Pen each point's pen pressure.
    #[test]
    fn adjust_tools_send_the_method_the_sizer_options_and_the_pen_pressure() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let press = |t: &mut SymbolismTool| {
            let down = PointerEvent { pressure: 0.25, ..PointerEvent::new(PointerKind::Down, 5.0, 5.0) };
            match t.pointer(&cx, &down).swap_remove(1) {
                Action::Preview(_, v) => v,
                other => panic!("{other:?}"),
            }
        };
        let mut sizer = SymbolismTool::new("symbolSizer");
        let v = press(&mut sizer);
        assert_eq!((v["method"].clone(), v["proportional"].clone(), v["affectsDensity"].clone()), (json!("userDefined"), json!(true), json!(false)));
        assert_eq!((v["points"].clone(), v.get("usePressure")), (json!([[5.0, 5.0]]), None));
        sizer.set_option("usePressure", &json!(true));
        sizer.set_option("method", &json!("average"));
        sizer.set_option("affectsDensity", &json!(true));
        let v = press(&mut sizer);
        assert_eq!((v["points"].clone(), v["usePressure"].clone()), (json!([[5.0, 5.0, 0.25]]), json!(true)));
        assert_eq!((v["method"].clone(), v["affectsDensity"].clone()), (json!("average"), json!(true)));
        let mut shifter = SymbolismTool::new("symbolShifter");
        shifter.set_option("method", &json!("random"));
        let v = press(&mut shifter);
        assert!(v.get("method").is_none() && v.get("proportional").is_none(), "{v}");
        let mut spinner = SymbolismTool::new("symbolSpinner");
        spinner.set_option("method", &json!("random"));
        let v = press(&mut spinner);
        assert!(v["method"] == "random" && v.get("proportional").is_none(), "{v}");
    }

    /// With Use Pressure Pen a drag sample where the pen stays is kept when the pressure changes;
    /// without it, or with the same pressure, the drag keeps thinning the samples by distance.
    #[test]
    fn a_pressure_change_where_the_pen_stays_is_kept() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let stroke = |use_pressure: bool, pressures: [f32; 3]| {
            let mut t = SymbolismTool::new("symbolSizer");
            t.set_option("usePressure", &json!(use_pressure));
            let at = |kind, pressure| PointerEvent { pressure, ..PointerEvent::new(kind, 5.0, 5.0) };
            let events =
                [(PointerKind::Down, pressures[0]), (PointerKind::Drag, pressures[1]), (PointerKind::Drag, pressures[2]), (PointerKind::Up, 0.0)];
            // The points of the last preview, the one the drag commits.
            let mut last = Value::Null;
            for (kind, pressure) in events {
                for a in t.pointer(&cx, &at(kind, pressure)) {
                    if let Action::Preview(_, v) = a {
                        last = v["points"].clone();
                    }
                }
            }
            last
        };
        assert_eq!(stroke(true, [0.0, 1.0, 1.0]), json!([[5.0, 5.0, 0.0], [5.0, 5.0, 1.0]]));
        assert_eq!(stroke(true, [0.5, 0.52, 0.5]), json!([[5.0, 5.0, 0.5]]));
        assert_eq!(stroke(false, [0.0, 1.0, 1.0]), json!([[5.0, 5.0]]));
    }

    /// The Sprayer sends its six options as `attributes`, and the fill color only while Stain is
    /// User Defined.
    #[test]
    fn the_sprayer_sends_its_attributes() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolSprayer");
        t.set_option("usePressure", &json!(true));
        let spray = |t: &mut SymbolismTool| match t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 5.0, 5.0)).swap_remove(1) {
            Action::Preview(c, v) if c == "symbol.spray" => v,
            other => panic!("{other:?}"),
        };
        let v = spray(&mut t);
        let average =
            json!({"scrunch": "average", "size": "average", "spin": "average", "screen": "average", "stain": "average", "style": "average"});
        assert_eq!((v["attributes"].clone(), v.get("color"), v["points"].clone()), (average, None, json!([[5.0, 5.0]])));
        t.set_option("sprayStain", &json!("userDefined"));
        t.set_option("spraySpin", &json!("userDefined"));
        let v = spray(&mut t);
        assert_eq!(
            (v["attributes"]["stain"].clone(), v["attributes"]["spin"].clone(), v["attributes"]["size"].clone()),
            (json!("userDefined"), json!("userDefined"), json!("average"))
        );
        assert_eq!((v["color"].clone(), v["keepModel"].clone()), (serde_json::to_value(p.fill.color().unwrap()).unwrap(), json!(true)));
    }

    /// Show Brush Size and Intensity: the brush's outline with a dashed ring for the intensity
    /// inside it; no ring with Use Pressure Pen, at intensity 10 or for the Symbol Sprayer, and
    /// nothing with it off.
    #[test]
    fn show_brush_size_and_intensity_draws_the_brush() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolScruncher");
        assert!(t.overlays(&cx).is_empty(), "no pointer yet");
        t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 50.0, 50.0));
        let rings = |t: &SymbolismTool| {
            t.overlays(&cx)
                .into_iter()
                .map(|o| match o {
                    Overlay::Path { path, dashed, .. } => (path.bounding_box().width().round(), dashed),
                    other => panic!("{other:?}"),
                })
                .collect::<Vec<_>>()
        };
        assert_eq!(rings(&t), [(80.0, false), (40.0, true)]);
        t.set_option("intensity", &json!(10));
        assert_eq!(rings(&t), [(80.0, false)]);
        t.set_option("intensity", &json!(2));
        t.set_option("usePressure", &json!(true));
        assert_eq!(rings(&t), [(80.0, false)]);
        t.set_option("showBrush", &json!(false));
        assert!(t.overlays(&cx).is_empty());
        // The Symbol Sprayer uses neither Intensity nor pen pressure: the outline only.
        let mut t = SymbolismTool::new("symbolSprayer");
        t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 50.0, 50.0));
        assert_eq!(rings(&t), [(80.0, false)]);
    }

    #[test]
    fn brackets_change_diameter_and_intensity() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let cx = cx(&d, &s, &p);
        let mut t = SymbolismTool::new("symbolSizer");
        t.key(&cx, ToolKey::BracketRight, Mods::default());
        t.key(&cx, ToolKey::BracketLeft, Mods { shift: true, ..Default::default() });
        assert_eq!(t.options()["diameter"], json!(90.0));
        assert_eq!(t.options()["intensity"], json!(4.0));
    }

    #[test]
    fn paintbrush_rewrites_freehand_to_brush_freehand() {
        let (mut d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        {
            let cx = cx(&d, &s, &p);
            let mut t = BrushPaintTool::default();
            t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
            let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 30.0, 0.0));
            assert!(matches!(&a[1], Action::Preview(c, _) if c == "path.freehand"), "no brush: plain freehand");
        }
        d.unknown.insert("currentBrush".into(), json!("Charcoal"));
        let cx = cx(&d, &s, &p);
        let mut t = BrushPaintTool::default();
        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 30.0, 0.0));
        assert!(matches!(&a[1], Action::Preview(c, v) if c == "brush.freehand" && v["brush"] == "Charcoal"));
        t.set_option("brush", &json!("Dots"));
        assert_eq!(t.options()["brush"], "Dots");
    }

    #[test]
    fn paintbrush_skips_a_brush_the_document_does_not_have() {
        let (mut d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let drag = |d: &vectorcraft_doc::Document, t: &mut BrushPaintTool| {
            let cx = cx(d, &s, &p);
            t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
            t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 30.0, 0.0)).swap_remove(1)
        };
        d.unknown.insert("currentBrush".into(), json!("Charcoal"));
        let mut t = BrushPaintTool::default();
        t.set_option("brush", &json!("Deleted"));
        let a = drag(&d, &mut t);
        assert!(matches!(&a, Action::Preview(c, v) if c == "brush.freehand" && v["brush"] == "Charcoal"), "the current brush: {a:?}");
        d.unknown.insert("currentBrush".into(), json!("Also deleted"));
        let a = drag(&d, &mut BrushPaintTool::default());
        assert!(matches!(&a, Action::Preview(c, v) if c == "path.freehand" && v.get("brush").is_none()), "no brush: {a:?}");
    }
}