how to use multiple message Enum

[tareksalem]

Hi,
I have this component

use iced::{Element, Column, Image, Length, Text, Align, Container, Row, Button, button, Command, Clipboard};

use super::state::{MarkData, Message};

// #[derive(Debug)]
pub struct MarkComponent{
    pub data: MarkData
}

impl MarkComponent{
    pub fn new(data: MarkData) -> Self {
        MarkComponent{
            data: data
        }
    }
    pub fn view(&mut self) -> Element<Message> {
        Column::new()
        .push(
            Image::new(&self.data.image).width(Length::Units(250)).height(Length::Units(250))
            // Text::new(&item.image)
        )
        .push(
            Text::new(&self.data.title)
        )
        .push(
            Text::new(&self.data.description)
        )
        .align_items(Align::Center)
        .padding(10)
        .width(Length::FillPortion(1)).into()
    }
}

#[derive(Clone, Debug)]
pub struct MarkComponents{
    pub data: Vec<MarkData>,
    items: Vec<MarkComponent>,
    read_more_state: button::State
}

impl MarkComponents{
    pub fn new() -> Self {
        let all_items = MarkData::all();
        MarkComponents{
            data: all_items.clone(),
            items: Vec::from_iter(
                all_items.iter().map(|item| {
                    MarkComponent::new(item.clone())
                })
            ),
            read_more_state: button::State::new()
        }
    }
    fn update(&mut self, message: Message, _clipboard: &mut Clipboard) -> Command<Message> {
        println!("===================================== button clicked");
        Command::none()
    }
    fn render_content(&mut self) -> Element<Message> {
        let mut all_content = Column::new();
        let mut row: Row<Message> = Row::new().width(Length::Fill).spacing(50).align_items(Align::Center);
        let mut splicer = 0;
        let mut count = 0;
        let mut marks = MarkData::all();
        let marks_count = marks.len();
        let columns_count: u16 = 2;
        for item in self.items.iter_mut() {
            count+=1;
            // row = row.push(MarkComponent::new(item).view());
            row = row.push(item.view());
            if splicer == columns_count -1 {
                all_content = all_content.push(row);
                row = Row::new().width(Length::Fill).spacing(50).align_items(Align::Center);
                splicer = 0;
            } else if count == marks_count {
                all_content = all_content.push(row);
                row = Row::new().width(Length::Fill).spacing(50).align_items(Align::Center);
                splicer = 0;
            } else {
                splicer+=1;
            }
        }
        all_content = all_content.push(
            Button::new(&mut self.read_more_state, Text::new("read more")).on_press(Message::LoadMore)
        );
        Container::new(all_content).into()
    }
    pub fn view(&mut self) -> Element<Message> {
        self.render_content()
    }
}

And have the main application as the following:

use iced::{executor, Application, Clipboard, Command, Element, Settings, Length, Scrollable, Container, scrollable, Row, Column, Image, Space};
mod components;
use components::{state::{Message}, mark_component::{MarkComponents}};
pub fn main() -> iced::Result {
    Mark::run(Settings::default())
}

struct Mark {
    body_scroll: scrollable::State,
    sidebar_scroll: scrollable::State,
    mark_components: MarkComponents,
}



impl Application for Mark {
    type Executor = executor::Default;
    type Message = Message;
    type Flags = ();
    fn new(_flags: ()) -> (Mark, Command<Message>) {
        let app: Mark = Mark {
            body_scroll: scrollable::State::new(),
            sidebar_scroll: scrollable::State::new(),
            mark_components: MarkComponents::new()
        };
        (app, Command::none())
    }
    fn title(&self) -> String {
        String::from("A cool application")
    }

    fn update(&mut self, _message: Self::Message, _clipboard: &mut Clipboard) -> Command<Self::Message> {
        println!("================================= there is a button clicked");
        Command::none()
    }
    fn view(&mut self) -> Element<Self::Message> {
        let mut content = Column::new()
        .width(Length::Fill)
        .align_items(iced::Align::Center)
        .spacing(10);
        let sidebar = Scrollable::new(&mut self.sidebar_scroll).width(Length::FillPortion(2)).
        push(Space::new(Length::Fill, Length::Units(1500)));
        let body = Scrollable::new(&mut self.body_scroll).width(Length::FillPortion(5))
        .push(self.mark_components.view());
        content = content.push(
            Row::new()
            .push(
                sidebar
            ).push(
                body
            ).spacing(20)
        );

        Container::new(content).into()
    }
}

what I want, is the ability to use a separated Message enum for the MarkComponents to handle its events separately
thanks

[Kaiden42]

You can take a look at the todo and tour examples on how to use multiple message enums for different parts of your UI.