/// data.)
#[derive(Clone, Debug)]
pub struct Dimension {
- /// Our axis within the pivot table.
- axis: Axis3,
-
/// The index for this dimension within its axis.
///
/// This [Dimension] is `pivot_table.axes[axis].dimensions[level]`.
self.root.assign_label_depth(label_position);
let root = self.root.build(label_position, None, &mut leaves);
Dimension {
- axis: self.axis,
level,
top_index,
root,
LabelPosition::Nested
};
let d = Arc::new(d.build(axes[axis].len(), top_index, label_position));
- axes[d.axis].push(d.clone());
+ axes[axis].push(d.clone());
dimensions.push(d);
}
table.dimensions = dimensions;
table.axes = axes.map(|_axis, dimensions| {
let label_depth = dimensions.iter().map(|d| d.label_depth()).sum();
- dbg!(label_depth);
let extent = dimensions.iter().map(|d| d.data_leaves.len()).product();
Axis {
dimensions,
footnote_marker_type: self.look.footnote_marker_type,
}
}
+
+ pub fn transpose(&mut self) {
+ self.axes.swap(Axis3::X, Axis3::Y);
+ }
}
pub struct Layers {}
fixed_indexes: &[usize],
fixed_axis: Axis3,
) -> bool {
- dbg!();
let vary_axis = fixed_axis.transpose().unwrap();
for vary_indexes in self.axes[vary_axis].iter() {
let mut presentation_indexes = enum_map! {
presentation_indexes[vary_axis] = &vary_indexes;
let data_indexes = self.convert_indexes_ptod(presentation_indexes);
if self.get(&data_indexes).is_some() {
- dbg!();
return false;
}
}
- dbg!();
true
}
fn enumerate_axis(
pt.insert(&[i], Value::new_number(Some(i as f64)));
}
let mut driver = TextDriver::new(File::create("/dev/stdout").unwrap());
- driver.write(&Arc::new(Item::new(Details::Table(Box::new(pt.build())))));
+ let mut pt = pt.build();
+ driver.write(&Arc::new(Item::new(Details::Table(Box::new(pt.clone())))));
+ pt.transpose();
+ driver.write(&Arc::new(Item::new(Details::Table(Box::new(pt)))));
}
fn new(table: Arc<Table>, device: &dyn Device, min_width: usize, look: &Look) -> Self {
use Axis2::*;
- dbg!(&table);
let n = table.n.clone();
// Figure out rule widths.
.map(|z| measure_rule(&*device, &*table, axis, z))
.collect::<Vec<_>>()
});
- dbg!(&rules);
let px_size = device.params().px_size.unwrap_or_default();
let heading_widths = look
}
}
}
- dbg!(&unspanned_columns);
// Distribute widths of spanned columns.
let mut columns = unspanned_columns.clone();
columns[1][i] = columns[0][i];
}
}
- dbg!(&columns);
// Decide final column widths.
let rule_widths = rules[X].iter().copied().sum::<usize>();
.iter()
.map(|row| row.iter().sum::<usize>() + rule_widths)
.collect::<SmallVec<[usize; 2]>>();
- dbg!(&table_widths);
let cp_x = if table_widths[1] <= device.params().size[X] {
// Fits even with maximum widths. Use them.
// later we can break it horizontally into multiple pages.
Self::use_row_widths(&columns[0], &rules[X])
};
- dbg!(&cp_x);
// Calculate heights of cells that do not span multiple rows.
let mut unspanned_rows = vec![0; n[Y]];
}
fn find_breakpoint(&mut self, device: &dyn Device, size: usize) -> Option<(usize, usize)> {
- dbg!(self.axis, self.z..self.page.n[self.axis]);
for z in self.z..self.page.n[self.axis] {
let needed = self.needed_size(z + 1);
if needed > size {
postindex
};
if index <= self.indexes.end {
- dbg!();
continue;
}
//
// We trim trailing spaces from the line we return, and leading
// spaces from the position where we resume.
- dbg!();
let segment = self.text[self.indexes.clone()].trim_end();
let start = self.text[self.indexes.end..].trim_start_matches([' ', '\t']);
) {
let display = Self::display_cell(cell);
let text = display.to_string();
- println!("text={text:?} bb={bb:?}");
let horz_align = cell
.style
.cell_style
HorzAlign::Left => bb[X].start,
HorzAlign::Center => (bb[X].start + bb[X].end - width + 1) / 2,
};
- dbg!(horz_align);
let Some((x, text)) = clip_text(&text, &(x..x + width), &clip[X]) else {
continue;
};
projects / pspp / commitdiff