bye launcher

src/model/launcher.rs

@@ -1,184 +0,0 @@
-use crate::{core::*, model::*};
-pub enum LauncherMode {
-    Tracks,
-    Sequencer,
-    Chains
-}
-impl LauncherMode {
-    pub fn is_chains (&self) -> bool {
-        match self { Self::Chains => true, _ => false }
-    }
-    pub fn is_tracks (&self) -> bool {
-        match self { Self::Tracks => true, _ => false }
-    }
-    pub fn is_sequencer (&self) -> bool {
-        match self { Self::Sequencer => true, _ => false }
-    }
-}
-pub struct Launcher {
-    pub name:          String,
-    pub timebase:      Arc<Timebase>,
-    pub transport:     ::jack::Transport,
-    pub playing:       TransportState,
-    pub monitoring:    bool,
-    pub recording:     bool,
-    pub overdub:       bool,
-    pub current_frame: usize,
-    pub cursor:        (usize, usize),
-    pub tracks:    Vec<Track>,
-    pub scenes:        Vec<Scene>,
-    pub show_help:     bool,
-    pub view:          LauncherMode,
-}
-render!(Launcher = crate::view::launcher::render);
-handle!(Launcher = crate::control::launcher::handle);
-process!(Launcher |self, _client, _scope| {
-    let transport = self.transport.query().unwrap();
-    self.playing = transport.state;
-    self.current_frame = transport.pos.frame() as usize;
-    Control::Continue
-});
-impl PortList for Launcher {}
-impl Launcher {
-    pub fn new (
-        name:     &str,
-        timebase: &Arc<Timebase>,
-        tracks:   Option<Vec<Track>>,
-        scenes:   Option<Vec<Scene>>
-    ) -> Result<Self, Box<dyn Error>> {
-        let (client, _) = Client::new(name, ClientOptions::NO_START_SERVER)?;
-        let transport = client.transport();
-        let ppq = timebase.ppq() as usize;
-        Ok(Self {
-            name:       name.into(),
-            view:       LauncherMode::Chains,
-            playing:    transport.query_state()?,
-            transport,
-            timebase:   timebase.clone(),
-            monitoring: true,
-            recording:  false,
-            overdub:    true,
-            cursor:     (2, 2),
-            current_frame: 0,
-            scenes: scenes.unwrap_or_else(||vec![Scene::new(&"Scene 1", &[None])]),
-            tracks: vec![]/*if let Some(tracks) = tracks { tracks } else { vec![
-                Track::new("Track 1", &timebase, None, Some(vec![
-                    Phrase::new("MIDI Clip 1", ppq * 4, Some(BTreeMap::from([
-                      ( ppq * 0, vec![MidiMessage::NoteOn { key: 36.into(), vel: 100.into() }] ),
-                      ( ppq * 1, vec![MidiMessage::NoteOn { key: 36.into(), vel: 100.into() }] ),
-                      ( ppq * 2, vec![MidiMessage::NoteOn { key: 36.into(), vel: 100.into() }] ),
-                      ( ppq * 3, vec![MidiMessage::NoteOn { key: 36.into(), vel: 100.into() }] ),
-                    ])))
-                ]))?,
-            ] }*/,
-            show_help: true,
-        })
-    }
-    pub fn connect (&self, midi_in: &str, audio_outs: &[&str]) -> Usually<()> {
-        let (client, _status) = Client::new(
-            &format!("{}-init", &self.name), ClientOptions::NO_START_SERVER
-        )?;
-        let midi_ins = client.ports(Some(midi_in), None, PortFlags::IS_OUTPUT);
-        let audio_outs: Vec<Vec<String>> = audio_outs.iter()
-            .map(|pattern|client.ports(Some(pattern), None, PortFlags::IS_INPUT))
-            .collect();
-        for (i, sequencer) in self.tracks.iter().enumerate() {
-            for sequencer_midi_in in sequencer.midi_ins()?.iter() {
-                for midi_in in midi_ins.iter() {
-                    client.connect_ports_by_name(&midi_in, &sequencer_midi_in)?;
-                }
-            }
-            let chain: &Chain = &self.tracks[i].chain;
-            for port in sequencer.midi_outs()?.iter() {
-                for midi_in in chain.midi_ins()?.iter() {
-                    client.connect_ports_by_name(&port, &midi_in)?;
-                }
-            }
-            for (j, port) in chain.audio_outs()?.iter().enumerate() {
-                for audio_out in audio_outs[j % audio_outs.len()].iter() {
-                    client.connect_ports_by_name(&port, &audio_out)?;
-                }
-            }
-        }
-        Ok(())
-    }
-    pub fn cols (&self) -> usize {
-        (self.tracks.len() + 2) as usize
-    }
-    pub fn col (&self) -> usize {
-        self.cursor.0 as usize
-    }
-    pub fn dec_col (&mut self) {
-        self.cursor.0 = if self.cursor.0 > 0 {
-            self.cursor.0 - 1
-        } else {
-            (self.cols() - 1) as usize
-        }
-    }
-    pub fn inc_col (&mut self) {
-        self.cursor.0 = if self.cursor.0 >= self.cols() - 1 {
-            0
-        } else {
-            self.cursor.0 + 1
-        }
-    }
-    pub fn rows (&self) -> usize {
-        (self.scenes.len() + 2) as usize
-    }
-    pub fn row (&self) -> usize {
-        self.cursor.1 as usize
-    }
-    pub fn dec_row (&mut self) {
-        self.cursor.1 = if self.cursor.1 > 0 {
-            self.cursor.1 - 1
-        } else {
-            self.rows() - 1
-        }
-    }
-    pub fn inc_row (&mut self) {
-        self.cursor.1 = if self.cursor.1 >= self.rows() - 1 {
-            0
-        } else {
-            self.cursor.1 + 1
-        }
-    }
-
-    pub fn track (&self) -> Option<(usize, &Track)> {
-        match self.col() { 0 => None, _ => {
-            let id = self.col() as usize - 1;
-            self.tracks.get(id).map(|t|(id, t))
-        } }
-    }
-    pub fn track_mut (&mut self) -> Option<(usize, &mut Track)> {
-        match self.col() { 0 => None, _ => {
-            let id = self.col() as usize - 1;
-            self.tracks.get_mut(id).map(|t|(id, t))
-        } }
-    }
-    pub fn scene (&self) -> Option<(usize, &Scene)> {
-        match self.row() { 0 => None, _ => {
-            let id = self.row() as usize - 1;
-            self.scenes.get(id).map(|t|(id, t))
-        } }
-    }
-    pub fn scene_mut (&mut self) -> Option<(usize, &mut Scene)> {
-        match self.row() { 0 => None, _ => {
-            let id = self.row() as usize - 1;
-            self.scenes.get_mut(id).map(|t|(id, t))
-        } }
-    }
-    pub fn sequencer (&self) -> Option<&Sequencer> {
-        Some(&self.track()?.1.sequencer)
-    }
-    pub fn sequencer_mut (&mut self) -> Option<&mut Sequencer> {
-        Some(&mut self.track_mut()?.1.sequencer)
-    }
-    pub fn chain (&self) -> Option<&Chain> {
-        Some(&self.track()?.1.chain)
-    }
-    pub fn phrase_id (&self) -> Option<usize> {
-        let (track_id, _) = self.track()?;
-        let (_, scene) = self.scene()?;
-        *scene.clips.get(track_id)?
-    }
-}

src/model/phrase.rs

@@ -127,3 +127,12 @@ impl Phrase {
     }
 
 }
+
+#[macro_export] macro_rules! phrase {
+    ($($t:expr => $msg:expr),* $(,)?) => {{
+        let mut phrase = BTreeMap::new();
+        $(phrase.insert($t, vec![]);)*
+        $(phrase.get_mut(&$t).unwrap().push($msg);)*
+        phrase
+    }}
+}