Splitting kana set

src/pages/selector.rs

@@ -0,0 +1,166 @@
+use crate::pages::dictionary::DictionaryState;
+use crate::navigation::Page::*;
+use crate::navigation::{NavigatedPage, Page, RootMessage};
+use crate::pages::randomizer::RandomizerState;
+use crate::pages::repetitions::RepetitionsState;
+use crate::pages::selector::SelectorMessage::ChangeMode;
+use crate::styling::*;
+use crate::pages::sync::SyncState;
+use crate::pages::writing::WritingState;
+use iced::widget::button::{Status, Style};
+use iced::widget::*;
+use iced::{Element, Task, alignment};
+use iced_core::Alignment::Center;
+use iced_core::Background;
+use iced_core::Color;
+use parking_lot::Mutex;
+use std::sync::Arc;
+use crate::app::AppState;
+use crate::core::kana_set::{KanaSet, KanaType};
+use crate::pages::quiz::QuizState;
+
+pub struct SelectorState {
+    pub set: KanaSet,
+    is_writing: bool,
+    state: Arc<Mutex<AppState>>,
+}
+
+#[derive(Debug, Clone)]
+pub enum SelectorMessage {
+    Change,
+    Goto,
+    Check(usize, bool),
+    ChangeMode(bool),
+    ToDictionary,
+    ToRandomize,
+    ToRepetitions,
+    ToSync,
+}
+
+impl NavigatedPage<SelectorMessage> for SelectorState {
+    fn navigate(&mut self, message: &SelectorMessage) -> Option<Page> {
+        if let SelectorMessage::Goto = message {
+            return if self.is_writing {
+                let writing = WritingState::new(&self.set);
+                Some(Writing(writing))
+            } else {
+                let mut quiz = QuizState::new();
+                quiz.set = self.set.clone();
+                Some(Quiz(quiz))
+            };
+        }
+        if let SelectorMessage::ToDictionary = message {
+            return Some(Dictionary(DictionaryState::new(self.state.clone())));
+        }
+        if let SelectorMessage::ToRandomize = message {
+            return Some(Randomizer(RandomizerState::default()));
+        }
+        if let SelectorMessage::ToRepetitions = message {
+            return Some(Repetitions(RepetitionsState::new(self.state.clone())));
+        }
+        if let SelectorMessage::ToSync = message {
+            return Some(Sync(SyncState::new(self.state.clone())));
+        }
+        None
+    }
+
+    fn navigated(&mut self) {}
+    fn update(&mut self, message: SelectorMessage) -> Task<RootMessage> {
+        match message {
+            SelectorMessage::Change => match self.set.chars_type {
+                KanaType::Katakana => self.set = KanaSet::hiragana(),
+                KanaType::Hiragana => self.set = KanaSet::katakana(),
+            },
+            SelectorMessage::Check(i, b) => self.set.include_map[i] = b,
+            ChangeMode(b) => self.is_writing = b,
+            _ => {}
+        }
+        Task::none()
+    }
+    fn view(&self) -> Element<'_, SelectorMessage> {
+        container(
+            iced::widget::column![
+                row![
+                    button("あ ↔ ア")
+                        .on_press(SelectorMessage::Change)
+                        .style(jl_button),
+                    button("Словарь")
+                        .on_press(SelectorMessage::ToDictionary)
+                        .style(Self::nav_style),
+                    button("Повторение")
+                        .on_press(SelectorMessage::ToRepetitions)
+                        .style(Self::nav_style),
+                    button("Рандомайзер")
+                        .on_press(SelectorMessage::ToRandomize)
+                        .style(Self::nav_style),
+                    button("Синхронизация")
+                        .on_press(SelectorMessage::ToSync)
+                        .style(Self::nav_style)
+                ]
+                .spacing(DEFAULT_SPACING),
+                scrollable(self.rows_selector()).horizontal(),
+                toggler(self.is_writing)
+                    .label("Режим письма")
+                    .on_toggle(ChangeMode),
+                button("К тесту")
+                    .on_press(SelectorMessage::Goto)
+                    .style(cta_button),
+            ]
+            .spacing(DEFAULT_SPACING),
+        )
+        .padding(10)
+        .into()
+    }
+}
+
+impl SelectorState {
+    pub fn new(state: Arc<Mutex<AppState>>) -> Self {
+        Self {
+            set: Default::default(),
+            is_writing: false,
+            state,
+        }
+    }
+
+    fn nav_style(theme: &Theme, status: Status) -> Style {
+        let mut basic = button::text(theme, status);
+        basic.background = if status == Status::Hovered {
+            Some(Background::Color(Color::WHITE.scale_alpha(0.1)))
+        } else {
+            None
+        };
+        basic.border.radius = BUTTON_RADIUS.into();
+        basic
+    }
+
+    fn rows_selector(&self) -> Element<'_, SelectorMessage> {
+        let mut row = Row::new();
+
+        for i in 0..self.set.dictionary.len() {
+            let setup_checked = move |b: bool| -> SelectorMessage { SelectorMessage::Check(i, b) };
+
+            let mut chars_column: Column<'_, _> = Column::new();
+            chars_column =
+                chars_column.push(checkbox(self.set.include_map[i]).on_toggle(setup_checked));
+
+            for v in &self.set.dictionary[i] {
+                chars_column = chars_column.push(
+                    container(text!("{}", v.0.clone().to_lowercase()).size(40))
+                        .align_y(Center)
+                        .align_x(Center)
+                        .width(80)
+                        .height(80)
+                        .style(container::rounded_box),
+                );
+            }
+
+            row = row.push(
+                chars_column
+                    .spacing(DEFAULT_SPACING)
+                    .align_x(alignment::Horizontal::Center),
+            );
+        }
+
+        row.spacing(DEFAULT_SPACING).into()
+    }
+}