allow adding scenes

Cargo.toml

@@ -11,7 +11,8 @@ name = "tek"
 path = "src/tek.rs"
 
 [target.'cfg(target_os = "linux")']
-rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+linker = "clang"
+rustflags = ["-Clink-arg=-fuse-ld=mold", "-Clink-arg=-Wl,--no-rosegment"]
 
 [dependencies]
 tek_proc = { path = "./proc" }

Justfile

@@ -1,7 +1,11 @@
 #export RUSTFLAGS := "--cfg procmacro2_semver_exempt -Zmacro-backtrace -Clink-arg=-fuse-ld=mold"
 export RUST_BACKTRACE := "1"
 
-default +ARGS="new":
+[default]
+list:
+  just -l
+
+now +ARGS="new":
   cargo run -- {{ARGS}}
 
 doc +ARGS="":
@@ -44,7 +48,7 @@ run-init:
   rm -rf ~/.config/tek && {{debug}}
 
 prof:
-  CARGO_PROFILE_RELEASE_DEBUG=true cargo flamegraph --
+  CARGO_PROFILE_RELEASE_DEBUG=true cargo flamegraph -- new
 
 release := "reset && cargo run --release --"
 release:

proc/src/lib.rs

@@ -48,7 +48,7 @@ attribute!(commands {
     impl Parse for CustomAttributeMeta {
         /// Parse contents of `#[command(...)]` attribute tag.
         fn parse (input: ParseStream) -> Result<Self> {
-          let meta: Expr = input.parse()?;
+            let meta: Expr = input.parse()?;
             Ok(match meta {
                 // Struct name only
                 Expr::Path(ExprPath { path, .. }) => Self(path, None),
@@ -167,69 +167,18 @@ attribute!(commands {
             let mut keywords = quote! {};
             let mut expressions = quote! {};
             for (ident, (variant, inputs, keyword)) in items.iter() {
-                let mut typed = quote! {};
+                write_variant(
-                let mut params = quote! {};
+                    &mut expressions, &mut keywords, &mut variants, &mut dispatch,
-                let mut has_args = false;
+                    ident, command, variant, inputs, namespace, keyword,
-                for arg in inputs.iter() {
+                )
-                    if let FnArg::Typed(PatType { pat, ty, .. }) = arg {
-                        has_args = true;
-                        append(&mut typed,  quote! { #pat: #ty, });
-                        append(&mut params, quote! { #pat, });
-                    }
-                }
-                append(&mut variants, if has_args {
-                    quote! { #variant { #typed }, }
-                } else {
-                    quote! { #variant, }
-                });
-                append(&mut dispatch, if has_args {
-                    quote! { #command::#variant { #params } => state.#ident(#params), }
-                } else {
-                    quote! { #command::#variant => state.#ident(), }
-                });
-                let keyword = if let Some(namespace) = namespace {
-                    format!("{}/{}", namespace.value(), keyword.value())
-                } else {
-                    keyword.value()
-                };
-                if has_args {
-                    append(&mut expressions, quote! {
-                        #keyword (#typed) => { #command::#variant { #params } },
-                    });
-                } else {
-                    append(&mut keywords, quote! {
-                        #keyword => #command::#variant,
-                    });
-                }
             }
             let impls = match item {
-                Item::Impl(ItemImpl { generics, .. }) => {
+                Item::Impl(ItemImpl { generics, .. }) => write_for_struct(
-                    let lts = Punctuated::<_, Comma>::from_iter(generics.lifetimes());
+                    keywords, expressions, dispatch, state, command, generics,
-                    let tys = Punctuated::<_, Comma>::from_iter(generics.type_params());
+                ),
-                    let cns = Punctuated::<_, Comma>::from_iter(generics.const_params());
+                Item::Trait { .. } => write_for_trait(
-                    quote! {
+                    keywords, expressions, dispatch, state, command,
-                        impl<'n, #tys> dizzle::Namespace<'n, #command> for #state {
+                ),
-                            symbols!('n |state: Self| -> #command { #keywords });
-                            expressions!('n |state: Self| -> #command { #expressions });
-                        }
-                        impl #generics #command {
-                            pub fn act (self, state: &mut #state) -> Perhaps<Self> {
-                                match self { #dispatch _ => unreachable!() }
-                            }
-                        }
-                    }
-                },
-                Item::Trait { .. } => quote! {
-                    impl<'n, T: #state + 'n> dizzle::Namespaced<'n, T> for #command {
-                        symbols!('n |state: T| -> Self { #keywords });
-                        expressions!('n |state: T| -> Self { #expressions });
-                    }
-                    impl #command {
-                        pub fn act <'n, T: #state + 'n> (self, state: &mut T) -> Perhaps<Self> {
-                            match self { #dispatch _ => unreachable!() }
-                        }
-                    }
-                },
                 _ => panic!("trait or inherent impl needed for #[commands]")
             };
             append(out, quote! {
@@ -240,6 +189,145 @@ attribute!(commands {
             })
         }
     }
+
+    fn write_variant (
+        exps:      &mut TokenStream2,
+        syms:      &mut TokenStream2,
+        vars:      &mut TokenStream2,
+        disp:      &mut TokenStream2,
+        ident:     &Ident,
+        command:   &Path,
+        variant:   &Ident,
+        inputs:    &[FnArg],
+        namespace: &Option<LitStr>,
+        keyword:   &LitStr,
+    ) {
+        let keyword = if let Some(namespace) = namespace {
+            format!("{}/{}", namespace.value(), keyword.value())
+        } else {
+            keyword.value()
+        };
+        let mut typed = quote! {};
+        let mut params = quote! {};
+        let mut obtain = quote! {};
+        let mut has_args = false;
+        for arg in inputs.iter() {
+            if let FnArg::Typed(PatType { pat, ty, .. }) = arg {
+                has_args = true;
+                append(&mut typed,  quote! { #pat: #ty, });
+                append(&mut params, quote! { #pat, });
+                append(&mut obtain, quote! { let #pat: #ty = {
+                    let head = tail.head()?.unwrap_or_default();
+                    let tail = tail.tail()?.unwrap_or_default();
+                    match dizzle::Namespace::<#ty>::namespace(state, &head)? {
+                        Some(arg) => arg,
+                        None => return Err(format!("{}: arg \"{}\" ({}) got: {head} {tail}",
+                            #keyword, stringify!(#pat), stringify!(#ty),
+                        ).into())
+                    }
+                };});
+            }
+        }
+        if has_args {
+            append(vars, quote! { #variant { #typed }, });
+            append(disp, quote! { #command::#variant { #params } => state.#ident(#params), });
+            append(exps, quote! {
+                let tail_base = tail;
+                if head.src()? == Some(#keyword) {
+                    let tail = tail_base;
+                    #obtain
+                    return Ok(Some(#command::#variant { #params }))
+                }
+            });
+        } else {
+            append(vars, quote! { #variant, });
+            append(disp, quote! { #command::#variant => state.#ident(), });
+            append(syms, quote! {
+                if word == #keyword { return Ok(Some(#command::#variant)); }
+            });
+        }
+    }
+
+    fn write_for_struct (
+        syms:     TokenStream2,
+        exps:     TokenStream2,
+        disp:     TokenStream2,
+        state:    &Path,
+        command:  &Path,
+        generics: &syn::Generics,
+    ) -> TokenStream2 {
+        //let lts = Punctuated::<_, Comma>::from_iter(generics.lifetimes());
+        //let cns = Punctuated::<_, Comma>::from_iter(generics.const_params());
+        let tys = Punctuated::<_, Comma>::from_iter(generics.type_params());
+        quote! {
+            impl<#tys> dizzle::Namespace<#command> for #state {
+                //def_namespace_symbols!('n |state: Self| -> #command {
+                    //#syms
+                //});
+                //def_namespace_exps!('n |state: Self| -> #command {
+                    //#exps
+                //});
+                fn namespace_symbol (&self, word: impl Symbol) -> Perhaps<#command> {
+                    if let Some(word) = word.word()? {
+                        #syms
+                    }
+                    Ok(None)
+                }
+                fn namespace_expression (&self, expr: impl Expression) -> Perhaps<#command> {
+                    let state = self;
+                    if let Some(expr) = expr.expr()? {
+                        let head = expr.head()?;
+                        let tail = expr.tail()?;
+                        #exps
+                    }
+                    Ok(None)
+                }
+            }
+            impl #generics dizzle::Dispatch<#state> for #command {
+                fn dispatch (self, state: &mut #state) -> Perhaps<Self> {
+                    match self {
+                        #disp
+                        _ => unreachable!()
+                    }
+                }
+            }
+        }
+    }
+
+    fn write_for_trait (
+        syms: TokenStream2,
+        exps: TokenStream2,
+        disp: TokenStream2,
+        state:   &Path,
+        command: &Path,
+    ) -> TokenStream2 {
+        quote! {
+            impl<T: #state> dizzle::Namespaced<T> for #command {
+                fn namespaced_symbol <L: Symbol> (state: &T, word: L) -> Perhaps<#command> {
+                    if let Some(word) = word.word()? {
+                        #syms
+                    }
+                    Ok(None)
+                }
+                fn namespaced_expression <L: Expression> (state: &T, expr: L) -> Perhaps<#command> {
+                    if let Some(expr) = expr.expr()? {
+                        let head = expr.head()?;
+                        let tail = expr.tail()?;
+                        #exps
+                    }
+                    Ok(None)
+                }
+            }
+            impl<T: #state> dizzle::Dispatch<T> for #command {
+                fn dispatch (self, state: &mut T) -> Perhaps<Self> {
+                    match self {
+                        #disp
+                        _ => unreachable!()
+                    }
+                }
+            }
+        }
+    }
 });
 
 attribute!(command {
@@ -265,7 +353,7 @@ attribute!(command {
             let mut variants_filtered = item.variants.clone();
             variants_filtered.clear();
             for variant in item.variants.iter_mut() {
-                let Variant { attrs, ident, fields, discriminant } = variant;
+                let Variant { attrs, ident, fields, discriminant: _ } = variant;
                 let mut attrs_filtered = attrs.clone();
                 attrs_filtered.clear();
                 for attr in attrs.iter() {
@@ -308,7 +396,7 @@ attribute!(command {
                     panic!()
                 };
                 match fields {
-                    Fields::Named(fields)   => todo!("named command fields"),
+                    Fields::Named(_fields)   => todo!("named command fields"),
                     Fields::Unnamed(fields) => {
                         let mut params = quote! {};
                         let mut values = quote! {};
@@ -367,9 +455,11 @@ attribute!(keyword {
     impl Parse for CustomAttributeItem {
         fn parse (input: ParseStream) -> Result<Self> {
             let mut item: ItemEnum = input.parse()?;
-            for Variant { attrs, ident, fields, discriminant } in item.variants.iter_mut() {
+            for Variant {
+                attrs, ident: _, fields: _, discriminant: _
+            } in item.variants.iter_mut() {
                 attrs.retain(|attr|if let syn::Meta::List(MetaList {
-                    ref path, ref tokens, ..
+                    ref path, tokens: ref _tokens, ..
                 }) = attr.meta && path == &Path::from(Ident::new(
                     "keyword", Span::call_site()
                 )) {
@@ -386,15 +476,15 @@ attribute!(keyword {
         fn to_tokens (&self, out: &mut TokenStream2) {
             let Self(
                 CustomAttributeMeta(state),
-                CustomAttributeItem(item, variants)
+                CustomAttributeItem(item, _variants)
             ) = self;
             let ident = &item.ident;
             let body = quote! {};
             append(out, quote! {
                 #item
 
-                impl<'n> Namespace<'n, #ident> for #state {
+                impl Namespace<#ident> for #state {
-                    symbols!('n |_state: #state| -> #ident { #body, });
+                    def_namespace_symbols!(|_state: #state| -> #ident { #body, });
                 }
             })
         }

shell.nix

@@ -9,6 +9,7 @@
     pkgs.grcov
     pkgs.libclang
     pkgs.mold
+    pkgs.perf
     pkgs.pkg-config
     pkgs.watchexec
   ];

src/deps.rs

@@ -0,0 +1,39 @@
+pub extern crate atomic_float;
+pub extern crate xdg;
+pub extern crate tengri;
+#[cfg(feature = "cli")]
+pub(crate) use ::clap::{self, Parser, Subcommand};
+#[allow(unused)]
+pub(crate) use ::{
+    std::{
+        cmp::Ord,
+        collections::BTreeMap,
+        error::Error,
+        ffi::OsString,
+        fmt::{Write, Debug, Formatter},
+        fs::File,
+        ops::{Add, Sub, Mul, Div, Rem},
+        path::{Path, PathBuf},
+        sync::{Arc, RwLock, atomic::{AtomicBool, AtomicUsize, AtomicU64, Ordering::Relaxed}},
+        time::Duration,
+        thread::{spawn, JoinHandle},
+    },
+    xdg::{
+        BaseDirectories,
+    },
+    tengri::{
+        *,
+        dizzle::*,
+        midly::{
+            Smf, TrackEventKind, MidiMessage, Error as MidiError,
+            num::*,
+            live::*,
+        },
+        crossterm::event::{Event, KeyEvent},
+        ratatui::{
+            self,
+            prelude::{Rect, Style, Stylize, Buffer, Color::{self, *}},
+            widgets::{Widget, canvas::{Canvas, Line}},
+        },
+    },
+};

src/device/arrange/scene.rs

@@ -1,4 +1,3 @@
-use crate::*;
 use super::*;
 
 /// A scene consists of a set of clips to play together.
@@ -73,32 +72,32 @@ pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
 }
 
 impl<T: HasScene
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, ItemTheme>
+    + Namespace<ItemTheme>
 > SceneController for T {}
 
 #[tek_proc::commands(SceneCommand)]
 pub trait SceneController: HasScene
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, ItemTheme>
+    + Namespace<ItemTheme>
 {
-    #[command(SetSize = "scene/size")]
+    #[command(SetSize = "size")]
-    fn scene_set_size (&mut self, size: usize) -> Perhaps<SceneCommand>
+    fn scene_set_size (&mut self, _size: usize) -> Perhaps<SceneCommand>
-        where Self: for<'a> Namespace<'a, usize>
+        where Self: Namespace<usize>
     {
         todo!()
     }
-    #[command(SetZoom = "scene/zoom")]
+    #[command(SetZoom = "zoom")]
-    fn scene_set_zoom (&mut self, size: usize) -> Perhaps<SceneCommand>
+    fn scene_set_zoom (&mut self, _size: usize) -> Perhaps<SceneCommand>
-        where Self: for<'a> Namespace<'a, usize>
+        where Self: Namespace<usize>
     {
         todo!()
     }
-    #[command(SetName = "scene/name")]
+    #[command(SetName = "name")]
     fn scene_set_name (&mut self, name: Arc<str>) -> Perhaps<SceneCommand>
-        where Self: for<'a> Namespace<'a, Arc<str>>
+        where Self: Namespace<Arc<str>>
     {
         Ok(self.scene_mut().map(|scene|swap_value(
             &mut scene.name,
@@ -106,9 +105,9 @@ pub trait SceneController: HasScene
             |name|SceneCommand::SetName { name }
         )).transpose()?.flatten())
     }
-    #[command(SetColor = "scene/color")]
+    #[command(SetColor = "color")]
     fn scene_set_color (&mut self, color: ItemTheme) -> Perhaps<SceneCommand>
-        where Self: for<'a> Namespace<'a, ItemTheme>
+        where Self: Namespace<ItemTheme>
     {
         Ok(self.scene_mut().map(|scene|swap_value(
             &mut scene.color,
@@ -172,17 +171,30 @@ pub trait HasScenes: AsRef<Vec<Scene>> + AsMut<Vec<Scene>> {
 }
 
 impl<T: HasScenes
-    + for<'a> Namespace<'a, usize>
+    + HasTracks
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + HasTrackScroll
-    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + HasJack<'static>
+    + Namespace<usize>
+    + Namespace<Option<ItemTheme>>
+    + Namespace<Option<Arc<str>>>
 > ScenesController for T {}
 
 #[tek_proc::commands(ScenesCommand)]
 pub trait ScenesController: HasScenes
-    + for<'a> Namespace<'a, usize>
+    + HasTracks
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + HasTrackScroll
-    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + HasJack<'static>
+    + Namespace<usize>
+    + Namespace<Option<ItemTheme>>
+    + Namespace<Option<Arc<str>>>
 {
+    #[command(Add = "add")]
+    fn scenes_add (&mut self) -> Perhaps<ScenesCommand>
+        where Self: HasScenes + HasJack<'static>
+    {
+        let (_index, _) = self.scenes_add_one(None, None)?;
+        Ok(None)
+    }
     // TODO
 }
 
@@ -263,27 +275,27 @@ impl HasSceneScroll for App {
     }
 }
 
-    pub fn view_scene_name (
+pub fn view_scene_name (
-        select:  &Selection,
+    select:  &Selection,
-        editor:  Option<&MidiEditor>,
+    editor:  Option<&MidiEditor>,
-        index:   usize,
+    index:   usize,
-        scene:   &Scene,
+    scene:   &Scene,
-        editing: bool
+    editing: bool
-    ) -> impl Draw<Tui> {
+) -> impl Draw<Tui> {
-        let h = if select.scene() == Some(index) && let Some(_editor) = editor {
+    let h = if select.scene() == Some(index) && let Some(_editor) = editor {
-            7
+        7
-        } else {
+    } else {
-            Scene::DEFAULT_HEIGHT as u16
+        Scene::DEFAULT_HEIGHT as u16
-        };
+    };
-        let a = east(format!("·s{index:02} "),
+    let a = east(format!("·s{index:02} "),
-            fg(g(255), bold(true, &scene.name))).align_w().full_w();
+        fg(g(255), bold(true, &scene.name))).align_w().full_w();
-        let b = when(select.scene() == Some(index) && editing, south(
+    let b = when(select.scene() == Some(index) && editing, south(
-            editor.as_ref().map(|e|e.clip_status()),
+        editor.as_ref().map(|e|e.clip_status()),
-            editor.as_ref().map(|e|e.edit_status())).align_nw().full_wh());
+        editor.as_ref().map(|e|e.edit_status())).align_nw().full_wh());
-        let c = if select.scene() == Some(index) {
+    let c = if select.scene() == Some(index) {
-            scene.color.light.term
+        scene.color.light.term
-        } else {
+    } else {
-            scene.color.base.term
+        scene.color.base.term
-        };
+    };
-        bg(c, south(a, b).align_nw()).exact_wh(20, h)
+    bg(c, south(a, b).align_nw()).exact_wh(20, h)
-    }
+}

src/device/arrange/track.rs

@@ -85,18 +85,18 @@ pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
 }
 
 impl<T: HasTrack
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, ItemTheme>
+    + Namespace<ItemTheme>
-    + for<'a> Namespace<'a, Option<bool>>
+    + Namespace<Option<bool>>
 > TrackController for T {}
 
 #[tek_proc::commands(TrackCommand)]
 pub trait TrackController: HasTrack
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, ItemTheme>
+    + Namespace<ItemTheme>
-    + for<'a> Namespace<'a, Option<bool>>
+    + Namespace<Option<bool>>
 {
     #[command(Stop = "track/stop")]
     fn track_stop (&mut self) -> Perhaps<TrackCommand> {
@@ -104,19 +104,19 @@ pub trait TrackController: HasTrack
         Ok(None)
     }
     #[command(SetMute = "track/mute")]
-    fn track_set_mute (&mut self, mute: Option<bool>) -> Perhaps<TrackCommand> {
+    fn track_set_mute (&mut self, _mute: Option<bool>) -> Perhaps<TrackCommand> {
         todo!()
     }
     #[command(SetSolo = "track/solo")]
-    fn track_set_solo (&mut self, solo: Option<bool>) -> Perhaps<TrackCommand> {
+    fn track_set_solo (&mut self, _solo: Option<bool>) -> Perhaps<TrackCommand> {
         todo!()
     }
     #[command(SetSize = "track/size")]
-    fn track_set_size (&mut self, size: usize) -> Perhaps<TrackCommand> {
+    fn track_set_size (&mut self, _size: usize) -> Perhaps<TrackCommand> {
         todo!()
     }
     #[command(SetZoom = "track/zoom")]
-    fn track_set_zoom (&mut self, zoom: usize) -> Perhaps<TrackCommand> {
+    fn track_set_zoom (&mut self, _zoom: usize) -> Perhaps<TrackCommand> {
         todo!()
     }
     #[command(SetName = "track/name")]
@@ -259,27 +259,31 @@ pub trait HasTracks: AsRef<Vec<Track>> + AsMut<Vec<Track>> + HasClock + HasTrack
 }
 
 impl<T: HasTracks
-    + for<'a> Namespace<'a, usize>
+    + HasScenes
-    + for<'a> Namespace<'a, Arc<[Connect]>>
+    + HasJack<'static>
-    + for<'a> Namespace<'a, Option<usize>>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + Namespace<Arc<[Connect]>>
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + Namespace<Option<usize>>
-    + for<'a> Namespace<'a, Option<Arc<[Connect]>>>
+    + Namespace<Option<Arc<str>>>
-    + for<'a> Namespace<'a, Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
+    + Namespace<Option<ItemTheme>>
+    + Namespace<Option<Arc<[Connect]>>>
+    + Namespace<Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
 > TracksController for T {}
 
 #[tek_proc::commands(TracksCommand)]
 pub trait TracksController: HasTracks
-    + for<'a> Namespace<'a, usize>
+    + HasScenes
-    + for<'a> Namespace<'a, Arc<[Connect]>>
+    + HasJack<'static>
-    + for<'a> Namespace<'a, Option<usize>>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Option<Arc<str>>>
+    + Namespace<Arc<[Connect]>>
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + Namespace<Option<usize>>
-    + for<'a> Namespace<'a, Option<Arc<[Connect]>>>
+    + Namespace<Option<Arc<str>>>
-    + for<'a> Namespace<'a, Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
+    + Namespace<Option<ItemTheme>>
+    + Namespace<Option<Arc<[Connect]>>>
+    + Namespace<Option<Vec<Option<Arc<RwLock<MidiClip>>>>>>
 {
 
-    #[command(Stop = "tracks/stop")]
+    #[command(Stop = "stop")]
     /// Stop all playing clips
     fn tracks_stop_all (&mut self) -> Perhaps<TracksCommand> {
         for track in self.tracks_mut().iter_mut() {
@@ -288,7 +292,7 @@ pub trait TracksController: HasTracks
         Ok(None)
     }
 
-    #[command(Launch = "tracks/launch")]
+    #[command(Launch = "launch")]
     /// Launch multiple clips
     fn tracks_launch (
         &mut self, clips: Option<Vec<Option<Arc<RwLock<MidiClip>>>>>
@@ -304,6 +308,14 @@ pub trait TracksController: HasTracks
         }
         Ok(None)
     }
+
+    #[command(Add = "add")]
+    fn tracks_add (&mut self) -> Perhaps<TracksCommand>
+        where Self: HasScenes + HasJack<'static>
+    {
+        let (_index, _) = self.tracks_add_one(None, None, [].into(), [].into())?;
+        Ok(None)
+    }
 }
 
 impl<

src/device/browse.rs

@@ -11,11 +11,17 @@ impl App {
     }
 }
 
+impl<T:
+    Namespace<usize> +
+    Namespace<PathBuf> +
+    Namespace<Arc<str>>
+> BrowseController for T {}
+
 #[tek_proc::commands(BrowseCommand = "browse")]
 pub trait BrowseController:
-    for<'a> Namespace<'a, usize> +
+    Namespace<usize> +
-    for<'a> Namespace<'a, PathBuf> +
+    Namespace<PathBuf> +
-    for<'a> Namespace<'a, Arc<str>>
+    Namespace<Arc<str>>
 {
     /// Toggle visibility of browser
     #[command(Show = "show")]
@@ -54,13 +60,13 @@ pub trait BrowseController:
     pub size:   Sizer,
 }
 
-pub(crate) struct EntriesIterator<'a, S: Screen> {
+//pub(crate) struct EntriesIterator<'a, S: Screen> {
-    pub browser: &'a Browse,
+    //pub browser: &'a Browse,
-    pub offset:  usize,
+    //pub offset:  usize,
-    pub length:  usize,
+    //pub length:  usize,
-    pub index:   usize,
+    //pub index:   usize,
-    _screen: std::marker::PhantomData<S>
+    //_screen: std::marker::PhantomData<S>
-}
+//}
 
 #[derive(Clone, Debug)] pub enum BrowseTarget {
     SaveProject,
@@ -112,40 +118,37 @@ impl Browse {
             unreachable!()
         })
     }
-    fn _todo_stub_path_buf (&self) -> PathBuf { todo!() }
+    //fn tui (&self) -> impl Draw<Tui> {
-    fn _todo_stub_usize (&self) -> usize { todo!() }
+        //iter_south_fixed(1, ||self.tui_entries(), |entry, _index|entry.origin_w().full_w())
-    fn _todo_stub_arc_str (&self) -> Arc<str> { todo!() }
+    //}
-    fn tui (&self) -> impl Draw<Tui> {
+    //fn tui_entries (&self) -> EntriesIterator<'_, Tui> {
-        iter_south_fixed(1, ||self.tui_entries(), |entry, _index|entry.origin_w().full_w())
+        //EntriesIterator {
-    }
+            //offset:  0,
-    fn tui_entries (&self) -> EntriesIterator<'_, Tui> {
+            //index:   0,
-        EntriesIterator {
+            //length:  self.dirs.len() + self.files.len(),
-            offset:  0,
+            //browser: self,
-            index:   0,
+            //_screen: Default::default(),
-            length:  self.dirs.len() + self.files.len(),
+        //}
-            browser: self,
+    //}
-            _screen: Default::default(),
-        }
-    }
 }
 
-impl<'a> Iterator for EntriesIterator<'a, Tui> {
+//impl<'a> Iterator for EntriesIterator<'a, Tui> {
-    type Item = impl Draw<Tui>;
+    //type Item = impl Draw<Tui>;
-    fn next (&mut self) -> Option<Self::Item> {
+    //fn next (&mut self) -> Option<Self::Item> {
-        let dirs  = self.browser.dirs.len();
+        //let dirs  = self.browser.dirs.len();
-        let files = self.browser.files.len();
+        //let files = self.browser.files.len();
-        let index = self.index;
+        //let index = self.index;
-        if self.index < dirs {
+        //if self.index < dirs {
-            self.index += 1;
+            //self.index += 1;
-            Some(bold(true, self.browser.dirs[index].1.as_str()))
+            //Some(bold(true, self.browser.dirs[index].1.as_str()))
-        } else if self.index < dirs + files {
+        //} else if self.index < dirs + files {
-            self.index += 1;
+            //self.index += 1;
-            Some(bold(false, self.browser.files[index - dirs].1.as_str()))
+            //Some(bold(false, self.browser.files[index - dirs].1.as_str()))
-        } else {
+        //} else {
-            None
+            //None
-        }
+        //}
-    }
+    //}
-}
+//}
 
 impl PartialEq for BrowseTarget {
     fn eq (&self, other: &Self) -> bool {

src/device/clock.rs

@@ -66,16 +66,16 @@ pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
 }
 
 impl<T: HasClock
-    + for<'a> Namespace<'a, u32>
+    + Namespace<u32>
-    + for<'a> Namespace<'a, f64>
+    + Namespace<f64>
-    + for<'a> Namespace<'a, Option<u32>>
+    + Namespace<Option<u32>>
 > ClockController for T {}
 
 #[tek_proc::commands(ClockCommand = "clock")]
 pub trait ClockController: HasClock
-    + for<'a> Namespace<'a, u32>
+    + Namespace<u32>
-    + for<'a> Namespace<'a, f64>
+    + Namespace<f64>
-    + for<'a> Namespace<'a, Option<u32>>
+    + Namespace<Option<u32>>
 {
     #[command(SeekUsec = "usec")]
     fn seek_usec (&mut self, usec: f64) -> Perhaps<ClockCommand> {
@@ -416,18 +416,6 @@ impl Clock {
     }
 }
 
-impl Clock {
-    fn _todo_provide_u32 (&self) -> u32 {
-        todo!()
-    }
-    fn _todo_provide_opt_u32 (&self) -> Option<u32> {
-        todo!()
-    }
-    fn _todo_provide_f64 (&self) -> f64 {
-        todo!()
-    }
-}
-
 impl_has!(Clock: |self: Track|self.sequencer.clock);
 impl_default!(Timebase: Self::new(48000f64, 150f64, DEFAULT_PPQ));
 
@@ -468,3 +456,58 @@ impl_time_unit!(Ppq);
 impl_time_unit!(Pulse);
 impl_time_unit!(Bpm);
 impl_time_unit!(LaunchSync);
+
+/// ```
+/// let x = "";
+/// let _ = tek::view_transport(true,  x.as_ref(), x.as_ref(), x.as_ref());
+/// let _ = tek::view_transport(false, x.as_ref(), x.as_ref(), x.as_ref());
+/// ```
+pub fn view_transport (play: bool, bpm: &str, beat: &str, time: &str) -> impl Draw<Tui> {
+    let theme = ItemTheme::G[96];
+    bg(Black, east!(above(
+        button_play_pause(play, false).align_w(),
+        east!(
+            field_h(theme, "BPM",  bpm),
+            field_h(theme, "Beat", beat),
+            field_h(theme, "Time", time),
+        ).align_e().full_wh()
+    )))
+}
+
+/// ```
+/// let x = "";
+/// let _ = tek::view_status(None, x.as_ref(), x.as_ref(), x.as_ref());
+/// let _ = tek::view_status(Some("".into()), x.as_ref(), x.as_ref(), x.as_ref());
+/// ```
+pub fn view_status (sel: Option<&str>, sr: &str, buf: &str, lat: &str) -> impl Draw<Tui> {
+    let theme = ItemTheme::G[96];
+    let sr    = field_h(theme, "SR",  sr);
+    let buf   = field_h(theme, "Buf", buf);
+    let lat   = field_h(theme, "Lat", lat);
+    bg(Black, east!(above(
+        sel.map(|sel|field_h(theme, "Selected", sel)).align_w().full_wh(),
+        east!(sr, buf, lat).align_e().full_wh(),
+    )))
+}
+
+/// ```
+/// let _ = tek::button_play_pause(true, true);
+/// let _ = tek::button_play_pause(true, false);
+/// let _ = tek::button_play_pause(false, true);
+/// let _ = tek::button_play_pause(false, false);
+/// ```
+pub fn button_play_pause (playing: bool, compact: bool) -> impl Draw<Tui> {
+    bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
+        either(compact,
+            draw(move|to: &mut Tui|either(playing,
+                fg(Rgb(0, 255, 0),   " PLAYING "),
+                fg(Rgb(255, 128, 0), " STOPPED "),
+            ).exact_w(9).draw(to)),
+            draw(move|to: &mut Tui|either(playing,
+                fg(Rgb(0, 255, 0),   south(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
+                fg(Rgb(255, 128, 0), south(" ▗▄▖ ", " ▝▀▘ ",)),
+            ).exact_w(5).draw(to)),
+        )
+    )
+}
+

src/device/editor.rs

@@ -67,22 +67,22 @@ pub trait HasEditor: AsRefOpt<MidiEditor> + AsMutOpt<MidiEditor> {
 impl<T: AsRefOpt<MidiEditor>+AsMutOpt<MidiEditor>> HasEditor for T {}
 
 impl<T: HasEditor
-    + for<'a> Namespace<'a, u32>
+    + Namespace<u32>
-    + for<'a> Namespace<'a, f64>
+    + Namespace<f64>
-    + for<'a> Namespace<'a, bool>
+    + Namespace<bool>
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Option<u32>>
+    + Namespace<Option<u32>>
-    + for<'a> Namespace<'a, Option<Arc<RwLock<MidiClip>>>>
+    + Namespace<Option<Arc<RwLock<MidiClip>>>>
 > MidiEditController for T {}
 
 #[tek_proc::commands(MidiEditCommand = "edit")]
 pub trait MidiEditController: HasEditor
-    + for<'a> Namespace<'a, u32>
+    + Namespace<u32>
-    + for<'a> Namespace<'a, f64>
+    + Namespace<f64>
-    + for<'a> Namespace<'a, bool>
+    + Namespace<bool>
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Option<u32>>
+    + Namespace<Option<u32>>
-    + for<'a> Namespace<'a, Option<Arc<RwLock<MidiClip>>>>
+    + Namespace<Option<Arc<RwLock<MidiClip>>>>
 {
     #[command(Show = "show")]
     fn show (&mut self, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<MidiEditCommand> {
@@ -236,7 +236,6 @@ impl MidiEditor {
             self.mode.redraw();
         }
     }
-    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() }

src/device/pool.rs

@@ -70,28 +70,24 @@ pub trait HasPool: AsRef<Pool> + AsMut<Pool> {
 }
 
 impl<T: HasPool
-    + for<'a> Namespace<'a, bool>
+    + Namespace<bool>
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, PathBuf>
+    + Namespace<PathBuf>
-    + for<'a> Namespace<'a, MidiClip>
+    + Namespace<MidiClip>
-    + for<'a> Namespace<'a, ItemColor>
+    + Namespace<ItemColor>
-    + for<'a> Namespace<'a, PoolCommand>
+    + Namespace<BrowseCommand>
-    + for<'a> Namespace<'a, PoolCommand>
-    + for<'a> Namespace<'a, BrowseCommand>
 > PoolController for T {}
 
 #[tek_proc::commands(PoolCommand = "pool")]
 pub trait PoolController: HasPool
-    + for<'a> Namespace<'a, bool>
+    + Namespace<bool>
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
-    + for<'a> Namespace<'a, Arc<str>>
+    + Namespace<Arc<str>>
-    + for<'a> Namespace<'a, PathBuf>
+    + Namespace<PathBuf>
-    + for<'a> Namespace<'a, MidiClip>
+    + Namespace<MidiClip>
-    + for<'a> Namespace<'a, ItemColor>
+    + Namespace<ItemColor>
-    + for<'a> Namespace<'a, PoolCommand>
+    + Namespace<BrowseCommand>
-    + for<'a> Namespace<'a, PoolCommand>
-    + for<'a> Namespace<'a, BrowseCommand>
 {
 
     #[command(Show = "show")]
@@ -139,7 +135,7 @@ pub trait PoolController: HasPool
         for event in events.iter() {
             clip.notes[event.0 as usize].push(event.2);
         }
-        Ok(PoolCommand::Add { index, clip }.act(self)?)
+        Ok(PoolCommand::Add { index, clip }.dispatch(self)?)
     }
 
     ///// Export to file
@@ -226,7 +222,7 @@ pub trait PoolController: HasPool
     }
 
     #[command(CropSet = "crop/set")]
-    fn crop_set (&mut self, length: usize) -> Perhaps<PoolCommand> {
+    fn crop_set (&mut self, _length: usize) -> Perhaps<PoolCommand> {
         if let Some(PoolMode::Length(clip, ref mut length, ref mut _focus))
             = self.pool_mut().mode_mut().clone()
         {
@@ -237,7 +233,7 @@ pub trait PoolController: HasPool
                 clip.write().unwrap().length = *length;
             }
             *self.pool_mut().mode_mut() = None;
-            return Ok(old_length.map(|length|PoolCommand::CropSet { length }))
+            return Ok(old_length.map(|l|PoolCommand::CropSet { _length: l }))
         }
         Ok(None)
     }
@@ -433,12 +429,6 @@ impl ClipLength {
 }
 
 impl Pool {
-    fn _todo_usize_ (&self) -> usize     { todo!() }
-    fn _todo_bool_  (&self) -> bool      { todo!() }
-    fn _todo_clip_  (&self) -> MidiClip  { todo!() }
-    fn _todo_path_  (&self) -> PathBuf   { todo!() }
-    fn _todo_color_ (&self) -> ItemColor { todo!() }
-    fn _todo_str_   (&self) -> Arc<str>  { todo!() }
     fn _clip_new (&self) -> MidiClip { self.new_clip() }
     fn _clip_cloned (&self) -> MidiClip { self.cloned_clip() }
     fn _clip_index_current (&self) -> usize { 0 }
@@ -449,44 +439,44 @@ impl Pool {
 }
 
 impl<'a> PoolView<'a> {
-    fn tui (&self) -> impl Draw<Tui> {
+    //fn tui (&self) -> impl Draw<Tui> {
-        let Self(pool) = self;
+        //let Self(pool) = self;
-        //let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||g(32).into());
+        ////let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||g(32).into());
-        //let on_bg  = |x|x;//below(Repeat(" "), bg(color.darkest.term, x));
+        ////let on_bg  = |x|x;//below(Repeat(" "), bg(color.darkest.term, x));
-        //let border = |x|x;//Outer(Style::default().fg(color.dark.term).bg(color.darkest.term)).enclose(x);
+        ////let border = |x|x;//Outer(Style::default().fg(color.dark.term).bg(color.darkest.term)).enclose(x);
-        //let height = pool.clips.read().unwrap().len() as u16;
+        ////let height = pool.clips.read().unwrap().len() as u16;
-        iter(
+        //iter(
-            ||pool.clips().clone().into_iter(),
+            //||pool.clips().clone().into_iter(),
-            move|clip: Arc<RwLock<MidiClip>>, i: usize|{
+            //move|clip: Arc<RwLock<MidiClip>>, i: usize|{
-                let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
+                //let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
-                let item_height = 1;
+                //let item_height = 1;
-                let _item_offset = i as u16 * item_height;
+                //let _item_offset = i as u16 * item_height;
-                let selected    = i == pool.clip_index();
+                //let selected    = i == pool.clip_index();
-                let b           = if selected { color.light.term } else { color.base.term };
+                //let b           = if selected { color.light.term } else { color.base.term };
-                let f           = color.lightest.term;
+                //let f           = color.lightest.term;
-                let name        = if false { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
+                //let name        = if false { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
-                let length      = if false { String::default()  } else { format!("{length}  ") };
+                //let length      = if false { String::default()  } else { format!("{length}  ") };
-                bg(b, below!(
+                //bg(b, below!(
-                    fg(f, bold(selected, name)).origin_w().full_w(),
+                    //fg(f, bold(selected, name)).origin_w().full_w(),
-                    fg(f, bold(selected, length)).origin_e().full_w(),
+                    //fg(f, bold(selected, length)).origin_e().full_w(),
-                    when(selected, bold(true, fg(g(255), "▶"))).origin_w().full_w(),
+                    //when(selected, bold(true, fg(g(255), "▶"))).origin_w().full_w(),
-                    when(selected, bold(true, fg(g(255), "◀"))).origin_e().full_w(),
+                    //when(selected, bold(true, fg(g(255), "◀"))).origin_e().full_w(),
-                )).exact_h(1)
+                //)).exact_h(1)
-            }).origin_n().full_h().exact_w(20)
+            //}).origin_n().full_h().exact_w(20)
-    }
+    //}
 }
 
 impl ClipLength {
-    fn tui (&self) -> impl Draw<Tui> {
+    //fn tui (&self) -> impl Draw<Tui> {
-        use ClipLengthFocus::*;
+        //use ClipLengthFocus::*;
-        let bars  = format!("{}", self.bars());
+        //let bars  = format!("{}", self.bars());
-        let beats = format!("{}", self.beats());
+        //let beats = format!("{}", self.beats());
-        let ticks = format!("{:>02}", self.ticks());
+        //let ticks = format!("{:>02}", self.ticks());
-        match self.focus {
+        //match self.focus {
-            None       => east!(" ", bars, ".", beats, ".", ticks),
+            //None       => east!(" ", bars, ".", beats, ".", ticks),
-            Some(Bar)  => east!("[", bars, "]", beats, ".", ticks),
+            //Some(Bar)  => east!("[", bars, "]", beats, ".", ticks),
-            Some(Beat) => east!(" ", bars, "[", beats, "]", ticks),
+            //Some(Beat) => east!(" ", bars, "[", beats, "]", ticks),
-            Some(Tick) => east!(" ", bars, ".", beats, "[", ticks),
+            //Some(Tick) => east!(" ", bars, ".", beats, "[", ticks),
-        }
+        //}
-    }
+    //}
 }

src/device/sampler.rs

@@ -21,7 +21,7 @@ impl<T: AsRef<Sampler> + AsMut<Sampler>> HasSampler for T {}
 
 #[tek_proc::commands(SamplerCommand = "sampler")]
 pub trait SamplerController: HasSampler
-    + for<'a> Namespace<'a, usize>
+    + Namespace<usize>
 {
 
     #[command(RecordToggle = "rec-toggle")]
@@ -30,10 +30,10 @@ pub trait SamplerController: HasSampler
     {
         let sampler = self.sampler_mut();
         let recording = sampler.recording.as_ref().map(|x|x.0);
-        let _ = SamplerCommand::RecordFinish.act(self)?;
+        let _ = SamplerCommand::RecordFinish.dispatch(self)?;
         // autoslice: continue recording at next slot
         if recording != Some(slot) {
-            SamplerCommand::RecordBegin { slot }.act(self)
+            SamplerCommand::RecordBegin { slot }.dispatch(self)
         } else {
             Ok(None)
         }

src/device/sequence.rs

@@ -245,19 +245,25 @@ pub trait HasMidiClip {
     fn clip (&self) -> Option<Arc<RwLock<MidiClip>>>;
 }
 
+impl HasMidiClip for App {
+    fn clip (&self) -> Option<Arc<RwLock<MidiClip>>> {
+        None
+    }
+}
+
 impl<T: HasMidiClip
-    + for<'a> Namespace<'a, Option<bool>>
+    + Namespace<Option<bool>>
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + Namespace<Option<ItemTheme>>
 > MidiClipController for T {}
 
 #[tek_proc::commands(MidiClipCommand)]
 pub trait MidiClipController: HasMidiClip
-    + for<'a> Namespace<'a, Option<bool>>
+    + Namespace<Option<bool>>
-    + for<'a> Namespace<'a, Option<ItemTheme>>
+    + Namespace<Option<ItemTheme>>
 {
 
     #[command(SetColor = "clip/color")]
-    fn clip_set_color (&mut self, color: Option<ItemTheme>) -> Perhaps<MidiClipCommand> {
+    fn clip_set_color (&mut self, _color: Option<ItemTheme>) -> Perhaps<MidiClipCommand> {
         //(SetColor [t: usize, s: usize, c: ItemTheme]
             //clip.clip_set_color(t, s, c).map(|o|Self::SetColor(t, s, o)))));
             //("color"   [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemTheme::random())))
@@ -265,7 +271,7 @@ pub trait MidiClipController: HasMidiClip
     }
 
     #[command(SetLoop = "clip/loop")]
-    fn clip_toggle_loop (&mut self, looping: Option<bool>) -> Perhaps<MidiClipCommand> {
+    fn clip_toggle_loop (&mut self, _looping: Option<bool>) -> Perhaps<MidiClipCommand> {
         //(SetLoop  [t: usize, s: usize, l: bool] cmd_todo!("\n\rtodo: {self:?}"))
             //("loop"    [a: usize, b: usize, c: bool] Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
         todo!()
@@ -356,14 +362,6 @@ impl PartialEq for MidiClip {
 
 impl Eq for MidiClip {}
 
-impl MidiClip {
-    fn _todo_opt_bool_stub_ (&self) -> Option<bool> { todo!() }
-    fn _todo_bool_stub_ (&self) -> bool { todo!() }
-    fn _todo_usize_stub_ (&self) -> usize { todo!() }
-    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
-    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
-    fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
-}
 impl_has!(Sequencer:       |self: Track|           self.sequencer);
 impl_has!(Clock:           |self: Sequencer|       self.clock);
 impl_has!(Vec<MidiInput>:  |self: Sequencer|       self.midi_ins);

src/tek.edn

@@ -18,10 +18,13 @@
     (align/s (bsp/e :ports/out (bsp/e :transport :ports/in)))
     (align/c (bsp/s (align/x (bg (g 36) :logo)) (bg (g 24) :dialog/menu))))))
 
+(keys :back    (@escape (back)))
+(keys :confirm (@enter  (dialog confirm)))
+(keys :axis/y  (@up     (axis (dec :y)))
+               (@down   (axis (inc :y))))
+
 (mode :arranger (name Arranger) (info Launch grid.)
-  (keys (see :clock :color :launch :scenes :tracks :global)
+  (keys :clock :color :launch :scenes :tracks :global)
-    (@tab project/edit) (@shift/I project/input/add) (@shift/O project/output/add)
-    (@shift/D dialog/show :dialog/device))
   (mode :editor     (keys :editor))
   (mode :dialog     (keys :dialog))
   (mode :message    (keys :message))
@@ -46,6 +49,27 @@
                          (bg (g 80) (bsp/s :scenes/names :editor))
                          (bg (g 90) :scenes))))))))))))))
 
+(keys :clock  (@space       clock/toggle 0)
+              (@shift/space clock/toggle 0))
+
+(keys :color  (@c           color))
+
+(keys :launch (@q           launch))
+
+(keys :scenes (@shift/S     (scenes add))
+              (@s           (select scene))
+              (@up          (select scene-dec))
+              (@down        (select scene-inc)))
+
+(keys :tracks (@shift/T     (tracks add))
+              (@t           (select track))
+              (@left        (select track-dec))
+              (@right       (select track-inc)))
+
+(keys :global (see :history :saveload)
+              (@f8          dialog :options)
+              (@f10         dialog :quit))
+
 (view :ports/out
   (bsp/s (align/w (text L-AUDIO-OUT))
     (bsp/e (text MIDI-OUT)
@@ -86,18 +110,24 @@
 
 (view :groove/sequence (bsp/e (fill/y (align/n (bsp/s :status/v :editor-status))) (bsp/e :samples/keys :editor)))
 
-(keys :back    (@escape back))
+(keys :axis/x  (@left         dec :x)
-(keys :confirm (@enter  confirm))
+               (@right        inc :x))
-(keys :axis/x  (@left        app/dec :x)  (@right        app/inc :x))
+(keys :axis/x2 (@shift/left   dec :x2)
-(keys :axis/x2 (@shift/left  app/dec :x2) (@shift/right  app/inc :x2))
+               (@shift/right  inc :x2))
-(keys :axis/y  (@up          app/dec :y)  (@down         app/inc :y))
+(keys :axis/y2 (@shift/up     dec :y2)
-(keys :axis/y2 (@shift/up    app/dec :y2) (@shift/down   app/inc :y2))
+               (@shift/down   inc :y2))
-(keys :axis/z  (@minus       app/dec :z)  (@equal        app/inc :z))
+(keys :axis/z  (@minus        dec :z)
-(keys :axis/z2 (@underscore  app/dec :z2) (@plus         app/inc :z2))
+               (@equal        inc :z))
-(keys :axis/i  (@comma       app/dec :i)  (@period       app/inc :z))
+(keys :axis/z2 (@underscore   dec :z2)
-(keys :axis/i2 (@lt          app/dec :i2) (@gt           app/inc :z2))
+               (@plus         inc :z2))
-(keys :axis/w  (@openbracket app/dec :w)  (@closebracket app/inc :w))
+(keys :axis/i  (@comma        dec :i)
-(keys :axis/w2 (@openbrace   app/dec :w2) (@closebrace   app/inc :w2))
+               (@period       inc :z))
+(keys :axis/i2 (@lt           dec :i2)
+               (@gt           inc :z2))
+(keys :axis/w  (@openbracket  dec :w)
+               (@closebracket inc :w))
+(keys :axis/w2 (@openbrace    dec :w2)
+               (@closebrace   inc :w2))
 (keys :focus)
 (keys :editor                (see :axis/i :axis/i2 :axis/y
                                   :page :editor/view :editor/add :editor/del))
@@ -117,19 +147,11 @@
                              (@down      sampler/select        :sample/below)
                              (@left      sampler/select        :sample/to/left)
                              (@right     sampler/select        :sample/to/right))
-(keys :tracks                (@t         select                :select/track)
-                             (@shift/T   project/track/add)
-                             (@left      select :select/track/dec)
-                             (@right     select :select/track/inc))
 (keys :track                 (see :color :launch :axis/z :axis/z2 :delete)
                              (@r         toggle :rec)
                              (@m         toggle :mon)
                              (@p         toggle :play)
                              (@P         toggle :solo))
-(keys :scenes                (@s         select :select/scene)
-                             (@shift/S   project/scene/add)
-                             (@up        select :select/scene/dec)
-                             (@down      select :select/scene/inc))
 (keys :scene                 (see :color :launch :axis/z :axis/z2 :delete))
 (keys :help                  (@f1        dialog :help))
 (keys :page                  (@pgup      page/up)
@@ -144,13 +166,6 @@
                              (@r           redo         1))
 (keys :saveload              (@f6          dialog       :save)
                              (@f9          dialog       :load))
-(keys :color                 (@c           color))
-(keys :launch                (@q           launch))
-(keys :clock                 (@space       clock/toggle 0)
-                             (@shift/space clock/toggle 0))
-(keys :global                (see :history :saveload)
-                             (@f8          dialog :options)
-                             (@f10         dialog :quit))
 (keys :clip                  (see :color :launch :axis/z :axis/z2 :delete)
                              (@l           toggle :loop))
 (keys :sequencer             (see :color :launch)

tengri

@@ -1 +1 @@
-Subproject commit b7f4d55e1d67d3481ecee14f693ca3e0a9426a6c
+Subproject commit 1f541407597c7866cf1450d03967ab4711d28d29