TnbGroupLayout.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
#include "TnbLayout.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CGroupLayout : public CAbstractLayout
{
    DEFSUPER(CAbstractLayout);
public:
 
    class CParallelGroup
    {
    public:
 
        CParallelGroup(ELocation defloc = DEFAULT) : m_defaultLocation(defloc)
        {
            m_params = new CParamVector;
        }
 
        CParallelGroup& Add(const ILayout& layout, ELocation loc)
        {
            TParam p(loc, layout.Clone());
            m_params->Add(p);
            return *this;
        }
 
        CParallelGroup& Add(const ILayout& layout)
        {
            return Add(layout, m_defaultLocation);
        }
 
        size_t GetItemCount(void) const
        {
            return m_params->GetSize();
        }
 
        ILayout* GetItemLayout(INDEX index)
        {
            return m_params->At(index).pLayout;
        }
 
        const ILayout* GetItemLayout(INDEX index) const
        {
            return m_params->At(index).pLayout;
        }
 
        ELocation GetItemLocation(INDEX index) const
        {
            return m_params->At(index).locate;
        }
 
        SIZE GetMinimumSize(void) const
        {
            SIZE ret = { 0, 0 };
            loop ( i, GetItemCount() )
            {
                SIZE sz;
                GetItemLayout(i)->GetMinimumSize(sz);
                ret.cx = max(ret.cx, sz.cx);
                ret.cy = max(ret.cy, sz.cy);
            }
            return ret;
        }
 
    private:
        struct TParam
        {
            ELocation       locate;     
            ILayout::Ptr    pLayout;    
            TParam(void) { }
            TParam(ELocation loc, ILayout* p) : locate(loc), pLayout(p) { }
        };
        typedef CSimpleVectorT<TParam> CParamVector;        
        CPointerHandleT<CParamVector>   m_params;           
        ELocation                       m_defaultLocation;  
    };
 
    enum EDistance
    {
        Distance_Default,       
        Distance_Absolute,      
        Distance_Rate,          
        Distance_ItemMax,       
        Distance_Rast,          
    };
    
    class CSequentialGroup
    {
    public:
 
        CSequentialGroup(void) : m_params(new CParamVector)
        {
        }
 
        CSequentialGroup& AddGroup(CParallelGroup& g, EDistance dis = Distance_Default, int val = 0)
        {
            TParam p(dis, val, g);
            m_params->Add(p);
            return *this;
        }
 
        CSequentialGroup& AutoEqualityDistance(int p = 100)
        {
            size_t num = GetGroupCount();
            size_t v = 0;
            loop ( i, num )
            {
                TParam& par = m_params->At(i);
                par.distance = Distance_Rate;
                double a = p;
                a /= num;
                a *= (i + 1);
                par.value = 1;
                if ( a >= v )
                {
                    par.value = static_cast<size_t>(a - v);
                    if ( par.value <= 0 )
                    {
                        par.value = 1;
                    }
                }
                v = static_cast<size_t>(a);
            }
            return *this;
        }
        
        size_t GetGroupCount(void) const
        {
            return m_params->GetSize();
        }
 
        CParallelGroup& GetGroup(INDEX index)
        {
            return m_params->At(index).parallel;
        }
 
        const CParallelGroup& GetGroup(INDEX index) const
        {
            return m_params->At(index).parallel;
        }
 
        EDistance GetGroupDistance(INDEX index) const
        {
            return m_params->At(index).distance;
        }
 
        size_t GetGroupValue(INDEX index) const
        {
            return m_params->At(index).value;
        }
 
        SIZE GetMinimumSize(void) const
        {
            SIZE ret = { 0, 0 };
            CWorkMemT<SIZE> sizes(GetGroupCount());
            loop ( i, GetGroupCount() )
            {
                const CParallelGroup& pg = GetGroup(i);
                SIZE sz;
                switch ( GetGroupDistance(i) )
                {
                case Distance_Absolute:// 絶対値
                    {
                        size_t val = GetGroupValue(i);
                        sz.cx = LOWORD(val);
                        sz.cy = HIWORD(val);
                    }
                    break;
                case Distance_Default:// デフォルト
                case Distance_Rate:// 比率
                case Distance_ItemMax:// アイテム最大
                case Distance_Rast:// 余り
                    sz = pg.GetMinimumSize();
                    break;
                default:
                    sz .cx = 0;
                    sz .cy = 0;
                    ASSERT( false );
                    break;
                }
                ret.cx += sz.cx;
                ret.cy += sz.cy;
                sizes[i] = sz;
            }
            // Rateチェック
            SIZE adSize = { 0, 0 };
            loop ( i, GetGroupCount() )
            {
                if ( GetGroupDistance(i) == Distance_Rate )
                {
                    size_t val = GetGroupValue(i);
                    INT_PTR x = ret.cx * val / 100;
                    if ( sizes[i].cx > x )
                    {
                        adSize.cx = max(adSize.cx, down_cast<LONG>(sizes[i].cx * 100 / val));
                    }
                    INT_PTR y = ret.cy * val / 100; 
                    if ( sizes[i].cy > y )
                    {
                        adSize.cy = max(adSize.cy, ToInt(sizes[i].cy * 100 / val));
                    }
                }
            }
            if ( adSize.cx != 0 || adSize.cy != 0 )
            {
                ret.cx = max(ret.cx, adSize.cx);
                ret.cy = max(ret.cy, adSize.cy);
            }
            return ret;
        }
 
    private:
        struct TParam
        {
            EDistance       distance;   
            size_t          value;      
            CParallelGroup  parallel;   
            TParam(void) { }
            TParam(EDistance dis, int v, CParallelGroup& para) : distance(dis), value(v), parallel(para) { }
        };
        typedef CSimpleVectorT<TParam> CParamVector;
        CPointerHandleT<CParamVector>   m_params;   
    };
 
 
    //-------------------------------------
 
 
    CGroupLayout(void)
    {
    }
 
    void SetHorizontalGroup(CSequentialGroup& g)
    {
        m_hGroup = g;
    }
 
    void SetVerticalGroup(CSequentialGroup& g)
    {
        m_vGroup = g;
    }
 
    virtual ILayout* Clone(void) const
    {
        CGroupLayout* P = new CGroupLayout();
        *P = *this;
        return P;
    }
 
    virtual bool GetMinimumSize(SIZE& _size) const
    {
        // Xを計算
        size_t hcnt = m_hGroup.GetGroupCount();
        _size.cx = (hcnt == 0) ? 0 :m_hGroup.GetMinimumSize().cx;
        // Yを計算
        size_t vcnt = m_vGroup.GetGroupCount();
        _size.cy = (vcnt == 0) ? 0 : m_vGroup.GetMinimumSize().cy;
        // 補正
        AddChinkSize(_size, hcnt, vcnt);
        return true;
    }
 
    virtual void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        size_t hcnt = m_hGroup.GetGroupCount();
        size_t vcnt = m_vGroup.GetGroupCount();
        SIZE chinkSize = { 0, 0 };
        AddChinkSize(chinkSize, hcnt, vcnt);
        //======= X座標 
        if ( x >= 0 && hcnt > 0 )
        {
            //-- 有効幅
            INT_PTR width = m_layoutSize.cx - chinkSize.cx;
            INT_PTR widthOrg = width;
            //
            INT_PTR xx = m_margn.left;
            CWorkMemT<INT_PTR> xpos(hcnt);
            CWorkMemT<size_t> xlen(hcnt);
            INDEX rastItem = INVALID_INDEX;
            loop ( index, hcnt )
            {
                xpos[index] = xx;
                const CParallelGroup& pg = m_hGroup.GetGroup(index);
                size_t val = m_hGroup.GetGroupValue(index);
                EDistance dis = m_hGroup.GetGroupDistance(index);
                if ( dis == Distance_Default )
                {
                    dis = Distance_ItemMax;
                    if ( index == hcnt - 1 && rastItem == INVALID_INDEX )
                    {
                        dis = Distance_Rast;
                    }
                }
                switch ( dis )
                {
                case Distance_Absolute:// 絶対値
                    val = LOWORD(val);
                    break;
                case Distance_Rate:// 比率
                    val = widthOrg * val / 100;
                    break;
                case Distance_ItemMax:// アイテム最大
                    val = pg.GetMinimumSize().cx;
                    break;
                case Distance_Rast:// 余り(二つ指定禁止)
                    val = 0;
                    ASSERT( rastItem == INVALID_INDEX );
                    rastItem = index;
                    break;
                default:
                    ASSERT( false );
                    break;
                }
                xlen[index] = val;
                width -= val;
                xx += val;
                xx += m_gapSize.cx; //アイテム間のサイズ
            }
            if ( rastItem != INVALID_INDEX )
            {
                // rastアイテムあり。以降、ずらす
                xlen[rastItem] = width;
                for ( size_t i = rastItem + 1; i < hcnt; i++ )
                {
                    xpos[i] += width;
                }
            }
            loop ( index, hcnt )
            {
                CParallelGroup& pg = m_hGroup.GetGroup(index);
                loop ( i, pg.GetItemCount() )
                {
                    HorizontalItemDecide(pg.GetItemLayout(i), x, xpos[index], xlen[index], pg.GetItemLocation(i), wParam, lParam);
                }
            }
        }
        //======= Y座標 
        if ( y >= 0 && vcnt > 0 )
        {
            //-- 有効幅
            INT_PTR height = m_layoutSize.cy - chinkSize.cy;
            INT_PTR heightOrg = height;
            //
            INT_PTR yy = m_margn.top;
            CWorkMemT<INT_PTR> ypos(vcnt);
            CWorkMemT<size_t> ylen(vcnt);
            INDEX rastItem = INVALID_INDEX;
            loop ( index, vcnt )
            {
                ypos[index] = yy;
                const CParallelGroup& pg = m_vGroup.GetGroup(index);
                size_t val = m_vGroup.GetGroupValue(index);
                EDistance dis = m_vGroup.GetGroupDistance(index);
                if ( dis == Distance_Default )
                {
                    dis = Distance_ItemMax;
                    if ( index == vcnt - 1 && rastItem == INVALID_INDEX )
                    {
                        dis = Distance_Rast;
                    }
                }
                switch ( dis )
                {
                case Distance_Absolute:// 絶対値
                    val = HIWORD(val);
                    break;
                case Distance_Rate:// 比率
                    val = heightOrg * val / 100;
                    break;
                case Distance_ItemMax:// アイテム最大
                    val = pg.GetMinimumSize().cy;
                    break;
                case Distance_Rast:// 余り(二つ指定禁止)
                    val = 0;
                    ASSERT( rastItem == INVALID_INDEX );
                    rastItem = index;
                    break;
                default:
                    ASSERT( false );
                    break;
                }
                ylen[index] = val;
                height -= val;
                yy += val;
                yy += m_gapSize.cy; //アイテム間のサイズ
            }
            if ( rastItem != INVALID_INDEX )
            {
                // rastアイテムあり。以降、ずらす
                ylen[rastItem] = height;
                for ( size_t i = rastItem + 1; i < vcnt; i++ )
                {
                    ypos[i] += height;
                }
            }
            loop ( index, vcnt )
            {
                CParallelGroup& pg = m_vGroup.GetGroup(index);
                loop ( i, pg.GetItemCount() )
                {
                    VerticalItemDecide(pg.GetItemLayout(i), y, ypos[index], ylen[index], pg.GetItemLocation(i), wParam, lParam);
                }
            }
        }
    }
 
 
    //------------------------
 
 
    inline friend CParallelGroup Add(ELocation defloc)
    {
        return CParallelGroup(defloc);
    }
 
    inline friend CParallelGroup Add(const ILayout& layout)
    {
        return CParallelGroup().Add(layout);
    }
 
    inline friend CParallelGroup Add(const ILayout& layout, ELocation loc)
    {
        return CParallelGroup().Add(layout, loc);
    }
 
    inline friend CSequentialGroup AddGroup(CParallelGroup& g, EDistance dis = Distance_Default, int val = 0)
    {
        return CSequentialGroup().AddGroup(g, dis, val);
    }
 
private:
    CSequentialGroup    m_hGroup;           
    CSequentialGroup    m_vGroup;           
};
 
 
 
}; // TNB