remove ArrangerMode and Arranger::new

Justfile

@@ -1,6 +1,21 @@
 default:
   bacon -sj test
 
+edn:
+  reset
+  cargo run --example edn
+
+test:
+  reset
+  cd engine && cargo test && cd ..
+  cd layout && cargo test && cd ..
+  cd edn && cargo test && cd ..
+  cd tui && cargo test && cd ..
+  cargo test
+
+cloc:
+  for src in {cli,edn/src,input/src,jack/src,midi/src,output/src,tek/src,time/src,tui/src}; do echo $src; cloc $src; done
+
 status:
   cargo c
   cloc --by-file src/
@@ -99,18 +114,3 @@ sampler:
   {{debug}} sampler
 plugin:
   {{debug}} plugin
-
-edn:
-  reset
-  cargo run --example edn
-
-test:
-  reset
-  cd engine && cargo test && cd ..
-  cd layout && cargo test && cd ..
-  cd edn && cargo test && cd ..
-  cd tui && cargo test && cd ..
-  cargo test
-
-cloc:
-  for src in {cli/src,edn/src,examples,input/src,jack/src,midi/src,output/src,time/src,tui/src,src}; do echo $src; cloc $src; done

cli/tek.rs

@@ -75,32 +75,38 @@ pub fn main () -> Usually<()> {
     let left_tos    = PortConnection::collect(&cli.left_to,    empty, empty);
     let right_froms = PortConnection::collect(&cli.right_from, empty, empty);
     let right_tos   = PortConnection::collect(&cli.right_to,   empty, empty);
+    let perf        = PerfModel::default();
+    let size        = Measure::new();
+    let default_clip = ||{
+        let len   = 384usize;
+        let color = ItemColor::random().into();
+        Arc::new(RwLock::new(MidiClip::new("Clip", true, len, None, Some(color))))
+    };
     Ok(match cli.mode {
 
         TekMode::Clock => engine.run(&jack.activate_with(|jack|Ok(TransportTui {
+            jack:  jack.clone(),
             clock: Clock::from(jack),
-            jack:  jack.clone()
         }))?)?,
 
         TekMode::Sequencer => engine.run(&jack.activate_with(|jack|Ok({
-            let length = 384;
+            let clip   = default_clip();
-            let color  = Some(ItemColor::random().into());
-            let clip   = Arc::new(RwLock::new(MidiClip::new("Clip", true, length, None, color)));
             let player = MidiPlayer::new(&jack, name, Some(&clip), &midi_froms, &midi_tos)?;
             Sequencer {
                 _jack:     jack.clone(),
                 clock:     player.clock.clone(),
+
                 player,
                 editor:    MidiEditor::from(&clip),
                 pool:      PoolModel::from(&clip),
                 compact:   true,
                 transport: true,
                 selectors: true,
-                size:      Measure::new(),
                 midi_buf:  vec![vec![];65536],
                 note_buf:  vec![],
-                perf:      PerfModel::default(),
                 status:    true,
+                perf,
+                size,
             }
         }))?)?,
 
@@ -109,35 +115,34 @@ pub fn main () -> Usually<()> {
                 cursor:  (0, 0),
                 editing: None,
                 mode:    None,
-                size:    Measure::new(),
                 note_lo: 36.into(),
                 note_pt: 36.into(),
                 color:   ItemPalette::from(Color::Rgb(64, 128, 32)),
                 state:   Sampler::new(jack, &"sampler", &midi_froms,
                     &[&left_froms, &right_froms], &[&left_tos, &right_tos])?,
+                size,
             }
         ))?)?,
 
         TekMode::Groovebox => engine.run(&jack.activate_with(|jack|Ok({
-            let length  = 384;
+            let clip    = default_clip();
-            let color   = Some(ItemColor::random().into());
-            let clip    = Arc::new(RwLock::new(MidiClip::new("Clip", true, length, None, color)));
             let player  = MidiPlayer::new(jack, &"sequencer", Some(&clip), &midi_froms, &midi_tos)?;
             let sampler = Sampler::new(jack, &"sampler", &midi_froms,
                 &[&left_froms, &right_froms], &[&left_tos, &right_tos])?;
             jack.read().unwrap().client().connect_ports(&player.midi_outs[0].port, &sampler.midi_in.port)?;
             let app = Groovebox {
+                _jack:    jack.clone(),
+
                 player,
                 sampler,
                 pool:     PoolModel::from(&clip),
                 editor:   MidiEditor::from(&clip),
                 compact:  true,
                 status:   true,
-                size:     Measure::new(),
                 midi_buf: vec![vec![];65536],
                 note_buf: vec![],
-                perf:     PerfModel::default(),
+                perf,
-                _jack:    jack.clone(),
+                size,
             };
             if let Some(bpm) = cli.bpm {
                 app.clock().timebase.bpm.set(bpm);
@@ -159,7 +164,25 @@ pub fn main () -> Usually<()> {
 
         TekMode::Arranger { scenes, tracks, track_width, .. } =>
             engine.run(&jack.activate_with(|jack|Ok({
-                let mut app = Arranger::new(jack);
+                let clock = Clock::from(jack);
+                let clip  = default_clip();
+                let mut app = Arranger {
+                    jack:      jack.clone(),
+                    clock,
+
+                    pool:      (&clip).into(),
+                    editor:    (&clip).into(),
+                    selected:  ArrangerSelection::Clip(0, 0),
+                    scenes:    vec![],
+                    tracks:    vec![],
+                    color:     ItemPalette::random(),
+                    splits:    [12, 20],
+                    midi_buf:  vec![vec![];65536],
+                    note_buf:  vec![],
+                    compact:   true,
+                    perf,
+                    size,
+                };
                 app.tracks_add(tracks, track_width, &midi_froms, &midi_tos)?;
                 app.scenes_add(scenes)?;
                 app

tek/src/arranger.rs

@@ -1,23 +1,21 @@
 use crate::*;
 
-mod arranger_command; pub(crate) use self::arranger_command::*;
+mod arranger_command; pub use self::arranger_command::*;
-mod arranger_scene;   pub(crate) use self::arranger_scene::*;
+mod arranger_scene;   pub use self::arranger_scene::*;
-mod arranger_select;  pub(crate) use self::arranger_select::*;
+mod arranger_select;  pub use self::arranger_select::*;
-mod arranger_track;   pub(crate) use self::arranger_track::*;
+mod arranger_track;   pub use self::arranger_track::*;
-mod arranger_tui;     pub(crate) use self::arranger_tui::*;
+mod arranger_tui;     pub use self::arranger_tui::*;
-mod arranger_mode;    pub(crate) use self::arranger_mode::*;
 mod arranger_h;
 
 /// Root view for standalone `tek_arranger`
 pub struct Arranger {
-    jack:         Arc<RwLock<JackConnection>>,
+    pub jack:     Arc<RwLock<JackConnection>>,
     pub clock:    Clock,
     pub pool:     PoolModel,
     pub tracks:   Vec<ArrangerTrack>,
     pub scenes:   Vec<ArrangerScene>,
     pub splits:   [u16;2],
     pub selected: ArrangerSelection,
-    pub mode:     ArrangerMode,
     pub color:    ItemPalette,
     pub size:     Measure<TuiOut>,
     pub note_buf: Vec<u8>,
@@ -67,30 +65,6 @@ has_phrases!(|self: Arranger|self.pool.phrases);
 has_editor!(|self: Arranger|self.editor);
 handle!(TuiIn: |self: Arranger, input|ArrangerCommand::execute_with_state(self, input.event()));
 impl Arranger {
-    pub fn new (jack: &Arc<RwLock<JackConnection>>) -> 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())
-        )));
-        Self {
-            clock,
-            pool:      (&phrase).into(),
-            editor:    (&phrase).into(),
-            selected:  ArrangerSelection::Clip(0, 0),
-            scenes:    vec![],
-            tracks:    vec![],
-            color:     ItemPalette::random(),
-            mode:      ArrangerMode::V(1),
-            size:      Measure::new(),
-            splits:    [12, 20],
-            midi_buf:  vec![vec![];65536],
-            note_buf:  vec![],
-            perf:      PerfModel::default(),
-            jack:      jack.clone(),
-            compact:   true,
-        }
-    }
     pub fn selected (&self) -> ArrangerSelection {
         self.selected
     }

tek/src/arranger/arranger_mode.rs

@@ -1,26 +0,0 @@
-use crate::*;
-/// Display mode of arranger
-#[derive(Clone, PartialEq)]
-pub enum ArrangerMode {
-    /// Tracks are columns
-    V(usize),
-    /// Tracks are rows
-    H,
-}
-impl<E: Output> Content<E> for ArrangerMode {}
-/// Arranger display mode can be cycled
-impl ArrangerMode {
-    /// Cycle arranger display mode
-    pub fn next (&mut self) {
-        *self = match self {
-            Self::H    => Self::V(1),
-            Self::V(1) => Self::V(2),
-            Self::V(2) => Self::V(2),
-            Self::V(0) => Self::H,
-            Self::V(_) => Self::V(0),
-        }
-    }
-}
-fn any_size <E: Output> (_: E::Size) -> Perhaps<E::Size>{
-    Ok(Some([0.into(),0.into()].into()))
-}