Skip to main content

gallery/
gallery.rs

1//! Localhost gallery. Hover fetches a **tooltip PNG** (host contract).
2//!
3//! ```text
4//! cargo run --example gallery
5//! # open http://127.0.0.1:3939/
6//! ```
7//!
8//! Std only. Binds 3939, then 3940..=3950.
9
10use std::collections::BTreeMap;
11use std::io::{Read, Write};
12use std::net::{TcpListener, TcpStream};
13
14use sealed_surface::{
15    AccessTier, Appearance, CellValue, Column, FrameRequest, Grid, LicenseLens, Pointer, Row,
16    Series, SeriesLayout, SeriesPoint, Surface, SurfaceMode, TreeLayout, TreeNode, Viewport,
17};
18
19#[derive(Clone, Copy)]
20enum Kind {
21    Table,
22    Series,
23    Scatter,
24    Tree,
25}
26
27struct Spec {
28    title: &'static str,
29    blurb: &'static str,
30    kind: Kind,
31    appearance: Appearance,
32    mode: SurfaceMode,
33    lens: LicenseLens,
34    viewport: Viewport,
35    caption: Option<&'static str>,
36    widths: Option<Vec<u32>>,
37}
38
39struct Gallery {
40    grid: Grid,
41    series: SeriesLayout,
42    scatter: SeriesLayout,
43    tree: TreeLayout,
44    specs: BTreeMap<&'static str, Spec>,
45}
46
47fn main() -> Result<(), Box<dyn std::error::Error>> {
48    let gallery = Gallery::build()?;
49    let listener = bind_listener()?;
50    let addr = listener.local_addr()?;
51    println!("sealed-surface gallery → http://{addr}/");
52    println!("hover a surface: tooltip is image/png, not JSON");
53    println!("Ctrl-C to stop");
54    for incoming in listener.incoming() {
55        let mut stream = match incoming {
56            Ok(s) => s,
57            Err(_) => continue,
58        };
59        let mut buf = [0u8; 4096];
60        let n = stream.read(&mut buf).unwrap_or(0);
61        let req = std::str::from_utf8(&buf[..n]).unwrap_or("");
62        let line = req.lines().next().unwrap_or("");
63        let raw = line.split_whitespace().nth(1).unwrap_or("/");
64        let (path, query) = split_query(raw);
65        route(&gallery, &mut stream, path, query);
66    }
67    Ok(())
68}
69
70fn split_query(raw: &str) -> (&str, &str) {
71    match raw.find('?') {
72        Some(i) => (&raw[..i], &raw[i + 1..]),
73        None => (raw, ""),
74    }
75}
76
77fn query_u32(query: &str, key: &str) -> Option<u32> {
78    for pair in query.split('&') {
79        let mut it = pair.splitn(2, '=');
80        if it.next() == Some(key) {
81            return it.next().and_then(|v| v.parse().ok());
82        }
83    }
84    None
85}
86
87fn bind_listener() -> Result<TcpListener, Box<dyn std::error::Error>> {
88    for p in [3939u16].into_iter().chain(3940..=3950) {
89        if let Ok(l) = TcpListener::bind(("127.0.0.1", p)) {
90            return Ok(l);
91        }
92    }
93    Err("no free port 3939–3950".into())
94}
95
96fn route(g: &Gallery, stream: &mut TcpStream, path: &str, query: &str) {
97    if path == "/" || path == "/index.html" {
98        let html = index_html(g);
99        respond(stream, "text/html; charset=utf-8", html.as_bytes());
100        return;
101    }
102    if let Some(rest) = path.strip_prefix("/i/") {
103        let pointer = match (query_u32(query, "x"), query_u32(query, "y")) {
104            (Some(x), Some(y)) => Some(Pointer::new(x, y)),
105            _ => None,
106        };
107        if let Some(id) = rest.strip_suffix("/tip.png") {
108            match g.tooltip(id, pointer) {
109                Ok(Some(png)) => respond(stream, "image/png", &png),
110                Ok(None) => respond_status(stream, 204, b""),
111                Err(_) => respond_status(stream, 500, b"render"),
112            }
113            return;
114        }
115        let id = rest.strip_suffix(".png").unwrap_or(rest);
116        match g.frame_png(id, pointer) {
117            Ok(png) => respond(stream, "image/png", &png),
118            Err(_) => respond_status(stream, 404, b"not found"),
119        }
120        return;
121    }
122    respond_status(stream, 404, b"not found");
123}
124
125fn respond(stream: &mut TcpStream, ctype: &str, body: &[u8]) {
126    let hdr = format!(
127        "HTTP/1.1 200 OK\r\nContent-Type: {ctype}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n",
128        body.len()
129    );
130    let _ = stream.write_all(hdr.as_bytes());
131    let _ = stream.write_all(body);
132    let _ = stream.flush();
133}
134
135fn respond_status(stream: &mut TcpStream, code: u16, body: &[u8]) {
136    let reason = if code == 204 { "No Content" } else { "X" };
137    let hdr = format!(
138        "HTTP/1.1 {code} {reason}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n",
139        body.len()
140    );
141    let _ = stream.write_all(hdr.as_bytes());
142    let _ = stream.write_all(body);
143    let _ = stream.flush();
144}
145
146fn index_html(g: &Gallery) -> String {
147    let mut body = String::from(
148        r#"<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"/>
149<title>sealed-surface gallery</title>
150<style>
151:root { color-scheme: dark; }
152body { margin:0; font: 15px/1.4 ui-sans-serif, system-ui, sans-serif;
153  background:#0e1116; color:#f2f6fc; }
154h1 { font-size:1.4rem; font-weight:600; padding:24px 24px 8px; }
155.sub { padding:0 24px 24px; color:#8a93a4; max-width:760px; }
156.grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(420px,1fr));
157  gap:20px; padding:0 24px 48px; }
158figure { margin:0; background:#161b24; border:1px solid #2a3140; border-radius:10px;
159  overflow:hidden; }
160.stage { position:relative; background:#0e1116; cursor:crosshair; overflow:auto; }
161figcaption { padding:10px 12px 14px; }
162figcaption strong { display:block; margin-bottom:4px; }
163figcaption span { color:#8a93a4; font-size:13px; }
164img.surface { display:block; width:auto; max-width:100%; height:auto;
165  image-rendering:pixelated; }
166img.tip { position:absolute; pointer-events:none; display:none;
167  image-rendering:pixelated; z-index:2; box-shadow:0 4px 16px #0008; }
168</style></head><body>
169<h1>sealed-surface gallery</h1>
170<p class="sub">Hover a <em>data cell</em>, <em>plot well</em>, or <em>treemap leaf</em>. Tooltips are
171<code>GET /i/…/tip.png?x=&amp;y=</code> → <code>image/png</code> (204 if miss — not JSON,
172not SSR). Default type scale is <strong>compact</strong> 5×7.
173<code>TypeScale::large()</code> is 2× opt-in (harder on the eyes). Not DRM; not OCR-proof.</p>
174<div class="grid">"#,
175    );
176    for (id, spec) in &g.specs {
177        body.push_str(&format!(
178            "<figure data-id=\"{id}\"><div class=\"stage\">\
179<img class=\"surface\" alt=\"\" src=\"/i/{id}.png\"/>\
180<img class=\"tip\" alt=\"\"/></div>\
181<figcaption><strong>{}</strong><span>{}</span></figcaption></figure>",
182            spec.title, spec.blurb
183        ));
184    }
185    body.push_str(
186        r#"</div>
187<script>
188document.querySelectorAll("figure[data-id]").forEach((fig) => {
189  const id = fig.getAttribute("data-id");
190  const img = fig.querySelector("img.surface");
191  const tip = fig.querySelector("img.tip");
192  const toPx = (e) => {
193    const r = img.getBoundingClientRect();
194    if (r.width < 1 || r.height < 1) return null;
195    const nw = img.naturalWidth || r.width;
196    const nh = img.naturalHeight || r.height;
197    const x = Math.floor((e.clientX - r.left) * nw / r.width);
198    const y = Math.floor((e.clientY - r.top) * nh / r.height);
199    return { x, y, l: e.clientX - r.left + 12, t: e.clientY - r.top + 12 };
200  };
201  let lastUrl = null;
202  let seq = 0;
203  let timer = 0;
204  const loadTip = (p) => {
205    const n = ++seq;
206    fetch("/i/" + id + "/tip.png?x=" + p.x + "&y=" + p.y).then((r) => {
207      if (n !== seq) return null;
208      if (r.status === 204 || !r.ok) { tip.style.display = "none"; return null; }
209      return r.blob();
210    }).then((b) => {
211      if (n !== seq) return;
212      if (!b || b.size < 32) { tip.style.display = "none"; return; }
213      if (lastUrl) URL.revokeObjectURL(lastUrl);
214      lastUrl = URL.createObjectURL(b);
215      tip.src = lastUrl;
216      tip.style.display = "block";
217    }).catch(() => { if (n === seq) tip.style.display = "none"; });
218  };
219  img.addEventListener("mousemove", (e) => {
220    const p = toPx(e);
221    if (!p) return;
222    tip.style.left = p.l + "px";
223    tip.style.top = p.t + "px";
224    clearTimeout(timer);
225    timer = setTimeout(() => loadTip(p), 24);
226  });
227  img.addEventListener("mouseleave", () => {
228    seq += 1;
229    clearTimeout(timer);
230    tip.style.display = "none";
231    if (lastUrl) { URL.revokeObjectURL(lastUrl); lastUrl = null; }
232  });
233});
234</script>
235</body></html>"#,
236    );
237    body
238}
239
240impl Gallery {
241    fn build() -> Result<Self, sealed_surface::Error> {
242        let grid = demo_grid();
243        let series = demo_series()?;
244        let scatter = demo_scatter()?;
245        let tree = demo_tree()?;
246        let vp_table = Viewport::window(520, 220);
247        let vp_chart = Viewport::window(640, 280);
248        let mut specs = BTreeMap::new();
249        let mut add = |id, spec: Spec| {
250            specs.insert(id, spec);
251        };
252
253        add(
254            "table-default",
255            Spec {
256                title: "Table · default (compact)",
257                blurb: "TypeScale::Compact — 5×7, row 18. Hover for PNG tooltip.",
258                kind: Kind::Table,
259                appearance: Appearance::default(),
260                mode: SurfaceMode::Sealed,
261                lens: LicenseLens::open(),
262                viewport: vp_table,
263                caption: None,
264                widths: None,
265            },
266        );
267        add(
268            "table-large",
269            Spec {
270                title: "Table · large (2×)",
271                blurb: "TypeScale::large() — opt-in; bigger bitmap, more strain.",
272                kind: Kind::Table,
273                appearance: Appearance::large(),
274                mode: SurfaceMode::Sealed,
275                lens: LicenseLens::open(),
276                viewport: Viewport::window(640, 280),
277                caption: None,
278                widths: None,
279            },
280        );
281        add(
282            "table-xlarge",
283            Spec {
284                title: "Table · xlarge (3×)",
285                blurb: "TypeScale::xlarge().",
286                kind: Kind::Table,
287                appearance: Appearance::xlarge(),
288                mode: SurfaceMode::Sealed,
289                lens: LicenseLens::open(),
290                viewport: Viewport::window(720, 320),
291                caption: None,
292                widths: None,
293            },
294        );
295        add(
296            "table-light",
297            Spec {
298                title: "Table · light",
299                blurb: "Theme::light(), compact glyphs.",
300                kind: Kind::Table,
301                appearance: Appearance::light(),
302                mode: SurfaceMode::Sealed,
303                lens: LicenseLens::open(),
304                viewport: vp_table,
305                caption: None,
306                widths: None,
307            },
308        );
309        add(
310            "table-hc",
311            Spec {
312                title: "Table · high contrast",
313                blurb: "Near-white text, strong grid.",
314                kind: Kind::Table,
315                appearance: Appearance::high_contrast(),
316                mode: SurfaceMode::Sealed,
317                lens: LicenseLens::open(),
318                viewport: vp_table,
319                caption: None,
320                widths: None,
321            },
322        );
323
324        let mut tmp = Surface::new(SurfaceMode::Sealed, LicenseLens::open());
325        tmp.set_appearance(Appearance::default());
326        let m = tmp.metrics(&grid);
327        add(
328            "table-scroll",
329            Spec {
330                title: "Table · scroll_by",
331                blurb: "Sticky header; body scrolled three rows.",
332                kind: Kind::Table,
333                appearance: Appearance::default(),
334                mode: SurfaceMode::Sealed,
335                lens: LicenseLens::open(),
336                viewport: vp_table.scroll_by(0, (m.row_height * 3) as i32, &m),
337                caption: None,
338                widths: None,
339            },
340        );
341        add(
342            "table-resize",
343            Spec {
344                title: "Table · column resize",
345                blurb: "SKU column forced to 220px.",
346                kind: Kind::Table,
347                appearance: Appearance::default(),
348                mode: SurfaceMode::Sealed,
349                lens: LicenseLens::open(),
350                viewport: vp_table,
351                caption: None,
352                widths: Some(m.resize_column(0, 220)),
353            },
354        );
355        add(
356            "table-copyable",
357            Spec {
358                title: "Table · copyable",
359                blurb: "Same pixels; TSV allowed. Tooltip still PNG.",
360                kind: Kind::Table,
361                appearance: Appearance::default(),
362                mode: SurfaceMode::Copyable,
363                lens: LicenseLens::open(),
364                viewport: vp_table,
365                caption: None,
366                widths: None,
367            },
368        );
369        add(
370            "table-trial",
371            Spec {
372                title: "Table · trial lens",
373                blurb: "Two clear rows; rest redacted before paint.",
374                kind: Kind::Table,
375                appearance: Appearance::default(),
376                mode: SurfaceMode::Sealed,
377                lens: LicenseLens::from_tier(AccessTier::Trial),
378                viewport: vp_table,
379                caption: None,
380                widths: None,
381            },
382        );
383        add(
384            "ts-default",
385            Spec {
386                title: "Timeseries · default",
387                blurb: "AA 2px stroke, area fill, nice ticks. Hover the line.",
388                kind: Kind::Series,
389                appearance: Appearance::default(),
390                mode: SurfaceMode::Sealed,
391                lens: LicenseLens::open(),
392                viewport: vp_chart,
393                caption: Some("px / qty"),
394                widths: None,
395            },
396        );
397        add(
398            "ts-large",
399            Spec {
400                title: "Timeseries · large type",
401                blurb: "Same chart, 2× tick glyphs.",
402                kind: Kind::Series,
403                appearance: Appearance::large(),
404                mode: SurfaceMode::Sealed,
405                lens: LicenseLens::open(),
406                viewport: vp_chart,
407                caption: Some("large"),
408                widths: None,
409            },
410        );
411        add(
412            "ts-light",
413            Spec {
414                title: "Timeseries · light",
415                blurb: "Light theme + derived ChartStyle.",
416                kind: Kind::Series,
417                appearance: Appearance::light(),
418                mode: SurfaceMode::Sealed,
419                lens: LicenseLens::open(),
420                viewport: vp_chart,
421                caption: Some("light"),
422                widths: None,
423            },
424        );
425        add(
426            "ts-hc",
427            Spec {
428                title: "Timeseries · high contrast",
429                blurb: "Strong grid and series colors.",
430                kind: Kind::Series,
431                appearance: Appearance::high_contrast(),
432                mode: SurfaceMode::Sealed,
433                lens: LicenseLens::open(),
434                viewport: vp_chart,
435                caption: Some("HC"),
436                widths: None,
437            },
438        );
439        add(
440            "ts-trial",
441            Spec {
442                title: "Timeseries · trial lens",
443                blurb: "Two samples kept per series.",
444                kind: Kind::Series,
445                appearance: Appearance::default(),
446                mode: SurfaceMode::Sealed,
447                lens: LicenseLens::from_tier(AccessTier::Trial),
448                viewport: vp_chart,
449                caption: Some("trial"),
450                widths: None,
451            },
452        );
453        add(
454            "sc-default",
455            Spec {
456                title: "Scatter · default",
457                blurb: "Unconnected markers. Same Series type, different encoding.",
458                kind: Kind::Scatter,
459                appearance: Appearance::default(),
460                mode: SurfaceMode::Sealed,
461                lens: LicenseLens::open(),
462                viewport: vp_chart,
463                caption: Some("scatter"),
464                widths: None,
465            },
466        );
467        add(
468            "sc-trial",
469            Spec {
470                title: "Scatter · trial lens",
471                blurb: "Two points kept per series.",
472                kind: Kind::Scatter,
473                appearance: Appearance::default(),
474                mode: SurfaceMode::Sealed,
475                lens: LicenseLens::from_tier(AccessTier::Trial),
476                viewport: vp_chart,
477                caption: Some("trial"),
478                widths: None,
479            },
480        );
481        add(
482            "tm-default",
483            Spec {
484                title: "Treemap · default",
485                blurb: "Squarified leaves. Hover a cell for PNG tooltip.",
486                kind: Kind::Tree,
487                appearance: Appearance::default(),
488                mode: SurfaceMode::Sealed,
489                lens: LicenseLens::open(),
490                viewport: Viewport::window(640, 320),
491                caption: Some("catalog"),
492                widths: None,
493            },
494        );
495        add(
496            "tm-trial",
497            Spec {
498                title: "Treemap · trial lens",
499                blurb: "Two leaves kept; areas reflow.",
500                kind: Kind::Tree,
501                appearance: Appearance::default(),
502                mode: SurfaceMode::Sealed,
503                lens: LicenseLens::from_tier(AccessTier::Trial),
504                viewport: Viewport::window(640, 320),
505                caption: Some("trial"),
506                widths: None,
507            },
508        );
509        add(
510            "tm-light",
511            Spec {
512                title: "Treemap · light",
513                blurb: "Same layout, light theme.",
514                kind: Kind::Tree,
515                appearance: Appearance::light(),
516                mode: SurfaceMode::Sealed,
517                lens: LicenseLens::open(),
518                viewport: Viewport::window(640, 320),
519                caption: Some("light"),
520                widths: None,
521            },
522        );
523
524        Ok(Self {
525            grid,
526            series,
527            scatter,
528            tree,
529            specs,
530        })
531    }
532
533    fn surface(&self, spec: &Spec) -> Surface {
534        let mut s = Surface::new(spec.mode, spec.lens.clone());
535        s.set_appearance(spec.appearance);
536        s
537    }
538
539    fn request(&self, spec: &Spec, pointer: Option<Pointer>) -> FrameRequest {
540        let mut req = FrameRequest::full(spec.viewport);
541        if let Some(c) = spec.caption {
542            req = req.caption(c);
543        }
544        if let Some(w) = spec.widths.clone() {
545            req = req.column_widths(w);
546        }
547        if let Some(p) = pointer {
548            req = req.pointer(p);
549        }
550        req
551    }
552
553    fn frame_png(
554        &self,
555        id: &str,
556        pointer: Option<Pointer>,
557    ) -> Result<Vec<u8>, sealed_surface::Error> {
558        let spec = self
559            .specs
560            .get(id)
561            .ok_or(sealed_surface::Error::InvalidGrid("unknown card"))?;
562        let s = self.surface(spec);
563        let req = self.request(spec, pointer);
564        let frame = match spec.kind {
565            Kind::Table => s.render(&self.grid, &req)?,
566            Kind::Series => s.render_series(&self.series, &req)?,
567            Kind::Scatter => s.render_scatter(&self.scatter, &req)?,
568            Kind::Tree => s.render_tree(&self.tree, &req)?,
569        };
570        Ok(frame.png)
571    }
572
573    fn tooltip(
574        &self,
575        id: &str,
576        pointer: Option<Pointer>,
577    ) -> Result<Option<Vec<u8>>, sealed_surface::Error> {
578        let Some(p) = pointer else {
579            return Ok(None);
580        };
581        let spec = self
582            .specs
583            .get(id)
584            .ok_or(sealed_surface::Error::InvalidGrid("unknown card"))?;
585        let s = self.surface(spec);
586        let req = self.request(spec, Some(p));
587        let frame = match spec.kind {
588            Kind::Table => s.render(&self.grid, &req)?,
589            Kind::Series => s.render_series(&self.series, &req)?,
590            Kind::Scatter => s.render_scatter(&self.scatter, &req)?,
591            Kind::Tree => s.render_tree(&self.tree, &req)?,
592        };
593        Ok(frame.tooltip_png)
594    }
595}
596
597fn demo_grid() -> Grid {
598    let mut rows = Vec::new();
599    for i in 0..16u32 {
600        rows.push(Row::new(
601            i,
602            vec![
603                CellValue::text(format!("SKU-{i:03}")),
604                CellValue::float(12.0 + f64::from(i) * 2.15, 2),
605                CellValue::int(i64::from(i) * 4 + 3),
606            ],
607        ));
608    }
609    Grid::try_new(
610        vec![
611            Column::new(0, "sku"),
612            Column::new(1, "price"),
613            Column::new(2, "qty"),
614        ],
615        rows,
616    )
617    .expect("grid")
618}
619
620fn demo_series() -> Result<SeriesLayout, sealed_surface::Error> {
621    let mut px = Vec::new();
622    let mut qty = Vec::new();
623    for i in 0..48u32 {
624        let x = f64::from(i);
625        px.push(SeriesPoint::new(
626            x,
627            40.0 + 14.0 * (x * 0.22).sin() + x * 0.2,
628        ));
629        qty.push(SeriesPoint::new(x, 10.0 + 4.0 * (x * 0.18).cos()));
630    }
631    SeriesLayout::try_new(vec![Series::new(0, "px", px), Series::new(1, "qty", qty)])
632}
633
634fn demo_scatter() -> Result<SeriesLayout, sealed_surface::Error> {
635    let mut a = Vec::new();
636    let mut b = Vec::new();
637    for i in 0..28u32 {
638        let t = f64::from(i);
639        a.push(SeriesPoint::new(
640            6.0 + (t * 0.37).sin() * 5.0 + t * 0.12,
641            22.0 + (t * 0.51).cos() * 8.0,
642        ));
643        b.push(SeriesPoint::new(
644            18.0 + (t * 0.29).cos() * 6.0,
645            12.0 + (t * 0.41).sin() * 7.0 + t * 0.15,
646        ));
647    }
648    SeriesLayout::try_new(vec![Series::new(0, "a", a), Series::new(1, "b", b)])
649}
650
651fn demo_tree() -> Result<TreeLayout, sealed_surface::Error> {
652    TreeLayout::try_new(TreeNode::branch(
653        0,
654        "catalog",
655        vec![
656            TreeNode::branch(
657                1,
658                "apparel",
659                vec![
660                    TreeNode::leaf(2, "shirts", 42.0),
661                    TreeNode::leaf(3, "pants", 18.0),
662                    TreeNode::leaf(4, "hats", 9.0),
663                ],
664            ),
665            TreeNode::branch(
666                5,
667                "home",
668                vec![
669                    TreeNode::leaf(6, "lamps", 21.0),
670                    TreeNode::leaf(7, "rugs", 14.0),
671                ],
672            ),
673            TreeNode::leaf(8, "other", 7.0),
674        ],
675    ))
676}