Pattern mute and so on

src/state/mod.rs

@@ -19,6 +19,7 @@ pub mod editor;
 pub mod file_browser;
 pub mod live_keys;
 pub mod modal;
+pub mod mute;
 pub mod options;
 pub mod panel;
 pub mod patterns_nav;
@@ -38,7 +39,8 @@ pub use modal::Modal;
 pub use options::{OptionsFocus, OptionsState};
 pub use panel::{PanelFocus, PanelState, SidePanel};
 pub use patterns_nav::{PatternsColumn, PatternsNav};
-pub use playback::{PlaybackState, StagedChange};
+pub use mute::MuteState;
+pub use playback::{PlaybackState, StagedChange, StagedMuteChange};
 pub use project::ProjectState;
 pub use sample_browser::SampleBrowserState;
 pub use ui::{DictFocus, FlashKind, HelpFocus, UiState};

src/state/mute.rs

@@ -0,0 +1,53 @@
+use std::collections::HashSet;
+
+#[derive(Default)]
+pub struct MuteState {
+    pub muted: HashSet<(usize, usize)>,
+    pub soloed: HashSet<(usize, usize)>,
+}
+
+impl MuteState {
+    pub fn toggle_mute(&mut self, bank: usize, pattern: usize) {
+        let key = (bank, pattern);
+        if self.muted.contains(&key) {
+            self.muted.remove(&key);
+        } else {
+            self.muted.insert(key);
+        }
+    }
+
+    pub fn toggle_solo(&mut self, bank: usize, pattern: usize) {
+        let key = (bank, pattern);
+        if self.soloed.contains(&key) {
+            self.soloed.remove(&key);
+        } else {
+            self.soloed.insert(key);
+        }
+    }
+
+    pub fn clear_mute(&mut self) {
+        self.muted.clear();
+    }
+
+    pub fn clear_solo(&mut self) {
+        self.soloed.clear();
+    }
+
+    pub fn is_muted(&self, bank: usize, pattern: usize) -> bool {
+        self.muted.contains(&(bank, pattern))
+    }
+
+    pub fn is_soloed(&self, bank: usize, pattern: usize) -> bool {
+        self.soloed.contains(&(bank, pattern))
+    }
+
+    pub fn is_effectively_muted(&self, bank: usize, pattern: usize) -> bool {
+        if self.muted.contains(&(bank, pattern)) {
+            return true;
+        }
+        if !self.soloed.is_empty() && !self.soloed.contains(&(bank, pattern)) {
+            return true;
+        }
+        false
+    }
+}

src/state/playback.rs

@@ -1,5 +1,6 @@
 use crate::engine::PatternChange;
 use crate::model::{LaunchQuantization, SyncMode};
+use std::collections::HashSet;
 
 #[derive(Clone)]
 pub struct StagedChange {
@@ -8,10 +9,17 @@ pub struct StagedChange {
     pub sync_mode: SyncMode,
 }
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum StagedMuteChange {
+    ToggleMute { bank: usize, pattern: usize },
+    ToggleSolo { bank: usize, pattern: usize },
+}
+
 pub struct PlaybackState {
     pub playing: bool,
     pub staged_changes: Vec<StagedChange>,
     pub queued_changes: Vec<StagedChange>,
+    pub staged_mute_changes: HashSet<StagedMuteChange>,
 }
 
 impl Default for PlaybackState {
@@ -20,6 +28,7 @@ impl Default for PlaybackState {
             playing: true,
             staged_changes: Vec::new(),
             queued_changes: Vec::new(),
+            staged_mute_changes: HashSet::new(),
         }
     }
 }
@@ -33,4 +42,38 @@ impl PlaybackState {
         self.staged_changes.clear();
         self.queued_changes.clear();
     }
+
+    pub fn stage_mute(&mut self, bank: usize, pattern: usize) {
+        let change = StagedMuteChange::ToggleMute { bank, pattern };
+        if self.staged_mute_changes.contains(&change) {
+            self.staged_mute_changes.remove(&change);
+        } else {
+            self.staged_mute_changes.insert(change);
+        }
+    }
+
+    pub fn stage_solo(&mut self, bank: usize, pattern: usize) {
+        let change = StagedMuteChange::ToggleSolo { bank, pattern };
+        if self.staged_mute_changes.contains(&change) {
+            self.staged_mute_changes.remove(&change);
+        } else {
+            self.staged_mute_changes.insert(change);
+        }
+    }
+
+    pub fn clear_staged_mutes(&mut self) {
+        self.staged_mute_changes.retain(|c| !matches!(c, StagedMuteChange::ToggleMute { .. }));
+    }
+
+    pub fn clear_staged_solos(&mut self) {
+        self.staged_mute_changes.retain(|c| !matches!(c, StagedMuteChange::ToggleSolo { .. }));
+    }
+
+    pub fn has_staged_mute(&self, bank: usize, pattern: usize) -> bool {
+        self.staged_mute_changes.contains(&StagedMuteChange::ToggleMute { bank, pattern })
+    }
+
+    pub fn has_staged_solo(&self, bank: usize, pattern: usize) -> bool {
+        self.staged_mute_changes.contains(&StagedMuteChange::ToggleSolo { bank, pattern })
+    }
 }