menu.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOBROWSER_MENU_HPP
#define MOBROWSER_MENU_HPP
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "mobrowser/shortcuts/shortcut.hpp"
 
namespace mobrowser {
 
class App;
class Browser;
 
enum class MenuItemType {
  kStandardMenu,
  kStandardMenuItem,
  kCustomMenu,
  kCustomMenuItem,
  kCustomCheckboxMenuItem,
  kSeparator
};
 
class MenuItem {
 public:
  [[nodiscard]] MenuItemType type() const;
 
 protected:
  explicit MenuItem(MenuItemType type);
 
 private:
  MenuItemType type_;
};
 
class SeparatorMenuItem : public MenuItem {
 public:
  static std::shared_ptr<SeparatorMenuItem> create();
  static std::shared_ptr<SeparatorMenuItem> cast(
      std::shared_ptr<MenuItem> item);
 
  explicit SeparatorMenuItem();
};
 
using MenuItems = std::vector<std::shared_ptr<MenuItem>>;
 
class Menu : public MenuItem {
 public:
  [[nodiscard]] MenuItems items() const;
 
 protected:
  Menu(MenuItemType type, MenuItems items);
 
 private:
  MenuItems items_;
};
 
class CustomMenu : public Menu {
 public:
  static std::shared_ptr<CustomMenu> create(MenuItems items);
  static std::shared_ptr<CustomMenu> create(std::string title, MenuItems items);
  static std::shared_ptr<CustomMenu> cast(std::shared_ptr<MenuItem> item);
 
  CustomMenu(std::string title, MenuItems items);
  [[nodiscard]] std::string title() const;
 
 private:
  std::string title_;
};
 
enum class StandardMenuRole {
  kMacAppMenu,
  kFileMenu,
  kEditMenu,
  kViewMenu,
  kWindowMenu,
  kHelpMenu
};
 
class StandardMenu : public Menu {
 public:
  static std::shared_ptr<StandardMenu> create(StandardMenuRole role);
  static std::shared_ptr<StandardMenu> create(StandardMenuRole role,
                                              MenuItems items);
  static std::shared_ptr<StandardMenu> cast(std::shared_ptr<MenuItem> item);
 
  StandardMenu(StandardMenuRole role, MenuItems items);
 
  [[nodiscard]] StandardMenuRole role() const;
 
 private:
  StandardMenuRole role_;
};
 
class BaseCustomMenuItem : public MenuItem {
 public:
  [[nodiscard]] int32_t id() const;
  void setTitle(const std::string& title);
  [[nodiscard]] std::string title() const;
  void setEnabled(bool enabled);
  [[nodiscard]] bool isEnabled() const;
 
 protected:
  BaseCustomMenuItem(MenuItemType type, std::string title, bool enabled = true);
 
 private:
  int32_t id_ = 0;
  std::string title_;
  bool enabled_ = true;
};
 
class CustomMenuItem;
class CustomCheckboxMenuItem;
 
struct CustomMenuItemActionArgs {
  std::shared_ptr<App> app;
  std::shared_ptr<Browser> browser;
  std::shared_ptr<CustomMenuItem> menu_item;
};
 
struct CustomCheckboxMenuItemActionArgs {
  std::shared_ptr<App> app;
  std::shared_ptr<Browser> browser;
  std::shared_ptr<CustomCheckboxMenuItem> menu_item;
};
 
using CustomMenuItemAction =
    std::function<void(const CustomMenuItemActionArgs& args)>;
 
using CustomCheckboxMenuItemAction =
    std::function<void(const CustomCheckboxMenuItemActionArgs& args)>;
 
class CustomMenuItem : public BaseCustomMenuItem {
 public:
  static std::shared_ptr<CustomMenuItem> create(std::string title,
                                                CustomMenuItemAction action,
                                                Shortcut shortcut,
                                                bool enabled = true);
  static std::shared_ptr<CustomMenuItem> cast(std::shared_ptr<MenuItem> item);
  static std::shared_ptr<CustomMenuItem> fromId(int32_t id);
 
  CustomMenuItem(std::string title,
                 CustomMenuItemAction action,
                 Shortcut shortcut,
                 bool enabled = true);
 
  [[nodiscard]] CustomMenuItemAction action() const;
  [[nodiscard]] Shortcut shortcut() const;
  void setShortcut(Shortcut shortcut);
 
 protected:
  CustomMenuItem(MenuItemType type,
                 std::string title,
                 CustomMenuItemAction action,
                 Shortcut shortcut,
                 bool enabled = true);
 
 private:
  CustomMenuItemAction action_ = nullptr;
  Shortcut shortcut_;
};
 
class CustomCheckboxMenuItem : public BaseCustomMenuItem {
 public:
  static std::shared_ptr<CustomCheckboxMenuItem> create(
      std::string title,
      CustomCheckboxMenuItemAction action,
      bool enabled = true,
      bool checked = false);
  static std::shared_ptr<CustomCheckboxMenuItem> cast(
      std::shared_ptr<MenuItem> item);
  static std::shared_ptr<CustomCheckboxMenuItem> fromId(int32_t id);
 
  CustomCheckboxMenuItem(std::string title,
                         CustomCheckboxMenuItemAction action,
                         bool enabled = true,
                         bool checked = false);
 
  [[nodiscard]] bool isChecked() const;
  void setChecked(bool checked);
  [[nodiscard]] CustomCheckboxMenuItemAction action() const;
 
 protected:
  CustomCheckboxMenuItem(MenuItemType type,
                         std::string title,
                         CustomCheckboxMenuItemAction action,
                         bool enabled = true,
                         bool checked = false);
 
 private:
  bool checked_ = false;
  CustomCheckboxMenuItemAction action_ = nullptr;
};
 
enum class StandardMenuItemCommandId {
  // The standard app menu items.
 
  // Mac App menu items.
  kMacHideApp,
  kMacHideOthers,
  kMacShowAll,
 
  // File menu items.
  kSavePageAs,
  kPrint,
  kPrintUsingSystemDialog,
  kCloseWindow,
  kQuit,
 
  // Edit menu items.
  kUndo,
  kRedo,
  kCut,
  kCopy,
  kPaste,
  kPasteAndMatchStyle,
  kDelete,
  kSelectAll,
  kFind,
  kFindNext,
  kFindPrevious,
 
  // View menu items.
  kGoBack,
  kGoForward,
  kStop,
  kReload,
  kReloadBypassingCache,
  kZoomNormal,
  kZoomIn,
  kZoomOut,
  kFullScreen,
  kDevTools,
  kViewSource,
 
  // Window menu items.
  kMinimizeWindow,
  kMaximizeWindow
};
 
class StandardMenuItem : public MenuItem {
 public:
  static std::shared_ptr<StandardMenuItem> create(StandardMenuItemCommandId id);
  static std::shared_ptr<StandardMenuItem> cast(std::shared_ptr<MenuItem> item);
 
  explicit StandardMenuItem(StandardMenuItemCommandId command_id);
 
  [[nodiscard]] StandardMenuItemCommandId commandId() const;
 
 private:
  StandardMenuItemCommandId command_id_;
};
 
namespace menu {
std::shared_ptr<SeparatorMenuItem> Separator();
std::shared_ptr<CustomMenu> Menu(MenuItems items);
std::shared_ptr<CustomMenu> Menu(std::string title, MenuItems items);
std::shared_ptr<CustomMenuItem> Item(std::string title,
                                     CustomMenuItemAction action,
                                     bool enabled = true);
std::shared_ptr<CustomMenuItem> Item(std::string title,
                                     CustomMenuItemAction action,
                                     Shortcut shortcut,
                                     bool enabled = true);
std::shared_ptr<CustomCheckboxMenuItem> CheckboxItem(
    std::string title,
    CustomCheckboxMenuItemAction action,
    bool enabled = true,
    bool checked = false);
 
std::shared_ptr<StandardMenu> MacApp(MenuItems items);
std::shared_ptr<StandardMenu> File(MenuItems items);
std::shared_ptr<StandardMenu> Edit(MenuItems items);
std::shared_ptr<StandardMenu> View(MenuItems items);
std::shared_ptr<StandardMenu> Window(MenuItems items);
std::shared_ptr<StandardMenu> Help(MenuItems items);
 
std::shared_ptr<CustomMenuItem> About(const std::shared_ptr<App>& app);
 
std::shared_ptr<StandardMenuItem> MacHideApp();
std::shared_ptr<StandardMenuItem> MacHideOthers();
std::shared_ptr<StandardMenuItem> MacShowAll();
std::shared_ptr<StandardMenuItem> Quit();
 
std::shared_ptr<StandardMenuItem> SavePageAs();
std::shared_ptr<StandardMenuItem> Print();
std::shared_ptr<StandardMenuItem> PrintUsingSystemDialog();
std::shared_ptr<StandardMenuItem> CloseWindow();
 
std::shared_ptr<StandardMenuItem> Undo();
std::shared_ptr<StandardMenuItem> Redo();
std::shared_ptr<StandardMenuItem> Cut();
std::shared_ptr<StandardMenuItem> Copy();
std::shared_ptr<StandardMenuItem> Paste();
std::shared_ptr<StandardMenuItem> PasteAndMatchStyle();
std::shared_ptr<StandardMenuItem> Delete();
std::shared_ptr<StandardMenuItem> SelectAll();
std::shared_ptr<StandardMenuItem> Find();
std::shared_ptr<StandardMenuItem> FindNext();
std::shared_ptr<StandardMenuItem> FindPrevious();
 
std::shared_ptr<StandardMenuItem> GoBack();
std::shared_ptr<StandardMenuItem> GoForward();
std::shared_ptr<StandardMenuItem> Stop();
std::shared_ptr<StandardMenuItem> Reload();
std::shared_ptr<StandardMenuItem> ReloadBypassingCache();
std::shared_ptr<StandardMenuItem> ZoomNormal();
std::shared_ptr<StandardMenuItem> ZoomIn();
std::shared_ptr<StandardMenuItem> ZoomOut();
std::shared_ptr<StandardMenuItem> FullScreen();
std::shared_ptr<StandardMenuItem> DevTools();
std::shared_ptr<StandardMenuItem> ViewSource();
 
std::shared_ptr<StandardMenuItem> MinimizeWindow();
std::shared_ptr<StandardMenuItem> MaximizeWindow();
 
}  // namespace menu
}  // namespace mobrowser
 
#endif  // MOBROWSER_MENU_HPP