Merge wp/A1

2026-10-26 10:47:11 -06:00 · 2026-10-04 21:46:02 +07:00
parent 0af6734b70 8910f8fd1e
commit 1ae0c22c26
23 changed files with 2002 additions and 161 deletions
@@ -257,7 +257,7 @@ fn convert_mode(s: &mut Session, p: &Value) -> Result<Value> {
            }
            n
        });
-        for sw in &mut d.swatches {
+        for sw in d.swatches_iter_mut() {
            match &mut sw.paint {
                Paint::Solid { color, .. } => *color = conv(color),
                Paint::Gradient(g) => {
@@ -486,14 +486,14 @@ fn set_spot(s: &mut Session, p: &Value) -> Result<Value> {
    const C: &str = "swatch.setSpot";
    let name = str_param(p, "name").ok_or_else(|| bad(C, "missing `name`"))?.to_string();
    let spot = bool_or(p, "spot", true);
-    let sw = s.doc()?.doc.swatches.iter().find(|w| w.name == name).ok_or_else(|| bad(C, format!("no swatch `{name}`")))?;
+    let sw = s.doc()?.doc.swatch(&name).ok_or_else(|| bad(C, format!("no swatch `{name}`")))?;
    if !matches!(sw.paint, Paint::Solid { .. }) {
        return Err(bad(C, "only solid-colour swatches can be spot colours"));
    }
    if sw.spot != spot {
        let n = name.clone();
        s.edit("Swatch Options", |d, _| {
-            if let Some(w) = d.swatches.iter_mut().find(|w| w.name == n) {
+            if let Some(w) = d.swatch_mut(&n) {
                w.spot = spot;
                if spot {
                    w.global = true;
@@ -113,7 +113,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
        "images": images,
        "symbols": symbols,
        "spotColors": spot,
-        "swatches": d.swatches.len(),
+        "swatches": d.swatches_iter().count(),
        "graphicStyles": d.graphic_styles.len(),
        "characterStyles": d.char_styles.len(),
        "paragraphStyles": d.para_styles.len(),
@@ -469,7 +469,7 @@ fn color_mode(s: &mut Session, p: &Value) -> Result<Value> {
            for l in &mut d.layers {
                map_node_colors(Arc::make_mut(l), &f, true, true);
            }
-            for sw in &mut d.swatches {
+            for sw in d.swatches_iter_mut() {
                if let vectorcraft_color::Paint::Solid { color, .. } = &mut sw.paint {
                    *color = f(*color);
                }
@@ -2,7 +2,9 @@

 use serde_json::{Value, json};
 use vectorcraft_color::{Color, Paint, Swatch, SwatchGroup};
-use vectorcraft_doc::Document;
+use vectorcraft_doc::pattern::pattern_paint;
+use vectorcraft_doc::swatches::{color_name, node_colors};
+use vectorcraft_doc::{Document, NodeId};

 use super::paint::paint_from;
 use super::*;
@@ -10,92 +12,222 @@ use crate::EngineError;

 pub fn specs() -> Vec<CommandSpec> {
    vec![
-        cmd!("swatch.new", "New Swatch", ["Window", "Swatches"], None, "{name?, color?, global?} (default: current fill)", has_doc, swatch_new),
-        cmd!("swatch.delete", "Delete Swatch", ["Window", "Swatches"], None, "{name}", has_doc, swatch_delete),
+        cmd!(
+            "swatch.new",
+            "New Swatch",
+            ["Window", "Swatches"],
+            None,
+            "{name?, color? | swatch? | gradient? | pattern?: name (default: the current fill), mode?: \"gray\"|\"rgb\"|\"hsb\"|\"cmyk\"|\"web\" (convert the colour), global?, spot? (a spot colour, always global), group?: colour group name (solid colours only; default: ungrouped)} save a colour, gradient or pattern as a swatch. Names are unique (\"Sky 2\"); a colour's default name is its values (\"C=10 M=20 Y=30 K=0\", \"R=255 G=128 B=0\", \"Gray K=40\") → {name}",
+            has_doc,
+            swatch_new
+        ),
+        cmd!(
+            "swatch.delete",
+            "Delete Swatch",
+            ["Window", "Swatches"],
+            None,
+            "{name? | names?: [swatch or colour group names] (a group goes with its swatches), unlink?: true (art using a deleted global swatch keeps its colour, unlinked; false keeps the stale link)} delete in one undo step → {deleted, unlinked: paints unlinked}",
+            has_doc,
+            swatch_delete
+        ),
        cmd!(
            "swatch.newGroup",
            "New Color Group",
            ["Window", "Swatches"],
            None,
-            "{name?, swatches?: [names] (moved into the group), colors?: [colour] (added as new swatches)}",
+            "{name?, swatches?: [names] (solid colours move into the group; gradients, patterns and None stay), colors?: [colour] (added as new swatches), fromArtwork?: false (add the unique colours of the selected art: fills, strokes, text, gradient stops and mesh points; a colour linked to a global swatch moves that swatch into the group), toGlobal?: true (with fromArtwork: the new swatches are global and the selected art's matching unlinked colours link to them), includeTints?: false (with fromArtwork: tints of global swatches also get swatches of their own)} → {name, swatches: [names in the group], linked: paints linked}",
            has_doc,
            swatch_new_group
        ),
        cmd!("swatch.duplicate", "Duplicate Swatch", ["Window", "Swatches"], None, "{name}", has_doc, swatch_duplicate),
        cmd!("swatch.sortByName", "Sort by Name", ["Window", "Swatches"], None, "{}", has_doc, swatch_sort),
+        cmd!(
+            "swatch.edit",
+            "Swatch Options",
+            ["Window", "Swatches"],
+            None,
+            "{name, newName?, color?, mode?: \"gray\"|\"rgb\"|\"hsb\"|\"cmyk\"|\"web\" (convert the colour), global?, spot? (spot colours are always global)} edit a swatch in any colour group, as one undo step. Fills, strokes and text linked to a global swatch take its new colour and name; turning Global off unlinks them (they keep their colour). Colour, mode and spot apply to solid colours only → {name, relinked: paints changed}",
+            has_doc,
+            swatch_edit
+        ),
+        cmd!(
+            query "swatch.list",
+            "Swatches",
+            [],
+            None,
+            "{group?: name (only that colour group's swatches)} → {swatches: [{name, kind: \"none\"|\"color\"|\"gradient\"|\"pattern\", group, global, spot, color?, hex?, gradient?, pattern?}], groups: [{name, swatches: [names]}]}",
+            has_doc,
+            swatch_list
+        ),
    ]
 }

 fn swatch_new(s: &mut Session, p: &Value) -> Result<Value> {
-    let paint = match paint_from(s, p)? {
-        Some(x) => x,
-        None => s.paint.fill.clone(),
+    const C: &str = "swatch.new";
+    let paint = match str_param(p, "pattern") {
+        Some(name) if s.doc()?.doc.pattern(name).is_some() => pattern_paint(name),
+        Some(name) => return Err(bad(C, format!("no pattern `{name}`"))),
+        None => paint_from(s, p)?.unwrap_or_else(|| s.paint.fill.clone()),
    };
-    let name = match str_param(p, "name") {
-        Some(n) => n.to_string(),
-        None => match &paint {
-            Paint::Solid { color, .. } => rgb_name(*color),
-            _ => format!("Swatch {}", s.doc()?.doc.swatches.len() + 1),
-        },
+    let spot = bool_or(p, "spot", false);
+    let global = spot || bool_or(p, "global", false);
+    let mode = str_param(p, "mode");
+    let group = str_param(p, "group");
+    let paint = match paint {
+        // The swatch holds the colour itself, not a link to the swatch it may have come from.
+        Paint::Solid { color, .. } => Paint::solid(match mode {
+            Some(m) => convert_to_mode(color, m, C)?,
+            None => color,
+        }),
+        Paint::None => return Err(bad(C, "a swatch needs a colour, gradient or pattern")),
+        _ if spot || mode.is_some() || group.is_some() => return Err(bad(C, "spot, mode and group apply to solid colours only")),
+        other => other,
    };
-    let global = bool_or(p, "global", false);
-    s.edit("New Swatch", |d, _| {
-        d.swatches.push(Swatch { name: name.clone(), paint, global, spot: false });
-        Ok(())
+    let requested = name_param(p, "name");
+    let name = s.edit("New Swatch", |d, _| {
+        let name = match requested {
+            Some(n) => d.free_swatch_name(&n),
+            None => d.new_swatch_name(&paint),
+        };
+        let swatch = Swatch { name: name.clone(), paint, global, spot };
+        match group {
+            Some(g) => {
+                d.swatch_groups.iter_mut().find(|x| x.name == g).ok_or_else(|| bad(C, format!("no colour group `{g}`")))?.swatches.push(swatch)
+            }
+            None => d.swatches.push(swatch),
+        }
+        Ok(name)
    })?;
    Ok(json!({ "name": name }))
 }

 fn swatch_delete(s: &mut Session, p: &Value) -> Result<Value> {
-    let name = str_param(p, "name").ok_or_else(|| bad("swatch.delete", "missing name"))?.to_string();
-    s.edit("Delete Swatch", |d, _| {
-        d.swatches.retain(|sw| sw.name != name);
-        for g in &mut d.swatch_groups {
-            g.swatches.retain(|sw| sw.name != name);
+    const C: &str = "swatch.delete";
+    let mut names: Vec<String> = vec![];
+    for n in str_list(p, "names").into_iter().chain(str_param(p, "name").map(str::to_string)) {
+        if !names.contains(&n) {
+            names.push(n);
        }
-        Ok(())
+    }
+    if names.is_empty() {
+        return Err(bad(C, "give `name` or `names`"));
+    }
+    let d = &s.doc()?.doc;
+    // Global swatches going away (named ones and those in named groups): their links are dropped.
+    let mut global: Vec<String> = vec![];
+    for n in &names {
+        let swatches: Vec<&Swatch> = match d.swatch_groups.iter().find(|g| g.name == *n) {
+            Some(g) => g.swatches.iter().collect(),
+            None => vec![d.swatch(n).ok_or_else(|| bad(C, format!("no swatch or colour group `{n}`")))?],
+        };
+        if swatches.iter().any(|w| w.paint.is_none()) {
+            return Err(bad(C, format!("`{n}` can't be deleted")));
+        }
+        global.extend(swatches.iter().filter(|w| w.global).map(|w| w.name.clone()));
+    }
+    if !bool_or(p, "unlink", true) {
+        global.clear();
+    }
+    let mut unlink = |_: &mut Color, link: &mut Option<String>| link.as_ref().is_some_and(|l| global.contains(l)) && link.take().is_some();
+    let unlinked = s.edit("Delete Swatch", |d, _| {
+        d.swatch_groups.retain(|g| !names.contains(&g.name));
+        for n in &names {
+            d.remove_swatch(n);
+        }
+        Ok(d.map_solid_paints(&mut unlink))
    })?;
-    ok()
+    map_default_paints(s, &mut unlink);
+    Ok(json!({"deleted": names, "unlinked": unlinked}))
 }

-/// The default name of a new solid swatch: its 8-bit RGB values.
-fn rgb_name(c: Color) -> String {
-    let [r, g, b] = c.to_rgb();
-    format!("R={} G={} B={}", (r * 255.0).round(), (g * 255.0).round(), (b * 255.0).round())
-}
-
-/// A swatch or colour-group name not used yet in `d`.
-fn free_name(d: &Document, base: &str) -> String {
-    unique_name(base, |n| d.swatch(n).is_some() || d.swatch_groups.iter().any(|g| g.name == n))
+/// The colours of the art `ids` for a new colour group, in paint order: the swatches that linked
+/// colours belong to (added to `swatches` once each) and the other colours (added to `colors` once
+/// each). A tint (a linked colour that differs from its swatch's) brings its swatch, and with
+/// `tints` its own colour too. Links to missing swatches count as unlinked.
+fn artwork_colors(d: &Document, ids: &[NodeId], tints: bool, swatches: &mut Vec<String>, colors: &mut Vec<Color>) {
+    for n in ids.iter().filter_map(|id| d.node(*id)) {
+        node_colors(n, &mut |c, link| {
+            let sw = link.and_then(|l| d.swatch(l)).filter(|w| w.paint.color().is_some());
+            if let Some(w) = sw
+                && !swatches.contains(&w.name)
+            {
+                swatches.push(w.name.clone());
+            }
+            let own = sw.is_none_or(|w| tints && w.paint.color() != Some(*c));
+            if own && !colors.contains(c) {
+                colors.push(*c);
+            }
+        });
+    }
 }

 fn swatch_new_group(s: &mut Session, p: &Value) -> Result<Value> {
-    let names: Vec<String> =
-        p.get("swatches").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default();
+    const C: &str = "swatch.newGroup";
+    let mut names = str_list(p, "swatches");
    let colors: Vec<Color> = p.get("colors").and_then(Value::as_array).map(|a| a.iter().filter_map(color_value).collect()).unwrap_or_default();
-    let requested = str_param(p, "name").map(str::to_string);
-    let name = s.edit("New Color Group", |d, _| {
-        let name = free_name(d, requested.as_deref().unwrap_or("Color Group"));
+    let from_art = bool_or(p, "fromArtwork", false);
+    let to_global = from_art && bool_or(p, "toGlobal", true);
+    let tints = bool_or(p, "includeTints", false);
+    let requested = name_param(p, "name");
+    let (name, members, linked) = s.edit("New Color Group", |d, sel| {
+        // New swatches: (colour, global).
+        let mut new: Vec<(Color, bool)> = colors.iter().map(|c| (*c, false)).collect();
+        if from_art {
+            if sel.objects.is_empty() {
+                return Err(bad(C, "select artwork to make a group of its colours"));
+            }
+            let mut art = vec![];
+            artwork_colors(d, &sel.objects, tints, &mut names, &mut art);
+            new.extend(art.into_iter().map(|c| (c, to_global)));
+        }
+        let name = d.free_swatch_name(requested.as_deref().unwrap_or("Color Group"));
        let mut group = SwatchGroup { name: name.clone(), swatches: vec![] };
+        // Colour groups hold solid colours only.
        for n in &names {
-            if let Some(pos) = d.swatches.iter().position(|sw| &sw.name == n) {
-                group.swatches.push(d.swatches.remove(pos));
+            if d.swatch(n).is_some_and(|sw| matches!(sw.paint, Paint::Solid { .. }))
+                && let Some(sw) = d.remove_swatch(n)
+            {
+                group.swatches.push(sw);
            }
        }
-        for c in &colors {
-            group.swatches.push(Swatch { name: rgb_name(*c), paint: Paint::solid(*c), global: false, spot: false });
+        // The global swatches made from the art's colours, which its unlinked paints link to.
+        let mut links: Vec<(Color, String)> = vec![];
+        for (c, global) in new {
+            let nm = unique_name(&color_name(c), |n| n == name || d.swatch_name_taken(n) || group.swatches.iter().any(|sw| sw.name == n));
+            if global {
+                links.push((c, nm.clone()));
+            }
+            group.swatches.push(Swatch { name: nm, paint: Paint::solid(c), global, spot: false });
        }
+        let members: Vec<String> = group.swatches.iter().map(|w| w.name.clone()).collect();
        d.swatch_groups.push(group);
-        Ok(name)
+        let linked = if links.is_empty() {
+            0
+        } else {
+            let live: Vec<String> = d.swatches_iter().map(|w| w.name.clone()).collect();
+            d.map_solid_paints_in(&sel.objects, &mut |c, link| {
+                if link.as_ref().is_some_and(|l| live.contains(l)) {
+                    return false;
+                }
+                match links.iter().find(|(lc, _)| lc == c) {
+                    Some((_, n)) => {
+                        *link = Some(n.clone());
+                        true
+                    }
+                    None => false,
+                }
+            })
+        };
+        Ok((name, members, linked))
    })?;
-    Ok(json!({"name": name}))
+    Ok(json!({"name": name, "swatches": members, "linked": linked}))
 }

 fn swatch_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
    let name = str_param(p, "name").ok_or_else(|| bad("swatch.duplicate", "missing name"))?.to_string();
    let new = s.edit("Duplicate Swatch", |d, _| {
        let src = d.swatch(&name).cloned().ok_or_else(|| EngineError::Other(format!("no swatch `{name}`")))?;
-        let nm = free_name(d, &format!("{name} copy"));
+        let nm = d.free_swatch_name(&format!("{name} copy"));
        let copy = Swatch { name: nm.clone(), ..src };
        if let Some(pos) = d.swatches.iter().position(|sw| sw.name == name) {
            d.swatches.insert(pos + 1, copy);
@@ -108,6 +240,159 @@ fn swatch_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
    Ok(json!({"name": new}))
 }

+/// A list-of-strings parameter (missing or non-string entries are skipped).
+fn str_list(p: &Value, key: &str) -> Vec<String> {
+    p.get(key).and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect()).unwrap_or_default()
+}
+
+/// A trimmed, non-empty name parameter.
+fn name_param(p: &Value, key: &str) -> Option<String> {
+    str_param(p, key).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string)
+}
+
+/// `c` converted to a Swatch Options colour mode through the colour settings (HSB is an RGB view;
+/// Web snaps each channel to a multiple of 0x33).
+fn convert_to_mode(c: Color, mode: &str, cmd: &str) -> Result<Color> {
+    use vectorcraft_color::cms::Model;
+    let cms = vectorcraft_color::cms::active();
+    let to = |m: Model| cms.convert(&c, m, cms.settings().intent);
+    Ok(match mode.to_ascii_lowercase().as_str() {
+        "gray" | "grayscale" => to(Model::Gray),
+        "rgb" | "hsb" => to(Model::Rgb),
+        "cmyk" => to(Model::Cmyk),
+        "web" => {
+            let snap = |v: f32| (v.clamp(0.0, 1.0) * 5.0).round() / 5.0;
+            let [r, g, b] = to(Model::Rgb).to_rgb_uncalibrated();
+            Color::rgb(snap(r), snap(g), snap(b))
+        }
+        other => return Err(bad(cmd, format!("unknown mode `{other}` (gray, rgb, hsb, cmyk or web)"))),
+    })
+}
+
+/// How a swatch edit reaches the solid paints linked to swatch `from`.
+struct Relink {
+    from: String,
+    /// The swatch's name after the edit.
+    to: String,
+    /// The new colour of a global swatch (linked paints take it).
+    color: Option<Color>,
+    /// false: drop the links (the swatch stopped being global); paints keep their colour.
+    keep: bool,
+}
+
+impl Relink {
+    /// Apply to one paint; true when it changed.
+    fn apply(&self, c: &mut Color, link: &mut Option<String>) -> bool {
+        if link.as_deref() != Some(self.from.as_str()) {
+            return false;
+        }
+        if !self.keep {
+            *link = None;
+            return true;
+        }
+        let renamed = self.to != self.from;
+        if renamed {
+            *link = Some(self.to.clone());
+        }
+        let recolored = self.color.is_some_and(|n| n != *c);
+        if let Some(n) = self.color {
+            *c = n;
+        }
+        renamed || recolored
+    }
+
+    fn defaults(&self, s: &mut Session) {
+        map_default_paints(s, &mut |c, l| self.apply(c, l));
+    }
+}
+
+/// Apply a swatch-link rewrite to the default fill and stroke for new art, except during a live
+/// preview (Cancel rolls the document back, not the session).
+fn map_default_paints(s: &mut Session, f: &mut dyn FnMut(&mut Color, &mut Option<String>) -> bool) {
+    if s.in_interaction() {
+        return;
+    }
+    for p in [&mut s.paint.fill, &mut s.paint.stroke] {
+        if let Paint::Solid { color, swatch } = p {
+            f(color, swatch);
+        }
+    }
+}
+
+fn swatch_edit(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "swatch.edit";
+    let name = str_param(p, "name").ok_or_else(|| bad(C, "missing `name`"))?.to_string();
+    let d = &s.doc()?.doc;
+    let sw = d.swatch(&name).cloned().ok_or_else(|| bad(C, format!("no swatch `{name}`")))?;
+    if sw.paint.is_none() {
+        return Err(bad(C, format!("`{name}` can't be edited")));
+    }
+    let given = |k: &str| p.get(k).is_some_and(|v| !v.is_null());
+    let solid = sw.paint.color();
+    if solid.is_none() && (given("color") || given("mode") || bool_or(p, "spot", false)) {
+        return Err(bad(C, "colour, mode and spot apply to solid-colour swatches only"));
+    }
+    let mut color = match p.get("color").filter(|v| !v.is_null()) {
+        Some(v) => Some(color_value(v).ok_or_else(|| bad(C, format!("bad color {v}")))?),
+        None => solid,
+    };
+    if let (Some(c), Some(m)) = (color, str_param(p, "mode")) {
+        color = Some(convert_to_mode(c, m, C)?);
+    }
+    let spot = bool_or(p, "spot", sw.spot);
+    let global = spot || bool_or(p, "global", sw.global);
+    let to = name_param(p, "newName").filter(|n| *n != name).map_or_else(|| name.clone(), |n| d.free_swatch_name(&n));
+    let relink = Relink { from: name.clone(), to: to.clone(), color: color.filter(|_| global), keep: global };
+    let relinked = s.edit("Swatch Options", |d, _| {
+        let w = d.swatch_mut(&name).ok_or_else(|| bad(C, format!("no swatch `{name}`")))?;
+        w.name = to.clone();
+        w.spot = spot;
+        w.global = global;
+        if let (Some(c), Paint::Solid { color: wc, .. }) = (color, &mut w.paint) {
+            *wc = c;
+        }
+        Ok(d.map_solid_paints(&mut |c, l| relink.apply(c, l)))
+    })?;
+    relink.defaults(s);
+    Ok(json!({"name": to, "relinked": relinked}))
+}
+
+fn swatch_json(sw: &Swatch, group: Option<&str>) -> Value {
+    let mut v = json!({"name": sw.name, "group": group, "global": sw.global, "spot": sw.spot});
+    match &sw.paint {
+        Paint::None => v["kind"] = json!("none"),
+        Paint::Solid { color, .. } => {
+            v["kind"] = json!("color");
+            v["color"] = json!(color);
+            v["hex"] = json!(color.to_hex());
+        }
+        Paint::Gradient(g) => {
+            v["kind"] = json!("gradient");
+            v["gradient"] = json!(g.gradient.kind.label().to_lowercase());
+        }
+        Paint::Pattern { pattern, .. } => {
+            v["kind"] = json!("pattern");
+            v["pattern"] = json!(pattern);
+        }
+    }
+    v
+}
+
+fn swatch_list(s: &mut Session, p: &Value) -> Result<Value> {
+    let d = &s.doc()?.doc;
+    let only = str_param(p, "group");
+    let groups: Vec<&SwatchGroup> = match only {
+        Some(g) => vec![d.swatch_groups.iter().find(|x| x.name == g).ok_or_else(|| bad("swatch.list", format!("no colour group `{g}`")))?],
+        None => d.swatch_groups.iter().collect(),
+    };
+    let ungrouped = d.swatches.iter().filter(|_| only.is_none()).map(|w| swatch_json(w, None));
+    let grouped = groups.iter().flat_map(|g| g.swatches.iter().map(|w| swatch_json(w, Some(&g.name))));
+    let swatches: Vec<Value> = ungrouped.chain(grouped).collect();
+    let groups: Vec<Value> =
+        groups.iter().map(|g| json!({"name": g.name, "swatches": g.swatches.iter().map(|w| &w.name).collect::<Vec<_>>()})).collect();
+    Ok(json!({"swatches": swatches, "groups": groups}))
+}
+
 fn swatch_sort(s: &mut Session, _: &Value) -> Result<Value> {
    s.edit("Sort Swatches", |d, _| {
        // [None] and other bracketed specials stay first, like the reference app.