GridLayoutContainer.h

/***********************************************************************
    created:    01/8/2010
    author:     Martin Preisler

    purpose:    Interface to a vertical layout container
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2010 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIGridLayoutContainer_h_
#define _CEGUIGridLayoutContainer_h_

#include "./LayoutContainer.h"
#include "../WindowFactory.h"

#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4251)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT GridLayoutContainer : public LayoutContainer
{
public:
    enum AutoPositioning
    {
        AP_Disabled,
        AP_LeftToRight,
        AP_TopToBottom
    };

    /*************************************************************************
        Constants
    *************************************************************************/
    static const String WidgetTypeName;

    /*************************************************************************
        Child Widget name suffix constants
    *************************************************************************/
    static const String DummyName;

    /*************************************************************************
        Event name constants
    *************************************************************************/
    static const String EventNamespace;

    static const String EventChildOrderChanged;

    /*************************************************************************
        Construction and Destruction
    *************************************************************************/
    GridLayoutContainer(const String& type, const String& name);

    virtual ~GridLayoutContainer(void);

    void setGridDimensions(size_t width, size_t height);
    void setGrid(const Sizef &size);

    size_t getGridWidth() const;

    size_t getGridHeight() const;

    Sizef getGrid() const;


    void setAutoPositioning(AutoPositioning positioning);

    AutoPositioning getAutoPositioning() const;

    void setNextAutoPositioningIdx(size_t idx);

    size_t getNextAutoPositioningIdx() const;

    void autoPositioningSkipCells(size_t cells);

    void addChildToPosition(Window* window, size_t gridX, size_t gridY);

    Window* getChildAtPosition(size_t gridX, size_t gridY);

    void removeChildFromPosition(size_t gridX, size_t gridY);

    virtual void swapChildPositions(size_t wnd1, size_t wnd2);

    void swapChildPositions(size_t gridX1, size_t gridY1,
                                  size_t gridX2, size_t gridY2);

    void swapChildren(Window* wnd1, Window* wnd2);

    void swapChildren(Window* wnd1, const String& wnd2);

    void swapChildren(const String& wnd1, Window* wnd2);

    void moveChildToPosition(Window* wnd, size_t gridX, size_t gridY);

    void moveChildToPosition(const String& wnd,
                                   size_t gridX, size_t gridY);

    virtual void layout();

protected:
    virtual void onChildOrderChanged(WindowEventArgs& e);

    size_t mapFromGridToIdx(size_t gridX, size_t gridY,
                            size_t gridWidth, size_t gridHeight) const;
    void mapFromIdxToGrid(size_t idx, size_t& gridX, size_t& gridY,
                          size_t gridWidth, size_t gridHeight) const;

    UVector2 getGridCellOffset(const std::vector<UDim>& colSizes,
                               const std::vector<UDim>& rowSizes,
                               size_t gridX, size_t gridY) const;
    USize getGridSize(const std::vector<UDim>& colSizes,
                         const std::vector<UDim>& rowSizes) const;

    size_t translateAPToGridIdx(size_t APIdx) const;

    size_t d_gridWidth;
    size_t d_gridHeight;

    AutoPositioning d_autoPositioning;
    size_t d_nextAutoPositioningIdx;

    size_t d_nextGridX;
    size_t d_nextGridY;

    size_t d_nextDummyIdx;

    Window* createDummy();
    bool isDummy(Window* wnd) const;

    virtual void addChild_impl(Element* element);
    virtual void removeChild_impl(Element* element);

private:
    void addGridLayoutContainerProperties(void);
};

template<>
class PropertyHelper<GridLayoutContainer::AutoPositioning>
{
public:
    typedef GridLayoutContainer::AutoPositioning return_type;
    typedef return_type safe_method_return_type;
    typedef GridLayoutContainer::AutoPositioning pass_type;
    typedef String string_return_type;

    static const String& getDataTypeName()
    {
        static String type("AutoPositioning");

        return type;
    }

    static return_type fromString(const String& str)
    {
        if (str == "Disabled")
        {
            return GridLayoutContainer::AP_Disabled;
        }
        else if (str == "Top to Bottom")
        {
            return GridLayoutContainer::AP_TopToBottom;
        }
        else
        {
            return GridLayoutContainer::AP_LeftToRight;
        }
    }

    static string_return_type toString(pass_type val)
    {
        if (val == GridLayoutContainer::AP_LeftToRight)
        {
            return "Left to Right";
        }
        else if (val == GridLayoutContainer::AP_Disabled)
        {
            return "Disabled";
        }
        else if (val == GridLayoutContainer::AP_TopToBottom)
        {
            return "Top to Bottom";
        }
        else
        {
            assert(false && "Invalid Auto Positioning");
            return "Left to Right";
        }
    }
};

} // End of  CEGUI namespace section

#if defined(_MSC_VER)
#   pragma warning(pop)
#endif

#endif  // end of guard _CEGUIGridLayoutContainer_h_