rsynko-manager 0.1.2

Renderer-neutral transfer-manager specification for Rsynko
Documentation 
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

use crate::*;
use alux_ext::ext;

/// Derives action availability from renderer-neutral manager observations.
#[ext(name = ManagerMenuExt)]
pub impl<This> This
where
    This: NavigationStateAlg
        + QueueCatalogAlg
        + DraftStateAlg
        + InputDraftAlg
        + OutputDraftAlg
        + TextEditorStateAlg
        + DetailSelectionAlg,
    This::Entry: QueueEntryAlg + RequestOptionsAlg,
    This::Id: Copy + Eq,
{
    /// Derives whether one reusable action currently has meaning.
    fn action_availability(&self, action: ManagerAction) -> ActionAvailability {
        let enabled = match action {
            ManagerAction::Exit => true,
            ManagerAction::Back => self.page() != ManagerPage::Collection,
            ManagerAction::AddSources => self.page() == ManagerPage::Collection,
            ManagerAction::Space => {
                matches!(self.page(), ManagerPage::Collection | ManagerPage::Details(_))
                    && self
                        .selected_queue_id()
                        .and_then(|id| self.queue_entry(id))
                        .and_then(QueueEntryAlg::space_action)
                        .is_some()
            }
            ManagerAction::Remove => self.page() == ManagerPage::Collection && self.selected_queue_id().is_some(),
            ManagerAction::Previous => self.cursor_can_move(false),
            ManagerAction::Next => self.cursor_can_move(true),
            ManagerAction::Activate => self.selection_can_activate(),
        };
        if enabled { ActionAvailability::Enabled } else { ActionAvailability::Disabled }
    }

    /// Derives whether the current page cursor can move in one direction.
    fn cursor_can_move(&self, forward: bool) -> bool {
        match self.page() {
            ManagerPage::Collection => self.queue_ids().take(2).count() > 1,
            ManagerPage::AddSources | ManagerPage::Output(_) | ManagerPage::Input(_) => self
                .active_text_editor()
                .is_some_and(|(text, cursor)| if forward { cursor < text.len() } else { cursor > 0 }),
            ManagerPage::Details(id) => self.queue_entry(id).is_some_and(|entry| !entry.detail_controls().is_empty()),
            ManagerPage::Formats(id) => {
                self.queue_entry(id).is_some_and(|entry| entry.selectable_choices().next().is_some())
            }
            // A record, a report, and a command are read, not traversed: they state no cursor.
            ManagerPage::Log(_) | ManagerPage::Report(_) | ManagerPage::Command(_) => false,
        }
    }

    /// Derives whether the current cursor position denotes an activatable value.
    fn selection_can_activate(&self) -> bool {
        match self.page() {
            ManagerPage::Collection => self.selected_queue_id().is_some(),
            ManagerPage::AddSources => self.draft().lines().any(|line| !line.trim().is_empty()),
            ManagerPage::Output(id) => {
                self.queue_entry(id).is_some_and(QueueEntryAlg::is_editable) && !self.output_draft().trim().is_empty()
            }
            ManagerPage::Input(id) => {
                self.queue_entry(id).is_some_and(QueueEntryAlg::is_editable) && !self.input_draft().trim().is_empty()
            }
            ManagerPage::Details(id) => self.queue_entry(id).is_some_and(|entry| {
                self.selected_detail_control().is_none_or(|control| entry.detail_controls().contains(&control))
            }),
            ManagerPage::Formats(id) => {
                self.queue_entry(id).is_some_and(|entry| entry.selectable_choices().next().is_some())
            }
            ManagerPage::Log(_) | ManagerPage::Report(_) | ManagerPage::Command(_) => false,
        }
    }
}

/// Identifies one reusable manager-menu action independently of its input binding.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ManagerAction {
    /// Moves the current page's cursor to the preceding value.
    Previous,
    /// Moves the current page's cursor to the following value.
    Next,
    /// Activates the current page's selected value.
    Activate,
    /// Opens the add-sources editor.
    AddSources,
    /// Applies the selected queue entry's state-dependent Space action.
    Space,
    /// Removes the selected queue entry.
    Remove,
    /// Returns to the parent page.
    Back,
    /// Requests safe application exit.
    Exit,
}

/// Denotes whether a menu action currently has meaning.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ActionAvailability {
    /// Denotes an action that may be selected and activated.
    Enabled,
    /// Denotes a visible action that must not be selected or activated.
    Disabled,
}

impl ActionAvailability {
    /// Observes whether the action may be activated.
    #[must_use]
    pub const fn is_enabled(self) -> bool {
        matches!(self, Self::Enabled)
    }
}