Files
solidcraft/crates/ui-egui/src/control.rs
T
PaddleStroke 22f8da2689 View: hold a shortcut to drag and zoom (#11701) (#11706)
* claim: #11701

* Allow assigned shortcuts to drag the view to zoom
2026-11-05 22:08:53 +00:00

3178 lines
169 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Programmatic control of the running app (agents, tests).
//!
//! Methods (JSON lines over the host's transport, `{"id", "method", "params"}`):
//! - `engine.execute {command, params}`: run any command with JSON parameters (no dialogs)
//! - `engine.script {commands: [...]}`: run a command script
//! - `engine.batch {commands: [...], rollback?}`: the steps in one request, each as
//! `engine.execute` runs it; stops at the first failure and goes back to the checkpoint
//! (per-step results, `failed`, `undone`, `rolled_back`). Refused (`engine.batch unavailable: …`)
//! when a step loads a file; with the agent cursor shown, the pointer acts out a short summary
//! of it first
//! - `engine.commands`: every command with tab, panel, params and enablement
//! - `document.inspect {measure?}`: the design (parameters, timeline, bodies, sketches)
//! - `document.export`, `document.import {text, name?}`, `document.saved {revision}`: the design
//! for a host that keeps the files itself (#8517)
//! - `ui.inspect`: UI state, viewport rect, camera, tool and dialog
//! - `ui.drag {x0, y0, x1, y1, button?, shift?, ctrl?, steps?, hold?}` (box selection, navigation;
//! `hold` keeps the button down that many frames before moving);
//! `ui.selection` (selection, dialog inputs, hover, drawn sketch dimensions);
//! `ui.sketchToScreen {points: [[x,y]…]}` (screen points of active-sketch coordinates); `ui.editFeature {feature}` (edit dialog)
//! - `ui.set {...UiState fields}`; `ui.view {view: front|back|top|bottom|left|right|iso|home|fit, animate?: bool}` (snaps unless animate)
//! - `ui.start {command}`: like clicking the toolbar button (starts tools/dialogs)
//! - `ui.click {x, y, button?, shift?}`, `ui.move {x, y}`: real
//! pointer input in screen points; `ui.scroll {x, y, delta}`: mouse-wheel input in
//! points (zooms); `ui.key {key, cmd?, shift?}`, `ui.text {text}`
//! - `ui.screenshot {path?}`: PNG of the window; `ui.render {path, width?, height?, grid?, axes?}`:
//! headless CPU render of the model with the current camera, in the window's theme, with the
//! section the viewport shows (no window needed); the ground grid and the origin's axes as the
//! window shows them, unless `grid` or `axes` says
//! - `ui.icon_audit {reset?, stop?}`: collect/drain requested icon names, resolved masters and placeholder flags;
//! - `ui.panel_fixture {enabled?, preset?}`: opt-in synthetic content in the real panel host;
//! `{}` observes the current host, probe and Session without ticking or model commands
//! - `ui.menu {x?, y?, target?, close?}`: open a context menu at a point (the viewport's marking
//! menu, or a browser menu with `target: {type: body|sketch|component, …}`); without a point,
//! the open menu and its items. `ui.menuPick {item}` runs an item by id or label;
//! `ui.rename {text?, commit?}` finishes the rename box
//! - `ui.window {action: minimize|maximize|restore|toggle|close}`: what the title bar's buttons do
//! - `ui.confirm {accept?}`: the Delete confirmation (without `accept`: what it lists)
//! - `ui.shortcut {command, key?, slot?, replace?}`: a command's keys, or bind one ("" clears)
//! - `ui.help {item?: about|updates|shortcuts|report}`: the Help menu; returns the version and diagnostics
//! - `ui.prefs {...}`: the preferences (default_units, nav, zoom_reverse, orbit_around, msaa,
//! length_decimals, angle_decimals); returns them all
//! - `ui.capture {action?: capture|revert|cancel}`: the Capture Position question
//! - `ui.agent_cursor {show?, speed?: 1–5 (times) | "instant", follow_camera?}`: the agent cursor
//! (#35); while it is shown, `engine.execute` first glides to the command's button and picks
//! and replies once the command has run (`"animate": false` skips that one call)
//! - `ui.resize {width, height}`, `app.quit`
use solidcraft_engine::geom::prelude::*;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::mpsc::Sender;
use std::sync::{Condvar, Mutex, MutexGuard, PoisonError};
use std::time::Duration;
use serde_json::{Value, json};
use solidcraft_engine::io::vfs;
use solidcraft_engine::render::{Camera, StandardView};
use solidcraft_engine::schema::ParamCheck;
use solidcraft_engine::{batch_params, timing};
use crate::SolveApp;
pub type ControlResponse = Value;
pub struct ControlRequest {
pub method: String,
pub params: Value,
pub reply: Sender<ControlResponse>,
/// Set once the window starts on it; until then it waits its turn (`control.running`, #3654).
pub started: std::sync::Arc<std::sync::atomic::AtomicBool>,
/// Chat requests already admitted by the gate may outlive a tab switch. This turn's
/// validity follows them through queues, computation and cursor animation.
pub(crate) chat_turn: Option<std::sync::Arc<std::sync::atomic::AtomicBool>>,
}
impl ControlRequest {
pub fn new(method: impl Into<String>, params: Value) -> (Self, std::sync::mpsc::Receiver<ControlResponse>) {
let (tx, rx) = std::sync::mpsc::channel();
(Self { method: method.into(), params, reply: tx, started: Default::default(), chat_turn: None }, rx)
}
pub(crate) fn refuse_cancelled_chat(&self) -> bool {
if chat_turn_cancelled(self.chat_turn.as_deref()) {
let _ = self.reply.send(cancelled_chat_response());
true
} else {
false
}
}
}
pub(crate) fn chat_turn_cancelled(turn: Option<&std::sync::atomic::AtomicBool>) -> bool {
turn.is_some_and(|active| !active.load(std::sync::atomic::Ordering::Relaxed))
}
pub(crate) fn cancelled_chat_response() -> Value {
json!({"ok": false, "error": "not run: the agent chat turn ended or its document tab was left"})
}
/// The active design's id and revision for control connections that sent `control.subscribe`
/// (#6985): the window publishes them each frame while one is subscribed, and each such
/// connection waits for them to move, then sends a `design.changed` line.
#[derive(Default)]
pub struct DesignWatch {
subscribers: AtomicUsize,
now: Mutex<Option<(String, u64)>>,
moved: Condvar,
}
/// The app's [`DesignWatch`].
pub static DESIGN_WATCH: DesignWatch = DesignWatch::new();
impl DesignWatch {
pub const fn new() -> Self {
DesignWatch { subscribers: AtomicUsize::new(0), now: Mutex::new(None), moved: Condvar::new() }
}
fn now(&self) -> MutexGuard<'_, Option<(String, u64)>> {
self.now.lock().unwrap_or_else(PoisonError::into_inner)
}
/// The design as it is now; waiters wake only when it moved. Only the latest is kept, so
/// changes made faster than a connection sends them go out as one.
pub fn publish(&self, document_id: &str, revision: u64) {
let mut now = self.now();
if now.as_ref().is_some_and(|(id, r)| id == document_id && *r == revision) {
return;
}
*now = Some((document_id.to_string(), revision));
self.moved.notify_all();
}
/// Whether a connection is subscribed: the window publishes only then.
pub fn subscribed(&self) -> bool {
self.subscribers.load(Ordering::Relaxed) > 0
}
/// Count a subscribed connection until the returned guard is dropped.
pub fn join(&'static self) -> Subscriber {
self.subscribers.fetch_add(1, Ordering::Relaxed);
Subscriber(self)
}
/// Wait up to `wait` for the design to differ from `seen`, or for `stop`; the design then
/// (`None` before anything was published).
pub fn wait(&self, seen: &(String, u64), stop: &AtomicBool, wait: Duration) -> Option<(String, u64)> {
let unmoved = |now: &mut Option<(String, u64)>| now.as_ref() == Some(seen) && !stop.load(Ordering::Relaxed);
let (now, _) = self.moved.wait_timeout_while(self.now(), wait, unmoved).unwrap_or_else(PoisonError::into_inner);
now.clone()
}
}
/// A subscribed connection, counted by its [`DesignWatch`] while this lives.
pub struct Subscriber(&'static DesignWatch);
impl Drop for Subscriber {
fn drop(&mut self) {
self.0.subscribers.fetch_sub(1, Ordering::Relaxed);
// Under the lock, so a connection about to wait sees its `stop` set before it does.
let _now = self.0.now();
self.0.moved.notify_all();
}
}
/// Publish the active design for subscribed connections ([`DesignWatch`]). Called at the end of
/// each frame's logic (which runs while the window is hidden too) and of its drawing, so a
/// change made in either goes out in that frame.
pub(crate) fn publish_design(app: &mut SolveApp, watch: &DesignWatch) {
if watch.subscribed() {
let revision = app.session.design_revision();
watch.publish(&app.session.document_id, revision);
}
}
pub enum Outcome {
Done(Value),
Screenshot { path: Option<String> },
}
fn ok(v: Value) -> Outcome {
Outcome::Done(json!({"ok": true, "result": v}))
}
fn err(e: impl std::fmt::Display) -> Outcome {
let text = e.to_string();
let mut reply = json!({"ok": false, "error": text});
if let Some(reason) = solidcraft_engine::panels::commands::structured_error(&text) {
reply["panel_error"] = reason;
}
Outcome::Done(reply)
}
fn wrap(r: Result<Value, String>) -> Outcome {
match r {
Ok(v) => ok(v),
Err(e) => err(e),
}
}
/// The design's own Sketches folder (`Visibility::hidden_folders`), which `showSketches` sets.
const SKETCHES_FOLDER: &str = "c0/sketches";
/// The open dialog as `ui.inspect`, `ui.start` and `ui.editFeature` report it: its command, its
/// picks and what OK runs, in the commands' own terms rather than the form's internals (#9087).
fn dialog_state(app: &SolveApp) -> Value {
let Some(d) = app.dialog.as_ref() else { return Value::Null };
let runs = crate::dialogs::apply_commands(app, d);
json!({
"command": d.command(),
"title": crate::dialogs::report_title(d),
"editing": d.editing.map(|(feature, _)| feature),
"inputs": d.inputs.iter().enumerate().map(|(i, input)| json!({"label": input.label, "items": input.items, "active": i == d.active})).collect::<Vec<_>>(),
"error": d.error,
"commands": runs.as_ref().ok().map(|cmds| cmds.iter().map(|(command, params)| json!({"command": command, "params": params})).collect::<Vec<_>>()),
"waiting": runs.err(),
})
}
/// The windows open beside the model (#9087), each named by what opens it: the command
/// `ui.start` takes, or the `ui.help` item.
fn open_windows(app: &SolveApp) -> Vec<&'static str> {
[
(app.params.is_some(), "parameters.change"),
(app.design_properties.is_some(), "document.metadata"),
(app.sketch_report.is_some(), "sketch.inspect"),
(app.bom.is_some(), "assembly.bom"),
(app.material_card_review.is_some(), "material.properties.validate"),
(app.help.about, "about"),
(app.updater.open, "updates"),
(app.keymap.open, "shortcuts"),
(app.crashes.open, "crashes"),
(app.issue_report.draft.is_some(), "report"),
(app.messages.open, "messages"),
]
.into_iter()
.filter_map(|(open, command)| open.then_some(command))
.collect()
}
/// What a start or an edit opened: the tool, the dialog and the windows. `pending` while it
/// waits for the history to compute first; it opens on a later frame (`ui.inspect` shows it).
fn started(app: &SolveApp) -> Value {
json!({
"tool": app.tool.as_ref().map(|t| t.cmd),
"dialog": dialog_state(app),
"windows": open_windows(app),
"pending": app.pending_feature_edit.is_some() || app.start_after_roll.is_some(),
"status": app.status.as_ref().map(|(text, _, error)| json!({"text": text, "error": error})),
})
}
/// `UiState` as `ui.inspect` and `ui.set` report it, with the browser's view of the design
/// (kept in the session) under the names the UI state used to give it.
fn ui_state(app: &SolveApp) -> Value {
let mut u = serde_json::to_value(&app.ui).unwrap_or_default();
let v = &app.session.visibility;
if let Some(o) = u.as_object_mut() {
o.insert("showOrigin".into(), json!(app.origin_shown()));
o.insert("showSketches".into(), json!(!app.session.folder_hidden(SKETCHES_FOLDER)));
o.insert("hiddenProfiles".into(), json!(v.hidden_profiles));
o.insert("shownDims".into(), json!(v.shown_dimensions));
o.insert("lockedBodies".into(), json!(v.locked_bodies));
}
u
}
fn key_from(name: &str) -> Option<egui::Key> {
egui::Key::from_name(name).or(match name.to_ascii_lowercase().as_str() {
"enter" | "return" => Some(egui::Key::Enter),
"esc" | "escape" => Some(egui::Key::Escape),
"delete" => Some(egui::Key::Delete),
"space" => Some(egui::Key::Space),
"tab" => Some(egui::Key::Tab),
_ => None,
})
}
/// Run one command as `engine.execute` does: through `app.run`, then the first-body fit and the
/// camera the command asked for.
fn execute(app: &mut SolveApp, id: &str, params: Value) -> Result<Value, String> {
if solidcraft_engine::panels::commands::is_command(id) {
// No first-body meshing, camera-follow or fit tail for application layout.
return app.run(id, params);
}
// User bindings live in the UI. A bridged agent needs the same key the menus show,
// including null for a cleared binding; the standalone engine keeps its defaults.
if id == "engine.commands" {
let mut commands = app.session.execute(id, &params).map_err(|e| e.to_string())?;
if let Some(rows) = commands.as_array_mut() {
for row in rows.iter_mut().filter_map(Value::as_object_mut) {
let key = row.get("id").and_then(Value::as_str).and_then(|id| crate::keymap::effective(app, id));
row.insert("shortcut".into(), json!(key));
}
}
return Ok(commands);
}
// `view.pick` is answered by the viewport, not the engine: pixels and rays need the
// window's camera and pick index, and the command must not touch the document, the
// selection or the undo stack. Intercepted here so `engine.execute` and `engine.batch`
// (and through them MCP `execute` and `batch`) reach it like any other command.
if id == "view.pick" {
return crate::view_pick::pick_command(app, &params);
}
let r = app.run(id, params);
// Update Links in a part edited in place reads the assembly around it too, as its button does.
if r.is_ok() && is_command(Some(id), "component.update_links") && app.edit_in_place.active.is_some() {
crate::edit_in_place::refresh(app);
}
if r.is_ok()
&& !matches!(
id,
"view.fit"
| "view.home"
| "view.tool"
| "view.tool.zoom"
| "view.spin"
| "view.visual_style"
| "view.grid"
| "view.ground_shadow"
| "view.navigation_bar"
| "view.ribbon_tabs_only"
| "view.next_tab"
| "view.previous_tab"
| "view.layout"
| "view.navigate"
| "view.ambient_occlusion"
| "view.perspective"
| "view.angle_readout"
| "view.graphics_preset"
| "view.history_layout"
| "timeline.play"
| "browser.expand_all"
| "browser.collapse_all"
)
&& !id.starts_with("settings.")
&& app.session.active_sketch.is_none()
// Cheap test first: placing the world (`world_state`) after every step of a batch in a
// design with components placed every component's bodies again once per step.
&& app.session.undo.len() <= 2
&& crate::open_meshing::session_world(&app.session).bodies.len() == 1
{
app.fit_view();
}
// After the first-body fit, so a camera the command asked for (`view.apply`) wins.
app.follow_view_request(false);
r
}
/// A batch step's command id.
fn command(step: &Value) -> Option<&str> {
step.get("command").or_else(|| step.get("id")).and_then(Value::as_str)
}
/// Most steps in one `engine.batch` (as in the MCP `batch` tool).
const MAX_BATCH: usize = 10_000;
/// Commands that load a file: through `engine.execute` they go to the app's file loader
/// (`file_load::control`: off the window thread, with progress and Cancel), which a batch would
/// bypass.
const LOADS_A_FILE: [&str; 4] = ["doc.open", "file.insert_step", "file.insert_mesh", "pointcloud.insert"];
/// Edit in Place, Finish Edit and the next or previous tab go to another design's tab: a batch's
/// rollback, or a script's later steps, would land in the wrong design.
const SWITCHES_DESIGN: [&str; 4] = ["component.edit_in_place", "component.finish_edit", "view.next_tab", "view.previous_tab"];
/// `command` names the command `id`, in any of the spellings the engine takes.
fn is_command(command: Option<&str>, id: &str) -> bool {
command.and_then(solidcraft_engine::find_command).is_some_and(|spec| spec.id == id)
}
/// The command of `step` when it goes to another design's tab.
fn switches_design(step: &Value) -> Option<&'static str> {
SWITCHES_DESIGN.into_iter().find(|id| is_command(command(step), id))
}
/// Why `engine.batch` refuses these steps before running any: a step loads a file or switches
/// to another design (send such steps one by one).
pub(crate) fn batch_refusal(steps: &[Value]) -> Option<String> {
if let Some((i, c)) = steps.iter().enumerate().find_map(|(i, step)| switches_design(step).map(|c| (i, c))) {
return Some(format!("engine.batch unavailable: step {i} ({c}) switches to another design"));
}
let (i, c) = steps.iter().enumerate().find_map(|(i, step)| command(step).filter(|c| LOADS_A_FILE.contains(c)).map(|c| (i, c)))?;
Some(format!("engine.batch unavailable: step {i} ({c}) loads a file"))
}
/// A batch step's command id (the agent cursor points at its toolbar button).
pub(crate) fn batch_step_command(step: &Value) -> Option<&str> {
command(step)
}
/// `engine.batch {commands, rollback?, timings?, profile?}`: the steps in one request, so in one
/// frame (#743). With `timings` the reply adds each step's time and `total_ms`, with `profile`
/// each step's kernel share too (`solidcraft_engine::timing`, #1833). Each
/// step runs as `engine.execute` runs it; the first failure stops the batch and, with
/// `rollback` (the default), the design goes back to its checkpoint. Step failures are part of
/// the reply; refusals (`engine.batch unavailable: …`) come before anything runs, so the client
/// can send the steps one by one instead.
fn batch(app: &mut SolveApp, p: &Value) -> Outcome {
let Some(steps) = p.get("commands").and_then(Value::as_array).filter(|s| s.len() <= MAX_BATCH) else {
return err(format!("engine.batch: commands must be an array of at most {MAX_BATCH} steps"));
};
let panels = steps.iter().filter(|step| command(step).is_some_and(solidcraft_engine::panels::commands::is_command)).count();
if panels > 0 {
if let Some(why) = batch_refusal(steps) {
return err(why);
}
if let Some(refusal) = solidcraft_engine::batch_preflight::check(steps, app.session.param_check, &["view.pick"]) {
return ok(refusal.reply(steps.len()));
}
let rollback = p.get("rollback").and_then(Value::as_bool).unwrap_or(true);
if rollback {
if panels != steps.len() {
return err(solidcraft_engine::panels::commands::error_text(solidcraft_engine::panels::error(
solidcraft_engine::panels::Rule::Capability,
"atomic mixed document/layout batches are unavailable; use rollback:false or separate transactions",
)));
}
return wrap(app.run_panel_batch(steps).map_err(solidcraft_engine::panels::commands::error_text));
}
// Explicit sequential mode has per-command atomicity and no document
// checkpoint; previous application changes are truthfully retained.
let mut results = Vec::new();
for (i, step) in steps.iter().enumerate() {
let result = command(step)
.ok_or_else(|| "missing command".to_string())
.and_then(|id| execute(app, id, step.get("params").cloned().filter(|p| !p.is_null()).unwrap_or(json!({}))));
match result {
Ok(result) => results.push(result),
Err(error) => return ok(solidcraft_engine::panels::commands::sequential_failure(i, command(step), error, results)),
}
}
return ok(json!({"completed":results.len(),"results":results,"undone":0}));
}
// (With the agent cursor shown, the pointer has already acted out a short summary of the
// batch: `agent_cursor::intercept`.)
if let Some(why) = batch_refusal(steps) {
return err(why);
}
// A step the batch would refuse at its turn refuses it now, before anything runs (#5853).
if let Some(refusal) = solidcraft_engine::batch_preflight::check(steps, app.session.param_check, &["view.pick"]) {
return ok(refusal.reply(steps.len()));
}
let rollback = p.get("rollback").and_then(Value::as_bool).unwrap_or(true);
let profile = p.get("profile").and_then(Value::as_bool).unwrap_or(false);
let timed = profile || p.get("timings").and_then(Value::as_bool).unwrap_or(false);
let mut rows = Vec::new();
let clock = timing::Clock::start();
let checkpoint = if rollback { app.run("edit.checkpoint", json!({})).ok().and_then(|v| v["checkpoint"].as_u64()) } else { None };
let mut results = Vec::with_capacity(steps.len());
// With `coalesce_parameters`, each run of plain parameter edits rebuilds once (#5822); a run
// whose combined edit is refused goes step by step, so a refused edit is named by its step.
let coalesce = p.get("coalesce_parameters").and_then(Value::as_bool).unwrap_or(false);
for run in batch_params::plan(steps, coalesce) {
let singles = match run {
batch_params::BatchRun::Step(i) => vec![i],
batch_params::BatchRun::Params { steps: indices, changes } => {
let (r, took) = timing::time(profile, || execute(app, "parameters.change", batch_params::combined_params(&changes)));
match r {
Ok(v) => {
if timed {
rows.push(took.to_json(indices.first().copied().unwrap_or(0), "parameters.change"));
}
results.extend(batch_params::step_results(steps, &indices, &v));
continue;
}
Err(_) => indices,
}
}
};
for i in singles {
let Some(step) = steps.get(i) else { continue };
let (r, took) = timing::time(profile, || match command(step) {
Some(id) => execute(app, id, step.get("params").cloned().filter(|v| !v.is_null()).unwrap_or(json!({}))),
None => Err("missing `command`".to_string()),
});
if timed {
rows.push(took.to_json(i, command(step).unwrap_or_default()));
}
match r {
Ok(v) => results.push(v),
Err(e) => {
let restored = checkpoint.is_some_and(|id| app.run("edit.restore_checkpoint", json!({"checkpoint": id})).is_ok());
let failed = json!({"index": i, "command": command(step), "error": e});
// `rolled_back`: the design really is back at its checkpoint.
let reply = json!({"completed": i, "results": results, "failed": failed, "undone": if restored { i } else { 0 }, "rolled_back": restored});
return ok(with_timings(reply, timed, rows, clock.ms()));
}
}
}
}
if let Some(id) = checkpoint {
let _ = app.run("edit.restore_checkpoint", json!({"checkpoint": id, "forget": true}));
}
ok(with_timings(json!({"completed": results.len(), "results": results, "undone": 0}), timed, rows, clock.ms()))
}
/// A batch reply with `timings` and `total_ms` when they were asked for.
fn with_timings(mut reply: Value, timed: bool, rows: Vec<Value>, total_ms: f64) -> Value {
if timed && let Some(o) = reply.as_object_mut() {
o.insert("timings".into(), Value::Array(rows));
o.insert("total_ms".into(), json!(timing::round_ms(total_ms)));
}
reply
}
/// A request from an MCP server carries the folders its agent may use (`allow_paths`); every
/// file the request reaches must lie inside them (docs/mcp.md). `None`: it names none.
pub fn request_scope(app: &SolveApp, params: &Value) -> Result<Option<vfs::PathScope>, String> {
let Some(allowed) = params.get("allow_paths") else { return Ok(None) };
let folders = |v: &Value| v.as_array().and_then(|a| a.iter().map(|r| r.as_str().map(std::path::PathBuf::from)).collect::<Option<Vec<_>>>());
let Some(roots) = folders(allowed) else {
return Err("`allow_paths` must be a list of folders".into());
};
// The folders the agent opened or saved a design in (#7181), judged as the open design's is.
let designs = match params.get("design_folders") {
None => Vec::new(),
Some(v) => folders(v)
.filter(|d| d.len() <= vfs::MAX_DESIGN_FOLDERS)
.ok_or_else(|| format!("`design_folders` must be a list of at most {} folders", vfs::MAX_DESIGN_FOLDERS))?,
};
// Plus the app's own recovery folder and, when it is a safe one, the open design's folder.
let roots = roots.into_iter().chain(solidcraft_engine::recovery::default_dir());
let scope = designs.iter().fold(vfs::PathScope::new(roots), |s, d| s.with_design_folder(d));
Ok(Some(scope.with_design(app.session.path.as_deref())))
}
/// What a picture of the view shows: the model as the window shows it (theme and colour vision
/// mode, the section the viewport shows: an open Section Analysis dialog's preview, a sketch's
/// Slice), with the grid and the origin's axes as `guides` says.
pub(crate) fn view_scene(app: &SolveApp, guides: solidcraft_engine::view::Guides) -> Result<solidcraft_engine::render::Scene, String> {
let mut palette = crate::viewport::scene_palette(app.viewport_dark(), app.preferences.color_vision);
// The view's own background colour (#7688).
if let Some([r, g, b]) = app.preferences.viewport_background {
palette.background = (solidcraft_engine::render::Rgb(r, g, b), solidcraft_engine::render::Rgb(r, g, b));
}
let mut scene = solidcraft_engine::view::scene_with_thread_markings(
&app.session,
&app.cam,
crate::viewport::section_plane(app),
solidcraft_engine::view::world_curve_parts,
&palette,
guides,
app.preferences.cosmetic_threads,
)
.map_err(|e| e.to_string())?;
scene.plain_cap = !crate::viewport::section_hatch(app);
if app.preferences.section_hatch == crate::prefs::SectionHatch::One {
scene.part_hatch = None;
}
Ok(scene)
}
/// The grid and the origin's axes as the window shows them (the Grid and Origin switches).
pub(crate) fn window_guides(app: &SolveApp) -> solidcraft_engine::view::Guides {
solidcraft_engine::view::Guides {
grid: (app.session.active_sketch.is_some() || app.ui.show_grid) && !crate::viewport::active_view(app).hide_grid,
axes: app.origin_visible(),
}
}
/// A picture of the view as the window shows it, RGBA, drawn on the GPU with the viewport's
/// pipelines (the renderer the app installs).
pub(crate) fn view_rgba(app: &SolveApp, w: u32, h: u32) -> Result<Vec<u8>, String> {
solidcraft_engine::capture::rgba(&view_scene(app, window_guides(app))?, &app.cam, w, h).map(|p| p.rgba)
}
/// [`view_rgba`] as PNG.
pub fn view_png(app: &SolveApp, w: u32, h: u32) -> Result<Vec<u8>, String> {
let rgba = view_rgba(app, w, h)?;
solidcraft_engine::render::png(w as usize, h as usize, rgba).ok_or_else(|| "PNG encoding failed".to_string())
}
pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
crate::agent_chat::with_tool_request(app, req.chat_turn.as_ref(), |app| handle_request(app, ctx, req))
}
fn handle_request(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
let level = match request_param_check(&req.method, &req.params) {
Ok(level) => level,
Err(e) => return err(e),
};
let scope = match request_scope(app, &req.params) {
Ok(scope) => scope,
Err(e) => return err(e),
};
if scope.is_none() && level.is_none() {
return dispatch(app, ctx, &req.method, &req.params);
}
let mut p = req.params.clone();
if let Some(o) = p.as_object_mut() {
o.remove("allow_paths");
o.remove("design_folders");
o.remove("param_check");
}
let run = |app: &mut SolveApp| match level {
Some(level) => dispatch_checked(app, ctx, &req.method, &p, level),
None => dispatch(app, ctx, &req.method, &p),
};
match scope {
Some(scope) => vfs::scoped(Some(scope), || run(app)),
None => run(app),
}
}
/// The request's `param_check` (#9184): how the commands of an `engine.execute`, `engine.batch`
/// or `engine.script` are checked against their contracts, whatever the app's own session level;
/// `None` when it names none (other methods ignore the field).
pub(crate) fn request_param_check(method: &str, params: &Value) -> Result<Option<ParamCheck>, String> {
if !matches!(method, "engine.execute" | "command" | "engine.batch" | "engine.script") {
return Ok(None);
}
match params.get("param_check") {
None => Ok(None),
Some(v) => v.as_str().and_then(ParamCheck::parse).map(Some).ok_or_else(|| "`param_check` must be off, warn or strict".to_string()),
}
}
/// `dispatch` of an `engine.execute`, `engine.batch` or `engine.script` with its commands checked
/// at `level`, echoed in the reply as `param_check`, so a client can tell an app that checked
/// from an older one that ignored the field. The session goes back to its own level afterwards.
fn dispatch_checked(app: &mut SolveApp, ctx: &egui::Context, method: &str, p: &Value, level: ParamCheck) -> Outcome {
let mut out = if switches_design(p).is_some() {
switch_checked(app, ctx, method, p, level)
} else {
let own = app.session.param_check;
app.session.param_check = level;
let out = dispatch(app, ctx, method, p);
app.session.param_check = own;
out
};
if let Outcome::Done(Value::Object(o)) = &mut out {
o.insert("param_check".into(), json!(level.name()));
}
out
}
/// A command that switches to another design, checked at `level` before it runs: it runs at the
/// app's own level, since the session it leaves and the one it brings in each keep theirs.
fn switch_checked(app: &mut SolveApp, ctx: &egui::Context, method: &str, p: &Value, level: ParamCheck) -> Outcome {
let id = command(p).unwrap_or_default();
let issues: Vec<String> = solidcraft_engine::schema::issues(id, p.get("params").unwrap_or(&Value::Null)).into_iter().map(|i| i.message).collect();
if level == ParamCheck::Strict
&& let Some(first) = issues.first()
{
return err(solidcraft_engine::params::bad(id, first.as_str()));
}
let mut out = dispatch(app, ctx, method, p);
if level == ParamCheck::Warn
&& !issues.is_empty()
&& let Outcome::Done(v) = &mut out
&& let Some(o) = v.get_mut("result").and_then(Value::as_object_mut)
{
o.insert("param_warnings".into(), json!(issues));
}
out
}
fn dispatch(app: &mut SolveApp, ctx: &egui::Context, method: &str, p: &Value) -> Outcome {
crate::render_workspace::sync_backend(app);
let s = |k: &str| p.get(k).and_then(Value::as_str);
let f = |k: &str| p.get(k).and_then(Value::as_f64).filter(|x| x.is_finite());
let b = |k: &str| p.get(k).and_then(Value::as_bool).unwrap_or(false);
match method {
"ui.blur" => {
// Internal rendering harness; deliberately no saved preference or product UI.
let radius = if let Some(radius) = p.get("radius_px") {
let Some(radius) = radius.as_f64().filter(|v| v.is_finite() && (0.0..=60.0).contains(v)) else {
return err("radius_px must be finite and between 0 and 60");
};
Some(radius as f32)
} else {
None
};
let alpha = if let Some(alpha) = p.get("surface_alpha") {
let alpha = if alpha.is_null() {
None
} else {
let Some(alpha) = alpha.as_f64().filter(|v| v.is_finite() && (0.0..=1.0).contains(v)) else {
return err("surface_alpha must be null or between 0 and 1");
};
Some((alpha * 255.0).round() as u8)
};
Some(alpha)
} else {
None
};
// Explicit, labelled evidence fixtures only. They can force a failure, never fake
// real renderer support. All validation precedes mutation, including old fields.
let fixture = if let Some(fixture) = p.get("fixture") {
let Some(fixture) =
fixture.as_str().filter(|s| matches!(*s, "clear" | "gpu-software" | "reduce-transparency" | "web-unsupported" | "guard-60"))
else {
return err("unknown blur evidence fixture");
};
Some(fixture)
} else {
None
};
if let Some(radius) = radius {
if let Err(error) = app.blur.set_radius(radius) {
return err(error);
}
app.blur_session.harness_radius = Some(radius);
ctx.request_repaint();
}
if let Some(alpha) = alpha {
app.blur.set_surface_alpha(alpha);
ctx.request_repaint();
}
if let Some(fixture) = fixture {
match fixture {
"clear" => {
app.blur_session.harness_unavailable = None;
app.blur_session.harness_radius = None;
app.blur_session.evidence_fixture = None;
}
"gpu-software" => {
app.blur_session.harness_unavailable = Some("prefs.blur_software");
app.blur_session.evidence_fixture = Some("gpu-software");
}
"reduce-transparency" => {
app.blur_session.harness_unavailable = Some("prefs.blur_reduce_transparency");
app.blur_session.evidence_fixture = Some("reduce-transparency");
}
"web-unsupported" => {
app.blur_session.harness_unavailable = Some("prefs.blur_web");
app.blur_session.evidence_fixture = Some("web-unsupported");
}
"guard-60" => {
let radius = app.blur.radius();
for _ in 0..60 {
app.blur_session.guard.observe(radius, 23.0, true);
}
app.blur_session.evidence_fixture = Some("guard-60");
}
_ => {}
}
ctx.request_repaint();
}
let availability = crate::prefs::blur_availability(app);
let reason = match availability {
crate::theme_options::Availability::Unavailable(reason) => Some(app.tr(reason)),
crate::theme_options::Availability::Available => None,
};
ok(
json!({"radius_px":app.blur.radius(), "max_radius_px":60, "capability":app.blur.capability_for(ctx.viewport_id()), "counters":app.blur.counters(),
"available": availability == crate::theme_options::Availability::Available, "reason": reason,
"evidence_fixture": app.blur_session.evidence_fixture,
"guard": {"tier_cap": app.blur_session.guard.cap, "streak": app.blur_session.guard.streak,
"notice": app.blur_session.guard.notice, "opted_out": app.blur_session.guard.opted_out}}),
)
}
"ui.panel_fixture" => {
let result = crate::panel_runtime::control_specimen(app, p);
if result.is_ok() && (p.get("enabled").is_some() || p.get("preset").is_some()) {
ctx.request_repaint();
}
wrap(result)
}
"ui.status_fixture" => wrap(crate::viewport_status_fixture::control(app, p)),
"ui.workspace" => {
if let Some(workspace) = s("workspace") {
if !matches!(workspace, "design" | "render") {
return err("workspace must be design or render");
}
if let Err(e) = crate::render_workspace::enter(app, workspace == "render") {
return err(e);
}
}
ok(json!({"workspace":if crate::render_workspace::active(app) {"render"} else {"design"}}))
}
"engine.execute" | "command" => {
let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };
wrap(execute(app, id, p.get("params").cloned().filter(|v| !v.is_null()).unwrap_or(json!({}))))
}
"engine.batch" => batch(app, p),
"ui.agent_cursor" => {
let s = &mut app.ui.agent_cursor;
if let Some(v) = p.get("show").and_then(Value::as_bool) {
s.show = v;
}
if let Some(v) = p.get("follow_camera").and_then(Value::as_bool) {
s.follow_camera = v;
}
if let Some(v) = p.get("speed") {
match crate::agent_cursor::Speed::from_value(v) {
Some(sp) => s.speed = sp,
None => return err("speed must be a number from 1 to 5, or \"instant\""),
}
}
ok(json!(app.ui.agent_cursor))
}
"engine.script" => {
let steps = p.as_array().or_else(|| p.get("commands").and_then(Value::as_array));
if let Some(c) = steps.and_then(|steps| steps.iter().find_map(switches_design)) {
return err(format!("engine.script unavailable: {c} switches to another design (send it on its own)"));
}
if let Some(steps) =
steps.filter(|steps| steps.iter().any(|step| command(step).is_some_and(solidcraft_engine::panels::commands::is_command)))
{
if steps.len() > 100_000 {
return err("script too long");
}
let mut results = Vec::new();
for (i, step) in steps.iter().enumerate() {
let result = command(step)
.ok_or_else(|| "missing command".to_string())
.and_then(|id| execute(app, id, step.get("params").cloned().filter(|p| !p.is_null()).unwrap_or(json!({}))));
match result {
Ok(result) => results.push(result),
Err(error) => {
let mut reply = json!({"ok":false,"error":error,"step":i + 1});
if let Some(reason) = solidcraft_engine::panels::commands::structured_error(&error) {
reply["panel_error"] = reason;
}
return Outcome::Done(reply);
}
}
}
return ok(json!(results));
}
let mut replaced = false;
let r = app
.session
.run_script_each(p, &mut |i, _| {
let id = steps.and_then(|steps| steps.get(i)).and_then(command).and_then(solidcraft_engine::find_command).map(|spec| spec.id);
replaced |= matches!(id, Some("file.new" | "doc.open" | "doc.recover"));
})
.map(|v| json!(v))
.map_err(|e| e.to_string());
// A successful replacement still happened if a later script step failed.
if replaced {
crate::documents::reset_chat(app);
app.edit_in_place.active = None;
}
app.follow_view_request(false);
wrap(r)
}
"engine.commands" => wrap(execute(app, "engine.commands", json!({}))),
"document.inspect" => wrap(app.session.execute("document.inspect", p).map_err(|e| e.to_string())),
"document.revision" => wrap(app.session.execute("document.revision", p).map_err(|e| e.to_string())),
// A host that keeps the files itself (an editing embed, #8517).
"document.export" => wrap(crate::documents::export(app)),
"document.import" => wrap(crate::documents::import(app, p)),
"document.saved" => wrap(crate::documents::saved(app, p)),
// The connection already counts as subscribed (`DesignWatch::join`), and its events start
// from this answer: published first, so no event repeats it and none older follows.
"control.subscribe" => {
let revision = app.session.design_revision();
DESIGN_WATCH.publish(&app.session.document_id, revision);
ok(json!({"document_id": app.session.document_id, "revision": revision}))
}
// What the MCP server bridged to this app shapes its output with (Preferences › AI).
"mcp.options" => ok(json!({"compact": app.preferences.mcp_compact})),
"ui.messages" => ok(crate::messages::control(app, p)),
"ui.inspect" => ok(json!({
"render": crate::render_workspace::inspect_state(app),
"ui": ui_state(app),
"visibility": app.session.visibility,
"viewport": app.viewport.rect.map(|r| json!([r.left(), r.top(), r.width(), r.height()])),
"camera": app.cam,
"tool": app.tool.as_ref().map(|t| t.cmd),
"dialog": dialog_state(app),
"windows": open_windows(app),
"status": app.status.as_ref().map(|(text, _, error)| json!({"text": text, "error": error})),
"hover": app.viewport.hover,
"renderer": if app.viewport.gpu.is_some() { "gpu" } else { "cpu" },
"frame_ms": app.frame_ms,
"draw": app.viewport.draw_stats.as_ref().and_then(|s| s.lock().ok().map(|d| json!({
"draw_calls": d.draw_calls, "triangles": d.triangles, "line_segments": d.line_segments, "supersampled": d.supersampled,
}))),
"adapter": app.viewport.adapter,
"file_busy": app.file_load.busy(),
"file_picker_busy": app.file_picker_busy(),
"file_dialog_open": app.file_picker_busy(),
"build_ms": app.viewport.build_ms,
"display_lod": app.viewport.lod.lock().map(|l| serde_json::to_value(&l.stats).unwrap_or_default()).unwrap_or_default(),
"preview": {"active": app.preview.active, "busy": app.preview.busy, "error": app.preview.error, "ms": app.preview.ms, "replaced": app.preview.replaced},
"home": app.home.open,
"recent_thumbnails_ready": app.home.ready_recents(),
"sample_thumbnails_ready": app.home.ready_samples(),
"documents": app.docs.count(),
"quit_requested": app.quit_requested,
"quitting": app.docs.quitting.is_some(),
})),
"ui.file" => {
let Some(path) = s("path") else { return err("path is required") };
// A control call never meets the unit dialog an STL or OBJ file asks a person: it names
// `units` itself, or the file is in millimetres.
let kind =
if p.get("insert").and_then(Value::as_bool).unwrap_or(false) { crate::file_load::Kind::Insert } else { crate::file_load::Kind::Open };
let mut request = crate::file_load::Request::new(path, kind);
if let Some(units) = p.get("units").filter(|u| !u.is_null()) {
request.options.insert("units".into(), units.clone());
}
let _ = crate::file_load::begin_request(app, request);
ok(json!({"busy": app.file_load.busy()}))
}
"ui.documents" => ok(crate::documents::control(app, p)),
"ui.home" => {
match p.get("open").and_then(Value::as_bool) {
Some(true) => {
let rev = app.session.revision;
app.home.show(rev);
crate::panel_runtime::hide_app_host(app);
}
Some(false) => app.home.open = false,
None => {}
}
if let Some(sample) = p.get("sample") {
// The index is checked here: `open_sample` drops an index that names no sample
// and says nothing, so the request would look like it had worked (#9087).
let count = solidcraft_engine::sample::samples().len();
let Some(index) = sample.as_i64() else {
return err(format!("`sample` must be an index from 0 to {}", count - 1));
};
if !(0..count as i64).contains(&index) {
return err(format!("`sample` must be an index from 0 to {}, not {index}", count - 1));
}
crate::home::open_sample(app, index as usize);
}
ok(json!({"open": app.home.open, "recent": app.home.recent}))
}
"ui.set" => {
// What is hidden lives in the session (`browser.visibility`); `ui.set` still sets it.
const VIS: [(&str, &str); 9] = [
("hiddenBodies", "hidden_bodies"),
("hiddenOrigin", "hidden_origin"),
("hiddenSketches", "hidden_sketches"),
("shownSketches", "shown_sketches"),
("hiddenJoints", "hidden_joints"),
("hiddenProfiles", "hidden_profiles"),
("shownDims", "shown_dimensions"),
("lockedBodies", "locked_bodies"),
("hiddenFolders", "hidden_folders"),
];
let mut cur = serde_json::to_value(&app.ui).unwrap_or(json!({}));
let mut vis = serde_json::to_value(&app.session.visibility).unwrap_or(json!({}));
let mut sketches = None;
if let (Some(o), Some(vo), Some(src)) = (cur.as_object_mut(), vis.as_object_mut(), p.as_object()) {
for (k, v) in src {
let shown = |v: &Value| v.as_bool().map(|b| json!(!b)).unwrap_or_else(|| v.clone());
match (VIS.iter().find(|(camel, _)| camel == k), k.as_str()) {
(Some((_, snake)), _) => vo.insert(snake.to_string(), v.clone()),
(None, "showOrigin") => vo.insert("origin_hidden".into(), shown(v)),
(None, "showSketches") => {
sketches = Some(v.as_bool().ok_or_else(|| "`showSketches` must be true or false".to_string()));
None
}
_ => o.insert(k.clone(), v.clone()),
};
}
}
let sketches = match sketches.transpose() {
Ok(s) => s,
Err(e) => return err(e),
};
match (serde_json::from_value::<crate::UiState>(cur), serde_json::from_value::<solidcraft_engine::Visibility>(vis)) {
(Ok(mut u), Ok(mut v)) => {
if let Some(shown) = sketches {
v.hidden_folders.retain(|k| k != SKETCHES_FOLDER);
if !shown {
v.hidden_folders.push(SKETCHES_FOLDER.to_string());
}
}
if crate::workspace::render_tab(&u.tab) != crate::render_workspace::active(app)
&& let Err(e) = crate::render_workspace::enter(app, crate::workspace::render_tab(&u.tab))
{
return err(e);
}
u.ribbon_context = app.ui.ribbon_context.clone();
app.ui = u;
app.session.visibility = v;
ok(ui_state(app))
}
(Err(e), _) | (_, Err(e)) => err(e),
}
}
"ui.view" => {
let v = s("view").unwrap_or("home");
app.viewport.orbit_free = None;
if p.get("animate").and_then(Value::as_bool).unwrap_or(false) {
if v != "fit" && v != "home" && StandardView::parse(v).is_none() {
return err(format!("unknown view `{v}`"));
}
app.animate_view(v);
return ok(json!({ "animating": true, "to": app.cam_anim.map(|a| a.to) }));
}
app.cancel_view_animation();
match v {
"fit" => app.fit_view(),
"home" => {
app.cam.set_view(StandardView::Iso);
app.fit_view();
}
v => match StandardView::parse(v) {
Some(sv) => app.cam.set_view(sv),
None => return err(format!("unknown view `{v}`")),
},
}
ok(json!(app.cam))
}
"ui.camera" => wrap(camera(app, p)),
"ui.palette" => {
if p.get("open").and_then(Value::as_bool) == Some(false) {
app.ui.palette_open = false;
app.sbox.text.clear();
} else {
app.start("ui.palette");
if let Some(query) = s("text") {
app.sbox.text = query.chars().take(crate::shortcut_box::MAX_QUERY).collect();
}
}
ok(json!({"open": app.ui.palette_open, "text": app.sbox.text}))
}
"ui.start" => {
let Some(id) = s("command") else { return err("missing `command`") };
// `params`: what the dialog opens on. Refused: nothing starts, or the dialog closes.
let params = p.get("params").filter(|v| !v.is_null());
if params.is_some() && id != "joint.drive" && id != "motion.study" {
return err(format!("`{id}` takes no ui.start params yet (joint.drive takes joint, values; motion.study takes study)"));
}
app.start(id);
if let Some(params) = params.filter(|_| id == "motion.study") {
let Some(crate::dialogs::Kind::Motion(k)) = app.dialog.as_mut().map(|d| &mut d.kind) else {
return err("Motion Study did not open");
};
if let Err(e) = crate::dialogs_motion::preset(&app.session, k, params) {
crate::dialogs::cancel(app);
return err(e);
}
} else if let Some(params) = params {
if app.tree.capture_prompt.is_some() {
return err("Drive Joints waits for the Capture Position question (ui.capture)");
}
let Some(crate::dialogs::Kind::Assembly(k)) = app.dialog.as_mut().map(|d| &mut d.kind) else {
let why = app.status.as_ref().filter(|s| s.2).map(|s| s.0.clone());
return err(why.unwrap_or_else(|| "Drive Joints did not open".into()));
};
if let Err(e) = crate::dialogs_assembly::preset(&app.session, k, params) {
crate::dialogs::cancel(app);
return err(e);
}
}
ok(started(app))
}
"ui.move" | "ui.click" => {
let (Some(x), Some(y)) = (f("x"), f("y")) else { return err("missing x/y") };
if x.abs() > 1e6 || y.abs() > 1e6 {
return err("x/y must be within ±1000000 screen points");
}
let pos = egui::pos2(x as f32, y as f32);
let modifiers = if method == "ui.move" {
egui::Modifiers { shift: b("shift"), alt: b("alt"), ctrl: b("ctrl"), command: b("ctrl") || b("cmd"), mac_cmd: b("cmd") }
} else {
egui::Modifiers::NONE
};
app.synthetic.push(egui::Event::ModifiersChanged(modifiers));
app.synthetic.push(egui::Event::PointerMoved(pos));
if method == "ui.click" {
let button = match s("button") {
Some("right") => egui::PointerButton::Secondary,
Some("middle") => egui::PointerButton::Middle,
_ => egui::PointerButton::Primary,
};
let modifiers = egui::Modifiers { shift: b("shift"), ctrl: b("ctrl"), command: b("ctrl"), alt: b("alt"), ..Default::default() };
// `double: true` sends two clicks in one frame, which egui reads as a double-click.
for _ in 0..if b("double") { 2 } else { 1 } {
app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: true, modifiers });
app.synthetic.push(egui::Event::PointerButton { pos, button, pressed: false, modifiers });
}
}
ok(Value::Null)
}
"ui.drag" => {
let (Some(x0), Some(y0), Some(x1), Some(y1)) = (f("x0"), f("y0"), f("x1"), f("y1")) else { return err("missing x0/y0/x1/y1") };
let button = match s("button") {
Some("right") => egui::PointerButton::Secondary,
Some("middle") => egui::PointerButton::Middle,
_ => egui::PointerButton::Primary,
};
let modifiers = egui::Modifiers { shift: b("shift"), ctrl: b("ctrl"), command: b("ctrl"), alt: b("alt"), ..Default::default() };
let (a, z) = (egui::pos2(x0 as f32, y0 as f32), egui::pos2(x1 as f32, y1 as f32));
// Positioning precedes the press by a frame: it is not a modifier-only gesture.
app.synthetic.push(egui::Event::ModifiersChanged(egui::Modifiers::NONE));
app.synthetic.push(egui::Event::PointerMoved(a));
app.synthetic.push(egui::Event::PointerButton { pos: a, button, pressed: true, modifiers });
// `hold`: frames to keep the button down before moving (press-and-hold).
for _ in 0..f("hold").unwrap_or(0.0).clamp(0.0, 600.0) as usize {
app.synthetic.push(egui::Event::PointerMoved(a));
}
let steps = f("steps").unwrap_or(10.0).clamp(1.0, 200.0) as usize;
// `via`: [[x, y], ...] the pointer passes through on its way (a lasso's loop, #4376).
let via: Vec<egui::Pos2> = p
.get("via")
.and_then(Value::as_array)
.into_iter()
.flatten()
.take(500)
.filter_map(|q| Some(egui::pos2(q.get(0)?.as_f64()? as f32, q.get(1)?.as_f64()? as f32)))
.filter(|q| q.is_finite())
.collect();
let mut from = a;
for to in via.into_iter().chain([z]) {
for k in 1..=steps {
app.synthetic.push(egui::Event::PointerMoved(from + (to - from) * (k as f32 / steps as f32)));
}
from = to;
}
// `hold_end`: frames to keep the button down at the end (to look at a drag's snap).
for _ in 0..f("hold_end").unwrap_or(0.0).clamp(0.0, 600.0) as usize {
app.synthetic.push(egui::Event::PointerMoved(z));
}
app.synthetic.push(egui::Event::PointerButton { pos: z, button, pressed: false, modifiers });
ok(Value::Null)
}
"ui.editFeature" => {
let key = match p.get("feature") {
Some(Value::Number(n)) => n.to_string(),
Some(Value::String(x)) => x.clone(),
_ => return err("`feature` must be an id or name"),
};
let Some(id) = app.session.doc.find_feature(&key).map(|f| f.id) else { return err(format!("no feature `{key}`")) };
app.edit_feature(id);
let mut reply = started(app);
if let Some(o) = reply.as_object_mut() {
o.insert("marker".into(), json!(app.session.doc.marker));
}
ok(reply)
}
"ui.selection" => ok(json!({
"selection": app.session.selection,
"dialog": app.dialog.as_ref().map(|d| d.inputs.iter().map(|i| json!({"label": i.label, "items": i.items})).collect::<Vec<_>>()),
"hover": app.viewport.hover,
"dimensions": crate::dim_view::drawn().into_iter().map(|(id, p)| json!({"id": id, "x": p.x, "y": p.y})).collect::<Vec<_>>(),
"shown_dimensions": crate::dim_view::model_drawn()
.into_iter()
.map(|(sketch, id, p)| json!({"sketch": sketch, "id": id, "x": p.x, "y": p.y}))
.collect::<Vec<_>>(),
"dimension_selected": crate::dim_view::selected(app),
"dimension_editing": crate::dim_view::editing(),
})),
"ui.triad" => {
// Screen points of the 3D move triad's handles (x, y, z arrows and the plane square).
let Some(rect) = app.viewport.rect else { return err("no viewport") };
let proj = crate::viewport::projection(app, rect);
ok(json!(
crate::sketch3d::handle_points(app, &proj).into_iter().map(|(n, p)| json!({"handle": n, "x": p.x, "y": p.y})).collect::<Vec<_>>()
))
}
"ui.dialogInput" => {
// What clicking a selection input's chip does: make it the one picks go to.
let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
match app.dialog.as_mut() {
Some(d) if i < d.inputs.len() => {
d.active = i;
ok(json!({"label": d.inputs.get(i).map(|x| x.label)}))
}
_ => err("no dialog input with that index"),
}
}
"ui.handles" => {
// The handles drawn last frame (toolbar buttons `toolbar:<id>`, panels, browser rows…).
let list = crate::scenario::handles(s("prefix").unwrap_or(""));
ok(json!(list.into_iter().map(|(n, p)| json!({"name": n, "x": p.x, "y": p.y})).collect::<Vec<_>>()))
}
"ui.pick" => wrap(crate::view_pick::pick_command(app, p)),
"ui.at" => {
if let Some(path) = p.get("occurrence").and_then(Value::as_array) {
let ids: Option<Vec<u64>> = path.iter().map(Value::as_u64).collect();
let Some(ids) = ids else { return err("occurrence path must contain integer ids") };
let key = ids.iter().map(u64::to_string).collect::<Vec<_>>().join("/");
let control = s("control").unwrap_or("row");
return match crate::scenario::handle_at(&format!("{control}:occurrence:{key}")) {
Some(q) => ok(json!([q.x, q.y])),
None => err("occurrence row or control is not shown"),
};
}
// A scenario point: {world: [x,y,z]} | {sketch: [x,y]} | {plane: "XY"} (the middle of an
// origin plane's square) → screen point.
if let Some(h) = p.get("handle").and_then(Value::as_str) {
return match crate::scenario::handle_at(h) {
Some(q) => ok(json!([q.x, q.y])),
None => err(format!("handle {h} is not shown")),
};
}
// A browser row by its label: the row itself, or its fold arrow.
for (k, chevron) in [("browser", false), ("chevron", true)] {
if let Some(label) = p.get(k).and_then(Value::as_str) {
let rows = crate::browser::drawn_rows();
let found = rows
.iter()
.find(|r| r.0 == label)
.and_then(|r| if chevron { r.2.map(|f| f.center()) } else { Some(r.1.left_center() + egui::vec2(120.0, 0.0)) });
return match found {
Some(q) => ok(json!([q.x, q.y])),
None => err(format!("no browser row `{label}`{} on screen", if chevron { " with a fold arrow" } else { "" })),
};
}
}
if let Some(d) = p.get("dimension").and_then(Value::as_str) {
return match crate::dim_view::text_at(d) {
Some(q) => ok(json!([q.x, q.y])),
None => err(format!("dimension {d} is not shown")),
};
}
let Some(rect) = app.viewport.rect else { return err("no viewport") };
let proj = crate::viewport::projection(app, rect);
let num = |v: &Value, i: usize| v.get(i).and_then(Value::as_f64).unwrap_or(0.0);
let world = if let Some(w) = p.get("world") {
Some(solidcore_record::Vec3::new(num(w, 0), num(w, 1), num(w, 2)))
} else if let Some(s) = p.get("sketch") {
let st = crate::open_meshing::session_world(&app.session);
app.session.active_sketch.and_then(|id| st.sketch(id)).map(|ss| ss.plane.to_world(solidcore_record::Vec2::new(num(s, 0), num(s, 1))))
} else if let Some(n) = p.get("plane").and_then(Value::as_str) {
crate::viewport::origin_plane_target(app, &proj, n)
} else if let Some(n) = p.get("axis").and_then(Value::as_str) {
// Along an origin axis, on its solid part.
let size = crate::selection::origin_size(app.cam.half_height());
crate::viewport::origin_axes(app).into_iter().find(|(name, _)| *name == n).map(|(_, d)| d * (size * 0.8))
} else if let Some(n) = p.get("gizmo").and_then(Value::as_str) {
// A handle of the move triad ("x", "xy", "rz", "ball"), moved `by` [x,y,z] mm or
// turned `turn` degrees (rings).
let by = p.get("by").map(|b| solidcore_record::Vec3::new(num(b, 0), num(b, 1), num(b, 2))).unwrap_or_default();
crate::gizmo::handle_point(n, by, p.get("turn").and_then(Value::as_f64).unwrap_or(0.0))
} else {
None
};
match world.and_then(|w| proj.to_screen(w)) {
Some(q) => ok(json!([q.x, q.y])),
None => err(format!("not on screen: {}", p)),
}
}
"ui.worldToScreen" => {
let Some(rect) = app.viewport.rect else { return err("no viewport") };
let proj = crate::viewport::projection(app, rect);
let pts: Vec<Value> = p
.get("points")
.and_then(Value::as_array)
.into_iter()
.flatten()
.take(1000)
.map(|v| {
let c = |i: usize| v.get(i).and_then(Value::as_f64).unwrap_or(0.0);
proj.to_screen(solidcore_record::Vec3::new(c(0), c(1), c(2))).map_or(Value::Null, |q| json!([q.x, q.y]))
})
.collect();
ok(json!(pts))
}
"ui.sketchToScreen" => {
// Screen points of active-sketch coordinates (for driving sketch interaction).
let st = crate::open_meshing::session_world(&app.session);
let (Some(rect), Some(ss)) = (app.viewport.rect, app.session.active_sketch.and_then(|s| st.sketch(s))) else {
return err("no active sketch in a drawn viewport");
};
let proj = crate::viewport::projection(app, rect);
let pts: Vec<Value> = p
.get("points")
.and_then(Value::as_array)
.into_iter()
.flatten()
.take(1000)
.map(|v| {
let c = |i: usize| v.get(i).and_then(Value::as_f64).unwrap_or(0.0);
let q = solidcore_record::Vec2::new(c(0), c(1));
proj.to_screen(ss.plane.to_world(q)).map_or(Value::Null, |p| json!([p.x, p.y]))
})
.collect();
ok(json!(pts))
}
"ui.scroll" => {
let (Some(x), Some(y)) = (f("x"), f("y")) else { return err("missing x/y") };
// Mouse-wheel semantics (lines): zooms regardless of the trackpad pan
// preference, so scripts and agents keep working. Trackpads report points.
// `ctrl: true` replays a Ctrl+wheel pinch in points (#8480). An explicit `unit`
// overrides that choice; without ctrl the default remains a line wheel.
let speed = ctx.options(|o| o.input_options.line_scroll_speed).max(1.0);
let points = f("delta").unwrap_or(-100.0);
let ctrl = b("ctrl");
let unit = match p.get("unit") {
Some(Value::String(unit)) if unit == "point" => egui::MouseWheelUnit::Point,
Some(Value::String(unit)) if unit == "line" => egui::MouseWheelUnit::Line,
Some(_) => return err("`unit` must be point or line"),
None if ctrl => egui::MouseWheelUnit::Point,
None => egui::MouseWheelUnit::Line,
};
let delta = match unit {
// A point wheel reaches the app as points; a line wheel is scaled up by the
// line scroll speed, so divide it out and both land on the same points.
egui::MouseWheelUnit::Line => points / f64::from(speed),
_ => points,
};
let (x, y, delta) = (x as f32, y as f32, delta as f32);
if !x.is_finite() || !y.is_finite() || !delta.is_finite() {
return err("x, y and delta must fit finite screen coordinates");
}
let modifiers = if ctrl { egui::Modifiers::CTRL } else { Default::default() };
let explicit = p.get("ctrl").is_some();
app.synthetic.push(egui::Event::PointerMoved(egui::pos2(x, y)));
if explicit {
app.synthetic.push(egui::Event::ModifiersChanged(modifiers));
}
app.synthetic.push(egui::Event::MouseWheel {
source: egui::MouseWheelSource::Unknown,
unit,
delta: egui::vec2(0.0, delta),
modifiers,
phase: egui::TouchPhase::Move,
});
if explicit {
app.synthetic.push(egui::Event::ModifiersChanged(egui::Modifiers::NONE));
}
ok(Value::Null)
}
"ui.key" => {
let Some(key) = s("key").and_then(key_from) else { return err("unknown key") };
// Preserve the control channel's legacy primary-modifier alias. An explicit
// ctrl flag opts into physical Control/Command state (ctrl:false for Cmd alone).
let explicit_ctrl = p.get("ctrl").is_some();
let ctrl = if explicit_ctrl { b("ctrl") } else { b("cmd") };
let modifiers = egui::Modifiers { shift: b("shift"), alt: b("alt"), ctrl, command: b("cmd") || ctrl, mac_cmd: b("cmd") && explicit_ctrl };
let pressed = match p.get("pressed") {
None => None,
Some(Value::Bool(pressed)) => Some(*pressed),
Some(_) => return err("pressed must be a boolean"),
};
app.synthetic.push(egui::Event::ModifiersChanged(modifiers));
if pressed != Some(false) {
app.synthetic.push(egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers });
}
if pressed != Some(true) {
app.synthetic.push(egui::Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers });
}
if pressed.is_none() {
app.synthetic.push(egui::Event::ModifiersChanged(egui::Modifiers::NONE));
}
ok(Value::Null)
}
"ui.text" => {
app.synthetic.push(egui::Event::Text(s("text").unwrap_or("").to_string()));
ok(Value::Null)
}
"ui.icon_audit" => {
if b("reset") {
crate::icon_svg::audit::start();
}
let requested = crate::icon_svg::audit::take();
if b("stop") {
crate::icon_svg::audit::stop();
}
ok(json!({"requested": requested}))
}
"ui.menu" => {
if b("close") {
crate::context_menu::close(app);
return ok(json!({"open": false}));
}
if let (Some(x), Some(y)) = (f("x"), f("y")) {
let target = match p.get("target") {
Some(v) => match serde_json::from_value::<crate::context_menu::Target>(v.clone()) {
Ok(t) => t,
Err(e) => return err(e),
},
None => crate::context_menu::Target::Viewport,
};
// A right-click opens a menu only on something that is there.
if let Err(e) = crate::context_menu::check_target(app, &target) {
return err(e);
}
crate::context_menu::request_open(app, egui::pos2(x as f32, y as f32), target);
return ok(json!({"pending": true}));
}
ok(crate::context_menu::describe(app))
}
"ui.confirm" => match p.get("accept").and_then(Value::as_bool) {
Some(a) => {
if crate::delete::confirm(app, a) {
ok(json!({"accepted": a}))
} else {
err("nothing is waiting for a confirmation")
}
}
None => ok(json!({"pending": app.menu.confirm.as_ref().map(|c| c.report.clone())})),
},
"ui.shortcut" => {
let Some(id) = s("command") else { return err("missing `command`") };
let slot = p.get("slot").and_then(Value::as_u64).map(|n| usize::try_from(n).unwrap_or(usize::MAX));
let report = |app: &SolveApp| ok(json!({"command": id, "key": crate::keymap::effective(app, id), "keys": crate::keymap::keys(app, id)}));
match s("key") {
Some(k) => match crate::keymap::bind_at(app, id, slot, k, b("replace")) {
Ok(()) => report(app),
Err(e) => err(e),
},
None => report(app),
}
}
"ui.browser" => ok(json!({
"occurrences": crate::browser::drawn_occurrences().iter().map(|(path, label, r, open)| json!({"path": path, "label": label, "y": r.center().y, "open": open})).collect::<Vec<_>>(),
"rows": crate::browser::drawn_rows().iter().map(|(label, r, _, open)| json!({"label": label, "y": r.center().y, "open": open})).collect::<Vec<_>>(),
"selection": app.session.selection,
"picked_components": app.tree.picked_components,
})),
"ui.capture" => match s("action") {
Some(a) => match crate::browser::answer_capture(app, a) {
Ok(()) => ok(json!({"pending_moves": app.session.pending_moves.len()})),
Err(e) => err(e),
},
None => ok(json!({"question": app.tree.capture_prompt, "pending_moves": app.session.pending_moves.len()})),
},
"ui.prefs" => wrap(crate::prefs::control(app, p)),
"ui.agent_chat" => wrap(crate::agent_chat::control(app, ctx, p)),
"ui.help" => match s("item") {
Some(i @ ("about" | "updates" | "shortcuts" | "report" | "crashes")) => {
crate::help::run(app, ctx, i);
ok(
json!({"diagnostics": crate::help::diagnostics(app), "version": crate::help::VERSION, "commit": crate::help::COMMIT, "built": crate::help::BUILD_DATE}),
)
}
_ => ok(
json!({"diagnostics": crate::help::diagnostics(app), "version": crate::help::VERSION, "commit": crate::help::COMMIT, "built": crate::help::BUILD_DATE}),
),
},
"ui.selectOther" => wrap(crate::select_other::control(app, p)),
"ui.menuPick" => {
let Some(key) = s("item") else { return err("missing `item` (id or label)") };
wrap(crate::context_menu::pick(app, key))
}
"ui.rename" => {
if crate::context_menu::finish_rename(app, s("text"), p.get("commit").and_then(Value::as_bool).unwrap_or(true)) {
ok(json!({"done": true}))
} else {
err("no rename in progress")
}
}
"ui.window" => match crate::titlebar::window_action(app, ctx, s("action").unwrap_or("")) {
Ok(()) => ok(json!({"custom_titlebar": app.custom_titlebar, "maximized": ctx.input(|i| i.viewport().maximized)})),
Err(e) => err(e),
},
"ui.resize" => {
let (Some(w), Some(h)) = (f("width"), f("height")) else { return err("missing width/height") };
ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(w.clamp(320.0, 8192.0) as f32, h.clamp(240.0, 8192.0) as f32)));
ok(Value::Null)
}
"ui.screenshot" => match s("path").map(vfs::check) {
Some(Err(e)) => err(e),
_ => Outcome::Screenshot { path: s("path").map(str::to_string) },
},
"ui.render" => {
let w = f("width").unwrap_or(1280.0).clamp(16.0, 8192.0) as u32;
let h = f("height").unwrap_or(800.0).clamp(16.0, 8192.0) as u32;
// As the window shows it (`view_scene`). The grid and the axes as the window shows
// them, unless the request says: `grid` and `axes` leave them out or put them in.
let shown = window_guides(app);
let guides = solidcraft_engine::view::Guides {
grid: p.get("grid").and_then(Value::as_bool).unwrap_or(shown.grid),
axes: p.get("axes").and_then(Value::as_bool).unwrap_or(shown.axes),
};
// A path outside the request's folders is refused before anything is drawn.
if let Some(Err(e)) = s("path").map(vfs::check) {
return err(e);
}
let scene = match view_scene(app, guides) {
Ok(scene) => scene,
Err(e) => return err(e),
};
let png = match solidcraft_engine::capture::png(&scene, &app.cam, w, h) {
Ok(png) => png,
Err(e) => return err(format!("render failed: {e}")),
};
// What drew it (gpu, gpu-software or cpu), and the warning a CPU render carries.
let (renderer, warning) = (png.renderer, solidcraft_engine::capture::warning(png.renderer));
match s("path") {
Some(path) => match vfs::check(path).and_then(|()| std::fs::write(path, &png.bytes)) {
Ok(()) => ok(json!({"path": path, "bytes": png.bytes.len(), "renderer": renderer, "warning": warning})),
Err(e) => err(e),
},
None => ok(json!({"bytes": png.bytes.len(), "renderer": renderer, "warning": warning})),
}
}
"app.quit" => {
// `force`: quit without asking about unsaved designs.
if p.get("force").and_then(Value::as_bool).unwrap_or(false) {
app.quit_requested = true;
} else {
crate::documents::request_quit(app);
}
if app.quit_requested {
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
}
ok(json!({"quitting": app.quit_requested, "asking": app.docs.closing.is_some()}))
}
other => err(format!("unknown method `{other}`")),
}
}
/// `ui.camera`: the viewport's orbit camera (`target`, `yaw`, `pitch`, `roll` in radians,
/// `distance` in mm, `fov`, `up`), or a new one. A field left out keeps its value, so a reply
/// passed back sets the same view again. `fov` is the angle the window draws with (see [`drawn`]). `fit`: frame the listed occurrences (ids or names;
/// `root`: the bodies outside every component), or everything (`true`), keeping the direction;
/// `false` frames nothing.
/// Nothing changes when a field is refused.
fn camera(app: &mut SolveApp, p: &Value) -> Result<Value, String> {
const FIELDS: [&str; 8] = ["target", "yaw", "pitch", "roll", "distance", "fov", "up", "fit"];
let o = match p {
Value::Null => serde_json::Map::new(),
Value::Object(o) => o.clone(),
_ => return Err("params must be an object".into()),
};
if let Some(k) = o.keys().find(|k| !FIELDS.contains(&k.as_str())) {
return Err(format!("unknown camera field `{k}` (it takes {})", FIELDS.join(", ")));
}
let mut cam = drawn(app);
let sets = o.keys().any(|k| k != "fit");
if sets {
let mut v = serde_json::to_value(cam).map_err(|e| e.to_string())?;
for (k, x) in o.iter().filter(|(k, _)| *k != "fit") {
v[k] = x.clone();
}
cam = serde_json::from_value(v).map_err(|e| format!("bad camera: {e}"))?;
// The distance cap is far past any Fit (so every reply replays) and still finite in f32.
if !cam.is_valid() || cam.distance > 1e15 || cam.pitch.abs() > std::f64::consts::FRAC_PI_2 {
return Err("the camera must be finite, with a distance up to 1e15 mm and a pitch within ±π/2".into());
}
// Straight up or down keeps a heading, as the standard views do.
let lim = std::f64::consts::FRAC_PI_2 - 1e-6;
cam.pitch = cam.pitch.clamp(-lim, lim);
// Perspective, its angle and the up axis are settings the camera follows, not its own.
if cam.fov != drawn(app).fov {
return Err("`fov` follows Perspective view (ui.set {perspective}) and its angle (ui.prefs {perspective_fov})".into());
}
cam.fov = app.cam.fov;
if cam.up != app.cam.up {
return Err("`up` follows the up axis preference (ui.prefs {up_axis})".into());
}
}
let fit = match o.get("fit") {
None | Some(Value::Bool(false)) => None,
Some(Value::Bool(true)) if !crate::render_workspace::active(app) && crate::viewport::view_bounds(app).is_empty() => {
return Err("nothing is shown to fit".into());
}
Some(Value::Bool(true)) => Some(None),
Some(Value::Array(list)) if !list.is_empty() && list.len() <= 10_000 => {
let occs = list.iter().map(|v| occurrence(&app.session, v)).collect::<Result<Vec<u64>, String>>()?;
let b = crate::dialogs_assembly::occurrence_bounds(&app.session, &occs);
if b.is_empty() {
return Err("those occurrences show nothing to fit".into());
}
Some(Some(b))
}
Some(_) => return Err("`fit` must be true, false or a list of occurrences".into()),
};
// A read leaves a view change that is animating alone.
if !sets && fit.is_none() {
return serde_json::to_value(drawn(app)).map_err(|e| e.to_string());
}
app.cancel_view_animation();
app.viewport.orbit_free = None;
app.cam = cam;
match fit {
Some(None) => app.fit_view(),
Some(Some(b)) => app.fit_bounds(b),
None => {}
}
serde_json::to_value(drawn(app)).map_err(|e| e.to_string())
}
/// The camera as the window draws it: with the view's angle ([`SolveApp::view_fov`]), or in Render
/// with the Render camera's own.
fn drawn(app: &SolveApp) -> Camera {
let mut cam = app.cam;
if !crate::render_workspace::active(app) {
cam.fov = app.view_fov();
}
cam
}
/// An occurrence by id or name (or a component's name: its first occurrence); 0 is the root.
fn occurrence(s: &solidcraft_engine::Session, v: &Value) -> Result<u64, String> {
let key = match v {
Value::Number(n) => n.to_string(),
Value::String(x) => x.clone(),
_ => return Err("an occurrence must be an id or a name".into()),
};
if key == "0" || key.eq_ignore_ascii_case("root") {
return Ok(0);
}
s.doc
.occurrences
.iter()
.find(|o| o.id.to_string() == key || o.name == key)
.map(|o| o.id)
.or_else(|| s.doc.find_component(&key).and_then(|c| s.doc.occurrence_of(c)).map(|o| o.id))
.ok_or_else(|| format!("no occurrence `{key}`"))
}
/// Save a screenshot PNG; without a `path`, in the temporary folder ([`vfs::temp_dir`], which in
/// the browser keeps it in memory: std's would panic there).
pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>) -> Value {
let [w, h] = image.size;
let path = path.map(str::to_string).unwrap_or_else(|| vfs::temp_dir().join("solidcraft-shot.png").to_string_lossy().to_string());
match write_screenshot(image, &path) {
Ok(()) => json!({"ok": true, "result": {"path": path, "width": w, "height": h}}),
Err(e) => json!({"ok": false, "error": e}),
}
}
/// Write `image` to `path` in the format its extension names (a PNG for `.png`), through
/// [`vfs`] like every other save: the disk natively, a download or browser storage in the web
/// app (#7192).
pub(crate) fn write_screenshot(image: &egui::ColorImage, path: &str) -> Result<(), String> {
let [w, h] = image.size;
let mut buf = Vec::with_capacity(w * h * 4);
for c in &image.pixels {
buf.extend_from_slice(&c.to_array());
}
let img = image::RgbaImage::from_raw(w as u32, h as u32, buf).ok_or("bad image")?;
let format = image::ImageFormat::from_path(path).map_err(|e| e.to_string())?;
let mut bytes = std::io::Cursor::new(Vec::new());
img.write_to(&mut bytes, format).map_err(|e| e.to_string())?;
vfs::write(path, bytes.get_ref()).map_err(|e| e.to_string())
}
#[cfg(test)]
mod tests {
fn panel_command_app() -> crate::SolveApp {
use crate::panel_runtime::*;
let h = PanelMountHarness::new(false).unwrap();
let catalogue = solidcraft_engine::panels::fixture_command_catalogue(h.runtime.layout().registry()).unwrap();
let mut app = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());
app.enable_panel_runtime(h.runtime, Box::<FakeAppPanelServices>::default()).unwrap();
app.panel_runtime_mut().unwrap().set_command_adapters(Box::new(catalogue), Box::new(FakeNativeAdapter::new(false))).unwrap();
app.enable_universal_panel_host(HostOptions::default()).unwrap();
prepare_panel_commands(&mut app);
app
}
fn prepare_panel_commands(app: &mut crate::SolveApp) {
use solidcraft_engine::panels::{LogicalRect, Point, Size};
let capacity = LogicalRect { origin: Point { x: 0.0, y: 0.0 }, size: Size { width: 1400.0, height: 1000.0 } };
app.panel_runtime.as_mut().unwrap().prepare_host(&app.session, capacity).unwrap();
}
fn panel_control(app: &mut crate::SolveApp, method: &str, params: serde_json::Value) -> serde_json::Value {
let (request, _) = super::ControlRequest::new(method, params);
match super::handle(app, &egui::Context::default(), &request) {
super::Outcome::Done(reply) => reply,
_ => panic!("unexpected screenshot"),
}
}
fn panel_steps() -> Vec<serde_json::Value> {
vec![
json!({"command":"panel.open","params":{"kind":"fixture.log","instance":"log","destination":{"type":"new_section","section":"logs","index":0,
"location":{"type":"dock","zone":"left"},"size":{"width":280,"height":240}}}}),
json!({"command":"panel.collapse","params":{"target":{"type":"instance","id":"log"},"collapsed":true}}),
]
}
#[test]
fn panel_control_single_atomic_batch_and_script_share_live_runtime_without_geometry_or_camera_work() {
use solidcraft_engine::panels::ActionSink;
let mut single = panel_command_app();
let mut batch = panel_command_app();
let mut script = panel_command_app();
// A one-body design with a deliberately different camera exercises the
// old first-body-fit condition, rather than making it vacuously false.
for app in [&mut single, &mut batch, &mut script] {
app.run("solid.box", json!({"length":10,"width":10,"height":10})).unwrap();
app.cam.distance *= 1.5;
app.session.mark_saved();
}
let doc = single.session.doc.clone();
let model = single.session.model.state();
let camera = single.cam;
let meshes: Vec<_> = model.bodies.iter().map(|body| body.cached_mesh()).collect();
let invariant = (single.session.document_id.clone(), single.session.revision, single.session.undo.len(), single.session.is_dirty());
for step in panel_steps() {
assert_eq!(panel_control(&mut single, "engine.execute", step)["ok"], true);
}
assert_eq!(panel_control(&mut batch, "engine.batch", json!({"commands":panel_steps(),"param_check":"strict"}))["ok"], true);
assert_eq!(panel_control(&mut script, "engine.script", json!({"commands":panel_steps(),"param_check":"strict"}))["ok"], true);
let live = single.panel_runtime().unwrap().layout().inspect();
assert_eq!(batch.panel_runtime().unwrap().layout().layout(), &live.layout);
assert_eq!(script.panel_runtime().unwrap().layout().layout(), &live.layout);
assert_eq!(panel_control(&mut single, "engine.execute", json!({"command":"layout.get"}))["result"]["state"]["revision"], live.revision);
assert!(crate::agent_cursor::picks(&single, "panel.open", &panel_steps()[0]["params"]).is_empty());
assert_eq!(single.cam, camera);
assert_eq!((single.session.document_id.clone(), single.session.revision, single.session.undo.len(), single.session.is_dirty()), invariant);
assert!(std::sync::Arc::ptr_eq(&doc, &single.session.doc));
assert!(std::sync::Arc::ptr_eq(&model, &single.session.model.state()));
for (old, new) in meshes.iter().zip(single.session.model.state().bodies.iter().map(|body| body.cached_mesh())) {
match (old, new) {
(Some(a), Some(b)) => assert!(std::sync::Arc::ptr_eq(a, &b)),
(None, None) => {}
_ => panic!("layout changed tessellation cache"),
}
}
}
#[test]
fn panel_control_reports_structured_missing_capability_unknown_fields_and_lifecycle_batch_errors() {
use solidcraft_engine::panels::ActionSink;
let mut disabled = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());
let reply = panel_control(&mut disabled, "engine.execute", json!({"command":"layout.get"}));
assert_eq!(reply["ok"], false);
assert_eq!(reply["panel_error"]["rule"], "capability");
let mut app = panel_command_app();
for check in ["off", "warn", "strict"] {
let reply = panel_control(&mut app, "engine.execute", json!({"command":"panel.list","params":{"unknown":true},"param_check":check}));
assert_eq!(reply["ok"], false);
assert_eq!(reply["panel_error"]["rule"], "schema");
assert_eq!(reply["param_check"], check);
}
assert_eq!(panel_control(&mut app, "engine.execute", panel_steps()[0].clone())["ok"], true);
let before = app.panel_runtime().unwrap().layout().inspect();
let reply = panel_control(
&mut app,
"engine.batch",
json!({"commands":[
{"command":"panel.close","params":{"target":{"type":"instance","id":"log"}}},
{"command":"panel.open","params":{"kind":"fixture.log","instance":"log"}}]}),
);
assert_eq!(reply["ok"], false);
assert_eq!(reply["panel_error"]["rule"], "lifecycle");
assert_eq!(app.panel_runtime().unwrap().layout().inspect(), before);
}
#[test]
fn panel_control_catalogue_batches_and_scripts_retain_memory_and_refuse_unsupported_atomic_domains() {
let mut app = panel_command_app();
assert_eq!(panel_control(&mut app, "engine.execute", panel_steps()[0].clone())["ok"], true);
let reply = panel_control(
&mut app,
"engine.batch",
json!({"commands":[
{"command":"layout.save","params":{"name":"Control saved"}},
{"command":"layout.reset"}, {"command":"layout.apply","params":{"name":"Control saved"}}, {"command":"layout.get"}]}),
);
assert_eq!(reply["ok"], true, "{reply}");
assert_eq!(reply["result"]["completed"], 4);
assert_eq!(reply["result"]["results"][3]["state"]["layout"]["instances"][0]["id"], "log");
let mixed = json!({"commands":[{"command":"layout.get"},{"command":"file.new"}]});
let before = app.session.document_id.clone();
let reply = panel_control(&mut app, "engine.batch", mixed);
assert_eq!(reply["panel_error"]["rule"], "capability");
assert_eq!(app.session.document_id, before);
let reply = panel_control(
&mut app,
"engine.script",
json!({"commands":[
{"command":"layout.workspace.select","params":{"workspace":"fixture.other"}},
{"command":"layout.apply","params":{"name":"Control saved"}}, {"command":"layout.get"}]}),
);
assert_eq!(reply["ok"], true, "{reply}");
assert_eq!(reply["result"][2]["state"]["layout"]["workspace"], "fixture.other");
}
#[test]
fn null_panel_params_match_single_atomic_sequential_and_script_routes() {
let mut app = panel_command_app();
let expected = app.run("panel.list", json!({})).unwrap();
assert_eq!(app.run("panel.list", serde_json::Value::Null).unwrap(), expected);
let single = panel_control(&mut app, "engine.execute", json!({"command":"panel.list","params":null}));
assert_eq!(single["result"], expected);
for (method, rollback) in [("engine.batch", true), ("engine.batch", false), ("engine.script", false)] {
let reply = panel_control(
&mut app,
method,
json!({"rollback":rollback,"commands":[
{"command":"panel.list","params":null},{"command":"layout.get","params":null},
]}),
);
assert_eq!(reply["ok"], true, "{method}: {reply}");
let results = if method == "engine.script" { &reply["result"] } else { &reply["result"]["results"] };
assert_eq!(results[0], expected, "{method}");
assert_eq!(results[1]["state"], expected["state"]);
}
}
#[test]
fn null_normal_document_params_remain_accepted_in_panel_containing_sequences() {
for method in ["engine.batch", "engine.script"] {
let mut app = panel_command_app();
let previous = app.session.document_id.clone();
let reply = panel_control(
&mut app,
method,
json!({"rollback":false,"commands":[
{"command":"file.new","params":null},{"command":"panel.list","params":null},{"command":"parameters.list","params":null},
]}),
);
assert_eq!(reply["ok"], true, "{reply}");
assert!(reply["result"].get("failed").is_none(), "{reply}");
assert_ne!(app.session.document_id, previous);
assert_eq!(app.panel_runtime().unwrap().environment().document.as_ref().unwrap().0, app.session.document_id);
}
}
#[test]
fn blur_control_validates_before_mutation_and_reports_no_gpu() {
let mut h = crate::scenario::Harness::new();
for invalid in [json!(-1), json!(61), json!("18"), json!(null)] {
let reply = h.call("ui.blur", json!({"radius_px":invalid}));
assert_eq!(reply["ok"], false, "{reply}");
assert_eq!(h.app.blur.radius(), 0.0);
}
let reply = h.call("ui.blur", json!({"radius_px":18,"surface_alpha":2}));
assert_eq!(reply["ok"], false);
assert_eq!(h.app.blur.radius(), 0.0);
let reply = h.call("ui.blur", json!({"radius_px":18,"surface_alpha":0.7}));
assert_eq!(reply["ok"], true);
assert!(matches!(h.app.blur.capability(), crate::blur::Capability::Unavailable(_)));
h.frames(2);
assert_eq!(h.app.blur.counters().textures_created, 0);
assert_eq!(h.app.blur.counters().markers_emitted, 0);
h.call("ui.blur", json!({"radius_px":0,"surface_alpha":null}));
assert_eq!(h.app.blur.radius(), 0.0);
}
#[test]
fn blur_evidence_fixtures_are_atomic_transient_and_never_fake_support() {
let mut h = crate::scenario::Harness::new();
let source: Value = serde_json::from_str(include_str!("../tests/fixtures/theme-blur.json")).unwrap();
assert_eq!(h.call("ui.prefs", json!({"theme_import":source,"theme_options":{"blur-review":{"blur":40}}}))["ok"], true);
h.frames(2);
let saved = h.app.preferences.theme_options.clone();
let revision = h.app.session.revision;
for invalid in [json!(null), json!([]), json!("available"), json!("unknown")] {
assert_eq!(h.call("ui.blur", json!({"fixture":invalid,"radius_px":8}))["ok"], false);
assert_eq!(h.app.blur.radius(), 40.0);
assert_eq!(h.app.blur_session.harness_radius, None);
}
for fixture in ["gpu-software", "reduce-transparency", "web-unsupported"] {
let reply = h.call("ui.blur", json!({"fixture":fixture}));
assert_eq!(reply["result"]["evidence_fixture"], fixture);
assert_eq!(reply["result"]["available"], false);
h.frames(2);
assert_eq!(h.app.blur.counters().textures_created, 0);
assert_eq!(h.app.blur.counters().markers_emitted, 0);
assert_eq!(h.app.preferences.theme_options, saved);
}
h.call("ui.blur", json!({"fixture":"clear"}));
h.call("ui.blur", json!({"fixture":"guard-60"}));
assert_eq!((h.app.blur_session.guard.cap, h.app.blur_session.guard.notice), (4, true));
assert_eq!(h.app.blur_session.evidence_fixture, Some("guard-60"));
h.app.blur_session.guard.undo();
assert_eq!((h.app.blur_session.guard.cap, h.app.blur_session.guard.opted_out), (5, true));
h.call("ui.blur", json!({"fixture":"guard-60"}));
assert_eq!(h.app.blur_session.guard.cap, 5);
assert_eq!(h.app.session.revision, revision, "quality actions never enter document undo");
assert_eq!(h.app.preferences.theme_options, saved);
h.call("ui.blur", json!({"fixture":"clear"}));
assert!(h.app.blur_session.evidence_fixture.is_none());
assert!(matches!(h.app.blur.capability(), crate::blur::Capability::Unavailable(_)), "clearing a fixture cannot manufacture a GPU");
}
use serde_json::json;
use solidcraft_engine::panels::ActionSink;
use solidcraft_engine::{Sel, Session};
use super::*;
use crate::Services;
#[test]
fn panel_fixture_validates_whole_request_before_activation() {
let mut app = SolveApp::new(Session::default(), Services::default());
let doc = app.session.doc.clone();
let model = app.session.model.state();
let camera = app.cam;
for params in [
Value::Null,
json!([]),
json!({"enabled":null}),
json!({"enabled":"true"}),
json!({"preset":false}),
json!({"preset":"unknown"}),
json!({"preset":"x".repeat(4096)}),
json!({"enabled":false,"preset":"docks"}),
json!({"enabled":true,"unknown":0}),
] {
assert!(crate::panel_runtime::control_specimen(&mut app, &params).is_err(), "{params}");
assert!(app.panel_runtime().is_none());
assert!(!app.universal_panel_host_enabled());
assert!(std::sync::Arc::ptr_eq(&doc, &app.session.doc));
assert!(std::sync::Arc::ptr_eq(&model, &app.session.model.state()));
assert_eq!(app.cam, camera);
}
let reply = crate::panel_runtime::control_specimen(&mut app, &json!({})).unwrap();
assert_eq!(reply["enabled"], false);
assert!(reply["host"].is_null());
}
#[test]
fn panel_fixture_presets_mount_retained_content_and_inspection_does_not_tick() {
let mut h = crate::scenario::Harness::new();
for (name, count) in [
("docks", 4),
("tabs", 4),
("collapsed", 4),
("floating", 4),
("overflow", 24),
("pinned", 4),
("columns", 3),
("stack_tabs", 4),
("content_fill", 2),
("inline", 1),
] {
let before = crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap()["session"].clone();
h.step(&json!({"panel_fixture":{"enabled":true,"preset":name}})).unwrap();
h.frames(2);
assert!(h.app.universal_panel_host_enabled());
assert!(h.app.universal_panel_frame().is_some());
let first = crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap();
let second = crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap();
assert_eq!(first, second, "inspection itself must not tick or dispatch");
assert_eq!(first["runtime"]["probe"]["preset"], name);
assert_eq!(first["runtime"]["controller_count"], count);
assert_eq!(first["session"], before, "host-only work changed Session for {name}");
assert_eq!(first["runtime"]["probe"]["content_command_calls"], 0);
let takeover = crate::panel_runtime::control_specimen(&mut h.app, &json!({"enabled":true,"preset":"tabs"}));
assert!(takeover.is_err());
assert_eq!(crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap(), second);
h.step(&json!({"panel_fixture":{"enabled":false}})).unwrap();
assert!(h.app.panel_runtime().is_none());
assert!(!h.app.universal_panel_host_enabled());
}
}
#[test]
fn panel_fixture_teardown_honors_live_editor_guard_atomically() {
fn click_visible_guard(h: &mut crate::scenario::Harness, guard: &str) {
for _ in 0..16 {
let body =
h.app.universal_panel_frame().unwrap().layout.sections.iter().find(|section| section.instance.0 == "specimen-0").unwrap().body;
let body = crate::panel_runtime::egui_rect(body.expect("expanded specimen body"));
let checkbox = h
.output
.accesskit_update
.as_ref()
.unwrap()
.nodes
.iter()
.find(|(_, node)| node.role() == egui::accesskit::Role::CheckBox && node.label() == Some(guard))
.and_then(|(_, node)| node.bounds())
.map(|bounds| {
egui::Rect::from_min_max(egui::pos2(bounds.x0 as f32, bounds.y0 as f32), egui::pos2(bounds.x1 as f32, bounds.y1 as f32))
});
if let Some(checkbox) = checkbox.filter(|bounds| body.contains(bounds.center())) {
assert!(checkbox.intersect(body).is_positive(), "the real checkbox must be visible inside its actual Body clip");
let at = checkbox.center();
h.frame_with(vec![egui::Event::PointerMoved(at)]);
for pressed in [true, false] {
h.frame_with(vec![
egui::Event::PointerMoved(at),
egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE },
]);
}
return;
}
// The specimen owns this ScrollArea. Accessibility also lists
// clipped content, so reveal the real checkbox before clicking.
let at = egui::pos2(body.center().x, body.top() + 4.0);
h.frame_with(vec![
egui::Event::PointerMoved(at),
egui::Event::MouseWheel {
source: egui::MouseWheelSource::Unknown,
unit: egui::MouseWheelUnit::Point,
delta: egui::vec2(0.0, -120.0),
modifiers: egui::Modifiers::NONE,
phase: egui::TouchPhase::Move,
},
]);
for _ in 0..120 {
if !h.ctx.input(|input| input.is_scrolling()) {
break;
}
h.frame();
}
assert!(!h.ctx.input(|input| input.is_scrolling()), "the checkbox click requires a settled Body scroll");
}
panic!("the actual specimen guard checkbox was never revealed in its Body");
}
let mut h = crate::scenario::Harness::new();
h.step(&json!({"panel_fixture":{"preset":"docks"}})).unwrap();
let guard = h.app.tr("ui.panel_fixture.guard").to_string();
click_visible_guard(&mut h, &guard);
let before = crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap();
let editor = &before["runtime"]["probe"]["controllers"][0];
assert_eq!(editor["reject_cancel"], true);
assert_eq!(editor["transaction_live"], true);
assert!(crate::panel_runtime::control_specimen(&mut h.app, &json!({"enabled":false})).is_err());
assert_eq!(crate::panel_runtime::inspect_host_specimen(&mut h.app).unwrap(), before);
click_visible_guard(&mut h, &guard);
h.step(&json!({"panel_fixture":{"enabled":false}})).unwrap();
assert!(h.app.panel_runtime().is_none());
}
#[test]
fn panel_fixture_rejects_takeover_and_teardown_of_unrelated_runtime() {
let harness = crate::panel_runtime::PanelMountHarness::new(false).unwrap();
#[derive(Default)]
struct Provider {
models: crate::panel_runtime::FakeModels,
commands: crate::panel_runtime::FakeContentCommands,
local: crate::panel_runtime::FakeLocalServices,
}
impl crate::panel_runtime::AppPanelServices for Provider {
fn refresh_read_only(&mut self, _: &Session) -> solidcraft_engine::panels::PanelResult<()> {
Ok(())
}
fn services(&mut self) -> crate::panel_runtime::ContentServices<'_> {
crate::panel_runtime::ContentServices { models: &self.models, commands: &mut self.commands, local: &mut self.local }
}
}
let mut app = SolveApp::new(Session::default(), Services::default());
app.panel_runtime = Some(crate::panel_runtime::AppPanelRuntime::new(harness.runtime, Box::<Provider>::default()).unwrap());
let before = app.panel_runtime().unwrap().layout().inspect();
for params in [json!({"enabled":true}), json!({"enabled":false})] {
assert!(crate::panel_runtime::control_specimen(&mut app, &params).is_err());
assert_eq!(app.panel_runtime().unwrap().layout().inspect(), before);
}
}
#[test]
fn viewport_status_fixture_rejects_hostile_presets_without_mutating_the_session() {
let mut h = crate::scenario::Harness::new();
let revision = h.app.session.revision;
for params in [Value::Null, json!([]), json!({}), json!({"preset":false}), json!({"preset":[]}), json!({"preset":"unknown"})] {
let reply = h.call("ui.status_fixture", params);
assert_eq!(reply["ok"], false, "{reply}");
assert_eq!(h.app.session.revision, revision);
}
let reply = h.call("ui.status_fixture", json!({"preset":"mode"}));
assert_eq!(reply["ok"], true, "{reply}");
assert_eq!(h.app.session.revision, revision);
assert!(h.app.session.analysis.is_none());
for preset in ["off", "mode"] {
h.call("ui.status_fixture", json!({"preset":preset}));
h.call("ui.resize", json!({"width":200,"height":600}));
h.frames(4);
assert_eq!(h.app.session.revision, revision);
h.call("ui.resize", json!({"width":1400,"height":900}));
h.frames(4);
}
}
#[test]
fn touchpad_automation_moves_with_modifiers_and_releases_without_buttons() {
let mut h = crate::scenario::Harness::new();
h.app.preferences.nav = "touchpad".into();
h.call("ui.move", json!({"x":800,"y":500}));
let before = h.app.cam;
h.call("ui.move", json!({"x":800,"y":500,"shift":true}));
h.step(&json!({"move":[830,520],"shift":true})).unwrap();
assert_ne!(h.app.cam.target, before.target);
assert_eq!(h.app.cam.yaw, before.yaw);
assert!(!h.ctx.input(|i| i.pointer.any_down()));
h.call("ui.move", json!({"x":830,"y":520,"alt":true}));
h.step(&json!({"move":[850,530],"alt":true})).unwrap();
assert!((h.app.cam.yaw - before.yaw - 0.16).abs() < 1e-6);
let after = h.app.cam;
h.call("ui.move", json!({"x":800,"y":500}));
h.frames(3);
assert_eq!(h.app.cam, after);
assert!(h.ctx.input(|i| i.modifiers.is_none()));
assert!(h.app.session.selection.is_empty());
assert!(h.app.viewport.boxsel.is_none());
}
/// #8480: `ui.scroll` with `ctrl: true` replays a Ctrl+wheel pinch in points. Without
/// `ctrl` the wheel stays a line wheel on the mouse path.
#[test]
fn scroll_sends_a_native_pinch_with_ctrl() {
let mut app = SolveApp::new(Session::default(), Services::default());
let ctx = crate::fonts::test_context();
let (req, _) = ControlRequest::new("ui.scroll", json!({"x":200,"y":300,"delta":40,"ctrl":true}));
assert!(matches!(handle(&mut app, &ctx, &req), Outcome::Done(_)));
// The pointer event is delivered a frame before the wheel (one pointer event per frame).
let mut events = Vec::new();
for _ in 0..3 {
let mut raw = egui::RawInput::default();
app.raw_input_hook(&mut raw);
events.extend(raw.events);
}
let wheels: Vec<_> = events
.iter()
.filter_map(|e| match e {
egui::Event::MouseWheel { unit, delta, modifiers, .. } => Some((*unit, *delta, *modifiers)),
_ => None,
})
.collect();
assert_eq!(wheels.len(), 1, "one wheel event: {wheels:?}");
let (unit, delta, modifiers) = wheels[0];
assert_eq!(unit, egui::MouseWheelUnit::Point, "the pinch replay uses points");
assert!((delta.y - 40.0).abs() < 1e-6, "points pass through: {delta:?}");
assert!(modifiers.matches_any(egui::Modifiers::COMMAND), "Ctrl is held: {modifiers:?}");
let changes: Vec<_> = events
.iter()
.filter_map(|e| match e {
egui::Event::ModifiersChanged(m) => Some(*m),
_ => None,
})
.collect();
assert!(changes.iter().any(|m| m.matches_any(egui::Modifiers::COMMAND)), "Ctrl is set for the wheel: {changes:?}");
assert_eq!(changes.last().copied(), Some(egui::Modifiers::NONE), "Ctrl is released after it: {changes:?}");
app.synthetic.clear();
let (req, _) = ControlRequest::new("ui.scroll", json!({"x":200,"y":300,"delta":40}));
assert!(matches!(handle(&mut app, &ctx, &req), Outcome::Done(_)));
let mut events = Vec::new();
for _ in 0..2 {
let mut raw = egui::RawInput::default();
app.raw_input_hook(&mut raw);
events.extend(raw.events);
}
let wheel = events.iter().find_map(|e| match e {
egui::Event::MouseWheel { unit, delta, modifiers, .. } => Some((*unit, *delta, *modifiers)),
_ => None,
});
let (unit, delta, modifiers) = wheel.expect("a wheel event");
assert_eq!(unit, egui::MouseWheelUnit::Line, "without ctrl the wheel stays a mouse wheel");
assert!((delta.y * ctx.options(|o| o.input_options.line_scroll_speed) - 40.0).abs() < 1e-3, "lines land on the same points: {delta:?}");
assert!(!modifiers.matches_any(egui::Modifiers::COMMAND), "no modifier without ctrl");
assert!(app.synthetic.is_empty());
}
#[test]
fn scroll_rejects_invalid_input_without_queuing_events() {
let mut app = SolveApp::new(Session::default(), Services::default());
let ctx = crate::fonts::test_context();
for invalid in
[json!({"unit":"invalid"}), json!({"unit":42}), json!({"unit":null}), json!({"x":1e300}), json!({"y":-1e300}), json!({"delta":1e300})]
{
let mut params = json!({"x":200,"y":300,"delta":40,"ctrl":true});
params.as_object_mut().unwrap().extend(invalid.as_object().unwrap().clone());
let (req, _) = ControlRequest::new("ui.scroll", params.clone());
let Outcome::Done(reply) = handle(&mut app, &ctx, &req) else { panic!("not a scroll reply") };
assert_eq!(reply["ok"], false, "{params}: {reply}");
assert!(app.synthetic.is_empty(), "a rejected scroll must not queue input: {params}");
}
}
#[test]
fn touchpad_drag_positioning_releases_previous_motion_modifiers() {
let mut h = crate::scenario::Harness::new();
h.app.preferences.nav = "touchpad".into();
h.call("ui.move", json!({"x":800,"y":500}));
for modifier in ["shift", "alt"] {
let mut params = json!({"x":800,"y":500});
params[modifier] = json!(true);
h.call("ui.move", params);
let before = h.app.cam;
h.call("ui.drag", json!({"x0":900,"y0":500,"x1":930,"y1":520,"shift":true,"steps":2}));
assert_eq!(h.app.cam, before, "positioning a selection drag must not inherit {modifier} motion");
assert!(!h.ctx.input(|i| i.pointer.any_down()));
}
}
#[test]
fn touchpad_text_prefix_does_not_collapse_queued_pointer_frames() {
let mut app = SolveApp::new(Session::default(), Services::default());
let ctx = crate::fonts::test_context();
let (req, _) = ControlRequest::new("ui.text", json!({"text":"prefix"}));
assert!(matches!(handle(&mut app, &ctx, &req), Outcome::Done(_)));
for params in [json!({"x":10,"y":10,"shift":true}), json!({"x":20,"y":20,"alt":true}), json!({"x":30,"y":30})] {
let (req, _) = ControlRequest::new("ui.move", params);
assert!(matches!(handle(&mut app, &ctx, &req), Outcome::Done(_)));
}
for (p, shift, alt) in [(10.0, true, false), (20.0, false, true), (30.0, false, false)] {
let mut raw = egui::RawInput::default();
app.raw_input_hook(&mut raw);
let mut out = ctx.run_ui(raw, |ui| {
ui.input(|i| {
assert_eq!(i.pointer.hover_pos(), Some(egui::pos2(p, p)));
assert_eq!((i.modifiers.shift, i.modifiers.alt), (shift, alt));
});
});
out.textures_delta.clear();
}
assert!(app.synthetic.is_empty());
}
#[test]
fn touchpad_automation_preserves_each_queued_moves_modifiers() {
let mut app = SolveApp::new(Session::default(), Services::default());
let ctx = crate::fonts::test_context();
for params in [json!({"x":10,"y":10,"shift":true}), json!({"x":20,"y":20,"alt":true}), json!({"x":30,"y":30})] {
let (req, _) = ControlRequest::new("ui.move", params);
assert!(matches!(handle(&mut app, &ctx, &req), Outcome::Done(_)));
}
for (p, shift, alt) in [(10.0, true, false), (20.0, false, true), (30.0, false, false)] {
let mut raw = egui::RawInput::default();
app.raw_input_hook(&mut raw);
let mut out = ctx.run_ui(raw, |ui| {
ui.input(|i| {
assert_eq!(i.pointer.hover_pos(), Some(egui::pos2(p, p)));
assert_eq!((i.modifiers.shift, i.modifiers.alt), (shift, alt));
assert!(!i.pointer.any_down());
});
});
out.textures_delta.clear();
}
assert!(app.synthetic.is_empty());
}
/// #6646: `document.revision` names the active design and what it holds. The revision moves on
/// an edit, a parameter, a hide, an undo and a redo, never on a read or a selection, and never
/// comes back; the id stays through edits and is another for another tab of the same name.
#[test]
fn document_revision_follows_the_design_and_tells_tabs_apart() {
fn now(h: &mut crate::scenario::Harness) -> (String, u64) {
let r = h.call("document.revision", json!({}));
assert_eq!(r["ok"], true, "{r}");
(r["result"]["document_id"].as_str().unwrap_or_default().to_string(), r["result"]["revision"].as_u64().unwrap_or_default())
}
fn run(h: &mut crate::scenario::Harness, command: &str, params: Value) {
let r = h.call("engine.execute", json!({"command": command, "params": params}));
assert_eq!(r["ok"], true, "{command}: {r}");
}
let mut h = crate::scenario::Harness::new();
let (id, mut last) = now(&mut h);
assert!(!id.is_empty() && last > 0, "{id} {last}");
// Reads and a selection leave it as it is (the view's own revision moves on a selection).
let view = h.app.session.revision;
h.call("document.inspect", json!({}));
h.call("ui.inspect", json!({}));
run(&mut h, "select.clear", json!({}));
assert!(h.app.session.revision > view);
assert_eq!(now(&mut h), (id.clone(), last));
for (command, params) in [
("solid.box", json!({"length": 10, "width": 10, "height": 10})),
("parameters.add", json!({"name": "w", "expression": "12 mm"})),
("browser.visibility", json!({"folder": "bodies", "visible": false})),
("edit.undo", json!({})),
("edit.redo", json!({})),
] {
run(&mut h, command, params);
let (same, revision) = now(&mut h);
assert_eq!(same, id, "{command} keeps the id");
assert!(revision > last, "{command}: {revision} after {last}");
assert_eq!(now(&mut h).1, revision, "asking again after {command}");
last = revision;
}
// Another tab with the same name is another design; back on the first, its revision is
// the one it had.
h.call("ui.documents", json!({"action": "new"}));
let tabs = h.call("ui.documents", json!({}))["result"]["documents"].clone();
assert_eq!(tabs[0]["name"], tabs[1]["name"], "{tabs}");
let (other, other_revision) = now(&mut h);
assert_ne!(other, id);
assert!(other_revision > last, "{other_revision} after {last}");
h.call("ui.documents", json!({"action": "switch", "index": 0}));
assert_eq!(now(&mut h), (id.clone(), last));
// A design started in its place is another one too, and its revision is new.
run(&mut h, "file.new", json!({}));
let (fresh, revision) = now(&mut h);
assert!(fresh != id && fresh != other, "{fresh}");
assert!(revision > other_revision, "{revision} after {other_revision}");
}
/// #6985: while a connection is subscribed, a frame publishes the active design as
/// `document.revision` names it: the same after a selection, a new revision after an edit,
/// another id on another tab; nothing while none is. `control.subscribe` answers what
/// `document.revision` does, and a connection that waited through several changes is told
/// only of the latest.
#[test]
fn subscribed_frames_publish_the_design() {
static WATCH: DesignWatch = DesignWatch::new();
let now = || WATCH.now().clone();
let mut h = crate::scenario::Harness::new();
publish_design(&mut h.app, &WATCH);
assert_eq!(now(), None, "nobody subscribed");
let counted = WATCH.join();
let subscribed = h.call("control.subscribe", json!({}));
assert_eq!(subscribed["result"], h.call("document.revision", json!({}))["result"], "{subscribed}");
publish_design(&mut h.app, &WATCH);
let (id, first) = now().unwrap();
assert_eq!(json!({"document_id": id, "revision": first}), subscribed["result"]);
h.call("engine.execute", json!({"command": "select.clear", "params": {}}));
publish_design(&mut h.app, &WATCH);
assert_eq!(now(), Some((id.clone(), first)), "a selection is no change");
h.call("engine.execute", json!({"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}));
publish_design(&mut h.app, &WATCH);
let (same, second) = now().unwrap();
assert!(same == id && second > first, "{same} {second} after {first}");
h.call("engine.execute", json!({"command": "edit.undo", "params": {}}));
publish_design(&mut h.app, &WATCH);
let third = now().unwrap().1;
assert!(third > second, "{third} after {second}");
let stop = AtomicBool::new(false);
assert_eq!(WATCH.wait(&(id.clone(), first), &stop, Duration::ZERO), Some((id.clone(), third)));
// New on a blank design reuses its tab: the box comes back first.
h.call("engine.execute", json!({"command": "edit.redo", "params": {}}));
h.call("ui.documents", json!({"action": "new"}));
publish_design(&mut h.app, &WATCH);
assert!(now().is_some_and(|(other, _)| other != id), "{:?}", now());
drop(counted);
assert!(!WATCH.subscribed());
}
fn render(app: &mut SolveApp, path: &std::path::Path) -> Vec<u8> {
let (req, _rx) = ControlRequest::new("ui.render", json!({"path": path.to_string_lossy(), "width": 200, "height": 140}));
match handle(app, &crate::fonts::test_context(), &req) {
Outcome::Done(v) => assert_eq!(v["ok"], true, "{v}"),
Outcome::Screenshot { .. } => panic!("ui.render took a screenshot"),
}
std::fs::read(path).unwrap()
}
/// `ui.render` draws in the window's theme (#974): its background is the viewport's, light
/// or dark, and with the 3D view in the other theme's colours, the view's (#4146).
#[test]
fn model_render_is_in_the_windows_theme() {
if !crate::gpu::test_picture_renderer() {
return;
}
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
let mut app = SolveApp::new(s, Services::default());
let dir = std::env::temp_dir().join(format!("solidcraft-render-theme-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
use crate::theme::ViewportTheme;
for (window, view) in
[(false, ViewportTheme::Theme), (true, ViewportTheme::Theme), (true, ViewportTheme::Light), (false, ViewportTheme::Dark)]
{
app.ui.dark = window;
app.preferences.viewport_theme = view;
let dark = app.viewport_dark();
let theme = format!("{window}-{}", view.id());
let png = render(&mut app, &dir.join(format!("{theme}.png")));
let img = image::load_from_memory(&png).unwrap().to_rgba8();
// The top row is the background's top: its most common colour.
let mut counts = std::collections::HashMap::new();
for x in 0..img.width() {
*counts.entry(img.get_pixel(x, 0).0).or_insert(0) += 1;
}
let top = counts.into_iter().max_by_key(|(_, n)| *n).map(|(c, _)| c).unwrap();
let want = if dark { crate::theme::Tokens::dark() } else { crate::theme::Tokens::light() }.viewport_top;
let near = top.iter().zip([want.r(), want.g(), want.b()]).all(|(a, b)| a.abs_diff(b) <= 2);
assert!(near, "{theme}: the render's top row is {top:?}, the view's background {want:?}");
}
std::fs::remove_dir_all(&dir).ok();
}
/// A model render shows the section the window shows: the open Section Analysis dialog's
/// preview too, not only a committed `inspect.section`.
#[test]
fn model_render_shows_the_section_dialog_preview() {
if !crate::gpu::test_picture_renderer() {
return;
}
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
let mut app = SolveApp::new(s, Services::default());
let dir = std::env::temp_dir().join(format!("solidcraft-render-section-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let whole = render(&mut app, &dir.join("whole.png"));
app.session.selection = vec![Sel::Plane { name: "XZ".into() }];
app.start("inspect.section");
let Some(crate::dialogs::Kind::Section { offset, .. }) = app.dialog.as_mut().map(|d| &mut d.kind) else { panic!("no section dialog") };
*offset = "15 mm".into();
assert!(app.session.section.is_none() && crate::viewport::section_plane(&app).is_some());
let preview = render(&mut app, &dir.join("preview.png"));
assert!(whole != preview, "the model render ignores the section the window shows");
// Committed, it renders the same.
app.run("inspect.section", json!({"plane": "XZ", "offset": 15})).unwrap();
app.dialog = None;
assert!(render(&mut app, &dir.join("committed.png")) == preview, "the committed section renders differently");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn model_render_cosmetic_threads_preserve_section_hatch_preview() {
let mut app = SolveApp::new(Session::default(), Services::default());
for cosmetic_threads in [false, true] {
app.preferences.cosmetic_threads = cosmetic_threads;
for hatch in [false, true] {
app.session.section_hatch = hatch;
assert_eq!(view_scene(&app, Default::default()).unwrap().plain_cap, !hatch);
app.session.selection = vec![Sel::Plane { name: "XZ".into() }];
app.start("inspect.section");
let Some(crate::dialogs::Kind::Section { hatch: preview_hatch, .. }) = app.dialog.as_mut().map(|d| &mut d.kind) else {
panic!("no section dialog")
};
*preview_hatch = !hatch;
assert_eq!(
view_scene(&app, Default::default()).unwrap().plain_cap,
hatch,
"the preview's hatch overrides the session with cosmetic_threads={cosmetic_threads}"
);
app.dialog = None;
}
}
}
/// `ui.render` with extra request parameters.
/// A `ui.render` of `app` to `path` with `extra` parameters: the PNG, and what drew it.
fn render_with(app: &mut SolveApp, path: &std::path::Path, extra: serde_json::Value) -> (Vec<u8>, String) {
let mut params = json!({"path": path.to_string_lossy(), "width": 200, "height": 140});
for (k, v) in extra.as_object().into_iter().flatten() {
params[k.as_str()] = v.clone();
}
let (req, _rx) = ControlRequest::new("ui.render", params);
let renderer = match handle(app, &crate::fonts::test_context(), &req) {
Outcome::Done(v) => {
assert_eq!(v["ok"], true, "{v}");
v["result"]["renderer"].as_str().or(v["renderer"].as_str()).unwrap_or("unknown").to_string()
}
Outcome::Screenshot { .. } => panic!("ui.render took a screenshot"),
};
(std::fs::read(path).unwrap(), renderer)
}
/// A model render draws the ground grid (it cuts through a part that straddles Z 0) and the
/// origin's axes as the window does, by the Grid and Origin switches, and `grid` and `axes`
/// in the request say otherwise for that render.
#[test]
fn model_render_follows_the_grid_and_origin_switches_unless_asked() {
if !crate::gpu::test_picture_renderer() {
return;
}
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20, "corner": [10, -15, -10]})).unwrap();
let mut app = SolveApp::new(s, Services::default());
app.cam.set_view(solidcraft_engine::render::StandardView::Front);
let dir = std::env::temp_dir().join(format!("solidcraft-render-guides-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("shot.png");
// Every picture is compared byte for byte, so each must come from the same renderer.
let drawn_by = std::cell::RefCell::new(Vec::new());
let shot = |app: &mut SolveApp, extra: serde_json::Value| {
let (png, renderer) = render_with(app, &path, extra);
drawn_by.borrow_mut().push(renderer);
png
};
let all = shot(&mut app, json!({}));
let no_grid = shot(&mut app, json!({"grid": false}));
let no_axes = shot(&mut app, json!({"axes": false}));
let bare = shot(&mut app, json!({"grid": false, "axes": false}));
let pictures = [&all, &no_grid, &no_axes, &bare];
for (i, a) in pictures.iter().enumerate() {
for b in &pictures[i + 1..] {
assert!(a != b, "two of the pictures are the same");
}
}
// A picture that is not the one expected: both are kept, with how much they differ, so a
// failure that does not come back on a rerun still leaves its evidence.
let same = |step: &str, got: Vec<u8>, want: &Vec<u8>| {
if got == *want {
return;
}
let kept = std::env::temp_dir().join(format!("solidcraft-render-guides-failed-{}", std::process::id()));
let _ = std::fs::create_dir_all(&kept);
let _ = std::fs::write(kept.join(format!("{step}-got.png")), &got);
let _ = std::fs::write(kept.join(format!("{step}-want.png")), want);
let differ = match (image::load_from_memory(&got), image::load_from_memory(want)) {
(Ok(a), Ok(b)) if a.width() == b.width() && a.height() == b.height() => {
let (a, b) = (a.to_rgba8(), b.to_rgba8());
format!("{} of {} pixels differ", a.pixels().zip(b.pixels()).filter(|(x, y)| x != y).count(), a.width() * a.height())
}
(Ok(a), Ok(b)) => format!("{}×{} against {}×{}", a.width(), a.height(), b.width(), b.height()),
_ => "a picture does not decode".to_string(),
};
panic!("{step}: not the picture expected ({differ}; drawn by {:?}); both kept in {}", drawn_by.borrow(), kept.display());
};
// With the Grid switch off the render has no grid, and `grid: true` brings it back.
app.ui.show_grid = false;
same("grid-off", shot(&mut app, json!({})), &no_grid);
same("grid-off-asked-on", shot(&mut app, json!({"grid": true})), &all);
// With the Origin off too it has neither; `axes: true` puts the axes back.
app.set_origin_shown(false);
same("both-off", shot(&mut app, json!({})), &bare);
same("both-off-axes-asked-on", shot(&mut app, json!({"axes": true})), &no_grid);
// The Origin and the Grid back on: the first picture again.
app.ui.show_grid = true;
app.set_origin_shown(true);
same("both-on-again", shot(&mut app, json!({})), &all);
let _ = std::fs::remove_dir_all(&dir);
}
fn batch(h: &mut crate::scenario::Harness, params: serde_json::Value) -> serde_json::Value {
h.call("engine.batch", params)
}
fn inspect(h: &mut crate::scenario::Harness) -> serde_json::Value {
h.call("document.inspect", json!({}))["result"].clone()
}
/// Timing fields (`ms`) differ from run to run.
fn without_timings(v: &serde_json::Value) -> serde_json::Value {
match v {
serde_json::Value::Object(o) => o.iter().filter(|(k, _)| *k != "ms").map(|(k, v)| (k.clone(), without_timings(v))).collect(),
serde_json::Value::Array(a) => a.iter().map(without_timings).collect(),
v => v.clone(),
}
}
/// A step of a long design leaves its components unplaced: the first-body fit's check
/// (`execute`) looks at the undo history before placing the world, which used to place
/// every component's bodies after every step of a batch.
#[test]
fn a_step_does_not_place_the_world_for_the_first_body_fit() {
let mut h = crate::scenario::Harness::new();
let v = batch(
&mut h,
json!({"commands": [
{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10, "body_name": "Cube"}},
{"command": "component.from_bodies", "params": {"bodies": ["Cube"]}},
{"command": "occurrence.copy", "params": {"component": "Cube", "translate": [0, 40, 0]}},
]}),
);
assert!(v["result"].get("failed").is_none(), "{v}");
assert!(h.app.session.undo.len() > 2, "past the first-body fit");
// Straight to `execute`, with no frame: drawing places the world too.
let r = super::execute(&mut h.app, "solid.sphere", json!({"radius": 3, "center": [80, 0, 0], "operation": "new"}));
assert!(r.is_ok(), "{r:?}");
assert!(h.app.session.cached_world_state().is_none(), "the step placed the components again");
assert_eq!(crate::open_meshing::session_world(&h.app.session).bodies.len(), 3);
}
/// #743: a batch is one request through the app's queue, answered within a frame, however
/// many steps it has.
#[test]
fn engine_batch_runs_in_one_frame() {
let mut h = crate::scenario::Harness::new();
let steps: Vec<_> = (0..40)
.flat_map(|_| [json!({"command": "sketch.create", "params": {"plane": "XY"}}), json!({"command": "sketch.finish", "params": {}})])
.collect();
let (v, frames) = h.call_queued("engine.batch", json!({"commands": steps}));
assert_eq!(v["ok"], true, "{v}");
assert_eq!(v["result"]["completed"], 80, "{v}");
assert_eq!(v["result"]["results"].as_array().map(Vec::len), Some(80));
assert!(v["result"].get("failed").is_none(), "{v}");
assert!(frames <= 2, "a batch of 80 steps took {frames} frames");
assert_eq!(inspect(&mut h)["sketches"].as_array().map(Vec::len), Some(40));
}
/// #5822: `engine.batch {coalesce_parameters}` sets a run of parameter edits together, one
/// rebuild, and answers each step; a refused edit is named by its own step and the batch goes
/// back. Unasked, each edit runs on its own as before.
#[test]
fn engine_batch_coalesces_parameter_edits_when_asked() {
let mut h = crate::scenario::Harness::new();
let build = json!([
{"command": "parameters.add", "params": {"name": "w", "expression": "10 mm"}},
{"command": "parameters.add", "params": {"name": "d", "expression": "10 mm"}},
{"command": "solid.box", "params": {"length": "w", "width": "d", "height": 10}},
]);
assert_eq!(batch(&mut h, json!({"commands": build}))["ok"], true);
let edits = json!([
{"command": "parameters.change", "params": {"name": "w", "expression": "20 mm"}},
{"command": "parameters.change", "params": {"name": "d", "expression": "30 mm"}},
]);
let v = batch(&mut h, json!({"commands": edits, "coalesce_parameters": true}));
let results = v["result"]["results"].as_array().unwrap();
assert_eq!(results.len(), 2, "{v}");
assert!(results.iter().all(|r| r["coalesced"] == 2), "{v}");
assert_eq!(results[1]["value"], 30.0, "{v}");
let volume = |h: &mut crate::scenario::Harness| {
h.call("engine.execute", json!({"command": "inspect.measure", "params": {}}))["result"]["total"]["volume_mm3"].as_f64()
};
assert!(volume(&mut h).is_some_and(|v| (v - 6000.0).abs() < 1e-6));
let bad = json!([
{"command": "parameters.change", "params": {"name": "w", "expression": "5 mm"}},
{"command": "parameters.change", "params": {"name": "d", "expression": "1 +"}},
]);
let v = batch(&mut h, json!({"commands": bad, "coalesce_parameters": true}));
assert_eq!(v["result"]["failed"]["index"], 1, "{v}");
assert_eq!(v["result"]["rolled_back"], true, "{v}");
assert!(volume(&mut h).is_some_and(|v| (v - 6000.0).abs() < 1e-6), "the batch went back");
// Unasked: one result per edit, none coalesced.
let v = batch(&mut h, json!({"commands": edits}));
assert!(v["result"]["results"].as_array().unwrap().iter().all(|r| r.get("coalesced").is_none()), "{v}");
}
/// #1833: `engine.batch` times its steps where they run, the failing one included, with the
/// kernel's share when `profile` asks; unasked, the reply is as before.
#[test]
fn engine_batch_times_its_steps() {
let mut h = crate::scenario::Harness::new();
let steps = json!([
{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}},
{"command": "solid.box", "params": {"length": 4, "width": 4, "height": 30, "operation": "join"}},
]);
let v = batch(&mut h, json!({"commands": steps, "profile": true}));
let rows = v["result"]["timings"].as_array().cloned().unwrap_or_default();
assert_eq!(rows.len(), 2, "{v}");
assert_eq!(rows[1]["index"], 1);
assert!(rows[1]["profile"]["boolean_ms"].as_f64().is_some_and(|ms| ms > 0.0), "{v}");
assert!(v["result"]["total_ms"].as_f64().is_some(), "{v}");
// A step that fails at its turn is timed too.
let v = batch(&mut h, json!({"timings": true, "commands": [{"command": "solid.extrude", "params": {"distance": "bogus +"}}]}));
assert_eq!(v["result"]["timings"].as_array().map(Vec::len), Some(1), "{v}");
assert!(v["result"]["timings"][0].get("profile").is_none(), "{v}");
let v = batch(&mut h, json!({"commands": [{"command": "solid.box", "params": {"length": 1, "width": 1, "height": 1}}]}));
assert!(v["result"].get("timings").is_none() && v["result"].get("total_ms").is_none(), "{v}");
}
#[test]
fn engine_batch_rolls_back_at_the_first_failure() {
let mut h = crate::scenario::Harness::new();
assert_eq!(h.call("engine.execute", json!({"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}))["ok"], true);
let before = inspect(&mut h);
let v = batch(
&mut h,
json!({"commands": [
{"command": "solid.sphere", "params": {"radius": 3, "center": [50, 0, 0]}},
{"command": "solid.extrude", "params": {"distance": "bogus +"}},
{"command": "solid.sphere", "params": {"radius": 3, "center": [80, 0, 0]}},
]}),
);
assert_eq!(v["ok"], true, "{v}");
let r = &v["result"];
assert_eq!((r["completed"].clone(), r["failed"]["index"].clone(), r["undone"].clone()), (json!(1), json!(1), json!(1)), "{v}");
assert_eq!(r["failed"]["command"], "solid.extrude");
let after = inspect(&mut h);
assert_eq!(after["undo"], before["undo"], "{after}");
assert_eq!(after["bodies"], before["bodies"]);
assert_eq!(without_timings(&after["timeline"]), without_timings(&before["timeline"]));
}
#[test]
fn engine_batch_without_rollback_keeps_completed_steps() {
let mut h = crate::scenario::Harness::new();
let v = batch(
&mut h,
json!({"rollback": false, "commands": [
{"command": "solid.sphere", "params": {"radius": 3}},
// Fails at its turn (an unknown command would be refused before the first step, #5853).
{"command": "solid.extrude", "params": {"distance": "bogus +"}},
]}),
);
assert_eq!(v["result"]["failed"]["index"], 1, "{v}");
assert_eq!(v["result"]["undone"], 0, "{v}");
assert_eq!(inspect(&mut h)["bodies"].as_array().map(Vec::len), Some(1));
}
#[test]
fn engine_batch_step_without_a_command_fails_that_step() {
let mut h = crate::scenario::Harness::new();
let v = batch(&mut h, json!({"commands": [{"params": {}}]}));
assert_eq!(v["result"]["failed"]["index"], 0, "{v}");
assert!(v["result"]["failed"]["error"].as_str().is_some_and(|e| e.contains("missing `command`")), "{v}");
}
/// #5853: a step the batch would refuse at its turn (an unknown command; with strict
/// parameter checking, a call that breaks its command's contract) refuses the batch before
/// its first step runs, however late the step is.
#[test]
fn engine_batch_refuses_a_bad_step_before_the_first_runs() {
let mut h = crate::scenario::Harness::new();
let before = inspect(&mut h);
let v = batch(
&mut h,
json!({"commands": [
{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}},
{"command": "solid.sphere", "params": {"radius": 3, "center": [50, 0, 0]}},
{"command": "solid.extrud", "params": {"distance": 5}},
]}),
);
assert_eq!(v["ok"], true, "{v}");
let r = &v["result"];
assert_eq!((r["completed"].clone(), r["failed"]["index"].clone(), r["undone"].clone()), (json!(0), json!(2), json!(0)), "{v}");
assert!(r["failed"]["error"].as_str().is_some_and(|e| e.starts_with("unknown command `solid.extrud`") && e.contains("solid.extrude")), "{v}");
assert_eq!(r["not_run"], json!([0, 1, 2]), "{v}");
let after = inspect(&mut h);
assert_eq!((after["bodies"].clone(), after["undo"].clone()), (before["bodies"].clone(), before["undo"].clone()), "nothing ran: {after}");
// Strict checking refuses a broken contract up front too; off, the step runs (and the
// box command reads what it knows).
h.app.session.param_check = solidcraft_engine::schema::ParamCheck::Strict;
let steps = json!([
{"command": "solid.sphere", "params": {"radius": 3}},
{"command": "solid.box", "params": {"lenght": 10, "width": 10, "height": 10}},
]);
let v = batch(&mut h, json!({"commands": steps}));
assert_eq!((v["result"]["completed"].clone(), v["result"]["failed"]["index"].clone()), (json!(0), json!(1)), "{v}");
assert!(v["result"]["failed"]["error"].as_str().is_some_and(|e| e.contains("lenght")), "{v}");
assert_eq!(inspect(&mut h)["bodies"], before["bodies"], "nothing ran");
// `view.pick` is answered by the app, outside the command registry: not refused.
h.app.session.param_check = solidcraft_engine::schema::ParamCheck::Off;
let v = batch(&mut h, json!({"commands": [{"command": "view.pick", "params": {"x": 1, "y": 1}}]}));
assert!(!v["result"]["failed"]["error"].as_str().is_some_and(|e| e.starts_with("unknown command")), "{v}");
}
/// A request's own `param_check` (#9184): `engine.execute`, `engine.batch` and `engine.script`
/// run at it and say so in the reply, whatever the app's session level, which is its own again
/// afterwards. A command that switches designs keeps the app's level.
#[test]
fn a_request_carries_its_own_param_check_level() {
use solidcraft_engine::schema::ParamCheck;
let mut h = crate::scenario::Harness::new();
let before = inspect(&mut h);
let warning = "unknown key `operaton`; did you mean `operation`?";
let misspelt = |level: &str| json!({"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10, "operaton": "cut"}, "param_check": level});
let v = h.call("engine.execute", misspelt("strict"));
assert_eq!((&v["ok"], &v["param_check"]), (&json!(false), &json!("strict")), "{v}");
assert!(v["error"].as_str().is_some_and(|e| e.contains(warning)), "{v}");
assert_eq!(inspect(&mut h)["bodies"], before["bodies"], "refused unrun");
assert_eq!(h.app.session.param_check, ParamCheck::Off, "the app's own level again");
let v = h.call("engine.execute", misspelt("warn"));
assert_eq!((&v["ok"], &v["param_check"], &v["result"]["param_warnings"]), (&json!(true), &json!("warn"), &json!([warning])), "{v}");
assert_eq!(h.app.session.param_check, ParamCheck::Off);
let steps = json!([
{"command": "solid.sphere", "params": {"radius": 3, "center": [50, 0, 0]}},
{"command": "solid.box", "params": {"lenght": 10, "width": 10, "height": 10}},
]);
let shown = inspect(&mut h)["bodies"].clone();
let v = h.call("engine.batch", json!({"commands": steps, "param_check": "strict"}));
assert_eq!((&v["result"]["completed"], &v["result"]["failed"]["index"], &v["param_check"]), (&json!(0), &json!(1), &json!("strict")), "{v}");
assert_eq!(inspect(&mut h)["bodies"], shown, "nothing ran");
let step = json!({"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10, "operaton": "cut"}});
let v = h.call("engine.script", json!({"commands": [step], "param_check": "warn"}));
assert_eq!((&v["param_check"], &v["result"][0]["param_warnings"]), (&json!("warn"), &json!([warning])), "{v}");
// Asked nothing, told nothing; a word that is no level is refused.
let v = h.call("engine.execute", json!({"command": "inspect.measure", "params": {}}));
assert_eq!((&v["ok"], v.get("param_check")), (&json!(true), None), "{v}");
let v = h.call("engine.execute", json!({"command": "inspect.measure", "params": {}, "param_check": "loud"}));
assert!(v["ok"] == false && v["error"].as_str().is_some_and(|e| e.contains("`param_check` must be off, warn or strict")), "{v}");
// The level is this request's, not another design's.
let v = h.call("engine.execute", json!({"command": "view.next_tab", "params": {}, "param_check": "strict"}));
assert_eq!((&v["ok"], &v["param_check"]), (&json!(true), &json!("strict")), "{v}");
assert_eq!(h.app.session.param_check, ParamCheck::Off);
// Its own parameters are still checked at the request's level, before it runs.
let v = h.call("engine.execute", json!({"command": "view.next_tab", "params": {"nonsense": 1}, "param_check": "strict"}));
assert!(v["ok"] == false && v["error"].as_str().is_some_and(|e| e.contains("nonsense")), "{v}");
assert_eq!(v["param_check"], "strict", "{v}");
let v = h.call("engine.execute", json!({"command": "view.next_tab", "params": {"nonsense": 1}, "param_check": "warn"}));
assert!(v["result"]["param_warnings"].as_array().is_some_and(|w| !w.is_empty()), "{v}");
assert_eq!(h.app.session.param_check, ParamCheck::Off);
// Other methods ignore the field, whatever it holds.
let v = h.call("ui.inspect", json!({"param_check": "loud"}));
assert_eq!((&v["ok"], v.get("param_check")), (&json!(true), None), "{v}");
}
#[test]
fn engine_batch_is_refused_when_a_step_loads_a_file() {
let mut h = crate::scenario::Harness::new();
let v = batch(
&mut h,
json!({"commands": [
{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}},
{"command": "doc.open", "params": {"path": "elsewhere.solidcraft"}},
]}),
);
assert_eq!(v["ok"], false, "{v}");
assert_eq!(v["error"], "engine.batch unavailable: step 1 (doc.open) loads a file", "{v}");
assert_eq!(inspect(&mut h)["bodies"].as_array().map(Vec::len), Some(0), "nothing may run before the refusal");
}
#[test]
fn engine_batch_runs_while_the_agent_cursor_is_shown() {
let mut h = crate::scenario::Harness::new();
assert_eq!(h.call("ui.agent_cursor", json!({"show": true}))["ok"], true);
let v = batch(&mut h, json!({"commands": [{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}]}));
assert_eq!(v["ok"], true, "{v}");
assert_eq!(v["result"]["completed"], 1, "{v}");
assert_eq!(inspect(&mut h)["bodies"].as_array().map(Vec::len), Some(1));
}
/// A failed batch says whether the design really went back (`rolled_back`), not just whether
/// it was asked to.
#[test]
fn engine_batch_reports_whether_it_rolled_back() {
let mut h = crate::scenario::Harness::new();
let steps = json!([{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}}, {"command": "solid.extrude", "params": {"distance": "bogus +"}}]);
let v = batch(&mut h, json!({"commands": steps.clone()}));
assert_eq!((&v["result"]["rolled_back"], &v["result"]["undone"]), (&json!(true), &json!(1)), "{v}");
let v = batch(&mut h, json!({"commands": steps, "rollback": false}));
assert_eq!((&v["result"]["rolled_back"], &v["result"]["undone"]), (&json!(false), &json!(0)), "{v}");
assert_eq!(inspect(&mut h)["bodies"].as_array().map(Vec::len), Some(1));
}
/// Every step of a batch from an MCP server stays inside the agent's folders (#205), as an
/// `engine.execute` would.
#[test]
fn engine_batch_stays_inside_allow_paths() {
let mut h = crate::scenario::Harness::new();
let base = vfs::temp_dir().join(format!("solidcraft-batch-scope-{}", std::process::id()));
let (root, out) = (base.join("root"), base.join("out"));
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&out).unwrap();
let export = |d: &std::path::Path| json!({"command": "file.export", "params": {"path": d.join("a.step").to_string_lossy()}});
let v = batch(
&mut h,
json!({"allow_paths": [root.to_string_lossy()], "commands": [
{"command": "solid.box", "params": {"length": 10, "width": 10, "height": 10}},
export(&root),
export(&out),
]}),
);
assert_eq!(v["result"]["failed"]["index"], 2, "{v}");
assert!(v["result"]["failed"]["error"].as_str().is_some_and(|e| e.contains("outside the folders this agent may use")), "{v}");
assert!(root.join("a.step").exists());
assert_eq!(std::fs::read_dir(&out).unwrap().count(), 0, "nothing written outside");
let _ = std::fs::remove_dir_all(&base);
}
/// An MCP server's `doc.open` and imports load off the window thread (`file_load`), where
/// the agent's folders hold as they do for every other request.
#[test]
fn file_loads_stay_inside_allow_paths() {
let mut h = crate::scenario::Harness::new();
let base = vfs::temp_dir().join(format!("solidcraft-load-scope-{}", std::process::id()));
let (root, out) = (base.join("root"), base.join("out"));
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&out).unwrap();
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
for d in [&root, &out] {
std::fs::write(d.join("part.solidcraft"), solidcraft_engine::io::write_design(&s.doc)).unwrap();
}
s.execute("file.export", &json!({"path": out.join("part.step").to_string_lossy()})).unwrap();
let load = |command: &str, d: &std::path::Path, file: &str| json!({"command": command, "params": {"path": d.join(file).to_string_lossy()}, "allow_paths": [root.to_string_lossy()]});
for (command, file) in [("doc.open", "part.solidcraft"), ("file.insert_step", "part.step")] {
let (v, _) = h.call_queued("engine.execute", load(command, &out, file));
assert!(v["ok"] == false && v.to_string().contains("outside the folders this agent may use"), "{command}: {v}");
}
let (v, _) = h.call_queued("engine.execute", load("doc.open", &root, "part.solidcraft"));
assert_eq!(v["ok"], true, "{v}");
let (v, _) = h.call_queued("engine.execute", json!({"command": "doc.open", "params": {"path": "x"}, "allow_paths": "/"}));
assert!(v["error"].as_str().is_some_and(|e| e.contains("allow_paths")), "{v}");
let _ = std::fs::remove_dir_all(&base);
}
/// Each step runs as `engine.execute` runs it: same results, same design.
#[test]
fn engine_batch_matches_engine_execute() {
let steps = [
json!({"command": "sketch.create", "params": {"plane": "XY"}}),
json!({"command": "sketch.rectangle.two_point", "params": {"p0": [0, 0], "p1": [40, 30]}}),
json!({"command": "sketch.finish", "params": {}}),
json!({"command": "solid.extrude", "params": {"distance": 20}}),
];
let mut a = crate::scenario::Harness::new();
let batched = batch(&mut a, json!({"commands": steps}));
let mut b = crate::scenario::Harness::new();
let one_by_one: Vec<_> = steps.iter().map(|s| b.call("engine.execute", s.clone())["result"].clone()).collect();
assert_eq!(without_timings(&batched["result"]["results"]), without_timings(&json!(one_by_one)), "{batched}");
assert_eq!(without_timings(&inspect(&mut a)["timeline"]), without_timings(&inspect(&mut b)["timeline"]));
assert_eq!(a.app.cam, b.app.cam, "the first-body fit must happen as for engine.execute");
}
/// A request carrying `allow_paths` (from an MCP server, #205) reaches files only inside
/// those folders; the same request without it, like the user's own dialogs, is unconfined.
#[test]
fn requests_with_allow_paths_stay_inside_them() {
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
let mut app = SolveApp::new(s, Services::default());
let base = vfs::temp_dir().join(format!("solidcraft-control-scope-{}", std::process::id()));
let (root, out) = (base.join("root"), base.join("out"));
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&out).unwrap();
let at = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().to_string();
let mut call = |method: &str, mut params: Value, scoped: bool| {
if scoped {
params["allow_paths"] = json!([root.to_string_lossy()]);
}
let (req, _rx) = ControlRequest::new(method, params);
match handle(&mut app, &crate::fonts::test_context(), &req) {
Outcome::Done(v) => v,
Outcome::Screenshot { path } => json!({"ok": true, "screenshot": path}),
}
};
let export = |p: String| json!({"command": "file.export", "params": {"path": p}});
assert_eq!(call("engine.execute", export(at(&root, "a.step")), true)["ok"], true);
if crate::gpu::test_picture_renderer() {
assert_eq!(call("ui.render", json!({"path": at(&root, "a.png"), "width": 32, "height": 32}), true)["ok"], true);
}
assert_eq!(call("ui.screenshot", json!({"path": at(&root, "b.png")}), true)["ok"], true);
// Settings profiles are read and written by the app, not the engine, and stay inside too (#11362).
let profile = |id: &str, params: Value| json!({"command": id, "params": params});
let poc = json!({"format": "solidcraft-profile/1", "name": "scope-poc"});
assert_eq!(call("engine.execute", profile("settings.profile.import", json!({"profile": poc})), true)["ok"], true);
let inside = json!({"name": "scope-poc", "path": at(&root, "p.json")});
assert_eq!(call("engine.execute", profile("settings.profile.export", inside), true)["ok"], true);
assert_eq!(call("engine.execute", profile("settings.profile.import", json!({"path": at(&root, "p.json")})), true)["ok"], true);
std::fs::write(at(&base, "p.json"), poc.to_string()).unwrap();
for (method, params) in [
("engine.execute", export(at(&out, "a.step"))),
("engine.execute", export(at(&root, "../out/a.step"))),
("engine.script", json!({"commands": [{"command": "file.export", "params": {"path": at(&out, "a.step")}}]})),
("ui.render", json!({"path": at(&out, "a.png"), "width": 32, "height": 32})),
("ui.screenshot", json!({"path": at(&out, "b.png")})),
("engine.execute", profile("settings.profile.export", json!({"name": "scope-poc", "path": at(&out, "p.json")}))),
("engine.execute", profile("settings.profile.import", json!({"path": at(&base, "p.json")}))),
("engine.execute", profile("settings.profile.import", json!({"path": at(&out, "missing.json")}))),
] {
let v = call(method, params, true);
assert!(v["ok"] == false && v.to_string().contains("outside the folders this agent may use"), "{method}: {v}");
}
assert_eq!(std::fs::read_dir(&out).unwrap().count(), 0, "nothing written outside");
assert_eq!(call("engine.execute", export(at(&out, "a.step")), false)["ok"], true, "without allow_paths: unconfined");
let bad = call("engine.execute", json!({"command": "file.new", "allow_paths": "/"}), false);
assert!(bad["error"].as_str().is_some_and(|e| e.contains("allow_paths")), "{bad}");
let _ = std::fs::remove_dir_all(&base);
}
/// A screenshot is written through `vfs`, as other saves are, so the web app can hand it out
/// as a download (#7192). On the disk it is the same PNG with the same reply. A folder scope
/// active while it is written refuses a path outside it, which shows the write goes through
/// `vfs`. (`ui.screenshot` checks an agent's folders when the request arrives; the write comes
/// in a later frame, outside the request's scope, as before.)
#[test]
fn screenshots_are_written_through_vfs_with_the_same_reply() {
let base = vfs::temp_dir().join(format!("solidcraft-shot-scope-{}", std::process::id()));
let (root, out) = (base.join("root"), base.join("out"));
std::fs::create_dir_all(&root).unwrap();
std::fs::create_dir_all(&out).unwrap();
let image = egui::ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12]);
let path = root.join("shot.png").to_string_lossy().to_string();
assert_eq!(save_screenshot(&image, Some(&path)), json!({"ok": true, "result": {"path": path, "width": 4, "height": 3}}));
let png = image::load_from_memory_with_format(&std::fs::read(&path).unwrap(), image::ImageFormat::Png).unwrap().into_rgba8();
assert_eq!((png.dimensions(), png.get_pixel(0, 0).0), ((4, 3), [0, 255, 0, 255]));
let outside = out.join("shot.png").to_string_lossy().to_string();
let v = vfs::scoped(Some(vfs::PathScope::new([root.clone()])), || save_screenshot(&image, Some(&outside)));
assert!(v["ok"] == false && v["error"].as_str().is_some_and(|e| e.contains("outside the folders this agent may use")), "{v}");
assert_eq!(std::fs::read_dir(&out).unwrap().count(), 0, "nothing written outside");
let _ = std::fs::remove_dir_all(&base);
}
/// Without a `path`, a screenshot goes to `vfs::temp_dir`: in the web app a folder kept in
/// memory, where std's temporary folder panics (#7192).
#[test]
fn a_screenshot_without_a_path_goes_to_the_vfs_temporary_folder() {
let image = egui::ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12]);
let path = vfs::temp_dir().join("solidcraft-shot.png");
let reply = save_screenshot(&image, None);
assert_eq!(reply, json!({"ok": true, "result": {"path": path.to_string_lossy(), "width": 4, "height": 3}}));
assert!(path.is_file());
}
/// A request's `design_folders` (where its MCP agent opened or saved a design, #7181) count
/// as the open design's folder does: their files are reachable, their hidden files and the
/// folders beside them are not, and a list that is not one of at most
/// `vfs::MAX_DESIGN_FOLDERS` folders is refused.
#[test]
fn a_requests_design_folders_count_as_the_open_designs() {
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
let mut app = SolveApp::new(s, Services::default());
let base = vfs::temp_dir().join(format!("solidcraft-control-design-folders-{}", std::process::id()));
let (root, proj, out) = (base.join("root"), base.join("proj"), base.join("out"));
for d in [&root, &proj.join(".git"), &out] {
std::fs::create_dir_all(d).unwrap();
}
let at = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().to_string();
let mut call = |path: String, designs: Value| {
let params =
json!({"command": "file.export", "params": {"path": path}, "allow_paths": [root.to_string_lossy()], "design_folders": designs});
let (req, _rx) = ControlRequest::new("engine.execute", params);
match handle(&mut app, &crate::fonts::test_context(), &req) {
Outcome::Done(v) => v,
Outcome::Screenshot { path } => json!({"ok": true, "screenshot": path}),
}
};
let designs = json!([proj.to_string_lossy()]);
assert_eq!(call(at(&proj, "a.step"), designs.clone())["ok"], true);
for p in [at(&proj, ".secret.step"), at(&proj, ".git/a.step"), at(&out, "a.step")] {
let v = call(p.clone(), designs.clone());
assert!(v["ok"] == false && v.to_string().contains("outside the folders this agent may use"), "{p}: {v}");
}
assert!(!proj.join(".secret.step").exists() && !proj.join(".git/a.step").exists());
assert_eq!(std::fs::read_dir(&out).unwrap().count(), 0, "nothing written beside it");
let too_many = json!(vec![proj.to_string_lossy(); vfs::MAX_DESIGN_FOLDERS + 1]);
for bad in [json!(proj.to_string_lossy()), json!([1]), too_many] {
let v = call(at(&proj, "b.step"), bad);
assert!(v["error"].as_str().is_some_and(|e| e.contains("design_folders")), "{v}");
}
assert!(!proj.join("b.step").exists());
let _ = std::fs::remove_dir_all(&base);
}
/// `ui.camera` reads the camera and sets it; its reply, passed back, sets the same view
/// again. Fields left out keep their values, `fit` frames occurrences, and a refused field
/// changes nothing.
#[test]
fn ui_camera_reads_sets_and_replays_the_view() {
let mut s = Session::default();
for (name, x) in [("A", 0), ("B", 100)] {
s.execute("component.activate", &json!({"component": "root"})).unwrap();
s.execute("component.create", &json!({ "name": name })).unwrap();
s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 10, "corner": [x, 0, 0]})).unwrap();
}
s.execute("component.activate", &json!({"component": "root"})).unwrap();
let mut h = crate::scenario::Harness::new();
h.app = SolveApp::new(s, Services::default());
h.frames(2);
let before = h.app.cam;
// Reading during an animated view change leaves it running (no frames run between).
fn raw(h: &mut crate::scenario::Harness, method: &str, params: Value) -> Value {
let (req, _rx) = ControlRequest::new(method, params);
match handle(&mut h.app, &h.ctx, &req) {
Outcome::Done(v) => v,
Outcome::Screenshot { .. } => Value::Null,
}
}
raw(&mut h, "ui.view", json!({"view": "top", "animate": true}));
let r = raw(&mut h, "ui.camera", Value::Null);
assert!(r["ok"] == true && h.app.cam_anim.is_some(), "{r}");
// Setting it, even to where it is now, ends the animation there.
let yaw = h.app.cam.yaw;
let r = raw(&mut h, "ui.camera", json!({ "yaw": yaw }));
assert!(r["ok"] == true && h.app.cam_anim.is_none(), "{r}");
h.app.cam = before;
let mut cam = |p: Value| {
let r = h.call("ui.camera", p);
assert_eq!(r["ok"], true, "{r}");
(r["result"].clone(), h.app.cam)
};
let (start, now) = cam(json!({}));
assert_eq!(start, json!(now));
let (set, _) = cam(json!({"target": [5, 6, 7], "yaw": 0.5, "pitch": -0.25, "distance": 300}));
assert_eq!(
(set["target"].clone(), set["yaw"].clone(), set["pitch"].clone(), set["distance"].clone()),
(json!([5.0, 6.0, 7.0]), json!(0.5), json!(-0.25), json!(300.0))
);
assert_eq!(set["roll"], start["roll"], "a field left out keeps its value");
let (top, _) = cam(json!({"pitch": std::f64::consts::FRAC_PI_2}));
assert!(top["pitch"].as_f64().unwrap() < std::f64::consts::FRAC_PI_2, "straight down keeps a heading: {top}");
let (again, now) = cam(set.clone());
assert_eq!((again, json!(now)), (set.clone(), set.clone()), "the reply sets the same view again");
let (fit, _) = cam(json!({"fit": ["B"]}));
let t: Vec<f64> = fit["target"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
// Framed as Fit frames (the viewport's panels shift the target a little): on B, not A.
assert!((100.0..120.0).contains(&t[0]) && (0.0..20.0).contains(&t[1]) && (0.0..10.0).contains(&t[2]), "{fit}");
assert_eq!(fit["yaw"], set["yaw"], "fit keeps the direction");
let fov = h.app.cam.fov + 0.25;
for bad in [
json!({"zoom": 2}),
json!({"distance": -1}),
json!({"distance": 1e300}),
json!({"pitch": 2}),
json!({"yaw": "x"}),
json!({"fov": fov}),
json!({"up": "y"}),
json!({"yaw": 1, "fit": ["Nope"]}),
json!({"fit": []}),
json!({"fit": 1}),
json!([1, 2]),
] {
let before = h.app.cam;
let r = h.call("ui.camera", bad.clone());
assert_eq!(r["ok"], false, "{bad}: {r}");
assert_eq!(h.app.cam, before, "{bad}");
}
// Nothing shown: nothing to fit.
let mut empty = crate::scenario::Harness::new();
let before = empty.app.cam;
let r = empty.call("ui.camera", json!({"yaw": 1, "fit": true}));
assert!(r["ok"] == false && empty.app.cam == before, "{r}");
}
/// With Perspective view on, `ui.camera` reports the angle the window draws with (#5364) and
/// its reply replays; another angle is refused, naming the preference. A sketch draws parallel.
#[test]
fn ui_camera_reports_the_drawn_angle_and_its_reply_replays() {
let mut h = crate::scenario::Harness::new();
h.call("ui.set", json!({"perspective": true}));
h.call("ui.prefs", json!({"perspective_fov": 1.0}));
let read = h.call("ui.camera", Value::Null);
assert_eq!(read["result"]["fov"], json!(1.0), "{read}");
let stored = h.app.cam.fov;
let again = h.call("ui.camera", read["result"].clone());
assert_eq!(again["result"], read["result"], "the reply replays");
assert_eq!(h.app.cam.fov, stored, "the camera's own angle is left as it was");
let refused = h.call("ui.camera", json!({"fov": 0.6}));
assert!(refused["ok"] == false && refused["error"].as_str().unwrap().contains("ui.prefs {perspective_fov}"), "{refused}");
h.app.run("sketch.create", json!({"plane": "XY"})).unwrap();
assert_eq!(h.call("ui.camera", Value::Null)["result"]["fov"], json!(0.0), "a sketch draws parallel");
}
/// `ui.start` params set what a dialog opens on: Drive Joints on a joint (by name or id) at
/// the given values, driving nothing yet. A param it doesn't take is refused and closes it.
#[test]
fn ui_start_params_open_drive_joints_where_asked() {
let mut s = Session::default();
for (name, x) in [("A", 0), ("B", 30), ("C", 60)] {
s.execute("component.activate", &json!({"component": "root"})).unwrap();
s.execute("component.create", &json!({ "name": name })).unwrap();
s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 10, "corner": [x, 0, 0]})).unwrap();
}
s.execute("component.activate", &json!({"component": "root"})).unwrap();
s.execute("occurrence.ground", &json!({"occurrence": "A:1", "grounded": true})).unwrap();
let at = |o: &str, x: i32| json!({"occurrence": o, "point": [x, 10, 5], "z": [1, 0, 0]});
s.execute("joint.create", &json!({"type": "revolute", "a": at("A", 25), "b": at("B", 25), "flip": true, "name": "Hinge"})).unwrap();
s.execute("joint.create", &json!({"type": "slider", "a": at("B", 55), "b": at("C", 55), "flip": true, "name": "Rail"})).unwrap();
let mut h = crate::scenario::Harness::new();
h.app = SolveApp::new(s, Services::default());
let before = h.app.session.doc.clone();
let drive = |h: &crate::scenario::Harness| match h.app.dialog.as_ref().map(|d| &d.kind) {
Some(crate::dialogs::Kind::Assembly(crate::dialogs_assembly::Asm::Drive { joint, values, .. })) => {
(h.app.session.doc.assembly.joints[*joint].name.clone(), values.clone())
}
other => panic!("{other:?}"),
};
let r = h.call("ui.start", json!({"command": "joint.drive", "params": {"joint": "Rail", "values": [12.5]}}));
assert_eq!(r["ok"], true, "{r}");
assert_eq!(drive(&h), ("Rail".to_string(), vec!["12.5 mm".to_string()]));
let hinge = h.app.session.doc.assembly.joints[0].id;
h.call("ui.start", json!({"command": "joint.drive", "params": {"joint": hinge, "values": ["45 deg"]}}));
assert_eq!(drive(&h), ("Hinge".to_string(), vec!["45 deg".to_string()]));
assert_eq!(h.app.session.doc, before, "nothing is driven until OK");
for bad in [json!({"joint": "Nope"}), json!({"joint": "Rail", "value": 3}), json!({"values": [1, 2]}), json!({"values": [f64::MAX]})] {
let r = h.call("ui.start", json!({"command": "joint.drive", "params": bad}));
assert_eq!(r["ok"], false, "{bad}: {r}");
assert!(h.app.dialog.is_none(), "{bad}");
}
for command in ["solid.extrude", "sketch.create", "inspect.zebra"] {
let r = h.call("ui.start", json!({"command": command, "params": {"distance": 5}}));
assert!(r["ok"] == false && r["error"].as_str().unwrap().contains("takes no ui.start params"), "{r}");
assert!(h.app.dialog.is_none() && h.app.tool.is_none() && h.app.session.analysis.is_none(), "{command} started nothing");
}
}
/// #9087: the dialog is reported as data (its command, inputs and what OK runs), not as the
/// form's Debug text; `ui.start` and `ui.editFeature` reply with what they opened, and the
/// tool windows (Parameters, Bill of Materials) are reported by the command that opens them.
#[test]
fn dialogs_and_tool_windows_are_reported_as_data() {
let mut s = Session::default();
s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
let mut h = crate::scenario::Harness::new();
h.app = SolveApp::new(s, Services::default());
let r = h.call("ui.start", json!({"command": "solid.fillet"}));
let d = &r["result"]["dialog"];
assert_eq!((&d["command"], &d["title"], &d["editing"]), (&json!("solid.fillet"), &json!("FILLET"), &Value::Null), "{r}");
assert_eq!((&d["inputs"][0]["active"], &d["inputs"][0]["items"]), (&json!(true), &json!([])), "{r}");
assert!(d["commands"].is_null() && d["waiting"].is_string(), "no edge picked yet: {r}");
assert_eq!((&r["result"]["pending"], &r["result"]["windows"]), (&json!(false), &json!([])), "{r}");
assert_eq!(h.call("ui.inspect", json!({}))["result"]["dialog"], *d, "ui.inspect reports the same");
crate::dialogs::cancel(&mut h.app);
let feature = h.app.session.doc.features[0].id;
let r = h.call("ui.editFeature", json!({"feature": feature}));
let d = &r["result"]["dialog"];
assert_eq!((&d["command"], &d["editing"]), (&json!("solid.box"), &json!(feature)), "{r}");
// OK rebuilds the feature in place, from what the form holds.
let runs = &d["commands"][0];
assert_eq!((&runs["command"], &runs["params"]["command"]), (&json!("timeline.redefine"), &json!("solid.box")), "{r}");
assert_eq!((&runs["params"]["feature"], &runs["params"]["params"]["length"]), (&json!(feature), &json!("40")), "{r}");
assert!(r["result"].get("marker").is_some(), "{r}");
crate::dialogs::cancel(&mut h.app);
for (command, windows) in
[("parameters.change", json!(["parameters.change"])), ("assembly.bom", json!(["parameters.change", "assembly.bom"]))]
{
let r = h.call("ui.start", json!({"command": command}));
assert_eq!((&r["result"]["dialog"], &r["result"]["tool"], &r["result"]["windows"]), (&Value::Null, &Value::Null, &windows), "{r}");
assert_eq!(h.call("ui.inspect", json!({}))["result"]["windows"], windows, "{command}");
}
h.call("ui.help", json!({"item": "about"}));
assert_eq!(
h.call("ui.inspect", json!({}))["result"]["windows"],
json!(["parameters.change", "assembly.bom", "about"]),
"the Help menu's windows too"
);
// What is under the pointer is a selection-like item, not the viewport's Debug text.
h.app.viewport.hover = Some(crate::viewport::Hit::Face { body: "Body1".into(), index: 2, point: solidcore_record::Vec3::new(1.0, 2.0, 3.0) });
let hover = json!({"type": "face", "body": "Body1", "index": 2, "point": [1.0, 2.0, 3.0]});
assert_eq!(h.call("ui.selection", json!({}))["result"]["hover"], hover);
}
/// #9087: a sample index that names no sample is refused, so an agent can tell a typo from
/// a sample that opened. The index is checked before it reaches `open_sample`, which would
/// otherwise drop it and reply `ok`.
#[test]
fn ui_home_refuses_a_sample_index_that_names_no_sample() {
let mut h = crate::scenario::Harness::new();
let count = solidcraft_engine::sample::samples().len();
for bad in [json!({"sample": count}), json!({"sample": 99}), json!({"sample": -1})] {
let r = h.call("ui.home", bad.clone());
assert_eq!(r["ok"], false, "{bad}: {r}");
let error = r["error"].as_str().unwrap_or_default();
assert!(error.contains(&format!("0 to {}", count - 1)), "the error names the valid range: {bad}: {r}");
}
// A sample that exists still opens.
let r = h.call("ui.home", json!({"sample": 0}));
assert_eq!(r["ok"], true, "{r}");
assert_eq!(r["result"]["open"], true, "the sample was asked for: {r}");
}
}