MyGUI_MenuControl.h

Go to the documentation of this file.

/*
 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
 * Distributed under the MIT License
 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
 */
 
#ifndef MYGUI_MENU_CONTROL_H_
#define MYGUI_MENU_CONTROL_H_
 
#include "MyGUI_Prerequest.h"
#include "MyGUI_Types.h"
#include "MyGUI_MenuItemType.h"
#include "MyGUI_Widget.h"
#include "MyGUI_Any.h"
#include "MyGUI_EventPair.h"
#include "MyGUI_MenuItemType.h"
#include "MyGUI_ControllerFadeAlpha.h"
#include "MyGUI_IItem.h"
#include "MyGUI_IItemContainer.h"
 
namespace MyGUI
{
 
    typedef delegates::CMultiDelegate2<MenuControl*, MenuItem*> EventHandle_MenuCtrlPtrMenuItemPtr;
    typedef delegates::CMultiDelegate1<MenuControl*> EventHandle_MenuCtrlPtr;
 
    class MYGUI_EXPORT MenuControl :
        public Widget,
        public IItemContainer,
        public MemberObsolete<MenuControl>
    {
        MYGUI_RTTI_DERIVED( MenuControl )
 
    public:
        MenuControl();
 
        struct ItemInfo
        {
            ItemInfo(MenuItem* _item, const UString& _name, MenuItemType _type, MenuControl* _submenu, const std::string& _id, Any _data) :
                item(_item),
                name(_name),
                type(_type),
                submenu(_submenu),
                id(_id),
                data(_data),
                width(0)
            {
            }
 
            MenuItem* item;
            UString name;
            MenuItemType type;
            MenuControl* submenu;
            std::string id;
            Any data;
            int width;
        };
 
        typedef std::vector<ItemInfo> VectorMenuItemInfo;
 
    public:
        void setVisible(bool _value) override;
 
        void setVisibleSmooth(bool _value);
 
        //------------------------------------------------------------------------------//
        // манипуляции айтемами
 
        size_t getItemCount() const;
 
        MenuItem* insertItemAt(size_t _index, const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
        MenuItem* insertItem(MenuItem* _to, const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
 
        MenuItem* addItem(const UString& _name, MenuItemType _type = MenuItemType::Normal, const std::string& _id = "", Any _data = Any::Null);
 
        void removeItemAt(size_t _index);
        void removeItem(MenuItem* _item);
 
        void removeAllItems();
 
 
        MenuItem* getItemAt(size_t _index) const;
 
        size_t getItemIndex(const MenuItem* _item) const;
 
        size_t findItemIndex(MenuItem* _item);
 
        MenuItem* findItemWith(const UString& _name);
 
        //------------------------------------------------------------------------------//
        // манипуляции данными
 
        void setItemDataAt(size_t _index, Any _data);
        void setItemData(MenuItem* _item, Any _data);
 
        void clearItemDataAt(size_t _index);
        void clearItemData(MenuItem* _item);
 
        template <typename ValueType>
        ValueType* getItemDataAt(size_t _index, bool _throw = true)
        {
            MYGUI_ASSERT_RANGE(_index, mItemsInfo.size(), "MenuControl::getItemDataAt");
            return mItemsInfo[_index].data.castType<ValueType>(_throw);
        }
        template <typename ValueType>
        ValueType* getItemData(MenuItem* _item, bool _throw = true)
        {
            return getItemDataAt<ValueType>(getItemIndex(_item), _throw);
        }
 
        void setItemIdAt(size_t _index, const std::string& _id);
        void setItemId(MenuItem* _item, const std::string& _id);
 
        const std::string& getItemIdAt(size_t _index) const;
        const std::string& getItemId(const MenuItem* _item) const;
 
        MenuItem* getItemById(const std::string& _id) const;
 
        MenuItem* findItemById(const std::string& _id, bool _recursive = false);
 
        size_t getItemIndexById(const std::string& _id) const;
        //------------------------------------------------------------------------------//
        // манипуляции отображением
 
        void setItemNameAt(size_t _index, const UString& _name);
        void setItemName(MenuItem* _item, const UString& _name);
 
        const UString& getItemNameAt(size_t _index) const;
        const UString& getItemName(const MenuItem* _item) const;
 
        size_t findItemIndexWith(const UString& _name);
 
        void setItemChildVisibleAt(size_t _index, bool _visible);
        void setItemChildVisible(MenuItem* _item, bool _visible);
 
        //------------------------------------------------------------------------------//
        // остальные манипуляции
 
        template <typename Type>
        Type* createItemChildTAt(size_t _index)
        {
            return static_cast<Type*>(createItemChildByType(_index, Type::getClassTypeName()));
        }
 
        template <typename Type>
        Type* createItemChildT(MenuItem* _item)
        {
            return createItemChildTAt<Type>(getItemIndex(_item));
        }
 
        MenuControl* getItemChildAt(size_t _index) const;
 
        MenuControl* getItemChild(const MenuItem* _item) const;
 
        MenuControl* createItemChildAt(size_t _index);
 
        MenuControl* createItemChild(MenuItem* _item);
 
        void removeItemChildAt(size_t _index);
 
        void removeItemChild(MenuItem* _item);
 
 
        MenuItemType getItemTypeAt(size_t _index) const;
 
        MenuItemType getItemType(const MenuItem* _item) const;
 
        void setItemTypeAt(size_t _index, MenuItemType _type);
        void setItemType(MenuItem* _item, MenuItemType _type);
 
        void setPopupAccept(bool _value);
        bool getPopupAccept() const;
 
        MenuItem* getMenuItemParent() const;
 
        void setVerticalAlignment(bool _value);
        bool getVerticalAlignment() const;
 
 
        /*events:*/
        EventHandle_MenuCtrlPtrMenuItemPtr eventMenuCtrlAccept;
 
        EventHandle_MenuCtrlPtr eventMenuCtrlClose;
 
 
        /*internal:*/
        void _notifyDeleteItem(MenuItem* _item);
        void _notifyDeletePopup(MenuItem* _item);
        void _notifyUpdateName(MenuItem* _item);
        void _wrapItemChild(MenuItem* _item, MenuControl* _widget);
 
        // IItemContainer impl
        size_t _getItemCount() const override;
        void _addItem(const MyGUI::UString& _name) override;
        void _removeItemAt(size_t _index) override;
        Widget* _getItemAt(size_t _index) const override;
        void _setItemNameAt(size_t _index, const UString& _name) override;
        const UString& _getItemNameAt(size_t _index) const override;
        void _setItemSelected(IItem* _item) override;
 
        void _updateItems(size_t _index);
        void _updateSizeForEmpty();
 
    protected:
        void initialiseOverride() override;
        void shutdownOverride() override;
 
        void onKeyChangeRootFocus(bool _focus) override;
 
        void onWidgetCreated(Widget* _widget) override;
 
        void setPropertyOverride(const std::string& _key, const std::string& _value) override;
 
    private:
        void notifyRootKeyChangeFocus(Widget* _sender, bool _focus) const;
        void notifyMouseButtonClick(Widget* _sender);
        void notifyMouseSetFocus(Widget* _sender, Widget* _new);
 
        const std::string& getSkinByType(MenuItemType _type) const;
        std::string getIconIndexByType(MenuItemType _type) const;
 
        void update();
 
        MenuItemType getItemType(bool _submenu, bool _separator) const;
 
        void notifyMenuCtrlAccept(MenuItem* _item);
 
        Widget* createItemChildByType(size_t _index, const std::string& _type);
 
        void _wrapItem(MenuItem* _item, size_t _index, const UString& _name, MenuItemType _type, const std::string& _id, Any _data);
 
        ControllerFadeAlpha* createControllerFadeAlpha(float _alpha, float _coef, bool _enable);
 
        void _setItemChildVisibleAt(size_t _index, bool _visible, bool _smooth);
 
    protected:
        bool mHideByAccept;
        // нужно ли выбрасывать по нажатию
        bool mMenuDropMode;
        bool mIsMenuDrop;
        bool mHideByLostKey;
        bool mResizeToContent;
 
    private:
        VectorMenuItemInfo mItemsInfo;
 
        std::string mItemNormalSkin;
        std::string mItemPopupSkin;
        std::string mItemSeparatorSkin;
 
        std::string mSubMenuSkin;
        std::string mSubMenuLayer;
 
        // флаг, чтобы отсеч уведомления от айтемов, при общем шутдауне виджета
        bool mShutdown;
 
        bool mVerticalAlignment;
        int mDistanceButton;
        bool mPopupAccept;
        MenuItem* mOwner;
        bool mAnimateSmooth;
 
        bool mChangeChildSkin;
        bool mInternalCreateChild;
    };
 
} // namespace MyGUI
 
#endif // MYGUI_MENU_CONTROL_H_