flatten workspace into 1 crate

src/mixer.rs

@@ -0,0 +1,263 @@
+use crate::*;
+
+#[derive(Debug)]
+pub struct Mixer {
+    /// JACK client handle (needs to not be dropped for standalone mode to work).
+    pub jack:            Arc<RwLock<JackClient>>,
+    pub name:            String,
+    pub tracks:          Vec<MixerTrack>,
+    pub selected_track:  usize,
+    pub selected_column: usize,
+}
+
+/// A mixer track.
+#[derive(Debug)]
+pub struct MixerTrack {
+    pub name:    String,
+    /// Inputs of 1st device
+    pub audio_ins: Vec<Port<AudioIn>>,
+    /// Outputs of last device
+    pub audio_outs: Vec<Port<AudioOut>>,
+    /// Device chain
+    pub devices: Vec<Box<dyn MixerTrackDevice>>,
+}
+
+audio!(|self: Mixer, _client, _scope|Control::Continue);
+
+impl Mixer {
+    pub fn new (jack: &Arc<RwLock<JackClient>>, name: &str) -> Usually<Self> {
+        Ok(Self {
+            jack: jack.clone(),
+            name: name.into(),
+            selected_column: 0,
+            selected_track:  1,
+            tracks: vec![],
+        })
+    }
+    pub fn track_add (&mut self, name: &str, channels: usize) -> Usually<&mut Self> {
+        let track = MixerTrack::new(name)?;
+        self.tracks.push(track);
+        Ok(self)
+    }
+    pub fn track (&self) -> Option<&MixerTrack> {
+        self.tracks.get(self.selected_track)
+    }
+}
+
+impl MixerTrack {
+    pub fn new (name: &str) -> Usually<Self> {
+        Ok(Self {
+            name:       name.to_string(),
+            audio_ins:  vec![],
+            audio_outs: vec![],
+            devices:    vec![],
+            //ports:   JackPorts::default(),
+            //devices: vec![],
+            //device:  0,
+        })
+    }
+    //fn get_device_mut (&self, i: usize) -> Option<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
+        //self.devices.get(i).map(|d|d.state.write().unwrap())
+    //}
+    //pub fn device_mut (&self) -> Option<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
+        //self.get_device_mut(self.device)
+    //}
+    ///// Add a device to the end of the chain.
+    //pub fn append_device (&mut self, device: JackDevice<E>) -> Usually<&mut JackDevice<E>> {
+        //self.devices.push(device);
+        //let index = self.devices.len() - 1;
+        //Ok(&mut self.devices[index])
+    //}
+    //pub fn add_device (&mut self, device: JackDevice<E>) {
+        //self.devices.push(device);
+    //}
+    //pub fn connect_first_device (&self) -> Usually<()> {
+        //if let (Some(port), Some(device)) = (&self.midi_out, self.devices.get(0)) {
+            //device.client.as_client().connect_ports(&port, &device.midi_ins()?[0])?;
+        //}
+        //Ok(())
+    //}
+    //pub fn connect_last_device (&self, app: &Track) -> Usually<()> {
+        //Ok(match self.devices.get(self.devices.len().saturating_sub(1)) {
+            //Some(device) => {
+                //app.audio_out(0).map(|left|device.connect_audio_out(0, &left)).transpose()?;
+                //app.audio_out(1).map(|right|device.connect_audio_out(1, &right)).transpose()?;
+                //()
+            //},
+            //None => ()
+        //})
+    //}
+}
+
+pub struct TrackView<'a> {
+    pub chain:     Option<&'a MixerTrack>,
+    pub direction: Direction,
+    pub focused:   bool,
+    pub entered:   bool,
+}
+
+impl<'a> Render<Tui> for TrackView<'a> {
+    fn min_size (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
+        todo!()
+    }
+    fn render (&self, to: &mut TuiOutput) -> Usually<()> {
+        todo!();
+        //let mut area = to.area();
+        //if let Some(chain) = self.chain {
+            //match self.direction {
+                //Direction::Down  => area.width = area.width.min(40),
+                //Direction::Right => area.width = area.width.min(10),
+                //_ => { unimplemented!() },
+            //}
+            //to.fill_bg(to.area(), Nord::bg_lo(self.focused, self.entered));
+            //let mut split = Stack::new(self.direction);
+            //for device in chain.devices.as_slice().iter() {
+                //split = split.add_ref(device);
+            //}
+            //let (area, areas) = split.render_areas(to)?;
+            //if self.focused && self.entered && areas.len() > 0 {
+                //Corners(Style::default().green().not_dim()).draw(to.with_rect(areas[0]))?;
+            //}
+            //Ok(Some(area))
+        //} else {
+            //let [x, y, width, height] = area;
+            //let label = "No chain selected";
+            //let x = x + (width - label.len() as u16) / 2;
+            //let y = y + height / 2;
+            //to.blit(&label, x, y, Some(Style::default().dim().bold()))?;
+            //Ok(Some(area))
+        //}
+    }
+}
+
+//impl Content<Tui> for Mixer<Tui> {
+    //fn content (&self) -> impl Render<Tui> {
+        //Stack::right(|add| {
+            //for channel in self.tracks.iter() {
+                //add(channel)?;
+            //}
+            //Ok(())
+        //})
+    //}
+//}
+
+//impl Content<Tui> for Track<Tui> {
+    //fn content (&self) -> impl Render<Tui> {
+        //TrackView {
+            //chain:     Some(&self),
+            //direction: tek_core::Direction::Right,
+            //focused:   true,
+            //entered:   true,
+            ////pub channels:          u8,
+            ////pub input_ports:       Vec<Port<AudioIn>>,
+            ////pub pre_gain_meter:    f64,
+            ////pub gain:              f64,
+            ////pub insert_ports:      Vec<Port<AudioOut>>,
+            ////pub return_ports:      Vec<Port<AudioIn>>,
+            ////pub post_gain_meter:   f64,
+            ////pub post_insert_meter: f64,
+            ////pub level:             f64,
+            ////pub pan:               f64,
+            ////pub output_ports:      Vec<Port<AudioOut>>,
+            ////pub post_fader_meter:  f64,
+            ////pub route:             String,
+        //}
+    //}
+//}
+
+handle!(<Tui>|self:Mixer,engine|{
+    if let TuiEvent::Input(crossterm::event::Event::Key(event)) = engine.event() {
+
+        match event.code {
+            //KeyCode::Char('c') => {
+                //if event.modifiers == KeyModifiers::CONTROL {
+                    //self.exit();
+                //}
+            //},
+            KeyCode::Down => {
+                self.selected_track = (self.selected_track + 1) % self.tracks.len();
+                println!("{}", self.selected_track);
+                return Ok(Some(true))
+            },
+            KeyCode::Up => {
+                if self.selected_track == 0 {
+                    self.selected_track = self.tracks.len() - 1;
+                } else {
+                    self.selected_track -= 1;
+                }
+                println!("{}", self.selected_track);
+                return Ok(Some(true))
+            },
+            KeyCode::Left => {
+                if self.selected_column == 0 {
+                    self.selected_column = 6
+                } else {
+                    self.selected_column -= 1;
+                }
+                return Ok(Some(true))
+            },
+            KeyCode::Right => {
+                if self.selected_column == 6 {
+                    self.selected_column = 0
+                } else {
+                    self.selected_column += 1;
+                }
+                return Ok(Some(true))
+            },
+            _ => {
+                println!("\n{event:?}");
+            }
+        }
+
+    }
+    Ok(None)
+});
+
+handle!(<Tui>|self:MixerTrack,from|{
+    match from.event() {
+        //,    NONE, "chain_cursor_up",   "move cursor up", || {
+        key_pat!(KeyCode::Up) => {
+            Ok(Some(true))
+        },
+        // ,  NONE, "chain_cursor_down", "move cursor down", || {
+        key_pat!(KeyCode::Down) => {
+            Ok(Some(true))
+        },
+        // Left,  NONE, "chain_cursor_left", "move cursor left", || {
+        key_pat!(KeyCode::Left) => {
+            //if let Some(track) = app.arranger.track_mut() {
+                //track.device = track.device.saturating_sub(1);
+                //return Ok(true)
+            //}
+            Ok(Some(true))
+        },
+        // , NONE, "chain_cursor_right", "move cursor right", || {
+        key_pat!(KeyCode::Right) => {
+            //if let Some(track) = app.arranger.track_mut() {
+                //track.device = (track.device + 1).min(track.devices.len().saturating_sub(1));
+                //return Ok(true)
+            //}
+            Ok(Some(true))
+        },
+        // , NONE, "chain_mode_switch", "switch the display mode", || {
+        key_pat!(KeyCode::Char('`')) => {
+            //app.chain_mode = !app.chain_mode;
+            Ok(Some(true))
+        },
+        _ => Ok(None)
+    }
+});
+
+pub enum MixerTrackCommand {}
+
+//impl MixerTrackDevice for LV2Plugin {}
+
+pub trait MixerTrackDevice: Debug + Send + Sync {
+    fn boxed (self) -> Box<dyn MixerTrackDevice> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+impl MixerTrackDevice for Sampler {}
+
+impl MixerTrackDevice for Plugin {}