tek/src/device/editor.rs

#![allow(unused)]
use crate::*;

impl App {
    /// Is a MIDI editor currently focused?
    ///
    /// ```
    /// tek::App::default().editor_focused();
    /// ```
    pub fn editor_focused (&self) -> bool {
        false
    }

    /// Toggle MIDI editor.
    ///
    /// ```
    /// tek::App::default().toggle_editor(None);
    /// ```
    pub fn toggle_editor (&mut self, value: Option<bool>) {
        //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
        let value = value.unwrap_or_else(||!self.editor().is_some());
        if value {
            // Create new clip in pool when entering empty cell
            if let Selection::TrackClip { track, scene } = *self.selection()
            && let Some(scene) = self.project.scenes.get_mut(scene)
            && let Some(slot)  = scene.clips.get_mut(track)
            && slot.is_none()
            && let Some(track) = self.project.tracks.get_mut(track)
            {
                let (_index, clip) = self.pool.add_new_clip();
                // autocolor: new clip colors from scene and track color
                let color = track.color.base.mix(scene.color.base, 0.5);
                clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
                if let Some(editor) = &mut self.project.editor {
                    editor.set_clip(Some(&clip));
                }
                *slot = Some(clip.clone());
                //Some(clip)
            } else {
                //None
            }
        } else if let Selection::TrackClip { track, scene } = *self.selection()
            && let Some(scene) = self.project.scenes.get_mut(scene)
            && let Some(slot) = scene.clips.get_mut(track)
            && let Some(clip) = slot.as_mut()
        {
            // Remove clip from arrangement when exiting empty clip editor
            let mut swapped = None;
            if clip.read().unwrap().count_midi_messages() == 0 {
                std::mem::swap(&mut swapped, slot);
            }
            if let Some(clip) = swapped {
                self.pool.delete_clip(&clip.read().unwrap());
            }
        }
    }
}

pub trait HasEditor: AsRefOpt<MidiEditor> + AsMutOpt<MidiEditor> {
    fn editor (&self) -> Option<&MidiEditor> { self.as_ref_opt() }
    fn editor_mut (&mut self) -> Option<&mut MidiEditor> { self.as_mut_opt() }
    fn is_editing (&self) -> bool { self.editor().is_some() }
    fn editor_w (&self) -> usize { self.editor().map(|e|e.size.w()).unwrap_or(0) as usize }
    fn editor_h (&self) -> usize { self.editor().map(|e|e.size.h()).unwrap_or(0) as usize }
}

impl<T: AsRefOpt<MidiEditor>+AsMutOpt<MidiEditor>> HasEditor for T {}

impl<T: HasEditor
    + Namespace<u32>
    + Namespace<f64>
    + Namespace<bool>
    + Namespace<usize>
    + Namespace<Option<u32>>
    + Namespace<Option<Arc<RwLock<MidiClip>>>>
> MidiEditController for T {}

#[tek_proc::commands(MidiEditCommand = "edit")]
pub trait MidiEditController: HasEditor
    + Namespace<u32>
    + Namespace<f64>
    + Namespace<bool>
    + Namespace<usize>
    + Namespace<Option<u32>>
    + Namespace<Option<Arc<RwLock<MidiClip>>>>
{
    #[command(Show = "show")]
    fn show (&mut self, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_clip(clip.as_ref());
            editor.redraw();
            None
        }).flatten())
    }

    #[command(DeleteNote = "delete")]
    fn note_delete (&mut self) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.redraw();
            todo!()
        }).flatten())
    }

    #[command(AppendNote = "append")]
    fn note_append (&mut self, advance: bool) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.put_note(advance);
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetNotePos = "note-pos")]
    fn note_set_pos (&mut self, pos: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_note_pos((pos).min(127));
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetNoteLen = "note-len")]
    fn note_set_len (&mut self, len: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_note_len(len);
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetNoteScroll = "note-scroll")]
    fn note_set_scroll (&mut self, scroll: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_note_lo((scroll).min(127));
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetTimePos = "time-pos")]
    fn time_set_pos (&mut self, pos: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_time_pos(pos);
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetTimeScroll = "time-scroll")]
    fn time_set_scroll (&mut self, scroll: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_time_start(scroll);
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetTimeZoom = "time-zoom")]
    fn time_set_zoom (&mut self, zoom: usize) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_time_zoom(zoom);
            editor.redraw();
            None
        }).flatten())
    }

    #[command(SetTimeLock = "time-lock")]
    fn time_set_lock (&mut self, lock: bool) -> Perhaps<MidiEditCommand> {
        Ok(self.editor_mut().map(|editor|{
            editor.set_time_lock(lock);
            editor.redraw();
            None
        }).flatten())
    }
    // TODO: 1-9 seek markers that by default start every 8th of the clip
}

/// Contains state for viewing and editing a clip.
///
/// ```
/// use std::sync::{Arc, RwLock};
/// let clip = tek::MidiClip::stop_all();
/// let mut editor = tek::MidiEditor {
///     mode: tek::PianoHorizontal::new(Some(&Arc::new(RwLock::new(clip)))),
///     size: Default::default(),
///     //keys: Default::default(),
/// };
/// let _ = editor.put_note(true);
/// let _ = editor.put_note(false);
/// let _ = editor.clip_status();
/// let _ = editor.edit_status();
/// ```
pub struct MidiEditor {
    /// View mode and state of editor
    pub mode: PianoHorizontal,
    /// Size of editor on screen
    pub size: Sizer,
}

impl_default!(MidiEditor: Self {
    mode: PianoHorizontal::new(None),
    size: Sizer(
        Arc::new(0usize.into()),
        Arc::new(0usize.into()),
    ),
});

impl MidiEditor {
    /// Put note at current position
    pub fn put_note (&mut self, advance: bool) {
        let mut redraw = false;
        if let Some(clip) = self.clip() {
            let mut clip   = clip.write().unwrap();
            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();
            let length     = clip.length;
            let note_end   = note_end % length;
            let note_on = MidiMessage::NoteOn { key, vel };
            if !clip.notes[note_start].iter().any(|msg|*msg == note_on) {
                clip.notes[note_start].push(note_on);
            }
            let note_off = MidiMessage::NoteOff { key, vel };
            if !clip.notes[note_end].iter().any(|msg|*msg == note_off) {
                clip.notes[note_end].push(note_off);
            }
            if advance {
                self.set_time_pos((note_end + 1) % clip.length);
            }
            redraw = true;
        }
        if redraw {
            self.mode.redraw();
        }
    }
    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_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() }
    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))
    }
    pub fn clip_status (&self) -> impl Draw<Tui> + '_ {
        let (_color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
            (clip.color, clip.name.clone(), clip.length, clip.looped)
        } else { (ItemTheme::G[64], String::new().into(), 0, false) };
        south!(
            east(button_2("f2", "name ", false), fg(Rgb(255, 255, 255), format!("{name} "))
                .origin_e().full_w()).origin_w().full_w(),
            east(button_2("l", "ength ", false), fg(Rgb(255, 255, 255), format!("{length} ")).origin_e().full_w())
                .origin_w().full_w(),
            east(button_2("r", "epeat ", false), fg(Rgb(255, 255, 255), format!("{looped} ")).origin_e().full_w())
                .origin_w().full_w(),
        ).exact_w(20)
    }
    pub fn edit_status (&self) -> impl Draw<Tui> + '_ {
        let (_color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
            (clip.color, clip.length)
        } else { (ItemTheme::G[64], 0) };
        let time_pos  = self.get_time_pos();
        let time_zoom = self.get_time_zoom();
        let time_lock = if self.get_time_lock() { "[lock]" } else { "      " };
        let note_pos  = self.get_note_pos();
        let note_name = format!("{:4}",  note_pitch_to_name(note_pos));
        let note_pos  = format!("{:>3}", note_pos);
        let note_len  = format!("{:>4}", self.get_note_len());
        south!(
            east(button_2("t", "ime  ", false),
                fg(Rgb(255, 255, 255), format!("{length} /{time_zoom} +{time_pos} ")).origin_e().full_w()).origin_w().full_w(),
            east(button_2("z", "lock ", false),
                fg(Rgb(255, 255, 255), format!("{time_lock}")).origin_e().full_w()).origin_w().full_w(),
            east(button_2("x", "note ", false),
                fg(Rgb(255, 255, 255), format!("{note_name} {note_pos} {note_len}")).origin_e().full_w()).origin_w().full_w(),
        ).exact_w(20)
    }
}

/// ```
/// use tek::{*, tengri::*};
///
/// struct Test(Option<MidiEditor>);
/// impl_as_ref_opt!(MidiEditor: |self: Test|self.0.as_ref());
/// impl_as_mut_opt!(MidiEditor: |self: Test|self.0.as_mut());
///
/// let mut host = Test(Some(MidiEditor::default()));
/// let _ = host.editor();
/// let _ = host.editor_mut();
/// let _ = host.is_editing();
/// let _ = host.editor_w();
/// let _ = host.editor_h();
/// ```

impl <T: NotePoint+TimePoint> MidiPoint for T {}

impl <T: TimeRange+NoteRange> MidiRange for T {}

pub trait MidiViewer: MidiRange + MidiPoint + Debug + Send + Sync {
    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize);
    fn redraw (&self);
    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>>;
    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>>;
    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
        *self.clip_mut() = clip.cloned();
        self.redraw();
    }
    /// Make sure cursor is within note range
    fn autoscroll (&self) {
        let note_pos = self.get_note_pos().min(127);
        let note_lo  = self.get_note_lo();
        let note_hi  = self.get_note_hi();
        if note_pos < note_lo {
            self.note_lo().store(note_pos, Relaxed);
        } else if note_pos > note_hi {
            self.note_lo().store((note_lo + note_pos).saturating_sub(note_hi), Relaxed);
        }
    }
    /// Make sure time range is within display
    fn autozoom (&self) {
        if self.time_lock().load(Relaxed) {
            let time_len  = self.get_time_len();
            let time_axis = self.get_time_axis();
            let time_zoom = self.get_time_zoom();
            loop {
                let time_zoom = self.time_zoom().load(Relaxed);
                let time_area = time_axis * time_zoom;
                if time_area > time_len {
                    let next_time_zoom = note_duration_prev(time_zoom);
                    if next_time_zoom <= 1 {
                        break
                    }
                    let next_time_area = time_axis * next_time_zoom;
                    if next_time_area >= time_len {
                        self.time_zoom().store(next_time_zoom, Relaxed);
                    } else {
                        break
                    }
                } else if time_area < time_len {
                    let prev_time_zoom = note_duration_next(time_zoom);
                    if prev_time_zoom > 384 {
                        break
                    }
                    let prev_time_area = time_axis * prev_time_zoom;
                    if prev_time_area <= time_len {
                        self.time_zoom().store(prev_time_zoom, Relaxed);
                    } else {
                        break
                    }
                }
            }
            if time_zoom != self.time_zoom().load(Relaxed) {
                self.redraw()
            }
        }
        //while time_len.div_ceil(time_zoom) > time_axis {
            //println!("\r{time_len} {time_zoom} {time_axis}");
            //time_zoom = Note::next(time_zoom);
        //}
        //self.time_zoom().set(time_zoom);
    }
}

impl_has!(Sizer: |self: MidiEditor| self.size);

impl std::fmt::Debug for MidiEditor {
    fn fmt (&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        f.debug_struct("MidiEditor").field("mode", &self.mode).finish()
    }
}

impl_from!(MidiEditor: |clip: &Arc<RwLock<MidiClip>>| {
    let model = Self::from(Some(clip.clone()));
    model.redraw();
    model
});

impl_from!(MidiEditor: |clip: Option<Arc<RwLock<MidiClip>>>| {
    let mut model = Self::default();
    *model.clip_mut() = clip;
    model.redraw();
    model
});

impl NotePoint for MidiEditor {
    fn note_len (&self) -> &AtomicUsize { self.mode.note_len() }
    fn note_pos (&self) -> &AtomicUsize { self.mode.note_pos() }
}

impl TimePoint for MidiEditor {
    fn time_pos (&self) -> &AtomicUsize { self.mode.time_pos() }
}

impl MidiViewer for MidiEditor {
    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
    fn redraw      (&self) { self.mode.redraw() }
    fn clip        (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
    fn clip_mut    (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
    fn set_clip    (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
}

impl Draw<Tui> for MidiEditor {
    fn draw (&self, to: &mut Tui) -> Drawn<u16> {
        self.autoscroll();
        /*self.autozoom();*/
        self.size.of(&self.mode).draw(to)
    }
}

mod octave; pub use self::octave::*;
mod piano; pub use self::piano::*;
mod point; pub use self::point::*;
mod range; pub use self::range::*;