tek/crates/device/src/editor/editor_api.rs

use crate::*;

#[tengri_proc::expose] impl MidiEditor {
    fn _todo_opt_clip_stub (&self) -> Option<Arc<RwLock<MidiClip>>> {
        todo!()
    }

    fn clip_length (&self) -> usize {
        self.clip().as_ref().map(|p|p.read().unwrap().length).unwrap_or(1)
    }

    fn note_length (&self) -> usize {
        self.get_note_len()
    }

    fn note_pos (&self) -> usize {
        self.get_note_pos()
    }
    fn note_pos_next (&self) -> usize {
        self.get_note_pos() + 1
    }
    fn note_pos_next_octave (&self) -> usize {
        self.get_note_pos() + 12
    }
    fn note_pos_prev (&self) -> usize {
        self.get_note_pos().saturating_sub(1)
    }
    fn note_pos_prev_octave (&self) -> usize {
        self.get_note_pos().saturating_sub(12)
    }

    fn note_len (&self) -> usize {
        self.get_note_len()
    }
    fn note_len_next (&self) -> usize {
        self.get_note_len() + 1
    }
    fn note_len_prev (&self) -> usize {
        self.get_note_len().saturating_sub(1)
    }

    fn note_range (&self) -> usize {
        self.get_note_axis()
    }
    fn note_range_next (&self) -> usize {
        self.get_note_axis() + 1
    }
    fn note_range_prev (&self) -> usize {
        self.get_note_axis().saturating_sub(1)
    }

    fn time_pos (&self) -> usize {
        self.get_time_pos()
    }
    fn time_pos_next (&self) -> usize {
        (self.get_time_pos() + self.get_note_len()) % self.clip_length()
    }
    fn time_pos_next_fine (&self) -> usize {
        (self.get_time_pos() + 1) % self.clip_length()
    }
    fn time_pos_prev (&self) -> usize {
        let step = self.get_note_len();
        self.get_time_pos().overflowing_sub(step)
            .0.min(self.clip_length().saturating_sub(step))
    }
    fn time_pos_prev_fine (&self) -> usize {
        self.get_time_pos().overflowing_sub(1)
            .0.min(self.clip_length().saturating_sub(1))
    }

    fn time_zoom (&self) -> usize {
        self.get_time_zoom()
    }
    fn time_zoom_next (&self) -> usize {
        self.get_time_zoom() + 1
    }
    fn time_zoom_next_fine (&self) -> usize {
        self.get_time_zoom() + 1
    }
    fn time_zoom_prev (&self) -> usize {
        self.get_time_zoom().saturating_sub(1).max(1)
    }
    fn time_zoom_prev_fine (&self) -> usize {
        self.get_time_zoom().saturating_sub(1).max(1)
    }

    fn time_lock (&self) -> bool {
        self.get_time_lock()
    }
    fn time_lock_toggled (&self) -> bool {
        !self.get_time_lock()
    }
}

#[tengri_proc::command(MidiEditor)] impl MidiEditCommand {
    fn append_note (editor: &mut MidiEditor, advance: bool) -> Perhaps<Self> {
        editor.put_note(advance);
        Ok(None)
    }
    fn delete_note (_editor: &mut MidiEditor) -> Perhaps<Self> {
        todo!()
    }
    fn set_note_pos (editor: &mut MidiEditor, pos: usize) -> Perhaps<Self> {
        editor.set_note_pos(pos.min(127));
        Ok(None)
    }
    fn set_note_len (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
        //let note_len = editor.get_note_len();
        //let time_zoom = editor.get_time_zoom();
        editor.set_note_len(value);
        //if note_len / time_zoom != x / time_zoom {
            editor.redraw();
        //}
        Ok(None)
    }
    fn set_note_scroll (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
        editor.set_note_lo(value.min(127));
        Ok(None)
    }
    fn set_time_pos (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
        editor.set_time_pos(value);
        Ok(None)
    }
    fn set_time_scroll (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
        editor.set_time_start(value);
        Ok(None)
    }
    fn set_time_zoom (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
        editor.set_time_zoom(value);
        editor.redraw();
        Ok(None)
    }
    fn set_time_lock (editor: &mut MidiEditor, value: bool) -> Perhaps<Self> {
        editor.set_time_lock(value);
        Ok(None)
    }
    fn show (editor: &mut MidiEditor, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<Self> {
        editor.set_clip(clip.as_ref());
        Ok(None)
    }
    // TODO: 1-9 seek markers that by default start every 8th of the clip
}