分清几个概念
 
<1>“主菜单” 和 “顶层菜单” 是一个意思。
 
<2>主菜单中的项目叫做 “弹出菜单” 或者 “子菜单”。
 
<3>弹出菜单的项目可以是另外一个弹出菜单。
 
<4>菜单的状态：启用，禁用，无效化，无效化跟前两者的区别是灰色显示文字。
 
 
 
（1）菜单消息
 
<1>WM_INITMENU
 
 
        wParam,   // handle to menu (HMENU)
        lParam    // not used
 
 
<2>WM_MENUSELECT 
 
菜单项被选中的时候
 
 
       wParam,   // menu item (UINT) and flags (UINT)
       lParam    //handle to menu (HMENU)
 
 
其中
 
 
LOWORD(wParam)		//被选中项目：菜单ID或者弹出式菜单句柄
HIWORD(wParam)		//选择旗标
 
 
旗标是MF_GRAYED、MF_DISABLED、MF_CHECKED、MF_BITMAP、MF_POPUP、MF_HELP、MF_SYSMENU和MF_MOUSESELECT的集合。
 
<3>WM_INITMENUPOPUP
 
 当下拉菜单被激活的时候就会发出这样的消息
 
 
WPARAM wParam,   // handle to menu (HMENU)
LPARAM lParam    // item position and indicator
LOWORD（lParam）代表的是菜单项索引，HIWORD（lParam）表示的是TRUE，或者FALSE，菜单是系统菜单的时候表示的TRUE，非系统菜单的时候表示的是FALSE。 
 
<4>WM_COMMAND
 
表示使用者已经从菜单中选择了一个被启用的菜单项，
 
LOWORD (wParam)：菜单命令ID
 
HIWORD(wParam)：0
 
lParam：0
 
<5>WM_MENUCHAR
 
（2）菜单项中的字母的下划线
 
把字母前面加&字符，就可以出现字母下划线的效果，当用Alt键+ 字符，可以快捷的弹出子菜单，或者执行菜单项命令。
 

 
 
 
对应属性
 


 
 
（3）菜单项的选中和去选中状态
 
 
CheckMenuItem(hMenu, iSelection, MF_UNCHECKED) ;
CheckMenuItem(hMenu, iSelection, MF_CHECKED) ;

 

 
 
（4）关于Menu的函数
 
         关于菜单的操作从大体方向上看无外乎增删改查四种操作。
 
4.1    HMENUCreateMenu(VOID);
 
4.2   BOOL AppendMenu( HMENU hMenu, // handle to menu
 
                         UINT uFlags,                            //menu-item options
 
                         UINT_PTR uIDNewItem,       // identifier, menu, or submenu
 
                         LPCTSTR lpNewItem         //menu-item content);
 
其中uFlags 可以是：
 
MF_BITMAP，MF_OWNERDRAW，MF_STRING
 
示例：
 
AppendMenu         (hMenuPopup, MF_STRING, IDM_APP_EXIT,"E&xit") ;
 
AppendMenu         (hMenu, MF_POPUP, hMenuPopup,"&File") ;
 
4.3    BOOLInsertMenu(  HMENU hMenu,          // handle to menu
 
                         UINT uPosition,       // item that new item precedes
 
                         UINT uFlags,          // options
 
                         UINT_PTR uIDNewItem,  // identifier, menu, or submenu
 
                         LPCTSTR lpNewItem     // menu item content);
 
这个函数和AppendMenu相比除了uPosition这个参数外，其余完全相同
 
uPosition：表示被插的位置索引或者菜单ID，具体是哪一个取决于uFlags中是MF_BYCOMMAND还是MF_BYPOSITION。
 
uIDNewItem：插入项是命令项的时候表示的是ID，插入项是菜单的时候表示的菜单句柄。
 
lpNewItem：    插入项的内容，具体取决于uFlags中包含的MF_BITMAP，MF_STRING，MF_OWNERDRAW
 
 
 
注意：不能放在一起的命令组合
 
MF_BYCOMMAND and MF_BYPOSITION 
MF_DISABLED, MF_ENABLED, and MF_GRAYED 
MF_BITMAP, MF_STRING, MF_OWNERDRAW, and MF_SEPARATOR 
MF_MENUBARBREAK and MF_MENUBREAK 
MF_CHECKED and MF_UNCHECKED 
 
4.4    BOOLInsertMenuItem(  HMENU hMenu,           // handle to menu
 
                UINT uItem,            // identifier or position
 
                BOOL fByPosition,      // meaning of uItem
 
                LPCMENUITEMINFO lpmii  // menu item information);
 
typedef struct tagMENUITEMINFO {
  UINT    cbSize; 
  UINT    fMask; 
  UINT    fType; 
  UINT    fState; 
  UINT    wID; 
  HMENU   hSubMenu; 
  HBITMAP hbmpChecked; 
  HBITMAP hbmpUnchecked; 
  ULONG_PTR dwItemData; 
  LPTSTR  dwTypeData; 
  UINT    cch; 
  HBITMAP hbmpItem;
} MENUITEMINFO, *LPMENUITEMINFO;
 
4.5   BOOL RemoveMenu(  HMENU hMenu,     // handle to menu
 
                UINT uPosition, // menu item identifier or position
 
                UINT uFlags     // options);
 
4.6    BOOLModifyMenu(  HMENU hMnu,           // handle to menu
 
                UINT uPosition,       // menu item to modify 
 
                   UINTuFlags,          // options
 
                UINT_PTR uIDNewItem,  // identifier, menu, or submenu
 
                 LPCTSTR lpNewItem     // menu item content);
 
4.7    BOOLDeleteMenu(  HMENU hMenu,     // handle to menu
 
                UINT uPosition,  // menu item identifier or position
 
                UINT uFlags      // option);
 
删除菜单项，如果菜单项时弹出菜单，那么就会释放菜单句柄所指向的内存。
 
4.7    BOOLDrawMenuBar(  HWND hWnd  // handle to window);
 
4.8    HMENUGetSubMenu(  HMENU hMenu,  // handle to menu
 
                         int nPos      // menu item position);
 
当菜单栏发生变化时候，必须调用这个函数重新绘制菜单//经常验证，未必
 
 
（6）右键菜单
 
右键菜单跟一般的菜单没什么区别，只是弹出的时候，需要用到这个函数
 
 
BOOLTrackPopupMenu(  HMENU hMenu,         // handle to shortcut menu
  UINT uFlags,         // options 
  int x,               // horizontal position
  int y,               // vertical position
  int nReserved,       // reserved, must be zero
  HWND hWnd,           // handle to owner window
  CONST RECT *prcRect  // ignored);
 
 
其中的uFlags参数指定了菜单中菜单中的对齐方式，左键右键选定菜单项
 
TPM_CENTERALIGN，TMP_LEFTALIGN，TMP_RIGHTALIGN
 
TPM_BOTTOMALIGN, TPM_TOPALIGN, TPM_VCENTERALIGN
 
TPM_LEFTBUTTPON,TPM_RIGHTBUTTON
 
TPM_NONOTIFY, TPM_RETURNCMD
 
（7）系统菜单
 
获取系统菜单句柄
 
HMENU GetSystemMenu(  
 
         HWNDhWnd,    // handle to window
 
       BOOL bRevert  // reset option);
 
其中bRevert = FALSE时候，表示，复制系统的菜单，并且返回复制菜单的句柄，这个菜单可以进行修改。当bRevert = TRUE 时，设置系统菜单为默认的原始状态，并且函数返回值是NULL.
 
 (8) 加速键
 
加速键也是一种资源，它可以使用快捷键迅速的打开命令项。加速键 可以在在资源中自己添加，也可以直接使用程序编写。加速键中主要的改变的code有
 
while(GetMessage(&msg,NULL,0,0))
 {
 if (!TranslateAccelerator(hWnd,hAccel,&msg))
 {
 TranslateMessage(&msg);
 DispatchMessage(&msg);
 }
 }
 
 
在这里 TranslateAccelerator函数把 一些按键消息翻译成WM_COMMAND，或者WM_SYSCOMMAND消息。
 
（9）代码示例
 
一下示例是一个完全依靠code不依赖创建资源的菜单demo，其中包含菜单栏，右键菜单，系统菜单，加速键可以对菜单进行动态的修改，删除，添加操作。
 

#define OEMRESOURCE
# include<Windows.h>

#define IDM_FILE_OPEN	100
#define IDM_FILE_NEW	101
#define IDM_FILE_PIC	102
#define IDM_FILE_EXIT	103
#define IDM_MENU_ADD	104
#define	IDM_MENU_REM	105
#define IDM_MENU_DEL	106
#define IDM_MENU_MOD	107
#define	IDM_ABOUT		108
#define IDM_VERSION		109
#define IDM_MENU_NEW	110

#define	IDM_POP_ONE		200
#define IDM_POP_TWO		201

#define IDM_SYS_ONE		300
#define IDM_SYS_TWO		301

LRESULT CALLBACK WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
HMENU	createOwnMenu(HWND hwnd);
HMENU	createPopMenu(HWND hwnd);
HACCEL	createAccelerator(HWND hwnd);
TCHAR* szAppName = TEXT("MenuClass");
TCHAR* szWndName = TEXT("ChangeMenu");
HACCEL	hAccel	 = NULL;


int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPreInstance,LPSTR lpCmdLine,int iCmdShow)
{
	WNDCLASS	wndCls;
	HWND		hWnd;
	MSG			msg;


	wndCls.cbClsExtra = 0;
	wndCls.cbWndExtra = 0;
	wndCls.lpfnWndProc = WndProc;
	wndCls.style = CS_HREDRAW | CS_VREDRAW;
	wndCls.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wndCls.hCursor = LoadCursor(NULL,IDC_ARROW);
	wndCls.hIcon = LoadIcon(NULL,IDI_APPLICATION);
	wndCls.hInstance = hInstance;
	wndCls.lpszClassName = szAppName;
	wndCls.lpszMenuName = NULL;

	if(!RegisterClass(&wndCls)) 
	{
		MessageBox(NULL,TEXT("Register window failed"),TEXT("Error"),MB_OK);
	}

	hWnd = CreateWindow(szAppName,szWndName,WS_OVERLAPPEDWINDOW,
			CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,
			NULL,NULL,hInstance,NULL);

	UpdateWindow(hWnd);
	ShowWindow(hWnd,SW_NORMAL);

	while(GetMessage(&msg,NULL,0,0))
	{
		if(!TranslateAccelerator(hWnd,hAccel,&msg))
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	static int nAdd = 1;
	HMENU hMenu,hSonMenu,hTmpMenu;
	HMENU hTrack,hSon;
	HMENU hSysMenu;
	POINT pt;

	switch(msg)
	{
	case WM_CREATE:
		hMenu = createOwnMenu(hwnd);
		SetMenu(hwnd,hMenu);
		hSysMenu = GetSystemMenu(hwnd,FALSE);
		AppendMenu(hSysMenu,MF_SEPARATOR,0,NULL);
		AppendMenu(hSysMenu,MF_STRING,IDM_SYS_ONE,TEXT("SysOne"));
		AppendMenu(hSysMenu,MF_STRING,IDM_SYS_TWO,TEXT("SysTwo"));
		hAccel = createAccelerator(hwnd);
		break;
	case WM_SYSCOMMAND:
		switch(LOWORD(wParam))
		{
		case IDM_SYS_ONE:
			MessageBox(NULL,TEXT("This is added system menu item1"),NULL,MB_OK);
			break;
		case IDM_SYS_TWO:
			MessageBox(NULL,TEXT("This is added system menu item2"),NULL,MB_OK);
			break;
		}
		break;
	case WM_COMMAND:
		hMenu = GetMenu(hwnd);
		switch(LOWORD(wParam))
		{
		case IDM_FILE_OPEN:
			MessageBox(NULL,TEXT("File Open selected"),TEXT("Test check"),MB_OK);
			break;
		case IDM_MENU_ADD:
			hTmpMenu = GetSubMenu(hMenu,2);
			AppendMenu(hTmpMenu,MF_STRING,IDM_MENU_NEW+nAdd,TEXT("New Item"));
			nAdd++;
			DrawMenuBar(hwnd);
			break;
		case IDM_MENU_REM:
			hTmpMenu = GetSubMenu(hMenu,2);
			if( nAdd >1 )
			{
				nAdd--;
				RemoveMenu(hTmpMenu,IDM_MENU_NEW+nAdd,MF_BYCOMMAND);
			}
			// 当菜单项时弹出菜单的时候，仅仅切断弹出菜单跟所属菜单的联系，但不销毁对象
			/*GetSubMenu(hTmpMenu,2);
			RemoveMenu(hTmpMenu,2,MF_BYPOSITION);*/
			DrawMenuBar(hwnd);
			break;
		case IDM_MENU_MOD:
			hTmpMenu = GetSubMenu(hMenu,2);
			ModifyMenu(hTmpMenu,0,MF_BYPOSITION,IDM_ABOUT,TEXT("Modified Item"));
			DrawMenuBar(hwnd);
			break;
		case IDM_MENU_DEL:
			hTmpMenu = GetSubMenu(hMenu,2);
			DeleteMenu(hTmpMenu,2,MF_BYPOSITION);
			DrawMenuBar(hwnd);
			break;
		}
		break;
	case WM_RBUTTONDOWN:
		hTrack	= createPopMenu(hwnd);
		hSon	= GetSubMenu(hTrack,0);
		pt.x = LOWORD(lParam);
		pt.y = HIWORD(lParam);
		ClientToScreen(hwnd,&pt);
		TrackPopupMenu(hSon,TPM_LEFTBUTTON| TPM_RIGHTALIGN,pt.x,pt.y,0,hwnd,NULL);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	}

	return DefWindowProc(hwnd,msg,wParam,lParam);
}

HMENU createOwnMenu(HWND hwnd)
{
	HMENU hMenu		= CreateMenu();
	HMENU hPopMenu	= CreateMenu();
	//MF_BYPOSIOTION,MF_BYCOMMAND is not useful here in AppendMenu
	AppendMenu(hPopMenu,MF_STRING|MF_CHECKED|MF_GRAYED,IDM_FILE_OPEN,TEXT("&Open"));
	InsertMenu(hPopMenu,0,MF_BYPOSITION|MF_STRING|MF_DISABLED,IDM_FILE_NEW,TEXT("&New"));
	
	HINSTANCE hInstance = (HINSTANCE)GetWindowLong(hwnd,GWL_HINSTANCE);
	HBITMAP hBmp = (HBITMAP)LoadImage(hInstance,TEXT("bitmap1.bmp"),IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
	AppendMenu(hPopMenu,MF_BITMAP,IDM_FILE_PIC,(LPCWSTR)hBmp);
	AppendMenu(hPopMenu,MF_SEPARATOR,NULL,NULL);
	AppendMenu(hPopMenu,MF_STRING,IDM_FILE_EXIT,TEXT("&Exit"));
	SetMenuItemBitmaps(hPopMenu,IDM_FILE_PIC,MF_BYCOMMAND,hBmp,hBmp);
	AppendMenu(hMenu,MF_POPUP,(UINT_PTR)hPopMenu,TEXT("File"));
	

	hPopMenu = CreateMenu();
	AppendMenu(hPopMenu,MF_STRING,IDM_MENU_ADD,TEXT("&Add"));
	AppendMenu(hPopMenu,MF_STRING,IDM_MENU_REM,TEXT("&Remove"));
	AppendMenu(hPopMenu,MF_STRING,IDM_MENU_MOD,TEXT("&Modify"));
	AppendMenu(hPopMenu,MF_STRING,IDM_MENU_DEL,TEXT("&Delete"));
	AppendMenu(hMenu,MF_POPUP,(UINT_PTR)hPopMenu,TEXT("Menu"));

	hPopMenu = CreateMenu();
	AppendMenu(hPopMenu,MF_STRING,IDM_ABOUT,TEXT("About"));
	AppendMenu(hPopMenu,MF_STRING,IDM_VERSION,TEXT("Version"));
	HMENU hSonMenu = CreateMenu();
	AppendMenu(hSonMenu,MF_STRING,IDM_MENU_NEW,TEXT("Son"));
	AppendMenu(hPopMenu,MF_POPUP,(UINT_PTR)hSonMenu,TEXT("Son Menu"));
	AppendMenu(hMenu,MF_POPUP,(UINT_PTR)hPopMenu,TEXT("Change"));

	return hMenu;
}

HMENU createPopMenu(HWND hwnd)
{
	HMENU hMenu = CreateMenu();
	HMENU hPop	= CreateMenu();
	AppendMenu(hPop,MF_STRING,IDM_POP_ONE,TEXT("One"));
	AppendMenu(hPop,MF_STRING,IDM_POP_TWO,TEXT("Twod"));

	AppendMenu(hMenu,MF_POPUP,(UINT_PTR)hPop,TEXT("Pop"));
	return  hMenu;

}

HACCEL	createAccelerator(HWND hwnd)
{
	ACCEL acce[2];
	acce[0].fVirt = FCONTROL | FNOINVERT | FVIRTKEY;
	acce[0].key = 'A';
	acce[0].cmd = IDM_MENU_ADD;
	acce[1].fVirt = FCONTROL | FNOINVERT | FVIRTKEY;
	acce[1].key = 'R';
	acce[1].cmd = IDM_MENU_REM;

	HACCEL hAccel = CreateAcceleratorTable(acce,2);
	return hAccel;
}

 

 
 

 

前言
 
windows窗口创建以后,往里头添加菜单就是一件很有意义的事了，菜单关联的东西有
        -它本身是一种资源，有菜单句柄HMENU需要维护
        -菜单点击会发出消息,需要知道怎么维护相关的消息处理函数
 
分类
 
>窗口顶层菜单、弹出式菜单、系统菜单
 
窗口顶层菜单
 
资源
 
窗口顶层菜单是一个窗口下的一级菜单，把它称作一个菜单栏(menu bar)更为合适，而里头的任何一项(没有下一级)可以称为
    一个菜单项(menu item),有下一级的被称为子菜单或者下拉菜单(即菜单项是一个新的菜单)
-通过函数CreateMenu我们可以创建一个窗口顶层菜单，它会返回一个HMENU的句柄,这就是这个顶层菜单的资源,这是编写程序
  创建菜单的方式,还有一种图形化创建资源文件的方式创建,这里你获得的只是一个标识,如IDR_MENU
-然后通过函数AppendMenu/DeleteMenu可以往这个资源里添加东西了,这里头可以添加的东西有菜单项(menu-item，对应一个
menu-item id),下拉菜单或子菜单(对应menu handle),这两类的添加方式会导致调用AppendMenu函数第二个第三个参数的区分.
-最后,我们可以用下面3种方式将这个菜单和对应的窗口关联起来，
    --a.使用SetMenu将HMENU和HWND进行绑定
    --b.在设计窗口类时,对应的LPCTSTR lpszMenuName填上,这里你需要用添加资源文件进行填充
        ((MAKEINTERSOURCE(IDR_MENU)).
    --c.创建窗口时,对应的HMENU hMenu填上,如果菜单是资源文件的方式添加的,可以用LoadMenu获得菜单句柄.
 
消息
 
窗口顶层菜单会产生两种消息WM_COMMAND,WM_INITMENUPOPUP,分别对应点击menu-item和弹出式菜单时产生,如果是WM_COMMAND
消息,我们可以通过菜单项的id来区分到底是那一项被点击了,而WM_INITMENUPOPUP消息，则通过菜单句柄来区分了。
 
菜单项操作函数
 
    menu-item可以通过函数CheckMenuItem    和EnableMenuItem来修改，它们分别有两种用法注意区分。
 
弹出式菜单
 
弹出式菜单无法直接和窗口挂钩，它只能选择1.加入窗口菜单。2.通过消息触发(比如右键响应).
 
资源
 
    -首先，我们可以用过函数CreatePopupMenu函数创建一个弹出式菜单。
    -然后，依旧通过AppendMenu往这个菜单里头添加东西。
    -最后，还是通过AppendMenu把它挂到窗口菜单或系统菜单下，或者通过在消息响应中调用TrackPopupMenu函数让它短暂的
        出现在客户区任何地方,再通过点击对它进行响应,注意TrackPopupMenu是个阻塞函数。
 
消息
 
    点击弹出式菜单是会产生WM_INITPOPUPMENU消息.
 
系统菜单
 
系统菜单是固定的，它无法被创建，只能获取，但是你可以修改它,基本上我们不会去改变它。
 
资源
 
    -通过GetSystemMenu可以获得系统菜单的句柄。
    -依旧通过AppendMenu/DeleteMenu可以修改里头的菜单项，有意思的是你把里面的东西删完了，你会发现这个窗口无法放大,
        缩小，移动和关闭了。
 
消息
 
    点击系统菜单会产生WM_SYSCOMMAND消息，而诸如最大化，最小化，关闭按钮其实都是系统菜单里的菜单项，所以点击关闭按钮
        其实并不会产生WM_DESTROY消息，而是产生WM_SYSCOMMAND的消息。
 
菜单消息传递的参数
 
type
wParam
lParam
note
WM_COMMAND
(HI)0 (LO)菜单项ID
NULL
windows里用的最多的消息
WM_INITMENUPOPUP
菜单句柄
菜单索引和菜单标识
无
WM_SYSCOMMAND
(LO)菜单项ID
光标位置
无

 Windows 窗体上的菜单是使用 MainMenu 对象创建的，该对象是一个 MenuItem 对象集合。可以在设计时向 Windows 窗体添加菜单，方法是添加MainMenu 组件然后使用菜单设计器向其追加菜单项。还可以用编程方法添加菜单，方法是向 Windows 窗体添加一个或多个 MainMenu 对象并向该集合中添加 MenuItem 对象。本主题中的过程说明如何使用菜单设计器或代码创建一个名为 File 的简单菜单。
 
 在设计时向 Windows 窗体添加菜单
 
在 Windows 窗体设计器中打开要将菜单添加到的窗体。
在“工具箱”中双击 MainMenu 组件。 
 一个菜单被添加到窗体中（该窗体显示文本“请在此处输入”），同时 MainMenu 组件添加到了组件栏中。
 
 
 以编程方式向 Windows 窗体添加菜单
 
在代码编辑器中，创建一个新公共方法，其中包含将菜单添加到窗体的代码。有关打开代码编辑器的更多信息，请参见在设计器中显示 Windows 窗体。 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
Public Sub AddMenu()

End Sub

// C#
public void AddMenu(){

}

// C++
public:
   void AddMenu()
   {

   }
 
     
 
    
 
   
 
  
 
在该方法内添加类似于以下内容的代码，以创建 MainMenu 组件的实例： 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
   Dim mnuFileMenu as New MainMenu()
   Me.Menu = mnuFileMenu

// C#
   MainMenu mnuFileMenu = new MainMenu();
   this.Menu = mnuFileMenu;

// C++
   MainMenu *mnuFileMenu = new MainMenu();
   this->Menu = mnuFileMenu;
 
     
 
    
 
   
 
  
 
 
 将 MainMenu 组件添加到 Windows 窗体后，需要向其添加菜单项。菜单设计器可让您在设计时向菜单组件添加菜单项。菜单内容保存在一个集合内，所以可在运行时通过向此集合添加 MenuItem 对象来向菜单添加菜单项。
 
 在设计时向菜单添加菜单项
 
单击 Windows 窗体上的 MainMenu 组件。 
 显示文本“请在此处输入”。
 
单击显示的文本，然后键入所需菜单项的名称以添加它。
若要添加另一个菜单项，请单击“菜单设计器”内的另一个“请在此处输入”区域。 
  
单击当前菜单项右侧的区域以添加子菜单。 
 - 或 -
 
单击当前菜单项下方的区域，以便将另一个项添加到同一菜单中。
 
 
 以编程方式向菜单添加菜单项
 
如果还没有 MainMenu 组件，则向公共方法内的 Windows 窗体添加一个 MainMenu 组件，并将一个 MainMenu 类的实例分配给该窗体的Menu 属性。有关集合的更多信息，请参见对象之间的关系。 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
Public Sub AddMenuAndItems()
   Dim mnuFileMenu as New MainMenu()
   Me.Menu = mnuFileMenu
End Sub

// C#
public void AddMenuAndItems(){
   MainMenu mnuFileMenu = new MainMenu();
   this.Menu = mnuFileMenu;
}

// C++
public:
   void AddMenu()
   {
      MainMenu *mnuFileMenu = new MainMenu();
      this->Menu = mnuFileMenu;
   }
 
     
 
    
 
   
 
  
 
在该方法内，创建要添加到 MainMenu 对象的集合中的 MenuItem 对象： 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
   Dim myMenuItemFile as New MenuItem("&File")
   Dim myMenuItemNew as New MenuItem("&New")

// C#
   MenuItem myMenuItemFile = new MenuItem("&File");
   MenuItem myMenuItemNew = new MenuItem("&New");

// C++
   MenuItem *myMenuItemFile = new MenuItem(S"&File");
   MenuItem *myMenuItemNew = new MenuItem(S"&New");
 
     
 
    
 
   
 
  
 
  

   注意   默认情况下，
   MainMenu 对象不包含菜单项，所以添加的第一个菜单项成为菜单标题。这就是 
   myMenuItemFile 的 
   Text属性设置为 
   &File 的原因。
  
 
在该方法内，分配顶级菜单项并向其添加后面的菜单项： 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
   mnuFileMenu.MenuItems.Add(myMenuItemFile)
   myMenuItemFile.MenuItems.Add(myMenuItemNew)

// C#
   mnuFileMenu.MenuItems.Add(myMenuItemFile);
   myMenuItemFile.MenuItems.Add(myMenuItemNew);

// C++
   mnuFileMenu->MenuItems->Add(myMenuItemFile);
   myMenuItemFile->MenuItems->Add(myMenuItemNew);
 
     
 
    
 
   
 
  
 
  

   注意   若要创建子菜单，可将 
   MenuItem 对象添加到父 
   MenuItem 的 
   MenuItems 属性中。对于上面的示例，如果希望将第三个菜单项 (
   myMenuItemFolder) 作为第二个菜单项 (
   myMenuItemNew) 的子菜单添加，则应包括下列代码行：
  
 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
Dim myMenuItemFolder as New MenuItem("&Folder")
myMenuItemNew.MenuItems.Add(myMenuItemFolder)

// C#
MenuItem myMenuItemFolder = new MenuItem("&Folder");
myMenuItemNew.MenuItems.Add(myMenuItemFolder);

// C++
MenuItem *myMenuItemFolder = new MenuItem(S"&Folder");
myMenuItemNew->MenuItems->Add(myMenuItemFolder);
 
     
 
    
 
   
 
  
 
 菜单项也可在创建时动态添加，属性也是这样，可在创建和添加菜单项时设置。例如，若要向上面的集合中添加第四个菜单项，请输入下列代码：
 
  
 
   
 
   
 
   
 
    
 
     
 
     
 
    
 
    
 
     
 
      
' Visual Basic
mnuFileMenu.MenuItems.Add("Save &As")

// C#
mnuFileMenu.MenuItems.Add("Save &As");

// C++
mnuFileMenu->MenuItems->Add("Save &As");
 
     
 
    
 
   
 
  
 
 
 有关向 MenuItems 集合中添加菜单项时动态创建菜单项的更多信息，请参见 Menu.MenuItemCollection 类。
 
 向菜单项添加功能
 
 最后，建立菜单结构后，需要为菜单项提供功能。通常需要通过 MenuItem.Click 事件的事件处理程序做到这一点。有关事件处理程序的更多信息，请参见 Windows 窗体中事件处理程序的介绍。

 
 
好久没有学windows编程了，今天计算机图形学作业用到了mfc，发现各种不适应。好了，不吐槽了，come on baby!
 
 
1. 首先新建当文档程序，并命名为Demo1，如图：
 
 
一路next。。，注意点如图：
 
 
2. 接下来添加菜单项
 
操作过程：首先找到资源视图(Resourse),然后点击IDR_MAINFRAME,好了，我们熟悉的基于对话框的菜单添加也是这个鬼东西。
 
 
3. 接下来我们就可以添加我们需要添加的菜单了，然后点击右键->属性，给这个菜单添加一个ID值，因为windows系统会把给个菜单的事件添加到消息队列中，这个才能知道是我们点击了这个菜单而不是别的（ID值随意，你开心就好，不过最好规范些，简明思议）
 
 
 
4. 上面只是添加了一下傀儡的东西，接下来我们需要添加程序的灵魂，即响应事件。
 
首先找到class视图，如图： 
 
 
 
 点击确定按钮，然后在BEGIN_MESSAGE_MAP宏中添加一个新项如下：
 
并在最后会给我们生成一个函数，然后我们就可以在这里添加我们想要处理的事件了。
 
 
点击我们新添加的菜单就可以起作用了，开心吧，嘻嘻