Struct Dropdown 

pub struct Dropdown<T>
where
    T: 'static,
{ /* private fields */ }

A customizable dropdown view for selecting an item from a list.

The Dropdown struct provides several constructors, each offering different levels of customization and ease of use:

• Dropdown::new_rw: The simplest constructor, ideal for quick setup with minimal customization. It uses default views and assumes direct access to a signal that can be both read from and written to for driving the selection of an item.

• Dropdown::new: Similar to new_rw, but uses a read-only function for the active item, and requires that you manually provide an on_accept callback.

• Dropdown::custom: Offers full customization, letting you define custom view functions for both the main display and list items. Uses a read-only function for the active item and requires that you manually provide an on_accept callback.

• The dropdown also has methods Dropdown::main_view and Dropdown::list_item_view that let you override the main view function and list item view function respectively.

Choose the constructor that best fits your needs based on the level of customization required.

Usage with Enums

A common scenario is populating a dropdown menu from an enum. The widget-gallery example does this.

The below example creates a dropdown with three items, one for each character in our Character enum.

The strum crate is handy for this use case. This example uses the strum crate to create an iterator for our Character enum.

First, define the enum and implement Clone, strum::EnumIter, and Display on it:

use strum::IntoEnumIterator;

#[derive(Clone, strum::EnumIter)]
enum Character {
    Ori,
    Naru,
    Gumo,
}

impl std::fmt::Display for Character {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        match self {
            Self::Ori => write!(f, "Ori"),
            Self::Naru => write!(f, "Naru"),
            Self::Gumo => write!(f, "Gumo"),
        }
    }
}

Then, create a signal:

let selected = RwSignal::new(Character::Ori);

Finally, create the dropdown using one of the available constructors, like Dropdown::new_rw:

Dropdown::new_rw(selected, Character::iter())

Styling

You can modify the behavior of the dropdown through the CloseOnAccept property. If the property is set to true, the dropdown will automatically close when an item is selected. If the property is set to false, the dropdown will not automatically close when an item is selected. The default is true. Styling Example:

// root view
empty().style(|s| {
    s.class(dropdown::DropdownClass, |s| {
        s.set(dropdown::CloseOnAccept, false)
    })
});

Implementations

impl<T> Dropdown<T>

where T: Clone + PartialEq + Debug,

pub fn default_main_view(item: T) -> Box<dyn View>

where T: Display,

Creates a default main view for the dropdown.

This function generates a view that displays the given item as text, along with a chevron-down icon to indicate that it’s a dropdown.

pub fn custom<MF, I, LF, AIF>( active_item: AIF, main_view: MF, iterator: I, list_item_fn: LF, ) -> Dropdown<T>

where MF: Fn(T) -> Box<dyn View> + 'static, I: IntoIterator<Item = T> + 'static, LF: Fn(&T) -> Box<dyn View> + Clone + 'static, T: PartialEq + Clone + 'static, AIF: Fn() -> T + 'static,

Creates a new customizable dropdown.

You might want to use some of the simpler constructors like Dropdown::new or Dropdown::new_rw.

Example

let active_item = RwSignal::new(3);

Dropdown::custom(
    move || active_item.get(),
    |main_item| text(main_item).into_any(),
    1..=5,
    |list_item| text(list_item).into_any(),
)
.on_accept(move |item| active_item.set(item));

This function provides full control over the dropdown’s appearance and behavior by allowing custom view functions for both the main display and list items.

Arguments

• active_item - A function that returns the currently selected item.

• main_view - A function that takes a value of type T and returns an AnyView to be used as the main dropdown display.

• iterator - An iterator that provides the items to be displayed in the dropdown list.

• list_item_fn - A function that takes a value of type T and returns an AnyView to be used for each item in the dropdown list.

pub fn new<AIF, I>(active_item: AIF, iterator: I) -> Dropdown<T>

where AIF: Fn() -> T + 'static, I: IntoIterator<Item = T> + 'static, T: Clone + PartialEq + Display + 'static,

Creates a new dropdown with a read-only function for the active item.

Example

let active_item = RwSignal::new(3);

Dropdown::new(move || active_item.get(), 1..=5).on_accept(move |val| active_item.set(val));

This function is a convenience wrapper around Dropdown::new that uses default views for the main and list items.

See also Dropdown::new_rw.

Arguments

• active_item - A function that returns the currently selected item.

• iterator - An iterator that provides the items to be displayed in the dropdown list.

pub fn new_rw<AI, I>(active_item: AI, iterator: I) -> Dropdown<T>

where AI: SignalGet<T> + SignalUpdate<T> + Copy + 'static, I: IntoIterator<Item = T> + 'static, T: Clone + PartialEq + Display + 'static,

Creates a new dropdown with a read-write signal for the active item.

Example:

let dropdown_active_item = RwSignal::new(3);

Dropdown::new_rw(dropdown_active_item, 1..=5);

This function is a convenience wrapper around Dropdown::custom that uses default views for the main and list items.

Arguments

• active_item - A read-write signal representing the currently selected item. It must implement SignalGet<T> and SignalUpdate<T>.

• iterator - An iterator that provides the items to be displayed in the dropdown list.

pub fn main_view( self, main_view: impl Fn(T) -> Box<dyn View> + 'static, ) -> Dropdown<T>

Overrides the main view for the dropdown.

pub fn list_item_view( self, list_item_fn: impl Fn(&T) -> Box<dyn View> + 'static, ) -> Dropdown<T>

Overrides the list view for each item in the dropdown list.

pub fn show_list(self, show: impl Fn() -> bool + 'static) -> Dropdown<T>

Sets a reactive condition for showing or hiding the dropdown list.

Reactivity

The show function will be re-run whenever any signal it depends on changes.

pub fn on_accept(self, on_accept: impl Fn(T) + 'static) -> Dropdown<T>

Add a callback to be called when an item is selected from the dropdown.

This is the preferred way to handle dropdown selections, as it provides direct typed access to the selected value without needing to correctly specify the generics on DropdownAccept.

Example

dropdown.on_accept(|value| {
    println!("Selected: {value}");
})

pub fn on_open(self, on_open: impl Fn(bool) + 'static) -> Dropdown<T>

👎Deprecated:

use .on_event_stop(DropdownOpenChanged::listener(), |_, _|) directly instead

Add a callback function to be called when the dropdown is opened.

pub fn dropdown_style( self, style: impl Fn(DropdownCustomStyle) -> DropdownCustomStyle + 'static, ) -> Dropdown<T>

Sets the custom style properties of the Dropdown.

Trait Implementations

impl<T> CustomStylable<DropdownCustomStyle> for Dropdown<T>

where T: Clone + PartialEq + Debug,

type DV = Dropdown<T>

The view type that this custom stylable converts to.

fn custom_style(self, style: impl Fn(S) -> S + 'static) -> Self::DV

Applies custom styling to the view with access to specialized custom style methods.

impl<T> Drop for Dropdown<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> View for Dropdown<T>

where T: 'static + Clone + PartialEq + Debug,

fn id(&self) -> ViewId

fn debug_name(&self) -> Cow<'static, str>

fn style_pass(&mut self, cx: &mut StyleCx<'_>)

Use this method to style the view’s children.

fn update(&mut self, cx: &mut UpdateCx<'_>, state: Box<dyn Any>)

Use this method to react to changes in view-related state. You will usually send state to this hook manually using the View’s Id handle

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

Handles an event during the target and bubble phases of event propagation.

fn view_style(&self) -> Option<Style>

fn view_class(&self) -> Option<StyleClassRef>

fn event_capture(&mut self, _cx: &mut EventCx<'_>) -> EventPropagation

Handles an event during the capture phase of event propagation.

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

View-specific implementation. Called during paint traversal for this view. Children are painted automatically by Floem. Views should only paint their own content (backgrounds, borders, custom drawing).

fn post_paint(&mut self, cx: &mut PaintCx<'_>)