Compare commits

..
29 Commits
Author SHA1 Message Date
Tanish Manku d1cb40332b Stack u2: #3077: collapse the nested if (clippy) 2026-11-19 15:42:50 -07:00
Tanish Mankuandgraficaeusebio-cloud b7d5ed3401 Stack u2: #1279: test that Options reset also brings back the status bar and command line
Carried over from #1283's test, which also covered the status bar.

Co-authored-by: graficaeusebio-cloud <224763601+graficaeusebio-cloud@users.noreply.github.com>
2026-11-19 15:19:53 -07:00
Tanish Manku 6b767073d8 Stack u2: #1279: Options reset keeps the user's shortcuts and remembered folders
The reset now rebuilds the whole interface state so hidden bars come back (#1240), but that
also dropped the user's keyboard shortcuts and the APPLOAD and .pgp folders, which the old
reset and Window > Reset Palettes keep.
2026-11-19 15:18:53 -07:00
Tanish Manku 7bcfe25938 Stack u2: #1452: a Chinese label for MENUBAR's Menu Bar
main requires a Chinese label for every command (chinese_menus_and_commands_are_fully_translated);
the new MENUBAR command's label had none.
2026-11-19 15:18:13 -07:00
Tanish Manku 3886fb952d Merge #3077 2026-11-19 15:17:16 -07:00
Tanish Manku 6c9eedd7e1 Merge #2443 2026-11-19 15:17:16 -07:00
Tanish Manku 6411c1a4ab Merge #1867 2026-11-19 15:17:15 -07:00
Tanish Manku 6f203fb64b Merge #1452 2026-11-19 15:17:15 -07:00
Tanish Manku a2d209e10b Merge #1279 2026-11-19 15:17:15 -07:00
midasmatterhorn cd226cdf0f ui: keep the in-window menu where the host has no native one 2026-11-14 17:18:20 +03:00
assamaralandClaude Opus 5.5 8d2c9d1a26 fix(app): a saved main window below the minimum size opens at the default size
On Windows app.ron can hold a 64x64 window (e.g. saved while minimized).
eframe restores it as is, so the next launch shows an unusable tiny window.
Such an entry is now dropped from app.ron before launch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 15:19:42 -03:00
Nicholas Gower 0156fd9b9f docking: follow the shared surface's stock tab menu and non-exhaustive node
The dock area's tab menu item is "Close Panel" in the pinned craft-ui, and
Node is non-exhaustive, so the accordion scan needs a catch-all arm.
2026-11-02 08:26:29 -08:00
Nicholas Gower df2a5131af i18n: the panel close button's accessible name translates as a whole
The header close button built its name by joining an English "Close" to
the translated panel label, so Spanish screen readers heard "Close Capas".
A single translatable "Close {panel}" template now carries both parts, and
the tooltip's "Close panel" joins the catalogs too. Spanish gets both
rows, Ukrainian (the reference catalog) is required to have them, and
docking.rs joins the scanned sources so future marked strings stay covered.

Regression test: a Spanish harness finds "Cerrar Capas" and "Cerrar
Propiedades" by accessible name, proves "Close Capas" is gone, and closes
Layers through the localized button.
2026-11-02 08:24:52 -08:00
Nicholas Gower 5644c6c946 docs: document the functions touched by #1838 2026-11-02 08:24:04 -08:00
Nicholas Gower 0fa45daf25 UI: a visible close button on every panel header (fixes #1838)
Every dockable panel header now carries an X beside its title, so closing
a palette no longer has to be discovered in the tab context menu. The
button queues the same Close action as that menu item.

Tab and floating group headers use the docking surface's header callback;
accordion title bars place the same button left of the stock collapse
control. The accessible name includes the panel ("Close Layers"), the
tooltip says "Close panel", and the drawing canvas stays unclosable.

Regression test: crates/ui-egui/tests/docking_workflows.rs. It opens the
External References tab and checks its button does not cover the title,
closes the default Layers accordion entry, closes a floating Properties
group, and still closes Layers through the context menu.
2026-11-02 08:23:33 -08:00
austin62jake a92fb047d8 Merge remote-tracking branch 'upstream/main' into fix/refmanager-menu-closes 2026-11-01 07:07:28 -06:00
midasmatterhorn 33dc795c5f ui: the options reset brings a hidden menu bar and tool bar back 2026-11-01 05:26:41 +03:00
Aldo Zarate 4255108429 Merge remote-tracking branch 'upstream/main' into feat/menubar-toolbar-cmds
# Conflicts:
#	crates/ui-egui/src/lib.rs
2026-10-31 14:08:28 -06:00
Aldo Zarate 0b585fa8cb Merge remote-tracking branch 'upstream/main' into feat/menubar-toolbar-cmds
# Conflicts:
#	crates/engine/src/lib.rs
2026-10-30 13:52:46 -06:00
austin62jakeandClaude Opus 5.5 21d9627840 fix(ui): Window > Reference Manager closes the open palette
Once the External References palette was open, Window > Reference
Manager only opened it again, so there was no obvious way to close it
(the tab's right-click Close Panel works but is easy to miss). The menu
item now closes the palette when it is open, as Window > QuickCalc does
for QuickCalc (#2001). Typed XREF still only opens it, as in AutoCAD,
and XREF with JSON parameters still only lists the references.

Fixes #2273.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 22:33:23 -05:00
Aldo ZarateandClaude Opus 5.5 1c611d610d Control API: the bars are synced after every request
A command a control request runs (MENUBAR, TOOLBAR, also through cmdline.key) may ask for a bar;
control::handle now applies that before the next request, so a later query or ui.set sees the
bars as they are.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 10:29:46 -06:00
Aldo Zarate 076b7761a3 Merge remote-tracking branch 'upstream/main' into feat/menubar-toolbar-cmds 2026-10-28 10:26:55 -06:00
Aldo ZarateandClaude Opus 5.5 71a0ef2260 MENUBAR started from the interface offers the bar as shown now
CadApp::start syncs the bars before starting the command, as run and cmdline do, so MENUBAR's
default is the menu bar as the interface shows it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 10:12:50 -06:00
Aldo ZarateandClaude Opus 5.5 4fadc54dbe MENUBAR/TOOLBAR: control-API calls see the bars as shown now
CadApp::run now syncs the bars before and after the engine runs, as the command line does,
so a bar query right after a ui.set reports the interface's current bars and a MENUBAR or
TOOLBAR request is applied at once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 09:46:12 -06:00
Aldo ZarateandClaude Opus 5.5 9c2ebc0e12 MENUBAR/TOOLBAR: request each bar on its own
The request was both bars as one snapshot, so a tool bar change made between MENUBAR and the
UI applying it was undone. Each command now asks only for its own bar, and the UI applies only
the bars asked for.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 09:25:10 -06:00
Aldo ZarateandClaude Opus 5.5 98240d82d0 MENUBAR/TOOLBAR: explicit imports for the wildcard-imports lint
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 08:03:36 -06:00
Aldo Zarate 1e1cf10a1c Merge remote-tracking branch 'upstream/main' into feat/menubar-toolbar-cmds 2026-10-28 08:02:57 -06:00
Aldo Zarate af460caac6 Merge remote-tracking branch 'upstream/main' into feat/menubar-toolbar-cmds 2026-10-26 19:34:20 -06:00
Aldo ZarateandClaude Opus 5.5 ad072e6cb0 MENUBAR and TOOLBAR at the command line bring hidden bars back (#1341)
On Windows and Linux the in-window menu bar is the only menu, so once it
was hidden there was no way back from the keyboard: MENUBAR and TOOLBAR,
which AutoCAD users type for this, were unknown commands.

MENUBAR asks "Enter new value for MENUBAR <1>:" (1 shows, 0 hides), and
TOOLBAR (alias -TOOLBAR) asks for Show or Hide, Show by default. The JSON
forms report or set the bars. The engine records the change and the UI
applies it, reporting what it shows every frame.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 10:54:43 -06:00
49 changed files with 759 additions and 2569 deletions
+45 -4
View File
@@ -233,11 +233,38 @@ fn saved_window(app_ron: &str) -> bool {
ron::from_str::<std::collections::HashMap<String, String>>(app_ron).is_ok_and(|kv| kv.contains_key(WINDOW_KEY))
}
/// The window state from the last session is saved and will be restored (#2595).
/// The window state from the last session is saved and will be restored (#2595). A saved size
/// below the minimum (seen on Windows: 64×64 points, which eframe restores un-maximized and
/// unusable) is dropped first, so the window opens at its default size.
fn restores_window() -> bool {
eframe::storage_dir(APP_ID).and_then(|dir| std::fs::read_to_string(dir.join("app.ron")).ok()).is_some_and(|ron| saved_window(&ron))
let Some(path) = eframe::storage_dir(APP_ID).map(|dir| dir.join("app.ron")) else { return false };
let Ok(mut ron) = std::fs::read_to_string(&path) else { return false };
if let Some(fixed) = without_tiny_window(&ron)
&& std::fs::write(&path, &fixed).is_ok()
{
ron = fixed;
}
saved_window(&ron)
}
/// `app_ron` without its window entry when that entry's inner size is below `MIN_INNER_SIZE`;
/// `None` when there is nothing to drop (no entry, a usable size, or an unreadable file).
fn without_tiny_window(app_ron: &str) -> Option<String> {
let mut kv = ron::from_str::<std::collections::BTreeMap<String, String>>(app_ron).ok()?;
let w = kv.get(WINDOW_KEY)?;
let size = &w[w.find("inner_size_points:")?..];
let num = |k: &str| size[size.find(k)? + k.len()..].split([',', ')']).next()?.trim().parse::<f32>().ok();
let (x, y) = (num("x:")?, num("y:")?);
if x >= MIN_INNER_SIZE[0] && y >= MIN_INNER_SIZE[1] {
return None;
}
kv.remove(WINDOW_KEY);
ron::ser::to_string_pretty(&kv, ron::ser::PrettyConfig::default()).ok()
}
/// The smallest main window, in points.
const MIN_INNER_SIZE: [f32; 2] = [900.0, 560.0];
/// The main window: its size, title bar, placement and rendering needs. `restoring`: a window state
/// saved by the last session is restored instead of opening centred.
fn window_options(restoring: bool) -> eframe::NativeOptions {
@@ -245,7 +272,7 @@ fn window_options(restoring: bool) -> eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_title("CADCraft")
.with_inner_size([1600.0, 1000.0])
.with_min_inner_size([900.0, 560.0])
.with_min_inner_size(MIN_INNER_SIZE)
.with_drag_and_drop(true)
.with_fullsize_content_view(true)
.with_titlebar_shown(false)
@@ -403,6 +430,9 @@ fn main() -> eframe::Result {
app.ui = ui;
}
app.set_system_cursor_default(vars.system_cursor == Switch::On);
// macOS: CADCRAFT_NO_NATIVE_MENU=1 keeps the menus inside the window.
#[cfg(target_os = "macos")]
app.set_native_menus(vars.no_native_menu != Switch::On);
if let Some(error) = &workspace_error {
eprintln!("CADCraft workspace: {error}");
app.set_status(error);
@@ -481,7 +511,7 @@ fn main() -> eframe::Result {
#[cfg(test)]
mod tests {
use super::{filters_for_save, follow_desktop, saved_window, window_options};
use super::{filters_for_save, follow_desktop, saved_window, window_options, without_tiny_window};
#[test]
fn save_dialog_offers_dwg_with_the_drawing_format_first() {
@@ -525,6 +555,17 @@ mod tests {
assert!(!saved_window("not ron at all"));
}
/// A saved 64×64 window (below the minimum) is dropped; a usable one is kept.
#[test]
fn a_tiny_saved_window_is_dropped() {
let tiny = r#"{"window": "(normal_geometry:(outer_position_pixels:Some((x:0.0,y:0.0)),scale_factor:1.25,inner_size_points:(x:64.0,y:64.0)),fullscreen:false,maximized:true)", "cadcraft.prefs": "{}"}"#;
let fixed = without_tiny_window(tiny).expect("dropped");
assert!(!saved_window(&fixed) && fixed.contains("cadcraft.prefs"));
let ok = tiny.replace("x:64.0,y:64.0)),", "x:1600.0,y:1000.0)),");
assert_eq!(without_tiny_window(&ok), None);
assert_eq!(without_tiny_window("not ron"), None);
}
/// View ▸ Theme ▸ System on Linux: winit reports no theme, so the desktop's answer stands in;
/// without one (or where winit answers and the desktop doesn't) the input is left alone.
#[test]
+1 -39
View File
@@ -931,49 +931,11 @@ pub struct Ucs {
pub y_axis: Vec3,
}
/// A saved layer state (LAYERSTATE), as AutoCAD keeps one in the LAYER table's
/// `ACAD_LAYERSTATES` dictionary.
/// A saved layer state (LAYERSTATE).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct LayerState {
pub name: String,
pub layers: Vec<Layer>,
/// The properties restoring sets ([`LayerState::ON`] …): AutoCAD's mask (group 91 of the
/// state's XRECORD). Bits CADCraft doesn't use are kept as read.
pub mask: u32,
/// The layer restoring makes current; empty, or a layer the drawing doesn't have, leaves the
/// current layer as it is (AutoCAD 2024, measured).
pub current: String,
/// Group 301 of the state's XRECORD: empty as AutoCAD 2024's -LAYER saves a state; a text a
/// file holds there is kept.
pub description: String,
}
impl Default for LayerState {
fn default() -> Self {
LayerState { name: String::new(), layers: Vec::new(), mask: LayerState::ALL, current: String::new(), description: String::new() }
}
}
impl LayerState {
pub const ON: u32 = 1;
pub const FROZEN: u32 = 2;
pub const LOCKED: u32 = 4;
pub const PLOT: u32 = 8;
pub const VP_FREEZE_NEW: u32 = 16;
pub const COLOR: u32 = 32;
pub const LINETYPE: u32 = 64;
pub const LINEWEIGHT: u32 = 128;
pub const PLOT_STYLE: u32 = 256;
pub const TRANSPARENCY: u32 = 1024;
/// Every property: the mask of AutoCAD 2024's -LAYER stAte Save with its defaults (2047; bit
/// 512, which no property toggles, is always set).
pub const ALL: u32 = 2047;
/// A state of every property of `layers`, with `current` the layer restoring makes current.
pub fn new(name: impl Into<String>, layers: Vec<Layer>, current: impl Into<String>) -> Self {
LayerState { name: name.into(), layers, current: current.into(), ..LayerState::default() }
}
}
/// A named group of entities (GROUP).
+2
View File
@@ -22,6 +22,7 @@ pub(crate) mod groups;
pub(crate) mod hatch;
mod image;
mod inquiry;
pub mod interface;
mod layer;
mod layout;
mod lisp;
@@ -212,6 +213,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(inquiry::specs());
v.extend(settings::specs());
v.extend(options::specs());
v.extend(interface::specs());
v.extend(utility::specs());
v.extend(table::specs());
v.extend(tolerance::specs());
+12 -72
View File
@@ -27,10 +27,6 @@ mod edit;
/// Most preview entities drawn while the array is edited.
const PREVIEW_LIMIT: usize = 2000;
/// Most objects whose key points are searched for a Key point base point.
const MAX_KEY_OBJECTS: usize = 10_000;
/// The prompt after the Key point option of a base point.
const KEY_POINT_PROMPT: &str = "Specify key point on source objects to use as base point";
/// Keyword-only prompts: each typed token is matched on its own (no free text).
const KEYWORDS: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
@@ -45,13 +41,13 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("arrayrect", "Rectangular Array", run_arrayrect)
.menu(&["Modify", "Array", "Rectangular Array"])
.params(
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
"{handles?, rows, cols, rowSpacing, colSpacing, levels? (1), levelSpacing?, rowElevation?, axisAngle? (degrees), base? ([x, y], default the objects' centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
)
.interactive(|_| Ok(Box::new(RectM::default()))),
CommandSpec::new("arraypolar", "Polar Array", run_arraypolar)
.menu(&["Modify", "Array", "Polar Array"])
.params(
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), keyPoint? ([x, y]: the base point is the objects' key point nearest it), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
"{handles?, center, count, angle? (degrees, default 360), rotate?: bool, rows? (1), rowSpacing?, rowElevation?, levels? (1), levelSpacing?, base? ([x, y], default the first object's centre), associative?: bool (default ARRAYASSOCIATIVITY, on)} → {handle (the array, when associative), created (copies)}",
)
.interactive(|_| Ok(Box::new(PolarM::default()))),
CommandSpec::new("-array", "Array", classic::run_classic)
@@ -250,45 +246,6 @@ fn bounds(d: &Drawing, hs: &[Handle]) -> Bounds2 {
hs.iter().filter_map(|h| d.entity(*h).map(|e| cadcraft_doc::entity_bounds(d, e, 0))).fold(Bounds2::EMPTY, |a, b| a.union(&b))
}
/// The key point of `ents`, placed by `m`, nearest `at`: one of their grips (end points,
/// midpoints, centres, vertices, insertion points). `None` when they have none. More than
/// [`MAX_KEY_OBJECTS`] objects are refused: searching only some could miss the nearest one.
pub(crate) fn nearest_key_point<'a>(ents: impl Iterator<Item = &'a Entity>, m: &Mat3, at: Vec2) -> Result<Option<Vec2>> {
if !at.is_finite() {
return Ok(None);
}
let mut best: Option<(Vec2, f64)> = None;
for (n, e) in ents.enumerate() {
if n >= MAX_KEY_OBJECTS {
return Err(other(format!("Too many objects to search for a key point (at most {MAX_KEY_OBJECTS}); specify a point.")));
}
let mut k = e.kind.clone();
k.transform(m);
for g in k.grips().into_iter().filter(|g| g.is_finite()) {
let d = g.dist(at);
if best.is_none_or(|(_, bd)| d < bd) {
best = Some((g, d));
}
}
}
Ok(best.map(|b| b.0))
}
/// `keyPoint` of a JSON form: absent or null is none; anything else must be a point, rather than
/// be taken as none and the base point found another way.
pub(crate) fn key_point_param(cmd: &str, p: &Value) -> Result<Option<Vec2>> {
match p.get("keyPoint") {
None | Some(Value::Null) => Ok(None),
Some(_) => point_param(p, "keyPoint").map(Some).ok_or_else(|| bad(cmd, "`keyPoint` must be a point [x, y]")),
}
}
/// The key point of objects `hs` in the drawing nearest `at`.
pub(crate) fn key_point_of(d: &Drawing, hs: &[Handle], at: Vec2) -> Result<Vec2> {
nearest_key_point(hs.iter().filter_map(|h| d.entity(*h)).map(|e| &**e), &Mat3::IDENTITY, at)?
.ok_or_else(|| other("The objects have no key point; specify a point."))
}
/// The centre of the first object (the point a non-rotated polar copy is moved by).
fn first_center(d: &Drawing, hs: &[Handle]) -> Option<Vec2> {
hs.first().and_then(|h| d.entity(*h)).map(|e| cadcraft_doc::entity_bounds(d, e, 0).center()).filter(|c| c.is_finite())
@@ -429,10 +386,9 @@ fn run_arrayrect(s: &mut Session, p: &Value) -> Result<Value> {
row_elevation: f64_or(p, "rowElevation", 0.0),
});
let rs = f64_or(p, "rowSpacing", 1.0);
let base = match (key_point_param("arrayrect", p)?, point_param(p, "base")) {
(Some(k), _) => key_point_of(s.doc()?, &hs, k)?,
(None, Some(b)) => b,
(None, None) => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
let base = match point_param(p, "base") {
Some(b) => b,
None => Some(bounds(s.doc()?, &hs).center()).filter(|c| c.is_finite()).unwrap_or_default(),
};
let p2 = params(kind, levels, f64_or(p, "levelSpacing", rs));
let associative = bool_or(p, "associative", assoc_default(s));
@@ -446,10 +402,7 @@ fn run_arraypolar(s: &mut Session, p: &Value) -> Result<Value> {
let rows = count_or("arraypolar", p, "rows", 1)?;
let levels = count_or("arraypolar", p, "levels", 1)?;
check_size(s, n.saturating_mul(rows).saturating_mul(levels), hs.len())?;
let base = match key_point_param("arraypolar", p)? {
Some(k) => key_point_of(s.doc()?, &hs, k)?,
None => point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c),
};
let base = point_param(p, "base").or_else(|| s.doc().ok().and_then(|d| first_center(d, &hs))).unwrap_or(c);
let row_spacing = f64_or(p, "rowSpacing", 1.0);
let fill = f64_or(p, "angle", 360.0);
if !(fill.abs() >= 1e-9 && fill.abs() <= 360.0 + 1e-9) {
@@ -550,8 +503,6 @@ enum RStage {
Main,
Assoc,
Base,
/// Base point: Key point (a grip of the source objects).
BaseKey,
/// COUnt: columns, then rows.
CountCols,
CountRows,
@@ -712,7 +663,6 @@ impl Interactive for RectM {
.default("eXit"),
Assoc => assoc_prompt(self.assoc),
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
CountCols | ColsCount => cols(),
CountRows | RowsCount => rows(),
SpaceCols => dist("Specify the distance between columns", self.cs).kw(&["Unit cell"]),
@@ -762,12 +712,10 @@ impl Interactive for RectM {
self.base = self.centroid;
Main
}
(Base, Input::Keyword(_)) => BaseKey,
(BaseKey, Input::Point(p)) => {
self.base = key_point_of(s.doc()?, &self.objs, *p)?;
Main
(Base, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
Base
}
(BaseKey, Input::Enter) => Base,
(CountCols | ColsCount, _) => match count(&i, self.cols, max_count(s, self.rows.saturating_mul(self.levels), n))? {
Some(c) => {
self.cols = c;
@@ -910,9 +858,6 @@ enum PStage {
Main,
Assoc,
Base,
/// Key point of the base point asked from the center prompt, or from the main prompt.
CenterBaseKey,
BaseKey,
Items,
Between,
Fill,
@@ -1089,7 +1034,6 @@ impl Interactive for PolarM {
match self.stage {
Center => Prompt::new("Specify center point of array", Accept::POINT).kw(&["Base point", "Axis of rotation"]),
CenterBase | Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
CenterBaseKey | BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
Main => Prompt::new("Select grip to edit array", Accept::POINT)
.kw(&["ASsociative", "Base point", "Items", "Angle between", "Fill angle", "ROWs", "Levels", "ROTate items", "eXit"])
.default("eXit"),
@@ -1148,14 +1092,10 @@ impl Interactive for PolarM {
self.base = None;
if stage == CenterBase { Center } else { Main }
}
(CenterBase, Input::Keyword(_)) => CenterBaseKey,
(Base, Input::Keyword(_)) => BaseKey,
(CenterBaseKey | BaseKey, Input::Point(p)) => {
self.base = Some(key_point_of(s.doc()?, &self.objs, *p)?);
if stage == CenterBaseKey { Center } else { Main }
(CenterBase | Base, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
stage
}
(CenterBaseKey, Input::Enter) => CenterBase,
(BaseKey, Input::Enter) => Base,
(Items, _) => match count(&i, self.items, max_count(s, self.rows.saturating_mul(self.levels), n))? {
Some(c) => {
self.items = c;
+10 -49
View File
@@ -18,9 +18,7 @@ use super::super::helpers::v3;
use super::super::machines::{SelOutcome, SelectPhase, number};
use super::super::{CommandSpec, bad, bool_or, point_param, targets};
use super::{
KEY_POINT_PROMPT, KEYWORDS, angle, check_size, count, fmt, key_point_of, key_point_param, nearest_key_point, nesting, other, yes, yes_no,
};
use super::{KEYWORDS, angle, check_size, count, fmt, nesting, other, yes, yes_no};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
pub(super) fn specs() -> Vec<CommandSpec> {
@@ -28,7 +26,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
CommandSpec::new("arrayedit", "Edit Array", run_arrayedit)
.menu(&["Modify", "Object", "Array"])
.params(
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, keyPoint? ([x, y]: the new base point is the source objects' key point nearest it, on the item there), replace?.keyPoint? ([x, y]: the replacement objects' key point nearest it is their base point), source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
"{handle, cols?, rows?, colSpacing?, rowSpacing?, axisAngle? (degrees), rowElevation?, levels?, levelSpacing?, items?, angle? (fill, degrees), angleBetween?, rotate?: bool, center? ([x, y]), base? ([x, y], the new base point), reset?: bool, replace?: {handles, base? ([x, y], default the objects' centre), items: [[i, j, level]…] | \"source\"}, source?: {item? ([i, j, level], default [0, 0, 0])} (places the source objects for editing; ARRAYCLOSE ends)}",
)
.interactive(|_| Ok(Box::new(EditM::default()))),
CommandSpec::new("arrayclose", "Close Array Editing", run_arrayclose)
@@ -217,16 +215,6 @@ fn item_at(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Option<(u32, u32, u32)
best.map(|b| b.0)
}
/// ARRAYEDIT Key point: the key point of the source objects nearest `at`, with the objects as
/// placed at the item under `at` (within `tol`).
fn source_key_point(d: &Drawing, h: Handle, at: Vec2, tol: f64) -> Result<Vec2> {
let item = item_at(d, h, at, tol).ok_or_else(|| other("No array item there; specify a point on an item of the array."))?;
let (ins, blk, p) = array_of(d, h)?;
let src = d.block(&p.source).ok_or_else(|| other("The array's source block is missing."))?;
let m = ins.transform(blk.base.xy()).then_before(item_place(&p, item)?).then_before(Mat3::translate(-src.base.xy()));
nearest_key_point(src.entities.iter().map(|e| e.as_ref()), &m, at)?.ok_or_else(|| other("The source objects have no key point; specify a point."))
}
/// Move the base point of array `h` to world point `base` without moving the items.
fn rebase(s: &mut Session, h: Handle, base: Vec2) -> Result<()> {
let d = s.doc()?;
@@ -355,9 +343,6 @@ fn close_source(s: &mut Session, save: bool) -> Result<Value> {
// ---------------- JSON ----------------
/// How far outside an item's extents a JSON `keyPoint` may be.
const KEY_POINT_TOLERANCE: f64 = 1e-6;
fn item_param(v: &Value) -> Option<(u32, u32, u32)> {
let a = v.as_array()?;
let n = |k: usize| a.get(k).and_then(Value::as_u64).and_then(|x| u32::try_from(x).ok());
@@ -464,7 +449,9 @@ fn fill_from_between(b: f64, items: u32) -> Result<f64> {
fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
let h = super::super::curves::handle_param(p, "handle").ok_or_else(|| bad("arrayedit", "`handle` (the array) is required"))?;
refuse_while_editing(s)?;
array_of(s.doc()?, h)?;
let (ins, blk, _) = array_of(s.doc()?, h)?;
let w = ins.transform(blk.base.xy());
let to_local = w.inverse().ok_or_else(|| other("The array's scale is zero."))?;
if bool_or(p, "reset", false) {
let (_, _, mut a) = array_of(s.doc()?, h)?;
a.replaced.clear();
@@ -472,10 +459,7 @@ fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
}
if let Some(r) = p.get("replace").filter(|v| !v.is_null()) {
let hs = targets(s, r)?;
let base = match key_point_param("arrayedit", r)? {
Some(k) => key_point_of(s.doc()?, &hs, k)?,
None => point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default()),
};
let base = point_param(r, "base").unwrap_or_else(|| s.doc().map(|d| centroid(d, &hs)).unwrap_or_default());
let name = block_from(s, h, &hs, base)?;
let (_, _, mut a) = array_of(s.doc()?, h)?;
match r.get("items") {
@@ -493,13 +477,7 @@ fn run_arrayedit(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(b) = point_param(p, "base") {
rebase(s, h, b)?;
}
if let Some(k) = key_point_param("arrayedit", p)? {
let at = source_key_point(s.doc()?, h, k, KEY_POINT_TOLERANCE)?;
rebase(s, h, at)?;
}
// A new base point moves the array's insertion point: read `center` in its placement after.
let (ins, blk, mut a) = array_of(s.doc()?, h)?;
let to_local = ins.transform(blk.base.xy()).inverse().ok_or_else(|| other("The array's scale is zero."))?;
let (_, _, mut a) = array_of(s.doc()?, h)?;
let before = a.clone();
apply_params(&mut a, p, &to_local)?;
if a != before {
@@ -529,8 +507,6 @@ enum Stage {
Select,
Main,
Base,
/// Base point: Key point (of the source objects).
BaseKey,
ColsCount,
ColsSpace,
ColsTotal,
@@ -548,8 +524,6 @@ enum Stage {
/// REPlace: objects, their base point, then the items to replace.
RepSelect,
RepBase,
/// REPlace base point: Key point (of the replacement objects).
RepKey,
RepItems,
/// Source: the item whose objects are placed for editing.
SourceItem,
@@ -685,7 +659,6 @@ impl Interactive for EditM {
.kw(&["Source", "REPlace", "Base point", "Rows", "Columns", "Levels", "RESet", "eXit"])
.default("eXit"),
Base => Prompt::new("Specify base point", Accept::POINT).kw(&["Key point"]).default("centroid"),
BaseKey => Prompt::new(KEY_POINT_PROMPT, Accept::POINT),
ColsCount => Prompt::new("Enter the number of columns", Accept::NUMBER).default(cols.to_string()),
ColsSpace => dist("Specify the distance between columns", cs).kw(&["Total"]),
ColsTotal => dist("Specify the distance between the first and last column", total(cols, cs)),
@@ -714,7 +687,6 @@ impl Interactive for EditM {
Rotate => Prompt::new("Rotate arrayed items?", KEYWORDS).kw(&["Yes", "No"]).default(yes(polar.as_ref().is_none_or(|k| k.rotate))),
RepSelect => Prompt::new("Select replacement objects", Accept::SELECT),
RepBase => Prompt::new("Select base point of replacement objects", Accept::POINT).kw(&["Key point"]).default("centroid"),
RepKey => Prompt::new("Specify key point on replacement objects to use as base point", Accept::POINT),
RepItems => Prompt::new("Select an item in array to replace", Accept::POINT).kw(&["Source objects"]),
SourceItem => Prompt::new("Select item in array", Accept::POINT),
}
@@ -774,21 +746,10 @@ impl Interactive for EditM {
}
Main
}
(Base, Input::Keyword(_)) => BaseKey,
(RepBase, Input::Keyword(_)) => RepKey,
(BaseKey, Input::Point(p)) => {
let tol = s.pixel_size() * s.settings.pickbox;
let at = source_key_point(s.doc()?, h, *p, tol)?;
rebase(s, h, at)?;
Main
(Base | RepBase, Input::Keyword(_)) => {
s.echo("Key points are not available yet; specify a point.");
stage
}
(BaseKey, Input::Enter) => Base,
(RepKey, Input::Point(p)) => {
let base = key_point_of(s.doc()?, &self.rep_objs, *p)?;
self.rep_block = Some(block_from(s, h, &self.rep_objs.clone(), base)?);
RepItems
}
(RepKey, Input::Enter) => RepBase,
(ColsCount | Items, _) => match count(&i, c64, self.max_for(s, r64.saturating_mul(l64)))? {
Some(n) => {
let n = super::count32(n);
+6 -164
View File
@@ -4,7 +4,6 @@
use cadcraft_doc::color::Color;
use cadcraft_doc::{AttribProps, Common, EntityKind, HAlign, Handle, Text, VAlign};
use cadcraft_geom::Vec3;
use serde_json::{Map, Value, json};
use crate::cmd::curves::KW;
@@ -154,19 +153,6 @@ fn set_value(text: &mut Text, value: String) {
}
}
/// Move `text` so the point it is placed by lands on `to`: the alignment point of justified text,
/// else the insertion point. Both points move by the same offset, so aligned and fit text keep the
/// baseline between them.
fn move_text(text: &mut Text, to: cadcraft_geom::Vec2) {
let anchor = match text.align_pt {
Some(ap) if !matches!((text.halign, text.valign), (HAlign::Left, VAlign::Baseline) | (HAlign::Aligned | HAlign::Fit, _)) => ap,
_ => text.insert,
};
let d = Vec3::new(to.x - anchor.x, to.y - anchor.y, 0.0);
text.insert = text.insert + d;
text.align_pt = text.align_pt.map(|ap| ap + d);
}
/// Change the properties set on attribute `k` of block reference `h`.
fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut AttribProps)) -> Result<()> {
s.doc_mut()?.modify_entity(h, |e| {
@@ -179,18 +165,6 @@ fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut Attri
Ok(())
}
/// Modify the attribute `k` of block reference `h`.
fn modify_attrib(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut cadcraft_doc::Attrib)) -> Result<()> {
s.doc_mut()?.modify_entity(h, |e| {
if let EntityKind::Insert(ins) = &mut e.kind
&& let Some(a) = ins.attribs.get_mut(k)
{
f(a);
}
})?;
Ok(())
}
/// The layer and colour attribute `k` of block reference `h` is drawn with: its own, else its
/// definition's (layer 0 is the reference's layer).
fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)> {
@@ -206,14 +180,6 @@ fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)
Some((layer, c.color))
}
/// The current text properties of attribute `k` of block reference `h`.
fn current_text(s: &Session, (h, k): (Handle, usize)) -> Option<cadcraft_doc::Text> {
let d = s.doc().ok()?;
let e = d.entity(h)?;
let EntityKind::Insert(ins) = &e.kind else { return None };
ins.attribs.get(k).map(|a| a.text.clone())
}
/// Replace every `find` in `value` with `with`, unless the result would be too long.
fn replaced(value: &str, find: &str, with: &str) -> Option<String> {
if find.is_empty() || !value.contains(find) {
@@ -326,10 +292,6 @@ enum Stage {
Select,
/// One at a time: what to do with the current attribute.
Option,
Position,
Height,
Angle,
Style,
ValueKind,
NewValue,
Layer,
@@ -403,7 +365,6 @@ impl Interactive for DashAtteditM {
}
fn prompt(&self, s: &Session) -> Prompt {
let cur = self.items.get(self.cur).and_then(|it| current_props(s, *it));
let cur_text = self.items.get(self.cur).and_then(|it| current_text(s, *it));
match self.stage {
Stage::OneAtATime => Prompt::new("Edit attributes one at a time?", KW).kw(&["Yes", "No"]).default("Y"),
Stage::VisibleOnly => Prompt::new("Edit only attributes visible on screen?", KW).kw(&["Yes", "No"]).default("Y"),
@@ -411,31 +372,7 @@ impl Interactive for DashAtteditM {
Stage::TagSpec => Prompt::new("Enter attribute tag specification", Accept::TEXT).default("*"),
Stage::ValueSpec => Prompt::new("Enter attribute value specification", Accept::TEXT).default("*"),
Stage::Select => Prompt::new("Select attributes", Accept::SELECT),
Stage::Option => {
Prompt::new("Enter an option", KW).kw(&["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"]).default("N")
}
Stage::Position => Prompt::new("Enter new text insertion point", Accept::POINT),
Stage::Height => {
let p = Prompt::new("Enter new text height", Accept::POINT_OR_NUMBER);
match cur_text {
Some(t) => p.default(format!("{:.4}", t.height)),
None => p,
}
}
Stage::Angle => {
let p = Prompt::new("Enter new text rotation angle", Accept::POINT_OR_NUMBER);
match cur_text {
Some(t) => p.default(format!("{:.4}", t.rotation.to_degrees())),
None => p,
}
}
Stage::Style => {
let p = Prompt::new("Enter new text style", Accept::TEXT);
match cur_text {
Some(t) => p.default(t.style),
None => p,
}
}
Stage::Option => Prompt::new("Enter an option", KW).kw(&["Value", "Layer", "Color", "Next"]).default("N"),
Stage::ValueKind => Prompt::new("Enter type of value modification", KW).kw(&["Change", "Replace"]).default("R"),
Stage::NewValue => Prompt::new("Enter new attribute value", Accept::TEXT),
Stage::Layer => {
@@ -509,10 +446,6 @@ impl Interactive for DashAtteditM {
}
Stage::Option => match &i {
Input::Keyword(k) if k == "Value" => self.stage = Stage::ValueKind,
Input::Keyword(k) if k == "Position" => self.stage = Stage::Position,
Input::Keyword(k) if k == "Height" => self.stage = Stage::Height,
Input::Keyword(k) if k == "Angle" => self.stage = Stage::Angle,
Input::Keyword(k) if k == "Style" => self.stage = Stage::Style,
Input::Keyword(k) if k == "Layer" => self.stage = Stage::Layer,
Input::Keyword(k) if k == "Color" => self.stage = Stage::Color,
Input::Keyword(_) | Input::Enter => {
@@ -524,105 +457,14 @@ impl Interactive for DashAtteditM {
}
Input::Text(t) => {
let tl = t.trim().to_ascii_lowercase();
let opts = ["Value", "Position", "Height", "Angle", "Style", "Layer", "Color", "Next"];
match opts.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
Some(&"Value") => self.stage = Stage::ValueKind,
Some(&"Position") => self.stage = Stage::Position,
Some(&"Height") => self.stage = Stage::Height,
Some(&"Angle") => self.stage = Stage::Angle,
Some(&"Style") => self.stage = Stage::Style,
Some(&"Layer") => self.stage = Stage::Layer,
Some(&"Color") => self.stage = Stage::Color,
Some(&"Next") => {
self.cur += 1;
if self.cur >= self.items.len() {
return Ok(Step::Done);
}
self.show_current(s);
}
_ => return Err(invalid_keyword()),
}
let later = ["Position", "Height", "Angle", "Style"];
return match later.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
Some(k) => Err(EngineError::Other(format!("{k} is not available yet."))),
None => Err(invalid_keyword()),
};
}
_ => {}
},
Stage::Position => {
let p = match i {
Input::Point(p) => p,
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| move_text(&mut a.text, p))?;
}
self.stage = Stage::Option;
}
Stage::Height => {
let h = match &i {
Input::Point(p) => {
let cur_pt = self.items.get(self.cur).and_then(|it| current_text(s, *it)).map(|t| t.insert.xy());
match cur_pt {
Some(base) => base.dist(*p).max(1e-9),
None => p.len().max(1e-9),
}
}
Input::Text(t) if !t.trim().is_empty() => crate::units::parse_distance(t.trim())
.filter(|v| *v > 0.0)
.ok_or_else(|| EngineError::Other("Requires a positive number.".into()))?,
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.height = h;
})?;
}
self.stage = Stage::Option;
}
Stage::Angle => {
let ang = match &i {
Input::Point(p) => {
let cur_pt = self.items.get(self.cur).and_then(|it| current_text(s, *it)).map(|t| t.insert.xy());
match cur_pt {
Some(base) => base.angle_to(*p),
None => p.y.atan2(p.x),
}
}
Input::Text(t) if !t.trim().is_empty() => {
s.angle_settings().direction(t.trim()).ok_or_else(|| EngineError::Other("Requires an angle.".into()))?
}
Input::Enter => {
self.stage = Stage::Option;
return Ok(Step::Continue);
}
_ => return Ok(Step::Continue),
};
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.rotation = ang;
})?;
}
self.stage = Stage::Option;
}
Stage::Style => {
let Some(t) = text else { return Ok(Step::Continue) };
let t = t.trim();
if !t.is_empty() {
let st =
s.doc()?.text_style(t).map(|st| st.name.clone()).ok_or_else(|| EngineError::Other(format!("Cannot find style \"{t}\".")))?;
if let Some(it) = self.items.get(self.cur).copied() {
modify_attrib(s, it, |a| {
a.text.style = st;
})?;
}
}
self.stage = Stage::Option;
}
Stage::ValueKind => match &i {
Input::Keyword(k) if k == "Change" => self.stage = Stage::Find,
Input::Keyword(_) | Input::Enter => self.stage = Stage::NewValue,
+134
View File
@@ -0,0 +1,134 @@
//! MENUBAR and TOOLBAR: show or hide the window's menu bar and tool bar from the command line, as
//! in AutoCAD. With the menu bar hidden on Windows and Linux (where it is the only menu), typing
//! these is the way back.
//!
//! The UI owns the bars: it reports what it shows in [`Session::bars_shown`] and applies
//! [`Session::bars_request`], which these commands set.
use serde_json::{Value, json};
use super::{CommandSpec, always, bad};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
/// The interface bars MENUBAR and TOOLBAR control.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct InterfaceBars {
pub menubar: bool,
pub toolbar: bool,
}
impl Default for InterfaceBars {
fn default() -> Self {
InterfaceBars { menubar: true, toolbar: true }
}
}
/// A change MENUBAR or TOOLBAR asked for: only the bars a command set, so the UI leaves the other
/// as it is (it may have been changed since).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct BarsRequest {
pub menubar: Option<bool>,
pub toolbar: Option<bool>,
}
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("menubar", "Menu Bar", run_menubar)
.params("{value?: 0|1} (1 shows the in-window menu bar, 0 hides it; without it, reports it)")
.enabled(always)
.noundo()
.interactive(|s| Ok(Box::new(MenubarM { current: s.bars_shown.menubar }))),
CommandSpec::new("toolbar", "Tool Bar", run_toolbar)
.alias(&["-toolbar"])
.params("{show?: bool} (without it, reports it)")
.enabled(always)
.noundo()
.interactive(|_| Ok(Box::new(ToolbarM))),
]
}
fn set_menubar(s: &mut Session, on: bool) {
s.bars_shown.menubar = on;
s.bars_request.menubar = Some(on);
}
fn set_toolbar(s: &mut Session, show: bool) {
s.bars_shown.toolbar = show;
s.bars_request.toolbar = Some(show);
}
fn run_menubar(s: &mut Session, p: &Value) -> Result<Value> {
let v = match p.get("value") {
None | Some(Value::Null) => return Ok(json!({ "value": u8::from(s.bars_shown.menubar) })),
Some(v) => v
.as_u64()
.or_else(|| v.as_str().and_then(|t| t.trim().parse().ok()))
.filter(|v| *v <= 1)
.ok_or_else(|| bad("menubar", "`value` must be 0 or 1"))?,
};
set_menubar(s, v == 1);
Ok(json!({ "value": v }))
}
fn run_toolbar(s: &mut Session, p: &Value) -> Result<Value> {
let Some(show) = p.get("show").filter(|v| !v.is_null()) else { return Ok(json!({ "show": s.bars_shown.toolbar })) };
let show = show.as_bool().ok_or_else(|| bad("toolbar", "`show` must be true or false"))?;
set_toolbar(s, show);
Ok(json!({ "show": show }))
}
/// Typed MENUBAR: "Enter new value for MENUBAR <1>:".
struct MenubarM {
current: bool,
}
impl Interactive for MenubarM {
fn name(&self) -> &'static str {
"MENUBAR"
}
fn prompt(&self, _s: &Session) -> Prompt {
Prompt::new("Enter new value for MENUBAR", Accept::NUMBER).default(u8::from(self.current).to_string())
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match i {
Input::Enter => Ok(Step::Done),
Input::Text(t) => match run_menubar(s, &json!({ "value": t })) {
Ok(_) => Ok(Step::Done),
Err(_) => {
s.echo("Requires 0 or 1.");
Ok(Step::Continue)
}
},
_ => Ok(Step::Continue),
}
}
}
/// Typed TOOLBAR: "Enter tool bar option [Show/Hide] <Show>:" (CADCraft has one tool bar).
struct ToolbarM;
impl Interactive for ToolbarM {
fn name(&self) -> &'static str {
"TOOLBAR"
}
fn prompt(&self, _s: &Session) -> Prompt {
Prompt::new("Enter tool bar option", Accept::TEXT).kw(&["Show", "Hide"]).default("Show")
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let word = match &i {
Input::Enter => "show".to_string(),
Input::Keyword(k) | Input::Text(k) => k.trim().to_ascii_lowercase(),
_ => return Ok(Step::Continue),
};
let show = if !word.is_empty() && "show".starts_with(&word) {
true
} else if !word.is_empty() && "hide".starts_with(&word) {
false
} else {
s.echo("Invalid option keyword.");
return Ok(Step::Continue);
};
run_toolbar(s, &json!({ "show": show }))?;
Ok(Step::Done)
}
}
+16 -246
View File
@@ -1,7 +1,6 @@
//! Layers: LAYER (programmatic sub-ids, -LAYER prompts), layer tools (LAYMCUR, LAYISO, LAYOFF, LAYFRZ…).
mod prompts;
mod state_prompts;
use cadcraft_color::Color;
use cadcraft_doc::{Layer, Lineweight};
@@ -56,9 +55,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("layon", "Turn All Layers On", |s, _| all_layers(s, |l| l.on = true)),
CommandSpec::new("laythw", "Thaw All Layers", |s, _| all_layers(s, |l| l.frozen = false)),
CommandSpec::new("layerp", "Previous Layer", run_layerp).menu(&["Format", "Layer Tools", "Previous Layer"]),
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save)
.menu(&["Format", "Layer States Manager..."])
.params("{name, mask? (properties restoring sets: 1 on, 2 frozen, 4 locked, 8 plot, 16 new viewport freeze, 32 color, 64 linetype, 128 lineweight, 256 plot style, 1024 transparency; default all)}"),
CommandSpec::new("layerstate.save", "Save Layer State", run_state_save).menu(&["Format", "Layer States Manager..."]).params("{name}"),
CommandSpec::new("layerstate.restore", "Restore Layer State", run_state_restore).params("{name}"),
CommandSpec::new("layerstate.list", "List Layer States", run_state_list).params("{} → states").noundo(),
CommandSpec::new("layerstate.delete", "Delete Layer State", run_state_delete).params("{name}"),
@@ -403,108 +400,31 @@ fn all_layers(s: &mut Session, f: fn(&mut Layer)) -> Result<Value> {
}
fn run_state_save(s: &mut Session, p: &Value) -> Result<Value> {
use cadcraft_doc::LayerState as S;
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.save", "`name` is required"))?.to_string();
// As -LAYER stAte Save and layerstate.rename take names: none empty, over 255 characters, with a
// control character or with one AutoCAD 2024 refuses (measured for Save).
if !valid_name(&name) {
return Err(bad("layerstate.save", "invalid name"));
}
// The properties restoring sets; bit 512, which no property toggles, is always set, as AutoCAD
// 2024 saves it (measured: On alone is 513).
let mask = match p.get("mask") {
None | Some(Value::Null) => S::ALL,
Some(v) => {
let m = v.as_u64().filter(|m| m & !u64::from(S::ALL) == 0);
m.and_then(|m| u32::try_from(m).ok()).ok_or_else(|| bad("layerstate.save", "`mask` must be a sum of layer state bits (0 to 2047)"))? | 512
}
};
let d = s.doc_mut()?;
let layers = d.layers.clone();
let current = d.header.str("CLAYER", "0");
// Replace the state Restore and Delete reach (the same spelling, else another case), so a
// drawing keeps one state per name: AutoCAD 2024 finds states without regard to case. Its
// -LAYER stAte Save and layerstate-save refuse `s1` after `S1` (measured), as the command line
// here does; this command replaces, as it does a state of the same spelling. When a file holds
// both `S1` and `s1`, only the one spelled so is replaced.
if let Some(i) = state_index(d, &name) {
d.layer_states.remove(i);
}
d.layer_states.push(S { mask, ..S::new(name, layers, current) });
d.layer_states.retain(|st| st.name != name);
d.layer_states.push(cadcraft_doc::LayerState { name, layers });
ok()
}
/// The saved state called `name`: the one spelled so, else the first whose name differs only in
/// case. AutoCAD 2024 finds layer states without regard to case (measured: Restore, Edit, Name
/// and Delete of `s1` reach `S1`); case is compared as for layers and view snapshots.
pub(super) fn state_index(d: &cadcraft_doc::Drawing, name: &str) -> Option<usize> {
d.layer_states.iter().position(|st| st.name == name).or_else(|| d.layer_states.iter().position(|st| st.name.eq_ignore_ascii_case(name)))
}
fn run_state_restore(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.restore", "`name` is required"))?;
let d = s.doc_mut()?;
let st = state_index(d, name).and_then(|i| d.layer_states.get(i)).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
restore_state(d, &st);
let st = d.layer_states.iter().find(|st| st.name == name).cloned().ok_or_else(|| bad("layerstate.restore", "no such layer state"))?;
restore_layers(d, st.layers);
ok()
}
/// Restore a saved layer state as AutoCAD 2024 does (measured): first the current layer it
/// names, when the drawing has it and the restore doesn't leave it frozen, then on each drawing
/// layer the state names (without regard to case) the properties its mask covers. The current
/// layer is never frozen; other properties (descriptions, names) stay as they are.
pub(crate) fn restore_state(d: &mut cadcraft_doc::Drawing, st: &cadcraft_doc::LayerState) {
use cadcraft_doc::LayerState as S;
// A frozen layer only thaws with Frozen in the mask and an entry of its own: without one
// AutoCAD 2024 keeps the current layer (measured).
let thaws = |l: &Layer| st.mask & S::FROZEN != 0 && st.layers.iter().any(|saved| saved.name.eq_ignore_ascii_case(&l.name));
if let Some(l) = d.layer(&st.current).filter(|l| !l.frozen || thaws(l)) {
let name = l.name.clone();
d.header.set_str("CLAYER", &name);
}
let current = d.header.str("CLAYER", "0");
let index = layer_index(d);
let has = |bit: u32| st.mask & bit != 0;
for saved in &st.layers {
let Some(l) = index.get(&saved.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) else { continue };
if has(S::ON) {
l.on = saved.on;
}
if has(S::FROZEN) {
l.frozen = saved.frozen && !l.name.eq_ignore_ascii_case(&current);
}
if has(S::LOCKED) {
l.locked = saved.locked;
}
if has(S::PLOT) {
l.plot = saved.plot;
}
if has(S::VP_FREEZE_NEW) {
l.vp_freeze_new = saved.vp_freeze_new;
}
if has(S::COLOR) {
l.color = saved.color;
}
if has(S::LINETYPE) {
l.linetype.clone_from(&saved.linetype);
}
if has(S::LINEWEIGHT) {
l.lineweight = saved.lineweight;
}
if has(S::PLOT_STYLE) {
l.plot_style.clone_from(&saved.plot_style);
}
if has(S::TRANSPARENCY) {
l.transparency = saved.transparency;
}
}
}
/// Put the saved layers back over the drawing's layers of the same name (without regard to case);
/// saved layers the drawing no longer has are skipped. Both lists can come from a file, so the
/// drawing's layers are looked up in an index rather than scanned per saved layer.
pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
let index = layer_index(d);
let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::with_capacity(d.layers.len());
for (i, l) in d.layers.iter().enumerate() {
// The first of names that differ only in case, as `Drawing::layer_mut` finds it.
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
}
for layer in saved {
if let Some(l) = index.get(&layer.name.to_ascii_lowercase()).and_then(|&i| d.layers.get_mut(i)) {
*l = layer;
@@ -512,16 +432,6 @@ pub(crate) fn restore_layers(d: &mut cadcraft_doc::Drawing, saved: Vec<Layer>) {
}
}
/// The drawing's layers by lower-case name: the first of names that differ only in case, as
/// `Drawing::layer_mut` finds it.
fn layer_index(d: &cadcraft_doc::Drawing) -> std::collections::HashMap<String, usize> {
let mut index = std::collections::HashMap::with_capacity(d.layers.len());
for (i, l) in d.layers.iter().enumerate() {
index.entry(l.name.to_ascii_lowercase()).or_insert(i);
}
index
}
fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
let d = s.doc()?;
let states: Vec<Value> = d.layer_states.iter().map(|st| json!({ "name": st.name, "layers": st.layers.len() })).collect();
@@ -536,8 +446,10 @@ fn run_state_list(s: &mut Session, _p: &Value) -> Result<Value> {
fn run_state_delete(s: &mut Session, p: &Value) -> Result<Value> {
let name = str_param(p, "name").ok_or_else(|| bad("layerstate.delete", "`name` is required"))?;
let d = s.doc_mut()?;
let i = state_index(d, name).ok_or_else(|| bad("layerstate.delete", "no such layer state"))?;
d.layer_states.remove(i);
if !d.layer_states.iter().any(|st| st.name == name) {
return Err(bad("layerstate.delete", "no such layer state"));
}
d.layer_states.retain(|st| st.name != name);
ok()
}
@@ -548,12 +460,10 @@ fn run_state_rename(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad("layerstate.rename", "invalid name"));
}
let d = s.doc_mut()?;
// A name in another case counts, the state's own too (AutoCAD 2024 refuses `S1` to `s1`,
// measured).
if d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(&to)) {
if d.layer_states.iter().any(|st| st.name == to) {
return Err(bad("layerstate.rename", format!("layer state `{to}` already exists")));
}
let st = state_index(d, from).and_then(|i| d.layer_states.get_mut(i)).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
let st = d.layer_states.iter_mut().find(|st| st.name == from).ok_or_else(|| bad("layerstate.rename", "no such layer state"))?;
st.name = to;
ok()
}
@@ -606,146 +516,6 @@ mod tests {
assert!(used.contains(&true) && used.contains(&false));
}
/// Restoring follows AutoCAD 2024 (measured with -LAYER stAte and states written into a DXF):
/// the current layer first, then only the properties the mask covers; the current layer stays
/// thawed; a current layer that is empty or gone leaves the current layer as it is.
#[test]
fn layer_state_restore_follows_the_mask_and_current_layer() {
use cadcraft_color::Color;
use cadcraft_doc::LayerState;
let mut s = Session::new();
s.execute("layer.new", &json!({ "name": "A", "color": 1, "current": true })).unwrap();
s.execute("layer.new", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
let saved = s.doc().unwrap().layer_states[0].clone();
assert_eq!((saved.mask, saved.current.as_str()), (LayerState::ALL, "A"));
// Only On: A's colour stays green, B comes back on (AutoCAD's S7, mask 513).
let d = s.doc_mut().unwrap();
d.layer_states.push(LayerState { name: "on".into(), mask: LayerState::ON | 512, ..saved.clone() });
s.execute("layer.set", &json!({ "name": "A", "color": 3 })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "on": false, "locked": true })).unwrap();
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "on" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
let (a, b) = (d.layer("A").unwrap(), d.layer("B").unwrap());
assert_eq!((a.color, b.on, b.locked), (Color::Index(3), true, true));
// Every property.
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.layer("B").unwrap().locked), (Color::Index(1), false));
// A state that freezes B with no current layer of its own (or one that is gone), restored
// with B current: B stays current and thawed; A is turned off.
for current in ["", "NOSUCH"] {
let mut frozen = s.doc().unwrap().layers.clone();
for l in &mut frozen {
l.frozen = l.name == "B";
l.on = l.name != "A";
}
s.doc_mut().unwrap().layer_states.push(LayerState::new(format!("f{current}"), frozen.clone(), current));
s.execute("layer.current", &json!({ "name": "B" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": format!("f{current}") })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B", "{current:?}");
assert!(!d.layer("B").unwrap().frozen && !d.layer("A").unwrap().on, "{current:?}");
// Naming A current, it becomes current and B freezes.
s.doc_mut().unwrap().layer_states.push(LayerState::new("fA", frozen, "A"));
s.execute("layerstate.restore", &json!({ "name": "fA" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
s.doc_mut().unwrap().layer_states.retain(|st| st.name != "fA");
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
}
// A current layer the state's mask leaves frozen doesn't become current (AutoCAD's S9: On
// only, current B; restored with A current and B frozen).
let mut on_only = s.doc().unwrap().layer_states[0].clone();
(on_only.name, on_only.mask, on_only.current) = ("S9".into(), LayerState::ON | 512, "B".into());
s.doc_mut().unwrap().layer_states.push(on_only);
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "S9" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
// With Frozen in the mask B is thawed and made current.
let mut thaw = s.doc().unwrap().layer_states[0].clone();
(thaw.name, thaw.current) = ("thaw".into(), "B".into());
s.doc_mut().unwrap().layer_states.push(thaw);
s.execute("layerstate.restore", &json!({ "name": "thaw" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B");
assert!(!d.layer("B").unwrap().frozen);
// Frozen in the mask, but no entry for B (a state written elsewhere): nothing would thaw
// B, so A stays current and B frozen (AutoCAD 2024, measured).
let mut no_entry = s.doc().unwrap().layer_states[0].clone();
(no_entry.name, no_entry.current) = ("no entry".into(), "B".into());
no_entry.layers.retain(|l| l.name != "B");
s.doc_mut().unwrap().layer_states.push(no_entry);
s.execute("layer.current", &json!({ "name": "A" })).unwrap();
s.execute("layer.set", &json!({ "name": "B", "frozen": true })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "no entry" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "A");
assert!(d.layer("B").unwrap().frozen);
// An entry spelled in another case is B's (layer names ignore case, as the restore of the
// properties does): B is thawed and made current.
let mut other_case = s.doc().unwrap().layer_states[0].clone();
(other_case.name, other_case.current) = ("other case".into(), "B".into());
for l in other_case.layers.iter_mut().filter(|l| l.name == "B") {
l.name = "b".into();
}
s.doc_mut().unwrap().layer_states.push(other_case);
s.execute("layerstate.restore", &json!({ "name": "other case" })).unwrap();
let d = s.doc().unwrap();
assert_eq!(d.header.str("CLAYER", ""), "B");
assert!(!d.layer("B").unwrap().frozen);
// What a state doesn't hold stays: the description.
s.execute("layer.set", &json!({ "name": "A", "description": "kept" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "all" })).unwrap();
assert_eq!(s.doc().unwrap().layer("A").unwrap().description, "kept");
}
/// Plotting, freezing in new viewports, linetype, lineweight, plot style and transparency each
/// come back under their own mask bit only: a state of one bit restores that property and
/// leaves the other five as they are.
#[test]
fn layer_state_restores_each_property_under_its_own_bit_only() {
use cadcraft_doc::{Drawing, LayerState as S, Lineweight};
let mut s = Session::new();
s.execute("layer.new", &json!({ "name": "A" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "all" })).unwrap();
let saved = s.doc().unwrap().layer_states[0].clone();
let props = |d: &Drawing| {
let l = d.layer("A").unwrap();
(l.plot, l.vp_freeze_new, l.linetype.clone(), l.lineweight, l.plot_style.clone(), l.transparency)
};
let change = |d: &mut Drawing| {
let l = d.layer_mut("A").unwrap();
(l.plot, l.vp_freeze_new, l.linetype, l.lineweight, l.plot_style, l.transparency) =
(false, true, "DASHED".into(), Lineweight::from_dxf(50), "Thick".into(), 40);
};
let before = props(s.doc().unwrap());
change(s.doc_mut().unwrap());
let after = props(s.doc().unwrap());
for bit in [S::PLOT, S::VP_FREEZE_NEW, S::LINETYPE, S::LINEWEIGHT, S::PLOT_STYLE, S::TRANSPARENCY] {
let name = format!("b{bit}");
s.doc_mut().unwrap().layer_states.push(S { name: name.clone(), mask: bit | 512, ..saved.clone() });
change(s.doc_mut().unwrap());
s.execute("layerstate.restore", &json!({ "name": name })).unwrap();
let mut want = after.clone();
match bit {
S::PLOT => want.0 = before.0,
S::VP_FREEZE_NEW => want.1 = before.1,
S::LINETYPE => want.2.clone_from(&before.2),
S::LINEWEIGHT => want.3 = before.3,
S::PLOT_STYLE => want.4.clone_from(&before.4),
_ => want.5 = before.5,
}
assert_eq!(props(s.doc().unwrap()), want, "mask {bit}");
}
}
#[test]
fn rejected_layer_set_changes_nothing() {
let mut s = Session::new();
+7 -20
View File
@@ -8,7 +8,6 @@ use serde_json::{Value, json};
use super::super::find_command;
use super::super::qselect::wildcard;
use super::state_prompts;
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
const OPTIONS: &[&str] = &[
@@ -35,9 +34,9 @@ const OPTIONS: &[&str] = &[
];
/// Keyword-only: spaces separate inputs.
pub(super) const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
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.
pub(super) const NAME: Accept = Accept { number: true, ..Accept::TEXT };
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
/// A per-layer change applied to a list of layer names.
#[derive(Clone, Debug)]
@@ -112,8 +111,6 @@ enum Stage {
Layers(Change),
/// Turning the current layer off asks first.
ConfirmOff(Vec<String>),
/// stAte and its options.
State(state_prompts::Stage),
}
#[derive(Default)]
@@ -126,19 +123,19 @@ fn current_layer(s: &Session) -> String {
}
/// Run a layer command's body directly: the running command records the single undo step.
pub(super) fn call(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
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)
}
pub(super) fn message(e: &EngineError) -> String {
fn message(e: &EngineError) -> String {
match e {
EngineError::BadParams { msg, .. } => msg.clone(),
other => other.to_string(),
}
}
pub(super) fn retry(msg: impl Into<String>) -> EngineError {
fn retry(msg: impl Into<String>) -> EngineError {
EngineError::Other(msg.into())
}
@@ -191,9 +188,8 @@ impl LayerM {
"LOck" => Stage::Layers(Change::Lock),
"Unlock" => Stage::Layers(Change::Unlock),
"Description" => Stage::Description,
"stAte" => Stage::State(state_prompts::Stage::Option),
other => {
// MATerial, rEconcile: report and stay at the option prompt.
// MATerial, stAte, rEconcile: report and stay at the option prompt.
s.echo(format!("-LAYER {other} is not available yet."));
Stage::Option
}
@@ -266,7 +262,7 @@ impl LayerM {
Ok(Step::Continue)
};
match stage {
Stage::Option | Stage::State(_) => Ok(Step::Continue),
Stage::Option => Ok(Step::Continue),
Stage::List => {
self.list(s, text.as_deref().unwrap_or("*"));
Ok(Step::Continue)
@@ -438,18 +434,9 @@ impl Interactive for LayerM {
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"),
Stage::State(st) => st.prompt(),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Stage::State(st) = &mut self.stage
&& !matches!(i, Input::Cancel)
{
if !st.input(s, &i)? {
self.stage = Stage::Option;
}
return Ok(Step::Continue);
}
match (&self.stage, &i) {
(_, Input::Cancel) => Ok(Step::Cancel),
(Stage::Option, Input::Enter) => Ok(Step::Done),
@@ -1,256 +0,0 @@
//! -LAYER stAte: save, restore, edit, rename, delete and list the drawing's layer states, with
//! AutoCAD 2024's prompts and messages (measured). Save, Restore, Name and Delete run the
//! `layerstate.*` commands; Edit changes the state's mask in place.
use cadcraft_doc::LayerState as LS;
use serde_json::{Value, json};
use super::prompts::{KW, NAME, call, message, retry};
use super::{state_index, valid_name};
use crate::{Input, Prompt, Result, Session};
/// The options after stAte. Import and EXport (layer state files) are not available yet.
const OPTIONS: &[&str] = &["?", "Save", "Restore", "Edit", "Name", "Delete", "Import", "EXport"];
/// "Enter states to change": each keyword, the name AutoCAD 2024 lists it by and its mask bit, in
/// AutoCAD's order.
const TOGGLES: [(&str, &str, u32); 10] = [
("On", "On", LS::ON),
("Frozen", "Frozen", LS::FROZEN),
("Lock", "Lock", LS::LOCKED),
("Plot", "Plot", LS::PLOT),
("Newvpfreeze", "Newvpfreeze", LS::VP_FREEZE_NEW),
("Color", "Color", LS::COLOR),
("lineType", "lineType", LS::LINETYPE),
("lineWeight", "lineWeight", LS::LINEWEIGHT),
("TRansparency", "Transparency", LS::TRANSPARENCY),
("plotStyle", "plotStyle", LS::PLOT_STYLE),
];
/// The options that ask for a saved state's name.
#[derive(Clone, Copy, Debug)]
pub(super) enum Pick {
Restore,
Edit,
Name,
Delete,
}
impl Pick {
fn verb(self) -> &'static str {
match self {
Pick::Restore => "restore",
Pick::Edit => "edit",
Pick::Name => "rename",
Pick::Delete => "delete",
}
}
}
#[derive(Clone, Debug, Default)]
pub(super) enum Stage {
#[default]
Option,
/// Save: the new state's name.
SaveName,
/// Restore, Edit, Name or Delete: the saved state's name.
Pick(Pick),
/// Name: the new name of the state called so.
RenameTo(String),
/// "Enter states to change" for the state `name`: one Save makes on Enter, or one Edit
/// changes (`edit`).
Toggles { name: String, mask: u32, edit: bool },
}
impl Stage {
pub(super) fn prompt(&self) -> Prompt {
match self {
Stage::Option => Prompt::new("Enter an option", KW).kw(OPTIONS),
Stage::SaveName | Stage::RenameTo(_) => Prompt::new("Enter new layer state name", NAME),
Stage::Pick(p) => Prompt::new(format!("Enter name of layer state to {}", p.verb()), NAME).kw(&["?"]),
Stage::Toggles { .. } => Prompt::new("Enter states to change", KW).kw(&TOGGLES.map(|t| t.0)),
}
}
/// One input. `Ok(false)`: back to -LAYER's options. An invalid input leaves the stage as it
/// is, so the prompt is asked again.
pub(super) fn input(&mut self, s: &mut Session, i: &Input) -> Result<bool> {
let text = match i {
Input::Text(t) | Input::Keyword(t) => Some(t.trim().to_string()).filter(|t| !t.is_empty()),
_ => None,
};
let next = match std::mem::take(self) {
Stage::Option => match i {
Input::Enter => return Ok(false),
Input::Keyword(k) => option(s, k),
_ => return Err(retry("Invalid option keyword.")),
},
Stage::SaveName => match text {
None => Stage::Option,
Some(n) => save_name(s, n),
},
Stage::Pick(p) => match (i, text) {
(Input::Keyword(k), _) if k == "?" => {
list(s);
Stage::Pick(p)
}
(_, None) => Stage::Option,
(_, Some(n)) => pick(s, p, &n),
},
Stage::RenameTo(from) => {
if let Some(to) = text {
rename(s, &from, &to);
}
Stage::Option
}
Stage::Toggles { name, mut mask, edit } => match i {
Input::Keyword(k) => {
if let Some(&(_, _, bit)) = TOGGLES.iter().find(|t| t.0 == k) {
mask ^= bit;
}
show(s, mask);
Stage::Toggles { name, mask, edit }
}
Input::Enter => {
finish(s, &name, mask, edit);
Stage::Option
}
_ => {
*self = Stage::Toggles { name, mask, edit };
return Err(retry("Invalid option keyword."));
}
},
};
*self = next;
Ok(true)
}
}
fn option(s: &mut Session, k: &str) -> Stage {
match k {
"?" => {
list(s);
Stage::Option
}
"Save" => Stage::SaveName,
"Restore" => Stage::Pick(Pick::Restore),
"Edit" => Stage::Pick(Pick::Edit),
"Name" => Stage::Pick(Pick::Name),
"Delete" => Stage::Pick(Pick::Delete),
other => {
s.echo(format!("-LAYER stAte {other} is not available yet."));
Stage::Option
}
}
}
/// Whether a saved state has the name `n` in any case.
fn taken(s: &Session, n: &str) -> bool {
s.doc().is_ok_and(|d| d.layer_states.iter().any(|st| st.name.eq_ignore_ascii_case(n)))
}
/// Save's name: refused (asked again) when it has a character AutoCAD 2024 refuses (the layer
/// name ones, measured one by one), is longer than 255 characters (measured 256), or is a saved
/// state's name in any case (measured `s1` after `S1`).
fn save_name(s: &mut Session, n: String) -> Stage {
if !valid_name(&n) {
s.echo(format!("\"{n}\" is an invalid layer state name."));
return Stage::SaveName;
}
if taken(s, &n) {
s.echo(format!("Layer state \"{n}\" already exists."));
return Stage::SaveName;
}
let mask = s.settings.layer_state_mask;
show(s, mask);
Stage::Toggles { name: n, mask, edit: false }
}
fn pick(s: &mut Session, p: Pick, n: &str) -> Stage {
let found = s.doc().ok().and_then(|d| state_index(d, n).and_then(|i| d.layer_states.get(i)).map(|st| (st.name.clone(), st.mask)));
let Some((name, mask)) = found else {
s.echo("Unknown layer state name.");
return Stage::Pick(p);
};
match p {
Pick::Restore => {
run(s, "layerstate.restore", &json!({ "name": name }));
Stage::Option
}
Pick::Delete => {
run(s, "layerstate.delete", &json!({ "name": name }));
Stage::Option
}
Pick::Edit => {
show(s, mask);
Stage::Toggles { name, mask, edit: true }
}
Pick::Name => Stage::RenameTo(name),
}
}
/// Name's new name. A name some state has in any case, the state's own too, is refused with
/// AutoCAD 2024's two lines (measured `S2` onto `S2`, `S1` onto `s1`). A name with a character
/// AutoCAD refuses leaves the state as it is with no message, as AutoCAD does (measured `a,b`,
/// `a<b`); AutoCAD renames to a name starting with "*" as an anonymous `*A1`, and CADCraft leaves
/// that state as it is too.
fn rename(s: &mut Session, from: &str, to: &str) {
if taken(s, to) {
s.echo("Layer state could not be renamed.");
s.echo(format!("{to} already exists."));
} else if valid_name(to) {
run(s, "layerstate.rename", &json!({ "from": from, "to": to }));
}
}
/// Enter at "Enter states to change": Save makes the state with this mask and keeps the toggles
/// for the next Save; Edit sets the state's mask and keeps the bits no toggle reaches (AutoCAD's
/// 65536 after a restore). Edit leaves the next Save's toggles alone (measured).
fn finish(s: &mut Session, name: &str, mask: u32, edit: bool) {
if !edit {
if run(s, "layerstate.save", &json!({ "name": name, "mask": mask & LS::ALL })) {
s.settings.layer_state_mask = mask & LS::ALL;
}
return;
}
// Only a changed mask touches the drawing.
let Ok(d) = s.doc() else { return };
let Some(i) = state_index(d, name).filter(|&i| d.layer_states.get(i).is_some_and(|st| st.mask != mask)) else { return };
if let Ok(d) = s.doc_mut()
&& let Some(st) = d.layer_states.get_mut(i)
{
st.mask = mask;
}
}
/// Run a `layerstate.*` command, reporting a refusal; `true` when it ran.
fn run(s: &mut Session, id: &str, p: &Value) -> bool {
match call(s, id, p) {
Ok(_) => true,
Err(e) => {
s.echo(message(&e));
false
}
}
}
/// The toggles as AutoCAD 2024 lists them before "Enter states to change".
fn show(s: &mut Session, mask: u32) {
s.echo("States");
for (_, label, bit) in TOGGLES {
s.echo(format!("{label:<20}{}", if mask & bit != 0 { "Yes" } else { "No" }));
}
}
/// `?`: every saved state by name without regard to case, as AutoCAD 2024 lists them (measured:
/// `S2`, `b`, `S1` saved in that order list as `b`, `S1`, `S2`; a name starting with "*", its
/// `*A1`, is listed too).
fn list(s: &mut Session) {
let mut names: Vec<String> = s.doc().map(|d| d.layer_states.iter().map(|st| st.name.clone()).collect()).unwrap_or_default();
names.sort_by_cached_key(|n| n.to_ascii_lowercase());
s.echo("Layer state");
s.echo("-".repeat(29));
for n in names {
s.echo(n);
}
}
+2 -2
View File
@@ -101,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("rename", "Rename...", run_rename)
.menu(&["Format", "Rename..."])
.alias(&["ren", "-rename"])
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs|vport, from, to}")
.params("{table: layer|linetype|style|dimstyle|block|mleaderstyle|tablestyle|view|ucs, from, to}")
.interactive(|_| Ok(Box::new(rename::RenameM::default()))),
]
}
@@ -995,7 +995,7 @@ fn run_rename(s: &mut Session, p: &Value) -> Result<Value> {
}
"block" => rename::block(s, &from, &to)?,
"mleaderstyle" | "multileaderstyle" => rename::simple(s, "mleaderstyle", &from, &to)?,
"tablestyle" | "view" | "ucs" | "vport" => rename::simple(s, &table, &from, &to)?,
"tablestyle" | "view" | "ucs" => rename::simple(s, &table, &from, &to)?,
"style" | "textstyle" => {
run_style_rename(s, &json!({ "from": from, "to": to }))?;
}
+16 -81
View File
@@ -93,8 +93,6 @@ pub(super) fn simple(s: &mut Session, table: &str, from: &str, to: &str) -> Resu
"tablestyle" => d.table_styles.iter_mut().map(|t| &mut t.name).collect(),
"view" => d.views.iter_mut().map(|t| &mut t.name).collect(),
"ucs" => d.ucss.iter_mut().map(|t| &mut t.name).collect(),
// A saved viewport configuration, every tile of it; never the one shown (`*Active`).
"vport" => d.vports.iter_mut().filter(|v| !v.is_active()).map(|t| &mut t.name).collect(),
_ => return Err(bad("rename", "unsupported table")),
};
if !to.eq_ignore_ascii_case(from) && names.iter().any(|n| n.eq_ignore_ascii_case(&to)) {
@@ -136,47 +134,35 @@ const TYPES: &[(&str, Option<&str>, &str)] = &[
("Plotstyle", None, "plot style"),
("textStyle", Some("style"), "text style"),
("Tablestyle", Some("tablestyle"), "table style"),
("Ucs", Some("ucs"), "ucs"),
("Ucs", Some("ucs"), "UCS"),
("VIew", Some("view"), "view"),
("VPort", Some("vport"), "viewport configuration"),
("VPort", None, "viewport configuration"),
];
/// The noun in "Cannot find …" and "Invalid … name.": AutoCAD 2024 writes "UCS" there, "ucs" in
/// its prompts and in "A ucs named … already exists." (measured).
fn title(noun: &str) -> &str {
if noun == "ucs" { "UCS" } else { noun }
}
/// Keyword-only: spaces separate inputs.
const KW: Accept = Accept { point: false, number: false, text: false, select: false, enter: true };
/// A name: Space ends the input.
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> Option<String> {
names.find(|n| n.eq_ignore_ascii_case(name)).cloned()
fn any_named<'a>(mut names: impl Iterator<Item = &'a String>, name: &str) -> bool {
names.any(|n| n.eq_ignore_ascii_case(name))
}
/// The name as the drawing spells it of the `table` entry named `name` (without regard to case).
fn stored(d: &Drawing, table: &str, name: &str) -> Option<String> {
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
match table {
"block" => d.block(name).map(|t| t.name.clone()),
"layer" => d.layer(name).map(|t| t.name.clone()),
"linetype" => d.linetype(name).map(|t| t.name.clone()),
"style" => d.text_style(name).map(|t| t.name.clone()),
"dimstyle" => d.dim_style(name).map(|t| t.name.clone()),
"block" => d.block(name).is_some(),
"layer" => d.layer(name).is_some(),
"linetype" => d.linetype(name).is_some(),
"style" => d.text_style(name).is_some(),
"dimstyle" => d.dim_style(name).is_some(),
"mleaderstyle" => any_named(d.mleader_styles.iter().map(|t| &t.name), name),
"tablestyle" => any_named(d.table_styles.iter().map(|t| &t.name), name),
"view" => any_named(d.views.iter().map(|t| &t.name), name),
"ucs" => any_named(d.ucss.iter().map(|t| &t.name), name),
"vport" => any_named(d.vports.iter().filter(|v| !v.is_active()).map(|t| &t.name), name),
_ => Some(name.to_string()),
_ => true,
}
}
fn exists(d: &Drawing, table: &str, name: &str) -> bool {
stored(d, table, name).is_some()
}
#[derive(Default)]
enum Stage {
#[default]
@@ -213,15 +199,6 @@ impl Interactive for RenameM {
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
// No new name is an invalid one (AutoCAD 2024, measured for layers, blocks, views and
// viewport configurations).
if i == Input::Enter
&& let Stage::New(t, _) = &self.stage
&& let Some((_, Some(_), noun)) = TYPES.get(*t)
{
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
}
if matches!(i, Input::Cancel | Input::Enter) {
return Ok(if i == Input::Cancel { Step::Cancel } else { Step::Done });
}
@@ -240,41 +217,12 @@ impl Interactive for RenameM {
self.stage = Stage::Old(t);
return Ok(Step::Continue);
};
// AutoCAD 2024 ends -RENAME on an old name it won't rename (measured): "Invalid … name."
// for a viewport configuration or block whose name starts with "*" (*Active,
// *Model_Space, an anonymous block's *U0) and for linetypes ByLayer and ByBlock;
// "Cannot rename …" and "*Invalid*" for layer 0 and linetype Continuous.
let invalid = match *table {
Some("vport" | "block") => name.starts_with('*'),
Some("linetype") => name.eq_ignore_ascii_case("bylayer") || name.eq_ignore_ascii_case("byblock"),
_ => false,
};
if invalid {
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
if let Some(table) = table
&& !exists(s.doc()?, table, &name)
{
self.stage = Stage::Old(t);
return Err(EngineError::Other(format!("No {noun} named \"{name}\".")));
}
let fixed = match *table {
Some("layer") => name == "0",
Some("linetype") => name.eq_ignore_ascii_case("continuous"),
_ => false,
};
if fixed {
s.echo(format!("Cannot rename {} \"{name}\".", title(noun)));
s.echo("*Invalid*");
return Ok(Step::Done);
}
// The old name as the drawing spells it: a new name in another case than that is a
// rename, even when it is the old name as typed (AutoCAD 2024, measured).
let name = match table {
Some(table) => match stored(s.doc()?, table, &name) {
Some(n) => n,
None => {
s.echo(format!("Cannot find {} \"{name}\".", title(noun)));
return Ok(Step::Done);
}
},
None => name,
};
self.stage = Stage::New(t, name);
Ok(Step::Continue)
}
@@ -287,19 +235,6 @@ impl Interactive for RenameM {
s.echo(format!("Renaming a {noun} is not available yet."));
return Ok(Step::Done);
};
// AutoCAD 2024's messages, each ending the command (measured).
if !valid_name(&name) {
s.echo(format!("Invalid {} name.", title(noun)));
return Ok(Step::Done);
}
if !name.eq_ignore_ascii_case(&old) && exists(s.doc()?, table, &name) {
s.echo(format!("A {noun} named \"{name}\" already exists."));
s.echo("*Invalid*");
return Ok(Step::Done);
}
if name == old {
return Ok(Step::Done);
}
match super::run_rename(s, &json!({ "table": table, "from": old, "to": name })) {
Ok(_) => Ok(Step::Done),
Err(e) => {
+1 -1
View File
@@ -138,7 +138,7 @@ fn save(s: &mut Session, name: &str, window: Option<Bounds2>, snapshot: bool) ->
let layer_state = snapshot.then(|| {
let state = snapshot_name(name);
d.layer_states.retain(|l| !l.name.eq_ignore_ascii_case(&state));
d.layer_states.push(LayerState::new(state.clone(), d.layers.clone(), ""));
d.layer_states.push(LayerState { name: state.clone(), layers: d.layers.clone() });
state
});
if let Some(old) = &replaced {
+6
View File
@@ -156,6 +156,10 @@ pub struct Session {
lisp_last: Option<std::result::Result<lisp::value::Value, String>>,
/// What the last HATCHPICK kept (the Hatch and Gradient dialog's picks).
pub hatch_picks: Option<cmd::hatch::HatchPicks>,
/// The window's menu bar and tool bar as the UI shows them (it reports them every frame).
pub bars_shown: cmd::interface::InterfaceBars,
/// The bars MENUBAR or TOOLBAR asked to change, for the UI to apply.
pub bars_request: cmd::interface::BarsRequest,
/// The object named with a point for the input a prompt picking one object is taking
/// ([`Session::input_object`]): a pick at exactly that point picks that object
/// ([`Session::pick_object`]).
@@ -215,6 +219,8 @@ impl Session {
lisp: lisp::LispState::default(),
lisp_last: None,
hatch_picks: None,
bars_shown: Default::default(),
bars_request: Default::default(),
pick_hint: None,
}
}
+1 -2
View File
@@ -31,7 +31,7 @@ impl Accept {
/// [Truecolor/COlorbook] <BYLAYER>:". A prompt asking for something else besides its keywords has
/// it: "Enter block name or [?]:", "Specify insertion base point or [Basepoint/…]:". Read from
/// AutoCAD's command line over measured runs, where no prompt was written both ways.
const NO_OR: &[&str] = &[
const NO_OR: [&str; 28] = [
"Bring to front",
"Calculate rectangle dimensions based on",
"Choose mode for selected object conversion",
@@ -50,7 +50,6 @@ const NO_OR: &[&str] = &[
"Enter option",
"Enter polyline linetype generation option",
"Enter property to change",
"Enter states to change",
"Enter the type of array",
"Enter type of unused objects to purge",
"Enter viewport arrangement",
-5
View File
@@ -27,10 +27,6 @@ pub struct Settings {
pub measureinit: bool,
/// -VIEW sEttings > Layer snapshot: named views save the layer settings with them.
pub view_layer_snapshot: bool,
/// -LAYER stAte Save: the properties a new layer state restores (its mask), as the last Save
/// left them. AutoCAD 2024 keeps these toggles in the registry from one Save to the next
/// (measured); Edit doesn't change them.
pub layer_state_mask: u32,
pub dynmode: bool,
/// DYNDIGRIP: which dimensions grip dimensional input shows while a grip is stretched (bits:
/// 1 resulting length, 2 length change, 4 absolute angle, 8 angle change, 16 radius); read
@@ -152,7 +148,6 @@ impl Default for Settings {
zoomfactor: 60,
measureinit: false,
view_layer_snapshot: true,
layer_state_mask: cadcraft_doc::LayerState::ALL,
dynmode: true,
dyndigrip: 31,
dyndivis: 1,
-202
View File
@@ -1,202 +0,0 @@
//! The Key point option of a base point: ARRAYRECT, ARRAYPOLAR and ARRAYEDIT (Base point and
//! REPlace) take the source objects' key point (an end point, midpoint, centre…) nearest the
//! picked point as the base point; the JSON forms take `keyPoint`.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{ArrayKind, ArrayParams, EntityKind, Handle};
use cadcraft_engine::geom::Vec2;
use serde_json::json;
fn source_line(s: &mut Session) -> String {
let r = s.execute("line", &json!({"points": [[0, 0], [2, 1]]})).unwrap();
r["handle"].as_str().or_else(|| r["handles"][0].as_str()).unwrap().to_string()
}
fn handle(v: &serde_json::Value) -> Handle {
Handle::parse_hex(v["handle"].as_str().unwrap()).unwrap()
}
/// The array's insertion point (its base point) and parameters.
fn array(s: &Session, h: Handle) -> (Vec2, ArrayParams) {
let d = s.doc().unwrap();
let e = d.entity(h).unwrap();
let EntityKind::Insert(i) = &e.kind else { panic!("not an array") };
(i.insert.xy(), d.array_params(e).unwrap())
}
fn only_array(s: &Session) -> Handle {
let d = s.doc().unwrap();
let arrays: Vec<Handle> = d.model.iter().filter(|e| d.array_params(e).is_some()).map(|e| e.handle).collect();
assert_eq!(arrays.len(), 1);
arrays[0]
}
fn typed(s: &mut Session, inputs: &[&str]) {
for t in inputs {
s.cmdline(t).unwrap();
}
}
#[test]
fn arrayrect_and_arraypolar_take_a_key_point_as_the_base_point() {
let mut s = Session::new();
let l = source_line(&mut s);
let r = s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "keyPoint": [1.9, 1.05]})).unwrap();
assert!(array(&s, handle(&r)).0.near(Vec2::new(2.0, 1.0), 1e-9));
let mut s = Session::new();
let l = source_line(&mut s);
let r = s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 4, "keyPoint": [1.1, 0.4]})).unwrap();
assert!(array(&s, handle(&r)).0.near(Vec2::new(1.0, 0.5), 1e-9), "the line's midpoint");
}
#[test]
fn typed_key_points_at_arrayrect_and_arraypolar() {
let mut s = Session::new();
source_line(&mut s);
typed(&mut s, &["arrayrect", "l", "", "b", "k", "1.9,0.95", "x"]);
assert!(array(&s, only_array(&s)).0.near(Vec2::new(2.0, 1.0), 1e-9));
// Enter at the key point prompt goes back to the base point prompt.
let mut s = Session::new();
source_line(&mut s);
typed(&mut s, &["arraypolar", "l", "", "b", "k"]);
assert!(s.current_prompt().unwrap().message.contains("key point"));
typed(&mut s, &[""]);
assert!(s.current_prompt().unwrap().message.contains("base point"));
typed(&mut s, &["k", "0.1,0.1", "-10,0", "x"]);
assert!(array(&s, only_array(&s)).0.near(Vec2::new(0.0, 0.0), 1e-9));
}
#[test]
fn arrayedit_moves_the_base_point_to_a_key_point_of_an_item() {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
// Near the start of the third item: the base point goes to (10, 0), the items stay.
s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [10.2, 0.05]})).unwrap();
let (at, p) = array(&s, h);
assert!(at.near(Vec2::new(10.0, 0.0), 1e-9), "{at:?}");
assert!(matches!(p.kind, ArrayKind::Rect(r) if r.cols == 3 && r.col_spacing == 5.0));
let items = s.execute("explode", &json!({"handles": [h.hex()]})).unwrap();
assert!(items.to_string().len() > 2);
let d = s.doc().unwrap();
let mut starts: Vec<(i64, i64)> = d
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some(((l.a.x * 10.0).round() as i64, (l.a.y * 10.0).round() as i64)),
_ => None,
})
.collect();
starts.sort();
assert_eq!(starts, [(0, 0), (50, 0), (100, 0)]);
// Not on an item: refused.
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [3.5, 40]})).is_err());
assert!(array(&s, h).0.near(Vec2::ZERO, 1e-9));
// Typed: Base point, Key point, a point on the second item near its end.
s.set_selection(vec![h]);
typed(&mut s, &["arrayedit", "b", "k", "6.9,0.9", "x"]);
assert!(array(&s, h).0.near(Vec2::new(7.0, 1.0), 1e-9));
}
#[test]
fn replacement_objects_take_a_key_point_as_their_base_point() {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 3, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
let c = s.execute("circle", &json!({"center": [50, 50], "radius": 1})).unwrap()["handle"].clone();
// The circle's right quadrant is the base point: on item 1 (at x = 5) its centre is at x = 4.
s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [c], "keyPoint": [51.2, 50.1], "items": [[1, 0, 0]]}})).unwrap();
s.execute("explode", &json!({"handles": [h.hex()]})).unwrap();
let d = s.doc().unwrap();
// The replaced item stays a reference to the replacement block.
let centres: Vec<Vec2> = d
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Insert(i) => d.block(&i.block).map(|b| (i.transform(b.base.xy()), b)),
_ => None,
})
.flat_map(|(m, b)| {
b.entities
.iter()
.filter_map(move |e| match &e.kind {
EntityKind::Circle(c) => Some(m.apply(c.center.xy())),
_ => None,
})
.collect::<Vec<_>>()
})
.collect();
assert!(centres.iter().any(|c| c.near(Vec2::new(4.0, 0.0), 1e-9)), "{centres:?}");
}
#[test]
fn hostile_key_points_never_panic() {
let mut s = Session::new();
let l = source_line(&mut s);
for kp in [json!(["a", 1]), json!([1e308, -1e308]), json!([]), json!("x"), json!(null)] {
let _ = s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "keyPoint": kp}));
let _ = s.execute("arraypolar", &json!({"handles": [l], "center": [5, 5], "count": 3, "keyPoint": kp}));
}
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
for kp in [json!([1e308, 1e308]), json!([-1e308, 0]), json!(["x"]), json!([0.5, 0.25])] {
let _ = s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": kp}));
let _ = s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [], "keyPoint": kp, "items": [[0, 0, 0]]}}));
}
// Typed key points far away or on nothing are refused without leaving the command broken.
s.set_selection(vec![h]);
typed(&mut s, &["arrayedit", "b", "k"]);
assert!(s.cmdline("1e300,1e300").is_err() || s.running.is_some());
s.cancel();
}
/// A `keyPoint` that is there but isn't a point is refused, not taken as no key point (which
/// would make the array at another base point).
#[test]
fn a_key_point_that_is_not_a_point_is_refused() {
let mut s = Session::new();
let l = source_line(&mut s);
assert!(s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "keyPoint": ["bad", 1]})).is_err());
assert!(s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 3, "keyPoint": "x"})).is_err());
assert!(s.doc().unwrap().model.iter().all(|e| s.doc().unwrap().array_params(e).is_none()), "no array made");
let h = handle(&s.execute("arrayrect", &json!({"handles": [l], "cols": 2, "rows": 1, "colSpacing": 5, "base": [0, 0]})).unwrap());
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "keyPoint": [1]})).is_err());
let c = s.execute("circle", &json!({"center": [50, 50], "radius": 1})).unwrap()["handle"].clone();
assert!(s.execute("arrayedit", &json!({"handle": h.hex(), "replace": {"handles": [c], "keyPoint": {}, "items": [[1, 0, 0]]}})).is_err());
}
/// More objects than the key point search takes are refused rather than searched in part, which
/// could miss the nearest key point.
#[test]
fn a_key_point_of_too_many_objects_is_refused() {
let mut s = Session::new();
// 10,001 lines; the last one ends nearest the key point.
let pts: Vec<[f64; 2]> = (0..10_002).map(|i| [f64::from(i), 0.0]).collect();
let r = s.execute("line", &json!({ "points": pts })).unwrap();
let hs: Vec<String> = s.doc().unwrap().model.iter().map(|e| e.handle.hex()).collect();
assert_eq!(hs.len(), 10_001, "{r}");
let e = s.execute("arraypolar", &json!({"handles": hs, "center": [0, -50], "count": 2, "keyPoint": [10_001.2, 0]})).unwrap_err();
assert!(e.to_string().contains("10000"), "{e}");
}
/// ARRAYEDIT with a new base point (`base` or `keyPoint`) and a polar `center` in one call puts the
/// centre where asked: the base point moves the array's insertion point, so the centre is read in
/// the array's placement after that move.
#[test]
fn arrayedit_center_with_a_new_base_point_lands_where_asked() {
for (key, at) in [("base", json!([2, 1])), ("keyPoint", json!([1.95, 0.99]))] {
let mut s = Session::new();
let l = source_line(&mut s);
let h = handle(&s.execute("arraypolar", &json!({"handles": [l], "center": [-10, 0], "count": 4, "base": [0, 0]})).unwrap());
s.execute("arrayedit", &json!({"handle": h.hex(), key: at, "center": [5, 0]})).unwrap();
let (ins, p) = array(&s, h);
let ArrayKind::Polar(k) = p.kind else { panic!("not polar") };
assert!(ins.near(Vec2::new(2.0, 1.0), 1e-9), "{key}: {ins:?}");
// The centre is kept relative to the insertion point.
assert!((ins + k.center).near(Vec2::new(5.0, 0.0), 1e-9), "{key}: centre at {:?}", ins + k.center);
}
}
+4 -43
View File
@@ -83,22 +83,14 @@ fn dash_attedit_one_at_a_time_edits_the_selected_attributes() {
let mut s = with_block();
let h = handle(&insert(&mut s, 100.0, json!({"T": "abc"})));
type_lines(&mut s, &["-attedit", "y", "", "T", "", "105,0", ""]);
assert!(s.prompt_text().contains("[Value/Position/Height/Angle/Style/Layer/Color/Next] <N>"), "{}", s.prompt_text());
// Edit Position, Height, Angle, and Style
type_lines(&mut s, &["p", "10,20", "h", "2.5", "a", "45", "s", "Standard"]);
// Edit Value: change and replace
assert!(s.prompt_text().contains("[Value/Layer/Color/Next] <N>"), "{}", s.prompt_text());
// Unsupported options say so and keep the prompt.
s.cmdline("p").unwrap();
assert!(s.log.iter().any(|l| l.contains("Position is not available yet")), "{:?}", s.log);
type_lines(&mut s, &["v", "c", "b", "B", "v", "r", "replaced value", "n"]);
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(value(&s, h, "T"), "replaced value");
assert_eq!(value(&s, h, "U"), "u");
let EntityKind::Insert(ins) = &s.doc().unwrap().entity(h).unwrap().kind else { panic!("not an insert") };
let att = ins.attribs.iter().find(|a| a.tag == "T").unwrap();
assert!((att.text.insert.x - 10.0).abs() < 1e-6);
assert!((att.text.insert.y - 20.0).abs() < 1e-6);
assert!((att.text.height - 2.5).abs() < 1e-6);
assert!((att.text.rotation.to_degrees() - 45.0).abs() < 1e-4);
assert_eq!(att.text.style, "Standard");
}
#[test]
@@ -117,34 +109,3 @@ fn attribute_tags_match_in_any_case_and_unknown_tags_are_reported() {
let r = s.execute("attedit", &json!({"handle": h.hex(), "values": {"T": "four"}})).unwrap();
assert_eq!(r, json!({"changed": 1}));
}
/// -ATTEDIT Position moves an aligned or fit attribute without losing its baseline: both of its
/// points move by the same offset (setting both to the picked point would leave no direction or
/// length to fit the text between).
#[test]
fn dash_attedit_position_keeps_an_aligned_attributes_baseline() {
use cadcraft_doc::HAlign;
use cadcraft_geom::Vec3;
for halign in [HAlign::Aligned, HAlign::Fit] {
let mut s = with_block();
let h = handle(&insert(&mut s, 100.0, json!({"T": "abc"})));
s.doc_mut()
.unwrap()
.modify_entity(h, |e| {
if let EntityKind::Insert(i) = &mut e.kind {
for a in i.attribs.iter_mut().filter(|a| a.tag == "T") {
a.text.halign = halign;
a.text.insert = Vec3::new(100.0, 1.0, 0.0);
a.text.align_pt = Some(Vec3::new(104.0, 1.0, 0.0));
}
}
})
.unwrap();
type_lines(&mut s, &["-attedit", "y", "", "T", "", "105,0", "", "p", "10,20", "n"]);
assert!(s.running.is_none(), "{}", s.prompt_text());
let EntityKind::Insert(ins) = &s.doc().unwrap().entity(h).unwrap().kind else { panic!("not an insert") };
let t = &ins.attribs.iter().find(|a| a.tag == "T").unwrap().text;
assert!(t.insert.xy().near(cadcraft_geom::Vec2::new(10.0, 20.0), 1e-9), "{halign:?}: {:?}", t.insert);
assert!(t.align_pt.is_some_and(|p| p.xy().near(cadcraft_geom::Vec2::new(14.0, 20.0), 1e-9)), "{halign:?}: {:?}", t.align_pt);
}
}
+1 -1
View File
@@ -38,7 +38,7 @@ fn dash_attedit_sets_layer_and_colour_of_one_attribute() {
for t in ["-attedit", "y", "", "T", "", "105,0", ""] {
s.cmdline(t).unwrap();
}
assert!(s.prompt_text().contains("[Value/Position/Height/Angle/Style/Layer/Color/Next] <N>"), "{}", s.prompt_text());
assert!(s.prompt_text().contains("[Value/Layer/Color/Next] <N>"), "{}", s.prompt_text());
s.cmdline("l").unwrap();
assert!(s.prompt_text().contains("Enter new layer name <0>"), "{}", s.prompt_text());
// An unknown layer is refused and asked again.
@@ -1,247 +0,0 @@
//! -LAYER stAte: AutoCAD 2024's layer state prompts and messages (measured with accoreconsole on a
//! drawing with layers A, red, and B), and the `layerstate.*` commands they run.
use cadcraft_engine::doc::LayerState;
use cadcraft_engine::{Input, Session};
use serde_json::json;
const LABELS: [&str; 10] = ["On", "Frozen", "Lock", "Plot", "Newvpfreeze", "Color", "lineType", "lineWeight", "Transparency", "plotStyle"];
/// The toggles AutoCAD lists before "Enter states to change", with `no` the ones set to No.
fn table(no: &[&str]) -> Vec<String> {
let mut v = vec!["States".to_string()];
v.extend(LABELS.iter().map(|l| format!("{l:<20}{}", if no.contains(l) { "No" } else { "Yes" })));
v
}
/// Layers A (red) and B; the current layer stays 0.
fn drawing() -> Session {
let mut s = Session::new();
s.script("-LAYER N A,B C 1 A\n\n").unwrap();
s
}
/// Run `script` to its end and return what it wrote besides the commands' names and -LAYER's
/// "Current layer" line.
fn run(s: &mut Session, script: &str) -> Vec<String> {
let at = s.log.len();
s.script(script).unwrap();
assert!(s.running.is_none(), "{script:?} ends at: {}", s.prompt_text());
s.log[at..].iter().filter(|l| !l.starts_with("Command: ") && !l.starts_with("Current layer:")).cloned().collect()
}
fn states(s: &Session) -> Vec<(String, u32)> {
s.doc().unwrap().layer_states.iter().map(|st| (st.name.clone(), st.mask)).collect()
}
fn state(name: &str, mask: u32) -> (String, u32) {
(name.to_string(), mask)
}
#[test]
fn save_asks_the_states_and_remembers_them_for_the_next_save() {
let mut s = drawing();
// Each toggle lists the states again; On off is AutoCAD's 2046.
let out = run(&mut s, "-LAYER A S S6 ON\n\n\n\nLINE 0,0 1,0\n\n");
assert_eq!(out, [table(&[]), table(&["On"])].concat());
assert_eq!(states(&s), [state("S6", 2046)]);
assert_eq!(s.doc().unwrap().model.len(), 1, "the next command runs");
// The next Save starts from the toggles the last one left: On alone is 513, then every
// toggle once more is 2046 (AutoCAD's S7 and S8).
let out = run(&mut s, "-LAYER A S S7 ON F L P N C T W TR S\n\n\n\n");
assert_eq!(out[..11], table(&["On"]));
assert_eq!(
out[out.len() - 11..],
table(&["Frozen", "Lock", "Plot", "Newvpfreeze", "Color", "lineType", "lineWeight", "Transparency", "plotStyle"])
);
run(&mut s, "-LAYER A S S8 ON F L P N C T W TR S\n\n\n\n");
run(&mut s, "-LAYER A S S9 ON\n\n\n\n");
assert_eq!(states(&s)[1..], [state("S7", 513), state("S8", 2046), state("S9", LayerState::ALL)]);
// Edit lists and changes the state's own mask (found in any case), not the next Save's
// toggles (AutoCAD: Edit S1 to 2015, then S2 is 2047).
let out = run(&mut s, "-LAYER A E s6 ON C\n\n\n\n");
assert_eq!(out, [table(&["On"]), table(&[]), table(&["Color"])].concat());
run(&mut s, "-LAYER A S S10\n\n\n\n");
assert_eq!(states(&s)[0], state("S6", 2015));
assert_eq!(states(&s)[4], state("S10", LayerState::ALL));
// Each -LAYER is one undo step.
s.undo().unwrap();
assert_eq!(states(&s).len(), 4);
s.undo().unwrap();
assert_eq!(states(&s)[0], state("S6", 2046));
// A state from AutoCAD after a restore (mask 67583 = 2047 + 65536) named as AutoCAD names a
// state renamed to "*X": `?` lists it, and Edit keeps the bit no toggle reaches.
s.doc_mut().unwrap().layer_states.push(LayerState { name: "*A1".into(), mask: 67583, ..LayerState::default() });
assert_eq!(
run(
&mut s,
"-LAYER A ?
"
)[2],
"*A1"
);
run(
&mut s,
"-LAYER A E *a1 C
",
);
assert_eq!(states(&s)[4], state("*A1", 67583 - 32));
}
#[test]
fn names_follow_autocads_rules_and_messages() {
let mut s = drawing();
run(&mut s, "-LAYER A S S1\n\n\n\n");
// A saved name in another case is refused and asked again.
let out = run(&mut s, "-LAYER A S s1 S2\n\n\n\n");
assert_eq!(out, [vec!["Layer state \"s1\" already exists.".to_string()], table(&[])].concat());
// The layer name characters, and more than 255 characters, are refused; Enter goes back.
let long = "y".repeat(256);
let out = run(&mut s, &format!("-LAYER A S *X a<b a,b {long}\n\n\n\n"));
assert_eq!(
out,
[
"\"*X\" is an invalid layer state name.",
"\"a<b\" is an invalid layer state name.",
"\"a,b\" is an invalid layer state name.",
&format!("\"{long}\" is an invalid layer state name.")
]
);
run(&mut s, &format!("-LAYER A S {}\n\n\n\n", "x".repeat(255)));
assert_eq!(states(&s).len(), 3);
run(&mut s, &format!("-LAYER A D {}\n\n\n", "x".repeat(255)));
// `?` lists by name without regard to case.
run(&mut s, "-LAYER A S b\n\n\n\n");
let list = ["Layer state", "-----------------------------", "b", "S1", "S2"];
assert_eq!(run(&mut s, "-LAYER A ?\n\n\n"), list);
// Each name prompt lists on `?`, says an unknown name and asks again, and Enter goes back.
let out = run(&mut s, "-LAYER A R ? NOSUCH\n\nE NOSUCH\n\nN NOSUCH\n\nD NOSUCH\n\n\n\n");
assert_eq!(out[..5], list);
assert_eq!(out[5..], ["Unknown layer state name."; 4]);
// Unknown options, Import and EXport.
let out = run(&mut s, "-LAYER A XYZ I EX\n\n\n");
assert_eq!(out, ["Invalid option keyword.", "-LAYER stAte Import is not available yet.", "-LAYER stAte EXport is not available yet."]);
let out = run(&mut s, "-LAYER A S T1 XYZ\n\n\n\n");
assert_eq!(out, [table(&[]), vec!["Invalid option keyword.".to_string()]].concat());
assert_eq!(states(&s).len(), 4, "T1 is saved after the invalid toggle");
run(&mut s, "-LAYER A D T1\n\n\n");
// Name: a name some state has in any case, the state's own too, is refused with two lines.
assert_eq!(run(&mut s, "-LAYER A N S1 S2\n\n\n"), ["Layer state could not be renamed.", "S2 already exists."]);
assert_eq!(run(&mut s, "-LAYER A N S1 s1\n\n\n"), ["Layer state could not be renamed.", "s1 already exists."]);
// A name with a refused character leaves the state as it is, with no message; Enter too.
assert!(run(&mut s, "-LAYER A N S1 a,b\n\n\n").is_empty());
assert!(run(&mut s, "-LAYER A N S1\n\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S1", "S2", "b"]);
// The old name in another case.
assert!(run(&mut s, "-LAYER A N s1 S9\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S9", "S2", "b"]);
assert!(run(&mut s, "-LAYER A D s9\n\n\n").is_empty());
assert_eq!(states(&s).iter().map(|st| st.0.as_str()).collect::<Vec<_>>(), ["S2", "b"]);
}
#[test]
fn esc_drops_the_state_being_saved_and_undo_takes_back_name_and_delete() {
let mut s = drawing();
run(
&mut s,
"-LAYER A S S1
",
);
// Esc at the toggles: that state isn't saved and the next Save's toggles stay as they were;
// what the same -LAYER did before Esc stays, as for the other -LAYER options.
s.script(
"-LAYER A S S2
S S3 C ON
",
)
.unwrap();
// AutoCAD 2024 asks for the toggles without "or" before them.
assert_eq!(
s.current_prompt().unwrap().display(),
"Enter states to change [On/Frozen/Lock/Plot/Newvpfreeze/Color/lineType/lineWeight/TRansparency/plotStyle]:"
);
s.input(Input::Cancel).unwrap();
assert!(s.running.is_none());
assert_eq!(states(&s), [state("S1", LayerState::ALL), state("S2", LayerState::ALL)]);
assert_eq!(s.settings.layer_state_mask, LayerState::ALL);
// Name and Delete are one undo step each, like Save.
run(
&mut s,
"-LAYER A N S1 S9
",
);
run(
&mut s,
"-LAYER A D S2
",
);
assert_eq!(states(&s), [state("S9", LayerState::ALL)]);
s.undo().unwrap();
assert_eq!(states(&s), [state("S9", LayerState::ALL), state("S2", LayerState::ALL)]);
s.undo().unwrap();
assert_eq!(states(&s), [state("S1", LayerState::ALL), state("S2", LayerState::ALL)]);
}
#[test]
fn restore_finds_the_state_in_any_case() {
let mut s = drawing();
run(&mut s, "-LAYER A S S1\n\n\n\n");
run(&mut s, "-LAYER C 3 A M C\n\n");
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.header.str("CLAYER", "0")), (cadcraft_color::Color::Index(3), "C".to_string()));
assert!(run(&mut s, "-LAYER A R s1\n\n\n").is_empty());
let d = s.doc().unwrap();
assert_eq!((d.layer("A").unwrap().color, d.header.str("CLAYER", "0")), (cadcraft_color::Color::Index(1), "0".to_string()));
}
#[test]
fn json_layer_states_take_a_mask_and_find_names_in_any_case() {
let mut s = drawing();
s.execute("layerstate.save", &json!({ "name": "M" })).unwrap();
s.execute("layerstate.save", &json!({ "name": "On", "mask": LayerState::ON })).unwrap();
for bad in [json!(4096), json!(-1), json!(1.5), json!("1")] {
assert!(s.execute("layerstate.save", &json!({ "name": "X", "mask": bad })).is_err(), "{bad}");
}
assert_eq!(states(&s), [state("M", LayerState::ALL), state("On", 513)]);
// Restore, Rename and Delete find a name in another case; a name another state has in any
// case is refused, the state's own in another case too.
s.execute("layer.set", &json!({ "name": "A", "color": "3" })).unwrap();
s.execute("layerstate.restore", &json!({ "name": "m" })).unwrap();
assert_eq!(s.doc().unwrap().layer("A").unwrap().color, cadcraft_color::Color::Index(1));
assert!(s.execute("layerstate.rename", &json!({ "from": "m", "to": "ON" })).is_err());
assert!(s.execute("layerstate.rename", &json!({ "from": "m", "to": "m" })).is_err());
s.execute("layerstate.rename", &json!({ "from": "m", "to": "M2" })).unwrap();
s.execute("layerstate.delete", &json!({ "name": "on" })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
// A name -LAYER stAte Save refuses is refused here too, and nothing is saved.
let long = "x".repeat(256);
for name in ["", " ", "a<b", "a\nb", long.as_str()] {
assert!(s.execute("layerstate.save", &json!({ "name": name })).is_err(), "{name:?}");
}
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
// Save onto a name another state has in another case replaces that state, as one spelled the
// same: AutoCAD 2024 keeps one state per name in any case.
s.execute("layerstate.save", &json!({ "name": "m2", "mask": LayerState::ON })).unwrap();
assert_eq!(states(&s), [state("m2", 513)]);
// Names that differ only in case (CADCraft's own record keeps the second of them, which AutoCAD
// 2024 doesn't see): Save and Delete take the one spelled so, though the other comes first, and
// leave the other.
s.doc_mut().unwrap().layer_states.insert(0, LayerState::new("M2", Vec::new(), ""));
s.execute("layerstate.save", &json!({ "name": "m2", "mask": LayerState::ON | LayerState::FROZEN })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL), state("m2", 515)]);
s.execute("layerstate.delete", &json!({ "name": "m2" })).unwrap();
assert_eq!(states(&s), [state("M2", LayerState::ALL)]);
}
-2
View File
@@ -4,7 +4,6 @@ mod annotate_options;
mod annotative;
mod arc_ctrl_direction;
mod array_commands;
mod array_key_point;
mod assoc_array;
mod attdef_command;
mod attdisp_attsync;
@@ -79,7 +78,6 @@ mod join_close;
mod json_param_validation;
mod layer_cmdline;
mod layer_merge_delete;
mod layer_state_cmdline;
mod layoff_repeat;
mod layout_prompts;
mod leader_command;
+7 -129
View File
@@ -76,135 +76,13 @@ fn rename_prompts_type_old_and_new_name() {
assert!(d.block("Pump").is_some() && d.layer("New").is_some() && d.layer("Old").is_none(), "{:?}", s.log);
assert_eq!(insert_targets(d), ["Assy", "Pump", "Pump", "Pump"]);
assert_eq!(d.model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 1);
// A type CADCraft lacks reads both names and reports.
let n = s.log.len();
s.script("-RENAME M a b\nLINE 0,0 2,0\n\n").unwrap();
// An unknown old name re-prompts; a type CADCraft lacks reads both names and reports.
s.script("-RENAME LA Missing\nNew\nNewer\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.log[n..].iter().any(|l| l.contains("Renaming a material is not available yet.")), "{:?}", &s.log[n..]);
assert!(s.doc().unwrap().layer("Newer").is_some());
let n = s.log.len();
s.script("-RENAME VP a b\nLINE 0,0 2,0\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.log[n..].iter().any(|l| l.contains("not available yet")), "{:?}", &s.log[n..]);
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 2);
}
/// What `script` adds to the log; the command has ended.
fn said(s: &mut Session, script: &str) -> Vec<String> {
let n = s.log.len();
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
s.log[n..].to_vec()
}
fn says(log: &[String], text: &str) -> bool {
log.iter().any(|l| l.contains(text))
}
#[test]
fn rename_ends_on_a_name_it_cannot_take_with_autocads_messages() {
// AutoCAD 2024 (accoreconsole, measured, the same for blocks, dimension styles, layers,
// linetypes, text styles, UCSs and views): `Cannot find layer "X".` for an old name that
// doesn't exist, `A layer named "X" already exists.` and `*Invalid*` for a new name that does,
// `Invalid layer name.` for one it can't take; each ends the command.
let mut s = drawing();
for name in ["A1", "A2"] {
s.execute("layer.new", &json!({ "name": name })).unwrap();
}
let log = said(&mut s, "-RENAME LA NOSUCH\nLINE 0,0 3,0\n\n");
assert!(says(&log, "Cannot find layer \"NOSUCH\"."), "{log:?}");
// The command ended there: the next input started LINE.
assert_eq!(s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count(), 1);
let log = said(&mut s, "-RENAME LA A1 A2\n");
assert!(says(&log, "A layer named \"A2\" already exists.") && says(&log, "*Invalid*"), "{log:?}");
let log = said(&mut s, "-RENAME LA A1 X<Y\n");
assert!(says(&log, "Invalid layer name."), "{log:?}");
// No new name at all is an invalid one too.
s.cmdline("-RENAME LA A1").unwrap();
let n = s.log.len();
s.cmdline("").unwrap();
assert!(s.running.is_none() && says(&s.log[n..], "Invalid layer name."), "{:?}", &s.log[n..]);
assert!(s.doc().unwrap().layer("A1").is_some());
said(&mut s, "-RENAME LA A1 B1\n");
assert!(s.doc().unwrap().layer("B1").is_some() && s.doc().unwrap().layer("A1").is_none());
// The old name in another case than stored, and the new name as typed: a rename to that case
// (AutoCAD 2024, measured: LAY1 typed lay1, new name lay1, gives lay1).
said(&mut s, "-RENAME LA b1 b1\n");
assert!(s.doc().unwrap().layers.iter().any(|l| l.name == "b1"));
// Old names AutoCAD 2024 won't rename (measured), each ending the command before the new name.
let lines = |s: &Session| s.doc().unwrap().model.iter().filter(|e| matches!(e.kind, EntityKind::Line(_))).count();
for (script, message) in [
("-RENAME LA 0\n", "Cannot rename layer \"0\"."),
("-RENAME LT continuous\n", "Cannot rename linetype \"continuous\"."),
("-RENAME LT ByLayer\n", "Invalid linetype name."),
("-RENAME LT byblock\n", "Invalid linetype name."),
("-RENAME LT CONTINUOUS\n", "Cannot rename linetype \"CONTINUOUS\"."),
("-RENAME B *Model_Space\n", "Invalid block name."),
("-RENAME B *U1\n", "Invalid block name."),
] {
let n = lines(&s);
let log = said(&mut s, &format!("{script}LINE 0,0 4,0\n\n"));
assert!(says(&log, message), "{script}: {log:?}");
assert_eq!(says(&log, "*Invalid*"), message.starts_with("Cannot"), "{script}: {log:?}");
assert_eq!(lines(&s), n + 1, "{script}: the next input starts a command");
}
// A UCS is "ucs" in the prompts and in "A ucs named", "UCS" in the other two.
for name in ["U1", "U2"] {
let ucs = cadcraft_engine::doc::Ucs { name: name.into(), origin: Default::default(), x_axis: Default::default(), y_axis: Default::default() };
s.doc_mut().unwrap().ucss.push(ucs);
}
s.cmdline("-RENAME U").unwrap();
assert!(s.prompt_text().contains("Enter old ucs name"), "{}", s.prompt_text());
s.cancel();
assert!(says(&said(&mut s, "-RENAME U NOSUCH\n"), "Cannot find UCS \"NOSUCH\"."));
assert!(says(&said(&mut s, "-RENAME U U1 U2\n"), "A ucs named \"U2\" already exists."));
assert!(says(&said(&mut s, "-RENAME U U1 X<Y\n"), "Invalid UCS name."));
}
#[test]
fn rename_takes_a_saved_viewport_configuration() {
// AutoCAD 2024 (measured): -RENAME VPort renames a saved configuration, every tile of it, old
// name in any case, and to another case of its own name; "*ACTIVE" (old or new), names with
// characters AutoCAD refuses and names already used are refused as for the other types.
let mut s = Session::new();
s.execute("-vports", &json!({ "option": "2", "arrangement": "vertical" })).unwrap();
s.execute("-vports", &json!({ "option": "save", "name": "CFG1" })).unwrap();
s.execute("-vports", &json!({ "option": "save", "name": "CFG3" })).unwrap();
let names = |s: &Session| -> Vec<(String, usize)> { s.doc().unwrap().vports.iter().map(|v| (v.name.clone(), v.tiles.len())).collect() };
said(&mut s, "-RENAME VP cfg1 CFG2\n");
assert_eq!(names(&s), [("*Active".to_string(), 2), ("CFG2".to_string(), 2), ("CFG3".to_string(), 2)]);
for (script, message) in [
// A refused old name ends the command before the new name is asked.
("-RENAME VP NOSUCH\n", "Cannot find viewport configuration \"NOSUCH\"."),
("-RENAME VP *ACTIVE\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 *ACTIVE\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 A<B\n", "Invalid viewport configuration name."),
("-RENAME VP CFG2 CFG3\n", "A viewport configuration named \"CFG3\" already exists."),
] {
let log = said(&mut s, script);
assert!(says(&log, message), "{script}: {log:?}");
// "*Invalid*" follows a name already used only.
assert_eq!(says(&log, "*Invalid*"), message.ends_with("already exists."), "{script}: {log:?}");
}
// No new name at all is an invalid one too (measured: CFG1, then Enter).
s.cmdline("-RENAME VP CFG2").unwrap();
let n = s.log.len();
s.cmdline("").unwrap();
assert!(s.running.is_none() && says(&s.log[n..], "Invalid viewport configuration name."), "{:?}", &s.log[n..]);
assert_eq!(names(&s), [("*Active".to_string(), 2), ("CFG2".to_string(), 2), ("CFG3".to_string(), 2)]);
said(&mut s, "-RENAME VP CFG2 cfg2\n");
assert_eq!(names(&s), [("*Active".to_string(), 2), ("cfg2".to_string(), 2), ("CFG3".to_string(), 2)]);
// The new name is compared with the stored one, not with the old name as typed (measured:
// CFG1 typed cfg1 to cfg1 gives cfg1; typed cfg1 to CFG1 changes nothing).
said(&mut s, "-RENAME VP CFG2 CFG2\n");
assert_eq!(names(&s)[1].0, "CFG2");
said(&mut s, "-RENAME VP cfg2 CFG2\n");
assert_eq!(names(&s)[1].0, "CFG2");
said(&mut s, "-RENAME VP cfg2 cfg2\n");
assert_eq!(names(&s)[1].0, "cfg2");
// The JSON form too, which never takes the configuration shown, and refuses a name already
// used (in any case) or with a character AutoCAD refuses, as for the other tables.
s.execute("rename", &json!({ "table": "vport", "from": "CFG3", "to": "Pair" })).unwrap();
assert_eq!(names(&s)[2].0, "Pair");
for to in ["Shown", "CFG2", "A<B"] {
let from = if to == "Shown" { "*Active" } else { "Pair" };
assert!(s.execute("rename", &json!({ "table": "vport", "from": from, "to": to })).is_err(), "{from} to {to}");
}
s.execute("rename", &json!({ "table": "vport", "from": "pair", "to": "PAIR" })).unwrap();
assert_eq!(names(&s), [("*Active".to_string(), 2), ("cfg2".to_string(), 2), ("PAIR".to_string(), 2)]);
}
-294
View File
@@ -1,294 +0,0 @@
//! Saved layer states as AutoCAD keeps them: the LAYER table's extension dictionary holds an
//! `ACAD_LAYERSTATES` dictionary of one XRECORD per state. Measured in AutoCAD 2024 (DXFOUT of
//! states saved with -LAYER stAte), an XRECORD holds `280 1`, the mask (91), a text (301: empty
//! as -LAYER saves it; AutoCAD keeps one a file holds through restore and DXFOUT), `290 0` and
//! the current layer's name (302), then for each layer its LAYER handle (330),
//! flags (90: 1 off, 2 frozen, 4 locked, 8 plotted, 16 frozen in new viewports), colour index
//! (62), lineweight (370), for a layer of an xref 93 (0 for a newly attached one; a file can hold
//! 1, whose meaning isn't measured), LTYPE handle (331), plot style (in a drawing of colour-dependent
//! plot styles the name `Color_N` in group 1, N its colour index; of named ones the handle of its
//! placeholder object in group 390), transparency (440: 0 opaque, else `0x02000000 | alpha`) and,
//! for a true colour, 92 (`0xC2RRGGBB`).
//!
//! States AutoCAD's dictionary can't hold stay in CADCraft's own record (`CADCRAFT_LAYERSTATES`):
//! the view layer snapshots (`*VIEW name`), and a name that repeats an earlier one in another
//! case: AutoCAD 2024 opens the entries `S` and `s` of one dictionary as one state, named as the
//! first entry and holding the last one's record (measured), and so does the reader here.
use std::collections::{HashMap, HashSet};
use cadcraft_color::{Color, Rgb};
use cadcraft_doc::{Layer, LayerState, Lineweight};
use craft_dxf::Tag;
use crate::dxf_ext::{transparency_from_dxf, transparency_to_dxf};
/// The key of the states dictionary in the LAYER table's extension dictionary.
pub(crate) const KEY: &str = "ACAD_LAYERSTATES";
/// The prefix of a true colour in group 92.
const TRUE_COLOR: u32 = 0xC200_0000;
/// The bytes of layers the states of one file may copy (CWE-400). Each entry of a state is a copy
/// of the drawing's layer, its names and description included, so without a bound a small file
/// naming one layer with a long description in a great many entries would take gigabytes.
pub(crate) const MAX_COPIED_BYTES: usize = 256 << 20;
/// Which of `states` go into AutoCAD's dictionary (the others into CADCraft's record).
pub(crate) fn in_acad(states: &[LayerState]) -> Vec<bool> {
let mut seen: HashSet<String> = HashSet::with_capacity(states.len());
states.iter().map(|st| !st.name.trim().is_empty() && !st.name.starts_with('*') && seen.insert(st.name.to_lowercase())).collect()
}
/// The states CADCraft's own record keeps (those [`in_acad`] leaves out).
pub(crate) fn own(states: &[LayerState]) -> Vec<LayerState> {
states.iter().zip(in_acad(states)).filter(|(_, acad)| !acad).map(|(st, _)| st.clone()).collect()
}
/// Handles of the objects that hold the drawing's states in AutoCAD's form.
#[derive(Default)]
pub(crate) struct Plan {
/// The LAYER table, which owns the extension dictionary.
pub table: String,
/// The LAYER table's extension dictionary.
pub xdict: String,
/// The `ACAD_LAYERSTATES` dictionary.
dict: String,
/// (index in the drawing's states, XRECORD handle).
records: Vec<(usize, String)>,
}
impl Plan {
pub fn new(states: &[LayerState], mut handle: impl FnMut() -> String) -> Self {
let acad = in_acad(states);
if !acad.contains(&true) {
return Plan::default();
}
let xdict = handle();
let dict = handle();
let records = acad.iter().enumerate().filter(|(_, a)| **a).map(|(i, _)| (i, handle())).collect();
Plan { table: String::new(), xdict, dict, records }
}
pub fn is_empty(&self) -> bool {
self.records.is_empty()
}
}
/// What the state objects need from the rest of the file.
pub(crate) struct Refs<'a> {
/// Upper-case layer name → LAYER record handle.
pub layers: &'a HashMap<String, String>,
/// Upper-case linetype name → LTYPE record handle.
pub ltypes: &'a HashMap<String, String>,
/// Upper-case plot style name → its placeholder object's handle.
pub pstyles: &'a HashMap<String, String>,
/// Plot styles by colour (`$PSTYLEMODE` 1): the plot style name is `Color_N`.
pub colour_dependent: bool,
}
/// The objects of plan `p`: the extension dictionary, the `ACAD_LAYERSTATES` dictionary and one
/// XRECORD per state. Layers the drawing no longer has are left out of a state (AutoCAD names
/// layers by handle).
pub(crate) fn objects(p: &Plan, states: &[LayerState], refs: &Refs) -> Vec<Tag> {
let mut t = Vec::new();
if p.is_empty() {
return t;
}
t.extend([Tag::s(0, "DICTIONARY"), Tag::s(5, &p.xdict), Tag::s(330, &p.table), Tag::s(100, "AcDbDictionary"), Tag::i(280, 1), Tag::i(281, 1)]);
t.extend([Tag::s(3, KEY), Tag::s(360, &p.dict)]);
t.extend([Tag::s(0, "DICTIONARY"), Tag::s(5, &p.dict), Tag::s(102, "{ACAD_REACTORS"), Tag::s(330, &p.xdict), Tag::s(102, "}")]);
t.extend([Tag::s(330, &p.xdict), Tag::s(100, "AcDbDictionary"), Tag::i(281, 1)]);
let planned = || p.records.iter().filter_map(|(i, h)| Some((states.get(*i)?, h)));
for (st, h) in planned() {
t.extend([Tag::s(3, &st.name), Tag::s(350, h)]);
}
for (st, h) in planned() {
t.extend([Tag::s(0, "XRECORD"), Tag::s(5, h), Tag::s(102, "{ACAD_REACTORS"), Tag::s(330, &p.dict), Tag::s(102, "}"), Tag::s(330, &p.dict)]);
t.extend([Tag::s(100, "AcDbXrecord"), Tag::i(280, 1), Tag::i(91, i64::from(st.mask)), Tag::s(301, &st.description), Tag::i(290, 0)]);
t.push(Tag::s(302, &st.current));
for l in &st.layers {
if let Some(lh) = refs.layers.get(&l.name.to_ascii_uppercase()) {
layer(&mut t, l, lh, refs);
}
}
}
t
}
/// One layer of a state's XRECORD.
fn layer(t: &mut Vec<Tag>, l: &Layer, handle: &str, refs: &Refs) {
let flags = i64::from(!l.on) | i64::from(l.frozen) << 1 | i64::from(l.locked) << 2 | i64::from(l.plot) << 3 | i64::from(l.vp_freeze_new) << 4;
let aci = match l.color {
Color::True(rgb) => i64::from(cadcraft_color::nearest_aci(rgb)),
c => i64::from(c.to_aci()).clamp(1, 255),
};
t.extend([Tag::s(330, handle), Tag::i(90, flags), Tag::i(62, aci), Tag::i(370, i64::from(l.lineweight.to_dxf()))]);
if crate::dxf_xref::dependent(&l.name) {
t.push(Tag::i(93, 0));
}
// A linetype the drawing no longer has: Continuous, which every drawing has.
if let Some(lt) = refs.ltypes.get(&l.linetype.to_ascii_uppercase()).or_else(|| refs.ltypes.get("CONTINUOUS")) {
t.push(Tag::s(331, lt));
}
if refs.colour_dependent {
t.push(Tag::s(1, format!("Color_{aci}")));
} else if let Some(ps) = refs.pstyles.get(&l.plot_style.trim().to_ascii_uppercase()).or_else(|| refs.pstyles.get("NORMAL")) {
t.push(Tag::s(390, ps));
}
t.push(Tag::i(440, if l.transparency == 0 { 0 } else { transparency_to_dxf(l.transparency) }));
if let Color::True(rgb) = l.color {
t.push(Tag::i(92, i64::from(i32::from_be_bytes((TRUE_COLOR | rgb.to_u32()).to_be_bytes()))));
}
}
/// What a state's handles name in the drawing being read.
pub(crate) struct Lookup<'a> {
/// The drawing's layer a LAYER handle names: a state's layer starts as a copy of it (what the
/// state doesn't hold, such as the description, is the drawing's).
pub layer: &'a dyn Fn(&str) -> Option<Layer>,
/// The linetype an LTYPE handle names.
pub ltype: &'a dyn Fn(&str) -> Option<String>,
/// The plot style a placeholder handle names.
pub pstyle: &'a dyn Fn(&str) -> Option<String>,
/// Plot styles by colour: group 1 (`Color_N`) says nothing the layer's colour doesn't.
pub colour_dependent: bool,
}
/// The state `name` from its XRECORD's groups. A layer whose record is gone (AutoCAD keeps a
/// purged layer's entry, measured) is skipped. A layer named in two entries is in the state once,
/// the later entry's groups over the earlier one's, as restoring both in turn did: AutoCAD 2024
/// restores the later one (measured with entries that each set every property). Each copy of a
/// layer is charged to `budget`, the file's [`MAX_COPIED_BYTES`]; once it is spent, the entries
/// left are left out.
pub(crate) fn read(name: &str, tags: &[Tag], lookup: &Lookup, budget: &mut usize) -> LayerState {
let mut st = LayerState { name: name.to_string(), ..LayerState::default() };
// The data follows the subclass marker (an XRECORD without one holds none).
let start = tags.iter().position(|t| t.code == 100 && t.str().trim() == "AcDbXrecord").map_or(tags.len(), |i| i + 1);
let body = tags.get(start..).unwrap_or_default();
let first = body.iter().position(|t| t.code == 330).unwrap_or(body.len());
for t in body.get(..first).unwrap_or_default() {
match t.code {
91 => st.mask = t.str().trim().parse::<u32>().unwrap_or(LayerState::ALL),
301 => st.description = t.str(),
302 => st.current = t.str(),
_ => {}
}
}
let rest = body.get(first..).unwrap_or_default();
// The index in the state of each layer by its LAYER handle.
let mut index: HashMap<String, usize> = HashMap::new();
let mut at = 0;
while let Some(group) = rest.get(at..) {
let Some(head) = group.first() else { break };
let len = group.iter().skip(1).position(|t| t.code == 330).map_or(group.len(), |n| n + 1);
at += len;
let groups = group.get(1..len).unwrap_or_default();
let key = head.str().trim().to_ascii_uppercase();
if let Some(slot) = index.get(&key).and_then(|&i| st.layers.get_mut(i)) {
entry(slot, groups, lookup);
} else if let Some(mut l) = (lookup.layer)(&head.str()) {
let Some(left) = budget.checked_sub(cost(&l)) else { break };
*budget = left;
entry(&mut l, groups, lookup);
index.insert(key, st.layers.len());
st.layers.push(l);
}
}
st
}
/// The bytes a copy of layer `l` takes.
fn cost(l: &Layer) -> usize {
std::mem::size_of::<Layer>() + l.name.len() + l.linetype.len() + l.description.len() + l.plot_style.len()
}
/// A layer's properties from the groups after its handle.
fn entry(l: &mut Layer, groups: &[Tag], lookup: &Lookup) {
let int = |t: &Tag| t.str().trim().parse::<i64>().ok();
let mut true_color = None;
for t in groups {
match t.code {
90 => {
if let Some(f) = int(t) {
(l.on, l.frozen, l.locked, l.plot, l.vp_freeze_new) = (f & 1 == 0, f & 2 != 0, f & 4 != 0, f & 8 != 0, f & 16 != 0);
}
}
62 => {
if let Some(c) = int(t).map(i64::abs).and_then(|c| u8::try_from(c).ok()).filter(|c| *c >= 1) {
l.color = Color::Index(c);
}
}
92 => true_color = int(t).and_then(|v| u32::try_from(v & 0xFFFF_FFFF).ok()).filter(|v| v & 0xFF00_0000 == TRUE_COLOR),
370 => {
if let Some(w) = int(t).and_then(|w| i16::try_from(w).ok()) {
l.lineweight = Lineweight::from_dxf(w);
}
}
331 => {
if let Some(lt) = (lookup.ltype)(&t.str()) {
l.linetype = lt;
}
}
390 => {
if let Some(ps) = (lookup.pstyle)(&t.str()) {
l.plot_style = ps;
}
}
1 if !lookup.colour_dependent => l.plot_style = t.str(),
440 => {
if let Some(v) = int(t) {
l.transparency = transparency_from_dxf(v).unwrap_or(0);
}
}
_ => {}
}
}
if let Some(v) = true_color {
l.color = Color::True(Rgb::from_u32(v & 0x00FF_FFFF));
}
}
#[cfg(test)]
mod tests {
use super::*;
/// A state's XRECORD groups with an entry per (layer handle, colour index).
fn tags(entries: &[(&str, i64)]) -> Vec<Tag> {
let mut t = vec![Tag::s(100, "AcDbXrecord"), Tag::i(280, 1), Tag::i(91, 2047), Tag::s(302, "0")];
for (h, aci) in entries {
t.extend([Tag::s(330, *h), Tag::i(90, 8)]);
// 0: no colour group.
if *aci != 0 {
t.push(Tag::i(62, *aci));
}
}
t
}
#[test]
fn a_layer_named_twice_takes_its_last_entry_and_copies_stop_at_the_budget() {
let layer = |h: &str| match h {
"A1" => Some(Layer::new("A")),
"B1" => Some(Layer::new("B")),
_ => None,
};
let none = |_: &str| None::<String>;
let lookup = Lookup { layer: &layer, ltype: &none, pstyle: &none, colour_dependent: true };
let colours = |st: &LayerState| st.layers.iter().map(|l| (l.name.clone(), l.color)).collect::<Vec<_>>();
// AutoCAD 2024 restores the last of two entries of one layer (measured: green, then blue,
// restores blue); it stays in the first one's place. A later entry without a colour keeps
// the earlier one's, as restoring both in turn did.
let mut budget = MAX_COPIED_BYTES;
let st = read("S", &tags(&[("A1", 3), ("B1", 2), ("A1", 5), ("B1", 0)]), &lookup, &mut budget);
assert_eq!(colours(&st), [("A".to_string(), Color::Index(5)), ("B".to_string(), Color::Index(2))]);
// Each new copy is charged (a repeated entry copies nothing); past the budget the rest of
// the entries, and of the file's states, are left out.
let one = cost(&Layer::new("A"));
let mut budget = one;
let st = read("S", &tags(&[("A1", 3), ("A1", 4), ("B1", 5)]), &lookup, &mut budget);
assert_eq!((colours(&st), budget), (vec![("A".to_string(), Color::Index(4))], 0));
let st = read("T", &tags(&[("B1", 2)]), &lookup, &mut budget);
assert!(st.layers.is_empty());
}
}
+21 -77
View File
@@ -36,11 +36,10 @@ const MODELLED_KEYS: &[&str] = &[
"ACAD_IMAGE_VARS",
];
/// Extension dictionary entries not kept raw: dimension associativity and the LAYER table's layer
/// states (CADCraft reads and rewrites them), draw order and annotation scale contexts (written
/// from their own models by the changes that model them; stale copies would contradict the
/// drawing).
const MODELLED_XDICT_KEYS: &[&str] = &["ACAD_DIMASSOC", "ACAD_LAYERSTATES", "ACAD_SORTENTS", "ACDBCONTEXTDATAMANAGER"];
/// Extension dictionary entries not kept raw: dimension associativity (CADCraft reads and
/// rewrites it), draw order and annotation scale contexts (written from their own models by the
/// changes that model them; stale copies would contradict the drawing).
const MODELLED_XDICT_KEYS: &[&str] = &["ACAD_DIMASSOC", "ACAD_SORTENTS", "ACDBCONTEXTDATAMANAGER"];
/// Applications whose xdata CADCraft reads and writes itself. `ACAD` holds dimension overrides
/// (DSTYLE) on dimensions and dimension styles; elsewhere it is kept.
@@ -990,7 +989,20 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
let root = objects.first().filter(|(k, _, _)| is_dictionary(k)).map(|(_, s, _)| *s);
let root_keys: HashSet<String> =
objects.iter().find(|(_, s, _)| Some(*s) == root).map(|(_, _, t)| entries(t).into_iter().map(|(k, _)| up(&k)).collect()).unwrap_or_default();
let (mut attached, merged) = kept_dictionaries(f, &xd, &recs, tags);
// Extension dictionaries that go on a written record (one without its own).
let mut block = String::new();
let mut attached: HashSet<String> = HashSet::new();
for r in &recs {
if r.kind == "BLOCK" {
block = up(&val(body(r), 2).unwrap_or_default());
}
if let Some(x) = extra_for(f, &xd, r, body(r), &block)
&& let Some(xd) = x.xdict
&& head(body(r)).xdict.is_none()
{
attached.insert(xd.hex());
}
}
for (_, t) in planned.values().flatten() {
let x = head(t.get(1..).unwrap_or(&[])).handle.and_then(|h| handle(&h)).and_then(|h| entity_extra(f, &xd, h));
attached.extend(x.and_then(|x| x.xdict).map(Handle::hex));
@@ -1038,7 +1050,7 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
if nod.contains(&owner) {
break dict_entries.get(&cur).is_some_and(|k| !root_keys.contains(&up(k))) && root.is_some();
}
if attached.contains(&cur) || merged.contains_key(&cur) {
if attached.contains(&cur) {
break true;
}
break unknown.contains(&owner) && written.contains(&owner);
@@ -1056,13 +1068,6 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
alive.insert(o.handle.hex(), format!("{next:X}"));
next = next.saturating_add(1);
}
// A merged dictionary is not written: what pointed at it points at the written one.
for (kept, own) in &merged {
if let Some(h) = alive.get_mut(kept) {
h.clone_from(own);
}
}
let merged_into: HashMap<String, &ForeignObject> = merged.iter().filter_map(|(kept, own)| Some((own.clone(), *objs.get(kept)?))).collect();
let entities: HashSet<String> = all_entities(d).map(|e| e.handle.hex()).filter(|h| written.contains(h)).collect();
let map = Map { f, alive, raw: objs.keys().cloned().collect(), roles, entities };
let mut out: Vec<Tag> = Vec::with_capacity(tags.len() + f.objects.iter().map(|o| o.tags.len() + 1).sum::<usize>());
@@ -1076,7 +1081,7 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
continue;
}
if r.kind == "ENDSEC" && r.sec == "OBJECTS" {
for o in f.objects.iter().filter(|o| map.alive.contains_key(&o.handle.hex()) && !merged.contains_key(&o.handle.hex())) {
for o in f.objects.iter().filter(|o| map.alive.contains_key(&o.handle.hex())) {
let number = is_proxy(&o.kind).then(|| renumber(class_number(o.tags.iter().map(|r| (r.code, r.value.as_str()))))).flatten();
match number {
Some(n) => {
@@ -1100,15 +1105,11 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
}
out.extend(tags.get(r.start).cloned());
let x = extra_for(f, &xd, r, b, &block);
let joined = joined_into(&merged_into, b);
if x.is_none() && Some(r.start) != root && joined.is_none() {
if x.is_none() && Some(r.start) != root {
out.extend(b.iter().cloned());
continue;
}
record(&map, r, b, x.as_deref(), None, Some(r.start) == root, &mut out);
if let Some(kept) = joined {
join_entries(&map, b, kept, &mut out);
}
}
add_appids(&mut out);
let top = max_handle(&out).saturating_add(1);
@@ -1120,32 +1121,6 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
*tags = out;
}
/// Kept extension dictionaries of written records: those that go on a record without its own,
/// and those whose entries join the one the writer gave a table (the LAYER table's, holding the
/// layer states) as kept dictionary → the written one.
fn kept_dictionaries(f: &Foreign, xd: &XdataOf, recs: &[Rec], tags: &[Tag]) -> (HashSet<String>, HashMap<String, String>) {
let body = |r: &Rec| tags.get(r.start + 1..r.end).unwrap_or(&[]);
let mut block = String::new();
let mut attached: HashSet<String> = HashSet::new();
let mut merged: HashMap<String, String> = HashMap::new();
for r in recs {
if r.kind == "BLOCK" {
block = up(&val(body(r), 2).unwrap_or_default());
}
let Some(kept) = extra_for(f, xd, r, body(r), &block).and_then(|x| x.xdict) else { continue };
match head(body(r)).xdict {
None => {
attached.insert(kept.hex());
}
Some(own) if r.sec == "TABLES" => {
merged.insert(kept.hex(), own);
}
Some(_) => {}
}
}
(attached, merged)
}
/// Complete source tables keep positional identities even when names repeat.
fn proxy_class_number(f: &Foreign, numbers: &HashMap<String, i64>, old: Option<i64>) -> Option<i64> {
if f.complete_class_table {
@@ -1377,37 +1352,6 @@ fn record(map: &Map, r: &Rec, b: &[Tag], x: Option<&ForeignExtra>, unknown: Opti
}
}
/// The kept dictionary whose entries join written dictionary `b`, if any.
fn joined_into<'a>(merged_into: &HashMap<String, &'a ForeignObject>, b: &[Tag]) -> Option<&'a ForeignObject> {
if merged_into.is_empty() {
return None;
}
head(b).handle.and_then(|h| merged_into.get(&h).copied())
}
/// The entries of kept dictionary `kept` that written dictionary `b` doesn't have (by key, without
/// regard to case), appended to it with their handles remapped; entries whose object is gone are
/// left out.
fn join_entries(map: &Map, b: &[Tag], kept: &ForeignObject, out: &mut Vec<Tag>) {
let has = |key: &str| b.iter().any(|t| t.code == 3 && up(&t.str()) == up(key));
let mut key: Option<&str> = None;
for t in kept.tags.iter().take_while(|t| t.code < 1000) {
match t.code {
3 => key = Some(t.value.as_str()),
350 | 360 => {
if let Some(k) = key.take()
&& !has(k)
&& let Some(h) = map.get(&t.value).filter(|h| h != "0")
{
out.push(Tag::s(3, k));
out.push(Tag::s(t.code, h));
}
}
_ => {}
}
}
}
/// Kept xdata of applications the record doesn't already carry, handles remapped.
fn xdata(map: &Map, x: &ForeignExtra, own: &HashSet<String>, out: &mut Vec<Tag>) {
let mut skip = false;
+5 -96
View File
@@ -8,14 +8,10 @@ use super::{Drawing, EntityKind, Group, Handle, HashMap, MLeaderStyle, PageSetup
pub(super) struct Objects {
/// Dictionary entry handle (upper case) → entry name.
names: HashMap<String, String>,
/// (dictionary handle, entry handle), both upper case, in the order the dictionaries list them.
entry_order: Vec<(String, String)>,
/// SCALE objects (the annotation scale list), in file order.
scales: Vec<cadcraft_doc::AnnoScale>,
/// XRECORD handle (upper case) → its groups.
xrecords: HashMap<String, Vec<Tag>>,
/// XRECORD handles in file order.
xrecord_order: Vec<String>,
/// TABLESTYLE objects: (handle, groups).
table_styles: Vec<(String, Vec<Tag>)>,
/// DIMASSOC objects.
@@ -54,11 +50,7 @@ impl Objects {
if let Some(n) = name.take()
&& self.names.len() < MAX_OBJECTS
{
let entry = t.str().trim().to_ascii_uppercase();
if self.entry_order.len() < MAX_OBJECTS {
self.entry_order.push((h.clone(), entry.clone()));
}
self.names.insert(entry, n);
self.names.insert(t.str().trim().to_ascii_uppercase(), n);
}
}
_ => {}
@@ -66,9 +58,7 @@ impl Objects {
}
}
"XRECORD" if self.xrecords.len() < MAX_OBJECTS => {
if self.xrecords.insert(h.clone(), tags.to_vec()).is_none() {
self.xrecord_order.push(h);
}
self.xrecords.insert(h, tags.to_vec());
}
"TABLESTYLE" if self.table_styles.len() < MAX_OBJECTS => self.table_styles.push((h, tags.to_vec())),
"DIMASSOC" if self.dimassocs.len() < MAX_OBJECTS => self.dimassocs.push(tags.to_vec()),
@@ -90,65 +80,6 @@ impl Objects {
}
}
/// The layer states of the LAYER table's `ACAD_LAYERSTATES` dictionary (its XRECORDs, in file
/// order), read with the drawing's layers and linetypes. Entries whose names differ only in case
/// are one state, as AutoCAD 2024 opens them (measured with `S` and `s` in both orders): named as
/// the first of them in the dictionary, holding the last one's record, where the first of their
/// records comes in the file.
fn acad_layer_states(&self, d: &Drawing, rx: &Rx) -> Vec<cadcraft_doc::LayerState> {
let dicts: std::collections::HashSet<&str> =
self.names.iter().filter(|(_, n)| n.eq_ignore_ascii_case(crate::dxf_layer_states::KEY)).map(|(h, _)| h.as_str()).collect();
if dicts.is_empty() {
return Vec::new();
}
let mut by_name: HashMap<String, &cadcraft_doc::Layer> = HashMap::with_capacity(d.layers.len());
for l in &d.layers {
by_name.entry(l.name.to_ascii_lowercase()).or_insert(l);
}
let layer_of =
|h: &str| rx.layers.get(&h.trim().to_ascii_uppercase()).and_then(|n| by_name.get(&n.to_ascii_lowercase())).map(|l| (*l).clone());
let ltype_of = |h: &str| rx.ltypes.get(&h.trim().to_ascii_uppercase()).cloned();
let pstyle_of = |h: &str| rx.pstyles.get(&h.trim().to_ascii_uppercase()).cloned();
let lookup = crate::dxf_layer_states::Lookup {
layer: &layer_of,
ltype: &ltype_of,
pstyle: &pstyle_of,
colour_dependent: d.header.i64("PSTYLEMODE", 1) != 0,
};
let ours = |tags: &[Tag]| owner(tags).is_some_and(|o| dicts.contains(o.as_str()));
// By lower-case name: the first entry's name and the last entry's record, in dictionary order.
let mut first: HashMap<String, &String> = HashMap::new();
let mut last: HashMap<String, &Vec<Tag>> = HashMap::new();
for (dict, h) in &self.entry_order {
if dicts.contains(dict.as_str())
&& let (Some(name), Some(tags)) = (self.names.get(h), self.xrecords.get(h))
&& ours(tags)
{
first.entry(name.to_ascii_lowercase()).or_insert(name);
last.insert(name.to_ascii_lowercase(), tags);
}
}
let mut out = Vec::new();
let mut taken = std::collections::HashSet::new();
let mut budget = crate::dxf_layer_states::MAX_COPIED_BYTES;
for h in &self.xrecord_order {
let (Some(tags), Some(name)) = (self.xrecords.get(h), self.names.get(h)) else { continue };
if out.len() >= crate::dxf_ext::MAX_LAYER_STATES {
break;
}
if !ours(tags) {
continue;
}
let key = name.to_ascii_lowercase();
if taken.insert(key.clone()) {
let name = first.get(&key).copied().unwrap_or(name);
let tags = last.get(&key).copied().unwrap_or(tags);
out.push(crate::dxf_layer_states::read(name, tags, &lookup, &mut budget));
}
}
out
}
/// The text of the CADCraft XRECORD stored under `key` in a dictionary (its 1/3 strings).
pub(super) fn xrecord_text(&self, key: &str) -> Option<String> {
let h = self.names.iter().find(|(_, n)| n.as_str() == key).map(|(h, _)| h)?;
@@ -277,18 +208,10 @@ impl Objects {
if let Some(p) = self.xrecord_text(crate::dxf_ext::ANNOTATION_KEY).and_then(|t| crate::dxf_ext::parse_anno(&t)) {
crate::dxf_ext::apply_anno(d, p);
}
// Saved layer states: AutoCAD's, then those of CADCraft's own record (a file of an
// earlier version keeps them all there) that AutoCAD's doesn't hold.
let mut states = self.acad_layer_states(d, rx);
if let Some(own) = self.xrecord_text(crate::dxf_ext::LAYER_STATES_KEY).and_then(|t| crate::dxf_ext::parse_layer_states(&t)) {
let mut names: std::collections::HashSet<String> = states.iter().map(|s| s.name.clone()).collect();
for st in own {
if states.len() < crate::dxf_ext::MAX_LAYER_STATES && names.insert(st.name.clone()) {
states.push(st);
}
}
// Saved layer states.
if let Some(states) = self.xrecord_text(crate::dxf_ext::LAYER_STATES_KEY).and_then(|t| crate::dxf_ext::parse_layer_states(&t)) {
d.layer_states = states;
}
d.layer_states = states;
// The drawing's plot style tables.
if let Some(tables) = self.xrecord_text(crate::dxf_ext::PLOT_STYLES_KEY).and_then(|t| crate::dxf_ext::parse_plot_styles(&t)) {
d.plot_style_tables = tables;
@@ -308,20 +231,6 @@ impl Objects {
}
}
/// An object's owner (its first group 330 outside a `102` group), upper case.
fn owner(tags: &[Tag]) -> Option<String> {
let mut inside = false;
for t in tags {
match t.code {
102 => inside = t.str().trim().starts_with('{'),
330 if !inside => return Some(t.str().trim().to_ascii_uppercase()),
100 => return None,
_ => {}
}
}
None
}
/// Page setup from a LAYOUT object's AcDbPlotSettings fields (sizes and margins in mm).
pub(super) fn page_setup(t: &T) -> PageSetup {
let mut p = PageSetup::default();
-2
View File
@@ -58,8 +58,6 @@ pub(super) struct Ctx {
pub(super) frozen_341: bool,
/// MTEXT columns as the legacy groups 75..79 even from R2018 (the groups AutoLISP lists).
pub(super) legacy_columns: bool,
/// Saved layer states in AutoCAD's form (the LAYER table's extension dictionary).
pub(super) layer_states: crate::dxf_layer_states::Plan,
}
impl Ctx {
-8
View File
@@ -143,18 +143,10 @@ pub(super) fn vport_table(w: &mut W, d: &Drawing, ext: Bounds2) {
}
pub(super) fn table_head(w: &mut W, name: &str, count: usize) -> String {
table_head_x(w, name, count, None)
}
/// A table's head, with its extension dictionary `xdict` when it has one.
pub(super) fn table_head_x(w: &mut W, name: &str, count: usize, xdict: Option<&str>) -> String {
let h = w.h();
w.s(0, "TABLE");
w.s(2, name);
w.s(5, h.clone());
if let Some(x) = xdict {
w.group("ACAD_XDICTIONARY", 360, &[x]);
}
w.s(330, "0");
w.s(100, "AcDbSymbolTable");
w.i(70, count as i64);
+8 -29
View File
@@ -4,7 +4,7 @@ use super::common::annotative_xdata;
use super::ctx::{AssocObj, Ctx};
use super::entity::{entity, hatch_reactors};
use super::header::{code_page, header_vars};
use super::layout::{paper_views, record_head, sheet_first, table_head, table_head_x, vport_table};
use super::layout::{paper_views, record_head, sheet_first, table_head, vport_table};
use super::objects::{cadcraft_fonts_name, group_obj, mleader_style_obj, scale_list, table_style_obj};
use super::{
Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, Layout, MLeaderStyle, PageSetup, Space,
@@ -68,7 +68,7 @@ fn write_tables(w: &mut W, plan: TableWritePlan<'_>) -> HashMap<String, String>
}
}
w.s(0, "ENDTAB");
write_layer_table(w, d, &mut cx.layer_states);
write_layer_table(w, d);
// STYLE. Linetype shapes from a shape file that isn't a text style get an unnamed shape
// style record (70 bit 1) naming the file.
let mut shape_files: Vec<String> = Vec::new();
@@ -185,12 +185,8 @@ fn write_tables(w: &mut W, plan: TableWritePlan<'_>) -> HashMap<String, String>
ltype_handles
}
/// The LAYER table; when the drawing has layer states AutoCAD can hold, the table's extension
/// dictionary holds them (written with the objects, [`crate::dxf_layer_states`]).
fn write_layer_table(w: &mut W, d: &Drawing, states: &mut crate::dxf_layer_states::Plan) {
let xdict = (!states.is_empty()).then(|| states.xdict.clone());
let th = table_head_x(w, "LAYER", d.layers.len(), xdict.as_deref());
states.table.clone_from(&th);
fn write_layer_table(w: &mut W, d: &Drawing) {
let th = table_head(w, "LAYER", d.layers.len());
for l in &d.layers {
let lh = record_head(w, "LAYER", &th, "AcDbLayerTableRecord");
w.layers.insert(l.name.to_ascii_uppercase(), lh);
@@ -753,16 +749,6 @@ fn write_objects(w: &mut W, plan: ObjectWritePlan<'_>) {
write_root_group_objects(w, &plan, &groups, &group_owner, &written, &mleader_dict);
write_style_objects(w, &plan, &mleader_dict, &mleader_handles);
write_named_objects(w, &plan);
let layer_states = {
let refs = crate::dxf_layer_states::Refs {
layers: &w.layers,
ltypes: &plan.cx.ltypes,
pstyles: &w.pstyles,
colour_dependent: plan.d.header.i64("PSTYLEMODE", 1) != 0,
};
crate::dxf_layer_states::objects(&plan.cx.layer_states, &plan.d.layer_states, &refs)
};
w.t.extend(layer_states);
write_associative_objects(w, plan.cx);
write_layout_objects(w, &plan);
// Raster image definitions.
@@ -993,9 +979,7 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
if let Some(chunks) = dxf_ext::constraint_chunks(&d.constraints, &d.parametric) {
xrecords.push((dxf_ext::CONSTRAINTS_KEY, w.h(), chunks));
}
// Saved layer states: AutoCAD's dictionary holds those it can, CADCraft's record the others.
cx.layer_states = crate::dxf_layer_states::Plan::new(&d.layer_states, || w.h());
if let Some(chunks) = dxf_ext::layer_state_chunks(&crate::dxf_layer_states::own(&d.layer_states)) {
if let Some(chunks) = dxf_ext::layer_state_chunks(&d.layer_states) {
xrecords.push((dxf_ext::LAYER_STATES_KEY, w.h(), chunks));
}
if let Some(chunks) = dxf_ext::plot_style_chunks(&d.plot_style_tables) {
@@ -1007,19 +991,14 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
// The annotation scale list: the ACAD_SCALELIST dictionary of SCALE objects.
let scale_dict = w.h();
let scales: Vec<(&cadcraft_doc::AnnoScale, String)> = d.scales.iter().filter(|s| s.is_valid()).map(|s| (s, w.h())).collect();
// Plot style names used by layers and objects (Normal always), each a placeholder object; in
// a drawing of named plot styles also those of the layers of saved layer states, which name
// theirs by placeholder.
// Plot style names used by layers and objects (Normal always), each a placeholder object.
let pstyle_dict = w.h();
let mut pstyle_names: Vec<String> = vec![cadcraft_doc::NORMAL_STYLE.to_string()];
let mut seen: std::collections::HashSet<String> = pstyle_names.iter().map(|n| n.to_ascii_uppercase()).collect();
let named_styles = d.header.i64("PSTYLEMODE", 1) == 0;
let in_states = d.layer_states.iter().filter(|_| named_styles).flat_map(|s| s.layers.iter());
let named = d.layers.iter().chain(in_states).map(|l| l.plot_style.as_str()).chain(every.iter().map(|e| e.common.plot_style.as_str()));
let named = d.layers.iter().map(|l| l.plot_style.as_str()).chain(every.iter().map(|e| e.common.plot_style.as_str()));
for n in named {
let n = n.trim();
let logical = n.is_empty() || n.eq_ignore_ascii_case("bylayer") || n.eq_ignore_ascii_case("byblock");
if !logical && pstyle_names.len() < dxf_ext::MAX_PLOT_STYLE_NAMES && seen.insert(n.to_ascii_uppercase()) {
if !logical && pstyle_names.len() < dxf_ext::MAX_PLOT_STYLE_NAMES && !pstyle_names.iter().any(|x| x.eq_ignore_ascii_case(n)) {
pstyle_names.push(n.to_string());
}
}
-1
View File
@@ -9,7 +9,6 @@ mod dxf_raw;
mod dxf_clip;
mod dxf_ext;
mod dxf_image;
mod dxf_layer_states;
mod dxf_mleader;
mod dxf_read;
mod dxf_table;
+5 -17
View File
@@ -1856,24 +1856,22 @@ fn layer_states_roundtrip_next_to_constraints() {
description: "walls \\ hidden".into(),
..Layer::default()
});
d.layer_states.push(LayerState::new("Plot", d.layers.clone(), "Wände"));
d.layer_states.push(LayerState { name: "Plot".into(), layers: d.layers.clone() });
let mut off = d.layers.clone();
for l in &mut off {
(l.on, l.frozen, l.locked, l.plot) = (false, true, true, false);
}
d.layer_states.push(LayerState::new("All off", off, ""));
d.layer_states.push(LayerState { name: "All off".into(), layers: off });
let text = write_dxf(&d);
// AutoCAD's dictionary holds both states; CADCraft's record isn't needed.
assert!(text.contains("ACAD_LAYERSTATES") && !text.contains("CADCRAFT_LAYERSTATES"));
assert!(text.contains("CADCRAFT_LAYERSTATES"));
let back = read_dxf(text.as_bytes()).unwrap();
assert_eq!(back.layer_states, d.layer_states);
assert_eq!(back.constraints, constraints);
assert_eq!(roundtrip(&back).layer_states, d.layer_states);
#[cfg(not(target_arch = "wasm32"))]
assert_eq!(read(&write(&d, "x.dwg").unwrap(), "x.dwg").unwrap().layer_states, d.layer_states);
// Drawings without saved layer states carry neither.
let none = write_dxf(&Drawing::new_imperial());
assert!(!none.contains("CADCRAFT_LAYERSTATES") && !none.contains("ACAD_LAYERSTATES"));
// Drawings without saved layer states carry no record.
assert!(!write_dxf(&Drawing::new_imperial()).contains("CADCRAFT_LAYERSTATES"));
}
fn table_sample() -> Table {
@@ -3715,13 +3713,3 @@ fn solid_hatch_keeps_angle_scale_and_double_flag() {
assert!(f("41").is_some_and(|s| (s - 2.0).abs() < 1e-12), "{h:?}");
assert_eq!(group(h, "77"), Some("0"), "{h:?}");
}
/// A layer state of CADCraft's own record from before states had a mask, a current layer and a
/// description (its JSON holds only the name and the layers) restores every property and names no
/// current layer.
#[test]
fn a_layer_state_saved_before_masks_restores_everything() {
let states = crate::dxf_ext::parse_layer_states(r#"{"version":1,"states":[{"name":"S","layers":[]}]}"#).unwrap();
let got: Vec<(&str, u32, &str, &str)> = states.iter().map(|s| (s.name.as_str(), s.mask, s.current.as_str(), s.description.as_str())).collect();
assert_eq!(got, [("S", LayerState::ALL, "", "")]);
}
-451
View File
@@ -1,451 +0,0 @@
//! Saved layer states in AutoCAD's form: the LAYER table's extension dictionary holds an
//! `ACAD_LAYERSTATES` dictionary of one XRECORD per state. The groups below are copied from
//! AutoCAD 2024's own DXFOUT of states saved with -LAYER stAte on a self-built drawing.
use cadcraft_color::{Color, Rgb};
use cadcraft_doc::{Drawing, Layer, LayerState, Lineweight};
use cadcraft_io::{read, write_dxf};
/// `(code, value)` pairs of a DXF, trimmed.
fn pairs(dxf: &str) -> Vec<(String, String)> {
let lines: Vec<&str> = dxf.lines().collect();
lines.chunks(2).filter_map(|c| Some((c.first()?.trim().to_string(), c.get(1)?.trim().to_string()))).collect()
}
fn join(p: &[(String, String)]) -> String {
p.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect()
}
fn g(c: &str, v: &str) -> (String, String) {
(c.to_string(), v.to_string())
}
/// The records of a DXF: (type, groups after the `0`).
fn records(p: &[(String, String)]) -> Vec<(String, Vec<(String, String)>)> {
let mut out: Vec<(String, Vec<(String, String)>)> = Vec::new();
for (c, v) in p {
if c == "0" {
out.push((v.clone(), Vec::new()));
} else if let Some(last) = out.last_mut() {
last.1.push((c.clone(), v.clone()));
}
}
out
}
fn value<'a>(groups: &'a [(String, String)], code: &str) -> Option<&'a str> {
groups.iter().find(|(c, _)| c == code).map(|(_, v)| v.as_str())
}
/// The handle of table record `kind` named `name`.
fn record_handle(p: &[(String, String)], kind: &str, name: &str) -> String {
let recs = records(p);
let (_, groups) = recs.iter().find(|(k, gs)| k == kind && value(gs, "2").is_some_and(|n| n.eq_ignore_ascii_case(name))).unwrap();
value(groups, "5").unwrap().to_string()
}
/// A handle above every handle of the file, plus `k`.
fn fresh(p: &[(String, String)], k: u64) -> String {
let top = p.iter().filter(|(c, _)| c == "5" || c == "105").filter_map(|(_, v)| u64::from_str_radix(v, 16).ok()).max().unwrap();
format!("{:X}", top + 0x100 + k)
}
/// `dxf` with the LAYER table given extension dictionary `xdict` and `objects` added at the end
/// of OBJECTS.
fn inject(dxf: &str, xdict: &str, objects: Vec<(String, String)>) -> String {
let mut p = pairs(dxf);
let table = p.iter().enumerate().position(|(i, (c, v))| c == "0" && v == "TABLE" && p.get(i + 1).is_some_and(|n| n.1 == "LAYER")).unwrap();
let at = table + p[table..].iter().position(|(c, _)| c == "5").unwrap() + 1;
p.splice(at..at, [g("102", "{ACAD_XDICTIONARY"), g("360", xdict), g("102", "}")]);
let objs = p.iter().position(|(c, v)| c == "2" && v == "OBJECTS").unwrap();
let end = objs + p[objs..].iter().position(|(c, v)| c == "0" && v == "ENDSEC").unwrap();
p.splice(end..end, objects);
join(&p)
}
/// Layers A (red) and B, and the DASHED linetype.
fn drawing() -> Drawing {
let mut d = Drawing::new_metric();
d.layers.push(Layer { color: Color::Index(1), ..Layer::new("A") });
d.layers.push(Layer::new("B"));
d.linetypes.push(cadcraft_doc::library::standard_linetypes().into_iter().find(|l| l.name == "DASHED").unwrap());
d
}
/// State S2 as AutoCAD 2024 wrote it after -LAYER: A true colour 10,20,30 (nearest index 168),
/// 50% transparent, 0.35 mm, DASHED, not plotted; B locked and frozen in new viewports. Then the
/// entry of a layer purged since (AutoCAD keeps it, pointing at handles that are gone).
fn s2(p: &[(String, String)], rec: &str, dict: &str) -> Vec<(String, String)> {
let (a, b, zero) = (record_handle(p, "LAYER", "A"), record_handle(p, "LAYER", "B"), record_handle(p, "LAYER", "0"));
let (cont, dashed) = (record_handle(p, "LTYPE", "Continuous"), record_handle(p, "LTYPE", "DASHED"));
let gone = fresh(p, 0x50);
let mut v =
vec![g("0", "XRECORD"), g("5", rec), g("102", "{ACAD_REACTORS"), g("330", dict), g("102", "}"), g("330", dict), g("100", "AcDbXrecord")];
v.extend([g("280", "1"), g("91", "2047"), g("301", ""), g("290", "0"), g("302", "0")]);
for (h, flags, aci, lw, lt, ps, tr) in [
(b.as_str(), "28", "7", "-3", cont.as_str(), "Color_7", "0"),
(a.as_str(), "0", "168", "35", dashed.as_str(), "Color_168", "33554559"),
(zero.as_str(), "8", "7", "-3", cont.as_str(), "Color_7", "0"),
(gone.as_str(), "8", "7", "-3", gone.as_str(), "Color_7", "0"),
] {
v.extend([g("330", h), g("90", flags), g("62", aci), g("370", lw), g("331", lt), g("1", ps), g("440", tr)]);
if h == a {
v.push(g("92", "-1039526882"));
}
}
v
}
/// State S7, saved with only On and restored once (AutoCAD then sets bit 65536), current layer A.
fn s7(p: &[(String, String)], rec: &str, dict: &str) -> Vec<(String, String)> {
let (a, b) = (record_handle(p, "LAYER", "A"), record_handle(p, "LAYER", "B"));
let cont = record_handle(p, "LTYPE", "Continuous");
let mut v =
vec![g("0", "XRECORD"), g("5", rec), g("102", "{ACAD_REACTORS"), g("330", dict), g("102", "}"), g("330", dict), g("100", "AcDbXrecord")];
v.extend([g("280", "1"), g("91", "66049"), g("301", "only on"), g("290", "0"), g("302", "A")]);
for (h, aci) in [(b.as_str(), "7"), (a.as_str(), "1")] {
v.extend([g("330", h), g("90", "8"), g("62", aci), g("370", "-3"), g("331", &cont), g("1", &format!("Color_{aci}")), g("440", "0")]);
}
v
}
/// The extension dictionary of the LAYER table and the states dictionary, with `extra` entries in
/// the extension dictionary.
fn dictionaries(p: &[(String, String)], x: &str, y: &str, states: &[(&str, &str)], extra: &[(&str, &str)]) -> Vec<(String, String)> {
let table = {
let recs = records(p);
let (_, gs) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
value(gs, "5").unwrap().to_string()
};
let mut v = vec![g("0", "DICTIONARY"), g("5", x), g("330", &table), g("100", "AcDbDictionary"), g("280", "1"), g("281", "1")];
for (k, h) in extra.iter().copied().chain([("ACAD_LAYERSTATES", y)]) {
v.extend([g("3", k), g("360", h)]);
}
v.extend([
g("0", "DICTIONARY"),
g("5", y),
g("102", "{ACAD_REACTORS"),
g("330", x),
g("102", "}"),
g("330", x),
g("100", "AcDbDictionary"),
g("281", "1"),
]);
for (name, h) in states {
v.extend([g("3", name), g("350", h)]);
}
v
}
fn autocad_file() -> String {
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, r7) = (h(1), h(2), h(3), h(4));
let mut objects = dictionaries(&p, &x, &y, &[("S2", &r2), ("S7", &r7)], &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &r7, &y));
inject(&base, &x, objects)
}
#[test]
fn reads_the_layer_states_autocad_writes() {
let d = read(autocad_file().as_bytes(), "acad.dxf").unwrap();
let names: Vec<&str> = d.layer_states.iter().map(|s| s.name.as_str()).collect();
assert_eq!(names, ["S2", "S7"]);
let s2 = &d.layer_states[0];
assert_eq!((s2.mask, s2.current.as_str(), s2.description.as_str()), (2047, "0", ""));
// The purged layer's entry is skipped.
let layers: Vec<&str> = s2.layers.iter().map(|l| l.name.as_str()).collect();
assert_eq!(layers, ["B", "A", "0"]);
let a = &s2.layers[1];
assert_eq!(a.color, Color::True(Rgb(10, 20, 30)));
assert_eq!((a.transparency, a.lineweight, a.linetype.as_str()), (50, Lineweight::from_dxf(35), "DASHED"));
assert!(a.on && !a.frozen && !a.locked && !a.plot && !a.vp_freeze_new);
// A colour-dependent drawing: the plot style stays the layer's ("Color_168" is its colour's).
assert_eq!(a.plot_style, "Normal");
let b = &s2.layers[0];
assert!(b.on && !b.frozen && b.locked && b.plot && b.vp_freeze_new, "{b:?}");
assert_eq!((b.color, b.linetype.as_str(), b.transparency), (Color::Index(7), "Continuous", 0));
let s7 = &d.layer_states[1];
assert_eq!((s7.mask, s7.current.as_str(), s7.description.as_str()), (66049, "A", "only on"));
assert_eq!(s7.layers.iter().find(|l| l.name == "A").unwrap().color, Color::Index(1));
}
#[test]
fn autocads_layer_states_are_written_back_in_its_form() {
let d = read(autocad_file().as_bytes(), "acad.dxf").unwrap();
let text = write_dxf(&d);
let p = pairs(&text);
// One states dictionary, in the LAYER table's extension dictionary, and no CADCraft copy.
assert_eq!(p.iter().filter(|(c, v)| c == "3" && v == "ACAD_LAYERSTATES").count(), 1);
assert!(!text.contains("CADCRAFT_LAYERSTATES"));
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let x = table.windows(2).find(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).unwrap();
let (_, xd) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(x.as_str())).unwrap();
assert_eq!(value(xd, "330"), value(table, "5"));
let back = read(text.as_bytes(), "back.dxf").unwrap();
assert_eq!(back.layer_states, d.layer_states);
// The XRECORD of S2 as AutoCAD writes it: B, then A.
let (a_h, b_h) = (record_handle(&p, "LAYER", "A"), record_handle(&p, "LAYER", "B"));
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
let head = rec.iter().position(|(c, _)| c == "280").unwrap();
assert_eq!(rec[head..head + 5], [("280", "1"), ("91", "2047"), ("301", ""), ("290", "0"), ("302", "0")].map(|(c, v)| g(c, v)));
let cont = record_handle(&p, "LTYPE", "Continuous");
let b = [("330", b_h.as_str()), ("90", "28"), ("62", "7"), ("370", "-3"), ("331", &cont), ("1", "Color_7"), ("440", "0")];
assert_eq!(rec[head + 5..head + 12], b.map(|(c, v)| g(c, v)));
let from = rec.iter().position(|(c, v)| c == "330" && *v == a_h).unwrap();
let a: Vec<(String, String)> = rec[from..from + 9].to_vec();
let dashed = record_handle(&p, "LTYPE", "DASHED");
let want = [
("330", a_h.as_str()),
("90", "0"),
("62", "168"),
("370", "35"),
("331", &dashed),
("1", "Color_168"),
("440", "33554559"),
("92", "-1039526882"),
];
assert_eq!(a[..8], want.map(|(c, v)| g(c, v)), "{a:?}");
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "x.dwg").unwrap();
assert_eq!(read(&dwg, "x.dwg").unwrap().layer_states, d.layer_states);
}
}
#[test]
fn layer_filters_next_to_the_states_are_kept() {
// The LAYER table's extension dictionary of a drawing with layer filters holds them next to
// the states (ACAD_LAYERFILTERS, ACLYDICTIONARY): they stay, in the dictionary CADCraft writes.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, f, fr, gone) = (h(1), h(2), h(3), h(4), h(5), h(6));
// Two entries whose objects the file doesn't have (a handle of nothing, and a null one): they
// aren't written into the table's dictionary.
let extra = [("ACAD_LAYERFILTERS", f.as_str()), ("OTHER_GONE", gone.as_str()), ("OTHER_NULL", "0")];
let mut objects = dictionaries(&p, &x, &y, &[("S2", &r2)], &extra);
objects.extend(s2(&p, &r2, &y));
objects.extend([g("0", "DICTIONARY"), g("5", &f), g("102", "{ACAD_REACTORS"), g("330", &x), g("102", "}"), g("330", &x)]);
objects.extend([g("100", "AcDbDictionary"), g("281", "1"), g("3", "Walls"), g("350", &fr)]);
objects.extend([g("0", "XRECORD"), g("5", &fr), g("102", "{ACAD_REACTORS"), g("330", &f), g("102", "}"), g("330", &f), g("100", "AcDbXrecord")]);
objects.extend([g("280", "1"), g("1", "A*")]);
let file = inject(&base, &x, objects);
let mut text = file;
for round in 0..2 {
let d = read(text.as_bytes(), "f.dxf").unwrap();
assert_eq!(d.layer_states.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["S2"], "round {round}");
text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let xdicts: Vec<String> = table.windows(2).filter(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).collect();
assert_eq!(xdicts.len(), 1, "round {round}");
let xd = &xdicts[0];
let (_, dict) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(xd.as_str())).unwrap();
let keys: Vec<&str> = dict.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.as_str()).collect();
assert_eq!(keys, ["ACAD_LAYERSTATES", "ACAD_LAYERFILTERS"], "round {round}");
// The filters dictionary is owned by the written one, and so is its filter by it.
let fh = dict.windows(2).find(|w| w[0] == g("3", "ACAD_LAYERFILTERS")).map(|w| w[1].1.clone()).unwrap();
let (_, fd) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(fh.as_str())).unwrap();
let owner = fd.iter().filter(|(c, _)| c == "330").map(|(_, v)| v.as_str()).collect::<Vec<_>>();
assert_eq!(owner, [xd.as_str(), xd.as_str()], "round {round}: reactor and owner");
let walls = value(fd, "350").unwrap();
let (_, wr) = recs.iter().find(|(k, gs)| k == "XRECORD" && value(gs, "5") == Some(walls)).unwrap();
assert!(wr.contains(&g("330", &fh)) && wr.contains(&g("1", "A*")), "round {round}");
// The kept dictionary itself is not written a second time.
assert_eq!(recs.iter().filter(|(k, gs)| k == "DICTIONARY" && gs.iter().any(|(c, v)| c == "3" && v == "ACAD_LAYERFILTERS")).count(), 1);
}
// With every state deleted the filters stay, in the table's own dictionary, and AutoCAD's states
// don't come back.
let mut d = read(text.as_bytes(), "f.dxf").unwrap();
d.layer_states.clear();
let text = write_dxf(&d);
assert!(!text.contains("ACAD_LAYERSTATES"));
let p = pairs(&text);
let recs = records(&p);
let (_, table) = recs.iter().find(|(k, gs)| k == "TABLE" && value(gs, "2") == Some("LAYER")).unwrap();
let xd = table.windows(2).find(|w| w[0] == g("102", "{ACAD_XDICTIONARY")).map(|w| w[1].1.clone()).unwrap();
let (_, dict) = recs.iter().find(|(k, gs)| k == "DICTIONARY" && value(gs, "5") == Some(xd.as_str())).unwrap();
assert_eq!(dict.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.as_str()).collect::<Vec<_>>(), ["ACAD_LAYERFILTERS"]);
assert!(read(text.as_bytes(), "g.dxf").unwrap().layer_states.is_empty());
}
#[test]
fn entries_whose_names_differ_only_in_case_open_as_one_state() {
// AutoCAD 2024 opens the entries `S` and `s` of one ACAD_LAYERSTATES dictionary as one state:
// named as the first entry in the dictionary and holding the last entry's record (measured with
// the records in one file order and the entries in both dictionary orders, so the first entry's
// record came first in the file once and last once). Here S2's record (mask 2047) comes first in
// the file, then state T's, then S7's (66049); the merged state stays where S2's record is.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r2, r7, rt) = (h(1), h(2), h(3), h(4), h(5));
let states = |d: &Drawing| d.layer_states.iter().map(|s| (s.name.clone(), s.mask)).collect::<Vec<_>>();
for (pair, name, mask) in [([("S", r2.as_str()), ("s", r7.as_str())], "S", 66049), ([("s", r7.as_str()), ("S", r2.as_str())], "s", 2047)] {
let entries = [pair[0], ("T", rt.as_str()), pair[1]];
let mut objects = dictionaries(&p, &x, &y, &entries, &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &rt, &y));
objects.extend(s7(&p, &r7, &y));
let d = read(inject(&base, &x, objects).as_bytes(), "case.dxf").unwrap();
let want = [(name.to_string(), mask), ("T".to_string(), 66049)];
assert_eq!(states(&d), want, "{entries:?}");
// Written back, they are the states AutoCAD opened.
let back = read(write_dxf(&d).as_bytes(), "back.dxf").unwrap();
assert_eq!(states(&back), want, "{entries:?}");
}
// A record the dictionary lists as `s` but another object owns isn't a state, and doesn't stand
// in for S's record either.
let mut objects = dictionaries(&p, &x, &y, &[("S", r2.as_str()), ("s", r7.as_str())], &[]);
objects.extend(s2(&p, &r2, &y));
objects.extend(s7(&p, &r7, &x));
let d = read(inject(&base, &x, objects).as_bytes(), "stray.dxf").unwrap();
assert_eq!(states(&d), [("S".to_string(), 2047)]);
}
#[test]
fn view_snapshots_and_names_twice_in_another_case_stay_in_cadcrafts_record() {
let mut d = drawing();
for name in ["Plan", "*VIEW Front", "PLAN", "Wände", "WÄNDE", "", " "] {
d.layer_states.push(LayerState::new(name, d.layers.clone(), "A"));
}
let text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, states) =
recs.iter().find(|(k, gs)| k == "DICTIONARY" && gs.contains(&g("281", "1")) && gs.iter().any(|(c, v)| c == "3" && v == "Plan")).unwrap();
// (The DXF writes "ä" as \U+00E4.)
let keys: Vec<String> = states.iter().filter(|(c, _)| c == "3").map(|(_, v)| v.replace("\\U+00E4", "ä")).collect();
assert_eq!(keys, ["Plan", "Wände"], "AutoCAD's dictionary holds the first of each name");
assert!(text.contains("CADCRAFT_LAYERSTATES"));
let back = read(text.as_bytes(), "v.dxf").unwrap();
// AutoCAD's states first, then CADCraft's own.
// (A blank name can't be a key of AutoCAD's dictionary: those stay in CADCraft's record too.)
let want: Vec<LayerState> = [0, 3, 1, 2, 4, 5, 6].iter().map(|&i| d.layer_states[i].clone()).collect();
assert_eq!(back.layer_states, want);
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "v.dwg").unwrap();
assert_eq!(read(&dwg, "v.dwg").unwrap().layer_states, want);
}
}
#[test]
fn a_layer_of_an_xref_gets_group_93() {
// AutoCAD 2024 writes 93 (0 for a newly attached xref) after the lineweight of an xref's layer
// only (measured with a self-built xref).
let mut d = drawing();
d.layers.push(Layer::new("XR|L1"));
d.layer_states.push(LayerState::new("X", d.layers.clone(), "0"));
let p = pairs(&write_dxf(&d));
let recs = records(&p);
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
let start = rec.iter().position(|(c, _)| c == "302").unwrap() + 1;
let mut with_93 = Vec::new();
let mut layer = String::new();
for (i, (c, v)) in rec.iter().enumerate().skip(start) {
match c.as_str() {
"330" => layer.clone_from(v),
"93" => {
assert_eq!((v.as_str(), rec[i - 1].0.as_str(), rec[i + 1].0.as_str()), ("0", "370", "331"));
with_93.push(layer.clone());
}
_ => {}
}
}
assert_eq!(with_93, [record_handle(&p, "LAYER", "XR|L1")]);
}
#[test]
fn named_plot_styles_are_written_by_placeholder() {
// In a drawing of named plot styles AutoCAD 2024 writes a layer's plot style as group 390, the
// handle of the style's placeholder object (measured); CADCraft reads it back by that handle.
let mut d = drawing();
d.header.set_i64("PSTYLEMODE", 0);
let a = d.layers.iter().position(|l| l.name == "A").unwrap();
d.layers[a].plot_style = "Thick".into();
d.layer_states.push(LayerState::new("N", d.layers.clone(), "0"));
// No layer uses Thick any more: its placeholder is written for the state.
d.layers[a].plot_style = "Normal".into();
let text = write_dxf(&d);
let p = pairs(&text);
let recs = records(&p);
let (_, names) = recs.iter().find(|(k, _)| k == "ACDBDICTIONARYWDFLT").unwrap();
let thick = names.windows(2).find(|w| w[0] == g("3", "Thick")).map(|w| w[1].1.clone()).unwrap();
let (_, rec) = recs.iter().find(|(k, gs)| k == "XRECORD" && gs.contains(&g("91", "2047"))).unwrap();
assert!(rec.contains(&g("390", &thick)) && !rec.iter().any(|(c, _)| c == "1"), "{rec:?}");
let back = read(text.as_bytes(), "n.dxf").unwrap();
assert_eq!(back.layer_states[0].layers.iter().find(|l| l.name == "A").unwrap().plot_style, "Thick");
assert_eq!(back.layer_states, d.layer_states);
#[cfg(not(target_arch = "wasm32"))]
{
let dwg = cadcraft_io::write(&d, "n.dwg").unwrap();
assert_eq!(read(&dwg, "n.dwg").unwrap().layer_states, d.layer_states);
}
}
#[test]
fn a_state_in_both_records_is_read_from_autocads() {
// A file of an earlier CADCraft keeps its states in CADCraft's record; AutoCAD then saves a state
// of the same name in its own dictionary: AutoCAD's is the one read.
let mut d = drawing();
d.layer_states.push(LayerState::new("S", d.layers.clone(), "A"));
d.layer_states.push(LayerState::new("*VIEW S", d.layers.clone(), "B"));
let text = write_dxf(&d);
assert!(text.contains("*VIEW S"));
let text = text.replace("*VIEW S", "S");
let back = read(text.as_bytes(), "both.dxf").unwrap();
assert_eq!(back.layer_states.iter().map(|s| (s.name.as_str(), s.current.as_str())).collect::<Vec<_>>(), [("S", "A")]);
}
#[test]
fn states_past_the_limit_are_left_out_and_the_rest_come_in_file_order() {
// A hostile file with one state more than the reader keeps (100 000): the last one in the file
// is left out, and the others come in file order, here the reverse of their names' order.
const LIMIT: u64 = 100_000;
let base = write_dxf(&drawing());
let p = pairs(&base);
let first = u64::from_str_radix(&fresh(&p, 0), 16).unwrap();
let h = |k: u64| format!("{:X}", first + k);
let (x, y) = (h(1), h(2));
let names: Vec<String> = (0..=LIMIT).map(|i| format!("S{:06}", LIMIT + 1 - i)).collect();
let records: Vec<String> = (0..=LIMIT).map(|i| h(3 + i)).collect();
let entries: Vec<(&str, &str)> = names.iter().map(String::as_str).zip(records.iter().map(String::as_str)).collect();
let mut objects = dictionaries(&p, &x, &y, &entries, &[]);
for r in &records {
objects.extend([g("0", "XRECORD"), g("5", r), g("330", &y), g("100", "AcDbXrecord")]);
objects.extend([g("280", "1"), g("91", "2047"), g("301", ""), g("290", "0"), g("302", "0")]);
}
let d = read(inject(&base, &x, objects).as_bytes(), "many.dxf").unwrap();
let names: Vec<&str> = d.layer_states.iter().map(|s| s.name.as_str()).collect();
assert_eq!(names.len(), 100_000);
assert_eq!((names.first().copied(), names.get(1).copied(), names.last().copied()), (Some("S100001"), Some("S100000"), Some("S000002")));
}
#[test]
fn a_record_twice_in_a_file_is_one_state() {
// A damaged file can hold an object twice under one handle: one state.
let base = write_dxf(&drawing());
let p = pairs(&base);
let h = |k| fresh(&p, k);
let (x, y, r7) = (h(1), h(2), h(4));
let mut objects = dictionaries(&p, &x, &y, &[("S7", &r7)], &[]);
objects.extend(s7(&p, &r7, &y));
objects.extend(s7(&p, &r7, &y));
let d = read(inject(&base, &x, objects).as_bytes(), "twice.dxf").unwrap();
assert_eq!(d.layer_states.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["S7"]);
}
#[test]
fn group_92_without_the_true_colour_prefix_is_not_a_true_colour() {
// AutoCAD 2024 writes 92 only for a true colour, 0xC2RRGGBB (measured); a value with another
// high byte (not seen from AutoCAD) leaves the colour index of group 62.
let text = autocad_file().replace("92\n-1039526882", "92\n-1023410175");
let d = read(text.as_bytes(), "c3.dxf").unwrap();
assert_eq!(d.layer_states[0].layers.iter().find(|l| l.name == "A").unwrap().color, Color::Index(168));
}
-1
View File
@@ -32,7 +32,6 @@ mod groups_roundtrip;
mod hatch_assoc_roundtrip;
mod hatch_pattern_def;
mod helix_roundtrip;
mod layer_states_acad;
mod layout_limits_roundtrip;
mod layout_paper_units;
mod layout_plot_window;
+1 -1
View File
@@ -185,7 +185,7 @@ pub(super) fn layer_states() -> Case {
layer.on = false;
layer.locked = true;
}
drawing.layer_states.push(LayerState::new("Saved", layers, "0"));
drawing.layer_states.push(LayerState { name: "Saved".into(), layers });
Case { name: "drawing/layer-state".into(), drawing }
}
+5 -15
View File
@@ -492,16 +492,11 @@ const OBJECTS: &str = "
330 61
100 AcDbXrecord
280 1
91 2047
91 0
301 Plan
290 0
302 0
330 11
90 8
8 WALLS
90 0
62 1
370 -3
1 Normal
440 0
0 DICTIONARY
5 63
330 10
@@ -808,19 +803,14 @@ fn ucs_layer_states_and_block_descriptions_are_kept() {
assert_eq!((u.origin.x, u.origin.y, u.origin.z), (1.0, 2.0, 3.0));
assert_eq!((u.x_axis.y, u.y_axis.x), (1.0, -1.0));
assert_eq!(d.block("DOOR").map(|b| b.description.as_str()), Some("A door leaf"));
let states: Vec<(&str, Vec<&str>)> =
d.layer_states.iter().map(|s| (s.name.as_str(), s.layers.iter().map(|l| l.name.as_str()).collect())).collect();
assert_eq!(states, [("Plan", vec!["WALLS"])]);
for o in [&a, &b] {
// Layer states live in the LAYER table's extension dictionary, each layer named by its
// handle (as AutoCAD 2024 writes them; CADCraft reads and rewrites them).
// Layer states live in the LAYER table's extension dictionary.
let table = o.of("TABLE").into_iter().find(|t| s(t, 2) == "LAYER").expect("LAYER table");
let [xd] = group(table, "ACAD_XDICTIONARY").try_into().expect("LAYER table extension dictionary");
let (_, dict) = o.handle(&xd).expect("dictionary");
let (_, states) = o.entry(dict, "ACAD_LAYERSTATES").expect("ACAD_LAYERSTATES");
let (_, plan) = o.entry(states, "Plan").expect("layer state Plan");
let layers = plan.iter().skip_while(|t| t.code != 302).filter(|t| t.code == 330).map(Tag::str).collect::<Vec<_>>();
assert_eq!((s(plan, 301), layers), ("Plan".into(), vec![h(o.named("LAYER", "WALLS"))]));
assert_eq!((s(plan, 301), s(plan, 8)), ("Plan".into(), "WALLS".into()));
}
}
+8
View File
@@ -308,6 +308,14 @@ fn key_from(name: &str) -> Option<egui::Key> {
}
pub fn handle(app: &mut CadApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
let out = handle_request(app, ctx, req);
// A command the request ran may have asked for a bar (MENUBAR, TOOLBAR): apply it before
// the next request, so a later query or `ui.set` sees the bars as they are now.
app.sync_bars();
out
}
fn handle_request(app: &mut CadApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
let p = &req.params;
let s = |k: &str| p.get(k).and_then(Value::as_str);
let f = |k: &str| p.get(k).and_then(Value::as_f64);
+94 -1
View File
@@ -316,6 +316,10 @@ pub fn command(app: &mut crate::CadApp, reset: bool, params: &Value) -> Result<V
}
/// Validate and repair the stored workspace, sync it with the app, and render the dock panels; a failed restore falls back to the default layout with a status message.
/// Draw the docked workspace: restore or fall back from the persisted layout, render every
/// panel body plus the header close buttons, and apply the resulting actions through
/// [`command`]. Bodies may dispatch commands, so the canonical workspace is published before
/// rendering while the layout snapshot stays immutable.
pub fn show(app: &mut crate::CadApp, ui: &mut egui::Ui) {
let t = crate::theme::Tokens::get();
let mut workspace = app.ui.docking.clone();
@@ -348,7 +352,33 @@ pub fn show(app: &mut crate::CadApp, ui: &mut egui::Ui) {
if let Some(panel) = app.raise_panel.take() {
area = area.raise_panel(panel);
}
let mut output = area.show_content(ui, &workspace.layout, &style, &mut Panels { app });
let (mut output, header_close) = {
let mut panels = Panels { app, close: None };
let output = area.show_content(ui, &workspace.layout, &style, &mut panels);
(output, panels.close)
};
// Accordion title bars are rendered by the shared surface without a header callback, so
// place the same close button over their title bar, left of the stock collapse control.
let mut close = header_close;
for panel in stack_panels(&workspace.layout) {
if !permissions(&panel).closable {
continue;
}
let Some(title) = ui.ctx().read_response(egui::Id::unique("cadcraft-docking").with(("tab", panel))) else { continue };
if !title.rect.is_positive() {
continue;
}
let rect = egui::Rect::from_center_size(
egui::pos2(title.rect.right() - 18.0 - CLOSE_BUTTON * 0.5 - 4.0, title.rect.center().y),
egui::vec2(CLOSE_BUTTON, CLOSE_BUTTON),
);
if close_button(ui, panel, rect) {
close = Some(panel);
}
}
if let Some(panel) = close {
output.actions.push(Action::Close { panel });
}
// Keys typed in a floating panel's own OS window run the main window's shortcuts and
// command line; files dropped on one open like files dropped on the main window.
app.forward_native_input(ui.ctx(), std::mem::take(&mut output.forwarded_events), output.forwarded_modifiers);
@@ -393,9 +423,55 @@ pub fn native_input_blocked(app: &crate::CadApp, ctx: &egui::Context) -> bool {
/// The panels' contents, names, size limits and icons for the dock area.
pub struct Panels<'a> {
pub app: &'a mut crate::CadApp,
/// The panel whose header close button was clicked this frame.
pub close: Option<Panel>,
}
/// Size of a panel header's close button, in points.
const CLOSE_BUTTON: f32 = 16.0;
/// The accessible name of a header's close button. One translated template carries both the
/// verb and the panel name, so a catalog translates the whole name instead of leaving an
/// English verb in front of a translated panel label.
fn close_label(panel: Panel) -> String {
crate::tf!("Close {panel}", panel = crate::i18n::t(panel.label()))
}
/// A visible close button for a panel header. It runs the same action as the tab context
/// menu's "Close panel"; the accessible name includes the panel so the headers stay distinct.
fn close_button(ui: &mut egui::Ui, panel: Panel, rect: egui::Rect) -> bool {
let t = crate::theme::Tokens::get();
let response = ui.interact(rect, egui::Id::unique("cadcraft-docking").with(("close", panel.id())), egui::Sense::click());
let label = close_label(panel);
crate::icons::describe_control(ui, &response, &label, None, false);
if response.hovered() {
ui.painter().rect_filled(rect.expand(2.0), 2.0, t.control_hover.gamma_multiply(0.6));
}
crate::icons::paint(ui.painter(), rect, crate::icons::Icon::Close, false);
response.on_hover_text(crate::tl!("Close panel")).clicked()
}
/// Panels whose title bar is an accordion entry rather than a tab group header.
fn stack_panels(layout: &Layout<Panel>) -> Vec<Panel> {
let mut panels = Vec::new();
let mut nodes: Vec<&Node<Panel>> = layout.root.iter().collect();
while let Some(node) = nodes.pop() {
match node {
Node::Split { first, second, .. } => {
nodes.push(first);
nodes.push(second);
}
Node::Stack { entries } => panels.extend(entries.iter().map(|entry| entry.panel)),
// Tab groups draw their own header; nothing else stacks an accordion entry.
_ => {}
}
}
panels
}
impl DockContent<Panel> for Panels<'_> {
/// Render `panel`'s existing view; Layers, Properties and External References scroll
/// independently, and the drawing canvas paints its own background before the view.
fn body(&mut self, ui: &mut egui::Ui, panel: &Panel) {
let app = &mut *self.app;
match panel {
@@ -445,6 +521,23 @@ impl DockContent<Panel> for Panels<'_> {
crate::icons::paint(painter, rect, icon, false);
true
}
/// Reserve header space for the close button only when `active` may be closed, so the
/// drawing view's title gets no empty gap.
fn group_header_width(&self, _panels: &[Panel], active: &Panel, _floating: bool, _strip_width: f32) -> f32 {
if permissions(active).closable { CLOSE_BUTTON + 8.0 } else { 0.0 }
}
/// Draw the close button at the right edge of a tab-group header and remember the panel
/// to close once the docking surface has returned, so layout changes stay outside rendering.
fn group_header(&mut self, ui: &mut egui::Ui, _panels: &[Panel], active: &Panel, _floating: bool) {
let header = ui.max_rect();
let rect = egui::Rect::from_center_size(
egui::pos2(header.right() - CLOSE_BUTTON * 0.5 - 4.0, header.center().y),
egui::vec2(CLOSE_BUTTON, CLOSE_BUTTON),
);
if close_button(ui, *active, rect) {
self.close = Some(*active);
}
}
}
fn panel_limits(panel: &Panel) -> PanelLimits {
+3
View File
@@ -139,11 +139,13 @@
Clip Viewport Delimitar ventana gráfica
Clipboard Portapapeles
Close Cerrar
Close {panel} Cerrar {panel}
Close All Cerrar todo
Close All Other Drawings Cerrar todos los demás dibujos
Close Array Editing Cerrar la edición de matriz
Close Comparison Cerrar comparación
Export Comparison Exportar comparación
Close panel Cerrar panel
Closed Cerrada
Coincident Coincidente
Collapse Palettes Contraer paletas
@@ -542,6 +544,7 @@
Measure Medir
Measure Distance Medir distancia
Measure Geometry Medir geometría
Menu Bar Barra de menús
Merge Cells Combinar celdas
Merged PRs PR integradas
Mid Between 2 Points Punto medio entre 2 puntos
1 # CADCraft Spanish interface catalog — original translations.
139
140
141
142
143
144
145
146
147
148
149
150
151
544
545
546
547
548
549
550
+1
View File
@@ -146,6 +146,7 @@ fn missing_marked_ui_literals(language: &str) -> BTreeSet<String> {
"chrome",
"cmdline",
"credits",
"docking",
"dialogs",
"hatchdlg",
"aliasdlg",
+3
View File
@@ -143,11 +143,13 @@
Xref Clip Frame Рамка обрізки зовнішнього посилання
Clipboard Буфер обміну
Close Закрити
Close {panel} Закрити {panel}
Close All Закрити всі
Close All Other Drawings Закрити всі інші креслення
Closed Замкнений
Close Comparison Закрити порівняння
Export Comparison Експортувати порівняння
Close panel Закрити панель
Coincident Збіг
Collapse Palettes Згорнути палітри
Collapse Tool Sets Згорнути набори інструментів
@@ -534,6 +536,7 @@
Measure Розмітити
Measure Distance Виміряти відстань
Measure Geometry Виміряти геометрію
Menu Bar Рядок меню
Merge Cells Об'єднати комірки
Merged PRs Об'єднані PR
Mid Between 2 Points Середина між 2 точками
1 # CADCraft Ukrainian interface catalog — original translations by @dmatviichuk.
143
144
145
146
147
148
149
150
151
152
153
154
155
536
537
538
539
540
541
542
+1
View File
@@ -928,6 +928,7 @@
Time 时间
To get started, create or open a drawing. 若要开始,请创建或打开一个图形。
Tool Bar 工具栏
Menu Bar 菜单栏
Tool Sets 工具集
Tools 工具
Torus 圆环体
1 # CADCraft Simplified Chinese interface catalog — original translations.
928
929
930
931
932
933
934
+85 -1
View File
@@ -283,6 +283,9 @@ pub struct CadApp {
pub system_animations: Option<bool>,
/// What `ui.system_cursor` goes back to when the interface is reset ([`Self::set_system_cursor_default`]).
pub system_cursor_default: bool,
/// Whether the host has a native menu bar: off where the menus stay in the window
/// ([`Self::set_native_menus`]).
pub native_menus: bool,
pub session: Session,
pub ui: UiState,
/// The interface's own preferences from the Options dialog ([`options`]).
@@ -381,6 +384,7 @@ impl CadApp {
system_languages: Vec::new(),
system_animations: None,
system_cursor_default: false,
native_menus: cfg!(target_os = "macos"),
session,
ui: UiState::default(),
options: options::UiOptions::default(),
@@ -588,7 +592,11 @@ impl CadApp {
if let Some(r) = menus::run_ui_command(self, id, &params) {
return r;
}
// The bars as the interface shows them now (a `ui.set` may have just changed one), and any
// MENUBAR or TOOLBAR request applied at once.
self.sync_bars();
let r = self.session.execute(id, &params).map_err(|e| e.to_string());
self.sync_bars();
if let Ok(v) = &r
&& let Some(m) = v.get("message").and_then(Value::as_str)
{
@@ -607,6 +615,7 @@ impl CadApp {
if menus::run_ui_command(self, name, &Value::Null).is_some() {
return;
}
self.sync_bars();
if let Err(e) = self.session.start(name) {
self.session.echo(e.to_string());
}
@@ -622,6 +631,7 @@ impl CadApp {
/// command or system variable) runs `fallback` instead: Enter on a partly typed name accepts
/// the highlighted AutoComplete suggestion.
pub fn cmdline_or(&mut self, text: &str, fallback: Option<&str>) -> Option<String> {
self.sync_bars();
if !self.session.prompting() {
let first = text.split_whitespace().next().unwrap_or("");
// `cmd {json}` is a programmatic call: the engine runs it with those parameters.
@@ -636,7 +646,9 @@ impl CadApp {
return None;
}
}
let e = match (self.session.cmdline(text), fallback) {
let r = self.session.cmdline(text);
self.sync_bars();
let e = match (r, fallback) {
(Ok(()), _) => return None,
(Err(cadcraft_engine::EngineError::UnknownCommand(_)), Some(f)) => return self.cmdline(f),
(Err(e), _) => e.to_string(),
@@ -645,6 +657,18 @@ impl CadApp {
Some(e)
}
/// Apply a menu bar / tool bar change MENUBAR or TOOLBAR asked for, and report the bars shown.
fn sync_bars(&mut self) {
let b = std::mem::take(&mut self.session.bars_request);
if let Some(on) = b.menubar {
self.ui.in_window_menu = on;
}
if let Some(show) = b.toolbar {
self.ui.show_toolbar = show;
}
self.session.bars_shown = cadcraft_engine::cmd::interface::InterfaceBars { menubar: self.ui.in_window_menu, toolbar: self.ui.show_toolbar };
}
/// The theme the interface shows now (the choice resolved against the OS appearance).
pub fn shown_theme(&self) -> egui::Theme {
self.shown_theme.unwrap_or_else(|| self.ui.theme.resolve(None))
@@ -731,6 +755,15 @@ impl CadApp {
}
}
/// Tell the interface whether the host has a native menu bar. Where it has none, the
/// in-window menu is the only menu, so it is shown and a reset keeps it.
pub fn set_native_menus(&mut self, on: bool) {
self.native_menus = on;
if !on {
self.ui.in_window_menu = true;
}
}
pub fn set_status(&mut self, s: impl Into<String>) {
self.status = Some((s.into(), now_ms()));
}
@@ -1087,6 +1120,7 @@ impl CadApp {
/// Draw one UI pass: title/toolbar, optional menu/status bar/file tabs, the standalone tool-set strip when a drawing is shown but Tool Sets is not docked, docking or the start page, and the floating overlays; record `frame_ms`. Runs on every pass, including one egui later discards.
fn draw(&mut self, ui: &mut egui::Ui) {
let t0 = now_ms();
self.sync_bars();
control::begin_frame(ui.ctx());
let t = theme::Tokens::get();
chrome::title_and_toolbar(self, ui);
@@ -1408,4 +1442,54 @@ mod tests {
let ui: UiState = serde_json::from_value(json!({ "saveFormat": "dwg" })).unwrap_or_default();
assert_eq!(ui.save_format, SaveFormat::Dwg);
}
#[test]
fn options_reset_brings_the_interface_back() {
// Hiding the interface (View/Window toggles) can leave no way back — on Windows the
// in-window menu bar is the only menu there is. Options > Reset must restore it (#1240).
let mut a = app();
a.run("ui.toggle.toolbar", json!({ "on": false })).unwrap();
a.run("ui.toggle.menubar", json!({ "on": cfg!(target_os = "macos") })).unwrap();
a.start("ui.hidepalettes");
assert!(!a.ui.show_toolbar && !a.ui.show_palettes && !a.ui.show_toolsets);
assert_eq!(a.ui.in_window_menu, cfg!(target_os = "macos"), "the test did not hide the menu bar");
a.run("options", json!({ "reset": true })).unwrap();
assert!(a.ui.show_toolbar, "the tool bar is still hidden");
assert!(a.ui.show_palettes, "the palettes are still hidden");
assert!(a.ui.show_toolsets);
assert_eq!(a.ui.in_window_menu, !cfg!(target_os = "macos"), "the menu bar did not come back");
}
#[test]
fn options_reset_keeps_the_menu_where_the_host_has_no_native_one() {
// With CADCRAFT_NO_NATIVE_MENU=1 the menus stay in the window: the host reports no native
// menu bar, so the in-window one is the only menu and the reset must leave it (#1240).
let mut a = app();
a.set_native_menus(false);
assert!(a.ui.in_window_menu, "the host's setting did not show the in-window menu");
a.run("ui.toggle.menubar", json!({ "on": false })).unwrap();
a.run("options", json!({ "reset": true })).unwrap();
assert!(a.ui.in_window_menu, "the only menu bar did not come back");
// Beside a native menu bar, the reset returns to the platform default.
a.set_native_menus(true);
a.run("ui.toggle.menubar", json!({ "on": true })).unwrap();
a.run("options", json!({ "reset": true })).unwrap();
assert!(!a.ui.in_window_menu, "the in-window menu is not the default beside a native one");
}
#[test]
fn options_reset_keeps_the_users_shortcuts_and_folders() {
// The reset brings hidden bars back (#1240); it must not also lose the user's own
// keyboard shortcuts or the folders the file pickers remember.
let mut a = app();
a.ui.shortcuts.insert("line".into(), "Ctrl+Shift+L".into());
a.ui.last_lisp_dir = Some("lisp-folder".into());
a.ui.last_pgp_dir = Some("pgp-folder".into());
a.run("ui.toggle.toolbar", json!({ "on": false })).unwrap();
a.run("options", json!({ "reset": true })).unwrap();
assert!(a.ui.show_toolbar, "the tool bar is still hidden");
assert_eq!(a.ui.shortcuts.get("line").map(String::as_str), Some("Ctrl+Shift+L"), "the reset lost a user shortcut");
assert_eq!(a.ui.last_lisp_dir.as_deref(), Some("lisp-folder"));
assert_eq!(a.ui.last_pgp_dir.as_deref(), Some("pgp-folder"));
}
}
+9 -2
View File
@@ -797,13 +797,20 @@ fn switch_on_hover(ctx: &egui::Context, titles: &[egui::Response]) {
}
}
/// Activate a menu command. QuickCalc toggles transparently; other items clear pending
/// command-line text and start their command interactively.
/// Activate a menu command. QuickCalc toggles transparently, and Reference Manager closes its
/// palette when it is open (typed XREF only opens it); other items clear pending command-line
/// text and start their command interactively.
pub fn activate(app: &mut CadApp, id: &str) {
if id == "ui.toggle.quickcalc" {
run_transparent(app, id);
return;
}
if id == "xref" && app.ui.docking.layout.contains(&crate::docking::Panel::ExternalRefs) {
if let Err(e) = crate::xrefs::close_palette(app) {
app.set_status(e);
}
return;
}
app.cmd.buffer.clear();
app.start(id);
}
+23 -6
View File
@@ -434,13 +434,30 @@ fn apply_right_click(o: &mut UiOptions, c: &UiChanges) {
/// The interface preferences back to their defaults (the interface language stays).
fn reset_ui(app: &mut CadApp) {
let d = crate::UiState::default();
app.ui.theme = d.theme;
app.ui.animations = d.animations;
app.ui.save_format = d.save_format;
app.ui.save_version = d.save_version;
// Everything interface, back to its defaults: a hidden menu bar, tool bar, palettes or
// panels and a rearranged panel layout come back — once the menu bar is hidden there may be
// no other way to reach the toggles (#1240). The interface language stays; the open dialog,
// the start tab, the recent files and the remembered folders are state, not preferences, and
// stay too. The user's keyboard shortcuts are their own customisation, which Window > Reset
// Palettes keeps as well: a reset meant to bring a bar back must not lose them.
let (language, dialog, start_tab) = (app.ui.interface_language, app.ui.dialog.take(), app.ui.start_tab);
let recent_files = std::mem::take(&mut app.ui.recent_files);
let shortcuts = std::mem::take(&mut app.ui.shortcuts);
let (last_lisp_dir, last_pgp_dir) = (app.ui.last_lisp_dir.take(), app.ui.last_pgp_dir.take());
app.ui = crate::UiState {
interface_language: language,
dialog,
start_tab,
recent_files,
shortcuts,
last_lisp_dir,
last_pgp_dir,
..Default::default()
};
// Where the host has no native menu bar the in-window one is the only menu: the reset must
// leave it in place (#1240).
app.ui.in_window_menu = !app.native_menus;
app.ui.system_cursor = app.system_cursor_default;
app.ui.history_lines = d.history_lines;
app.options = UiOptions::default();
}
+6
View File
@@ -42,6 +42,12 @@ fn open_palette(app: &mut CadApp) -> Result<Value, String> {
crate::docking::command(app, false, &json!({ "operation": "open", "panel": Panel::ExternalRefs.id() }))
}
/// Close the palette: Window ▸ Reference Manager while it is open, as Window ▸ QuickCalc closes
/// QuickCalc (#2273).
pub(crate) fn close_palette(app: &mut CadApp) -> Result<Value, String> {
crate::docking::command(app, false, &json!({ "operation": "close", "panel": Panel::ExternalRefs.id() }))
}
/// A picked file inside the host drawing's folder is attached by its relative path, so the
/// project folder can move.
fn relative_to_host(app: &CadApp, picked: &str) -> String {
+60 -1
View File
@@ -123,7 +123,7 @@ fn palette_icons_are_painted_in_code_and_shown_in_an_iconic_column() {
let ctx = egui::Context::default();
let mut paint = |panel: Panel| {
let mut painted = false;
let mut content = Panels { app: &mut app };
let mut content = Panels { app: &mut app, close: None };
let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
let painter = ui.ctx().layer_painter(egui::LayerId::background());
let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(20.0, 20.0));
@@ -593,3 +593,62 @@ fn group_drag_bar_moves_the_whole_group_into_the_other_dock() {
assert_eq!(frames(layout), [[Panel::Canvas]]);
assert_eq!(h.state().session.doc().unwrap(), &document);
}
/// Guard that every closable panel header offers a visible close button: a docked tab group,
/// the default accordion stack, and a floating group. Each click must remove the panel, the
/// button must not cover the title, and the tab context menu must still close the same panel.
#[test]
fn every_panel_header_has_a_close_button_that_closes_like_the_context_menu() {
let mut h = harness(None, 1280.0, 1.0);
assert!(h.query_by_label("Close Tool Sets").is_some(), "docked tab headers show a close button");
assert!(h.query_by_label("Close Drawing").is_none(), "the drawing view is not a closable panel");
// External References opens as a tabbed pane; its button sits beside the title, not over it.
h.state_mut().run("ui.dock", json!({"operation":"open","panel":"externalReferences"})).unwrap();
h.run_steps(4);
assert!(h.state().ui.docking.layout.contains(&Panel::ExternalRefs));
let close = h.get_by_label("Close External References").rect();
let title = h.get_by_role_and_label(egui::accesskit::Role::Tab, "External References").rect();
assert!(!close.intersects(title), "the close button does not cover the panel title");
h.get_by_label("Close External References").click();
h.run_steps(4);
assert!(!h.state().ui.docking.layout.contains(&Panel::ExternalRefs));
// Accordion headers (the default Layers/Properties stack) get one too.
assert!(h.state().ui.docking.layout.contains(&Panel::Layers));
h.get_by_label("Close Layers").click();
h.run_steps(4);
assert!(!h.state().ui.docking.layout.contains(&Panel::Layers));
// The context menu still closes the same panel after it is reopened.
h.state_mut().run("ui.dock", json!({"operation":"open","panel":"layers"})).unwrap();
h.run_steps(4);
assert!(h.state().ui.docking.layout.contains(&Panel::Layers));
h.get_by_role_and_label(egui::accesskit::Role::Tab, "Layers").click_button(PointerButton::Secondary);
h.run_steps(3);
// The docking surface's stock tab menu item ("Close Panel"), not our tooltip.
h.get_by_label("Close Panel").click();
h.run_steps(4);
assert!(!h.state().ui.docking.layout.contains(&Panel::Layers));
// Floating panels get the same button in their group header.
h.state_mut().run("ui.dock", json!({"operation":"float","panel":"properties","rect":[400,250,300,350]})).unwrap();
h.run_steps(4);
h.get_by_label("Close Properties").click();
h.run_steps(4);
assert!(!h.state().ui.docking.layout.contains(&Panel::Properties));
}
/// The accessible name is one translated string, not an English verb glued to a translated
/// panel label: Spanish readers must hear "Cerrar Capas", never "Close Capas".
#[test]
fn spanish_close_button_accessible_name_is_localized_as_a_whole() {
let mut h = harness(None, 1280.0, 1.0);
h.state_mut().run("ui.language", json!({"lang": "es"})).unwrap();
h.run_steps(4);
assert!(h.query_by_label("Cerrar Capas").is_some(), "the accordion close button is named in Spanish");
assert!(h.query_by_label("Cerrar Propiedades").is_some(), "every panel's close button follows the language");
assert!(h.query_by_label("Close Capas").is_none(), "no English verb survives the translation");
h.get_by_label("Cerrar Capas").click();
h.run_steps(4);
assert!(!h.state().ui.docking.layout.contains(&Panel::Layers), "the localized name still closes its panel");
}
+19
View File
@@ -252,3 +252,22 @@ fn selection_highlight_settings_set_save_and_show_in_the_selection_tab() {
assert!(text.contains(label), "{label} missing from:\n{text}");
}
}
#[test]
fn reset_brings_back_hidden_menu_bar_toolbar_and_status_bar() {
// #1240: with the in-window menu bar, the toolbar and the status bar hidden, OPTIONS ▸ Reset
// to Defaults (typed, or from the right-click menu) is the way back.
let mut a = app();
let d = cadcraft_ui_egui::UiState::default();
a.ui.in_window_menu = !d.in_window_menu;
a.ui.show_toolbar = false;
a.ui.show_status_bar = false;
a.ui.show_command_line = false;
a.ui.show_palettes = false;
a.run("options", json!({"reset": true})).unwrap();
assert_eq!(a.ui.in_window_menu, d.in_window_menu);
assert_eq!(a.ui.show_toolbar, d.show_toolbar);
assert_eq!(a.ui.show_status_bar, d.show_status_bar);
assert_eq!(a.ui.show_command_line, d.show_command_line);
assert_eq!(a.ui.show_palettes, d.show_palettes);
}
+107
View File
@@ -0,0 +1,107 @@
//! MENUBAR and TOOLBAR at the command line bring a hidden menu bar and tool bar back (#1341):
//! on Windows and Linux the in-window menu bar is the only menu, so with it hidden typing these
//! is the way back, as in AutoCAD.
use cadcraft_engine::Session;
use cadcraft_ui_egui::{CadApp, Services};
use serde_json::json;
fn app() -> CadApp {
CadApp::new(Session::new(), Services::default())
}
#[test]
fn typed_menubar_shows_and_hides_the_menu_bar() {
let mut app = app();
app.ui.in_window_menu = false;
app.cmdline("MENUBAR");
assert_eq!(app.session.prompt_text(), "MENUBAR Enter new value for MENUBAR <0>:");
app.cmdline("1");
assert!(app.session.running.is_none());
assert!(app.ui.in_window_menu);
// 0 hides it again; anything else is refused and asked again.
app.cmdline("MENUBAR");
app.cmdline("2");
assert!(app.session.running.is_some(), "still asking");
app.cmdline("0");
assert!(!app.ui.in_window_menu);
}
#[test]
fn typed_toolbar_shows_the_tool_bar_by_default() {
let mut app = app();
app.ui.show_toolbar = false;
app.cmdline("TOOLBAR");
assert_eq!(app.session.prompt_text(), "TOOLBAR Enter tool bar option or [Show/Hide] <Show>:");
app.cmdline("");
assert!(app.ui.show_toolbar);
app.cmdline("TOOLBAR");
app.cmdline("H");
assert!(!app.ui.show_toolbar);
}
#[test]
fn the_json_forms_report_and_set_the_bars() {
let mut app = app();
app.ui.in_window_menu = true;
app.ui.show_toolbar = false;
app.cmdline("MENUBAR");
app.cmdline("");
assert_eq!(app.session.execute("menubar", &json!({})).unwrap(), json!({ "value": 1 }));
assert_eq!(app.session.execute("toolbar", &json!({})).unwrap(), json!({ "show": false }));
app.session.execute("toolbar", &json!({ "show": true })).unwrap();
app.cmdline("MENUBAR");
app.cmdline("");
assert!(app.ui.show_toolbar && app.ui.in_window_menu);
assert!(app.session.execute("menubar", &json!({ "value": 3 })).is_err());
}
/// MENUBAR changes only the menu bar: a tool bar change made before the request is applied
/// stays (a control-API `ui.set` can come between them).
#[test]
fn menubar_leaves_a_later_tool_bar_change() {
let mut app = app();
app.ui.in_window_menu = true;
app.ui.show_toolbar = true;
app.session.execute("menubar", &json!({ "value": 0 })).unwrap();
app.ui.show_toolbar = false;
app.cmdline("'REDRAW");
assert!(!app.ui.in_window_menu, "MENUBAR applied");
assert!(!app.ui.show_toolbar, "the tool bar keeps its later change");
}
/// A bar query through `CadApp::run` reports the bars as the interface shows them now, even when
/// a UI change came just before it with no frame drawn in between.
#[test]
fn a_bar_query_sees_a_ui_change_just_made() {
let mut app = app();
app.ui.show_toolbar = true;
assert_eq!(app.run("toolbar", json!({})).unwrap(), json!({ "show": true }));
app.ui.show_toolbar = false;
assert_eq!(app.run("toolbar", json!({})).unwrap(), json!({ "show": false }));
app.run("toolbar", json!({ "show": true })).unwrap();
assert!(app.ui.show_toolbar, "the request is applied at once");
}
#[test]
fn menubar_started_from_the_ui_offers_the_bar_as_shown_now() {
let mut app = app();
app.ui.in_window_menu = true;
app.cmdline("");
app.ui.in_window_menu = false;
app.start("menubar");
let prompt = app.session.prompt_text();
assert!(prompt.contains("<0>"), "{prompt}");
}
#[test]
fn enter_through_the_control_api_applies_the_bar_before_the_next_request() {
let mut app = app();
let ctx = egui::Context::default();
app.ui.show_toolbar = false;
app.start("toolbar");
let (req, _pending) = cadcraft_ui_egui::control::ControlRequest::new("cmdline.key", serde_json::json!({ "key": "enter" }));
cadcraft_ui_egui::control::handle(&mut app, &ctx, &req);
assert!(app.session.running.is_none());
assert!(app.ui.show_toolbar, "TOOLBAR's default Show is applied before the next request");
}
+18 -1
View File
@@ -5,7 +5,7 @@ use cadcraft_engine::Session;
use cadcraft_engine::cmd::file::{IoHooks, set_io};
use cadcraft_engine::doc::geom::Vec3;
use cadcraft_engine::doc::{Drawing, Entity, EntityKind, Handle, Layer, Line, XrefStatus};
use cadcraft_ui_egui::{CadApp, Services, docking::Panel};
use cadcraft_ui_egui::{CadApp, Services, docking::Panel, menus};
use egui::vec2;
use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
@@ -71,6 +71,23 @@ fn xref_opens_the_palette_and_its_buttons_manage_the_xref() {
h.get_by_label("site");
}
/// Window ▸ Reference Manager closes the palette when it is open, like Window ▸ QuickCalc; typed,
/// XREF only ever opens it (#2273).
#[test]
fn the_window_menu_item_closes_an_open_palette() {
let mut app = CadApp::new(Session::default(), Services::default());
let open = |app: &CadApp| app.ui.docking.layout.contains(&Panel::ExternalRefs);
menus::activate(&mut app, "xref");
assert!(open(&app), "the menu item opens the palette");
menus::activate(&mut app, "xref");
assert!(!open(&app), "the menu item closes the open palette");
menus::activate(&mut app, "xref");
assert!(open(&app), "and opens it again");
assert!(app.cmdline("XREF").is_none());
assert!(app.cmdline("XR").is_none());
assert!(open(&app), "typed XREF keeps it open");
}
#[test]
fn json_xref_lists_and_never_opens_the_palette() {
let mut app = CadApp::new(Session::default(), Services::default());
+6
View File
@@ -144,6 +144,12 @@ The shortcut also works with text-field focus. Toggling preserves the running dr
and pending command-line input. The expression, history and calculator variables survive
closing/reopening within the same session; they are not saved across application restarts.
The External References palette (`externalReferences`) is not part of the default arrangement
either. Typed `XREF`/`XR` opens and activates it. **Window > Reference Manager** (also
`ui.menu.invoke` with `xref`) opens it too, but closes it when it is present, as Window >
QuickCalc does; closing leaves the running command and command-line input alone. `xref` with
JSON parameters lists the references and never opens or closes the palette.
Invoke these UI commands through `engine.execute`, for example `{"command":"ui.dock","params":{"operation":"float","panel":"layers","rect":[100,100,320,440]}}`.
Advanced `ui.dock` operations use the same validated transaction as pointer gestures: