wip: render: remove render! macro

crates/tek_core/src/lib.rs

@@ -106,8 +106,8 @@ pub trait ExitableComponent<T, U>: Exit + Component<T, U> {
 impl<E: Exit + Component<T, U>, T, U> ExitableComponent<T, U> for E {}
 
 /// Run the main loop.
-pub fn run <'a, R> (state: Arc<RwLock<R>>) -> Usually<Arc<RwLock<R>>>
+pub fn run <R> (state: Arc<RwLock<R>>) -> Usually<Arc<RwLock<R>>>
-    where R: Render<TuiOutput<'a>, Rect> + Handle + Sized + 'static
+    where R: for <'a> Render<TuiOutput<'a>, Rect> + Handle + Sized + 'static
 {
     let exited = Arc::new(AtomicBool::new(false));
     let _input_thread = input_thread(&exited, &state);

crates/tek_core/src/render_split.rs

@@ -56,7 +56,7 @@ impl<'a, T, U> Collect<'a, T, U> for Split<'a, T, U> {
 
 impl<'a> Render<TuiOutput<'a>, Rect> for Split<'a, TuiOutput<'a>, Rect> {
     fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
-        Ok(Some(self.render_areas(to)?.0))
+        Ok(None)//Rect::default())//Some(self.render_areas(to)?.0))
     }
 }
 

crates/tek_core/src/render_tui.rs

@@ -1,6 +1,7 @@
 use crate::*;
 
 pub(crate) use ratatui::buffer::Cell;
+use ratatui::backend::Backend;
 
 pub struct TuiOutput<'a> {
     pub buffer: &'a mut Buffer,
@@ -8,24 +9,29 @@ pub struct TuiOutput<'a> {
 }
 
 /// Main thread render loop
-pub fn tui_render_thread <'a: 'static, T> (
+pub fn tui_render_thread <T> (exited: &Arc<AtomicBool>, device: &Arc<RwLock<T>>)
-    exited: &Arc<AtomicBool>, device: &Arc<RwLock<T>>,
+    -> Usually<JoinHandle<()>>
-) -> Usually<JoinHandle<()>> where
+where
-    T: Render<TuiOutput<'a>, Rect> + 'static
+    T: for <'a> Render<TuiOutput<'a>, Rect> + 'static
 {
     let exited      = exited.clone();
     let device      = device.clone();
-    let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))?;
+    let mut backend = CrosstermBackend::new(stdout());
+    let area        = backend.size()?;
+    let mut buffers = [Buffer::empty(area), Buffer::empty(area)];
+    let mut index   = 0;
     let sleep       = Duration::from_millis(20);
     Ok(spawn(move || {
-        let draw = |frame: &'a mut ratatui::Frame|{
-            let area   = frame.size();
-            let buffer = frame.buffer_mut();
-            device.render(&mut TuiOutput { buffer, area }).expect("Failed to render content");
-        };
         loop {
-            if let Ok(_) = device.try_read() {
+            if let Ok(device) = device.try_read() {
-                terminal.draw(draw).expect("Failed to render frame");
+                let mut target = TuiOutput { buffer: &mut buffers[index], area };
+                device.render(&mut target).expect("render failed");
+                let previous_buffer = &buffers[1 - index];
+                let current_buffer  = &buffers[index];
+                let updates = previous_buffer.diff(current_buffer);
+                backend.draw(updates.into_iter());
+                buffers[1 - index].reset();
+                index = 1 - index;
             }
             if exited.fetch_and(true, Ordering::Relaxed) {
                 break

crates/tek_mixer/src/mixer_render.rs

@@ -1,6 +1,7 @@
 use crate::*;
 
-render!(Mixer |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for Mixer {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
         let mut x = 0;
         for channel in self.tracks.iter() {
             x = x + channel.render(buf, Rect {
@@ -14,4 +15,5 @@ render!(Mixer |self, buf, area| {
             }
         }
         Ok(area)
-});
+    }
+}

crates/tek_mixer/src/plugin.rs

@@ -9,9 +9,43 @@ pub struct Plugin {
     pub mapping:  bool,
     pub ports:    JackPorts,
 }
-render!(Plugin = render_plugin);
 handle!(Plugin |self, e| handle_keymap(self, e, KEYMAP_PLUGIN));
 process!(Plugin = Plugin::process);
+impl<'a> Render<TuiOutput<'a>, Rect> for Plugin {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
+        let Rect { x, y, height, .. } = area;
+        let mut width = 20u16;
+        match &state.plugin {
+            Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
+                let start = state.selected.saturating_sub((height as usize / 2).saturating_sub(1));
+                let end   = start + height as usize - 2;
+                //draw_box(buf, Rect { x, y, width, height });
+                for i in start..end {
+                    if let Some(port) = port_list.get(i) {
+                        let value = if let Some(value) = instance.control_input(port.index) {
+                            value
+                        } else {
+                            port.default_value
+                        };
+                        //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
+                        let label = &format!("{:25} = {value:.03}", port.name);
+                        width = width.max(label.len() as u16 + 4);
+                        label.blit(buf, x + 2, y + 1 + i as u16 - start as u16, if i == state.selected {
+                            Some(Style::default().green())
+                        } else {
+                            None
+                        })?;
+                    } else {
+                        break
+                    }
+                }
+            },
+            _ => {}
+        };
+        draw_header(state, buf, area.x, area.y, width)?;
+        Ok(Some(Rect { width, ..area }))
+    }
+}
 
 /// Supported plugin formats.
 pub enum PluginKind {
@@ -21,7 +55,6 @@ pub enum PluginKind {
     },
     VST3,
 }
-
 impl Plugin {
     pub fn new_lv2 (name: &str, path: &str) -> Usually<JackDevice> {
         let plugin = LV2Plugin::new(path)?;
@@ -102,43 +135,6 @@ impl Plugin {
         Control::Continue
     }
 }
-
-pub fn render_plugin (state: &Plugin, buf: &mut Buffer, area: Rect)
-    -> Usually<Rect>
-{
-    let Rect { x, y, height, .. } = area;
-    let mut width = 20u16;
-    match &state.plugin {
-        Some(PluginKind::LV2(LV2Plugin { port_list, instance, .. })) => {
-            let start = state.selected.saturating_sub((height as usize / 2).saturating_sub(1));
-            let end   = start + height as usize - 2;
-            //draw_box(buf, Rect { x, y, width, height });
-            for i in start..end {
-                if let Some(port) = port_list.get(i) {
-                    let value = if let Some(value) = instance.control_input(port.index) {
-                        value
-                    } else {
-                        port.default_value
-                    };
-                    //let label = &format!("C·· M·· {:25} = {value:.03}", port.name);
-                    let label = &format!("{:25} = {value:.03}", port.name);
-                    width = width.max(label.len() as u16 + 4);
-                    label.blit(buf, x + 2, y + 1 + i as u16 - start as u16, if i == state.selected {
-                        Some(Style::default().green())
-                    } else {
-                        None
-                    })?;
-                } else {
-                    break
-                }
-            }
-        },
-        _ => {}
-    };
-    draw_header(state, buf, area.x, area.y, width)?;
-    Ok(Rect { width, ..area })
-}
-
 fn draw_header (state: &Plugin, buf: &mut Buffer, x: u16, y: u16, w: u16) -> Usually<Rect> {
     let style  = Style::default().gray();
     let label1 = format!(" {}", state.name);

crates/tek_mixer/src/sample_add.rs

@@ -22,12 +22,13 @@ pub struct AddSampleModal {
 
 exit!(AddSampleModal);
 
-render!(AddSampleModal |self,buf,area|{
+impl<'a> Render<TuiOutput<'a>, Rect> for AddSampleModal {
-    make_dim(buf);
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
+        make_dim(to.buffer);
         let area = center_box(
-        area,
+            to.area,
-        64.max(area.width.saturating_sub(8)),
+            64.max(to.area.width.saturating_sub(8)),
-        20.max(area.width.saturating_sub(8)),
+            20.max(to.area.width.saturating_sub(8)),
         );
         fill_fg(buf, area, Color::Reset);
         fill_bg(buf, area, Nord::bg_lo(true, true));
@@ -55,7 +56,8 @@ render!(AddSampleModal |self,buf,area|{
             }))?;
         }
         Lozenge(Style::default()).draw(buf, area)
-});
+    }
+}
 
 handle!(AddSampleModal |self,e|{
     if handle_keymap(self, e, KEYMAP_ADD_SAMPLE)? {

crates/tek_mixer/src/sampler.rs

@@ -15,8 +15,11 @@ pub struct Sampler {
 }
 
 process!(Sampler = Sampler::process);
+
 handle!(Sampler |self, event| handle_keymap(self, event, KEYMAP_SAMPLER));
-render!(Sampler |self, buf, area| {
+
+impl<'a> Render<TuiOutput<'a>, Rect> for Sampler {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
         let Rect { x, y, height, .. } = area;
         let style = Style::default().gray();
         let title = format!(" {} ({})", self.name, self.voices.read().unwrap().len());
@@ -38,7 +41,8 @@ render!(Sampler |self, buf, area| {
         }
         let height = ((2 + y1) as u16).min(height);
         Ok(Rect { x, y, width: (width as u16).min(area.width), height })
-});
+    }
+}
 
 fn draw_sample (
     buf: &mut Buffer, x: u16, y: u16, note: Option<&u7>, sample: &Sample, focus: bool

crates/tek_mixer/src/track_view.rs

@@ -1,7 +1,9 @@
 use crate::*;
 use tek_core::Direction;
 
-render!(Track |self, buf, area| TrackView {
+impl<'a> Render<TuiOutput<'a>, Rect> for Track {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
+        TrackView {
             chain:     Some(&self),
             direction: tek_core::Direction::Right,
             focused:   true,
@@ -19,17 +21,17 @@ render!(Track |self, buf, area| TrackView {
             //pub output_ports:      Vec<Port<AudioOut>>,
             //pub post_fader_meter:  f64,
             //pub route:             String,
-}.render(buf, area));
+        }.render(to)
-
+    }
+}
 pub struct TrackView<'a> {
     pub chain:     Option<&'a Track>,
     pub direction: Direction,
     pub focused:   bool,
     pub entered:   bool,
 }
-
+impl<'a> Render<TuiOutput<'a>, Rect> for TrackView<'a> {
-impl<'a> Render for TrackView<'a> {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
-    fn render (&self, buf: &mut Buffer, mut area: Rect) -> Usually<Rect> {
         if let Some(chain) = self.chain {
             match self.direction {
                 Direction::Down  => area.width = area.width.min(40),

crates/tek_sequencer/src/arranger_rename.rs

@@ -35,7 +35,8 @@ impl ArrangerRenameModal {
     }
 }
 
-render!(ArrangerRenameModal |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for ArrangerRenameModal {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
         let y = area.y + area.height / 2;
         let bg_area = Rect {
             x: 1,
@@ -58,7 +59,8 @@ render!(ArrangerRenameModal |self, buf, area| {
         let style = Some(Style::default().bold().white().not_dim().reversed());
         "▂".blit(buf, area.x + 3 + label.len() as u16 + 1 + self.cursor as u16, y, style)?;
         Ok(area)
-});
+    }
+}
 
 handle!(ArrangerRenameModal |self, e| {
     match e {

crates/tek_sequencer/src/arranger_view.rs

@@ -19,19 +19,23 @@ impl ArrangerViewMode {
     }
 }
 
-render!(Arranger |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for Arranger {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
         let area = Rect {
-        x: area.x + 1, width: area.width - 2, y: area.y + 1, height: area.height - 2
+            x:      to.area.x + 1,
+            width:  to.area.width - 2,
+            y:      to.area.y + 1,
+            height: to.area.height - 2
         };
         let area = match self.mode {
             ArrangerViewMode::Horizontal =>
-            super::arranger_view_h::draw(self, buf, area),
+                super::arranger_view_h::draw(self, to.buffer, area),
             ArrangerViewMode::VerticalCompact1 =>
-            super::arranger_view_v::draw_compact_1(self, buf, area),
+                super::arranger_view_v::draw_compact_1(self, to.buffer, area),
             ArrangerViewMode::VerticalCompact2 =>
-            super::arranger_view_v::draw_compact_2(self, buf, area),
+                super::arranger_view_v::draw_compact_2(self, to.buffer, area),
             ArrangerViewMode::VerticalExpanded =>
-            super::arranger_view_v::draw_expanded(self, buf, area),
+                super::arranger_view_v::draw_expanded(self, to.buffer, area),
         }?;
         let area = Rect {
             x: area.x - 1,
@@ -39,5 +43,6 @@ render!(Arranger |self, buf, area| {
             y: area.y - 1,
             height: area.height + 2,
         };
-    Lozenge(Style::default().fg(Nord::BG2)).draw(buf, area)
+        Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, area)
-});
+    }
+}

crates/tek_sequencer/src/sequencer_view.rs

@@ -1,12 +1,14 @@
 use crate::*;
 
-render!(Sequencer |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for Sequencer {
-    self.horizontal_draw(buf, area)?;
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
+        self.horizontal_draw(target)?;
         if self.focused && self.entered {
             Corners(Style::default().green().not_dim()).draw(buf, area)?;
         }
         Ok(area)
-});
+    }
+}
 
 impl Sequencer {
     /// Select which pattern to display. This pre-renders it to the buffer at full resolution.

crates/tek_sequencer/src/sequencer_view_h.rs

@@ -47,7 +47,7 @@ const STYLE_VALUE: Option<Style> = Some(Style {
 
 struct SequenceName<'a>(&'a Sequencer);
 
-impl<'a> Render for SequenceName<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceName<'a> {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let Rect { x, y, .. } = area;
         let frame = Rect { x, y, width: 10, height: 4 };
@@ -60,7 +60,7 @@ impl<'a> Render for SequenceName<'a> {
 
 struct SequenceRange;
 
-impl Render for SequenceRange {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceRange {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let Rect { x, y, .. } = area;
         let frame = Rect { x, y, width: 10, height: 6 };
@@ -75,7 +75,7 @@ impl Render for SequenceRange {
 
 struct SequenceLoopRange;
 
-impl Render for SequenceLoopRange {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceLoopRange {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let Rect { x, y, .. } = area;
         let range = Rect { x, y, width: 10, height: 7 };
@@ -91,7 +91,7 @@ impl Render for SequenceLoopRange {
 
 struct SequenceNoteRange;
 
-impl Render for SequenceNoteRange {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceNoteRange {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let Rect { x, y, .. } = area;
         let range = Rect { x, y, width: 10, height: 9 };
@@ -109,7 +109,7 @@ impl Render for SequenceNoteRange {
 
 struct SequenceKeys<'a>(&'a Sequencer);
 
-impl<'a> Render for SequenceKeys<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceKeys<'a> {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         if area.height < 2 {
             return Ok(area)
@@ -132,7 +132,7 @@ impl<'a> Render for SequenceKeys<'a> {
 
 struct SequenceNotes<'a>(&'a Sequencer);
 
-impl<'a> Render for SequenceNotes<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceNotes<'a> {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         if area.height < 2 {
             return Ok(area)
@@ -160,7 +160,7 @@ impl<'a> Render for SequenceNotes<'a> {
 
 struct SequenceCursor<'a>(&'a Sequencer);
 
-impl<'a> Render for SequenceCursor<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceCursor<'a> {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         if let (Some(time), Some(note)) = (self.0.time_axis.point, self.0.note_axis.point) {
             let x = area.x + Sequencer::H_KEYS_OFFSET as u16 + time as u16;
@@ -175,7 +175,7 @@ impl<'a> Render for SequenceCursor<'a> {
 
 struct SequenceZoom<'a>(&'a Sequencer);
 
-impl<'a> Render for SequenceZoom<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceZoom<'a> {
     fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         let quant = ppq_to_name(self.0.time_axis.scale);
         let quant_x = area.x + area.width - 1 - quant.len() as u16;
@@ -186,8 +186,8 @@ impl<'a> Render for SequenceZoom<'a> {
 
 struct SequenceTimer<'a>(&'a Sequencer, Arc<RwLock<Phrase>>);
 
-impl<'a> Render for SequenceTimer<'a> {
+impl<'a> Render<TuiOutput<'a>, Rect> for SequenceTimer<'a> {
-    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+    fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
         let phrase = self.1.read().unwrap();
         let (time0, time_z, now) = (
             self.0.time_axis.start, self.0.time_axis.scale, self.0.now % phrase.length

crates/tek_sequencer/src/transport_render.rs

@@ -2,8 +2,9 @@ use crate::*;
 
 const CORNERS: Corners = Corners(NOT_DIM_GREEN);
 
-render!(TransportToolbar |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportToolbar {
-    let mut area = area;
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
+        let mut area = target.area;
         area.height = 2;
         let area = Split::right()
             .add_ref(&self.playing)
@@ -11,17 +12,19 @@ render!(TransportToolbar |self, buf, area| {
             .add_ref(&self.quant)
             .add_ref(&self.sync)
             .add_ref(&self.clock)
-        .render(buf, area)?;
+            .render(target)?;
         //if self.is_focused() {
             //fill_bg(buf, area, COLOR_BG0);
             //CORNERS_DIM.draw(buf, area)?;
         //}
         Ok(area)
-});
+    }
+}
 
-render!(TransportPlayPauseButton |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportPlayPauseButton {
-    let Rect { x, y, .. } = area;
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
-    let Self { value, focused } = self;
+        let Rect { x, y, .. } = target.area;
+        let Self { value, focused } = &self;
         let style = Some(match value {
             Some(TransportState::Stopped)  => GRAY_DIM.bold(),
             Some(TransportState::Starting) => GRAY_NOT_DIM_BOLD,
@@ -34,18 +37,20 @@ render!(TransportPlayPauseButton |self, buf, area| {
             Some(TransportState::Stopped)  => "⏹ STOPPED",
             _ => unreachable!(),
         };
-    let mut area = label.blit(buf, x + 1, y, style)?;
+        let mut area = label.blit(target.buffer, x + 1, y, style)?.unwrap();
         area.width = area.width + 1;
         area.height = area.height + 1;
         if *focused {
             let area = Rect { x: area.x - 1, width: area.width - 1, ..area };
-        CORNERS.draw(buf, area)?;
+            CORNERS.draw(target)?;
-        fill_bg(buf, area, COLOR_BG1);
+            fill_bg(target.buffer, target.area, COLOR_BG1);
         }
         Ok(area)
-});
+    }
+}
 
-render!(TransportBPM |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportBPM {
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
         let Rect { x, y, .. } = area;
         let Self { value, focused } = self;
         "BPM".blit(buf, x, y, Some(NOT_DIM))?;
@@ -57,9 +62,11 @@ render!(TransportBPM |self, buf, area| {
             fill_bg(buf, area, COLOR_BG1);
         }
         Ok(area)
-});
+    }
+}
 
-render!(TransportQuantize |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportQuantize {
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
         let Rect { x, y, .. } = area;
         let Self { value, focused } = self;
         "QUANT".blit(buf, x, y, Some(NOT_DIM))?;
@@ -71,9 +78,11 @@ render!(TransportQuantize |self, buf, area| {
             fill_bg(buf, area, COLOR_BG1);
         }
         Ok(area)
-});
+    }
+}
 
-render!(TransportSync |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportSync {
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
         let Rect { x, y, .. } = area;
         let Self { value, focused } = self;
         "SYNC".blit(buf, x, y, Some(NOT_DIM))?;
@@ -85,9 +94,11 @@ render!(TransportSync |self, buf, area| {
             fill_bg(buf, area, COLOR_BG1);
         }
         Ok(area)
-});
+    }
+}
 
-render!(TransportClock |self, buf, area| {
+impl<'a> Render<TuiOutput<'a>, Rect> for TransportClock {
+    fn render (&self, target: &mut TuiOutput<'a>) -> Perhaps<Rect> {
         let Rect { x, y, width, .. } = area;
         let Self { frame, pulse, ppq, usecs, focused } = self;
         let (beats, pulses)    = if *ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
@@ -106,4 +117,5 @@ render!(TransportClock |self, buf, area| {
             fill_bg(buf, area, COLOR_BG1);
         }
         Ok(area)
-});
+    }
+}