unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-08 04:36:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

wip: refactor pt.23: 47 errors

Browse source
This commit is contained in:
🪞👃🪞 2024-11-13 19:59:48 +01:00
parent e7e57cea1e
commit ff4698d046
3 changed files with 31 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

21
crates/tek_snd/src/snd_arrange.rs
View file

@ -18,24 +18,3 @@ impl<'a, T: ArrangerModelApi + Send + Sync> Audio for ArrangerRefAudio<'a, T> {
Control::Continue Control::Continue
} }
} }
//pub struct ArrangerAudio(pub Arc<RwLock<ArrangerModel>>);
//impl Audio for ArrangerAudio {
//#[inline] fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
//ArrangerRefAudio(&mut*self.0.write().unwrap()).process(client, scope)
//}
//}
//pub struct ArrangerRefAudio<'a>(pub &'a mut ArrangerModel);
//impl<'a> Audio for ArrangerRefAudio<'a> {
//#[inline] fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
//for track in self.0.tracks.iter_mut() {
//if MIDIPlayerAudio::from(&mut track.player).process(client, scope) == Control::Quit {
//return Control::Quit
//}
//}
//Control::Continue
//}
//}

85
crates/tek_tui/src/tui_arranger.rs
View file

@ -12,35 +12,18 @@ pub type ArrangerApp = AppContainer<
impl TryFrom<&Arc<RwLock<JackClient>>> for ArrangerApp { impl TryFrom<&Arc<RwLock<JackClient>>> for ArrangerApp {
type Error = Box<dyn std::error::Error>; type Error = Box<dyn std::error::Error>;
fn try_from (jack: &Arc<RwLock<JackClient>>) -> Usually<Self> { fn try_from (jack: &Arc<RwLock<JackClient>>) -> Usually<Self> {
let clock = Arc::new(Clock::from(Instant::default())); let model = Arc::new(RwLock::new(ArrangerModel {
name: Arc::new(RwLock::new(String::new())),
let transport = Arc::new(RwLock::new(tek_api::Transport { phrases: vec![],
metronome: false, scenes: vec![],
transport: jack.read().unwrap().transport(), tracks: vec![],
jack: jack.clone(), transport: TransportModel {
clock: clock.clone() metronome: false,
})); transport: jack.read().unwrap().transport(),
clock: Arc::new(Clock::from(Instant::default())),
let phrases = Arc::new(RwLock::new(PhrasePool { phrases: vec![] }));
let model = Arc::new(RwLock::new(Arranger {
arrangement: Arc::new(RwLock::new(ArrangerModel {
jack: jack.clone(), jack: jack.clone(),
clock: clock.clone(), },
name: Arc::new(RwLock::new(String::new())),
phrases: phrases.clone(), // FIXME
tracks: vec![],
scenes: vec![],
})),
sequencer: Arc::new(RwLock::new(SequencerModel {
transport: transport.clone(),
phrases: phrases.clone(),
player: Arc::new(RwLock::new(MIDIPlayer::new(jack, &clock, "preview")?)),
})),
transport: transport.clone(),
phrases: phrases.clone(),
})); }));
Ok(Self::new( Ok(Self::new(
&model, &model,
ArrangerView::from(&model), ArrangerView::from(&model),
@ -51,15 +34,8 @@ impl TryFrom<&Arc<RwLock<JackClient>>> for ArrangerApp {
} }
} }
pub struct Arranger { impl<E: Engine> From<&Arc<RwLock<ArrangerModel>>> for ArrangerView<E> {
pub arrangement: Arc<RwLock<ArrangerModel>>, fn from (model: &Arc<RwLock<ArrangerModel>>) -> Self {
pub sequencer: Arc<RwLock<SequencerModel>>,
pub transport: Arc<RwLock<tek_api::Transport>>,
pub phrases: Arc<RwLock<PhrasePool>>,
}
impl<E: Engine> From<&Arc<RwLock<Arranger>>> for ArrangerView<E> {
fn from (model: &Arc<RwLock<Arranger>>) -> Self {
let mut view = Self { let mut view = Self {
model: model.clone(), model: model.clone(),
sequencer: SequencerView::from(&model.read().unwrap().sequencer), sequencer: SequencerView::from(&model.read().unwrap().sequencer),
@ -78,7 +54,7 @@ impl<E: Engine> From<&Arc<RwLock<Arranger>>> for ArrangerView<E> {
/// Root level object for standalone `tek_arranger` /// Root level object for standalone `tek_arranger`
pub struct ArrangerView<E: Engine> { pub struct ArrangerView<E: Engine> {
pub model: Arc<RwLock<Arranger>>, pub model: ArrangerModel,
/// Sequencer component /// Sequencer component
pub sequencer: SequencerView<E>, pub sequencer: SequencerView<E>,
/// Height of arrangement /// Height of arrangement
@ -124,13 +100,13 @@ impl<E: Engine> Audio for ArrangerView<E> {
#[inline] fn process (&mut self, _: &Client, _: &ProcessScope) -> Control { #[inline] fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
// FIXME: one of these per playing track // FIXME: one of these per playing track
if let ArrangerFocus::Clip(t, s) = self.selected { if let ArrangerFocus::Clip(t, s) = self.selected {
let phrase = self.model.scenes.get(s).map(|scene|scene.clips.get(t)); let phrase = self.model.scenes().get(s).map(|scene|scene.clips.get(t));
if let Some(Some(Some(phrase))) = phrase { if let Some(Some(Some(phrase))) = phrase {
if let Some(track) = self.model.tracks.get(t) { if let Some(track) = self.model.tracks().get(t) {
if let Some((ref started_at, Some(ref playing))) = track.player.phrase { if let Some((ref started_at, Some(ref playing))) = track.player.phrase {
let phrase = phrase.read().unwrap(); let phrase = phrase.read().unwrap();
if *playing.read().unwrap() == *phrase { if *playing.read().unwrap() == *phrase {
let pulse = self.sequencer.transport.model.clock.current.pulse.get(); let pulse = self.sequencer.transport.model.clock().current.pulse.get();
let start = started_at.pulse.get(); let start = started_at.pulse.get();
let now = (pulse - start) % phrase.length as f64; let now = (pulse - start) % phrase.length as f64;
self.sequencer.editor.now.set(now); self.sequencer.editor.now.set(now);
@ -192,17 +168,15 @@ impl<E: Engine> ArrangerView<E> {
/// Focus the editor with the current phrase /// Focus the editor with the current phrase
pub fn show_phrase (&mut self) { pub fn show_phrase (&mut self) {
let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
self.sequencer.editor.show(self.selected_phrase().as_ref()); self.sequencer.editor.show(self.selected_phrase().as_ref());
} }
pub fn activate (&mut self) { pub fn activate (&mut self) {
let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
match self.selected { match self.selected {
ArrangerFocus::Scene(s) => { ArrangerFocus::Scene(s) => {
for (t, track) in self.model.tracks.iter_mut().enumerate() { for (t, track) in self.model.tracks_mut().iter_mut().enumerate() {
let player = &mut track.player; let player = &mut track.player;
let clip = self.model.scenes[s].clips[t].as_ref(); let clip = self.model.scenes()[s].clips[t].as_ref();
if player.phrase.is_some() || clip.is_some() { if player.phrase.is_some() || clip.is_some() {
player.enqueue_next(clip); player.enqueue_next(clip);
} }
@ -214,25 +188,23 @@ impl<E: Engine> ArrangerView<E> {
//} //}
}, },
ArrangerFocus::Clip(t, s) => { ArrangerFocus::Clip(t, s) => {
let clip = self.model.scenes[s].clips[t].as_ref(); let clip = self.model.scenes()[s].clips[t].as_ref();
self.model.tracks[t].player.enqueue_next(clip); self.model.tracks_mut()[t].player.enqueue_next(clip);
}, },
_ => {} _ => {}
} }
} }
pub fn is_first_row (&self) -> bool { pub fn is_first_row (&self) -> bool {
let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
let selected = self.selected; let selected = self.selected;
selected.is_mix() || selected.is_track() selected.is_mix() || selected.is_track()
} }
pub fn is_last_row (&self) -> bool { pub fn is_last_row (&self) -> bool {
let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
let selected = self.selected; let selected = self.selected;
(self.model.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected { (self.model.scenes().len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
ArrangerFocus::Scene(s) => s == self.model.scenes.len() - 1, ArrangerFocus::Scene(s) => s == self.model.scenes().len() - 1,
ArrangerFocus::Clip(_, s) => s == self.model.scenes.len() - 1, ArrangerFocus::Clip(_, s) => s == self.model.scenes().len() - 1,
_ => false _ => false
} }
} }
@ -244,29 +216,28 @@ impl<E: Engine> ArrangerView<E> {
} }
pub fn randomize_color (&mut self) { pub fn randomize_color (&mut self) {
let arrangement = self.model.read().unwrap().arrangement.read().unwrap();
match self.selected { match self.selected {
ArrangerFocus::Mix => { ArrangerFocus::Mix => {
self.color = ItemColor::random_dark() self.color = ItemColor::random_dark()
}, },
ArrangerFocus::Track(t) => { ArrangerFocus::Track(t) => {
self.model.tracks[t].color = ItemColor::random() self.model.tracks_mu()[t].color = ItemColor::random()
}, },
ArrangerFocus::Scene(s) => { ArrangerFocus::Scene(s) => {
self.model.scenes[s].color = ItemColor::random() self.model.scenes_mut()[s].color = ItemColor::random()
}, },
ArrangerFocus::Clip(t, s) => { ArrangerFocus::Clip(t, s) => {
if let Some(phrase) = &self.model.scenes[s].clips[t] { if let Some(phrase) = &self.model.scenes_mut()[s].clips[t] {
phrase.write().unwrap().color = ItemColorTriplet::random(); phrase.write().unwrap().color = ItemColorTriplet::random();
} }
} }
} }
} }
pub fn selected_scene (&self) -> Option<&ArrangerScene> { pub fn selected_scene (&self) -> Option<&ArrangerScene> {
self.selected.scene().map(|s|self.model.scenes.get(s)).flatten() self.selected.scene().map(|s|self.model.scenes().get(s)).flatten()
} }
pub fn selected_scene_mut (&mut self) -> Option<&mut ArrangerScene> { pub fn selected_scene_mut (&mut self) -> Option<&mut ArrangerScene> {
self.selected.scene().map(|s|self.model.scenes.get_mut(s)).flatten() self.selected.scene().map(|s|self.model.scenes_mut().get_mut(s)).flatten()
} }
pub fn selected_phrase (&self) -> Option<Arc<RwLock<Phrase>>> { pub fn selected_phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
self.selected_scene()?.clips.get(self.selected.track()?)?.clone() self.selected_scene()?.clips.get(self.selected.track()?)?.clone()

8
crates/tek_tui/src/tui_transport.rs
View file

@ -1,5 +1,4 @@
use crate::*; use crate::*;
use tek_api::Transport;
pub type TransportApp = AppContainer< pub type TransportApp = AppContainer<
Tui, Tui,
@ -13,13 +12,12 @@ pub type TransportApp = AppContainer<
impl TryFrom<&Arc<RwLock<JackClient>>> for TransportApp { impl TryFrom<&Arc<RwLock<JackClient>>> for TransportApp {
type Error = Box<dyn std::error::Error>; type Error = Box<dyn std::error::Error>;
fn try_from (jack: &Arc<RwLock<JackClient>>) -> Usually<Self> { fn try_from (jack: &Arc<RwLock<JackClient>>) -> Usually<Self> {
let model = Arc::new(RwLock::new(Transport { let model = Arc::new(RwLock::new(TransportModel {
metronome: false, metronome: false,
transport: jack.read().unwrap().transport(), transport: jack.read().unwrap().transport(),
jack: jack.clone(), jack: jack.clone(),
clock: Arc::new(Clock::from(Instant::default())) clock: Arc::new(Clock::from(Instant::default()))
})); }));
Ok(Self::new( Ok(Self::new(
&model, &model,
TransportView::from(&model), TransportView::from(&model),
@ -33,8 +31,8 @@ impl TryFrom<&Arc<RwLock<JackClient>>> for TransportApp {
/// Stores and displays time-related info. /// Stores and displays time-related info.
#[derive(Debug)] #[derive(Debug)]
pub struct TransportView<E: Engine> { pub struct TransportView<E: Engine> {
_engine: PhantomData<E>, _engine: PhantomData<E>,
pub model: Arc<RwLock<Transport>>, pub model: TransportModel,
pub focus: TransportViewFocus, pub focus: TransportViewFocus,
pub focused: bool, pub focused: bool,
pub size: Measure<E>, pub size: Measure<E>,