facett_core/
lib.rs

1//! **facett-core** — the visual kernel. Render a node/edge **`Scene`** into egui.
2//! Source-agnostic: build a `Scene` from anything (Arrow rows, a graph, a DAG),
3//! hand it here, get pixels. The CPU painter is the reference; a **wgpu** fast
4//! path (GPU viewport-cull + indirect draw, seeded from katana-osm's
5//! `osm-viewer`) lands behind this same `draw()` call — consumers don't change.
6
7use egui::{Align2, Color32, FontId, Pos2, Rect, Sense, Stroke, Ui, vec2};
8
9pub mod a11y;
10pub mod caps;
11pub mod clip;
12pub mod clipboard;
13pub mod deckfx;
14pub mod edges;
15pub mod effects;
16pub mod focus;
17pub mod labels3d;
18pub mod harness;
19pub mod look;
20pub mod nav;
21pub mod overlay;
22pub mod rabbit;
23pub mod scroll_engine;
24pub mod testmatrix; // functional-status → nornir test-matrix bridge (feature
25                    // `testmatrix`); no-op in release.
26pub mod theme;
27pub mod trace; // structured IN/OUT/END event stream ($FACETT_TRACE) — the
28               // machine-readable data a facet actually rendered.
29pub use a11y::{Semantics, node as a11y_node, stable_id};
30pub use caps::FacetCaps;
31pub use clip::{ArrowColumnRef, ClipKind, ClipPayload, CopySource, PasteTarget};
32pub use clipboard::ClipAction;
33pub use deckfx::{DeckFx, DeckRaven};
34pub use look::{Action, KeyMap, Palette};
35pub use nav::{Dir4, Navigable, nearest_in_direction};
36pub use rabbit::{Rabbit, RabbitMesh, rabbit_mesh, rabbit_outline};
37pub use scroll_engine::SmoothScroll;
38pub use theme::{Theme, set_theme, theme};
39
40// The rich look-&-feel `Theme` (the work-order architecture) is re-exported under
41// an unambiguous alias so it coexists with the legacy flat palette `Theme` above.
42pub use look::Theme as LookTheme;
43
44/// A node: a label + a colour (the *consumer* picks the colour policy — hash by
45/// label, by status, …).
46#[derive(Clone)]
47pub struct Node {
48    pub label: String,
49    pub color: Color32,
50}
51
52/// A directed edge between node indices.
53#[derive(Clone, Copy)]
54pub struct Edge {
55    pub src: usize,
56    pub dst: usize,
57}
58
59/// A drawable graph: nodes + edges (edges index into `nodes`).
60#[derive(Default, Clone)]
61pub struct Scene {
62    pub nodes: Vec<Node>,
63    pub edges: Vec<Edge>,
64}
65
66impl Scene {
67    pub fn new() -> Self {
68        Self::default()
69    }
70    /// Push a node, returning its index.
71    pub fn node(&mut self, label: impl Into<String>, color: Color32) -> usize {
72        self.nodes.push(Node { label: label.into(), color });
73        self.nodes.len() - 1
74    }
75    pub fn edge(&mut self, src: usize, dst: usize) {
76        self.edges.push(Edge { src, dst });
77    }
78    pub fn is_empty(&self) -> bool {
79        self.nodes.is_empty()
80    }
81}
82
83/// Node placement strategy.
84#[derive(Clone, Copy, PartialEq, Eq, Default)]
85pub enum Layout {
86    #[default]
87    Circular,
88    /// Deterministic Fruchterman–Reingold (edges pull, all nodes repel). O(n²)
89    /// per iteration — best for small/medium graphs.
90    Force,
91}
92
93/// Draw a `Scene` into `ui` — the reusable render primitive. Empty scenes show
94/// `empty_hint`. Labels render when the node count is small enough to read.
95pub fn draw(ui: &mut Ui, scene: &Scene, layout: Layout, empty_hint: &str) {
96    let (rect, _) = ui.allocate_exact_size(ui.available_size(), Sense::hover());
97    let th = theme(ui);
98    let painter = ui.painter_at(rect);
99    let n = scene.nodes.len();
100    if n == 0 {
101        painter.text(rect.center(), Align2::CENTER_CENTER, empty_hint, FontId::proportional(13.0), th.text_dim);
102        return;
103    }
104    let pos = positions(layout, scene, rect);
105    for e in &scene.edges {
106        if e.src < n && e.dst < n {
107            painter.line_segment([pos[e.src], pos[e.dst]], Stroke::new(0.6, th.edge));
108        }
109    }
110    for (i, node) in scene.nodes.iter().enumerate() {
111        painter.circle_filled(pos[i], 5.0, node.color);
112    }
113    if n <= 60 {
114        for (i, node) in scene.nodes.iter().enumerate() {
115            painter.text(pos[i] + vec2(7.0, 0.0), Align2::LEFT_CENTER, &node.label, FontId::proportional(10.0), th.text);
116        }
117    }
118}
119
120fn positions(layout: Layout, scene: &Scene, rect: Rect) -> Vec<Pos2> {
121    let n = scene.nodes.len();
122    let center = rect.center();
123    let radius = rect.size().min_elem() * 0.42;
124    let circular = |i: usize| {
125        let a = std::f32::consts::TAU * (i as f32) / (n as f32);
126        vec2(a.cos(), a.sin())
127    };
128    match layout {
129        Layout::Circular => (0..n).map(|i| center + radius * circular(i)).collect(),
130        Layout::Force => {
131            // Deterministic Fruchterman–Reingold from a circular seed (unit space).
132            let mut p: Vec<egui::Vec2> = (0..n).map(circular).collect();
133            let k = (1.0 / (n.max(1) as f32).sqrt()).clamp(0.05, 1.0);
134            for _ in 0..120 {
135                let mut disp = vec![egui::Vec2::ZERO; n];
136                for i in 0..n {
137                    for j in (i + 1)..n {
138                        let d = p[i] - p[j];
139                        let dist = d.length().max(1e-3);
140                        let f = k * k / dist;
141                        let dir = d / dist;
142                        disp[i] += dir * f;
143                        disp[j] -= dir * f;
144                    }
145                }
146                for e in &scene.edges {
147                    if e.src < n && e.dst < n {
148                        let d = p[e.src] - p[e.dst];
149                        let dist = d.length().max(1e-3);
150                        let f = dist * dist / k;
151                        let dir = d / dist;
152                        disp[e.src] -= dir * f;
153                        disp[e.dst] += dir * f;
154                    }
155                }
156                for i in 0..n {
157                    let dl = disp[i].length().max(1e-3);
158                    p[i] += disp[i] / dl * dl.min(0.04); // capped step (cooling-free, deterministic)
159                }
160            }
161            // Normalise to fit the rect.
162            let (mut mn, mut mx) = (egui::vec2(f32::MAX, f32::MAX), egui::vec2(f32::MIN, f32::MIN));
163            for v in &p {
164                mn.x = mn.x.min(v.x);
165                mn.y = mn.y.min(v.y);
166                mx.x = mx.x.max(v.x);
167                mx.y = mx.y.max(v.y);
168            }
169            let span = (mx - mn).max(egui::vec2(1e-3, 1e-3));
170            p.iter()
171                .map(|v| center + egui::vec2(((v.x - mn.x) / span.x - 0.5) * 2.0 * radius, ((v.y - mn.y) / span.y - 0.5) * 2.0 * radius))
172                .collect()
173        }
174    }
175}
176
177/// The facett **component contract**. Every facet — graph, map, pipeline, table,
178/// the ported nornir viewers — implements this, so consumers (korp, nornir, …)
179/// compose them uniformly *and* get headless robot-testing for free.
180///
181/// The three things a component owes its host:
182/// 1. a **title** (tab label / panel heading),
183/// 2. how to **draw** itself into egui,
184/// 3. its **observable state** as JSON — dumped to `$APP_STATE` for headless
185///    assertions. **Rule:** every visible list/status/count goes in `state_json`.
186pub trait Facet {
187    fn title(&self) -> &str;
188    fn ui(&mut self, ui: &mut Ui);
189    fn state_json(&self) -> serde_json::Value;
190
191    // --- uniform capability surface (all defaulted; see caps.rs / clipboard.rs) ---
192
193    /// What this facet can do. Override to opt into capabilities.
194    fn caps(&self) -> FacetCaps {
195        FacetCaps::NONE
196    }
197
198    /// Current uniform scale (1.0 = native). Override if `caps().scalable`.
199    fn scale(&self) -> f32 {
200        1.0
201    }
202    /// Set the uniform scale; clamp internally. Default no-op (not scalable).
203    fn set_scale(&mut self, _scale: f32) {}
204
205    /// The current selection as JSON (also folded into `state_json` by
206    /// convention). `Null` when nothing/none selectable.
207    fn selection_json(&self) -> serde_json::Value {
208        serde_json::Value::Null
209    }
210
211    /// Clipboard hooks — see clipboard.rs. Defaults: nothing to give/take.
212    /// Returns the text to place on the clipboard (None = nothing copyable now).
213    fn copy(&mut self) -> Option<String> {
214        None
215    }
216    /// Like `copy`, but also removes the selection. Default delegates to `copy`.
217    fn cut(&mut self) -> Option<String> {
218        self.copy()
219    }
220    /// Accept pasted text. Returns true if consumed.
221    fn paste(&mut self, _text: &str) -> bool {
222        false
223    }
224
225    /// Optional downcast handle for hosts that need typed access to a specific
226    /// facet living inside a [`FacetDeck`] (e.g. a robot-UI driver clicking an
227    /// app-level control that must forward to a concrete component's own API).
228    /// Defaulted to `None` so no existing facet has to change; a component opts in
229    /// by returning `Some(self)`.
230    fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
231        None
232    }
233}
234
235/// A tabbed set of [`Facet`]s — the reusable multi-component shell. Draws a tab
236/// bar + the active facet, and composes **every** facet's `state_json` under its
237/// title, so the whole-app introspection contract is free. korp/nornir can build
238/// their window from a `FacetDeck` instead of hand-rolling tabs + the state dump.
239pub struct FacetDeck {
240    facets: Vec<Box<dyn Facet>>,
241    active: usize,
242    /// Opt-in deck effects (palette override + glow). `Default` = all off, so a
243    /// deck that never opts in is unchanged and pays nothing.
244    fx: DeckFx,
245    /// A raven summoned through the deck, in flight or perched (or `None`).
246    raven: Option<DeckRaven>,
247}
248
249impl FacetDeck {
250    pub fn new(facets: Vec<Box<dyn Facet>>) -> Self {
251        Self { facets, active: 0, fx: DeckFx::OFF, raven: None }
252    }
253    pub fn active(&self) -> usize {
254        self.active
255    }
256
257    /// Typed mutable access to the facet with `title`, downcast to `T` — `None` if
258    /// no such facet, or it doesn't opt into [`Facet::as_any_mut`], or the type
259    /// mismatches. Lets a host drive a concrete component's own API (e.g. a
260    /// robot-UI control forwarding a node selection to a `SystemChart`).
261    pub fn facet_mut<T: std::any::Any>(&mut self, title: &str) -> Option<&mut T> {
262        self.facets
263            .iter_mut()
264            .find(|f| f.title() == title)
265            .and_then(|f| f.as_any_mut())
266            .and_then(|a| a.downcast_mut::<T>())
267    }
268
269    // ── opt-in effects + theming (see deckfx.rs) ─────────────────────────────
270
271    /// Enable deck effects up front (builder form of [`fx_mut`](Self::fx_mut)).
272    pub fn with_fx(mut self, fx: DeckFx) -> Self {
273        self.fx = fx;
274        self
275    }
276    /// The current deck-effects config (read-only).
277    pub fn fx(&self) -> &DeckFx {
278        &self.fx
279    }
280    /// Mutate the deck-effects config (toggle glow, pin a palette, …).
281    pub fn fx_mut(&mut self) -> &mut DeckFx {
282        &mut self.fx
283    }
284    /// Override the deck theme with palette index `i` (wraps); enables the
285    /// override. Convenience over `fx_mut().set_palette(i)`.
286    pub fn set_palette(&mut self, i: usize) {
287        self.fx.set_palette(i);
288    }
289    /// Advance to the next palette in [`Theme::ALL`] (wrapping); returns the new
290    /// index. Convenience over `fx_mut().cycle_palette()`.
291    pub fn cycle_palette(&mut self) -> usize {
292        self.fx.cycle_palette()
293    }
294
295    /// **Summon the raven** to perch on `target` — any rect a facet/host hands us
296    /// (a table row, a node, a header). Replaces any raven already in flight. The
297    /// body is tinted from the deck's current palette (or the host theme). Logs an
298    /// activity trail entry. Drive/paint happens automatically inside
299    /// [`ui`](Self::ui).
300    pub fn send_raven(&mut self, target: Rect) {
301        let theme = self.effective_theme();
302        self.raven = Some(DeckRaven::new(target, &theme));
303        harness::trail(
304            harness::Kind::Render,
305            format!("raven launched → perch ({:.0},{:.0})", target.center().x, target.top()),
306        );
307    }
308    /// True while a raven is present (flying or perched).
309    pub fn has_raven(&self) -> bool {
310        self.raven.is_some()
311    }
312    /// True once the summoned raven has landed (false if none).
313    pub fn raven_perched(&self) -> bool {
314        self.raven.as_ref().map(|r| r.is_perched()).unwrap_or(false)
315    }
316    /// Dismiss any raven.
317    pub fn clear_raven(&mut self) {
318        self.raven = None;
319    }
320
321    /// The theme the deck paints with: the fx palette override if set, else
322    /// [`Theme::default`] (the host's own `set_theme` still applies its visuals;
323    /// this is just the colour source for deck-owned effects/picker).
324    fn effective_theme(&self) -> Theme {
325        self.fx.theme().unwrap_or_default()
326    }
327
328    /// Draw a one-line **palette picker** — a switcher over [`Theme::ALL`] the
329    /// host can place anywhere (toolbar, menu). Selecting a palette pins the fx
330    /// override; `ui()` then applies it each frame. Returns the chosen index if it
331    /// changed this frame.
332    pub fn palette_picker(&mut self, ui: &mut Ui) -> Option<usize> {
333        let mut sel = self.fx.palette().unwrap_or(0);
334        let before = sel;
335        ui.horizontal_wrapped(|ui| {
336            ui.label("Palette:");
337            for (i, ctor) in Theme::ALL.iter().enumerate() {
338                ui.selectable_value(&mut sel, i, ctor().name);
339            }
340        });
341        if sel != before || self.fx.palette().is_none() {
342            self.fx.set_palette(sel);
343        }
344        (sel != before).then_some(sel)
345    }
346
347    /// The capabilities of the currently-active facet (or `NONE` if empty).
348    pub fn active_caps(&self) -> FacetCaps {
349        self.facets.get(self.active).map(|f| f.caps()).unwrap_or(FacetCaps::NONE)
350    }
351
352    /// The active facet's current scale (1.0 if none / not scalable).
353    fn active_scale(&self) -> f32 {
354        self.facets.get(self.active).map(|f| f.scale()).unwrap_or(1.0)
355    }
356
357    /// Multiply the active facet's scale by `k`, clamped to a sane range.
358    fn scale_active(&mut self, k: f32) {
359        if let Some(f) = self.facets.get_mut(self.active) {
360            let s = (f.scale() * k).clamp(0.25, 4.0);
361            f.set_scale(s);
362        }
363    }
364
365    /// Reset the active facet's scale to native.
366    fn reset_scale(&mut self) {
367        if let Some(f) = self.facets.get_mut(self.active) {
368            f.set_scale(1.0);
369        }
370    }
371
372    /// Draw the tab bar + capability toolbar + the active facet, and route
373    /// capability-gated shortcuts (Ctrl-+/-/0 for scale; Ctrl-C/X/V for clipboard).
374    pub fn ui(&mut self, ui: &mut Ui) {
375        // Opt-in palette override: apply the chosen Theme::ALL palette + its
376        // egui Visuals each frame so the whole deck (and every facet that reads
377        // `theme(ui)`) follows. No override → the host's own theme stays.
378        if let Some(theme) = self.fx.theme() {
379            set_theme(ui.ctx(), theme);
380        }
381
382        let titles: Vec<String> = self.facets.iter().map(|f| f.title().to_string()).collect();
383        // Wrap the tab bar: with many facets a single non-wrapping row overflows
384        // the panel width and the trailing tabs become unreachable (off-screen,
385        // unclickable for a robot driver / pointer). Wrapping keeps every tab
386        // visible + clickable no matter how many facets the deck holds.
387        ui.horizontal_wrapped(|ui| {
388            for (i, t) in titles.iter().enumerate() {
389                ui.selectable_value(&mut self.active, i, t);
390            }
391        });
392
393        let caps = self.active_caps();
394
395        // Capability-driven toolbar: only show controls the active facet honors.
396        if caps.scalable {
397            ui.horizontal(|ui| {
398                if ui.button("−").on_hover_text("Zoom out (Ctrl-−)").clicked() {
399                    self.scale_active(1.0 / 1.1);
400                }
401                ui.label(format!("{:.0}%", self.active_scale() * 100.0));
402                if ui.button("+").on_hover_text("Zoom in (Ctrl-+)").clicked() {
403                    self.scale_active(1.1);
404                }
405                if ui.button("Reset").on_hover_text("Reset zoom (Ctrl-0)").clicked() {
406                    self.reset_scale();
407                }
408            });
409        }
410
411        // Capability-gated scale shortcuts. egui has no semantic event for these,
412        // so we hand-detect the key combos (clipboard uses semantic events below).
413        if caps.scalable {
414            let (cmd, plus, minus, zero) = ui.input(|i| {
415                (
416                    i.modifiers.command,
417                    i.key_pressed(egui::Key::Plus) || i.key_pressed(egui::Key::Equals),
418                    i.key_pressed(egui::Key::Minus),
419                    i.key_pressed(egui::Key::Num0),
420                )
421            });
422            if cmd {
423                if plus {
424                    self.scale_active(1.1);
425                }
426                if minus {
427                    self.scale_active(1.0 / 1.1);
428                }
429                if zero {
430                    self.reset_scale();
431                }
432            }
433        }
434
435        // Clipboard routing: drain semantic events and dispatch to the active
436        // facet, gated by its caps. A focused TextEdit already consumed its own.
437        self.route_clipboard(ui.ctx());
438
439        ui.separator();
440        // Render the active facet, capturing the rect it occupied so the deck can
441        // bloom it (opt-in glow) without the facet knowing.
442        let content = ui.scope(|ui| {
443            if let Some(f) = self.facets.get_mut(self.active) {
444                f.ui(ui);
445            }
446        });
447        let content_rect = content.response.rect;
448
449        // Opt-in glow on the active facet's content rect, pulsing.
450        if self.fx.glow && content_rect.is_positive() {
451            let theme = self.effective_theme();
452            let time = ui.input(|i| i.time);
453            let painter = ui.painter_at(content_rect);
454            deckfx::paint_active_glow(&painter, content_rect.shrink(2.0), &theme, &self.fx, time);
455            ui.ctx().request_repaint(); // keep the pulse animating
456        }
457
458        // Drive + paint a summoned raven on a foreground layer above everything.
459        self.drive_raven(ui.ctx());
460    }
461
462    /// Advance + paint the summoned raven (if any) on a foreground layer. Pins its
463    /// launch time on the first frame and keeps repainting while it flies.
464    fn drive_raven(&mut self, ctx: &egui::Context) {
465        let Some(raven) = self.raven.as_mut() else { return };
466        raven.sprite.update(ctx);
467        let painter =
468            ctx.layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::new("facett_deck_raven")));
469        raven.sprite.paint(&painter);
470    }
471
472    /// Route this frame's clipboard events to the active facet, gated by caps.
473    /// The single OS-touching write (`clipboard::put`) lives here.
474    fn route_clipboard(&mut self, ctx: &egui::Context) {
475        let caps = self.active_caps();
476        if !(caps.copyable || caps.cuttable || caps.pasteable) {
477            return;
478        }
479        for action in clipboard::poll(ctx) {
480            let Some(f) = self.facets.get_mut(self.active) else { continue };
481            match action {
482                ClipAction::Copy if caps.copyable => {
483                    if let Some(t) = f.copy() {
484                        clipboard::put(ctx, t);
485                    }
486                }
487                ClipAction::Cut if caps.cuttable => {
488                    if let Some(t) = f.cut() {
489                        clipboard::put(ctx, t);
490                    }
491                }
492                ClipAction::Paste(s) if caps.pasteable => {
493                    f.paste(&s);
494                }
495                // Capability not declared → ignore (event may belong to a focused
496                // sub-widget egui already handled).
497                _ => {}
498            }
499        }
500    }
501
502    /// The whole-app observable state: the active facet + each facet's
503    /// `state_json`, plus an **additive** sibling `caps` map (title → caps JSON)
504    /// so the existing flat `facets[title]` shape is unchanged for consumers.
505    pub fn state_json(&self) -> serde_json::Value {
506        let mut facets = serde_json::Map::new();
507        let mut caps = serde_json::Map::new();
508        for f in &self.facets {
509            facets.insert(f.title().to_string(), f.state_json());
510            caps.insert(f.title().to_string(), f.caps().to_json());
511        }
512        serde_json::json!({
513            "active": self.facets.get(self.active).map(|f| f.title()),
514            "facets": facets,
515            "caps": caps,
516        })
517    }
518}
519
520/// A stable, bright-ish colour from a string (FNV-1a). Handy default node colour.
521pub fn hash_color(s: &str) -> Color32 {
522    let mut h: u32 = 2166136261;
523    for b in s.bytes() {
524        h = (h ^ b as u32).wrapping_mul(16777619);
525    }
526    Color32::from_rgb((h & 0xFF) as u8 | 0x60, ((h >> 8) & 0xFF) as u8 | 0x60, ((h >> 16) & 0xFF) as u8 | 0x60)
527}
528
529#[cfg(test)]
530mod tests {
531    use super::*;
532
533    #[test]
534    fn scene_builds() {
535        let mut s = Scene::new();
536        let a = s.node("Person", hash_color("Person"));
537        let b = s.node("Company", hash_color("Company"));
538        s.edge(a, b);
539        assert_eq!(s.nodes.len(), 2);
540        assert_eq!(s.edges.len(), 1);
541        assert!(!s.is_empty());
542    }
543
544    #[test]
545    fn force_layout_produces_finite_bounded_positions() {
546        let mut scene = Scene::new();
547        for i in 0..12 { scene.node(format!("n{i}"), hash_color("n")); }
548        for i in 0..12 { scene.edge(i, (i + 1) % 12); }
549        let rect = egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(400.0, 400.0));
550        let pos = positions(Layout::Force, &scene, rect);
551        assert_eq!(pos.len(), 12);
552        for p in &pos {
553            assert!(p.x.is_finite() && p.y.is_finite(), "finite");
554            assert!(rect.expand(50.0).contains(*p), "roughly within the rect");
555        }
556    }
557
558    #[test]
559    fn hash_color_is_stable() {
560        assert_eq!(hash_color("Person"), hash_color("Person"));
561        assert_ne!(hash_color("Person"), hash_color("Company"));
562    }
563
564    /// A minimal facet for deck tests.
565    struct Stub(&'static str);
566    impl Facet for Stub {
567        fn title(&self) -> &str {
568            self.0
569        }
570        fn ui(&mut self, ui: &mut Ui) {
571            ui.label(self.0);
572        }
573        fn state_json(&self) -> serde_json::Value {
574            serde_json::json!({ "t": self.0 })
575        }
576    }
577
578    #[test]
579    fn deck_fx_is_off_by_default() {
580        let deck = FacetDeck::new(vec![Box::new(Stub("a"))]);
581        assert_eq!(*deck.fx(), DeckFx::OFF, "no effects until the host opts in");
582        assert!(!deck.has_raven());
583        assert!(!deck.fx().glow);
584        assert!(deck.fx().palette().is_none());
585    }
586
587    #[test]
588    fn deck_cycle_palette_walks_theme_all() {
589        let mut deck = FacetDeck::new(vec![Box::new(Stub("a"))]);
590        let first = deck.cycle_palette();
591        assert_eq!(first, 0);
592        assert_eq!(deck.fx().theme().map(|t| t.name), Some(Theme::ALL[0]().name));
593        // walks forward and wraps
594        for _ in 1..Theme::ALL.len() {
595            deck.cycle_palette();
596        }
597        assert_eq!(deck.cycle_palette(), 0, "wraps back to the first palette");
598    }
599
600    #[test]
601    fn deck_send_raven_launches_and_perches_after_a_full_flight() {
602        use crate::effects::RAVEN_FLIGHT_SECS;
603        let mut deck = FacetDeck::new(vec![Box::new(Stub("rows"))]);
604        assert!(!deck.has_raven());
605        let target = egui::Rect::from_min_size(egui::pos2(120.0, 80.0), egui::vec2(200.0, 28.0));
606        deck.send_raven(target);
607        assert!(deck.has_raven(), "raven summoned");
608        assert!(!deck.raven_perched(), "not perched at launch");
609
610        // Drive the sprite headlessly past the flight duration → it perches.
611        if let Some(r) = deck.raven.as_mut() {
612            r.sprite.advance(RAVEN_FLIGHT_SECS + 0.1);
613        }
614        assert!(deck.raven_perched(), "perched after the flight duration");
615
616        deck.clear_raven();
617        assert!(!deck.has_raven());
618    }
619
620    #[test]
621    fn deck_palette_override_applies_theme_in_a_ui_pass() {
622        let mut deck = FacetDeck::new(vec![Box::new(Stub("a"))]);
623        deck.set_palette(1); // sci-fi
624        let ctx = egui::Context::default();
625        let mut seen = "";
626        let _ = ctx.run(egui::RawInput::default(), |ctx| {
627            egui::CentralPanel::default().show(ctx, |ui| {
628                deck.ui(ui);
629                seen = theme(ui).name;
630            });
631        });
632        assert_eq!(seen, Theme::ALL[1]().name, "deck applied its palette override");
633    }
634}
facett_core/lib.rs

facett_core/
lib.rs
