6ef13b2cc8a6
layout.rs
use super::cells::{cell, selected_cells, with_cells, with_table};
use super::{
Align, Border, BorderStyle, Borders, CmdError, CmdResult, HeightRule, Path, Pos, Rgb, Selection, Session, Table, TextDirection, VAlign, Value,
json, p, sel_result,
};
/// Table Layout › AutoFit: Contents sizes the columns to their text, Window spreads them across
/// the text column, Fixed keeps the widths as they are.
pub(super) fn autofit(s: &mut Session, v: &Value) -> CmdResult {
let mode = p::str(v, "mode").unwrap_or("window");
let (tp, _, _) = cell(s)?;
let story = s.sel.focus.story;
let tw = crate::cmd::page::sect(s).text_width();
match mode {
"fixed" => with_table(s, |t| t.props.fixed = true),
"contents" => {
let t = s.doc.table(story, &tp).ok_or_else(|| CmdError::Disabled("the cursor isn't in a table".into()))?;
let avail = (tw - t.props.indent.filter(|i| i.is_finite()).unwrap_or(0.0).max(0.0)).max(72.0);
let widths = wordcraft_layout::autofit_widths(&wordcraft_layout::measure_table_columns(&s.doc, t), avail);
with_table(s, |t| {
t.props.fixed = false;
t.props.width = None;
t.props.width_pct = None;
t.grid = widths.iter().map(|w| w.max(6.0)).collect();
sync_cell_widths(t);
})
}
_ => with_table(s, |t| {
t.props.fixed = false;
t.props.width_pct = Some(100.0);
let n = t.grid.len().max(1) as f32;
t.grid.iter_mut().for_each(|g| *g = tw / n);
sync_cell_widths(t);
}),
}
}
/// Give every cell the width of the grid columns it spans, so the cells' preferred widths
/// (saved to .docx) agree with the grid.
pub(crate) fn sync_cell_widths(t: &mut Table) {
let grid = t.grid.clone();
for row in &mut t.rows {
// A row's cells start after the grid columns it skips (`w:gridBefore`).
let mut g = row.first_grid();
for c in &mut row.cells {
let span = c.span();
let w: f32 = grid.get(g..g.saturating_add(span).min(grid.len())).unwrap_or(&[]).iter().sum();
if w > 0.0 {
c.props.width = Some(w);
}
g = g.saturating_add(span);
}
}
}
/// Set the width of the grid column cell `c` of row `r` starts in. The table's preferred width
/// goes, so the layout doesn't scale the column back.
/// Give every grid column the `cells` (row, cell) pairs touch the width `w`.
pub(super) fn set_column_widths(t: &mut Table, cells: &[(usize, usize)], w: f32) {
let mut cols: Vec<usize> = cells.iter().map(|&(r, c)| t.grid_col(r, c)).collect();
cols.sort_unstable();
cols.dedup();
let mut any = false;
for g in cols {
if let Some(x) = t.grid.get_mut(g) {
*x = w;
any = true;
}
}
if any {
t.props.width = None;
t.props.width_pct = None;
sync_cell_widths(t);
}
}
/// Table Properties: table, row, column and cell settings in one undoable step. Row, column and
/// cell settings apply to the selected rows, columns and cells, as in Word, and to the caret's
/// when nothing is selected (#4857). Without any setting it returns the caret's current values.
pub(super) fn properties(s: &mut Session, v: &Value) -> CmdResult {
let (tp, r, c) = cell(s)?;
let keys = [
"align",
"rtl",
"width",
"widthPct",
"indent",
"rowHeight",
"rowHeightRule",
"allowBreak",
"headerRow",
"columnWidth",
"cellWidth",
"valign",
];
if !keys.iter().any(|k| v.get(*k).is_some()) {
let t = s.doc.table(s.sel.focus.story, &tp).cloned().unwrap_or_default();
let mut out = serde_json::to_value(&t.props).unwrap_or(Value::Null);
let row = t.rows.get(r);
let cl = row.and_then(|x| x.cells.get(c));
if let Some(o) = out.as_object_mut() {
o.insert("row".into(), row.map(|x| serde_json::to_value(&x.props).unwrap_or(Value::Null)).unwrap_or(Value::Null));
o.insert("columnWidth".into(), t.grid.get(t.grid_col(r, c)).map_or(Value::Null, |w| json!(w)));
o.insert("cell".into(), cl.map(|x| serde_json::to_value(&x.props).unwrap_or(Value::Null)).unwrap_or(Value::Null));
}
return Ok(out);
}
let align = match p::str(v, "align") {
None => None,
Some("left") => Some(Align::Left),
Some("center") => Some(Align::Center),
Some("right") => Some(Align::Right),
Some(x) => return Err(CmdError::Params(format!("unknown table alignment `{x}`"))),
};
let rule = match p::str(v, "rowHeightRule") {
None => None,
Some("atLeast") => Some(HeightRule::AtLeast),
Some("exact") => Some(HeightRule::Exact),
Some(x) => return Err(CmdError::Params(format!("unknown height rule `{x}`"))),
};
let valign = match p::str(v, "valign") {
None => None,
Some("top") => Some(VAlign::Top),
Some("center") => Some(VAlign::Center),
Some("bottom") => Some(VAlign::Bottom),
Some(x) => return Err(CmdError::Params(format!("unknown vertical alignment `{x}`"))),
};
// `null` clears a preferred size (automatic); a number sets it.
let size = |k: &str, lo: f32, hi: f32| -> Option<Option<f32>> {
match v.get(k)? {
Value::Null => Some(None),
x => x.as_f64().map(|f| f as f32).filter(|f| f.is_finite()).map(|f| Some(f.clamp(lo, hi))),
}
};
let width = size("width", 6.0, 1584.0);
let width_pct = p::f32(v, "widthPct").map(|x| x.clamp(1.0, 100.0));
let indent = p::f32(v, "indent").map(|x| x.clamp(-1584.0, 1584.0));
let row_height = size("rowHeight", 1.0, 1584.0);
let allow_break = p::bool(v, "allowBreak");
let header = p::bool(v, "headerRow");
let column_width = p::f32(v, "columnWidth").map(|x| x.clamp(6.0, 1584.0));
let cell_width = size("cellWidth", 6.0, 1584.0);
let rtl = p::bool(v, "rtl");
// The selected cells (a whole table, rows, a column…), else the caret's.
let cells = Some(selected_cells(s)).filter(|c| !c.is_empty()).unwrap_or_else(|| vec![(r, c)]);
let mut rows: Vec<usize> = cells.iter().map(|&(r, _)| r).collect();
rows.sort_unstable();
rows.dedup();
with_table(s, |t| {
if let Some(a) = align {
t.props.align = Some(a);
}
if let Some(on) = rtl {
t.props.bidi_visual = on;
}
if let Some(i) = indent {
t.props.indent = Some(i);
}
if let Some(cw) = column_width {
set_column_widths(t, &cells, cw);
}
if let Some(w) = width {
t.props.width = w;
t.props.width_pct = None;
}
if let Some(pct) = width_pct {
t.props.width_pct = Some(pct);
}
for &r in &rows {
let Some(row) = t.rows.get_mut(r) else { continue };
if let Some(h) = row_height {
row.props.height = h;
row.props.height_rule = if h.is_some() { rule.unwrap_or(HeightRule::AtLeast) } else { HeightRule::Auto };
} else if let Some(rule) = rule
&& row.props.height.is_some()
{
row.props.height_rule = rule;
}
if let Some(b) = allow_break {
row.props.cant_split = !b;
}
if let Some(h) = header {
row.props.header = h;
}
}
for &(r, c) in &cells {
let Some(cl) = t.rows.get_mut(r).and_then(|row| row.cells.get_mut(c)) else { continue };
if let Some(w) = cell_width {
cl.props.width = w;
}
if let Some(va) = valign {
cl.props.valign = Some(va);
}
}
})
}
/// Table Layout › Text Direction: turn the selected cells' text. Without a value it cycles the
/// caret cell's direction (horizontal → down → up) and gives every selected cell the result.
pub(crate) fn text_direction(s: &mut Session, v: &Value) -> CmdResult {
let (tp, r, c) = cell(s)?;
let dir = match p::str(v, "value") {
Some("horizontal" | "lrTb") => TextDirection::Horizontal,
Some("down" | "tbRl") => TextDirection::Down,
Some("up" | "btLr") => TextDirection::Up,
Some(x) => return Err(CmdError::Params(format!("unknown text direction `{x}`"))),
None => {
let t = s.doc.table(s.sel.focus.story, &tp).ok_or_else(|| CmdError::Disabled("the cursor isn't in a table".into()))?;
t.rows.get(r).and_then(|row| row.cells.get(c)).map(|cl| cl.props.text_direction).unwrap_or_default().next()
}
};
with_cells(s, |cl| cl.props.text_direction = dir)
}
/// Bump the revision of every paragraph in a table (table style changes alter their layout).
pub(crate) fn touch_cells(s: &mut Session, tp: &Path) -> Result<(), CmdError> {
let story = s.sel.focus.story;
let paths: Vec<Path> = s.doc.para_paths(story).into_iter().filter(|p| p.0.len() > tp.0.len() && p.0.starts_with(&tp.0)).collect();
for p in paths {
s.doc.para_mut(story, &p)?.touch();
}
Ok(())
}
pub(super) fn fix_caret(s: &mut Session, tp: &Path, r: usize, c: usize) -> CmdResult {
let story = s.sel.focus.story;
let Some(t) = s.doc.table(story, tp) else {
s.sel = Selection::caret(s.doc.clamp(&Pos { story, path: tp.clone(), off: 0 }));
return sel_result(s);
};
let r = r.min(t.rows.len().saturating_sub(1));
let c = c.min(t.rows.get(r).map(|x| x.cells.len().saturating_sub(1)).unwrap_or(0));
let mut path = tp.0.clone();
path.extend([r as u32, c as u32, 0]);
s.sel = Selection::caret(Pos { story, path: Path(path), off: 0 });
sel_result(s)
}
pub(super) fn borders(s: &mut Session, v: &Value) -> CmdResult {
let kind = p::str(v, "kind").unwrap_or("all");
let w = p::f32(v, "width").unwrap_or(0.5).clamp(0.25, 6.0);
let color = p::str(v, "color").and_then(Rgb::parse);
let b = Border { style: BorderStyle::Single, width: w, color, space: 0.0 };
let none = Border { style: BorderStyle::None, width: 0.0, color: None, space: 0.0 };
with_table(s, |t| {
let mut cur = t.props.borders.unwrap_or_default();
match kind {
"all" => cur = Borders::all(b),
"none" => cur = Borders::all(none),
"outside" => {
cur.top = Some(b);
cur.bottom = Some(b);
cur.left = Some(b);
cur.right = Some(b);
// The cleared inside sides must not fall back to the table style (Word writes nil).
cur.between = Some(none);
cur.inside_v = Some(none);
}
"inside" => {
cur.between = Some(b);
cur.inside_v = Some(b);
// The cleared outer sides must not fall back to the table style (Word writes nil).
cur.top = Some(none);
cur.bottom = Some(none);
cur.left = Some(none);
cur.right = Some(none);
}
"top" => cur.top = Some(b),
"bottom" => cur.bottom = Some(b),
"left" => cur.left = Some(b),
"right" => cur.right = Some(b),
_ => {}
}
t.props.borders = Some(cur);
for r in &mut t.rows {
for c in &mut r.cells {
c.props.borders = None;
}
}
})
}
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.