Struct UserInterface

pub struct UserInterface {
    pub style: StyleResource,
    pub default_font: FontResource,
    pub double_click_time_slice: f32,
    pub tooltip_appear_delay: f32,
    /* private fields */
}

Fields

style: StyleResource

default_font: FontResource

double_click_time_slice: f32

tooltip_appear_delay: f32

Implementations

impl UserInterface

pub const SCREEN_SIZE: &'static str = "screen_size"

pub const NODES: &'static str = "nodes"

pub const VISUAL_DEBUG: &'static str = "visual_debug"

pub const ROOT_CANVAS: &'static str = "root_canvas"

pub const PICKED_NODE: &'static str = "picked_node"

pub const PREV_PICKED_NODE: &'static str = "prev_picked_node"

pub const CAPTURED_NODE: &'static str = "captured_node"

pub const KEYBOARD_FOCUS_NODE: &'static str = "keyboard_focus_node"

pub const CURSOR_POSITION: &'static str = "cursor_position"

pub const STYLE: &'static str = "style"

pub const STACK: &'static str = "stack"

pub const PICKING_STACK: &'static str = "picking_stack"

pub const DRAG_CONTEXT: &'static str = "drag_context"

pub const MOUSE_STATE: &'static str = "mouse_state"

pub const KEYBOARD_MODIFIERS: &'static str = "keyboard_modifiers"

pub const CURSOR_ICON: &'static str = "cursor_icon"

pub const NEED_UPDATE_GLOBAL_TRANSFORM: &'static str = "need_update_global_transform"

pub const DOUBLE_CLICK_TIME_SLICE: &'static str = "double_click_time_slice"

pub const TOOLTIP_APPEAR_DELAY: &'static str = "tooltip_appear_delay"

impl UserInterface

pub fn new(screen_size: Vector2<f32>) -> UserInterface

pub fn new_with_channel( sender: Sender<UiMessage>, receiver: Receiver<UiMessage>, screen_size: Vector2<f32>, ) -> UserInterface

pub fn set_tooltip_appear_delay(&mut self, appear_delay: f32)

pub fn tooltip_appear_delay(&self) -> f32

pub fn active_tooltip(&self) -> Option<&TooltipEntry>

pub fn keyboard_modifiers(&self) -> KeyboardModifiers

pub fn build_ctx(&mut self) -> BuildContext<'_>

pub fn capture_mouse(&mut self, node: Handle<UiNode>) -> bool

pub fn release_mouse_capture(&mut self)

pub fn get_drawing_context(&self) -> &DrawingContext

pub fn get_drawing_context_mut(&mut self) -> &mut DrawingContext

pub fn is_node_enabled(&self, handle: Handle<UiNode>) -> bool

pub fn screen_size(&self) -> Vector2<f32>

pub fn set_screen_size(&mut self, screen_size: Vector2<f32>)

pub fn invalidate_layout(&mut self)

pub fn update_layout(&mut self, screen_size: Vector2<f32>)

pub fn update( &mut self, screen_size: Vector2<f32>, dt: f32, switches: &UiUpdateSwitches, )

pub fn style(&self) -> &StyleResource

pub fn set_style(&mut self, style: StyleResource)

pub fn cursor(&self) -> CursorIcon

pub fn set_time(&mut self, elapsed_time: f32)

pub fn draw(&mut self) -> &DrawingContext

pub fn clipboard(&self) -> Option<Ref<'_, ClipboardContext>>

pub fn clipboard_mut(&self) -> Option<RefMut<'_, ClipboardContext>>

pub fn arrange_node( &self, handle: Handle<UiNode>, final_rect: &Rect<f32>, ) -> bool

pub fn measure_node( &self, handle: Handle<UiNode>, available_size: Vector2<f32>, ) -> bool

pub fn cursor_position(&self) -> Vector2<f32>

Cursor position in screen space coordinate system.

pub fn hit_test_unrestricted(&self, pt: Vector2<f32>) -> Handle<UiNode>

pub fn hit_test(&self, pt: Vector2<f32>) -> Handle<UiNode>

pub fn is_node_child_of( &self, node_handle: Handle<UiNode>, root_handle: Handle<UiNode>, ) -> bool

Checks if specified node is a child of some other node on root_handle. This method is useful to understand if some event came from some node down by tree.

pub fn sender(&self) -> Sender<UiMessage>

Returns instance of message sender which can be used to push messages into queue from other threads.

pub fn send_message(&self, message: UiMessage)

pub fn poll_message(&mut self) -> Option<UiMessage>

Extracts UI event one-by-one from common queue. Each extracted event will go to all available nodes first and only then will be moved outside of this method. This is one of most important methods which must be called each frame of your game loop, otherwise UI will not respond to any kind of events and simply speaking will just not work.

pub fn screen_to_root_canvas_space( &self, position: Vector2<f32>, ) -> Vector2<f32>

pub fn captured_node(&self) -> Handle<UiNode>

pub fn process_os_event(&mut self, event: &OsEvent) -> bool

Translates raw window event into some specific UI message. This is one of the most important methods of UI. You must call it each time you received a message from a window.

pub fn nodes(&self) -> &Pool<UiNode, WidgetContainer>

pub fn root(&self) -> Handle<UiNode>

pub fn take_reserve( &mut self, handle: Handle<UiNode>, ) -> (Ticket<UiNode>, UiNode)

Extracts a widget from the user interface and reserves its handle. It is used to temporarily take ownership over the widget, and then put the widget back using the returned ticket. Extracted widget is detached from its parent!

pub fn put_back( &mut self, ticket: Ticket<UiNode>, node: UiNode, ) -> Handle<UiNode>

Puts the widget back by the given ticket. Attaches it back to the root canvas of the user interface.

pub fn forget_ticket(&mut self, ticket: Ticket<UiNode>, node: UiNode) -> UiNode

Makes a widget handle vacant again.

pub fn take_reserve_sub_graph(&mut self, root: Handle<UiNode>) -> SubGraph

Extracts sub-graph starting from the given widget. All handles to extracted widgets becomes reserved and will be marked as “occupied”, an attempt to borrow a widget at such handle will result in panic!. Please note that root widget will be detached from its parent!

pub fn put_sub_graph_back(&mut self, sub_graph: SubGraph) -> Handle<UiNode>

Puts previously extracted sub-graph into the user interface. Handles to widgets will become valid again. After that you probably want to re-link returned handle with its previous parent.

pub fn forget_sub_graph(&mut self, sub_graph: SubGraph)

Forgets the entire sub-graph making handles to widgets invalid.

pub fn push_picking_restriction(&mut self, restriction: RestrictionEntry)

pub fn remove_picking_restriction(&mut self, node: Handle<UiNode>)

pub fn picking_restriction_stack(&self) -> &[RestrictionEntry]

pub fn drop_picking_restrictions(&mut self)

Removes all picking restrictions.

pub fn top_picking_restriction(&self) -> Option<RestrictionEntry>

pub fn drag_context(&self) -> &DragContext

pub fn link_nodes( &mut self, child_handle: Handle<UiNode>, parent_handle: Handle<UiNode>, in_front: bool, )

Links the specified child widget with the specified parent widget.

pub fn node_mut(&mut self, node_handle: Handle<UiNode>) -> &mut UiNode

pub fn try_get_node_mut( &mut self, node_handle: Handle<UiNode>, ) -> Option<&mut UiNode>

pub fn copy_node(&mut self, node: Handle<UiNode>) -> Handle<UiNode>

pub fn copy_node_to<Post>( &self, node: Handle<UiNode>, dest: &mut UserInterface, post_process_callback: &mut Post, ) -> (Handle<UiNode>, NodeHandleMap<UiNode>)

where Post: FnMut(Handle<UiNode>, Handle<UiNode>, &mut UiNode),

pub fn copy_node_with_limit( &mut self, node: Handle<UiNode>, limit: Option<usize>, ) -> Handle<UiNode>

pub fn save(&mut self, path: &Path) -> Result<Visitor, VisitError>

pub async fn load_from_file<P: AsRef<Path>>( path: P, resource_manager: ResourceManager, ) -> Result<Self, VisitError>

pub fn resolve(&mut self)

pub fn collect_used_resources(&self) -> FxHashSet<UntypedResource>

Collects all resources used by the user interface. It uses reflection to “scan” the contents of the user interface, so if some fields marked with #[reflect(hidden)] attribute, then such field will be ignored!

pub async fn load_from_file_ex<P: AsRef<Path>>( path: P, constructors: Arc<WidgetConstructorContainer>, resource_manager: ResourceManager, io: &dyn ResourceIo, ) -> Result<Self, VisitError>

Trait Implementations

impl AbstractSceneGraph for UserInterface

fn try_get_node_untyped( &self, handle: ErasedHandle, ) -> Option<&dyn AbstractSceneNode>

fn try_get_node_untyped_mut( &mut self, handle: ErasedHandle, ) -> Option<&mut dyn AbstractSceneNode>

impl BaseSceneGraph for UserInterface

type Prefab = UserInterface

type Node = UiNode

fn root(&self) -> Handle<Self::Node>

Returns a handle of the root node of the graph.

fn set_root(&mut self, root: Handle<Self::Node>)

Sets the new root of the graph. If used incorrectly, it may create isolated sub-graphs.

fn try_get(&self, handle: Handle<Self::Node>) -> Option<&Self::Node>

Tries to borrow a node, returns Some(node) if the handle is valid, None - otherwise.

fn try_get_mut(&mut self, handle: Handle<Self::Node>) -> Option<&mut Self::Node>

Tries to borrow a node, returns Some(node) if the handle is valid, None - otherwise.

fn is_valid_handle(&self, handle: Handle<Self::Node>) -> bool

Checks whether the given node handle is valid or not.

fn add_node(&mut self, node: Self::Node) -> Handle<Self::Node>

Adds a new node to the graph.

fn remove_node(&mut self, node: Handle<Self::Node>)

Destroys the node and its children recursively.

fn link_nodes(&mut self, child: Handle<Self::Node>, parent: Handle<Self::Node>)

Links specified child with specified parent.

fn unlink_node(&mut self, node_handle: Handle<Self::Node>)

Unlinks specified node from its parent and attaches it to root graph node.

fn isolate_node(&mut self, node_handle: Handle<Self::Node>)

Detaches the node from its parent, making the node unreachable from any other node in the graph.

fn node(&self, handle: Handle<Self::Node>) -> &Self::Node

Borrows a node by its handle.

fn node_mut(&mut self, handle: Handle<Self::Node>) -> &mut Self::Node

Borrows a node by its handle.

fn change_hierarchy_root( &mut self, prev_root: Handle<Self::Node>, new_root: Handle<Self::Node>, ) -> LinkScheme<Self::Node>

Reorders the node hierarchy so the new_root becomes the root node for the entire hierarchy under the prev_root node. For example, if we have this hierarchy and want to set C as the new root:

fn apply_link_scheme(&mut self, scheme: LinkScheme<Self::Node>)

Applies the given link scheme to the graph, basically reverting graph structure to the one that was before the call of Self::change_hierarchy_root.

fn remove_nodes(&mut self, nodes: &[Handle<Self::Node>])

Removes all the nodes from the given slice.

impl Clone for UserInterface

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstructorProvider<UiNode, UserInterface> for AbsmEventProvider

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for AlphaBar

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for AnimationBlendingStateMachine

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for AnimationPlayer

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl<T: BitContainer> ConstructorProvider<UiNode, UserInterface> for BitField<T>

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Border

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Button

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Canvas

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for CheckBox

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ColorField

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ColorGradientEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ColorGradientField

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ColorPicker

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ColorPoint

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ContextMenu

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for CurveEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Decorator

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for DockingManager

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for DropdownList

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Expander

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for FileBrowser

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for FileSelector

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for FileSelectorField

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Grid

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for HotKeyEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for HueBar

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Image

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Inspector

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for KeyBindingEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ListView

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ListViewItem

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Menu

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for MenuItem

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for MessageBox

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for NinePatch

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl<T: NumericType> ConstructorProvider<UiNode, UserInterface> for NumericUpDown<T>

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for PathEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Popup

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ProgressBar

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl<T: NumericType> ConstructorProvider<UiNode, UserInterface> for RangeEditor<T>

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl<T: NumericType> ConstructorProvider<UiNode, UserInterface> for RectEditor<T>

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for SaturationBrightnessField

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Screen

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ScrollBar

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ScrollPanel

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ScrollViewer

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for SearchBar

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Selector

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for StackPanel

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for TabControl

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Text

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for TextBox

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Thumb

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Tile

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for ToggleButton

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Tree

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for TreeRoot

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for UuidEditor

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl<T: NumericType, const D: usize> ConstructorProvider<UiNode, UserInterface> for VecEditor<T, D>

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for VectorImage

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for Window

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl ConstructorProvider<UiNode, UserInterface> for WrapPanel

fn constructor() -> GraphNodeConstructor<UiNode, UserInterface>

impl Debug for UserInterface

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

Formats the value using the given formatter.

impl Default for UserInterface

fn default() -> Self

Returns the “default value” for a type.

impl<'a> From<&'a mut UserInterface> for BuildContext<'a>

fn from(ui: &'a mut UserInterface) -> Self

Converts to this type from the input type.

impl PrefabData for UserInterface

type Graph = UserInterface

fn graph(&self) -> &Self::Graph

fn mapping(&self) -> NodeMapping

impl Reflect for UserInterface

where Self: 'static, Vector2<f32>: Reflect, Pool<UiNode, WidgetContainer>: Reflect, bool: Reflect, Handle<UiNode>: Reflect, StyleResource: Reflect, Vec<Handle<UiNode>>: Reflect, Vec<RestrictionEntry>: Reflect, DragContext: Reflect, MouseState: Reflect, KeyboardModifiers: Reflect, CursorIcon: Reflect, f32: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl ResourceData for UserInterface

fn type_uuid(&self) -> Uuid

Returns unique data type id.

fn save(&mut self, path: &Path) -> Result<(), Box<dyn Error>>

Saves the resource data a file at the specified path. This method is free to decide how the resource data is saved. This is needed, because there are multiple formats that defines various kinds of resources. For example, a rectangular texture could be saved into a bunch of formats, such as png, bmp, tga, jpg etc., but in the engine it is single Texture resource. In any case, produced file should be compatible with a respective resource loader.

fn can_be_saved(&self) -> bool

Returns true if the resource data can be saved to a file, false - otherwise. Not every resource type supports saving, for example there might be temporary resource type that is used only at runtime which does not need saving at all.

impl SceneGraph for UserInterface

fn pair_iter(&self) -> impl Iterator<Item = (Handle<Self::Node>, &Self::Node)>

Creates new iterator that iterates over internal collection giving (handle; node) pairs.

fn linear_iter(&self) -> impl Iterator<Item = &Self::Node>

Creates an iterator that has linear iteration order over internal collection of nodes. It does not perform any tree traversal!

fn linear_iter_mut(&mut self) -> impl Iterator<Item = &mut Self::Node>

Creates an iterator that has linear iteration order over internal collection of nodes. It does not perform any tree traversal!

fn try_get_of_type<T>(&self, handle: Handle<Self::Node>) -> Option<&T>

where T: 'static,

Tries to borrow a node and fetch its component of specified type.

fn try_get_mut_of_type<T>( &mut self, handle: Handle<Self::Node>, ) -> Option<&mut T>

where T: 'static,

Tries to mutably borrow a node and fetch its component of specified type.

fn has_component<T>(&self, handle: Handle<Self::Node>) -> bool

where T: 'static,

Tries to borrow a node by the given handle and checks if it has a component of the specified type.

fn find_map<C, T>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Option<(Handle<Self::Node>, &T)>

where C: FnMut(&Self::Node) -> Option<&T>, T: ?Sized,

Searches for a node down the tree starting from the specified node using the specified closure. Returns a tuple with a handle and a reference to the mapped value. If nothing is found, it returns None.

fn find_up<C>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Option<(Handle<Self::Node>, &Self::Node)>

where C: FnMut(&Self::Node) -> bool,

Searches for a node up the tree starting from the specified node using the specified closure. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find_handle_up<C>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Handle<Self::Node>

where C: FnMut(&Self::Node) -> bool,

The same as Self::find_up, but only returns node handle which will be Handle::NONE if nothing is found.

fn find_component_up<T>( &self, node_handle: Handle<Self::Node>, ) -> Option<(Handle<Self::Node>, &T)>

where T: 'static,

fn find_component<T>( &self, node_handle: Handle<Self::Node>, ) -> Option<(Handle<Self::Node>, &T)>

where T: 'static,

fn find_up_map<C, T>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Option<(Handle<Self::Node>, &T)>

where C: FnMut(&Self::Node) -> Option<&T>, T: ?Sized,

Searches for a node up the tree starting from the specified node using the specified closure. Returns a tuple with a handle and a reference to the mapped value. If nothing is found, it returns None.

fn find_by_name( &self, root_node: Handle<Self::Node>, name: &str, ) -> Option<(Handle<Self::Node>, &Self::Node)>

Searches for a node with the specified name down the tree starting from the specified node. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find_up_by_name( &self, root_node: Handle<Self::Node>, name: &str, ) -> Option<(Handle<Self::Node>, &Self::Node)>

Searches for a node with the specified name up the tree starting from the specified node. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find_by_name_from_root( &self, name: &str, ) -> Option<(Handle<Self::Node>, &Self::Node)>

Searches for a node with the specified name down the tree starting from the graph root. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find_handle_by_name_from_root(&self, name: &str) -> Handle<Self::Node>

fn find_from_root<C>( &self, cmp: &mut C, ) -> Option<(Handle<Self::Node>, &Self::Node)>

where C: FnMut(&Self::Node) -> bool,

Searches node using specified compare closure starting from root. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find<C>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Option<(Handle<Self::Node>, &Self::Node)>

where C: FnMut(&Self::Node) -> bool,

Searches for a node down the tree starting from the specified node using the specified closure. Returns a tuple with a handle and a reference to the found node. If nothing is found, it returns None.

fn find_handle<C>( &self, root_node: Handle<Self::Node>, cmp: &mut C, ) -> Handle<Self::Node>

where C: FnMut(&Self::Node) -> bool,

The same as Self::find, but only returns node handle which will be Handle::NONE if nothing is found.

fn relative_position( &self, child: Handle<Self::Node>, offset: isize, ) -> Option<(Handle<Self::Node>, usize)>

Returns position of the node in its parent children list and the handle to the parent. Adds given offset to the position. For example, if you have the following hierarchy:

fn traverse_iter( &self, from: Handle<Self::Node>, ) -> impl Iterator<Item = (Handle<Self::Node>, &Self::Node)>

Create a graph depth traversal iterator.

fn traverse_handle_iter( &self, from: Handle<Self::Node>, ) -> impl Iterator<Item = Handle<Self::Node>>

Create a graph depth traversal iterator.

fn restore_integrity<F>( &mut self, instantiate: F, ) -> Vec<(Handle<Self::Node>, Resource<Self::Prefab>)>

where F: FnMut(Resource<Self::Prefab>, &Self::Prefab, Handle<Self::Node>, &mut Self) -> (Handle<Self::Node>, NodeHandleMap<Self::Node>),

This method checks integrity of the graph and restores it if needed. For example, if a node was added in a parent asset, then it must be added in the graph. Alternatively, if a node was deleted in a parent asset, then its instance must be deleted in the graph.

fn restore_original_handles_and_inherit_properties<F>( &mut self, ignored_types: &[TypeId], before_inherit: F, )

where F: FnMut(&Self::Node, &mut Self::Node),

fn remap_handles( &mut self, instances: &[(Handle<Self::Node>, Resource<Self::Prefab>)], )

Maps handles in properties of instances after property inheritance. It is needed, because when a property contains node handle, the handle cannot be used directly after inheritance. Instead, it must be mapped to respective instance first.

impl TypeUuidProvider for UserInterface

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for UserInterface

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

Read or write this value, depending on whether Visitor::is_reading() is true or false.