maolan 0.2.3

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
107
108
109
110
111
112
113

use super::*;

impl Maolan {
    pub(super) fn handle_response_session_state_action(
        &mut self,
        action: &Action,
    ) -> Option<Task<Message>> {
        match action {
            Action::SetSessionPath(_) => {
                self.has_unsaved_changes = false;
                self.engine_dirty = false;
                self.last_autosave_snapshot = None;
                self.pending_autosave_recovery = None;
                self.pending_open_session_dir = None;
                self.modal = None;
                if let Some(path) = self.session_dir.clone() {
                    self.remember_recent_session_path(&path);
                }
                if let Some(autosave_root) = self.autosave_snapshot_root()
                    && autosave_root.exists()
                    && let Err(_err) = fs::remove_dir_all(&autosave_root)
                {}
                if self.pending_exit_after_save {
                    self.pending_exit_after_save = false;
                    return Some(self.request_quit());
                }
                if self.pending_record_after_save {
                    self.pending_record_after_save = false;
                    return Some(self.send(Action::SetRecordEnabled(true)));
                }
                Some(Task::none())
            }
            #[cfg(all(unix, not(target_os = "macos")))]
            Action::Lv2Plugins(plugins) => {
                let blocklist = crate::plugin_blocklist::Blocklist::load();
                let (filtered, blocked): (Vec<_>, Vec<_>) =
                    plugins.iter().cloned().partition(|p| {
                        !blocklist.is_blocked(&p.bundle_uri) && !blocklist.is_blocked(&p.uri)
                    });
                let mut state = self.state.blocking_write();
                state.lv2_plugins = filtered;
                state.lv2_plugins_loaded = true;
                state.lv2_plugins_unavailable = false;
                state.message = format!(
                    "Loaded {} LV2 plugins ({} blocklisted)",
                    state.lv2_plugins.len(),
                    blocked.len()
                );
                Some(Task::none())
            }
            #[cfg(all(unix, not(target_os = "macos")))]
            Action::Lv2PluginsUnavailable { error } => {
                let mut state = self.state.blocking_write();
                state.lv2_plugins = vec![];
                state.lv2_plugins_loaded = true;
                state.lv2_plugins_unavailable = true;
                state.message = format!("LV2 plugin scan unavailable: {error}");
                Some(Task::none())
            }
            Action::Vst3Plugins(plugins) => {
                let blocklist = crate::plugin_blocklist::Blocklist::load();
                let (filtered, blocked): (Vec<_>, Vec<_>) = plugins
                    .iter()
                    .cloned()
                    .partition(|p| !blocklist.is_blocked(&p.path));
                let mut state = self.state.blocking_write();
                state.vst3_plugins = filtered;
                state.vst3_plugins_loaded = true;
                state.vst3_plugins_unavailable = false;
                state.message = format!(
                    "Loaded {} VST3 plugins ({} blocklisted)",
                    state.vst3_plugins.len(),
                    blocked.len()
                );
                Some(Task::none())
            }
            Action::Vst3PluginsUnavailable { error } => {
                let mut state = self.state.blocking_write();
                state.vst3_plugins = vec![];
                state.vst3_plugins_loaded = true;
                state.vst3_plugins_unavailable = true;
                state.message = format!("VST3 plugin scan unavailable: {error}");
                Some(Task::none())
            }
            Action::ClapPlugins(plugins) => {
                let blocklist = crate::plugin_blocklist::Blocklist::load();
                let (filtered, blocked): (Vec<_>, Vec<_>) = plugins
                    .iter()
                    .cloned()
                    .partition(|p| !blocklist.is_blocked(&p.path));
                let mut state = self.state.blocking_write();
                state.clap_plugins = filtered;
                state.clap_plugins_loaded = true;
                state.clap_plugins_unavailable = false;
                state.message = format!(
                    "Loaded {} CLAP plugins ({} blocklisted)",
                    state.clap_plugins.len(),
                    blocked.len()
                );
                Some(Task::none())
            }
            Action::ClapPluginsUnavailable { error } => {
                let mut state = self.state.blocking_write();
                state.clap_plugins = vec![];
                state.clap_plugins_loaded = true;
                state.clap_plugins_unavailable = true;
                state.message = format!("CLAP plugin scan unavailable: {error}");
                Some(Task::none())
            }
            _ => None,
        }
    }
}