Sizer.h

Go to the documentation of this file.

#ifndef SIZER_H
#define SIZER_H

#include <vector>

struct SizerPoint
{
    SizerPoint(int px = 0, int py = 0) : x(px), y(py) {}

    void Set(int px, int py) { x = px; y = py; }

    int x; 
    int y; 
};

struct SizerSize
{
    SizerSize(int width = 0, int height = 0) : w(width), h(height) {}

    void Set(int width, int height) { w = width; h = height; }

    int w; 
    int h; 
};

struct SizerRect
{
    SizerRect(int x = 0, int y = 0, int width = 0, int height = 0) : p(x, y), s(width, height) {}
    SizerRect(const SizerPoint& topLeft, const SizerSize& size) : p(topLeft), s(size) {}

    void Set(int x, int y, int w, int h) { p.Set(x, y); s.Set(w, h); }

    SizerPoint p; 
    SizerSize s;  
};

class ISizer
{
public:
    ISizer()
    {
        dirty = true;
    }

    virtual ~ISizer() {}

    virtual void OnCalcSizes() = 0;
    virtual void OnRectChanged(int x, int y, int w, int h) = 0;
    virtual size_t GetItemCount() { return 0; }
    virtual ISizer* GetItem(size_t i) { return NULL; }

    void CalcSizes();
    SizerSize GetMinSize();
    void Move(int x, int y, int w, int h);
    void Move(const SizerPoint& p, const SizerSize& s) { return Move(p.x, p.y, s.w, s.h); }
    void Move(const SizerRect& r) { return Move(r.p.x, r.p.y, r.s.w, r.s.h); }
    SizerRect GetRect() const;

    void WmSize(UINT type, int cx, int cy)
    {
        Move(0, 0, cx, cy);
    }

    void WmGetMinMaxInfo(HWND window, MINMAXINFO* mmi)
    {
        RECT r;
        SetRect(&r, 0, 0, GetMinSize().w, GetMinSize().h);
        DWORD style = GetWindowLong(window, GWL_STYLE);
        AdjustWindowRectEx(&r,
            style,
            (style & WS_CHILD) == 0 && GetMenu(window) != NULL, // with menu?
            GetWindowLong(window, GWL_EXSTYLE));

        mmi->ptMinTrackSize.x = r.right - r.left;
        mmi->ptMinTrackSize.y = r.bottom - r.top;
    }
protected:
    bool dirty;
    SizerRect rect;
    SizerSize minimumSize;
private:
    // disable copy constructor for all subclasses
    ISizer(const ISizer& other) {}
    // disable assignment operator for all subclasses
    ISizer& operator= (const ISizer& other) { return *this; }
};

class EmptySizer : public ISizer
{
public:
    EmptySizer(int minW = 0, int minH = 0)
    {
        minimumSize.w = minW;
        minimumSize.h = minH;
    }

    virtual void OnCalcSizes() {}
    virtual void OnRectChanged(int x, int y, int w, int h) {}
};

class WindowSizer : public ISizer
{
public:
    WindowSizer(HWND pWindow);

    virtual void OnCalcSizes() {}
    virtual void OnRectChanged(int x, int y, int w, int h) { MoveWindow(window, x, y, w, h, TRUE); }
private:
    HWND window;
};

class GroupboxSizer : public ISizer
{
public:
    GroupboxSizer(HWND pGroupbox, ISizer* pItem);
    ~GroupboxSizer();

    void SetOuterPadding(int pad);

    virtual void OnCalcSizes();
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return 1; }
    virtual ISizer* GetItem(size_t i) { return item; }
private:
    int GetHPadding() { return leftPadding+rightPadding; }
    int GetVPadding() { return topPadding+bottomPadding; }

    HWND groupbox;
    ISizer* item;
    int leftPadding;
    int rightPadding;
    int topPadding;
    int bottomPadding;
    int outerPadding;
};

class OverlapSizer : public ISizer
{
public:
    OverlapSizer();
    ~OverlapSizer();

    virtual void OnCalcSizes();
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return items.size(); }
    virtual ISizer* GetItem(size_t i) { return items[i]; }

    void SetOuterPadding(int pad);
    void Add(ISizer* item);
    void Add(HWND window) { return Add(new WindowSizer(window)); }
    void RemoveAll();
private:
    std::vector<ISizer*> items;
    int outerPadding;
};

class BoxSizer : public ISizer
{
public:
    BoxSizer(bool pHorizontal);
    ~BoxSizer();

    virtual void OnCalcSizes();
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return items.size(); }
    virtual ISizer* GetItem(size_t i) { return items[i].sizer; }

    BoxSizer* SetPadding(int pad);
    BoxSizer* SetOuterPadding(int pad);
    BoxSizer* Add(ISizer* sizer, int proportion = 0);
    BoxSizer* Add(HWND window, int proportion = 0) { return Add(new WindowSizer(window), proportion); }
    BoxSizer* AddStretchSpace(int proportion) { return Add((ISizer*)NULL, proportion); }
    void RemoveAll();
    BoxSizer* StretchItemInMinorDirection(bool stretch);
private:
    int GetTotalPadding() { return items.empty() ? 0 : ((int)items.size()-1)*padding; }

    // a BoxSizer works 1-dimensional, so there is a major and a minor coordinate
    //             major minor
    // horizontal    x     y
    // vertical      y     x
    int GetMajorCoord(const SizerPoint& p) const { return horizontal ? p.x : p.y; }
    int GetMinorCoord(const SizerPoint& p) const { return horizontal ? p.y : p.x; }
    int& MajorCoord(SizerPoint& p) const { return horizontal ? p.x : p.y; }
    int& MinorCoord(SizerPoint& p) const { return horizontal ? p.y : p.x; }
    SizerPoint PosFromMajorMinor(int major, int minor) const { return horizontal ? SizerPoint(major, minor) : SizerPoint(minor, major); }
    int GetMajorCoord(const SizerSize& s) const { return horizontal ? s.w : s.h; }
    int GetMinorCoord(const SizerSize& s) const { return horizontal ? s.h : s.w; }
    int& MajorCoord(SizerSize& s) const { return horizontal ? s.w : s.h; }
    int& MinorCoord(SizerSize& s) const { return horizontal ? s.h : s.w; }
    SizerSize SizeFromMajorMinor(int major, int minor) const { return horizontal ? SizerSize(major, minor) : SizerSize(minor, major); }

    struct Item
    {
        Item(ISizer* s, int prop)
        {
            sizer = s;
            proportion = prop;
        }

        ISizer* sizer;
        int proportion;
    };

    std::vector<Item> items;
    int padding;
    bool horizontal;
    int outerPadding;
    bool stretchInMinorDir;

    // this data is generated from CalcSizes()
    std::vector<SizerSize> calcedSizes;
};

class HBoxSizer : public BoxSizer
{
public:
    HBoxSizer() : BoxSizer(true) {}

    static HBoxSizer* New() { return new HBoxSizer(); }
};

class VBoxSizer : public BoxSizer
{
public:
    VBoxSizer() : BoxSizer(false) {}

    static VBoxSizer* New() { return new VBoxSizer(); }
};

enum SIZER_HALIGN
{
    SIZER_LEFT,    
    SIZER_HCENTER, 
    SIZER_RIGHT,   
};

class HAlignSizer : public ISizer
{
public:
    HAlignSizer();
    HAlignSizer(ISizer* pItem, SIZER_HALIGN pAlign);
    HAlignSizer(HWND window, SIZER_HALIGN pAlign);
    ~HAlignSizer();

    virtual void OnCalcSizes() { minimumSize = item->GetMinSize(); }
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return 1; }
    virtual ISizer* GetItem(size_t i) { return item; }

    void SetItem(ISizer* pItem, SIZER_HALIGN pAlign) { Init(pItem, pAlign); }
    void SetItem(HWND window, SIZER_HALIGN pAlign) { Init(new WindowSizer(window), pAlign); }

    void RemoveAll() { Init(NULL, SIZER_LEFT); }
private:
    void Init(ISizer* pItem, SIZER_HALIGN pAlign);

    ISizer* item;
    SIZER_HALIGN align;
};

enum SIZER_VALIGN
{
    SIZER_TOP,     
    SIZER_VCENTER, 
    SIZER_BOTTOM,  
};

class VAlignSizer : public ISizer
{
public:
    VAlignSizer();
    VAlignSizer(ISizer* pItem, SIZER_VALIGN pAlign);
    VAlignSizer(HWND window, SIZER_VALIGN pAlign);
    ~VAlignSizer();

    virtual void OnCalcSizes() { minimumSize = item->GetMinSize(); }
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return 1; }
    virtual ISizer* GetItem(size_t i) { return item; }

    void SetItem(ISizer* pItem, SIZER_VALIGN pAlign) { Init(pItem, pAlign); }
    void SetItem(HWND window, SIZER_VALIGN pAlign) { Init(new WindowSizer(window), pAlign); }

    void RemoveAll() { Init(NULL, SIZER_TOP); }
private:
    void Init(ISizer* pItem, SIZER_VALIGN pAlign);

    ISizer* item;
    SIZER_VALIGN align;
};

class GridSizer : public ISizer
{
public:
    GridSizer();
    ~GridSizer();

    virtual void OnCalcSizes();
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return items.size(); }
    virtual ISizer* GetItem(size_t i) { return items[i]->sizer; }

    void SetPadding(int padX, int padY);
    void SetOuterPadding(int pad);
    void Add(ISizer* sizer, size_t row, size_t column, size_t spannedRows = 1, size_t spannedColumns = 1);
    void Add(HWND window, size_t row, size_t column, size_t spannedRows = 1, size_t spannedColumns = 1) { return Add(new WindowSizer(window), row, column, spannedRows, spannedColumns); }
    void Remove(size_t row, size_t column);
    void RemoveAll();
    void SetColumnProportion(size_t column, int proportion);
    void SetColumnItemsSameWidth(size_t column, bool set);
    void SetRowProportion(size_t row, int proportion);
    void SetRowItemsSameHeight(size_t row, bool set);
    size_t GetNumRows() { return grid.totalRows; }
    size_t GetNumColumns() { return grid.totalColumns; }
private:
    void EnsureCellExists(size_t row, size_t column);
    int GetTotalPaddingX() { return grid.totalColumns == 0 ? 0 : ((int)grid.totalColumns-1)*paddingX; }
    int GetTotalPaddingY() { return grid.totalRows == 0 ? 0 : ((int)grid.totalRows-1)*paddingY; }

    // specialization of a vector to support 2 dimensions
    template<typename T>
    class Grid : public std::vector<T>
    {
    public:
        Grid();
        void SetSize(size_t rows, size_t columns, T defaultValue);
        T& Get(size_t row, size_t column);
        void Set(size_t row, size_t column, const T& value);

        size_t totalRows;
        size_t totalColumns;
    };

    // holds a sizer and extra information for it, like spanned rows and columns
    class Item
    {
    public:
        Item(ISizer* pSizer, size_t row, size_t column, size_t spannedRows, size_t spannedColumns)
        {
            sizer = pSizer;

            startRow = row;
            startColumn = column;
            // span must not be less than 1
            spanRows = spannedRows < 1 ? 1 : spannedRows;
            spanColumns = spannedRows < 1 ? 1 : spannedColumns;
        }

        ~Item() { delete sizer; }

        bool IsColumnSpan() { return spanColumns > 1; }
        bool IsRowSpan() { return spanRows > 1; }
        bool IsSpan() { return IsColumnSpan() || IsRowSpan(); }

        ISizer* sizer;
        size_t startRow;
        size_t startColumn;
        size_t spanRows;
        size_t spanColumns;
    };

    // holds information about a row or column.
    class RowOrColumn
    {
    public:
        RowOrColumn() : proportion(0), allItemsSameSize(false) {}

        int proportion;
        bool allItemsSameSize;
    };

    std::vector<RowOrColumn> rows;
    std::vector<RowOrColumn> columns;

    // unique list of sizer items
    std::vector<Item*> items;
    // grid of sizer items, if a sizer shows up in multiple grid cells, than it is spanned.
    Grid<Item*> grid;
    int paddingX;
    int paddingY;
    int outerPadding;

    // this data is generated from CalcSizes()
    std::vector<int> rowHeights;
    std::vector<int> columnWidths;
    Grid<SizerSize> calcedCellSizes;
};

class FlowSizer : public ISizer
{
public:
    FlowSizer();
    ~FlowSizer();

    void SetPadding(int pad);
    void SetOuterPadding(int pad);
    void Add(ISizer* item);
    void Add(HWND window) { return Add(new WindowSizer(window)); }
    void RemoveAll();

    virtual void OnCalcSizes();
    virtual void OnRectChanged(int x, int y, int w, int h);
    virtual size_t GetItemCount() { return items.size(); }
    virtual ISizer* GetItem(size_t i) { return items[i]; }
private:
    std::vector<ISizer*> items;
    int padding;
    int outerPadding;
};

#endif