TnbGridLayout.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
#include "TnbLayout.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CGridLayout : public CAbstractLayout
{
    DEFSUPER(CAbstractLayout);
public:
 
    CGridLayout(size_t cx) : m_sizex(cx)
    {
        ASSERT( m_sizex != 0 );
        m_params = new CParamVector();
    }
 
    CGridLayout& Add(const ILayout& layout, ELocation hloc = DEFAULT, ELocation vloc = DEFAULT)
    {
        m_params->Add(TParam(hloc, vloc, layout));
        return *this;
    }
 
    virtual ILayout* Clone(void) const
    {
        CGridLayout* P = new CGridLayout(m_sizex);
        *P = *this;
        return P;
    }
 
    virtual bool GetMinimumSize(SIZE& _size) const
    {
        _size.cx =0;
        _size.cy =0;
        int ly = 0;
        CWorkMemT<LONG> lxs(GetHorizontalItemCount());
        loop ( y, GetVerticalItemCount() )
        {
            loop ( x, GetHorizontalItemCount() )
            {
                if ( m_params->GetSize() > y * GetHorizontalItemCount() + x)
                {
                    SIZE sz;
                    if ( m_params->At(y * GetHorizontalItemCount() + x).pLayout->GetMinimumSize(sz) )
                    {
                        ly = max(ly, sz.cy);
                        lxs[x] = max(lxs[x], sz.cx);
                    }
                }
            }
        }
        _size.cy += ToInt(ly * GetVerticalItemCount());
        // Xを調べる
        int lx = 0;
        loop ( x, GetHorizontalItemCount() )
        {
            lx = max(lx, lxs[x]);
        }
        _size.cx += ToInt(lx * GetVerticalItemCount());
        //
        AddChinkSize(_size, GetHorizontalItemCount(), GetVerticalItemCount());
        return true;
    }
    
    virtual void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        SIZE areaSize = m_layoutSize;
        {
            SIZE sz = { 0, 0 };
            AddChinkSize(sz, GetHorizontalItemCount(), GetVerticalItemCount());
            areaSize.cx = ToInt((areaSize.cx - sz.cx) / GetHorizontalItemCount());
            areaSize.cy = ToInt((areaSize.cy - sz.cy) / GetVerticalItemCount());
        }
        int posy = m_margn.top;
        loop ( yy, GetVerticalItemCount() )
        {
            int posx = m_margn.left;
            loop ( xx, GetHorizontalItemCount() )
            {
                if ( m_params->GetSize() > yy * GetHorizontalItemCount() + xx)
                {
                    TParam& pa = m_params->At(yy * GetHorizontalItemCount() + xx);
                    HorizontalItemDecide(pa.pLayout, x, posx, areaSize.cx, pa.horizontalLocate, wParam, lParam);
                    VerticalItemDecide(pa.pLayout, y, posy, areaSize.cy, pa.verticalLocate, wParam, lParam);
                    posx += areaSize.cx + m_gapSize.cx;
                }
            }
            posy += areaSize.cy + m_gapSize.cy;
        }
    }
 
private:
    typedef CSimpleVectorT<TParam> CParamVector;    
    CPointerHandleT<CParamVector>   m_params;       
    size_t                          m_sizex;        
    size_t GetHorizontalItemCount(void) const
    {
        return m_sizex;
    }
    size_t GetVerticalItemCount(void) const
    {
        return (m_params->GetSize() + m_sizex - 1) / m_sizex;
    }
};
 
 
 
}; // TNB