�������� Linux Tags

19. �����ļ�����

�����ļ����棨MDI����Microsoft Windows�ļ�����Ӧ�ó�ʽ��һ�ֹ淶���ù淶�������Ӵ��ṹ������ʹ�����ڵ���Ӧ�ó�ʽ��ʹ�ö���ļ���ʹ���߽��棨�����鴦����ʽ�е������ļ����������ʽ�е�����������򵥵�˵������Windows��һ��өĻ��ά�����Ӧ�ó�ʽ�Ӵ�һ����MDIӦ�ó�ʽ��һ����ʾ������ά������ļ��Ӵ���Windows�еĵ�һ��MDIӦ�ó�ʽ��Windows�µ�Microsoft Excel�ĵ�һ���汾���������ֳ���������������Ӧ�ó�ʽ��


MDI����
��

����MDI�淶����Windows 2.0���Ƴ��Ѿ����ռ���������ʱ��MDIӦ�ó�ʽд���������ѣ�������ҪһЩ�dz����ӵij�ʽ��ƹ�������Windows 3.0���������๤���Ͷ���WindowsΪ�������ˡ�Windows 95����ǿ��֧ԮҲ�Ѿ������ӽ�Windows 98��Microsoft Windows NT�С�

MDI�����
��

MDI��ʽ����Ӧ�ó�ʽ�Ӵ��Ǻ���ͨ�ģ�����һ�������С�һ�����ܱ���һ�����ű߿�һ��ϵͳ���ܱ�ͼʾ�����/��С��/�رհ�ť����ʾ���򾭳�����Ϊ�������ռ䡹������ֱ�������ʾ��ʽ�������������ռ��������������Ӵ���ÿ���Ӵ�����ʾһ���ļ���

��Щ���Ӵ���������ͨ����Ӧ�ó�ʽ�Ӵ��Լ�MDI��ʽ�����Ӵ������ơ�������һ�������С�һ�����ű߿�һ��ϵͳ���ܱ�ͼʾ�����/��С��/�رհ�ť�����ܻ����������С������ļ��Ӵ�û�й��ܱ�����Ӧ�ó�ʽ�Ӵ��ϵĹ��ܱ�������ļ��Ӵ���

���κ�ʱ��ֻ����һ���ļ��Ӵ��ǻ�ģ���������������ʾ���������������������ļ��Ӵ�֮ǰ�������ļ��Ӵ����ɹ����ռ�������Լ��ã������������Ӧ�ó�ʽ�Ӵ�֮�⡣

������������Windows��ʽд������˵��MDI�ƺ����൱�򵥡���Ҫ��ʽд�������Ĺ����������Ϊÿ���ļ�����һ��WS_CHILD�Ӵ�����ʹ��ʽ����Ӧ�ó�ʽ�Ӵ���Ϊ�ļ��Ӵ��ĸ��Ӵ����������е�MDIӦ�ó�ʽ�Լ��о����ͻᷢ��һЩ���³�ʽд�����ѵĸ������⡣���磺

  • MDI�ļ��Ӵ�������С��������ͼʾ�����ڹ����ռ�ĵײ���һ����˵��MDIӦ�ó�ʽ���Խ���ͬ��ͼʾ�ֱ������Ӧ�ó�ʽ�Ӵ���ÿһ���ļ�Ӧ�á�
    ��
  • MDI�ļ��Ӵ�������󻯡�����������£��ļ��Ӵ��ı����У�һ��������ʾ�Ӵ����ļ��ĵ������ƣ���ʧ���������Ƴ�����Ӧ�ó�ʽ�Ӵ������е�Ӧ�ó�ʽ����֮�ᣬ�ļ��Ӵ���ϵͳ���ܱ�ͼʾ��ΪӦ�ó�ʽ�Ӵ��Ķ��㹦�ܱ��еĵ�һ��ر��ļ��Ӵ���ť��ɶ��㹦�ܱ��е�����һ��ҳ��������ұߡ�
    ��
  • ���Թر��ļ��Ӵ���ϵͳ���̼��ټ���ر����Ӵ���ϵͳ���̼��ټ�һ����ֻ��Ctrl��������Alt������Ҳ����˵��Alt+F4��춹ر�Ӧ�ó�ʽ�Ӵ�����Ctrl+F4��춹ر��ļ��Ӵ������⣬Ctrl+F6�����ڻMDIӦ�ó�ʽ�����ļ��Ӵ�֮���л�����ƽʱһ����Alt+�հ׼��������Ӵ���ϵͳ���ܱ���Alt+-�����ţ���������ļ��Ӵ���ϵͳ���ܱ���
    ��
  • ��ʹ���α���ڹ��ܱ�����ƶ�ʱ��������Ȩͨ����ϵͳ���ܱ�ת�����ܱ����еĵ�һ���MDIӦ�ó�ʽ�У�������Ȩ�Ǵ�Ӧ�ó�ʽϵͳ���ܱ�ת����ļ�ϵͳ���ܱ���Ȼ����ת�����ܱ����еĵ�һ�
    ��
  • ���Ӧ�ó�ʽ�ܹ�֧Ԯ��������̬�����Ӵ�����Microsoft Excel�еĹ�������ͼ���ļ�������ô���ܱ�Ӧ�ܷ�ӳ����������̬���ļ��йصIJ��������Ҫ�󵱲�ͬ�������Ӵ���ɻ�Ӵ�ʱ����ʽ�ܸ������ܱ������⣬��û���ļ��Ӵ�����ʱ�����ܱ�Ӧ�ñ�������ֻʣ��������ļ��йصIJ�����
    ��
  • ���㹦�ܱ�����һ���������Ӵ���Window�����Ĺ��ܱ������ϰ�ߣ����Ƕ��㹦�ܱ��ϡ�Help��֮ǰ����һ��������ڶ�����Ӵ����ӹ��ܱ���ͨ�������ڹ����ռ��ڰ����ļ��Ӵ���ѡ��ļ��Ӵ����Դ����Ϸ���ʼ��ƽ�̡��ò¡¸²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ç°Ò»ï¿½Ö·ï¿½Ê½ï¿½Â£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ø¿ï¿½ï¿½ï¿½Ã¿Ò»ï¿½ï¿½ï¿½Ä¼ï¿½ï¿½Ó´ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó¹ï¿½ï¿½Ü±ï¿½Í¬Ê±Ò²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ä¼ï¿½ï¿½Ó´ï¿½ï¿½ï¿½ï¿½Ð±ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ñ¡ï¿½ï¿½Ò»ï¿½ï¿½ï¿½Ä¼ï¿½ï¿½Ó´ï¿½ï¿½ï¿½ï¿½Í¿ï¿½ï¿½Ô°Ñ´ï¿½ï¿½Ä¼ï¿½ï¿½Ó´ï¿½ï¿½Æµï¿½Ç°ï¿½ï¿½ï¿½ï¿½
    ��

Windows 98֧ԮMDI��������Щ���档��Ȼ����Ҫ����һЩ������������ķ�����ʽ��ʾ�������ǣ���Զ����Ҫ����ʽд����ֱ��֧Ԯ������Щ���ܡ�

MDIÖ§Ô®
��

̽��Windows��MDI֧Ԯʱ��Ҫ����һЩ�������Ӧ�ó�ʽ�Ӵ���Ϊ������Ӵ���������ͳ��Windows��ʽһ��������WS_OVERLAPPEDWINDOW��ʽ���Ӵ���

MDIӦ�ó�ʽ������Ԥ�ȶ�����Ӵ����MDICLIENT�������ͻ��Ӵ�������һ�ͻ��Ӵ����������Ӵ�����WS_CHILD��ʽ����CreateWindow�������ġ���һ���е�����һ��������ָ��һ��CLIENTCREATESTRUCT��̬�Ľṹ��ָ�ꡣ����ͻ��Ӵ����ǿ���Ӵ�����ʾ���򣬲��ṩ����MDI֧Ԯ���˿ͻ��Ӵ�����ɫ��ϵͳ��ɫCOLOR_APPWORKSPACE��

�ļ��Ӵ�����Ϊ�����Ӵ�����ͨ����ʼ��һ��MDICREATESTRUCT��̬�Ľṹ����һ��ָ��˽ṹ��ָ��Ϊ������ѶϢWM_MDICREATE���͸��ͻ��Ӵ����Ϳ��Խ�����Щ�ļ��Ӵ���

�ļ��Ӵ��ǿͻ��Ӵ������Ӵ������ͻ��Ӵ����ǿ���Ӵ������Ӵ�����-���Ӵ��ֲ�ṹ��ͼ19-1��ʾ��


��

ͼ19-1 Windows MDIӦ�ó�ʽ�ĸ�-�Ӳ��ͼ

����Ҫ����Ӵ����Ӵ���𣨼��Ӵ�ѶϢ������ʽ����һ����Ӧ�ó�ʽ֧Ԯ��ÿ�����Ӵ����Ӵ���𣨼��Ӵ�ѶϢ������ʽ��������Ѿ�Ԥ��ע�����Ӵ�������Բ���Ҫ�ͻ��Ӵ����Ӵ�ѶϢ������ʽ��

Windows 98��MDI֧Ԯ����һ���Ӵ���������ʽ���������Ͻṹ��12��ѶϢ��ǰ���Ѿ��ᵽ��MDI�Ӵ���𣬼�MDICLIENT���Լ����ϽṹCLIENTCREATESTRUCT��MDICREATESTRUCT����MDIӦ�ó�ʽ�У��������ʽ�е��������ȡ��DefWindowProc�����ٽ�DefWindowProc�����������δ������ѶϢ�������ɿ���Ӵ��������DefFrameProc�����Ӵ��������DefMDIChildProc����һ��MDI���еĺ�ʽTranslateMDISysAccel���ʮ�������۵�TranslateAccelerator��ʹ�÷�ʽ��ͬ��MDI֧ԮҲ����ArrangeIconicWindows��ʽ������һ��ר�õ�MDIѶϢʹ�ô˺�ʽ��MDI��ʽ��˵���ٱ�Ҫ��

�����MDI��ʽ��CreateMDIWindow����ʹ�����Ӵ������ڵ�����ִ�����б������������ʽ����Ҫ�ڵ�ִ�����ij�ʽ�У��һ�չʾ��һ�㡣

������ij�ʽ�У��ҽ�չʾ12��MDIѶϢ�е�9������������ѶϢһ�㲻�ã�����ЩѶϢ��������WM_MDI������Ӵ���ͻ��Ӵ���������ij��ѶϢ���Ա������Ӵ������һ���������ȡ�ù�����Ӵ�����Ѷ�����磬����Ӵ�����һ��WM_MDICREATEѶϢ���ͻ��Ӵ����Խ������Ӵ�����ѶϢWM_MDIACTIVATEѶϢ�е��ر𣺿���Ӵ����Է������ѶϢ���ͻ��Ӵ�������һ�����Ӵ������ͻ��Ӵ�Ҳ�����ѶϢ���͸�������������ʧȥ������Ӵ����Ա�֪ͨ������һ�仯��

MDI�ķ�����ʽ
��

��ʽ19-1 MDIDEMO��ʽ˵���˱�дMDIӦ�ó�ʽ�Ļ���������

 ï¿½ï¿½Ê½19-1  MDIDEMO
MDIDEMO.C
/*---------------------------------------------------------------------------
   	MDIDEMO.C -- Multiple-Document Interface Demonstration
                						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

#define INIT_MENU_POS    			0
#define HELLO_MENU_POS   		    2
#define RECT_MENU_POS    			1

#define IDM_FIRSTCHILD   		50000

LRESULT 	CALLBACK FrameWndProc  			(HWND, UINT, WPARAM, LPARAM) ;
BOOL    		CALLBACK CloseEnumProc 		(HWND, LPARAM) ;
LRESULT 	CALLBACK HelloWndProc  			(HWND, UINT, WPARAM, LPARAM) ;
LRESULT 	CALLBACK RectWndProc   			(HWND, UINT, WPARAM, LPARAM) ;

     	// structure for storing data unique to each Hello child window

typedef struct tagHELLODATA
{
     	UINT     			iColor ;
     	COLORREF 		clrText ;
}
HELLODATA, * PHELLODATA ;
     	// structure for storing data unique to each Rect child window
typedef struct tagRECTDATA
{
     	short 		cxClient ;
     	short 		cyClient ;
}
RECTDATA, * PRECTDATA ;
     	// global variables
TCHAR     				szAppName[]    		= TEXT ("MDIDemo") ;
TCHAR     				szFrameClass[] 		= TEXT ("MdiFrame") ;
TCHAR     				szHelloClass[] 		= TEXT ("MdiHelloChild") ;
TCHAR     				szRectClass[]  		= TEXT ("MdiRectChild") ;
HINSTANCE 		hInst ;
HMENU     				hMenuInit, hMenuHello, hMenuRect ;
HMENU     				hMenuInitWindow, hMenuHelloWindow, hMenuRectWindow ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HACCEL   			hAccel ;
     	HWND     				hwndFrame, hwndClient ;
     	MSG      				msg ;
     	WNDCLASS 			wndclass ;
     
     	hInst = hInstance ;
          			// Register the frame window class
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= FrameWndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) (COLOR_APPWORKSPACE + 1) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szFrameClass ;
     
     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      								szAppName, MB_ICONERROR) ;
         			return 0 ;
 	}
        
          			// Register the Hello child window class
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= HelloWndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= sizeof (HANDLE) ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szHelloClass ;
          
     	RegisterClass (&wndclass) ;
          			// Register the Rect child window class
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= RectWndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= sizeof (HANDLE) ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szRectClass ;
          
     	RegisterClass (&wndclass) ;
          			// Obtain handles to three possible menus & submenus
     	hMenuInit  		= LoadMenu 	(hInstance, TEXT ("MdiMenuInit")) ;
     	hMenuHello 		= LoadMenu 	(hInstance, TEXT ("MdiMenuHello")) ;
     	hMenuRect  		= LoadMenu 	(hInstance, TEXT ("MdiMenuRect")) ;
     
     	hMenuInitWindow  		= GetSubMenu 	(hMenuInit,   INIT_MENU_POS) 	;
     	hMenuHelloWindow 		= GetSubMenu 	(hMenuHello, HELLO_MENU_POS) 	;
     	hMenuRectWindow  		= GetSubMenu 	(hMenuRect,   RECT_MENU_POS) 	;

          			// Load accelerator table
     
     	hAccel = LoadAccelerators (hInstance, szAppName) ;
          			// Create the frame window
     	hwndFrame 	= CreateWindow (szFrameClass, TEXT ("MDI Demonstration"),
                      WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                      CW_USEDEFAULT, CW_USEDEFAULT,
                      CW_USEDEFAULT, CW_USEDEFAULT,
                      NULL, hMenuInit, hInstance, NULL) ;
     	hwndClient = GetWindow (hwndFrame, GW_CHILD) ;
     	ShowWindow (hwndFrame, iCmdShow) ;
     	UpdateWindow (hwndFrame) ;
     
          			// Enter the modified message loop
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		if (	!TranslateMDISysAccel (hwndClient, &msg) &&
              				!TranslateAccelerator (hwndFrame, hAccel, &msg))
          			{
               				TranslateMessage (&msg) ;
               				DispatchMessage (&msg) ;
          			}
     	}
          			// Clean up by deleting unattached menus
     	DestroyMenu (hMenuHello) ;
     	DestroyMenu (hMenuRect) ;
     
     	return msg.wParam ;
     	}
     
LRESULT CALLBACK FrameWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HWND        		hwndClient ;
     	CLIENTCREATESTRUCT 		clientcreate ;
     	HWND               		hwndChild ;
     	MDICREATESTRUCT    		mdicreate ;
          
     	switch (message)
     	{
     	case 	WM_CREATE:           				// Create the client window
          
        clientcreate.hWindowMenu  		= hMenuInitWindow ;
  		clientcreate.idFirstChild 		= IDM_FIRSTCHILD ;
          
        hwndClient = CreateWindow	(	TEXT ("MDICLIENT"), NULL,
                                     	WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,   
                                     	0, 0, 0, 0, hwnd, (HMENU) 1, hInst,
                                     	(PSTR) &clientcreate) ;
      			return 0 ;
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_NEWHELLO:  // Create a Hello child window
                            mdicreate.szClass 		= szHelloClass ;
               				mdicreate.szTitle 		= TEXT ("Hello") ;
               				mdicreate.hOwner  		= hInst ;
               				mdicreate.x       				= CW_USEDEFAULT ;
               				mdicreate.y       				= CW_USEDEFAULT ;
               				mdicreate.cx      			= CW_USEDEFAULT ;
               				mdicreate.cy      			= CW_USEDEFAULT ;
               				mdicreate.style   		= 0 ;
               				mdicreate.lParam  		= 0 ;
               
               	hwndChild = (HWND) SendMessage (hwndClient,
                WM_MDICREATE, 0, (LPARAM) (LPMDICREATESTRUCT) &mdicreate) ;
               	return 0 ;
               
          			case 	IDM_FILE_NEWRECT:  	// Create a Rect child window
               
               		mdicreate.szClass 		    = szRectClass ;
               		mdicreate.szTitle 		    = TEXT ("Rectangles") ;
               		mdicreate.hOwner  		    = hInst ;
               		mdicreate.x       			= CW_USEDEFAULT ;
               		mdicreate.y       			= CW_USEDEFAULT ;
               		mdicreate.cx      			= CW_USEDEFAULT ;
               		mdicreate.cy      			= CW_USEDEFAULT ;
               		mdicreate.style   		    = 0 ;
               		mdicreate.lParam  		    = 0 ;
               
               		hwndChild = (HWND) SendMessage (hwndClient,
                              	WM_MDICREATE, 0,
                                (LPARAM) (LPMDICREATESTRUCT) &mdicreate) ;
               					return 0 ;
               
          			case 	IDM_FILE_CLOSE:   	// Close the active window
               
               		hwndChild = (HWND) SendMessage (hwndClient,
                                WM_MDIGETACTIVE, 0, 0) ;
               
               		if (SendMessage (hwndChild, WM_QUERYENDSESSION, 0, 0))
              			SendMessage (hwndClient, WM_MDIDESTROY,
                        (WPARAM) hwndChild, 0) ;
               			return 0 ;

          			case 	IDM_APP_EXIT:	// Exit the program
               
               		SendMessage (hwnd, WM_CLOSE, 0, 0) ;
               		return 0 ;
               
               		// messages for arranging windows

          			case 	IDM_WINDOW_TILE:
               				SendMessage (hwndClient, WM_MDITILE, 0, 0) ;
               				return 0 ;
               
          			case 	IDM_WINDOW_CASCADE:
               				SendMessage (hwndClient, WM_MDICASCADE, 0, 0) ;
               				return 0 ;
               
          			case 	IDM_WINDOW_ARRANGE:
               				SendMessage (hwndClient, WM_MDIICONARRANGE, 0, 0) ;
               				return 0 ;
               
          			case 	IDM_WINDOW_CLOSEALL:  // Attempt to close all children
               
               				EnumChildWindows (hwndClient, CloseEnumProc, 0) ;
               				return 0 ;
               
          			default:			// Pass to active child...

               				hwndChild = (HWND) SendMessage (hwndClient,
                                         WM_MDIGETACTIVE, 0, 0) ;
               				if (IsWindow (hwndChild))
                    		SendMessage (hwndChild, WM_COMMAND, wParam, lParam) ;
               
               			break ;    // ...and then to DefFrameProc
          			}
          			break ;
          
     	case 	WM_QUERYENDSESSION:
     	case 	WM_CLOSE:	// Attempt to close all children
               
          		SendMessage (hwnd, WM_COMMAND, IDM_WINDOW_CLOSEALL, 0) ;
               
          	    if (NULL != GetWindow (hwndClient, GW_CHILD))
               	return 0 ;
               
          			break ;   	// i.e., call DefFrameProc 
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
        // Pass unprocessed messages to DefFrameProc (not DefWindowProc)
     
     	return DefFrameProc (hwnd, hwndClient, message, wParam, lParam) ;
}

BOOL CALLBACK CloseEnumProc (HWND hwnd, LPARAM lParam)
{
     	if (GetWindow (hwnd, GW_OWNER)) // Check for icon title
          			return TRUE ;
     
     	SendMessage (GetParent (hwnd), WM_MDIRESTORE, (WPARAM) hwnd, 0) ;
     	if (!SendMessage (hwnd, WM_QUERYENDSESSION, 0, 0))
        return TRUE ;
     	SendMessage (GetParent (hwnd), WM_MDIDESTROY, (WPARAM) hwnd, 0) ;
     	return TRUE ;
}

LRESULT CALLBACK HelloWndProc (HWND hwnd, UINT message, 
WPARAM wParam, LPARAM lParam)
{
     	static COLORREF clrTextArray[] = { 	RGB (0,   0, 0), RGB (255, 0,   0),
        RGB (0, 255, 0), RGB (  0, 0, 255),
        RGB (255, 255, 255) } ;
     	static HWND     		hwndClient, hwndFrame ;
     	HDC             		hdc ;
     	HMENU           		hMenu ;
     	PHELLODATA      		pHelloData ;
     	PAINTSTRUCT     		ps ;
     	RECT            		rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
                // Allocate memory for window private data
          
          			pHelloData = (PHELLODATA) HeapAlloc (GetProcessHeap (),
                              	  HEAP_ZERO_MEMORY, sizeof (HELLODATA)) ;
          			pHelloData->iColor  = IDM_COLOR_BLACK ;
          			pHelloData->clrText = RGB (0, 0, 0) ;
          			SetWindowLong (hwnd, 0, (long) pHelloData) ;
          
               				// Save some window handles
          
          			hwndClient = GetParent (hwnd) ;
          			hwndFrame  = GetParent (hwndClient) ;
          			return 0 ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          				case IDM_COLOR_BLACK:
          				case IDM_COLOR_RED:
          				case IDM_COLOR_GREEN:
          				case IDM_COLOR_BLUE:
          				case IDM_COLOR_WHITE:
                    	// Change the text color
               
               pHelloData = (PHELLODATA) GetWindowLong (hwnd, 0) ;
               
               hMenu = GetMenu (hwndFrame) ;
               
               CheckMenuItem (hMenu, pHelloData->iColor, MF_UNCHECKED) ;
               pHelloData->iColor = wParam ;
               CheckMenuItem (hMenu, pHelloData->iColor, MF_CHECKED) ;
               
               pHelloData->clrText = clrTextArray[wParam - IDM_COLOR_BLACK] ;
               
               InvalidateRect (hwnd, NULL, FALSE) ;
          	   }
          	   return 0 ;
          
     	case 	WM_PAINT:
               	// Paint the window
               
          			hdc = BeginPaint (hwnd, &ps) ;
               
          			pHelloData = (PHELLODATA) GetWindowLong (hwnd, 0) ;
          			SetTextColor (hdc, pHelloData->clrText) ;
               
          			GetClientRect (hwnd, &rect) ;
               
          			DrawText (hdc, TEXT ("Hello, World!"), -1, &rect,
                    DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
               
     	case 	WM_MDIACTIVATE:
               	// Set the Hello menu if gaining focus
               
          			if (lParam == (LPARAM) hwnd)
               	SendMessage (hwndClient, WM_MDISETMENU,(WPARAM)
 hMenuHello, (LPARAM) hMenuHelloWindow) ;
               
               					// Check or uncheck menu item
               
          			pHelloData = (PHELLODATA) GetWindowLong (hwnd, 0) ;
          			CheckMenuItem (hMenuHello, pHelloData->iColor,
                    				(lParam == (LPARAM) hwnd) ? MF_CHECKED : MF_UNCHECKED) ;
               
               					// Set the Init menu if losing focus
               
          			if (lParam != (LPARAM) hwnd)
               					SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) 
hMenuInit,(LPARAM) hMenuInitWindow) ;
               
          			DrawMenuBar (hwndFrame) ;
          			return 0 ;

     	case 	WM_QUERYENDSESSION:
     	case 	WM_CLOSE:
        if (IDOK != MessageBox (hwnd, TEXT ("OK to close window?"),
                                  	  TEXT ("Hello"), 
                    MB_ICONQUESTION | MB_OKCANCEL))
               		return 0 ;
               
          			break ;   		// i.e., call DefMDIChildProc
               
     	case 	WM_DESTROY:
          			pHelloData = (PHELLODATA) GetWindowLong (hwnd, 0) ;
          			HeapFree (GetProcessHeap (), 0, pHelloData) ;
          			return 0 ;
	}
          				// Pass unprocessed message to DefMDIChildProc
     
     	return DefMDIChildProc (hwnd, message, wParam, lParam) ;
}
LRESULT CALLBACK RectWndProc (	HWND hwnd, UINT message,WPARAM wParam, LPARAM lParam)
{
     	static HWND 	hwndClient, hwndFrame ;
     	HBRUSH      	hBrush ;
     	HDC         	hdc ;
     	PRECTDATA   	pRectData ;
     	PAINTSTRUCT 	ps ;
     	int         				xLeft, xRight, yTop, yBottom ;
     	short      	 				nRed, nGreen, nBlue ;
     
     	switch (message)
     {
     	case 	WM_CREATE:
               				// Allocate memory for window private data
          
          			pRectData = (PRECTDATA) HeapAlloc (GetProcessHeap (),
                                HEAP_ZERO_MEMORY, sizeof (RECTDATA)) ;
          
          			SetWindowLong (hwnd, 0, (long) pRectData) ;
          
             								// Start the timer going
          
          			SetTimer (hwnd, 1, 250, NULL) ;
          
               								// Save some window handles
          			hwndClient	= GetParent (hwnd) ;
          			hwndFrame	= GetParent (hwndClient) ;
          			return 0 ;
          
     	case 	WM_SIZE:    // If not minimized, save the window size
          
          			if (wParam != SIZE_MINIMIZED)
          			{
               					pRectData = (PRECTDATA) GetWindowLong (hwnd, 0) ;
               
               					pRectData->cxClient = LOWORD (lParam) ;
               					pRectData->cyClient = HIWORD (lParam) ;
          			}
          
          			break ;        			// WM_SIZE must be processed by DefMDIChildProc
          
     	case 	WM_TIMER:            		// Display a random rectangle
          
          			pRectData 	= (PRECTDATA) GetWindowLong (hwnd, 0) ;
          			xLeft   			= rand () % pRectData->cxClient ;
          			xRight  		= rand () % pRectData->cxClient ;
          			yTop    			= rand () % pRectData->cyClient ;
          			yBottom 		= rand () % pRectData->cyClient ;
          			nRed    			= rand () & 255 ;
          			nGreen  		= rand () & 255 ;
          			nBlue   			= rand () & 255 ;
          
          			hdc = GetDC (hwnd) ;
          			hBrush = CreateSolidBrush (RGB (nRed, nGreen, nBlue)) ;
          			SelectObject (hdc, hBrush) ;
          
          			Rectangle (hdc, min (xLeft, xRight), min (yTop, yBottom),
               								max (xLeft, xRight), max (yTop, yBottom)) ;
          
          			ReleaseDC (hwnd, hdc) ;
          			DeleteObject (hBrush) ;
          			return 0 ;
          
     	case 	WM_PAINT:            					// Clear the window
          
          			InvalidateRect (hwnd, NULL, TRUE) ;
          			hdc = BeginPaint (hwnd, &ps) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_MDIACTIVATE:      			// Set the appropriate menu
          			if (lParam == (LPARAM) hwnd)
               	SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuRect, (LPARAM) hMenuRectWindow) ;
          			else
               	SendMessage (hwndClient, WM_MDISETMENU, (WPARAM) hMenuInit, (LPARAM) hMenuInitWindow) ;
          
          				DrawMenuBar (hwndFrame) ;
          				return 0 ;
          
     	case 	WM_DESTROY:
          			pRectData = (PRECTDATA) GetWindowLong (hwnd, 0) ;
          			HeapFree (GetProcessHeap (), 0, pRectData) ;
          			KillTimer (hwnd, 1) ;
          			return 0 ;
     }
          // Pass unprocessed message to DefMDIChildProc
     return DefMDIChildProc (hwnd, message, wParam, lParam) ;
}
 MDIDEMO.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
MDIMENUINIT MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        			MENUITEM "New &Hello",				IDM_FILE_NEWHELLO
        			MENUITEM "New &Rectangle",   	 		IDM_FILE_NEWRECT
        			MENUITEM SEPARATOR
        			MENUITEM "E&xit", IDM_APP_EXIT
    	END
END
MDIMENUHELLO MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
MENUITEM "New &Hello", 		IDM_FILE_NEWHELLO
MENUITEM "New &Rectangle", 	IDM_FILE_NEWRECT
MENUITEM "&Close",    		IDM_FILE_CLOSE
MENUITEM SEPARATOR
MENUITEM "E&xit",  			IDM_APP_EXIT
END
    	POPUP "&Color"
    	BEGIN
        MENUITEM "&Black", 			IDM_COLOR_BLACK
        MENUITEM "&Red",       	    IDM_COLOR_RED
        MENUITEM "&Green",            IDM_COLOR_GREEN
        MENUITEM "B&lue",     		IDM_COLOR_BLUE
        MENUITEM "&White",  			IDM_COLOR_WHITE
    	END
    	POPUP "&Window"
    	BEGIN
        MENUITEM "&Cascade\tShift+F5",  	 	IDM_WINDOW_CASCADE
        MENUITEM "&Tile\tShift+F4",    	 	IDM_WINDOW_TILE
        MENUITEM "Arrange &Icons",   		 	IDM_WINDOW_ARRANGE
        MENUITEM "Close &All",   				IDM_WINDOW_CLOSEALL
    	END
END
MDIMENURECT MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        MENUITEM "New &Hello",   				IDM_FILE_NEWHELLO
        MENUITEM "New &Rectangle", 			IDM_FILE_NEWRECT
        MENUITEM "&Close",        	      	IDM_FILE_CLOSE
        MENUITEM SEPARATOR
        MENUITEM "E&xit", 					IDM_APP_EXIT
    	END
    	POPUP "&Window"
    	BEGIN
        MENUITEM "&Cascade\tShift+F5",  	 	IDM_WINDOW_CASCADE
        MENUITEM "&Tile\tShift+F4",     	  	IDM_WINDOW_TILE
        MENUITEM "Arrange &Icons",     	  	IDM_WINDOW_ARRANGE
        MENUITEM "Close &All",         	    IDM_WINDOW_CLOSEALL
    	END
END

/////////////////////////////////////////////////////////////////////////////
// Accelerator
MDIDEMO ACCELERATORS DISCARDABLE 
BEGIN
    VK_F4,    IDM_WINDOW_TILE,     VIRTKEY, SHIFT, NOINVERT
    VK_F5,    IDM_WINDOW_CASCADE,  VIRTKEY, SHIFT, NOINVERT
END
 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by MDIDemo.rc

#define IDM_FILE_NEWHELLO               						40001
#define IDM_FILE_NEWRECT                						40002
#define IDM_APP_EXIT                    						40003
#define IDM_FILE_CLOSE                  						40004
#define IDM_COLOR_BLACK                 						40005
#define IDM_COLOR_RED                   						40006
#define IDM_COLOR_GREEN                 						40007
#define IDM_COLOR_BLUE                  						40008
#define IDM_COLOR_WHITE                 						40009
#define IDM_WINDOW_CASCADE              					    40010
#define IDM_WINDOW_TILE                 						40011
#define IDM_WINDOW_ARRANGE              					    40012
#define IDM_WINDOW_CLOSEALL             					    40013

MDIDEMO֧Ԯ������̬�ķdz��򵥵��ļ��Ӵ�����һ���Ӵ���������ʾ����������ʾ"Hello, World!"����һ���Ӵ���ʾһϵ��������Σ���ԭʼ���б���ʶ�������У����Ƿֱ������Hello���ļ��͡�Rect���ļ������������ļ��Ӵ��Ĺ��ܱ���ͬ����ʾ"Hello, World!"���ļ��Ӵ���һ������ʹ�����޸�������ɫ�Ĺ��ܱ���

�������ܱ�
��

�����������ȿ���MDIDEMO.RC��Դ���������������˳�ʽ��ʹ�õ��������ܱ�ģ�塣

���ļ��Ӵ�������ʱ����ʽ��ʾMdiMenuInit���ܱ���������ܱ�ֻ����ʹ���߽������ļ����˳���ʽ��

MdiMenuHello���ܱ�����ʾ��Hello, World!�����ļ��Ӵ����������File���ӹ��ܱ�����ʹ���ߴ��κ�һ�����ļ����رջ�ļ����˳���ʽ����Color���ӹ��ܱ�����ʹ�����趨������ɫ��Window�ӹ��ܱ�������ƽ�̻����ص��ķ�ʽ�����ļ��Ӵ��������ļ�ͼʾ��ر������Ӵ���ѡ�����ӹ��ܱ�Ҳ�г������ǽ����������ļ��Ӵ���

MdiMenuRect���ܱ�����������ļ�����������˲�������Color���ӹ��ܱ��⣬����MdiMenuHello���ܱ�һ����

RESOURCE.H��ͷ�����������еĹ��ܱ�ʶ���֡����⣬������������������MDIDEMO.C�У�

#define INIT_MENU_POS     		0
#define HELLO_MENU_POS    		2
#define RECT_MENU_POS     		1

��Щʶ����˵��ÿ�����ܱ�ģ����Windows�ӹ��ܱ���λ�á���ʽ��Ҫ��Щ��Ѷ��֪ͨ�ͻ��Ӵ��ļ��б�Ӧ�����������Ȼ��MdiMenuInit���ܱ�û��Windows�ӹ��ܱ���������ǰ�������ļ��б�Ӧ�����ڵ�һ���ӹ��ܱ��У�λ��0����������ʵ������Զ�����ڴ˿����ļ��б������������۴˳�ʽʱ�������Է�����������ԭ�򣩡�

������MDIDEMO.C�е�IDM_FIRSTCHILDʶ���ֲ���Ӧ춹��ܱ�����������Windows�ӹ��ܱ��ϵ��ļ��б��еĵ�һ���ļ��Ӵ�����������ʶ���ֵ�ֵӦ����������������ܱ�ID��ֵ��

��ʽ��ʼ��
��

��MDIDEMO.C�У�WinMain�Ǵ�ע�����Ӵ����������Ӵ����Ӵ����ʼ�ġ��Ӵ�ѶϢ������ʽ��FrameWndProc��HelloWndProc��RectWndProc��һ����˵����Щ�Ӵ����Ӧ���벻ͬ��ͼʾ�������Ϊ�˼���������ǽ���׼IDI_APPLICATIONͼʾ��춿���Ӵ������Ӵ���

ע�⣬�����Ѿ������˿���Ӵ�����WNDCLASS�ṹ��hbrBackground��λΪCOLOR_APPWORKSPACEϵͳ��ɫ����춿���Ӵ�����ʾ���򱻿ͻ��Ӵ������Dz��ҿͻ��Ӵ�����������ɫ����������Ķ��岻�Ǿ��Ա�Ҫ�ġ����ǣ��������ʾ����Ӵ�ʱ��ʹ��������ɫ�ƺ�Ҫ��һЩ��

�������Ӵ�����е�lpszMenuName��λ���趨ΪNULL���ԡ�Hello���͡�Rect�����Ӵ������˵�����Ǻ���Ȼ�ġ���춿���Ӵ�������ڽ�������Ӵ�ʱ��CreateWindow��ʽ�и������ܱ����š�

��Hello���͡�Rect�����Ӵ����Ӵ����WNDCLASS�ṹ�е�cbWndExtra��λ��Ϊ����ֵ��Ϊÿ���Ӵ����ö���ռ䣬����ռ佫��춴���ָ��һ����������ָ�꣨HELLODATA��RECTDATA�ṹ�Ĵ�С������MDIDEMO.C�Ŀ�ʼ���������������鱻��춴���ÿ���ļ��Ӵ����е���Ѷ��

��һ����WinMain��LoadMenu�����������ܱ����������ǵĴ��Ŵ��浽��������С���������GetSubMenu��ʽ�ɻ��Windows�ӹ��ܱ����ļ��б������������棩�Ĵ��ţ�ͬ��Ҳ�����Ǵ��浽��������С�LoadAccelerators��ʽ������ټ�����

��WinMain�к���CreateWindow��������Ӵ�����FrameWndProc��WM_CREATEѶϢ�����ڼ䣬����Ӵ������ͻ��Ӵ�����������漰����һ�κ��к�ʽCreateWindow���Ӵ�����趨ΪMDICLIENT������Ԥ��ע���MDI��ʾ�����Ӵ������Windows�������MDI��֧Ԯ��������MDICLIENT�Ӵ�����С���ʾ�����Ӵ�ѶϢ������ʽ��Ϊ����Ӵ��Ͳ�ͬ�ļ��Ӵ����м�㡣������CreateWindow������ʾ�����Ӵ�ʱ������һ���������뱻�趨Ϊָ��CLIENTCREATESTRUCT��̬�ṹ��ָ�ꡣ����ṹ��������λ��

  • hWindowMenu��Ҫ�����ļ��б����ӹ��ܱ��Ĵ��š���MDIDEMO������hMenuInitWindow������WinMain�ڼ��õġ����潫��������޸Ĵ˹��ܱ���
    ��
  • idFirstChild�����ļ��б��еĵ�һ���ļ��Ӵ�������Ĺ��ܱ�ID��������IDM_FIRSTCHILD.
    ��

�������ǻع�ͷ������WinMain��MDIDEMO��ʾ�½����Ŀ���Ӵ�������ѶϢ��Ȧ��ѶϢ��Ȧ�������Ļ�Ȧ���в�ͬ���ں���GetMessage��ѶϢ�����л��ѶϢ֮�ᣬMDI��ʽ�����ѶϢ���͸���TranslateMDISysAccel���Լ�TranslateAccelerator�������MDIDEMO��ʽһ������ʽ����Ҳ�й��ܱ����ټ��Ļ�����

TranslateMDISysAccel��ʽ�ѿ��ܶ�Ӧ�ض�MDI���ټ�������Ctrl-F6���İ���ת����WM_SYSCOMMANDѶϢ�����TranslateMDISysAccel��TranslateAccelerator������TRUE����ʾij��ѶϢ�ѱ���Щ��ʽ֮һת�������Ͳ��ܺ���TranslateMessage��DispatchMessage��

ע�⴫�ݵ�TranslateMDISysAccel��TranslateAccelerator�������Ӵ����ţ�hwndClient��hwndFrame��WinMain��ʽͨ����GW_CHILD��������GetWindow���hwndClient�Ӵ����š�

�������Ӵ�
��

FrameWndProc�Ĵ󲿷ֹ�������춴���֪ͨ���ܱ�ѡ���WM_COMMANDѶϢ����ƽʱһ����FrameWndProc��wParam�����ĵ�������������ܱ�ID��

�ڹ��ܱ�ID��ֵΪIDM_FILE_NEWHELLO��IDM_FILE_NEWRECT������£�FrameWndProc���뽨��һ���µ��ļ��Ӵ������漰����ʼ��MDICREATESTRUCT�ṹ�е���λ���������λ��Ӧ�CreateWindow�IJ�����������ѶϢWM_MDICREATE���͸��ͻ��Ӵ���ѶϢ��lParam�����趨Ϊָ������ṹ��ָ�ꡣȻ���ɿͻ��Ӵ��������ļ��Ӵ�����Ҳ����ʹ��CreateMDIWindow��ʽ����

MDICREATESTRUCT�ṹ�е�szTitle��λһ���Ƕ�Ӧ��ļ��ĵ������ơ���ʽ��λ�趨Ϊ�Ӵ���ʽWS_HSCROLL��WS_VSCROLL�������ߵ���ϣ��Ա����ļ��Ӵ��а��������С���ʽ��λҲ���԰���WS_MINIMIZE��WS_MAXIMIZE���Ա������ʱ����С�������״̬��ʾ�ļ��Ӵ���

MDICREATESTRUCT�ṹ��lParam��λΪ����Ӵ������Ӵ�����ijЩ�����ṩ��һ�ַ����������λ�����趨Ϊ����һ���ṹ�ļ������ļ�������š������ļ��Ӵ���WM_CREATEѶϢ�����ڼ䣬lParam��һ��ָ��CREATESTRUCT�ṹ��ָ�꣬����ṹ��lpCreateParams��λ��һ��ָ����춽����Ӵ���MDICREATESTRUCT�ṹ��ָ�ꡣ

�ͻ��Ӵ�һ�����յ�WM_MDICREATEѶϢ�ͽ���һ�����ļ��Ӵ��������Ӵ�����ӵ���춽����ͻ��Ӵ���MDICLIENTSTRUCT�ṹ����ָ�����ӹ��ܱ��ĵײ�����MDIDEMO��ʽ�������ĵ�һ���ļ��Ӵ�ʱ������ӹ��ܱ����ǡ�MdiMenuInit�����ܱ��еġ�File���ӹ��ܱ������潫��������ļ��б�������Ƶ���MdiMenuHello���͡�MdiMenuRect�����ܱ��ġ�Windows���ӹ��ܱ��С�

���ܱ��Ͽ����г�9���ļ���ÿ���ļ���ǰ���Ǵ��е��ߵ�����1��9������������ļ��Ӵ����9����������嵥����С�More Windows�����ܱ���������������嵥����ĶԻ����飬�嵥�����г��������ļ��������ļ��б���ά����Windows MDI֧Ԯ���������֮һ��

��춿���Ӵ���ѶϢ����
��

�ڰ�ע����ת�Ƶ����ļ��Ӵ�֮ǰ�������ȼ�������FrameWndProc��ѶϢ������

���ӡ�File�����ܱ���ѡ��Close��ʱ��MDIDEMO�رջ���Ӵ�����ͨ����WM_MDIGETACTIVEѶϢ���͸��ͻ��Ӵ�������û���Ӵ��Ĵ��š�������Ӵ���WM_QUERYENDSESSIONѶϢ����Ӧ����ôMDIDEMO��WM_MDIDESTROYѶϢ���͸��ͻ��Ӵ����Ӷ��ر����Ӵ���

������File�����ܱ��еġ�Exit��ѡ��ֻ��Ҫ����Ӵ�ѶϢ������ʽ���Լ�����һ��WM_CLOSEѶϢ��

����Window�ӹ��ܱ��ġ�Tile������Cascade���͡�Arrange��ѡ���Ǽ����׵ģ�ֻ���ѶϢWM_MDITILE��WM_MDICASCADE��WM_MDIICONARRANGE���͸��ͻ��Ӵ���

������Close All��ѡ��Ҫ��΢����һЩ��FrameWndProc����EnumChildWindows������һ������CloseEnumProc��ʽ��ָ�ꡣ�˺�ʽ��WM_MDIRESTOREѶϢ���͸�ÿ�����Ӵ�������������WM_QUERYENDSESSION��WM_MDIDESTROY����ͼʾƽ���Ӵ���˵�����ʹ˽�������GW_OWNER��������GetWindowʱ�����صķ�NULLֵ������ʾ����һ�㡣

FrameWndProcû�д����κ��ɡ�Color�����ܱ��ж���ɫ��ѡ�������µ�WM_COMMANDѶϢ����ЩѶϢӦ�����ļ��Ӵ�����������ˣ�FrameWndProc������δ��������WM_COMMANDѶϢ���͵�����Ӵ����Ա����Ӵ����Դ�����Щ�������йص�ѶϢ��

����Ӵ�ѶϢ������ʽ���账��������ѶϢ��Ҫ�͵�DefFrameProc�����ڿ���Ӵ�ѶϢ������ʽ��ȡ����DefWindowProc����ʹ����Ӵ�ѶϢ������ʽ������WM_MENUCHAR��WM_SETFOCUS��WM_SIZEѶϢ����ЩѶϢҲҪ���͵�DefFrameProc�С�

����δ��������WM_COMMANDѶϢҲ�����͸�DefFrameProc�������˵��FrameWndProc���������κ�WM_COMMANDѶϢ����ʹ��ЩѶϢ��ʹ������Windows�ӹ��ܱ����ļ��б���ѡ���ļ�ʱ�����ģ���Щѡ���wParamֵ����IDM_FIRSTCHILD��ʼ�ģ�����ЩѶϢҪ���͵�DefFrameProc������������д�����

ע�����Ӵ�������Ҫά�����������������ļ��Ӵ����Ӵ������嵥�������Ҫ��Щ�Ӵ����ţ��紦�����ܱ��ϵġ�Close All��ѡ��ʱ��������ʹ��EnumChildWindows�õ����ǡ�

���ļ��Ӵ�
��

���ڿ�һ��HelloWndProc�����������ʾ��Hello, World!�������ļ��Ӵ����Ӵ�ѶϢ������ʽ��

����춶���Ӵ����Ӵ����һ�����������Ӵ�ѶϢ������ʽ����Ӹ��Ӵ�ѶϢ������ʽ�к��е��κκ�ʽ���ж���ľ�̬���������ݸ��Ӵ�������������Ӵ����á�

ֻ�ж��ÿ��Ψһ��Ӵ������ϲű�����÷Ǿ�̬�����ķ��������档�����ļ���Ҫ�õ��Ӵ����ԡ���һ�ַ�������ʹ�õķ�������ʹ��Ԥ���ļ�����ռ䣻������ע���Ӵ����ʱ��WNDCLASS�ṹ��cbWndExtra��λ�趨Ϊ����ֵ�Ա�Ԥ���ⲿ�ּ�����ռ䡣

MDIDEMO��ʽʹ�����������ռ�������һ��ָ�꣬���ָ��ָ��һ����HELLODATA�ṹ��С��ͬ�ļ�����顣�ڴ���WM_CREATEѶϢʱ��HelloWndProc�����������壬��ʼ������������λ���������ָ��Ŀǰѡ�еĹ��ܱ����������ɫ��������SetWindowLong��������ָ�괢�浽Ԥ���Ŀռ��С�

�������ı�������ɫ��WM_COMMANDѶϢ������һ�£���ЩѶϢ���Կ���Ӵ�ѶϢ������ʽ��ʱ��HelloWndProcʹ��GetWindowLong��ð���HELLODATA�ṹ�ļ�������ָ�ꡣ��������ṹ��HelloWndProc���ԭ���Թ��ܱ����ѡ���趨��ѡ���ܱ���Ϊѡ��״̬���������µ���ɫ��

���Ӵ���ɻ�Ӵ��򲻻��ʱ���ļ��Ӵ�ѶϢ������ʽ�����յ�WM_MDIACTIVATEѶϢ��lParam��ֵ�Ƿ�Ϊ����Ӵ��Ĵ��ű�ʾ�˸��Ӵ��ǻ�Ļ��Dz���ģ�����Ҳ�����ܼ���MDIDEMO��ʽ����������ͬ�Ĺ��ܱ��������ļ�ʱΪMdiMenuInit������Hello���ļ��Ӵ��ǻ�Ӵ�ʱΪMdiMenuHello������Rect���ļ��Ӵ�Ϊ��Ӵ�ʱΪMdiMenuRect��

WM_MDIACTIVATEѶϢΪ�ļ��Ӵ��ṩ��һ���޸Ĺ��ܱ��Ļ��ᡣ���lParam�к��б��Ӵ��Ĵ��ţ���ζ�����Ӵ�����ɻ�ģ�����ôHelloWndProc�ͽ����ܱ���ΪMdiMenuHello�����lParam�а�����һ���Ӵ��Ĵ��ţ���ôHelloWndProc�����ܱ���ΪMdiMenuInit��

HelloWndProc���ɰ�WM_MDISETMENUѶϢ���͸��ͻ��Ӵ����޸Ĺ��ܱ����ͻ��Ӵ�͸����Ŀǰ���ܱ���ɾ���ļ��б����������ӵ�һ���µĹ��ܱ������������ѶϢ��������ļ��б���MdiMenuInit���ܱ������ڽ�����һ���ļ�ʱ��Ч�����͵�MdiMenuHello���ܱ��еķ�������MDIӦ�ó�ʽ�в�Ҫ��SetMenu��ʽ�ı书�ܱ���

��һ����漰����Color���ӹ��ܱ��ϵ�ѡ����ꡣ�������ij�ʽѡ���ÿ���ļ���˵���Dz�ͬ�ģ����磬������һ���Ӵ����趨��ɫ���֣�����һ���Ӵ����趨��ɫ���֡����ܱ�ѡ�����Ӧ�ܷ�ӳ����Ӵ���ѡ���ѡ��������ԭ��HelloWndProc���Ӵ���ɷǻ�Ӵ�ʱ���ѡ�й��ܱ����ѡ����꣬�����Ӵ���ɻ�Ӵ�ʱ�趨�ʵ����ܱ����ѡ����ꡣ

WM_MDIACTIVATE��wParam��lParamֵ�ֱ���ʧȥ��ͱ������Ӵ��Ĵ��š��Ӵ�ѶϢ������ʽ�õ��ĵ�һ��WM_MDIACTIVATEѶϢ��lParam�������趨ΪĿǰ�Ӵ��Ĵ��š������Ӵ�������ʱ���Ӵ�ѶϢ������ʽ�õ�������һ��ѶϢ��lParam�������趨Ϊ��һ��ֵ����ʹ���ߴ�һ���ļ��л�����һ���ļ�ʱ��ǰһ���ļ��Ӵ��յ�һ��WM_MDIACTIVATEѶϢ����lParam����Ϊ��һ���Ӵ��Ĵ��ţ���ʱ���Ӵ�ѶϢ������ʽ�����ܱ��趨ΪMdiMenuInit������һ���ļ��Ӵ��յ�һ��WM_MDIACTIVATEѶϢ����lParam�����ǵڶ����Ӵ��Ĵ��ţ���ʱ���Ӵ�ѶϢ������ʽ�����ܱ��趨ΪMdiMenuHello��MdiMenuRect���ʵ����Ǹ�����������е��Ӵ����ر��ˣ�ʣ�µĹ��ܱ�����MdiMenuInit��

��ʹ���ߴӹ��ܱ���ѡ��Close����Close All��ʱ��FrameWndProc�����Ӵ�����һ��WM_QUERYENDSESSIONѶϢ��HelloWndProc����ʾһ��ѶϢ���鲢ѯ��ʹ�����Ƿ�Ҫ�ر��Ӵ����Դ�������WM_QUERYENDSESSION��WM_CLOSEѶϢ������ʵ��Ӧ�ó�ʽ�У�ѶϢ�����ѯ���Ƿ���Ҫ���浵���������ʹ���߱�ʾ���ܹر��Ӵ�����ô�Ӵ�ѶϢ������ʽ����0��

��WM_DESTROYѶϢ�����ڼ䣬HelloWndProc�ͷ���WM_CREATE�ڼ����õļ�����顣

����δ��������ѶϢ���봫�͵�����ڶ�������DefMDIChildProc������DefWindowProc�����������Ӵ�ѶϢ������ʽ�Ƿ�ʹ������ЩѶϢ���м���ѶϢ���뱻���͸�DefMDIChildProc����ЩѶϢ�ǣ�WM_CHILDACTIVATE��WM_GETMINMAXINFO��WM_MENUCHAR��WM_MOVE��WM_SETFOCUS��WM_SIZE��WM_SYSCOMMAND��

RectWndProc��HelloWndProc�dz����ƣ���������HelloWndProcҪ��һЩ���������ܱ�ѡ�������ʹ����ȷ���Ƿ�ر��Ӵ������������ﲻ�������������ˡ���Ӧ��ע�⵽���ڴ���WM_SIZE֮��RectWndProcʹ���ˡ�break������������WM_SIZEѶϢ������DefMDIChildProc��

��������
��

��WinMain�У�MDIDEMOʹ��LoadMenu������Դ�������ж�����������ܱ���һ��˵���������ܱ����ڵ��Ӵ������ʱ��WindowsҲҪ�����֮�����Ĺ��ܱ������Init���ܱ���Ӧ�������Щû����ϵ���Ӵ��Ĺ��ܱ���������ԭ��MDIDEMO��WinMain��ĩβ����������DestroyMenu�������Hello���͡�Rect�����ܱ���