TnbDrawable.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
#include "TnbDcSelectAssistant.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct IDrawable
{
    virtual ~IDrawable(void) { }
 
    virtual IDrawable* Clone(void) const = 0;
 
    virtual bool GetSize(SIZE& _size) const = 0;
 
    virtual bool Resize(const SIZE& size) = 0;
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const = 0;
 
    virtual void DrawEx(HDC dc, int x, int y, LPARAM lParam) const
    {
        Draw(dc, x, y);
    }
 
    typedef CPointerHandleT<IDrawable> Ptr;
};
 
 
 
class CNullDrawer : public IDrawable
{
    DEFSUPER(IDrawable);
protected:
    SIZE            m_size;     
public:
 
    CNullDrawer(const SIZE& size) : m_size(size)
    {
    }
 
    CNullDrawer(void)
    {
        m_size.cx = 0;
        m_size.cy = 0;
    }
 
    virtual IDrawable* Clone(void) const 
    {
        return new CNullDrawer(m_size); 
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        _size = m_size;
        return true;
    }
 
    virtual bool Resize(const SIZE& size)
    {
        m_size = size;
        return true;
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
    }
};
 
 
 
class CPairDrawer : public IDrawable
{
    DEFSUPER(IDrawable);
    IDrawable::Ptr  m_pDrawLeft;    
    IDrawable::Ptr  m_pDrawRight;   
    size_t          m_orgLeftWidth; 
    SIZE            m_size;         
 
public:
 
    CPairDrawer(const IDrawable& drawLeft, const IDrawable& drawRight)
    {
        m_pDrawLeft = drawLeft.Clone();
        m_pDrawRight = drawRight.Clone();
        SIZE orgSize;
        m_pDrawLeft->GetSize(orgSize);
        m_orgLeftWidth = orgSize.cx;
        m_size.cx = 0;
        m_size.cy = 0;
    }
 
    virtual IDrawable* Clone(void) const
    {
        CPairDrawer* P = new CPairDrawer(*this);
        return P;
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        _size = m_size;
        return true;
    }
    
    virtual bool Resize(const SIZE& size)
    {
        m_size = size;
        SIZE s1 = { min(ToInt(m_orgLeftWidth), size.cx), size.cy };
        SIZE s2 = { max(down_cast<LONG>(size.cx - m_orgLeftWidth), 0), size.cy };
        m_pDrawLeft->Resize(s1);
        m_pDrawRight->Resize(s2);
        return true;
    }
 
    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
    {
        SIZE s1;
        m_pDrawLeft->GetSize(s1);
        m_pDrawLeft->DrawEx(dc, x, y + (m_size.cy - s1.cy) / 2, lParam);
        SIZE s2;
        m_pDrawRight->GetSize(s2);
        m_pDrawRight->DrawEx(dc, x + s1.cx, y + (m_size.cy - s2.cy) / 2, lParam);
    }
};
 
 
 
class COffsetDrawer : public IDrawable
{
    DEFSUPER(IDrawable);
    IDrawable::Ptr  m_pDrawBase;    
    POINT           m_offsetOver;   
    IDrawable::Ptr  m_pDrawOver;    
    SIZE            m_size;         
    void m_CalcSize(void)
    {
        m_size.cx = 0;
        m_size.cy = 0;
        SIZE s1;
        SIZE s2;
        if ( m_pDrawBase->GetSize(s1) && m_pDrawOver->GetSize(s2) )
        {
            RECT r1 = { 0, 0, s1.cx, s1.cy };
            RECT r2 = { m_offsetOver.x, m_offsetOver.y, m_offsetOver.x + s2.cx, m_offsetOver.y + s2.cy };
            if ( ::UnionRect(&r1, &r1, &r2) )
            {
                m_size.cx = r1.right - r1.left;
                m_size.cy = r1.bottom - r1.top;
            }
        }
    }
 
public:
 
    COffsetDrawer(const IDrawable& drawBase, const POINT& off, const IDrawable& drawOver)
        : m_offsetOver(off)
    {
        m_pDrawBase = drawBase.Clone();
        m_pDrawOver = drawOver.Clone();
        m_CalcSize();
    }
 
    COffsetDrawer(const SIZE& size, const POINT& off, const IDrawable& draw)
        : m_offsetOver(off)
    {
        m_pDrawBase = new CNullDrawer(size);
        m_pDrawOver = draw.Clone();
        m_CalcSize();
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new COffsetDrawer(*m_pDrawBase, m_offsetOver, *m_pDrawOver);
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        _size = m_size;
        return true;
    }
    
    virtual bool Resize(const SIZE& size)
    {
        return false;
    }
 
    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 ( ! m_pDrawBase.IsNull() ) 
        {
            m_pDrawBase->DrawEx(dc, x, y, lParam);
        }
        if ( ! m_pDrawOver.IsNull() ) 
        {
            m_pDrawOver->DrawEx(dc, x + m_offsetOver.x, y + m_offsetOver.y, lParam);
        }
    }
};
 
 
 
class CBoxDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
    COLORREF    m_color;    
    int         m_width;    
public:
 
    CBoxDrawer(const SIZE& size, COLORREF color, int width = 1) 
        : _super(size), m_color(color), m_width(width)
    {
    }
 
    CBoxDrawer(COLORREF color, int width = 1) 
        : _super(), m_color(color), m_width(width)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CBoxDrawer(m_size, m_color, m_width);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        int z1 = m_width / 2;
        int z2 = (m_width + 1) / 2 - 1;
        HPEN pen = ::CreatePen(PS_SOLID, m_width, m_color);
        CDcSelectAssistant dca(dc);
//      HGDIOBJ oldPen = ::SelectObject(dc, pen);
//      HGDIOBJ oldBrush = ::SelectObject(dc, ::GetStockObject(NULL_BRUSH));
        dca.SelectPen(pen);
        dca.SelectBrush(static_cast<HBRUSH>(::GetStockObject(NULL_BRUSH)));
        ::RoundRect(dc, x + z1, y + z1, m_size.cx + x - z2, m_size.cy + y - z2, 0, 0);
//      ::SelectObject(dc, oldBrush);
//      ::SelectObject(dc, oldPen);
        dca.Restore();
        _DeleteObject(pen);
    }
};
 
 
 
class CBoxFillDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
    COLORREF    m_color;    
public:
 
    CBoxFillDrawer(const SIZE& size, COLORREF color) : _super(size), m_color(color)
    {
    }
 
    CBoxFillDrawer(COLORREF color) : _super(), m_color(color)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CBoxFillDrawer(m_size, m_color);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x, y, x + m_size.cx, y + m_size.cy };
        COLORREF c = ::GetBkColor(dc);
        ::SetBkColor(dc, m_color);
        ::ExtTextOut(dc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
        ::SetBkColor(dc, c);
    }
};
 
 
 
class CBoxInverter : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
public:
 
    CBoxInverter(const SIZE& size) : _super(size)
    {
    }
 
    CBoxInverter(void) : _super()
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CBoxInverter(m_size);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x, y, x + m_size.cx, y + m_size.cy };
        ::InvertRect(dc, &rc);
    }
};
 
 
 
class CFrameDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
    bool        m_isFrameMode;
    UINT        m_param1;
    UINT        m_param2;
public:
 
    CFrameDrawer(const SIZE& size, bool isFrameMode, UINT p1, UINT p2) 
        : _super(size), m_isFrameMode(isFrameMode), m_param1(p1), m_param2(p2)
    {
    }
 
    CFrameDrawer(bool isFrameMode, UINT p1, UINT p2) 
        : _super(), m_isFrameMode(isFrameMode), m_param1(p1), m_param2(p2)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CFrameDrawer(*this);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x, y, x + m_size.cx, y + m_size.cy };
        m_isFrameMode ? ::DrawFrameControl(dc, &rc, m_param1, m_param2) : ::DrawEdge(dc, &rc, m_param1, m_param2);
    }
};
 
 
 
class CFocusFrameDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
public:
 
    CFocusFrameDrawer(const SIZE& size) : _super(size)
    {
    }
 
    CFocusFrameDrawer(void) : _super()
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CFocusFrameDrawer(m_size);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x, y, x + m_size.cx, y + m_size.cy };
        ::DrawFocusRect(dc, &rc);
    }
};
 
 
 
};