D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/GUI/spGUIController.hpp

Go to the documentation of this file.

/*
 * GUI controller header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_GUI_CONTROLLER_H__
#define __SP_GUI_CONTROLLER_H__


#include "Base/spStandard.hpp"

#ifdef SP_COMPILE_WITH_GUI


#include "RenderSystem/spRenderSystem.hpp"
#include "GUI/spGUIBaseObject.hpp"


namespace sp
{
namespace gui
{


class GUIScrollbarGadget;

enum EGUIControllerTypes
{
    CONTROLLER_WINDOW,
    CONTROLLER_GADGET,
};

enum EControllerFlags
{
    GUIFLAG_TEXTLEFT        = 0x01000000,
    GUIFLAG_TEXTRIGHT       = 0x02000000,
    GUIFLAG_TEXTCENTER      = 0x04000000,
    GUIFLAG_BORDERLESS      = 0x08000000,
    GUIFLAG_NOSCROLL        = 0x10000000,
    GUIFLAG_HOLDSELECTION   = 0x20000000,
};


class SP_EXPORT GUIController : public GUIBaseObject
{
    
    public:
        
        virtual ~GUIController();
        
        /* === Functions === */
        
        virtual bool update() = 0;
        virtual void draw() = 0;
        virtual void updateAlways();
        
        virtual void setRect(const dim::rect2di &Rect);
        
        virtual void setPosition(const dim::point2di &Position);
        
        virtual void setSize(const dim::size2di &Size);
        
        virtual dim::point2di getPosition(bool isGlobal) const;
        
        virtual dim::rect2di getRect(bool isGlobal) const;
        
        virtual dim::rect2di getLocalViewArea(const GUIController* Obj = 0) const;
        
        virtual dim::rect2di getViewArea(const GUIController* Obj = 0) const;
        
        virtual dim::point2di getViewOrigin() const;
        
        virtual dim::point2di getScrollPosition(bool isGlobal) const;
        
        virtual void setParent(GUIController* Parent);
        
        virtual void focus();
        
        virtual bool hasFocus() const;
        
        virtual void foreground();
        
        virtual void setFlags(s32 Flags);
        
        /* === Inline functions === */
        
        inline EGUIControllerTypes getType() const
        {
            return Type_;
        }
        
        inline GUIController* getParent() const
        {
            return Parent_;
        }
        
        inline dim::rect2di getRect() const
        {
            return Rect_;
        }
        
        inline dim::point2di getPosition() const
        {
            return dim::point2di(RootRect_.Left, RootRect_.Top);
        }
        
        inline dim::size2di getSize() const
        {
            return dim::size2di(RootRect_.Right - RootRect_.Left, RootRect_.Bottom - RootRect_.Top);
        }
        
        inline void setScrollPosition(const dim::point2di &Position)
        {
            ScrollPos_ = Position;
        }
        
        inline dim::point2di getScrollPosition() const
        {
            return ScrollPos_;
        }
        
        inline void translate(const dim::point2di &Direction)
        {
            setPosition(getPosition() + Direction);
        }
        
        inline void transform(const dim::size2di &Size)
        {
            setSize(getSize() + Size);
        }
        
        inline void scroll(const dim::point2di &Direction)
        {
            setScrollPosition(getScrollPosition() + Direction);
        }
        
        inline void setMinSize(const dim::size2di &Size)
        {
            MinSize_ = Size;
        }
        inline dim::size2di getMinSize() const
        {
            return MinSize_;
        }
        
        inline void setMaxSize(const dim::size2di &Size)
        {
            MaxSize_ = Size;
        }
        inline dim::size2di getMaxSize() const
        {
            return MaxSize_;
        }
        
        inline void setOrder(s32 Order)
        {
            Order_ = Order;
        }
        inline s32 getOrder() const
        {
            return Order_;
        }
        
        inline void setVisible(bool isVisible)
        {
            isVisible_ = isVisible;
        }
        inline bool getVisible() const
        {
            return isVisible_;
        }
        
        inline bool hasForeground() const
        {
            return isForeground_;
        }
        
        inline s32 getFlags() const
        {
            return Flags_;
        }
        
    protected:
        
        friend class GUIManager;
        
        /* === Macros === */
        
        static const s32 SCROLLBAR_SIZE = 15;
        
        /* === Functions === */
        
        GUIController(const EGUIControllerTypes Type);
        
        void updateChildren();
        void drawChildren();
        
        void updateClipping();
        bool setupClipping();
        bool checkClipping() const;
        void updateRect();
        bool checkDefaultUpdate();
        
        virtual void addChild(GUIController* Child);
        virtual void removeChild(GUIController* Child);
        
        void useFocus(s32 Usage = 0);
        bool usage(s32 Usage) const;
        bool usage() const;
        bool foreignUsage() const;
        
        dim::rect2di getParentViewArea() const;
        
        void updateScrollBars(GUIScrollbarGadget* HorzScroll, GUIScrollbarGadget* VertScroll);
        
        virtual void checkFlags();
        
        /* === Members === */
        
        EGUIControllerTypes Type_;
        
        GUIController* Parent_;
        std::list<GUIController*> Children_;
        
        s32 Order_;
        dim::rect2di RootRect_, Rect_, VisRect_;
        dim::size2di MinSize_, MaxSize_;
        dim::point2di ScrollPos_;
        
        bool isVisible_;
        bool isValidated_;
        bool isForeground_;
        
        s32 Flags_;
        
        s32 FocusUsage_;
        bool Usable_;
        
};


} // /namespace gui

} // /namespace sp


#endif

#endif



// ================================================================================