Struct Node 

pub struct Node<T = ()> {

    pub id: NodeId,
    pub position: Position,
    pub size: Size,
    pub data: T,
    pub node_type: Option<String>,
    pub selected: bool,
    pub dragging: bool,
    pub selectable: bool,
    pub connectable: bool,
    pub deletable: bool,
    pub drag_handle: Option<String>,
    pub parent_node: Option<NodeId>,
    pub z_index: Option<i32>,
    pub hidden: bool,
    pub measured: Option<Size>,
    /* private fields */
}

Node in a flow graph

Fields

id: NodeId

position: Position

size: Size

data: T

node_type: Option<String>

selected: bool

dragging: bool

selectable: bool

connectable: bool

deletable: bool

drag_handle: Option<String>

parent_node: Option<NodeId>

z_index: Option<i32>

hidden: bool

measured: Option<Size>

Implementations

impl<T: Clone> Node<T>

pub fn new(id: impl Into<NodeId>, position: Position, data: T) -> Self

Create a new node

pub fn builder(id: impl Into<NodeId>) -> NodeBuilder<T>

where T: Default,

Create a builder for fluent construction

pub fn bounds(&self) -> Rect

Get the bounding rectangle

pub fn center(&self) -> Position

Get the center position

pub fn contains_point(&self, point: Position) -> bool

Check if point is inside the node

pub fn set_position(&mut self, position: Position)

Update position

pub fn set_size(&mut self, size: Size)

Update size

pub fn set_selected(&mut self, selected: bool)

Set selection state

pub fn set_dragging(&mut self, dragging: bool)

Set dragging state

pub fn map_data<U>(self, f: impl FnOnce(T) -> U) -> Node<U>

Convert to a different data type

impl<T> Node<T>

pub fn add_handle(&mut self, handle: Handle) -> Result<()>

Add a handle to this node

pub fn remove_handle(&mut self, handle_id: &HandleId) -> Result<Handle>

Remove a handle from this node

pub fn get_handle(&self, handle_id: &HandleId) -> Option<&Handle>

Get a handle by ID

pub fn handles(&self) -> &[Handle]

Get all handles on this node

pub fn handle_at_position( &self, point: Position, handle_size: f64, ) -> Option<&Handle>

Find handle at position relative to this node

pub fn source_handles(&self) -> impl Iterator<Item = &Handle>

Get source handles

pub fn target_handles(&self) -> impl Iterator<Item = &Handle>

Get target handles

impl Node<()>

pub fn simple(id: impl Into<NodeId>, position: Position) -> Self

Create a simple node with default data

impl<T: Default> Node<T>

pub fn with_default_data(id: impl Into<NodeId>, position: Position) -> Self

where T: Default + Clone,

Create a node with default data

Trait Implementations

impl<T: Clone> Clone for Node<T>

fn clone(&self) -> Node<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Node<T>

fn eq(&self, other: &Node<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for Node<T>