windowpp 0.1.1

package/framework/src/platform/win32/app_win32.cpp

@@ -0,0 +1,572 @@
+// ============================================================================
+//  app_win32.cpp — Win32 Application implementation
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include "app_win32.h"
+#include "window_win32.h"
+#include "win32_helpers.h"
+#include "../../Input/input_service.h"
+#include "../../Input/Windows/win32_key_utils.h"
+#include "../../renderer/webview/webview.h"
+#include <algorithm>
+
+namespace wpp {
+
+namespace {
+
+constexpr wchar_t kWindowClassName[] = L"WindowPPClass";
+
+bool use_native_window_file_drop(const WindowConfig& config) {
+    return config.file_drop && !config.webview.enabled;
+}
+
+}
+
+Win32Application::Win32Application(const AppConfig& config) : config_(config) {
+    win32::WindowClass wc("WindowPPApp", wnd_proc);
+    class_atom_ = wc.atom;
+
+    hwnd_ = CreateWindowExW(
+        0,
+        MAKEINTATOM(class_atom_),
+        win32::to_wide(config.name).c_str(),
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT, CW_USEDEFAULT,
+        800, 600,
+        nullptr, nullptr,
+        GetModuleHandleW(nullptr),
+        this
+    );
+
+    if (!hwnd_) {
+        return;
+    }
+
+    SetWindowLongPtr(hwnd_, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+
+    input::detail::set_dispatch([this](std::function<void()> fn) {
+        dispatch(std::move(fn));
+    });
+    input::detail::set_global_backend(
+        [this](const std::string& id, const input::Shortcut& shortcut, std::string* error) {
+            return register_global_hotkey(id, shortcut, error);
+        },
+        [this](const std::string& id) {
+            unregister_global_hotkey(id);
+        });
+
+    if (config_.single_instance) {
+        CreateMutexW(nullptr, TRUE, win32::to_wide(config.identifier).c_str());
+    }
+
+    if (config_.run_on_startup) {
+        HKEY hKey;
+        RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
+                     0, KEY_SET_VALUE, &hKey);
+        RegSetValueExW(hKey, win32::to_wide(config.name).c_str(), 0, REG_SZ,
+                      (BYTE*)win32::to_wide("").c_str(), 0);
+        RegCloseKey(hKey);
+    }
+
+    if (config_.on_ready) {
+        config_.on_ready();
+    }
+
+    if (config_.tray_enabled) {
+        set_tray(config_.tray);
+    }
+}
+
+Win32Application::~Win32Application() {
+    shutting_down_ = true;
+    clear_global_hotkeys();
+    input::detail::clear_global_backend();
+    if (hwnd_ && IsWindow(hwnd_)) {
+        DestroyWindow(hwnd_);
+    }
+}
+
+Window* Win32Application::create_window(const WindowConfig& config) {
+    auto id = config.id.empty() ? "main" : config.id;
+
+    DWORD style = WS_OVERLAPPEDWINDOW;
+    DWORD ex_style = 0;
+
+    if (config.frameless) {
+        style = WS_POPUP | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
+    }
+    if (config.transparent) {
+        ex_style |= WS_EX_LAYERED | WS_EX_COMPOSITED;
+    }
+    if (config.always_on_top) {
+        ex_style |= WS_EX_TOPMOST;
+    }
+    if (config.modal && !config.parent_id.empty()) {
+        ex_style |= WS_EX_DLGMODALFRAME;
+    }
+
+    HWND parent = nullptr;
+    if (!config.parent_id.empty()) {
+        auto parent_win = get_window(config.parent_id);
+        if (parent_win) {
+            parent = static_cast<Win32Window*>(parent_win)->hwnd();
+        }
+    }
+
+    int x = config.x >= 0 ? config.x : CW_USEDEFAULT;
+    int y = config.y >= 0 ? config.y : CW_USEDEFAULT;
+    int w = config.width;
+    int h = config.height;
+
+    HWND hwnd = CreateWindowExW(
+        ex_style,
+        MAKEINTATOM(class_atom_),
+        win32::to_wide(config.title).c_str(),
+        style,
+        x, y, w, h,
+        parent, nullptr,
+        GetModuleHandleW(nullptr),
+        this
+    );
+
+    if (!hwnd) {
+        return nullptr;
+    }
+
+    if (config.frameless) {
+        SetWindowLongPtr(hwnd, GWL_STYLE,
+            GetWindowLongPtr(hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME));
+        MARGINS margins = { -1, -1, -1, -1 };
+        DwmExtendFrameIntoClientArea(hwnd, &margins);
+    }
+
+    auto window = std::make_unique<Win32Window>(config, hwnd);
+
+    if (use_native_window_file_drop(config)) {
+        DragAcceptFiles(hwnd, TRUE);
+    }
+
+    if (config.initial_state == WindowState::Hidden) {
+        ShowWindow(hwnd, SW_HIDE);
+    } else {
+        ShowWindow(hwnd, SW_SHOW);
+    }
+
+    if (config.webview.enabled) {
+        auto webview_config = config.webview;
+        webview_config.frameless = config.frameless;
+        webview_config.scrollbars = config.scrollbars;
+        webview_config.file_drop = config.file_drop;
+        window->set_webview(create_webview(webview_config, hwnd));
+        if (auto* webview = window->webview()) {
+            webview->set_drag_drop_enabled(config.file_drop);
+        }
+    }
+
+    auto* ptr = window.get();
+    windows_[id] = std::move(window);
+    hwnd_to_id_[hwnd] = id;
+
+    if (config.center) {
+        ptr->center();
+    }
+
+    if (config.on_created) {
+        config.on_created();
+    }
+
+    return ptr;
+}
+
+Window* Win32Application::get_window(const std::string& id) {
+    auto it = windows_.find(id);
+    return it != windows_.end() ? it->second.get() : nullptr;
+}
+
+std::vector<Window*> Win32Application::all_windows() {
+    std::vector<Window*> result;
+    for (auto& [id, win] : windows_) {
+        result.push_back(win.get());
+    }
+    return result;
+}
+
+Win32Window* Win32Application::get_window_by_hwnd(HWND hwnd) {
+    auto it = hwnd_to_id_.find(hwnd);
+    if (it == hwnd_to_id_.end()) return nullptr;
+    auto wit = windows_.find(it->second);
+    return wit != windows_.end() ? wit->second.get() : nullptr;
+}
+
+void Win32Application::run() {
+    running_ = true;
+    MSG msg;
+    while (running_) {
+        BOOL ret = GetMessageW(&msg, nullptr, 0, 0);
+        if (ret == 0 || ret == -1) {
+            break;
+        }
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+    }
+}
+
+void Win32Application::quit() {
+    running_ = false;
+    should_quit_ = true;
+    if (config_.on_quit) {
+        config_.on_quit();
+    }
+    PostQuitMessage(0);
+}
+
+void Win32Application::set_tray(const TrayConfig& config) {
+    tray_ = std::make_unique<Win32Tray>(config, hwnd_);
+}
+
+void Win32Application::remove_tray() {
+    tray_.reset();
+}
+
+std::vector<MonitorInfo> Win32Application::monitors() {
+    std::vector<MonitorInfo> result;
+    EnumDisplayMonitors(nullptr, nullptr, [](HMONITOR hmon, HDC, LPRECT, LPARAM lp) -> BOOL {
+        auto* result = reinterpret_cast<std::vector<MonitorInfo>*>(lp);
+        MonitorInfo mi;
+        MONITORINFOEXW mi_ex = { sizeof(mi_ex) };
+        GetMonitorInfoW(hmon, &mi_ex);
+        mi.name = win32::from_wide(mi_ex.szDevice);
+        mi.bounds = { (int)mi_ex.rcMonitor.left, (int)mi_ex.rcMonitor.top,
+                     (int)(mi_ex.rcMonitor.right - mi_ex.rcMonitor.left),
+                     (int)(mi_ex.rcMonitor.bottom - mi_ex.rcMonitor.top) };
+        mi.work_area = { (int)mi_ex.rcWork.left, (int)mi_ex.rcWork.top,
+                        (int)(mi_ex.rcWork.right - mi_ex.rcWork.left),
+                        (int)(mi_ex.rcWork.bottom - mi_ex.rcWork.top) };
+        mi.scale_factor = 1.0f;
+        mi.is_primary = (mi_ex.dwFlags & MONITORINFOF_PRIMARY) != 0;
+        result->push_back(mi);
+        return TRUE;
+    }, reinterpret_cast<LPARAM>(&result));
+    return result;
+}
+
+MonitorInfo Win32Application::primary_monitor() {
+    auto all = monitors();
+    for (auto& m : all) {
+        if (m.is_primary) return m;
+    }
+    return all.front();
+}
+
+std::string Win32Application::clipboard_text() {
+    if (!OpenClipboard(nullptr)) return {};
+    HANDLE data = GetClipboardData(CF_UNICODETEXT);
+    if (!data) {
+        CloseClipboard();
+        return {};
+    }
+    std::wstring wstr = (wchar_t*)data;
+    CloseClipboard();
+    return win32::from_wide(wstr);
+}
+
+void Win32Application::set_clipboard_text(const std::string& text) {
+    if (!OpenClipboard(nullptr)) return;
+    EmptyClipboard();
+    std::wstring wstr = win32::to_wide(text);
+    HGLOBAL mem = GlobalAlloc(GMEM_MOVEABLE, (wstr.size() + 1) * sizeof(wchar_t));
+    wchar_t* dst = (wchar_t*)GlobalLock(mem);
+    wcscpy_s(dst, wstr.size() + 1, wstr.c_str());
+    GlobalUnlock(mem);
+    SetClipboardData(CF_UNICODETEXT, mem);
+    CloseClipboard();
+}
+
+void Win32Application::send_message(const std::string& window_id,
+                                     const std::string& event,
+                                     const std::string& payload) {
+    auto it = message_handlers_.find(window_id);
+    if (it != message_handlers_.end()) {
+        for (auto& handler : it->second) {
+            handler(event, payload);
+        }
+    }
+}
+
+void Win32Application::on_message(const std::string& window_id, MessageHandler handler) {
+    message_handlers_[window_id].push_back(handler);
+}
+
+Application::TimerId Win32Application::set_timeout(uint32_t ms, std::function<void()> callback) {
+    return SetTimer(hwnd_, next_timer_id_++, ms, nullptr);
+}
+
+Application::TimerId Win32Application::set_interval(uint32_t ms, std::function<void()> callback) {
+    return SetTimer(hwnd_, next_timer_id_++, ms, nullptr);
+}
+
+void Win32Application::clear_timer(TimerId id) {
+    KillTimer(hwnd_, id);
+}
+
+void Win32Application::dispatch(std::function<void()> fn) {
+    {
+        std::lock_guard<std::mutex> lock(dispatch_mutex_);
+        dispatch_queue_.push(std::move(fn));
+    }
+    PostMessageW(hwnd_, WM_APP, 0, 0);
+}
+
+LRESULT CALLBACK Win32Application::wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
+    if (msg == WM_CREATE) {
+        auto* cs = reinterpret_cast<CREATESTRUCT*>(lparam);
+        SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(cs->lpCreateParams));
+    }
+    auto* app = reinterpret_cast<Win32Application*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+    if (app) {
+        return app->handle_message(hwnd, msg, wparam, lparam);
+    }
+    return DefWindowProcW(hwnd, msg, wparam, lparam);
+}
+
+LRESULT Win32Application::handle_message(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
+    switch (msg) {
+        case WM_APP: {
+            std::queue<std::function<void()>> pending;
+            {
+                std::lock_guard<std::mutex> lock(dispatch_mutex_);
+                std::swap(pending, dispatch_queue_);
+            }
+            while (!pending.empty()) {
+                auto fn = std::move(pending.front());
+                pending.pop();
+                if (fn) {
+                    fn();
+                }
+            }
+            return 0;
+        }
+
+        case WM_CLOSE:
+            if (hwnd == hwnd_) {
+                if (config_.hide_on_close) {
+                    ShowWindow(hwnd, SW_HIDE);
+                    return 0;
+                }
+                quit();
+            } else {
+                auto* win = get_window_by_hwnd(hwnd);
+                if (win && win->config().on_close_requested && !win->config().on_close_requested()) {
+                    return 0;
+                }
+                DestroyWindow(hwnd);
+            }
+            return 0;
+
+        case WM_HOTKEY: {
+            if (hwnd != hwnd_) {
+                return 0;
+            }
+            auto it = hotkey_ids_.find(static_cast<int>(wparam));
+            if (it != hotkey_ids_.end()) {
+                input::detail::trigger_global_shortcut(it->second);
+            }
+            return 0;
+        }
+
+        case WM_DESTROY:
+            if (shutting_down_) return 0;
+            if (hwnd == hwnd_) {
+                PostQuitMessage(0);
+            } else {
+                auto id_it = hwnd_to_id_.find(hwnd);
+                if (id_it != hwnd_to_id_.end()) {
+                    std::string id = id_it->second;
+                    hwnd_to_id_.erase(id_it);
+                    auto wit = windows_.find(id);
+                    if (wit != windows_.end()) {
+                        auto* win = wit->second.get();
+                        win->nullify_hwnd();
+                        if (win->config().on_closed) win->config().on_closed();
+                        windows_.erase(wit);
+                    }
+                    if (config_.quit_on_last_close && windows_.empty()) {
+                        quit();
+                    }
+                }
+            }
+            return 0;
+
+        case WM_SIZE: {
+            int w = LOWORD(lparam);
+            int h = HIWORD(lparam);
+            ResizeEvent e{{0, 0}, {w, h}};
+            auto* win = get_window_by_hwnd(hwnd);
+            if (win) {
+                win->resize_webview(w, h);
+                if (win->config().on_resize) {
+                    win->config().on_resize(e);
+                }
+            }
+            return 0;
+        }
+
+        case WM_MOVE: {
+            int x = LOWORD(lparam);
+            int y = HIWORD(lparam);
+            MoveEvent e{{x, y}, {x, y}};
+            auto* win = get_window_by_hwnd(hwnd);
+            if (win && win->config().on_move) {
+                win->config().on_move(e);
+            }
+            return 0;
+        }
+
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+        case WM_KEYUP:
+        case WM_SYSKEYUP: {
+            auto* win = get_window_by_hwnd(hwnd);
+            if (!win) {
+                return DefWindowProcW(hwnd, msg, wparam, lparam);
+            }
+
+            if (win->webview()) {
+                return DefWindowProcW(hwnd, msg, wparam, lparam);
+            }
+
+            auto event = input::win32::make_key_event(msg, wparam, lparam, win->id());
+            input::detail::emit_key_event(event);
+
+            if (event.type == input::KeyEventType::KeyDown) {
+                if (win->config().on_key_down) {
+                    win->config().on_key_down(event);
+                }
+            } else if (win->config().on_key_up) {
+                win->config().on_key_up(event);
+            }
+            return 0;
+        }
+
+        case WM_NCHITTEST: {
+            auto* win = get_window_by_hwnd(hwnd);
+            if (!win || !win->config().frameless) return DefWindowProcW(hwnd, msg, wparam, lparam);
+
+            POINT pt = { (int)(short)LOWORD(lparam), (int)(short)HIWORD(lparam) };
+            ScreenToClient(hwnd, &pt);
+
+            switch (win->hit_test({pt.x, pt.y})) {
+                case HitTestRegion::Caption:          return HTCAPTION;
+                case HitTestRegion::ResizeTop:        return HTTOP;
+                case HitTestRegion::ResizeBottom:     return HTBOTTOM;
+                case HitTestRegion::ResizeLeft:       return HTLEFT;
+                case HitTestRegion::ResizeRight:      return HTRIGHT;
+                case HitTestRegion::ResizeTopLeft:    return HTTOPLEFT;
+                case HitTestRegion::ResizeTopRight:   return HTTOPRIGHT;
+                case HitTestRegion::ResizeBottomLeft: return HTBOTTOMLEFT;
+                case HitTestRegion::ResizeBottomRight:return HTBOTTOMRIGHT;
+                default:                              return HTCLIENT;
+            }
+        }
+
+        case WM_ERASEBKGND: {
+            auto* win = get_window_by_hwnd(hwnd);
+            Color bg = win ? win->config().background : Color{255, 255, 255, 255};
+            HDC hdc = reinterpret_cast<HDC>(wparam);
+            RECT rc;
+            GetClientRect(hwnd, &rc);
+            HBRUSH brush = CreateSolidBrush(RGB(bg.r, bg.g, bg.b));
+            FillRect(hdc, &rc, brush);
+            DeleteObject(brush);
+            return 1;
+        }
+
+        case WM_TIMER:
+            return 0;
+
+        case WM_DROPFILES: {
+            auto* win = get_window_by_hwnd(hwnd);
+            if (win && use_native_window_file_drop(win->config()) && win->config().on_file_drop) {
+                HDROP hDrop = reinterpret_cast<HDROP>(wparam);
+                UINT fileCount = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
+                std::vector<std::string> paths;
+                for (UINT i = 0; i < fileCount; ++i) {
+                    UINT pathLen = DragQueryFileW(hDrop, i, nullptr, 0);
+                    if (pathLen > 0) {
+                        std::wstring wpath(pathLen + 1, L'\0');
+                        DragQueryFileW(hDrop, i, &wpath[0], pathLen + 1);
+                        wpath.resize(pathLen);
+                        paths.push_back(win32::from_wide(wpath));
+                    }
+                }
+                DragFinish(hDrop);
+                if (!paths.empty()) {
+                    DropEvent e;
+                    e.paths = std::move(paths);
+                    e.position = {0, 0};
+                    win->config().on_file_drop(e);
+                }
+            }
+            return 0;
+        }
+
+        default:
+            return DefWindowProcW(hwnd, msg, wparam, lparam);
+    }
+}
+
+bool Win32Application::register_global_hotkey(const std::string& id,
+                                              const input::Shortcut& shortcut,
+                                              std::string* error) {
+    unregister_global_hotkey(id);
+
+    if (input::win32::is_modifier_key(shortcut.key)) {
+        if (error) {
+            *error = "Modifier-only global hotkeys are not supported on Windows";
+        }
+        return false;
+    }
+
+    const UINT vk = input::win32::virtual_key_from_key(shortcut.key);
+    if (vk == 0) {
+        if (error) {
+            *error = "Unsupported key for Windows global hotkey";
+        }
+        return false;
+    }
+
+    const int hotkey_id = next_hotkey_id_++;
+    if (!RegisterHotKey(hwnd_, hotkey_id, input::win32::hotkey_modifiers_from_shortcut(shortcut), vk)) {
+        if (error) {
+            *error = "RegisterHotKey failed";
+        }
+        return false;
+    }
+
+    hotkey_ids_[hotkey_id] = id;
+    hotkey_name_to_id_[id] = hotkey_id;
+    return true;
+}
+
+void Win32Application::unregister_global_hotkey(const std::string& id) {
+    auto it = hotkey_name_to_id_.find(id);
+    if (it == hotkey_name_to_id_.end()) {
+        return;
+    }
+
+    UnregisterHotKey(hwnd_, it->second);
+    hotkey_ids_.erase(it->second);
+    hotkey_name_to_id_.erase(it);
+}
+
+void Win32Application::clear_global_hotkeys() {
+    for (const auto& entry : hotkey_ids_) {
+        UnregisterHotKey(hwnd_, entry.first);
+    }
+    hotkey_ids_.clear();
+    hotkey_name_to_id_.clear();
+}
+
+} // namespace wpp

package/framework/src/platform/win32/app_win32.h

@@ -0,0 +1,83 @@
+// ============================================================================
+//  app_win32.h — Win32 Application implementation
+// ============================================================================
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <map>
+#include <memory>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <string>
+#include "window_win32.h"
+#include "tray_win32.h"
+#include <windowpp/windowpp.h>
+
+namespace wpp {
+
+class Win32Application : public Application {
+public:
+    Win32Application(const AppConfig& config);
+    ~Win32Application() override;
+
+    Window* create_window(const WindowConfig& config) override;
+    Window* get_window(const std::string& id) override;
+    std::vector<Window*> all_windows() override;
+
+    void run() override;
+    void quit() override;
+    void set_tray(const TrayConfig& config) override;
+    void remove_tray() override;
+
+    std::vector<MonitorInfo> monitors() override;
+    MonitorInfo primary_monitor() override;
+
+    std::string clipboard_text() override;
+    void set_clipboard_text(const std::string& text) override;
+
+    void send_message(const std::string& window_id,
+                      const std::string& event,
+                      const std::string& payload) override;
+    void on_message(const std::string& window_id, MessageHandler handler) override;
+
+    TimerId set_timeout(uint32_t ms, std::function<void()> callback) override;
+    TimerId set_interval(uint32_t ms, std::function<void()> callback) override;
+    void clear_timer(TimerId id) override;
+
+    void dispatch(std::function<void()> fn) override;
+
+    HWND get_hwnd() const { return hwnd_; }
+    void set_hwnd(HWND h) { hwnd_ = h; }
+
+private:
+    AppConfig config_;
+    HWND hwnd_ = nullptr;
+    ATOM class_atom_ = 0;
+    std::map<std::string, std::unique_ptr<Win32Window>> windows_;
+    std::map<HWND, std::string> hwnd_to_id_;
+    std::unique_ptr<Win32Tray> tray_;
+    std::map<std::string, std::vector<MessageHandler>> message_handlers_;
+    bool running_ = false;
+    bool should_quit_ = false;
+    bool shutting_down_ = false;
+    uint64_t next_timer_id_ = 1;
+    std::mutex dispatch_mutex_;
+    std::queue<std::function<void()>> dispatch_queue_;
+
+    static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+    LRESULT handle_message(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+    Win32Window* get_window_by_hwnd(HWND hwnd);
+    bool register_global_hotkey(const std::string& id, const input::Shortcut& shortcut, std::string* error);
+    void unregister_global_hotkey(const std::string& id);
+    void clear_global_hotkeys();
+
+    std::map<int, std::string> hotkey_ids_;
+    std::map<std::string, int> hotkey_name_to_id_;
+    int next_hotkey_id_ = 1;
+};
+
+} // namespace wpp

package/framework/src/platform/win32/tray_win32.cpp

@@ -0,0 +1,57 @@
+// ============================================================================
+//  tray_win32.cpp — Win32 System Tray implementation
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include "tray_win32.h"
+#include "win32_helpers.h"
+
+namespace wpp {
+
+Win32Tray::Win32Tray(const TrayConfig& config, HWND app_hwnd)
+    : config_(config), app_hwnd_(app_hwnd) {
+
+    nid_.cbSize = sizeof(NOTIFYICONDATAW);
+    nid_.hWnd = app_hwnd_;
+    nid_.uID = 1;
+    nid_.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+    nid_.uCallbackMessage = WM_USER;
+
+    if (!config.icon_path.empty()) {
+        nid_.hIcon = (HICON)LoadImageW(nullptr,
+            win32::to_wide(config.icon_path).c_str(),
+            IMAGE_ICON, 0, 0, LR_LOADFROMFILE);
+    }
+
+    if (!nid_.hIcon) {
+        nid_.hIcon = LoadIconW(nullptr, IDI_APPLICATION);
+    }
+
+    wcscpy_s(nid_.szTip, win32::to_wide(config.tooltip).c_str());
+
+    Shell_NotifyIconW(NIM_ADD, &nid_);
+    update_menu();
+}
+
+Win32Tray::~Win32Tray() {
+    Shell_NotifyIconW(NIM_DELETE, &nid_);
+    if (menu_) DestroyMenu(menu_);
+}
+
+void Win32Tray::update_menu() {
+    if (menu_) DestroyMenu(menu_);
+    menu_ = CreatePopupMenu();
+
+    for (size_t i = 0; i < config_.menu.size(); ++i) {
+        const auto& item = config_.menu[i];
+        if (item.is_separator) {
+            AppendMenuW(menu_, MF_SEPARATOR, 0, nullptr);
+        } else {
+            AppendMenuW(menu_, MF_STRING, (UINT)i,
+                win32::to_wide(item.label).c_str());
+        }
+    }
+}
+
+} // namespace wpp