D:/Programmation/Sources/lxgui/bak/lxgui/gui/include/gui_uiobject.hpp

Go to the documentation of this file.

#ifndef GUI_UIOBJECT_HPP
#define GUI_UIOBJECT_HPP

#include <utils.hpp>
#include "gui_anchor.hpp"
#include "gui_manager.hpp"
#include <luapp_state.hpp>
#include "gui_vector2.hpp"
#include <xml.hpp>

#include <array>

namespace gui
{
    class lua_glue;

    enum border_type
    {
        BORDER_LEFT   = 0,
        BORDER_RIGHT  = 1,
        BORDER_TOP    = 2,
        BORDER_BOTTOM = 3
    };

    enum layer_type
    {
        LAYER_BACKGROUND,
        LAYER_BORDER,
        LAYER_ARTWORK,
        LAYER_OVERLAY,
        LAYER_HIGHLIGHT,
        LAYER_SPECIALHIGH
    };


    class uiobject
    {
    friend manager;
    public :

        explicit uiobject(manager* pManager);

        virtual ~uiobject();

        virtual void render() = 0;


        virtual void update_anchors();

        virtual void update(float fDelta);


        virtual std::string serialize(const std::string& sTab) const;


        virtual void copy_from(uiobject* pObj);

        virtual void fire_update_borders() const;

        void fire_update_dimensions() const;


        const std::string& get_name() const;


        const std::string& get_lua_name() const;


        const std::string& get_raw_name() const;


        void set_name(const std::string& sName);


        virtual void set_parent(uiobject* pParent);


        const uiobject* get_parent() const;


        uiobject* get_parent();


        uiobject* get_base();


        void set_alpha(float fAlpha);


        float get_alpha() const;


        virtual void show();


        virtual void hide();


        virtual void set_shown(bool bIsShown);


        bool is_shown() const;


        virtual bool is_visible() const;


        virtual void set_abs_width(uint uiAbsWidth);


        virtual void set_abs_height(uint uiAbsHeight);


        bool is_width_absolute() const;


        bool is_height_absolute() const;


        void set_rel_width(float fRelWidth);


        void set_rel_height(float fRelHeight);


        uint get_abs_width() const;


        uint get_apparent_width() const;


        uint get_abs_height() const;


        uint get_apparent_height() const;


        float get_rel_width() const;


        float get_rel_height() const;


        const std::string& get_object_type() const;


        bool is_object_type(const std::string& sType) const;


        const std::vector<std::string>& get_object_typeList() const;


        int get_bottom() const;


        vector2<int> get_center() const;


        int get_left() const;


        int get_right() const;


        int get_top() const;


        const std::array<int,4>& get_borders() const;


        void clear_all_points();


        void set_all_points(uiobject* pObj);


        void set_all_points(const std::string& sObjName);


        void set_abs_point(anchor_point mPoint, const std::string& sParentName,
            anchor_point mRelativePoint, int iX = 0, int iY = 0);


        void set_rel_point(anchor_point mPoint, const std::string& sParentName,
            anchor_point mRelativePoint, float fX = 0, float fY = 0);


        void set_point(const anchor& mAnchor);


        bool depends_on(uiobject* pObj) const;


        uint get_num_point() const;


        anchor* modify_point(anchor_point mPoint);


        const anchor* get_point(anchor_point mPoint) const;


        const std::map<anchor_point, anchor>& get_point_list() const;


        void notify_anchored_object(uiobject* pObj, bool bAnchored) const;


        bool is_virtual() const;


        void set_virtual();


        uint get_id() const;


        void set_id(uint uiID);


        void set_special();


        bool is_special() const;


        virtual void set_manually_rendered(bool bManuallyRendered, uiobject* pRenderer = nullptr);


        bool is_manually_rendered() const;


        void set_newly_created();


        bool is_newly_created() const;


        virtual void notify_renderer_need_redraw() const;


        virtual void fire_redraw() const;


        void mark_for_copy(const std::string& sVariable);


        virtual std::vector<uiobject*> clear_links();


        std::map<uint, uiobject*> get_anchored_objects() const;

        virtual void notify_loaded();


        manager* get_manager();


        const manager* get_manager() const;


        virtual void create_glue() = 0;

        void remove_glue();


        virtual void push_on_lua(lua::state* pLua) const;


        virtual void parse_block(xml::block* pBlock) = 0;

    protected :

        // XML parsing
        virtual void parse_size_block_(xml::block* pBlock);
        virtual void parse_anchor_block_(xml::block* pBlock);

        void         read_anchors_(float& iLeft, float& iRight, float& iTop, float& iBottom, float& iXCenter, float& iYCenter) const;
        void         make_borders_(float& iMin, float& iMax, float iCenter, float iSize) const;
        virtual void update_borders_() const;
        virtual void update_dimensions_() const;

        virtual void notify_manually_rendered_object_(uiobject* pObject, bool bManuallyRendered);

        manager* pManager_;

        std::string sName_;
        std::string sRawName_;
        std::string sLuaName_;
        uint        uiID_;
        uiobject*   pParent_;
        uiobject*   pInheritance_;
        bool        bSpecial_;
        bool        bManuallyRendered_;
        bool        bNewlyCreated_;
        uiobject*   pRenderer_;
        bool        bInherits_;

        bool         bVirtual_;
        bool         bLoaded_;
        mutable bool bReady_;

        std::vector<lua_glue*>   lGlueList_;
        std::vector<std::string> lCopyList_;

        std::vector<std::string> lType_;

        std::map<anchor_point, anchor> lAnchorList_;
        std::vector<const uiobject*>   lPreviousAnchorParentList_;
        std::array<bool, 4>            lDefinedBorderList_;
        mutable std::array<int, 4>     lBorderList_;

        float fAlpha_;
        bool  bIsShown_;
        bool  bIsVisible_;

        mutable bool  bIsWidthAbs_;
        mutable bool  bIsHeightAbs_;
        mutable uint  uiAbsWidth_;
        mutable uint  uiAbsHeight_;
        mutable float fRelWidth_;
        mutable float fRelHeight_;

        mutable bool bUpdateAnchors_;
        mutable bool bUpdateBorders_;
        mutable bool bUpdateDimensions_;

        mutable std::map<uint, uiobject*> lAnchoredObjectList_;
    };

    // Generic Lua glue
    class lua_glue
    {
    public :

        explicit lua_glue(lua_State* luaVM);
        virtual ~lua_glue();

        virtual void notify_deleted() = 0;

        int get_data_table(lua_State *L);

    protected :

        lua_State* pLua_;
        int        iRef_;
    };

    // Virtual widget Lua glue
    class lua_virtual_glue : public lua_glue
    {
    public :

        explicit lua_virtual_glue(lua_State* luaVM);
        virtual ~lua_virtual_glue();

        virtual void notify_deleted();

        int _mark_for_copy(lua_State*);
        int _get_base(lua_State*);
        int _get_name(lua_State*);

        static const char className[];
        static const char* classList[];
        static Lunar<lua_virtual_glue>::RegType methods[];

    protected :

        uint      uiID_;
        uiobject* pParent_;
    };

    // uiobject Lua glue
    class lua_uiobject : public lua_glue
    {
    public :

        explicit lua_uiobject(lua_State* luaVM);
        virtual ~lua_uiobject();

        virtual void notify_deleted();

        uiobject* get_parent();

        // uiobject
        int _get_alpha(lua_State*);
        int _get_name(lua_State*);
        int _get_object_type(lua_State*);
        int _is_object_type(lua_State*);
        int _set_alpha(lua_State*);
        // region
        int _clear_all_points(lua_State*);
        int _get_base(lua_State*);
        int _get_bottom(lua_State*);
        int _get_center(lua_State*);
        int _get_height(lua_State*);
        int _get_left(lua_State*);
        int _get_num_point(lua_State*);
        int _get_parent(lua_State*);
        int _get_point(lua_State*);
        int _get_right(lua_State*);
        int _get_top(lua_State*);
        int _get_width(lua_State*);
        int _hide(lua_State*);
        int _is_shown(lua_State*);
        int _is_visible(lua_State*);
        int _set_all_points(lua_State*);
        int _set_height(lua_State*);
        int _set_parent(lua_State*);
        int _set_point(lua_State*);
        int _set_rel_point(lua_State*);
        int _set_width(lua_State*);
        int _show(lua_State*);

        static const char className[];
        static const char* classList[];
        static Lunar<lua_uiobject>::RegType methods[];

    protected :

        bool check_parent_();

        std::string sName_;
        uiobject*   pParent_;
    };

}

#endif

---