render chain with SplitFocus

src/model/track.rs

@@ -1,6 +1,52 @@
 use crate::core::*;
 use crate::model::*;
 
+impl App {
+    pub fn next_track (&mut self) {
+        self.track_cursor = self.tracks.len().min(self.track_cursor + 1); 
+    }
+    pub fn prev_track (&mut self) {
+        self.track_cursor = self.track_cursor.saturating_sub(1); 
+    }
+
+    pub fn new_track_name (&self) -> String {
+        format!("Track {}", self.tracks.len() + 1)
+    }
+
+    pub fn add_track (&mut self, name: Option<&str>) -> Usually<&mut Track> {
+        let name = name.ok_or_else(||self.new_track_name())?;
+        self.tracks.push(Track::new(&name, None, None)?);
+        self.track_cursor = self.tracks.len();
+        Ok(&mut self.tracks[self.track_cursor - 1])
+    }
+
+    fn add_track_with_cb (
+        &mut self, name: Option<&str>, init: impl FnOnce(&Client, &mut Track)->Usually<()>,
+    ) -> Usually<&mut Track> {
+        let name = name.ok_or_else(||self.new_track_name())?;
+        let mut track = Track::new(&name, None, None)?;
+        init(self.client(), &mut track)?;
+        self.tracks.push(track);
+        self.track_cursor = self.tracks.len();
+        Ok(&mut self.tracks[self.track_cursor - 1])
+    }
+
+    pub fn track (&self) -> Option<(usize, &Track)> {
+        match self.track_cursor { 0 => None, _ => {
+            let id = self.track_cursor as usize - 1;
+            self.tracks.get(id).map(|t|(id, t))
+        } }
+    }
+
+    pub fn track_mut (&mut self) -> Option<(usize, &mut Track)> {
+        match self.track_cursor { 0 => None, _ => {
+            let id = self.track_cursor as usize - 1;
+            self.tracks.get_mut(id).map(|t|(id, t))
+        } }
+    }
+
+}
+
 pub struct Track {
     pub name:       String,
     /// Play input through output.
@@ -29,7 +75,7 @@ pub struct Track {
     pub notes_out:  [bool;128],
 }
 impl Track {
-    pub fn new (
+    fn new (
         name:    &str,
         phrases: Option<Vec<Phrase>>,
         devices: Option<Vec<JackDevice>>,
@@ -50,19 +96,19 @@ impl Track {
             reset:        true,
         })
     }
-    pub fn get_device (&self, i: usize) -> Option<RwLockReadGuard<Box<dyn Device>>> {
+    fn get_device (&self, i: usize) -> Option<RwLockReadGuard<Box<dyn Device>>> {
         self.devices.get(i).map(|d|d.state.read().unwrap())
     }
-    pub fn get_device_mut (&self, i: usize) -> Option<RwLockWriteGuard<Box<dyn Device>>> {
+    fn get_device_mut (&self, i: usize) -> Option<RwLockWriteGuard<Box<dyn Device>>> {
         self.devices.get(i).map(|d|d.state.write().unwrap())
     }
-    pub fn device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
+    fn device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
         self.get_device(self.device)
     }
     pub fn device_mut (&self) -> Option<RwLockWriteGuard<Box<dyn Device>>> {
         self.get_device_mut(self.device)
     }
-    pub fn first_device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
+    fn first_device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
         self.get_device(0)
     }
     pub fn connect_first_device (&self) -> Usually<()> {
@@ -71,7 +117,7 @@ impl Track {
         }
         Ok(())
     }
-    pub fn last_device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
+    fn last_device (&self) -> Option<RwLockReadGuard<Box<dyn Device>>> {
         self.get_device(self.devices.len().saturating_sub(1))
     }
     pub fn connect_last_device (&self, app: &App) -> Usually<()> {
@@ -89,7 +135,7 @@ impl Track {
         let index = self.devices.len() - 1;
         Ok(&mut self.devices[index])
     }
-    pub fn add_device_with_cb (
+    fn add_device_with_cb (
         &mut self,
         mut device: JackDevice,
         init: impl Fn(&Self, &mut JackDevice)->Usually<()>
@@ -99,21 +145,21 @@ impl Track {
         let index = self.devices.len() - 1;
         Ok(&mut self.devices[index])
     }
-    pub fn phrase (&self) -> Option<&Phrase> {
+    fn phrase (&self) -> Option<&Phrase> {
         if let Some(phrase) = self.sequence {
             return self.phrases.get(phrase)
         } else {
             None
         }
     }
-    pub fn phrase_mut (&mut self) -> Option<&mut Phrase> {
+    fn phrase_mut (&mut self) -> Option<&mut Phrase> {
         if let Some(phrase) = self.sequence {
             return self.phrases.get_mut(phrase)
         } else {
             None
         }
     }
-    pub fn add_phrase (
+    fn add_phrase (
         &mut self, name: &str, length: usize, data: Option<PhraseData>
     ) -> &mut Phrase {
         self.phrases.push(Phrase::new(name, length, data));
@@ -243,43 +289,3 @@ impl Track {
         }
     }
 }
-
-impl App {
-
-    pub fn new_track_name (&self) -> String {
-        format!("Track {}", self.tracks.len() + 1)
-    }
-
-    pub fn add_track (&mut self, name: Option<&str>) -> Usually<&mut Track> {
-        let name = name.ok_or_else(||self.new_track_name())?;
-        self.tracks.push(Track::new(&name, None, None)?);
-        self.track_cursor = self.tracks.len();
-        Ok(&mut self.tracks[self.track_cursor - 1])
-    }
-
-    pub fn add_track_with_cb (
-        &mut self, name: Option<&str>, init: impl FnOnce(&Client, &mut Track)->Usually<()>,
-    ) -> Usually<&mut Track> {
-        let name = name.ok_or_else(||self.new_track_name())?;
-        let mut track = Track::new(&name, None, None)?;
-        init(self.client(), &mut track)?;
-        self.tracks.push(track);
-        self.track_cursor = self.tracks.len();
-        Ok(&mut self.tracks[self.track_cursor - 1])
-    }
-
-    pub fn track (&self) -> Option<(usize, &Track)> {
-        match self.track_cursor { 0 => None, _ => {
-            let id = self.track_cursor as usize - 1;
-            self.tracks.get(id).map(|t|(id, t))
-        } }
-    }
-
-    pub fn track_mut (&mut self) -> Option<(usize, &mut Track)> {
-        match self.track_cursor { 0 => None, _ => {
-            let id = self.track_cursor as usize - 1;
-            self.tracks.get_mut(id).map(|t|(id, t))
-        } }
-    }
-
-}