SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Web app: open a design a few features a frame, with progress and Cancel (#10275)
kaltenbrunnermarkusb7a6967ef29a
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rsindex 77bf1b8f75..d3dc965be0 100644--- a/crates/engine/src/cmd/file.rs+++ b/crates/engine/src/cmd/file.rs@@ -9,6 +9,9 @@ mod easyprint;#[path = "file_import.rs"]pub(crate) mod import;+#[path = "file_open_steps.rs"]+pub(crate) mod open_steps;+#[cfg(not(target_arch = "wasm32"))]#[path = "file_send.rs"]mod send;@@ -339,11 +342,29 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {let read_only = bool_(p, "read_only").unwrap_or(false);// Stamped before it is read: a write while it is being read is a change too.let disk = solidcraft_io::design_lock::stamp(path);+ let (doc, saved) = read_design(s, path)?;+ opened_design(s, Session::opened_at(doc, saved.as_ref(), Some(path)), path, read_only, disk)+}++/// Read the design file at `path` for `doc.open`, under its file's name if it has none of its own.+fn read_design(s: &mut Session, path: &str) -> Result<(Document, Option<solidcraft_doc::SavedModel>)> {let (mut doc, saved) = solidcraft_io::read_design_file(path, s.open_preview.take()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;if let Some(stem) = default_name_for(&doc.name, path) {doc.name = stem;}- s.replace_design(Session::opened_at(doc, saved.as_ref(), Some(path)));+ Ok((doc, saved))+}++/// `doc.open` of a design: `opened`, the design read from `path` and evaluated, takes `s`'s+/// place, and the reply says what it is.+fn opened_design(+ s: &mut Session,+ opened: Session,+ path: &str,+ read_only: bool,+ disk: Option<solidcraft_io::design_lock::FileStamp>,+) -> Result<Value> {+ s.replace_design(opened);s.disk = disk;s.read_only = read_only;let errors = s.model.results.iter().filter(|r| r.error.is_some()).count();@@ -475,7 +496,12 @@ impl Session {/// them. Absolute in-memory targets survive Save As, undo, redo and recovery unchanged.pub fn opened_at(mut doc: Document, saved: Option<&solidcraft_doc::SavedModel>, path: Option<&str>) -> Self {super::component_link::resolve_design_links(&mut doc, path);- let mut session = Self::opened(doc, saved);+ Self::opened(doc, saved).located(path)+ }++ /// This session, just opened, as the design in the file at `path`.+ pub(crate) fn located(self, path: Option<&str>) -> Self {+ let mut session = self;session.path = path.map(str::to_owned);// A design saved before body names were pinned (#6403) is pinned now, as its first// command would pin it: that command pinned them as part of itself, so undoing it went@@ -1855,6 +1881,68 @@ mod tests {std::fs::remove_dir_all(dir).unwrap();}+ /// #10198: a design opened a feature at a time ([`OpenSteps`]) is the design `doc.open`+ /// opens: the same features, results, bodies and history marker, with its file and name. Its+ /// import is offered before the step that evaluates it, and other files are left to `doc.open`.+ #[test]+ fn a_design_opened_a_feature_at_a_time_is_the_one_doc_open_opens() {+ use super::open_steps::OpenSteps;+ let dir = std::env::temp_dir().join(format!("solidcraft-open-steps-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("steps.sc").to_string_lossy().to_string();+ let step = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/step-conformance/cylinder_seam.step");+ let mut s = Session::default();+ s.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap();+ s.execute("file.insert_step", &json!({"path": step})).unwrap();+ s.execute("component.activate", &json!({"component": "root"})).unwrap();+ s.execute("solid.box", &json!({"length":5,"width":5,"height":5,"corner":[40,0,0]})).unwrap();+ s.execute("solid.box", &json!({"length":5,"width":5,"height":5,"corner":[60,0,0]})).unwrap();+ let features = s.doc.features.len();+ s.execute("timeline.rollback", &json!({"position": features - 1})).unwrap();+ s.execute("file.save", &json!({"path": path, "cache": false})).unwrap();++ let mut whole = Session::default();+ let opened = whole.execute("doc.open", &json!({"path": path, "read_only": true})).unwrap();++ let mut steps = OpenSteps::start(&json!({"path": path, "read_only": true})).unwrap().expect("a design is opened in steps");+ assert_eq!(steps.path(), path);+ assert_eq!(steps.progress(), (0, features - 1), "the saved marker is where evaluation stops");+ let mut imports = 0;+ let mut n = 0;+ while !steps.done() {+ if let Some(text) = steps.next_import() {+ assert!(text.contains("ISO-10303-21"));+ imports += 1;+ }+ steps.step();+ n += 1;+ assert_eq!(steps.progress().0, n);+ }+ assert_eq!((imports, n), (1, features - 1));+ assert!(!steps.step(), "nothing is left to evaluate");+ let mut stepped = Session::default();+ let reply = steps.finish(&mut stepped).unwrap();++ assert_eq!(reply, opened);+ assert_eq!(stepped.doc, whole.doc);+ assert_eq!(stepped.doc.marker, Some(features - 1));+ assert_eq!((stepped.path.as_deref(), stepped.read_only), (Some(path.as_str()), true));+ let summary = |s: &Session| -> Vec<(u64, bool, bool)> { s.model.results.iter().map(|r| (r.id, r.skipped, r.error.is_some())).collect() };+ assert_eq!(summary(&stepped), summary(&whole));+ let bodies =+ |s: &Session| -> Vec<(String, usize)> { s.world_state().bodies.iter().map(|b| (b.name.clone(), b.mesh().triangles.len())).collect() };+ assert_eq!(bodies(&stepped), bodies(&whole));+ assert_eq!(stepped.world_state().bodies.len(), 3, "the box, the cylinder and the box before the marker");+ assert!(stepped.model.is_current(&stepped.doc));++ // Other files, and STEP-only options, are opened by `doc.open`.+ for p in [json!({"path": step}), json!({"path": "part.stl"}), json!({"path": path, "up": "y"}), json!({})] {+ assert!(OpenSteps::start(&p).unwrap().is_none(), "{p}");+ }+ assert!(OpenSteps::start(&json!({"path": dir.join("missing.sc").to_string_lossy()})).is_err());+ std::fs::remove_dir_all(dir).unwrap();+ }+/// Every option the format registry offers is a parameter its owning command documents,/// so the registry and the commands can't drift apart.#[test]diff --git a/crates/engine/src/cmd/file_open_steps.rs b/crates/engine/src/cmd/file_open_steps.rsnew file mode 100644index 0000000000..e32665b863--- /dev/null+++ b/crates/engine/src/cmd/file_open_steps.rs@@ -0,0 +1,125 @@+//! Opening a design a feature at a time, for a caller that must keep doing other work while a+//! large design is read: the web app has one thread, which has to keep drawing frames (and offer+//! Cancel) meanwhile (#10198). [`OpenSteps::start`] reads the file, [`OpenSteps::step`] evaluates+//! the next feature of its timeline, and [`OpenSteps::finish`] puts the design in the session's+//! place as `doc.open` does. The result is the same design, evaluated the same way: each step+//! moves a copy's history marker one feature on, so the evaluation reuses every result before it.++use std::sync::Arc;++use serde_json::Value;+use solidcraft_doc::{Document, FeatureKind, Model, Visibility};++use super::{opened_design, read_design};+use crate::params::bool_;+use crate::{Result, Session};++/// A design file being opened ([`OpenSteps::start`]).+pub struct OpenSteps {+ path: String,+ read_only: bool,+ disk: Option<solidcraft_io::design_lock::FileStamp>,+ /// The design as the session will hold it, its history marker moved to `next` meanwhile.+ doc: Arc<Document>,+ /// The history marker the design was saved with.+ marker: Option<usize>,+ visibility: Visibility,+ model: Model,+ /// Features evaluated so far, and where evaluation stops (the saved marker, or the end).+ next: usize,+ stop: usize,+ /// The model came from the file and needs no evaluation.+ adopted: bool,+}++impl OpenSteps {+ /// Read the design file `doc.open` would open with parameters `p`, without evaluating it.+ /// `None` when `p` names a file `doc.open` reads in another way (a CAD, mesh or drawing file,+ /// or a point cloud), or asks for something only those take: run `doc.open` for it.+ pub fn start(p: &Value) -> Result<Option<OpenSteps>> {+ let Some(path) = p.get("path").and_then(Value::as_str) else { return Ok(None) };+ let other = solidcraft_io::is_step_path(path)+ || solidcraft_io::is_mesh_path(path)+ || solidcraft_io::is_point_cloud_path(path)+ || super::super::drawing_import_command(path).is_some()+ || ["names", "up"].iter().any(|k| p.get(k).is_some_and(|v| !v.is_null()));+ if other || path.trim().is_empty() || path.len() >= 4096 {+ return Ok(None);+ }+ let read_only = bool_(p, "read_only").unwrap_or(false);+ // Stamped before it is read, as `doc.open` does.+ let disk = solidcraft_io::design_lock::stamp(path);+ let (mut doc, saved) = read_design(&mut Session::default(), path)?;+ super::super::component_link::resolve_design_links(&mut doc, Some(path));+ // What `Session::opened` does before it evaluates.+ solidcraft_io::vfs::install_checks();+ let visibility = std::mem::take(&mut doc.visibility);+ let doc = Arc::new(doc);+ let marker = doc.marker;+ let stop = marker.unwrap_or(usize::MAX).min(doc.features.len());+ let adopted = Session::saved_model(&doc, saved.as_ref());+ let steps = OpenSteps {+ path: path.to_string(),+ read_only,+ disk,+ doc,+ marker,+ visibility,+ next: if adopted.is_some() { stop } else { 0 },+ stop,+ adopted: adopted.is_some(),+ model: adopted.unwrap_or_default(),+ };+ Ok(Some(steps))+ }++ /// The file being opened.+ pub fn path(&self) -> &str {+ &self.path+ }++ /// Features evaluated so far, and how many there are to evaluate.+ pub fn progress(&self) -> (usize, usize) {+ (self.next, self.stop)+ }++ /// Whether every feature has been evaluated ([`Self::finish`] is next).+ pub fn done(&self) -> bool {+ self.next >= self.stop+ }++ /// The STEP text the next feature imports, when it is an import that is not suppressed: a+ /// caller can read it in parts first (`kernel::StepReading`), and while it holds that+ /// reading's result the step finds the file read.+ pub fn next_import(&self) -> Option<Arc<str>> {+ let f = self.doc.features.get(self.next).filter(|_| !self.done())?;+ match &f.kind {+ FeatureKind::Import { step, .. } if !f.suppressed => Some(step.clone()),+ _ => None,+ }+ }++ /// Evaluate the next feature. False once there is none left.+ pub fn step(&mut self) -> bool {+ if self.done() {+ return false;+ }+ self.next += 1;+ Arc::make_mut(&mut self.doc).marker = Some(self.next);+ self.model.evaluate(&self.doc);+ !self.done()+ }++ /// Put the design in `s`'s place as `doc.open` does, and answer as it does. Features not+ /// yet evaluated are evaluated now.+ pub fn finish(mut self, s: &mut Session) -> Result<Value> {+ Arc::make_mut(&mut self.doc).marker = self.marker;+ if !self.adopted {+ // Every result is current: this takes them all and keeps the placement proof+ // `Session::opened` keeps.+ self.model.evaluate_shared(&self.doc);+ }+ let opened = Session::with_model(self.doc, self.visibility, self.model).located(Some(&self.path));+ opened_design(s, opened, &self.path, self.read_only, self.disk)+ }+}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex cf228ea4a3..0064bc9b55 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -42,6 +42,7 @@ pub(crate) use face::{FaceRefForm, face_ref_form};pub(crate) use features::profiles as feature_profiles;pub(crate) use features::{EdgeRefForm, PLANE_FORMS, axis_dir_form, axis_line_object, edge_ref_form, explicit_plane, plane_name_problem, sketch_key};pub use features::{auto_operation, extrude_reach, shown_scope};+pub use file::open_steps::OpenSteps;pub use join_pieces::{Addition, addition};pub use sketch::dimension_roles;pub(crate) use sketch::face::face_pick_form;diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 591677e215..4779c6a826 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -47,8 +47,8 @@ use solidcraft_geom::Vec3;pub use cmd::settings::{MAX_PROFILE_NAME, profile_name};pub use cmd::{- Addition, CommandInfo, CommandSpec, addition, auto_operation, command_specs, dimension_roles, extrude_reach, find_command, resolve_design_links,- shown_scope, standard_view,+ Addition, CommandInfo, CommandSpec, OpenSteps, addition, auto_operation, command_specs, dimension_roles, extrude_reach, find_command,+ resolve_design_links, shown_scope, standard_view,};pub use solidcraft_doc as doc;pub use solidcraft_doc::Visibility;@@ -671,14 +671,23 @@ impl Session {// The session keeps what is hidden (an undo step of its own); the design file carries it.let visibility = std::mem::take(&mut doc.visibility);let doc = Arc::new(doc);- let adopted = saved- .filter(|_| solidcraft_geom::env::var_os("NO_MODEL_CACHE").is_none())- .and_then(|saved| Model::adopt(&doc, saved).map_err(|e| log::info!("the saved model is not used: {e}")).ok());- let model = adopted.unwrap_or_else(|| {+ let model = Self::saved_model(&doc, saved).unwrap_or_else(|| {let mut model = Model::new();model.evaluate_shared(&doc);model});+ Self::with_model(doc, visibility, model)+ }++ /// The model `doc`'s file kept, when it is `doc`'s evaluation and the cache is not turned off.+ pub(crate) fn saved_model(doc: &Arc<Document>, saved: Option<&solidcraft_doc::SavedModel>) -> Option<Model> {+ saved+ .filter(|_| solidcraft_geom::env::var_os("NO_MODEL_CACHE").is_none())+ .and_then(|saved| Model::adopt(doc, saved).map_err(|e| log::info!("the saved model is not used: {e}")).ok())+ }++ /// A session on `doc` evaluated as `model`, with what it hides.+ pub(crate) fn with_model(doc: Arc<Document>, visibility: Visibility, model: Model) -> Self {Session {saved: doc.clone(),doc,diff --git a/crates/ui-egui/src/file_load.rs b/crates/ui-egui/src/file_load.rsindex b5dc74bdb3..5de4f4b0ad 100644--- a/crates/ui-egui/src/file_load.rs+++ b/crates/ui-egui/src/file_load.rs@@ -152,12 +152,19 @@ impl Drop for Running {/// drawing (and offer Cancel) while a large file comes in. The file is parsed in one frame,/// then its solids are converted a few at a time, each frame for about [`STAGED_FRAME_MS`];/// the import is then cached, and the command that inserts or opens the file finds it read.+/// A design is opened the same way, a few features a frame ([`step_opening`]).struct Staged {tx: Sender<Job>,session: Option<Session>,command: &'static str,params: Value,reading: Option<solidcraft_engine::kernel::StepReading>,+ /// A design being opened: its features evaluated so far.+ opening: Option<solidcraft_engine::OpenSteps>,+ /// The feature of that design whose imported STEP file was read last (by `reading`), and+ /// the result, held until the feature has been evaluated, which finds the file read.+ read_for: Option<usize>,+ held: Option<Arc<solidcraft_engine::kernel::StepImport>>,/// The command's result once it has run; then the bodies' meshes are made, a few a frame,/// so the first frame that draws the design doesn't make them all at once.ran: Option<Value>,@@ -175,14 +182,15 @@ const STAGED_THUMBNAIL_TRIANGLES: usize = 1_000_000;const STAGED_FRAME_MS: f64 = 30.0;/// Files read in stages: STEP (not IGES, FreeCAD or Rhino, which are first restated as STEP) to-/// insert or open.+/// insert or open, and designs to open (#10198).#[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))]fn staged_kind(request: &Request) -> bool {let p = &request.path;- matches!(request.kind, Kind::Insert | Kind::Open)+ let step = matches!(request.kind, Kind::Insert | Kind::Open)&& solidcraft_engine::io::is_step_path(p)&& !solidcraft_engine::io::is_iges_path(p)- && !solidcraft_engine::io::is_native_cad_path(p)+ && !solidcraft_engine::io::is_native_cad_path(p);+ step || (request.kind == Kind::Open && solidcraft_engine::io::is_design_path(p))}impl Running {@@ -192,6 +200,19 @@ impl Running {fn cancelled(&self) -> bool {self.progress.is_cancelled() || crate::control::chat_turn_cancelled(self.request.chat_turn.as_deref())}+ /// Features rebuilt and the timeline's length: a design opened in stages counts its own.+ fn features(&self) -> (usize, usize) {+ self.staged.as_ref().and_then(|s| s.opening.as_ref()).map_or_else(|| self.progress.features(), |o| o.progress())+ }+ /// Long work inside a feature for the card. A design opened in stages has some only while+ /// it reads a feature's STEP file: the kernel's last count stays behind once the file is+ /// read, and would hide "Rebuilding feature N of M" until the next import (#10198).+ fn work(&self) -> Option<(&'static str, usize, usize)> {+ match &self.staged {+ Some(s) if s.opening.is_some() && s.reading.is_none() => None,+ _ => self.progress.work(),+ }+ }}#[derive(Default)]@@ -217,7 +238,7 @@ impl FileLoad {}/// The running load's progress: (features rebuilt, timeline length).pub fn features(&self) -> Option<(usize, usize)> {- self.running.as_ref().map(|r| r.progress.features())+ self.running.as_ref().map(Running::features)}/// No active or queued request; cancelled import workers may still be unwinding.pub fn idle(&self) -> bool {@@ -596,7 +617,20 @@ fn start_staged(app: &mut SolveApp) {preview: None,partial_rx: None,built: None,- staged: Some(Staged { tx, session: Some(session), command, params, reading: None, ran: None, warmed: 0, triangles: 0, shown: false }),+ staged: Some(Staged {+ tx,+ session: Some(session),+ command,+ params,+ reading: None,+ opening: None,+ read_for: None,+ held: None,+ ran: None,+ warmed: 0,+ triangles: 0,+ shown: false,+ }),request,});}@@ -613,6 +647,8 @@ fn step_staged(running: &mut Running) {let _ = staged.tx.send(job);staged.session = None;staged.reading = None;+ staged.opening = None;+ staged.held = None;};if staged.session.is_none() {return;@@ -644,6 +680,18 @@ fn step_staged(running: &mut Running) {send(staged, Ok(Made { session, result, thumbnail }));return;}+ if staged.command == "doc.open" && solidcraft_engine::io::is_design_path(&path) {+ match step_opening(staged, &progress, scope, &in_budget) {+ None => {}+ Some(Ok(result)) => {+ // Next frames: the meshes ("Preparing the view").+ running.phase.store(1, Ordering::Relaxed);+ staged.ran = Some(result);+ }+ Some(Err(e)) => send(staged, Err(e)),+ }+ return;+ }let Some(reading) = staged.reading.as_mut() else {// Parse and walk the file. The reading keeps the watch: its steps report progress and// stop on Cancel.@@ -697,6 +745,60 @@ fn step_staged(running: &mut Running) {}}+/// A frame of a design opened in stages (#10198): read the file, then evaluate its features+/// for a frame's worth of time, reading the STEP file a feature imports a piece per frame first,+/// as a staged STEP import does. Once every feature is in, the design takes the scratch+/// session's place as `doc.open` would leave it, and its answer is returned; `None` until then.+fn step_opening(+ staged: &mut Staged,+ progress: &Arc<Progress>,+ scope: Option<solidcraft_engine::io::vfs::PathScope>,+ in_budget: &dyn Fn() -> bool,+) -> Option<Result<Value, String>> {+ use solidcraft_engine::doc::progress::watch;+ use solidcraft_engine::io::vfs::scoped;+ let session = staged.session.as_mut()?;+ let Some(opening) = staged.opening.as_mut() else {+ let params = staged.params.clone();+ match scoped(scope.clone(), || watch(progress.clone(), || solidcraft_engine::OpenSteps::start(¶ms))) {+ Ok(Some(opening)) => staged.opening = Some(opening),+ // Options only `doc.open` takes: it opens the file at once.+ Ok(None) => {+ return Some(scoped(scope, || watch(progress.clone(), || session.execute(staged.command, ¶ms))).map_err(|e| e.to_string()));+ }+ Err(e) => return Some(Err(e.to_string())),+ }+ return None;+ };+ while in_budget() {+ if progress.is_cancelled() {+ return Some(Err("file operation cancelled".into()));+ }+ if let Some(reading) = staged.reading.as_mut() {+ if !reading.step() {+ // A file that cannot be read fails in its feature, which says why.+ staged.held = staged.reading.take().and_then(|r| r.finish_shared().ok());+ }+ continue;+ }+ let next = opening.progress().0;+ if staged.read_for != Some(next)+ && let Some(text) = opening.next_import()+ {+ staged.read_for = Some(next);+ staged.reading = watch(progress.clone(), || solidcraft_engine::kernel::StepReading::new(&text)).ok();+ continue;+ }+ let more = scoped(scope.clone(), || watch(progress.clone(), || opening.step()));+ staged.held = None;+ if !more {+ let opening = staged.opening.take()?;+ return Some(scoped(scope, || watch(progress.clone(), || opening.finish(session))).map_err(|e| e.to_string()));+ }+ }+ None+}+/// A small picture of the bodies built so far (their display meshes, made here and kept for/// the finished model), or `None` when there is nothing to show yet, too much to draw, or the/// load ended meanwhile (`stop`).@@ -1056,10 +1158,10 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {_ => std::path::Path::new(&r.request.path).file_name().map(|p| p.to_string_lossy().to_string()).unwrap_or_default(),};let phase = r.phase.load(Ordering::Relaxed);- let (done, total) = r.progress.features();+ let (done, total) = r.features();// Long work inside one feature (a large STEP file) has progress of its own.let export = r.request.kind == Kind::ExportDxf;- let work = r.progress.work().filter(|(_, d, t)| export || (phase == 0 && d < t));+ let work = r.work().filter(|(_, d, t)| export || (phase == 0 && d < t));let screen = ctx.content_rect();// Leave the title bar to the window. The resize edges are a foreground layer above this.let cover = egui::Rect::from_min_max(egui::pos2(screen.left(), screen.top() + crate::toolbar::APP_BAR_HEIGHT), screen.max);@@ -1579,7 +1681,7 @@ mod tests {let mut app = SolveApp::new(Session::default(), Default::default());let bodies = |app: &SolveApp| app.session.world_state().bodies.len();assert!(staged_kind(&Request::new(&path, Kind::Insert)) && staged_kind(&Request::new(&path, Kind::Open)));- assert!(!staged_kind(&Request::new("part.igs", Kind::Insert)) && !staged_kind(&Request::new("part.solidcraft", Kind::Open)));+ assert!(!staged_kind(&Request::new("part.igs", Kind::Insert)) && !staged_kind(&Request::new("part.solidcraft", Kind::Insert)));app.file_load.queued.push_back(Request::new(&path, Kind::Insert));start_staged(&mut app);tick(&mut app, &ctx);@@ -1618,4 +1720,116 @@ mod tests {assert!(Arc::ptr_eq(&before, &app.session.doc));let _ = std::fs::remove_dir_all(&dir);}++ /// #10198: the web app opens a design a few features a frame, reading the STEP file a feature+ /// imports in pieces first, behind the same progress card and Cancel as a STEP file; the+ /// design that lands is the one `doc.open` opens.+ #[test]+ fn a_staged_design_open_lands_over_frames_and_cancels_between_them() {+ let dir = std::env::temp_dir().join(format!("solidcraft-staged-open-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("staged.sc").to_string_lossy().into_owned();+ let step = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/step-conformance/cylinder_seam.step");+ let mut part = Session::default();+ part.execute("solid.box", &serde_json::json!({"length": 10, "width": 10, "height": 10})).unwrap();+ part.execute("file.insert_step", &serde_json::json!({"path": step})).unwrap();+ part.execute("component.activate", &serde_json::json!({"component": "root"})).unwrap();+ part.execute("solid.box", &serde_json::json!({"length": 5, "width": 5, "height": 5, "corner": [40, 0, 0]})).unwrap();+ part.execute("file.save", &serde_json::json!({"path": path, "cache": false})).unwrap();+ let mut whole = Session::default();+ whole.execute("doc.open", &serde_json::json!({"path": path})).unwrap();+ let names = |s: &Session| s.world_state().bodies.iter().map(|b| b.name.clone()).collect::<Vec<_>>();++ let ctx = crate::fonts::test_context();+ let mut app = SolveApp::new(Session::default(), Default::default());+ assert!(staged_kind(&Request::new(&path, Kind::Open)) && !staged_kind(&Request::new(&path, Kind::Insert)));+ let opening =+ |app: &SolveApp| app.file_load.running.as_ref().and_then(|r| r.staged.as_ref()).and_then(|s| s.opening.as_ref()).map(|o| o.progress());+ app.file_load.queued.push_back(Request::new(&path, Kind::Open));+ start_staged(&mut app);+ tick(&mut app, &ctx);+ assert!(app.file_load.busy() && opening(&app).is_none(), "the first frame only shows the overlay");+ tick(&mut app, &ctx);+ let features = whole.doc.features.len();+ assert_eq!(opening(&app), Some((0, features)), "the next frame reads the file, evaluating nothing yet");+ assert_eq!(app.file_load.features(), Some((0, features)), "the card counts the design's features");+ let mut frames = 2;+ while app.file_load.running.is_some() && frames < 1000 {+ tick(&mut app, &ctx);+ frames += 1;+ }+ assert!(app.status.as_ref().is_some_and(|s| s.0.contains("Open done")), "{:?}", app.status);+ assert_eq!(app.session.path.as_deref(), Some(path.as_str()));+ assert_eq!(app.session.doc, whole.doc);+ assert_eq!(names(&app.session), names(&whole));+ assert_eq!(names(&app.session).len(), 3);++ // Cancelled after the file is read: the design before stays, and nothing waits.+ let before = app.session.doc.clone();+ app.file_load.queued.push_back(Request::new(&path, Kind::Open));+ start_staged(&mut app);+ tick(&mut app, &ctx);+ tick(&mut app, &ctx);+ app.file_load.cancel();+ tick(&mut app, &ctx);+ assert!(app.file_load.running.is_none() && !app.file_load.busy());+ assert!(Arc::ptr_eq(&before, &app.session.doc));+ // A file that isn't a design fails, and the design stays.+ let junk = dir.join("junk.sc").to_string_lossy().into_owned();+ std::fs::write(&junk, "not a design").unwrap();+ app.file_load.queued.push_back(Request::new(&junk, Kind::Open));+ start_staged(&mut app);+ for _ in 0..4 {+ tick(&mut app, &ctx);+ }+ assert!(app.file_load.running.is_none());+ assert!(app.status.as_ref().is_some_and(|s| s.2 && s.0.contains("junk.sc")), "{:?}", app.status);+ assert!(Arc::ptr_eq(&before, &app.session.doc));+ let _ = std::fs::remove_dir_all(&dir);+ }++ /// #10198: while a design opens in stages, the card shows an import's progress only while+ /// its STEP file is read, and "Rebuilding feature N of M" again once it is; the kernel's+ /// last count of that file must not stay up until the next import.+ #[test]+ fn a_staged_design_open_shows_an_import_only_while_its_file_is_read() {+ let dir = std::env::temp_dir().join(format!("solidcraft-staged-work-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let path = dir.join("staged.sc").to_string_lossy().into_owned();+ let step = concat!(env!("CARGO_MANIFEST_DIR"), "/../../tests/step-conformance/cylinder_seam.step");+ let mut part = Session::default();+ part.execute("file.insert_step", &serde_json::json!({"path": step})).unwrap();+ part.execute("component.activate", &serde_json::json!({"component": "root"})).unwrap();+ part.execute("solid.box", &serde_json::json!({"length": 5, "width": 5, "height": 5, "corner": [40, 0, 0]})).unwrap();+ part.execute("file.save", &serde_json::json!({"path": path, "cache": false})).unwrap();++ let ctx = crate::fonts::test_context();+ let mut app = SolveApp::new(Session::default(), Default::default());+ app.file_load.queued.push_back(Request::new(&path, Kind::Open));+ start_staged(&mut app);+ tick(&mut app, &ctx);+ tick(&mut app, &ctx);+ // One step of the open at a time, as if every step filled a frame.+ let (mut read, mut after_read) = (false, false);+ for _ in 0..10_000 {+ let Some(r) = app.file_load.running.as_mut() else { break };+ let Some(staged) = r.staged.as_mut() else { break };+ if staged.opening.is_none() {+ break;+ }+ let once = std::cell::Cell::new(true);+ if step_opening(staged, &r.progress, None, &|| once.replace(false)).is_some() {+ break;+ }+ let reading = r.staged.as_ref().is_some_and(|s| s.reading.is_some());+ let work = r.work();+ if reading {+ read |= work.is_some();+ } else {+ after_read |= read;+ assert_eq!(work, None, "no import's progress once its file is read");+ }+ }+ assert!(read && after_read, "the import's progress showed while its file was read, then the open went on");+ }}