Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

M1: ruler guides (drag out/move/delete, Create Guides); fix task-bar deadlock while dragging

Brandon Thomas9b8983ada2cc
diff --git a/ROADMAP.md b/ROADMAP.md
index d849ae8dd..8ac3a295d 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -22,6 +22,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
- Index: page references (topic from the selection or up to 4 levels, sort keys; current page, to end of story, next n paragraphs, suppressed, See / See also), Generate / Update Index (section headings, nested or run-in, page ranges merged, Index Title / Section Head / Level 1–4 styles); IDML export/import as InDesign topics, page references and topic cross-references (verified in InDesign 2026); `index.*` commands.
- Text clipboard keeps formatting (character/paragraph formats, footnotes, cross-references, index markers, tables) and falls back to plain text when the system clipboard changed; Paste without Formatting (⇧⌘V); Change Case (UPPERCASE, lowercase, Title Case, Sentence case — formatting kept); Type › Insert Special Character / White Space / Break Character submenus.
- Anchored objects: items flow in the text inline (on the baseline, with Y offset; lines grow to fit) or above the line (left/center/right, space before/after); paste copied items into text to anchor them; Anchored Object Options and Release (back onto the page where shown); rendered, exported to PDF and to/from IDML (InDesign anchored object settings; verified in InDesign 2026); copy/paste and threading carry them; `anchored.*` commands.
+- Ruler guides: drag out of the rulers (page guides, or spread guides on the pasteboard), drag to move, drop on a ruler to delete; Layout › Create Guides (rows/columns with gutters, fit to margins or page); Delete All Guides on Spread; `guide.*` commands.
- Menus expose the engine's features (TOC, numbering & sections, text variables, hyperlinks, cross-references, footnotes, step and repeat, spelling, fitting/content, effects, Data Merge, Preflight, EPUB); any menu command with parameters gets a dialog generated from its parameter documentation.
- Table of contents (generate/update, dot leaders) and text variables (running headers, last page number, chapter number, file name, dates, custom) resolved per page.
- Soft effects: blurred drop shadow, inner shadow, outer glow, basic feather.
diff --git a/crates/engine/src/cmd/guides.rs b/crates/engine/src/cmd/guides.rs
new file mode 100644
index 000000000..dd3e70cbf
--- /dev/null
+++ b/crates/engine/src/cmd/guides.rs
@@ -0,0 +1,217 @@
+//! Ruler guides: add (dragged from the rulers), move, delete, list; Layout › Create Guides.
+//!
+//! Guides are stored on their page in spread coordinates; a spread guide (dropped on the
+//! pasteboard) lives on the spread's first page with `spread: true` and crosses the pasteboard.
+
+use designcraft_doc::{Document, Guide, Orientation, SpreadRef};
+use designcraft_geom::Rect;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, bad, cmd, has_doc, spread_param, str_param};
+use crate::{Result, Session};
+
+pub fn specs() -> Vec<CommandSpec> {
+ vec![
+ cmd!(
+ "guide.add",
+ "New Guide",
+ [],
+ None,
+ "{orientation: horizontal|vertical, position (spread coordinate), spread?, page? (index in the spread; default: the page under `at` or the position), at? (the other coordinate), spreadGuide?: bool} → {page, index}",
+ has_doc,
+ add
+ ),
+ cmd!("guide.move", "Move Guide", [], None, "{spread?, page, index, position}", has_doc, move_guide),
+ cmd!("guide.delete", "Delete Guide", [], None, "{spread?, page, index}", has_doc, delete),
+ cmd!("guide.deleteAll", "Delete All Guides on Spread", ["View", "Grids & Guides"], None, "{spread?}", has_doc, |s, p| {
+ let r = spread_param(p, "spread");
+ s.edit(|d, _| {
+ let sp = d.spread_mut(r).ok_or_else(|| bad("guide.deleteAll", "no such spread"))?;
+ let mut n = 0;
+ for pg in &mut sp.pages {
+ n += pg.guides.len();
+ pg.guides.clear();
+ }
+ Ok(json!({"deleted": n}))
+ })
+ }),
+ cmd!(query "guide.list", "Guides", [], None, "{spread?} → [{page, index, orientation, position, spread}]", has_doc, |s, p| {
+ let d = &s.doc()?.doc;
+ let sp = d.spread(spread_param(p, "spread")).ok_or_else(|| bad("guide.list", "no such spread"))?;
+ let mut out = Vec::new();
+ for (pi, pg) in sp.pages.iter().enumerate() {
+ for (i, g) in pg.guides.iter().enumerate() {
+ out.push(json!({"page": pi, "index": i, "orientation": g.orientation, "position": g.position, "spread": g.spread}));
+ }
+ }
+ Ok(Value::Array(out))
+ }),
+ cmd!(
+ "layout.createGuides",
+ "Create Guides…",
+ ["Layout"],
+ None,
+ "{rows?: 0, columns?: 0, rowGutter?: 12, columnGutter?: 12, fitTo?: margins|page, removeExisting?: false, spread?, page? (index in the spread; default all pages)}",
+ has_doc,
+ create_guides
+ ),
+ ]
+}
+
+fn orientation(p: &Value) -> Result<Orientation> {
+ match str_param(p, "orientation") {
+ Some("horizontal") => Ok(Orientation::Horizontal),
+ Some("vertical") => Ok(Orientation::Vertical),
+ _ => Err(bad("guide", "orientation: horizontal|vertical")),
+ }
+}
+
+/// The page of a spread at a spread x coordinate (nearest page).
+fn page_at(d: &Document, r: SpreadRef, x: f64) -> usize {
+ d.spread(r).and_then(|sp| sp.page_at_x(x)).unwrap_or(0)
+}
+
+fn add(s: &mut Session, p: &Value) -> Result<Value> {
+ let o = orientation(p)?;
+ let pos = p.get("position").and_then(Value::as_f64).ok_or_else(|| bad("guide.add", "missing position"))?;
+ let r = spread_param(p, "spread");
+ let spread_guide = p.get("spreadGuide").and_then(Value::as_bool).unwrap_or(false);
+ let d = &s.doc()?.doc;
+ let pi = match p.get("page").and_then(Value::as_u64) {
+ Some(pi) => pi as usize,
+ None if spread_guide => 0,
+ None => {
+ let x = match o {
+ Orientation::Vertical => pos,
+ Orientation::Horizontal => p.get("at").and_then(Value::as_f64).unwrap_or(0.0),
+ };
+ page_at(d, r, x)
+ }
+ };
+ s.edit(|d, _| {
+ let sp = d.spread_mut(r).ok_or_else(|| bad("guide.add", "no such spread"))?;
+ let pg = sp.pages.get_mut(pi).ok_or_else(|| bad("guide.add", "no such page"))?;
+ pg.guides.push(Guide { orientation: o, position: pos, spread: spread_guide, locked: false });
+ Ok(json!({"page": pi, "index": pg.guides.len() - 1}))
+ })
+}
+
+fn guide_ref(p: &Value, cmd: &str) -> Result<(SpreadRef, usize, usize)> {
+ let pi = p.get("page").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing page"))? as usize;
+ let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing index"))? as usize;
+ Ok((spread_param(p, "spread"), pi, i))
+}
+
+fn move_guide(s: &mut Session, p: &Value) -> Result<Value> {
+ let (r, pi, i) = guide_ref(p, "guide.move")?;
+ let pos = p.get("position").and_then(Value::as_f64).ok_or_else(|| bad("guide.move", "missing position"))?;
+ s.edit(|d, _| {
+ let g = d
+ .spread_mut(r)
+ .and_then(|sp| sp.pages.get_mut(pi))
+ .and_then(|pg| pg.guides.get_mut(i))
+ .ok_or_else(|| bad("guide.move", "no such guide"))?;
+ if g.locked {
+ return Err(bad("guide.move", "the guide is locked"));
+ }
+ g.position = pos;
+ Ok(Value::Null)
+ })
+}
+
+fn delete(s: &mut Session, p: &Value) -> Result<Value> {
+ let (r, pi, i) = guide_ref(p, "guide.delete")?;
+ s.edit(|d, _| {
+ let pg = d.spread_mut(r).and_then(|sp| sp.pages.get_mut(pi)).ok_or_else(|| bad("guide.delete", "no such page"))?;
+ if i >= pg.guides.len() {
+ return Err(bad("guide.delete", "no such guide"));
+ }
+ pg.guides.remove(i);
+ Ok(Value::Null)
+ })
+}
+
+/// Evenly spaced rows/columns with gutters inside `area`: the guide positions.
+pub(crate) fn grid_positions(a: f64, b: f64, n: u32, gutter: f64) -> Vec<f64> {
+ if n < 2 {
+ return vec![];
+ }
+ let cell = ((b - a) - gutter * (n - 1) as f64) / n as f64;
+ let mut v = Vec::new();
+ for k in 1..n {
+ let edge = a + k as f64 * cell + (k - 1) as f64 * gutter;
+ v.push(edge);
+ if gutter > 0.0 {
+ v.push(edge + gutter);
+ }
+ }
+ v
+}
+
+fn create_guides(s: &mut Session, p: &Value) -> Result<Value> {
+ let rows = p.get("rows").and_then(Value::as_u64).unwrap_or(0) as u32;
+ let cols = p.get("columns").and_then(Value::as_u64).unwrap_or(0) as u32;
+ let rg = p.get("rowGutter").and_then(Value::as_f64).unwrap_or(12.0);
+ let cg = p.get("columnGutter").and_then(Value::as_f64).unwrap_or(12.0);
+ let to_page = str_param(p, "fitTo") == Some("page");
+ let remove = p.get("removeExisting").and_then(Value::as_bool).unwrap_or(false);
+ let r = spread_param(p, "spread");
+ let only = p.get("page").and_then(Value::as_u64).map(|v| v as usize);
+ s.edit(|d, _| {
+ let sp = d.spread_mut(r).ok_or_else(|| bad("layout.createGuides", "no such spread"))?;
+ let mut n = 0;
+ for (pi, pg) in sp.pages.iter_mut().enumerate() {
+ if only.is_some_and(|o| o != pi) {
+ continue;
+ }
+ if remove {
+ pg.guides.clear();
+ }
+ let area: Rect = if to_page { pg.bounds() } else { pg.margin_rect() };
+ for y in grid_positions(area.y0, area.y1, rows, rg) {
+ pg.guides.push(Guide { orientation: Orientation::Horizontal, position: y, spread: false, locked: false });
+ n += 1;
+ }
+ for x in grid_positions(area.x0, area.x1, cols, cg) {
+ pg.guides.push(Guide { orientation: Orientation::Vertical, position: x, spread: false, locked: false });
+ n += 1;
+ }
+ }
+ Ok(json!({"guides": n}))
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn guides_add_move_delete_and_grid() {
+ let mut s = Session::new();
+ s.execute("file.new", &json!({"pages": 3})).unwrap();
+ // Spread 1 holds pages 2–3 side by side from x = 0.
+ let r = s.execute("guide.add", &json!({"spread": 1, "orientation": "vertical", "position": 100.0})).unwrap();
+ assert_eq!(r["page"], 0);
+ let r = s.execute("guide.add", &json!({"spread": 1, "orientation": "horizontal", "position": 200.0, "at": 700.0})).unwrap();
+ assert_eq!(r["page"], 1);
+ s.execute("guide.move", &json!({"spread": 1, "page": 1, "index": 0, "position": 250.0})).unwrap();
+ let l = s.execute("guide.list", &json!({"spread": 1})).unwrap();
+ assert_eq!(l.as_array().unwrap().len(), 2);
+ assert_eq!(l[1]["position"], 250.0);
+ s.execute("guide.delete", &json!({"spread": 1, "page": 0, "index": 0})).unwrap();
+ assert_eq!(s.execute("guide.list", &json!({"spread": 1})).unwrap().as_array().unwrap().len(), 1);
+ // 3 columns with 12 pt gutters inside the margins: 4 guides; 2 rows without gutter: 1 guide.
+ let r = s.execute("layout.createGuides", &json!({"spread": 0, "columns": 3, "rows": 2, "rowGutter": 0.0})).unwrap();
+ assert_eq!(r["guides"], 5);
+ let d = &s.doc().unwrap().doc;
+ let pg = &d.spreads[0].pages[0];
+ let m = pg.margin_rect();
+ let v: Vec<f64> = pg.guides.iter().filter(|g| g.orientation == Orientation::Vertical).map(|g| g.position).collect();
+ let cell = (m.width() - 24.0) / 3.0;
+ assert!((v[0] - (m.x0 + cell)).abs() < 1e-9 && (v[1] - (m.x0 + cell + 12.0)).abs() < 1e-9);
+ s.execute("guide.deleteAll", &json!({"spread": 0})).unwrap();
+ assert!(s.doc().unwrap().doc.spreads[0].pages[0].guides.is_empty());
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(s.doc().unwrap().doc.spreads[0].pages[0].guides.len(), 5);
+ }
+}
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 122571805..2e649dd68 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -6,6 +6,7 @@ mod edit;
mod export;
mod file;
mod find;
+mod guides;
mod index;
mod inspect;
mod interactive;
@@ -130,6 +131,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(xref::specs());
v.extend(index::specs());
v.extend(anchored::specs());
+ v.extend(guides::specs());
v.extend(spelling::specs());
v.extend(datamerge::specs());
v.extend(interactive::specs());
diff --git a/crates/ui-egui/examples/ui_shot.rs b/crates/ui-egui/examples/ui_shot.rs
index 465c3e493..c0bf38943 100644
--- a/crates/ui-egui/examples/ui_shot.rs
+++ b/crates/ui-egui/examples/ui_shot.rs
@@ -48,10 +48,13 @@ fn main() {
);
harness.input_mut().max_texture_side = Some(8192);
READY.store(true, std::sync::atomic::Ordering::Relaxed);
- harness.run_steps(6);
+ step_n(&mut harness, 6);
for l in lines {
+ if std::env::var_os("UI_SHOT_TRACE").is_some() {
+ eprintln!("> {l}");
+ }
if let Some(p) = l.get("shot").and_then(|v| v.as_str()) {
- harness.run_steps(3);
+ step_n(&mut harness, 3);
match harness.render() {
Ok(img) => {
img.save(p).expect("save png");
@@ -60,20 +63,35 @@ fn main() {
Err(e) => eprintln!("render failed: {e}"),
}
} else if let Some(n) = l.get("steps").and_then(|v| v.as_u64()) {
- harness.run_steps(n as usize);
+ step_n(&mut harness, n as usize);
} else if let Some(m) = l.get("method").and_then(|v| v.as_str()) {
let (req, reply) = ControlRequest::new(m, l.get("params").cloned().unwrap_or_default());
tx.send(req).expect("send");
// Pointer/keyboard input is injected one event per frame.
for _ in 0..40 {
- harness.step();
+ step(&mut harness);
if let Ok(r) = reply.try_recv() {
let s = r.to_string();
println!("{m}: {}", &s[..s.len().min(300)]);
break;
}
}
- harness.run_steps(2);
+ step_n(&mut harness, 2);
}
}
}
+
+/// One frame, with the app's synthetic input (`ui.click`, `ui.drag`, `ui.key`) injected like the
+/// windowed app's raw-input hook does.
+fn step(harness: &mut egui_kittest::Harness<'_, DesignApp>) {
+ let mut raw = std::mem::take(harness.input_mut());
+ harness.state_mut().raw_input_hook(&mut raw);
+ *harness.input_mut() = raw;
+ harness.step();
+}
+
+fn step_n(harness: &mut egui_kittest::Harness<'_, DesignApp>, n: usize) {
+ for _ in 0..n {
+ step(harness);
+ }
+}
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index ac23d27d7..eb4381a96 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -200,6 +200,16 @@ pub fn show(app: &mut DesignApp, ui: &mut egui::Ui) {
}
if !preview {
draw_guides(app, &painter, &xf, &doc, &layout, &t);
+ if let Some(g) = ui.data(|d| d.get_temp::<GuideDrag>(egui::Id::new(GUIDE_DRAG)))
+ && let Some(p) = g.at
+ {
+ let col = Color32::from_rgb(74, 227, 255);
+ let (a, b) = match g.orientation {
+ designcraft_doc::Orientation::Horizontal => (pos2(rect.min.x, p.y), pos2(rect.max.x, p.y)),
+ designcraft_doc::Orientation::Vertical => (pos2(p.x, rect.min.y), pos2(p.x, rect.max.y)),
+ };
+ painter.line_segment([a, b], Stroke::new(1.0, col));
+ }
draw_frames(app, &painter, &xf, &doc, &layout);
if app.ui.hidden_characters {
draw_hidden_characters(app, &painter, &xf, &doc, &layout);
@@ -410,9 +420,14 @@ fn draw_guides(app: &DesignApp, painter: &egui::Painter, xf: &Xf, doc: &Document
}
}
for g in &p.guides {
+ // Spread guides cross the pasteboard; page guides their page.
+ let span = if g.spread { layout.pasteboard } else { pr };
let (a, bb) = match g.orientation {
- designcraft_doc::Orientation::Horizontal => (Point::new(pr.x0, g.position + off.y), Point::new(pr.x1, g.position + off.y)),
- designcraft_doc::Orientation::Vertical => (Point::new(g.position + off.x, pr.y0), Point::new(g.position + off.x, pr.y1)),
+ designcraft_doc::Orientation::Horizontal => (Point::new(span.x0, g.position + off.y), Point::new(span.x1, g.position + off.y)),
+ designcraft_doc::Orientation::Vertical => {
+ let span = if g.spread { slot.bounds.inflate(0.0, 36.0) } else { pr };
+ (Point::new(g.position + off.x, span.y0), Point::new(g.position + off.x, span.y1))
+ }
};
painter.line_segment([xf.to_screen(a), xf.to_screen(bb)], Stroke::new(hair(painter), Color32::from_rgb(74, 227, 255)));
}
@@ -1085,6 +1100,9 @@ fn handle_input(app: &mut DesignApp, ui: &mut egui::Ui, resp: &egui::Response, r
}
return;
}
+ if !space && guide_drag(app, ui, resp, rect, &xf) {
+ return;
+ }
let m = ui.input(|i| mods(i, space));
let vi = app.view_info();
let pos = |p: Pos2| xf.to_canvas(p);
@@ -1240,3 +1258,129 @@ pub fn selected_text(app: &DesignApp) -> Option<String> {
fn hair(painter: &egui::Painter) -> f32 {
1.0 / painter.ctx().pixels_per_point()
}
+
+const GUIDE_DRAG: &str = "canvas_guide_drag";
+
+/// A ruler guide being dragged: out of a ruler (`from` None) or an existing one.
+#[derive(Clone, Debug)]
+struct GuideDrag {
+ orientation: designcraft_doc::Orientation,
+ from: Option<(designcraft_doc::SpreadRef, usize, usize)>,
+ /// Pointer position (screen).
+ at: Option<Pos2>,
+}
+
+/// The guide under a screen point (within 3 px), as (spread, page, index, orientation).
+fn guide_at(app: &DesignApp, xf: &Xf, p: Pos2) -> Option<(designcraft_doc::SpreadRef, usize, usize, designcraft_doc::Orientation)> {
+ let st = app.session.active()?;
+ let layout = CanvasLayout::new(&st.doc, st.editing_parents);
+ let cp = xf.to_canvas(p);
+ let tol = 3.0 / xf.zoom;
+ for slot in &layout.slots {
+ let sp = st.doc.spread(slot.spread)?;
+ let local = cp - slot.offset;
+ for (pi, pg) in sp.pages.iter().enumerate() {
+ let pr = if pg.guides.iter().any(|g| g.spread) { layout.pasteboard - slot.offset } else { pg.bounds() };
+ for (gi, g) in pg.guides.iter().enumerate() {
+ let r = if g.spread { pr } else { pg.bounds() };
+ let hit = match g.orientation {
+ designcraft_doc::Orientation::Horizontal => (local.y - g.position).abs() <= tol && local.x >= r.x0 && local.x <= r.x1,
+ designcraft_doc::Orientation::Vertical => (local.x - g.position).abs() <= tol && local.y >= r.y0 - tol && local.y <= r.y1 + tol,
+ };
+ if hit && !g.locked {
+ return Some((slot.spread, pi, gi, g.orientation));
+ }
+ }
+ }
+ }
+ None
+}
+
+/// Ruler guides: drag one out of a ruler, drag an existing one (Selection tools, not over an
+/// object) to move it, drop it back on a ruler to delete it. Returns true while it owns the pointer.
+fn guide_drag(app: &mut DesignApp, ui: &mut egui::Ui, resp: &egui::Response, rect: Rect, xf: &Xf) -> bool {
+ let id = egui::Id::new(GUIDE_DRAG);
+ let (pressed, released, origin, latest) =
+ ui.input(|i| (i.pointer.primary_pressed(), i.pointer.primary_released(), i.pointer.press_origin(), i.pointer.latest_pos()));
+ let mut drag: Option<GuideDrag> = ui.data(|d| d.get_temp(id));
+ if drag.is_none() && pressed && resp.hovered() && app.ui.guides && !app.ui.guides_locked {
+ let Some(o) = origin else { return false };
+ let full = resp.rect;
+ if full.contains(o) && !rect.contains(o) {
+ // In a ruler (not the corner).
+ let orientation = if o.y < rect.min.y && o.x >= rect.min.x {
+ Some(designcraft_doc::Orientation::Horizontal)
+ } else if o.x < rect.min.x && o.y >= rect.min.y {
+ Some(designcraft_doc::Orientation::Vertical)
+ } else {
+ None
+ };
+ if let Some(orientation) = orientation {
+ drag = Some(GuideDrag { orientation, from: None, at: Some(o) });
+ }
+ } else if rect.contains(o)
+ && matches!(app.session.tool_id(), "selection" | "directSelection")
+ && let Some((r, pi, gi, orientation)) = guide_at(app, xf, o)
+ {
+ // Objects take precedence over the guides behind them.
+ let over_item = app.session.active().is_some_and(|st| {
+ let layout = CanvasLayout::new(&st.doc, st.editing_parents);
+ layout.spread_at(xf.to_canvas(o)).is_some_and(|(sr, p)| match sr {
+ designcraft_doc::SpreadRef::Doc(si) => st.doc.hit_item(si, p, 3.0 / xf.zoom).is_some(),
+ _ => false,
+ })
+ });
+ if !over_item {
+ drag = Some(GuideDrag { orientation, from: Some((r, pi, gi)), at: Some(o) });
+ }
+ }
+ }
+ let Some(mut g) = drag else { return false };
+ if let Some(p) = latest {
+ g.at = Some(p);
+ }
+ if !released {
+ ui.ctx().set_cursor_icon(match g.orientation {
+ designcraft_doc::Orientation::Horizontal => egui::CursorIcon::ResizeVertical,
+ designcraft_doc::Orientation::Vertical => egui::CursorIcon::ResizeHorizontal,
+ });
+ ui.data_mut(|d| d.insert_temp(id, g));
+ return true;
+ }
+ ui.data_mut(|d| d.remove::<GuideDrag>(id));
+ let Some(p) = g.at else { return true };
+ let on_canvas = rect.contains(p);
+ let target = app.session.active().and_then(|st| {
+ let layout = CanvasLayout::new(&st.doc, st.editing_parents);
+ let (r, sp) = layout.spread_at(xf.to_canvas(p))?;
+ let spread = st.doc.spread(r)?;
+ let on_page = spread.pages.iter().position(|pg| pg.bounds().contains(sp));
+ Some((r, sp, on_page))
+ });
+ let pos_of = |sp: Point| match g.orientation {
+ designcraft_doc::Orientation::Horizontal => sp.y,
+ designcraft_doc::Orientation::Vertical => sp.x,
+ };
+ let orient = match g.orientation {
+ designcraft_doc::Orientation::Horizontal => "horizontal",
+ designcraft_doc::Orientation::Vertical => "vertical",
+ };
+ match (g.from, on_canvas, target) {
+ // Dropped back on a ruler: delete.
+ (Some((r, pi, gi)), false, _) => {
+ let _ = app.run("guide.delete", json!({"spread": r, "page": pi, "index": gi}));
+ }
+ (Some((r, pi, gi)), true, Some((tr, sp, _))) if tr == r => {
+ let _ = app.run("guide.move", json!({"spread": r, "page": pi, "index": gi, "position": pos_of(sp)}));
+ }
+ (None, true, Some((r, sp, on_page))) => {
+ let mut params = json!({"spread": r, "orientation": orient, "position": pos_of(sp), "at": sp.x, "spreadGuide": on_page.is_none()});
+ if let Some(pi) = on_page {
+ params["page"] = json!(pi);
+ }
+ let _ = app.run("guide.add", params);
+ }
+ _ => {}
+ }
+ true
+}
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index 158642cba..2e88d0cfb 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -19,6 +19,7 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
("app.insertTableDialog", "Create Table…", None, "{} — Insert Table dialog (body/header/footer rows, columns)"),
("app.footnoteOptionsDialog", "Document Footnote Options…", None, "{} — numbering, formatting and layout of footnotes"),
("app.insertXrefDialog", "Insert Cross-Reference…", None, "{} — New Cross-Reference dialog (paragraph or text anchor, format)"),
+ ("app.deleteAllGuides", "Delete All Guides on Spread", None, "{} — the spread in view"),
("app.deletePage", "Delete Page", None, "{} — deletes the page in view"),
("app.duplicateSpread", "Duplicate Spread", None, "{} — duplicates the spread in view (pages and items)"),
("app.tablePanel", "Table Panel", Some("Shift+F9"), "{}"),
@@ -132,6 +133,7 @@ pub const MENUS: &[(&str, &[&str])] = &[
"cmd:layout.parents.new",
"<",
"cmd:layout.marginsAndColumns",
+ "cmd:layout.createGuides",
"-",
"ui:view.goToPage",
"-",
@@ -345,8 +347,12 @@ pub const MENUS: &[(&str, &[&str])] = &[
"ui:view.textThreads",
"ui:view.hiddenCharacters",
"-",
+ ">Grids & Guides",
"ui:view.guides",
"ui:view.baselineGrid",
+ "-",
+ "ui:app.deleteAllGuides",
+ "<",
],
),
(
@@ -456,6 +462,12 @@ pub fn run_ui(app: &mut DesignApp, id: &str, p: &Value) -> Option<Result<Value,
app.ui.dialog = Some(crate::dialogs::Dialog::new("insertXref", json!({})));
Ok(Value::Null)
}
+ "app.deleteAllGuides" => {
+ let Some(st) = app.session.active() else { return Some(Err("no document open".into())) };
+ let page = crate::canvas::current_page(app).unwrap_or(0);
+ let spread = if st.editing_parents { json!({"kind": "parent", "index": 0}) } else { json!(st.doc.page_loc(page).map_or(0, |l| l.0)) };
+ return Some(app.run("guide.deleteAll", json!({"spread": spread})));
+ }
"app.deletePage" | "app.duplicateSpread" => {
let Some(st) = app.session.active() else { return Some(Err("no document open".into())) };
let page = crate::canvas::current_page(app).unwrap_or(0);
diff --git a/crates/ui-egui/src/taskbar.rs b/crates/ui-egui/src/taskbar.rs
index c3a3aad0e..0198ebf4e 100644
--- a/crates/ui-egui/src/taskbar.rs
+++ b/crates/ui-egui/src/taskbar.rs
@@ -12,7 +12,8 @@ pub const HEIGHT: f32 = 36.0;
/// Show the bar under `sel` (screen rect of the selection), kept inside `canvas`.
pub fn show(app: &mut DesignApp, ctx: &egui::Context, sel: Rect, canvas: Rect) {
- if !app.ui.task_bar || ctx.input(|i| i.pointer.any_down() && !ctx.is_pointer_over_egui()) {
+ // (Two separate context calls: `is_pointer_over_egui` inside an `input` closure deadlocks.)
+ if !app.ui.task_bar || (ctx.input(|i| i.pointer.any_down()) && !ctx.is_pointer_over_egui()) {
return;
}
let Some(st) = app.session.active() else { return };