Grid.hpp

//
// TGUI - Texus's Graphical User Interface
// Copyright (C) 2012-2015 Bruno Van de Velde (vdv_b@tgui.eu)
//
// 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_GRID_HPP
#define TGUI_GRID_HPP


#include <TGUI/Container.hpp>


namespace tgui
{

    class TGUI_API Grid : public Container
    {
      public:

        typedef SharedWidgetPtr<Grid> Ptr;


        struct Layout
        {
            enum Layouts
            {
                UpperLeft,   
                Up,          
                UpperRight,  
                Right,       
                BottomRight, 
                Bottom,      
                BottomLeft,  
                Left,        
                Center       
            };
        };


        Grid();


        Grid(const Grid& copy);


        virtual ~Grid();


        Grid& operator= (const Grid& right);


        // Makes a copy of the widget by calling the copy constructor.
        // This function calls new and if you use this function then you are responsible for calling delete.
        virtual Grid* clone();


        virtual void setSize(float width, float height);


        virtual sf::Vector2f getSize() const;


        virtual void remove(const Widget::Ptr& widget);


        virtual void remove(Widget* widget);


        virtual void removeAllWidgets();


        void addWidget(const Widget::Ptr& widget,
                       unsigned int       row,
                       unsigned int       column,
                       const Borders&     borders = Borders(0, 0, 0, 0),
                       Layout::Layouts    layout  = Layout::Center);


        Widget::Ptr getWidget(unsigned int row, unsigned int column);


        void updateWidgets();


        void changeWidgetBorders(const Widget::Ptr& widget, const Borders& borders = Borders(0, 0, 0, 0));


        void changeWidgetLayout(const Widget::Ptr& widget, Layout::Layouts layout = Layout::Center);


        virtual bool mouseOnWidget(float x, float y);


      protected:


        // Returns the minimum size required by the grid to display correctly all widgets.
        sf::Vector2f getMinSize();


        // Reposition all the widgets.
        void updatePositionsOfAllWidgets();


        // Draws the widget on the render target.
        virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;


      public:

        enum GridCallbacks
        {
            AllGridCallbacks = WidgetCallbacksCount - 1, 
            GridCallbacksCount = WidgetCallbacksCount
        };


      protected:

        std::vector< std::vector<Widget::Ptr> >     m_GridWidgets;
        std::vector< std::vector<Borders> >         m_ObjBorders;
        std::vector< std::vector<Layout::Layouts> > m_ObjLayout;

        std::vector<unsigned int> m_RowHeight;
        std::vector<unsigned int> m_ColumnWidth;

        sf::Vector2f m_Size; // Real (optimal) size of the grid
        sf::Vector2f m_IntendedSize; // Intended size that the grid should have if it is possible


    };

}


#endif // TGUI_GRID_HPP