53 lines
1.5 KiB
Rust
53 lines
1.5 KiB
Rust
//! `Executable` is a property to execute a closure
|
|
|
|
use anyhow::Result;
|
|
use ecs::*;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
use crate::prelude::*;
|
|
|
|
/// `Executable` holds a closure which can be executed
|
|
pub struct Executable<I: Send + Sync> {
|
|
callback:
|
|
RwLock<Option<Arc<dyn Fn(&mut Commands, &mut GuiHandler, I) -> Result<()> + Send + Sync>>>,
|
|
}
|
|
|
|
impl<I: Send + Sync + 'static> Executable<I> {
|
|
/// Factory method for `Executable`, returns `Arc<Executable>`
|
|
pub fn new() -> Arc<Self> {
|
|
Arc::new(Executable {
|
|
callback: RwLock::new(None),
|
|
})
|
|
}
|
|
|
|
/// Set callback closure
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `callback` is a `Option<Callback>` closure
|
|
pub fn set_callback<F>(&self, callback: impl Into<Option<F>>)
|
|
where
|
|
F: Fn(&mut Commands, &mut GuiHandler, I) -> Result<()> + Send + Sync + 'static,
|
|
{
|
|
let mut function = self.callback.write().unwrap();
|
|
|
|
match callback.into() {
|
|
Some(f) => *function = Some(Arc::new(f)),
|
|
None => *function = None,
|
|
}
|
|
}
|
|
|
|
/// Execute the callback closure if possible
|
|
pub fn execute(&self, gui_handler: &mut GuiHandler, input: I) -> Result<()> {
|
|
if let Some(callback) = self.callback.read().unwrap().as_ref() {
|
|
let callback = callback.clone();
|
|
|
|
gui_handler.add_callback(move |commands, gui_handler| {
|
|
(callback)(commands, gui_handler, input)
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|