menu.h

Go to the documentation of this file.

#pragma once
#include <any>
#include <map>
#include <optional>
#include <string>
#include <xtd/iequatable.h>
#include "component.h"
#include "layout/arranged_element_collection.h"

namespace xtd {
  namespace forms {
    class context_menu;
    class main_menu;
    class menu_item;

    using menu_item_ref = std::reference_wrapper<menu_item>;

    using const_menu_item_ref = std::reference_wrapper<const menu_item>;

    class forms_export_ menu : public component, public iequatable<menu> {
    public:
      
      using menu_item_collection = layout::arranged_element_collection<menu_item_ref>;
      
      
      static constexpr const int find_handle = 0;
      static constexpr const int find_shortcut = 1;

      ~menu();

      
      intptr_t handle() const {return data_->handle_;}
      
      virtual bool is_parent() const;

      const menu_item& mdi_list_item() const;

      const menu_item_collection& menu_items() const {return data_->menu_items_;}
      menu_item_collection& menu_items() {return data_->menu_items_;}
      menu& menu_items(const menu_item_collection& value);
      menu& menu_items(const std::initializer_list<menu_item_ref>& value);
      menu& menu_items(const std::vector<menu_item_ref>& value);

      const xtd::ustring& name() const {return data_->name_;}

      menu& name(const xtd::ustring& value) {
        data_->name_ = value;
        return *this;
      }

      std::any tag() const {return data_->tag_;}
      menu& tag(std::any value) {
        data_->tag_ = value;
        return *this;
      }

      
      bool equals(const menu&) const noexcept override;
      bool equals(const object&) const noexcept override;

      std::optional<std::reference_wrapper<context_menu>> get_context_menu() const;

      std::optional<std::reference_wrapper<main_menu>> get_main_menu() const;

      virtual void merge_menu(const menu& menu_src);

      xtd::ustring to_string() const noexcept override;
      
      friend std::ostream& operator<<(std::ostream& os, const xtd::forms::menu& menu) noexcept {
        return os << menu.to_string();
      }

    protected:
      friend menu_item;

      
      menu();
      explicit menu(const menu_item_collection& items);
      
      explicit menu(const std::initializer_list<menu_item_ref>& items);
      explicit menu(const std::vector<menu_item_ref>& items);
      menu(const menu&) = delete;

      
      void clone_menu(const menu& menu_src);

      virtual intptr_t create_menu_handle() = 0;

      virtual void destroy_menu_handle(intptr_t handle) {}

      virtual void on_item_added(size_t pos, menu_item_ref item) {}
      virtual void on_item_removed(size_t pos, menu_item_ref item) {}

      virtual void create_menu();
      virtual void destroy_menu();
      void recreate_menu();

      struct data {
        intptr_t handle_ = 0;
        std::optional<std::reference_wrapper<menu>> context_menu_;
        menu_item_collection menu_items_;
        std::unique_ptr<menu_item> mdi_list_item_;
        std::optional<std::reference_wrapper<menu>> main_menu_;
        xtd::ustring name_;
        std::optional<std::reference_wrapper<menu>> parent_;
        std::any tag_;
      };
      std::shared_ptr<data> data_;
      static std::map<int32_t, std::reference_wrapper<menu>> handles_;
    };
  }
}