no more mode-specific constructors

cli/Cargo.toml

@@ -5,7 +5,6 @@ version = "0.2.0"
 
 [dependencies]
 tek = { workspace = true }
-
 clap = { workspace = true }
 
 [[bin]]

cli/tek.rs

@@ -1,4 +1,5 @@
-pub use tek::*;
+pub(crate) use tek::*;
+pub(crate) use std::sync::{Arc, RwLock};
 pub(crate) use clap::{self, Parser, Subcommand};
 /// Application entrypoint.
 pub fn main () -> Usually<()> {
@@ -64,9 +65,7 @@ pub struct Cli {
 impl Cli {
     pub fn run (&self) -> Usually<()> {
         let name        = self.name.as_ref().map_or("tek", |x|x.as_str());
-        //let color       = ItemPalette::random();
-        let jack        = Jack::new(name)?;
-        let engine      = Tui::new()?;
+        let mode        = &self.mode;
         let empty       = &[] as &[&str];
         let midi_froms  = PortConnect::collect(&self.midi_from,  empty, &self.midi_from_re);
         let midi_tos    = PortConnect::collect(&self.midi_to,    empty, &self.midi_to_re);
@@ -74,27 +73,98 @@ impl Cli {
         let left_tos    = PortConnect::collect(&self.left_to,    empty, empty);
         let right_froms = PortConnect::collect(&self.right_from, empty, empty);
         let right_tos   = PortConnect::collect(&self.right_to,   empty, empty);
-        let audio_froms = &[left_froms.as_slice(), right_froms.as_slice()];
-        let audio_tos   = &[left_tos.as_slice(),   right_tos.as_slice()  ];
-        let jack = jack.run(|jack|match self.mode {
-            Mode::Clock => Tek::new_clock(
-                jack, self.bpm, self.sync_lead, self.sync_follow,
-                &midi_froms, &midi_tos),
-            Mode::Sequencer => Tek::new_sequencer(
-                jack, self.bpm, self.sync_lead, self.sync_follow,
-                &midi_froms, &midi_tos),
-            Mode::Groovebox => Tek::new_groovebox(
-                jack, self.bpm, self.sync_lead, self.sync_follow,
-                &midi_froms, &midi_tos,
-                &audio_froms, &audio_tos),
-            Mode::Arranger { scenes, tracks, track_width, .. } => Tek::new_arranger(
-                jack, self.bpm, self.sync_lead, self.sync_follow,
-                &midi_froms, &midi_tos,
-                &audio_froms, &audio_tos,
-                scenes, tracks, track_width),
-            _ => todo!()
+        let audio_froms = &[
+            left_froms.as_slice(),
+            right_froms.as_slice()
+        ];
+        let audio_tos   = &[left_tos.as_slice(), right_tos.as_slice()];
+        let clip = match mode {
+            Mode::Sequencer | Mode::Groovebox => Some(Arc::new(RwLock::new(MidiClip::new(
+                "Clip", true, 384usize, None, Some(ItemColor::random().into())),
+            ))),
+            _ => None,
+        };
+        let scenes = vec![];
+        let jack = Jack::new(name)?;
+        let jack = jack.run(|jack|{
+            let mut midi_ins  = vec![];
+            let mut midi_outs = vec![];
+            for (index, connect) in midi_froms.iter().enumerate() {
+                let port = JackMidiIn::new(jack, &format!("M/{index}"), &[connect.clone()])?;
+                midi_ins.push(port);
+            }
+            for (index, connect) in midi_tos.iter().enumerate() {
+                let port = JackMidiOut::new(jack, &format!("{index}/M"), &[connect.clone()])?;
+                midi_outs.push(port);
+            }
+            let mut app = Tek {
+                jack: jack.clone(),
+                view: SourceIter(match mode {
+                    Mode::Clock           => include_str!("./view_transport.edn"),
+                    Mode::Sequencer       => include_str!("./view_sequencer.edn"),
+                    Mode::Groovebox       => include_str!("./view_groovebox.edn"),
+                    Mode::Arranger { .. } => include_str!("./view_arranger.edn"),
+                    _ => todo!("{mode:?}"),
+                }),
+                pool: match mode {
+                    Mode::Sequencer | Mode::Groovebox => clip.as_ref().map(Into::into),
+                    Mode::Arranger { .. } => Some(Default::default()),
+                    _ => None,
+                },
+                editor: match mode {
+                    Mode::Sequencer | Mode::Groovebox => clip.as_ref().map(Into::into),
+                    Mode::Arranger { .. } => Some(Default::default()),
+                    _ => None
+                },
+                midi_ins,
+                midi_outs,
+                midi_buf: match mode {
+                    Mode::Clock => vec![],
+                    Mode::Sequencer | Mode::Groovebox | Mode::Arranger {..} => vec![vec![];65536],
+                    _ => todo!("{mode:?}"),
+                },
+                color:      ItemPalette::random(),
+                clock:      Clock::new(jack, self.bpm)?,
+                keys:       SourceIter(KEYS_APP),
+                keys_clip:  SourceIter(KEYS_CLIP),
+                keys_track: SourceIter(KEYS_TRACK),
+                keys_scene: SourceIter(KEYS_SCENE),
+                keys_mix:   SourceIter(KEYS_MIX),
+                tracks: match mode {
+                    Mode::Sequencer => vec![Track::default()],
+                    Mode::Groovebox => vec![Track {
+                        devices: vec![
+                            Sampler::new(
+                                jack,
+                                &"sampler",
+                                midi_froms.as_slice(),
+                                audio_froms,
+                                audio_tos
+                            )?.boxed()
+                        ],
+                        ..Track::default()
+                    }],
+                    _ => vec![]
+                },
+                scenes,
+                ..Default::default()
+            };
+            if let &Mode::Arranger { scenes, tracks, track_width, .. } = mode {
+                app.arranger = Default::default();
+                app.selected = Selection::Clip(1, 1);
+                app.scenes_add(scenes);
+                app.tracks_add(tracks, Some(track_width), &[], &[]);
+            }
+            jack.sync_lead(self.sync_lead, |mut state|{
+                let clock = app.clock();
+                clock.playhead.update_from_sample(state.position.frame() as f64);
+                state.position.bbt = Some(clock.bbt());
+                state.position
+            });
+            jack.sync_follow(self.sync_follow);
+            Ok(app)
         })?;
-        engine.run(&jack)
+        Tui::new()?.run(&jack)
     }
 }
 

cli/view_arranger.edn

@@ -0,0 +1,4 @@
+(bsp/s (fixed/y 1 :transport)
+  (bsp/n (fixed/y 1 :status)
+    (fill/xy (bsp/a (fill/xy (align/e :pool))
+      :arranger))))

cli/view_groovebox.edn

@@ -0,0 +1,6 @@
+(bsp/s (fixed/y 2 :toolbar)
+  (bsp/s :sample (bsp/n
+    (fixed/y 2 :status)
+    (bsp/w
+      (fixed/x :pool-w :pool)
+      (bsp/e :sampler :editor)))))

cli/view_sequencer.edn

@@ -0,0 +1,4 @@
+(bsp/s (fixed/y 2 :toolbar)
+  (bsp/n (fixed/y 2 :status) (bsp/w
+    (fixed/x :pool-w :pool)
+    :editor)))

cli/view_transport.edn

@@ -0,0 +1 @@
+:transport