Struct TypedGridView 

pub struct TypedGridView<T, S> {
    pub view: GridView,
    pub selection_model: S,
    /* private fields */
}

A high-level wrapper around gio::ListStore, gtk::SignalListItemFactory and gtk::GridView.

TypedGridView aims at keeping nearly the same functionality and flexibility of the raw bindings while introducing a more idiomatic and type-safe interface.

Fields

view: GridView

The internal grid view.

selection_model: S

The internal selection model.

Implementations

impl<T, S> TypedGridView<T, S>

where T: RelmGridItem + Ord, S: RelmSelectionExt,

pub fn with_sorting() -> Self

Create a new TypedGridView that sorts the items based on the Ord trait.

impl<T, S> TypedGridView<T, S>

where T: RelmGridItem, S: RelmSelectionExt,

pub fn new() -> Self

Create a new, empty TypedGridView.

Examples found in repository

relm4/examples/message_from_grid_view.rs (line 150)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // Initialize the GridView
        let grid_view: TypedGridView<MyGridItem, gtk::NoSelection> = TypedGridView::new();

        let model = App { grid_view };

        let my_view = &model.grid_view.view;

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/typed_grid_view.rs (line 145)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // Initialize the GridView wrapper
        let mut grid_view_wrapper: TypedGridView<MyGridItem, gtk::SingleSelection> =
            TypedGridView::new();

        // Add a filter and disable it
        grid_view_wrapper.add_filter(|item| item.value % 2 == 0);
        grid_view_wrapper.set_filter_status(0, false);

        let model = App {
            counter,
            grid_view_wrapper,
        };

        let my_view = &model.grid_view_wrapper.view;

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

pub fn add_filter<F: Fn(&T) -> bool + 'static>(&mut self, f: F)

Add a function to filter the stored items. Returning false will simply hide the item.

Note that several filters can be added on top of each other.

Examples found in repository

relm4/examples/typed_grid_view.rs (line 148)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // Initialize the GridView wrapper
        let mut grid_view_wrapper: TypedGridView<MyGridItem, gtk::SingleSelection> =
            TypedGridView::new();

        // Add a filter and disable it
        grid_view_wrapper.add_filter(|item| item.value % 2 == 0);
        grid_view_wrapper.set_filter_status(0, false);

        let model = App {
            counter,
            grid_view_wrapper,
        };

        let my_view = &model.grid_view_wrapper.view;

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

pub fn filters_len(&self) -> usize

Returns the amount of filters that were added.

pub fn set_filter_status(&mut self, idx: usize, active: bool) -> bool

Set a certain filter as active or inactive.

Examples found in repository

relm4/examples/typed_grid_view.rs (line 149)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        // Initialize the GridView wrapper
        let mut grid_view_wrapper: TypedGridView<MyGridItem, gtk::SingleSelection> =
            TypedGridView::new();

        // Add a filter and disable it
        grid_view_wrapper.add_filter(|item| item.value % 2 == 0);
        grid_view_wrapper.set_filter_status(0, false);

        let model = App {
            counter,
            grid_view_wrapper,
        };

        let my_view = &model.grid_view_wrapper.view;

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            Msg::Append => {
                // Add 10 items
                for _ in 0..10 {
                    self.counter = self.counter.wrapping_add(1);
                    self.grid_view_wrapper.append(MyGridItem::new(self.counter));
                }

                self.grid_view_wrapper
                    .iter()
                    .for_each(|row| println!("item {}", row.borrow().value));

                // Count up the first item
                let first_item = self.grid_view_wrapper.get(0).unwrap();
                let first_binding = &mut first_item.borrow_mut().binding;
                let mut guard = first_binding.guard();
                *guard += 1;
            }
            Msg::Remove => {
                // Remove the second item
                self.grid_view_wrapper.remove(1);
            }
            Msg::OnlyShowEven(show_only_even) => {
                // Disable or enable the first filter
                self.grid_view_wrapper.set_filter_status(0, show_only_even);
            }
        }
    }

pub fn notify_filter_changed(&self, idx: usize) -> bool

Notify that a certain filter has changed. This causes the filter expression to be re-evaluated.

Returns true if a filter was notified.

pub fn pop_filter(&mut self)

Remove the last filter.

pub fn clear_filters(&mut self)

Remove all filters.

pub fn append(&mut self, value: T)

Add a new item at the end of the list.

Examples found in repository

relm4/examples/message_from_grid_view.rs (line 165)

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>) {
        match msg {
            Msg::Add => {
                for _ in 0..10 {
                    self.grid_view.append(MyGridItem::new(sender.clone()));
                }
            }
            Msg::Print(name) => {
                println!("Name: {:?}", name)
            }
        }
    }

relm4/examples/typed_grid_view.rs (line 169)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            Msg::Append => {
                // Add 10 items
                for _ in 0..10 {
                    self.counter = self.counter.wrapping_add(1);
                    self.grid_view_wrapper.append(MyGridItem::new(self.counter));
                }

                self.grid_view_wrapper
                    .iter()
                    .for_each(|row| println!("item {}", row.borrow().value));

                // Count up the first item
                let first_item = self.grid_view_wrapper.get(0).unwrap();
                let first_binding = &mut first_item.borrow_mut().binding;
                let mut guard = first_binding.guard();
                *guard += 1;
            }
            Msg::Remove => {
                // Remove the second item
                self.grid_view_wrapper.remove(1);
            }
            Msg::OnlyShowEven(show_only_even) => {
                // Disable or enable the first filter
                self.grid_view_wrapper.set_filter_status(0, show_only_even);
            }
        }
    }

pub fn extend_from_iter<I: IntoIterator<Item = T>>(&mut self, init: I)

Add new items from an iterator the the end of the list.

pub fn find<F: FnMut(&T) -> bool>(&self, equal_func: F) -> Option<u32>

Available on crate feature gnome_43 only.

Find the index of the first item that matches a certain function.

pub fn is_empty(&self) -> bool

Returns true if the list is empty.

pub fn len(&self) -> u32

Returns the length of the list (without filters).

pub fn get(&self, position: u32) -> Option<TypedListItem<T>>

Get the TypedListItem at the specified position.

Returns None if the position is invalid.

Examples found in repository

relm4/examples/typed_grid_view.rs (line 177)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            Msg::Append => {
                // Add 10 items
                for _ in 0..10 {
                    self.counter = self.counter.wrapping_add(1);
                    self.grid_view_wrapper.append(MyGridItem::new(self.counter));
                }

                self.grid_view_wrapper
                    .iter()
                    .for_each(|row| println!("item {}", row.borrow().value));

                // Count up the first item
                let first_item = self.grid_view_wrapper.get(0).unwrap();
                let first_binding = &mut first_item.borrow_mut().binding;
                let mut guard = first_binding.guard();
                *guard += 1;
            }
            Msg::Remove => {
                // Remove the second item
                self.grid_view_wrapper.remove(1);
            }
            Msg::OnlyShowEven(show_only_even) => {
                // Disable or enable the first filter
                self.grid_view_wrapper.set_filter_status(0, show_only_even);
            }
        }
    }

pub fn get_visible(&self, position: u32) -> Option<TypedListItem<T>>

Get the visible TypedListItem at the specified position, (the item at the given position after filtering and sorting).

Returns None if the position is invalid.

pub fn insert(&mut self, position: u32, value: T)

Insert an item at a specific position.

pub fn insert_sorted<F: FnMut(&T, &T) -> Ordering>( &self, value: T, compare_func: F, ) -> u32

Insert an item into the list and calculate its position from a sorting function.

pub fn remove(&mut self, position: u32)

Remove an item at a specific position.

Examples found in repository

relm4/examples/typed_grid_view.rs (line 184)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            Msg::Append => {
                // Add 10 items
                for _ in 0..10 {
                    self.counter = self.counter.wrapping_add(1);
                    self.grid_view_wrapper.append(MyGridItem::new(self.counter));
                }

                self.grid_view_wrapper
                    .iter()
                    .for_each(|row| println!("item {}", row.borrow().value));

                // Count up the first item
                let first_item = self.grid_view_wrapper.get(0).unwrap();
                let first_binding = &mut first_item.borrow_mut().binding;
                let mut guard = first_binding.guard();
                *guard += 1;
            }
            Msg::Remove => {
                // Remove the second item
                self.grid_view_wrapper.remove(1);
            }
            Msg::OnlyShowEven(show_only_even) => {
                // Disable or enable the first filter
                self.grid_view_wrapper.set_filter_status(0, show_only_even);
            }
        }
    }

pub fn clear(&mut self)

Remove all items.

pub fn iter(&self) -> TypedIterator<'_, TypedGridView<T, S>>

Returns an iterator that allows modifying each TypedListItem.

Examples found in repository

relm4/examples/typed_grid_view.rs (line 173)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        match msg {
            Msg::Append => {
                // Add 10 items
                for _ in 0..10 {
                    self.counter = self.counter.wrapping_add(1);
                    self.grid_view_wrapper.append(MyGridItem::new(self.counter));
                }

                self.grid_view_wrapper
                    .iter()
                    .for_each(|row| println!("item {}", row.borrow().value));

                // Count up the first item
                let first_item = self.grid_view_wrapper.get(0).unwrap();
                let first_binding = &mut first_item.borrow_mut().binding;
                let mut guard = first_binding.guard();
                *guard += 1;
            }
            Msg::Remove => {
                // Remove the second item
                self.grid_view_wrapper.remove(1);
            }
            Msg::OnlyShowEven(show_only_even) => {
                // Disable or enable the first filter
                self.grid_view_wrapper.set_filter_status(0, show_only_even);
            }
        }
    }

Trait Implementations

impl<T: Debug, S: Debug> Debug for TypedGridView<T, S>

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

Formats the value using the given formatter.

impl<T, S> Default for TypedGridView<T, S>

where T: RelmGridItem, S: RelmSelectionExt,

fn default() -> Self

Returns the “default value” for a type.