mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 11:46:41 +01:00
wip: bringing it back from the dead once again
Some checks are pending
/ build (push) Waiting to run
Some checks are pending
/ build (push) Waiting to run
This commit is contained in:
parent
45dc05acd6
commit
71c519b711
10 changed files with 530 additions and 371 deletions
|
|
@ -7,7 +7,7 @@ macro_rules! cmd_todo { ($msg:literal) => {{ println!($msg); None }}; }
|
|||
handle!(TuiIn: |self: App, input|self.handle_tui_key_with_history(input));
|
||||
impl App {
|
||||
fn handle_tui_key_with_history (&mut self, input: &TuiIn) -> Perhaps<bool> {
|
||||
Ok(if let Some(command) = self.config.keys.keybind_resolve(self, input)? {
|
||||
Ok(if let Some(command) = self.config.keys.handle(self, input)? {
|
||||
// FIXME failed commands not persisted in undo history
|
||||
let undo = command.clone().execute(self)?;
|
||||
self.history.push((command, undo));
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ pub struct App {
|
|||
/// Performance counter
|
||||
pub perf: PerfModel,
|
||||
// View and input definition
|
||||
pub config: Configuration,
|
||||
pub config: Configuration<Ast>,
|
||||
/// Contains all recently created clips.
|
||||
pub pool: Pool,
|
||||
/// Contains the currently edited musical arrangement
|
||||
|
|
@ -42,12 +42,12 @@ maybe_has!(Scene: |self: App|
|
|||
impl HasSceneScroll for App { fn scene_scroll (&self) -> usize { self.project.scene_scroll() } }
|
||||
has_clips!(|self: App|self.pool.clips);
|
||||
impl HasClipsSize for App { fn clips_size (&self) -> &Measure<TuiOut> { &self.project.inner_size } }
|
||||
take!(ClockCommand |state: App, iter|Take::take(state.clock(), iter));
|
||||
take!(MidiEditCommand |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
|
||||
take!(PoolCommand |state: App, iter|Take::take(&state.pool, iter));
|
||||
take!(SamplerCommand |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
|
||||
take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));
|
||||
take!(DialogCommand |state: App, iter|Take::take(&state.dialog, iter));
|
||||
//take!(ClockCommand |state: App, iter|Take::take(state.clock(), iter));
|
||||
//take!(MidiEditCommand |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
|
||||
//take!(PoolCommand |state: App, iter|Take::take(&state.pool, iter));
|
||||
//take!(SamplerCommand |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
|
||||
//take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));
|
||||
//take!(DialogCommand |state: App, iter|Take::take(&state.dialog, iter));
|
||||
//has_editor!(|self: App|{
|
||||
//editor = self.editor;
|
||||
//editor_w = {
|
||||
|
|
@ -319,7 +319,7 @@ impl App {
|
|||
|
||||
/// Configuration
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Configuration {
|
||||
pub struct Configuration<T: Dsl> {
|
||||
/// Path of configuration entrypoint
|
||||
pub path: PathBuf,
|
||||
/// Name of configuration
|
||||
|
|
@ -327,149 +327,100 @@ pub struct Configuration {
|
|||
/// Description of configuration
|
||||
pub info: Option<Arc<str>>,
|
||||
/// View definition
|
||||
pub view: Cst,
|
||||
pub view: T,
|
||||
// Input keymap
|
||||
pub keys: InputMap<App, AppCommand, TuiIn, Cst>,
|
||||
pub keys: EventMap<TuiEvent, T>,
|
||||
}
|
||||
|
||||
impl Configuration {
|
||||
|
||||
pub fn new (path: &impl AsRef<Path>, _watch: bool) -> Usually<Self> {
|
||||
let text = read_and_leak(path.as_ref())?;
|
||||
let [name, info, view, keys] = Self::parse(Cst::from(text))?;
|
||||
impl<T: Dsl> Configuration<T> {
|
||||
pub fn from_path (path: &impl AsRef<Path>, _watch: bool) -> Usually<Self> where T: for<'a> From<&'a str> {
|
||||
let mut dsl = T::from(read_and_leak(path.as_ref())?);
|
||||
let mut name: Option<T::Exp> = None;
|
||||
let mut info: Option<T::Exp> = None;
|
||||
let mut view: Option<T::Exp> = None;
|
||||
let mut keys: Option<T::Exp> = None;
|
||||
dsl.exp_each(|form|Ok(match form.exp_head().dsl() {
|
||||
Val::Key(key) => match key.as_ref() {
|
||||
"name" => name = Some(form.exp_tail()),
|
||||
"info" => info = Some(form.exp_tail()),
|
||||
"keys" => keys = Some(form.exp_tail()),
|
||||
"view" => view = Some(form.exp_tail()),
|
||||
_ => return Err(format!("(e3) unexpected key {key:?} in {form:?}").into())
|
||||
},
|
||||
_ => return Err(format!("(e2) unexpected exp {form :?}").into())
|
||||
}))?;
|
||||
Ok(Self {
|
||||
path: path.as_ref().into(),
|
||||
info: info.map(Self::parse_info).flatten(),
|
||||
name: name.map(Self::parse_name).flatten(),
|
||||
view: Self::parse_view(view)?,
|
||||
keys: Self::parse_keys(&path, keys)?,
|
||||
view: Self::parse_view(view)?.into(),
|
||||
keys: Self::parse_keys(&path, keys)?.into(),
|
||||
})
|
||||
}
|
||||
|
||||
fn parse (iter: Cst) -> Usually<[Option<Cst>;4]> {
|
||||
let mut name: Option<Cst> = None;
|
||||
let mut info: Option<Cst> = None;
|
||||
let mut view: Option<Cst> = None;
|
||||
let mut keys: Option<Cst> = None;
|
||||
for token in iter {
|
||||
match token.value {
|
||||
Value::Exp(_, mut exp) => {
|
||||
let next = exp.next();
|
||||
match next {
|
||||
Some(Token { value: Value::Key(sym), .. }) => match sym {
|
||||
"name" => name = Some(exp),
|
||||
"info" => info = Some(exp),
|
||||
"keys" => keys = Some(exp),
|
||||
"view" => view = Some(exp),
|
||||
_ => return Err(
|
||||
format!("(e3) unexpected symbol {sym:?}").into()
|
||||
)
|
||||
},
|
||||
_ => return Err(
|
||||
format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into()
|
||||
)
|
||||
}
|
||||
},
|
||||
t => return Err(
|
||||
format!("(e1) unexpected token {token:?}").into()
|
||||
)
|
||||
};
|
||||
}
|
||||
Ok([name, info, view, keys])
|
||||
fn parse_name (dsl: T) -> Option<Arc<str>> {
|
||||
dsl.str().map(Into::into)
|
||||
}
|
||||
|
||||
fn parse_info (mut iter: Cst) -> Option<Arc<str>> {
|
||||
iter.next().and_then(|x|if let Value::Str(x) = x.value {
|
||||
Some(x.into())
|
||||
} else {
|
||||
None
|
||||
})
|
||||
fn parse_info (dsl: T) -> Option<Arc<str>> {
|
||||
dsl.str().map(Into::into)
|
||||
}
|
||||
|
||||
fn parse_name (mut iter: Cst) -> Option<Arc<str>> {
|
||||
iter.next().and_then(|x|if let Value::Str(x) = x.value {
|
||||
Some(x.into())
|
||||
} else {
|
||||
None
|
||||
})
|
||||
fn parse_view (dsl: Option<T>) -> Usually<T> {
|
||||
match dsl { Some(view) => Ok(view), _ => Err(format!("missing view definition").into()) }
|
||||
}
|
||||
|
||||
fn parse_view (iter: Option<Cst>) -> Usually<Cst> {
|
||||
if let Some(view) = iter {
|
||||
Ok(view)
|
||||
} else {
|
||||
Err(format!("missing view definition").into())
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_keys (base: &impl AsRef<Path>, iter: Option<Cst>)
|
||||
-> Usually<InputMap<App, AppCommand, TuiIn, Cst>>
|
||||
{
|
||||
if iter.is_none() {
|
||||
fn parse_keys (base: &impl AsRef<Path>, dsl: Option<T>) -> Usually<EventMap<TuiIn, T>> {
|
||||
let mut map = EventMap::default();
|
||||
let mut keys = if let Some(keys) = dsl { keys } else {
|
||||
return Err(format!("missing keys definition").into())
|
||||
}
|
||||
let mut keys = iter.unwrap();
|
||||
let mut map = InputMap::default();
|
||||
while let Some(token) = keys.next() {
|
||||
if let Value::Exp(_, mut exp) = token.value {
|
||||
let next = exp.next();
|
||||
if let Some(Token { value: Value::Key(sym), .. }) = next {
|
||||
match sym {
|
||||
"layer" => {
|
||||
if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
|
||||
let path = base.as_ref().parent().unwrap().join(unquote(path));
|
||||
if !std::fs::exists(&path)? {
|
||||
return Err(format!("(e5) not found: {path:?}").into())
|
||||
}
|
||||
map.add_layer(read_and_leak(path)?.into());
|
||||
print!("layer:\n path: {:?}...", exp.0.0.trim());
|
||||
println!("ok");
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-string {next:?}").into())
|
||||
}
|
||||
},
|
||||
|
||||
"layer-if" => {
|
||||
let mut cond = None;
|
||||
|
||||
if let Some(Token { value: Value::Sym(sym), .. }) = exp.next() {
|
||||
cond = Some(leak(sym));
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
||||
};
|
||||
|
||||
if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
|
||||
let path = base.as_ref().parent().unwrap().join(unquote(path));
|
||||
if !std::fs::exists(&path)? {
|
||||
return Err(format!("(e5) not found: {path:?}").into())
|
||||
}
|
||||
print!("layer-if:\n cond: {}\n path: {path:?}...",
|
||||
cond.unwrap_or_default());
|
||||
let keys = read_and_leak(path)?.into();
|
||||
let cond = cond.unwrap();
|
||||
println!("ok");
|
||||
map.add_layer_if(
|
||||
Box::new(move |state: &App|Take::take_or_fail(
|
||||
state, exp, ||"missing input layer conditional"
|
||||
)), keys
|
||||
);
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
||||
}
|
||||
},
|
||||
|
||||
_ => return Err(format!("(e3) unexpected symbol {sym:?}").into())
|
||||
}
|
||||
} else {
|
||||
return Err(format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into())
|
||||
}
|
||||
} else {
|
||||
return Err(format!("(e1) unexpected token {token:?}").into())
|
||||
}
|
||||
}
|
||||
};
|
||||
keys.exp_each(|form|Ok(match form.exp_head().dsl() {
|
||||
Val::Sym(s) if s.as_ref() == "layer" =>
|
||||
Self::parse_keys_layer(&mut map, base, form.exp_tail()),
|
||||
Val::Sym(s) if s.as_ref() == "layer-if" =>
|
||||
Self::parse_keys_layer_if(&mut map, base, form.exp_tail()),
|
||||
x =>
|
||||
return Err(format!("(e3) unexpected {x:?} in {form:?}").into())
|
||||
}))?;
|
||||
Ok(map)
|
||||
}
|
||||
fn parse_keys_layer (map: &mut EventMap<TuiIn, T>, base: &impl AsRef<Path>, exp: &T) {
|
||||
let next = exp.peek().map(|x|x.val());
|
||||
if let Some(Val::Str(path)) = next {
|
||||
let path = base.as_ref().parent().unwrap().join(unquote(path));
|
||||
if !std::fs::exists(&path)? {
|
||||
return Err(format!("(e5) not found: {path:?}").into())
|
||||
}
|
||||
map.add_layer(read_and_leak(path)?.into());
|
||||
print!("layer:\n path: {:?}...", exp.0.0.trim());
|
||||
println!("ok");
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-string {next:?}").into())
|
||||
}
|
||||
}
|
||||
fn parse_keys_layer_if (map: &mut EventMap<TuiIn, T>, base: &impl AsRef<Path>, exp: &T) {
|
||||
let next = exp.next().map(|x|x.val());
|
||||
let cond = if let Some(Val::Sym(sym)) = next {
|
||||
leak(sym)
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
||||
};
|
||||
|
||||
let next = exp.peek().map(|x|x.val());
|
||||
if let Some(Val::Str(path)) = next {
|
||||
let path = base.as_ref().parent().unwrap().join(unquote(path));
|
||||
if !std::fs::exists(&path)? {
|
||||
return Err(format!("(e5) not found: {path:?}").into())
|
||||
}
|
||||
print!("layer-if:\n cond: {cond}\n path: {path:?}...");
|
||||
let keys = read_and_leak(path)?.into();
|
||||
println!("ok");
|
||||
//map.add_layer_if(
|
||||
//Box::new(move |state: &App|Take::take_or_fail(
|
||||
//state, exp, ||"missing input layer conditional"
|
||||
//)), keys
|
||||
//);
|
||||
} else {
|
||||
return Err(format!("(e4) unexpected non-symbol {next:?}").into())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn read_and_leak (path: impl AsRef<Path>) -> Usually<&'static str> {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue