TnbBitmapDrawer.h

[詳解]

#pragma once
#include "TnbBitmapImage.h"
#include "TnbDrawable.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBitmapDrawer : public IDrawable
{
    DEFSUPER(IDrawable);
protected:
 
    CBitmapHandle m_bmp;    
public:
 
    CBitmapDrawer(CBitmapHandle bmp) : m_bmp(bmp)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CBitmapDrawer(m_bmp);
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        return m_bmp.GetSize(_size);
    }
 
    virtual bool Resize(const SIZE& size)
    {
        return false;
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
#ifndef _WIN32_WCE
        HBITMAP h = m_bmp;
        ::DrawState(dc, NULL, NULL, reinterpret_cast<LPARAM>(h), 0, x, y, 0, 0, DST_BITMAP);
#else
        HBITMAP h = m_bmp;
        CBitmapHandle::Draw(dc, h, x, y);
#endif
    }
 
    static CBitmapHandle ToBitmap(const IDrawable& draw, COLORREF color = CLR_INVALID)
    {
        CBitmapImage bi;
        SIZE size;
        if ( draw.GetSize(size) )
        {
            if ( bi.Set(size.cx, size.cy, color) )
            {
                HDC dc = bi.GetDC();
                draw.Draw(dc);
                bi.ReleaseDC();
            }
        }
        return bi;
    }
};
 
 
 
#ifndef _WIN32_WCE
class CBitmapExDrawer : public CBitmapDrawer
{
    DEFSUPER(CBitmapDrawer);
    UINT        m_uExFlag;      
public:
 
    CBitmapExDrawer(CBitmapHandle bmp, UINT uExFlag = DSS_NORMAL)
        : _super(bmp), m_uExFlag(uExFlag)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CBitmapExDrawer(m_bmp, m_uExFlag);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        HBITMAP h = m_bmp;
        ::DrawState(dc, NULL, NULL, reinterpret_cast<LPARAM>(h), 0, x, y, 0, 0, DST_BITMAP | m_uExFlag);
    }
};
#endif //_WIN32_WCE
 
 
 
class CSemitransparentBitmapDrawer : public CBitmapDrawer
{
    DEFSUPER(CBitmapDrawer);
    int         m_parsent;      
    COLORREF    m_color;        
public:
 
    CSemitransparentBitmapDrawer(CBitmapHandle bmp, int par = 100, COLORREF color = CLR_INVALID)
        : _super(bmp), m_parsent(par), m_color(color)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CSemitransparentBitmapDrawer(m_bmp, m_parsent, m_color);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        CBitmapImage bi(m_bmp);
        bi.SemitransparectBlt(dc, x, y, m_parsent, m_color);
    }
};
 
 
 
class CTileDrawer : public CBitmapDrawer
{
    DEFSUPER(CBitmapDrawer);
    SIZE        m_size;     
public:
 
    CTileDrawer(const SIZE& size, CBitmapHandle bmp) : _super(bmp), m_size(size)
    {
    }
 
    CTileDrawer(const SIZE& size, const IDrawable& draw, COLORREF color = CLR_INVALID) 
        : _super(CBitmapDrawer::ToBitmap(draw, color)), m_size(size)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CTileDrawer(m_size, m_bmp);
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        _size = m_size;
        return ! m_bmp.IsNull();
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        CBitmapImage bi(m_bmp);
        RECT rect = { x, y, x + m_size.cx, y + m_size.cy };
        bi.DrawTile(dc, rect);  
    }
};
 
 
 
class CSemitransparentBoxFillDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
    COLORREF    m_color;        
    int         m_parsent;      
public:
 
    CSemitransparentBoxFillDrawer(const SIZE& size, COLORREF color, int par = 100)
        : _super(size), m_color(color), m_parsent(par)
    {
    }
 
    CSemitransparentBoxFillDrawer(COLORREF color, int par = 100)
        : _super(), m_color(color), m_parsent(par)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CSemitransparentBoxFillDrawer(m_size, m_color, m_parsent);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        CBitmapImage bi;
        bi.Set(m_size.cx, m_size.cy, m_color);
        bi.AlphaBlend(dc, x, y, m_parsent);
    }
};
 
 
 
};