Add dynamic menu support. (#16)

Author: tychedelia

Cargo.lock

@@ -20,6 +20,7 @@ members = [
     "plugins/chop/python",
     "plugins/chop/wasm",
     "plugins/dat/filter",
+    "plugins/dat/dynamic_menu",
     "plugins/sop/generator-sop",
     "plugins/top/cpu-memory-top",
     "plugins/top/stable-diffusion",

Cargo.toml

@@ -1,4 +1,5 @@
 use monome::{KeyDirection, Monome, MonomeDevice, MonomeEvent};
+use td_rs_chop::cxx::OP_Inputs;
 use td_rs_chop::*;
 use td_rs_derive::{Param, Params};
 
@@ -70,7 +71,7 @@ impl Chop for MonomeGrid {
         if let Some(ref mut device) = &mut self.device {
             while let Some(event) = device.poll() {
                 match event {
-                    MonomeEvent::GridKey { x, y, direction, } => {
+                    MonomeEvent::GridKey { x, y, direction } => {
                         let index = (y * 16 + x) as usize;
                         if self.params.hold {
                             if matches!(direction, KeyDirection::Down) {

CrashAutoSave.NewProject.1.toe

@@ -0,0 +1,15 @@
+[package]
+name = "dynamic-menu"
+version = "0.1.0"
+edition = "2021"
+
+[package.metadata.td-rs]
+type = "dat"
+
+[lib]
+name = "dynamic_menu"
+crate-type = ["staticlib"]
+
+[dependencies]
+td-rs-dat = { path = "../../../td-rs-dat" }
+td-rs-derive = { path = "../../../td-rs-derive" }

plugins/chop/monome-grid/src/lib.rs

@@ -0,0 +1,91 @@
+use td_rs_dat::chop::ChopInput;
+use td_rs_dat::*;
+use td_rs_derive::{Param, Params};
+
+#[derive(Params, Default, Clone, Debug)]
+struct DynamicMenuDatParams {
+    #[param(label = "Menu")]
+    menu: DynamicMenuParam,
+}
+
+/// Struct representing our DAT's state
+pub struct DynamicMenuDat {
+    params: DynamicMenuDatParams,
+}
+
+impl OpNew for DynamicMenuDat {
+    fn new(_info: NodeInfo) -> Self {
+        Self {
+            params: Default::default(),
+        }
+    }
+}
+
+impl OpInfo for DynamicMenuDat {
+    const OPERATOR_TYPE: &'static str = "Dynamicmenu";
+    const OPERATOR_LABEL: &'static str = "Dynamic Menu";
+    const MIN_INPUTS: usize = 1;
+    // This Dat takes no input
+    const MAX_INPUTS: usize = 1;
+}
+
+impl Op for DynamicMenuDat {
+    fn params_mut(&mut self) -> Option<Box<&mut dyn OperatorParams>> {
+        Some(Box::new(&mut self.params))
+    }
+}
+
+impl Dat for DynamicMenuDat {
+    fn general_info(&self, _inputs: &OperatorInputs<DatInput>) -> DatGeneralInfo {
+        DatGeneralInfo {
+            cook_every_frame: false,
+            cook_every_frame_if_asked: false,
+        }
+    }
+
+    fn execute(&mut self, output: DatOutput, inputs: &OperatorInputs<DatInput>) {
+        if let Some(input) = inputs.input(0) {
+            match input.dat_type() {
+                DatType::Text => {
+                    if let Some(output_text) = &self.params.menu.0 {
+                        output
+                            .text()
+                            .set_text(&format!("Selected: {}", output_text));
+                    } else {
+                        output.text().set_text("");
+                    }
+                }
+                _ => self.set_warning("Input must be a text DAT"),
+            }
+        }
+    }
+
+    fn build_dynamic_menu(
+        &mut self,
+        inputs: &OperatorInputs<DatInput>,
+        menu_info: &mut DynamicMenuInfo,
+    ) {
+        if menu_info.param_name() == "Menu" {
+            if let Some(input) = inputs.input(0) {
+                match input.dat_type() {
+                    DatType::Text => {
+                        let text = input.text();
+                        let labels = text
+                            .split('\n')
+                            .map(|s| s.to_string())
+                            .collect::<Vec<String>>();
+                        for label in labels {
+                            let name = label.replace(" ", "");
+                            menu_info.add_menu_entry(&name, &label);
+                        }
+                    }
+                    _ => self.set_warning("Input must be a text DAT"),
+                }
+            }
+        }
+    }
+}
+
+impl DynamicMenuDat {}
+
+dat_plugin!(DynamicMenuDat);

plugins/dat/dynamic_menu/Cargo.toml

@@ -27,4 +27,8 @@ void releaseDownloadResult(TD::OP_SmartRef<TD::OP_TOPDownloadResult> &result) {
     result.release();
 }
 
+const char* getBuildDynamicMenuInfoNames(TD::OP_BuildDynamicMenuInfo &info) {
+    return info.name;
+}
+
 #endif // TD_RS_RUSTBASE_H

plugins/dat/dynamic_menu/src/lib.rs

@@ -16,14 +16,12 @@ TD::PY_Context* getPyContext(TD::PY_Struct *pyStruct) {
 
 void setPyInfo(TD::OP_CustomOPInfo &opInfo, void *pymethods, size_t size, void *pygetsets, size_t getsetsize) {
     if (size == 0) {
-        std::cout << "No methods" << std::endl;
         opInfo.pythonMethods = nullptr;
     } else {
         opInfo.pythonMethods = static_cast<PyMethodDef*>(pymethods);
     }
 
     if (getsetsize == 0) {
-        std::cout << "No getsets" << std::endl;
         opInfo.pythonGetSets = nullptr;
     } else {
         opInfo.pythonGetSets = static_cast<PyGetSetDef*>(pygetsets);

td-rs-base/src/RustBase.h

@@ -36,6 +36,7 @@ include_cpp! {
     generate!("TD::OP_SmartRef")
     generate_pod!("TD::OP_TextureDesc")
     generate_pod!("TD::OP_TexDim")
+    generate!("TD::OP_BuildDynamicMenuInfo")
 
     // util fns
     generate!("setString")
@@ -44,6 +45,7 @@ include_cpp! {
     generate!("getDownloadData")
     generate!("getDownloadTextureDesc")
     generate!("releaseDownloadResult")
+    generate!("getBuildDynamicMenuInfoNames")
 
     // Custom ops
     generate!("TD::OP_CustomOPInstance")

td-rs-base/src/RustPy.h

@@ -1,6 +1,7 @@
 #![feature(associated_type_defaults)]
 #![feature(min_specialization)]
 
+use crate::cxx::OP_Inputs;
 pub use param::*;
 #[cfg(feature = "python")]
 pub use py::*;
@@ -243,6 +244,30 @@ where
     }
 }
 
+pub struct DynamicMenuInfo<'cook> {
+    pub menu_info: Pin<&'cook mut cxx::OP_BuildDynamicMenuInfo>,
+}
+
+impl<'cook> DynamicMenuInfo<'cook> {
+    pub fn new(menu_info: Pin<&'cook mut cxx::OP_BuildDynamicMenuInfo>) -> Self {
+        Self { menu_info }
+    }
+
+    pub fn param_name(&mut self) -> &str {
+        let name = cxx::getBuildDynamicMenuInfoNames(self.menu_info.as_mut());
+        unsafe { ffi::CStr::from_ptr(name).to_str().unwrap() }
+    }
+
+    pub fn add_menu_entry(&mut self, name: &str, label: &str) -> bool {
+        unsafe {
+            self.menu_info.as_mut().addMenuEntry(
+                ffi::CString::new(name).unwrap().into_raw(),
+                ffi::CString::new(label).unwrap().into_raw(),
+            )
+        }
+    }
+}
+
 /// Parameter inputs to an operator.
 pub struct ParamInputs<'cook> {
     inputs: &'cook crate::cxx::OP_Inputs,
@@ -276,6 +301,11 @@ impl<'cook> ParamInputs<'cook> {
             let res = self
                 .inputs
                 .getParString(ffi::CString::new(name).unwrap().into_raw());
+
+            if res.is_null() {
+                return "";
+            }
+
             ffi::CStr::from_ptr(res).to_str().unwrap()
         }
     }