delegate more control to transport items

crates/tek_sequencer/src/transport.rs

@@ -32,6 +32,7 @@ impl<E: Engine> TransportToolbar<E> {
             Client::new("tek_transport", ClientOptions::NO_START_SERVER)?.0
         );
         transport.transport = Some(jack.transport());
+        transport.playing.transport = Some(jack.transport());
         let transport = Arc::new(RwLock::new(transport));
         transport.write().unwrap().jack = Some(
             jack.activate(
@@ -51,8 +52,9 @@ impl<E: Engine> TransportToolbar<E> {
 
             playing:   TransportPlayPauseButton {
                 _engine: Default::default(),
-                value:   Some(TransportState::Stopped),
-                focused: true
+                transport: None,
+                value:     Some(TransportState::Stopped),
+                focused:   true
             },
             bpm:       TransportBPM {
                 _engine: Default::default(),
@@ -86,18 +88,7 @@ impl<E: Engine> TransportToolbar<E> {
         }
     }
     pub fn toggle_play (&mut self) -> Usually<()> {
-        let transport = self.transport.as_ref().unwrap();
-        self.playing.value = match self.playing.value.expect("1st frame has not been processed yet") {
-            TransportState::Stopped => {
-                transport.start()?;
-                Some(TransportState::Starting)
-            },
-            _ => {
-                transport.stop()?;
-                transport.locate(0)?;
-                Some(TransportState::Stopped)
-            },
-        };
+        self.playing.toggle();
         Ok(())
     }
     pub fn update (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, usize, f64) {
@@ -148,6 +139,12 @@ impl<E: Engine> TransportToolbar<E> {
     pub fn usecs (&self) -> usize {
         self.timebase.frame_to_usec(self.clock.frame as f64) as usize
     }
+    pub fn quant (&self) -> usize {
+        self.quant.value
+    }
+    pub fn sync (&self) -> usize {
+        self.sync.value
+    }
 }
 impl Focus<5, Tui> for TransportToolbar<Tui> {
     fn focus (&self) -> usize {
@@ -222,8 +219,26 @@ impl Content for TransportToolbar<Tui> {
 
 pub struct TransportPlayPauseButton<E: Engine> {
     pub _engine: PhantomData<E>,
-    pub value:   Option<TransportState>,
-    pub focused: bool
+    pub transport: Option<Transport>,
+    pub value:     Option<TransportState>,
+    pub focused:   bool
+}
+impl<E: Engine> TransportPlayPauseButton<E> {
+    fn toggle (&mut self) -> Usually<()> {
+        let transport = self.transport.as_ref().unwrap();
+        self.value = match self.value.expect("1st frame has not been processed yet") {
+            TransportState::Stopped => {
+                transport.start()?;
+                Some(TransportState::Starting)
+            },
+            _ => {
+                transport.stop()?;
+                transport.locate(0)?;
+                Some(TransportState::Stopped)
+            },
+        };
+        Ok(())
+    }
 }
 impl Focusable<Tui> for TransportPlayPauseButton<Tui> {
     fn is_focused (&self) -> bool {
@@ -233,6 +248,34 @@ impl Focusable<Tui> for TransportPlayPauseButton<Tui> {
         self.focused = focused
     }
 }
+impl Handle<Tui> for TransportPlayPauseButton<Tui> {
+    fn handle (&mut self, from: &Tui) -> Perhaps<bool> {
+        match from.event() {
+            key!(KeyCode::Enter) => self.toggle().map(|_|Some(true)),
+            _ => Ok(None)
+        }
+    }
+}
+impl Content for TransportPlayPauseButton<Tui> {
+    type Engine = Tui;
+    fn content (&self) -> impl Widget<Engine = Tui> {
+        Layers::new(|add|{
+            //add(&self.focused.then_some(CORNERS))?;
+            add(&Styled(match self.value {
+                Some(TransportState::Stopped)  => Some(GRAY_DIM.bold()),
+                Some(TransportState::Starting) => Some(GRAY_NOT_DIM_BOLD),
+                Some(TransportState::Rolling)  => Some(WHITE_NOT_DIM_BOLD),
+                _ => unreachable!(),
+            }, match self.value {
+                Some(TransportState::Rolling)  => "▶ PLAYING",
+                Some(TransportState::Starting) => "READY ...",
+                Some(TransportState::Stopped)  => "⏹ STOPPED",
+                _ => unreachable!(),
+            }))?;
+            Ok(())
+        })
+    }
+}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -253,11 +296,19 @@ impl Handle<Tui> for TransportBPM<Tui> {
     fn handle (&mut self, from: &Tui) -> Perhaps<bool> {
         match from.event() {
             key!(KeyCode::Char(',')) => {
-                self.bpm().fetch_sub(1.0, Ordering::Relaxed);
+                self.value += 1.0;
                 Ok(Some(true))
             },
             key!(KeyCode::Char('.')) => {
-                self.bpm().fetch_add(1.0, Ordering::Relaxed);
+                self.value -= 1.0;
+                Ok(Some(true))
+            },
+            key!(KeyCode::Char('<')) => {
+                self.value += 0.001;
+                Ok(Some(true))
+            },
+            key!(KeyCode::Char('>')) => {
+                self.value -= 0.001;
                 Ok(Some(true))
             },
             _ => Ok(None)
@@ -307,11 +358,11 @@ impl Handle<Tui> for TransportQuantize<Tui> {
     fn handle (&mut self, from: &Tui) -> Perhaps<bool> {
         match from.event() {
             key!(KeyCode::Char(',')) => {
-                transport.quant.value = prev_note_length(transport.quant);
+                self.value = prev_note_length(self.value);
                 Ok(Some(true))
             },
             key!(KeyCode::Char('.')) => {
-                transport.quant.value = next_note_length(transport.quant);
+                self.value = next_note_length(self.value);
                 Ok(Some(true))
             },
             _ => Ok(None)
@@ -360,11 +411,11 @@ impl Handle<Tui> for TransportSync<Tui> {
     fn handle (&mut self, from: &Tui) -> Perhaps<bool> {
         match from.event() {
             key!(KeyCode::Char(',')) => {
-                transport.sync.value = prev_note_length(transport.quant);
+                self.value = prev_note_length(self.value);
                 Ok(Some(true))
             },
             key!(KeyCode::Char('.')) => {
-                transport.sync.value = next_note_length(transport.quant);
+                self.value = next_note_length(self.value);
                 Ok(Some(true))
             },
             _ => Ok(None)
@@ -444,34 +495,3 @@ impl Widget for TransportClock<Tui> {
         Ok(Some(area))
     }
 }
-impl Handle<Tui> for TransportPlayPauseButton<Tui> {
-    fn handle (&mut self, from: &Tui) -> Perhaps<bool> {
-        match from.event() {
-            key!(KeyCode::Enter) => {
-                self.toggle();
-                Ok(Some(true))
-            }
-            _ => Ok(None)
-        }
-    }
-}
-impl Content for TransportPlayPauseButton<Tui> {
-    type Engine = Tui;
-    fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers::new(|add|{
-            //add(&self.focused.then_some(CORNERS))?;
-            add(&Styled(match self.value {
-                Some(TransportState::Stopped)  => Some(GRAY_DIM.bold()),
-                Some(TransportState::Starting) => Some(GRAY_NOT_DIM_BOLD),
-                Some(TransportState::Rolling)  => Some(WHITE_NOT_DIM_BOLD),
-                _ => unreachable!(),
-            }, match self.value {
-                Some(TransportState::Rolling)  => "▶ PLAYING",
-                Some(TransportState::Starting) => "READY ...",
-                Some(TransportState::Stopped)  => "⏹ STOPPED",
-                _ => unreachable!(),
-            }))?;
-            Ok(())
-        })
-    }
-}