wip: refactor arranger to device

crates/device/src/arranger/arranger_api.rs

@@ -0,0 +1,207 @@
+use crate::*;
+
+#[tengri_proc::command(Arrangement)] 
+impl ArrangementCommand {
+    fn track (arranger: &mut Arrangement, track: TrackCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn track_add (arranger: &mut Arrangement) -> Perhaps<Self> {
+        let index = arranger.track_add(None, None, &[], &[])?.0;
+        arranger.selected = match arranger.selected {
+            Some(Selection::Track(_)) =>
+                Selection::Track(index),
+            Some(Selection::TrackClip { track, scene }) =>
+                Selection::TrackClip { track: index, scene },
+            _ => arranger.selected
+        };
+        Ok(Some(Self::TrackDelete { index }))
+    }
+    fn track_swap (arranger: &mut Arrangement, index: usize, other: usize) -> Perhaps<Self> {
+        todo!();
+        Ok(Some(Self::TrackSwap { index, other }))
+    }
+    fn track_delete (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
+        let exists = arranger.tracks().get(index).is_some();
+        if exists {
+            let track = arranger.tracks_mut().remove(index);
+            let Track { sequencer: Sequencer { midi_ins, midi_outs, .. }, .. } = track;
+            for port in midi_ins.into_iter() {
+                port.close()?;
+            }
+            for port in midi_outs.into_iter() {
+                port.close()?;
+            }
+            for scene in arranger.scenes_mut().iter_mut() {
+                scene.clips.remove(index);
+            }
+        }
+        Ok(None)
+        //TODO:Ok(Some(Self::TrackAdd ( index, track: Some(deleted_track) })
+    }
+    fn midi_in (arranger: &mut Arrangement, input: InputCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn midi_in_add (arranger: &mut Arrangement) -> Perhaps<Self> {
+        arranger.midi_in_add()?;
+        Ok(None)
+    }
+    fn midi_out (arranger: &mut Arrangement, input: OutputCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn midi_out_add (arranger: &mut Arrangement) -> Perhaps<Self> {
+        arranger.midi_out_add()?;
+        Ok(None)
+    }
+    fn device (arranger: &mut Arrangement, input: DeviceCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn device_add (arranger: &mut Arrangement, i: usize) -> Perhaps<Self> {
+        arranger.device_add(i);
+        Ok(None)
+    }
+    fn scene (arranger: &mut Arrangement, scene: SceneCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn scene_add (arranger: &mut Arrangement) -> Perhaps<Self> {
+        let index = arranger.scene_add(None, None)?.0;
+        arranger.selected = match arranger.selected {
+            Selection::Scene(_) =>
+                Selection::Scene(index),
+            Selection::TrackClip { track, scene } =>
+                Selection::TrackClip { track, scene: index },
+            _ => arranger.selected
+        };
+        Ok(None) // TODO
+    }
+    fn scene_swap (arranger: &mut Arrangement, index: usize, other: usize) -> Perhaps<Self> {
+        todo!();
+        Ok(Some(Self::SceneSwap { index, other }))
+    }
+    fn scene_delete (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
+        let scenes = arranger.scenes_mut();
+        Ok(if scenes.get(index).is_some() {
+            Some(scenes.remove(index))
+        } else {
+            None
+        })
+    }
+    fn scene_launch (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
+        for track in 0..arranger.tracks.len() {
+            let clip = arranger.scenes[index].clips[track].as_ref();
+            arranger.tracks[track].sequencer.enqueue_next(clip);
+        }
+    }
+    fn clip (arranger: &mut Arrangement, scene: ClipCommand) -> Perhaps<Self> {
+        todo!("delegate")
+    }
+    fn clip_get (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
+        //(Get      [a: usize, b: usize]          cmd_todo!("\n\rtodo: clip: get: {a} {b}"))
+            //("get"     [a: usize, b: usize] Some(Self::Get(a.unwrap(), b.unwrap())))
+        todo!()
+    }
+    fn clip_put (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
+        //(Put      [t: usize, s: usize, c: MaybeClip]
+            //Some(Self::Put(t, s, arranger.clip_put(t, s, c))))
+            //("put"     [a: usize, b: usize, c: MaybeClip] Some(Self::Put(a.unwrap(), b.unwrap(), c.unwrap())))
+        todo!()
+    }
+    fn clip_del (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
+        //("delete"  [a: usize, b: usize] Some(Self::Put(a.unwrap(), b.unwrap(), None))))
+        todo!()
+    }
+    fn clip_enqueue (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
+        //(Enqueue  [t: usize, s: usize]
+            //cmd!(arranger.tracks[t].sequencer.enqueue_next(arranger.scenes[s].clips[t].as_ref())))
+            //("enqueue" [a: usize, b: usize] Some(Self::Enqueue(a.unwrap(), b.unwrap())))
+        todo!()
+    }
+    fn clip_edit (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
+        //(Edit     [clip: MaybeClip]             cmd_todo!("\n\rtodo: clip: edit: {clip:?}"))
+            //("edit"    [a: MaybeClip] Some(Self::Edit(a.unwrap())))
+        todo!()
+    }
+
+}
+
+#[tengri_proc::command(MidiClip)]
+impl ClipCommand {
+    fn set_color (clip: &mut MidiClip, color: Option<ItemTheme>) -> Perhaps<Self> {
+        //(SetColor [t: usize, s: usize, c: ItemTheme]
+            //clip.clip_set_color(t, s, c).map(|o|Self::SetColor(t, s, o)))));
+            //("color"   [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemTheme::random())))
+        todo!()
+    }
+    fn set_loop (clip: &mut MidiClip, looping: Option<bool>) -> Perhaps<Self> {
+        //(SetLoop  [t: usize, s: usize, l: bool] cmd_todo!("\n\rtodo: {self:?}"))
+            //("loop"    [a: usize, b: usize, c: bool] Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
+        todo!()
+    }
+}
+
+#[tengri_proc::command(Device)]
+impl DeviceCommand {
+}
+
+#[tengri_proc::command(JackMidiIn)]
+impl InputCommand {
+}
+
+#[tengri_proc::command(JackMidiOut)]
+impl OutputCommand {
+}
+
+#[tengri_proc::command(Scene)]
+impl SceneCommand {
+    fn set_name (scene: &mut Scene, mut name: Arc<str>) -> Perhaps<Self> {
+        std::mem::swap(&mut scene.name, &mut name);
+        Ok(Some(Self::SetName { name }))
+    }
+    fn set_color (scene: &mut Scene, mut color: ItemTheme) -> Perhaps<Self> {
+        std::mem::swap(&mut scene.color, &mut color);
+        Ok(Some(Self::SetColor { color }))
+    }
+    fn set_size (scene: &mut Scene, size: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_zoom (scene: &mut Scene, zoom: usize) -> Perhaps<Self> {
+        todo!()
+    }
+}
+
+#[tengri_proc::command(Track)]
+impl TrackCommand {
+    fn set_name (track: &mut Track, mut name: Arc<str>) -> Perhaps<Self> {
+        std::mem::swap(&mut name, &mut track.name);
+        Ok(Some(Self::SetName { name }))
+    }
+    fn set_color (track: &mut Track, color: ItemTheme) -> Perhaps<Self> {
+        std::mem::swap(color, track.color);
+        Ok(Some(Self::SetColor { color }))
+    }
+    fn set_mute (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_solo (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_rec (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        let current = track.sequencer.recording;
+        let value = value.unwrap_or(!current);
+        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
+    }
+    fn set_mon (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
+        let current = track.sequencer.monitoring;
+        let value = value.unwrap_or(!current);
+        Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
+    }
+    fn set_size (track: &mut Track, size: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn set_zoom (track: &mut Track, zoom: usize) -> Perhaps<Self> {
+        todo!()
+    }
+    fn stop (track: &mut Track) -> Perhaps<Self> {
+        track.sequencer.enqueue_next(None);
+        Ok(None)
+    }
+}