TnbDrawingContainer.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
#include "TnbBitmapDrawer.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CDrawingContainer : public IDrawable
{
    DEFSUPER(IDrawable);
public:
 
    CDrawingContainer(void)
    {
        m_appendPos.x = 0;
        m_appendPos.y = 0;
    }
 
    virtual ~CDrawingContainer(void)
    {
        m_drawers.RemoveAll();
    }
 
    virtual IDrawable* Clone(void) const
    {
        CDrawingContainer* pNew = new CDrawingContainer();
        pNew->m_appendPos = m_appendPos;
        pNew->m_drawers.RemoveAll();
        size_t l = m_drawers.GetSize();
        pNew->m_drawers.SetSize(l);
        loop ( i, l )
        {
            pNew->m_drawers[i] = m_drawers[i];
        }
        return pNew;
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        RECT rc;
        if ( GetAllRect(rc) )
        {
            _size.cx = rc.right;
            _size.cy = rc.bottom;
            return true;
        }
        return false;
    }
 
    virtual bool Resize(const SIZE& size)
    {
        loop ( i, m_drawers.GetSize() )
        {
            TParam& A = m_drawers[i];
            SIZE sz = A.orgSize;
            if ( sz.cx + A.pos.x > size.cx )
            {
                sz.cx = size.cx - A.pos.x;
                if ( sz.cx < 0 )
                {
                    sz.cx = 0;
                }
            }
            if ( sz.cy + A.pos.y > size.cy )
            {
                sz.cy = size.cy - A.pos.y;
                if ( sz.cy < 0 )
                {
                    sz.cy = 0;
                }
            }
            A.pDrawer->Resize(sz);
        }
        return true;
    }
 
    void DefaultSize(void)
    {
        loop ( i, m_drawers.GetSize() )
        {
            TParam& A = m_drawers[i];
            A.pDrawer->Resize(A.orgSize);
        }
    }
 
    CBitmapHandle CreateBitmap(COLORREF color = CLR_INVALID) const
    {
        return CBitmapDrawer::ToBitmap(*this, color);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        DrawEx(dc, x, y, 0);
    }
 
    virtual void DrawEx(HDC dc, int x, int y, LPARAM lParam) const
    {
        if ( dc == NULL )
        {
            loop ( i, m_drawers.GetSize() )
            {
                const TParam& A = m_drawers.At(i);
                A.pDrawer->DrawEx(dc, x + A.pos.x, y + A.pos.y, lParam);
            }
        }
        else
        {
            loop ( i, m_drawers.GetSize() )
            {
                const TParam& A = m_drawers.At(i);
                SIZE size;
                if ( A.pDrawer->GetSize(size) )
                {
                    RECT rc = { x + A.pos.x, y + A.pos.y, x + A.pos.x + size.cx, y + A.pos.y + size.cy };
                    if ( ::RectVisible(dc, &rc) )
                    {
                        A.pDrawer->DrawEx(dc, rc.left, rc.top, lParam);
                    }
                }
            }
        }
    }
 
    size_t GetCount(void) const
    {
        return m_drawers.GetSize();
    }
    
    const IDrawable* At(INDEX index) const
    {
        if ( m_drawers.IsInRange(index) )
        {
            return m_drawers.At(index).pDrawer;
        }
        return NULL;
    }
 
    bool RemoveAt(INDEX index)
    {
        return m_drawers.Remove(index);
    }
 
    void RemoveAll(void)
    {
        m_drawers.RemoveAll();
        m_appendPos.x = 0;
        m_appendPos.y = 0;
    }
 
//  CBitmapHandle GetAtBitmap(INDEX index) const
//  {
//      if ( m_drawers.IsInRange(index) )
//      {
//          const TParam& A = m_drawers.At(index);
//          return A.pDrawer->GetBitmap();
//      }
//      return CBitmapHandle();
//  }
 
    bool GetAtRect(INDEX index, RECT& _rect) const
    {
        if ( ! m_drawers.IsInRange(index) ) { return false; }
        const TParam& A = m_drawers.At(index);
        SIZE size;
        bool r = A.pDrawer->GetSize(size);
        if ( r )
        {
            ::SetRect(&_rect, A.pos.x, A.pos.y, A.pos.x + size.cx, A.pos.y + size.cy);
        }
        else
        {
            ::SetRectEmpty(&_rect);
        }
        return r;
    }
 
    bool GetAllRect(RECT& _rect) const
    {
        bool r = true;
        ::SetRectEmpty(&_rect);
        loop ( i, m_drawers.GetSize() )
        {
            RECT rc;
            r &= GetAtRect(i, rc);
            ::UnionRect(&_rect, &_rect, &rc);
        }
        return r;
    }
 
    HRGN GetAllRgn(void) const
    {
        if ( GetCount() == 0 ) { return NULL; }
        HRGN rgn = ::CreateRectRgn(0, 0, 0, 0);
        loop ( i, GetCount() )
        {
            RECT r;
            if ( GetAtRect(i, r) )
            {
                HRGN rgnTemp = ::CreateRectRgnIndirect(&r);
                ::CombineRgn(rgn, rgn, rgnTemp, RGN_OR);
                _DeleteObject(rgnTemp);
            }
        }
        return rgn;
    }
 
    void DrawAt(INDEX index, HDC dc, int x = 0, int y = 0) const
    {
        if ( m_drawers.IsInRange(index) )
        {
            const TParam& A = m_drawers.At(index);
            A.pDrawer->Draw(dc, x, y);
        }
    }
 
    const POINT& GetAppendPosition(void) const
    {
        return m_appendPos;
    }
 
    void OffsetAppendPosition(int x, int y)
    {
        m_appendPos.x += x;
        m_appendPos.y += y;
    }
 
    void SetAppendPosition(int x, int y)
    {
        m_appendPos.x = x;
        m_appendPos.y = y;
    }
 
    enum EDirection
    {   
        DOWN,   
        RIGHT,  
        RETURN, 
        VRETURN,
        STAY    
    };
 
    bool MoveAppendPosition(INDEX index, EDirection dire = DOWN, int x = 0, int y = 0)
    {
        if ( m_drawers.IsInRange(index) )
        {
            const TParam& A = m_drawers.At(index);
            SIZE size;
            if ( A.pDrawer->GetSize(size) )
            {
                m_appendPos.x = A.pos.x + x;
                m_appendPos.y = A.pos.y + y;
                m_Offset(dire, size.cx, size.cy);
                return true;
            }
        }
        return false;
    }
 
    enum ELocation
    {
        RIGHTTOP,       
        RIGHTCENTER,    
        RIGHTBOTTOM,    
        //
        DOWNLEFT,       
        DOWNCENTER,     
        DOWNRIGHT,      
        //
        CENTER,         
    };
 
    INDEX AddNewPointer(IDrawable* pDraw, EDirection dire = DOWN)
    {
        TParam p;
        if ( pDraw != NULL && pDraw->GetSize(p.orgSize) )
        {
            p.pos = m_appendPos;
            p.pDrawer = pDraw;
            INDEX r = m_drawers.Add(p);
            if ( r != INVALID_INDEX )
            {
                m_Offset(dire, p.orgSize.cx, p.orgSize.cy);
                return r;
            }
        }
        delete pDraw;
        return INVALID_INDEX;
    };
 
    INDEX AddNewPointer(INDEX index, ELocation locate, IDrawable* pDraw, EDirection dire = DOWN)
    {
        if ( ! m_Locate(index, locate, pDraw) ) { return INVALID_INDEX; }
        return AddNewPointer(pDraw, dire);
    }
    
    INDEX Add(const IDrawable& draw, EDirection dire = DOWN)
    {
        return AddNewPointer(draw.Clone(), dire);
    };
 
    INDEX Add(INDEX index, ELocation locate, const IDrawable& draw, EDirection dire = DOWN)
    {
        return AddNewPointer(index, locate, draw.Clone(), dire);
    };
 
    INDEX AddBitmap(CBitmapHandle bmp, EDirection dire = DOWN)
    {
        return AddNewPointer(new CBitmapDrawer(bmp), dire);
    }
 
    INDEX AddBitmap(INDEX index, ELocation locate, CBitmapHandle bmp, EDirection dire = DOWN)
    {
        return AddNewPointer(index, locate, new CBitmapDrawer(bmp), dire);
    }
 
    int AppendBitmaps(LPCTSTR lpszPath, INDEX maxIndex, EDirection dire = DOWN)
    {
        RemoveAll();
        WIN32_FIND_DATA wfd;
        SIZE nullSize = { 0, 0 };
        CWorkMemT<TCHAR> str(MAX_PATH + 1);
        INDEX lastValidIndex = INVALID_INDEX;
        int foundCount = 0;
        loop( i, maxIndex + 1 )
        {
            if ( ! STRLIB::PrintF(str, MAX_PATH, lpszPath, i) )
            {
                return -1;
            }
            IDrawable* pDraw = NULL; 
            HANDLE hFind = ::FindFirstFile(str, &wfd);
            if ( hFind != INVALID_HANDLE_VALUE )
            {
                ::FindClose(hFind);
                CWorkMemT<TCHAR> s(MAX_PATH + 1);
                STRLIB::Copy(s, str);
                INT_PTR l = STRLIB::PathIndexOf(s) + 1;
                STRLIB::Copy(&s[l], wfd.cFileName);
                CBitmapHandle bmp(s);
                if ( ! bmp.IsNull() )
                {
                    pDraw = new CBitmapDrawer(bmp);
                    lastValidIndex = i;
                    foundCount++;
                }
            }
            if ( pDraw == NULL )
            {
                pDraw = new CNullDrawer(nullSize);
            }
            INDEX idx = AddNewPointer(pDraw, dire);
            ASSERTLIB( idx == i );
        }
        if ( lastValidIndex != INVALID_INDEX )
        {
            while ( RemoveAt(lastValidIndex + 1 ));
        }
        else
        {
            RemoveAll();
        }
        return foundCount;
    }
 
private:
 
    struct TParam
    {
        POINT                       pos;        
        SIZE                        orgSize;    
        IDrawable::Ptr              pDrawer;    
    };
    CSimpleVectorT<TParam>  m_drawers;          
    POINT                   m_appendPos;        
    // OFFSET
    void m_Offset(EDirection dire, int x, int y)
    {
        if ( dire == DOWN ) 
        {
            m_appendPos.y += y;
        }
        else if ( dire == RIGHT ) 
        {
            m_appendPos.x += x;
        }
        else if ( dire == RETURN )
        { 
            m_appendPos.x = 0;
            m_appendPos.y += y;
        }
        else if ( dire == VRETURN )
        { 
            m_appendPos.x += x;
            m_appendPos.y = 0;
        }
    }
    bool m_Locate(INDEX index, ELocation locate, const IDrawable* pDraw)
    {
        if ( ! m_drawers.IsInRange(index) ) { return false; }
        const TParam& A = m_drawers.At(index);
        SIZE baseSize;
        if ( ! A.pDrawer->GetSize(baseSize) ) { return false; }
        SIZE mySize;
        if ( ! pDraw->GetSize(mySize) ) { return false; }
        m_appendPos.x = A.pos.x;
        m_appendPos.y = A.pos.y;
        // Y調整
        if ( locate == RIGHTCENTER || locate == CENTER )
        {
            m_appendPos.y += (baseSize.cy - mySize.cy) / 2;
        }
        else if( locate == RIGHTBOTTOM )
        {
            m_appendPos.y += baseSize.cy - mySize.cy;
        }
        else if ( locate != RIGHTTOP )//下に追加
        {
            m_appendPos.y += baseSize.cy;
        }
        // X調整
        if ( locate == DOWNCENTER || locate == CENTER )
        {
            m_appendPos.x += (baseSize.cx - mySize.cx) / 2;
        }
        else if( locate == DOWNRIGHT )
        {
            m_appendPos.x += baseSize.cx - mySize.cx;
        }
        else if ( locate != DOWNLEFT )//右に追加
        {
            m_appendPos.x += baseSize.cx;
        }
        return true;
    }
};
 
 
 
};