plusui-native-core 0.1.4 → 0.1.7

package/Core/CMakeLists.txt

@@ -5,11 +5,33 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
+# ============================================================
+# WebGPU (Optional - disabled by default)
+# ============================================================
+option(PLUSUI_ENABLE_WEBGPU "Enable WebGPU support via Dawn" OFF)
+
+# Platform detection
+if(WIN32)
+    add_definitions(-DPLUSUI_EDGE)
+elseif(APPLE)
+    add_definitions(-DPLUSUI_COCOA)
+else()
+    add_definitions(-DPLUSUI_GTK)
+endif()
+
 add_library(plusui STATIC
-    src/app.cpp
-    src/window.cpp
-    src/display.cpp
-    src/tray.cpp
+    Features/App/app.cpp
+    Features/Window/window.cpp
+    Features/WindowManager/window_manager.cpp
+    Features/WebView/webview.cpp
+    Features/Browser/browser.cpp
+    Features/Display/display.cpp
+    Features/Tray/tray.cpp
+    Features/Clipboard/clipboard.cpp
+    Features/Menu/menu.cpp
+    Features/Keyboard/keyboard.cpp
+    Features/Event/events.cpp
+    Features/WebGPU/webgpu.cpp
 )
 
 target_include_directories(plusui PUBLIC
@@ -18,16 +40,177 @@ target_include_directories(plusui PUBLIC
     $<INSTALL_INTERFACE:include>
 )
 
-target_compile_definitions(plusui PUBLIC WEBVIEW_HEADER)
+# Define WEBVIEW_EDGE on Windows to enable WebView2 backend
+if(WIN32)
+    target_compile_definitions(plusui PUBLIC WEBVIEW_EDGE)
+endif()
 target_compile_options(plusui PRIVATE
-    $<$<CXX_COMPILER_ID:MSVC>:/W4 /utf-8>
+    $<$<CXX_COMPILER_ID:MSVC>:/W4 /utf-8 /FS>
     $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra>
 )
 
 find_package(Threads REQUIRED)
+target_link_libraries(plusui PRIVATE Threads::Threads)
+
+# ============================================================
+# WebGPU: Dawn Library (Optional)
+# ============================================================
+if(PLUSUI_ENABLE_WEBGPU)
+    include(FetchContent)
+
+    set(DAWN_FETCH_DEPENDENCIES ON)
+    set(DAWN_BUILD_SAMPLES OFF)
+    set(DAWN_BUILD_TESTS OFF)
+    if(WIN32)
+        set(DAWN_ENABLE_D3D12 ON)
+        set(DAWN_ENABLE_METAL OFF)
+        set(DAWN_ENABLE_VULKAN OFF)
+        set(DAWN_USE_X11 OFF)
+    elseif(APPLE)
+        set(DAWN_ENABLE_D3D12 OFF)
+        set(DAWN_ENABLE_METAL ON)
+        set(DAWN_ENABLE_VULKAN OFF)
+        set(DAWN_USE_X11 OFF)
+    else()
+        set(DAWN_ENABLE_D3D12 OFF)
+        set(DAWN_ENABLE_METAL OFF)
+        set(DAWN_ENABLE_VULKAN ON)
+        set(DAWN_USE_X11 ON)
+    endif()
+
+    FetchContent_Declare(
+        dawn
+        GIT_REPOSITORY https://dawn.googlesource.com/dawn
+        GIT_TAG        d41e7df926f0d84ca64262cffa7f3a0ddc56c53c
+        GIT_SHALLOW    TRUE
+        TIMEOUT        600
+    )
+
+    message(STATUS "Fetching Dawn WebGPU library...")
+    FetchContent_MakeAvailable(dawn)
+
+    target_link_libraries(plusui PUBLIC
+        dawncpp
+        dawn_native
+        dawn_proc
+    )
+
+    target_include_directories(plusui PUBLIC
+        ${dawn_SOURCE_DIR}/include
+        ${dawn_BINARY_DIR}/gen/include
+    )
+
+    target_compile_definitions(plusui PUBLIC PLUSUI_WEBGPU_ENABLED)
+    message(STATUS "WebGPU support enabled via Dawn")
+else()
+    message(STATUS "WebGPU support disabled (set PLUSUI_ENABLE_WEBGPU=ON to enable)")
+endif()
 
+# ============================================================
+# Windows: WebView2 SDK
+# ============================================================
 if(WIN32)
-    find_package(WebView2 QUIET)
+    include(FetchContent)
+
+    # Download Microsoft WebView2 SDK
+    FetchContent_Declare(
+        webview2
+        URL https://www.nuget.org/api/v2/package/Microsoft.Web.WebView2/1.0.2210.55
+        URL_HASH SHA256=482d0b55f78a9a90fe4a03e66b5ba5d0dc4b9b55dfe9e9e4e3f3e6e6e3e3e3e3e
+        DOWNLOAD_NO_EXTRACT FALSE
+    )
+
+    # Check if already downloaded, if not use alternative method
+    set(WEBVIEW2_DIR "${CMAKE_BINARY_DIR}/_deps/webview2")
+
+    if(NOT EXISTS "${WEBVIEW2_DIR}/build/native/include/WebView2.h")
+        message(STATUS "Downloading WebView2 SDK...")
+
+        # Create directory
+        file(MAKE_DIRECTORY "${WEBVIEW2_DIR}")
+
+        # Download the NuGet package
+        set(WEBVIEW2_NUGET_URL "https://www.nuget.org/api/v2/package/Microsoft.Web.WebView2/1.0.2210.55")
+        set(WEBVIEW2_ZIP "${WEBVIEW2_DIR}/webview2.zip")
+
+        if(NOT EXISTS "${WEBVIEW2_ZIP}")
+            file(DOWNLOAD
+                "${WEBVIEW2_NUGET_URL}"
+                "${WEBVIEW2_ZIP}"
+                SHOW_PROGRESS
+                STATUS DOWNLOAD_STATUS
+            )
+            list(GET DOWNLOAD_STATUS 0 STATUS_CODE)
+            if(NOT STATUS_CODE EQUAL 0)
+                message(WARNING "Failed to download WebView2 SDK. Trying alternative...")
+                # Try alternative URL
+                file(DOWNLOAD
+                    "https://globalcdn.nuget.org/packages/microsoft.web.webview2.1.0.2210.55.nupkg"
+                    "${WEBVIEW2_ZIP}"
+                    SHOW_PROGRESS
+                )
+            endif()
+        endif()
+
+        # Extract the package
+        if(EXISTS "${WEBVIEW2_ZIP}" AND NOT EXISTS "${WEBVIEW2_DIR}/build")
+            message(STATUS "Extracting WebView2 SDK...")
+            execute_process(
+                COMMAND ${CMAKE_COMMAND} -E tar xzf "${WEBVIEW2_ZIP}"
+                WORKING_DIRECTORY "${WEBVIEW2_DIR}"
+            )
+        endif()
+    endif()
+
+    # Add WebView2 include directory
+    if(EXISTS "${WEBVIEW2_DIR}/build/native/include")
+        target_include_directories(plusui PUBLIC "${WEBVIEW2_DIR}/build/native/include")
+        message(STATUS "WebView2 SDK found at: ${WEBVIEW2_DIR}/build/native/include")
+    else()
+        message(WARNING "WebView2 SDK headers not found. Please install WebView2 SDK manually.")
+    endif()
+
+    # Link required Windows libraries
+    target_link_libraries(plusui PRIVATE
+        ole32
+        shell32
+        shlwapi
+        user32
+        version
+        advapi32
+    )
+
+    # Link WebView2 loader library
+    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+        set(WEBVIEW2_ARCH "x64")
+    else()
+        set(WEBVIEW2_ARCH "x86")
+    endif()
+
+    set(WEBVIEW2_LIB "${WEBVIEW2_DIR}/build/native/${WEBVIEW2_ARCH}/WebView2LoaderStatic.lib")
+    if(EXISTS "${WEBVIEW2_LIB}")
+        target_link_libraries(plusui PUBLIC "${WEBVIEW2_LIB}")
+    else()
+        # Try the loader DLL approach
+        set(WEBVIEW2_LOADER_LIB "${WEBVIEW2_DIR}/build/native/${WEBVIEW2_ARCH}/WebView2Loader.dll.lib")
+        if(EXISTS "${WEBVIEW2_LOADER_LIB}")
+            target_link_libraries(plusui PUBLIC "${WEBVIEW2_LOADER_LIB}")
+        endif()
+    endif()
+
+elseif(APPLE)
+    # macOS: WebKit frameworks
+    find_library(WEBKIT_LIBRARY WebKit REQUIRED)
+    find_library(COCOA_LIBRARY Cocoa REQUIRED)
+    target_link_libraries(plusui PRIVATE ${WEBKIT_LIBRARY} ${COCOA_LIBRARY})
+
+else()
+    # Linux: GTK + WebKitGTK
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
+    pkg_check_modules(WEBKIT2 REQUIRED webkit2gtk-4.0)
+    target_include_directories(plusui PRIVATE ${GTK3_INCLUDE_DIRS} ${WEBKIT2_INCLUDE_DIRS})
+    target_link_libraries(plusui PRIVATE ${GTK3_LIBRARIES} ${WEBKIT2_LIBRARIES})
 endif()
 
 install(TARGETS plusui ARCHIVE DESTINATION lib)

package/Core/Features/App/app.cpp

@@ -0,0 +1,129 @@
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include <plusui/app.hpp>
+#include <plusui/tray.hpp>
+#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
+#include <plusui/window_manager.hpp>
+
+namespace plusui {
+
+struct App::Impl {
+  bool running = false;
+};
+
+App::App() : pImpl(std::make_unique<Impl>()) {}
+App::~App() = default;
+
+void App::run() {
+  pImpl->running = true;
+#ifdef _WIN32
+  MSG msg;
+  while (GetMessage(&msg, nullptr, 0, 0)) {
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+#endif
+}
+
+void App::quit() {
+  pImpl->running = false;
+#ifdef _WIN32
+  PostQuitMessage(0);
+#endif
+}
+
+App::Builder::Builder() = default;
+
+App::Builder &App::Builder::title(const std::string &t) {
+  config.title = t;
+  return *this;
+}
+App::Builder &App::Builder::width(int w) {
+  config.width = w;
+  return *this;
+}
+App::Builder &App::Builder::height(int h) {
+  config.height = h;
+  return *this;
+}
+App::Builder &App::Builder::resizable(bool r) {
+  config.resizable = r;
+  return *this;
+}
+App::Builder &App::Builder::devtools(bool d) {
+  config.devtools = d;
+  return *this;
+}
+App::Builder &App::Builder::trayIcon(const std::string &icon) {
+  config.trayIconPath = icon;
+  return *this;
+}
+App::Builder &App::Builder::trayTooltip(const std::string &tooltip) {
+  config.trayTooltip = tooltip;
+  return *this;
+}
+App::Builder &App::Builder::alwaysOnTop(bool top) {
+  config.alwaysOnTop = top;
+  return *this;
+}
+App::Builder &App::Builder::centered(bool center) {
+  config.centered = center;
+  return *this;
+}
+App::Builder &App::Builder::transparent(bool transparent) {
+  config.transparent = transparent;
+  return *this;
+}
+App::Builder &App::Builder::decorations(bool decorations) {
+  config.decorations = decorations;
+  return *this;
+}
+App::Builder &App::Builder::skipTaskbar(bool skip) {
+  config.skipTaskbar = skip;
+  return *this;
+}
+App::Builder &App::Builder::scrollbars(bool show) {
+  config.scrollbars = show;
+  return *this;
+}
+
+WebView App::Builder::build() {
+  WindowConfig winConfig;
+  winConfig.title = config.title;
+  winConfig.width = config.width;
+  winConfig.height = config.height;
+  winConfig.resizable = config.resizable;
+  winConfig.alwaysOnTop = config.alwaysOnTop;
+  winConfig.center = config.centered;
+  winConfig.transparent = config.transparent;
+  winConfig.decorations = config.decorations;
+  winConfig.skipTaskbar = config.skipTaskbar;
+
+  auto win = std::make_shared<Window>(Window::create(winConfig));
+  win->show();
+
+  WebViewConfig webConfig;
+  webConfig.devtools = config.devtools;
+  webConfig.scrollbars = config.scrollbars;
+
+  WebView wv = WebView::create(win->nativeHandle(), webConfig);
+  wv.setWindow(win);
+
+  if (!config.trayIconPath.empty()) {
+    wv.tray().setIcon(config.trayIconPath);
+    wv.tray().setVisible(true);
+    if (!config.trayTooltip.empty()) {
+      wv.tray().setTooltip(config.trayTooltip);
+    }
+  }
+
+  return wv;
+}
+
+App::Builder createApp() { return App::Builder(); }
+
+} // namespace plusui

package/Core/Features/App/app.ts

@@ -0,0 +1,126 @@
+export interface AppConfig {
+  title?: string;
+  width?: number;
+  height?: number;
+  resizable?: boolean;
+  devtools?: boolean;
+  trayIcon?: string;
+  trayTooltip?: string;
+  alwaysOnTop?: boolean;
+  centered?: boolean;
+  transparent?: boolean;
+  decorations?: boolean;
+  skipTaskbar?: boolean;
+}
+
+export interface InvokeOptions {
+  timeout?: number;
+}
+
+export class App {
+  private initialized = false;
+
+  constructor(
+    private config: AppConfig = {},
+    private invokeFn?: (name: string, args?: unknown[]) => Promise<unknown>
+  ) {
+    if (typeof window !== 'undefined') {
+      this.init();
+    }
+  }
+
+  private init(): void {
+    if (this.initialized) return;
+    this.initialized = true;
+
+    if (typeof window !== 'undefined') {
+      const win = window as Window & {
+        __plusui_listeners__?: Map<string, Set<(...args: unknown[]) => void>>;
+      };
+
+      win.__plusui_listeners__ = new Map();
+
+      window.addEventListener('message', (event: MessageEvent) => {
+        if (event.data?.type === '__plusui_event__') {
+          const { event: eventName, payload } = event.data;
+          const listeners = win.__plusui_listeners__?.get(eventName);
+          if (listeners) {
+            listeners.forEach(cb => cb(payload));
+          }
+        }
+      });
+    }
+  }
+
+  async invoke<T = unknown>(name: string, args?: unknown[], options: InvokeOptions = {}): Promise<T> {
+    const { timeout = 30000 } = options;
+
+    if (this.invokeFn) {
+      return this.invokeFn(name, args) as Promise<T>;
+    }
+
+    if (typeof window !== 'undefined') {
+      const win = window as Window & {
+        __plusui_invoke__?: (name: string, args?: unknown[]) => Promise<unknown>;
+        __invoke__?: (name: string, args?: unknown[]) => Promise<unknown>;
+        __native_invoke__?: (request: string) => void;
+      };
+      // Check for SDK bridge first (__invoke__ from plusui-native-core)
+      if (win.__invoke__) {
+        return win.__invoke__(name, args) as Promise<T>;
+      }
+      // Check for legacy __plusui_invoke__
+      if (win.__plusui_invoke__) {
+        return win.__plusui_invoke__(name, args) as Promise<T>;
+      }
+    }
+
+    return new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Invocation ${name} timed out`)), timeout);
+    });
+  }
+
+  on(event: string, callback: (...args: unknown[]) => void): () => void {
+    if (typeof window === 'undefined') {
+      return () => { };
+    }
+
+    const win = window as Window & {
+      __plusui_listeners__?: Map<string, Set<(...args: unknown[]) => void>>;
+    };
+
+    if (!win.__plusui_listeners__) {
+      win.__plusui_listeners__ = new Map();
+    }
+
+    if (!win.__plusui_listeners__.has(event)) {
+      win.__plusui_listeners__.set(event, new Set());
+    }
+
+    win.__plusui_listeners__.get(event)!.add(callback);
+
+    return () => {
+      win.__plusui_listeners__.get(event)?.delete(callback);
+    };
+  }
+
+  once(event: string, callback: (...args: unknown[]) => void): void {
+    const unsubscribe = this.on(event, (...args) => {
+      unsubscribe();
+      callback(...args);
+    });
+  }
+
+  emit(event: string, payload?: unknown): void {
+    if (typeof window !== 'undefined') {
+      const customEvent = new CustomEvent(event, { detail: payload });
+      window.dispatchEvent(customEvent);
+    }
+  }
+}
+
+export function createApp(config?: AppConfig): App {
+  return new App(config);
+}
+
+export default App;

package/Core/Features/Browser/browser.cpp

@@ -0,0 +1,181 @@
+#include <iostream>
+#include <plusui/browser.hpp>
+#include <plusui/webview.hpp>
+
+namespace plusui {
+
+struct Browser::Impl {
+    WebView* webview = nullptr;
+    std::map<std::string, std::string> routes;
+    std::string currentRoute;
+    BrowserState state;
+    
+    std::vector<NavigateCallback> navigateCallbacks;
+    std::vector<StateCallback> stateCallbacks;
+    std::vector<LoadCallback> loadStartCallbacks;
+    std::vector<LoadCallback> loadEndCallbacks;
+    std::vector<std::function<void(const std::string&)>> loadErrorCallbacks;
+    
+    void updateState() {
+        if (webview) {
+            state.url = webview->getURL();
+            state.title = webview->getTitle();
+            state.canGoBack = webview->canGoBack();
+            state.canGoForward = webview->canGoForward();
+            state.isLoading = webview->isLoading();
+            
+            for (auto& cb : stateCallbacks) {
+                cb(state);
+            }
+        }
+    }
+    
+    void notifyNavigate(const std::string& url) {
+        state.url = url;
+        for (auto& cb : navigateCallbacks) {
+            cb(url);
+        }
+        updateState();
+    }
+};
+
+Browser::Browser() : pImpl(std::make_shared<Impl>()) {}
+
+Browser::~Browser() = default;
+
+Browser Browser::create(WebView* webview) {
+    Browser browser;
+    browser.pImpl->webview = webview;
+    
+    if (webview) {
+        webview->onNavigationStart([impl = browser.pImpl](const std::string& url) {
+            impl->notifyNavigate(url);
+            return true;
+        });
+        
+        webview->onLoadStart([impl = browser.pImpl]() {
+            impl->state.isLoading = true;
+            for (auto& cb : impl->loadStartCallbacks) {
+                cb();
+            }
+        });
+        
+        webview->onLoadEnd([impl = browser.pImpl]() {
+            impl->state.isLoading = false;
+            impl->updateState();
+            for (auto& cb : impl->loadEndCallbacks) {
+                cb();
+            }
+        });
+        
+        webview->onLoadError([impl = browser.pImpl](const std::string& error, int code) {
+            impl->state.isLoading = false;
+            for (auto& cb : impl->loadErrorCallbacks) {
+                cb(error);
+            }
+        });
+    }
+    
+    return browser;
+}
+
+void Browser::navigate(const std::string& url) {
+    if (pImpl->webview) {
+        pImpl->webview->navigate(url);
+        pImpl->notifyNavigate(url);
+    }
+}
+
+void Browser::goBack() {
+    if (pImpl->webview && pImpl->webview->canGoBack()) {
+        pImpl->webview->goBack();
+        pImpl->updateState();
+    }
+}
+
+void Browser::goForward() {
+    if (pImpl->webview && pImpl->webview->canGoForward()) {
+        pImpl->webview->goForward();
+        pImpl->updateState();
+    }
+}
+
+void Browser::reload() {
+    if (pImpl->webview) {
+        pImpl->webview->reload();
+    }
+}
+
+void Browser::stop() {
+    if (pImpl->webview) {
+        pImpl->webview->stop();
+    }
+}
+
+std::string Browser::getURL() const {
+    return pImpl->webview ? pImpl->webview->getURL() : "";
+}
+
+std::string Browser::getTitle() const {
+    return pImpl->webview ? pImpl->webview->getTitle() : "";
+}
+
+BrowserState Browser::getState() const {
+    return pImpl->state;
+}
+
+bool Browser::canGoBack() const {
+    return pImpl->webview ? pImpl->webview->canGoBack() : false;
+}
+
+bool Browser::canGoForward() const {
+    return pImpl->webview ? pImpl->webview->canGoForward() : false;
+}
+
+bool Browser::isLoading() const {
+    return pImpl->state.isLoading;
+}
+
+void Browser::onNavigate(NavigateCallback callback) {
+    pImpl->navigateCallbacks.push_back(callback);
+}
+
+void Browser::onStateChange(StateCallback callback) {
+    pImpl->stateCallbacks.push_back(callback);
+}
+
+void Browser::onLoadStart(LoadCallback callback) {
+    pImpl->loadStartCallbacks.push_back(callback);
+}
+
+void Browser::onLoadEnd(LoadCallback callback) {
+    pImpl->loadEndCallbacks.push_back(callback);
+}
+
+void Browser::onLoadError(std::function<void(const std::string& error)> callback) {
+    pImpl->loadErrorCallbacks.push_back(callback);
+}
+
+void Browser::setRoutes(const std::map<std::string, std::string>& routes) {
+    pImpl->routes = routes;
+}
+
+void Browser::push(const std::string& route) {
+    pImpl->currentRoute = route;
+    auto it = pImpl->routes.find(route);
+    if (it != pImpl->routes.end()) {
+        navigate(it->second);
+    } else {
+        navigate(route);
+    }
+}
+
+void Browser::replace(const std::string& route) {
+    push(route);
+}
+
+std::string Browser::getCurrentRoute() const {
+    return pImpl->currentRoute;
+}
+
+} // namespace plusui