Struct Graph

Source

pub struct Graph {
    pub ports: HashMap<PortId, Port>,
    pub edges: HashMap<EdgeId, Edge>,
    pub selected_edge: HashSet<EdgeId>,
    pub selected_node: HashSet<NodeId>,
    /* private fields */
}

Fields§

§ports: HashMap<PortId, Port>§edges: HashMap<EdgeId, Edge>§selected_edge: HashSet<EdgeId>§selected_node: HashSet<NodeId>

Implementations§

Source §

impl Graph

Source

pub fn new() -> Self

Examples found in repository ?

examples/extension.rs (line 10)

8fn main() {
9    Application::new().run(|cx| {
10        let mut graph = Graph::new();
11
12        graph
13            .create_node("number")
14            .position(100.0, 100.0)
15            .size(300.0, 150.0)
16            .output()
17            .data(json!({ "label": "Number Node" }))
18            .build(&mut graph);
19
20        graph
21            .create_node("")
22            .position(300.0, 400.0)
23            .input()
24            .build(&mut graph);
25
26        graph
27            .create_node("undefined")
28            .position(500.0, 500.0)
29            .input()
30            .output()
31            .build(&mut graph);
32
33        cx.open_window(WindowOptions::default(), |window, cx| {
34            cx.new(|ctx| {
35                FlowCanvas::builder(graph, ctx, window)
36                    .plugins_core()
37                    .plugin(SnapGuidesPlugin::new())
38                    .plugin(ZoomControlsPlugin::new())
39                    .plugin(FocusSelectionPlugin::new())
40                    .plugin(FitAllGraphPlugin::new())
41                    .plugin(ClipboardPlugin::new())
42                    .plugin(ContextMenuPlugin::new())
43                    .node_renderer("number", NumberNode {})
44                    .build()
45            })
46        })
47        .unwrap();
48    });
49}

More examples

Hide additional examples

examples/bench.rs (line 7)

5fn main() {
6    Application::new().run(|cx| {
7        let mut graph = Graph::new();
8
9        for j in 0..100 {
10            for i in 0..100 {
11                graph
12                    .create_node("")
13                    .position(200.0 * i as f32, 200.0 * j as f32)
14                    .input()
15                    .output()
16                    .data(json!({ "label": format!("Node {}", i * 100 + j) }))
17                    .build(&mut graph);
18            }
19        }
20
21        let node_ids = graph.nodes().iter().map(|(id, _)| *id).collect::<Vec<_>>();
22
23        generate_chain_edges(&mut graph, node_ids);
24
25        cx.open_window(WindowOptions::default(), |window, cx| {
26            cx.new(|ctx| {
27                FlowCanvas::builder(graph, ctx, window)
28                    .plugins_core()
29                    .plugin(MinimapPlugin::new())
30                    .plugin(ClipboardPlugin::new())
31                    .plugin(ContextMenuPlugin::new())
32                    .plugin(SelectAllViewportPlugin::new())
33                    .plugin(AlignPlugin::new())
34                    .plugin(FocusSelectionPlugin::new())
35                    .plugin(FitAllGraphPlugin::new())
36                    .plugin(SnapGuidesPlugin::new())
37                    .plugin(ZoomControlsPlugin::new())
38                    .build()
39            })
40        })
41        .unwrap();
42    });
43}

examples/theme.rs (line 49)

47fn main() {
48    Application::new().run(|cx| {
49        let mut graph = Graph::new();
50
51        graph
52            .create_node("")
53            .position(100.0, 100.0)
54            .output()
55            .output()
56            .data(json!({ "label": "Themed" }))
57            .build(&mut graph);
58
59        cx.open_window(WindowOptions::default(), |window, cx| {
60            cx.new(|ctx| {
61                FlowCanvas::builder(graph, ctx, window)
62                    .plugin(DarkGridThemePlugin)
63                    .plugin(MinimapPlugin::new())
64                    .plugin(SelectionPlugin::new())
65                    .plugin(NodeInteractionPlugin::new())
66                    .plugin(SnapGuidesPlugin::new())
67                    .plugin(ViewportPlugin::new())
68                    .plugin(ZoomControlsPlugin::new())
69                    .plugin(BackgroundPlugin::new())
70                    .plugin(NodePlugin::new())
71                    .plugin(PortInteractionPlugin::new())
72                    .plugin(EdgePlugin::new())
73                    .plugin(ClipboardPlugin::new())
74                    .plugin(ContextMenuPlugin::new())
75                    .plugin(SelectAllViewportPlugin::new())
76                    .plugin(AlignPlugin::new())
77                    .plugin(FocusSelectionPlugin::new())
78                    .plugin(FitAllGraphPlugin::new())
79                    .plugin(DeletePlugin::new())
80                    .plugin(HistoryPlugin::new())
81                    .build()
82            })
83        })
84        .unwrap();
85    });
86}

examples/basic.rs (line 7)

5fn main() {
6    Application::new().run(|cx| {
7        let mut graph = Graph::new();
8
9        graph
10            .create_node("")
11            .position(100.0, 100.0)
12            .output()
13            .output()
14            .output_with(PortPosition::Bottom, Size::new(px(20.0), px(20.0)))
15            .output_at(PortPosition::Bottom)
16            .data(json!({ "label": "Node 1" }))
17            .build(&mut graph);
18
19        graph
20            .create_node("")
21            .position(300.0, 400.0)
22            .input()
23            .input_at(PortPosition::Top)
24            .input_at(PortPosition::Top)
25            .output()
26            .output_at(PortPosition::Bottom)
27            .output_at(PortPosition::Bottom)
28            .data(json!({ "label": "Node 2" }))
29            .build(&mut graph);
30
31        graph
32            .create_node("")
33            .position(500.0, 500.0)
34            .input()
35            .output()
36            .data(json!({ "label": "Node 3" }))
37            .build(&mut graph);
38
39        cx.open_window(WindowOptions::default(), |window, cx| {
40            cx.new(|ctx| {
41                FlowCanvas::builder(graph, ctx, window)
42                    .plugins_core()
43                    .plugin(MinimapPlugin::new())
44                    .plugin(SnapGuidesPlugin::new())
45                    .plugin(ZoomControlsPlugin::new())
46                    .plugin(ClipboardPlugin::new())
47                    .plugin(ContextMenuPlugin::new())
48                    .plugin(SelectAllViewportPlugin::new())
49                    .plugin(AlignPlugin::new())
50                    .plugin(FocusSelectionPlugin::new())
51                    .plugin(FitAllGraphPlugin::new())
52                    .build()
53            })
54        })
55        .unwrap();
56    });
57}

Source

pub fn create_node(&self, node_type: &str) -> NodeBuilder

Examples found in repository ?

examples/extension.rs (line 13)

8fn main() {
9    Application::new().run(|cx| {
10        let mut graph = Graph::new();
11
12        graph
13            .create_node("number")
14            .position(100.0, 100.0)
15            .size(300.0, 150.0)
16            .output()
17            .data(json!({ "label": "Number Node" }))
18            .build(&mut graph);
19
20        graph
21            .create_node("")
22            .position(300.0, 400.0)
23            .input()
24            .build(&mut graph);
25
26        graph
27            .create_node("undefined")
28            .position(500.0, 500.0)
29            .input()
30            .output()
31            .build(&mut graph);
32
33        cx.open_window(WindowOptions::default(), |window, cx| {
34            cx.new(|ctx| {
35                FlowCanvas::builder(graph, ctx, window)
36                    .plugins_core()
37                    .plugin(SnapGuidesPlugin::new())
38                    .plugin(ZoomControlsPlugin::new())
39                    .plugin(FocusSelectionPlugin::new())
40                    .plugin(FitAllGraphPlugin::new())
41                    .plugin(ClipboardPlugin::new())
42                    .plugin(ContextMenuPlugin::new())
43                    .node_renderer("number", NumberNode {})
44                    .build()
45            })
46        })
47        .unwrap();
48    });
49}

More examples

Hide additional examples

examples/bench.rs (line 12)

5fn main() {
6    Application::new().run(|cx| {
7        let mut graph = Graph::new();
8
9        for j in 0..100 {
10            for i in 0..100 {
11                graph
12                    .create_node("")
13                    .position(200.0 * i as f32, 200.0 * j as f32)
14                    .input()
15                    .output()
16                    .data(json!({ "label": format!("Node {}", i * 100 + j) }))
17                    .build(&mut graph);
18            }
19        }
20
21        let node_ids = graph.nodes().iter().map(|(id, _)| *id).collect::<Vec<_>>();
22
23        generate_chain_edges(&mut graph, node_ids);
24
25        cx.open_window(WindowOptions::default(), |window, cx| {
26            cx.new(|ctx| {
27                FlowCanvas::builder(graph, ctx, window)
28                    .plugins_core()
29                    .plugin(MinimapPlugin::new())
30                    .plugin(ClipboardPlugin::new())
31                    .plugin(ContextMenuPlugin::new())
32                    .plugin(SelectAllViewportPlugin::new())
33                    .plugin(AlignPlugin::new())
34                    .plugin(FocusSelectionPlugin::new())
35                    .plugin(FitAllGraphPlugin::new())
36                    .plugin(SnapGuidesPlugin::new())
37                    .plugin(ZoomControlsPlugin::new())
38                    .build()
39            })
40        })
41        .unwrap();
42    });
43}

examples/theme.rs (line 52)

47fn main() {
48    Application::new().run(|cx| {
49        let mut graph = Graph::new();
50
51        graph
52            .create_node("")
53            .position(100.0, 100.0)
54            .output()
55            .output()
56            .data(json!({ "label": "Themed" }))
57            .build(&mut graph);
58
59        cx.open_window(WindowOptions::default(), |window, cx| {
60            cx.new(|ctx| {
61                FlowCanvas::builder(graph, ctx, window)
62                    .plugin(DarkGridThemePlugin)
63                    .plugin(MinimapPlugin::new())
64                    .plugin(SelectionPlugin::new())
65                    .plugin(NodeInteractionPlugin::new())
66                    .plugin(SnapGuidesPlugin::new())
67                    .plugin(ViewportPlugin::new())
68                    .plugin(ZoomControlsPlugin::new())
69                    .plugin(BackgroundPlugin::new())
70                    .plugin(NodePlugin::new())
71                    .plugin(PortInteractionPlugin::new())
72                    .plugin(EdgePlugin::new())
73                    .plugin(ClipboardPlugin::new())
74                    .plugin(ContextMenuPlugin::new())
75                    .plugin(SelectAllViewportPlugin::new())
76                    .plugin(AlignPlugin::new())
77                    .plugin(FocusSelectionPlugin::new())
78                    .plugin(FitAllGraphPlugin::new())
79                    .plugin(DeletePlugin::new())
80                    .plugin(HistoryPlugin::new())
81                    .build()
82            })
83        })
84        .unwrap();
85    });
86}

examples/basic.rs (line 10)

5fn main() {
6    Application::new().run(|cx| {
7        let mut graph = Graph::new();
8
9        graph
10            .create_node("")
11            .position(100.0, 100.0)
12            .output()
13            .output()
14            .output_with(PortPosition::Bottom, Size::new(px(20.0), px(20.0)))
15            .output_at(PortPosition::Bottom)
16            .data(json!({ "label": "Node 1" }))
17            .build(&mut graph);
18
19        graph
20            .create_node("")
21            .position(300.0, 400.0)
22            .input()
23            .input_at(PortPosition::Top)
24            .input_at(PortPosition::Top)
25            .output()
26            .output_at(PortPosition::Bottom)
27            .output_at(PortPosition::Bottom)
28            .data(json!({ "label": "Node 2" }))
29            .build(&mut graph);
30
31        graph
32            .create_node("")
33            .position(500.0, 500.0)
34            .input()
35            .output()
36            .data(json!({ "label": "Node 3" }))
37            .build(&mut graph);
38
39        cx.open_window(WindowOptions::default(), |window, cx| {
40            cx.new(|ctx| {
41                FlowCanvas::builder(graph, ctx, window)
42                    .plugins_core()
43                    .plugin(MinimapPlugin::new())
44                    .plugin(SnapGuidesPlugin::new())
45                    .plugin(ZoomControlsPlugin::new())
46                    .plugin(ClipboardPlugin::new())
47                    .plugin(ContextMenuPlugin::new())
48                    .plugin(SelectAllViewportPlugin::new())
49                    .plugin(AlignPlugin::new())
50                    .plugin(FocusSelectionPlugin::new())
51                    .plugin(FitAllGraphPlugin::new())
52                    .build()
53            })
54        })
55        .unwrap();
56    });
57}

Source

pub fn create_dege(&self) -> EdgeBuilder

Source

pub fn next_node_id(&self) -> NodeId

Source

pub fn next_port_id(&self) -> PortId

Source

pub fn next_edge_id(&self) -> EdgeId

Source

pub fn add_node(&mut self, node: Node)

Source

pub fn add_port(&mut self, port: Port)

Source

pub fn remove_port(&mut self, id: &PortId)

Source

pub fn nodes(&self) -> &HashMap<NodeId, Node>

Examples found in repository ?

examples/bench.rs (line 21)

5fn main() {
6    Application::new().run(|cx| {
7        let mut graph = Graph::new();
8
9        for j in 0..100 {
10            for i in 0..100 {
11                graph
12                    .create_node("")
13                    .position(200.0 * i as f32, 200.0 * j as f32)
14                    .input()
15                    .output()
16                    .data(json!({ "label": format!("Node {}", i * 100 + j) }))
17                    .build(&mut graph);
18            }
19        }
20
21        let node_ids = graph.nodes().iter().map(|(id, _)| *id).collect::<Vec<_>>();
22
23        generate_chain_edges(&mut graph, node_ids);
24
25        cx.open_window(WindowOptions::default(), |window, cx| {
26            cx.new(|ctx| {
27                FlowCanvas::builder(graph, ctx, window)
28                    .plugins_core()
29                    .plugin(MinimapPlugin::new())
30                    .plugin(ClipboardPlugin::new())
31                    .plugin(ContextMenuPlugin::new())
32                    .plugin(SelectAllViewportPlugin::new())
33                    .plugin(AlignPlugin::new())
34                    .plugin(FocusSelectionPlugin::new())
35                    .plugin(FitAllGraphPlugin::new())
36                    .plugin(SnapGuidesPlugin::new())
37                    .plugin(ZoomControlsPlugin::new())
38                    .build()
39            })
40        })
41        .unwrap();
42    });
43}

Source

pub fn node_order(&self) -> &Vec<NodeId>

Source

pub fn node_order_mut(&mut self) -> &mut Vec<NodeId>

Source

pub fn new_edge(&self) -> Edge

Source

pub fn add_edge(&mut self, edge: Edge)

Source

pub fn remove_edge(&mut self, edge_id: EdgeId)

Source

pub fn get_node(&self, id: &NodeId) -> Option<&Node>

Examples found in repository ?

examples/bench.rs (line 50)

45pub fn generate_chain_edges(graph: &mut Graph, node_ids: Vec<NodeId>) {
46    for window in node_ids.windows(2) {
47        let from = window[0];
48        let to = window[1];
49
50        let from_node = graph.get_node(&from).unwrap();
51        let to_node = graph.get_node(&to).unwrap();
52
53        let source_port = from_node.outputs[0];
54        let target_port = to_node.inputs[0];
55
56        EdgeBuilder::new()
57            .source(source_port)
58            .target(target_port)
59            .build(graph);
60    }
61}

Source

pub fn get_node_mut(&mut self, id: &NodeId) -> Option<&mut Node>

Source

pub fn remove_node(&mut self, id: &NodeId)

Source

pub fn add_selected_node(&mut self, id: NodeId, shift: bool)

Source

pub fn clear_selected_node(&mut self)

Source

pub fn remove_selected_node(&mut self) -> bool

Source

pub fn add_selected_edge(&mut self, id: EdgeId, shift: bool)

Source

pub fn clear_selected_edge(&mut self)

Source

pub fn remove_selected_edge(&mut self) -> bool

Source

pub fn selection_bounds(&self) -> Option<Bounds<Pixels>>

Source

pub fn selected_nodes_with_positions(&self) -> HashMap<NodeId, Point<Pixels>>

Source

pub fn hit_node(&self, mouse: Point<Pixels>) -> Option<NodeId>

Source

pub fn bring_node_to_front(&mut self, node_id: NodeId)

Source

pub fn ports_on_node_side( &self, node_id: NodeId, kind: PortKind, position: PortPosition, ) -> Vec<&Port>

Trait Implementations§

Source §

impl Clone for Graph

Source §

fn clone(&self) -> Graph

Returns a duplicate of the value. Read more

1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Source §

impl Debug for Graph

Source §

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Source §

impl<'de> Deserialize<'de> for Graph

Source §

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

Source §

impl Serialize for Graph

Source §

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Graph

§

impl RefUnwindSafe for Graph

§

impl Send for Graph

§

impl Sync for Graph

§

impl Unpin for Graph

§

impl UnsafeUnpin for Graph

§

impl UnwindSafe for Graph

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> CloneToUninit for T
where T: Clone,

Source §

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Source §

impl<T> Downcast for T
where T: Any,

Source §

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

Source §

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

Source §

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

Source §

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

Source §

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source §

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.

Source §

impl<T> DynClone for T
where T: Clone,

Source §

fn __clone_box(&self, _: Private) -> *mut ()

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Instrument for T

Source §

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Source §

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §