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

last small wave of 15 errors?

Browse source
This commit is contained in:
🪞👃🪞 2025-05-14 17:15:27 +03:00
parent 4fe51b5267
commit 872c2d94d6
11 changed files with 181 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

81
crates/device/src/arranger/arranger_api.rs
View file

@ -6,27 +6,28 @@ impl Arrangement {
fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
fn _todo_opt_selection_ (&self) -> Option<Selection> { todo!() }
fn select_nothing (&self) -> Selection {
Selection::Nothing
}
}
#[tengri_proc::command(Arrangement)]
impl ArrangementCommand {
/// Set the selection
fn select (arranger: &mut Arrangement, s: Option<Selection>) -> Perhaps<Self> {
arranger.selected = s;
fn select (arranger: &mut Arrangement, s: Selection) -> Perhaps<Self> {
*arranger.selection_mut() = s;
Ok(None)
}
/// Launch a clip or scene
fn launch (arranger: &mut Arrangement) -> Perhaps<Self> {
use Selection::*;
match arranger.selected {
Some(Track(t)) => {
match *arranger.selection() {
Selection::Track(t) => {
arranger.tracks[t].sequencer.enqueue_next(None)
},
Some(TrackClip { track, scene }) => {
Selection::TrackClip { track, scene } => {
arranger.tracks[track].sequencer.enqueue_next(arranger.scenes[scene].clips[track].as_ref())
},
Some(Scene(s)) => {
Selection::Scene(s) => {
for t in 0..arranger.tracks.len() {
arranger.tracks[t].sequencer.enqueue_next(arranger.scenes[s].clips[t].as_ref())
}
@ -37,49 +38,44 @@ impl ArrangementCommand {
}
/// Set the color of the selected entity
fn set_color (arranger: &mut Arrangement, palette: Option<ItemTheme>) -> Perhaps<Self> {
use Selection::*;
let palette = palette.unwrap_or_else(||ItemTheme::random());
Ok(Some(Self::SetColor { palette: match arranger.selected {
Some(Mix) => {
let old = arranger.color;
arranger.color = palette;
Some(old)
let mut palette = palette.unwrap_or_else(||ItemTheme::random());
let selection = *arranger.selection();
Ok(Some(Self::SetColor { palette: Some(match selection {
Selection::Mix => {
std::mem::swap(&mut palette, &mut arranger.color);
palette
},
Some(Scene(s)) => {
let old = arranger.scenes[s].color;
arranger.scenes[s].color = palette;
Some(old)
Selection::Scene(s) => {
std::mem::swap(&mut palette, &mut arranger.scenes[s].color);
palette
}
Some(Track(t)) => {
let old = arranger.tracks[t].color;
arranger.tracks[t].color = palette;
Some(old)
Selection::Track(t) => {
std::mem::swap(&mut palette, &mut arranger.tracks[t].color);
palette
}
Some(TrackClip { track, scene }) => {
Selection::TrackClip { track, scene } => {
if let Some(ref clip) = arranger.scenes[scene].clips[track] {
let mut clip = clip.write().unwrap();
let old = clip.color;
clip.color = palette;
Some(old)
std::mem::swap(&mut palette, &mut clip.color);
palette
} else {
None
return Ok(None)
}
},
_ => todo!()
} }))
}) }))
}
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(_)) =>
Some(Selection::Track(index)),
Some(Selection::TrackClip { track, scene }) =>
Some(Selection::TrackClip { track: index, scene }),
_ => arranger.selected
*arranger.selection_mut() = match arranger.selection() {
Selection::Track(_) => Selection::Track(index),
Selection::TrackClip { track, scene } => Selection::TrackClip {
track: index, scene: *scene
},
_ => *arranger.selection()
};
Ok(Some(Self::TrackDelete { index }))
}
@ -135,12 +131,13 @@ impl ArrangementCommand {
}
fn scene_add (arranger: &mut Arrangement) -> Perhaps<Self> {
let index = arranger.scene_add(None, None)?.0;
arranger.selected = match arranger.selected {
Some(Selection::Scene(_)) =>
Some(Selection::Scene(index)),
Some(Selection::TrackClip { track, scene }) =>
Some(Selection::TrackClip { track, scene: index }),
_ => arranger.selected
*arranger.selection_mut() = match arranger.selection() {
Selection::Scene(_) => Selection::Scene(index),
Selection::TrackClip { track, scene } => Selection::TrackClip {
track: *track,
scene: index
},
_ => *arranger.selection()
};
Ok(None) // TODO
}

38
crates/device/src/arranger/arranger_model.rs
View file

@ -33,7 +33,7 @@ pub struct Arrangement {
/// Scroll offset of scenes
pub scene_scroll: usize,
/// Selected UI element
pub selected: Option<Selection>,
pub selection: Selection,
/// Contains a render of the project arrangement, redrawn on update.
/// TODO rename to "render_cache" or smth
pub arranger: Arc<RwLock<Buffer>>,
@ -43,13 +43,13 @@ pub struct Arrangement {
pub pool: Pool,
}
has!(Option<Selection>: |self: Arrangement|self.selected);
has!(Vec<JackMidiIn>: |self: Arrangement|self.midi_ins);
has!(Vec<JackMidiOut>: |self: Arrangement|self.midi_outs);
has!(Vec<Scene>: |self: Arrangement|self.scenes);
has!(Vec<Track>: |self: Arrangement|self.tracks);
has!(Jack: |self: Arrangement|self.jack);
has!(Clock: |self: Arrangement|self.clock);
has!(Jack: |self: Arrangement|self.jack);
has!(Clock: |self: Arrangement|self.clock);
has!(Selection: |self: Arrangement|self.selection);
has!(Vec<JackMidiIn>: |self: Arrangement|self.midi_ins);
has!(Vec<JackMidiOut>: |self: Arrangement|self.midi_outs);
has!(Vec<Scene>: |self: Arrangement|self.scenes);
has!(Vec<Track>: |self: Arrangement|self.tracks);
impl Arrangement {
/// Width of display
@ -62,7 +62,7 @@ impl Arrangement {
}
/// Width taken by all tracks.
pub fn w_tracks (&self) -> u16 {
self.tracks_with_sizes(&self.selected, None).last()
self.tracks_with_sizes(&self.selection(), None).last()
.map(|(_, _, _, x)|x as u16).unwrap_or(0)
}
/// Width available to display tracks.
@ -90,18 +90,12 @@ impl Arrangement {
}
/// Height taken by all scenes.
pub fn h_scenes (&self, is_editing: bool) -> u16 {
let (selected_track, selected_scene) = match Has::<Option<Selection>>::get(self) {
Some(Selection::Track(t)) => (Some(*t), None),
Some(Selection::Scene(s)) => (None, Some(*s)),
Some(Selection::TrackClip { track, scene }) => (Some(*track), Some(*scene)),
_ => (None, None)
};
self.scenes_with_sizes(
is_editing,
ArrangerView::H_SCENE,
ArrangerView::H_EDITOR,
selected_track,
selected_scene
self.selection().track(),
self.selection().scene(),
)
.last()
.map(|(_, _, _, y)|y as u16).unwrap_or(0)
@ -121,27 +115,27 @@ impl Arrangement {
}
/// Get the active track
fn get_track (&self) -> Option<&Track> {
let index = self.selection()?.track()?;
let index = self.selection().track()?;
Has::<Vec<Track>>::get(self).get(index)
}
/// Get a mutable reference to the active track
fn get_track_mut (&mut self) -> Option<&mut Track> {
let index = self.selection()?.track()?;
let index = self.selection().track()?;
Has::<Vec<Track>>::get_mut(self).get_mut(index)
}
/// Get the active scene
fn get_scene (&self) -> Option<&Scene> {
let index = self.selection()?.scene()?;
let index = self.selection().scene()?;
Has::<Vec<Scene>>::get(self).get(index)
}
/// Get a mutable reference to the active scene
fn get_scene_mut (&mut self) -> Option<&mut Scene> {
let index = self.selection()?.scene()?;
let index = self.selection().scene()?;
Has::<Vec<Scene>>::get_mut(self).get_mut(index)
}
/// Get the active clip
fn get_clip (&self) -> Option<Arc<RwLock<MidiClip>>> {
self.get_scene()?.clips.get(self.selection()?.track()?)?.clone()
self.get_scene()?.clips.get(self.selection().track()?)?.clone()
}
/// Put a clip in a slot
pub fn clip_put (

13
crates/device/src/arranger/arranger_select.rs
View file

@ -1,19 +1,16 @@
use crate::*;
impl<T: Has<Option<Selection>>> HasSelection for T {}
impl<T: Has<Selection>> HasSelection for T {}
pub trait HasSelection: Has<Option<Selection>> {
fn selection (&self) -> Option<&Selection> {
self.get().as_ref()
pub trait HasSelection: Has<Selection> {
fn selection (&self) -> &Selection {
self.get()
}
fn selection_mut (&mut self) -> &mut Option<Selection> {
fn selection_mut (&mut self) -> &mut Selection {
self.get_mut()
}
}
impl Arrangement {
}
/// Represents the current user selection in the arranger
#[derive(PartialEq, Clone, Copy, Debug, Default)]
pub enum Selection {

22
crates/device/src/arranger/arranger_track.rs
View file

@ -149,13 +149,27 @@ impl Track {
}
}
impl<T: Has<Option<Track>> + Send + Sync> HasTrack for T {}
pub trait HasTrack {
fn track (&self) -> Option<&Track>;
fn track_mut (&mut self) -> Option<&mut Track>;
}
pub trait HasTrack: Has<Option<Track>> + Send + Sync {
//impl<T: Has<Option<Track>>> HasTrack for T {
//fn track (&self) -> Option<&Track> {
//self.get().as_ref()
//}
//fn track_mut (&mut self) -> Option<&mut Track> {
//self.get_mut().as_mut()
//}
//}
impl<T: Has<Vec<Track>> + Has<Selection>> HasTrack for T {
fn track (&self) -> Option<&Track> {
Has::<Option<Track>>::get(self).as_ref()
let index = Has::<Selection>::get(self).track()?;
Has::<Vec<Track>>::get(self).get(index)
}
fn track_mut (&mut self) -> Option<&mut Track> {
Has::<Option<Track>>::get_mut(self).as_mut()
let index = Has::<Selection>::get(self).track()?;
Has::<Vec<Track>>::get_mut(self).get_mut(index)
}
}

9
crates/device/src/arranger/arranger_tracks.rs
View file

@ -47,11 +47,11 @@ pub trait HasTracks: Has<Vec<Track>> + Send + Sync {
/// Iterate over tracks with their corresponding sizes.
fn tracks_with_sizes (
&self,
selection: &Option<Selection>,
selection: &Selection,
editor_width: Option<usize>
) -> impl TracksSizes<'_> {
let mut x = 0;
let active_track = if let Some(width) = editor_width && let Some(selection) = selection {
let active_track = if let Some(width) = editor_width {
selection.track()
} else {
None
@ -74,7 +74,10 @@ impl<'a> ArrangerView<'a> {
-> impl TracksSizes<'a>
{
self.arrangement
.tracks_with_sizes(&self.arrangement.selected, self.is_editing.then_some(20/*FIXME*/))
.tracks_with_sizes(
&self.arrangement.selection(),
self.is_editing.then_some(20/*FIXME*/)
)
.map_while(move|(t, track, x1, x2)|{
(self.width_mid > x2 as u16).then_some((t, track, x1, x2))
})

11
crates/device/src/arranger/arranger_view.rs
View file

@ -35,7 +35,6 @@ impl<'a> ArrangerView<'a> {
editor: Option<&'a MidiEditor>
) -> Self {
let is_editing = editor.is_some();
let selected = arrangement.selected;
let h_tracks_area = arrangement.h_tracks_area();
let h_scenes_area = arrangement.h_scenes_area();
let h_scenes = arrangement.h_scenes(is_editing);
@ -54,7 +53,7 @@ impl<'a> ArrangerView<'a> {
outputs_count: arrangement.midi_outs.len(),
scenes_height: h_scenes_area,
scene_selected: selected.map(|s|s.scene()).flatten(),
scene_selected: arrangement.selection().scene(),
scene_count: arrangement.scenes.len(),
scene_last: arrangement.scenes.len().saturating_sub(1),
scene_scroll: Fill::y(Fixed::x(1, ScrollbarV {
@ -65,7 +64,7 @@ impl<'a> ArrangerView<'a> {
tracks_height: h_tracks_area,
track_count: arrangement.tracks.len(),
track_selected: selected.map(|s|s.track()).flatten(),
track_selected: arrangement.selection().track(),
track_scroll: Fill::x(Fixed::y(1, ScrollbarH {
offset: arrangement.track_scroll,
length: h_tracks_area as usize,
@ -160,9 +159,9 @@ impl<'a> ArrangerView<'a> {
track_selected, is_editing, ..
} = self;
let selection = Has::<Option<Selection>>::get(self.arrangement);
let selected_track = selection.map(|s|s.track()).flatten();
let selected_scene = selection.map(|s|s.scene()).flatten();
let selection = Has::<Selection>::get(self.arrangement);
let selected_track = selection.track();
let selected_scene = selection.scene();
Tryptich::center(*scenes_height)
.left(*width_side, Map::new(

2
crates/device/src/browser/browser_model.rs
View file

@ -3,7 +3,7 @@ use std::path::PathBuf;
use std::ffi::OsString;
/// Browses for phrase to import/export
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Default)]
pub struct Browser {
pub cwd: PathBuf,
pub dirs: Vec<(OsString, String)>,