more shuffling; testing dispatch

src/gear/device.rs

@@ -0,0 +1,122 @@
+use crate::*;
+
+impl App {
+    /// FIXME: generalize. Set picked device in device pick dialog.
+    ///
+    /// ```
+    /// tek::App::default().device_pick(0);
+    /// ```
+    pub fn device_pick (&mut self, index: usize) {
+        self.dialog = Dialog::Device(index);
+    }
+
+    /// FIXME: generalize. Add device to current track.
+    pub fn add_device (&mut self, index: usize) -> Usually<()> {
+        match index {
+            0 => {
+                let name    = self.jack.with_client(|c|c.name().to_string());
+                let midi    = self.project.track().expect("no active track").sequencer.midi_outs[0].port_name();
+                let track   = self.track().expect("no active track");
+                let port    = format!("{}/Sampler", &track.name);
+                let connect = Connect::exact(format!("{name}:{midi}"));
+                let sampler = if let Ok(sampler) = Sampler::new(
+                    &self.jack, &port, &[connect], &[&[], &[]], &[&[], &[]]
+                ) {
+                    self.dialog = Dialog::None;
+                    Device::Sampler(sampler)
+                } else {
+                    self.dialog = Dialog::Message("Failed to add device.".into());
+                    return Err("failed to add device".into())
+                };
+                let track   = self.track_mut().expect("no active track");
+                track.devices.push(sampler);
+                Ok(())
+            },
+            1 => {
+                todo!();
+                //Ok(())
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[tek_proc::command(Device)]
+#[tek_proc::keyword(Device)]
+#[derive(Debug)]
+pub enum DeviceCmd {}
+
+impl Device {
+    pub fn name (&self) -> &str {
+        match self {
+            Self::Sampler(sampler) => sampler.name.as_ref(),
+            _ => todo!(),
+        }
+    }
+    pub fn midi_ins (&self) -> &[MidiInput] {
+        match self {
+            //Self::Sampler(Sampler { midi_in, .. }) => &[midi_in],
+            _ => todo!()
+        }
+    }
+    pub fn midi_outs (&self) -> &[MidiOutput] {
+        match self {
+            Self::Sampler(_) => &[],
+            _ => todo!()
+        }
+    }
+    pub fn audio_ins (&self) -> &[AudioInput] {
+        match self {
+            Self::Sampler(Sampler { audio_ins, .. }) => audio_ins.as_slice(),
+            _ => todo!()
+        }
+    }
+    pub fn audio_outs (&self) -> &[AudioOutput] {
+        match self {
+            Self::Sampler(Sampler { audio_outs, .. }) => audio_outs.as_slice(),
+            _ => todo!()
+        }
+    }
+}
+
+/// A device that can be plugged into the chain.
+///
+/// ```
+/// let device = tek::Device::default();
+/// ```
+#[derive(Debug, Default)] pub enum Device {
+    #[default]
+    Bypass,
+    Mute,
+    #[cfg(feature = "sampler")]
+    Sampler(Sampler),
+    #[cfg(feature = "lv2")]  // TODO
+    Lv2(Lv2),
+    #[cfg(feature = "vst2")] // TODO
+    Vst2,
+    #[cfg(feature = "vst3")] // TODO
+    Vst3,
+    #[cfg(feature = "clap")] // TODO
+    Clap,
+    #[cfg(feature = "sf2")]  // TODO
+    Sf2,       
+}
+
+/// Some sort of wrapper?
+pub struct DeviceAudio<'a>(pub &'a mut Device);
+
+pub fn device_kinds () -> &'static [&'static str] {
+    &[
+        #[cfg(feature = "sampler")] "Sampler",
+        #[cfg(feature = "lv2")] "Plugin (LV2)",
+    ]
+}
+
+impl<T: AsRef<Vec<Device>> + AsMut<Vec<Device>>> HasDevices for T {
+    fn devices (&self) -> &Vec<Device> {
+        self.as_ref()
+    }
+    fn devices_mut (&mut self) -> &mut Vec<Device> {
+        self.as_mut()
+    }
+}