Refactor tray and menu icon handling to use Image class

Introduces a new Image class for unified icon management across platforms. Refactors tray icon and menu item APIs to accept and return Image objects instead of raw strings, updating platform-specific implementations and C API bindings accordingly. Example usages in tray and window examples are updated to use the new Image API.

Author: lijy91

examples/tray_icon_example/main.cpp

@@ -3,6 +3,7 @@
 #include <memory>
 #include <thread>
 
+#include "../../src/image.h"
 #include "../../src/menu.h"
 #include "../../src/tray_icon.h"
 #include "../../src/tray_icon_event.h"
@@ -46,7 +47,8 @@ int main() {
   trayIcon->SetTooltip("This is a test tray icon");
 
   // Try to set a system icon (using a system-provided icon)
-  trayIcon->SetIcon("NSImageNameStatusAvailable");
+  auto icon = nativeapi::Image::FromSystemIcon("NSImageNameStatusAvailable");
+  trayIcon->SetIcon(icon);
 
   // Set up event listeners
   trayIcon->AddListener<TrayIconClickedEvent>(

examples/window_example/main.cpp

@@ -45,7 +45,7 @@ int main() {
   std::shared_ptr<TrayIcon> tray_icon_ptr = std::make_shared<TrayIcon>();
   if (tray_icon_ptr != nullptr) {
     TrayIcon& tray_icon = *tray_icon_ptr;
-    tray_icon.SetIcon(
+    auto icon = nativeapi::Image::FromBase64(
         "data:image/"
         "png;base64,"
         "iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAABGdBTUEAALGPC/"
@@ -82,6 +82,7 @@ int main() {
         "WVy6ENA/1l/"
         "XFg23zDhiRuqUXbBi1whJ9enqSQUWa7x3IcWHH0xDhLfUVYSpsWt6LMfZQwwX/"
         "wLVwWPG97osM9Wf7Df6GGOwnsP4BQFiPuOZ8wJUAAAAASUVORK5CYII=");
+    tray_icon.SetIcon(icon);
     std::cout << "Tray ID: " << tray_icon.GetId() << std::endl;
     auto title = tray_icon.GetTitle();
     std::cout << "Tray Title: "

include/nativeapi.h

@@ -18,6 +18,7 @@
 #include "../src/window.h"
 #include "../src/window_event.h"
 #include "../src/window_manager.h"
+#include "../src/image.h"
 
 // Include necessary headers for C API
 #include "../src/capi/accessibility_manager_c.h"
@@ -33,3 +34,4 @@
 #include "../src/capi/tray_manager_c.h"
 #include "../src/capi/window_c.h"
 #include "../src/capi/window_manager_c.h"
+#include "../src/capi/image_c.h"

src/capi/menu_c.cpp

@@ -6,6 +6,7 @@
 #include <memory>
 #include <optional>
 #include "../global_registry.h"
+#include "../image.h"
 #include "../menu.h"
 
 using namespace nativeapi;
@@ -253,42 +254,38 @@ char* native_menu_item_get_label(native_menu_item_t item) {
   }
 }
 
-void native_menu_item_set_icon(native_menu_item_t item, const char* icon) {
+void native_menu_item_set_icon(native_menu_item_t item, native_image_t image) {
   if (!item)
     return;
 
   try {
     auto menu_item = static_cast<MenuItem*>(item);
-    if (icon) {
-      menu_item->SetIcon(std::string(icon));
+    if (image) {
+      // Extract the shared_ptr from the native_image_t handle
+      auto image_ptr = static_cast<std::shared_ptr<Image>*>(image);
+      menu_item->SetIcon(*image_ptr);
     } else {
-      menu_item->SetIcon(std::nullopt);
+      menu_item->SetIcon(nullptr);
     }
   } catch (...) {
     // Ignore exceptions
   }
 }
 
-char* native_menu_item_get_icon(native_menu_item_t item) {
+native_image_t native_menu_item_get_icon(native_menu_item_t item) {
   if (!item)
     return nullptr;
 
   try {
     auto menu_item = static_cast<MenuItem*>(item);
-    auto iconOpt = menu_item->GetIcon();
+    auto image = menu_item->GetIcon();
 
-    if (!iconOpt.has_value()) {
+    if (!image) {
       return nullptr;
     }
 
-    const std::string& icon = iconOpt.value();
-
-    // Allocate C string and copy content
-    char* result = static_cast<char*>(malloc(icon.length() + 1));
-    if (result) {
-      strcpy(result, icon.c_str());
-    }
-    return result;
+    // Create a new shared_ptr wrapper for the C API
+    return new std::shared_ptr<Image>(image);
   } catch (...) {
     return nullptr;
   }

src/capi/tray_icon_c.cpp

@@ -4,6 +4,7 @@
 #include <memory>
 #include <optional>
 #include "../global_registry.h"
+#include "../image.h"
 #include "../tray_icon.h"
 #include "../tray_icon_event.h"
 #include "string_utils_c.h"
@@ -83,18 +84,43 @@ native_tray_icon_id_t native_tray_icon_get_id(native_tray_icon_t tray_icon) {
   }
 }
 
-void native_tray_icon_set_icon(native_tray_icon_t tray_icon, const char* icon) {
-  if (!tray_icon || !icon)
+void native_tray_icon_set_icon(native_tray_icon_t tray_icon, native_image_t image) {
+  if (!tray_icon)
     return;
 
   try {
     auto tray_icon_ptr = static_cast<TrayIcon*>(tray_icon);
-    tray_icon_ptr->SetIcon(icon);
+    if (image) {
+      // Extract the shared_ptr from the native_image_t handle
+      auto image_ptr = static_cast<std::shared_ptr<Image>*>(image);
+      tray_icon_ptr->SetIcon(*image_ptr);
+    } else {
+      tray_icon_ptr->SetIcon(nullptr);
+    }
   } catch (...) {
     // Ignore exceptions
   }
 }
 
+native_image_t native_tray_icon_get_icon(native_tray_icon_t tray_icon) {
+  if (!tray_icon)
+    return nullptr;
+
+  try {
+    auto tray_icon_ptr = static_cast<TrayIcon*>(tray_icon);
+    auto image = tray_icon_ptr->GetIcon();
+
+    if (!image) {
+      return nullptr;
+    }
+
+    // Create a new shared_ptr wrapper for the C API
+    return new std::shared_ptr<Image>(image);
+  } catch (...) {
+    return nullptr;
+  }
+}
+
 void native_tray_icon_set_title(native_tray_icon_t tray_icon,
                                 const char* title) {
   if (!tray_icon)

src/image.cpp

@@ -0,0 +1,72 @@
+#include "image.h"
+#include <memory>
+#include <string>
+
+namespace nativeapi {
+
+// Minimal implementation of Image class
+class Image::Impl {
+ public:
+  std::string source_;
+  Size size_;
+  std::string format_;
+
+  Impl() : size_({0, 0}), format_("Unknown") {}
+};
+
+Image::Image() : pimpl_(std::make_unique<Impl>()) {}
+
+Image::~Image() = default;
+
+Image::Image(const Image& other) : pimpl_(std::make_unique<Impl>(*other.pimpl_)) {}
+
+Image::Image(Image&& other) noexcept : pimpl_(std::move(other.pimpl_)) {}
+
+std::shared_ptr<Image> Image::FromFile(const std::string& file_path) {
+  auto image = std::make_shared<Image>();
+  image->pimpl_->source_ = file_path;
+  image->pimpl_->size_ = {16, 16}; // Placeholder size
+  image->pimpl_->format_ = "PNG"; // Placeholder format
+  return image;
+}
+
+std::shared_ptr<Image> Image::FromBase64(const std::string& base64_data) {
+  auto image = std::make_shared<Image>();
+  image->pimpl_->source_ = base64_data;
+  image->pimpl_->size_ = {16, 16}; // Placeholder size
+  image->pimpl_->format_ = "PNG"; // Placeholder format
+  return image;
+}
+
+std::shared_ptr<Image> Image::FromSystemIcon(const std::string& icon_name) {
+  auto image = std::make_shared<Image>();
+  image->pimpl_->source_ = icon_name;
+  image->pimpl_->size_ = {16, 16}; // Placeholder size
+  image->pimpl_->format_ = "System"; // Placeholder format
+  return image;
+}
+
+Size Image::GetSize() const {
+  return pimpl_->size_;
+}
+
+std::string Image::GetFormat() const {
+  return pimpl_->format_;
+}
+
+std::string Image::ToBase64() const {
+  // Placeholder implementation - return a simple base64 encoded 1x1 pixel
+  return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChAI9jU77kQAAAABJRU5ErkJggg==";
+}
+
+bool Image::SaveToFile(const std::string& file_path) const {
+  // Placeholder implementation
+  return true;
+}
+
+void* Image::GetNativeObjectInternal() const {
+  // Placeholder implementation - return nullptr for now
+  return nullptr;
+}
+
+} // namespace nativeapi

src/image.h

@@ -9,28 +9,6 @@
 
 namespace nativeapi {
 
-/**
- * @brief Image source type enumeration.
- *
- * Defines the different ways an image can be initialized.
- */
-enum class ImageSourceType {
-  /**
-   * Image is loaded from a file path on disk.
-   */
-  FilePath,
-
-  /**
-   * Image is initialized from base64-encoded data.
-   */
-  Base64,
-
-  /**
-   * Image is a platform-specific system icon.
-   */
-  SystemIcon
-};
-
 /**
  * @brief Image class for cross-platform image handling.
  *
@@ -93,6 +71,13 @@ enum class ImageSourceType {
  */
 class Image : public NativeObjectProvider {
  public:
+  /**
+   * @brief Default constructor.
+   *
+   * Creates an empty image instance.
+   */
+  Image();
+
   /**
    * @brief Destructor.
    *

src/platform/linux/menu_linux.cpp

@@ -8,6 +8,7 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
+#include "../../image.h"
 #include "../../menu.h"
 
 namespace nativeapi {
@@ -26,7 +27,6 @@ class MenuItem::Impl {
   Impl(GtkWidget* menu_item, MenuItemType type)
       : gtk_menu_item_(menu_item),
         title_(""),
-        icon_(""),
         tooltip_(""),
         type_(type),
         enabled_(true),
@@ -37,7 +37,7 @@ class MenuItem::Impl {
 
   GtkWidget* gtk_menu_item_;
   std::optional<std::string> title_;
-  std::optional<std::string> icon_;
+  std::shared_ptr<Image> image_;
   std::optional<std::string> tooltip_;
   MenuItemType type_;
   bool enabled_;
@@ -116,13 +116,13 @@ std::optional<std::string> MenuItem::GetLabel() const {
   return pimpl_->title_;
 }
 
-void MenuItem::SetIcon(const std::optional<std::string>& icon) {
-  pimpl_->icon_ = icon;
+void MenuItem::SetIcon(std::shared_ptr<Image> image) {
+  pimpl_->image_ = image;
   // TODO: Implement icon setting for GTK menu item
 }
 
-std::optional<std::string> MenuItem::GetIcon() const {
-  return pimpl_->icon_;
+std::shared_ptr<Image> MenuItem::GetIcon() const {
+  return pimpl_->image_;
 }
 
 void MenuItem::SetTooltip(const std::optional<std::string>& tooltip) {