MyGUI_Widget.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_WIDGET_H_
#define MYGUI_WIDGET_H_
 
#include "MyGUI_Prerequest.h"
#include "MyGUI_Any.h"
#include "MyGUI_ICroppedRectangle.h"
#include "MyGUI_WidgetUserData.h"
#include "MyGUI_WidgetInput.h"
#include "MyGUI_ResourceSkin.h"
#include "MyGUI_ResourceLayout.h"
#include "MyGUI_IObject.h"
#include "MyGUI_SkinItem.h"
#include "MyGUI_BackwardCompatibility.h"
 
namespace MyGUI
{
 
    typedef delegates::CMultiDelegate3<Widget*, const std::string&, const std::string&> EventHandle_WidgetStringString;
 
    class MYGUI_EXPORT Widget :
        public IObject,
        public ICroppedRectangle,
        public UserData,
        public WidgetInput,
        public delegates::IDelegateUnlink,
        public SkinItem,
        public MemberObsolete<Widget>
    {
        // для вызова закрытых деструкторов
        friend class WidgetManager;
 
        MYGUI_RTTI_DERIVED( Widget )
 
    public:
        Widget();
 
        Widget* createWidgetT(const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _name = "");
 
        Widget* createWidgetT(const std::string& _type, const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _name = "");
 
        Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _name = "");
 
        Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _name = "");
 
        // templates for creating widgets by type
        template <typename T>
        T* createWidget(const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _name = "")
        {
            return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, _coord, _align, _name));
        }
 
        template <typename T>
        T* createWidget(const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _name = "")
        {
            return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, IntCoord(_left, _top, _width, _height), _align, _name));
        }
 
        template <typename T>
        T* createWidgetReal(const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _name = "")
        {
            return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _coord, _align, _name));
        }
 
        template <typename T>
        T* createWidgetReal(const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _name = "")
        {
            return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _left, _top, _width, _height, _align, _name));
        }
 
        Widget* createWidgetT(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer = "", const std::string& _name = "");
 
        template <typename T>
        T* createWidget(WidgetStyle _style, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer = "", const std::string& _name = "")
        {
            return static_cast<T*>(createWidgetT(_style, T::getClassTypeName(), _skin, _coord, _align, _layer, _name));
        }
 
        void setPosition(const IntPoint& _value) override;
        void setSize(const IntSize& _value) override;
        void setCoord(const IntCoord& _value) override;
 
        void setPosition(int _left, int _top);
        void setSize(int _width, int _height);
        void setCoord(int _left, int _top, int _width, int _height);
 
        void setRealPosition(const FloatPoint& _value);
        void setRealSize(const FloatSize& _value);
        void setRealCoord(const FloatCoord& _value);
 
        void setRealPosition(float _left, float _top);
        void setRealSize(float _width, float _height);
        void setRealCoord(float _left, float _top, float _width, float _height);
 
        const std::string& getName() const;
 
        virtual void setVisible(bool _value);
        bool getVisible() const;
 
        void setDepth(int _value);
        int getDepth() const;
 
        bool getInheritedVisible() const;
 
        virtual void setAlign(Align _value);
        Align getAlign() const;
 
        void setAlpha(float _value);
        float getAlpha() const;
 
        void setInheritsAlpha(bool _value);
        bool getInheritsAlpha() const;
 
        void setColour(const Colour& _value);
 
        // являемся ли мы рутовым виджетом
        bool isRootWidget() const;
 
        Widget* getParent() const;
 
        IntSize getParentSize() const;
 
        EnumeratorWidgetPtr getEnumerator() const;
 
        size_t getChildCount() const;
 
        Widget* getChildAt(size_t _index) const;
 
        Widget* findWidget(const std::string& _name);
 
        void findWidgets(const std::string& _name, VectorWidgetPtr& _result);
 
        virtual void setEnabled(bool _value);
        void setEnabledSilent(bool _value);
        bool getEnabled() const;
 
        bool getInheritedEnabled() const;
 
        IntCoord getClientCoord() const;
 
        Widget* getClientWidget();
        const Widget* getClientWidget() const;
 
        void detachFromWidget(const std::string& _layer = "");
 
        void attachToWidget(Widget* _parent, WidgetStyle _style = WidgetStyle::Child, const std::string& _layer = "");
 
        void changeWidgetSkin(const std::string& _skinName);
 
        void setWidgetStyle(WidgetStyle _style, const std::string& _layer = "");
        WidgetStyle getWidgetStyle() const;
 
        void setProperty(const std::string& _key, const std::string& _value);
 
 
        EventHandle_WidgetStringString eventChangeProperty;
 
        EventHandle_WidgetVoid eventChangeCoord;
 
        EventHandle_WidgetVoid eventWidgetDestroyed;
 
        /*internal:*/
        // метод для запроса номера айтема и контейнера
        virtual size_t _getItemIndex(Widget* _item) const;
 
        // дает приоритет виджету при пиккинге
        void _forcePick(Widget* _widget);
 
        void _initialise(WidgetStyle _style, const IntCoord& _coord, const std::string& _skinName, Widget* _parent, ICroppedRectangle* _croppedParent, const std::string& _name);
        void _shutdown();
 
        // удяляет неудачника
        void _destroyChildWidget(Widget* _widget);
 
        void _setContainer(Widget* _value);
        Widget* _getContainer() const;
 
        void _setAlign(const IntSize& _oldsize, const IntSize& _newSize);
        bool _checkPoint(int _left, int _top) const;
 
        Widget* _createSkinWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer = "", const std::string& _name = "");
 
        // сброс всех данных контейнера, тултипы и все остальное
        virtual void _resetContainer(bool _update);
 
        bool _setWidgetState(const std::string& _value);
 
        // перерисовывает детей
        void _updateChilds();
 
    protected:
        // все создание только через фабрику
        ~Widget() override = default;
 
        virtual void shutdownOverride();
        virtual void initialiseOverride();
 
        void _updateView(); // обновления себя и детей
 
        // создает виджет
        Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name, bool _template);
 
        // удаляет всех детей
        void _destroyAllChildWidget();
 
        // запрашиваем у конейтера айтем по позиции мыши
        virtual size_t _getContainerIndex(const IntPoint& _point) const;
 
        virtual void baseUpdateEnable();
 
        // наследуемся он LayerInfo
        ILayerItem* getLayerItemByPoint(int _left, int _top) const override;
        const IntCoord& getLayerItemCoord() const override;
 
        template <typename T>
        void assignWidget(T*& _widget, const std::string& _name)
        {
            _widget = nullptr;
            for (VectorWidgetPtr::iterator iter = mWidgetChildSkin.begin(); iter != mWidgetChildSkin.end(); ++iter)
            {
                Widget* find = (*iter)->findWidget(_name);
                if (nullptr != find)
                {
                    _widget = find->castType<T>(false);
                    break;
                }
            }
        }
 
        VectorWidgetPtr getSkinWidgetsByName(const std::string& _name) const;
 
        virtual void onWidgetCreated(Widget* _widget);
        virtual void onWidgetDestroy(Widget* _widget);
 
        void setWidgetClient(Widget* _widget);
        Widget* _getClientWidget();
        const Widget* _getClientWidget() const;
 
        virtual void setPropertyOverride(const std::string& _key, const std::string& _value);
 
    private:
        const WidgetInfo* initialiseWidgetSkinBase(ResourceSkin* _info, ResourceLayout* _templateInfo);
        void shutdownWidgetSkinBase();
 
        void _updateAlpha();
        void _updateAbsolutePoint();
 
        // для внутреннего использования
        void _updateVisible();
 
        void _updateEnabled();
 
        float _getRealAlpha() const;
 
        void _createChildSkinWidget(ResourceSkin* _info);
        void _destroyChildSkinWidget();
 
        void _parseSkinProperties(ResourceSkin* _info);
        void _checkInheristProperties();
 
        void _linkChildWidget(Widget* _widget);
        void _unlinkChildWidget(Widget* _widget);
 
        void setSkinProperty(ResourceSkin* _info);
 
        void resizeLayerItemView(const IntSize& _oldView, const IntSize& _newView) override;
 
        void addWidget(Widget* _widget);
 
    private:
        // клиентская зона окна
        // если виджет имеет пользовательские окна не в себе
        // то обязательно проинициализировать Client
        Widget* mWidgetClient;
 
        // вектор всех детей виджетов
        VectorWidgetPtr mWidgetChild;
 
        // вектор детей скина
        VectorWidgetPtr mWidgetChildSkin;
 
        // availability for mouse/keyboard
        bool mEnabled;
        bool mInheritedEnabled;
        // visibility on screen and for mouse
        bool mVisible;
        bool mInheritedVisible;
        // transparency and transparency inheritance
        float mAlpha;
        float mRealAlpha;
        bool mInheritsAlpha;
        std::string mName;
 
        // parent in widgets hierarchy
        Widget* mParent;
 
        WidgetStyle mWidgetStyle;
 
        Widget* mContainer;
 
        Align mAlign;
        int mDepth;
    };
 
} // namespace MyGUI
 
#endif // MYGUI_WIDGET_H_