mirror of
https://github.com/storytold/AniCraft.git
synced 2026-11-20 09:32:48 +01:00
feat(engine): document swatches with swatch.* commands, swatch files and GIMP palettes (M1)
This commit is contained in:
1 parent
f00e5b99bd
commit
a64130a9da
13 files changed
+891
-11
No files matched your search
+24
-3
@@ -28,6 +28,7 @@ pub mod publish;
|
||||
pub mod sample;
|
||||
pub mod templates;
|
||||
pub mod sound;
|
||||
pub mod swatch;
|
||||
|
||||
pub use filter::{Filter, FilterSide, MAX_BLUR, MAX_QUALITY, MAX_RAMP_STOPS, REST_SNAP, default_bevel_ramp, default_glow_ramp, pinned_stop, ramp_at};
|
||||
pub use bitmap::{Bitmap, BitmapId, ImageError, MAX_BITMAP_EDGE, Pixels, base64_decode, base64_encode, decode_png, image_to_png};
|
||||
@@ -40,6 +41,7 @@ pub use sound::{EnvelopePoint, FrameSound, Sound, SoundEffect, SoundFormat, Soun
|
||||
pub use width::{MAX_WIDTH_FACTOR, MAX_WIDTH_POINTS, ProfilePreset, WidthPoint, WidthProfile};
|
||||
pub use stroke_style::{Cap, Dash, DashKind, Join, StrokeStyle};
|
||||
pub use camera::Camera;
|
||||
pub use swatch::{MAX_SWATCHES, Swatch, SwatchPaint};
|
||||
pub use nine_slice::symbol_box;
|
||||
pub use armature::{Armature, Bone, BoneId, JointAngle, Limits, Pose};
|
||||
pub use eval::{DisplayItem, DisplayList, Group, MAX_SYMBOL_DEPTH, evaluate, evaluate_guided, evaluate_layer_elements, evaluate_player, evaluate_scene, evaluate_scene_camera, evaluate_timeline, evaluate_timeline_at, guide_walk, instance_start};
|
||||
@@ -1655,10 +1657,22 @@ pub struct Document {
|
||||
/// File › Publish Settings: the formats Publish writes and their options (ADR 0060).
|
||||
#[serde(default, skip_serializing_if = "publish_is_default")]
|
||||
pub publish: Arc<publish::PublishProfile>,
|
||||
/// The Swatches panel's colours and gradients (ADR 0078). A file without them opens with
|
||||
/// the default set, which is written only once changed.
|
||||
#[serde(default = "default_swatches", skip_serializing_if = "swatches_are_default")]
|
||||
pub swatches: Arc<Vec<Swatch>>,
|
||||
/// Next free id for layers, elements and symbols.
|
||||
pub next_id: u64,
|
||||
}
|
||||
|
||||
fn default_swatches() -> Arc<Vec<Swatch>> {
|
||||
Arc::new(swatch::default_set())
|
||||
}
|
||||
|
||||
fn swatches_are_default(v: &Arc<Vec<Swatch>>) -> bool {
|
||||
swatch::is_default_set(v)
|
||||
}
|
||||
|
||||
/// What a document file may hold: `scenes`, or (files before scenes) a single `timeline`.
|
||||
#[derive(Deserialize)]
|
||||
struct DocumentFile {
|
||||
@@ -1680,6 +1694,8 @@ struct DocumentFile {
|
||||
document_class: String,
|
||||
#[serde(default)]
|
||||
publish: Arc<publish::PublishProfile>,
|
||||
#[serde(default = "default_swatches")]
|
||||
swatches: Arc<Vec<Swatch>>,
|
||||
#[serde(default = "first_id")]
|
||||
next_id: u64,
|
||||
}
|
||||
@@ -1690,7 +1706,7 @@ impl From<DocumentFile> for Document {
|
||||
if let Some(tl) = f.timeline {
|
||||
scenes.insert(0, Arc::new(Scene { name: "Scene 1".into(), timeline: tl }));
|
||||
}
|
||||
Document { stage: f.stage, scenes, library: f.library, bitmaps: f.bitmaps, sounds: f.sounds, library_tree: f.library_tree, document_class: f.document_class, publish: f.publish, next_id: f.next_id }
|
||||
Document { stage: f.stage, scenes, library: f.library, bitmaps: f.bitmaps, sounds: f.sounds, library_tree: f.library_tree, document_class: f.document_class, publish: f.publish, swatches: f.swatches, next_id: f.next_id }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1711,13 +1727,13 @@ static NO_TIMELINE: Timeline = Timeline { layers: Vec::new() };
|
||||
|
||||
impl PartialEq for Document {
|
||||
fn eq(&self, o: &Document) -> bool {
|
||||
self.stage == o.stage && self.next_id == o.next_id && self.document_class == o.document_class && arcs_eq(&self.scenes, &o.scenes) && arcs_eq(&self.library, &o.library) && arcs_eq(&self.bitmaps, &o.bitmaps) && arcs_eq(&self.sounds, &o.sounds) && arc_eq(&self.library_tree, &o.library_tree) && arc_eq(&self.publish, &o.publish)
|
||||
self.stage == o.stage && self.next_id == o.next_id && self.document_class == o.document_class && arcs_eq(&self.scenes, &o.scenes) && arcs_eq(&self.library, &o.library) && arcs_eq(&self.bitmaps, &o.bitmaps) && arcs_eq(&self.sounds, &o.sounds) && arc_eq(&self.library_tree, &o.library_tree) && arc_eq(&self.publish, &o.publish) && arc_eq(&self.swatches, &o.swatches)
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Document {
|
||||
fn default() -> Self {
|
||||
let mut d = Document { stage: Stage::default(), scenes: vec![Arc::new(Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Arc::default(), document_class: String::new(), publish: Arc::default(), next_id: 1 };
|
||||
let mut d = Document { stage: Stage::default(), scenes: vec![Arc::new(Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Arc::default(), document_class: String::new(), publish: Arc::default(), swatches: default_swatches(), next_id: 1 };
|
||||
let id = LayerId(d.alloc_id());
|
||||
d.timeline_mut(0).layers.push(Arc::new(Layer::new(id, "Layer 1")));
|
||||
d
|
||||
@@ -1831,6 +1847,11 @@ impl Document {
|
||||
if !self.document_class.is_empty() && !actions::valid_class_name(&self.document_class) {
|
||||
self.document_class.clear();
|
||||
}
|
||||
// Swatches that can't be repaired are dropped; at most MAX_SWATCHES are kept.
|
||||
let swatches: Vec<Swatch> = self.swatches.iter().filter_map(Swatch::sanitized).take(MAX_SWATCHES).collect();
|
||||
if swatches != *self.swatches {
|
||||
self.swatches = Arc::new(swatches);
|
||||
}
|
||||
let mut publish = (*self.publish).clone();
|
||||
publish.sanitize();
|
||||
if publish != *self.publish {
|
||||
|
||||
@@ -41,7 +41,7 @@ fn key(start: u32, duration: u32, elements: Vec<Arc<Element>>, tween: Option<Eas
|
||||
|
||||
/// Builds the demo document: a bouncing ball, a spinning star, a pulsing sun over hills.
|
||||
pub fn demo() -> Document {
|
||||
let mut d = Document { stage: Stage { width: 1280, height: 720, fps: 24.0, background: Rgba::WHITE }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), next_id: 1 };
|
||||
let mut d = Document { stage: Stage { width: 1280, height: 720, fps: 24.0, background: Rgba::WHITE }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), swatches: Arc::new(crate::swatch::default_set()), next_id: 1 };
|
||||
let (w, h) = (1280.0, 720.0);
|
||||
|
||||
// --- library -------------------------------------------------------------------------
|
||||
@@ -147,7 +147,7 @@ pub fn demo() -> Document {
|
||||
/// whose last frame traces a line and goes back to the menu.
|
||||
pub fn interactive() -> Document {
|
||||
use crate::actions::{Action, ButtonEvent, EventHandler, FrameRef, FrameScript, Target};
|
||||
let mut d = Document { stage: Stage { width: 1280, height: 720, fps: 24.0, background: Rgba::hex(0x1d2333) }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), next_id: 1 };
|
||||
let mut d = Document { stage: Stage { width: 1280, height: 720, fps: 24.0, background: Rgba::hex(0x1d2333) }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), swatches: Arc::new(crate::swatch::default_set()), next_id: 1 };
|
||||
const LEN: u32 = 36;
|
||||
let solid = |c: u32| Paint::Solid(Rgba::hex(c));
|
||||
|
||||
@@ -211,7 +211,7 @@ pub fn interactive() -> Document {
|
||||
/// `shapes` shapes each, keyed every 12 frames over `frames` frames with classic tweens.
|
||||
/// Every element keeps one `Arc<Path>` across its keyframes, as a real tweened shape does.
|
||||
pub fn stress(layers: u32, shapes: u32, frames: u32) -> Document {
|
||||
let mut d = Document { stage: Stage { width: 1920, height: 1080, fps: 24.0, background: Rgba::WHITE }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), next_id: 1 };
|
||||
let mut d = Document { stage: Stage { width: 1920, height: 1080, fps: 24.0, background: Rgba::WHITE }, scenes: vec![Arc::new(crate::Scene::new("Scene 1"))], library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), swatches: Arc::new(crate::swatch::default_set()), next_id: 1 };
|
||||
let (layers, shapes, frames) = (layers.clamp(1, 1000), shapes.clamp(1, 100_000), frames.clamp(1, 10_000));
|
||||
let mut seed = 0x2545_f491_u32;
|
||||
let mut rnd = move || {
|
||||
|
||||
@@ -0,0 +1,266 @@
|
||||
//! The document's swatches (ADR 0078): saved colours and gradients, as Animate keeps them per
|
||||
//! document in its Swatches panel.
|
||||
//!
|
||||
//! A swatch is a colour (with alpha) or a gradient's ramp and options, never its geometry: a
|
||||
//! gradient swatch poured on a shape is fitted to it, as a new gradient is. A new document
|
||||
//! starts with [`default_set`]; a document file that has no swatches (every file before ADR
|
||||
//! 0078) opens with that set too, and the set is not written while it is unchanged.
|
||||
//!
|
||||
//! GIMP palettes (`.gpl`, an open plain-text format) import through [`parse_gpl`].
|
||||
|
||||
use crate::{GradientStop, MAX_FOCAL, MAX_GRADIENT_STOPS, Paint, Rgba, Spread, is_false, is_zero};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// Most swatches a document keeps (Animate's panel holds a few hundred at most).
|
||||
pub const MAX_SWATCHES: usize = 1024;
|
||||
/// Longest swatch name, in characters.
|
||||
pub const MAX_SWATCH_NAME: usize = 128;
|
||||
|
||||
/// One saved colour or gradient.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Swatch {
|
||||
/// Shown on hover (empty: the colour's hex).
|
||||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||||
pub name: String,
|
||||
pub paint: SwatchPaint,
|
||||
}
|
||||
|
||||
/// What a swatch holds.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "type", rename_all = "snake_case")]
|
||||
pub enum SwatchPaint {
|
||||
Solid {
|
||||
color: Rgba,
|
||||
},
|
||||
Linear {
|
||||
stops: Vec<GradientStop>,
|
||||
#[serde(default, skip_serializing_if = "Spread::is_pad")]
|
||||
spread: Spread,
|
||||
#[serde(default, skip_serializing_if = "is_false")]
|
||||
linear_rgb: bool,
|
||||
},
|
||||
Radial {
|
||||
stops: Vec<GradientStop>,
|
||||
#[serde(default, skip_serializing_if = "Spread::is_pad")]
|
||||
spread: Spread,
|
||||
#[serde(default, skip_serializing_if = "is_false")]
|
||||
linear_rgb: bool,
|
||||
#[serde(default, skip_serializing_if = "is_zero")]
|
||||
focal: f32,
|
||||
},
|
||||
}
|
||||
|
||||
impl SwatchPaint {
|
||||
/// The swatch of a fill: its colour, or its gradient's ramp and options (where it lies is
|
||||
/// left behind). `None` for a bitmap fill, which a swatch can't hold.
|
||||
pub fn from_paint(p: &Paint) -> Option<SwatchPaint> {
|
||||
match p {
|
||||
Paint::Solid(c) => Some(SwatchPaint::Solid { color: *c }),
|
||||
Paint::Linear { stops, spread, linear_rgb, .. } => Some(SwatchPaint::Linear { stops: stops.clone(), spread: *spread, linear_rgb: *linear_rgb }),
|
||||
Paint::Radial { stops, spread, linear_rgb, focal, .. } => Some(SwatchPaint::Radial { stops: stops.clone(), spread: *spread, linear_rgb: *linear_rgb, focal: *focal }),
|
||||
Paint::Bitmap { .. } => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Its colour, or its gradient's first stop.
|
||||
pub fn primary_color(&self) -> Rgba {
|
||||
match self {
|
||||
SwatchPaint::Solid { color } => *color,
|
||||
SwatchPaint::Linear { stops, .. } | SwatchPaint::Radial { stops, .. } => stops.first().map_or(Rgba::BLACK, |s| s.color),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn stops(&self) -> Option<&[GradientStop]> {
|
||||
match self {
|
||||
SwatchPaint::Solid { .. } => None,
|
||||
SwatchPaint::Linear { stops, .. } | SwatchPaint::Radial { stops, .. } => Some(stops),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_gradient(&self) -> bool {
|
||||
!matches!(self, SwatchPaint::Solid { .. })
|
||||
}
|
||||
|
||||
/// The key `paint.set_fill` and swatch files use for its kind.
|
||||
pub fn kind(&self) -> &'static str {
|
||||
match self {
|
||||
SwatchPaint::Solid { .. } => "solid",
|
||||
SwatchPaint::Linear { .. } => "linear",
|
||||
SwatchPaint::Radial { .. } => "radial",
|
||||
}
|
||||
}
|
||||
|
||||
/// Repaired: colours in range, 2 to [`MAX_GRADIENT_STOPS`] stops in order, the focal point
|
||||
/// in range. `None` when it can't be (a gradient with fewer than two stops).
|
||||
pub fn sanitized(&self) -> Option<SwatchPaint> {
|
||||
let stops = |s: &[GradientStop]| -> Option<Vec<GradientStop>> {
|
||||
if s.len() < 2 {
|
||||
return None;
|
||||
}
|
||||
let mut v: Vec<GradientStop> = s.iter().take(MAX_GRADIENT_STOPS).map(|g| GradientStop { offset: if g.offset.is_finite() { g.offset.clamp(0.0, 1.0) } else { 0.0 }, color: g.color.sanitized() }).collect();
|
||||
v.sort_by(|a, b| a.offset.total_cmp(&b.offset));
|
||||
Some(v)
|
||||
};
|
||||
Some(match self {
|
||||
SwatchPaint::Solid { color } => SwatchPaint::Solid { color: color.sanitized() },
|
||||
SwatchPaint::Linear { stops: s, spread, linear_rgb } => SwatchPaint::Linear { stops: stops(s)?, spread: *spread, linear_rgb: *linear_rgb },
|
||||
SwatchPaint::Radial { stops: s, spread, linear_rgb, focal } => SwatchPaint::Radial { stops: stops(s)?, spread: *spread, linear_rgb: *linear_rgb, focal: if focal.is_finite() { focal.clamp(-MAX_FOCAL, MAX_FOCAL) } else { 0.0 } },
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Swatch {
|
||||
pub fn new(name: &str, paint: SwatchPaint) -> Swatch {
|
||||
Swatch { name: clean_name(name), paint }
|
||||
}
|
||||
pub fn solid(c: Rgba) -> Swatch {
|
||||
Swatch { name: String::new(), paint: SwatchPaint::Solid { color: c } }
|
||||
}
|
||||
/// Repaired (see [`SwatchPaint::sanitized`]), its name trimmed and bounded.
|
||||
pub fn sanitized(&self) -> Option<Swatch> {
|
||||
Some(Swatch { name: clean_name(&self.name), paint: self.paint.sanitized()? })
|
||||
}
|
||||
}
|
||||
|
||||
/// A swatch name: one line, trimmed, at most [`MAX_SWATCH_NAME`] characters.
|
||||
pub fn clean_name(s: &str) -> String {
|
||||
s.chars().filter(|c| !c.is_control()).take(MAX_SWATCH_NAME).collect::<String>().trim().to_string()
|
||||
}
|
||||
|
||||
fn stop(offset: f32, rgb: u32) -> GradientStop {
|
||||
GradientStop { offset, color: Rgba::hex(rgb) }
|
||||
}
|
||||
|
||||
/// A new document's swatches: greys from black to white, the primaries and secondaries (the
|
||||
/// picker's web-safe palette has the rest), then seven gradients.
|
||||
pub fn default_set() -> Vec<Swatch> {
|
||||
let colours = [0x000000, 0x333333, 0x666666, 0x999999, 0xcccccc, 0xffffff, 0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 0x00ffff, 0xff00ff];
|
||||
let mut v: Vec<Swatch> = colours.iter().map(|c| Swatch::solid(Rgba::hex(*c))).collect();
|
||||
let linear = |stops| SwatchPaint::Linear { stops, spread: Spread::Pad, linear_rgb: false };
|
||||
let radial = |stops| SwatchPaint::Radial { stops, spread: Spread::Pad, linear_rgb: false, focal: 0.0 };
|
||||
v.extend([
|
||||
Swatch::new("Black to white", linear(vec![stop(0.0, 0x000000), stop(1.0, 0xffffff)])),
|
||||
Swatch::new("White to black", radial(vec![stop(0.0, 0xffffff), stop(1.0, 0x000000)])),
|
||||
Swatch::new("Red ball", radial(vec![stop(0.0, 0xff8080), stop(1.0, 0x990000)])),
|
||||
Swatch::new("Green ball", radial(vec![stop(0.0, 0x80ff80), stop(1.0, 0x006600)])),
|
||||
Swatch::new("Blue ball", radial(vec![stop(0.0, 0x80b0ff), stop(1.0, 0x000099)])),
|
||||
Swatch::new("Spectrum", linear(vec![stop(0.0, 0xff0000), stop(0.2, 0xffff00), stop(0.4, 0x00ff00), stop(0.6, 0x00ffff), stop(0.8, 0x0000ff), stop(1.0, 0xff00ff)])),
|
||||
Swatch::new("Gold", linear(vec![stop(0.0, 0xfff2a8), stop(0.5, 0xd4a017), stop(1.0, 0x7a5200)])),
|
||||
]);
|
||||
v
|
||||
}
|
||||
|
||||
/// Whether `v` is exactly the default set (then a document file leaves it out).
|
||||
pub fn is_default_set(v: &[Swatch]) -> bool {
|
||||
let d = default_set();
|
||||
v.len() == d.len() && v.iter().zip(&d).all(|(a, b)| a == b)
|
||||
}
|
||||
|
||||
/// Largest palette file read, in bytes.
|
||||
pub const MAX_PALETTE_BYTES: usize = 1 << 20;
|
||||
|
||||
/// Reads a GIMP palette (`.gpl`): a `GIMP Palette` line, optional `Name:` and `Columns:`
|
||||
/// lines and `#` comments, then one colour per line, `R G B` (0 to 255) and an optional name.
|
||||
/// Lines that aren't colours are skipped; at most [`MAX_SWATCHES`] colours are read. The
|
||||
/// palette's own name comes back with the colours.
|
||||
pub fn parse_gpl(text: &str) -> Result<(String, Vec<Swatch>), String> {
|
||||
if text.len() > MAX_PALETTE_BYTES {
|
||||
return Err("the palette file is too large".into());
|
||||
}
|
||||
let mut lines = text.lines();
|
||||
let first = lines.next().unwrap_or("").trim_start_matches('\u{feff}').trim();
|
||||
if first != "GIMP Palette" {
|
||||
return Err("this isn't a GIMP palette (its first line must be \"GIMP Palette\")".into());
|
||||
}
|
||||
let mut name = String::new();
|
||||
let mut out = Vec::new();
|
||||
for line in lines {
|
||||
let l = line.trim();
|
||||
if l.is_empty() || l.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
if let Some(n) = l.strip_prefix("Name:") {
|
||||
name = clean_name(n);
|
||||
continue;
|
||||
}
|
||||
if l.starts_with("Columns:") || l.starts_with("Channels:") {
|
||||
continue;
|
||||
}
|
||||
let mut parts = l.split_whitespace();
|
||||
let channel = |s: Option<&str>| s.and_then(|v| v.parse::<u16>().ok()).filter(|v| *v <= 255).map(|v| f32::from(v) / 255.0);
|
||||
let (Some(r), Some(g), Some(b)) = (channel(parts.next()), channel(parts.next()), channel(parts.next())) else { continue };
|
||||
let rest: Vec<&str> = parts.collect();
|
||||
let label = rest.join(" ");
|
||||
// GIMP names unnamed colours "Untitled"; the hex says more.
|
||||
let label = if label == "Untitled" { String::new() } else { label };
|
||||
out.push(Swatch::new(&label, SwatchPaint::Solid { color: Rgba::new(r, g, b, 1.0) }));
|
||||
if out.len() >= MAX_SWATCHES {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if out.is_empty() {
|
||||
return Err("the palette has no colours in it".into());
|
||||
}
|
||||
Ok((name, out))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_default_set_is_valid_and_recognised() {
|
||||
let d = default_set();
|
||||
assert_eq!(d.len(), 19);
|
||||
assert!(is_default_set(&d));
|
||||
assert!(d.iter().all(|s| s.sanitized().as_ref() == Some(s)), "nothing to repair");
|
||||
assert_eq!(d.iter().filter(|s| s.paint.is_gradient()).count(), 7);
|
||||
let mut other = d.clone();
|
||||
other.swap(0, 1);
|
||||
assert!(!is_default_set(&other));
|
||||
assert!(!is_default_set(&[]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swatches_are_repaired() {
|
||||
let bad = Swatch { name: " a\nb ".into(), paint: SwatchPaint::Radial { stops: vec![GradientStop { offset: 2.0, color: Rgba::new(f32::NAN, 9.0, -1.0, 1.0) }, GradientStop { offset: -1.0, color: Rgba::WHITE }], spread: Spread::Pad, linear_rgb: false, focal: 5.0 } };
|
||||
let s = bad.sanitized().unwrap();
|
||||
assert_eq!(s.name, "ab");
|
||||
let SwatchPaint::Radial { stops, focal, .. } = &s.paint else { panic!() };
|
||||
assert_eq!((stops[0].offset, stops[1].offset), (0.0, 1.0), "in order and in range");
|
||||
assert_eq!(stops[1].color, Rgba::new(0.0, 1.0, 0.0, 1.0));
|
||||
assert_eq!(*focal, MAX_FOCAL);
|
||||
let one = Swatch { name: String::new(), paint: SwatchPaint::Linear { stops: vec![GradientStop { offset: 0.0, color: Rgba::BLACK }], spread: Spread::Pad, linear_rgb: false } };
|
||||
assert!(one.sanitized().is_none(), "a gradient needs two stops");
|
||||
assert_eq!(clean_name(&"x".repeat(500)).chars().count(), MAX_SWATCH_NAME);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_swatch_keeps_a_fills_ramp_not_its_geometry() {
|
||||
let p = Paint::linear(crate::Vec2::new(5.0, 5.0), crate::Vec2::new(50.0, 5.0), vec![stop(0.0, 0xff0000), stop(1.0, 0x0000ff)]);
|
||||
let s = SwatchPaint::from_paint(&p).unwrap();
|
||||
assert_eq!(s.kind(), "linear");
|
||||
assert_eq!(s.primary_color(), Rgba::hex(0xff0000));
|
||||
assert!(SwatchPaint::from_paint(&Paint::Bitmap { bitmap: crate::BitmapId(1), repeat: true, matrix: crate::Affine::IDENTITY }).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gimp_palettes_are_read() {
|
||||
let text = "GIMP Palette\nName: Brand\nColumns: 4\n# a comment\n255 0 0\tCrimson red\n 0 128 255 Untitled\n300 0 0 too bright\nnot a colour\n\n10 20 30\n";
|
||||
let (name, sw) = parse_gpl(text).unwrap();
|
||||
assert_eq!(name, "Brand");
|
||||
assert_eq!(sw.len(), 3);
|
||||
assert_eq!(sw[0].name, "Crimson red");
|
||||
assert_eq!(sw[0].paint, SwatchPaint::Solid { color: Rgba::hex(0xff0000) });
|
||||
assert_eq!(sw[1].name, "", "GIMP's Untitled shows as the hex");
|
||||
assert_eq!(sw[2].paint.primary_color().to_hex(), "#0a141e");
|
||||
// A byte-order mark and Windows line ends are fine.
|
||||
assert!(parse_gpl("\u{feff}GIMP Palette\r\n1 2 3\r\n").is_ok());
|
||||
for bad in ["", "JASC-PAL\n0 0 0", "GIMP Palette\nName: empty\n", "GIMP Palette\n1 2\n"] {
|
||||
assert!(parse_gpl(bad).is_err(), "{bad:?}");
|
||||
}
|
||||
let many = format!("GIMP Palette\n{}", "1 2 3\n".repeat(MAX_SWATCHES + 10));
|
||||
assert_eq!(parse_gpl(&many).unwrap().1.len(), MAX_SWATCHES, "bounded");
|
||||
assert!(parse_gpl(&"x".repeat(MAX_PALETTE_BYTES + 1)).is_err());
|
||||
}
|
||||
}
|
||||
@@ -378,7 +378,7 @@ fn set_fill(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({"ok": true}))
|
||||
}
|
||||
|
||||
fn set_stroke(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
pub(crate) fn set_stroke(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let remove = p.get("color").is_some_and(Value::is_null);
|
||||
let color = opt_color(p, "color")?;
|
||||
let width = opt_f32(p, "width")?;
|
||||
|
||||
@@ -479,7 +479,7 @@ fn default_stops() -> Vec<GradientStop> {
|
||||
}
|
||||
|
||||
/// The `stops` param: 2 to 15 stops, each `{offset, color}`, put in order of offset.
|
||||
fn opt_stops(p: &Value) -> Result<Option<Vec<GradientStop>>> {
|
||||
pub(crate) fn opt_stops(p: &Value) -> Result<Option<Vec<GradientStop>>> {
|
||||
let bad = || EngineError::Param(format!("param 'stops' must be a list of 2 to {MAX_GRADIENT_STOPS} stops like {{\"offset\": 0.5, \"color\": \"#ff8800\"}}"));
|
||||
let list = match p.get("stops") {
|
||||
None | Some(Value::Null) => return Ok(None),
|
||||
@@ -596,7 +596,7 @@ pub fn fill_json(p: &Paint) -> Value {
|
||||
}
|
||||
}
|
||||
|
||||
fn opt_focal(p: &Value) -> Result<Option<f32>> {
|
||||
pub(crate) fn opt_focal(p: &Value) -> Result<Option<f32>> {
|
||||
let f = opt_f32(p, "focal")?;
|
||||
if f.is_some_and(|f| !(-MAX_FOCAL..=MAX_FOCAL).contains(&f)) {
|
||||
return Err(EngineError::Param(format!("param 'focal' must be between -{MAX_FOCAL} and {MAX_FOCAL}")));
|
||||
@@ -605,7 +605,7 @@ fn opt_focal(p: &Value) -> Result<Option<f32>> {
|
||||
}
|
||||
|
||||
/// `paint.set_fill`: the Colour panel's fill (type, stops, overflow, linear RGB, bitmap).
|
||||
fn set_fill(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
pub(crate) fn set_fill(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let swatch = s.style.fill_paint();
|
||||
let kind = match opt_str(p, "type")? {
|
||||
None => fill_kind(&swatch),
|
||||
|
||||
@@ -47,6 +47,9 @@ pub fn plugin_may_call(id: &str) -> std::result::Result<(), &'static str> {
|
||||
// user's own brushes are their preferences, and a brush set is a file.
|
||||
"brush" if id == "brush.preset_list" => Ok(()),
|
||||
"brush" => Err("plug-ins can't change your brushes or read and write brush sets"),
|
||||
// The document's swatches are document data; swatch files are files.
|
||||
"swatch" if matches!(id, "swatch.import" | "swatch.export") => Err("plug-ins can't read or write swatch files"),
|
||||
"swatch" => Ok(()),
|
||||
"plugin" => Err("plug-ins can't install, run or remove plug-ins"),
|
||||
"control" => Err("plug-ins can't play the movie"),
|
||||
ns if DOCUMENT.contains(&ns) => Ok(()),
|
||||
|
||||
@@ -0,0 +1,302 @@
|
||||
//! The Swatches panel's commands (ADR 0078): the document's saved colours and gradients.
|
||||
//!
|
||||
//! Swatches live in the document (`Document::swatches`), so every change here is an undo step
|
||||
//! and is saved with the file, as Animate keeps them per document. Applying a swatch is
|
||||
//! `paint.set_fill` (fill) or `element.set_stroke` (stroke) underneath, so the selection and
|
||||
//! the tool colour change exactly as they do from the Colour panel.
|
||||
//!
|
||||
//! A swatch set moves between documents and computers as a small JSON file
|
||||
//! (`swatch.export` / `swatch.import`); GIMP palettes (`.gpl`, an open plain-text format)
|
||||
//! import too. Adobe's `.aco`, `.ase` and `.clr` formats are proprietary and not read.
|
||||
|
||||
use crate::params::*;
|
||||
use crate::{CommandSpec, EngineError, Result, Session};
|
||||
use anicraft_doc::swatch::{MAX_PALETTE_BYTES, clean_name, default_set, parse_gpl};
|
||||
use anicraft_doc::{GradientStop, MAX_SWATCHES, Rgba, Spread, Swatch, SwatchPaint};
|
||||
use serde_json::{Value, json};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
let c = |id, label, params, mutates, run| CommandSpec { id, label, menu: "", shortcut: None, params, mutates, run };
|
||||
vec![
|
||||
c("swatch.list", "Swatches", "{} the document's swatches, in the Swatches panel's order → {swatches: [{index, name, type, color | stops, ..}], count}", false, list as crate::RunFn),
|
||||
c(
|
||||
"swatch.add",
|
||||
"Add Swatch",
|
||||
"{from?: fill|stroke (default fill: the fill swatch's colour or gradient; stroke: the stroke colour), or the swatch itself: type?: solid|linear|radial, color? (\"#rrggbb\" | \"#rrggbbaa\", solid), stops?: [{offset: 0..1, color}, ..] (2 to 15), spread?: extend|reflect|repeat, linear_rgb?: bool, focal?: -0.98..0.98 (radial); name?, at? (index; default: the end)} → {index, count}",
|
||||
true,
|
||||
add,
|
||||
),
|
||||
c("swatch.remove", "Delete Swatch", "{index} → {count}", true, remove),
|
||||
c("swatch.move", "Move Swatch", "{from, to} (indices: the swatch at `from` ends up at `to`) → {index}", true, move_swatch),
|
||||
c("swatch.duplicate", "Duplicate Swatch", "{index} puts a copy right after it → {index, count}", true, duplicate),
|
||||
c("swatch.rename", "Rename Swatch", "{index, name} (empty: no name, the hex shows on hover)", true, rename),
|
||||
c(
|
||||
"swatch.apply",
|
||||
"Apply Swatch",
|
||||
"{index, target?: fill|stroke (default fill), selection?: bool (default true)} sets the fill swatch (as paint.set_fill: a gradient is fitted to each shape) or the stroke colour, and unless `selection` is false the selected shapes' fills or strokes. A gradient swatch can't be a stroke (strokes are one colour) → {target, changed}",
|
||||
true,
|
||||
apply,
|
||||
),
|
||||
c("swatch.clear", "Clear Swatches", "{} removes every swatch but black and white (Animate's Clear Colors; undoable)", true, clear),
|
||||
c("swatch.reset", "Default Swatches", "{} replaces the swatches with a new document's set (undoable)", true, reset),
|
||||
c("swatch.import", "Import Swatches", "{path: a swatch file (.json, from swatch.export) or a GIMP palette (.gpl), replace?: bool (default false: added at the end)} → {imported, count}", true, import),
|
||||
c("swatch.export", "Export Swatches", "{path} writes the document's swatches to a swatch file (JSON) → {written, swatches}", false, export),
|
||||
]
|
||||
}
|
||||
|
||||
/// `#rrggbb`, or `#rrggbbaa` when not opaque.
|
||||
pub fn hex(c: Rgba) -> String {
|
||||
let c = c.sanitized();
|
||||
if c.a >= 1.0 { c.to_hex() } else { format!("{}{:02x}", c.to_hex(), (c.a * 255.0).round() as u8) }
|
||||
}
|
||||
|
||||
fn stops_json(stops: &[GradientStop]) -> Value {
|
||||
json!(stops.iter().map(|s| json!({"offset": s.offset, "color": hex(s.color)})).collect::<Vec<_>>())
|
||||
}
|
||||
|
||||
/// A swatch as commands and swatch files write it.
|
||||
pub fn swatch_json(s: &Swatch) -> Value {
|
||||
let mut v = match &s.paint {
|
||||
SwatchPaint::Solid { color } => json!({"type": "solid", "color": hex(*color)}),
|
||||
SwatchPaint::Linear { stops, spread, linear_rgb } => json!({"type": "linear", "stops": stops_json(stops), "spread": spread.key(), "linear_rgb": linear_rgb}),
|
||||
SwatchPaint::Radial { stops, spread, linear_rgb, focal } => json!({"type": "radial", "stops": stops_json(stops), "spread": spread.key(), "linear_rgb": linear_rgb, "focal": focal}),
|
||||
};
|
||||
if !s.name.is_empty()
|
||||
&& let Some(o) = v.as_object_mut()
|
||||
{
|
||||
o.insert("name".into(), json!(s.name));
|
||||
}
|
||||
v
|
||||
}
|
||||
|
||||
/// A swatch from its JSON (see `swatch.add`). `None` when `v` names no paint (no type, colour
|
||||
/// or stops), so the caller can fall back to the current one.
|
||||
pub fn swatch_from_json(v: &Value) -> Result<Option<Swatch>> {
|
||||
let kind = opt_str(v, "type")?;
|
||||
let color = opt_color(v, "color")?;
|
||||
let stops = crate::cmds_paint::opt_stops(v)?;
|
||||
let spread = match opt_str(v, "spread")? {
|
||||
None => Spread::Pad,
|
||||
Some(k) => Spread::from_key(k).ok_or_else(|| EngineError::Param(format!("unknown spread '{k}' (extend, reflect or repeat)")))?,
|
||||
};
|
||||
let linear_rgb = opt_bool(v, "linear_rgb")?.unwrap_or(false);
|
||||
let focal = crate::cmds_paint::opt_focal(v)?.unwrap_or(0.0);
|
||||
let kind = match (kind, &color, &stops) {
|
||||
(None, None, None) => return Ok(None),
|
||||
(Some(k), ..) => k,
|
||||
(None, _, Some(_)) => "linear",
|
||||
(None, Some(_), None) => "solid",
|
||||
};
|
||||
let need_stops = || stops.clone().ok_or_else(|| EngineError::Param(format!("a {kind} swatch needs 'stops' (2 to 15 like {{\"offset\": 0, \"color\": \"#ff0000\"}})")));
|
||||
let paint = match kind {
|
||||
"solid" => SwatchPaint::Solid { color: color.ok_or_else(|| EngineError::Param("a solid swatch needs 'color' (like \"#ff8800\")".into()))? },
|
||||
"linear" => SwatchPaint::Linear { stops: need_stops()?, spread, linear_rgb },
|
||||
"radial" => SwatchPaint::Radial { stops: need_stops()?, spread, linear_rgb, focal },
|
||||
other => return Err(EngineError::Param(format!("unknown swatch type '{other}' (solid, linear or radial)"))),
|
||||
};
|
||||
let name = opt_str(v, "name")?.unwrap_or("");
|
||||
Swatch::new(name, paint).sanitized().map(Some).ok_or_else(|| EngineError::Param("that swatch can't be kept (a gradient needs two stops)".into()))
|
||||
}
|
||||
|
||||
fn index_param(s: &Session, p: &Value, key: &str) -> Result<usize> {
|
||||
let n = s.doc.swatches.len();
|
||||
let i = opt_u64(p, key)?.ok_or_else(|| EngineError::Param(format!("param '{key}' is required (a swatch's index)")))?;
|
||||
usize::try_from(i).ok().filter(|i| *i < n).ok_or_else(|| if n == 0 { EngineError::State("the document has no swatches".into()) } else { EngineError::Param(format!("param '{key}' must be a swatch index, 0 to {}", n - 1)) })
|
||||
}
|
||||
|
||||
fn swatches_mut(s: &mut Session) -> &mut Vec<Swatch> {
|
||||
Arc::make_mut(&mut s.doc.swatches)
|
||||
}
|
||||
|
||||
fn list(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
let v: Vec<Value> = s
|
||||
.doc
|
||||
.swatches
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, sw)| {
|
||||
let mut j = swatch_json(sw);
|
||||
if let Some(o) = j.as_object_mut() {
|
||||
o.insert("index".into(), json!(i));
|
||||
}
|
||||
j
|
||||
})
|
||||
.collect();
|
||||
Ok(json!({"count": v.len(), "swatches": v}))
|
||||
}
|
||||
|
||||
/// The swatch `swatch.add` makes from the current colours: the fill swatch, or the stroke.
|
||||
fn current(s: &Session, from: &str) -> Result<Swatch> {
|
||||
match from {
|
||||
"fill" => SwatchPaint::from_paint(&s.style.fill_paint()).map(|p| Swatch { name: String::new(), paint: p }).ok_or_else(|| EngineError::State("a bitmap fill can't be a swatch (swatches hold colours and gradients)".into())),
|
||||
"stroke" => Ok(Swatch::solid(s.style.stroke)),
|
||||
other => Err(EngineError::Param(format!("param 'from' must be fill or stroke, not '{other}'"))),
|
||||
}
|
||||
}
|
||||
|
||||
fn add(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if s.doc.swatches.len() >= MAX_SWATCHES {
|
||||
return Err(EngineError::State(format!("a document keeps at most {MAX_SWATCHES} swatches; delete some first")));
|
||||
}
|
||||
let mut sw = match (opt_str(p, "from")?, swatch_from_json(p)?) {
|
||||
(Some(_), Some(_)) => return Err(EngineError::Param("give either 'from' or the swatch's own type, colour or stops, not both".into())),
|
||||
(None, Some(sw)) => sw,
|
||||
(from, None) => current(s, from.unwrap_or("fill"))?,
|
||||
};
|
||||
if let Some(n) = opt_str(p, "name")? {
|
||||
sw.name = clean_name(n);
|
||||
}
|
||||
let n = s.doc.swatches.len();
|
||||
let at = match opt_u64(p, "at")? {
|
||||
None => n,
|
||||
Some(i) => usize::try_from(i).ok().filter(|i| *i <= n).ok_or_else(|| EngineError::Param(format!("param 'at' must be 0 to {n}")))?,
|
||||
};
|
||||
swatches_mut(s).insert(at, sw);
|
||||
Ok(json!({"index": at, "count": n + 1}))
|
||||
}
|
||||
|
||||
fn remove(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let i = index_param(s, p, "index")?;
|
||||
let v = swatches_mut(s);
|
||||
v.remove(i);
|
||||
Ok(json!({"count": v.len()}))
|
||||
}
|
||||
|
||||
fn move_swatch(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let from = index_param(s, p, "from")?;
|
||||
let to = index_param(s, p, "to")?;
|
||||
if from != to {
|
||||
let v = swatches_mut(s);
|
||||
let sw = v.remove(from);
|
||||
v.insert(to, sw);
|
||||
}
|
||||
Ok(json!({"index": to}))
|
||||
}
|
||||
|
||||
fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let i = index_param(s, p, "index")?;
|
||||
if s.doc.swatches.len() >= MAX_SWATCHES {
|
||||
return Err(EngineError::State(format!("a document keeps at most {MAX_SWATCHES} swatches; delete some first")));
|
||||
}
|
||||
let v = swatches_mut(s);
|
||||
let copy = v.get(i).cloned().ok_or_else(|| EngineError::Param("no such swatch".into()))?;
|
||||
v.insert(i + 1, copy);
|
||||
Ok(json!({"index": i + 1, "count": v.len()}))
|
||||
}
|
||||
|
||||
fn rename(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let i = index_param(s, p, "index")?;
|
||||
let name = clean_name(str_req(p, "name")?);
|
||||
if let Some(sw) = swatches_mut(s).get_mut(i) {
|
||||
sw.name = name.clone();
|
||||
}
|
||||
Ok(json!({"index": i, "name": name}))
|
||||
}
|
||||
|
||||
fn apply(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let i = index_param(s, p, "index")?;
|
||||
let sw = s.doc.swatches.get(i).cloned().ok_or_else(|| EngineError::Param("no such swatch".into()))?;
|
||||
let selection = opt_bool(p, "selection")?.unwrap_or(true);
|
||||
match opt_str(p, "target")?.unwrap_or("fill") {
|
||||
"fill" => {
|
||||
let mut fill = swatch_json(&sw);
|
||||
if let Some(o) = fill.as_object_mut() {
|
||||
o.remove("name");
|
||||
o.insert("selection".into(), json!(selection));
|
||||
}
|
||||
let r = crate::cmds_paint::set_fill(s, &fill)?;
|
||||
Ok(json!({"target": "fill", "changed": r.get("changed").cloned().unwrap_or(json!(0))}))
|
||||
}
|
||||
"stroke" => {
|
||||
let SwatchPaint::Solid { color } = sw.paint else {
|
||||
return Err(EngineError::State("strokes are one colour: apply a gradient swatch to the fill instead".into()));
|
||||
};
|
||||
s.style.stroke = color;
|
||||
s.style.use_stroke = true;
|
||||
let changed = if selection && !s.selection.is_empty() {
|
||||
s.each_layer(false, |s| crate::cmds_draw::set_stroke(s, &json!({"color": hex(color)})))?;
|
||||
s.selection.len()
|
||||
} else {
|
||||
0
|
||||
};
|
||||
Ok(json!({"target": "stroke", "changed": changed}))
|
||||
}
|
||||
other => Err(EngineError::Param(format!("param 'target' must be fill or stroke, not '{other}'"))),
|
||||
}
|
||||
}
|
||||
|
||||
fn clear(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
s.doc.swatches = Arc::new(vec![Swatch::solid(Rgba::BLACK), Swatch::solid(Rgba::WHITE)]);
|
||||
Ok(json!({"count": 2}))
|
||||
}
|
||||
|
||||
fn reset(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
s.doc.swatches = Arc::new(default_set());
|
||||
Ok(json!({"count": s.doc.swatches.len()}))
|
||||
}
|
||||
|
||||
/// The JSON swatch file: `{"format": "anicraft-swatches", "version": 1, "swatches": [..]}`.
|
||||
pub fn file_json(swatches: &[Swatch]) -> String {
|
||||
let v = json!({"format": FORMAT, "version": 1, "swatches": swatches.iter().map(swatch_json).collect::<Vec<_>>()});
|
||||
serde_json::to_string_pretty(&v).unwrap_or_default()
|
||||
}
|
||||
|
||||
const FORMAT: &str = "anicraft-swatches";
|
||||
|
||||
/// The swatches in a swatch file (JSON) or a GIMP palette, told apart by their content.
|
||||
pub fn parse_file(text: &str) -> Result<Vec<Swatch>> {
|
||||
if text.len() > MAX_PALETTE_BYTES {
|
||||
return Err(EngineError::Param("the swatch file is too large".into()));
|
||||
}
|
||||
if text.trim_start_matches('\u{feff}').trim_start().starts_with("GIMP Palette") {
|
||||
return parse_gpl(text).map(|(_, v)| v).map_err(EngineError::Param);
|
||||
}
|
||||
let v: Value = serde_json::from_str(text).map_err(|e| EngineError::Param(format!("this isn't a swatch file or a GIMP palette ({e})")))?;
|
||||
if v.get("format").and_then(Value::as_str) != Some(FORMAT) {
|
||||
return Err(EngineError::Param(format!("this JSON isn't a swatch file (its \"format\" must be \"{FORMAT}\")")));
|
||||
}
|
||||
let list = v.get("swatches").and_then(Value::as_array).ok_or_else(|| EngineError::Param("the swatch file has no \"swatches\" list".into()))?;
|
||||
let mut out = Vec::new();
|
||||
for item in list.iter().take(MAX_SWATCHES) {
|
||||
// A swatch this version can't read is skipped, so a newer file still opens.
|
||||
if let Ok(Some(sw)) = swatch_from_json(item) {
|
||||
out.push(sw);
|
||||
}
|
||||
}
|
||||
if out.is_empty() {
|
||||
return Err(EngineError::Param("the swatch file has no swatches in it".into()));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn import(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = PathBuf::from(str_req(p, "path")?);
|
||||
if crate::vfs::len(&path)? > MAX_PALETTE_BYTES as u64 {
|
||||
return Err(EngineError::Param(format!("{} is too large to be a swatch file", path.display())));
|
||||
}
|
||||
let found = parse_file(&crate::vfs::read_to_string(&path)?)?;
|
||||
let replace = opt_bool(p, "replace")?.unwrap_or(false);
|
||||
let v = swatches_mut(s);
|
||||
if replace {
|
||||
v.clear();
|
||||
}
|
||||
let room = MAX_SWATCHES.saturating_sub(v.len());
|
||||
if room == 0 {
|
||||
return Err(EngineError::State(format!("a document keeps at most {MAX_SWATCHES} swatches; delete some first")));
|
||||
}
|
||||
let n = found.len().min(room);
|
||||
v.extend(found.into_iter().take(n));
|
||||
Ok(json!({"imported": n, "count": v.len()}))
|
||||
}
|
||||
|
||||
fn export(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let path = PathBuf::from(str_req(p, "path")?);
|
||||
if s.doc.swatches.is_empty() {
|
||||
return Err(EngineError::State("the document has no swatches to export".into()));
|
||||
}
|
||||
let text = file_json(&s.doc.swatches);
|
||||
crate::vfs::write(&path, text.as_bytes())?;
|
||||
Ok(json!({"written": path.display().to_string(), "swatches": s.doc.swatches.len(), "bytes": text.len()}))
|
||||
}
|
||||
@@ -38,6 +38,10 @@ fn plural(n: usize, word: &str) -> String {
|
||||
if n == 1 { format!("1 {word}") } else { format!("{n} {word}s") }
|
||||
}
|
||||
|
||||
fn swatches(n: usize) -> String {
|
||||
if n == 1 { "1 swatch".into() } else { format!("{n} swatches") }
|
||||
}
|
||||
|
||||
fn target_layer<'a>(s: &'a Session, p: &Value) -> Option<&'a Layer> {
|
||||
let id = p.get("layer").and_then(Value::as_u64).map_or(s.layer, LayerId);
|
||||
s.timeline().layer(id)
|
||||
@@ -124,6 +128,35 @@ pub fn confirmation(s: &Session, id: &str, p: &Value) -> Option<Confirmation> {
|
||||
irreversible: true,
|
||||
})
|
||||
}
|
||||
// Swatches are document data and undoable (ADR 0078): replacing many asks by default.
|
||||
"swatch.export" => {
|
||||
let path = Path::new(p.get("path").and_then(Value::as_str)?);
|
||||
crate::vfs::exists(path).then(|| overwrite(path, "Exporting the swatches"))
|
||||
}
|
||||
"swatch.clear" => {
|
||||
let n = s.doc.swatches.len();
|
||||
(n > 2).then(|| Confirmation {
|
||||
title: "Clear swatches?".into(),
|
||||
message: format!("{} will be removed, leaving black and white. You can undo this.", swatches(n)),
|
||||
action: "Clear Swatches".into(),
|
||||
irreversible: false,
|
||||
})
|
||||
}
|
||||
"swatch.reset" => {
|
||||
let custom = !anicraft_doc::swatch::is_default_set(&s.doc.swatches) && !s.doc.swatches.is_empty();
|
||||
custom.then(|| Confirmation {
|
||||
title: "Load the default swatches?".into(),
|
||||
message: "The document's swatches will be replaced with a new document's set. You can undo this.".into(),
|
||||
action: "Load Default Swatches".into(),
|
||||
irreversible: false,
|
||||
})
|
||||
}
|
||||
"swatch.import" if p.get("replace").and_then(Value::as_bool) == Some(true) && !s.doc.swatches.is_empty() => Some(Confirmation {
|
||||
title: "Replace swatches?".into(),
|
||||
message: format!("The document's {} will be replaced with the file's. You can undo this.", swatches(s.doc.swatches.len())),
|
||||
action: "Replace Swatches".into(),
|
||||
irreversible: false,
|
||||
}),
|
||||
"brush.preset_export" => {
|
||||
let path = Path::new(p.get("path").and_then(Value::as_str)?);
|
||||
crate::vfs::exists(path).then(|| overwrite(path, "Exporting the brushes"))
|
||||
|
||||
@@ -249,6 +249,6 @@ pub fn unique_bytes(old: &Document, new: &Document) -> usize {
|
||||
|
||||
/// Estimated total bytes of a document (as if nothing were shared). Used for reporting.
|
||||
pub fn document_bytes(doc: &Document) -> usize {
|
||||
let empty = Document { stage: doc.stage, scenes: Vec::new(), library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), next_id: doc.next_id };
|
||||
let empty = Document { stage: doc.stage, scenes: Vec::new(), library: Vec::new(), bitmaps: Vec::new(), sounds: Vec::new(), library_tree: Default::default(), document_class: String::new(), publish: Default::default(), swatches: doc.swatches.clone(), next_id: doc.next_id };
|
||||
unique_bytes(doc, &empty)
|
||||
}
|
||||
@@ -38,6 +38,7 @@ pub mod cmds_text;
|
||||
mod cmds_timeline;
|
||||
mod cmds_width;
|
||||
mod cmds_stroke;
|
||||
pub mod cmds_swatch;
|
||||
pub mod confirm;
|
||||
pub mod editing;
|
||||
pub mod explorer;
|
||||
@@ -153,6 +154,7 @@ pub fn commands() -> Vec<CommandSpec> {
|
||||
v.extend(cmds_brush::specs());
|
||||
v.extend(cmds_erase::specs());
|
||||
v.extend(cmds_paint::specs());
|
||||
v.extend(cmds_swatch::specs());
|
||||
v.extend(cmds_text::specs());
|
||||
v.extend(cmds_width::specs());
|
||||
v.extend(cmds_stroke::specs());
|
||||
@@ -1089,3 +1091,5 @@ mod tests_bone_chain;
|
||||
mod path_text_tests;
|
||||
#[cfg(test)]
|
||||
mod group_tests;
|
||||
#[cfg(test)]
|
||||
mod swatch_tests;
|
||||
@@ -176,6 +176,8 @@ fn every_command_namespace_has_a_plugin_policy() {
|
||||
"publish" => assert_eq!(verdict.is_ok(), c.id == "publish.settings_get", "{}", c.id),
|
||||
// Brushes (ADR 0068): list yes; your own brushes and brush set files no.
|
||||
"brush" => assert_eq!(verdict.is_ok(), c.id == "brush.preset_list", "{}", c.id),
|
||||
// Swatches (ADR 0078): document data yes, swatch files no.
|
||||
"swatch" => assert_eq!(verdict.is_ok(), !matches!(c.id, "swatch.import" | "swatch.export"), "{}", c.id),
|
||||
_ => assert!(verdict.is_ok() || matches!(c.id, "edit.undo" | "edit.redo") || c.id.contains("copy") || c.id.contains("cut") || c.id.contains("paste"), "{} has no plug-in policy (add its namespace to plugin_may_call)", c.id),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,244 @@
|
||||
//! The Swatches panel's commands (ADR 0078).
|
||||
|
||||
use crate::Session;
|
||||
use anicraft_doc::{Document, ElementId, ElementKind, Paint, Rgba, Shape, Swatch, SwatchPaint};
|
||||
use serde_json::{Value, json};
|
||||
use std::path::Path;
|
||||
|
||||
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
||||
s.execute(id, &p).unwrap_or_else(|e| panic!("{id}: {e}"))
|
||||
}
|
||||
|
||||
fn blank() -> Session {
|
||||
Session::new(Document::default())
|
||||
}
|
||||
|
||||
fn shape(s: &Session, id: u64) -> Shape {
|
||||
s.visible_elements()
|
||||
.iter()
|
||||
.find(|e| e.id == ElementId(id))
|
||||
.and_then(|e| match &e.kind {
|
||||
ElementKind::Shape(sh) => Some(sh.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.expect("a shape")
|
||||
}
|
||||
|
||||
/// A selected 100 × 100 square at (x, 100), red with a black stroke.
|
||||
fn square(s: &mut Session, x: f32) -> u64 {
|
||||
run(s, "draw.rect", json!({"x": x, "y": 100, "w": 100, "h": 100, "fill": "#ff0000", "stroke": "#000000"}))["element"].as_u64().unwrap()
|
||||
}
|
||||
|
||||
fn find(s: &Session, name: &str) -> usize {
|
||||
s.doc.swatches.iter().position(|w| w.name == name).unwrap_or_else(|| panic!("no swatch {name}"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_new_document_has_the_default_swatches_and_older_files_open_with_them() {
|
||||
let s = blank();
|
||||
assert_eq!(s.doc.swatches.len(), 19);
|
||||
// A file from before swatches (no "swatches" key) opens with the default set; the set is
|
||||
// not written while unchanged, so such files stay as they were.
|
||||
let text = crate::format::to_json(&s.doc).unwrap();
|
||||
assert!(!text.contains("\"swatches\""), "the default set isn't written");
|
||||
let back = crate::format::from_json(&text).unwrap();
|
||||
assert!(anicraft_doc::swatch::is_default_set(&back.swatches));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swatches_round_trip_through_the_file() {
|
||||
let mut s = blank();
|
||||
run(&mut s, "swatch.clear", json!({"confirm": true}));
|
||||
run(&mut s, "swatch.add", json!({"color": "#12345680", "name": "Ink"}));
|
||||
run(&mut s, "swatch.add", json!({"type": "radial", "stops": [{"offset": 0, "color": "#ffffff"}, {"offset": 0.7, "color": "#ff000080"}], "spread": "reflect", "linear_rgb": true, "focal": 0.5, "name": "Glow"}));
|
||||
let text = crate::format::to_json(&s.doc).unwrap();
|
||||
let back = crate::format::from_json(&text).unwrap();
|
||||
assert_eq!(*back.swatches, *s.doc.swatches);
|
||||
assert_eq!(back.swatches.len(), 4);
|
||||
let SwatchPaint::Radial { spread, linear_rgb, focal, stops } = &back.swatches[3].paint else { panic!("a radial swatch") };
|
||||
assert_eq!((spread.key(), *linear_rgb, *focal, stops.len()), ("reflect", true, 0.5, 2));
|
||||
// An explicitly empty list stays empty (it isn't the default set).
|
||||
let mut e = blank();
|
||||
run(&mut e, "swatch.clear", json!({"confirm": true}));
|
||||
run(&mut e, "swatch.remove", json!({"index": 0}));
|
||||
run(&mut e, "swatch.remove", json!({"index": 0}));
|
||||
let back = crate::format::from_json(&crate::format::to_json(&e.doc).unwrap()).unwrap();
|
||||
assert!(back.swatches.is_empty());
|
||||
// A damaged file's swatches are repaired or dropped on open.
|
||||
let mut v: Value = serde_json::from_str(&text).unwrap();
|
||||
v["document"]["swatches"] = json!([{"paint": {"type": "linear", "stops": [{"offset": 0, "color": {"r": 0, "g": 0, "b": 0, "a": 1}}]}}, {"name": "ok", "paint": {"type": "solid", "color": {"r": 9, "g": 0.5, "b": 0, "a": 1}}}]);
|
||||
let fixed = crate::format::from_json(&v.to_string()).unwrap();
|
||||
assert_eq!(fixed.swatches.len(), 1);
|
||||
assert_eq!(fixed.swatches[0].paint.primary_color().r, 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn add_takes_the_current_fill_or_stroke_or_a_given_swatch() {
|
||||
let mut s = blank();
|
||||
let n = s.doc.swatches.len();
|
||||
s.style.set_fill_color(Rgba::hex(0x3366ff));
|
||||
s.style.stroke = Rgba::hex(0x00aa00);
|
||||
assert_eq!(run(&mut s, "swatch.add", json!({}))["index"], n);
|
||||
assert_eq!(s.doc.swatches[n].paint, SwatchPaint::Solid { color: Rgba::hex(0x3366ff) });
|
||||
run(&mut s, "swatch.add", json!({"from": "stroke", "at": 0, "name": "Leaf"}));
|
||||
assert_eq!((s.doc.swatches[0].name.as_str(), s.doc.swatches[0].paint.primary_color()), ("Leaf", Rgba::hex(0x00aa00)));
|
||||
// A gradient fill swatch adds its ramp and options.
|
||||
run(&mut s, "paint.set_fill", json!({"type": "radial", "spread": "repeat", "selection": false}));
|
||||
let i = run(&mut s, "swatch.add", json!({"from": "fill"}))["index"].as_u64().unwrap() as usize;
|
||||
assert!(matches!(&s.doc.swatches[i].paint, SwatchPaint::Radial { spread: anicraft_doc::Spread::Repeat, .. }));
|
||||
// Each add is one undo step.
|
||||
let len = s.doc.swatches.len();
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert_eq!(s.doc.swatches.len(), len - 1);
|
||||
for bad in [json!({"from": "middle"}), json!({"type": "solid"}), json!({"type": "linear"}), json!({"type": "conic", "color": "#000000"}), json!({"from": "fill", "color": "#000000"}), json!({"color": "#00"}), json!({"color": "#000000", "at": 9999})] {
|
||||
assert!(s.execute("swatch.add", &bad).is_err(), "{bad}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_move_duplicate_and_rename() {
|
||||
let mut s = blank();
|
||||
let n = s.doc.swatches.len();
|
||||
let red = s.doc.swatches[6].clone();
|
||||
run(&mut s, "swatch.move", json!({"from": 6, "to": 0}));
|
||||
assert_eq!(s.doc.swatches[0], red);
|
||||
assert_eq!(s.doc.swatches.len(), n);
|
||||
run(&mut s, "swatch.move", json!({"from": 0, "to": n - 1}));
|
||||
assert_eq!(s.doc.swatches[n - 1], red, "to the end");
|
||||
assert_eq!(run(&mut s, "swatch.duplicate", json!({"index": n - 1}))["index"], n);
|
||||
assert_eq!(s.doc.swatches[n], red);
|
||||
run(&mut s, "swatch.rename", json!({"index": n, "name": " Fire engine "}));
|
||||
assert_eq!(s.doc.swatches[n].name, "Fire engine");
|
||||
run(&mut s, "swatch.remove", json!({"index": n}));
|
||||
assert_eq!(s.doc.swatches.len(), n);
|
||||
for (id, bad) in [("swatch.remove", json!({"index": n})), ("swatch.remove", json!({})), ("swatch.move", json!({"from": 0, "to": n})), ("swatch.duplicate", json!({"index": -1})), ("swatch.rename", json!({"index": 0}))] {
|
||||
assert!(s.execute(id, &bad).is_err(), "{id} {bad}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_sets_the_fill_or_the_stroke_of_the_selection_and_the_tool() {
|
||||
let mut s = blank();
|
||||
let id = square(&mut s, 50.0);
|
||||
let blue = find_colour(&s, 0x0000ff);
|
||||
// Fill: the selection and the fill swatch.
|
||||
assert_eq!(run(&mut s, "swatch.apply", json!({"index": blue}))["changed"], 1);
|
||||
assert_eq!(shape(&s, id).fill, Some(Paint::Solid(Rgba::hex(0x0000ff))));
|
||||
assert_eq!(s.style.fill_paint(), Paint::Solid(Rgba::hex(0x0000ff)));
|
||||
assert_eq!(shape(&s, id).stroke.unwrap().color, Rgba::BLACK, "the stroke is untouched");
|
||||
// Stroke: the selection's lines and the stroke colour; the fill stays.
|
||||
let yellow = find_colour(&s, 0xffff00);
|
||||
run(&mut s, "swatch.apply", json!({"index": yellow, "target": "stroke"}));
|
||||
assert_eq!(shape(&s, id).stroke.unwrap().color, Rgba::hex(0xffff00));
|
||||
assert_eq!(s.style.stroke, Rgba::hex(0xffff00));
|
||||
assert_eq!(shape(&s, id).fill, Some(Paint::Solid(Rgba::hex(0x0000ff))));
|
||||
// A gradient swatch is fitted to the shape, and the swatch holds it.
|
||||
let glow = find(&s, "Red ball");
|
||||
run(&mut s, "swatch.apply", json!({"index": glow}));
|
||||
let Some(Paint::Radial { center, radius, stops, .. }) = shape(&s, id).fill else { panic!("a radial fill") };
|
||||
assert_eq!(stops[0].color, Rgba::hex(0xff8080));
|
||||
assert!(center.x.abs() < 1e-3 && center.y.abs() < 1e-3 && (radius - 50.0).abs() < 1.0, "fitted to the 100-unit square: {center:?} {radius}");
|
||||
assert!(matches!(s.style.fill_paint, Some(Paint::Radial { .. })));
|
||||
// Strokes are one colour.
|
||||
assert!(s.execute("swatch.apply", &json!({"index": glow, "target": "stroke"})).is_err());
|
||||
// With `selection: false` only the tool colour changes.
|
||||
let white = find_colour(&s, 0xffffff);
|
||||
assert_eq!(run(&mut s, "swatch.apply", json!({"index": white, "selection": false}))["changed"], 0);
|
||||
assert_eq!(s.style.fill_paint(), Paint::Solid(Rgba::WHITE));
|
||||
assert!(matches!(shape(&s, id).fill, Some(Paint::Radial { .. })));
|
||||
// Nothing selected: the tool colour.
|
||||
run(&mut s, "edit.deselect", json!({}));
|
||||
run(&mut s, "swatch.apply", json!({"index": blue, "target": "stroke"}));
|
||||
assert_eq!(s.style.stroke, Rgba::hex(0x0000ff));
|
||||
assert_eq!(shape(&s, id).stroke.unwrap().color, Rgba::hex(0xffff00));
|
||||
// On the selection: one undo step (the tool colour alone is no document change).
|
||||
run(&mut s, "edit.select_all", json!({}));
|
||||
let before = s.history_len();
|
||||
run(&mut s, "swatch.apply", json!({"index": blue, "target": "fill"}));
|
||||
assert_eq!(s.history_len(), before + 1);
|
||||
assert!(s.execute("swatch.apply", &json!({"index": 0, "target": "outline"})).is_err());
|
||||
}
|
||||
|
||||
fn find_colour(s: &Session, rgb: u32) -> usize {
|
||||
s.doc.swatches.iter().position(|w| w.paint == SwatchPaint::Solid { color: Rgba::hex(rgb) }).expect("a default colour")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_and_reset_ask_first_and_undo() {
|
||||
let mut s = blank();
|
||||
let c = s.confirmation("swatch.clear", &json!({})).expect("clearing 19 swatches asks");
|
||||
assert!(!c.irreversible, "undoable, so it asks by default only");
|
||||
run(&mut s, "swatch.clear", json!({}));
|
||||
assert_eq!(*s.doc.swatches, vec![Swatch::solid(Rgba::BLACK), Swatch::solid(Rgba::WHITE)]);
|
||||
assert!(s.confirmation("swatch.clear", &json!({})).is_none(), "nothing to lose");
|
||||
assert!(s.confirmation("swatch.reset", &json!({})).is_some());
|
||||
run(&mut s, "swatch.reset", json!({}));
|
||||
assert!(anicraft_doc::swatch::is_default_set(&s.doc.swatches));
|
||||
assert!(s.confirmation("swatch.reset", &json!({})).is_none(), "already the default set");
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert_eq!(s.doc.swatches.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swatch_files_export_and_import() {
|
||||
crate::vfs::use_memory();
|
||||
let mut s = blank();
|
||||
run(&mut s, "swatch.add", json!({"type": "linear", "stops": [{"offset": 0, "color": "#000000"}, {"offset": 1, "color": "#ffffff00"}], "name": "Fade"}));
|
||||
let v = run(&mut s, "swatch.export", json!({"path": "set.json"}));
|
||||
assert_eq!(v["swatches"], 20);
|
||||
let text = crate::vfs::read_to_string(Path::new("set.json")).unwrap();
|
||||
assert!(text.contains("\"format\": \"anicraft-swatches\"") && text.contains("\"Fade\"") && text.contains("#ffffff00"));
|
||||
assert!(s.confirmation("swatch.export", &json!({"path": "set.json"})).is_some_and(|c| c.irreversible), "overwriting a file asks");
|
||||
// Another document: added at the end, or replacing (which asks by default).
|
||||
let mut t = blank();
|
||||
assert_eq!(run(&mut t, "swatch.import", json!({"path": "set.json"}))["count"], 39);
|
||||
assert!(t.confirmation("swatch.import", &json!({"path": "set.json", "replace": true})).is_some_and(|c| !c.irreversible));
|
||||
run(&mut t, "swatch.import", json!({"path": "set.json", "replace": true}));
|
||||
assert_eq!(*t.doc.swatches, *s.doc.swatches, "the same swatches, exactly");
|
||||
// Unknown swatches in a newer file are skipped; junk is refused.
|
||||
crate::vfs::put(Path::new("new.json"), br##"{"format": "anicraft-swatches", "version": 2, "swatches": [{"type": "conic"}, {"type": "solid", "color": "#010203"}]}"##.to_vec()).unwrap();
|
||||
let before = t.doc.swatches.len();
|
||||
assert_eq!(run(&mut t, "swatch.import", json!({"path": "new.json"}))["imported"], 1);
|
||||
assert_eq!(t.doc.swatches.len(), before + 1);
|
||||
for (name, body) in [("a.json", "{}"), ("b.json", "[1, 2]"), ("c.json", "not json"), ("d.json", r#"{"format": "anicraft-brushes"}"#), ("e.json", r#"{"format": "anicraft-swatches", "swatches": []}"#)] {
|
||||
crate::vfs::put(Path::new(name), body.as_bytes().to_vec()).unwrap();
|
||||
assert!(t.execute("swatch.import", &json!({"path": name})).is_err(), "{name}");
|
||||
}
|
||||
assert!(t.execute("swatch.import", &json!({"path": "missing.json"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gimp_palettes_import() {
|
||||
crate::vfs::use_memory();
|
||||
let mut s = blank();
|
||||
crate::vfs::put(Path::new("brand.gpl"), b"GIMP Palette\nName: Brand\nColumns: 3\n#\n230 57 70\tRed\n 29 53 87\tNavy\n241 250 238 Untitled\n".to_vec()).unwrap();
|
||||
run(&mut s, "swatch.import", json!({"path": "brand.gpl", "replace": true, "confirm": true}));
|
||||
assert_eq!(s.doc.swatches.len(), 3);
|
||||
assert_eq!(s.doc.swatches[0].name, "Red");
|
||||
assert_eq!(s.doc.swatches[1].paint.primary_color().to_hex(), "#1d3557");
|
||||
assert_eq!(s.doc.swatches[2].name, "");
|
||||
// Then they paint like any swatch.
|
||||
let id = square(&mut s, 0.0);
|
||||
run(&mut s, "swatch.apply", json!({"index": 1}));
|
||||
assert_eq!(shape(&s, id).fill.map(|p| p.primary_color().to_hex()), Some("#1d3557".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swatches_are_bounded() {
|
||||
let mut s = blank();
|
||||
s.doc.swatches = std::sync::Arc::new(vec![Swatch::solid(Rgba::BLACK); anicraft_doc::MAX_SWATCHES]);
|
||||
assert!(s.execute("swatch.add", &json!({"color": "#ffffff"})).is_err());
|
||||
assert!(s.execute("swatch.duplicate", &json!({"index": 0})).is_err());
|
||||
let list = run(&mut s, "swatch.list", json!({}));
|
||||
assert_eq!(list["count"], anicraft_doc::MAX_SWATCHES);
|
||||
assert_eq!(list["swatches"][3]["index"], 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plug_ins_edit_swatches_but_not_swatch_files() {
|
||||
use crate::cmds_plugin::plugin_may_call;
|
||||
for id in ["swatch.add", "swatch.apply", "swatch.remove", "swatch.move", "swatch.list", "swatch.clear"] {
|
||||
assert!(plugin_may_call(id).is_ok(), "{id}");
|
||||
}
|
||||
assert!(plugin_may_call("swatch.import").is_err() && plugin_may_call("swatch.export").is_err());
|
||||
}
|
||||
@@ -558,6 +558,11 @@ fn panic_hunt_every_command() {
|
||||
json!({"points": [[0, 0], [10, 0]], "preset": "nope", "curve": "wobbly", "spacing": 1, "jitter": -1, "name": "", "from": "missing", "names": [1, 2]}),
|
||||
json!({"points": [[f64::MAX, 0]], "curve": [[f64::NAN, 2]], "pressure_size": "yes", "pressure_opacity": 1, "as_stroke": "no", "name": "Chalk", "to": "Pencil"}),
|
||||
json!({"points": (0..2000).map(|i| json!([f64::from(i), f64::from(i % 7) * 3.0, f64::from(i % 3) * 0.5])).collect::<Vec<_>>(), "preset": "ink_pen", "as_stroke": true, "name": "a".repeat(5000)}),
|
||||
// Swatches (ADR 0078): junk kinds, indices and paints, both targets, a missing file.
|
||||
json!({"index": 0, "from": 18, "to": 0, "target": "stroke", "name": "a".repeat(5000)}),
|
||||
json!({"index": 12, "target": "stroke", "selection": false, "type": "radial", "stops": [{"offset": 0, "color": "#000000"}, {"offset": 1, "color": "#ffffff"}], "focal": 0.98, "at": 0}),
|
||||
json!({"index": u64::MAX, "from": "nowhere", "target": 3, "type": "conic", "stops": [{"offset": 2, "color": "#00"}], "spread": "wrap", "path": "no/such/palette.gpl"}),
|
||||
json!({"color": "#ff000000", "name": "\u{0}\n", "at": u64::MAX, "replace": true, "path": ""}),
|
||||
// Stroke styles (ADR 0046): junk, extremes and patterns that would be very fine.
|
||||
json!({"cap": "none", "join": "miter", "miter": 100, "dash": [0, 1e-30], "dash_offset": -1e4, "style": "dashed"}),
|
||||
json!({"cap": 7, "join": "mitre", "miter": f64::NAN, "dash": vec![1e4; 16], "dot_spacing": 0, "style": "dotted"}),
|
||||
|
||||
Reference in new issue
Block a user