unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 11:46:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor and cleanup (move impls)

Browse source
This commit is contained in:
🪞👃🪞 2024-07-11 16:13:54 +03:00
parent c2d6f22e46
commit db25099268
4 changed files with 111 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

217
src/model.rs
View file

@ -116,11 +116,10 @@ impl App {
})
}
}
process!(App |self, _client, scope| {
let (
reset, current_frames, current_usecs, next_usecs, period_usecs
) = self.process_update_time(&scope);
) = self.update_time(&scope);
for track in self.tracks.iter_mut() {
track.process(
self.midi_in.as_ref().map(|p|p.iter(&scope)),
@ -138,6 +137,12 @@ process!(App |self, _client, scope| {
Control::Continue
});
impl App {
pub fn client (&self) -> &Client {
self.jack.as_ref().unwrap().client()
}
pub fn audio_out (&self, index: usize) -> Option<Arc<Port<Unowned>>> {
self.audio_outs.get(index).map(|x|x.clone())
}
pub fn with_midi_ins (mut self, names: &[&str]) -> Usually<Self> {
self.midi_ins = names.iter().map(|x|x.to_string()).collect();
Ok(self)
@ -156,35 +161,18 @@ impl App {
.collect();
Ok(self)
}
pub fn connect_to_midi_ins (&mut self, ports: &[&str]) -> Usually<&mut Self> {
let client = self.client();
let midi_in = client.register_port("midi-in", MidiIn)?;
ports
.iter()
.map(|name|client
.ports(Some(name), None, PortFlags::empty())
.iter()
.map(|name|{
if let Some(port) = client.port_by_name(name) {
client.connect_ports(&port, &midi_in)?;
}
Ok(())
})
.collect::<Usually<()>>())
.collect::<Usually<()>>()?;
Ok(self)
}
pub fn activate (mut self, init: Option<impl FnOnce(&Arc<RwLock<Self>>)->Usually<()>>) -> Usually<Arc<RwLock<Self>>> {
let jack = self.jack.take().expect("no jack client");
let app = Arc::new(RwLock::new(self));
app.write().unwrap().jack = Some(jack.activate(&app.clone(), Self::process)?);
if let Some(init) = init { init(&app)?; }
app.write().unwrap().jack = Some(jack.activate(&app.clone(), |state, client, scope|{
state.write().unwrap().process(client, scope)
})?);
if let Some(init) = init {
init(&app)?;
}
Ok(app)
}
pub fn process (state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope) -> Control {
state.write().unwrap().process(client, scope)
}
pub fn process_update_time (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, f64) {
pub fn update_time (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, f64) {
let CycleTimes {
current_frames,
current_usecs,
@ -215,12 +203,6 @@ impl App {
reset, current_frames as usize, current_usecs as usize, next_usecs as usize, period_usecs as f64
)
}
pub fn audio_out (&self, index: usize) -> Option<Arc<Port<Unowned>>> {
self.audio_outs.get(index).map(|x|x.clone())
}
pub fn client (&self) -> &Client {
self.jack.as_ref().unwrap().client()
}
pub fn toggle_play (&mut self) -> Usually<()> {
self.playing = match self.playing.expect("1st frame has not been processed yet") {
TransportState::Stopped => {
@ -235,178 +217,11 @@ impl App {
};
Ok(())
}
pub fn new_track_name (&self) -> String {
format!("Track {}", self.tracks.len() + 1)
}
pub fn add_track (
&mut self,
name: Option<&str>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
self.tracks.push(Track::new(&name, None, None)?);
self.track_cursor = self.tracks.len();
Ok(&mut self.tracks[self.track_cursor - 1])
}
pub fn add_track_with_cb (
&mut self,
name: Option<&str>,
init: impl FnOnce(&Client, &mut Track)->Usually<()>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
let mut track = Track::new(&name, None, None)?;
init(self.client(), &mut track)?;
self.tracks.push(track);
self.track_cursor = self.tracks.len();
Ok(&mut self.tracks[self.track_cursor - 1])
}
pub fn track (&self) -> Option<(usize, &Track)> {
match self.track_cursor { 0 => None, _ => {
let id = self.track_cursor as usize - 1;
self.tracks.get(id).map(|t|(id, t))
} }
}
pub fn track_mut (&mut self) -> Option<(usize, &mut Track)> {
match self.track_cursor { 0 => None, _ => {
let id = self.track_cursor as usize - 1;
self.tracks.get_mut(id).map(|t|(id, t))
} }
}
pub fn new_scene_name (&self) -> String {
format!("Scene {}", self.scenes.len() + 1)
}
pub fn add_scene (&mut self, name: Option<&str>) -> Usually<&mut Scene> {
let name = name.ok_or_else(||self.new_scene_name())?;
self.scenes.push(Scene::new(&name, vec![]));
self.scene_cursor = self.scenes.len();
Ok(&mut self.scenes[self.scene_cursor - 1])
}
pub fn add_scene_with_clips (
&mut self,
name: Option<&str>,
clips: &[Option<usize>]
) -> Usually<&mut Scene> {
let name = name.ok_or_else(||self.new_scene_name())?;
self.scenes.push(Scene::new(&name, Vec::from(clips)));
self.scene_cursor = self.scenes.len();
Ok(&mut self.scenes[self.scene_cursor - 1])
}
pub fn scene (&self) -> Option<(usize, &Scene)> {
match self.scene_cursor { 0 => None, _ => {
let id = self.scene_cursor as usize - 1;
self.scenes.get(id).map(|t|(id, t))
} }
}
pub fn scene_mut (&mut self) -> Option<(usize, &mut Scene)> {
match self.scene_cursor { 0 => None, _ => {
let id = self.scene_cursor as usize - 1;
self.scenes.get_mut(id).map(|t|(id, t))
} }
}
pub fn phrase (&self) -> Option<&Phrase> {
let (track_id, track) = self.track()?;
let (_, scene) = self.scene()?;
track.phrases.get((*scene.clips.get(track_id)?)?)
}
pub fn phrase_mut (&mut self) -> Option<&mut Phrase> {
let (track_id, _) = self.track()?;
let (_, scene) = self.scene()?;
let clip = (*scene.clips.get(track_id)?)?;
self.track_mut()?.1.phrases.get_mut(clip)
}
pub fn phrase_id (&self) -> Option<usize> {
let (track_id, _) = self.track()?;
let (_, scene) = self.scene()?;
*scene.clips.get(track_id)?
}
pub fn selection <'a> (&'a self) -> Selection<'a> {
let track_id = if self.track_cursor == 0 { None } else { Some(self.track_cursor - 1) };
let track = (&track_id).map(|id|self.tracks.get(id)).flatten();
let scene_id = if self.scene_cursor == 0 { None } else { Some(self.scene_cursor - 1) };
let scene = (&scene_id).map(|id|self.scenes.get(id)).flatten();
let phrase_id = if let (Some(scene), Some(id)) = (scene, track_id) {
if let Some(Some(id)) = scene.clips.get(id) {
Some(*id)
} else {
None
}
} else {
None
};
let phrase = if let (Some(id), Some(track)) = (phrase_id, track) {
track.phrases.get(id)
} else {
None
};
Selection {
track_id,
track,
scene_id,
scene,
phrase_id,
phrase
}
}
//pub fn selection_mut <'a> (&'a mut self) -> SelectionMut<'a> {
//let track_id = if self.track_cursor == 0 { None } else { Some(self.track_cursor - 1) };
//let track = (&track_id).map(|id|self.tracks.get_mut(id)).flatten();
//let scene_id = if self.scene_cursor == 0 { None } else { Some(self.scene_cursor - 1) };
//let scene = (&scene_id).map(|id|self.scenes.get_mut(id)).flatten();
//let phrase_id = if let (Some(scene), Some(id)) = (scene, track_id) {
//if let Some(Some(id)) = scene.clips.get_mut(id) {
//Some(*id)
//} else {
//None
//}
//} else {
//None
//};
//let phrase = if let (Some(id), Some(track)) = (phrase_id, track) {
//track.phrases.get_mut(id)
//} else {
//None
//};
//SelectionMut {
//track_id,
//track,
//scene_id,
//scene,
//phrase_id,
//phrase
//}
//}
}
struct Selection<'a> {
pub track_id: Option<usize>,
pub track: Option<&'a Track>,
pub scene_id: Option<usize>,
pub scene: Option<&'a Scene>,
pub phrase_id: Option<usize>,
pub phrase: Option<&'a Phrase>,
}
struct SelectionMut<'a> {
pub track_id: Option<usize>,
pub track: Option<&'a mut Track>,
pub scene_id: Option<usize>,
pub scene: Option<&'a mut Scene>,
pub phrase_id: Option<usize>,
pub phrase: Option<&'a mut Phrase>,
}
#[derive(PartialEq, Clone, Copy)]
pub enum AppSection {
Arranger,
Sequencer,
Chain,
}
impl Default for AppSection {
fn default () -> Self {
Self::Arranger
}
}
pub enum AppSection { Arranger, Sequencer, Chain, }
impl Default for AppSection { fn default () -> Self { Self::Arranger } }
impl AppSection {
pub fn prev (&mut self) {
*self = match self {

21
src/model/phrase.rs
View file

@ -1,4 +1,4 @@
use crate::core::*;
use crate::{core::*, model::App};
/// Define a MIDI phrase.
#[macro_export] macro_rules! phrase {
@ -89,3 +89,22 @@ impl Phrase {
}
}
}
impl App {
pub fn phrase (&self) -> Option<&Phrase> {
let (track_id, track) = self.track()?;
let (_, scene) = self.scene()?;
track.phrases.get((*scene.clips.get(track_id)?)?)
}
pub fn phrase_mut (&mut self) -> Option<&mut Phrase> {
let (track_id, _) = self.track()?;
let (_, scene) = self.scene()?;
let clip = (*scene.clips.get(track_id)?)?;
self.track_mut()?.1.phrases.get_mut(clip)
}
pub fn phrase_id (&self) -> Option<usize> {
let (track_id, _) = self.track()?;
let (_, scene) = self.scene()?;
*scene.clips.get(track_id)?
}
}

36
src/model/scene.rs
View file

@ -1,3 +1,5 @@
use crate::{core::*, model::App};
pub struct Scene {
pub name: String,
pub clips: Vec<Option<usize>>,
@ -11,3 +13,37 @@ impl Scene {
}
}
}
impl App {
pub fn new_scene_name (&self) -> String {
format!("Scene {}", self.scenes.len() + 1)
}
pub fn add_scene (&mut self, name: Option<&str>) -> Usually<&mut Scene> {
let name = name.ok_or_else(||self.new_scene_name())?;
self.scenes.push(Scene::new(&name, vec![]));
self.scene_cursor = self.scenes.len();
Ok(&mut self.scenes[self.scene_cursor - 1])
}
pub fn add_scene_with_clips (
&mut self,
name: Option<&str>,
clips: &[Option<usize>]
) -> Usually<&mut Scene> {
let name = name.ok_or_else(||self.new_scene_name())?;
self.scenes.push(Scene::new(&name, Vec::from(clips)));
self.scene_cursor = self.scenes.len();
Ok(&mut self.scenes[self.scene_cursor - 1])
}
pub fn scene (&self) -> Option<(usize, &Scene)> {
match self.scene_cursor { 0 => None, _ => {
let id = self.scene_cursor as usize - 1;
self.scenes.get(id).map(|t|(id, t))
} }
}
pub fn scene_mut (&mut self) -> Option<(usize, &mut Scene)> {
match self.scene_cursor { 0 => None, _ => {
let id = self.scene_cursor as usize - 1;
self.scenes.get_mut(id).map(|t|(id, t))
} }
}
}

39
src/model/track.rs
View file

@ -239,3 +239,42 @@ impl Track {
}
}
}
impl App {
pub fn new_track_name (&self) -> String {
format!("Track {}", self.tracks.len() + 1)
}
pub fn add_track (
&mut self,
name: Option<&str>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
self.tracks.push(Track::new(&name, None, None)?);
self.track_cursor = self.tracks.len();
Ok(&mut self.tracks[self.track_cursor - 1])
}
pub fn add_track_with_cb (
&mut self,
name: Option<&str>,
init: impl FnOnce(&Client, &mut Track)->Usually<()>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
let mut track = Track::new(&name, None, None)?;
init(self.client(), &mut track)?;
self.tracks.push(track);
self.track_cursor = self.tracks.len();
Ok(&mut self.tracks[self.track_cursor - 1])
}
pub fn track (&self) -> Option<(usize, &Track)> {
match self.track_cursor { 0 => None, _ => {
let id = self.track_cursor as usize - 1;
self.tracks.get(id).map(|t|(id, t))
} }
}
pub fn track_mut (&mut self) -> Option<(usize, &mut Track)> {
match self.track_cursor { 0 => None, _ => {
let id = self.track_cursor as usize - 1;
self.tracks.get_mut(id).map(|t|(id, t))
} }
}
}