cadmus_core/view/settings_editor/kinds/
reader.rs

1//! Setting kinds for the Reader category.
2
3use super::{SettingData, SettingIdentity, SettingKind, WidgetKind};
4use crate::fl;
5use crate::i18n::I18nDisplay;
6use crate::settings::{FinishedAction, Settings};
7use crate::view::{Bus, EntryId, EntryKind, Event};
8
9/// Reader finished action setting
10pub struct FinishedActionSetting;
11
12impl SettingKind for FinishedActionSetting {
13    fn identity(&self) -> SettingIdentity {
14        SettingIdentity::FinishedAction
15    }
16
17    fn label(&self, _settings: &Settings) -> String {
18        fl!("settings-reader-end-of-book-action")
19    }
20
21    fn fetch(&self, settings: &Settings) -> SettingData {
22        let current = settings.reader.finished;
23
24        let entries = vec![
25            EntryKind::RadioButton(
26                FinishedAction::Notify.to_i18n_string(),
27                EntryId::SetFinishedAction(FinishedAction::Notify),
28                current == FinishedAction::Notify,
29            ),
30            EntryKind::RadioButton(
31                FinishedAction::Close.to_i18n_string(),
32                EntryId::SetFinishedAction(FinishedAction::Close),
33                current == FinishedAction::Close,
34            ),
35            EntryKind::RadioButton(
36                FinishedAction::GoToNext.to_i18n_string(),
37                EntryId::SetFinishedAction(FinishedAction::GoToNext),
38                current == FinishedAction::GoToNext,
39            ),
40        ];
41
42        SettingData {
43            value: current.to_i18n_string(),
44            widget: WidgetKind::SubMenu(entries),
45        }
46    }
47
48    fn handle(&self, evt: &Event, settings: &mut Settings, _bus: &mut Bus) -> Option<String> {
49        if let Event::Select(EntryId::SetFinishedAction(action)) = evt {
50            settings.reader.finished = *action;
51            return Some(action.to_i18n_string());
52        }
53        None
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60    use crate::settings::{FinishedAction, Settings};
61    use crate::view::{Bus, EntryId, Event};
62    use std::collections::VecDeque;
63
64    mod finished_action_setting {
65        use super::*;
66
67        #[test]
68        fn handle_set_action_updates_settings() {
69            let setting = FinishedActionSetting;
70            let mut settings = Settings::default();
71            settings.reader.finished = FinishedAction::Close;
72            let mut bus: Bus = VecDeque::new();
73            let event = Event::Select(EntryId::SetFinishedAction(FinishedAction::GoToNext));
74
75            let result = setting.handle(&event, &mut settings, &mut bus);
76
77            assert!(result.is_some());
78            assert_eq!(settings.reader.finished, FinishedAction::GoToNext);
79        }
80
81        #[test]
82        fn handle_can_set_all_actions() {
83            let setting = FinishedActionSetting;
84            let mut settings = Settings::default();
85            let mut bus: Bus = VecDeque::new();
86
87            for action in [
88                FinishedAction::Notify,
89                FinishedAction::Close,
90                FinishedAction::GoToNext,
91            ] {
92                let event = Event::Select(EntryId::SetFinishedAction(action));
93                setting.handle(&event, &mut settings, &mut bus);
94                assert_eq!(settings.reader.finished, action);
95            }
96        }
97
98        #[test]
99        fn handle_returns_none_for_wrong_event() {
100            let setting = FinishedActionSetting;
101            let mut settings = Settings::default();
102            let mut bus: Bus = VecDeque::new();
103
104            let result = setting.handle(&Event::Select(EntryId::About), &mut settings, &mut bus);
105
106            assert!(result.is_none());
107        }
108
109        #[test]
110        fn handle_returns_none_for_per_library_entry_id() {
111            let setting = FinishedActionSetting;
112            let mut settings = Settings::default();
113            let mut bus: Bus = VecDeque::new();
114            let event = Event::Select(EntryId::SetLibraryFinishedAction(0, FinishedAction::Notify));
115
116            let result = setting.handle(&event, &mut settings, &mut bus);
117
118            assert!(result.is_none());
119        }
120    }
121}