* claim: #3133 * Apply complete feature transactions off the window thread Evaluate dependent history and prepare reference and GPU display caches before accepting a guarded result. Preserve the evaluated original model for safe editor cancellation and journal only accepted commands. * fix(ui): preserve original marker across sketch-to-feature edits * test(ui): verify edit-sketch cleanup and guard Unix link fixture * test(ui): fix texture disposal and unreachable assertion in feature tests * fix(build): compile CLI link inspection only on Unix
This commit is contained in:
committed by
GitHub
parent
c5e63b7871
commit
13cd45d1f1
+60
-2
@@ -1135,8 +1135,8 @@ impl ModelState {
|
||||
}
|
||||
});
|
||||
}
|
||||
/// [`ModelState::warm_meshes`], and every body's display plan at the current display quality
|
||||
/// (what a GPU viewport draws).
|
||||
|
||||
/// Prepare reference meshes and display plans at the current quality for ahead jobs.
|
||||
pub fn warm_display(&self) {
|
||||
let q = crate::display_quality::current();
|
||||
let planned = |b: &ModelBody| b.plan.get(q.index()).is_none_or(|cell| cell.get().is_some());
|
||||
@@ -1146,6 +1146,19 @@ impl ModelState {
|
||||
let _ = b.display_plan();
|
||||
});
|
||||
}
|
||||
|
||||
/// Prepare reference picking geometry and the GPU plan/highlight mesh at exactly the
|
||||
/// requested quality. The first viewport frame then consumes initialized caches only.
|
||||
pub fn warm_display_at(&self, quality: crate::display_quality::DisplayQuality, go_on: impl Fn() -> bool + Sync) {
|
||||
kernel::for_each_on_threads(&self.bodies, 16, |body| {
|
||||
if go_on() {
|
||||
let _ = body.mesh();
|
||||
}
|
||||
if go_on() {
|
||||
let _ = body.plan_mesh_at(quality);
|
||||
}
|
||||
});
|
||||
}
|
||||
pub fn sketch(&self, feature: u64) -> Option<&SolvedSketch> {
|
||||
self.sketches.iter().find(|s| s.feature == feature).map(|s| &**s)
|
||||
}
|
||||
@@ -8298,6 +8311,51 @@ pub fn world_state_reusing(doc: &Document, st: &ModelState, placed_before: &mut
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod display_preparation_tests {
|
||||
use super::*;
|
||||
|
||||
fn state() -> ModelState {
|
||||
let body = kernel::box_solid(Vec3::ZERO, Vec3::new(2.0, 3.0, 4.0)).unwrap();
|
||||
ModelState { bodies: vec![ModelBody::new("Box".into(), body, 1)], ..Default::default() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepared_display_reads_all_three_caches_without_cold_geometry_or_quality_changes() {
|
||||
use crate::display_quality::{DisplayQuality, current};
|
||||
let state = state();
|
||||
let body = &state.bodies[0];
|
||||
let quality = DisplayQuality::Fine;
|
||||
let index = quality.index();
|
||||
let current = current();
|
||||
let tolerance = body.display_tol();
|
||||
assert!(body.mesh.get().is_none() && body.plan[index].get().is_none() && body.plan_mesh[index].get().is_none());
|
||||
state.warm_display_at(quality, || true);
|
||||
// Inspect the caches before invoking any consumer that could initialize them.
|
||||
let reference = body.mesh.get().unwrap();
|
||||
let plan = body.plan[index].get().unwrap().as_ref().unwrap();
|
||||
let display = body.plan_mesh[index].get().unwrap().as_ref().unwrap();
|
||||
assert!(Arc::ptr_eq(reference, &body.mesh()));
|
||||
assert!(Arc::ptr_eq(plan, &body.display_plan_at(quality).unwrap()));
|
||||
assert!(Arc::ptr_eq(display, &body.plan_mesh_at(quality).unwrap()));
|
||||
assert_eq!(crate::display_quality::current(), current);
|
||||
assert_eq!(body.display_tol(), tolerance);
|
||||
for other in DisplayQuality::ALL.into_iter().filter(|other| *other != quality) {
|
||||
assert!(body.plan[other.index()].get().is_none() && body.plan_mesh[other.index()].get().is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelled_display_preparation_leaves_cold_caches_untouched() {
|
||||
let state = state();
|
||||
state.warm_display_at(crate::display_quality::DisplayQuality::Normal, || false);
|
||||
let body = &state.bodies[0];
|
||||
assert!(body.mesh.get().is_none());
|
||||
assert!(body.plan.iter().all(|slot| slot.get().is_none()));
|
||||
assert!(body.plan_mesh.iter().all(|slot| slot.get().is_none()));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod world_placement_cache_tests {
|
||||
use super::*;
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
//! Prepared transactions preserve live state until accepted and reject stale sources.
|
||||
use crate::Session;
|
||||
use serde_json::json;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn commands() -> Vec<(String, serde_json::Value)> {
|
||||
vec![("solid.box".into(), json!({"length":2,"width":3,"height":4}))]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn acceptance_preserves_file_history_and_prepared_world_without_evaluation() {
|
||||
let mut session = Session::default();
|
||||
session.execute("solid.box", &json!({"length":1,"width":1,"height":1})).unwrap();
|
||||
session.path = Some("working.solidcraft".into());
|
||||
let saved = session.saved.clone();
|
||||
let checkpoint = session.checkpoint();
|
||||
let history = session.undo.len();
|
||||
let prepared = session.scratch().compute_commands(&commands(), None).unwrap();
|
||||
prepared.warm_meshes(|| true);
|
||||
let world = prepared.computed.world_state();
|
||||
let before = session.evaluations;
|
||||
session.accept_commands(prepared).unwrap();
|
||||
assert_eq!(session.evaluations, before);
|
||||
assert_eq!(session.path.as_deref(), Some("working.solidcraft"));
|
||||
assert!(Arc::ptr_eq(&saved, &session.saved));
|
||||
assert_eq!(session.undo.len(), history + 1);
|
||||
assert!(Arc::ptr_eq(&world, &session.world_state()));
|
||||
session.restore_checkpoint(checkpoint).unwrap();
|
||||
assert_eq!(session.undo.len(), history);
|
||||
assert_eq!(session.doc.features.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failure_discards_the_entire_batch() {
|
||||
let session = Session::default();
|
||||
let document = session.doc.clone();
|
||||
let mut batch = commands();
|
||||
batch.push(("solid.box".into(), json!({"length":-1})));
|
||||
assert!(session.scratch().compute_commands(&batch, None).is_err());
|
||||
assert!(Arc::ptr_eq(&document, &session.doc));
|
||||
assert!(session.undo.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn revision_context_selection_and_replaced_document_reject_old_work() {
|
||||
for change in 0..5 {
|
||||
let mut session = Session::default();
|
||||
let prepared = session.scratch().compute_commands(&commands(), None).unwrap();
|
||||
match change {
|
||||
0 => session.revision += 1,
|
||||
1 => session.active_component = 17,
|
||||
2 => session.active_occurrence_path = Some(vec![1]),
|
||||
3 => session.selection.push(crate::Sel::Axis { name: "X".into() }),
|
||||
_ => session = Session::default(),
|
||||
}
|
||||
let document = session.doc.clone();
|
||||
assert!(!prepared.is_current(&session));
|
||||
assert!(session.accept_commands(prepared).is_err());
|
||||
assert!(Arc::ptr_eq(&document, &session.doc));
|
||||
assert!(session.undo.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn editor_marker_restoration_reuses_the_pinned_model_with_an_empty_cache() {
|
||||
let mut session = Session::default();
|
||||
session.execute("solid.box", &json!({"length":2,"width":3,"height":4})).unwrap();
|
||||
let world = session.world_state();
|
||||
let original = session.scratch();
|
||||
session.execute("timeline.roll_to", &json!({"position":0})).unwrap();
|
||||
let source = session.scratch();
|
||||
*session.model.cache.lock().unwrap() = Default::default();
|
||||
let prepared = session.scratch().compute_editor_commands(&[], &source, original).unwrap();
|
||||
assert_eq!(prepared.computed.evaluations, 0, "restoring the marker must never evaluate the old suffix");
|
||||
assert!(Arc::ptr_eq(&world, &prepared.computed.world_state()));
|
||||
session.accept_commands(prepared).unwrap();
|
||||
assert_eq!(session.doc.marker, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_editor_cannot_take_a_pinned_model_from_another_document() {
|
||||
let mut session = Session::default();
|
||||
session.execute("solid.box", &json!({"length":2,"width":3,"height":4})).unwrap();
|
||||
session.execute("timeline.roll_to", &json!({"position":0})).unwrap();
|
||||
let source = session.scratch();
|
||||
let document = session.doc.clone();
|
||||
assert!(session.scratch().compute_editor_commands(&[], &source, Session::default()).is_err());
|
||||
assert!(Arc::ptr_eq(&document, &session.doc));
|
||||
}
|
||||
@@ -507,18 +507,45 @@ pub(crate) fn command_begin(s: &Session, id: &str, params: &Value) {
|
||||
let ptr = std::sync::Arc::as_ptr(&s.doc) as usize;
|
||||
if ptr != j.last_doc {
|
||||
// The design changed outside commands (opened, a new tab, a dialog): what is it now?
|
||||
let base = if s.is_dirty() {
|
||||
json!("unknown")
|
||||
} else if let Some(p) = &s.path {
|
||||
json!({ "file": p })
|
||||
} else if s.doc.features.is_empty() {
|
||||
json!("new")
|
||||
} else {
|
||||
json!("unknown")
|
||||
};
|
||||
j.rebase(&journal_base(s), ptr);
|
||||
}
|
||||
j.run(id, params);
|
||||
}
|
||||
|
||||
fn journal_base(s: &Session) -> Value {
|
||||
if s.is_dirty() {
|
||||
json!("unknown")
|
||||
} else if let Some(path) = &s.path {
|
||||
json!({ "file": path })
|
||||
} else if s.doc.features.is_empty() {
|
||||
json!("new")
|
||||
} else {
|
||||
json!("unknown")
|
||||
}
|
||||
}
|
||||
|
||||
/// Record a successful isolated command only after its entire transaction is accepted.
|
||||
pub(crate) fn accepted_command(
|
||||
s: &Session,
|
||||
before: &std::sync::Arc<Document>,
|
||||
after: &std::sync::Arc<Document>,
|
||||
id: &str,
|
||||
params: &Value,
|
||||
changed: bool,
|
||||
) {
|
||||
let Some(state) = STATE.get() else { return };
|
||||
if !s.crash_journal {
|
||||
return;
|
||||
}
|
||||
let Ok(mut j) = state.journal.lock() else { return };
|
||||
let ptr = std::sync::Arc::as_ptr(before) as usize;
|
||||
if ptr != j.last_doc {
|
||||
let base = if std::sync::Arc::ptr_eq(&s.doc, before) { journal_base(s) } else { json!("unknown") };
|
||||
j.rebase(&base, ptr);
|
||||
}
|
||||
j.run(id, params);
|
||||
j.done(&Ok(()), changed);
|
||||
j.last_doc = std::sync::Arc::as_ptr(after) as usize;
|
||||
}
|
||||
|
||||
/// A top-level command ended: the journal records how, and panics caught inside it are reported
|
||||
|
||||
@@ -46,6 +46,53 @@ fn child() {
|
||||
s.execute("document.inspect", &json!({})).unwrap();
|
||||
}
|
||||
match mode.as_str() {
|
||||
"prepared" => {
|
||||
let original = s.scratch();
|
||||
s.execute("timeline.roll_to", &json!({"position":0})).unwrap();
|
||||
let source = s.scratch();
|
||||
let state = STATE.get().unwrap();
|
||||
let journal_before_error = read_live_journal(state).replay;
|
||||
let invalid = vec![(
|
||||
"timeline.redefine".into(),
|
||||
json!({"feature":1,"command":"solid.box","params":{"length":"missing_extent","width":20,"height":30}}),
|
||||
)];
|
||||
assert!(s.scratch().compute_editor_commands(&invalid, &source, original.scratch()).is_err());
|
||||
assert_eq!(read_live_journal(state).replay, journal_before_error, "failed worker work never enters recovery");
|
||||
let evaluations = s.evaluations;
|
||||
s.restore_editor(&source, original).unwrap();
|
||||
assert_eq!(s.evaluations, evaluations, "Cancel restores without evaluating");
|
||||
assert_eq!(s.doc.marker, None);
|
||||
let original = s.scratch();
|
||||
s.execute("timeline.roll_to", &json!({"position":0})).unwrap();
|
||||
let source = s.scratch();
|
||||
let commands =
|
||||
vec![("timeline.redefine".into(), json!({"feature":1,"command":"solid.box","params":{"length":12,"width":20,"height":30}}))];
|
||||
let before = read_live_journal(state).replay;
|
||||
let discarded = s.scratch().compute_editor_commands(&commands, &source, original.scratch()).unwrap();
|
||||
drop(discarded);
|
||||
assert_eq!(read_live_journal(state).replay, before, "discarded work never enters recovery");
|
||||
let prepared = s.scratch().compute_editor_commands(&commands, &source, original).unwrap();
|
||||
s.accept_commands(prepared).unwrap();
|
||||
let journal = read_live_journal(state);
|
||||
assert_eq!(journal.base, json!("new"), "accepted steps form one continuous replay");
|
||||
assert_eq!(journal.replay.len(), before.len() + 2, "restore marker and redefine are recorded once");
|
||||
let mut replay = Session::default();
|
||||
for command in &journal.replay {
|
||||
replay.execute(command["command"].as_str().unwrap(), &command["params"]).unwrap();
|
||||
}
|
||||
assert_eq!(replay.doc.marker, None);
|
||||
let volume = replay.execute("inspect.measure", &json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((volume - 7200.0).abs() < 0.001);
|
||||
let path = state.dir.join("prepared-source.solidcraft");
|
||||
s.execute("file.save_as", &json!({"path":path})).unwrap();
|
||||
// A host can adopt an opened tab before any command has rebased its journal.
|
||||
state.journal.lock().unwrap().last_doc = 0;
|
||||
let commands = vec![("solid.box".into(), json!({"length":1,"width":1,"height":1}))];
|
||||
let prepared = s.scratch().compute_commands(&commands, None).unwrap();
|
||||
s.accept_commands(prepared).unwrap();
|
||||
assert_eq!(read_live_journal(state).base, json!({"file":path}));
|
||||
println!("PREPARED_JOURNAL_OK");
|
||||
}
|
||||
"render" => {
|
||||
s.execute("render.settings.set", &json!({"name":"Studio","set":{"exposure_ev":2}})).unwrap();
|
||||
s.execute("render.settings.get", &json!({"name":"Studio"})).unwrap();
|
||||
@@ -112,6 +159,14 @@ fn run_child(dir: &Path, mode: &str) -> (String, bool) {
|
||||
(String::from_utf8_lossy(&out.stdout).into_owned(), out.status.success())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepted_prepared_commands_replay_and_discarded_work_is_not_journaled() {
|
||||
let directory = fresh_dir("prepared");
|
||||
let (output, ok) = run_child(&directory, "prepared");
|
||||
assert!(ok && output.contains("PREPARED_JOURNAL_OK"), "{output}");
|
||||
let _ = fs::remove_dir_all(directory);
|
||||
}
|
||||
|
||||
fn only_report(dir: &Path) -> (Summary, Value) {
|
||||
let all = list(dir);
|
||||
assert_eq!(all.len(), 1, "{all:?}");
|
||||
|
||||
@@ -273,6 +273,41 @@ impl WorldCache {
|
||||
}
|
||||
}
|
||||
|
||||
/// Commands evaluated in isolation, ready for an atomic handoff to their source session.
|
||||
pub struct ComputedCommands {
|
||||
source: Session,
|
||||
computed: Session,
|
||||
steps: Vec<ComputedCommand>,
|
||||
}
|
||||
|
||||
struct ComputedCommand {
|
||||
id: String,
|
||||
params: Value,
|
||||
before: Arc<Document>,
|
||||
after: Arc<Document>,
|
||||
changed: bool,
|
||||
reply: Value,
|
||||
}
|
||||
|
||||
impl ComputedCommands {
|
||||
/// Whether the source design and authoring context still match this result.
|
||||
pub fn is_current(&self, session: &Session) -> bool {
|
||||
let source = &self.source;
|
||||
session.same_document_context(source) && session.selection == source.selection
|
||||
}
|
||||
|
||||
/// Prepare display tessellation before returning the transaction to the window.
|
||||
pub fn warm_meshes(&self, keep_going: impl Fn() -> bool + Sync) {
|
||||
self.warm_display(solidcraft_doc::display_quality::DisplayQuality::Normal, keep_going);
|
||||
}
|
||||
|
||||
/// Prepare both the reference picking mesh and the GPU plan/highlight mesh at the
|
||||
/// selected quality. Warming only the reference mesh leaves cold planning on the UI.
|
||||
pub fn warm_display(&self, quality: solidcraft_doc::display_quality::DisplayQuality, keep_going: impl Fn() -> bool + Sync) {
|
||||
self.computed.world_state().warm_display_at(quality, keep_going);
|
||||
}
|
||||
}
|
||||
|
||||
/// An editing session on one design.
|
||||
pub struct Session {
|
||||
pub doc: Arc<Document>,
|
||||
@@ -1267,6 +1302,112 @@ impl Session {
|
||||
}
|
||||
}
|
||||
|
||||
/// Evaluate a feature dialog's complete transaction, including the dependent timeline.
|
||||
/// `marker` restores an editor's original marker before recording its undo snapshot.
|
||||
/// The source remains untouched, including its history and recovery journal.
|
||||
pub fn compute_commands(self, commands: &[(String, Value)], marker: Option<Option<usize>>) -> Result<ComputedCommands> {
|
||||
self.compute_commands_inner(commands, marker, None)
|
||||
}
|
||||
|
||||
/// Start an edit from its pinned original model, so restoring the original marker cannot
|
||||
/// recompute the obsolete suffix even when previews have evicted its evaluation cache.
|
||||
pub fn compute_editor_commands(self, commands: &[(String, Value)], source: &Session, original: Session) -> Result<ComputedCommands> {
|
||||
if !self.same_document_context(source) {
|
||||
return Err(EngineError::Other("the design changed while the feature editor was open".into()));
|
||||
}
|
||||
let mut expected = (*original.doc).clone();
|
||||
expected.marker = source.doc.marker;
|
||||
if expected != *source.doc {
|
||||
return Err(EngineError::Other("the original editor model does not match its source design".into()));
|
||||
}
|
||||
self.compute_commands_inner(commands, Some(original.doc.marker), Some(original))
|
||||
}
|
||||
|
||||
fn compute_commands_inner(
|
||||
self,
|
||||
commands: &[(String, Value)],
|
||||
marker: Option<Option<usize>>,
|
||||
original: Option<Session>,
|
||||
) -> Result<ComputedCommands> {
|
||||
let mut computed = self.scratch();
|
||||
let mut steps = Vec::new();
|
||||
if let Some(marker) = marker {
|
||||
let before = computed.doc.clone();
|
||||
let params = marker.map(|position| serde_json::json!({"position":position})).unwrap_or_else(|| serde_json::json!({}));
|
||||
let reply = if let Some(original) = original {
|
||||
computed.doc = original.doc;
|
||||
computed.model = original.model;
|
||||
computed.world_cache = original.world_cache;
|
||||
serde_json::json!({"marker":marker.unwrap_or(computed.doc.features.len()),"features":computed.doc.features.len()})
|
||||
} else {
|
||||
let undo = std::mem::take(&mut computed.undo);
|
||||
let redo = std::mem::take(&mut computed.redo);
|
||||
let selection = computed.selection.clone();
|
||||
let reply = computed.execute("timeline.roll_to", ¶ms)?;
|
||||
computed.undo = undo;
|
||||
computed.redo = redo;
|
||||
computed.selection = selection;
|
||||
reply
|
||||
};
|
||||
let changed = !Arc::ptr_eq(&before, &computed.doc);
|
||||
steps.push(ComputedCommand { id: "timeline.roll_to".into(), params, before, after: computed.doc.clone(), changed, reply });
|
||||
}
|
||||
for (id, params) in commands {
|
||||
let before = computed.doc.clone();
|
||||
let active_sketch = computed.active_sketch;
|
||||
let pending_moves = computed.pending_moves.clone();
|
||||
let reply = computed.execute(id, params)?;
|
||||
let changed = !Arc::ptr_eq(&before, &computed.doc)
|
||||
|| active_sketch != computed.active_sketch
|
||||
|| pending_moves != computed.pending_moves
|
||||
|| id.starts_with("select.");
|
||||
steps.push(ComputedCommand { id: id.clone(), params: params.clone(), before, after: computed.doc.clone(), changed, reply });
|
||||
}
|
||||
Ok(ComputedCommands { source: self, computed, steps })
|
||||
}
|
||||
|
||||
/// Adopt evaluated commands only if their document and authoring context are still current.
|
||||
/// No model evaluation occurs here. Rejected or cancelled work never enters the journal.
|
||||
pub fn accept_commands(&mut self, prepared: ComputedCommands) -> Result<Vec<(String, Value)>> {
|
||||
if !prepared.is_current(self) {
|
||||
return Err(EngineError::Other("the design changed while the feature was computing".into()));
|
||||
}
|
||||
for step in &prepared.steps {
|
||||
crash::accepted_command(self, &step.before, &step.after, &step.id, &step.params, step.changed);
|
||||
}
|
||||
let replies = prepared.steps.into_iter().map(|step| (step.id, step.reply)).collect();
|
||||
self.accept_computed(prepared.computed);
|
||||
Ok(replies)
|
||||
}
|
||||
|
||||
fn same_document_context(&self, source: &Session) -> bool {
|
||||
Arc::ptr_eq(&self.doc, &source.doc)
|
||||
&& self.revision == source.revision
|
||||
&& self.active_sketch == source.active_sketch
|
||||
&& self.active_component == source.active_component
|
||||
&& self.active_occurrence_path == source.active_occurrence_path
|
||||
&& self.pending_moves == source.pending_moves
|
||||
}
|
||||
|
||||
/// Cancel an unchanged feature editor by restoring its original evaluated model, even
|
||||
/// after preview work has evicted the old suffix from the shared evaluation cache.
|
||||
pub fn restore_editor(&mut self, source: &Session, mut original: Session) -> Result<()> {
|
||||
if !self.same_document_context(source) {
|
||||
return Err(EngineError::Other("the design changed while the feature editor was open; its current timeline was preserved".into()));
|
||||
}
|
||||
let params = original.doc.marker.map(|position| serde_json::json!({"position":position})).unwrap_or_else(|| serde_json::json!({}));
|
||||
crash::accepted_command(self, &self.doc, &original.doc, "timeline.roll_to", ¶ms, !Arc::ptr_eq(&self.doc, &original.doc));
|
||||
let undo = std::mem::take(&mut self.undo);
|
||||
let redo = std::mem::take(&mut self.redo);
|
||||
let selection = std::mem::take(&mut self.selection);
|
||||
original.visibility.hidden_joints.clear();
|
||||
self.accept_computed(original);
|
||||
self.undo = undo;
|
||||
self.redo = redo;
|
||||
self.selection = selection;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Refresh UI caches when adopting a session or switching tabs, without discarding its
|
||||
/// already prepared world-space geometry. This does not change the document.
|
||||
pub fn invalidate_view(&mut self, previous_revision: u64) {
|
||||
@@ -1467,6 +1608,8 @@ impl Session {
|
||||
#[cfg(test)]
|
||||
mod boolean_regression_tests;
|
||||
#[cfg(test)]
|
||||
mod computed_commands_tests;
|
||||
#[cfg(test)]
|
||||
mod construct_tests;
|
||||
#[cfg(test)]
|
||||
mod delete_face_tests;
|
||||
|
||||
@@ -39,45 +39,114 @@ fn until_applied(h: &mut Harness) {
|
||||
h.frames(1);
|
||||
}
|
||||
|
||||
/// An evaluated result held behind a channel, so widget assertions do not race the worker.
|
||||
fn hold_result(h: &mut Harness, different_commands: bool) -> std::sync::mpsc::Sender<Result<solidcraft_engine::ComputedCommands, String>> {
|
||||
let cmds = crate::dialogs::apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();
|
||||
let (finish, done) = std::sync::mpsc::channel();
|
||||
h.app.applying = Some(crate::dialogs::Applying {
|
||||
done,
|
||||
ready: None,
|
||||
seen: true,
|
||||
started: crate::now_ms(),
|
||||
cmds: if different_commands { Vec::new() } else { cmds },
|
||||
progress: Default::default(),
|
||||
quality: Default::default(),
|
||||
});
|
||||
finish
|
||||
}
|
||||
|
||||
fn result(h: &Harness) -> Result<solidcraft_engine::ComputedCommands, String> {
|
||||
let dialog = h.app.dialog.as_ref().unwrap();
|
||||
let commands = crate::dialogs::apply_commands(&h.app, dialog).unwrap();
|
||||
match &h.app.editing_state {
|
||||
Some(state) => h.app.session.scratch().compute_editor_commands(&commands, &state.source, state.original.scratch()),
|
||||
None => h.app.session.scratch().compute_commands(&commands, dialog.editing.map(|(_, marker)| marker)),
|
||||
}
|
||||
.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ok_computes_off_the_window_thread_saying_so_then_applies() {
|
||||
let mut h = square_on_a_block();
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
// The evaluation is held until the dialog has been seen saying so (it is in the cache all
|
||||
// the same), so no frame can apply it before the checks below.
|
||||
let (finish, gate) = std::sync::mpsc::channel();
|
||||
h.app.apply_gate = Some(std::sync::Arc::new(std::sync::Mutex::new(gate)));
|
||||
h.step(&json!({"key": "Enter"})).unwrap();
|
||||
assert!(h.app.applying.is_some() && h.app.dialog.is_some(), "computing, the dialog open");
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.frames(1);
|
||||
assert!(h.widget("Computing… 0 s").is_some(), "the dialog says it computes");
|
||||
// Enter again does not start it twice.
|
||||
assert!(h.widget("Computing\u{2026} 0 s").is_some(), "the dialog says it computes");
|
||||
h.step(&json!({"key": "Enter"})).unwrap();
|
||||
finish.send(()).unwrap();
|
||||
until_applied(&mut h);
|
||||
assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog.as_ref().and_then(|d| d.error.clone()));
|
||||
finish.send(prepared).ok().unwrap();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || until_applied(&mut h));
|
||||
assert_eq!(window.features(), (0, 0), "adoption does not evaluate the model");
|
||||
assert!(h.app.dialog.is_none());
|
||||
h.step(&json!({"expect": {"bodies": 1, "volume": 13000}})).unwrap();
|
||||
assert_eq!(h.app.session.doc.features.len(), 4, "one extrude added");
|
||||
assert_eq!(h.app.session.doc.features.len(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancel_while_computing_applies_nothing() {
|
||||
let mut h = square_on_a_block();
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
// Held, as the preview's evaluation is in the cache and would otherwise be in before OK's
|
||||
// wait is over, applying at once.
|
||||
let (finish, gate) = std::sync::mpsc::channel();
|
||||
h.app.apply_gate = Some(std::sync::Arc::new(std::sync::Mutex::new(gate)));
|
||||
let prepared = result(&h);
|
||||
let features = h.app.session.doc.features.len();
|
||||
h.step(&json!({"key": "Enter"})).unwrap();
|
||||
assert!(h.app.applying.is_some());
|
||||
let finish = hold_result(&mut h, false);
|
||||
let progress = h.app.applying.as_ref().unwrap().progress.clone();
|
||||
h.step(&json!({"key": "Escape"})).unwrap();
|
||||
assert!(h.app.applying.is_none() && h.app.dialog.is_none());
|
||||
finish.send(()).unwrap();
|
||||
assert!(progress.is_cancelled());
|
||||
assert!(finish.send(prepared).is_err());
|
||||
h.frames(5);
|
||||
assert_eq!(h.app.session.doc.features.len(), features);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ready_transaction_waits_one_frame_before_adoption() {
|
||||
let mut h = square_on_a_block();
|
||||
let features = h.app.session.doc.features.len();
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.app.applying.as_mut().unwrap().seen = false;
|
||||
finish.send(prepared).ok().unwrap();
|
||||
h.frames(1);
|
||||
assert_eq!(h.app.session.doc.features.len(), features);
|
||||
assert!(h.app.applying.is_some());
|
||||
until_applied(&mut h);
|
||||
assert_eq!(h.app.session.doc.features.len(), features + 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restarting_the_same_command_discards_the_previous_dialog_job() {
|
||||
let mut h = square_on_a_block();
|
||||
let document = h.app.session.doc.clone();
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
let progress = h.app.applying.as_ref().unwrap().progress.clone();
|
||||
h.app.start("solid.extrude");
|
||||
assert!(h.app.applying.is_none());
|
||||
assert!(h.app.dialog.is_some());
|
||||
assert!(progress.is_cancelled());
|
||||
assert!(finish.send(prepared).is_err());
|
||||
h.frames(2);
|
||||
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_tabs_cancels_the_transaction_without_changing_either_document() {
|
||||
let mut h = square_on_a_block();
|
||||
let original = h.app.session.doc.clone();
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
let progress = h.app.applying.as_ref().unwrap().progress.clone();
|
||||
let other = solidcraft_engine::Session::default();
|
||||
let other_doc = other.doc.clone();
|
||||
crate::documents::open_tab(&mut h.app, other).unwrap();
|
||||
assert!(progress.is_cancelled());
|
||||
assert!(finish.send(prepared).is_err());
|
||||
assert!(h.app.applying.is_none() && h.app.dialog.is_none() && h.app.editing_state.is_none());
|
||||
h.frames(2);
|
||||
assert!(std::sync::Arc::ptr_eq(&other_doc, &h.app.session.doc));
|
||||
crate::documents::switch(&mut h.app, 0);
|
||||
assert!(std::sync::Arc::ptr_eq(&original, &h.app.session.doc));
|
||||
}
|
||||
|
||||
/// #2929: the feature must not appear in the frame OK starts computing in. The window thread
|
||||
/// can be held up between starting the evaluation and the check that takes it up, and the
|
||||
/// feature then appears where the dialog says it is computing - which is what made
|
||||
@@ -104,38 +173,258 @@ fn the_dialog_holds_its_inputs_while_ok_computes() {
|
||||
let mut h = square_on_a_block();
|
||||
h.app.fit_view();
|
||||
h.frames(2);
|
||||
let picked = h.app.dialog.as_ref().map(|d| d.inputs[0].items.clone()).unwrap();
|
||||
// OK computing, until the test lets it finish.
|
||||
let (finish, done) = std::sync::mpsc::channel();
|
||||
let cmds = h.app.dialog.as_ref().and_then(|d| crate::dialogs::apply_commands(&h.app, d).ok()).unwrap();
|
||||
h.app.applying = Some(crate::dialogs::Applying::computing(done, cmds));
|
||||
// A click on the square picked would take it out of the profiles.
|
||||
let picked = h.app.dialog.as_ref().unwrap().inputs[0].items.clone();
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.step(&json!({"click": {"world": [10, 10, 10]}})).unwrap();
|
||||
h.frames(2);
|
||||
assert_eq!(h.app.dialog.as_ref().map(|d| d.inputs[0].items.clone()), Some(picked), "no pick while computing");
|
||||
finish.send(None).unwrap();
|
||||
assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].items, picked);
|
||||
finish.send(prepared).ok().unwrap();
|
||||
until_applied(&mut h);
|
||||
assert!(h.app.dialog.is_none());
|
||||
h.step(&json!({"expect": {"bodies": 1, "volume": 13000}})).unwrap();
|
||||
}
|
||||
|
||||
/// Inputs that changed while OK computed (nothing should change them) are computed in turn, off
|
||||
/// the window thread too, then applied: run as OK finished, they would hold the window for the
|
||||
/// whole boolean.
|
||||
#[test]
|
||||
fn inputs_changed_while_ok_computes_are_computed_off_the_thread_too() {
|
||||
let mut h = square_on_a_block();
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
let features = h.app.session.doc.features.len();
|
||||
// OK computing other commands than the dialog's, until the test lets it finish.
|
||||
let (finish, done) = std::sync::mpsc::channel();
|
||||
h.app.applying = Some(crate::dialogs::Applying::computing(done, Vec::new()));
|
||||
finish.send(None).unwrap();
|
||||
h.frames(1);
|
||||
assert!(h.app.applying.is_some(), "the dialog's own commands are computing");
|
||||
assert_eq!(h.app.session.doc.features.len(), features, "nothing applied on the window thread");
|
||||
until_applied(&mut h);
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, true);
|
||||
finish.send(prepared).ok().unwrap();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || until_applied(&mut h));
|
||||
assert_eq!(window.features(), (0, 0));
|
||||
assert!(h.app.dialog.is_none());
|
||||
assert_eq!(h.app.session.doc.features.len(), features + 1);
|
||||
h.step(&json!({"expect": {"bodies": 1, "volume": 13000}})).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_document_rejects_a_completed_result() {
|
||||
let mut h = square_on_a_block();
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.app.run("solid.box", json!({"length":2,"width":2,"height":2})).unwrap();
|
||||
let current = h.app.session.doc.clone();
|
||||
finish.send(prepared).ok().unwrap();
|
||||
until_applied(&mut h);
|
||||
assert!(std::sync::Arc::ptr_eq(¤t, &h.app.session.doc));
|
||||
assert!(h.app.dialog.as_ref().unwrap().error.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hole_ok_adopts_real_cut_without_window_evaluation() {
|
||||
let mut h = Harness::new();
|
||||
h.app.home.open = false;
|
||||
h.app.set_origin_shown(false);
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
h.app.run("solid.box", json!({"length":40,"width":30,"height":20})).unwrap();
|
||||
h.call("ui.view", json!({"view":"top"}));
|
||||
h.app.fit_view();
|
||||
h.settle();
|
||||
let undo = h.app.session.undo.len();
|
||||
h.step(&json!({"start":"solid.hole"})).unwrap();
|
||||
h.step(&json!({"click":{"world":[12,9,20]}})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:Diameter"}})).unwrap();
|
||||
h.step(&json!({"key":"A","cmd":true})).unwrap();
|
||||
h.step(&json!({"text":"4 mm"})).unwrap();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || {
|
||||
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
|
||||
until_applied(&mut h);
|
||||
});
|
||||
assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog.as_ref().and_then(|d| d.error.clone()));
|
||||
assert_eq!(window.features(), (0, 0));
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1);
|
||||
let volume = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!(volume < 23990.0 && volume > 23000.0, "the hole removed actual material: {volume}");
|
||||
h.app.run("edit.undo", json!({})).unwrap();
|
||||
h.step(&json!({"expect":{"volume":24000,"bodies":1}})).unwrap();
|
||||
}
|
||||
|
||||
fn cut_chain() -> (Harness, u64) {
|
||||
let mut h = Harness::new();
|
||||
h.app.home.open = false;
|
||||
h.app.apply_off_thread = Some(std::time::Duration::ZERO);
|
||||
h.app.run("solid.box", json!({"length":80,"width":50,"height":20,"body_name":"Stock"})).unwrap();
|
||||
let mut target = 0;
|
||||
for index in 0..6 {
|
||||
let sketch = format!("Circle{}", index + 1);
|
||||
h.app.run("sketch.create", json!({"plane":"XY","offset":20,"name":sketch})).unwrap();
|
||||
h.app.run("sketch.circle.center", json!({"center":[10 + 10 * index,25],"diameter":4})).unwrap();
|
||||
h.app.run("sketch.finish", json!({})).unwrap();
|
||||
let result = h
|
||||
.app
|
||||
.run(
|
||||
"solid.extrude",
|
||||
json!({"sketch":sketch,"profiles":"all","distance":6,"direction":"negative","operation":"cut","name":format!("Cut{}", index+1)}),
|
||||
)
|
||||
.unwrap();
|
||||
if index == 0 {
|
||||
target = result["feature"].as_u64().unwrap();
|
||||
}
|
||||
}
|
||||
(h, target)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_first_cut_adopts_its_entire_suffix_without_window_evaluation() {
|
||||
let (mut h, target) = cut_chain();
|
||||
let before = h.app.run("inspect.measure", json!({})).unwrap();
|
||||
let undo = h.app.session.undo.len();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
h.frames(3);
|
||||
assert!(h.app.session.feature_edit_sketch.is_some(), "the edited Extrude keeps its input sketch visible");
|
||||
h.step(&json!({"click":{"handle":"dialog:Distance"}})).unwrap();
|
||||
h.step(&json!({"key":"A","cmd":true})).unwrap();
|
||||
h.step(&json!({"text":"9 mm"})).unwrap();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || {
|
||||
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
|
||||
for _ in 0..5000 {
|
||||
h.frames(1);
|
||||
if h.app.dialog.is_none() {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(1));
|
||||
}
|
||||
});
|
||||
assert_eq!(window.features(), (0, 0), "the complete changed suffix is adopted without UI evaluation");
|
||||
assert!(h.app.dialog.is_none(), "changed edit did not complete");
|
||||
assert_eq!(h.app.session.feature_edit_sketch, None, "Apply clears the temporary sketch override");
|
||||
let after = h.app.run("inspect.measure", json!({})).unwrap();
|
||||
let before_volume = before["total"]["volume_mm3"].as_f64().unwrap();
|
||||
let after_volume = after["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!(before_volume - after_volume > 30.0, "the edit must change actual geometry: {before_volume} -> {after_volume}");
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1);
|
||||
assert_eq!(h.app.session.doc.marker, None);
|
||||
h.app.run("edit.undo", json!({})).unwrap();
|
||||
let restored = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((restored - before_volume).abs() < 0.001);
|
||||
h.app.run("edit.redo", json!({})).unwrap();
|
||||
let redone = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((redone - after_volume).abs() < 0.001);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelling_an_edit_restores_pinned_geometry_without_evaluating_an_evicted_suffix() {
|
||||
let (mut h, target) = cut_chain();
|
||||
h.app.run("solid.box", json!({"corner":[100,0,0],"length":2,"width":2,"height":2})).unwrap();
|
||||
h.app.run("edit.undo", json!({})).unwrap();
|
||||
let before = h.app.session.world_state();
|
||||
let history = (h.app.session.undo.len(), h.app.session.redo.len());
|
||||
let visibility = h.app.session.visibility.clone();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
crate::dialogs::sync_feature_edit_sketch(&mut h.app);
|
||||
let sketch = h.app.session.feature_edit_sketch.expect("edited Extrude exposes its sketch");
|
||||
assert!(solidcraft_engine::view::sketch_shown(&h.app.session, sketch));
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
*h.app.session.model.cache.lock().unwrap() = Default::default();
|
||||
// Picks are view state: cancellation keeps a newer selection.
|
||||
h.app.session.selection = vec![solidcraft_engine::Sel::Axis { name: "X".into() }];
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || {
|
||||
h.step(&json!({"key":"Escape"})).unwrap();
|
||||
});
|
||||
assert_eq!(window.features(), (0, 0), "Cancel never rebuilds the old suffix on the window thread");
|
||||
assert!(h.app.dialog.is_none() && h.app.applying.is_none() && h.app.editing_state.is_none());
|
||||
assert!(finish.send(prepared).is_err());
|
||||
assert_eq!(h.app.session.feature_edit_sketch, None, "Cancel clears the temporary sketch override");
|
||||
assert_eq!(h.app.session.visibility, visibility, "temporary sketch display does not change stored visibility");
|
||||
assert_eq!(h.app.session.doc.marker, None);
|
||||
assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
|
||||
assert!(std::sync::Arc::ptr_eq(&before, &h.app.session.world_state()));
|
||||
assert_eq!(h.app.session.selection, vec![solidcraft_engine::Sel::Axis { name: "X".into() }]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replacing_a_document_discards_pending_apply_and_editor_backup() {
|
||||
let (mut h, target) = cut_chain();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.app.run("file.new", json!({})).unwrap();
|
||||
assert!(h.app.dialog.is_none() && h.app.applying.is_none() && h.app.editing_state.is_none());
|
||||
assert!(finish.send(prepared).is_err());
|
||||
h.frames(3);
|
||||
assert!(h.app.session.doc.features.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancelling_a_stale_editor_preserves_the_newer_document() {
|
||||
let (mut h, target) = cut_chain();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
h.app.session.execute("solid.box", &json!({"length":2,"width":2,"height":2})).unwrap();
|
||||
let document = h.app.session.doc.clone();
|
||||
h.step(&json!({"key":"Escape"})).unwrap();
|
||||
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
assert!(h.app.dialog.is_none());
|
||||
assert!(h.app.status.as_ref().is_some_and(|(_, _, error)| *error));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_worker_error_then_cancel_preserves_original_world_history_redo_and_selection() {
|
||||
let (mut h, target) = cut_chain();
|
||||
h.app.run("solid.box", json!({"corner":[100,0,0],"length":2,"width":2,"height":2})).unwrap();
|
||||
h.app.run("edit.undo", json!({})).unwrap();
|
||||
let world = h.app.session.world_state();
|
||||
let document = h.app.session.doc.clone();
|
||||
let history = (h.app.session.undo.len(), h.app.session.redo.len());
|
||||
h.app.session.selection = vec![solidcraft_engine::Sel::Feature { id: target }];
|
||||
let selection = h.app.session.selection.clone();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
let prefix = h.app.session.doc.clone();
|
||||
let dialog = h.app.dialog.as_mut().unwrap();
|
||||
if let crate::dialogs::Kind::Extrude { distance, .. } = &mut dialog.kind {
|
||||
*distance = "missing_extent".into();
|
||||
}
|
||||
let dialog = dialog.clone();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || {
|
||||
// Exercise the production worker directly: a preview may disable the OK widget
|
||||
// for this deliberately invalid expression before a synthetic click reaches it.
|
||||
h.app.applying = crate::dialogs::begin_applying(&h.app, &dialog);
|
||||
assert!(h.app.applying.is_some(), "the real apply worker was started");
|
||||
until_applied(&mut h);
|
||||
assert!(h.app.dialog.as_ref().and_then(|d| d.error.as_ref()).is_some_and(|error| error.contains("missing_extent")), "{:?}", h.app.dialog);
|
||||
assert!(std::sync::Arc::ptr_eq(&prefix, &h.app.session.doc), "worker failure leaves the live prefix untouched");
|
||||
h.step(&json!({"key":"Escape"})).unwrap();
|
||||
});
|
||||
assert_eq!(window.features(), (0, 0));
|
||||
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
assert!(std::sync::Arc::ptr_eq(&world, &h.app.session.world_state()));
|
||||
assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
|
||||
assert_eq!(h.app.session.selection, selection);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn another_interactive_command_closes_the_editor_without_rebuilding_its_old_suffix() {
|
||||
let (mut h, target) = cut_chain();
|
||||
let document = h.app.session.doc.clone();
|
||||
h.call("ui.editFeature", json!({"feature":target}));
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || h.app.start("solid.hole"));
|
||||
assert_eq!(window.features(), (0, 0));
|
||||
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
assert!(h.app.editing_state.is_none());
|
||||
assert!(h.app.dialog.as_ref().is_some_and(|d| d.editing.is_none() && matches!(d.kind, crate::dialogs::Kind::Hole { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_changed_display_quality_warms_the_result_without_replaying_commands() {
|
||||
let mut h = square_on_a_block();
|
||||
h.app.apply_off_thread = Some(Duration::ZERO);
|
||||
let prepared = result(&h);
|
||||
let finish = hold_result(&mut h, false);
|
||||
h.app.preferences.display_quality = "fine".into();
|
||||
finish.send(prepared).ok().unwrap();
|
||||
h.frames(1);
|
||||
let progress = h.app.applying.as_ref().expect("the new display plans run off the window thread").progress.clone();
|
||||
until_applied(&mut h);
|
||||
assert_eq!(progress.features(), (0, 0), "changing display quality does not replay the geometry commands");
|
||||
assert!(h.app.dialog.is_none());
|
||||
h.step(&json!({"expect":{"bodies":1,"volume":13000}})).unwrap();
|
||||
}
|
||||
|
||||
@@ -159,6 +159,7 @@ mod tests {
|
||||
// `link_in` only makes links on Unix, and the test makes its own with `std::os::unix`.
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn links_only_where_it_may() {
|
||||
let d = std::env::temp_dir().join(format!("solidcraft-cli-link-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
|
||||
@@ -155,7 +155,11 @@ impl SolveApp {
|
||||
/// Since when a command, or a delete's check, has been computing off the window thread (ms),
|
||||
/// if one is.
|
||||
pub fn computing_since(&self) -> Option<f64> {
|
||||
let started = [self.deferred.as_ref().map(|d| d.started), self.delete_check.as_ref().map(|c| c.started)];
|
||||
let started = [
|
||||
self.deferred.as_ref().map(|d| d.started),
|
||||
self.delete_check.as_ref().map(|c| c.started),
|
||||
self.pending_feature_edit.as_ref().map(|edit| edit.started),
|
||||
];
|
||||
started.into_iter().flatten().reduce(f64::min)
|
||||
}
|
||||
|
||||
|
||||
+207
-98
@@ -480,111 +480,170 @@ struct ShellChain {
|
||||
faces: Vec<Sel>,
|
||||
}
|
||||
|
||||
/// OK computing off the window thread: the dialog's commands evaluated on a copy of the
|
||||
/// session. Once that is in, OK runs them for real, taking what the copy evaluated
|
||||
/// ([`solidcraft_engine::Session::prime`]) rather than computing it again; meanwhile the window
|
||||
/// stays live and the dialog says it is computing.
|
||||
/// Pin the pre-edit model so Cancel never depends on the shared cache retaining it.
|
||||
pub(crate) struct EditingState {
|
||||
pub(crate) source: Session,
|
||||
pub(crate) original: Session,
|
||||
}
|
||||
|
||||
struct DialogComputation {
|
||||
session: Session,
|
||||
cmds: Vec<(String, Value)>,
|
||||
marker: Option<Option<usize>>,
|
||||
editing: Option<EditingState>,
|
||||
}
|
||||
|
||||
impl DialogComputation {
|
||||
fn new(app: &SolveApp, d: &Dialog) -> Result<Self, String> {
|
||||
if app.file_load.busy() || app.file_picker_busy() {
|
||||
return Err("a file operation is in progress".into());
|
||||
}
|
||||
Ok(Self {
|
||||
session: app.session.scratch(),
|
||||
cmds: apply_commands(app, d)?,
|
||||
marker: d.editing.map(|(_, marker)| marker),
|
||||
editing: d
|
||||
.editing
|
||||
.and(app.editing_state.as_ref())
|
||||
.map(|state| EditingState { source: state.source.scratch(), original: state.original.scratch() }),
|
||||
})
|
||||
}
|
||||
|
||||
fn compute(self) -> Result<solidcraft_engine::ComputedCommands, String> {
|
||||
match self.editing {
|
||||
Some(state) => self.session.compute_editor_commands(&self.cmds, &state.source, state.original),
|
||||
None => self.session.compute_commands(&self.cmds, self.marker),
|
||||
}
|
||||
.map_err(|e| e.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
fn adopt_dialog(app: &mut SolveApp, prepared: solidcraft_engine::ComputedCommands) -> Result<(), String> {
|
||||
if app.file_load.busy() || app.file_picker_busy() {
|
||||
return Err("a file operation is in progress".into());
|
||||
}
|
||||
let replies = app.session.accept_commands(prepared).map_err(|e| e.to_string())?;
|
||||
app.big_operation = true;
|
||||
for (id, reply) in replies {
|
||||
let stop = (id == "joint.drive").then(|| crate::dialogs_assembly::drive_stop(&reply)).flatten();
|
||||
app.command_completed(&id, Ok(reply))?;
|
||||
if let Some(why) = stop {
|
||||
app.set_status(why, false);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A complete feature transaction, evaluated without changing the displayed session.
|
||||
pub struct Applying {
|
||||
pub(crate) done: std::sync::mpsc::Receiver<Option<solidcraft_engine::Evaluated>>,
|
||||
/// What it evaluated, once in (`Some(None)`: it failed, or its worker is gone).
|
||||
evaluated: Option<Option<solidcraft_engine::Evaluated>>,
|
||||
pub(crate) done: std::sync::mpsc::Receiver<Result<solidcraft_engine::ComputedCommands, String>>,
|
||||
pub(crate) ready: Option<Result<solidcraft_engine::ComputedCommands, String>>,
|
||||
pub(crate) seen: bool,
|
||||
/// When OK was pressed (ms).
|
||||
pub(crate) started: f64,
|
||||
/// The commands being computed.
|
||||
pub(crate) cmds: Vec<(String, Value)>,
|
||||
/// The job has been in a frame. A job that has just started is not taken up in the frame it
|
||||
/// starts, so the dialog says it is computing before the feature appears.
|
||||
pub(crate) seen: bool,
|
||||
pub(crate) progress: std::sync::Arc<solidcraft_engine::doc::progress::Progress>,
|
||||
pub(crate) quality: solidcraft_engine::doc::display_quality::DisplayQuality,
|
||||
}
|
||||
|
||||
impl Applying {
|
||||
/// OK computing `cmds`, in once `done` says what was evaluated (tests stand in for the worker).
|
||||
#[cfg(test)]
|
||||
pub(crate) fn computing(done: std::sync::mpsc::Receiver<Option<solidcraft_engine::Evaluated>>, cmds: Vec<(String, Value)>) -> Self {
|
||||
Applying { done, evaluated: None, started: crate::now_ms(), cmds, seen: true }
|
||||
}
|
||||
|
||||
/// The evaluation is in and the job has been in a frame. A job that has just started waits
|
||||
/// one frame: the window thread may be held up between starting it and the check, and the
|
||||
/// feature must not appear where the dialog says it is computing.
|
||||
fn ready(&mut self) -> bool {
|
||||
self.seen && self.finished()
|
||||
}
|
||||
|
||||
/// The evaluation is in (or its worker ended).
|
||||
fn finished(&mut self) -> bool {
|
||||
if self.evaluated.is_none() {
|
||||
match self.done.try_recv() {
|
||||
Ok(evaluated) => self.evaluated = Some(evaluated),
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => self.evaluated = Some(None),
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => {}
|
||||
}
|
||||
fn finished(&mut self) -> Option<Result<solidcraft_engine::ComputedCommands, String>> {
|
||||
if !self.seen {
|
||||
self.seen = true;
|
||||
return None;
|
||||
}
|
||||
self.evaluated.is_some()
|
||||
self.ready.take().or_else(|| match self.done.try_recv() {
|
||||
Ok(result) => Some(result),
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => None,
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => Some(Err("feature computation ended without a result".into())),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// How OK goes.
|
||||
enum Begun {
|
||||
/// It computes off the window thread.
|
||||
Later(Applying),
|
||||
/// It runs now, with what was evaluated for it (if anything).
|
||||
Now(Option<solidcraft_engine::Evaluated>),
|
||||
}
|
||||
|
||||
/// Run the dialog's commands, taking the features `evaluated` computed for them ahead.
|
||||
fn run_evaluated(app: &mut SolveApp, d: &Dialog, evaluated: Option<&solidcraft_engine::Evaluated>) -> Result<(), String> {
|
||||
if let Some(evaluated) = evaluated {
|
||||
app.session.prime(evaluated);
|
||||
impl Drop for Applying {
|
||||
fn drop(&mut self) {
|
||||
self.progress.cancel();
|
||||
}
|
||||
let r = run_dialog(app, d);
|
||||
app.session.unprime();
|
||||
r
|
||||
}
|
||||
|
||||
/// How long the desktop app's OK waits for its evaluation before it lets the window go on and
|
||||
/// shows that it is computing ([`SolveApp::apply_off_thread`]): a feature quicker than this
|
||||
/// applies at once, as it always did.
|
||||
/// How long OK waits before displaying its computing state.
|
||||
pub const APPLY_AT_ONCE: std::time::Duration = std::time::Duration::from_millis(150);
|
||||
|
||||
/// Start OK's evaluation off the window thread, for a feature dialog. `Now` when OK should
|
||||
/// just run: not a feature, not asked for ([`SolveApp::apply_off_thread`]), no threads (the
|
||||
/// web), or done within the wait.
|
||||
fn display_quality(app: &SolveApp) -> solidcraft_engine::doc::display_quality::DisplayQuality {
|
||||
solidcraft_engine::doc::display_quality::DisplayQuality::parse(&app.preferences.display_quality).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Desktop feature dialogs evaluate the entire command and its dependent suffix once.
|
||||
/// Results wait until a later frame before adoption, keeping the computing state visible.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn begin_applying(app: &SolveApp, d: &Dialog) -> Begun {
|
||||
let Some(wait) = app.apply_off_thread else { return Begun::Now(None) };
|
||||
pub(crate) fn begin_applying(app: &SolveApp, d: &Dialog) -> Option<Applying> {
|
||||
let wait = app.apply_off_thread?;
|
||||
if !d.previews() {
|
||||
return Begun::Now(None);
|
||||
return None;
|
||||
}
|
||||
let Ok(cmds) = apply_commands(app, d) else { return Begun::Now(None) };
|
||||
let ahead = app.session.ahead();
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let computed = cmds.clone();
|
||||
let computation = DialogComputation::new(app, d).ok()?;
|
||||
let cmds = computation.cmds.clone();
|
||||
#[cfg(test)]
|
||||
let gate = app.apply_gate.clone();
|
||||
let spawned = std::thread::Builder::new().name("apply".into()).spawn(move || {
|
||||
let evaluated = ahead.evaluate(&computed).ok();
|
||||
Some(start_applying(cmds, display_quality(app), crate::now_ms(), wait, move || {
|
||||
let result = computation.compute();
|
||||
#[cfg(test)]
|
||||
if let Some(gate) = gate {
|
||||
let _ = gate.lock().unwrap().recv();
|
||||
}
|
||||
let _ = tx.send(evaluated);
|
||||
result
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn start_applying(
|
||||
cmds: Vec<(String, Value)>,
|
||||
quality: solidcraft_engine::doc::display_quality::DisplayQuality,
|
||||
started: f64,
|
||||
wait: std::time::Duration,
|
||||
compute: impl FnOnce() -> Result<solidcraft_engine::ComputedCommands, String> + Send + 'static,
|
||||
) -> Applying {
|
||||
let progress = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
let watching = progress.clone();
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let worker = std::thread::Builder::new().name("apply".into()).spawn(move || {
|
||||
let result = solidcraft_engine::doc::progress::watch(watching.clone(), || {
|
||||
let prepared = compute()?;
|
||||
if watching.is_cancelled() {
|
||||
return Err("feature computation cancelled".into());
|
||||
}
|
||||
prepared.warm_display(quality, || !watching.is_cancelled());
|
||||
if watching.is_cancelled() {
|
||||
return Err("feature computation cancelled".into());
|
||||
}
|
||||
Ok(prepared)
|
||||
});
|
||||
let _ = tx.send(result);
|
||||
});
|
||||
if spawned.is_err() {
|
||||
return Begun::Now(None);
|
||||
}
|
||||
match rx.recv_timeout(wait) {
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
|
||||
Begun::Later(Applying { done: rx, evaluated: None, started: crate::now_ms(), cmds, seen: false })
|
||||
}
|
||||
Ok(evaluated) => Begun::Now(evaluated),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Begun::Now(None),
|
||||
}
|
||||
let ready = match worker {
|
||||
Err(error) => Some(Err(format!("could not start feature computation: {error}"))),
|
||||
Ok(_) => match rx.recv_timeout(wait) {
|
||||
Ok(result) => Some(result),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => None,
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Some(Err("feature computation ended without a result".into())),
|
||||
},
|
||||
};
|
||||
Applying { done: rx, ready, seen: false, started, cmds, progress, quality }
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn warm_applying(app: &SolveApp, prepared: solidcraft_engine::ComputedCommands, cmds: Vec<(String, Value)>, started: f64) -> Option<Applying> {
|
||||
Some(start_applying(cmds, display_quality(app), started, std::time::Duration::ZERO, move || Ok(prepared)))
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
fn begin_applying(_app: &SolveApp, _d: &Dialog) -> Begun {
|
||||
Begun::Now(None)
|
||||
fn warm_applying(_app: &SolveApp, _prepared: solidcraft_engine::ComputedCommands, _cmds: Vec<(String, Value)>, _started: f64) -> Option<Applying> {
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
pub(crate) fn begin_applying(_app: &SolveApp, _d: &Dialog) -> Option<Applying> {
|
||||
None
|
||||
}
|
||||
|
||||
/// The commands a dialog's inputs make (or why they make none), its picks, and the design's
|
||||
@@ -2653,6 +2712,7 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
let mut ok = false;
|
||||
let mut applied = false;
|
||||
let mut apply_again = app.applying.is_some() && d.repeat_after_apply;
|
||||
let mut adopted = false;
|
||||
let mut cancel = false;
|
||||
let mut enter = false;
|
||||
let mut value_fields = Vec::new();
|
||||
@@ -2870,7 +2930,8 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
Err(error) => d.refuse(app, error),
|
||||
}
|
||||
}
|
||||
if ok && app.applying.is_none() {
|
||||
cancel |= !keep;
|
||||
if ok && !cancel && app.applying.is_none() {
|
||||
d.repeat_after_apply = apply_again;
|
||||
// Edit Text applies its own way: its live changes and OK are one undo step.
|
||||
let run = match &mut d.kind {
|
||||
@@ -2878,44 +2939,68 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
Kind::ChatContext => Some(crate::agent_chat::pick_done(app, &d)),
|
||||
_ => match begin_applying(app, &d) {
|
||||
// Computing: the dialog stays, saying so, until it is in.
|
||||
Begun::Later(job) => {
|
||||
Some(job) => {
|
||||
app.applying = Some(job);
|
||||
None
|
||||
}
|
||||
Begun::Now(evaluated) => Some(run_evaluated(app, &d, evaluated.as_ref())),
|
||||
None => Some(run_dialog(app, &d)),
|
||||
},
|
||||
};
|
||||
match run {
|
||||
Some(Ok(())) => {
|
||||
applied = true;
|
||||
cancel = !apply_again;
|
||||
adopted = d.previews();
|
||||
}
|
||||
Some(Err(e)) => d.refuse(app, e),
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
// OK's evaluation is in: run it, taking what was evaluated. Inputs changed meanwhile
|
||||
// (nothing should change them) are computed in turn, off the window thread too: run here,
|
||||
// they would hold the window for the whole boolean.
|
||||
// A job that has just started is not in yet: it waits a frame, so the dialog says it is
|
||||
// computing before the feature appears.
|
||||
let ready = app.applying.as_mut().is_some_and(Applying::ready);
|
||||
if let Some(job) = &mut app.applying {
|
||||
job.seen = true;
|
||||
}
|
||||
if ready && !cancel {
|
||||
let (computed, evaluated) = app.applying.take().map(|job| (Some(job.cmds), job.evaluated.flatten())).unwrap_or_default();
|
||||
// Adopt the complete transaction. Never rerun a Boolean on the window thread.
|
||||
let finished = if cancel { None } else { app.applying.as_mut().and_then(Applying::finished) };
|
||||
// Preferences received after this frame's renderer setup take effect next frame.
|
||||
// Keep the result ready until the viewport will consume the prepared quality.
|
||||
let finished = if finished.is_some() && solidcraft_engine::doc::display_quality::current() != display_quality(app) {
|
||||
if let Some(job) = app.applying.as_mut() {
|
||||
job.ready = finished;
|
||||
}
|
||||
ctx.request_repaint();
|
||||
None
|
||||
} else {
|
||||
finished
|
||||
};
|
||||
if let Some(result) = finished {
|
||||
let commands = app.applying.as_ref().map(|job| job.cmds.clone());
|
||||
let quality = app.applying.as_ref().map(|job| job.quality);
|
||||
let started = app.applying.as_ref().map_or_else(crate::now_ms, |job| job.started);
|
||||
app.applying = None;
|
||||
let current = apply_commands(app, &d).ok();
|
||||
let again = if current.is_some() && current != computed { begin_applying(app, &d) } else { Begun::Now(evaluated) };
|
||||
match again {
|
||||
Begun::Later(job) => app.applying = Some(job),
|
||||
Begun::Now(evaluated) => match run_evaluated(app, &d, evaluated.as_ref()) {
|
||||
let source_current = result.as_ref().is_ok_and(|prepared| prepared.is_current(&app.session));
|
||||
if current.is_some() && current != commands && source_current {
|
||||
app.applying = begin_applying(app, &d);
|
||||
} else if current != commands && source_current {
|
||||
d.refuse(app, "the feature inputs changed while computing".into());
|
||||
} else if source_current && quality.is_some_and(|quality| quality != display_quality(app)) {
|
||||
// A different display quality needs new plans, never another Boolean evaluation.
|
||||
match result {
|
||||
Ok(prepared) => {
|
||||
app.applying = warm_applying(app, prepared, current.unwrap_or_default(), started);
|
||||
if app.applying.is_none() {
|
||||
d.refuse(app, "the display quality changed while computing".into());
|
||||
}
|
||||
}
|
||||
Err(error) => d.refuse(app, error),
|
||||
}
|
||||
} else {
|
||||
let run = result.and_then(|prepared| adopt_dialog(app, prepared));
|
||||
match run {
|
||||
Ok(()) => {
|
||||
cancel = !apply_again;
|
||||
applied = true;
|
||||
adopted = true;
|
||||
}
|
||||
Err(e) => d.refuse(app, e),
|
||||
},
|
||||
Err(error) => d.refuse(app, error),
|
||||
}
|
||||
}
|
||||
}
|
||||
if applied && apply_again {
|
||||
@@ -2952,8 +3037,14 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
}
|
||||
app.dialog = Some(d);
|
||||
} else if let Some((_, marker)) = d.editing {
|
||||
// Editing done: put the timeline marker back where it was.
|
||||
let _ = roll_marker(app, marker);
|
||||
if applied {
|
||||
app.editing_state = None;
|
||||
if !adopted && app.session.doc.marker != marker {
|
||||
let _ = roll_marker(app, marker);
|
||||
}
|
||||
} else {
|
||||
restore_editing(app, marker);
|
||||
}
|
||||
}
|
||||
// The shortcut that asked for this sketch starts its tool in it.
|
||||
if let Some(id) = then_start {
|
||||
@@ -2964,6 +3055,9 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
/// Close the dialog without applying it (Esc, Cancel). An edit puts the timeline marker back.
|
||||
pub fn cancel(app: &mut SolveApp) {
|
||||
app.session.feature_edit_sketch = None;
|
||||
if let Some(pending) = &mut app.pending_feature_edit {
|
||||
pending.cancel();
|
||||
}
|
||||
app.applying = None;
|
||||
if let Some(mut d) = app.dialog.take() {
|
||||
crate::dialogs_motion::closed(app, &mut d, false);
|
||||
@@ -2975,6 +3069,17 @@ pub fn cancel(app: &mut SolveApp) {
|
||||
if let Some(d) = app.dialog.take()
|
||||
&& let Some((_, marker)) = d.editing
|
||||
{
|
||||
restore_editing(app, marker);
|
||||
}
|
||||
app.editing_state = None;
|
||||
}
|
||||
|
||||
pub(crate) fn restore_editing(app: &mut SolveApp, marker: Option<usize>) {
|
||||
if let Some(state) = app.editing_state.take() {
|
||||
if let Err(error) = app.session.restore_editor(&state.source, state.original) {
|
||||
app.set_status(error.to_string(), true);
|
||||
}
|
||||
} else {
|
||||
let _ = roll_marker(app, marker);
|
||||
}
|
||||
}
|
||||
@@ -3341,6 +3446,10 @@ pub(crate) fn run_dialog(app: &mut SolveApp, d: &Dialog) -> Result<(), String> {
|
||||
if let Kind::SaveMesh(k) = &d.kind {
|
||||
return crate::dialogs_save_mesh::run(app, k, &d.inputs);
|
||||
}
|
||||
if d.previews() {
|
||||
let prepared = DialogComputation::new(app, d)?.compute()?;
|
||||
return adopt_dialog(app, prepared);
|
||||
}
|
||||
let commands = apply_commands(app, d)?;
|
||||
if let Some((_, marker)) = d.editing {
|
||||
// Record the actual pre-edit timeline state in the command's undo snapshot.
|
||||
|
||||
@@ -192,14 +192,16 @@ fn apply_keeps_the_panel_open_after_asynchronous_evaluation() {
|
||||
let mut h = fixture();
|
||||
let mut d = picked(&h, "sketch.pattern.rectangular");
|
||||
let cmds = apply_commands(&h.app, &d).unwrap();
|
||||
let prepared = h.app.session.scratch().compute_commands(&cmds, None).unwrap();
|
||||
d.repeat_after_apply = true;
|
||||
h.app.dialog = Some(d);
|
||||
let (finish, done) = std::sync::mpsc::channel();
|
||||
h.app.applying = Some(Applying::computing(done, cmds));
|
||||
h.app.applying =
|
||||
Some(Applying { done, ready: None, started: crate::now_ms(), cmds, seen: true, progress: Default::default(), quality: Default::default() });
|
||||
let undo = h.app.session.undo.len();
|
||||
h.frames(2);
|
||||
assert_eq!(h.app.session.undo.len(), undo);
|
||||
finish.send(None).unwrap();
|
||||
finish.send(Ok(prepared)).ok().unwrap();
|
||||
h.frames(3);
|
||||
assert!(h.app.applying.is_none());
|
||||
let d = h.app.dialog.as_ref().unwrap();
|
||||
|
||||
@@ -25,6 +25,7 @@ pub struct DocSlot {
|
||||
pub(crate) big_operation: bool,
|
||||
cam: Camera,
|
||||
pre_sketch_marker: Option<Option<usize>>,
|
||||
pub(crate) pending_feature_edit: Option<crate::feature_edit::PendingFeatureEdit>,
|
||||
view: DocView,
|
||||
occurrence_move: Option<crate::browser::OccMove>,
|
||||
agent_chat: crate::agent_chat::AgentChat,
|
||||
@@ -45,6 +46,7 @@ impl DocSlot {
|
||||
big_operation: false,
|
||||
cam: Camera::default(),
|
||||
pre_sketch_marker: None,
|
||||
pending_feature_edit: None,
|
||||
view: DocView::default(),
|
||||
occurrence_move: None,
|
||||
agent_chat: Default::default(),
|
||||
@@ -126,6 +128,7 @@ fn swap_in(app: &mut SolveApp, mut slot: DocSlot) -> DocSlot {
|
||||
big_operation: std::mem::replace(&mut app.big_operation, slot.big_operation),
|
||||
cam: std::mem::replace(&mut app.cam, slot.cam),
|
||||
pre_sketch_marker: std::mem::replace(&mut app.pre_sketch_marker, slot.pre_sketch_marker),
|
||||
pending_feature_edit: std::mem::replace(&mut app.pending_feature_edit, slot.pending_feature_edit),
|
||||
view: take_view(app),
|
||||
occurrence_move: std::mem::replace(&mut app.tree.occurrence_move, slot.occurrence_move),
|
||||
agent_chat: slot.agent_chat,
|
||||
@@ -137,7 +140,11 @@ fn swap_in(app: &mut SolveApp, mut slot: DocSlot) -> DocSlot {
|
||||
// Preferences the session holds go with the user, not the tab (#680).
|
||||
app.session.auto_project = out.session.auto_project;
|
||||
// Views cache by revision: the incoming design must not look unchanged.
|
||||
let before = app.session.revision;
|
||||
app.session.invalidate_view(out_rev);
|
||||
if let Some(pending) = &mut app.pending_feature_edit {
|
||||
pending.view_changed(before, app.session.revision);
|
||||
}
|
||||
app.ui.ribbon_context = None;
|
||||
app.ui.tab = "MODEL".into();
|
||||
crate::workspace::sync_context(app);
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
//! Prepare the original and rollback models when transferring a sketch's history marker.
|
||||
|
||||
use solidcraft_engine::Session;
|
||||
|
||||
use crate::SolveApp;
|
||||
|
||||
pub(crate) struct PendingFeatureEdit {
|
||||
source: Session,
|
||||
done: std::sync::mpsc::Receiver<Result<(Session, Session), String>>,
|
||||
feature: Option<u64>,
|
||||
next_command: Option<String>,
|
||||
pub(crate) marker: Option<usize>,
|
||||
pub(crate) started: f64,
|
||||
}
|
||||
|
||||
impl PendingFeatureEdit {
|
||||
pub(crate) fn cancel(&mut self) {
|
||||
self.feature = None;
|
||||
self.next_command = None;
|
||||
}
|
||||
|
||||
pub(crate) fn then_start(&mut self, command: &str) {
|
||||
self.cancel();
|
||||
self.next_command = Some(command.to_owned());
|
||||
}
|
||||
|
||||
pub(crate) fn view_changed(&mut self, before: u64, after: u64) {
|
||||
if self.source.revision == before {
|
||||
self.source.revision = after;
|
||||
}
|
||||
}
|
||||
|
||||
fn result(&self) -> Option<Result<(Session, Session), String>> {
|
||||
match self.done.try_recv() {
|
||||
Ok(result) => Some(result),
|
||||
Err(std::sync::mpsc::TryRecvError::Empty) => None,
|
||||
Err(std::sync::mpsc::TryRecvError::Disconnected) => Some(Err("feature editor preparation ended without a result".into())),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl SolveApp {
|
||||
pub(crate) fn prepare_feature_edit(&mut self, feature: u64, index: usize, marker: Option<usize>) {
|
||||
let source = self.session.scratch();
|
||||
let mut original = source.scratch();
|
||||
let quality = solidcraft_engine::doc::display_quality::DisplayQuality::parse(&self.preferences.display_quality).unwrap_or_default();
|
||||
let compute = move || {
|
||||
let params = marker.map(|position| serde_json::json!({"position": position})).unwrap_or_else(|| serde_json::json!({}));
|
||||
original.execute("timeline.roll_to", ¶ms).map_err(|error| error.to_string())?;
|
||||
let mut rolled = original.scratch();
|
||||
rolled.execute("timeline.roll_to", &serde_json::json!({"position": index})).map_err(|error| error.to_string())?;
|
||||
original.world_state().warm_display_at(quality, || true);
|
||||
rolled.world_state().warm_display_at(quality, || true);
|
||||
Ok((original, rolled))
|
||||
};
|
||||
let (tx, done) = std::sync::mpsc::channel();
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Err(error) = std::thread::Builder::new().name("feature edit".into()).spawn(move || {
|
||||
let _ = tx.send(compute());
|
||||
}) {
|
||||
self.set_status(format!("could not prepare feature editor: {error}"), true);
|
||||
return;
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
let _ = tx.send(compute());
|
||||
self.pending_feature_edit =
|
||||
Some(PendingFeatureEdit { source, done, feature: Some(feature), next_command: None, marker, started: crate::now_ms() });
|
||||
}
|
||||
|
||||
pub(crate) fn poll_feature_edit(&mut self, ctx: &egui::Context) {
|
||||
// A tab switch cancels opening the editor, but its original model still belongs
|
||||
// to that design. Finish its guarded restoration in its own inactive slot.
|
||||
for slot in self.docs.background_mut() {
|
||||
let Some(pending) = slot.pending_feature_edit.take() else { continue };
|
||||
match pending.result() {
|
||||
None => {
|
||||
slot.pending_feature_edit = Some(pending);
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(16));
|
||||
}
|
||||
Some(Ok((original, _))) => {
|
||||
let _ = slot.session.restore_editor(&pending.source, original);
|
||||
}
|
||||
Some(Err(_)) => {}
|
||||
}
|
||||
}
|
||||
let Some(mut pending) = self.pending_feature_edit.take() else { return };
|
||||
if ctx.input(|input| input.key_pressed(egui::Key::Escape)) {
|
||||
self.esc_handled = true;
|
||||
pending.cancel();
|
||||
}
|
||||
let Some(result) = pending.result() else {
|
||||
self.pending_feature_edit = Some(pending);
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(16));
|
||||
return;
|
||||
};
|
||||
match result {
|
||||
Ok((original, rolled)) => {
|
||||
// A stale result is discarded, never restarted against a newer design.
|
||||
// Adoption preserves the live history stacks and current selection.
|
||||
let restore = if pending.feature.is_some() { rolled } else { original.scratch() };
|
||||
if let Err(error) = self.session.restore_editor(&pending.source, restore) {
|
||||
self.set_status(error.to_string(), true);
|
||||
return;
|
||||
}
|
||||
if let Some(feature) = pending.feature {
|
||||
self.open_feature_edit(feature, pending.marker, original);
|
||||
} else if let Some(command) = pending.next_command {
|
||||
self.start(&command);
|
||||
}
|
||||
}
|
||||
Err(error) => self.set_status(error, true),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -28,7 +28,7 @@ fn block_boss_hole() -> Harness {
|
||||
/// Frames until nothing computes or waits (a few seconds at most).
|
||||
fn until_settled(h: &mut Harness) {
|
||||
for _ in 0..500 {
|
||||
if h.app.deferred.is_none() && h.app.deferred_queue.is_empty() && h.app.delete_check.is_none() {
|
||||
if h.app.deferred.is_none() && h.app.deferred_queue.is_empty() && h.app.delete_check.is_none() && h.app.pending_feature_edit.is_none() {
|
||||
break;
|
||||
}
|
||||
h.frames(1);
|
||||
@@ -220,6 +220,178 @@ fn switching_from_a_sketch_to_a_feature_keeps_the_original_marker_with_backgroun
|
||||
assert_eq!(h.app.session.model.state().bodies.len(), bodies, "all later bodies return");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_restores_partial_markers_and_sketch_changes() {
|
||||
for original_marker in [None, Some(4)] {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
h.app.run("timeline.roll_to", json!({"position": original_marker})).unwrap();
|
||||
let bodies = h.app.session.model.state().bodies.len();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.run("sketch.line", json!({"points": [[0, 2], [10, 2]]})).unwrap();
|
||||
h.app.edit_feature(feature);
|
||||
let history = (h.app.session.undo.len(), h.app.session.redo.len());
|
||||
let changed = h.app.session.doc.sketch(sketches[0]).unwrap().clone();
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.dialog.is_some());
|
||||
h.app.session.selection = vec![solidcraft_engine::Sel::Axis { name: "X".into() }];
|
||||
*h.app.session.model.cache.lock().unwrap() = Default::default();
|
||||
let window = std::sync::Arc::new(solidcraft_engine::doc::progress::Progress::default());
|
||||
solidcraft_engine::doc::progress::watch(window.clone(), || crate::dialogs::cancel(&mut h.app));
|
||||
assert_eq!(window.features(), (0, 0), "Cancel uses the pinned matching model");
|
||||
assert_eq!(marker(&h), original_marker);
|
||||
assert_eq!(h.app.session.model.state().bodies.len(), bodies);
|
||||
assert_eq!(h.app.session.doc.sketch(sketches[0]).unwrap(), &changed);
|
||||
assert_eq!((h.app.session.undo.len(), h.app.session.redo.len()), history);
|
||||
assert_eq!(h.app.session.selection, vec![solidcraft_engine::Sel::Axis { name: "X".into() }]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_rejects_replaced_or_changed_documents() {
|
||||
for action in ["new", "change"] {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.edit_feature(feature);
|
||||
assert!(h.app.computing_since().is_some());
|
||||
match action {
|
||||
"new" => {
|
||||
h.app.run("file.new", json!({})).unwrap();
|
||||
}
|
||||
"change" => {
|
||||
h.app.run("solid.box", json!({"corner": [80, 0, 0], "length": 2, "width": 2, "height": 2})).unwrap();
|
||||
}
|
||||
_ => assert_eq!(action, "change", "unexpected test action"),
|
||||
}
|
||||
let current = h.app.session.doc.clone();
|
||||
let sketch = h.app.session.active_sketch;
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.dialog.is_none(), "{action} must not open the obsolete editor");
|
||||
assert!(std::sync::Arc::ptr_eq(¤t, &h.app.session.doc), "{action} must preserve the current document");
|
||||
assert_eq!(h.app.session.active_sketch, sketch);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_applies_with_one_undo_and_redo() {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
let before = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.edit_feature(feature);
|
||||
let undo = h.app.session.undo.len();
|
||||
until_settled(&mut h);
|
||||
h.frames(2);
|
||||
h.step(&json!({"click":{"handle":"dialog:length"}})).unwrap();
|
||||
h.step(&json!({"key":"A","cmd":true})).unwrap();
|
||||
h.step(&json!({"text":"12 mm"})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
|
||||
for _ in 0..500 {
|
||||
if h.app.dialog.is_none() {
|
||||
break;
|
||||
}
|
||||
h.frames(1);
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
assert!(h.app.dialog.is_none(), "the edit must finish");
|
||||
assert_eq!(marker(&h), None);
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1);
|
||||
let after = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((after - before - 200.0).abs() < 0.001);
|
||||
h.app.run("edit.undo", json!({})).unwrap();
|
||||
assert_eq!(marker(&h), None);
|
||||
let restored = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((restored - before).abs() < 0.001);
|
||||
h.app.run("edit.redo", json!({})).unwrap();
|
||||
let redone = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
|
||||
assert!((redone - after).abs() < 0.001);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_preserves_the_marker_through_cancel_and_superseding_editors() {
|
||||
for next in ["cancel", "escape", "sketch", "feature", "tab", "tab_back_pending"] {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.edit_feature(feature);
|
||||
match next {
|
||||
"cancel" => crate::dialogs::cancel(&mut h.app),
|
||||
"escape" => {
|
||||
h.step(&json!({"key":"Escape"})).unwrap();
|
||||
}
|
||||
"sketch" => {
|
||||
h.app.edit_sketch(sketches[1]);
|
||||
h.app.finish_sketch();
|
||||
}
|
||||
"feature" => {
|
||||
h.app.edit_feature(feature);
|
||||
until_settled(&mut h);
|
||||
crate::dialogs::cancel(&mut h.app);
|
||||
}
|
||||
_ => {
|
||||
let other = solidcraft_engine::Session::new(Default::default());
|
||||
crate::documents::open_tab(&mut h.app, other).unwrap();
|
||||
if next == "tab" {
|
||||
h.frames(10);
|
||||
}
|
||||
assert!(h.app.session.doc.features.is_empty());
|
||||
crate::documents::switch(&mut h.app, 0);
|
||||
}
|
||||
}
|
||||
until_settled(&mut h);
|
||||
assert!(h.app.dialog.is_none(), "{next} must leave no feature editor");
|
||||
assert_eq!(marker(&h), None, "{next} must restore the original marker");
|
||||
assert_eq!(h.app.session.model.state().bodies.len(), 3);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_defers_a_new_command_until_restoration() {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
let count = h.app.session.doc.features.len();
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.edit_feature(feature);
|
||||
h.app.start("solid.box");
|
||||
assert!(h.app.dialog.is_none(), "the next dialog waits for the matching model");
|
||||
until_settled(&mut h);
|
||||
assert_eq!(marker(&h), None);
|
||||
assert_eq!(h.app.dialog.as_ref().unwrap().editing, None);
|
||||
let undo = h.app.session.undo.len();
|
||||
h.frames(2);
|
||||
h.step(&json!({"click":{"handle":"dialog:OK"}})).unwrap();
|
||||
for _ in 0..500 {
|
||||
if h.app.dialog.is_none() {
|
||||
break;
|
||||
}
|
||||
h.frames(1);
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
assert!(h.app.dialog.is_none());
|
||||
assert_eq!(marker(&h), None);
|
||||
assert_eq!(h.app.session.doc.features.len(), count + 1);
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn switching_from_a_sketch_to_a_feature_defers_press_pull_with_its_pick_contract() {
|
||||
let (mut h, sketches) = sketches_with_later_bodies();
|
||||
let feature = h.app.session.doc.features[3].id;
|
||||
h.app.edit_sketch(sketches[0]);
|
||||
h.app.edit_feature(feature);
|
||||
h.app.session.selection.clear();
|
||||
h.app.start("solid.press_pull");
|
||||
assert!(h.app.dialog.is_none());
|
||||
until_settled(&mut h);
|
||||
assert_eq!(marker(&h), None);
|
||||
let dialog = h.app.dialog.as_ref().unwrap();
|
||||
assert!(dialog.press_pull);
|
||||
let picks = dialog.inputs[0].accept;
|
||||
assert_ne!(picks & crate::selection::FACES, 0);
|
||||
assert_ne!(picks & crate::selection::EDGES, 0);
|
||||
}
|
||||
|
||||
/// A control request for the app, and where its reply lands.
|
||||
fn ask(tx: &std::sync::mpsc::Sender<crate::ControlRequest>, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {
|
||||
let (req, reply) = crate::ControlRequest::new(method, params);
|
||||
|
||||
@@ -57,6 +57,7 @@ pub mod documents;
|
||||
pub mod drag_extrude;
|
||||
pub mod drag_snap;
|
||||
pub mod edit_clipboard;
|
||||
mod feature_edit;
|
||||
#[cfg(test)]
|
||||
mod font_literals_tests;
|
||||
pub mod fonts;
|
||||
@@ -459,6 +460,8 @@ pub struct SolveApp {
|
||||
pub preview: preview::PreviewState,
|
||||
/// OK pressed on a feature that takes a while: its evaluation runs off the window thread.
|
||||
pub applying: Option<dialogs::Applying>,
|
||||
pub(crate) editing_state: Option<dialogs::EditingState>,
|
||||
pub(crate) pending_feature_edit: Option<feature_edit::PendingFeatureEdit>,
|
||||
/// A command recomputing the history (the marker moved, undo) computing off the window
|
||||
/// thread, and those asked for meanwhile ([`deferred`]).
|
||||
pub deferred: Option<deferred::Deferred>,
|
||||
@@ -634,6 +637,8 @@ impl SolveApp {
|
||||
slicer_menu: dialogs_save_mesh::SlicerMenu::default(),
|
||||
preview: preview::PreviewState::default(),
|
||||
applying: None,
|
||||
editing_state: None,
|
||||
pending_feature_edit: None,
|
||||
deferred: None,
|
||||
deferred_queue: Vec::new(),
|
||||
start_after_roll: None,
|
||||
@@ -902,6 +907,11 @@ impl SolveApp {
|
||||
let t0 = now_ms();
|
||||
let r = self.session.execute(id, ¶ms).map_err(|e| e.to_string());
|
||||
self.big_operation |= now_ms() - t0 >= recovery_ui::BIG_OPERATION_MS;
|
||||
self.command_completed(id, r)
|
||||
}
|
||||
|
||||
/// Host effects shared by directly executed and already evaluated commands.
|
||||
pub(crate) fn command_completed(&mut self, id: &str, r: Result<Value, String>) -> Result<Value, String> {
|
||||
if let Ok(v) = &r {
|
||||
if id == "view.layout" {
|
||||
let layout =
|
||||
@@ -1000,6 +1010,9 @@ impl SolveApp {
|
||||
// The old document is already replaced: discard its editor without
|
||||
// applying cancellation hooks (such as restoring its timeline marker).
|
||||
self.dialog = None;
|
||||
self.applying = None;
|
||||
self.editing_state = None;
|
||||
self.pending_feature_edit = None;
|
||||
self.tool = None;
|
||||
self.preview.reset();
|
||||
self.cam = Camera::default();
|
||||
@@ -1225,6 +1238,10 @@ impl SolveApp {
|
||||
}
|
||||
// Press Pull: edges get a fillet, curved faces an offset, planar faces and profiles an extrude.
|
||||
if id == "solid.press_pull" {
|
||||
if let Some(pending) = &mut self.pending_feature_edit {
|
||||
pending.then_start(id);
|
||||
return;
|
||||
}
|
||||
let sel = &self.session.selection;
|
||||
let edges = sel.iter().any(|s| matches!(s, solidcraft_engine::Sel::Edge { .. }));
|
||||
let curved = sel.iter().any(
|
||||
@@ -1247,6 +1264,15 @@ impl SolveApp {
|
||||
}
|
||||
return;
|
||||
}
|
||||
let interactive = self.interactive(id);
|
||||
if interactive && let Some(pending) = &mut self.pending_feature_edit {
|
||||
pending.then_start(id);
|
||||
return;
|
||||
}
|
||||
// Cancel before finishing a sketch or waiting for its history marker.
|
||||
if interactive && (self.editing_state.is_some() || self.applying.is_some()) {
|
||||
dialogs::cancel(self);
|
||||
}
|
||||
let finished_sketch = self.session.active_sketch.filter(|_| ends_sketch(id) && self.interactive(id));
|
||||
if finished_sketch.is_some() {
|
||||
self.finish_sketch();
|
||||
@@ -1352,6 +1378,7 @@ impl SolveApp {
|
||||
/// timeline back to just before themselves and reopen their dialog, filled in.
|
||||
pub fn edit_feature(&mut self, id: u64) {
|
||||
use solidcraft_engine::doc::FeatureKind;
|
||||
dialogs::cancel(self);
|
||||
let Some(f) = self.session.doc.feature(id) else { return };
|
||||
if matches!(f.kind, FeatureKind::Sketch { .. }) {
|
||||
self.edit_sketch(id);
|
||||
@@ -1360,14 +1387,28 @@ impl SolveApp {
|
||||
let Some(idx) = self.session.doc.feature_index(id) else { return };
|
||||
let marker = self.finish_sketch_for_edit();
|
||||
self.tool = None;
|
||||
if self.session.doc.marker != marker {
|
||||
self.prepare_feature_edit(id, idx, marker);
|
||||
return;
|
||||
}
|
||||
let original = self.session.scratch();
|
||||
if dialogs::roll_marker(self, Some(idx)).is_err() {
|
||||
return;
|
||||
}
|
||||
self.open_feature_edit(id, marker, original);
|
||||
}
|
||||
|
||||
fn open_feature_edit(&mut self, id: u64, marker: Option<usize>, original: Session) {
|
||||
self.editing_state = Some(dialogs::EditingState { source: self.session.scratch(), original });
|
||||
match dialogs::for_feature(self, id, marker) {
|
||||
Some(d) => self.dialog = Some(d),
|
||||
Some(d) => {
|
||||
if !d.previews() {
|
||||
self.editing_state = None;
|
||||
}
|
||||
self.dialog = Some(d);
|
||||
}
|
||||
None => {
|
||||
let _ = dialogs::roll_marker(self, marker);
|
||||
// No dialog for this feature: open the search box with the command to edit it.
|
||||
dialogs::restore_editing(self, marker);
|
||||
self.sbox.text = format!("timeline.edit {{\"feature\": {id}, \"set\": {{}}}}");
|
||||
self.ui.palette_open = true;
|
||||
}
|
||||
@@ -1407,7 +1448,11 @@ impl SolveApp {
|
||||
/// Pass the original marker to the next editor. Restoring it between editors could finish
|
||||
/// in the background after the next rollback, moving the marker out from under that edit.
|
||||
fn finish_sketch_for_edit(&mut self) -> Option<usize> {
|
||||
let marker = self.pre_sketch_marker.take().unwrap_or(self.session.doc.marker);
|
||||
let marker = self
|
||||
.pending_feature_edit
|
||||
.take()
|
||||
.map(|pending| pending.marker)
|
||||
.unwrap_or_else(|| self.pre_sketch_marker.take().unwrap_or(self.session.doc.marker));
|
||||
if self.session.active_sketch.is_some() {
|
||||
self.finish_sketch();
|
||||
}
|
||||
@@ -1933,6 +1978,7 @@ impl SolveApp {
|
||||
}
|
||||
self.ui.layout.publish(ui.ctx());
|
||||
scenario::clear_handles();
|
||||
self.poll_feature_edit(ui.ctx());
|
||||
self.poll_deferred(ui.ctx());
|
||||
self.poll_delete_check(ui.ctx());
|
||||
if !self.embedded {
|
||||
|
||||
@@ -68,6 +68,45 @@ pub fn tick(app: &mut SolveApp, wait: bool) {
|
||||
mod tests {
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn a_pending_save_blocks_feature_computation_and_completed_transaction_adoption() {
|
||||
let mut h = crate::scenario::Harness::new();
|
||||
h.app.home.open = false;
|
||||
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
|
||||
h.app.run("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[10,10]})).unwrap();
|
||||
h.app.finish_sketch();
|
||||
h.app.start("solid.extrude");
|
||||
h.frames(2);
|
||||
let dialog = h.app.dialog.as_ref().unwrap().clone();
|
||||
let cmds = crate::dialogs::apply_commands(&h.app, &dialog).unwrap();
|
||||
let prepared = h.app.session.scratch().compute_commands(&cmds, None).unwrap();
|
||||
let document = h.app.session.doc.clone();
|
||||
let history = h.app.session.undo.len();
|
||||
let (_save_finish, save_done) = std::sync::mpsc::channel();
|
||||
h.app.saving = Some(super::Saving { command: "file.save", done: save_done });
|
||||
h.app.apply_off_thread = Some(std::time::Duration::ZERO);
|
||||
assert!(crate::dialogs::begin_applying(&h.app, &dialog).is_none());
|
||||
assert!(crate::dialogs::run_dialog(&mut h.app, &dialog).unwrap_err().contains("file operation"));
|
||||
let (finish, done) = std::sync::mpsc::channel();
|
||||
h.app.applying = Some(crate::dialogs::Applying {
|
||||
done,
|
||||
ready: None,
|
||||
seen: true,
|
||||
started: crate::now_ms(),
|
||||
cmds,
|
||||
progress: Default::default(),
|
||||
quality: Default::default(),
|
||||
});
|
||||
finish.send(Ok(prepared)).ok().unwrap();
|
||||
// Run just the dialog, without the normal frame's save polling.
|
||||
let mut out = h.ctx.run_ui(Default::default(), |ui| crate::dialogs::show(&mut h.app, ui.ctx()));
|
||||
// Not drawn: discard the texture updates explicitly.
|
||||
out.textures_delta.clear();
|
||||
assert!(std::sync::Arc::ptr_eq(&document, &h.app.session.doc));
|
||||
assert_eq!(h.app.session.undo.len(), history);
|
||||
assert!(h.app.dialog.as_ref().unwrap().error.as_ref().unwrap().contains("file operation"));
|
||||
}
|
||||
|
||||
/// #3044: Save writes on a worker while the window keeps drawing; the design waits (commands
|
||||
/// are refused) until the save is taken up, which leaves it saved under its file, in the
|
||||
/// recent files, with the command echoed, as a save run here does.
|
||||
|
||||
@@ -2095,7 +2095,7 @@ pub fn shortcuts(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
crate::select_other::close(app);
|
||||
} else if app.tool.is_some() {
|
||||
crate::tools::finish(app);
|
||||
} else if app.dialog.is_some() {
|
||||
} else if app.dialog.is_some() || app.pending_feature_edit.is_some() {
|
||||
crate::dialogs::cancel(app);
|
||||
} else if !app.session.selection.is_empty() || app.session.active_sketch.is_none() {
|
||||
app.tree.picked_joints.clear();
|
||||
|
||||
Reference in New Issue
Block a user