unify cli

src/arranger/arranger_scene.rs

@@ -24,6 +24,16 @@ impl Arranger {
     pub fn selected_scene_mut (&mut self) -> Option<&mut ArrangerScene> {
         self.selected.scene().and_then(|s|self.scenes.get_mut(s))
     }
+    pub fn scenes_add (&mut self, n: usize) -> Usually<()> {
+        let scene_color_1 = ItemColor::random();
+        let scene_color_2 = ItemColor::random();
+        for i in 0..n {
+            let _scene = self.scene_add(None, Some(
+                scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
+            ))?;
+        }
+        Ok(())
+    }
 }
 #[derive(Default, Debug, Clone)] pub struct ArrangerScene {
     /// Name of scene

src/arranger/arranger_track.rs

@@ -23,6 +23,77 @@ impl Arranger {
             scene.clips.remove(index);
         }
     }
+    pub fn tracks_add (
+        &mut self,
+        count: usize,
+        width: usize,
+        midi_from: &[impl AsRef<str>],
+        midi_to:   &[impl AsRef<str>],
+    ) -> Usually<()> {
+        let jack = self.jack.clone();
+        let track_color_1 = ItemColor::random();
+        let track_color_2 = ItemColor::random();
+        for i in 0..count {
+            let color = track_color_1.mix(track_color_2, i as f32 / count as f32).into();
+            let mut track = self.track_add(None, Some(color))?;
+            track.width = width;
+
+            let name = &format!("{}I", &track.name);
+            let port = jack.read().unwrap().client().register_port(&name, MidiIn::default())?;
+            track.player.midi_ins.push(port);
+
+            let name = &format!("{}O", &track.name);
+            let port = jack.read().unwrap().client().register_port(&name, MidiOut::default())?;
+            track.player.midi_outs.push(port);
+        }
+        for connection in midi_from.iter() {
+            let mut split = connection.as_ref().split("=");
+            let number = split.next().unwrap().trim();
+            if let Ok(track) = number.parse::<usize>() {
+                if track < 1 {
+                    panic!("Tracks are zero-indexed")
+                }
+                if track > count {
+                    panic!("Tried to connect track {track} or {count}. Pass -t {track} to increase number of tracks.")
+                }
+                if let Some(port) = split.next() {
+                    if let Some(port) = jack.read().unwrap().client().port_by_name(port).as_ref() {
+                        jack.read().unwrap().client().connect_ports(port, &self.tracks[track-1].player.midi_ins[0])?;
+                    } else {
+                        panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+                    }
+                } else {
+                    panic!("No port specified for track {track}. Format is TRACK_NUMBER=PORT_NAME")
+                }
+            } else {
+                panic!("Failed to parse track number: {number}")
+            }
+        }
+        for connection in midi_to.iter() {
+            let mut split = connection.as_ref().split("=");
+            let number = split.next().unwrap().trim();
+            if let Ok(track) = number.parse::<usize>() {
+                if track < 1 {
+                    panic!("Tracks are zero-indexed")
+                }
+                if track > count {
+                    panic!("Tried to connect track {track} or {count}. Pass -t {track} to increase number of tracks.")
+                }
+                if let Some(port) = split.next() {
+                    if let Some(port) = jack.read().unwrap().client().port_by_name(port).as_ref() {
+                        jack.read().unwrap().client().connect_ports(&self.tracks[track-1].player.midi_outs[0], port)?;
+                    } else {
+                        panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+                    }
+                } else {
+                    panic!("No port specified for track {track}. Format is TRACK_NUMBER=PORT_NAME")
+                }
+            } else {
+                panic!("Failed to parse track number: {number}")
+            }
+        }
+        Ok(())
+    }
 }
 #[derive(Debug)] pub struct ArrangerTrack {
     /// Name of track

src/sequencer.rs

@@ -23,30 +23,32 @@ pub struct Sequencer {
     pub midi_buf:  Vec<Vec<Vec<u8>>>,
     pub perf:      PerfModel,
 }
-from_jack!(|jack|Sequencer {
-    let clock = Clock::from(jack);
-    let phrase = Arc::new(RwLock::new(MidiClip::new(
-        "Clip", true, 4 * clock.timebase.ppq.get() as usize,
-        None, Some(ItemColor::random().into())
-    )));
-    Self {
-        _jack: jack.clone(),
+impl Sequencer {
+    pub fn new (jack: &Arc<RwLock<JackConnection>>) -> Usually<Self> {
+        let clock = Clock::from(jack);
+        let phrase = Arc::new(RwLock::new(MidiClip::new(
+            "Clip", true, 4 * clock.timebase.ppq.get() as usize,
+            None, Some(ItemColor::random().into())
+        )));
+        Ok(Self {
+            _jack: jack.clone(),
 
-        pool:   PoolModel::from(&phrase),
-        editor: MidiEditor::from(&phrase),
-        player: MidiPlayer::from((&clock, &phrase)),
+            pool:   PoolModel::from(&phrase),
+            editor: MidiEditor::from(&phrase),
+            player: MidiPlayer::from((&clock, &phrase)),
 
-        compact:   true,
-        transport: true,
-        selectors: true,
-        size:      Measure::new(),
-        midi_buf:  vec![vec![];65536],
-        note_buf:  vec![],
-        perf:      PerfModel::default(),
-        status:    true,
-        clock,
+            compact:   true,
+            transport: true,
+            selectors: true,
+            size:      Measure::new(),
+            midi_buf:  vec![vec![];65536],
+            note_buf:  vec![],
+            perf:      PerfModel::default(),
+            status:    true,
+            clock,
+        })
     }
-});
+}
 render!(TuiOut: (self: Sequencer) => self.size.of(
     Bsp::s(self.toolbar_view(),
     Bsp::n(self.selector_view(),