maolan 0.1.0

Rust DAW application for recording, editing, routing, automation, export, and plugin hosting
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

use super::*;

impl Maolan {
    pub(super) fn handle_track_selection_message(
        &mut self,
        message: Message,
    ) -> Option<Task<Message>> {
        match message {
            Message::ShiftPressed => {
                if !self.state.blocking_read().hw_loaded {
                    return Some(Task::none());
                }
                self.state.blocking_write().shift = true;
                None
            }
            Message::ShiftReleased => {
                if !self.state.blocking_read().hw_loaded {
                    return Some(Task::none());
                }
                self.state.blocking_write().shift = false;
                None
            }
            Message::CtrlPressed => {
                if !self.state.blocking_read().hw_loaded {
                    return Some(Task::none());
                }
                self.state.blocking_write().ctrl = true;
                None
            }
            Message::CtrlReleased => {
                if !self.state.blocking_read().hw_loaded {
                    return Some(Task::none());
                }
                self.state.blocking_write().ctrl = false;
                None
            }
            Message::SelectTrack(ref name) => {
                let now = Instant::now();
                let track_name = name.clone();
                let ctrl = self.state.blocking_read().ctrl;
                let mut state = self.state.blocking_write();
                state.track_context_menu = None;
                if ctrl {
                    state.connections_last_track_click = None;
                } else if let Some((last_track, last_time)) = &state.connections_last_track_click
                    && *last_track == track_name
                    && now.duration_since(*last_time) <= DOUBLE_CLICK.saturating_mul(2)
                {
                    state.connections_last_track_click = None;
                    return Some(Task::perform(async {}, move |_| {
                        Message::OpenTrackPlugins(track_name)
                    }));
                } else {
                    state.connections_last_track_click = Some((track_name.clone(), now));
                }

                if ctrl {
                    state.selected.insert(name.clone());
                    if let ConnectionViewSelection::Tracks(set) =
                        &mut state.connection_view_selection
                    {
                        set.insert(name.clone());
                    } else {
                        let mut set = std::collections::HashSet::new();
                        set.insert(name.clone());
                        state.connection_view_selection = ConnectionViewSelection::Tracks(set);
                    }
                } else {
                    state.selected.clear();
                    state.selected.insert(name.clone());
                    let mut set = std::collections::HashSet::new();
                    set.insert(name.clone());
                    state.connection_view_selection = ConnectionViewSelection::Tracks(set);
                }
                None
            }
            Message::SelectTrackFromMixer(ref name) => {
                let ctrl = self.state.blocking_read().ctrl;
                let mut state = self.state.blocking_write();
                state.track_context_menu = None;
                state.connections_last_track_click = None;

                if ctrl {
                    state.selected.insert(name.clone());
                    if let ConnectionViewSelection::Tracks(set) =
                        &mut state.connection_view_selection
                    {
                        set.insert(name.clone());
                    } else {
                        let mut set = std::collections::HashSet::new();
                        set.insert(name.clone());
                        state.connection_view_selection = ConnectionViewSelection::Tracks(set);
                    }
                } else {
                    state.selected.clear();
                    state.selected.insert(name.clone());
                    let mut set = std::collections::HashSet::new();
                    set.insert(name.clone());
                    state.connection_view_selection = ConnectionViewSelection::Tracks(set);
                }
                None
            }
            _ => None,
        }
    }
}