窗口子类化与超类化

模板类

CWindowImplBaseT

提供一个数据成员

WNDPROC m_pfnSuperWindowProc

并且初始化为

::DefWindowProc

。然而在窗口超类化处理时它存储了已注册窗口类的窗口过程，在窗口子类化时它保存窗口实例句柄原有的窗口过程，所有设置了
bHandled = false
的消息都由该数据成员处理。

template <class
TBase = CWindow, class TWinTraits = CControlWinTraits>
class ATL_NO_VTABLE
CWindowImplBaseT : public CWindowImplRoot< TBase >
{
public:
WNDPROC
m_pfnSuperWindowProc;

CWindowImplBaseT()
: m_pfnSuperWindowProc(::DefWindowProc)
{}
···
}

子类化
Subclass

子类化是在窗口实例创建之后，把窗口实例的窗口过程用另一个用户定义窗口类的窗口过程函数替换，从而改变其窗口行为。而窗口实例的原窗口过程则保存在数据成员

m_pfnSuperWindowProc

中。

template <class
TBase, class TWinTraits>
BOOL
CWindowImplBaseT< TBase, TWinTraits >::SubclassWindow(HWND hWnd)
{
BOOL
result;
ATLASSUME(m_hWnd
== NULL);
ATLASSERT(::IsWindow(hWnd));

//
Allocate the thunk structure here, where we can fail gracefully.

result
= m_thunk.Init(GetWindowProc(), this);
if
(result == FALSE)
{
return
FALSE;
}
WNDPROC
pProc = m_thunk.GetWNDPROC();
WNDPROC
pfnWndProc = (WNDPROC)::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)pProc);
if(pfnWndProc
== NULL)
return
FALSE;
m_pfnSuperWindowProc
= pfnWndProc;
m_hWnd
= hWnd;
return
TRUE;
}
窗口子类化函数接受一个有效窗口实例句柄
hWnd
，此窗口句柄必须是一个根据某个窗口类创建的窗口（如果是对话框模板资源上的控件窗口，则必然满足此要求）。

1
）把此窗口句柄
hWnd
对应的窗口类（超类窗口
Superclass
）的窗口过程设置为调用者窗口类（子类窗口
Subclass
）的窗口过程函数。

2
）
hWnd
原有窗口过程函数由数据成员
m_pfnSuperWindowProc
保存，便于把未处理的消息传递到原有窗口过程处理。

3
）调用者窗口类与窗口句柄
hWnd
挂接

m_hWnd = hWnd。

窗口子类化的行为在程序运行期有效。当窗口接收到

WM_NCDESTROY

消息即将被销毁时，如果该窗口存在窗口子类化的行为，则对此窗口类进行去子类化处理，即恢复
hWnd
对应的原窗口类的原窗口过程，并且窗口标识设置

WINSTATE_DESTROYED

位。具体实现如下：

template <class
TBase, class TWinTraits>
LRESULT CALLBACK
CWindowImplBaseT< TBase, TWinTraits >::WindowProc(HWND hWnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
···
//
pass to the message map to process
LRESULT
lRes;
BOOL
bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam,
lRes, 0);
//
restore saved value for the current message
ATLASSERT(pThis->m_pCurrentMsg
== &msg);

//
do the default processing if message was not handled
if(!bRet)
{
if(uMsg
!= WM_NCDESTROY)
lRes
= pThis->DefWindowProc(uMsg, wParam, lParam);
else
{
//
unsubclass, if needed
LONG_PTR
pfnWndProc = ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC);
lRes
= pThis->DefWindowProc(uMsg, wParam, lParam);
if(pThis->m_pfnSuperWindowProc
!= ::DefWindowProc && ::GetWindowLongPtr(pThis->m_hWnd,
GWLP_WNDPROC) == pfnWndProc)
::SetWindowLongPtr(pThis->m_hWnd,
GWLP_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
//
mark window as destryed
pThis->m_dwState
|= WINSTATE_DESTROYED;
}
}
···
return
lRes;
}
首先将消息传递到消息映射函数处理：
ProcessWindowMessage(pThis->m_hWnd,
uMsg, wParam, lParam, lRes, 0);
此函数是

CMessageLoop
接口类的唯一虚拟函数，完成具体的消息处理任务，在具体窗口类中由
BEGIN_MSG_MAP
（
wndclass
）
/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
ALT_MSG_MAP(msgMapID) /
break;
/
case
msgMapID:

#define
MESSAGE_HANDLER(msg, func) /
if(uMsg
== msg) /
{
/
bHandled
= TRUE; /
lResult
= func(uMsg, wParam, lParam, bHandled); /
if(bHandled)
/
return
TRUE; /
}

#define END_MSG_MAP()
/
break;
/
default:
/
ATLTRACE(ATL::atlTraceWindowing,
0, _T("Invalid message map ID (%i)/n"), dwMsgMapID); /
ATLASSERT(FALSE);
/
break;
/
} /
return
FALSE; /
}
可见所有的消息映射处理函数都在

ProcessWindowMessage

（）中被按照相应的消息来调用，处理结果
LRESULT
由该函数的参数返回。此函数中还定义了一个极其重要的变量
bHandled
，它决定了此函数的返回值。该变量作为参数传递给消息处理函数，因此可以在消息映射函数中被设置。在窗口过程函数中若

ProcessWindowMessage（）

返回
TRUE
则此消息处理到此结束，否则调用窗口类默认窗口函数：

LRESULT
DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
#ifdef STRICT
return
::CallWindowProc(m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
#else
return
::CallWindowProc((FARPROC)m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
#endif
}
仅仅是调用数据成员

m_pfnSuperWindowProc

保存的窗口过程函数进行处理。前面提到在窗口超类化处理时它存储了已注册窗口类的窗口过程，在窗口子类化时它保存窗口实例句柄原有的窗口过程，所有
bHandled = false
的消息都由该数据成员处理，也就是说超类化时路由到已注册窗口类窗口过程继续处理，子类化时路由到窗口实例句柄原有的窗口过程继续处理，否则，调用默认窗口过程函数处理。

因此在消息映射函数中可以通过设置
bHandled

来决定是否需要继续对此消息进行处理。然后窗口销毁时进行去子类化。当然如果需要在窗口销毁前去子类化，则可直接调用如下函数去子类化：

template <class
TBase, class TWinTraits>
HWND
CWindowImplBaseT< TBase, TWinTraits >::UnsubclassWindow(BOOL bForce /*=
FALSE*/)
{
ATLASSUME(m_hWnd
!= NULL);

WNDPROC
pOurProc = m_thunk.GetWNDPROC();
WNDPROC
pActiveProc = (WNDPROC)::GetWindowLongPtr(m_hWnd, GWLP_WNDPROC);

HWND
hWnd = NULL;
if
(bForce || pOurProc == pActiveProc)
{
if(!::SetWindowLongPtr(m_hWnd,
GWLP_WNDPROC, (LONG_PTR)m_pfnSuperWindowProc))
return
NULL;

m_pfnSuperWindowProc
= ::DefWindowProc;
hWnd
= m_hWnd;
m_hWnd
= NULL;
}
return
hWnd;
}
首先判断窗口实例句柄现有的窗口过程是否是当前窗口类的窗口过程，即是否存在子类化。若是并且强制要求去子类化，则恢复窗口实例句柄原有的窗口过程，并设置

m_pfnSuperWindowProc = ::DefWindowProc

存储默认窗口过程。最后窗口类与窗口实例句柄分离

m_hWnd = NULL。返回窗口实例句柄。

超类化

superclassing

超类化是根据已注册的窗口类来创建一个新的窗口类，这一过程是一个复制的过程，新建窗口类复制了已注册窗口类的所有内容，但是把窗口类名和窗口过程改为自己预定义的窗口类名和窗口过程。
然后注册新建窗口类，
同时设置数据成员

m_pfnSuperWindowProc

为已注册窗口类的窗口过程。

#define
DECLARE_WND_SUPERCLASS(WndClassName, OrigWndClassName) /
static
ATL::CWndClassInfo& GetWndClassInfo() /
{ /
static
ATL::CWndClassInfo wc = /
{
/
{
sizeof(WNDCLASSEX), 0, StartWindowProc, /

0, 0, NULL, NULL, NULL, NULL, NULL,
WndClassName, NULL }, /
OrigWndClassName,
NULL, NULL, TRUE, 0, _T("") /
};
/
return
wc; /
}
超类化宏设置了窗口类信息结构体的成员变量

OrigWndClassName

为一个已注册窗口类的窗口类名。

CWindowImpl
::
Create（）函数中注册窗口类然后创建窗口实例。

ATOM atom =
T::GetWndClassInfo().Register(&m_pfnSuperWindowProc);
注册窗口类时传递了

m_pfnSuperWindowProc

作为参数，最终调用的是如下模板函数

template <class
T>
ATLINLINE ATOM
AtlModuleRegisterWndClassInfoT(_ATL_BASE_MODULE* pBaseModule, _ATL_WIN_MODULE*
pWinModule, typename T::_ATL_WNDCLASSINFO* p, WNDPROC* pProc, T)
{
···
if(p->m_atom
== 0)
{
if
(p->m_lpszOrigName != NULL)
{
ATLASSERT(pProc
!= NULL);
T::PCXSTR
lpsz = p->m_wc.lpszClassName;
WNDPROC
proc = p->m_wc.lpfnWndProc;

T::WNDCLASSEX
wc;
wc.cbSize
= sizeof(T::WNDCLASSEX);
//
Try global class
if(!T::GetClassInfoEx(NULL,
p->m_lpszOrigName, &wc))
{
//
try process local
if(!T::GetClassInfoEx(pBaseModule->m_hInst,
p->m_lpszOrigName, &wc))
{
ATLTRACE(atlTraceWindowing,
0, "ERROR : Could not obtain Window Class information for %s/n",
p->m_lpszOrigName);
return
0;
}
}
p->m_wc
= wc;
p->pWndProc
= p->m_wc.lpfnWndProc;
p->m_wc.lpszClassName
= lpsz;
p->m_wc.lpfnWndProc
= proc;
}

···
T::WNDCLASSEX
wcTemp;
wcTemp
= p->m_wc;
p->m_atom
= static_cast<ATOM>(T::GetClassInfoEx(p->m_wc.hInstance,
p->m_wc.lpszClassName, &wcTemp));
if
(p->m_atom == 0)
{
p->m_atom
= T::RegisterClassEx(pWinModule, &p->m_wc);
}
}

if
(p->m_lpszOrigName != NULL)
{
ATLASSERT(pProc
!= NULL);
ATLASSERT(p->pWndProc
!= NULL);
*pProc
= p->pWndProc;
}
return
p->m_atom;
}
函数判断如果有窗口超类化（p->m_lpszOrigName != NULL）则获取已注册窗口类的信息
wc
，然后

p->m_wc = wc;
p->pWndProc =
p->m_wc.lpfnWndProc;
p->m_wc.lpszClassName
= lpsz;
p->m_wc.lpfnWndProc
= proc;
以上语句的作用是：
令新建窗口类的

pWndProc

变量保存已注册窗口类窗口函数地址。

新建窗口类仅仅保留窗口类名和窗口过程函数不变，其余的都用子类窗口类相关信息替换。
注册新建窗口类，令新建窗口类

m_pfnSuperWindowProc

成员数据保存已注册窗口类的窗口过程函数地址。返回注册结果。