collect crates/ and deps/

app/src/keys.rs

@@ -1,177 +0,0 @@
-use crate::*;
-mod keys_clip;  pub use self::keys_clip::*;
-mod keys_ins;   pub use self::keys_ins::*;
-mod keys_outs;  pub use self::keys_outs::*;
-mod keys_scene; pub use self::keys_scene::*;
-mod keys_track; pub use self::keys_track::*;
-handle!(TuiIn: |self: Tek, input|Ok({
-    // If editing, editor keys take priority
-    if self.is_editing() {
-        if self.editor.handle(input)? == Some(true) {
-            return Ok(Some(true))
-        }
-    }
-    // Handle from root keymap
-    if let Some(command) = self.keys.command::<_, TekCommand, _>(self, input) {
-        if let Some(undo) = command.execute(self)? { self.history.push(undo); }
-        return Ok(Some(true))
-    }
-    // Handle from selection-dependent keymaps
-    if let Some(command) = match self.selected() {
-        Selection::Clip(_, _) => self.keys_clip,
-        Selection::Track(_)   => self.keys_track,
-        Selection::Scene(_)   => self.keys_scene,
-        Selection::Mix        => self.keys_mix,
-    }.command::<_, TekCommand, _>(self, input) {
-        if let Some(undo) = command.execute(self)? { self.history.push(undo); }
-        return Ok(Some(true))
-    }
-    None
-}));
-#[derive(Clone, Debug)] pub enum TekCommand {
-    Clip(ClipCommand),
-    Clock(ClockCommand),
-    Color(ItemPalette),
-    Edit(Option<bool>),
-    Editor(MidiEditCommand),
-    Enqueue(Option<Arc<RwLock<MidiClip>>>),
-    History(isize),
-    Input(InputCommand),
-    Launch,
-    Output(OutputCommand),
-    Pool(PoolCommand),
-    Sampler(SamplerCommand),
-    Scene(SceneCommand),
-    Select(Selection),
-    StopAll,
-    Track(TrackCommand),
-    Zoom(Option<usize>),
-}
-command!(|self: TekCommand, app: Tek|match self {
-    Self::Zoom(_) => { println!("\n\rtodo: global zoom"); None },
-    Self::History(delta) => { println!("\n\rtodo: undo/redo"); None },
-    Self::Select(s) => {
-        app.selected = s;
-        // autoedit: load focused clip in editor.
-        if let Some(ref mut editor) = app.editor {
-            editor.set_clip(match app.selected {
-                Selection::Clip(t, s) if let Some(Some(Some(clip))) = app
-                    .scenes.get(s).map(|s|s.clips.get(t)) => Some(clip),
-                _ => None
-            });
-        }
-        None
-    },
-    Self::Edit(value) => {
-        if let Some(value) = value {
-            if app.is_editing() != value {
-                app.editing.store(value, Relaxed);
-            }
-        } else {
-            app.editing.store(!app.is_editing(), Relaxed);
-        };
-        // autocreate: create new clip from pool when entering empty cell
-        if let Some(ref pool) = app.pool {
-            if app.is_editing() {
-                if let Selection::Clip(t, s) = app.selected {
-                    if let Some(scene) = app.scenes.get_mut(s) {
-                        if let Some(slot) = scene.clips.get_mut(t) {
-                            if slot.is_none() {
-                                let (index, mut clip) = pool.add_new_clip();
-                                // autocolor: new clip colors from scene and track color
-                                clip.write().unwrap().color = ItemColor::random_near(
-                                    app.tracks[t].color.base.mix(
-                                        scene.color.base,
-                                        0.5
-                                    ),
-                                    0.2
-                                ).into();
-                                if let Some(ref mut editor) = app.editor {
-                                    editor.set_clip(Some(&clip));
-                                }
-                                *slot = Some(clip);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        None
-    },
-    Self::Clock(cmd)  => cmd.delegate(app, Self::Clock)?,
-    Self::Scene(cmd)  => cmd.delegate(app, Self::Scene)?,
-    Self::Track(cmd)  => cmd.delegate(app, Self::Track)?,
-    Self::Input(cmd)  => cmd.delegate(app, Self::Input)?,
-    Self::Output(cmd) => cmd.delegate(app, Self::Output)?,
-    Self::Clip(cmd)   => cmd.delegate(app, Self::Clip)?,
-    Self::Editor(cmd) => app.editor.as_mut()
-        .map(|editor|cmd.delegate(editor, Self::Editor)).transpose()?.flatten(),
-    //Self::Sampler(cmd) => app.sampler.as_mut()
-        //.map(|sampler|cmd.delegate(sampler, Self::Sampler)).transpose()?.flatten(),
-    //Self::Enqueue(clip) => app.player.as_mut()
-        //.map(|player|{player.enqueue_next(clip.as_ref());None}).flatten(),
-    Self::Launch => {
-        use Selection::*;
-        match app.selected {
-            Track(t) => app.tracks[t].player.enqueue_next(None),
-            Clip(t, s) => app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref()),
-            Scene(s) => {
-                for t in 0..app.tracks.len() {
-                    app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref())
-                }
-            },
-            _ => {}
-        };
-        None
-    },
-    Self::Color(palette) => {
-        use Selection::*;
-        Some(Self::Color(match app.selected {
-            Mix => {
-                let old = app.color;
-                app.color = palette;
-                old
-            },
-            Track(t) => {
-                let old = app.tracks[t].color;
-                app.tracks[t].color = palette;
-                old
-            }
-            Scene(s) => {
-                let old = app.scenes[s].color;
-                app.scenes[s].color = palette;
-                old
-            }
-            Clip(t, s) => {
-                if let Some(ref clip) = app.scenes[s].clips[t] {
-                    let mut clip = clip.write().unwrap();
-                    let old = clip.color;
-                    clip.color = palette;
-                    old
-                } else {
-                    return Ok(None)
-                }
-            }
-        }))
-    },
-    Self::StopAll => {
-        for track in 0..app.tracks.len(){app.tracks[track].player.enqueue_next(None);}
-        None
-    },
-    Self::Pool(cmd) => if let Some(pool) = app.pool.as_mut() {
-        let undo = cmd.clone().delegate(pool, Self::Pool)?;
-        if let Some(editor) = app.editor.as_mut() {
-            match cmd {
-                // autoselect: automatically load selected clip in editor
-                // autocolor:  update color in all places simultaneously
-                PoolCommand::Select(_) | PoolCommand::Clip(PoolClipCommand::SetColor(_, _)) =>
-                    editor.set_clip(pool.clip().as_ref()),
-                _ => {}
-            }
-        };
-        undo
-    } else {
-        None
-    },
-    _ => todo!("{self:?}")
-});