plusui-native-core 0.1.30 → 0.1.32

package/Core/CMakeLists.txt

@@ -24,7 +24,6 @@ add_library(plusui STATIC
     Features/Bindings/CustomBindings/custom_bindings.cpp
     Features/App/app.cpp
     Features/Window/window.cpp
-    Features/Window/window_manager.cpp
     Features/Window/webview.cpp
     Features/Browser/browser.cpp
     Features/Display/display.cpp

package/Core/Features/App/app.cpp

@@ -6,8 +6,6 @@
 #include <plusui/app.hpp>
 #include <plusui/tray.hpp>
 #include <plusui/window.hpp>
-#include <plusui/window.hpp>
-#include <plusui/window_manager.hpp>
 
 namespace plusui {
 

package/Core/Features/Window/webview.cpp

@@ -1,11 +1,10 @@
 #include <fstream>
+#include <functional>
 #include <iostream>
 #include <map>
 #include <plusui/tray.hpp>
 #include <plusui/webgpu.hpp>
 #include <plusui/window.hpp>
-#include <plusui/window.hpp>
-#include <plusui/window_manager.hpp>
 #include <regex>
 #include <sstream>
 
@@ -44,7 +43,6 @@ struct Window::Impl {
   std::map<std::string, JSCallback> bindings;
 
   std::unique_ptr<TrayManager> trayManager;
-  std::unique_ptr<WindowManager> windowManager;
   std::map<std::string, std::function<void(const std::string &)>> events;
   WebGPU webgpu; // WebGPU support
 
@@ -242,39 +240,43 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   if (method.find("window.") == 0) {
                                     std::string winMethod = method.substr(7);
                                     if (winMethod == "minimize") {
-                                      pImpl->windowManager->minimize();
+                                      if (pImpl->window) pImpl->window->minimize();
                                       success = true;
                                     } else if (winMethod == "maximize") {
-                                      pImpl->windowManager->maximize();
+                                      if (pImpl->window) pImpl->window->maximize();
                                       success = true;
                                     } else if (winMethod == "restore") {
-                                      pImpl->windowManager->restore();
+                                      if (pImpl->window) pImpl->window->restore();
                                       success = true;
                                     } else if (winMethod == "close") {
-                                      pImpl->windowManager->close();
+                                      if (pImpl->window) pImpl->window->close();
                                       success = true;
                                     } else if (winMethod == "show") {
-                                      pImpl->windowManager->show();
+                                      if (pImpl->window) pImpl->window->show();
                                       success = true;
                                     } else if (winMethod == "hide") {
-                                      pImpl->windowManager->hide();
+                                      if (pImpl->window) pImpl->window->hide();
                                       success = true;
                                     } else if (winMethod == "getSize") {
-                                      auto size =
-                                          pImpl->windowManager->getSize();
-                                      result = "{\"width\":" +
-                                               std::to_string(size.width) +
-                                               ",\"height\":" +
-                                               std::to_string(size.height) +
-                                               "}";
+                                      if (pImpl->window) {
+                                        int w, h;
+                                        pImpl->window->getSize(w, h);
+                                        result = "{\"width\":" +
+                                                 std::to_string(w) +
+                                                 ",\"height\":" +
+                                                 std::to_string(h) +
+                                                 "}";
+                                      }
                                       success = true;
                                     } else if (winMethod == "getPosition") {
-                                      auto pos =
-                                          pImpl->windowManager->getPosition();
-                                      result =
-                                          "{\"x\":" + std::to_string(pos.x) +
-                                          ",\"y\":" + std::to_string(pos.y) +
-                                          "}";
+                                      if (pImpl->window) {
+                                        int x, y;
+                                        pImpl->window->getPosition(x, y);
+                                        result =
+                                            "{\"x\":" + std::to_string(x) +
+                                            ",\"y\":" + std::to_string(y) +
+                                            "}";
+                                      }
                                       success = true;
                                     } else if (winMethod == "setSize") {
                                       // Parse params [width, height]
@@ -287,7 +289,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                         int w = 0, h = 0;
                                         sscanf(params.c_str(), "%d, %d", &w,
                                                &h);
-                                        pImpl->windowManager->setSize(w, h);
+                                        if (pImpl->window) pImpl->window->setSize(w, h);
                                       }
                                       success = true;
                                     } else if (winMethod == "setPosition") {
@@ -300,7 +302,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                         int x = 0, y = 0;
                                         sscanf(params.c_str(), "%d, %d", &x,
                                                &y);
-                                        pImpl->windowManager->setPosition(x, y);
+                                        if (pImpl->window) pImpl->window->setPosition(x, y);
                                       }
                                       success = true;
                                     } else if (winMethod == "setTitle") {
@@ -310,7 +312,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string title =
                                             msg.substr(p1 + 2, p2 - p1 - 2);
-                                        pImpl->windowManager->setTitle(title);
+                                        if (pImpl->window) pImpl->window->setTitle(title);
                                       }
                                       success = true;
                                     } else if (winMethod == "setFullscreen") {
@@ -320,7 +322,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string params =
                                             msg.substr(p1 + 1, p2 - p1 - 1);
-                                        pImpl->windowManager->setFullscreen(
+                                        if (pImpl->window) pImpl->window->setFullscreen(
                                             params.find("true") !=
                                             std::string::npos);
                                       }
@@ -332,7 +334,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string params =
                                             msg.substr(p1 + 1, p2 - p1 - 1);
-                                        pImpl->windowManager->setAlwaysOnTop(
+                                        if (pImpl->window) pImpl->window->setAlwaysOnTop(
                                             params.find("true") !=
                                             std::string::npos);
                                       }
@@ -344,30 +346,30 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string params =
                                             msg.substr(p1 + 1, p2 - p1 - 1);
-                                        pImpl->windowManager->setResizable(
+                                        if (pImpl->window) pImpl->window->setResizable(
                                             params.find("true") !=
                                             std::string::npos);
                                       }
                                       success = true;
                                     } else if (winMethod == "isMaximized") {
                                       result =
-                                          pImpl->windowManager->isMaximized()
+                                          (pImpl->window && pImpl->window->isMaximized())
                                               ? "true"
                                               : "false";
                                       success = true;
                                     } else if (winMethod == "isMinimized") {
                                       result =
-                                          pImpl->windowManager->isMinimized()
+                                          (pImpl->window && pImpl->window->isMinimized())
                                               ? "true"
                                               : "false";
                                       success = true;
                                     } else if (winMethod == "isVisible") {
-                                      result = pImpl->windowManager->isVisible()
+                                      result = (pImpl->window && pImpl->window->isVisible())
                                                    ? "true"
                                                    : "false";
                                       success = true;
                                     } else if (winMethod == "center") {
-                                      pImpl->windowManager->setCenter();
+                                      if (pImpl->window) pImpl->window->center();
                                       success = true;
                                     }
                                   } else if (method.find("tray.") == 0) {
@@ -432,7 +434,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   } else if (method.find("app.") == 0) {
                                     std::string appMethod = method.substr(4);
                                     if (appMethod == "quit") {
-                                      pImpl->windowManager->close();
+                                      if (pImpl->window) pImpl->window->close();
                                       PostQuitMessage(0);
                                       success = true;
                                     }
@@ -725,7 +727,6 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 
 #endif
 
-  win.pImpl->windowManager = std::make_unique<WindowManager>(windowHandle);
   win.pImpl->trayManager = std::make_unique<TrayManager>();
   win.pImpl->trayManager->setWindowHandle(windowHandle);
 
@@ -733,7 +734,6 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 }
 
 TrayManager &Window::tray() { return *pImpl->trayManager; }
-WindowManager &Window::windowManager() { return *pImpl->windowManager; }
 
 void Window::setWindow(std::shared_ptr<Window> win) {
   pImpl->window = win;

package/Core/include/plusui/app.hpp

@@ -3,7 +3,6 @@
 
 #include "tray.hpp"
 #include "window.hpp"
-#include "window_manager.hpp"
 #include <functional>
 #include <future>
 #include <memory>

package/Core/include/plusui/plusui.hpp

@@ -36,4 +36,3 @@
 #include <plusui/tray.hpp>
 #include <plusui/webgpu.hpp>
 #include <plusui/window.hpp>
-#include <plusui/window_manager.hpp>

package/Core/include/plusui/window.hpp

@@ -10,7 +10,6 @@
 namespace plusui {
 
 class TrayManager;
-class WindowManager;
 
 struct WindowConfig {
   // Window properties
@@ -207,7 +206,6 @@ public:
 
   // Features
   TrayManager &tray();
-  WindowManager &windowManager();
 
 private:
   struct Impl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native-core",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "PlusUI Core framework (frontend + backend implementations)",
   "type": "module",
   "files": [

package/Core/Features/Window/window_manager.cpp

@@ -1,428 +0,0 @@
-#include <plusui/window_manager.hpp>
-#include <stb_image.h>
-
-#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; }
-
-void WindowManager::setIcon(const std::string& iconPath) {
-#ifdef _WIN32
-  if (pImpl->nativeWindow && !iconPath.empty()) {
-    std::wstring wpath(iconPath.begin(), iconPath.end());
-    HICON hIcon = (HICON)LoadImageW(nullptr, wpath.c_str(), IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE);
-    if (hIcon) {
-      SendMessage(pImpl->hwnd(), WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
-      SendMessage(pImpl->hwnd(), WM_SETICON, ICON_BIG, (LPARAM)hIcon);
-    }
-  }
-#elif defined(__APPLE__)
-  // macOS implementation
-#else
-  if (pImpl->nativeWindow && !iconPath.empty()) {
-    GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file(iconPath.c_str(), nullptr);
-    if (pixbuf) {
-      gtk_window_set_icon(GTK_WINDOW(pImpl->nativeWindow), pixbuf);
-      g_object_unref(pixbuf);
-    }
-  }
-#endif
-}
-
-void WindowManager::setIconFromMemory(const unsigned char *data, size_t size) {
-#ifdef _WIN32
-  if (pImpl->nativeWindow && data && size > 0) {
-    int width, height, channels;
-    unsigned char *pixels = stbi_load_from_memory(data, (int)size, &width, &height, &channels, 4);
-    if (pixels) {
-      // Convert RGBA to BGRA for Windows
-      for (int i = 0; i < width * height; ++i) {
-        unsigned char r = pixels[i * 4 + 0];
-        unsigned char b = pixels[i * 4 + 2];
-        pixels[i * 4 + 0] = b;
-        pixels[i * 4 + 2] = r;
-      }
-      
-      BITMAPINFO bmi = {};
-      bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-      bmi.bmiHeader.biWidth = width;
-      bmi.bmiHeader.biHeight = -height;
-      bmi.bmiHeader.biPlanes = 1;
-      bmi.bmiHeader.biBitCount = 32;
-      bmi.bmiHeader.biCompression = BI_RGB;
-      
-      void *bits = nullptr;
-      HBITMAP hbm = CreateDIBSection(nullptr, &bmi, DIB_RGB_COLORS, &bits, nullptr, 0);
-      if (hbm && bits) {
-        memcpy(bits, pixels, width * height * 4);
-        
-        ICONINFO ii = {};
-        ii.fIcon = TRUE;
-        ii.hbmColor = hbm;
-        ii.hbmMask = CreateCompatibleBitmap(GetDC(nullptr), width, height);
-        
-        HICON hIcon = CreateIconIndirect(&ii);
-        if (hIcon) {
-          SendMessage(pImpl->hwnd(), WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
-          SendMessage(pImpl->hwnd(), WM_SETICON, ICON_BIG, (LPARAM)hIcon);
-        }
-        
-        DeleteObject(ii.hbmMask);
-        DeleteObject(hbm);
-      }
-      
-      stbi_image_free(pixels);
-    }
-  }
-#elif defined(__APPLE__)
-  // macOS implementation
-#else
-  if (pImpl->nativeWindow && data && size > 0) {
-    int width, height, channels;
-    unsigned char *pixels = stbi_load_from_memory(data, (int)size, &width, &height, &channels, 4);
-    if (pixels) {
-      GdkPixbuf* pixbuf = gdk_pixbuf_new_from_data(pixels, GDK_COLORSPACE_RGB, TRUE, 8, width, height, width * 4, nullptr, nullptr);
-      if (pixbuf) {
-        gtk_window_set_icon(GTK_WINDOW(pImpl->nativeWindow), pixbuf);
-        g_object_unref(pixbuf);
-      }
-      stbi_image_free(pixels);
-    }
-  }
-#endif
-}
-
-} // namespace plusui

package/Core/include/plusui/window_manager.hpp

@@ -1,59 +0,0 @@
-#ifndef PLUSUI_WINDOW_MANAGER_H
-#define PLUSUI_WINDOW_MANAGER_H
-
-#include <string>
-#include <memory>
-
-namespace plusui {
-
-struct WindowSize {
-    int width = 0;
-    int height = 0;
-};
-
-struct WindowPosition {
-    int x = 0;
-    int y = 0;
-};
-
-class WindowManager {
-public:
-    WindowManager();
-    explicit WindowManager(void* nativeWindow);
-    ~WindowManager();
-
-    // Window operations
-    void setTitle(const std::string& title);
-    void setSize(int width, int height);
-    WindowSize getSize() const;
-    void setPosition(int x, int y);
-    WindowPosition getPosition() const;
-    void setCenter();
-    void setFullscreen(bool enabled);
-    void setAlwaysOnTop(bool enabled);
-    void setResizable(bool enabled);
-    void setDecorations(bool enabled);
-    void setSkipTaskbar(bool enabled);
-    void setTransparency(double alpha);
-    void setIcon(const std::string& iconPath);
-    void setIconFromMemory(const unsigned char *data, size_t size);
-    
-    void minimize();
-    void maximize();
-    void restore();
-    void show();
-    void hide();
-    void close();
-    
-    bool isMaximized() const;
-    bool isMinimized() const;
-    bool isVisible() const;
-
-private:
-    struct Impl;
-    std::unique_ptr<Impl> pImpl;
-};
-
-} // namespace plusui
-
-#endif