From 6f981cba78ea264ab0d5bed523b27ea230dcff43 Mon Sep 17 00:00:00 2001 From: Nils Schlemminger Date: Tue, 20 Oct 2026 17:18:45 +0200 Subject: [PATCH] Add standalone parts manager and shared UI library - Add openecraft-parts-manager: standalone app (desktop + web) to create, edit, rename and delete the parts of a parts server, upload CSV/JSON parts files and export all parts - Add the openecraft-ui crate with the part tree, part editor, 2D/3D model previews, parts server client (now with save and delete) and file I/O, moved out of the editor - Move the 3D vector math / orbit camera and PartsDb::merge into openecraft-parts - Extend the test layout and glyph checks to the new crates - Update README, AGENTS.md, CI and the launch configurations Co-Authored-By: Claude Opus 5.5 --- .claude/launch.json | 12 + .github/workflows/ci.yml | 8 + .gitignore | 1 + AGENTS.md | 21 +- Cargo.lock | 37 +- Cargo.toml | 22 +- README.md | 26 +- crates/openecraft-parts/src/lib.rs | 1 + crates/openecraft-parts/src/part.rs | 23 + crates/openecraft-parts/src/part/tests.rs | 21 + crates/openecraft-parts/src/vec3.rs | 47 ++ crates/openecraft-parts/src/vec3/tests.rs | 22 + crates/openecraft-ui/Cargo.toml | 22 + crates/openecraft-ui/src/client.rs | 202 +++++++ .../openecraft-ui/src/client}/tests.rs | 34 +- crates/openecraft-ui/src/io.rs | 159 ++++++ crates/openecraft-ui/src/io/tests.rs | 16 + crates/openecraft-ui/src/lib.rs | 9 + crates/openecraft-ui/src/part_editor.rs | 534 ++++++++++++++++++ crates/openecraft-ui/src/part_editor/tests.rs | 32 ++ parts-manager/Cargo.toml | 35 ++ parts-manager/Trunk.toml | 7 + parts-manager/index.html | 19 + parts-manager/src/app.rs | 357 ++++++++++++ parts-manager/src/main.rs | 48 ++ parts-manager/src/session.rs | 157 +++++ parts-manager/src/session/tests.rs | 120 ++++ src/app.rs | 4 +- src/conventions/tests.rs | 2 +- src/glyphs/tests.rs | 4 +- src/io.rs | 149 +---- src/main.rs | 1 - src/panel_ui.rs | 103 +--- src/parts_server.rs | 157 ----- src/parts_ui.rs | 464 +-------------- src/parts_ui/tests.rs | 20 +- 36 files changed, 2016 insertions(+), 880 deletions(-) create mode 100644 crates/openecraft-parts/src/part/tests.rs create mode 100644 crates/openecraft-parts/src/vec3.rs create mode 100644 crates/openecraft-parts/src/vec3/tests.rs create mode 100644 crates/openecraft-ui/Cargo.toml create mode 100644 crates/openecraft-ui/src/client.rs rename {src/parts_server => crates/openecraft-ui/src/client}/tests.rs (56%) create mode 100644 crates/openecraft-ui/src/io.rs create mode 100644 crates/openecraft-ui/src/io/tests.rs create mode 100644 crates/openecraft-ui/src/lib.rs create mode 100644 crates/openecraft-ui/src/part_editor.rs create mode 100644 crates/openecraft-ui/src/part_editor/tests.rs create mode 100644 parts-manager/Cargo.toml create mode 100644 parts-manager/Trunk.toml create mode 100644 parts-manager/index.html create mode 100644 parts-manager/src/app.rs create mode 100644 parts-manager/src/main.rs create mode 100644 parts-manager/src/session.rs create mode 100644 parts-manager/src/session/tests.rs delete mode 100644 src/parts_server.rs diff --git a/.claude/launch.json b/.claude/launch.json index dcd6dae1..243e6b46 100644 --- a/.claude/launch.json +++ b/.claude/launch.json @@ -12,6 +12,18 @@ "runtimeExecutable": "trunk", "runtimeArgs": ["serve", "--port", "8081", "--dist", "target/dist-fresh"], "port": 8081 + }, + { + "name": "parts-manager-web", + "runtimeExecutable": "trunk", + "runtimeArgs": ["serve", "parts-manager/index.html", "--port", "8082", "--dist", "target/dist-parts-manager"], + "port": 8082 + }, + { + "name": "parts-server", + "runtimeExecutable": "cargo", + "runtimeArgs": ["run", "-p", "openecraft-server", "--", "--token", "local-test-token", "--data", "target/parts-db-dev.json"], + "port": 8090 } ] } diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index efab4a32..80ece3da 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -29,6 +29,8 @@ jobs: target/release/openecraft.exe target/release/openecraft-server target/release/openecraft-server.exe + target/release/openecraft-parts-manager + target/release/openecraft-parts-manager.exe web: runs-on: ubuntu-latest @@ -39,7 +41,13 @@ jobs: targets: wasm32-unknown-unknown - run: cargo install trunk --locked - run: trunk build --release + - run: trunk build --release + working-directory: parts-manager - uses: actions/upload-artifact@v4 with: name: openecraft-web path: dist + - uses: actions/upload-artifact@v4 + with: + name: openecraft-parts-manager-web + path: parts-manager/dist diff --git a/.gitignore b/.gitignore index 1c12d09b..42f8ac21 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ /target /dist +/parts-manager/dist /.idea/ # Local parts server databases parts-db.json diff --git a/AGENTS.md b/AGENTS.md index 4c9ce38b..431cbd65 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -11,11 +11,12 @@ Run these before considering a change done. All of them must pass without warnin ```bash cargo test --workspace cargo clippy --workspace --all-targets -cargo clippy -p openecraft --target wasm32-unknown-unknown +cargo clippy -p openecraft -p openecraft-parts-manager --target wasm32-unknown-unknown ``` - Desktop: `cargo run --release` - Parts server: `cargo run -p openecraft-server -- --token ` (http://127.0.0.1:8090) +- Parts manager: `cargo run -p openecraft-parts-manager`; web: `cd parts-manager && trunk serve` (http://127.0.0.1:8082) - Web: `trunk serve` (dev server on http://127.0.0.1:8080), `trunk build --release` - The web target needs `rustup target add wasm32-unknown-unknown` and `cargo install trunk --locked`. @@ -25,11 +26,16 @@ cargo clippy -p openecraft --target wasm32-unknown-unknown | --- | --- | --- | | `openecraft` | `.` (`src/`) | Editor (desktop + web) – the root package, built by trunk | | `openecraft-parts` | `crates/openecraft-parts` | Shared library: part model, function templates, CSV/JSON, catalog, parts server API types | +| `openecraft-ui` | `crates/openecraft-ui` | Shared egui library: part tree / editor / previews, parts server client, file dialogs | | `openecraft-server` | `server/` | Standalone parts database server (axum, JSON file storage) | +| `openecraft-parts-manager` | `parts-manager/` | Standalone parts server maintenance app (desktop + web, own `index.html` / `Trunk.toml`) | - Code needed by more than one executable belongs in a library crate under `crates/`, - never duplicated. The library must stay free of UI and platform dependencies - (only `serde` / `serde_json`). + never duplicated. + - `openecraft-parts` stays free of UI and platform dependencies (only `serde` / + `serde_json`); pure logic such as 3D math (`vec3`) goes here. + - `openecraft-ui` holds egui widgets and platform code shared by the editor and the + parts manager. It must not depend on an application crate. - API types and request paths of the parts server live in `openecraft_parts::api`; change server and client together. - New crates are added to `[workspace] members` in the root `Cargo.toml`; the @@ -68,10 +74,11 @@ violations. Do not weaken or delete that test to make a change pass. - **Glyphs:** every character used in a string literal must exist in the bundled egui fonts. Native builds have no font fallback, so missing characters render as - empty boxes (the browser hides the problem). `src/glyphs/tests.rs` checks this; if + empty boxes (the browser hides the problem). `src/glyphs/tests.rs` checks this for + every UI crate (editor, `openecraft-parts`, `openecraft-ui`, parts manager); if it fails, pick a character the fonts contain instead of disabling the check. Keep the egui feature `monochrome_emoji_fonts` enabled. -- **eframe features:** default features are disabled in `Cargo.toml`; when changing +- **eframe features:** default features are disabled in both app manifests; when changing the feature list keep `clipboard` (desktop copy/paste), `persistence`, `default_fonts` and `glow`. - **Demo project:** `src/sample.rs` is checked by `sample/tests.rs` (no check errors, @@ -81,7 +88,9 @@ violations. Do not weaken or delete that test to make a change pass. - **Undo:** edits are captured by snapshot comparison (`history.rs`); just mutate the `Project`, no explicit undo bookkeeping is needed. - **Platform code:** keep `#[cfg(target_arch = "wasm32")]` branches confined to - `io.rs` and `main.rs`. + `crates/openecraft-ui/src/io.rs` and the `main.rs` files. +- **Parts manager:** keep its editing rules (drafts, renames, unsaved changes) in + `parts-manager/src/session.rs` (no UI code, unit tested); `app.rs` only draws. - **Style:** match the surrounding code; keep comments as sparse as the existing ones. ## Commits diff --git a/Cargo.lock b/Cargo.lock index 17e7f06c..ead7263e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2539,12 +2539,10 @@ version = "0.1.0" dependencies = [ "eframe", "egui", - "ehttp", "env_logger", - "js-sys", "log", "openecraft-parts", - "rfd", + "openecraft-ui", "serde", "serde_json", "wasm-bindgen", @@ -2560,6 +2558,22 @@ dependencies = [ "serde_json", ] +[[package]] +name = "openecraft-parts-manager" +version = "0.1.0" +dependencies = [ + "eframe", + "egui", + "env_logger", + "log", + "openecraft-parts", + "openecraft-ui", + "serde_json", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "openecraft-server" version = "0.1.0" @@ -2577,6 +2591,23 @@ dependencies = [ "tower-http", ] +[[package]] +name = "openecraft-ui" +version = "0.1.0" +dependencies = [ + "egui", + "ehttp", + "js-sys", + "log", + "openecraft-parts", + "rfd", + "serde", + "serde_json", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "orbclient" version = "0.3.55" diff --git a/Cargo.toml b/Cargo.toml index 02567526..9b282830 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ name = "openecraft" path = "src/main.rs" [workspace] -members = [".", "crates/openecraft-parts", "server"] +members = [".", "crates/openecraft-parts", "crates/openecraft-ui", "server", "parts-manager"] [dependencies] eframe = { version = "0.37", default-features = false, features = [ @@ -29,9 +29,8 @@ egui = { version = "0.37", features = ["monochrome_emoji_fonts"] } serde = { version = "1", features = ["derive"] } serde_json = "1" log = "0.4" -rfd = "0.17" -ehttp = "0.7" openecraft-parts = { path = "crates/openecraft-parts" } +openecraft-ui = { path = "crates/openecraft-ui" } [target.'cfg(not(target_arch = "wasm32"))'.dependencies] env_logger = "0.11" @@ -39,22 +38,7 @@ env_logger = "0.11" [target.'cfg(target_arch = "wasm32")'.dependencies] wasm-bindgen = "0.2" wasm-bindgen-futures = "0.4" -js-sys = "0.3" -web-sys = { version = "0.3", features = [ - "Window", - "Document", - "Element", - "HtmlCanvasElement", - "HtmlAnchorElement", - "HtmlInputElement", - "Blob", - "BlobPropertyBag", - "Url", - "File", - "FileList", - "FileReader", - "Event", -] } +web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement"] } [profile.release] opt-level = 2 diff --git a/README.md b/README.md index 8ef2885f..7a725254 100644 --- a/README.md +++ b/README.md @@ -110,6 +110,23 @@ cargo run --release -p openecraft-server -- --bind 0.0.0.0:8090 --data parts-db. - The server speaks plain HTTP; put it behind a TLS reverse proxy when it is reachable from outside your network. +### Parts manager + +`openecraft-parts-manager` is a standalone application that maintains the parts of a +parts server: create new parts, edit existing ones (including 2D / 3D models), rename +and delete parts, upload CSV / JSON parts files and export all parts. It uses the same +part editor as the editor's parts management and runs on the desktop and in the browser. + +```bash +cargo run --release -p openecraft-parts-manager # desktop +cd parts-manager && trunk serve # web, http://127.0.0.1:8082 +cd parts-manager && trunk build --release # static files in parts-manager/dist/ +``` + +Enter the server URL and the access token (kept in memory only) and click *Connect*. +Changes are saved to the server with *Save* (`Ctrl+S`); the editor asks before unsaved +changes are discarded and before a part is deleted. + ### Tests ```bash @@ -133,9 +150,10 @@ cargo test --workspace | File | Purpose | | --- | --- | -| `crates/openecraft-parts` | Shared library: part model, function templates, CSV/JSON, catalog, server API types | +| `crates/openecraft-parts` | Shared library: part model, function templates, CSV/JSON, catalog, server API types, 3D math | +| `crates/openecraft-ui` | Shared egui library: part editor and previews, parts server client, file dialogs | | `server/` | `openecraft-server`: parts database server (REST API, JSON storage) | -| `src/parts_server.rs` | Client for the parts server | +| `parts-manager/` | `openecraft-parts-manager`: standalone parts server maintenance (desktop + web) | | `src/model.rs` | Project data model (pages, symbols, wires, parts) and page layout constants | | `src/symbols.rs` | Built-in IEC symbol library | | `src/netlist.rs` | Connectivity analysis (nets / potentials, junctions) | @@ -147,7 +165,7 @@ cargo test --workspace | `src/panel.rs` | Panel layout model, device sizes, rail snapping, collisions, duct routing | | `src/panel_ui.rs` | Panel layout workspace: navigator, 2D editor, 3D view, properties | | `src/parts.rs` | Parts database, function templates, project parts, CSV import/export | -| `src/parts_ui.rs` | Parts management window and part selection dialog | +| `src/parts_ui.rs` | Parts management window, part selection dialog, parts server panel | | `src/app.rs` | Application UI (menus, panels, dialogs) | | `src/svg.rs` | SVG / print export | -| `src/io.rs` | Native file dialogs and browser up/downloads | +| `src/io.rs` | File kinds of the editor (dialogs are in `openecraft-ui`) | diff --git a/crates/openecraft-parts/src/lib.rs b/crates/openecraft-parts/src/lib.rs index 4b8638d0..c0f65c7b 100644 --- a/crates/openecraft-parts/src/lib.rs +++ b/crates/openecraft-parts/src/lib.rs @@ -13,6 +13,7 @@ mod csv; mod graphics; mod part; mod text; +pub mod vec3; pub use catalog::default_catalog; pub use csv::{from_csv, import, to_csv}; diff --git a/crates/openecraft-parts/src/part.rs b/crates/openecraft-parts/src/part.rs index 7d189aa2..c33c6337 100644 --- a/crates/openecraft-parts/src/part.rs +++ b/crates/openecraft-parts/src/part.rs @@ -344,6 +344,26 @@ impl PartsDb { pub fn sort(&mut self) { self.parts.sort_by(|a, b| natural_cmp(&a.number, &b.number)); } + + /// Adds / replaces parts (e.g. downloaded from a parts server). Returns (added, updated). + pub fn merge(&mut self, parts: Vec) -> (usize, usize) { + let (mut added, mut updated) = (0, 0); + for part in parts { + match self.parts.iter_mut().find(|p| p.number == part.number) { + Some(existing) if *existing != part => { + *existing = part; + updated += 1; + } + Some(_) => {} + None => { + self.parts.push(part); + added += 1; + } + } + } + self.sort(); + (added, updated) + } } pub fn upsert(list: &mut Vec, part: Part) { @@ -363,3 +383,6 @@ pub fn unique_number(list: &[Part], base: &str) -> String { .find(|n| !list.iter().any(|p| &p.number == n)) .unwrap() } + +#[cfg(test)] +mod tests; \ No newline at end of file diff --git a/crates/openecraft-parts/src/part/tests.rs b/crates/openecraft-parts/src/part/tests.rs new file mode 100644 index 00000000..23e8ffb3 --- /dev/null +++ b/crates/openecraft-parts/src/part/tests.rs @@ -0,0 +1,21 @@ +use super::*; + +#[test] +fn merge_adds_and_updates() { + let mut db = PartsDb { parts: vec![Part { number: "A".into(), description: "old".into(), ..Default::default() }] }; + let incoming = vec![ + Part { number: "A".into(), description: "new".into(), ..Default::default() }, + Part { number: "B".into(), ..Default::default() }, + ]; + assert_eq!(db.merge(incoming.clone()), (1, 1)); + assert_eq!(db.get("A").unwrap().description, "new"); + // Same data again: nothing changes. + assert_eq!(db.merge(incoming), (0, 0)); +} + +#[test] +fn unique_numbers() { + let list = vec![Part { number: "X".into(), ..Default::default() }, Part { number: "X_1".into(), ..Default::default() }]; + assert_eq!(unique_number(&list, "Y"), "Y"); + assert_eq!(unique_number(&list, "X"), "X_2"); +} diff --git a/crates/openecraft-parts/src/vec3.rs b/crates/openecraft-parts/src/vec3.rs new file mode 100644 index 00000000..07a17079 --- /dev/null +++ b/crates/openecraft-parts/src/vec3.rs @@ -0,0 +1,47 @@ +//! Small 3D vector helpers and an orbit camera, shared by the 3D views. + +pub type V3 = [f32; 3]; + +pub fn sub(a: V3, b: V3) -> V3 { + [a[0] - b[0], a[1] - b[1], a[2] - b[2]] +} + +pub fn dot(a: V3, b: V3) -> f32 { + a[0] * b[0] + a[1] * b[1] + a[2] * b[2] +} + +pub fn cross(a: V3, b: V3) -> V3 { + [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]] +} + +pub fn norm(a: V3) -> V3 { + let l = dot(a, a).sqrt().max(1e-6); + [a[0] / l, a[1] / l, a[2] / l] +} + +/// Camera orbiting around `target` (y up). +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Orbit { + pub yaw: f32, + pub pitch: f32, + pub dist: f32, + pub target: V3, +} + +impl Orbit { + /// Eye position and camera axes (right, up, forward). + pub fn basis(&self) -> (V3, V3, V3, V3) { + let eye = [ + self.target[0] + self.dist * self.pitch.cos() * self.yaw.sin(), + self.target[1] + self.dist * self.pitch.sin(), + self.target[2] + self.dist * self.pitch.cos() * self.yaw.cos(), + ]; + let fwd = norm(sub(self.target, eye)); + let right = norm(cross(fwd, [0.0, 1.0, 0.0])); + let up = cross(right, fwd); + (eye, right, up, fwd) + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/openecraft-parts/src/vec3/tests.rs b/crates/openecraft-parts/src/vec3/tests.rs new file mode 100644 index 00000000..602cc402 --- /dev/null +++ b/crates/openecraft-parts/src/vec3/tests.rs @@ -0,0 +1,22 @@ +use super::*; + +fn close(a: V3, b: V3) -> bool { + a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5) +} + +#[test] +fn vector_basics() { + assert_eq!(dot([1.0, 2.0, 3.0], [4.0, 5.0, 6.0]), 32.0); + assert_eq!(cross([1.0, 0.0, 0.0], [0.0, 1.0, 0.0]), [0.0, 0.0, 1.0]); + assert!(close(norm([3.0, 0.0, 4.0]), [0.6, 0.0, 0.8])); +} + +#[test] +fn orbit_from_the_front_looks_down_minus_z() { + let cam = Orbit { yaw: 0.0, pitch: 0.0, dist: 10.0, target: [1.0, 2.0, 3.0] }; + let (eye, right, up, fwd) = cam.basis(); + assert!(close(eye, [1.0, 2.0, 13.0])); + assert!(close(fwd, [0.0, 0.0, -1.0])); + assert!(close(right, [1.0, 0.0, 0.0])); + assert!(close(up, [0.0, 1.0, 0.0])); +} diff --git a/crates/openecraft-ui/Cargo.toml b/crates/openecraft-ui/Cargo.toml new file mode 100644 index 00000000..2f1347f4 --- /dev/null +++ b/crates/openecraft-ui/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "openecraft-ui" +version = "0.1.0" +edition = "2021" +description = "Shared egui components of OpenECraft (part editor, model previews, parts server client, file dialogs)" +license = "MIT OR Apache-2.0" + +[dependencies] +# Bundle the symbol / emoji fonts: native builds have no browser font fallback. +egui = { version = "0.37", features = ["monochrome_emoji_fonts"] } +ehttp = "0.7" +log = "0.4" +rfd = "0.17" +serde = { version = "1", features = ["derive"] } +serde_json = "1" +openecraft-parts = { path = "../openecraft-parts" } + +[target.'cfg(target_arch = "wasm32")'.dependencies] +wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" +js-sys = "0.3" +web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url"] } diff --git a/crates/openecraft-ui/src/client.rs b/crates/openecraft-ui/src/client.rs new file mode 100644 index 00000000..c0ea7dc1 --- /dev/null +++ b/crates/openecraft-ui/src/client.rs @@ -0,0 +1,202 @@ +//! Client for the global parts server (`openecraft-server`). Requests run in the +//! background (thread on desktop, fetch in the browser); results are collected with +//! [`ServerClient::poll`]. + +use openecraft_parts::api::{self, ApiError, ImportResult, PartList, ServerInfo, API_PREFIX, DEFAULT_PORT}; +use openecraft_parts::Part; +use serde::de::DeserializeOwned; +use std::sync::{Arc, Mutex}; + +/// Result of a finished request. +#[derive(Debug)] +pub enum Reply { + Info(Result), + Parts(Result), + Imported(Result), + Saved(Result, String>), + /// Part number and result. + Deleted(String, Result<(), String>), +} + +impl Reply { + pub fn error(&self) -> Option<&str> { + match self { + Reply::Info(Err(e)) | Reply::Parts(Err(e)) | Reply::Imported(Err(e)) | Reply::Saved(Err(e)) | Reply::Deleted(_, Err(e)) => { + Some(e) + } + _ => None, + } + } + + /// Text for a status line. + pub fn describe(&self) -> String { + if let Some(e) = self.error() { + return format!("Parts server: {e}"); + } + match self { + Reply::Info(Ok(info)) => format!( + "Connected: {} {} – {} parts, revision {}, {}", + info.name, + info.version, + info.parts, + info.revision, + if info.writable { "changes with token" } else { "read-only" } + ), + Reply::Parts(Ok(list)) => format!("Loaded {} parts (revision {})", list.parts.len(), list.revision), + Reply::Imported(Ok(r)) => format!("Uploaded {} parts, server revision {}", r.imported, r.revision), + Reply::Saved(Ok(p)) => format!("Saved part {}", p.number), + Reply::Deleted(number, Ok(())) => format!("Deleted part {number}"), + _ => String::new(), + } + } +} + +pub struct ServerClient { + pub url: String, + /// Access token for changes (kept in memory only). + pub token: String, + pub info: Option, + pub status: String, + pending: usize, + inbox: Arc>>, +} + +impl Default for ServerClient { + fn default() -> Self { + ServerClient { + url: format!("http://127.0.0.1:{DEFAULT_PORT}"), + token: String::new(), + info: None, + status: String::new(), + pending: 0, + inbox: Arc::default(), + } + } +} + +/// Turns an HTTP result into the expected JSON type or a readable error. +pub fn decode(result: ehttp::Result) -> Result { + let resp = check(result)?; + serde_json::from_slice(&resp.bytes).map_err(|e| format!("unexpected answer: {e}")) +} + +/// Successful response or a readable error (server message, HTTP status, connection error). +fn check(result: ehttp::Result) -> Result { + match result { + Err(e) => Err(format!("connection failed: {e}")), + Ok(resp) if resp.ok => Ok(resp), + Ok(resp) => Err(serde_json::from_slice::(&resp.bytes) + .map(|e| e.error) + .unwrap_or_else(|_| format!("{} {}", resp.status, resp.status_text))), + } +} + +impl ServerClient { + pub fn busy(&self) -> bool { + self.pending > 0 + } + + /// True if the last connection check found a server that accepts changes. + pub fn writable(&self) -> bool { + self.info.as_ref().is_some_and(|i| i.writable) + } + + fn endpoint(&self, path: &str) -> String { + api::url(&self.url, path) + } + + fn authorized(&self, mut req: ehttp::Request) -> ehttp::Request { + if !self.token.trim().is_empty() { + req.headers.insert("Authorization", format!("Bearer {}", self.token.trim())); + } + req + } + + fn send( + &mut self, + ctx: &egui::Context, + request: ehttp::Request, + status: String, + wrap: impl 'static + Send + FnOnce(ehttp::Result) -> Reply, + ) { + self.status = status; + self.pending += 1; + let inbox = self.inbox.clone(); + let ctx = ctx.clone(); + ehttp::fetch(request, move |result| { + if let Ok(mut inbox) = inbox.lock() { + inbox.push(wrap(result)); + } + ctx.request_repaint(); + }); + } + + /// GET /api/v1/info + pub fn check(&mut self, ctx: &egui::Context) { + let req = ehttp::Request::get(self.endpoint(&format!("{API_PREFIX}/info"))); + self.send(ctx, req, "Connecting…".into(), |r| Reply::Info(decode(r))); + } + + /// GET /api/v1/parts (all parts) + pub fn download(&mut self, ctx: &egui::Context) { + let req = ehttp::Request::get(self.endpoint(&format!("{API_PREFIX}/parts"))); + self.send(ctx, req, "Downloading parts…".into(), |r| Reply::Parts(decode(r))); + } + + /// POST /api/v1/import with the parts as JSON (needs the access token). + pub fn upload(&mut self, ctx: &egui::Context, parts: &[Part]) { + let body = serde_json::to_vec(parts).unwrap_or_default(); + self.import(ctx, body, "application/json", format!("Uploading {} parts…", parts.len())); + } + + /// POST /api/v1/import with the content of a CSV or JSON parts file. + pub fn upload_file(&mut self, ctx: &egui::Context, content: Vec) { + self.import(ctx, content, "text/plain; charset=utf-8", "Uploading parts file…".into()); + } + + fn import(&mut self, ctx: &egui::Context, body: Vec, content_type: &str, status: String) { + let mut req = ehttp::Request::post(self.endpoint(&format!("{API_PREFIX}/import")), body); + req.headers.insert("Content-Type", content_type); + let req = self.authorized(req); + self.send(ctx, req, status, |r| Reply::Imported(decode(r))); + } + + /// PUT /api/v1/parts/{number}: creates or replaces a part. + pub fn save(&mut self, ctx: &egui::Context, part: &Part) { + let body = serde_json::to_vec(part).unwrap_or_default(); + let mut req = ehttp::Request::put(self.endpoint(&api::part_path(&part.number)), body); + req.headers.insert("Content-Type", "application/json"); + let req = self.authorized(req); + self.send(ctx, req, format!("Saving {}…", part.number), |r| Reply::Saved(decode(r).map(Box::new))); + } + + /// DELETE /api/v1/parts/{number} + pub fn delete(&mut self, ctx: &egui::Context, number: &str) { + let req = self.authorized(ehttp::Request::delete(&self.endpoint(&api::part_path(number)))); + let n = number.to_string(); + self.send(ctx, req, format!("Deleting {number}…"), move |r| Reply::Deleted(n, check(r).map(|_| ()))); + } + + /// Takes the finished requests and updates `status` / `info`. + pub fn poll(&mut self) -> Vec { + let replies: Vec = self.inbox.lock().map(|mut i| std::mem::take(&mut *i)).unwrap_or_default(); + for reply in &replies { + self.pending = self.pending.saturating_sub(1); + match reply { + Reply::Info(Ok(info)) => self.info = Some(info.clone()), + Reply::Info(Err(_)) => self.info = None, + _ => {} + } + self.status = reply.describe(); + } + replies + } + + /// True if the status line shows an error. + pub fn failed(&self) -> bool { + self.status.starts_with("Parts server:") + } +} + +#[cfg(test)] +mod tests; diff --git a/src/parts_server/tests.rs b/crates/openecraft-ui/src/client/tests.rs similarity index 56% rename from src/parts_server/tests.rs rename to crates/openecraft-ui/src/client/tests.rs index c3107879..e9299947 100644 --- a/src/parts_server/tests.rs +++ b/crates/openecraft-ui/src/client/tests.rs @@ -28,14 +28,28 @@ fn decode_success_and_errors() { } #[test] -fn merge_adds_and_updates() { - let mut db = PartsDb { parts: vec![Part { number: "A".into(), description: "old".into(), ..Default::default() }] }; - let incoming = vec![ - Part { number: "A".into(), description: "new".into(), ..Default::default() }, - Part { number: "B".into(), ..Default::default() }, - ]; - assert_eq!(merge(&mut db, incoming.clone()), (1, 1)); - assert_eq!(db.get("A").unwrap().description, "new"); - // Same data again: nothing changes. - assert_eq!(merge(&mut db, incoming), (0, 0)); +fn empty_answers_are_fine_for_deletes() { + assert!(check(response(204, "")).is_ok()); + assert_eq!(check(response(404, r#"{"error": "part 'X' not found"}"#)).unwrap_err(), "part 'X' not found"); +} + +#[test] +fn poll_updates_status_and_info() { + let mut client = ServerClient { pending: 2, ..Default::default() }; + { + let mut inbox = client.inbox.lock().unwrap(); + inbox.push(Reply::Info(Ok(ServerInfo { name: "srv".into(), writable: true, ..Default::default() }))); + inbox.push(Reply::Deleted("A".into(), Ok(()))); + } + let replies = client.poll(); + assert_eq!(replies.len(), 2); + assert!(!client.busy()); + assert!(client.writable()); + assert_eq!(client.status, "Deleted part A"); + assert!(!client.failed()); + + client.inbox.lock().unwrap().push(Reply::Info(Err("connection failed: refused".into()))); + client.poll(); + assert!(client.failed()); + assert!(client.info.is_none()); } diff --git a/crates/openecraft-ui/src/io.rs b/crates/openecraft-ui/src/io.rs new file mode 100644 index 00000000..f02271ae --- /dev/null +++ b/crates/openecraft-ui/src/io.rs @@ -0,0 +1,159 @@ +//! Platform specific file handling: native file dialogs on desktop, file picker and +//! downloads in the browser. Generic over the application's kinds of files. + +use std::sync::{Arc, Mutex}; + +/// What a file is opened for; provides the file dialog filter. +pub trait FileKind: Copy + Send + 'static { + /// Filter name and extensions. + fn filter(self) -> (&'static str, &'static [&'static str]); +} + +pub struct Loaded { + pub purpose: K, + /// Native: full path. Web: file name. + pub name: String, + /// Raw file content (binary STL files are not text). + pub bytes: Vec, +} + +impl Loaded { + pub fn text(&self) -> String { + String::from_utf8_lossy(&self.bytes).into_owned() + } +} + +pub struct FileIo { + inbox: Arc>>>, +} + +impl Default for FileIo { + fn default() -> Self { + FileIo { inbox: Arc::default() } + } +} + +impl Clone for FileIo { + fn clone(&self) -> Self { + FileIo { inbox: self.inbox.clone() } + } +} + +impl FileIo { + /// Takes a file that finished loading (the web picker is asynchronous). + pub fn poll(&self) -> Option> { + self.inbox.lock().ok()?.pop() + } + + #[cfg(not(target_arch = "wasm32"))] + pub fn open(&self, _ctx: &egui::Context, purpose: K) { + let (name, ext) = purpose.filter(); + let Some(path) = rfd::FileDialog::new() + .add_filter(name, ext) + .pick_file() + else { + return; + }; + match std::fs::read(&path) { + Ok(bytes) => { + if let Ok(mut inbox) = self.inbox.lock() { + inbox.push(Loaded { purpose, name: path.display().to_string(), bytes }); + } + } + Err(e) => log::error!("Could not read {}: {e}", path.display()), + } + } + + #[cfg(target_arch = "wasm32")] + pub fn open(&self, ctx: &egui::Context, purpose: K) { + let inbox = self.inbox.clone(); + let ctx = ctx.clone(); + wasm_bindgen_futures::spawn_local(async move { + let (name, ext) = purpose.filter(); + let Some(file) = rfd::AsyncFileDialog::new() + .add_filter(name, ext) + .pick_file() + .await + else { + return; + }; + let bytes = file.read().await; + if let Ok(mut inbox) = inbox.lock() { + inbox.push(Loaded { purpose, name: file.file_name(), bytes }); + } + ctx.request_repaint(); + }); + } +} + +impl FileIo { + /// Asks for a location and writes the file. Returns the chosen path / name. + #[cfg(not(target_arch = "wasm32"))] + pub fn save_as(&self, suggested: &str, filter: (&str, &str), content: &str) -> Result, String> { + let Some(path) = rfd::FileDialog::new().add_filter(filter.0, &[filter.1]).set_file_name(suggested).save_file() + else { + return Ok(None); + }; + std::fs::write(&path, content).map_err(|e| e.to_string())?; + Ok(Some(path.display().to_string())) + } + + /// In the browser "save as" is a download. + #[cfg(target_arch = "wasm32")] + pub fn save_as(&self, suggested: &str, filter: (&str, &str), content: &str) -> Result, String> { + download(suggested, mime_type(filter.1), content).map_err(|e| format!("{e:?}"))?; + Ok(Some(suggested.to_string())) + } + + /// Writes to a known location (native) or downloads again (web). + pub fn save_to(&self, path: &str, content: &str) -> Result<(), String> { + #[cfg(not(target_arch = "wasm32"))] + { + std::fs::write(path, content).map_err(|e| e.to_string()) + } + #[cfg(target_arch = "wasm32")] + { + download(path, "application/json", content).map_err(|e| format!("{e:?}")) + } + } + + pub fn can_save_in_place() -> bool { + cfg!(not(target_arch = "wasm32")) + } +} + +/// MIME type of a download by file extension. +pub fn mime_type(ext: &str) -> &'static str { + match ext { + "svg" => "image/svg+xml", + "html" => "text/html", + "csv" => "text/csv", + _ => "application/json", + } +} + +#[cfg(target_arch = "wasm32")] +fn download(name: &str, mime: &str, content: &str) -> Result<(), wasm_bindgen::JsValue> { + use wasm_bindgen::JsCast; + let parts = js_sys::Array::new(); + parts.push(&wasm_bindgen::JsValue::from_str(content)); + let opts = web_sys::BlobPropertyBag::new(); + opts.set_type(mime); + let blob = web_sys::Blob::new_with_str_sequence_and_options(&parts, &opts)?; + let url = web_sys::Url::create_object_url_with_blob(&blob)?; + let document = web_sys::window().and_then(|w| w.document()).ok_or("no document")?; + let a: web_sys::HtmlAnchorElement = document.create_element("a")?.dyn_into()?; + a.set_href(&url); + a.set_download(name); + a.click(); + web_sys::Url::revoke_object_url(&url)?; + Ok(()) +} + +/// File name without directories, for window titles. +pub fn short_name(path: &str) -> &str { + path.rsplit(['/', '\\']).next().unwrap_or(path) +} + +#[cfg(test)] +mod tests; diff --git a/crates/openecraft-ui/src/io/tests.rs b/crates/openecraft-ui/src/io/tests.rs new file mode 100644 index 00000000..b0f8ee79 --- /dev/null +++ b/crates/openecraft-ui/src/io/tests.rs @@ -0,0 +1,16 @@ +use super::*; + +#[test] +fn short_names_and_mime_types() { + assert_eq!(short_name("C:\\models\\part.obj"), "part.obj"); + assert_eq!(short_name("/home/x/front.svg"), "front.svg"); + assert_eq!(short_name("plain.csv"), "plain.csv"); + assert_eq!(mime_type("csv"), "text/csv"); + assert_eq!(mime_type("json"), "application/json"); +} + +#[test] +fn loaded_text_is_lossy() { + let l = Loaded { purpose: (), name: "a".into(), bytes: vec![b'o', b'k', 0xff] }; + assert!(l.text().starts_with("ok")); +} diff --git a/crates/openecraft-ui/src/lib.rs b/crates/openecraft-ui/src/lib.rs new file mode 100644 index 00000000..282ed35e --- /dev/null +++ b/crates/openecraft-ui/src/lib.rs @@ -0,0 +1,9 @@ +//! egui components shared by the OpenECraft applications (editor and parts manager). +//! +//! - [`part_editor`] – part tree, tabbed part editor, 2D / 3D model previews +//! - [`client`] – client of the parts server (`openecraft-server`) +//! - [`io`] – file dialogs on desktop, file picker and downloads in the browser + +pub mod client; +pub mod io; +pub mod part_editor; diff --git a/crates/openecraft-ui/src/part_editor.rs b/crates/openecraft-ui/src/part_editor.rs new file mode 100644 index 00000000..9434a0eb --- /dev/null +++ b/crates/openecraft-ui/src/part_editor.rs @@ -0,0 +1,534 @@ +//! Part widgets: product group tree, tabbed part editor, read only summary and +//! previews of the 2D front view and the 3D model. + +use crate::io::{short_name, FileKind}; +use egui::{vec2, Color32, Pos2, RichText, Sense, Shape, Stroke}; +use openecraft_parts::vec3::{cross, dot, norm, sub, Orbit}; +use openecraft_parts::{parse_mesh, parse_svg, natural_cmp, FnKind, FunctionTemplate, Mesh3d, Model2d, Part, Prim2d, TopGroup, PRODUCT_GROUPS}; +use std::collections::BTreeMap; + +/// Graphics file of a part. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ModelKind { + /// 2D front view (SVG). + Front2d, + /// 3D model (STL, OBJ). + Mesh3d, +} + +impl FileKind for ModelKind { + fn filter(self) -> (&'static str, &'static [&'static str]) { + match self { + ModelKind::Front2d => ("2D front view (SVG)", &["svg"]), + ModelKind::Mesh3d => ("3D model (STL, OBJ)", &["stl", "obj"]), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PartTab { + General, + Commercial, + Technical, + Mounting, + Functions, + Accessories, + Graphics, +} + +/// Editor settings kept between frames. +pub struct EditorState { + pub tab: PartTab, + /// Factor of the "Scale" button for imported 3D models. + pub model_scale: f32, +} + +impl Default for EditorState { + fn default() -> Self { + EditorState { tab: PartTab::General, model_scale: 25.4 } + } +} + +/// Product group tree. Returns the part number that was double clicked. +pub fn part_tree(ui: &mut egui::Ui, id: &str, parts: &[&Part], filter: &str, selected: &mut Option) -> Option { + let mut tree: BTreeMap>>> = BTreeMap::new(); + for p in parts.iter().filter(|p| p.matches_text(filter)) { + let group = if p.group.is_empty() { "(no product group)" } else { p.group.as_str() }; + tree.entry(p.top_group).or_default().entry(group).or_default().entry(p.subgroup.as_str()).or_default().push(p); + } + let open = if filter.is_empty() { None } else { Some(true) }; + let mut activated = None; + let mut leaf = |ui: &mut egui::Ui, list: &mut Vec<&Part>| { + list.sort_by(|a, b| natural_cmp(&a.number, &b.number)); + for p in list.iter() { + let is_sel = selected.as_deref() == Some(p.number.as_str()); + let r = ui.selectable_label(is_sel, &p.number).on_hover_text(&p.description); + if r.clicked() { + *selected = Some(p.number.clone()); + } + if r.double_clicked() { + activated = Some(p.number.clone()); + } + } + }; + for (top, groups) in tree.iter_mut() { + egui::CollapsingHeader::new(RichText::new(top.title()).strong()) + .id_salt((id, top.title())) + .default_open(true) + .open(open) + .show(ui, |ui| { + for (group, subs) in groups.iter_mut() { + egui::CollapsingHeader::new(*group).id_salt((id, top.title(), *group)).open(open).show(ui, |ui| { + for (sub, list) in subs.iter_mut() { + if sub.is_empty() { + leaf(ui, list); + } else { + egui::CollapsingHeader::new(*sub) + .id_salt((id, top.title(), *group, *sub)) + .open(open) + .show(ui, |ui| leaf(ui, list)); + } + } + }); + } + }); + } + if tree.is_empty() { + ui.weak("No parts found."); + } + activated +} + +fn text_row(ui: &mut egui::Ui, label: &str, value: &mut String) { + ui.label(label); + ui.add(egui::TextEdit::singleline(value).desired_width(f32::INFINITY)); + ui.end_row(); +} + +fn num_row(ui: &mut egui::Ui, label: &str, value: &mut f32, suffix: &str) { + ui.label(label); + ui.add(egui::DragValue::new(value).speed(0.1).range(0.0..=1.0e7).suffix(suffix)); + ui.end_row(); +} + +/// Tabbed editor for one part. `all_numbers` are offered as accessories, `duplicate` +/// marks the part number as already used. Returns a requested model import. +pub fn part_editor(ui: &mut egui::Ui, part: &mut Part, state: &mut EditorState, all_numbers: &[String], duplicate: bool) -> Option { + let mut request = None; + ui.horizontal_wrapped(|ui| { + for (t, name) in [ + (PartTab::General, "General"), + (PartTab::Commercial, "Prices / other"), + (PartTab::Technical, "Technical data"), + (PartTab::Mounting, "Mounting data"), + (PartTab::Functions, "Function template"), + (PartTab::Accessories, "Accessories"), + (PartTab::Graphics, "Graphics"), + ] { + ui.selectable_value(&mut state.tab, t, name); + } + }); + ui.separator(); + egui::ScrollArea::vertical().id_salt("part_editor").auto_shrink([false, false]).show(ui, |ui| match state.tab { + PartTab::General => { + egui::Grid::new("pg").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { + ui.label("Part number"); + ui.vertical(|ui| { + ui.add(egui::TextEdit::singleline(&mut part.number).desired_width(f32::INFINITY).font(egui::TextStyle::Monospace)); + if duplicate { + ui.colored_label(Color32::from_rgb(220, 60, 60), "Part number already exists"); + } + }); + ui.end_row(); + text_row(ui, "Type number", &mut part.type_number); + text_row(ui, "Order number", &mut part.order_number); + text_row(ui, "Manufacturer", &mut part.manufacturer); + text_row(ui, "Supplier", &mut part.supplier); + ui.label("Description"); + ui.add(egui::TextEdit::multiline(&mut part.description).desired_rows(2).desired_width(f32::INFINITY)); + ui.end_row(); + ui.label("Product top group"); + egui::ComboBox::from_id_salt("top").selected_text(part.top_group.title()).show_ui(ui, |ui| { + for t in TopGroup::ALL { + ui.selectable_value(&mut part.top_group, t, t.title()); + } + }); + ui.end_row(); + ui.label("Product group"); + ui.horizontal(|ui| { + ui.add(egui::TextEdit::singleline(&mut part.group).desired_width(200.0)); + egui::ComboBox::from_id_salt("grp").selected_text("…").width(24.0).show_ui(ui, |ui| { + for (g, _) in PRODUCT_GROUPS { + if ui.selectable_label(part.group == *g, *g).clicked() { + part.group = g.to_string(); + } + } + }); + }); + ui.end_row(); + ui.label("Product subgroup"); + ui.horizontal(|ui| { + ui.add(egui::TextEdit::singleline(&mut part.subgroup).desired_width(200.0)); + let subs = PRODUCT_GROUPS.iter().find(|(g, _)| *g == part.group).map(|(_, s)| *s).unwrap_or(&[]); + if !subs.is_empty() { + egui::ComboBox::from_id_salt("sub").selected_text("…").width(24.0).show_ui(ui, |ui| { + for s in subs { + if ui.selectable_label(part.subgroup == *s, *s).clicked() { + part.subgroup = s.to_string(); + } + } + }); + } + }); + ui.end_row(); + ui.label("Identifier"); + ui.add(egui::TextEdit::singleline(&mut part.identifier).desired_width(50.0)) + .on_hover_text("Identifying letter of devices using this part (K, Q, S …)"); + ui.end_row(); + ui.label("Note"); + ui.add(egui::TextEdit::multiline(&mut part.note).desired_rows(2).desired_width(f32::INFINITY)); + ui.end_row(); + }); + } + PartTab::Commercial => { + egui::Grid::new("pc").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { + ui.label("Price"); + ui.horizontal(|ui| { + ui.add(egui::DragValue::new(&mut part.price).speed(0.1).range(0.0..=1.0e7).fixed_decimals(2)); + ui.add(egui::TextEdit::singleline(&mut part.currency).desired_width(40.0)); + }); + ui.end_row(); + ui.label("Price unit"); + ui.add(egui::DragValue::new(&mut part.price_unit).range(1..=100000)).on_hover_text("The price refers to this many units"); + ui.end_row(); + ui.label("Packaging quantity"); + ui.add(egui::DragValue::new(&mut part.pack_quantity).range(1..=100000)); + ui.end_row(); + ui.label("Quantity unit"); + ui.add(egui::TextEdit::singleline(&mut part.quantity_unit).desired_width(60.0)); + ui.end_row(); + text_row(ui, "Certificates", &mut part.certificates); + text_row(ui, "Datasheet (URL)", &mut part.datasheet); + }); + if part.datasheet.starts_with("http") { + ui.hyperlink_to("Open datasheet", &part.datasheet); + } + } + PartTab::Technical => { + egui::Grid::new("pt").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { + text_row(ui, "Voltage", &mut part.voltage); + text_row(ui, "Current", &mut part.current); + text_row(ui, "Power", &mut part.power); + ui.label("Technical data"); + ui.add(egui::TextEdit::multiline(&mut part.tech_data).desired_rows(5).desired_width(f32::INFINITY)); + ui.end_row(); + }); + } + PartTab::Mounting => { + egui::Grid::new("pm").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { + num_row(ui, "Width", &mut part.width, " mm"); + num_row(ui, "Height", &mut part.height, " mm"); + num_row(ui, "Depth", &mut part.depth, " mm"); + num_row(ui, "Weight", &mut part.weight, " kg"); + text_row(ui, "Mounting", &mut part.mounting); + }); + } + PartTab::Functions => { + ui.weak("Functions the part provides. Used for device selection, the contact image (reserve contacts), the project check and to assign connection designations. Designations are listed in symbol connection order, separated by blanks."); + ui.add_space(4.0); + let mut remove = None; + egui::Grid::new("pf").num_columns(4).striped(true).spacing([8.0, 4.0]).show(ui, |ui| { + ui.label(RichText::new("Function").strong()); + ui.label(RichText::new("Connection designations").strong()); + ui.label(RichText::new("Description").strong()); + ui.label(""); + ui.end_row(); + for (i, f) in part.functions.iter_mut().enumerate() { + egui::ComboBox::from_id_salt(("fk", i)).selected_text(f.kind.title()).width(170.0).show_ui(ui, |ui| { + for k in FnKind::ALL { + ui.selectable_value(&mut f.kind, k, k.title()); + } + }); + ui.add(egui::TextEdit::singleline(&mut f.pins).desired_width(140.0).font(egui::TextStyle::Monospace)); + ui.add(egui::TextEdit::singleline(&mut f.description).desired_width(160.0)); + if ui.small_button("🗑").clicked() { + remove = Some(i); + } + ui.end_row(); + } + }); + if let Some(i) = remove { + part.functions.remove(i); + } + if ui.button("➕ Add function").clicked() { + part.functions.push(FunctionTemplate::new(FnKind::No, "")); + } + } + PartTab::Accessories => { + let mut remove = None; + for (i, a) in part.accessories.iter().enumerate() { + ui.horizontal(|ui| { + let known = all_numbers.contains(a); + ui.label(RichText::new(a).monospace().color(if known { ui.visuals().text_color() } else { Color32::from_rgb(220, 60, 60) })); + if ui.small_button("🗑").clicked() { + remove = Some(i); + } + }); + } + if let Some(i) = remove { + part.accessories.remove(i); + } + let mut add = None; + egui::ComboBox::from_id_salt("acc").selected_text("➕ Add accessory").width(240.0).show_ui(ui, |ui| { + for n in all_numbers { + if *n != part.number && !part.accessories.contains(n) && ui.selectable_label(false, n).clicked() { + add = Some(n.clone()); + } + } + }); + if let Some(n) = add { + part.accessories.push(n); + } + } + PartTab::Graphics => request = graphics_tab(ui, part, &mut state.model_scale), + }); + request +} + +/// 2D front view and 3D model of a part. +fn graphics_tab(ui: &mut egui::Ui, part: &mut Part, model_scale: &mut f32) -> Option { + let mut request = None; + ui.weak("The 2D front view is used in the panel front view and on mounting layout pages, the 3D model in the 3D panel view. Both are fitted to the mounting data (width × height × depth)."); + ui.add_space(4.0); + ui.label(RichText::new("2D front view").strong()); + ui.horizontal(|ui| { + model_2d_preview(ui, part.model_2d.as_ref(), vec2(180.0, 140.0)); + ui.vertical(|ui| { + match &part.model_2d { + Some(m) => ui.label(format!("{:.1} × {:.1} mm, {} elements", m.width, m.height, m.prims.len())), + None => ui.weak("none – a plain rectangle is drawn"), + }; + if ui.button("Import SVG…").clicked() { + request = Some(ModelKind::Front2d); + } + if part.model_2d.is_some() && ui.button("🗑 Remove").clicked() { + part.model_2d = None; + } + }); + }); + ui.separator(); + ui.label(RichText::new("3D model").strong()); + ui.horizontal(|ui| { + match &part.model_3d { + Some(m) => mesh_preview(ui, m, vec2(180.0, 160.0)), + None => { + ui.allocate_space(vec2(180.0, 40.0)); + } + } + ui.vertical(|ui| { + match &part.model_3d { + Some(m) => { + let s = m.size(); + ui.label(format!("{:.1} × {:.1} × {:.1} mm, {} triangles", s[0], s[1], s[2], m.triangles.len())); + } + None => { + ui.weak("none – a box of the mounting dimensions is drawn"); + } + } + if ui.button("Import STL / OBJ…").clicked() { + request = Some(ModelKind::Mesh3d); + } + if part.model_3d.is_some() && ui.button("🗑 Remove").clicked() { + part.model_3d = None; + } + }); + }); + if let Some(m) = &mut part.model_3d { + ui.horizontal_wrapped(|ui| { + ui.label("Rotate 90°:"); + for (axis, label) in [(0, "X"), (1, "Y"), (2, "Z")] { + if ui.button(label).on_hover_text("Turn the model so that its front faces the viewer (+Z) and its top is +Y").clicked() { + m.rotate90(axis); + } + } + ui.separator(); + ui.label("Scale ×"); + ui.add(egui::DragValue::new(model_scale).speed(0.01).range(0.001..=10000.0)); + if ui.button("Apply").on_hover_text("e.g. 25.4 for models in inch, 1000 for models in metres").clicked() { + m.scale(*model_scale); + } + }); + let s = m.size(); + let differs = [(s[0], part.width), (s[1], part.height), (s[2], part.depth)].iter().any(|(a, b)| (a - b).abs() > 0.5); + if differs { + ui.colored_label( + Color32::from_rgb(220, 140, 0), + format!( + "The model ({:.1} × {:.1} × {:.1}) differs from the mounting data ({:.1} × {:.1} × {:.1}); it is stretched to the mounting data.", + s[0], s[1], s[2], part.width, part.height, part.depth + ), + ); + if ui.button("Use model size as mounting data").clicked() { + part.width = (s[0] * 10.0).round() / 10.0; + part.height = (s[1] * 10.0).round() / 10.0; + part.depth = (s[2] * 10.0).round() / 10.0; + } + } + } + request +} + +/// Parses a model file and assigns it to the part. Returns a status message. +pub fn apply_model(part: &mut Part, kind: ModelKind, name: &str, bytes: &[u8]) -> Result { + let file = short_name(name); + let number = &part.number; + match kind { + ModelKind::Front2d => { + let m = parse_svg(&String::from_utf8_lossy(bytes))?; + let msg = format!("{file}: 2D front view with {} elements assigned to {number}", m.prims.len()); + part.model_2d = Some(m); + Ok(msg) + } + ModelKind::Mesh3d => { + let m = parse_mesh(file, bytes)?; + let s = m.size(); + let msg = format!("{file}: 3D model with {} triangles ({:.1} × {:.1} × {:.1} mm) assigned to {number}", m.triangles.len(), s[0], s[1], s[2]); + // Parts without mounting data take the model size. + if part.width <= 0.0 || part.height <= 0.0 { + part.width = s[0]; + part.height = s[1]; + part.depth = s[2]; + } + part.model_3d = Some(m); + Ok(msg) + } + } +} + +/// Scaled drawing of a 2D front view. +pub fn model_2d_preview(ui: &mut egui::Ui, model: Option<&Model2d>, size: egui::Vec2) { + let (resp, painter) = ui.allocate_painter(size, Sense::hover()); + let visuals = ui.visuals(); + painter.rect_filled(resp.rect, 4.0, visuals.extreme_bg_color); + let Some(m) = model.filter(|m| m.width > 0.0 && m.height > 0.0) else { + painter.text(resp.rect.center(), egui::Align2::CENTER_CENTER, "no 2D model", egui::FontId::proportional(12.0), visuals.weak_text_color()); + return; + }; + let zoom = ((size.x - 12.0) / m.width).min((size.y - 12.0) / m.height); + let origin = resp.rect.center() - vec2(m.width, m.height) * zoom / 2.0; + let map = |q: [f32; 2]| origin + vec2(q[0], q[1]) * zoom; + let ink = visuals.text_color(); + let line = Stroke::new(1.0, ink); + painter.rect_filled(egui::Rect::from_two_pos(map([0.0, 0.0]), map([m.width, m.height])), 0.0, visuals.widgets.inactive.bg_fill); + for prim in &m.prims { + match prim { + Prim2d::Line { a, b } => { + painter.line_segment([map(*a), map(*b)], line); + } + Prim2d::Rect { min, max, fill } => { + let r = egui::Rect::from_two_pos(map(*min), map(*max)); + if *fill { + painter.rect_filled(r, 0.0, ink); + } else { + painter.rect_stroke(r, 0.0, line, egui::StrokeKind::Middle); + } + } + Prim2d::Circle { c, r, fill } => { + let r = (r * zoom).max(1.0); + if *fill { + painter.circle_filled(map(*c), r, ink); + } else { + painter.circle_stroke(map(*c), r, line); + } + } + Prim2d::Polyline { pts, closed, fill } => { + let v: Vec = pts.iter().map(|q| map(*q)).collect(); + painter.add(match (*closed, *fill) { + (true, true) => Shape::convex_polygon(v, ink, Stroke::NONE), + (true, false) => Shape::closed_line(v, line), + _ => Shape::line(v, line), + }); + } + Prim2d::Text { pos, text, size } => { + let px = size * zoom * 1.25; + if px >= 3.0 { + painter.text(map(*pos), egui::Align2::LEFT_CENTER, text, egui::FontId::proportional(px), ink); + } + } + } + } +} + +/// Small shaded view of a mesh; drag to rotate. +pub fn mesh_preview(ui: &mut egui::Ui, mesh: &Mesh3d, size: egui::Vec2) { + let (resp, painter) = ui.allocate_painter(size, Sense::drag()); + let id = resp.id.with("angles"); + let (mut yaw, mut pitch): (f32, f32) = ui.data(|d| d.get_temp(id)).unwrap_or((0.6, 0.35)); + if resp.dragged() { + yaw -= resp.drag_delta().x * 0.01; + pitch = (pitch + resp.drag_delta().y * 0.01).clamp(-1.5, 1.5); + ui.data_mut(|d| d.insert_temp(id, (yaw, pitch))); + } + let dark = ui.visuals().dark_mode; + painter.rect_filled(resp.rect, 4.0, if dark { Color32::from_rgb(30, 32, 36) } else { Color32::from_rgb(232, 235, 240) }); + let s = mesh.size(); + let (min, _) = mesh.bounds(); + let c = [min[0] + s[0] / 2.0, min[1] + s[1] / 2.0, min[2] + s[2] / 2.0]; + let (eye, right, up, fwd) = Orbit { yaw, pitch, dist: 1.0, target: c }.basis(); + let view = sub(eye, c); // direction towards the viewer + let radius = (s[0] * s[0] + s[1] * s[1] + s[2] * s[2]).sqrt().max(1e-3) / 2.0; + let scale = size.x.min(size.y) * 0.45 / radius; + let center = resp.rect.center(); + let light = norm([0.35, 0.75, 0.55]); + let mut tris: Vec<(f32, [Pos2; 3], Color32)> = Vec::new(); + for t in &mesh.triangles { + let v = t.map(|i| mesh.vertices[i as usize]); + let n = norm(cross(sub(v[1], v[0]), sub(v[2], v[0]))); + if dot(n, view) <= 0.0 { + continue; + } + let pts = v.map(|q| { + let d = sub(q, c); + center + vec2(dot(d, right), -dot(d, up)) * scale + }); + let depth = v.iter().map(|q| dot(sub(*q, c), fwd)).sum::(); + let shade = 0.5 + 0.5 * dot(n, light).max(0.0); + let g = (190.0 * shade) as u8; + tris.push((depth, pts, Color32::from_rgb(g, g.saturating_add(6), g.saturating_add(14)))); + } + tris.sort_by(|a, b| b.0.total_cmp(&a.0)); + for (_, pts, color) in tris { + painter.add(Shape::convex_polygon(pts.to_vec(), color, Stroke::new(0.5, color))); + } + if resp.hovered() { + painter.text(resp.rect.left_bottom() + vec2(4.0, -4.0), egui::Align2::LEFT_BOTTOM, "drag to rotate", egui::FontId::proportional(10.0), Color32::GRAY); + } +} + +/// Read only summary of a part. +pub fn part_summary(ui: &mut egui::Ui, p: &Part) { + ui.label(RichText::new(&p.number).monospace().strong()); + ui.label(&p.description); + egui::Grid::new("sum").num_columns(2).show(ui, |ui| { + for (k, v) in [ + ("Manufacturer", p.manufacturer.clone()), + ("Type number", p.type_number.clone()), + ("Order number", p.order_number.clone()), + ("Product group", format!("{} / {}", p.group, p.subgroup)), + ("Voltage / current", format!("{} {}", p.voltage, p.current)), + ("Price", format!("{:.2} {} / {} {}", p.price, p.currency, p.price_unit, p.quantity_unit)), + ("Dimensions", format!("{} × {} × {} mm", p.width, p.height, p.depth)), + ("Functions", p.template_summary()), + ("Accessories", p.accessories.join(", ")), + ] { + if !v.trim().is_empty() && v.trim() != "/" { + ui.label(RichText::new(k).weak()); + ui.label(v); + ui.end_row(); + } + } + }); +} + +#[cfg(test)] +mod tests; diff --git a/crates/openecraft-ui/src/part_editor/tests.rs b/crates/openecraft-ui/src/part_editor/tests.rs new file mode 100644 index 00000000..e3c36188 --- /dev/null +++ b/crates/openecraft-ui/src/part_editor/tests.rs @@ -0,0 +1,32 @@ +use super::*; + +#[test] +fn models_are_assigned_to_the_part() { + let mut part = Part { number: "NEW.PART".into(), ..Default::default() }; + let svg = r#""#; + let msg = apply_model(&mut part, ModelKind::Front2d, "C:\\drawings\\front.svg", svg.as_bytes()).unwrap(); + assert!(msg.starts_with("front.svg"), "{msg}"); + assert_eq!(part.model_2d.as_ref().unwrap().prims.len(), 1); + + // Without mounting data the part takes the model size. + let obj = "v 0 0 0\nv 30 0 0\nv 30 20 0\nv 0 20 10\nf 1 2 3\nf 1 3 4\n"; + let msg = apply_model(&mut part, ModelKind::Mesh3d, "/models/part.obj", obj.as_bytes()).unwrap(); + assert!(msg.contains("part.obj") && msg.contains("NEW.PART"), "{msg}"); + assert_eq!((part.width, part.height, part.depth), (30.0, 20.0, 10.0)); + assert_eq!(part.model_3d.as_ref().unwrap().triangles.len(), 2); + + // Existing mounting data is kept. + part.width = 45.0; + apply_model(&mut part, ModelKind::Mesh3d, "part.obj", obj.as_bytes()).unwrap(); + assert_eq!(part.width, 45.0); + + // Broken files are reported, the part keeps its model. + assert!(apply_model(&mut part, ModelKind::Mesh3d, "bad.stl", b"garbage").is_err()); + assert!(part.model_3d.is_some()); +} + +#[test] +fn model_file_filters() { + assert_eq!(ModelKind::Front2d.filter().1, &["svg"]); + assert_eq!(ModelKind::Mesh3d.filter().1, &["stl", "obj"]); +} diff --git a/parts-manager/Cargo.toml b/parts-manager/Cargo.toml new file mode 100644 index 00000000..a853feb8 --- /dev/null +++ b/parts-manager/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "openecraft-parts-manager" +version = "0.1.0" +edition = "2021" +description = "OpenECraft parts manager - maintains the parts of an OpenECraft parts server" +license = "MIT OR Apache-2.0" + +[[bin]] +name = "openecraft-parts-manager" +path = "src/main.rs" + +[dependencies] +eframe = { version = "0.37", default-features = false, features = [ + "accesskit", + "clipboard", + "default_fonts", + "glow", + "links", + "persistence", + "wayland", + "x11", +] } +egui = { version = "0.37", features = ["monochrome_emoji_fonts"] } +serde_json = "1" +log = "0.4" +openecraft-parts = { path = "../crates/openecraft-parts" } +openecraft-ui = { path = "../crates/openecraft-ui" } + +[target.'cfg(not(target_arch = "wasm32"))'.dependencies] +env_logger = "0.11" + +[target.'cfg(target_arch = "wasm32")'.dependencies] +wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" +web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement"] } diff --git a/parts-manager/Trunk.toml b/parts-manager/Trunk.toml new file mode 100644 index 00000000..f64ccb0f --- /dev/null +++ b/parts-manager/Trunk.toml @@ -0,0 +1,7 @@ +[build] +target = "index.html" +dist = "dist" + +[serve] +addresses = ["127.0.0.1"] +port = 8082 diff --git a/parts-manager/index.html b/parts-manager/index.html new file mode 100644 index 00000000..36bb4584 --- /dev/null +++ b/parts-manager/index.html @@ -0,0 +1,19 @@ + + + + + + OpenECraft parts manager + + + + + +
Loading the OpenECraft parts manager…
+ + diff --git a/parts-manager/src/app.rs b/parts-manager/src/app.rs new file mode 100644 index 00000000..120abb97 --- /dev/null +++ b/parts-manager/src/app.rs @@ -0,0 +1,357 @@ +//! Main window of the parts manager: connection, part tree, part editor. + +use crate::session::{FollowUp, Session}; +use egui::{Color32, Key, KeyboardShortcut, Modifiers, RichText}; +use openecraft_parts::to_csv; +use openecraft_ui::client::ServerClient; +use openecraft_ui::io::{short_name, FileIo, FileKind, Loaded}; +use openecraft_ui::part_editor::{self as pe, EditorState, ModelKind}; + +/// What a file is opened for. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Purpose { + /// CSV / JSON parts file, uploaded to the server. + Parts, + /// 2D / 3D model of the part in the editor. + Model(ModelKind), +} + +impl FileKind for Purpose { + fn filter(self) -> (&'static str, &'static [&'static str]) { + match self { + Purpose::Parts => ("Parts (CSV, JSON)", &["csv", "json", "txt"]), + Purpose::Model(kind) => kind.filter(), + } + } +} + +/// Action waiting for confirmation. +enum Confirm { + /// Discard unsaved changes, then open this part (`None`: start a new part). + Discard(Option), + /// Delete this part on the server. + Delete(String), +} + +pub struct ManagerApp { + client: ServerClient, + session: Session, + editor: EditorState, + io: FileIo, + filter: String, + confirm: Option, + /// Part number a model import was requested for. + model_target: Option, + started: bool, + title: String, +} + +const URL_KEY: &str = "server_url"; + +impl ManagerApp { + pub fn new(cc: &eframe::CreationContext<'_>) -> ManagerApp { + let mut client = ServerClient::default(); + if let Some(url) = cc.storage.and_then(|s| eframe::get_value::(s, URL_KEY)) { + client.url = url; + } + ManagerApp { + client, + session: Session::default(), + editor: EditorState::default(), + io: FileIo::default(), + filter: String::new(), + confirm: None, + model_target: None, + started: false, + title: String::new(), + } + } + + fn writable(&self) -> bool { + self.client.writable() && !self.client.busy() + } + + fn poll(&mut self, ctx: &egui::Context) { + for reply in self.client.poll() { + match self.session.apply(&reply) { + Some(FollowUp::Reload) => self.client.download(ctx), + Some(FollowUp::Delete(number)) => self.client.delete(ctx, &number), + None => {} + } + } + if let Some(loaded) = self.io.poll() { + self.loaded(ctx, loaded); + } + } + + fn loaded(&mut self, ctx: &egui::Context, loaded: Loaded) { + match loaded.purpose { + Purpose::Parts => self.client.upload_file(ctx, loaded.bytes), + Purpose::Model(kind) => { + let target = self.model_target.take(); + let draft = self.session.draft.as_mut().filter(|d| Some(&d.part.number) == target.as_ref()); + self.client.status = match draft { + Some(d) => pe::apply_model(&mut d.part, kind, &loaded.name, &loaded.bytes) + .map(|m| format!("{m} – save to upload it")) + .unwrap_or_else(|e| format!("Model import failed: {e}")), + None => format!("{}: the part is no longer open", short_name(&loaded.name)), + }; + } + } + } + + /// Opens a part or starts a new one, asking first if changes would be lost. + fn open(&mut self, number: Option) { + if self.session.dirty() { + self.confirm = Some(Confirm::Discard(number)); + return; + } + match number { + Some(n) => self.session.select(&n), + None => self.session.new_part(), + } + } + + fn save(&mut self, ctx: &egui::Context) { + if let (Some(d), None) = (&self.session.draft, self.session.save_problem()) { + let part = d.part.clone(); + self.client.save(ctx, &part); + } + } + + fn export(&mut self, csv: bool) { + let (name, filter, content) = if csv { + ("parts.csv", ("CSV", "csv"), to_csv(&self.session.parts)) + } else { + ("parts.json", ("JSON", "json"), serde_json::to_string_pretty(&self.session.database()).unwrap_or_default()) + }; + self.client.status = match self.io.save_as(name, filter, &content) { + Ok(Some(path)) => format!("Exported {} parts to {}", self.session.parts.len(), short_name(&path)), + Ok(None) => return, + Err(e) => format!("Export failed: {e}"), + }; + } + + fn connection_bar(&mut self, ui: &mut egui::Ui) { + let ctx = ui.ctx().clone(); + ui.horizontal_wrapped(|ui| { + ui.label(RichText::new("OpenECraft parts manager").strong()); + ui.separator(); + ui.label("Server"); + let url = ui.add(egui::TextEdit::singleline(&mut self.client.url).desired_width(240.0)); + ui.label("Access token"); + let token = ui.add( + egui::TextEdit::singleline(&mut self.client.token).password(true).desired_width(160.0).hint_text("needed for changes"), + ); + let enter = (url.lost_focus() || token.lost_focus()) && ui.input(|i| i.key_pressed(Key::Enter)); + if ui.add_enabled(!self.client.busy(), egui::Button::new("Connect")).clicked() || enter { + self.client.check(&ctx); + } + ui.separator(); + match &self.client.info { + Some(info) => { + ui.label(format!("{} {}", info.name, info.version)); + if info.writable { + ui.label(RichText::new("writable with token").color(Color32::from_rgb(60, 160, 90))); + } else { + ui.label(RichText::new("read-only server").color(Color32::from_rgb(220, 140, 0))) + .on_hover_text("Start openecraft-server with --token to allow changes"); + } + } + None => { + ui.weak("not connected"); + } + } + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + let mut pref = ui.ctx().options(|o| o.theme_preference); + egui::ComboBox::from_id_salt("theme").selected_text(format!("{pref:?}")).width(70.0).show_ui(ui, |ui| { + ui.selectable_value(&mut pref, egui::ThemePreference::System, "System"); + ui.selectable_value(&mut pref, egui::ThemePreference::Light, "Light"); + ui.selectable_value(&mut pref, egui::ThemePreference::Dark, "Dark"); + }); + if pref != ui.ctx().options(|o| o.theme_preference) { + ui.ctx().set_theme(pref); + } + }); + }); + } + + fn toolbar(&mut self, ui: &mut egui::Ui) { + let ctx = ui.ctx().clone(); + let connected = self.session.loaded; + let writable = self.writable(); + let has_draft = self.session.draft.is_some(); + let dirty = self.session.dirty(); + ui.horizontal_wrapped(|ui| { + if ui.add_enabled(connected, egui::Button::new("➕ New")).clicked() { + self.open(None); + } + if ui.add_enabled(has_draft, egui::Button::new("⎘ Copy")).on_hover_text("New part based on the open one").clicked() { + self.session.copy_part(); + } + let save = ui + .add_enabled(writable && dirty && self.session.save_problem().is_none(), egui::Button::new("✔ Save")) + .on_hover_text("Create / update the part on the server (Ctrl+S)"); + if save.clicked() { + self.save(&ctx); + } + if ui.add_enabled(dirty, egui::Button::new("⟲ Revert")).on_hover_text("Discard the changes").clicked() { + self.session.revert(); + } + let deletable = self.session.draft.as_ref().and_then(|d| d.original.clone()); + if ui.add_enabled(writable && deletable.is_some(), egui::Button::new("🗑 Delete")).clicked() { + self.confirm = deletable.map(Confirm::Delete); + } + ui.separator(); + if ui.add_enabled(!self.client.busy() && connected, egui::Button::new("⟳ Reload")).on_hover_text("Load all parts from the server again").clicked() { + self.client.download(&ctx); + } + ui.menu_button("Import / export", |ui| { + if ui + .add_enabled(writable, egui::Button::new("⬆ Upload parts file (CSV / JSON)…")) + .on_hover_text("Adds new parts and replaces existing ones on the server") + .clicked() + { + self.io.open(&ctx, Purpose::Parts); + } + ui.separator(); + if ui.add_enabled(connected, egui::Button::new("Export as CSV…")).clicked() { + self.export(true); + } + if ui.add_enabled(connected, egui::Button::new("Export as JSON…")).clicked() { + self.export(false); + } + }); + if self.client.busy() { + ui.spinner(); + } + }); + } + + fn part_list(&mut self, ui: &mut egui::Ui) { + ui.add(egui::TextEdit::singleline(&mut self.filter).hint_text("Filter (number, type, manufacturer, text …)")); + ui.label(RichText::new(format!("{} parts", self.session.parts.len())).weak()); + if let Some(d) = self.session.draft.as_ref().filter(|d| d.original.is_none()) { + ui.label(RichText::new(format!("➕ {} (not saved)", d.part.number)).italics()); + } + egui::ScrollArea::vertical().id_salt("tree").auto_shrink([false, false]).show(ui, |ui| { + let refs: Vec<_> = self.session.parts.iter().collect(); + let before = self.session.selected().map(String::from); + let mut selected = before.clone(); + pe::part_tree(ui, "parts", &refs, &self.filter, &mut selected); + if selected != before { + self.open(selected); + } + }); + } + + fn editor(&mut self, ui: &mut egui::Ui) { + if !self.session.loaded { + ui.vertical_centered(|ui| { + ui.add_space(60.0); + ui.heading("Connect to a parts server"); + ui.label("Enter the address of an openecraft-server and click Connect."); + ui.label("The access token is only needed for changes; it is not stored."); + ui.add_space(8.0); + ui.weak("Start a server with: openecraft-server --token "); + }); + return; + } + let numbers: Vec = self.session.parts.iter().map(|p| p.number.clone()).collect(); + let problem = self.session.save_problem(); + let dirty = self.session.dirty(); + let Some(d) = self.session.draft.as_mut() else { + ui.weak("Select a part in the tree or create a new one."); + return; + }; + ui.horizontal(|ui| { + ui.heading(&d.part.number); + match (&d.original, dirty) { + (None, _) => ui.label(RichText::new("new part, not saved").color(Color32::from_rgb(220, 140, 0))), + (Some(_), true) => ui.label(RichText::new("changed, not saved").color(Color32::from_rgb(220, 140, 0))), + (Some(_), false) => ui.weak("saved"), + }; + if let Some(original) = d.original.as_ref().filter(|o| **o != d.part.number) { + ui.weak(format!("(renamed from {original})")); + } + }); + ui.separator(); + let duplicate = problem == Some("Part number already exists"); + if let Some(kind) = pe::part_editor(ui, &mut d.part, &mut self.editor, &numbers, duplicate) { + self.model_target = Some(d.part.number.clone()); + let ctx = ui.ctx().clone(); + self.io.open(&ctx, Purpose::Model(kind)); + } + } + + fn dialogs(&mut self, ctx: &egui::Context) { + let Some(confirm) = &self.confirm else { return }; + let (text, button) = match confirm { + Confirm::Discard(_) => { + let n = self.session.draft.as_ref().map(|d| d.part.number.clone()).unwrap_or_default(); + (format!("Discard the unsaved changes of {n}?"), "Discard") + } + Confirm::Delete(n) => (format!("Delete part {n} from the server? This cannot be undone."), "🗑 Delete"), + }; + let mut answer = None; + egui::Modal::new(egui::Id::unique("confirm")).show(ctx, |ui| { + ui.set_width(340.0); + ui.label(text); + ui.add_space(8.0); + ui.horizontal(|ui| { + if ui.button(button).clicked() { + answer = Some(true); + } + if ui.button("Cancel").clicked() || ui.input(|i| i.key_pressed(Key::Escape)) { + answer = Some(false); + } + }); + }); + match answer { + Some(true) => match self.confirm.take() { + Some(Confirm::Discard(number)) => { + self.session.revert(); + self.open(number); + } + Some(Confirm::Delete(number)) => self.client.delete(ctx, &number), + None => {} + }, + Some(false) => self.confirm = None, + None => {} + } + } +} + +impl eframe::App for ManagerApp { + fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) { + let ctx = ui.ctx().clone(); + if !self.started { + self.started = true; + self.client.check(&ctx); + } + self.poll(&ctx); + if ctx.input_mut(|i| i.consume_shortcut(&KeyboardShortcut::new(Modifiers::COMMAND, Key::S))) && self.writable() { + self.save(&ctx); + } + + egui::Panel::top("connection").show(ui, |ui| self.connection_bar(ui)); + egui::Panel::top("toolbar").show(ui, |ui| self.toolbar(ui)); + egui::Panel::bottom("status").show(ui, |ui| { + let color = if self.client.failed() { Color32::from_rgb(220, 60, 60) } else { ui.visuals().text_color() }; + ui.label(RichText::new(&self.client.status).color(color)); + }); + egui::Panel::left("parts").resizable(true).default_size(300.0).show(ui, |ui| self.part_list(ui)); + egui::CentralPanel::default().show(ui, |ui| self.editor(ui)); + self.dialogs(&ctx); + + let title = format!("OpenECraft parts manager – {}{}", self.client.url, if self.session.dirty() { " *" } else { "" }); + if title != self.title { + ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone())); + self.title = title; + } + } + + fn save(&mut self, storage: &mut dyn eframe::Storage) { + eframe::set_value(storage, URL_KEY, &self.client.url); + } +} diff --git a/parts-manager/src/main.rs b/parts-manager/src/main.rs new file mode 100644 index 00000000..ec7222c7 --- /dev/null +++ b/parts-manager/src/main.rs @@ -0,0 +1,48 @@ +//! OpenECraft parts manager – creates, edits and deletes the parts of an OpenECraft +//! parts server (`openecraft-server`). +//! +//! Runs natively on Windows, Linux and macOS and in the browser (WebAssembly). + +#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] + +mod app; +mod session; + +#[cfg(not(target_arch = "wasm32"))] +fn main() -> eframe::Result { + env_logger::init(); + let options = eframe::NativeOptions { + viewport: egui::ViewportBuilder::default() + .with_title("OpenECraft parts manager") + .with_inner_size([1200.0, 800.0]) + .with_min_inner_size([700.0, 450.0]), + ..Default::default() + }; + eframe::run_native("OpenECraft parts manager", options, Box::new(|cc| Ok(Box::new(app::ManagerApp::new(cc))))) +} + +#[cfg(target_arch = "wasm32")] +fn main() { + use wasm_bindgen::JsCast; + eframe::WebLogger::init(log::LevelFilter::Info).ok(); + wasm_bindgen_futures::spawn_local(async { + let document = web_sys::window().expect("no window").document().expect("no document"); + let canvas = document + .get_element_by_id("parts_manager_canvas") + .expect("canvas missing") + .dyn_into::() + .expect("not a canvas"); + let result = eframe::WebRunner::new() + .start(canvas, eframe::WebOptions::default(), Box::new(|cc| Ok(Box::new(app::ManagerApp::new(cc))))) + .await; + if let Some(loading) = document.get_element_by_id("loading") { + match result { + Ok(()) => loading.remove(), + Err(e) => { + loading.set_inner_html("

The parts manager failed to start. See the browser console for details.

"); + panic!("Failed to start eframe: {e:?}"); + } + } + } + }); +} diff --git a/parts-manager/src/session.rs b/parts-manager/src/session.rs new file mode 100644 index 00000000..3999d7f7 --- /dev/null +++ b/parts-manager/src/session.rs @@ -0,0 +1,157 @@ +//! Local copy of the server's parts and the part being edited. No UI code, so the +//! editing rules (new parts, renames, unsaved changes) are unit testable. + +use openecraft_parts::{natural_cmp, unique_number, Part, PartsDb}; +use openecraft_ui::client::Reply; + +/// The part in the editor. +#[derive(Clone, Debug, PartialEq)] +pub struct Draft { + /// Part number on the server; `None` for a part that was never saved. + pub original: Option, + pub part: Part, +} + +/// Request the application has to send after a server reply. +#[derive(Clone, Debug, PartialEq)] +pub enum FollowUp { + /// Load all parts again. + Reload, + /// Remove the old number of a renamed part. + Delete(String), +} + +#[derive(Default)] +pub struct Session { + /// Parts on the server (as of the last download). + pub parts: Vec, + pub revision: u64, + pub loaded: bool, + pub draft: Option, +} + +impl Session { + pub fn get(&self, number: &str) -> Option<&Part> { + self.parts.iter().find(|p| p.number == number) + } + + /// Server version of the draft. + fn saved(&self) -> Option<&Part> { + self.draft.as_ref()?.original.as_deref().and_then(|n| self.get(n)) + } + + /// True if the draft has changes that are not on the server. + pub fn dirty(&self) -> bool { + match &self.draft { + None => false, + Some(d) => self.saved() != Some(&d.part), + } + } + + /// The draft's part number belongs to another part on the server. + pub fn number_taken(&self) -> bool { + self.draft.as_ref().is_some_and(|d| { + d.original.as_deref() != Some(d.part.number.as_str()) && self.get(&d.part.number).is_some() + }) + } + + /// Why the draft cannot be saved, if it cannot. + pub fn save_problem(&self) -> Option<&'static str> { + let d = self.draft.as_ref()?; + if d.part.number.trim().is_empty() { + Some("The part number must not be empty") + } else if self.number_taken() { + Some("Part number already exists") + } else { + None + } + } + + pub fn selected(&self) -> Option<&str> { + self.draft.as_ref().map(|d| d.original.as_deref().unwrap_or(&d.part.number)) + } + + /// Opens a server part in the editor. + pub fn select(&mut self, number: &str) { + self.draft = self.get(number).map(|p| Draft { original: Some(p.number.clone()), part: p.clone() }); + } + + /// Discards the changes of the draft. + pub fn revert(&mut self) { + match self.draft.as_ref().and_then(|d| d.original.clone()) { + Some(n) => self.select(&n), + None => self.draft = None, + } + } + + /// Starts a new part. + pub fn new_part(&mut self) { + let number = unique_number(&self.parts, "NEW.PART"); + self.draft = Some(Draft { original: None, part: Part { number, manufacturer: "NEW".into(), ..Default::default() } }); + } + + /// Starts a new part as a copy of the draft. + pub fn copy_part(&mut self) { + if let Some(d) = &self.draft { + let mut part = d.part.clone(); + part.number = unique_number(&self.parts, &format!("{}_COPY", part.number)); + self.draft = Some(Draft { original: None, part }); + } + } + + /// All parts as a parts database (export). + pub fn database(&self) -> PartsDb { + PartsDb { parts: self.parts.clone() } + } + + /// Updates the local copy with a server reply. + pub fn apply(&mut self, reply: &Reply) -> Option { + match reply { + Reply::Info(Ok(info)) if !self.loaded || info.revision != self.revision => Some(FollowUp::Reload), + Reply::Parts(Ok(list)) => { + let keep = self.dirty(); + self.parts = list.parts.clone(); + self.parts.sort_by(|a, b| natural_cmp(&a.number, &b.number)); + self.revision = list.revision; + self.loaded = true; + if !keep { + // Show the current server state of the selected part. + match self.draft.as_ref().and_then(|d| d.original.clone()) { + Some(n) => self.select(&n), + None => self.draft = None, + } + } + None + } + Reply::Saved(Ok(part)) => { + match self.parts.iter_mut().find(|p| p.number == part.number) { + Some(p) => *p = (**part).clone(), + None => { + self.parts.push((**part).clone()); + self.parts.sort_by(|a, b| natural_cmp(&a.number, &b.number)); + } + } + let mut follow = None; + if let Some(d) = self.draft.as_mut().filter(|d| d.part.number == part.number) { + if let Some(old) = d.original.replace(part.number.clone()).filter(|old| *old != part.number) { + follow = Some(FollowUp::Delete(old)); + } + d.part = (**part).clone(); + } + follow + } + Reply::Deleted(number, Ok(())) => { + self.parts.retain(|p| &p.number != number); + if self.draft.as_ref().is_some_and(|d| d.original.as_ref() == Some(number)) { + self.draft = None; + } + None + } + Reply::Imported(Ok(_)) => Some(FollowUp::Reload), + _ => None, + } + } +} + +#[cfg(test)] +mod tests; diff --git a/parts-manager/src/session/tests.rs b/parts-manager/src/session/tests.rs new file mode 100644 index 00000000..ceaea3d5 --- /dev/null +++ b/parts-manager/src/session/tests.rs @@ -0,0 +1,120 @@ +use super::*; +use openecraft_parts::api::{ImportResult, PartList, ServerInfo}; + +fn part(number: &str) -> Part { + Part { number: number.into(), ..Default::default() } +} + +fn loaded(numbers: &[&str]) -> Session { + let mut s = Session::default(); + let list = PartList { revision: 4, parts: numbers.iter().map(|n| part(n)).collect(), ..Default::default() }; + assert_eq!(s.apply(&Reply::Parts(Ok(list))), None); + s +} + +#[test] +fn connecting_loads_the_parts_once_per_revision() { + let mut s = Session::default(); + let info = |revision| Reply::Info(Ok(ServerInfo { revision, ..Default::default() })); + assert_eq!(s.apply(&info(4)), Some(FollowUp::Reload)); + let list = PartList { revision: 4, parts: vec![part("B10"), part("B9")], ..Default::default() }; + s.apply(&Reply::Parts(Ok(list))); + assert!(s.loaded); + assert_eq!(s.parts[0].number, "B9", "natural sort order"); + assert_eq!(s.apply(&info(4)), None); + assert_eq!(s.apply(&info(5)), Some(FollowUp::Reload)); +} + +#[test] +fn editing_marks_the_draft_dirty_until_reverted() { + let mut s = loaded(&["A", "B"]); + assert!(!s.dirty()); + s.select("A"); + assert_eq!(s.selected(), Some("A")); + assert!(!s.dirty()); + s.draft.as_mut().unwrap().part.description = "changed".into(); + assert!(s.dirty()); + s.revert(); + assert!(!s.dirty()); + assert_eq!(s.draft.as_ref().unwrap().part.description, ""); +} + +#[test] +fn new_parts_get_unique_numbers_and_are_dirty() { + let mut s = loaded(&["NEW.PART"]); + s.new_part(); + let d = s.draft.as_ref().unwrap(); + assert_eq!((d.original.clone(), d.part.number.as_str()), (None, "NEW.PART_1")); + assert!(s.dirty()); + assert_eq!(s.save_problem(), None); + s.copy_part(); + assert_eq!(s.draft.as_ref().unwrap().part.number, "NEW.PART_1_COPY"); + s.revert(); + assert!(s.draft.is_none()); +} + +#[test] +fn existing_or_empty_numbers_cannot_be_saved() { + let mut s = loaded(&["A", "B"]); + s.select("A"); + s.draft.as_mut().unwrap().part.number = "B".into(); + assert!(s.number_taken()); + assert!(s.save_problem().is_some()); + s.draft.as_mut().unwrap().part.number = " ".into(); + assert!(s.save_problem().is_some()); + s.draft.as_mut().unwrap().part.number = "A".into(); + assert_eq!(s.save_problem(), None); +} + +#[test] +fn saving_a_renamed_part_deletes_the_old_number() { + let mut s = loaded(&["A"]); + s.select("A"); + s.draft.as_mut().unwrap().part.number = "A2".into(); + let follow = s.apply(&Reply::Saved(Ok(Box::new(part("A2"))))); + assert_eq!(follow, Some(FollowUp::Delete("A".into()))); + assert_eq!(s.draft.as_ref().unwrap().original.as_deref(), Some("A2")); + // Deleting the old number keeps the renamed part in the editor. + s.apply(&Reply::Deleted("A".into(), Ok(()))); + assert_eq!(s.parts.iter().map(|p| p.number.as_str()).collect::>(), ["A2"]); + assert_eq!(s.selected(), Some("A2")); + assert!(!s.dirty()); +} + +#[test] +fn saving_a_new_part_adds_it() { + let mut s = loaded(&["A"]); + s.new_part(); + let number = s.draft.as_ref().unwrap().part.number.clone(); + assert_eq!(s.apply(&Reply::Saved(Ok(Box::new(part(&number))))), None); + assert!(s.get(&number).is_some()); + assert!(!s.dirty()); +} + +#[test] +fn deleting_the_selected_part_closes_the_editor() { + let mut s = loaded(&["A", "B"]); + s.select("B"); + s.apply(&Reply::Deleted("B".into(), Ok(()))); + assert!(s.draft.is_none()); + assert_eq!(s.parts.len(), 1); + // Failed requests change nothing. + s.select("A"); + s.apply(&Reply::Deleted("A".into(), Err("missing or wrong access token".into()))); + assert_eq!(s.selected(), Some("A")); +} + +#[test] +fn reloading_keeps_unsaved_changes() { + let mut s = loaded(&["A"]); + s.select("A"); + s.draft.as_mut().unwrap().part.description = "mine".into(); + let mut theirs = part("A"); + theirs.description = "theirs".into(); + s.apply(&Reply::Parts(Ok(PartList { revision: 5, parts: vec![theirs.clone()], ..Default::default() }))); + assert_eq!(s.draft.as_ref().unwrap().part.description, "mine"); + // Without changes the editor shows the new server state. + s.revert(); + assert_eq!(s.draft.as_ref().unwrap().part.description, "theirs"); + assert_eq!(s.apply(&Reply::Imported(Ok(ImportResult { imported: 3, revision: 6 }))), Some(FollowUp::Reload)); +} diff --git a/src/app.rs b/src/app.rs index 86b5b73a..2746ffdb 100644 --- a/src/app.rs +++ b/src/app.rs @@ -195,7 +195,7 @@ impl App { fn poll_loaded(&mut self, ctx: &egui::Context) { if let Some(loaded) = self.io.poll() { - if matches!(loaded.purpose, Purpose::Model2d | Purpose::Model3d) { + if matches!(loaded.purpose, Purpose::Model(_)) { let msg = match self.parts_ui.apply_model(&loaded, &mut self.parts_db, &mut self.prj) { Ok(m) => m, Err(e) => format!("Model import failed: {e}"), @@ -1056,7 +1056,7 @@ impl App { for action in self.parts_ui.manager(ctx, &mut self.parts_db, &mut self.prj) { match action { PartsAction::Import => self.io.open(ctx, Purpose::Parts), - PartsAction::ImportModel(purpose) => self.io.open(ctx, purpose), + PartsAction::ImportModel(kind) => self.io.open(ctx, Purpose::Model(kind)), PartsAction::Export { name, filter, content } => self.export(ctx, name, filter, content), PartsAction::Message(m) => self.notify(ctx, m), } diff --git a/src/conventions/tests.rs b/src/conventions/tests.rs index 5771dd47..93f8d7fb 100644 --- a/src/conventions/tests.rs +++ b/src/conventions/tests.rs @@ -96,7 +96,7 @@ fn tests_path(module_file: &str) -> String { #[test] fn all_workspace_crates_are_checked() { let dirs = source_dirs(); - for member in ["src", "crates/openecraft-parts/src", "server/src"] { + for member in ["src", "crates/openecraft-parts/src", "crates/openecraft-ui/src", "server/src", "parts-manager/src"] { assert!(dirs.iter().any(|d| d.ends_with(member)), "{member} missing in {dirs:?}"); } } diff --git a/src/glyphs/tests.rs b/src/glyphs/tests.rs index 5dbfb2e3..484ac5ce 100644 --- a/src/glyphs/tests.rs +++ b/src/glyphs/tests.rs @@ -25,11 +25,11 @@ fn source_files(dir: &Path) -> Vec { fn all_ui_characters_exist_in_bundled_fonts() { let mut fonts = Fonts::new(TextOptions::default(), FontDefinitions::default()); let font = FontId::new(14.0, FontFamily::Proportional); - // The application and the parts library (catalog texts are shown in the UI). + // Every crate with UI texts (catalog texts of the parts library are shown, too). let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")); let mut missing: BTreeMap> = BTreeMap::new(); let mut checked = 0; - let files = [root.join("src"), root.join("crates/openecraft-parts/src")].iter().flat_map(|d| source_files(d)).collect::>(); + let files = ["src", "crates/openecraft-parts/src", "crates/openecraft-ui/src", "parts-manager/src"].iter().map(|d| root.join(d)).flat_map(|d| source_files(&d)).collect::>(); for path in files { let src = std::fs::read_to_string(&path).unwrap(); let name = path.strip_prefix(root).unwrap_or(&path).display().to_string(); diff --git a/src/io.rs b/src/io.rs index a882c169..141d8f99 100644 --- a/src/io.rs +++ b/src/io.rs @@ -1,7 +1,9 @@ -//! Platform specific file handling: native file dialogs on desktop, file picker and -//! downloads in the browser. +//! Files of the editor. Dialogs, the browser file picker and downloads are +//! implemented in `openecraft_ui::io`. -use std::sync::{Arc, Mutex}; +pub use openecraft_ui::io::short_name; +use openecraft_ui::io::FileKind; +use openecraft_ui::part_editor::ModelKind; /// What a file is opened for. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -9,150 +11,21 @@ pub enum Purpose { Project, /// Import into the parts database. Parts, - /// 2D front view of a part (SVG). - Model2d, - /// 3D model of a part (STL, OBJ). - Model3d, + /// 2D / 3D model of a part. + Model(ModelKind), } -impl Purpose { +impl FileKind for Purpose { fn filter(self) -> (&'static str, &'static [&'static str]) { match self { Purpose::Project => ("OpenECraft project", &[PROJECT_EXT, "json"]), Purpose::Parts => ("Parts (CSV, JSON)", &["csv", "json", "txt"]), - Purpose::Model2d => ("2D front view (SVG)", &["svg"]), - Purpose::Model3d => ("3D model (STL, OBJ)", &["stl", "obj"]), + Purpose::Model(kind) => kind.filter(), } } } -pub struct Loaded { - pub purpose: Purpose, - /// Native: full path. Web: file name. - pub name: String, - /// Raw file content (binary STL files are not text). - pub bytes: Vec, -} - -impl Loaded { - pub fn text(&self) -> String { - String::from_utf8_lossy(&self.bytes).into_owned() - } -} - -#[derive(Default, Clone)] -pub struct FileIo { - inbox: Arc>>, -} +pub type FileIo = openecraft_ui::io::FileIo; +pub type Loaded = openecraft_ui::io::Loaded; pub const PROJECT_EXT: &str = "oec"; - -impl FileIo { - /// Takes a file that finished loading (the web picker is asynchronous). - pub fn poll(&self) -> Option { - self.inbox.lock().ok()?.pop() - } - - #[cfg(not(target_arch = "wasm32"))] - pub fn open(&self, _ctx: &egui::Context, purpose: Purpose) { - let (name, ext) = purpose.filter(); - let Some(path) = rfd::FileDialog::new() - .add_filter(name, ext) - .pick_file() - else { - return; - }; - match std::fs::read(&path) { - Ok(bytes) => { - if let Ok(mut inbox) = self.inbox.lock() { - inbox.push(Loaded { purpose, name: path.display().to_string(), bytes }); - } - } - Err(e) => log::error!("Could not read {}: {e}", path.display()), - } - } - - #[cfg(target_arch = "wasm32")] - pub fn open(&self, ctx: &egui::Context, purpose: Purpose) { - let inbox = self.inbox.clone(); - let ctx = ctx.clone(); - wasm_bindgen_futures::spawn_local(async move { - let (name, ext) = purpose.filter(); - let Some(file) = rfd::AsyncFileDialog::new() - .add_filter(name, ext) - .pick_file() - .await - else { - return; - }; - let bytes = file.read().await; - if let Ok(mut inbox) = inbox.lock() { - inbox.push(Loaded { purpose, name: file.file_name(), bytes }); - } - ctx.request_repaint(); - }); - } - - /// Asks for a location and writes the file. Returns the chosen path / name. - #[cfg(not(target_arch = "wasm32"))] - pub fn save_as(&self, suggested: &str, filter: (&str, &str), content: &str) -> Result, String> { - let Some(path) = rfd::FileDialog::new().add_filter(filter.0, &[filter.1]).set_file_name(suggested).save_file() - else { - return Ok(None); - }; - std::fs::write(&path, content).map_err(|e| e.to_string())?; - Ok(Some(path.display().to_string())) - } - - /// In the browser "save as" is a download. - #[cfg(target_arch = "wasm32")] - pub fn save_as(&self, suggested: &str, filter: (&str, &str), content: &str) -> Result, String> { - let mime = match filter.1 { - "svg" => "image/svg+xml", - "html" => "text/html", - "csv" => "text/csv", - _ => "application/json", - }; - download(suggested, mime, content).map_err(|e| format!("{e:?}"))?; - Ok(Some(suggested.to_string())) - } - - /// Writes to a known location (native) or downloads again (web). - pub fn save_to(&self, path: &str, content: &str) -> Result<(), String> { - #[cfg(not(target_arch = "wasm32"))] - { - std::fs::write(path, content).map_err(|e| e.to_string()) - } - #[cfg(target_arch = "wasm32")] - { - download(path, "application/json", content).map_err(|e| format!("{e:?}")) - } - } - - pub fn can_save_in_place() -> bool { - cfg!(not(target_arch = "wasm32")) - } -} - -#[cfg(target_arch = "wasm32")] -fn download(name: &str, mime: &str, content: &str) -> Result<(), wasm_bindgen::JsValue> { - use wasm_bindgen::JsCast; - let parts = js_sys::Array::new(); - parts.push(&wasm_bindgen::JsValue::from_str(content)); - let opts = web_sys::BlobPropertyBag::new(); - opts.set_type(mime); - let blob = web_sys::Blob::new_with_str_sequence_and_options(&parts, &opts)?; - let url = web_sys::Url::create_object_url_with_blob(&blob)?; - let document = web_sys::window().and_then(|w| w.document()).ok_or("no document")?; - let a: web_sys::HtmlAnchorElement = document.create_element("a")?.dyn_into()?; - a.set_href(&url); - a.set_download(name); - a.click(); - web_sys::Url::revoke_object_url(&url)?; - Ok(()) -} - -/// File name without directories, for window titles. -pub fn short_name(path: &str) -> &str { - path.rsplit(['/', '\\']).next().unwrap_or(path) -} diff --git a/src/main.rs b/src/main.rs index 29b589a5..62d1199a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -21,7 +21,6 @@ mod ops; mod panel; mod panel_ui; mod parts; -mod parts_server; mod parts_ui; mod render; mod reports; diff --git a/src/panel_ui.rs b/src/panel_ui.rs index 571e6146..b93e4141 100644 --- a/src/panel_ui.rs +++ b/src/panel_ui.rs @@ -6,6 +6,7 @@ use crate::geom::{p, P}; use crate::model::{natural_cmp, Project}; use crate::panel::{self, Enclosure, ItemKind, PanelItem, PLATE_MARGIN, PLATE_THICKNESS, PLATE_Z}; use crate::parts::{self, PartsDb}; +use crate::parts::vec3::{cross, dot, norm, sub, Orbit}; use crate::render::{self, Draw, Ink}; use crate::reports::Analysis; use egui::{vec2, Color32, Key, PointerButton, Pos2, Rect, RichText, Sense, Shape, Stroke, Vec2}; @@ -25,13 +26,6 @@ pub enum View { ThreeD, } -struct Camera { - yaw: f32, - pitch: f32, - dist: f32, - target: [f32; 3], -} - struct MoveDrag { start: P, originals: Vec<(u64, f32, f32)>, @@ -58,7 +52,7 @@ pub struct PanelUi { fit_pending: bool, start: Option

, drag: Option, - cam: Option, + cam: Option, device_filter: String, new_enclosure: Option, pub status: String, @@ -831,7 +825,7 @@ impl PanelUi { let dark = ui.visuals().dark_mode; let (resp, painter) = ui.allocate_painter(ui.available_size(), Sense::click_and_drag()); let rect = resp.rect; - let cam = self.cam.get_or_insert_with(|| Camera { + let cam = self.cam.get_or_insert_with(|| Orbit { yaw: 0.55, pitch: 0.3, dist: e.width.max(e.height) * 1.9, @@ -845,7 +839,7 @@ impl PanelUi { } if resp.dragged_by(PointerButton::Middle) || resp.dragged_by(PointerButton::Secondary) { let dl = resp.drag_delta(); - let (_, right, up, _) = cam_basis(cam); + let (_, right, up, _) = cam.basis(); let s = cam.dist * 0.0015; for k in 0..3 { cam.target[k] += -right[k] * dl.x * s + up[k] * dl.y * s; @@ -856,11 +850,11 @@ impl PanelUi { let factor = zoom_delta * (wheel * 0.0025).exp(); cam.dist = (cam.dist / factor).clamp(100.0, 20000.0); } - let (eye, right, up, fwd) = cam_basis(cam); + let (eye, right, up, fwd) = cam.basis(); let f = rect.height() * 1.3; let center = rect.center(); let project = |q: [f32; 3]| -> Option<(Pos2, f32)> { - let v = sub3(q, eye); + let v = sub(q, eye); let z = dot(v, fwd); if z < 10.0 { return None; @@ -897,7 +891,7 @@ impl PanelUi { pts3.iter().map(|q| q[1]).sum::() / 4.0, pts3.iter().map(|q| q[2]).sum::() / 4.0, ]; - if dot(n, sub3(eye, fc)) <= 0.0 { + if dot(n, sub(eye, fc)) <= 0.0 { continue; // back face } let Some(pr) = pts3.iter().map(|q| project(*q)).collect::>>() else { continue }; @@ -952,8 +946,8 @@ impl PanelUi { if let Some(mesh) = mesh { for tri in panel::place_mesh(mesh, it) { let w = tri.map(|v| to3(v[0], v[1], v[2])); - let n = norm(cross(sub3(w[1], w[0]), sub3(w[2], w[0]))); - if dot(n, sub3(eye, w[0])) <= 0.0 { + let n = norm(cross(sub(w[1], w[0]), sub(w[2], w[0]))); + if dot(n, sub(eye, w[0])) <= 0.0 { continue; // back face } let Some(pr) = w.iter().map(|q| project(*q)).collect::>>() else { continue }; @@ -1035,7 +1029,7 @@ impl PanelUi { for it in e.items.iter().filter(|i| i.kind == ItemKind::Device) { if let Some((q, z)) = project(to3(it.x + it.w / 2.0, it.y + it.h / 2.0, it.z + it.d)) { let size = (it.w.min(it.h) * 0.25 * f / z).clamp(0.0, 18.0); - if size >= 7.0 && dot(sub3(eye, to3(it.x, it.y, it.z + it.d)), [0.0, 0.0, 1.0]) > 0.0 { + if size >= 7.0 && dot(sub(eye, to3(it.x, it.y, it.z + it.d)), [0.0, 0.0, 1.0]) > 0.0 { painter.text(q, egui::Align2::CENTER_CENTER, &it.tag, egui::FontId::proportional(size), Color32::from_rgb(20, 30, 50)); } } @@ -1085,53 +1079,6 @@ impl PanelUi { } } -/// Small shaded view of a mesh; drag to rotate. -pub fn mesh_preview(ui: &mut egui::Ui, mesh: &crate::parts::Mesh3d, size: Vec2) { - let (resp, painter) = ui.allocate_painter(size, Sense::drag()); - let id = resp.id.with("angles"); - let (mut yaw, mut pitch): (f32, f32) = ui.data(|d| d.get_temp(id)).unwrap_or((0.6, 0.35)); - if resp.dragged() { - yaw -= resp.drag_delta().x * 0.01; - pitch = (pitch + resp.drag_delta().y * 0.01).clamp(-1.5, 1.5); - ui.data_mut(|d| d.insert_temp(id, (yaw, pitch))); - } - let dark = ui.visuals().dark_mode; - painter.rect_filled(resp.rect, 4.0, if dark { Color32::from_rgb(30, 32, 36) } else { Color32::from_rgb(232, 235, 240) }); - let s = mesh.size(); - let (min, _) = mesh.bounds(); - let c = [min[0] + s[0] / 2.0, min[1] + s[1] / 2.0, min[2] + s[2] / 2.0]; - let cam = Camera { yaw, pitch, dist: 1.0, target: c }; - let (eye_dir, right, up, fwd) = cam_basis(&cam); - let view = sub3(eye_dir, c); // direction towards the viewer - let radius = (s[0] * s[0] + s[1] * s[1] + s[2] * s[2]).sqrt().max(1e-3) / 2.0; - let scale = size.x.min(size.y) * 0.45 / radius; - let center = resp.rect.center(); - let light = norm([0.35, 0.75, 0.55]); - let mut tris: Vec<(f32, [Pos2; 3], Color32)> = Vec::new(); - for t in &mesh.triangles { - let v = t.map(|i| mesh.vertices[i as usize]); - let n = norm(cross(sub3(v[1], v[0]), sub3(v[2], v[0]))); - if dot(n, view) <= 0.0 { - continue; - } - let pts = v.map(|q| { - let d = sub3(q, c); - center + vec2(dot(d, right), -dot(d, up)) * scale - }); - let depth = v.iter().map(|q| dot(sub3(*q, c), fwd)).sum::(); - let shade = 0.5 + 0.5 * dot(n, light).max(0.0); - let g = (190.0 * shade) as u8; - tris.push((depth, pts, Color32::from_rgb(g, g.saturating_add(6), g.saturating_add(14)))); - } - tris.sort_by(|a, b| b.0.total_cmp(&a.0)); - for (_, pts, color) in tris { - painter.add(Shape::convex_polygon(pts.to_vec(), color, Stroke::new(0.5, color))); - } - if resp.hovered() { - painter.text(resp.rect.left_bottom() + vec2(4.0, -4.0), egui::Align2::LEFT_BOTTOM, "drag to rotate", egui::FontId::proportional(10.0), Color32::GRAY); - } -} - fn apply_enclosure_part(ne: &mut NewEnclosure, db: &PartsDb) { if let Some(p) = db.get(&ne.part) { if p.width > 0.0 && p.height > 0.0 { @@ -1173,36 +1120,6 @@ fn wheel_delta(i: &egui::InputState) -> f32 { wheel } -fn sub3(a: [f32; 3], b: [f32; 3]) -> [f32; 3] { - [a[0] - b[0], a[1] - b[1], a[2] - b[2]] -} - -fn dot(a: [f32; 3], b: [f32; 3]) -> f32 { - a[0] * b[0] + a[1] * b[1] + a[2] * b[2] -} - -fn cross(a: [f32; 3], b: [f32; 3]) -> [f32; 3] { - [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]] -} - -fn norm(a: [f32; 3]) -> [f32; 3] { - let l = dot(a, a).sqrt().max(1e-6); - [a[0] / l, a[1] / l, a[2] / l] -} - -/// Eye position and camera axes (right, up, forward). -fn cam_basis(cam: &Camera) -> ([f32; 3], [f32; 3], [f32; 3], [f32; 3]) { - let eye = [ - cam.target[0] + cam.dist * cam.pitch.cos() * cam.yaw.sin(), - cam.target[1] + cam.dist * cam.pitch.sin(), - cam.target[2] + cam.dist * cam.pitch.cos() * cam.yaw.cos(), - ]; - let fwd = norm(sub3(cam.target, eye)); - let right = norm(cross(fwd, [0.0, 1.0, 0.0])); - let up = cross(right, fwd); - (eye, right, up, fwd) -} - fn point_in_convex(q: Pos2, pts: &[Pos2]) -> bool { let mut sign = 0.0f32; for i in 0..pts.len() { diff --git a/src/parts_server.rs b/src/parts_server.rs deleted file mode 100644 index 13f82098..00000000 --- a/src/parts_server.rs +++ /dev/null @@ -1,157 +0,0 @@ -//! Client for the global parts server (`openecraft-server`). Requests run in the -//! background (thread on desktop, fetch in the browser); results are collected with -//! [`ServerClient::poll`]. - -use crate::parts::{Part, PartsDb}; -use openecraft_parts::api::{self, ApiError, ImportResult, PartList, ServerInfo, API_PREFIX, DEFAULT_PORT}; -use serde::de::DeserializeOwned; -use std::sync::{Arc, Mutex}; - -enum Reply { - Info(Result), - Parts(Result), - Uploaded(Result), -} - -pub struct ServerClient { - pub url: String, - /// Access token for uploads (kept in memory only). - pub token: String, - pub info: Option, - pub status: String, - pending: usize, - inbox: Arc>>, -} - -impl Default for ServerClient { - fn default() -> Self { - ServerClient { - url: format!("http://127.0.0.1:{DEFAULT_PORT}"), - token: String::new(), - info: None, - status: String::new(), - pending: 0, - inbox: Arc::default(), - } - } -} - -/// Turns an HTTP result into the expected JSON type or a readable error. -pub fn decode(result: ehttp::Result) -> Result { - match result { - Err(e) => Err(format!("connection failed: {e}")), - Ok(resp) if resp.ok => serde_json::from_slice(&resp.bytes).map_err(|e| format!("unexpected answer: {e}")), - Ok(resp) => Err(serde_json::from_slice::(&resp.bytes) - .map(|e| e.error) - .unwrap_or_else(|_| format!("{} {}", resp.status, resp.status_text))), - } -} - -/// Adds / replaces downloaded parts in the local database. Returns (added, updated). -pub fn merge(db: &mut PartsDb, parts: Vec) -> (usize, usize) { - let (mut added, mut updated) = (0, 0); - for part in parts { - match db.parts.iter_mut().find(|p| p.number == part.number) { - Some(existing) if *existing != part => { - *existing = part; - updated += 1; - } - Some(_) => {} - None => { - db.parts.push(part); - added += 1; - } - } - } - db.sort(); - (added, updated) -} - -impl ServerClient { - pub fn busy(&self) -> bool { - self.pending > 0 - } - - fn send( - &mut self, - ctx: &egui::Context, - request: ehttp::Request, - wrap: impl 'static + Send + FnOnce(Result) -> Reply, - ) { - self.pending += 1; - let inbox = self.inbox.clone(); - let ctx = ctx.clone(); - ehttp::fetch(request, move |result| { - if let Ok(mut inbox) = inbox.lock() { - inbox.push(wrap(decode(result))); - } - ctx.request_repaint(); - }); - } - - /// GET /api/v1/info - pub fn check(&mut self, ctx: &egui::Context) { - self.status = "Connecting…".into(); - let req = ehttp::Request::get(api::url(&self.url, &format!("{API_PREFIX}/info"))); - self.send(ctx, req, Reply::Info); - } - - /// GET /api/v1/parts (all parts) - pub fn download(&mut self, ctx: &egui::Context) { - self.status = "Downloading parts…".into(); - let req = ehttp::Request::get(api::url(&self.url, &format!("{API_PREFIX}/parts"))); - self.send(ctx, req, Reply::Parts); - } - - /// POST /api/v1/import with the parts as JSON (needs the access token). - pub fn upload(&mut self, ctx: &egui::Context, parts: &[Part]) { - let body = serde_json::to_vec(parts).unwrap_or_default(); - let mut req = ehttp::Request::post(api::url(&self.url, &format!("{API_PREFIX}/import")), body); - req.headers.insert("Content-Type", "application/json"); - if !self.token.trim().is_empty() { - req.headers.insert("Authorization", format!("Bearer {}", self.token.trim())); - } - self.status = format!("Uploading {} parts…", parts.len()); - self.send(ctx, req, Reply::Uploaded); - } - - /// Applies finished requests. Returns a message for the status bar. - pub fn poll(&mut self, db: &mut PartsDb) -> Option { - let replies: Vec = self.inbox.lock().map(|mut i| std::mem::take(&mut *i)).unwrap_or_default(); - let mut message = None; - for reply in replies { - self.pending = self.pending.saturating_sub(1); - let text = match reply { - Reply::Info(Ok(info)) => { - let text = format!( - "Connected: {} {} – {} parts, revision {}, {}", - info.name, - info.version, - info.parts, - info.revision, - if info.writable { "uploads with token" } else { "read-only" } - ); - self.info = Some(info); - text - } - Reply::Parts(Ok(list)) => { - let n = list.parts.len(); - let (added, updated) = merge(db, list.parts); - format!("Downloaded {n} parts (revision {}): {added} new, {updated} updated", list.revision) - } - Reply::Uploaded(Ok(r)) => format!("Uploaded {} parts, server revision {}", r.imported, r.revision), - Reply::Info(Err(e)) => { - self.info = None; - format!("Parts server: {e}") - } - Reply::Parts(Err(e)) | Reply::Uploaded(Err(e)) => format!("Parts server: {e}"), - }; - self.status = text.clone(); - message = Some(text); - } - message - } -} - -#[cfg(test)] -mod tests; diff --git a/src/parts_ui.rs b/src/parts_ui.rs index 08f297b4..bbda5127 100644 --- a/src/parts_ui.rs +++ b/src/parts_ui.rs @@ -1,13 +1,12 @@ -//! Parts management window and part selection dialog. +//! Parts management window and part selection dialog. The part widgets are shared +//! with the parts manager (`openecraft_ui::part_editor`). -use crate::model::{natural_cmp, Project}; -use crate::editor::{EguiDraw, Palette}; -use crate::parts::{self, FnKind, FunctionTemplate, Model2d, Part, PartRef, PartsDb, TopGroup, PRODUCT_GROUPS}; -use crate::render::{Draw, Ink}; +use crate::model::Project; +use crate::parts::{self, Part, PartRef, PartsDb}; use crate::io::{Loaded, Purpose}; -use crate::parts_server::ServerClient; use egui::{vec2, Color32, RichText}; -use std::collections::BTreeMap; +use openecraft_ui::client::{Reply, ServerClient}; +use openecraft_ui::part_editor::{self as pe, EditorState, ModelKind, PartTab}; #[derive(Clone, Copy, PartialEq, Eq)] pub enum Source { @@ -15,22 +14,11 @@ pub enum Source { Project, } -#[derive(Clone, Copy, PartialEq, Eq)] -enum Tab { - General, - Commercial, - Technical, - Mounting, - Functions, - Accessories, - Graphics, -} - /// Requests the application has to carry out (file dialogs, messages). pub enum PartsAction { Import, /// Pick a 2D / 3D model file for the selected part. - ImportModel(Purpose), + ImportModel(ModelKind), Export { name: String, filter: (&'static str, &'static str), content: String }, Message(String), } @@ -44,7 +32,7 @@ pub struct PartsUi { source: Source, filter: String, selected: Option, - tab: Tab, + editor: EditorState, select: Option, sel_filter: String, sel_matching: bool, @@ -54,7 +42,6 @@ pub struct PartsUi { show_server: bool, /// Part (source, number) that receives the next imported model. model_target: Option<(Source, String)>, - model_scale: f32, } impl Default for PartsUi { @@ -64,7 +51,7 @@ impl Default for PartsUi { source: Source::Database, filter: String::new(), selected: None, - tab: Tab::General, + editor: EditorState::default(), select: None, sel_filter: String::new(), sel_matching: true, @@ -72,426 +59,36 @@ impl Default for PartsUi { server: ServerClient::default(), show_server: false, model_target: None, - model_scale: 25.4, } } } -/// Product group tree. Returns the part number that was double clicked. -fn part_tree(ui: &mut egui::Ui, id: &str, parts: &[&Part], filter: &str, selected: &mut Option) -> Option { - let mut tree: BTreeMap>>> = BTreeMap::new(); - for p in parts.iter().filter(|p| p.matches_text(filter)) { - let group = if p.group.is_empty() { "(no product group)" } else { p.group.as_str() }; - tree.entry(p.top_group).or_default().entry(group).or_default().entry(p.subgroup.as_str()).or_default().push(p); - } - let open = if filter.is_empty() { None } else { Some(true) }; - let mut activated = None; - let mut leaf = |ui: &mut egui::Ui, list: &mut Vec<&Part>| { - list.sort_by(|a, b| natural_cmp(&a.number, &b.number)); - for p in list.iter() { - let is_sel = selected.as_deref() == Some(p.number.as_str()); - let r = ui.selectable_label(is_sel, &p.number).on_hover_text(&p.description); - if r.clicked() { - *selected = Some(p.number.clone()); - } - if r.double_clicked() { - activated = Some(p.number.clone()); - } - } - }; - for (top, groups) in tree.iter_mut() { - egui::CollapsingHeader::new(RichText::new(top.title()).strong()) - .id_salt((id, top.title())) - .default_open(true) - .open(open) - .show(ui, |ui| { - for (group, subs) in groups.iter_mut() { - egui::CollapsingHeader::new(*group).id_salt((id, top.title(), *group)).open(open).show(ui, |ui| { - for (sub, list) in subs.iter_mut() { - if sub.is_empty() { - leaf(ui, list); - } else { - egui::CollapsingHeader::new(*sub) - .id_salt((id, top.title(), *group, *sub)) - .open(open) - .show(ui, |ui| leaf(ui, list)); - } - } - }); - } - }); - } - if tree.is_empty() { - ui.weak("No parts found."); - } - activated -} - -fn text_row(ui: &mut egui::Ui, label: &str, value: &mut String) { - ui.label(label); - ui.add(egui::TextEdit::singleline(value).desired_width(f32::INFINITY)); - ui.end_row(); -} - -fn num_row(ui: &mut egui::Ui, label: &str, value: &mut f32, suffix: &str) { - ui.label(label); - ui.add(egui::DragValue::new(value).speed(0.1).range(0.0..=1.0e7).suffix(suffix)); - ui.end_row(); -} - -/// Tabbed editor for one part. -/// Tabbed editor for one part. Returns a requested model import. -fn part_editor( - ui: &mut egui::Ui, - part: &mut Part, - tab: &mut Tab, - all_numbers: &[String], - duplicate: bool, - model_scale: &mut f32, -) -> Option { - let mut request = None; - ui.horizontal_wrapped(|ui| { - for (t, name) in [ - (Tab::General, "General"), - (Tab::Commercial, "Prices / other"), - (Tab::Technical, "Technical data"), - (Tab::Mounting, "Mounting data"), - (Tab::Functions, "Function template"), - (Tab::Accessories, "Accessories"), - (Tab::Graphics, "Graphics"), - ] { - ui.selectable_value(tab, t, name); - } - }); - ui.separator(); - egui::ScrollArea::vertical().id_salt("part_editor").auto_shrink([false, false]).show(ui, |ui| match tab { - Tab::General => { - egui::Grid::new("pg").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { - ui.label("Part number"); - ui.vertical(|ui| { - ui.add(egui::TextEdit::singleline(&mut part.number).desired_width(f32::INFINITY).font(egui::TextStyle::Monospace)); - if duplicate { - ui.colored_label(Color32::from_rgb(220, 60, 60), "Part number already exists"); - } - }); - ui.end_row(); - text_row(ui, "Type number", &mut part.type_number); - text_row(ui, "Order number", &mut part.order_number); - text_row(ui, "Manufacturer", &mut part.manufacturer); - text_row(ui, "Supplier", &mut part.supplier); - ui.label("Description"); - ui.add(egui::TextEdit::multiline(&mut part.description).desired_rows(2).desired_width(f32::INFINITY)); - ui.end_row(); - ui.label("Product top group"); - egui::ComboBox::from_id_salt("top").selected_text(part.top_group.title()).show_ui(ui, |ui| { - for t in TopGroup::ALL { - ui.selectable_value(&mut part.top_group, t, t.title()); - } - }); - ui.end_row(); - ui.label("Product group"); - ui.horizontal(|ui| { - ui.add(egui::TextEdit::singleline(&mut part.group).desired_width(200.0)); - egui::ComboBox::from_id_salt("grp").selected_text("…").width(24.0).show_ui(ui, |ui| { - for (g, _) in PRODUCT_GROUPS { - if ui.selectable_label(part.group == *g, *g).clicked() { - part.group = g.to_string(); - } - } - }); - }); - ui.end_row(); - ui.label("Product subgroup"); - ui.horizontal(|ui| { - ui.add(egui::TextEdit::singleline(&mut part.subgroup).desired_width(200.0)); - let subs = PRODUCT_GROUPS.iter().find(|(g, _)| *g == part.group).map(|(_, s)| *s).unwrap_or(&[]); - if !subs.is_empty() { - egui::ComboBox::from_id_salt("sub").selected_text("…").width(24.0).show_ui(ui, |ui| { - for s in subs { - if ui.selectable_label(part.subgroup == *s, *s).clicked() { - part.subgroup = s.to_string(); - } - } - }); - } - }); - ui.end_row(); - ui.label("Identifier"); - ui.add(egui::TextEdit::singleline(&mut part.identifier).desired_width(50.0)) - .on_hover_text("Identifying letter of devices using this part (K, Q, S …)"); - ui.end_row(); - ui.label("Note"); - ui.add(egui::TextEdit::multiline(&mut part.note).desired_rows(2).desired_width(f32::INFINITY)); - ui.end_row(); - }); - } - Tab::Commercial => { - egui::Grid::new("pc").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { - ui.label("Price"); - ui.horizontal(|ui| { - ui.add(egui::DragValue::new(&mut part.price).speed(0.1).range(0.0..=1.0e7).fixed_decimals(2)); - ui.add(egui::TextEdit::singleline(&mut part.currency).desired_width(40.0)); - }); - ui.end_row(); - ui.label("Price unit"); - ui.add(egui::DragValue::new(&mut part.price_unit).range(1..=100000)).on_hover_text("The price refers to this many units"); - ui.end_row(); - ui.label("Packaging quantity"); - ui.add(egui::DragValue::new(&mut part.pack_quantity).range(1..=100000)); - ui.end_row(); - ui.label("Quantity unit"); - ui.add(egui::TextEdit::singleline(&mut part.quantity_unit).desired_width(60.0)); - ui.end_row(); - text_row(ui, "Certificates", &mut part.certificates); - text_row(ui, "Datasheet (URL)", &mut part.datasheet); - }); - if part.datasheet.starts_with("http") { - ui.hyperlink_to("Open datasheet", &part.datasheet); - } - } - Tab::Technical => { - egui::Grid::new("pt").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { - text_row(ui, "Voltage", &mut part.voltage); - text_row(ui, "Current", &mut part.current); - text_row(ui, "Power", &mut part.power); - ui.label("Technical data"); - ui.add(egui::TextEdit::multiline(&mut part.tech_data).desired_rows(5).desired_width(f32::INFINITY)); - ui.end_row(); - }); - } - Tab::Mounting => { - egui::Grid::new("pm").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| { - num_row(ui, "Width", &mut part.width, " mm"); - num_row(ui, "Height", &mut part.height, " mm"); - num_row(ui, "Depth", &mut part.depth, " mm"); - num_row(ui, "Weight", &mut part.weight, " kg"); - text_row(ui, "Mounting", &mut part.mounting); - }); - } - Tab::Functions => { - ui.weak("Functions the part provides. Used for device selection, the contact image (reserve contacts), the project check and to assign connection designations. Designations are listed in symbol connection order, separated by blanks."); - ui.add_space(4.0); - let mut remove = None; - egui::Grid::new("pf").num_columns(4).striped(true).spacing([8.0, 4.0]).show(ui, |ui| { - ui.label(RichText::new("Function").strong()); - ui.label(RichText::new("Connection designations").strong()); - ui.label(RichText::new("Description").strong()); - ui.label(""); - ui.end_row(); - for (i, f) in part.functions.iter_mut().enumerate() { - egui::ComboBox::from_id_salt(("fk", i)).selected_text(f.kind.title()).width(170.0).show_ui(ui, |ui| { - for k in FnKind::ALL { - ui.selectable_value(&mut f.kind, k, k.title()); - } - }); - ui.add(egui::TextEdit::singleline(&mut f.pins).desired_width(140.0).font(egui::TextStyle::Monospace)); - ui.add(egui::TextEdit::singleline(&mut f.description).desired_width(160.0)); - if ui.small_button("🗑").clicked() { - remove = Some(i); - } - ui.end_row(); - } - }); - if let Some(i) = remove { - part.functions.remove(i); - } - if ui.button("➕ Add function").clicked() { - part.functions.push(FunctionTemplate::new(FnKind::No, "")); - } - } - Tab::Accessories => { - let mut remove = None; - for (i, a) in part.accessories.iter().enumerate() { - ui.horizontal(|ui| { - let known = all_numbers.contains(a); - ui.label(RichText::new(a).monospace().color(if known { ui.visuals().text_color() } else { Color32::from_rgb(220, 60, 60) })); - if ui.small_button("🗑").clicked() { - remove = Some(i); - } - }); - } - if let Some(i) = remove { - part.accessories.remove(i); - } - let mut add = None; - egui::ComboBox::from_id_salt("acc").selected_text("➕ Add accessory").width(240.0).show_ui(ui, |ui| { - for n in all_numbers { - if *n != part.number && !part.accessories.contains(n) && ui.selectable_label(false, n).clicked() { - add = Some(n.clone()); - } - } - }); - if let Some(n) = add { - part.accessories.push(n); - } - } - Tab::Graphics => request = graphics_tab(ui, part, model_scale), - }); - request -} - -/// 2D front view and 3D model of a part. -fn graphics_tab(ui: &mut egui::Ui, part: &mut Part, model_scale: &mut f32) -> Option { - let mut request = None; - ui.weak("The 2D front view is used in the panel front view and on mounting layout pages, the 3D model in the 3D panel view. Both are fitted to the mounting data (width × height × depth)."); - ui.add_space(4.0); - ui.label(RichText::new("2D front view").strong()); - ui.horizontal(|ui| { - model_2d_preview(ui, part.model_2d.as_ref(), vec2(180.0, 140.0)); - ui.vertical(|ui| { - match &part.model_2d { - Some(m) => ui.label(format!("{:.1} × {:.1} mm, {} elements", m.width, m.height, m.prims.len())), - None => ui.weak("none – a plain rectangle is drawn"), - }; - if ui.button("Import SVG…").clicked() { - request = Some(Purpose::Model2d); - } - if part.model_2d.is_some() && ui.button("🗑 Remove").clicked() { - part.model_2d = None; - } - }); - }); - ui.separator(); - ui.label(RichText::new("3D model").strong()); - ui.horizontal(|ui| { - match &part.model_3d { - Some(m) => crate::panel_ui::mesh_preview(ui, m, vec2(180.0, 160.0)), - None => { - ui.allocate_space(vec2(180.0, 40.0)); - } - } - ui.vertical(|ui| { - match &part.model_3d { - Some(m) => { - let s = m.size(); - ui.label(format!("{:.1} × {:.1} × {:.1} mm, {} triangles", s[0], s[1], s[2], m.triangles.len())); - } - None => { - ui.weak("none – a box of the mounting dimensions is drawn"); - } - } - if ui.button("Import STL / OBJ…").clicked() { - request = Some(Purpose::Model3d); - } - if part.model_3d.is_some() && ui.button("🗑 Remove").clicked() { - part.model_3d = None; - } - }); - }); - if let Some(m) = &mut part.model_3d { - ui.horizontal_wrapped(|ui| { - ui.label("Rotate 90°:"); - for (axis, label) in [(0, "X"), (1, "Y"), (2, "Z")] { - if ui.button(label).on_hover_text("Turn the model so that its front faces the viewer (+Z) and its top is +Y").clicked() { - m.rotate90(axis); - } - } - ui.separator(); - ui.label("Scale ×"); - ui.add(egui::DragValue::new(model_scale).speed(0.01).range(0.001..=10000.0)); - if ui.button("Apply").on_hover_text("e.g. 25.4 for models in inch, 1000 for models in metres").clicked() { - m.scale(*model_scale); - } - }); - let s = m.size(); - let differs = [(s[0], part.width), (s[1], part.height), (s[2], part.depth)].iter().any(|(a, b)| (a - b).abs() > 0.5); - if differs { - ui.colored_label( - Color32::from_rgb(220, 140, 0), - format!( - "The model ({:.1} × {:.1} × {:.1}) differs from the mounting data ({:.1} × {:.1} × {:.1}); it is stretched to the mounting data.", - s[0], s[1], s[2], part.width, part.height, part.depth - ), - ); - if ui.button("Use model size as mounting data").clicked() { - part.width = (s[0] * 10.0).round() / 10.0; - part.height = (s[1] * 10.0).round() / 10.0; - part.depth = (s[2] * 10.0).round() / 10.0; - } - } - } - request -} - -/// Scaled drawing of a 2D front view. -pub fn model_2d_preview(ui: &mut egui::Ui, model: Option<&Model2d>, size: egui::Vec2) { - let (resp, painter) = ui.allocate_painter(size, egui::Sense::hover()); - let pal = Palette::new(ui.visuals().dark_mode); - painter.rect_filled(resp.rect, 4.0, pal.paper); - let Some(m) = model.filter(|m| m.width > 0.0 && m.height > 0.0) else { - painter.text(resp.rect.center(), egui::Align2::CENTER_CENTER, "no 2D model", egui::FontId::proportional(12.0), pal.frame); - return; - }; - let zoom = ((size.x - 12.0) / m.width).min((size.y - 12.0) / m.height); - let origin = resp.rect.center() - vec2(m.width, m.height) * zoom / 2.0; - let mut d = EguiDraw { painter: &painter, origin, zoom, pal: &pal, force: None }; - d.rect(crate::geom::p(0.0, 0.0), crate::geom::p(m.width, m.height), 0.0, Ink::Fill, true); - crate::render::draw_prims_2d(&mut d, &m.prims, &|q| crate::geom::p(q[0], q[1]), 1.0, 0.15, Ink::Line); -} - -/// Read only summary used in the selection dialog. -fn part_summary(ui: &mut egui::Ui, p: &Part) { - ui.label(RichText::new(&p.number).monospace().strong()); - ui.label(&p.description); - egui::Grid::new("sum").num_columns(2).show(ui, |ui| { - for (k, v) in [ - ("Manufacturer", p.manufacturer.clone()), - ("Type number", p.type_number.clone()), - ("Order number", p.order_number.clone()), - ("Product group", format!("{} / {}", p.group, p.subgroup)), - ("Voltage / current", format!("{} {}", p.voltage, p.current)), - ("Price", format!("{:.2} {} / {} {}", p.price, p.currency, p.price_unit, p.quantity_unit)), - ("Dimensions", format!("{} × {} × {} mm", p.width, p.height, p.depth)), - ("Functions", p.template_summary()), - ("Accessories", p.accessories.join(", ")), - ] { - if !v.trim().is_empty() && v.trim() != "/" { - ui.label(RichText::new(k).weak()); - ui.label(v); - ui.end_row(); - } - } - }); -} - impl PartsUi { - /// Opens the management window with a part selected. /// Puts an imported 2D / 3D model into the part it was requested for. pub fn apply_model(&mut self, loaded: &Loaded, db: &mut PartsDb, prj: &mut Project) -> Result { + let Purpose::Model(kind) = loaded.purpose else { return Err("not a model file".into()) }; let (source, number) = self.model_target.take().ok_or("no part selected for the model")?; let list = match source { Source::Database => &mut db.parts, Source::Project => &mut prj.parts, }; let part = list.iter_mut().find(|p| p.number == number).ok_or(format!("part {number} not found"))?; - let file = crate::io::short_name(&loaded.name).to_string(); - match loaded.purpose { - Purpose::Model2d => { - let m = parts::parse_svg(&loaded.text())?; - let msg = format!("{file}: 2D front view with {} elements assigned to {number}", m.prims.len()); - part.model_2d = Some(m); - Ok(msg) - } - Purpose::Model3d => { - let m = parts::parse_mesh(&file, &loaded.bytes)?; - let s = m.size(); - // Parts without mounting data take the model size. - if part.width <= 0.0 || part.height <= 0.0 { - part.width = s[0]; - part.height = s[1]; - part.depth = s[2]; - } - let msg = format!("{file}: 3D model with {} triangles ({:.1} × {:.1} × {:.1} mm) assigned to {number}", m.triangles.len(), s[0], s[1], s[2]); - part.model_3d = Some(m); - Ok(msg) - } - _ => Err("not a model file".into()), - } + pe::apply_model(part, kind, &loaded.name, &loaded.bytes) } - /// Applies finished parts server requests (call every frame). + /// Applies finished parts server requests (call every frame). Downloaded parts + /// are merged into the database. pub fn poll_server(&mut self, db: &mut PartsDb) -> Option { - self.server.poll(db) + let mut message = None; + for reply in self.server.poll() { + if let Reply::Parts(Ok(list)) = reply { + let n = list.parts.len(); + let (added, updated) = db.merge(list.parts); + self.server.status = format!("Downloaded {n} parts (revision {}): {added} new, {updated} updated", list.revision); + } + message = Some(self.server.status.clone()); + } + message } /// Server URL, token and transfer buttons. @@ -535,12 +132,13 @@ impl PartsUi { } }); if !self.server.status.is_empty() { - let ok = !self.server.status.starts_with("Parts server:"); + let ok = !self.server.failed(); let color = if ok { ui.visuals().text_color() } else { Color32::from_rgb(220, 60, 60) }; ui.label(RichText::new(&self.server.status).color(color)); } } + /// Opens the management window with a part selected. pub fn show_part(&mut self, number: &str, in_project: bool) { self.open = true; self.source = if in_project { Source::Project } else { Source::Database }; @@ -573,7 +171,7 @@ impl PartsUi { let number = parts::unique_number(list, "NEW.PART"); list.push(Part { number: number.clone(), manufacturer: "NEW".into(), ..Default::default() }); self.selected = Some(number); - self.tab = Tab::General; + self.editor.tab = PartTab::General; } let sel_idx = self.selected.as_ref().and_then(|n| list.iter().position(|p| &p.number == n)); if ui.add_enabled(sel_idx.is_some(), egui::Button::new("⎘ Copy")).clicked() { @@ -668,7 +266,7 @@ impl PartsUi { ui.label(RichText::new(format!("{} parts", list.len())).weak()); egui::ScrollArea::vertical().id_salt("ptree").auto_shrink([false, false]).show(ui, |ui| { let refs: Vec<&Part> = list.iter().collect(); - part_tree(ui, "mgr", &refs, &self.filter, &mut self.selected); + pe::part_tree(ui, "mgr", &refs, &self.filter, &mut self.selected); }); }); ui.separator(); @@ -678,9 +276,9 @@ impl PartsUi { Some(i) => { let duplicate = list.iter().filter(|p| p.number == list[i].number).count() > 1; let before = list[i].number.clone(); - if let Some(purpose) = part_editor(ui, &mut list[i], &mut self.tab, &numbers, duplicate, &mut self.model_scale) { + if let Some(kind) = pe::part_editor(ui, &mut list[i], &mut self.editor, &numbers, duplicate) { self.model_target = Some((self.source, list[i].number.clone())); - actions.push(PartsAction::ImportModel(purpose)); + actions.push(PartsAction::ImportModel(kind)); } if list[i].number != before { self.selected = Some(list[i].number.clone()); @@ -732,7 +330,7 @@ impl PartsUi { ui.horizontal_top(|ui| { ui.allocate_ui_with_layout(vec2(300.0, h), egui::Layout::top_down(egui::Align::Min), |ui| { egui::ScrollArea::vertical().id_salt("seltree").auto_shrink([false, false]).show(ui, |ui| { - if let Some(n) = part_tree(ui, "sel", &shown, &self.sel_filter, &mut self.sel_part) { + if let Some(n) = pe::part_tree(ui, "sel", &shown, &self.sel_filter, &mut self.sel_part) { chosen = Some(n); } }); @@ -740,7 +338,7 @@ impl PartsUi { ui.separator(); ui.vertical(|ui| { match self.sel_part.as_ref().and_then(|n| all.iter().find(|p| &p.number == n)) { - Some(p) => part_summary(ui, p), + Some(p) => pe::part_summary(ui, p), None => { ui.weak("Select a part. Double click adds it to the device."); } diff --git a/src/parts_ui/tests.rs b/src/parts_ui/tests.rs index e26eecf6..12b9dbeb 100644 --- a/src/parts_ui/tests.rs +++ b/src/parts_ui/tests.rs @@ -1,8 +1,8 @@ use super::*; use crate::sample::demo_project; -fn loaded(purpose: Purpose, name: &str, bytes: &[u8]) -> Loaded { - Loaded { purpose, name: name.into(), bytes: bytes.to_vec() } +fn loaded(kind: ModelKind, name: &str, bytes: &[u8]) -> Loaded { + Loaded { purpose: Purpose::Model(kind), name: name.into(), bytes: bytes.to_vec() } } #[test] @@ -12,25 +12,23 @@ fn imported_models_go_to_the_requested_part() { let mut ui = PartsUi::default(); let svg = r#""#; // Without a requested target nothing happens. - assert!(ui.apply_model(&loaded(Purpose::Model2d, "front.svg", svg.as_bytes()), &mut db, &mut prj).is_err()); + assert!(ui.apply_model(&loaded(ModelKind::Front2d, "front.svg", svg.as_bytes()), &mut db, &mut prj).is_err()); ui.model_target = Some((Source::Database, "GEN.CT-9A-24DC".into())); - ui.apply_model(&loaded(Purpose::Model2d, "front.svg", svg.as_bytes()), &mut db, &mut prj).unwrap(); + ui.apply_model(&loaded(ModelKind::Front2d, "front.svg", svg.as_bytes()), &mut db, &mut prj).unwrap(); assert_eq!(db.get("GEN.CT-9A-24DC").unwrap().model_2d.as_ref().unwrap().prims.len(), 1); assert!(ui.model_target.is_none()); - // 3D into a project part without mounting data: it takes the model size. + // Project parts are found as well. let obj = "v 0 0 0\nv 30 0 0\nv 30 20 0\nv 0 20 10\nf 1 2 3\nf 1 3 4\n"; prj.parts.push(Part { number: "NEW.PART".into(), ..Default::default() }); ui.model_target = Some((Source::Project, "NEW.PART".into())); - let msg = ui.apply_model(&loaded(Purpose::Model3d, "C:/models/part.obj", obj.as_bytes()), &mut db, &mut prj).unwrap(); - assert!(msg.contains("part.obj"), "{msg}"); + ui.apply_model(&loaded(ModelKind::Mesh3d, "C:/models/part.obj", obj.as_bytes()), &mut db, &mut prj).unwrap(); let part = prj.parts.iter().find(|p| p.number == "NEW.PART").unwrap(); - assert_eq!((part.width, part.height, part.depth), (30.0, 20.0, 10.0)); assert_eq!(part.model_3d.as_ref().unwrap().triangles.len(), 2); - // Broken files are reported, the part keeps its model. + // Other files are rejected. ui.model_target = Some((Source::Project, "NEW.PART".into())); - assert!(ui.apply_model(&loaded(Purpose::Model3d, "bad.stl", b"garbage"), &mut db, &mut prj).is_err()); - assert!(prj.parts.iter().find(|p| p.number == "NEW.PART").unwrap().model_3d.is_some()); + let project_file = Loaded { purpose: Purpose::Project, name: "x.oec".into(), bytes: Vec::new() }; + assert!(ui.apply_model(&project_file, &mut db, &mut prj).is_err()); }