DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Tables: drag row and column borders with the Type tool
aiongg44fde504631f
diff --git a/ROADMAP.md b/ROADMAP.mdindex d33353caa..2023bbaba 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -129,6 +129,7 @@ list) · [roadmap.md](docs/roadmap.md) (milestones, plan) · [parity-checklist.mNewest first.+- **2026-10-12** · With the Type tool, dragging a table's column or row border resizes it (the double-arrow cursor shows over a border): later columns and rows move along, Shift keeps the table size, and Shift on the right or bottom edge scales every column or row. A dragged row becomes At Least; one undo step per drag, Esc cancels; works in rotated frames and turned spreads. Scripts use `table.resizeBorder`. No readiness percentage change.- **2026-10-12** · Words in capitals hyphenate like capitalized words (FERRUM COM-MODI), as in InDesign; Hyphenate Capitalized Words off keeps them whole. No readiness percentage change.- **2026-10-11** · `transform.move {copy}`, Edit › Duplicate and Step and Repeat return the copies' ids, so a script can go on with them. No readiness percentage change.- **2026-10-11** · `object.fill` and `object.stroke` refuse a swatch name the document doesn't have (it painted nothing) and suggest the name meant (`Paper` → `[Paper]`). No readiness percentage change.diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rsindex 3dd7c25b3..225b6ceac 100644--- a/crates/compose/src/lib.rs+++ b/crates/compose/src/lib.rs@@ -40,7 +40,7 @@ pub use crate::cache::Cache;use crate::notes::Notes;pub use crate::notes::{find_note, hit_note, note_caret};use crate::shape::{Glyph, StyleTable, SubstCtx};-pub use crate::table::{PlacedCell, StrokeSeg, TableFrag, cell_caret, find_cell, hit_cell};+pub use crate::table::{BorderHit, PlacedCell, StrokeSeg, TableFrag, cell_caret, find_cell, hit_border, hit_cell};/// Character appearance shared by many glyphs (indexed from [`PlacedGlyph::style`]).#[derive(Clone, Debug, PartialEq)]diff --git a/crates/compose/src/table.rs b/crates/compose/src/table.rsindex c70f477be..69e1d75c4 100644--- a/crates/compose/src/table.rs+++ b/crates/compose/src/table.rs@@ -618,6 +618,56 @@ pub fn hit_cell(cs: &ComposedStory, fi: usize, p: Point) -> Option<(u64, usize,None}+/// A row or column border under the pointer, found by [`hit_border`].+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct BorderHit {+ pub table: u64,+ /// `true`: a column border (dragged horizontally); `false`: a row border.+ pub column: bool,+ /// The row above / logical column before the border. The last index is the table's+ /// bottom or end edge.+ pub index: usize,+ /// The column border is the physical left edge of its column (a right-to-left table), so+ /// dragging left widens it.+ pub mirrored: bool,+}++/// The row or column border within `tol` of `p` (frame inner space) in frame `fi`, nearest+/// first. Only borders that resize something count: inner borders and the bottom and end+/// edges. `tables` holds the story's tables (for cell spans).+pub fn hit_border(cs: &ComposedStory, fi: usize, tables: &std::collections::BTreeMap<u64, Arc<Table>>, p: Point, tol: f64) -> Option<BorderHit> {+ if !(tol.is_finite() && p.x.is_finite() && p.y.is_finite()) {+ return None;+ }+ let ft = cs.frames.get(fi)?;+ let mut best: Option<(f64, BorderHit)> = None;+ let mut offer = |d: f64, hit: BorderHit| {+ if d <= tol && best.is_none_or(|(bd, _)| d < bd) {+ best = Some((d, hit));+ }+ };+ for t in &ft.tables {+ if !t.rect.inflate(tol, tol).contains(p) {+ continue;+ }+ let Some(table) = tables.get(&t.table) else { continue };+ let rtl = table.options.direction == designcraft_doc::TextDirection::RightToLeft;+ for c in &t.cells {+ let Some(cell) = table.cell(c.row, c.col) else { continue };+ let last_col = c.col.saturating_add((cell.col_span.max(1) - 1) as usize);+ let last_row = c.row.saturating_add((cell.row_span.max(1) - 1) as usize);+ if (c.rect.y0..=c.rect.y1).contains(&p.y) {+ let x = if rtl { c.rect.x0 } else { c.rect.x1 };+ offer((p.x - x).abs(), BorderHit { table: t.table, column: true, index: last_col, mirrored: rtl });+ }+ if (c.rect.x0..=c.rect.x1).contains(&p.x) {+ offer((p.y - c.rect.y1).abs(), BorderHit { table: t.table, column: false, index: last_row, mirrored: false });+ }+ }+ }+ best.map(|(_, h)| h)+}+/// Frame index and placed cell for a cell address (the first, non-repeated occurrence).pub fn find_cell(cs: &ComposedStory, table: u64, row: usize, col: usize) -> Option<(usize, &TableFrag, &PlacedCell)> {let mut found = None;diff --git a/crates/engine/src/cmd/table.rs b/crates/engine/src/cmd/table.rsindex c2313170a..96c2d0484 100644--- a/crates/engine/src/cmd/table.rs+++ b/crates/engine/src/cmd/table.rs@@ -202,6 +202,15 @@ fn table_specs() -> Vec<CommandSpec> {),cmd!("table.setRowHeight", "Row Height", [], None, "{height, mode?: atLeast|exactly}", in_table, set_row_height),cmd!("table.setColumnWidth", "Column Width", [], None, "{width}", in_table, set_col_width),+ cmd!(+ "table.resizeBorder",+ "Resize Row or Column",+ [],+ None,+ "{story?, table?, frame?, axis: column|row, index, delta? | size?, keepTableSize?: bool} — moves the border after column/row `index` by `delta` (or makes that column/row `size` wide/high); later columns/rows move along. The last index is the table's end/bottom edge. keepTableSize: on an inner border the next column/row gives or takes the change; on the edge all columns/rows scale proportionally. A dragged row becomes At Least. Refuses a locked `frame`",+ in_table_or_ids,+ resize_border+ ),cmd!("table.distributeColumns", "Distribute Columns Evenly", ["Table"], None, "{}", in_table, distribute_cols),cmd!("table.distributeRows",@@ -821,6 +830,114 @@ fn set_col_width(s: &mut Session, p: &Value) -> Result<Value> {})}+/// Smallest column width and row height a border drag leaves.+const MIN_TRACK: f64 = 3.0;+const MAX_TRACK: f64 = 10000.0;++/// Composed height of `row` (laid out from cells that span only that row), else its model height.+fn composed_row_height(cs: &compose::ComposedStory, t: &Table, row: usize) -> Option<f64> {+ let laid_out = cs+ .frames+ .iter()+ .flat_map(|f| &f.tables)+ .filter(|f| f.table == t.id)+ .flat_map(|f| &f.cells)+ .filter(|c| c.row == row && t.cell(c.row, c.col).is_some_and(|x| x.row_span <= 1))+ .map(|c| c.rect.height())+ .filter(|h| h.is_finite() && *h > 0.0)+ .reduce(f64::max);+ laid_out.or_else(|| t.rows.get(row).map(|r| r.height))+}++/// Move the border after `index` among `sizes` by `delta`. Returns the new sizes.+fn resize_track(sizes: &[f64], index: usize, delta: f64, keep: bool) -> Option<Vec<f64>> {+ let mut out = sizes.to_vec();+ let cur = *sizes.get(index)?;+ let last = index + 1 == sizes.len();+ if keep && last {+ // Scale every track so the table edge moves by `delta`.+ let total: f64 = sizes.iter().sum();+ let smallest = sizes.iter().copied().fold(f64::INFINITY, f64::min);+ let largest = sizes.iter().copied().fold(0.0, f64::max);+ if !(total > 0.0 && smallest > 0.0 && largest > 0.0) {+ return None;+ }+ let lo = (MIN_TRACK / smallest).min(1.0);+ let hi = (MAX_TRACK / largest).max(1.0);+ let f = ((total + delta) / total).clamp(lo, hi);+ out.iter_mut().for_each(|v| *v *= f);+ } else if keep {+ let next = *sizes.get(index + 1)?;+ let pair = cur + next;+ let a = (cur + delta).clamp(MIN_TRACK, (pair - MIN_TRACK).max(MIN_TRACK));+ let [this, after] = out.get_mut(index..index + 2)? else { return None };+ *this = a;+ *after = (pair - a).max(MIN_TRACK);+ } else {+ *out.get_mut(index)? = (cur + delta).clamp(MIN_TRACK, MAX_TRACK);+ }+ out.iter().all(|v| v.is_finite()).then_some(out)+}++fn resize_border(s: &mut Session, p: &Value) -> Result<Value> {+ const ID: &str = "table.resizeBorder";+ let column = match str_param(p, "axis") {+ Some("column") => true,+ Some("row") => false,+ _ => return Err(bad(ID, "axis must be `column` or `row`")),+ };+ let index = p.get("index").and_then(Value::as_u64).and_then(|v| usize::try_from(v).ok()).ok_or_else(|| bad(ID, "`index` required"))?;+ let keep = p.get("keepTableSize").and_then(Value::as_bool).unwrap_or(false);+ let g = target(s, p, ID)?;+ let st = s.doc()?;+ if let Some(fid) = super::id_param(p, "frame") {+ let it = st.doc.item(fid).ok_or_else(|| bad(ID, format!("no frame {}", fid.0)))?;+ if it.text_frame().map(|f| f.story) != Some(g.story) {+ return Err(bad(ID, "the table is not in that frame's story"));+ }+ if it.locked || st.doc.layer(it.layer).is_some_and(|l| l.locked) {+ return Err(bad(ID, "the frame or its layer is locked"));+ }+ }+ let t = st.doc.story(g.story).and_then(|x| x.tables.get(&g.table)).ok_or_else(|| bad(ID, "no table"))?;+ let sizes: Vec<f64> = if column {+ t.columns.iter().map(|c| c.width).collect()+ } else {+ let cs = s.cache.get(&st.doc, g.story, None);+ (0..t.nrows()).map(|r| composed_row_height(&cs, t, r).unwrap_or(MIN_TRACK)).collect()+ };+ let cur = *sizes.get(index).ok_or_else(|| bad(ID, format!("index {index} out of range")))?;+ let delta = match (p.get("delta").and_then(Value::as_f64), p.get("size").and_then(Value::as_f64)) {+ (Some(d), _) => d,+ (None, Some(sz)) => sz - cur,+ (None, None) => return Err(bad(ID, "`delta` or `size` required")),+ };+ if !delta.is_finite() {+ return Err(bad(ID, "`delta`/`size` must be a finite number"));+ }+ let new = resize_track(&sizes, index, delta, keep).ok_or_else(|| bad(ID, "invalid table geometry"))?;+ let size = new.get(index).copied().unwrap_or(cur);+ let scaled = keep && index + 1 == sizes.len();+ edit_table(s, &g, ID, |t| {+ if column {+ for (c, w) in t.columns.iter_mut().zip(&new) {+ c.width = *w;+ }+ } else {+ for (i, (r, h)) in t.rows.iter_mut().zip(&new).enumerate() {+ // Only the rows the drag changed take the new height.+ if scaled || i == index || (keep && i == index + 1) {+ r.height = *h;+ }+ if i == index && !scaled {+ r.mode = RowHeightMode::AtLeast;+ }+ }+ }+ Ok(json!({"axis": if column { "column" } else { "row" }, "index": index, "size": size}))+ })+}+fn distribute_rows(s: &mut Session, p: &Value) -> Result<Value> {const ID: &str = "table.distributeRows";if !p.is_object() {@@ -1748,3 +1865,97 @@ mod arabic_tests {}}}++#[cfg(test)]+mod resize_border_tests {+ use serde_json::json;++ use crate::Session;++ /// A 3×3 table of 80 pt columns; returns the session, frame id, story and table ids.+ fn session() -> (Session, u64, u64, u64) {+ let mut s = Session::new();+ s.execute("file.new", &json!({})).unwrap();+ let r = s.execute("frame.create", &json!({"rect": [72, 72, 472, 600], "content": "text", "text": ""})).unwrap();+ s.execute("text.select", &json!({"story": r["story"], "anchor": 0, "focus": 0})).unwrap();+ let t = s.execute("table.insert", &json!({"rows": 3, "cols": 3, "width": 240})).unwrap();+ (s, r["id"].as_u64().unwrap(), t["story"].as_u64().unwrap(), t["table"].as_u64().unwrap())+ }++ fn table(s: &Session) -> designcraft_doc::Table {+ (**s.doc().unwrap().doc.stories.values().flat_map(|st| st.tables.values()).next().unwrap()).clone()+ }++ fn widths(s: &Session) -> Vec<f64> {+ table(s).columns.iter().map(|c| c.width).collect()+ }++ /// Composed cell rects of column 0, top to bottom.+ fn rows(s: &Session) -> Vec<designcraft_geom::Rect> {+ let st = s.doc().unwrap();+ let sid = st.doc.stories.values().find(|x| !x.tables.is_empty()).unwrap().id;+ let cs = s.cache.get(&st.doc, sid, None);+ cs.frames.iter().flat_map(|f| &f.tables).flat_map(|f| &f.cells).filter(|c| c.col == 0).map(|c| c.rect).collect()+ }++ fn resize(s: &mut Session, ids: (u64, u64, u64), mut p: serde_json::Value) {+ p["frame"] = json!(ids.0);+ p["story"] = json!(ids.1);+ p["table"] = json!(ids.2);+ s.execute("table.resizeBorder", &p).unwrap();+ }++ #[test]+ fn column_border_drags_widen_the_table_or_keep_its_width() {+ let (mut s, f, st, t) = session();+ resize(&mut s, (f, st, t), json!({"axis": "column", "index": 0, "delta": 20}));+ assert_eq!(widths(&s), [100.0, 80.0, 80.0]);+ resize(&mut s, (f, st, t), json!({"axis": "column", "index": 1, "delta": 30, "keepTableSize": true}));+ assert_eq!(widths(&s), [100.0, 110.0, 50.0]);+ // Clamped at the minimum; the neighbour takes only what is left.+ resize(&mut s, (f, st, t), json!({"axis": "column", "index": 1, "delta": 500, "keepTableSize": true}));+ assert_eq!(widths(&s), [100.0, 157.0, 3.0]);+ resize(&mut s, (f, st, t), json!({"axis": "column", "index": 0, "delta": -1000}));+ assert_eq!(widths(&s), [3.0, 157.0, 3.0]);+ // Shift on the end edge scales every column.+ resize(&mut s, (f, st, t), json!({"axis": "column", "index": 2, "size": 166, "keepTableSize": true}));+ let w = widths(&s);+ assert!((w.iter().sum::<f64>() - 326.0).abs() < 1e-9, "{w:?}");+ assert!((w[1] / w[0] - 157.0 / 3.0).abs() < 1e-9, "{w:?}");+ assert!(s.execute("table.resizeBorder", &json!({"table": t, "axis": "column", "index": 3, "delta": 1})).is_err());+ assert!(s.execute("table.resizeBorder", &json!({"table": t, "axis": "column", "index": 0})).is_err());+ }++ #[test]+ fn row_drag_sets_at_least_and_moves_later_rows() {+ let (mut s, f, st, t) = session();+ s.execute("table.setRowHeight", &json!({"table": t, "row": 0, "height": 30, "mode": "exactly"})).unwrap();+ let before = rows(&s);+ resize(&mut s, (f, st, t), json!({"axis": "row", "index": 0, "delta": 12}));+ let row = &table(&s).rows[0];+ assert_eq!((row.height, row.mode), (42.0, designcraft_doc::RowHeightMode::AtLeast));+ let after = rows(&s);+ assert!((after[0].height() - 42.0).abs() < 1e-9);+ assert!((after[1].y0 - before[1].y0 - 12.0).abs() < 1e-9 && (after[1].height() - before[1].height()).abs() < 1e-9);+ // Below the minimum: clamped, never negative.+ resize(&mut s, (f, st, t), json!({"axis": "row", "index": 0, "delta": -1000}));+ assert_eq!(table(&s).rows[0].height, 3.0);+ }++ #[test]+ fn a_drag_is_one_undo_step_and_locked_frames_refuse() {+ let (mut s, f, st, t) = session();+ let before = table(&s);+ s.begin_interaction("Resize Column").unwrap();+ for d in [5.0, 15.0, 25.0] {+ let p = json!({"frame": f, "story": st, "table": t, "axis": "column", "index": 0, "delta": d});+ s.preview("table.resizeBorder", p).unwrap();+ }+ s.commit_interaction().unwrap();+ assert_eq!(widths(&s), [105.0, 80.0, 80.0]);+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(table(&s), before);+ s.execute("object.setFlags", &json!({"ids": [f], "locked": true})).unwrap();+ assert!(s.execute("table.resizeBorder", &json!({"frame": f, "table": t, "axis": "column", "index": 0, "delta": 5})).is_err());+ }+}diff --git a/crates/tools/src/tests.rs b/crates/tools/src/tests.rsindex 6c75b0da6..009feb7dc 100644--- a/crates/tools/src/tests.rs+++ b/crates/tools/src/tests.rs@@ -705,3 +705,53 @@ fn pen_click_snaps_to_a_guide() {let x = p["anchors"][0]["p"][0].as_f64().unwrap();assert!((x - 100.0).abs() < 1e-6, "anchor x {x}");}++/// A text frame holding a 3×3 table of 80 pt columns, optionally rotated about its centre.+fn table_frame(degrees: f64) -> (Document, ItemId) {+ let mut d = Document::new(&NewDocument::default());+ let layer = d.default_layer();+ let (id, sid) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(100.0, 100.0, 400.0, 400.0), layer, "", ParaFormat::default()).unwrap();+ let tid = d.alloc();+ d.story_mut(sid).unwrap().insert_table(0, designcraft_doc::Table::new(tid, 3, 3, 0, 0, 240.0));+ d.item_mut(id).unwrap().xf = designcraft_geom::Affine::rotate_about(degrees.to_radians(), Point::new(250.0, 250.0));+ (d, id)+}++#[test]+fn type_tool_drags_a_table_column_border() {+ for degrees in [0.0, 90.0] {+ let (d, id) = table_frame(degrees);+ let (s, c, l) = (Selection::default(), Cache::new(), CanvasLayout::new(&d, false));+ let cx = ctx(&d, &s, &c, &l);+ let it = d.item(id).unwrap();+ let sid = it.text_frame().unwrap().story;+ let cs = c.get(&d, sid, None);+ let cell = cs.frames[0].tables[0].cell(1, 0).unwrap();+ let xf = cx.item_canvas_xf(id).unwrap() * d.text_xf(it);+ let on_border = xf * Point::new(cell.rect.x1 + 1.0, (cell.rect.y0 + cell.rect.y1) / 2.0);+ let dragged = xf * Point::new(cell.rect.x1 + 21.0, (cell.rect.y0 + cell.rect.y1) / 2.0);+ let mut t = create("type");+ let expected = if degrees == 0.0 { Cursor::ResizeH } else { Cursor::ResizeV };+ assert_eq!(t.cursor(&cx, on_border, Mods::default()), expected);+ // A press on the border starts a resize, not a text selection.+ assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, on_border.x, on_border.y)).is_empty());+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, dragged.x, dragged.y));+ assert_eq!(a[0], Action::Begin("Resize Column".into()));+ let Action::Preview(cmd, p) = &a[1] else { panic!("{a:?}") };+ assert_eq!(+ (cmd.as_str(), &p["axis"], &p["index"], &p["frame"]),+ ("table.resizeBorder", &serde_json::json!("column"), &serde_json::json!(0), &serde_json::json!(id.0))+ );+ assert!((p["delta"].as_f64().unwrap() - 20.0).abs() < 1e-6, "{p}");+ assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, dragged.x, dragged.y)), vec![Action::Commit]);+ // Esc cancels a drag in progress.+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, on_border.x, on_border.y));+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, dragged.x, dragged.y));+ assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Cancel]);+ assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, dragged.x, dragged.y)).is_empty());+ // Inside the cell the Type tool places the caret as usual.+ let inside = xf * Point::new(cell.rect.x0 + 20.0, (cell.rect.y0 + cell.rect.y1) / 2.0);+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, inside.x, inside.y));+ assert!(matches!(&a[..], [Action::Exec(cmd, _)] if cmd == "text.placeCaret"), "{a:?}");+ }+}diff --git a/crates/tools/src/text.rs b/crates/tools/src/text.rsindex 13a93f23a..195ee41b3 100644--- a/crates/tools/src/text.rs+++ b/crates/tools/src/text.rs@@ -1,8 +1,10 @@//! Type tool (T): click in a frame to place the caret, drag in a frame to select text, drag on//! empty canvas to draw a new text frame. Keys move the caret / delete; typing goes through-//! `text.insert` (sent by the UI as text input).+//! `text.insert` (sent by the UI as text input). Dragging a table's row or column border resizes+//! it (`table.resizeBorder`).-use designcraft_geom::Point;+use designcraft_compose::BorderHit;+use designcraft_geom::{Affine, Point};use serde_json::json;use crate::{Action, Cursor, Mods, PointerEvent, PointerKind, Tool, ToolContext, ToolKey, frame::drag_rect, rect_json, spread_json};@@ -17,6 +19,86 @@ pub struct TypeTool {/// A press on a table whose whole rows or columns are selected: (frame, press point in/// spread space) — a drag moves them, a click places the caret.cell_drag: Option<(u64, Point)>,+ /// A press on a table row or column border: a drag resizes it.+ border: Option<BorderDrag>,+}++/// A table border under the pointer, and the frame's canvas → inner-space mapping.+#[derive(Clone, Copy)]+struct BorderDrag {+ frame: u64,+ story: u64,+ hit: BorderHit,+ /// Canvas → frame inner space (through rotations, scaling and turned spreads).+ inv: Affine,+ /// Press point in frame inner space.+ start: Point,+ begun: bool,+ /// The border runs vertically on the canvas (column borders on an unrotated frame).+ horizontal_drag: bool,+}++/// The row or column border of a table near canvas point `pos`, in an unlocked text frame.+fn border_at(cx: &ToolContext, pos: Point) -> Option<BorderDrag> {+ let (_, id) = cx.hit(pos)?;+ let it = cx.doc.item(id)?;+ if it.locked {+ return None;+ }+ let sid = it.text_frame()?.story;+ let story = cx.doc.story(sid)?;+ if story.tables.is_empty() {+ return None;+ }+ let xf = cx.item_canvas_xf(id)? * cx.doc.text_xf(it);+ let det = xf.determinant().abs();+ if !(det.is_finite() && det > 1e-12) {+ return None;+ }+ let inv = xf.inverse();+ let start = inv * pos;+ let cs = cx.cache.get(cx.doc, sid, None);+ let fi = cs.frames.iter().position(|f| f.frame == id)?;+ let hit = designcraft_compose::hit_border(&cs, fi, &story.tables, start, cx.tol(4.0) / det.sqrt())?;+ let axis = if hit.column { Point::new(1.0, 0.0) } else { Point::new(0.0, 1.0) };+ let v = (xf * axis) - (xf * Point::ORIGIN);+ Some(BorderDrag { frame: id.0, story: sid.0, hit, inv, start, begun: false, horizontal_drag: v.x.abs() >= v.y.abs() })+}++impl BorderDrag {+ fn cursor(&self) -> Cursor {+ if self.horizontal_drag { Cursor::ResizeH } else { Cursor::ResizeV }+ }++ /// Begin (once) and preview the resize for the pointer at canvas `pos`.+ fn drag(&mut self, pos: Point, keep: bool) -> Vec<Action> {+ let d = (self.inv * pos) - self.start;+ let mut delta = if self.hit.column { d.x } else { d.y };+ if self.hit.mirrored {+ delta = -delta;+ }+ if !delta.is_finite() {+ return vec![];+ }+ let mut out = vec![];+ if !self.begun {+ self.begun = true;+ out.push(Action::Begin(if self.hit.column { "Resize Column" } else { "Resize Row" }.into()));+ }+ out.push(Action::Preview(+ "table.resizeBorder".into(),+ json!({+ "frame": self.frame,+ "story": self.story,+ "table": self.hit.table,+ "axis": if self.hit.column { "column" } else { "row" },+ "index": self.hit.index,+ "delta": delta,+ "keepTableSize": keep,+ }),+ ));+ out+ }}/// Are whole rows or whole columns of a table selected?@@ -45,6 +127,13 @@ impl Tool for TypeTool {self.drawing = false;self.selecting = None;self.cell_drag = None;+ self.border = None;+ if ev.kind == PointerKind::Down+ && let Some(b) = border_at(cx, ev.pos)+ {+ self.border = Some(b);+ return vec![];+ }if let Some((_, id)) = cx.hit(ev.pos)&& let Some(it) = cx.doc.item(id)&& !matches!(it.content, designcraft_doc::Content::Graphic(_) | designcraft_doc::Content::Group { .. })@@ -69,6 +158,9 @@ impl Tool for TypeTool {}PointerKind::Drag => {let Some(a) = self.start else { return vec![] };+ if let Some(b) = self.border.as_mut() {+ return b.drag(ev.pos, ev.mods.shift);+ }if self.cell_drag.is_some() {return vec![];}@@ -94,6 +186,9 @@ impl Tool for TypeTool {}PointerKind::Up => {let start = self.start.take();+ if let Some(b) = self.border.take() {+ return if b.begun { vec![Action::Commit] } else { vec![] };+ }if let Some((fid, from)) = self.cell_drag.take() {let sp = cx.layout.spread_at(ev.pos).map(|(_, p)| p).unwrap_or(ev.pos);let moved = start.is_some_and(|a| (ev.pos - a).hypot() >= cx.tol(3.0));@@ -123,6 +218,12 @@ impl Tool for TypeTool {}fn key(&mut self, cx: &ToolContext, key: ToolKey, mods: Mods) -> Vec<Action> {+ if key == ToolKey::Escape+ && let Some(b) = self.border.take()+ {+ self.start = None;+ return if b.begun { vec![Action::Cancel] } else { vec![] };+ }if cx.selection.text.is_none() {return vec![];}@@ -146,14 +247,14 @@ impl Tool for TypeTool {}fn cursor(&self, cx: &ToolContext, p: Point, _m: Mods) -> Cursor {- match cx.hit(p) {- Some((_, id)) if cx.doc.item(id).is_some_and(|i| i.is_text_frame()) => Cursor::Text,- _ => Cursor::Text,+ if let Some(b) = self.border.as_ref().copied().or_else(|| if self.start.is_none() { border_at(cx, p) } else { None }) {+ return b.cursor();}+ Cursor::Text}fn busy(&self) -> bool {- self.drawing+ self.drawing || self.border.is_some()}fn wants_text(&self, cx: &ToolContext) -> bool {diff --git a/docs/target-app-parity.md b/docs/target-app-parity.mdindex e9c27a9f8..ceee73976 100644--- a/docs/target-app-parity.md+++ b/docs/target-app-parity.md@@ -273,7 +273,7 @@ It is evidence of breadth: each item exists. It is not a claim of InDesign-level- Tools: Selection (click, marquee, move, Alt-duplicate, resize handles), Direct Selection, Type (draw frame, click caret, select, type), Rectangle/Ellipse/Polygon (+ frame variants), Line, Hand, Zoom.- PDF export (krilla): real selectable text with embedded font subsets, DeviceCMYK/RGB + spot Separations, bleed boxes, crop/bleed marks + page info, pages or spreads, PDF/A-2b (PDF/X-4 output intent pending) — `file.exportPdf`, File › Export PDF…, `designcraft-cli run --export out.pdf`. File › Export PDF… now opens an "Export PDF" options dialog (General / Compression / Marks and Bleeds / Advanced) and remembers the last-used settings across exports and sessions.- IDML interchange (`designcraft-idml`): export and import of swatches, styles, fonts, preferences, parent spreads, spreads/pages, frames, groups, images (embedded or linked), formatted threaded stories — opens in InDesign 2026 and round-trips InDesign-exported files (`file.exportIdml`, `file.openIdml`, File → Export IDML…, CLI `--in x.idml` / `--export x.idml`).-- Tables (M8): tables anchored in stories (header/footer/body rows, merged cells, per-edge strokes, fills + alternating fills, insets, vertical justification, at-least/exact row heights); composed into the text column (columns scale to fit, rows break across columns/frames with repeating headers/footers, overset); rendered, exported to PDF (real text) and IDML (export + import); Table menu, Table panel, Create Table dialog, caret/typing/Tab navigation and cell selection in cells; `table.*` commands.+- Tables (M8): tables anchored in stories (header/footer/body rows, merged cells, per-edge strokes, fills + alternating fills, insets, vertical justification, at-least/exact row heights); composed into the text column (columns scale to fit, rows break across columns/frames with repeating headers/footers, overset); rendered, exported to PDF (real text) and IDML (export + import); Table menu, Table panel, Create Table dialog, caret/typing/Tab navigation and cell selection in cells; Type tool drags of row and column borders (Shift keeps the table size, or scales every row/column on the outer edge; `table.resizeBorder`); `table.*` commands.- Hyperlinks (text or frames → URL / e-mail / page) and bookmarks, exported as PDF link annotations and outline.- EPUB 3 (reflowable) export: stories in reading order, CSS from paragraph/character styles, images, navigation (`file.exportEpub`, CLI `--export x.epub`).- Data Merge (one linked CSV, TSV, text, or Excel file; text, image, QR, and hyperlink placeholders; preview; a new document with one record per page or records tiled on a single page), spell checking (public-domain Moby list + document dictionary, suggestions), Step and Repeat (count or grid), snippets, object styles, Numbering & Section Options.