plusui-native-core 0.1.4 → 0.1.5

package/Core/Features/Window/window.cpp

@@ -0,0 +1,664 @@
+#include <iostream>
+#include <map>
+#include <plusui/display.hpp>
+#include <plusui/window.hpp>
+
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#include <objc/objc-runtime.h>
+#else
+#include <gtk/gtk.h>
+#endif
+
+#include <stb_image.h>
+
+namespace plusui {
+
+struct Window::Impl {
+  void *nativeWindow = nullptr;
+  WindowConfig config;
+  WindowState state;
+
+  std::vector<MoveCallback> moveCallbacks;
+  std::vector<ResizeCallback> resizeCallbacks;
+  std::vector<CloseCallback> closeCallbacks;
+  std::vector<FocusCallback> focusCallbacks;
+  std::vector<StateCallback> stateCallbacks;
+
+#ifdef _WIN32
+  HWND hwnd = nullptr;
+  WNDPROC originalProc = nullptr;
+
+  static LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
+    Impl *impl = nullptr;
+    if (msg == WM_NCCREATE) {
+      auto cs = (LPCREATESTRUCT)lp;
+      impl = (Impl *)cs->lpCreateParams;
+      SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)impl);
+    } else {
+      impl = (Impl *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+    }
+
+    if (impl) {
+      switch (msg) {
+      case WM_MOVE: {
+        int x = (int)(short)LOWORD(lp);
+        int y = (int)(short)HIWORD(lp);
+        impl->state.x = x;
+        impl->state.y = y;
+        for (auto &cb : impl->moveCallbacks)
+          cb(x, y);
+        break;
+      }
+      case WM_SIZE: {
+        int width = LOWORD(lp);
+        int height = HIWORD(lp);
+        impl->state.width = width;
+        impl->state.height = height;
+        for (auto &cb : impl->resizeCallbacks)
+          cb(width, height);
+        break;
+      }
+      case WM_CLOSE:
+        for (auto &cb : impl->closeCallbacks)
+          cb();
+        break;
+      case WM_SETFOCUS:
+        impl->state.isFocused = true;
+        for (auto &cb : impl->focusCallbacks)
+          cb(true);
+        break;
+      case WM_KILLFOCUS:
+        impl->state.isFocused = false;
+        for (auto &cb : impl->focusCallbacks)
+          cb(false);
+        break;
+      }
+    }
+    return DefWindowProc(hwnd, msg, wp, lp);
+  }
+#endif
+};
+
+Window::Window() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
+
+Window::~Window() = default;
+
+Window Window::create(const WindowConfig &config) {
+  Window w;
+  w.pImpl->config = config;
+
+#ifdef _WIN32
+  WNDCLASSEXW wc = {};
+  wc.cbSize = sizeof(WNDCLASSEXW);
+  wc.lpfnWndProc = Impl::wndProc;
+  wc.hInstance = GetModuleHandle(nullptr);
+  wc.lpszClassName = L"PLUSUI_WINDOW";
+  wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+  wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
+  RegisterClassExW(&wc);
+
+  DWORD style = 0;
+  DWORD exStyle = 0;
+
+  if (config.decorations) {
+    style = WS_OVERLAPPEDWINDOW;
+    if (!config.resizable)
+      style &= ~WS_THICKFRAME;
+    if (!config.minimizable)
+      style &= ~WS_MINIMIZEBOX;
+    if (!config.closable)
+      style &= ~WS_SYSMENU;
+  } else {
+    // Frameless window
+    style = WS_POPUP;
+    if (config.resizable)
+      style |= WS_THICKFRAME;
+  }
+
+  if (config.transparent) {
+    exStyle = WS_EX_LAYERED;
+  }
+
+  if (config.skipTaskbar) {
+    exStyle |= WS_EX_TOOLWINDOW;
+  }
+
+  std::wstring wideTitle(config.title.begin(), config.title.end());
+  w.pImpl->hwnd = CreateWindowExW(
+      exStyle, L"PLUSUI_WINDOW", wideTitle.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.pImpl.get());
+
+  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) {
+    std::wstring wideTitle(title.begin(), title.end());
+    SetWindowTextW(pImpl->hwnd, wideTitle.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) {
+  bool wasFullscreen = pImpl->state.isFullscreen;
+  pImpl->config.fullscreen = enabled;
+  pImpl->state.isFullscreen = enabled;
+  pImpl->state.isHidden = false;
+
+#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
+
+  if (wasFullscreen != enabled) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+bool Window::isFullscreen() const { return pImpl->state.isFullscreen; }
+
+void Window::minimize() {
+  bool wasMinimized = pImpl->state.isMinimized;
+  pImpl->state.isMinimized = true;
+  pImpl->state.isHidden = false;
+
+#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
+
+  if (!wasMinimized) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+void Window::maximize() {
+  bool wasMaximized = pImpl->state.isMaximized;
+  pImpl->state.isMaximized = true;
+  pImpl->state.isHidden = false;
+
+#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
+
+  if (!wasMaximized) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+void Window::restore() {
+  bool wasMinimized = pImpl->state.isMinimized;
+  bool wasMaximized = pImpl->state.isMaximized;
+  pImpl->state.isMinimized = false;
+  pImpl->state.isMaximized = false;
+  pImpl->state.isHidden = false;
+
+#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
+
+  if (wasMinimized || wasMaximized) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+bool Window::isMaximized() const { return pImpl->state.isMaximized; }
+
+bool Window::isMinimized() const { return pImpl->state.isMinimized; }
+
+void Window::show() {
+  bool wasHidden = pImpl->state.isHidden;
+  pImpl->state.isVisible = true;
+  pImpl->state.isHidden = false;
+
+#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
+
+  // Fire state change event if hidden state changed
+  if (wasHidden) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+void Window::hide() {
+  bool wasVisible = pImpl->state.isVisible;
+  pImpl->state.isVisible = false;
+  pImpl->state.isHidden = true;
+
+#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
+
+  // Fire state change event if visibility changed
+  if (wasVisible) {
+    for (auto &cb : pImpl->stateCallbacks)
+      cb(pImpl->state);
+  }
+}
+
+bool Window::isVisible() const { return pImpl->state.isVisible; }
+
+bool Window::isHidden() const { return pImpl->state.isHidden; }
+
+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
+}
+
+void Window::setOpacity(double opacity) {
+  pImpl->config.opacity = opacity;
+#ifdef _WIN32
+  if (pImpl->hwnd) {
+    BYTE alpha = static_cast<BYTE>(opacity * 255);
+    SetWindowLongPtr(pImpl->hwnd, GWL_EXSTYLE,
+                     GetWindowLong(pImpl->hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);
+    SetLayeredWindowAttributes(pImpl->hwnd, 0, alpha, LWA_ALPHA);
+  }
+#endif
+}
+
+void Window::setIconFromMemory(const unsigned char *data, size_t size) {
+#ifdef _WIN32
+  if (pImpl->hwnd) {
+    int width, height, channels;
+    unsigned char *pixels =
+        stbi_load_from_memory(data, (int)size, &width, &height, &channels, 4);
+    if (pixels) {
+      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) {
+        // Convert RGBA to BGRA
+        for (int i = 0; i < width * height; ++i) {
+          ((uint8_t *)bits)[i * 4 + 0] = pixels[i * 4 + 2];
+          ((uint8_t *)bits)[i * 4 + 1] = pixels[i * 4 + 1];
+          ((uint8_t *)bits)[i * 4 + 2] = pixels[i * 4 + 0];
+          ((uint8_t *)bits)[i * 4 + 3] = pixels[i * 4 + 3];
+        }
+
+        ICONINFO ii = {};
+        ii.fIcon = TRUE;
+        ii.hbmColor = hbm;
+        ii.hbmMask = hbm;
+
+        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(hbm);
+      }
+      stbi_image_free(pixels);
+    }
+  }
+#endif
+}
+
+WindowState Window::getState() const { return pImpl->state; }
+
+void Window::onMove(MoveCallback callback) {
+  pImpl->moveCallbacks.push_back(callback);
+}
+
+void Window::onResize(ResizeCallback callback) {
+  pImpl->resizeCallbacks.push_back(callback);
+}
+
+void Window::onClose(CloseCallback callback) {
+  pImpl->closeCallbacks.push_back(callback);
+}
+
+void Window::onFocus(FocusCallback callback) {
+  pImpl->focusCallbacks.push_back(callback);
+}
+
+void Window::onStateChange(StateCallback callback) {
+  pImpl->stateCallbacks.push_back(callback);
+}
+
+void *Window::nativeHandle() const { return pImpl->nativeWindow; }
+
+} // namespace plusui