a770fa5a5e5f
trimextend.rs
//! TRIM and EXTEND: the prompt sequence and the JSON forms. Quick and Standard modes
//! (TRIMEXTENDMODE), cutting/boundary edges, Fence, Crossing, Project (PROJMODE), Edge (EDGEMODE),
//! eRase and Undo. The geometry of one trim or extend is in modify.rs.
use std::sync::Arc;
use cadcraft_doc::{Drawing, EntityKind, Handle};
use cadcraft_geom::{Bounds2, Line, Vec2, line_line};
use serde_json::{Value, json};
use super::helpers::{line, lwpoly, rect_vertices};
use super::modify::{Edges, extend, trim};
use super::{bad, point_param, points_param};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
/// Most fence points the JSON form takes.
const MAX_FENCE: usize = 10_000;
/// TRIMEXTENDMODE: 1 (default) Quick, 0 Standard.
fn quick_mode(s: &Session) -> bool {
s.doc().map(|d| d.header.i64("TRIMEXTENDMODE", 1) != 0).unwrap_or(true)
}
/// EDGEMODE: 1 extends cutting and boundary edges virtually (Standard mode).
fn edge_mode(s: &Session) -> bool {
s.doc().map(|d| d.header.i64("EDGEMODE", 0) != 0).unwrap_or(false)
}
/// PROJMODE: 0 None, 1 UCS (default), 2 View. Drawings are 2D (every object lies in the XY
/// plane), so the three give the same result; the setting is kept for scripts and the DWG.
fn proj_mode(s: &Session) -> i64 {
s.doc().map(|d| d.header.i64("PROJMODE", 1)).unwrap_or(1)
}
/// Whether a trim error says the object meets no cutting edge (a Quick-mode trim then erases it).
fn misses_edges(e: &EngineError) -> bool {
e.to_string().contains("intersect")
}
/// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
/// erases it. Returns what `h` became: its pieces, `h` itself first (none when it was erased).
fn apply(s: &mut Session, h: Handle, at: Vec2, extending: bool, edges: Edges, quick: bool) -> Result<Vec<Handle>> {
if extending {
extend(s, h, at, edges)?;
return Ok(vec![h]);
}
match trim(s, h, at, edges) {
Err(e) if quick && misses_edges(&e) => {
s.doc_mut()?.remove_entity(h);
Ok(Vec::new())
}
r => r,
}
}
/// Trim (or extend) every object the fence `pts` crosses, at each crossing (extend: at the first).
/// Returns how many trims or extends were made.
fn fence(s: &mut Session, pts: &[Vec2], extending: bool, edges: Edges, quick: bool) -> Result<usize> {
let space = s.space();
let d = s.doc()?;
let fb = Bounds2::from_points(pts.iter().copied());
let tol = crate::select::window_tol(&fb);
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
for h in crate::select::select_fence_in(d, &space, s.viewport_frozen(), pts) {
let Some(e) = d.entity(h) else { continue };
let polys = crate::select::hit_polylines(d, e, tol);
let mut xs: Vec<Vec2> = Vec::new();
for f in pts.windows(2) {
let (Some(a), Some(b)) = (f.first(), f.get(1)) else { continue };
let fl = Line::new(*a, *b);
// Crossings along this fence segment, in fence order.
let mut here: Vec<Vec2> = polys
.iter()
.flat_map(|pl| pl.windows(2).filter_map(|w| line_line(&fl, &Line::new(*w.first()?, *w.get(1)?))))
.filter(|x| !xs.iter().any(|y| y.near(*x, tol)))
.collect();
here.sort_by(|x, y| x.dist(*a).total_cmp(&y.dist(*a)));
here.dedup_by(|x, y| x.near(*y, tol));
xs.extend(here);
}
work.push((h, xs));
}
run_picks(s, work, extending, edges, quick, tol)
}
/// Trim (or extend) every object a crossing window from `a` to `b` touches, picked at its point
/// in the window nearest the first corner `a`.
fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, quick: bool) -> Result<usize> {
let space = s.space();
let d = s.doc()?;
let bx = Bounds2::new(a, b);
let tol = crate::select::window_tol(&bx);
let sides = [
Line::new(bx.min, Vec2::new(bx.max.x, bx.min.y)),
Line::new(Vec2::new(bx.max.x, bx.min.y), bx.max),
Line::new(bx.max, Vec2::new(bx.min.x, bx.max.y)),
Line::new(Vec2::new(bx.min.x, bx.max.y), bx.min),
];
let inside = |p: Vec2| bx.expand(tol).contains(p);
let mut work: Vec<(Handle, Vec<Vec2>)> = Vec::new();
for h in crate::select::select_window_in(d, &space, s.viewport_frozen(), bx, true) {
let Some(e) = d.entity(h) else { continue };
let mut best: Option<Vec2> = None;
for pl in crate::select::hit_polylines(d, e, tol) {
for w in pl.windows(2) {
let (Some(p), Some(q)) = (w.first(), w.get(1)) else { continue };
let seg = Line::new(*p, *q);
let cands = [*p, *q, seg.closest(a)].into_iter().chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
for c in cands.filter(|c| inside(*c)) {
if best.is_none_or(|b| c.dist(a) < b.dist(a)) {
best = Some(c);
}
}
}
}
if let Some(p) = best {
work.push((h, vec![p]));
}
}
run_picks(s, work, extending, edges, quick, tol)
}
/// Trim (or extend) each object at its pick points. A trim leaves the object in pieces, so later
/// picks go to the piece within `tol` of the point (none: that part is already gone).
fn run_picks(s: &mut Session, work: Vec<(Handle, Vec<Vec2>)>, extending: bool, edges: Edges, quick: bool, tol: f64) -> Result<usize> {
let mut n = 0;
let mut last_err = None;
for (h, picks) in work {
let mut live = vec![h];
for x in picks {
let target = {
let d = s.doc()?;
live.iter()
.filter_map(|l| d.entity(*l).map(|e| (*l, crate::select::entity_distance(d, e, x, tol))))
.filter(|(_, dist)| *dist <= 3.0 * tol)
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(l, _)| l)
};
let Some(t) = target else { continue };
match apply(s, t, x, extending, edges, quick) {
Ok(new) => {
live.retain(|l| *l != t);
live.extend(new);
n += 1;
}
Err(e) => last_err = Some(e),
}
if extending {
break;
}
}
}
match (n, last_err) {
(0, Some(e)) => Err(e),
(0, None) => Err(EngineError::Other("No objects found.".into())),
_ => Ok(n),
}
}
/// The JSON forms' `edgeMode`: "extend" / "none" (or true / false).
fn edge_mode_param(cmd: &str, p: &Value) -> Result<bool> {
match p.get("edgeMode") {
None | Some(Value::Null) => Ok(false),
Some(Value::Bool(b)) => Ok(*b),
Some(Value::String(t)) => match t.trim().to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
"extend" => Ok(true),
"none" | "noextend" => Ok(false),
_ => Err(bad(cmd, "`edgeMode` must be \"extend\" or \"none\"")),
},
Some(_) => Err(bad(cmd, "`edgeMode` must be \"extend\" or \"none\"")),
}
}
fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
let cmd = if extending { "extend" } else { "trim" };
let only: Option<Vec<Handle>> =
p.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_str().and_then(Handle::parse_hex)).collect());
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
let quick = match p.get("mode") {
None | Some(Value::Null) => false,
Some(v) => match v.as_str().map(|m| m.trim().to_ascii_lowercase()).as_deref() {
Some("quick") => true,
Some("standard") => false,
_ => return Err(bad(cmd, "`mode` must be \"quick\" or \"standard\"")),
},
};
let key = if extending { "extended" } else { "trimmed" };
if p.get("fence").is_some_and(|v| !v.is_null()) {
let pts = points_param(p, "fence")
.filter(|v| (2..=MAX_FENCE).contains(&v.len()))
.ok_or_else(|| bad(cmd, "`fence` needs two or more points [[x,y], ...]"))?;
let n = fence(s, &pts, extending, edges, quick)?;
return Ok(json!({ key: n }));
}
if p.get("crossing").is_some_and(|v| !v.is_null()) {
let c = points_param(p, "crossing").filter(|v| v.len() == 2).ok_or_else(|| bad(cmd, "`crossing` needs two corners [[x,y], [x,y]]"))?;
let (Some(a), Some(b)) = (c.first(), c.get(1)) else { return Err(bad(cmd, "`crossing` needs two corners")) };
let n = crossing(s, *a, *b, extending, edges, quick)?;
return Ok(json!({ key: n }));
}
let h = super::targets(s, p)?.first().copied().ok_or_else(|| bad(cmd, "`handle` is required"))?;
let pick = point_param(p, "pick").ok_or_else(|| bad(cmd, "`pick` ([x, y]) is required"))?;
let r = apply(s, h, pick, extending, edges, quick)?;
if extending { Ok(Value::Null) } else { Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() })) }
}
pub(crate) fn run_trim(s: &mut Session, p: &Value) -> Result<Value> {
run(s, p, false)
}
pub(crate) fn run_extend(s: &mut Session, p: &Value) -> Result<Value> {
run(s, p, true)
}
// ---------------- the prompt sequence ----------------
#[derive(Clone, PartialEq)]
enum Stage {
/// "Select object to trim or shift-select to extend".
Pick,
/// "Select objects or <select all>": the cutting/boundary edges picked so far.
Edges(Vec<Handle>),
/// Fence points so far.
Fence(Vec<Vec2>),
/// A crossing window: its first corner once picked.
Crossing(Option<Vec2>),
Mode,
Project,
Edge,
/// "Select objects to erase or <exit>": the objects picked so far.
Erase(Vec<Handle>),
}
pub(crate) struct TrimM {
extend: bool,
/// Cutting/boundary edges; `None`: all objects.
edges: Option<Vec<Handle>>,
stage: Stage,
/// The drawing before each trim, extend or erase, for Undo.
undo: Vec<Arc<Drawing>>,
}
impl TrimM {
pub(crate) fn new(extend: bool) -> Self {
TrimM { extend, edges: None, stage: Stage::Pick, undo: Vec::new() }
}
fn edges(&self, quick: bool, implied: bool) -> Edges<'_> {
Edges { only: self.edges.as_deref(), implied: !quick && implied }
}
fn select_edges(&mut self, s: &mut Session) {
s.echo(if self.extend { "Select boundary edges ..." } else { "Select cutting edges ..." });
s.set_selection(Vec::new());
self.stage = Stage::Edges(Vec::new());
}
/// Run `f` as one undoable step of the command; a step that changed nothing records none.
fn step(&mut self, s: &mut Session, f: impl FnOnce(&mut Self, &mut Session) -> Result<()>) -> Result<()> {
let before = s.state()?.doc.clone();
let r = f(self, s);
if !Arc::ptr_eq(&before, &s.state()?.doc) {
self.undo.push(before);
}
r
}
fn option(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let word = match &i {
Input::Keyword(k) | Input::Text(k) => k.trim().to_ascii_lowercase(),
Input::Enter => String::new(),
_ => return Ok(Step::Continue),
};
let stage = self.stage.clone();
let invalid = || EngineError::Other("Invalid option keyword.".into());
match stage {
Stage::Mode => {
let quick = match word.as_str() {
"" => quick_mode(s),
w if w.starts_with('q') => true,
w if w.starts_with('s') => false,
_ => return Err(invalid()),
};
s.doc_mut()?.header.set_i64("TRIMEXTENDMODE", i64::from(quick));
if quick {
self.edges = None;
self.stage = Stage::Pick;
} else {
self.select_edges(s);
}
}
Stage::Project => {
let v = match word.as_str() {
"" => proj_mode(s),
w if w.starts_with('n') => 0,
w if w.starts_with('u') => 1,
w if w.starts_with('v') => 2,
_ => return Err(invalid()),
};
s.doc_mut()?.header.set_i64("PROJMODE", v);
self.stage = Stage::Pick;
}
Stage::Edge => {
let v = match word.as_str() {
"" => edge_mode(s),
w if w.starts_with('e') => true,
w if w.starts_with('n') => false,
_ => return Err(invalid()),
};
s.doc_mut()?.header.set_i64("EDGEMODE", i64::from(v));
self.stage = Stage::Pick;
}
_ => {}
}
Ok(Step::Continue)
}
}
impl Interactive for TrimM {
fn name(&self) -> &'static str {
if self.extend { "EXTEND" } else { "TRIM" }
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
s.set_selection(Vec::new());
let quick = quick_mode(s);
let proj = match proj_mode(s) {
0 => "None",
2 => "View",
_ => "UCS",
};
s.echo(format!(
"Current settings: Projection={proj}, Edge={}, Mode={}",
if edge_mode(s) { "Extend" } else { "None" },
if quick { "Quick" } else { "Standard" }
));
if !quick {
self.select_edges(s);
}
Ok(Step::Continue)
}
fn prompt(&self, s: &Session) -> Prompt {
match &self.stage {
Stage::Pick => {
let (msg, first) = if self.extend {
("Select object to extend or shift-select to trim", "Boundary edges")
} else {
("Select object to trim or shift-select to extend", "cuTting edges")
};
let mut kw = vec![first, "Fence", "Crossing", "mOde", "Project"];
if !quick_mode(s) {
kw.push("Edge");
}
if !self.extend {
kw.push("eRase");
}
kw.push("Undo");
Prompt::new(msg, Accept::POINT).kw(&kw)
}
Stage::Edges(_) => Prompt::new("Select objects or", Accept::SELECT).default("select all"),
Stage::Erase(_) => Prompt::new("Select objects to erase or", Accept::SELECT).default("exit"),
Stage::Fence(pts) => match pts.last() {
None => Prompt::new("Specify first fence point", Accept::POINT),
Some(l) => Prompt::new("Specify next fence point", Accept::POINT).kw(&["Undo"]).base(*l),
},
Stage::Crossing(None) => Prompt::new("Specify first corner", Accept::POINT),
Stage::Crossing(Some(_)) => Prompt::new("Specify opposite corner", Accept::POINT),
Stage::Mode => {
let msg = if self.extend { "Enter an extend mode option" } else { "Enter a trim mode option" };
Prompt::new(msg, Accept::TEXT).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
}
Stage::Project => {
let cur = match proj_mode(s) {
0 => "None",
2 => "View",
_ => "Ucs",
};
Prompt::new("Enter a projection option", Accept::TEXT).kw(&["None", "Ucs", "View"]).default(cur)
}
Stage::Edge => Prompt::new("Enter an implied edge extension mode", Accept::TEXT).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
"Extend"
} else {
"No extend"
}),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let quick = quick_mode(s);
let implied = edge_mode(s);
let extending = self.extend;
match self.stage.clone() {
Stage::Mode | Stage::Project | Stage::Edge => self.option(s, i),
Stage::Edges(mut picked) => {
match i {
Input::Pick(hs) => {
for h in hs {
if !picked.contains(&h) {
picked.push(h);
}
}
s.set_selection(picked.clone());
self.stage = Stage::Edges(picked);
}
Input::Enter => {
s.set_selection(Vec::new());
self.edges = if picked.is_empty() { None } else { Some(picked) };
self.stage = Stage::Pick;
}
_ => {}
}
Ok(Step::Continue)
}
Stage::Erase(mut picked) => {
match i {
Input::Pick(hs) => {
for h in hs {
if !picked.contains(&h) {
picked.push(h);
}
}
s.set_selection(picked.clone());
self.stage = Stage::Erase(picked);
}
Input::Enter => {
s.set_selection(Vec::new());
self.step(s, |_, s| {
let d = s.doc_mut()?;
for h in &picked {
let locked = d.entity(*h).and_then(|e| d.layer(&e.common.layer)).is_some_and(|l| l.locked);
if !locked {
d.remove_entity(*h);
}
}
Ok(())
})?;
self.stage = Stage::Pick;
}
_ => {}
}
Ok(Step::Continue)
}
Stage::Fence(mut pts) => {
match i {
Input::Point(p) => {
pts.push(p);
self.stage = Stage::Fence(pts);
}
Input::Keyword(k) if k == "Undo" => {
pts.pop();
self.stage = Stage::Fence(pts);
}
Input::Enter => {
self.stage = Stage::Pick;
if pts.len() >= 2 {
let r = self.step(s, |m, s| fence(s, &pts, extending, m.edges(quick, implied), quick).map(|_| ()));
if let Err(e) = r {
s.echo(e.to_string());
}
}
}
_ => {}
}
Ok(Step::Continue)
}
Stage::Crossing(first) => {
match (first, i) {
(None, Input::Point(p)) => self.stage = Stage::Crossing(Some(p)),
(Some(a), Input::Point(b)) => {
self.stage = Stage::Pick;
let r = self.step(s, |m, s| crossing(s, a, b, extending, m.edges(quick, implied), quick).map(|_| ()));
if let Err(e) = r {
s.echo(e.to_string());
}
}
(_, Input::Enter) => self.stage = Stage::Pick,
_ => {}
}
Ok(Step::Continue)
}
Stage::Pick => match i {
Input::Point(p) => {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
let Some(h) = s.pick_object(&space, p, ap)? else {
// A pick in empty space opens a crossing window there.
self.stage = Stage::Crossing(Some(p));
return Ok(Step::Continue);
};
let r = self.step(s, |m, s| apply(s, h, p, extending, m.edges(quick, implied), quick).map(|_| ()));
if let Err(e) = r {
s.echo(e.to_string());
}
Ok(Step::Continue)
}
Input::Enter => Ok(Step::Done),
Input::Keyword(k) => {
match k.as_str() {
"cuTting edges" | "Boundary edges" => self.select_edges(s),
"Fence" => self.stage = Stage::Fence(Vec::new()),
"Crossing" => self.stage = Stage::Crossing(None),
"mOde" => self.stage = Stage::Mode,
"Project" => self.stage = Stage::Project,
"Edge" => self.stage = Stage::Edge,
"eRase" => {
s.set_selection(Vec::new());
self.stage = Stage::Erase(Vec::new());
}
"Undo" => match self.undo.pop() {
Some(doc) => {
// Settings changed meanwhile stay.
let header = s.doc()?.header.clone();
s.state_mut()?.doc = doc;
s.doc_mut()?.header = header;
}
None => s.echo("Nothing to undo."),
},
_ => {}
}
Ok(Step::Continue)
}
_ => Ok(Step::Continue),
},
}
}
fn preview(&self, _s: &Session, c: Vec2) -> Vec<EntityKind> {
match &self.stage {
Stage::Fence(pts) if !pts.is_empty() => pts
.iter()
.copied()
.chain(std::iter::once(c))
.collect::<Vec<_>>()
.windows(2)
.filter_map(|w| Some(line(*w.first()?, *w.get(1)?)))
.collect(),
Stage::Crossing(Some(a)) => vec![lwpoly(rect_vertices(*a, c), true)],
_ => Vec::new(),
}
}
}
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.