micialware/jap_learn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename and clear bad code

Browse Source
This commit is contained in:
micialware
2026-08-18 12:14:35 +03:00
parent 3fcbd235cf
commit 99b3818181
19 changed files with 186 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/repetitions.rs
+128 -169
View File
@@ -1,7 +1,8 @@
use std::ops::Deref;
use crate::data_provider::card_sets::{delete_set, update_card_set};
use crate::data_provider::card_stats::{add_stat_list, load_stats_of_set};
use crate::history::HistoryState;
use crate::lang::{AppendMode, CardSetSettings, CardStatistics, OrderMode};
use crate::lang::{AppendMode, DeckSettings, CardStatistics, OrderMode};
use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
use crate::navigation::{NavigatedPage, Page};
use crate::repetition::RepetitionState;
@@ -11,53 +12,65 @@ use crate::styling::*;
use crate::{AppState, RootMessage};
use chrono::{Days, Local, Utc};
use hashbrown::{HashMap, HashSet};
use iced::widget::button::{danger, Status};
pub use iced::widget::button::{Catalog, Style};
use iced::widget::button::{Status, danger};
use iced::widget::tooltip::Position::Top;
use iced::widget::{
button, column, container, lazy, radio, row, scrollable, space, svg, text, text_input, tooltip,
Column, Row,
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 iced_core::Padding;
use std::sync::{Arc, Mutex};
#[derive(Clone)]
pub struct RepetitionsState {
selected_set: Option<usize>,
selected_set_index: Option<usize>,
correct_filters: Vec<bool>,
current_sets_cards_cache: HashMap<usize, (Vec<usize>, Vec<usize>)>,
word_id_index_map: HashMap<u32, usize>,
local_settings: HashMap<u32, DeckLocalSetting>,
view_data: Option<SetViewData>,
pub state: Arc<Mutex<AppState>>,
set_names: Vec<String>
}
impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
fn navigate(&self, message: &RepetitionsMessage) -> Option<Page> {
fn navigate(&mut self, message: &RepetitionsMessage) -> Option<Page> {
if let Back = message {
Some(PreviousPage)
} else if let GoToHistory = message {
let card_set;
{
card_set = self.state.lock().unwrap().card_sets[self.selected_set.unwrap()].id;
card_set = self.state.lock().unwrap().card_sets[self.selected_set_index.unwrap()].id;
}
Some(History(HistoryState::new(card_set, self.state.clone())))
} else if let GoToRepetition = message {
let clone = self.state.clone();
let card_set;
{
card_set = self.state.lock().unwrap().card_sets[self.selected_set.unwrap()].clone();
card_set = self.state.lock().unwrap().card_sets[self.selected_set_index.unwrap()].clone();
}
if card_set.append_mode == AppendMode::Full {
if self.local_settings[&card_set.id].append_mode == AppendMode::Full {
self.append_all_words(&card_set);
} else {
let cache = self
.current_sets_cards_cache
.get(&self.selected_set_index.unwrap())
.unwrap();
if cache.1.is_empty() || cache.0.is_empty() {
let local_settings = self.local_settings.get_mut(&card_set.id).unwrap();
local_settings.append_warning = true;
}
}
Some(Repetition(RepetitionState::new(card_set, clone)))
} else if let GoToSettings = message {
Some(RepetitionSettings(RepetitionSettingsState::new(
self.selected_set.unwrap(),
self.selected_set_index.unwrap(),
self.state.clone(),
)))
} else {
@@ -65,110 +78,29 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
}
}
fn navigated(&mut self) {
self.selected_set = None;
self.clear_selection();
self.current_sets_cards_cache.clear();
}
fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
let mut state = self.state.lock().unwrap();
match message {
Next => {}
Back => {}
GoToRepetition => {}
GoToHistory => {}
GoToSettings => {}
CreateSet => {
let index = state.card_sets.len() + 1;
state
.card_sets
.push(CardSetSettings::with_name(format!("Card set #{}", index)));
self.correct_filters.push(true);
}
DeleteSet => {
let set = state.card_sets.remove(self.selected_set.unwrap());
self.correct_filters.remove(self.selected_set.unwrap());
self.selected_set = None;
delete_set(&set, &state.connection);
}
SelectSet(index) => {
self.selected_set = Some(index);
let set = state.card_sets.get(index).unwrap().clone();
if !self.current_sets_cards_cache.contains_key(&index) {
let added: Vec<_> = load_stats_of_set(&set, &state.connection)
.iter()
.map(|c| self.word_id_index_map[&c.word_id])
.collect();
let total = set.get_word_list(&state);
self.current_sets_cards_cache.insert(index, (added, total));
}
state.card_sets[index] = set;
}
SetName(new) => {
state.card_sets[self.selected_set.unwrap()].name = new;
}
Save => {
for i in 0..state.card_sets.len() {
self.correct_filters[i] = state.card_sets[i].check_filter();
}
let set = &mut state.card_sets[self.selected_set.unwrap()].clone();
update_card_set(set, &state.connection);
state.card_sets[self.selected_set.unwrap()] = set.clone();
}
SetForward(new) => {
state.card_sets[self.selected_set.unwrap()].forward = new;
}
SetBackward(new) => {
state.card_sets[self.selected_set.unwrap()].backward = new;
}
SetFilter(new) => {
state.card_sets[self.selected_set.unwrap()].filter = new;
}
TryFilter => {
let set = state.card_sets.get(self.selected_set.unwrap()).unwrap();
let count = set.get_word_list(&state).len();
state.card_sets[self.selected_set.unwrap()].count = Some(count);
}
SetOpenMode(mode) => {
state
.card_sets
.get_mut(self.selected_set.unwrap())
.unwrap()
.open_mode = mode;
}
SetAppendMode(mode) => {
let set = state.card_sets.get_mut(self.selected_set.unwrap()).unwrap();
set.append_mode = mode;
}
AppendWords(count) => {
let adding: Vec<usize>;
let set = state.card_sets.get(self.selected_set.unwrap()).unwrap();
let index = self.selected_set.unwrap();
{
let total_cache = &mut self.current_sets_cards_cache;
let cache = total_cache.get_mut(&index).unwrap().clone();
let mut created_set = HashSet::with_capacity(cache.0.len());
cache.0.iter().for_each(|c| {
created_set.insert(c);
});
adding = cache
.1
.iter()
.filter(|c| !created_set.contains(c))
.take(count)
.cloned()
.collect();
let mut new_current = cache.0.clone();
new_current.append(&mut adding.clone());
total_cache.insert(index, (new_current, cache.1.clone()));
}
Self::append_words(&state, set, adding.into_iter());
}
CreateSet => {}
DeleteSet => {}
SetName(_) => {}
SelectSet(_) => {}
Save => {}
SetForward(_) => {}
SetBackward(_) => {}
SetFilter(_) => {}
TryFilter => {}
SetOpenMode(_) => {}
SetAppendMode(_) => {}
AppendWords(_) => {}
}
Task::none()
}
@@ -203,55 +135,34 @@ impl RepetitionsState {
let count = state_.card_sets.len();
let mut map = HashMap::with_capacity(state_.dictionary.len());
state_.dictionary.iter().enumerate().for_each(|(index, word)| {map.insert(word.id, index);});
state_
.dictionary
.iter()
.enumerate()
.for_each(|(index, word)| {
map.insert(word.id, index);
});
let mut local_settings = HashMap::with_capacity(state_.card_sets.len());
state_.card_sets.iter().for_each(|card_set| {
local_settings.insert(card_set.id, Default::default());
});
drop(state_);
RepetitionsState {
selected_set: None,
selected_set_index: None,
correct_filters: vec![true; count],
current_sets_cards_cache: Default::default(),
word_id_index_map: map,
local_settings,
view_data: None,
state,
set_names: vec![],
}
}
}
impl RepetitionsState {
fn append_all_words(&self, set: &CardSetSettings) {
let index = self.selected_set.unwrap();
let cache = &self.current_sets_cards_cache[&index];
let mut created_set = HashSet::with_capacity(cache.0.len());
cache.0.iter().for_each(|c| {
created_set.insert(c);
});
let required = cache
.1
.iter()
.filter(|i| !created_set.contains(i)).cloned();
Self::append_words(&self.state.lock().unwrap(), set, required);
}
fn append_words(state: &AppState, set: &CardSetSettings, indices: impl Iterator<Item = usize>) {
let words = &state.dictionary;
let stats = &mut indices
.map(|i| {
let word = words.get(i).unwrap();
CardStatistics {
id: 0,
word_id: word.id,
last_open: Utc::now(),
score: 1,
set_id: set.id,
}
})
.collect::<Vec<_>>();
if !stats.is_empty() {
add_stat_list(stats, &state.connection);
}
}
fn launch_delete_button(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
fn launch_delete_button(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
if set.id != 0 {
return row![
space().width(Fill),
@@ -263,17 +174,8 @@ impl RepetitionsState {
}
button("Удалить").style(danger).on_press(DeleteSet).into()
}
fn selected_set_view(&self) -> Element<'_, RepetitionsMessage> {
if let Some(index) = self.selected_set {
let set;
{
let state = self.state.lock().unwrap();
if state.card_sets.len() <= index {
return space().width(Length::FillPortion(3)).into();
}
set = state.card_sets[index].clone();
}
if let Some(set) = &self.view_data {
return column![
scrollable(
column![
@@ -362,14 +264,13 @@ impl RepetitionsState {
}
space().width(Length::FillPortion(2)).into()
}
fn filled_set_data_view(&self, set: &CardSetSettings) -> Column<'_, RepetitionsMessage> {
fn filled_set_data_view(&self, set: &DeckSettings) -> Column<'_, RepetitionsMessage> {
column![self.activity_bar(set), self.count_comparator_view()]
.align_x(Center)
.width(Fill)
.spacing(DEFAULT_SPACING)
}
fn activity_bar(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
fn activity_bar(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
const MAX_DAY_COUNT: f32 = 128.0;
let state = self.state.lock().unwrap();
@@ -446,21 +347,20 @@ impl RepetitionsState {
})
.into()
}
fn word_append_panel(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
fn word_append_panel(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
column![
text!("Режим добавления карточек"),
row![
radio(
"Добавлять все доступные",
AppendMode::Full,
Some(set.append_mode),
Some(self.local_settings[&set.id].append_mode),
SetAppendMode
),
radio(
"Добавлять вручную",
AppendMode::Manual,
Some(set.append_mode),
Some(self.local_settings[&set.id].append_mode),
SetAppendMode
)
]
@@ -470,9 +370,8 @@ impl RepetitionsState {
.spacing(HALF_SPACING)
.into()
}
fn adder_panel(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
match set.append_mode {
fn adder_panel(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
match self.local_settings[&set.id].append_mode {
AppendMode::Full => space().into(),
AppendMode::Manual => row![
button("+5").on_press(AppendWords(5)),
@@ -484,27 +383,24 @@ impl RepetitionsState {
.into(),
}
}
fn count_comparator_view(&self) -> Element<'_, RepetitionsMessage> {
let cache = &self.current_sets_cards_cache[&self.selected_set.unwrap()];
let cache = &self.current_sets_cards_cache[&self.selected_set_index.unwrap()];
let now = cache.0.len();
let available = cache.1.len();
text!("{} слова добавлено из {}", now, available).into()
}
fn count_view(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
fn count_view(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
if let Some(count) = set.count {
return text!("Количество слов: {}", count).into();
}
space().into()
}
fn sets_list(&self) -> Column<'_, RepetitionsMessage> {
let mut column = Column::new();
let sets = &self.state.lock().unwrap().card_sets;
for (i, set) in sets.iter().enumerate() {
for (i, set) in self.set_names.iter().enumerate() {
column = column.push(
button(text!("{}", set.name.clone()))
button(text!("{}", set.clone()))
.on_press_with(move || SelectSet(i))
.style(move |_x: &Theme, status: Status| Style {
background: if status == Status::Hovered {
@@ -532,6 +428,48 @@ impl RepetitionsState {
}
}
impl RepetitionsState {
fn append_all_words(&self, set: &DeckSettings) {
let index = self.selected_set_index.unwrap();
let cache = &self.current_sets_cards_cache[&index];
let mut created_set = HashSet::with_capacity(cache.0.len());
cache.0.iter().for_each(|c| {
created_set.insert(c);
});
let required = cache.1.iter().filter(|i| !created_set.contains(i)).cloned();
Self::append_words(&self.state.lock().unwrap(), set, required);
}
fn append_words(state: &AppState, set: &DeckSettings, indices: impl Iterator<Item = usize>) {
let words = &state.dictionary;
let stats = &mut indices
.map(|i| {
let word = words.get(i).unwrap();
CardStatistics {
id: 0,
word_id: word.id,
last_open: Utc::now(),
score: 1,
set_id: set.id,
}
})
.collect::<Vec<_>>();
if !stats.is_empty() {
add_stat_list(stats, &state.connection);
}
}
fn select_set(&mut self, index: usize) {
let state = self.state.lock().unwrap();
if let Some(set) = state.card_sets.get(index) {
self.selected_set_index = Some(index);
}
}
fn clear_selection(&mut self) {
self.selected_set_index = None;
}
}
#[derive(Clone)]
pub enum RepetitionsMessage {
Next,
@@ -552,3 +490,24 @@ pub enum RepetitionsMessage {
GoToSettings,
AppendWords(usize),
}
#[derive(Clone, Default)]
struct DeckLocalSetting {
append_mode: AppendMode,
append_warning: bool,
}
#[derive(Clone)]
struct SetViewData{
set_local_settings: DeckLocalSetting,
set_settings: DeckSettings,
existing_words_indices: Vec<usize>,
available_words_indices: Vec<usize>,
}
impl Deref for SetViewData {
type Target = DeckSettings;
fn deref(&self) -> &Self::Target {
&self.set_settings
}
}