Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

49.6 KB
Raw Blame
//! The Save as mesh dialog (`file.save_mesh`): which bodies and the mesh format, then a file dialog.
//! Send to Slicer (`file.send_to_slicer`) shares the dialog without the format and with a slicer to
//! send the bodies to: it always asks, and pre-selects the slicer used last time. The list also has
//! a plain text row for EasyPrint (`file.open_in_easyprint`), which works in a browser too.
//!
//! Send to Slicer also has a Print face input (#8429): it shows the print face of each body being
//! sent, takes a flat face picked in the viewport as its body's print face (in place of the one it
//! had), and clears a body's when its face is taken out. Each change runs `body.print_face` at
//! once, so it undoes like any other.
//!
//! Every place that saves a mesh opens this dialog: File › Export STL / Export 3MF, the Mesh tab, and the
//! Save As Mesh item of the body menus. The slicer list (Send to Slicer only) holds the programs the user added (kept
//! between runs, newest first), then the slicers found on this machine, then "Custom…", which asks
//! for a program and adds it at the top; "Custom…" itself is never the selection. Pressing Delete
//! over a program the user added removes it.

use crate::selection::SelectionExt as _;
use crate::ui_kit::BackingTooltipExt as _;
use crate::ui_kit::choice_row;
use std::collections::HashMap;

use egui::{Color32, Sense, vec2};
use serde_json::{Value, json};
use solidcraft_engine::slicers::{self, Slicer};

use crate::SolveApp;
use crate::dialogs::{Kind, form_row};
use crate::selection::{BODIES, PLANAR_FACES, SelInput};
use crate::theme::Tokens;
use solidcraft_engine::Sel;

/// The formats, as shown and as `file.save_mesh` names them.
/// (label, `format` parameter, file extension).
const FORMATS: [(&str, &str, &str); 3] = [("STL", "stl", "stl"), ("3MF", "3mf", "3mf"), ("3MF with face tags", "3mf-tagged", "3mf")];
/// The list key of the EasyPrint row (no slicer has it: ids are words, programs are paths).
const EASYPRINT: &str = "easyprint";
/// How closely the mesh follows curved faces (#4747): the label and `file.save_mesh`'s `quality`.
const QUALITIES: [(&str, &str); 3] = [("Standard", "standard"), ("Fine", "fine"), ("Finest", "finest")];
/// Edge of a slicer's icon in the list.
const ICON: f32 = 16.0;
/// Most programs the user can keep in the list.
const MAX_CUSTOM: usize = 24;

/// The dialog's values.
#[derive(Clone, Debug, PartialEq)]
pub struct SaveMesh {
    format: usize,
    /// Send to Slicer: only the bodies and the slicer are asked.
    open: bool,
    /// Index into [`QUALITIES`] (Save As Mesh; Send to Slicer has no quality row).
    quality: usize,
    /// The chosen slicer: an installed one's id, or the path of one the user added.
    slicer: String,
    /// The slicer list has not been read for this opening yet.
    stale: bool,
    /// Send to Slicer: the bodies and the print faces the Print face input last showed, to tell
    /// a pick or a clear in it from a change of the bodies.
    shown: Option<(Vec<String>, Vec<Sel>)>,
}

impl SaveMesh {
    /// The chosen format, as `file.save_mesh` names it (`stl`, `3mf`, `3mf-tagged`).
    #[cfg(test)]
    pub(crate) fn format_name(&self) -> &'static str {
        FORMATS.get(self.format).map_or("stl", |f| f.1)
    }
}

/// One line of the slicer list.
struct Entry {
    key: String,
    slicer: Slicer,
    /// Added by the user (can be deleted).
    user: bool,
}

/// The slicers known to the dialog, and their icons.
#[derive(Default)]
pub struct SlicerMenu {
    detected: Vec<Slicer>,
    custom: Vec<(String, Slicer)>,
    icons: HashMap<String, Option<egui::TextureHandle>>,
    /// A program chosen in the Custom… file dialog, waiting for the open dialog to take it.
    picked: Option<String>,
}

impl SlicerMenu {
    /// Look at the machine and at the saved programs again.
    pub fn refresh(&mut self, custom_paths: &[String]) {
        self.detected = slicers::detect();
        self.set_custom(custom_paths);
    }

    fn set_custom(&mut self, paths: &[String]) {
        // A program that has been uninstalled drops out of the list (it stays in the settings).
        self.custom = paths.iter().filter_map(|p| slicers::custom(p).map(|s| (p.clone(), s))).collect();
    }

    /// The list key for a remembered one: itself; or, for one remembered under another install
    /// of the same slicer (`prusa` before it had several, `prusa#x` after an uninstall), the one
    /// install of that slicer when there is exactly one; else none.
    fn key_for(&self, key: &str) -> Option<String> {
        let entries = self.entries();
        if let Some(e) = entries.iter().find(|e| e.key == key) {
            return Some(e.key.clone());
        }
        // `prusa#x` remembered while there were two installs, and one left: the plain `prusa`. Only
        // when it is exactly one: with several, nothing says which was meant, and another is not
        // picked in its place (the choice then starts from the first, as when nothing was remembered).
        let base = key.split('#').next().unwrap_or(key);
        let mut same = entries.iter().filter(|e| !e.user && e.slicer.base_id() == base);
        match (same.next(), same.next()) {
            (Some(only), None) => Some(only.key.clone()),
            _ => None,
        }
    }

    fn entries(&self) -> Vec<Entry> {
        let user = self.custom.iter().map(|(path, s)| Entry { key: path.clone(), slicer: s.clone(), user: true });
        let found = self.detected.iter().map(|s| Entry { key: s.id.clone(), slicer: s.clone(), user: false });
        user.chain(found).collect()
    }
}

/// The dialog for `file.save_mesh` or `file.send_to_slicer`, with the choices of last time.
pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {
    let open = match id {
        "file.save_mesh" => false,
        "file.send_to_slicer" | "file.open_in_easyprint" => true,
        _ => return None,
    };
    let p = &app.preferences;
    let format = FORMATS.iter().position(|f| f.1 == p.save_mesh_format).unwrap_or(0);
    let slicer = match id {
        "file.open_in_easyprint" => EASYPRINT.into(),
        _ if open => p.send_slicer.clone(),
        _ => String::new(),
    };
    let quality = QUALITIES.iter().position(|q| q.1 == p.save_mesh_quality).unwrap_or(0);
    let kind = Kind::SaveMesh(SaveMesh { format, quality, open, slicer, stale: true, shown: None });
    let mut inputs = vec![SelInput::new("Bodies", BODIES, true)];
    if open {
        inputs.push(SelInput::new("Print face", PLANAR_FACES, true));
    }
    Some((kind, inputs))
}

/// Send to Slicer needs a way to start a program (a browser has none) or a way to reach EasyPrint.
pub fn available(app: &SolveApp) -> bool {
    app.services.pick_program.is_some() || crate::easyprint_ui::available(app)
}

/// A slicer that was started alone and is being waited for, off the UI thread, until it can take
/// the file (`Target::ready` in `slicers`). One at a time: a second send while it lasts does nothing.
pub struct SlicerWait {
    done: std::sync::mpsc::Receiver<bool>,
    /// The slicer that was started, found once.
    slicer: slicers::Slicer,
    /// What `file.send_to_slicer` answered when it wrote the file: the file that is sent, not
    /// exported again, however the design has changed since.
    result: Value,
}

/// Look at `ready` on another thread until it says so or `limit` runs out; the answer arrives on the
/// channel.
fn spawn_wait(
    ready: impl FnMut(std::time::Duration) -> bool + Send + 'static,
    limit: std::time::Duration,
    poll: std::time::Duration,
) -> std::sync::mpsc::Receiver<bool> {
    let (tx, rx) = std::sync::mpsc::channel();
    std::thread::spawn(move || {
        let _ = tx.send(slicers::wait_until(ready, limit, poll));
    });
    rx
}

/// Run `file.send_to_slicer` and report what happened. A slicer that has to be started first is
/// started and waited for in the background.
fn send_to_slicer(app: &mut SolveApp, params: Value) {
    let _language = crate::i18n::scope(&app.preferences.language);
    if let Some(wait) = &app.slicer_wait {
        // Whatever was picked this time (another slicer, other bodies): nothing else is sent.
        let line = crate::i18n::format("ui.slicer_still_starting", &[("slicer", &wait.slicer.name)]);
        app.set_status(line, false);
        return;
    }
    let mut params = params;
    params["single_instance"] = json!(app.preferences.slicer_single_instance);
    params["wait"] = json!("return");
    let Ok(result) = app.run("file.send_to_slicer", params.clone()) else { return };
    if result.get("starting").is_none() {
        return report(app, &result);
    }
    begin_wait(app, params, &result);
}

/// The command started the slicer on its own (`result.starting`): wait for it in the background.
fn begin_wait(app: &mut SolveApp, params: Value, result: &Value) {
    let name = result.get("starting").and_then(Value::as_str).unwrap_or_default().to_string();
    let path = result.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
    let spec = params["slicer"].as_str().unwrap_or_default().to_string();
    let Some(slicer) = slicers::resolve(&spec) else {
        // Started, but it can't be found again to be sent the file: say so rather than go quiet.
        app.set_status(crate::i18n::format("ui.slicer_lost", &[("slicer", &name), ("path", &path)]), true);
        return;
    };
    // Same reading as `slicers::wait_for_ready`: when `busctl` is missing or fails, send; when it is
    // only slow, keep waiting.
    let probe = slicer.clone();
    let done =
        spawn_wait(move |left| probe.is_ready_within(left.min(slicers::PROBE_LIMIT)) != Some(false), slicers::READY_LIMIT, slicers::READY_POLL);
    app.slicer_wait = Some(SlicerWait { done, slicer, result: result.clone() });
    app.set_status(crate::i18n::format("ui.slicer_starting", &[("slicer", &name)]), false);
}

/// Per frame: when the slicer being waited for is ready, send the file; when the wait ran out, say so.
pub fn tick_wait(app: &mut SolveApp, ctx: &egui::Context) {
    use std::sync::mpsc::TryRecvError;
    let Some(wait) = app.slicer_wait.as_ref() else { return };
    let ready = match wait.done.try_recv() {
        Err(TryRecvError::Empty) => return ctx.request_repaint_after(std::time::Duration::from_millis(200)),
        Ok(ready) => ready,
        Err(TryRecvError::Disconnected) => false,
    };
    let Some(wait) = app.slicer_wait.take() else { return };
    let _language = crate::i18n::scope(&app.preferences.language);
    let path = wait.result.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
    if ready && path.is_empty() {
        // Nothing was written to send (the answer had no path): say so, rather than open "".
        app.set_status(crate::i18n::format("ui.slicer_no_file", &[("slicer", &wait.slicer.name)]), true);
    } else if ready {
        // The file is already written: open that one, rather than export the design again.
        let mut result = wait.result;
        if let Some(obj) = result.as_object_mut() {
            obj.remove("starting");
            // After a start the file has to reach the instance that is now running, so the flag goes
            // on whatever the preference says (the preference is for a slicer that was already up).
            match wait.slicer.open(&path, true) {
                Ok(()) => obj.insert("slicer".into(), json!(wait.slicer.name)),
                Err(e) => obj.insert("slicer_error".into(), json!(e)),
            };
        }
        report(app, &result);
    } else {
        app.set_status(crate::i18n::format("ui.slicer_no_response", &[("slicer", &wait.slicer.name), ("path", &path)]), true);
    }
}

/// Open the dialog with `format` (`stl`, `3mf` or `3mf-tagged`) chosen, whatever was used last:
/// File › Export STL… and Export 3MF…. The user can still change it in the dialog.
pub fn start_with_format(app: &mut SolveApp, format: &str) {
    app.start("file.save_mesh");
    if let Some(index) = FORMATS.iter().position(|f| f.1 == format)
        && let Some(Kind::SaveMesh(k)) = app.dialog.as_mut().map(|d| &mut d.kind)
    {
        k.format = index;
    }
}

/// A popup with the slicer list is open (Delete belongs to it, not to the design's selection).
pub fn popup_open(ctx: &egui::Context) -> bool {
    let frame = ctx.cumulative_frame_nr();
    let at = ctx.data(|d| d.get_temp::<u64>(egui::Id::unique("sc_slicer_popup")));
    at.is_some_and(|n| n + 1 >= frame)
}

/// The icon of an entry as a texture (`None`: no icon could be read).
fn icon(menu: &mut SlicerMenu, ctx: &egui::Context, e: &Entry) -> Option<egui::TextureId> {
    let tex = menu.icons.entry(e.key.clone()).or_insert_with(|| {
        let bytes = e.slicer.icon.as_ref()?.load()?;
        let img = decode(&bytes)?;
        Some(ctx.load_texture(format!("slicer-icon-{}", e.key), img, egui::TextureOptions::LINEAR))
    });
    tex.as_ref().map(egui::TextureHandle::id)
}

/// An icon file (PNG or ICO) as a small square image.
fn decode(bytes: &[u8]) -> Option<egui::ColorImage> {
    const SIDE: u32 = 48;
    let reader = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().ok()?;
    let (w, h) = reader.into_dimensions().ok()?;
    if w == 0 || h == 0 || w > 4096 || h > 4096 {
        return None;
    }
    let img = image::load_from_memory(bytes).ok()?;
    let small = image::imageops::resize(&img.to_rgba8(), SIDE, SIDE, image::imageops::FilterType::Lanczos3);
    Some(egui::ColorImage::from_rgba_unmultiplied([SIDE as usize, SIDE as usize], small.as_raw()))
}

/// `text` on one line, ending in … when it is wider than `width`.
fn fitted(ui: &egui::Ui, text: &str, width: f32, color: Color32) -> std::sync::Arc<egui::Galley> {
    let mut job = egui::text::LayoutJob::simple_singleline(text.to_string(), egui::FontId::proportional(Tokens::get().font_button), color);
    job.wrap = egui::text::TextWrapping::truncate_at_width(width.max(0.0));
    ui.painter().layout_job(job)
}

/// An icon, or the first letter of the name on a tile when there is none.
fn paint_icon(ui: &egui::Ui, rect: egui::Rect, tex: Option<egui::TextureId>, name: &str) {
    match tex {
        Some(id) => {
            ui.painter().image(id, rect, egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)), Color32::WHITE);
        }
        None => {
            let t = Tokens::get();
            ui.painter().rect_filled(rect, t.radius_sm.saturating_sub(1), t.chip);
            let letter = name.chars().next().map(|c| c.to_uppercase().to_string()).unwrap_or_default();
            ui.painter().text(
                rect.center(),
                egui::Align2::CENTER_CENTER,
                letter,
                egui::FontId::proportional(crate::theme::Tokens::get().font_small),
                t.text,
            );
        }
    }
}

/// Every body of the design, in model order; with `visible`, only the bodies the viewport shows.
pub(crate) fn body_picks(app: &SolveApp, visible: bool) -> Vec<Sel> {
    let st = crate::open_meshing::session_world(&app.session);
    let shown = |name: &str| !visible || app.session.body_visible(name);
    st.bodies.iter().filter(|b| shown(&b.name)).map(|b| Sel::Body { name: b.name.clone() }).collect()
}

/// Keep the Print face input and the design in step: it holds the print face of each body being
/// sent. A face picked into it becomes the print face of its body, in place of the one it had; a
/// face taken out of it clears its body's. When the bodies change, it shows their print faces.
fn sync_print_face(app: &mut SolveApp, k: &mut SaveMesh, inputs: &mut [SelInput]) {
    let bodies = crate::selection::items(inputs, 0).body_names();
    let Some(input) = inputs.get_mut(1) else { return };
    match k.shown.take() {
        Some((shown_bodies, shown)) if shown_bodies == bodies && shown != input.items => {
            let picked = input.items.clone();
            // New faces first: a body picked anew keeps its new face, and is not then cleared
            // because its old one has left the input.
            let mut done: Vec<String> = Vec::new();
            for face in picked.iter().filter(|f| !shown.contains(f)) {
                let Sel::Face { body, .. } = face else { continue };
                if !bodies.contains(body) {
                    app.set_status(crate::i18n::tr("ui.print_face_body_not_sent"), true);
                } else if !done.contains(body) {
                    crate::print_face_ui::set(app, body, Some(face));
                    done.push(body.clone());
                }
            }
            for face in shown.iter().filter(|f| !picked.contains(f)) {
                let Sel::Face { body, .. } = face else { continue };
                if !done.contains(body) {
                    crate::print_face_ui::set(app, body, None);
                    done.push(body.clone());
                }
            }
        }
        Some(shown) if shown.0 == bodies => {
            k.shown = Some(shown);
            return;
        }
        _ => {}
    }
    let current: Vec<Sel> = bodies.iter().filter_map(|b| crate::print_face_ui::current(app, b)).collect();
    input.items = current.clone();
    k.shown = Some((bodies, current));
}

/// The rows after the Bodies input; true when Enter was pressed in a field.
pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut SaveMesh, inputs: &mut [SelInput]) -> bool {
    if k.open {
        sync_print_face(app, k, inputs);
    }
    // One row each: the two side by side do not fit the dialog's width.
    for (label, visible) in [("Add all bodies", false), ("Add visible bodies", true)] {
        form_row(ui, "", |ui| {
            if crate::ui_kit::button(ui, crate::i18n::tr_label(label), crate::ui_kit::Button::Small).clicked()
                && let Some(input) = inputs.first_mut()
            {
                input.items = body_picks(app, visible);
            }
        });
    }
    if !k.open {
        choice_row(ui, "Format", "sm_format", &mut k.format, &FORMATS.map(|f| f.0));
        choice_row(ui, "Quality", "sm_quality", &mut k.quality, &QUALITIES.map(|q| q.0));
        return false;
    }
    if k.stale {
        // Look at the machine once per opening, then settle on a slicer that exists.
        k.stale = false;
        app.slicer_menu.picked = None;
        app.slicer_menu.refresh(&app.preferences.custom_slicers);
        let entries = app.slicer_menu.entries();
        let easyprint = crate::easyprint_ui::available(app);
        k.slicer = if easyprint && k.slicer == EASYPRINT {
            EASYPRINT.into()
        } else {
            app.slicer_menu
                .key_for(&k.slicer)
                .or_else(|| entries.first().map(|e| e.key.clone()))
                .or_else(|| easyprint.then(|| EASYPRINT.to_string()))
                .unwrap_or_default()
        };
    }

    form_row(ui, "Slicer", |ui| {
        if let Some(path) = app.slicer_menu.picked.take() {
            match add_custom(app, &path) {
                Ok(()) => k.slicer = path,
                Err(e) => app.set_status(e, true),
            }
        }
        let choosing = app.file_picker_busy();
        ui.add_enabled_ui(!choosing, |ui| slicer_combo(app, ui, k));
    });
    false
}

fn slicer_combo(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut SaveMesh) {
    let entries = app.slicer_menu.entries();
    let ctx = ui.ctx().clone();
    let current = entries.iter().find(|e| e.key == k.slicer);
    let pad = "\u{2003}\u{2003}";
    let easyprint = crate::easyprint_ui::available(app);
    let easyprint_label = crate::i18n::tr("ui.easyprint_row");
    let text = match current {
        Some(e) => format!("{pad}{}", e.slicer.name),
        None if easyprint && k.slicer == EASYPRINT => format!("{pad}{easyprint_label}"),
        None => crate::i18n::tr_label("No slicer found").to_string(),
    };
    let mut pick_custom = false;
    let mut delete: Option<String> = None;
    let mut chosen: Option<String> = None;
    let name = current.map(|e| e.slicer.name.clone());
    // A long name ends in … instead of wrapping onto a second line; the full one is in the tooltip.
    let wrap = ui.style().wrap_mode;
    ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
    let r = crate::ui_kit::dropdown_menu(ui, "sm_slicer", &text, |ui| {
        let frame = ctx.cumulative_frame_nr();
        ctx.data_mut(|d| d.insert_temp(egui::Id::unique("sc_slicer_popup"), frame));
        for e in &entries {
            let tex = icon(&mut app.slicer_menu, &ctx, e);
            let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
            let selected = e.key == k.slicer;
            if resp.hovered() || selected {
                let fill = if resp.hovered() { Tokens::get().hover } else { Tokens::get().selected_bg };
                ui.painter().rect_filled(rect, Tokens::get().radius_sm / 2, fill);
            }
            paint_icon(ui, egui::Rect::from_min_size(rect.left_center() + vec2(3.0, -ICON / 2.0), vec2(ICON, ICON)), tex, &e.slicer.name);
            let text = fitted(ui, &e.slicer.name, rect.width() - (ICON + 9.0) - 6.0, Tokens::get().text);
            let (elided, at) = (text.elided, rect.left_center() + vec2(ICON + 9.0, -text.size().y / 2.0));
            ui.painter().galley(at, text, Tokens::get().text);
            crate::scenario::publish_handle(&format!("dialog:Slicer:{}", e.slicer.name), rect.center());
            if e.user {
                let hint = crate::i18n::format("ui.slicer_delete_tip", &[("program", e.slicer.command.first().map_or("", String::as_str))]);
                resp.clone().backing_on_hover_text(if elided { format!("{}\n{hint}", e.slicer.name) } else { hint });
                if resp.hovered() && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Delete)) {
                    delete = Some(e.key.clone());
                }
            } else if elided {
                resp.clone().backing_on_hover_text(&e.slicer.name);
            }
            if resp.clicked() {
                chosen = Some(e.key.clone());
                ui.close();
            }
        }
        if easyprint {
            let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
            if resp.hovered() || k.slicer == EASYPRINT {
                let fill = if resp.hovered() { Tokens::get().hover } else { Tokens::get().selected_bg };
                ui.painter().rect_filled(rect, 2.0, fill);
            }
            let text = fitted(ui, easyprint_label, rect.width() - (ICON + 9.0) - 6.0, Tokens::get().text);
            ui.painter().galley(rect.left_center() + vec2(ICON + 9.0, -text.size().y / 2.0), text, Tokens::get().text);
            crate::scenario::publish_handle("dialog:Slicer:EasyPrint", rect.center());
            if resp.clicked() {
                chosen = Some(EASYPRINT.to_string());
                ui.close();
            }
        }
        if !entries.is_empty() || easyprint {
            ui.separator();
        }
        // A browser has no program to add.
        if app.services.pick_program.is_none() {
            return;
        }
        let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
        if resp.hovered() {
            ui.painter().rect_filled(rect, Tokens::get().radius_sm / 2, Tokens::get().hover);
        }
        ui.painter().text(
            rect.left_center() + vec2(ICON + 9.0, 0.0),
            egui::Align2::LEFT_CENTER,
            crate::i18n::tr_label("Custom…"),
            egui::FontId::proportional(crate::theme::Tokens::get().font_button),
            Tokens::get().text,
        );
        crate::scenario::publish_handle("dialog:Slicer:Custom", rect.center());
        if resp.backing_on_hover_text(crate::i18n::tr("ui.custom_program_tip")).clicked() {
            pick_custom = true;
            ui.close();
        }
    });
    ui.style_mut().wrap_mode = wrap;
    if let Some(name) = name {
        r.clone().backing_on_hover_text(name);
    }
    if let Some(e) = current {
        let tex = icon(&mut app.slicer_menu, &ctx, e);
        let rect = r.rect;
        let at = egui::Rect::from_min_size(rect.left_center() + vec2(ui.spacing().button_padding.x + 1.0, -ICON / 2.0), vec2(ICON, ICON));
        paint_icon(ui, at, tex, &e.slicer.name);
    }
    if let Some(key) = chosen {
        k.slicer = key;
    }
    if let Some(key) = delete {
        app.preferences.custom_slicers.retain(|p| *p != key);
        app.slicer_menu.set_custom(&app.preferences.custom_slicers);
        if k.slicer == key {
            k.slicer = app.slicer_menu.entries().first().map(|e| e.key.clone()).unwrap_or_default();
        }
    }
    if pick_custom {
        // Closing the file dialog without a program leaves the choice as it was.
        app.pick_program(|app, path| app.slicer_menu.picked = path);
    }
}

/// Put a program the user picked at the top of the list (and keep it).
fn add_custom(app: &mut SolveApp, path: &str) -> Result<(), String> {
    if slicers::custom(path).is_none() {
        return Err(crate::i18n::format("ui.not_a_program", &[("path", path)]));
    }
    let list = &mut app.preferences.custom_slicers;
    list.retain(|p| p != path);
    list.insert(0, path.to_string());
    list.truncate(MAX_CUSTOM);
    app.slicer_menu.set_custom(&app.preferences.custom_slicers);
    Ok(())
}

/// What the Save (or Send) button asks `file.save_mesh` or `file.send_to_slicer` to do; Save is
/// without the file name.
pub fn commands(k: &SaveMesh, inputs: &[SelInput]) -> Result<Vec<(String, Value)>, String> {
    let format = FORMATS.get(k.format).map_or("stl", |f| f.1);
    let mut p = json!({ "format": format });
    // Standard is the command's own default, so it is left out. Sending has no quality row.
    if let Some((_, quality)) = QUALITIES.get(k.quality).filter(|_| k.quality > 0 && !k.open) {
        p["quality"] = json!(quality);
    }
    let names = crate::selection::items(inputs, 0).body_names();
    if names.is_empty() {
        return Err(crate::i18n::tr("ui.save_mesh_pick_bodies").into());
    }
    p["bodies"] = json!(names);
    if k.open {
        if k.slicer.is_empty() {
            return Err(crate::i18n::tr("ui.save_mesh_no_slicer_open").into());
        }
        p["format"] = json!("3mf");
        if k.slicer == EASYPRINT {
            return Ok(vec![("file.open_in_easyprint".into(), p)]);
        }
        p["slicer"] = json!(k.slicer);
        return Ok(vec![("file.send_to_slicer".into(), p)]);
    }
    Ok(vec![("file.save_mesh".into(), p)])
}

/// Save and Send need at least one body.
pub fn ready(inputs: &[SelInput]) -> bool {
    !crate::selection::items(inputs, 0).body_names().is_empty()
}

/// The command the dialog is for: its name is the dialog's title.
pub fn command_id(k: &SaveMesh) -> &'static str {
    if k.open { "file.send_to_slicer" } else { "file.save_mesh" }
}

/// The button's label: Save, or Send when the file goes to a slicer.
pub fn button(k: &SaveMesh) -> &'static str {
    if k.open { "Send" } else { "Save" }
}

/// Save: ask for a file name and write the file. Send: write it to the slicer folder and start the
/// slicer with it, with no file dialog.
pub fn run(app: &mut SolveApp, k: &SaveMesh, inputs: &[SelInput]) -> Result<(), String> {
    let (_, params) = commands(k, inputs)?.into_iter().next().ok_or("nothing to save")?;
    if k.open {
        app.preferences.send_slicer = k.slicer.clone();
        if k.slicer == EASYPRINT {
            crate::easyprint_ui::request(app, params);
        } else {
            send_to_slicer(app, params);
        }
        return Ok(());
    }
    let (format, ext) = FORMATS.get(k.format).map_or(("stl", "stl"), |f| (f.1, f.2));
    let name = crate::selection::items(inputs, 0).body_names().first().cloned().unwrap_or_else(|| app.session.doc.name.clone());
    app.preferences.save_mesh_format = format.into();
    app.preferences.save_mesh_quality = QUALITIES.get(k.quality).map_or("standard", |q| q.1).into();
    // The file dialog answers later; the dialog closes meanwhile, as for every export.
    app.pick_save(&format!("{name}.{ext}"), &[ext], move |app, path| {
        if let Some(path) = path {
            save(app, params, &path);
        }
    });
    Ok(())
}

/// Run `file.save_mesh` into `path` and report what happened.
fn save(app: &mut SolveApp, mut params: Value, path: &str) {
    // Runs from the file picker's answer, outside the frame's language scope.
    let _language = crate::i18n::scope(&app.preferences.language);
    params["path"] = json!(path);
    let Ok(result) = app.run("file.save_mesh", params) else { return };
    report(app, &result);
}

/// The status line after a save or a send.
fn report(app: &mut SolveApp, result: &Value) {
    let path = result.get("path").and_then(Value::as_str).unwrap_or_default();
    match result.get("slicer_error").and_then(Value::as_str) {
        Some(e) => app.set_status(e.to_string(), true),
        None => match result.get("slicer").and_then(Value::as_str) {
            Some(s) => {
                let mut line = match (result.get("numbered").and_then(Value::as_bool), std::path::Path::new(path).file_name()) {
                    (Some(true), Some(file)) => crate::i18n::format("ui.sent_to_slicer_copy", &[("slicer", s), ("file", &file.to_string_lossy())]),
                    _ => crate::i18n::format("ui.sent_to_slicer", &[("slicer", s)]),
                };
                // Said once: sending the same bodies again overwrites the file the slicer has open.
                if result.get("numbered").is_some() && !std::mem::replace(&mut app.preferences.slicer_resend_hint_seen, true) {
                    line = format!("{line}. {}", crate::i18n::tr("ui.slicer_resend_hint"));
                }
                if result.get("stl_fallback").and_then(Value::as_bool) == Some(true) {
                    line = format!("{line}. {}", crate::i18n::tr("ui.slicer_stl_fallback"));
                }
                app.set_status(line, false);
            }
            None => app.set_status(crate::i18n::format("ui.saved_to", &[("path", path)]), false),
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use solidcraft_engine::Sel;

    #[test]
    fn without_a_program_dialog_send_to_slicer_is_unavailable_and_starts_nothing() {
        let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
        assert!(app.services.pick_program.is_none());
        assert!(!available(&app));
        app.preferences.send_slicer = "prusa".into();
        app.start("file.send_to_slicer");
        assert!(app.dialog.is_none(), "no dialog to choose a slicer in");
        assert!(matches!(&app.status, Some((_, _, true))));
        app.services.pick_program = Some(Box::new(|| Box::pin(async { None })));
        assert!(available(&app));
    }

    /// An app with a box in it, `fake-slicer` (a script that writes its arguments to `seen`) among the
    /// user's programs, and the parameters Send to Slicer would send.
    #[cfg(unix)]
    fn app_with_fake_slicer(tag: &str) -> (SolveApp, std::path::PathBuf, Value) {
        use std::os::unix::fs::PermissionsExt;
        let dir = std::env::temp_dir().join(format!("solidcraft-slicer-wait-{tag}-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).unwrap();
        let (script, seen) = (dir.join("fake-slicer"), dir.join("seen"));
        std::fs::write(&script, format!("#!/bin/sh\necho \"$@\" >> {}\n", seen.display())).unwrap();
        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
        let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
        app.run("solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Part"})).unwrap();
        app.preferences.custom_slicers = vec![script.to_string_lossy().into_owned()];
        let params = json!({"slicer": script, "bodies": ["Part"], "wait": "no"});
        (app, seen, params)
    }

    #[cfg(unix)]
    fn sent(seen: &std::path::Path) -> usize {
        for _ in 0..100 {
            if seen.exists() && std::fs::metadata(seen).map(|m| m.len() > 0).unwrap_or(false) {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(30));
        }
        std::fs::read_to_string(seen).map(|t| t.lines().count()).unwrap_or(0)
    }

    #[cfg(unix)]
    #[test]
    fn the_menu_entries_always_ask_and_a_script_with_a_slicer_does_not() {
        let (mut app, seen, mut params) = app_with_fake_slicer("ask");
        app.services.pick_program = Some(Box::new(|| Box::pin(async { None })));
        app.run("select.set", json!({"items": [{"type": "body", "name": "Part"}]})).unwrap();
        // Last time's slicer is remembered and bodies are selected: still the picker, with it pre-selected.
        let key = params["slicer"].as_str().unwrap().to_string();
        app.preferences.send_slicer = key.clone();
        app.start("file.send_to_slicer");
        let Some(Kind::SaveMesh(k)) = app.dialog.as_ref().map(|d| d.kind.clone()) else { panic!("no picker opened") };
        assert!(k.open);
        assert_eq!(k.slicer, key, "pre-selected");
        assert!(!seen.exists(), "nothing sent until the user confirms");
        // A script names the slicer: no dialog, the file goes.
        app.dialog = None;
        params["wait"] = json!("no");
        app.run("file.send_to_slicer", params).unwrap();
        assert!(app.dialog.is_none());
        assert_eq!(sent(&seen), 1);
        let _ = std::fs::remove_dir_all(seen.parent().unwrap());
        solidcraft_engine::slicers::set_chosen_programs(&[]);
    }

    #[cfg(unix)]
    #[test]
    fn a_started_slicer_is_waited_for_and_then_sent_the_file_once() {
        let ctx = egui::Context::default();
        let (mut app, seen, params) = app_with_fake_slicer("ready");
        // Ready on the third look; a second click while it waits starts and sends nothing.
        let mut looks = 0;
        let done = spawn_wait(
            move |_| {
                looks += 1;
                looks == 3
            },
            std::time::Duration::from_secs(5),
            std::time::Duration::from_millis(5),
        );
        let slicer = slicers::custom(params["slicer"].as_str().unwrap()).unwrap();
        app.slicer_wait = Some(SlicerWait { done, slicer, result: json!({"path": "/p"}) });
        send_to_slicer(&mut app, params);
        assert!(app.slicer_wait.is_some(), "still the one wait");
        let status = app.status.clone().unwrap();
        assert!(!status.2 && status.0.contains("Still waiting") && status.0.contains("Nothing else was sent"), "{status:?}");
        assert!(status.0.contains(&app.slicer_wait.as_ref().unwrap().slicer.name), "names the slicer being waited for: {status:?}");
        assert!(!seen.exists(), "the second click sent nothing");
        for _ in 0..200 {
            tick_wait(&mut app, &ctx);
            if app.slicer_wait.is_none() {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
        }
        assert!(app.slicer_wait.is_none());
        assert_eq!(sent(&seen), 1, "one send");
        assert!(app.status.as_ref().is_some_and(|(_, _, error)| !*error), "{:?}", app.status);
        let _ = std::fs::remove_dir_all(seen.parent().unwrap());
        solidcraft_engine::slicers::set_chosen_programs(&[]);
    }

    #[test]
    fn a_started_slicer_that_can_not_be_found_again_is_reported() {
        let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
        let result = json!({"starting": "Ghost Slicer", "path": "/tmp/part.3mf"});
        begin_wait(&mut app, json!({"slicer": "no such slicer anywhere", "bodies": ["Part"]}), &result);
        assert!(app.slicer_wait.is_none());
        let status = app.status.clone().unwrap();
        assert!(status.2 && status.0.contains("Ghost Slicer") && status.0.contains("/tmp/part.3mf"), "{status:?}");
    }

    #[cfg(unix)]
    #[test]
    fn the_file_that_was_written_is_sent_whatever_happens_to_the_design_meanwhile() {
        let ctx = egui::Context::default();
        let (mut app, seen, params) = app_with_fake_slicer("same-file");
        let dir = seen.parent().unwrap().to_path_buf();
        let file = dir.join("part.3mf");
        std::fs::write(&file, b"as exported").unwrap();
        let slicer = slicers::custom(params["slicer"].as_str().unwrap()).unwrap();
        let done = spawn_wait(|_| true, std::time::Duration::from_secs(5), std::time::Duration::from_millis(5));
        let result = json!({"path": file, "numbered": false, "starting": slicer.name});
        app.slicer_wait = Some(SlicerWait { done, slicer, result });
        // The design changes while the slicer starts: a body is added and the first one removed.
        app.run("solid.box", json!({"length": 5, "width": 5, "height": 5, "body_name": "Late", "operation": "new"})).unwrap();
        app.run("solid.remove", json!({"bodies": ["Part"]})).unwrap();
        let revision = app.session.revision;
        for _ in 0..200 {
            tick_wait(&mut app, &ctx);
            if app.slicer_wait.is_none() {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
        }
        assert_eq!(sent(&seen), 1);
        assert_eq!(std::fs::read_to_string(&seen).unwrap().trim(), file.to_string_lossy(), "the file already written");
        assert_eq!(std::fs::read(&file).unwrap(), b"as exported", "not written again");
        assert_eq!(app.session.revision, revision, "no command ran for the send");
        let mut names: Vec<String> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
        names.sort();
        assert_eq!(names, ["fake-slicer", "part.3mf", "seen"], "no second file");
        assert!(app.status.as_ref().is_some_and(|(m, _, error)| !*error && m.contains("Sent")), "{:?}", app.status);
        let _ = std::fs::remove_dir_all(dir);
        solidcraft_engine::slicers::set_chosen_programs(&[]);
    }

    #[cfg(unix)]
    #[test]
    fn the_launcher_gets_the_flag_on_a_send_and_after_a_start_even_when_the_preference_is_off() {
        use std::os::unix::fs::PermissionsExt;
        let ctx = egui::Context::default();
        let dir = std::env::temp_dir().join(format!("solidcraft-slicer-flag-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&dir);
        // The launcher is recognised by its command, and PrusaSlicer by its name.
        let folder = dir.join("slic3r-app-launcher");
        std::fs::create_dir_all(&folder).unwrap();
        let (script, seen) = (folder.join("PrusaSlicer"), dir.join("seen"));
        std::fs::write(&script, format!("#!/bin/sh\necho \"$@\" >> {}\n", seen.display())).unwrap();
        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
        let mut app = SolveApp::new(solidcraft_engine::Session::default(), Default::default());
        app.run("solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Part"})).unwrap();
        let spec = script.to_string_lossy().into_owned();
        app.preferences.custom_slicers = vec![spec.clone()];
        app.preferences.slicer_single_instance = false;
        // A normal send with the preference off: this launcher still gets the flag, it can't hand a file over without.
        app.run("file.send_to_slicer", json!({"slicer": spec, "bodies": ["Part"], "wait": "no", "single_instance": false})).unwrap();
        assert_eq!(sent(&seen), 1);
        assert!(std::fs::read_to_string(&seen).unwrap().starts_with("--single-instance "), "{:?}", std::fs::read_to_string(&seen));
        // The send that follows a start: the flag, preference or not.
        let slicer = slicers::custom(&spec).unwrap();
        assert!(slicer.waits_for_ready().is_some());
        let done = spawn_wait(|_| true, std::time::Duration::from_secs(5), std::time::Duration::from_millis(5));
        app.slicer_wait = Some(SlicerWait { done, slicer, result: json!({"path": "/tmp/part.3mf"}) });
        for _ in 0..200 {
            tick_wait(&mut app, &ctx);
            if app.slicer_wait.is_none() {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
        }
        for _ in 0..100 {
            if std::fs::read_to_string(&seen).map(|t| t.lines().count()).unwrap_or(0) >= 2 {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(30));
        }
        assert_eq!(sent(&seen), 2);
        let second = std::fs::read_to_string(&seen).unwrap().lines().nth(1).unwrap().to_string();
        assert_eq!(second, "--single-instance /tmp/part.3mf");
        let _ = std::fs::remove_dir_all(dir);
        solidcraft_engine::slicers::set_chosen_programs(&[]);
    }

    #[cfg(unix)]
    #[test]
    fn a_ready_slicer_with_no_file_to_send_is_reported_and_nothing_is_started() {
        let ctx = egui::Context::default();
        let (mut app, seen, params) = app_with_fake_slicer("nofile");
        let slicer = slicers::custom(params["slicer"].as_str().unwrap()).unwrap();
        let done = spawn_wait(|_| true, std::time::Duration::from_secs(5), std::time::Duration::from_millis(5));
        app.slicer_wait = Some(SlicerWait { done, slicer, result: json!({"starting": "Fake"}) });
        for _ in 0..200 {
            tick_wait(&mut app, &ctx);
            if app.slicer_wait.is_none() {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
        }
        assert!(app.slicer_wait.is_none());
        let status = app.status.clone().unwrap();
        assert!(status.2 && status.0.contains("no file"), "{status:?}");
        std::thread::sleep(std::time::Duration::from_millis(100));
        assert!(!seen.exists(), "the slicer was not started with an empty path");
        let _ = std::fs::remove_dir_all(seen.parent().unwrap());
        solidcraft_engine::slicers::set_chosen_programs(&[]);
    }

    #[cfg(unix)]
    #[test]
    fn a_slicer_that_never_comes_up_is_reported_and_nothing_is_sent() {
        let ctx = egui::Context::default();
        let (mut app, seen, params) = app_with_fake_slicer("late");
        let done = spawn_wait(|_| false, std::time::Duration::from_millis(30), std::time::Duration::from_millis(5));
        let slicer = slicers::custom(params["slicer"].as_str().unwrap()).unwrap();
        app.slicer_wait = Some(SlicerWait { done, slicer, result: json!({"path": "/tmp/part.3mf"}) });
        for _ in 0..400 {
            tick_wait(&mut app, &ctx);
            if app.slicer_wait.is_none() {
                break;
            }
            std::thread::sleep(std::time::Duration::from_millis(5));
        }
        assert!(app.slicer_wait.is_none());
        let status = app.status.clone().unwrap();
        assert!(status.2 && status.0.contains("/tmp/part.3mf"), "{status:?}");
        assert!(!seen.exists());
        let _ = std::fs::remove_dir_all(seen.parent().unwrap());
    }

    #[test]
    fn a_long_slicer_name_is_cut_with_an_ellipsis_to_fit_its_row() {
        let ctx = egui::Context::default();
        let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
            let long = "PrusaSlicer (Flatpak, master, a rather long install label)";
            let galley = fitted(ui, long, 120.0, Color32::WHITE);
            assert!(galley.elided, "does not fit, so it is cut");
            assert!(galley.size().x <= 120.0 + 0.5, "{}", galley.size().x);
            assert_eq!(galley.rows.len(), 1, "one line");
            let short = fitted(ui, "OrcaSlicer", 120.0, Color32::WHITE);
            assert!(!short.elided && short.size().x <= 120.0);
        });
        output.textures_delta.clear();
    }

    #[test]
    fn a_remembered_install_that_is_gone_falls_back_to_the_same_slicer() {
        let prusa = |id: &str| slicers::Slicer {
            id: id.into(),
            name: "PrusaSlicer".into(),
            command: vec!["prusa-slicer".into()],
            icon: None,
            prusa_major: None,
        };
        let orca =
            slicers::Slicer { id: "orca".into(), name: "OrcaSlicer".into(), command: vec!["orca-slicer".into()], icon: None, prusa_major: None };
        let menu = |detected: Vec<slicers::Slicer>| SlicerMenu { detected, ..Default::default() };
        // Two installs when it was remembered, one (now plain) left.
        let lone = menu(vec![orca.clone(), prusa("prusa")]);
        assert_eq!(lone.key_for("prusa#prusaslicer").as_deref(), Some("prusa"));
        assert_eq!(lone.key_for("prusa").as_deref(), Some("prusa"));
        // Remembered plain, now two: which of them was meant is not known, so none is taken; an exact key is itself.
        let two = menu(vec![prusa("prusa#a"), prusa("prusa#b")]);
        assert_eq!(two.key_for("prusa"), None);
        assert_eq!(two.key_for("prusa#b").as_deref(), Some("prusa#b"));
        // An AppImage remembered when it was alone, now two versions side by side: not remembered.
        let side_by_side = menu(vec![prusa("prusa#appimage-1f-prusaslicer29"), prusa("prusa#appimage-1f-prusaslicer210")]);
        assert_eq!(side_by_side.key_for("prusa#appimage-1f"), None);
        // And after an upgrade, the id is the same and is found.
        assert_eq!(menu(vec![prusa("prusa#appimage-1f")]).key_for("prusa#appimage-1f").as_deref(), Some("prusa#appimage-1f"));
        // A different slicer is never picked for it.
        assert_eq!(menu(vec![orca]).key_for("prusa#x"), None);
    }

    #[test]
    fn send_to_slicer_asks_for_bodies_and_a_slicer_but_not_a_format() {
        let k = SaveMesh { format: 0, quality: 0, open: true, slicer: "prusa".into(), stale: false, shown: None };
        let mut input = SelInput::new("Bodies", BODIES, true);
        assert!(commands(&k, std::slice::from_ref(&input)).is_err());
        input.items = vec![Sel::Body { name: "Part".into() }];
        let cmds = commands(&k, std::slice::from_ref(&input)).unwrap();
        assert_eq!(cmds, [("file.send_to_slicer".to_string(), json!({"slicer": "prusa", "bodies": ["Part"], "format": "3mf"}))]);
        // Save as mesh is a plain export in the chosen format: no slicer in it, whatever was set.
        let save = SaveMesh { format: 2, open: false, slicer: "prusa".into(), ..k.clone() };
        let (id, p) = commands(&save, std::slice::from_ref(&input)).unwrap().remove(0);
        assert_eq!((id.as_str(), p["format"].as_str(), p.get("slicer")), ("file.save_mesh", Some("3mf-tagged"), None));
        assert_eq!(button(&save), "Save");
        assert_eq!(button(&k), "Send");
        assert!(commands(&SaveMesh { slicer: String::new(), ..k }, &[input]).is_err());
    }

    #[test]
    fn a_remembered_quality_goes_to_save_but_not_to_send() {
        let mut input = SelInput::new("Bodies", BODIES, true);
        input.items = vec![Sel::Body { name: "Part".into() }];
        let k = SaveMesh { format: 0, quality: 2, open: true, slicer: "prusa".into(), stale: false, shown: None };
        let (_, sent) = commands(&k, std::slice::from_ref(&input)).unwrap().remove(0);
        assert_eq!(sent.get("quality"), None, "sending has no quality row: the default applies");
        let (_, saved) = commands(&SaveMesh { open: false, ..k }, &[input]).unwrap().remove(0);
        assert_eq!(saved["quality"], "finest");
    }

    #[test]
    fn the_print_face_input_takes_one_face_for_each_body_sent() {
        let mut h = crate::scenario::Harness::new();
        for (name, x) in [("One", 0), ("Two", 20)] {
            h.app.run("solid.box", json!({"length":10,"width":10,"height":10,"corner":[x,0,0],"operation":"new_body","body_name":name})).unwrap();
        }
        h.app.services.pick_program = Some(Box::new(|| Box::pin(async { None })));
        h.app.start("file.send_to_slicer");
        let all = body_picks(&h.app, false);
        h.app.dialog.as_mut().unwrap().inputs[0].items = all;
        h.settle();
        // A click on the face of `body` at `point` in the Print face input; that face's index.
        let pick = |h: &mut crate::scenario::Harness, body: &str, point: [f64; 3]| {
            let p = solidcore_record::Vec3::new(point[0], point[1], point[2]);
            let index = solidcraft_engine::doc::appearance::face_index_at(h.app.session.world_state().unwrap().body(body).unwrap(), p).unwrap();
            let d = h.app.dialog.as_mut().unwrap();
            d.active = 1;
            d.pick(&h.app.session, Sel::Face { body: body.into(), index, point: p });
            h.settle();
            index
        };
        let shown = |h: &crate::scenario::Harness| h.app.dialog.as_ref().unwrap().inputs[1].items.len();
        let one_bottom = pick(&mut h, "One", [5.0, 5.0, 0.0]);
        let two_bottom = pick(&mut h, "Two", [25.0, 5.0, 0.0]);
        assert!(crate::print_face_ui::is_print_face(&h.app, "One", one_bottom));
        assert!(crate::print_face_ui::is_print_face(&h.app, "Two", two_bottom), "a second body takes its own face");
        assert_eq!(shown(&h), 2);
        // Another face of One takes the place of its first; Two keeps its own.
        let one_top = pick(&mut h, "One", [5.0, 5.0, 10.0]);
        assert!(crate::print_face_ui::is_print_face(&h.app, "One", one_top));
        assert!(crate::print_face_ui::is_print_face(&h.app, "Two", two_bottom));
        assert_eq!(shown(&h), 2);
        // A click on a body's print face takes it out, and clears only that body's.
        pick(&mut h, "One", [5.0, 5.0, 10.0]);
        assert!(crate::print_face_ui::current(&h.app, "One").is_none());
        assert!(crate::print_face_ui::is_print_face(&h.app, "Two", two_bottom));
        assert_eq!(shown(&h), 1);
        // Each change is a command of its own.
        h.app.run("edit.undo", json!({})).unwrap();
        assert!(crate::print_face_ui::is_print_face(&h.app, "One", one_top));
        // With Two alone sent, the input shows its face; a face of One, not sent, is refused.
        h.app.dialog.as_mut().unwrap().inputs[0].items = vec![Sel::Body { name: "Two".into() }];
        h.settle();
        assert_eq!(h.app.dialog.as_ref().unwrap().inputs[1].items.len(), 1);
        pick(&mut h, "One", [5.0, 5.0, 0.0]);
        assert!(crate::print_face_ui::is_print_face(&h.app, "One", one_top), "One is not being sent: its print face stays");
        assert!(matches!(&h.app.status, Some((_, _, true))));
        assert_eq!(shown(&h), 1);
    }
}