wip: refactor into crates

crates/tek_mixer/src/lib.rs

@@ -0,0 +1,8 @@
+pub(crate) use tek_core::*;
+pub(crate) use tek_core::ratatui::prelude::*;
+pub(crate) use tek_core::crossterm::event::{KeyCode, KeyModifiers};
+pub(crate) use tek_jack::{*, jack::*};
+submod! {
+    mixer
+    mixer_track
+}

crates/tek_mixer/src/mixer.rs

@@ -0,0 +1,94 @@
+use crate::*;
+
+//pub const ACTIONS: [(&'static str, &'static str);2] = [
+    //("+/-",     "Adjust"),
+    //("Ins/Del", "Add/remove track"),
+//];
+
+pub struct Mixer {
+    pub name:            String,
+    pub tracks:          Vec<MixerTrack>,
+    pub selected_track:  usize,
+    pub selected_column: usize,
+}
+
+//render!(Mixer = crate::view::mixer::render);
+handle!(Mixer = handle_mixer);
+process!(Mixer = process);
+
+impl Mixer {
+    pub fn new (name: &str) -> Usually<Self> {
+        let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
+        Ok(Self {
+            name: name.into(),
+            selected_column: 0,
+            selected_track:  1,
+            tracks: vec![
+                MixerTrack::new(&client, 1, "Mono 1")?,
+                MixerTrack::new(&client, 1, "Mono 2")?,
+                MixerTrack::new(&client, 2, "Stereo 1")?,
+                MixerTrack::new(&client, 2, "Stereo 2")?,
+                MixerTrack::new(&client, 2, "Stereo 3")?,
+                MixerTrack::new(&client, 2, "Bus 1")?,
+                MixerTrack::new(&client, 2, "Bus 2")?,
+                MixerTrack::new(&client, 2, "Mix")?,
+            ],
+        })
+    }
+}
+
+fn process (
+    _: &mut Mixer,
+    _: &Client,
+    _: &ProcessScope
+) -> Control {
+    Control::Continue
+}
+
+pub fn handle_mixer (state: &mut Mixer, event: &AppEvent) -> Usually<bool> {
+    if let AppEvent::Input(crossterm::event::Event::Key(event)) = event {
+
+        match event.code {
+            //KeyCode::Char('c') => {
+                //if event.modifiers == KeyModifiers::CONTROL {
+                    //state.exit();
+                //}
+            //},
+            KeyCode::Down => {
+                state.selected_track = (state.selected_track + 1) % state.tracks.len();
+                println!("{}", state.selected_track);
+                return Ok(true)
+            },
+            KeyCode::Up => {
+                if state.selected_track == 0 {
+                    state.selected_track = state.tracks.len() - 1;
+                } else {
+                    state.selected_track = state.selected_track - 1;
+                }
+                println!("{}", state.selected_track);
+                return Ok(true)
+            },
+            KeyCode::Left => {
+                if state.selected_column == 0 {
+                    state.selected_column = 6
+                } else {
+                    state.selected_column = state.selected_column - 1;
+                }
+                return Ok(true)
+            },
+            KeyCode::Right => {
+                if state.selected_column == 6 {
+                    state.selected_column = 0
+                } else {
+                    state.selected_column = state.selected_column + 1;
+                }
+                return Ok(true)
+            },
+            _ => {
+                println!("\n{event:?}");
+            }
+        }
+
+    }
+    Ok(false)
+}

crates/tek_mixer/src/mixer_track.rs

@@ -0,0 +1,91 @@
+use crate::*;
+
+/// TODO: A track in the mixer. (Integrate with [crate::model::Track]?)
+pub struct MixerTrack {
+    pub name:              String,
+    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,
+}
+
+impl MixerTrack {
+    pub fn new (jack: &Client, channels: u8, name: &str) -> Usually<Self> {
+        let mut input_ports  = vec![];
+        let mut insert_ports = vec![];
+        let mut return_ports = vec![];
+        let mut output_ports = vec![];
+        for channel in 1..=channels {
+            input_ports.push(jack.register_port(&format!("{name} [input {channel}]"),   AudioIn::default())?);
+            output_ports.push(jack.register_port(&format!("{name} [out {channel}]"),    AudioOut::default())?);
+            let insert_port = jack.register_port(&format!("{name} [pre {channel}]"),    AudioOut::default())?;
+            let return_port = jack.register_port(&format!("{name} [insert {channel}]"), AudioIn::default())?;
+            jack.connect_ports(&insert_port, &return_port)?;
+            insert_ports.push(insert_port);
+            return_ports.push(return_port);
+        }
+        Ok(Self {
+            name:              name.into(),
+            channels,
+            input_ports,
+            pre_gain_meter:    0.0,
+            gain:              0.0,
+            post_gain_meter:   0.0,
+            insert_ports,
+            return_ports,
+            post_insert_meter: 0.0,
+            level:             0.0,
+            pan:               0.0,
+            post_fader_meter:  0.0,
+            route:             "---".into(),
+            output_ports,
+        })
+    }
+}
+
+//impl<W: Write> Input<TUI<W>, bool> for Mixer {
+    //fn handle (&mut self, engine: &mut TUI<W>) -> Result<Option<bool>> {
+        //Ok(None)
+    //}
+//
+
+//impl<W: Write> Output<TUI<W>, [u16;2]> for Mixer {
+    //fn render (&self, envine: &mut TUI<W>) -> Result<Option<[u16;2]>> {
+
+        //let tracks_table = Columns::new()
+            //.add(titles)
+            //.add(input_meters)
+            //.add(gains)
+            //.add(gain_meters)
+            //.add(pres)
+            //.add(pre_meters)
+            //.add(levels)
+            //.add(pans)
+            //.add(pan_meters)
+            //.add(posts)
+            //.add(routes)
+
+        //Rows::new()
+            //.add(Columns::new()
+                //.add(Rows::new()
+                    //.add("[Arrows]".bold())
+                    //.add("Navigate"))
+                //.add(Rows::new()
+                    //.add("[+/-]".bold())
+                    //.add("Adjust"))
+                //.add(Rows::new()
+                    //.add("[Ins/Del]".bold())
+                    //.add("Add/remove track")))
+            //.add(tracks_table)
+            //.render(engine)
+    //}
+//}