做一个CFrameWnd.(用到的相关类可在前几篇内找到)

效果如上:

1.头文件

 

//  MKFrameWnd.h : CMKFrameWnd 类的接口
//

#pragma once

class   CMKFrameWnd :  public  CFrameWnd
... {
    
public: // 仅从序列化创建
    CMKFrameWnd();
    DECLARE_DYNCREATE(CMKFrameWnd)

// 属性
public:
    typedef enum _tagDrawState
    ...{
        StateNormal = 0,
        StateDown = 1,
        StateFocus = 2,
        StateDisable = 3
    }DrawState;

    typedef enum _tagMouseState
    ...{
        MouseStateNormal = 0,
        MouseStateDown =1,
        MouseStateUp = 2
    }MouseState;

    typedef enum _tagTitleButtons
    ...{
        ExitButton = 0,
        MaximizeButton = 1,
        MinimizeButton = 2,
        NoneButton = -1
    }TitleButtons;

// 操作
public:

// 重写
public:
    virtual BOOL PreCreateWindow(CREATESTRUCT& cs);

// 实现
public:
    virtual ~CMKFrameWnd();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

protected:  

    BOOL        m_bActive;
    int         m_ExitButtonState;
    int         m_MaximizeButtonState;
    int         m_MinimizeButtonState;
    MouseState  m_NcMouseState;
    TitleButtons m_SelTitleButton;

// 生成的消息映射函数
protected:
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    DECLARE_MESSAGE_MAP()
public:
    virtual BOOL LoadFrame(UINT nIDResource,
                DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,
                CWnd* pParentWnd = NULL,
                CCreateContext* pContext = NULL);

    BOOL MKDrawFrameBorder(CDC *pDC,HRGN hRgn = NULL);
    BOOL MKDrawMenuBar(CDC *pDC,LPARAM lParam,HRGN hrgn = NULL);
    BOOL MKDrawTitleBar(CDC* pDC,BOOL bActive,HRGN hrgn = NULL);
    BOOL MKDrawTitleBarButtons(CDC* pDC);

    LRESULT OnMKNcPaint(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKNcActive(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKActive(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKNodify(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKActiveApp(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKSetIcon(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKNcMouseMove(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKNcLMouseDown(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKNcLMouseUp(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKMouseMove(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKLButtonUp(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKNcHitTest(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKSetText(WPARAM wParam, LPARAM lParam);
    LRESULT OnMKSysCommand(WPARAM wParam,LPARAM lParam);
    LRESULT OnMKSetCursor(WPARAM wParam,LPARAM lParam);
protected:
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
} ;

 2.源文件

 

//  MKFrameWnd.cpp : CMainFrame 类的实现


#include  " stdafx.h "
#include  " MKFrameWnd.h "
#include  " MKDraw.h "
#ifdef _DEBUG
#define  new  DEBUG_NEW
#endif

static  COLORREF MKButtons[][ 4 ]  =
... {        
        ...{0x00FFE7CE, 0x00FFE7CE, 0x00EE8269, 0xFFEE8269},            
        ...{0x00BDCBD6, 0x00C6CFD6, 0x00EFF3F7, 0xFFEFF3F7},    
        ...{0x00CFF0FF, 0x00CFF0FF, 0x000097E5, 0xFF0097E5},        
        ...{0x00C1CCD1, 0x00C1CCD1, 0x00EEF1F2, 0xFFEEF1F2},
        ...{0x00FFFFFF, 0x00FFFFFF, 0x00D6DFE2, 0xFFD6DFE2},
} ;

static  COLORREF MKTitle[][ 4 ]  =
... {
        ...{0x00FF900B, 0x00FF900B,0x00F7CBAD, 0x00FF350B },
        ...{0x00FFFFFF, 0x00FFFFFF,0x00FF900B, 0x00FF900B }
} ;

//  CMKFrameWnd

IMPLEMENT_DYNCREATE(CMKFrameWnd, CFrameWnd)

BEGIN_MESSAGE_MAP(CMKFrameWnd, CFrameWnd)
    ON_WM_CREATE()
END_MESSAGE_MAP()

static  UINT indicators[]  =
... {
    ID_SEPARATOR,           // 状态行指示器
    ID_INDICATOR_CAPS,
    ID_INDICATOR_NUM,
    ID_INDICATOR_SCRL,
} ;


//  CMKFrameWnd 构造/销毁

CMKFrameWnd::CMKFrameWnd()
... {
    m_bActive = FALSE;

    m_ExitButtonState = StateNormal;
    m_MinimizeButtonState = StateNormal;
    m_MaximizeButtonState = StateNormal;
    m_NcMouseState = MouseStateNormal;
    m_SelTitleButton = NoneButton;
}

CMKFrameWnd:: ~ CMKFrameWnd()
... {
    
}

int  CMKFrameWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
... {
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
        return -1;

    return 0;
}

BOOL CMKFrameWnd::PreCreateWindow(CREATESTRUCT &  cs)
... {
    if( !CFrameWnd::PreCreateWindow(cs) )
        return FALSE;
    return TRUE;
}


//  CMKFrameWnd 诊断

#ifdef _DEBUG
void  CMKFrameWnd::AssertValid()  const
... {
    CFrameWnd::AssertValid();
}

void  CMKFrameWnd::Dump(CDumpContext &  dc)  const
... {
    CFrameWnd::Dump(dc);
}

#endif  // _DEBUG


//  CMKFrameWnd 消息处理程序
BOOL CMKFrameWnd::MKDrawFrameBorder(CDC  * pDC,HRGN hRgn)
... {
    //画框架
    CRect rtWnd;
    GetWindowRect(&rtWnd);
    rtWnd.right = rtWnd.Width() ;
    rtWnd.bottom = rtWnd.Height() ;
    rtWnd.left = rtWnd.top = 0 ;

    int Frame_BorderWidth = GetSystemMetrics(SM_CXFRAME);
    int Frame_BorderHeight =GetSystemMetrics(SM_CYFRAME);

    //画边框


    pDC->FillSolidRect(rtWnd.left  , rtWnd.top  , rtWnd.Width()  , Frame_BorderHeight , RGB(0,0,255)) ;
    pDC->FillSolidRect(rtWnd.left  , rtWnd.top  , Frame_BorderWidth  , rtWnd.Height() , RGB(0,0,255)) ;
    pDC->FillSolidRect(rtWnd.left  , rtWnd.bottom - Frame_BorderHeight  , rtWnd.Width()  ,Frame_BorderHeight , RGB(0,0,255)) ;
    pDC->FillSolidRect(rtWnd.right - Frame_BorderWidth   , rtWnd.top  , Frame_BorderWidth  , rtWnd.Height() , RGB(0,0,255)) ;

    return TRUE;
}


BOOL CMKFrameWnd::MKDrawMenuBar(CDC  * pDC,LPARAM lParam,HRGN hrgn)
... {
    CMenu *pMenu = GetMenu();
    if(pMenu == NULL)return TRUE;

    CRect rtMenu;
    CRect rtWnd;
    
    GetWindowRect(&rtWnd);
    rtMenu.left = GetSystemMetrics(SM_CXFRAME);
    rtMenu.top = GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CXFRAME) + 1;
    rtMenu.right = rtWnd.Width() - GetSystemMetrics(SM_CXFRAME);
    rtMenu.bottom = rtMenu.top +  GetSystemMetrics(SM_CYMENU);

    UINT ItemCount = pMenu->GetMenuItemCount();

    int PrevTop = rtMenu.top;
    int PrevLeft = rtMenu.left;
    int MenuItemHeight = GetSystemMetrics(SM_CYMENU);
    CRect rtMenuItem;
    
    //画菜单上部线
    CBrush brMenu(GetSysColor(COLOR_MENU));
    CBrush* pOldBrush = pDC->SelectObject(&brMenu);
    pDC->PatBlt(rtMenu.left,rtMenu.top - 1,rtMenu.Width(),1, PATCOPY);
    
    for(UINT items = 0; items < ItemCount; items++)
    ...{
        GetMenuItemRect(m_hWnd,pMenu->m_hMenu,items,&rtMenuItem);

        //画系统菜单
        HRGN rgn = CreateRectRgn(rtMenuItem.left,rtMenuItem.top,rtMenuItem.right,rtMenuItem.bottom);
        if(hrgn != NULL)
        ...{
            if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
            ...{
                CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
            }
        }
        else
        ...{
            CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
        }
        DeleteObject(rgn);

        int MenuTop = rtMenuItem.top - rtWnd.top;
        MenuItemHeight = rtMenuItem.Height();
        if(MenuTop != PrevTop)
        ...{
            rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - GetSystemMetrics(SM_CXFRAME),rtWnd.top + PrevTop + MenuItemHeight);
            if(hrgn != NULL)
            ...{
                if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
                ...{
                    CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
                }
            }
            else
            ...{
                CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
            }
            DeleteObject(rgn);


            PrevTop = MenuTop;
            PrevLeft = rtMenu.left + rtMenuItem.Width();
        }
        else
        ...{
            PrevLeft += rtMenuItem.Width();
        }
    }

    HRGN rgn = CreateRectRgn(rtWnd.left + PrevLeft,rtWnd.top + PrevTop,rtWnd.right - GetSystemMetrics(SM_CXFRAME),rtWnd.top + PrevTop + MenuItemHeight);
    if(hrgn != NULL)
    ...{
        if(NULLREGION != CombineRgn(rgn,rgn,hrgn,RGN_AND))
        ...{
            CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
        }
    }
    else
    ...{
        CFrameWnd::WindowProc(WM_NCPAINT,(WPARAM)rgn,0);
    }
    DeleteObject(rgn);
    

    //画菜单上部线
    pDC->PatBlt(rtMenu.left,PrevTop + MenuItemHeight,rtMenu.Width(),1, PATCOPY);
    pDC->SelectObject(pOldBrush);
    return TRUE;
}

BOOL CMKFrameWnd::MKDrawTitleBar(CDC *  pDC,BOOL bActive,HRGN hrgn)
... {
    //取得标题栏的位置
    DWORD style = GetStyle();
    if((style & WS_CAPTION) != WS_CAPTION) return TRUE;

    CRect rtWnd;
    GetWindowRect(&rtWnd);
    CRect rtTitle , rtTemp ;
    rtTitle.CopyRect(&rtWnd) ;
    rtTitle.right  -= rtTitle.left ;
    rtTitle.bottom -= rtTitle.top  ;
    rtTitle.left = rtTitle.top = 0 ;

    rtTitle.left = GetSystemMetrics(SM_CXFRAME);
    rtTitle.top = GetSystemMetrics(SM_CYFRAME);
    rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYSIZE) /**//*+ GetSystemMetrics(SM_CYFRAME)*/ ;
    
    CMemDC memDC(pDC,rtTitle);
    COLORREF TitleTextColor;

    if(bActive)
    ...{
        //rtTemp.CopyRect(&rtTitle) ;
        //rtTemp.bottom = rtTemp.top + rtTitle.Height()/2 ;
        //CMKDraw::MKFillGradient(&memDC,rtTemp,RGB(255,255,255),RGB(28,93,253)/*RGB(121,184,249)*/,TRUE) ;
        //rtTemp.top    = rtTemp.bottom ;
        //rtTemp.bottom = rtTitle.bottom ;
        //CMKDraw::MKFillGradient(&memDC,rtTemp,RGB(28,93,253) , RGB(255,255,255),TRUE) ;

        CMKDraw::MKGradientRectXP(&memDC , &rtTitle , MKTitle[0] ) ;
        TitleTextColor = GetSysColor(COLOR_CAPTIONTEXT);
    }
    else
    ...{
        //rtTemp.CopyRect(&rtTitle) ;
        //rtTemp.bottom = rtTemp.top + rtTitle.Height()/2 ;
        //CMKDraw::MKFillGradient(&memDC,rtTemp,RGB(255,255,255),RGB(100,93,253)/*RGB(121,184,249)*/,TRUE) ;
        //rtTemp.top    = rtTemp.bottom ;
        //rtTemp.bottom = rtTitle.bottom ;
        //CMKDraw::MKFillGradient(&memDC,rtTemp,RGB(100,93,253) , RGB(255,255,255),TRUE) ;

        CMKDraw::MKGradientRectXP(&memDC , &rtTitle , MKTitle[1] ) ;
        TitleTextColor = GetSysColor(COLOR_INACTIVECAPTIONTEXT);
    }    

    //画标题栏图标
    HICON hIcon = GetIcon(FALSE);
    CRect rtTitleText;
    if(hIcon != NULL)
    ...{
        DrawIconEx(memDC.m_hDC,rtTitle.left+1,rtTitle.top+1,hIcon,rtTitle.Height() - 2,rtTitle.Height() - 2,0,NULL,DI_NORMAL);
        rtTitleText.SetRect(rtTitle.left + rtTitle.Height(),rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
    }
    else
    ...{
        rtTitleText.SetRect(rtTitle.left + 5,rtTitle.top,rtTitle.right - 60,rtTitle.bottom);
    }

    //画标题栏文字
    CFont TitleFont;
    NONCLIENTMETRICS nif;
    nif.cbSize = sizeof(nif);
    SystemParametersInfo(SPI_GETNONCLIENTMETRICS,sizeof(NONCLIENTMETRICS),&nif,0);
    TitleFont.CreateFontIndirect(&nif.lfCaptionFont);
    CFont *pOldFont = memDC.SelectObject(&TitleFont);
    CString titleText = GetTitle();
    
    int oldBkMode = memDC.SetBkMode(TRANSPARENT);
    int oldTextColor = memDC.SetTextColor(TitleTextColor);

    TEXTMETRIC Metrics;
    pDC->GetTextMetrics(&Metrics);
    rtTitleText.top = rtTitle.top + (rtTitle.Height() - Metrics.tmHeight)/2 + 1;
    
    memDC.DrawText(titleText,&rtTitleText,DT_LEFT | DT_SINGLELINE);
    memDC.SetBkMode(oldBkMode);
    memDC.SetTextColor(oldTextColor);
    memDC.SelectObject(&pOldFont);

    //画标题栏按扭
    MKDrawTitleBarButtons(&memDC);
    return TRUE;
}

LRESULT CMKFrameWnd::OnMKNcPaint(WPARAM wParam, LPARAM lParam)
... {
    
    CWindowDC dc(this);
    HRGN hrgn = NULL;
    CRect rtWnd;
    GetWindowRect(&rtWnd);
    if(wParam != 1)
    ...{
        hrgn = (HRGN)wParam;
    }

    if(hrgn != NULL)
    ...{
        ::SelectClipRgn(dc.m_hDC,hrgn);
        ::OffsetClipRgn(dc.m_hDC,0 - rtWnd.left,0 - rtWnd.top);
    }
    MKDrawFrameBorder(&dc,hrgn);
    MKDrawTitleBar(&dc,m_bActive,hrgn);
    MKDrawMenuBar(&dc,lParam);
    if(hrgn != NULL)
    ...{
        ::SelectClipRgn(dc.m_hDC,NULL);
        DeleteObject(hrgn);
    }
    return FALSE;
}


LRESULT CMKFrameWnd::OnMKNcActive(WPARAM wParam, LPARAM lParam)
... {
    return CFrameWnd::WindowProc(WM_NCACTIVATE,wParam,lParam);
}

LRESULT CMKFrameWnd::OnMKActive(WPARAM wParam,LPARAM lParam)
... {
    LRESULT result = CFrameWnd::WindowProc(WM_ACTIVATE,wParam,lParam);
        
    if(!IsWindow(m_hWnd))return result;
    CWindowDC dc(this);
    if(wParam == WA_INACTIVE)
    ...{
        m_bActive = FALSE;
    }
    else
    ...{
        m_bActive = TRUE;
    }

    OnMKNcPaint(1,0);
    return result;
}

LRESULT CMKFrameWnd::OnMKNodify(WPARAM wParam, LPARAM lParam)
... {
    LRESULT result = CFrameWnd::WindowProc(WM_NOTIFY,wParam,lParam);

    CWindowDC dc(this);
    MKDrawTitleBar(&dc,m_bActive);
    return 0;
}

LRESULT CMKFrameWnd::OnMKActiveApp(WPARAM wParam,LPARAM lParam)
... {
    LRESULT result = CFrameWnd::WindowProc(WM_ACTIVATEAPP,wParam,lParam);

    m_bActive = (BOOL)wParam;
    return 0;
}

LRESULT CMKFrameWnd::OnMKSetText(WPARAM wParam, LPARAM lParam)
... {
    LRESULT result = CFrameWnd::WindowProc(WM_SETTEXT,wParam,lParam);

    CWindowDC dc(this);
    MKDrawTitleBar(&dc,m_bActive);
    return result;
}



BOOL CMKFrameWnd::MKDrawTitleBarButtons(CDC *  pDC)
... {    
    //取得标题栏的位置
    CRect rtWnd;
    CRect rtTitle;
    GetWindowRect(&rtWnd);
    rtTitle.left = GetSystemMetrics(SM_CXFRAME);
    rtTitle.top = GetSystemMetrics(SM_CYFRAME);
    rtTitle.right = rtWnd.right - rtWnd.left - GetSystemMetrics(SM_CXFRAME);
    rtTitle.bottom = rtTitle.top + GetSystemMetrics(SM_CYSIZE);

    int iButtonWidth = GetSystemMetrics(SM_CYSIZE) ;
    
    CRect rtButtons;

    //画标题栏按扭
    DWORD dwStyle = GetStyle();
    
    //重画关闭button
    if(dwStyle & WS_SYSMENU)
    ...{
        rtButtons.left = rtTitle.right - iButtonWidth + 2 ;
        rtButtons.top = rtTitle.top + 2;
        rtButtons.right = rtTitle.right - 2;
        rtButtons.bottom = rtTitle.bottom - 2;

        pDC->RoundRect(rtButtons.left-1, rtButtons.top -1, rtButtons.right +1, rtButtons.bottom +1, 4,4 );
        CMKDraw::MKGradientRectXP(pDC, &rtButtons, MKButtons[m_ExitButtonState]);
        pDC->MoveTo( rtButtons.left + 2, rtButtons.top + 2);
        pDC->LineTo( rtButtons.right - 2, rtButtons.bottom - 2);
        pDC->MoveTo(rtButtons.right - 2, rtButtons.top + 2);
        pDC->LineTo(rtButtons.left + 2, rtButtons.bottom - 2);
    }
    //重画最大化/恢复button
    if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
    ...{
        rtButtons.right = rtButtons.left - 2;
        rtButtons.left = rtButtons.left - rtTitle.Height() +2;
        pDC->RoundRect(rtButtons.left-1, rtButtons.top -1,rtButtons.right +1, rtButtons.bottom +1, 4,4);
        CMKDraw::MKGradientRectXP(pDC, &rtButtons, MKButtons[m_MaximizeButtonState]) ;

        if ( IsZoomed() )  
        ...{
            pDC->MoveTo(rtButtons.left + 2 , rtButtons.top + rtButtons.Height() / 2  - 1) ;
            pDC->LineTo(rtButtons.left + rtButtons.Width() - 2 , rtButtons.top + rtButtons.Height()/2 -1) ;
            pDC->MoveTo(rtButtons.left + 2 , rtButtons.top + rtButtons.Height() / 2 ) ;
            pDC->LineTo(rtButtons.left + rtButtons.Width() - 2 , rtButtons.top + rtButtons.Height()/2 ) ;
            pDC->MoveTo(rtButtons.left + 2 , rtButtons.top + rtButtons.Height() / 2 +1) ;
            pDC->LineTo(rtButtons.left + rtButtons.Width() - 2 , rtButtons.top + rtButtons.Height()/2 +1) ;
        }
        else
        ...{
            pDC->MoveTo(rtButtons.left + 2, rtButtons.top + rtButtons.Height()/2);
            pDC->LineTo(rtButtons.left + rtButtons.Width() -2 , rtButtons.top +rtButtons.Height()/2 );
            pDC->MoveTo(rtButtons.left + rtButtons.Width()/2 , rtButtons.top + 2 );
            pDC->LineTo(rtButtons.left + rtButtons.Width()/2 , rtButtons.top + rtButtons.Height() - 2);        
        }
    }
    //重画最小化button
    if(dwStyle & WS_MAXIMIZEBOX || dwStyle & WS_MINIMIZEBOX)
    ...{
        rtButtons.right = rtButtons.left - 2;
        rtButtons.left = rtButtons.left - rtTitle.Height() + 2 ;
        pDC->RoundRect(rtButtons.left-1, rtButtons.top -1,rtButtons.right +1, rtButtons.bottom +1, 4,4);
        CMKDraw::MKGradientRectXP(pDC, &rtButtons, MKButtons[m_MinimizeButtonState]) ;
        pDC->MoveTo(rtButtons.left + 4, rtButtons.bottom - 4);
        pDC->LineTo(rtButtons.right - 4, rtButtons.bottom - 4);
        pDC->MoveTo(rtButtons.left + 4, rtButtons.bottom - 5);
        pDC->LineTo(rtButtons.right- 4, rtButtons.bottom - 5);
    }
    return TRUE;
}


LRESULT CMKFrameWnd::OnMKSetIcon(WPARAM wParam, LPARAM lParam)
... {
    LRESULT result = CFrameWnd::WindowProc(WM_SETICON,wParam,lParam);

    if(IsWindow(m_hWnd))
    ...{
        CWindowDC dc(this);
        MKDrawTitleBar(&dc,m_bActive);
    }
    return result;
}

LRESULT CMKFrameWnd::OnMKNcMouseMove(WPARAM wParam,LPARAM lParam)
... {

    LRESULT result = 0;
    CWindowDC dc(this);
    switch(wParam)
    ...{
    case HTMAXBUTTON:
        if(m_NcMouseState == MouseStateNormal)
        ...{
            if(m_MaximizeButtonState != StateFocus)
            ...{
                m_MaximizeButtonState = StateFocus;
                m_MinimizeButtonState = StateNormal;
                m_ExitButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        else if(m_NcMouseState == MouseStateDown)
        ...{
            if(m_SelTitleButton == MaximizeButton)
            ...{
                if(m_MaximizeButtonState != StateDown)
                ...{
                    m_MaximizeButtonState = StateDown;
                    MKDrawTitleBarButtons(&dc);
                }
            }
            else if(m_SelTitleButton != NoneButton)
            ...{
                m_MinimizeButtonState = StateNormal;
                m_ExitButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        break;
    case HTMINBUTTON:
        if(m_NcMouseState == MouseStateNormal)
        ...{
            if(m_MinimizeButtonState != StateFocus)
            ...{
                m_MinimizeButtonState = StateFocus;
                m_MaximizeButtonState = StateNormal;
                m_ExitButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        else if(m_NcMouseState == MouseStateDown)
        ...{
            if(m_SelTitleButton == MinimizeButton)
            ...{
                if(m_MinimizeButtonState != StateDown)
                ...{
                    m_MinimizeButtonState = StateDown;
                    MKDrawTitleBarButtons(&dc);
                }
            }
            else if(m_SelTitleButton != NoneButton)
            ...{
                m_MaximizeButtonState = StateNormal;
                m_ExitButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        break;
    case HTCLOSE:
        if(m_NcMouseState == MouseStateNormal)
        ...{
            if(m_ExitButtonState != StateFocus)
            ...{
                m_ExitButtonState = StateFocus;
                m_MaximizeButtonState = StateNormal;
                m_MinimizeButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        else if(m_NcMouseState == MouseStateDown)
        ...{
            if(m_SelTitleButton == ExitButton)
            ...{
                if(m_ExitButtonState != StateDown)
                ...{
                    m_ExitButtonState = StateDown;
                    MKDrawTitleBarButtons(&dc);
                }
            }
            else if(m_SelTitleButton != NoneButton)
            ...{
                m_MaximizeButtonState = StateNormal;
                m_MinimizeButtonState = StateNormal;
                MKDrawTitleBarButtons(&dc);
            }
        }
        break;
    default:
        if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
        ...{
            m_MaximizeButtonState = StateNormal;
            m_MinimizeButtonState = StateNormal;
            m_ExitButtonState = StateNormal;
            MKDrawTitleBarButtons(&dc);
        }
        result = 0;//CFrameWnd::WindowProc(WM_NCMOUSEMOVE,wParam,lParam);
        break;
    }
    return result;
}

LRESULT CMKFrameWnd::OnMKNcLMouseDown(WPARAM wParam,LPARAM lParam)
... {

    LRESULT result = 0;
    CWindowDC dc(this);
    switch(wParam)
    ...{
    case HTMAXBUTTON:
        m_NcMouseState = MouseStateDown;
        m_SelTitleButton = MaximizeButton;
        m_MaximizeButtonState = StateDown;
        MKDrawTitleBarButtons(&dc);
        SetCapture();
        break;
    case HTMINBUTTON:
        m_NcMouseState = MouseStateDown;
        m_SelTitleButton = MinimizeButton;
        m_MinimizeButtonState = StateDown;
        MKDrawTitleBarButtons(&dc);
        SetCapture();
        break;
    case HTCLOSE:
        m_NcMouseState = MouseStateDown;
        m_SelTitleButton = ExitButton;
        m_ExitButtonState = StateDown;
        MKDrawTitleBarButtons(&dc);
        SetCapture();
        break;
    default:
        result = CFrameWnd::WindowProc(WM_NCLBUTTONDOWN,wParam,lParam);
        break;
    }

    MKDrawTitleBar(&dc,m_bActive);
    return result;
}

LRESULT CMKFrameWnd::OnMKNcLMouseUp(WPARAM wParam,LPARAM lParam)
... {

    LRESULT result = 0;
    if(m_NcMouseState == MouseStateNormal)
    ...{
        return CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
    }
    m_NcMouseState = MouseStateNormal;
    ReleaseCapture();

    if(wParam == HTMAXBUTTON)
    ...{
        if(m_SelTitleButton == MaximizeButton)
        ...{
            CWindowDC dc(this);
            m_SelTitleButton = NoneButton;
            m_MaximizeButtonState = StateNormal;
            MKDrawTitleBarButtons(&dc);
            if(IsZoomed())
            ...{
                SendMessage(WM_SYSCOMMAND, SC_RESTORE, lParam);
            }
            else
            ...{
                SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE,lParam);
            }
        }
    }
    else if(wParam == HTMINBUTTON)
    ...{
        if(m_SelTitleButton == MinimizeButton)
        ...{
            CWindowDC dc(this);
            m_SelTitleButton = NoneButton;
            m_MinimizeButtonState = StateNormal;
            MKDrawTitleBarButtons(&dc);
            SendMessage(WM_SYSCOMMAND, SC_MINIMIZE,lParam);
        }
    }
    else if(wParam == HTCLOSE)
    ...{
        if(m_SelTitleButton == ExitButton)
        ...{
            //CWindowDC dc(this);
            m_SelTitleButton = NoneButton;
            m_ExitButtonState = StateNormal;
            //MKDrawTitleBarButtons(&dc);
            SendMessage(WM_SYSCOMMAND,SC_CLOSE,lParam);
        }
    }
    else
    ...{
        m_MinimizeButtonState = StateNormal;
        m_MaximizeButtonState = StateNormal;
        m_ExitButtonState = StateNormal;
        result = CFrameWnd::WindowProc(WM_NCLBUTTONUP,wParam,lParam);
    }

    
    
    return result;
}

LRESULT CMKFrameWnd::OnMKMouseMove(WPARAM wParam, LPARAM lParam)
... {

    if(m_NcMouseState != MouseStateNormal)
    ...{
        CRect rtWnd;
        GetWindowRect(&rtWnd);
        CPoint point(lParam);
        ClientToScreen(&point);
        UINT hit = (UINT)CFrameWnd::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));
        return OnMKNcMouseMove(hit,MAKELPARAM(point.x,point.y));
    }
    else
    ...{
        if(m_ExitButtonState != StateNormal || m_MinimizeButtonState != StateNormal || m_MaximizeButtonState != StateNormal)
        ...{
            CWindowDC dc(this);
            m_MaximizeButtonState = StateNormal;
            m_MinimizeButtonState = StateNormal;
            m_ExitButtonState = StateNormal;
            MKDrawTitleBarButtons(&dc);
        }
    }
    return CFrameWnd::WindowProc(WM_MOUSEMOVE,wParam,lParam);
}

LRESULT CMKFrameWnd::OnMKLButtonUp(WPARAM wParam, LPARAM lParam)
... {

    if(m_NcMouseState != MouseStateNormal)
    ...{
        CRect rtWnd;
        GetWindowRect(&rtWnd);
        CPoint point(lParam);
        ClientToScreen(&point);
        UINT hit = (UINT)CFrameWnd::WindowProc(WM_NCHITTEST,wParam,MAKELPARAM(point.x,point.y));    
        return OnMKNcLMouseUp(hit,MAKELPARAM(point.x,point.y));
    }
    return CFrameWnd::WindowProc(WM_LBUTTONUP,wParam,lParam);
}

BOOL CMKFrameWnd::LoadFrame (UINT nIDResource, DWORD dwDefaultStyle, CWnd *  pParentWnd, CCreateContext *  pContext)
... {
    if ( !CFrameWnd::LoadFrame (nIDResource, dwDefaultStyle, pParentWnd, pContext) )
    ...{
        return false;
    }
 
    return true;
}

LRESULT CMKFrameWnd::OnMKSysCommand(WPARAM wParam,LPARAM lParam)
... {

    if(wParam != SC_CLOSE)
    ...{
        CWindowDC dc(this);
        MKDrawTitleBar(&dc,m_bActive);
    }
    return CFrameWnd::WindowProc(WM_SYSCOMMAND,wParam,lParam);
}

LRESULT CMKFrameWnd::OnMKSetCursor(WPARAM wParam,LPARAM lParam)
... {
    LRESULT rt = CFrameWnd::WindowProc(WM_SETCURSOR,wParam,lParam); 

    UINT nHitTest = LOWORD(lParam);

    CWindowDC dc(this);
    switch(nHitTest)
    ...{
    case HTBORDER:
    case HTLEFT:
    case HTRIGHT:
    case HTTOP:
    case HTBOTTOM:
    case HTBOTTOMLEFT:
    case HTBOTTOMRIGHT:
    case HTTOPLEFT:
    case HTTOPRIGHT:
        MKDrawTitleBar(&dc,m_bActive);
        break;
    default:
        break;
    }
    

    return rt;
}



LRESULT CMKFrameWnd::OnMKNcHitTest(WPARAM wParam, LPARAM lParam)
... {
    LRESULT lrst = CFrameWnd::WindowProc(WM_NCHITTEST,wParam,lParam);
    return lrst;
}

LRESULT CMKFrameWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
... {
    switch(message)
    ...{
    case WM_INITMENUPOPUP:
        if(1)
        ...{
            CWindowDC dc(this);
            MKDrawTitleBar(&dc,m_bActive);
        }
        break;
    case WM_NCPAINT:
        return OnMKNcPaint(wParam,lParam);
    case WM_NCACTIVATE:
        return OnMKNcActive(wParam,lParam);
    case WM_ACTIVATE:
        return OnMKActive(wParam,lParam);
    case WM_ACTIVATEAPP:
        return OnMKActiveApp(wParam,lParam);
    case WM_NOTIFY:
        return OnMKNodify(wParam,lParam);
    case WM_SETTEXT:
        return OnMKSetText(wParam,lParam);
    case WM_SETICON:
        return OnMKSetIcon(wParam,lParam);
    case WM_NCMOUSEMOVE:
        return OnMKNcMouseMove(wParam,lParam);
    case WM_NCLBUTTONDOWN:
        return OnMKNcLMouseDown(wParam,lParam);
    case WM_NCLBUTTONUP:
        OnMKNcLMouseUp(wParam,lParam);
    case WM_LBUTTONUP:
        return OnMKLButtonUp(wParam,lParam);
    case WM_MOUSEMOVE:
        return OnMKMouseMove(wParam,lParam);
    case WM_SYSCOMMAND:
        return OnMKSysCommand(wParam,lParam);
    case WM_SETCURSOR:
        return OnMKSetCursor(wParam,lParam);
    default:
        break;
    }

    return CFrameWnd::WindowProc(message, wParam, lParam);
}

 

收工.