Struct PluginContext 

pub struct PluginContext<'a> {
    pub graph: &'a mut Graph,
    pub port_offset_cache: &'a mut PortLayoutCache,
    pub viewport: &'a mut Viewport,
    pub renderers: &'a mut RendererRegistry,
    pub history: &'a mut dyn HistoryProvider,
    pub theme: &'a mut FlowTheme,
    /* private fields */
}

Fields

graph: &'a mut Graph

port_offset_cache: &'a mut PortLayoutCache

viewport: &'a mut Viewport

renderers: &'a mut RendererRegistry

history: &'a mut dyn HistoryProvider

theme: &'a mut FlowTheme

Canvas theme; change during event handling and call PluginContext::notify to redraw.

Implementations

impl<'a> PluginContext<'a>

pub fn new( graph: &'a mut Graph, port_offset_cache: &'a mut PortLayoutCache, viewport: &'a mut Viewport, interaction: &'a mut InteractionState, renderers: &'a mut RendererRegistry, sync_plugin: &'a mut Option<Box<dyn SyncPlugin + 'static>>, history: &'a mut dyn HistoryProvider, clipboard_subgraph: &'a mut Option<CopiedSubgraph>, theme: &'a mut FlowTheme, emit: &'a mut dyn FnMut(FlowEvent), notify: &'a mut dyn FnMut(), ) -> Self

pub fn start_interaction(&mut self, handler: impl Interaction + 'static)

pub fn cancel_interaction(&mut self)

pub fn has_interaction(&self) -> bool

pub fn notify(&mut self)

Tell GPUI that this entity has changed and observers of it should be notified.

pub fn emit(&mut self, event: FlowEvent)

pub fn has_sync_plugin(&self) -> bool

pub fn execute_command(&mut self, command: impl Command + 'static)

pub fn undo(&mut self)

pub fn redo(&mut self)

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_render(&self, id: &NodeId) -> Option<&dyn NodeRenderer>

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_all_node_port_offset(&mut self)

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)