correct history order on history page

Reviewed-on: #19

Cargo.lock

@@ -2203,7 +2203,7 @@ checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jap_learn"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "criterion",
@@ -2230,7 +2230,7 @@ dependencies = [
  "sha2",
  "tokio",
  "zip",
- "zstd 0.14.0",
+ "zstd 0.14.1",
 ]
 
 [[package]]
@@ -2501,9 +2501,6 @@ name = "litemap"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
-dependencies = [
- "serde_core",
-]
 
 [[package]]
 name = "litrs"
@@ -3596,9 +3593,9 @@ checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
 dependencies = [
  "chacha20",
  "getrandom 0.4.1",
@@ -3857,9 +3854,9 @@ dependencies = [
 
 [[package]]
 name = "rhai"
-version = "1.26.0"
+version = "1.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6e1be9d697d537ce450766df42ad6adf1a93f25f21d73217354ad7e3d3dae1"
+checksum = "0334639972c0ea5a3fd366aa36116754a11431b619fec3ed559b3f73bcbcebf5"
 dependencies = [
  "ahash",
  "bitflags 2.10.0",
@@ -4925,9 +4922,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.53.1"
+version = "1.53.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
+checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
 dependencies = [
  "bytes",
  "libc",
@@ -6488,11 +6485,11 @@ dependencies = [
 
 [[package]]
 name = "zstd"
-version = "0.14.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf06bd8162af0734b344780deb55b42a2429ae430870d13fcc12f238e880fe6e"
+checksum = "a4a9ecd0608fac4196ed58e1f337e9a72680fcc9ee449b8bcde6acea680b46f0"
 dependencies = [
- "zstd-safe 8.0.0",
+ "zstd-safe 8.1.0",
 ]
 
 [[package]]
@@ -6506,18 +6503,18 @@ dependencies = [
 
 [[package]]
 name = "zstd-safe"
-version = "8.0.0"
+version = "8.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae42c0555055784c70058d19ba8e275528e8a99a706684868ace5da4e716a4ab"
+checksum = "bdd44c6a7284e91f3717755b24315a302edd9153a01f753c3cba3d765e8eafac"
 dependencies = [
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.1.0+zstd.1.5.7"
+version = "2.1.1+zstd.1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"
+checksum = "aeec9eaf2dffbbd09201e23bd0ffcbaa33bb8e9266a10734fd7ed90a85eca078"
 dependencies = [
  "cc",
  "pkg-config",

Cargo.toml

@@ -1,23 +1,23 @@
 [package]
 name = "jap_learn"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]
 iced = { version = "0.14.0", features = ["tokio", "svg", "lazy", "crisp", "tiny-skia", "wayland", "wgpu"], default-features = false}
 iced_core = "0.14.0"
-rand = "0.10.2"
+rand = "0.10.3"
 dirs = "7.0.0"
 serde_json = "1.0.151"
-rhai = { version = "1.26.0", features = ["sync"] }
+rhai = { version = "1.26.1", features = ["sync"] }
 chrono = "0.4.45"
 rusqlite = { version = "0.40.2", features = ["chrono", "bundled"] }
 reqwest = { version = "0.13.5", features = ["json", "stream", "multipart"] }
 rodio = "0.22.2"
 sha2 = "0.11.0"
-tokio = { version = "1.53.1", features = ["rt", "rt-multi-thread", "macros"] }
+tokio = { version = "1.53.2", features = ["rt", "rt-multi-thread", "macros"] }
 hex = "0.4.3"
-zstd = "0.14.0"
+zstd = "0.14.1"
 zip = "8.6.0"
 rfd = "0.17.2"
 mimalloc = "0.1.52"
@@ -27,7 +27,7 @@ parking_lot = "0.12.5"
 env_logger = "0.11.11"
 log = "0.4.34"
 fsrs = "6.6.2"
-litemap = { version = "0.8.3", features = ["serde"] }
+litemap = { version = "0.8.3" }
 
 [profile.super-release]
 inherits = "release"

sql/exam.sql

@@ -0,0 +1,5 @@
+create table exams(
+    id integer primary key,
+    timestamp integer,
+    deck_id integer  not null references decks on delete cascade
+);

sql/exam_entry.sql

@@ -0,0 +1,7 @@
+create table exam_entries
+(
+    id      integer primary key,
+    exam_id integer not null references exams on delete cascade,
+    word_id integer not null references words on delete cascade,
+    status integer default null
+);

src/app.rs

@@ -1,5 +1,6 @@
 use crate::data::repositories::Repository;
 use crate::data_provider::card_states::CardStateRepository;
+use crate::data_provider::custom_fields::CustomFieldRepository;
 use crate::data_provider::decks::DeckRepository;
 use crate::data_provider::history::HistoryRepository;
 use crate::data_provider::settings::get_setting;
@@ -17,7 +18,7 @@ use log::info;
 use parking_lot::{Mutex, RwLock};
 use rusqlite::Connection;
 use std::sync::Arc;
-use crate::data_provider::custom_fields::CustomFieldRepository;
+use crate::data_provider::exam::{ExamEntryRepository, ExamRepository};
 
 pub const USER_FONT: Font = Font::with_name("Noto Sans JP");
 
@@ -70,6 +71,8 @@ pub struct AppState {
     pub connection: Arc<Mutex<SqliteConnection>>,
     pub sync_data: Arc<RwLock<AppSettings>>,
     pub history: HistoryRepository,
+    pub exam: ExamRepository,
+    pub exam_entries: ExamEntryRepository
 }
 
 impl Default for AppState {
@@ -87,7 +90,9 @@ impl AppState {
             word_groups: WordGroupRepository::new(connection.clone()),
             card_states: CardStateRepository::new(connection.clone()),
             history: HistoryRepository::new(connection.clone()),
+            exam: ExamRepository::new(connection.clone()),
             custom_fields: CustomFieldRepository::new(connection.clone()),
+            exam_entries: ExamEntryRepository::new(connection.clone()),
             sync_data: Arc::new(RwLock::new(AppSettings {
                 key: None,
                 auto_web_fetch: false,
@@ -108,7 +113,8 @@ pub fn fill_state(state: &mut AppState) {
     state.history.write().start().unwrap();
     state.card_states.write().start().unwrap();
     state.custom_fields.write().start().unwrap();
-
+    state.exam.write().start().unwrap();
+    state.exam_entries.write().start().unwrap();
     state.sync_data = Arc::new(RwLock::new(setting))
 }
 

src/core/deck.rs

@@ -1,20 +1,21 @@
-use std::collections::HashMap;
 use crate::app::AppState;
 use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS};
 use crate::core::srs::{
     FsrsModule, OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule,
     WordOpenMode, WorstWordsSRSModule,
 };
+use crate::data::Id;
 use crate::data::entities::*;
 use crate::data::repositories::Repository;
 use crate::data_provider::card_states::CardStateRepositoryInner;
 use crate::notification::MaybeError;
 use chrono::Utc;
+use litemap::LiteMap;
 use log::info;
 use rhai::{Engine, Scope};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Instant;
-use crate::data::Id;
 
 #[derive(Clone)]
 pub struct DeckData {
@@ -26,6 +27,11 @@ pub struct DeckData {
     open_mode: OrderMode,
     settings: DeckSettings,
 }
+
+struct DisplayStyle {
+    properties: LiteMap<String, String>,
+}
+
 impl DeckData {
     pub fn new(settings: &DeckSettings, open_mode: OrderMode, state: AppState) -> Self {
         let states_repo = state.card_states.read();
@@ -156,11 +162,17 @@ impl DeckData {
         if let Ok(ast) = ast {
             let groups = state.word_groups.read().iter().cloned().collect::<Vec<_>>();
             let dictionary = &state.dictionary.read();
-            let fields : HashMap<Id, String> = HashMap::from_iter(state.custom_fields.read().iter().map(|f| (f.id, f.identifier.clone())));
+            let fields: HashMap<Id, String> = HashMap::from_iter(
+                state
+                    .custom_fields
+                    .read()
+                    .iter()
+                    .map(|f| (f.id, f.identifier.clone())),
+            );
             let query = dictionary.query_par(Arc::new(move |word| {
                 let mut more = rhai::Map::new();
                 for kv in &word.additional {
-                    more.insert(fields[&kv.0].clone().into(), kv.1.clone().into());
+                    more.insert(fields[kv.0].clone().into(), kv.1.clone().into());
                 }
                 let mut scope = Scope::new();
                 let group_name = groups[groups

src/core/srs.rs

@@ -1,7 +1,6 @@
 use crate::data::entities::CardState;
 use chrono::{Local, TimeDelta};
 use fsrs::FSRS;
-use log::{debug, info};
 use rand::distr::weighted::WeightedIndex;
 use rand::prelude::ThreadRng;
 use rand::prelude::{Distribution, SliceRandom};
@@ -67,6 +66,18 @@ pub struct SemiRandomSRSModule {
     generator: ThreadRng,
 }
 impl SRSModule for SemiRandomSRSModule {
+    fn new(set: &[&CardState]) -> Self {
+        let weights = set
+            .iter()
+            .map(|s| (100.0 / s.calculated_score()).powf(2.0) * 2.0)
+            .collect::<Vec<f32>>();
+
+        Self {
+            generator: rng(),
+            last_weights: WeightedIndex::new(weights).expect("Incorrect weights update"),
+            history: vec![],
+        }
+    }
     fn next(&mut self, set: &[&CardState]) -> usize {
         let index = self.last_weights.sample(&mut self.generator);
 
@@ -87,18 +98,6 @@ impl SRSModule for SemiRandomSRSModule {
             .update_weights(&[(index, &new_weight)])
             .expect("update weights error");
     }
-    fn new(set: &[&CardState]) -> Self {
-        let weights = set
-            .iter()
-            .map(|s| (100.0 / s.calculated_score()).powf(2.0) * 2.0)
-            .collect::<Vec<f32>>();
-
-        Self {
-            generator: rng(),
-            last_weights: WeightedIndex::new(weights).expect("Incorrect weights update"),
-            history: vec![],
-        }
-    }
 }
 impl SemiRandomSRSModule {
     fn history_len(&self, set: &[&CardState]) -> usize {
@@ -114,6 +113,16 @@ pub struct WorstWordsSRSModule {
     rounds_count: u8,
 }
 impl SRSModule for WorstWordsSRSModule {
+    fn new(_: &[&CardState]) -> Self {
+        WorstWordsSRSModule {
+            pool_size: PARTIAL_POOL_SIZE,
+            rounds_count: 2,
+            rounds_remaining: 0,
+            pool: vec![],
+            queue: vec![],
+        }
+    }
+
     fn next(&mut self, set: &[&CardState]) -> usize {
         if self.rounds_remaining == 0 {
             self.fill_pool(set);
@@ -131,16 +140,6 @@ impl SRSModule for WorstWordsSRSModule {
     }
 
     fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardState) {}
-
-    fn new(_: &[&CardState]) -> Self {
-        WorstWordsSRSModule {
-            pool_size: PARTIAL_POOL_SIZE,
-            rounds_count: 2,
-            rounds_remaining: 0,
-            pool: vec![],
-            queue: vec![],
-        }
-    }
 }
 impl WorstWordsSRSModule {
     fn fill_pool(&mut self, set: &[&CardState]) {
@@ -157,9 +156,7 @@ impl WorstWordsSRSModule {
 
 #[derive(Clone)]
 pub struct FsrsModule {
-    today_set: Vec<usize>,
+    next_round: Vec<usize>,
-    solved: Vec<usize>,
-    current_group: Vec<usize>,
     queue: Vec<usize>,
     rng: ThreadRng,
     fsrs: FSRS,
@@ -170,29 +167,22 @@ impl SRSModule for FsrsModule {
         let today = Local::now().date_naive();
 
         let mut new = Self {
-            today_set: set
+            queue: set
                 .iter()
                 .enumerate()
                 .filter(|(_, c)| c.fsrs_open_day <= today)
                 .map(|(index, _)| index)
                 .collect(),
-            current_group: vec![],
+            next_round: vec![],
-            queue: vec![],
-            solved: vec![],
             rng: rng(),
             fsrs: FSRS::default(),
         };
-        new.today_set.shuffle(&mut new.rng);
+        new.queue.shuffle(&mut new.rng);
-        new.fill_partial_pool();
 
         new
     }
 
     fn next(&mut self, _: &[&CardState]) -> usize {
-        if self.current_group.is_empty() {
-            self.fill_partial_pool();
-        }
-
         if self.queue.is_empty() {
             self.fill_queue();
             self.queue.shuffle(&mut self.rng);
@@ -230,37 +220,21 @@ impl SRSModule for FsrsModule {
         updated_word.fsrs_open_day = next_day;
         updated_word.fsrs_opened = updated_word.last_open.date_naive();
 
-        if (updated_word.fsrs_open_day != today && !first_time)
+        if (updated_word.fsrs_open_day == today && !first_time)
-            || (first_time && status == WordOpenMode::Easy)
+            || (first_time && status != WordOpenMode::Easy)
         {
-            info!("For today word on index {} solved", index);
+            self.next_round.push(index);
-            self.solved.push(index);
-            let index = self.current_group.iter().position(|x| *x == index).unwrap();
-            self.current_group.remove(index);
         }
     }
 }
 
 impl FsrsModule {
-    fn fill_partial_pool(&mut self) {
-        debug!("Filling partial pool");
-        self.current_group.extend(
-            self.today_set
-                .iter()
-                .filter(|x| !self.solved.contains(*x))
-                .take(PARTIAL_POOL_SIZE),
-        );
-
-        self.queue.clear();
-        self.queue.extend(self.current_group.clone());
-    }
-
     fn fill_queue(&mut self) {
-        self.queue.extend(self.current_group.clone());
+        self.queue.append(&mut self.next_round);
     }
 
     pub fn finished(&self) -> bool {
-        self.today_set.len() == self.solved.len()
+        self.queue.is_empty() && self.next_round.is_empty()
     }
 }
 

src/data/entities.rs

@@ -1,5 +1,5 @@
 use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, WordOpenMode};
-use crate::data::{Id, SmallId, INVALID_ID};
+use crate::data::{INVALID_ID, Id};
 use crate::data_provider::history::HistoryRepositoryInner;
 use chrono::{DateTime, Local, NaiveDate, Utc};
 use fsrs::MemoryState;
@@ -101,6 +101,9 @@ impl HistoryRepositoryInner {
                     count = 0;
                 }
             }
+            if count != 0 {
+                counts.push((date, count));
+            }
         }
         counts
     }
@@ -130,8 +133,8 @@ impl DeckSettings {
         DeckSettings {
             id: 0.into(),
             name,
-            forward: "".to_string(),
+            forward: String::new(),
-            backward: "".to_string(),
+            backward: String::new(),
             filter: "true".to_string(),
         }
     }
@@ -143,7 +146,7 @@ impl DeckSettings {
         ast.is_ok()
     }
     pub fn require_speech(&self) -> bool {
-        self.forward == "speech" || self.backward == "speech"
+        self.forward.contains("speech") || self.backward.contains("speech")
     }
 }
 
@@ -213,6 +216,40 @@ impl EntityData for CustomField {
     }
 }
 
+#[derive(Clone)]
+pub struct Exam {
+    pub id: Id,
+    pub timestamp: DateTime<Utc>,
+    pub deck_id: Id,
+}
+
+impl EntityData for Exam {
+    fn id(&self) -> Id {
+        self.id
+    }
+    fn set_id(&mut self, id: Id) {
+        self.id = id;
+    }
+}
+
+#[derive(Clone)]
+pub struct ExamEntry{
+    pub id: Id,
+    pub exam_id: Id,
+    pub word_id: Id,
+    pub status: Option<bool>
+}
+
+impl EntityData for ExamEntry {
+    fn id(&self) -> Id {
+        self.id
+    }
+    
+    fn set_id(&mut self, id: Id) {
+        self.id = id;
+    }
+}
+
 pub struct EntityHandle<E> {
     pub(crate) id: Id,
     index: u32,

src/data_provider/card_states.rs

@@ -1,15 +1,22 @@
-use crate::data::Id;
 use crate::data::entities::CardState;
 use crate::data::repositories::{DataRepository, DataRepositoryInner, Query};
+use crate::data::Id;
+use crate::data_access_methods;
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use chrono::NaiveDate;
 use fsrs::MemoryState;
 use rusqlite::{Error, Params, Row};
 use std::sync::Arc;
 
-pub type CardStateRepository = DataRepository<CardState, CardStateDbLayer>;
+data_access_methods!(
-pub type CardStateRepositoryInner = DataRepositoryInner<CardState, CardStateDbLayer>;
+    CardStateDbLayer,
-pub type CardStateDbLayer = SqliteDbLayer<CardState, CardStatesQuerySet>;
+    CardStateRepository,
+    CardStateRepositoryInner,
+    CardState,
+    CardStatesQuerySet,
+    CardStateQuery
+);
+
 #[derive(Clone)]
 pub struct CardStatesQuerySet;
 impl TableAccessQuerySet<CardState> for CardStatesQuerySet {

src/data_provider/custom_fields.rs

@@ -2,10 +2,9 @@ use crate::data::entities::CustomField;
 use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
+use crate::data_access_methods;
 
-pub type CustomFieldRepository = DataRepository<CustomField, CustomFieldDbLayer>;
+data_access_methods!(CustomFieldDbLayer, CustomFieldRepository, CustomFieldRepositoryInner, CustomField, CustomFieldsQuerySet, CustomFieldQuery);
-pub type CustomFieldRepositoryInner = DataRepositoryInner<CustomField, CustomFieldDbLayer>;
-pub type CustomFieldDbLayer = SqliteDbLayer<CustomField, CustomFieldsQuerySet>;
 #[derive(Clone)]
 pub struct CustomFieldsQuerySet;
 impl TableAccessQuerySet<CustomField> for CustomFieldsQuerySet {

src/data_provider/exam.rs

@@ -0,0 +1,98 @@
+use crate::data::entities::{Exam, ExamEntry};
+use crate::data::repositories::*;
+use crate::data_access_methods;
+use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
+use rusqlite::{Error, Params, Row};
+
+data_access_methods!(
+    ExamDataLayer,
+    ExamRepository,
+    ExamRepositoryInner,
+    Exam,
+    ExamQuerySet,
+    ExamQuery
+);
+
+data_access_methods!(
+    ExamEntryLayer,
+    ExamEntryRepository,
+    ExamEntryRepositoryInner,
+    ExamEntry,
+    ExamEntryQuerySet,
+    ExamEntryQuery
+);
+
+#[derive(Clone)]
+pub struct ExamQuerySet;
+
+impl TableAccessQuerySet<Exam> for ExamQuerySet {
+    fn load() -> &'static str {
+        "SELECT id, timestamp, deck_id FROM exams"
+    }
+
+    fn save() -> &'static str {
+        "UPDATE exams set deck_id = $1, timestamp = $2 WHERE id = $3"
+    }
+
+    fn add() -> &'static str {
+        "INSERT INTO exams (timestamp, deck_id) values ($1, $2)"
+    }
+
+    fn name() -> &'static str {
+        "exams"
+    }
+
+    fn from_sql(row: &Row) -> Result<Exam, Error> {
+        Ok(Exam {
+            id: row.get(0)?,
+            timestamp: row.get(1)?,
+            deck_id: row.get(2)?,
+        })
+    }
+
+    fn insert_params(entity: &Exam) -> impl Params {
+        (entity.timestamp.timestamp(), entity.deck_id)
+    }
+
+    fn update_params(entity: &Exam) -> impl Params {
+        (entity.timestamp.timestamp(), entity.deck_id, entity.id)
+    }
+}
+
+#[derive(Clone)]
+pub struct ExamEntryQuerySet;
+
+impl TableAccessQuerySet<ExamEntry> for ExamEntryQuerySet {
+    fn load() -> &'static str {
+        "SELECT id, exam_id, word_id, status FROM exam_entries"
+    }
+
+    fn save() -> &'static str {
+        "UPDATE exam_entries set status = $1 WHERE id = $2"
+    }
+
+    fn add() -> &'static str {
+        "INSERT into exam_entries (exam_id, word_id, status) VALUES ($1, $2, $3)"
+    }
+
+    fn name() -> &'static str {
+        "exam_entries"
+    }
+
+    fn from_sql(row: &Row) -> Result<ExamEntry, Error> {
+        Ok(ExamEntry {
+            id: row.get(0)?,
+            exam_id: row.get(1)?,
+            word_id: row.get(2)?,
+            status: row.get(3)?,
+        })
+    }
+
+    fn insert_params(entity: &ExamEntry) -> impl Params {
+        (entity.exam_id, entity.word_id, entity.status)
+    }
+
+    fn update_params(entity: &ExamEntry) -> impl Params {
+        (entity.status, entity.id)
+    }
+}

src/data_provider/history.rs

@@ -4,10 +4,9 @@ use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::types::{FromSql, FromSqlResult, ToSqlOutput, ValueRef};
 use rusqlite::{Error, Params, Row, ToSql};
+use crate::data_access_methods;
 
-pub type HistoryRepository = DataRepository<HistoryNote, HistoryDataLayer>;
+data_access_methods!(HistoryDataLayer, HistoryRepository, HistoryRepositoryInner, HistoryNote, HistoryQuerySet, HistoryQuery);
-pub type HistoryRepositoryInner = DataRepositoryInner<HistoryNote, HistoryDataLayer>;
-pub type HistoryDataLayer = SqliteDbLayer<HistoryNote, HistoryQuerySet>;
 
 #[derive(Clone)]
 pub struct HistoryQuerySet;

src/data_provider/import.rs

@@ -1,11 +1,11 @@
 use crate::helpers::into_result;
 use crate::notification::NotificationData;
 use crate::notification::NotificationData::IncorrectAnkiFile;
+use crate::pages::import::AnkiSchema;
 use log::info;
 use rusqlite::Connection;
 use serde_json::Value;
 use std::collections::BTreeMap;
-use crate::pages::import::AnkiSchema;
 
 #[derive(Clone)]
 pub struct ImportData(pub(crate) Vec<ImportGroup>);
@@ -26,14 +26,13 @@ pub struct ImportNote {
     pub fields: Vec<String>,
 }
 
-pub fn load_groups(connection: &Connection, schema: AnkiSchema) -> Result<ImportData, NotificationData> {
+pub fn load_groups(
+    connection: &Connection,
+    schema: AnkiSchema,
+) -> Result<ImportData, NotificationData> {
     match schema {
-        AnkiSchema::Old => {
+        AnkiSchema::Old => load_old_schema(connection),
-            load_old_schema(connection)
+        AnkiSchema::Beta => load_new_schema(connection),
-        }
-        AnkiSchema::Beta => {
-            load_new_schema(connection)
-        }
     }
 }
 
@@ -94,8 +93,8 @@ fn load_old_schema(connection: &Connection) -> Result<ImportData, NotificationDa
     }
     Err(IncorrectAnkiFile)
 }
-fn load_new_schema(connection: &Connection) -> Result<ImportData, NotificationData> {
+fn load_new_schema(_: &Connection) -> Result<ImportData, NotificationData> {
-    return Err(IncorrectAnkiFile);
+    Err(IncorrectAnkiFile)
 }
 pub fn get_words_of_group(
     connection: &Connection,

src/data_provider/mod.rs

@@ -19,6 +19,7 @@ pub(crate) mod voice;
 pub(crate) mod web_api;
 pub mod word_groups;
 pub(crate) mod words;
+pub(crate) mod exam;
 
 pub trait TableAccessQuerySet<T> {
     fn load() -> &'static str;
@@ -190,3 +191,12 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> BatchedDbLayer<T> for SqliteDbLay
         Ok(())
     }
 }
+
+#[macro_export]
+macro_rules! data_access_methods {
+    ($layer:ident, $repo:ident, $repoinner:ident, $data:ty, $queryset:ty, $query:ident) => {
+pub type $repo = DataRepository<$data, $layer>;
+pub type $repoinner = DataRepositoryInner<$data, $layer>;
+pub type $layer = SqliteDbLayer<$data, $queryset>;
+    };
+}

src/data_provider/sqlite.rs

@@ -24,6 +24,8 @@ fn create_tables(conn: &Connection) {
     make_card_stats(conn).expect("Failed to init table");
     make_history(conn).expect("Failed to init table");
     make_custom_fields(conn).expect("Failed to init table");
+    make_exams(conn).expect("Failed to init table");
+    make_exam_entry(conn).expect("Failed to init table");
 }
 
 fn make_settings(conn: &Connection) -> Result<(), rusqlite::Error> {
@@ -68,6 +70,18 @@ fn make_custom_fields(conn: &Connection) -> Result<(), rusqlite::Error> {
     Ok(())
 }
 
+fn make_exams(conn: &Connection) -> Result<(), rusqlite::Error> {
+    let query = include_str!("../../sql/exam.sql");
+    conn.execute(query, ())?;
+    Ok(())
+}
+
+fn make_exam_entry(conn: &Connection) -> Result<(), rusqlite::Error> {
+    let query = include_str!("../../sql/exam_entry.sql");
+    conn.execute(query, ())?;
+    Ok(())
+}
+
 pub fn default_connection() -> Connection {
     let db_file = db_path();
     let connection = Connection::open(db_file).expect("Failed to open database");
@@ -76,12 +90,9 @@ pub fn default_connection() -> Connection {
         .expect("Failed to set PRAGMA");
     connection
         .query_one("PRAGMA journal_mode = WAL;", [], |row| {
-            println!("{:?}", row);
             Ok(())
         })
-        .unwrap_or_else(|e| {
+        .expect("Failed to init database");
-            println!("{}", e);
-        });
     connection
         .execute("PRAGMA synchronous = NORMAL;", [])
         .expect("Failed to set PRAGMA");

src/data_provider/web_api.rs

@@ -1,9 +1,12 @@
 use crate::fs::*;
-use crate::notification::NotificationData::{CompressError, PermissionDenied, WebApiUnavailable};
+use crate::notification::NotificationData::{
+    CompressError, OpenFileError, PermissionDenied, WebApiUnavailable,
+};
 use crate::notification::{MaybeError, NotificationData};
-use log::info;
+use log::{debug, info};
 use std::io;
-use tokio::fs::{File, OpenOptions};
+use std::time::Instant;
+use tokio::fs::{File, OpenOptions, remove_file};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use zstd::{DEFAULT_COMPRESSION_LEVEL, Decoder, Encoder};
 
@@ -35,10 +38,13 @@ pub async fn send_data(id: String) -> MaybeError {
 }
 
 fn compress(data: Vec<u8>) -> Result<Vec<u8>, NotificationData> {
+    let time = Instant::now();
     let mut encoder =
-        Encoder::new(Vec::new(), DEFAULT_COMPRESSION_LEVEL).map_err(|_| CompressError)?;
+        Encoder::new(Vec::new(), 17).map_err(|_| CompressError)?;
     io::copy(&mut &data[..], &mut encoder).map_err(|_| PermissionDenied)?;
-    encoder.finish().map_err(|_| CompressError)
+    let result = encoder.finish().map_err(|_| CompressError);
+    debug!("Compress time: {:?}", time.elapsed());
+    result
 }
 
 pub async fn load_data(id: String, temp: bool) -> MaybeError {
@@ -49,7 +55,7 @@ pub async fn load_data(id: String, temp: bool) -> MaybeError {
         .get(&id_url)
         .send()
         .await
-        .map_err(|_| WebApiUnavailable)?
+        .map_err(|e| WebApiUnavailable)?
         .bytes()
         .await
         .map_err(|_| WebApiUnavailable)?
@@ -74,6 +80,12 @@ pub async fn load_data(id: String, temp: bool) -> MaybeError {
         .await
         .map_err(|_| WebApiUnavailable)?;
     set_local_version(version.parse::<u32>().unwrap_or_default()).await?;
+    if db_wal().exists() {
+        remove_file(db_wal()).await.map_err(|_| OpenFileError)?;
+    }
+    if db_shm().exists() {
+        remove_file(db_shm()).await.map_err(|_| OpenFileError)?;
+    }
     Ok(())
 }
 

src/data_provider/word_groups.rs

@@ -2,10 +2,9 @@ use crate::data::entities::WordGroup;
 use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
+use crate::data_access_methods;
 
-pub type WordGroupRepository = DataRepository<WordGroup, WordGroupDataLayer>;
+data_access_methods!(WordGroupDataLayer, WordGroupRepository, WordGroupRepositoryInner, WordGroup, WordGroupQuerySet, WordGroupQuery);
-pub type WordGroupRepositoryInner = DataRepositoryInner<WordGroup, WordGroupDataLayer>;
-pub type WordGroupDataLayer = SqliteDbLayer<WordGroup, WordGroupQuerySet>;
 
 #[derive(Clone)]
 pub struct WordGroupQuerySet;

src/data_provider/words.rs

@@ -1,13 +1,13 @@
+use crate::data::Id;
 use crate::data::entities::WordData;
 use crate::data::repositories::{DataRepository, DataRepositoryInner};
-use crate::data::Id;
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use litemap::LiteMap;
 use rusqlite::{Error, Params, Row};
+use crate::data_access_methods;
+
+data_access_methods!(WordDataLayer, WordRepository, WordRepositoryInner, WordData, WordQuerySet, WordQuery);
 
-pub type WordRepository = DataRepository<WordData, WordDataLayer>;
-pub type WordRepositoryInner = DataRepositoryInner<WordData, WordDataLayer>;
-pub type WordDataLayer = SqliteDbLayer<WordData, WordQuerySet>;
 #[derive(Clone)]
 pub struct WordQuerySet;
 impl TableAccessQuerySet<WordData> for WordQuerySet {
@@ -69,25 +69,15 @@ fn additional_to_string(map: &LiteMap<Id, String>) -> String {
     parts.join("")
 }
 
-fn additional_from_string_temp(data: String) -> LiteMap<Id, String> {
-
-    let pre_map : LiteMap<String, String> = serde_json::from_str(data.as_str()).unwrap();
-    LiteMap::from(pre_map.iter().map(|(k, v)| (match k.as_str() {
-        "reading" => Id(1),
-        "description" => Id(2),
-        "context" => Id(3),
-        &_ => Id(0) }, v.to_string())).collect())
-}
-
 fn additional_from_string(data: String) -> LiteMap<Id, String> {
     if data.is_empty() {
-        return LiteMap::new()
+        return LiteMap::new();
     }
     let parts = data.split('').collect::<Vec<&str>>();
     let chunks = parts.chunks(2).collect::<Vec<&[&str]>>();
     let mut map = LiteMap::with_capacity(parts.len());
     for part in &chunks {
-        let id : Id = part[0].parse().unwrap();
+        let id: Id = part[0].parse().unwrap();
         let value: String = part[1].to_string();
         map.insert(id, value);
     }

src/fs.rs

@@ -16,6 +16,14 @@ pub fn app_data_dir() -> PathBuf {
 pub fn db_path() -> PathBuf {
     app_data_dir().join("data.db")
 }
+
+pub fn db_wal() -> PathBuf {
+    app_data_dir().join("data.db-wal")
+}
+pub fn db_shm() -> PathBuf {
+    app_data_dir().join("data.db-shm")
+}
+
 pub fn temp_db_path() -> PathBuf {
     app_data_dir().join("data.db.tmp")
 }

src/navigation.rs

@@ -1,4 +1,4 @@
-use crate::app::{AppState, fill_state};
+use crate::app::{fill_state, AppState};
 use crate::data_provider::sqlite::create_db;
 use crate::data_provider::web_api::{
     get_local_version, get_web_version, load_data, set_local_version,
@@ -12,6 +12,7 @@ use crate::notification::{
 };
 use crate::pages::dictionary::{DictionaryMessage, DictionaryState};
 use crate::pages::dictionary_quiz::{DictionaryQuizMessage, DictionaryQuizState};
+use crate::pages::exams::{ExamsMessage, ExamsState};
 use crate::pages::history::{HistoryMessage, HistoryState};
 use crate::pages::import::{ImportMessage, ImportState};
 use crate::pages::quiz::{QuizMessage, QuizState};
@@ -32,6 +33,7 @@ use iced::{Element, Task};
 use iced_core::Length::Fill;
 use log::{debug, info};
 use std::time::Instant;
+use crate::pages::exam::{ExamMessage, ExamState};
 
 impl Default for ScreenState {
     fn default() -> Self {
@@ -59,6 +61,8 @@ pub enum RootMessage {
     History(HistoryMessage),
     RepetitionSettings(RepetitionSettingsMessage),
     Import(ImportMessage),
+    Exams(ExamsMessage),
+    Exam(ExamMessage),
     Keyboard(Event),
     PushNotification(NotificationRequest),
     Notification(NotificationMessage),
@@ -80,6 +84,8 @@ pub enum Page {
     History(HistoryState),
     RepetitionSettings(RepetitionSettingsState),
     Import(ImportState),
+    Exams(ExamsState),
+    Exam(ExamState),
     PreviousPage,
 }
 
@@ -182,7 +188,9 @@ impl ScreenState {
                 Sync,
                 History,
                 RepetitionSettings,
-                Import
+                Import,
+                Exams,
+                Exam
             );
         }
         debug!("Update took {:?}", time.elapsed());
@@ -205,7 +213,9 @@ impl ScreenState {
             Sync,
             History,
             RepetitionSettings,
-            Import
+            Import,
+            Exams,
+                Exam
         )
     }
 
@@ -225,7 +235,9 @@ impl ScreenState {
             Sync,
             History,
             RepetitionSettings,
-            Import
+            Import,
+            Exams,
+                Exam
         );
 
         let notifications = self.notification_manager.draw().map(Notification);
@@ -239,6 +251,7 @@ impl ScreenState {
             return match page {
                 Repetition(page) => page.press(&message),
                 Dictionary(page) => page.press(&message),
+                Exam(page) => page.press(&message),
                 _ => Task::none(),
             };
         }

src/notification.rs

@@ -138,8 +138,8 @@ impl NotificationManager {
 
     fn draw_data<'a>(data: &NotificationData) -> Element<'a, NotificationMessage> {
         match data {
-            NotificationData::DataLoaded => {
+            NotificationData::DataSynced => {
-                text!("Данные успешно загружены на сервер")
+                text!("Данные успешно синхронизированы")
             }
             NotificationData::ImportError => {
                 text!("Ошибка при импорте данных из Anki")
@@ -148,7 +148,7 @@ impl NotificationManager {
                 text!("Неподдерживаемый формат файла .apkg")
             }
             NotificationData::OpenFileError => {
-                text!("Ошибка открытия файла пакета")
+                text!("Ошибка открытия файла")
             }
             NotificationData::VoiceVoxUnavailable => {
                 text!("Не получается подключиться к VoiceVox")
@@ -168,6 +168,9 @@ impl NotificationManager {
             NotificationData::CompressError => {
                 text!("Ошибка сжатия или распаковки данных")
             }
+            NotificationData::LocalVersionChanged => {
+                text!("Локальная версия будет заменена")
+            }
         }
         .width(Fill)
         .into()
@@ -184,7 +187,7 @@ pub enum NotificationRequest {
 #[derive(Clone, Debug)]
 pub enum NotificationData {
     PermissionDenied,
-    DataLoaded,
+    DataSynced,
     ImportError,
     IncorrectAnkiFile,
     OpenFileError,
@@ -193,6 +196,7 @@ pub enum NotificationData {
     DbSaveError,
     DbLoadError,
     CompressError,
+    LocalVersionChanged,
 }
 
 pub type MaybeError = Result<(), NotificationData>;

src/pages.rs

@@ -11,3 +11,5 @@ pub mod selector;
 pub mod sync;
 pub mod word;
 pub mod writing;
+pub mod exams;
+pub mod exam;

src/pages/dictionary.rs

@@ -1,7 +1,7 @@
 use crate::app::AppState;
+use crate::data::Id;
 use crate::data::entities::{EntityHandle, WordData, WordGroup};
 use crate::data::repositories::{Query, Repository};
-use crate::data::Id;
 use crate::data_provider::word_groups::{WordGroupDataLayer, WordGroupRepositoryInner};
 use crate::data_provider::words::WordDataLayer;
 use crate::data_provider::words::WordRepositoryInner;
@@ -13,26 +13,27 @@ use crate::pages::dictionary::SelectionChangeDirection::*;
 use crate::pages::dictionary_quiz::DictionaryQuizState;
 use crate::pages::import::ImportState;
 use crate::pages::word::{WordEditor, WordMessage};
-use crate::push_error_task;
 use crate::styling::*;
 use crate::widgets::hard_mouse_area::hard_mouse_area;
 use crate::{jl_button, push_error};
+use crate::{jl_text_input, push_error_task};
 use chrono::{DateTime, TimeDelta, Utc};
 use hashbrown::{HashMap, HashSet};
 use iced::alignment::Vertical::Center;
 use iced::widget::button::Style;
-use iced::widget::button::{danger, text};
+use iced::widget::button::{danger};
 use iced::widget::operation::focus;
 use iced::widget::space::horizontal;
-use iced::widget::text_input::default;
 use iced::widget::text_input::Status::Active;
-use iced::widget::*;
+use iced::widget::text_input::default;
-use iced::{Border, Color, Shadow, Task};
+use iced::widget::{row, container, column, text_input, space, button, scrollable, text, Row, checkbox, Column, toggler, lazy};
-use iced_core::keyboard;
+use iced::{Border, Color, Element, Shadow, Task};
+use iced_core::Length::{Fill, FillPortion};
+use iced_core::border::Radius;
+use iced_core::keyboard::Key::Named;
 use iced_core::keyboard::key::Physical::Code;
 use iced_core::keyboard::{Event, Modifiers};
-use iced_core::keyboard::Key::Named;
+use iced_core::{keyboard, Padding, Theme};
-use iced_core::Length::{Fill, FillPortion};
 use log::info;
 use rand::random_range;
 use std::ops::Add;
@@ -81,7 +82,7 @@ pub enum DictionaryMessage {
     EditField(String),
     ChangeSelectedField(SelectionChangeDirection),
     EditorAction(WordMessage),
-    ExtendedWordEdited
+    ExtendedWordEdited,
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Copy)]
@@ -97,6 +98,7 @@ pub enum BasicWordFields {
     Key,
     Value,
     Tags,
+    TotalLine,
 }
 
 const FIELDS: &[BasicWordFields] = &[Key, Value, Tags];
@@ -150,8 +152,8 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
             }
             ExtendedEdit(i) => {
                 self.word_editor = Some(self.editor_for_word(i));
-                if let Some((handle, cell, index)) = self.selected_cell.clone() {
+                if let Some((_, _, index)) = self.selected_cell {
-                    self.selected_cell = Some((i, cell, index))
+                    self.selected_cell = Some((i, TotalLine, index))
                 }
             }
             Include(i, b) => {
@@ -253,7 +255,9 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                     let _ = dictionary.save(&mut handle);
                     if reload_query {
                         self.displayed_words_query.load(&dictionary);
-                        if let Some(selected) = self.selected_cell && selected.0 == original {
+                        if let Some(selected) = self.selected_cell
+                            && selected.0 == original
+                        {
                             self.selected_cell = Some((handle, selected.1, selected.2));
                             if self.word_editor.is_some() {
                                 self.word_editor = Some(self.editor_for_word(handle));
@@ -267,7 +271,10 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
             GotoImport => {}
             SelectField(e, f, index) => {
                 info!("Editing word {}", e.id);
-                if self.word_editor.is_some() && let Some(selected) = &self.selected_cell && selected.0 != e {
+                if self.word_editor.is_some()
+                    && let Some(selected) = &self.selected_cell
+                    && selected.0 != e
+                {
                     self.word_editor = Some(self.editor_for_word(e));
                 }
                 self.selected_cell = Some((e, f, index));
@@ -289,6 +296,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                             Tags => {
                                 word.tags = value;
                             }
+                            _ => {}
                         }
                     }
 
@@ -349,45 +357,47 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 }
 
                 self.displayed_words_query.load(&dictionary);
-                   self.selected_cell = None;
+                self.selected_cell = None;
-                   self.word_editor = None;
+                self.word_editor = None;
-
             }
             EditorAction(action) => {
                 let result = self.word_editor.as_mut().unwrap().update(action);
                 if let Some(result) = result {
                     match result {
-                        DeleteWord(_) |
+                        DeleteWord(_) | ExtendedWordEdited => {
-                            ExtendedWordEdited => {
                             return Task::done(RootMessage::Dictionary(result));
-                        },
+                        }
 
                         _ => {}
                     }
                 }
             }
             ExtendedWordEdited => {
-                return self.launch_auto_save_offset(self.selected_cell.unwrap().0);
+                let handle = self.word_editor.as_ref().unwrap().word_handle;
+                return self.launch_auto_save_offset(handle);
             }
         }
 
         Task::none()
     }
 
-    fn view(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn view(&self) -> Element<'_, DictionaryMessage> {
         back_overlay(
             row![
-                iced::widget::column![
+                column![
                     self.groups_panel(),
-                    row![horizontal().width(8), self.words_list(),],
+                    column![
-                    self.selection_editor(),
+                        row![horizontal().width(8), self.words_list(),],
+                        self.selection_editor(),
+                    ],
                     row![
                         self.add_word_button(),
                         horizontal().width(Fill),
-                        button("Импорт").style(text).on_press(GotoImport),
+                        button("Импорт").style(button::text).on_press(GotoImport),
                     ]
                 ]
-                .spacing(5).width(FillPortion(4)),
+                .spacing(5)
+                .width(FillPortion(4)),
                 self.right_panel(),
             ]
             .spacing(DEFAULT_SPACING)
@@ -408,7 +418,7 @@ impl DictionaryState {
             tag_map: HashMap::new(),
             words_tags: vec![],
             reverse: false,
-            search: "".to_string(),
+            search: String::new(),
             no_typing: true,
             reverse_list: true,
             auto_save_queue: HashMap::new(),
@@ -425,7 +435,9 @@ impl DictionaryState {
     }
 
     fn editor_for_word(&self, handle: EntityHandle<WordData>) -> WordEditor<DictionaryMessage> {
-        WordEditor::new(handle, self.state.clone()).on_delete(DeleteWord(handle)).on_edit(ExtendedWordEdited)
+        WordEditor::new(handle, self.state.clone())
+            .on_delete(DeleteWord(handle))
+            .on_edit(ExtendedWordEdited)
     }
 
     fn init(&mut self) {
@@ -455,7 +467,7 @@ impl DictionaryState {
         )
     }
 
-    fn words_list(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn words_list(&self) -> Element<'_, DictionaryMessage> {
         let time = Instant::now();
         let mut col = Column::new().width(Fill);
 
@@ -488,9 +500,9 @@ impl DictionaryState {
 
             let word_line_data = WordLineState {
                 is_included: self.included.contains(word_handle),
-                key: word.key.clone().into(),
+                key: word.key.clone(),
-                value: word.value.clone().into(),
+                value: word.value.clone(),
-                tags: word.tags.clone().into(),
+                tags: word.tags.clone(),
                 handle: *word_handle,
                 selection,
                 number: i,
@@ -505,7 +517,7 @@ impl DictionaryState {
         scrollable(col).height(Fill).into()
     }
 
-    fn word_line<'a>(data: &WordLineState) -> Row<'a, DictionaryMessage> {
+    fn word_line<'a>(data: &WordLineState) -> Element<'a, DictionaryMessage> {
         let mut line = Row::new().width(Fill).align_y(Center);
         let handle = data.handle;
         line = line.push(
@@ -575,22 +587,44 @@ impl DictionaryState {
                 .style(button::primary)
                 .width(15)
         };
-        line.push(line_button()).push(space().width(10))
+
+        let assembled = line.push(line_button()).push(space().width(10));
+
+        if let Some(selection) = data.selection
+            && selection == TotalLine
+        {
+            return container(assembled.padding(Padding {
+                top: 2.0,
+                right: 0.0,
+                bottom: 2.0,
+                left: 0.0,
+            }))
+            .style(|theme: &Theme| {
+                let mut style = container::Style::default();
+                style.border.color = theme.extended_palette().secondary.base.color;
+                style.border.width = 3.0_f32;
+                style
+            })
+            .into();
+        }
+        assembled.into()
     }
 
-    fn right_panel(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn right_panel(&self) -> Element<'_, DictionaryMessage> {
         if let Some(editor) = &self.word_editor {
-            container(editor.view().map(EditorAction)).width(FillPortion(3)).into()
+            container(editor.view().map(EditorAction))
+                .width(FillPortion(3))
+                .into()
         } else {
             self.filters()
         }
     }
 
-    fn filters(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn filters(&self) -> Element<'_, DictionaryMessage> {
         let dict = &self.state.dictionary.read();
 
-        iced::widget::column![
+        column![
-            text_input("Поиск", &self.search)
+            jl_text_input!("Поиск", &self.search)
                 .on_input(Search)
                 .width(Fill),
             text!("Всего слов: {}", dict.len()),
@@ -612,7 +646,7 @@ impl DictionaryState {
         .into()
     }
 
-    fn tags_selector(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn tags_selector(&self) -> Element<'_, DictionaryMessage> {
         let mut col = Column::new().width(Fill);
         col = col.push(
             button("Сбросить")
@@ -707,9 +741,12 @@ impl DictionaryState {
         info!("Time {}", time.elapsed().as_micros());
     }
 
-    fn selection_editor(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn selection_editor(&self) -> Element<'_, DictionaryMessage> {
-        let mut display = "".to_string();
+        let mut display = String::new();
-        if let Some(selected) = self.selected_cell.as_ref() {
+        let mut editable = false;
+        if let Some(selected) = self.selected_cell.as_ref()
+            && selected.1 != TotalLine
+        {
             let mut dictionary = self.state.dictionary.write();
             let word = dictionary.get_mut_static(selected.0).unwrap();
 
@@ -723,18 +760,28 @@ impl DictionaryState {
                 Tags => {
                     display = word.tags.clone();
                 }
+                _ => {}
             }
+            editable = true;
         }
-        text_input("", display.as_str())
+        let mut field = jl_text_input!("", display.as_str())
             .width(Fill)
             .id(iced::widget::Id::new("editor"))
-            .on_input(EditField)
+            .style(|theme, status| {
-            .into()
+                let mut default = default(theme, status);
+                default.border.radius = Radius::new(0);
+                default
+            });
+        if editable {
+            field = field.on_input(EditField)
+        }
+
+        field.into()
     }
 
-    fn groups_panel(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn groups_panel(&self) -> Element<'_, DictionaryMessage> {
         let mut row = Row::new();
-        row = row.push(button("+").style(text).on_press(CreateGroup));
+        row = row.push(button("+").style(button::text).on_press(CreateGroup));
 
         let groups = &self.state.word_groups.read();
 
@@ -742,7 +789,7 @@ impl DictionaryState {
             let group_name = groups.get(&mut group).unwrap().name.clone();
             row = row.push(
                 button(text!("{}", group_name))
-                    .style(text)
+                    .style(button::text)
                     .on_press(SelectGroup(group)),
             );
         }
@@ -750,11 +797,11 @@ impl DictionaryState {
         let groups = self.state.word_groups.read();
         let group = groups.get_static(self.selected_group).unwrap();
 
-        iced::widget::column![
+        column![
             scrollable(row).width(Fill).horizontal(),
             row![
                 jl_button!("⇳").on_press(ChangeDirection),
-                text_input("Название группы слов", &group.name)
+                jl_text_input!("Название группы слов", &group.name)
                     .on_input(EditGroup)
                     .width(250)
                     .on_submit(SaveGroup),
@@ -766,7 +813,7 @@ impl DictionaryState {
         .into()
     }
 
-    fn group_delete_button(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn group_delete_button(&self) -> Element<'_, DictionaryMessage> {
         if self.selected_group.real() && self.selected_group.id != 1.into() {
             button("Удалить").style(danger).on_press(DeleteGroup).into()
         } else {
@@ -774,7 +821,7 @@ impl DictionaryState {
         }
     }
 
-    fn add_word_button(&self) -> iced::Element<'_, DictionaryMessage> {
+    fn add_word_button(&self) -> Element<'_, DictionaryMessage> {
         let button = jl_button!("Добавить слово");
 
         if self.selected_group.real() {
@@ -806,18 +853,25 @@ impl KeyPressedPage for DictionaryState {
                     Task::done(RootMessage::Dictionary(ChangeSelectedField(Previous)))
                 }
                 keyboard::key::Code::Tab => {
-                    return if *mods == Modifiers::CTRL && let Some(selected) = self.selected_cell {
+                    return if *mods == Modifiers::CTRL
+                        && let Some(selected) = self.selected_cell
+                    {
                         Task::done(RootMessage::Dictionary(ExtendedEdit(selected.0)))
                     } else if let Named(keyboard::key::Named::Alt) = modifier {
                         Task::done(RootMessage::Dictionary(ChangeSelectedField(Backward)))
                     } else {
                         Task::done(RootMessage::Dictionary(ChangeSelectedField(Forward)))
-                    }
+                    };
                 }
                 keyboard::key::Code::Escape => {
                     if self.word_editor.is_some() {
                         self.word_editor = None;
-                    }else if self.selected_cell.is_some() {
+                        if let Some(selected) = self.selected_cell
+                            && selected.1 == TotalLine
+                        {
+                            self.selected_cell = None;
+                        }
+                    } else if self.selected_cell.is_some() {
                         self.selected_cell = None;
                     }
 

src/pages/dictionary_quiz.rs

@@ -1,7 +1,6 @@
 use crate::app::AppState;
 use crate::data::entities::{EntityHandle, WordData};
 use crate::data::repositories::Repository;
-use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::RootMessage;
 use crate::navigation::*;
@@ -9,11 +8,12 @@ use crate::pages::dictionary::split_with_coma;
 use crate::pages::dictionary_quiz::DictionaryQuizMessage::*;
 use crate::pages::quiz::Score;
 use crate::styling::*;
-use iced::Background::Color;
+use crate::{jl_button, jl_text_input};
 use iced::border::Radius;
 use iced::widget::container::Style;
-use iced::widget::{Row, container, row, space, text, text_input};
+use iced::widget::{container, row, space, text, Row};
-use iced::{Border, Element, Fill, Task, Theme, alignment};
+use iced::Background::Color;
+use iced::{alignment, Border, Element, Fill, Task, Theme};
 use rand::prelude::SliceRandom;
 
 pub struct DictionaryQuizState {
@@ -76,7 +76,7 @@ impl NavigatedPage<DictionaryQuizMessage> for DictionaryQuizState {
                 ]
                 .align_x(alignment::Horizontal::Center)
                 .spacing(5),
-                text_input("Перевод", &self.answer)
+                jl_text_input!("Перевод", &self.answer)
                     .size(28)
                     .width(250)
                     .on_input(AnswerChanged)
@@ -114,9 +114,9 @@ impl DictionaryQuizState {
             state,
             words,
             current_set: Vec::new(),
-            answer: "".to_string(),
+            answer: String::new(),
             view: "---".to_string(),
-            correct: "".to_string(),
+            correct: String::new(),
             score: Default::default(),
             is_help: false,
             reverse,

src/pages/exam.rs

@@ -0,0 +1,253 @@
+use crate::app::AppState;
+use crate::data::entities::{CustomField, DeckSettings, EntityHandle, ExamEntry, WordData};
+use crate::data::repositories::Repository;
+use crate::data::Id;
+use crate::navigation::Page::PreviousPage;
+use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
+use crate::pages::exam::ExamMessage::*;
+use crate::pages::repetition::play_sound;
+use crate::styling::*;
+use crate::{push_error, push_error_task};
+use iced::widget::space::horizontal;
+use iced::widget::{button, column, container, progress_bar, row, text, tooltip};
+use iced::{Element, Task};
+use iced_core::keyboard::key::Physical::Code;
+use iced_core::keyboard::Event;
+use iced_core::widget::text::Style;
+use iced_core::Alignment::Center;
+use iced_core::Length::Fill;
+use iced_core::{keyboard, Theme};
+use rand::prelude::SliceRandom;
+use rand::rng;
+use rodio::MixerDeviceSink;
+use std::sync::Arc;
+
+pub struct ExamState {
+    id: Id,
+    state: AppState,
+    entries: Vec<ExamEntry>,
+    total_count: u32,
+    open: bool,
+    custom_fields_cache: Vec<CustomField>,
+    current_word: WordData,
+    current_exam_entry_handle: EntityHandle<ExamEntry>,
+    deck: DeckSettings,
+    can_play: bool,
+    sink: Arc<Option<MixerDeviceSink>>,
+}
+
+#[derive(Clone)]
+pub enum ExamMessage {
+    Back,
+    Open,
+    Answer(bool),
+    Play,
+    PlayFinished,
+}
+
+impl NavigatedPage<ExamMessage> for ExamState {
+    fn navigate(&mut self, message: &ExamMessage) -> Option<Page> {
+        if let Back = message {
+            return Some(PreviousPage);
+        }
+        None
+    }
+
+    fn navigated(&mut self) {}
+
+    fn update(&mut self, message: ExamMessage) -> Task<RootMessage> {
+        match message {
+            Back => {}
+            Open => {
+                if self.open {
+                    return Task::none();
+                }
+
+                self.open = true;
+            }
+            Answer(answer) => {
+                if !self.open {
+                    return Task::none();
+                }
+                let id = self.current_exam_entry_handle.id;
+                let mut repo = self.state.exam_entries.write();
+                repo.set(
+                    &mut self.current_exam_entry_handle,
+                    ExamEntry {
+                        id,
+                        exam_id: self.id,
+                        word_id: self.current_word.id,
+                        status: Some(answer),
+                    },
+                );
+                if let Err(err) = repo.save(&mut self.current_exam_entry_handle) {
+                    return push_error_task!(err);
+                }
+                drop(repo);
+                self.open = false;
+                return self.next();
+            }
+            Play => {
+                if !self.can_play {
+                    return Task::none();
+                }
+
+                self.can_play = false;
+                let value = self.current_word.key.clone();
+                if self.deck.require_speech() {
+                    return Task::perform(play_sound(self.sink.clone(), value), |r| match r {
+                        Ok(_) => RootMessage::Exam(PlayFinished),
+                        Err(err) => push_error!(err),
+                    });
+                }
+            }
+            PlayFinished => {
+                self.can_play = true;
+            }
+        }
+
+        Task::none()
+    }
+
+    fn view(&self) -> Element<'_, ExamMessage> {
+        back_overlay(
+            column![
+                column![
+                    progress_bar(
+                        0.0..=(self.total_count as f32),
+                        (self.total_count - self.entries.len() as u32) as f32
+                    ),
+                    row![
+                        text!("Решено: {}", self.total_count - self.entries.len() as u32),
+                        horizontal().width(Fill),
+                        text!("Осталось: {}", self.entries.len())
+                    ],
+                ],
+                crate::widgets::card_display::word_display(
+                    &self.deck,
+                    &self.current_word,
+                    self.open,
+                    Play,
+                    self.custom_fields_cache.as_slice()
+                ),
+                container(self.answer_bar())
+                    .width(Fill)
+                    .align_x(Center)
+                    .height(80),
+            ]
+            .into(),
+            Back,
+        )
+    }
+}
+
+impl ExamState {
+    fn answer_bar(&self) -> Element<'_, ExamMessage> {
+        if !self.open {
+            return text!("Нажмите Пробел для открытия карточки")
+                .style(|theme: &Theme| Style {
+                    color: Some(theme.palette().text.scale_alpha(0.3)),
+                })
+                .into();
+        }
+
+        row![
+            tooltip(
+                button("Не знаю").on_press(Answer(false)),
+                "Клавиша 1",
+                tooltip::Position::Top
+            ),
+            tooltip(
+                button("Знаю").on_press(Answer(true)),
+                "Клавиша 2",
+                tooltip::Position::Top
+            ),
+        ]
+        .spacing(QUARTER_SPACING)
+        .into()
+    }
+}
+
+impl ExamState {
+    pub fn new(exam_id: Id, deck: DeckSettings, state: &AppState) -> Self {
+        let custom_fields_cache = state.custom_fields.read().iter().cloned().collect();
+        let sink_handle = if deck.require_speech() {
+            rodio::DeviceSinkBuilder::open_default_sink().ok()
+        } else {
+            None
+        };
+
+        let mut entries: Vec<_> = state
+            .exam_entries
+            .read()
+            .iter()
+            .filter(|e| e.exam_id == exam_id)
+            .cloned()
+            .collect();
+        let total_count = entries.len() as u32;
+        entries.retain(|e| e.status.is_none());
+        entries.shuffle(&mut rng());
+        let word = state
+            .dictionary
+            .read()
+            .get_static(EntityHandle::from_id(entries.last().unwrap().word_id))
+            .unwrap();
+        Self {
+            id: exam_id,
+            state: state.clone(),
+            current_word: word,
+            current_exam_entry_handle: EntityHandle::from_id(entries.last().unwrap().id),
+            entries,
+            total_count,
+            open: false,
+            custom_fields_cache,
+            deck,
+            can_play: true,
+            sink: Arc::new(sink_handle),
+        }
+    }
+
+    fn next(&mut self) -> Task<RootMessage> {
+        self.entries.pop().unwrap();
+        if self.entries.is_empty() {
+            return Task::done(RootMessage::Exam(Back));
+        }
+
+        let entry = self.entries.last().unwrap();
+        let handle: EntityHandle<ExamEntry> = EntityHandle::from_id(entry.id);
+        let word = self
+            .state
+            .dictionary
+            .read()
+            .get_static(EntityHandle::from_id(entry.word_id))
+            .unwrap();
+        self.current_word = word;
+        self.current_exam_entry_handle = handle;
+        Task::none()
+    }
+}
+
+impl KeyPressedPage for ExamState {
+    fn press(&mut self, message: &Event) -> Task<RootMessage> {
+        if let Event::KeyPressed {
+            key: _,
+            modified_key: _,
+            physical_key: pk,
+            location: _,
+            modifiers: _,
+            text: _,
+            repeat: _,
+        } = message
+            && let Code(code) = pk
+        {
+            return match code {
+                keyboard::key::Code::Space => Task::done(RootMessage::Exam(Open)),
+                keyboard::key::Code::Digit1 => Task::done(RootMessage::Exam(Answer(false))),
+                keyboard::key::Code::Digit2 => Task::done(RootMessage::Exam(Answer(true))),
+                _ => Task::none(),
+            };
+        }
+
+        Task::none()
+    }
+}

src/pages/exams.rs

@@ -0,0 +1,440 @@
+use crate::app::AppState;
+use crate::data::entities::{DeckSettings, EntityHandle, Exam, ExamEntry, WordData};
+use crate::data::repositories::{BatchedRepository, Repository};
+use crate::data::Id;
+use crate::navigation::Page::PreviousPage;
+use crate::navigation::{NavigatedPage, Page, RootMessage};
+use crate::notification::MaybeError;
+use crate::pages::exam::ExamState;
+use crate::pages::exams::ExamsMessage::*;
+use crate::pages::repetitions::Style;
+use crate::push_error;
+use crate::styling::{
+    back_overlay, cta_button, BUTTON_RADIUS, DEFAULT_SPACING, HALF_SPACING, QUARTER_SPACING,
+};
+use crate::{jl_button, push_error_task};
+use chrono::{Local, Utc};
+use iced::widget::button::Status;
+use iced::widget::container::bordered_box;
+use iced::widget::space::horizontal;
+use iced::widget::{
+    button, center_x, column, container, row, rule, scrollable, space, text, tooltip,
+    Column,
+};
+use iced::{Element, Task};
+use iced_core::Alignment::*;
+use iced_core::Length::{Fill, FillPortion};
+use iced_core::{Background, Border, Color, Shadow, Theme};
+use std::collections::BTreeMap;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+pub struct ExamsState {
+    state: AppState,
+    deck_id: EntityHandle<DeckSettings>,
+    deck: DeckSettings,
+    selected_exam_id: Option<EntityHandle<Exam>>,
+    exams: BTreeMap<EntityHandle<Exam>, ExamExtended>,
+}
+
+#[derive(Clone, Eq, PartialEq)]
+pub enum ExamsMessage {
+    Back,
+    SelectExam(EntityHandle<Exam>),
+    CreateExam,
+    GotoExam,
+}
+
+impl NavigatedPage<ExamsMessage> for ExamsState {
+    fn navigate(&mut self, message: &ExamsMessage) -> Option<Page> {
+        if let Back = message {
+            return Some(PreviousPage);
+        }
+        if let Some(selected_exam_id) = self.selected_exam_id
+            && GotoExam == *message
+        {
+            return Some(Page::Exam(ExamState::new(
+                selected_exam_id.id,
+                self.deck.clone(),
+                &self.state,
+            )));
+        }
+        None
+    }
+
+    fn navigated(&mut self) {
+        self.exams = Self::get_exams_list(&self.state, self.deck_id.id);
+    }
+
+    fn update(&mut self, message: ExamsMessage) -> Task<RootMessage> {
+        match message {
+            Back => {}
+            GotoExam => {}
+            SelectExam(id) => {
+                self.selected_exam_id = Some(id);
+            }
+            CreateExam => {
+                let exam = Exam {
+                    id: Default::default(),
+                    timestamp: Utc::now(),
+                    deck_id: self.deck_id.id,
+                };
+                let mut exam_repo = self.state.exam.write();
+                let handle = exam_repo.create_now(exam);
+                if let Ok(handle) = handle {
+                    drop(exam_repo);
+                    if let Err(err) = self.append_exam_entries(handle) {
+                        return push_error_task!(err);
+                    }
+                    self.exams = Self::get_exams_list(&self.state, self.deck_id.id);
+                    self.selected_exam_id = Some(handle);
+                } else {
+                    return push_error_task!(handle.err().unwrap());
+                }
+            }
+        }
+
+        Task::none()
+    }
+
+    fn view(&self) -> Element<'_, ExamsMessage> {
+        back_overlay(
+            column![
+                text(format!("Экзамены для колоды {}", self.deck.name)),
+                row![
+                    column![
+                        scrollable(self.exams_list()).height(Fill),
+                        jl_button!("Добавить").width(Fill).on_press(CreateExam),
+                    ]
+                    .spacing(DEFAULT_SPACING)
+                    .width(FillPortion(1)),
+                    self.selected_exam_view(),
+                ].spacing(DEFAULT_SPACING)
+            ]
+            .into(),
+            Back,
+        )
+    }
+}
+
+impl ExamsState {
+    pub fn new(deck_id: EntityHandle<DeckSettings>, state: AppState) -> Self {
+        let deck = state.decks.read().get_static(deck_id).unwrap();
+
+        Self {
+            exams: Self::get_exams_list(&state, deck_id.id),
+            state,
+            deck_id,
+            deck,
+            selected_exam_id: None,
+        }
+    }
+
+    fn selected_exam(&self) -> Option<&ExamExtended> {
+        self.exams.get(&self.selected_exam_id?)
+    }
+
+    fn append_exam_entries(&mut self, handle: EntityHandle<Exam>) -> MaybeError {
+        let deck_id = self.deck_id.id;
+        let words: Vec<_> = self
+            .state
+            .card_states
+            .read()
+            .iter()
+            .filter(|state| state.deck_id == deck_id)
+            .map(|state| state.word_id)
+            .collect();
+        let mut entries = words
+            .iter()
+            .map(|word_id| ExamEntry {
+                id: Default::default(),
+                exam_id: handle.id,
+                word_id: *word_id,
+                status: None,
+            })
+            .collect::<Vec<_>>();
+
+        self.state
+            .exam_entries
+            .write()
+            .create_now_many(entries.as_mut_slice())?;
+
+        Ok(())
+    }
+
+    fn get_exams_list(state: &AppState, deck_id: Id) -> BTreeMap<EntityHandle<Exam>, ExamExtended> {
+        let mut query = state
+            .exam
+            .read()
+            .query(Arc::new(move |exam| exam.deck_id == deck_id));
+        let handles: Vec<_> = query.handles().collect();
+        query
+            .iter(&state.exam.read())
+            .cloned()
+            .zip(handles)
+            .map(|(e, h)| (h, ExamExtended::from(e, state)))
+            .collect()
+    }
+}
+
+impl ExamsState {
+    pub fn exams_list(&self) -> Column<'_, ExamsMessage> {
+        let mut column = Column::new();
+
+        for (handle, deck) in self.exams.iter() {
+            column = column.push(
+                jl_button!(text!(
+                    "{}",
+                    &deck
+                        .timestamp
+                        .with_timezone(&Local)
+                        .format("%d/%m/%Y %H:%M")
+                ))
+                .on_press_with(move || SelectExam(*handle))
+                .style(move |_x: &Theme, status: Status| Style {
+                    background: if status == Status::Hovered {
+                        Some(Background::Color(Color::WHITE.scale_alpha(0.2)))
+                    } else {
+                        None
+                    },
+                    text_color: if deck.finished() {
+                        _x.palette().success
+                    } else {
+                        _x.palette().primary
+                    },
+                    border: Border {
+                        color: Default::default(),
+                        width: 0.0,
+                        radius: BUTTON_RADIUS.into(),
+                    },
+                    shadow: Shadow::default(),
+                    snap: false,
+                }),
+            );
+        }
+
+        column
+    }
+    pub fn selected_exam_view(&self) -> Element<'_, ExamsMessage> {
+        if let Some(exam) = self.selected_exam() {
+            return column![
+                center_x(text!(
+                    "Экзамен от {}",
+                    exam.timestamp
+                        .with_timezone(&Local)
+                        .format("%d/%m/%Y %H:%M")
+                )),
+                row![text!("{} карточек", exam.total), Self::exam_bar(exam)]
+                    .height(30)
+                    .align_y(Center)
+                    .width(Fill)
+                    .spacing(HALF_SPACING),
+                rule::horizontal(2),
+                self.exam_variable_view(exam),
+            ]
+            .spacing(DEFAULT_SPACING)
+            .width(FillPortion(2))
+            .into();
+        }
+
+        space().width(FillPortion(3)).into()
+    }
+
+    fn exam_bar(exam: &ExamExtended) -> Element<'_, ExamsMessage> {
+        let total = 1000.0;
+        let answered = (exam.answered as f64 / exam.total as f64 * total).round();
+        let unknown = (exam.unknown as f64 / exam.total as f64 * total).round();
+        let remaining = (exam.remaining() as f64 / exam.total as f64 * total).round();
+        let mut row = row![];
+        if answered > 0.0 {
+            row = row.push(tooltip(
+                container(space())
+                    .height(Fill)
+                    .width(FillPortion(answered as u16))
+                    .style(|theme: &Theme| container::Style {
+                        background: Some(Background::Color(theme.palette().success)),
+                        text_color: Default::default(),
+                        border: Default::default(),
+                        shadow: Default::default(),
+                        snap: false,
+                    }),
+                text!("Правильно: {}% ({})", answered / 10.0, exam.answered),
+                tooltip::Position::Bottom,
+            ));
+        }
+        if unknown > 0.0 {
+            row = row.push(tooltip(
+                container(space())
+                    .height(Fill)
+                    .width(FillPortion(unknown as u16))
+                    .style(|theme: &Theme| container::Style {
+                        background: Some(Background::Color(theme.palette().danger)),
+                        text_color: Default::default(),
+                        border: Default::default(),
+                        shadow: Default::default(),
+                        snap: false,
+                    }),
+                text!("Не получилось: {}% ({})", unknown / 10.0, exam.unknown),
+                tooltip::Position::Bottom,
+            ));
+        }
+        if remaining > 0.0 {
+            row = row.push(tooltip(
+                container(space())
+                    .height(Fill)
+                    .width(FillPortion(remaining as u16))
+                    .style(|theme: &Theme| container::Style {
+                        background: Some(Background::Color(theme.palette().primary)),
+                        text_color: Default::default(),
+                        border: Default::default(),
+                        shadow: Default::default(),
+                        snap: false,
+                    }),
+                text!("Осталось {}% ({})", remaining / 10.0, exam.remaining()),
+                tooltip::Position::Bottom,
+            ));
+        }
+
+        row.width(Fill).height(Fill).into()
+    }
+
+    fn exam_variable_view(&self, exam: &ExamExtended) -> Element<'_, ExamsMessage> {
+        if exam.finished() {
+            self.exam_finished_view(exam)
+        } else {
+            self.exam_ongoing_view(exam)
+        }
+    }
+
+    fn exam_finished_view(&self, exam: &ExamExtended) -> Element<'_, ExamsMessage> {
+        let result = (exam.answered as f64 / exam.total as f64 * 1000.0).round() / 10.0;
+        let words_repo = self.state.dictionary.read();
+        column![
+            center_x(text!("Итоговый результат: {}%", result).size(28)),
+            row![
+                Self::words_list(
+                    "Правильно",
+                    exam.answered_list
+                        .iter()
+                        .map(|handle| words_repo.get_ref_static(*handle).unwrap())
+                        .collect::<Vec<_>>()
+                        .as_slice()
+                )
+                .width(Fill),
+                Self::words_list(
+                    "Не получилось",
+                    exam.unknows_list
+                        .iter()
+                        .map(|handle| words_repo.get_ref_static(*handle).unwrap())
+                        .collect::<Vec<_>>()
+                        .as_slice()
+                )
+                .width(Fill)
+            ]
+            .width(Fill)
+            .spacing(QUARTER_SPACING)
+        ]
+        .spacing(DEFAULT_SPACING)
+        .into()
+    }
+
+    fn exam_ongoing_view(&self, _: &ExamExtended) -> Element<'_, ExamsMessage> {
+        center_x(
+            button("Продолжить экзамен")
+                .style(cta_button)
+                .on_press(GotoExam),
+        )
+        .into()
+    }
+
+    fn words_list<'a>(name: &str, words: &[&WordData]) -> Column<'a, ExamsMessage> {
+        let mut column = column![];
+        for word in words {
+            let container = container(
+                column![text!("{}", word.key), text!("{}", word.value)].padding(QUARTER_SPACING),
+            )
+            .width(Fill)
+            .style(bordered_box);
+            column = column.push(container);
+        }
+        column![
+            text!("{}", name),
+            scrollable(row![
+                column.spacing(QUARTER_SPACING),
+                horizontal().width(DEFAULT_SPACING)
+            ])
+        ]
+        .align_x(Center)
+    }
+}
+
+struct ExamExtended {
+    exam: Exam,
+    total: u32,
+    answered: u32,
+    unknown: u32,
+    answered_list: Vec<EntityHandle<WordData>>,
+    unknows_list: Vec<EntityHandle<WordData>>,
+}
+
+impl ExamExtended {
+    fn from(exam: Exam, state: &AppState) -> Self {
+        let entries = state.exam_entries.read();
+        let mut total = 0;
+        let mut answered = 0;
+        let mut unknown = 0;
+        let mut answered_list = Vec::with_capacity(128);
+        let mut unknows_list = Vec::with_capacity(128);
+        entries
+            .iter()
+            .filter(|e| e.exam_id == exam.id)
+            .for_each(|e| {
+                total += 1;
+                match e.status {
+                    None => {}
+                    Some(s) => {
+                        if s {
+                            answered += 1;
+                            answered_list.push(EntityHandle::from_id(e.word_id));
+                        } else {
+                            unknown += 1;
+                            unknows_list.push(EntityHandle::from_id(e.word_id));
+                        }
+                    }
+                }
+            });
+
+        Self {
+            exam,
+            total,
+            answered,
+            unknown,
+            answered_list,
+            unknows_list,
+        }
+    }
+    fn solved(&self) -> u32 {
+        self.answered + self.unknown
+    }
+
+    fn finished(&self) -> bool {
+        self.solved() == self.total
+    }
+
+    fn remaining(&self) -> u32 {
+        self.total - self.solved()
+    }
+}
+
+impl Deref for ExamExtended {
+    type Target = Exam;
+    fn deref(&self) -> &Self::Target {
+        &self.exam
+    }
+}
+
+impl DerefMut for ExamExtended {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.exam
+    }
+}

src/pages/history.rs

@@ -49,7 +49,7 @@ impl HistoryState {
         let history_repo = &mut state.history.write();
         history_repo.init().expect("TODO: panic message");
         let mut history = history_repo.query(Arc::new(move |h| h.deck_id == id));
-        let words = history
+        let mut words: Vec<_> = history
             .iter(history_repo)
             .map(|item| {
                 let handle = dict.handle_by_id(item.word_id);
@@ -57,13 +57,14 @@ impl HistoryState {
                     id: Default::default(),
                     group_id: Default::default(),
                     key: "Удаленное слово".to_string(),
-                    value: "".to_string(),
+                    value: String::new(),
-                    tags: "".to_string(),
+                    tags: String::new(),
                     additional: Default::default(),
                 });
                 (word, item.clone())
             })
             .collect();
+        words.reverse();
         Self { list: words }
     }
 

src/pages/import.rs

@@ -9,13 +9,13 @@ use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::NotificationData::{CompressError, OpenFileError};
 use crate::notification::{MaybeError, NotificationData};
 use crate::pages::import::ImportMessage::*;
-use crate::push_error;
 use crate::styling::*;
 use crate::{jl_button, push_error_task};
+use crate::{jl_text_input, push_error};
 use iced::widget::button::danger;
 use iced::widget::container::success;
 use iced::widget::{
-    Row, button, checkbox, column, container, progress_bar, row, rule, text, text_input,
+    Row, button, checkbox, column, container, progress_bar, row, rule, text,
 };
 use iced::widget::{scrollable, space};
 use iced::{Element, Task};
@@ -269,7 +269,7 @@ impl ImportState {
             self.available_properties(),
             button("Добавить напрямую").on_press(SetupDirect),
             row![
-                text_input("Пользовательское поле", &self.custom_property_name)
+                jl_text_input!("Пользовательское поле", &self.custom_property_name)
                     .on_input(EditCustomProperty),
                 button("Установить привязку").on_press(SetupCustomProperty)
             ]
@@ -297,7 +297,7 @@ impl ImportState {
                 .on_toggle(SwitchSkipEmpty),
             column![
                 text!("Разделитель при множественном объединении"),
-                text_input("", &self.separator).on_input(EditSeparator)
+                jl_text_input!("", &self.separator).on_input(EditSeparator)
             ]
         ]
         .spacing(DEFAULT_SPACING)
@@ -329,7 +329,7 @@ impl ImportState {
             import_data: None,
             selected_index: 0,
             selected_property: None,
-            custom_property_name: "".to_string(),
+            custom_property_name: String::new(),
             skip_empty: true,
             separator: ", ".to_string(),
             progress: None,
@@ -582,7 +582,11 @@ impl ImportState {
             .iter()
             .map(|field| field.identifier.clone())
             .collect();
-        current_fields.append(&mut vec!["key".to_string(), "value".to_string(), "tags".to_string()]);
+        current_fields.append(&mut vec![
+            "key".to_string(),
+            "value".to_string(),
+            "tags".to_string(),
+        ]);
         for (field, _) in import_group {
             if current_fields.contains(field) {
                 continue;
@@ -600,5 +604,6 @@ impl ImportState {
 }
 
 pub enum AnkiSchema {
-    Old, Beta
+    Old,
+    Beta,
 }

src/pages/quiz.rs

@@ -1,10 +1,10 @@
 use crate::app::USER_FONT;
 use crate::core::kana_set::KanaSet;
-use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::pages::quiz::QuizMessage::*;
 use crate::styling::*;
+use crate::{jl_button, jl_text_input};
 use iced::widget::*;
 use iced::{Element, Fill, Task, alignment};
 use rand::seq::SliceRandom;
@@ -77,7 +77,7 @@ impl NavigatedPage<QuizMessage> for QuizState {
                 ]
                 .align_y(alignment::Vertical::Center)
                 .spacing(20),
-                text_input("Романдзи", &self.current_roman)
+                jl_text_input!("Романдзи", &self.current_roman)
                     .size(28)
                     .width(150)
                     .on_input(ContentChanged),
@@ -113,7 +113,7 @@ impl QuizState {
             kana: "ぁ".to_string(),
             correct_roman: "a".to_string(),
             is_help: false,
-            current_roman: "".to_string(),
+            current_roman: String::new(),
             set: KanaSet::hiragana(),
             queue: Vec::new(),
             score: Score {

src/pages/repetition.rs

@@ -1,22 +1,22 @@
 use crate::app::AppState;
 use crate::core::deck::DeckData;
 use crate::core::srs::WordOpenMode;
-use crate::data::Id;
+use crate::data::entities::{CardState, CustomField, WordData};
-use crate::data::entities::{CardState, WordData};
 use crate::data::repositories::Repository;
+use crate::data::Id;
 use crate::data_provider::voice::get_voice;
-use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
 use crate::notification::{MaybeError, NotificationData};
+use crate::pages::repetition::RepetitionMessage::Play;
 use crate::pages::repetitions::DeckRunData;
 use crate::styling::*;
 use crate::{push_error, push_error_task};
 use iced::alignment::Horizontal::Center;
 use iced::keyboard::key::Physical::Code;
 use iced::widget::text::Style;
-use iced::widget::{Column, button, column, container, row, rule, space, text, tooltip};
+use iced::widget::{button, column, container, row, text, tooltip};
-use iced::{Element, Fill, Task, Theme, alignment, keyboard};
+use iced::{keyboard, Element, Fill, Task, Theme};
 use rodio::MixerDeviceSink;
 use std::collections::HashSet;
 use std::sync::Arc;
@@ -32,6 +32,7 @@ pub struct RepetitionState {
     can_play: bool,
     sink: Arc<Option<MixerDeviceSink>>,
     opened: HashSet<Id>,
+    custom_fields_cache: Vec<CustomField>,
 }
 
 impl NavigatedPage<RepetitionMessage> for RepetitionState {
@@ -49,7 +50,7 @@ impl NavigatedPage<RepetitionMessage> for RepetitionState {
             RepetitionMessage::Back => {}
             RepetitionMessage::Next => return self.next(),
             RepetitionMessage::Answer(m) => return self.answer(m),
-            RepetitionMessage::Play => {
+            Play => {
                 if !self.can_play {
                     return Task::none();
                 }
@@ -73,17 +74,7 @@ impl NavigatedPage<RepetitionMessage> for RepetitionState {
     fn view(&self) -> Element<'_, RepetitionMessage> {
         back_overlay(
             column![
-                container(self.draw_forward())
+                crate::widgets::card_display::word_display(&self.settings.general_settings, &self.current_word, self.open, Play, self.custom_fields_cache.as_slice()),
-                    .width(Fill)
-                    .height(Fill)
-                    .align_x(Center)
-                    .align_y(alignment::Vertical::Center),
-                rule::horizontal(2),
-                container(self.draw_backward())
-                    .width(Fill)
-                    .height(Fill)
-                    .align_x(Center)
-                    .align_y(alignment::Vertical::Center),
                 container(self.answer_bar())
                     .width(Fill)
                     .align_x(Center)
@@ -92,7 +83,7 @@ impl NavigatedPage<RepetitionMessage> for RepetitionState {
                     "Затронуто слов {}, {}%",
                     self.opened.len(),
                     (self.opened.len() as f32 / self.set.len() as f32 * 10000.0).round() / 100.0
-                )
+                ),
             ]
             .height(Fill)
             .width(Fill)
@@ -117,6 +108,8 @@ impl RepetitionState {
             None
         };
 
+        let custom_fields_cache = state.custom_fields.read().iter().cloned().collect();
+
         Ok(RepetitionState {
             state,
             settings: set,
@@ -127,6 +120,7 @@ impl RepetitionState {
             can_play: true,
             sink: Arc::new(sink_handle),
             opened: HashSet::new(),
+            custom_fields_cache,
         })
     }
 }
@@ -169,43 +163,6 @@ impl RepetitionState {
         Task::none()
     }
 
-    fn draw_forward(&self) -> Element<'_, RepetitionMessage> {
-        self.draw_card_view(self.settings.forward.as_str())
-    }
-
-    fn draw_backward(&self) -> Element<'_, RepetitionMessage> {
-        if !self.open {
-            return container(text!("?").size(72))
-                .width(Fill)
-                .height(Fill)
-                .align_y(alignment::Vertical::Center)
-                .align_x(Center)
-                .into();
-        }
-
-        self.draw_card_view(self.settings.backward.as_str())
-    }
-
-    fn draw_card_view(&self, properties: &str) -> Element<'_, RepetitionMessage> {
-        let word = &self.current_word;
-
-        let mut col = Column::new();
-
-        for view_type in properties.split(" ") {
-            col = col.push(match view_type {
-                "key" => self.draw_key(word),
-                "value" => self.draw_value(word),
-                "speech" => self.draw_voice(),
-                "reading" => self.draw_reading(word),
-                "context" => self.draw_context(word),
-                "description" => self.draw_description(word),
-                _ => space().into(),
-            })
-        }
-
-        col.spacing(DEFAULT_SPACING).align_x(Center).into()
-    }
-
     fn answer_bar(&self) -> Element<'_, RepetitionMessage> {
         if !self.open {
             return text!("Нажмите Пробел для открытия карточки")
@@ -247,38 +204,6 @@ impl RepetitionState {
         .spacing(DEFAULT_SPACING)
         .into()
     }
-
-    fn draw_key(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        text!("{}", word.key).size(36).into()
-    }
-    fn draw_value(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        text!("{}", word.value).size(24).into()
-    }
-
-    fn draw_voice(&self) -> Element<'_, RepetitionMessage> {
-        jl_button!("Воспроизвести")
-            .on_press(RepetitionMessage::Play)
-            .into()
-    }
-
-    fn draw_reading(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        match word.additional.get(&Id(1)) {
-            None => space().into(),
-            Some(reading) => text!("{}", reading).size(24).into(),
-        }
-    }
-    fn draw_context(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        match word.additional.get(&Id(3)) {
-            None => space().into(),
-            Some(context) => text!("{}", context).size(24).into(),
-        }
-    }
-    fn draw_description(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        match word.additional.get(&Id(2)) {
-            None => space().into(),
-            Some(context) => text!("{}", context).size(24).into(),
-        }
-    }
 }
 
 impl KeyPressedPage for RepetitionState {
@@ -317,7 +242,7 @@ pub enum RepetitionMessage {
     PlayFinished,
 }
 
-async fn play_sound(sink: Arc<Option<MixerDeviceSink>>, text: String) -> MaybeError {
+pub async fn play_sound(sink: Arc<Option<MixerDeviceSink>>, text: String) -> MaybeError {
     let data = get_voice(text.as_str()).await?;
     spawn_blocking(move || {
         if let Some(sink) = sink.as_ref()

src/pages/repetition_settings.rs

@@ -2,20 +2,20 @@ use crate::app::AppState;
 use crate::core::deck::DeckData;
 use crate::data::entities::{DeckSettings, EntityHandle};
 use crate::data::repositories::{BatchedRepository, Repository};
-use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::MaybeError;
 use crate::pages::repetition_settings::RepetitionSettingsMessage::*;
 use crate::styling::*;
+use crate::{jl_button, jl_text_input};
 use crate::{push_error, push_error_task};
 use iced::widget::button::danger;
 use iced::widget::space::horizontal;
 use iced::widget::text_input::Catalog;
-use iced::widget::{button, column, row, scrollable, space, text, text_input};
+use iced::widget::{button, column, row, scrollable, space, text};
 use iced::{Element, Task};
 use iced_core::Length::Fill;
-use iced_core::{Padding, Theme, color};
+use iced_core::{color, Padding, Theme};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -143,22 +143,22 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                     column![
                         column![
                             text!("Название набора"),
-                            text_input("", &self.settings_data.name).on_input(SetName),
+                            jl_text_input!("", &self.settings_data.name).on_input(SetName),
                         ]
                         .spacing(QUARTER_SPACING),
                         column![
                             text!("Передняя сторона"),
-                            text_input("", &self.settings_data.forward).on_input(SetForward),
+                            jl_text_input!("", &self.settings_data.forward).on_input(SetForward),
                         ]
                         .spacing(QUARTER_SPACING),
                         column![
                             text!("Задняя сторона"),
-                            text_input("", &self.settings_data.backward).on_input(SetBackward),
+                            jl_text_input!("", &self.settings_data.backward).on_input(SetBackward),
                         ]
                         .spacing(QUARTER_SPACING),
                         column![
                             text!("Фильтр"),
-                            text_input("", &self.settings_data.filter)
+                            jl_text_input!("", &self.settings_data.filter)
                                 .style(|x, status| {
                                     let mut primary = Theme::default()(x, status);
                                     if !self.correct_filter {
@@ -220,7 +220,7 @@ fn update_deck_stats(deck: &DeckSettings, state: &AppState) -> MaybeError {
         .map(|w| w.id)
         .collect::<Vec<_>>();
     filtered_words.iter().for_each(|word_id| {
-        if let Some(index) = db_stats.iter().position(|stat_id| stat_id.id == *word_id) {
+        if let Some(index) = db_stats.iter().position(|stat_id| stat_id.word_id == *word_id) {
             db_stats.remove(index);
         }
     });

src/pages/repetitions.rs

@@ -3,10 +3,10 @@ use crate::core::deck::DeckData;
 use crate::core::srs::{AppendMode, OrderMode};
 use crate::data::entities::{CardState, DeckSettings, EntityHandle, WordData};
 use crate::data::repositories::{BatchedRepository, Repository};
-use crate::jl_button;
+use crate::navigation::Page::{Exams, History, PreviousPage, Repetition, RepetitionSettings};
-use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::MaybeError;
+use crate::pages::exams::ExamsState;
 use crate::pages::history::HistoryState;
 use crate::pages::repetition::RepetitionState;
 use crate::pages::repetition_settings::RepetitionSettingsState;
@@ -14,19 +14,19 @@ use crate::pages::repetitions::RepetitionsMessage::*;
 use crate::push_error;
 use crate::push_error_task;
 use crate::styling::*;
+use crate::{jl_button, jl_text_input};
 use chrono::{Days, Local, Utc};
 use hashbrown::HashSet;
+use iced::widget::button::{danger, Status};
 pub use iced::widget::button::{Catalog, Style};
-use iced::widget::button::{Status, danger};
 use iced::widget::tooltip::Position::Top;
 use iced::widget::{
-    Column, Row, button, column, container, lazy, radio, row, scrollable, space, svg, text,
+    button, column, container, lazy, radio, row, scrollable, space, svg, text, tooltip, Column, Row,
-    text_input, tooltip,
 };
 use iced::{Background, Border, Center, Color, Element, Fill, Length, Shadow, Task, Theme};
-use iced_core::Padding;
 use iced_core::border::Radius;
 use iced_core::svg::Handle;
+use iced_core::Padding;
 use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::sync::Arc;
@@ -74,9 +74,9 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 self.selected_deck_handle.unwrap(),
                 self.state.clone(),
             )))
-        } else {
+        } else if let GoToExams = message {
-            None
+            Some(Exams(ExamsState::new(self.selected_deck_handle.unwrap(), self.state.clone())))
-        }
+        } else { None }
     }
     fn navigated(&mut self) {
         if let Some(index) = self.selected_deck_handle {
@@ -96,6 +96,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
         } else {
             self.fill_deck_word_indices();
         }
+        _ = self.state.history.write().reload()
     }
     fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
         match message {
@@ -218,6 +219,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                     return push_error_task!(err);
                 }
             }
+            GoToExams => {}
         }
         Task::none()
     }
@@ -302,7 +304,7 @@ impl RepetitionsState {
                         column![
                             text!("Название набора"),
                             row![
-                                text_input("", &deck.name).on_input(SetName),
+                                jl_text_input!("", &deck.name).on_input(SetName),
                                 button(svg(Handle::from_memory(SETTINGS_ICON)))
                                     .width(43)
                                     .on_press(GoToSettings),
@@ -315,17 +317,17 @@ impl RepetitionsState {
                                 column![
                                     column![
                                         text!("Передняя сторона"),
-                                        text_input("", &deck.forward).on_input(SetForward),
+                                        jl_text_input!("", &deck.forward).on_input(SetForward),
                                     ]
                                     .spacing(QUARTER_SPACING),
                                     column![
                                         text!("Задняя сторона"),
-                                        text_input("", &deck.backward).on_input(SetBackward),
+                                        jl_text_input!("", &deck.backward).on_input(SetBackward),
                                     ]
                                     .spacing(QUARTER_SPACING),
                                     column![
                                         text!("Фильтр"),
-                                        text_input("", &deck.filter).on_input(SetFilter),
+                                        jl_text_input!("", &deck.filter).on_input(SetFilter),
                                         jl_button!("Проверить фильтр").on_press(TryFilter),
                                         self.count_view(deck),
                                     ]
@@ -354,7 +356,10 @@ impl RepetitionsState {
                                         Some(deck.open_mode),
                                         SetOpenMode
                                     ),
-                                    jl_button!("История").on_press(GoToHistory),
+                                    row![
+                                        jl_button!("История").on_press(GoToHistory),
+                                        jl_button!("Экзамены").on_press(GoToExams),
+                                    ].spacing(DEFAULT_SPACING),
                                 ]
                                 .spacing(HALF_SPACING)
                             }
@@ -629,6 +634,7 @@ pub enum RepetitionsMessage {
     SetOpenMode(OrderMode),
     SetAppendMode(AppendMode),
     GoToHistory,
+    GoToExams,
     GoToSettings,
     AppendWords(usize),
 }

src/pages/sync.rs

@@ -15,6 +15,7 @@ use iced::widget::{button, column, container, progress_bar, row, space, text, to
 use iced::{Center, Element, Fill, Font, Length, Task};
 use log::error;
 use std::time::Duration;
+use crate::notification::NotificationData::LocalVersionChanged;
 
 #[derive(Clone)]
 pub enum SyncMessage {
@@ -31,11 +32,13 @@ pub enum SyncMessage {
     Disable,
     DisableSync,
     SwitchAutoSync,
+    ResetRealLoad,
 }
 pub struct SyncState {
     state: AppState,
     auto_fetch: bool,
     frozen: bool,
+    real_load: bool,
     progress: f32,
 }
 
@@ -99,13 +102,29 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 return tasks;
             }
             GetLast => {
+                if !self.real_load {
+                    self.real_load = true;
+                    return Task::batch([
+                        Task::future(async {
+                            tokio::time::sleep(Duration::from_millis(3000)).await;
+                            RootMessage::Sync(ResetRealLoad)
+                        }),
+                        Task::done(RootMessage::PushNotification(NotificationRequest::Warning(LocalVersionChanged)))
+                    ]);
+                }
+
+                self.real_load = false;
                 let id = self.state.sync_data.read().key.clone().unwrap();
+                self.state.connection.lock().finish();
                 let tasks = Task::batch([
                     Task::perform(
                         async { tokio::time::sleep(Duration::from_millis(200)).await },
                         |_| RootMessage::Sync(NextAnimation),
                     ),
-                    Task::perform(load_data(id, false), |_| RootMessage::Sync(NetworkFinished)),
+                    Task::perform(load_data(id, false), |load_result| match load_result {
+                        Ok(_) => RootMessage::Sync(NetworkFinished),
+                        Err(error) => push_error!(error)
+                    }),
                 ]);
 
                 return tasks;
@@ -134,7 +153,7 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 }
 
                 return Task::done(RootMessage::PushNotification(NotificationRequest::Info(
-                    NotificationData::DataLoaded,
+                    NotificationData::DataSynced,
                 )));
             }
             Disable => {}
@@ -166,6 +185,9 @@ impl NavigatedPage<SyncMessage> for SyncState {
                     return push_error_task!(err);
                 }
             }
+            ResetRealLoad => {
+                self.real_load = false;
+            }
         }
         Task::none()
     }
@@ -189,6 +211,7 @@ impl SyncState {
             auto_fetch,
             state,
             frozen: false,
+            real_load: false,
             progress: 0.0,
         }
     }
@@ -199,6 +222,8 @@ impl SyncState {
         self.state.decks.write().reload()?;
         self.state.dictionary.write().reload()?;
         self.state.history.write().reload()?;
+        self.state.exam.write().reload()?;
+        self.state.exam_entries.write().reload()?;
         Ok(())
     }
 

src/pages/word.rs

@@ -2,29 +2,30 @@ use crate::app::AppState;
 use crate::data::Id;
 use crate::data::entities::{CustomField, EntityHandle, WordData};
 use crate::data::repositories::Repository;
+use crate::jl_text_input;
 use crate::pages::word::WordMessage::*;
 use crate::styling::*;
 use iced::widget::button::danger;
 use iced::widget::space::horizontal;
-use iced::widget::{button, column, row, rule, scrollable, text, text_input};
+use iced::widget::{button, column, row, rule, scrollable, text};
 use iced::{Element, Fill};
 use iced_core::Padding;
 
-pub struct WordEditor<Message> {
+pub struct WordEditor<Message : Clone> {
     state: AppState,
-    handle: EntityHandle<WordData>,
+    pub word_handle: EntityHandle<WordData>,
     on_delete: Option<Message>,
     on_edit: Option<Message>,
     fields: Vec<CustomField>,
 }
 
-impl<Message> WordEditor<Message> {
+impl<Message: std::clone::Clone> WordEditor<Message> {
     pub(crate) fn update(&mut self, message: WordMessage) -> Option<Message> {
         let dictionary = &mut self.state.dictionary.write();
-        let word = dictionary.get_mut(&mut self.handle).unwrap();
+        let word = dictionary.get_mut(&mut self.word_handle).unwrap();
         match message {
             Delete => {
-                return self.on_delete.take();
+                return self.on_delete.clone();
             }
             SetTags(n) => word.tags = n,
             SetKey(n) => {
@@ -34,16 +35,16 @@ impl<Message> WordEditor<Message> {
                 word.value = n;
             }
             SetAdditional(key, value) => {
-                word.additional.insert(key, value.clone());
+                word.additional.insert(key, value.replace("", ""));
             }
             AddAdditional(key) => {
-                word.additional.insert(key, "".to_string());
+                word.additional.insert(key, String::new());
             }
             RemoveAdditional(key) => {
                 word.additional.remove(&key);
             }
         }
-        self.on_edit.take()
+        self.on_edit.clone()
     }
 
     pub(crate) fn view(&self) -> Element<'_, WordMessage> {
@@ -52,7 +53,7 @@ impl<Message> WordEditor<Message> {
             .state
             .dictionary
             .read()
-            .get_static(self.handle)
+            .get_static(self.word_handle)
             .unwrap();
         for field in &self.fields {
             if !word.additional.contains_key(&field.id) {
@@ -65,23 +66,29 @@ impl<Message> WordEditor<Message> {
         }
 
         let mut col = iced::widget::column![
-            column![text!("Ключ"), text_input("key", &word.key).on_input(SetKey),]
+            column![
-                .spacing(QUARTER_SPACING),
+                text!("Ключ"),
+                jl_text_input!("key", &word.key).on_input(SetKey),
+            ]
+            .spacing(QUARTER_SPACING),
             column![
                 text!("Значение"),
-                text_input("value", &word.value).on_input(SetValue),
+                jl_text_input!("value", &word.value).on_input(SetValue),
             ]
             .spacing(QUARTER_SPACING),
             column![
                 text!("Теги"),
-                text_input("tags", &word.tags).on_input(SetTags),
+                jl_text_input!("tags", &word.tags).on_input(SetTags),
             ]
             .spacing(QUARTER_SPACING),
             rule::horizontal(2),
-            scrollable(fast_add.padding(Padding{
+            scrollable(fast_add.padding(Padding {
-
+                top: 0.0,
-
+                right: 0.0,
-            top: 0.0 , right: 0.0 , bottom: 4.0 , left: 0.0 , })).horizontal(),
+                bottom: 4.0,
+                left: 0.0,
+            }))
+            .horizontal(),
         ];
 
         for more in &word.additional {
@@ -101,7 +108,7 @@ impl<Message> WordEditor<Message> {
     }
 }
 
-impl<Message> WordEditor<Message> {
+impl<Message: std::clone::Clone> WordEditor<Message> {
     pub fn new(handle: EntityHandle<WordData>, state: AppState) -> Self {
         let fields = state
             .custom_fields
@@ -111,7 +118,7 @@ impl<Message> WordEditor<Message> {
             .collect::<Vec<_>>();
         Self {
             state,
-            handle,
+            word_handle: handle,
             on_delete: None,
             on_edit: None,
             fields,
@@ -128,24 +135,20 @@ impl<Message> WordEditor<Message> {
     }
 }
 
-impl<Message> WordEditor<Message> {
+impl<Message: std::clone::Clone> WordEditor<Message> {
     fn get_view_for_more(&self, value: (&Id, &String)) -> Element<'_, WordMessage> {
         let field = self.fields.iter().find(|f| f.id == *value.0).unwrap();
-        match value.0 {
+        self.additional_field(value.1, field.name.as_str(), *value.0)
-            _ => self.additional_field(value.1, field.name.as_str(), value.0.clone()),
-        }
     }
 
     fn additional_field(&self, value: &str, name: &str, id: Id) -> Element<'_, WordMessage> {
         column![
             text!("{}", name),
             row![
-                text_input(name, value)
+                jl_text_input!(name, value)
                     .on_input(move |string| SetAdditional(id, string))
                     .width(Fill),
-                button("-")
+                button("-").on_press(RemoveAdditional(id)).style(danger),
-                    .on_press(RemoveAdditional(id))
-                    .style(danger),
             ]
             .spacing(QUARTER_SPACING),
         ]

src/pages/writing.rs

@@ -65,11 +65,11 @@ impl WritingState {
         let mut list = set.list();
         list.shuffle(&mut rand::rng());
         WritingState {
-            kana: "".to_string(),
+            kana: String::new(),
             set: list.clone(),
             original_set: list,
-            kana_total: "".to_string(),
+            kana_total: String::new(),
-            roman_total: "".to_string(),
+            roman_total: String::new(),
             next_text: "Дальше".to_string(),
             show_all: false,
         }
@@ -79,9 +79,9 @@ impl WritingState {
 impl WritingState {
     fn next(&mut self) {
         if self.set.is_empty() {
-            self.kana = "".to_string();
+            self.kana = String::new();
-            self.roman_total = "".to_string();
+            self.roman_total = String::new();
-            self.kana_total = "".to_string();
+            self.kana_total = String::new();
 
             self.set = self.original_set.clone();
             self.set.shuffle(&mut rand::rng());

src/styling.rs

@@ -23,6 +23,15 @@ pub fn jl_button_style(theme: &Theme, status: Status) -> Style {
     };
     style
 }
+
+pub fn jl_text_input_style(
+    theme: &Theme,
+    status: iced::widget::text_input::Status,
+) -> iced::widget::text_input::Style {
+    let mut style = iced::widget::text_input::default(theme, status);
+    style.border.radius = Radius::new(BUTTON_RADIUS);
+    style
+}
 pub fn cta_button(theme: &Theme, status: Status) -> Style {
     let mut style = secondary(theme, status);
     style.border.width = 1.0;
@@ -37,6 +46,13 @@ macro_rules! jl_button {
     };
 }
 
+#[macro_export]
+macro_rules! jl_text_input {
+    ($placeholder:expr, $content:expr) => {
+        iced::widget::text_input($placeholder, $content).style($crate::styling::jl_text_input_style)
+    };
+}
+
 pub fn back_overlay<'a, T: Clone + 'a>(content: Element<'a, T>, back_message: T) -> Element<'a, T> {
     container(
         iced::widget::column![jl_button!("Назад").on_press(back_message), content]

src/widgets/card_display.rs

@@ -0,0 +1,107 @@
+use crate::data::entities::{CustomField, DeckSettings, WordData};
+use crate::data::Id;
+use crate::styling::HALF_SPACING;
+use iced::widget::{button, center, column, rule, text};
+use iced_core::Alignment::Center;
+use iced_core::Length::Fill;
+
+pub fn word_display<'a, T: 'a + Clone>(
+    deck: &DeckSettings,
+    word: &WordData,
+    open: bool,
+    speech_action: T,
+    fields_set: &[CustomField],
+) -> iced::Element<'a, T> {
+    column![
+        forward_side(deck, word, speech_action.clone(), fields_set),
+        rule::horizontal(2),
+        backward_side(deck, word, speech_action, fields_set, open)
+    ]
+    .into()
+}
+
+fn forward_side<'a, T: 'a + Clone>(
+    deck: &DeckSettings,
+    word: &WordData,
+    speech_action: T,
+    fields_set: &[CustomField],
+) -> iced::Element<'a, T> {
+    center(property_draw(
+        deck.forward.as_str(),
+        word,
+        speech_action,
+        fields_set,
+    ))
+    .into()
+}
+
+fn backward_side<'a, T: 'a + Clone>(
+    deck: &DeckSettings,
+    word: &WordData,
+    speech_action: T,
+    fields_set: &[CustomField],
+    open: bool,
+) -> iced::Element<'a, T> {
+    if open {
+        return center(property_draw(
+            deck.backward.as_str(),
+            word,
+            speech_action,
+            fields_set,
+        ))
+        .into();
+    }
+    center(text!("?").size(72)).width(Fill).height(Fill).into()
+}
+
+fn property_draw<'a, T: 'a + Clone>(
+    formula: &str,
+    word: &WordData,
+    speech_action: T,
+    fields_set: &[CustomField],
+) -> iced::Element<'a, T> {
+    let mut column = column![];
+    let parts = formula.split(" ");
+    println!("{:?}", formula);
+    for part in parts {
+        println!("displaying {}", part);
+        match part {
+            "key" => column = column.push(text!("{}", word.key).align_x(Center).size(48)),
+            "value" => column = column.push(text!("{}", word.value).align_x(Center).size(28)),
+            "tags" => column = column.push(text!("{}", word.tags).align_x(Center).size(28)),
+            "speech" => {
+                column = column.push(button("Воспроизвести").on_press(speech_action.clone()))
+            }
+            _ => {
+                if part == "reading"
+                    && let Some(reading) = word.additional.get(&Id(1))
+                {
+                    column = column.push(text!("{}", reading).align_x(Center).size(24));
+                    continue
+                }
+
+                if part == "description"
+                    && let Some(description) = word.additional.get(&Id(2))
+                {
+                    column = column.push(text!("{}", description).align_x(Center).size(20));
+                    continue
+                }
+
+                if part == "context"
+                    && let Some(context) = word.additional.get(&Id(3))
+                {
+                    column = column.push(text!("{}", context).align_x(Center).size(24));
+                    continue
+                }
+
+                let field_id = fields_set.iter().find(|f| f.identifier == part);
+                if let Some(id) = field_id
+                    && let Some(custom) = word.additional.get(&id.id)
+                {
+                    column = column.push(text!("{}", custom).align_x(Center).size(24))
+                }
+            }
+        }
+    }
+    column.align_x(Center).spacing(HALF_SPACING).into()
+}

src/widgets/hard_mouse_area.rs

@@ -1,8 +1,7 @@
-use iced::widget::MouseArea;
+use iced_core::widget::{tree, Operation, Tree};
-use iced_core::widget::{Operation, Tree, tree};
 use iced_core::{
-    Clipboard, Element, Event, Layout, Length, Point, Rectangle, Shell, Size, Vector, Widget,
+    layout, mouse, overlay, renderer, touch, Clipboard, Element, Event, Layout, Length, Point,
-    layout, mouse, overlay, renderer, touch,
+    Rectangle, Shell, Size, Vector, Widget,
 };
 
 pub fn hard_mouse_area<'a, Message, Theme, Renderer>(
@@ -161,6 +160,42 @@ where
     Renderer: renderer::Renderer,
     Message: Clone,
 {
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+
+    fn layout(
+        &mut self,
+        tree: &mut Tree,
+        renderer: &Renderer,
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut Renderer,
+        theme: &Theme,
+        renderer_style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            renderer_style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+
     fn tag(&self) -> tree::Tag {
         tree::Tag::of::<State>()
     }
@@ -177,21 +212,6 @@ where
         tree.diff_children(std::slice::from_ref(&self.content));
     }
 
-    fn size(&self) -> Size<Length> {
-        self.content.as_widget().size()
-    }
-
-    fn layout(
-        &mut self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        self.content
-            .as_widget_mut()
-            .layout(&mut tree.children[0], renderer, limits)
-    }
-
     fn operate(
         &mut self,
         tree: &mut Tree,
@@ -215,7 +235,9 @@ where
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
     ) {
-        if self.on_move.is_none() && let Event::Mouse(mouse::Event::CursorMoved {..}) = event {
+        if self.on_move.is_none()
+            && let Event::Mouse(mouse::Event::CursorMoved { .. }) = event
+        {
             self.content.as_widget_mut().update(
                 &mut tree.children[0],
                 event,
@@ -228,7 +250,9 @@ where
             );
         }
 
-        if self.on_enter.is_none() && let Event::Mouse(mouse::Event::CursorEntered {..}) = event {
+        if self.on_enter.is_none()
+            && let Event::Mouse(mouse::Event::CursorEntered) = event
+        {
             self.content.as_widget_mut().update(
                 &mut tree.children[0],
                 event,
@@ -240,7 +264,9 @@ where
                 viewport,
             );
         }
-        if self.on_exit.is_none() && let Event::Mouse(mouse::Event::CursorLeft {..}) = event {
+        if self.on_exit.is_none()
+            && let Event::Mouse(mouse::Event::CursorLeft) = event
+        {
             self.content.as_widget_mut().update(
                 &mut tree.children[0],
                 event,
@@ -284,27 +310,6 @@ where
         }
     }
 
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        renderer_style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-    ) {
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            renderer_style,
-            layout,
-            cursor,
-            viewport,
-        );
-    }
-
     fn overlay<'b>(
         &'b mut self,
         tree: &'b mut Tree,

src/widgets/mod.rs

@@ -1 +1,2 @@
 pub mod hard_mouse_area;
+pub mod card_display;