install_framework_gui/renderer/
window.rs

1// Copyright 2021 Yuri6037
2
3// Permission is hereby granted, free of charge, to any person obtaining a copy
4// of this software and associated documentation files (the "Software"),
5// to deal in the Software without restriction, including without limitation
6// the rights to use, copy, modify, merge, publish, distribute, sublicense,
7// and/or sell copies of the Software, and to permit persons to whom the
8// Software is furnished to do so, subject to the following conditions:
9
10// The above copyright notice and this permission notice shall be included in
11// all copies or substantial portions of the Software.
12
13// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19// IN THE SOFTWARE.
20
21use std::string::String;
22use iced::Application;
23use iced::executor;
24use iced::Clipboard;
25use std::sync::Arc;
26use iced_futures::Command;
27use iced::Element;
28use iced::Subscription;
29use async_channel::Sender;
30use async_channel::Receiver;
31use async_channel::SendError;
32use iced::Column;
33use iced::Align;
34use iced::Text;
35
36use super::queue::MessageQueue;
37use super::welcome::WelcomePage;
38use super::error::ErrorPage;
39use super::processing::ProcessingPage;
40use super::home::HomePage;
41use super::finish::FinishPage;
42use crate::messages;
43use crate::messages::RenderMessage;
44use crate::messages::ThreadMessage;
45use crate::error::GuiError;
46
47pub trait ConstructiblePage
48{
49    type PageType : Page + 'static;
50    fn new(page: &messages::Page) -> Self::PageType;
51}
52
53pub trait Page
54{
55    fn handle_message(&mut self, msg: &RenderMessage, sender: &mut Sender<ThreadMessage>) -> Result<(), SendError<ThreadMessage>>;
56    fn update(&mut self, msg: &PageMessage, _: &mut Sender<ThreadMessage>) -> Result<bool, SendError<ThreadMessage>>;
57    fn view(&mut self) -> Element<PageMessage>;
58}
59
60#[derive(Clone)]
61pub enum PageMessage
62{
63    Next,
64    Close,
65    UserInstallSelected(bool),
66    InstallFlagSelected(bool),
67    TextChanged(String),
68    ToggleComponent(usize)
69}
70
71#[derive(Clone)]
72pub enum GuiMessage
73{
74    MainThread(Arc<RenderMessage>),
75    Page(PageMessage)
76}
77
78impl std::fmt::Debug for GuiMessage
79{
80    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error>
81    {
82        return Ok(());
83    }
84}
85
86pub struct InstallerWindow
87{
88    sender: Sender<ThreadMessage>,
89    receiver: Receiver<RenderMessage>,
90    page: Option<Box<dyn Page>>,
91    exit: bool
92}
93
94impl InstallerWindow
95{
96    fn switch_page<TPage: ConstructiblePage>(&mut self, page: &messages::Page)
97    {
98        self.page = Some(Box::new(TPage::new(page)));
99    }
100
101    fn enum_to_type(&mut self, pagemsg: &messages::Page)
102    {
103        match pagemsg
104        {
105            messages::Page::Welcome(_, _, _) => self.switch_page::<WelcomePage>(pagemsg),
106            messages::Page::Error(_) => self.switch_page::<ErrorPage>(pagemsg),
107            messages::Page::Processing => self.switch_page::<ProcessingPage>(pagemsg),
108            messages::Page::ComponentView(_, _, _) => self.switch_page::<HomePage>(pagemsg),
109            messages::Page::Finish(_) => self.switch_page::<FinishPage>(pagemsg)
110        }
111    }
112}
113
114impl Application for InstallerWindow
115{
116    type Executor = executor::Default;
117    type Message = GuiMessage;
118    type Flags = (Sender<ThreadMessage>, Receiver<RenderMessage>);
119
120    fn new((sender, receiver): Self::Flags) -> (Self, Command<GuiMessage>)
121    {
122        return (
123            InstallerWindow
124            {
125                sender: sender,
126                receiver: receiver,
127                page: None,
128                exit: false
129            },
130            Command::none()
131        );
132    }
133
134    fn title(&self) -> String
135    {
136        return String::from("Installer Framework");
137    }
138
139    fn update(&mut self, msg: GuiMessage, _: &mut Clipboard) -> Command<GuiMessage>
140    {
141        match msg
142        {
143            GuiMessage::MainThread(msg) =>
144            {
145                if let RenderMessage::SwitchPage(new_page) = msg.as_ref()
146                {
147                    self.enum_to_type(new_page);
148                }
149                if let Some(page) = &mut self.page
150                {
151                    if let Err(e) = page.handle_message(&msg, &mut self.sender)
152                    {
153                        self.switch_page::<ErrorPage>(&messages::Page::Error(GuiError::channel_send(e)));
154                    }
155                }
156            },
157            GuiMessage::Page(msg) =>
158            {
159                if let Some(page) = &mut self.page
160                {
161                    match page.update(&msg, &mut self.sender)
162                    {
163                        Err(e) => self.switch_page::<ErrorPage>(&messages::Page::Error(GuiError::channel_send(e))),
164                        Ok(v) => self.exit = v
165                    };
166                }
167            }
168        };
169        return Command::none();
170    }
171
172    fn should_exit(&self) -> bool
173    {
174        return self.exit;
175    }
176
177    fn view(&mut self) -> Element<GuiMessage>
178    {
179        if let Some(page) = &mut self.page
180        {
181            let container = page.view();
182            return Column::new()
183                .spacing(10)
184                .padding(10)
185                .align_items(Align::Center)
186                .push(container.map(GuiMessage::Page))
187                .into();
188        }
189        else
190        {
191            return Column::new()
192                .spacing(10)
193                .padding(10)
194                .align_items(Align::Center)
195                .push(Text::new("Initializing..."))
196                .into();
197        }
198    }
199
200    fn subscription(&self) -> Subscription<GuiMessage>
201    {
202        return Subscription::from_recipe(MessageQueue
203        {
204            channel: self.receiver.clone()
205        }).map(|msg| GuiMessage::MainThread(Arc::new(msg)));
206    }
207}