plusui-native-core 0.1.4 → 0.1.5

package/Core/Features/Window/window.ts

@@ -0,0 +1,142 @@
+export interface WindowSize {
+  width: number;
+  height: number;
+}
+
+export interface WindowPosition {
+  x: number;
+  y: number;
+}
+
+export interface WindowRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface WindowState {
+  isMinimized: boolean;
+  isMaximized: boolean;
+  isVisible: boolean;
+  isFullscreen: boolean;
+}
+
+export type WindowId = string;
+
+let _invoke: ((method: string, args?: unknown[]) => Promise<unknown>) | null = null;
+
+export function setInvokeFn(fn: (method: string, args?: unknown[]) => Promise<unknown>) {
+  _invoke = fn;
+}
+
+async function invoke(method: string, args?: unknown[]): Promise<unknown> {
+  if (!_invoke) {
+    if (typeof window !== 'undefined' && (window as any).__invoke__) {
+      _invoke = (window as any).__invoke__;
+    } else {
+      throw new Error('Window API not initialized');
+    }
+  }
+  return _invoke(method, args);
+}
+
+export const window = {
+  async minimize(id?: WindowId): Promise<void> {
+    await invoke('window.minimize', id ? [id] : []);
+  },
+
+  async maximize(id?: WindowId): Promise<void> {
+    await invoke('window.maximize', id ? [id] : []);
+  },
+
+  async restore(id?: WindowId): Promise<void> {
+    await invoke('window.restore', id ? [id] : []);
+  },
+
+  async close(id?: WindowId): Promise<void> {
+    await invoke('window.close', id ? [id] : []);
+  },
+
+  async show(id?: WindowId): Promise<void> {
+    await invoke('window.show', id ? [id] : []);
+  },
+
+  async hide(id?: WindowId): Promise<void> {
+    await invoke('window.hide', id ? [id] : []);
+  },
+
+  async center(id?: WindowId): Promise<void> {
+    await invoke('window.center', id ? [id] : []);
+  },
+
+  async setSize(width: number, height: number, id?: WindowId): Promise<void> {
+    const args = id ? [width, height, id] : [width, height];
+    await invoke('window.setSize', args);
+  },
+
+  async setPosition(x: number, y: number, id?: WindowId): Promise<void> {
+    const args = id ? [x, y, id] : [x, y];
+    await invoke('window.setPosition', args);
+  },
+
+  async setTitle(title: string, id?: WindowId): Promise<void> {
+    const args = id ? [title, id] : [title];
+    await invoke('window.setTitle', args);
+  },
+
+  async setFullscreen(enabled: boolean, id?: WindowId): Promise<void> {
+    const args = id ? [enabled, id] : [enabled];
+    await invoke('window.setFullscreen', args);
+  },
+
+  async setAlwaysOnTop(enabled: boolean, id?: WindowId): Promise<void> {
+    const args = id ? [enabled, id] : [enabled];
+    await invoke('window.setAlwaysOnTop', args);
+  },
+
+  async setResizable(enabled: boolean, id?: WindowId): Promise<void> {
+    const args = id ? [enabled, id] : [enabled];
+    await invoke('window.setResizable', args);
+  },
+
+  async setDecorations(enabled: boolean, id?: WindowId): Promise<void> {
+    const args = id ? [enabled, id] : [enabled];
+    await invoke('window.setDecorations', args);
+  },
+
+  async setTransparency(alpha: number, id?: WindowId): Promise<void> {
+    const args = id ? [alpha, id] : [alpha];
+    await invoke('window.setTransparency', args);
+  },
+
+  async getSize(id?: WindowId): Promise<WindowSize> {
+    return await invoke('window.getSize', id ? [id] : []) as Promise<WindowSize>;
+  },
+
+  async getPosition(id?: WindowId): Promise<WindowPosition> {
+    return await invoke('window.getPosition', id ? [id] : []) as Promise<WindowPosition>;
+  },
+
+  async getRect(id?: WindowId): Promise<WindowRect> {
+    return await invoke('window.getRect', id ? [id] : []) as Promise<WindowRect>;
+  },
+
+  async getState(id?: WindowId): Promise<WindowState> {
+    return await invoke('window.getState', id ? [id] : []) as Promise<WindowState>;
+  },
+
+  async isMaximized(id?: WindowId): Promise<boolean> {
+    return await invoke('window.isMaximized', id ? [id] : []) as Promise<boolean>;
+  },
+
+  async isMinimized(id?: WindowId): Promise<boolean> {
+    return await invoke('window.isMinimized', id ? [id] : []) as Promise<boolean>;
+  },
+
+  async isVisible(id?: WindowId): Promise<boolean> {
+    return await invoke('window.isVisible', id ? [id] : []) as Promise<boolean>;
+  }
+};
+
+export default window;

package/Core/Features/WindowManager/window_manager.cpp

@@ -0,0 +1,341 @@
+#include <plusui/window_manager.hpp>
+
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#else
+#include <gtk/gtk.h>
+#endif
+
+namespace plusui {
+
+struct WindowManager::Impl {
+  void *nativeWindow = nullptr;
+  bool visible = true;
+  bool maximized = false;
+  bool minimized = false;
+
+#ifdef _WIN32
+  HWND hwnd() const { return (HWND)nativeWindow; }
+#endif
+};
+
+WindowManager::WindowManager() : pImpl(std::make_unique<Impl>()) {}
+
+WindowManager::WindowManager(void *nativeWindow)
+    : pImpl(std::make_unique<Impl>()) {
+  pImpl->nativeWindow = nativeWindow;
+}
+
+WindowManager::~WindowManager() = default;
+
+void WindowManager::setTitle(const std::string &title) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    std::wstring wideTitle(title.begin(), title.end());
+    SetWindowTextW(pImpl->hwnd(), wideTitle.c_str());
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_set_title(GTK_WINDOW(pImpl->nativeWindow), title.c_str());
+  }
+#endif
+}
+
+void WindowManager::setSize(int width, int height) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    SetWindowPos(pImpl->hwnd(), nullptr, 0, 0, width, height,
+                 SWP_NOMOVE | SWP_NOZORDER);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_resize(GTK_WINDOW(pImpl->nativeWindow), width, height);
+  }
+#endif
+}
+
+WindowSize WindowManager::getSize() const {
+  WindowSize size;
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    RECT rc;
+    GetWindowRect(pImpl->hwnd(), &rc);
+    size.width = rc.right - rc.left;
+    size.height = rc.bottom - rc.top;
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gint w, h;
+    gtk_window_get_size(GTK_WINDOW(pImpl->nativeWindow), &w, &h);
+    size.width = w;
+    size.height = h;
+  }
+#endif
+  return size;
+}
+
+void WindowManager::setPosition(int x, int y) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    SetWindowPos(pImpl->hwnd(), nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_move(GTK_WINDOW(pImpl->nativeWindow), x, y);
+  }
+#endif
+}
+
+WindowPosition WindowManager::getPosition() const {
+  WindowPosition pos;
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    RECT rc;
+    GetWindowRect(pImpl->hwnd(), &rc);
+    pos.x = rc.left;
+    pos.y = rc.top;
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gint x, y;
+    gtk_window_get_position(GTK_WINDOW(pImpl->nativeWindow), &x, &y);
+    pos.x = x;
+    pos.y = y;
+  }
+#endif
+  return pos;
+}
+
+void WindowManager::setCenter() {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    RECT rc, screen;
+    GetWindowRect(pImpl->hwnd(), &rc);
+    SystemParametersInfo(SPI_GETWORKAREA, 0, &screen, 0);
+    int x = (screen.right - (rc.right - rc.left)) / 2;
+    int y = (screen.bottom - (rc.bottom - rc.top)) / 2;
+    SetWindowPos(pImpl->hwnd(), nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_set_position(GTK_WINDOW(pImpl->nativeWindow),
+                            GTK_WIN_POS_CENTER);
+  }
+#endif
+}
+
+void WindowManager::setFullscreen(bool enabled) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    if (enabled) {
+      ShowWindow(pImpl->hwnd(), SW_MAXIMIZE);
+    } else {
+      ShowWindow(pImpl->hwnd(), SW_RESTORE);
+    }
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    if (enabled) {
+      gtk_window_fullscreen(GTK_WINDOW(pImpl->nativeWindow));
+    } else {
+      gtk_window_unfullscreen(GTK_WINDOW(pImpl->nativeWindow));
+    }
+  }
+#endif
+}
+
+void WindowManager::setAlwaysOnTop(bool enabled) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    SetWindowPos(pImpl->hwnd(), enabled ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0,
+                 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_set_keep_above(GTK_WINDOW(pImpl->nativeWindow), enabled);
+  }
+#endif
+}
+
+void WindowManager::setResizable(bool enabled) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    LONG style = GetWindowLong(pImpl->hwnd(), GWL_STYLE);
+    if (enabled) {
+      style |= WS_THICKFRAME;
+    } else {
+      style &= ~WS_THICKFRAME;
+    }
+    SetWindowLong(pImpl->hwnd(), GWL_STYLE, style);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_set_resizable(GTK_WINDOW(pImpl->nativeWindow), enabled);
+  }
+#endif
+}
+
+void WindowManager::setDecorations(bool enabled) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    LONG style = GetWindowLong(pImpl->hwnd(), GWL_STYLE);
+    if (enabled) {
+      style |= WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+    } else {
+      style &= ~(WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
+    }
+    SetWindowLong(pImpl->hwnd(), GWL_STYLE, style);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_set_decorated(GTK_WINDOW(pImpl->nativeWindow), enabled);
+  }
+#endif
+}
+
+void WindowManager::setSkipTaskbar(bool enabled) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    LONG exStyle = GetWindowLong(pImpl->hwnd(), GWL_EXSTYLE);
+    if (enabled) {
+      exStyle |= WS_EX_TOOLWINDOW;
+    } else {
+      exStyle &= ~WS_EX_TOOLWINDOW;
+    }
+    SetWindowLong(pImpl->hwnd(), GWL_EXSTYLE, exStyle);
+  }
+#endif
+}
+
+void WindowManager::setTransparency(double alpha) {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    LONG exStyle = GetWindowLong(pImpl->hwnd(), GWL_EXSTYLE);
+    SetWindowLong(pImpl->hwnd(), GWL_EXSTYLE, exStyle | WS_EX_LAYERED);
+    SetLayeredWindowAttributes(pImpl->hwnd(), 0, (BYTE)(alpha * 255),
+                               LWA_ALPHA);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_widget_set_opacity(GTK_WIDGET(pImpl->nativeWindow), alpha);
+  }
+#endif
+}
+
+void WindowManager::minimize() {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    ShowWindow(pImpl->hwnd(), SW_MINIMIZE);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_iconify(GTK_WINDOW(pImpl->nativeWindow));
+  }
+#endif
+}
+
+void WindowManager::maximize() {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    ShowWindow(pImpl->hwnd(), SW_MAXIMIZE);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_maximize(GTK_WINDOW(pImpl->nativeWindow));
+  }
+#endif
+}
+
+void WindowManager::restore() {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    ShowWindow(pImpl->hwnd(), SW_RESTORE);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_unmaximize(GTK_WINDOW(pImpl->nativeWindow));
+  }
+#endif
+}
+
+void WindowManager::show() {
+  pImpl->visible = true;
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    ShowWindow(pImpl->hwnd(), SW_SHOW);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_widget_show(GTK_WIDGET(pImpl->nativeWindow));
+  }
+#endif
+}
+
+void WindowManager::hide() {
+  pImpl->visible = false;
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    ShowWindow(pImpl->hwnd(), SW_HIDE);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_widget_hide(GTK_WIDGET(pImpl->nativeWindow));
+  }
+#endif
+}
+
+void WindowManager::close() {
+#ifdef _WIN32
+  if (pImpl->nativeWindow) {
+    PostMessage(pImpl->hwnd(), WM_CLOSE, 0, 0);
+  }
+#elif defined(__APPLE__)
+  // macOS implementation
+#else
+  if (pImpl->nativeWindow) {
+    gtk_window_close(GTK_WINDOW(pImpl->nativeWindow));
+  }
+#endif
+}
+
+bool WindowManager::isMaximized() const { return pImpl->maximized; }
+
+bool WindowManager::isMinimized() const { return pImpl->minimized; }
+
+bool WindowManager::isVisible() const { return pImpl->visible; }
+
+} // namespace plusui

package/Core/include/plusui/app.hpp

@@ -0,0 +1,73 @@
+#ifndef PLUSUI_APP_H
+#define PLUSUI_APP_H
+
+#include "tray.hpp"
+#include "webview.hpp"
+#include "window_manager.hpp"
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
+
+namespace plusui {
+
+class App {
+public:
+  App();
+  ~App();
+
+  class Builder;
+
+  void run();
+  void quit();
+
+private:
+  struct Impl;
+  std::unique_ptr<Impl> pImpl;
+};
+
+class App::Builder {
+public:
+  struct Config {
+    std::string title = "PlusUI App";
+    int width = 1200;
+    int height = 800;
+    bool resizable = true;
+    bool devtools = true;
+    std::string trayIconPath;
+    std::string trayTooltip;
+    bool alwaysOnTop = false;
+    bool centered = true;
+    bool transparent = false;
+    bool decorations = true;
+    bool skipTaskbar = false;
+    bool scrollbars = true;
+  };
+
+  Builder();
+
+  Builder &title(const std::string &t);
+  Builder &width(int w);
+  Builder &height(int h);
+  Builder &resizable(bool r);
+  Builder &devtools(bool d);
+  Builder &trayIcon(const std::string &icon);
+  Builder &trayTooltip(const std::string &tooltip);
+  Builder &alwaysOnTop(bool top);
+  Builder &centered(bool center);
+  Builder &transparent(bool transparent);
+  Builder &decorations(bool decorations);
+  Builder &skipTaskbar(bool skip);
+  Builder &scrollbars(bool show);
+
+  WebView build();
+
+private:
+  Config config;
+};
+
+App::Builder createApp();
+
+} // namespace plusui
+
+#endif

package/Core/include/plusui/browser.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <map>
+
+namespace plusui {
+
+class WebView;
+
+struct BrowserState {
+    std::string url;
+    std::string title;
+    bool canGoBack = false;
+    bool canGoForward = false;
+    bool isLoading = false;
+};
+
+struct RouteConfig {
+    std::string path;
+    std::string url;
+};
+
+class Browser {
+public:
+    using NavigateCallback = std::function<void(const std::string& url)>;
+    using StateCallback = std::function<void(const BrowserState& state)>;
+    using LoadCallback = std::function<void()>;
+
+    Browser();
+    ~Browser();
+
+    static Browser create(WebView* webview);
+
+    void navigate(const std::string& url);
+    void goBack();
+    void goForward();
+    void reload();
+    void stop();
+
+    std::string getURL() const;
+    std::string getTitle() const;
+    BrowserState getState() const;
+    
+    bool canGoBack() const;
+    bool canGoForward() const;
+    bool isLoading() const;
+
+    void onNavigate(NavigateCallback callback);
+    void onStateChange(StateCallback callback);
+    void onLoadStart(LoadCallback callback);
+    void onLoadEnd(LoadCallback callback);
+    void onLoadError(std::function<void(const std::string& error)> callback);
+
+    void setRoutes(const std::map<std::string, std::string>& routes);
+    void push(const std::string& route);
+    void replace(const std::string& route);
+    std::string getCurrentRoute() const;
+
+private:
+    struct Impl;
+    std::shared_ptr<Impl> pImpl;
+};
+
+} // namespace plusui

package/Core/include/plusui/clipboard.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>
+
+namespace PlusUI {
+
+/**
+ * Clipboard - Cross-platform clipboard management
+ *
+ * Provides access to system clipboard for text and images.
+ * Supports clipboard change events.
+ */
+class Clipboard {
+public:
+    Clipboard();
+    ~Clipboard();
+
+    // Text operations
+    std::string getText();
+    void setText(const std::string& text);
+    bool hasText();
+
+    // Image operations (base64 encoded)
+    std::string getImage();
+    void setImage(const std::string& base64Data);
+    bool hasImage();
+
+    // Clear clipboard
+    void clear();
+
+    // Clipboard change events
+    void onClipboardChange(std::function<void(const std::string&)> callback);
+
+private:
+    struct Impl;
+    Impl* pImpl;
+};
+
+} // namespace PlusUI

package/Core/include/plusui/events.hpp

@@ -0,0 +1,58 @@
+// Event API - Bidirectional custom events
+#pragma once
+#include <string>
+#include <functional>
+#include <cstdint>
+#include <cstddef>
+
+namespace plusui {
+namespace event {
+
+using ListenerId = std::uint64_t;
+using EventData = std::string;
+using EventCallback = std::function<void(const EventData&)>;
+using AnyEventCallback = std::function<void(const std::string&, const EventData&)>;
+
+/**
+ * Simple Bidirectional Event System
+ * 
+ * Backend:
+ *   event::on("myEvent", callback)   // Listen for events from frontend
+ *   event::emit("myEvent", data)     // Send events to frontend
+ * 
+ * Frontend:
+ *   event.on("myEvent", callback)    // Listen for events from backend
+ *   event.emit("myEvent", data)      // Send events to backend
+ * 
+ * Users create custom events anywhere in their app - bindings auto-generated on build
+ */
+
+// Listen for events emitted from frontend
+ListenerId on(const std::string& name, EventCallback callback);
+
+// Listen once, then auto-unsubscribe
+ListenerId once(const std::string& name, EventCallback callback);
+
+// Listen to every event emitted from frontend
+ListenerId on_any(AnyEventCallback callback);
+
+// Remove a specific listener from an event
+bool off(const std::string& name, ListenerId id);
+
+// Remove a specific global listener
+bool off_any(ListenerId id);
+
+// Remove all listeners for a given event name
+std::size_t off_all(const std::string& name);
+
+// Remove all listeners in the event system
+void clear();
+
+// Emit events to frontend
+void emit(const std::string& name, const EventData& data);
+
+// Internal: Dispatch from frontend (used by binding system)
+void __dispatch_from_frontend__(const std::string& name, const EventData& data);
+
+} // namespace event
+} // namespace plusui