SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! 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);
}
}