deck list code

Cargo.lock

@@ -2203,7 +2203,7 @@ checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jap_learn"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "criterion",
@@ -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",

Cargo.toml

@@ -1,15 +1,15 @@
 [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"] }
@@ -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"

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,6 @@ use log::info;
 use parking_lot::{Mutex, RwLock};
 use rusqlite::Connection;
 use std::sync::Arc;
-use crate::data_provider::custom_fields::CustomFieldRepository;
 
 pub const USER_FONT: Font = Font::with_name("Noto Sans JP");
 

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,7 +162,13 @@ 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 {

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(),
         }
     }

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,9 +93,7 @@ fn load_old_schema(connection: &Connection) -> Result<ImportData, NotificationDa
     }
     Err(IncorrectAnkiFile)
 }
-fn load_new_schema(connection: &Connection) -> Result<ImportData, NotificationData> {
+
-    return Err(IncorrectAnkiFile);
-}
 pub fn get_words_of_group(
     connection: &Connection,
     group_id: u64,
@@ -120,3 +117,23 @@ pub fn get_words_of_group(
         .filter_map(|x| x.ok())
         .collect::<Vec<ImportNote>>())
 }
+
+fn load_new_schema(connection: &Connection) -> Result<ImportData, NotificationData> {
+    return Err(IncorrectAnkiFile);
+}
+
+pub struct DeckHeader {
+    pub id: u64,
+    pub name: String,
+    pub count: u64,
+}
+
+pub fn load_decks(connection: &Connection) -> Result<Vec<DeckHeader>, NotificationData> {
+    let mut stmt = connection
+        .prepare("select id, name from decks")
+        .unwrap();
+    Ok(stmt.query_map([], |row| Ok(DeckHeader{
+        id: row.get::<usize, i64>(0)? as u64,
+        name: row.get(1)?
+    })).unwrap().filter_map(|x| x.ok()).collect::<Vec<DeckHeader>>())
+}

src/data_provider/sqlite.rs

@@ -76,12 +76,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,9 @@
 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 std::io;
-use tokio::fs::{File, OpenOptions};
+use tokio::fs::{remove_file, File, OpenOptions};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use zstd::{DEFAULT_COMPRESSION_LEVEL, Decoder, Encoder};
 
@@ -74,6 +74,8 @@ pub async fn load_data(id: String, temp: bool) -> MaybeError {
         .await
         .map_err(|_| WebApiUnavailable)?;
     set_local_version(version.parse::<u32>().unwrap_or_default()).await?;
+    remove_file(db_wal()).await.map_err(|_| OpenFileError)?;
+    remove_file(db_wal()).await.map_err(|_| OpenFileError)?;
     Ok(())
 }
 

src/data_provider/words.rs

@@ -1,6 +1,6 @@
+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};
@@ -69,19 +69,9 @@ 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]>>();

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/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")
@@ -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/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.clone() {
-                    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;
                             }
+                            _ => {}
                         }
                     }
 
@@ -351,43 +359,45 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 self.displayed_words_query.load(&dictionary);
                 self.selected_cell = 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(),
+                    column![
                         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);
 
@@ -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)
         }
 
-    fn groups_panel(&self) -> iced::Element<'_, DictionaryMessage> {
+        field.into()
+    }
+
+    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,17 +853,24 @@ 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;
+                        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,6 +8,7 @@ use crate::pages::dictionary::split_with_coma;
 use crate::pages::dictionary_quiz::DictionaryQuizMessage::*;
 use crate::pages::quiz::Score;
 use crate::styling::*;
+use crate::{jl_button, jl_text_input};
 use iced::Background::Color;
 use iced::border::Radius;
 use iced::widget::container::Style;
@@ -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/history.rs

@@ -57,8 +57,8 @@ 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())

src/pages/import.rs

@@ -9,9 +9,9 @@ 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::{
@@ -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

@@ -270,13 +270,13 @@ impl RepetitionState {
     fn draw_context(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
         match word.additional.get(&Id(3)) {
             None => space().into(),
-            Some(context) => text!("{}", context).size(24).into(),
+            Some(context) => text!("{}", context).center().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(),
+            Some(context) => text!("{}", context).center().size(24).into(),
         }
     }
 }

src/pages/repetition_settings.rs

@@ -2,12 +2,12 @@ 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;
@@ -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,7 +3,6 @@ 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::{History, PreviousPage, Repetition, RepetitionSettings};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::MaybeError;
@@ -14,6 +13,7 @@ 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;
 pub use iced::widget::button::{Catalog, Style};
@@ -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 {
@@ -302,7 +303,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 +316,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),
                                     ]

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,6 +102,18 @@ 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;
+                            return RootMessage::Sync(ResetRealLoad);
+                        }),
+                        Task::done(RootMessage::PushNotification(NotificationRequest::Warning(LocalVersionChanged)))
+                    ]);
+                }
+
+                self.real_load = false;
                 let id = self.state.sync_data.read().key.clone().unwrap();
                 let tasks = Task::batch([
                     Task::perform(
@@ -134,7 +149,7 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 }
 
                 return Task::done(RootMessage::PushNotification(NotificationRequest::Info(
-                    NotificationData::DataLoaded,
+                    NotificationData::DataSynced,
                 )));
             }
             Disable => {}
@@ -166,6 +181,9 @@ impl NavigatedPage<SyncMessage> for SyncState {
                     return push_error_task!(err);
                 }
             }
+            ResetRealLoad => {
+                self.real_load = false;
+            }
         }
         Task::none()
     }
@@ -189,6 +207,7 @@ impl SyncState {
             auto_fetch,
             state,
             frozen: false,
+            real_load: false,
             progress: 0.0,
         }
     }

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![
+                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 {
-
+                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,7 +135,7 @@ 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 {
@@ -140,12 +147,10 @@ impl<Message> WordEditor<Message> {
         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/tests.rs

@@ -1,5 +1,5 @@
 #[cfg(test)]
-mod mod_tests {
+mod data_access {
     use crate::data::Id;
     use crate::data::entities::{EntityData, EntityHandle};
     use crate::data::repositories::fast_position_of;
@@ -121,3 +121,19 @@ mod mod_tests {
         assert_eq!(entity.index(), 0)
     }
 }
+
+#[cfg(test)]
+mod anki_import{
+    use std::path::{Path, PathBuf};
+    use rusqlite::Connection;
+    use crate::data_provider::import::load_decks;
+    use crate::notification::NotificationData::IncorrectAnkiFile;
+
+    #[test]
+    pub fn decks(){
+        let file_name = Path::new("import");
+        let connection = Connection::open(file_name).unwrap();
+        let decks = load_decks(&connection).unwrap();
+        assert_eq!(decks.len(), 2);
+    }
+}

src/widgets/hard_mouse_area.rs

@@ -215,7 +215,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 +230,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 +244,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,