broot 1.56.2

File browser and launcher
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use {
    super::*,
    crate::{
        pattern::*,
        verb::{
            Internal,
            VerbId,
            VerbInvocation,
            VerbStore,
            Verb,
        },
    },
    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 {
        verb_id: VerbId,
        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
    }

    pub fn is_none(&self) -> bool {
        matches!(self, Command::None)
    }

    pub fn triggered_verb<'v>(
        &self,
        verb_store: &'v VerbStore,
    ) -> Option<&'v Verb> {
        match self {
            Self::VerbTrigger { verb_id, .. } => Some(verb_store.verb(*verb_id)),
            _ => None,
        }
    }

    pub fn as_verb_invocation(&self) -> Option<&VerbInvocation> {
        match self {
            Self::VerbEdit(vi) => Some(vi),
            Self::VerbInvocate(vi) => Some(vi),
            Self::Internal {
                input_invocation, ..
            } => input_invocation.as_ref(),
            Self::VerbTrigger {
                input_invocation, ..
            } => input_invocation.as_ref(),
            _ => 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()
    }
}