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

        virtual void setPosition(const IntPoint& _value);
        virtual void setSize(const IntSize& _value);
        virtual void setCoord(const IntCoord& _value);

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

        Widget* getChildAt(size_t _index);

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

        Widget* getClientWidget();

        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;

        /*internal:*/
        // метод для запроса номера айтема и контейнера
        virtual size_t _getItemIndex(Widget* _item);

        // дает приоритет виджету при пиккинге
        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();

        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:
        // все создание только через фабрику
        virtual ~Widget();

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

        virtual void baseUpdateEnable();

        // наследуемся он LayerInfo
        virtual ILayerItem* getLayerItemByPoint(int _left, int _top) const;
        virtual const IntCoord& getLayerItemCoord() const;

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

        void destroySkinWidget(Widget* _widget);

        virtual void onWidgetCreated(Widget* _widget);
        virtual void onWidgetDestroy(Widget* _widget);

        void setWidgetClient(Widget* _widget);

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

    private:
        void frameEntered(float _frame);

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

        virtual void resizeLayerItemView(const IntSize& _oldView, const IntSize& _newView);

        void addWidget(Widget* _widget);

    private:
        // клиентская зона окна
        // если виджет имеет пользовательские окна не в себе
        // то обязательно проинициализировать Client
        Widget* mWidgetClient;

        // вектор всех детей виджетов
        VectorWidgetPtr mWidgetChild;

        // вектор детей скина
        VectorWidgetPtr mWidgetChildSkin;

        // доступен ли на виджет
        bool mEnabled;
        bool mInheritsEnabled;
        // для иерархического скрытия
        bool mInheritsVisible;
        // прозрачность и флаг наследования альфы нашего оверлея
        float mAlpha;
        float mRealAlpha;
        bool mInheritsAlpha;
        // имя виджета
        std::string mName;

        // наш отец в иерархии виджетов
        Widget* mParent;

        // поведение виджета, перекрывающийся дочерний или всплывающий
        WidgetStyle mWidgetStyle;

        Widget* mContainer;

        Align mAlign;
        bool mVisible;
        int mDepth;
    };

} // namespace MyGUI

#endif // __MYGUI_WIDGET_H__