wip: bringing it back from the dead once again

config/config_arranger.edn

@@ -1,23 +1,22 @@
-(name "Arranger")
-
-(info "A session grid.")
-
+(name
+  "Arranger")
+(info
+  "A grid of launchable clips arranged by track and scene.")
 (keys
-  (layer-if :focus-editor      "./keys_editor.edn")
-  (layer-if :focus-dialog      "./keys_dialog.edn")
-  (layer-if :focus-message     "./keys_message.edn")
-  (layer-if :focus-device-add  "./keys_device_add.edn")
-  (layer-if :focus-browser     "./keys_browser.edn")
-  (layer-if :focus-pool-rename "./keys_rename.edn")
-  (layer-if :focus-pool-length "./keys_length.edn")
-  (layer-if :focus-clip        "./keys_clip.edn")
-  (layer-if :focus-track       "./keys_track.edn")
-  (layer-if :focus-scene       "./keys_scene.edn")
-  (layer-if :focus-mix         "./keys_mix.edn")
-  (layer                       "./keys_clock.edn")
-  (layer                       "./keys_arranger.edn")
-  (layer                       "./keys_global.edn"))
-
+  (cond :focus-editor      (load "./keys_editor.edn"))
+  (cond :focus-dialog      (load "./keys_dialog.edn"))
+  (cond :focus-message     (load "./keys_message.edn"))
+  (cond :focus-device-add  (load "./keys_device_add.edn"))
+  (cond :focus-browser     (load "./keys_browser.edn"))
+  (cond :focus-pool-rename (load "./keys_rename.edn"))
+  (cond :focus-pool-length (load "./keys_length.edn"))
+  (cond :focus-clip        (load "./keys_clip.edn"))
+  (cond :focus-track       (load "./keys_track.edn"))
+  (cond :focus-scene       (load "./keys_scene.edn"))
+  (cond :focus-mix         (load "./keys_mix.edn"))
+  (load "./keys_clock.edn")
+  (load "./keys_arranger.edn")
+  (load "./keys_global.edn"))
 (view
   (bsp/a :view-dialog
     (bsp/w :view-meters-output

crates/app/src/model.rs

@@ -42,12 +42,12 @@ maybe_has!(Scene: |self: App|
 impl HasSceneScroll for App { fn scene_scroll (&self) -> usize { self.project.scene_scroll() } }
 has_clips!(|self: App|self.pool.clips);
 impl HasClipsSize for App { fn clips_size (&self) -> &Measure<TuiOut> { &self.project.inner_size } }
-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));
-take!(DialogCommand      |state: App, iter|Take::take(&state.dialog, iter));
+//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));
+//take!(DialogCommand      |state: App, iter|Take::take(&state.dialog, iter));
 //has_editor!(|self: App|{
     //editor = self.editor;
     //editor_w = {
@@ -327,36 +327,36 @@ pub struct Configuration {
     /// Description of configuration
     pub info: Option<Arc<str>>,
     /// View definition
-    pub view: Cst,
+    pub view: Ast,
     // Input keymap
-    pub keys: InputMap<App, AppCommand, TuiIn, Cst>,
+    pub keys: InputMap<TuiIn, Ast>,
 }
 
 impl Configuration {
 
     pub fn new (path: &impl AsRef<Path>, _watch: bool) -> Usually<Self> {
         let text = read_and_leak(path.as_ref())?;
-        let [name, info, view, keys] = Self::parse(Cst::from(text))?;
+        let [name, info, view, keys] = Self::parse(Ast::from(text))?;
         Ok(Self {
             path: path.as_ref().into(),
             info: info.map(Self::parse_info).flatten(),
             name: name.map(Self::parse_name).flatten(),
-            view: Self::parse_view(view)?,
-            keys: Self::parse_keys(&path, keys)?,
+            view: Self::parse_view(view)?.into(),
+            keys: Self::parse_keys(&path, keys)?.into(),
         })
     }
 
-    fn parse (iter: Cst) -> Usually<[Option<Cst>;4]> {
-        let mut name: Option<Cst> = None;
-        let mut info: Option<Cst> = None;
-        let mut view: Option<Cst> = None;
-        let mut keys: Option<Cst> = None;
+    fn parse <T: Dsl> (iter: T) -> Usually<[Option<T>;4]> {
+        let mut name: Option<T> = None;
+        let mut info: Option<T> = None;
+        let mut view: Option<T> = None;
+        let mut keys: Option<T> = None;
         for token in iter {
             match token.value {
-                Value::Exp(_, mut exp) => {
+                DslVal::Exp(_, mut exp) => {
                     let next = exp.next();
-                    match next {
-                        Some(Token { value: Value::Key(sym), .. }) => match sym {
+                    match next.val() {
+                        Some(DslVal::Key(sym)) => match sym.as_ref() {
                             "name" => name = Some(exp),
                             "info" => info = Some(exp),
                             "keys" => keys = Some(exp),
@@ -378,23 +378,23 @@ impl Configuration {
         Ok([name, info, view, keys])
     }
 
-    fn parse_info (mut iter: Cst) -> Option<Arc<str>> {
-        iter.next().and_then(|x|if let Value::Str(x) = x.value {
+    fn parse_info <T: Dsl> (mut iter: T) -> Option<Arc<str>> {
+        iter.next().and_then(|x|if let DslVal::Str(x) = x.value {
             Some(x.into())
         } else {
             None
         })
     }
 
-    fn parse_name (mut iter: Cst) -> Option<Arc<str>> {
-        iter.next().and_then(|x|if let Value::Str(x) = x.value {
+    fn parse_name <T: Dsl> (mut iter: T) -> Option<Arc<str>> {
+        iter.next().and_then(|x|if let DslVal::Str(x) = x.value {
             Some(x.into())
         } else {
             None
         })
     }
 
-    fn parse_view (iter: Option<Cst>) -> Usually<Cst> {
+    fn parse_view <T: Dsl> (iter: Option<T>) -> Usually<T> {
         if let Some(view) = iter {
             Ok(view)
         } else {
@@ -402,8 +402,8 @@ impl Configuration {
         }
     }
 
-    fn parse_keys (base: &impl AsRef<Path>, iter: Option<Cst>)
-        -> Usually<InputMap<App, AppCommand, TuiIn, Cst>>
+    fn parse_keys <T: Dsl> (base: &impl AsRef<Path>, iter: Option<T>)
+        -> Usually<InputMap<TuiIn, T>>
     {
         if iter.is_none() {
             return Err(format!("missing keys definition").into())
@@ -411,12 +411,12 @@ impl Configuration {
         let mut keys = iter.unwrap();
         let mut map  = InputMap::default();
         while let Some(token) = keys.next() {
-            if let Value::Exp(_, mut exp) = token.value {
+            if let DslVal::Exp(_, mut exp) = token.value {
                 let next = exp.next();
-                if let Some(Token { value: Value::Key(sym), .. }) = next {
+                if let Some(DslVal::Key(sym)) = next.val().map(|x|x.val()) {
                     match sym {
                         "layer" => {
-                            if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
+                            if let Some(DslVal::Str(path)) = exp.peek().map(|x|x.val()) {
                                 let path = base.as_ref().parent().unwrap().join(unquote(path));
                                 if !std::fs::exists(&path)? {
                                     return Err(format!("(e5) not found: {path:?}").into())
@@ -432,13 +432,13 @@ impl Configuration {
                         "layer-if" => {
                             let mut cond = None;
 
-                            if let Some(Token { value: Value::Sym(sym), .. }) = exp.next() {
+                            if let Some(DslVal::Sym(sym)) = exp.next().map(|x|x.val()) {
                                 cond = Some(leak(sym));
                             } else {
                                 return Err(format!("(e4) unexpected non-symbol {next:?}").into())
                             };
 
-                            if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
+                            if let Some(DslVal::Str(path)) = exp.peek().map(|x|x.val()) {
                                 let path = base.as_ref().parent().unwrap().join(unquote(path));
                                 if !std::fs::exists(&path)? {
                                     return Err(format!("(e5) not found: {path:?}").into())
@@ -448,11 +448,11 @@ impl Configuration {
                                 let keys = read_and_leak(path)?.into();
                                 let cond = cond.unwrap();
                                 println!("ok");
-                                map.add_layer_if(
-                                    Box::new(move |state: &App|Take::take_or_fail(
-                                        state, exp, ||"missing input layer conditional"
-                                    )), keys
-                                );
+                                //map.add_layer_if(
+                                    //Box::new(move |state: &App|Take::take_or_fail(
+                                        //state, exp, ||"missing input layer conditional"
+                                    //)), keys
+                                //);
                             } else {
                                 return Err(format!("(e4) unexpected non-symbol {next:?}").into())
                             }

crates/device/src/arranger/arranger_model.rs

@@ -58,18 +58,18 @@ maybe_has!(Track:      |self: Arrangement|
 maybe_has!(Scene:      |self: Arrangement|
     { Has::<Selection>::get(self).track().map(|index|Has::<Vec<Scene>>::get(self).get(index)).flatten() };
     { Has::<Selection>::get(self).track().map(|index|Has::<Vec<Scene>>::get_mut(self).get_mut(index)).flatten() });
-take!(MidiInputCommand  |state: Arrangement, iter|state.selected_midi_in().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-take!(MidiOutputCommand |state: Arrangement, iter|state.selected_midi_out().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-take!(DeviceCommand|state: Arrangement, iter|state.selected_device().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-take!(TrackCommand |state: Arrangement, iter|state.selected_track().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-take!(SceneCommand |state: Arrangement, iter|state.selected_scene().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
-take!(ClipCommand  |state: Arrangement, iter|state.selected_clip().as_ref()
-    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(MidiInputCommand  |state: Arrangement, iter|state.selected_midi_in().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(MidiOutputCommand |state: Arrangement, iter|state.selected_midi_out().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(DeviceCommand|state: Arrangement, iter|state.selected_device().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(TrackCommand |state: Arrangement, iter|state.selected_track().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(SceneCommand |state: Arrangement, iter|state.selected_scene().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
+//take!(ClipCommand  |state: Arrangement, iter|state.selected_clip().as_ref()
+    //.map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 #[tengri_proc::expose] impl Arrangement {
     fn selected_midi_in  (&self) -> Option<MidiInput>  { todo!() }
     fn selected_midi_out (&self) -> Option<MidiOutput> { todo!() }

crates/device/src/pool/pool_model.rs

@@ -12,10 +12,10 @@ pub struct Pool {
     /// Embedded file browser
     pub browser: Option<Browser>,
 }
-take!(BrowserCommand |state: Pool, iter|Ok(state.browser.as_ref()
-    .map(|p|Take::take(p, iter))
-    .transpose()?
-    .flatten()));
+//take!(BrowserCommand |state: Pool, iter|Ok(state.browser.as_ref()
+    //.map(|p|Take::take(p, iter))
+    //.transpose()?
+    //.flatten()));
 impl Default for Pool {
     fn default () -> Self {
         use PoolMode::*;

deps/tengri

@@ -1 +1 @@
-Subproject commit 21832453d9554752a77278385446518744baeee8
+Subproject commit ca4c558eab46aad27da145381e425908d995a625