wip: refactor pt.6, fixed tek_api

crates/tek_tui/src/tui_arranger.rs

@@ -1,7 +1,7 @@
 use crate::*;
 
 /// Root level object for standalone `tek_arranger`
-pub struct ArrangerView<E: Engine> {
+pub struct ArrangerApp<E: Engine> {
     /// JACK client handle (needs to not be dropped for standalone mode to work).
     pub jack:              Arc<RwLock<JackClient>>,
     /// Which view is focused
@@ -13,7 +13,7 @@ pub struct ArrangerView<E: Engine> {
     /// Global timebase
     pub clock:             Arc<TransportTime>,
     /// Contains all the sequencers.
-    pub arrangement:       Arrangement<E>,
+    pub arrangement:       ArrangementEditor<E>,
     /// Pool of all phrases in the arrangement
     pub phrases:           Arc<RwLock<PhrasePool<E>>>,
     /// Phrase editor view
@@ -31,102 +31,79 @@ pub struct ArrangerView<E: Engine> {
     /// Command history
     pub history:           Vec<ArrangerCommand>,
 }
-/// Sections in the arranger app that may be focused
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum ArrangerFocus {
-    /// The transport (toolbar) is focused
-    Transport,
-    /// The arrangement (grid) is focused
-    Arrangement,
-    /// The phrase list (pool) is focused
-    PhrasePool,
-    /// The phrase editor (sequencer) is focused
-    PhraseEditor,
+
+impl Audio for ArrangerApp {
+    fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
+        if let Some(ref transport) = self.transport {
+            transport.write().unwrap().process(client, scope);
+        }
+        let Arrangement { scenes, ref mut tracks, selected, .. } = &mut self.arrangement;
+        for track in tracks.iter_mut() {
+            track.player.process(client, scope);
+        }
+        if let ArrangementEditorFocus::Clip(t, s) = selected {
+            if let Some(Some(Some(phrase))) = scenes.get(*s).map(|scene|scene.clips.get(*t)) {
+                if let Some(track) = tracks.get(*t) {
+                    if let Some((ref started_at, Some(ref playing))) = track.player.phrase {
+                        let phrase = phrase.read().unwrap();
+                        if *playing.read().unwrap() == *phrase {
+                            let pulse = self.clock.current.pulse.get();
+                            let start = started_at.pulse.get();
+                            let now   = (pulse - start) % phrase.length as f64;
+                            self.editor.now.set(now);
+                            return Control::Continue
+                        }
+                    }
+                }
+            }
+        }
+        self.editor.now.set(0.);
+        Control::Continue
+    }
 }
-/// Status bar for arranger ap
-pub enum ArrangerStatusBar {
-    Transport,
-    ArrangementMix,
-    ArrangementTrack,
-    ArrangementScene,
-    ArrangementClip,
-    PhrasePool,
-    PhraseView,
-    PhraseEdit,
+
+/// Layout for standalone arranger app.
+impl Content for ArrangerApp {
+    type Engine = Tui;
+    fn content (&self) -> impl Widget<Engine = Tui> {
+        let focused   = self.arrangement.focused;
+        let border_bg = Arranger::<Tui>::border_bg();
+        let border_fg = Arranger::<Tui>::border_fg(focused);
+        let title_fg  = Arranger::<Tui>::title_fg(focused);
+        let border    = Lozenge(Style::default().bg(border_bg).fg(border_fg));
+        let entered   = if self.arrangement.entered { "■" } else { " " };
+        Split::down(
+            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),
+                        )
+                    )
+                )
+            )
+        )
+    }
 }
-/// Represents the tracks and scenes of the composition.
-pub struct Arrangement<E: Engine> {
-    /// Global JACK client
-    pub jack:     Arc<RwLock<JackClient>>,
-    /// Global timebase
-    pub clock:    Arc<TransportTime>,
-    /// Name of arranger
-    pub name:     Arc<RwLock<String>>,
-    /// Collection of phrases.
-    pub phrases:  Arc<RwLock<PhrasePool<E>>>,
-    /// Collection of tracks.
-    pub tracks:   Vec<ArrangementTrack>,
-    /// Collection of scenes.
-    pub scenes:   Vec<Scene>,
-    /// Currently selected element.
-    pub selected: ArrangementFocus,
-    /// Display mode of arranger
-    pub mode:     ArrangementViewMode,
-    /// Whether the arranger is currently focused
-    pub focused:  bool,
-    /// Background color of arrangement
-    pub color:    ItemColor,
-    /// Width and height of arrangement area at last render
-    pub size:     Measure<E>,
-    /// Whether this is currently in edit mode
-    pub entered:  bool,
-}
-/// Represents a track in the arrangement
-pub struct ArrangementTrack {
-    /// Name of track
-    pub name:   Arc<RwLock<String>>,
-    /// Preferred width of track column
-    pub width:  usize,
-    /// Identifying color of track
-    pub color:  ItemColor,
-    /// MIDI player/recorder
-    pub player: PhrasePlayer,
-}
-#[derive(Default, Debug)]
-pub struct Scene {
-    /// Name of scene
-    pub name:  Arc<RwLock<String>>,
-    /// Clips in scene, one per track
-    pub clips: Vec<Option<Arc<RwLock<Phrase>>>>,
-    /// Identifying color of scene
-    pub color: ItemColor,
-}
-#[derive(PartialEq, Clone, Copy)]
-/// Represents the current user selection in the arranger
-pub enum ArrangementFocus {
-    /// 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),
-}
-/// Display mode of arranger
-#[derive(PartialEq)]
-pub enum ArrangementViewMode {
-    /// Tracks are rows
-    Horizontal,
-    /// Tracks are columns
-    Vertical(usize),
-}
-/// Arrangement, rendered vertically (session/grid mode).
-pub struct VerticalArranger<'a, E: Engine>(pub &'a Arrangement<E>, pub usize);
-/// Arrangement, rendered horizontally (arrangement/track mode).
-pub struct HorizontalArranger<'a, E: Engine>(pub &'a Arrangement<E>);
+
 /// General methods for arranger
-impl<E: Engine> Arranger<E> {
+impl<E: Engine> ArrangerApp<E> {
     pub fn new (
         jack:        &Arc<RwLock<JackClient>>,
         transport:   Option<Arc<RwLock<TransportToolbar<E>>>>,
@@ -208,6 +185,29 @@ impl<E: Engine> Arranger<E> {
         app.update_focus();
         app
     }
+
+    //pub fn new (
+        //jack:    &Arc<RwLock<JackClient>>,
+        //clock:   &Arc<TransportTime>,
+        //name:    &str,
+        //phrases: &Arc<RwLock<PhrasePool<E>>>
+    //) -> Self {
+        //Self {
+            //jack:     jack.clone(),
+            //clock:    clock.clone(),
+            //name:     Arc::new(RwLock::new(name.into())),
+            //mode:     ArrangementViewMode::Vertical(2),
+            //selected: ArrangementEditorFocus::Clip(0, 0),
+            //phrases:  phrases.clone(),
+            //scenes:   vec![],
+            //tracks:   vec![],
+            //focused:  false,
+            //color:    Color::Rgb(28, 35, 25).into(),
+            //size:     Measure::new(),
+            //entered:  false,
+        //}
+    //}
+
     /// Toggle global play/pause
     pub fn toggle_play (&mut self) -> Perhaps<bool> {
         match self.transport {
@@ -217,7 +217,7 @@ impl<E: Engine> Arranger<E> {
         Ok(Some(true))
     }
     pub fn next_color (&self) -> ItemColor {
-        if let ArrangementFocus::Clip(track, scene) = self.arrangement.selected {
+        if let ArrangementEditorFocus::Clip(track, scene) = self.arrangement.selected {
             let track_color = self.arrangement.tracks[track].color;
             let scene_color = self.arrangement.scenes[scene].color;
             track_color.mix(scene_color, 0.5).mix(ItemColor::random(), 0.25)
@@ -234,20 +234,20 @@ impl<E: Engine> Arranger<E> {
             self.arrangement.phrase_put();
         }
         self.show_phrase();
-        self.focus(ArrangerFocus::PhraseEditor);
+        self.focus(ArrangerAppFocus::PhraseEditor);
         self.editor.entered = true;
     }
     /// Rename the selected track, scene, or clip
     pub fn rename_selected (&mut self) {
         let Arrangement { selected, ref scenes, .. } = self.arrangement;
         match selected {
-            ArrangementFocus::Mix        => {},
-            ArrangementFocus::Track(_)   => { todo!("rename track"); },
-            ArrangementFocus::Scene(_)   => { todo!("rename scene"); },
-            ArrangementFocus::Clip(t, s) => if let Some(ref phrase) = scenes[s].clips[t] {
+            ArrangementEditorFocus::Mix        => {},
+            ArrangementEditorFocus::Track(_)   => { todo!("rename track"); },
+            ArrangementEditorFocus::Scene(_)   => { todo!("rename scene"); },
+            ArrangementEditorFocus::Clip(t, s) => if let Some(ref phrase) = scenes[s].clips[t] {
                 let index = self.phrases.read().unwrap().index_of(&*phrase.read().unwrap());
                 if let Some(index) = index {
-                    self.focus(ArrangerFocus::PhrasePool);
+                    self.focus(ArrangerAppFocus::PhrasePool);
                     self.phrases.write().unwrap().phrase = index;
                     self.phrases.write().unwrap().begin_rename();
                 }
@@ -257,103 +257,23 @@ impl<E: Engine> Arranger<E> {
     /// Update status bar
     pub fn update_status (&mut self) {
         self.status = match self.focused() {
-            ArrangerFocus::Transport         => ArrangerStatusBar::Transport,
-            ArrangerFocus::Arrangement       => match self.arrangement.selected {
-                ArrangementFocus::Mix        => ArrangerStatusBar::ArrangementMix,
-                ArrangementFocus::Track(_)   => ArrangerStatusBar::ArrangementTrack,
-                ArrangementFocus::Scene(_)   => ArrangerStatusBar::ArrangementScene,
-                ArrangementFocus::Clip(_, _) => ArrangerStatusBar::ArrangementClip,
+            ArrangerAppFocus::Transport         => ArrangerStatusBar::Transport,
+            ArrangerAppFocus::Arrangement       => match self.arrangement.selected {
+                ArrangementEditorFocus::Mix        => ArrangerStatusBar::ArrangementMix,
+                ArrangementEditorFocus::Track(_)   => ArrangerStatusBar::ArrangementTrack,
+                ArrangementEditorFocus::Scene(_)   => ArrangerStatusBar::ArrangementScene,
+                ArrangementEditorFocus::Clip(_, _) => ArrangerStatusBar::ArrangementClip,
             },
-            ArrangerFocus::PhrasePool        => ArrangerStatusBar::PhrasePool,
-            ArrangerFocus::PhraseEditor      => match self.editor.entered {
+            ArrangerAppFocus::PhrasePool        => ArrangerStatusBar::PhrasePool,
+            ArrangerAppFocus::PhraseEditor      => match self.editor.entered {
                 true  => ArrangerStatusBar::PhraseEdit,
                 false => ArrangerStatusBar::PhraseView,
             },
         }
     }
-}
-/// Focus layout of arranger app
-impl<E: Engine> FocusGrid for Arranger<E> {
-    type Item = ArrangerFocus;
-    fn cursor (&self) -> (usize, usize) { self.focus_cursor }
-    fn cursor_mut (&mut self) -> &mut (usize, usize) { &mut self.focus_cursor }
-    fn focus_enter (&mut self) {
-        let focused = self.focused();
-        if !self.entered {
-            self.entered = true;
-            use ArrangerFocus::*;
-            if let Some(transport) = self.transport.as_ref() {
-                //transport.write().unwrap().entered = focused == Transport
-            }
-            self.arrangement.entered = focused == Arrangement;
-            self.phrases.write().unwrap().entered = focused == PhrasePool;
-            self.editor.entered = focused == PhraseEditor;
-        }
-    }
-    fn focus_exit (&mut self) {
-        if self.entered {
-            self.entered = false;
-            self.arrangement.entered = false;
-            self.editor.entered = false;
-            self.phrases.write().unwrap().entered = false;
-        }
-    }
-    fn entered (&self) -> Option<ArrangerFocus> {
-        if self.entered {
-            Some(self.focused())
-        } else {
-            None
-        }
-    }
-    fn layout (&self) -> &[&[ArrangerFocus]] {
-        use ArrangerFocus::*;
-        &[
-            &[Transport,   Transport],
-            &[Arrangement, Arrangement],
-            &[PhrasePool,  PhraseEditor],
-        ]
-    }
-    fn update_focus (&mut self) {
-        use ArrangerFocus::*;
-        let focused = self.focused();
-        if let Some(transport) = self.transport.as_ref() {
-            transport.write().unwrap().focused = focused == Transport
-        }
-        self.arrangement.focused = focused == Arrangement;
-        self.phrases.write().unwrap().focused = focused == PhrasePool;
-        self.editor.focused = focused == PhraseEditor;
-        self.update_status();
-    }
-}
-/// General methods for arrangement
-impl<E: Engine> Arrangement<E> {
-    pub fn new (
-        jack:    &Arc<RwLock<JackClient>>,
-        clock:   &Arc<TransportTime>,
-        name:    &str,
-        phrases: &Arc<RwLock<PhrasePool<E>>>
-    ) -> Self {
-        Self {
-            jack:     jack.clone(),
-            clock:    clock.clone(),
-            name:     Arc::new(RwLock::new(name.into())),
-            mode:     ArrangementViewMode::Vertical(2),
-            selected: ArrangementFocus::Clip(0, 0),
-            phrases:  phrases.clone(),
-            scenes:   vec![],
-            tracks:   vec![],
-            focused:  false,
-            color:    Color::Rgb(28, 35, 25).into(),
-            size:     Measure::new(),
-            entered:  false,
-        }
-    }
-    fn is_stopped (&self) -> bool {
-        *self.clock.playing.read().unwrap() == Some(TransportState::Stopped)
-    }
     pub fn activate (&mut self) {
         match self.selected {
-            ArrangementFocus::Scene(s) => {
+            ArrangementEditorFocus::Scene(s) => {
                 for (t, track) in self.tracks.iter_mut().enumerate() {
                     let player = &mut track.player;
                     let clip = self.scenes[s].clips[t].as_ref();
@@ -367,7 +287,7 @@ impl<E: Engine> Arrangement<E> {
                     //self.transport.toggle_play()
                 //}
             },
-            ArrangementFocus::Clip(t, s) => {
+            ArrangementEditorFocus::Clip(t, s) => {
                 self.tracks[t].player.enqueue_next(self.scenes[s].clips[t].as_ref());
             },
             _ => {}
@@ -375,26 +295,26 @@ impl<E: Engine> Arrangement<E> {
     }
     pub fn delete (&mut self) {
         match self.selected {
-            ArrangementFocus::Track(_)   => self.track_del(),
-            ArrangementFocus::Scene(_)   => self.scene_del(),
-            ArrangementFocus::Clip(_, _) => self.phrase_del(),
+            ArrangementEditorFocus::Track(_)   => self.track_del(),
+            ArrangementEditorFocus::Scene(_)   => self.scene_del(),
+            ArrangementEditorFocus::Clip(_, _) => self.phrase_del(),
             _ => {}
         }
     }
     pub fn increment (&mut self) {
         match self.selected {
-            ArrangementFocus::Track(_)   => self.track_width_inc(),
-            ArrangementFocus::Scene(_)   => self.scene_next(),
-            ArrangementFocus::Clip(_, _) => self.phrase_next(),
-            ArrangementFocus::Mix        => self.zoom_in(),
+            ArrangementEditorFocus::Track(_)   => self.track_width_inc(),
+            ArrangementEditorFocus::Scene(_)   => self.scene_next(),
+            ArrangementEditorFocus::Clip(_, _) => self.phrase_next(),
+            ArrangementEditorFocus::Mix        => self.zoom_in(),
         }
     }
     pub fn decrement (&mut self) {
         match self.selected {
-            ArrangementFocus::Track(_)   => self.track_width_dec(),
-            ArrangementFocus::Scene(_)   => self.scene_prev(),
-            ArrangementFocus::Clip(_, _) => self.phrase_prev(),
-            ArrangementFocus::Mix        => self.zoom_out(),
+            ArrangementEditorFocus::Track(_)   => self.track_width_dec(),
+            ArrangementEditorFocus::Scene(_)   => self.scene_prev(),
+            ArrangementEditorFocus::Clip(_, _) => self.phrase_prev(),
+            ArrangementEditorFocus::Mix        => self.zoom_out(),
         }
     }
     pub fn zoom_in (&mut self) {
@@ -414,8 +334,8 @@ impl<E: Engine> Arrangement<E> {
     pub fn is_last_row (&self) -> bool {
         let selected = self.selected;
         (self.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
-            ArrangementFocus::Scene(s)   => s == self.scenes.len() - 1,
-            ArrangementFocus::Clip(_, s) => s == self.scenes.len() - 1,
+            ArrangementEditorFocus::Scene(s)   => s == self.scenes.len() - 1,
+            ArrangementEditorFocus::Clip(_, s) => s == self.scenes.len() - 1,
             _ => false
         }
     }
@@ -450,16 +370,16 @@ impl<E: Engine> Arrangement<E> {
     }
     pub fn move_back (&mut self) {
         match self.selected {
-            ArrangementFocus::Scene(s) => {
+            ArrangementEditorFocus::Scene(s) => {
                 if s > 0 {
                     self.scenes.swap(s, s - 1);
-                    self.selected = ArrangementFocus::Scene(s - 1);
+                    self.selected = ArrangementEditorFocus::Scene(s - 1);
                 }
             },
-            ArrangementFocus::Track(t) => {
+            ArrangementEditorFocus::Track(t) => {
                 if t > 0 {
                     self.tracks.swap(t, t - 1);
-                    self.selected = ArrangementFocus::Track(t - 1);
+                    self.selected = ArrangementEditorFocus::Track(t - 1);
                     // FIXME: also swap clip order in scenes
                 }
             },
@@ -468,16 +388,16 @@ impl<E: Engine> Arrangement<E> {
     }
     pub fn move_forward (&mut self) {
         match self.selected {
-            ArrangementFocus::Scene(s) => {
+            ArrangementEditorFocus::Scene(s) => {
                 if s < self.scenes.len().saturating_sub(1) {
                     self.scenes.swap(s, s + 1);
-                    self.selected = ArrangementFocus::Scene(s + 1);
+                    self.selected = ArrangementEditorFocus::Scene(s + 1);
                 }
             },
-            ArrangementFocus::Track(t) => {
+            ArrangementEditorFocus::Track(t) => {
                 if t < self.tracks.len().saturating_sub(1) {
                     self.tracks.swap(t, t + 1);
-                    self.selected = ArrangementFocus::Track(t + 1);
+                    self.selected = ArrangementEditorFocus::Track(t + 1);
                     // FIXME: also swap clip order in scenes
                 }
             },
@@ -486,15 +406,16 @@ impl<E: Engine> Arrangement<E> {
     }
     pub fn randomize_color (&mut self) {
         match self.selected {
-            ArrangementFocus::Mix        => { self.color = ItemColor::random_dark() },
-            ArrangementFocus::Track(t)   => { self.tracks[t].color = ItemColor::random() },
-            ArrangementFocus::Scene(s)   => { self.scenes[s].color = ItemColor::random() },
-            ArrangementFocus::Clip(t, s) => if let Some(phrase) = &self.scenes[s].clips[t] {
+            ArrangementEditorFocus::Mix        => { self.color = ItemColor::random_dark() },
+            ArrangementEditorFocus::Track(t)   => { self.tracks[t].color = ItemColor::random() },
+            ArrangementEditorFocus::Scene(s)   => { self.scenes[s].color = ItemColor::random() },
+            ArrangementEditorFocus::Clip(t, s) => if let Some(phrase) = &self.scenes[s].clips[t] {
                 phrase.write().unwrap().color = ItemColorTriplet::random();
             }
         }
     }
 }
+
 /// Methods for tracks in arrangement
 impl<E: Engine> Arrangement<E> {
     pub fn track (&self) -> Option<&ArrangementTrack> {
@@ -597,12 +518,12 @@ impl<E: Engine> Arrangement<E> {
                 .map(|scene|scene.clips[track_index] = None));
     }
     pub fn phrase_put (&mut self) {
-        if let ArrangementFocus::Clip(track, scene) = self.selected {
+        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 ArrangementFocus::Clip(track, scene) = self.selected {
+        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()) {
@@ -612,7 +533,7 @@ impl<E: Engine> Arrangement<E> {
         }
     }
     pub fn phrase_next (&mut self) {
-        if let ArrangementFocus::Clip(track, scene) = self.selected {
+        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());
@@ -625,7 +546,7 @@ impl<E: Engine> Arrangement<E> {
         }
     }
     pub fn phrase_prev (&mut self) {
-        if let ArrangementFocus::Clip(track, scene) = self.selected {
+        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());
@@ -638,6 +559,7 @@ impl<E: Engine> Arrangement<E> {
         }
     }
 }
+
 impl ArrangementTrack {
     pub fn new (
         jack:  &Arc<RwLock<JackClient>>,
@@ -659,91 +581,7 @@ impl ArrangementTrack {
     pub fn width_inc (&mut self) { self.width += 1; }
     pub fn width_dec (&mut self) { if self.width > Self::MIN_WIDTH { self.width -= 1; } }
 }
-/// Focus identification methods
-impl ArrangementFocus {
-    pub fn description <E: Engine> (
-        &self,
-        tracks: &Vec<ArrangementTrack>,
-        scenes: &Vec<Scene>,
-    ) -> String {
-        format!("Selected: {}", match self {
-            Self::Mix => format!("Everything"),
-            Self::Track(t)  => match tracks.get(*t) {
-                Some(track) => format!("T{t}: {}", &track.name.read().unwrap()),
-                None        => format!("T??"),
-            },
-            Self::Scene(s)  => match scenes.get(*s) {
-                Some(scene) => format!("S{s}: {}", &scene.name.read().unwrap()),
-                None        => format!("S??"),
-            },
-            Self::Clip(t, s) => match (tracks.get(*t), scenes.get(*s)) {
-                (Some(_), Some(scene)) => match scene.clip(*t) {
-                    Some(clip) => format!("T{t} S{s} C{}", &clip.read().unwrap().name),
-                    None       => format!("T{t} S{s}: Empty")
-                },
-                _ => format!("T{t} S{s}: Empty"),
-            }
-        })
-    }
-    pub fn is_mix   (&self) -> bool { match self { Self::Mix        => true, _ => false } }
-    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 } }
-    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) }
-        }
-    }
-    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)) }
-        }
-    }
-}
+
 /// Arranger display mode can be cycled
 impl ArrangementViewMode {
     /// Cycle arranger display mode
@@ -769,27 +607,6 @@ impl Scene {
             color: color.unwrap_or_else(ItemColor::random),
         }
     }
-    /// Returns the pulse length of the longest phrase in the scene
-    pub fn pulses (&self) -> usize {
-        self.clips.iter().fold(0, |a, p|{
-            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
-        })
-    }
-    /// Returns true if all phrases in the scene are currently playing
-    pub fn is_playing (&self, tracks: &[ArrangementTrack]) -> bool {
-        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
-            .all(|(track_index, clip)|match clip {
-                Some(clip) => tracks
-                    .get(track_index)
-                    .map(|track|if let Some((_, Some(phrase))) = &track.player.phrase {
-                        *phrase.read().unwrap() == *clip.read().unwrap()
-                    } else {
-                        false
-                    })
-                    .unwrap_or(false),
-                None => true
-            })
-    }
     pub fn ppqs (scenes: &[Self], factor: usize) -> Vec<(usize, usize)> {
         let mut total = 0;
         if factor == 0 {
@@ -807,60 +624,4 @@ impl Scene {
     pub fn longest_name (scenes: &[Self]) -> usize {
         scenes.iter().map(|s|s.name.read().unwrap().len()).fold(0, usize::max)
     }
-    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<Phrase>>> {
-        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
-    }
-}
-
-/// Layout for standalone arranger app.
-impl Content for Arranger<Tui> {
-    type Engine = Tui;
-    fn content (&self) -> impl Widget<Engine = Tui> {
-        let focused   = self.arrangement.focused;
-        let border_bg = Arranger::<Tui>::border_bg();
-        let border_fg = Arranger::<Tui>::border_fg(focused);
-        let title_fg  = Arranger::<Tui>::title_fg(focused);
-        let border    = Lozenge(Style::default().bg(border_bg).fg(border_fg));
-        let entered   = if self.arrangement.entered { "■" } else { " " };
-        Split::down(
-            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),
-                        )
-                    )
-                )
-            )
-        )
-    }
-}
-
-impl Content for Arrangement<Tui> {
-    type Engine = Tui;
-    fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers::new(move |add|{
-            match self.mode {
-                ArrangementViewMode::Horizontal       => { add(&HorizontalArranger(&self))       },
-                ArrangementViewMode::Vertical(factor) => { add(&VerticalArranger(&self, factor)) },
-            }?;
-            add(&self.size)
-        })
-    }
 }