mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2025-12-06 03:36:42 +01:00
228 lines
9.2 KiB
Rust
228 lines
9.2 KiB
Rust
use crate::*;
|
|
/// A collection of input bindings.
|
|
///
|
|
/// Each contained layer defines a mapping from input event to command invocation
|
|
/// over a given state. Furthermore, each layer may have an associated cond,
|
|
/// so that only certain layers are active at a given time depending on state.
|
|
///
|
|
/// When a key is pressed, the bindings for it are checked in sequence.
|
|
/// When the first non-conditional or true conditional binding is executed,
|
|
/// that .event()binding's value is returned.
|
|
#[derive(Debug)] pub struct EventMap<E, D: Dsl>(
|
|
/// Map of each event (e.g. key combination) to
|
|
/// all command expressions bound to it by
|
|
/// all loaded input layers.
|
|
pub EventBindings<E, D>
|
|
);
|
|
type EventBindings<E, D> = BTreeMap<E, Vec<Binding<D>>>;
|
|
/// An input binding.
|
|
#[derive(Debug, Default)] pub struct Binding<D: Dsl> {
|
|
condition: Option<D>,
|
|
command: D,
|
|
description: Option<Arc<str>>,
|
|
source: Option<Arc<PathBuf>>,
|
|
}
|
|
impl<E, D: Dsl> Default for EventMap<E, D> {
|
|
fn default () -> Self {
|
|
Self(Default::default())
|
|
}
|
|
}
|
|
impl<E: Ord + Debug + From<Arc<str>> + Clone> EventMap<E, Ast> {
|
|
/// Create input layer collection from DSL.
|
|
pub fn new (dsl: Ast) -> Usually<Self> {
|
|
use Val::*;
|
|
let mut input_map: EventBindings<E, Ast> = Default::default();
|
|
match dsl.exp_head() {
|
|
Str(path) => {
|
|
let path = PathBuf::from(path.as_ref() as &str);
|
|
for (key, val) in Self::from_path(&path)?.0.into_iter() {
|
|
todo!("import {path:?} {key:?} {val:?}");
|
|
let key: E = key.into();
|
|
if !input_map.contains_key(&key) {
|
|
input_map.insert(key, vec![]);
|
|
}
|
|
}
|
|
},
|
|
Sym(s) => {
|
|
let key: Arc<str> = s.as_ref().into();
|
|
let key: E = key.into();
|
|
if !input_map.contains_key(&key) {
|
|
input_map.insert(key.clone(), vec![]);
|
|
}
|
|
todo!("binding {s:?} {:?}", dsl.exp_tail());
|
|
},
|
|
Key(k) if k.as_ref() == "if" => {
|
|
todo!("conditional binding {:?}", dsl.exp_tail());
|
|
},
|
|
_ => return Err(format!("invalid form in keymap: {dsl:?}").into())
|
|
}
|
|
Ok(Self(input_map))
|
|
}
|
|
/// Create input layer collection from string.
|
|
pub fn from_source (source: &str) -> Usually<Self> {
|
|
Self::new(Ast::from(source))
|
|
}
|
|
/// Create input layer collection from path to text file.
|
|
pub fn from_path <P: Debug + AsRef<Path>> (path: P) -> Usually<Self> {
|
|
if !exists(path.as_ref())? {
|
|
return Err(format!("(e5) not found: {path:?}").into())
|
|
}
|
|
Self::from_source(read_and_leak(path)?)
|
|
}
|
|
/// Evaluate the active layers for a given state,
|
|
/// returning the command to be executed, if any.
|
|
pub fn handle <S, O> (&self, state: &mut S, event: &E) -> Perhaps<O> where
|
|
S: DslInto<bool> + DslInto<O>,
|
|
O: Command<S>
|
|
{
|
|
todo!();
|
|
//let layers = self.0.as_slice();
|
|
//for InputLayer { cond, bind } in layers.iter() {
|
|
//let mut matches = true;
|
|
//if let Some(cond) = cond {
|
|
//matches = state.dsl_into(cond, ||format!("input: no cond").into())?;
|
|
//}
|
|
//if matches
|
|
//&& let Some(exp) = bind.val().exp_head()
|
|
//&& input.dsl_into(exp, ||format!("EventMap: input.eval(binding) failed").into())?
|
|
//&& let Some(command) = state.try_dsl_into(exp)? {
|
|
//return Ok(Some(command))
|
|
//}
|
|
//}
|
|
Ok(None)
|
|
}
|
|
/*
|
|
/// Create an input map with a single non-condal layer.
|
|
/// (Use [Default::default] to get an empty map.)
|
|
pub fn new (layer: Val<T::Str, T::Exp>) -> Self {
|
|
Self::default().layer(layer)
|
|
}
|
|
/// Add layer, return `Self`.
|
|
pub fn layer (mut self, layer: Val<T::Str, T::Exp>) -> Self {
|
|
self.add_layer(layer); self
|
|
}
|
|
/// Add condal layer, return `Self`.
|
|
pub fn layer_if (mut self, cond: Val<T::Str, T::Exp>, layer: Val<T::Str, T::Exp>) -> Self {
|
|
self.add_layer_if(Some(cond), layer); self
|
|
}
|
|
/// Add layer, return `&mut Self`.
|
|
pub fn add_layer (&mut self, layer: Val<T::Str, T::Exp>) -> &mut Self {
|
|
self.add_layer_if(None, layer.into()); self
|
|
}
|
|
/// Add condal layer, return `&mut Self`.
|
|
pub fn add_layer_if (&mut self, cond: Option<Val<T::Str, T::Exp>>, bind: Val<T::Str, T::Exp>) -> &mut Self {
|
|
self.0.push(InputLayer { cond, bind });
|
|
self
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
//let mut keys = iter.unwrap();
|
|
//let mut map = EventMap::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())
|
|
//}
|
|
//}
|
|
//Ok(map)
|
|
//}
|
|
//{
|
|
//}
|
|
//fn from (source: &'s str) -> Self {
|
|
//// this should be for single layer:
|
|
//use Val::*;
|
|
//let mut layers = vec![];
|
|
//let mut source = CstIter::from(source);
|
|
//while let Some(Exp(_, mut iter)) = source.next().map(|x|x.value) {
|
|
//let mut iter = iter.clone();
|
|
//layers.push(match iter.next().map(|x|x.value) {
|
|
//Some(Sym(sym)) if sym.starts_with("@") => InputLayer {
|
|
//cond: None,
|
|
//bind: vec![[
|
|
//dsl_val(source.nth(1).unwrap()),
|
|
//dsl_val(source.nth(2).unwrap()),
|
|
//]],
|
|
//},
|
|
//Some(Str(layer)) => InputLayer {
|
|
//cond: None,
|
|
//bind: dsl_val(source.nth(1).unwrap()),
|
|
//},
|
|
//Some(Key("if")) => InputLayer {
|
|
//cond: Some(dsl_val(source.nth(1).unwrap())),
|
|
//bind: dsl_val(source.nth(2).unwrap()),
|
|
//},
|
|
//_ => panic!("invalid token in keymap"),
|
|
//})
|
|
//}
|
|
//Self(layers)
|
|
//}
|
|
//}
|
|
|
|
fn unquote (x: &str) -> &str {
|
|
let mut chars = x.chars();
|
|
chars.next();
|
|
//chars.next_back();
|
|
chars.as_str()
|
|
}
|
|
|
|
fn read_and_leak (path: impl AsRef<Path>) -> Usually<&'static str> {
|
|
Ok(leak(String::from_utf8(std::fs::read(path.as_ref())?)?))
|
|
}
|
|
|
|
fn leak (x: impl AsRef<str>) -> &'static str {
|
|
Box::leak(x.as_ref().into())
|
|
}
|