wip: perilous unblocker

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 } }
-from_dsl!(ClockCommand:       |state: App, iter|Namespace::take_from(state.clock(), iter));
+from_dsl!(ClockCommand:       |state: App, iter|Take::take(state.clock(), iter));
-from_dsl!(MidiEditCommand:    |state: App, iter|Ok(state.editor().map(|x|Namespace::take_from(x, iter)).transpose()?.flatten()));
+from_dsl!(MidiEditCommand:    |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
-from_dsl!(PoolCommand:        |state: App, iter|Namespace::take_from(&state.pool, iter));
+from_dsl!(PoolCommand:        |state: App, iter|Take::take(&state.pool, iter));
-from_dsl!(SamplerCommand:     |state: App, iter|Ok(state.project.sampler().map(|x|Namespace::take_from(x, iter)).transpose()?.flatten()));
+from_dsl!(SamplerCommand:     |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
-from_dsl!(ArrangementCommand: |state: App, iter|Namespace::take_from(&state.project, iter));
+from_dsl!(ArrangementCommand: |state: App, iter|Take::take(&state.project, iter));
-from_dsl!(DialogCommand:      |state: App, iter|Namespace::take_from(&state.dialog, iter));
+from_dsl!(DialogCommand:      |state: App, iter|Take::take(&state.dialog, iter));
 //has_editor!(|self: App|{
     //editor = self.editor;
     //editor_w = {
@@ -449,9 +449,9 @@ impl Configuration {
                                 let cond = cond.unwrap();
                                 println!("ok");
                                 map.add_layer_if(
-                                    Box::new(move |state: &App|Namespace::take_from_or_fail(
+                                    Box::new(move |state: &App|Take::take_or_fail(
                                         state, &mut exp.clone(),
-                                        format!("missing input layer conditional")
+                                        ||"missing input layer conditional"
                                     )), keys
                                 );
                             } else {

crates/app/src/view.rs

@@ -10,41 +10,55 @@ impl<T: Content<TuiOut>> Content<TuiOut> for ErrorBoundary<TuiOut, T> {
             Ok(Some(content)) => content.render(to),
             Ok(None) => to.blit(&"empty?", 0, 0, Some(Style::default().yellow())),
             Err(e) => Content::render(&Tui::fg_bg(
-                Rgb(255,224,244),
+                Rgb(255,224,244), Rgb(96,24,24), Bsp::s(
-                Rgb(96,24,24),
-                Bsp::s(
                     Bsp::e(Tui::bold(true, "oops. "), "rendering failed."),
-                    Bsp::e("\"why?\" ", Tui::bold(true, &format!("{e}"))),
+                    Bsp::e("\"why?\" ", Tui::bold(true, &format!("{e}"))))), to)
-                )), to)
         })
     }
 }
 
+impl App {
+    pub fn view (model: &Self) -> impl Content<TuiOut> + '_ {
+        ErrorBoundary::<TuiOut, Box<dyn Render<TuiOut> + '_>>(
+            Default::default(),
+            Give::give(model, &mut model.config.view.clone())
+        )
+    }
+}
+
 #[tengri_proc::view(TuiOut)]
 impl App {
-    pub fn view (app: &Self) -> impl Content<TuiOut> {
+    pub fn view_nil (model: &Self) -> impl Content<TuiOut> {
-        ErrorBoundary::<TuiOut, Box<dyn Render<TuiOut> + '_>>(
-            Default::default(),
-            Namespace::take_from(app, &mut app.config.view.clone())
-        )
-    }
-    pub fn view_nil (app: &Self) -> impl Content<TuiOut> {
         "nil"
     }
-    pub fn view_history (app: &Self) -> impl Content<TuiOut> {
+    pub fn view_dialog (model: &Self) -> impl Content<TuiOut> + use<'_> {
-        Fixed::y(1, Fill::x(Align::w(FieldH(app.color,
+        model.dialog.as_ref().map(|dialog|Bsp::b("",
-            format!("History ({})", app.history.len()),
+            Fixed::xy(70, 23, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
-                app.history.last().map(|last|Fill::x(Align::w(format!("{:?}", last.0))))))))
+                Repeat(" "), Outer(true, Style::default().fg(Tui::g(96)))
+                    .enclose(dialog))))))
     }
-    pub fn view_status_h2 (app: &Self) -> impl Content<TuiOut> {
+    pub fn view_meters_input (model: &Self) -> impl Content<TuiOut> + use<'_> {
-        app.update_clock();
+        model.project.sampler().map(|s|
-        let theme     = app.color;
+            s.view_meters_input())
-        let clock     = app.clock();
+    }
+    pub fn view_meters_output (model: &Self) -> impl Content<TuiOut> + use<'_> {
+        model.project.sampler().map(|s|
+            s.view_meters_output())
+    }
+    pub fn view_history (model: &Self) -> impl Content<TuiOut> {
+        Fixed::y(1, Fill::x(Align::w(FieldH(model.color,
+            format!("History ({})", model.history.len()),
+                model.history.last().map(|last|Fill::x(Align::w(format!("{:?}", last.0))))))))
+    }
+    pub fn view_status_h2 (model: &Self) -> impl Content<TuiOut> {
+        model.update_clock();
+        let theme     = model.color;
+        let clock     = model.clock();
         let playing   = clock.is_rolling();
         let cache     = clock.view_cache.clone();
-        //let selection = app.selection().describe(app.tracks(), app.scenes());
+        //let selection = model.selection().describe(model.tracks(), model.scenes());
-        let hist_len  = app.history.len();
+        let hist_len  = model.history.len();
-        let hist_last = app.history.last();
+        let hist_last = model.history.last();
         Fixed::y(2, Stack::east(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
             add(&Fixed::x(5, Tui::bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
                 Either::new(false, // TODO
@@ -79,8 +93,8 @@ impl App {
                         //hist_last.map(|last|Fill::x(Align::w(format!("{:?}", last.0))))))),
                     //""
                 //));
-                ////if let Some(last) = app.history.last() {
+                ////if let Some(last) = model.history.last() {
-                    ////add(&FieldV(theme, format!("History ({})", app.history.len()),
+                    ////add(&FieldV(theme, format!("History ({})", model.history.len()),
                         ////Fill::x(Align::w(format!("{:?}", last.0)))));
                 ////}
             }
@@ -198,18 +212,6 @@ impl App {
         //self.project.sampler().map(|s|Outer(true, Style::default().fg(Tui::g(96))).enclose(
             //Fill::y(Align::n(s.view_sample_status(self.editor().unwrap().get_note_pos())))))
     //}
-    //pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
-        //self.project.sampler().map(|s|s.view_meters_input())
-    //}
-    //pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
-        //self.project.sampler().map(|s|s.view_meters_output())
-    //}
-    //pub fn view_dialog (&self) -> impl Content<TuiOut> + use<'_> {
-        //self.dialog.as_ref().map(|dialog|Bsp::b("",
-            //Fixed::xy(70, 23, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
-                //Repeat(" "), Outer(true, Style::default().fg(Tui::g(96)))
-                    //.enclose(dialog))))))
-    //}
 }
 
 impl ScenesView for App {

crates/device/src/arranger/arranger_model.rs

@@ -59,17 +59,17 @@ 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() });
 from_dsl!(MidiInputCommand:  |state: Arrangement, iter|state.selected_midi_in().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 from_dsl!(MidiOutputCommand: |state: Arrangement, iter|state.selected_midi_out().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 from_dsl!(DeviceCommand:|state: Arrangement, iter|state.selected_device().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 from_dsl!(TrackCommand: |state: Arrangement, iter|state.selected_track().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 from_dsl!(SceneCommand: |state: Arrangement, iter|state.selected_scene().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .map(|t|Take::take(t, iter)).transpose().map(|x|x.flatten()));
 from_dsl!(ClipCommand:  |state: Arrangement, iter|state.selected_clip().as_ref()
-    .map(|t|Namespace::take_from(t, iter)).transpose().map(|x|x.flatten()));
+    .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

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

deps/tengri

@@ -1 +1 @@
-Subproject commit a4a1066f187e6b2e119e3c3b471219f1e128d4af
+Subproject commit cbd28a5934a7a2a9f7c48faa92bfe7ba52440919