Struct Slider 

pub struct Slider<M> { /* private fields */ }

A horizontal slider over min..=max.

The message carries the value itself rather than a fraction, so a setpoint reads as one:

enum Message { Setpoint(f32) }
Slider::new(16.0, 30.0, 21.5, Message::Setpoint).with_step(0.5);

Dragging keeps the pointer even when it leaves

This is the whole reason a slider belongs in a toolkit rather than in every application. The tree already routes moves to the pressed widget wherever the pointer goes — but it clears VisualState::PRESSED the moment the pointer leaves the widget, because that is what makes a button’s drag-off cancel. A slider that read its drag state from PRESSED would therefore stop tracking at exactly the edge it most needs to keep tracking past.

So the drag is a flag of this widget’s own, set on press and cleared on release, and the pressed look comes from that flag rather than from the tree’s. A drag that runs off either end clamps and keeps following, and comes back when the pointer does.

The one thing that flag assumes is that every press is eventually followed by a release. That is the input stream’s contract, and every backend here honours it; there is no event that means “your capture was taken away”.

Pressing the track jumps

Rather than stepping towards the press. A panel is touch-first, and a finger landing on a point of the track means go there — there is no cursor hovering to suggest anything else. It also makes the whole track a target instead of just the knob, which matters when the knob is 20 pixels wide and the finger is not.

Implementations

impl<M> Slider<M>

pub fn new(min: f32, max: f32, value: f32, message: fn(f32) -> M) -> Self

A slider over min..=max, starting at value.

A reversed range is put the right way round rather than refused: it is a caller’s argument order, not a state the widget has to model.

pub fn inert(min: f32, max: f32, value: f32) -> Self

A slider that emits nothing, for a value the application reads rather than reacts to.

pub fn with_step(self, step: f32) -> Self

Snaps to multiples of step from min.

Off by default, because a continuous slider is what a brightness or a volume wants. A step that is zero, negative or not a number is ignored rather than dividing by it.

pub fn with_role(self, role: Role) -> Self

Sets the colour role of the filled portion and the knob.

pub const fn value(&self) -> f32

The current value, always within the range and on a step if there is one.

pub const fn range(&self) -> (f32, f32)

The range, in order.

pub fn set_value(&mut self, value: f32)

Sets the value without emitting anything, clamped and snapped.

Silent for the same reason Checkbox::set_checked is: the message reports what a person did.

pub fn update(&mut self, value: f32) -> bool

Sets the value, reporting whether it actually changed.

pub fn set_range(&mut self, min: f32, max: f32)

Replaces the range, keeping the value inside it.

pub fn set_role(&mut self, role: Role)

Replaces the colour role.

pub const fn dragging(&self) -> bool

Whether a drag is in progress.

Trait Implementations

impl<M: Clone> Clone for Slider<M>

fn clone(&self) -> Slider<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Slider<M>

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

Formats the value using the given formatter.

impl<M> Describe for Slider<M>

const KIND: &'static str = "slider"

The name a form file uses for this widget. Kebab-case.

const DOC: &'static str = "A value in a range, dragged along a track."

One line saying what this widget is, for somebody choosing one.

const GROUP: Group = Group::Input

Which shelf of the catalogue this belongs on.

const ICON: &'static Icon

The widget’s glyph: a small portrait of the thing, for a palette to draw beside — or instead of — its name.

const PROPERTIES: &'static [Property]

Every property, in the order an inspector should show them.

fn get(&self, name: &str) -> Option<Value>

The current value.

fn apply(&mut self, name: &str, value: Value) -> Result<(), Mismatch>

Applies a value, reporting only what went wrong.

fn set(&mut self, name: &str, value: Value) -> Result<(), PropertyError>

Applies a value, reporting what went wrong and where.

impl<M: 'static> Widget<M> for Slider<M>

fn describe(&self) -> Option<&dyn DynDescribe>

This widget’s property description, if it has one.

fn describe_mut(&mut self) -> Option<&mut dyn DynDescribe>

The mutable half of describe.

fn paint(&self, ctx: &mut PaintCtx<'_>, canvas: &mut Pen<'_>)

Draws into canvas, which is already clipped to this widget’s bounds intersected with the damage region being repainted.

fn on_event(&mut self, event: &Event<'_>, ctx: &mut EventCtx<'_, M>) -> Handled

Reacts to an event routed to this widget.

fn accepts_pointer(&self) -> bool

Returns true if the pointer can hit this widget.

fn focusable(&self) -> bool

Returns true if this widget can take keyboard focus.

fn measure(&self, ctx: &mut MeasureCtx<'_>, offered: Offer) -> Measured

How big this widget would like to be, given what the caller can promise.

fn preserves_focus(&self) -> bool

Returns true if a press on this widget should leave focus exactly where it is.

fn animate(&mut self, now_ms: u64) -> Animation

Advances time-based state. Called only while this widget has asked to animate — see EventCtx::request_animation — and stops being called the moment it answers Wake::Never.

fn snap(&mut self, now_ms: u64) -> Animation

Lands whatever is in flight at its end state, without animating it.