TnbBorderLayout.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
#include "TnbLayout.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBorderLayout : public CAbstractLayout
{
    DEFSUPER(CAbstractLayout);
public:
 
    enum EPosition
    {
        Position_North,             
        Position_South,             
        Position_West,              
        Position_Center,                
        Position_East,              
        //
        Position_Top = Position_North,      
        Position_Left = Position_West,      
        Position_Right = Position_East,     
        Position_Bottom = Position_South,   
    };
 
    CBorderLayout(void)
    {
        m_params = new TParams();
    }
 
    CBorderLayout& Add(EPosition pos, const ILayout& layout, ELocation hloc = DEFAULT, ELocation vloc = DEFAULT)
    {
        if ( pos >= Position_North && pos <= Position_East )
        {
            m_params->param[pos] = TParam(hloc, vloc, layout);
        }
        else
        {
            ASSERT( false );
        }
        return *this;
    }
 
    virtual ILayout* Clone(void) const
    {
        CBorderLayout* P = new CBorderLayout();
        *P = *this;
        return P;
    }
 
    virtual bool GetMinimumSize(SIZE& _size) const
    {
        _size.cx =0;
        _size.cy =0;
        SIZE sz;
        for ( int e = Position_West; e <= Position_East; e++ )
        {
            if ( m_params->param[e].pLayout != NULL && m_params->param[e].pLayout->GetMinimumSize(sz) )
            {
                _size.cy = max(_size.cy, sz.cy);
                if ( _size.cx != 0 )
                {
                    _size.cx += m_gapSize.cx;
                }
                _size.cx += sz.cx;
            }
        }
        for ( int e = Position_North; e <= Position_South; e++ )
        {
            if ( m_params->param[e].pLayout != NULL && m_params->param[e].pLayout->GetMinimumSize(sz) )
            {
                _size.cx = max(_size.cx, sz.cx);
                if ( _size.cy != 0 )
                {
                    _size.cy += m_gapSize.cy;
                }
                _size.cy += sz.cy;
            }
        }
        //
        AddMargnSize(_size);
        return true;
    }
    
    virtual void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        SIZE areaSize = m_layoutSize;
        {
            SIZE sz;
            GetMargnSize(sz);
            areaSize.cx -= sz.cx;
            areaSize.cy -= sz.cy;
        }
        POINT cpos = { m_margn.left, m_margn.top };
        SIZE csize = areaSize;
        SIZE sz; //汎用
        POINT pp[5] = { 0 };
        SIZE ss[5] = { 0 };
        //南（下）
        {
            TParam& pa = m_params->param[Position_South];
            if ( ! pa.pLayout.IsNull() && pa.pLayout->GetSize(sz) )
            {
                pp[Position_South].x = cpos.x;
                ss[Position_South].cx = csize.cx;
                pp[Position_South].y = cpos.y + csize.cy - sz.cy;
                ss[Position_South].cy = sz.cy;
                csize.cy -= sz.cy + m_gapSize.cy;
            }
        }
        //北（上）
        {
            TParam& pa = m_params->param[Position_North];
            if ( ! pa.pLayout.IsNull() && pa.pLayout->GetSize(sz) )
            {
                pp[Position_North].x = cpos.x;
                ss[Position_North].cx = csize.cx;
                pp[Position_North].y = cpos.y;
                ss[Position_North].cy = sz.cy;
                csize.cy -= sz.cy + m_gapSize.cy;
                cpos.y += sz.cy + m_gapSize.cy;
            }
        }
        //西（右）
        {
            TParam& pa = m_params->param[Position_East];
            if ( ! pa.pLayout.IsNull() && pa.pLayout->GetSize(sz) )
            {
                pp[Position_East].x = cpos.x + csize.cx - sz.cx;
                ss[Position_East].cx = sz.cx;
                pp[Position_East].y = cpos.y;
                ss[Position_East].cy = csize.cy;
                csize.cx -= sz.cx+ m_gapSize.cx;
            }
        }   
        //東（左）
        {
            TParam& pa = m_params->param[Position_West];
            if ( ! pa.pLayout.IsNull() && pa.pLayout->GetSize(sz) )
            {
                pp[Position_West].x = cpos.x;
                ss[Position_West].cx = sz.cx;
                pp[Position_West].y = cpos.y;
                ss[Position_West].cy = csize.cy;
                csize.cx -= sz.cx + m_gapSize.cx;
                cpos.x += sz.cx + m_gapSize.cx;
            }
        }   
        //中
        {
            TParam& pa = m_params->param[Position_Center];
            if ( ! pa.pLayout.IsNull() && pa.pLayout->GetSize(sz) )
            {
                pp[Position_Center].x = cpos.x;
                ss[Position_Center].cx = csize.cx;
                pp[Position_Center].y = cpos.y;
                ss[Position_Center].cy = csize.cy;
            }
        }
        //レイアウト
        int row[5] = { Position_North, Position_West, Position_Center, Position_East, Position_South };
        loop ( j, 5 )
        {
            int i = row[j];
            TParam& pa = m_params->param[i];
            if ( ! pa.pLayout.IsNull() )
            {
                HorizontalItemDecide(pa.pLayout, x, pp[i].x, ss[i].cx, pa.horizontalLocate, wParam, lParam);
                VerticalItemDecide(pa.pLayout, y, pp[i].y, ss[i].cy, pa.verticalLocate, wParam, lParam);
            }
        }
    }
 
private:
    struct TParams
    {
        TParam  param[5];
    };
    CPointerHandleT<TParams>    m_params;       
};
 
 
 
}; // TNB