separate tui model and view layers

crates/tek_tui/src/tui_view_phrase_editor.rs

@@ -0,0 +1,365 @@
+use crate::*;
+
+impl Widget for PhraseEditorModel {
+    type Engine = Tui;
+    fn layout (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
+        PhraseView(self).layout(to)
+    }
+    fn render (&self, to: &mut TuiOutput) -> Usually<()> {
+        PhraseView(self).render(to)
+    }
+}
+
+pub struct PhraseView<'a, T: PhraseViewState>(pub &'a T);
+
+impl<'a, T: PhraseViewState> Content for PhraseView<'a, T> {
+    type Engine = Tui;
+    fn content (&self) -> impl Widget<Engine = Tui> {
+        let phrase    = self.0.phrase_editing();
+        let size      = self.0.size();
+        let focused   = self.0.phrase_editor_focused();
+        let entered   = self.0.phrase_editor_entered();
+        let keys      = self.0.keys();
+        let buffer    = self.0.buffer();
+        let note_len  = self.0.note_len();
+        let note_axis = self.0.note_axis();
+        let time_axis = self.0.time_axis();
+        let FixedAxis  { start: note_start, point: note_point, clamp: note_clamp }
+            = *note_axis.read().unwrap();
+        let ScaledAxis { start: time_start, point: time_point, clamp: time_clamp, scale: time_scale }
+            = *time_axis.read().unwrap();
+        //let color = Color::Rgb(0,255,0);
+        //let color = phrase.as_ref().map(|p|p.read().unwrap().color.base.rgb).unwrap_or(color);
+        let keys = CustomWidget::new(|to:[u16;2]|Ok(Some(to.clip_w(5))), move|to: &mut TuiOutput|{
+            Ok(if to.area().h() >= 2 {
+                to.buffer_update(to.area().set_w(5), &|cell, x, y|{
+                    let y = y + (note_start / 2) as u16;
+                    if x < keys.area.width && y < keys.area.height {
+                        *cell = keys.get(x, y).clone()
+                    }
+                });
+            })
+        }).fill_y();
+        let notes_bg_null = Color::Rgb(28, 35, 25);
+        let notes = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
+            let area = to.area();
+            let h = area.h() as usize;
+            size.set_wh(area.w(), h);
+            let mut axis = note_axis.write().unwrap();
+            if let Some(point) = axis.point {
+                if point.saturating_sub(axis.start) > (h * 2).saturating_sub(1) {
+                    axis.start += 2;
+                }
+            }
+            Ok(if to.area().h() >= 2 {
+                let area = to.area();
+                to.buffer_update(area, &move |cell, x, y|{
+                    cell.set_bg(notes_bg_null);
+                    let src_x = (x as usize + time_start) * time_scale;
+                    let src_y = y as usize + note_start / 2;
+                    if src_x < buffer.width && src_y < buffer.height - 1 {
+                        buffer.get(src_x, buffer.height - src_y - 2).map(|src|{
+                            cell.set_symbol(src.symbol());
+                            cell.set_fg(src.fg);
+                            cell.set_bg(src.bg);
+                        });
+                    }
+                });
+            })
+        }).fill_x();
+        let cursor = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
+            Ok(if focused && entered {
+                let area = to.area();
+                if let (Some(time), Some(note)) = (time_point, note_point) {
+                    let x1 = area.x() + (time / time_scale) as u16;
+                    let x2 = x1 + (note_len / time_scale) as u16;
+                    let y = area.y() + note.saturating_sub(note_start) as u16 / 2;
+                    let c = if note % 2 == 0 { "▀" } else { "▄" };
+                    for x in x1..x2 {
+                        to.blit(&c, x, y, Some(Style::default().fg(Color::Rgb(0,255,0))));
+                    }
+                }
+            })
+        });
+        let playhead_inactive = Style::default().fg(Color::Rgb(255,255,255)).bg(Color::Rgb(40,50,30));
+        let playhead_active   = playhead_inactive.clone().yellow().bold().not_dim();
+        let playhead = CustomWidget::new(
+            |to:[u16;2]|Ok(Some(to.clip_h(1))),
+            move|to: &mut TuiOutput|{
+                if let Some(_) = phrase {
+                    let now = self.0.now().get() as usize; // TODO FIXME: self.now % phrase.read().unwrap().length;
+                    let time_clamp = time_clamp
+                        .expect("time_axis of sequencer expected to be clamped");
+                    for x in 0..(time_clamp/time_scale).saturating_sub(time_start) {
+                        let this_step = time_start + (x + 0) * time_scale;
+                        let next_step = time_start + (x + 1) * time_scale;
+                        let x         = to.area().x() + x as u16;
+                        let active    = this_step <= now && now < next_step;
+                        let character = if active { "|" } else { "·" };
+                        let style     = if active { playhead_active } else { playhead_inactive };
+                        to.blit(&character, x, to.area.y(), Some(style));
+                    }
+                }
+                Ok(())
+            }
+        ).push_x(6).align_sw();
+        let border_color    = if focused{Color::Rgb(100, 110, 40)}else{Color::Rgb(70,   80,  50)};
+        let title_color     = if focused{Color::Rgb(150, 160, 90)}else{Color::Rgb(120, 130, 100)};
+        let border          = Lozenge(Style::default().bg(Color::Rgb(40, 50, 30)).fg(border_color));
+        let note_area       = lay!(notes, cursor).fill_x();
+        let piano_roll      = row!(keys, note_area).fill_x();
+        let content         = piano_roll.bg(Color::Rgb(40, 50, 30)).border(border);
+        let content         = lay!(content, playhead);
+        let mut upper_left  = format!("[{}] Sequencer", if entered {"■"} else {" "});
+        if let Some(phrase) = phrase {
+            upper_left = format!("{upper_left}: {}", phrase.read().unwrap().name);
+        }
+        let mut lower_right = format!("┤{}├", size.format());
+        lower_right = format!("┤Zoom: {}├─{lower_right}", pulses_to_name(time_scale));
+        //lower_right = format!("Zoom: {} (+{}:{}*{}|{})",
+            //pulses_to_name(time_scale),
+            //time_start, time_point.unwrap_or(0),
+            //time_scale, time_clamp.unwrap_or(0),
+        //);
+        if focused && entered {
+            lower_right = format!("┤Note: {} {}├─{lower_right}",
+                note_axis.read().unwrap().point.unwrap(),
+                pulses_to_name(note_len));
+            //lower_right = format!("Note: {} (+{}:{}|{})  {upper_right}",
+                //pulses_to_name(*note_len),
+                //note_start,
+                //note_point.unwrap_or(0),
+                //note_clamp.unwrap_or(0),
+            //);
+        }
+        let upper_right = if let Some(phrase) = phrase {
+            format!("┤Length: {}├", phrase.read().unwrap().length)
+        } else {
+            String::new()
+        };
+        lay!(
+            content,
+            TuiStyle::fg(upper_left.to_string(),  title_color).push_x(1).align_nw().fill_xy(),
+            TuiStyle::fg(upper_right.to_string(), title_color).pull_x(1).align_ne().fill_xy(),
+            TuiStyle::fg(lower_right.to_string(), title_color).pull_x(1).align_se().fill_xy(),
+        )
+    }
+}
+
+pub trait PhraseViewState: Send + Sync {
+    fn phrase_editing (&self) -> &Option<Arc<RwLock<Phrase>>>;
+    fn phrase_editor_focused (&self) -> bool;
+    fn phrase_editor_size (&self) -> &Measure<Tui>;
+    fn phrase_editor_entered (&self) -> bool;
+    fn keys (&self) -> &Buffer;
+    fn buffer (&self) -> &BigBuffer;
+    fn note_len (&self) -> usize;
+    fn note_axis (&self) -> &RwLock<FixedAxis<usize>>;
+    fn time_axis (&self) -> &RwLock<ScaledAxis<usize>>;
+    fn now (&self) -> &Arc<Pulse>;
+    fn size (&self) -> &Measure<Tui>;
+}
+
+macro_rules! impl_phrase_view_state {
+    ($Struct:ident $(:: $field:ident)* [$self1:ident : $focused:expr] [$self2:ident : $entered:expr]) => {
+        impl PhraseViewState for $Struct {
+            fn phrase_editing (&self) -> &Option<Arc<RwLock<Phrase>>> {
+                &self$(.$field)*.phrase
+            }
+            fn phrase_editor_focused (&$self1) -> bool {
+                $focused
+                //self$(.$field)*.focus.is_focused()
+            }
+            fn phrase_editor_entered (&$self2) -> bool {
+                $entered
+                //self$(.$field)*.focus.is_entered()
+            }
+            fn phrase_editor_size (&self) -> &Measure<Tui> {
+                todo!()
+            }
+            fn keys (&self) -> &Buffer {
+                &self$(.$field)*.keys
+            }
+            fn buffer (&self) -> &BigBuffer {
+                &self$(.$field)*.buffer
+            }
+            fn note_len (&self) -> usize {
+                self$(.$field)*.note_len
+            }
+            fn note_axis (&self) -> &RwLock<FixedAxis<usize>> {
+                &self$(.$field)*.note_axis
+            }
+            fn time_axis (&self) -> &RwLock<ScaledAxis<usize>> {
+                &self$(.$field)*.time_axis
+            }
+            fn now (&self) -> &Arc<Pulse> {
+                &self$(.$field)*.now
+            }
+            fn size (&self) -> &Measure<Tui> {
+                &self$(.$field)*.size
+            }
+        }
+    }
+}
+impl_phrase_view_state!(PhraseEditorModel
+    [self: true]
+    [self: true]
+);
+impl_phrase_view_state!(SequencerTui::editor
+    [self: self.focused() == AppFocus::Content(SequencerFocus::PhraseEditor)]
+    [self: self.entered() && self.focused() == AppFocus::Content(SequencerFocus::PhraseEditor)]
+);
+impl_phrase_view_state!(ArrangerTui::editor
+    [self: self.focused() == AppFocus::Content(ArrangerFocus::PhraseEditor)]
+    [self: self.entered() && self.focused() == AppFocus::Content(ArrangerFocus::PhraseEditor)])
+;
+
+/// Colors of piano keys
+const KEY_COLORS: [(Color, Color);6] = [
+    (Color::Rgb(255, 255, 255), Color::Rgb(255, 255, 255)),
+    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
+    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
+    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
+    (Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
+    (Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
+];
+
+pub(crate) fn keys_vert () -> Buffer {
+    let area = [0, 0, 5, 64];
+    let mut buffer = Buffer::empty(Rect {
+        x: area.x(), y: area.y(), width: area.w(), height: area.h()
+    });
+    buffer_update(&mut buffer, area, &|cell, x, y| {
+        let y = 63 - y;
+        match x {
+            0 => {
+                cell.set_char('▀');
+                let (fg, bg) = KEY_COLORS[((6 - y % 6) % 6) as usize];
+                cell.set_fg(fg);
+                cell.set_bg(bg);
+            },
+            1 => {
+                cell.set_char('▀');
+                cell.set_fg(Color::White);
+                cell.set_bg(Color::White);
+            },
+            2 => if y % 6 == 0 {
+                cell.set_char('C');
+            },
+            3 => if y % 6 == 0 {
+                cell.set_symbol(NTH_OCTAVE[(y / 6) as usize]);
+            },
+            _ => {}
+        }
+    });
+    buffer
+}
+
+const NTH_OCTAVE: [&'static str; 11] = [
+    "-2", "-1", "0", "1", "2", "3", "4", "5", "6", "7", "8",
+];
+
+impl PhraseEditorModel {
+    pub fn put (&mut self) {
+        if let (Some(phrase), Some(time), Some(note)) = (
+            &self.phrase,
+            self.time_axis.read().unwrap().point,
+            self.note_axis.read().unwrap().point,
+        ) {
+            let mut phrase = phrase.write().unwrap();
+            let key: u7 = u7::from((127 - note) as u8);
+            let vel: u7 = 100.into();
+            let start = time;
+            let end   = (start + self.note_len) % phrase.length;
+            phrase.notes[time].push(MidiMessage::NoteOn { key, vel });
+            phrase.notes[end].push(MidiMessage::NoteOff { key, vel });
+            self.buffer = Self::redraw(&phrase);
+        }
+    }
+    /// Select which pattern to display. This pre-renders it to the buffer at full resolution.
+    pub fn show (&mut self, phrase: Option<Arc<RwLock<Phrase>>>) {
+        if let Some(phrase) = phrase {
+            self.phrase = Some(phrase.clone());
+            self.time_axis.write().unwrap().clamp = Some(phrase.read().unwrap().length);
+            self.buffer = Self::redraw(&*phrase.read().unwrap());
+        } else {
+            self.phrase = None;
+            self.time_axis.write().unwrap().clamp = Some(0);
+            self.buffer = Default::default();
+        }
+    }
+    fn redraw (phrase: &Phrase) -> BigBuffer {
+        let mut buf = BigBuffer::new(usize::MAX.min(phrase.length), 65);
+        Self::fill_seq_bg(&mut buf, phrase.length, phrase.ppq);
+        Self::fill_seq_fg(&mut buf, &phrase);
+        buf
+    }
+    fn fill_seq_bg (buf: &mut BigBuffer, length: usize, ppq: usize) {
+        for x in 0..buf.width {
+            // Only fill as far as phrase length
+            if x as usize >= length { break }
+            // Fill each row with background characters
+            for y in 0 .. buf.height {
+                buf.get_mut(x, y).map(|cell|{
+                    cell.set_char(if ppq == 0 {
+                        '·'
+                    } else if x % (4 * ppq) == 0 {
+                        '│'
+                    } else if x % ppq == 0 {
+                        '╎'
+                    } else {
+                        '·'
+                    });
+                    cell.set_fg(Color::Rgb(48, 64, 56));
+                    cell.modifier = Modifier::DIM;
+                });
+            }
+        }
+    }
+    fn fill_seq_fg (buf: &mut BigBuffer, phrase: &Phrase) {
+        let mut notes_on = [false;128];
+        for x in 0..buf.width {
+            if x as usize >= phrase.length {
+                break
+            }
+            if let Some(notes) = phrase.notes.get(x as usize) {
+                if phrase.percussive {
+                    for note in notes {
+                        match note {
+                            MidiMessage::NoteOn { key, .. } =>
+                                notes_on[key.as_int() as usize] = true,
+                            _ => {}
+                        }
+                    }
+                } else {
+                    for note in notes {
+                        match note {
+                            MidiMessage::NoteOn { key, .. } =>
+                                notes_on[key.as_int() as usize] = true,
+                            MidiMessage::NoteOff { key, .. } =>
+                                notes_on[key.as_int() as usize] = false,
+                            _ => {}
+                        }
+                    }
+                }
+                for y in 0..buf.height {
+                    if y >= 64 {
+                        break
+                    }
+                    if let Some(block) = half_block(
+                        notes_on[y as usize * 2],
+                        notes_on[y as usize * 2 + 1],
+                    ) {
+                        buf.get_mut(x, y).map(|cell|{
+                            cell.set_char(block);
+                            cell.set_fg(Color::White);
+                        });
+                    }
+                }
+                if phrase.percussive {
+                    notes_on.fill(false);
+                }
+            }
+        }
+    }
+}