Struct conrod::graph::Graph [−] [src]

pub struct Graph {
    // some fields omitted
}

Stores the dynamic state of a UI tree of Widgets.

Methods

`impl Graph`
[src]

`fn new() -> Self`

A new empty Graph.

`fn with_node_capacity(n_nodes: usize) -> Self`

A new Graph with the given node capacity.

We know that there can be no more than three parents per node as the public API enforces a maximum of one Depth, Position and Graphic parent each. Thus, we can assume an edge capacity of exactly three times the given node capacity.

`fn clear(&mut self)`

Removes all Nodes and Edges from the Graph.

`fn node_count(&self) -> usize`

The total number of Nodes in the Graph.

`fn widget_count(&self) -> usize`

The total number of Node::Widgets in the Graph.

`fn edge_count(&self) -> usize`

The total number of Edges in the Graph.

`fn node_capacity(&self) -> usize`

The current capacity for the Graph's internal node Vec.

`fn convert_idx<I, J>(&self, idx: I) -> Option<J> where I: GraphIndex, J: GraphIndex`

Converts the given GraphIndex into an index of type J.

Returns None if there is no direct mapping from the given index to an index of type J.

`fn node_index<I: GraphIndex>(&self, idx: I) -> Option<NodeIndex>`

Get the NodeIndex for the given GraphIndex.

`fn widget_id<I: GraphIndex>(&self, idx: I) -> Option<Id>`

Get the WidgetId for the given GraphIndex.

`fn widget_index<I: GraphIndex>(&self, idx: I) -> Option<Index>`

Get the widget::Index for the given GraphIndex.

First attempts to produce a WidgetId, then tries to produce a NodeIndex.

`fn add_placeholder(&mut self) -> NodeIndex`

Add a new placeholder node and return it's NodeIndex into the Graph.

This method is used by the widget::set_widget function when some internal widget does not yet have it's own NodeIndex.

`fn node<I: GraphIndex>(&self, idx: I) -> Option<&Node>`

Borrow the node at the given GraphIndex if there is one.

`fn node_mut<I: GraphIndex>(&mut self, idx: I) -> Option<&mut Node>`

Mutably borrow the node at the given GraphIndex if there is one.

`fn edge(&self, idx: EdgeIndex) -> Option<&Edge>`

Borrow the edge at the given EdgeIndex if there is one.

`fn edge_mut(&mut self, idx: EdgeIndex) -> Option<&mut Edge>`

Mutably borrow the edge at the given EdgeIndex if there is one.

`fn edge_endpoints(&self, idx: EdgeIndex) -> Option<(NodeIndex, NodeIndex)>`

Return the parent and child nodes on either end of the Edge at the given index.

`fn widget<I: GraphIndex>(&self, idx: I) -> Option<&Container>`

If there is a Widget for the given index, return a reference to it.

`fn widget_mut<I: GraphIndex>(&mut self, idx: I) -> Option<&mut Container>`

If there is a Widget for the given Id, return a mutable reference to it.

`fn widget_scroll_state<I: GraphIndex>(&self, idx: I) -> Option<&State>`

If there is a scrollable widget at the given index, return a reference to the widget's scroll state.

`fn parents<I: GraphIndex>(&self, child: I) -> Parents`

A Walker type that may be used to step through the parents of the given child node.

`fn recursive_walk<I, F>(&self, start: I, recursive_fn: F) -> RecursiveWalk<F> where I: GraphIndex, F: FnMut(&Self, NodeIndex) -> Option<(EdgeIndex, NodeIndex)>`

A Walker type that recursively walks the Graph using the given recursive_fn.

Panics If the given start index does not exist within the Graph.

`fn edge_parent<I, J>(&self, idx: I, edge: Edge) -> Option<J> where I: GraphIndex, J: GraphIndex`

If the widget at the given index has some parent along an Edge of the given variant, return an index to it.

`fn depth_parent<I, J = NodeIndex>(&self, idx: I) -> Option<J> where I: GraphIndex, J: GraphIndex`

Return the index of the parent along the given widget's Depth Edge.

`fn position_parent<I, J = NodeIndex>(&self, idx: I) -> Option<J> where I: GraphIndex, J: GraphIndex`

Return the index of the parent along the given widget's Position Edge.

`fn graphic_parent<I, J = NodeIndex>(&self, idx: I) -> Option<J> where I: GraphIndex, J: GraphIndex`

Return the index of the parent along the given widget's Graphic Edge.

`fn depth_parent_recursion<I: GraphIndex>(&self, idx: I) -> RecursiveWalk<fn(&Graph, NodeIndex) -> Option<IndexPair>>`

A Walker type that recursively walks Depth parents starting from the given node.

`fn position_parent_recursion<I: GraphIndex>(&self, idx: I) -> RecursiveWalk<fn(&Graph, NodeIndex) -> Option<IndexPair>>`

A Walker type that recursively walks Position parents starting from the given node.

`fn graphic_parent_recursion<I: GraphIndex>(&self, idx: I) -> RecursiveWalk<fn(&Graph, NodeIndex) -> Option<IndexPair>>`

A Walker type that recursively walks Graphic parents starting from the given node.

`fn children<I: GraphIndex>(&self, parent: I) -> Children`

A Walker type that may be used to step through the children of the given parent node.

`fn depth_children<I: GraphIndex>(&self, idx: I) -> DepthChildren`

For walking the Depth children of the given parent node.

`fn position_children<I: GraphIndex>(&self, idx: I) -> PositionChildren`

For walking the Position children of the given parent node.