Cyclic0007/ewwii
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: make register_function on ewwii_plugin_api register directly

Browse Source
This commit is contained in:
Byson94
2025-11-21 21:53:19 +05:30
parent 9aec974e9e
commit 1aee3163e0
8 changed files with 7 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@@ -527,7 +527,7 @@ dependencies = [
[[package]]
name = "ewwii_plugin_api"
version = "0.6.1"
version = "0.6.7"
dependencies = [
"gtk4",
"rhai",

4
crates/ewwii/src/app.rs
View File

@@ -936,9 +936,7 @@ impl<B: DisplayBackend> App<B> {
cp.borrow_mut().action_with_engine(func);
}
PluginRequest::RegisterFunc((name, func)) => {
if let Err(e) = shared_utils::slib_store::register_functions(name, func) {
log::error!("Error registering function: {}", e);
}
cp.borrow_mut().engine.register_fn(name, func);
}
PluginRequest::ListWidgetIds(res_tx) => {
let wgs_guard = wgs.lock().unwrap();

6
crates/ewwii/src/plugin.rs
View File

@@ -1,5 +1,5 @@
use ewwii_plugin_api::{widget_backend, EwwiiAPI};
use rhai::{Array, Dynamic, Engine};
use rhai::{Array, Dynamic, Engine, EvalAltResult};
use std::sync::mpsc::{channel as mpsc_channel, Receiver, Sender};
pub(crate) struct EwwiiImpl {
@@ -36,7 +36,7 @@ impl EwwiiAPI for EwwiiImpl {
fn register_function(
&self,
name: String,
f: Box<dyn Fn(Array) -> Dynamic + Send + Sync>,
f: Box<dyn Fn(Array) -> Result<Dynamic, Box<EvalAltResult>> + Send + Sync>,
) -> Result<(), String> {
let func_info = (name, f);
@@ -73,7 +73,7 @@ impl EwwiiAPI for EwwiiImpl {
pub(crate) enum PluginRequest {
RhaiEngineAct(Box<dyn FnOnce(&mut Engine) + Send>),
RegisterFunc((String, Box<dyn Fn(Array) -> Dynamic + Send + Sync>)),
RegisterFunc((String, Box<dyn Fn(Array) -> Result<Dynamic, Box<EvalAltResult>> + Send + Sync>)),
ListWidgetIds(Sender<Vec<u64>>),
WidgetRegistryAct(Box<dyn FnOnce(&mut widget_backend::WidgetRegistryRepr) + Send>),
}

2
crates/ewwii_plugin_api/src/lib.rs
View File

@@ -107,7 +107,7 @@ pub trait EwwiiAPI: Send + Sync {
fn register_function(
&self,
name: String,
f: Box<dyn Fn(rhai::Array) -> rhai::Dynamic + Send + Sync>,
f: Box<dyn Fn(rhai::Array) -> Result<rhai::Dynamic, Box<rhai::EvalAltResult>> + Send + Sync>,
) -> Result<(), String>;
// == Widget Rendering & Logic == //

5
crates/rhai_impl/src/providers/apilib/mod.rs
View File

@@ -1,20 +1,17 @@
pub mod linux;
pub mod slib;
pub mod wifi;
use rhai::exported_module;
use rhai::module_resolvers::StaticModuleResolver;
pub fn register_apilib(resolver: &mut StaticModuleResolver) {
use crate::providers::apilib::{linux::linux, slib::slib, wifi::wifi};
use crate::providers::apilib::{linux::linux, wifi::wifi};
// adding modules
let wifi_mod = exported_module!(wifi);
let linux_mod = exported_module!(linux);
let slib_mod = exported_module!(slib);
// inserting modules
resolver.insert("api::wifi", wifi_mod);
resolver.insert("api::linux", linux_mod);
resolver.insert("api::slib", slib_mod);
}

65
crates/rhai_impl/src/providers/apilib/slib.rs
View File

@@ -1,65 +0,0 @@
//! Slib, A rhai library for interacting with loaded shared libraries.
use rhai::{plugin::*, Array, Dynamic};
#[export_module]
pub mod slib {
/// Call a function registered by the currently loaded shared library
///
/// # Arguments
///
/// * `fn_name`: The name of the function to call
/// * `args`: The arguments to pass to the function (in an array)
///
/// # Returns
///
/// The result from the shared library
///
/// # Example
///
/// ```javascript
/// import "api::slib" as slib;
///
/// let eg_output = slib::call_fn("my_func", ["foo", 80, true]);
/// ```
pub fn call_fn(fn_name: String, args: Array) -> Dynamic {
match shared_utils::slib_store::call_registered(&fn_name, args) {
Ok(Some(d)) => d,
Ok(None) => Dynamic::default(),
Err(e) => {
log::error!("Error calling function: {}", e);
Dynamic::default()
}
}
}
/// List all the registered functions
///
/// # Arguments
///
/// None
///
/// # Returns
///
/// An array of strings containing the names
///
/// # Example
///
/// ```javascript
/// import "api::slib" as slib;
///
/// let eg_output = slib::list_fns();
/// print(eg_output);
/// ```
pub fn list_fns() -> Array {
match shared_utils::slib_store::list_registered() {
Ok(a) => a.into_iter().map(Dynamic::from).collect(),
Err(e) => {
log::error!("Error calling function: {}", e);
Array::new()
}
}
}
}

1
crates/shared_utils/src/lib.rs
View File

@@ -1,5 +1,4 @@
pub mod extract_props;
pub mod slib_store;
pub mod span;
pub use span::*;

31
crates/shared_utils/src/slib_store.rs
View File

@@ -1,31 +0,0 @@
use once_cell::sync::Lazy;
use rhai::{Array, Dynamic};
use std::collections::HashMap;
use std::sync::Mutex;
static FUNC_REGISTRY: Lazy<Mutex<HashMap<String, Box<dyn Fn(Array) -> Dynamic + Send + Sync>>>> =
Lazy::new(|| Mutex::new(HashMap::new()));
pub fn register_functions(
name: String,
func: Box<dyn Fn(Array) -> Dynamic + Send + Sync>,
) -> Result<(), String> {
let mut registry = FUNC_REGISTRY.lock().map_err(|e| e.to_string())?;
registry.insert(name, func);
Ok(())
}
pub fn call_registered(name: &str, args: Array) -> Result<Option<Dynamic>, String> {
let registry = FUNC_REGISTRY.lock().map_err(|e| e.to_string())?;
if let Some(func) = registry.get(name) {
Ok(Some(func(args)))
} else {
Ok(None)
}
}
pub fn list_registered() -> Result<Vec<String>, String> {
let registry = FUNC_REGISTRY.lock().map_err(|e| e.to_string())?;
Ok(registry.keys().cloned().collect())
}