Files
solidcraft/crates/ui-egui/src/delete.rs
T
semmelrindeandClaude Opus 5.5 31a0c99a2c Delete: the delete runs with what its check computed ahead, instead of building the history again (#9917) (#10090)
* Delete: the delete runs with what its check computed ahead (#9917)

With the history rolled back, a delete builds the history after the
marker to see what it breaks, once in the check that runs off the window
thread (Session::ahead) and once more in the delete itself, on the window
thread. The check's results were lost on the way: the dry run's scratch
session and the whole-history copy dropped what the model keeps, and the
check's kept results never reached the delete. The scratch and the copy
now keep what their model keeps, and the delete (at once or after the
confirmation) runs with the check's kept results, so it finds the
history there instead of building it again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Delete: test that a confirmed delete runs with what its check kept (#9917)

With the history rolled back, deleting a side of the plate's outline is
checked off the window thread and confirmed first; the confirmation
carries the check's kept results, and the delete adds nothing to them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 15:19:57 +00:00

226 lines
9.6 KiB
Rust

//! Delete (the Delete and Backspace keys, and every menu's Delete item): whatever is selected in
//! the viewport or the browser goes in one undoable step through `selection.delete`. When it
//! takes other features with it or makes some fail, a confirmation lists them first.
use std::sync::Arc;
use serde_json::{Value, json};
use solidcraft_engine::doc::KeptResults;
use crate::SolveApp;
use crate::ui_kit;
/// Longest list of names the confirmation shows before "and n more".
const MAX_LISTED: usize = 20;
/// A delete waiting for confirmation: its parameters and the dry run's report.
#[derive(Clone, Debug)]
pub struct Pending {
pub params: Value,
pub report: Value,
/// What the dry run computed ahead, for the delete to find (#9917).
pub kept: Option<Arc<KeptResults>>,
}
/// What Delete acts on now: the selection (bodies not locked), plus the components picked in
/// the browser (their occurrences).
pub fn selection_params(app: &SolveApp) -> Value {
use solidcraft_engine::Sel;
let mut items: Vec<Sel> = Vec::new();
for s in app.session.selection.iter().filter(|s| !matches!(s, Sel::Body { name } if app.session.visibility.locked_bodies.contains(name))) {
// A MidPoint glyph shared by lines whose midpoints meet removes every constraint it
// shows, and the point they shared when nothing else holds it.
let group = match s {
Sel::SketchConstraint { id } => crate::sketch_tools::active_glyph_deletion(app, id),
_ => vec![s.clone()],
};
for g in group {
if !items.contains(&g) {
items.push(g);
}
}
}
let occurrences: Vec<u64> = app.tree.picked_components.iter().filter_map(|c| app.session.doc.occurrence_of(*c).map(|o| o.id)).collect();
json!({ "items": items, "occurrences": occurrences, "canvases": app.tree.picked_canvases, "joints": app.tree.picked_joints })
}
fn is_empty(p: &Value) -> bool {
["items", "occurrences", "components", "canvases", "joints"].iter().all(|k| p.get(*k).and_then(Value::as_array).is_none_or(|a| a.is_empty()))
}
fn shared_occurrences(app: &SolveApp, params: &Value) -> bool {
let explicit = params.get("occurrences").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64);
let selected = params
.get("items")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter(|item| item["type"] == "occurrence")
.filter_map(|item| item["path"].as_array()?.last()?.as_u64());
explicit.chain(selected).any(|id| app.session.occurrence_id_scope_count(id).is_ok_and(|n| n > 1))
}
/// Delete what is selected (the Delete key). A selected sketch dimension or constraint glyph
/// goes first, as before.
pub fn delete_selection(app: &mut SolveApp) {
if crate::sketch3d::delete_selected(app) || crate::sketch_tools::delete_glyph(app) {
return;
}
let mut params = selection_params(app);
// In Edit Joint with nothing else selected, Delete means the joint being edited (#3749).
if is_empty(&params)
&& let Some(id) = edited_joint(app)
{
params["joints"] = json!([id]);
}
request(app, params);
}
/// Whether Delete has nothing to act on: nothing selected, and no joint open in Edit Joint.
pub fn nothing_to_delete(app: &SolveApp) -> bool {
is_empty(&selection_params(app)) && edited_joint(app).is_none()
}
/// The joint the open Edit Joint dialog edits.
fn edited_joint(app: &SolveApp) -> Option<u64> {
match app.dialog.as_ref().map(|d| &d.kind) {
Some(crate::dialogs::Kind::Assembly(crate::dialogs_assembly::Asm::Joint(f))) => f.editing,
_ => None,
}
}
/// Why a joint cannot be deleted now (the history it changes is busy), if it cannot.
fn joint_delete_blocked(app: &SolveApp) -> Option<&'static str> {
if app.dialog.is_some() {
Some("Close the open dialog before deleting a joint")
} else if app.tool.is_some() {
Some("Finish the active tool before deleting a joint")
} else if app.computing_since().is_some() {
Some("Wait for the design to finish computing before deleting a joint")
} else if app.file_load.busy() {
Some("Wait for the file to finish loading before deleting a joint")
} else {
None
}
}
/// Delete `params` (as `selection.delete` takes them): at once, or after a confirmation when
/// other features go with it or would fail. The dry run that finds out evaluates the history
/// after what is deleted, so it may compute off the window thread (#2678).
pub fn request(app: &mut SolveApp, params: Value) {
let joints: Vec<u64> = params.get("joints").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).collect();
if !joints.is_empty() {
// Deleting just the joint Edit Joint edits closes the dialog first, as its Cancel does.
let only_edited = edited_joint(app).is_some_and(|id| joints == [id])
&& ["items", "occurrences", "components", "canvases"]
.iter()
.all(|k| params.get(*k).and_then(Value::as_array).is_none_or(|a| a.is_empty()));
if only_edited && app.applying.is_none() && app.tool.is_none() && app.computing_since().is_none() && !app.file_load.busy() {
crate::dialogs::cancel(app);
}
if let Some(why) = joint_delete_blocked(app) {
app.set_status(why, true);
return;
}
}
if is_empty(&params) {
return;
}
let mut dry = params.clone();
dry["dry_run"] = json!(true);
app.check_delete(vec![("selection.delete".to_string(), dry)], crate::deferred::AfterCheck::Selection(params));
}
/// [`request`] once its dry run's report is in.
pub(crate) fn checked(app: &mut SolveApp, params: Value, report: Result<Value, String>, kept: Option<Arc<KeptResults>>) {
let report = match report {
Ok(r) => r,
Err(e) => {
app.set_status(e.replace("selection.delete: ", ""), true);
return;
}
};
let asked =
params.get("items").and_then(Value::as_array).map_or(0, |a| a.iter().filter(|i| i["type"] == "feature" || i["type"] == "plane").count());
let extra = report["deleted"].as_array().map_or(0, Vec::len) > asked;
let fails = report["would_fail"].as_array().is_some_and(|a| !a.is_empty());
let shared = shared_occurrences(app, &params);
if extra || fails || shared {
app.menu.confirm = Some(Pending { params, report, kept });
} else {
run(app, &params, kept);
}
}
/// Delete for real. With the history rolled back it builds the history after the marker to see
/// what the delete breaks: the dry run built it ahead, off the window thread, and `kept` it.
fn run(app: &mut SolveApp, params: &Value, kept: Option<Arc<KeptResults>>) {
match app.run_with_kept(kept, |app| app.run("selection.delete", params.clone())) {
Ok(r) => {
app.tree.picked_components.clear();
app.tree.picked_canvases.clear();
app.tree.picked_joints.clear();
if let Some(s) = r["skipped"].as_array().and_then(|a| a.first()).and_then(Value::as_str) {
app.set_status(format!("deleted; {s}"), false);
}
}
Err(e) => app.set_status(e.replace("selection.delete: ", ""), true),
}
}
/// Answer the confirmation (also `ui.confirm`): delete, or keep everything.
pub fn confirm(app: &mut SolveApp, accept: bool) -> bool {
let Some(p) = app.menu.confirm.take() else { return false };
if accept {
run(app, &p.params, p.kept);
}
true
}
/// The confirmation card.
pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
let Some(p) = app.menu.confirm.clone() else { return };
let list = |k: &str| -> Vec<String> {
p.report[k].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default()
};
let (deleted, fails) = (list("deleted"), list("would_fail"));
let shared = shared_occurrences(app, &p.params);
let (closed, action) = ui_kit::Confirm::new(egui::Id::new("sc_delete_confirm"), "delete", crate::i18n::tr_label("Delete"))
.tone(ui_kit::Tone::Danger)
.actions("Delete", "Cancel", None)
.show(ctx, true, |ui| {
if shared {
ui_kit::text(
ui,
crate::i18n::tr_label("This child is shared. Deleting it removes it from every copy of its parent."),
ui_kit::Text::Report("shared", false),
);
}
for (key, heading, names, error) in
[("deleted", "These features will be deleted:", &deleted, false), ("fails", "These features will fail:", &fails, true)]
{
if names.is_empty() {
continue;
}
ui_kit::text(ui, crate::i18n::tr_label(heading), ui_kit::Text::Report(key, error));
for name in names.iter().take(MAX_LISTED) {
ui_kit::text(ui, &format!(" • {name}"), ui_kit::Text::Report(&format!("{key}:{name}"), error));
}
if names.len() > MAX_LISTED {
let more = (names.len() - MAX_LISTED).to_string();
ui_kit::text(
ui,
&crate::i18n::format("delete.and_more", &[("count", &more)]),
ui_kit::Text::Report(&format!("{key}:more"), error),
);
}
}
});
match action {
ui_kit::Action::Ok => drop(confirm(app, true)),
ui_kit::Action::Cancel => drop(confirm(app, false)),
_ if closed => drop(confirm(app, false)),
_ => {}
}
}