TnbBoxLayout.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
#include "TnbLayout.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBoxLayout : public CAbstractLayout
{
    DEFSUPER(CAbstractLayout);
public:
 
    CBoxLayout(bool isHorizental = true, bool isLastFilling = true)
        : m_isHorizental(isHorizental), m_isLastFilling(isLastFilling)
    {
        m_params = new CParamVector();
    }
 
    void SetLastFilling(bool isLastFilling)
    {
        m_isLastFilling = isLastFilling;
    }
 
    void SetHorizentalMode(bool isHorizental)
    {
        m_isHorizental = isHorizental;
    }
 
    CBoxLayout& Add(const ILayout& layout, ELocation hloc = DEFAULT, ELocation vloc = DEFAULT)
    {
        m_params->Add(TParam(hloc, vloc, layout));
        return *this;
    }
 
    virtual ILayout* Clone(void) const
    {
        CBoxLayout* P = new CBoxLayout();
        *P = *this;
        return P;
    }
 
    virtual bool GetMinimumSize(SIZE& _size) const
    {
        return m_Calc(_size, NULL);
    }
    
    virtual void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        CSizeEx position(m_margn.left, m_margn.top);
        CSizeEx minSize;
        CSimpleVectorT<TResult> poss;
        if ( ! m_Calc(minSize, &poss) )
        {
            return;
        }
        size_t itemNum = m_params->GetSize();
        loop ( item, itemNum )
        {
            TParam& pa = m_params->At(item);
            CSizeEx nowItemSize;
            if ( ! pa.pLayout->GetSize(nowItemSize) )
            {
                return;
            }
            CSizeEx areaSize = poss[item].size;
            int ll = 0;
            if ( m_isHorizental )
            {
                areaSize.cy = m_layoutSize.cy - m_margn.top - m_margn.bottom;
                ll = m_layoutSize.cx - minSize.cx;
            }
            else
            {
                areaSize.cx = m_layoutSize.cx - m_margn.left - m_margn.right;
                ll = m_layoutSize.cy - minSize.cy;
            }
            if ( m_isLastFilling && item == (itemNum - 1) )
            {
                areaSize.At(m_isHorizental) += ll;
            }
            loop ( hos, 2 )
            {
                bool isHos = (hos == 0);
                if ( position.At(isHos) < 0 )
                {
                    continue;
                }
                int ww = position.At(isHos);
                if ( m_isHorizental == isHos )
                {
                    ww += poss[item].pos;
                }
                if ( isHos )
                {
                    HorizontalItemDecide(pa.pLayout, x, ww, areaSize.At(isHos), GetLocation(pa, isHos), wParam, lParam);
                }
                else
                {
                    VerticalItemDecide(pa.pLayout, y, ww, areaSize.At(isHos), GetLocation(pa, isHos), wParam, lParam);
                }
            }
        }
    }
 
private:
    class CSizeEx : public SIZE
    {
        DEFSUPER(SIZE);
    public:
        CSizeEx() {}
        CSizeEx(int x, int y) { cx = x; cy = y; }
        CSizeEx(SIZE initSize) { cx = initSize.cx; cy = initSize.cy; }
        LONG& At(bool isHorizen) { return isHorizen ? cx : cy; }
        const LONG& At(bool isHorizen) const { return isHorizen ? cx : cy; }
    };
    struct TResult
    {
        LONG    pos;    
        CSizeEx size;   
    };
    bool m_Calc(SIZE& _size, CSimpleVectorT<TResult>* pRes) const
    {
        CSizeEx gapSize = m_gapSize;
        TResult r;
        r.pos = 0;
        LONG hh = 0;
        loop ( item, m_params->GetSize() )
        {
            const TParam& pa = m_params->At(item);
            if ( ! pa.pLayout->GetMinimumSize(r.size) )
            {
                return false;
            }
            if ( item != 0 )
            {
                r.pos += gapSize.At(m_isHorizental);
            }
            if ( pRes != NULL )
            {
                pRes->Add(r);
            }
            r.pos += r.size.At(m_isHorizental);
            hh = max(hh, r.size.At(! m_isHorizental));
        }
        CSizeEx sz;
        GetMargnSize(sz);
        sz.At(m_isHorizental) += r.pos;
        sz.At(! m_isHorizental) += hh;
        _size = sz;
        return true;
    }
    static ELocation GetLocation(TParam& p, bool isHorizen) 
    {
        return isHorizen ? p.horizontalLocate : p.verticalLocate; 
    }
    typedef CSimpleVectorT<TParam> CParamVector;    
    CPointerHandleT<CParamVector>   m_params;       
    bool m_isHorizental;                            
    bool m_isLastFilling;                           
};
 
 
 
}; // TNB