MFC文档视图结构内幕

骑猪看日落 2022-02-27 15:24 327阅读 0赞

/\*\*\*\*\*\*\*\*\* 文章系列：MFC技术内幕系列\*\*\*\*\*\*\*\*\*\*\*/  
/\*\*\*\*\*\*\*\*\*\*\*\*MFC技术内幕系列之（二）\*\*\*\*\*\*\*\*\*\*\*/  
/\*\*\*\* 文章题目：MFC文档视图结构内幕 \*\*\*\*\*/  
/\* Copyright(c)2002 bigwhite \*/  
/\* All rights Reserved \*/  
/\*\*\*\*\*\*\*\*\*关键字：MFC，文档视图结构\*\*\*\*\*\*\*\*\*\*\*\*/  
/\* 时间：2002.7.23 \*/  
/\* 注释：本文所涉及的程序源代码均在Microsoft \*/  
/ Visual Studio.Net Enterprise Architect Edition /  
/\* 开发工具包提供的源代码中 \*/  
  
//  
引言：侯捷老师的"深入浅出MFC"一书的第8章中有“"Document/View"是MFC的基石。”一说，可以看出文档视图结构在MFC Framework中的地位是多么的重要。本文将以一个标准MFC应用程序向导作成的MDI程序为例，来和大家一起详细挖掘文档视图结构的内幕。

正文：  
 /  
/\* 1.回顾"InitInstance函数" \*/  
/  
在我的《MFC应用程序“生死因果”内幕》一文中，当谈到CMyWinApp::InitInstance()时，我只是粗略的讲了介绍了一下各个函数的功能，而忽略了很多细节，这里让我们在回顾一下CMyWinApp::InitInstance()函数，并将里面与文档视图结构有关的代码深入探讨一下：  
 BOOL CMyApp::InitInstance()//只列出了与文档视图结构相关的源代码  
 \{  
//...

//文档模板将用作文档、框架窗口和视图之间的连接  
 CMultiDocTemplate\* pDocTemplate;  
pDocTemplate = new CMultiDocTemplate(IDR\_MyTYPE,  
RUNTIME\_CLASS(CMyDoc),  
RUNTIME\_CLASS(CChildFrame), // 自定义 MDI 子框架  
 RUNTIME\_CLASS(CMyView));  
AddDocTemplate(pDocTemplate);  
// 创建主 MDI 框架窗口  
 CMainFrame\* pMainFrame = new CMainFrame;  
if (!pMainFrame->LoadFrame(IDR\_MAINFRAME))  
return FALSE;  
m\_pMainWnd = pMainFrame;  
// 仅当具有后缀时才调用 DragAcceptFiles  
// 在 MDI 应用程序中，这应在设置 m\_pMainWnd 之后立即发生  
 // 分析标准外壳命令、DDE、打开文件操作的命令行  
 CCommandLineInfo cmdInfo;  
ParseCommandLine(cmdInfo);  
// 调度在命令行中指定的命令。如果  
 // 用 /RegServer、/Register、/Unregserver 或 /Unregister 启动应用程序，则返回 FALSE。  
 if (!ProcessShellCommand(cmdInfo))  
return FALSE;  
// 主窗口已初始化，因此显示它并对其进行更新  
 pMainFrame->ShowWindow(m\_nCmdShow);  
pMainFrame->UpdateWindow();  
return TRUE;  
\}

/\* 2.初始化文档模板 \*/  
  
分析以下代码：  
 CMultiDocTemplate\* pDocTemplate;  
pDocTemplate = new CMultiDocTemplate(IDR\_MyTYPE,  
RUNTIME\_CLASS(CMyDoc),  
RUNTIME\_CLASS(CChildFrame), // 自定义 MDI 子框架  
 RUNTIME\_CLASS(CMyView));  
应用程序首先实例化一个CMultiDocTemplate对象，此过程也是对CMultiDocTemplate类数据成员的初始化过程。按调用次序我列出了以下源代码：  
注释1: CDocTemplate构造函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/doctempl.cpp  
CDocTemplate::CDocTemplate(UINT nIDResource, CRuntimeClass\* pDocClass,  
CRuntimeClass\* pFrameClass, CRuntimeClass\* pViewClass)//部分源代码  
 \{  
ASSERT\_VALID\_IDR(nIDResource);  
ASSERT(pDocClass == NULL ||  
pDocClass->IsDerivedFrom(RUNTIME\_CLASS(CDocument)));  
ASSERT(pFrameClass == NULL ||  
pFrameClass->IsDerivedFrom(RUNTIME\_CLASS(CFrameWnd)));  
ASSERT(pViewClass == NULL ||  
pViewClass->IsDerivedFrom(RUNTIME\_CLASS(CView)));

m\_nIDResource = nIDResource;  
...//  
m\_pDocClass = pDocClass;  
m\_pFrameClass = pFrameClass;  
m\_pViewClass = pViewClass;  
m\_pOleFrameClass = NULL;  
m\_pOleViewClass = NULL;  
...//  
\}  
以上为CMultiDocTemplate类的基类CDocTemplate构造函数的部分源代码，该函数初始化了四个重要的成员  
m\_nIDResource，m\_pDocClass，m\_pFrameClass和m\_pViewClass。  
注释2: CMultiDocTemplate构造函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/docmulti.cpp  
CMultiDocTemplate::CMultiDocTemplate(UINT nIDResource, CRuntimeClass\* pDocClass,  
CRuntimeClass\* pFrameClass, CRuntimeClass\* pViewClass)  
: CDocTemplate(nIDResource, pDocClass, pFrameClass, pViewClass)  
\{  
ASSERT(m\_docList.IsEmpty());

m\_hMenuShared = NULL;  
m\_hAccelTable = NULL;  
m\_nUntitledCount = 0; // start at 1

// load resources in constructor if not statically allocated  
if (!CDocManager::bStaticInit)  
LoadTemplate();  
\}  
看完以上代码后，来回过头看一看InitInstance函数将什么参数值传给了CMultiDocTemplate的构造函数。  
原来是一些RUNTIME\_CLASS宏。以下是RUNTIME\_CLASS宏的定义:  
注释3: 以下的宏定义在：../Visual Studio.NET/vc7/atlmfc/include/afx.h中  
 \#define RUNTIME\_CLASS(class\_name) \_RUNTIME\_CLASS(class\_name)  
\#define \_RUNTIME\_CLASS(class\_name) ((CRuntimeClass\*)(&class\_name::class\#\#class\_name))  
这个地方是个难点，这将涉及到MFC的另一个重要技术\---"执行期类型识别"。此项技术我将在  
MFC技术内幕系列之（三）\---《MFC执行期类型识别与动态创建技术内幕》中详细讲解。回到眼前来，源代码中这样作是为了将CMyDoc，CChildFrame，CMyView各类中的static CRuntimeClass class\#\#class\_name地址赋予CMultiDocTemplate类的各CRuntimeClass\*指针成员m\_pDocClass，m\_pFrameClass和m\_pViewClass，这位以后的动态创建Document/Frame/View"三口组"打下了基础。  
 ///  
/\* 3.文档模板列队 \*/  
///  
文档模板初始化结束后，InitInstance函数调用了CWinApp::AddDocTemplate(pDocTemplate)函数，其主要目的是将以初始化后的那个文档模板加入到文档模板链表中,并由CDocManager类对象进行管理。以下操作就是为了完成此工作。

注释1: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/appui2.cpp  
void CWinApp::AddDocTemplate(CDocTemplate\* pTemplate)//将CMultiDocTemplate\* pDocTemplate  
\{ //传给pTemplate  
if (m\_pDocManager == NULL)  
m\_pDocManager = new CDocManager;  
m\_pDocManager->AddDocTemplate(pTemplate);  
\}  
注释2: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/docmgr.cpp  
CDocManager::CDocManager()  
\{  
\}//目前是一个空函数；

void CDocManager::AddDocTemplate(CDocTemplate\* pTemplate)//部分源代码  
 \{  
if (pTemplate == NULL)  
\{  
...//  
\}  
else  
\{  
ASSERT\_VALID(pTemplate);  
ASSERT(m\_templateList.Find(pTemplate, NULL) == NULL);// must not be in list  
pTemplate->LoadTemplate();  
m\_templateList.AddTail(pTemplate);//CPtrList m\_templateList is a member //of CDocManager  
\}  
\}

///  
/\* 4.创建程序主框架窗口 \*/  
///  
应用程序实例化了一个CMainFrame类对象，并调用LoadFrame函数加载窗口资源创建主框架窗口。以下是创建主框架窗口的流程。  
创建窗口的主要代码是：pMainFrame->LoadFrame(IDR\_MAINFRAME)；LoadFrame函数是MFC包装了窗口创建过程的函数，在后面动态创建Child窗口时，它还将披挂上阵(但稍有不同）。下面是它的源代码,让我们仔细分析一下:  
注释1: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/winmdi.cpp  
  
BOOL CMDIFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,  
CWnd\* pParentWnd, CCreateContext\* pContext)  
\{  
if (!CFrameWnd::LoadFrame(nIDResource, dwDefaultStyle,  
pParentWnd, pContext))  
return FALSE;

// save menu to use when no active MDI child window is present  
ASSERT(m\_hWnd != NULL);  
m\_hMenuDefault = ::GetMenu(m\_hWnd);  
if (m\_hMenuDefault == NULL)  
TRACE(traceAppMsg, 0, "Warning: CMDIFrameWnd without a default menu./n");  
return TRUE;  
\}  
CMDIFrameWnd::LoadFrame调用了其基类CFrameWnd的LoadFrame，并将参数原封不动的传给它。

注释2: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/winfrm.cpp  
BOOL CFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,  
CWnd\* pParentWnd, CCreateContext\* pContext) //部分源代码  
 \{  
...//  
CString strFullString;  
if (strFullString.LoadString(nIDResource))  
AfxExtractSubString(m\_strTitle, strFullString, 0); // first sub-string

VERIFY(AfxDeferRegisterClass(AFX\_WNDFRAMEORVIEW\_REG));

// attempt to create the window  
LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);  
CString strTitle = m\_strTitle;  
if (!Create(lpszClass, strTitle, dwDefaultStyle, rectDefault,  
pParentWnd, MAKEINTRESOURCE(nIDResource), 0L , pContext))  
\{  
return FALSE; // will self destruct on failure normally  
\}

...//  
if (pContext == NULL) // send initial update  
SendMessageToDescendants(WM\_INITIALUPDATE, 0, 0, TRUE, TRUE);

return TRUE;  
\}  
//  
/\* 4.1注册应用程序主框架窗口类 \*/  
//  
在传统的Win32API编程中，创建窗口一般步骤是定义窗口类，注册窗口类，并调用::CreateWindow函数来创建。前面说过LoadFrame函数封装了MFC创建窗口的过程，那么也就是说LoadFrame函数将负责定义窗口类，注册窗口类等琐碎工作。下面我们就通过挖掘源代码来看看LoadFrame函数是如何完成这些工作的。  
 LoadFrame首先调用AfxDeferRegisterClass(AFX\_WNDFRAMEORVIEW\_REG)，  
注释1: 以下宏定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/afximpl.h  
\#define AfxDeferRegisterClass(fClass) AfxEndDeferRegisterClass(fClass)  
  
注释2: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/wincore.cpp  
  
BOOL AFXAPI AfxEndDeferRegisterClass(LONG fToRegister)//部分源代码  
 \{  
// mask off all classes that are already registered  
AFX\_MODULE\_STATE\* pModuleState = AfxGetModuleState();  
fToRegister &= ~pModuleState->m\_fRegisteredClasses;  
if (fToRegister == 0)  
return TRUE;

LONG fRegisteredClasses = 0;

// common initialization  
WNDCLASS wndcls;  
memset(&wndcls, 0, sizeof(WNDCLASS)); // start with NULL defaults  
wndcls.lpfnWndProc = DefWindowProc;  
wndcls.hInstance = AfxGetInstanceHandle();  
wndcls.hCursor = afxData.hcurArrow;

INITCOMMONCONTROLSEX init;  
init.dwSize = sizeof(init);

// work to register classes as specified by fToRegister, populate fRegisteredClasses as we go  
if (fToRegister & AFX\_WND\_REG)  
\{  
// Child windows - no brush, no icon, safest default class styles  
wndcls.style = CS\_DBLCLKS | CS\_HREDRAW | CS\_VREDRAW;  
wndcls.lpszClassName = \_afxWnd;  
if (AfxRegisterClass(&wndcls))  
fRegisteredClasses |= AFX\_WND\_REG;  
\}  
...//  
if (fToRegister & AFX\_WNDMDIFRAME\_REG)  
\{  
// MDI Frame window (also used for splitter window)  
wndcls.style = CS\_DBLCLKS;  
wndcls.hbrBackground = NULL;  
if (\_AfxRegisterWithIcon(&wndcls, \_afxWndMDIFrame, AFX\_IDI\_STD\_MDIFRAME))  
fRegisteredClasses |= AFX\_WNDMDIFRAME\_REG;  
\}  
if (fToRegister & AFX\_WNDFRAMEORVIEW\_REG)  
\{  
// SDI Frame or MDI Child windows or views - normal colors  
wndcls.style = CS\_DBLCLKS | CS\_HREDRAW | CS\_VREDRAW;  
wndcls.hbrBackground = (HBRUSH) (COLOR\_WINDOW + 1);  
if (\_AfxRegisterWithIcon(&wndcls, \_afxWndFrameOrView, AFX\_IDI\_STD\_FRAME))  
fRegisteredClasses |= AFX\_WNDFRAMEORVIEW\_REG;  
\}  
  
...//  
// must have registered at least as mamy classes as requested  
return (fToRegister & fRegisteredClasses) == fToRegister;  
\}  
MFC预定义了若干个“窗口类模板”，比如"AFX\_WNDMDIFRAME\_REG","AFX\_WNDFRAMEORVIEW\_REG"等，MFC在  
LoadFrame函数中调用AfxEndDeferRegisterClass函数为你的应用程序预注册了适当的窗口类。本例中预注册的窗口类为AFX\_WNDFRAMEORVIEW\_REG。（注意是预注册，如果你在后面更改了CREATESTRUCT结构的域成员，MFC还会根据你的更改重新为你的应用程序正式注册新的窗口类，稍候会有详细叙述）  
  
预注册完窗口类，MFC将判断你是否想更改窗口类的各参数。若你更改了，则MFC会重新注册新类；否则源预注册的窗口类就将成为正式的窗口类。下面我们来看看MFC的判断过程：此判断过程由GetIconWndClass开始  
 LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);  
注释3: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/winfrm.cpp  
  
LPCTSTR CFrameWnd::GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource)//部分源代码  
 \{  
...//  
HICON hIcon = ::LoadIcon(hInst, MAKEINTRESOURCE(nIDResource));  
if (hIcon != NULL)  
\{  
CREATESTRUCT cs;  
memset(&cs, 0, sizeof(CREATESTRUCT));  
cs.style = dwDefaultStyle;  
PreCreateWindow(cs);  
// will fill lpszClassName with default WNDCLASS name  
// ignore instance handle from PreCreateWindow.

WNDCLASS wndcls;  
if (cs.lpszClass != NULL &&  
GetClassInfo(AfxGetInstanceHandle(), cs.lpszClass, &wndcls) &&  
wndcls.hIcon != hIcon)  
\{  
// register a very similar WNDCLASS  
return AfxRegisterWndClass(wndcls.style,  
wndcls.hCursor, wndcls.hbrBackground, hIcon);  
\}  
\}  
return NULL; // just use the default  
\}  
GetIconWndClass函数将调用CMainFrame::PreCreateWindow(CREATESTRUCT& cs)来看看应用程序是否修改了CREATESTRUCT结构的域成员。CMainFrame::PreCreateWindow调用 CMDIFrameWnd::PreCreateWindow(CREATESTRUCT& cs)，后者的代码如下:  
BOOL CMDIFrameWnd::PreCreateWindow(CREATESTRUCT& cs)//in winmdi.cpp  
\{  
if (cs.lpszClass == NULL)  
\{  
VERIFY(AfxDeferRegisterClass(AFX\_WNDMDIFRAME\_REG));  
cs.lpszClass = \_afxWndMDIFrame;  
\}  
return TRUE;  
\}  
MFC将为应用程序注册AFX\_WNDMDIFRAME\_REG预定义窗口类，并设置cs.lpszClass = \_afxWndMDIFrame。  
在应用程序的代码中我更改了cs结构：  
 BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)  
\{  
if( !CMDIFrameWnd::PreCreateWindow(cs) )  
return FALSE;  
// TODO: 在此处通过修改 CREATESTRUCT cs 来修改窗口类或  
 // 样式  
 cs.dwExStyle=~WS\_EX\_CLIENTEDGE;  
return TRUE;  
\}  
  
CMainFrame::PreCreateWindow返回后，GetIconWndClass函数调用GetClassInfo函数重新收集cs信息（此时的信息已是更改后的了)，并调用AfxRegisterWndClass函数重新注册该窗口类（此窗口类为该应用程序的正式窗口类）。到此为止窗口类注册完毕，以后程序还会调用一次CMainFrame::PreCreateWindow，不过那此只是"过门不如"而已。  
 /  
/\* 4.2主框架窗口创建开始 \*/  
/

开始进入创建框架窗口的实质阶段。看LoadFrame函数做了什么?原来它调用了Create函数。  
注释1: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/winfrm.cpp  
BOOL CFrameWnd::Create(LPCTSTR lpszClassName,  
LPCTSTR lpszWindowName,  
DWORD dwStyle,  
const RECT& rect,  
CWnd\* pParentWnd,  
LPCTSTR lpszMenuName,  
DWORD dwExStyle,  
CCreateContext\* pContext)  
\{  
HMENU hMenu = NULL;  
if (lpszMenuName != NULL)  
\{  
// load in a menu that will get destroyed when window gets destroyed  
HINSTANCE hInst = AfxFindResourceHandle(lpszMenuName, RT\_MENU);  
if ((hMenu = ::LoadMenu(hInst, lpszMenuName)) == NULL)  
\{  
TRACE(traceAppMsg, 0, "Warning: failed to load menu for CFrameWnd./n");  
PostNcDestroy(); // perhaps delete the C++ object  
return FALSE;  
\}  
\}

m\_strTitle = lpszWindowName; // save title for later

if (!CreateEx(dwExStyle, lpszClassName, lpszWindowName, dwStyle,  
rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,  
pParentWnd->GetSafeHwnd(), hMenu, (LPVOID)pContext))  
\{  
TRACE(traceAppMsg, 0, "Warning: failed to create CFrameWnd./n");  
if (hMenu != NULL)  
DestroyMenu(hMenu);  
return FALSE;  
\}

return TRUE;  
\}

简单地说CFrameWnd::Create函数调用了基类的CWnd::CreateEx；  
注释2: 以下函数定义在：../Visual Studio.NET/vc7/atlmfc/src/mfc/wincore.cpp  
BOOL CWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName,  
LPCTSTR lpszWindowName, DWORD dwStyle,  
int x, int y, int nWidth, int nHeight,  
HWND hWndParent, HMENU nIDorHMenu, LPVOID lpParam)//部分源代码  
 \{  
// allow modification of several common create parameters  
CREATESTRUCT cs;  
cs.dwExStyle = dwExStyle;  
cs.lpszClass = lpszClassName;  
cs.lpszName = lpszWindowName;  
cs.style = dwStyle;  
cs.x = x;  
cs.y = y;  
cs.cx = nWidth;  
cs.cy = nHeight;  
cs.hwndParent = hWndParent;  
cs.hMenu = nIDorHMenu;  
cs.hInstance = AfxGetInstanceHandle();  
cs.lpCreateParams = lpParam;

if (!PreCreateWindow(cs))  
\{  
PostNcDestroy();  
return FALSE;  
\}

AfxHookWindowCreate(this);  
HWND hWnd = ::CreateWindowEx(cs.dwExStyle, cs.lpszClass,  
cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,  
cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);  
...//  
  
return TRUE;  
\}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)  
\{  
if( !CMDIFrameWnd::PreCreateWindow(cs) )  
return FALSE;  
// TODO: 在此处通过修改 CREATESTRUCT cs 来修改窗口类或  
 // 样式  
 cs.dwExStyle=~WS\_EX\_CLIENTEDGE;  
return TRUE;  
\}

BOOL CMDIFrameWnd::PreCreateWindow(CREATESTRUCT& cs)  
\{  
if (cs.lpszClass == NULL)  
\{  
VERIFY(AfxDeferRegisterClass(AFX\_WNDMDIFRAME\_REG));  
cs.lpszClass = \_afxWndMDIFrame;  
\}  
return TRUE;  
\}  
CWnd::CreateEx调用了CMainFrame::PreCreateWindow，但此次AfxDeferRegisterClass将不会被调用。也就是我上面所说的“过门不入”。

CWnd::CreateEx函数还调用了AfxHookWindowCreate(this);后者是干什么的呢？其实它与消息映射和命令传递有关，我将在MFC技术内幕系列之（四）\--《MFC消息映射与消息传递内幕》一文中详解。  
  
CWnd::CreateEx调用Win32API ::CreateWindowEx函数（传统的Win32API程序员一定不陌生这个函数），  
就这样主框架窗口创建结束。

//  
/\* 5.标准外壳命令解析 \*/  
///  
MFC向导制作的标准MDI应用程序启动时，应用程序会自动启动一个子窗口框架（实际上是一套文档模板），这是为何呢？下面我将详细讲解一下这个创建过程.  
其实这一过程也是在CMyWinApp::InitInstance()函数中完成的，看看下面代码：

CCommandLineInfo cmdInfo;  
ParseCommandLine(cmdInfo);  
if (!ProcessShellCommand(cmdInfo))  
return FALSE;  
函数首先实例化一个CCommandLineInfo类对象cmdInfo，让我们看看CCommandLineInfo是个什么东东?  
//in afxwin.h  
class CCommandLineInfo : public CObject//部分源代码  
\{  
public:  
// Sets default values  
CCommandLineInfo();  
...//  
BOOL m\_bShowSplash;  
BOOL m\_bRunEmbedded;  
BOOL m\_bRunAutomated;  
enum \{ FileNew, FileOpen, FilePrint, FilePrintTo, FileDDE, AppRegister,  
AppUnregister, FileNothing = -1 \} m\_nShellCommand;

// not valid for FileNew  
CString m\_strFileName;

// valid only for FilePrintTo  
CString m\_strPrinterName;  
CString m\_strDriverName;  
CString m\_strPortName;

~CCommandLineInfo();  
// Implementation  
...//  
\};

再让我们来看看它的构造函数的实现：

//in appcore.cpp  
CCommandLineInfo::CCommandLineInfo()  
\{  
m\_bShowSplash = TRUE;  
m\_bRunEmbedded = FALSE;  
m\_bRunAutomated = FALSE;  
m\_nShellCommand = FileNew;  
\}  
m\_nShellCommand = FileNew;这一句对我们最重要；至于CWinApp::ParseCommandLine我想用MFC文档中的一句话来解释：  
 Call this member function to parse the command line and send the parameters, one at a time, to CCommandLineInfo::ParseParam.  
下面我们来看看外壳命令解析的主角：CWinApp::ProcessShellCommand  
//in appui2.cpp  
//DDE and ShellExecute support

BOOL CWinApp::ProcessShellCommand(CCommandLineInfo& rCmdInfo)//部分源代码  
\{  
BOOL bResult = TRUE;  
switch (rCmdInfo.m\_nShellCommand)  
\{  
case CCommandLineInfo::FileNew:  
if (!AfxGetApp()->OnCmdMsg(ID\_FILE\_NEW, 0, NULL, NULL))  
OnFileNew();  
if (m\_pMainWnd == NULL)  
bResult = FALSE;  
break;

// If we've been asked to open a file, call OpenDocumentFile()

case CCommandLineInfo::FileOpen:  
if (!OpenDocumentFile(rCmdInfo.m\_strFileName))  
bResult = FALSE;  
break;  
case CCommandLineInfo::FilePrintTo:  
case CCommandLineInfo::FilePrint:  
...//  
case CCommandLineInfo::FileDDE:  
...//  
case CCommandLineInfo::AppRegister:  
...//  
case CCommandLineInfo::AppUnregister:  
...//  
\}  
return bResult;  
\}  
挖掘源代码的确是了解MFC运行内幕的最好手段，大家一看源代码便知道如之何了。CCommandLineInfo构造函数中m\_nShellCommand = FileNew;所以在ProcessShellCommand中对应的代码自然就一目了然了：CWinApp::OnFileNew()被调用了。

//  
/\* 6.一套文档/视图即将诞生 \*/  
//  
上文说CWinApp::OnFileNew()被调用了，那么就让我来看看其代码吧！  
 //in appdlg.cpp  
void CWinApp::OnFileNew()  
\{  
if (m\_pDocManager != NULL)  
m\_pDocManager->OnFileNew();  
\}  
//in docmgr.cpp  
void CDocManager::OnFileNew()//部分源代码  
\{  
...//  
CDocTemplate\* pTemplate = (CDocTemplate\*)m\_templateList.GetHead();  
if (m\_templateList.GetCount() > 1)  
\{  
// more than one document template to choose from  
// bring up dialog prompting user  
CNewTypeDlg dlg(&m\_templateList);  
INT\_PTR nID = dlg.DoModal();  
if (nID == IDOK)  
pTemplate = dlg.m\_pSelectedTemplate;  
else  
return; // none - cancel operation  
\}

ASSERT(pTemplate != NULL);  
ASSERT\_KINDOF(CDocTemplate, pTemplate);  
pTemplate->OpenDocumentFile(NULL);  
// if returns NULL, the user has already been alerted  
\}  
//in docmulti.cpp  
CDocument\* CMultiDocTemplate::OpenDocumentFile(LPCTSTR lpszPathName,  
BOOL bMakeVisible)//部分源代码  
\{  
CDocument\* pDocument = CreateNewDocument();  
...//  
BOOL bAutoDelete = pDocument->m\_bAutoDelete;  
pDocument->m\_bAutoDelete = FALSE; // don't destroy if something goes wrong  
CFrameWnd\* pFrame = CreateNewFrame(pDocument, NULL);  
pDocument->m\_bAutoDelete = bAutoDelete;  
...//

if (lpszPathName == NULL)  
\{  
// create a new document - with default document name  
SetDefaultTitle(pDocument);

// avoid creating temporary compound file when starting up invisible  
if (!bMakeVisible)  
pDocument->m\_bEmbedded = TRUE;

if (!pDocument->OnNewDocument())  
\{  
// user has be alerted to what failed in OnNewDocument  
TRACE(traceAppMsg, 0, "CDocument::OnNewDocument returned FALSE./n");  
pFrame->DestroyWindow();  
return NULL;  
\}

// it worked, now bump untitled count  
m\_nUntitledCount++;  
\}  
else  
\{  
// open an existing document  
CWaitCursor wait;  
if (!pDocument->OnOpenDocument(lpszPathName))  
\{  
// user has be alerted to what failed in OnOpenDocument  
TRACE(traceAppMsg, 0, "CDocument::OnOpenDocument returned FALSE./n");  
pFrame->DestroyWindow();  
return NULL;  
\}  
pDocument->SetPathName(lpszPathName);  
\}

InitialUpdateFrame(pFrame, pDocument, bMakeVisible);  
return pDocument;  
\}  
//  
/\* 6.1.子文档动态生成 \*/  
//  
CMultiDocTemplate::OpenDocumentFile调用了CreateNewDocument()，这就是子文档动态生成的主函数。  
 //in doctempl.cpp  
CDocument\* CDocTemplate::CreateNewDocument()//部分源代码  
 \{  
// default implementation constructs one from CRuntimeClass  
...//  
CDocument\* pDocument = (CDocument\*)m\_pDocClass->CreateObject();  
...//  
AddDocument(pDocument);//将动态生成的文档对象的指针加入到应用程序的文档列表中  
 return pDocument;  
\}  
CDocument\* pDocument = (CDocument\*)m\_pDocClass->CreateObject()；这一句就是动态产生的核心，它借助于CRuntimeClass动态生成一个CDocument对象。其动态生成的奥秘我将在MFC技术内幕系列之（三）\---  
《MFC执行期类型识别与动态创建技术内幕》一文中详解。

//  
/\* 6.2.子窗口框架动态生成 \*/  
/  
CMultiDocTemplate::OpenDocumentFile调用了CreateNewFrame，这就是子窗口框架动态生成的主函数。

// Default frame creation  
CFrameWnd\* CDocTemplate::CreateNewFrame(CDocument\* pDoc, CFrameWnd\* pOther)//部分源代码  
 \{  
if (pDoc != NULL)  
ASSERT\_VALID(pDoc);  
// create a frame wired to the specified document

ASSERT(m\_nIDResource != 0); // must have a resource ID to load from  
CCreateContext context;  
context.m\_pCurrentFrame = pOther;  
context.m\_pCurrentDoc = pDoc;  
context.m\_pNewViewClass = m\_pViewClass;  
context.m\_pNewDocTemplate = this;  
...//  
CFrameWnd\* pFrame = (CFrameWnd\*)m\_pFrameClass->CreateObject();  
if (pFrame == NULL)  
\{  
TRACE(traceAppMsg, 0, "Warning: Dynamic create of frame %hs failed./n",  
m\_pFrameClass->m\_lpszClassName);  
return NULL;  
\}  
ASSERT\_KINDOF(CFrameWnd, pFrame);  
...//  
  
// create new from resource  
if (!pFrame->LoadFrame(m\_nIDResource,  
WS\_OVERLAPPEDWINDOW | FWS\_ADDTOTITLE, // default frame styles  
NULL, &context))  
\{  
TRACE(traceAppMsg, 0, "Warning: CDocTemplate couldn't create a frame./n");  
// frame will be deleted in PostNcDestroy cleanup  
return NULL;  
\}

// it worked !  
return pFrame;  
\}  
CFrameWnd\* pFrame = (CFrameWnd\*)m\_pFrameClass->CreateObject();这一句就是动态产生的核心，它借助于CRuntimeClass动态生成一个CDocument对象。其动态生成的奥秘我将在MFC技术内幕系列之（三）\---  
《MFC执行期类型识别与动态创建技术内幕》一文中详解。之后函数调用LoadFrame来创建子窗口。其过程与创建主框架窗口的过程大致相同，但也有一些不同的地方，下面我就将说说这点不同。

//  
/\* 6.3.子视图动态生成 \*/  
//  
瞪大眼睛仔细察看OpenDocumentFile的源代码，疑惑了,"怎么没有类似CView\* pView =CreateNewView();  
的代码?","那么子视图是如何生成的呢"下面我就为你详细解释一下吧！其实子视图动态生成函数被放到另一个地方了。让我们详细来看看吧。  
其实，关键还是在LoadFrame，但与创建主窗口框架的那个LoadFrame不同的是传进了一个不同的参数  
&context，你回过头看看主窗口框架的那个LoadFrame，调用它时使用了默认参数，而那个默认参数值为NULL,  
下面看看CCreateContext 结构。  
//in afxext.h  
struct CCreateContext // Creation information structure  
// All fields are optional and may be NULL  
\{  
// for creating new views  
CRuntimeClass\* m\_pNewViewClass; // runtime class of view to create or NULL  
CDocument\* m\_pCurrentDoc;

// for creating MDI children (CMDIChildWnd::LoadFrame)  
CDocTemplate\* m\_pNewDocTemplate;

// for sharing view/frame state from the original view/frame  
CView\* m\_pLastView;  
CFrameWnd\* m\_pCurrentFrame;  
// Implementation  
CCreateContext();  
\};  
而在CDocTemplate::CreateNewFrame中初始化了该结构如下：  
 CCreateContext context;  
context.m\_pCurrentFrame = pOther;  
context.m\_pCurrentDoc = pDoc;  
context.m\_pNewViewClass = m\_pViewClass;  
context.m\_pNewDocTemplate = this;  
context.m\_pNewViewClass = m\_pViewClass;//关键的成员  
下面看看这个创建的具体过程：  
 LoadFrame(...,&context)-->CFrameWnd::Create(...,&context)--> CWnd::CreateEx(...,&context)  
\-->::CreateWindowEx  
::CreateWindowEx API函数将产生WM\_CREATE消息，并将&context传递之,CMainFrame::OnCreate将响应消息,并引起一系列的函数调用，看下面:  
//in mainfrm.cpp  
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)  
\{  
if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)  
return -1;  
...//  
return 0;  
\}  
// in winfrm.cpp  
int CFrameWnd::OnCreate(LPCREATESTRUCT lpcs)  
\{  
CCreateContext\* pContext = (CCreateContext\*)lpcs->lpCreateParams;  
return OnCreateHelper(lpcs, pContext);  
\}  
// in winfrm.cpp  
int CFrameWnd::OnCreateHelper(LPCREATESTRUCT lpcs, CCreateContext\* pContext)//部分源代码  
\{  
if (CWnd::OnCreate(lpcs) == -1)  
return -1;

// create special children first  
if (!OnCreateClient(lpcs, pContext))  
\{  
TRACE(traceAppMsg, 0, "Failed to create client pane/view for frame./n");  
return -1;  
\}

...//  
return 0; // create ok  
\}  
// in winfrm.cpp  
BOOL CFrameWnd::OnCreateClient(LPCREATESTRUCT, CCreateContext\* pContext)  
\{  
// default create client will create a view if asked for it  
if (pContext != NULL && pContext->m\_pNewViewClass != NULL)  
\{  
if (CreateView(pContext, AFX\_IDW\_PANE\_FIRST) == NULL)  
return FALSE;  
\}  
return TRUE;  
\}  
// in winfrm.cpp  
CWnd\* CFrameWnd::CreateView(CCreateContext\* pContext, UINT nID)//部分源代码  
\{  
...//

// Note: can be a CWnd with PostNcDestroy self cleanup  
CWnd\* pView = (CWnd\*)pContext->m\_pNewViewClass->CreateObject();  
if (pView == NULL)  
\{  
TRACE(traceAppMsg, 0, "Warning: Dynamic create of view type %hs failed./n",  
pContext->m\_pNewViewClass->m\_lpszClassName);  
return NULL;  
\}  
ASSERT\_KINDOF(CWnd, pView);

// views are always created with a border!  
if (!pView->Create(NULL, NULL, AFX\_WS\_DEFAULT\_VIEW,  
CRect(0,0,0,0), this, nID, pContext))  
\{  
TRACE(traceAppMsg, 0, "Warning: could not create view for frame./n");  
return NULL; // can't continue without a view  
\}

...//  
return pView;  
\}  
CWnd\* pView = (CWnd\*)pContext->m\_pNewViewClass->CreateObject();核心函数终于出现了。子视图动态生成完毕。

/  
/\* 7.收尾工作 \*/  
/  
至此，一套完整的Document/ChildFrame/View结构生成,此“三口组”共属同一套文档模板，如果你要定义另一套不同的文档模档需再定义另一组不同“三口组”（ChildFrame可以使用相同的）。并调用AddDocTemplate将该文档模板加入到应用程序的文档模板列表。比如：

CMultiDocTemplate\* pOtherDocTemplate;  
pOtherDocTemplate = new CMultiDocTemplate(IDR\_MyOtherTYPE,  
RUNTIME\_CLASS(CMyOtherDoc),  
RUNTIME\_CLASS(CChildFrame), // 自定义 MDI 子框架  
 RUNTIME\_CLASS(CMyOtherView));  
AddDocTemplate(pOtherDocTemplate);

“三口组”生成后程序调用ShowWindow，UpdateWindow将应用程序的主窗口展现在你眼前。

注释:当你在File菜单中选择new或在工具栏中单击“新建”时，应用程序将选择当前默认的文档模板并以它为基础动态生成 Document/ChildFrame/View“三口组”，其生成过程与我上述讲的一般不二。