Process -> Audio; Layers2 -> Layers

crates/tek_sequencer/src/arranger_view_h.rs

@@ -4,17 +4,17 @@ pub fn draw (state: &Arranger<Tui>, to: &mut Tui) -> Perhaps<[u16;4]> {
     let area = to.area();
     let area = [area.x(), area.y(), area.w(), area.h().min((2 + state.tracks.len() * 2) as u16)];
     let tracks = state.tracks.as_slice();
-    Layers([
-        &state.focused.then_some(FillBg(COLOR_BG0)),
-        &Split::right()
+    Layers::new(|add|{
+        add(&state.focused.then_some(FillBg(COLOR_BG0)))?;
+        add(&Split::right()
             .add(TrackNameColumn(tracks, state.selected))
             .add(TrackMonitorColumn(tracks))
             .add(TrackRecordColumn(tracks))
             .add(TrackOverdubColumn(tracks))
             .add(TrackEraseColumn(tracks))
             .add(TrackGainColumn(tracks))
-            .add(TrackScenesColumn(tracks, state.scenes.as_slice(), state.selected))
-    ]).render(to.with_rect(area))
+            .add(TrackScenesColumn(tracks, state.scenes.as_slice(), state.selected)))
+    }).render(to.with_rect(area))
 }
 
 struct TrackNameColumn<'a>(&'a [Sequencer<Tui>], ArrangerFocus);

crates/tek_sequencer/src/arranger_view_v.rs

@@ -38,24 +38,21 @@ pub fn draw <'a, 'b> (
     let offset = 3 + scene_name_max_len(state.scenes.as_ref()) as u16;
     let tracks = state.tracks.as_ref();
     let scenes = state.scenes.as_ref();
-    Layers([
+    Layers::new(|add|{
         //.add_ref(&FillBg(Color::Rgb(30, 33, 36)))//COLOR_BG1))//bg_lo(state.focused, state.entered)))
-        &ColumnSeparators(offset, cols),
-        &RowSeparators(rows),
-        &CursorFocus(state.selected, offset, cols, rows),
-        &Split::down()
+        add(&ColumnSeparators(offset, cols))?;
+        add(&RowSeparators(rows))?;
+        add(&CursorFocus(state.selected, offset, cols, rows))?;
+        add(&Split::down()
             .add_ref(&TracksHeader(offset, cols, tracks))
-            .add_ref(&SceneRows(offset, cols, rows, tracks, scenes))
-    ]).render(to.with_rect(area))
+            .add_ref(&SceneRows(offset, cols, rows, tracks, scenes)))
+    }).render(to.with_rect(area))
 }
 
 struct ColumnSeparators<'a>(u16, &'a [(usize, usize)]);
 
 impl<'a> Widget for ColumnSeparators<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, cols) = self;
@@ -74,9 +71,6 @@ struct RowSeparators<'a>(&'a [(usize, usize)]);
 
 impl<'a> Widget for RowSeparators<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(rows) = self;
@@ -101,9 +95,6 @@ struct CursorFocus<'a>(
 
 impl<'a> Widget for CursorFocus<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(selected, offset, cols, rows) = *self;
@@ -171,9 +162,6 @@ struct TracksHeader<'a>(u16, &'a[(usize, usize)], &'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TracksHeader<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, track_cols, tracks) = *self;
@@ -195,9 +183,6 @@ struct SceneRows<'a>(u16, &'a[(usize, usize)], &'a[(usize, usize)], &'a[Sequence
 
 impl<'a> Widget for SceneRows<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, track_cols, scene_rows, tracks, scenes) = *self;
@@ -228,9 +213,6 @@ struct SceneRow<'a>(&'a[Sequencer<Tui>], &'a Scene, &'a[(usize, usize)], u16);
 
 impl<'a> Widget for SceneRow<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(tracks, scene, track_cols, offset) = self;
@@ -258,9 +240,6 @@ struct SceneClip<'a>(&'a Sequencer<Tui>, usize);
 
 impl<'a> Widget for SceneClip<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(track, clip) = self;

crates/tek_sequencer/src/sequencer_view_h.rs

@@ -15,13 +15,13 @@ impl Sequencer<Tui> {
         let area = [area.x() + 10, area.y(), area.w().saturating_sub(10), area.h().min(66)];
         Lozenge(Style::default().fg(Nord::BG2)).draw(to.with_rect(area))?;
         let area = [area.x() + 1, area.y(), area.w().saturating_sub(1), area.h()];
-        Layers([
-            &SequenceKeys(&self),
-            &self.phrase.as_ref().map(|phrase|SequenceTimer(&self, phrase.clone())),
-            &SequenceNotes(&self),
-            &SequenceCursor(&self),
-            &SequenceZoom(&self),
-        ]).render(to.with_rect(area))?;
+        Layers::new(|add|{
+            add(&SequenceKeys(&self))?;
+            add(&self.phrase.as_ref().map(|phrase|SequenceTimer(&self, phrase.clone())))?;
+            add(&SequenceNotes(&self))?;
+            add(&SequenceCursor(&self))?;
+            add(&SequenceZoom(&self))
+        }).render(to.with_rect(area))?;
         Ok(())
     }
 

crates/tek_sequencer/src/transport.rs

@@ -181,7 +181,7 @@ impl Focusable<Tui> for TransportToolbar<Tui> {
         self.focused = focused
     }
 }
-impl<E: Engine> Process for TransportToolbar<E> {
+impl<E: Engine> Audio for TransportToolbar<E> {
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
         self.update(&scope);
         Control::Continue

crates/tek_sequencer/src/transport_view.rs

@@ -17,7 +17,7 @@ impl Content for TransportToolbar<Tui> {
 impl Content for TransportPlayPauseButton<Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers2::new(|add|{
+        Layers::new(|add|{
             //add(&self.focused.then_some(CORNERS))?;
             add(&Styled(match self.value {
                 Some(TransportState::Stopped)  => Some(GRAY_DIM.bold()),