Struct SystemChart 

pub struct SystemChart {
    pub title: String,
    pub state: SysChartModel,
}

The system-map chart Facet: a tab title plus the complete observable SysChartModel. The FC-9 pure view reads it and the FC-2 update is the sole path that mutates it.

Fields

title: String

Tab/panel title.

state: SysChartModel

All observable state (FC-3).

Implementations

impl SystemChart

pub const NODE_R: f32 = NODE_R

The node radius (px) the free-position layout pads the canvas by, exposed so the matrix can assert nodes land inside rect by exactly this inset.

pub fn new( title: impl Into<String>, nodes: Vec<SysNode>, edges: Vec<SysEdge>, ) -> Self

pub fn with_canvas_height(self, h: f32) -> Self

pub fn from_layers( title: impl Into<String>, layers: Vec<Vec<SysNode>>, edges: Vec<SysEdge>, ) -> Self

Build a layered system map — the architecture/topology “grouped by layer” shape. layers are top-to-bottom bands (e.g. ingress → services → storage); each band’s nodes are spread evenly across the width and pinned to that band’s vertical position, so the map reads as a constellation diagram organised by layer. Node pos fields are overwritten by the layout; edges (the dependencies) are added as given. This is SystemChart::new with the free positions computed from the layering instead of supplied.

pub fn demo() -> Self

A self-contained demo constellation map — a small nordisk architecture in three layers (ingress gateway → the korp/nornir/holger services → the skade/iceberg storage), with dependency edges and per-service badges. The fixture the syschart_panel demo (and the Pages site) mounts.

pub fn nodes(&self) -> &[SysNode]

The nodes (read-only view of the model).

pub fn edges(&self) -> &[SysEdge]

The edges (read-only view of the model).

pub fn update(&mut self, msg: Msg) -> Vec<Effect>

FC-2 / FC-8 — the single mutation path. Apply one Msg; returns the (always empty) Effects the host should run. The canvas click routes its Msg here too, so live == headless.

pub fn select(&mut self, id: &str)

Select a node by id (headless-test + host entry point). Selecting the already-selected node deselects it. Unknown id is a no-op. Thin wrapper over update(Msg::Select) — the single mutation path.

pub fn clear_selection(&mut self)

Clear the selection (Msg::ClearSelection).

pub fn selected(&self) -> Option<&str>

The selected node’s id, if any.

pub fn set_badge(&mut self, id: &str, badge: u64)

Update a node’s badge by id (e.g. a live event count). No-op if unknown. Thin wrapper over update(Msg::SetBadge).

pub fn set_detail(&mut self, id: &str, detail: impl Into<String>)

Update a node’s detail text by id. No-op if unknown. Thin wrapper over update(Msg::SetDetail).

pub fn node_center(&self, i: usize, rect: Rect) -> Pos2

Test/host hook (additive). The public, return-asserted view of the private center layout node — the absolute pixel centre node i’s circle is painted at inside rect. Exposed so the syschart call-chain matrix can assert the layout/place stage (finite, confined to the padded inner rect, monotone in the normalized pos) without a painter. Calls the same private fn view paints with — additive, no behaviour change. The node radius the layout pads for is SystemChart::NODE_R.

impl SystemChart

pub fn copy_text(&self) -> Option<String>

The copyable text: the selected node’s label · detail (badge in a suffix) when a node is selected, else the whole node list as a TSV rectangle (id \t label \t badge).

pub fn view(&self, ui: &mut Ui) -> Vec<Msg>

FC-9 pure view — a function of &self: it paints the chart and returns the Msgs the frame produced (a node click → Msg::Select). It does not mutate the model; the impl_facet_via_elm! bridge applies the returned messages through update, so a headless driver feeding the same Msgs reproduces the live behaviour.

Trait Implementations

impl CopySource for SystemChart

fn copy_kinds(&self) -> &[ClipKind]

The kinds this source can offer, richest first.

fn copy_payload(&self) -> Option<ClipPayload>

Produce the payload for the current selection (richest representation).

impl Elm for SystemChart

type Model = SysChartModel

All observable state, in one serializable struct (FC-1 / FC-3).

type Msg = Msg

Every input the component accepts (FC-2). The only legal way to mutate the Model.

type Effect = Effect

Side work as data (FC-8). Use enum Effect {} when the component does no I/O.

fn title(&self) -> &str

The deck keys facets off this (mirrors Facet::title).

fn state(&self) -> &SysChartModel

FC-3 — read the complete observable state at any frame boundary.

fn update(&mut self, msg: Msg) -> Vec<Effect>

FC-2 / FC-8 — the single mutation path. Apply one Msg; return the Effects the host should run (empty = nothing to do).

fn view(&self, ui: &mut Ui) -> Vec<Msg>

FC-9 / FC-4 — a pure function of &self: it paints and returns the Msgs it produced. It MUST NOT mutate the model or do I/O; the Facet::ui bridge applies the returned messages through update.

impl Facet for SystemChart

fn component(&self) -> &'static str

The pane’s DEV-ID, derived with zero per-pane code: module_path!() expands at the CALL site, so a bridged pane in facett-geomap reports facett_geomap, which devid::normalize maps to the registry component geomap. Override in the extras block to say something else.

fn ui(&mut self, ui: &mut Ui)

FC-9: the view is pure (paints + emits Msgs); FC-2: mutation only via update. The immediate-mode trait just bridges the two.

fn severity(&self) -> Severity

STRUCTURAL severity (the Robot-UI gate signal): RED when the chart has no peers to show (the facet-syschart-1 empty state), the Info floor otherwise.

fn caps(&self) -> FacetCaps

Painted with the active Theme (nodes/edges/text/accent ring), and its canvas takes the host’s available width — themeable + resizable.

fn as_any_mut(&mut self) -> Option<&mut dyn Any>

Opt into typed downcast so a host (e.g. the demo’s robot-UI node-select toolbar) can forward a selection to SystemChart::select when this chart lives boxed inside a FacetDeck.

fn title(&self) -> &str

fn copy(&mut self) -> Option<String>

Clipboard hooks — see clipboard.rs. Defaults: nothing to give/take. Returns the text to place on the clipboard (None = nothing copyable now).

fn state_json(&self) -> Value

fn selection_json(&self) -> Value

The current selection as JSON (also folded into state_json by convention). Null when nothing/none selectable.

fn update_json(&mut self, _msg_json: &str)

The Elm mutation path — apply one message (JSON). This is the fourth member of the component contract (title/ui/state_json/update_json), and it is defaulted to a no-op so it is purely ADDITIVE: every existing impl Facet keeps compiling unchanged, while a facet that wants the writable input surface overrides it (an Elm-backed facet routes the JSON through its update). With this default in place Facet and Panel share the same four-method shape, which is what lets the blanket impl<T: Facet> Panel for T (see panel) make every Facet a Panel for free. Unknown/undriven messages are ignored — the default simply does nothing.

fn scale(&self) -> f32

Current uniform scale (1.0 = native). Override if caps().scalable.

fn set_scale(&mut self, _scale: f32)

Set the uniform scale; clamp internally. Default no-op (not scalable).

fn scale_range(&self) -> (f32, f32)

The band [min, max], relative to native (1.0), that this facet’s uniform scale may be driven over. FacetDeck::scale_active clamps into it.

fn cut(&mut self) -> Option<String>

Like copy, but also removes the selection. Default delegates to copy.

fn paste(&mut self, _text: &str) -> bool

Accept pasted text. Returns true if consumed.

fn kind(&self) -> &'static str

Stable component-type id (e.g. "jobview", "graphpan", "table"). Two instances with the same kind can exchange portable state; the empty default "" means opted out of cross-instance clone.

fn portable_state(&self) -> Option<Value>

The portable subset of this facet’s state — the fields a same-kind sibling can adopt. None = not cloneable. Kept SEPARATE from state_json (the introspection dump, which may carry derived / render-only data) so this stays round-trippable through load_state.

fn load_state(&mut self, _state: &Value) -> bool

Adopt a portable state produced by portable_state on a same-kind sibling. Returns true if accepted. Default false (opt-in per component).