Struct FlowCanvas 

pub struct FlowCanvas {
    pub graph: Graph,
    pub history: Box<dyn HistoryProvider>,
    pub event_queue: Vec<FlowEvent>,
    pub port_offset_cache: PortLayoutCache,
    pub theme: FlowTheme,
    /* private fields */
}

Fields

graph: Graph

history: Box<dyn HistoryProvider>

event_queue: Vec<FlowEvent>

port_offset_cache: PortLayoutCache

theme: FlowTheme

Visual tokens for canvas chrome; plugins adjust via InitPluginContext::theme.

Implementations

impl FlowCanvas

pub fn new(graph: Graph, cx: &mut Context<'_, Self>) -> Self

pub fn builder<'a, 'b>( graph: Graph, ctx: &'a mut Context<'b, Self>, window: &'a Window, ) -> FlowCanvasBuilder<'a, 'b>

Examples found in repository

examples/extension.rs (line 35)

fn main() {
    Application::new().run(|cx| {
        let mut graph = Graph::new();

        graph
            .create_node("number")
            .position(100.0, 100.0)
            .size(300.0, 150.0)
            .output()
            .data(json!({ "label": "Number Node" }))
            .build(&mut graph);

        graph
            .create_node("")
            .position(300.0, 400.0)
            .input()
            .build(&mut graph);

        graph
            .create_node("undefined")
            .position(500.0, 500.0)
            .input()
            .output()
            .build(&mut graph);

        cx.open_window(WindowOptions::default(), |window, cx| {
            cx.new(|ctx| {
                FlowCanvas::builder(graph, ctx, window)
                    .plugins_core()
                    .plugin(SnapGuidesPlugin::new())
                    .plugin(ZoomControlsPlugin::new())
                    .plugin(FocusSelectionPlugin::new())
                    .plugin(FitAllGraphPlugin::new())
                    .plugin(ClipboardPlugin::new())
                    .plugin(ContextMenuPlugin::new())
                    .node_renderer("number", NumberNode {})
                    .build()
            })
        })
        .unwrap();
    });
}

examples/bench.rs (line 27)

fn main() {
    Application::new().run(|cx| {
        let mut graph = Graph::new();

        for j in 0..100 {
            for i in 0..100 {
                graph
                    .create_node("")
                    .position(200.0 * i as f32, 200.0 * j as f32)
                    .input()
                    .output()
                    .data(json!({ "label": format!("Node {}", i * 100 + j) }))
                    .build(&mut graph);
            }
        }

        let node_ids = graph.nodes().iter().map(|(id, _)| *id).collect::<Vec<_>>();

        generate_chain_edges(&mut graph, node_ids);

        cx.open_window(WindowOptions::default(), |window, cx| {
            cx.new(|ctx| {
                FlowCanvas::builder(graph, ctx, window)
                    .plugins_core()
                    .plugin(MinimapPlugin::new())
                    .plugin(ClipboardPlugin::new())
                    .plugin(ContextMenuPlugin::new())
                    .plugin(SelectAllViewportPlugin::new())
                    .plugin(AlignPlugin::new())
                    .plugin(FocusSelectionPlugin::new())
                    .plugin(FitAllGraphPlugin::new())
                    .plugin(SnapGuidesPlugin::new())
                    .plugin(ZoomControlsPlugin::new())
                    .build()
            })
        })
        .unwrap();
    });
}

examples/theme.rs (line 61)

fn main() {
    Application::new().run(|cx| {
        let mut graph = Graph::new();

        graph
            .create_node("")
            .position(100.0, 100.0)
            .output()
            .output()
            .data(json!({ "label": "Themed" }))
            .build(&mut graph);

        cx.open_window(WindowOptions::default(), |window, cx| {
            cx.new(|ctx| {
                FlowCanvas::builder(graph, ctx, window)
                    .plugin(DarkGridThemePlugin)
                    .plugin(MinimapPlugin::new())
                    .plugin(SelectionPlugin::new())
                    .plugin(NodeInteractionPlugin::new())
                    .plugin(SnapGuidesPlugin::new())
                    .plugin(ViewportPlugin::new())
                    .plugin(ZoomControlsPlugin::new())
                    .plugin(BackgroundPlugin::new())
                    .plugin(NodePlugin::new())
                    .plugin(PortInteractionPlugin::new())
                    .plugin(EdgePlugin::new())
                    .plugin(ClipboardPlugin::new())
                    .plugin(ContextMenuPlugin::new())
                    .plugin(SelectAllViewportPlugin::new())
                    .plugin(AlignPlugin::new())
                    .plugin(FocusSelectionPlugin::new())
                    .plugin(FitAllGraphPlugin::new())
                    .plugin(DeletePlugin::new())
                    .plugin(HistoryPlugin::new())
                    .build()
            })
        })
        .unwrap();
    });
}

examples/basic.rs (line 41)

fn main() {
    Application::new().run(|cx| {
        let mut graph = Graph::new();

        graph
            .create_node("")
            .position(100.0, 100.0)
            .output()
            .output()
            .output_with(PortPosition::Bottom, Size::new(px(20.0), px(20.0)))
            .output_at(PortPosition::Bottom)
            .data(json!({ "label": "Node 1" }))
            .build(&mut graph);

        graph
            .create_node("")
            .position(300.0, 400.0)
            .input()
            .input_at(PortPosition::Top)
            .input_at(PortPosition::Top)
            .output()
            .output_at(PortPosition::Bottom)
            .output_at(PortPosition::Bottom)
            .data(json!({ "label": "Node 2" }))
            .build(&mut graph);

        graph
            .create_node("")
            .position(500.0, 500.0)
            .input()
            .output()
            .data(json!({ "label": "Node 3" }))
            .build(&mut graph);

        cx.open_window(WindowOptions::default(), |window, cx| {
            cx.new(|ctx| {
                FlowCanvas::builder(graph, ctx, window)
                    .plugins_core()
                    .plugin(MinimapPlugin::new())
                    .plugin(SnapGuidesPlugin::new())
                    .plugin(ZoomControlsPlugin::new())
                    .plugin(ClipboardPlugin::new())
                    .plugin(ContextMenuPlugin::new())
                    .plugin(SelectAllViewportPlugin::new())
                    .plugin(AlignPlugin::new())
                    .plugin(FocusSelectionPlugin::new())
                    .plugin(FitAllGraphPlugin::new())
                    .build()
            })
        })
        .unwrap();
    });
}

pub fn handle_event(&mut self, event: FlowEvent, cx: &mut Context<'_, Self>)

Trait Implementations

impl Render for FlowCanvas

fn render( &mut self, window: &mut Window, this_cx: &mut Context<'_, Self>, ) -> impl IntoElement

Render this view into an element tree.