// SkinButton.cpp : 实现文件
//
#include "stdafx.h"
#include "SkinButton.h"
IMPLEMENT_DYNAMIC(CSkinButton, CButton)
extern HMODULE SkinhInstance;
CSkinButton::CSkinButton()
{
    m_state = NORMAL;
    m_pFont=new CFont();
    m_pFont->CreatePointFont(90,_T("Arial"));
    m_fg = RGB(0, 0, 0);
    m_bg = RGB(255, 255, 255);
    m_bMouseOver = false;
    m_bEnabled = true;
    m_bDCStored = false;
    m_textPos = CPoint(0,0);
    m_iconRect = CRect(0,0,16,16);
}

CSkinButton::~CSkinButton()
{
    delete m_pFont;
    m_memDC.DeleteDC();
}


BEGIN_MESSAGE_MAP(CSkinButton, CButton)
    ON_WM_MOUSEMOVE()
    ON_WM_TIMER()
    ON_WM_ERASEBKGND()
    ON_WM_SETCURSOR()
    ON_WM_ENABLE()
    ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()
void CSkinButton::SetMyAllname(CString allname)
{
    Myallname=allname;
}
CString CSkinButton::GetMyAllname(void)
{

    return Myallname;
}
void CSkinButton::SetMyNumber(int MyNumber)
{
    n_MyNumber=MyNumber;
}

int CSkinButton::GetMyNumber()
{
    return n_MyNumber;
}
void CSkinButton::DrawItem(LPDRAWITEMSTRUCT lpDIS)
{

    //// TODO:  添加您的代码以绘制指定项
    //CDC* pDC = CDC::FromHandle(lpDIS->hDC);
    UINT state = lpDIS->itemState; 
    //CRect rect;
    //rect.CopyRect(&lpDIS->rcItem); 

    m_state = NORMAL;

    if (state & ODS_FOCUS)
    {
        if (state & ODS_SELECTED)
        { 
            m_state = DOWN;
        }
        else
        {
            if(m_bMouseOver)
                m_state = HOVER;
        }
    }
    else
    {
        m_state = NORMAL;
    }
    if (state & ODS_DISABLED)
    {
        m_state = DISABLE;
        m_bEnabled = false;
    }

    DrawButton();
}

void CSkinButton::DrawButton()
{
    CClientDC  dc(this);

    CRect    rect;
    GetClientRect(&rect);

    CDC memDC;
    memDC.CreateCompatibleDC(&dc);

    CBitmap Screen;
    Screen.CreateCompatibleBitmap(&dc, rect.Width(), rect.Height());
    memDC.SelectObject(&Screen);
    Screen.DeleteObject();

    //画背景 
    memDC.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &m_memDC, 0, 0, SRCCOPY);

    CString str;
    GetWindowText(str);    

    memDC.SetBkMode(TRANSPARENT);
    memDC.SelectObject(m_pFont);
    switch(m_state)
    {
    case NORMAL:

        if(!m_imgNormal.IsNull())
        {
            m_imgNormal.TransparentBlt(memDC, rect.left, rect.top, 
            m_imgNormal.GetWidth(), m_imgNormal.GetHeight(), RGB(255,0,255));

        }
        memDC.SetTextColor(GetFGColor());
        memDC.TextOut(m_textPos.x,m_textPos.y,str);

        if(!m_hMouseOutIcon.IsNull())
        {
            m_hMouseOutIcon.TransparentBlt(memDC, m_iconRect.left,m_iconRect.top, 
                m_iconRect.Width(), m_iconRect.Height(), RGB(0,0,0));
            memDC.SetTextColor(GetFGColor());
            memDC.TextOut(m_textPos.x,m_textPos.y,str);
        }
        if(!m_imgIconNormal.IsNull())
        {
            m_imgIconNormal.TransparentBlt(memDC, rect.left,rect.top, 
                m_imgIconNormal.GetWidth(), m_imgIconNormal.GetHeight(), RGB(255,0,255));

        }

        memDC.SetTextColor(GetFGColor());
        memDC.TextOut(m_textPos.x,m_textPos.y,str);
        break;
    case HOVER:

        if(!m_imgHover.IsNull())
        {
            m_imgHover.TransparentBlt(memDC, rect.left, rect.top, 
            m_imgHover.GetWidth(), m_imgHover.GetHeight(), RGB(255,0,255));

        }
        memDC.SetTextColor(GetBGColor());
        memDC.TextOut(m_textPos.x,m_textPos.y,str);

        if(!m_hMouseInIcon.IsNull())
        {
            m_hMouseInIcon.TransparentBlt(memDC, m_iconRect.left,m_iconRect.top, 
                m_iconRect.Width(), m_iconRect.Height(), RGB(0,0,0));
            memDC.SetTextColor(GetBGColor());
            memDC.TextOut(m_textPos.x,m_textPos.y,str);
        }
        if(!m_imgIconHover.IsNull())
        {
            m_imgIconHover.TransparentBlt(memDC, rect.left,rect.top, 
                m_imgIconHover.GetWidth(), m_imgIconNormal.GetHeight(), RGB(255,0,255));
            memDC.SetTextColor(GetBGColor());
            memDC.TextOut(m_textPos.x,m_textPos.y,str);
        }
        break;
    case DOWN:

        if(!m_imgDown.IsNull())
        {
            m_imgDown.TransparentBlt(memDC, rect.left, rect.top, 
            m_imgDown.GetWidth(), m_imgHover.GetHeight(), RGB(255,0,255));


        }
        memDC.SetTextColor(GetBGColor());
        memDC.TextOut(m_textPos.x+1,m_textPos.y+1,str);
        if(!m_hMouseOutIcon.IsNull())
        {
            m_hMouseOutIcon.TransparentBlt(memDC, m_iconRect.left+1,m_iconRect.top+1, 
                m_iconRect.Width(), m_iconRect.Height(), RGB(0,0,0));
            memDC.SetTextColor(GetBGColor());
            memDC.TextOut(m_textPos.x+1,m_textPos.y+1,str);
        }
        if(!m_imgIconDown.IsNull())
        {
            m_imgIconDown.TransparentBlt(memDC, rect.left+1,rect.top+1, 
                m_imgIconDown.GetWidth(), m_imgIconNormal.GetHeight(), RGB(255,0,255));
            memDC.SetTextColor(GetBGColor());
            memDC.TextOut(m_textPos.x+1,m_textPos.y+1,str);
        }
        break;
    case DISABLE:
        if(!m_imgDisable.IsNull())
        {
            m_imgDisable.TransparentBlt(memDC, rect.left, rect.top, 
            m_imgDisable.GetWidth(), m_imgHover.GetHeight(), RGB(255,0,255));

        }
        memDC.SetTextColor(GetFGColor());
        memDC.TextOut(m_textPos.x,m_textPos.y,str);
        if(!m_hMouseOutIcon.IsNull())
        {
            m_hMouseOutIcon.TransparentBlt(memDC, m_iconRect.left,m_iconRect.top, 
                m_iconRect.Width(), m_iconRect.Height(), RGB(0,0,0));
            memDC.SetTextColor(GetFGColor());
            memDC.TextOut(m_textPos.x,m_textPos.y,str);
        }
        if(!m_imgIconDisable.IsNull())
        {
            m_imgIconDisable.TransparentBlt(memDC, rect.left,rect.top, 
                m_imgIconDisable.GetWidth(), m_imgIconNormal.GetHeight(), RGB(255,0,255));
            memDC.SetTextColor(GetFGColor());
            memDC.TextOut(m_textPos.x,m_textPos.y,str);
        }
        break;
    default:
        break;
    }

    dc.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &memDC, 0, 0, SRCCOPY);

    memDC.DeleteDC();
}

void CSkinButton::DrawFilledRect(CDC *DC, CRect R, COLORREF color)
{ 
    CBrush B;
    B.CreateSolidBrush(color);
    DC->FillRect(R, &B);
}

void CSkinButton::DrawButtonText(CDC *DC, CRect R, CString str, COLORREF TextColor)
{
    COLORREF prevColor = DC->SetTextColor(TextColor);
    DC->SetBkMode(TRANSPARENT);
    DC->SelectObject(m_pFont);
    if(m_hMouseOutIcon.IsNull()&&m_hMouseInIcon.IsNull())
    {
        R.right=R.right-m_textPos.x;
        DC->DrawText( str, str.GetLength(), R, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
    }
    else
    {
        DC->DrawText( str, str.GetLength(), R, DT_RIGHT|DT_VCENTER|DT_SINGLELINE);
    }
    DC->SetTextColor(prevColor);
}

void CSkinButton::OnMouseMove(UINT nFlags, CPoint point)
{

    if(!m_bMouseOver&&m_bEnabled)
    {
        m_bMouseOver=true;
        m_state = HOVER;

        CPoint    point;
        CRect    rect;
        GetWindowRect(&rect);    
        GetCursorPos(&point);
        if (!rect.PtInRect(point) && m_bMouseOver&&m_bEnabled)
        {
            SetTimer(1,10,NULL);
            return;
        }

        DrawButton();

        SetTimer(1,10,NULL);
    }
    CButton::OnMouseMove(nFlags, point);
}

void CSkinButton::OnTimer(UINT_PTR nIDEvent)
{
    CPoint    point;
    CRect    rect;
    GetWindowRect(&rect);    
    GetCursorPos(&point);

    if (!rect.PtInRect(point) && m_bMouseOver&&m_bEnabled)
    {
        KillTimer (1);
        m_bMouseOver=false;
        m_state = NORMAL;
        DrawButton();
    }

    CButton::OnTimer(nIDEvent);
}

void CSkinButton::PreSubclassWindow()
{
    SetOwnerDraw(true);

    CButton::PreSubclassWindow();
}

void CSkinButton::SetOwnerDraw(bool IsDraw)
{
    if(IsDraw)
    {
        ModifyStyle(NULL, BS_OWNERDRAW); 
        Invalidate();
    }
    else
    {
        ModifyStyle(BS_OWNERDRAW, NULL); 
        Invalidate();
    }
}

void CSkinButton::SetImage(CString strNormal, CString strHover, CString strDown, CString strDisable)
{
    m_imgNormal.Load(strNormal);
    m_imgHover.Load(strHover);
    m_imgDown.Load(strDown);
    m_imgDisable.Load(strDisable);
}

void CSkinButton::SetImage(UINT nNormalID, UINT nHoverID, UINT nDownID, UINT nDisableID)
{

    m_imgNormal.LoadFromResource(SkinhInstance,nNormalID ); 
    m_imgHover.LoadFromResource(SkinhInstance, nHoverID ); 
    m_imgDown.LoadFromResource(SkinhInstance, nDownID ); 
    m_imgDisable.LoadFromResource(SkinhInstance, nDisableID ); 
}
void CSkinButton::SetImgIcon(UINT nNormalID, UINT nHoverID, UINT nDownID, UINT nDisableID)
{

    m_imgIconNormal.LoadFromResource(SkinhInstance,nNormalID ); 
    m_imgIconHover.LoadFromResource(SkinhInstance, nHoverID ); 
    m_imgIconDown.LoadFromResource(SkinhInstance, nDownID ); 
    m_imgIconDisable.LoadFromResource(SkinhInstance, nDisableID ); 
}

BOOL CSkinButton::OnEraseBkgnd(CDC* pDC)
{

    if(!m_bDCStored)
    {
        CRect  rect;
        GetClientRect(&rect);

        m_memDC.CreateCompatibleDC (pDC);
        CBitmap    btScreen;
        btScreen.CreateCompatibleBitmap (pDC,rect.Width(),rect.Height());
        m_memDC.SelectObject (&btScreen);

        m_memDC.BitBlt (0,0,rect.Width(),rect.Height(),pDC,0,0,SRCCOPY);

        m_bDCStored=true;

        CRgn rgn;
        rgn.CreateRectRgn (0, 0, rect.Width(), rect.Height());
        SetWindowRgn (rgn, TRUE);

        btScreen.DeleteObject();
    }
    return TRUE;// CButton::OnEraseBkgnd(pDC);
}

BOOL CSkinButton::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
    ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
    return TRUE;


}

void CSkinButton::SetIcon(CString  strMouseOut,CString strMouseIn)
{
    m_hMouseOutIcon.Load(strMouseOut);
    m_hMouseInIcon.Load(strMouseIn);
}

void CSkinButton::SetColor(COLORREF fgcolor,COLORREF bgcolor)
{
    m_fg = fgcolor;
    m_bg = bgcolor;
    DrawButton();
}

void CSkinButton::SetTextPos(CPoint point)
{
    m_textPos = point;
    DrawButton();
}
CRect CSkinButton::GetRectInParent()
{
    CRect rcWindowParent;
    GetParent()->GetWindowRect(rcWindowParent);//client
    CRect rcWindow;
    GetWindowRect(&rcWindow);
    CRect rect;
    rect.left = rcWindow.left-rcWindowParent.left;
    rect.top = rcWindow.top-rcWindowParent.top;
    rect.right = rcWindow.right-rcWindowParent.left;
    rect.bottom = rcWindow.bottom-rcWindowParent.top;

    return rect;
}
void CSkinButton::OnEnable(BOOL bEnable)
{
    CButton::OnEnable(bEnable);

    if(bEnable)
        m_bEnabled = true;
    else
        m_bEnabled = false;
}

void CSkinButton::OnReDraw(CDC *Mdc,CImage* Img)
{
    CImage *image=NULL;
    CRect rect;
    image=Img;
    rect =GetRectInParent();
    if(!image->IsNull())
        image->TransparentBlt(Mdc->m_hDC, rect.left,rect.top, 
        image->GetWidth(),image->GetHeight(), RGB(255,0,255));

}

#pragma once
#include <atlimage.h>       

// CSkinButton

class CSkinButton : public CButton
{
    DECLARE_DYNAMIC(CSkinButton)

public:
    CSkinButton();
    virtual ~CSkinButton();

    typedef enum state
    {
        NORMAL,
        HOVER,
        DOWN,
        DISABLE
    }state;

protected:
    DECLARE_MESSAGE_MAP()

    CImage  m_imgNormal;
    CImage  m_imgHover;
    CImage  m_imgDown;
    CImage  m_imgDisable;
    CImage  m_imgIconNormal;
    CImage  m_imgIconHover;
    CImage  m_imgIconDown;
    CImage  m_imgIconDisable;

private:
    state m_state;
    COLORREF m_fg, m_bg;
    bool m_bMouseOver;
    bool m_bEnabled;
    CFont *m_pFont;
    CString Myallname;
    bool m_bDCStored;

    CImage m_hMouseInIcon;
    CImage m_hMouseOutIcon;
    CPoint m_textPos;
    CRect m_iconRect;
    CDC m_memDC;
    int n_MyNumber;

public:
    afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    afx_msg void OnTimer(UINT_PTR nIDEvent);
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
    afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
protected:
    virtual void PreSubclassWindow();
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDIS);
protected:    
    //在按钮中填充颜色
    void DrawFilledRect(CDC *DC, CRect R, COLORREF color);
    //设置按钮上的字体颜色
    void DrawButtonText(CDC *DC, CRect R, CString str, COLORREF TextColor);
    void DrawButton();
public:
    void SetMyAllname(CString allname);
    CString GetMyAllname(void);
    void SetOwnerDraw(bool IsDraw);
    void SetImage(UINT nNormalID, UINT nHoverID, UINT nDownID, UINT nDisableID);
    void SetImage(CString strNormal, CString strHover, CString strDown, CString strDisable);
    void SetIcon(CString  strMouseOut,CString strMouseIn);
    void SetImgIcon(UINT nNormalID, UINT nHoverID, UINT nDownID, UINT nDisableID);
    void SetColor(COLORREF fgcolor,COLORREF bgcolor);
    void SetTextPos(CPoint point);
    void OnReDraw(CDC *Mdc,CImage* Img);
    void SetMyNumber(int MyNumber);
    int GetMyNumber();
    CImage* GetPaintImage(){return &m_imgNormal;}
    CImage* GetPaintIcon(){return &m_hMouseOutIcon;}
    CImage* GetPaintImgIcon(){return &m_imgIconNormal;}
    CPoint GetTextPos(){return m_textPos;}
    COLORREF GetFGColor() { return m_fg; }    
    COLORREF GetBGColor() { return m_bg; }
    CRect GetRectInParent();
    CRect GetIconRect(){return m_iconRect;}
    int FileID;
public:
    afx_msg void OnEnable(BOOL bEnable);
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
};

m_SelectBtn.Create(NULL,WS_CHILD | WS_VISIBLE ,CRect(135,100,135+21,100+20),this,IDC_SKINBUTTON_USERLIST);
动态创建按钮.

m_SelectBtn.SetImage(IDB_SKINBUTTON_USERNORMAL,IDB_SKINBUTTON_USERHOVER,IDB_SKINBUTTON_USERDOWN,IDB_SKINBUTTON_USERENABLE);
设置四种状态所对应的图片 然后就可以使用了

class CMyButton : public CButton
{
    DECLARE_DYNAMIC(CMyButton)
public:
    CMyButton();
    virtual ~CMyButton();
public:
    void SetBitmaps(HBITMAP Normal = NULL, HBITMAP Hot = NULL, HBITMAP Pressed = NULL, HBITMAP Disable = NULL);
protected:
    DECLARE_MESSAGE_MAP()
private:
    HBITMAP m_BitmapNormal, m_BitmapHot, m_BitmapPressed, m_BitmapDisable;
    BOOL m_MouseHover;
protected:
    virtual void PreSubclassWindow();
    virtual void DrawItem(LPDRAWITEMSTRUCT /*lpDrawItemStruct*/);
    afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    afx_msg LRESULT OnMouseLeave(WPARAM wParam, LPARAM lParam);
};
IMPLEMENT_DYNAMIC(CMyButton, CButton)

CMyButton::CMyButton()
    : m_BitmapNormal(NULL), m_BitmapHot(NULL), m_BitmapPressed(NULL), m_BitmapDisable(NULL), m_MouseHover(FALSE)
{
}

CMyButton::~CMyButton()
{
}

void CMyButton::SetBitmaps(HBITMAP Normal, HBITMAP Hot, HBITMAP Pressed, HBITMAP Disable)
{
    m_BitmapNormal = Normal;
    m_BitmapHot = Hot;
    m_BitmapPressed = Pressed;
    m_BitmapDisable = Disable;
}

BEGIN_MESSAGE_MAP(CMyButton, CButton)
    ON_WM_MOUSEMOVE()
    ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave)
END_MESSAGE_MAP()

void CMyButton::PreSubclassWindow()
{
    ModifyStyle(0, BS_OWNERDRAW);

    CButton::PreSubclassWindow();
}

void CMyButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
    RECT rc;
    GetClientRect(&rc);
    HBITMAP bitmap;
    if (lpDrawItemStruct->itemState & ODS_DISABLED)
        bitmap = m_BitmapDisable;
    else if (lpDrawItemStruct->itemState & ODS_SELECTED)
        bitmap = m_BitmapPressed;
    else
    {
        if (m_MouseHover)
            bitmap = m_BitmapHot;
        else
            bitmap = m_BitmapNormal;
    }
    HDC dc = CreateCompatibleDC(lpDrawItemStruct->hDC);
    HBITMAP oldBitmap = (HBITMAP)SelectObject(dc, bitmap);
    BitBlt(lpDrawItemStruct->hDC, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, dc, 0, 0, SRCCOPY);
    SelectObject(dc, oldBitmap);
    DeleteDC(dc);
    CString text;
    GetWindowText(text);
    SetBkMode(lpDrawItemStruct->hDC, TRANSPARENT);
    DrawText(lpDrawItemStruct->hDC, text, text.GetLength(), &rc, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
}

void CMyButton::OnMouseMove(UINT nFlags, CPoint point)
{
    if (!m_MouseHover)
    {
        Invalidate();
        TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, 0};
        m_MouseHover = TrackMouseEvent(&tme);
    }

    CButton::OnMouseMove(nFlags, point);
}

LRESULT CMyButton::OnMouseLeave(WPARAM wParam, LPARAM lParam)
{
    Invalidate();
    m_MouseHover = FALSE;
    return 0;
}