Struct fyrox_ui::scroll_bar::ScrollBar

pub struct ScrollBar {

    pub widget: Widget,
    pub min: f32,
    pub max: f32,
    pub value: f32,
    pub step: f32,
    pub orientation: Orientation,
    pub is_dragging: bool,
    pub offset: Vector2<f32>,
    pub increase: Handle<UiNode>,
    pub decrease: Handle<UiNode>,
    pub indicator: Handle<UiNode>,
    pub indicator_canvas: Handle<UiNode>,
    pub value_text: Handle<UiNode>,
    pub value_precision: usize,
}

Scroll bar is used to represent a value on a finite range. It has a thumb that shows the current value on on the bar. Usually it is used in pair with crate::scroll_panel::ScrollPanel to create something like crate::scroll_viewer::ScrollViewer widget. However, it could also be used to create sliders to show some value that lies within some range.

Example

A simple example of how to create a new ScrollBar could be something like this:

fn create_scroll_bar(ctx: &mut BuildContext) -> Handle<UiNode> {
    ScrollBarBuilder::new(WidgetBuilder::new())
        .with_min(0.0)
        .with_max(200.0)
        .with_value(123.0)
        .build(ctx)
}

It creates a horizontal scroll bar with 123.0 value and a range of [0.0..200.0]. To fetch the new value of the scroll bar, use ScrollBarMessage::Value message:

if message.destination() == scroll_bar
    && message.direction() == MessageDirection::FromWidget
{
    if let Some(ScrollBarMessage::Value(value)) = message.data() {
        println!("{}", value);
    }
}

Please note, that you need to explicitly filter messages by MessageDirection::FromWidget, because it’s the only direction that is used as an “indicator” that the value was accepted by the scroll bar.

Orientation

Scroll bar could be either horizontal (default) or vertical. You can select the orientation when building a scroll bar using ScrollBarBuilder::with_orientation method and provide a desired value from Orientation enum there.

Show values

By default, scroll bar does not show its actual value, you can turn it on using ScrollBarBuilder::show_value method with true as the first argument. To change rounding of the value, use ScrollBarBuilder::with_value_precision and provide the desired amount of decimal places there.

Step

Scroll bar provides arrows to change the current value using a fixed step value. You can change it using ScrollBarBuilder::with_step method.

Fields

widget: Widget

Base widget of the scroll bar.

min: f32

Min value of the scroll bar.

max: f32

Max value of the scroll bar.

value: f32

Current value of the scroll bar.

step: f32

Step of the scroll bar.

orientation: Orientation

Current orientation of the scroll bar.

is_dragging: bool

Internal flag, that could be used to check whether the scroll bar’s thumb is being dragged or not.

offset: Vector2<f32>

Internal mouse offset that is used for dragging purposes.

increase: Handle<UiNode>

A handle of the increase button.

decrease: Handle<UiNode>

A handle of the decrease button.

indicator: Handle<UiNode>

A handle of the indicator (thumb).

indicator_canvas: Handle<UiNode>

A handle of the canvas that is used for the thumb.

value_text: Handle<UiNode>

A handle of the crate::text::Text widget that is used to show the current value of the scroll bar.

value_precision: usize

Current value precison in decimal places.

Methods from Deref<Target = Widget>

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

Returns self handle of the widget.

pub fn name(&self) -> &str

Returns the name of the widget.

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

Sets the new name of the widget.

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

Returns the actual size of the widget after the full layout cycle.

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

Returns size of the widget without any layout or rendering transform applied.

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

Returns the actual global size of the widget after the full layout cycle.

pub fn set_min_size(&mut self, value: Vector2<f32>) -> &mut Self

Sets the new minimum size of the widget.

pub fn set_min_width(&mut self, value: f32) -> &mut Self

Sets the new minimum width of the widget.

pub fn set_min_height(&mut self, value: f32) -> &mut Self

Sets the new minimum height of the widget.

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

Sets the new minimum size of the widget.

pub fn min_width(&self) -> f32

Returns the minimum width of the widget.

pub fn min_height(&self) -> f32

Returns the minimum height of the widget.

pub fn is_drag_allowed(&self) -> bool

Return true if the dragging of the widget is allowed, false - otherwise.

pub fn is_drop_allowed(&self) -> bool

Return true if the dropping of other widgets is allowed on this widget, false - otherwise.

pub fn screen_to_local(&self, point: Vector2<f32>) -> Vector2<f32>

Maps the given point from screen to local widget’s coordinates.

pub fn invalidate_layout(&self)

Invalidates layout of the widget. WARNING: Do not use this method, unless you understand what you’re doing, it will cause new layout pass for this widget which could be quite heavy and doing so on every frame for multiple widgets will cause severe performance issues.

pub fn invalidate_measure(&self)

Invalidates measurement results of the widget. WARNING: Do not use this method, unless you understand what you’re doing, it will cause new measurement pass for this widget which could be quite heavy and doing so on every frame for multiple widgets will cause severe performance issues.

pub fn invalidate_arrange(&self)

Invalidates arrangement results of the widget. WARNING: Do not use this method, unless you understand what you’re doing, it will cause new arrangement pass for this widget which could be quite heavy and doing so on every frame for multiple widgets will cause severe performance issues.

pub fn is_hit_test_visible(&self) -> bool

Returns true if the widget is able to participate in hit testing, false - otherwise.

pub fn set_max_size(&mut self, value: Vector2<f32>) -> &mut Self

Sets the new maximum size of the widget.

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

Returns current maximum size of the widget.

pub fn max_width(&self) -> f32

Returns maximum width of the widget.

pub fn max_height(&self) -> f32

Return maximum height of the widget.

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

Sets new Z index for the widget. Z index defines the sorting (stable) index which will be used to “arrange” widgets in the correct order.

pub fn z_index(&self) -> usize

Returns current Z index of the widget.

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

Sets the new background of the widget.

pub fn background(&self) -> Brush

Returns current background of the widget.

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

Sets new foreground of the widget.

pub fn foreground(&self) -> Brush

Returns current foreground of the widget.

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

Sets new width of the widget.

pub fn width(&self) -> f32

Returns current width of the widget.

pub fn is_draw_on_top(&self) -> bool

Return true if the widget is set to be drawn on top of every other, normally drawn, widgets, false - otherwise.

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

Sets new height of the widget.

pub fn height(&self) -> f32

Returns current height of the widget.

pub fn set_desired_local_position(&mut self, pos: Vector2<f32>) -> &mut Self

Sets the desired local position of the widget.

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

Returns current screen-space position of the widget.

pub fn children(&self) -> &[Handle<UiNode>]

Returns a reference to the slice with the children widgets of this widget.

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

Returns current parent handle of the widget.

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

Sets new column of the widget. Columns are used only by crate::grid::Grid widget.

pub fn column(&self) -> usize

Returns current column of the widget. Columns are used only by crate::grid::Grid widget.

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

Sets new row of the widget. Rows are used only by crate::grid::Grid widget.

pub fn row(&self) -> usize

Returns current row of the widget. Rows are used only by crate::grid::Grid widget.

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

Returns the desired size of the widget.

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

Returns current desired local position of the widget.

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

Returns current screen-space bounds of the widget.

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

Returns local-space bounding rect of the widget.

pub fn visual_transform(&self) -> &Matrix3<f32>

Returns current visual transform of the widget.

pub fn render_transform(&self) -> &Matrix3<f32>

Returns current render transform of the widget.

pub fn layout_transform(&self) -> &Matrix3<f32>

Returns current layout transform of the widget.

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

Returns true, if the widget has a descendant widget with the specified handle, false - otherwise.

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

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

pub fn handle_routed_message( &mut self, _ui: &mut UserInterface, msg: &mut UiMessage )

Handles incoming WidgetMessages. This method must be called in crate::control::Control::handle_routed_message of any derived widgets!

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

Sets new vertical alignment of the widget.

pub fn vertical_alignment(&self) -> VerticalAlignment

Returns current vertical alignment of the widget.

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

Sets new horizontal alignment of the widget.

pub fn horizontal_alignment(&self) -> HorizontalAlignment

Returns current horizontal alignment of the widget.

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

Sets new margin of the widget.

pub fn margin(&self) -> Thickness

Returns current margin of the widget.

pub fn measure_override( &self, ui: &UserInterface, available_size: Vector2<f32> ) -> Vector2<f32>

Performs standard measurement of children nodes. It provides available size as a constraint and returns the maximum desired size across all children. As a result, this widget will have this size as its desired size to fit all the children nodes.

pub fn arrange_override( &self, ui: &UserInterface, final_size: Vector2<f32> ) -> Vector2<f32>

Performs standard arrangement of the children nodes of the widget. It uses input final size to make a final bounding rectangle to arrange children. As a result, all the children nodes will be located at the top-left corner of this widget and stretched to fit its bounds.

pub fn is_arrange_valid(&self) -> bool

Returns true if the current results of arrangement of the widget are valid, false - otherwise.

pub fn is_measure_valid(&self) -> bool

Returns true if the current results of measurement of the widget are valid, false - otherwise.

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

Returns current actual local position of the widget. It is valid only after layout pass!

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

Returns center point of the widget. It is valid only after layout pass!

pub fn is_globally_visible(&self) -> bool

Returns true of the widget is globally visible, which means that all its parents are visible as well as this widget. It is valid only after the first update of the layout, otherwise if will be always false.

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

Sets new visibility of the widget.

pub fn request_update_visibility(&self)

Requests (via event queue, so the request is deferred) the update of the visibility of the widget.

pub fn visibility(&self) -> bool

Returns current visibility of the widget.

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

Enables or disables the widget. Disabled widgets does not interact with user and usually greyed out.

pub fn enabled(&self) -> bool

Returns true if the widget if enabled, false - otherwise.

pub fn set_cursor(&mut self, cursor: Option<CursorIcon>)

Sets new cursor of the widget.

pub fn cursor(&self) -> Option<CursorIcon>

Returns current cursor of the widget.

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

Tries to fetch user-defined data of the specified type T.

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

Returns current clipping bounds of the widget. It is valid only after at least one layout pass.

pub fn set_opacity(&mut self, opacity: Option<f32>) -> &mut Self

Set new opacity of the widget. Opacity should be in [0.0..1.0] range.

pub fn opacity(&self) -> Option<f32>

Returns current opacity of the widget.

pub fn tooltip(&self) -> Option<RcUiNodeHandle>

Returns current tooltip handle of the widget.

pub fn set_tooltip(&mut self, tooltip: Option<RcUiNodeHandle>) -> &mut Self

Sets new tooltip handle of the widget (if any).

pub fn tooltip_time(&self) -> f32

Returns maximum available time to show the tooltip after the cursor was moved away from the widget.

pub fn set_tooltip_time(&mut self, tooltip_time: f32) -> &mut Self

Set the maximum available time to show the tooltip after the cursor was moved away from the widget.

pub fn context_menu(&self) -> Option<RcUiNodeHandle>

Returns current context menu of the widget.

pub fn set_context_menu( &mut self, context_menu: Option<RcUiNodeHandle> ) -> &mut Self

The context menu receives PopupMessages for being displayed, and so should support those.

Trait Implementations

impl Clone for ScrollBar

fn clone(&self) -> ScrollBar

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Control for ScrollBar

fn query_component(&self, type_id: TypeId) -> Option<&dyn Any>

Allows a widget to provide access to inner components. For example you can build your custom MyTree widget using engine’s Tree widget as a base. The engine needs to know whether the custom widget is actually extends functionality of some existing widget.

fn resolve(&mut self, node_map: &NodeHandleMapping)

This method will be called right after the widget was cloned. It is used remap handles in the widgets to their respective copies from the copied hierarchy.

fn arrange_override( &self, ui: &UserInterface, final_size: Vector2<f32> ) -> Vector2<f32>

This method is used to override arrangement step of the layout system. Arrangement step is used to commit the final location and size of the widget in local coordinates. It is done after the measurement step; when all desired sizes of every widget is known. This fact allows you to calculate final location and size of every child widget, based in their desired size. Usually this method is used in some panel widgets, that takes their children and arranges them in some specific way. For example, it may stack widgets on top of each other, or put them in a line with wrapping, etc.

fn handle_routed_message( &mut self, ui: &mut UserInterface, message: &mut UiMessage )

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

fn on_remove(&self, sender: &Sender<UiMessage>)

This method will be called before the widget is destroyed (dropped). At the moment, when this method is called, the widget is still in the widget graph and can be accessed via handles. It is guaranteed to be called once, and only if the widget is deleted via crate::widget::WidgetMessage::remove.

fn measure_override( &self, ui: &UserInterface, available_size: Vector2<f32> ) -> Vector2<f32>

This method is used to override measurement step of the layout system. It should return desired size of the widget (how many space it wants to occupy).

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

This method is used to emit drawing commands that will be used later to draw your widget on screen. Keep in mind that any emitted geometry (quads, lines, text, etc), will be used to perform hit test. In other words, all the emitted geometry will make your widget “clickable”. Widgets with no geometry emitted by this method are mouse input transparent.

fn update(&mut self, dt: f32, sender: &Sender<UiMessage>)

This method is called every frame and can be used to update internal variables of the widget, that can be used to animated your widget. Its main difference from other methods, is that it does not provide access to any other widget in the UI. Instead, you can only send messages to widgets to force them to change their state.

fn preview_message(&self, ui: &UserInterface, message: &mut UiMessage)

Used to react to a message (by producing another message) that was posted outside of current hierarchy. In other words this method is used when you need to “peek” a message before it’ll be passed into bubbling router. Most common use case is to catch messages from popups: popup in 99.9% cases is a child of root canvas and it won’t receive a message from a its logical parent during bubbling message routing. For example preview_message used in a dropdown list: dropdown list has two separate parts - a field with selected value and a popup for all possible options. Visual parent of the popup in this case is the root canvas, but logical parent is the dropdown list. Because of this fact, the field won’t receive any messages from popup, to solve this we use preview_message. This method is much more restrictive - it does not allow you to modify a node and ui, you can either request changes by sending a message or use internal mutability (Cell, RefCell, etc).

fn handle_os_event( &mut self, self_handle: Handle<UiNode>, ui: &mut UserInterface, 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 Deref for ScrollBar

type Target = Widget

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for ScrollBar

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

Mutably dereferences the value.