e4f86d11fe8a
chartex.rs
//! Office 2016 charts (`cx:chartSpace`, the `chartEx` part): waterfall, funnel, treemap,
//! sunburst, histogram, Pareto and box & whisker. Their data sits in `cx:chartData` as levels of
//! points, and each series names its layout (`layoutId`).
use super::chart::rich_text;
use crate::xml::El;
use deckcraft_model::chart::{Chart, ChartType, Series};
use std::collections::HashMap;
/// Points per level and levels per dimension we keep (guards against hostile parts).
const MAX_POINTS: usize = 100_000;
const MAX_CHARTEX_POINTS: usize = 1_000_000;
/// One `cx:data`: its categories (the innermost level) and named numeric dimensions.
#[derive(Default)]
struct Data {
categories: Vec<String>,
/// Outer category levels, innermost first.
levels: Vec<Vec<String>>,
numbers: HashMap<String, (Vec<Option<f64>>, Option<String>)>,
}
/// A level's points, by `idx`.
fn points(lvl: &El, budget: &mut usize) -> Vec<String> {
if *budget == 0 {
return Vec::new();
}
let cap = MAX_POINTS.min(*budget);
let mut pts = Vec::new();
let mut max_idx = 0;
for pt in lvl.children_named("pt").take(cap) {
let i = pt.u32("idx").unwrap_or(0) as usize;
if i >= cap {
continue;
}
max_idx = max_idx.max(i + 1);
pts.push((i, pt.text()));
}
if pts.is_empty() {
return Vec::new();
}
let n = max_idx.min(cap);
let mut out = vec![String::new(); n];
for (i, s) in pts {
if let Some(target) = out.get_mut(i) {
*target = s;
}
}
*budget = budget.saturating_sub(out.len());
out
}
fn data(d: &El, budget: &mut usize) -> Data {
let mut out = Data::default();
for dim in d.elements().take(64) {
if *budget == 0 {
break;
}
// The first level is the innermost: a treemap's leaves, a waterfall's categories.
let Some(lvl) = dim.child("lvl") else { continue };
let ty = dim.attr("type").unwrap_or("");
if dim.is("strDim") || (dim.is("numDim") && ty == "cat") {
if ty == "cat" || out.categories.is_empty() {
out.categories = points(lvl, budget);
// Further levels are the hierarchy's parents, innermost first.
out.levels = dim.children_named("lvl").skip(1).take(deckcraft_model::chart::MAX_LEVELS).map(|l| points(l, budget)).collect();
}
} else if dim.is("numDim") {
let vals = points(lvl, budget).into_iter().map(|s| s.trim().parse::<f64>().ok().filter(|v| v.is_finite())).collect();
out.numbers.insert(ty.to_string(), (vals, lvl.attr("formatCode").map(str::to_string)));
}
}
out
}
fn kind_of(layout: &str) -> Option<ChartType> {
Some(match layout {
"waterfall" => ChartType::Waterfall,
"funnel" => ChartType::Funnel,
"treemap" => ChartType::Treemap,
"sunburst" => ChartType::Sunburst,
"clusteredColumn" => ChartType::Histogram,
"boxWhisker" => ChartType::BoxWhisker,
"regionMap" => ChartType::RegionMap,
_ => return None,
})
}
/// Parse a `chartEx` part. `None` for anything else, and for layouts DeckCraft has no type for.
pub fn read_chartex_xml(bytes: &[u8]) -> Option<Chart> {
let doc = crate::xml::parse(bytes).ok()?;
let mut root = doc.root;
super::resolve_mc(&mut root, 0);
let mut c = chartex_from(&root)?;
c.raw = Some(String::from_utf8_lossy(bytes).into_owned());
Some(c)
}
pub(crate) fn chartex_from(root: &El) -> Option<Chart> {
if !root.is("chartSpace") {
return None;
}
let mut decode_budget = MAX_CHARTEX_POINTS;
let datas: HashMap<String, Data> = root
.child("chartData")?
.children_named("data")
.take(64)
.map(|d| (d.attr("id").unwrap_or("0").to_string(), data(d, &mut decode_budget)))
.collect();
let ch = root.child("chart")?;
let region = ch.child("plotArea")?.child("plotAreaRegion")?;
let mut c = Chart { categories: vec![], series: vec![], title: None, legend: None, gridlines: false, ..Default::default() };
c.title = ch.child("title").map(|t| rich_text(t).filter(|s| !s.is_empty()).unwrap_or_else(|| "Chart Title".into()));
c.legend = ch.child("legend").map(|l| l.attr("pos").unwrap_or("t").to_string());
let mut kind = None;
let mut output_budget = MAX_CHARTEX_POINTS;
let mut categories_set = false;
for s in region.children_named("series").take(1000) {
let layout = s.attr("layoutId").unwrap_or("");
if layout == "paretoLine" {
// The cumulative line PowerPoint adds to a Pareto histogram.
kind = Some(ChartType::Pareto);
continue;
}
let k = kind_of(layout)?;
if s.bool("hidden") == Some(true) {
continue;
}
kind = Some(match kind {
Some(ChartType::Pareto) => ChartType::Pareto,
_ => k,
});
let d = datas.get(s.child("dataId").and_then(|i| i.attr("val")).unwrap_or("0"))?;
let (values_src, format) = ["val", "size", "colorVal"]
.iter()
.find_map(|t| d.numbers.get(*t))
.or_else(|| d.numbers.values().next())
.map(|(v, f)| (v.as_slice(), f.clone()))
.unwrap_or((&[], None));
let take_len = values_src.len().min(output_budget);
let values = values_src[..take_len].to_vec();
output_budget = output_budget.saturating_sub(values.len());
if !categories_set && (!d.categories.is_empty() || !d.levels.is_empty()) {
categories_set = true;
c.categories = d.categories.clone();
c.category_levels = d.levels.clone();
output_budget = output_budget.saturating_sub(c.categories.len());
for lvl in &c.category_levels {
output_budget = output_budget.saturating_sub(lvl.len());
}
}
if let Some(st) = s.child("layoutPr").and_then(|l| l.child("statistics")) {
c.inclusive_quartiles = st.attr("quartileMethod") == Some("inclusive");
}
if let Some(b) = s.child("layoutPr").and_then(|l| l.child("binning")) {
c.bin_count = b.child("binCount").and_then(|n| n.u32("val")).filter(|n| *n > 0);
c.bin_size = b.child("binSize").and_then(|n| n.attr("val")).and_then(|v| v.parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0);
}
if let Some(st) = s.child("layoutPr").and_then(|l| l.child("subtotals")) {
c.subtotals = st.children_named("idx").filter_map(|i| i.u32("val")).map(|i| i as usize).take(MAX_POINTS).collect();
}
let name = s.child("tx").and_then(|t| t.find("v")).map(|v| v.text()).unwrap_or_default();
c.series.push(Series {
name,
values,
data_labels: s.child("dataLabels").map(|l| l.bool("hidden") != Some(true)),
number_format: format,
..Default::default()
});
}
c.kind = kind?;
c.data_labels = c.series.iter().any(|s| s.data_labels == Some(true));
c.vary_colors = matches!(c.kind, ChartType::Funnel | ChartType::Treemap | ChartType::Sunburst | ChartType::Waterfall);
// Waterfall, histogram and box charts have a value axis with gridlines by default.
c.gridlines = matches!(c.kind, ChartType::Waterfall | ChartType::Histogram | ChartType::Pareto | ChartType::BoxWhisker);
Some(c)
}
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.