clock: replace provide calls with expose stubs

.old/demo.rs.old

@@ -0,0 +1,112 @@
+use tek::*;
+
+fn main () -> Usually<()> {
+    Tui::run(Arc::new(RwLock::new(Demo::new())))?;
+    Ok(())
+}
+
+pub struct Demo<E: Engine> {
+    index: usize,
+    items: Vec<Box<dyn Render<Engine = E>>>
+}
+
+impl Demo<Tui> {
+    fn new () -> Self {
+        Self {
+            index: 0,
+            items: vec![]
+        }
+    }
+}
+
+impl Content for Demo<Tui> {
+    type Engine = Tui;
+    fn content (&self) -> dyn Render<Engine = Tui> {
+        let border_style = Style::default().fg(Color::Rgb(0,0,0));
+        Align::Center(Layers::new(move|add|{
+
+            add(&Background(Color::Rgb(0,128,128)))?;
+
+            add(&Margin::XY(1, 1, Stack::down(|add|{
+
+                add(&Layers::new(|add|{
+                    add(&Background(Color::Rgb(128,96,0)))?;
+                    add(&Border(Square(border_style)))?;
+                    add(&Margin::XY(2, 1, "..."))?;
+                    Ok(())
+                }).debug())?;
+
+                add(&Layers::new(|add|{
+                    add(&Background(Color::Rgb(128,64,0)))?;
+                    add(&Border(Lozenge(border_style)))?;
+                    add(&Margin::XY(4, 2, "---"))?;
+                    Ok(())
+                }).debug())?;
+
+                add(&Layers::new(|add|{
+                    add(&Background(Color::Rgb(96,64,0)))?;
+                    add(&Border(SquareBold(border_style)))?;
+                    add(&Margin::XY(6, 3, "~~~"))?;
+                    Ok(())
+                }).debug())?;
+
+                Ok(())
+            })).debug())?;
+
+            Ok(())
+
+        }))
+        //Align::Center(Margin::X(1, Layers::new(|add|{
+            //add(&Background(Color::Rgb(128,0,0)))?;
+            //add(&Stack::down(|add|{
+                //add(&Margin::Y(1, Layers::new(|add|{
+                    //add(&Background(Color::Rgb(0,128,0)))?;
+                    //add(&Align::Center("12345"))?;
+                    //add(&Align::Center("FOO"))
+                //})))?;
+                //add(&Margin::XY(1, 1, Layers::new(|add|{
+                    //add(&Align::Center("1234567"))?;
+                    //add(&Align::Center("BAR"))?;
+                    //add(&Background(Color::Rgb(0,0,128)))
+                //})))
+            //}))
+        //})))
+
+        //Align::Y(Layers::new(|add|{
+            //add(&Background(Color::Rgb(128,0,0)))?;
+            //add(&Margin::X(1, Align::Center(Stack::down(|add|{
+                //add(&Align::X(Margin::Y(1, Layers::new(|add|{
+                    //add(&Background(Color::Rgb(0,128,0)))?;
+                    //add(&Align::Center("12345"))?;
+                    //add(&Align::Center("FOO"))
+                //})))?;
+                //add(&Margin::XY(1, 1, Layers::new(|add|{
+                    //add(&Align::Center("1234567"))?;
+                    //add(&Align::Center("BAR"))?;
+                    //add(&Background(Color::Rgb(0,0,128)))
+                //})))?;
+                //Ok(())
+            //})))))
+        //}))
+    }
+}
+
+impl Handle<TuiIn> for Demo<Tui> {
+    fn handle (&mut self, from: &TuiIn) -> Perhaps<bool> {
+        use KeyCode::{PageUp, PageDown};
+        match from.event() {
+            kexp!(PageUp) => {
+                self.index = (self.index + 1) % self.items.len();
+            },
+            kexp!(PageDown) => {
+                self.index = if self.index > 1 {
+                    self.index - 1
+                } else {
+                    self.items.len() - 1
+                };
+            },
+            _ => return Ok(None)
+        }
+        Ok(Some(true))
+    }
+}

crates/app/src/model/editor.rs

@@ -53,9 +53,9 @@ impl MidiEditor {
         let mut redraw = false;
         if let Some(clip) = self.clip() {
             let mut clip   = clip.write().unwrap();
-            let note_start = self.time_pos();
-            let note_pos   = self.note_pos();
-            let note_len   = self.note_len();
+            let note_start = self.get_time_pos();
+            let note_pos   = self.get_note_pos();
+            let note_len   = self.get_note_len();
             let note_end   = note_start + (note_len.saturating_sub(1));
             let key: u7    = u7::from(note_pos as u8);
             let vel: u7    = 100.into();

crates/app/src/view.rs

@@ -1195,8 +1195,8 @@ impl MidiViewer for PianoHorizontal {
             let clip       = clip.read().unwrap();
             let buf_size   = self.buffer_size(&clip);
             let mut buffer = BigBuffer::from(buf_size);
-            let note_len   = self.note_len();
-            let time_zoom  = self.time_zoom().get();
+            let note_len   = self.get_note_len();
+            let time_zoom  = self.get_time_zoom();
             self.time_len().set(clip.length);
             PianoHorizontal::draw_bg(&mut buffer, &clip, time_zoom, note_len);
             PianoHorizontal::draw_fg(&mut buffer, &clip, time_zoom);

crates/device/src/clock/clock_api.rs

@@ -1,55 +1,61 @@
 use crate::*;
 
-#[derive(Clone, Debug, PartialEq)]
-pub enum ClockCommand {
-    Play(Option<u32>),
-    Pause(Option<u32>),
-    SeekUsec(f64),
-    SeekSample(f64),
-    SeekPulse(f64),
-    SetBpm(f64),
-    SetQuant(f64),
-    SetSync(f64),
+#[tengri_proc::expose]
+impl Clock {
+    fn _todo_provide_u32 (&self) -> u32 {
+        todo!()
+    }
+    fn _todo_provide_opt_u32 (&self) -> Option<u32> {
+        todo!()
+    }
+    fn _todo_provide_f64 (&self) -> f64 {
+        todo!()
+    }
 }
 
-provide_num!(u32: |self: Clock| {});
-
-provide!(f64: |self: Clock| {});
-
-atom_command!(ClockCommand: |state: Clock| {
-    ("play"        []       Some(Self::Play(None)))
-    ("play"        [t: u32] Some(Self::Play(t)))
-    ("pause"       []       Some(Self::Pause(None)))
-    ("pause"       [t: u32] Some(Self::Pause(t)))
-    ("toggle"      []       Some(if state.is_rolling() { Self::Pause(None) } else { Self::Play(None) }))
-    ("toggle"      [t: u32] Some(if state.is_rolling() { Self::Pause(t) } else { Self::Play(t) }))
-    ("seek/usec"   [t: f64] Some(Self::SeekUsec(t.expect("no usec"))))
-    ("seek/pulse"  [t: f64] Some(Self::SeekPulse(t.expect("no pulse"))))
-    ("seek/sample" [t: f64] Some(Self::SeekSample(t.expect("no sample"))))
-    ("set/bpm"     [t: f64] Some(Self::SetBpm(t.expect("no bpm"))))
-    ("set/sync"    [t: f64] Some(Self::SetSync(t.expect("no sync"))))
-    ("set/quant"   [t: f64] Some(Self::SetQuant(t.expect("no quant"))))
-});
-
 impl<T: HasClock> Command<T> for ClockCommand {
     fn execute (self, state: &mut T) -> Perhaps<Self> {
-        self.execute(state.clock_mut())
+        self.execute(state.clock_mut()) // awesome
     }
 }
 
-impl Command<Clock> for ClockCommand {
-    fn execute (self, state: &mut Clock) -> Perhaps<Self> {
-        use ClockCommand::*;
-        match self {
-            Play(start)        => state.play_from(start)?,
-            Pause(pause)       => state.pause_at(pause)?,
-            SeekUsec(usec)     => state.playhead.update_from_usec(usec),
-            SeekSample(sample) => state.playhead.update_from_sample(sample),
-            SeekPulse(pulse)   => state.playhead.update_from_pulse(pulse),
-            SetBpm(bpm)        => return Ok(Some(SetBpm(state.timebase().bpm.set(bpm)))),
-            SetQuant(quant)    => return Ok(Some(SetQuant(state.quant.set(quant)))),
-            SetSync(sync)      => return Ok(Some(SetSync(state.sync.set(sync)))),
-        };
+#[tengri_proc::command(Clock)]
+impl ClockCommand {
+    fn play (state: &mut Clock, position: Option<u32>) -> Perhaps<Self> {
+        state.play_from(position)?;
+        Ok(None) // TODO Some(Pause(previousPosition))
+    }
+    fn pause (state: &mut Clock, position: Option<u32>) -> Perhaps<Self> {
+        state.pause_at(position)?;
         Ok(None)
     }
+    fn toggle_playback (state: &mut Clock, position: Option<u32>) -> Perhaps<Self> {
+        if state.is_rolling() {
+            state.pause_at(position)?;
+        } else {
+            state.play_from(position)?;
+        }
+        Ok(None)
+    }
+    fn seek_usec (state: &mut Clock, usec: f64) -> Perhaps<Self> {
+        state.playhead.update_from_usec(usec);
+        Ok(None)
+    }
+    fn seek_sample (state: &mut Clock, sample: f64) -> Perhaps<Self> {
+        state.playhead.update_from_sample(sample);
+        Ok(None)
+    }
+    fn seek_pulse (state: &mut Clock, pulse: f64) -> Perhaps<Self> {
+        state.playhead.update_from_pulse(pulse);
+        Ok(None)
+    }
+    fn set_bpm (state: &mut Clock, bpm: f64) -> Perhaps<Self> {
+        Ok(Some(Self::SetBpm { bpm: state.timebase().bpm.set(bpm) }))
+    }
+    fn set_quant (state: &mut Clock, quant: f64) -> Perhaps<Self> {
+        Ok(Some(Self::SetQuant { quant: state.quant.set(quant) }))
+    }
+    fn set_sync (state: &mut Clock, sync: f64) -> Perhaps<Self> {
+        Ok(Some(Self::SetSync { sync: state.sync.set(sync) }))
+    }
 }

crates/engine/src/note/note_range.rs

@@ -37,14 +37,23 @@ pub trait TimeRange {
     fn get_time_zoom (&self) -> usize {
         self.time_zoom().load(Ordering::Relaxed)
     }
+    fn set_time_zoom (&self, value: usize) -> usize {
+        self.time_zoom().swap(value, Ordering::Relaxed)
+    }
     fn time_lock (&self) -> &AtomicBool;
     fn get_time_lock (&self) -> bool {
         self.time_lock().load(Ordering::Relaxed)
     }
+    fn set_time_lock (&self, value: bool) -> bool {
+        self.time_lock().swap(value, Ordering::Relaxed)
+    }
     fn time_start (&self) -> &AtomicUsize;
     fn get_time_start (&self) -> usize {
         self.time_start().load(Ordering::Relaxed)
     }
+    fn set_time_start (&self, value: usize) -> usize {
+        self.time_start().swap(value, Ordering::Relaxed)
+    }
     fn time_axis (&self) -> &AtomicUsize;
     fn get_time_axis (&self) -> usize {
         self.time_axis().load(Ordering::Relaxed)

deps/tengri

@@ -1 +1 @@
-Subproject commit fa10f7d4d36924beae83d2136d180c2006508ae9
+Subproject commit b7bb6119aac975632969719c7ec5b71d97dbe356