zoukankan      html  css  js  c++  java

  • 深入Windows窗体原理及控件重绘技巧

    之前有学MFC的同学告诉我觉得Windows的控件重绘难以理解，就算重绘成功了还是有些地方不明白，我觉得可能很多人都有这样的问题，在这里我从Windows窗体的最基本原理来讲解，如果你有类似的疑惑希望这篇文章可以帮你解惑。

    1.Windows窗体原理

    首先，如果看过Win32 SDK编程的都知道Windows的三大核心系统：负责窗口对象产生和消息分发的USER模块，负责图像显示绘制的GDI模块，负责内存、进程、IO管理的KERNEL模块。试想象一下如何在一个像素阵列上产生窗口对象，其实就是使用GDI绘制窗口，不停的以一定的频率刷新显示在屏幕上，这就是图形界面，如果由在DOS或Windows DOS模拟器下编写图形界面的经验这个比较好理解。所以说其实USER模块中的窗口产生是依靠GDI模块的(包括菜单、滚动条等都是使用GDI来绘制的)。

    那么，下面我们就从USER模块和GDI模块来说说Windows 的窗体原理。

    如果接触过Win32 SDK编程的知道一个标准Windows窗体的产生过程：设计窗口类、注册窗口类、创建窗口、显示窗口、启动消息循环泵循环获取消息分发到窗体过程函数处理。为了保证博客的连贯性，在这里我贴上一个标准Windows窗体的产生代码。

    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. #include <windows.h>  
    2.   
    3. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);  
    4.   
    5. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)  
    6. {  
    7.     static TCHAR szAppName[] = TEXT ("窗口类名称");  
    8.     HWND         hwnd;  
    9.     MSG          msg;  
    10.     WNDCLASSEX   wndclassex = {0};  
    11.   
    12.     //设计窗口类  
    13.     wndclassex.cbSize        = sizeof(WNDCLASSEX);  
    14.     wndclassex.style         = CS_HREDRAW | CS_VREDRAW;  
    15.     wndclassex.lpfnWndProc   = WndProc;  
    16.     wndclassex.cbClsExtra    = 0;  
    17.     wndclassex.cbWndExtra    = 0;  
    18.     wndclassex.hInstance     = hInstance;  
    19.     wndclassex.hIcon         = LoadIcon (NULL, IDI_APPLICATION);  
    20.     wndclassex.hCursor       = LoadCursor (NULL, IDC_ARROW);  
    21.     wndclassex.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);  
    22.     wndclassex.lpszMenuName  = NULL;  
    23.     wndclassex.lpszClassName = szAppName;  
    24.     wndclassex.hIconSm       = wndclassex.hIcon;  
    25.       
    26.     //注册窗口类  
    27.     if (!RegisterClassEx (&wndclassex))  
    28.     {  
    29.         MessageBox (NULL, TEXT ("RegisterClassEx failed!"), szAppName, MB_ICONERROR);  
    30.         return 0;  
    31.     }  
    32.   
    33.     //产生窗口  
    34.     hwnd = CreateWindowEx (WS_EX_OVERLAPPEDWINDOW,   
    35.                           szAppName,   
    36.                           TEXT ("窗口名称"),  
    37.                           WS_OVERLAPPEDWINDOW,  
    38.                           CW_USEDEFAULT,   
    39.                           CW_USEDEFAULT,   
    40.                           CW_USEDEFAULT,   
    41.                           CW_USEDEFAULT,   
    42.                           NULL,   
    43.                           NULL,   
    44.                           hInstance,  
    45.                           NULL);   
    46.               
    47.     //显示窗口  
    48.     ShowWindow (hwnd, iCmdShow);  
    49.     UpdateWindow (hwnd);  
    50.       
    51.     //启动消息循环泵循环获取消息分配到窗体过程函数处理  
    52.     while (GetMessage (&msg, NULL, 0, 0))  
    53.     {  
    54.         TranslateMessage (&msg);  
    55.         DispatchMessage (&msg);  
    56.     }  
    57.   
    58.     return msg.wParam;  
    59. }  
    60.   
    61. //窗体过程函数  
    62. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
    63. {  
    64.     HDC hdc;  
    65.     PAINTSTRUCT ps;  
    66.   
    67.     switch (message)  
    68.     {  
    69.     case WM_CREATE:  
    70.         return (0);  
    71.           
    72.     case WM_PAINT:  
    73.         hdc = BeginPaint (hwnd, &ps);  
    74.         EndPaint (hwnd, &ps);  
    75.         return (0);  
    76.           
    77.     case WM_DESTROY:  
    78.         PostQuitMessage (0);  
    79.         return (0);  
    80.     }  
    81.   
    82.     return DefWindowProc (hwnd, message, wParam, lParam);  
    83. }  

    需要明白的是，所有Windows的窗体及控件归根结底都是使用CreateWindow或CreateWindowEx来创建的，他们都需要标准Windows窗体的产生过程。

    普通的窗体好理解，主要需要弄清楚是对话框及控件的产生和消息分派处理流程。

    对话框及其子控件的管理依靠Windows内建的对话框管理器，对话框管理器的工作包括：

    1.根据我们在资源设计器中设计的对话框及子控件产生的.rc文件来自动生成对话框和子控件(如果有手动编写.rc文件的经历的话，知道编写RC文件其实就是指定窗口和子控件大小、类型、样式等参数，对话框管理器将这些参数传入CreateWindow函数产生窗体)

    2.模态对话框直接显示窗体，非模态对话框消息指明WS_VISIBLE属性的话，需要调用ShowWindow来显示窗体。

    4.维护一个消息循环泵，对于模态对话框来说这个消息泵的消息不经过父窗口，所以表现为模态；对于非模态对话框这个消息泵消息经过主窗口，必须由主窗口传给非模态对话框，表现为非模态。

    3.维护一个内建的窗体过程函数，对于对话框来说会处理对话框的关闭打开及子窗口的焦点、tab等，对于子控件也是一样，每个子控件会有自己类型的窗体过程函数，窗体过程函数处理子控件的获得或失去焦点、按下或弹起、创建等表现样式和行为。对于对话框来说，他会开放一个对话框过程函数，让部分消息先通过对话框管理函数处理，如果对话框过程函数不处理才交给默认的内建过程函数处理，对于子控件来说，他们并没有开放过程函数，而是由内建窗体函数将要处理的消息发给父窗口处理。

    那么对话框管理器完成了标准Windows窗体的产生中后半部分工作，至于设计窗口类和注册窗口类这是由Windows自己预先做好了的，如常见的“button”、“listbox”、“edit”类等等。

    一个简要的示意图如下


    那么既然所有的窗体(包括对话框和控件)产生过程一样，那么我们就可以将对话框管理器的部分工作替换掉：

    1.不使用对话框读取.rc模板的方式，直接将参数传递给CreateWindow函数来创建对话框和控件，这就是常见的动态创建控件原理。

    2.设置控件自绘制如BS_OWNDRAW属性，开放控件的WM_DRAWITEM消息给父窗口，由父窗口来绘制按钮样式，这就是常见的控件重绘原理。

    3.替换掉内建的窗体函数，将消息传到自定义的窗体过程函数处理，这就是常见的控件子类化原理。


    下面，为了做演示，先用通用模板创建的方式创建一个模态对话框和其子控件，然后模板创建一个非模态对话框，在非模态对话框中使用动态创建的方式创建和模态对话框中模板创建一样的按钮(当然位置和大小等可能不一样，这里只是为了说明原理故笔者并没有去管这些细节，如果你愿意完全可以把它们做的一模一样)。

    代码太长，这里只贴出部分代码，详细代码请下载演示文件

    主窗口消息泵

    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1.   while (GetMessage (&msg, NULL, 0, 0))  
    2.   {  
    3. //注意非模态对话框消息由主窗口分发  
    4. if (hDlgModeless == NULL || !IsDialogMessage(hDlgModeless, &msg))  
    5. {  
    6.     TranslateMessage (&msg);  
    7.     DispatchMessage (&msg);  
    8. }  
    9.   }  

    主窗口菜单响应

    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. case IDM_TEMPLATE:  
    2.     DialogBox(GetWindowLong(hwnd, GWL_HINSTANCE),  
    3.               IDD_TEMPLATE,  
    4.               hwnd,  
    5.               TemplateProc);  
    6.     break;  
    7. case IDM_CREATE:  
    8.     hDlgModeless = CreateDialog(GetWindowLong(hwnd, GWL_HINSTANCE),  
    9.                                  MAKEINTRESOURCE(IDD_CREATE),  
    10.                                  hwnd,  
    11.                                  CreateProc);  
    12.     ShowWindow(hDlgModeless, SW_NORMAL);//注意非模态对话框不指明WS_VISIBLE属性必须显示调用ShowWindow来显示  
    13.     break;  

    模板创建的模态对话框对话框过程函数

    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. BOOL CALLBACK  TemplateProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)  
    2. {  
    3.     switch(message)  
    4.     {  
    5.     case WM_CLOSE:  
    6.         {  
    7.             EndDialog(hDlg,0);  
    8.         }  
    9.         return (TRUE);  
    10.   
    11.     case WM_COMMAND:  
    12.         switch (LOWORD(wParam))  
    13.         {  
    14.         case IDCANCEL:  
    15.             {  
    16.                 SendMessage(hDlg, WM_CLOSE, 0, 0);  
    17.             }  
    18.             return (TRUE);  
    19.         case IDOK:  
    20.             {  
    21.                   
    22.             }  
    23.             return (TRUE);  
    24.         }  
    25.         return (FALSE);  
    26.     }  
    27.   
    28.     return (FALSE);  
    29. }  

    模板创建的非模态对话框的对话框过程函数

    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. BOOL CALLBACK  CreateProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)  
    2. {  
    3.     switch(message)  
    4.     {  
    5.     case WM_INITDIALOG:  
    6.         {  
    7.             //动态创建控件子窗口  
    8.             CreateWindow(TEXT("button"),   
    9.                          TEXT("确定"),   
    10.                          WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,  
    11.                          10, 10,  
    12.                          100, 50,  
    13.                          hDlg,  
    14.                          (HMENU)IDOK,  
    15.                          GetWindowLong(hDlg, GWL_HINSTANCE),  
    16.                          NULL);  
    17.             CreateWindow(TEXT("button"),   
    18.                         TEXT("取消"),   
    19.                         WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,  
    20.                         10, 100,  
    21.                         100, 50,  
    22.                         hDlg,  
    23.                         (HMENU)IDCANCEL,  
    24.                         GetWindowLong(hDlg, GWL_HINSTANCE),  
    25.                         NULL);  
    26.         }  
    27.         return (TRUE);  
    28.   
    29.     case WM_CLOSE:  
    30.         DestroyWindow(hDlg);  
    31.         hDlgModeless = NULL;//注意及时将指针置0防止窗口销毁后消窗口分发消息  
    32.         return (TRUE);  
    33.   
    34.     case WM_COMMAND:  
    35.         switch (LOWORD(wParam))  
    36.         {  
    37.         case IDCANCEL:  
    38.             {  
    39.                 SendMessage(hDlg, WM_CLOSE, 0, 0);  
    40.             }  
    41.             return (TRUE);  
    42.         case IDOK:  
    43.             {  
    44.   
    45.             }  
    46.             return (TRUE);  
    47.         }  
    48.         return (FALSE);  
    49.     }  

    创建效果

    模态对话框


    非模态对话框

    二者起到了相同的作用，动态创建比模板创建要灵活的多，这个深入学习请自行查找相关资料。上例中需要注意的模态对话框和非模态对话框，前者的消息不流经主窗口消息泵，后者的消息要先流经主窗口消息泵。

    2.控件重绘(WM_DRAWITEM)

    写这篇博文的初衷就是讲解控件重绘原理，自然不能少了这一内容，在刚刚提到了修改对话框管理器的行为的几种方式，后两种(开放WM_DRAWITEM消息和控件子类化)都是常用的控件重绘技巧，在这一节先讲WM_DRAWITEM消息重绘，下一节讲控件子类化重绘，都是以按钮的重绘为例来讲解。
    WM_DRAWITEM顾名思义当控件需要重绘的时候发给主窗口的消息，一般在按钮按下或弹起、获得焦点或失去焦点、创建等时候会产生这一消息，默认是不开启重绘消息的，如果使用模板创建按钮必须在按钮属性中设置OwnDraw属性为True，如果动态创建按钮必须加上BS_OWNDRAW这一属性。
    下面我要重绘两个个按钮，按钮是模板创建的，是默认的IDOK和IDCANCEL按钮，希望达到的效果是
    按钮普通状态分别为

    按钮获得焦点分别为

    按钮按下状态分别为


    下面先贴出绘制部分代码，再讲解
    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. BOOL CALLBACK SelfDrawProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)  
    2. {  
    3.     LPDRAWITEMSTRUCT pdis;  
    4.     HDC hdc;  
    5.     HDC hMemDc;  
    6.   
    7.     static HINSTANCE hInstance;  
    8.     static HBITMAP hBitmapOK_D;  
    9.     static HBITMAP hBitmapOK_U;  
    10.     static HBITMAP hBitmapOK_F;  
    11.     static HBITMAP hBitmapCANCEL_D;  
    12.     static HBITMAP hBitmapCANCEL_U;  
    13.     static HBITMAP hBitmapCANCEL_F;  
    14.     static HWND    hwndOk;  
    15.     static HWND    hwndCanel;  
    16.     static BITMAP  bm;  
    17.   
    18.   
    19.     switch(message)  
    20.     {  
    21.     case WM_INITDIALOG:  
    22.         {  
    23.             hInstance = GetWindowLong(hDlg, GWL_HINSTANCE);  
    24.             hwndOk = GetDlgItem(hDlg, IDOK);  
    25.             hwndCanel = GetDlgItem(hDlg, IDCANCEL);  
    26.   
    27.             hBitmapOK_D = LoadBitmap(hInstance, TEXT("image1d"));  
    28.             hBitmapOK_U = LoadBitmap(hInstance, TEXT("image1u"));  
    29.             hBitmapOK_F = LoadBitmap(hInstance, TEXT("image1f"));  
    30.             hBitmapCANCEL_D = LoadBitmap(hInstance, TEXT("image2d"));  
    31.             hBitmapCANCEL_U = LoadBitmap(hInstance, TEXT("image2u"));  
    32.             hBitmapCANCEL_F = LoadBitmap(hInstance, TEXT("image2f"));  
    33.   
    34.             GetObject(hBitmapCANCEL_D, sizeof(BITMAP), (PTSTR)&bm);  
    35.   
    36.             //调整按钮大小和最大图片一样大  
    37.             SetWindowPos(hwndOk, HWND_TOPMOST, 0, 0, bm.bmWidth, bm.bmHeight, SWP_NOZORDER | SWP_NOMOVE);  
    38.             SetWindowPos(hwndCanel, HWND_TOPMOST, 0, 0,  bm.bmWidth, bm.bmHeight, SWP_NOZORDER | SWP_NOMOVE);  
    39.         }  
    40.         return (TRUE);  
    41.   
    42.     case WM_CLOSE:  
    43.         {  
    44.             EndDialog(hDlg,0);  
    45.         }  
    46.         return (TRUE);  
    47.   
    48.     case WM_COMMAND:  
    49.         switch (LOWORD(wParam))  
    50.         {  
    51.         case IDCANCEL:  
    52.             {  
    53.                 SendMessage(hDlg, WM_CLOSE, 0, 0);  
    54.             }  
    55.             return (TRUE);  
    56.         case IDOK:  
    57.             {  
    58.                   
    59.             }  
    60.             return (TRUE);  
    61.         }  
    62.         return (FALSE);  
    63.       
    64.     //自绘制按钮  
    65.     case WM_DRAWITEM:  
    66.         //获得绘制结构体，包含绘制的按钮DC和当前按钮状态等  
    67.         pdis = (LPDRAWITEMSTRUCT)lParam;  
    68.               
    69.         if (pdis->CtlType == ODT_BUTTON)//只绘制button类型  
    70.         {  
    71.             hdc = pdis->hDC;  
    72.             SaveDC(hdc);//保存DC,绘制完必须恢复默认  
    73.   
    74.             //绘制默认状态  
    75.             hMemDc = CreateCompatibleDC(hdc);  
    76.             SelectObject(hMemDc, pdis->CtlID == IDOK ? hBitmapOK_U : hBitmapCANCEL_U);  
    77.             BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hMemDc, 0, 0, SRCCOPY);  
    78.             DeleteDC(hMemDc);  
    79.   
    80.             //绘制获取焦点时状态  
    81.             if (pdis->itemState & ODS_FOCUS)  
    82.             {  
    83.                 hMemDc = CreateCompatibleDC(hdc);  
    84.                 SelectObject(hMemDc, pdis->CtlID == IDOK ? hBitmapOK_F : hBitmapCANCEL_F);  
    85.                 BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hMemDc, 0, 0, SRCCOPY);  
    86.                 DeleteDC(hMemDc);  
    87.             }  
    88.   
    89.             //绘制下压状态  
    90.             if (pdis->itemState & ODS_SELECTED)  
    91.             {  
    92.                 hMemDc = CreateCompatibleDC(hdc);  
    93.                 SelectObject(hMemDc, pdis->CtlID == IDOK ? hBitmapOK_D : hBitmapCANCEL_D);  
    94.                 BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hMemDc, 0, 0, SRCCOPY);  
    95.                 DeleteDC(hMemDc);  
    96.             }  
    97.               
    98.             RestoreDC(hdc, -1);  
    99.         }  
    100.   
    101.         return (TRUE);  
    102.     }  
    103.     return (FALSE);  
    104. }  
    在WM_INITDIALOG函数中加载相关资源和设置按钮大小
    在WM_DRAWITEM完成主要绘制工作，获得WM_DRAWITEM消息时获得绘制的结构体，这个结构体包括当前要绘制的按钮的ID、状态等，我们主要的工作就是将对应状态的按钮贴上相应的位图即可。
    效果如下
    WM_DRAWITEM消息控件重绘是最常用的重绘技巧，在网上常见的别人封装好的自定义控件都是这样的原理。

    3.控件重绘(控件子类化)

    子类化是借鉴C++的面向对象中的继承和重载的思想，基本意思就是如果子类对消息处理了的话对应C++的重载，这时候父类就没办法再处理这个消息，除非人为的将消息传递给父类，所有的消息先流经子类再到父类，当然这一过程需要子类的配合，具体意思我们用代码来说明。
    同样是达到上一节WM_DRAWITEM绘制的按钮效果
    我们用控件子类化完成这一效果，贴出部分代码，完整代码请下载演示文件
    对话框过程函数
    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. WNDPROC btnOkOldProc, btnCancelOldProc;  
    2. BOOL CALLBACK SubclassProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)  
    3. {  
    4.     static HWND    hwndOk;  
    5.     static HWND    hwndCanel;  
    6.   
    7.     switch(message)  
    8.     {  
    9.     case WM_INITDIALOG:  
    10.         {  
    11.             hwndOk = GetDlgItem(hDlg, IDOK);  
    12.             hwndCanel = GetDlgItem(hDlg, IDCANCEL);  
    13.   
    14.             //窗口子类化  
    15.             btnOkOldProc = SetWindowLong(hwndOk, GWL_WNDPROC, (LONG)BtnProc);  
    16.             btnCancelOldProc = SetWindowLong(hwndCanel, GWL_WNDPROC, (LONG)BtnProc);  
    17.         }  
    18.         return (TRUE);  
    19.   
    20.     case WM_CLOSE:  
    21.         {  
    22.             EndDialog(hDlg,0);  
    23.         }  
    24.         return (TRUE);  
    25.   
    26.     case WM_COMMAND:  
    27.         switch (LOWORD(wParam))  
    28.         {  
    29.         case IDCANCEL:  
    30.             {  
    31.                 SendMessage(hDlg, WM_CLOSE, 0, 0);  
    32.             }  
    33.             return (TRUE);  
    34.         case IDOK:  
    35.             {  
    36.                   
    37.             }  
    38.             return (TRUE);  
    39.         }  
    40.         return (FALSE);  
    41.     }  
    42.     return (FALSE);  
    43. }  
    按钮过程函数(子类)
    [cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
    1. typedef enum tagBUTTONSTATE  
    2. {  
    3.     BTNSTATE_DEFAULT=0,  
    4.     BTNSTATE_FOCUS,  
    5.     BTNSTATE_SELECTED  
    6. }BUTTONSTATE;  
    7. LRESULT CALLBACK  BtnProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
    8. {  
    9.     HDC hdc;  
    10.     HDC hMemDc;  
    11.     PAINTSTRUCT ps;  
    12.       
    13.     static int      id;  
    14.     static HINSTANCE hInstance;  
    15.     static HBITMAP hBitmapOK_D;  
    16.     static HBITMAP hBitmapOK_U;  
    17.     static HBITMAP hBitmapOK_F;  
    18.     static HBITMAP hBitmapCANCEL_D;  
    19.     static HBITMAP hBitmapCANCEL_U;  
    20.     static HBITMAP hBitmapCANCEL_F;  
    21.     static BITMAP  bm;  
    22.     static BOOL    bOnce = TRUE;  
    23.     static BUTTONSTATE btnOkState=BTNSTATE_FOCUS;  
    24.     static BUTTONSTATE btnCancelState=BTNSTATE_DEFAULT;  
    25.   
    26.     id = GetWindowLong(hwnd, GWL_ID);  
    27.   
    28.     //初次进入函数加载资源,模拟WM_CREATE  
    29.     if (TRUE == bOnce)  
    30.     {  
    31.         hInstance = GetWindowLong(hwnd, GWL_HINSTANCE);  
    32.   
    33.         hBitmapOK_D = LoadBitmap(hInstance, TEXT("image1d"));  
    34.         hBitmapOK_U = LoadBitmap(hInstance, TEXT("image1u"));  
    35.         hBitmapOK_F = LoadBitmap(hInstance, TEXT("image1f"));  
    36.         hBitmapCANCEL_D = LoadBitmap(hInstance, TEXT("image2d"));  
    37.         hBitmapCANCEL_U = LoadBitmap(hInstance, TEXT("image2u"));  
    38.         hBitmapCANCEL_F = LoadBitmap(hInstance, TEXT("image2f"));  
    39.   
    40.         GetObject(hBitmapCANCEL_D, sizeof(BITMAP), (PTSTR)&bm);  
    41.         SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, bm.bmWidth, bm.bmHeight, SWP_NOZORDER | SWP_NOMOVE);  
    42.   
    43.         bOnce = FALSE;  
    44.     }  
    45.   
    46.     switch (message)  
    47.     {  
    48.     case WM_CREATE:  
    49.         //注意这个消息不会进入  
    50.         return (0);  
    51.           
    52.     case WM_PAINT:  
    53.         hdc = BeginPaint (hwnd, &ps);  
    54.   
    55.         hMemDc = CreateCompatibleDC(hdc);  
    56.   
    57.         //绘制不同状态下的按钮样式  
    58.         if (btnOkState == BTNSTATE_DEFAULT && id == IDOK)  
    59.         {  
    60.             SelectObject(hMemDc, hBitmapOK_U);  
    61.         }  
    62.         if(btnCancelState == BTNSTATE_DEFAULT && id==IDCANCEL)  
    63.         {  
    64.             SelectObject(hMemDc, hBitmapCANCEL_U);  
    65.         }  
    66.         if (btnOkState == BTNSTATE_FOCUS && id==IDOK)  
    67.         {  
    68.             SelectObject(hMemDc, hBitmapOK_F);  
    69.         }  
    70.         if(btnCancelState == BTNSTATE_FOCUS && id==IDCANCEL)  
    71.         {  
    72.             SelectObject(hMemDc, hBitmapCANCEL_F);  
    73.         }  
    74.         if (btnOkState == BTNSTATE_SELECTED && id==IDOK)  
    75.         {  
    76.             SelectObject(hMemDc, hBitmapOK_D);  
    77.         }  
    78.         if(btnCancelState == BTNSTATE_SELECTED && id==IDCANCEL)  
    79.         {  
    80.             SelectObject(hMemDc, hBitmapCANCEL_D);  
    81.         }  
    82.   
    83.         BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hMemDc, 0, 0, SRCCOPY);  
    84.         DeleteDC(hMemDc);  
    85.   
    86.         EndPaint (hwnd, &ps);  
    87.         return (0);  
    88.   
    89.     case WM_SETFOCUS:  
    90.         if (id==IDOK)  
    91.         {  
    92.             btnOkState = BTNSTATE_FOCUS;  
    93.         }  
    94.         else  
    95.         {  
    96.             btnCancelState = BTNSTATE_FOCUS;  
    97.         }  
    98.         return (0);  
    99.   
    100.     case WM_KILLFOCUS:  
    101.         if (id==IDOK)  
    102.         {  
    103.             btnOkState = BTNSTATE_DEFAULT;  
    104.         }  
    105.         else  
    106.         {  
    107.             btnCancelState = BTNSTATE_DEFAULT;  
    108.         }  
    109.         return (0);  
    110.   
    111.     case WM_KEYDOWN:  
    112.         if (wParam == VK_SPACE)  
    113.         {  
    114.             if (id==IDOK)  
    115.             {  
    116.                 btnOkState = BTNSTATE_SELECTED;  
    117.             }  
    118.             else  
    119.             {  
    120.                 btnCancelState = BTNSTATE_SELECTED;  
    121.             }  
    122.   
    123.             InvalidateRect(hwnd, NULL, TRUE);  
    124.         }  
    125.         return (0);  
    126.   
    127.     case WM_KEYUP:  
    128.         if (wParam == VK_SPACE)  
    129.         {  
    130.             if (id==IDOK)  
    131.             {  
    132.                 btnOkState = BTNSTATE_FOCUS;  
    133.             }  
    134.             else  
    135.             {  
    136.                 btnCancelState = BTNSTATE_FOCUS;  
    137.             }  
    138.   
    139.             InvalidateRect(hwnd, NULL, TRUE);  
    140.         }  
    141.         return (0);  
    142.   
    143.     case WM_LBUTTONDOWN:  
    144.             SetCapture(hwnd);  
    145.             if (id==IDOK)  
    146.             {  
    147.                 btnOkState = BTNSTATE_SELECTED;  
    148.             }  
    149.             else  
    150.             {  
    151.                 btnCancelState = BTNSTATE_SELECTED;  
    152.             }  
    153.   
    154.             InvalidateRect(hwnd, NULL, TRUE);  
    155.         return (0);  
    156.   
    157.     case WM_LBUTTONUP:  
    158.             if (id==IDOK)  
    159.             {  
    160.                 btnOkState = BTNSTATE_FOCUS;  
    161.             }  
    162.             else  
    163.             {  
    164.                 btnCancelState = BTNSTATE_FOCUS;  
    165.             }  
    166.   
    167.             InvalidateRect(hwnd, NULL, TRUE);  
    168.             ReleaseCapture();  
    169.         return (0);  
    170.           
    171.     case WM_DESTROY:  
    172.         DestroyWindow(hwnd);  
    173.         return (0);  
    174.     }  
    175.     return CallWindowProc (id == IDOK ? btnOkOldProc : btnCancelOldProc, hwnd, message, wParam, lParam);  
    176. }  
    在以上代码，我们在对话框的WM_INITDIALOG消息中强制换掉按钮原有的内建窗体过程函数，使用我们自己的BtnProc过程函数。需要注意的是在我们换掉
    按钮原有的内建窗体过程函数的时候按钮已经创建完成，所以如果我们在BtnProc的WM_CREATE设置断点，程序是不会进入的。和WM_DRAWITEM一样，我们需要按钮的不同状态时绘制，因为我们采用自己的BtnProc过程函数，所以我们只能自己来维护按钮的状态，在WM_PAINT函数中根据不同状态绘制不同样式的按钮，在其他消息中处理按钮的按下或弹起、获得焦点、或失去焦点等状态转变。
    创建效果如下

    我们基本上模拟了WM_DRAWITEM消息重绘效果：按Tab键切换焦点，按Space键按钮按下弹起(当然只是为了演示原理，会有一些Bug，你可以想办法完善他们)。在上诉代码中，我们在最后调用了原来的内建的窗体过程函数，我们处理了WM_PAINT、WM_KEYUP、WM_KEYDOWN等消息，这些消息都return (0)直接返回了，即内建的窗体过程函数没有机会处理这些消息，其他的子类没有处理的消息都传给原来内建的窗体过程函数处理了，如果我们想原来的内建窗体过程函数也处理WM_PAINT，那么将return (0)改成break即可。这就是我上面提到的子类化的实现必须依靠子类化窗体函数的配合，我们也可以将所有的消息都在子类中处理不回传给原来的内建窗口，但是这样的工作量太大，一般是不会这样做的。
    另外，可以看到相比于WM_DRAWITEM消息重绘，子类化实现控件重绘工作量要大得多，当然这样的灵活性要更大。实际上，微软提供子类化的作用更多是为了重新定制子控件的行为，比如说要将一组相同按钮按下时发送一个自定义消息，这时候就可以将这些按钮的消息子类化都先流经一个子类化窗体过程函数，然后再调用内建的窗体过程函数。

    总结来说，一般重绘控件样式使用WM_DRAWITEM消息，重新定制控件行为使用窗体子类化。

    博客完整演示代码下载链接
    毕竟现在来说如果不是为了实现一个自绘控件库的话，不会使用SDK自绘的方式，下一次我会讲一下MFC中自绘方式的具体流程和实例。

    原创，转载请注明来自http://blog.csdn.net/wenzhou1219
  • 相关阅读:
    第2阶段冲刺2
    第2阶段冲刺1
    在Ubuntu下安装VWMare tools
    mysql命令行修改密码
    Ubuntu设置环境变量
    java输出程序运行时间
    Hadoop之环境搭建
    MapReduce实现WordCount
    大数据技术之kettle（2）——练习三个基本操作
    大数据技术之kettle（1）——安装
  • 原文地址：https://www.cnblogs.com/zhoug2020/p/6264732.html
Copyright © 2011-2022 走看看