深入解析Windows窗体创建和消息分发

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Windows GUI採用基于事件驱动的编程模型，其实差点儿全部的界面库都是这样做的。在纯粹的Window32 SDK编程时代。人们还能够搞懂整个Windows窗口创建和消息的流通过程。可是在如今各种框架的包装下非常多在Window32 SDK下非常明显易懂的东西显得不是那么简单了。本文力图去繁求简，教你看懂全部框架的基本构造。而其实对于了解这一切的人来说。这些界面框架的设计都是如出一辙的，希望看完本文。再去看常见的MFC/WTL等框架时，不会再认为有不论什么的不适。

C程序的处理办法

1.基本原理

先说古老的Win32 SDK的做法，他们非常明显，这里还是先贴上代码。为了缩减篇幅非常多地方我就省略了

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)

{

    static TCHAR szAppName[] = TEXT ("TestClass");

    HWND         hwnd;

    MSG          msg;

    WNDCLASSEX   wndclassex = {0};

	//1.设计窗体类

    wndclassex.cbSize        = sizeof(WNDCLASSEX);

    wndclassex.style         = CS_HREDRAW | CS_VREDRAW;

    wndclassex.lpfnWndProc   = WndProc ...

	//2.注冊窗体类

    if (!RegisterClassEx (&wndclassex))

    {

        MessageBox (NULL, TEXT ("RegisterClassEx failed!"), szAppName, MB_ICONERROR);

        return 0;

    }

	//3.创建窗体

    hwnd = CreateWindowEx (WS_EX_OVERLAPPEDWINDOW,

		                  szAppName,

        		          ...

	//4.显示窗体

    ShowWindow (hwnd, iCmdShow);

    UpdateWindow (hwnd);

	//5.開始消息循环，又称消息泵

    while (GetMessage (&msg, NULL, 0, 0))

    {

        TranslateMessage (&msg);

        DispatchMessage (&msg);

    }

    return msg.wParam;

}

//回调函数中做消息分发

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    HDC hdc;

    PAINTSTRUCT ps;

	//分发

    switch (message)

    {

    case WM_CREATE:

        return (0);

    case WM_PAINT:

        ...

        return (0);

    case WM_DESTROY:

        PostQuitMessage (0);

        return (0);

    }

	//默认处理函数

    return DefWindowProc (hwnd, message, wParam, lParam);

}

设计窗体类和注冊窗体类可称为 InitApplication ，即初始化Windows 应用所须要做的工作，这个窗体类 能够是公用的 。

创建一个窗口和显示可称为 InitInstance ，即初始化一个Windows 应用实例所须要做的工作，对每一个窗口来说这 都是唯一的 。可做定制化改动。

开启消息泵可称为 Run ，一单消息泵开启，意味着一个程序開始接受消息和分发消息，整个应用程序算是開始执行了。

在WndProc中做的是推断相应的消息。然后做相应的处理工作。

2.改进窗体创建

能够看到，最原始的Win32 SDK编程全然是面向过程编程创建，比較繁琐。为了简化编写。可在VS2008里面打开新建一个Win32 程序能够看到代码例如以下:

	// 1.设计和注冊消息类

	...

	MyRegisterClass(hInstance);

	// 2.运行应用程序初始化:

	if (!InitInstance (hInstance, nCmdShow))

	{

		return FALSE;

	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN321));

	// 3.主消息循环:

	while (GetMessage(&msg, NULL, 0, 0))

	{

		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

		{

			TranslateMessage(&msg);

			DispatchMessage(&msg);

		}

	}

	return (int) msg.wParam;

能够看到依照在基本原理中讲的。这里微软的做法也一样。 依照三大部分封装到函数中 ，简化操作，InitApplication命名成了MyRegisterClass而已。

3.改进消息分发

前面讲了改进窗体创建，可是消息分发仍然是一团乱麻，全部的消息响应都塞在switch case中，这里我们自然想到和窗体创建一样。相应的处理分发到函数中。而其实微软也确实是这么做的，微软提供了头文件WindowsX.h来帮助我们分发消息，详细例如以下:

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

	switch (message)

	{

		HANDLE_MSG(hWnd, WM_PAINT, Cls_OnPaint);

		HANDLE_MSG(hWnd, WM_DESTROY, Cls_OnDestroy);

	}

	return DefWindowProc(hWnd, message, wParam, lParam);

}

void Cls_OnPaint(HWND hwnd)

{

	HDC hdc;

	PAINTSTRUCT ps;

	hdc = BeginPaint(hwnd, &ps);

	//...

	EndPaint(hwnd, &ps);

}

void Cls_OnDestroy(HWND hwnd)

{

	PostQuitMessage(0);

}

能够看到，这里借助于HANDLE_MSG宏让消息相应到详细的处理函数上，HANDLE_MSG展开例如以下：

#define HANDLE_MSG(hwnd, message, fn)    \

    case (message): return HANDLE_##message((hwnd), (wParam), (lParam), (fn))

HANDLE##message为处理函数

可看到这里 借助宏来降低switch case代码的编写量 ，但实际代码内容是一样的。

实际上对话框的处理略有不同。例如以下:

#define chHANDLE_DLGMSG(hwnd, message, fn) case (message): \

	return (SetDlgMsgResult(hwnd, uMsg, HANDLE_##message((hwnd), (wParam), (lParam), (fn))))

INT_PTR CALLBACK Dlg_Proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{

	UNREFERENCED_PARAMETER(lParam);

	switch (message)

	{

		chHANDLE_DLGMSG(hwnd, WM_INITDIALOG, Dlg_OnInitDialog);

		chHANDLE_DLGMSG(hwnd, WM_COMMAND,    Dlg_OnCommand);

	}

	return (INT_PTR)FALSE;

}

这里的chHANDLE_DLGMSG是仿照HANDLE_MSG自己定义的。

C++程序的处理办法

在C++时代。人们提倡面向对象编程， 对于窗体的创建和消息的分发响应都是窗体的行为。所以差点儿全部的框架都是想办法把这两者封装在一起 ，这也是我们解说的重点。对于C++程序我们先讲大框架，再讲窗体类封装。

1.MFC大框架

盗用侯捷先生一张图，MFC的基本层次结构例如以下:

MFC将开启消息循环放到CWinThread中， 将窗体注冊、创建、消息分发响应均放到CWnd中处理，这样全部和窗体处理相关的都是由同一个类来完毕 ，符合C++的封装特性，也便于使用。

VS安装完文件夹VC\atlmfc\src\mfc下有部分mfc源代码，我们直接看微软的实现。

首先，入口文件appmodul.cpp中定义入口例如以下:

extern "C" int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, int nCmdShow)

#pragma warning(suppress: 4985)

{

	// call shared/exported WinMain

	return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);

}

然后，在winmain.cpp查看定义AfxWinMain例如以下

int AFXAPI AfxWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, int nCmdShow)

{

	...

	// AFX internal initialization

	if (!AfxWinInit(hInstance, hPrevInstance, lpCmdLine, nCmdShow))

		goto InitFailure;

	// App global initializations (rare)

	if (pApp != NULL && !pApp->InitApplication())

		goto InitFailure;

	// Perform specific initializations

	if (!pThread->InitInstance())

	{

		...

	}

	nReturnCode = pThread->Run();

    ...

}

所以还是InitApplication、InitInstance、Run三大块，AfxWinInit用于做一些框架的初始化工作。

CWinApp::InitApplication在appcore.cpp中，和C程序略有不同，这里的工作主要是Doc模板管理器的初始化工作。

CThread::InitInstance虚函数会被用户改写。在这其中调用CWnd完毕窗体的注冊和创建，这个在之后一起讲

CThread::Run在thrdcore.cpp中，Run-》PumpMessage-》AfxInternalPumpMessage完毕消息泵的开启，例如以下:

BOOL AFXAPI AfxInternalPumpMessage()

{

	_AFX_THREAD_STATE *pState = AfxGetThreadState();

	if (!::GetMessage(&(pState->m_msgCur), NULL, NULL, NULL))

	{

...

		return FALSE;

	}

...

	if (pState->m_msgCur.message != WM_KICKIDLE && !AfxPreTranslateMessage(&(pState->m_msgCur)))

	{

		::TranslateMessage(&(pState->m_msgCur));

		::DispatchMessage(&(pState->m_msgCur));

	}

  return TRUE;

}

2.MFC封装窗体创建和消息分发

利用C++面向对象的特征。将窗体创建和消息分发、响应分装在一个类中，这样 一个窗体类相应一个实际窗体 ，很easy直观。

首先我们思考下，把窗体创建和消息分发封装在一起有哪些难点？

1.怎么将不同的窗体过程勾到一起

历史经验告诉我们。专制往往有时候好办事。

假设每一个窗体都有自己的窗体过程。那样处理起来就比較麻烦。最好的做法是全部的窗体在同一个窗体过程中控制分发。

2.同一窗体过程中如何将不同的hwnd消息分发给相应的CWnd类去处理响应

由于窗体回调函数的限制，回调函数不能拥有相应CWnd类的this指针，也就是说来了窗体消息，如何才干辨别相应的hwnd相应的CWnd，把消息分发给CWnd去处理呢？

3.最后。假设CWnd拿到了消息。如何去简单有效的去处理和响应呢

我们说过消息的响应也是在Cwnd中处理，如何将拿到的消息相应成详细的类成员函数呢？

这些问题串通后，MFC的做法，我们画一张消息流通图例如以下：

a).窗体创建

相同我们拿源代码来解释，

在MFC中我们自己定义的窗体类继承关系例如以下:

CWnd->CFrameWnd->CMyFrameWnd

winfrm.cpp中CFrameWnd::LoadFrame

首先，调用GetIconWndClass->AfxRegisterWndClass完毕 窗体类设计和注冊 ，

然后。调用CFrameWnd::Create->CWnd::CreateEx完毕窗体创建，例如以下:

BOOL CFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)

{

...

	LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);

	CString strTitle = m_strTitle;

	if (!Create(lpszClass, strTitle, dwDefaultStyle, rectDefault, pParentWnd, ATL_MAKEINTRESOURCE(nIDResource), 0L, pContext))

	{

		return FALSE;   // will self destruct on failure normally

	}

...

}

LPCTSTR CFrameWnd::GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource)

{

...

	if (hIcon != NULL)

	{

...

		{

			// register a very similar WNDCLASS

			return AfxRegisterWndClass(wndcls.style, wndcls.hCursor, wndcls.hbrBackground, hIcon);

		}

	}

	return NULL;        // just use the default

}

在wincore.cpp的CWnd::CreateEx中， 创建窗体

BOOL CWnd::CreateEx(...)

{

...

	// 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;

	...

	AfxHookWindowCreate(this);

	HWND hWnd = ::AfxCtxCreateWindowEx(cs.dwExStyle, cs.lpszClass,

			cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,

			cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);

    ...

}

当中。在 AfxHookWindowCreate中 安装钩子使全部窗体消息勾到一起处理 例如以下:

void AFXAPI AfxHookWindowCreate(CWnd* pWnd)

{

...

		pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT, _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());

	...

}

在_AfxCbtFilterHook中代码例如以下：

LRESULT CALLBACK _AfxCbtFilterHook(int code, WPARAM wParam, LPARAM lParam)

{

...

		if (pWndInit != NULL)

		{

			AFX_MANAGE_STATE(pWndInit->m_pModuleState);

			// the window should not be in the permanent map at this time

			ASSERT(CWnd::FromHandlePermanent(hWnd) == NULL);

			// connect the HWND to pWndInit...

			pWndInit->Attach(hWnd);

			// allow other subclassing to occur first

			pWndInit->PreSubclassWindow();

			WNDPROC *pOldWndProc = pWndInit->GetSuperWndProcAddr();

			ASSERT(pOldWndProc != NULL);

			// subclass the window with standard AfxWndProc

			WNDPROC afxWndProc = AfxGetAfxWndProc();

			oldWndProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,

				(DWORD_PTR)afxWndProc);

			ASSERT(oldWndProc != NULL);

			if (oldWndProc != afxWndProc)

				*pOldWndProc = oldWndProc;

		...

}

当中pWndInit->Attach完毕 句柄hwnd和窗体类CWnd*的绑定 ，建立一张hash表，相应的HashMap结构可參照CWnd::afxMapHWND相应的winhand_.h中的CHandleMap

SetWindowLongPtr使全部的 窗体响应都走AfxWndProc中 ,在AfxWndProc中完毕消息分发到相应的Cwnd中。

b).消息的分发和响应

LRESULT CALLBACK AfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)

{

...

	// all other messages route through message map

	CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);

	...

	return AfxCallWndProc(pWnd, hWnd, nMsg, wParam, lParam);

}

能够看到，依据hwnd取得相应的CWnd* ，然后看AfxCallWndProc例如以下:

LRESULT AFXAPI AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT nMsg, WPARAM wParam = 0, LPARAM lParam = 0)

{

...

		// delegate to object's WindowProc

		lResult = pWnd->WindowProc(nMsg, wParam, lParam);

...

}

在这里開始 调用CWnd成员响应函数 ，最终又回到CWnd中了。接着往下看

LRESULT CWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)

{

...

	if (!OnWndMsg(message, wParam, lParam, &lResult))

		...

}

在OnWndMsg中做了什么呢？看以下代码

BOOL CWnd::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)

{

...

    //WM_COMMAND特殊处理

	if (message == WM_COMMAND)

	{

		if (OnCommand(wParam, lParam))

		{

			lResult = 1;

			goto LReturnTrue;

		}

		return FALSE;

	}

...

    //找到当前的CWnd类的MessageMap表，查表得到相应响应函数并处理

	const AFX_MSGMAP* pMessageMap; pMessageMap = GetMessageMap();

	...

		for (/* pMessageMap already init'ed */; pMessageMap->pfnGetBaseMap != NULL;

			pMessageMap = (*pMessageMap->pfnGetBaseMap)())

		{

			...

		}

...

}

能够看到。到此 完毕了CWnd中的查表调用消息相应的处理函数 ，至于详细的OnCommand消息处理和详细响应函数调用过程，恕不详述。

可是等等，另一个问题没有解决。那就 是CWnd中的消息-处理函数表怎么来的 ，这就是我们常见的例如以下结构

BEGIN_MESSAGE_MAP(CMainFrame, ...)

	ON_WM_CREATE()

	ON_WM_SETFOCUS()

...

END_MESSAGE_MAP()

头文件里的DECLARE_MESSAGE_MAP定义例如以下，能够看到回调函数中 取消息映射表的函数GetMessageMap在此定义

#define DECLARE_MESSAGE_MAP() \

protected: \

	static const AFX_MSGMAP* PASCAL GetThisMessageMap(); \

	virtual const AFX_MSGMAP* GetMessageMap() const; \

BEGIN_MESSAGE_MAP结构展开例如以下

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \

	PTM_WARNING_DISABLE \

	const AFX_MSGMAP* theClass::GetMessageMap() const \

		{ return GetThisMessageMap(); } \

	const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \

	{ \

		typedef theClass ThisClass;						   \

		typedef baseClass TheBaseClass;					   \

		static const AFX_MSGMAP_ENTRY _messageEntries[] =  \

		{

可见 真正的映射表结构_massgeEntries在此定义 ,ON_WM_CRATE完毕实际的表内容填充。比如:

#define ON_WM_CREATE() \

	{ WM_CREATE, 0, 0, 0, AfxSig_is, \

		(AFX_PMSG) (AFX_PMSGW) \

		(static_cast< int (AFX_MSG_CALL CWnd::*)(LPCREATESTRUCT) > ( &ThisClass :: OnCreate)) },

将 WM_CREATE和OnCreate函数绑定

至此，窗体类的封装过程尽在眼前，可能你认为过程比較繁琐，那么我把它概括例如以下:

1.Create窗体时完毕两件事:(1)窗体过程勾到一起处理(2)hwnd和相应的CWnd*绑定

2.CWnd中利用BEGIN_MESSAGE_MAP结构定义【消息-响应函数】的路由表

3.响应函数中依据传入的hwnd查表得到CWnd*，调用CWnd->GetMassageMap获取【消息-响应函数】表，查相应消息的响应函数。调用完毕响应

如今再返回去看，是不是清晰明朗了？

3.ATL大框架

MFC出如今C++尚未完好时。没有採用c++的高级特性，基本上都是继承和虚函数、查表，类的层次过多，显得比較臃肿。

相比而言。ATL就好多了，採用模板技术简化了设计，也没有那么多的层次结构，很轻量，在此基础上上封装的WTL界面库被越来越多的人使用。WTL尽管是在ATL上封装的，可是窗体的创建和消息分发原理并没有变，所以我们仍然以ATL来解说整个过程。

ATL的框架基本上是自己搭建起来的，自己编写_tWinMain函数，期间可借助CMessageLoop完毕消息泵的开启，例如以下：

int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow)

{

...

	int nRet = Run(lpstrCmdLine, nCmdShow);

...

}

int Run(LPTSTR /*lpstrCmdLine*/ = NULL, int nCmdShow = SW_SHOWDEFAULT)

{

	CMessageLoop theLoop;

	_Module.AddMessageLoop(&theLoop);

	CMainFrame wndMain;

	if(wndMain.CreateEx() == NULL)

	{

		ATLTRACE(_T("Main window creation failed!\n"));

		return 0;

	}

	wndMain.ShowWindow(nCmdShow);

	int nRet = theLoop.Run();

	_Module.RemoveMessageLoop();

	return nRet;

}

可知CMainFrame::CreateEx完毕窗体创建。atlapp.h中CMessageLoop完毕消息泵开启。代码例如以下:

// message loop

	int Run()

	{

...

		for(;;)

		{

...

			bRet = ::GetMessage(&m_msg, NULL, 0, 0);

...

			if(!PreTranslateMessage(&m_msg))

			{

				::TranslateMessage(&m_msg);

				::DispatchMessage(&m_msg);

			}

...

		}

		return (int)m_msg.wParam;

	}

整个大框架和Win32 SDK非常像，没什么封装，唯一不同的是全部的窗体创建和消息分发都封装到窗体类中了，这个接下来重点说说。

4.ATL封装窗体创建和消息分发

和MFC封装窗体类一样，这里相同须要考虑之前说的三个问题。重要的事情说三遍，我就再贴一次之前的话。

1.怎么将不同的窗体过程勾到一起

2.同一窗体过程中如何将不同的hwnd消息分发给相应的CWnd类去处理响应

3.最后，假设CWnd拿到了消息。如何去简单有效的去处理和响应呢

这里和MFC一样，

1.全部的窗口窗口过程函数一样。保证统一处理

2.hwnd和相应窗体类是通过汇编强制粘连起来的

3.CWnd拿到消息后类似前面的C语言通过一组宏简化switch case结构调用相应的消息响应函数

相同我们从源代码開始入手:

全部的窗口类都继承于CWndImpl，我们关注这个类就可以

a).窗体创建

atlwin.app中CWindowImpl::Create中例如以下。取得窗体信息，注冊窗体类

HWND Create(HWND hWndParent, _U_RECT rect = NULL, LPCTSTR szWindowName = NULL,

            DWORD dwStyle = 0, DWORD dwExStyle = 0,

            _U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)

{

    if (T::GetWndClassInfo().m_lpszOrigName == NULL)

        T::GetWndClassInfo().m_lpszOrigName = GetWndClassName();

    ATOM atom = T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);

    dwStyle = T::GetWndStyle(dwStyle);

    dwExStyle = T::GetWndExStyle(dwExStyle);

    ...

    return CWindowImplBaseT< TBase, TWinTraits >::Create(hWndParent, rect, szWindowName,

                                                         dwStyle, dwExStyle, MenuOrID, atom, lpCreateParam);

}

能够看到调用 GetWndClassInfo.Register注冊窗体类 ，每一个类中使用DECLARE_WND_CLASS等宏来填充相应信息。

DECLARE_WND_CLASS展开例如以下:

#define DECLARE_WND_CLASS(WndClassName) \

static ATL::CWndClassInfo& GetWndClassInfo() \

{ \

	static ATL::CWndClassInfo wc = \

	{ \

		{ sizeof(WNDCLASSEX), CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS, StartWindowProc, \

		  0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName, NULL }, \

		NULL, NULL, IDC_ARROW, TRUE, 0, _T("") \

	}; \

	return wc; \

}

可知默认的 全部窗体的窗体过程函数是StartWindowProc。完毕统一控制

实际的 窗体创建函数 例如以下：

template <class TBase, class TWinTraits>

HWND CWindowImplBaseT< TBase, TWinTraits >::Create(...)

{

	BOOL result;

	ATLASSUME(m_hWnd == NULL);

	// 初始化Thunk结构体

	result = m_thunk.Init(NULL,NULL);

...

    //保存当前窗体类指针到全局

	_AtlWinModule.AddCreateWndData(&m_thunk.cd, this);

	//创建窗体

	HWND hWnd = ::CreateWindowEx(dwExStyle, MAKEINTATOM(atom), szWindowName,

		dwStyle, rect.m_lpRect->left, rect.m_lpRect->top, rect.m_lpRect->right - rect.m_lpRect->left,

		rect.m_lpRect->bottom - rect.m_lpRect->top, hWndParent, MenuOrID.m_hMenu,

		_AtlBaseModule.GetModuleInstance(), lpCreateParam);

...

}

这里的Thunk和保存指针到全局之后再说。

至此创建过程完毕。

b).消息分发和响应

前面说了，全部的窗体类的响应函数都是在StartWndProc中。例如以下:

template <class TBase, class TWinTraits>

LRESULT CALLBACK CWindowImplBaseT< TBase, TWinTraits >::StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

	CWindowImplBaseT< TBase, TWinTraits >* pThis = (CWindowImplBaseT< TBase, TWinTraits >*)_AtlWinModule.ExtractCreateWndData();

	...

	pThis->m_thunk.Init(pThis->GetWindowProc(), pThis);

	WNDPROC pProc = pThis->m_thunk.GetWNDPROC();

	WNDPROC pOldProc = (WNDPROC)::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)pProc);

	...

	return pProc(hWnd, uMsg, wParam, lParam);

}

可知， 第一次窗体响应会进入到此函数 。这里的代码从全局结构中拿到当前窗体类的指针，初始化Thunk。设置Thunk为代理窗体响应函数，通过pThis->m_thunk.Init(pThis->GetWindowProc(), pThis); 将窗体的this指针和窗体消息处理函数WindowProc初始化到thunk静态结构里。

设置全部的窗体过程函数为WindowProc。

这里用到了Thunk转换技术，所谓Thunk就是转换的意思，这里的基本思想是 替换掉传统的WndProc的第一个句柄參数hwnd,让这里的hwnd实际上是相应的CWndImpl的指针。这样完毕了hwnd到窗口类的映射。

详细的实如今atlstdthunk.h中。例如以下:

#pragma pack(push,1)

struct _stdcallthunk

{

	DWORD   m_mov;          // 替换hwnd參数为相应CWndImpl指针 mov dword ptr [esp+0x4], pThis (esp+0x4 is hWnd)

	DWORD   m_this;         //

	BYTE    m_jmp;          // 跳转到WndProc

	DWORD   m_relproc;      // relative jmp

	BOOL Init(DWORD_PTR proc, void* pThis)

	{

		m_mov = 0x042444C7;  //C7 44 24 0C

		m_this = PtrToUlong(pThis);

		m_jmp = 0xe9;

		m_relproc = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(_stdcallthunk)));   // write block from data cache and

		FlushInstructionCache(GetCurrentProcess(), this, sizeof(_stdcallthunk));    //  flush from instruction cache

		return TRUE;

	}

...

};

#pragma pack(pop)

WindowProc处理例如以下:

template <class TBase, class TWinTraits>

LRESULT CALLBACK CWindowImplBaseT< TBase, TWinTraits >::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

	CWindowImplBaseT< TBase, TWinTraits >* pThis = (CWindowImplBaseT< TBase, TWinTraits >*)hWnd;//hwnd转换成CWindowImplBaseT指针

	...

	BOOL bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam, lRes, 0);//调用相应的窗体类的ProcessWindowMessage处理函数

	...

}

可知在详细的窗体过程函数中， 将hWnd转换成相应的窗体类。接着调用窗体类的ProcessWindowMessage 调用相应的窗体类处理函数。

每一个窗口类都有ProcessWindowMessage函数，它使用一组宏定义例如以下:

BEGIN_MSG_MAP(CMainFrame)

    MESSAGE_HANDLER(WM_CREATE, OnCreate)

    ...

END_MSG_MAP()

展开显演示样例如以下:

#define BEGIN_MSG_MAP(theClass) \

public: \

	BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lResult, DWORD dwMsgMapID = 0) \

	{ \

		BOOL bHandled = TRUE; \

		(hWnd); \

		(uMsg); \

		(wParam); \

		(lParam); \

		(lResult); \

		(bHandled); \

		switch(dwMsgMapID) \

		{ \

		case 0:

#define MESSAGE_HANDLER(msg, func) \

	if(uMsg == msg) \

	{ \

		bHandled = TRUE; \

		lResult = func(uMsg, wParam, lParam, bHandled); \

		if(bHandled) \

			return TRUE; \

	}