From 2ac8e530b8fb9ca4fa073e1e25a4230a83d99c5d Mon Sep 17 00:00:00 2001 From: Johannes Hofmann Date: Tue, 27 Oct 2026 10:48:03 +0100 Subject: web: W1 scaffold — Yew app with image display, pan and zoom MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit First milestone of wasm-plan.md: - new crate gipfel-web: Yew 0.21 (csr), canvas 2D viewport - file input + drag-and-drop; browser-native decode via createImageBitmap (faster than image-crate decode in wasm, GPU-backed blitting) - pan (pointer drag with capture, touch-ready) and cursor-anchored wheel zoom, DPR-aware canvas sizing, fit-to-window - dark sidebar shell: open/fit buttons, status line - Trunk.toml + www/ (index.html, style.css); README with dev setup Verified: cargo check clean (native and wasm32-unknown-unknown), release wasm builds (5.3 MB pre-wasm-opt), all 38 native tests pass. Runtime behavior to be confirmed with trunk serve on a desktop browser. --- crates/gipfel-web/Cargo.toml | 37 +++++++ crates/gipfel-web/README.md | 46 +++++++++ crates/gipfel-web/Trunk.toml | 2 + crates/gipfel-web/src/app.rs | 193 +++++++++++++++++++++++++++++++++++ crates/gipfel-web/src/bridge.rs | 45 ++++++++ crates/gipfel-web/src/canvas_view.rs | 148 +++++++++++++++++++++++++++ crates/gipfel-web/src/main.rs | 7 ++ crates/gipfel-web/www/index.html | 11 ++ crates/gipfel-web/www/style.css | 77 ++++++++++++++ 9 files changed, 566 insertions(+) create mode 100644 crates/gipfel-web/Cargo.toml create mode 100644 crates/gipfel-web/README.md create mode 100644 crates/gipfel-web/Trunk.toml create mode 100644 crates/gipfel-web/src/app.rs create mode 100644 crates/gipfel-web/src/bridge.rs create mode 100644 crates/gipfel-web/src/canvas_view.rs create mode 100644 crates/gipfel-web/src/main.rs create mode 100644 crates/gipfel-web/www/index.html create mode 100644 crates/gipfel-web/www/style.css (limited to 'crates') diff --git a/crates/gipfel-web/Cargo.toml b/crates/gipfel-web/Cargo.toml new file mode 100644 index 0000000..b53fdaa --- /dev/null +++ b/crates/gipfel-web/Cargo.toml @@ -0,0 +1,37 @@ +[package] +name = "gipfel-web" +version.workspace = true +edition.workspace = true +license.workspace = true +description = "gipfel web — browser front end (WASM)" + +[dependencies] +gipfel-core = { path = "../gipfel-core" } +js-sys = "0.3" +wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" +yew = { version = "0.21", features = ["csr"] } + +[dependencies.web-sys] +version = "0.3" +features = [ + "Blob", + "CanvasRenderingContext2d", + "DataTransfer", + "Document", + "DomRect", + "DragEvent", + "Element", + "Event", + "EventTarget", + "File", + "FileList", + "HtmlCanvasElement", + "HtmlElement", + "HtmlInputElement", + "ImageBitmap", + "MouseEvent", + "PointerEvent", + "Window", + "WheelEvent", +] diff --git a/crates/gipfel-web/README.md b/crates/gipfel-web/README.md new file mode 100644 index 0000000..2442e67 --- /dev/null +++ b/crates/gipfel-web/README.md @@ -0,0 +1,46 @@ +# gipfel-web + +Browser front end for gipfel (WASM, Yew + canvas 2D). See +[`/wasm-plan.md`](../../wasm-plan.md) for the overall plan and milestones. + +**Status: W1 (scaffold + image display) done** — open/drag-drop a JPEG, +pan (drag) and zoom (wheel, cursor-anchored). Peak identification, +fitting and saving arrive in W2/W3. + +## Development + +Prerequisites: [rustup](https://rustup.rs) and trunk: + +```sh +cargo install --locked trunk +``` + +Serve with hot reload: + +```sh +cd crates/gipfel-web +trunk serve --port 8090 # then open http://localhost:8090 +``` + +Release build (static output in `dist/`, serveable by any web server): + +```sh +trunk build --release +``` + +## Layout + +| File | Purpose | +|---|---| +| `src/main.rs` | entry point | +| `src/app.rs` | root component: sidebar, file loading, state | +| `src/canvas_view.rs` | viewport canvas: bitmap blit, pan/zoom | +| `src/bridge.rs` | JS glue: image decode, blob read, canvas ctx | +| `www/` | index.html, style.css (trunk assets) | + +## Notes + +- The base image is decoded by the browser (`createImageBitmap`), not + by the `image` crate — faster decode and GPU-backed blitting. +- The crate compiles natively (`cargo check -p gipfel-web`) so it can + be checked in CI without a wasm toolchain; runtime is wasm-only. diff --git a/crates/gipfel-web/Trunk.toml b/crates/gipfel-web/Trunk.toml new file mode 100644 index 0000000..1772684 --- /dev/null +++ b/crates/gipfel-web/Trunk.toml @@ -0,0 +1,2 @@ +[build] +target = "www/index.html" diff --git a/crates/gipfel-web/src/app.rs b/crates/gipfel-web/src/app.rs new file mode 100644 index 0000000..9e8c543 --- /dev/null +++ b/crates/gipfel-web/src/app.rs @@ -0,0 +1,193 @@ +//! Root component: sidebar (open/fit/status) + viewport canvas. +//! File loading: `` and drag-and-drop, decoded by the +//! browser into an ImageBitmap (see `bridge`). + +use std::rc::Rc; +use wasm_bindgen::closure::Closure; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::spawn_local; +use web_sys::{DragEvent, Event, HtmlCanvasElement, HtmlInputElement, MouseEvent}; +use yew::prelude::*; + +use crate::bridge; +use crate::canvas_view::{CanvasView, ViewCallbacks, ViewState}; + +#[function_component(App)] +pub fn app() -> Html { + let bitmap = use_state(|| None::); + let view = use_state(ViewState::default); + let status = use_state(|| "No image loaded.".to_string()); + let tick = use_state(|| 0u32); + let canvas_ref = use_node_ref(); + let file_ref = use_node_ref(); + + // force a redraw when the window is resized so the canvas backing + // store tracks its CSS size (listener lives as long as the app) + { + let tick = tick.clone(); + use_effect_with((), move |_| { + let closure = Closure::wrap(Box::new(move || tick.set(*tick + 1)) as Box); + let _ = bridge::window() + .add_event_listener_with_callback("resize", closure.as_ref().unchecked_ref()); + // the listener is never removed (app lifetime); leak the closure + std::mem::forget(closure); + }); + } + + // Fit the current bitmap into the canvas, centered. + let fit = { + let bitmap = bitmap.clone(); + let view = view.clone(); + let canvas_ref = canvas_ref.clone(); + Callback::from(move |_: MouseEvent| { + let Some(bmp) = bitmap.as_ref() else { return }; + let (cw, ch) = canvas_ref + .cast::() + .map(|c| (c.client_width() as f64, c.client_height() as f64)) + .unwrap_or((800.0, 600.0)); + let (iw, ih) = (bmp.width() as f64, bmp.height() as f64); + if iw <= 0.0 || ih <= 0.0 || cw <= 0.0 || ch <= 0.0 { + return; + } + let scale = (cw / iw).min(ch / ih); + view.set(ViewState { + scale, + ox: (cw - iw * scale) / 2.0, + oy: (ch - ih * scale) / 2.0, + }); + }) + }; + + // Decode dropped/selected bytes and display them, fitting to view. + let load_bytes = { + let bitmap = bitmap.clone(); + let status = status.clone(); + let fit = fit.clone(); + Callback::from(move |(bytes, name): (Vec, String)| { + let (bitmap, status, fit) = (bitmap.clone(), status.clone(), fit.clone()); + spawn_local(async move { + match bridge::decode_bitmap(&bytes).await { + Ok(bmp) => { + status.set(format!( + "{name} — {}×{} px", + bmp.width(), + bmp.height() + )); + bitmap.set(Some(bmp)); + fit.emit(MouseEvent::new("fit").unwrap()); + } + Err(e) => status.set(format!("Failed to load {name}: {e}")), + } + }); + }) + }; + + let read_file = { + let load_bytes = load_bytes.clone(); + let status = status.clone(); + Rc::new(move |file: web_sys::File| { + let (load_bytes, status) = (load_bytes.clone(), status.clone()); + let name = file.name(); + spawn_local(async move { + match bridge::read_blob(&file).await { + Ok(bytes) => load_bytes.emit((bytes, name)), + Err(e) => status.set(format!("Failed to read {name}: {e}")), + } + }); + }) + }; + + let on_file_change = { + let read_file = read_file.clone(); + Callback::from(move |e: Event| { + let input: HtmlInputElement = e.target_unchecked_into(); + if let Some(file) = input.files().and_then(|fl| fl.item(0)) { + read_file(file); + } + }) + }; + + let on_drop = { + let read_file = read_file.clone(); + let status = status.clone(); + Callback::from(move |e: DragEvent| { + e.prevent_default(); + match e.data_transfer().and_then(|dt| dt.files()).and_then(|fl| fl.item(0)) { + Some(file) => read_file(file), + None => status.set("Dropped item was not a file.".to_string()), + } + }) + }; + let on_dragover = Callback::from(|e: DragEvent| e.prevent_default()); + + let open_picker = { + let file_ref = file_ref.clone(); + Callback::from(move |_: MouseEvent| { + if let Some(input) = file_ref.cast::() { + input.click(); + } + }) + }; + + let callbacks = ViewCallbacks { + pan: { + let view = view.clone(); + Callback::from(move |(dx, dy): (f64, f64)| { + let mut v = (*view).clone(); + v.ox += dx; + v.oy += dy; + view.set(v); + }) + }, + zoom: { + let view = view.clone(); + Callback::from(move |(cx, cy, factor): (f64, f64, f64)| { + let v = &*view; + let ns = (v.scale * factor).clamp(0.02, 64.0); + let k = ns / v.scale; + view.set(ViewState { + scale: ns, + ox: cx - (cx - v.ox) * k, + oy: cy - (cy - v.oy) * k, + }); + }) + }, + }; + + let zoom_pct = (view.scale * 100.0).round(); + + html! { +
+ +
+ +
+
+ } +} diff --git a/crates/gipfel-web/src/bridge.rs b/crates/gipfel-web/src/bridge.rs new file mode 100644 index 0000000..1353279 --- /dev/null +++ b/crates/gipfel-web/src/bridge.rs @@ -0,0 +1,45 @@ +//! Small JS helpers: window access, browser-native image decode, blob +//! reads, canvas context — the hand-written JS boundary of the app. + +use js_sys::Uint8Array; +use wasm_bindgen::JsCast; +use wasm_bindgen_futures::JsFuture; +use web_sys::{Blob, CanvasRenderingContext2d, HtmlCanvasElement, ImageBitmap, Window}; + +pub fn window() -> Window { + web_sys::window().expect("no global window") +} + +/// Decode image bytes into a browser-native (GPU-backed) bitmap. +/// The browser does the JPEG decode and keeps the pixels where canvas +/// blitting is fast — cheaper than any pure-Rust path in wasm. +pub async fn decode_bitmap(bytes: &[u8]) -> Result { + let array = js_sys::Array::new(); + array.push(&Uint8Array::from(bytes).buffer()); + let blob = Blob::new_with_u8_array_sequence(&array).map_err(|_| "blob failed".to_string())?; + let promise = window() + .create_image_bitmap_with_blob(&blob) + .map_err(|_| "createImageBitmap failed".to_string())?; + let value = JsFuture::from(promise) + .await + .map_err(|e| format!("decode failed: {e:?}"))?; + value + .dyn_into::() + .map_err(|_| "decode produced non-bitmap".to_string()) +} + +/// Read a File/Blob fully into memory. +pub async fn read_blob(blob: &Blob) -> Result, String> { + let buf = JsFuture::from(blob.array_buffer()) + .await + .map_err(|e| format!("read failed: {e:?}"))?; + Ok(Uint8Array::new(&buf).to_vec()) +} + +pub fn ctx2d(canvas: &HtmlCanvasElement) -> Option { + canvas + .get_context("2d") + .ok() + .flatten() + .and_then(|c| c.dyn_into::().ok()) +} diff --git a/crates/gipfel-web/src/canvas_view.rs b/crates/gipfel-web/src/canvas_view.rs new file mode 100644 index 0000000..87b89d9 --- /dev/null +++ b/crates/gipfel-web/src/canvas_view.rs @@ -0,0 +1,148 @@ +//! Viewport canvas: browser-native bitmap blitted with a pan/zoom +//! transform. Overlay drawing (markers, labels, compass) is added in W3. + +use web_sys::{HtmlCanvasElement, ImageBitmap, PointerEvent, WheelEvent};use yew::prelude::*; + +use crate::bridge; + +/// Image -> screen transform: `screen = img * scale + (ox, oy)`. +/// Same convention as the desktop viewport widget. +#[derive(Clone, Debug, PartialEq, Default)] +pub struct ViewState { + pub scale: f64, + pub ox: f64, + pub oy: f64, +} + +#[derive(Clone, PartialEq)] +pub struct ViewCallbacks { + pub pan: Callback<(f64, f64)>, + /// (cursor x, cursor y, factor) — zoom anchored at the cursor. + pub zoom: Callback<(f64, f64, f64)>, +} + +#[derive(Properties, PartialEq)] +pub struct Props { + pub bitmap: Option, + pub view: ViewState, + pub callbacks: ViewCallbacks, + pub canvas_ref: NodeRef, + /// bumped on window resize to force a redraw + pub tick: u32, +} + +#[function_component(CanvasView)] +pub fn canvas_view(props: &Props) -> Html { + let dragging = use_mut_ref(|| false); + let last = use_mut_ref(|| (0.0f64, 0.0f64)); + + // redraw on every view/bitmap change and on resize ticks + { + let bitmap = props.bitmap.clone(); + let view = props.view.clone(); + let canvas_ref = props.canvas_ref.clone(); + use_effect_with((bitmap, view, props.tick), move |(bitmap, view, _tick)| { + let Some(canvas) = canvas_ref.cast::() else { + return; + }; + let Some(ctx) = bridge::ctx2d(&canvas) else { + return; + }; + let dpr = bridge::window().device_pixel_ratio(); + let cw = canvas.client_width() as f64; + let ch = canvas.client_height() as f64; + // keep the backing store in sync with the CSS size + let bw = (cw * dpr).max(1.0) as u32; + let bh = (ch * dpr).max(1.0) as u32; + if canvas.width() != bw || canvas.height() != bh { + canvas.set_width(bw); + canvas.set_height(bh); + } + let _ = ctx.set_transform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); + // web-sys 0.3: set_fill_style takes a JsValue (deprecated alias) + #[allow(deprecated)] + ctx.set_fill_style(&wasm_bindgen::JsValue::from_str("#101014")); + ctx.fill_rect(0.0, 0.0, canvas.width() as f64, canvas.height() as f64); + if let Some(bitmap) = bitmap { + let _ = ctx.set_transform( + dpr * view.scale, + 0.0, + 0.0, + dpr * view.scale, + dpr * view.ox, + dpr * view.oy, + ); + let _ = ctx.draw_image_with_image_bitmap(bitmap, 0.0, 0.0); + } + }); + } + + let on_pointerdown = { + let dragging = dragging.clone(); + let last = last.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + e.prevent_default(); + if let Some(c) = canvas_ref.cast::() { + let _ = c.set_pointer_capture(e.pointer_id()); + } + *dragging.borrow_mut() = true; + *last.borrow_mut() = (e.client_x() as f64, e.client_y() as f64); + }) + }; + let on_pointermove = { + let dragging = dragging.clone(); + let last = last.clone(); + let pan = props.callbacks.pan.clone(); + Callback::from(move |e: PointerEvent| { + if !*dragging.borrow() { + return; + } + let cur = (e.client_x() as f64, e.client_y() as f64); + let prev = *last.borrow(); + *last.borrow_mut() = cur; + pan.emit((cur.0 - prev.0, cur.1 - prev.1)); + }) + }; + let on_pointerup = { + let dragging = dragging.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: PointerEvent| { + *dragging.borrow_mut() = false; + if let Some(c) = canvas_ref.cast::() { + let _ = c.release_pointer_capture(e.pointer_id()); + } + }) + }; + let on_wheel = { + let zoom = props.callbacks.zoom.clone(); + let canvas_ref = props.canvas_ref.clone(); + Callback::from(move |e: WheelEvent| { + e.prevent_default(); + let cx = e.client_x() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().left()) + .unwrap_or(0.0); + let cy = e.client_y() as f64 + - canvas_ref + .cast::() + .map(|c| c.get_bounding_client_rect().top()) + .unwrap_or(0.0); + let factor = 1.0015f64.powf(-(e.delta_y() as f64)); + zoom.emit((cx, cy, factor)); + }) + }; + + html! { + + } +} diff --git a/crates/gipfel-web/src/main.rs b/crates/gipfel-web/src/main.rs new file mode 100644 index 0000000..6a3e4d4 --- /dev/null +++ b/crates/gipfel-web/src/main.rs @@ -0,0 +1,7 @@ +mod app; +mod bridge; +mod canvas_view; + +fn main() { + yew::Renderer::::new().render(); +} diff --git a/crates/gipfel-web/www/index.html b/crates/gipfel-web/www/index.html new file mode 100644 index 0000000..c601fee --- /dev/null +++ b/crates/gipfel-web/www/index.html @@ -0,0 +1,11 @@ + + + + + + gipfel web + + + + + diff --git a/crates/gipfel-web/www/style.css b/crates/gipfel-web/www/style.css new file mode 100644 index 0000000..5ea080d --- /dev/null +++ b/crates/gipfel-web/www/style.css @@ -0,0 +1,77 @@ +* { + box-sizing: border-box; +} +html, +body { + margin: 0; + height: 100%; + font-family: system-ui, sans-serif; +} +.app { + display: flex; + height: 100vh; + background: #101014; + color: #e8e8ea; +} +.sidebar { + width: 300px; + padding: 16px; + background: #1a1a20; + border-right: 1px solid #2c2c34; + display: flex; + flex-direction: column; + gap: 8px; + overflow-y: auto; +} +.sidebar h1 { + margin: 0; + font-size: 22px; +} +.tag { + margin: 0 0 12px; + color: #8a8a94; + font-size: 12px; + text-transform: uppercase; + letter-spacing: 1px; +} +.sidebar button { + padding: 8px 12px; + background: #3b6fd4; + color: #fff; + border: 0; + border-radius: 6px; + font-size: 14px; + cursor: pointer; +} +.sidebar button:hover { + background: #4a7ee4; +} +.status { + font-size: 13px; + color: #c8c8d0; + word-break: break-word; +} +.hint { + font-size: 12px; + color: #8a8a94; +} +.dim { + opacity: 0.6; +} +.hidden-file { + display: none; +} +.main { + flex: 1; + position: relative; + min-width: 0; +} +canvas.viewport { + position: absolute; + inset: 0; + width: 100%; + height: 100%; + display: block; + touch-action: none; + cursor: grab; +} -- cgit v1.2.3