It's working

Author: andreamancuso

.gitignore

@@ -18,4 +18,11 @@ Cargo.lock
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+*.dll
+*.lib
+*.so
+*.so.*
+main
+.idea

Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "xframes-rust"
+version = "0.1.0"
+authors = ["Andrea Mancuso <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+libc = "0.2"  # If you haven't added libc already
+
+[profile.dev]
+opt-level = 0
+debug = true
+
+[profile.release]
+opt-level = 3    # Maximum optimization for performance
+debug = false
+lto = true
+panic = "abort"
+
+[[bin]]
+name = "main"
+path = "main.rs"

README.md

@@ -1 +1,3 @@
-# xframes-rust
+# xframes-rust
+
+rustc main.rs -l xframesshared -L .

assets/.gitignore

@@ -0,0 +1,4 @@
+fn main() {
+    println!("cargo:rustc-link-lib=dylib=xframesshared");
+    println!("cargo:rustc-link-search=native=./");
+}

assets/77-771550_dollar-currency-money-finance-usd-us-dollar-dollar_apzzg2.png

@@ -0,0 +1,141 @@
+use serde_json::json;
+use std::ffi::CStr;
+use std::io::{self, Write};
+use std::ffi::CString;
+use std::os::raw::{c_char, c_float, c_int};
+
+pub type OnInitCb = extern "C" fn();
+pub type OnTextChangedCb = extern "C" fn(id: c_int, text: *const c_char);
+pub type OnComboChangedCb = extern "C" fn(id: c_int, index: c_int);
+pub type OnNumericValueChangedCb = extern "C" fn(id: c_int, value: c_float);
+pub type OnBooleanValueChangedCb = extern "C" fn(id: c_int, value: bool);
+pub type OnMultipleNumericValuesChangedCb =
+extern "C" fn(id: c_int, values: *const c_float, num_values: c_int);
+pub type OnClickCb = extern "C" fn(id: c_int);
+
+
+#[link(name = "xframesshared")]
+extern "C" {
+    pub fn init(
+        assets_base_path: *const c_char,
+        raw_font_definitions: *const c_char,
+        raw_style_override_definitions: *const c_char,
+        on_init: OnInitCb,
+        on_text_changed: OnTextChangedCb,
+        on_combo_changed: OnComboChangedCb,
+        on_numeric_value_changed: OnNumericValueChangedCb,
+        on_boolean_value_changed: OnBooleanValueChangedCb,
+        on_multiple_numeric_values_changed: OnMultipleNumericValuesChangedCb,
+        on_click: OnClickCb,
+    );
+
+    fn setElement(element_json: *const libc::c_char);
+    fn setChildren(id: libc::c_int, children_ids: *const libc::c_char);
+}
+
+extern "C" fn on_init_callback() {
+    println!("Init callback called");
+
+    // For some reason `0` as integer isn't serialized / passed correctly. Same as in Free Pascal on x64-linux
+    let root_node = json!({
+        "id": 0f64,
+        "type": "node",
+        "root": true
+    });
+
+    let unformatted_text = json!({
+        "id": 1,
+        "type": "unformatted-text",
+        "text": "Hello, world"
+    });
+
+    let root_node_json = root_node.to_string();
+    let unformatted_text_json = unformatted_text.to_string();
+
+    let root_node_json_cstring = CString::new(root_node_json).expect("CString::new failed");
+    let unformatted_text_json_cstring = CString::new(unformatted_text_json).expect("CString::new failed");
+
+    let children = json!([1]);
+    let children_json = children.to_string();
+    let children_json_cstring = CString::new(children_json).expect("CString::new failed");
+
+    unsafe {
+        setElement(root_node_json_cstring.as_ptr());
+        setElement(unformatted_text_json_cstring.as_ptr());
+
+        setChildren(0, children_json_cstring.as_ptr());
+    }
+}
+
+extern "C" fn on_text_changed_callback(id: c_int, text: *const c_char) {
+    unsafe {
+        let text_str = CStr::from_ptr(text).to_string_lossy();
+        println!("Text changed (id: {}, text: {})", id, text_str);
+    }
+}
+
+extern "C" fn on_combo_changed_callback(id: c_int, index: c_int) {
+    println!("Combo changed (id: {}, index: {})", id, index);
+}
+
+extern "C" fn on_numeric_value_changed_callback(id: c_int, value: c_float) {
+    println!("Numeric value changed (id: {}, value: {})", id, value);
+}
+
+extern "C" fn on_boolean_value_changed_callback(id: c_int, value: bool) {
+    println!("Boolean value changed (id: {}, value: {})", id, value);
+}
+
+extern "C" fn on_multiple_numeric_values_changed_callback(
+    id: c_int,
+    values: *const c_float,
+    num_values: c_int,
+) {
+    unsafe {
+        let values_slice = std::slice::from_raw_parts(values, num_values as usize);
+        println!("Multiple numeric values changed (id: {}, values: {:?})", id, values_slice);
+    }
+}
+
+extern "C" fn on_click_callback(id: c_int) {
+    println!("Click callback called (id: {})", id);
+}
+
+fn main() {
+    unsafe {
+        let font_defs = json!({
+            "defs": [{
+                "name": "roboto-regular",
+                "size": 16
+            }]
+        });
+
+        let font_defs_json = font_defs.to_string();
+
+        // Prepare strings
+        let assets_base_path = CString::new("./assets").unwrap();
+        let raw_font_definitions = CString::new(font_defs_json).unwrap();
+        let raw_style_override_definitions = CString::new("{}").unwrap();
+
+        // Call init
+        init(
+            assets_base_path.as_ptr(),
+            raw_font_definitions.as_ptr(),
+            raw_style_override_definitions.as_ptr(),
+            on_init_callback,
+            on_text_changed_callback,
+            on_combo_changed_callback,
+            on_numeric_value_changed_callback,
+            on_boolean_value_changed_callback,
+            on_multiple_numeric_values_changed_callback,
+            on_click_callback,
+        );
+
+        println!("Press Enter to exit...");
+        let mut buffer = String::new();
+        io::stdout().flush().unwrap(); // Ensure the prompt is shown
+        io::stdin().read_line(&mut buffer).unwrap(); // Wait for user input
+        println!("Exiting...");
+
+    }
+}