cosmic::widget::segmented_button

Type Alias MultiSelectModel

source
pub type MultiSelectModel = Model<MultiSelect>;
Expand description

A model for multi-select button selection.

Aliased Type§

struct MultiSelectModel { /* private fields */ }

Implementations

source§

impl Model<MultiSelect>

source

pub fn deactivate(&mut self, id: Entity)

Deactivates the item in the model.

source

pub fn active(&self) -> impl Iterator<Item = Entity> + '_

The IDs of the active items.

source§

impl<SelectionMode: Default> Model<SelectionMode>
where Self: Selectable,

source

pub fn activate(&mut self, id: Entity)

Activates the item in the model.

model.activate(id);
source

pub fn activate_position(&mut self, position: u16) -> bool

Activates the item at the given position, returning true if it was activated.

source

pub fn builder() -> ModelBuilder<SelectionMode>

Creates a builder for initializing a model.

let model = segmented_button::Model::builder()
    .insert(|b| b.text("Item A").activate())
    .insert(|b| b.text("Item B"))
    .insert(|b| b.text("Item C"))
    .build();
source

pub fn clear(&mut self)

Removes all items from the model.

Any IDs held elsewhere by the application will no longer be usable with the map. The generation is incremented on removal, so the stale IDs will return None for any attempt to get values from the map.

model.clear();
source

pub fn closable_set(&mut self, id: Entity, closable: bool)

Shows or hides the item’s close button.

source

pub fn contains_item(&self, id: Entity) -> bool

Check if an item exists in the map.

if model.contains_item(id) {
    println!("ID is still valid");
}
source

pub fn data<Data: 'static>(&self, id: Entity) -> Option<&Data>

Get an immutable reference to data associated with an item.

if let Some(data) = model.data::<String>(id) {
    println!("found string on {:?}: {}", id, data);
}
source

pub fn data_mut<Data: 'static>(&mut self, id: Entity) -> Option<&mut Data>

Get a mutable reference to data associated with an item.

source

pub fn data_set<Data: 'static>(&mut self, id: Entity, data: Data)

Associates data with the item.

There may only be one data component per Rust type.

model.data_set::<String>(id, String::from("custom string"));
source

pub fn data_remove<Data: 'static>(&mut self, id: Entity)

Removes a specific data type from the item.

model.data.remove::<String>(id);
source

pub fn divider_above(&self, id: Entity) -> Option<bool>

source

pub fn divider_above_set( &mut self, id: Entity, divider_above: bool, ) -> Option<bool>

source

pub fn divider_above_remove(&mut self, id: Entity) -> Option<bool>

source

pub fn enable(&mut self, id: Entity, enable: bool)

Enable or disable an item.

model.enable(id, true);
source

pub fn entity_at(&mut self, position: u16) -> Option<Entity>

Get the item that is located at a given position.

source

pub fn icon(&self, id: Entity) -> Option<&Icon>

Immutable reference to the icon associated with the item.

if let Some(icon) = model.icon(id) {
    println!("has icon: {:?}", icon);
}
source

pub fn icon_set(&mut self, id: Entity, icon: Icon) -> Option<Icon>

Sets a new icon for an item.

if let Some(old_icon) = model.icon_set(IconSource::from("new-icon")) {
    println!("previously had icon: {:?}", old_icon);
}
source

pub fn icon_remove(&mut self, id: Entity) -> Option<Icon>

Removes the icon from an item.

if let Some(old_icon) = model.icon_remove(id) {
    println!("previously had icon: {:?}", old_icon);
}
source

pub fn insert(&mut self) -> EntityMut<'_, SelectionMode>

Inserts a new item in the model.

let id = model.insert().text("Item A").icon("custom-icon").id();
source

pub fn is_active(&self, id: Entity) -> bool

Check if the given ID is the active ID.

source

pub fn is_closable(&self, id: Entity) -> bool

Whether the item should contain a close button.

source

pub fn is_enabled(&self, id: Entity) -> bool

Check if the item is enabled.

if model.is_enabled(id) {
    if let Some(text) = model.text(id) {
        println!("{text} is enabled");
    }
}
source

pub fn iter(&self) -> impl Iterator<Item = Entity> + '_

Iterates across items in the model in the order that they are displayed.

source

pub fn indent(&self, id: Entity) -> Option<u16>

source

pub fn indent_set(&mut self, id: Entity, indent: u16) -> Option<u16>

source

pub fn indent_remove(&mut self, id: Entity) -> Option<u16>

source

pub fn position(&self, id: Entity) -> Option<u16>

The position of the item in the model.

if let Some(position) = model.position(id) {
    println!("found item at {}", position);
}
source

pub fn position_set(&mut self, id: Entity, position: u16) -> Option<usize>

Change the position of an item in the model.

if let Some(new_position) = model.position_set(id, 0) {
    println!("placed item at {}", new_position);
}
source

pub fn position_swap(&mut self, first: Entity, second: Entity) -> bool

Swap the position of two items in the model.

Returns false if the swap cannot be performed.

if model.position_swap(first_id, second_id) {
    println!("positions swapped");
}
source

pub fn remove(&mut self, id: Entity)

Removes an item from the model.

The generation of the slot for the ID will be incremented, so this ID will no longer be usable with the map. Subsequent attempts to get values from the map with this ID will return None and failed to assign values.

source

pub fn text(&self, id: Entity) -> Option<&str>

Immutable reference to the text assigned to the item.

if let Some(text) = model.text(id) {
    println!("{:?} has text {text}", id);
}
source

pub fn text_set( &mut self, id: Entity, text: impl Into<Cow<'static, str>>, ) -> Option<Cow<'_, str>>

Sets new text for an item.

if let Some(old_text) = model.text_set(id, "Item B") {
    println!("{:?} had text {}", id, old_text)
}
source

pub fn text_remove(&mut self, id: Entity) -> Option<Cow<'static, str>>

Removes text from an item.

if let Some(old_text) = model.text_remove(id) {
    println!("{:?} had text {}", id, old_text);
}

Trait Implementations

source§

impl<SelectionMode: Default + Default> Default for Model<SelectionMode>

source§

fn default() -> Model<SelectionMode>

Returns the “default value” for a type. Read more
source§

impl Selectable for Model<MultiSelect>

source§

fn activate(&mut self, id: Entity)

Activate an item.
source§

fn deactivate(&mut self, id: Entity)

Deactivate an item.
source§

fn is_active(&self, id: Entity) -> bool

Checks if the item is active.