wip: ArrangerStandalone

crates/tek_sequencer/src/arranger_main.rs

@@ -1,5 +1,97 @@
 include!("lib.rs");
+
+use tek_core::clap::{self, Parser};
+
 pub fn main () -> Usually<()> {
-    tek_core::run(Arc::new(RwLock::new(crate::Arranger::from_args()?)))?;
+    tek_core::run(Arc::new(RwLock::new(crate::ArrangerStandalone::from_args()?)))?;
     Ok(())
 }
+
+struct ArrangerStandalone {
+    arranger:       Arranger,
+    transport:      Option<Arc<RwLock<TransportToolbar>>>,
+    show_sequencer: Option<tek_core::Direction>,
+}
+
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct ArrangerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Pulses per quarter note (arruencer resolution; default: 96)
+    #[arg(short, long)] ppq: Option<usize>,
+    /// Whether to include a transport toolbar (default: true)
+    #[arg(short, long)] transport: Option<bool>,
+    /// Number of tracks
+    #[arg(short = 'x', long, default_value_t = 8)] tracks: usize,
+    /// Number of scenes
+    #[arg(short, long, default_value_t = 8)] scenes: usize,
+}
+
+impl ArrangerStandalone {
+    pub fn from_args () -> Usually<Self> {
+        let args = ArrangerCli::parse();
+        let mut app = ArrangerStandalone {
+            arranger: Arranger::new(""),
+            transport: match args.transport {
+                Some(true) => Some(Arc::new(RwLock::new(TransportToolbar::new(None)))),
+                _ => None
+            },
+            show_sequencer: Some(tek_core::Direction::Down),
+        };
+        if let Some(name) = args.name {
+            app.arranger.name = name.clone();
+        }
+        for _ in 0..args.tracks {
+            app.arranger.track_add(None)?;
+        }
+        for _ in 0..args.scenes {
+            app.arranger.scene_add(None)?;
+        }
+        Ok(app)
+    }
+}
+
+render!(ArrangerStandalone |self, buf, area| {
+    let mut layout = Split::down();
+    if let Some(transport) = &self.transport {
+        layout = layout.add_ref(transport);
+    }
+    let sequencer = self.arranger.sequencer();
+    if let Some(direction) = self.show_sequencer {
+        layout = layout.add(Split::new(direction)
+            .add_ref(&self.arranger)
+            .add(sequencer))
+    } else {
+        layout = layout.add_ref(&self.arranger)
+    }
+    layout.render(buf, area)
+});
+
+handle!(ArrangerStandalone |self, e| {
+    if let Some(modal) = self.arranger.modal.as_mut() {
+        let result = modal.handle(e)?;
+        if modal.exited() {
+            self.arranger.modal = None;
+        }
+        Ok(result)
+    } else {
+        match e {
+            AppEvent::Input(Event::Key(k)) => {
+                if k.code == KeyCode::Tab {
+                    self.arranger.focus_sequencer = !self.arranger.focus_sequencer;
+                    Ok(true)
+                } else if self.arranger.focus_sequencer {
+                    if let Some(sequencer) = self.arranger.sequencer_mut() {
+                        handle_keymap(sequencer, e, KEYMAP_SEQUENCER)
+                    } else {
+                        Ok(false)
+                    }
+                } else {
+                    handle_keymap(&mut self.arranger, e, KEYMAP_ARRANGER)
+                }
+            },
+            _ => Ok(false),
+        }
+    }
+});