mirror of
https://codeberg.org/unspeaker/tek.git
synced 2026-10-08 18:56:42 +02:00
1797 lines
62 KiB
Rust
1797 lines
62 KiB
Rust
#![allow(clippy::unit_arg)]
|
||
|
||
pub use self::deps::*; mod deps;
|
||
|
||
/// Command-line entrypoint.
|
||
#[allow(unused)]
|
||
#[hotpath::main]
|
||
fn main () -> Usually<()> {
|
||
tengri::Tui::setup_panic();
|
||
#[cfg(not(feature = "cli"))]
|
||
let outcome = Watch::run_watched(main_plain, None);
|
||
#[cfg(feature = "cli")]
|
||
let outcome = Watch::run_watched(main_cli, None);
|
||
if let Err(e) = outcome {
|
||
println!("{e:#?}");
|
||
std::process::exit(1);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Start with empty project.
|
||
#[cfg(not(feature = "cli"))]
|
||
fn main_plain (config: Arc<Watch>) -> Usually<()> {
|
||
let name = "tek";
|
||
tengri::Tui::run_main(Jack::new_run(name, move|jack|{
|
||
let mode = "Menu";
|
||
let title = "untitled!";
|
||
let bpm = 74.;
|
||
let clock = Clock::new(&jack, Some(bpm))?;
|
||
let tracks = [];
|
||
let scenes = [];
|
||
let project = Project::create(
|
||
&jack,
|
||
title.into(),
|
||
clock,
|
||
tracks.into_iter(),
|
||
scenes.into_iter(),
|
||
connect_midi_ins(&jack, &"M", &[], None)?.into_iter(),
|
||
connect_midi_outs(&jack, &"M", &[], None)?.into_iter(),
|
||
[].into_iter().chain(connect_audio_ins(&jack, &"L", &[], None)?.into_iter())
|
||
.chain(connect_audio_ins(&jack, &"R", &[], None)?.into_iter()),
|
||
[].into_iter().chain(connect_audio_outs(&jack, &"L", &[], None)?.into_iter())
|
||
.chain(connect_audio_outs(&jack, &"R", &[], None)?.into_iter()),
|
||
);
|
||
let mut app = App::new(None, project, config, mode);
|
||
app.dialog = Dialog::welcome();
|
||
Ok(app)
|
||
})?)
|
||
}
|
||
|
||
/// Total application state.
|
||
///
|
||
/// ```
|
||
/// # use tek::*;
|
||
/// let mut app = App::default();
|
||
/// let _ = app.scenes_add_one(None, None).unwrap();
|
||
/// let _ = app.update_clock();
|
||
/// app.project.editor = Some(Default::default());
|
||
/// //let _: Vec<_> = app.project.inputs_with_sizes().collect();
|
||
/// //let _: Vec<_> = app.project.outputs_with_sizes().collect();
|
||
/// let _: Vec<_> = app.project.tracks_with_sizes().collect();
|
||
/// //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
|
||
/// //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
|
||
/// //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
|
||
/// let _ = app.project.w();
|
||
/// //let _ = app.project.w_sidebar();
|
||
/// //let _ = app.project.w_tracks_area();
|
||
/// let _ = app.project.h();
|
||
/// //let _ = app.project.h_tracks_area();
|
||
/// //let _ = app.project.h_inputs();
|
||
/// //let _ = app.project.h_outputs();
|
||
/// let _ = app.project.h_scenes();
|
||
/// ```
|
||
#[derive(Default, Debug)]
|
||
#[namespace(Arc<[Connect]> tek_arc_array_connect)]
|
||
#[namespace(Arc<str> tek_arc_str)]
|
||
#[namespace(Color tek_color)]
|
||
#[namespace(Option<Arc<[Connect]>> tek_opt_arc_array_connect)]
|
||
#[namespace(Option<Arc<str>> tek_opt_arc_str)]
|
||
#[namespace(Option<ItemTheme> tek_opt_itemtheme)]
|
||
#[namespace(Option<bool> tek_opt_bool)]
|
||
#[namespace(Option<u16> tek_opt_u16)]
|
||
#[namespace(Option<u32> tek_opt_u32)]
|
||
#[namespace(Option<usize> tek_opt_usize)]
|
||
#[namespace(PathBuf tek_path_buf)]
|
||
#[namespace(Vec<Arc<str>> tek_vec_arc_str)]
|
||
#[namespace(bool tek_bool)]
|
||
#[namespace(f64 tek_f64)]
|
||
#[namespace(u16 tek_u16)]
|
||
#[namespace(usize tek_usize)]
|
||
#[namespace(ControlAxis ControlAxis::eval)]
|
||
#[namespace(Dialog Dialog::eval)]
|
||
#[namespace(ClipSlot ClipSlot::eval)]
|
||
#[namespace(ClipPool ClipPool::eval)]
|
||
#[namespace(SampleSlot SampleSlot::eval)]
|
||
#[namespace(SamplePool SamplePool::eval)]
|
||
#[namespace(ItemColor)]
|
||
#[namespace(ItemTheme)]
|
||
#[namespace(MidiClip)]
|
||
#[namespace(isize)]
|
||
#[namespace(u32)]
|
||
#[namespace(u8)]
|
||
pub struct App {
|
||
/// Exit flag
|
||
pub exit: Exit,
|
||
/// Base color.
|
||
pub color: ItemTheme,
|
||
/// Must not be dropped for the duration of the process
|
||
pub jack: Jack<'static>,
|
||
/// Display size
|
||
pub size: Sizer,
|
||
/// Performance counter
|
||
pub perf: PerfModel,
|
||
/// Available view modes and input bindings
|
||
pub watch: Arc<Watch>,
|
||
/// Currently active modes
|
||
pub stack: Arc<RwLock<Vec<Arc<str>>>>,
|
||
/// Undo history
|
||
pub history: Vec<(AppCmd, Option<AppCmd>)>,
|
||
/// Dialog overlay
|
||
pub dialog: Dialog,
|
||
/// Contains the currently edited musical arrangement
|
||
pub project: Project,
|
||
/// Error, if any
|
||
pub error: Arc<RwLock<Option<Arc<str>>>>,
|
||
/// Tracing guard
|
||
#[cfg(feature = "prof2")] pub guard: Option<tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>>,
|
||
}
|
||
|
||
impl App {
|
||
/// Create a new application instance from a backend, project, config, and mode
|
||
///
|
||
/// ```
|
||
/// # use ::tek::{*, tengri::Jack};
|
||
/// let proj = Project::new_jack(&"test_tek").expect("failed to connect to jack");
|
||
/// let tek = config_reload(App::new(None, proj, None, "Arranger"), stringify!(
|
||
/// (mode Arranger (name Arranger) (info Launch grid.)
|
||
/// (axis X Track)
|
||
/// (axis Y Scene)
|
||
/// (bind Global Clock Tracks Scenes Clip Launch Color History)
|
||
/// (view (bar/n 2 StatusBar (bar/s 8 (bar/e 16 (align/nw Transport)
|
||
/// (bar/w 20 (bar/s 2 (bar/w 4 TracksOutputsAdd TracksOutputsCount)
|
||
/// (bar/s 2 (bar/w 4 TracksDevicesAdd TracksDevicesCount)
|
||
/// (bar/s 2 (bar/w 4 TracksNamesAdd TracksNamesCount)
|
||
/// (bar/w 4 TracksInputsAdd TracksInputsCount))))
|
||
/// (align/x (bar/s 2 TracksOutputsCells
|
||
/// (bar/s 2 TracksDevicesCells
|
||
/// (bar/s 2 TracksNamesCells TracksInputsCells))))))
|
||
/// (bar/w 20 (text) (bar/e 16 ScenesNames ScenesClips))))))
|
||
/// )).unwrap();
|
||
/// ```
|
||
pub fn new (
|
||
exit: Option<Exit>,
|
||
project: Project,
|
||
watch: impl Into<Option<Arc<Watch>>>,
|
||
mode: impl AsRef<str>
|
||
) -> Self {
|
||
App {
|
||
exit: exit.unwrap_or_default(),
|
||
jack: project.jack.clone(),
|
||
color: ItemTheme::random(),
|
||
dialog: Dialog::welcome(),
|
||
stack: Arc::new(RwLock::new(vec![mode.as_ref().into()])),
|
||
watch: watch.into().unwrap_or_default(),
|
||
project,
|
||
..Default::default()
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Configuration watcher and manager.
|
||
///
|
||
/// ```
|
||
/// let config = tek::Watch::new(None);
|
||
/// ```
|
||
#[derive(Default, Debug)]
|
||
pub struct Watch {
|
||
/// XDG base directories of running user.
|
||
pub dirs: BaseDirectories,
|
||
/// Watcher
|
||
pub watch: RwLock<Option<PollWatcher>>,
|
||
/// App configuration
|
||
pub config: Config,
|
||
}
|
||
|
||
impl Watch {
|
||
/// Default configuration directory.
|
||
const DIR: &'static str = "tek";
|
||
/// Default configuration subdirectory.
|
||
const SUB: &'static str = "v0";
|
||
/// Default configuration file name.
|
||
const EDN: &'static str = "tek.edn";
|
||
/// Create a new watched app configuration
|
||
/// from a set of XDG base directories,
|
||
pub fn new (dirs: Option<BaseDirectories>) -> Self {
|
||
Self {
|
||
dirs: dirs.unwrap_or_else(||BaseDirectories::with_profile(Self::DIR, Self::SUB)),
|
||
..Default::default()
|
||
}
|
||
}
|
||
/// Create, initialize, and watch a new configuration.
|
||
pub fn run_watched <T: 'static> (
|
||
callback: impl FnOnce(Arc<Self>)->T,
|
||
dirs: impl Into<Option<BaseDirectories>>,
|
||
) -> Usually<T> {
|
||
let watch = Arc::new(Self::new(dirs.into()));
|
||
Self::watch(watch.clone(), None)?;
|
||
let result = callback(watch);
|
||
Ok(result)
|
||
}
|
||
/// Watch a config's file for changes.
|
||
pub fn watch (config: Arc<Self>, poll: Option<Duration>) -> Usually<()> {
|
||
let poll = poll.unwrap_or(Duration::from_millis(250));
|
||
let opts = NotifyConfig::default().with_poll_interval(poll);
|
||
let mut watcher = ::notify_debouncer_full::notify::poll::PollWatcher::new({
|
||
let config = config.clone();
|
||
move|result|{
|
||
match result {
|
||
Ok(_events) => if let Err(e) = config_init(config.as_ref()) {
|
||
config.error_set(Some(format!("{e:?}").into()));
|
||
panic!("{e:?}");
|
||
} else {
|
||
//println!("config updated");
|
||
},
|
||
Err(errors) => {
|
||
panic!("{errors:?}");
|
||
}
|
||
}
|
||
}
|
||
}, opts)?;
|
||
if let Some(path) = config.get_file() {
|
||
//println!("watching: {path:?}");
|
||
watcher.watch(&path, RecursiveMode::NonRecursive)?;
|
||
*config.as_ref().watch.try_write().unwrap() = Some(watcher);
|
||
Ok(())
|
||
} else {
|
||
Err(format!("no config path").into())
|
||
}
|
||
}
|
||
/// Find the config file.
|
||
fn find_file (&self) -> Option<PathBuf> {
|
||
self.dirs.find_config_file(Self::EDN)
|
||
}
|
||
/// Place config file in default location.
|
||
fn place_file (&self) -> Result<PathBuf, std::io::Error> {
|
||
self.dirs.place_config_file(Self::EDN)
|
||
}
|
||
/// Get path to config file.
|
||
fn get_file (&self) -> Option<PathBuf> {
|
||
self.dirs.get_config_file(Self::EDN)
|
||
}
|
||
}
|
||
|
||
/// Arranger.
|
||
///
|
||
/// ```
|
||
/// let arranger = tek::Project::default();
|
||
/// ```
|
||
#[namespace(ClipPool ClipPool::eval)]
|
||
#[derive(Default, Debug)]
|
||
pub struct Project {
|
||
/// JACK client handle.
|
||
pub jack: Jack<'static>,
|
||
/// Project name.
|
||
pub name: Arc<str>,
|
||
/// Base color.
|
||
pub color: ItemTheme,
|
||
/// FIXME a render of the project arrangement, redrawn on update.
|
||
/// TODO rename to "render_cache" or smth
|
||
pub arranger: Arc<RwLock<Buffer>>,
|
||
/// Display size
|
||
pub size: Sizer,
|
||
/// Display size of clips area
|
||
pub size_inner: Sizer,
|
||
/// Selected UI element
|
||
pub selection: Selection,
|
||
/// Contains all recently created clips.
|
||
#[cfg(feature = "sequencer")] pub clips: Pool<MidiClip>,
|
||
/// Contains all recently created clips.
|
||
#[cfg(feature = "sampler")] pub samples: Pool<Sample>,
|
||
/// Source of time
|
||
#[cfg(feature = "clock")] pub clock: Clock,
|
||
/// Allows one MIDI clip to be edited
|
||
#[cfg(feature = "editor")] pub editor: Option<MidiEditor>,
|
||
/// List of global midi inputs
|
||
#[cfg(feature = "port")] pub midi_ins: Vec<MidiInput>,
|
||
/// List of global midi outputs
|
||
#[cfg(feature = "port")] pub midi_outs: Vec<MidiOutput>,
|
||
/// List of global audio inputs
|
||
#[cfg(feature = "port")] pub audio_ins: Vec<AudioInput>,
|
||
/// List of global audio outputs
|
||
#[cfg(feature = "port")] pub audio_outs: Vec<AudioOutput>,
|
||
/// Last track number (to avoid duplicate port names)
|
||
#[cfg(feature = "track")] pub track_last: usize,
|
||
/// List of tracks
|
||
#[cfg(feature = "track")] pub tracks: Vec<Track>,
|
||
/// Scroll offset of tracks
|
||
#[cfg(feature = "track")] pub track_scroll: usize,
|
||
/// List of scenes
|
||
#[cfg(feature = "scene")] pub scenes: Vec<Scene>,
|
||
/// Scroll offset of scenes
|
||
#[cfg(feature = "scene")] pub scenes_scroll: usize,
|
||
}
|
||
|
||
fn tek_jack_process (state: &mut App, client: &Client, scope: &ProcessScope) -> Control {
|
||
let t0 = state.perf.get_t0();
|
||
state.clock().update_from_scope(scope).unwrap();
|
||
let midi_in = state.project.midi_input_collect(scope);
|
||
if let Some(editor) = &state.editor() {
|
||
let mut pitch: Option<u7> = None;
|
||
for port in midi_in.iter() {
|
||
for event in port.iter() {
|
||
if let (_, Ok(LiveEvent::Midi {message: MidiMessage::NoteOn {key, ..}, ..}))
|
||
= event
|
||
{
|
||
pitch = Some(key.clone());
|
||
}
|
||
}
|
||
}
|
||
if let Some(pitch) = pitch {
|
||
editor.set_note_pos(pitch.as_int() as usize);
|
||
}
|
||
}
|
||
let result = state.project.tracks_jack_process(client, scope);
|
||
state.perf.update_from_jack_scope(t0, scope);
|
||
result
|
||
}
|
||
|
||
fn tek_jack_event (state: &mut App, event: JackEvent) {
|
||
use JackEvent::*;
|
||
match event {
|
||
SampleRate(sr) => { state.clock().timebase.sr.set(sr as f64); },
|
||
PortRegistration(_id, true) => {
|
||
//let port = self.jack().port_by_id(id);
|
||
//println!("\rport add: {id} {port:?}");
|
||
//println!("\rport add: {id}");
|
||
},
|
||
PortRegistration(_id, false) => {
|
||
/*println!("\rport del: {id}")*/
|
||
},
|
||
PortsConnected(_a, _b, true) => { /*println!("\rport conn: {a} {b}")*/ },
|
||
PortsConnected(_a, _b, false) => { /*println!("\rport disc: {a} {b}")*/ },
|
||
ClientRegistration(_id, true) => {},
|
||
ClientRegistration(_id, false) => {},
|
||
ThreadInit => {},
|
||
XRun => {},
|
||
GraphReorder => {},
|
||
_ => { panic!("{event:?}"); }
|
||
}
|
||
}
|
||
|
||
impl Project {
|
||
pub fn new (jack: &Jack<'static>) -> Self {
|
||
Self {
|
||
jack: jack.clone(),
|
||
..Default::default()
|
||
}
|
||
}
|
||
|
||
pub fn new_jack (name: impl AsRef<str>) -> Usually<Self> {
|
||
let name = name.as_ref();
|
||
Ok(Self {
|
||
name: name.into(),
|
||
jack: Jack::new(name)?,
|
||
..Default::default()
|
||
})
|
||
}
|
||
|
||
/// Create a new arrangement.
|
||
pub fn create (
|
||
jack: &Jack<'static>,
|
||
name: Arc<str>,
|
||
clock: Clock,
|
||
tracks: impl Iterator<Item = Track>,
|
||
scenes: impl Iterator<Item = Scene>,
|
||
midi_ins: impl Iterator<Item = MidiInput>,
|
||
midi_outs: impl Iterator<Item = MidiOutput>,
|
||
audio_ins: impl Iterator<Item = AudioInput>,
|
||
audio_outs: impl Iterator<Item = AudioOutput>,
|
||
) -> Self {
|
||
Self {
|
||
jack: jack.clone(),
|
||
color: ItemTheme::random(),
|
||
selection: Selection::TrackClip { track: 0, scene: 0 },
|
||
tracks: tracks.collect(),
|
||
scenes: scenes.collect(),
|
||
midi_ins: midi_ins.collect(),
|
||
midi_outs: midi_outs.collect(),
|
||
audio_ins: audio_ins.collect(),
|
||
audio_outs: audio_outs.collect(),
|
||
size_inner: Sizer(Arc::new(40.into()), Arc::new(25.into())),
|
||
clock,
|
||
name,
|
||
..Default::default()
|
||
}
|
||
}
|
||
|
||
/// Width of display
|
||
pub fn w (&self) -> u16 {
|
||
self.size.w() as u16
|
||
}
|
||
|
||
/// Width allocated for sidebar.
|
||
pub fn w_sidebar (&self, is_editing: bool) -> u16 {
|
||
self.w() / if is_editing { 16 } else { 8 } as u16
|
||
}
|
||
|
||
/// Width available to display tracks.
|
||
fn w_tracks_area (&self, is_editing: bool) -> u16 {
|
||
self.w().saturating_sub(self.w_sidebar(is_editing))
|
||
}
|
||
|
||
/// Height of display
|
||
pub fn h (&self) -> u16 {
|
||
self.size.h() as u16
|
||
}
|
||
|
||
/// Height taken by visible device slots.
|
||
fn h_devices (&self) -> u16 {
|
||
2
|
||
//1 + self.devices_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
|
||
}
|
||
}
|
||
|
||
impl HasJack<'static> for App {
|
||
fn jack (&self) -> &Jack<'static> {
|
||
&self.jack
|
||
}
|
||
}
|
||
impl HasJack<'static> for Project {
|
||
fn jack (&self) -> &Jack<'static> {
|
||
&self.jack
|
||
}
|
||
}
|
||
|
||
impl ScenesView for Project {
|
||
fn h_scenes (&self) -> u16 {
|
||
(self.size.h() as u16).saturating_sub(20)
|
||
}
|
||
fn w_side (&self) -> u16 {
|
||
(self.size.w() as u16 * 2 / 10).max(20)
|
||
}
|
||
fn w_mid (&self) -> u16 {
|
||
(self.size.w() as u16).saturating_sub(2 * self.w_side()).max(40)
|
||
}
|
||
}
|
||
|
||
impl HasScenes for Project {
|
||
fn scenes_scroll (&self) -> usize {
|
||
self.scenes_scroll
|
||
}
|
||
fn scenes (&self) -> &Vec<Scene> {
|
||
&self.scenes
|
||
}
|
||
fn scenes_mut (&mut self) -> &mut Vec<Scene> {
|
||
&mut self.scenes
|
||
}
|
||
}
|
||
|
||
/// Represents the current user selection in the arranger
|
||
#[derive(PartialEq, Clone, Copy, Debug, Default)]
|
||
pub enum Selection {
|
||
#[default]
|
||
/// Nothing is selected
|
||
Nothing,
|
||
/// The whole mix is selected
|
||
Mix,
|
||
/// A MIDI input is selected.
|
||
Input(usize),
|
||
/// A MIDI output is selected.
|
||
Output(usize),
|
||
/// A clip is selected.
|
||
Clip(usize),
|
||
/// A sample is selected.
|
||
Sample(usize),
|
||
/// A scene is selected.
|
||
#[cfg(feature = "scene")] Scene(usize),
|
||
/// A track is selected.
|
||
#[cfg(feature = "track")] Track(usize),
|
||
/// A clip slot (track × scene) is selected.
|
||
#[cfg(feature = "track")] TrackClip { track: usize, scene: usize },
|
||
/// A track's MIDI input connection is selected.
|
||
#[cfg(feature = "track")] TrackInput { track: usize, port: usize },
|
||
/// A track's MIDI output connection is selected.
|
||
#[cfg(feature = "track")] TrackOutput { track: usize, port: usize },
|
||
/// A track device slot is selected.
|
||
#[cfg(feature = "track")] TrackDevice { track: usize, device: usize },
|
||
}
|
||
|
||
impl Selection {
|
||
|
||
pub fn describe (
|
||
&self,
|
||
#[cfg(feature = "track")] tracks: &[Track],
|
||
#[cfg(feature = "scene")] scenes: &[Scene],
|
||
) -> Arc<str> {
|
||
use Selection::*;
|
||
format!("{}", match self {
|
||
Mix => "Everything".to_string(),
|
||
#[cfg(feature = "scene")] Scene(s) =>
|
||
scenes.get(*s).map(|scene|format!("S{s}: {}", &scene.name)).unwrap_or_else(||"S??".into()),
|
||
#[cfg(feature = "track")] Track(t) =>
|
||
tracks.get(*t).map(|track|format!("T{t}: {}", &track.name)).unwrap_or_else(||"T??".into()),
|
||
TrackClip { track, scene } => match (tracks.get(*track), scenes.get(*scene)) {
|
||
(Some(_), Some(s)) => match &s.clips.get(*track) {
|
||
None => format!("T{track} S{scene}: Empty"),
|
||
Some(clip) => format!("T{track} S{scene} C{}",
|
||
clip.as_ref().map(|clip|clip.read().name.clone()).unwrap_or_default()),
|
||
},
|
||
_ => format!("T{track} S{scene}: Empty"),
|
||
},
|
||
_ => todo!()
|
||
}).into()
|
||
}
|
||
|
||
}
|
||
|
||
#[cfg(feature = "scene")]
|
||
impl Selection {
|
||
|
||
pub fn scene (&self) -> Option<usize> {
|
||
use Selection::*;
|
||
match self { Scene(scene) | TrackClip { scene, .. } => Some(*scene), _ => None }
|
||
}
|
||
|
||
pub fn select_scene (&self, scene_count: usize) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix | Track(_) => Scene(0),
|
||
Scene(s) => Scene((s + 1) % scene_count),
|
||
TrackClip { scene, .. } => Track(*scene),
|
||
_ => todo!(),
|
||
}
|
||
}
|
||
|
||
pub fn select_scene_next (&self, len: usize) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix => Scene(0),
|
||
Track(t) => TrackClip { track: *t, scene: 0 },
|
||
Scene(s) => if s + 1 < len { Scene(s + 1) } else { Mix },
|
||
TrackClip { track, scene } => if scene + 1 < len { TrackClip { track: *track, scene: scene + 1 } } else { Track(*track) },
|
||
_ => todo!()
|
||
}
|
||
}
|
||
|
||
pub fn select_scene_prev (&self) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix | Scene(0) => Mix,
|
||
Scene(s) => Scene(s - 1),
|
||
Track(t) => Track(*t),
|
||
TrackClip { track, scene: 0 } => Track(*track),
|
||
TrackClip { track, scene } => TrackClip { track: *track, scene: scene - 1 },
|
||
_ => todo!()
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
#[cfg(feature = "track")]
|
||
impl Selection {
|
||
|
||
pub fn track (&self) -> Option<usize> {
|
||
use Selection::*;
|
||
if let Track(track)|TrackClip{track,..}|TrackInput{track,..}|TrackOutput{track,..}|TrackDevice{track,..} = self {
|
||
Some(*track)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
pub fn select_track (&self, track_count: usize) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix => Track(0),
|
||
Scene(_) => Mix,
|
||
Track(t) => Track((t + 1) % track_count),
|
||
TrackClip { track, .. } => Track(*track),
|
||
_ => todo!(),
|
||
}
|
||
}
|
||
|
||
pub fn select_track_next (&self, len: usize) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix => Track(0),
|
||
Scene(s) => TrackClip { track: 0, scene: *s },
|
||
Track(t) => if t + 1 < len { Track(t + 1) } else { Mix },
|
||
TrackClip {track, scene} => if track + 1 < len { TrackClip { track: track + 1, scene: *scene } } else { Scene(*scene) },
|
||
_ => todo!()
|
||
}
|
||
}
|
||
|
||
pub fn select_track_prev (&self) -> Self {
|
||
use Selection::*;
|
||
match self {
|
||
Mix => Mix,
|
||
Scene(s) => Scene(*s),
|
||
Track(0) => Mix,
|
||
Track(t) => Track(t - 1),
|
||
TrackClip { track: 0, scene } => Scene(*scene),
|
||
TrackClip { track: t, scene } => TrackClip { track: t - 1, scene: *scene },
|
||
_ => todo!()
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
impl<T: HasSelection> SelectionModel for T {}
|
||
|
||
pub trait SelectionModel: HasSelection {
|
||
/// Get the active track
|
||
#[cfg(feature = "track")] fn selected_track (&self) -> Option<&Track> where Self: HasTracks {
|
||
let index = self.selection().track()?;
|
||
self.tracks().get(index)
|
||
}
|
||
/// Get a mutable reference to the active track
|
||
#[cfg(feature = "track")] fn selected_track_mut (&mut self) -> Option<&mut Track> where Self: HasTracks {
|
||
let index = self.selection().track()?;
|
||
self.tracks_mut().get_mut(index)
|
||
}
|
||
/// Get the active scene
|
||
#[cfg(feature = "scene")] fn selected_scene (&self) -> Option<&Scene> where Self: HasScenes {
|
||
let index = self.selection().scene()?;
|
||
self.scenes().get(index)
|
||
}
|
||
/// Get a mutable reference to the active scene
|
||
#[cfg(feature = "scene")] fn selected_scene_mut (&mut self) -> Option<&mut Scene> where Self: HasScenes {
|
||
let index = self.selection().scene()?;
|
||
self.scenes_mut().get_mut(index)
|
||
}
|
||
/// Get the active clip
|
||
#[cfg(feature = "clip")] fn selected_clip (&self) -> Option<Slot<MidiClip>> where Self: HasScenes + HasTracks {
|
||
self.selected_scene()?.clips.read().get(self.selection().track()?).cloned()
|
||
}
|
||
}
|
||
|
||
/// A scene consists of a set of clips to play together.
|
||
///
|
||
/// ```
|
||
/// let scene: tek::Scene = Default::default();
|
||
/// let _ = scene.pulses();
|
||
/// let _ = scene.is_playing(&[]);
|
||
/// ```
|
||
#[derive(Debug, Default)] pub struct Scene {
|
||
/// Name of scene
|
||
pub name: Arc<str>,
|
||
/// Identifying color of scene
|
||
pub color: ItemTheme,
|
||
/// Clips in scene, one per track
|
||
pub clips: Pool<MidiClip>,
|
||
}
|
||
|
||
impl Scene {
|
||
pub const DEFAULT_HEIGHT: usize = 2;
|
||
/// Get pulse length of the longest clip in the scene
|
||
pub fn pulses (&self) -> usize {
|
||
self.clips.read().iter().fold(0, |a, p|{
|
||
a.max(p.read().as_ref().map(|q|q.read().length).unwrap_or(0))
|
||
})
|
||
}
|
||
/// True if all clips in scene are currently playing on given tracks.
|
||
pub fn is_playing (&self, tracks: &[Track]) -> bool {
|
||
// Not "playing" if there are no clips
|
||
if !self.clips.read().iter().any(|clip|clip.read().is_some()) {
|
||
return false
|
||
}
|
||
// Playing if at least 1 clip is playing
|
||
self.clips.read().iter().enumerate().all(|(track_index, clip)|match &*clip.read() {
|
||
Some(c) => tracks
|
||
.get(track_index)
|
||
.map(|track|{
|
||
if let Some((_, Some(clip))) = track.sequencer().play_clip() {
|
||
*clip.read() == *c.read()
|
||
} else {
|
||
false
|
||
}
|
||
})
|
||
.unwrap_or(false),
|
||
None => true
|
||
})
|
||
}
|
||
}
|
||
|
||
impl ScenesView for App {
|
||
fn w_mid (&self) -> u16 {
|
||
(self.size.w() as u16).saturating_sub(self.w_side())
|
||
}
|
||
fn w_side (&self) -> u16 {
|
||
20
|
||
}
|
||
fn h_scenes (&self) -> u16 {
|
||
(self.size.h() as u16).saturating_sub(20)
|
||
}
|
||
}
|
||
|
||
impl HasScenes for App {
|
||
fn scenes_scroll (&self) -> usize {
|
||
self.project.scenes_scroll()
|
||
}
|
||
fn scenes (&self) -> &Vec<Scene> {
|
||
self.project.scenes()
|
||
}
|
||
fn scenes_mut (&mut self) -> &mut Vec<Scene> {
|
||
self.project.scenes_mut()
|
||
}
|
||
}
|
||
|
||
impl App {
|
||
/// Return reference to content browser if open.
|
||
///
|
||
/// ```
|
||
/// assert_eq!(tek::App::default().browser(), None);
|
||
/// ```
|
||
pub fn browser (&self) -> Option<&Browse> {
|
||
if let Dialog::Browse(_, ref b) = self.dialog { Some(b) } else { None }
|
||
}
|
||
}
|
||
|
||
/// Has a MIDI editor.
|
||
///
|
||
/// ```
|
||
/// use tek::{*, tengri::*};
|
||
///
|
||
/// struct Test(Option<MidiEditor>);
|
||
/// impl_as_ref!(Option<MidiEditor>: |self: Test|&self.0);
|
||
/// impl_as_mut!(Option<MidiEditor>: |self: Test|&mut self.0);
|
||
///
|
||
/// let mut host = Test(Some(MidiEditor::default()));
|
||
/// let _ = host.editor();
|
||
/// let _ = host.editor_mut();
|
||
/// let _ = host.is_editing();
|
||
/// let _ = host.editor_w();
|
||
/// let _ = host.editor_h();
|
||
/// ```
|
||
impl<T> HasEditor for T where T:
|
||
AsRef<Option<MidiEditor>> + AsMut<Option<MidiEditor>> {}
|
||
pub trait HasEditor:
|
||
AsRef<Option<MidiEditor>> + AsMut<Option<MidiEditor>>
|
||
{
|
||
fn editor (&self) -> &Option<MidiEditor> {
|
||
self.as_ref()
|
||
}
|
||
fn editor_mut (&mut self) -> &mut Option<MidiEditor> {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
|
||
/// Has a pair of buffers for MIDI IO.
|
||
pub trait HasMidiBuffers {
|
||
fn note_buf_mut (&mut self) -> &mut Vec<u8>;
|
||
fn midi_buf_mut (&mut self) -> &mut Vec<Vec<Vec<u8>>>;
|
||
}
|
||
|
||
/// Can have a currently playing clip.
|
||
pub trait HasPlayClip: HasClock {
|
||
fn reset (&self) -> bool;
|
||
fn reset_mut (&mut self) -> &mut bool;
|
||
fn play_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
||
fn play_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
||
fn next_clip (&self) -> &Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
||
fn next_clip_mut (&mut self) -> &mut Option<(Moment, Option<Arc<RwLock<MidiClip>>>)>;
|
||
}
|
||
|
||
/// Has a MIDI sequencer.
|
||
impl <T> HasSequencer for T where T: AsRef<Sequencer> + AsMut<Sequencer> {}
|
||
pub trait HasSequencer: AsRef<Sequencer> + AsMut<Sequencer> {
|
||
fn sequencer (&self) -> &Sequencer {
|
||
self.as_ref()
|
||
}
|
||
fn sequencer_mut (&mut self) -> &mut Sequencer {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
|
||
/// Has a clock.
|
||
pub trait HasClock: AsRef<Clock> + AsMut<Clock> {
|
||
fn clock (&self) -> &Clock {
|
||
self.as_ref()
|
||
}
|
||
fn clock_mut (&mut self) -> &mut Clock {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
impl<T> HasClock for T where T: AsRef<Clock> + AsMut<Clock> {}
|
||
|
||
/// Has a chain of devices.
|
||
pub trait HasDevices: AsRef<Vec<Device>> + AsMut<Vec<Device>> {
|
||
fn devices (&self) -> &Vec<Device> {
|
||
self.as_ref()
|
||
}
|
||
fn devices_mut (&mut self) -> &mut Vec<Device> {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
|
||
pub trait HasProject: AsRef<Option<Project>> + AsMut<Option<Project>> {}
|
||
|
||
/// Has a loaded project.
|
||
impl<T> HasProject for T where T: AsRef<Option<Project>> + AsMut<Option<Project>> {}
|
||
|
||
pub trait HasScene: AsRefOpt<Scene> + AsMutOpt<Scene> {
|
||
fn scene (&self) -> Option<&Scene> {
|
||
self.as_ref_opt()
|
||
}
|
||
fn scene_mut (&mut self) -> Option<&mut Scene> {
|
||
self.as_mut_opt()
|
||
}
|
||
}
|
||
impl<T> HasScene for T where T: AsRefOpt<Scene> + AsMutOpt<Scene> + Send + Sync {}
|
||
|
||
pub trait HasScenes {
|
||
fn scenes (&self) -> &Vec<Scene>;
|
||
fn scenes_mut (&mut self) -> &mut Vec<Scene>;
|
||
fn scenes_scroll (&self) -> usize {
|
||
0
|
||
}
|
||
}
|
||
|
||
impl<T> HasSelection for T where T: AsRef<Selection> + AsMut<Selection> {}
|
||
pub trait HasSelection: AsRef<Selection> + AsMut<Selection> {
|
||
fn selection (&self) -> &Selection {
|
||
self.as_ref()
|
||
}
|
||
fn selection_mut (&mut self) -> &mut Selection {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
|
||
impl<T> HasTrack for T where T: AsRefOpt<Track> + AsMutOpt<Track> {}
|
||
pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
|
||
fn track (&self) -> Option<&Track> {
|
||
self.as_ref_opt()
|
||
}
|
||
fn track_mut (&mut self) -> Option<&mut Track> {
|
||
self.as_mut_opt()
|
||
}
|
||
}
|
||
|
||
impl<T> HasTracks for T where T: AsRef<Vec<Track>> + AsMut<Vec<Track>> + HasClock + HasTrackScroll {}
|
||
pub trait HasTracks: AsRef<Vec<Track>> + AsMut<Vec<Track>> + HasClock + HasTrackScroll {
|
||
/// Read-only reference to collection of [Track]s.
|
||
fn tracks (&self) -> &Vec<Track> {
|
||
self.as_ref()
|
||
}
|
||
/// Mutable reference to collection of [Track]s.
|
||
fn tracks_mut (&mut self) -> &mut Vec<Track> {
|
||
self.as_mut()
|
||
}
|
||
}
|
||
|
||
pub trait HasTrackScroll {
|
||
fn track_scroll (&self) -> usize;
|
||
fn tracks_last (&self) -> usize;
|
||
fn tracks_last_mut (&mut self) -> &mut usize;
|
||
}
|
||
impl HasTrackScroll for &mut Project {
|
||
fn track_scroll (&self) -> usize {
|
||
self.track_scroll
|
||
}
|
||
fn tracks_last (&self) -> usize {
|
||
self.track_last
|
||
}
|
||
fn tracks_last_mut (&mut self) -> &mut usize {
|
||
&mut self.track_last
|
||
}
|
||
}
|
||
impl HasTrackScroll for Project {
|
||
fn track_scroll (&self) -> usize {
|
||
self.track_scroll
|
||
}
|
||
fn tracks_last (&self) -> usize {
|
||
self.track_last
|
||
}
|
||
fn tracks_last_mut (&mut self) -> &mut usize {
|
||
&mut self.track_last
|
||
}
|
||
}
|
||
impl HasTrackScroll for App {
|
||
fn track_scroll (&self) -> usize {
|
||
self.project.track_scroll()
|
||
}
|
||
fn tracks_last (&self) -> usize {
|
||
self.project.track_last
|
||
}
|
||
fn tracks_last_mut (&mut self) -> &mut usize {
|
||
&mut self.project.track_last
|
||
}
|
||
}
|
||
|
||
pub trait HasClip {
|
||
fn clip_slot (&self) -> Option<Slot<MidiClip>>;
|
||
fn clip (&self) -> Option<ArcRwLockReadGuard<RawRwLock, Option<Arc<RwLock<MidiClip>>>>> {
|
||
self.clip_slot().map(|slot|slot.read())
|
||
}
|
||
fn clip_mut (&self) -> Option<ArcRwLockWriteGuard<RawRwLock, Option<Arc<RwLock<MidiClip>>>>> {
|
||
self.clip_slot().map(|slot|slot.write())
|
||
}
|
||
}
|
||
impl HasClip for App {
|
||
fn clip_slot (&self) -> Option<Slot<MidiClip>> {
|
||
self.project.clip_slot()
|
||
}
|
||
}
|
||
impl HasClip for Project {
|
||
fn clip_slot (&self) -> Option<Slot<MidiClip>> {
|
||
match self.selection {
|
||
Selection::Clip(index) =>
|
||
Some(self.clips.slot(index)),
|
||
Selection::TrackClip { track, scene } if let Some(scene) = self.scenes.get(scene) =>
|
||
Some(scene.clips.slot(track)),
|
||
_ =>
|
||
None
|
||
}
|
||
}
|
||
}
|
||
|
||
pub trait HasWidth {
|
||
const MIN_WIDTH: usize;
|
||
/// Increment track width.
|
||
fn width_inc (&mut self);
|
||
/// Decrement track width, down to a hardcoded minimum of [Self::MIN_WIDTH].
|
||
fn width_dec (&mut self);
|
||
}
|
||
|
||
pub trait HasClipsSize {
|
||
/// Size of clips area.
|
||
fn clips_size (&self) -> &Sizer;
|
||
/// Draw content annotated with value of [Self::clips_size].
|
||
fn with_clips_size (&self, show: bool, content: impl Draw<Tui>) -> impl Draw<Tui> {
|
||
let size = self.clips_size();
|
||
above(
|
||
when(show, fg(Green, east!(size.w() as usize, "x", size.h() as usize)).align_se()),
|
||
size.of(content.align_c().full_wh())
|
||
)
|
||
}
|
||
}
|
||
impl HasClipsSize for App {
|
||
fn clips_size (&self) -> &Sizer {
|
||
&self.project.size_inner
|
||
}
|
||
}
|
||
impl HasClipsSize for Project {
|
||
fn clips_size (&self) -> &Sizer {
|
||
&self.size_inner
|
||
}
|
||
}
|
||
|
||
pub struct Junction<T: JackPort>(T);
|
||
|
||
impl<T: JackPort> Draw<Tui> for Junction<T> {
|
||
fn draw (&self, to: &mut Tui) -> Drawn<u16> {
|
||
T::KIND.draw(to)
|
||
}
|
||
}
|
||
|
||
/// An item of a menu.
|
||
///
|
||
/// ```
|
||
/// let item: tek::MenuItem = Default::default();
|
||
/// ```
|
||
#[derive(Clone)] pub struct MenuItem(pub Arc<str>, pub Arc<[AppCmd]>);
|
||
|
||
impl PartialEq for MenuItem {
|
||
fn eq (&self, other: &Self) -> bool {
|
||
self.0 == other.0
|
||
}
|
||
}
|
||
|
||
impl MenuItem {
|
||
pub fn new <const N: usize> (name: impl AsRef<str>, actions: [AppCmd; N]) -> Self {
|
||
Self(name.as_ref().into(), Arc::new(actions))
|
||
}
|
||
}
|
||
|
||
/// Various possible dialog modes.
|
||
///
|
||
/// ```
|
||
/// let dialog: tek::Dialog = Default::default();
|
||
/// ```
|
||
#[derive(Debug, Clone, Default, PartialEq)] pub enum Dialog {
|
||
#[default] None,
|
||
Help(usize),
|
||
Menu(usize, Arc<[MenuItem]>),
|
||
Device(usize),
|
||
Message(Arc<str>),
|
||
Browse(BrowseTarget, Arc<Browse>),
|
||
Options,
|
||
}
|
||
|
||
impl Dialog {
|
||
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome();
|
||
/// ```
|
||
pub fn welcome () -> Self {
|
||
Self::Menu(1, Arc::new([
|
||
|
||
MenuItem::new(" Resume session ", [
|
||
AppCmd::Project { command: ProjectCmd::LoadLast }
|
||
]),
|
||
|
||
MenuItem::new(" Create session ", [
|
||
AppCmd::Dialog { dialog: Dialog::None },
|
||
AppCmd::Mode { modes: vec!["Arranger".into()] },
|
||
AppCmd::Tracks { command: TracksCmd::Add },
|
||
AppCmd::Scenes { command: ScenesCmd::Add },
|
||
AppCmd::MidiClip { command: MidiClipCmd::Upsert },
|
||
AppCmd::MidiEdit { command: MidiEditCmd::Toggle },
|
||
]),
|
||
|
||
MenuItem::new(" Load session ", [
|
||
AppCmd::Dialog { dialog: Dialog::Browse(
|
||
BrowseTarget::LoadProject,
|
||
Browse::new(None).unwrap().into()
|
||
) }
|
||
]),
|
||
|
||
MenuItem::new(" Exit ", [
|
||
AppCmd::Exit
|
||
]),
|
||
|
||
]))
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().menu_selected();
|
||
/// ```
|
||
pub fn menu_selected (&self) -> Option<usize> {
|
||
if let Self::Menu(selected, _) = self { Some(*selected) } else { None }
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().menu_next();
|
||
/// ```
|
||
pub fn menu_next (&self) -> Self {
|
||
match self {
|
||
Self::Menu(index, items) => Self::Menu(wrap_inc(*index, items.len()), items.clone()),
|
||
_ => Self::None
|
||
}
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().menu_prev();
|
||
/// ```
|
||
pub fn menu_prev (&self) -> Self {
|
||
match self {
|
||
Self::Menu(index, items) => Self::Menu(wrap_dec(*index, items.len()), items.clone()),
|
||
_ => Self::None
|
||
}
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().device_kind();
|
||
/// ```
|
||
pub fn device_kind (&self) -> Option<usize> {
|
||
if let Self::Device(index) = self { Some(*index) } else { None }
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().device_kind_next();
|
||
/// ```
|
||
pub fn device_kind_next (&self) -> Option<usize> {
|
||
self.device_kind().map(|index|(index + 1) % device_kinds().len())
|
||
}
|
||
|
||
/// FIXME: generalize
|
||
/// ```
|
||
/// let _ = tek::Dialog::welcome().device_kind_prev();
|
||
/// ```
|
||
pub fn device_kind_prev (&self) -> Option<usize> {
|
||
self.device_kind().map(|index|index.overflowing_sub(1).0.min(device_kinds().len().saturating_sub(1)))
|
||
}
|
||
|
||
/// FIXME: implement
|
||
pub fn message (&self) -> Option<&str> { todo!() }
|
||
|
||
/// FIXME: implement
|
||
pub fn browser (&self) -> Option<&Arc<Browse>> { todo!() }
|
||
|
||
/// FIXME: implement
|
||
pub fn browser_target (&self) -> Option<&BrowseTarget> { todo!() }
|
||
|
||
}
|
||
|
||
/// Browses for files to load/save.
|
||
///
|
||
/// ```
|
||
/// let browse = tek::Browse::default();
|
||
/// ```
|
||
#[derive(Debug, Clone, Default, PartialEq)] pub struct Browse {
|
||
pub cwd: PathBuf,
|
||
pub dirs: Vec<(OsString, String)>,
|
||
pub files: Vec<(OsString, String)>,
|
||
pub filter: String,
|
||
pub index: usize,
|
||
pub scroll: usize,
|
||
pub size: Sizer,
|
||
}
|
||
|
||
#[derive(Clone, Debug)] pub enum BrowseTarget {
|
||
SaveProject,
|
||
LoadProject,
|
||
ImportSample(Arc<RwLock<Option<Sample>>>),
|
||
ExportSample(Arc<RwLock<Option<Sample>>>),
|
||
ImportClip(Arc<RwLock<Option<MidiClip>>>),
|
||
ExportClip(Arc<RwLock<Option<MidiClip>>>),
|
||
}
|
||
impl Browse {
|
||
pub fn new (cwd: Option<PathBuf>) -> Usually<Self> {
|
||
let cwd = if let Some(cwd) = cwd { cwd } else { std::env::current_dir()? };
|
||
let mut dirs = vec![];
|
||
let mut files = vec![];
|
||
for entry in std::fs::read_dir(&cwd)? {
|
||
let entry = entry?;
|
||
let name = entry.file_name();
|
||
let decoded = name.clone().into_string().unwrap_or_else(|_|"<unreadable>".to_string());
|
||
let meta = entry.metadata()?;
|
||
if meta.is_dir() {
|
||
dirs.push((name, format!("📁 {decoded}")));
|
||
} else if meta.is_file() {
|
||
files.push((name, format!("📄 {decoded}")));
|
||
}
|
||
}
|
||
Ok(Self { cwd, dirs, files, ..Default::default() })
|
||
}
|
||
pub fn to_chdir (&self) -> Usually<Self> {
|
||
Self::new(Some(self.path()))
|
||
}
|
||
pub fn len (&self) -> usize {
|
||
self.dirs.len() + self.files.len()
|
||
}
|
||
pub fn is_dir (&self) -> bool {
|
||
self.index < self.dirs.len()
|
||
}
|
||
pub fn is_file (&self) -> bool {
|
||
self.index >= self.dirs.len()
|
||
}
|
||
pub fn path (&self) -> PathBuf {
|
||
self.cwd.join(if self.is_dir() {
|
||
&self.dirs[self.index].0
|
||
} else if self.is_file() {
|
||
&self.files[self.index - self.dirs.len()].0
|
||
} else {
|
||
unreachable!()
|
||
})
|
||
}
|
||
//fn tui_entries (&self) -> EntriesIterator<'_, Tui> {
|
||
//EntriesIterator {
|
||
//offset: 0,
|
||
//index: 0,
|
||
//length: self.dirs.len() + self.files.len(),
|
||
//browser: self,
|
||
//_screen: Default::default(),
|
||
//}
|
||
//}
|
||
}
|
||
|
||
impl PartialEq for BrowseTarget {
|
||
fn eq (&self, other: &Self) -> bool {
|
||
match self {
|
||
Self::ImportSample(_) => false,
|
||
Self::ExportSample(_) => false,
|
||
Self::ImportClip(_) => false,
|
||
Self::ExportClip(_) => false,
|
||
#[allow(unused)] t => matches!(other, t)
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
|
||
let (mut subdirs, mut files) = std::fs::read_dir(dir)?
|
||
.fold((vec!["..".into()], vec![]), |(mut subdirs, mut files), entry|{
|
||
let entry = entry.expect("failed to read drectory entry");
|
||
let meta = entry.metadata().expect("failed to read entry metadata");
|
||
if meta.is_file() {
|
||
files.push(entry.file_name());
|
||
} else if meta.is_dir() {
|
||
subdirs.push(entry.file_name());
|
||
}
|
||
(subdirs, files)
|
||
});
|
||
subdirs.sort();
|
||
files.sort();
|
||
Ok((subdirs, files))
|
||
}
|
||
|
||
pub trait DispatchBind<C: Clone>: HasBinds + HasModeStack + HasModes + Namespace<C> {
|
||
fn dispatch_bind (&mut self, input: &TuiEvent) -> Usually<()> {
|
||
if let Some(bindings) = self.dispatch_bind_match(input) {
|
||
return self.dispatch_bind_exec(bindings)
|
||
}
|
||
Ok(())
|
||
}
|
||
/// Find command bindings that match the ,nput.
|
||
/// ```
|
||
/// # use ::{std::sync::Arc, tek::*};
|
||
/// // Configure modes:
|
||
/// let app = config_reload(App::default(), stringify!(
|
||
/// (axis Y @up @down)
|
||
/// (bind Confirm (@enter confirm))
|
||
/// (mode Test (axis Y Index) (bind (@escape Cancel) Confirm))
|
||
/// )).unwrap();
|
||
/// println!("Modes: {:#?}", app.watch.config.modes);
|
||
///
|
||
/// // No mode is active:
|
||
/// assert!(app.dispatch_bind_match(&"@left".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@enter".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@escape".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@down".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@up".into()).is_none());
|
||
///
|
||
/// // Push mode onto stack:
|
||
/// app.mode_stack_push("Test");
|
||
/// assert!(app.dispatch_bind_match(&"@left".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@enter".into()).is_some());
|
||
/// assert!(app.dispatch_bind_match(&"@escape".into()).is_some());
|
||
/// assert!(app.dispatch_bind_match(&"@down".into()).is_some());
|
||
/// assert!(app.dispatch_bind_match(&"@up".into()).is_some());
|
||
/// ```
|
||
fn dispatch_bind_match (&self, input: &TuiEvent) -> Option<Arc<[Binding<Arc<str>>]>> {
|
||
for name in self.mode_stack().read().iter().rev() {
|
||
if let Some(mode) = self.modes_get(name).as_ref().map(Arc::clone) {
|
||
if let Some(binds) = self.dispatch_bind_match_axis(mode.as_ref(), input) {
|
||
return Some(binds)
|
||
}
|
||
if let Some(binds) = self.dispatch_bind_match_keys(mode.as_ref(), input) {
|
||
return Some(binds)
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
/// ```
|
||
/// # use ::{std::sync::Arc, tek::*};
|
||
/// let app = config_reload(App::default(), stringify!(
|
||
/// (axis Y @up @down) (mode Test (axis Y Index))
|
||
/// )).unwrap();
|
||
/// assert!(app.dispatch_bind_match(&"@down".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@up".into()).is_none());
|
||
/// app.mode_stack_push("Test");
|
||
/// assert!(app.dispatch_bind_match(&"@down".into()).is_some());
|
||
/// assert!(app.dispatch_bind_match(&"@up".into()).is_some());
|
||
/// ```
|
||
fn dispatch_bind_match_axis (&self, mode: &Mode, input: &TuiEvent) -> Option<Arc<[Binding<Arc<str>>]>> {
|
||
let axis = self.binds_axis().read();
|
||
for (ctrl, _param) in mode.axis.iter() {
|
||
if let Some(axis) = axis.get(ctrl) {
|
||
if *input == axis.0 {
|
||
return Some([Binding { commands: [].into(), ..Default::default() }].into())
|
||
} else if *input == axis.1 {
|
||
return Some([Binding { commands: [].into(), ..Default::default() }].into())
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
/// ```
|
||
/// # use ::{std::sync::Arc, tek::*};
|
||
/// let app = config_reload(App::default(), stringify!(
|
||
/// (bind Confirm (@enter confirm)) (mode Test (bind Confirm (@escape Cancel)))
|
||
/// )).unwrap();
|
||
/// assert!(app.dispatch_bind_match(&"@enter".into()).is_none());
|
||
/// assert!(app.dispatch_bind_match(&"@escape".into()).is_none());
|
||
/// app.mode_stack_push("Test");
|
||
/// assert!(app.dispatch_bind_match(&"@enter".into()).is_some());
|
||
/// assert!(app.dispatch_bind_match(&"@escape".into()).is_some());
|
||
/// ```
|
||
fn dispatch_bind_match_keys (&self, mode: &Mode, input: &TuiEvent) -> Option<Arc<[Binding<Arc<str>>]>> {
|
||
for id in mode.keys.iter() {
|
||
println!("{input:?} {id:?}");
|
||
if let Some(event_map) = self.binds_find(id)
|
||
&& let Some(bindings) = event_map.query(input) {
|
||
return Some(bindings.into())
|
||
}
|
||
if let Ok(Some(expr)) = id.expr()
|
||
&& let Ok(Some(head)) = expr.head()
|
||
&& *input == head.into()
|
||
&& let Ok(Some(tail)) = expr.tail() {
|
||
return Some([Binding { commands: [tail.into()].into(), ..Default::default() }].into())
|
||
}
|
||
}
|
||
None
|
||
}
|
||
fn dispatch_bind_exec (&mut self, bindings: Arc<[Binding<Arc<str>>]>) -> Usually<()> {
|
||
for binding in bindings.iter() {
|
||
for src in binding.commands.iter() {
|
||
if let Some(command) = Namespace::<C>::namespace(self, &src)? {
|
||
self.cmd_dispatch(command)?;
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
fn cmd_dispatch (&mut self, command: C) -> Usually<()>;
|
||
}
|
||
|
||
impl DispatchBind<AppCmd> for App {
|
||
fn cmd_dispatch (&mut self, command: AppCmd) -> Usually<()> {
|
||
match command.clone().dispatch(self) {
|
||
Ok(undo) => { self.history.push((command, undo)); Ok(()) },
|
||
Err(err) => { self.history.push((command, None)); Err(err) },
|
||
}
|
||
}
|
||
}
|
||
|
||
pub use self::conf::*; mod conf {
|
||
use crate::*;
|
||
|
||
mod axis; pub use self::axis::*;
|
||
mod bind; pub use self::bind::*;
|
||
mod lang; pub use self::lang::*;
|
||
mod mode; pub use self::mode::*;
|
||
mod view; pub use self::view::*;
|
||
|
||
pub trait HasError<T> {
|
||
fn error (&self) -> &RwLock<Option<T>>;
|
||
fn error_set (&self, e: Option<T>) {
|
||
*self.error().write() = e;
|
||
}
|
||
}
|
||
impl<T: AsRef<Config>> HasError<Arc<str>> for T {
|
||
fn error (&self) -> &RwLock<Option<Arc<str>>> {
|
||
&self.as_ref().error
|
||
}
|
||
}
|
||
impl HasError<Arc<str>> for Arc<Watch> {
|
||
fn error (&self) -> &RwLock<Option<Arc<str>>> {
|
||
&self.as_ref().config.error
|
||
}
|
||
}
|
||
|
||
pub trait HasConfig {
|
||
fn config (&self) -> &Config;
|
||
/// Print the configuration.
|
||
fn config_print (&self) {
|
||
let config = self.config();
|
||
print_config_views(config);
|
||
print_config_binds(config);
|
||
print_config_modes(config);
|
||
}
|
||
/// Make this configuration empty.
|
||
fn config_clear (&self) {
|
||
let config = self.config();
|
||
config.modes_clear();
|
||
config.views_clear();
|
||
config.binds_clear();
|
||
config.stamp.store(quanta::Clock::new().raw(), Relaxed);
|
||
}
|
||
}
|
||
impl HasConfig for App {
|
||
fn config (&self) -> &Config {
|
||
&self.watch.config
|
||
}
|
||
}
|
||
impl HasConfig for Watch {
|
||
fn config (&self) -> &Config {
|
||
&self.config
|
||
}
|
||
}
|
||
impl HasConfig for Config {
|
||
fn config (&self) -> &Config {
|
||
self
|
||
}
|
||
}
|
||
|
||
/// Default configuration contents.
|
||
const CONFIG_DEFAULT: &'static str = include_str!("tek.edn");
|
||
|
||
pub fn config_init <C: AsRef<Watch> + AsRef<Config>> (config: C) -> Usually<C> {
|
||
// Write initial contents of configuration:
|
||
let watcher: &Watch = config.as_ref();
|
||
if watcher.find_file().is_none() {
|
||
std::fs::write(watcher.place_file()?, CONFIG_DEFAULT)?;
|
||
}
|
||
// Load config from file:
|
||
Ok(if let Some(path) = watcher.find_file() {
|
||
config_reload(config, std::fs::read_to_string(&path)?)?
|
||
} else {
|
||
return Err(format!("config_init: not found").into())
|
||
})
|
||
}
|
||
|
||
/// Reload configuration from source.
|
||
pub fn config_reload <C: AsRef<Config>, L: Language> (state: C, src: L) -> Usually<C> {
|
||
state.as_ref().config_clear();
|
||
src.each(state, |c, s|config_add(c, s.trim()))
|
||
}
|
||
|
||
/// Load configuration item.
|
||
fn config_add <C: AsRef<Config>, L: Language> (state: C, src: L) -> Usually<C> {
|
||
if let Some(expr) = src.expr()? {
|
||
match expr.head()? {
|
||
Some("mode") => state.as_ref().modes_add(expr.tail()),
|
||
Some("view") => state.as_ref().views_add(expr.tail()),
|
||
Some("bind") => state.as_ref().binds_def_keys(expr.tail()),
|
||
Some("axis") => state.as_ref().binds_def_axis(expr.tail()),
|
||
_ => return Err(format!("config_add: unexpected: {src:?}").into())
|
||
}?;
|
||
Ok(state)
|
||
} else {
|
||
Err(format!("Config::add_one: tried to add empty item").into())
|
||
}
|
||
}
|
||
|
||
/// Contains timestamped mode, view, and bind definitions.
|
||
///
|
||
/// ```
|
||
/// # use ::{std::sync::Arc, tek::*};
|
||
///
|
||
/// // Default empty config:
|
||
/// let config: Config = Default::default();
|
||
///
|
||
/// // Define a binding:
|
||
/// config.binds_def_keys(stringify!(Confirm (@enter confirm))).unwrap();
|
||
///
|
||
/// // Define an axis:
|
||
/// config.binds_def_axis(stringify!(Y @up @down)).unwrap();
|
||
/// ```
|
||
#[derive(Default, Debug)]
|
||
pub struct Config {
|
||
/// Error caught during (re)loading
|
||
pub error: RwLock<Option<Arc<str>>>,
|
||
/// Timestamp
|
||
pub stamp: AtomicU64,
|
||
/// Active collection of interaction modes.
|
||
pub modes: Arc<RwLock<BTreeMap<Arc<str>, Arc<Mode>>>>,
|
||
/// Active collection of view definitions.
|
||
pub views: Arc<RwLock<BTreeMap<Arc<str>, Arc<View<Tui, App>>>>>,
|
||
/// Active collection of key bindings.
|
||
pub keys: Arc<RwLock<BTreeMap<Arc<str>, Arc<Bind<TuiEvent, Arc<str>>>>>>,
|
||
/// Active collection of axis bindings.
|
||
pub axis: Arc<RwLock<BTreeMap<Arc<str>, Arc<Axis<TuiEvent>>>>>,
|
||
}
|
||
|
||
impl Config {
|
||
/// Create a new timestamped config state.
|
||
pub fn new () -> Self {
|
||
Self { stamp: quanta::Clock::new().raw().into(), ..Default::default() }
|
||
}
|
||
}
|
||
}
|
||
|
||
pub use self::gear::*; mod gear {
|
||
mod device; pub use self::device::*;
|
||
mod midi; pub use self::midi::*;
|
||
mod mixer; pub use self::mixer::*;
|
||
mod pool; pub use self::pool::*;
|
||
mod sample; pub use self::sample::*;
|
||
mod track; pub use self::track::*;
|
||
|
||
#[cfg(feature = "lv2")] mod lv2;
|
||
#[cfg(feature = "lv2")] pub use self::lv2::*;
|
||
|
||
#[cfg(feature = "lv2_gui")] mod lv2_gui;
|
||
#[cfg(feature = "lv2_gui")] pub use self::lv2_gui::*;
|
||
|
||
#[cfg(feature = "vst2")] mod vst2;
|
||
#[cfg(feature = "vst2")] pub use self::vst2::*;
|
||
}
|
||
|
||
#[cfg(feature = "cli")] pub use self::cli::*;
|
||
#[cfg(feature = "cli")] mod cli {
|
||
use super::*;
|
||
|
||
/// Banner.
|
||
pub(crate) const HEADER: &'static str = r#"
|
||
~ █▀█▀█ █▀▀█ █ █ ~~~ ~ ~ ~~ ~ ~ ~ ~~ ~ ~ ~ ~
|
||
█ █▀ █▀▀▄ ~ heatwave is the new darkwave ~
|
||
~ ▀ █▀▀█ ▀ ▀ ~ ~~~ ~ ~ ~ ~ ~~~ ~~~ ~ ~~ "#;
|
||
|
||
pub fn show_version () {
|
||
println!("versions aint real man");
|
||
}
|
||
|
||
pub fn main_cli (config: Arc<Watch>) -> Usually<()> {
|
||
Cli::parse().run(Some(config.into()))
|
||
}
|
||
|
||
/// The command-line interface descriptor.
|
||
///
|
||
/// ```
|
||
/// let cli: tek::Cli = Default::default();
|
||
///
|
||
/// use clap::CommandFactory;
|
||
/// tek::Cli::command().debug_assert();
|
||
/// ```
|
||
#[derive(Parser, Debug, Default)]
|
||
#[command(name = "tek", version, about = Some(HEADER), long_about = Some(HEADER))]
|
||
pub struct Cli {
|
||
/// Pre-defined configuration modes.
|
||
///
|
||
/// TODO: Replace these with scripted configurations.
|
||
#[command(subcommand)]
|
||
pub action: Action,
|
||
|
||
/// Record data for performance flamegraph.
|
||
#[arg(long)]
|
||
trace: bool,
|
||
}
|
||
|
||
/// Command-line configuration.
|
||
impl Cli {
|
||
pub fn run (&self, mut config: Option<Arc<Watch>>) -> Usually<()> {
|
||
self.action.run(
|
||
config.unwrap_or_else(||Arc::new(Watch::new(None))),
|
||
self.trace
|
||
)
|
||
}
|
||
}
|
||
|
||
/// Application modes that can be passed to the mommand line interface.
|
||
///
|
||
/// ```
|
||
/// let action: tek::Action = Default::default();
|
||
/// ```
|
||
#[derive(Debug, Clone, Subcommand, Default)]
|
||
pub enum Action {
|
||
/// Continue where you left off
|
||
#[default] Resume,
|
||
/// Run headlessly in current session.
|
||
Headless,
|
||
/// Show status of current session.
|
||
Status,
|
||
/// List known sessions.
|
||
List,
|
||
/// Continue work in a copy of the current session.
|
||
Fork,
|
||
/// Create a new empty session.
|
||
New(ProjectInit),
|
||
/// Import media as new session.
|
||
Import,
|
||
/// Show configuration.
|
||
Config,
|
||
/// Show version.
|
||
Version,
|
||
}
|
||
|
||
impl Action {
|
||
fn run (&self, watch: Arc<Watch>, _trace: bool) -> Usually<()> {
|
||
use Action::*;
|
||
match self {
|
||
Version => show_version(),
|
||
Config => watch.config_print(),
|
||
Resume => todo!("resume session"),
|
||
List => todo!("list sessions"),
|
||
New(sesh) => Exit::run(|exit|Tui::run_main(
|
||
exit.clone(),
|
||
{
|
||
#[allow(unused_mut)]
|
||
let mut app = App::new(Some(exit), sesh.init()?, watch, "Menu");
|
||
app.dialog = Dialog::welcome();
|
||
#[cfg(feature = "prof2")] {
|
||
if trace {
|
||
app.guard = Some({
|
||
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
|
||
//let tracy = tracing_tracy::TracyLayer::default();
|
||
let (flame, _guard) = tracing_flame::FlameLayer::with_file("./tracing.folded").unwrap();
|
||
//let registry = tracing_subscriber::registry().with(flame).init();
|
||
//tracing::subscriber::set_global_default(registry)?;
|
||
tracing::subscriber::set_global_default(tracing_subscriber::registry().with(flame))?;
|
||
_guard
|
||
})
|
||
}
|
||
}
|
||
Arc::new(RwLock::new(app))
|
||
})).map(|_|())?,
|
||
_ => todo!()
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// Command to launch into new project from CLI.
|
||
#[derive(Debug, Clone, Parser, Default)]
|
||
pub struct ProjectInit {
|
||
/// Name of JACK client
|
||
#[arg(short='n', long)] name: Option<String>,
|
||
/// Whether to attempt to become transport master
|
||
#[arg(short='Y', long, default_value_t = false)] sync_lead: bool,
|
||
/// Whether to sync to external transport master
|
||
#[arg(short='y', long, default_value_t = true)] sync_follow: bool,
|
||
/// Initial tempo in beats per minute
|
||
#[arg(short='b', long, default_value = None)] bpm: Option<f64>,
|
||
/// Whether to include a transport toolbar (default: true)
|
||
#[arg(short='c', long, default_value_t = true)] show_clock: bool,
|
||
/// MIDI outs to connect to (multiple instances accepted)
|
||
#[arg(short='I', long)] midi_from: Vec<String>,
|
||
/// MIDI outs to connect to (multiple instances accepted)
|
||
#[arg(short='i', long)] midi_from_re: Vec<String>,
|
||
/// MIDI ins to connect to (multiple instances accepted)
|
||
#[arg(short='O', long)] midi_to: Vec<String>,
|
||
/// MIDI ins to connect to (multiple instances accepted)
|
||
#[arg(short='o', long)] midi_to_re: Vec<String>,
|
||
/// Audio outs to connect to left input
|
||
#[arg(short='l', long)] left_from: Vec<String>,
|
||
/// Audio outs to connect to right input
|
||
#[arg(short='r', long)] right_from: Vec<String>,
|
||
/// Audio ins to connect from left output
|
||
#[arg(short='L', long)] left_to: Vec<String>,
|
||
/// Audio ins to connect from right output
|
||
#[arg(short='R', long)] right_to: Vec<String>,
|
||
/// Tracks to creat
|
||
#[arg(short='t', long)] tracks: Option<usize>,
|
||
/// Scenes to create
|
||
#[arg(short='s', long)] scenes: Option<usize>,
|
||
}
|
||
|
||
impl ProjectInit {
|
||
pub fn init (&self) -> Usually<Project> {
|
||
let name = self.name.as_ref().map_or("tek", |x|x.as_str());
|
||
let jack = Jack::new(&name)?;
|
||
let midi_ins = connect_midi_ins(&jack, &"M".to_string(), &self.midi_from, Some(&self.midi_from_re))?;
|
||
let midi_out = connect_midi_outs(&jack, &"M".to_string(), &self.midi_to, Some(&self.midi_to_re))?;
|
||
let inputs = [].into_iter()
|
||
.chain(connect_audio_ins(&jack, &"L".to_string(), &self.left_from, None)?.into_iter())
|
||
.chain(connect_audio_ins(&jack, &"R".to_string(), &self.right_from, None)?.into_iter());
|
||
let outputs = [].into_iter()
|
||
.chain(connect_audio_outs(&jack, &"L".to_string(), &self.left_to, None)?.into_iter())
|
||
.chain(connect_audio_outs(&jack, &"R".to_string(), &self.right_to, None)?.into_iter());
|
||
let mut proj = Project::create(&jack, name.into(), Clock::new(&jack, self.bpm)?,
|
||
[].into_iter(), [].into_iter(), midi_ins.into_iter(), midi_out.into_iter(),
|
||
inputs, outputs);
|
||
proj.tracks_add_many(self.tracks.unwrap_or(0), None, [].into(), [].into())?;
|
||
proj.scenes_add_many(self.scenes.unwrap_or(0))?;
|
||
Ok(proj)
|
||
}
|
||
}
|
||
|
||
pub fn print_status (project: &Project) {
|
||
println!("Name: {:?}", &project.name);
|
||
println!("JACK: {:?}", &project.jack);
|
||
println!("Buffer: {:?}", &project.clock.chunk);
|
||
println!("Sample rate: {:?}", &project.clock.timebase.sr);
|
||
println!("MIDI PPQ: {:?}", &project.clock.timebase.ppq);
|
||
println!("Tempo: {:?}", &project.clock.timebase.bpm);
|
||
println!("Quantize: {:?}", &project.clock.quant);
|
||
println!("Launch: {:?}", &project.clock.sync);
|
||
println!("Playhead: {:?}us", &project.clock.playhead.usec);
|
||
println!("Playhead: {:?}s", &project.clock.playhead.sample);
|
||
println!("Playhead: {:?}p", &project.clock.playhead.pulse);
|
||
println!("Started: {:?}", &project.clock.started);
|
||
println!("Tracks:");
|
||
for (i, t) in project.tracks.iter().enumerate() {
|
||
println!(" Track {i}: {} {} {:?} {:?}", t.name, t.width,
|
||
&t.sequencer.play_clip, &t.sequencer.next_clip);
|
||
}
|
||
println!("Scenes:");
|
||
for (i, t) in project.scenes.iter().enumerate() {
|
||
println!(" Scene {i}: {} {:?}", &t.name, &t.clips);
|
||
}
|
||
println!("MIDI Ins: {:?}", &project.midi_ins);
|
||
println!("MIDI Outs: {:?}", &project.midi_outs);
|
||
println!("Audio Ins: {:?}", &project.audio_ins);
|
||
println!("Audio Outs: {:?}", &project.audio_outs);
|
||
// TODO git integration
|
||
// TODO dawvert integration
|
||
}
|
||
}
|
||
|
||
/// Define and implement a unit of time
|
||
macro_rules! impl_time_unit {
|
||
($T:ident) => {
|
||
impl TimeUnit for $T {}
|
||
impl_op!($T, Add, add, |a, b|{a + b});
|
||
impl_op!($T, Sub, sub, |a, b|{a - b});
|
||
impl_op!($T, Mul, mul, |a, b|{a * b});
|
||
impl_op!($T, Div, div, |a, b|{a / b});
|
||
impl_op!($T, Rem, rem, |a, b|{a % b});
|
||
impl_from!($T: |value: f64| { Self(value.into()) });
|
||
impl_from!($T: |value: usize| { Self((value as f64).into()) });
|
||
impl From<$T> for f64 { fn from (value: $T) -> Self { value.get() } }
|
||
impl From<&$T> for f64 { fn from (value: &$T) -> Self { value.get() } }
|
||
impl From<$T> for usize { fn from (value: $T) -> Self { value.get() as usize } }
|
||
impl From<&$T> for usize { fn from (value: &$T) -> Self { value.get() as usize } }
|
||
impl Clone for $T { fn clone (&self) -> Self { Self(self.get().into()) } }
|
||
impl $T {
|
||
pub fn get (&self) -> f64 {
|
||
self.0.load(Relaxed)
|
||
}
|
||
pub fn set (&self, value: f64) -> f64 {
|
||
let old = self.get();
|
||
self.0.store(value, Relaxed);
|
||
old
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
impl_time_unit!(SampleCount);
|
||
impl_time_unit!(SampleRate);
|
||
impl_time_unit!(Microsecond);
|
||
impl_time_unit!(Quantize);
|
||
impl_time_unit!(Ppq);
|
||
impl_time_unit!(Pulse);
|
||
impl_time_unit!(Bpm);
|
||
impl_time_unit!(LaunchSync);
|
||
|
||
/// Define a type alias for iterators of sized items (columns).
|
||
macro_rules! def_sizes_iter {
|
||
($Type:ident => $($Item:ty),+) => {
|
||
pub trait $Type<'a>: Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a {}
|
||
impl<'a, T: Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a> $Type<'a> for T {}
|
||
}
|
||
}
|
||
|
||
def_sizes_iter!(ScenesSizes => Scene);
|
||
def_sizes_iter!(TracksSizes => Track);
|
||
def_sizes_iter!(PortsSizes => Arc<str>, [Connect]);
|
||
|
||
impl_has!(Clock: |self: Track|self.sequencer.clock);
|
||
impl_default!(Timebase: Self::new(48000f64, 150f64, DEFAULT_PPQ));
|
||
|
||
primitive!(isize: try_to_isize);
|
||
primitive!(u16: try_to_u16);
|
||
primitive!(u8: try_to_u8);
|
||
primitive!(usize: try_to_usize);
|
||
|
||
impl_as_ref!(Config: |self: Config| self);
|
||
impl_as_ref!(Config: |self: Watch| &self.config);
|
||
impl_as_mut!(Config: |self: Watch| &mut self.config);
|
||
impl_as_ref!(Watch: |self: Watch| &self);
|
||
|
||
impl_debug!(MenuItem: |self, w| { write!(w, "{}", &self.0) });
|
||
impl_default!(MenuItem: Self::new("", []));
|
||
|
||
impl_as_mut!(Option<MidiEditor>: |self: Project| &mut self.editor);
|
||
impl_as_mut_opt!(Scene: |self: Project| self.selected_scene_mut());
|
||
impl_as_mut_opt!(Track: |self: Project| self.selected_track_mut());
|
||
impl_as_ref!(Option<MidiEditor>: |self: Project| &self.editor);
|
||
impl_as_ref_opt!(Scene: |self: Project| self.selected_scene());
|
||
impl_as_ref_opt!(Track: |self: Project| self.selected_track());
|
||
impl_has!(Clock: |self: Project| self.clock);
|
||
impl_has!(Jack<'static>: |self: Project| self.jack);
|
||
impl_has!(Selection: |self: Project| self.selection);
|
||
impl_has!(Sizer: |self: Project| self.size);
|
||
impl_has!(Vec<MidiInput>: |self: Project| self.midi_ins);
|
||
impl_has!(Vec<MidiOutput>: |self: Project| self.midi_outs);
|
||
|
||
impl_as_ref!(Config: |self: App|self.watch.config.as_ref());
|
||
impl_as_mut!(Option<MidiEditor>: |self: App|self.project.as_mut());
|
||
impl_as_mut!(Option<Project>: |self: App|todo!());
|
||
impl_as_ref!(Option<MidiEditor>: |self: App|self.project.as_ref());
|
||
impl_as_ref!(Option<Project>: |self: App|todo!());
|
||
impl_as_mut_opt!(Scene: |self: App|self.project.as_mut_opt());
|
||
impl_as_mut_opt!(Track: |self: App|self.project.as_mut_opt());
|
||
impl_as_ref_opt!(Scene: |self: App|self.project.as_ref_opt());
|
||
impl_as_ref_opt!(Track: |self: App|self.project.as_ref_opt());
|
||
impl_audio!(App: tek_jack_process, tek_jack_event);
|
||
|
||
impl_has!(Clock: |self: App|self.project.clock);
|
||
impl_has!(Dialog: |self: App|self.dialog);
|
||
impl_has!(Jack<'static>: |self: App|self.jack);
|
||
impl_has!(Pool<MidiClip>: |self: App|self.project.clips);
|
||
impl_has!(Pool<Sample>: |self: App|self.project.samples);
|
||
impl_has!(Selection: |self: App|self.project.selection);
|
||
impl_has!(Sizer: |self: App|self.size);
|
||
impl_has!(Vec<MidiInput>: |self: App|self.project.midi_ins);
|
||
impl_has!(Vec<MidiOutput>: |self: App|self.project.midi_outs);
|
||
|
||
impl_from!(AppCmd: |x: BrowseCmd| AppCmd::Browse { command: x });
|
||
impl_from!(AppCmd: |x: MidiClipCmd| AppCmd::MidiClip { command: x });
|
||
impl_from!(AppCmd: |x: MidiEditCmd| AppCmd::MidiEdit { command: x });
|
||
impl_from!(AppCmd: |x: ProjectCmd| AppCmd::Project { command: x });
|
||
impl_from!(AppCmd: |x: SceneCmd| AppCmd::Scene { command: x });
|
||
impl_from!(AppCmd: |x: ScenesCmd| AppCmd::Scenes { command: x });
|
||
impl_from!(AppCmd: |x: TrackCmd| AppCmd::Track { command: x });
|
||
impl_from!(AppCmd: |x: TracksCmd| AppCmd::Tracks { command: x });
|
||
|
||
tui_keys!(self: App, input {
|
||
#[cfg(feature = "prof2")] profiling::scope!("App::tui_keys!");
|
||
self.dispatch_bind(input)
|
||
});
|
||
|
||
/// The [Draw] implementation for [App] handles the loaded view,
|
||
/// which is defined in terms of [dizzle] DSL.
|
||
///
|
||
/// If there is an error, the error is displayed. FIXME: overlay it
|
||
/// Then, every top-level form of the DSL description is rendered.
|
||
impl Draw<Tui> for App {
|
||
fn draw (&self, to: &mut Tui) -> Drawn<u16> {
|
||
#[cfg(feature = "prof2")] profiling::scope!("App::draw");
|
||
self.perf.cycle(&mut |_|{
|
||
draw_error(to, self.error.as_ref())?;
|
||
draw_mode_stack(to, &self)?;
|
||
view_debug(&*self.stack.read(), &self.perf, &self.size).draw(to)?;
|
||
#[cfg(feature = "prof2")] profiling::finish_frame!();
|
||
Ok(Some(to.area().into()))
|
||
})
|
||
}
|
||
}
|