unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-08 12:46:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

wip: borrow checker battles

Browse source
This commit is contained in:
🪞👃🪞 2024-09-04 16:57:48 +03:00
parent 1d4db3c629
commit 7fbb40fad6
38 changed files with 778 additions and 708 deletions
Download patch file Download diff file Expand all files Collapse all files

145
crates/tek_sequencer/src/sequencer_view_h.rs
View file

@ -4,17 +4,26 @@ impl Sequencer {
const H_KEYS_OFFSET: usize = 5;
pub(crate) fn horizontal_draw (&self, buf: &mut Buffer, mut area: Rect) -> Usually<()> {
pub(crate) fn horizontal_draw <'a> (&self, to: &mut TuiOutput<'a>) -> Usually<()> {
let mut area = to.area;
Split::down()
.add_ref(&SequenceName(&self))
.add_ref(&SequenceRange)
.add_ref(&SequenceLoopRange)
.add_ref(&SequenceNoteRange)
.render(buf, Rect { x: area.x, y: area.y, width: 10, height: area.height })?;
.render(&mut TuiOutput {
buffer: to.buffer,
area: Rect {
x: area.x,
y: area.y,
height: area.height,
width: 10,
}
})?;
area.x = area.x + 10;
area.width = area.width.saturating_sub(10);
area.height = area.height.min(66);
Lozenge(Style::default().fg(Nord::BG2)).draw(buf, area)?;
Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, area)?;
area.x = area.x + 1;
area.width = area.width.saturating_sub(1);
Layered::new()
@ -23,7 +32,7 @@ impl Sequencer {
.add_ref(&SequenceNotes(&self))
.add_ref(&SequenceCursor(&self))
.add_ref(&SequenceZoom(&self))
.render(buf, area)?;
.render(&mut TuiOutput { buffer: to.buffer, area: area })?;
Ok(())
}
@ -48,102 +57,102 @@ const STYLE_VALUE: Option<Style> = Some(Style {
struct SequenceName<'a>(&'a Sequencer);
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceName<'a> {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
let Rect { x, y, .. } = area;
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
let Rect { x, y, .. } = to.area;
let frame = Rect { x, y, width: 10, height: 4 };
Lozenge(Style::default().fg(Nord::BG2)).draw(buf, frame)?;
"Name:".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
self.0.name.read().unwrap().blit(buf, x + 1, y + 2, STYLE_VALUE)?;
Ok(frame)
Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, frame)?;
"Name:".blit(to.buffer, x + 1, y + 1, STYLE_LABEL)?;
self.0.name.read().unwrap().blit(to.buffer, x + 1, y + 2, STYLE_VALUE)?;
Ok(Some(frame))
}
}
struct SequenceRange;
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceRange {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
let Rect { x, y, .. } = area;
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
let Rect { x, y, .. } = to.area;
let frame = Rect { x, y, width: 10, height: 6 };
Lozenge(Style::default().fg(Nord::BG2)).draw(buf, frame)?;
"Start: ".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
" 1.1.1".blit(buf, x + 1, y + 2, STYLE_VALUE)?;
"End: ".blit(buf, x + 1, y + 3, STYLE_LABEL)?;
" 2.1.1".blit(buf, x + 1, y + 4, STYLE_VALUE)?;
Ok(frame)
Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, frame)?;
"Start: ".blit(to.buffer, x + 1, y + 1, STYLE_LABEL)?;
" 1.1.1".blit(to.buffer, x + 1, y + 2, STYLE_VALUE)?;
"End: ".blit(to.buffer, x + 1, y + 3, STYLE_LABEL)?;
" 2.1.1".blit(to.buffer, x + 1, y + 4, STYLE_VALUE)?;
Ok(Some(frame))
}
}
struct SequenceLoopRange;
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceLoopRange {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
let Rect { x, y, .. } = area;
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
let Rect { x, y, .. } = to.area;
let range = Rect { x, y, width: 10, height: 7 };
Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
"Loop [ ]".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
"From: ".blit(buf, x + 1, y + 2, STYLE_LABEL)?;
" 1.1.1".blit(buf, x + 1, y + 3, STYLE_VALUE)?;
"Length: ".blit(buf, x + 1, y + 4, STYLE_LABEL)?;
" 1.0.0".blit(buf, x + 1, y + 5, STYLE_VALUE)?;
Ok(range)
Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, range)?;
"Loop [ ]".blit(to.buffer, x + 1, y + 1, STYLE_LABEL)?;
"From: ".blit(to.buffer, x + 1, y + 2, STYLE_LABEL)?;
" 1.1.1".blit(to.buffer, x + 1, y + 3, STYLE_VALUE)?;
"Length: ".blit(to.buffer, x + 1, y + 4, STYLE_LABEL)?;
" 1.0.0".blit(to.buffer, x + 1, y + 5, STYLE_VALUE)?;
Ok(Some(range))
}
}
struct SequenceNoteRange;
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceNoteRange {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
let Rect { x, y, .. } = area;
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
let Rect { x, y, .. } = to.area;
let range = Rect { x, y, width: 10, height: 9 };
Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
"Notes: ".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
"C#0-C#9 ".blit(buf, x + 1, y + 2, STYLE_VALUE)?;
"[ /2 ]".blit(buf, x + 1, y + 3, STYLE_LABEL)?;
"[ x2 ]".blit(buf, x + 1, y + 4, STYLE_LABEL)?;
"[ Rev ]".blit(buf, x + 1, y + 5, STYLE_LABEL)?;
"[ Inv ]".blit(buf, x + 1, y + 6, STYLE_LABEL)?;
"[ Dup ]".blit(buf, x + 1, y + 7, STYLE_LABEL)?;
Ok(area)
Lozenge(Style::default().fg(Nord::BG2)).draw(to.buffer, range)?;
"Notes: ".blit(to.buffer, x + 1, y + 1, STYLE_LABEL)?;
"C#0-C#9 ".blit(to.buffer, x + 1, y + 2, STYLE_VALUE)?;
"[ /2 ]".blit(to.buffer, x + 1, y + 3, STYLE_LABEL)?;
"[ x2 ]".blit(to.buffer, x + 1, y + 4, STYLE_LABEL)?;
"[ Rev ]".blit(to.buffer, x + 1, y + 5, STYLE_LABEL)?;
"[ Inv ]".blit(to.buffer, x + 1, y + 6, STYLE_LABEL)?;
"[ Dup ]".blit(to.buffer, x + 1, y + 7, STYLE_LABEL)?;
Ok(Some(to.area))
}
}
struct SequenceKeys<'a>(&'a Sequencer);
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)
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
if to.area.height < 2 {
return Ok(Some(to.area))
}
let area = Rect {
x: area.x,
y: area.y + 1,
x: to.area.x,
y: to.area.y + 1,
width: 5,
height: area.height - 2
height: to.area.height - 2
};
buffer_update(buf, area, &|cell, x, y|{
buffer_update(to.buffer, area, &|cell, x, y|{
let y = y + self.0.note_axis.start as u16;
if x < self.0.keys.area.width && y < self.0.keys.area.height {
*cell = self.0.keys.get(x, y).clone()
}
});
Ok(area)
Ok(Some(to.area))
}
}
struct SequenceNotes<'a>(&'a Sequencer);
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)
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
if to.area.height < 2 {
return Ok(Some(to.area))
}
let area = Rect {
x: area.x + Sequencer::H_KEYS_OFFSET as u16,
y: area.y + 1,
width: area.width - Sequencer::H_KEYS_OFFSET as u16,
height: area.height - 2
x: to.area.x + Sequencer::H_KEYS_OFFSET as u16,
y: to.area.y + 1,
width: to.area.width - Sequencer::H_KEYS_OFFSET as u16,
height: to.area.height - 2
};
buffer_update(buf, area, &move |cell, x, y|{
buffer_update(to.buffer, area, &move |cell, x, y|{
let src_x = ((x as usize + self.0.time_axis.start) * self.0.time_axis.scale) as usize;
let src_y = (y as usize + self.0.note_axis.start) as usize;
if src_x < self.0.buffer.width && src_y < self.0.buffer.height - 1 {
@ -154,21 +163,21 @@ impl<'a> Render<TuiOutput<'a>, Rect> for SequenceNotes<'a> {
});
}
});
Ok(area)
Ok(Some(to.area))
}
}
struct SequenceCursor<'a>(&'a Sequencer);
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceCursor<'a> {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<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;
let y = area.y + 1 + note as u16 / 2;
let x = to.area.x + Sequencer::H_KEYS_OFFSET as u16 + time as u16;
let y = to.area.y + 1 + note as u16 / 2;
let c = if note % 2 == 0 { "▀" } else { "▄" };
c.blit(buf, x, y, self.0.style_focus())
c.blit(to.buffer, x, y, self.0.style_focus())
} else {
Ok(Rect::default())
Ok(Some(Rect::default()))
}
}
}
@ -176,31 +185,31 @@ impl<'a> Render<TuiOutput<'a>, Rect> for SequenceCursor<'a> {
struct SequenceZoom<'a>(&'a Sequencer);
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceZoom<'a> {
fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<Rect> {
let quant = ppq_to_name(self.0.time_axis.scale);
let quant_x = area.x + area.width - 1 - quant.len() as u16;
let quant_y = area.y + area.height - 2;
quant.blit(buf, quant_x, quant_y, self.0.style_focus())
let quant_x = to.area.x + to.area.width - 1 - quant.len() as u16;
let quant_y = to.area.y + to.area.height - 2;
quant.blit(to.buffer, quant_x, quant_y, self.0.style_focus())
}
}
struct SequenceTimer<'a>(&'a Sequencer, Arc<RwLock<Phrase>>);
impl<'a> Render<TuiOutput<'a>, Rect> for SequenceTimer<'a> {
fn render (&self, to: &mut TuiOutput<'a>) -> Usually<Rect> {
fn render (&self, to: &mut TuiOutput<'a>) -> Perhaps<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
);
let Rect { x, width, .. } = area;
let Rect { x, width, .. } = to.area;
let x2 = x as usize + Sequencer::H_KEYS_OFFSET;
let x3 = x as usize + width as usize;
for x in x2..x3 {
let step = (time0 + x2) * time_z;
let next_step = (time0 + x2 + 1) * time_z;
let style = Sequencer::style_timer_step(now, step as usize, next_step as usize);
"-".blit(buf, x as u16, area.y, Some(style))?;
"-".blit(to.buffer, x as u16, to.area.y, Some(style))?;
}
return Ok(Rect { x: area.x, y: area.y, width: area.width, height: 1 })
return Ok(Some(Rect { x: to.area.x, y: to.area.y, width: to.area.width, height: 1 }))
}
}