ludusavi 0.18.0

Game save backup tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use fuzzy_matcher::FuzzyMatcher;
use iced::Alignment;

use crate::{
    gui::{
        common::{Message, Screen, UndoSubject},
        shortcuts::TextHistories,
        widget::{Checkbox, Column, Element, IcedParentExt, PickList, Row, Text},
    },
    lang::TRANSLATOR,
    scan::{
        game_filter::{self, FilterKind},
        Duplication, ScanInfo,
    },
};

#[derive(Default, Clone, Eq, PartialEq)]
pub struct Filter<T> {
    active: bool,
    pub choice: T,
}

#[derive(Default)]
pub struct FilterComponent {
    pub show: bool,
    pub game_name: String,
    pub uniqueness: Filter<game_filter::Uniqueness>,
    pub completeness: Filter<game_filter::Completeness>,
    pub enablement: Filter<game_filter::Enablement>,
}

fn template<'a, T: 'static + Default + Copy + Eq + PartialEq + ToString>(
    filter: &'a Filter<T>,
    kind: FilterKind,
    options: &'a [T],
    message: fn(T) -> Message,
) -> Element<'a> {
    Row::new()
        .spacing(10)
        .align_items(Alignment::Center)
        .push(
            Checkbox::new("", filter.active, move |enabled| Message::ToggledSearchFilter {
                filter: kind,
                enabled,
            })
            .spacing(0),
        )
        .push(PickList::new(options, Some(filter.choice), message))
        .into()
}

impl FilterComponent {
    pub fn qualifies(
        &self,
        scan: &ScanInfo,
        enabled: bool,
        duplicated: Duplication,
        show_deselected_games: bool,
    ) -> bool {
        let fuzzy = self.game_name.is_empty()
            || fuzzy_matcher::skim::SkimMatcherV2::default()
                .fuzzy_match(&scan.game_name, &self.game_name)
                .is_some();
        let unique = !self.uniqueness.active || self.uniqueness.choice.qualifies(duplicated);
        let complete = !self.completeness.active || self.completeness.choice.qualifies(scan);
        let enable = !show_deselected_games || !self.enablement.active || self.enablement.choice.qualifies(enabled);

        fuzzy && unique && complete && enable
    }

    pub fn toggle_filter(&mut self, filter: FilterKind, enabled: bool) {
        match filter {
            FilterKind::Uniqueness => self.uniqueness.active = enabled,
            FilterKind::Completeness => self.completeness.active = enabled,
            FilterKind::Enablement => self.enablement.active = enabled,
        }
    }

    pub fn view(&self, screen: Screen, histories: &TextHistories, show_deselected_games: bool) -> Option<Element> {
        if !self.show {
            return None;
        }
        Some(
            Column::new()
                .push(
                    Row::new()
                        .padding([0, 20, 20, 20])
                        .spacing(20)
                        .align_items(Alignment::Center)
                        .push(Text::new(TRANSLATOR.filter_label()))
                        .push(histories.input(match screen {
                            Screen::Restore => UndoSubject::RestoreSearchGameName,
                            _ => UndoSubject::BackupSearchGameName,
                        }))
                        .push(template(
                            &self.uniqueness,
                            FilterKind::Uniqueness,
                            game_filter::Uniqueness::ALL,
                            Message::EditedSearchFilterUniqueness,
                        ))
                        .push(template(
                            &self.completeness,
                            FilterKind::Completeness,
                            game_filter::Completeness::ALL,
                            Message::EditedSearchFilterCompleteness,
                        ))
                        .push_if(
                            || show_deselected_games,
                            || {
                                template(
                                    &self.enablement,
                                    FilterKind::Enablement,
                                    game_filter::Enablement::ALL,
                                    Message::EditedSearchFilterEnablement,
                                )
                            },
                        ),
                )
                .into(),
        )
    }
}