Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! Series of axis-based groups: bars, lines, areas, scatter, bubbles, and
//! stock (high-low lines and up/down bars).
use super::canvas::Canvas;
use super::dlabel::{self, Pending};
use super::look::Look;
use super::model::{Blanks, GroupModel, Grouping, Kind, LabelPos, SeriesModel};
use super::plot::{Mapping, Plot, x_values};
use super::style::{resolve_fill, resolve_line, solid_line};
use crate::model::color::Rgba;
use crate::model::fill::Fill;
use crate::path::{Path, Point, Rect};
/// Drawing order of group kinds (areas at the back, points at the front).
fn rank(k: Kind) -> u8 {
match k {
Kind::Area => 0,
Kind::Bar => 1,
Kind::Stock => 2,
Kind::Line => 3,
Kind::Scatter => 4,
Kind::Bubble => 5,
_ => 6,
}
}
/// Draws every axis-based group; data labels are collected into `labels`.
pub(crate) fn draw(cv: &mut Canvas<'_>, p: &Plot<'_>, chart: Rect, labels: &mut Vec<Pending>) {
let mut trend_budget = super::trend::MAX_PER_CHART;
let mut order: Vec<(usize, usize, usize)> = p.groups.clone();
order.sort_by_key(|&(gi, _, _)| rank(p.m.groups[gi].kind));
for (gi, ca, va) in order {
let g = &p.m.groups[gi];
let margin = match g.kind {
Kind::Bar | Kind::Area => 0.0,
_ => 8.0,
};
let clip = p.bounds().outset(margin);
let mut pending = Vec::new();
cv.clipped(clip, |cv| match g.kind {
Kind::Bar => bars(cv, p, g, ca, va, &mut pending),
Kind::Area => areas(cv, p, g, ca, va, &mut pending),
Kind::Line => lines(cv, p, g, ca, va, &mut pending),
Kind::Stock => {
stock(cv, p, g, ca, va);
lines(cv, p, g, ca, va, &mut pending);
}
Kind::Scatter | Kind::Bubble => scatter(cv, p, g, ca, va, &mut pending),
_ => {}
});
for Label {
at,
point,
block,
l,
} in pending
{
let center = dlabel::offset(at, &l, chart);
labels.push(Pending {
leader: dlabel::moved_leader(p.m, &l, &block, center, point),
block,
center,
shape: l.shape.clone(),
rot: dlabel::rotation(&l),
});
}
super::trend::draw(cv, p, g, (ca, va), &mut trend_budget, labels);
}
}
/// A data label at its default place `at`, describing the data point at `point`.
struct Label {
at: Point,
point: Point,
block: super::canvas::Block,
l: super::model::LabelModel,
}
/// Category count of a category axis.
fn count(p: &Plot<'_>, ca: usize) -> usize {
match p.axes[ca].map {
Mapping::Cat { count, .. } => count,
Mapping::Val(_) => 0,
}
}
/// Values of series `s` after stacking: `(from, to)` per category.
struct Stacker {
pos: Vec<f64>,
neg: Vec<f64>,
totals: Vec<f64>,
mode: Grouping,
}
impl Stacker {
fn new(g: &GroupModel, n: usize) -> Self {
let mut totals = vec![0.0; n];
for s in &g.series {
for (i, t) in totals.iter_mut().enumerate() {
if let Some(v) = s.value(i) {
*t += v.abs();
}
}
}
Self {
pos: vec![0.0; n],
neg: vec![0.0; n],
totals,
mode: g.grouping,
}
}
fn stacked(&self) -> bool {
matches!(self.mode, Grouping::Stacked | Grouping::Percent)
}
/// The span of value `v` at category `i` (`base` for unstacked groups).
fn push(&mut self, i: usize, v: f64, base: f64) -> (f64, f64) {
if !self.stacked() || i >= self.pos.len() {
return (base, v);
}
let v = if self.mode == Grouping::Percent {
if self.totals[i] == 0.0 {
0.0
} else {
v / self.totals[i]
}
} else {
v
};
let cum = if v >= 0.0 {
&mut self.pos[i]
} else {
&mut self.neg[i]
};
let from = *cum;
*cum += v;
(from, *cum)
}
/// The running top of category `i` (lines and areas stack on positives and negatives alike).
fn push_line(&mut self, i: usize, v: f64) -> (f64, f64) {
if !self.stacked() || i >= self.pos.len() {
return (0.0, v);
}
let v = if self.mode == Grouping::Percent {
if self.totals[i] == 0.0 {
0.0
} else {
v / self.totals[i]
}
} else {
v
};
let from = self.pos[i];
self.pos[i] += v;
(from, self.pos[i])
}
fn percent(&self, i: usize, v: f64) -> Option<f64> {
let t = self.totals.get(i).copied().unwrap_or(0.0);
(t != 0.0).then(|| v / t)
}
}
fn bars(
cv: &mut Canvas<'_>,
p: &Plot<'_>,
g: &GroupModel,
ca: usize,
va: usize,
labels: &mut Vec<Label>,
) {
let m = p.m;
let n = count(p, ca);
let mut st = Stacker::new(g, n);
let nb = if st.stacked() {
1.0
} else {
g.series.len().max(1) as f64
};
let overlap = g.overlap.map_or(if st.stacked() { 1.0 } else { 0.0 }, |o| {
f64::from(o) / 100.0
});
let gap = f64::from(g.gap_width) / 100.0;
let slot = p.slot_t(ca);
let bar = slot / (nb - (nb - 1.0) * overlap + gap).max(0.01);
let cluster = bar * (nb - (nb - 1.0) * overlap);
let step = bar * (1.0 - overlap);
let base = p.base_value(va);
for (k, s) in g.series.iter().enumerate() {
let look = m.look(g, s, None);
for i in 0..s.len().min(n) {
let Some(v) = s.value(i) else { continue };
let (from, to) = st.push(i, v, base);
let c = p.cat_t(ca, i as f64);
let lo = c - cluster / 2.0 + if st.stacked() { 0.0 } else { k as f64 * step };
let (a0, a1) = (p.coord(ca, lo), p.coord(ca, lo + bar));
let (v0, v1) = (p.coord(va, p.val_t(va, from)), p.coord(va, p.val_t(va, to)));
let r = if g.horizontal {
Rect::from_ltrb(v0.min(v1), a0.min(a1), v0.max(v1), a0.max(a1))
} else {
Rect::from_ltrb(a0.min(a1), v0.min(v1), a0.max(a1), v0.max(v1))
};
let pl = if s.points.is_empty() && !m.varies(g) {
look.clone()
} else {
m.look(g, s, Some(i))
};
let invert = s
.point(i)
.and_then(|d| d.invert)
.unwrap_or(s.invert_if_negative)
&& v < 0.0;
let fill = if invert && matches!(pl.fill, Some(Fill::Solid(_)) | None) {
Some(Fill::Solid(Rgba::WHITE))
} else {
pl.fill.clone()
};
// 3-D bars are boxes; their labels follow the front face.
let (r, v0, v1) = match &p.depth {
Some(d) => {
super::depth::draw_box(cv, d, r, fill.as_ref(), pl.line.as_ref());
let f = d.front(r);
let shift = if g.horizontal { f.x - r.x } else { f.y - r.y };
(f, v0 + shift, v1 + shift)
}
None => {
cv.shape(&Path::rect(r), fill.as_ref(), pl.line.as_ref(), r);
(r, v0, v1)
}
};
if let Some((block, l)) = dlabel::make(cv, m, g, s, i, st.percent(i, v)) {
let c = dlabel::place_bar(&block, &l, g, r, v1, v0);
// Leader lines reach the bar's end (its middle for inside labels).
let inside = matches!(
l.pos,
Some(LabelPos::Center | LabelPos::InBase | LabelPos::InEnd)
);
let mid = Point::new(r.x + r.w / 2.0, r.y + r.h / 2.0);
let point = match (inside, g.horizontal) {
(true, _) => mid,
(false, true) => Point::new(v1, mid.y),
(false, false) => Point::new(mid.x, v1),
};
labels.push(Label {
at: c,
point,
block,
l,
});
}
}
}
}
/// Builds a polyline or smooth curve through `pts`.
fn curve(pts: &[Point], smooth: bool) -> Path {
let mut path = Path::new();
let Some(&first) = pts.first() else {
return path;
};
path.move_to(first);
if !smooth || pts.len() < 3 {
for &q in &pts[1..] {
path.line_to(q);
}
return path;
}
// Catmull-Rom spline as cubic Béziers.
let k = 1.0 / 6.0;
for i in 0..pts.len() - 1 {
let p0 = pts[i.saturating_sub(1)];
let p1 = pts[i];
let p2 = pts[i + 1];
let p3 = pts[(i + 2).min(pts.len() - 1)];
let c1 = Point::new(p1.x + (p2.x - p0.x) * k, p1.y + (p2.y - p0.y) * k);
let c2 = Point::new(p2.x - (p3.x - p1.x) * k, p2.y - (p3.y - p1.y) * k);
path.cubic_to(c1, c2, p2);
}
path
}
/// Splits optional points into runs according to the blank-cell rule.
fn runs(pts: &[Option<Point>], blanks: Blanks) -> Vec<Vec<Point>> {
let mut out: Vec<Vec<Point>> = vec![Vec::new()];
for p in pts {
match p {
Some(q) => out.last_mut().expect("non-empty").push(*q),
None if blanks == Blanks::Span => {}
None => out.push(Vec::new()),
}
}
out.retain(|r| !r.is_empty());
out
}
fn markers_and_labels(
cv: &mut Canvas<'_>,
p: &Plot<'_>,
g: &GroupModel,
s: &SeriesModel,
look: &Look,
pts: &[(usize, Point, Option<f64>)],
labels: &mut Vec<Label>,
) {
let m = p.m;
let per_point = !s.points.is_empty() || m.varies(g);
for &(i, q, pct) in pts {
let pl = if per_point {
m.look(g, s, Some(i))
} else {
look.clone()
};
let size = pl.marker.as_ref().map_or(0.0, |mk| mk.size);
if let Some(mk) = &pl.marker {
cv.marker(mk.symbol, q, mk.size, mk.fill.as_ref(), mk.line.as_ref());
}
if let Some((block, l)) = dlabel::make(cv, m, g, s, i, pct) {
let c = dlabel::place_point(&block, &l, g, q, size);
labels.push(Label {
at: c,
point: q,
block,
l,
});
}
}
}
fn lines(
cv: &mut Canvas<'_>,
p: &Plot<'_>,
g: &GroupModel,
ca: usize,
va: usize,
labels: &mut Vec<Label>,
) {
let m = p.m;
let n = count(p, ca);
let mut st = Stacker::new(g, n);
for s in &g.series {
let look = m.look(g, s, None);
let mut pts: Vec<Option<Point>> = Vec::with_capacity(n);
let mut marks = Vec::new();
for i in 0..s.len().min(n) {
let v = match s.value(i) {
Some(v) => Some(v),
None if m.blanks == Blanks::Zero || st.stacked() => Some(0.0),
None => None,
};
let Some(v) = v else {
pts.push(None);
continue;
};
let (_, top) = st.push_line(i, v);
let q = Point::new(
p.coord(ca, p.cat_t(ca, i as f64)),
p.coord(va, p.val_t(va, top)),
);
pts.push(Some(q));
if s.value(i).is_some() {
marks.push((i, q, st.percent(i, v)));
}
}
if let Some(l) = &look.line {
let mut path = Path::new();
for run in runs(&pts, m.blanks) {
path.extend(&curve(&run, s.smooth));
}
cv.stroke(&path, l);
}
markers_and_labels(cv, p, g, s, &look, &marks, labels);
}
}
fn areas(
cv: &mut Canvas<'_>,
p: &Plot<'_>,
g: &GroupModel,
ca: usize,
va: usize,
labels: &mut Vec<Label>,
) {
let m = p.m;
let n = count(p, ca);
if n == 0 {
return;
}
let mut st = Stacker::new(g, n);
let base = p.base_value(va);
for s in &g.series {
let look = m.look(g, s, None);
let mut upper = Vec::with_capacity(n);
let mut lower = Vec::with_capacity(n);
let mut marks = Vec::new();
for i in 0..n {
let v = s.value(i).unwrap_or(0.0);
let (from, to) = if st.stacked() {
st.push_line(i, v)
} else {
(base, v)
};
let x = p.coord(ca, p.cat_t(ca, i as f64));
let top = Point::new(x, p.coord(va, p.val_t(va, to)));
upper.push(top);
lower.push(Point::new(x, p.coord(va, p.val_t(va, from))));
if s.value(i).is_some() {
let mid = Point::new(x, (top.y + p.coord(va, p.val_t(va, from))) / 2.0);
marks.push((i, mid, st.percent(i, v)));
}
}
let mut path = Path::new();
for (k, q) in upper.iter().enumerate() {
if k == 0 {
path.move_to(*q)
} else {
path.line_to(*q)
}
}
for q in lower.iter().rev() {
path.line_to(*q);
}
path.close();
let bbox = path.bounds().unwrap_or(p.inner);
cv.shape(&path, look.fill.as_ref(), look.line.as_ref(), bbox);
for (i, q, pct) in marks {
if let Some((block, l)) = dlabel::make(cv, m, g, s, i, pct) {
let c = dlabel::place_point(&block, &l, g, q, 0.0);
labels.push(Label {
at: c,
point: q,
block,
l,
});
}
}
}
}
fn scatter(
cv: &mut Canvas<'_>,
p: &Plot<'_>,
g: &GroupModel,
xa: usize,
ya: usize,
labels: &mut Vec<Label>,
) {
let m = p.m;
let bubble = g.kind == Kind::Bubble;
let max_size = g
.series
.iter()
.filter_map(|s| s.bubble.as_ref())
.flat_map(|b| b.nums.iter().flatten().copied())
.map(f64::abs)
.fold(0.0f64, f64::max);
let max_r = f64::from(p.inner.w.min(p.inner.h)) * 0.125 * f64::from(g.bubble_scale) / 100.0;
for s in &g.series {
let look = m.look(g, s, None);
let xs = x_values(s);
let mut pts: Vec<Option<Point>> = Vec::new();
let mut marks = Vec::new();
for (i, x) in xs.iter().enumerate() {
let (Some(x), Some(y)) = (*x, s.value(i)) else {
pts.push(None);
continue;
};
let q = Point::new(p.coord(xa, p.val_t(xa, x)), p.coord(ya, p.val_t(ya, y)));
pts.push(Some(q));
marks.push((i, q, None));
}
if bubble {
for &(i, q, _) in &marks {
let size = s.bubble.as_ref().and_then(|b| b.num(i)).unwrap_or(1.0);
if size < 0.0 && !g.show_neg_bubbles || max_size <= 0.0 {
continue;
}
let frac = size.abs() / max_size;
let r = if g.size_is_width {
max_r * frac
} else {
max_r * frac.sqrt()
} as f32;
let pl = m.look(g, s, Some(i));
let c = Rect::from_xywh(q.x - r, q.y - r, 2.0 * r, 2.0 * r);
let fill = if size < 0.0 {
Some(Fill::Solid(Rgba::WHITE))
} else {
pl.fill.clone()
};
cv.shape(&Path::ellipse(c), fill.as_ref(), pl.line.as_ref(), c);
if let Some((block, l)) = dlabel::make(cv, m, g, s, i, None) {
let at = dlabel::place_point(&block, &l, g, q, 0.0);
labels.push(Label {
at,
point: q,
block,
l,
});
}
}
continue;
}
if let Some(l) = &look.line {
let smooth = s.smooth || g.style.starts_with("smooth");
let mut path = Path::new();
for run in runs(&pts, m.blanks) {
path.extend(&curve(&run, smooth));
}
cv.stroke(&path, l);
}
markers_and_labels(cv, p, g, s, &look, &marks, labels);
}
}
/// High-low lines and up/down bars of a stock group.
fn stock(cv: &mut Canvas<'_>, p: &Plot<'_>, g: &GroupModel, ca: usize, va: usize) {
let m = p.m;
let n = count(p, ca);
let hi_low = g
.hi_low
.as_ref()
.and_then(|shape| resolve_line(shape.line.as_ref(), Some(solid_line(m.palette.tx1, 0.75))));
if let Some(l) = hi_low {
let mut path = Path::new();
for i in 0..n {
let vals: Vec<f64> = g.series.iter().filter_map(|s| s.value(i)).collect();
if vals.len() < 2 {
continue;
}
let lo = vals.iter().copied().fold(f64::INFINITY, f64::min);
let hi = vals.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let x = p.coord(ca, p.cat_t(ca, i as f64));
path.move_to(Point::new(x, p.coord(va, p.val_t(va, lo))));
path.line_to(Point::new(x, p.coord(va, p.val_t(va, hi))));
}
cv.stroke(&path, &l);
}
if let (Some((up, down, gap)), Some(open), Some(close)) =
(&g.up_down, g.series.first(), g.series.last())
{
if g.series.len() < 2 {
return;
}
let w = p.slot_t(ca) / (1.0 + f64::from(*gap) / 100.0);
let border = solid_line(m.palette.tx1, 0.75);
for i in 0..n {
let (Some(o), Some(c)) = (open.value(i), close.value(i)) else {
continue;
};
let t = p.cat_t(ca, i as f64);
let (x0, x1) = (p.coord(ca, t - w / 2.0), p.coord(ca, t + w / 2.0));
let (y0, y1) = (p.coord(va, p.val_t(va, o)), p.coord(va, p.val_t(va, c)));
let r = Rect::from_ltrb(x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1));
let (shape, auto) = if c >= o {
(up, m.palette.bg1)
} else {
(down, m.palette.tx1)
};
let fill = resolve_fill(shape, Some(Fill::Solid(auto)));
let line = resolve_line(shape.line.as_ref(), Some(border.clone()));
cv.shape(&Path::rect(r), fill.as_ref(), line.as_ref(), r);
}
}
}