872 lines
29 KiB
Rust
872 lines
29 KiB
Rust
use crate::app::AppState;
|
|
use crate::data::Id;
|
|
use crate::data::entities::{EntityHandle, WordData, WordGroup};
|
|
use crate::data::repositories::{Query, Repository};
|
|
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;
|
|
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::{WordEditor, WordMessage};
|
|
use crate::styling::*;
|
|
use crate::widgets::hard_mouse_area::hard_mouse_area;
|
|
use crate::{jl_button, push_error};
|
|
use crate::{jl_text_input, push_error_task};
|
|
use chrono::{DateTime, TimeDelta, Utc};
|
|
use hashbrown::{HashMap, HashSet};
|
|
use iced::alignment::Vertical::Center;
|
|
use iced::widget::button::Style;
|
|
use iced::widget::button::{danger, text};
|
|
use iced::widget::operation::focus;
|
|
use iced::widget::space::horizontal;
|
|
use iced::widget::text_input::Status::Active;
|
|
use iced::widget::text_input::default;
|
|
use iced::widget::*;
|
|
use iced::{Border, Color, Shadow, Task};
|
|
use iced_core::Length::{Fill, FillPortion};
|
|
use iced_core::border::Radius;
|
|
use iced_core::keyboard;
|
|
use iced_core::keyboard::Key::Named;
|
|
use iced_core::keyboard::key::Physical::Code;
|
|
use iced_core::keyboard::{Event, Modifiers};
|
|
use log::info;
|
|
use rand::random_range;
|
|
use std::ops::Add;
|
|
use std::sync::Arc;
|
|
use std::time::{Duration, Instant};
|
|
|
|
pub struct DictionaryState {
|
|
state: AppState,
|
|
included: HashSet<EntityHandle<WordData>>,
|
|
tag_map: HashMap<String, bool>,
|
|
words_tags: Vec<(EntityHandle<WordData>, Vec<String>)>,
|
|
reverse: bool,
|
|
search: String,
|
|
no_typing: bool,
|
|
selected_group: EntityHandle<WordGroup>,
|
|
reverse_list: bool,
|
|
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,
|
|
ExtendedEdit(EntityHandle<WordData>),
|
|
DeleteWord(EntityHandle<WordData>),
|
|
NewWord,
|
|
Include(EntityHandle<WordData>, bool),
|
|
IncludeTag(String, bool),
|
|
GotoTest,
|
|
ResetTags,
|
|
SetReverse(bool),
|
|
Search(String),
|
|
SetTyping(bool),
|
|
CreateGroup,
|
|
EditGroup(String),
|
|
SaveGroup,
|
|
SelectGroup(EntityHandle<WordGroup>),
|
|
DeleteGroup,
|
|
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 {
|
|
return Some(Page::PreviousPage);
|
|
}
|
|
if let GotoTest = message
|
|
&& !self.included.is_empty()
|
|
{
|
|
let mut words = vec![];
|
|
let dict = &self.state.dictionary.read();
|
|
|
|
let query = dict.query(Arc::new(|_| true));
|
|
let handles = query.handles();
|
|
words = handles.filter(|h| self.included.contains(h)).collect();
|
|
|
|
return Some(Page::DictionaryQuiz(DictionaryQuizState::new(
|
|
words,
|
|
self.reverse,
|
|
self.no_typing,
|
|
self.state.clone(),
|
|
)));
|
|
}
|
|
|
|
if let GotoImport = message {
|
|
return Some(Import(ImportState::new(self.state.clone())));
|
|
}
|
|
None
|
|
}
|
|
|
|
fn navigated(&mut self) {
|
|
self.included = Default::default();
|
|
self.tag_map = Default::default();
|
|
let groups = self.state.word_groups.read();
|
|
self.groups_query.load(&groups);
|
|
drop(groups);
|
|
self.update_tags();
|
|
}
|
|
|
|
fn update(&mut self, message: DictionaryMessage) -> Task<RootMessage> {
|
|
match message {
|
|
NewWord => {
|
|
let mut dictionary = self.state.dictionary.write();
|
|
let mut word = WordData::new();
|
|
word.group_id = self.selected_group.id;
|
|
dictionary.create(word);
|
|
self.displayed_words_query.load(&dictionary);
|
|
}
|
|
ExtendedEdit(i) => {
|
|
self.word_editor = Some(self.editor_for_word(i));
|
|
if let Some((handle, cell, index)) = self.selected_cell.clone() {
|
|
self.selected_cell = Some((i, cell, index))
|
|
}
|
|
}
|
|
Include(i, b) => {
|
|
if b {
|
|
self.included.insert(i);
|
|
} else {
|
|
self.included.remove(&i);
|
|
}
|
|
}
|
|
IncludeTag(t, v) => {
|
|
self.tag_map.insert(t, v);
|
|
self.update_words_include(self.selected_group.id)
|
|
}
|
|
|
|
ResetTags => {
|
|
self.tag_map.iter_mut().for_each(|(_, v)| *v = false);
|
|
self.included.clear();
|
|
}
|
|
SetReverse(v) => self.reverse = v,
|
|
Search(s) => {
|
|
self.search = s;
|
|
}
|
|
SetTyping(b) => self.no_typing = b,
|
|
Back => {}
|
|
GotoTest => {}
|
|
CreateGroup => {
|
|
let mut groups = self.state.word_groups.write();
|
|
groups.create(WordGroup {
|
|
id: 0.into(),
|
|
name: format!("Группа слов {}", random_range(100..1000)),
|
|
});
|
|
self.groups_query.load(&groups);
|
|
}
|
|
EditGroup(new) => {
|
|
let mut groups = self.state.word_groups.write();
|
|
|
|
let group = groups.get_mut(&mut self.selected_group);
|
|
if let Some(group) = group {
|
|
group.name = new;
|
|
}
|
|
}
|
|
SaveGroup => {
|
|
{
|
|
let mut groups = self.state.word_groups.write();
|
|
|
|
if let Err(err) = groups.save(&mut self.selected_group) {
|
|
return push_error_task!(err);
|
|
}
|
|
|
|
self.groups_query.load(&groups);
|
|
}
|
|
|
|
self.setup_words_query();
|
|
}
|
|
SelectGroup(i) => {
|
|
self.selected_group = i;
|
|
self.setup_words_query();
|
|
self.update_words_include(i.id)
|
|
}
|
|
DeleteGroup => {
|
|
if self.selected_group.id.0 == 1 {
|
|
return Task::none();
|
|
}
|
|
{
|
|
let delete_group = self.selected_group;
|
|
self.selected_group = EntityHandle::from_id(1.into());
|
|
self.setup_words_query();
|
|
let mut groups = self.state.word_groups.write();
|
|
|
|
if let Err(err) = groups.delete(delete_group) {
|
|
return push_error_task!(err);
|
|
}
|
|
|
|
if let Err(err) = self.state.dictionary.write().reload() {
|
|
return push_error_task!(err);
|
|
}
|
|
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();
|
|
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()
|
|
}
|
|
|
|
fn view(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
back_overlay(
|
|
row![
|
|
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)
|
|
.width(FillPortion(4)),
|
|
self.right_panel(),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.into(),
|
|
Back,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl DictionaryState {
|
|
pub fn new(state: AppState) -> Self {
|
|
let words_query = state.dictionary.read().empty_query_par();
|
|
let groups_query = state.word_groups.read().query(Arc::new(|_| true));
|
|
let mut result = DictionaryState {
|
|
included: Default::default(),
|
|
selected_group: EntityHandle::new(Id(1), 0, true),
|
|
state,
|
|
tag_map: HashMap::new(),
|
|
words_tags: vec![],
|
|
reverse: false,
|
|
search: "".to_string(),
|
|
no_typing: true,
|
|
reverse_list: true,
|
|
auto_save_queue: HashMap::new(),
|
|
displayed_words_query: words_query,
|
|
groups_query,
|
|
selected_cell: None,
|
|
word_editor: None,
|
|
};
|
|
|
|
result.init();
|
|
result.update_tags();
|
|
|
|
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
|
|
.dictionary
|
|
.read()
|
|
.query(Arc::new(|word| word.group_id == Id(1)));
|
|
}
|
|
|
|
fn setup_words_query(&mut self) {
|
|
let id = self.selected_group.id;
|
|
self.displayed_words_query = self
|
|
.state
|
|
.dictionary
|
|
.read()
|
|
.query(Arc::new(move |word| word.group_id == id));
|
|
}
|
|
|
|
fn launch_auto_save_offset(&mut self, handle: EntityHandle<WordData>) -> Task<RootMessage> {
|
|
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_millis(520)).await },
|
|
|_| message,
|
|
)
|
|
}
|
|
|
|
fn words_list(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
let time = Instant::now();
|
|
let mut col = Column::new().width(Fill);
|
|
|
|
let query = &self.displayed_words_query;
|
|
let dictionary = self.state.dictionary.read();
|
|
|
|
for access_index in 0..query.len() {
|
|
let mut i = access_index;
|
|
if self.reverse_list {
|
|
i = query.len() - access_index - 1;
|
|
}
|
|
let word_handle = &query[i];
|
|
let word = dictionary.get_ref_static(*word_handle).unwrap();
|
|
|
|
if !self.search.is_empty()
|
|
&& !word.key.contains(&self.search)
|
|
&& !word.value.contains(&self.search)
|
|
&& !word.tags.contains(&self.search)
|
|
{
|
|
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,
|
|
selection,
|
|
number: i,
|
|
};
|
|
|
|
let lazy_line = lazy(word_line_data, Self::word_line);
|
|
|
|
col = col.push(lazy_line);
|
|
}
|
|
|
|
info!("Words rendering time: {:?}", time.elapsed());
|
|
scrollable(col).height(Fill).into()
|
|
}
|
|
|
|
fn word_line<'a>(data: &WordLineState) -> Row<'a, DictionaryMessage> {
|
|
let mut line = Row::new().width(Fill).align_y(Center);
|
|
let handle = data.handle;
|
|
line = line.push(
|
|
checkbox(data.is_included)
|
|
.label("")
|
|
.spacing(15)
|
|
.on_toggle(move |b| Include(handle, b)),
|
|
);
|
|
|
|
let field = |placeholder: &str, data: &str, selected: bool| {
|
|
text_input(placeholder, data)
|
|
.size(ACCENT_FONT_SIZE)
|
|
.width(Fill)
|
|
.style(move |x, _| {
|
|
let mut default_style = default(x, Active);
|
|
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(
|
|
hard_mouse_area(field(
|
|
"Перевод",
|
|
&data.value,
|
|
data.selection.is_some() && data.selection.unwrap() == Value,
|
|
))
|
|
.on_press(SelectField(data.handle, Value, data.number)),
|
|
);
|
|
|
|
line = line.push(
|
|
hard_mouse_area(field(
|
|
"Теги",
|
|
&data.tags,
|
|
data.selection.is_some() && data.selection.unwrap() == Tags,
|
|
))
|
|
.on_press(SelectField(data.handle, Tags, data.number)),
|
|
);
|
|
|
|
let line_button = || {
|
|
if !data.handle.real() {
|
|
return button("-")
|
|
.on_press(DeleteWord(data.handle))
|
|
.style(|_x: &Theme, _status: button::Status| Style {
|
|
background: None,
|
|
text_color: Color::BLACK,
|
|
border: Border::default(),
|
|
shadow: Shadow::default(),
|
|
snap: false,
|
|
})
|
|
.width(15);
|
|
}
|
|
|
|
button("")
|
|
.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();
|
|
|
|
iced::widget::column![
|
|
jl_text_input!("Поиск", &self.search)
|
|
.on_input(Search)
|
|
.width(Fill),
|
|
text!("Всего слов: {}", dict.len()),
|
|
text!("Выбрано слов: {}", self.included.iter().count()),
|
|
self.tags_selector(),
|
|
toggler(self.no_typing)
|
|
.label("Без набора")
|
|
.on_toggle(SetTyping),
|
|
toggler(self.reverse)
|
|
.label("Обратный тест")
|
|
.on_toggle(SetReverse),
|
|
button(text!("Тест").center().width(Fill))
|
|
.style(cta_button)
|
|
.on_press(GotoTest)
|
|
.width(Fill),
|
|
]
|
|
.width(FillPortion(1))
|
|
.spacing(DEFAULT_SPACING)
|
|
.into()
|
|
}
|
|
|
|
fn tags_selector(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
let mut col = Column::new().width(Fill);
|
|
col = col.push(
|
|
button("Сбросить")
|
|
.on_press(ResetTags)
|
|
.style(|x: &Theme, _status| Style {
|
|
background: None,
|
|
text_color: x.palette().primary,
|
|
border: Border::default(),
|
|
shadow: Shadow::default(),
|
|
snap: false,
|
|
}),
|
|
);
|
|
let mut sorted_tags = self.tag_map.iter().collect::<Vec<_>>();
|
|
sorted_tags.sort();
|
|
for tag in sorted_tags {
|
|
col = col.push(
|
|
checkbox(*tag.1)
|
|
.label(tag.0)
|
|
.on_toggle(|x1| IncludeTag(tag.0.clone(), x1)),
|
|
)
|
|
}
|
|
|
|
container(scrollable(col)).height(Fill).into()
|
|
}
|
|
|
|
fn update_tags(&mut self) {
|
|
self.words_tags.clear();
|
|
let mut tags_list: HashSet<String> = HashSet::new();
|
|
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)| {
|
|
let tags = split_with_coma(element.tags.as_str());
|
|
tags.iter().for_each(|tag| {
|
|
tags_list.insert(tag.clone());
|
|
});
|
|
self.words_tags.push((handle, tags))
|
|
});
|
|
|
|
let current_tags = self
|
|
.tag_map
|
|
.keys()
|
|
.map(|k| k.clone().to_string())
|
|
.collect::<Vec<String>>();
|
|
|
|
current_tags
|
|
.iter()
|
|
.filter(|tag| !tags_list.contains(*tag))
|
|
.for_each(|tag| {
|
|
self.tag_map.remove(tag);
|
|
});
|
|
|
|
tags_list.iter().for_each(|tag| {
|
|
self.tag_map.insert(tag.clone(), false);
|
|
});
|
|
}
|
|
|
|
fn update_words_include(&mut self, group_id: Id) {
|
|
let include_tags = self
|
|
.tag_map
|
|
.iter()
|
|
.filter(|(_, value)| **value)
|
|
.map(|(t, _)| t.clone())
|
|
.collect::<Vec<String>>();
|
|
|
|
if include_tags.is_empty() {
|
|
self.included.clear();
|
|
return;
|
|
}
|
|
|
|
let dict = &self.state.dictionary.read();
|
|
let time = Instant::now();
|
|
|
|
self.included.clear();
|
|
for (handle, tags) in &mut self.words_tags {
|
|
if let Some(word) = dict.get_ref(handle) {
|
|
if word.group_id != group_id {
|
|
continue;
|
|
}
|
|
|
|
if !tags.is_empty() && tags.iter().all(|t| include_tags.contains(t)) {
|
|
self.included.insert(*handle);
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
info!("Time {}", time.elapsed().as_micros());
|
|
}
|
|
|
|
fn selection_editor(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
let mut display = "".to_string();
|
|
let mut editable = false;
|
|
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();
|
|
}
|
|
}
|
|
editable = true;
|
|
}
|
|
let mut field = jl_text_input!("", display.as_str())
|
|
.width(Fill)
|
|
.id(iced::widget::Id::new("editor"))
|
|
.style(|theme, status| {
|
|
let mut default = default(theme, status);
|
|
default.border.radius = Radius::new(0);
|
|
default
|
|
});
|
|
if editable {
|
|
field = field.on_input(EditField)
|
|
}
|
|
|
|
field.into()
|
|
}
|
|
|
|
fn groups_panel(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
let mut row = Row::new();
|
|
row = row.push(button("+").style(text).on_press(CreateGroup));
|
|
|
|
let groups = &self.state.word_groups.read();
|
|
|
|
for mut group in self.groups_query.handles() {
|
|
let group_name = groups.get(&mut group).unwrap().name.clone();
|
|
row = row.push(
|
|
button(text!("{}", group_name))
|
|
.style(text)
|
|
.on_press(SelectGroup(group)),
|
|
);
|
|
}
|
|
|
|
let groups = self.state.word_groups.read();
|
|
let group = groups.get_static(self.selected_group).unwrap();
|
|
|
|
iced::widget::column![
|
|
scrollable(row).width(Fill).horizontal(),
|
|
row![
|
|
jl_button!("⇳").on_press(ChangeDirection),
|
|
jl_text_input!("Название группы слов", &group.name)
|
|
.on_input(EditGroup)
|
|
.width(250)
|
|
.on_submit(SaveGroup),
|
|
horizontal(),
|
|
self.group_delete_button(),
|
|
]
|
|
.spacing(DEFAULT_SPACING / 2.0)
|
|
]
|
|
.into()
|
|
}
|
|
|
|
fn group_delete_button(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
if self.selected_group.real() && self.selected_group.id != 1.into() {
|
|
button("Удалить").style(danger).on_press(DeleteGroup).into()
|
|
} else {
|
|
space().into()
|
|
}
|
|
}
|
|
|
|
fn add_word_button(&self) -> iced::Element<'_, DictionaryMessage> {
|
|
let button = jl_button!("Добавить слово");
|
|
|
|
if self.selected_group.real() {
|
|
return button.on_press(NewWord).into();
|
|
}
|
|
|
|
button.into()
|
|
}
|
|
}
|
|
|
|
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())
|
|
.filter(|t| !t.is_empty())
|
|
.collect::<Vec<String>>()
|
|
}
|
|
|
|
#[derive(Clone, Hash, PartialEq, Eq)]
|
|
struct WordLineState {
|
|
is_included: bool,
|
|
key: String,
|
|
value: String,
|
|
tags: String,
|
|
handle: EntityHandle<WordData>,
|
|
selection: Option<BasicWordFields>,
|
|
number: usize,
|
|
}
|