tbx_interface_element.hpp

#ifndef TurtleBrainsExpress_InterfaceElement_hpp
#define TurtleBrainsExpress_InterfaceElement_hpp

#include <turtle_brains/express/interface/tbx_interface.hpp>
#include <turtle_brains/graphics/tb_graphic_list.hpp>

#include <functional>
#include <array>

namespace TurtleBrainsExpress
{
    namespace Interface
    {
        namespace Unstable
        {

            class Controller;
            class InterfaceHandlerInterface;

            class Element
            {
            public:
                enum class State
                {
                    Hidden,
                    Disabled,
                    Enabled,
                    Focused,
                    Activated
                };

                Element(void);
                virtual ~Element(void);

                const State& GetState(void) const;
                void SetState(const State& newState);

                //TODO: TurtleBrainsExpress: Interface: Refactor and move to base Element:

                void SetHandler(InterfaceHandlerInterface* handler, const ElementHandle& elementHandle);
                void SetFunction(std::function<void(ElementHandle)> handlerFunction, ElementHandle elementHandle);
                void SetFunction(std::function<void()> callbackFunction);

                void HandleUserEvent(const UserEvent& userEvent);
                void LinkToNeighbor(const NavigationDirection& direction, Element* element);

                Point GetPosition(void) const;
                void SetPosition(const tbGraphics::PixelSpace& pixelX, const tbGraphics::PixelSpace& pixelY);
                inline tbGraphics::PixelSpace GetPixelWidth(void) const { return mPixelSize.x; }
                inline tbGraphics::PixelSpace GetPixelHeight(void) const { return mPixelSize.y; }

                void Render(void) const;

            protected:
                virtual void OnRender(void) const;
                virtual void OnActivate(void);

                virtual bool ContainsPointer(const Point& pointerPosition) const;
                virtual bool CanLinkWithNeighbor(const NavigationDirection& direction) const;
                virtual void OnStateChange(const State& newState);

                virtual void OnHandleUserEvent(const UserEvent& userEvent);
                virtual void OnHandleActiveUserEvent(const UserEvent& userEvent);

                Element* FindNextElementInDirection(const NavigationDirection& direction, bool enabledOnly);
                void SetPixelSize(const tbGraphics::PixelSpace& width, const tbGraphics::PixelSpace& height);

                void ClearGraphics(void);
                void AddGraphic(tbGraphics::Graphic& graphic);
                void AddGraphic(tbGraphics::Graphic* graphic);
                void ClearGraphics(const State& state);
                void AddGraphic(const State& state, tbGraphics::Graphic& graphic);
                void AddGraphic(const State& state, tbGraphics::Graphic* graphic);

            private:
                tbGraphics::GraphicList mGraphics;
                std::array<tbGraphics::GraphicList, 5> mStateGraphics;
                std::array<Element*, 4> mNeighbors;
                Point mPixelSize; //x = width, y = height
                InterfaceHandlerInterface* mInterfaceHandler;
                std::function<void(ElementHandle)> mFunctionHandler;
                std::function<void(void)> mFunctionCallback;
                ElementHandle mElementHandle;
                State mState;
            };

        };
    }; /* namespace Interface */
}; /* namespace TurtleBrainsExpress */

namespace tbxInterface = TurtleBrainsExpress::Interface;

#endif /* TurtleBrainsExpress_InterfaceElement_hpp */