mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-19 20:30:42 -06:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
198c36b406 | ||
|
|
2101a81d62 | ||
|
|
2827ccb6c8 | ||
|
|
8ec1e9a0a5 | ||
|
|
b184454275 | ||
|
|
077c054d18 | ||
|
|
5eafcc93bb | ||
|
|
7c366f7b5a | ||
|
|
a39d637814 | ||
|
|
dc7e5cdd6e | ||
|
|
e4f9b6aae3 | ||
|
|
140437e78e | ||
|
|
528e2698fe | ||
|
|
764204540a | ||
|
|
a516ce11eb | ||
|
|
03baa73ae5 | ||
|
|
797c5df792 | ||
|
|
736f56d320 | ||
|
|
a9b93676a4 | ||
|
|
19fc1f20be | ||
|
|
31866fcf05 | ||
|
|
ed8555875a | ||
|
|
6f862d7b4b | ||
|
|
b1a34dc0ef | ||
|
|
f24da7a85b | ||
|
|
6a240a7076 | ||
|
|
f903621540 | ||
|
|
063cbef279 | ||
|
|
51f38b4eda | ||
|
|
348d767b93 | ||
|
|
82779b50d0 | ||
|
|
09d2e06862 | ||
|
|
16e0fa5293 | ||
|
|
f13a1f2e39 | ||
|
|
44b0399aa6 | ||
|
|
bb91014ebd | ||
|
|
b439879181 | ||
|
|
5154f5757b | ||
|
|
661e5e2dd9 | ||
|
|
225407ca61 | ||
|
|
01c003e407 | ||
|
|
50644fb0c4 | ||
|
|
23c55fc1a8 | ||
|
|
1a1d8404b6 | ||
|
|
f998f2f663 | ||
|
|
f91d5ad38f | ||
|
|
aaaf654872 | ||
|
|
cfc4fc5e88 | ||
|
|
bcac20dd5f |
+76
-9
@@ -44,6 +44,11 @@ pub use store::EntityStore;
|
||||
pub use tables::*;
|
||||
pub use xclip::{ClipBoundary, MAX_CLIP_VERTICES};
|
||||
|
||||
/// Handles at or above this are not followed: a file may name one (an object's handle, or its
|
||||
/// `$HANDSEED`), and the four billion handles above the limit stay free for the drawing's own
|
||||
/// growth. A file's handles keep their identity, however high they are (#913, #939).
|
||||
pub const HANDLE_LIMIT: u64 = u64::MAX - 0xFFFF_FFFF;
|
||||
|
||||
/// File data CADCraft doesn't model, kept for saving (#528).
|
||||
pub mod dynblock;
|
||||
pub mod foreign;
|
||||
@@ -127,6 +132,10 @@ pub struct Drawing {
|
||||
pub scales: Vec<AnnoScale>,
|
||||
/// Next free handle.
|
||||
pub handseed: u64,
|
||||
/// Handles a file's records hold in the reserved band, recorded while reading before the
|
||||
/// record is placed: [`Drawing::new_handle`] skips them meanwhile. [`Drawing::bump_handseed`]
|
||||
/// does not follow them (#913). Emptied once the file is read; never written to a file.
|
||||
pub reserved_handles: BTreeSet<u64>,
|
||||
/// Objects hidden for this session by ISOLATEOBJECTS / HIDEOBJECTS. Never written to a file:
|
||||
/// a drawing opens with everything shown again.
|
||||
pub hidden_objects: BTreeSet<Handle>,
|
||||
@@ -200,6 +209,7 @@ impl Drawing {
|
||||
parametric: Parametric::default(),
|
||||
scales: imperial_scales(),
|
||||
handseed: 0x100,
|
||||
reserved_handles: BTreeSet::new(),
|
||||
hidden_objects: BTreeSet::new(),
|
||||
read_notes: Vec::new(),
|
||||
refedit: None,
|
||||
@@ -209,26 +219,83 @@ impl Drawing {
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocate a fresh handle. It skips the handles the drawing's file gave the objects CADCraft
|
||||
/// writes itself ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a
|
||||
/// file CADCraft wrote numbers them above its `$HANDSEED` (#495).
|
||||
/// Allocate a fresh handle: [`Drawing::next_handle`], with the seed moved past it. Past the
|
||||
/// top of the range the drawing goes on growing in the reserved band (#913).
|
||||
pub fn new_handle(&mut self) -> Handle {
|
||||
let h = self.next_handle();
|
||||
self.handseed = h.0.saturating_add(1);
|
||||
self.handseed = h.0.checked_add(1).unwrap_or(HANDLE_LIMIT);
|
||||
h
|
||||
}
|
||||
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it.
|
||||
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it:
|
||||
/// the first one at or above the seed that nothing holds. It skips
|
||||
/// - the handles the drawing's file gave the objects CADCraft writes itself
|
||||
/// ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a file
|
||||
/// CADCraft wrote numbers them above its `$HANDSEED` (#495);
|
||||
/// - handles an object or a file record being read holds in the reserved band above
|
||||
/// [`HANDLE_LIMIT`]. A hostile or damaged file may name a `$HANDSEED` there, and a file
|
||||
/// object may hold that same handle; the seed does not follow a file's handles in the band,
|
||||
/// so taking it as-is would hand the file's object's handle to a new object and
|
||||
/// `EntityStore` would replace it (#913, #1921);
|
||||
/// - handle 0, which a file reads as "no handle".
|
||||
///
|
||||
/// Off the top of the range it goes on at the bottom of the band.
|
||||
///
|
||||
/// Cost: below the band the reader and [`Drawing::bump_handseed`] keep the seed above every
|
||||
/// handle an object holds (AUDIT repairs a drawing where that fails), and reserved handles are
|
||||
/// all in the band, so there only `foreign.handles` is looked up. The scan of every space and
|
||||
/// block definition runs only for a candidate in the band. Every handle skipped is a distinct
|
||||
/// one something holds, so the walk ends within one step more than the count of held handles.
|
||||
pub fn next_handle(&self) -> Handle {
|
||||
let held = |h: u64| {
|
||||
h == 0
|
||||
|| self.foreign.handles.contains_key(&Handle(h))
|
||||
|| (h >= HANDLE_LIMIT && (self.reserved_handles.contains(&h) || self.handle_in_use(Handle(h))))
|
||||
};
|
||||
let mut h = self.handseed;
|
||||
while self.foreign.handles.contains_key(&Handle(h)) && h < u64::MAX {
|
||||
h = h.saturating_add(1);
|
||||
// Counted only once a handle is skipped, so the usual first-try answer costs nothing.
|
||||
let mut steps_left: Option<usize> = None;
|
||||
while held(h) {
|
||||
let left = steps_left.get_or_insert_with(|| self.held_handle_count());
|
||||
let Some(rest) = left.checked_sub(1) else { break };
|
||||
*left = rest;
|
||||
h = h.checked_add(1).unwrap_or(HANDLE_LIMIT);
|
||||
}
|
||||
Handle(h)
|
||||
}
|
||||
|
||||
/// Whether an object in any space or block definition already holds `h`.
|
||||
fn handle_in_use(&self, h: Handle) -> bool {
|
||||
self.model.contains(h) || self.layouts.iter().any(|l| l.entities.contains(h)) || self.blocks.values().any(|b| b.entities.contains(h))
|
||||
}
|
||||
/// An upper bound on how many handles [`Drawing::next_handle`] can find held, plus handle 0.
|
||||
fn held_handle_count(&self) -> usize {
|
||||
let spaces = self.layouts.iter().map(|l| l.entities.len()).chain(self.blocks.values().map(|b| b.entities.len()));
|
||||
spaces
|
||||
.fold(self.model.len(), usize::saturating_add)
|
||||
.saturating_add(self.foreign.handles.len())
|
||||
.saturating_add(self.reserved_handles.len())
|
||||
.saturating_add(1)
|
||||
}
|
||||
/// Record a handle a file's record holds in the reserved band, before the record is placed in
|
||||
/// the drawing, so [`Drawing::new_handle`] does not hand it to an object read earlier (#1276).
|
||||
///
|
||||
/// Only handles at or above [`HANDLE_LIMIT`] are recorded: below it [`Drawing::bump_handseed`]
|
||||
/// already moves the seed past them. The reservation stays separate from the seed because the
|
||||
/// writer's growth lives above the limit and a file's handles there are not followed (#913).
|
||||
pub fn reserve_handle(&mut self, h: Handle) {
|
||||
if h.0 >= HANDLE_LIMIT {
|
||||
self.reserved_handles.insert(h.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// Make sure future handles don't collide with `h` (after loading a file).
|
||||
///
|
||||
/// A handle at or above [`HANDLE_LIMIT`] is the file's own and stays as it is: it is not
|
||||
/// followed, so a new object is never given the top handle and the file's object is never
|
||||
/// replaced (#913). The handles above the limit are the drawing's room to grow.
|
||||
pub fn bump_handseed(&mut self, h: Handle) {
|
||||
if h.0 >= self.handseed {
|
||||
self.handseed = h.0.saturating_add(1);
|
||||
if h.0 >= self.handseed && h.0 < HANDLE_LIMIT {
|
||||
self.handseed = h.0 + 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -805,11 +805,9 @@ pub struct PageSetup {
|
||||
/// Plot objects with their transparency ("Plot transparency"; PLOTTRANSPARENCYOVERRIDE can
|
||||
/// override it). The DXF plot layout flags have no bit for it, so it is not saved in DXF.
|
||||
pub plot_transparency: bool,
|
||||
/// Explicit paper-space unit for the layout: `Some(true)` for millimetres (plot paper units 1
|
||||
/// in DXF), `Some(false)` for inches, or `None` to follow the drawing's `MEASUREMENT` (#1058,
|
||||
/// #3249).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub paper_mm: Option<bool>,
|
||||
/// The layout's paper units are millimetres (plot paper units 1 in DXF) whatever the
|
||||
/// drawing's MEASUREMENT says; otherwise paper units follow MEASUREMENT (#1058).
|
||||
pub paper_mm: bool,
|
||||
/// Paper size (DXF groups 44, 45) and plot rotation (group 73) as the file stored them.
|
||||
/// Saving writes them back while they still describe `width_mm`, `height_mm` and
|
||||
/// `landscape`, so each program's convention for media defined wider than tall survives a
|
||||
@@ -841,7 +839,7 @@ impl Default for PageSetup {
|
||||
lineweights: true,
|
||||
show_plot_styles: false,
|
||||
plot_transparency: false,
|
||||
paper_mm: None,
|
||||
paper_mm: false,
|
||||
file_paper: None,
|
||||
image_origin: None,
|
||||
}
|
||||
|
||||
@@ -726,6 +726,34 @@ fn new_handles_skip_the_files_object_handles() {
|
||||
assert_eq!(d.new_handle(), Handle(next + 3));
|
||||
}
|
||||
|
||||
/// In the reserved band a new handle skips the file's kept object handles (#2514) and the handles
|
||||
/// objects hold in model space, a layout and a block definition, or that a file record reserved
|
||||
/// (#913); off the top of the range it goes on at the bottom of the band. HANDSEED reports the
|
||||
/// handle `new_handle` takes.
|
||||
#[test]
|
||||
fn new_handles_in_the_reserved_band_skip_every_held_handle_and_wrap() {
|
||||
let mut d = Drawing::new_metric();
|
||||
let top = u64::MAX;
|
||||
d.model.push(Entity::new(Handle(top - 4), line((0.0, 0.0), (1.0, 0.0))));
|
||||
let mut sheet = Layout::new("Sheet", 1);
|
||||
sheet.entities.push(Entity::new(Handle(top - 3), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.layouts.push(sheet);
|
||||
let mut b = Block::new("B");
|
||||
b.entities.push(Entity::new(Handle(top - 2), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.blocks.insert("B".into(), std::sync::Arc::new(b));
|
||||
std::sync::Arc::make_mut(&mut d.foreign).handles.insert(Handle(top - 1), ("LAYER".into(), "0".into()));
|
||||
d.reserve_handle(Handle(top));
|
||||
d.model.push(Entity::new(Handle(HANDLE_LIMIT), line((0.0, 0.0), (1.0, 0.0))));
|
||||
d.handseed = top - 5;
|
||||
assert_eq!(d.new_handle(), Handle(top - 5));
|
||||
assert_eq!(d.next_handle(), Handle(HANDLE_LIMIT + 1), "a held handle was offered");
|
||||
assert_eq!(d.new_handle(), Handle(HANDLE_LIMIT + 1));
|
||||
assert_eq!(d.handseed, HANDLE_LIMIT + 2);
|
||||
// Handle 0 means "no handle" in a file; a seed there moves on.
|
||||
d.handseed = 0;
|
||||
assert_eq!(d.new_handle(), Handle(1));
|
||||
}
|
||||
|
||||
/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
|
||||
#[test]
|
||||
fn dim_style_spellings_of_one_field_apply_once() {
|
||||
|
||||
@@ -319,8 +319,14 @@ fn all_handles(d: &Drawing) -> HashSet<Handle> {
|
||||
}
|
||||
|
||||
/// The next handle is above every handle in use, so new objects never take an existing one.
|
||||
///
|
||||
/// A handle at or above [`cadcraft_doc::HANDLE_LIMIT`] is the file's own and is deliberately not
|
||||
/// followed: the seed never moves past it, and new objects take free handles in the band above
|
||||
/// the limit. Reporting it would repeat the same repair on every audit, so it is not an issue.
|
||||
/// Such a handle is left out of the maximum too, or the largest handle would hide every ordinary
|
||||
/// one behind it and the seed would never be repaired past them.
|
||||
fn handseed(d: &mut Drawing, out: &mut Vec<Issue>) {
|
||||
let Some(max) = each_entity(d).map(|e| e.handle).max() else { return };
|
||||
let Some(max) = each_entity(d).map(|e| e.handle).filter(|h| h.0 < cadcraft_doc::HANDLE_LIMIT).max() else { return };
|
||||
if max.0 >= d.handseed {
|
||||
out.push(issue(
|
||||
"handseed",
|
||||
|
||||
@@ -11,7 +11,7 @@ use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use cadcraft_color::Rgb;
|
||||
use cadcraft_doc::{Drawing, Entity, EntityKind, Space};
|
||||
use cadcraft_doc::{Drawing, Entity, EntityKind, PageSetup, Space};
|
||||
use cadcraft_geom::{Bounds2, Mat3, Vec2};
|
||||
use cadcraft_render::paper::{self, Sheet};
|
||||
use cadcraft_render::raster::{RasterOptions, View};
|
||||
@@ -276,8 +276,18 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let d = s.doc()?;
|
||||
let mut page = match space.layout() {
|
||||
Some(n) => d.layout(n).map(|l| l.page.clone()).unwrap_or_default(),
|
||||
// Model space plots on ISO A4 (metric) or ANSI A, like the PDF plotter.
|
||||
None => paper::model_page(d),
|
||||
None => {
|
||||
// Model space plots on A4 (metric) or ANSI A, like the PDF plotter.
|
||||
let mut page = PageSetup::default();
|
||||
if paper::paper_unit_mm(d) == 1.0
|
||||
&& let Some(a4) = paper::paper_size("A4")
|
||||
{
|
||||
page.paper = a4.name.into();
|
||||
page.width_mm = a4.width_mm;
|
||||
page.height_mm = a4.height_mm;
|
||||
}
|
||||
page
|
||||
}
|
||||
};
|
||||
if let Some(name) = str_param(p, "paper") {
|
||||
let ps = paper::paper_size(name).ok_or_else(|| bad("preview", format!("unknown paper size `{name}`")))?;
|
||||
@@ -285,10 +295,6 @@ fn run_preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
page.width_mm = ps.width_mm;
|
||||
page.height_mm = ps.height_mm;
|
||||
}
|
||||
// A model-space plot takes its units from the paper it was given (a layout keeps its page setup's).
|
||||
if matches!(space, Space::Model) {
|
||||
paper::apply_model_paper_units(&mut page);
|
||||
}
|
||||
if let Some(l) = p.get("landscape").and_then(Value::as_bool) {
|
||||
page.landscape = l;
|
||||
}
|
||||
|
||||
@@ -18,8 +18,13 @@ use crate::{Result, Session};
|
||||
/// Most image files loaded per drawing.
|
||||
const MAX_IMAGE_FILES: usize = 1000;
|
||||
/// Largest image file read (bytes).
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
const MAX_IMAGE_BYTES: u64 = 256 << 20;
|
||||
/// Longest base64 text taken for `data`: what a file of [`MAX_IMAGE_BYTES`] encodes to.
|
||||
const MAX_IMAGE_BASE64: u64 = MAX_IMAGE_BYTES.div_ceil(3) * 4;
|
||||
/// Longest `data` text with the line breaks and spaces base64 may carry (MIME breaks every 76
|
||||
/// characters, under 3% more): the characters past [`MAX_IMAGE_BASE64`] are counted only up to
|
||||
/// here, which also bounds what decoding sets aside.
|
||||
const MAX_IMAGE_TEXT: u64 = MAX_IMAGE_BASE64 + MAX_IMAGE_BASE64 / 16;
|
||||
/// Most decoded pixel bytes kept per drawing; images past it stay unloaded.
|
||||
const MAX_LOADED_BYTES: u64 = 2 << 30;
|
||||
/// Most image files decoded at the same time when a drawing opens.
|
||||
@@ -70,11 +75,22 @@ fn paths(d: &Drawing) -> Vec<String> {
|
||||
paths
|
||||
}
|
||||
|
||||
/// Whether `path` is a full path here, or on Windows where a drawing may have been written (a
|
||||
/// drive, `C:\maps\a.png`, or a share, `\\server\maps`), which other systems read as relative.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn full_path(path: &str) -> bool {
|
||||
let b = path.trim().as_bytes();
|
||||
std::path::Path::new(path.trim()).is_absolute() || b.starts_with(b"\\\\") || matches!(b, [d, b':', b'\\' | b'/', ..] if d.is_ascii_alphabetic())
|
||||
}
|
||||
|
||||
/// The contents of the image file saved as `path` in a drawing at `host`.
|
||||
fn read_file(path: &str, host: Option<&str>) -> std::result::Result<Vec<u8>, String> {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
let file = super::blocks::xref::find_file(path, host).ok_or("file not found")?;
|
||||
let file = super::blocks::xref::find_file(path, host).ok_or_else(|| {
|
||||
// An unsaved drawing has no folder for a relative path to be relative to.
|
||||
if host.is_none() && !full_path(path) { "file not found (save the drawing first, or give a full path)" } else { "file not found" }
|
||||
})?;
|
||||
let len = std::fs::metadata(&file).map_err(|e| e.to_string())?.len();
|
||||
if len > MAX_IMAGE_BYTES {
|
||||
return Err(format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20));
|
||||
@@ -304,7 +320,19 @@ fn pixels(s: &Session, p: &Value, path: &str) -> Result<Arc<Raster>> {
|
||||
let bytes = match p.get("data") {
|
||||
Some(data) => {
|
||||
let text = data.as_str().ok_or_else(|| bad(ID, "`data` must be base64 text"))?;
|
||||
base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?
|
||||
// Refused before decoding, which would hold all of it in memory. Line breaks and
|
||||
// spaces, which decoding skips, don't count.
|
||||
let len = u64::try_from(text.len()).unwrap_or(u64::MAX);
|
||||
let digits = || u64::try_from(text.bytes().filter(|b| !matches!(b, b'\n' | b'\r' | b' ')).count()).unwrap_or(u64::MAX);
|
||||
if len > MAX_IMAGE_TEXT || (len > MAX_IMAGE_BASE64 && digits() > MAX_IMAGE_BASE64) {
|
||||
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
|
||||
}
|
||||
let bytes = base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?;
|
||||
// The longest text allowed can still hold a byte or two more than the limit.
|
||||
if u64::try_from(bytes.len()).unwrap_or(u64::MAX) > MAX_IMAGE_BYTES {
|
||||
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
|
||||
}
|
||||
bytes
|
||||
}
|
||||
None => {
|
||||
if let Some(loaded) = s.doc()?.rasters.get(path) {
|
||||
|
||||
@@ -78,7 +78,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
CommandSpec::new("pagesetup", "Page Setup Manager...", run_pagesetup)
|
||||
.menu(&["File", "Page Setup Manager..."])
|
||||
.params(
|
||||
"{layout?: current, device?: plotter name (PLOTTERMANAGER) | \"None\", paper?: the device's paper | \"A4\"|\"A3\"|\"Letter\"|\"ANSI B\"|…, width?, height? (mm), landscape?, paperUnits?: \"mm\"|\"inches\" (one paper-space unit on the layout), margins?: [l,b,r,t] mm, lineweights?, plotArea?, scale?, scaleToFit?, center?, plotStyleTable?: \"monochrome.ctb\"|\"grayscale.ctb\"|\"default.ctb\"|\"None\"|…, displayPlotStyles?: bool, plotTransparency?: bool}",
|
||||
"{layout?: current, device?: plotter name (PLOTTERMANAGER) | \"None\", paper?: the device's paper | \"A4\"|\"A3\"|\"Letter\"|\"ANSI B\"|…, width?, height? (mm), landscape?, margins?: [l,b,r,t] mm, lineweights?, plotArea?, scale?, scaleToFit?, center?, plotStyleTable?: \"monochrome.ctb\"|\"grayscale.ctb\"|\"default.ctb\"|\"None\"|…, displayPlotStyles?: bool, plotTransparency?: bool}",
|
||||
),
|
||||
CommandSpec::new("plot", "Print...", |s, p| run_plot(s, &super::plotters::plot_options(s, p, "plot")?, "plot"))
|
||||
.menu(&["File", "Print..."])
|
||||
@@ -641,7 +641,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
"width",
|
||||
"height",
|
||||
"landscape",
|
||||
"paperUnits",
|
||||
"margins",
|
||||
"lineweights",
|
||||
"plotArea",
|
||||
@@ -683,22 +682,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
page.width_mm = ps.width_mm;
|
||||
page.height_mm = ps.height_mm;
|
||||
}
|
||||
// The picked paper's own units become the layout's paper units: millimetres for a metric
|
||||
// paper, else the drawing's MEASUREMENT. Otherwise ISO A0 in a new (imperial) drawing's
|
||||
// layout is 33.11 x 46.81 units (#2836). This holds for a standard size from the page's
|
||||
// device's list too (the built-in devices list every standard size), and a device's own
|
||||
// paper that is not a standard size keeps the layout's units. Only a saved page setup changes
|
||||
// units; a one-off plot's `paper` keeps the layout's, so its objects stay the size they were
|
||||
// drawn. A custom `width` and `height` in the same call replace this paper below, and a
|
||||
// custom size keeps the layout's units, with `paper` or without it. An explicit `paperUnits`
|
||||
// in the same call wins (below).
|
||||
if p.get("paper").is_some()
|
||||
&& p.get("width").is_none()
|
||||
&& p.get("height").is_none()
|
||||
&& let Some(ps) = cadcraft_render::paper_size(&page.paper)
|
||||
{
|
||||
page.paper_mm = (!ps.imperial).then_some(true);
|
||||
}
|
||||
let mm = |k: &str| p.get(k).and_then(Value::as_f64).filter(|v| v.is_finite() && *v > 0.0 && *v <= 5080.0);
|
||||
match (mm("width"), mm("height")) {
|
||||
(Some(w), Some(h)) => {
|
||||
@@ -712,15 +695,6 @@ fn run_pagesetup(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if let Some(l) = p.get("landscape").and_then(Value::as_bool) {
|
||||
page.landscape = l;
|
||||
}
|
||||
// Paper units: what one paper-space unit is on this layout, whatever the paper's own family
|
||||
// (an ARCH D sheet can be drawn in millimetres, #3249).
|
||||
if let Some(v) = p.get("paperUnits") {
|
||||
page.paper_mm = Some(match v.as_str().map(str::to_ascii_lowercase).as_deref() {
|
||||
Some("mm" | "millimeters" | "millimetres") => true,
|
||||
Some("in" | "inch" | "inches") => false,
|
||||
_ => return Err(bad(cmd, "`paperUnits` must be \"mm\" or \"inches\"")),
|
||||
});
|
||||
}
|
||||
if let Some(m) = p.get("margins") {
|
||||
let a: Vec<f64> = m.as_array().map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
|
||||
match a[..] {
|
||||
|
||||
@@ -165,57 +165,14 @@ fn viewport_scale_lock_and_layers() {
|
||||
}
|
||||
}
|
||||
|
||||
/// #2836: picking a paper sets the layout's paper units from it. In a new drawing (imperial,
|
||||
/// MEASUREMENT 0) ISO A0 was 46.81 x 33.11 units, the inch equivalent; now it is 1189 x 841.
|
||||
/// An inch paper gives the layout back the drawing's units.
|
||||
#[test]
|
||||
fn pagesetup_paper_sets_the_layout_paper_units() {
|
||||
let mut s = Session::new();
|
||||
assert_eq!(cadcraft_render::paper::paper_unit_mm(s.doc().unwrap()), 25.4, "a new drawing is imperial");
|
||||
let size = |s: &Session| {
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
((sheet.size.x * 100.0).round() / 100.0, (sheet.size.y * 100.0).round() / 100.0, sheet.unit_mm)
|
||||
};
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A0", "landscape": true})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], true);
|
||||
assert_eq!(size(&s), (1189.0, 841.0, 1.0), "ISO A0 in millimetres");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ANSI D"})).unwrap();
|
||||
assert_eq!(size(&s), (34.0, 22.0, 25.4), "ANSI D in the drawing's inches");
|
||||
// A custom size replaces the named paper in the same call and keeps the layout's units.
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A4", "width": 254, "height": 508})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, None, "the layout still follows MEASUREMENT");
|
||||
assert_eq!(size(&s), (20.0, 10.0, 25.4), "the custom size in the layout's inches");
|
||||
}
|
||||
|
||||
/// #2836 through a device: the built-in devices list every standard size, so a paper picked in
|
||||
/// Page Setup with CADCraft PDF as the device comes from the device's list. It sets the layout's
|
||||
/// paper units as a paper picked with no device does.
|
||||
#[test]
|
||||
fn pagesetup_device_paper_sets_the_layout_paper_units() {
|
||||
let mut s = Session::new();
|
||||
let size = |s: &Session| {
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
((sheet.size.x * 100.0).round() / 100.0, (sheet.size.y * 100.0).round() / 100.0, sheet.unit_mm)
|
||||
};
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "device": "CADCraft PDF", "landscape": true})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ISO A0 (841.00 x 1189.00 MM)"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.device, "CADCraft PDF");
|
||||
assert_eq!(size(&s), (1189.0, 841.0, 1.0), "ISO A0 from the device's list in millimetres");
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ANSI D"})).unwrap();
|
||||
assert_eq!(size(&s), (34.0, 22.0, 25.4), "ANSI D from the device's list in the drawing's inches");
|
||||
// An explicit choice in the same call wins over the paper's own units (#3249).
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "paperUnits": "mm"})).unwrap();
|
||||
assert_eq!(size(&s), (914.4, 609.6, 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_table() {
|
||||
let mut s = Session::new();
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "A3", "landscape": true, "margins": [5, 5, 5, 5]})).unwrap();
|
||||
assert_eq!(r["page"]["widthMm"], 297.0);
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
// An imperial drawing, but a metric paper: the layout's paper units are millimetres (#2836).
|
||||
assert!((sheet.size.x - 420.0).abs() < 1e-9 && (sheet.size.y - 297.0).abs() < 1e-9);
|
||||
// Imperial drawing: paper units are inches.
|
||||
assert!((sheet.size.x - 420.0 / 25.4).abs() < 1e-9 && (sheet.size.y - 297.0 / 25.4).abs() < 1e-9);
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "Z12"})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "margins": [1, 2]})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "width": 1e308, "height": 5})).is_err());
|
||||
@@ -233,40 +190,6 @@ fn pagesetup_paper_table() {
|
||||
assert_eq!((p.width_mm, p.height_mm), (300.0, 500.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_units_make_an_inch_sheet_metric() {
|
||||
// An ARCH D sheet in a drawing that measures in millimetres (#3249): the page setup's paper
|
||||
// units decide the paper-space unit, so the sheet can be 914.4 x 609.6 mm.
|
||||
let mut s = Session::new();
|
||||
s.execute("units", &json!({"insunits": 4})).unwrap();
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true, "paperUnits": "mm"})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], true);
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((sheet.size.x - 914.4).abs() < 1e-9 && (sheet.size.y - 609.6).abs() < 1e-9, "{:?}", sheet.size);
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "Inches"})).unwrap();
|
||||
let sheet = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((sheet.size.x - 36.0).abs() < 1e-9 && (sheet.size.y - 24.0).abs() < 1e-9, "{:?}", sheet.size);
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "millimeters"})).unwrap();
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, Some(true));
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "feet"})).is_err());
|
||||
assert!(s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": 4})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pagesetup_paper_units_inches_overrides_metric_measurement() {
|
||||
let mut s = Session::new();
|
||||
s.execute("setvar", &json!({"name": "MEASUREMENT", "value": 1})).unwrap();
|
||||
s.execute("pagesetup", &json!({"layout": "Layout1", "paper": "ARCH D", "landscape": true})).unwrap();
|
||||
// Without an explicit paperUnits choice, MEASUREMENT = 1 keeps the sheet in millimetres.
|
||||
let metric = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((metric.size.x - 914.4).abs() < 1e-9 && (metric.size.y - 609.6).abs() < 1e-9, "{:?}", metric.size);
|
||||
let r = s.execute("pagesetup", &json!({"layout": "Layout1", "paperUnits": "inches"})).unwrap();
|
||||
assert_eq!(r["page"]["paperMm"], false);
|
||||
assert_eq!(s.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, Some(false));
|
||||
let inch = cadcraft_render::sheet(s.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((inch.size.x - 36.0).abs() < 1e-9 && (inch.size.y - 24.0).abs() < 1e-9, "{:?}", inch.size);
|
||||
}
|
||||
|
||||
fn fake_plot(d: &Drawing, space: &Space, opts: &Value) -> std::result::Result<Vec<u8>, String> {
|
||||
let _ = d;
|
||||
Ok(format!("%PDF-1.4 fake {space:?} {opts}").into_bytes())
|
||||
|
||||
@@ -139,6 +139,9 @@ pub struct LispState {
|
||||
/// Interpreter steps all synchronous callbacks have run, nested ones included. A callback's
|
||||
/// allowance counts what ran since it started, so the callbacks it calls spend its steps.
|
||||
pub(crate) callback_used: u64,
|
||||
/// Work synchronous callbacks did inside the running step, already counted in `callback_used`:
|
||||
/// the step is charged it without charging the enclosing callback a second time.
|
||||
pub(crate) callback_work: u64,
|
||||
/// The `callback_used` value the callback running now (and so every one it calls) must not
|
||||
/// pass: the lowest of its own and its callers' allowances.
|
||||
pub(crate) callback_ceiling: Option<u64>,
|
||||
@@ -383,6 +386,14 @@ impl Session {
|
||||
let uid = run.uid;
|
||||
self.lisp_flush(&mut env, false);
|
||||
self.lisp_env_put(uid, env);
|
||||
// The work the slice did, which one step can take far past the slice. After a panic
|
||||
// `used` is still the previous slice's; the run ends with the error anyway.
|
||||
run.steps = run.steps.saturating_add(run.machine.used);
|
||||
if run.blocking && run.steps > BLOCKING_CAP && matches!(outcome, Outcome::Wait(_)) {
|
||||
self.lisp.run = Some(run);
|
||||
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
|
||||
return;
|
||||
}
|
||||
match outcome {
|
||||
Outcome::Done(v) => {
|
||||
self.lisp.run = Some(run);
|
||||
@@ -395,13 +406,7 @@ impl Session {
|
||||
return;
|
||||
}
|
||||
Outcome::Wait(Need::Yield) => {
|
||||
run.steps = run.steps.saturating_add(SLICE);
|
||||
if run.blocking {
|
||||
if run.steps > BLOCKING_CAP {
|
||||
self.lisp.run = Some(run);
|
||||
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
|
||||
return;
|
||||
}
|
||||
self.lisp.run = Some(run);
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -175,17 +175,19 @@ pub struct Machine {
|
||||
stack: Vec<Frame>,
|
||||
state: State,
|
||||
need: Option<Need>,
|
||||
/// Steps the last [`Machine::run`] took, with the work done inside them.
|
||||
pub(crate) used: u64,
|
||||
}
|
||||
|
||||
impl Machine {
|
||||
/// A machine evaluating `forms` in turn.
|
||||
pub fn forms(forms: Vec<Value>) -> Machine {
|
||||
Machine { stack: vec![Frame::Forms { rest: forms.into_iter().rev().collect() }], state: State::Ret(Value::Nil), need: None }
|
||||
Machine { stack: vec![Frame::Forms { rest: forms.into_iter().rev().collect() }], state: State::Ret(Value::Nil), need: None, used: 0 }
|
||||
}
|
||||
|
||||
/// A machine calling `f` with `args`.
|
||||
pub fn calling(f: Value, args: Vec<Value>) -> Machine {
|
||||
Machine { stack: Vec::new(), state: State::Call(f, args), need: None }
|
||||
Machine { stack: Vec::new(), state: State::Call(f, args), need: None, used: 0 }
|
||||
}
|
||||
|
||||
/// Give the value a [`Need`] waited for, and carry on.
|
||||
@@ -193,12 +195,31 @@ impl Machine {
|
||||
self.state = State::Ret(v);
|
||||
}
|
||||
|
||||
/// Run until done, waiting, or `budget` steps.
|
||||
/// Run until done, waiting, or `budget` steps. A step that walks a long list (`length`) or
|
||||
/// runs a synchronous callback counts that work too, so one slice stays short.
|
||||
pub fn run(&mut self, ctx: &mut Ctx<'_>, budget: u64) -> Outcome {
|
||||
let mut n = 0u64;
|
||||
let outcome = self.run_counted(ctx, budget, &mut n);
|
||||
// The last step's work too, so nothing is left for the next run.
|
||||
self.used = n.saturating_add(Machine::take_step_work(ctx));
|
||||
outcome
|
||||
}
|
||||
|
||||
/// The work the last step did besides itself: the lists it walked, which count against a
|
||||
/// callback's allowance too, and the callbacks it ran, which were counted there as they ran.
|
||||
fn take_step_work(ctx: &mut Ctx<'_>) -> u64 {
|
||||
let walked = super::value::take_work();
|
||||
let callbacks = std::mem::take(&mut ctx.s.lisp.callback_work);
|
||||
if ctx.depth > 0 {
|
||||
ctx.s.lisp.callback_used = ctx.s.lisp.callback_used.saturating_add(walked);
|
||||
}
|
||||
walked.saturating_add(callbacks)
|
||||
}
|
||||
|
||||
fn run_counted(&mut self, ctx: &mut Ctx<'_>, budget: u64, n: &mut u64) -> Outcome {
|
||||
loop {
|
||||
n += 1;
|
||||
if n > budget {
|
||||
*n = n.saturating_add(1).saturating_add(Machine::take_step_work(ctx));
|
||||
if *n > budget {
|
||||
return Outcome::Wait(Need::Yield);
|
||||
}
|
||||
// Charge a callback's step as it runs, so callbacks it calls see what it already spent.
|
||||
@@ -651,6 +672,10 @@ impl Ctx<'_> {
|
||||
return Ok(v);
|
||||
}
|
||||
let cap = self.s.lisp.limits.callback_steps;
|
||||
// Work the caller queued before this call (its list walks, earlier callbacks of the same
|
||||
// step) is not this callback's: set it aside and hand it back with this callback's.
|
||||
let pending = super::value::take_work();
|
||||
let pending_callbacks = std::mem::take(&mut self.s.lisp.callback_work);
|
||||
let start = self.s.lisp.callback_used;
|
||||
// This callback may run until `callback_used` reaches `ceiling`: `cap` steps from now, or
|
||||
// sooner where a caller's allowance ends, so callbacks nested in callbacks share one
|
||||
@@ -658,13 +683,20 @@ impl Ctx<'_> {
|
||||
let outer = self.s.lisp.callback_ceiling;
|
||||
let ceiling = start.saturating_add(cap).min(outer.unwrap_or(u64::MAX));
|
||||
self.s.lisp.callback_ceiling = Some(ceiling);
|
||||
let r = self.drive_callback(f, args, ceiling);
|
||||
let mut spent: u64 = 0;
|
||||
let r = self.drive_callback(f, args, ceiling, &mut spent);
|
||||
self.s.lisp.callback_ceiling = outer;
|
||||
super::value::charge_work(pending);
|
||||
// Its steps, nested callbacks' included, are work done inside the caller's one step: they
|
||||
// count against the caller's slice and every enclosing callback's. They are in
|
||||
// `callback_used` already, so they reach the caller apart from its list walks.
|
||||
self.s.lisp.callback_work = pending_callbacks.saturating_add(spent);
|
||||
r
|
||||
}
|
||||
|
||||
/// Run callback `f` in slices until it finishes or `callback_used` reaches `ceiling`.
|
||||
fn drive_callback(&mut self, f: &Value, args: Vec<Value>, ceiling: u64) -> Result<Value, LispError> {
|
||||
/// Run callback `f` in slices until it finishes or `callback_used` reaches `ceiling`, adding
|
||||
/// the work each slice did to `spent`.
|
||||
fn drive_callback(&mut self, f: &Value, args: Vec<Value>, ceiling: u64, spent: &mut u64) -> Result<Value, LispError> {
|
||||
let cap = self.s.lisp.limits.callback_steps;
|
||||
let mut m = Machine::calling(f.clone(), args);
|
||||
let mut sub = Ctx { s: &mut *self.s, env: &mut *self.env, depth: self.depth + 1 };
|
||||
@@ -680,6 +712,7 @@ impl Ctx<'_> {
|
||||
}
|
||||
let slice = remaining.min(SYNC_SLICE);
|
||||
let outcome = m.run(&mut sub, slice);
|
||||
*spent = spent.saturating_add(m.used);
|
||||
match outcome {
|
||||
// The steps were charged as they ran; finishing past the shared allowance is a failure too.
|
||||
Outcome::Done(_) if sub.s.lisp.callback_used > ceiling => {
|
||||
|
||||
@@ -247,6 +247,112 @@ fn synchronous_callback_loop_is_an_error_not_a_hang() {
|
||||
assert_eq!(ok(&mut s, "(vl-sort '(3 1 2) '<)"), "(1 2 3)");
|
||||
}
|
||||
|
||||
/// A step that walks a long list counts its work: one `length` of 32768 cells is past a 1000-step
|
||||
/// slice, so the slice yields after it.
|
||||
#[test]
|
||||
fn walking_a_long_list_counts_against_the_slice() {
|
||||
use super::eval::{Ctx, Machine, Need, Outcome};
|
||||
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut s = session();
|
||||
let mut env = super::Env::default();
|
||||
let mut ctx = Ctx { s: &mut s, env: &mut env, depth: 0 };
|
||||
// Built before the measured run, so only the `length` is counted.
|
||||
let mut build = Machine::forms(super::read::read_all("(setq l '(1)) (repeat 15 (setq l (append l l)))").unwrap());
|
||||
assert!(matches!(build.run(&mut ctx, u64::MAX), Outcome::Done(_)));
|
||||
let mut m = Machine::forms(super::read::read_all("(length l)").unwrap());
|
||||
// Counted as one step, the walk left the few steps of `(length l)` well inside the slice.
|
||||
assert!(matches!(m.run(&mut ctx, 1_000), Outcome::Wait(Need::Yield)), "the walk was not charged");
|
||||
assert!(m.used > 32_768, "{}", m.used);
|
||||
match m.run(&mut ctx, u64::MAX) {
|
||||
Outcome::Done(v) => assert_eq!(to_text(&v, true), "32768"),
|
||||
_ => panic!("the length did not finish"),
|
||||
}
|
||||
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
|
||||
}
|
||||
|
||||
/// A routine is charged the work its slice did, not the slice's length: one `length` of 2^19
|
||||
/// cells is far past a 400000-step slice.
|
||||
#[test]
|
||||
fn a_routine_is_charged_the_work_of_its_slice() {
|
||||
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut s = session();
|
||||
ok(&mut s, "(setq l '(1)) (repeat 19 (setq l (append l l))) nil");
|
||||
let r = s.lisp_eval("(length l) (repeat 10 (setq x 1))", false, false, Vec::new()).unwrap();
|
||||
assert!(r.is_none(), "the routine gave the interface a frame");
|
||||
assert!(s.lisp_busy());
|
||||
let steps = s.lisp.run.as_ref().map(|r| r.steps).unwrap_or(0);
|
||||
assert!(steps >= 1 << 19, "{steps}");
|
||||
for _ in 0..100 {
|
||||
if !s.lisp_busy() {
|
||||
break;
|
||||
}
|
||||
s.lisp_tick();
|
||||
}
|
||||
assert!(!s.lisp_running());
|
||||
ok(&mut s, "(setq l nil)");
|
||||
}
|
||||
|
||||
/// A run's last step walking a long list is charged to that run, not left for the next one: here
|
||||
/// it fails after the walk (a list of numbers isn't a list of strings), so no step follows it.
|
||||
#[test]
|
||||
fn the_last_steps_list_walk_is_charged_to_its_run() {
|
||||
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut s = session();
|
||||
let mut env = super::Env::default();
|
||||
env.globals.insert(super::value::Sym::new("L"), Value::list(vec![Value::Int(1); 100_000]));
|
||||
let mut m = super::eval::Machine::forms(super::read::read_all("(acad_strlsort l)").unwrap());
|
||||
let mut ctx = super::eval::Ctx { s: &mut s, env: &mut env, depth: 0 };
|
||||
assert!(matches!(m.run(&mut ctx, u64::MAX), super::eval::Outcome::Error(_)));
|
||||
assert!(m.used > 100_000, "{}", m.used);
|
||||
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
|
||||
}
|
||||
|
||||
/// Nested callbacks share one cap: an inner endless callback retried by an outer one stops.
|
||||
#[test]
|
||||
fn nested_callback_steps_count_against_the_outer_callback() {
|
||||
let mut s = session();
|
||||
s.lisp.limits.callback_steps = 10_000;
|
||||
// Each level retried the endless level inside it with a fresh cap: 10000^3 steps, a hang.
|
||||
let code = "(defun g (a b) (while t)) \
|
||||
(defun f (a b) (while t (vl-catch-all-apply 'vl-sort (list '(1 2) 'g)))) \
|
||||
(defun h (a b) (while t (vl-catch-all-apply 'vl-sort (list '(1 2) 'f)))) \
|
||||
(vl-sort '(1 2) 'h)";
|
||||
assert_eq!(eval(&mut s, code), Err("callback stopped after 10000 steps".into()));
|
||||
// A callback's own steps count once, however many slices it runs in: three slices do three
|
||||
// times the work of one.
|
||||
let counts: Vec<u64> = [400_000, 1_200_000]
|
||||
.into_iter()
|
||||
.map(|cap| {
|
||||
s.lisp.limits.callback_steps = cap;
|
||||
ok(&mut s, "(setq n 0)");
|
||||
assert!(eval(&mut s, "(vl-remove-if '(lambda (x) (while t (setq n (1+ n)))) '(1))").is_err());
|
||||
ok(&mut s, "n").parse().unwrap()
|
||||
})
|
||||
.collect();
|
||||
assert!(counts[1] * 10 >= counts[0] * 29, "{counts:?}");
|
||||
}
|
||||
|
||||
/// The callback cap holds for each callback: a sort's comparisons together take more steps than
|
||||
/// it, and all their work still reaches the enclosing run.
|
||||
#[test]
|
||||
fn each_callback_has_its_own_cap_and_its_work_reaches_the_caller() {
|
||||
let mut s = session();
|
||||
s.lisp.limits.callback_steps = 1_000;
|
||||
let mut env = super::Env::default();
|
||||
env.globals.insert(super::value::Sym::new("L"), Value::list((0..300).rev().map(Value::Int)));
|
||||
let mut m = super::eval::Machine::forms(super::read::read_all("(vl-sort l (function (lambda (a b) (< a b))))").unwrap());
|
||||
let mut ctx = super::eval::Ctx { s: &mut s, env: &mut env, depth: 0 };
|
||||
let v = match m.run(&mut ctx, u64::MAX) {
|
||||
super::eval::Outcome::Done(v) => v,
|
||||
super::eval::Outcome::Error(e) => panic!("the sort failed: {e:?}"),
|
||||
super::eval::Outcome::Wait(_) => panic!("the sort waited"),
|
||||
};
|
||||
assert_eq!(to_text(&v, true), to_text(&Value::list((0..300).map(Value::Int)), true));
|
||||
// Over a thousand comparisons of several steps each, together well past the cap.
|
||||
assert!(m.used > 3_000, "{}", m.used);
|
||||
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
|
||||
}
|
||||
|
||||
/// A zero-step callback limit prevents even the first callback side effect.
|
||||
#[test]
|
||||
fn a_zero_callback_budget_does_not_run_the_callback() {
|
||||
|
||||
@@ -64,6 +64,8 @@ thread_local! {
|
||||
static STRING_BYTES: Cell<(u64, u64)> = const { Cell::new((0, STRING_BUDGET)) };
|
||||
/// The running slice's cap on live cons cells.
|
||||
static CELL_LIMIT: Cell<usize> = const { Cell::new(MAX_CELLS) };
|
||||
/// Work done inside the current machine step: list cells walked, steps of synchronous callbacks.
|
||||
static WORK: Cell<u64> = const { Cell::new(0) };
|
||||
}
|
||||
|
||||
/// Start a slice of a run on this thread: it fails when more than `limit` cells are alive.
|
||||
@@ -76,6 +78,16 @@ pub fn check_cells() -> Result<(), LispError> {
|
||||
if live_cells() > CELL_LIMIT.with(Cell::get) { Err(LispError::quit("out of memory: too many list cells")) } else { Ok(()) }
|
||||
}
|
||||
|
||||
/// Count `n` units of work done inside one machine step ([`super::eval::Machine::run`] charges them as steps).
|
||||
pub fn charge_work(n: u64) {
|
||||
WORK.with(|c| c.set(c.get().saturating_add(n)));
|
||||
}
|
||||
|
||||
/// The work counted since the last call.
|
||||
pub fn take_work() -> u64 {
|
||||
WORK.with(|c| c.replace(0))
|
||||
}
|
||||
|
||||
/// Start a slice of a run on this thread: it has made `used` bytes of its `budget`.
|
||||
pub fn set_string_budget(used: u64, budget: u64) {
|
||||
STRING_BYTES.with(|c| c.set((used, budget)));
|
||||
@@ -262,7 +274,10 @@ impl Value {
|
||||
loop {
|
||||
match v {
|
||||
Value::Nil => return true,
|
||||
Value::Cons(c) => v = c.cdr.clone(),
|
||||
Value::Cons(c) => {
|
||||
charge_work(1);
|
||||
v = c.cdr.clone();
|
||||
}
|
||||
_ => return false,
|
||||
}
|
||||
}
|
||||
@@ -318,6 +333,7 @@ impl Iterator for ListIter {
|
||||
fn next(&mut self) -> Option<Value> {
|
||||
match std::mem::take(&mut self.next) {
|
||||
Value::Cons(c) => {
|
||||
charge_work(1);
|
||||
self.next = c.cdr.clone();
|
||||
Some(c.car.clone())
|
||||
}
|
||||
|
||||
@@ -329,3 +329,39 @@ fn auditctl_generates_adt_report_file() {
|
||||
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_handle_in_the_reserved_band_is_not_repaired_on_every_audit() {
|
||||
// A file object above HANDLE_LIMIT keeps its handle, and the seed deliberately does not move
|
||||
// past it (#913). AUDIT must not report that policy as an error its own repair never fixes.
|
||||
let band = Handle(cadcraft_engine::doc::HANDLE_LIMIT);
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.space_mut(&Space::Model).unwrap().push(Entity { handle: band, common: Common::default(), kind: line((0.0, 0.0), (1.0, 0.0)) });
|
||||
d.handseed = band.0;
|
||||
for _ in 0..3 {
|
||||
let r = cadcraft_engine::audit::check(&d);
|
||||
assert!(r.issues.iter().all(|i| i.kind != "handseed"), "{}", r.message());
|
||||
}
|
||||
let mut repaired = d.clone();
|
||||
let r = cadcraft_engine::audit::repair(&mut repaired);
|
||||
assert!(r.iter().all(|i| i.kind != "handseed"), "{r:?}");
|
||||
assert_eq!(repaired.handseed, band.0, "the seed moved past the file's own handle");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_ordinary_handle_behind_a_reserved_band_one_is_still_repaired() {
|
||||
// The largest handle is in the reserved band, which the seed deliberately does not follow.
|
||||
// An ordinary handle above the seed must still be found behind it: it is the one the seed
|
||||
// has to move past, and skipping the check would leave AUDIT reporting a clean drawing.
|
||||
let band = Handle(cadcraft_engine::doc::HANDLE_LIMIT);
|
||||
let mut d = Drawing::new_imperial();
|
||||
let store = d.space_mut(&Space::Model).unwrap();
|
||||
store.push(Entity { handle: Handle(20), common: Common::default(), kind: line((0.0, 0.0), (1.0, 0.0)) });
|
||||
store.push(Entity { handle: band, common: Common::default(), kind: line((2.0, 0.0), (3.0, 0.0)) });
|
||||
d.handseed = 10;
|
||||
let r = cadcraft_engine::audit::repair(&mut d);
|
||||
assert!(r.iter().any(|i| i.kind == "handseed" && i.message.contains("(14)")), "the ordinary handle was hidden: {r:?}");
|
||||
assert_eq!(d.handseed, 21, "the seed was not moved past the ordinary handle");
|
||||
let r = cadcraft_engine::audit::repair(&mut d.clone());
|
||||
assert!(r.iter().all(|i| i.kind != "handseed"), "the repair does not stick: {r:?}");
|
||||
}
|
||||
|
||||
@@ -142,6 +142,51 @@ fn bad_input_is_refused_and_changes_nothing() {
|
||||
assert_eq!(listed(&mut s), json!([]));
|
||||
}
|
||||
|
||||
/// `data` longer than the largest image file encodes to is refused before it is decoded.
|
||||
#[test]
|
||||
fn oversized_data_is_refused_before_decoding() {
|
||||
hooks();
|
||||
const LIMIT: u64 = 256 << 20;
|
||||
let mut s = Session::new();
|
||||
// Not base64 at all: only the check before decoding tells it is too long ("not valid base64"
|
||||
// otherwise), and nothing is decoded.
|
||||
let too_long = "!".repeat(usize::try_from(LIMIT.div_ceil(3) * 4 + 1).unwrap());
|
||||
let e = s.execute("imageattach", &json!({ "path": "a.png", "data": too_long })).unwrap_err().to_string();
|
||||
assert!(e.contains("`data` is larger than 256 MB"), "{e}");
|
||||
// Line breaks don't count: base64 wrapped as MIME writes it is taken.
|
||||
let wrapped: String = base64_encode(&png()).as_bytes().chunks(76).map(|c| format!("{}\r\n", String::from_utf8_lossy(c))).collect();
|
||||
s.execute("imageattach", &json!({ "path": "wrapped.png", "data": wrapped })).unwrap();
|
||||
s.execute("undo", &json!({})).unwrap();
|
||||
|
||||
// The longest text allowed, holding one byte more than the limit, is refused once decoded.
|
||||
let groups = usize::try_from(LIMIT / 3).unwrap();
|
||||
let one_over = format!("{}AAA=", "AAAA".repeat(groups));
|
||||
assert_eq!(u64::try_from(one_over.len()).unwrap(), LIMIT.div_ceil(3) * 4, "as long as the text for the limit itself");
|
||||
let e = s.execute("imageattach", &json!({ "path": "a.png", "data": one_over })).unwrap_err().to_string();
|
||||
assert!(e.contains("`data` is larger than 256 MB"), "{e}");
|
||||
assert!(images(&s).is_empty());
|
||||
}
|
||||
|
||||
/// A relative path in an unsaved drawing has nothing to be relative to, and the error says so.
|
||||
#[test]
|
||||
fn a_relative_path_in_an_unsaved_drawing_says_what_to_do() {
|
||||
hooks();
|
||||
let mut s = Session::new();
|
||||
let e = s.execute("imageattach", &json!({ "path": "missing.png" })).unwrap_err().to_string();
|
||||
assert!(e.contains("save the drawing first, or give a full path"), "{e}");
|
||||
|
||||
let dir = folder("unsaved");
|
||||
let full = dir.join("missing.png");
|
||||
let e = s.execute("imageattach", &json!({ "path": full.to_string_lossy() })).unwrap_err().to_string();
|
||||
assert!(e.contains("file not found") && !e.contains("save the drawing"), "{e}");
|
||||
// A full Windows path, read as relative elsewhere, is a full path all the same.
|
||||
for windows in [r"C:\nowhere\a.png", "D:/nowhere/a.png", r"\\server\maps\a.png"] {
|
||||
let e = s.execute("imageattach", &json!({ "path": windows })).unwrap_err().to_string();
|
||||
assert!(e.contains("file not found") && !e.contains("save the drawing"), "{windows}: {e}");
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_image_among_many_objects_keeps_its_pixels() {
|
||||
// More objects than one build task takes: the display list is built in parts and joined,
|
||||
|
||||
@@ -56,11 +56,17 @@ pub struct ShxGlyph {
|
||||
pub advance: Vec2,
|
||||
}
|
||||
|
||||
/// Glyphs cached per font, keyed by (shape, vertical).
|
||||
type GlyphCache = HashMap<(u16, bool), Option<Arc<ShxGlyph>>>;
|
||||
/// Glyphs cached per font, keyed by (shape, vertical), and their points in all.
|
||||
#[derive(Default)]
|
||||
struct GlyphCache {
|
||||
glyphs: HashMap<(u16, bool), Option<Arc<ShxGlyph>>>,
|
||||
points: usize,
|
||||
}
|
||||
|
||||
/// Most glyphs cached per font (a big font has thousands; text uses a few hundred).
|
||||
const MAX_CACHED_GLYPHS: usize = 16_384;
|
||||
/// Most points cached per font (16 MB; a glyph may hold thousands of points).
|
||||
const MAX_CACHED_POINTS: usize = 1 << 20;
|
||||
|
||||
/// A parsed SHX file.
|
||||
pub struct ShxFont {
|
||||
@@ -203,15 +209,22 @@ impl ShxFont {
|
||||
}
|
||||
let vertical = vertical && self.dual;
|
||||
let key = (number, vertical);
|
||||
if let Some(g) = self.cache.read().unwrap_or_else(PoisonError::into_inner).get(&key) {
|
||||
if let Some(g) = self.cache.read().unwrap_or_else(PoisonError::into_inner).glyphs.get(&key) {
|
||||
return g.clone();
|
||||
}
|
||||
let g = program::outline(self, number, vertical).ok().map(Arc::new);
|
||||
let points = g.as_ref().map_or(0, |g| g.strokes.iter().map(Vec::len).sum::<usize>());
|
||||
let mut c = self.cache.write().unwrap_or_else(PoisonError::into_inner);
|
||||
if c.len() >= MAX_CACHED_GLYPHS {
|
||||
c.clear();
|
||||
// Another thread may have outlined it in the meantime: its points are counted already.
|
||||
if let Some(g) = c.glyphs.get(&key) {
|
||||
return g.clone();
|
||||
}
|
||||
c.insert(key, g.clone());
|
||||
if c.glyphs.len() >= MAX_CACHED_GLYPHS || c.points.saturating_add(points) > MAX_CACHED_POINTS {
|
||||
c.glyphs.clear();
|
||||
c.points = 0;
|
||||
}
|
||||
c.points = c.points.saturating_add(points);
|
||||
c.glyphs.insert(key, g.clone());
|
||||
g
|
||||
}
|
||||
}
|
||||
|
||||
@@ -309,6 +309,22 @@ fn hostile_files_never_panic() {
|
||||
assert!(compile("").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_glyph_cache_is_bounded_by_points() {
|
||||
// Hostile: every glyph at the point bound, so 16,384 cached glyphs would hold 2 GB.
|
||||
let mut src = format!("*2,1,HUNDRED\n{}0\n*3,3,V\n011,019,0\n", "7,3,".repeat(100));
|
||||
for n in 10..=200 {
|
||||
src.push_str(&format!("*{n},1,HEAVY\n{}0\n", "7,2,".repeat(40)));
|
||||
}
|
||||
let f = font(&src);
|
||||
for n in 10..=200 {
|
||||
assert!(f.glyph(n, false).is_some());
|
||||
}
|
||||
let c = f.cache.read().unwrap();
|
||||
let cached: usize = c.glyphs.values().flatten().map(|g| g.strokes.iter().map(Vec::len).sum::<usize>()).sum();
|
||||
assert!(cached <= MAX_CACHED_POINTS && cached == c.points, "{cached}");
|
||||
}
|
||||
|
||||
/// Register a compiled test font under `name` (each test its own names: the table is shared).
|
||||
fn reg(name: &str, src: &str) {
|
||||
register(name, &compile(src).unwrap()).unwrap();
|
||||
|
||||
@@ -1062,11 +1062,10 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
|
||||
alive_memo
|
||||
});
|
||||
// New handles for the written kept objects, above every written handle and the seed.
|
||||
let mut next = seed(tags).max(max_handle(tags).saturating_add(1));
|
||||
let mut fresh = Fresh::new(tags);
|
||||
let mut alive: HashMap<String, String> = HashMap::new();
|
||||
for o in f.objects.iter().filter(|o| alive_memo.get(&o.handle.hex()) == Some(&true)) {
|
||||
alive.insert(o.handle.hex(), format!("{next:X}"));
|
||||
next = next.saturating_add(1);
|
||||
alive.insert(o.handle.hex(), format!("{:X}", fresh.take()));
|
||||
}
|
||||
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 };
|
||||
@@ -1389,19 +1388,18 @@ fn add_appids(out: &mut Vec<Tag>) {
|
||||
return;
|
||||
}
|
||||
// New handles above the seed, which is then moved past them.
|
||||
let mut next = seed(out).max(max_handle(out).saturating_add(1));
|
||||
let mut fresh = Fresh::new(out);
|
||||
let mut add = Vec::new();
|
||||
for app in &missing {
|
||||
add.extend([
|
||||
Tag::s(0, "APPID"),
|
||||
Tag::s(5, format!("{next:X}")),
|
||||
Tag::s(5, format!("{:X}", fresh.take())),
|
||||
Tag::s(330, table_h.clone()),
|
||||
Tag::s(100, "AcDbSymbolTableRecord"),
|
||||
Tag::s(100, "AcDbRegAppTableRecord"),
|
||||
Tag::s(2, (*app).clone()),
|
||||
Tag::i(70, 0),
|
||||
]);
|
||||
next = next.saturating_add(1);
|
||||
}
|
||||
let end_at = end.start;
|
||||
if let Some(count) = out.get_mut(t.start + 1..t.end).and_then(|b| b.iter_mut().find(|x| x.code == 70)) {
|
||||
@@ -1420,6 +1418,36 @@ fn seed(tags: &[Tag]) -> u64 {
|
||||
seed_index(tags).and_then(|i| tags.get(i)).and_then(|t| Handle::parse_hex(&t.str())).map_or(0, |h| h.0)
|
||||
}
|
||||
|
||||
/// New handles for records added to written tags: above the seed and every handle written, and
|
||||
/// never one a record already holds. A file may hold the top handle (#913): then counting on from
|
||||
/// it would give every added record that same handle, so past the top of the range the numbering
|
||||
/// goes on in the reserved band above [`cadcraft_doc::HANDLE_LIMIT`], skipping the handles there.
|
||||
struct Fresh {
|
||||
next: u64,
|
||||
used: HashSet<u64>,
|
||||
}
|
||||
|
||||
impl Fresh {
|
||||
fn new(tags: &[Tag]) -> Self {
|
||||
let used: HashSet<u64> =
|
||||
tags.iter().filter(|t| t.code == 5 || t.code == 105).filter_map(|t| Handle::parse_hex(&t.str())).map(|h| h.0).collect();
|
||||
let above = used.iter().max().map_or(0, |h| h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT));
|
||||
Fresh { next: seed(tags).max(above), used }
|
||||
}
|
||||
/// The next free handle. Each handle skipped is one a record holds, so the walk is bounded
|
||||
/// by their count (and handle 0, which means "none").
|
||||
fn take(&mut self) -> u64 {
|
||||
for _ in 0..self.used.len().saturating_add(2) {
|
||||
let h = self.next;
|
||||
self.next = h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT);
|
||||
if h != 0 && self.used.insert(h) {
|
||||
return h;
|
||||
}
|
||||
}
|
||||
self.next
|
||||
}
|
||||
}
|
||||
|
||||
/// The largest handle of a record (groups 5 and 105).
|
||||
fn max_handle(tags: &[Tag]) -> u64 {
|
||||
tags.iter().filter(|t| t.code == 5 || t.code == 105).filter_map(|t| Handle::parse_hex(&t.str())).map(|h| h.0).max().unwrap_or(0)
|
||||
|
||||
@@ -102,11 +102,36 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
|
||||
// its $HANDSEED can be lower than its handles, and entities made while reading (the faces of
|
||||
// a polygon mesh) would otherwise get handles that records further on still have. A file
|
||||
// CADCraft wrote names its own next handle, above which its rebuilt records are numbered
|
||||
// (#495), so it is left to that.
|
||||
// (#495), so for it only the entity records are reserved. Handles in the reserved band are
|
||||
// reserved for allocation rather than followed (#913): a handle-less entity read before the
|
||||
// section that names one is placed would otherwise be given it and replace the record (#1276).
|
||||
let ours = secs.iter().any(|s| s.name == "OBJECTS" && s.tags.iter().any(|t| t.code == 3 && t.str() == crate::dxf_ext::HANDSEED_KEY));
|
||||
for t in secs.iter().filter(|_| !ours).flat_map(|s| s.tags.iter()).filter(|t| t.code == 5 || t.code == 105) {
|
||||
if let Some(h) = Handle::parse_hex(t.str().trim()) {
|
||||
d.bump_handseed(h);
|
||||
if ours {
|
||||
// Its table and object records are numbered above its seed and rebuilt on save (#495),
|
||||
// so only its entities are reserved. Reading is section by section: an entity that has
|
||||
// no handle, or repeats one within its section, gets a fresh handle, and that must not
|
||||
// be one an entity of a later section still names. `BLOCK` and `ENDBLK` are structural
|
||||
// records, not entities, and are left out so they don't move the saved seed.
|
||||
for (kind, tags) in secs.iter().filter(|s| s.name == "BLOCKS" || s.name == "ENTITIES").flat_map(|s| records(&s.tags)) {
|
||||
if matches!(kind.as_str(), "BLOCK" | "ENDBLK") {
|
||||
continue;
|
||||
}
|
||||
if let Some(h) = tags.iter().find(|t| t.code == 5).and_then(|t| Handle::parse_hex(t.str().trim())) {
|
||||
d.bump_handseed(h);
|
||||
d.reserve_handle(h);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for s in &secs {
|
||||
let entity_section = s.name == "BLOCKS" || s.name == "ENTITIES";
|
||||
for t in s.tags.iter().filter(|t| t.code == 5 || t.code == 105) {
|
||||
if let Some(h) = Handle::parse_hex(t.str().trim()) {
|
||||
d.bump_handseed(h);
|
||||
if entity_section {
|
||||
d.reserve_handle(h);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut skipped = std::collections::BTreeMap::new();
|
||||
@@ -148,6 +173,9 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
|
||||
crate::dxf_raw::read(&secs, &mut d);
|
||||
crate::dxf_clip::read(&mut d);
|
||||
d.skipped_records = skipped;
|
||||
// Every record is placed now, and an object holding a reserved handle keeps it from new
|
||||
// objects by itself. Kept, the set would be copied with every undo step of the drawing.
|
||||
d.reserved_handles.clear();
|
||||
Ok(d)
|
||||
}
|
||||
|
||||
|
||||
@@ -55,6 +55,7 @@ pub(super) fn parse_entities(
|
||||
}
|
||||
if let Some((c, mut k)) = kindent {
|
||||
let h = match handle {
|
||||
// A file's handles keep their identity, however high they are (#913, #939).
|
||||
Some(h) => {
|
||||
d.bump_handseed(h);
|
||||
h
|
||||
@@ -143,7 +144,7 @@ pub(super) fn read_objects(tags: &[Tag], objs: &mut Objects, layout_objs: &mut V
|
||||
// LAYOUT has two 330s: owner dict and the block record; take the last.
|
||||
let br = tg.iter().rfind(|x| x.code == 330).map(Tag::str).unwrap_or_default();
|
||||
let plot = T(tg.get(..start).unwrap_or(&[]));
|
||||
layout_objs.push((t.s(1).unwrap_or_default(), t.i(71).unwrap_or(0) as u32, br.to_ascii_uppercase(), page_setup(&plot, &tg), limits(&t)));
|
||||
layout_objs.push((t.s(1).unwrap_or_default(), t.i(71).unwrap_or(0) as u32, br.to_ascii_uppercase(), page_setup(&plot), limits(&t)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -231,9 +231,8 @@ impl Objects {
|
||||
}
|
||||
}
|
||||
|
||||
/// Page setup from a LAYOUT object's AcDbPlotSettings fields (sizes and margins in mm), and its
|
||||
/// CADCraft xdata in the record's `tags`.
|
||||
pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup {
|
||||
/// 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();
|
||||
let mm = |code: i32, d: f64| {
|
||||
let v = t.fd(code, d);
|
||||
@@ -245,17 +244,9 @@ pub(super) fn page_setup(t: &T, tags: &[Tag]) -> PageSetup {
|
||||
p.height_mm = w.max(h);
|
||||
}
|
||||
p.margins_mm = [mm(40, p.margins_mm[0]), mm(41, p.margins_mm[1]), mm(42, p.margins_mm[2]), mm(43, p.margins_mm[3])];
|
||||
// CADCraft's paper units come first (PSUNITS xdata: 0 inches, 1 millimetres, 2 follows
|
||||
// MEASUREMENT), because plot paper units 0 cannot tell an explicit inch layout from an unset
|
||||
// one: earlier CADCraft versions wrote 0 for every layout, so 0 alone is left to MEASUREMENT.
|
||||
// Plot paper units 1 is millimetres (#3249).
|
||||
let units = crate::dxf_ext::xdata_list(crate::dxf_ext::xdata(tags, crate::dxf_ext::APP), "PSUNITS");
|
||||
p.paper_mm = match units.iter().find(|t| t.code == 1070).map(|t| t.i64()) {
|
||||
Some(0) => Some(false),
|
||||
Some(1) => Some(true),
|
||||
Some(2) => None,
|
||||
_ => (t.i(72) == Some(1)).then_some(true),
|
||||
};
|
||||
// Plot paper units 1: millimetres. 0 (inches) is left to MEASUREMENT: earlier CADCraft
|
||||
// versions wrote 0 for every layout.
|
||||
p.paper_mm = t.i(72) == Some(1);
|
||||
// Plot rotation 1 or 3 turns the media a quarter turn; media defined wider than tall is
|
||||
// already landscape.
|
||||
let rotated = matches!(t.i(73), Some(1 | 3));
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//! the newer DIMSTYLE groups, and from 2007 in UTF-8 text (the caller picks the text encoding) and
|
||||
//! MULTILEADER entities (older files get LEADER + MTEXT).
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{
|
||||
@@ -39,6 +39,9 @@ use sections::tags_for;
|
||||
struct W {
|
||||
t: Vec<Tag>,
|
||||
next: u64,
|
||||
/// Handles the drawing's objects already hold: structural records skip them, so writing a
|
||||
/// file whose own handles sit near the top of the range never repeats a handle (#913).
|
||||
used: HashSet<u64>,
|
||||
/// Upper-case plot style name → its `ACDBPLACEHOLDER` handle (group 390 of layers and objects).
|
||||
pstyles: HashMap<String, String>,
|
||||
/// Upper-case layer name → its LAYER table record handle (group 331/341 of viewports).
|
||||
@@ -48,6 +51,21 @@ struct W {
|
||||
reactors: HashMap<Handle, Vec<String>>,
|
||||
}
|
||||
|
||||
/// Where the writer's own records (tables, objects, dictionaries) start numbering: above every
|
||||
/// object handle and the drawing's seed, with headroom for handles the drawing allocates next.
|
||||
fn structural_start(d: &Drawing) -> u64 {
|
||||
let highest = entity_handles(d).max().unwrap_or(0);
|
||||
d.handseed.max(0x100).max(highest.saturating_add(1)).saturating_add(0x1000)
|
||||
}
|
||||
|
||||
/// Every handle an object holds, plus the drawing's next one.
|
||||
fn entity_handles(d: &Drawing) -> impl Iterator<Item = u64> + '_ {
|
||||
let model = d.model.iter().map(|e| e.handle.0);
|
||||
let layouts = d.layouts.iter().flat_map(|l| l.entities.iter()).map(|e| e.handle.0);
|
||||
let blocks = d.blocks.values().flat_map(|b| b.entities.iter()).map(|e| e.handle.0);
|
||||
model.chain(layouts).chain(blocks).chain(std::iter::once(d.handseed))
|
||||
}
|
||||
|
||||
impl W {
|
||||
fn s(&mut self, c: i32, v: impl Into<String>) {
|
||||
self.t.push(Tag::s(c, v));
|
||||
@@ -71,10 +89,20 @@ impl W {
|
||||
format!("{:X}", self.next_handle())
|
||||
}
|
||||
/// A new handle for a record the drawing doesn't hold (as [`W::h`]).
|
||||
///
|
||||
/// Skips every handle in use, so a file object carrying a handle above the seed (the
|
||||
/// reserved band) is not handed out again, and wraps into that band if the writer runs off
|
||||
/// the top of the range. Each handle skipped is one in use, so the walk is bounded by their
|
||||
/// count.
|
||||
fn next_handle(&mut self) -> u64 {
|
||||
let h = self.next;
|
||||
self.next = self.next.saturating_add(1);
|
||||
h
|
||||
for _ in 0..self.used.len().saturating_add(1) {
|
||||
let h = self.next;
|
||||
self.next = h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT);
|
||||
if self.used.insert(h) {
|
||||
return h;
|
||||
}
|
||||
}
|
||||
self.next
|
||||
}
|
||||
/// A `102 {NAME` … `102 }` group of handles.
|
||||
fn group(&mut self, name: &str, code: i32, handles: &[&str]) {
|
||||
@@ -152,7 +180,8 @@ fn bridge_markers(tags: &mut [Tag]) {
|
||||
pub fn entity_groups(d: &Drawing, e: &Entity) -> (String, Vec<Tag>) {
|
||||
let mut w = W {
|
||||
t: Vec::new(),
|
||||
next: d.handseed.max(0x100).saturating_add(0x1000),
|
||||
next: structural_start(d),
|
||||
used: entity_handles(d).collect(),
|
||||
pstyles: HashMap::new(),
|
||||
layers: HashMap::new(),
|
||||
reactors: HashMap::new(),
|
||||
|
||||
@@ -16,7 +16,14 @@ pub(super) fn annotative_xdata(w: &mut W) {
|
||||
|
||||
/// Override (`ACAD` DSTYLE) and associativity (`CADCRAFT` ASSOC) xdata of a dimension.
|
||||
pub(super) fn dim_xdata(w: &mut W, dm: &Dimension, cx: &Ctx) {
|
||||
let mut ov = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
|
||||
let mut ov = W {
|
||||
t: Vec::new(),
|
||||
next: 0,
|
||||
used: std::collections::HashSet::new(),
|
||||
pstyles: HashMap::new(),
|
||||
layers: HashMap::new(),
|
||||
reactors: HashMap::new(),
|
||||
};
|
||||
let mut sah = false;
|
||||
for (k, v) in &dm.overrides {
|
||||
let Some(field) = DimStyle::field_name(k) else { continue };
|
||||
|
||||
@@ -7,9 +7,10 @@ use super::header::{code_page, header_vars};
|
||||
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,
|
||||
TableStyle, Tag, Vec2, Vec3, Version, W, dxf_ext,
|
||||
Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, HashSet, Layout, MLeaderStyle, PageSetup,
|
||||
Space, TableStyle, Tag, Vec2, Vec3, Version, W, dxf_ext,
|
||||
};
|
||||
use super::{entity_handles, structural_start};
|
||||
|
||||
struct TableWritePlan<'a> {
|
||||
d: &'a Drawing,
|
||||
@@ -245,7 +246,7 @@ fn write_dimstyles(w: &mut W, d: &Drawing, cx: &mut Ctx, version: Version) {
|
||||
w.i(70, 0);
|
||||
let v = serde_json::to_value(s).unwrap_or_default();
|
||||
let defaults = serde_json::to_value(DimStyle::default()).unwrap_or_default();
|
||||
let mut newer = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
|
||||
let mut newer = W { t: Vec::new(), next: 0, used: HashSet::new(), pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
|
||||
for (field, code, kind) in dxf_ext::DIM_CODES {
|
||||
let Some(enc) = v.get(*field).and_then(|x| cx.encode(*kind, x)) else { continue };
|
||||
// DIMPOST is written even when empty: a reader that defaults a missing one to "<>"
|
||||
@@ -473,35 +474,14 @@ fn layout_obj(w: &mut W, context: LayoutWriteContext<'_>, data: LayoutWriteData<
|
||||
w.p(17, Vec3::new(0.0, 1.0, 0.0));
|
||||
w.i(76, 0);
|
||||
w.s(330, brh);
|
||||
// CADCraft xdata: the saved paper-space view (centre, height), and the layout's paper units.
|
||||
// Group 72 cannot carry the choice on its own: 0 means inches, but it is also what earlier
|
||||
// CADCraft versions wrote for a layout that follows MEASUREMENT, and 1 is what a layout that
|
||||
// inherits a metric MEASUREMENT writes too. PSUNITS keeps the three states apart: 0 inches,
|
||||
// 1 millimetres, 2 follows MEASUREMENT (#3249).
|
||||
let view = view.filter(|(c, v)| c.x.is_finite() && c.y.is_finite() && v.is_finite());
|
||||
let unit_marker = match page.paper_mm {
|
||||
Some(false) => Some(0),
|
||||
Some(true) => Some(1),
|
||||
// An inherited imperial layout writes group 72 = 0, which already reads back as
|
||||
// inherited; only group 72 = 1 is ambiguous and needs the marker.
|
||||
None if cadcraft_render::paper::page_unit_mm(d, page) == 1.0 => Some(2),
|
||||
None => None,
|
||||
};
|
||||
if view.is_some() || unit_marker.is_some() {
|
||||
// The saved paper-space view (centre, height) as CADCraft xdata.
|
||||
if let Some((c, height)) = view.filter(|(c, v)| c.x.is_finite() && c.y.is_finite() && v.is_finite()) {
|
||||
w.s(1001, dxf_ext::APP);
|
||||
if let Some((c, height)) = view {
|
||||
w.s(1000, "PSVIEW");
|
||||
w.s(1002, "{");
|
||||
w.p(1010, c.to3(0.0));
|
||||
w.f(1040, height);
|
||||
w.s(1002, "}");
|
||||
}
|
||||
if let Some(units) = unit_marker {
|
||||
w.s(1000, "PSUNITS");
|
||||
w.s(1002, "{");
|
||||
w.i(1070, units);
|
||||
w.s(1002, "}");
|
||||
}
|
||||
w.s(1000, "PSVIEW");
|
||||
w.s(1002, "{");
|
||||
w.p(1010, c.to3(0.0));
|
||||
w.f(1040, height);
|
||||
w.s(1002, "}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -937,7 +917,8 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
|
||||
// Structural handles start above every entity handle.
|
||||
let mut w = W {
|
||||
t: Vec::new(),
|
||||
next: d.handseed.max(0x100).saturating_add(0x1000),
|
||||
next: structural_start(d),
|
||||
used: entity_handles(d).collect(),
|
||||
pstyles: HashMap::new(),
|
||||
layers: HashMap::new(),
|
||||
reactors: hatch_reactors(d),
|
||||
@@ -1114,11 +1095,11 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
|
||||
for (n, h, b) in &user_blocks {
|
||||
block(&mut w, (n, &b.description), h, b.base, if b.anonymous { 1 } else { 0 }, &mut b.entities.iter().map(|e| e.as_ref()), false);
|
||||
}
|
||||
// Generated geometry entities (dimension, arrowhead and table blocks) need handles.
|
||||
// Generated geometry entities (dimension, arrowhead and table blocks) need handles; take
|
||||
// them from the writer's allocator, which skips the drawing's own handles.
|
||||
for (_, _, ents) in dim_defs.iter_mut().chain(arrow_defs.iter_mut()).chain(table_defs.iter_mut()) {
|
||||
for e in ents.iter_mut().filter(|e| e.handle.0 == 0) {
|
||||
e.handle = Handle(w.next);
|
||||
w.next = w.next.saturating_add(1);
|
||||
e.handle = Handle(w.next_handle());
|
||||
}
|
||||
}
|
||||
for (n, h, ents) in &dim_defs {
|
||||
|
||||
+11
-6
@@ -292,8 +292,17 @@ fn links_json(v: Option<&Value>) -> Vec<(Handle, String)> {
|
||||
pub fn page_for(d: &Drawing, space: &Space, o: &PdfOptions) -> Result<PageSetup> {
|
||||
let mut page = match space.layout() {
|
||||
Some(n) => d.layout(n).map(|l| l.page.clone()).ok_or_else(|| IoError::Format(format!("no layout `{n}`")))?,
|
||||
// Model space has no stored page setup: ISO A4 in a metric drawing, ANSI A otherwise.
|
||||
None => paper::model_page(d),
|
||||
None => {
|
||||
let mut p = PageSetup::default();
|
||||
if paper::paper_unit_mm(d) == 1.0
|
||||
&& let Some(a4) = paper::paper_size("A4")
|
||||
{
|
||||
p.paper = a4.name.into();
|
||||
p.width_mm = a4.width_mm;
|
||||
p.height_mm = a4.height_mm;
|
||||
}
|
||||
p
|
||||
}
|
||||
};
|
||||
if let Some(name) = &o.paper {
|
||||
let ps = paper::paper_size(name).ok_or_else(|| IoError::Format(format!("unknown paper size `{name}`")))?;
|
||||
@@ -316,10 +325,6 @@ pub fn page_for(d: &Drawing, space: &Space, o: &PdfOptions) -> Result<PageSetup>
|
||||
if let (Space::Model, Some(m)) = (space, o.margins) {
|
||||
page.margins_mm = m;
|
||||
}
|
||||
// A model-space plot takes its units from the paper it was given; a layout keeps its page setup's.
|
||||
if matches!(space, Space::Model) {
|
||||
paper::apply_model_paper_units(&mut page);
|
||||
}
|
||||
page.width_mm = page.width_mm.clamp(1.0, MAX_SHEET_MM);
|
||||
page.height_mm = page.height_mm.clamp(1.0, MAX_SHEET_MM);
|
||||
Ok(page)
|
||||
|
||||
+122
-16
@@ -17,7 +17,7 @@ use std::collections::BTreeMap;
|
||||
|
||||
use cadcraft_color::Color;
|
||||
use cadcraft_doc::{Circle, Common, Drawing, Ellipse, EntityKind, Layer, Line, LwPolyline, Space};
|
||||
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3};
|
||||
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3, bulge_to_arc};
|
||||
|
||||
use crate::{IoError, Result};
|
||||
|
||||
@@ -70,6 +70,8 @@ struct Parser {
|
||||
verts_left: usize,
|
||||
/// What was left out, by kind ([`LeftOut`]).
|
||||
left_out: BTreeMap<LeftOut, usize>,
|
||||
/// Shapes left out because their coordinates or extents overflow: invalid, not unsupported.
|
||||
too_large: usize,
|
||||
}
|
||||
|
||||
/// Drawn content the reader leaves out, named in the drawing's read note.
|
||||
@@ -105,16 +107,23 @@ impl Parser {
|
||||
elements: 0,
|
||||
verts_left: MAX_TOTAL_VERTS,
|
||||
left_out: BTreeMap::new(),
|
||||
too_large: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// The read note on what was left out, if anything was.
|
||||
fn note(&self) -> Option<String> {
|
||||
if self.left_out.is_empty() {
|
||||
return None;
|
||||
/// The read notes on what was left out: what isn't read yet, then what is invalid.
|
||||
fn notes(&self) -> Vec<String> {
|
||||
let mut notes = Vec::new();
|
||||
if !self.left_out.is_empty() {
|
||||
let list: Vec<String> = self.left_out.iter().map(|(k, n)| k.describe(*n)).collect();
|
||||
notes.push(format!("SVG: CADCraft doesn't read these yet, so they were left out: {}", list.join(", ")));
|
||||
}
|
||||
let list: Vec<String> = self.left_out.iter().map(|(k, n)| k.describe(*n)).collect();
|
||||
Some(format!("SVG: CADCraft doesn't read these yet, so they were left out: {}", list.join(", ")))
|
||||
match self.too_large {
|
||||
0 => {}
|
||||
1 => notes.push("SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent".into()),
|
||||
n => notes.push(format!("SVG: {n} shapes were left out as invalid: their coordinates or size are too large to represent")),
|
||||
}
|
||||
notes
|
||||
}
|
||||
|
||||
fn parse(&mut self, text: &str) -> Result<()> {
|
||||
@@ -150,7 +159,7 @@ impl Parser {
|
||||
};
|
||||
self.left_out.insert(kind, count);
|
||||
}
|
||||
self.drawing.read_notes.extend(self.note());
|
||||
self.drawing.read_notes.extend(self.notes());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -218,12 +227,18 @@ impl Parser {
|
||||
}
|
||||
// Charge the vertices this entity retains against the shared document budget, so repeated
|
||||
// flattened arcs/curves cannot amplify a compact path into unbounded geometry (CWE-400).
|
||||
// A shape left out below was generated all the same, so it is charged too.
|
||||
let verts = match &kind {
|
||||
EntityKind::LwPolyline(p) => p.vertices.len(),
|
||||
EntityKind::Spline(s) => s.control.len(),
|
||||
_ => 1,
|
||||
};
|
||||
self.verts_left = self.verts_left.checked_sub(verts).ok_or_else(|| IoError::Format("SVG: too much generated geometry".into()))?;
|
||||
// Finite numbers can still overflow through transforms and relative steps (`l1e308 0` twice).
|
||||
if !finite(&kind) {
|
||||
self.too_large += 1;
|
||||
return Ok(());
|
||||
}
|
||||
let common = Common { layer: self.layer.clone(), ..Common::default() };
|
||||
self.drawing.add(&Space::Model, common, kind).map(|_| ()).map_err(parse_err)
|
||||
}
|
||||
@@ -231,7 +246,10 @@ impl Parser {
|
||||
/// A circle or ellipse through a transform. A circle stays a `CIRCLE` under rotations,
|
||||
/// uniform scales and reflections; anything else becomes an `ELLIPSE` holding the axes
|
||||
/// of the transformed shape — a linear map sends the unit circle to an ellipse whose
|
||||
/// semi-axes are the square roots of the eigenvalues of `A·Aᵀ`.
|
||||
/// semi-axes are the square roots of the eigenvalues of `A·Aᵀ`. With `B = [bx by]` the
|
||||
/// ellipse is `center + B·(cos t, sin t)`; `B·Bᵀ` lives in the drawing plane, so its leading
|
||||
/// eigenvector is the major axis's direction. `major` is that axis from the centre, as
|
||||
/// [`Ellipse::major`] is everywhere else.
|
||||
fn add_rounded(&mut self, center_user: Vec2, rx: f64, ry: f64) -> Result<()> {
|
||||
let center = self.map(center_user);
|
||||
let bx = self.map_vec(Vec2::new(rx, 0.0));
|
||||
@@ -253,18 +271,15 @@ impl Parser {
|
||||
if s_max <= f64::EPSILON {
|
||||
return Ok(());
|
||||
}
|
||||
let axis = if xy.abs() <= 1e-12 * trace.max(1.0) {
|
||||
let axis = if xy.abs() <= 1e-12 * trace {
|
||||
if yy > xx { Vec2::new(0.0, 1.0) } else { Vec2::new(1.0, 0.0) }
|
||||
} else {
|
||||
let v = Vec2::new(xy, l_max - xx);
|
||||
let l = len(v);
|
||||
if l <= f64::EPSILON {
|
||||
return Ok(());
|
||||
}
|
||||
v / l
|
||||
// |v| ≥ |xy| > 1e-12·trace ≥ 0 here, so the division is never by zero.
|
||||
v / len(v)
|
||||
};
|
||||
let ratio = (l_min.max(0.0).sqrt() / s_max).clamp(1e-9, 1.0);
|
||||
let major = center + axis * s_max;
|
||||
let major = axis * s_max;
|
||||
self.add(EntityKind::Ellipse(Ellipse { center: v3(center), major: v3(major), ratio, start: 0.0, end: std::f64::consts::TAU }))
|
||||
}
|
||||
|
||||
@@ -380,6 +395,79 @@ impl Parser {
|
||||
}
|
||||
}
|
||||
|
||||
/// Every coordinate of an entity the reader makes is finite, and so are its extents: a finite
|
||||
/// centre and radius can still reach past the largest number.
|
||||
fn finite(kind: &EntityKind) -> bool {
|
||||
match kind {
|
||||
EntityKind::Line(l) => l.a.is_finite() && l.b.is_finite(),
|
||||
EntityKind::Circle(c) => {
|
||||
c.center.is_finite()
|
||||
&& c.radius.is_finite()
|
||||
&& cadcraft_geom::Circle::new(c.center.xy(), c.radius).bounds().corners().iter().all(|p| p.is_finite())
|
||||
}
|
||||
EntityKind::Ellipse(e) => {
|
||||
// Half the box is `hypot` of the major axis and the minor axis (`ratio` times it, turned).
|
||||
let (m, r) = (e.major.xy(), e.ratio);
|
||||
e.center.is_finite() && e.major.is_finite() && e.ratio.is_finite() && box_finite(e.center.xy(), m.x.hypot(r * m.y), m.y.hypot(r * m.x))
|
||||
}
|
||||
EntityKind::LwPolyline(p) => p.vertices.iter().all(|v| v.p.is_finite() && v.bulge.is_finite()) && bulges_finite(p),
|
||||
EntityKind::Spline(s) => s.control.iter().all(|p| p.is_finite()),
|
||||
// The SVG reader doesn't make these.
|
||||
EntityKind::Point(_)
|
||||
| EntityKind::Arc(_)
|
||||
| EntityKind::Polyline3d(_)
|
||||
| EntityKind::Helix(_)
|
||||
| EntityKind::Ray(_)
|
||||
| EntityKind::XLine(_)
|
||||
| EntityKind::Text(_)
|
||||
| EntityKind::MText(_)
|
||||
| EntityKind::AttDef(_)
|
||||
| EntityKind::Insert(_)
|
||||
| EntityKind::Dimension(_)
|
||||
| EntityKind::MLine(_)
|
||||
| EntityKind::Leader(_)
|
||||
| EntityKind::MLeader(_)
|
||||
| EntityKind::Hatch(_)
|
||||
| EntityKind::Solid(_)
|
||||
| EntityKind::Trace(_)
|
||||
| EntityKind::Face3d(_)
|
||||
| EntityKind::PolyfaceMesh(_)
|
||||
| EntityKind::Region(_)
|
||||
| EntityKind::Viewport(_)
|
||||
| EntityKind::Image(_)
|
||||
| EntityKind::Wipeout(_)
|
||||
| EntityKind::Table(_)
|
||||
| EntityKind::Tolerance(_)
|
||||
| EntityKind::Unknown(_) => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// The box `centre ± (hx, hy)` is finite.
|
||||
fn box_finite(c: Vec2, hx: f64, hy: f64) -> bool {
|
||||
[c.x - hx, c.x + hx, c.y - hy, c.y + hy].iter().all(|v| v.is_finite())
|
||||
}
|
||||
|
||||
/// Every arc segment of the polyline (a bulge between finite vertices) has a finite centre and
|
||||
/// radius, and the quadrant points it passes through are finite.
|
||||
fn bulges_finite(p: &LwPolyline) -> bool {
|
||||
let n = p.vertices.len();
|
||||
p.vertices.iter().enumerate().all(|(i, v)| {
|
||||
let next = if i + 1 < n {
|
||||
p.vertices.get(i + 1)
|
||||
} else if p.closed {
|
||||
p.vertices.first()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let Some((arc, _)) = next.and_then(|w| bulge_to_arc(v.p, w.p, v.bulge)) else { return true };
|
||||
arc.center.is_finite()
|
||||
&& arc.radius.is_finite()
|
||||
&& (0..4)
|
||||
.map(|k| f64::from(k) * std::f64::consts::FRAC_PI_2)
|
||||
.all(|a| !arc.contains_angle(a) || Vec2::polar(arc.center, arc.radius, a).is_finite())
|
||||
})
|
||||
}
|
||||
|
||||
/// One `M …` run of a `d` attribute.
|
||||
struct Subpath {
|
||||
start: Vec2,
|
||||
@@ -471,4 +559,22 @@ mod tests {
|
||||
assert_eq!(arc_of("M10 10 a20 20 0 1 0 20 20"), (true, false, spaced.2));
|
||||
assert!(arc_of("M10 10 a20 20 0 10-20 20").0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extents_past_the_largest_number_are_not_finite() {
|
||||
let ellipse = |c: Vec2, major: Vec2| EntityKind::Ellipse(Ellipse { center: v3(c), major: v3(major), ratio: 1.0, start: 0.0, end: 0.0 });
|
||||
assert!(!finite(&ellipse(Vec2::new(1e308, 0.0), Vec2::new(1e308, 0.0))));
|
||||
assert!(finite(&ellipse(Vec2::new(5e307, 0.0), Vec2::new(5e307, 0.0))));
|
||||
// Turned, its box is wider than its axis: `centre ± major` is finite, the box isn't.
|
||||
assert!(!finite(&ellipse(Vec2::new(6e307, 0.0), Vec2::new(9e307, 9e307))));
|
||||
assert!(finite(&ellipse(Vec2::ZERO, Vec2::new(9e307, 9e307))));
|
||||
// Half circles between the same finite points: bulging up passes 1.8e308, down doesn't.
|
||||
let half = |bulge: f64| {
|
||||
let (a, b) = (Vec2::new(0.0, 1.5e308), Vec2::new(1e308, 1.5e308));
|
||||
let vertices = vec![PolyVertex::with_bulge(a, bulge), PolyVertex::new(b)];
|
||||
EntityKind::LwPolyline(LwPolyline { vertices, closed: false, const_width: 0.0, elevation: 0.0, plinegen: false })
|
||||
};
|
||||
assert!(!finite(&half(-1.0)));
|
||||
assert!(finite(&half(1.0)));
|
||||
}
|
||||
}
|
||||
|
||||
+117
-1
@@ -2915,12 +2915,75 @@ fn svg_shapes_become_entities_in_millimetres() {
|
||||
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
|
||||
assert!((c.radius - 2.0).abs() < 1e-9 && (c.center.x - 10.0).abs() < 1e-9 && (c.center.y - 5.0).abs() < 1e-9, "{c:?}");
|
||||
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
|
||||
let major = Vec2::new(e.major.x - e.center.x, e.major.y - e.center.y);
|
||||
let major = Vec2::new(e.major.x, e.major.y);
|
||||
assert!((major.len() - 4.0).abs() < 1e-9 && (e.ratio - 0.5).abs() < 1e-9, "{e:?}");
|
||||
let l = first(&d, |k| if let EntityKind::Line(l) = k { Some(l.clone()) } else { None });
|
||||
assert!((l.a.y - 10.0).abs() < 1e-9 && (l.b.y).abs() < 1e-9, "{l:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_ellipse_major_axis_is_relative_to_its_centre() {
|
||||
// Away from the origin: the major axis was stored as the absolute point centre + axis.
|
||||
let svg = format!("{SVG_PAGE}<ellipse cx=\"15\" cy=\"2\" rx=\"2\" ry=\"1\"/><circle cx=\"15\" cy=\"2\" r=\"1\"/></svg>");
|
||||
let d = read(svg.as_bytes(), "ellipse.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Ellipse", "Circle"]);
|
||||
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
|
||||
assert!((e.center - Vec3::new(15.0, 8.0, 0.0)).len() < 1e-9, "{e:?}");
|
||||
assert!((e.major.x.abs() - 2.0).abs() < 1e-9 && e.major.y.abs() < 1e-9 && e.major.z == 0.0, "{e:?}");
|
||||
assert!((e.ratio - 0.5).abs() < 1e-9, "{e:?}");
|
||||
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
|
||||
assert!((c.center - Vec3::new(15.0, 8.0, 0.0)).len() < 1e-9 && (c.radius - 1.0).abs() < 1e-9, "{c:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_rotated_ellipse_keeps_its_turn() {
|
||||
// The page maps SVG (x, y) to (x, 10 - y); undo that, then rotate by -30°, to get back to the ellipse's own frame.
|
||||
let svg = format!("{SVG_PAGE}<ellipse cx=\"0\" cy=\"0\" rx=\"20\" ry=\"10\" transform=\"rotate(30)\"/></svg>");
|
||||
let d = read(svg.as_bytes(), "rotated.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Ellipse"]);
|
||||
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
|
||||
let major = Vec2::new(e.major.x, e.major.y);
|
||||
assert!((major.len() - 20.0).abs() < 1e-9 && (e.ratio - 0.5).abs() < 1e-9, "{e:?}");
|
||||
let (s, c) = 30f64.to_radians().sin_cos();
|
||||
let want = Vec2::new(20.0 * c, -20.0 * s);
|
||||
assert!((major - want).len() < 1e-9 || (major + want).len() < 1e-9, "{e:?}");
|
||||
let (ux, uy) = (e.center.x + major.x, 10.0 - (e.center.y + major.y));
|
||||
let (x, y) = (c * ux + s * uy, -s * ux + c * uy);
|
||||
assert!(((x / 20.0).powi(2) + (y / 10.0).powi(2) - 1.0).abs() < 1e-9, "{e:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_sheared_circle_has_the_axes_of_its_image() {
|
||||
// matrix(1 0 1 1 0 0) is B = [[1, 1], [0, 1]]; the page then flips Y at one millimetre per unit.
|
||||
let svg = format!("{SVG_PAGE}<circle r=\"1\" transform=\"matrix(1 0 1 1 0 0)\"/></svg>");
|
||||
let d = read(svg.as_bytes(), "sheared.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Ellipse"]);
|
||||
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
|
||||
let major = Vec2::new(e.major.x, e.major.y);
|
||||
let s_max = ((3.0 + 5f64.sqrt()) / 2.0).sqrt();
|
||||
let s_min = ((3.0 - 5f64.sqrt()) / 2.0).sqrt();
|
||||
assert!((major.len() - s_max).abs() < 1e-9 * s_max, "{e:?}");
|
||||
assert!((e.ratio - s_min / s_max).abs() < 1e-9, "{e:?}");
|
||||
let (ux, uy) = (major.x, -major.y);
|
||||
let pre = Vec2::new(ux - uy, uy);
|
||||
assert!((pre.len() - 1.0).abs() < 1e-9, "B⁻¹·major = {pre:?}, {e:?}");
|
||||
assert!(major.x.abs() > 1e-3 && major.y.abs() > 1e-3, "{e:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_tiny_sheared_circle_has_the_axes_of_its_image() {
|
||||
// Columns (1, 0.5)·1e-6 and (1, -0.5)·1e-6: far from orthogonal, though their dot product is tiny.
|
||||
let svg = format!("{SVG_PAGE}<circle r=\"1\" transform=\"matrix(1e-6 0.5e-6 1e-6 -0.5e-6 0 0)\"/></svg>");
|
||||
let d = read(svg.as_bytes(), "tiny.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Ellipse"]);
|
||||
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
|
||||
let major = Vec2::new(e.major.x, e.major.y);
|
||||
assert!(major.y.abs() <= 1e-9 * major.x.abs(), "{e:?}");
|
||||
let want = 2f64.sqrt() * 1e-6;
|
||||
assert!((major.len() - want).abs() < 1e-9 * want, "{e:?}");
|
||||
assert!((e.ratio - 0.5).abs() < 1e-9, "{e:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_path_lines_curves_and_arcs() {
|
||||
let svg = format!("{SVG_PAGE}<path d=\"M1 1 L5 1 C6 1 7 2 8 3\"/><path d=\"M0 0 A5 5 0 0 1 10 0 Z\"/></svg>");
|
||||
@@ -3137,6 +3200,59 @@ fn svg_hostile_input_errors_without_panicking() {
|
||||
assert!(deep.is_err(), "200 nested groups are refused, not walked");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_coordinates_that_overflow_are_left_out() {
|
||||
// Every number is finite; relative steps and transforms overflow them to infinity or NaN.
|
||||
let svg = format!(
|
||||
"{SVG_PAGE}<path d=\"M1e308 0 l1e308 0\"/><rect x=\"1e308\" width=\"1e308\" height=\"1\"/>\
|
||||
<g transform=\"scale(1e308)\"><line x1=\"1e308\" y1=\"0\" x2=\"1\" y2=\"1\"/><circle r=\"1e308\"/></g>\
|
||||
<g transform=\"scale(1e308,1)\"><ellipse rx=\"1e308\" ry=\"1\"/><path d=\"M0 0 C1e308 0 1 1 2 2\"/></g>\
|
||||
<line x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\"/></svg>"
|
||||
);
|
||||
let d = read(svg.as_bytes(), "huge.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Line"]);
|
||||
assert_eq!(d.read_notes, ["SVG: 6 shapes were left out as invalid: their coordinates or size are too large to represent"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_shapes_whose_extents_overflow_are_left_out() {
|
||||
// A finite centre and radius whose sum overflows; the same scale on smaller values stays
|
||||
// representable.
|
||||
let svg = format!("{SVG_PAGE}<g transform=\"scale(1e308)\"><circle cx=\"1\" cy=\"0\" r=\"1\"/><circle cx=\"0.5\" cy=\"0\" r=\"0.5\"/></g></svg>");
|
||||
let d = read(svg.as_bytes(), "huge.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Circle"]);
|
||||
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
|
||||
assert!((c.radius - 5e307).abs() < 1e293, "{}", c.radius);
|
||||
assert_eq!(d.read_notes, ["SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent"]);
|
||||
}
|
||||
|
||||
/// A shape too large to represent is invalid, not something CADCraft doesn't read yet: it gets a
|
||||
/// note of its own.
|
||||
#[test]
|
||||
fn svg_too_large_shapes_are_noted_apart_from_unread_content() {
|
||||
let svg = format!("{SVG_PAGE}<text x=\"0\" y=\"5\">one</text><path d=\"M1e308 0 l1e308 0\"/><line x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\"/></svg>");
|
||||
let d = read(svg.as_bytes(), "huge.svg").unwrap();
|
||||
assert_eq!(kinds(&d), ["Line"]);
|
||||
assert_eq!(
|
||||
d.read_notes,
|
||||
[
|
||||
"SVG: CADCraft doesn't read these yet, so they were left out: 1 text",
|
||||
"SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_shapes_left_out_still_count_against_the_vertex_budget() {
|
||||
// Each arc flattens to 10,000 chords under the non-uniform scale, and the doubled translation
|
||||
// overflows to infinity, so each is left out; 820 of them make more than the 8,000,000 vertices
|
||||
// a file may generate.
|
||||
let arcs = "A1e9 1e9 0 0 1 2e9 0 A1e9 1e9 0 0 1 0 0 ".repeat(410);
|
||||
let svg = format!("{SVG_PAGE}<g transform=\"translate(1e308 0) translate(1e308 0) scale(2 1)\"><path d=\"M0 0 {arcs}\"/></g></svg>");
|
||||
let err = read(svg.as_bytes(), "huge.svg").err().map(|e| e.to_string()).unwrap_or_default();
|
||||
assert!(err.contains("SVG: too much generated geometry"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn svg_no_geometry_yields_an_empty_drawing() {
|
||||
let svg = format!("{SVG_PAGE}</svg>");
|
||||
|
||||
@@ -0,0 +1,360 @@
|
||||
//! A hostile or damaged file can name a handle at the top of the range: an object's own handle,
|
||||
//! or its `$HANDSEED`. A file's handles keep their identity, so a new object must take a free
|
||||
//! handle instead of replacing the file's own object (#913).
|
||||
#![cfg(not(target_arch = "wasm32"))]
|
||||
|
||||
use cadcraft_doc::{Common, DimKind, Dimension, Drawing, Entity, EntityKind, Handle, Line, Space};
|
||||
use cadcraft_geom::Vec3;
|
||||
|
||||
const TOP: &str = "FFFFFFFFFFFFFFFF";
|
||||
const NEAR_TOP: &str = "FFFFFFFFFFFEFFFF";
|
||||
|
||||
fn read(text: &str) -> Drawing {
|
||||
cadcraft_io::read_dxf(text.as_bytes()).unwrap()
|
||||
}
|
||||
|
||||
fn line(x: f64, y: f64) -> EntityKind {
|
||||
EntityKind::Line(Line { a: Vec3::new(x, y, 0.0), b: Vec3::new(x + 1.0, y, 0.0) })
|
||||
}
|
||||
|
||||
/// One line, with `entity_handle` when given, under a `$HANDSEED` of `seed`.
|
||||
fn dxf(entity_handle: Option<&str>, seed: &str) -> String {
|
||||
let handle = entity_handle.map(|h| format!("5\n{h}\n")).unwrap_or_default();
|
||||
format!(
|
||||
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n{seed}\n0\nENDSEC\n\
|
||||
0\nSECTION\n2\nENTITIES\n0\nLINE\n{handle}8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n0\nENDSEC\n0\nEOF\n"
|
||||
)
|
||||
}
|
||||
|
||||
fn distinct(d: &Drawing) -> Vec<Handle> {
|
||||
d.model.iter().map(|e| e.handle).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_object_at_the_top_of_the_handle_range_is_not_replaced_by_a_new_one() {
|
||||
let mut d = read(&dxf(Some(TOP), TOP));
|
||||
assert_eq!(d.model.len(), 1);
|
||||
// The file's handle is its own; the new object takes a free handle below it.
|
||||
assert!(d.entity(Handle::parse_hex(TOP).unwrap()).is_some(), "the file's handle was renumbered");
|
||||
d.add(&Space::Model, Common::default(), line(10.0, 10.0)).unwrap();
|
||||
assert_eq!(d.model.len(), 2, "the file's line was replaced by the new one");
|
||||
let handles = distinct(&d);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the file's line is gone");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_seed_at_the_top_of_the_handle_range_cannot_be_followed_twice() {
|
||||
let mut d = read(&dxf(None, TOP));
|
||||
let a = d.add(&Space::Model, Common::default(), line(0.0, 10.0)).unwrap();
|
||||
let b = d.add(&Space::Model, Common::default(), line(0.0, 20.0)).unwrap();
|
||||
assert_ne!(a, b, "two objects were given the same handle");
|
||||
assert_eq!(d.model.len(), 3, "the second line replaced the first");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_ordinary_high_handle_keeps_its_identity() {
|
||||
// Far below the top of the range a file's handles are its own: they stay as they are.
|
||||
let h = "FFFFFFFF";
|
||||
let mut d = read(&dxf(Some(h), h));
|
||||
assert!(d.entity(Handle::parse_hex(h).unwrap()).is_some(), "the file's handle was renumbered");
|
||||
let n = d.add(&Space::Model, Common::default(), line(0.0, 5.0)).unwrap();
|
||||
assert!(n.0 > Handle::parse_hex(h).unwrap().0, "a new handle below the file's own");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_handle_just_below_the_top_survives_a_save() {
|
||||
// Main keeps a file's handles exactly as written, even near the top of the range: handles
|
||||
// are how other objects and other programs refer to an entity (#939's round-trip tests).
|
||||
let mut d = read(&dxf(Some(NEAR_TOP), NEAR_TOP));
|
||||
let n = d.add(&Space::Model, Common::default(), line(0.0, 5.0)).unwrap();
|
||||
let bytes = cadcraft_io::write(&d, "near-top.dxf").unwrap();
|
||||
let r = cadcraft_io::read_dxf(&bytes).unwrap();
|
||||
assert!(r.entity(Handle::parse_hex(NEAR_TOP).unwrap()).is_some(), "the file's handle did not survive the save");
|
||||
assert!(r.entity(n).is_some(), "the new handle did not survive the save");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nine_objects_drawn_after_a_saturated_seed_save_and_reopen_distinct() {
|
||||
// The nine-entity case from #2237: a saturated $HANDSEED, ordinary entity handles. Drawing
|
||||
// after the load gives every object its own handle, and a save/reopen keeps them apart.
|
||||
let mut d = read(&dxf(None, TOP));
|
||||
for i in 0..9 {
|
||||
d.add(&Space::Model, Common::default(), line(f64::from(i), 40.0)).unwrap();
|
||||
}
|
||||
let bytes = cadcraft_io::write(&d, "nine.dxf").unwrap();
|
||||
let r = cadcraft_io::read_dxf(&bytes).unwrap();
|
||||
assert_eq!(r.model.len(), 10, "the file's line and the nine drawn ones");
|
||||
let handles = distinct(&r);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "repeated handles on reopen: {handles:?}");
|
||||
}
|
||||
|
||||
/// The first handle in the reserved band above [`HANDLE_LIMIT`].
|
||||
const BAND: &str = "FFFFFFFF00000000";
|
||||
|
||||
#[test]
|
||||
fn a_seed_in_the_reserved_band_does_not_hand_out_the_files_handle() {
|
||||
// #913's remaining case: a file says its next handle is FFFFFFFF00000000 and an object holds
|
||||
// that handle. Following the seed once would hand the object's handle to the new object, and
|
||||
// `EntityStore` would replace the file's line.
|
||||
let mut d = read(&dxf(Some(BAND), BAND));
|
||||
assert_eq!(d.model.len(), 1);
|
||||
let n = d.add(&Space::Model, Common::default(), line(10.0, 10.0)).unwrap();
|
||||
assert_ne!(n, Handle::parse_hex(BAND).unwrap(), "the new object took the file object's handle");
|
||||
assert_eq!(d.model.len(), 2, "the file's line was replaced");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the file's line is gone");
|
||||
|
||||
let bytes = cadcraft_io::write(&d, "band-seed.dxf").unwrap();
|
||||
let r = cadcraft_io::read_dxf(&bytes).unwrap();
|
||||
let handles = distinct(&r);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "repeated handles on reopen: {handles:?}");
|
||||
assert_eq!(r.model.len(), 2, "a line did not survive the save");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_save_does_not_give_a_structural_record_an_objects_handle() {
|
||||
// The writer numbers its own records from `seed + 0x1000`; with the seed at the bottom of the
|
||||
// reserved band that lands on the file's own handle. The file must keep one record per handle.
|
||||
let object = "FFFFFFFF00001000";
|
||||
let d = read(&dxf(Some(object), "FFFFFFFEFFFFFFFF"));
|
||||
let bytes = cadcraft_io::write(&d, "band-structural.dxf").unwrap();
|
||||
let tags = craft_dxf::parse(&bytes).unwrap();
|
||||
// Record handles start with the TABLES section; before it the HEADER's `$HANDSEED` is the
|
||||
// next free handle, not a record's.
|
||||
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
|
||||
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
|
||||
let unique: std::collections::HashSet<&String> = written.iter().collect();
|
||||
assert_eq!(unique.len(), written.len(), "the save repeats a handle: {written:?}");
|
||||
assert_eq!(written.iter().filter(|h| h.as_str() == object).count(), 1, "the object's handle was not written exactly once");
|
||||
|
||||
let r = cadcraft_io::read_dxf(&bytes).unwrap();
|
||||
assert!(r.entity(Handle::parse_hex(object).unwrap()).is_some(), "the file's object is gone");
|
||||
}
|
||||
|
||||
/// A CADCraft-marked file with a handle-less block entity and an `ENTITIES` record that names
|
||||
/// the handle the reader would give it. The marker means the reader skips the handle pre-scan,
|
||||
/// so the two sections must still reserve against each other.
|
||||
fn marked_file_with_handle_less_block_entity() -> String {
|
||||
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n1000\n0\nENDSEC\n\
|
||||
0\nSECTION\n2\nBLOCKS\n\
|
||||
0\nBLOCK\n8\n0\n2\n*MODEL_SPACE\n70\n0\n10\n0.0\n20\n0.0\n30\n0.0\n3\n*MODEL_SPACE\n1\n\n\
|
||||
0\nLINE\n8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n\
|
||||
0\nENDBLK\n8\n0\n\
|
||||
0\nENDSEC\n\
|
||||
0\nSECTION\n2\nENTITIES\n\
|
||||
0\nLINE\n5\n100\n8\n0\n10\n10.0\n20\n0.0\n30\n0.0\n11\n11.0\n21\n0.0\n31\n0.0\n\
|
||||
0\nENDSEC\n\
|
||||
0\nSECTION\n2\nOBJECTS\n\
|
||||
0\nXRECORD\n5\n300\n100\nAcDbXrecord\n3\nCADCRAFT_HANDSEED\n1\n1000\n\
|
||||
0\nENDSEC\n0\nEOF\n"
|
||||
.to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_marked_files_sections_reserve_handles_against_each_other() {
|
||||
// The block entity has no handle of its own, so the reader gives it one; a later ENTITIES
|
||||
// record must not be given the same handle, or one entity silently replaces the other.
|
||||
let d = read(&marked_file_with_handle_less_block_entity());
|
||||
assert_eq!(d.model.len(), 2, "one entity replaced the other");
|
||||
let handles = distinct(&d);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the block entity is gone");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 10.0)), "the ENTITIES line is gone");
|
||||
}
|
||||
|
||||
/// A file whose BLOCKS holds a handle-less model-space entity and whose ENTITIES names the
|
||||
/// last handle below the reserved band and the first handle in it. With `marked` the file names
|
||||
/// CADCraft's own seed record, which narrows the reader's handle pre-scan to the entity sections.
|
||||
fn file_with_reserved_band_entities(marked: bool) -> String {
|
||||
let below = format!("{:X}", cadcraft_doc::HANDLE_LIMIT - 1);
|
||||
let band = format!("{:X}", cadcraft_doc::HANDLE_LIMIT);
|
||||
let objects = if marked {
|
||||
"0\nSECTION\n2\nOBJECTS\n\
|
||||
0\nXRECORD\n5\n300\n100\nAcDbXrecord\n3\nCADCRAFT_HANDSEED\n1\n1000\n\
|
||||
0\nENDSEC\n"
|
||||
} else {
|
||||
""
|
||||
};
|
||||
format!(
|
||||
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n1000\n0\nENDSEC\n\
|
||||
0\nSECTION\n2\nBLOCKS\n\
|
||||
0\nBLOCK\n8\n0\n2\n*MODEL_SPACE\n70\n0\n10\n0.0\n20\n0.0\n30\n0.0\n3\n*MODEL_SPACE\n1\n\n\
|
||||
0\nLINE\n8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n\
|
||||
0\nENDBLK\n8\n0\n\
|
||||
0\nENDSEC\n\
|
||||
0\nSECTION\n2\nENTITIES\n\
|
||||
0\nLINE\n5\n{below}\n8\n0\n10\n10.0\n20\n0.0\n30\n0.0\n11\n11.0\n21\n0.0\n31\n0.0\n\
|
||||
0\nLINE\n5\n{band}\n8\n0\n10\n20.0\n20\n0.0\n30\n0.0\n11\n21.0\n21\n0.0\n31\n0.0\n\
|
||||
0\nENDSEC\n{objects}0\nEOF\n"
|
||||
)
|
||||
}
|
||||
|
||||
/// All three lines survive with their own handles: the handle-less block entity could not take
|
||||
/// the reserved-band handle of the file's own ENTITIES record.
|
||||
fn assert_three_lines_survive(d: &Drawing) {
|
||||
assert_eq!(d.model.len(), 3, "one entity replaced another");
|
||||
let handles = distinct(d);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the block entity is gone");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 10.0)), "the line below the band is gone");
|
||||
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 20.0)), "the line in the band is gone");
|
||||
// The band's explicit handle stays with the record that names it.
|
||||
let band = Handle(cadcraft_doc::HANDLE_LIMIT);
|
||||
let owner = d.model.iter().find(|e| e.handle == band).expect("the band handle was renumbered");
|
||||
assert!(matches!(&owner.kind, EntityKind::Line(l) if l.a.x == 20.0), "the band handle moved to another line");
|
||||
// The handle just below the band is the file's too, and it stays with its own record.
|
||||
let below = Handle(cadcraft_doc::HANDLE_LIMIT - 1);
|
||||
let owner = d.model.iter().find(|e| e.handle == below).expect("the below-band handle was renumbered");
|
||||
assert!(matches!(&owner.kind, EntityKind::Line(l) if l.a.x == 10.0), "the below-band handle moved to another line");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_band_handles_in_entities_are_not_handed_to_a_handle_less_block_entity() {
|
||||
// The handle below the reserved band is the file's, so the reader's next handle is the first
|
||||
// handle in the band, which an ENTITIES record already owns. The seed cannot follow it
|
||||
// (#913), so the handle is reserved for allocation instead: the handle-less model-space
|
||||
// block entity must not take it and replace the file's line.
|
||||
assert_three_lines_survive(&read(&file_with_reserved_band_entities(true)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_band_handles_are_reserved_without_the_cadcraft_seed_record() {
|
||||
// The same reservation holds when the pre-scan reads every section's handles: a handle in
|
||||
// the band is the file's own there too, and still must not be given away.
|
||||
assert_three_lines_survive(&read(&file_with_reserved_band_entities(false)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reservations_end_with_the_read_and_placed_objects_still_keep_their_handles() {
|
||||
// The reservations only bridge the gap until a record is placed; a drawing does not carry
|
||||
// them on (every undo step copies the drawing). The placed objects keep new ones off.
|
||||
let mut d = read(&file_with_reserved_band_entities(true));
|
||||
assert!(d.reserved_handles.is_empty(), "the reader's reservations outlived the read");
|
||||
for i in 0..3 {
|
||||
d.add(&Space::Model, Common::default(), line(f64::from(i), 50.0)).unwrap();
|
||||
}
|
||||
assert_eq!(d.model.len(), 6, "a new object replaced one of the file's");
|
||||
assert_three_lines_survive_among(&d);
|
||||
}
|
||||
|
||||
fn assert_three_lines_survive_among(d: &Drawing) {
|
||||
let band = Handle(cadcraft_doc::HANDLE_LIMIT);
|
||||
assert!(d.model.iter().any(|e| e.handle == band && matches!(&e.kind, EntityKind::Line(l) if l.a.x == 20.0)), "the band line lost its handle");
|
||||
let handles = distinct(d);
|
||||
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
|
||||
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generated_geometry_never_takes_a_handle_an_object_holds() {
|
||||
// The drawing's own handles sit in the reserved band and the seed is at the top of the
|
||||
// range, so the writer's structural numbering wraps into the band. Every other band handle
|
||||
// is taken, so without a check the generated dimension block's entities land on an occupied
|
||||
// one: the saved file would repeat a handle.
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.handseed = u64::MAX - 1;
|
||||
{
|
||||
let model = d.space_mut(&Space::Model).unwrap();
|
||||
for i in 0..200u64 {
|
||||
let handle = Handle(cadcraft_doc::HANDLE_LIMIT + 1 + 2 * i);
|
||||
model.push(Entity { handle, common: Common::default(), kind: line(i as f64, 0.0) });
|
||||
}
|
||||
model.push(Entity {
|
||||
handle: Handle(0x200),
|
||||
common: Common::default(),
|
||||
kind: EntityKind::Dimension(Dimension {
|
||||
kind: DimKind::Linear { rotation: 0.0 },
|
||||
defpt: Vec3::new(0.0, 1.0, 0.0),
|
||||
text_mid: Vec3::new(1.0, 1.0, 0.0),
|
||||
p13: Vec3::ZERO,
|
||||
p14: Vec3::new(2.0, 0.0, 0.0),
|
||||
p15: Vec3::ZERO,
|
||||
p16: Vec3::ZERO,
|
||||
text: String::new(),
|
||||
style: "Standard".into(),
|
||||
measurement: 2.0,
|
||||
text_rotation: 0.0,
|
||||
user_text_pos: false,
|
||||
block: None,
|
||||
insertion_point: Vec3::ZERO,
|
||||
overrides: serde_json::Map::new(),
|
||||
assoc: Vec::new(),
|
||||
marks: Default::default(),
|
||||
}),
|
||||
});
|
||||
}
|
||||
let bytes = cadcraft_io::write(&d, "generated.dxf").unwrap();
|
||||
let tags = craft_dxf::parse(&bytes).unwrap();
|
||||
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
|
||||
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
|
||||
let unique: std::collections::HashSet<&String> = written.iter().collect();
|
||||
assert_eq!(unique.len(), written.len(), "the save repeats a handle");
|
||||
}
|
||||
|
||||
/// A line at the top handle with another application's xdata, and that application's object kept
|
||||
/// from the file: a dictionary in the named object dictionary holding an XRECORD.
|
||||
fn top_line_with_kept_objects() -> String {
|
||||
let groups: &[(i32, &str)] = &[
|
||||
(0, "SECTION"),
|
||||
(2, "ENTITIES"),
|
||||
(0, "LINE"),
|
||||
(5, TOP),
|
||||
(8, "0"),
|
||||
(10, "0"),
|
||||
(20, "0"),
|
||||
(11, "10"),
|
||||
(21, "0"),
|
||||
(1001, "OTHER_APP"),
|
||||
(1000, "tagged"),
|
||||
(0, "ENDSEC"),
|
||||
(0, "SECTION"),
|
||||
(2, "OBJECTS"),
|
||||
(0, "DICTIONARY"),
|
||||
(5, "C"),
|
||||
(330, "0"),
|
||||
(100, "AcDbDictionary"),
|
||||
(3, "OTHER_APP"),
|
||||
(350, "50"),
|
||||
(0, "DICTIONARY"),
|
||||
(5, "50"),
|
||||
(330, "C"),
|
||||
(100, "AcDbDictionary"),
|
||||
(281, "1"),
|
||||
(3, "DATA"),
|
||||
(360, "51"),
|
||||
(0, "XRECORD"),
|
||||
(5, "51"),
|
||||
(330, "50"),
|
||||
(100, "AcDbXrecord"),
|
||||
(280, "1"),
|
||||
(1, "kept"),
|
||||
(0, "ENDSEC"),
|
||||
(0, "EOF"),
|
||||
];
|
||||
groups.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn records_added_on_save_after_the_top_handle_take_free_handles() {
|
||||
// The writer adds the kept objects (and any application id the xdata needs) after its own
|
||||
// records, numbered above the largest handle written. That is the file's line at the top of
|
||||
// the range: counting on from it would give every added record the line's handle.
|
||||
let d = read(&top_line_with_kept_objects());
|
||||
let bytes = cadcraft_io::write(&d, "kept-top.dxf").unwrap();
|
||||
let text = String::from_utf8_lossy(&bytes);
|
||||
assert!(text.contains("\nkept"), "the kept XRECORD was not written");
|
||||
let tags = craft_dxf::parse(&bytes).unwrap();
|
||||
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
|
||||
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
|
||||
let unique: std::collections::HashSet<&String> = written.iter().collect();
|
||||
assert_eq!(unique.len(), written.len(), "the save repeats a handle: {written:?}");
|
||||
assert_eq!(written.iter().filter(|h| h.as_str() == TOP).count(), 1, "the line's handle was not written exactly once");
|
||||
|
||||
let r = read(&String::from_utf8_lossy(&bytes));
|
||||
assert!(r.entity(Handle::parse_hex(TOP).unwrap()).is_some(), "the file's line is gone");
|
||||
}
|
||||
@@ -169,7 +169,7 @@ fn the_added_paper_viewport_follows_the_plot_scale() {
|
||||
let sheet_width = |scale: f64, fit: bool| {
|
||||
let mut d = Drawing::new_metric();
|
||||
let page = &mut d.layouts[0].page;
|
||||
(page.width_mm, page.height_mm, page.landscape, page.paper_mm) = (297.0, 420.0, true, Some(true));
|
||||
(page.width_mm, page.height_mm, page.landscape, page.paper_mm) = (297.0, 420.0, true, true);
|
||||
(page.scale, page.scale_to_fit) = (scale, fit);
|
||||
let first = Space::Paper(d.layouts[0].name.clone());
|
||||
d.add(&first, Common::default(), viewport(2)).unwrap();
|
||||
|
||||
@@ -19,7 +19,7 @@ fn drawing() -> Drawing {
|
||||
height_mm: 297.0,
|
||||
margins_mm: [0.0; 4],
|
||||
landscape: true,
|
||||
paper_mm: Some(true),
|
||||
paper_mm: true,
|
||||
..PageSetup::default()
|
||||
};
|
||||
d.layouts.push(l);
|
||||
@@ -57,81 +57,16 @@ fn plot_paper_units_round_trip_through_dxf() {
|
||||
// Written as group 72 = 1 (millimetres) and read back as such.
|
||||
let back = read(write_dxf(&drawing()).as_bytes(), "x.dxf").unwrap();
|
||||
let page = &back.layouts.iter().find(|l| l.name == "SHEET").unwrap().page;
|
||||
assert_eq!(page.paper_mm, Some(true));
|
||||
assert!(page.paper_mm);
|
||||
assert_eq!(cadcraft_render::sheet(&back, "SHEET").unwrap().unit_mm, 1.0);
|
||||
// A metric drawing's layouts stay in millimetres even from files that say 72 = 0 and carry
|
||||
// no PSUNITS xdata (what earlier CADCraft versions wrote for every layout).
|
||||
// A metric drawing's layouts stay in millimetres even from files that say 72 = 0 (what
|
||||
// earlier CADCraft versions wrote for every layout).
|
||||
let mut metric = Drawing::new_metric();
|
||||
metric.header.set_i64("MEASUREMENT", 1);
|
||||
let written = write_dxf(&metric);
|
||||
let text = written
|
||||
.replace("1001\r\nCADCRAFT\r\n1000\r\nPSUNITS\r\n1002\r\n{\r\n1070\r\n2\r\n1002\r\n}\r\n", "")
|
||||
.replace("\r\n 72\r\n1\r\n", "\r\n 72\r\n0\r\n");
|
||||
let text = written.replace("\r\n 72\r\n1\r\n", "\r\n 72\r\n0\r\n");
|
||||
assert_ne!(text, written, "the layouts' 72 = 1 became 0");
|
||||
let back = read(text.as_bytes(), "old.dxf").unwrap();
|
||||
let name = back.layouts.first().unwrap().name.clone();
|
||||
assert_eq!(cadcraft_render::sheet(&back, &name).unwrap().unit_mm, 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_explicit_inch_layout_round_trips_on_a_metric_drawing() {
|
||||
// #3249: group 72 = 0 is also what an unset layout writes, so the explicit inch choice
|
||||
// travels in CADCraft xdata and must win over the group 72 fallback.
|
||||
let mut d = Drawing::new_metric();
|
||||
d.header.set_i64("MEASUREMENT", 1);
|
||||
let mut l = Layout::new("INCHES", 3);
|
||||
l.page = PageSetup {
|
||||
paper: "ARCH D".into(),
|
||||
width_mm: 609.6,
|
||||
height_mm: 914.4,
|
||||
margins_mm: [0.0; 4],
|
||||
landscape: true,
|
||||
paper_mm: Some(false),
|
||||
..PageSetup::default()
|
||||
};
|
||||
d.layouts.push(l);
|
||||
let back = read(write_dxf(&d).as_bytes(), "x.dxf").unwrap();
|
||||
let page = &back.layouts.iter().find(|l| l.name == "INCHES").unwrap().page;
|
||||
assert_eq!(page.paper_mm, Some(false));
|
||||
let sheet = cadcraft_render::sheet(&back, "INCHES").unwrap();
|
||||
assert_eq!(sheet.unit_mm, 25.4);
|
||||
assert!((sheet.size.x - 36.0).abs() < 1e-9 && (sheet.size.y - 24.0).abs() < 1e-9, "{:?}", sheet.size);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_inherited_layout_keeps_following_measurement_after_a_dxf_round_trip() {
|
||||
// #3249: a layout that never chose its paper units reads back as inherited, not fixed to the
|
||||
// MEASUREMENT it had when saved. An ARCH D sheet on a metric drawing is 914.4 x 609.6; after
|
||||
// MEASUREMENT changes to imperial it must be 36 x 24. The explicit choices do not move.
|
||||
let mut d = Drawing::new_metric();
|
||||
d.header.set_i64("MEASUREMENT", 1);
|
||||
for (name, paper_mm) in [("INHERITED", None), ("INCHES", Some(false)), ("MILLIMETRES", Some(true))] {
|
||||
let mut l = Layout::new(name, 3);
|
||||
l.page = PageSetup {
|
||||
paper: "ARCH D".into(),
|
||||
width_mm: 609.6,
|
||||
height_mm: 914.4,
|
||||
margins_mm: [0.0; 4],
|
||||
landscape: true,
|
||||
paper_mm,
|
||||
..PageSetup::default()
|
||||
};
|
||||
d.layouts.push(l);
|
||||
}
|
||||
|
||||
let mut back = read(write_dxf(&d).as_bytes(), "x.dxf").unwrap();
|
||||
let units = |d: &Drawing, name: &str| d.layouts.iter().find(|l| l.name == name).unwrap().page.paper_mm;
|
||||
assert_eq!(units(&back, "INHERITED"), None);
|
||||
assert_eq!(units(&back, "INCHES"), Some(false));
|
||||
assert_eq!(units(&back, "MILLIMETRES"), Some(true));
|
||||
|
||||
back.header.set_i64("MEASUREMENT", 0);
|
||||
let sheet = |name: &str| cadcraft_render::sheet(&back, name).unwrap();
|
||||
let inherited = sheet("INHERITED");
|
||||
assert_eq!(inherited.unit_mm, 25.4);
|
||||
assert!((inherited.size.x - 36.0).abs() < 1e-9 && (inherited.size.y - 24.0).abs() < 1e-9, "{:?}", inherited.size);
|
||||
assert_eq!(sheet("INCHES").unit_mm, 25.4);
|
||||
let metric = sheet("MILLIMETRES");
|
||||
assert_eq!(metric.unit_mm, 1.0);
|
||||
assert!((metric.size.x - 914.4).abs() < 1e-9 && (metric.size.y - 609.6).abs() < 1e-9, "{:?}", metric.size);
|
||||
}
|
||||
|
||||
@@ -60,7 +60,6 @@ mod pdf_layers;
|
||||
#[path = "../support/pdf_read.rs"]
|
||||
mod pdf_read;
|
||||
mod plot_layout_scale;
|
||||
mod plot_model_metric_units;
|
||||
mod plot_model_png_scale;
|
||||
mod plot_styles;
|
||||
mod polyface_roundtrip;
|
||||
|
||||
@@ -1,130 +0,0 @@
|
||||
//! #1828: a model-space plot at 1:1 in a drawing whose units are millimetres puts a 10 mm line
|
||||
//! at 28.35 pt on an ISO A4 sheet, whatever MEASUREMENT says. A drawing made in millimetres by
|
||||
//! changing the drawing units (UNITS sets INSUNITS, not MEASUREMENT) was plotted 25.4 times too
|
||||
//! large, because model-space paper units were taken as inches.
|
||||
//!
|
||||
//! The model plot's units are the paper's, never the layouts' page setups': a layout whose page
|
||||
//! setup is in inches still plots its paper space in inches (#1866).
|
||||
|
||||
use cadcraft_doc::{Common, Drawing, EntityKind, Layout, Line, PageSetup, Space};
|
||||
use cadcraft_geom::Vec3;
|
||||
use cadcraft_io::plot;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::pdf_read;
|
||||
|
||||
/// The page size in points.
|
||||
fn media_box(pdf: &[u8]) -> (f64, f64) {
|
||||
pdf_read::read(pdf).media()
|
||||
}
|
||||
|
||||
/// The plotted length in points of the single horizontal line.
|
||||
fn line_pt(pdf: &[u8]) -> f64 {
|
||||
let doc = pdf_read::read(pdf);
|
||||
let xs: Vec<f64> = pdf_read::drawn(doc.content()).iter().filter(|o| o.op == "m" || o.op == "l").filter_map(|o| o.nums.first().copied()).collect();
|
||||
assert_eq!(xs.len(), 2, "one line, two ends: {xs:?}");
|
||||
(xs[1] - xs[0]).abs()
|
||||
}
|
||||
|
||||
/// A drawing with one 10-unit line in model space and the given drawing units.
|
||||
fn drawing(insunits: i64, measurement: i64) -> Drawing {
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.header.set_i64("INSUNITS", insunits);
|
||||
d.header.set_i64("MEASUREMENT", measurement);
|
||||
let line = EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(10.0, 0.0, 0.0) });
|
||||
d.add(&Space::Model, Common::default(), line).unwrap();
|
||||
d
|
||||
}
|
||||
|
||||
/// Plot the model at 1:1 on the named paper, as the Plot dialog does.
|
||||
fn plot_on(d: &Drawing, paper: &str) -> Vec<u8> {
|
||||
let opts: Value = json!({
|
||||
"paper": paper,
|
||||
"landscape": false,
|
||||
"fit": false,
|
||||
"scale": 1,
|
||||
"lineweights": false,
|
||||
"compress": false,
|
||||
});
|
||||
plot(d, &Space::Model, &opts).unwrap()
|
||||
}
|
||||
|
||||
const A4_PT: (f64, f64) = (595.28, 841.89);
|
||||
const ANSI_A_PT: (f64, f64) = (612.0, 792.0);
|
||||
const TEN_MM_PT: f64 = 28.3465;
|
||||
const TEN_IN_PT: f64 = 720.0;
|
||||
|
||||
fn assert_pt(actual: f64, want: f64) {
|
||||
assert!((actual - want).abs() < 0.01, "{actual} pt, want {want}");
|
||||
}
|
||||
|
||||
/// The MediaBox is the sheet in points (A4 or ANSI A, portrait).
|
||||
fn assert_media(pdf: &[u8], size: (f64, f64)) {
|
||||
let (w, h) = media_box(pdf);
|
||||
assert!((w - size.0).abs() < 0.01 && (h - size.1).abs() < 0.01, "{w} x {h} pt, want {size:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_plot_in_a_metric_drawing_is_one_to_one() {
|
||||
let pdf = plot_on(&drawing(4, 1), "ISO A4");
|
||||
assert_media(&pdf, A4_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_MM_PT);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_plot_follows_the_length_unit_when_measurement_says_inches() {
|
||||
// A drawing started imperial whose units the user changed to millimetres with UNITS:
|
||||
// MEASUREMENT stays 0, the length unit is what says the drawing is in millimetres.
|
||||
let pdf = plot_on(&drawing(4, 0), "ISO A4");
|
||||
assert_media(&pdf, A4_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_MM_PT);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_plot_takes_units_from_the_paper() {
|
||||
// A millimetre sheet at 1:1 prints one drawing unit per millimetre, whatever the drawing's
|
||||
// length unit is.
|
||||
let pdf = plot_on(&drawing(1, 0), "ISO A4");
|
||||
assert_media(&pdf, A4_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_MM_PT);
|
||||
// An inch sheet prints one drawing unit per inch, whatever the drawing's length unit is.
|
||||
let pdf = plot_on(&drawing(4, 0), "ANSI A");
|
||||
assert_media(&pdf, ANSI_A_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_IN_PT);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_plot_on_an_inch_sheet_is_in_inches_whatever_measurement_says() {
|
||||
// MEASUREMENT 1 (an ISO-template drawing) must not turn an inch sheet's units into
|
||||
// millimetres: a 10-unit line on ANSI A at 1:1 is 10 inches for every drawing unit.
|
||||
for (insunits, measurement) in [(4, 1), (0, 1), (1, 1), (4, 0)] {
|
||||
let pdf = plot_on(&drawing(insunits, measurement), "ANSI A");
|
||||
assert_media(&pdf, ANSI_A_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_IN_PT);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn layout_plot_keeps_its_page_setup_units() {
|
||||
// The @echelon regression: a metric drawing whose layout has a page setup in inches. The
|
||||
// layout's paper space is in inches (25.4 mm per unit), not in the drawing's millimetres,
|
||||
// and its A4 sheet is still A4.
|
||||
let mut d = drawing(4, 0);
|
||||
let mut l = Layout::new("SHEET", 3);
|
||||
l.page = PageSetup {
|
||||
paper: "ISO A4".into(),
|
||||
width_mm: 210.0,
|
||||
height_mm: 297.0,
|
||||
margins_mm: [0.0; 4],
|
||||
landscape: false,
|
||||
paper_mm: Some(false),
|
||||
..PageSetup::default()
|
||||
};
|
||||
d.layouts.push(l);
|
||||
let line = EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(10.0, 0.0, 0.0) });
|
||||
d.add(&Space::Paper("SHEET".into()), Common::default(), line).unwrap();
|
||||
let opts = json!({"fit": false, "scale": 1, "lineweights": false, "compress": false});
|
||||
let pdf = plot(&d, &Space::Paper("SHEET".into()), &opts).unwrap();
|
||||
assert_media(&pdf, A4_PT);
|
||||
assert_pt(line_pt(&pdf), TEN_IN_PT);
|
||||
}
|
||||
@@ -197,7 +197,7 @@ pub(super) fn layouts() -> Case {
|
||||
let mut drawing = cases::drawing();
|
||||
drawing.layouts = vec![Layout::new("Sheet_A", 1), Layout::new("Sheet_B", 2)];
|
||||
for (index, layout) in drawing.layouts.iter_mut().enumerate() {
|
||||
layout.page.paper_mm = Some(true);
|
||||
layout.page.paper_mm = true;
|
||||
// PageSetup stores portrait dimensions; landscape is a separate orientation flag.
|
||||
layout.page.width_mm = 297.0;
|
||||
layout.page.height_mm = 420.0;
|
||||
|
||||
@@ -26,7 +26,6 @@ fn preserves_or_refuses(path: &str, binary: bool) {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "Confirmed DXF data loss: exhausted generated handles produce a successful save that reopens with no model entities"]
|
||||
fn dxf_exhausted_handles_are_preserved_or_refused() {
|
||||
for binary in [false, true] {
|
||||
preserves_or_refuses("memory.dxf", binary);
|
||||
|
||||
@@ -16,8 +16,8 @@ fn import(transform: &str) -> (f64, f64) {
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
let (dx, dy) = (e.major.x - e.center.x, e.major.y - e.center.y);
|
||||
(dy.atan2(dx), e.ratio)
|
||||
// `major` is the axis from the centre (#2821).
|
||||
(e.major.y.atan2(e.major.x), e.ratio)
|
||||
}
|
||||
|
||||
/// Major-axis angle and ratio of the image of the ellipse under the 2x2 map `[a c; b d]`, with
|
||||
|
||||
+6
-170
@@ -1,9 +1,7 @@
|
||||
//! Paper sizes and the layout sheet (paper rectangle, printable area) for paper space.
|
||||
//!
|
||||
//! Paper-space units follow a layout's explicit page-setup choice (millimetres or inches), and
|
||||
//! otherwise `MEASUREMENT` (millimetres when 1, inches otherwise). The sheet's lower-left corner is the paper-space origin.
|
||||
//! Model-space plots have no stored page setup, so they take their units from the paper itself
|
||||
//! ([`model_page`], [`model_unit_mm`]).
|
||||
//! Paper-space units are millimetres in metric drawings (`MEASUREMENT` = 1) and on layouts whose
|
||||
//! page setup is in millimetres, and inches otherwise. The sheet's lower-left corner is the paper-space origin.
|
||||
|
||||
use cadcraft_doc::{Drawing, PageSetup};
|
||||
use cadcraft_geom::{Bounds2, Vec2};
|
||||
@@ -83,70 +81,11 @@ pub fn paper_unit_mm(d: &Drawing) -> f64 {
|
||||
if d.header.i64("MEASUREMENT", 0) == 1 { 1.0 } else { 25.4 }
|
||||
}
|
||||
|
||||
/// Whether the drawing's length unit is metric: `INSUNITS` millimetres to kilometres and
|
||||
/// angstroms to parsecs (4..=7, 11..=20) are metric, inches to US survey units (1, 2, 3, 8, 9,
|
||||
/// 10, 21, 22, 23, 24) imperial. A unitless drawing (`INSUNITS` 0, absent or unknown, as files
|
||||
/// without `$INSUNITS` are read, #1209) falls back to `MEASUREMENT` = 1.
|
||||
///
|
||||
/// `MEASUREMENT` only chooses the imperial or ISO hatch and linetype libraries (#1649, #1826),
|
||||
/// so it is not what says a drawing is metric: a drawing whose units are millimetres but whose
|
||||
/// MEASUREMENT is 0 — what UNITS leaves when the user picks millimetres, and what AutoCAD writes
|
||||
/// for many metric drawings — is metric by this test (#1828).
|
||||
pub fn metric_length_unit(d: &Drawing) -> bool {
|
||||
match d.header.i64("INSUNITS", 0) {
|
||||
// Inches, feet, miles, microinches, mils, yards and US survey units.
|
||||
1 | 2 | 3 | 8 | 9 | 10 | 21 | 22 | 23 | 24 => false,
|
||||
// Millimetres, centimetres, metres, kilometres, angstroms, nanometres, microns,
|
||||
// decimetres to gigametres, astronomical units, light years and parsecs.
|
||||
4..=7 | 11..=20 => true,
|
||||
// Unitless: as MEASUREMENT says.
|
||||
_ => d.header.i64("MEASUREMENT", 0) == 1,
|
||||
}
|
||||
}
|
||||
|
||||
/// Millimetres per paper unit of the paper named by `page`, from the paper itself: 1.0 for ISO
|
||||
/// and user-defined millimetre sizes, 25.4 for the ANSI, ARCH and Legal sheets. A name that is
|
||||
/// no known paper size is treated as a user millimetre size (1.0).
|
||||
pub fn model_unit_mm(page: &PageSetup) -> f64 {
|
||||
match paper_size(&page.paper) {
|
||||
Some(p) if p.imperial => 25.4,
|
||||
_ => 1.0,
|
||||
}
|
||||
}
|
||||
|
||||
/// The page a model-space plot starts from: ISO A4 in a drawing whose length unit is metric,
|
||||
/// ANSI A otherwise. Model space has no stored page setup, so the plot takes its sheet (and its
|
||||
/// units) from here unless the caller picks another paper.
|
||||
pub fn model_page(d: &Drawing) -> PageSetup {
|
||||
let mut page = PageSetup::default();
|
||||
if let Some(p) = paper_size(if metric_length_unit(d) { "A4" } else { "ANSI A" }) {
|
||||
page.paper = p.name.into();
|
||||
page.width_mm = p.width_mm;
|
||||
page.height_mm = p.height_mm;
|
||||
}
|
||||
apply_model_paper_units(&mut page);
|
||||
page
|
||||
}
|
||||
|
||||
/// Set a model-space plot's paper units once its paper is known: the paper's own units decide
|
||||
/// (ISO and user millimetre sizes are millimetres, ANSI and ARCH sheets inches), as a model-space
|
||||
/// page setup's "plot paper units" would. Layouts keep their stored page setup and go through
|
||||
/// [`page_unit_mm`]; only model-space callers use this. The units are set explicitly either
|
||||
/// way: an inch sheet left to follow `MEASUREMENT` would plot in millimetres in a drawing whose
|
||||
/// `MEASUREMENT` is 1.
|
||||
pub fn apply_model_paper_units(page: &mut PageSetup) {
|
||||
page.paper_mm = Some(model_unit_mm(page) == 1.0);
|
||||
}
|
||||
|
||||
/// Millimetres per paper-space unit on a layout with page setup `page`: `1.0` when the page
|
||||
/// chooses millimetres, `25.4` when it chooses inches, else as the drawing's `MEASUREMENT`
|
||||
/// says. Drawings from AutoCAD often have `MEASUREMENT` 0 with layouts in millimetres (#1058).
|
||||
/// Millimetres per paper-space unit on a layout with page setup `page`: millimetres when the
|
||||
/// page says so (plot paper units mm), else as the drawing's MEASUREMENT says. Drawings from
|
||||
/// AutoCAD often have MEASUREMENT 0 with layouts in millimetres (#1058).
|
||||
pub fn page_unit_mm(d: &Drawing, page: &PageSetup) -> f64 {
|
||||
match page.paper_mm {
|
||||
Some(true) => 1.0,
|
||||
Some(false) => 25.4,
|
||||
None => paper_unit_mm(d),
|
||||
}
|
||||
if page.paper_mm { 1.0 } else { paper_unit_mm(d) }
|
||||
}
|
||||
|
||||
/// Millimetres per paper-space unit on the layout holding the paper-space entity `h` (the
|
||||
@@ -200,92 +139,6 @@ pub fn sheet(d: &Drawing, layout: &str) -> Option<Sheet> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn metric_length_unit_reads_the_length_unit() {
|
||||
// Metric units, whatever MEASUREMENT says.
|
||||
let mut d = Drawing::new_imperial();
|
||||
d.header.set_i64("MEASUREMENT", 0);
|
||||
for u in [4, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] {
|
||||
d.header.set_i64("INSUNITS", u);
|
||||
assert!(metric_length_unit(&d), "INSUNITS {u} is metric");
|
||||
}
|
||||
// Imperial units, even with MEASUREMENT 1.
|
||||
d.header.set_i64("MEASUREMENT", 1);
|
||||
for u in [1, 2, 3, 8, 9, 10, 21, 22, 23, 24] {
|
||||
d.header.set_i64("INSUNITS", u);
|
||||
assert!(!metric_length_unit(&d), "INSUNITS {u} is imperial");
|
||||
}
|
||||
// Unitless: as MEASUREMENT says.
|
||||
for u in [0, 25] {
|
||||
d.header.set_i64("INSUNITS", u);
|
||||
d.header.set_i64("MEASUREMENT", 1);
|
||||
assert!(metric_length_unit(&d), "unitless with MEASUREMENT 1 is metric");
|
||||
d.header.set_i64("MEASUREMENT", 0);
|
||||
assert!(!metric_length_unit(&d), "unitless with MEASUREMENT 0 is imperial");
|
||||
}
|
||||
d.header.vars.remove("INSUNITS");
|
||||
d.header.vars.remove("MEASUREMENT");
|
||||
assert!(!metric_length_unit(&d), "no units at all is imperial, as before");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paper_unit_mm_still_follows_measurement() {
|
||||
let mut m = Drawing::new_metric();
|
||||
assert_eq!(paper_unit_mm(&m), 1.0);
|
||||
m.header.set_i64("MEASUREMENT", 0);
|
||||
assert_eq!(paper_unit_mm(&m), 25.4, "layouts stay on MEASUREMENT (page setups in inches fit)");
|
||||
let mut i = Drawing::new_imperial();
|
||||
assert_eq!(paper_unit_mm(&i), 25.4);
|
||||
i.header.set_i64("INSUNITS", 4);
|
||||
assert_eq!(paper_unit_mm(&i), 25.4, "a metric length unit does not move layout paper units");
|
||||
i.header.set_i64("MEASUREMENT", 1);
|
||||
assert_eq!(paper_unit_mm(&i), 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_unit_mm_reads_the_paper() {
|
||||
let page = |name: &str| PageSetup { paper: name.into(), ..PageSetup::default() };
|
||||
assert_eq!(model_unit_mm(&page("ISO A4")), 1.0);
|
||||
assert_eq!(model_unit_mm(&page("ISO A0")), 1.0);
|
||||
assert_eq!(model_unit_mm(&page("ANSI A")), 25.4);
|
||||
assert_eq!(model_unit_mm(&page("ARCH D")), 25.4);
|
||||
assert_eq!(model_unit_mm(&page("User (300.00 x 400.00 MM)")), 1.0);
|
||||
assert_eq!(model_unit_mm(&page("nope")), 1.0, "an unknown paper is a user millimetre size");
|
||||
assert_eq!(model_unit_mm(&PageSetup::default()), 25.4, "the default page is ANSI A");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_page_is_a4_for_metric_drawings() {
|
||||
let mut d = Drawing::new_metric();
|
||||
let page = model_page(&d);
|
||||
assert_eq!(page.paper, "ISO A4 (210.00 x 297.00 MM)");
|
||||
assert_eq!((page.width_mm, page.height_mm), (210.0, 297.0));
|
||||
assert_eq!(page.paper_mm, Some(true), "A4 in a metric drawing is in millimetres");
|
||||
// The length unit decides, not MEASUREMENT.
|
||||
d.header.set_i64("MEASUREMENT", 0);
|
||||
assert_eq!(model_page(&d).paper, "ISO A4 (210.00 x 297.00 MM)");
|
||||
// An imperial drawing starts on ANSI A.
|
||||
let page = model_page(&Drawing::new_imperial());
|
||||
assert_eq!(page.paper, "ANSI A (8.50 x 11.00 Inches)");
|
||||
assert!((page.width_mm - 215.9).abs() < 1e-9 && (page.height_mm - 279.4).abs() < 1e-9);
|
||||
assert_eq!(page.paper_mm, Some(false), "ANSI A in an imperial drawing is in inches");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_paper_units_follow_the_chosen_paper() {
|
||||
// The sheet decides, whatever the drawing's length unit is.
|
||||
let mut a4 = PageSetup { paper: "ISO A4 (210.00 x 297.00 MM)".into(), ..PageSetup::default() };
|
||||
apply_model_paper_units(&mut a4);
|
||||
assert_eq!(a4.paper_mm, Some(true), "ISO A4 is a millimetre sheet");
|
||||
let mut ansi = PageSetup { paper: "ANSI A (8.50 x 11.00 Inches)".into(), ..PageSetup::default() };
|
||||
apply_model_paper_units(&mut ansi);
|
||||
assert_eq!(ansi.paper_mm, Some(false), "ANSI A is an inch sheet");
|
||||
// A user size in millimetres is one to one.
|
||||
let mut user = PageSetup { paper: "User (300.00 x 400.00 MM)".into(), ..PageSetup::default() };
|
||||
apply_model_paper_units(&mut user);
|
||||
assert_eq!(user.paper_mm, Some(true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lookup_and_sheet() {
|
||||
assert_eq!(paper_size("a4").map(|p| p.width_mm), Some(210.0));
|
||||
@@ -301,23 +154,6 @@ mod tests {
|
||||
let s = Sheet::from_page(&hostile, 0.0);
|
||||
assert!(s.size.x > 0.0 && s.printable == s.bounds());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_unit_mm_honours_explicit_choice_and_falls_back_to_measurement() {
|
||||
let mut imperial = Drawing::new_imperial();
|
||||
imperial.header.set_i64("MEASUREMENT", 0);
|
||||
let mut metric = Drawing::new_metric();
|
||||
metric.header.set_i64("MEASUREMENT", 1);
|
||||
let unset = PageSetup::default();
|
||||
let mm = PageSetup { paper_mm: Some(true), ..PageSetup::default() };
|
||||
let inches = PageSetup { paper_mm: Some(false), ..PageSetup::default() };
|
||||
assert_eq!(page_unit_mm(&imperial, &unset), 25.4);
|
||||
assert_eq!(page_unit_mm(&imperial, &mm), 1.0);
|
||||
assert_eq!(page_unit_mm(&imperial, &inches), 25.4);
|
||||
assert_eq!(page_unit_mm(&metric, &unset), 1.0);
|
||||
assert_eq!(page_unit_mm(&metric, &mm), 1.0);
|
||||
assert_eq!(page_unit_mm(&metric, &inches), 25.4);
|
||||
}
|
||||
}
|
||||
|
||||
/// What a layout's saved page setup says about how to plot it, for a plot that was not given the
|
||||
|
||||
@@ -584,8 +584,7 @@ fn page_setup(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) -> Action
|
||||
let Some((_, name, page)) = layouts.iter().find(|l| l.1 == sel) else { return };
|
||||
right.label(RichText::new(format!("Page setup of {name}")).strong());
|
||||
// Layout plotting always prints the whole sheet, so only that area is offered.
|
||||
let paper_mm = cadcraft_render::paper::page_unit_mm(d, page) == 1.0;
|
||||
let rows = PageRows { areas: &["layout"], scale: true, center: true, paper_mm: Some(paper_mm) };
|
||||
let rows = PageRows { areas: &["layout"], scale: true, center: true };
|
||||
egui::Grid::new("pagesetup_grid").num_columns(2).spacing(vec2(10.0, 6.0)).show(right, |ui| {
|
||||
if let Some((k, v)) = page_rows(ui, egui::Id::unique(("pagesetup", name)), page, &rows, &choices, None) {
|
||||
action = Some(("pagesetup", json!({ "layout": name, k: v })));
|
||||
@@ -605,9 +604,6 @@ struct PageRows {
|
||||
areas: &'static [&'static str],
|
||||
scale: bool,
|
||||
center: bool,
|
||||
/// Effective paper units (`Some(true)` = millimetres, `Some(false)` = inches) for the layout's
|
||||
/// page setup, or `None` to hide the row (the Plot dialog).
|
||||
paper_mm: Option<bool>,
|
||||
}
|
||||
|
||||
/// The devices and plot style tables the page-setup rows offer.
|
||||
@@ -670,7 +666,7 @@ fn parse_ratio(t: &str) -> Option<f64> {
|
||||
/// The page-setup rows (device, paper, orientation, plot area, fit, scale, center, lineweights,
|
||||
/// transparency, plot style table) shared by the Page Setup Manager and the Plot dialog, inside a
|
||||
/// two-column grid. Returns the setting the user changed as a `pagesetup` parameter (`device`,
|
||||
/// `paper`, `landscape`, `paperUnits`, `plotArea`, `scaleToFit`, `scale`, `center`, `lineweights`,
|
||||
/// `paper`, `landscape`, `plotArea`, `scaleToFit`, `scale`, `center`, `lineweights`,
|
||||
/// `plotTransparency` or `plotStyleTable`).
|
||||
fn page_rows(
|
||||
ui: &mut egui::Ui,
|
||||
@@ -728,23 +724,6 @@ fn page_rows(
|
||||
}
|
||||
});
|
||||
ui.end_row();
|
||||
if let Some(mm) = rows.paper_mm {
|
||||
ui.label(crate::tl!("Paper units"));
|
||||
ui.horizontal(|ui| {
|
||||
// Every click records the choice, even on the selected radio: while the layout has
|
||||
// no explicit units it inherits MEASUREMENT, and clicking the value it currently
|
||||
// inherits must lock that choice against a later MEASUREMENT change (#3249).
|
||||
if ui.radio(!mm, crate::tl!("Inches")).clicked() {
|
||||
change = Some(("paperUnits", json!("inches")));
|
||||
}
|
||||
if ui.radio(mm, crate::tl!("Millimeters")).clicked() {
|
||||
change = Some(("paperUnits", json!("mm")));
|
||||
}
|
||||
})
|
||||
.response
|
||||
.on_hover_text(crate::tl!("What one paper-space unit is on this layout"));
|
||||
ui.end_row();
|
||||
}
|
||||
ui.label("Plot area");
|
||||
ui.add_enabled_ui(rows.areas.len() > 1, |ui| {
|
||||
craft_ui::ComboBox::from_id_salt(salt.with("area")).selected_text(area_label(&page.plot_area)).show_ui(ui, |ui| {
|
||||
@@ -930,7 +909,7 @@ fn plot_page(d: &cadcraft_doc::Drawing, target: &str) -> cadcraft_doc::PageSetup
|
||||
return page;
|
||||
}
|
||||
let mut page = cadcraft_doc::PageSetup { plot_area: "extents".into(), scale_to_fit: true, ..Default::default() };
|
||||
if cadcraft_render::paper::metric_length_unit(d)
|
||||
if cadcraft_render::paper::paper_unit_mm(d) == 1.0
|
||||
&& let Some(a4) = cadcraft_render::paper_size("A4")
|
||||
{
|
||||
page.paper = a4.name.into();
|
||||
@@ -1055,9 +1034,9 @@ fn plot(app: &mut CadApp, ctx: &egui::Context, open: &mut bool) -> Action {
|
||||
ui.horizontal_top(|ui| {
|
||||
egui::Grid::new("plot_grid").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
|
||||
let rows = if model {
|
||||
PageRows { areas: MODEL_AREAS, scale: true, center: false, paper_mm: None }
|
||||
PageRows { areas: MODEL_AREAS, scale: true, center: false }
|
||||
} else {
|
||||
PageRows { areas: &["layout"], scale: false, center: false, paper_mm: None }
|
||||
PageRows { areas: &["layout"], scale: false, center: false }
|
||||
};
|
||||
let placement = model.then_some((&mut st.center, &mut st.offset_mm, offset_supported));
|
||||
if let Some((k, v)) = page_rows(ui, egui::Id::unique(("plot", st.target.as_str())), &st.page, &rows, &choices, placement) {
|
||||
|
||||
@@ -27,7 +27,6 @@ mod native_menu_text_keys;
|
||||
mod native_windows;
|
||||
mod options_dialog;
|
||||
mod options_right_click;
|
||||
mod page_setup_paper_units;
|
||||
mod parameters_rename;
|
||||
mod pickdrag;
|
||||
mod properties_described;
|
||||
|
||||
@@ -1,87 +0,0 @@
|
||||
//! File ▸ Page Setup Manager: a layout's paper units can be millimetres on an inch-family sheet
|
||||
//! (an ARCH D sheet in a metric drawing, #3249), so the sheet measures 914.4 x 609.6 units.
|
||||
|
||||
use cadcraft_engine::Session;
|
||||
use cadcraft_ui_egui::{CadApp, Services};
|
||||
use egui::vec2;
|
||||
use egui_kittest::Harness;
|
||||
use egui_kittest::kittest::Queryable;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn page_setup_switches_an_arch_d_sheet_to_millimetres() {
|
||||
let mut app = CadApp::new(Session::new(), Services::default());
|
||||
app.run("units", json!({ "insunits": 4 })).unwrap();
|
||||
app.run("pagesetup", json!({ "layout": "Layout1", "paper": "ARCH D", "landscape": true })).unwrap();
|
||||
let inch = cadcraft_render::sheet(app.session.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((inch.size.x - 36.0).abs() < 1e-9, "{:?}", inch.size);
|
||||
app.start("pagesetup");
|
||||
// The dialog's existing combo boxes (device, paper, plot area, plot style) have no
|
||||
// accessible name yet; that check is not what this test is about.
|
||||
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_accessibility_check(false).build_ui_state(
|
||||
|ui, app: &mut CadApp| {
|
||||
app.logic(ui.ctx());
|
||||
app.ui(ui);
|
||||
},
|
||||
app,
|
||||
);
|
||||
h.run_steps(5);
|
||||
h.get_by_label("Millimeters").click();
|
||||
h.run_steps(5);
|
||||
let d = h.state().session.doc().unwrap();
|
||||
assert_eq!(d.layout("Layout1").unwrap().page.paper_mm, Some(true));
|
||||
let mm = cadcraft_render::sheet(d, "Layout1").unwrap();
|
||||
assert!((mm.size.x - 914.4).abs() < 1e-9 && (mm.size.y - 609.6).abs() < 1e-9, "{:?}", mm.size);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_setup_switches_a_metric_drawing_sheet_to_inches() {
|
||||
let mut app = CadApp::new(Session::new(), Services::default());
|
||||
app.run("setvar", json!({ "name": "MEASUREMENT", "value": 1 })).unwrap();
|
||||
app.run("pagesetup", json!({ "layout": "Layout1", "paper": "ARCH D", "landscape": true })).unwrap();
|
||||
let mm = cadcraft_render::sheet(app.session.doc().unwrap(), "Layout1").unwrap();
|
||||
assert!((mm.size.x - 914.4).abs() < 1e-9 && (mm.size.y - 609.6).abs() < 1e-9, "{:?}", mm.size);
|
||||
app.start("pagesetup");
|
||||
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_accessibility_check(false).build_ui_state(
|
||||
|ui, app: &mut CadApp| {
|
||||
app.logic(ui.ctx());
|
||||
app.ui(ui);
|
||||
},
|
||||
app,
|
||||
);
|
||||
h.run_steps(5);
|
||||
h.get_by_label("Inches").click();
|
||||
h.run_steps(5);
|
||||
let d = h.state().session.doc().unwrap();
|
||||
assert_eq!(d.layout("Layout1").unwrap().page.paper_mm, Some(false));
|
||||
let inch = cadcraft_render::sheet(d, "Layout1").unwrap();
|
||||
assert!((inch.size.x - 36.0).abs() < 1e-9 && (inch.size.y - 24.0).abs() < 1e-9, "{:?}", inch.size);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clicking_the_inherited_paper_units_records_the_choice() {
|
||||
// The layout starts with no explicit units and inherits MEASUREMENT 0 (inches). Clicking the
|
||||
// selected Inches radio must record that choice, so a later MEASUREMENT change cannot flip
|
||||
// the sheet to millimetres (#3249).
|
||||
let mut app = CadApp::new(Session::new(), Services::default());
|
||||
app.run("pagesetup", json!({ "layout": "Layout1", "paper": "ARCH D", "landscape": true })).unwrap();
|
||||
assert_eq!(app.session.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, None);
|
||||
app.start("pagesetup");
|
||||
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_accessibility_check(false).build_ui_state(
|
||||
|ui, app: &mut CadApp| {
|
||||
app.logic(ui.ctx());
|
||||
app.ui(ui);
|
||||
},
|
||||
app,
|
||||
);
|
||||
h.run_steps(5);
|
||||
h.get_by_label("Inches").click();
|
||||
h.run_steps(5);
|
||||
assert_eq!(h.state().session.doc().unwrap().layout("Layout1").unwrap().page.paper_mm, Some(false));
|
||||
h.state_mut().run("setvar", json!({ "name": "MEASUREMENT", "value": 1 })).unwrap();
|
||||
let d = h.state().session.doc().unwrap();
|
||||
assert_eq!(d.layout("Layout1").unwrap().page.paper_mm, Some(false));
|
||||
let inch = cadcraft_render::sheet(d, "Layout1").unwrap();
|
||||
assert_eq!(inch.unit_mm, 25.4);
|
||||
assert!((inch.size.x - 36.0).abs() < 1e-9 && (inch.size.y - 24.0).abs() < 1e-9, "{:?}", inch.size);
|
||||
}
|
||||
Reference in New Issue
Block a user