Struct Model

pub struct Model<SelectionMode: Default, Item: ItemInterface<Category>, Category>
where
    Category: ItemCategory,
{ /* private fields */ }

Implementations

impl<Item: ItemInterface<Category>, Category: ItemCategory> Model<SingleSelect, Item, Category>

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<Item: ItemInterface<Category>, Category: ItemCategory> Model<MultiSelect, Item, Category>

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, Item: ItemInterface<Category>, Category: ItemCategory> Model<SelectionMode, Item, Category>

where Self: Selectable,

pub fn new(categories: Vec<Category>) -> Self

pub fn categories(&mut self, cats: Vec<Category>)

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 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 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 item(&self, id: Entity) -> Option<&Item>

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 item_mut(&mut self, id: Entity) -> Option<&mut Item>

Get a mutable reference to data associated with an item.

pub fn item_set(&mut self, id: Entity, data: Item)

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<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 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 insert( &mut self, item: Item, ) -> EntityMut<'_, SelectionMode, Item, Category>

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_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 get_sort(&self) -> Option<(Category, bool)>

Get the sort data

pub fn sort(&mut self, category: Category, ascending: bool)

Sorts items in the model, this should be called before it is drawn after all items have been added for the view

Trait Implementations

impl<Item: ItemInterface<Category>, Category: ItemCategory> Selectable for Model<MultiSelect, Item, Category>

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<Item: ItemInterface<Category>, Category: ItemCategory> Selectable for Model<SingleSelect, Item, Category>

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.