Struct DurationInput 

pub struct DurationInput<Msg> { /* private fields */ }

A length of time edited segment by segment: hours and minutes, optionally seconds, each followed by its unit in the active language: 1 h 30 min, 1 sa 30 dk.

It is built like TimeInput and handled the same way. The field takes focus as one control and one segment at a time is active: Left and Right move between segments, Up and Down change the active segment by one of its unit, and typing digits fills it, two digits a segment, moving on once the segment is complete. : and Space move on as well and Backspace sets the segment to zero. A click activates the segment under the pointer. The wheel changes the segment under the pointer, one unit per notch, without moving focus or the active segment; over a unit word it changes the segment the pointer was last over inside the field, or the active segment when there was none. The application owns the length.

Unlike a time of day a length does not wrap: stepping carries between the units (0 h 59 min up is 1 h 00 min), stops at zero going down and at 99 h 59 min 59 s going up. Minutes and seconds typed past 59 carry too, so 90 typed into the minutes reads 1 h 30 min.

Ctrl+A selects the whole length; then Ctrl+C copies it as written in the active language (1 h 30 min) and Ctrl+X copies it and sets the length to zero. Pasting sets the length from anything parse_duration reads (90 dk, 1 h 30 min, 2:15); other text is ignored, or sent to on_reject with the reason. A right click (or Shift+F10 and the menu key) opens the edit menu of TextInput with the same actions; Cut and Copy need the whole length selected.

A zero length is the field’s empty state: its digits are drawn as faint as the unit words until the pointer or focus is on the field. Where the words do not fit, the field shows the compact clock form, 1 : 30, with the same segments and keys.

Style keys, shared with TimeInput so both fields look alike: time-input (bg, fg) with states hover, focus, invalid, disabled; time-segment (bg, fg, bold) with selected for the active segment and active while a first digit waits for the second; time-separator (fg) for the unit words, the colons and the digits of a zero length at rest; text-input-selection (bg, fg) for the whole length selected. Language keys: quvyta.duration.* for the units and the reasons a paste was not read, quvyta.edit.* for the menu.

Implementations

impl<Msg> DurationInput<Msg>

pub fn new(value: Duration) -> Self

A field showing value as hours and minutes. Parts of a second are not shown and are dropped by the first change.

pub fn seconds(self, seconds: bool) -> Self

Shows and edits seconds too.

pub fn invalid(self, invalid: bool) -> Self

Marks the length as failing validation, such as a break longer than the session.

pub fn disabled(self, disabled: bool) -> Self

Greys the field out; it cannot be focused or changed.

pub fn on_change(self, message: impl Fn(Duration) -> Msg + 'static) -> Self

Message carrying the new length after every change.

pub fn on_reject(self, message: impl Fn(DurationError) -> Msg + 'static) -> Self

Message carrying why a pasted text could not be read, so the application can say so next to the field with DurationError::message. Without it such a paste is ignored and passed on, as in TimeInput.

Trait Implementations

impl<Msg: 'static> Widget<Msg> for DurationInput<Msg>

fn measure(&self, cx: &mut MeasureCx<'_>, available: Size) -> Size

The size the widget wants when it may use up to available.

fn paint(&self, cx: &mut PaintCx<'_>, area: Rect)

Draws the widget into area.

fn paint_overlay(&self, cx: &mut PaintCx<'_>, anchor: Rect)

Draws the widget’s overlay after the whole view was painted, when it asked for one with PaintCx::request_overlay. anchor is the area the widget was painted in.

fn event(&self, cx: &mut EventCx<'_, Msg>, event: &Event) -> bool

Handles input. Returns true when the event was used; unused key and scroll events bubble to the parent widget.

fn focusable(&self) -> bool

Whether the widget can take keyboard focus.

fn children(&self) -> &[Node<Msg>]

Child nodes, for widgets that contain other widgets.

fn children_mut(&mut self) -> &mut [Node<Msg>]

Mutable child nodes, used to assign ids.