Struct cosmic::widget::segmented_button::Model

pub struct Model<SelectionMode: Default> { /* private fields */ }

The model held by the application, containing the unique IDs and data of each inserted item.

Implementations

impl Model<SingleSelect>

pub fn active_data<Data: 'static>(&self) -> Option<&Data>

Get an immutable reference to the data associated with the active item.

pub fn active_data_mut<Data: 'static>(&mut self) -> Option<&mut Data>

Get a mutable reference to the data associated with the active item.

pub fn deactivate(&mut self)

Deactivates the active item.

pub fn active(&self) -> Entity

The ID of the active item.

impl Model<MultiSelect>

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

Deactivates the item in the model.

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

The IDs of the active items.

impl<SelectionMode: Default> Model<SelectionMode>

where Self: Selectable,

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

Activates the item in the model.

model.activate(id);

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

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

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();

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();

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

Shows or hides the item’s close button.

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");
}

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);
}

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

Get a mutable reference to data associated with an item.

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"));

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

Removes a specific data type from the item.

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

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

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

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

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

Enable or disable an item.

model.enable(id, true);

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

Get the item that is located at a given position.

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);
}

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);
}

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);
}

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();

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

Check if the given ID is the active ID.

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

Whether the item should contain a close button.

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");
    }
}

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

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

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

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

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

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);
}

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);
}

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");
}

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.

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);
}

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)
}

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

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

fn default() -> Model<SelectionMode>

Returns the “default value” for a type.

impl Selectable for Model<MultiSelect>

fn activate(&mut self, id: Entity)

Activate an item.

fn deactivate(&mut self, id: Entity)

Deactivate an item.

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

Checks if the item is active.

impl Selectable for Model<SingleSelect>

fn activate(&mut self, id: Entity)

Activate an item.

fn deactivate(&mut self, id: Entity)

Deactivate an item.

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

Checks if the item is active.