Struct Select 

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

A control showing one chosen option, which asks to be opened.

enum Message { Open, Chose(usize) }
Select::new(["Auto", "Manuell", "Av"], Message::Open).with_placeholder("Velg modus");

It does not open its own list, and nothing here can

To open a list a widget would have to create nodes from inside on_event. EventCtx can emit a message, ask for focus, ask for frames and ask to be revealed — it cannot add widgets, and giving it that power would let any widget restructure the tree from an event handler.

That is the same line already drawn three times: Tabs owns the selected index and not the pages, List owns the selection and not the viewport, and Ui::push_popup places a container the caller fills. A select that owned its list would be the first widget to own nodes, and the exception would be permanent.

So this widget emits an open message and the application opens the list — which open_select does in one call:

match message {
    Message::Open => { widgets::open_select(&mut ui, select, Message::Chose); }
    Message::Chose(index) => {
        ui.close_popup();
        ui.widget_mut::<Select<Message>>(select).unwrap().set_selected(Some(index));
    }
}

Everything the open list needs is already there: the popup flips near a screen edge, closes on Escape or a press outside — swallowing that press — and returns focus here when it goes.

Keyboard

Enter, Space and ArrowDown open it. Left and Right deliberately do not cycle the value: a select whose value changes as somebody tabs past it is the classic accidental-edit bug, and a closed control that quietly edits itself is worse than one that needs a second keystroke.

Implementations

impl<M> Select<M>

pub fn new( options: impl IntoIterator<Item = impl Into<String>>, message: M, ) -> Self

A select with nothing chosen, emitting message when it wants opening.

pub fn inert(options: impl IntoIterator<Item = impl Into<String>>) -> Self

A dropdown that emits nothing, for a chosen value the application reads rather than one it is told about.

The message a Select carries is its request to be opened — the popup is a scene the application pushes, since a widget cannot own other nodes — so one without a message is a closed control showing selected and nothing else. That is the honest meaning of an inert select, and it is what a form file wants for a value it displays.

A form that wants the list to open names on-change, and the engine wires it; see docs/forms.md.

pub fn with_placeholder(self, placeholder: impl Into<String>) -> Self

Sets the text shown when nothing is chosen.

pub fn with_selected(self, index: Option<usize>) -> Self

Sets the initially chosen option. Out of range chooses nothing.

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

Sets the control’s surface role.

pub fn with_style(self, style: TextStyle) -> Self

Sets the font and size.

pub const fn selected(&self) -> Option<usize>

The chosen index, if any.

pub fn selected_option(&self) -> Option<&str>

The chosen option’s text, or None when nothing is chosen.

pub fn set_selected(&mut self, index: Option<usize>)

Chooses an option without emitting anything. Out of range chooses nothing, as List::set_selected does and for the same reason: nothing chosen is a state this control can show.

pub fn options(&self) -> &[String]

The options, in order.

pub fn set_options( &mut self, options: impl IntoIterator<Item = impl Into<String>>, )

Replaces the options, dropping a selection that no longer exists.

pub fn set_style(&mut self, style: TextStyle)

Replaces the font and size.

pub const fn style(&self) -> TextStyle

The font and size the text draws in.

Trait Implementations

impl<M: Clone> Clone for Select<M>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Select<M>

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

Formats the value using the given formatter.

impl<M> Describe for Select<M>

const KIND: &'static str = "select"

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

const DOC: &'static str = "One choice out of many, picked from a dropdown list."

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: Clone + 'static> Widget<M> for Select<M>

fn focusable(&self) -> bool

A select with no options is not a tab stop: there is nothing to open.

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 measure(&self, ctx: &mut MeasureCtx<'_>, _offered: Offer) -> Measured

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

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 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.