Struct Slider 

pub struct Slider<'a, T, Message, Theme = Theme>
where
    Theme: Catalog,
{ /* private fields */ }

An horizontal bar and a handle that selects a single value from a range of values.

A Slider will try to fill the horizontal space of its container.

The Slider range of numeric values is generic and its step size defaults to 1 unit.

Note: Under the hood values are converted to/from f64 so only values representable exactly as an f64 are possible to select via the slider. However it is likely that the precision of the slider at these scales is already less than the precision lost from the f64 representation.

Example

use iced::widget::slider;

struct State {
   value: f32,
}

#[derive(Debug, Clone)]
enum Message {
    ValueChanged(f32),
}

fn view(state: &State) -> Element<'_, Message> {
    slider(0.0..=100.0, state.value, Message::ValueChanged).into()
}

fn update(state: &mut State, message: Message) {
    match message {
        Message::ValueChanged(value) => {
            state.value = value;
        }
    }
}

Implementations

impl<'a, T, Message, Theme> Slider<'a, T, Message, Theme>

where T: Copy + PartialOrd, Message: Clone, Theme: Catalog,

pub const DEFAULT_HEIGHT: f32 = 16.0

The default height of a Slider.

pub fn new<F>(range: RangeInclusive<T>, value: T, on_change: F) -> Self

where F: 'a + Fn(T) -> Message,

Creates a new Slider.

It expects:

• an inclusive range of possible values
• the current value of the Slider
• a function that will be called when the Slider is dragged. It receives the new value of the Slider and must produce a Message.

pub fn default(self, default: impl Into<T>) -> Self

Sets the optional default value for the Slider.

If set, the Slider will reset to this value when ctrl-clicked or command-clicked.

pub fn on_release(self, on_release: Message) -> Self

Sets the release message of the Slider. This is called when the mouse is released from the slider.

Typically, the user’s interaction with the slider is finished when this message is produced. This is useful if you need to spawn a long-running task from the slider’s result, where the default on_change message could create too many events.

pub fn width(self, width: impl Into<Length>) -> Self

Sets the width of the Slider.

pub fn height(self, height: impl Into<Pixels>) -> Self

Sets the height of the Slider.

pub fn step(self, step: impl AsPrimitive<f64>) -> Self

Sets the step size of the Slider.

pub fn shift_step(self, shift_step: impl AsPrimitive<f64>) -> Self

Sets the optional “shift” step for the Slider.

If set, this value is used as the step while the shift key is pressed.

pub fn style(self, style: impl Fn(&Theme, Status) -> Style + 'a) -> Self

where Theme::Class<'a>: From<StyleFn<'a, Theme>>,

Sets the style of the Slider.

pub fn class(self, class: impl Into<Theme::Class<'a>>) -> Self

Available on crate feature advanced only.

Sets the style class of the Slider.

Trait Implementations

impl<'a, T, Message, Theme, Renderer> From<Slider<'a, T, Message, Theme>> for Element<'a, Message, Theme, Renderer>

where T: Copy + AsPrimitive<f64> + FromPrimitive + 'a, Message: Clone + 'a, Theme: Catalog + 'a, Renderer: Renderer + 'a,

fn from( slider: Slider<'a, T, Message, Theme>, ) -> Element<'a, Message, Theme, Renderer>

Converts to this type from the input type.

impl<T, Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Slider<'_, T, Message, Theme>

where T: Copy + AsPrimitive<f64> + FromPrimitive, Message: Clone, Theme: Catalog, Renderer: Renderer,

fn tag(&self) -> Tag

Returns the Tag of the [Widget].

fn state(&self) -> State

Returns the State of the [Widget].

fn size(&self) -> Size<Length>

Returns the [Size] of the [Widget] in lengths.

fn layout( &mut self, _tree: &mut Tree, _renderer: &Renderer, limits: &Limits, ) -> Node

Returns the [layout::Node] of the [Widget].

fn update( &mut self, tree: &mut Tree, event: &Event, layout: Layout<'_>, cursor: Cursor, _renderer: &Renderer, shell: &mut Shell<'_, Message>, _viewport: &Rectangle, )

Processes a runtime Event.

fn draw( &self, _tree: &Tree, renderer: &mut Renderer, theme: &Theme, _style: &Style, layout: Layout<'_>, _cursor: Cursor, _viewport: &Rectangle, )

Draws the [Widget] using the associated Renderer.

fn mouse_interaction( &self, tree: &Tree, layout: Layout<'_>, cursor: Cursor, _viewport: &Rectangle, _renderer: &Renderer, ) -> Interaction

Returns the current [mouse::Interaction] of the [Widget].

fn diff(&mut self, tree: &mut Tree)

Reconciles the [Widget] with the provided [Tree].

fn operate( &mut self, _tree: &mut Tree, _layout: Layout<'_>, _renderer: &Renderer, _operation: &mut dyn Operation, )

Applies an [Operation] to the [Widget].

fn overlay<'a>( &'a mut self, _tree: &'a mut Tree, _layout: Layout<'a>, _renderer: &Renderer, _viewport: &Rectangle, _translation: Vector, ) -> Option<Element<'a, Message, Theme, Renderer>>

Returns the overlay of the [Widget], if there is any.