650 lines
24 KiB
Rust
650 lines
24 KiB
Rust
use crate::app::AppState;
|
|
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::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
|
|
use crate::navigation::{NavigatedPage, Page, RootMessage};
|
|
use crate::notification::MaybeError;
|
|
use crate::pages::history::HistoryState;
|
|
use crate::pages::repetition::RepetitionState;
|
|
use crate::pages::repetition_settings::RepetitionSettingsState;
|
|
use crate::pages::repetitions::RepetitionsMessage::*;
|
|
use crate::push_error;
|
|
use crate::push_error_task;
|
|
use crate::styling::*;
|
|
use chrono::{Days, Local, Utc};
|
|
use hashbrown::{HashMap, HashSet};
|
|
pub use iced::widget::button::{Catalog, Style};
|
|
use iced::widget::button::{Status, danger};
|
|
use iced::widget::tooltip::Position::Top;
|
|
use iced::widget::{
|
|
Column, Row, button, column, container, lazy, radio, row, scrollable, space, svg, text,
|
|
text_input, tooltip,
|
|
};
|
|
use iced::{Background, Border, Center, Color, Element, Fill, Length, Shadow, Task, Theme};
|
|
use iced_core::Padding;
|
|
use iced_core::border::Radius;
|
|
use iced_core::svg::Handle;
|
|
use std::ops::Deref;
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Clone)]
|
|
pub struct RepetitionsState {
|
|
selected_deck_handle: Option<EntityHandle<DeckSettings>>,
|
|
decks: HashMap<EntityHandle<DeckSettings>, DeckViewData>,
|
|
state: AppState,
|
|
}
|
|
|
|
impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
|
|
fn navigate(&mut self, message: &RepetitionsMessage) -> Option<Page> {
|
|
if let Back = message {
|
|
Some(PreviousPage)
|
|
} else if let GoToHistory = message {
|
|
Some(History(HistoryState::new(
|
|
self.selected_deck().unwrap().id,
|
|
self.state.clone(),
|
|
)))
|
|
} else if let GoToRepetition = message {
|
|
let mut state_clone = self.state.clone();
|
|
let selected_set = self.selected_deck_mut().unwrap();
|
|
if selected_set.append_mode == AppendMode::Full {
|
|
if let Err(_err) = Self::append_all_words(&mut state_clone, selected_set) {
|
|
return None;
|
|
}
|
|
selected_set.existing_words_indices = selected_set.available_words_indices.clone();
|
|
} else {
|
|
if selected_set.available_words_indices.is_empty()
|
|
|| selected_set.existing_words_indices.is_empty()
|
|
{
|
|
return None;
|
|
}
|
|
}
|
|
|
|
if let Ok(repetition_state) =
|
|
RepetitionState::new(selected_set.general_settings.clone(), self.state.clone())
|
|
{
|
|
return Some(Repetition(repetition_state));
|
|
}
|
|
|
|
None
|
|
} else if let GoToSettings = message {
|
|
Some(RepetitionSettings(RepetitionSettingsState::new(
|
|
EntityHandle::from_id(self.selected_deck().unwrap().id),
|
|
self.state.clone(),
|
|
)))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
fn navigated(&mut self) {
|
|
if let Some(index) = self.selected_deck_handle {
|
|
let decks = self.state.decks.read();
|
|
if let None = decks.get_static(index) {
|
|
self.decks.remove(&index);
|
|
drop(decks);
|
|
self.clear_selection();
|
|
}
|
|
} else {
|
|
let _ = self.fill_deck_word_indices();
|
|
}
|
|
}
|
|
fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
|
|
match message {
|
|
Next => {}
|
|
Back => {}
|
|
GoToRepetition => {}
|
|
GoToHistory => {}
|
|
GoToSettings => {}
|
|
|
|
CreateSet => {
|
|
let index = self.decks.len() + 1;
|
|
let general = DeckSettings::with_name(format!("Колода #{}", index));
|
|
let handle = self.state.decks.write().create(general.clone());
|
|
self.decks.insert(
|
|
handle,
|
|
DeckViewData {
|
|
settings_handle: handle,
|
|
general_settings: general,
|
|
existing_words_indices: Default::default(),
|
|
available_words_indices: Default::default(),
|
|
indices_ready: false,
|
|
append_mode: Default::default(),
|
|
count: None,
|
|
open_mode: OrderMode::Default,
|
|
},
|
|
);
|
|
}
|
|
DeleteSet => {
|
|
let index = self.selected_deck_handle.unwrap();
|
|
self.clear_selection();
|
|
let deck = self.decks.remove(&index);
|
|
|
|
if index.real() {
|
|
let mut repo = self.state.decks.write();
|
|
if let Err(err) = repo.delete(index) {
|
|
return push_error_task!(err);
|
|
}
|
|
}
|
|
}
|
|
SetName(value) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.general_settings.name = value;
|
|
}
|
|
SelectSet(index) => {
|
|
self.select_deck(index);
|
|
let deck = self.selected_deck().unwrap();
|
|
if !deck.indices_ready
|
|
&& let Err(err) = self.fill_deck_word_indices()
|
|
{
|
|
return push_error_task!(err);
|
|
}
|
|
}
|
|
Save => {
|
|
let deck = self.selected_deck().unwrap().clone();
|
|
let handle = self.selected_deck_handle.unwrap();
|
|
let mut repo = self.state.decks.write();
|
|
|
|
repo.set_static(handle, deck.general_settings.clone());
|
|
if let Err(err) = repo.save(&mut handle.clone()) {
|
|
return push_error_task!(err);
|
|
}
|
|
}
|
|
SetForward(value) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.general_settings.forward = value;
|
|
}
|
|
SetBackward(value) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.general_settings.backward = value;
|
|
}
|
|
SetFilter(value) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.general_settings.filter = value;
|
|
}
|
|
TryFilter => {
|
|
let deck = self.selected_deck().unwrap();
|
|
let count = DeckData::list(&deck, &self.state).len();
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.count = Some(count);
|
|
}
|
|
SetOpenMode(mode) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.open_mode = mode;
|
|
}
|
|
SetAppendMode(mode) => {
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.append_mode = mode;
|
|
}
|
|
AppendWords(count) => {
|
|
let adding: Vec<EntityHandle<WordData>>;
|
|
{
|
|
{
|
|
let deck = self.selected_deck().unwrap();
|
|
let existing_words_indices = &deck.existing_words_indices;
|
|
let mut created_set = HashSet::with_capacity(existing_words_indices.len());
|
|
existing_words_indices.iter().for_each(|c| {
|
|
created_set.insert(c);
|
|
});
|
|
adding = deck
|
|
.available_words_indices
|
|
.iter()
|
|
.filter(|c| !created_set.contains(c))
|
|
.take(count)
|
|
.cloned()
|
|
.collect();
|
|
}
|
|
|
|
let deck = self.selected_deck_mut().unwrap();
|
|
deck.existing_words_indices.append(&mut adding.clone());
|
|
}
|
|
|
|
let deck = self.selected_deck().unwrap().clone();
|
|
let state = &mut self.state;
|
|
if let Err(err) =
|
|
Self::append_words(state, &deck.general_settings, adding.into_iter())
|
|
{
|
|
return push_error_task!(err);
|
|
}
|
|
}
|
|
}
|
|
Task::none()
|
|
}
|
|
|
|
fn view(&self) -> Element<'_, RepetitionsMessage> {
|
|
back_overlay(
|
|
row![
|
|
column![
|
|
scrollable(self.decks_list()).height(Fill),
|
|
button("Добавить")
|
|
.style(jl_button)
|
|
.width(Fill)
|
|
.on_press(CreateSet),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.width(Length::FillPortion(1)),
|
|
self.selected_deck_view(),
|
|
]
|
|
.align_y(Center)
|
|
.spacing(DEFAULT_SPACING)
|
|
.width(Fill)
|
|
.height(Fill)
|
|
.into(),
|
|
Back,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl RepetitionsState {
|
|
pub(crate) fn new(state: AppState) -> RepetitionsState {
|
|
let decks = Self::get_decks_from_state(&state);
|
|
RepetitionsState {
|
|
selected_deck_handle: None,
|
|
decks,
|
|
state,
|
|
}
|
|
}
|
|
|
|
fn get_decks_from_state(state: &AppState) -> HashMap<EntityHandle<DeckSettings>, DeckViewData> {
|
|
state
|
|
.decks
|
|
.read()
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(index, deck)| {
|
|
(
|
|
EntityHandle::new(deck.id, index, true),
|
|
DeckViewData {
|
|
settings_handle: EntityHandle::new(deck.id, index, true),
|
|
general_settings: deck.clone(),
|
|
existing_words_indices: Default::default(),
|
|
available_words_indices: Default::default(),
|
|
indices_ready: false,
|
|
append_mode: Default::default(),
|
|
count: None,
|
|
open_mode: OrderMode::Default,
|
|
},
|
|
)
|
|
})
|
|
.collect::<HashMap<_, _>>()
|
|
}
|
|
}
|
|
|
|
impl RepetitionsState {
|
|
fn launch_delete_button(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
|
|
if deck.id.is_valid() {
|
|
if deck.append_mode == AppendMode::Manual && deck.existing_words_indices.is_empty() {
|
|
return text!("Добавьте карточки или измените фильтр").into();
|
|
}
|
|
return row![
|
|
space().width(Fill),
|
|
button(text!("Начать повторение").width(200).center())
|
|
.style(cta_button)
|
|
.on_press(GoToRepetition)
|
|
]
|
|
.into();
|
|
}
|
|
button("Удалить").style(danger).on_press(DeleteSet).into()
|
|
}
|
|
fn selected_deck_view(&self) -> Element<'_, RepetitionsMessage> {
|
|
if let Some(deck) = &self.selected_deck() {
|
|
return column![
|
|
scrollable(
|
|
column![
|
|
column![
|
|
text!("Название набора"),
|
|
row![
|
|
text_input("", &deck.name).on_input(SetName),
|
|
button(svg(Handle::from_memory(SETTINGS_ICON)))
|
|
.width(43)
|
|
.on_press(GoToSettings),
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
]
|
|
.spacing(QUARTER_SPACING),
|
|
{
|
|
if !deck.id.is_valid() {
|
|
column![
|
|
column![
|
|
text!("Передняя сторона"),
|
|
text_input("", &deck.forward).on_input(SetForward),
|
|
]
|
|
.spacing(QUARTER_SPACING),
|
|
column![
|
|
text!("Задняя сторона"),
|
|
text_input("", &deck.backward).on_input(SetBackward),
|
|
]
|
|
.spacing(QUARTER_SPACING),
|
|
column![
|
|
text!("Фильтр"),
|
|
text_input("", &deck.filter).on_input(SetFilter),
|
|
button("Проверить фильтр")
|
|
.style(jl_button)
|
|
.on_press(TryFilter),
|
|
self.count_view(deck),
|
|
]
|
|
.spacing(QUARTER_SPACING),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
} else {
|
|
column![
|
|
self.filled_deck_data_view(deck),
|
|
self.word_append_panel(deck),
|
|
radio(
|
|
"Обычный режим",
|
|
OrderMode::Default,
|
|
Some(deck.open_mode),
|
|
SetOpenMode
|
|
),
|
|
radio(
|
|
"Начать с плохих слов",
|
|
OrderMode::TrainWorstFirst,
|
|
Some(deck.open_mode),
|
|
SetOpenMode
|
|
),
|
|
radio(
|
|
"Полностью случайно",
|
|
OrderMode::FullRandom,
|
|
Some(deck.open_mode),
|
|
SetOpenMode
|
|
),
|
|
button("История").style(jl_button).on_press(GoToHistory),
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
}
|
|
},
|
|
// self.words_words_view(&set),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.padding(Padding {
|
|
top: 0.0,
|
|
right: DEFAULT_SPACING,
|
|
bottom: 0.0,
|
|
left: 0.0,
|
|
})
|
|
)
|
|
.height(Fill),
|
|
row![
|
|
button("Сохранить").style(jl_button).on_press(Save),
|
|
self.launch_delete_button(deck)
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.align_y(Center),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.width(Length::FillPortion(2))
|
|
.into();
|
|
}
|
|
space().width(Length::FillPortion(2)).into()
|
|
}
|
|
fn filled_deck_data_view(&self, deck: &DeckSettings) -> Column<'_, RepetitionsMessage> {
|
|
column![self.activity_bar(deck), self.count_comparator_view()]
|
|
.align_x(Center)
|
|
.width(Fill)
|
|
.spacing(DEFAULT_SPACING)
|
|
}
|
|
fn activity_bar(&self, deck: &DeckSettings) -> Element<'_, RepetitionsMessage> {
|
|
const MAX_DAY_COUNT: f32 = 128.0;
|
|
|
|
let history = self.state.history.read();
|
|
let history = history.activity_of_deck(deck.id);
|
|
let mut counts: Vec<u32> = vec![0; 30 * 7];
|
|
let now = Local::now().date_naive();
|
|
|
|
for (date, activity) in history {
|
|
let distance = now - date;
|
|
let index = counts.len() as i64 - distance.num_days() - 1;
|
|
|
|
if index < 0 {
|
|
continue;
|
|
}
|
|
|
|
counts[index as usize] = activity;
|
|
}
|
|
|
|
lazy((counts, now), |(counts, now)| {
|
|
let mut row = Row::new()
|
|
.padding(Padding {
|
|
top: 0.0,
|
|
right: 0.0,
|
|
bottom: 0.0,
|
|
left: DEFAULT_SPACING,
|
|
})
|
|
.spacing(QUARTER_SPACING);
|
|
|
|
let mut iter = counts.iter();
|
|
for i in 0..30 {
|
|
let mut column = Column::new().spacing(QUARTER_SPACING);
|
|
|
|
for j in 0..7 {
|
|
let value = *iter.next().unwrap() as f32;
|
|
let k = (value / MAX_DAY_COUNT).min(1.0) * 0.9 + 0.1;
|
|
|
|
let date = (*now)
|
|
.checked_sub_days(Days::new(30 * 7 - i * 7 - j - 1))
|
|
.unwrap_or_default();
|
|
|
|
column = column.push(tooltip(
|
|
iced::widget::container(space().height(15).width(15)).style(
|
|
move |x: &Theme| container::Style {
|
|
text_color: None,
|
|
background: Some(Background::Color(
|
|
x.palette().primary.scale_alpha(k),
|
|
)),
|
|
border: Border {
|
|
color: Default::default(),
|
|
width: 0.0,
|
|
radius: Radius::new(5),
|
|
},
|
|
shadow: Default::default(),
|
|
snap: false,
|
|
},
|
|
),
|
|
text!("{} {} карточки", date.format("%Y.%m.%d"), value),
|
|
Top,
|
|
));
|
|
}
|
|
|
|
row = row.push(column);
|
|
}
|
|
scrollable(
|
|
column!["Карта активности", row]
|
|
.spacing(QUARTER_SPACING)
|
|
.align_x(Center),
|
|
)
|
|
})
|
|
.into()
|
|
}
|
|
fn word_append_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
|
|
column![
|
|
text!("Режим добавления карточек"),
|
|
row![
|
|
radio(
|
|
"Добавлять все доступные",
|
|
AppendMode::Full,
|
|
Some(deck.append_mode),
|
|
SetAppendMode
|
|
),
|
|
radio(
|
|
"Добавлять вручную",
|
|
AppendMode::Manual,
|
|
Some(deck.append_mode),
|
|
SetAppendMode
|
|
)
|
|
]
|
|
.spacing(HALF_SPACING),
|
|
self.adder_panel(deck),
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
.into()
|
|
}
|
|
fn adder_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
|
|
match deck.append_mode {
|
|
AppendMode::Full => space().into(),
|
|
AppendMode::Manual => row![
|
|
button("+5").on_press(AppendWords(5)),
|
|
button("+10").on_press(AppendWords(10)),
|
|
button("+15").on_press(AppendWords(15)),
|
|
button("+20").on_press(AppendWords(20))
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
.into(),
|
|
}
|
|
}
|
|
|
|
fn count_comparator_view(&self) -> Element<'_, RepetitionsMessage> {
|
|
let selected_deck = self.selected_deck().unwrap();
|
|
let now = selected_deck.existing_words_indices.len();
|
|
let available = selected_deck.available_words_indices.len();
|
|
text!("{} слова добавлено из {}", now, available).into()
|
|
}
|
|
fn count_view(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
|
|
if let Some(count) = deck.count {
|
|
return text!("Количество слов: {}", count).into();
|
|
}
|
|
space().into()
|
|
}
|
|
fn decks_list(&self) -> Column<'_, RepetitionsMessage> {
|
|
let mut column = Column::new();
|
|
|
|
for (i, (handle, deck)) in self.decks.iter().enumerate() {
|
|
column = column.push(
|
|
button(text!("{}", &deck.name))
|
|
.on_press_with(move || SelectSet(*handle))
|
|
.style(move |_x: &Theme, status: Status| Style {
|
|
background: if status == Status::Hovered {
|
|
Some(Background::Color(Color::WHITE.scale_alpha(0.2)))
|
|
} else {
|
|
None
|
|
},
|
|
text_color: _x.palette().primary,
|
|
border: Border {
|
|
color: Default::default(),
|
|
width: 0.0,
|
|
radius: BUTTON_RADIUS.into(),
|
|
},
|
|
shadow: Shadow::default(),
|
|
snap: false,
|
|
}),
|
|
);
|
|
}
|
|
|
|
column
|
|
}
|
|
}
|
|
|
|
impl RepetitionsState {
|
|
fn append_all_words(state: &mut AppState, deck: &DeckViewData) -> MaybeError {
|
|
let existing = &deck.existing_words_indices;
|
|
let mut created_set = HashSet::with_capacity(existing.len());
|
|
existing.iter().for_each(|c| {
|
|
created_set.insert(c);
|
|
});
|
|
let required = deck
|
|
.available_words_indices
|
|
.iter()
|
|
.filter(|i| !created_set.contains(i))
|
|
.cloned();
|
|
Self::append_words(state, deck, required)?;
|
|
Ok(())
|
|
}
|
|
fn append_words(
|
|
state: &mut AppState,
|
|
deck: &DeckSettings,
|
|
indices: impl Iterator<Item = EntityHandle<WordData>>,
|
|
) -> MaybeError {
|
|
let words = &state.dictionary;
|
|
let stats = &mut indices
|
|
.map(|i| CardState {
|
|
id: 0.into(),
|
|
word_id: i.id,
|
|
last_open: Utc::now(),
|
|
score: 1,
|
|
fsrs_opened: Utc::now().date_naive(),
|
|
fsrs_memory: None,
|
|
deck_id: deck.id,
|
|
fsrs_open_day: Utc::now().date_naive(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
if !stats.is_empty() {
|
|
let mut repo = state.card_states.write();
|
|
repo.create_now_many(stats.as_mut_slice())?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn select_deck(&mut self, index: EntityHandle<DeckSettings>) {
|
|
if self.decks.contains_key(&index) {
|
|
self.selected_deck_handle = Some(index);
|
|
}
|
|
}
|
|
|
|
fn selected_deck(&self) -> Option<&DeckViewData> {
|
|
self.decks.get(&self.selected_deck_handle?)
|
|
}
|
|
fn selected_deck_mut(&mut self) -> Option<&mut DeckViewData> {
|
|
self.decks.get_mut(&self.selected_deck_handle?)
|
|
}
|
|
|
|
fn clear_selection(&mut self) {
|
|
self.selected_deck_handle = None;
|
|
}
|
|
|
|
fn fill_deck_word_indices(&mut self) -> MaybeError {
|
|
let card_states = self.state.card_states.read();
|
|
let deck_id = self.selected_deck().unwrap().id;
|
|
let added = card_states
|
|
.query_par(Arc::new(move |state| state.deck_id == deck_id))
|
|
.iter(&card_states)
|
|
.map(|state| EntityHandle::from_id(state.word_id))
|
|
.collect::<Vec<_>>();
|
|
let mut deck = self.selected_deck().unwrap().clone();
|
|
let total = DeckData::list(&deck, &self.state);
|
|
deck.existing_words_indices = added;
|
|
deck.available_words_indices = total;
|
|
self.decks.insert(self.selected_deck_handle.unwrap(), deck);
|
|
Ok(())
|
|
}
|
|
}
|
|
#[derive(Clone)]
|
|
pub enum RepetitionsMessage {
|
|
Next,
|
|
Back,
|
|
GoToRepetition,
|
|
CreateSet,
|
|
DeleteSet,
|
|
SetName(String),
|
|
SelectSet(EntityHandle<DeckSettings>),
|
|
Save,
|
|
SetForward(String),
|
|
SetBackward(String),
|
|
SetFilter(String),
|
|
TryFilter,
|
|
SetOpenMode(OrderMode),
|
|
SetAppendMode(AppendMode),
|
|
GoToHistory,
|
|
GoToSettings,
|
|
AppendWords(usize),
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct DeckViewData {
|
|
settings_handle: EntityHandle<DeckSettings>,
|
|
general_settings: DeckSettings,
|
|
existing_words_indices: Vec<EntityHandle<WordData>>,
|
|
available_words_indices: Vec<EntityHandle<WordData>>,
|
|
indices_ready: bool,
|
|
append_mode: AppendMode,
|
|
count: Option<usize>,
|
|
open_mode: OrderMode,
|
|
}
|
|
|
|
impl Deref for DeckViewData {
|
|
type Target = DeckSettings;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.general_settings
|
|
}
|
|
}
|