Struct rg3d_ui::decorator::Decorator

pub struct Decorator<M: 'static, C: 'static + Control<M, C>> { /* fields omitted */ }

A visual element that changes its appearance by listening specific events. It can has "pressed", "hover", "selected" or normal appearance:

Pressed - enables on mouse down message. Selected - decorator listens for messages from parent ItemContainer and if its ItemsControl has changed selection, then if current decorator is in subtree of ItemContainer it will be either selected or not (determined by selection of parent ItemContainer) Hovered - used when mouse is over decorator. Normal - used when not selected, pressed, hovered.

This element is widely used to provide some generic visual behaviour for various widgets. For example it used to decorate button, items in items control.

Methods from Deref<Target = Widget<M, C>>

pub fn handle(&self) -> Handle<UINode<M, C>>

pub fn name(&self) -> &str

pub fn set_name<P: AsRef<str>>(&mut self, name: P) -> &mut Self

pub fn actual_size(&self) -> Vec2

pub fn set_min_size(&mut self, value: Vec2) -> &mut Self

pub fn min_size(&self) -> Vec2

pub fn min_width(&self) -> f32

pub fn min_height(&self) -> f32

pub fn is_drag_allowed(&self) -> bool

pub fn is_drop_allowed(&self) -> bool

pub fn invalidate_layout(&self)

pub fn is_hit_test_visible(&self) -> bool

pub fn set_max_size(&mut self, value: Vec2) -> &mut Self

pub fn max_size(&self) -> Vec2

pub fn max_width(&self) -> f32

pub fn max_height(&self) -> f32

pub fn set_z_index(&mut self, z_index: usize) -> &mut Self

pub fn z_index(&self) -> usize

pub fn set_background(&mut self, brush: Brush) -> &mut Self

pub fn background(&self) -> Brush

pub fn set_foreground(&mut self, brush: Brush) -> &mut Self

pub fn foreground(&self) -> Brush

pub fn set_width(&mut self, width: f32) -> &mut Self

pub fn width(&self) -> f32

pub fn is_draw_on_top(&self) -> bool

pub fn set_height(&mut self, height: f32) -> &mut Self

pub fn height(&self) -> f32

pub fn set_desired_local_position(&mut self, pos: Vec2) -> &mut Self

pub fn screen_position(&self) -> Vec2

pub fn raw_copy(&self) -> Self

pub fn children(&self) -> &[Handle<UINode<M, C>>]

pub fn parent(&self) -> Handle<UINode<M, C>>

pub fn set_parent(&mut self, parent: Handle<UINode<M, C>>)

pub fn column(&self) -> usize

pub fn set_row(&mut self, row: usize) -> &mut Self

pub fn row(&self) -> usize

pub fn desired_size(&self) -> Vec2

pub fn desired_local_position(&self) -> Vec2

pub fn set_visibility(&mut self, visibility: bool) -> &mut Self

pub fn screen_bounds(&self) -> Rect<f32>

pub fn has_descendant(
    &self,
    node_handle: Handle<UINode<M, C>>,
    ui: &UserInterface<M, C>
) -> bool

pub fn find_by_criteria_up<Func: Fn(&UINode<M, C>) -> bool>(
    &self,
    ui: &UserInterface<M, C>,
    func: Func
) -> Handle<UINode<M, C>>

Searches a node up on tree starting from given root that matches a criteria defined by a given func.

pub fn handle_routed_message(
    &mut self,
    _ui: &mut UserInterface<M, C>,
    msg: &mut UiMessage<M, C>
)

pub fn set_vertical_alignment(
    &mut self,
    vertical_alignment: VerticalAlignment
) -> &mut Self

pub fn vertical_alignment(&self) -> VerticalAlignment

pub fn set_horizontal_alignment(
    &mut self,
    horizontal_alignment: HorizontalAlignment
) -> &mut Self

pub fn horizontal_alignment(&self) -> HorizontalAlignment

pub fn set_column(&mut self, column: usize) -> &mut Self

pub fn set_margin(&mut self, margin: Thickness) -> &mut Self

pub fn margin(&self) -> Thickness

pub fn measure_override(
    &self,
    ui: &UserInterface<M, C>,
    available_size: Vec2
) -> Vec2

pub fn arrange_override(
    &self,
    ui: &UserInterface<M, C>,
    final_size: Vec2
) -> Vec2

pub fn is_arrange_valid(&self) -> bool

pub fn is_measure_valid(&self) -> bool

pub fn actual_local_position(&self) -> Vec2

pub fn is_globally_visible(&self) -> bool

pub fn visibility(&self) -> bool

pub fn user_data_ref<T: 'static>(&self) -> &T

Trait Implementations

impl<M: 'static, C: 'static + Control<M, C>> Control<M, C> for Decorator<M, C>

fn raw_copy(&self) -> UINode<M, C>

fn resolve(&mut self, node_map: &NodeHandleMapping<M, C>)

fn measure_override(
    &self,
    ui: &UserInterface<M, C>,
    available_size: Vec2
) -> Vec2

fn arrange_override(&self, ui: &UserInterface<M, C>, final_size: Vec2) -> Vec2

fn arrange(&self, ui: &UserInterface<M, C>, final_rect: &Rect<f32>)

fn is_measure_valid(&self, ui: &UserInterface<M, C>) -> bool

fn is_arrange_valid(&self, ui: &UserInterface<M, C>) -> bool

fn measure(&self, ui: &UserInterface<M, C>, available_size: Vec2)

fn draw(&self, drawing_context: &mut DrawingContext)

fn update(&mut self, dt: f32)

fn handle_routed_message(
    &mut self,
    ui: &mut UserInterface<M, C>,
    message: &mut UiMessage<M, C>
)

Performs event-specific actions. Must call widget.handle_message()!

fn remove_ref(&mut self, handle: Handle<UINode<M, C>>)

Called when a node is deleted from container thus giving a chance to remove dangling handles which may cause panic.

fn preview_message(
    &mut self,
    _ui: &mut UserInterface<M, C>,
    _message: &mut UiMessage<M, C>
)

fn handle_os_event(
    &mut self,
    _self_handle: Handle<UINode<M, C>>,
    _ui: &mut UserInterface<M, C>,
    _event: &OsEvent
)

Provides a way to respond to OS specific events. Can be useful to detect if a key or mouse button was pressed. This method significantly differs from handle_message because os events are not dispatched - they'll be passed to this method in any case.

impl<M: 'static, C: 'static + Control<M, C>> Deref for Decorator<M, C>

type Target = Widget<M, C>

The resulting type after dereferencing.

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

Dereferences the value.

impl<M: 'static, C: 'static + Control<M, C>> DerefMut for Decorator<M, C>

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

Mutably dereferences the value.