summaryrefslogtreecommitdiff
path: root/crates/gipfel-web/src
diff options
context:
space:
mode:
authorJohannes Hofmann <Johannes.Hofmann@gmx.de>2026-10-27 10:48:03 +0100
committerJohannes Hofmann <Johannes.Hofmann@gmx.de>2026-10-27 10:48:03 +0100
commit2ac8e530b8fb9ca4fa073e1e25a4230a83d99c5d (patch)
tree573b6745d9c7d8d3cb884c955009f6deaadedd87 /crates/gipfel-web/src
parent236fcded5e7302c4b99f4626b4e8cbc35896ceee (diff)
web: W1 scaffold — Yew app with image display, pan and zoom
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.
Diffstat (limited to 'crates/gipfel-web/src')
-rw-r--r--crates/gipfel-web/src/app.rs193
-rw-r--r--crates/gipfel-web/src/bridge.rs45
-rw-r--r--crates/gipfel-web/src/canvas_view.rs148
-rw-r--r--crates/gipfel-web/src/main.rs7
4 files changed, 393 insertions, 0 deletions
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: `<input type=file>` 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::<web_sys::ImageBitmap>);
+ 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<dyn Fn()>);
+ 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::<HtmlCanvasElement>()
+ .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<u8>, 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::<HtmlInputElement>() {
+ 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! {
+ <div class="app" ondrop={on_drop} ondragover={on_dragover}>
+ <aside class="sidebar">
+ <h1>{ "gipfel" }</h1>
+ <p class="tag">{ "web · W1 scaffold" }</p>
+ <button onclick={open_picker}>{ "Open image…" }</button>
+ <button onclick={fit} disabled={bitmap.is_none()}>{ "Fit to window" }</button>
+ <input
+ type="file"
+ ref={file_ref}
+ accept="image/jpeg,image/png"
+ class="hidden-file"
+ onchange={on_file_change}
+ />
+ <p class="status">{ (*status).clone() }</p>
+ if bitmap.is_some() {
+ <p class="hint">{ format!("zoom: {zoom_pct:.0} %") }</p>
+ }
+ <p class="hint">{ "Drag to pan, wheel to zoom. Drop a JPEG anywhere." }</p>
+ <p class="hint dim">
+ { "Peak identification, fitting and saving arrive in W2/W3." }
+ </p>
+ </aside>
+ <main class="main">
+ <CanvasView
+ bitmap={bitmap.as_ref().cloned()}
+ view={(*view).clone()}
+ {callbacks}
+ canvas_ref={canvas_ref.clone()}
+ tick={*tick}
+ />
+ </main>
+ </div>
+ }
+}
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<ImageBitmap, String> {
+ 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::<ImageBitmap>()
+ .map_err(|_| "decode produced non-bitmap".to_string())
+}
+
+/// Read a File/Blob fully into memory.
+pub async fn read_blob(blob: &Blob) -> Result<Vec<u8>, 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<CanvasRenderingContext2d> {
+ canvas
+ .get_context("2d")
+ .ok()
+ .flatten()
+ .and_then(|c| c.dyn_into::<CanvasRenderingContext2d>().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<ImageBitmap>,
+ 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::<HtmlCanvasElement>() 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::<HtmlCanvasElement>() {
+ 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::<HtmlCanvasElement>() {
+ 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::<HtmlCanvasElement>()
+ .map(|c| c.get_bounding_client_rect().left())
+ .unwrap_or(0.0);
+ let cy = e.client_y() as f64
+ - canvas_ref
+ .cast::<HtmlCanvasElement>()
+ .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! {
+ <canvas
+ ref={props.canvas_ref.clone()}
+ class="viewport"
+ onpointerdown={on_pointerdown}
+ onpointermove={on_pointermove}
+ onpointerup={on_pointerup.clone()}
+ onpointercancel={on_pointerup}
+ onwheel={on_wheel}
+ />
+ }
+}
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::<app::App>::new().render();
+}