Refactoring

seq/src/app.rs

@@ -4,14 +4,15 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
+use crossbeam_channel::Sender;
+
 use crate::commands::AppCommand;
 use crate::config::MAX_SLOTS;
-use crate::file;
-use crate::link::LinkState;
-use crate::model::Pattern;
+use crate::engine::{
+    LinkState, PatternSnapshot, SeqCommand, SequencerSnapshot, SlotChange, StepSnapshot,
+};
+use crate::model::{self, Pattern, Rng, ScriptEngine, StepContext, Variables};
 use crate::page::Page;
-use crate::script::{Rng, ScriptEngine, StepContext, Variables};
-use crate::sequencer::{SequencerSnapshot, SlotChange};
 use crate::services::pattern_editor;
 use crate::state::{
     AudioSettings, EditorContext, Focus, Metrics, Modal, PatternField, PatternsViewLevel,
@@ -334,14 +335,14 @@ impl App {
         pattern: usize,
         snapshot: &SequencerSnapshot,
     ) -> Option<bool> {
-        self.playback.queued_changes.iter().find_map(|c| match c {
+        self.playback.queued_changes.iter().find_map(|c| match *c {
             SlotChange::Add {
                 slot: _,
                 bank: b,
                 pattern: p,
-            } if *b == bank && *p == pattern => Some(true),
+            } if b == bank && p == pattern => Some(true),
             SlotChange::Remove { slot } => {
-                let s = snapshot.slot_data[*slot];
+                let s = snapshot.slot_data[slot];
                 if s.active && s.bank == bank && s.pattern == pattern {
                     Some(false)
                 } else {
@@ -366,14 +367,14 @@ impl App {
             }
         });
 
-        let pending = self.playback.queued_changes.iter().position(|c| match c {
+        let pending = self.playback.queued_changes.iter().position(|c| match *c {
             SlotChange::Add {
                 bank: b,
                 pattern: p,
                 ..
-            } => *b == bank && *p == pattern,
+            } => b == bank && p == pattern,
             SlotChange::Remove { slot } => {
-                let s = snapshot.slot_data[*slot];
+                let s = snapshot.slot_data[slot];
                 s.bank == bank && s.pattern == pattern
             }
         });
@@ -428,7 +429,7 @@ impl App {
 
     pub fn save(&mut self, path: PathBuf) {
         self.save_editor_to_step();
-        match file::save(&self.project_state.project, &path) {
+        match model::save(&self.project_state.project, &path) {
             Ok(()) => {
                 self.ui.set_status(format!("Saved: {}", path.display()));
                 self.project_state.file_path = Some(path);
@@ -440,7 +441,7 @@ impl App {
     }
 
     pub fn load(&mut self, path: PathBuf, link: &LinkState) {
-        match file::load(&path) {
+        match model::load(&path) {
             Ok(project) => {
                 self.project_state.project = project;
                 self.editor_ctx.step = 0;
@@ -663,4 +664,49 @@ impl App {
             },
         }
     }
+
+    pub fn flush_queued_changes(&mut self, cmd_tx: &Sender<SeqCommand>) {
+        for change in self.playback.queued_changes.drain(..) {
+            match change {
+                SlotChange::Add {
+                    slot,
+                    bank,
+                    pattern,
+                } => {
+                    let _ = cmd_tx.send(SeqCommand::SlotAdd {
+                        slot,
+                        bank,
+                        pattern,
+                    });
+                }
+                SlotChange::Remove { slot } => {
+                    let _ = cmd_tx.send(SeqCommand::SlotRemove { slot });
+                }
+            }
+        }
+    }
+
+    pub fn flush_dirty_patterns(&mut self, cmd_tx: &Sender<SeqCommand>) {
+        for (bank, pattern) in self.project_state.take_dirty() {
+            let pat = self.project_state.project.pattern_at(bank, pattern);
+            let snapshot = PatternSnapshot {
+                speed: pat.speed,
+                length: pat.length,
+                steps: pat
+                    .steps
+                    .iter()
+                    .take(pat.length)
+                    .map(|s| StepSnapshot {
+                        active: s.active,
+                        script: s.script.clone(),
+                    })
+                    .collect(),
+            };
+            let _ = cmd_tx.send(SeqCommand::PatternUpdate {
+                bank,
+                pattern,
+                data: snapshot,
+            });
+        }
+    }
 }