Struct FactoryVecDequeBuilder 

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

A builder-pattern struct for building a FactoryVecDeque.

Implementations

impl<C> FactoryVecDequeBuilder<C>

where C: FactoryComponent<Index = DynamicIndex>, C::ParentWidget: Default,

pub fn launch_default(self) -> FactoryVecDequeConnector<C>

Launch the factory with a default parent widget.

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/to_do.rs (line 147)

    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/grid_factory.rs (line 191)

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

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

impl<C> FactoryVecDequeBuilder<C>

where C: FactoryComponent<Index = DynamicIndex>,

pub fn new() -> Self

Create a builder for this component.

pub fn launch(self, widget: C::ParentWidget) -> FactoryVecDequeConnector<C>

Launch the factory. This is similar to Connector::launch.

Examples found in repository

relm4/examples/entry.rs (line 85)

    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/tab_factory.rs (line 163)

    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/tab_game.rs (line 219)

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

Trait Implementations

impl<C> Debug for FactoryVecDequeBuilder<C>

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

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

Formats the value using the given formatter.

impl<C> Default for FactoryVecDequeBuilder<C>

where C: FactoryComponent<Index = DynamicIndex>,

fn default() -> Self

Returns the “default value” for a type.