plusui-native-core 0.1.0

package/Core/src/window.cpp

@@ -0,0 +1,528 @@
+#include "window.hpp"
+#include "display.hpp"
+#include <iostream>
+#include <map>
+
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#include <objc/objc-runtime.h>
+#else
+#include <gtk/gtk.h>
+#endif
+
+namespace plusui {
+
+struct Window::Impl {
+    void* nativeWindow = nullptr;
+    WindowConfig config;
+    WindowState state;
+    
+    MoveCallback moveCallback;
+    ResizeCallback resizeCallback;
+    CloseCallback closeCallback;
+    FocusCallback focusCallback;
+    StateCallback stateCallback;
+
+#ifdef _WIN32
+    HWND hwnd = nullptr;
+    WNDPROC originalProc = nullptr;
+    
+    static LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
+        Window* w = nullptr;
+        if (msg == WM_NCCREATE) {
+            auto cs = (LPCREATESTRUCT)lp;
+            w = (Window*)cs->lpCreateParams;
+            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)w);
+        } else {
+            w = (Window*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+        }
+        
+        if (w && w->pImpl) {
+            switch (msg) {
+                case WM_MOVE:
+                    if (w->pImpl->moveCallback) {
+                        int x = (int)(short)LOWORD(lp);
+                        int y = (int)(short)HIWORD(lp);
+                        w->pImpl->moveCallback(x, y);
+                    }
+                    break;
+                case WM_SIZE:
+                    if (w->pImpl->resizeCallback) {
+                        int w = LOWORD(lp);
+                        int h = HIWORD(lp);
+                        w->pImpl->resizeCallback(w, h);
+                    }
+                    break;
+                case WM_CLOSE:
+                    if (w->pImpl->closeCallback) {
+                        w->pImpl->closeCallback();
+                    }
+                    break;
+                case WM_SETFOCUS:
+                    if (w->pImpl->focusCallback) {
+                        w->pImpl->focusCallback(true);
+                    }
+                    break;
+                case WM_KILLFOCUS:
+                    if (w->pImpl->focusCallback) {
+                        w->pImpl->focusCallback(false);
+                    }
+                    break;
+            }
+        }
+        return DefWindowProc(hwnd, msg, wp, lp);
+    }
+#endif
+};
+
+Window::Window() : pImpl(std::make_unique<Impl>()) {}
+
+Window::~Window() = default;
+
+Window Window::create(const WindowConfig& config) {
+    Window w;
+    w.pImpl->config = config;
+    
+#ifdef _WIN32
+    WNDCLASSEX wc = {};
+    wc.cbSize = sizeof(WNDCLASSEX);
+    wc.lpfnWndProc = Impl::wndProc;
+    wc.hInstance = GetModuleHandle(nullptr);
+    wc.lpszClassName = L"PLUSUI_WINDOW";
+    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    RegisterClassEx(&wc);
+    
+    DWORD style = WS_OVERLAPPEDWINDOW;
+    if (!config.resizable) style &= ~WS_THICKFRAME;
+    if (!config.minimizable) style &= ~WS_MINIMIZEBOX;
+    if (!config.closable) style &= ~WS_SYSMENU;
+    
+    std::wstring wtitle(config.title.begin(), config.title.end());
+    w.pImpl->hwnd = CreateWindowExW(
+        0, L"PLUSUI_WINDOW",
+        wtitle.c_str(),
+        style,
+        config.x >= 0 ? config.x : CW_USEDEFAULT,
+        config.y >= 0 ? config.y : CW_USEDEFAULT,
+        config.width, config.height,
+        nullptr, nullptr,
+        GetModuleHandle(nullptr),
+        &w
+    );
+    
+    w.pImpl->nativeWindow = (void*)w.pImpl->hwnd;
+    w.pImpl->state.width = config.width;
+    w.pImpl->state.height = config.height;
+    
+    if (config.center) {
+        RECT screen;
+        SystemParametersInfo(SPI_GETWORKAREA, 0, &screen, 0);
+        int x = (screen.right - config.width) / 2;
+        int y = (screen.bottom - config.height) / 2;
+        SetWindowPos(w.pImpl->hwnd, nullptr, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+    }
+    
+    if (config.alwaysOnTop) {
+        SetWindowPos(w.pImpl->hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    }
+    
+#elif defined(__APPLE__)
+    NSWindow* nswin = [[NSWindow alloc] 
+        initWithContentRect:NSMakeRect(config.x >= 0 ? config.x : 100, 
+                                       config.y >= 0 ? config.y : 100,
+                                       config.width, config.height)
+        styleMask:(config.resizable ? NSWindowStyleMaskResizable : 0) |
+                  NSWindowStyleMaskTitled |
+                  NSWindowStyleMaskClosable |
+                  (config.minimizable ? NSWindowStyleMaskMiniaturizable : 0)
+        backing:NSBackingStoreBuffered
+        defer:NO];
+    
+    [nswin setTitle:[NSString stringWithUTF8String:config.title.c_str()]];
+    [nswin setReleasedWhenClosed:NO];
+    
+    if (config.center) {
+        [nswin center];
+    }
+    
+    if (config.alwaysOnTop) {
+        [nswin setLevel:NSFloatingWindowLevel];
+    }
+    
+    w.pImpl->nativeWindow = (__bridge void*)nswin;
+    
+#else
+    gtk_init_check(0, nullptr);
+    
+    GtkWindow* gtkwin = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
+    gtk_window_set_title(gtkwin, config.title.c_str());
+    gtk_window_set_default_size(gtkwin, config.width, config.height);
+    
+    if (config.x >= 0 && config.y >= 0) {
+        gtk_window_move(gtkwin, config.x, config.y);
+    } else if (config.center) {
+        gtk_window_set_position(gtkwin, GTK_WIN_POS_CENTER);
+    }
+    
+    if (!config.resizable) {
+        gtk_window_set_resizable(gtkwin, FALSE);
+    }
+    
+    if (config.alwaysOnTop) {
+        gtk_window_set_keep_above(gtkwin, TRUE);
+    }
+    
+    w.pImpl->nativeWindow = (void*)gtkwin;
+#endif
+
+    return w;
+}
+
+void Window::setTitle(const std::string& title) {
+    pImpl->config.title = title;
+#ifdef _WIN32
+    if (pImpl->hwnd) SetWindowTextA(pImpl->hwnd, title.c_str());
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin setTitle:[NSString stringWithUTF8String:title.c_str()]];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_set_title(GTK_WINDOW(pImpl->nativeWindow), title.c_str());
+    }
+#endif
+}
+
+std::string Window::getTitle() const {
+    return pImpl->config.title;
+}
+
+void Window::setSize(int width, int height) {
+    pImpl->config.width = width;
+    pImpl->config.height = height;
+#ifdef _WIN32
+    if (pImpl->hwnd) SetWindowPos(pImpl->hwnd, nullptr, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin setContentSize:NSMakeSize(width, height)];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_resize(GTK_WINDOW(pImpl->nativeWindow), width, height);
+    }
+#endif
+}
+
+void Window::getSize(int& width, int& height) const {
+    width = pImpl->state.width;
+    height = pImpl->state.height;
+}
+
+void Window::setMinSize(int minWidth, int minHeight) {
+    pImpl->config.minWidth = minWidth;
+    pImpl->config.minHeight = minHeight;
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        SetWindowLongPtr(pImpl->hwnd, GWL_STYLE, 
+            GetWindowLong(pImpl->hwnd, GWL_STYLE) | WS_THICKFRAME);
+    }
+#endif
+}
+
+void Window::setMaxSize(int maxWidth, int maxHeight) {
+    pImpl->config.maxWidth = maxWidth;
+    pImpl->config.maxHeight = maxHeight;
+}
+
+void Window::setPosition(int x, int y) {
+    pImpl->config.x = x;
+    pImpl->config.y = y;
+#ifdef _WIN32
+    if (pImpl->hwnd) SetWindowPos(pImpl->hwnd, nullptr, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin setFrameOrigin:NSMakePoint(x, y)];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_move(GTK_WINDOW(pImpl->nativeWindow), x, y);
+    }
+#endif
+}
+
+void Window::getPosition(int& x, int& y) const {
+    x = pImpl->state.x;
+    y = pImpl->state.y;
+}
+
+void Window::center() {
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        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_NOZORDER | SWP_NOSIZE);
+    }
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin center];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_set_position(GTK_WINDOW(pImpl->nativeWindow), GTK_WIN_POS_CENTER);
+    }
+#endif
+}
+
+void Window::setFullscreen(bool enabled) {
+    pImpl->config.fullscreen = enabled;
+    pImpl->state.isFullscreen = enabled;
+    
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        if (enabled) {
+            SetWindowLongPtr(pImpl->hwnd, GWL_STYLE, 
+                GetWindowLong(pImpl->hwnd, GWL_STYLE) & ~WS_OVERLAPPEDWINDOW);
+            SetWindowPos(pImpl->hwnd, HWND_TOP, 0, 0, 
+                GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
+                SWP_SHOWWINDOW);
+        } else {
+            SetWindowLongPtr(pImpl->hwnd, GWL_STYLE, 
+                GetWindowLong(pImpl->hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW);
+            SetWindowPos(pImpl->hwnd, nullptr, 0, 0, 0, 0, 
+                SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
+        }
+    }
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        if (enabled) {
+            [nswin toggleFullScreen:nil];
+        }
+    }
+#else
+    if (pImpl->nativeWindow) {
+        if (enabled) {
+            gtk_window_fullscreen(GTK_WINDOW(pImpl->nativeWindow));
+        } else {
+            gtk_window_unfullscreen(GTK_WINDOW(pImpl->nativeWindow));
+        }
+    }
+#endif
+}
+
+bool Window::isFullscreen() const {
+    return pImpl->state.isFullscreen;
+}
+
+void Window::minimize() {
+#ifdef _WIN32
+    if (pImpl->hwnd) ShowWindow(pImpl->hwnd, SW_MINIMIZE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin miniaturize:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_iconify(GTK_WINDOW(pImpl->nativeWindow));
+    }
+#endif
+}
+
+void Window::maximize() {
+#ifdef _WIN32
+    if (pImpl->hwnd) ShowWindow(pImpl->hwnd, SW_MAXIMIZE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin zoom:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_maximize(GTK_WINDOW(pImpl->nativeWindow));
+    }
+#endif
+}
+
+void Window::restore() {
+#ifdef _WIN32
+    if (pImpl->hwnd) ShowWindow(pImpl->hwnd, SW_RESTORE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin deminiaturize:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_unmaximize(GTK_WINDOW(pImpl->nativeWindow));
+        gtk_window_deiconify(GTK_WINDOW(pImpl->nativeWindow));
+    }
+#endif
+}
+
+bool Window::isMaximized() const {
+    return pImpl->state.isMaximized;
+}
+
+bool Window::isMinimized() const {
+    return pImpl->state.isMinimized;
+}
+
+void Window::show() {
+    pImpl->state.isVisible = true;
+#ifdef _WIN32
+    if (pImpl->hwnd) ShowWindow(pImpl->hwnd, SW_SHOW);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin orderFront:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_widget_show(GTK_WIDGET(pImpl->nativeWindow));
+    }
+#endif
+}
+
+void Window::hide() {
+    pImpl->state.isVisible = false;
+#ifdef _WIN32
+    if (pImpl->hwnd) ShowWindow(pImpl->hwnd, SW_HIDE);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin orderOut:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_widget_hide(GTK_WIDGET(pImpl->nativeWindow));
+    }
+#endif
+}
+
+bool Window::isVisible() const {
+    return pImpl->state.isVisible;
+}
+
+void Window::focus() {
+#ifdef _WIN32
+    if (pImpl->hwnd) SetFocus(pImpl->hwnd);
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin makeKeyAndOrderFront:nil];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_present(GTK_WINDOW(pImpl->nativeWindow));
+    }
+#endif
+}
+
+bool Window::isFocused() const {
+    return pImpl->state.isFocused;
+}
+
+void Window::setAlwaysOnTop(bool enabled) {
+    pImpl->config.alwaysOnTop = enabled;
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        SetWindowPos(pImpl->hwnd, enabled ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+    }
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin setLevel:enabled ? NSFloatingWindowLevel : NSNormalWindowLevel];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_set_keep_above(GTK_WINDOW(pImpl->nativeWindow), enabled);
+    }
+#endif
+}
+
+void Window::setResizable(bool enabled) {
+    pImpl->config.resizable = enabled;
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        SetWindowLongPtr(pImpl->hwnd, GWL_STYLE,
+            enabled ? GetWindowLong(pImpl->hwnd, GWL_STYLE) | WS_THICKFRAME
+                    : GetWindowLong(pImpl->hwnd, GWL_STYLE) & ~WS_THICKFRAME);
+    }
+#elif defined(__APPLE__)
+    // Handled in create
+#else
+    if (pImpl->nativeWindow) {
+        gtk_window_set_resizable(GTK_WINDOW(pImpl->nativeWindow), enabled);
+    }
+#endif
+}
+
+void Window::setDecorations(bool enabled) {
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        SetWindowLongPtr(pImpl->hwnd, GWL_STYLE,
+            enabled ? GetWindowLong(pImpl->hwnd, GWL_STYLE) | WS_CAPTION
+                    : GetWindowLong(pImpl->hwnd, GWL_STYLE) & ~WS_CAPTION);
+    }
+#elif defined(__APPLE__)
+    if (pImpl->nativeWindow) {
+        NSWindow* nswin = (__bridge NSWindow*)pImpl->nativeWindow;
+        [nswin setStyleMask:enabled ? [nswin styleMask] | NSWindowStyleMaskTitled 
+                                   : [nswin styleMask] & ~NSWindowStyleMaskTitled];
+    }
+#else
+    if (pImpl->nativeWindow) {
+        // GTK handles this differently
+    }
+#endif
+}
+
+void Window::setSkipTaskbar(bool enabled) {
+#ifdef _WIN32
+    if (pImpl->hwnd) {
+        SetWindowLongPtr(pImpl->hwnd, GWL_EXSTYLE,
+            enabled ? GetWindowLong(pImpl->hwnd, GWL_EXSTYLE) | WS_EX_TOOLWINDOW
+                    : GetWindowLong(pImpl->hwnd, GWL_EXSTYLE) & ~WS_EX_TOOLWINDOW);
+    }
+#endif
+}
+
+WindowState Window::getState() const {
+    return pImpl->state;
+}
+
+void Window::onMove(MoveCallback callback) {
+    pImpl->moveCallback = callback;
+}
+
+void Window::onResize(ResizeCallback callback) {
+    pImpl->resizeCallback = callback;
+}
+
+void Window::onClose(CloseCallback callback) {
+    pImpl->closeCallback = callback;
+}
+
+void Window::onFocus(FocusCallback callback) {
+    pImpl->focusCallback = callback;
+}
+
+void Window::onStateChange(StateCallback callback) {
+    pImpl->stateCallback = callback;
+}
+
+void* Window::nativeHandle() const {
+    return pImpl->nativeWindow;
+}
+
+}