gantz_egui 0.6.1

UI traits and widgets that make up the GUI for gantz, an environment for creative systems.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use crate::{
    Env, InspectorRowsResponse, NodeCtx, NodeUi, NodeUiResponse, SocketDoc, SocketKind,
    widget::node_inspector,
};
use gantz_core::node;

impl NodeUi for gantz_core::node::graph::Outlet {
    fn name(&self, _: &Env<'_>) -> std::borrow::Cow<'_, str> {
        "out".into()
    }

    fn description(&self) -> Option<&'static str> {
        Some("A graph output")
    }

    fn ui(&mut self, ctx: NodeCtx, uictx: egui_graph::NodeCtx) -> NodeUiResponse {
        let framed = uictx.framed(|ui, _sockets| {
            let name = self.name(ctx.env());
            let ix = outlet_ix(ctx.path(), ctx.outlets());
            let text = format!("{}[{}]", name, ix);
            ui.add(egui::Label::new(text).selectable(false))
        });
        NodeUiResponse::new(framed)
    }

    fn inspector_rows(
        &mut self,
        ctx: &mut NodeCtx,
        body: &mut egui_extras::TableBody,
    ) -> InspectorRowsResponse {
        let row_h = node_inspector::table_row_h(body.ui_mut());
        body.row(row_h, |mut row| {
            row.col(|ui| {
                ui.label("index");
            });
            row.col(|ui| {
                let ix = outlet_ix(ctx.path(), ctx.outlets());
                ui.label(format!("{ix}"));
            });
        });
        let changed =
            node_inspector::socket_doc_rows(body, ctx.path(), &mut self.ty, &mut self.description);
        InspectorRowsResponse {
            changed,
            payloads: Vec::new(),
        }
    }

    fn socket_doc(&self, _: &Env<'_>, kind: SocketKind, _ix: usize) -> Option<SocketDoc> {
        match kind {
            SocketKind::Input => Some(super::inlet::socket_doc(
                &self.ty,
                &self.description,
                "output",
            )),
            SocketKind::Output => None,
        }
    }
}

/// Determine the outlet's index.
///
/// Outlets are ordered by their appearance within the graph indices.
fn outlet_ix(path: &[node::Id], outlets: &[node::Id]) -> usize {
    let id = path.last().expect("outlet must have non-outlet path");
    outlets
        .iter()
        .position(|in_id| id == in_id)
        .expect("outlet ID must exist")
}