Struct ContextMenuPlugin 

pub struct ContextMenuPlugin { /* private fields */ }

Right-click menu on the canvas (empty area) or on a node. Optional ContextMenuCanvasExtra rows are appended after built-in canvas actions.

Implementations

impl ContextMenuPlugin

pub fn new() -> Self

Examples found in repository

examples/extension.rs (line 42)

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 31)

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 74)

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 47)

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 with_canvas_extras(canvas_extras: Vec<ContextMenuCanvasExtra>) -> Self

pub fn canvas_row( self, label: impl Into<SharedString>, on_select: impl for<'a> Fn(&mut PluginContext<'a>, Point<Pixels>) + Send + Sync + 'static, ) -> Self

Append a canvas-background row with a custom label (e.g. “Add node…” → show input in meili).

pub fn canvas_row_with_shortcut( self, label: impl Into<SharedString>, shortcut: impl Into<SharedString>, on_select: impl for<'a> Fn(&mut PluginContext<'a>, Point<Pixels>) + Send + Sync + 'static, ) -> Self

Same as Self::canvas_row but with a shortcut hint string shown on the right.

Trait Implementations

impl Plugin for ContextMenuPlugin

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

fn setup(&mut self, _ctx: &mut InitPluginContext<'_, '_>)

fn priority(&self) -> i32

fn render_layer(&self) -> RenderLayer

fn render(&mut self, ctx: &mut RenderContext<'_>) -> Option<AnyElement>

fn on_event( &mut self, event: &FlowEvent, ctx: &mut PluginContext<'_>, ) -> EventResult