wip: refactor pt.13: 146 errors

crates/tek_tui/src/tui_arranger.rs

@@ -46,36 +46,30 @@ impl<E: Engine> Audio for ArrangerView<E> {
 impl Content for ArrangerView<Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        let focused   = self.arrangement.focused;
-        let border_bg = TuiTheme::border_bg();
-        let border_fg = TuiTheme::border_fg(focused);
-        let title_fg  = TuiTheme::title_fg(focused);
-        let border    = Lozenge(Style::default().bg(border_bg).fg(border_fg));
-        let entered   = if self.arrangement.entered { "■" } else { " " };
-        Split::down(
+        Split::up(
             1,
-            row!(menu in self.menu.menus.iter() => {
-                row!(" ", menu.title.as_str(), " ")
-            }),
-            Split::up(
-                1,
-                widget(&self.status),
-                Split::up(
-                    1,
-                    widget(&self.transport),
-                    Split::down(
-                        self.arrangement_split,
-                        lay!(
-                            widget(&self.arrangement).grow_y(1).border(border),
-                            widget(&self.arrangement.size),
-                            widget(&format!("[{}] Arrangement", entered)).fg(title_fg).push_x(1),
-                        ),
-                        Split::right(
-                            self.phrases_split,
-                            self.phrases.clone(),
-                            widget(&self.editor),
-                        )
-                    )
+            widget(&self.sequencer.transport),
+            Split::down(
+                self.split,
+                lay!(
+                    widget(&self.arrangement)
+                        .grow_y(1)
+                        .border(Lozenge(Style::default()
+                            .bg(TuiTheme::border_bg())
+                            .fg(TuiTheme::border_fg(self.arrangement.focused)))),
+                    widget(&self.arrangement.size),
+                    widget(&format!("[{}] Arrangement", if self.arrangement.entered {
+                        "■"
+                    } else {
+                        " "
+                    }))
+                        .fg(TuiTheme::title_fg(self.arrangement.focused))
+                        .push_x(1),
+                ),
+                Split::right(
+                    self.sequencer.split,
+                    widget(&self.sequencer.phrases),
+                    widget(&self.sequencer.editor),
                 )
             )
         )
@@ -190,7 +184,7 @@ impl<E: Engine> ArrangerView<E> {
     }
     pub fn increment (&mut self) {
         match self.arrangement.selected {
-            ArrangementEditorFocus::Track(_)   => self.track_width_inc(),
+            ArrangementEditorFocus::Track(_)   => self.track_mut().map(|t|t.width_inc()),
             ArrangementEditorFocus::Scene(_)   => self.scene_next(),
             ArrangementEditorFocus::Clip(_, _) => self.phrase_next(),
             ArrangementEditorFocus::Mix        => self.zoom_in(),
@@ -198,7 +192,7 @@ impl<E: Engine> ArrangerView<E> {
     }
     pub fn decrement (&mut self) {
         match self.arrangement.selected {
-            ArrangementEditorFocus::Track(_)   => self.track_width_dec(),
+            ArrangementEditorFocus::Track(_)   => self.track_mut().map(|t|t.width_dec()),
             ArrangementEditorFocus::Scene(_)   => self.scene_prev(),
             ArrangementEditorFocus::Clip(_, _) => self.phrase_prev(),
             ArrangementEditorFocus::Mix        => self.zoom_out(),
@@ -302,161 +296,3 @@ impl<E: Engine> ArrangerView<E> {
         }
     }
 }
-
-/// Methods for tracks in arrangement
-impl<E: Engine> Arrangement<E> {
-    pub fn track (&self) -> Option<&ArrangementTrack> {
-        self.selected.track().map(|t|self.tracks.get(t)).flatten()
-    }
-    pub fn track_mut (&mut self) -> Option<&mut ArrangementTrack> {
-        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) }
-    pub fn track_prev (&mut self) { self.selected.track_prev() }
-    pub fn track_add (
-        &mut self, name: Option<&str>, color: Option<ItemColor>
-    ) -> Usually<&mut ArrangementTrack> {
-        self.tracks.push(name.map_or_else(
-            || ArrangementTrack::new(
-                &self.jack, &self.clock, &self.track_default_name(), color
-            ),
-            |name| ArrangementTrack::new(
-                &self.jack, &self.clock, name, color
-            ),
-        )?);
-        let index = self.tracks.len() - 1;
-        Ok(&mut self.tracks[index])
-    }
-    pub fn track_del (&mut self) {
-        if let Some(index) = self.selected.track() {
-            self.tracks.remove(index);
-            for scene in self.scenes.iter_mut() {
-                scene.clips.remove(index);
-            }
-        }
-    }
-    pub fn track_default_name (&self) -> String {
-        format!("Track {}", self.tracks.len() + 1)
-    }
-    pub fn track_widths (&self) -> Vec<(usize, usize)> {
-        let mut widths = vec![];
-        let mut total = 0;
-        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
-impl<E: Engine> Arrangement<E> {
-    pub fn scene (&self) -> Option<&ArrangementScene> {
-        self.selected.scene().map(|s|self.scenes.get(s)).flatten()
-    }
-    pub fn scene_mut (&mut self) -> Option<&mut ArrangementScene> {
-        self.selected.scene().map(|s|self.scenes.get_mut(s)).flatten()
-    }
-    pub fn scene_next (&mut self) {
-        self.selected.scene_next(self.scenes.len() - 1)
-    }
-    pub fn scene_prev (&mut self) {
-        self.selected.scene_prev()
-    }
-    pub fn scene_add (
-        &mut self, name: Option<&str>, color: Option<ItemColor>
-    ) -> Usually<&mut ArrangementScene> {
-        let clips = vec![None;self.tracks.len()];
-        let name = name.map(|x|x.to_string()).unwrap_or_else(||self.scene_default_name());
-        self.scenes.push(Scene::new(name, clips, color));
-        let index = self.scenes.len() - 1;
-        Ok(&mut self.scenes[index])
-    }
-    pub fn scene_del (&mut self) {
-        if let Some(index) = self.selected.scene() {
-            self.scenes.remove(index);
-        }
-    }
-    pub fn scene_default_name (&self) -> String {
-        format!("Scene {}", self.scenes.len() + 1)
-    }
-}
-/// Methods for phrases in arrangement
-impl<E: Engine> Arrangement<E> {
-    pub fn sequencer (&self) -> Option<&ArrangementTrack> {
-        self.selected.track().map(|track|self.tracks.get(track)).flatten()
-    }
-    pub fn sequencer_mut (&mut self) -> Option<&mut ArrangementTrack> {
-        self.selected.track().map(|track|self.tracks.get_mut(track)).flatten()
-    }
-    pub fn phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
-        self.scene()?.clips.get(self.selected.track()?)?.clone()
-    }
-    pub fn phrase_del (&mut self) {
-        let track_index = self.selected.track();
-        let scene_index = self.selected.scene();
-        track_index
-            .and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
-            .map(|(track_index, _)|scene_index
-                .and_then(|index|self.scenes.get_mut(index))
-                .map(|scene|scene.clips[track_index] = None));
-    }
-    pub fn phrase_put (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            self.scenes[scene].clips[track] = Some(self.phrases.read().unwrap().phrase().clone());
-        }
-    }
-    pub fn phrase_get (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(phrase) = &self.scenes[scene].clips[track] {
-                let mut phrases = self.phrases.write().unwrap();
-                if let Some(index) = phrases.index_of(&*phrase.read().unwrap()) {
-                    phrases.phrase = index;
-                }
-            }
-        }
-    }
-    pub fn phrase_next (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(ref mut phrase) = self.scenes[scene].clips[track] {
-                let phrases = self.phrases.read().unwrap();
-                let index = phrases.index_of(&*phrase.read().unwrap());
-                if let Some(index) = index {
-                    if index < phrases.phrases.len().saturating_sub(1) {
-                        *phrase = phrases.phrases[index + 1].clone();
-                    }
-                }
-            }
-        }
-    }
-    pub fn phrase_prev (&mut self) {
-        if let ArrangementEditorFocus::Clip(track, scene) = self.selected {
-            if let Some(ref mut phrase) = self.scenes[scene].clips[track] {
-                let phrases = self.phrases.read().unwrap();
-                let index = phrases.index_of(&*phrase.read().unwrap());
-                if let Some(index) = index {
-                    if index > 0 {
-                        *phrase = phrases.phrases[index - 1].clone();
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Arranger display mode can be cycled
-impl ArrangementEditorMode {
-    /// Cycle arranger display mode
-    pub fn to_next (&mut self) {
-        *self = match self {
-            Self::Horizontal  => Self::Vertical(1),
-            Self::Vertical(1) => Self::Vertical(2),
-            Self::Vertical(2) => Self::Vertical(2),
-            Self::Vertical(0) => Self::Horizontal,
-            Self::Vertical(_) => Self::Vertical(0),
-        }
-    }
-}