Prepare for new anki format

Compressing word fields
Fix deck filter
2026-09-13 12:44:51 +03:00 · 2026-09-11 22:08:50 +03:00 · 2026-09-11 14:02:57 +03:00 · 2026-09-11 13:56:26 +03:00 · 2026-09-11 13:28:23 +03:00 · 2026-09-11 13:12:45 +03:00
41 changed files with 1258 additions and 1178 deletions
@@ -40,11 +40,3 @@ panic = "abort"
 [dev-dependencies]
 criterion = { version = "0.8.2", features = ["html_reports"] }
 rustc-hash = "2.1.3"
 [[bench]]
 name = "map_bench"
 harness = false
 [[bench]]
 name = "repo_cache_bench"
 harness = false
@@ -1,126 +0,0 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use std::collections::HashMap as StdHashMap;
 use std::hint::black_box;
 use hashbrown::HashMap as BrownHashMap;
 const SIZES: [usize; 3] = [5, 10, 50];
 const QUERY_COUNT: usize = 4096;
 /// Детерминированный ключ ~17 символов, например "key_9e3779b9_0042".
 fn make_key(i: u64) -> String {
    let h = i.wrapping_mul(0x9E37_79B9_7F4A_7C15);
    format!("key_{:08x}_{:04}", h & 0xFFFF_FFFF, i)
 }
 // Для длинных ключей (пути/URL) замени на:
 // fn make_key(i: u64) -> String {
 //     format!(
 //         "/api/v2/users/{i}/settings/visibility_{:08x}",
 //         i.wrapping_mul(0x9E37_79B9)
 //     )
 // }
 fn make_vec(n: usize) -> Vec<(String, u64)> {
    (0..n as u64).map(|i| (make_key(i), i)).collect()
 }
 fn make_std_map(data: &[(String, u64)]) -> StdHashMap<String, u64> {
    data.iter().map(|(k, v)| (k.clone(), *v)).collect()
 }
 fn make_brown_map(data: &[(String, u64)]) -> BrownHashMap<String, u64> {
    data.iter().map(|(k, v)| (k.clone(), *v)).collect()
 }
 fn make_queries(n: usize, with_misses: bool) -> Vec<String> {
    let keys: Vec<String> = (0..n as u64).map(make_key).collect();
    let missing = "__missing_key__".to_string();
    (0..QUERY_COUNT)
        .map(|i| {
            if with_misses && i % 16 == 15 {
                missing.clone()
            } else {
                let idx = i.wrapping_mul(2_654_435_761) % n;
                keys[idx].clone()
            }
        })
        .collect()
 }
 fn lookup_std(map: &StdHashMap<String, u64>, queries: &[String]) -> u64 {
    let mut sum = 0u64;
    for q in queries {
        match map.get(black_box(q.as_str())) {
            Some(v) => sum = sum.wrapping_add(*v),
            None => sum = sum.wrapping_add(1),
        }
    }
    black_box(sum)
 }
 fn lookup_brown(map: &BrownHashMap<String, u64>, queries: &[String]) -> u64 {
    let mut sum = 0u64;
    for q in queries {
        match map.get(black_box(q.as_str())) {
            Some(v) => sum = sum.wrapping_add(*v),
            None => sum = sum.wrapping_add(1),
        }
    }
    black_box(sum)
 }
 fn lookup_vec(data: &[(String, u64)], queries: &[String]) -> u64 {
    let mut sum = 0u64;
    for q in queries {
        let q = black_box(q);
        match data.iter().find(|(k, _)| k == q) {
            Some((_, v)) => sum = sum.wrapping_add(*v),
            None => sum = sum.wrapping_add(1),
        }
    }
    black_box(sum)
 }
 fn bench(c: &mut Criterion) {
    let mut group = c.benchmark_group("map_vs_vec_str");
    for n in SIZES {
        let vec_data = make_vec(n);
        let std_map = make_std_map(&vec_data);
        let brown_map = make_brown_map(&vec_data);
        let queries_hit = make_queries(n, false);
        let queries_mixed = make_queries(n, true);
        // std::collections::HashMap (SipHash)
        group.bench_function(format!("std_hashmap_hit/{n}"), |b| {
            b.iter(|| lookup_std(black_box(&std_map), black_box(&queries_hit)))
        });
        group.bench_function(format!("std_hashmap_mixed/{n}"), |b| {
            b.iter(|| lookup_std(black_box(&std_map), black_box(&queries_mixed)))
        });
        // hashbrown (SwissTable + foldhash)
        group.bench_function(format!("hashbrown_hit/{n}"), |b| {
            b.iter(|| lookup_brown(black_box(&brown_map), black_box(&queries_hit)))
        });
        group.bench_function(format!("hashbrown_mixed/{n}"), |b| {
            b.iter(|| lookup_brown(black_box(&brown_map), black_box(&queries_mixed)))
        });
        // Vec<(String, u64)>, линейный поиск
        group.bench_function(format!("vec_linear_hit/{n}"), |b| {
            b.iter(|| lookup_vec(black_box(&vec_data), black_box(&queries_hit)))
        });
        group.bench_function(format!("vec_linear_mixed/{n}"), |b| {
            b.iter(|| lookup_vec(black_box(&vec_data), black_box(&queries_mixed)))
        });
    }
    group.finish();
 }
 criterion_group!(benches, bench);
 criterion_main!(benches);
@@ -1,325 +0,0 @@
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use hashbrown::HashMap as HashbrownMap;
 use rustc_hash::FxHashMap;
 use std::collections::{BTreeMap, HashMap};
 use std::hint::black_box;
 // Тестовая структура (аналог вашей сущности)
 #[derive(Debug, Clone)]
 struct Entity {
    id: i64,
    data: [u8; 64], // 64 байта данных для реалистичности
 }
 impl Entity {
    fn new(id: i64) -> Self {
        Self {
            id,
            data: [id as u8; 64],
        }
    }
 }
 // ========== ТЕСТОВЫЕ ФУНКЦИИ ==========
 fn bench_vec_insert_sorted(vec: &mut Vec<Entity>, entities: &[Entity]) {
    vec.clear();
    for entity in entities {
        vec.push(entity.clone());
    }
    // Vec уже отсортирован, так как ID монотонно возрастают
 }
 fn bench_vec_search_separated<'a>(ids: &[i64], vec: &'a [Entity], id: i64) -> Option<&'a Entity> {
    match ids.binary_search(&id) {
        Ok(index) => Some(&vec[index]),
        Err(_) => None,
    }
 }
 fn bench_vec_search(vec: &Vec<Entity>, id: i64) -> Option<&Entity> {
    match vec.binary_search_by(|probe| probe.id.cmp(&id)) {
        Ok(index) => Some(&vec[index]),
        Err(_) => None,
    }
 }
 fn bench_btreemap_insert(map: &mut BTreeMap<i64, Entity>, entities: &[Entity]) {
    map.clear();
    for entity in entities {
        map.insert(entity.id, entity.clone());
    }
 }
 fn bench_btreemap_search(map: &BTreeMap<i64, Entity>, id: i64) -> Option<&Entity> {
    map.get(&id)
 }
 fn bench_hashmap_insert(map: &mut HashMap<i64, Entity>, entities: &[Entity]) {
    map.clear();
    for entity in entities {
        map.insert(entity.id, entity.clone());
    }
 }
 fn bench_hashmap_search(map: &HashMap<i64, Entity>, id: i64) -> Option<&Entity> {
    map.get(&id)
 }
 fn bench_hashbrown_insert(map: &mut HashbrownMap<i64, Entity>, entities: &[Entity]) {
    map.clear();
    for entity in entities {
        map.insert(entity.id, entity.clone());
    }
 }
 fn bench_hashbrown_search(map: &HashbrownMap<i64, Entity>, id: i64) -> Option<&Entity> {
    map.get(&id)
 }
 fn bench_fxhashmap_insert(map: &mut FxHashMap<i64, Entity>, entities: &[Entity]) {
    map.clear();
    for entity in entities {
        map.insert(entity.id, entity.clone());
    }
 }
 fn bench_fxhashmap_search(map: &FxHashMap<i64, Entity>, id: i64) -> Option<&Entity> {
    map.get(&id)
 }
 // ========== ГЕНЕРАЦИЯ ДАННЫХ ==========
 fn generate_entities(count: usize) -> Vec<Entity> {
    (0..count).map(|i| Entity::new(i as i64)).collect()
 }
 fn generate_search_ids(count: usize, max_id: i64) -> Vec<i64> {
    // 70% попаданий, 30% промахов (реалистичный сценарий)
    let mut ids = Vec::with_capacity(count);
    for i in 0..count {
        if i % 10 < 7 {
            // Попадание
            ids.push((i as i64 * 13) % max_id);
        } else {
            // Промах (несуществующий ID)
            ids.push(max_id + i as i64);
        }
    }
    ids
 }
 // ========== БЕНЧМАРКИ ==========
 fn bench_insert(c: &mut Criterion) {
    let mut group = c.benchmark_group("insert");
    for size in [10_000, 100_000, 500_000] {
        let entities = generate_entities(size);
        group.bench_with_input(
            BenchmarkId::new("Vec (sorted)", size),
            &entities,
            |b, entities| {
                let mut vec = Vec::with_capacity(size);
                b.iter(|| {
                    bench_vec_insert_sorted(&mut vec, black_box(entities));
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("BTreeMap", size),
            &entities,
            |b, entities| {
                let mut map = BTreeMap::new();
                b.iter(|| {
                    bench_btreemap_insert(&mut map, black_box(entities));
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("HashMap (std)", size),
            &entities,
            |b, entities| {
                let mut map = HashMap::new();
                b.iter(|| {
                    bench_hashmap_insert(&mut map, black_box(entities));
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("HashMap (hashbrown)", size),
            &entities,
            |b, entities| {
                let mut map = HashbrownMap::new();
                b.iter(|| {
                    bench_hashbrown_insert(&mut map, black_box(entities));
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("FxHashMap", size),
            &entities,
            |b, entities| {
                let mut map = FxHashMap::default();
                b.iter(|| {
                    bench_fxhashmap_insert(&mut map, black_box(entities));
                });
            },
        );
    }
    group.finish();
 }
 fn bench_search(c: &mut Criterion) {
    let mut group = c.benchmark_group("search");
    for size in [10_000, 100_000, 500_000] {
        let entities = generate_entities(size);
        let entity_ids = entities.iter().map(|entity| entity.id).collect::<Vec<_>>();
        let search_ids = generate_search_ids(1000, size as i64);
        // Подготовка коллекций
        let mut vec = Vec::with_capacity(size);
        bench_vec_insert_sorted(&mut vec, &entities);
        let mut btreemap = BTreeMap::new();
        bench_btreemap_insert(&mut btreemap, &entities);
        let mut hashmap = HashMap::new();
        bench_hashmap_insert(&mut hashmap, &entities);
        let mut hashbrown = HashbrownMap::new();
        bench_hashbrown_insert(&mut hashbrown, &entities);
        let mut fxhashmap = FxHashMap::default();
        bench_fxhashmap_insert(&mut fxhashmap, &entities);
        group.bench_with_input(
            BenchmarkId::new("Vec (binary search)", size),
            &search_ids,
            |b, ids| {
                b.iter(|| {
                    for &id in ids {
                        black_box(bench_vec_search_separated(&entity_ids, &vec, black_box(id)));
                    }
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("Vec (binary search) separated", size),
            &search_ids,
            |b, ids| {
                b.iter(|| {
                    for &id in ids {
                        black_box(bench_vec_search(&vec, black_box(id)));
                    }
                });
            },
        );
        group.bench_with_input(BenchmarkId::new("BTreeMap", size), &search_ids, |b, ids| {
            b.iter(|| {
                for &id in ids {
                    black_box(bench_btreemap_search(&btreemap, black_box(id)));
                }
            });
        });
        group.bench_with_input(
            BenchmarkId::new("HashMap (std)", size),
            &search_ids,
            |b, ids| {
                b.iter(|| {
                    for &id in ids {
                        black_box(bench_hashmap_search(&hashmap, black_box(id)));
                    }
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("HashMap (hashbrown)", size),
            &search_ids,
            |b, ids| {
                b.iter(|| {
                    for &id in ids {
                        black_box(bench_hashbrown_search(&hashbrown, black_box(id)));
                    }
                });
            },
        );
        group.bench_with_input(
            BenchmarkId::new("FxHashMap", size),
            &search_ids,
            |b, ids| {
                b.iter(|| {
                    for &id in ids {
                        black_box(bench_fxhashmap_search(&fxhashmap, black_box(id)));
                    }
                });
            },
        );
    }
    group.finish();
 }
 fn bench_memory_efficiency(c: &mut Criterion) {
    let mut group = c.benchmark_group("memory_efficiency");
    let size = 100_000;
    let entities = generate_entities(size);
    group.bench_function("Vec memory", |b| {
        b.iter(|| {
            let mut vec = Vec::with_capacity(size);
            bench_vec_insert_sorted(&mut vec, black_box(&entities));
            black_box(vec);
        });
    });
    group.bench_function("BTreeMap memory", |b| {
        b.iter(|| {
            let mut map = BTreeMap::new();
            bench_btreemap_insert(&mut map, black_box(&entities));
            black_box(map);
        });
    });
    group.bench_function("HashMap (std) memory", |b| {
        b.iter(|| {
            let mut map = HashMap::new();
            bench_hashmap_insert(&mut map, black_box(&entities));
            black_box(map);
        });
    });
    group.bench_function("HashMap (hashbrown) memory", |b| {
        b.iter(|| {
            let mut map = HashbrownMap::new();
            bench_hashbrown_insert(&mut map, black_box(&entities));
            black_box(map);
        });
    });
    group.bench_function("FxHashMap memory", |b| {
        b.iter(|| {
            let mut map = FxHashMap::default();
            bench_fxhashmap_insert(&mut map, black_box(&entities));
            black_box(map);
        });
    });
    group.finish();
 }
 criterion_group!(benches, bench_insert, bench_search, bench_memory_efficiency);
 criterion_main!(benches);
@@ -1,4 +1,6 @@
-create table custom_fields(
+create table custom_fields
-    id INTEGER PRIMARY KEY,
+(
-    name TEXT not null
+    id            integer primary key,
    name          text not null,
    identifier text not null
 );
@@ -1,9 +1,9 @@
 create table decks
 (
-    id       INTEGER
+    id       integer
        primary key autoincrement,
-    name     TEXT not null,
+    name     text not null,
-    forward  TEXT not null,
+    forward  text not null,
-    backward TEXT not null,
+    backward text not null,
-    filter   TEXT not null
+    filter   text not null
 );
@@ -1,12 +1,12 @@
 create table history
 (
-    id INTEGER
+    id        integer
        primary key autoincrement,
-    deck_id INTEGER not null references decks on delete cascade,
+    deck_id   integer not null references decks on delete cascade,
-    word_id INTEGER not null references words on delete cascade,
+    word_id   integer not null references words on delete cascade,
-    timestamp INTEGER not null,
+    timestamp integer not null,
-    answer INTEGER not null,
+    answer    integer not null,
-    before INTEGER not null,
+    before    integer not null,
-    after INTEGER not null,
+    after     integer not null,
-    fsrs INTEGER not null
+    fsrs      integer not null
 );
@@ -1,16 +1,16 @@
 create table states
 (
-    id          INTEGER
+    id            integer
        primary key autoincrement,
-    word_id     INTEGER           not null
+    word_id       integer           not null
        references words
            on delete cascade,
-    deck_id      INTEGER              not null
+    deck_id       integer           not null
        references decks
            on delete cascade,
-    score       INTEGER default 1 not null,
+    score         integer default 1 not null,
-    last_opened INTEGER           not null,
+    last_opened   integer           not null,
-    fsrs_opened INTEGER not null,
+    fsrs_opened   integer           not null,
-    fsrs_memory INTEGER not null,
+    fsrs_memory   integer           not null,
-    fsrs_open_day INTEGER not null
+    fsrs_open_day integer           not null
 );
@@ -1,6 +1,6 @@
 create table word_groups
 (
-    id   INTEGER
+    id   integer
        primary key autoincrement,
-    name TEXT not null
+    name text not null
 );
@@ -1,11 +1,11 @@
 create table words
 (
-    id       INTEGER
+    id       integer
        primary key autoincrement,
-    key      TEXT              not null,
+    key      text              not null,
-    value    TEXT              not null,
+    value    text              not null,
-    tags     TEXT              not null,
+    tags     text              not null,
-    more     TEXT,
+    more     text,
    group_id integer default 1 not null
        constraint words_word_groups_id_fk
            references word_groups
@@ -17,6 +17,7 @@ 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");
@@ -65,6 +66,7 @@ pub struct AppState {
    pub decks: DeckRepository,
    pub word_groups: WordGroupRepository,
    pub card_states: CardStateRepository,
    pub custom_fields: CustomFieldRepository,
    pub connection: Arc<Mutex<SqliteConnection>>,
    pub sync_data: Arc<RwLock<AppSettings>>,
    pub history: HistoryRepository,
@@ -85,6 +87,7 @@ impl AppState {
            word_groups: WordGroupRepository::new(connection.clone()),
            card_states: CardStateRepository::new(connection.clone()),
            history: HistoryRepository::new(connection.clone()),
            custom_fields: CustomFieldRepository::new(connection.clone()),
            sync_data: Arc::new(RwLock::new(AppSettings {
                key: None,
                auto_web_fetch: false,
@@ -104,6 +107,7 @@ pub fn fill_state(state: &mut AppState) {
    state.decks.write().start().unwrap();
    state.history.write().start().unwrap();
    state.card_states.write().start().unwrap();
    state.custom_fields.write().start().unwrap();
    state.sync_data = Arc::new(RwLock::new(setting))
 }
@@ -1,3 +1,4 @@
 use std::collections::HashMap;
 use crate::app::AppState;
 use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS};
 use crate::core::srs::{
@@ -13,6 +14,7 @@ use log::info;
 use rhai::{Engine, Scope};
 use std::sync::Arc;
 use std::time::Instant;
 use crate::data::Id;
 #[derive(Clone)]
 pub struct DeckData {
@@ -33,7 +35,9 @@ impl DeckData {
            .map(|card_state| EntityHandle::from_id(card_state.word_id))
            .collect();
        let states = query.handles().collect::<Vec<EntityHandle<CardState>>>();
-        let fsrs = Fsrs(FsrsModule::new(Self::set_links(states.as_slice(), &states_repo).as_slice()));
+        let fsrs = Fsrs(FsrsModule::new(
            Self::set_links(states.as_slice(), &states_repo).as_slice(),
        ));
        drop(states_repo);
        Self {
            states,
@@ -61,7 +65,7 @@ impl DeckData {
        };
        self.current_word_index = Some(index);
-        (self.words[index].clone(), self.states[index].clone())
+        (self.words[index], self.states[index])
    }
    fn set_links<'a>(
@@ -108,7 +112,7 @@ impl DeckData {
                timestamp: Utc::now(),
                deck_id: self.settings.id,
                word_id,
-                answer: status.clone(),
+                answer: status,
                before: old_score,
                after: new_score,
                fsrs,
@@ -152,10 +156,11 @@ 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 query = dictionary.query_par(Arc::new(move |word| {
                let mut more = rhai::Map::new();
-                for iced in &word.additional {
+                for kv in &word.additional {
-                    more.insert(iced.0.clone().into(), iced.1.clone().into());
+                    more.insert(fields[&kv.0].clone().into(), kv.1.clone().into());
                }
                let mut scope = Scope::new();
                let group_name = groups[groups
@@ -44,9 +44,7 @@ impl SRSModule for RandomSRSModule {
    fn new(set: &[&CardState]) -> Self {
        let mut basket = (0..set.len()).collect::<Vec<usize>>();
        basket.shuffle(&mut rand::rng());
-        Self{
+        Self { basket }
            basket,
        }
    }
    fn next(&mut self, set: &[&CardState]) -> usize {
@@ -90,7 +88,6 @@ impl SRSModule for SemiRandomSRSModule {
            .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)
@@ -99,7 +96,7 @@ impl SRSModule for SemiRandomSRSModule {
        Self {
            generator: rng(),
            last_weights: WeightedIndex::new(weights).expect("Incorrect weights update"),
-            history: vec![]
+            history: vec![],
        }
    }
 }
@@ -233,7 +230,9 @@ 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) || (first_time && status == WordOpenMode::Easy) {
+        if (updated_word.fsrs_open_day != today && !first_time)
            || (first_time && status == WordOpenMode::Easy)
        {
            info!("For today word on index {} solved", index);
            self.solved.push(index);
            let index = self.current_group.iter().position(|x| *x == index).unwrap();
@@ -1,5 +1,6 @@
 use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, WordOpenMode};
-use crate::data::{INVALID_ID, Id};
+use crate::data::{Id, SmallId, INVALID_ID};
 use crate::data_provider::history::HistoryRepositoryInner;
 use chrono::{DateTime, Local, NaiveDate, Utc};
 use fsrs::MemoryState;
 use litemap::LiteMap;
@@ -10,7 +11,6 @@ use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Instant;
 use crate::data_provider::history::{HistoryRepository, HistoryRepositoryInner};
 #[derive(Clone, Debug)]
 pub struct WordData {
@@ -19,7 +19,7 @@ pub struct WordData {
    pub key: String,
    pub value: String,
    pub tags: String,
-    pub additional: LiteMap<String, String>,
+    pub additional: LiteMap<Id, String>,
 }
 impl EntityData for WordData {
@@ -70,7 +70,7 @@ pub struct HistoryNote {
    pub answer: WordOpenMode,
    pub before: u8,
    pub after: u8,
-    pub fsrs: bool
+    pub fsrs: bool,
 }
 impl EntityData for HistoryNote {
@@ -86,7 +86,7 @@ impl EntityData for HistoryNote {
 impl HistoryRepositoryInner {
    pub fn activity_of_deck(&self, id: Id) -> Vec<(NaiveDate, u32)> {
        let mut query = self.query(Arc::new(move |note| note.deck_id == id));
-        let values = query.iter(&self).collect::<Vec<_>>();
+        let values = query.iter(self).collect::<Vec<_>>();
        let mut counts = vec![];
        if !values.is_empty() {
            let mut date = values[0].timestamp.with_timezone(&Local).date_naive();
@@ -95,8 +95,7 @@ impl HistoryRepositoryInner {
                let current_date = note.timestamp.with_timezone(&Local).date_naive();
                if date == current_date {
                    count += 1;
-                }
+                } else {
                else {
                    counts.push((date, count));
                    date = current_date;
                    count = 0;
@@ -197,9 +196,21 @@ impl CardState {
    }
 }
 #[derive(Clone)]
 pub struct CustomField {
    pub id: Id,
    pub name: String,
    pub identifier: String,
 }
 impl EntityData for CustomField {
    fn id(&self) -> Id {
        self.id
    }
    fn set_id(&mut self, id: Id) {
        self.id = id;
    }
 }
 pub struct EntityHandle<E> {
@@ -210,13 +221,10 @@ pub struct EntityHandle<E> {
 impl<T> Clone for EntityHandle<T> {
    fn clone(&self) -> Self {
-        EntityHandle {
+        *self
            id: self.id,
            index: self.index,
            _phantom: Default::default(),
        }
    }
 }
 impl<T> Copy for EntityHandle<T> {}
 impl<T> EntityHandle<T> {
    pub fn new(id: Id, index: usize, real: bool) -> Self {
@@ -1,8 +1,9 @@
 use crate::data::Id;
-use crate::data::entities::{CardState, EntityData, EntityHandle};
+use crate::data::entities::{EntityData, EntityHandle};
 use crate::data_provider::sqlite::SqliteConnection;
 use crate::helpers::into_result;
 use crate::notification::{MaybeError, NotificationData};
 use log::debug;
 use parking_lot::{Mutex, RwLock};
 use rayon::iter::IndexedParallelIterator;
 use rayon::iter::IntoParallelRefIterator;
@@ -12,7 +13,6 @@ use std::marker::PhantomData;
 use std::ops::{Deref, Index, IndexMut};
 use std::sync::Arc;
 use std::time::Instant;
 use log::debug;
 pub trait Repository<T, D>
 where
@@ -31,13 +31,19 @@ where
    fn create_now(&mut self, new: T) -> Result<EntityHandle<T>, NotificationData>;
    fn save(&mut self, entity: &mut EntityHandle<T>) -> MaybeError;
    fn delete(&mut self, handle: EntityHandle<T>) -> MaybeError;
-    fn find<F>(&self, predicate: F) -> Option<EntityHandle<T>> where F : Fn(&T) -> bool;
+    fn find<F>(&self, predicate: F) -> Option<EntityHandle<T>>
    where
        F: Fn(&T) -> bool;
    fn init(&mut self) -> MaybeError;
    fn start(&mut self) -> MaybeError;
    fn reload(&mut self) -> MaybeError;
    fn shifts(&self) -> usize;
-    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a T> where T: 'a;
+    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a T>
-    fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut T> where T: 'a;
+    where
        T: 'a;
    fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut T>
    where
        T: 'a;
 }
 struct QueryManger<T, R, D>
@@ -88,9 +94,7 @@ where
            .filter(|(_, q)| {
                let query = q.lock();
                let rule = &query.rule;
-                return rule(data);
+                rule(data)
                false
            })
            .map(|(i, _)| i)
            .collect()
@@ -118,7 +122,10 @@ where
 }
 impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Query<T, R, D> {
-    pub fn iter<'a>(&mut self, data_repository_inner: &'a DataRepositoryInner<T, D>) -> impl Iterator<Item = &'a T>
+    pub fn iter<'a>(
        &mut self,
        data_repository_inner: &'a DataRepositoryInner<T, D>,
    ) -> impl Iterator<Item = &'a T>
    where
        T: 'a,
    {
@@ -130,7 +137,10 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
            .filter_map(move |e| data_repository_inner.get_ref(e))
    }
-    pub fn iter_with_handles<'a>(&mut self, data_repository_inner: &'a DataRepositoryInner<T, D>) -> impl Iterator<Item =  (&'a T, EntityHandle<T>)>
+    pub fn iter_with_handles<'a>(
        &mut self,
        data_repository_inner: &'a DataRepositoryInner<T, D>,
    ) -> impl Iterator<Item = (&'a T, EntityHandle<T>)>
    where
        T: 'a,
    {
@@ -139,7 +149,7 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
        }
        self.cache
            .iter_mut()
-            .filter_map(move |e| Some((data_repository_inner.get_ref(e)?, e.clone())))
+            .filter_map(move |e| Some((data_repository_inner.get_ref(e)?, *e)))
    }
    pub fn for_each_mut<F>(&mut self, repo: &mut DataRepositoryInner<T, D>, mut f: F)
@@ -190,7 +200,12 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
                .collect::<Vec<_>>(),
        );
-        debug!("Query for {} elements (filtered {}) takes {:?}", data_repository.len(), self.cache.len(), time.elapsed());
+        debug!(
            "Query for {} elements (filtered {}) takes {:?}",
            data_repository.len(),
            self.cache.len(),
            time.elapsed()
        );
    }
    pub fn handles(&self) -> impl Iterator<Item = EntityHandle<T>> {
@@ -200,9 +215,15 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
    pub fn len(&self) -> usize {
        self.cache.len()
    }
    pub fn get(&self, index: usize) -> Option<EntityHandle<T>> {
        self.cache.get(index).cloned()
    }
 }
-impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Index<usize> for  Query<T, R, D> {
+impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Index<usize>
    for Query<T, R, D>
 {
    type Output = EntityHandle<T>;
    fn index(&self, index: usize) -> &Self::Output {
@@ -210,7 +231,9 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> In
    }
 }
-impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> IndexMut<usize> for  Query<T, R, D> {
+impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> IndexMut<usize>
    for Query<T, R, D>
 {
    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
        &mut self.cache[index]
    }
@@ -221,7 +244,10 @@ where
    D: BatchedDbLayer<T>,
    T: EntityData,
 {
-    fn create_now_many(&mut self, entities: &mut [T]) -> Result<Vec<EntityHandle<T>>, NotificationData>;
+    fn create_now_many(
        &mut self,
        entities: &mut [T],
    ) -> Result<Vec<EntityHandle<T>>, NotificationData>;
    fn save_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError;
    fn delete_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError;
 }
@@ -274,7 +300,6 @@ impl<T: Clone + EntityData, D: DbLayer<T> + Default>  DataRepository<T, D> {
    }
 }
 impl<T: Clone + EntityData, D: DbLayer<T>> Deref for DataRepository<T, D> {
    type Target = Arc<RwLock<DataRepositoryInner<T, D>>>;
@@ -283,7 +308,9 @@ impl<T: Clone + EntityData, D: DbLayer<T>> Deref for DataRepository<T, D> {
    }
 }
-impl<T: EntityData + Clone + std::marker::Send + std::marker::Sync, D: DbLayer<T>> DataRepositoryInner<T, D> {
+impl<T: EntityData + Clone + std::marker::Send + std::marker::Sync, D: DbLayer<T>>
    DataRepositoryInner<T, D>
 {
    pub fn query_par(
        &self,
        rule: Arc<dyn Fn(&T) -> bool + Send + Sync>,
@@ -433,7 +460,7 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
    }
    fn save(&mut self, entity: &mut EntityHandle<T>) -> MaybeError {
-        let original_state = entity.clone();
+        let original_state = *entity;
        if entity.real() {
            let data = self.get_ref(entity).unwrap();
            self.data_layer
@@ -441,12 +468,11 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
        } else {
            let index = fast_position_of(self.temporal.as_slice(), entity).unwrap();
            let data = &mut self.temporal[index];
-            self.data_layer
+            self.data_layer.add_entity(data, &self.connection.lock())?;
                .add_entity(data, &self.connection.lock())?;
            entity.set_real(true);
            entity.id = data.id();
            entity.set_index(self.cache.len());
-            self.query_manger.handle_save(original_state, entity, &data);
+            self.query_manger.handle_save(original_state, entity, data);
            let data = self.temporal.remove(index);
            self.cache.push(data);
@@ -477,16 +503,16 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
    fn find<F>(&self, predicate: F) -> Option<EntityHandle<T>>
    where
-        F: Fn(&T) -> bool
+        F: Fn(&T) -> bool,
    {
-        if let Some(index) = self.cache.iter().position(|entity| predicate(entity)){
+        if let Some(index) = self.cache.iter().position(&predicate) {
            let value = &self.cache[index];
-            return Some(EntityHandle::new(value.id(), index, true))
+            return Some(EntityHandle::new(value.id(), index, true));
        }
-        if let Some(index) = self.temporal.iter().position(|entity| predicate(entity)){
+        if let Some(index) = self.temporal.iter().position(predicate) {
            let value = &self.temporal[index];
-            return Some(EntityHandle::new(value.id(), index, false))
+            return Some(EntityHandle::new(value.id(), index, false));
        }
        None
    }
@@ -520,14 +546,14 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
    fn iter<'a>(&'a self) -> impl Iterator<Item = &'a T>
    where
-        T: 'a
+        T: 'a,
    {
        self.cache.iter().chain(self.temporal.iter())
    }
    fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut T>
    where
-        T: 'a
+        T: 'a,
    {
        self.cache.iter_mut().chain(self.temporal.iter_mut())
    }
@@ -535,10 +561,18 @@ impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryIn
 impl<T: EntityData + Clone, D: BatchedDbLayer<T> + DbLayer<T>> BatchedRepository<T, D>
    for DataRepositoryInner<T, D>
 {
-    fn create_now_many(&mut self, entities: &mut [T]) -> Result<Vec<EntityHandle<T>>, NotificationData> {
+    fn create_now_many(
-        self.data_layer.add_many_entities(entities, &mut self.connection.lock())?;
+        &mut self,
        entities: &mut [T],
    ) -> Result<Vec<EntityHandle<T>>, NotificationData> {
        self.data_layer
            .add_many_entities(entities, &mut self.connection.lock())?;
        let len = self.cache.len();
-        let handles = entities.iter().enumerate().map(|(index, entity)| {EntityHandle::new(entity.id(), index + len, true)}).collect();
+        let handles = entities
            .iter()
            .enumerate()
            .map(|(index, entity)| EntityHandle::new(entity.id(), index + len, true))
            .collect();
        self.cache.extend(entities.to_vec());
        Ok(handles)
    }
@@ -577,7 +611,7 @@ impl<T: EntityData + Clone, D: BatchedDbLayer<T> + DbLayer<T>> BatchedRepository
        let start = self.cache.len();
        for (i, (handle, data)) in temp.into_iter().zip(&mut temp_values).enumerate() {
-            let old = handle.clone();
+            let old = *handle;
            handle.id = data.id();
            handle.set_index(start + i);
            handle.set_real(true);
@@ -641,7 +675,7 @@ where
 {
    let mut temp = Vec::with_capacity(handles.len() / 2);
    let mut cached = Vec::with_capacity(handles.len() / 2);
-    handles.sort_by(|a, b| a.id.cmp(&b.id));
+    handles.sort_by_key(|a| a.id);
    handles.iter().for_each(|handle| {
        if handle.real() {
            cached.push(getter(handle))
@@ -1,20 +1,14 @@
-use std::sync::Arc;
+use crate::data::Id;
-use crate::data::entities::{CardState, DeckSettings};
+use crate::data::entities::CardState;
 use crate::data::repositories::{DataRepository, DataRepositoryInner, Query};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};
 use crate::notification::{MaybeError, NotificationData};
 use chrono::NaiveDate;
 use fsrs::MemoryState;
-use log::info;
+use rusqlite::{Error, Params, Row};
-use rusqlite::{Connection, Error, Params, Row, params};
+use std::sync::Arc;
 use std::time::Instant;
 use crate::data::Id;
-pub type CardStateRepository =
+pub type CardStateRepository = DataRepository<CardState, CardStateDbLayer>;
-    DataRepository<CardState, CardStateDbLayer>;
+pub type CardStateRepositoryInner = DataRepositoryInner<CardState, CardStateDbLayer>;
 pub type CardStateRepositoryInner =
    DataRepositoryInner<CardState, CardStateDbLayer>;
 pub type CardStateDbLayer = SqliteDbLayer<CardState, CardStatesQuerySet>;
 #[derive(Clone)]
 pub struct CardStatesQuerySet;
@@ -73,35 +67,6 @@ impl TableAccessQuerySet<CardState> for CardStatesQuerySet {
        )
    }
 }
 pub fn load_stats_of_deck(
    set: &DeckSettings,
    connection: &Connection,
 ) -> Result<Vec<CardState>, NotificationData> {
    let mut stmt = connection
        .prepare("SELECT id, word_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day FROM states WHERE set_id = ?1")
        .expect("Failed to prepare state query");
    let iter = stmt
        .query_map((set.id,), |row| {
            Ok(CardState {
                id: row.get(0)?,
                word_id: row.get(1)?,
                deck_id: set.id,
                score: row.get(2)?,
                fsrs_opened: NaiveDate::from_epoch_days(row.get::<usize, i32>(4)?)
                    .expect("Incorrect date encoding"),
                fsrs_memory: get_memory(row.get(5)?),
                last_open: row.get(3)?,
                fsrs_open_day: NaiveDate::from_epoch_days(row.get::<usize, i32>(6)?)
                    .expect("Incorrect date encoding"),
            })
        })
        .map_err(|_| DbLoadError)?;
    let mut buffer = Vec::with_capacity(512);
    iter.filter_map(|res| res.ok()).for_each(|i| buffer.push(i));
    Ok(buffer)
 }
 fn get_memory(value: i64) -> Option<MemoryState> {
    if value == 0 {
@@ -122,7 +87,10 @@ fn memory_to_i64(value: &Option<MemoryState>) -> i64 {
 }
 impl CardStateRepositoryInner {
-    pub fn deck_states(&self, deck_id: Id) -> Query<CardState, CardStateRepositoryInner, CardStateDbLayer> {
+    pub fn deck_states(
-        self.query(Arc::new(move |state| {state.deck_id == deck_id}))
+        &self,
        deck_id: Id,
    ) -> Query<CardState, CardStateRepositoryInner, CardStateDbLayer> {
        self.query(Arc::new(move |state| state.deck_id == deck_id))
    }
 }
@@ -1,40 +1,43 @@
-use crate::data::entities::{CustomField, WordGroup};
+use crate::data::entities::CustomField;
-use crate::data::repositories::DataRepository;
+use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use rusqlite::{Error, Params, Row};
-pub type CustomFieldRepository = DataRepository<CustomField, SqliteDbLayer<CustomField, CustomFieldsQuerySet>>;
+pub type CustomFieldRepository = DataRepository<CustomField, CustomFieldDbLayer>;
-
+pub type CustomFieldRepositoryInner = DataRepositoryInner<CustomField, CustomFieldDbLayer>;
 pub type CustomFieldDbLayer = SqliteDbLayer<CustomField, CustomFieldsQuerySet>;
 #[derive(Clone)]
 pub struct CustomFieldsQuerySet;
-impl TableAccessQuerySet<WordGroup> for CustomFieldsQuerySet {
+impl TableAccessQuerySet<CustomField> for CustomFieldsQuerySet {
    fn load() -> &'static str {
-        "SELECT id, name FROM custom_fields"
+        "SELECT id, name, identifier FROM custom_fields"
    }
    fn save() -> &'static str {
-        "UPDATE custom_fields SET name = ?1 WHERE id = ?2"
+        "UPDATE custom_fields SET name = ?1, identifier = ?2 WHERE id = ?3"
    }
    fn add() -> &'static str {
-        "INSERT INTO word_groups (name) VALUES (?1)"
+        "INSERT INTO custom_fields (name, identifier) VALUES (?1, ?2)"
    }
    fn name() -> &'static str {
        "custom_fields"
    }
-    fn from_sql(row: &Row) -> Result<WordGroup, Error> {
+    fn from_sql(row: &Row) -> Result<CustomField, Error> {
-        Ok(WordGroup {
+        Ok(CustomField {
            id: row.get(0)?,
            name: row.get(1)?,
            identifier: row.get(2)?,
        })
    }
-    fn insert_params(entity: &WordGroup) -> impl Params {
+    fn insert_params(entity: &CustomField) -> impl Params {
-        (&entity.name,)
+        (&entity.name, &entity.identifier)
    }
-    fn update_params(entity: &WordGroup) -> impl Params {
+    fn update_params(entity: &CustomField) -> impl Params {
-        (&entity.name, entity.id)
+        (&entity.name, &entity.identifier, entity.id)
    }
 }
@@ -48,7 +48,7 @@ impl TableAccessQuerySet<HistoryNote> for HistoryQuerySet {
        (
            entity.deck_id,
            entity.word_id,
-            entity.timestamp,
+            entity.timestamp.timestamp(),
            entity.answer,
            entity.before,
            entity.after,
@@ -60,7 +60,7 @@ impl TableAccessQuerySet<HistoryNote> for HistoryQuerySet {
        (
            entity.deck_id,
            entity.word_id,
-            entity.timestamp,
+            entity.timestamp.timestamp(),
            entity.answer,
            entity.before,
            entity.after,
@@ -77,7 +77,7 @@ impl FromSql for WordOpenMode {
                2 => Ok(WordOpenMode::Ok),
                3 => Ok(WordOpenMode::Easy),
                _ => Ok(WordOpenMode::None),
-            }
+            };
        }
        Ok(WordOpenMode::None)
    }
@@ -89,7 +89,7 @@ impl ToSql for WordOpenMode {
            WordOpenMode::Easy => 3,
            WordOpenMode::Ok => 2,
            WordOpenMode::Hard => 1,
-            WordOpenMode::None => 0
+            WordOpenMode::None => 0,
        }))
    }
 }
@@ -1,10 +1,11 @@
 use std::collections::BTreeMap;
 use crate::helpers::into_result;
 use crate::notification::NotificationData;
 use crate::notification::NotificationData::IncorrectAnkiFile;
 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>);
@@ -25,7 +26,18 @@ pub struct ImportNote {
    pub fields: Vec<String>,
 }
-pub fn load_groups(connection: &Connection) -> Result<ImportData, NotificationData> {
+pub fn load_groups(connection: &Connection, schema: AnkiSchema) -> Result<ImportData, NotificationData> {
    match schema {
        AnkiSchema::Old => {
            load_old_schema(connection)
        }
        AnkiSchema::Beta => {
            load_new_schema(connection)
        }
    }
 }
 fn load_old_schema(connection: &Connection) -> Result<ImportData, NotificationData> {
    let json_models: String = connection
        .query_one("select models from col", (), |row| row.get(0))
        .map_err(|_| IncorrectAnkiFile)?;
@@ -82,7 +94,9 @@ pub fn load_groups(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,
@@ -67,7 +67,11 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
        let time = Instant::now();
        let index: u32 = connection
-            .query_row(format!("{} RETURNING {}", Q::add(), Q::id_field()).as_str(), Q::insert_params(entity), |row| row.get(0))
+            .query_row(
                format!("{} RETURNING {}", Q::add(), Q::id_field()).as_str(),
                Q::insert_params(entity),
                |row| row.get(0),
            )
            .map_err(|e| {
                error!("{}", e);
                DbSaveError
@@ -103,9 +107,7 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
        let mut stmt = connection
            .prepare(Q::load())
            .expect("Failed to prepare state query");
-        let iter = stmt
+        let iter = stmt.query_map([], |row| Q::from_sql(row)).map_err(|e| {
            .query_map([], |row| Ok(Q::from_sql(row)?))
            .map_err(|e| {
            error!("{}", e);
            DbSaveError
        })?;
@@ -1,7 +1,7 @@
 use crate::fs::*;
 use log::error;
 use rusqlite::Connection;
 use std::ops::{Deref, DerefMut};
 use log::error;
 pub fn create_db() {
    let db_file = db_path();
@@ -64,6 +64,7 @@ fn make_history(conn: &Connection) -> Result<(), rusqlite::Error> {
 fn make_custom_fields(conn: &Connection) -> Result<(), rusqlite::Error> {
    let query = include_str!("../../sql/custom_fields.sql");
    conn.execute(query, ())?;
    conn.execute("insert into custom_fields (name, identifier) values (\"Чтение\", \"reading\"), (\"Описание\", \"description\"), (\"Пример использования\", \"context\")", ())?;
    Ok(())
 }
@@ -130,6 +131,7 @@ impl SqliteConnection {
 }
 impl Drop for SqliteConnection {
-
+    fn drop(&mut self) {
-fn drop(&mut self) { self.finish(); }
+        self.finish();
    }
 }
@@ -1,9 +1,9 @@
-use crate::data::entities::{WordData, WordGroup};
+use crate::data::entities::WordData;
 use crate::data::repositories::{DataRepository, DataRepositoryInner};
 use crate::data::Id;
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
-use crate::notification::NotificationData::{DbLoadError, DbSaveError};
+use litemap::LiteMap;
-use crate::notification::{MaybeError, NotificationData};
+use rusqlite::{Error, Params, Row};
 use rusqlite::{Connection, Error, Params, Row, params};
 pub type WordRepository = DataRepository<WordData, WordDataLayer>;
 pub type WordRepositoryInner = DataRepositoryInner<WordData, WordDataLayer>;
@@ -34,7 +34,7 @@ impl TableAccessQuerySet<WordData> for WordQuerySet {
            key: row.get(1)?,
            value: row.get(2)?,
            tags: row.get(3)?,
-            additional: serde_json::from_str(&additional).unwrap_or_default(),
+            additional: additional_from_string(additional),
            group_id: row.get(5)?,
        })
    }
@@ -44,7 +44,7 @@ impl TableAccessQuerySet<WordData> for WordQuerySet {
            &entity.key,
            &entity.value,
            &entity.tags,
-            serde_json::to_string(&entity.additional).unwrap_or_default(),
+            additional_to_string(&entity.additional),
            entity.group_id,
        )
    }
@@ -54,175 +54,42 @@ impl TableAccessQuerySet<WordData> for WordQuerySet {
            &entity.key,
            &entity.value,
            &entity.tags,
-            serde_json::to_string(&entity.additional).unwrap_or_default(),
+            additional_to_string(&entity.additional),
            entity.id,
        )
    }
 }
-pub fn add_word(word: &mut WordData, connection: &Connection) -> MaybeError {
+fn additional_to_string(map: &LiteMap<Id, String>) -> String {
-    let index : u32 = connection
+    let mut parts = Vec::with_capacity(map.len() * 2);
-        .query_row(
+    for (id, value) in map {
-            "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5)",
+        parts.push(id.to_string());
-            (
+        parts.push(value.clone());
-                &word.key,
+    }
-                &word.value,
+    parts.join("")
                &word.tags,
                serde_json::to_string(&word.additional).unwrap_or_default(),
                &word.group_id,
            ),
            |row| row.get(0),
        ).map_err(|_| DbSaveError)?;
    word.id = index.into();
    Ok(())
 }
-pub fn add_words(words: &mut [WordData], connection: &mut Connection) -> MaybeError {
+fn additional_from_string_temp(data: String) -> LiteMap<Id, String> {
    let tx = connection.transaction().map_err(|_| DbLoadError)?;
    let count = words.len();
-    {
+    let pre_map : LiteMap<String, String> = serde_json::from_str(data.as_str()).unwrap();
-        let mut stmt = tx
+    LiteMap::from(pre_map.iter().map(|(k, v)| (match k.as_str() {
-            .prepare(
+        "reading" => Id(1),
-                "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5)",
+        "description" => Id(2),
-            )
+        "context" => Id(3),
-            .expect("Failed to prepare statement");
+        &_ => Id(0) }, v.to_string())).collect())
        for word in words.iter() {
            stmt.execute(params![
                word.key,
                word.value,
                word.tags,
                serde_json::to_string(&word.additional).unwrap_or_default(),
                word.group_id
            ])
            .map_err(|_| DbSaveError)?;
        }
 }
-    let last_index: u32 = tx.last_insert_rowid() as u32;
+fn additional_from_string(data: String) -> LiteMap<Id, String> {
-    tx.commit().map_err(|_| DbSaveError)?;
+    if data.is_empty() {
-
+        return LiteMap::new()
    let start_index = last_index - (count as u32) + 1;
    for (index, id) in (start_index..=last_index).enumerate() {
        words[index].id = id.into();
    }
-
+    let parts = data.split('').collect::<Vec<&str>>();
-    Ok(())
+    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 value: String = part[1].to_string();
        map.insert(id, value);
    }
-
+    map
 pub fn update_word(word: &mut WordData, connection: &Connection) -> MaybeError {
    if !word.id.is_valid() {
        Ok(add_word(word, connection)?)
    } else {
        connection
            .execute(
                "UPDATE words SET key = ?1, value = ?2, tags = ?3, more = ?4 WHERE id = ?5",
                (
                    &word.key,
                    &word.value,
                    &word.tags,
                    serde_json::to_string(&word.additional).map_err(|_| DbSaveError)?,
                    &word.id,
                ),
            )
            .map_err(|_| DbSaveError)?;
        Ok(())
    }
 }
 pub fn delete_word(word: &WordData, connection: &Connection) -> MaybeError {
    if !word.id.is_valid() {
        return Err(DbSaveError);
    }
    connection
        .execute("DELETE FROM words WHERE id = ?1", (&word.id,))
        .map_err(|_| DbSaveError)?;
    Ok(())
 }
 pub fn load_words(connection: &Connection) -> Result<Vec<WordData>, NotificationData> {
    let mut stmt = connection
        .prepare("SELECT id, key, value, tags, more, group_id FROM words")
        .expect("Failed to prepare statement");
    let word_iter = stmt
        .query_map([], |row| {
            let additional: String = row.get(4)?;
            Ok(WordData {
                id: row.get(0)?,
                key: row.get(1)?,
                value: row.get(2)?,
                tags: row.get(3)?,
                additional: serde_json::from_str(&additional).unwrap_or_default(),
                group_id: row.get(5)?,
            })
        })
        .map_err(|_| DbLoadError)?;
    let mut buffer = Vec::with_capacity(1024);
    word_iter
        .filter_map(|res| res.ok())
        .for_each(|i| buffer.push(i));
    Ok(buffer)
 }
 pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, NotificationData> {
    let mut stmt = connection
        .prepare("SELECT id, name FROM word_groups")
        .expect("Failed to prepare statement");
    let group_iter = stmt
        .query_map([], |row| {
            Ok(WordGroup {
                id: row.get(0)?,
                name: row.get(1)?,
            })
        })
        .map_err(|_| DbLoadError)?;
    let mut buffer = Vec::with_capacity(8);
    group_iter
        .filter_map(|res| res.ok())
        .for_each(|i| buffer.push(i));
    Ok(buffer)
 }
 pub fn add_group(group: &mut WordGroup, connection: &Connection) -> MaybeError {
    let index: u32 = connection
        .query_row(
            "INSERT INTO word_groups (name) VALUES (?1)",
            (&group.name,),
            |row| row.get(0),
        )
        .map_err(|_| DbSaveError)?;
    group.id = index.into();
    Ok(())
 }
 pub fn update_group(group: &mut WordGroup, connection: &Connection) -> MaybeError {
    if !group.id.is_valid() {
        Ok(add_group(group, connection)?)
    } else {
        connection
            .execute(
                "UPDATE word_groups SET name = ?1 WHERE id = ?2",
                (&group.name, &group.id),
            )
            .map_err(|_| DbSaveError)?;
        Ok(())
    }
 }
 pub fn delete_group(group: &WordGroup, connection: &Connection) -> MaybeError {
    if !group.id.is_valid() {
        return Err(DbSaveError);
    }
    connection
        .execute("DELETE FROM word_groups WHERE id = ?1", (&group.id,))
        .map_err(|_| DbSaveError)?;
    Ok(())
 }
@@ -28,14 +28,6 @@ pub fn db_meta_path() -> PathBuf {
    app_data_dir().join("data.meta")
 }
 pub fn history_dir() -> Result<PathBuf, NotificationData> {
    let directory = app_data_dir().join("history");
    if !directory.exists() {
        fs::create_dir_all(directory.clone()).map_err(|_| PermissionDenied)?;
    }
    Ok(directory)
 }
 pub fn voice_dir() -> Result<PathBuf, NotificationData> {
    let directory = app_data_dir().join("voice");
    if !directory.exists() {
@@ -10,6 +10,7 @@ pub mod notification;
 mod pages;
 mod styling;
 pub mod tests;
 pub mod widgets;
 use crate::app::start;
 use mimalloc::MiMalloc;
@@ -1,5 +1,5 @@
-use crate::app::{fill_state, AppState};
+use crate::app::{AppState, fill_state};
-use crate::data_provider::sqlite::{create_db};
+use crate::data_provider::sqlite::create_db;
 use crate::data_provider::web_api::{
    get_local_version, get_web_version, load_data, set_local_version,
 };
@@ -21,7 +21,6 @@ use crate::pages::repetition_settings::{RepetitionSettingsMessage, RepetitionSet
 use crate::pages::repetitions::{RepetitionsMessage, RepetitionsState};
 use crate::pages::selector::{SelectorMessage, SelectorState};
 use crate::pages::sync::{SyncMessage, SyncState};
 use crate::pages::word::{WordMessage, WordState};
 use crate::pages::writing::{WritingMessage, WritingState};
 use crate::state_navigate_handle;
 use crate::state_update;
@@ -56,7 +55,6 @@ pub enum RootMessage {
    Randomizer(RandomizerMessage),
    Repetitions(RepetitionsMessage),
    Repetition(RepetitionMessage),
    Word(WordMessage),
    Sync(SyncMessage),
    History(HistoryMessage),
    RepetitionSettings(RepetitionSettingsMessage),
@@ -78,7 +76,6 @@ pub enum Page {
    Randomizer(RandomizerState),
    Repetitions(RepetitionsState),
    Repetition(RepetitionState),
    Word(WordState),
    Sync(SyncState),
    History(HistoryState),
    RepetitionSettings(RepetitionSettingsState),
@@ -182,7 +179,6 @@ impl ScreenState {
                Randomizer,
                Repetitions,
                Repetition,
                Word,
                Sync,
                History,
                RepetitionSettings,
@@ -206,7 +202,6 @@ impl ScreenState {
            Randomizer,
            Repetitions,
            Repetition,
            Word,
            Sync,
            History,
            RepetitionSettings,
@@ -227,7 +222,6 @@ impl ScreenState {
            Randomizer,
            Repetitions,
            Repetition,
            Word,
            Sync,
            History,
            RepetitionSettings,
@@ -244,6 +238,7 @@ impl ScreenState {
        if let Some(page) = self.stack.last_mut() {
            return match page {
                Repetition(page) => page.press(&message),
                Dictionary(page) => page.press(&message),
                _ => Task::none(),
            };
        }
@@ -1,29 +1,38 @@
 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;
-use crate::navigation::Page::{Import, Word};
+use crate::navigation::Page::Import;
-use crate::navigation::{NavigatedPage, Page, RootMessage};
+use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
 use crate::pages::dictionary::BasicWordFields::*;
 use crate::pages::dictionary::DictionaryMessage::*;
 use crate::pages::dictionary::SelectionChangeDirection::*;
 use crate::pages::dictionary_quiz::DictionaryQuizState;
 use crate::pages::import::ImportState;
-use crate::pages::word::WordState;
+use crate::pages::word::{WordEditor, WordMessage};
 use crate::push_error;
 use crate::push_error_task;
 use crate::styling::*;
 use crate::widgets::hard_mouse_area::hard_mouse_area;
 use crate::{jl_button, push_error};
 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::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::{Border, Color, Shadow, Task};
-use iced_core::Length::Fill;
+use iced_core::keyboard;
 use iced_core::keyboard::key::Physical::Code;
 use iced_core::keyboard::{Event, Modifiers};
 use iced_core::keyboard::Key::Named;
 use iced_core::Length::{Fill, FillPortion};
 use log::info;
 use rand::random_range;
 use std::ops::Add;
@@ -43,15 +52,15 @@ pub struct DictionaryState {
    auto_save_queue: HashMap<EntityHandle<WordData>, DateTime<Utc>>,
    displayed_words_query: Query<WordData, WordRepositoryInner, WordDataLayer>,
    groups_query: Query<WordGroup, WordGroupRepositoryInner, WordGroupDataLayer>,
    selected_cell: Option<(EntityHandle<WordData>, BasicWordFields, usize)>,
    word_editor: Option<WordEditor<DictionaryMessage>>,
 }
 #[derive(Clone)]
 pub enum DictionaryMessage {
    Back,
-    SetTags(EntityHandle<WordData>, String),
+    ExtendedEdit(EntityHandle<WordData>),
-    SetKey(EntityHandle<WordData>, String),
+    DeleteWord(EntityHandle<WordData>),
    SetValue(EntityHandle<WordData>, String),
    WordAction(EntityHandle<WordData>),
    NewWord,
    Include(EntityHandle<WordData>, bool),
    IncludeTag(String, bool),
@@ -68,8 +77,30 @@ pub enum DictionaryMessage {
    ChangeDirection,
    TrySave(EntityHandle<WordData>),
    GotoImport,
    SelectField(EntityHandle<WordData>, BasicWordFields, usize),
    EditField(String),
    ChangeSelectedField(SelectionChangeDirection),
    EditorAction(WordMessage),
    ExtendedWordEdited
 }
 #[derive(Clone, PartialEq, Eq, Hash, Copy)]
 pub enum SelectionChangeDirection {
    Next,
    Previous,
    Forward,
    Backward,
 }
 #[derive(Clone, PartialEq, Eq, Hash, Copy)]
 pub enum BasicWordFields {
    Key,
    Value,
    Tags,
 }
 const FIELDS: &[BasicWordFields] = &[Key, Value, Tags];
 impl NavigatedPage<DictionaryMessage> for DictionaryState {
    fn navigate(&mut self, message: &DictionaryMessage) -> Option<Page> {
        if let Back = message {
@@ -81,7 +112,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
            let mut words = vec![];
            let dict = &self.state.dictionary.read();
-            let mut query = dict.query(Arc::new(|_| true));
+            let query = dict.query(Arc::new(|_| true));
            let handles = query.handles();
            words = handles.filter(|h| self.included.contains(h)).collect();
@@ -92,11 +123,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                self.state.clone(),
            )));
        }
-        if let WordAction(handle) = message
+
            && handle.real()
        {
            return Some(Word(WordState::new(*handle, self.state.clone())));
        }
        if let GotoImport = message {
            return Some(Import(ImportState::new(self.state.clone())));
        }
@@ -121,49 +148,11 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                dictionary.create(word);
                self.displayed_words_query.load(&dictionary);
            }
-
+            ExtendedEdit(i) => {
-            SetKey(handle, v) => {
+                self.word_editor = Some(self.editor_for_word(i));
-                let mut dictionary = self.state.dictionary.write();
+                if let Some((handle, cell, index)) = self.selected_cell.clone() {
-                dictionary.get_mut_static(handle).unwrap().key = v;
+                    self.selected_cell = Some((i, cell, index))
                drop(dictionary);
                return self.launch_auto_save_offset(handle);
                }
            SetValue(handle, v) => {
                let mut dictionary = self.state.dictionary.write();
                dictionary.get_mut_static(handle).unwrap().value = v;
                drop(dictionary);
                return self.launch_auto_save_offset(handle);
            }
            SetTags(i, mut v) => {
                {
                    let mut dictionary = self.state.dictionary.write();
                    let word = dictionary.get_mut_static(i).unwrap();
                    let current_tags_value = word.tags.clone();
                    if v.ends_with(", ") && v.len() < current_tags_value.len() {
                        v = v[..v.len() - 2].to_string()
                    }
                    while let Some(index) = v.find(",,") {
                        v.remove(index);
                    }
                    word.tags = v;
                }
                self.update_tags();
                return self.launch_auto_save_offset(i);
            }
            WordAction(i) => {
                let mut dictionary = self.state.dictionary.write();
                if let Err(err) = dictionary.delete(i) {
                    return push_error_task!(err);
                }
                self.displayed_words_query.load(&dictionary);
            }
            Include(i, b) => {
                if b {
@@ -241,31 +230,145 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                    }
                    self.groups_query.load(&groups);
                }
-
+                self.selected_cell = None;
                self.word_editor = None;
                self.update_tags()
            }
            ChangeDirection => {
                self.reverse_list = !self.reverse_list;
            }
            TrySave(mut handle) => {
                let original = handle;
                let now = Utc::now();
                if !self.auto_save_queue.contains_key(&handle) {
                    return Task::none();
                }
                if self.auto_save_queue[&handle] <= now {
                    self.update_tags();
                    self.auto_save_queue.remove(&handle);
                    let mut dictionary = self.state.dictionary.write();
-                    let reload_query = handle.real() == false;
+                    let reload_query = !handle.real();
                    let _ = dictionary.save(&mut handle);
                    if reload_query {
                        self.displayed_words_query.load(&dictionary);
                        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));
                            }
                        }
                    }
                    info!("Saved word");
                    return Task::none();
                }
            }
            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 {
                    self.word_editor = Some(self.editor_for_word(e));
                }
                self.selected_cell = Some((e, f, index));
                return focus(iced::widget::Id::new("editor"));
            }
            EditField(value) => {
                if let Some(selected) = self.selected_cell.as_ref() {
                    {
                        let mut dictionary = self.state.dictionary.write();
                        let word = dictionary.get_mut_static(selected.0).unwrap();
                        match selected.1 {
                            Key => {
                                word.key = value;
                            }
                            Value => {
                                word.value = value;
                            }
                            Tags => {
                                word.tags = value;
                            }
                        }
                    }
                    return self.launch_auto_save_offset(selected.0);
                }
            }
            ChangeSelectedField(change) => {
                return if let Some(selected) = self.selected_cell {
                    let update_vertical = move |mut dir: bool| {
                        if self.reverse_list {
                            dir = !dir;
                        }
                        let new_index = if dir {
                            selected.2.saturating_add(1)
                        } else {
                            selected.2.saturating_sub(1)
                        };
                        if new_index < self.displayed_words_query.len() {
                            return SelectField(
                                self.displayed_words_query.get(new_index).unwrap(),
                                selected.1,
                                new_index,
                            );
                        }
                        SelectField(selected.0, selected.1, selected.2)
                    };
                    let update_horizontal = move |dir: bool| {
                        let current = selected.1;
                        let delta = if dir { 1 } else { -1 };
                        let mut index =
                            FIELDS.iter().position(|&f| f == current).unwrap() as i8 + delta;
                        if index < 0 {
                            index = (FIELDS.len() - 1) as i8;
                        }
                        if index >= FIELDS.len() as i8 {
                            index = 0;
                        }
                        SelectField(selected.0, FIELDS[index as usize], selected.2)
                    };
                    Task::done(RootMessage::Dictionary(match change {
                        Next => update_vertical(true),
                        Previous => update_vertical(false),
                        Forward => update_horizontal(true),
                        Backward => update_horizontal(false),
                    }))
                } else {
                    Task::none()
                };
            }
            DeleteWord(i) => {
                let mut dictionary = self.state.dictionary.write();
                if let Err(err) = dictionary.delete(i) {
                    return push_error_task!(err);
                }
                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(_) |
                            ExtendedWordEdited => {
                            return Task::done(RootMessage::Dictionary(result));
                        },
                        _ => {}
                    }
                }
            }
            ExtendedWordEdited => {
                return self.launch_auto_save_offset(self.selected_cell.unwrap().0);
            }
        }
        Task::none()
@@ -277,14 +380,15 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                iced::widget::column![
                    self.groups_panel(),
                    row![horizontal().width(8), self.words_list(),],
                    self.selection_editor(),
                    row![
                        self.add_word_button(),
                        horizontal().width(Fill),
                        button("Импорт").style(text).on_press(GotoImport),
                    ]
                ]
-                .spacing(5),
+                .spacing(5).width(FillPortion(4)),
-                self.filters(),
+                self.right_panel(),
            ]
            .spacing(DEFAULT_SPACING)
            .into(),
@@ -310,6 +414,8 @@ impl DictionaryState {
            auto_save_queue: HashMap::new(),
            displayed_words_query: words_query,
            groups_query,
            selected_cell: None,
            word_editor: None,
        };
        result.init();
@@ -318,6 +424,10 @@ impl DictionaryState {
        result
    }
    fn editor_for_word(&self, handle: EntityHandle<WordData>) -> WordEditor<DictionaryMessage> {
        WordEditor::new(handle, self.state.clone()).on_delete(DeleteWord(handle)).on_edit(ExtendedWordEdited)
    }
    fn init(&mut self) {
        self.displayed_words_query = self
            .state
@@ -336,11 +446,11 @@ impl DictionaryState {
    }
    fn launch_auto_save_offset(&mut self, handle: EntityHandle<WordData>) -> Task<RootMessage> {
-        let save_time = Utc::now().add(TimeDelta::milliseconds(900));
+        let save_time = Utc::now().add(TimeDelta::milliseconds(500));
        self.auto_save_queue.insert(handle, save_time);
        let message = RootMessage::Dictionary(TrySave(handle));
        Task::perform(
-            async { tokio::time::sleep(Duration::from_secs(1)).await },
+            async { tokio::time::sleep(Duration::from_millis(520)).await },
            |_| message,
        )
    }
@@ -368,12 +478,22 @@ impl DictionaryState {
                continue;
            }
            let mut selection = None;
            if let Some(cell) = self.selected_cell.as_ref()
                && cell.0 == *word_handle
            {
                selection = Some(cell.1);
            }
            let word_line_data = WordLineState {
                is_included: self.included.contains(word_handle),
                key: word.key.clone().into(),
                value: word.value.clone().into(),
                tags: word.tags.clone().into(),
-                handle: word_handle.clone(),
+                handle: *word_handle,
                selection,
                number: i,
            };
            let lazy_line = lazy(word_line_data, Self::word_line);
@@ -387,7 +507,7 @@ impl DictionaryState {
    fn word_line<'a>(data: &WordLineState) -> Row<'a, DictionaryMessage> {
        let mut line = Row::new().width(Fill).align_y(Center);
-        let handle = data.handle.clone();
+        let handle = data.handle;
        line = line.push(
            checkbox(data.is_included)
                .label("")
@@ -395,65 +515,77 @@ impl DictionaryState {
                .on_toggle(move |b| Include(handle, b)),
        );
-        line = line.push(
+        let field = |placeholder: &str, data: &str, selected: bool| {
-            text_input("Слово", &data.key)
+            text_input(placeholder, data)
                .size(ACCENT_FONT_SIZE)
                .width(Fill)
-                .on_input(move |string| SetKey(handle, string))
+                .style(move |x, _| {
-                .style(|x, status| {
+                    let mut default_style = default(x, Active);
                    let mut default_style = default(x, status);
                    default_style.border.radius = 0.0.into();
                    if selected {
                        default_style.border.color = x.extended_palette().secondary.base.color;
                        default_style.border.width = 3.0_f32;
                    }
                    default_style
-                }),
+                })
        };
        line = line.push(
            hard_mouse_area(field(
                "Слово",
                &data.key,
                data.selection.is_some() && data.selection.unwrap() == Key,
            ))
            .on_press(SelectField(data.handle, Key, data.number)),
        );
        line = line.push(
-            text_input("Перевод", &data.value)
+            hard_mouse_area(field(
-                .size(ACCENT_FONT_SIZE)
+                "Перевод",
-                .width(Fill)
+                &data.value,
-                .on_input(move |string| SetValue(handle, string))
+                data.selection.is_some() && data.selection.unwrap() == Value,
-                .style(|x, status| {
+            ))
-                    let mut default_style = default(x, status);
+            .on_press(SelectField(data.handle, Value, data.number)),
                    default_style.border.radius = 0.0.into();
                    default_style
                }),
        );
        line = line.push(
-            text_input("Теги", data.tags.as_ref())
+            hard_mouse_area(field(
-                .size(ACCENT_FONT_SIZE)
+                "Теги",
-                .width(Fill)
+                &data.tags,
-                .on_input(move |string| SetTags(handle, string))
+                data.selection.is_some() && data.selection.unwrap() == Tags,
-                .style(|x, status| {
+            ))
-                    let mut default_style = default(x, status);
+            .on_press(SelectField(data.handle, Tags, data.number)),
                    default_style.border.radius = 0.0.into();
                    default_style
                }),
        );
        let line_button = || {
            if !data.handle.real() {
                return button("-")
-                    .on_press(WordAction(data.handle))
+                    .on_press(DeleteWord(data.handle))
-                    .style(
+                    .style(|_x: &Theme, _status: button::Status| Style {
                        |_x: &iced::Theme, _status: iced::widget::button::Status| Style {
                        background: None,
                        text_color: Color::BLACK,
                        border: Border::default(),
                        shadow: Shadow::default(),
                        snap: false,
-                        },
+                    })
                    )
                    .width(15);
            }
            button("")
-                .on_press(WordAction(data.handle))
+                .on_press(ExtendedEdit(data.handle))
                .style(button::primary)
                .width(15)
        };
        line.push(line_button()).push(space().width(10))
    }
    fn right_panel(&self) -> iced::Element<'_, DictionaryMessage> {
        if let Some(editor) = &self.word_editor {
            container(editor.view().map(EditorAction)).width(FillPortion(3)).into()
        } else {
            self.filters()
        }
    }
    fn filters(&self) -> iced::Element<'_, DictionaryMessage> {
        let dict = &self.state.dictionary.read();
@@ -475,7 +607,7 @@ impl DictionaryState {
                .on_press(GotoTest)
                .width(Fill),
        ]
-        .width(250)
+        .width(FillPortion(1))
        .spacing(DEFAULT_SPACING)
        .into()
    }
@@ -512,14 +644,15 @@ impl DictionaryState {
        let dict = &self.state.dictionary.write();
        let mut words_query = dict.full_query();
        let handles = words_query.handles().collect::<Vec<_>>();
-        words_query.iter(dict).zip(handles).for_each(|(element, handle)| {
+        words_query
            .iter(dict)
            .zip(handles)
            .for_each(|(element, handle)| {
                let tags = split_with_coma(element.tags.as_str());
-                tags.iter()
+                tags.iter().for_each(|tag| {
                .for_each(|tag| {
                    tags_list.insert(tag.clone());
                });
                self.words_tags.push((handle, tags))
            });
        let current_tags = self
@@ -574,6 +707,31 @@ impl DictionaryState {
        info!("Time {}", time.elapsed().as_micros());
    }
    fn selection_editor(&self) -> iced::Element<'_, DictionaryMessage> {
        let mut display = "".to_string();
        if let Some(selected) = self.selected_cell.as_ref() {
            let mut dictionary = self.state.dictionary.write();
            let word = dictionary.get_mut_static(selected.0).unwrap();
            match selected.1 {
                Key => {
                    display = word.key.clone();
                }
                Value => {
                    display = word.value.clone();
                }
                Tags => {
                    display = word.tags.clone();
                }
            }
        }
        text_input("", display.as_str())
            .width(Fill)
            .id(iced::widget::Id::new("editor"))
            .on_input(EditField)
            .into()
    }
    fn groups_panel(&self) -> iced::Element<'_, DictionaryMessage> {
        let mut row = Row::new();
        row = row.push(button("+").style(text).on_press(CreateGroup));
@@ -590,12 +748,12 @@ impl DictionaryState {
        }
        let groups = self.state.word_groups.read();
-        let group = groups.get_static(self.selected_group.clone()).unwrap();
+        let group = groups.get_static(self.selected_group).unwrap();
        iced::widget::column![
            scrollable(row).width(Fill).horizontal(),
            row![
-                button("⇳").on_press(ChangeDirection).style(jl_button),
+                jl_button!("⇳").on_press(ChangeDirection),
                text_input("Название группы слов", &group.name)
                    .on_input(EditGroup)
                    .width(250)
@@ -617,7 +775,7 @@ impl DictionaryState {
    }
    fn add_word_button(&self) -> iced::Element<'_, DictionaryMessage> {
-        let button = button("Добавить слово").style(jl_button);
+        let button = jl_button!("Добавить слово");
        if self.selected_group.real() {
            return button.on_press(NewWord).into();
@@ -627,6 +785,52 @@ impl DictionaryState {
    }
 }
 impl KeyPressedPage for DictionaryState {
    fn press(&mut self, message: &Event) -> Task<RootMessage> {
        if let Event::KeyPressed {
            key: _,
            modified_key: modifier,
            physical_key: pk,
            location: _,
            modifiers: mods,
            text: _,
            repeat: _,
        } = message
            && let Code(code) = pk
        {
            return match code {
                keyboard::key::Code::ArrowDown => {
                    Task::done(RootMessage::Dictionary(ChangeSelectedField(Next)))
                }
                keyboard::key::Code::ArrowUp => {
                    Task::done(RootMessage::Dictionary(ChangeSelectedField(Previous)))
                }
                keyboard::key::Code::Tab => {
                    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() {
                        self.selected_cell = None;
                    }
                    Task::none()
                }
                _ => Task::none(),
            };
        }
        Task::none()
    }
 }
 pub fn split_with_coma(ts: &str) -> Vec<String> {
    ts.split(',')
        .map(|ts| ts.to_lowercase().trim().to_string())
@@ -637,8 +841,10 @@ pub fn split_with_coma(ts: &str) -> Vec<String> {
 #[derive(Clone, Hash, PartialEq, Eq)]
 struct WordLineState {
    is_included: bool,
-    key: Box<str>,
+    key: String,
-    value: Box<str>,
+    value: String,
-    tags: Box<str>,
+    tags: String,
    handle: EntityHandle<WordData>,
    selection: Option<BasicWordFields>,
    number: usize,
 }
@@ -1,4 +1,7 @@
 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 +12,9 @@ use crate::styling::*;
 use iced::Background::Color;
 use iced::border::Radius;
 use iced::widget::container::Style;
-use iced::widget::{Row, button, container, row, space, text, text_input};
+use iced::widget::{Row, container, row, space, text, text_input};
 use iced::{Border, Element, Fill, Task, Theme, alignment};
 use rand::prelude::SliceRandom;
 use crate::app::AppState;
 use crate::data::repositories::Repository;
 pub struct DictionaryQuizState {
    state: AppState,
@@ -90,10 +91,7 @@ impl NavigatedPage<DictionaryQuizMessage> for DictionaryQuizState {
                        .size(25),
                ]
                .spacing(DEFAULT_SPACING),
-                row![
+                row![jl_button!("Закончить").on_press(Back), self.appeal_button()]
                    button("Закончить").style(jl_button).on_press(Back),
                    self.appeal_button()
                ]
                    .spacing(DEFAULT_SPACING),
            ]
            .spacing(DEFAULT_SPACING)
@@ -106,8 +104,13 @@ impl NavigatedPage<DictionaryQuizMessage> for DictionaryQuizState {
 }
 impl DictionaryQuizState {
-    pub fn new(words: Vec<EntityHandle<WordData>>, reverse: bool, no_typing: bool, state: AppState) -> DictionaryQuizState {
+    pub fn new(
-        let state = DictionaryQuizState {
+        words: Vec<EntityHandle<WordData>>,
        reverse: bool,
        no_typing: bool,
        state: AppState,
    ) -> DictionaryQuizState {
        Self {
            state,
            words,
            current_set: Vec::new(),
@@ -119,9 +122,7 @@ impl DictionaryQuizState {
            reverse,
            laps: 0,
            no_typing,
-        };
+        }
        state
    }
    fn submit(&mut self) {
@@ -218,7 +219,7 @@ impl DictionaryQuizState {
    fn appeal_button(&self) -> Element<'_, DictionaryQuizMessage> {
        if self.is_help && !self.no_typing {
-            return button("Апелляция").style(jl_button).on_press(Appeal).into();
+            return jl_button!("Апелляция").on_press(Appeal).into();
        }
        space().into()
    }
@@ -3,18 +3,16 @@ use crate::data::entities::{HistoryNote, WordData};
 use crate::data::repositories::Repository;
 use crate::navigation::*;
 use crate::styling::*;
 use HistoryMessage::Back;
 use chrono::Local;
 use iced::alignment::Horizontal::Center;
 use iced::widget::space::horizontal;
 use iced::widget::*;
 use iced::{Element, Fill, FillPortion, Task};
 use std::sync::Arc;
 use HistoryMessage::Back;
 #[derive(Clone)]
 pub struct HistoryState {
    list: Vec<(WordData, HistoryNote)>,
    pub state: AppState,
 }
 impl NavigatedPage<HistoryMessage> for HistoryState {
@@ -50,12 +48,11 @@ impl HistoryState {
        let dict = &state.dictionary.read();
        let history_repo = &mut state.history.write();
        history_repo.init().expect("TODO: panic message");
        let id = id.clone();
        let mut history = history_repo.query(Arc::new(move |h| h.deck_id == id));
        let words = history
            .iter(history_repo)
-            .map(
+            .map(|item| {
-                |item| {let handle = dict.handle_by_id(item.word_id);
+                let handle = dict.handle_by_id(item.word_id);
                let word = dict.get_static(handle).unwrap_or(WordData {
                    id: Default::default(),
                    group_id: Default::default(),
@@ -65,36 +62,30 @@ impl HistoryState {
                    additional: Default::default(),
                });
                (word, item.clone())
-                }
+            })
            )
            .collect();
-        Self {
+        Self { list: words }
            list: words,
            state: state.clone(),
        }
    }
    fn history_lines(&self) -> Column<'_, HistoryMessage> {
        let mut column = Column::new();
        for (index, item) in &self.list {
            let activity = item;
            column = column.push(
                row![
                    iced::widget::column![
-                        text!("{}", index.key)
+                        text!("{}", index.key).width(Fill).align_x(Center),
-                            .width(Fill)
+                        text!("{}", index.value).width(Fill).align_x(Center),
                            .align_x(Center),
                        text!("{}", index.value)
                            .width(Fill)
                            .align_x(Center),
                    ]
                    .align_x(Center),
                    iced::widget::column![
                        text!("{} ➞ {}", activity.before, activity.after),
                        text!(
                            "{}",
-                            activity.timestamp.with_timezone(&Local).format("%d.%m %H:%M")
+                            activity
                                .timestamp
                                .with_timezone(&Local)
                                .format("%d.%m %H:%M")
                        )
                    ]
                    .spacing(5)
@@ -1,15 +1,17 @@
 use crate::app::AppState;
-use crate::data::entities::EntityData;
+use crate::data::Id;
 use crate::data::entities::WordData;
 use crate::data::entities::WordGroup;
 use crate::data::entities::{CustomField, WordData};
 use crate::data::repositories::{BatchedRepository, Repository};
 use crate::data_provider::import::{ImportData, ImportGroup, get_words_of_group, load_groups};
 use crate::fs::*;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
-use crate::notification::NotificationData::OpenFileError;
+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 iced::widget::button::danger;
 use iced::widget::container::success;
 use iced::widget::{
@@ -24,17 +26,17 @@ use log::info;
 use parking_lot::Mutex;
 use rfd::AsyncFileDialog;
 use rusqlite::Connection;
 use std::collections::HashMap;
 use std::fs::{File, OpenOptions};
 use std::io::BufReader;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::task::spawn_blocking;
 use zip::ZipArchive;
-use crate::data::repositories::{BatchedRepository, Repository};
+use zstd::Decoder;
 const DEFAULT_FIELDS: [&str; 6] = ["key", "value", "tags", "reading", "context", "description"];
 #[derive(Clone)]
 pub struct ImportState {
    state: AppState,
    path: Option<PathBuf>,
@@ -155,7 +157,7 @@ impl NavigatedPage<ImportMessage> for ImportState {
                    scrollable(
                        column![
                            row![
-                                button("Выбрать файл").style(jl_button).on_press(SelectFile),
+                                jl_button!("Выбрать файл").on_press(SelectFile),
                                text!("{}", {
                                    if let Some(path) = &self.path {
                                        path.to_string_lossy().to_string()
@@ -361,8 +363,8 @@ impl ImportState {
        Task::perform(
            async {
                spawn_blocking(move || {
-                    Self::extract_import_file(path)?;
+                    let schema = Self::extract_import_file(path)?;
-                    let data = Self::read_import_file()?;
+                    let data = Self::read_import_file(schema)?;
                    Ok(data)
                })
                .await
@@ -375,7 +377,7 @@ impl ImportState {
        )
    }
-    fn extract_import_file(path: PathBuf) -> MaybeError {
+    fn extract_import_file(path: PathBuf) -> Result<AnkiSchema, NotificationData> {
        let file = File::open(path).map_err(|_| OpenFileError)?;
        let reader = BufReader::new(file);
        let mut archive = ZipArchive::new(reader).map_err(|_| OpenFileError)?;
@@ -386,20 +388,24 @@ impl ImportState {
            .truncate(true)
            .open(&temp_file_path)
            .map_err(|_| OpenFileError)?;
-        if let Ok(mut file) = archive.by_name("collection.anki21") {
+        if let Ok(mut file) = archive.by_name("collection.anki21b") {
            let mut decoder = Decoder::new(&mut file).map_err(|_| CompressError)?;
            std::io::copy(&mut decoder, &mut temp_file).map_err(|_| OpenFileError)?;
            Ok(AnkiSchema::Beta)
        } else if let Ok(mut file) = archive.by_name("collection.anki21") {
            std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
-            Ok(())
+            Ok(AnkiSchema::Old)
        } else if let Ok(mut file) = archive.by_name("collection.anki2") {
            std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
-            Ok(())
+            Ok(AnkiSchema::Old)
        } else {
            Err(OpenFileError)
        }
    }
-    fn read_import_file() -> Result<ImportData, NotificationData> {
+    fn read_import_file(schema: AnkiSchema) -> Result<ImportData, NotificationData> {
        let temp_file_path = temp_import_path();
        let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
-        let data = load_groups(&connection)?;
+        let data = load_groups(&connection, schema)?;
        Ok(data)
    }
    fn setup_mapping(&mut self, property_name: String) {
@@ -429,17 +435,29 @@ impl ImportState {
        let separator = self.separator.clone();
        let skip_empty = self.skip_empty;
        let group = self.import_data.as_ref().unwrap().0[self.selected_index].clone();
        let map_indices = Self::get_mapping_indices(&group);
        let progress = self.progress.clone().unwrap();
        if let Err(err) = Self::ensure_fields(&state, &map_indices) {
            return push_error_task!(err);
        }
        let fields: HashMap<String, Id> = HashMap::from_iter(
            state
                .custom_fields
                .read()
                .iter()
                .map(|f| (f.identifier.clone(), f.id)),
        );
        info!("{}", group.name);
        Task::perform(
            async move {
                spawn_blocking(move || {
                    let temp_file_path = temp_import_path();
-                    let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
+                    let connection =
                        Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
                    let import_list = get_words_of_group(&connection, group.id)?;
                    let mut words_list = Vec::with_capacity(import_list.len());
                    let map_indices = Self::get_mapping_indices(&group);
                    let group_handle;
                    {
                        let group_entity = WordGroup {
@@ -474,7 +492,7 @@ impl ImportState {
                                    word.tags = collected_string;
                                }
                                &_ => {
-                                    word.additional.insert((*dest).clone(), collected_string);
+                                    word.additional.insert(fields[dest], collected_string);
                                }
                            }
                        }
@@ -554,4 +572,33 @@ impl ImportState {
            |_| RootMessage::Import(NextProgress),
        )
    }
    fn ensure_fields(
        state: &AppState,
        import_group: &Vec<(String, Vec<usize>)>,
    ) -> Result<(), NotificationData> {
        let mut fields_repo = state.custom_fields.write();
        let mut current_fields: Vec<String> = fields_repo
            .iter()
            .map(|field| field.identifier.clone())
            .collect();
        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;
            }
            fields_repo.create_now(CustomField {
                id: Default::default(),
                name: field.clone(),
                identifier: field.clone(),
            })?;
        }
        Ok(())
    }
 }
 pub enum AnkiSchema {
    Old, Beta
 }
@@ -1,5 +1,6 @@
 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::*;
@@ -8,7 +9,6 @@ use iced::widget::*;
 use iced::{Element, Fill, Task, alignment};
 use rand::seq::SliceRandom;
 #[derive(Clone, Debug)]
 pub struct QuizState {
    kana: String,
    current_roman: String,
@@ -82,7 +82,7 @@ impl NavigatedPage<QuizMessage> for QuizState {
                    .width(150)
                    .on_input(ContentChanged),
                score_display(&self.score),
-                button("Закончить").style(jl_button).on_press(Back),
+                jl_button!("Закончить").on_press(Back),
            ]
            .spacing(DEFAULT_SPACING)
            .align_x(alignment::Horizontal::Center),
@@ -1,12 +1,12 @@
 use crate::jl_button;
 use crate::navigation::RootMessage;
 use crate::navigation::{NavigatedPage, Page};
 use crate::pages::randomizer::RandomizerMessage::{Back, Edit, Start};
-use crate::styling::{HALF_SPACING, back_overlay, jl_button};
+use crate::styling::{HALF_SPACING, back_overlay};
 use iced::Task;
-use iced::widget::{button, text_editor};
+use iced::widget::text_editor;
 use rand::prelude::SliceRandom;
 #[derive(Clone, Debug)]
 pub struct RandomizerState {
    text: text_editor::Content,
    list: Vec<String>,
@@ -56,7 +56,7 @@ impl NavigatedPage<RandomizerMessage> for RandomizerState {
                    .width(400)
                    .height(400)
                    .placeholder("Каждый элемент с новой строки"),
-                button("Перемешать").style(jl_button).on_press(Start),
+                jl_button!("Перемешать").on_press(Start),
            ]
            .spacing(HALF_SPACING)
            .into(),
@@ -5,6 +5,7 @@ use crate::data::Id;
 use crate::data::entities::{CardState, WordData};
 use crate::data::repositories::Repository;
 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};
@@ -255,26 +256,25 @@ impl RepetitionState {
    }
    fn draw_voice(&self) -> Element<'_, RepetitionMessage> {
-        button("Воспроизвести")
+        jl_button!("Воспроизвести")
            .style(jl_button)
            .on_press(RepetitionMessage::Play)
            .into()
    }
    fn draw_reading(&self, word: &WordData) -> Element<'_, RepetitionMessage> {
-        match word.additional.get("reading") {
+        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("context") {
+        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("description") {
+        match word.additional.get(&Id(2)) {
            None => space().into(),
            Some(context) => text!("{}", context).size(24).into(),
        }
@@ -2,6 +2,7 @@ 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;
@@ -122,7 +123,10 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                }
                let mut states = self.state.card_states.write();
                let deck_id = self.settings_handle.id;
-                let mut query = states.query(Arc::new(move |state| {state.deck_id == deck_id})).handles().collect::<Vec<_>>();
+                let mut query = states
                    .query(Arc::new(move |state| state.deck_id == deck_id))
                    .handles()
                    .collect::<Vec<_>>();
                if let Err(e) = states.delete_many(query.as_mut_slice()) {
                    return push_error_task!(e);
                }
@@ -163,9 +167,7 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                                    primary
                                })
                                .on_input(SetFilter),
-                            button("Проверить фильтр")
+                            jl_button!("Проверить фильтр").on_press(TryFilter),
                                .style(jl_button)
                                .on_press(TryFilter),
                            self.count_view(),
                        ]
                        .spacing(QUARTER_SPACING),
@@ -180,7 +182,7 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                )
                .height(Fill),
                row![
-                    button("Сохранить").style(jl_button).on_press(Save),
+                    jl_button!("Сохранить").on_press(Save),
                    horizontal(),
                    button(if self.real_delete_states {
                        "Вы уверены?"
@@ -211,7 +213,7 @@ fn update_deck_stats(deck: &DeckSettings, state: &AppState) -> MaybeError {
    let deck_id = deck.id;
    let mut db_stats = states_repo
        .query_par(Arc::new(move |s| s.deck_id == deck_id))
-        .iter(&states_repo)
+        .iter(states_repo)
        .collect::<Vec<_>>();
    let filtered_words = DeckData::list(deck, state)
        .iter()
@@ -3,6 +3,7 @@ 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;
@@ -30,7 +31,6 @@ use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::sync::Arc;
 #[derive(Clone)]
 pub struct RepetitionsState {
    selected_deck_handle: Option<EntityHandle<DeckSettings>>,
    decks: BTreeMap<EntityHandle<DeckSettings>, DeckRunData>,
@@ -94,7 +94,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                self.clear_selection();
            }
        } else {
-            let _ = self.fill_deck_word_indices();
+            self.fill_deck_word_indices();
        }
    }
    fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
@@ -126,7 +126,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
            DeleteSet => {
                let index = self.selected_deck_handle.unwrap();
                self.clear_selection();
-                let deck = self.decks.remove(&index);
+                self.decks.remove(&index);
                if index.real() {
                    let mut repo = self.state.decks.write();
@@ -152,7 +152,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                let mut repo = self.state.decks.write();
                repo.set(handle, deck.general_settings.clone());
-                let old = handle.clone();
+                let old = *handle;
                if let Err(err) = repo.save(handle) {
                    return push_error_task!(err);
                }
@@ -175,7 +175,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
            }
            TryFilter => {
                let deck = self.selected_deck().unwrap();
-                let count = DeckData::list(&deck, &self.state).len();
+                let count = DeckData::list(deck, &self.state).len();
                let deck = self.selected_deck_mut().unwrap();
                deck.count = Some(count);
            }
@@ -227,10 +227,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
            row![
                column![
                    scrollable(self.decks_list()).height(Fill),
-                    button("Добавить")
+                    jl_button!("Добавить").width(Fill).on_press(CreateSet),
                        .style(jl_button)
                        .width(Fill)
                        .on_press(CreateSet),
                ]
                .spacing(DEFAULT_SPACING)
                .width(Length::FillPortion(1)),
@@ -256,9 +253,7 @@ impl RepetitionsState {
        }
    }
-    fn get_decks_from_state(
+    fn get_decks_from_state(state: &AppState) -> BTreeMap<EntityHandle<DeckSettings>, DeckRunData> {
        state: &AppState,
    ) -> BTreeMap<EntityHandle<DeckSettings>, DeckRunData> {
        state
            .decks
            .read()
@@ -331,9 +326,7 @@ impl RepetitionsState {
                                    column![
                                        text!("Фильтр"),
                                        text_input("", &deck.filter).on_input(SetFilter),
-                                        button("Проверить фильтр")
+                                        jl_button!("Проверить фильтр").on_press(TryFilter),
                                            .style(jl_button)
                                            .on_press(TryFilter),
                                        self.count_view(deck),
                                    ]
                                    .spacing(QUARTER_SPACING),
@@ -361,7 +354,7 @@ impl RepetitionsState {
                                        Some(deck.open_mode),
                                        SetOpenMode
                                    ),
-                                    button("История").style(jl_button).on_press(GoToHistory),
+                                    jl_button!("История").on_press(GoToHistory),
                                ]
                                .spacing(HALF_SPACING)
                            }
@@ -378,7 +371,7 @@ impl RepetitionsState {
                )
                .height(Fill),
                row![
-                    button("Сохранить").style(jl_button).on_press(Save),
+                    jl_button!("Сохранить").on_press(Save),
                    self.launch_delete_button(deck)
                ]
                .spacing(DEFAULT_SPACING)
@@ -520,7 +513,7 @@ impl RepetitionsState {
    fn decks_list(&self) -> Column<'_, RepetitionsMessage> {
        let mut column = Column::new();
-        for (i, (handle, deck)) in self.decks.iter().enumerate() {
+        for (handle, deck) in self.decks.iter() {
            column = column.push(
                button(text!("{}", &deck.name))
                    .on_press_with(move || SelectSet(*handle))
@@ -566,7 +559,6 @@ impl RepetitionsState {
        deck: &DeckSettings,
        indices: impl Iterator<Item = EntityHandle<WordData>>,
    ) -> MaybeError {
        let words = &state.dictionary;
        let stats = &mut indices
            .map(|i| CardState {
                id: 0.into(),
@@ -1,5 +1,6 @@
 use crate::app::AppState;
 use crate::core::kana_set::{KanaSet, KanaType};
 use crate::jl_button;
 use crate::navigation::Page::*;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::pages::dictionary::DictionaryState;
@@ -16,8 +17,6 @@ use iced::{Element, Task, alignment};
 use iced_core::Alignment::Center;
 use iced_core::Background;
 use iced_core::Color;
 use parking_lot::Mutex;
 use std::sync::Arc;
 pub struct SelectorState {
    pub set: KanaSet,
@@ -81,9 +80,7 @@ impl NavigatedPage<SelectorMessage> for SelectorState {
        container(
            iced::widget::column![
                row![
-                    button("あ ↔ ア")
+                    jl_button!("あ ↔ ア").on_press(SelectorMessage::Change),
                        .on_press(SelectorMessage::Change)
                        .style(jl_button),
                    button("Словарь")
                        .on_press(SelectorMessage::ToDictionary)
                        .style(Self::nav_style),
@@ -2,6 +2,7 @@ use crate::app::AppState;
 use crate::data::repositories::Repository;
 use crate::data_provider::settings::{delete_settings, set_setting};
 use crate::data_provider::web_api::*;
 use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::{NotificationData, NotificationRequest};
@@ -31,7 +32,6 @@ pub enum SyncMessage {
    DisableSync,
    SwitchAutoSync,
 }
 #[derive(Clone)]
 pub struct SyncState {
    state: AppState,
    auto_fetch: bool,
@@ -221,14 +221,13 @@ impl SyncState {
                        .padding(3)
                    )
                    .style(rounded_box),
-                    button("Скопировать в буфер обмена")
+                    jl_button!("Скопировать в буфер обмена")
                        .style(jl_button)
                        .on_press(CopyKey)
                        .width(Fill),
                    row![
-                        button("↑ Отправить").style(jl_button).on_press(Send),
+                        jl_button!("↑ Отправить").on_press(Send),
                        space().width(Fill),
-                        button("↓ Скачать").style(jl_button).on_press(GetLast)
+                        jl_button!("↓ Скачать").on_press(GetLast)
                    ]
                    .spacing(DEFAULT_SPACING),
                    toggler(self.auto_fetch)
@@ -241,12 +240,8 @@ impl SyncState {
                ]
            } else {
                column![
-                    button("Создать сохранение")
+                    jl_button!("Создать сохранение").on_press(InitSync),
-                        .style(jl_button)
+                    jl_button!("Вставить ключ из буфера").on_press(GetKey),
                        .on_press(InitSync),
                    button("Вставить ключ из буфера")
                        .style(jl_button)
                        .on_press(GetKey),
                ]
            }
        }
@@ -273,9 +268,7 @@ impl SyncState {
            .unwrap_or_else(|e| {
                error!("Ошибка при checkpoint WAL: {e}");
            });
-        connection
+        connection.execute("VACUUM;", []).unwrap_or_else(|e| {
            .execute("VACUUM;", [])
            .unwrap_or_else(|e| {
            error!("Ошибка при checkpoint WAL: {e}");
            0
        });
@@ -1,182 +1,150 @@
 use crate::app::AppState;
-use crate::data::entities::{EntityHandle, WordData};
+use crate::data::Id;
-use crate::data_provider::words::{delete_word, update_word};
+use crate::data::entities::{CustomField, EntityHandle, WordData};
-use crate::navigation::Page::PreviousPage;
+use crate::data::repositories::Repository;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::pages::word::WordMessage::*;
 use crate::push_error;
 use crate::push_error_task;
 use crate::styling::*;
 use iced::widget::button::danger;
-use iced::widget::{button, column, row, rule, scrollable, space, text, text_input};
+use iced::widget::space::horizontal;
-use iced::{Element, Fill, Task};
+use iced::widget::{button, column, row, rule, scrollable, text, text_input};
-use parking_lot::Mutex;
+use iced::{Element, Fill};
-use std::sync::Arc;
+use iced_core::Padding;
-#[derive(Clone)]
+pub struct WordEditor<Message> {
 pub struct WordState {
    state: AppState,
    handle: EntityHandle<WordData>,
    on_delete: Option<Message>,
    on_edit: Option<Message>,
    fields: Vec<CustomField>,
 }
-impl NavigatedPage<WordMessage> for WordState {
+impl<Message> WordEditor<Message> {
-    fn navigate(&mut self, message: &WordMessage) -> Option<Page> {
+    pub(crate) fn update(&mut self, message: WordMessage) -> Option<Message> {
-        if let Back = message {
+        let dictionary = &mut self.state.dictionary.write();
-            Some(PreviousPage)
+        let word = dictionary.get_mut(&mut self.handle).unwrap();
-        } else {
+        match message {
-            None
+            Delete => {
                return self.on_delete.take();
            }
            SetTags(n) => word.tags = n,
            SetKey(n) => {
                word.key = n;
            }
            SetValue(n) => {
                word.value = n;
            }
            SetAdditional(key, value) => {
                word.additional.insert(key, value.clone());
            }
            AddAdditional(key) => {
                word.additional.insert(key, "".to_string());
            }
            RemoveAdditional(key) => {
                word.additional.remove(&key);
            }
        }
        self.on_edit.take()
    }
    pub(crate) fn view(&self) -> Element<'_, WordMessage> {
        let mut fast_add = row![];
        let word = self
            .state
            .dictionary
            .read()
            .get_static(self.handle)
            .unwrap();
        for field in &self.fields {
            if !word.additional.contains_key(&field.id) {
                fast_add = fast_add.push(
                    button(field.name.as_str())
                        .style(button::text)
                        .on_press(AddAdditional(field.id)),
                );
            }
        }
-    fn navigated(&mut self) {}
+        let mut col = iced::widget::column![
-    fn update(&mut self, message: WordMessage) -> Task<RootMessage> {
+            column![text!("Ключ"), text_input("key", &word.key).on_input(SetKey),]
-        // match message {
+                .spacing(QUARTER_SPACING),
-        //     Back => {}
+            column![
-        //     Save => {
+                text!("Значение"),
-        //         let mut state = self.state.lock();
+                text_input("value", &word.value).on_input(SetValue),
-        //         state.dictionary[self.index] = self.word.clone();
+            ]
-        //
+            .spacing(QUARTER_SPACING),
-        //         if let Err(err) = update_word(&mut self.word, &state.connection) {
+            column![
-        //             return push_error_task!(err);
+                text!("Теги"),
-        //         }
+                text_input("tags", &word.tags).on_input(SetTags),
-        //         return Task::done(RootMessage::Word(Back));
+            ]
-        //     }
+            .spacing(QUARTER_SPACING),
-        //     Delete => {
+            rule::horizontal(2),
-        //         let mut state = self.state.lock();
+            scrollable(fast_add.padding(Padding{
-        //         state.dictionary.remove(self.index);
+
-        //         if let Err(err) = delete_word(&self.word, &state.connection) {
+
-        //             return push_error_task!(err);
+            top: 0.0 , right: 0.0 , bottom: 4.0 , left: 0.0 , })).horizontal(),
-        //         }
+        ];
-        //         return Task::done(RootMessage::Word(Back));
+
-        //     }
+        for more in &word.additional {
-        //     SetTags(n) => self.word.tags = n,
+            col = col.push(self.get_view_for_more(more));
        //     SetKey(n) => {
        //         self.word.key = n;
        //     }
        //     SetValue(n) => {
        //         self.word.value = n;
        //     }
        //     SetAdditional(key, value) => {
        //         self.word.additional.insert(key, value.clone());
        //     }
        //     AddAdditional(key) => {
        //         self.word.additional.insert(key, "".to_string());
        //     }
        //     RemoveAdditional(key) => {
        //         self.word.additional.remove(key.as_str());
        //     }
        // }
        Task::none()
        }
-    fn view(&self) -> Element<'_, WordMessage> {
+        column![
-        // let mut fast_add = row![];
+            col.spacing(DEFAULT_SPACING / 2.0).width(Fill).height(Fill),
-        // if !self.word.additional.contains_key("reading") {
+            row![
-        //     fast_add = fast_add.push(
+                horizontal().width(Fill),
-        //         button("Чтение")
+                button("Удалить").style(danger).on_press(Delete),
-        //             .style(button::text)
+            ]
-        //             .on_press(AddAdditional("reading".to_string())),
+            .spacing(DEFAULT_SPACING)
-        //     );
+        ]
-        // }
+        .spacing(DEFAULT_SPACING)
-        // if !self.word.additional.contains_key("description") {
+        .into()
        //     fast_add = fast_add.push(
        //         button("Описание")
        //             .style(button::text)
        //             .on_press(AddAdditional("description".to_string())),
        //     );
        // }
        //
        // if !self.word.additional.contains_key("context") {
        //     fast_add = fast_add.push(
        //         button("В контексте")
        //             .style(button::text)
        //             .on_press(AddAdditional("context".to_string())),
        //     );
        // }
        //
        // let mut col = iced::widget::column![
        //     column![
        //         text!("Ключ"),
        //         text_input("key", &self.word.key).on_input(SetKey),
        //     ]
        //     .spacing(QUARTER_SPACING),
        //     column![
        //         text!("Значение"),
        //         text_input("value", &self.word.value).on_input(SetValue),
        //     ]
        //     .spacing(QUARTER_SPACING),
        //     column![
        //         text!("Теги"),
        //         text_input("tags", &self.word.tags).on_input(SetTags),
        //     ]
        //     .spacing(QUARTER_SPACING),
        //     rule::horizontal(2),
        //     scrollable(fast_add),
        // ];
        //
        // for more in &self.word.additional {
        //     col = col.push(self.get_view_for_more(more));
        // }
        //
        // back_overlay(
        //     column![
        //         col.spacing(DEFAULT_SPACING / 2.0).width(Fill).height(Fill),
        //         row![
        //             button("Сохранить").style(jl_button).on_press(Save),
        //             button("Удалить").style(danger).on_press(Delete),
        //         ]
        //         .spacing(DEFAULT_SPACING)
        //     ]
        //     .spacing(DEFAULT_SPACING)
        //     .into(),
        //     Back,
        // )
        space().into()
    }
 }
-impl WordState {
+impl<Message> WordEditor<Message> {
    pub fn new(handle: EntityHandle<WordData>, state: AppState) -> Self {
        let fields = state
            .custom_fields
            .read()
            .iter()
            .cloned()
            .collect::<Vec<_>>();
        Self {
            state,
            handle,
-        }
+            on_delete: None,
-    }
+            on_edit: None,
-}
+            fields,
 impl WordState {
    fn get_view_for_more(&self, value: (&String, &String)) -> Element<'_, WordMessage> {
        match value.0.as_str() {
            "reading" => self.reading_field(value.1),
            "description" => self.description_field(value.1),
            "context" => self.context_field(value.1),
            _ => self.additional_field(value.1, value.0.clone(), value.0.clone()),
        }
    }
-    fn reading_field(&self, value: &str) -> Element<'_, WordMessage> {
+    pub fn on_delete(mut self, message: Message) -> Self {
-        self.additional_field(value, "Чтение слова".to_string(), "reading".to_string())
+        self.on_delete = Some(message);
        self
    }
    pub fn on_edit(mut self, message: Message) -> Self {
        self.on_edit = Some(message);
        self
    }
 }
-    fn description_field(&self, value: &str) -> Element<'_, WordMessage> {
+impl<Message> WordEditor<Message> {
-        self.additional_field(value, "Описание".to_string(), "description".to_string())
+    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.clone()),
        }
    }
-    fn context_field(&self, value: &str) -> Element<'_, WordMessage> {
+    fn additional_field(&self, value: &str, name: &str, id: Id) -> Element<'_, WordMessage> {
        self.additional_field(value, "В контексте".to_string(), "context".to_string())
    }
    fn additional_field(&self, value: &str, name: String, id: String) -> Element<'_, WordMessage> {
        column![
            text!("{}", name),
            row![
-                text_input(id.clone().as_str(), value)
+                text_input(name, value)
-                    .on_input({
+                    .on_input(move |string| SetAdditional(id, string))
                        let value = id.clone();
                        move |string| SetAdditional(value.clone(), string)
                    })
                    .width(Fill),
                button("-")
-                    .on_press(RemoveAdditional(id.clone()))
+                    .on_press(RemoveAdditional(id))
                    .style(danger),
            ]
            .spacing(QUARTER_SPACING),
@@ -188,13 +156,11 @@ impl WordState {
 #[derive(Debug, Clone)]
 pub enum WordMessage {
    Save,
    Back,
    Delete,
    SetTags(String),
    SetKey(String),
    SetValue(String),
-    AddAdditional(String),
+    AddAdditional(Id),
-    RemoveAdditional(String),
+    RemoveAdditional(Id),
-    SetAdditional(String, String),
+    SetAdditional(Id, String),
 }
@@ -1,4 +1,5 @@
 use crate::core::kana_set::KanaSet;
 use crate::jl_button;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
@@ -6,7 +7,6 @@ use iced::widget::*;
 use iced::{Element, Fill, Task, alignment};
 use rand::seq::SliceRandom;
 #[derive(Clone, Debug)]
 pub struct WritingState {
    kana: String,
    set: Vec<(String, String)>,
@@ -45,12 +45,8 @@ impl NavigatedPage<WritingMessage> for WritingState {
                text!("{}", self.kana).size(48),
                self.answers(),
                row![
-                    button(text!("{}", self.next_text))
+                    jl_button!(text!("{}", self.next_text)).on_press(WritingMessage::Next),
-                        .style(jl_button)
+                    jl_button!("Закончить").on_press(WritingMessage::Back),
                        .on_press(WritingMessage::Next),
                    button("Закончить")
                        .style(jl_button)
                        .on_press(WritingMessage::Back),
                ]
                .spacing(DEFAULT_SPACING)
            ]
@@ -1,7 +1,7 @@
 use iced::Element;
 use iced::border::Radius;
 use iced::widget::button::*;
-use iced::widget::{button, container};
+use iced::widget::container;
 use iced_core::Length::Fill;
 use iced_core::alignment::Horizontal::Left;
 use iced_core::{Border, Theme};
@@ -14,7 +14,7 @@ pub const BUTTON_RADIUS: f32 = 8.0;
 pub const SETTINGS_ICON: &[u8] = include_bytes!("../settings_icon.svg");
-pub fn jl_button(theme: &Theme, status: Status) -> Style {
+pub fn jl_button_style(theme: &Theme, status: Status) -> Style {
    let mut style = primary(theme, status);
    style.border = Border {
        color: Default::default(),
@@ -30,12 +30,16 @@ pub fn cta_button(theme: &Theme, status: Status) -> Style {
    style
 }
 #[macro_export]
 macro_rules! jl_button {
    ($content:expr) => {
        iced::widget::button($content).style($crate::styling::jl_button_style)
    };
 }
 pub fn back_overlay<'a, T: Clone + 'a>(content: Element<'a, T>, back_message: T) -> Element<'a, T> {
    container(
-        iced::widget::column![
+        iced::widget::column![jl_button!("Назад").on_press(back_message), content]
            button("Назад").style(jl_button).on_press(back_message),
            content
        ]
            .spacing(DEFAULT_SPACING)
            .align_x(Left)
            .width(Fill),
@@ -73,13 +73,13 @@ mod mod_tests {
    #[test]
    fn id_0() {
        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
-        assert_eq!(entity.real(), true)
+        assert!(entity.real())
    }
    #[test]
    fn id_1() {
        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
-        assert_eq!(entity.real(), false)
+        assert!(!entity.real())
    }
    #[test]
@@ -97,14 +97,14 @@ mod mod_tests {
    fn id_5() {
        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
        entity.set_real(true);
-        assert_eq!(entity.real(), true)
+        assert!(entity.real())
    }
    #[test]
    fn id_6() {
        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
        entity.set_real(true);
-        assert_eq!(entity.real(), true)
+        assert!(entity.real())
    }
    #[test]
@@ -0,0 +1,447 @@
 use iced::widget::MouseArea;
 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,
 };
 pub fn hard_mouse_area<'a, Message, Theme, Renderer>(
    widget: impl Into<Element<'a, Message, Theme, Renderer>>,
 ) -> HardMouseArea<'a, Message, Theme, Renderer>
 where
    Renderer: iced_core::Renderer,
 {
    HardMouseArea::new(widget)
 }
 pub struct HardMouseArea<'a, Message, Theme = iced::Theme, Renderer = iced::Renderer> {
    content: Element<'a, Message, Theme, Renderer>,
    on_press: Option<Message>,
    on_release: Option<Message>,
    on_double_click: Option<Message>,
    on_right_press: Option<Message>,
    on_right_release: Option<Message>,
    on_middle_press: Option<Message>,
    on_middle_release: Option<Message>,
    on_scroll: Option<Box<dyn Fn(mouse::ScrollDelta) -> Message + 'a>>,
    on_enter: Option<Message>,
    on_move: Option<Box<dyn Fn(Point) -> Message + 'a>>,
    on_exit: Option<Message>,
    interaction: Option<mouse::Interaction>,
 }
 impl<'a, Message, Theme, Renderer> HardMouseArea<'a, Message, Theme, Renderer> {
    /// The message to emit on a left button press.
    #[must_use]
    pub fn on_press(mut self, message: Message) -> Self {
        self.on_press = Some(message);
        self
    }
    /// The message to emit on a left button release.
    #[must_use]
    pub fn on_release(mut self, message: Message) -> Self {
        self.on_release = Some(message);
        self
    }
    /// The message to emit on a double click.
    ///
    /// If you use this with [`on_press`]/[`on_release`], those
    /// event will be emit as normal.
    ///
    /// The events stream will be: on_press -> on_release -> on_press
    /// -> on_double_click -> on_release -> on_press ...
    ///
    /// [`on_press`]: Self::on_press
    /// [`on_release`]: Self::on_release
    #[must_use]
    pub fn on_double_click(mut self, message: Message) -> Self {
        self.on_double_click = Some(message);
        self
    }
    /// The message to emit on a right button press.
    #[must_use]
    pub fn on_right_press(mut self, message: Message) -> Self {
        self.on_right_press = Some(message);
        self
    }
    /// The message to emit on a right button release.
    #[must_use]
    pub fn on_right_release(mut self, message: Message) -> Self {
        self.on_right_release = Some(message);
        self
    }
    /// The message to emit on a middle button press.
    #[must_use]
    pub fn on_middle_press(mut self, message: Message) -> Self {
        self.on_middle_press = Some(message);
        self
    }
    /// The message to emit on a middle button release.
    #[must_use]
    pub fn on_middle_release(mut self, message: Message) -> Self {
        self.on_middle_release = Some(message);
        self
    }
    /// The message to emit when scroll wheel is used
    #[must_use]
    pub fn on_scroll(mut self, on_scroll: impl Fn(mouse::ScrollDelta) -> Message + 'a) -> Self {
        self.on_scroll = Some(Box::new(on_scroll));
        self
    }
    /// The message to emit when the mouse enters the area.
    #[must_use]
    pub fn on_enter(mut self, message: Message) -> Self {
        self.on_enter = Some(message);
        self
    }
    /// The message to emit when the mouse moves in the area.
    #[must_use]
    pub fn on_move(mut self, on_move: impl Fn(Point) -> Message + 'a) -> Self {
        self.on_move = Some(Box::new(on_move));
        self
    }
    /// The message to emit when the mouse exits the area.
    #[must_use]
    pub fn on_exit(mut self, message: Message) -> Self {
        self.on_exit = Some(message);
        self
    }
    /// The [`mouse::Interaction`] to use when hovering the area.
    #[must_use]
    pub fn interaction(mut self, interaction: mouse::Interaction) -> Self {
        self.interaction = Some(interaction);
        self
    }
 }
 /// Local state of the [`HardMouseArea`].
 #[derive(Default)]
 struct State {
    is_hovered: bool,
    bounds: Rectangle,
    cursor_position: Option<Point>,
    previous_click: Option<mouse::Click>,
 }
 impl<'a, Message, Theme, Renderer> HardMouseArea<'a, Message, Theme, Renderer> {
    /// Creates a [`HardMouseArea`] with the given content.
    pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
        HardMouseArea {
            content: content.into(),
            on_press: None,
            on_release: None,
            on_double_click: None,
            on_right_press: None,
            on_right_release: None,
            on_middle_press: None,
            on_middle_release: None,
            on_scroll: None,
            on_enter: None,
            on_move: None,
            on_exit: None,
            interaction: None,
        }
    }
 }
 impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
    for HardMouseArea<'_, Message, Theme, Renderer>
 where
    Renderer: renderer::Renderer,
    Message: Clone,
 {
    fn tag(&self) -> tree::Tag {
        tree::Tag::of::<State>()
    }
    fn state(&self) -> tree::State {
        tree::State::new(State::default())
    }
    fn children(&self) -> Vec<Tree> {
        vec![Tree::new(&self.content)]
    }
    fn diff(&self, tree: &mut Tree) {
        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,
        layout: Layout<'_>,
        renderer: &Renderer,
        operation: &mut dyn Operation,
    ) {
        self.content
            .as_widget_mut()
            .operate(&mut tree.children[0], layout, renderer, operation);
    }
    fn update(
        &mut self,
        tree: &mut Tree,
        event: &Event,
        layout: Layout<'_>,
        cursor: mouse::Cursor,
        renderer: &Renderer,
        clipboard: &mut dyn Clipboard,
        shell: &mut Shell<'_, Message>,
        viewport: &Rectangle,
    ) {
        if self.on_move.is_none() && let Event::Mouse(mouse::Event::CursorMoved {..}) = event {
            self.content.as_widget_mut().update(
                &mut tree.children[0],
                event,
                layout,
                cursor,
                renderer,
                clipboard,
                shell,
                viewport,
            );
        }
        if self.on_enter.is_none() && let Event::Mouse(mouse::Event::CursorEntered {..}) = event {
            self.content.as_widget_mut().update(
                &mut tree.children[0],
                event,
                layout,
                cursor,
                renderer,
                clipboard,
                shell,
                viewport,
            );
        }
        if self.on_exit.is_none() && let Event::Mouse(mouse::Event::CursorLeft {..}) = event {
            self.content.as_widget_mut().update(
                &mut tree.children[0],
                event,
                layout,
                cursor,
                renderer,
                clipboard,
                shell,
                viewport,
            );
        }
        if shell.is_event_captured() {
            return;
        }
        update(self, tree, event, layout, cursor, shell);
    }
    fn mouse_interaction(
        &self,
        tree: &Tree,
        layout: Layout<'_>,
        cursor: mouse::Cursor,
        viewport: &Rectangle,
        renderer: &Renderer,
    ) -> mouse::Interaction {
        let content_interaction = self.content.as_widget().mouse_interaction(
            &tree.children[0],
            layout,
            cursor,
            viewport,
            renderer,
        );
        match (self.interaction, content_interaction) {
            (Some(interaction), mouse::Interaction::None) if cursor.is_over(layout.bounds()) => {
                interaction
            }
            _ => content_interaction,
        }
    }
    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,
        layout: Layout<'b>,
        renderer: &Renderer,
        viewport: &Rectangle,
        translation: Vector,
    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
        self.content.as_widget_mut().overlay(
            &mut tree.children[0],
            layout,
            renderer,
            viewport,
            translation,
        )
    }
 }
 impl<'a, Message, Theme, Renderer> From<HardMouseArea<'a, Message, Theme, Renderer>>
    for Element<'a, Message, Theme, Renderer>
 where
    Message: 'a + Clone,
    Theme: 'a,
    Renderer: 'a + renderer::Renderer,
 {
    fn from(
        area: HardMouseArea<'a, Message, Theme, Renderer>,
    ) -> Element<'a, Message, Theme, Renderer> {
        Element::new(area)
    }
 }
 /// Processes the given [`Event`] and updates the [`State`] of an [`HardMouseArea`]
 /// accordingly.
 fn update<Message: Clone, Theme, Renderer>(
    widget: &mut HardMouseArea<'_, Message, Theme, Renderer>,
    tree: &mut Tree,
    event: &Event,
    layout: Layout<'_>,
    cursor: mouse::Cursor,
    shell: &mut Shell<'_, Message>,
 ) {
    let state: &mut State = tree.state.downcast_mut();
    let cursor_position = cursor.position();
    let bounds = layout.bounds();
    if state.cursor_position != cursor_position || state.bounds != bounds {
        let was_hovered = state.is_hovered;
        state.is_hovered = cursor.is_over(layout.bounds());
        state.cursor_position = cursor_position;
        state.bounds = bounds;
        match (
            widget.on_enter.as_ref(),
            widget.on_move.as_ref(),
            widget.on_exit.as_ref(),
        ) {
            (Some(on_enter), _, _) if state.is_hovered && !was_hovered => {
                shell.publish(on_enter.clone());
            }
            (_, Some(on_move), _) if state.is_hovered => {
                if let Some(position) = cursor.position_in(layout.bounds()) {
                    shell.publish(on_move(position));
                }
            }
            (_, _, Some(on_exit)) if !state.is_hovered && was_hovered => {
                shell.publish(on_exit.clone());
            }
            _ => {}
        }
    }
    if !cursor.is_over(layout.bounds()) {
        return;
    }
    match event {
        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
        | Event::Touch(touch::Event::FingerPressed { .. }) => {
            if let Some(message) = widget.on_press.as_ref() {
                shell.publish(message.clone());
                shell.capture_event();
            }
            if let Some(position) = cursor_position
                && let Some(message) = widget.on_double_click.as_ref()
            {
                let new_click =
                    mouse::Click::new(position, mouse::Button::Left, state.previous_click);
                if new_click.kind() == mouse::click::Kind::Double {
                    shell.publish(message.clone());
                }
                state.previous_click = Some(new_click);
                // Even if this is not a double click, but the press is nevertheless
                // processed by us and should not be popup to parent widgets.
                shell.capture_event();
            }
        }
        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
        | Event::Touch(touch::Event::FingerLifted { .. }) => {
            if let Some(message) = widget.on_release.as_ref() {
                shell.publish(message.clone());
            }
        }
        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Right)) => {
            if let Some(message) = widget.on_right_press.as_ref() {
                shell.publish(message.clone());
                shell.capture_event();
            }
        }
        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Right)) => {
            if let Some(message) = widget.on_right_release.as_ref() {
                shell.publish(message.clone());
            }
        }
        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Middle)) => {
            if let Some(message) = widget.on_middle_press.as_ref() {
                shell.publish(message.clone());
                shell.capture_event();
            }
        }
        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Middle)) => {
            if let Some(message) = widget.on_middle_release.as_ref() {
                shell.publish(message.clone());
            }
        }
        Event::Mouse(mouse::Event::WheelScrolled { delta }) => {
            if let Some(on_scroll) = widget.on_scroll.as_ref() {
                shell.publish(on_scroll(*delta));
                shell.capture_event();
            }
        }
        _ => {}
    }
 }
@@ -0,0 +1 @@
 pub mod hard_mouse_area;
Author	SHA1	Message	Date
micialware	ccfb302770	Prepare for new anki format	2026-09-13 12:44:51 +03:00
micialware	0de809fcce	Compressing word fields	2026-09-11 22:08:50 +03:00
micialware	e5622c70de	Fix deck filter	2026-09-11 14:02:57 +03:00
micialware	cbf49412ec	additional fields encoding and decoding	2026-09-11 13:56:26 +03:00
micialware	f61f93717c	Custom fields repo into AppState	2026-09-11 13:28:23 +03:00
micialware	be64b1da2d	Fix group delete	2026-09-11 13:12:45 +03:00
micialware	2568b9f292	More fixes for dictionary panel	2026-09-11 13:09:20 +03:00
micialware	05c82bee02	Fix tag edit bug	2026-09-11 12:48:04 +03:00
micialware	5d305affd3	Fixing some bugs	2026-09-11 12:38:21 +03:00
micialware	d59776d713	More keyboard handling for dictionary	2026-09-11 12:03:13 +03:00
micialware	adb6388ee2	Prepare for extended word edit	2026-09-11 11:47:04 +03:00
micialware	8fe4f3b8f4	New selected field movement	2026-09-11 00:41:36 +03:00
micialware	47bc83d4ae	New edit process	2026-09-11 00:01:19 +03:00
micialware	097c3c033c	Merge pull request 'reformat custom fields table. will return to this topic later' (#18 ) from compressed-fields into master Reviewed-on: #18	2026-09-09 15:16:01 +03:00
micialware	c30be42822	reformat custom fields table. will return to this topic later	2026-09-09 15:15:47 +03:00
micialware	ace54b10e1	remove clone from states	2026-09-09 15:03:54 +03:00
micialware	f66bf69ef5	Code cleanup	2026-09-09 15:00:52 +03:00
micialware	1ad991667b	Migrate to tiny macros of button	2026-09-09 14:26:55 +03:00
micialware	444352c007	Merge pull request 'Repo integration' (#15 ) from repo-integration into master Reviewed-on: #15	2026-09-09 12:47:42 +03:00