Adding webui_set_root_folder (macOS)

* macOS build of (d786f6db2a)

Release/macOS/include/webui.h

@@ -12,6 +12,7 @@
 #define _WEBUI_H
 
 #define WEBUI_VERSION "2.3.0"
+#define WEBUI_MAX_IDS (512)
 
 // Dynamic Library Exports
 #if defined(_MSC_VER) || defined(__TINYC__)
@@ -71,6 +72,7 @@
     #include <fcntl.h>
     #include <poll.h>
     #include <sys/time.h>
+    #include <signal.h>
     #define WEBUI_GET_CURRENT_DIR getcwd
     #define WEBUI_FILE_EXIST access
     #define WEBUI_POPEN popen
@@ -90,6 +92,7 @@
     #include <sys/syslimits.h>
     #include <sys/time.h>
     #include <sys/sysctl.h>
+    #include <signal.h>
     #define WEBUI_GET_CURRENT_DIR getcwd
     #define WEBUI_FILE_EXIST access
     #define WEBUI_POPEN popen
@@ -130,36 +133,44 @@ enum webui_events {
 
 // -- Structs -------------------------
 typedef struct webui_event_t {
-    size_t window; // Pointer to the window object
-    unsigned int event_type; // Event type
+    size_t window; // The window object number
+    size_t event_type; // Event type
     char* element; // HTML element ID
     char* data; // JavaScript data
-    unsigned int event_number; // Internal WebUI
+    size_t event_number; // Internal WebUI
 } webui_event_t;
 
 // -- Definitions ---------------------
 // Create a new webui window object.
 WEBUI_EXPORT size_t webui_new_window(void);
+// Create a new webui window object.
+WEBUI_EXPORT void webui_new_window_id(size_t window_number);
+// Get a free window ID that can be used with `webui_new_window_id()`
+WEBUI_EXPORT size_t webui_get_new_window_id(void);
 // Bind a specific html element click event with a function. Empty element means all events.
-WEBUI_EXPORT unsigned int webui_bind(size_t window, const char* element, void (*func)(webui_event_t* e));
+WEBUI_EXPORT size_t webui_bind(size_t window, const char* element, void (*func)(webui_event_t* e));
 // Show a window using a embedded HTML, or a file. If the window is already opened then it will be refreshed.
 WEBUI_EXPORT bool webui_show(size_t window, const char* content);
 // Same as webui_show(). But with a specific web browser.
-WEBUI_EXPORT bool webui_show_browser(size_t window, const char* content, unsigned int browser);
+WEBUI_EXPORT bool webui_show_browser(size_t window, const char* content, size_t browser);
 // Set the window in Kiosk mode (Full screen)
 WEBUI_EXPORT void webui_set_kiosk(size_t window, bool status);
 // Wait until all opened windows get closed.
 WEBUI_EXPORT void webui_wait(void);
-// Close a specific window.
+// Close a specific window only. The window object will still exist.
 WEBUI_EXPORT void webui_close(size_t window);
+// Close a specific window and free all memory resources.
+WEBUI_EXPORT void webui_destroy(size_t window);
 // Close all opened windows. webui_wait() will break.
 WEBUI_EXPORT void webui_exit(void);
+// Set the web-server root folder path.
+WEBUI_EXPORT bool webui_set_root_folder(size_t window, const char* path);
 
 // -- Other ---------------------------
 // Check a specific window if it's still running
 WEBUI_EXPORT bool webui_is_shown(size_t window);
 // Set the maximum time in seconds to wait for browser to start
-WEBUI_EXPORT void webui_set_timeout(unsigned int second);
+WEBUI_EXPORT void webui_set_timeout(size_t second);
 // Set the default embedded HTML favicon
 WEBUI_EXPORT void webui_set_icon(size_t window, const char* icon, const char* icon_type);
 // Allow the window URL to be re-used in normal web browsers
@@ -167,11 +178,11 @@ WEBUI_EXPORT void webui_set_multi_access(size_t window, bool status);
 
 // -- JavaScript ----------------------
 // Run JavaScript quickly with no waiting for the response.
-WEBUI_EXPORT bool webui_run(size_t window, const char* script);
+WEBUI_EXPORT void webui_run(size_t window, const char* script);
 // Run a JavaScript, and get the response back (Make sure your local buffer can hold the response).
-WEBUI_EXPORT bool webui_script(size_t window, const char* script, unsigned int timeout, char* buffer, size_t buffer_length);
+WEBUI_EXPORT bool webui_script(size_t window, const char* script, size_t timeout, char* buffer, size_t buffer_length);
 // Chose between Deno and Nodejs runtime for .js and .ts files.
-WEBUI_EXPORT void webui_set_runtime(size_t window, unsigned int runtime);
+WEBUI_EXPORT void webui_set_runtime(size_t window, size_t runtime);
 // Parse argument as integer.
 WEBUI_EXPORT long long int webui_get_int(webui_event_t* e);
 // Parse argument as string.
@@ -181,18 +192,26 @@ WEBUI_EXPORT bool webui_get_bool(webui_event_t* e);
 // Return the response to JavaScript as integer.
 WEBUI_EXPORT void webui_return_int(webui_event_t* e, long long int n);
 // Return the response to JavaScript as string.
-WEBUI_EXPORT void webui_return_string(webui_event_t* e, char* s);
+WEBUI_EXPORT void webui_return_string(webui_event_t* e, const char* s);
 // Return the response to JavaScript as boolean.
 WEBUI_EXPORT void webui_return_bool(webui_event_t* e, bool b);
+// Base64 encoding. Use this to safely send text based data to the UI. If it fails it will return NULL.
+WEBUI_EXPORT char* webui_encode(const char* str);
+// Base64 decoding. Use this to safely decode received Base64 text from the UI. If it fails it will return NULL.
+WEBUI_EXPORT char* webui_decode(const char* str);
+// Safely free a buffer allocated by WebUI, for example when using webui_encode().
+WEBUI_EXPORT void webui_free(void* ptr);
 
 // -- Interface -----------------------
 // Bind a specific html element click event with a function. Empty element means all events. This replace webui_bind(). The func is (Window, EventType, Element, Data, EventNumber)
-WEBUI_EXPORT unsigned int webui_interface_bind(size_t window, const char* element, void (*func)(size_t, unsigned int, char*, char*, unsigned int));
+WEBUI_EXPORT size_t webui_interface_bind(size_t window, const char* element, void (*func)(size_t, size_t, char*, char*, size_t));
 // When using `webui_interface_bind()` you may need this function to easily set your callback response.
-WEBUI_EXPORT void webui_interface_set_response(size_t window, unsigned int event_number, const char* response);
+WEBUI_EXPORT void webui_interface_set_response(size_t window, size_t event_number, const char* response);
 // Check if the app still running or not. This replace webui_wait().
 WEBUI_EXPORT bool webui_interface_is_app_running(void);
 // Get window unique ID
-WEBUI_EXPORT unsigned int webui_interface_get_window_id(size_t window);
+WEBUI_EXPORT size_t webui_interface_get_window_id(size_t window);
+// Get a unique ID. Same ID as `webui_bind()`. Return > 0 if bind exist.
+WEBUI_EXPORT size_t webui_interface_get_bind_id(size_t window, const char* element);
 
 #endif /* _WEBUI_H */

Release/macOS/include/webui.hpp

@@ -13,141 +13,237 @@
 
 // C++ STD
 #include <string>
+#include <string_view>
+#include <array>
 
 // WebUI C Header
 extern "C" {
-	#include "webui.h"
+    #include "webui.h"
 }
 
 namespace webui {
 
-	// Create a new webui window object.
-	size_t new_window(void) {
-		return webui_new_window();
-	}
+    static constexpr int DISCONNECTED = 0; // 0. Window disconnection event
+    static constexpr int CONNECTED = 1; // 1. Window connection event
+    static constexpr int MULTI_CONNECTION = 2; // 2. New window connection event
+    static constexpr int UNWANTED_CONNECTION = 3; // 3. New unwanted window connection event
+    static constexpr int MOUSE_CLICK = 4; // 4. Mouse click event
+    static constexpr int NAVIGATION = 5; // 5. Window navigation event
+    static constexpr int CALLBACKS = 6; // 6. Function call event
 
-	// Bind a specific html element click event with a function. Empty element means all events.
-	unsigned int bind(size_t window, std::string element, void (*func)(webui_event_t* e)) {
-		return webui_bind(window, element.c_str(), func);
-	}
+    class window {
+    private:
+        size_t webui_window {
+            webui_new_window()
+        };
 
-	// Show a window using a embedded HTML, or a file. If the window is already opened then it will be refreshed.
-	bool show(size_t window, std::string content) {
-		return webui_show(window, content.c_str());
-	}
+    public:
+        // Event Struct
+        class event : public webui_event_t {
+            // Window object constructor that
+            // initializes the reference, This
+            // is to avoid creating copies.
+            event(webui::window& window_obj, webui_event_t c_e) : webui_event_t(c_e) {
 
-	// Same as show(). But with a specific web browser.
-	bool show_browser(size_t window, std::string content, unsigned int browser) {
-		return webui_show_browser(window, content.c_str(), browser);
-	}
+                reinterpret_cast<webui_event_t*>(this)->window = window_obj.webui_window;
+            }
+            public:
 
-	// Wait until all opened windows get closed.
-	void wait(void) {
-		webui_wait();
-	}
+            class handler {
 
-	// Close a specific window.
-	void close(size_t window) {
-		webui_close(window);
-	}
+                public:
+                using callback_t = void(*)(event*);
 
-	// Set the window in Kiosk mode (Full screen)
-	void set_kiosk(size_t window, bool status) {
-		webui_set_kiosk(window, status);
-	}
+                private:
+                static inline std::array<callback_t, 512> callback_list{};
 
-	// Close all opened windows. wait() will break.
-	void exit(void) {
-		webui_exit();
-	}
+                // List of window objects: webui::window
+                static inline std::array<webui::window*, 512> window_list{};
 
-	// -- Other ---------------------------
-	// Check a specific window if it's still running
-	bool is_shown(size_t window) {
-		return webui_is_shown(window);
-	}
+                public:
+                handler() = delete;
+                handler(const handler&) = delete;
+                handler(handler&&) = delete;
+                handler& operator = (const handler&) = delete;
+                handler& operator = (handler&&) = delete;
+                ~handler() = delete;
 
-	// Set the maximum time in seconds to wait for browser to start
-	void set_timeout(unsigned int second) {
-		webui_set_timeout(second);
-	}
+                static void add(size_t id, webui::window* win, callback_t func) {
 
-	// Set the default embedded HTML favicon
-	void set_icon(size_t window, std::string icon, std::string icon_type) {
-		webui_set_icon(window, icon.c_str(), icon_type.c_str());
-	}
+                    window_list[id] = win;
 
-	// Allow the window URL to be re-used in normal web browsers
-	void set_multi_access(size_t window, bool status) {
-		webui_set_multi_access(window, status);
-	}
+                    // Save callback
+                    callback_list[id] = func;
+                }
 
-	// -- JavaScript ----------------------
-	// Quickly run a JavaScript (no response waiting).
-	bool run(size_t window, std::string script) {
-		return webui_run(window, script.c_str());
-	}
+                static void handle(webui_event_t* c_e) {
 
-	// Run a JavaScript, and get the response back (Make sure your local buffer can hold the response).
-	bool script(size_t window, std::string script, unsigned int timeout, char* buffer, size_t buffer_length) {
-		return webui_script(window, script.c_str(), timeout, buffer, buffer_length);
-	}
+                    // Get a unique ID. Same ID as `webui_bind()`. Return > 0 if bind exist.
+                    const size_t id = webui_interface_get_bind_id(c_e->window, c_e->element);
 
-	// Chose between Deno and Nodejs runtime for .js and .ts files.
-	void set_runtime(size_t window, unsigned int runtime) {
-		webui_set_runtime(window, runtime);
-	}
+                    if(id < 1){
+                        return;
+                    }
 
-	// Parse argument as integer.
-	long long int get_int(webui_event_t* e) {
-		return webui_get_int(e);
-	}
+                    // Create a new event struct
+                    event e(*window_list[id], *c_e);
 
-	// Parse argument as string.
-	std::string get_string(webui_event_t* e) {
-		return std::string(webui_get_string(e));
-	}
+                    // Call the user callback
+                    if(callback_list[id] != nullptr)
+                        callback_list[id](&e);
+                }
 
-	// Parse argument as boolean.
-	bool get_bool(webui_event_t* e) {
-		return webui_get_bool(e);
-	}
+                static webui::window& get_window(const size_t index){
+                    return *window_list[index];
+                }
+            };
 
-	// Return the response to JavaScript as integer.
-	void return_int(webui_event_t* e, long long int n) {
-		webui_return_int(e, n);
-	}
+            // Parse argument as integer.
+            long long int get_int() {
+                return webui_get_int(this);
+            }
 
-	// Return the response to JavaScript as string.
-	void return_string(webui_event_t* e, std::string s) {
-		webui_return_string(e, &s[0]);
-	}
+            // Parse argument as string.
+            std::string get_string()  {
+                return std::string{webui_get_string(this)};
+            }
 
-	// Return the response to JavaScript as boolean.
-	void return_bool(webui_event_t* e, bool b) {
-		webui_return_bool(e, b);
-	}
+            std::string_view get_string_view()  {
+                return std::string_view{webui_get_string(this)};
+            }
 
-	// -- Interface -----------------------
-	// Bind a specific html element click event with a function. Empty element means all events. This replace bind(). The func is (Window, EventType, Element, Data, EventNumber)
-	unsigned int interface_bind(size_t window, std::string element, void (*func)(size_t, unsigned int, char*, char*, unsigned int)) {
-		return webui_interface_bind(window, element.c_str(), func);
-	}
+            // Parse argument as boolean.
+            bool get_bool()  {
+                return webui_get_bool(this);
+            }
 
-	// When using `interface_bind()` you need this function to easily set your callback response.
-	void interface_set_response(size_t window, webui_event_t* e, std::string response) {
-		webui_interface_set_response(window, e->event_number, response.c_str());
-	}
+            // Return the response to JavaScript as integer.
+            void return_int(long long int n) {
+                webui_return_int(this, n);
+            }
 
-	// Check if the app still running or not. This replace wait().
-	bool interface_is_app_running(void) {
-		return webui_interface_is_app_running();
-	}
+            // Return the response to JavaScript as string.
+            void return_string(const std::string_view s) {
+                webui_return_string(this, s.data());
+            }
 
-	// Get window unique ID
-	unsigned int interface_get_window_id(size_t window) {
-		return webui_interface_get_window_id(window);
-	}
+            // Return the response to JavaScript as boolean.
+            void return_bool(bool b) {
+                webui_return_bool(this, b);
+            }
+
+            webui::window& get_window(){
+                return event::handler::get_window(window);
+            }
+
+            size_t get_type() const {
+                return event_type;
+            }
+
+            std::string_view get_element() const {
+                return std::string_view{element};
+            }
+
+            std::string_view get_data() const {
+                return std::string_view{data};
+            }
+
+            size_t number() const {
+                return event_number;
+            }
+        };
+
+        // Bind a specific html element click event with a function. Empty element means all events.
+        void bind(const std::string_view element, event::handler::callback_t func) {
+
+            // Get unique ID
+            const size_t id = webui_bind(webui_window, element.data(), event::handler::handle);
+
+            event::handler::add(id, this, func);
+        }
+
+        // Show a window using a embedded HTML, or a file. If the window is already opened then it will be refreshed.
+        bool show(const std::string_view content) const {
+            return webui_show(webui_window, content.data());
+        }
+
+        // Same as show(). But with a specific web browser.
+        bool show_browser(const std::string_view content, unsigned int browser) const {
+            return webui_show_browser(webui_window, content.data(), browser);
+        }
+
+        // Close a specific window.
+        void close() const {
+            webui_close(webui_window);
+        }
+
+        // Set the window in Kiosk mode (Full screen)
+        void set_kiosk(bool status) const {
+            webui_set_kiosk(webui_window, status);
+        }
+
+        // -- Other ---------------------------
+        // Check a specific window if it's still running
+        bool is_shown() const {
+            return webui_is_shown(webui_window);
+        }
+
+        // Set the default embedded HTML favicon
+        void set_icon(const std::string_view icon, const std::string_view icon_type) const {
+            webui_set_icon(webui_window, icon.data(), icon_type.data());
+        }
+
+        // Allow the window URL to be re-used in normal web browsers
+        void set_multi_access(bool status) const {
+            webui_set_multi_access(webui_window, status);
+        }
+
+        // -- JavaScript ----------------------
+        // Quickly run a JavaScript (no response waiting).
+        void run(const std::string_view script) const {
+            webui_run(webui_window, script.data());
+        }
+
+        // Run a JavaScript, and get the response back (Make sure your local buffer can hold the response).
+        bool script(const std::string_view script, unsigned int timeout, char* buffer, size_t buffer_length) const {
+            return webui_script(webui_window, script.data(), timeout, buffer, buffer_length);
+        }
+
+        // Chose between Deno and Nodejs runtime for .js and .ts files.
+        void set_runtime(unsigned int runtime) const {
+            webui_set_runtime(webui_window, runtime);
+        }
+    };
+
+    // Wait until all opened windows get closed.
+    inline void wait() {
+        webui_wait();
+    }
+
+    // Close all opened windows. wait() will break.
+    inline void exit() {
+        webui_exit();
+    }
+
+    // Set the maximum time in seconds to wait for browser to start
+    inline void set_timeout(unsigned int second) {
+        webui_set_timeout(second);
+    }
+
+    // Base64 encoding. Use this to safely send text based data to the UI. If it fails it will return NULL.
+    inline std::string encode(const std::string_view str) {
+        return std::string{webui_encode(str.data())};
+    }
+
+    // Base64 decoding. Use this to safely decode received Base64 text from the UI. If it fails it will return NULL.
+    inline std::string decode(const std::string_view str) {
+        return std::string{webui_decode(str.data())};
+    }
+
+    // Safely free a buffer allocated by WebUI, for example when using webui_encode().
+    inline void free(void* ptr) {
+        webui_free(ptr);
+    }
 }
 
 #endif /* _WEBUI_HPP */