Layout.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */

#ifndef _GG_Layout_h_
#define _GG_Layout_h_

#include <GG/AlignmentFlags.h>
#include <GG/Wnd.h>

#include <boost/serialization/version.hpp>


namespace GG {

struct SetMarginAction;

class GG_API Layout : public Wnd
{
public: 

    Layout(int x, int y, int w, int h, int rows, int columns, int border_margin = 0, int cell_margin = -1);
 
    virtual Pt MinUsableSize() const;

    int    Rows() const;                             
    int    Columns() const;                          
    Flags<Alignment>
           ChildAlignment(Wnd* wnd) const;           
    int    BorderMargin() const;                     
    int    CellMargin() const;                       
    double RowStretch(int row) const;                
    double ColumnStretch(int column) const;          
    int    MinimumRowHeight(int row) const;          
    int    MinimumColumnWidth(int column) const;     
    std::vector<std::vector<const Wnd*> >
           Cells() const;                            
    std::vector<std::vector<Rect> >
           CellRects() const;                        
    std::vector<std::vector<Rect> >
           RelativeCellRects() const;                

    bool   RenderOutline() const;

    Clr    OutlineColor() const;
    
    virtual void StartingChildDragDrop(const Wnd* wnd, const Pt& offset);
    virtual void CancellingChildDragDrop(const std::list<Wnd*>& wnds);
    virtual void ChildrenDraggedAway(const std::list<Wnd*>& wnds, const Wnd* destination);
    virtual void SizeMove(const Pt& ul, const Pt& lr);
    virtual void Render();
    virtual void MouseWheel(const Pt& pt, int move, Flags<ModKey> mod_keys);
    virtual void KeyPress(Key key, Flags<ModKey> mod_keys);
    virtual void KeyRelease(Key key, Flags<ModKey> mod_keys);

    void Add(Wnd* wnd, int row, int column, Flags<Alignment> alignment = ALIGN_NONE);

    void Add(Wnd* wnd, int row, int column, int num_rows, int num_columns, Flags<Alignment> alignment = ALIGN_NONE);

    void Remove(Wnd* wnd);

    void DetachAndResetChildren();

    void ResizeLayout(int rows, int columns);

    void SetChildAlignment(Wnd* wnd, Flags<Alignment> alignment);

    void SetBorderMargin(int margin);

    void SetCellMargin(int margin);

    void SetRowStretch(int row, double stretch);

    void SetColumnStretch(int column, double stretch);

    void SetMinimumRowHeight(int row, int height);

    void SetMinimumColumnWidth(int column, int width);

    void RenderOutline(bool render_outline);

    void SetOutlineColor(Clr color);

    virtual void DefineAttributes(WndEditor* editor);
 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(InvalidMargin, GG::Layout, Exception);

    GG_CONCRETE_EXCEPTION(NoSuchChild, GG::Layout, Exception);

    GG_CONCRETE_EXCEPTION(FailedCalculationCheck, GG::Layout, Exception);

    GG_CONCRETE_EXCEPTION(AttemptedOverwrite, GG::Layout, Exception);

protected: 
    Layout(); 


private:
    struct GG_API RowColParams
    {
        RowColParams();

        double stretch;
        int    min;
        int    effective_min;   
        int    current_origin;  
        int    current_width;   

    private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };

    struct GG_API WndPosition
    {
        WndPosition();
        WndPosition(int first_row_, int first_column_, int last_row_, int last_column_, Flags<Alignment> alignment_, const Pt& original_ul_, const Pt& original_size_);

        int              first_row;
        int              first_column;
        int              last_row;
        int              last_column;
        Flags<Alignment> alignment;
        Pt               original_ul;
        Pt               original_size;

    private:
        friend class boost::serialization::access;
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };

    double TotalStretch(const std::vector<RowColParams>& params_vec) const;
    int    TotalMinWidth() const;
    int    TotalMinHeight() const;
    void   ValidateAlignment(Flags<Alignment>& alignment);
    void   RedoLayout();
    void   ChildSizeOrMinSizeOrMaxSizeChanged();

    std::vector<std::vector<Wnd*> > m_cells;
    int                             m_border_margin;
    int                             m_cell_margin;
    std::vector<RowColParams>       m_row_params;
    std::vector<RowColParams>       m_column_params;
    std::map<Wnd*, WndPosition>     m_wnd_positions;
    Pt                              m_min_usable_size;
    bool                            m_ignore_child_resize;
    bool                            m_ignore_parent_resize;
    bool                            m_render_outline;
    Clr                             m_outline_color;

    friend class Wnd;
    friend struct SetMarginAction;

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

} // namespace GG

BOOST_CLASS_VERSION(GG::Layout, 1)

// template implementations
template <class Archive>
void GG::Layout::RowColParams::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(stretch)
        & BOOST_SERIALIZATION_NVP(min)
        & BOOST_SERIALIZATION_NVP(effective_min)
        & BOOST_SERIALIZATION_NVP(current_origin)
        & BOOST_SERIALIZATION_NVP(current_width);
}

template <class Archive>
void GG::Layout::WndPosition::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(first_row)
        & BOOST_SERIALIZATION_NVP(first_column)
        & BOOST_SERIALIZATION_NVP(last_row)
        & BOOST_SERIALIZATION_NVP(last_column)
        & BOOST_SERIALIZATION_NVP(alignment)
        & BOOST_SERIALIZATION_NVP(original_ul)
        & BOOST_SERIALIZATION_NVP(original_size);
}

template <class Archive>
void GG::Layout::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Wnd)
        & BOOST_SERIALIZATION_NVP(m_cells)
        & BOOST_SERIALIZATION_NVP(m_border_margin)
        & BOOST_SERIALIZATION_NVP(m_cell_margin)
        & BOOST_SERIALIZATION_NVP(m_row_params)
        & BOOST_SERIALIZATION_NVP(m_column_params)
        & BOOST_SERIALIZATION_NVP(m_wnd_positions)
        & BOOST_SERIALIZATION_NVP(m_ignore_child_resize)
        & BOOST_SERIALIZATION_NVP(m_render_outline)
        & BOOST_SERIALIZATION_NVP(m_outline_color);

    if (1 <= version)
        ar & BOOST_SERIALIZATION_NVP(m_min_usable_size);
}

#endif // _GG_Layout_h_

---