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
//! Tick computation for a plot: automatic value scales, category label
//! rotation/wrapping/thinning, date-axis labels, and axis titles.
use super::axis::{Fixed, Scale, auto_scale};
use super::canvas::{Block, Canvas, LINE_HEIGHT};
use super::model::TickLabels;
use super::numfmt;
use super::plot::{LABEL_GAP, Mapping, Plot, TICK_LEN, TickLabel, V_DENSITY, title_paras};
use super::style::Role;
use crate::render::label::HAlign;
/// Widest axis title running across its axis, as a fraction of the chart.
const ACROSS_TITLE: f32 = 0.2;
/// Whether every `k`-th label clears its shown neighbours horizontally: a
/// label wider than its slot (an unbreakable word) may use spare room beside
/// shorter neighbours. A lone label must fit its slot.
fn pairs_fit(blocks: &[Block], k: usize, slot: f32, pad: f32) -> bool {
let k = k.max(1);
let room = slot * k as f32;
if let [only] = blocks {
return only.width + pad <= room;
}
let shown: Vec<f32> = blocks.iter().step_by(k).map(|b| b.width).collect();
shown.windows(2).all(|w| (w[0] + w[1]) / 2.0 + pad <= room)
}
impl Plot<'_> {
/// Automatic scales for value axes, given the current plot size.
pub(crate) fn compute_scales(&mut self, cv: &Canvas<'_>) {
for ai in 0..self.axes.len() {
if !self.axes[ai].is_value {
continue;
}
let len = self.len(ai).max(1.0);
let a = &self.axes[ai];
let fixed = Fixed {
min: a.model.min,
max: a.model.max,
major: a.model.major_unit,
minor: a.model.minor_unit,
log_base: a.model.log_base,
};
let size = a.style.size;
let data = if a.percent {
a.data.map(|(lo, hi)| (lo.max(-1.0), hi.min(1.0)))
} else {
a.data
};
let scale = if a.vertical {
let max_n = (len / (size * V_DENSITY)).floor().max(1.0) as usize;
auto_scale(data, fixed, a.percent, max_n, &|_| true)
} else {
let fmt = a.fmt.clone();
let style = a.style.clone();
let unit = a.model.disp_unit.unwrap_or(1.0);
let date1904 = self.m.date1904;
let fits = move |s: &Scale| {
let ticks = s.ticks();
if ticks.len() < 2 {
return true;
}
let spacing = len / (ticks.len() - 1) as f32;
let widths: Vec<f32> = ticks
.iter()
.map(|v| cv.measure(&numfmt::format(v / unit, &fmt, date1904), &style))
.collect();
widths
.windows(2)
.all(|w| (w[0] + w[1]) / 2.0 + style.size * 0.6 <= spacing)
};
auto_scale(data, fixed, a.percent, 10, &fits)
};
self.axes[ai].map = Mapping::Val(scale);
}
}
/// Tick labels (with category label rotation, wrapping, and thinning).
pub(crate) fn compute_labels(&mut self, cv: &Canvas<'_>) {
let date1904 = self.m.date1904;
for ai in 0..self.axes.len() {
let len = self.len(ai).max(1.0);
if self.date_labels(cv, ai, len) {
continue;
}
let a = &self.axes[ai];
let mut labels = Vec::new();
let mut rot = a.model.text.rot.unwrap_or(0.0);
if a.model.deleted || a.model.tick_labels == TickLabels::None {
self.axes[ai].labels = labels;
continue;
}
match &a.map {
Mapping::Val(s) => {
let unit = a.model.disp_unit.unwrap_or(1.0);
for v in s.ticks() {
let text = numfmt::format(v / unit, &a.fmt, date1904);
labels.push(TickLabel {
t: s.norm(v),
block: cv.plain(&text, &a.style, f32::INFINITY, HAlign::Center),
});
}
}
Mapping::Cat { count, between } => {
let n = *count;
if n == 0 {
self.axes[ai].labels = labels;
continue;
}
let slot = if *between || n <= 1 {
len / n as f32
} else {
len / (n - 1) as f32
};
// Labels thinned explicitly get the room of the skipped ones.
let slot = slot * a.model.label_skip.unwrap_or(1) as f32;
let lh = a.style.size * LINE_HEIGHT;
let pad = a.style.size * 0.3;
let touch = a.style.size * 0.1;
let explicit_rot = a.model.text.rot;
let blocks: Vec<Block>;
let mut skip;
if a.vertical {
// Room beside the plot (manual layouts), at least 40% of the chart.
let room = (self.inner.x - cv.chart.x)
.max(cv.chart.right() - self.inner.right())
- TICK_LEN
- LABEL_GAP;
let max_w = room.max(cv.chart.w * 0.4).max(a.style.size * 3.0);
blocks = a
.cat_text
.iter()
.map(|t| cv.plain(t, &a.style, max_w, HAlign::Center))
.collect();
let h = blocks
.iter()
.map(|b| b.rotated_size(rot).1)
.fold(lh, f32::max);
skip = (h / slot).ceil().max(1.0) as usize;
} else {
let single: Vec<Block> = a
.cat_text
.iter()
.map(|t| cv.plain(t, &a.style, f32::INFINITY, HAlign::Center))
.collect();
if let Some(r) = explicit_rot.filter(|r| r.abs() > 0.5) {
rot = r;
blocks = single;
} else if single.iter().all(|b| b.width + pad <= slot) {
rot = 0.0;
blocks = single;
} else {
// Wrap to the slot; neighbours then only need not touch.
let wrapped: Vec<Block> = a
.cat_text
.iter()
.map(|t| cv.plain(t, &a.style, slot.max(1.0), HAlign::Center))
.collect();
let fits = wrapped.iter().all(|b| b.lines.len() <= 3)
&& pairs_fit(&wrapped, 1, slot, touch);
// An explicit horizontal angle still wraps, never turns.
if fits || explicit_rot.is_some() {
rot = 0.0;
blocks = wrapped;
} else {
rot = -45.0;
blocks = single;
}
}
skip = if rot.abs() < 0.5 {
(1..blocks.len().max(1))
.find(|&k| pairs_fit(&blocks, k, slot, touch))
.unwrap_or(blocks.len().max(1))
} else {
let foot =
lh / (f64::from(rot).to_radians().sin().abs() as f32).max(0.1);
(foot / slot).ceil().max(1.0) as usize
};
}
if let Some(k) = a.model.label_skip {
skip = k;
}
for (i, b) in blocks.into_iter().enumerate().step_by(skip.max(1)) {
labels.push(TickLabel {
t: self.cat_t(ai, i as f64),
block: b,
});
}
}
}
self.axes[ai].rot = rot;
self.axes[ai].labels = labels;
self.outer_rows(cv, ai, len);
}
// A data table replaces the labels of its category axis.
self.layout_table(cv);
if let Some(ai) = self.table.as_ref().map(|t| t.axis) {
self.axes[ai].labels.clear();
self.axes[ai].outer.clear();
}
// Axis titles.
for ai in 0..self.axes.len() {
let a = &self.axes[ai];
let title = match (&a.model.title, a.model.deleted) {
(Some(t), false) => {
let base = self.m.base_text(Role::AxisTitle);
let paras = title_paras(t, &base, "Axis Title");
let rot = t
.rich
.as_ref()
.and_then(|r| r.rot)
.or(t.tx_pr.rot)
.unwrap_or(if a.vertical { -90.0 } else { 0.0 });
// Text running along the axis wraps at its length; text
// across it at a fraction of the chart.
let along = (rot.abs() > 45.0) == a.vertical;
let max_w = match (along, a.vertical) {
(true, true) => self.inner.h,
(true, false) => self.inner.w,
(false, true) => cv.chart.w * ACROSS_TITLE,
(false, false) => cv.chart.h * ACROSS_TITLE,
}
.max(20.0);
let block = cv.layout(¶s, max_w);
Some((block, rot))
}
_ => None,
};
let unit = match (&a.model.disp_label, a.model.deleted) {
(Some((t, name)), false) if a.model.disp_unit.is_some() => {
let paras = title_paras(t, &self.m.base_text(Role::AxisTitle), name);
let block = cv.layout(¶s, f32::INFINITY);
let rot = t
.rich
.as_ref()
.and_then(|r| r.rot)
.or(t.tx_pr.rot)
.unwrap_or(if a.vertical { -90.0 } else { 0.0 });
(!block.is_empty()).then_some((block, rot))
}
_ => None,
};
self.axes[ai].title = title;
self.axes[ai].unit = unit;
}
}
/// Groups of the outer levels of multi-level categories.
fn outer_rows(&mut self, cv: &Canvas<'_>, ai: usize, len: f32) {
let a = &self.axes[ai];
let n = match a.map {
Mapping::Cat { count, .. } => count,
Mapping::Val(_) => 0,
};
if a.model.deleted || a.model.tick_labels == TickLabels::None || n == 0 {
self.axes[ai].outer = Vec::new();
return;
}
let half = self.slot_t(ai) / 2.0;
let mut rows = Vec::new();
for level in &a.outer_text {
let starts: Vec<usize> = (0..n)
.filter(|&i| {
level
.get(i)
.and_then(|v| v.as_deref())
.is_some_and(|v| !v.is_empty())
})
.collect();
let mut row = Vec::new();
for (k, &start) in starts.iter().enumerate() {
let end = starts.get(k + 1).map_or(n - 1, |next| next - 1);
let (t0, t1) = (
self.cat_t(ai, start as f64) - half,
self.cat_t(ai, end as f64) + half,
);
let span = (len * (t1 - t0).abs() as f32).max(a.style.size * 2.0);
let text = level[start].as_deref().unwrap_or("");
let max_w = if a.vertical { f32::INFINITY } else { span };
row.push((t0, t1, cv.plain(text, &a.style, max_w, HAlign::Center)));
}
rows.push(row);
}
self.axes[ai].outer = rows;
}
/// Ticks and labels of a date axis; `false` when `ai` is not one.
fn date_labels(&mut self, cv: &Canvas<'_>, ai: usize, len: f32) -> bool {
let a = &self.axes[ai];
let Some(d) = &a.date else { return false };
let date1904 = self.m.date1904;
let pad = a.style.size * 0.6;
let widest = cv
.measure(&numfmt::format(d.end, &a.fmt, date1904), &a.style)
.max(cv.measure(&numfmt::format(d.start, &a.fmt, date1904), &a.style));
let max_labels = if a.vertical {
len / (a.style.size * LINE_HEIGHT)
} else {
len / (widest + pad)
};
let (step, unit) = d.major(
&a.model,
a.model.major_time,
max_labels.floor().max(1.0) as usize,
);
let dates = d.label_dates(step, unit);
let half = if d.between { d.slot() / 2.0 } else { 0.0 };
let ticks: Vec<f64> = dates
.iter()
.map(|&s| d.date_t(s) - half)
.filter(|t| (-1e-9..=1.0 + 1e-9).contains(t))
.collect();
let mut labels = Vec::new();
let mut rot = a.model.text.rot.unwrap_or(0.0);
if !a.model.deleted && a.model.tick_labels != TickLabels::None {
let spacing = if dates.len() > 1 {
len * (d.date_t(dates[1]) - d.date_t(dates[0])) as f32
} else {
len
};
if a.model.text.rot.is_none() && !a.vertical && widest + pad > spacing {
rot = -45.0;
}
for s in dates {
let t = d.date_t(s);
if (-1e-9..=1.0 + 1e-9).contains(&t) {
let text = numfmt::format(s, &a.fmt, date1904);
labels.push(TickLabel {
t,
block: cv.plain(&text, &a.style, f32::INFINITY, HAlign::Center),
});
}
}
}
let ax = &mut self.axes[ai];
ax.date_ticks = ticks;
ax.labels = labels;
ax.rot = rot;
true
}
}