plusui-native-core 0.1.3 → 0.1.5

package/Core/Features/Tray/tray.cpp

@@ -0,0 +1,310 @@
+#ifdef _WIN32
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0601
+#endif
+#include <windows.h>
+
+#ifndef EXTERN_C
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C extern
+#endif
+#endif
+
+#include <shellapi.h>
+#include <shlobj.h>
+#pragma comment(lib, "shell32.lib")
+#endif
+
+#include <algorithm>
+#include <iostream>
+#include <plusui/tray.hpp>
+#include <string>
+#include <vector>
+
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+
+#ifdef __APPLE__
+#include <Cocoa/Cocoa.h>
+#elif !defined(_WIN32)
+#include <gdk/gdk.h>
+#include <gtk/gtk.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(TrayIcon &&other) noexcept = default;
+TrayIcon &TrayIcon::operator=(TrayIcon &&other) noexcept = default;
+
+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.uID = 1;
+  icon.pImpl->nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+  icon.pImpl->nid.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
+  icon.pImpl->nid.uCallbackMessage = WM_APP + 1; // Example message
+
+  if (!tooltip.empty()) {
+    std::wstring wtooltip(tooltip.begin(), tooltip.end());
+    wcsncpy_s(icon.pImpl->nid.szTip, _countof(icon.pImpl->nid.szTip),
+              wtooltip.c_str(), _TRUNCATE);
+  }
+
+  // Note: nim_add should be called after hwnd is set
+#endif
+
+  return icon;
+}
+
+void TrayIcon::show() {
+  pImpl->visible = true;
+#ifdef _WIN32
+  if (pImpl->hwnd) {
+    pImpl->nid.hWnd = pImpl->hwnd;
+    Shell_NotifyIconW(NIM_ADD, &pImpl->nid);
+  }
+#endif
+}
+
+void TrayIcon::hide() {
+  pImpl->visible = false;
+#ifdef _WIN32
+  Shell_NotifyIconW(NIM_DELETE, &pImpl->nid);
+#endif
+}
+
+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, _countof(pImpl->nid.szTip), wtooltip.c_str(),
+              _TRUNCATE);
+    Shell_NotifyIconW(NIM_MODIFY, &pImpl->nid);
+  }
+#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
+}
+
+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::setIconFromMemory(const unsigned char *data, size_t size) {
+  int width, height, channels;
+  unsigned char *pixels =
+      stbi_load_from_memory(data, (int)size, &width, &height, &channels, 4);
+  if (pixels) {
+    std::vector<uint8_t> pixelVec(pixels, pixels + (width * height * 4));
+
+#ifdef _WIN32
+    // Windows expects BGRA, stb_image returns RGBA
+    for (int i = 0; i < width * height; ++i) {
+      uint8_t r = pixelVec[i * 4 + 0];
+      uint8_t b = pixelVec[i * 4 + 2];
+      pixelVec[i * 4 + 0] = b;
+      pixelVec[i * 4 + 2] = r;
+    }
+    setIconFromData(pixelVec, width, height);
+#elif defined(__APPLE__)
+    // Implementation for macOS (To be implemented)
+#else
+    // Implementation for Linux (GTK) (To be implemented)
+#endif
+
+    stbi_image_free(pixels);
+  }
+}
+
+// Methods removed: show, hide (duplicate definitions)
+
+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());
+    }
+  }
+#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 {
+  HWND hwnd = nullptr;
+  std::unique_ptr<TrayIcon> mainIcon;
+  std::vector<TrayIcon *> icons;
+  std::function<void(TrayIcon &)> onCreatedCallback;
+  std::function<void(int)> onDestroyedCallback;
+  std::string currentIconPath;
+  std::string currentTooltip;
+  bool currentVisible = false;
+};
+
+TrayManager::TrayManager() : pImpl(std::make_unique<Impl>()) {}
+TrayManager::~TrayManager() = default;
+
+TrayManager &TrayManager::instance() {
+  static TrayManager inst;
+  return inst;
+}
+
+void TrayManager::setWindowHandle(void *hwnd) {
+#ifdef _WIN32
+  pImpl->hwnd = (HWND)hwnd;
+  if (pImpl->mainIcon) {
+    pImpl->mainIcon->pImpl->hwnd = pImpl->hwnd;
+  }
+#endif
+}
+
+void TrayManager::setIcon(const std::string &iconPath) {
+  pImpl->currentIconPath = iconPath;
+  if (pImpl->mainIcon) {
+    pImpl->mainIcon->setIcon(iconPath);
+  } else {
+    pImpl->mainIcon =
+        std::make_unique<TrayIcon>(TrayIcon::create("", iconPath));
+#ifdef _WIN32
+    pImpl->mainIcon->pImpl->nid.cbSize = sizeof(NOTIFYICONDATAW);
+    pImpl->mainIcon->pImpl->hwnd = pImpl->hwnd;
+#endif
+  }
+}
+
+void TrayManager::setTooltip(const std::string &tooltip) {
+  pImpl->currentTooltip = tooltip;
+  if (pImpl->mainIcon) {
+    pImpl->mainIcon->setTooltip(tooltip);
+  }
+}
+
+void TrayManager::setVisible(bool visible) {
+  pImpl->currentVisible = visible;
+  if (pImpl->mainIcon) {
+    if (visible)
+      pImpl->mainIcon->show();
+    else
+      pImpl->mainIcon->hide();
+  }
+}
+
+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() {}
+
+} // namespace plusui

package/Core/Features/Tray/tray.ts

@@ -0,0 +1,68 @@
+export interface TrayMenuItem {
+  id: string;
+  label: string;
+  icon?: string;
+  enabled?: boolean;
+  checked?: boolean;
+  separator?: boolean;
+  submenu?: TrayMenuItem[];
+}
+
+export interface TrayIconData {
+  id: number;
+  tooltip: string;
+  iconPath: string;
+  isVisible: boolean;
+}
+
+export class TrayAPI {
+  constructor(
+    private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
+    private eventFn: (event: string, callback: (...args: unknown[]) => void) => () => void
+  ) {}
+
+  async setIcon(iconPath: string): Promise<void> {
+    await this.invokeFn('tray.setIcon', [iconPath]);
+  }
+
+  async setTooltip(tooltip: string): Promise<void> {
+    await this.invokeFn('tray.setTooltip', [tooltip]);
+  }
+
+  async setVisible(visible: boolean): Promise<void> {
+    await this.invokeFn('tray.setVisible', [visible]);
+  }
+
+  async setMenu(items: TrayMenuItem[]): Promise<void> {
+    await this.invokeFn('tray.setMenu', [items]);
+  }
+
+  async setContextMenu(items: TrayMenuItem[]): Promise<void> {
+    await this.invokeFn('tray.setContextMenu', [items]);
+  }
+
+  onClick(callback: (x: number, y: number) => void): () => void {
+    return this.eventFn('tray:click', callback as (...args: unknown[]) => void);
+  }
+
+  onDoubleClick(callback: () => void): () => void {
+    return this.eventFn('tray:doubleClick', callback as (...args: unknown[]) => void);
+  }
+
+  onRightClick(callback: (x: number, y: number) => void): () => void {
+    return this.eventFn('tray:rightClick', callback as (...args: unknown[]) => void);
+  }
+
+  onMenuItemClick(callback: (id: string) => void): () => void {
+    return this.eventFn('tray:menuItemClick', callback as (...args: unknown[]) => void);
+  }
+}
+
+export function createTrayAPI(
+  invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
+  eventFn: (event: string, callback: (...args: unknown[]) => void) => () => void
+): TrayAPI {
+  return new TrayAPI(invokeFn, eventFn);
+}
+
+export default TrayAPI;