Layout rework

Author: gintsgints

src/config.rs

@@ -1,17 +1,15 @@
 mod exercise;
-mod keyboard;
-mod lesson;
 mod index;
+mod lesson;
 
 use index::Index;
 use serde::{Deserialize, Serialize};
 use std::{fs, path::PathBuf};
 use thiserror::Error;
 
 use crate::{environment, Result};
-pub use keyboard::{Keyboard, PressedKeyCoord};
-pub use lesson::Exercise;
 pub use index::IndexRecord;
+pub use lesson::Exercise;
 use lesson::{Lesson, LessonPage};
 
 #[derive(Deserialize, Serialize, Default)]
@@ -28,10 +26,9 @@ pub struct Configuration {
 
 #[derive(Debug, Clone, Default)]
 pub struct Config {
-    pub keyboard: Keyboard,
     pub lesson: Lesson,
     pub index: Index,
-    current_keyboard: String,
+    pub current_keyboard: String,
     current_lesson: String,
     current_page: usize,
     current_exercise: usize,
@@ -75,15 +72,9 @@ impl Config {
             }
         };
 
-        let keyboard = Keyboard::load(
-            Self::data_dir()
-                .join("keyboards")
-                .join(format!("{}.yaml", current_keyboard)),
-        )?;
         let lesson = Lesson::load(Self::data_dir().join(format!("{}.yaml", current_lesson)))?;
         let index = Index::load(Self::data_dir().join("index.yaml"))?;
         Ok(Config {
-            keyboard,
             lesson,
             index,
             current_keyboard,
@@ -94,15 +85,18 @@ impl Config {
     }
 
     pub async fn save(self) -> core::result::Result<(), Error> {
-        let config_to_save =    Configuration {
+        let config_to_save = Configuration {
             current_keyboard: self.current_keyboard.clone(),
             current_lesson: self.current_lesson.clone(),
             current_page: self.current_page,
             current_exercise: self.current_exercise,
         };
-        let config = serde_yaml::to_string(&config_to_save).map_err(|e| Error::Parse(e.to_string()))?;
+        let config =
+            serde_yaml::to_string(&config_to_save).map_err(|e| Error::Parse(e.to_string()))?;
         let path = Self::path();
-        tokio::fs::write(path, &config).await.map_err(|e| Error::Write(e.to_string()))?;
+        tokio::fs::write(path, &config)
+            .await
+            .map_err(|e| Error::Write(e.to_string()))?;
         Ok(())
     }
 

src/config/lesson.rs

@@ -2,7 +2,8 @@ use serde::Deserialize;
 use std::{fs, path::PathBuf};
 use thiserror::Error;
 
-use super::keyboard::PressedKeyCoord;
+use crate::keyboard_config::PressedKeyCoord;
+
 pub use super::exercise::Exercise;
 
 #[derive(Debug, Default, Clone, Deserialize)]

src/keyboard.rs src/keyboard_component.rssrc/keyboard.rs renamed to src/keyboard_component.rs

@@ -6,7 +6,7 @@ use iced::{
     Color, Element, Event, Length, Point, Rectangle, Renderer, Size, Theme,
 };
 
-use crate::config::PressedKeyCoord;
+use crate::keyboard_config::{KeyboardConfig, PressedKeyCoord};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Message {
@@ -17,18 +17,18 @@ pub enum Message {
 }
 
 #[derive(Default)]
-pub struct Keyboard {
+pub struct KeyboardComponent {
     draw_cache: Cache,
-    config: crate::config::Keyboard,
+    config: KeyboardConfig,
     pressed_keys: Vec<PressedKeyCoord>,
     show_keys: Vec<PressedKeyCoord>,
     key_to_show: usize,
     hide: bool,
 }
 
-impl Keyboard {
-    pub fn new(config: crate::config::Keyboard) -> Keyboard {
-        Keyboard {
+impl KeyboardComponent {
+    pub fn new(config: KeyboardConfig) -> KeyboardComponent {
+        KeyboardComponent {
             config,
             ..Default::default()
         }
@@ -94,7 +94,7 @@ impl Keyboard {
                 self.pressed_keys.clear();
                 self.key_to_show = 0;
                 self.hide = false;
-            },
+            }
         }
     }
 
@@ -106,7 +106,7 @@ impl Keyboard {
     }
 }
 
-impl<Message> canvas::Program<Message> for Keyboard {
+impl<Message> canvas::Program<Message> for KeyboardComponent {
     type State = ();
 
     fn draw(

src/config/keyboard.rs src/keyboard_config.rssrc/config/keyboard.rs renamed to src/keyboard_config.rs

@@ -103,7 +103,7 @@ pub struct Row {
 }
 
 #[derive(Debug, Clone, Default, Deserialize)]
-pub struct Keyboard {
+pub struct KeyboardConfig {
     pub cols_for_keys: f32,
     pub space_between_keys: f32,
     pub keyboard_corner_curve: f32,
@@ -113,10 +113,10 @@ pub struct Keyboard {
     pub rows: Vec<Row>,
 }
 
-impl Keyboard {
+impl KeyboardConfig {
     pub fn load(path: PathBuf) -> Result<Self, Error> {
         let content = fs::read_to_string(path).map_err(|e| Error::Read(e.to_string()))?;
-        let keyboard: Keyboard =
+        let keyboard: KeyboardConfig =
             serde_yaml::from_str(&content).map_err(|e| Error::Parse(e.to_string()))?;
         Ok(keyboard)
     }

src/main.rs

@@ -3,27 +3,31 @@ pub type Error = Box<dyn std::error::Error>;
 
 use config::{Config, IndexRecord};
 use exercise::Exercise;
-use keyboard::Keyboard;
+use keyboard_component::KeyboardComponent;
 
 use handlebars::Handlebars;
 use iced::{
     event,
     keyboard::{key, Modifiers},
-    widget::{self, button, canvas::path::lyon_path::geom::euclid::num::Round, column, container, text},
+    widget::{
+        self, button, canvas::path::lyon_path::geom::euclid::num::Round, column, container, text,
+    },
     window, Element, Event, Length, Subscription, Task,
 };
 use serde_json::json;
 
+use crate::keyboard_config::KeyboardConfig;
+
 mod config;
 mod environment;
 mod exercise;
 mod font;
-mod keyboard;
+mod keyboard_component;
+mod keyboard_config;
 
 pub const TICK_MILIS: u64 = 500;
 
 fn main() -> iced::Result {
-
     font::set();
 
     iced::application("Raiti - Touch typing tutor", Raiti::update, Raiti::view)
@@ -43,7 +47,7 @@ struct Raiti {
     exercise: Vec<Exercise>,
     was_errors: u64,
     was_wpm: f64,
-    keyboard: Keyboard,
+    keyboard: KeyboardComponent,
     show_confirm: bool,
 }
 
@@ -52,7 +56,7 @@ pub enum Message {
     Event(Event),
     Tick,
     Exercise(exercise::Message),
-    Keyboard(keyboard::Message),
+    Keyboard(keyboard_component::Message),
     LessonSelected(IndexRecord),
     Confirm,
     WindowSettingsSaved(core::result::Result<(), config::Error>),
@@ -62,13 +66,18 @@ impl Raiti {
     fn new() -> (Self, Task<Message>) {
         // Read config & initialize state
         let config = Config::load().expect("Error loading context");
+        let keyboard_config = KeyboardConfig::load(
+            Config::data_dir()
+                .join("keyboards")
+                .join(format!("{}.yaml", &config.current_keyboard)),
+        ).expect("Error loading keyboard config");
 
 
         (
             Self {
                 config: config.clone(),
                 exercise: vec![],
-                keyboard: Keyboard::new(config.keyboard.clone()),
+                keyboard: KeyboardComponent::new(keyboard_config),
                 ..Default::default()
             },
             widget::focus_next(),
@@ -89,7 +98,7 @@ impl Raiti {
                     exercise.update(exercise::Message::Event(event.clone()));
                 }
                 self.keyboard
-                    .update(keyboard::Message::Event(event.clone()));
+                    .update(keyboard_component::Message::Event(event.clone()));
                 if let Event::Keyboard(iced::keyboard::Event::KeyPressed {
                     key,
                     location,
@@ -137,7 +146,7 @@ impl Raiti {
                     exercise.update(exercise::Message::Tick);
                 }
 
-                self.keyboard.update(keyboard::Message::Tick);
+                self.keyboard.update(keyboard_component::Message::Tick);
                 Task::none()
             }
             Message::Keyboard(message) => {
@@ -232,12 +241,12 @@ impl Raiti {
         self.calculate_stats();
 
         self.exercise.clear();
-        self.keyboard.update(keyboard::Message::ClearKeys);
+        self.keyboard.update(keyboard_component::Message::ClearKeys);
         self.config.next_page();
         if let Some(page) = self.config.get_page() {
             if !page.show_keys.is_empty() {
                 self.keyboard
-                    .update(keyboard::Message::SetShowKeys(page.show_keys.clone()))
+                    .update(keyboard_component::Message::SetShowKeys(page.show_keys.clone()))
             }
         }
         if let Some(ex) = self.config.get_exercise() {
@@ -269,7 +278,7 @@ impl Raiti {
             length += ex.exercise.chars().map(|_| 1).sum::<u64>();
         }
         self.was_errors = errors.round();
-        let was_wpm = ((length as f64 - errors as f64) / (mseconds as f64 / 60000.0))/ 5.0;
+        let was_wpm = ((length as f64 - errors as f64) / (mseconds as f64 / 60000.0)) / 5.0;
         self.was_wpm = (was_wpm * 100.0).round() / 100.0;
     }
 }