no more mode-specific constructors

app/src/model.rs

@@ -44,7 +44,7 @@ mod model_select; pub use self::model_select::*;
     pub keys_scene: SourceIter<'static>,
     pub keys_mix:   SourceIter<'static>,
 
-    pub(crate) fmtd: Arc<RwLock<ViewCache>>,
+    pub fmtd: Arc<RwLock<ViewCache>>,
 }
 has_size!(<TuiOut>|self: Tek|&self.size);
 has_clock!(|self: Tek|self.clock);
@@ -148,129 +148,6 @@ impl Tek {
         Ok(())
     }
 }
-impl Tek {
-    pub fn new_clock (
-        jack: &Jack,
-        bpm: Option<f64>,
-        sync_lead: bool,
-        sync_follow: bool,
-        midi_froms: &[PortConnect],
-        midi_tos: &[PortConnect],
-    ) -> Usually<Self> {
-        let tek = Self {
-            view: SourceIter(include_str!("../edn/view_transport.edn")),
-            jack: jack.clone(),
-            color: ItemPalette::random(),
-            clock: Clock::new(jack, bpm)?,
-            midi_ins: {
-                let mut midi_ins  = vec![];
-                for (index, connect) in midi_froms.iter().enumerate() {
-                    let port = JackMidiIn::new(jack, &format!("M/{index}"), &[connect.clone()])?;
-                    midi_ins.push(port);
-                }
-                midi_ins
-            },
-            midi_outs: {
-                let mut midi_outs = vec![];
-                for (index, connect) in midi_tos.iter().enumerate() {
-                    let port = JackMidiOut::new(jack, &format!("{index}/M"), &[connect.clone()])?;
-                    midi_outs.push(port);
-                }
-                midi_outs
-            },
-            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:     vec![],
-            scenes:     vec![],
-            ..Default::default()
-        };
-        jack.sync_lead(sync_lead, |mut state|{
-            let clock = tek.clock();
-            clock.playhead.update_from_sample(state.position.frame() as f64);
-            state.position.bbt = Some(clock.bbt());
-            state.position
-        });
-        jack.sync_follow(sync_follow);
-        Ok(tek)
-    }
-    pub fn new_sequencer (
-        jack: &Jack,
-        bpm: Option<f64>,
-        sync_lead: bool,
-        sync_follow: bool,
-        midi_froms: &[PortConnect],
-        midi_tos: &[PortConnect],
-    ) -> Usually<Self> {
-        let clip = MidiClip::new("Clip", true, 384usize, None, Some(ItemColor::random().into()));
-        let clip = Arc::new(RwLock::new(clip));
-        let this = Self::new_clock(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?;
-        Ok(Self {
-            view: SourceIter(include_str!("../edn/view_sequencer.edn")),
-            pool: Some((&clip).into()),
-            editor: Some((&clip).into()),
-            editing: false.into(),
-            midi_buf: vec![vec![];65536],
-            tracks: vec![Track::default()],
-            //player: Some(MidiPlayer::new("sequencer", &jack, Some(&this.clock), Some(&clip), &midi_froms, &midi_tos)?),
-            ..this
-        })
-    }
-    pub fn new_groovebox (
-        jack: &Jack,
-        bpm: Option<f64>,
-        sync_lead: bool,
-        sync_follow: bool,
-        midi_froms: &[PortConnect],
-        midi_tos: &[PortConnect],
-        audio_froms: &[&[PortConnect];2],
-        audio_tos: &[&[PortConnect];2],
-    ) -> Usually<Self> {
-        let tek = Self {
-            view: SourceIter(include_str!("../edn/view_groovebox.edn")),
-            tracks: vec![Track {
-                devices: vec![Sampler::new(jack, &"sampler", midi_froms, audio_froms, audio_tos)?.boxed()],
-                ..Track::default()
-            }],
-            ..Self::new_sequencer(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?
-        };
-        //if let Some(sampler) = tek.sampler.as_ref().unwrap().midi_in.as_ref() {
-            //tek.player.as_ref().unwrap().midi_outs[0].connect_to(sampler.port())?;
-        //}
-        Ok(tek)
-    }
-    pub fn new_arranger (
-        jack: &Jack,
-        bpm: Option<f64>,
-        sync_lead: bool,
-        sync_follow: bool,
-        midi_froms: &[PortConnect],
-        midi_tos: &[PortConnect],
-        audio_froms: &[&[PortConnect];2],
-        audio_tos: &[&[PortConnect];2],
-        scenes: usize,
-        tracks: usize,
-        track_width: usize,
-    ) -> Usually<Self> {
-        let mut tek = Self {
-            view: SourceIter(include_str!("../edn/view_arranger.edn")),
-            pool: Some(Default::default()),
-            editor: Some(Default::default()),
-            editing: false.into(),
-            midi_buf: vec![vec![];65536],
-            tracks: vec![],
-            scenes: vec![],
-            ..Self::new_clock(jack, bpm, sync_lead, sync_follow, midi_froms, midi_tos)?
-        };
-        tek.arranger = Default::default();
-        tek.selected = Selection::Clip(1, 1);
-        tek.scenes_add(scenes);
-        tek.tracks_add(tracks, Some(track_width), &[], &[]);
-        Ok(tek)
-    }
-}
 #[cfg(test)] #[test] fn test_model () {
     let mut tek = Tek::default();
     let _ = tek.clip();

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 mode        = &self.mode;
-        let jack        = Jack::new(name)?;
-        let engine      = Tui::new()?;
         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_froms = &[
-        let audio_tos   = &[left_tos.as_slice(),   right_tos.as_slice()  ];
+            left_froms.as_slice(),
-        let jack = jack.run(|jack|match self.mode {
+            right_froms.as_slice()
-            Mode::Clock => Tek::new_clock(
+        ];
-                jack, self.bpm, self.sync_lead, self.sync_follow,
+        let audio_tos   = &[left_tos.as_slice(), right_tos.as_slice()];
-                &midi_froms, &midi_tos),
+        let clip = match mode {
-            Mode::Sequencer => Tek::new_sequencer(
+            Mode::Sequencer | Mode::Groovebox => Some(Arc::new(RwLock::new(MidiClip::new(
-                jack, self.bpm, self.sync_lead, self.sync_follow,
+                "Clip", true, 384usize, None, Some(ItemColor::random().into())),
-                &midi_froms, &midi_tos),
+            ))),
-            Mode::Groovebox => Tek::new_groovebox(
+            _ => None,
-                jack, self.bpm, self.sync_lead, self.sync_follow,
+        };
-                &midi_froms, &midi_tos,
+        let scenes = vec![];
-                &audio_froms, &audio_tos),
+        let jack = Jack::new(name)?;
-            Mode::Arranger { scenes, tracks, track_width, .. } => Tek::new_arranger(
+        let jack = jack.run(|jack|{
-                jack, self.bpm, self.sync_lead, self.sync_follow,
+            let mut midi_ins  = vec![];
-                &midi_froms, &midi_tos,
+            let mut midi_outs = vec![];
-                &audio_froms, &audio_tos,
+            for (index, connect) in midi_froms.iter().enumerate() {
-                scenes, tracks, track_width),
+                let port = JackMidiIn::new(jack, &format!("M/{index}"), &[connect.clone()])?;
-            _ => todo!()
+                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_transport.edn

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