wip: ratatui

Cargo.toml

@@ -6,4 +6,4 @@ edition = "2021"
 jack = "0.10"
 clap = { version = "4.5.4", features = [ "derive" ] }
 crossterm = "0.27"
-ratatui = "0.26.3"
+ratatui = { version = "0.26.3", features = [ "unstable-widget-ref" ] }

src/engine.rs

@@ -10,6 +10,10 @@ pub trait Exitable {
     fn exited (&self) -> bool;
 }
 
+pub trait HandleInput {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>>;
+}
+
 #[derive(Debug)]
 pub enum Event {
     /// An input event that must be handled.
@@ -87,36 +91,32 @@ impl Engine {
         })
     }
 
-    pub fn run <T: Exitable> (
-        &mut self,
-        state: &mut T,
-        mut render: impl FnMut(&mut T, &mut Stdout, (u16, u16)) -> Result<(), Box<dyn Error>>,
-        mut handle: impl FnMut(&mut T, &Event) -> Result<(), Box<dyn Error>>,
+    pub fn run <T: Exitable + WidgetRef + HandleInput> (
+        &mut self, mut state: T,
     ) -> Result<(), Box<dyn Error>> {
-        // JACK thread:
-        // Input thread:
-        // Render (main) thread:
-        crossterm::terminal::enable_raw_mode()?;
-        let stdout = &mut self.stdout;
-        stdout
-            .queue(crossterm::terminal::EnterAlternateScreen)?
-            .flush()?;
+        stdout().queue(EnterAlternateScreen)?.flush();
+        enable_raw_mode()?;
+        let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))?;
         let sleep = std::time::Duration::from_millis(20);
         loop {
-            stdout
-                .queue(crossterm::terminal::BeginSynchronizedUpdate)?
-                .queue(Clear(ClearType::All))?;
-            render(state, stdout, (0, 0))?;
-            stdout
-                .queue(crossterm::terminal::EndSynchronizedUpdate)?
-                .flush()?;
+            //stdout()
+                //.queue(crossterm::terminal::BeginSynchronizedUpdate)?
+                //.queue(Clear(ClearType::All))?;
+            terminal.draw(|frame|{
+                let area = frame.size();
+                frame.render_widget(&state, area);
+            });
+            //render(state, stdout, (0, 0))?;
+            //stdout()
+                //.queue(crossterm::terminal::EndSynchronizedUpdate)?
+                //.flush()?;
             // Handle event if present (`None` redraws)
             if let event = self.receiver.recv()? {
-                handle(state, &event)?;
+                state.handle(&event)?;
             }
             if state.exited() {
                 self.exited.store(true, Ordering::Relaxed);
-                stdout
+                stdout()
                     .queue(crossterm::terminal::LeaveAlternateScreen)?
                     .flush()?;
                 crossterm::terminal::disable_raw_mode()?;

src/looper/handle.rs

@@ -1,6 +1,12 @@
 use crate::prelude::*;
 use super::Looper;
 
+impl HandleInput for Looper {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
+        handle(self, event)
+    }
+}
+
 pub fn handle (state: &mut Looper, event: &Event) -> Result<(), Box<dyn Error>> {
     Ok(())
 }

src/looper/render.rs

@@ -1,6 +1,11 @@
 use crate::prelude::*;
 use super::{Looper, ACTIONS};
 
+impl WidgetRef for Looper {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+    }
+}
+
 pub fn render (
     state:  &mut Looper,
     stdout: &mut std::io::Stdout,

src/main.rs

@@ -16,6 +16,7 @@ pub mod sequencer;
 pub mod render;
 
 use crate::prelude::*;
+use crate::render::ActionBar;
 
 fn main () -> Result<(), Box<dyn Error>> {
     let cli = cli::Cli::parse();
@@ -28,65 +29,38 @@ fn main () -> Result<(), Box<dyn Error>> {
 
 fn run_one (command: &cli::Command) -> Result<(), Box<dyn Error>> {
     let mut engine = crate::engine::Engine::new(None)?;
-
     match command {
-
         cli::Command::Transport => engine.run(
-            &mut transport::Transport::new(engine.jack_client.as_client())?,
-            |state, stdout, mut offset| {
-                let (w, h) = render::render_toolbar_vertical(stdout, offset, &transport::ACTIONS)?;
-                offset.0 = offset.0 + w + 2;
-                transport::render(state, stdout, offset)
-            },
-            |_, _|Ok(())
+            transport::Transport::new(engine.jack_client.as_client())?,
         ),
-
         cli::Command::Mixer => engine.run(
-            &mut mixer::Mixer::new()?,
-            |state, stdout, mut offset| {
-                let (w, h) = render::render_toolbar_vertical(stdout, offset, &mixer::ACTIONS)?;
-                offset.0 = offset.0 + w + 2;
-                mixer::render(state, stdout, offset)
-            },
-            |_, _|Ok(())
+            mixer::Mixer::new()?,
         ),
-
         cli::Command::Looper => engine.run(
-            &mut looper::Looper::new()?,
-            |state, stdout, mut offset| {
-                let (w, h) = render::render_toolbar_vertical(stdout, offset, &looper::ACTIONS)?;
-                offset.0 = offset.0 + w + 2;
-                looper::render(state, stdout, offset)
-            },
-            |_, _|Ok(())
+            looper::Looper::new()?,
         ),
-
         cli::Command::Sampler => engine.run(
-            &mut sampler::Sampler::new()?,
-            |state, stdout, mut offset| {
-                let (w, h) = render::render_toolbar_vertical(stdout, offset, &sampler::ACTIONS)?;
-                offset.0 = offset.0 + w + 2;
-                sampler::render(state, stdout, offset)
-            },
-            |_, _|Ok(())
+            sampler::Sampler::new()?,
         ),
-
         cli::Command::Sequencer => engine.run(
-            &mut sequencer::Sequencer::new()?,
-            |state, stdout, mut offset| {
-                let (w, h) = render::render_toolbar_vertical(stdout, offset, &sequencer::ACTIONS)?;
-                offset.0 = offset.0 + w + 2;
-                sequencer::render(state, stdout, offset)
-            },
-            |_, _|Ok(())
+            sequencer::Sequencer::new()?,
         ),
-
     }
 }
 
 fn run_all () -> Result<(), Box<dyn Error>> {
-
     let mut engine = crate::engine::Engine::new(None)?;
+    engine.run(App {
+        exited:    false,
+        mode:      Mode::Sequencer,
+        transport: transport::Transport::new(engine.jack_client.as_client())?,
+        sequencer: sequencer::Sequencer::new()?,
+        mixer:     mixer::Mixer::new()?,
+        looper:    looper::Looper::new()?,
+        sampler:   sampler::Sampler::new()?,
+        actions:   vec![],
+    })
+}
 
 struct App {
     exited:    bool,
@@ -96,6 +70,7 @@ fn run_all () -> Result<(), Box<dyn Error>> {
     looper:    crate::looper::Looper,
     sampler:   crate::sampler::Sampler,
     sequencer: crate::sequencer::Sequencer,
+    actions:   Vec<(&'static str, &'static str)>
 }
 
 #[derive(PartialEq)]
@@ -116,109 +91,163 @@ fn run_all () -> Result<(), Box<dyn Error>> {
     }
 }
 
-    let mut actions = vec![];
+impl WidgetRef for App {
+    fn render_ref (&self, area: Rect, buffer: &mut Buffer) {
+        use ratatui::{widgets::*, style::Stylize};
+        let column_constraints = vec![
+            Constraint::Percentage(28),
+            Constraint::Percentage(72),
+        ];
+        let row_constraints = vec![
+            Constraint::Length(4),
+            Constraint::Length(14),
+            Constraint::Length(10),
+            Constraint::Length(10),
+            Constraint::Length(10),
+        ];
+        let cols = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints(column_constraints)
+            .split(area);
+        let side = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(row_constraints.clone())
+            .split(cols[0]);
+        let main = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(row_constraints)
+            .split(cols[1]);
 
-    let mut state = App {
-        exited:    false,
-        mode:      Mode::Sequencer,
-        transport: transport::Transport::new(engine.jack_client.as_client())?,
-        sequencer: sequencer::Sequencer::new()?,
-        mixer:     mixer::Mixer::new()?,
-        looper:    looper::Looper::new()?,
-        sampler:   sampler::Sampler::new()?,
-    };
+        Line::from(" Transport").render(side[0], buffer);
+        self.transport.render(main[0].inner(&Margin {
+            vertical:   0,
+            horizontal: 1,
+        }), buffer);
+        buffer.set_string(
+            area.x, main[1].y-1, "─".repeat(area.width as usize), Style::default().black().dim()
+        );
+        Line::from(" Piano roll").render(side[1], buffer);
+        self.sequencer.render(main[1].inner(&Margin {
+            vertical:   0,
+            horizontal: 1,
+        }), buffer);
+        buffer.set_string(
+            area.x, main[2].y+1, "─".repeat(area.width as usize), Style::default().black().dim()
+        );
 
-    let render = |state: &mut App, stdout: &mut Stdout, mut offset: (u16, u16)| {
-        actions.clear();
-        actions.extend_from_slice(&transport::ACTIONS);
-        match state.mode {
-            Mode::Transport => {},
-            Mode::Mixer     => actions.extend_from_slice(&mixer::ACTIONS),
-            Mode::Looper    => actions.extend_from_slice(&looper::ACTIONS),
-            Mode::Sampler   => actions.extend_from_slice(&sampler::ACTIONS),
-            Mode::Sequencer => actions.extend_from_slice(&sequencer::ACTIONS),
+        //Block::default()
+            //.title("Sampler")
+            //.borders(Borders::ALL)
+            //.render(rows[2], buffer);
+
+        //Block::default()
+            //.title("Mixer")
+            //.borders(Borders::ALL)
+            //.render(rows[3], buffer);
+
+        //Block::default()
+            //.title("Looper")
+            //.borders(Borders::ALL)
+            //.render(rows[4], buffer);
+
+
+        //let mut offset = (0, 0);
+        //let (w, h) = render::render_toolbar_vertical(stdout, (offset.0, offset.1 + 1), &actions)?;
+        //offset.0 = offset.0 + 20;
+
+        //transport::render(&mut state.transport, stdout, (offset.0 + 1, 1))?;
+        //render::render_box(stdout, Some("Transport"), offset.0, 0,  70, 4,
+            //state.mode == Mode::Transport)?;
+
+        //sequencer::render(&mut state.sequencer, stdout, (offset.0 + 1, 3))?;
+        //render::render_box(stdout, Some("Sequencer"), offset.0, 5,  70, 6,
+            //state.mode == Mode::Sequencer)?;
+
+        //sampler::render(&mut state.sampler, stdout, (offset.0 + 1, 10))?;
+        //render::render_box(stdout, Some("Sampler"),   offset.0, 12, 70, 4,
+            //state.mode == Mode::Sampler)?;
+
+        //mixer::render(&mut state.mixer, stdout, (offset.0 + 1, 18))?;
+        //render::render_box(stdout, Some("Mixer"),     offset.0, 17, 70, 9,
+            //state.mode == Mode::Mixer)?;
+
+        //looper::render(&mut state.looper, stdout, (offset.0 + 1, 28))?;
+        //render::render_box(stdout, Some("Looper"),    offset.0, 27, 70, 6,
+            //state.mode == Mode::Looper)?;
+
+        //Ok(())
+    }
 }
 
-        let (w, h) = render::render_toolbar_vertical(stdout, (offset.0, offset.1 + 1), &actions)?;
-        offset.0 = offset.0 + 20;
-
-        transport::render(&mut state.transport, stdout, (offset.0 + 1, 1))?;
-        render::render_box(stdout, Some("Transport"), offset.0, 0,  70, 4,
-            state.mode == Mode::Transport)?;
-
-        sequencer::render(&mut state.sequencer, stdout, (offset.0 + 1, 3))?;
-        render::render_box(stdout, Some("Sequencer"), offset.0, 5,  70, 6,
-            state.mode == Mode::Sequencer)?;
-
-        sampler::render(&mut state.sampler, stdout, (offset.0 + 1, 10))?;
-        render::render_box(stdout, Some("Sampler"),   offset.0, 12, 70, 4,
-            state.mode == Mode::Sampler)?;
-
-        mixer::render(&mut state.mixer, stdout, (offset.0 + 1, 18))?;
-        render::render_box(stdout, Some("Mixer"),     offset.0, 17, 70, 9,
-            state.mode == Mode::Mixer)?;
-
-        looper::render(&mut state.looper, stdout, (offset.0 + 1, 28))?;
-        render::render_box(stdout, Some("Looper"),    offset.0, 27, 70, 6,
-            state.mode == Mode::Looper)?;
-
-        Ok(())
-    };
-
-    let handle = |state: &mut App, event: &Event| {
+impl HandleInput for App {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
         //println!("{event:?}");
         if let Event::Input(crossterm::event::Event::Key(key)) = event {
             match key.code {
                 KeyCode::Char('c') => {
                     if key.modifiers == KeyModifiers::CONTROL {
-                        state.exit();
+                        self.exit();
                     }
                 },
                 KeyCode::Char(' ') => {
                     if key.modifiers == KeyModifiers::SHIFT {
-                        state.transport.play_from_start_or_stop_and_rewind();
+                        self.transport.play_from_start_or_stop_and_rewind();
                     } else {
-                        state.transport.play_or_pause().unwrap();
+                        self.transport.play_or_pause().unwrap();
                     }
                 },
-                KeyCode::Tab => match state.mode {
-                    Mode::Transport => state.mode = Mode::Sequencer,
-                    Mode::Sequencer => state.mode = Mode::Sampler,
-                    Mode::Sampler   => state.mode = Mode::Mixer,
-                    Mode::Mixer     => state.mode = Mode::Looper,
-                    Mode::Looper    => state.mode = Mode::Transport,
+                KeyCode::Tab => {
+                    match self.mode {
+                        Mode::Transport => self.mode = Mode::Sequencer,
+                        Mode::Sequencer => self.mode = Mode::Sampler,
+                        Mode::Sampler   => self.mode = Mode::Mixer,
+                        Mode::Mixer     => self.mode = Mode::Looper,
+                        Mode::Looper    => self.mode = Mode::Transport,
                         _ => {}
+                    };
+                    self.actions.clear();
+                    self.actions.extend_from_slice(&transport::ACTIONS);
+                    match self.mode {
+                        Mode::Transport => {},
+                        Mode::Mixer     => self.actions.extend_from_slice(&mixer::ACTIONS),
+                        Mode::Looper    => self.actions.extend_from_slice(&looper::ACTIONS),
+                        Mode::Sampler   => self.actions.extend_from_slice(&sampler::ACTIONS),
+                        Mode::Sequencer => self.actions.extend_from_slice(&sequencer::ACTIONS),
+                    }
                 },
-                KeyCode::BackTab => match state.mode {
-                    Mode::Transport => state.mode = Mode::Looper,
-                    Mode::Sequencer => state.mode = Mode::Transport,
-                    Mode::Sampler   => state.mode = Mode::Sequencer,
-                    Mode::Mixer     => state.mode = Mode::Sampler,
-                    Mode::Looper    => state.mode = Mode::Mixer,
+                KeyCode::BackTab => {
+                    match self.mode {
+                        Mode::Transport => self.mode = Mode::Looper,
+                        Mode::Sequencer => self.mode = Mode::Transport,
+                        Mode::Sampler   => self.mode = Mode::Sequencer,
+                        Mode::Mixer     => self.mode = Mode::Sampler,
+                        Mode::Looper    => self.mode = Mode::Mixer,
                         _ => {}
+                    };
+                    self.actions.clear();
+                    self.actions.extend_from_slice(&transport::ACTIONS);
+                    match self.mode {
+                        Mode::Transport => {},
+                        Mode::Mixer     => self.actions.extend_from_slice(&mixer::ACTIONS),
+                        Mode::Looper    => self.actions.extend_from_slice(&looper::ACTIONS),
+                        Mode::Sampler   => self.actions.extend_from_slice(&sampler::ACTIONS),
+                        Mode::Sequencer => self.actions.extend_from_slice(&sequencer::ACTIONS),
+                    }
                 },
-                _ => match state.mode {
-                    Mode::Transport => transport::handle(
-                        &mut state.transport, &event
-                    )?,
-                    Mode::Mixer => mixer::handle(
-                        &mut state.mixer, &event
-                    )?,
-                    Mode::Looper => looper::handle(
-                        &mut state.looper, &event
-                    )?,
-                    Mode::Sampler => sampler::handle(
-                        &mut state.sampler, &event
-                    )?,
-                    Mode::Sequencer => sequencer::handle(
-                        &mut state.sequencer, &event
-                    )?,
+                _ => match self.mode {
+                    Mode::Transport => self.transport
+                        .handle(&event)?,
+                    Mode::Mixer => self.mixer
+                        .handle(&event)?,
+                    Mode::Looper => self.looper
+                        .handle(&event)?,
+                    Mode::Sampler => self.sampler
+                        .handle(&event)?,
+                    Mode::Sequencer => self.sequencer
+                        .handle(&event)?,
                 }
             }
         }
         Ok(())
-    };
-
-    engine.run(&mut state, render, handle)
-
+    }
 }

src/mixer/handle.rs

@@ -1,6 +1,12 @@
 use crate::prelude::*;
 use super::Mixer;
 
+impl HandleInput for Mixer {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
+        handle(self, event)
+    }
+}
+
 pub fn handle (state: &mut Mixer, event: &Event) -> Result<(), Box<dyn Error>> {
 
     if let Event::Input(crossterm::event::Event::Key(event)) = event {

src/mixer/render.rs

@@ -1,6 +1,11 @@
 use crate::prelude::*;
 use super::{Mixer, ACTIONS};
 
+impl WidgetRef for Mixer {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+    }
+}
+
 pub fn render (
     state:  &mut Mixer,
     stdout: &mut Stdout,

src/prelude.rs

@@ -19,9 +19,19 @@ pub use crossterm::{
     QueueableCommand, 
     event::{self, KeyCode, KeyModifiers},
     cursor::{self, MoveTo, Show, Hide},
-    terminal::{self, Clear, ClearType},
+    terminal::{
+        self,
+        Clear, ClearType,
+        EnterAlternateScreen, LeaveAlternateScreen,
+        enable_raw_mode, disable_raw_mode
+    },
     style::*,
 };
+pub use ratatui::{
+    prelude::*,
+    widgets::WidgetRef,
+    //style::Stylize,
+};
 pub use jack::{
     AsyncClient,
     AudioIn,
@@ -45,4 +55,8 @@ pub use jack::{
 };
 pub type BoxedProcessHandler = Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
 pub type Jack<N> = AsyncClient<N, ClosureProcessHandler<BoxedProcessHandler>>;
-pub use crate::engine::{Exitable, Event};
+pub use crate::engine::{
+    Exitable,
+    HandleInput,
+    Event
+};

src/render.rs

@@ -1,5 +1,32 @@
 use crate::prelude::*;
 
+    //let render_with_actions = |actions| |state, frame: &mut Frame| {
+        //let layout = Layout::default()
+            //.direction(Direction::Horizontal)
+            //.constraints(vec![
+                //Constraint::Percentage(30),
+                //Constraint::Percentage(70),
+            //])
+            //.split(frame.size());
+        //frame.render_widget_ref(ActionBar(actions), layout[0]);
+        //frame.render_widget_ref(state, layout[1]);
+        //Ok(())
+    //};
+
+pub struct ActionBar<'a>(pub &'a [(&'static str, &'static str)]);
+
+impl<'a> WidgetRef for ActionBar<'a> {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+        let layout = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(self.0.iter().map(|_|Constraint::Length(3)).collect::<Vec<_>>())
+            .split(area);
+        for (index, action) in self.0.iter().enumerate() {
+            Line::raw(action.0).render(layout[index], buf);
+        }
+    }
+}
+
 pub fn render_toolbar_vertical (
     stdout:  &mut std::io::Stdout,
     offset:  (u16, u16),

src/sampler/handle.rs

@@ -1,6 +1,12 @@
 use crate::prelude::*;
 use super::Sampler;
 
+impl HandleInput for Sampler {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
+        handle(self, event)
+    }
+}
+
 pub fn handle (
     state: &mut Sampler,
     event: &Event

src/sampler/render.rs

@@ -1,6 +1,11 @@
 use crate::prelude::*;
 use super::Sampler;
 
+impl WidgetRef for Sampler {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+    }
+}
+
 pub fn render (
     state: &mut Sampler,
     stdout: &mut Stdout,

src/sequencer/handle.rs

@@ -1,7 +1,13 @@
 use crate::prelude::*;
 use super::Sequencer;
 
-pub fn handle (state: &mut Sequencer, event: &Event) -> Result<(), Box<dyn Error>> {
+impl HandleInput for Sequencer {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
+        handle(self, event)
+    }
+}
+
+fn handle (state: &mut Sequencer, event: &Event) -> Result<(), Box<dyn Error>> {
 
     if let Event::Input(crossterm::event::Event::Key(event)) = event {
 
@@ -12,7 +18,7 @@ pub fn handle (state: &mut Sequencer, event: &Event) -> Result<(), Box<dyn Error
                 }
             },
             KeyCode::Down => {
-                state.cursor.0 = if state.cursor.0 >= 3 {
+                state.cursor.0 = if state.cursor.0 >= 23 {
                     0
                 } else {
                     state.cursor.0 + 1
@@ -20,7 +26,7 @@ pub fn handle (state: &mut Sequencer, event: &Event) -> Result<(), Box<dyn Error
             },
             KeyCode::Up => {
                 state.cursor.0 = if state.cursor.0 == 0 {
-                    3
+                    23
                 } else {
                     state.cursor.0 - 1
                 }

src/sequencer/mod.rs

@@ -33,7 +33,8 @@ impl Sequencer {
 
     pub fn new () -> Result<Self, Box<dyn Error>> {
         let exited = Arc::new(AtomicBool::new(false));
-        let sequence: Arc<Mutex<Vec<Vec<Option<Event>>>>> = Arc::new(Mutex::new(vec![vec![None;64];4]));
+        let sequence: Arc<Mutex<Vec<Vec<Option<Event>>>>> = 
+            Arc::new(Mutex::new(vec![vec![None;64];128]));
         let (client, _status) = Client::new(
             "blinkenlive-sequencer",
             ClientOptions::NO_START_SERVER

src/sequencer/render.rs

@@ -1,81 +1,170 @@
 use crate::prelude::*;
 use super::Sequencer;
+use ratatui::style::Stylize;
 
-pub fn render (
-    state:  &mut Sequencer,
-    stdout: &mut Stdout,
-    offset: (u16, u16)
-) -> Result<(), Box<dyn Error>> {
-    //render_toolbar(state, stdout, offset)?;
-    render_grid(state, stdout, offset)?;
-    render_events(state, stdout, offset)?;
-    Ok(())
+const NOTE_NAMES: [&'static str;12] = [
+    "C ", "C#", "D ", "D#", "E ", "F ", "F#", "G ", "G#", "A ", "A#", "B ",
+];
+
+const KEYS: [&'static str; 6] = [
+    "▀",
+    "▀",
+    "▀",
+    "█",
+    "▄",
+    "▄",
+];
+
+impl WidgetRef for Sequencer {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+        render_sequence_header(area, buf);
+        render_sequence_keys(area, buf, &self.sequence);
+        render_sequence_cursor(area, buf, self.cursor);
+        let cursor = self.cursor;
+    }
 }
 
-fn render_grid (
-    state:  &mut Sequencer,
-    stdout: &mut Stdout,
-    offset: (u16, u16)
-) -> Result<(), Box<dyn Error>> {
-    let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
-    let cursor: String = if state.cursor.2 == 0 {
-        "❱".into()
-    } else {
-        std::iter::repeat("·")
-            .take(state.cursor.2 as usize)
-            .collect()
+fn render_sequence_header (
+    area: Rect, buf: &mut Buffer
+) {
+    buf.set_string(area.x,      area.y, "1.1.", Style::default().dim());
+    buf.set_string(area.x + 16, area.y, "1.2.", Style::default().dim());
+    buf.set_string(area.x + 32, area.y, "1.3.", Style::default().dim());
+    buf.set_string(area.x + 48, area.y, "1.4.", Style::default().dim());
+}
+
+fn render_sequence_keys (
+    area: Rect, buf: &mut Buffer, sequence: &Arc<Mutex<Vec<Vec<Option<super::Event>>>>>
+) {
+    let sequence = sequence.lock().unwrap();
+    for key in 0..12 {
+        buf.set_string(area.x - 3, area.y + 1 + key, KEYS[(key % 6) as usize],
+            Style::default().dim());
+        buf.set_string(area.x - 2, area.y + 1 + key, "█",
+            Style::default().dim());
+        buf.set_string(area.x, area.y + 1 + key, "·".repeat(64),
+            Style::default().black().dim());
+        buf.set_string(area.x, area.y + 1 + key, "┊",
+            Style::default().black().dim());
+        buf.set_string(area.x + 16, area.y + 1 + key, "┊",
+            Style::default().black().dim());
+        buf.set_string(area.x + 32, area.y + 1 + key, "┊",
+            Style::default().black().dim());
+        buf.set_string(area.x + 48, area.y + 1 + key, "┊",
+            Style::default().black().dim());
+        for step in 0..64 {
+            let top = sequence[(key * 2) as usize][step].is_some();
+            let bottom = sequence[(key * 2 + 1) as usize][step].is_some();
+            match (top, bottom) {
+                (true, true) => {
+                    buf.set_string(area.x + step as u16, area.y + 1 + key, "█",
+                        Style::default().yellow().bold());
+                },
+                (true, false) => {
+                    buf.set_string(area.x + step as u16, area.y + 1 + key, "▀",
+                        Style::default().yellow().bold());
+                },
+                (false, true) => {
+                    buf.set_string(area.x + step as u16, area.y + 1 + key, "▄",
+                        Style::default().yellow().bold());
+                },
+                (false, false) => {},
+            }
+        }
+    }
+}
+
+fn render_sequence_cursor (
+    area: Rect, buf: &mut Buffer, cursor: (u16, u16, u16)
+) {
+    let cursor_character = match cursor.0 % 2 {
+        0 => "▀",
+        1 => "▄",
+        _ => unreachable!()
     };
-    let transport = state.transport.query()?;
-    let frame  = transport.pos.frame();
-    let rate   = transport.pos.frame_rate().unwrap();
-    let second = (frame as f64) / (rate as f64);
-    let minute = second / 60f64;
-    let bpm    = 120f64;
-    let div    = 4;
-    let beats  = minute * bpm;
-    let bars   = beats as u32 / div as u32;
-    let beat   = beats as u32 % div as u32 + 1;
-    let beat_sub = beats % 1.0;
-    stdout
-        .queue(move_to(1,  3))?.queue(Print("1.1"))?
-        .queue(move_to(17, 3))?.queue(Print("1.2"))?
-        .queue(move_to(33, 3))?.queue(Print("1.3"))?
-        .queue(move_to(49, 3))?.queue(Print("1.4"))?;
-    let sequence = state.sequence.lock().unwrap();
-    for (index, row) in sequence.iter().enumerate() {
-        let y = index as u16 + 4;
-        for x in 0u16..64 {
-            let bg = if x as u32 == (beat - 1) * 16 + (beat_sub * 16.0) as u32 {
-                crossterm::style::Color::Black
+    let cursor_y = cursor.0 / 2;
+    buf.set_string(area.x + cursor.1, area.y + 1 + cursor_y, if cursor.2 == 0 {
+        cursor_character.into()
     } else {
-                crossterm::style::Color::Reset
-            };
-            if let Some(step) = &row[x as usize] {
-                stdout.queue(move_to(1 + x, y))?.queue(
-                    PrintStyledContent("X".white().bold().on(bg))
-                )?;
-            } else if x % 16 == 0 {
-                stdout.queue(move_to(1 + x, y))?.queue(
-                    PrintStyledContent("┊".grey().on(bg))
-                )?;
-            } else {
-                stdout.queue(move_to(1 + x, y))?.queue(
-                    PrintStyledContent("·".grey().on(bg))
-                )?;
-            }
-        }
-    }
-    stdout
-        .queue(move_to(1 + state.cursor.1, 4 + state.cursor.0))?
-        .queue(PrintStyledContent(cursor.reverse()))?;
-    Ok(())
+        cursor_character.repeat(cursor.2 as usize)
+    }, Style::default().yellow());
 }
 
-fn render_events (
-    state:  &mut Sequencer,
-    stdout: &mut Stdout,
-    offset: (u16, u16)
-) -> Result<(), Box<dyn Error>> {
-    Ok(())
-}
+//pub fn render (
+    //state:  &mut Sequencer,
+    //stdout: &mut Stdout,
+    //offset: (u16, u16)
+//) -> Result<(), Box<dyn Error>> {
+    ////render_toolbar(state, stdout, offset)?;
+    //render_grid(state, stdout, offset)?;
+    //render_events(state, stdout, offset)?;
+    //Ok(())
+//}
+
+//fn render_grid (
+    //state:  &mut Sequencer,
+    //stdout: &mut Stdout,
+    //offset: (u16, u16)
+//) -> Result<(), Box<dyn Error>> {
+    //let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
+    //let cursor: String = if state.cursor.2 == 0 {
+        //"❱".into()
+    //} else {
+        //std::iter::repeat("·")
+            //.take(state.cursor.2 as usize)
+            //.collect()
+    //};
+    //let transport = state.transport.query()?;
+    //let frame  = transport.pos.frame();
+    //let rate   = transport.pos.frame_rate().unwrap();
+    //let second = (frame as f64) / (rate as f64);
+    //let minute = second / 60f64;
+    //let bpm    = 120f64;
+    //let div    = 4;
+    //let beats  = minute * bpm;
+    //let bars   = beats as u32 / div as u32;
+    //let beat   = beats as u32 % div as u32 + 1;
+    //let beat_sub = beats % 1.0;
+    //stdout
+        //.queue(move_to(1,  3))?.queue(Print("1.1"))?
+        //.queue(move_to(17, 3))?.queue(Print("1.2"))?
+        //.queue(move_to(33, 3))?.queue(Print("1.3"))?
+        //.queue(move_to(49, 3))?.queue(Print("1.4"))?;
+    //let sequence = state.sequence.lock().unwrap();
+    //for (index, row) in sequence.iter().enumerate() {
+        //let y = index as u16 + 4;
+        //for x in 0u16..64 {
+            //let bg = if x as u32 == (beat - 1) * 16 + (beat_sub * 16.0) as u32 {
+                //crossterm::style::Color::Black
+            //} else {
+                //crossterm::style::Color::Reset
+            //};
+            //if let Some(step) = &row[x as usize] {
+                //stdout.queue(move_to(1 + x, y))?.queue(
+                    //PrintStyledContent("X".white().bold().on(bg))
+                //)?;
+            //} else if x % 16 == 0 {
+                //stdout.queue(move_to(1 + x, y))?.queue(
+                    //PrintStyledContent("┊".grey().on(bg))
+                //)?;
+            //} else {
+                //stdout.queue(move_to(1 + x, y))?.queue(
+                    //PrintStyledContent("·".grey().on(bg))
+                //)?;
+            //}
+        //}
+    //}
+    //stdout
+        //.queue(move_to(1 + state.cursor.1, 4 + state.cursor.0))?
+        //.queue(PrintStyledContent(cursor.reverse()))?;
+    //Ok(())
+//}
+
+//fn render_events (
+    //state:  &mut Sequencer,
+    //stdout: &mut Stdout,
+    //offset: (u16, u16)
+//) -> Result<(), Box<dyn Error>> {
+    //Ok(())
+//}
 

src/transport/handle.rs

@@ -1,6 +1,8 @@
 use crate::prelude::*;
 use super::*;
 
-pub fn handle (state: &mut super::Transport, event: &Event) -> Result<(), Box<dyn Error>> {
+impl HandleInput for super::Transport {
+    fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
         Ok(())
     }
+}

src/transport/render.rs

@@ -1,6 +1,47 @@
 use crate::prelude::*;
 use super::{Transport, ACTIONS};
 
+impl WidgetRef for Transport {
+    fn render_ref (&self, area: Rect, buf: &mut Buffer) {
+        use ratatui::{layout::*, widgets::*, style::Stylize};
+        Line::from("Project:").render(area, buf);
+        if let Ok(position) = self.transport.query() {
+            let frame = position.pos.frame();
+            let rate  = position.pos.frame_rate();
+            let bbt   = position.pos.bbt().map(|mut bbt|*bbt
+                .with_bpm(self.bpm)
+                .with_timesig(self.timesig.0, self.timesig.1));
+            Line::from("Frame:").render(area.clone().offset(Offset { x: 0, y: 1 }), buf);
+            Line::from(format!("{frame}")).render(area.clone().offset(Offset { x: 0, y: 2 }), buf);
+            Line::from("Rate:").render(area.clone().offset(Offset { x: 10, y: 1 }), buf);
+            Line::from(match rate {
+                Some(rate) => format!("{rate}Hz"),
+                None       => String::from("(none)"),
+            }).render(area.clone().offset(Offset { x: 10, y: 2 }), buf);
+            Line::from("Time:").render(area.clone().offset(Offset { x: 20, y: 1 }), buf);
+            Line::from(match rate {
+                Some(rate) => format!("{:.03}", frame as f64 / rate as f64),
+                None       => String::from("(none)")
+            }).render(area.clone().offset(Offset { x: 20, y: 2 }), buf);
+            Line::from("BPM:").render(area.clone().offset(Offset { x: 30, y: 1 }), buf);
+            Line::from(match bbt {
+                Some(bbt)  => format!("{:.01}", bbt.bpm),
+                None       => String::from("(none)")
+            }).render(area.clone().offset(Offset { x: 30, y: 2 }), buf);
+            Line::from("TimeSig:").render(area.clone().offset(Offset { x: 40, y: 1 }), buf);
+            Line::from(match bbt {
+                Some(bbt)  => format!("{}/{}", bbt.sig_num, bbt.sig_denom),
+                None       => String::from("(none)")
+            }).render(area.clone().offset(Offset { x: 40, y: 2 }), buf);
+            Line::from("Beat:").render(area.clone().offset(Offset { x: 50, y: 1 }), buf);
+            Line::from(match bbt {
+                Some(bbt)  => format!("{}.{}.{}", bbt.bar, bbt.beat, bbt.tick),
+                None       => String::from("(none)")
+            }).render(area.clone().offset(Offset { x: 50, y: 2 }), buf);
+        }
+    }
+}
+
 pub fn render (
     state:  &mut Transport,
     stdout: &mut Stdout,