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

midi: add pgup/pgdn; cleanup

Browse source
This commit is contained in:
🪞👃🪞 2025-04-27 16:33:00 +03:00
parent 22155f7acf
commit 397e71edee
15 changed files with 96 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

6
crates/app/src/api.rs
View file

@ -117,8 +117,8 @@ defcom!([self, app: Tek]
(Clock [cmd: ClockCommand] cmd.delegate(app, Self::Clock)?)
(Editor [cmd: MidiEditCommand] delegate_to_editor(app, cmd)?)
(Pool [cmd: PoolCommand] delegate_to_pool(app, cmd)?)
(ToggleHelp [] cmd!({ app.modal = match app.modal { Some(Modal::Help) => None, _ => Some(Modal::Help) }}))
(ToggleMenu [] cmd!({ app.modal = match app.modal { Some(Modal::Menu) => None, _ => Some(Modal::Menu) }}))
(ToggleHelp [] cmd!(app.toggle_modal(Some(Modal::Help))))
(ToggleMenu [] cmd!(app.toggle_modal(Some(Modal::Menu))))
(Color [p: ItemTheme] app.set_color(Some(p)).map(Self::Color))
(Enqueue [c: MaybeClip] cmd_todo!("\n\rtodo: enqueue {c:?}"))
(History [d: isize] cmd_todo!("\n\rtodo: history {d:?}"))
@ -144,7 +144,7 @@ defcom!([self, app: Tek]
(Stop [index: usize] cmd!(app.tracks[index].player.enqueue_next(None)))
(Add [] Some(Self::Del(app.track_add_focus()?)))
(SetColor [i: usize, c: ItemTheme] Some(Self::SetColor(i, app.track_set_color(i, c))))
(ToggleRec [] { app.track_toggle_record(); Some(Self::ToggleRec) })
(ToggleRec [] { app.track_toggle_record(); Some(Self::ToggleRec) })
(ToggleMon [] { app.track_toggle_monitor(); Some(Self::ToggleMon) }))
(SceneCommand

8
crates/app/src/model.rs
View file

@ -182,6 +182,14 @@ impl Tek {
}
}
pub fn toggle_modal (&mut self, modal: Option<Modal>) {
self.modal = if self.modal == modal {
None
} else {
modal
}
}
// Create new clip in pool when entering empty cell
pub fn clip_auto_create (&mut self) {
if let Some(ref pool) = self.pool

9
crates/cli/tek.rs
View file

@ -172,12 +172,9 @@ impl Cli {
/// CLI header
const HEADER: &'static str = r#"
░▒▓████████▓▒░▒▓███████▓▒░▒▓█▓▒░░▒▓█▓▒░░
░░░░▒▓█▓▒░░░░░▒▓█▓▒░░░░░░░▒▓█▓▒░▒▓█▓▒░░░
░░░░▒▓█▓▒░░░░░▒▓█████▓▒░░░▒▓██████▓▒░░░░
░░░░▒▓█▓▒░░░░░▒▓█▓▒░░░░░░░▒▓█▓▒░▒▓█▓▒░░░
░░░░▒▓█▓▒░░░░░▒▓█▓▒░░░░░░░▒▓█▓▒░░▒▓█▓▒░░
░░░░▒▓█▓▒░░░░░▒▓███████▓▒░▒▓█▓▒░░▒▓█▓▒░░"#;
╓─╥─╖ ╓──╖ ╥ ╖
║ ╟─╌ ╟─╡
╨ ╙──╜ ╨ ╜"#;
#[cfg(test)] #[test] fn test_cli () {
use clap::CommandFactory;

36
crates/jack/src/jack_client.rs
View file

@ -1,6 +1,7 @@
use crate::*;
use ::jack::contrib::*;
use self::JackState::*;
/// Things that can provide a [jack::Client] reference.
pub trait HasJack {
/// Return the internal [jack::Client] handle
@ -38,13 +39,25 @@ pub trait HasJack {
Ok(())
}
}
impl HasJack for Jack { fn jack (&self) -> &Jack { self } }
impl HasJack for &Jack { fn jack (&self) -> &Jack { self } }
impl HasJack for Jack {
fn jack (&self) -> &Jack {
self
}
}
impl HasJack for &Jack {
fn jack (&self) -> &Jack {
self
}
}
/// Wraps [JackState] and through it [jack::Client].
#[derive(Clone, Debug, Default)]
pub struct Jack {
state: Arc<RwLock<JackState>>
}
impl Jack {
pub fn new (name: &str) -> Usually<Self> {
Ok(Self {
@ -82,6 +95,7 @@ impl Jack {
Ok(app)
}
}
/// This is a connection which may be [Inactive], [Activating], or [Active].
/// In the [Active] and [Inactive] states, [JackState::client] returns a
/// [jack::Client], which you can use to talk to the JACK API.
@ -95,33 +109,36 @@ impl Jack {
/// After activation. Must not be dropped for JACK thread to persist.
Active(DynamicAsyncClient<'static>),
}
impl JackState {
fn new (client: Client) -> Arc<RwLock<Self>> { Arc::new(RwLock::new(Self::Inactive(client))) }
fn new (client: Client) -> Arc<RwLock<Self>> {
Arc::new(RwLock::new(Self::Inactive(client)))
}
}
//has_jack_client!(|self: JackState|match self {
//Inert => panic!("jack client not activated"),
//Inactive(ref client) => client,
//Activating => panic!("jack client has not finished activation"),
//Active(ref client) => client.as_client(),
//});
/// This is a boxed realtime callback.
pub type BoxedAudioHandler<'j> =
Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + 'j>;
/// This is the notification handler wrapper for a boxed realtime callback.
pub type DynamicAudioHandler<'j> =
ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
/// This is a boxed [JackEvent] callback.
pub type BoxedJackEventHandler<'j> =
Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
/// This is the notification handler wrapper for a boxed [JackEvent] callback.
pub type DynamicNotifications<'j> =
Notifications<BoxedJackEventHandler<'j>>;
/// This is a running JACK [AsyncClient] with maximum type erasure.
/// It has one [Box] containing a function that handles [JackEvent]s,
/// and another [Box] containing a function that handles realtime IO,
/// and that's all it knows about them.
pub type DynamicAsyncClient<'j>
= AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
/// Implement [Audio]: provide JACK callbacks.
#[macro_export] macro_rules! audio {
(|
@ -134,6 +151,7 @@ pub type DynamicAsyncClient<'j>
}
}
}
/// Trait for thing that has a JACK process callback.
pub trait Audio: Send + Sync {
fn handle (&mut self, _event: JackEvent) {}

123
crates/jack/src/jack_device.rs
View file

@ -1,4 +1,5 @@
use crate::*
/// A [AudioComponent] bound to a JACK client and a set of ports.
pub struct JackDevice<E: Engine> {
/// The active JACK client of this device.
@ -9,6 +10,7 @@ pub struct JackDevice<E: Engine> {
/// The "real" readable/writable `Port`s are owned by the `state`.
pub ports: UnownedJackPorts,
}
impl<E: Engine> std::fmt::Debug for JackDevice<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("JackDevice")
@ -16,6 +18,7 @@ impl<E: Engine> std::fmt::Debug for JackDevice<E> {
.finish()
}
}
impl<E: Engine> Render for JackDevice<E> {
type Engine = E;
fn min_size(&self, to: E::Size) -> Perhaps<E::Size> {
@ -25,11 +28,13 @@ impl<E: Engine> Render for JackDevice<E> {
self.state.read().unwrap().render(to)
}
}
impl<E: Engine> Handle<E> for JackDevice<E> {
fn handle(&mut self, from: &E::Input) -> Perhaps<E::Handled> {
self.state.write().unwrap().handle(from)
}
}
impl<E: Engine> Ports for JackDevice<E> {
fn audio_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(self.ports.audio_ins.values().collect())
@ -44,6 +49,7 @@ impl<E: Engine> Ports for JackDevice<E> {
Ok(self.ports.midi_outs.values().collect())
}
}
impl<E: Engine> JackDevice<E> {
/// Returns a locked mutex of the state's contents.
pub fn state(&self) -> LockResult<RwLockReadGuard<Box<dyn AudioComponent<E>>>> {
@ -78,120 +84,3 @@ impl<E: Engine> JackDevice<E> {
.connect_ports(self.audio_outs()?[index], port)?)
}
}
////////////////////////////////////////////////////////////////////////////////////
///// `JackDevice` factory. Creates JACK `Client`s, performs port registration
///// and activation, and encapsulates a `AudioComponent` into a `JackDevice`.
//pub struct Jack {
//pub client: Client,
//pub midi_ins: Vec<String>,
//pub audio_ins: Vec<String>,
//pub midi_outs: Vec<String>,
//pub audio_outs: Vec<String>,
//}
//impl Jack {
//pub fn new(name: &str) -> Usually<Self> {
//Ok(Self {
//midi_ins: vec![],
//audio_ins: vec![],
//midi_outs: vec![],
//audio_outs: vec![],
//client: Client::new(name, ClientOptions::NO_START_SERVER)?.0,
//})
//}
//pub fn run<'a: 'static, D, E>(
//self,
//state: impl FnOnce(JackPorts) -> Box<D>,
//) -> Usually<JackDevice<E>>
//where
//D: AudioComponent<E> + Sized + 'static,
//E: Engine + 'static,
//{
//let owned_ports = JackPorts {
//audio_ins: register_ports(&self.client, self.audio_ins, AudioIn::default())?,
//audio_outs: register_ports(&self.client, self.audio_outs, AudioOut::default())?,
//midi_ins: register_ports(&self.client, self.midi_ins, MidiIn::default())?,
//midi_outs: register_ports(&self.client, self.midi_outs, MidiOut::default())?,
//};
//let midi_outs = owned_ports
//.midi_outs
//.values()
//.map(|p| Ok(p.name()?))
//.collect::<Usually<Vec<_>>>()?;
//let midi_ins = owned_ports
//.midi_ins
//.values()
//.map(|p| Ok(p.name()?))
//.collect::<Usually<Vec<_>>>()?;
//let audio_outs = owned_ports
//.audio_outs
//.values()
//.map(|p| Ok(p.name()?))
//.collect::<Usually<Vec<_>>>()?;
//let audio_ins = owned_ports
//.audio_ins
//.values()
//.map(|p| Ok(p.name()?))
//.collect::<Usually<Vec<_>>>()?;
//let state = Arc::new(RwLock::new(state(owned_ports) as Box<dyn AudioComponent<E>>));
//let client = self.client.activate_async(
//Notifications(Box::new({
//let _state = state.clone();
//move |_event| {
//// FIXME: this deadlocks
////state.lock().unwrap().handle(&event).unwrap();
//}
//}) as Box<dyn Fn(JackEvent) + Send + Sync>),
//ClosureProcessHandler::new(Box::new({
//let state = state.clone();
//move |c: &Client, s: &ProcessScope| state.write().unwrap().process(c, s)
//}) as BoxedAudioHandler),
//)?;
//Ok(JackDevice {
//ports: UnownedJackPorts {
//audio_ins: query_ports(&client.as_client(), audio_ins),
//audio_outs: query_ports(&client.as_client(), audio_outs),
//midi_ins: query_ports(&client.as_client(), midi_ins),
//midi_outs: query_ports(&client.as_client(), midi_outs),
//},
//client,
//state,
//})
//}
//pub fn audio_in(mut self, name: &str) -> Self {
//self.audio_ins.push(name.to_string());
//self
//}
//pub fn audio_out(mut self, name: &str) -> Self {
//self.audio_outs.push(name.to_string());
//self
//}
//pub fn midi_in(mut self, name: &str) -> Self {
//self.midi_ins.push(name.to_string());
//self
//}
//pub fn midi_out(mut self, name: &str) -> Self {
//self.midi_outs.push(name.to_string());
//self
//}
//}
///// A UI component that may be associated with a JACK client by the `Jack` factory.
//pub trait AudioComponent<E: Engine>: Component<E> + Audio {
///// Perform type erasure for collecting heterogeneous devices.
//fn boxed(self) -> Box<dyn AudioComponent<E>>
//where
//Self: Sized + 'static,
//{
//Box::new(self)
//}
//}
///// All things that implement the required traits can be treated as `AudioComponent`.
//impl<E: Engine, W: Component<E> + Audio> AudioComponent<E> for W {}
/////////
/*
*/

3
crates/jack/src/jack_event.rs
View file

@ -1,4 +1,5 @@
use crate::*;
/// Event enum for JACK events.
#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
ThreadInit,
@ -12,8 +13,10 @@ use crate::*;
GraphReorder,
XRun,
}
/// Generic notification handler that emits [JackEvent]
pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
fn thread_init(&self, _: &Client) {
self.0(JackEvent::ThreadInit);

13
crates/jack/src/jack_port.rs
View file

@ -1,4 +1,5 @@
use crate::*;
macro_rules! impl_port {
($Name:ident : $Spec:ident -> $Pair:ident |$jack:ident, $name:ident|$port:expr) => {
#[derive(Debug)] pub struct $Name {
@ -73,18 +74,25 @@ macro_rules! impl_port {
}
};
}
impl_port!(JackAudioIn: AudioIn -> AudioOut |j, n|j.register_port::<AudioIn>(n));
impl_port!(JackAudioOut: AudioOut -> AudioIn |j, n|j.register_port::<AudioOut>(n));
impl_port!(JackMidiIn: MidiIn -> MidiOut |j, n|j.register_port::<MidiIn>(n));
impl_port!(JackMidiOut: MidiOut -> MidiIn |j, n|j.register_port::<MidiOut>(n));
pub trait JackPort: HasJack {
type Port: PortSpec;
type Pair: PortSpec;
fn port (&self) -> &Port<Self::Port>;
}
pub trait JackPortConnect<T>: JackPort {
fn connect_to (&self, to: T) -> Usually<PortConnectStatus>;
}
pub trait JackPortAutoconnect: JackPort + for<'a>JackPortConnect<&'a Port<Unowned>> {
fn conn (&self) -> &[PortConnect];
fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
@ -146,6 +154,7 @@ pub trait JackPortAutoconnect: JackPort + for<'a>JackPortConnect<&'a Port<Unowne
})
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum PortConnectName {
/** Exact match */
@ -153,22 +162,26 @@ pub enum PortConnectName {
/** Match regular expression */
RegExp(Arc<str>),
}
#[derive(Clone, Copy, Debug, PartialEq)] pub enum PortConnectScope {
One,
All
}
#[derive(Clone, Copy, Debug, PartialEq)] pub enum PortConnectStatus {
Missing,
Disconnected,
Connected,
Mismatch,
}
#[derive(Clone, Debug)] pub struct PortConnect {
pub name: PortConnectName,
pub scope: PortConnectScope,
pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, PortConnectStatus)>>>,
pub info: Arc<String>,
}
impl PortConnect {
pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
-> Vec<Self>

39
crates/midi/edn/keys_edit.edn
View file

@ -1,19 +1,28 @@
(@up note/pos :note-pos-next)
(@w note/pos :note-pos-next)
(@down note/pos :note-pos-prev)
(@s note/pos :note-pos-prev)
(@comma note/len :note-len-prev)
(@period note/len :note-len-next)
(@plus note/range :note-range-next-)
(@underscore note/range :note-range-prev-)
(@up note/pos :note-pos-next)
(@w note/pos :note-pos-next)
(@down note/pos :note-pos-prev)
(@s note/pos :note-pos-prev)
(@left time/pos :time-pos-prev)
(@a time/pos :time-pos-prev)
(@right time/pos :time-pos-next)
(@d time/pos :time-pos-next)
(@equal time/zoom :time-zoom-prev)
(@minus time/zoom :time-zoom-next)
(@z time/lock)
(@pgup note/pos :note-pos-next-octave)
(@pgdn note/pos :note-pos-prev-octave)
(@comma note/len :note-len-prev)
(@period note/len :note-len-next)
(@lt note/len :note-len-prev)
(@gt note/len :note-len-next)
(@plus note/range :note-range-next)
(@underscore note/range :note-range-prev)
(@left time/pos :time-pos-prev)
(@a time/pos :time-pos-prev)
(@right time/pos :time-pos-next)
(@d time/pos :time-pos-next)
(@equal time/zoom :time-zoom-prev)
(@minus time/zoom :time-zoom-next)
(@z time/lock)
(@enter note/put)
(@shift-enter note/append)

12
crates/midi/edn/keys_pool.edn
View file

@ -2,11 +2,11 @@
(@t length begin)
(@m import begin)
(@x export begin)
(@c clip color :current :random-color)
(@openbracket select :previous)
(@closebracket select :next)
(@lt swap :current :previous)
(@gt swap :current :next)
(@delete clip/delete :current)
(@c clip color :clip :random-color)
(@openbracket select :clip-prev)
(@closebracket select :clip-next)
(@lt swap :clip :clip-prev)
(@gt swap :clip :clip-next)
(@delete clip/delete :clip)
(@shift-A clip/add :after :new-clip)
(@shift-D clip/add :after :cloned-clip)

0
crates/midi/edn/piano-view-h.edn
View file

0
crates/midi/edn/piano-view-v.edn
View file

0
crates/midi/edn/view_pool.edn
View file

55
crates/midi/midi.scratch.rs
View file

@ -1,53 +1,4 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
//fn to_clips_command (state: &MidiPool, input: &Event) -> Option<PoolCommand> {
//use KeyCode::{Up, Down, Delete, Char};
//use PoolCommand as Cmd;
//let index = state.clip_index();
//let count = state.clips().len();
//Some(match input {
//kpat!(Char('n')) => Cmd::Rename(ClipRenameCommand::Begin),
//kpat!(Char('t')) => Cmd::Length(ClipLengthCommand::Begin),
//kpat!(Char('m')) => Cmd::Import(FileBrowserCommand::Begin),
//kpat!(Char('x')) => Cmd::Export(FileBrowserCommand::Begin),
//kpat!(Char('c')) => Cmd::Clip(PoolClipCommand::SetColor(index, ItemColor::random())),
//kpat!(Char('[')) | kpat!(Up) => Cmd::Select(
//index.overflowing_sub(1).0.min(state.clips().len() - 1)
//),
//kpat!(Char(']')) | kpat!(Down) => Cmd::Select(
//index.saturating_add(1) % state.clips().len()
//),
//kpat!(Char('<')) => if index > 1 {
//state.set_clip_index(state.clip_index().saturating_sub(1));
//Cmd::Clip(PoolClipCommand::Swap(index - 1, index))
//} else {
//return None
//},
//kpat!(Char('>')) => if index < count.saturating_sub(1) {
//state.set_clip_index(state.clip_index() + 1);
//Cmd::Clip(PoolClipCommand::Swap(index + 1, index))
//} else {
//return None
//},
//kpat!(Delete) => if index > 0 {
//state.set_clip_index(index.min(count.saturating_sub(1)));
//Cmd::Clip(PoolClipCommand::Delete(index))
//} else {
//return None
//},
//kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Clip(PoolClipCommand::Add(count, MidiClip::new(
//"Clip", true, 4 * PPQ, None, Some(ItemTheme::random())
//))),
//kpat!(Char('i')) => Cmd::Clip(PoolClipCommand::Add(index + 1, MidiClip::new(
//"Clip", true, 4 * PPQ, None, Some(ItemTheme::random())
//))),
//kpat!(Char('d')) | kpat!(Shift-Char('D')) => {
//let mut clip = state.clips()[index].read().unwrap().duplicate();
//clip.color = ItemTheme::random_near(clip.color, 0.25);
//Cmd::Clip(PoolClipCommand::Add(index + 1, clip))
//},
//_ => return None
//})
//}
//keymap!(KEYS_MIDI_EDITOR = |s: MidiEditor, _input: Event| MidiEditCommand {
//key(Up) => SetNoteCursor(s.note_pos() + 1),
//key(Char('w')) => SetNoteCursor(s.note_pos() + 1),
@ -74,12 +25,6 @@
//key(Char('_')) => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { NoteDuration::next(s.time_zoom().get()) }),
//key(Char('=')) => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { NoteDuration::prev(s.time_zoom().get()) }),
//key(Char('+')) => SetTimeZoom(if s.time_lock().get() { s.time_zoom().get() } else { NoteDuration::prev(s.time_zoom().get()) }),
//key(Enter) => PutNote,
//ctrl(key(Enter)) => AppendNote,
//key(Char(',')) => SetNoteLength(NoteDuration::prev(s.note_len())),
//key(Char('.')) => SetNoteLength(NoteDuration::next(s.note_len())),
//key(Char('<')) => SetNoteLength(NoteDuration::prev(s.note_len())),
//key(Char('>')) => SetNoteLength(NoteDuration::next(s.note_len())),
////// TODO: kpat!(Char('/')) => // toggle 3plet
////// TODO: kpat!(Char('?')) => // toggle dotted
//});

2
crates/midi/src/clip/clip_editor.rs
View file

@ -61,6 +61,8 @@ provide!(usize: |self: MidiEditor| {
":note-pos" => self.note_pos(),
":note-pos-next" => self.note_pos() + 1,
":note-pos-prev" => self.note_pos().saturating_sub(1),
":note-pos-next-octave" => self.note_pos() + 12,
":note-pos-prev-octave" => self.note_pos().saturating_sub(12),
":note-len" => self.note_len(),
":note-len-next" => self.note_len() + 1,