refactor arranger back into modules

src/devices/arranger/arr_focus.rs

@@ -0,0 +1,95 @@
+#[derive(PartialEq)]
+/// Represents the current user selection in the arranger
+pub enum ArrangerFocus {
+    /** The whole mix is selected */
+    Mix,
+    /// A track is selected.
+    Track(usize),
+    /// A scene is selected.
+    Scene(usize),
+    /// A clip (track × scene) is selected.
+    Clip(usize, usize),
+}
+
+/// Focus identification methods
+impl ArrangerFocus {
+    pub fn is_track (&self) -> bool {
+        match self { Self::Track(_) => true, _ => false }
+    }
+    pub fn is_scene (&self) -> bool {
+        match self { Self::Scene(_) => true, _ => false }
+    }
+    pub fn is_clip (&self) -> bool {
+        match self { Self::Clip(_, _) => true, _ => false }
+    }
+}
+
+/// Track focus methods
+impl ArrangerFocus {
+    pub fn track (&self) -> Option<usize> {
+        match self {
+            Self::Clip(t, _) => Some(*t),
+            Self::Track(t)   => Some(*t),
+            _ => None
+        }
+    }
+    pub fn track_next (&mut self, last_track: usize) {
+        *self = match self {
+            Self::Mix        => Self::Track(0),
+            Self::Track(t)   => Self::Track(last_track.min(*t + 1)),
+            Self::Scene(s)   => Self::Clip(0, *s),
+            Self::Clip(t, s) => Self::Clip(last_track.min(*t + 1), *s),
+        }
+    }
+    pub fn track_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Scene(s) => Self::Scene(*s),
+            Self::Track(t) => if *t == 0 {
+                Self::Mix
+            } else {
+                Self::Track(*t - 1)
+            },
+            Self::Clip(t, s) => if *t == 0 {
+                Self::Scene(*s)
+            } else {
+                Self::Clip(t.saturating_sub(1), *s)
+            }
+        }
+    }
+}
+
+/// Scene focus methods
+impl ArrangerFocus {
+    pub fn scene (&self) -> Option<usize> {
+        match self {
+            Self::Clip(_, s) => Some(*s),
+            Self::Scene(s)   => Some(*s),
+            _ => None
+        }
+    }
+    pub fn scene_next (&mut self, last_scene: usize) {
+        *self = match self {
+            Self::Mix        => Self::Scene(0),
+            Self::Track(t)   => Self::Clip(*t, 0),
+            Self::Scene(s)   => Self::Scene(last_scene.min(*s + 1)),
+            Self::Clip(t, s) => Self::Clip(*t, last_scene.min(*s + 1)),
+        }
+    }
+    pub fn scene_prev (&mut self) {
+        *self = match self {
+            Self::Mix      => Self::Mix,
+            Self::Track(t) => Self::Track(*t),
+            Self::Scene(s) => if *s == 0 {
+                Self::Mix
+            } else {
+                Self::Scene(*s - 1)
+            },
+            Self::Clip(t, s) => if *s == 0 {
+                Self::Track(*t)
+            } else {
+                Self::Clip(*t, s.saturating_sub(1))
+            }
+        }
+    }
+}