Struct GraphView 

pub struct GraphView<T>
where
    T: GraphNode + 'static,
{ /* private fields */ }

Implementations

impl<T> GraphView<T>

where T: GraphNode,

pub fn new(layout: Layout, flags: Flags) -> Self

Creates a new GraphView control with the specified layout and flags.

Parameters

• layout: The layout configuration for positioning and sizing the GraphView
• flags: Combination of initialization flags that control the GraphView behavior:
  • Flags::ScrollBars: Enables scroll bars for navigating large graphs
  • Flags::SearchBar: Enables a search bar for finding nodes
  • Flags::MultiSelect: Enables multi-selection UI (checkbox column and related behavior)

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars | graphview::Flags::SearchBar
);

pub fn set_background(&mut self, backgroud_char: Character)

Sets the background of the GraphView to the specified character.

This method allows you to customize the background appearance of the GraphView. The background character will be used to fill the entire control area before drawing the graph nodes and edges.

Parameters

• backgroud_char: The character to use as background, including its color and formatting

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:30,h:10"),
    graphview::Flags::ScrollBars
);
graph_view.set_background(Character::new('·', Color::Gray, Color::Black, CharFlags::None));

pub fn clear_background(&mut self)

Clears the background character of the GraphView.

This method removes any previously set background character and resets the GraphView to use transparent foreground and background colors, allowing the default theme background to show through.

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:30,h:10"),
    graphview::Flags::None
);
graph_view.set_background(Character::new('*', Color::White, Color::Black, CharFlags::None));
graph_view.clear_background(); // Removes the background character

pub fn set_graph(&mut self, graph: Graph<T>)

Sets the graph data to be displayed in the GraphView.

This method replaces the current graph with a new one, updates the rendering options, and automatically arranges the nodes using the current arrangement method.

Parameters

• graph: The graph containing nodes and edges to be displayed

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);

let nodes = &["A", "B", "C", "D", "E"];
let edges = &[(0, 1), (0, 2), (1, 3), (2, 4)];
let graph = graphview::Graph::with_slices(nodes, edges, true);
graph_view.set_graph(graph);

pub fn set_edge_routing(&mut self, routing: EdgeRouting)

Sets the edge routing method for drawing connections between nodes.

This method determines how edges are drawn between nodes in the graph.

Parameters

• routing: The routing method to use:
  • EdgeRouting::Direct: Draw edges as straight lines between nodes
  • EdgeRouting::Orthogonal: Draw edges as orthogonal (right-angled) lines

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);
graph_view.set_edge_routing(graphview::EdgeRouting::Orthogonal);

pub fn set_edge_line_type(&mut self, line_type: LineType)

Sets the line type used for drawing edges between nodes.

This method controls the visual style of the lines used to draw edges. Different line types provide different visual appearances.

Parameters

• line_type: The line style to use:
  • LineType::Single: Single lines with Unicode box-drawing characters
  • LineType::Double: Double lines with Unicode box-drawing characters
  • LineType::SingleThick: Thick single lines
  • LineType::Border: Border-style thick lines
  • LineType::Ascii: ASCII characters (‘+’, ‘-’, ‘|’)
  • LineType::AsciiRound: ASCII with rounded corners
  • LineType::SingleRound: Unicode single lines with rounded corners
  • LineType::Braille: Double lines using Braille characters

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);
graph_view.set_edge_line_type(LineType::Double);

pub fn enable_edge_highlighting(&mut self, incoming: bool, outgoing: bool)

Enables or disables edge highlighting for the currently selected node.

When edge highlighting is enabled, edges connected to the currently selected node will be visually highlighted to make the connections more apparent.

Parameters

• incoming: Whether to highlight edges pointing to the current node
• outgoing: Whether to highlight edges originating from the current node

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);
// Highlight both incoming and outgoing edges
graph_view.enable_edge_highlighting(true, true);

// Only highlight outgoing edges
graph_view.enable_edge_highlighting(false, true);

pub fn enable_arrow_heads(&mut self, enabled: bool)

Enables or disables arrow heads on directed edges.

When enabled, directed edges will display arrow heads to indicate the direction of the connection between nodes.

Parameters

• enabled: Whether to show arrow heads on directed edges

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);
graph_view.enable_arrow_heads(true);

pub fn arrange_nodes(&mut self, method: ArrangeMethod)

Arranges the nodes in the graph using the specified layout algorithm.

This method automatically positions all nodes in the graph according to the chosen arrangement algorithm. The graph will be resized and repainted after the arrangement is complete.

Parameters

• method: The arrangement algorithm to use:
  • ArrangeMethod::None: No automatic arrangement (manual positioning)
  • ArrangeMethod::Grid: Arrange nodes in a regular grid with spacing
  • ArrangeMethod::GridPacked: Arrange nodes in a compact grid
  • ArrangeMethod::Circular: Arrange nodes in a circular pattern
  • ArrangeMethod::Hierarchical: Arrange nodes in hierarchical layers with spacing
  • ArrangeMethod::HierarchicalPacked: Arrange nodes in compact hierarchical layers
  • ArrangeMethod::ForceDirected: Use force-directed algorithm for natural positioning

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);

// Arrange nodes in a hierarchical layout
graph_view.arrange_nodes(graphview::ArrangeMethod::Hierarchical);

// Use force-directed layout for organic appearance
graph_view.arrange_nodes(graphview::ArrangeMethod::ForceDirected);

pub fn graph(&self) -> &Graph<T>

Returns an immutable reference to the underlying graph data.

This method provides read-only access to the graph structure, allowing you to query nodes, edges, and other graph properties.

Returns

A reference to the Graph<T> containing all nodes and edges

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);

let graph = graph_view.graph();
if let Some(node) = graph.current_node() {
    // do something with the current node
}

pub fn modify_graph<F>(&mut self, f: F)

where F: FnOnce(&mut EditableGraph<'_, T>),

Performs an in-place edit to the graph structure.

This method allows you to modify the graph’s nodes, edges, and current selection in a single atomic operation. The changes are tracked and applied to the graph, triggering a repaint and resize if necessary.

Parameters

• f: A closure that takes an EditableGraph reference and performs the desired edits.

Example

use appcui::prelude::*;

type MyNode = &'static str; // or any other type that implements the GraphNode trait

let mut graph_view: GraphView<MyNode> = GraphView::new(
    layout!("x:1,y:1,w:50,h:30"),
    graphview::Flags::ScrollBars
);

graph_view.modify_graph(|g| {
    let mut node = g.node(0).unwrap();
    node.set_value("New Value");
});

pub fn selected_count(&self) -> usize

Returns the number of selected nodes in the graph.

Methods from Deref<Target = ControlBase>

pub fn size(&self) -> Size

Returns the size of a control

pub fn client_size(&self) -> Size

Returns the client size of a control. In most cases it is the same as the size returned the method .get_size(). However, if the control has margins (for example in case of a Window) this size will be smaller.

pub fn set_size(&mut self, width: u16, height: u16)

Sets the new size for a control (to a specified size given by parameters width and height). Keep in mind that this method will change the existing layout to an a layout based on top-left corner (given by controls x and y coordonates) and the new provided size. Any dock or alignment properties will be removed. This method has no effect on a Desktop control.

pub fn position(&self) -> Point

Returns the relatove position (x,y) of the current control to its parent.

pub fn set_position(&mut self, x: i32, y: i32)

Sets the new position for a control (to a specified coordonate given by parameters x and y). Keep in mind that this method will change the existing layout to an a layout based on top-left corner (given by coordonates x and y) and the controls current width and height. Any dock or alignment properties will be removed. This method has no effect on a Desktop control.

pub fn set_enabled(&mut self, enabled: bool)

Sets the enabled state of a control. This method has no effect on a Desktop or a Window control that will always be enabled.

pub fn set_visible(&mut self, visible: bool)

Can be used to make a control visible or not. This method has no effect on the Desktop control that will always be visible.

Examples

use appcui::prelude::*;
let mut button = button!("'Click me',x:1,y:1,w:15");
button.set_visible(false); // this will hide the button

pub fn set_components_toolbar_margins(&mut self, left: u8, top: u8)

pub fn expanded_size(&self) -> Size

pub fn request_focus(&mut self) -> bool

A control can use this method to request focus

pub fn timer(&mut self) -> Option<&mut Timer>

pub fn is_visible(&self) -> bool

Returns true if the current control is visible or false otherwise

pub fn is_enabled(&self) -> bool

Returns true if the current control is enabled or false otherwise

pub fn is_active(&self) -> bool

Returns true if the current control is active (enabled and visible at the same time) or false otherwise

pub fn can_receive_input(&self) -> bool

Returns true if the current control can receive focus or false otherwise. If the control is not visible or it is disable this function will return false.

pub fn has_focus(&self) -> bool

Returns true if the current control has the focus or false otherwise

pub fn is_mouse_over(&self) -> bool

Returns true if the mouse cursor is over the current control or false otherwise

pub fn set_size_bounds( &mut self, min_width: u16, min_height: u16, max_width: u16, max_height: u16, )

Sets the bounds (minim and maxim sized allowed for a control). If the size of a control is outside its bounds, its size will be adjusted automatically. This method has no effect on a Desktop control.

pub fn set_hotkey<T>(&mut self, hotkey: T)

where Key: From<T>,

Sets the hot-key associated with a control. Use Key::None to clear an existing hotkey

pub fn hotkey(&self) -> Key

Returns the hotkey associated to a control or Key::None otherwise.

pub fn raise_custom_event(&self, class_hash: u64, event_id: u32)

pub fn request_update(&self)

pub fn register_menu(&mut self, menu: Menu) -> Handle<Menu>

pub fn show_menu( &self, handle: Handle<Menu>, x: i32, y: i32, max_size: Option<Size>, )

pub fn menuitem<T>( &self, menu_handle: Handle<Menu>, menuitem_handle: Handle<T>, ) -> Option<&T>

where T: MenuItem,

pub fn menuitem_mut<T>( &mut self, menu_handle: Handle<Menu>, menuitem_handle: Handle<T>, ) -> Option<&mut T>

where T: MenuItem,

pub fn appbar(&mut self) -> &mut AppBar

pub fn theme(&self) -> &Theme

pub fn update_layout(&mut self, layout: Layout)

Updates the layout of the current control

Trait Implementations

impl<T> AccordionEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_panel_changed( &mut self, _handle: Handle<Accordion>, _new_panel_index: u32, _old_panel_index: u32, ) -> EventProcessStatus

impl<T> AppBarEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_button_click(&mut self, _button: Handle<Button>)

Called when a button is clicked.

fn on_togglebutton_state_changed( &mut self, _togglebutton: Handle<ToggleButton>, _selected: bool, )

Called when a toggle button’s state changes.

fn on_switchbutton_state_changed( &mut self, _switchbutton: Handle<SwitchButton>, _selected: bool, )

Called when a switch button’s state changes.

fn on_update(&self, _appbar: &mut AppBar)

Called when the app bar needs to be updated. By default, all items are hidden and whenever the focus changes, the AppCUI framework hides all items and starts from the focus control and moves to its parent and calls this method. In this method you should call appbar.show(…) method to show the items you want to show.

impl<T> ButtonEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_pressed(&mut self, _handle: Handle<Button>) -> EventProcessStatus

impl<T> CharPickerEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_char_changed( &mut self, _handle: Handle<CharPicker>, _code: Option<char>, ) -> EventProcessStatus

impl<T> CheckBoxEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_status_changed( &mut self, _handle: Handle<CheckBox>, _checked: bool, ) -> EventProcessStatus

impl<T> ColorPickerEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_color_changed( &mut self, _handle: Handle<ColorPicker>, _color: Color, ) -> EventProcessStatus

impl<T> ComboBoxEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_selection_changed( &mut self, _handle: Handle<ComboBox>, ) -> EventProcessStatus

impl<T> Control for GraphView<T>

where T: GraphNode + 'static,

impl<T> CustomEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_event( &mut self, _handle: Handle<()>, _class_hash: u64, _event_id: u32, ) -> EventProcessStatus

impl<T> DatePickerEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_date_changed( &mut self, _handle: Handle<DatePicker>, _date: NaiveDate, ) -> EventProcessStatus

impl<T> Deref for GraphView<T>

where T: GraphNode + 'static,

type Target = ControlBase

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for GraphView<T>

where T: GraphNode + 'static,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> DesktopEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_start(&mut self)

fn on_close(&mut self) -> ActionRequest

fn on_update_window_count(&mut self, _count: usize)

impl<T> GenericBackgroundTaskEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_start(&mut self, _handle: Handle<()>) -> EventProcessStatus

fn on_update(&mut self, _handle: Handle<()>) -> EventProcessStatus

fn on_finish(&mut self, _handle: Handle<()>) -> EventProcessStatus

fn on_query(&mut self, _handle: Handle<()>) -> EventProcessStatus

impl<T> GenericCommandBarEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_update_commandbar(&self, _commandbar: &mut CommandBar)

fn on_event(&mut self, _command_id: u32)

impl<T> GenericDropDownListEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_selection_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

impl<T> GenericGraphViewEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_current_node_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

fn on_node_action( &mut self, _handle: Handle<()>, _type_id: TypeId, _node_index: usize, ) -> EventProcessStatus

fn on_request_new_node( &mut self, _handle: Handle<()>, _type_id: TypeId, _p: Point, ) -> EventProcessStatus

fn on_request_new_edge( &mut self, _handle: Handle<()>, _type_id: TypeId, _from: u32, _to: u32, ) -> EventProcessStatus

fn on_selection_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

impl<T> GenericListViewEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_current_item_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

fn on_group_collapsed( &mut self, _handle: Handle<()>, _type_id: TypeId, _group: Group, ) -> EventProcessStatus

fn on_group_expanded( &mut self, _handle: Handle<()>, _type_id: TypeId, _group: Group, ) -> EventProcessStatus

fn on_selection_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

fn on_item_action( &mut self, _handle: Handle<()>, _type_id: TypeId, _index: usize, ) -> EventProcessStatus

impl<T> GenericMenuEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_menu_open(&self, _menu: &mut Menu)

Called when a menu is about to be opened.

fn on_command( &mut self, _menu: Handle<Menu>, _item: Handle<Command>, _command: u32, )

Called when a command menu item is activated.

fn on_check( &mut self, _menu: Handle<Menu>, _item: Handle<CheckBox>, _command: u32, _checked: bool, )

Called when a checkbox menu item’s state changes.

fn on_select( &mut self, _menu: Handle<Menu>, _item: Handle<SingleChoice>, _command: u32, )

Called when a single choice menu item is selected.

impl<T> GenericNumericSelectorEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_value_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

impl<T> GenericSelectorEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_selection_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

impl<T> GenericTreeViewEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_current_item_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, _current_item: Handle<()>, ) -> EventProcessStatus

fn on_item_collapsed( &mut self, _handle: Handle<()>, _type_id: TypeId, _item: Handle<()>, _recursive: bool, ) -> EventProcessStatus

fn on_item_expanded( &mut self, _handle: Handle<()>, _type_id: TypeId, _item: Handle<()>, _recursive: bool, ) -> EventProcessStatus

fn on_selection_changed( &mut self, _handle: Handle<()>, _type_id: TypeId, ) -> EventProcessStatus

fn on_item_action( &mut self, _handle: Handle<()>, _type_id: TypeId, _current_item: Handle<()>, ) -> EventProcessStatus

impl<T> KeySelectorEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_key_changed( &mut self, _handle: Handle<KeySelector>, _new_key: Key, _old_key: Key, ) -> EventProcessStatus

impl<T> ListBoxEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_current_item_changed( &mut self, _handle: Handle<ListBox>, _index: usize, ) -> EventProcessStatus

fn on_item_checked( &mut self, _handle: Handle<ListBox>, _index: usize, _checked: bool, ) -> EventProcessStatus

impl<T> MarkdownEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_external_link( &mut self, _handle: Handle<Markdown>, _link: &str, ) -> EventProcessStatus

fn on_backspace_navigation( &mut self, _handle: Handle<Markdown>, ) -> EventProcessStatus

impl<T> NotDesktop for GraphView<T>

where T: GraphNode + 'static,

impl<T> NotWindow for GraphView<T>

where T: GraphNode + 'static,

impl<T> OnDefaultAction for GraphView<T>

where T: GraphNode + 'static,

fn on_default_action(&mut self)

impl<T> OnExpand for GraphView<T>

where T: GraphNode + 'static,

fn on_expand(&mut self, _direction: ExpandedDirection)

fn on_pack(&mut self)

impl<T> OnFocus for GraphView<T>

where T: GraphNode,

fn on_focus(&mut self)

fn on_lose_focus(&mut self)

impl<T> OnKeyPressed for GraphView<T>

where T: GraphNode,

fn on_key_pressed(&mut self, key: Key, character: char) -> EventProcessStatus

impl<T> OnMouseEvent for GraphView<T>

where T: GraphNode,

fn on_mouse_event(&mut self, event: &MouseEvent) -> EventProcessStatus

impl<T> OnPaint for GraphView<T>

where T: GraphNode,

fn on_paint(&self, surface: &mut Surface, theme: &Theme)

impl<T> OnResize for GraphView<T>

where T: GraphNode,

fn on_resize(&mut self, _: Size, _: Size)

impl<T> OnSiblingSelected for GraphView<T>

where T: GraphNode + 'static,

fn on_sibling_selected(&mut self, _handle: Handle<()>)

impl<T> OnThemeChanged for GraphView<T>

where T: GraphNode + 'static,

fn on_theme_changed(&mut self, _theme: &Theme)

impl<T> OnWindowRegistered for GraphView<T>

where T: GraphNode + 'static,

fn on_registered(&mut self)

impl<T> PasswordEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_accept(&mut self, _handle: Handle<Password>) -> EventProcessStatus

fn on_cancel(&mut self, _handle: Handle<Password>) -> EventProcessStatus

impl<T> PathFinderEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_path_updated(&mut self, _handle: Handle<PathFinder>) -> EventProcessStatus

impl<T> RadioBoxEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_selected(&mut self, _handle: Handle<RadioBox>) -> EventProcessStatus

impl<T> RichTextFieldEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_validate( &mut self, _handle: Handle<RichTextField>, _text: &str, ) -> EventProcessStatus

fn on_text_changed( &mut self, _handle: Handle<RichTextField>, ) -> EventProcessStatus

impl<T> TabEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_tab_changed( &mut self, _handle: Handle<Tab>, _new_tab_index: u32, _old_tabl_index: u32, ) -> EventProcessStatus

impl<T> TextFieldEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_validate( &mut self, _handle: Handle<TextField>, _text: &str, ) -> EventProcessStatus

fn on_text_changed(&mut self, _handle: Handle<TextField>) -> EventProcessStatus

impl<T> ThreeStateBoxEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_status_changed( &mut self, _handle: Handle<ThreeStateBox>, _state: State, ) -> EventProcessStatus

impl<T> TimePickerEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_time_changed( &mut self, _handle: Handle<TimePicker>, _time: NaiveTime, ) -> EventProcessStatus

impl<T> TimerEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_start(&mut self) -> EventProcessStatus

fn on_resume(&mut self, _ticks: u64) -> EventProcessStatus

fn on_pause(&mut self, _ticks: u64) -> EventProcessStatus

fn on_update(&mut self, _ticks: u64) -> EventProcessStatus

impl<T> ToggleButtonEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_selection_changed( &mut self, _handle: Handle<ToggleButton>, _selected: bool, ) -> EventProcessStatus

impl<T> ToolBarEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_button_clicked(&mut self, _handle: Handle<Button>) -> EventProcessStatus

Called when a toolbar button is clicked.

fn on_checkbox_clicked( &mut self, _handle: Handle<CheckBox>, _checked: bool, ) -> EventProcessStatus

Called when a toolbar checkbox is clicked, changing its checked state.

fn on_choice_selected( &mut self, _handle: Handle<SingleChoice>, ) -> EventProcessStatus

Called when a toolbar single choice item is selected.

impl<T> WindowEvents for GraphView<T>

where T: GraphNode + 'static,

fn on_layout_changed(&mut self, _old_layout: Rect, _new_layout: Rect)

fn on_activate(&mut self)

called whenver the window receives focus

fn on_deactivate(&mut self)

called whenever the window loses focus.

fn on_accept(&mut self)

called whenever the ENTER key is intercepted by the Window For modal windows the behavior should be to use .exit_with(...) method to exit. for a regular (non-modal) window this callback is never called)

fn on_cancel(&mut self) -> ActionRequest

called whenever the ESC key is interpreted by the Window