tek/app/src/api.rs

use crate::*;

view!(TuiOut: |self: Tek| self.size.of(View(self, self.view)); {
    //":inputs"    => self.view_inputs().boxed(),
    //":outputs"   => self.view_outputs().boxed(),
    //":scene-add" => self.view_scene_add().boxed(),
    //":scenes"    => self.view_scenes().boxed(),
    //":tracks"    => self.view_tracks().boxed(),
    ":nil"       => Box::new("nil"),
    ":transport" => self.view_transport().boxed(),
    ":arranger"  => ArrangerView::new(self).boxed(),
    ":editor"    => self.editor.as_ref().map(|e|Bsp::e(e.clip_status(), e.edit_status())).boxed(),
    ":sample"    => ().boxed(),//self.view_sample(self.is_editing()).boxed(),
    ":sampler"   => ().boxed(),//self.view_sampler(self.is_editing(), &self.editor).boxed(),
    ":status"    => self.view_status().boxed(),
    ":pool"      => self.pool.as_ref()
        .map(|pool|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), pool)))
        .boxed(),
});

expose!([self: Tek] {
    bool => {}
    u16 => {
        ":h-ins"     => self.h_inputs(),
        ":h-outs"    => self.h_outputs(),
        ":h-sample"  => if self.is_editing() { 0 } else { 5 },
        ":w-samples" => if self.is_editing() { 4 } else { 11 },
        ":w-sidebar" => self.w_sidebar(),
        ":y-ins"     => (self.size.h() as u16).saturating_sub(self.h_inputs() + 1),
        ":y-outs"    => (self.size.h() as u16).saturating_sub(self.h_outputs() + 1),
        ":y-samples" => if self.is_editing() { 1 } else { 0 },
    }
    usize => {
        ":scene-last" => self.scenes.len(),
        ":track-last" => self.tracks.len(),
    }
    isize => {}
    Option<usize> => {
        ":scene" => self.selected.scene(),
        ":track" => self.selected.track(),
    }
    Color => {}
    Arc<RwLock<MidiClip>> => {}
    Option<Arc<RwLock<MidiClip>>> => {
        ":clip" => match self.selected {
            Selection::Clip(t, s) => self.scenes[s].clips[t].clone(),
            _ => None
        }
    }
    Selection => {
        ":scene-next" => match self.selected {
            Selection::Mix => Selection::Scene(0),
            Selection::Track(t) => Selection::Clip(t, 0),
            Selection::Scene(s) if s + 1 < self.scenes.len() => Selection::Scene(s + 1),
            Selection::Scene(s) => Selection::Mix,
            Selection::Clip(t, s) if s + 1 < self.scenes.len() => Selection::Clip(t, s + 1),
            Selection::Clip(t, s) => Selection::Track(t),
        },
        ":scene-prev" => match self.selected {
            Selection::Mix        => Selection::Mix,
            Selection::Track(t)   => Selection::Track(t),
            Selection::Scene(0)   => Selection::Mix,
            Selection::Scene(s)   => Selection::Scene(s - 1),
            Selection::Clip(t, 0) => Selection::Track(t),
            Selection::Clip(t, s) => Selection::Clip(t, s - 1),
        },
        ":track-next" => match self.selected {
            Selection::Mix => Selection::Track(0),
            Selection::Track(t) if t + 1 < self.tracks.len() => Selection::Track(t + 1),
            Selection::Track(t) => Selection::Mix,
            Selection::Scene(s) => Selection::Clip(0, s),
            Selection::Clip(t, s) if t + 1 < self.tracks.len() => Selection::Clip(t + 1, s),
            Selection::Clip(t, s) => Selection::Scene(s),
        },
        ":track-prev" => match self.selected {
            Selection::Mix        => Selection::Mix,
            Selection::Scene(s)   => Selection::Scene(s),
            Selection::Track(0)   => Selection::Mix,
            Selection::Track(t)   => Selection::Track(t - 1),
            Selection::Clip(0, s) => Selection::Scene(s),
            Selection::Clip(t, s) => Selection::Clip(t - 1, s),
        },
    }
});

impose!([app: Tek] {

    TekCommand => {
        ("stop"    []
            Some(Self::StopAll))
        ("undo"    [d: usize]
            Some(Self::History(-(d.unwrap_or(0)as isize))))
        ("redo"    [d: usize]
            Some(Self::History(d.unwrap_or(0) as isize)))
        ("zoom"    [z: usize]
            Some(Self::Zoom(z)))
        ("edit"    []
            Some(Self::Edit(None)))
        ("edit"    [c: bool]
            Some(Self::Edit(c)))
        ("color"   [c: Color]
            Some(Self::Color(ItemPalette::random())))
        ("color"   [c: Color]
            Some(Self::Color(c.map(ItemPalette::from).expect("no color"))))
        ("enqueue" [c: Arc<RwLock<MidiClip>>]
            Some(Self::Enqueue(c)))
        ("launch"  []
            Some(Self::Launch))
        ("clip"    [,..a]
            ClipCommand::try_from_expr(app, a).map(Self::Clip))
        ("clock"   [,..a]
            ClockCommand::try_from_expr(app.clock(), a).map(Self::Clock))
        ("editor"  [,..a]
            MidiEditCommand::try_from_expr(app.editor.as_ref().expect("no editor"), a).map(Self::Editor))
        ("pool"    [,..a]
            PoolCommand::try_from_expr(app.pool.as_ref().expect("no pool"), a).map(Self::Pool))
        //("sampler" [,..a]
        //  Self::Sampler( //SamplerCommand::try_from_expr(app.sampler().as_ref().expect("no sampler"), a).expect("invalid command")))
        ("scene"   [,..a]
            SceneCommand::try_from_expr(app, a).map(Self::Scene))
        ("track"   [,..a]
            TrackCommand::try_from_expr(app, a).map(Self::Track))
        ("input"   [,..a]
            InputCommand::try_from_expr(app, a).map(Self::Input))
        ("output"  [,..a]
            OutputCommand::try_from_expr(app, a).map(Self::Output))
        ("select"  [t: Selection]
            Some(t.map(Self::Select).expect("no selection")))
        ("select"  [t: usize, s: usize]
            Some(match (t.expect("no track"), s.expect("no scene")) {
                (0, 0) => Self::Select(Selection::Mix),
                (t, 0) => Self::Select(Selection::Track(t)),
                (0, s) => Self::Select(Selection::Scene(s)),
                (t, s) => Self::Select(Selection::Clip(t, s)),
            }))
    }

    ClipCommand => {
        ("get"     [a: usize, b: usize]
            Some(Self::Get(a.unwrap(), b.unwrap())))
        ("put"     [a: usize, b: usize, c: Option<Arc<RwLock<MidiClip>>>]
            Some(Self::Put(a.unwrap(), b.unwrap(), c.unwrap())))
        ("enqueue" [a: usize, b: usize]
            Some(Self::Enqueue(a.unwrap(), b.unwrap())))
        ("edit"    [a: Option<Arc<RwLock<MidiClip>>>]
            Some(Self::Edit(a.unwrap())))
        ("loop"    [a: usize, b: usize, c: bool]
            Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
        ("color"   [a: usize, b: usize]
            Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemPalette::random())))
    }

    InputCommand => {
        ("add" [] Some(Self::Add))
    }

    OutputCommand => {
        ("add" [] Some(Self::Add))
    }

    SceneCommand => {
        ("add"     []
            Some(Self::Add))
        ("del"     [a: usize]
            Some(Self::Del(0)))
        ("zoom"    [a: usize]
            Some(Self::SetZoom(a.unwrap())))
        ("color"   [a: usize]
            Some(Self::SetColor(a.unwrap(), ItemPalette::G[128])))
        ("enqueue" [a: usize]
            Some(Self::Enqueue(a.unwrap())))
        ("swap"    [a: usize, b: usize]
            Some(Self::Swap(a.unwrap(), b.unwrap())))
    }

    TrackCommand => {
        ("add"   []
            Some(Self::Add))
        ("size"  [a: usize]
            Some(Self::SetSize(a.unwrap())))
        ("zoom"  [a: usize]
            Some(Self::SetZoom(a.unwrap())))
        ("color" [a: usize]
            Some(Self::SetColor(a.unwrap(), ItemPalette::random())))
        ("del"   [a: usize]
            Some(Self::Del(a.unwrap())))
        ("stop"  [a: usize]
            Some(Self::Stop(a.unwrap())))
        ("swap"  [a: usize, b: usize]
            Some(Self::Swap(a.unwrap(), b.unwrap())))
        ("play"  []
            Some(Self::TogglePlay))
        ("solo"  []
            Some(Self::ToggleSolo))
        ("rec"   []
            Some(Self::ToggleRecord))
        ("mon"   []
            Some(Self::ToggleMonitor))
    }

});