2bc41aeb8602
columns.rs
use super::data::fmt_value;
use super::designs::design_names;
use super::edit::{regenerate, spec_of, target};
use super::generate::generate_with;
use super::markers::{design_frame, fit_affine};
use super::series::{picked_series, reselect_series};
use super::{
Affine, Arc, ColumnDesign, ColumnType, Document, FillRule, Fractions, GraphSpec, Node, NodeKind, Point, Rect, Result, Session, TextObject, Value,
bad, json, refresh_bounds, shapes,
};
/// Most objects a graph's column designs may add (each column, repeated copy and legend swatch draws a copy).
const COLUMN_BUDGET: usize = 200_000;
/// A series' column design (Object › Graph › Column): its options; its art without guide lines and without the totals
/// taken out of it ([`without_totals`]); the bounds of those guides; those totals; its frame (the art's without guides,
/// totals included, [`design_frame`]); whether its art still holds totals (inside groups that do more than group, or
/// inside other objects that hold objects), which are filled where they are; and its art without any total for the
/// legend swatch, `None` when that draws nothing.
pub(super) struct ColumnArt {
options: ColumnDesign,
art: Node,
guides: Vec<Rect>,
totals: Vec<Node>,
frame: Option<Rect>,
in_place: bool,
pub(super) legend: Option<Node>,
}
impl ColumnArt {
/// A copy of `art` with the design's frame fitted to `cell`, as [`fit_design`] fits it. Fresh ids.
pub(super) fn fit(&self, d: &mut Document, art: &Node, cell: Rect) -> Option<Arc<Node>> {
let art = crate::cmd::place::transformed(art.clone(), fit_affine(self.frame?, cell));
Some(Arc::new(d.reid(&art)))
}
}
/// The column design totals in `s` (Add totals to a column design): each `%` followed by two digits, as its byte offset,
/// the places before the decimal point (the first digit) and the places after it (the second), left to right. A `%` not
/// followed by two digits is plain text.
fn total_spans(s: &str) -> Vec<(usize, usize, usize)> {
let b = s.as_bytes();
let mut out = vec![];
let mut i = 0;
while let Some(w) = b.get(i..i + 3) {
match *w {
[b'%', x, y] if x.is_ascii_digit() && y.is_ascii_digit() => {
out.push((i, usize::from(x - b'0'), usize::from(y - b'0')));
i += 3;
}
_ => i += 1,
}
}
out
}
/// Value `v` as a column design total shows it: rounded half away from zero, from its shortest decimal form, to `after`
/// places after the decimal point, zeros added as needed; and with at least `before` places before the point, zeros
/// added in front (0: as many as the value needs). The places before the point are never cut, and a value that rounds
/// to 0 has no minus sign.
pub(super) fn total_text(v: f64, before: usize, after: usize) -> String {
if !v.is_finite() {
return fmt_value(v);
}
let s = format!("{}", v.abs());
let (int, frac) = s.split_once('.').unwrap_or((s.as_str(), ""));
// The digits kept, the point `after` places from the end.
let mut digits: Vec<u8> = int.bytes().chain(frac.bytes().chain(std::iter::repeat(b'0')).take(after)).collect();
if frac.as_bytes().get(after).is_some_and(|d| *d >= b'5') {
let mut carry = true;
for d in digits.iter_mut().rev() {
if *d == b'9' {
*d = b'0';
} else {
*d += 1;
carry = false;
break;
}
}
if carry {
digits.insert(0, b'1');
}
}
let (whole, places) = digits.split_at(digits.len().saturating_sub(after));
let mut out = String::new();
if v < 0.0 && digits.iter().any(|d| *d != b'0') {
out.push('-');
}
out.extend(std::iter::repeat_n('0', before.saturating_sub(whole.len())));
out.extend(whole.iter().map(|d| char::from(*d)));
if after > 0 {
out.push('.');
out.extend(places.iter().map(|d| char::from(*d)));
}
out
}
/// Type `t` with each total in it ([`total_spans`]) replaced by value `v` ([`total_text`]), styled as its `%` was; true
/// when it held one.
pub(super) fn fill_totals(t: &mut TextObject, v: f64) -> bool {
let spans = total_spans(&t.plain_text());
// Last first, so the offsets of earlier ones stay valid.
for &(at, before, after) in spans.iter().rev() {
let s = total_text(v, before, after);
t.splice_paras(at, at + 3, &s);
vectorcraft_text::edit::replace_range(&mut t.runs, at, at + 3, &s);
}
if !spans.is_empty() {
refresh_bounds(t);
}
!spans.is_empty()
}
/// Is `n` type that holds a total ([`total_spans`])?
fn holds_total(n: &Node) -> bool {
matches!(&n.kind, NodeKind::Text(t) if !total_spans(&t.plain_text()).is_empty())
}
/// Does group `n` only group its children: no clipping, hiding, opacity, blend mode, isolation, knockout, appearance of
/// its own or opacity mask, so that type taken out of it draws as it did inside it?
fn only_groups(n: &Node) -> bool {
matches!(n.kind, NodeKind::Group { clip: false, .. })
&& n.visible
&& n.opacity == 1.0
&& n.blend == vectorcraft_color::BlendMode::Normal
&& !n.isolate
&& n.knockout == vectorcraft_doc::Knockout::default()
&& n.appearance.items.is_empty()
&& n.appearance.effects.is_empty()
&& n.extras().mask.is_none()
}
/// Is `n` a clipping group whose clipping path is type that holds a total?
fn clipped_by_total(n: &Node) -> bool {
matches!(&n.kind, NodeKind::Group { clip: true, children } if children.first().is_some_and(|c| holds_total(c)))
}
/// `art` without the type in it that holds a total, inside groups at any depth that only group ([`only_groups`]), and
/// that type, pushed to `totals` in paint order (Add totals to a column design); with `all`, without every total inside
/// any group or other object that holds objects (a blend, compound shape, envelope, repeat or intertwine), and with
/// each group that such type clips left empty. A design that is such type alone leaves an empty group.
fn without_totals(art: &Node, all: bool, totals: &mut Vec<Node>) -> Node {
if holds_total(art) || (all && clipped_by_total(art)) {
totals.push(art.clone());
return Node::group(art.id, vec![]);
}
let mut n = art.clone();
let take = all || only_groups(&n);
if take && let Some(children) = n.children_mut() {
for c in std::mem::take(children) {
if holds_total(&c) {
totals.push((*c).clone());
} else if c.children().is_some() {
children.push(Arc::new(without_totals(&c, all, totals)));
} else {
children.push(c);
}
}
}
n
}
/// `n` with the totals in it at any depth, in groups and the other objects that hold objects, showing value `v` where
/// they are ([`fill_totals`]).
fn fill_in_place(n: &mut Node, v: f64) {
if let NodeKind::Text(t) = &mut n.kind {
fill_totals(t, v);
} else if let Some(children) = n.children_mut() {
for c in children.iter_mut() {
fill_in_place(Arc::make_mut(c), v);
}
}
}
/// `art` without the paths made into guides, at any depth.
fn without_guides(art: &Node) -> Node {
let mut n = art.clone();
if let Some(ch) = n.children_mut() {
let old = std::mem::take(ch);
*ch = old.iter().filter(|c| !matches!(c.kind, NodeKind::Path { guide: true, .. })).map(|c| Arc::new(without_guides(c))).collect();
}
n
}
/// Each series' column design, when the document has the design.
pub(super) fn column_designs(d: &Document, g: &GraphSpec) -> Vec<Option<ColumnArt>> {
let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).clamp(1, vectorcraft_doc::MAX_GRAPH_SERIES);
(0..nser)
.map(|s| {
let options = g.series_columns.get(s)?.as_ref()?;
let art = &d.graph_designs.iter().find(|x| x.name == options.design)?.art;
let mut guides = vec![];
art.walk(&mut |n| {
if matches!(n.kind, NodeKind::Path { guide: true, .. })
&& let Some(b) = n.geometric_bounds()
{
guides.push(b);
}
});
let art = without_guides(art);
let frame = design_frame(&art);
let legend = without_totals(&art, true, &mut vec![]);
let mut draws = false;
legend.walk(&mut |n| draws |= n.children().is_none());
let mut totals = vec![];
let art = without_totals(&art, false, &mut totals);
let mut in_place = false;
art.walk(&mut |n| in_place |= holds_total(n));
Some(ColumnArt { options: options.clone(), art, guides, totals, frame, in_place, legend: draws.then_some(legend) })
})
.collect()
}
/// The value one copy of a repeating design stands for, when the design repeats and the value is usable.
fn repeat_each(c: &ColumnDesign) -> Option<f64> {
(c.column_type == ColumnType::Repeating && c.each.is_finite() && c.each > 0.0).then_some(c.each)
}
/// The objects a graph's column designs may still add (out of [`COLUMN_BUDGET`]); `short` once a copy needed more than
/// was left, and the graph is then drawn with plain columns.
pub(super) struct Allowance {
left: usize,
pub(super) short: bool,
}
impl Allowance {
pub(super) fn new() -> Self {
Self { left: COLUMN_BUDGET, short: false }
}
/// Spend `n` objects, when that many are left.
pub(super) fn take(&mut self, n: usize) -> bool {
match self.left.checked_sub(n) {
Some(rest) => {
self.left = rest;
true
}
None => {
self.short = true;
false
}
}
}
}
/// Column or bar `rect` of value `value` drawn with column design `c` (Object › Graph › Column), as a group of fresh art,
/// its copies spent from `left`. `far_low`: the value end of the column is at the rect's lower coordinate (the top of a
/// column above zero, the left end of a bar below zero), so repeating copies stack from the other end. `per_unit`: plot
/// points per unit of value. The design's totals show `value` and come last: each keeps its size and is moved to where
/// the design's copy puts the point it is set from; in a repeating design they are drawn once, where a whole copy ending
/// at the value end puts them, and a sliding design moves each with the part of the design on its side of the guide.
/// Totals left in the art ([`ColumnArt`]) show `value` in each copy, drawn with it. `None` for art with no area, for a
/// column of no length and when `left` runs out, which are drawn plain.
pub(super) fn column_art(
d: &mut Document,
c: &ColumnArt,
(rect, value): (Rect, f64),
(horizontal, far_low): (bool, bool),
per_unit: f64,
left: &mut Allowance,
) -> Option<Arc<Node>> {
let frame = c.frame?;
let length = |r: Rect| if horizontal { r.width() } else { r.height() };
let thickness = |r: Rect| if horizontal { r.height() } else { r.width() };
if length(rect) <= 1e-9 || !length(rect).is_finite() {
return None;
}
let cost = c.art.count_with_masks();
// A copy of the design moved by `a`, the totals left in it showing `value`; a copy fitted to `cell`; and a copy moved
// by `a` and clipped to what it paints, cut at `at` (an x when `along_x`, else a y) with the side below `at` kept when
// `keep_low` (two objects more).
let copy = |d: &mut Document, a: Affine| {
let mut art = d.reid(&crate::cmd::place::transformed(c.art.clone(), a));
if c.in_place {
fill_in_place(&mut art, value);
}
art
};
let fit = |d: &mut Document, cell: Rect, left: &mut Allowance| left.take(cost).then(|| Arc::new(copy(d, fit_affine(frame, cell))));
let clipped = |d: &mut Document, a: Affine, (along_x, keep_low, at): (bool, bool, f64), left: &mut Allowance| {
let art = left.take(cost + 2).then(|| copy(d, a))?;
// The box of the copy and of each object in it that isn't a group or layer, as the brush art past a brushed
// stroke counts only in its own object's box.
let mut b = vectorcraft_render::painted_bounds(d, &art);
art.walk(&mut |n| {
if !matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) {
b = vectorcraft_geom::union_opt(b, vectorcraft_render::painted_bounds(d, n));
}
});
// A copy that draws nothing (a design of totals alone) needs no clip.
let Some(b) = b.or_else(|| art.geometric_bounds()) else { return Some(Arc::new(art)) };
let keep = match (along_x, keep_low) {
(true, true) => Rect::new(b.x0, b.y0, at.max(b.x0), b.y1),
(true, false) => Rect::new(at.min(b.x1), b.y0, b.x1, b.y1),
(false, true) => Rect::new(b.x0, b.y0, b.x1, at.max(b.y0)),
(false, false) => Rect::new(b.x0, at.min(b.y1), b.x1, b.y1),
};
Some(Arc::new(crate::cmd::rasterfx::clip_group(d, shapes::rectangle(keep), FillRule::NonZero, art)))
};
// The part of the column from `a` to `b` points out from its zero end.
let piece = |a: f64, b: f64| match (horizontal, far_low) {
(true, true) => Rect::new(rect.x1 - b, rect.y0, rect.x1 - a, rect.y1),
(true, false) => Rect::new(rect.x0 + a, rect.y0, rect.x0 + b, rect.y1),
(false, true) => Rect::new(rect.x0, rect.y1 - b, rect.x1, rect.y1 - a),
(false, false) => Rect::new(rect.x0, rect.y0 + a, rect.x1, rect.y0 + b),
};
// The column's group: `parts`, then the totals, each showing `value` at its own size, moved as `a` moves the point it
// is set from; with `sliding` (the kept part's map, the stretched part's map and the guide, as [`slide`] gives them),
// as the map of the part on its side of the guide moves it. One object each.
let group = |d: &mut Document, mut parts: Vec<Arc<Node>>, a: Affine, sliding: Option<(Affine, Affine, f64)>, left: &mut Allowance| {
for t in &c.totals {
if !left.take(1) {
return None;
}
let mut n = t.clone();
let mut by = Affine::IDENTITY;
if let NodeKind::Text(text) = &mut n.kind {
// A move only, so the type keeps its size; pattern paints move with it.
let p = text.xf * Point::ZERO;
let a = match sliding {
Some((kept, stretched, at)) => {
let q = kept * p;
if (horizontal && q.x >= at) || (!horizontal && q.y <= at) { kept } else { stretched }
}
None => a,
};
fill_totals(text, value);
by = Affine::translate(a * p - p);
}
parts.push(Arc::new(d.reid(&crate::cmd::place::transformed(n, by))));
}
Some(Arc::new(Node::group(d.alloc_id(), parts)))
};
let mut parts = vec![];
let (mut label, mut sliding) = (fit_affine(frame, rect), None);
match c.options.column_type {
ColumnType::Uniform => {
// Scaled both ways to the column's length, centered across it.
let t = thickness(frame) * length(rect) / length(frame) / 2.0;
let cell = if horizontal {
Rect::new(rect.x0, rect.center().y - t, rect.x1, rect.center().y + t)
} else {
Rect::new(rect.center().x - t, rect.y0, rect.center().x + t, rect.y1)
};
parts.push(fit(d, cell, left)?);
label = fit_affine(frame, cell);
}
ColumnType::Repeating => {
// When the value per copy is unusable, too small to draw or makes one copy longer than the canvas, the design
// is drawn vertically scaled.
let Some(unit) = repeat_each(&c.options).map(|e| e * per_unit).filter(|u| u.is_finite() && *u > 1e-9 && *u <= crate::MAX_COORD) else {
parts.push(fit(d, rect, left)?);
return group(d, parts, label, None, left);
};
// The totals go where a whole copy ending at the value end puts them.
label = fit_affine(frame, piece(length(rect) - unit, length(rect)));
// The whole copies, and the points of the column left for the last one (none under a millionth of a point).
let whole = ((length(rect) + 1e-6) / unit).floor();
let rest = length(rect) - whole * unit;
// Each copy is spent from `left`, which stops the loop.
for i in 0..whole as usize {
parts.push(fit(d, piece(i as f64 * unit, (i + 1) as f64 * unit), left)?);
}
if rest > 1e-6 {
let start = whole * unit;
match c.options.fractions {
Fractions::Scale => parts.push(fit(d, piece(start, start + rest), left)?),
Fractions::Chop => {
// The last copy cut off where the column ends, and nowhere else.
let cut = match (horizontal, far_low) {
(true, true) => (true, false, rect.x0),
(true, false) => (true, true, rect.x1),
(false, true) => (false, false, rect.y0),
(false, false) => (false, true, rect.y1),
};
parts.push(clipped(d, fit_affine(frame, piece(start, start + unit)), cut, left)?);
}
}
}
}
ColumnType::Sliding => match slide(frame, &c.guides, rect, horizontal) {
Some((kept, stretched, at)) => {
// Each copy cut at the guide, on its own side.
parts.push(clipped(d, kept, (horizontal, !horizontal, at), left)?);
parts.push(clipped(d, stretched, (horizontal, horizontal, at), left)?);
sliding = Some((kept, stretched, at));
}
None => parts.push(fit(d, rect, left)?),
},
ColumnType::Vertical => parts.push(fit(d, rect, left)?),
}
group(d, parts, label, sliding, left)
}
/// Sliding design with frame `frame` in column `rect`, at the column's width: the map of the part above the first
/// horizontal guide in `guides` inside the frame (in a bar, right of the first vertical one), scaled in proportion and
/// put at the rect's top (in a bar, its right end), the value end for values above zero; the map of the part below (left
/// of) it, stretched or compressed to fill the rest; and where the guide lands (y, or x in a bar). Both maps put the guide there. `None` without such a guide, or when the column is too
/// short for the part kept in proportion.
fn slide(frame: Rect, guides: &[Rect], rect: Rect, horizontal: bool) -> Option<(Affine, Affine, f64)> {
// A horizontal line (in a bar, a vertical one): longer than it is across, and at most a hundredth of the frame across.
let inside = |g: &&Rect| {
if horizontal {
g.width() < g.height() && g.width() <= frame.width() / 100.0 && g.center().x > frame.x0 && g.center().x < frame.x1
} else {
g.height() < g.width() && g.height() <= frame.height() / 100.0 && g.center().y > frame.y0 && g.center().y < frame.y1
}
};
let g = guides.iter().find(inside)?.center();
if horizontal {
let s = rect.height() / frame.height();
let (kept, stretched) = (frame.x1 - g.x, g.x - frame.x0);
let rest = rect.width() - kept * s;
if !(rest.is_finite() && rest > 1e-9) {
return None;
}
let k = rest / stretched;
let kept_map = Affine::new([s, 0.0, 0.0, s, rect.x1 - frame.x1 * s, rect.y0 - frame.y0 * s]);
let stretched_map = Affine::new([k, 0.0, 0.0, s, rect.x0 - frame.x0 * k, rect.y0 - frame.y0 * s]);
Some((kept_map, stretched_map, rect.x1 - kept * s))
} else {
let s = rect.width() / frame.width();
let (kept, stretched) = (g.y - frame.y0, frame.y1 - g.y);
let rest = rect.height() - kept * s;
if !(rest.is_finite() && rest > 1e-9) {
return None;
}
let k = rest / stretched;
let kept_map = Affine::new([s, 0.0, 0.0, s, rect.x0 - frame.x0 * s, rect.y0 - frame.y0 * s]);
let stretched_map = Affine::new([s, 0.0, 0.0, k, rect.x0 - frame.x0 * s, rect.y1 - frame.y1 * k]);
Some((kept_map, stretched_map, rect.y0 + kept * s))
}
}
pub(super) fn set_column(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "graph.column";
let id = target(s, p, C)?;
let mut spec = spec_of(s, id)?;
let count = spec.rows.iter().map(Vec::len).max().unwrap_or(0).min(vectorcraft_doc::MAX_GRAPH_SERIES);
let picked = picked_series(s, p, id, count, C)?;
let names = design_names(&s.doc()?.doc);
let all: Vec<usize> = if picked.is_empty() { (0..count).collect() } else { picked.clone() };
// The column design the picked series (all of them with none picked) share; a design deleted since doesn't count,
// as those series draw plain columns.
let used: Vec<Option<&ColumnDesign>> =
all.iter().map(|i| spec.series_columns.get(*i).and_then(Option::as_ref).filter(|c| names.contains(&c.design))).collect();
let shared = used.first().copied().flatten().filter(|c| used.iter().all(|x| *x == Some(*c))).cloned();
let Some(v) = p.get("design") else {
let options = shared.clone().unwrap_or_default();
return Ok(json!({
"designs": names,
"design": shared.map(|c| c.design),
"columnType": options.column_type.id(),
"each": options.each,
"fractions": options.fractions.id(),
}));
};
let design = match v {
Value::Null => None,
Value::String(n) if names.contains(n) => Some(n.clone()),
Value::String(n) => return Err(bad(C, format!("no design named `{n}`"))),
_ => return Err(bad(C, "`design` is a design name, or null for plain columns")),
};
let mut options = shared.unwrap_or_default();
if let Some(t) = p.get("columnType") {
options.column_type =
t.as_str().and_then(ColumnType::parse).ok_or_else(|| bad(C, "`columnType` is vertical, uniform, repeating or sliding"))?;
}
if let Some(e) = p.get("each") {
options.each =
e.as_f64().filter(|e| e.is_finite() && *e > 0.0).ok_or_else(|| bad(C, "`each` is the value one design stands for, more than 0"))?;
}
if let Some(f) = p.get("fractions") {
options.fractions = f.as_str().and_then(Fractions::parse).ok_or_else(|| bad(C, "`fractions` is chop or scale"))?;
}
let reselect: Vec<u32> = if p.get("seriesIndexes").is_none() { picked.iter().filter_map(|i| u32::try_from(*i).ok()).collect() } else { vec![] };
spec.series_columns.truncate(count);
spec.series_columns.resize(count, None);
for i in all {
if let Some(c) = spec.series_columns.get_mut(i) {
*c = design.clone().map(|design| ColumnDesign { design, ..options.clone() });
}
}
while spec.series_columns.last().is_some_and(Option::is_none) {
spec.series_columns.pop();
}
// Drawn once on a copy of the document, to refuse designs past the budget before the edit.
let mut probe = (*s.doc()?.doc).clone();
let looks = column_designs(&probe, &spec);
if generate_with(&mut probe, &spec, &looks).is_none() {
return Err(bad(C, "the design is too big to draw in every column of this graph"));
}
s.edit("Graph Column", |d, sel| {
regenerate(d, id, spec)?;
if !reselect.is_empty() {
reselect_series(d, sel, id, &reselect);
}
Ok(())
})?;
Ok(json!({ "id": id.0 }))
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.