mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-07 04:06:45 +01:00
790 lines
30 KiB
Rust
790 lines
30 KiB
Rust
use crate::*;
|
||
|
||
/// Root level object for standalone `tek_arranger`
|
||
pub struct Arranger<E: Engine> {
|
||
/// JACK client handle (needs to not be dropped for standalone mode to work).
|
||
pub jack: Arc<RwLock<JackClient>>,
|
||
/// Which view is focused
|
||
pub focus_cursor: (usize, usize),
|
||
/// Whether the focused view is entered
|
||
pub entered: bool,
|
||
/// Controls the JACK transport.
|
||
pub transport: Option<Arc<RwLock<TransportToolbar<E>>>>,
|
||
/// Global timebase
|
||
pub clock: Arc<TransportTime>,
|
||
/// Contains all the sequencers.
|
||
pub arrangement: Arrangement<E>,
|
||
/// Pool of all phrases in the arrangement
|
||
pub phrases: Arc<RwLock<PhrasePool<E>>>,
|
||
/// Phrase editor view
|
||
pub editor: PhraseEditor<E>,
|
||
/// Status bar
|
||
pub status: ArrangerStatusBar,
|
||
/// Height of arrangement
|
||
pub arrangement_split: u16,
|
||
/// Width of phrase pool
|
||
pub phrases_split: u16,
|
||
/// Width and height of app at last render
|
||
pub size: Measure<E>,
|
||
/// Menu bar
|
||
pub menu: MenuBar<E, Self, ArrangerCommand>,
|
||
}
|
||
/// Sections in the arranger app that may be focused
|
||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||
pub enum ArrangerFocus {
|
||
/// The transport (toolbar) is focused
|
||
Transport,
|
||
/// The arrangement (grid) is focused
|
||
Arrangement,
|
||
/// The phrase list (pool) is focused
|
||
PhrasePool,
|
||
/// The phrase editor (sequencer) is focused
|
||
PhraseEditor,
|
||
}
|
||
/// Status bar for arranger ap
|
||
pub enum ArrangerStatusBar {
|
||
Transport,
|
||
ArrangementMix,
|
||
ArrangementTrack,
|
||
ArrangementScene,
|
||
ArrangementClip,
|
||
PhrasePool,
|
||
PhraseView,
|
||
PhraseEdit,
|
||
}
|
||
/// Represents the tracks and scenes of the composition.
|
||
pub struct Arrangement<E: Engine> {
|
||
/// Global JACK client
|
||
pub jack: Arc<RwLock<JackClient>>,
|
||
/// Global timebase
|
||
pub clock: Arc<TransportTime>,
|
||
/// Name of arranger
|
||
pub name: Arc<RwLock<String>>,
|
||
/// Collection of phrases.
|
||
pub phrases: Arc<RwLock<PhrasePool<E>>>,
|
||
/// Collection of tracks.
|
||
pub tracks: Vec<ArrangementTrack>,
|
||
/// Collection of scenes.
|
||
pub scenes: Vec<Scene>,
|
||
/// Currently selected element.
|
||
pub selected: ArrangementFocus,
|
||
/// Display mode of arranger
|
||
pub mode: ArrangementViewMode,
|
||
/// Whether the arranger is currently focused
|
||
pub focused: bool,
|
||
/// Background color of arrangement
|
||
pub color: ItemColor,
|
||
/// Width and height of arrangement area at last render
|
||
pub size: Measure<E>,
|
||
/// Whether this is currently in edit mode
|
||
pub entered: bool,
|
||
}
|
||
/// Represents a track in the arrangement
|
||
pub struct ArrangementTrack {
|
||
/// Name of track
|
||
pub name: Arc<RwLock<String>>,
|
||
/// Preferred width of track column
|
||
pub width: usize,
|
||
/// Identifying color of track
|
||
pub color: ItemColor,
|
||
/// MIDI player/recorder
|
||
pub player: PhrasePlayer,
|
||
}
|
||
#[derive(Default, Debug)]
|
||
pub struct Scene {
|
||
/// Name of scene
|
||
pub name: Arc<RwLock<String>>,
|
||
/// Clips in scene, one per track
|
||
pub clips: Vec<Option<Arc<RwLock<Phrase>>>>,
|
||
/// Identifying color of scene
|
||
pub color: ItemColor,
|
||
}
|
||
#[derive(PartialEq, Clone, Copy)]
|
||
/// Represents the current user selection in the arranger
|
||
pub enum ArrangementFocus {
|
||
/// The whole mix is selected
|
||
Mix,
|
||
/// A track is selected.
|
||
Track(usize),
|
||
/// A scene is selected.
|
||
Scene(usize),
|
||
/// A clip (track × scene) is selected.
|
||
Clip(usize, usize),
|
||
}
|
||
/// Display mode of arranger
|
||
#[derive(PartialEq)]
|
||
pub enum ArrangementViewMode {
|
||
/// Tracks are rows
|
||
Horizontal,
|
||
/// Tracks are columns
|
||
Vertical(usize),
|
||
}
|
||
/// Arrangement, rendered vertically (session/grid mode).
|
||
pub struct VerticalArranger<'a, E: Engine>(pub &'a Arrangement<E>, pub usize);
|
||
/// Arrangement, rendered horizontally (arrangement/track mode).
|
||
pub struct HorizontalArranger<'a, E: Engine>(pub &'a Arrangement<E>);
|
||
/// General methods for arranger
|
||
impl<E: Engine> Arranger<E> {
|
||
pub fn new (
|
||
jack: &Arc<RwLock<JackClient>>,
|
||
transport: Option<Arc<RwLock<TransportToolbar<E>>>>,
|
||
arrangement: Arrangement<E>,
|
||
phrases: Arc<RwLock<PhrasePool<E>>>,
|
||
) -> Self {
|
||
let mut app = Self {
|
||
jack: jack.clone(),
|
||
focus_cursor: (0, 1),
|
||
entered: false,
|
||
phrases_split: 20,
|
||
arrangement_split: 15,
|
||
editor: PhraseEditor::new(),
|
||
status: ArrangerStatusBar::ArrangementClip,
|
||
transport: transport.clone(),
|
||
arrangement,
|
||
phrases,
|
||
size: Measure::new(),
|
||
clock: if let Some(ref transport) = transport {
|
||
transport.read().unwrap().clock.clone()
|
||
} else {
|
||
Arc::new(TransportTime::default())
|
||
},
|
||
menu: {
|
||
use ArrangerCommand::*;
|
||
MenuBar::new()
|
||
.add({
|
||
use ArrangementCommand::*;
|
||
Menu::new("File")
|
||
.cmd("n", "New project", Arrangement(New))
|
||
.cmd("l", "Load project", Arrangement(Load))
|
||
.cmd("s", "Save project", Arrangement(Save))
|
||
})
|
||
.add({
|
||
use TransportCommand::*;
|
||
Menu::new("Transport")
|
||
.cmd("p", "Play", Transport(Play))
|
||
.cmd("s", "Play from start", Transport(PlayFromStart))
|
||
.cmd("a", "Pause", Transport(Pause))
|
||
})
|
||
.add({
|
||
use ArrangementCommand::*;
|
||
Menu::new("Track")
|
||
.cmd("a", "Append new", Arrangement(AddTrack))
|
||
.cmd("i", "Insert new", Arrangement(AddTrack))
|
||
.cmd("n", "Rename", Arrangement(AddTrack))
|
||
.cmd("d", "Delete", Arrangement(AddTrack))
|
||
.cmd(">", "Move up", Arrangement(AddTrack))
|
||
.cmd("<", "Move down", Arrangement(AddTrack))
|
||
})
|
||
.add({
|
||
use ArrangementCommand::*;
|
||
Menu::new("Scene")
|
||
.cmd("a", "Append new", Arrangement(AddScene))
|
||
.cmd("i", "Insert new", Arrangement(AddTrack))
|
||
.cmd("n", "Rename", Arrangement(AddTrack))
|
||
.cmd("d", "Delete", Arrangement(AddTrack))
|
||
.cmd(">", "Move up", Arrangement(AddTrack))
|
||
.cmd("<", "Move down", Arrangement(AddTrack))
|
||
})
|
||
.add({
|
||
use PhrasePoolCommand::*;
|
||
use PhraseRenameCommand as Rename;
|
||
use PhraseLengthCommand as Length;
|
||
Menu::new("Phrase")
|
||
.cmd("a", "Append new", Phrases(Append))
|
||
.cmd("i", "Insert new", Phrases(Insert))
|
||
.cmd("n", "Rename", Phrases(Rename(Rename::Begin)))
|
||
.cmd("t", "Set length", Phrases(Length(Length::Begin)))
|
||
.cmd("d", "Delete", Phrases(Delete))
|
||
.cmd("l", "Load from MIDI...", Phrases(Import))
|
||
.cmd("s", "Save to MIDI...", Phrases(Export))
|
||
.cmd(">", "Move up", Phrases(MoveUp))
|
||
.cmd("<", "Move down", Phrases(MoveDown))
|
||
})
|
||
}
|
||
};
|
||
app.update_focus();
|
||
app
|
||
}
|
||
/// Toggle global play/pause
|
||
pub fn toggle_play (&mut self) -> Perhaps<bool> {
|
||
match self.transport {
|
||
Some(ref mut transport) => { transport.write().unwrap().toggle_play()?; },
|
||
None => { return Ok(None) }
|
||
}
|
||
Ok(Some(true))
|
||
}
|
||
pub fn next_color (&self) -> ItemColor {
|
||
if let ArrangementFocus::Clip(track, scene) = self.arrangement.selected {
|
||
let track_color = self.arrangement.tracks[track].color;
|
||
let scene_color = self.arrangement.scenes[scene].color;
|
||
track_color.mix(scene_color, 0.5).mix(ItemColor::random(), 0.25)
|
||
} else {
|
||
panic!("could not compute next color")
|
||
}
|
||
}
|
||
/// Focus the editor with the current phrase
|
||
pub fn show_phrase (&mut self) { self.editor.show(self.arrangement.phrase().as_ref()); }
|
||
/// Focus the editor with the current phrase
|
||
pub fn edit_phrase (&mut self) {
|
||
if self.arrangement.selected.is_clip() && self.arrangement.phrase().is_none() {
|
||
self.phrases.write().unwrap().append_new(None, Some(self.next_color().into()));
|
||
self.arrangement.phrase_put();
|
||
}
|
||
self.show_phrase();
|
||
self.focus(ArrangerFocus::PhraseEditor);
|
||
self.editor.entered = true;
|
||
}
|
||
/// Rename the selected track, scene, or clip
|
||
pub fn rename_selected (&mut self) {
|
||
let Arrangement { selected, ref scenes, .. } = self.arrangement;
|
||
match selected {
|
||
ArrangementFocus::Mix => {},
|
||
ArrangementFocus::Track(_) => { todo!("rename track"); },
|
||
ArrangementFocus::Scene(_) => { todo!("rename scene"); },
|
||
ArrangementFocus::Clip(t, s) => if let Some(ref phrase) = scenes[s].clips[t] {
|
||
let index = self.phrases.read().unwrap().index_of(&*phrase.read().unwrap());
|
||
if let Some(index) = index {
|
||
self.focus(ArrangerFocus::PhrasePool);
|
||
self.phrases.write().unwrap().phrase = index;
|
||
self.phrases.write().unwrap().begin_rename();
|
||
}
|
||
},
|
||
}
|
||
}
|
||
/// Update status bar
|
||
pub fn update_status (&mut self) {
|
||
self.status = match self.focused() {
|
||
ArrangerFocus::Transport => ArrangerStatusBar::Transport,
|
||
ArrangerFocus::Arrangement => match self.arrangement.selected {
|
||
ArrangementFocus::Mix => ArrangerStatusBar::ArrangementMix,
|
||
ArrangementFocus::Track(_) => ArrangerStatusBar::ArrangementTrack,
|
||
ArrangementFocus::Scene(_) => ArrangerStatusBar::ArrangementScene,
|
||
ArrangementFocus::Clip(_, _) => ArrangerStatusBar::ArrangementClip,
|
||
},
|
||
ArrangerFocus::PhrasePool => ArrangerStatusBar::PhrasePool,
|
||
ArrangerFocus::PhraseEditor => match self.editor.entered {
|
||
true => ArrangerStatusBar::PhraseEdit,
|
||
false => ArrangerStatusBar::PhraseView,
|
||
},
|
||
}
|
||
}
|
||
}
|
||
/// Focus layout of arranger app
|
||
impl<E: Engine> FocusGrid for Arranger<E> {
|
||
type Item = ArrangerFocus;
|
||
fn cursor (&self) -> (usize, usize) { self.focus_cursor }
|
||
fn cursor_mut (&mut self) -> &mut (usize, usize) { &mut self.focus_cursor }
|
||
fn focus_enter (&mut self) { self.entered = true }
|
||
fn focus_exit (&mut self) { self.entered = false }
|
||
fn entered (&self) -> Option<ArrangerFocus> {
|
||
if self.entered { Some(self.focused()) } else { None }
|
||
}
|
||
fn layout (&self) -> &[&[ArrangerFocus]] {
|
||
use ArrangerFocus::*;
|
||
&[
|
||
&[Transport, Transport],
|
||
&[Arrangement, Arrangement],
|
||
&[PhrasePool, PhraseEditor],
|
||
]
|
||
}
|
||
fn update_focus (&mut self) {
|
||
let focused = self.focused();
|
||
if let Some(transport) = self.transport.as_ref() {
|
||
transport.write().unwrap().focused =
|
||
focused == ArrangerFocus::Transport
|
||
}
|
||
self.arrangement.focused =
|
||
focused == ArrangerFocus::Arrangement;
|
||
self.phrases.write().unwrap().focused =
|
||
focused == ArrangerFocus::PhrasePool;
|
||
self.editor.focused =
|
||
focused == ArrangerFocus::PhraseEditor;
|
||
self.update_status();
|
||
}
|
||
}
|
||
/// General methods for arrangement
|
||
impl<E: Engine> Arrangement<E> {
|
||
pub fn new (
|
||
jack: &Arc<RwLock<JackClient>>,
|
||
clock: &Arc<TransportTime>,
|
||
name: &str,
|
||
phrases: &Arc<RwLock<PhrasePool<E>>>
|
||
) -> Self {
|
||
Self {
|
||
jack: jack.clone(),
|
||
clock: clock.clone(),
|
||
name: Arc::new(RwLock::new(name.into())),
|
||
mode: ArrangementViewMode::Vertical(2),
|
||
selected: ArrangementFocus::Clip(0, 0),
|
||
phrases: phrases.clone(),
|
||
scenes: vec![],
|
||
tracks: vec![],
|
||
focused: false,
|
||
color: Color::Rgb(28, 35, 25).into(),
|
||
size: Measure::new(),
|
||
entered: false,
|
||
}
|
||
}
|
||
fn is_stopped (&self) -> bool {
|
||
*self.clock.playing.read().unwrap() == Some(TransportState::Stopped)
|
||
}
|
||
pub fn activate (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Scene(s) => {
|
||
for (t, track) in self.tracks.iter_mut().enumerate() {
|
||
let player = &mut track.player;
|
||
let clip = self.scenes[s].clips[t].as_ref();
|
||
if player.phrase.is_some() || clip.is_some() {
|
||
player.enqueue_next(clip);
|
||
}
|
||
}
|
||
// TODO make transport available here, so that
|
||
// activating a scene when stopped starts playback
|
||
//if self.is_stopped() {
|
||
//self.transport.toggle_play()
|
||
//}
|
||
},
|
||
ArrangementFocus::Clip(t, s) => {
|
||
self.tracks[t].player.enqueue_next(self.scenes[s].clips[t].as_ref());
|
||
},
|
||
_ => {}
|
||
}
|
||
}
|
||
pub fn delete (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Track(_) => self.track_del(),
|
||
ArrangementFocus::Scene(_) => self.scene_del(),
|
||
ArrangementFocus::Clip(_, _) => self.phrase_del(),
|
||
_ => {}
|
||
}
|
||
}
|
||
pub fn increment (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Track(_) => self.track_width_inc(),
|
||
ArrangementFocus::Scene(_) => self.scene_next(),
|
||
ArrangementFocus::Clip(_, _) => self.phrase_next(),
|
||
ArrangementFocus::Mix => self.zoom_in(),
|
||
}
|
||
}
|
||
pub fn decrement (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Track(_) => self.track_width_dec(),
|
||
ArrangementFocus::Scene(_) => self.scene_prev(),
|
||
ArrangementFocus::Clip(_, _) => self.phrase_prev(),
|
||
ArrangementFocus::Mix => self.zoom_out(),
|
||
}
|
||
}
|
||
pub fn zoom_in (&mut self) {
|
||
if let ArrangementViewMode::Vertical(factor) = self.mode {
|
||
self.mode = ArrangementViewMode::Vertical(factor + 1)
|
||
}
|
||
}
|
||
pub fn zoom_out (&mut self) {
|
||
if let ArrangementViewMode::Vertical(factor) = self.mode {
|
||
self.mode = ArrangementViewMode::Vertical(factor.saturating_sub(1))
|
||
}
|
||
}
|
||
pub fn is_first_row (&self) -> bool {
|
||
let selected = self.selected;
|
||
selected.is_mix() || selected.is_track()
|
||
}
|
||
pub fn is_last_row (&self) -> bool {
|
||
let selected = self.selected;
|
||
(self.scenes.len() == 0 && (selected.is_mix() || selected.is_track())) || match selected {
|
||
ArrangementFocus::Scene(s) => s == self.scenes.len() - 1,
|
||
ArrangementFocus::Clip(_, s) => s == self.scenes.len() - 1,
|
||
_ => false
|
||
}
|
||
}
|
||
pub fn toggle_loop (&mut self) {
|
||
if let Some(phrase) = self.phrase() {
|
||
phrase.write().unwrap().toggle_loop()
|
||
}
|
||
}
|
||
pub fn go_up (&mut self) {
|
||
match self.mode {
|
||
ArrangementViewMode::Horizontal => self.track_prev(),
|
||
_ => self.scene_prev(),
|
||
};
|
||
}
|
||
pub fn go_down (&mut self) {
|
||
match self.mode {
|
||
ArrangementViewMode::Horizontal => self.track_next(),
|
||
_ => self.scene_next(),
|
||
};
|
||
}
|
||
pub fn go_left (&mut self) {
|
||
match self.mode {
|
||
ArrangementViewMode::Horizontal => self.scene_prev(),
|
||
_ => self.track_prev(),
|
||
};
|
||
}
|
||
pub fn go_right (&mut self) {
|
||
match self.mode {
|
||
ArrangementViewMode::Horizontal => self.scene_next(),
|
||
_ => self.track_next(),
|
||
};
|
||
}
|
||
pub fn move_back (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Scene(s) => {
|
||
if s > 0 {
|
||
self.scenes.swap(s, s - 1);
|
||
self.selected = ArrangementFocus::Scene(s - 1);
|
||
}
|
||
},
|
||
ArrangementFocus::Track(t) => {
|
||
if t > 0 {
|
||
self.tracks.swap(t, t - 1);
|
||
self.selected = ArrangementFocus::Track(t - 1);
|
||
// FIXME: also swap clip order in scenes
|
||
}
|
||
},
|
||
_ => todo!("arrangement: move forward")
|
||
}
|
||
}
|
||
pub fn move_forward (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Scene(s) => {
|
||
if s < self.scenes.len().saturating_sub(1) {
|
||
self.scenes.swap(s, s + 1);
|
||
self.selected = ArrangementFocus::Scene(s + 1);
|
||
}
|
||
},
|
||
ArrangementFocus::Track(t) => {
|
||
if t < self.tracks.len().saturating_sub(1) {
|
||
self.tracks.swap(t, t + 1);
|
||
self.selected = ArrangementFocus::Track(t + 1);
|
||
// FIXME: also swap clip order in scenes
|
||
}
|
||
},
|
||
_ => todo!("arrangement: move forward")
|
||
}
|
||
}
|
||
pub fn randomize_color (&mut self) {
|
||
match self.selected {
|
||
ArrangementFocus::Mix => { self.color = ItemColor::random_dark() },
|
||
ArrangementFocus::Track(t) => { self.tracks[t].color = ItemColor::random() },
|
||
ArrangementFocus::Scene(s) => { self.scenes[s].color = ItemColor::random() },
|
||
ArrangementFocus::Clip(t, s) => if let Some(phrase) = &self.scenes[s].clips[t] {
|
||
phrase.write().unwrap().color = ItemColorTriplet::random();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/// Methods for tracks in arrangement
|
||
impl<E: Engine> Arrangement<E> {
|
||
pub fn track (&self) -> Option<&ArrangementTrack> {
|
||
self.selected.track().map(|t|self.tracks.get(t)).flatten()
|
||
}
|
||
pub fn track_mut (&mut self) -> Option<&mut ArrangementTrack> {
|
||
self.selected.track().map(|t|self.tracks.get_mut(t)).flatten()
|
||
}
|
||
pub fn track_width_inc (&mut self) { self.track_mut().map(|t|t.width_inc()); }
|
||
pub fn track_width_dec (&mut self) { self.track_mut().map(|t|t.width_dec()); }
|
||
pub fn track_next (&mut self) { self.selected.track_next(self.tracks.len() - 1) }
|
||
pub fn track_prev (&mut self) { self.selected.track_prev() }
|
||
pub fn track_add (
|
||
&mut self, name: Option<&str>, color: Option<ItemColor>
|
||
) -> Usually<&mut ArrangementTrack> {
|
||
self.tracks.push(name.map_or_else(
|
||
|| ArrangementTrack::new(
|
||
&self.jack, &self.clock, &self.track_default_name(), color
|
||
),
|
||
|name| ArrangementTrack::new(
|
||
&self.jack, &self.clock, name, color
|
||
),
|
||
)?);
|
||
let index = self.tracks.len() - 1;
|
||
Ok(&mut self.tracks[index])
|
||
}
|
||
pub fn track_del (&mut self) {
|
||
if let Some(index) = self.selected.track() {
|
||
self.tracks.remove(index);
|
||
for scene in self.scenes.iter_mut() {
|
||
scene.clips.remove(index);
|
||
}
|
||
}
|
||
}
|
||
pub fn track_default_name (&self) -> String {
|
||
format!("Track {}", self.tracks.len() + 1)
|
||
}
|
||
pub fn track_widths (&self) -> Vec<(usize, usize)> {
|
||
let mut widths = vec![];
|
||
let mut total = 0;
|
||
for track in self.tracks.iter() {
|
||
let width = track.width;
|
||
widths.push((width, total));
|
||
total += width;
|
||
}
|
||
widths.push((0, total));
|
||
widths
|
||
}
|
||
}
|
||
/// Methods for scenes in arrangement
|
||
impl<E: Engine> Arrangement<E> {
|
||
pub fn scene (&self) -> Option<&Scene> {
|
||
self.selected.scene().map(|s|self.scenes.get(s)).flatten()
|
||
}
|
||
pub fn scene_mut (&mut self) -> Option<&mut Scene> {
|
||
self.selected.scene().map(|s|self.scenes.get_mut(s)).flatten()
|
||
}
|
||
pub fn scene_next (&mut self) {
|
||
self.selected.scene_next(self.scenes.len() - 1)
|
||
}
|
||
pub fn scene_prev (&mut self) {
|
||
self.selected.scene_prev()
|
||
}
|
||
pub fn scene_add (
|
||
&mut self, name: Option<&str>, color: Option<ItemColor>
|
||
) -> Usually<&mut Scene> {
|
||
let clips = vec![None;self.tracks.len()];
|
||
let name = name.map(|x|x.to_string()).unwrap_or_else(||self.scene_default_name());
|
||
self.scenes.push(Scene::new(name, clips, color));
|
||
let index = self.scenes.len() - 1;
|
||
Ok(&mut self.scenes[index])
|
||
}
|
||
pub fn scene_del (&mut self) {
|
||
if let Some(index) = self.selected.scene() {
|
||
self.scenes.remove(index);
|
||
}
|
||
}
|
||
pub fn scene_default_name (&self) -> String {
|
||
format!("Scene {}", self.scenes.len() + 1)
|
||
}
|
||
}
|
||
/// Methods for phrases in arrangement
|
||
impl<E: Engine> Arrangement<E> {
|
||
pub fn sequencer (&self) -> Option<&ArrangementTrack> {
|
||
self.selected.track().map(|track|self.tracks.get(track)).flatten()
|
||
}
|
||
pub fn sequencer_mut (&mut self) -> Option<&mut ArrangementTrack> {
|
||
self.selected.track().map(|track|self.tracks.get_mut(track)).flatten()
|
||
}
|
||
pub fn phrase (&self) -> Option<Arc<RwLock<Phrase>>> {
|
||
self.scene()?.clips.get(self.selected.track()?)?.clone()
|
||
}
|
||
pub fn phrase_del (&mut self) {
|
||
let track_index = self.selected.track();
|
||
let scene_index = self.selected.scene();
|
||
track_index
|
||
.and_then(|index|self.tracks.get_mut(index).map(|track|(index, track)))
|
||
.map(|(track_index, _)|scene_index
|
||
.and_then(|index|self.scenes.get_mut(index))
|
||
.map(|scene|scene.clips[track_index] = None));
|
||
}
|
||
pub fn phrase_put (&mut self) {
|
||
if let ArrangementFocus::Clip(track, scene) = self.selected {
|
||
self.scenes[scene].clips[track] = Some(self.phrases.read().unwrap().phrase().clone());
|
||
}
|
||
}
|
||
pub fn phrase_get (&mut self) {
|
||
if let ArrangementFocus::Clip(track, scene) = self.selected {
|
||
if let Some(phrase) = &self.scenes[scene].clips[track] {
|
||
let mut phrases = self.phrases.write().unwrap();
|
||
if let Some(index) = phrases.index_of(&*phrase.read().unwrap()) {
|
||
phrases.phrase = index;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
pub fn phrase_next (&mut self) {
|
||
if let ArrangementFocus::Clip(track, scene) = self.selected {
|
||
if let Some(ref mut phrase) = self.scenes[scene].clips[track] {
|
||
let phrases = self.phrases.read().unwrap();
|
||
let index = phrases.index_of(&*phrase.read().unwrap());
|
||
if let Some(index) = index {
|
||
if index < phrases.phrases.len().saturating_sub(1) {
|
||
*phrase = phrases.phrases[index + 1].clone();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
pub fn phrase_prev (&mut self) {
|
||
if let ArrangementFocus::Clip(track, scene) = self.selected {
|
||
if let Some(ref mut phrase) = self.scenes[scene].clips[track] {
|
||
let phrases = self.phrases.read().unwrap();
|
||
let index = phrases.index_of(&*phrase.read().unwrap());
|
||
if let Some(index) = index {
|
||
if index > 0 {
|
||
*phrase = phrases.phrases[index - 1].clone();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
impl ArrangementTrack {
|
||
pub fn new (
|
||
jack: &Arc<RwLock<JackClient>>,
|
||
clock: &Arc<TransportTime>,
|
||
name: &str,
|
||
color: Option<ItemColor>
|
||
) -> Usually<Self> {
|
||
Ok(Self {
|
||
name: Arc::new(RwLock::new(name.into())),
|
||
width: name.len() + 2,
|
||
color: color.unwrap_or_else(ItemColor::random),
|
||
player: PhrasePlayer::new(&jack, clock, name)?,
|
||
})
|
||
}
|
||
pub fn longest_name (tracks: &[Self]) -> usize {
|
||
tracks.iter().map(|s|s.name.read().unwrap().len()).fold(0, usize::max)
|
||
}
|
||
pub const MIN_WIDTH: usize = 3;
|
||
pub fn width_inc (&mut self) { self.width += 1; }
|
||
pub fn width_dec (&mut self) { if self.width > Self::MIN_WIDTH { self.width -= 1; } }
|
||
}
|
||
/// Focus identification methods
|
||
impl ArrangementFocus {
|
||
pub fn description <E: Engine> (
|
||
&self,
|
||
tracks: &Vec<ArrangementTrack>,
|
||
scenes: &Vec<Scene>,
|
||
) -> String {
|
||
format!("Selected: {}", match self {
|
||
Self::Mix => format!("Everything"),
|
||
Self::Track(t) => match tracks.get(*t) {
|
||
Some(track) => format!("T{t}: {}", &track.name.read().unwrap()),
|
||
None => format!("T??"),
|
||
},
|
||
Self::Scene(s) => match scenes.get(*s) {
|
||
Some(scene) => format!("S{s}: {}", &scene.name.read().unwrap()),
|
||
None => format!("S??"),
|
||
},
|
||
Self::Clip(t, s) => match (tracks.get(*t), scenes.get(*s)) {
|
||
(Some(_), Some(scene)) => match scene.clip(*t) {
|
||
Some(clip) => format!("T{t} S{s} C{}", &clip.read().unwrap().name),
|
||
None => format!("T{t} S{s}: Empty")
|
||
},
|
||
_ => format!("T{t} S{s}: Empty"),
|
||
}
|
||
})
|
||
}
|
||
pub fn is_mix (&self) -> bool { match self { Self::Mix => true, _ => false } }
|
||
pub fn is_track (&self) -> bool { match self { Self::Track(_) => true, _ => false } }
|
||
pub fn is_scene (&self) -> bool { match self { Self::Scene(_) => true, _ => false } }
|
||
pub fn is_clip (&self) -> bool { match self { Self::Clip(_, _) => true, _ => false } }
|
||
pub fn track (&self) -> Option<usize> {
|
||
match self { Self::Clip(t, _) => Some(*t), Self::Track(t) => Some(*t), _ => None }
|
||
}
|
||
pub fn track_next (&mut self, last_track: usize) {
|
||
*self = match self {
|
||
Self::Mix =>
|
||
Self::Track(0),
|
||
Self::Track(t) =>
|
||
Self::Track(last_track.min(*t + 1)),
|
||
Self::Scene(s) =>
|
||
Self::Clip(0, *s),
|
||
Self::Clip(t, s) =>
|
||
Self::Clip(last_track.min(*t + 1), *s),
|
||
}
|
||
}
|
||
pub fn track_prev (&mut self) {
|
||
*self = match self {
|
||
Self::Mix =>
|
||
Self::Mix,
|
||
Self::Scene(s) =>
|
||
Self::Scene(*s),
|
||
Self::Track(t) =>
|
||
if *t == 0 { Self::Mix } else { Self::Track(*t - 1) },
|
||
Self::Clip(t, s) =>
|
||
if *t == 0 { Self::Scene(*s) } else { Self::Clip(t.saturating_sub(1), *s) }
|
||
}
|
||
}
|
||
pub fn scene (&self) -> Option<usize> {
|
||
match self { Self::Clip(_, s) => Some(*s), Self::Scene(s) => Some(*s), _ => None }
|
||
}
|
||
pub fn scene_next (&mut self, last_scene: usize) {
|
||
*self = match self {
|
||
Self::Mix =>
|
||
Self::Scene(0),
|
||
Self::Track(t) =>
|
||
Self::Clip(*t, 0),
|
||
Self::Scene(s) =>
|
||
Self::Scene(last_scene.min(*s + 1)),
|
||
Self::Clip(t, s) =>
|
||
Self::Clip(*t, last_scene.min(*s + 1)),
|
||
}
|
||
}
|
||
pub fn scene_prev (&mut self) {
|
||
*self = match self {
|
||
Self::Mix =>
|
||
Self::Mix,
|
||
Self::Track(t) =>
|
||
Self::Track(*t),
|
||
Self::Scene(s) =>
|
||
if *s == 0 { Self::Mix } else { Self::Scene(*s - 1) },
|
||
Self::Clip(t, s) =>
|
||
if *s == 0 { Self::Track(*t) } else { Self::Clip(*t, s.saturating_sub(1)) }
|
||
}
|
||
}
|
||
}
|
||
/// Arranger display mode can be cycled
|
||
impl ArrangementViewMode {
|
||
/// Cycle arranger display mode
|
||
pub fn to_next (&mut self) {
|
||
*self = match self {
|
||
Self::Horizontal => Self::Vertical(1),
|
||
Self::Vertical(1) => Self::Vertical(2),
|
||
Self::Vertical(2) => Self::Vertical(2),
|
||
Self::Vertical(0) => Self::Horizontal,
|
||
Self::Vertical(_) => Self::Vertical(0),
|
||
}
|
||
}
|
||
}
|
||
impl Scene {
|
||
pub fn new (
|
||
name: impl AsRef<str>,
|
||
clips: impl AsRef<[Option<Arc<RwLock<Phrase>>>]>,
|
||
color: Option<ItemColor>,
|
||
) -> Self {
|
||
Self {
|
||
name: Arc::new(RwLock::new(name.as_ref().into())),
|
||
clips: clips.as_ref().iter().map(|x|x.clone()).collect(),
|
||
color: color.unwrap_or_else(ItemColor::random),
|
||
}
|
||
}
|
||
/// Returns the pulse length of the longest phrase in the scene
|
||
pub fn pulses (&self) -> usize {
|
||
self.clips.iter().fold(0, |a, p|{
|
||
a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
|
||
})
|
||
}
|
||
/// Returns true if all phrases in the scene are currently playing
|
||
pub fn is_playing (&self, tracks: &[ArrangementTrack]) -> bool {
|
||
self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
|
||
.all(|(track_index, clip)|match clip {
|
||
Some(clip) => tracks
|
||
.get(track_index)
|
||
.map(|track|if let Some((_, Some(phrase))) = &track.player.phrase {
|
||
*phrase.read().unwrap() == *clip.read().unwrap()
|
||
} else {
|
||
false
|
||
})
|
||
.unwrap_or(false),
|
||
None => true
|
||
})
|
||
}
|
||
pub fn ppqs (scenes: &[Self], factor: usize) -> Vec<(usize, usize)> {
|
||
let mut total = 0;
|
||
if factor == 0 {
|
||
scenes.iter().map(|scene|{
|
||
let pulses = scene.pulses().max(PPQ);
|
||
total = total + pulses;
|
||
(pulses, total - pulses)
|
||
}).collect()
|
||
} else {
|
||
(0..=scenes.len()).map(|i|{
|
||
(factor*PPQ, factor*PPQ*i)
|
||
}).collect()
|
||
}
|
||
}
|
||
pub fn longest_name (scenes: &[Self]) -> usize {
|
||
scenes.iter().map(|s|s.name.read().unwrap().len()).fold(0, usize::max)
|
||
}
|
||
pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<Phrase>>> {
|
||
match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
|
||
}
|
||
}
|