Add cross-platform window background color support

Introduces a new Color abstraction and C API for color manipulation, including parsing from hex and conversion utilities. Adds SetBackgroundColor and GetBackgroundColor methods to the Window class and implements them for all supported platforms. Updates the C API to allow setting and retrieving window background color, and provides platform-specific implementations for Windows, macOS, Linux, Android, iOS, and OpenHarmony.

Author: lijy91

src/capi/color_c.cpp

@@ -0,0 +1,69 @@
+#include "color_c.h"
+#include "../foundation/color.h"
+#include <cstring>
+
+using namespace nativeapi;
+
+// Helper function to convert C++ Color to native_color_t
+static native_color_t to_native_color(const Color& color) {
+  native_color_t result;
+  result.r = color.r;
+  result.g = color.g;
+  result.b = color.b;
+  result.a = color.a;
+  return result;
+}
+
+// Helper function to convert native_color_t to C++ Color
+static Color from_native_color(const native_color_t& color) {
+  return Color{color.r, color.g, color.b, color.a};
+}
+
+native_color_t native_color_from_rgba(unsigned char red,
+                                      unsigned char green,
+                                      unsigned char blue,
+                                      unsigned char alpha) {
+  native_color_t color;
+  color.r = red;
+  color.g = green;
+  color.b = blue;
+  color.a = alpha;
+  return color;
+}
+
+bool native_color_from_hex(const char* hex, native_color_t* out_color) {
+  if (!hex || !out_color) {
+    return false;
+  }
+
+  try {
+    Color color = Color::FromHex(hex);
+    *out_color = to_native_color(color);
+    return true;
+  } catch (...) {
+    return false;
+  }
+}
+
+uint32_t native_color_to_rgba(native_color_t color) {
+  Color cpp_color = from_native_color(color);
+  return cpp_color.ToRGBA();
+}
+
+uint32_t native_color_to_argb(native_color_t color) {
+  Color cpp_color = from_native_color(color);
+  return cpp_color.ToARGB();
+}
+
+// Predefined color constants
+extern "C" {
+  const native_color_t NATIVE_COLOR_TRANSPARENT = {0, 0, 0, 0};
+  const native_color_t NATIVE_COLOR_BLACK = {0, 0, 0, 255};
+  const native_color_t NATIVE_COLOR_WHITE = {255, 255, 255, 255};
+  const native_color_t NATIVE_COLOR_RED = {255, 0, 0, 255};
+  const native_color_t NATIVE_COLOR_GREEN = {0, 255, 0, 255};
+  const native_color_t NATIVE_COLOR_BLUE = {0, 0, 255, 255};
+  const native_color_t NATIVE_COLOR_YELLOW = {255, 255, 0, 255};
+  const native_color_t NATIVE_COLOR_CYAN = {0, 255, 255, 255};
+  const native_color_t NATIVE_COLOR_MAGENTA = {255, 0, 255, 255};
+}

src/capi/color_c.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#if _WIN32
+#define FFI_PLUGIN_EXPORT __declspec(dllexport)
+#else
+#define FFI_PLUGIN_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @struct native_color_t
+ * @brief Representation of a color with RGBA components
+ *
+ * Each component is represented as an unsigned byte (0-255).
+ * Alpha value: 0 = fully transparent, 255 = fully opaque
+ */
+typedef struct {
+  unsigned char r;  /** Red component (0-255) */
+  unsigned char g;  /** Green component (0-255) */
+  unsigned char b;  /** Blue component (0-255) */
+  unsigned char a;  /** Alpha component (0-255) */
+} native_color_t;
+
+/**
+ * @brief Creates a color from RGBA values.
+ *
+ * @param red Red component (0-255)
+ * @param green Green component (0-255)
+ * @param blue Blue component (0-255)
+ * @param alpha Alpha component (0-255)
+ * @return Color instance with specified values
+ */
+FFI_PLUGIN_EXPORT
+native_color_t native_color_from_rgba(unsigned char red,
+                                      unsigned char green,
+                                      unsigned char blue,
+                                      unsigned char alpha);
+
+/**
+ * @brief Creates a color from a hexadecimal string.
+ *
+ * Supports multiple hex color formats:
+ * - "#RGB" - 3-digit hex (e.g., "#F00" = red)
+ * - "#RGBA" - 4-digit hex with alpha
+ * - "#RRGGBB" - 6-digit hex (e.g., "#FF0000" = red)
+ * - "#RRGGBBAA" - 8-digit hex with alpha
+ *
+ * @param hex Hexadecimal color string (with or without '#' prefix)
+ * @param out_color Pointer to store the resulting color
+ * @return true if parsing succeeded, false otherwise
+ */
+FFI_PLUGIN_EXPORT
+bool native_color_from_hex(const char* hex, native_color_t* out_color);
+
+/**
+ * @brief Converts the color to a 32-bit integer (RGBA format).
+ *
+ * @param color The color to convert
+ * @return 32-bit unsigned integer in RGBA format (0xRRGGBBAA)
+ */
+FFI_PLUGIN_EXPORT
+uint32_t native_color_to_rgba(native_color_t color);
+
+/**
+ * @brief Converts the color to a 32-bit integer (ARGB format).
+ *
+ * @param color The color to convert
+ * @return 32-bit unsigned integer in ARGB format (0xAARRGGBB)
+ */
+FFI_PLUGIN_EXPORT
+uint32_t native_color_to_argb(native_color_t color);
+
+// Predefined color constants
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_TRANSPARENT;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_BLACK;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_WHITE;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_RED;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_GREEN;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_BLUE;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_YELLOW;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_CYAN;
+
+FFI_PLUGIN_EXPORT
+extern const native_color_t NATIVE_COLOR_MAGENTA;
+
+#ifdef __cplusplus
+}
+#endif

src/capi/window_c.cpp

@@ -608,6 +608,29 @@ native_visual_effect_t native_window_get_visual_effect(native_window_t window) {
   return static_cast<native_visual_effect_t>(win->GetVisualEffect());
 }
 
+FFI_PLUGIN_EXPORT
+void native_window_set_background_color(native_window_t window, native_color_t color) {
+  if (!window)
+    return;
+  auto* win = static_cast<nativeapi::Window*>(window);
+  Color cpp_color = Color::FromRGBA(color.r, color.g, color.b, color.a);
+  win->SetBackgroundColor(cpp_color);
+}
+
+FFI_PLUGIN_EXPORT
+native_color_t native_window_get_background_color(native_window_t window) {
+  native_color_t result = {255, 255, 255, 255};  // Default to white
+  if (!window)
+    return result;
+  auto* win = static_cast<nativeapi::Window*>(window);
+  Color cpp_color = win->GetBackgroundColor();
+  result.r = cpp_color.r;
+  result.g = cpp_color.g;
+  result.b = cpp_color.b;
+  result.a = cpp_color.a;
+  return result;
+}
+
 FFI_PLUGIN_EXPORT
 void native_window_set_visible_on_all_workspaces(native_window_t window, bool visible) {
   if (!window)

src/capi/window_c.h

@@ -9,6 +9,7 @@
 #define FFI_PLUGIN_EXPORT
 #endif
 
+#include "color_c.h"
 #include "geometry_c.h"
 
 #ifdef __cplusplus
@@ -236,6 +237,12 @@ void native_window_set_visual_effect(native_window_t window, native_visual_effec
 FFI_PLUGIN_EXPORT
 native_visual_effect_t native_window_get_visual_effect(native_window_t window);
 
+FFI_PLUGIN_EXPORT
+void native_window_set_background_color(native_window_t window, native_color_t color);
+
+FFI_PLUGIN_EXPORT
+native_color_t native_window_get_background_color(native_window_t window);
+
 FFI_PLUGIN_EXPORT
 void native_window_set_visible_on_all_workspaces(native_window_t window, bool visible);
 

src/foundation/color.cpp

@@ -0,0 +1,86 @@
+#include "color.h"
+#include <cstring>
+#include <stdexcept>
+
+namespace nativeapi {
+
+// Parse a single hex digit (0-9, A-F, a-f) to a value 0-15
+static unsigned char ParseHexDigit(char c) {
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  throw std::invalid_argument("Invalid hex digit");
+}
+
+// Parse two hex digits to a byte value 0-255
+static unsigned char ParseHexByte(const char* hex) {
+  return (ParseHexDigit(hex[0]) << 4) | ParseHexDigit(hex[1]);
+}
+
+Color Color::FromHex(const char* hex) {
+  if (!hex) {
+    throw std::invalid_argument("Hex string cannot be null");
+  }
+
+  // Skip leading '#' if present
+  if (hex[0] == '#') {
+    hex++;
+  }
+
+  size_t len = std::strlen(hex);
+
+  // Parse based on format
+  if (len == 3) {
+    // #RGB format - expand each digit to two digits
+    unsigned char r = ParseHexDigit(hex[0]);
+    unsigned char g = ParseHexDigit(hex[1]);
+    unsigned char b = ParseHexDigit(hex[2]);
+    // Expand: F -> FF (15 -> 255)
+    r = (r << 4) | r;
+    g = (g << 4) | g;
+    b = (b << 4) | b;
+    return Color{r, g, b, 255};
+  } else if (len == 4) {
+    // #RGBA format - expand each digit to two digits
+    unsigned char r = ParseHexDigit(hex[0]);
+    unsigned char g = ParseHexDigit(hex[1]);
+    unsigned char b = ParseHexDigit(hex[2]);
+    unsigned char a = ParseHexDigit(hex[3]);
+    r = (r << 4) | r;
+    g = (g << 4) | g;
+    b = (b << 4) | b;
+    a = (a << 4) | a;
+    return Color{r, g, b, a};
+  } else if (len == 6) {
+    // #RRGGBB format
+    unsigned char r = ParseHexByte(hex);
+    unsigned char g = ParseHexByte(hex + 2);
+    unsigned char b = ParseHexByte(hex + 4);
+    return Color{r, g, b, 255};
+  } else if (len == 8) {
+    // #RRGGBBAA format
+    unsigned char r = ParseHexByte(hex);
+    unsigned char g = ParseHexByte(hex + 2);
+    unsigned char b = ParseHexByte(hex + 4);
+    unsigned char a = ParseHexByte(hex + 6);
+    return Color{r, g, b, a};
+  } else {
+    throw std::invalid_argument("Invalid hex color format. Expected #RGB, #RGBA, #RRGGBB, or #RRGGBBAA");
+  }
+}
+
+// Color constants
+const Color Color::Transparent = {0, 0, 0, 0};
+const Color Color::Black = {0, 0, 0, 255};
+const Color Color::White = {255, 255, 255, 255};
+const Color Color::Red = {255, 0, 0, 255};
+const Color Color::Green = {0, 255, 0, 255};
+const Color Color::Blue = {0, 0, 255, 255};
+const Color Color::Yellow = {255, 255, 0, 255};
+const Color Color::Cyan = {0, 255, 255, 255};
+const Color Color::Magenta = {255, 0, 255, 255};
+
+}  // namespace nativeapi