a770fa5a5e5f
prompts.rs
//! -LAYER: the command-line form of LAYER. An option loop that ends on Enter; every option runs
//! the `layer.*` commands, so validation matches the JSON form and the whole session is one undo
//! step.
use cadcraft_color::Color;
use cadcraft_doc::Lineweight;
use serde_json::{Value, json};
use super::super::find_command;
use super::super::qselect::wildcard;
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
const OPTIONS: &[&str] = &[
"?",
"Make",
"Set",
"New",
"Rename",
"ON",
"OFF",
"Color",
"Ltype",
"LWeight",
"TRansparency",
"MATerial",
"Plot",
"Freeze",
"Thaw",
"LOck",
"Unlock",
"stAte",
"Description",
"rEconcile",
];
/// Keyword-only: spaces separate inputs.
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
/// A name or value: Space ends the input, as it does in AutoCAD scripts.
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
/// A per-layer change applied to a list of layer names.
#[derive(Clone, Debug)]
enum Change {
On,
Off,
Freeze,
Thaw,
Lock,
Unlock,
Color(String),
Ltype(String),
Lweight(f64),
Transparency(u64),
Plot(bool),
Description(String),
}
impl Change {
fn params(&self) -> Value {
match self {
Change::On => json!({ "on": true }),
Change::Off => json!({ "on": false }),
Change::Freeze => json!({ "frozen": true }),
Change::Thaw => json!({ "frozen": false }),
Change::Lock => json!({ "locked": true }),
Change::Unlock => json!({ "locked": false }),
Change::Color(c) => json!({ "color": c }),
Change::Ltype(l) => json!({ "linetype": l }),
Change::Lweight(mm) => json!({ "lineweight": mm }),
Change::Transparency(t) => json!({ "transparency": t }),
Change::Plot(p) => json!({ "plot": p }),
Change::Description(d) => json!({ "description": d }),
}
}
/// The layer-list prompt for this change; `true` when Enter means the current layer.
fn prompt(&self) -> (String, bool) {
match self {
Change::On => ("Enter name list of layer(s) to turn on".into(), false),
Change::Off => ("Enter name list of layer(s) to turn off".into(), false),
Change::Freeze => ("Enter name list of layer(s) to freeze".into(), false),
Change::Thaw => ("Enter name list of layer(s) to thaw".into(), false),
Change::Lock => ("Enter name list of layer(s) to lock".into(), false),
Change::Unlock => ("Enter name list of layer(s) to unlock".into(), false),
Change::Color(c) => (format!("Enter name list of layer(s) for color {c}"), true),
Change::Ltype(l) => (format!("Enter name list of layer(s) for linetype \"{l}\""), true),
Change::Lweight(mm) => (format!("Enter name list of layer(s) for lineweight {mm:.2}mm"), true),
Change::Transparency(t) => (format!("Enter name list of layer(s) for transparency {t}%"), true),
Change::Plot(_) => ("Enter layer name(s) for this plot preference".into(), true),
Change::Description(_) => ("Enter name list of layer(s) to apply description".into(), true),
}
}
}
#[derive(Clone, Debug, Default)]
enum Stage {
#[default]
Option,
List,
Make,
Set,
New,
RenameFrom,
RenameTo(String),
Color,
TrueColor,
Ltype,
Lweight,
Transparency,
Plot,
Description,
Layers(Change),
/// Turning the current layer off asks first.
ConfirmOff(Vec<String>),
}
#[derive(Default)]
pub struct LayerM {
stage: Stage,
}
fn current_layer(s: &Session) -> String {
s.doc().map(|d| d.header.str("CLAYER", "0")).unwrap_or_else(|_| "0".into())
}
/// Run a layer command's body directly: the running command records the single undo step.
fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.into()))?;
(spec.run)(s, p)
}
fn message(e: &EngineError) -> String {
match e {
EngineError::BadParams { msg, .. } => msg.clone(),
other => other.to_string(),
}
}
fn retry(msg: impl Into<String>) -> EngineError {
EngineError::Other(msg.into())
}
/// Layers matching a comma-separated name list (wildcards allowed), in drawing order.
fn matching(s: &mut Session, list: &str) -> Vec<String> {
let Ok(d) = s.doc() else { return Vec::new() };
let mut out: Vec<String> = Vec::new();
let mut missing = Vec::new();
for pat in list.split(',').map(str::trim).filter(|p| !p.is_empty()).take(1000) {
let before = out.len();
for l in &d.layers {
if wildcard(pat, &l.name) && !out.iter().any(|n| n.eq_ignore_ascii_case(&l.name)) {
out.push(l.name.clone());
}
}
if out.len() == before && !d.layers.iter().any(|l| wildcard(pat, &l.name)) {
missing.push(pat.to_string());
}
}
for m in missing {
s.echo(format!("Cannot find layer \"{m}\"."));
}
out
}
/// Nearest standard lineweight to `mm`.
fn snap_lineweight(mm: f64) -> f64 {
let want = mm * 100.0;
let best = Lineweight::STANDARD.iter().copied().min_by(|a, b| (f64::from(*a) - want).abs().total_cmp(&(f64::from(*b) - want).abs())).unwrap_or(0);
f64::from(best) / 100.0
}
impl LayerM {
fn option(&mut self, s: &mut Session, k: &str) -> Result<Step> {
self.stage = match k {
"?" => Stage::List,
"Make" => Stage::Make,
"Set" => Stage::Set,
"New" => Stage::New,
"Rename" => Stage::RenameFrom,
"ON" => Stage::Layers(Change::On),
"OFF" => Stage::Layers(Change::Off),
"Color" => Stage::Color,
"Ltype" => Stage::Ltype,
"LWeight" => Stage::Lweight,
"TRansparency" => Stage::Transparency,
"Plot" => Stage::Plot,
"Freeze" => Stage::Layers(Change::Freeze),
"Thaw" => Stage::Layers(Change::Thaw),
"LOck" => Stage::Layers(Change::Lock),
"Unlock" => Stage::Layers(Change::Unlock),
"Description" => Stage::Description,
other => {
// MATerial, stAte, rEconcile: report and stay at the option prompt.
s.echo(format!("-LAYER {other} is not available yet."));
Stage::Option
}
};
Ok(Step::Continue)
}
fn list(&mut self, s: &mut Session, pat: &str) {
let names = matching(s, if pat.trim().is_empty() { "*" } else { pat });
let Ok(d) = s.doc() else { return };
let cur = d.header.str("CLAYER", "0");
let mut lines = vec![format!("{:<24} {:<26} {:<10} {:<14} {}", "Layer name", "State", "Color", "Linetype", "Lineweight")];
for l in names.iter().filter_map(|n| d.layer(n)) {
let state = format!(
"{} {} {}{}",
if l.on { "On" } else { "Off" },
if l.frozen { "Frozen" } else { "Thawed" },
if l.locked { "Locked" } else { "Unlocked" },
if l.plot { "" } else { " No plot" }
);
lines.push(format!("{:<24} {:<26} {:<10} {:<14} {}", l.name, state, l.color.name(), l.linetype, l.lineweight.name()));
}
lines.push(format!("Current layer: \"{cur}\""));
for l in lines {
s.echo(l);
}
}
/// Apply `change` to the named layers through `layer.set`; refusals are reported per layer.
fn apply(&mut self, s: &mut Session, change: &Change, names: &[String]) {
for n in names {
let mut p = change.params();
if let Some(o) = p.as_object_mut() {
o.insert("name".into(), json!(n));
}
if let Err(e) = call(s, "layer.set", &p) {
s.echo(format!("Layer \"{n}\": {}", message(&e)));
}
}
}
fn layers(&mut self, s: &mut Session, change: Change, text: Option<&str>) -> Result<Step> {
let (_, enter_is_current) = change.prompt();
let names = match text {
Some(t) => matching(s, t),
None if enter_is_current => vec![current_layer(s)],
None => Vec::new(),
};
let cur = current_layer(s);
if matches!(change, Change::Off) && names.iter().any(|n| n.eq_ignore_ascii_case(&cur)) {
self.stage = Stage::ConfirmOff(names);
return Ok(Step::Continue);
}
if matches!(change, Change::Freeze) && names.iter().any(|n| n.eq_ignore_ascii_case(&cur)) {
s.echo(format!("Cannot freeze layer \"{cur}\". It is the CURRENT layer."));
}
let names: Vec<String> = names.into_iter().filter(|n| !(matches!(change, Change::Freeze) && n.eq_ignore_ascii_case(&cur))).collect();
self.apply(s, &change, &names);
Ok(Step::Continue)
}
/// One input at a sub-prompt. Returns to the option prompt unless a value must be re-entered.
fn sub(&mut self, s: &mut Session, stage: Stage, i: Input) -> Result<Step> {
let text = match &i {
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
_ => None,
};
let back = |m: &mut LayerM, st: Stage| {
m.stage = st;
Ok(Step::Continue)
};
match stage {
Stage::Option => Ok(Step::Continue),
Stage::List => {
self.list(s, text.as_deref().unwrap_or("*"));
Ok(Step::Continue)
}
Stage::Make => {
let Some(n) = text else { return Ok(Step::Continue) };
let exists = s.doc()?.layer(&n).is_some();
let r = if exists {
call(s, "layer.current", &json!({ "name": n }))
} else {
call(s, "layer.new", &json!({ "name": n, "current": true }))
};
if let Err(e) = r {
s.echo(message(&e));
}
Ok(Step::Continue)
}
Stage::Set => {
let Some(n) = text else { return Ok(Step::Continue) };
if s.doc()?.layer(&n).is_none() {
s.echo(format!("Cannot find layer \"{n}\"."));
} else if let Err(e) = call(s, "layer.current", &json!({ "name": n })) {
s.echo(message(&e));
}
Ok(Step::Continue)
}
Stage::New => {
for n in text.as_deref().unwrap_or("").split(',').map(str::trim).filter(|n| !n.is_empty()).take(1000) {
if let Err(e) = call(s, "layer.new", &json!({ "name": n })) {
s.echo(message(&e));
}
}
Ok(Step::Continue)
}
Stage::RenameFrom => match text {
None => Ok(Step::Continue),
Some(n) => match s.doc()?.layer(&n).map(|l| l.name.clone()) {
Some(old) => back(self, Stage::RenameTo(old)),
None => {
s.echo(format!("Cannot find layer \"{n}\"."));
Ok(Step::Continue)
}
},
},
Stage::RenameTo(old) => {
if let Some(n) = text
&& let Err(e) = call(s, "layer.set", &json!({ "name": old, "newName": n }))
{
s.echo(message(&e));
}
Ok(Step::Continue)
}
Stage::Color => match (&i, text) {
(Input::Keyword(k), _) if k == "Truecolor" => back(self, Stage::TrueColor),
(Input::Keyword(_), _) => {
s.echo("Color books are not available yet.");
Ok(Step::Continue)
}
(_, None) => Ok(Step::Continue),
(_, Some(t)) => match Color::parse(&t) {
Some(Color::Index(c)) => back(self, Stage::Layers(Change::Color(c.to_string()))),
Some(Color::True(rgb)) => back(self, Stage::Layers(Change::Color(format!("{},{},{}", rgb.0, rgb.1, rgb.2)))),
_ => {
self.stage = Stage::Color;
Err(retry("Enter a color name or a number from 1 to 255."))
}
},
},
Stage::TrueColor => match text.as_deref().map(Color::parse) {
None => Ok(Step::Continue),
Some(Some(Color::True(rgb))) => back(self, Stage::Layers(Change::Color(format!("{},{},{}", rgb.0, rgb.1, rgb.2)))),
Some(_) => {
self.stage = Stage::TrueColor;
Err(retry("Enter three values from 0 to 255, separated by commas."))
}
},
Stage::Ltype => match (&i, text) {
(Input::Keyword(_), _) => {
let names: Vec<String> = s.doc()?.linetypes.iter().map(|l| l.name.clone()).collect();
s.echo(format!("Loaded linetypes: {}", names.join(", ")));
back(self, Stage::Ltype)
}
(_, None) => back(self, Stage::Layers(Change::Ltype("Continuous".into()))),
(_, Some(t)) => {
let found =
s.doc()?.linetype(&t).map(|l| l.name.clone()).filter(|n| !["bylayer", "byblock"].contains(&n.to_ascii_lowercase().as_str()));
match found {
Some(n) => back(self, Stage::Layers(Change::Ltype(n))),
None => {
s.echo(format!("Linetype \"{t}\" is not loaded. Load it with the LINETYPE command."));
Ok(Step::Continue)
}
}
}
},
Stage::Lweight => match text {
None => Ok(Step::Continue),
Some(t) => match t.trim_end_matches("mm").trim().parse::<f64>().ok().filter(|v| v.is_finite() && (0.0..=2.11).contains(v)) {
Some(mm) => back(self, Stage::Layers(Change::Lweight(snap_lineweight(mm)))),
None => {
self.stage = Stage::Lweight;
Err(retry("Enter a lineweight from 0.0mm to 2.11mm."))
}
},
},
Stage::Transparency => {
let v = match text {
None => Some(0),
Some(t) => t.parse::<u64>().ok().filter(|v| *v <= 90),
};
match v {
Some(v) => back(self, Stage::Layers(Change::Transparency(v))),
None => {
self.stage = Stage::Transparency;
Err(retry("Enter a transparency value from 0 to 90."))
}
}
}
Stage::Plot => match &i {
Input::Keyword(k) => back(self, Stage::Layers(Change::Plot(k != "No"))),
Input::Enter => back(self, Stage::Layers(Change::Plot(true))),
_ => {
self.stage = Stage::Plot;
Err(retry("Enter Plot or No."))
}
},
Stage::Description => back(self, Stage::Layers(Change::Description(text.unwrap_or_default()))),
Stage::Layers(change) => self.layers(s, change, text.as_deref()),
Stage::ConfirmOff(names) => {
let cur = current_layer(s);
let yes = matches!(&i, Input::Keyword(k) if k == "Yes");
let names: Vec<String> = names.into_iter().filter(|n| yes || !n.eq_ignore_ascii_case(&cur)).collect();
self.apply(s, &Change::Off, &names);
Ok(Step::Continue)
}
}
}
}
impl Interactive for LayerM {
fn name(&self) -> &'static str {
"-LAYER"
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
let cur = current_layer(s);
s.echo(format!("Current layer: \"{cur}\""));
Ok(Step::Continue)
}
fn prompt(&self, s: &Session) -> Prompt {
let cur = current_layer(s);
match &self.stage {
Stage::Option => Prompt::new("Enter an option", KW).kw(OPTIONS),
Stage::List => Prompt::new("Enter layer name(s) to list", NAME).default("*"),
Stage::Make => Prompt::new("Enter name for new layer (becomes the current layer)", NAME).default(cur),
Stage::Set => Prompt::new("Enter layer name to make current", NAME),
Stage::New => Prompt::new("Enter name list for new layer(s)", NAME),
Stage::RenameFrom => Prompt::new("Enter old layer name", NAME),
Stage::RenameTo(_) => Prompt::new("Enter new layer name", NAME),
Stage::Color => Prompt::new("Enter color name or number (1-255)", NAME).kw(&["Truecolor", "COlorbook"]),
Stage::TrueColor => Prompt::new("Red, Green, Blue", NAME),
Stage::Ltype => Prompt::new("Enter a loaded linetype name", NAME).kw(&["?"]).default("Continuous"),
Stage::Lweight => Prompt::new("Enter lineweight (0.0mm - 2.11mm)", NAME),
Stage::Transparency => Prompt::new("Enter transparency value (0-90)", NAME).default("0"),
Stage::Plot => Prompt::new("Enter a plotting preference", KW).kw(&["Plot", "No"]).default("Plot"),
Stage::Description => Prompt::new("Enter layer description", Accept::TEXT),
Stage::Layers(c) => {
let (msg, enter_is_current) = c.prompt();
let p = Prompt::new(msg, NAME);
if enter_is_current { p.default(cur) } else { p }
}
Stage::ConfirmOff(_) => Prompt::new(format!("Really want layer \"{cur}\" (the CURRENT layer) off?"), KW).kw(&["Yes", "No"]).default("N"),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (&self.stage, &i) {
(_, Input::Cancel) => Ok(Step::Cancel),
(Stage::Option, Input::Enter) => Ok(Step::Done),
(Stage::Option, Input::Keyword(k)) => {
let k = k.clone();
self.option(s, &k)
}
(Stage::Option, _) => Err(retry("Invalid option keyword.")),
_ => {
let stage = std::mem::take(&mut self.stage);
self.sub(s, stage, i)
}
}
}
}
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.