shrink and grow track widths

crates/tek_sequencer/src/arranger.rs

@@ -47,6 +47,8 @@ pub struct ArrangementTrack<E: Engine> {
     pub player:  PhrasePlayer<E>,
     /// Outputs
     pub outputs: Vec<()>,
+    /// Preferred width of track column
+    pub width:   usize,
 }
 #[derive(Default)]
 pub struct Scene {
@@ -143,6 +145,33 @@ impl<E: Engine> Arrangement<E> {
             _ => {}
         }
     }
+    pub fn delete (&mut self) {
+        match self.selected {
+            ArrangementFocus::Track(t)   => self.track_del(),
+            ArrangementFocus::Scene(s)   => self.scene_del(),
+            ArrangementFocus::Clip(t, s) => self.phrase_del(),
+            _ => {}
+        }
+        self.show_phrase()
+    }
+    pub fn increment (&mut self) {
+        match self.selected {
+            ArrangementFocus::Track(t)   => self.track_width_inc(),
+            ArrangementFocus::Scene(s)   => self.scene_next(),
+            ArrangementFocus::Clip(t, s) => self.phrase_next(),
+            _ => {}
+        }
+        self.show_phrase()
+    }
+    pub fn decrement (&mut self) {
+        match self.selected {
+            ArrangementFocus::Track(t)   => self.track_width_dec(),
+            ArrangementFocus::Scene(s)   => self.scene_prev(),
+            ArrangementFocus::Clip(t, s) => self.phrase_prev(),
+            _ => {}
+        }
+        self.show_phrase()
+    }
     pub fn is_first_row (&self) -> bool {
         let selected = self.selected;
         selected.is_mix() || selected.is_track()
@@ -166,6 +195,12 @@ impl<E: Engine> Arrangement<E> {
     pub fn track_mut (&mut self) -> Option<&mut ArrangementTrack<E>> {
         self.selected.track().map(|t|self.tracks.get_mut(t)).flatten()
     }
+    pub fn track_width_inc (&mut self) {
+        self.track_mut().map(|t|t.width_inc());
+    }
+    pub fn track_width_dec (&mut self) {
+        self.track_mut().map(|t|t.width_dec());
+    }
     pub fn track_next (&mut self) {
         self.selected.track_next(self.tracks.len() - 1)
     }
@@ -187,21 +222,15 @@ impl<E: Engine> Arrangement<E> {
         format!("Track {}", self.tracks.len() + 1)
     }
     pub fn track_widths (&self) -> Vec<(usize, usize)> {
-        let to_len = |track: &ArrangementTrack<E>|track.name.read().unwrap().len();
-        let mut lens: Vec<usize> = self.tracks.iter().map(to_len).collect();
-        for scene in self.scenes.iter() {
-            for track_index in 0..self.tracks.len() {
-                if let Some(phrase) = scene.clip(track_index) {
-                    let len = phrase.read().unwrap().name.read().unwrap().len();
-                    lens[track_index] = lens[track_index].max(len);
-                }
-            }
-        }
+        let mut widths = vec![];
         let mut total = 0;
-        let to_x_and_w = |len: &usize|{ total = total + *len; (*len, total - *len) };
-        let mut lens: Vec<(usize, usize)> = lens.iter().map(to_x_and_w).collect();
-        lens.push((0, total));
-        lens
+        for track in self.tracks.iter() {
+            let width = track.width;
+            widths.push((width, total));
+            total += width;
+        }
+        widths.push((0, total));
+        widths
     }
 }
 /// Methods for scenes in arrangement
@@ -326,6 +355,7 @@ impl<E: Engine> ArrangementTrack<E> {
             inputs:  vec![],
             player:  PhrasePlayer::new(name),
             outputs: vec![],
+            width:   name.len() + 2,
         }
     }
     pub fn longest_name (tracks: &[Self]) -> usize {
@@ -333,6 +363,14 @@ impl<E: Engine> ArrangementTrack<E> {
             .map(|s|s.name.read().unwrap().len())
             .fold(0, usize::max)
     }
+    pub fn width_inc (&mut self) {
+        self.width += 1;
+    }
+    pub fn width_dec (&mut self) {
+        if self.width > 1 {
+            self.width -= 1;
+        }
+    }
 }
 /// Focus identification methods
 impl ArrangementFocus {