broot 1.6.2

A new file manager
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

use {
    super::*,
    crate::{
        pattern::*,
        verb::{Internal, VerbInvocation},
    },
    bet::BeTree,
};

/// a command which may result in a change in the application state.
///
/// It may come from a shortcut, from the parsed input, from an argument
/// given on launch.
#[derive(Debug, Clone)]
pub enum Command {

    /// no command
    None,

    /// a verb invocation, unfinished
    /// (user didn't hit enter)
    VerbEdit(VerbInvocation),

    /// verb invocation, finished
    /// (coming from --cmd, or after the user hit enter)
    VerbInvocate(VerbInvocation),

    /// call of an internal done without the input
    /// (using a trigger key for example)
    Internal {
        internal: Internal,
        input_invocation: Option<VerbInvocation>,
    },

    /// call of a verb done without the input
    /// (using a trigger key for example)
    VerbTrigger {
        index: usize,
        input_invocation: Option<VerbInvocation>,
    },

    /// a pattern being edited
    PatternEdit {
        raw: String,
        expr: BeTree<PatternOperator, PatternParts>,
    },

    /// a mouse click
    Click(u16, u16),

    /// a mouse double-click
    /// Always come after a simple click at same position
    DoubleClick(u16, u16),
}

impl Command {

    pub fn empty() -> Command {
        Command::None
    }

    /// build a command from the parsed string representation
    ///
    /// The command being finished is the difference between
    /// a command being edited and a command launched (which
    /// happens on enter in the input).
    pub fn from_parts(mut cp: CommandParts, finished: bool) -> Self {
        if let Some(verb_invocation) = cp.verb_invocation.take() {
            if finished {
                Self::VerbInvocate(verb_invocation)
            } else {
                Self::VerbEdit(verb_invocation)
            }
        } else if finished {
            Self::Internal {
                internal: Internal::open_stay,
                input_invocation: None,
            }
        } else {
            Self::PatternEdit {
                raw: cp.raw_pattern,
                expr: cp.pattern,
            }
        }
    }

    /// tells whether this action is a verb being invocated on enter
    /// in the input field
    pub fn is_verb_invocated_from_input(&self) -> bool {
        matches!(self, Self::VerbInvocate(_))
    }

    /// create a command from a raw input.
    ///
    /// `finished` makes the command an executed form,
    /// it's equivalent to using the Enter key in the Gui.
    pub fn from_raw(raw: String, finished: bool) -> Self {
        let parts = CommandParts::from(raw);
        Self::from_parts(parts, finished)
    }

    /// build a non executed command from a pattern
    pub fn from_pattern(pattern: &InputPattern) -> Self {
        Command::from_raw(pattern.raw.clone(), false)
    }
}

impl Default for Command {
    fn default() -> Command {
        Command::empty()
    }
}