Struct FactoryVecDeque 

pub struct FactoryVecDeque<C>
where
    C: FactoryComponent<Index = DynamicIndex>,
{ /* private fields */ }

A container similar to VecDeque that can be used to store data associated with components that implement FactoryComponent.

To access mutable methods of the factory, create a guard using Self::guard.

Implementations

impl<C> FactoryVecDeque<C>

where C: FactoryComponent<Index = DynamicIndex>,

pub fn builder() -> FactoryVecDequeBuilder<C>

Creates a builder for making a FactoryVecDeque.

Examples found in repository

relm4/examples/state_management.rs (line 164)

    fn init_model(_name: Self::Init, index: &DynamicIndex, sender: FactorySender<Self>) -> Self {
        let task_index = index.clone();

        let tags = FactoryVecDeque::builder().launch_default().forward(
            sender.output_sender(),
            move |output| match output {
                TagOutput::Delete(tag_index) => {
                    TaskOutput::DeleteTag(task_index.clone(), tag_index)
                }
            },
        );

        Self {
            name: "".into(),
            tags,
        }
    }
}

#[derive(Debug)]
struct Tag {
    name: String,
}

#[derive(Debug)]
enum TagInput {}

#[derive(Debug)]
enum TagOutput {
    Delete(DynamicIndex),
}

#[relm4::factory]
impl FactoryComponent for Tag {
    type Init = String;
    type Input = TagInput;
    type Output = TagOutput;
    type CommandOutput = ();
    type ParentWidget = gtk::Box;

    view! {
        gtk::MenuButton {
            #[watch]
            set_label: &self.name,

            #[wrap(Some)]
            set_popover = &gtk::Popover {
                gtk::Button {
                    set_label: "Delete",

                    connect_clicked[sender, index] => move |_| {
                        sender.output(TagOutput::Delete(index.clone())).unwrap();
                    }
                }
            }
        }
    }

    fn init_model(name: Self::Init, _index: &DynamicIndex, _sender: FactorySender<Self>) -> Self {
        Self { name }
    }
}

/// The document is a headless component which holds and manages the data model.
/// It receives input events FROM the App to update the data model.
/// When updates to the model occur, it sends output events TO the App.
///
/// The document's interface is just input and output events. As a result you have a lot of freedom
/// in how you choose to store the data model within the component, which backing store you use
/// (such as the file system, a database, or a Web API), and how you synchronise to the backing
/// store (e.g. manual save/load control, auto-saving on each change, batching up changes before
/// syncing, and so on).
struct Document {
    /// The application data model.
    /// In this case we have just stored the whole thing in memory because our requirements are
    /// simple. In a real app you might choose a more elaborate approach.
    model: Model,
}

#[derive(Default, Serialize, Deserialize)]
struct TagModel {
    name: String,
}
#[derive(Default, Serialize, Deserialize)]
struct TaskModel {
    name: String,
    tags: Vec<TagModel>,
}
#[derive(Default, Serialize, Deserialize)]
struct Model {
    tasks: Vec<TaskModel>,
}

#[derive(Debug)]
enum DocumentInput {
    // extra operations on the document itself (in this case, related to file I/O)
    Open(PathBuf),
    Save(PathBuf),

    // events related to the model that the document stores
    Clear,
    AddTask,
    DeleteTask(DynamicIndex),
    ChangeTaskName(DynamicIndex, String),
    AddTag(DynamicIndex, String),
    DeleteTag(DynamicIndex, DynamicIndex),
}

#[derive(Debug)]
enum DocumentOutput {
    Cleared,
    AddedTask,
    DeletedTask(usize),
    ChangedTaskName(usize, String),
    AddedTag(usize, String),
    DeletedTag(usize, usize),
}

impl Worker for Document {
    type Init = ();
    type Input = DocumentInput;
    type Output = DocumentOutput;

    fn init(_init: Self::Init, _sender: ComponentSender<Self>) -> Self {
        let model = Model::default();
        Self { model }
    }

    fn update(&mut self, input: DocumentInput, sender: ComponentSender<Self>) {
        match input {
            DocumentInput::Save(path) => {
                println!("Save as JSON to {path:?}");

                // TODO in a real app you would report any errors from saving the document
                if let Ok(json) = serde_json::to_string(&self.model) {
                    std::fs::write(path, json).unwrap();
                }
            }
            DocumentInput::Open(path) => {
                println!("Open tasks document at {path:?}");

                if let Ok(json) = std::fs::read_to_string(path)
                    && let Ok(new_model) = serde_json::from_str(&json)
                {
                    // update the data model
                    self.model = new_model;

                    // refresh the view from the data model
                    let _ = sender.output(DocumentOutput::Cleared);

                    for (task_index, task) in self.model.tasks.iter().enumerate() {
                        let _ = sender.output(DocumentOutput::AddedTask);

                        let task_name = task.name.clone();
                        let _ =
                            sender.output(DocumentOutput::ChangedTaskName(task_index, task_name));

                        for tag in &task.tags {
                            let tag_name = tag.name.clone();
                            let _ = sender.output(DocumentOutput::AddedTag(task_index, tag_name));
                        }
                    }
                }
            }
            DocumentInput::Clear => {
                self.model.tasks.clear();

                let _ = sender.output(DocumentOutput::Cleared);
            }
            DocumentInput::AddTask => {
                self.model.tasks.push(TaskModel::default());

                let _ = sender.output(DocumentOutput::AddedTask);
            }
            DocumentInput::DeleteTask(index) => {
                self.model.tasks.remove(index.current_index());

                let _ = sender.output(DocumentOutput::DeletedTask(index.current_index()));
            }
            DocumentInput::ChangeTaskName(index, name) => {
                if let Some(task) = self.model.tasks.get_mut(index.current_index()) {
                    task.name.clone_from(&name);
                }

                // We don't technically need to send an event, because gtk::Entry updates itself
                // this is just to make the example consistent.
                let _ = sender.output(DocumentOutput::ChangedTaskName(index.current_index(), name));
            }
            DocumentInput::AddTag(task_index, name) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.push(TagModel { name: name.clone() })
                }

                let _ = sender.output(DocumentOutput::AddedTag(task_index.current_index(), name));
            }
            DocumentInput::DeleteTag(task_index, tag_index) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.remove(tag_index.current_index());
                }

                let _ = sender.output(DocumentOutput::DeletedTag(
                    task_index.current_index(),
                    tag_index.current_index(),
                ));
            }
        }
    }
}

/// The App is at the top level.
/// It acts as a bridge between the view and the document, forwarding events between them.
struct App {
    view: FactoryVecDeque<Task>,
    document: Controller<Document>,
    save_dialog: Controller<SaveDialog>,
    open_dialog: Controller<OpenDialog>,
}

#[derive(Debug)]
enum AppInput {
    Clear,
    Cleared,

    AddTask,
    AddedTask,

    DeleteTask(DynamicIndex),
    DeletedTask(usize),

    ChangeTaskName(DynamicIndex, String),
    ChangedTaskName(usize, String),

    AddTag(DynamicIndex, String),
    AddedTag(usize, String),

    DeleteTag(DynamicIndex, DynamicIndex),
    DeletedTag(usize, usize),

    // No-op event for when load/save dialogs result in Cancel
    None,
    Open,
    OpenResponse(PathBuf),
    Save,
    SaveResponse(PathBuf),
}

#[relm4::component]
impl SimpleComponent for App {
    type Init = ();
    type Input = AppInput;
    type Output = ();

    view! {
        main_window = gtk::ApplicationWindow {
            set_width_request: 360,
            set_title: Some("Tasks"),

            gtk::Box {
                set_orientation: gtk::Orientation::Vertical,

                gtk::HeaderBar {
                    set_show_title_buttons: false,

                    #[wrap(Some)]
                    set_title_widget = &gtk::Label {
                        set_text: ""
                    },

                    pack_start = &gtk::Button {
                        set_icon_name: "plus",
                        set_tooltip: "Add Task",

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::AddTask);
                        }
                    },

                    pack_end = &gtk::Button {
                        set_label: "Save",
                        connect_clicked => AppInput::Save,
                    },
                    pack_end = &gtk::Button {
                        set_label: "Open",
                        connect_clicked => AppInput::Open,
                    },
                },

                gtk::ScrolledWindow {
                    set_hscrollbar_policy: gtk::PolicyType::Never,
                    set_min_content_height: 360,
                    set_vexpand: true,

                    #[local_ref]
                    task_list_box -> gtk::ListBox {
                        set_selection_mode: gtk::SelectionMode::None,
                    }
                },

                gtk::Box {
                    set_hexpand: true,
                    set_spacing: DEFAULT_SPACING,
                    set_orientation: gtk::Orientation::Horizontal,

                    gtk::Label {
                        set_text: "Press Enter after editing task names",
                        set_hexpand: true,
                        set_xalign: XALIGN_CENTER,
                    },

                    gtk::Button {
                        set_icon_name: "edit-delete",
                        set_tooltip: "Delete All Tasks",
                        add_css_class: CSS_CLASS_DESTRUCTIVE_ACTION,

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::Clear);
                        }
                    }
                }
            }
        }
    }

    fn update(&mut self, msg: AppInput, _sender: ComponentSender<Self>) {
        match msg {
            AppInput::Clear => {
                self.document.emit(DocumentInput::Clear);
            }
            AppInput::Cleared => {
                self.view.guard().clear();
            }
            AppInput::AddTask => {
                self.document.emit(DocumentInput::AddTask);
            }
            AppInput::AddedTask => {
                self.view.guard().push_back(());
            }
            AppInput::DeleteTask(index) => {
                self.document.emit(DocumentInput::DeleteTask(index));
            }
            AppInput::DeletedTask(index) => {
                self.view.guard().remove(index);
            }
            AppInput::ChangeTaskName(index, name) => {
                self.document
                    .emit(DocumentInput::ChangeTaskName(index, name));
            }
            AppInput::ChangedTaskName(index, name) => {
                self.view.guard().send(index, TaskInput::ChangedName(name));
            }
            AppInput::AddTag(index, name) => {
                self.document.emit(DocumentInput::AddTag(index, name));
            }
            AppInput::AddedTag(index, name) => {
                self.view.guard().send(index, TaskInput::AddedTag(name));
            }
            AppInput::DeleteTag(task_index, tag_index) => {
                self.document
                    .emit(DocumentInput::DeleteTag(task_index, tag_index));
            }
            AppInput::DeletedTag(task_index, tag_index) => {
                self.view
                    .guard()
                    .send(task_index, TaskInput::DeletedTag(tag_index));
            }
            AppInput::None => {}
            AppInput::Save => {
                let name = "tasks.json".into();
                self.save_dialog.emit(SaveDialogMsg::SaveAs(name));
            }
            AppInput::SaveResponse(path) => {
                self.document.emit(DocumentInput::Save(path));
            }
            AppInput::Open => {
                self.open_dialog.emit(OpenDialogMsg::Open);
            }
            AppInput::OpenResponse(path) => {
                self.document.emit(DocumentInput::Open(path));
            }
        }
    }

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let view =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    TaskOutput::Delete(index) => AppInput::DeleteTask(index),
                    TaskOutput::Name(index, name) => AppInput::ChangeTaskName(index, name),
                    TaskOutput::AddTag(index, name) => AppInput::AddTag(index, name),
                    TaskOutput::DeleteTag(task_index, tag_index) => {
                        AppInput::DeleteTag(task_index, tag_index)
                    }
                });

        let document =
            Document::builder()
                .launch(())
                .forward(sender.input_sender(), |msg| match msg {
                    DocumentOutput::Cleared => AppInput::Cleared,
                    DocumentOutput::DeletedTask(index) => AppInput::DeletedTask(index),
                    DocumentOutput::DeletedTag(task_index, tag_index) => {
                        AppInput::DeletedTag(task_index, tag_index)
                    }
                    DocumentOutput::AddedTask => AppInput::AddedTask,
                    DocumentOutput::AddedTag(index, name) => AppInput::AddedTag(index, name),
                    DocumentOutput::ChangedTaskName(index, name) => {
                        AppInput::ChangedTaskName(index, name)
                    }
                });

        let save_dialog = SaveDialog::builder()
            .transient_for_native(&root)
            .launch(SaveDialogSettings {
                create_folders: true,
                accept_label: "Save".into(),
                cancel_label: "Cancel".into(),
                is_modal: true,
                filters: tasks_filename_filters(),
            })
            .forward(sender.input_sender(), |response| match response {
                SaveDialogResponse::Accept(path) => AppInput::SaveResponse(path),
                SaveDialogResponse::Cancel => AppInput::None,
            });

        let open_dialog = OpenDialog::builder()
            .transient_for_native(&root)
            .launch(OpenDialogSettings {
                create_folders: false,
                folder_mode: false,
                cancel_label: "Cancel".into(),
                accept_label: "Open".into(),
                is_modal: true,
                filters: tasks_filename_filters(),
            })
            .forward(sender.input_sender(), |response| match response {
                OpenDialogResponse::Accept(path) => AppInput::OpenResponse(path),
                OpenDialogResponse::Cancel => AppInput::None,
            });

        let app = App {
            view,
            document,
            open_dialog,
            save_dialog,
        };

        let task_list_box = app.view.widget();
        let widgets = view_output!();

        ComponentParts {
            model: app,
            widgets,
        }
    }

relm4/examples/entry.rs (line 84)

    fn init(
        _init: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let factory_box = gtk::Box::default();

        let counters = FactoryVecDeque::builder()
            .launch(factory_box.clone())
            .forward(sender.input_sender(), |output| output);

        let model = App {
            counters,
            created_counters: 0,
            entry: gtk::EntryBuffer::default(),
        };

        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/to_do.rs (line 146)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let tasks =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |output| match output {
                    TaskOutput::Delete(index) => AppMsg::DeleteEntry(index),
                });

        let model = App { tasks };

        let task_list_box = model.tasks.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/tab_factory.rs (line 162)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryVecDeque::builder()
            .launch(adw::TabView::default())
            .forward(sender.input_sender(), |output| match output {
                CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
            });
        let model = App {
            created_widgets: counter,
            counters,
        };

        let tab_view = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/grid_factory.rs (line 190)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                    CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                    CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
                });

        let model = App {
            created_widgets: counter,
            counters,
        };

        let counter_grid = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/factory.rs (line 165)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                    CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                    CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
                    CounterOutput::Remove(index) => AppMsg::Remove(index),
                });

        let model = App {
            created_widgets: counter,
            counters,
        };

        let counter_box = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

Additional examples can be found in:

• relm4/examples/tab_game.rs

pub fn guard(&mut self) -> FactoryVecDequeGuard<'_, C>

Provides a FactoryVecDequeGuard that can be used to edit the factory.

The changes will be rendered on the widgets after the guard goes out of scope.

Examples found in repository

relm4/examples/to_do.rs (line 132)

    fn update(&mut self, msg: AppMsg, _sender: ComponentSender<Self>) {
        match msg {
            AppMsg::DeleteEntry(index) => {
                self.tasks.guard().remove(index.current_index());
            }
            AppMsg::AddEntry(name) => {
                self.tasks.guard().push_back(name);
            }
        }
    }

relm4/examples/state_management.rs (line 139)

    fn update(&mut self, message: Self::Input, _sender: FactorySender<Self>) {
        match message {
            TaskInput::ChangedName(name) => {
                self.name = name;
            }
            TaskInput::AddedTag(name) => {
                self.tags.guard().push_back(name);
            }
            TaskInput::DeletedTag(index) => {
                self.tags.guard().remove(index);
            }
        }
    }

    fn init_widgets(
        &mut self,
        index: &Self::Index,
        root: Self::Root,
        _returned_widget: &<Self::ParentWidget as FactoryView>::ReturnedWidget,
        sender: FactorySender<Self>,
    ) -> Self::Widgets {
        let tag_list_box = self.tags.widget();

        let widgets = view_output!();

        widgets
    }

    fn init_model(_name: Self::Init, index: &DynamicIndex, sender: FactorySender<Self>) -> Self {
        let task_index = index.clone();

        let tags = FactoryVecDeque::builder().launch_default().forward(
            sender.output_sender(),
            move |output| match output {
                TagOutput::Delete(tag_index) => {
                    TaskOutput::DeleteTag(task_index.clone(), tag_index)
                }
            },
        );

        Self {
            name: "".into(),
            tags,
        }
    }
}

#[derive(Debug)]
struct Tag {
    name: String,
}

#[derive(Debug)]
enum TagInput {}

#[derive(Debug)]
enum TagOutput {
    Delete(DynamicIndex),
}

#[relm4::factory]
impl FactoryComponent for Tag {
    type Init = String;
    type Input = TagInput;
    type Output = TagOutput;
    type CommandOutput = ();
    type ParentWidget = gtk::Box;

    view! {
        gtk::MenuButton {
            #[watch]
            set_label: &self.name,

            #[wrap(Some)]
            set_popover = &gtk::Popover {
                gtk::Button {
                    set_label: "Delete",

                    connect_clicked[sender, index] => move |_| {
                        sender.output(TagOutput::Delete(index.clone())).unwrap();
                    }
                }
            }
        }
    }

    fn init_model(name: Self::Init, _index: &DynamicIndex, _sender: FactorySender<Self>) -> Self {
        Self { name }
    }
}

/// The document is a headless component which holds and manages the data model.
/// It receives input events FROM the App to update the data model.
/// When updates to the model occur, it sends output events TO the App.
///
/// The document's interface is just input and output events. As a result you have a lot of freedom
/// in how you choose to store the data model within the component, which backing store you use
/// (such as the file system, a database, or a Web API), and how you synchronise to the backing
/// store (e.g. manual save/load control, auto-saving on each change, batching up changes before
/// syncing, and so on).
struct Document {
    /// The application data model.
    /// In this case we have just stored the whole thing in memory because our requirements are
    /// simple. In a real app you might choose a more elaborate approach.
    model: Model,
}

#[derive(Default, Serialize, Deserialize)]
struct TagModel {
    name: String,
}
#[derive(Default, Serialize, Deserialize)]
struct TaskModel {
    name: String,
    tags: Vec<TagModel>,
}
#[derive(Default, Serialize, Deserialize)]
struct Model {
    tasks: Vec<TaskModel>,
}

#[derive(Debug)]
enum DocumentInput {
    // extra operations on the document itself (in this case, related to file I/O)
    Open(PathBuf),
    Save(PathBuf),

    // events related to the model that the document stores
    Clear,
    AddTask,
    DeleteTask(DynamicIndex),
    ChangeTaskName(DynamicIndex, String),
    AddTag(DynamicIndex, String),
    DeleteTag(DynamicIndex, DynamicIndex),
}

#[derive(Debug)]
enum DocumentOutput {
    Cleared,
    AddedTask,
    DeletedTask(usize),
    ChangedTaskName(usize, String),
    AddedTag(usize, String),
    DeletedTag(usize, usize),
}

impl Worker for Document {
    type Init = ();
    type Input = DocumentInput;
    type Output = DocumentOutput;

    fn init(_init: Self::Init, _sender: ComponentSender<Self>) -> Self {
        let model = Model::default();
        Self { model }
    }

    fn update(&mut self, input: DocumentInput, sender: ComponentSender<Self>) {
        match input {
            DocumentInput::Save(path) => {
                println!("Save as JSON to {path:?}");

                // TODO in a real app you would report any errors from saving the document
                if let Ok(json) = serde_json::to_string(&self.model) {
                    std::fs::write(path, json).unwrap();
                }
            }
            DocumentInput::Open(path) => {
                println!("Open tasks document at {path:?}");

                if let Ok(json) = std::fs::read_to_string(path)
                    && let Ok(new_model) = serde_json::from_str(&json)
                {
                    // update the data model
                    self.model = new_model;

                    // refresh the view from the data model
                    let _ = sender.output(DocumentOutput::Cleared);

                    for (task_index, task) in self.model.tasks.iter().enumerate() {
                        let _ = sender.output(DocumentOutput::AddedTask);

                        let task_name = task.name.clone();
                        let _ =
                            sender.output(DocumentOutput::ChangedTaskName(task_index, task_name));

                        for tag in &task.tags {
                            let tag_name = tag.name.clone();
                            let _ = sender.output(DocumentOutput::AddedTag(task_index, tag_name));
                        }
                    }
                }
            }
            DocumentInput::Clear => {
                self.model.tasks.clear();

                let _ = sender.output(DocumentOutput::Cleared);
            }
            DocumentInput::AddTask => {
                self.model.tasks.push(TaskModel::default());

                let _ = sender.output(DocumentOutput::AddedTask);
            }
            DocumentInput::DeleteTask(index) => {
                self.model.tasks.remove(index.current_index());

                let _ = sender.output(DocumentOutput::DeletedTask(index.current_index()));
            }
            DocumentInput::ChangeTaskName(index, name) => {
                if let Some(task) = self.model.tasks.get_mut(index.current_index()) {
                    task.name.clone_from(&name);
                }

                // We don't technically need to send an event, because gtk::Entry updates itself
                // this is just to make the example consistent.
                let _ = sender.output(DocumentOutput::ChangedTaskName(index.current_index(), name));
            }
            DocumentInput::AddTag(task_index, name) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.push(TagModel { name: name.clone() })
                }

                let _ = sender.output(DocumentOutput::AddedTag(task_index.current_index(), name));
            }
            DocumentInput::DeleteTag(task_index, tag_index) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.remove(tag_index.current_index());
                }

                let _ = sender.output(DocumentOutput::DeletedTag(
                    task_index.current_index(),
                    tag_index.current_index(),
                ));
            }
        }
    }
}

/// The App is at the top level.
/// It acts as a bridge between the view and the document, forwarding events between them.
struct App {
    view: FactoryVecDeque<Task>,
    document: Controller<Document>,
    save_dialog: Controller<SaveDialog>,
    open_dialog: Controller<OpenDialog>,
}

#[derive(Debug)]
enum AppInput {
    Clear,
    Cleared,

    AddTask,
    AddedTask,

    DeleteTask(DynamicIndex),
    DeletedTask(usize),

    ChangeTaskName(DynamicIndex, String),
    ChangedTaskName(usize, String),

    AddTag(DynamicIndex, String),
    AddedTag(usize, String),

    DeleteTag(DynamicIndex, DynamicIndex),
    DeletedTag(usize, usize),

    // No-op event for when load/save dialogs result in Cancel
    None,
    Open,
    OpenResponse(PathBuf),
    Save,
    SaveResponse(PathBuf),
}

#[relm4::component]
impl SimpleComponent for App {
    type Init = ();
    type Input = AppInput;
    type Output = ();

    view! {
        main_window = gtk::ApplicationWindow {
            set_width_request: 360,
            set_title: Some("Tasks"),

            gtk::Box {
                set_orientation: gtk::Orientation::Vertical,

                gtk::HeaderBar {
                    set_show_title_buttons: false,

                    #[wrap(Some)]
                    set_title_widget = &gtk::Label {
                        set_text: ""
                    },

                    pack_start = &gtk::Button {
                        set_icon_name: "plus",
                        set_tooltip: "Add Task",

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::AddTask);
                        }
                    },

                    pack_end = &gtk::Button {
                        set_label: "Save",
                        connect_clicked => AppInput::Save,
                    },
                    pack_end = &gtk::Button {
                        set_label: "Open",
                        connect_clicked => AppInput::Open,
                    },
                },

                gtk::ScrolledWindow {
                    set_hscrollbar_policy: gtk::PolicyType::Never,
                    set_min_content_height: 360,
                    set_vexpand: true,

                    #[local_ref]
                    task_list_box -> gtk::ListBox {
                        set_selection_mode: gtk::SelectionMode::None,
                    }
                },

                gtk::Box {
                    set_hexpand: true,
                    set_spacing: DEFAULT_SPACING,
                    set_orientation: gtk::Orientation::Horizontal,

                    gtk::Label {
                        set_text: "Press Enter after editing task names",
                        set_hexpand: true,
                        set_xalign: XALIGN_CENTER,
                    },

                    gtk::Button {
                        set_icon_name: "edit-delete",
                        set_tooltip: "Delete All Tasks",
                        add_css_class: CSS_CLASS_DESTRUCTIVE_ACTION,

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::Clear);
                        }
                    }
                }
            }
        }
    }

    fn update(&mut self, msg: AppInput, _sender: ComponentSender<Self>) {
        match msg {
            AppInput::Clear => {
                self.document.emit(DocumentInput::Clear);
            }
            AppInput::Cleared => {
                self.view.guard().clear();
            }
            AppInput::AddTask => {
                self.document.emit(DocumentInput::AddTask);
            }
            AppInput::AddedTask => {
                self.view.guard().push_back(());
            }
            AppInput::DeleteTask(index) => {
                self.document.emit(DocumentInput::DeleteTask(index));
            }
            AppInput::DeletedTask(index) => {
                self.view.guard().remove(index);
            }
            AppInput::ChangeTaskName(index, name) => {
                self.document
                    .emit(DocumentInput::ChangeTaskName(index, name));
            }
            AppInput::ChangedTaskName(index, name) => {
                self.view.guard().send(index, TaskInput::ChangedName(name));
            }
            AppInput::AddTag(index, name) => {
                self.document.emit(DocumentInput::AddTag(index, name));
            }
            AppInput::AddedTag(index, name) => {
                self.view.guard().send(index, TaskInput::AddedTag(name));
            }
            AppInput::DeleteTag(task_index, tag_index) => {
                self.document
                    .emit(DocumentInput::DeleteTag(task_index, tag_index));
            }
            AppInput::DeletedTag(task_index, tag_index) => {
                self.view
                    .guard()
                    .send(task_index, TaskInput::DeletedTag(tag_index));
            }
            AppInput::None => {}
            AppInput::Save => {
                let name = "tasks.json".into();
                self.save_dialog.emit(SaveDialogMsg::SaveAs(name));
            }
            AppInput::SaveResponse(path) => {
                self.document.emit(DocumentInput::Save(path));
            }
            AppInput::Open => {
                self.open_dialog.emit(OpenDialogMsg::Open);
            }
            AppInput::OpenResponse(path) => {
                self.document.emit(DocumentInput::Open(path));
            }
        }
    }

relm4/examples/tab_game.rs (line 233)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryVecDeque::builder()
            .launch(adw::TabView::default())
            .forward(sender.input_sender(), |output| match output {
                CounterOutput::StartGame(index) => AppMsg::StartGame(index),
                CounterOutput::SelectedGuess(guess) => AppMsg::SelectedGuess(guess),
            });

        let mut model = App {
            counters,
            start_index: None,
        };

        let tab_view = model.counters.widget();
        let widgets = view_output!();

        let mut counters_guard = model.counters.guard();
        for i in 0..3 {
            counters_guard.push_back(i);
        }

        // Explicitly drop the guard,
        // so that 'model' is no longer borrowed
        // and can be moved inside ComponentParts
        counters_guard.drop();

        ComponentParts { model, widgets }
    }

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>, _root: &Self::Root) {
        match msg {
            AppMsg::StartGame(index) => {
                self.start_index = Some(index);
                sender.command(|sender, _| async move {
                    for i in (1..4).rev() {
                        *GAME_STATE.write() = GameState::Countdown(i);
                        relm4::tokio::time::sleep(Duration::from_millis(1000)).await;
                    }
                    *GAME_STATE.write() = GameState::Running;
                    for _ in 0..20 {
                        relm4::tokio::time::sleep(Duration::from_millis(500)).await;
                        sender.send(false).unwrap();
                    }
                    relm4::tokio::time::sleep(Duration::from_millis(1000)).await;
                    sender.send(true).unwrap();
                });
            }
            AppMsg::StopGame => {
                *GAME_STATE.write() = GameState::Guessing;
            }
            AppMsg::SelectedGuess(index) => {
                *GAME_STATE.write() = GameState::End(index == self.start_index.take().unwrap());
            }
        }
    }

    fn update_cmd(
        &mut self,
        msg: Self::CommandOutput,
        sender: ComponentSender<Self>,
        _root: &Self::Root,
    ) {
        if msg {
            sender.input(AppMsg::StopGame);
        } else {
            let mut counters_guard = self.counters.guard();
            match rand::random::<u8>() % 3 {
                0 => {
                    counters_guard.swap(1, 2);
                }
                1 => {
                    counters_guard.swap(0, 1);
                }
                _ => {
                    let widget = counters_guard.widget();
                    if !widget.select_next_page() {
                        widget.select_previous_page();
                    }
                }
            }
        }
    }

relm4/examples/grid_factory.rs (line 210)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        let mut counters_guard = self.counters.guard();

        match msg {
            AppMsg::AddCounter => {
                counters_guard.push_back(self.created_widgets);
                self.created_widgets = self.created_widgets.wrapping_add(1);
            }
            AppMsg::RemoveCounter => {
                counters_guard.pop_back();
            }
            AppMsg::SendFront(index) => {
                counters_guard.move_front(index.current_index());
            }
            AppMsg::MoveDown(index) => {
                let index = index.current_index();
                let new_index = index + 1;
                // Already at the end?
                if new_index < counters_guard.len() {
                    counters_guard.move_to(index, new_index);
                }
            }
            AppMsg::MoveUp(index) => {
                let index = index.current_index();
                // Already at the start?
                if index != 0 {
                    counters_guard.move_to(index, index - 1);
                }
            }
        }
    }

relm4/examples/tab_factory.rs (line 181)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        let mut counters_guard = self.counters.guard();

        match msg {
            AppMsg::AddCounter => {
                counters_guard.push_back(self.created_widgets);
                self.created_widgets = self.created_widgets.wrapping_add(1);
            }
            AppMsg::RemoveCounter => {
                counters_guard.pop_back();
            }
            AppMsg::SendFront(index) => {
                counters_guard.move_front(index.current_index());
            }
            AppMsg::MoveDown(index) => {
                let index = index.current_index();
                let new_index = index + 1;
                // Already at the end?
                if new_index < counters_guard.len() {
                    counters_guard.move_to(index, new_index);
                }
            }
            AppMsg::MoveUp(index) => {
                let index = index.current_index();
                // Already at the start?
                if index != 0 {
                    counters_guard.move_to(index, index - 1);
                }
            }
        }
    }

relm4/examples/entry.rs (line 104)

    fn update(&mut self, message: Self::Input, _sender: ComponentSender<Self>) {
        match message {
            AppMsg::AddCounters => {
                let text = self.entry.text();
                if let Ok(v) = text.parse::<i32>() {
                    let mut guard = self.counters.guard();
                    if v.is_positive() {
                        // add as many counters as user entered
                        for _ in 0..v {
                            guard.push_back(self.created_counters);
                            self.created_counters += 1;
                        }
                    } else if v.is_negative() {
                        // remove counters
                        for _ in v..0 {
                            guard.pop_front();
                        }
                    }

                    // clearing the entry value clears the entry widget
                    self.entry.set_text("");
                }
            }
            AppMsg::Clicked(index) => {
                if let Some(counter) = self.counters.guard().get_mut(index.current_index()) {
                    counter.value = counter.value.wrapping_sub(1);
                }
            }
        }
    }

Additional examples can be found in:

• relm4/examples/factory.rs

pub fn len(&self) -> usize

Returns the number of elements in the FactoryVecDeque.

Examples found in repository

relm4/examples/grid_factory.rs (line 227)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        let mut counters_guard = self.counters.guard();

        match msg {
            AppMsg::AddCounter => {
                counters_guard.push_back(self.created_widgets);
                self.created_widgets = self.created_widgets.wrapping_add(1);
            }
            AppMsg::RemoveCounter => {
                counters_guard.pop_back();
            }
            AppMsg::SendFront(index) => {
                counters_guard.move_front(index.current_index());
            }
            AppMsg::MoveDown(index) => {
                let index = index.current_index();
                let new_index = index + 1;
                // Already at the end?
                if new_index < counters_guard.len() {
                    counters_guard.move_to(index, new_index);
                }
            }
            AppMsg::MoveUp(index) => {
                let index = index.current_index();
                // Already at the start?
                if index != 0 {
                    counters_guard.move_to(index, index - 1);
                }
            }
        }
    }

relm4/examples/tab_factory.rs (line 198)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        let mut counters_guard = self.counters.guard();

        match msg {
            AppMsg::AddCounter => {
                counters_guard.push_back(self.created_widgets);
                self.created_widgets = self.created_widgets.wrapping_add(1);
            }
            AppMsg::RemoveCounter => {
                counters_guard.pop_back();
            }
            AppMsg::SendFront(index) => {
                counters_guard.move_front(index.current_index());
            }
            AppMsg::MoveDown(index) => {
                let index = index.current_index();
                let new_index = index + 1;
                // Already at the end?
                if new_index < counters_guard.len() {
                    counters_guard.move_to(index, new_index);
                }
            }
            AppMsg::MoveUp(index) => {
                let index = index.current_index();
                // Already at the start?
                if index != 0 {
                    counters_guard.move_to(index, index - 1);
                }
            }
        }
    }

relm4/examples/factory.rs (line 202)

    fn update(&mut self, msg: Self::Input, _sender: ComponentSender<Self>) {
        let mut counters_guard = self.counters.guard();
        match msg {
            AppMsg::AddCounter => {
                counters_guard.push_back(self.created_widgets);
                self.created_widgets = self.created_widgets.wrapping_add(1);
            }
            AppMsg::RemoveCounter => {
                counters_guard.pop_back();
            }
            AppMsg::SendFront(index) => {
                counters_guard.move_front(index.current_index());
            }
            AppMsg::MoveDown(index) => {
                let index = index.current_index();
                let new_index = index + 1;
                // Already at the end?
                if new_index < counters_guard.len() {
                    counters_guard.move_to(index, new_index);
                }
            }
            AppMsg::MoveUp(index) => {
                let index = index.current_index();
                // Already at the start?
                if index != 0 {
                    counters_guard.move_to(index, index - 1);
                }
            }
            AppMsg::Remove(index) => {
                counters_guard.remove(index.current_index());
            }
        }
    }

pub fn is_empty(&self) -> bool

Returns true if the FactoryVecDeque is empty.

pub fn send(&self, index: usize, msg: C::Input)

Send a message to one of the elements.

Examples found in repository

relm4/examples/state_management.rs (line 509)

    fn update(&mut self, msg: AppInput, _sender: ComponentSender<Self>) {
        match msg {
            AppInput::Clear => {
                self.document.emit(DocumentInput::Clear);
            }
            AppInput::Cleared => {
                self.view.guard().clear();
            }
            AppInput::AddTask => {
                self.document.emit(DocumentInput::AddTask);
            }
            AppInput::AddedTask => {
                self.view.guard().push_back(());
            }
            AppInput::DeleteTask(index) => {
                self.document.emit(DocumentInput::DeleteTask(index));
            }
            AppInput::DeletedTask(index) => {
                self.view.guard().remove(index);
            }
            AppInput::ChangeTaskName(index, name) => {
                self.document
                    .emit(DocumentInput::ChangeTaskName(index, name));
            }
            AppInput::ChangedTaskName(index, name) => {
                self.view.guard().send(index, TaskInput::ChangedName(name));
            }
            AppInput::AddTag(index, name) => {
                self.document.emit(DocumentInput::AddTag(index, name));
            }
            AppInput::AddedTag(index, name) => {
                self.view.guard().send(index, TaskInput::AddedTag(name));
            }
            AppInput::DeleteTag(task_index, tag_index) => {
                self.document
                    .emit(DocumentInput::DeleteTag(task_index, tag_index));
            }
            AppInput::DeletedTag(task_index, tag_index) => {
                self.view
                    .guard()
                    .send(task_index, TaskInput::DeletedTag(tag_index));
            }
            AppInput::None => {}
            AppInput::Save => {
                let name = "tasks.json".into();
                self.save_dialog.emit(SaveDialogMsg::SaveAs(name));
            }
            AppInput::SaveResponse(path) => {
                self.document.emit(DocumentInput::Save(path));
            }
            AppInput::Open => {
                self.open_dialog.emit(OpenDialogMsg::Open);
            }
            AppInput::OpenResponse(path) => {
                self.document.emit(DocumentInput::Open(path));
            }
        }
    }

pub fn broadcast(&self, msg: C::Input)

where C::Input: Clone,

Send clone of a message to all of the elements.

pub fn get(&self, index: usize) -> Option<&C>

Tries to get an immutable reference to the model of one element.

Returns None if index is invalid.

pub fn back(&self) -> Option<&C>

Provides a reference to the model of the back element.

Returns None if the deque is empty.

pub fn front(&self) -> Option<&C>

Provides a reference to the model of the front element.

Returns None if the deque is empty.

pub const fn widget(&self) -> &C::ParentWidget

Returns the widget all components are attached to.

Examples found in repository

relm4/examples/state_management.rs (line 154)

    fn init_widgets(
        &mut self,
        index: &Self::Index,
        root: Self::Root,
        _returned_widget: &<Self::ParentWidget as FactoryView>::ReturnedWidget,
        sender: FactorySender<Self>,
    ) -> Self::Widgets {
        let tag_list_box = self.tags.widget();

        let widgets = view_output!();

        widgets
    }

    fn init_model(_name: Self::Init, index: &DynamicIndex, sender: FactorySender<Self>) -> Self {
        let task_index = index.clone();

        let tags = FactoryVecDeque::builder().launch_default().forward(
            sender.output_sender(),
            move |output| match output {
                TagOutput::Delete(tag_index) => {
                    TaskOutput::DeleteTag(task_index.clone(), tag_index)
                }
            },
        );

        Self {
            name: "".into(),
            tags,
        }
    }
}

#[derive(Debug)]
struct Tag {
    name: String,
}

#[derive(Debug)]
enum TagInput {}

#[derive(Debug)]
enum TagOutput {
    Delete(DynamicIndex),
}

#[relm4::factory]
impl FactoryComponent for Tag {
    type Init = String;
    type Input = TagInput;
    type Output = TagOutput;
    type CommandOutput = ();
    type ParentWidget = gtk::Box;

    view! {
        gtk::MenuButton {
            #[watch]
            set_label: &self.name,

            #[wrap(Some)]
            set_popover = &gtk::Popover {
                gtk::Button {
                    set_label: "Delete",

                    connect_clicked[sender, index] => move |_| {
                        sender.output(TagOutput::Delete(index.clone())).unwrap();
                    }
                }
            }
        }
    }

    fn init_model(name: Self::Init, _index: &DynamicIndex, _sender: FactorySender<Self>) -> Self {
        Self { name }
    }
}

/// The document is a headless component which holds and manages the data model.
/// It receives input events FROM the App to update the data model.
/// When updates to the model occur, it sends output events TO the App.
///
/// The document's interface is just input and output events. As a result you have a lot of freedom
/// in how you choose to store the data model within the component, which backing store you use
/// (such as the file system, a database, or a Web API), and how you synchronise to the backing
/// store (e.g. manual save/load control, auto-saving on each change, batching up changes before
/// syncing, and so on).
struct Document {
    /// The application data model.
    /// In this case we have just stored the whole thing in memory because our requirements are
    /// simple. In a real app you might choose a more elaborate approach.
    model: Model,
}

#[derive(Default, Serialize, Deserialize)]
struct TagModel {
    name: String,
}
#[derive(Default, Serialize, Deserialize)]
struct TaskModel {
    name: String,
    tags: Vec<TagModel>,
}
#[derive(Default, Serialize, Deserialize)]
struct Model {
    tasks: Vec<TaskModel>,
}

#[derive(Debug)]
enum DocumentInput {
    // extra operations on the document itself (in this case, related to file I/O)
    Open(PathBuf),
    Save(PathBuf),

    // events related to the model that the document stores
    Clear,
    AddTask,
    DeleteTask(DynamicIndex),
    ChangeTaskName(DynamicIndex, String),
    AddTag(DynamicIndex, String),
    DeleteTag(DynamicIndex, DynamicIndex),
}

#[derive(Debug)]
enum DocumentOutput {
    Cleared,
    AddedTask,
    DeletedTask(usize),
    ChangedTaskName(usize, String),
    AddedTag(usize, String),
    DeletedTag(usize, usize),
}

impl Worker for Document {
    type Init = ();
    type Input = DocumentInput;
    type Output = DocumentOutput;

    fn init(_init: Self::Init, _sender: ComponentSender<Self>) -> Self {
        let model = Model::default();
        Self { model }
    }

    fn update(&mut self, input: DocumentInput, sender: ComponentSender<Self>) {
        match input {
            DocumentInput::Save(path) => {
                println!("Save as JSON to {path:?}");

                // TODO in a real app you would report any errors from saving the document
                if let Ok(json) = serde_json::to_string(&self.model) {
                    std::fs::write(path, json).unwrap();
                }
            }
            DocumentInput::Open(path) => {
                println!("Open tasks document at {path:?}");

                if let Ok(json) = std::fs::read_to_string(path)
                    && let Ok(new_model) = serde_json::from_str(&json)
                {
                    // update the data model
                    self.model = new_model;

                    // refresh the view from the data model
                    let _ = sender.output(DocumentOutput::Cleared);

                    for (task_index, task) in self.model.tasks.iter().enumerate() {
                        let _ = sender.output(DocumentOutput::AddedTask);

                        let task_name = task.name.clone();
                        let _ =
                            sender.output(DocumentOutput::ChangedTaskName(task_index, task_name));

                        for tag in &task.tags {
                            let tag_name = tag.name.clone();
                            let _ = sender.output(DocumentOutput::AddedTag(task_index, tag_name));
                        }
                    }
                }
            }
            DocumentInput::Clear => {
                self.model.tasks.clear();

                let _ = sender.output(DocumentOutput::Cleared);
            }
            DocumentInput::AddTask => {
                self.model.tasks.push(TaskModel::default());

                let _ = sender.output(DocumentOutput::AddedTask);
            }
            DocumentInput::DeleteTask(index) => {
                self.model.tasks.remove(index.current_index());

                let _ = sender.output(DocumentOutput::DeletedTask(index.current_index()));
            }
            DocumentInput::ChangeTaskName(index, name) => {
                if let Some(task) = self.model.tasks.get_mut(index.current_index()) {
                    task.name.clone_from(&name);
                }

                // We don't technically need to send an event, because gtk::Entry updates itself
                // this is just to make the example consistent.
                let _ = sender.output(DocumentOutput::ChangedTaskName(index.current_index(), name));
            }
            DocumentInput::AddTag(task_index, name) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.push(TagModel { name: name.clone() })
                }

                let _ = sender.output(DocumentOutput::AddedTag(task_index.current_index(), name));
            }
            DocumentInput::DeleteTag(task_index, tag_index) => {
                if let Some(task) = self.model.tasks.get_mut(task_index.current_index()) {
                    task.tags.remove(tag_index.current_index());
                }

                let _ = sender.output(DocumentOutput::DeletedTag(
                    task_index.current_index(),
                    tag_index.current_index(),
                ));
            }
        }
    }
}

/// The App is at the top level.
/// It acts as a bridge between the view and the document, forwarding events between them.
struct App {
    view: FactoryVecDeque<Task>,
    document: Controller<Document>,
    save_dialog: Controller<SaveDialog>,
    open_dialog: Controller<OpenDialog>,
}

#[derive(Debug)]
enum AppInput {
    Clear,
    Cleared,

    AddTask,
    AddedTask,

    DeleteTask(DynamicIndex),
    DeletedTask(usize),

    ChangeTaskName(DynamicIndex, String),
    ChangedTaskName(usize, String),

    AddTag(DynamicIndex, String),
    AddedTag(usize, String),

    DeleteTag(DynamicIndex, DynamicIndex),
    DeletedTag(usize, usize),

    // No-op event for when load/save dialogs result in Cancel
    None,
    Open,
    OpenResponse(PathBuf),
    Save,
    SaveResponse(PathBuf),
}

#[relm4::component]
impl SimpleComponent for App {
    type Init = ();
    type Input = AppInput;
    type Output = ();

    view! {
        main_window = gtk::ApplicationWindow {
            set_width_request: 360,
            set_title: Some("Tasks"),

            gtk::Box {
                set_orientation: gtk::Orientation::Vertical,

                gtk::HeaderBar {
                    set_show_title_buttons: false,

                    #[wrap(Some)]
                    set_title_widget = &gtk::Label {
                        set_text: ""
                    },

                    pack_start = &gtk::Button {
                        set_icon_name: "plus",
                        set_tooltip: "Add Task",

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::AddTask);
                        }
                    },

                    pack_end = &gtk::Button {
                        set_label: "Save",
                        connect_clicked => AppInput::Save,
                    },
                    pack_end = &gtk::Button {
                        set_label: "Open",
                        connect_clicked => AppInput::Open,
                    },
                },

                gtk::ScrolledWindow {
                    set_hscrollbar_policy: gtk::PolicyType::Never,
                    set_min_content_height: 360,
                    set_vexpand: true,

                    #[local_ref]
                    task_list_box -> gtk::ListBox {
                        set_selection_mode: gtk::SelectionMode::None,
                    }
                },

                gtk::Box {
                    set_hexpand: true,
                    set_spacing: DEFAULT_SPACING,
                    set_orientation: gtk::Orientation::Horizontal,

                    gtk::Label {
                        set_text: "Press Enter after editing task names",
                        set_hexpand: true,
                        set_xalign: XALIGN_CENTER,
                    },

                    gtk::Button {
                        set_icon_name: "edit-delete",
                        set_tooltip: "Delete All Tasks",
                        add_css_class: CSS_CLASS_DESTRUCTIVE_ACTION,

                        connect_clicked[sender] => move |_| {
                            sender.input(AppInput::Clear);
                        }
                    }
                }
            }
        }
    }

    fn update(&mut self, msg: AppInput, _sender: ComponentSender<Self>) {
        match msg {
            AppInput::Clear => {
                self.document.emit(DocumentInput::Clear);
            }
            AppInput::Cleared => {
                self.view.guard().clear();
            }
            AppInput::AddTask => {
                self.document.emit(DocumentInput::AddTask);
            }
            AppInput::AddedTask => {
                self.view.guard().push_back(());
            }
            AppInput::DeleteTask(index) => {
                self.document.emit(DocumentInput::DeleteTask(index));
            }
            AppInput::DeletedTask(index) => {
                self.view.guard().remove(index);
            }
            AppInput::ChangeTaskName(index, name) => {
                self.document
                    .emit(DocumentInput::ChangeTaskName(index, name));
            }
            AppInput::ChangedTaskName(index, name) => {
                self.view.guard().send(index, TaskInput::ChangedName(name));
            }
            AppInput::AddTag(index, name) => {
                self.document.emit(DocumentInput::AddTag(index, name));
            }
            AppInput::AddedTag(index, name) => {
                self.view.guard().send(index, TaskInput::AddedTag(name));
            }
            AppInput::DeleteTag(task_index, tag_index) => {
                self.document
                    .emit(DocumentInput::DeleteTag(task_index, tag_index));
            }
            AppInput::DeletedTag(task_index, tag_index) => {
                self.view
                    .guard()
                    .send(task_index, TaskInput::DeletedTag(tag_index));
            }
            AppInput::None => {}
            AppInput::Save => {
                let name = "tasks.json".into();
                self.save_dialog.emit(SaveDialogMsg::SaveAs(name));
            }
            AppInput::SaveResponse(path) => {
                self.document.emit(DocumentInput::Save(path));
            }
            AppInput::Open => {
                self.open_dialog.emit(OpenDialogMsg::Open);
            }
            AppInput::OpenResponse(path) => {
                self.document.emit(DocumentInput::Open(path));
            }
        }
    }

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let view =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    TaskOutput::Delete(index) => AppInput::DeleteTask(index),
                    TaskOutput::Name(index, name) => AppInput::ChangeTaskName(index, name),
                    TaskOutput::AddTag(index, name) => AppInput::AddTag(index, name),
                    TaskOutput::DeleteTag(task_index, tag_index) => {
                        AppInput::DeleteTag(task_index, tag_index)
                    }
                });

        let document =
            Document::builder()
                .launch(())
                .forward(sender.input_sender(), |msg| match msg {
                    DocumentOutput::Cleared => AppInput::Cleared,
                    DocumentOutput::DeletedTask(index) => AppInput::DeletedTask(index),
                    DocumentOutput::DeletedTag(task_index, tag_index) => {
                        AppInput::DeletedTag(task_index, tag_index)
                    }
                    DocumentOutput::AddedTask => AppInput::AddedTask,
                    DocumentOutput::AddedTag(index, name) => AppInput::AddedTag(index, name),
                    DocumentOutput::ChangedTaskName(index, name) => {
                        AppInput::ChangedTaskName(index, name)
                    }
                });

        let save_dialog = SaveDialog::builder()
            .transient_for_native(&root)
            .launch(SaveDialogSettings {
                create_folders: true,
                accept_label: "Save".into(),
                cancel_label: "Cancel".into(),
                is_modal: true,
                filters: tasks_filename_filters(),
            })
            .forward(sender.input_sender(), |response| match response {
                SaveDialogResponse::Accept(path) => AppInput::SaveResponse(path),
                SaveDialogResponse::Cancel => AppInput::None,
            });

        let open_dialog = OpenDialog::builder()
            .transient_for_native(&root)
            .launch(OpenDialogSettings {
                create_folders: false,
                folder_mode: false,
                cancel_label: "Cancel".into(),
                accept_label: "Open".into(),
                is_modal: true,
                filters: tasks_filename_filters(),
            })
            .forward(sender.input_sender(), |response| match response {
                OpenDialogResponse::Accept(path) => AppInput::OpenResponse(path),
                OpenDialogResponse::Cancel => AppInput::None,
            });

        let app = App {
            view,
            document,
            open_dialog,
            save_dialog,
        };

        let task_list_box = app.view.widget();
        let widgets = view_output!();

        ComponentParts {
            model: app,
            widgets,
        }
    }

relm4/examples/to_do.rs (line 154)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let tasks =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |output| match output {
                    TaskOutput::Delete(index) => AppMsg::DeleteEntry(index),
                });

        let model = App { tasks };

        let task_list_box = model.tasks.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/tab_factory.rs (line 174)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryVecDeque::builder()
            .launch(adw::TabView::default())
            .forward(sender.input_sender(), |output| match output {
                CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
            });
        let model = App {
            created_widgets: counter,
            counters,
        };

        let tab_view = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/grid_factory.rs (line 203)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                    CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                    CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
                });

        let model = App {
            created_widgets: counter,
            counters,
        };

        let counter_grid = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/factory.rs (line 179)

    fn init(
        counter: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters =
            FactoryVecDeque::builder()
                .launch_default()
                .forward(sender.input_sender(), |msg| match msg {
                    CounterOutput::SendFront(index) => AppMsg::SendFront(index),
                    CounterOutput::MoveUp(index) => AppMsg::MoveUp(index),
                    CounterOutput::MoveDown(index) => AppMsg::MoveDown(index),
                    CounterOutput::Remove(index) => AppMsg::Remove(index),
                });

        let model = App {
            created_widgets: counter,
            counters,
        };

        let counter_box = model.counters.widget();
        let widgets = view_output!();

        ComponentParts { model, widgets }
    }

relm4/examples/tab_game.rs (line 230)

    fn init(
        _: Self::Init,
        root: Self::Root,
        sender: ComponentSender<Self>,
    ) -> ComponentParts<Self> {
        let counters = FactoryVecDeque::builder()
            .launch(adw::TabView::default())
            .forward(sender.input_sender(), |output| match output {
                CounterOutput::StartGame(index) => AppMsg::StartGame(index),
                CounterOutput::SelectedGuess(guess) => AppMsg::SelectedGuess(guess),
            });

        let mut model = App {
            counters,
            start_index: None,
        };

        let tab_view = model.counters.widget();
        let widgets = view_output!();

        let mut counters_guard = model.counters.guard();
        for i in 0..3 {
            counters_guard.push_back(i);
        }

        // Explicitly drop the guard,
        // so that 'model' is no longer borrowed
        // and can be moved inside ComponentParts
        counters_guard.drop();

        ComponentParts { model, widgets }
    }

    fn update(&mut self, msg: Self::Input, sender: ComponentSender<Self>, _root: &Self::Root) {
        match msg {
            AppMsg::StartGame(index) => {
                self.start_index = Some(index);
                sender.command(|sender, _| async move {
                    for i in (1..4).rev() {
                        *GAME_STATE.write() = GameState::Countdown(i);
                        relm4::tokio::time::sleep(Duration::from_millis(1000)).await;
                    }
                    *GAME_STATE.write() = GameState::Running;
                    for _ in 0..20 {
                        relm4::tokio::time::sleep(Duration::from_millis(500)).await;
                        sender.send(false).unwrap();
                    }
                    relm4::tokio::time::sleep(Duration::from_millis(1000)).await;
                    sender.send(true).unwrap();
                });
            }
            AppMsg::StopGame => {
                *GAME_STATE.write() = GameState::Guessing;
            }
            AppMsg::SelectedGuess(index) => {
                *GAME_STATE.write() = GameState::End(index == self.start_index.take().unwrap());
            }
        }
    }

    fn update_cmd(
        &mut self,
        msg: Self::CommandOutput,
        sender: ComponentSender<Self>,
        _root: &Self::Root,
    ) {
        if msg {
            sender.input(AppMsg::StopGame);
        } else {
            let mut counters_guard = self.counters.guard();
            match rand::random::<u8>() % 3 {
                0 => {
                    counters_guard.swap(1, 2);
                }
                1 => {
                    counters_guard.swap(0, 1);
                }
                _ => {
                    let widget = counters_guard.widget();
                    if !widget.select_next_page() {
                        widget.select_previous_page();
                    }
                }
            }
        }
    }

pub fn iter( &self, ) -> impl DoubleEndedIterator<Item = &C> + ExactSizeIterator + FusedIterator

Returns an iterator over the components.

pub fn from_iter( component_iter: impl IntoIterator<Item = C::Init>, widget: C::ParentWidget, ) -> Self

Creates a FactoryVecDeque from any IntoIterator

pub fn extend(&mut self, component_iter: impl IntoIterator<Item = C::Init>)

Adds multiple components to the back of the FactoryVecDeque.

This method takes an iterator over components and adds each one to the deque, rendering them efficiently.

impl<C> FactoryVecDeque<C>

where C: FactoryComponent<Index = DynamicIndex>, C::ParentWidget: IsA<Stack>, C::Root: IsA<Widget>,

pub fn set_visible(&self, index: usize) -> bool

Makes the element at a given index visible in a gtk::Stack. Returns true on success, otherwise false.

Trait Implementations

impl<C> Clone for FactoryVecDeque<C>

where C: CloneableFactoryComponent + FactoryComponent<Index = DynamicIndex>,

Implements the Clone Trait for FactoryVecDeque<C> where C is Cloneable

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Debug for FactoryVecDeque<C>

where C: FactoryComponent<Index = DynamicIndex> + Debug, C::ParentWidget: Debug, C::Output: Debug,

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

Formats the value using the given formatter.

impl<C> Drop for FactoryVecDeque<C>

where C: FactoryComponent<Index = DynamicIndex>,

fn drop(&mut self)

Executes the destructor for this type.

impl<C> Index<usize> for FactoryVecDeque<C>

where C: FactoryComponent<Index = DynamicIndex>,

type Output = C

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.