plusui-native-core 0.1.4 → 0.1.7

package/Core/Features/Menu/menu.cpp

@@ -0,0 +1,481 @@
+#include <iostream>
+#include <plusui/menu.hpp>
+#include <plusui/webview.hpp>
+#include <sstream>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+namespace plusui {
+namespace bindings {
+
+// JSON parsing helpers (simple implementation)
+static std::string trim(const std::string &str) {
+  size_t first = str.find_first_not_of(" \t\n\r");
+  if (first == std::string::npos)
+    return "";
+  size_t last = str.find_last_not_of(" \t\n\r");
+  return str.substr(first, last - first + 1);
+}
+
+static std::string extractJsonString(const std::string &json,
+                                     const std::string &key) {
+  std::string searchKey = "\"" + key + "\"";
+  size_t pos = json.find(searchKey);
+  if (pos == std::string::npos)
+    return "";
+
+  pos = json.find(":", pos);
+  if (pos == std::string::npos)
+    return "";
+
+  pos = json.find("\"", pos);
+  if (pos == std::string::npos)
+    return "";
+
+  size_t start = pos + 1;
+  size_t end = json.find("\"", start);
+  if (end == std::string::npos)
+    return "";
+
+  return json.substr(start, end - start);
+}
+
+static bool extractJsonBool(const std::string &json, const std::string &key,
+                            bool defaultVal = false) {
+  std::string searchKey = "\"" + key + "\"";
+  size_t pos = json.find(searchKey);
+  if (pos == std::string::npos)
+    return defaultVal;
+
+  pos = json.find(":", pos);
+  if (pos == std::string::npos)
+    return defaultVal;
+
+  std::string rest = json.substr(pos + 1);
+  rest = trim(rest);
+
+  if (rest.find("true") == 0)
+    return true;
+  if (rest.find("false") == 0)
+    return false;
+  return defaultVal;
+}
+
+void MenuBindings::registerBindings(WebView &webview) {
+  // Binding: menu.create
+  webview.bind("plusui_menu_create",
+               [this](const std::string &args) -> std::string {
+                 auto items = parseMenuItems(args);
+                 std::string menuId = MenuManager::instance().createMenu(items);
+                 return "\"" + menuId + "\"";
+               });
+
+  // Binding: menu.popup
+  webview.bind("plusui_menu_popup", [](const std::string &args) -> std::string {
+    // Parse: [menuId, x, y]
+    std::string menuId = extractJsonString(args, "menuId");
+
+    // Get x, y from args (simplified parsing)
+    int x = 0, y = 0;
+    size_t xPos = args.find("\"x\"");
+    size_t yPos = args.find("\"y\"");
+
+    if (xPos != std::string::npos) {
+      size_t colonPos = args.find(":", xPos);
+      if (colonPos != std::string::npos) {
+        x = std::stoi(args.substr(colonPos + 1));
+      }
+    }
+    if (yPos != std::string::npos) {
+      size_t colonPos = args.find(":", yPos);
+      if (colonPos != std::string::npos) {
+        y = std::stoi(args.substr(colonPos + 1));
+      }
+    }
+
+    Menu *menu = MenuManager::instance().getMenu(menuId);
+    if (menu) {
+      menu->popup(x, y);
+    }
+    return "null";
+  });
+
+  // Binding: menu.setApplicationMenu
+  webview.bind("plusui_menu_setAppMenu",
+               [this](const std::string &args) -> std::string {
+                 auto items = parseMenuItems(args);
+                 MenuBarData data;
+                 data.items = items;
+                 MenuBar::instance().setMenu(data);
+                 return "null";
+               });
+
+  // Binding: menu.destroy
+  webview.bind("plusui_menu_destroy",
+               [](const std::string &args) -> std::string {
+                 std::string menuId = extractJsonString(args, "menuId");
+                 MenuManager::instance().destroyMenu(menuId);
+                 return "null";
+               });
+
+  // Binding: menu.close
+  webview.bind("plusui_menu_close", [](const std::string &args) -> std::string {
+    std::string menuId = extractJsonString(args, "menuId");
+    Menu *menu = MenuManager::instance().getMenu(menuId);
+    if (menu) {
+      menu->close();
+    }
+    return "null";
+  });
+
+  // Inject JavaScript bridge for context menu handling
+  webview.eval(R"(
+        // PlusUI Context Menu Bridge
+        window.__plusui_contextMenu = {
+            enabled: false,
+            items: [],
+
+            enable: function(items) {
+                this.enabled = true;
+                this.items = items || [];
+            },
+
+            disable: function() {
+                this.enabled = false;
+            },
+
+            setItems: function(items) {
+                this.items = items;
+            }
+        };
+
+        // Override right-click if custom context menu is enabled
+        document.addEventListener('contextmenu', function(e) {
+            if (window.__plusui_contextMenu.enabled) {
+                e.preventDefault();
+
+                // Get element info for context-aware menus
+                const target = e.target;
+                const selector = target.tagName.toLowerCase() +
+                    (target.id ? '#' + target.id : '') +
+                    (target.className ? '.' + target.className.split(' ').join('.') : '');
+
+                // Notify C++ to show native context menu
+                if (typeof plusui_menu_showContext === 'function') {
+                    plusui_menu_showContext(JSON.stringify({
+                        x: e.screenX,
+                        y: e.screenY,
+                        clientX: e.clientX,
+                        clientY: e.clientY,
+                        selector: selector,
+                        tagName: target.tagName,
+                        isEditable: target.isContentEditable ||
+                                    target.tagName === 'INPUT' ||
+                                    target.tagName === 'TEXTAREA',
+                        hasSelection: window.getSelection().toString().length > 0
+                    }));
+                }
+
+                return false;
+            }
+        });
+    )");
+
+  // Binding: Show context menu
+  webview.bind("plusui_menu_showContext",
+               [this](const std::string &args) -> std::string {
+                 if (!contextMenuEnabled_ || contextMenuItems_.empty()) {
+                   return "null";
+                 }
+
+                 int x = 0, y = 0;
+                 size_t xPos = args.find("\"x\"");
+                 size_t yPos = args.find("\"y\"");
+
+                 if (xPos != std::string::npos) {
+                   size_t colonPos = args.find(":", xPos);
+                   if (colonPos != std::string::npos) {
+                     x = std::stoi(args.substr(colonPos + 1));
+                   }
+                 }
+                 if (yPos != std::string::npos) {
+                   size_t colonPos = args.find(":", yPos);
+                   if (colonPos != std::string::npos) {
+                     y = std::stoi(args.substr(colonPos + 1));
+                   }
+                 }
+
+                 // Create and show context menu
+                 if (currentContextMenuId_.empty()) {
+                   currentContextMenuId_ =
+                       MenuManager::instance().createMenu(contextMenuItems_);
+                 }
+
+                 Menu *menu =
+                     MenuManager::instance().getMenu(currentContextMenuId_);
+                 if (menu) {
+                   menu->popup(x, y);
+                 }
+
+                 return "null";
+               });
+
+  // Binding: Enable custom context menu
+  webview.bind("plusui_menu_enableContext",
+               [this, &webview](const std::string &args) -> std::string {
+                 contextMenuEnabled_ = true;
+                 webview.eval("window.__plusui_contextMenu.enabled = true;");
+                 return "null";
+               });
+
+  // Binding: Disable custom context menu
+  webview.bind("plusui_menu_disableContext",
+               [this, &webview](const std::string &args) -> std::string {
+                 contextMenuEnabled_ = false;
+                 webview.eval("window.__plusui_contextMenu.enabled = false;");
+                 return "null";
+               });
+}
+
+void MenuBindings::setItemClickCallback(
+    std::function<void(const std::string &, const std::string &)> callback) {
+  itemClickCallback_ = callback;
+}
+
+void MenuBindings::setContextMenu(const std::vector<MenuItem> &items) {
+  contextMenuItems_ = items;
+
+  // Destroy old context menu if exists
+  if (!currentContextMenuId_.empty()) {
+    MenuManager::instance().destroyMenu(currentContextMenuId_);
+    currentContextMenuId_.clear();
+  }
+}
+
+void MenuBindings::enableContextMenu(bool enable) {
+  contextMenuEnabled_ = enable;
+}
+
+void MenuBindings::showContextMenuAtCursor() {
+#ifdef _WIN32
+  POINT pt;
+  GetCursorPos(&pt);
+
+  if (!currentContextMenuId_.empty()) {
+    Menu *menu = MenuManager::instance().getMenu(currentContextMenuId_);
+    if (menu) {
+      menu->popup(pt.x, pt.y);
+    }
+  }
+#endif
+}
+
+std::vector<MenuItem> MenuBindings::parseMenuItems(const std::string &json) {
+  std::vector<MenuItem> items;
+
+  // Simple JSON array parsing
+  // Format: [{"id":"...", "label":"...", ...}, ...]
+  size_t pos = json.find('[');
+  if (pos == std::string::npos)
+    return items;
+
+  size_t end = json.rfind(']');
+  if (end == std::string::npos)
+    return items;
+
+  std::string content = json.substr(pos + 1, end - pos - 1);
+
+  // Find each object
+  int braceCount = 0;
+  size_t objStart = std::string::npos;
+
+  for (size_t i = 0; i < content.size(); i++) {
+    char c = content[i];
+    if (c == '{') {
+      if (braceCount == 0) {
+        objStart = i;
+      }
+      braceCount++;
+    } else if (c == '}') {
+      braceCount--;
+      if (braceCount == 0 && objStart != std::string::npos) {
+        std::string objStr = content.substr(objStart, i - objStart + 1);
+
+        MenuItem item;
+        item.id = extractJsonString(objStr, "id");
+        item.label = extractJsonString(objStr, "label");
+        item.accelerator = extractJsonString(objStr, "accelerator");
+        item.icon = extractJsonString(objStr, "icon");
+        item.enabled = extractJsonBool(objStr, "enabled", true);
+        item.checked = extractJsonBool(objStr, "checked", false);
+
+        std::string typeStr = extractJsonString(objStr, "type");
+        if (typeStr == "separator") {
+          item.type = MenuItemType::Separator;
+        } else if (typeStr == "checkbox") {
+          item.type = MenuItemType::Checkbox;
+        } else if (typeStr == "radio") {
+          item.type = MenuItemType::Radio;
+        } else if (typeStr == "submenu") {
+          item.type = MenuItemType::Submenu;
+        } else {
+          item.type = MenuItemType::Normal;
+        }
+
+        // Parse submenu recursively
+        size_t subPos = objStr.find("\"submenu\"");
+        if (subPos != std::string::npos) {
+          size_t subStart = objStr.find('[', subPos);
+          if (subStart != std::string::npos) {
+            int bracketCount = 1;
+            size_t subEnd = subStart + 1;
+            while (subEnd < objStr.size() && bracketCount > 0) {
+              if (objStr[subEnd] == '[')
+                bracketCount++;
+              else if (objStr[subEnd] == ']')
+                bracketCount--;
+              subEnd++;
+            }
+            std::string subJson = objStr.substr(subStart, subEnd - subStart);
+            item.submenu = parseMenuItems(subJson);
+          }
+        }
+
+        items.push_back(item);
+        objStart = std::string::npos;
+      }
+    }
+  }
+
+  return items;
+}
+
+std::string MenuBindings::menuItemToJson(const MenuItem &item) {
+  std::ostringstream ss;
+  ss << "{";
+  ss << "\"id\":\"" << item.id << "\",";
+  ss << "\"label\":\"" << item.label << "\",";
+  ss << "\"enabled\":" << (item.enabled ? "true" : "false") << ",";
+  ss << "\"checked\":" << (item.checked ? "true" : "false");
+
+  if (!item.accelerator.empty()) {
+    ss << ",\"accelerator\":\"" << item.accelerator << "\"";
+  }
+  if (!item.icon.empty()) {
+    ss << ",\"icon\":\"" << item.icon << "\"";
+  }
+
+  std::string typeStr;
+  switch (item.type) {
+  case MenuItemType::Separator:
+    typeStr = "separator";
+    break;
+  case MenuItemType::Checkbox:
+    typeStr = "checkbox";
+    break;
+  case MenuItemType::Radio:
+    typeStr = "radio";
+    break;
+  case MenuItemType::Submenu:
+    typeStr = "submenu";
+    break;
+  default:
+    typeStr = "normal";
+    break;
+  }
+  ss << ",\"type\":\"" << typeStr << "\"";
+
+  if (!item.submenu.empty()) {
+    ss << ",\"submenu\":[";
+    for (size_t i = 0; i < item.submenu.size(); i++) {
+      if (i > 0)
+        ss << ",";
+      ss << menuItemToJson(item.submenu[i]);
+    }
+    ss << "]";
+  }
+
+  ss << "}";
+  return ss.str();
+}
+
+// ContextMenuManager implementation
+
+ContextMenuManager &ContextMenuManager::instance() {
+  static ContextMenuManager inst;
+  return inst;
+}
+
+void ContextMenuManager::setDefaultMenu(const std::vector<MenuItem> &items) {
+  defaultMenu_ = items;
+}
+
+void ContextMenuManager::setMenuForSelector(
+    const std::string &selector, const std::vector<MenuItem> &items) {
+  selectorMenus_[selector] = items;
+}
+
+void ContextMenuManager::attachToWebView(WebView &webview) {
+  // Inject context menu override script
+  webview.eval(R"(
+        (function() {
+            document.addEventListener('contextmenu', function(e) {
+                // Check if we should use custom context menu
+                if (window.__plusui_useCustomContext) {
+                    e.preventDefault();
+
+                    const info = {
+                        x: e.screenX,
+                        y: e.screenY,
+                        target: e.target.tagName,
+                        id: e.target.id,
+                        className: e.target.className,
+                        isInput: e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA',
+                        isEditable: e.target.isContentEditable,
+                        selectedText: window.getSelection().toString()
+                    };
+
+                    if (window.plusui && window.plusui.menu) {
+                        window.plusui.menu._showContextMenu(info);
+                    }
+                }
+            });
+        })();
+    )");
+}
+
+void ContextMenuManager::handleRightClick(int x, int y,
+                                          const std::string &targetSelector) {
+  // Find the appropriate menu for this selector
+  std::vector<MenuItem> *menuItems = &defaultMenu_;
+
+  for (const auto &pair : selectorMenus_) {
+    if (targetSelector.find(pair.first) != std::string::npos) {
+      menuItems = const_cast<std::vector<MenuItem> *>(&pair.second);
+      break;
+    }
+  }
+
+  if (menuItems->empty())
+    return;
+
+  // Create and show menu
+  std::string menuId = MenuManager::instance().createMenu(*menuItems);
+  Menu *menu = MenuManager::instance().getMenu(menuId);
+  if (menu) {
+    menu->popup(x, y);
+  }
+
+  // Cleanup after menu closes (delayed)
+  // In production, this should be handled by menu close event
+}
+
+void ContextMenuManager::onItemClick(
+    std::function<void(const std::string &, const std::string &)> callback) {
+  clickCallback_ = callback;
+}
+
+} // namespace bindings
+} // namespace plusui