Struct InitPluginContext 

pub struct InitPluginContext<'a, 'b> {
    pub graph: &'a mut Graph,
    pub port_offset_cache: &'a mut PortLayoutCache,
    pub viewport: &'a mut Viewport,
    pub renderers: &'a mut RendererRegistry,
    pub gpui_ctx: &'a Context<'b, FlowCanvas>,
    pub drawable_size: Size<Pixels>,
    pub theme: &'a mut FlowTheme,
}

Fields

graph: &'a mut Graph

port_offset_cache: &'a mut PortLayoutCache

viewport: &'a mut Viewport

renderers: &'a mut RendererRegistry

gpui_ctx: &'a Context<'b, FlowCanvas>

drawable_size: Size<Pixels>

Drawable size from the window passed to FlowCanvas::builder (Window::viewport_size when build() runs).

theme: &'a mut FlowTheme

Canvas colors and strokes; mutate in Plugin::setup to customize chrome.

Implementations

impl<'a, 'b> InitPluginContext<'a, 'b>

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

pub fn create_edge(&self) -> EdgeBuilder

pub fn next_node_id(&self) -> NodeId

pub fn next_port_id(&self) -> PortId

pub fn next_edge_id(&self) -> EdgeId

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

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

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

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

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

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

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

pub fn new_edge(&self) -> Edge

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

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

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

pub fn clear_selected_node(&mut self)

pub fn remove_selected_node(&mut self) -> bool

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

pub fn clear_selected_edge(&mut self)

pub fn remove_selected_edge(&mut self) -> bool

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

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

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

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

pub fn world_to_screen(&self, p: Point<Pixels>) -> Point<Pixels>

pub fn screen_to_world(&self, p: Point<Pixels>) -> Point<Pixels>

pub fn is_node_visible(&self, node_id: &NodeId) -> bool

pub fn is_edge_visible(&self, edge: &Edge) -> bool

pub fn port_offset_cached( &self, node_id: &NodeId, port_id: &PortId, ) -> Option<Point<Pixels>>

pub fn cache_port_offset_with_node(&mut self, node_ids: &Vec<NodeId>)

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

pub fn cache_port_offset_with_port(&mut self, port_id: &PortId)