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:
        virtual void setVisible(bool _value);

        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);

        size_t getItemIndex(MenuItem* _item);

        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 std::string& getItemId(MenuItem* _item);

        MenuItem* getItemById(const std::string& _id);

        MenuItem* findItemById(const std::string& _id, bool _recursive = false);

        size_t getItemIndexById(const std::string& _id);
        //------------------------------------------------------------------------------//
        // манипуляции отображением

        void setItemNameAt(size_t _index, const UString& _name);
        void setItemName(MenuItem* _item, const UString& _name);

        const UString& getItemNameAt(size_t _index);
        const UString& getItemName(MenuItem* _item);

        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);

        MenuControl* getItemChild(MenuItem* _item);

        MenuControl* createItemChildAt(size_t _index);

        MenuControl* createItemChild(MenuItem* _item);

        void removeItemChildAt(size_t _index);

        void removeItemChild(MenuItem* _item);


        MenuItemType getItemTypeAt(size_t _index);

        MenuItemType getItemType(MenuItem* _item);

        void setItemTypeAt(size_t _index, MenuItemType _type);
        void setItemType(MenuItem* _item, MenuItemType _type);

        void setPopupAccept(bool _value);
        bool getPopupAccept() const;

        MenuItem* getMenuItemParent();

        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
        virtual size_t _getItemCount();
        virtual void _addItem(const MyGUI::UString& _name);
        virtual void _removeItemAt(size_t _index);
        virtual Widget* _getItemAt(size_t _index);
        virtual void _setItemNameAt(size_t _index, const UString& _name);
        virtual const UString& _getItemNameAt(size_t _index);
        virtual void _setItemSelected(IItem* _item);

        void _updateItems(size_t _index);
        void _updateSizeForEmpty();

    protected:
        virtual void initialiseOverride();
        virtual void shutdownOverride();

        virtual void onKeyChangeRootFocus(bool _focus);

        virtual void onWidgetCreated(Widget* _widget);

        virtual void setPropertyOverride(const std::string& _key, const std::string& _value);

    private:
        void notifyRootKeyChangeFocus(Widget* _sender, bool _focus);
        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);

        Widget* _getClientWidget();

        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;
        Widget* mClient;
        bool mInternalCreateChild;
    };

} // namespace MyGUI

#endif // __MYGUI_MENU_CONTROL_H__