plusui-native-core 0.1.0

package/Core/src/display.cpp

@@ -0,0 +1,424 @@
+#include "display.hpp"
+#include <vector>
+#include <algorithm>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <winuser.h>
+#pragma comment(lib, "user32.lib")
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#include <CoreGraphics/CoreGraphics.h>
+#else
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#endif
+
+namespace plusui {
+
+struct DisplayManager::Impl {
+    std::vector<Display> displays;
+    std::function<void(const Display&)> onConnectCallback;
+    std::function<void(int)> onDisconnectCallback;
+    std::function<void(const Display&)> onChangeCallback;
+};
+
+DisplayManager::DisplayManager() : pImpl(std::make_unique<Impl>()) {
+    refresh();
+}
+
+DisplayManager::~DisplayManager() = default;
+
+DisplayManager& DisplayManager::instance() {
+    static DisplayManager inst;
+    return inst;
+}
+
+std::vector<Display> DisplayManager::getAllDisplays() {
+#ifdef _WIN32
+    pImpl->displays.clear();
+    
+    int i = 0;
+    DISPLAY_DEVICE dd = {};
+    dd.cb = sizeof(dd);
+    
+    while (EnumDisplayDevices(nullptr, i, &dd, 0)) {
+        if (dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) {
+            i++;
+            continue;
+        }
+        
+        Display d;
+        d.id = i;
+        d.name = dd.DeviceName;
+        
+        DEVMODE dm = {};
+        dm.dmSize = sizeof(dm);
+        if (EnumDisplaySettings(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) {
+            d.bounds.x = dm.dmPosition.x;
+            d.bounds.y = dm.dmPosition.y;
+            d.bounds.width = dm.dmPelsWidth;
+            d.bounds.height = dm.dmPelsHeight;
+            d.resolution.width = dm.dmPelsWidth;
+            d.resolution.height = dm.dmPelsHeight;
+            d.currentMode.width = dm.dmPelsWidth;
+            d.currentMode.height = dm.dmPelsHeight;
+            d.currentMode.refreshRate = dm.dmDisplayFrequency;
+        }
+        
+        d.isPrimary = (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE);
+        
+        HMONITOR hMon = MonitorFromWindow(nullptr, MONITOR_DEFAULTTOPRIMARY);
+        MONITORINFO mi = {};
+        mi.cbSize = sizeof(mi);
+        if (GetMonitorInfo(hMon, &mi)) {
+            d.workArea.x = mi.rcWork.left;
+            d.workArea.y = mi.rcWork.top;
+            d.workArea.width = mi.rcWork.right - mi.rcWork.left;
+            d.workArea.height = mi.rcWork.bottom - mi.rcWork.top;
+        }
+        
+        d.scaleFactor = 1.0;
+        d.isConnected = true;
+        
+        pImpl->displays.push_back(d);
+        i++;
+    }
+    
+#elif defined(__APPLE__)
+    pImpl->displays.clear();
+    
+    CGDirectDisplayID mainDisplay = CGMainDisplayID();
+    CGDisplayCount count;
+    CGGetActiveDisplayList(0, nullptr, &count);
+    
+    std::vector<CGDirectDisplayID> displays(count);
+    CGGetActiveDisplayList(count, displays.data(), &count);
+    
+    for (uint32_t i = 0; i < count; i++) {
+        Display d;
+        d.id = displays[i];
+        
+        CGRect bounds = CGDisplayBounds(displays[i]);
+        d.bounds.x = (int)bounds.origin.x;
+        d.bounds.y = (int)bounds.origin.y;
+        d.bounds.width = (int)bounds.size.width;
+        d.bounds.height = (int)bounds.size.height;
+        d.resolution.width = (int)bounds.size.width;
+        d.resolution.height = (int)bounds.size.height;
+        
+        d.currentMode.width = (int)bounds.size.width;
+        d.currentMode.height = (int)bounds.size.height;
+        d.currentMode.refreshRate = (int)CGDisplayModeGetRefreshRate(CGDisplayCopyDisplayMode(displays[i]));
+        
+        d.isPrimary = (displays[i] == mainDisplay);
+        d.isInternal = CGDisplayIsBuiltin(displays[i]);
+        d.isConnected = true;
+        
+        NSScreen* screen = [NSScreen screens][i];
+        if (screen) {
+            NSRect frame = [screen visibleFrame];
+            d.workArea.x = (int)frame.origin.x;
+            d.workArea.y = (int)(CGDisplayPixelsHigh(CGMainDisplayID()) - frame.origin.y - frame.size.height);
+            d.workArea.width = (int)frame.size.width;
+            d.workArea.height = (int)frame.size.height;
+        }
+        
+        d.scaleFactor = CGDisplayPixelsHigh(mainDisplay) / CGDisplayPixelsHigh(displays[i]);
+        
+        pImpl->displays.push_back(d);
+    }
+    
+#else
+    pImpl->displays.clear();
+    
+    gtk_init_check(0, nullptr);
+    
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return pImpl->displays;
+    
+    int nMonitors = gdk_display_get_n_monitors(display);
+    
+    for (int i = 0; i < nMonitors; i++) {
+        GdkMonitor* monitor = gdk_display_get_monitor(display, i);
+        
+        Display d;
+        d.id = i;
+        
+        const char* name = gdk_monitor_get_model(monitor);
+        d.name = name ? name : "Display " + std::to_string(i);
+        
+        GdkRectangle rect;
+        gdk_monitor_get_geometry(monitor, &rect);
+        d.bounds.x = rect.x;
+        d.bounds.y = rect.y;
+        d.bounds.width = rect.width;
+        d.bounds.height = rect.height;
+        d.resolution.width = rect.width;
+        d.resolution.height = rect.height;
+        
+        d.currentMode.width = rect.width;
+        d.currentMode.height = rect.height;
+        d.currentMode.refreshRate = gdk_monitor_get_refresh_rate(monitor) / 1000;
+        
+        d.isPrimary = (i == 0);
+        d.scaleFactor = gdk_monitor_get_scale_factor(monitor);
+        
+        GdkRectangle work;
+        gdk_monitor_get_workarea(monitor, &work);
+        d.workArea.x = work.x;
+        d.workArea.y = work.y;
+        d.workArea.width = work.width;
+        d.workArea.height = work.height;
+        
+        d.isConnected = gdk_monitor_is_connected(monitor);
+        
+        pImpl->displays.push_back(d);
+    }
+#endif
+    
+    return pImpl->displays;
+}
+
+Display DisplayManager::getPrimaryDisplay() {
+    auto displays = getAllDisplays();
+    auto it = std::find_if(displays.begin(), displays.end(), 
+        [](const Display& d) { return d.isPrimary; });
+    return it != displays.end() ? *it : Display{};
+}
+
+Display DisplayManager::getDisplayAt(int x, int y) {
+    auto displays = getAllDisplays();
+    for (const auto& d : displays) {
+        if (x >= d.bounds.x && x < d.bounds.x + d.bounds.width &&
+            y >= d.bounds.y && y < d.bounds.y + d.bounds.height) {
+            return d;
+        }
+    }
+    return getPrimaryDisplay();
+}
+
+Display DisplayManager::getDisplayAtCursor() {
+#ifdef _WIN32
+    POINT pt;
+    GetCursorPos(&pt);
+    return getDisplayAt(pt.x, pt.y);
+#elif defined(__APPLE__)
+    CGPoint pt = CGEventGetLocation(CGEventCreate(nullptr));
+    return getDisplayAt((int)pt.x, (int)pt.y);
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return Display{};
+    
+    GdkSeat* seat = gdk_display_get_default_seat(display);
+    if (!seat) return Display{};
+    
+    GdkDevice* pointer = gdk_seat_get_pointer(seat);
+    if (!pointer) return Display{};
+    
+    gint x, y;
+    gdk_device_get_position(pointer, nullptr, &x, &y);
+    return getDisplayAt(x, y);
+#endif
+}
+
+Display DisplayManager::getDisplayById(int id) {
+    auto displays = getAllDisplays();
+    auto it = std::find_if(displays.begin(), displays.end(), 
+        [id](const Display& d) { return d.id == id; });
+    return it != displays.end() ? *it : Display{};
+}
+
+void DisplayManager::onDisplayConnected(std::function<void(const Display&)> callback) {
+    pImpl->onConnectCallback = callback;
+}
+
+void DisplayManager::onDisplayDisconnected(std::function<void(int)> callback) {
+    pImpl->onDisconnectCallback = callback;
+}
+
+void DisplayManager::onDisplayChanged(std::function<void(const Display&)> callback) {
+    pImpl->onChangeCallback = callback;
+}
+
+void DisplayManager::refresh() {
+    getAllDisplays();
+}
+
+bool DisplayManager::setDisplayMode(int displayId, const DisplayMode& mode) {
+#ifdef _WIN32
+    DEVMODE dm = {};
+    dm.dmSize = sizeof(dm);
+    dm.dmPelsWidth = mode.width;
+    dm.dmPelsHeight = mode.height;
+    dm.dmDisplayFrequency = mode.refreshRate;
+    dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+    
+    return ChangeDisplaySettingsEx(nullptr, &dm, nullptr, CDS_UPDATEREGISTRY, nullptr) == DISP_CHANGE_SUCCESSFUL;
+#else
+    (void)displayId;
+    (void)mode;
+    return false;
+#endif
+}
+
+bool DisplayManager::setPosition(int displayId, int x, int y) {
+#ifdef _WIN32
+    DEVMODE dm = {};
+    dm.dmSize = sizeof(dm);
+    if (EnumDisplaySettings(nullptr, ENUM_CURRENT_SETTINGS, &dm)) {
+        dm.dmPosition.x = x;
+        dm.dmPosition.y = y;
+        dm.dmFields = DM_POSITION;
+        return ChangeDisplaySettingsEx(nullptr, &dm, nullptr, CDS_UPDATEREGISTRY, nullptr) == DISP_CHANGE_SUCCESSFUL;
+    }
+#else
+    (void)displayId;
+    (void)x;
+    (void)y;
+#endif
+    return false;
+}
+
+bool DisplayManager::turnOff(int displayId) {
+#ifdef _WIN32
+    (void)displayId;
+    return SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, (LPARAM)2) != 0;
+#else
+    (void)displayId;
+    return false;
+#endif
+}
+
+int Screen::getWidth() {
+#ifdef _WIN32
+    return GetSystemMetrics(SM_CXSCREEN);
+#elif defined(__APPLE__)
+    return (int)CGDisplayPixelsWide(CGMainDisplayID());
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 0;
+    return gdk_monitor_get_width_mm(monitor);
+#endif
+}
+
+int Screen::getHeight() {
+#ifdef _WIN32
+    return GetSystemMetrics(SM_CYSCREEN);
+#elif defined(__APPLE__)
+    return (int)CGDisplayPixelsHigh(CGMainDisplayID());
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 0;
+    return gdk_monitor_get_height_mm(monitor);
+#endif
+}
+
+int Screen::getWidthMM() {
+#ifdef _WIN32
+    HDC hdc = GetDC(nullptr);
+    int width = GetDeviceCaps(hdc, HORZSIZE);
+    ReleaseDC(nullptr, hdc);
+    return width;
+#elif defined(__APPLE__)
+    return 0;
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 0;
+    return gdk_monitor_get_width_mm(monitor);
+#endif
+}
+
+int Screen::getHeightMM() {
+#ifdef _WIN32
+    HDC hdc = GetDC(nullptr);
+    int height = GetDeviceCaps(hdc, VERTSIZE);
+    ReleaseDC(nullptr, hdc);
+    return height;
+#elif defined(__APPLE__)
+    return 0;
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 0;
+    return gdk_monitor_get_height_mm(monitor);
+#endif
+}
+
+double Screen::getScaleFactor() {
+#ifdef _WIN32
+    HDC hdc = GetDC(nullptr);
+    int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
+    ReleaseDC(nullptr, hdc);
+    return dpi / 96.0;
+#elif defined(__APPLE__)
+    return CGDisplayPixelsHigh(CGMainDisplayID()) / CGDisplayBounds(CGMainDisplayID()).size.height;
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 1.0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 1.0;
+    return gdk_monitor_get_scale_factor(monitor);
+#endif
+}
+
+double Screen::getRefreshRate() {
+#ifdef _WIN32
+    DEVMODE dm = {};
+    if (EnumDisplaySettings(nullptr, ENUM_CURRENT_SETTINGS, &dm)) {
+        return dm.dmDisplayFrequency;
+    }
+    return 60.0;
+#elif defined(__APPLE__)
+    return CGDisplayModeGetRefreshRate(CGDisplayCopyDisplayMode(CGMainDisplayID()));
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return 60.0;
+    GdkMonitor* monitor = gdk_display_get_primary_monitor(display);
+    if (!monitor) return 60.0;
+    return gdk_monitor_get_refresh_rate(monitor) / 1000.0;
+#endif
+}
+
+bool Screen::isMain() {
+    return true;
+}
+
+bool Screen::isMulti() {
+#ifdef _WIN32
+    return GetSystemMetrics(SM_CMONITORS) > 1;
+#elif defined(__APPLE__)
+    return CGDisplayCount() > 1;
+#else
+    gtk_init_check(0, nullptr);
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) return false;
+    return gdk_display_get_n_monitors(display) > 1;
+#endif
+}
+
+std::string Screen::getName() {
+#ifdef _WIN32
+    return "Primary Screen";
+#elif defined(__APPLE__)
+    return [[[NSScreen mainScreen] localizedName] UTF8String];
+#else
+    return "Primary Screen";
+#endif
+}
+
+}

package/Core/src/tray.cpp

@@ -0,0 +1,275 @@
+#include "tray.hpp"
+#include <iostream>
+#include <algorithm>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <shellapi.h>
+#pragma comment(lib, "shell32.lib")
+#elif defined(__APPLE__)
+#include <Cocoa/Cocoa.h>
+#else
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#endif
+
+namespace plusui {
+
+struct TrayIcon::Impl {
+    int id = 0;
+    std::string tooltip;
+    std::string iconPath;
+    bool visible = true;
+    
+    std::function<void(int, int)> clickCallback;
+    std::function<void(int, int)> rightClickCallback;
+    std::function<void()> doubleClickCallback;
+    std::function<void(const std::string&)> menuItemCallback;
+    std::vector<TrayMenuItem> menuItems;
+
+#ifdef _WIN32
+    NOTIFYICONDATAW nid = {};
+    HWND hwnd = nullptr;
+#endif
+};
+
+TrayIcon::TrayIcon() : pImpl(std::make_unique<Impl>()) {}
+
+TrayIcon::~TrayIcon() {
+    dispose();
+}
+
+TrayIcon TrayIcon::create(const std::string& tooltip, const std::string& iconPath) {
+    TrayIcon icon;
+    icon.pImpl->tooltip = tooltip;
+    icon.pImpl->iconPath = iconPath;
+    
+#ifdef _WIN32
+    icon.pImpl->nid.cbSize = sizeof(NOTIFYICONDATAW);
+    icon.pImpl->nid.uID = 1;
+    icon.pImpl->nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+    icon.pImpl->nid.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
+    
+    if (!tooltip.empty()) {
+        std::wstring wtooltip(tooltip.begin(), tooltip.end());
+        wcsncpy_s(icon.pImpl->nid.szTip, wtooltip.c_str(), _TRUNCATE);
+    }
+    
+    Shell_NotifyIconW(NIM_ADD, &icon.pImpl->nid);
+#endif
+
+#ifdef __APPLE__
+    NSStatusItem* item = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength];
+    if (!iconPath.empty()) {
+        NSImage* image = [NSImage imageNamed:[NSString stringWithUTF8String:iconPath.c_str()]];
+        if (image) {
+            [item.button setImage:image];
+        }
+    }
+    if (!tooltip.empty()) {
+        [item.button setToolTip:[NSString stringWithUTF8String:tooltip.c_str()]];
+    }
+#endif
+
+#ifndef _WIN32
+#ifndef __APPLE__
+    gtk_init_check(0, nullptr);
+#endif
+#endif
+
+    return icon;
+}
+
+void TrayIcon::setTooltip(const std::string& tooltip) {
+    pImpl->tooltip = tooltip;
+    
+#ifdef _WIN32
+    if (!tooltip.empty()) {
+        std::wstring wtooltip(tooltip.begin(), tooltip.end());
+        wcsncpy_s(pImpl->nid.szTip, wtooltip.c_str(), _TRUNCATE);
+        Shell_NotifyIconW(NIM_MODIFY, &pImpl->nid);
+    }
+#endif
+
+#ifdef __APPLE__
+#endif
+}
+
+void TrayIcon::setIcon(const std::string& iconPath) {
+    pImpl->iconPath = iconPath;
+    
+#ifdef _WIN32
+    if (!iconPath.empty()) {
+        std::wstring wpath(iconPath.begin(), iconPath.end());
+        pImpl->nid.hIcon = (HICON)LoadImageW(nullptr, wpath.c_str(), IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
+        Shell_NotifyIconW(NIM_MODIFY, &pImpl->nid);
+    }
+#endif
+
+#ifdef __APPLE__
+    if (!iconPath.empty()) {
+        NSImage* image = [NSImage imageNamed:[NSString stringWithUTF8String:iconPath.c_str()]];
+        if (image) {
+            [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength].button.image = image;
+        }
+    }
+#endif
+}
+
+void TrayIcon::setIconFromData(const std::vector<uint8_t>& data, int width, int height) {
+#ifdef _WIN32
+    if (!data.empty()) {
+        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 && data.size() >= (size_t)width * height * 4) {
+            memcpy(bits, data.data(), width * height * 4);
+            
+            ICONINFO ii = {};
+            ii.fIcon = TRUE;
+            ii.hbmColor = hbm;
+            ii.hbmMask = hbm;
+            
+            HICON hIcon = CreateIconIndirect(&ii);
+            if (hIcon) {
+                pImpl->nid.hIcon = hIcon;
+                Shell_NotifyIconW(NIM_MODIFY, &pImpl->nid);
+                DestroyIcon(hIcon);
+            }
+            DeleteObject(hbm);
+        }
+    }
+#endif
+}
+
+void TrayIcon::show() {
+    pImpl->visible = true;
+#ifdef _WIN32
+    pImpl->nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+    Shell_NotifyIconW(NIM_ADD, &pImpl->nid);
+#endif
+}
+
+void TrayIcon::hide() {
+    pImpl->visible = false;
+#ifdef _WIN32
+    Shell_NotifyIconW(NIM_DELETE, &pImpl->nid);
+#endif
+}
+
+bool TrayIcon::isVisible() const {
+    return pImpl->visible;
+}
+
+void TrayIcon::setMenu(const std::vector<TrayMenuItem>& items) {
+    pImpl->menuItems = items;
+    
+#ifdef _WIN32
+    HMENU hMenu = CreatePopupMenu();
+    
+    for (const auto& item : items) {
+        if (item.separator) {
+            AppendMenuW(hMenu, MF_SEPARATOR, 0, nullptr);
+        } else {
+            std::wstring label(item.label.begin(), item.label.end());
+            UINT flags = MF_STRING;
+            if (!item.enabled) flags |= MF_DISABLED;
+            if (item.checked) flags |= MF_CHECKED;
+            
+            AppendMenuW(hMenu, flags, (UINT_PTR)item.id.c_str(), label.c_str());
+            
+            if (!item.submenu.empty()) {
+                HMENU hSubMenu = CreatePopupMenu();
+                for (const auto& sub : item.submenu) {
+                    std::wstring subLabel(sub.label.begin(), sub.label.end());
+                    AppendMenuW(hSubMenu, MF_STRING, (UINT_PTR)sub.id.c_str(), subLabel.c_str());
+                }
+                SetMenuItemInfoW(hMenu, GetMenuItemCount(hMenu) - 1, TRUE, nullptr);
+            }
+        }
+    }
+    
+    pImpl->nid.hWnd = GetForegroundWindow();
+    pImpl->nid.uCallbackMessage = WM_USER;
+    
+    Shell_NotifyIconW(NIM_MODIFY, &pImpl->nid);
+#endif
+
+#ifdef __APPLE__
+    NSMenu* menu = [[NSMenu alloc] init];
+    
+    for (const auto& item : items) {
+        if (item.separator) {
+            [menu addItem:[NSMenuItem separatorItem]];
+        } else {
+            NSMenuItem* menuItem = [[NSMenuItem alloc] 
+                initWithTitle:[NSString stringWithUTF8String:item.label.c_str()]
+                action:@selector(trayMenuItemClicked:)
+                keyEquivalent:@""];
+            menuItem.enabled = item.enabled;
+            [menu addItem:menuItem];
+        }
+    }
+#endif
+}
+
+void TrayIcon::setContextMenu(const std::vector<TrayMenuItem>& items) {
+    setMenu(items);
+}
+
+void TrayIcon::onClick(std::function<void(int, int)> callback) {
+    pImpl->clickCallback = callback;
+}
+
+void TrayIcon::onRightClick(std::function<void(int, int)> callback) {
+    pImpl->rightClickCallback = callback;
+}
+
+void TrayIcon::onDoubleClick(std::function<void()> callback) {
+    pImpl->doubleClickCallback = callback;
+}
+
+void TrayIcon::onMenuItemClick(std::function<void(const std::string&)> callback) {
+    pImpl->menuItemCallback = callback;
+}
+
+void TrayIcon::dispose() {
+#ifdef _WIN32
+    Shell_NotifyIconW(NIM_DELETE, &pImpl->nid);
+#endif
+}
+
+struct TrayManager::Impl {
+    std::vector<TrayIcon*> icons;
+    std::function<void(TrayIcon&)> onCreatedCallback;
+    std::function<void(int)> onDestroyedCallback;
+};
+
+TrayManager& TrayManager::instance() {
+    static TrayManager inst;
+    return inst;
+}
+
+std::vector<TrayIcon*> TrayManager::getIcons() {
+    return pImpl->icons;
+}
+
+void TrayManager::onTrayCreated(std::function<void(TrayIcon&)> callback) {
+    pImpl->onCreatedCallback = callback;
+}
+
+void TrayManager::onTrayDestroyed(std::function<void(int)> callback) {
+    pImpl->onDestroyedCallback = callback;
+}
+
+void TrayManager::refresh() {
+}
+
+}