Objects.hpp

//
// TGUI - Texus's Graphical User Interface
// Copyright (C) 2012 Bruno Van de Velde (VDV_B@hotmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//


#ifndef _TGUI_OBJECTS_INCLUDED_
#define _TGUI_OBJECTS_INCLUDED_


namespace tgui
{
    struct TGUI_API OBJECT : public sf::Drawable, sf::Transformable
    {
        OBJECT();


        OBJECT(const OBJECT& copy);


        virtual ~OBJECT();


        OBJECT& operator= (const OBJECT& right);


        // This function is called when the object is created (when it is added to a group).
        virtual void initialize();


        // Makes a copy of the object by just calling the copy constructor.
        virtual OBJECT* clone() = 0;


        virtual void setSize(float width, float height) = 0;


        virtual Vector2u getSize() const = 0;


        virtual Vector2f getScaledSize() const = 0;


        virtual void show();


        virtual void hide();


        virtual bool isVisible() const;


        virtual void enable();


        virtual void disable();


        virtual bool isEnabled() const;


        virtual bool isDisabled() const;


        virtual bool isLoaded() const;


        //  Get the ObjectPhases from the string read from the info file
        virtual void extractPhases(std::string phases);


        void focus();


        void unfocus();


        void focusNextObject();


        virtual bool isFocused() const;


        virtual ObjectTypes getObjectType() const;


        virtual void moveToFront();


        virtual void moveToBack();


        // These functions are used to receive callback from the EventManager.
        // You normally don't need them, but you can use them to simulate an event.
        virtual bool mouseOnObject(float x, float y);
        virtual void leftMousePressed(float x, float y);
        virtual void leftMouseReleased(float x, float y);
        virtual void mouseMoved(float x, float y);
        virtual void keyPressed(sf::Keyboard::Key key);
        virtual void textEntered(sf::Uint32 key);
        virtual void mouseWheelMoved(int delta);
        virtual void objectFocused();
        virtual void objectUnfocused();

        virtual void mouseNotOnObject();
        virtual void mouseNoLongerDown();


    public:

        // When the id is 0 then there will be no callback. Otherwise, this will be the callbackID inside the Callback struct.
        unsigned int callbackID;


    protected:

        // When an object is disabled, it will no longer receive events
        bool m_Enabled;

        // Is the object visible? When it is invisible it will not receive events and it won't be drawn.
        bool m_Visible;

        // This bool will be true from the moment that the load function is completed successfully.
        bool m_Loaded;

        // This will store the different phases that the object can have
        // e.g. if there isn't a mouse down image then a button should not try to change its image on mouse down
        unsigned char m_ObjectPhase;

        // This will point to our parent object. If there is no parent then this will be NULL.
        Group* m_Parent;

        // Is the mouse on top of the object? Did the mouse go down on the object?
        bool m_MouseHover;
        bool m_MouseDown;

        // Are you focused on the object?
        bool m_Focused;

        // Can the object be focused?
        bool m_AllowFocus;

        // Is the object a button, an edit box, a checkbox, ...
        ObjectTypes m_ObjectType;

        // This is set to true for objects that are also derived from OBJECT_ANIMATION.
        bool m_AnimatedObject;

        // This is set to true for objects that have something to be dragged around (e.g. sliders and scrollbars)
        bool m_DraggableObject;

        // This is set to true for objects that store other objects inside them
        bool m_GroupObject;



        friend struct EventManager;
        friend struct Group;
    };


    struct TGUI_API OBJECT_BORDERS
    {
        OBJECT_BORDERS();


        virtual void setBorders(unsigned int leftBorder = 0,  unsigned int topBorder = 0,
                                unsigned int rightBorder = 0, unsigned int bottomBorder = 0) = 0;


        virtual Vector4u getBorders() const;


    protected:

        unsigned int m_LeftBorder;
        unsigned int m_TopBorder;
        unsigned int m_RightBorder;
        unsigned int m_BottomBorder;

    };


    struct TGUI_API OBJECT_ANIMATION
    {
        // The event manager will be able to change the elapsed time from any object
        friend struct EventManager;

    protected:

        // This function is called right after the elapsed time is changed.
        virtual void update() = 0;

    protected:

        // This will store the elapsed time since the last animation
        sf::Time m_AnimationTimeElapsed;
    };


    struct Callback
    {
        // All objects

            // The id that was passed to the object. It is used to identify from what object the callback came from. It can'b be 0.
            unsigned int callbackID;

            // How did the callbak occur? (one of the elements from the Triggers enum)
            unsigned int trigger;

            // Pointer to the object
            OBJECT* object;


        // Checkbox and RadioButton

            // True when the checkbox is checked, false otherwise.
            bool checked;


        // Button (these members are still in there because of what I did in v0.1, but they shouldn't be used)

            // This will store the mouse position. Only used on mouse clicks.
            float mouseX;
            float mouseY;

            // When you click on an object then this contains the button
            sf::Mouse::Button mouseButton;


        // Editbox and ListBox

            // This string will contain the new string inside the editbox
            sf::String text;


        // Slider, ListBox and LoadingBar

            unsigned int value;


        // This enum contains the different values for Trigger.
        enum triggers
        {
            mouseDown,         // Button
            mouseClick,        // Button, Checkbox, RadioButton
            keyPress_Space,    // Button, Checkbox, RadioButton
            keyPress_Return,   // Button, Checkbox, RadioButton
            textChanged,       // EditBox
            valueChanged,      // Slider, LoadingBar
            itemSelected,      // ListBox, ComboBox
            animationFinished, // AnimatedPicture
            closed,            // ChildWindow

            count // Keep this one last
        };
    };


    // Get a sf::Color from a string. The string must look like: "(r, g, b)" or "(r, g, b, a)".
    // When this function fails then it will return black.
    TGUI_API sf::Color extractColor(std::string string);


    // This function does exactly the opposite of extractColor.
    // The returned string will be "(r,g,b)" when a=255 or "(r,g,b,a)" when a<255.
    TGUI_API std::string convertColorToString(const sf::Color& color);


    // Get a Vector2f from a string. The string must look like: "(x, y)".
    TGUI_API bool extractVector2f(std::string string, Vector2f& vector);


    // Get a Vector2u from a string. The string must look like: "(x, y)".
    TGUI_API bool extractVector2u(std::string string, Vector2u& vector);


    // Get a Vector4u from a string. The string must look like: "(x1, x2, x3, x4)".
    TGUI_API bool extractVector4u(std::string string, Vector4u& vector);
}


#endif //_TGUI_OBJECTS_INCLUDED_