<2017年12月>
日一二三四五六
262728293012
3456789
10111213141516
17181920212223
24252627282930
31123456

跟我一起玩Win32开发（4）：创建菜单

也不知道发生什么事情，CSDN把我的文章弄到首页，结果有不少说我在误人子弟，是啊，我去年就说过了，如果你要成为砖家级人物，请远离我的博客，我这个人没什么特长，唯一厉害的一点就是不相信权威，鄙视砖家，所以，我一直以来都有属于俺自己的编程思想。

就好比当年咏春拳刚浮出江湖的时候，武学界骂声不停，有人说：“这哪像拳？分明是女人拳。”然后不知道什么时候，一位叫叶问的大侠突然牛B起来了，于是，咏春拳的传播速度比其他拳种更快，都传到老外那里去了。

所以，为了继续误人子弟，我决定把这些文章写下去，直到误尽天下苍生为止。

我们当然知道，现在，在实际开发中肯定不会像我这样写Win32程序的，你看，连个WinMain都要N行代码。但很多人不明白什么叫学习，什么叫探索。实际上，通常能用于实际开发中的技巧只是占我们对客观世界的认识总和不到20%，所以，如果你有兴趣计算一下，估计有80%的知识你不知道用到哪里去了。就算我们今后不会把Win32程序投入到实际操作中，然而如果你了解过这东西，你会发现很多时候对我们是有帮助的。

哪怕只是简单认识一下Win32的一些原理，相信对于日后编程的学习和成长，是有益处的。

 

为了提高误人子弟的效果，上面我说了几段F话，下面开始今天的正题。

要在窗口上添加菜单，当然你可能会研究出N种方法，不过，这里我说两种，一种相当复杂，另一种稍微简单。

 

方法一，用代码添加菜单

 

这种方法的思路是：首先在全局范围内定义一个HMENU的变量，用来保存窗口中菜单栏的句柄，根菜单（菜单栏）可以CreateMenu函数来创建，接着可以使用AppendMenu函数或者InsertMenuItem函数来创建菜单项。

句柄就是内存中各种资源的ID，比如图标，图片，字符串等。我们的菜单也是一种资源。

 

下面我写了一个函数，用来动态创建菜单。

[cpp] view plain copy
 
  1. void CreateMyMenu()  
  2. {  
  3.     hRoot = CreateMenu();  
  4.     if(!hRoot)  
  5.         return;  
  6.     HMENU pop1 = CreatePopupMenu();  
  7.     AppendMenu(hRoot,  
  8.         MF_POPUP,  
  9.         (UINT_PTR)pop1,  
  10.         L"操作");  
  11.     // 一种方法是使用AppendMenu函数  
  12.     AppendMenu(pop1,  
  13.         MF_STRING,  
  14.         IDM_OPT1,  
  15.         L"飞机");  
  16.   
  17.     // 另一种方法是使用InsertMenuItem函数  
  18.     MENUITEMINFO mif;  
  19.     mif.cbSize = sizeof(MENUITEMINFO);  
  20.     mif.cch = 100;  
  21.     mif.dwItemData  = NULL;  
  22.     mif.dwTypeData = L"机关枪";  
  23.     mif.fMask = MIIM_ID | MIIM_STRING | MIIM_STATE;  
  24.     mif.fState = MFS_ENABLED;  
  25.     mif.fType = MIIM_STRING;  
  26.     mif.wID = IDM_OPT2;  
  27.   
  28.     InsertMenuItem(pop1,IDM_OPT2,FALSE,&mif);  
  29.   
  30. }  


hRoot是在外部定义的全局变量，保存菜单栏的标识。完整的代码如下：

[cpp] view plain copy
 
  1. #include <Windows.h>  
  2.   
  3. #define IDM_OPT1     301  
  4. #define IDM_OPT2     302  
  5.   
  6. HMENU hRoot;  
  7. void CreateMyMenu();//创建菜单  
  8.   
  9. LRESULT CALLBACK MyWinProce(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);  
  10.   
  11.   
  12. int CALLBACK WinMain(HINSTANCE hInstance,  
  13.                     HINSTANCE hPrevInstance,  
  14.                     LPSTR cmdLine,  
  15.                     int nShow)  
  16. {  
  17.     CreateMyMenu();//创建菜单  
  18.     WCHAR* cn = L"Myapp";  
  19.     WNDCLASS wc={   };  
  20.     wc.hbrBackground = (HBRUSH)COLOR_WINDOW;  
  21.     wc.lpszClassName = cn;  
  22.     wc.style = CS_HREDRAW | CS_VREDRAW;  
  23.     wc.hInstance = hInstance;  
  24.     wc.lpfnWndProc = (WNDPROC)MyWinProce;  
  25.     RegisterClass(&wc);  
  26.     HWND hm = CreateWindow(cn,  
  27.         L"我的应用程序",  
  28.         WS_OVERLAPPEDWINDOW,  
  29.         20,  
  30.         15,  
  31.         420,  
  32.         360,  
  33.         NULL,  
  34.         hRoot,  
  35.         hInstance,  
  36.         NULL);  
  37.     if( hm == NULL )  
  38.         return 0;  
  39.     ShowWindow(hm,nShow);  
  40.     MSG msg;  
  41.     while(GetMessage(&msg,NULL,0,0))  
  42.     {  
  43.         TranslateMessage(&msg);  
  44.         DispatchMessage(&msg);  
  45.     }  
  46.   
  47.     return 0;  
  48. }  
  49.   
  50.   
  51. LRESULT CALLBACK MyWinProce(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)  
  52. {  
  53.     switch(msg)  
  54.     {  
  55.     case WM_DESTROY:  
  56.         //DestroyMenu(hRoot);  
  57.         PostQuitMessage(0);  
  58.         return 0;  
  59.     default:  
  60.         return DefWindowProc(hwnd, msg, wParam,lParam);  
  61.     }  
  62. }  
  63.   
  64. void CreateMyMenu()  
  65. {  
  66.     hRoot = CreateMenu();  
  67.     if(!hRoot)  
  68.         return;  
  69.     HMENU pop1 = CreatePopupMenu();  
  70.     AppendMenu(hRoot,  
  71.         MF_POPUP,  
  72.         (UINT_PTR)pop1,  
  73.         L"操作");  
  74.     // 一种方法是使用AppendMenu函数  
  75.     AppendMenu(pop1,  
  76.         MF_STRING,  
  77.         IDM_OPT1,  
  78.         L"飞机");  
  79.   
  80.     // 另一种方法是使用InsertMenuItem函数  
  81.     MENUITEMINFO mif;  
  82.     mif.cbSize = sizeof(MENUITEMINFO);  
  83.     mif.cch = 100;  
  84.     mif.dwItemData  = NULL;  
  85.     mif.dwTypeData = L"机关枪";  
  86.     mif.fMask = MIIM_ID | MIIM_STRING | MIIM_STATE;  
  87.     mif.fState = MFS_ENABLED;  
  88.     mif.fType = MIIM_STRING;  
  89.     mif.wID = IDM_OPT2;  
  90.   
  91.     InsertMenuItem(pop1,IDM_OPT2,FALSE,&mif);  
  92.   
  93. }  


 

 

方法二，通过编辑资源来添加菜单

上面的方法虽然创建了菜单，但你也看到了，是相当地不方便，所以，下面我重点介绍一下用资源编辑器来创建菜单资源。

在你的开发工具上，依次找到菜单项【视图】【资源视图】。

 

在资源视图中，右击项目根节点，从弹出的菜单中选择【添加】【资源】。

 

在随后弹出的对话框中，选择Menu，单击右边的“新建”按钮。

 

可以通过属性窗口来重命名菜单的ID。

 

我们可以使用可视化视图来建立菜单，为了可以在代码中使用，给需要的菜单一个ID，这个名字你可以自己喜欢，只是惯用的是以IDM_开头，意思是Menu ID，比如IDC开头的，意思是Control ID等等。

 

 编辑好之后，保存，在【解决方案资源管理器】中你会看到一个resource.h文件，其实我们为资源定义的ID都以宏的形式声明的，不信你打开看看。

 

资源ID都是数字，只是为它定义个名字，方便识别罢了，就好像人们平时只叫你的名字或者小名，你见过谁会叫你的身份证号码的？

开发工具生成的ID有时候会有问题，或者有些ID我们在程序中没用上，如果你觉得它们留在代码文件中会影响市容的话，你可以这样：

1、在【资源视图】窗口中，右击，从弹出的快捷菜单中选择【资源符号...】，弹出一个窗口，这里可以看到应用程序中的资源ID列表，以及哪些ID已被使用，但是，这个窗口中显示的内容，有时候不准确，有些ID明明没有被使用，它右边却打上了勾。

这里可以修改ID的值，也可以新建资源ID，所以，你也可以在这里预先为资源分配ID，然后在属性窗口设置资源的标识时，从下拉列表中选择指定的ID。资源ID的名字和数值不能重复，但是，不同的资源是可以使用同一个资源ID的。例如，通常在应用程序中，某些菜单项的功能和工具栏上的按钮是一一对应的，功能相同，这种情况下，我们可以考虑让它们共用一个ID。

2、你可以直接打开resource.h头文件，直接在上面修改。

 

 

响应菜单命令

当用户单击某个菜单项后，窗口处理程序（WindowProc）会收到一条WM_COMMAND消息，它的两个附加参数如下：

在收到WM_COMMAND后，我们可以用LOWORD取得它的低数位，上表中已经说明，wParam的低位值表示菜单的资源ID，我们通过它的值与哪个菜单的ID相等，就知道用户点击了哪个菜单项。

所以，我们的程序代码现在应为：

[cpp] view plain copy
 
  1. #include <Windows.h>  
  2. #include "resource.h"  
  3.   
  4. LRESULT CALLBACK MyWinProce(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);  
  5.   
  6.   
  7. int CALLBACK WinMain(HINSTANCE hInstance,  
  8.                     HINSTANCE hPrevInstance,  
  9.                     LPSTR cmdLine,  
  10.                     int nShow)  
  11. {  
  12.     WCHAR* cn = L"Myapp";  
  13.     WNDCLASS wc={   };  
  14.     wc.hbrBackground = (HBRUSH)COLOR_WINDOW;  
  15.     wc.lpszClassName = cn;  
  16.     wc.style = CS_HREDRAW | CS_VREDRAW;  
  17.     wc.hInstance = hInstance;  
  18.     wc.lpfnWndProc = (WNDPROC)MyWinProce;  
  19.     RegisterClass(&wc);  
  20.     HWND hm = CreateWindow(cn,  
  21.         L"我的应用程序",  
  22.         WS_OVERLAPPEDWINDOW,  
  23.         20,  
  24.         15,  
  25.         420,  
  26.         360,  
  27.         NULL,  
  28.         // 加载菜单资源  
  29.         LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MAIN)),  
  30.         hInstance,  
  31.         NULL);  
  32.     if( hm == NULL )  
  33.         return 0;  
  34.     ShowWindow(hm,nShow);  
  35.     MSG msg;  
  36.     while(GetMessage(&msg,NULL,0,0))  
  37.     {  
  38.         TranslateMessage(&msg);  
  39.         DispatchMessage(&msg);  
  40.     }  
  41.   
  42.     return 0;  
  43. }  
  44.   
  45.   
  46. LRESULT CALLBACK MyWinProce(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)  
  47. {  
  48.     switch(msg)  
  49.     {  
  50.     case WM_COMMAND:  
  51.         {  
  52.             // 取出资源Id值  
  53.             // 并判断用户选择了哪个菜单项  
  54.             switch(LOWORD(wParam))  
  55.             {  
  56.             case IDM_PLANE:  
  57.                 MessageBox(hwnd,L"灰机来了。",L"提示",MB_OK);  
  58.                 break;  
  59.             case IDM_GUN:  
  60.                 MessageBox(hwnd,L"让炮弹飞。",L"提示",MB_OK);  
  61.                 break;  
  62.             case IDM_MT_GUN:  
  63.                 MessageBox(hwnd,L"山炮欲来风满楼。",L"提示",MB_OK);  
  64.                 break;  
  65.             default:  
  66.                 break;  
  67.             }  
  68.         }  
  69.         return 0;  
  70.     case WM_DESTROY:  
  71.         PostQuitMessage(0);  
  72.         return 0;  
  73.     default:  
  74.         return DefWindowProc(hwnd, msg, wParam,lParam);  
  75.     }  
  76. }  

在注册窗口类时，如要设置菜单，调用LoadMenu函数，第一个参数是当前程序实例的句柄，从WinMain的参数中获得，第二个参数是菜单的ID，因为这里要名字，字符串，而我们的ID都是数值，可通过MAKEINTRESOURCE宏转换。至于MessageBox函数就不用我介绍了。

 

好了，我们的应用程序已经创建了菜单了。

 

呵，有人说我的编程学习方法很奇特，其实，我们何苦要墨守成规呢，局限在定势思维中呢？枯躁无味的东西，你可以人为地让它变得充满乐趣，关键是你的心态罢了。这让我想起，以前某同学A跟我讨论两个问题：

1、我的程序只想保存用户的一些使用设置，用数据库没必要，写注册不环保；

2、我有一个dll类库，我希望最后我的程序既可以引用它，但同时只生成一个exe文件，能做到吧。

 

我就说了，问题一好办，你定义一个存放设置项的类，把它直接进行XML序列化和反序列化就完事了，这既能保存数据，又可以封装对象。如果不想让别人看到XML文件中的内容，就把它用DES算法加密/解密；而第二个问题，你把dll文件当成资源嵌入到程序的资源文件中，运行时如果要用到类库的类，那就把它反射出来，动态调用就行了。

然后他说，这好像没有人这样做，老师也没教过。

我说：靠，你老爸小时候教过你泡妞吗？你一上大学怎么就学会了泡妞？四年大学还换了N个妞，我一个都没换成，你的爱情事业如此成功。再说了，吕不韦临死前有教过秦始皇怎么统一中华吗？难道秦始皇会说：以前没人统一过华夏，我怎么统一？最后他老人家还是把六国给干掉了。

 

posted @ 2018-03-31 13:48  史D芬周  阅读(2500)  评论(0)  编辑  收藏  举报