tek/src/gear/device.rs

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!(),
        }
    }
}

/// Has a chain of devices.
pub trait HasDevices: AsRef<Vec<Device>> + AsMut<Vec<Device>> {
    fn devices (&self) -> &Vec<Device> {
        self.as_ref()
    }
    fn devices_mut (&mut self) -> &mut Vec<Device> {
        self.as_mut()
    }
}

#[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()
    }
}