tek/crates/app/app_bind.rs

use crate::*;

impl<'t> DslNs<'t, AppCommand> for App {
    dsl_exprs!(|app| -> AppCommand { /* TODO */ });
    dsl_words!(|app| -> AppCommand {
        "x/inc"   => todo!(),
        "x/dec"   => todo!(),
        "y/inc"   => todo!(),
        "y/dec"   => todo!(),
        "confirm" => todo!(),
    });
}
#[derive(Debug)]
pub enum AppCommand { /* TODO */ }

#[tengri_proc::command(Option<Dialog>)]
impl DialogCommand {
    fn open (dialog: &mut Option<Dialog>, new: Dialog) -> Perhaps<Self> {
        *dialog = Some(new);
        Ok(None)
    }
    fn close (dialog: &mut Option<Dialog>) -> Perhaps<Self> {
        *dialog = None;
        Ok(None)
    }
}


    //AppCommand => {
        //("x/inc" /
        //("stop-all") => todo!(),//app.project.stop_all(),
        //("enqueue", clip: Option<Arc<RwLock<MidiClip>>>) => todo!(),
        //("history", delta: isize) => todo!(),
        //("zoom", zoom: usize) => todo!(),
        //("select", selection: Selection) => todo!(),
        //("dialog"  / command: DialogCommand) => todo!(),
        //("project" / command: ArrangementCommand) => todo!(),
        //("clock" / command: ClockCommand) => todo!(),
        //("sampler" / command: SamplerCommand) => todo!(),
        //("pool" / command: PoolCommand) => todo!(),
        //("edit" / editor:  MidiEditCommand) => todo!(),
    //};

    //DialogCommand;

    //ArrangementCommand;

    //ClockCommand;

    //SamplerCommand;

    //PoolCommand;

    //MidiEditCommand;


//take!(DialogCommand      |state: App, iter|Take::take(&state.dialog, iter));
//#[derive(Clone, Debug)]
//pub enum DialogCommand {
    //Open { dialog: Dialog },
    //Close
//}

//impl Command<Option<Dialog>> for DialogCommand {
    //fn execute (self, state: &mut Option<Dialog>) -> Perhaps<Self> {
        //match self {
            //Self::Open { dialog } => {
                //*state = Some(dialog);
            //},
            //Self::Close => {
                //*state = None;
            //}
        //};
        //Ok(None)
    //}
//}

//dsl!(DialogCommand: |self: Dialog, iter|todo!());
//Dsl::take(&mut self.dialog, iter));

//#[tengri_proc::command(Option<Dialog>)]//Nope.
//impl DialogCommand {
    //fn open (dialog: &mut Option<Dialog>, new: Dialog) -> Perhaps<Self> {
        //*dialog = Some(new);
        //Ok(None)
    //}
    //fn close (dialog: &mut Option<Dialog>) -> Perhaps<Self> {
        //*dialog = None;
        //Ok(None)
    //}
//}
//
//dsl_bind!(AppCommand: App {
    //enqueue  = |app, clip:  Option<Arc<RwLock<MidiClip>>>| { todo!() };
    //history  = |app, delta: isize| { todo!() };
    //zoom     = |app, zoom:  usize| { todo!() };
    //stop_all = |app| { app.tracks_stop_all(); Ok(None) };
    ////dialog   = |app, command: DialogCommand|
        ////Ok(command.delegate(&mut app.dialog, |c|Self::Dialog{command: c})?);
    //project  = |app, command: ArrangementCommand|
        //Ok(command.delegate(&mut app.project, |c|Self::Project{command: c})?);
    //clock    = |app, command: ClockCommand|
        //Ok(command.execute(app.clock_mut())?.map(|c|Self::Clock{command: c}));
    //sampler  = |app, command: SamplerCommand|
        //Ok(app.project.sampler_mut().map(|s|command.delegate(s, |command|Self::Sampler{command}))
            //.transpose()?.flatten());
    //pool     = |app, command: PoolCommand| {
        //let undo = command.clone().delegate(&mut app.pool, |command|AppCommand::Pool{command})?;
        //// update linked editor after pool action
        //match command {
            //// autoselect: automatically load selected clip in editor
            //PoolCommand::Select { .. } |
            //// autocolor: update color in all places simultaneously
            //PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => {
                //let clip = app.pool.clip().clone();
                //app.editor_mut().map(|editor|editor.set_clip(clip.as_ref()))
            //},
            //_ => None
        //};
        //Ok(undo)
    //};
    //select   = |app, selection: Selection| {
        //*app.project.selection_mut() = selection;
        ////todo!
        ////if let Some(ref mut editor) = app.editor_mut() {
            ////editor.set_clip(match selection {
                ////Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
                    ////.project
                    ////.scenes.get(scene)
                    ////.map(|s|s.clips.get(track))
                ////=>
                    ////Some(clip),
                ////_ =>
                    ////None
            ////});
        ////}
        //Ok(None)
        ////("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::TrackClip { track: t, scene: s }) })))
        //// autoedit: load focused clip in editor.
    //};
    ////fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
        ////Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
    ////}
    ////fn launch (app: &mut App) -> Perhaps<Self> {
        ////app.project.launch();
        ////Ok(None)
    ////}
    //toggle_editor = |app, value: bool|{ app.toggle_editor(Some(value)); Ok(None) };
    //editor = |app, command: MidiEditCommand| Ok(if let Some(editor) = app.editor_mut() {
        //let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
        //// update linked sampler after editor action
        //app.project.sampler_mut().map(|sampler|match command {
            //// autoselect: automatically select sample in sampler
            //MidiEditCommand::SetNotePos { pos } => { sampler.set_note_pos(pos); },
            //_ => {}
        //});
        //undo
    //} else {
        //None
    //});
//});
//take!(ClockCommand       |state: App, iter|Take::take(state.clock(), iter));
//take!(MidiEditCommand    |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(PoolCommand        |state: App, iter|Take::take(&state.pool, iter));
//take!(SamplerCommand     |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));