MFC消息映射和命令路由

//wincore.cpp
BOOL
CWnd::CreateEx(DWORDdwExStyle,LPCTSTRlpszClassName,
LPCTSTR
lpszWindowName, DWORDdwStyle,
int
x, int y,intnWidth,
int nHeight,
HWND
hWndParent, HMENUnIDorHMenu,LPVOIDlpParam)
{
ASSERT(lpszClassName ==NULL||AfxIsValidString(lpszClassName)||
AfxIsValidAtom(lpszClassName));
ENSURE_ARG(lpszWindowName ==NULL||AfxIsValidString(lpszWindowName));

// allowmodification of several common create parameters
CREATESTRUCTcs;
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); //修改窗口处理函数为：AfxWndProc
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);

#ifdef
_DEBUG
if (hWnd ==NULL)
{
TRACE(traceAppMsg, 0,"Warning:Window creation failed: GetLastError returns 0x%8.8X\n",
GetLastError());
}
#endif

if (!AfxUnhookWindowCreate())
PostNcDestroy(); // cleanup ifCreateWindowEx fails too soon

if (hWnd ==NULL)
return
FALSE;
ASSERT(hWnd ==m_hWnd);// should have been set in send msg hook
return
TRUE;
}

// for child windows
BOOL
CWnd::PreCreateWindow(CREATESTRUCT&cs)
{
if (cs.lpszClass ==NULL)
{
// make surethe default window class is registered
VERIFY(AfxDeferRegisterClass(AFX_WND_REG));

// noWNDCLASS provided - use child window default
ASSERT(cs.style &WS_CHILD);
cs.lpszClass =_afxWnd;
}
return
TRUE;
}

// wincore.cpp
void
AFXAPI AfxHookWindowCreate(CWnd*pWnd)
{
_AFX_THREAD_STATE*pThreadState =_afxThreadState.GetData();
if (pThreadState->m_pWndInit==pWnd)
return;

if (pThreadState->m_hHookOldCbtFilter==NULL)
{
pThreadState->m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,

_AfxCbtFilterHook,NULL, ::GetCurrentThreadId());
if (pThreadState->m_hHookOldCbtFilter==NULL)
AfxThrowMemoryException();
}
ASSERT(pThreadState->m_hHookOldCbtFilter!=NULL);
ASSERT(pWnd !=NULL);
ASSERT(pWnd->m_hWnd==NULL); // only do once

ASSERT(pThreadState->m_pWndInit==NULL); // hook not already in progress
pThreadState->m_pWndInit =pWnd;
}

// wincore.cpp
LRESULT
CALLBACK
_AfxCbtFilterHook(intcode,WPARAMwParam,LPARAMlParam)
{
_AFX_THREAD_STATE*pThreadState =_afxThreadState.GetData();
if (code !=HCBT_CREATEWND)
{
// wait forHCBT_CREATEWND just pass others on...
return
CallNextHookEx(pThreadState->m_hHookOldCbtFilter,code,
wParam,lParam);
}

ASSERT(lParam !=NULL);
LPCREATESTRUCTlpcs = ((LPCBT_CREATEWND)lParam)->lpcs;
ASSERT(lpcs !=NULL);

CWnd*
pWndInit = pThreadState->m_pWndInit;
BOOL
bContextIsDLL = afxContextIsDLL;
if (pWndInit !=NULL|| (!(lpcs->style&WS_CHILD)
&& !bContextIsDLL))
{
// Note:special check to avoid subclassing the IME window
if (_afxDBCS)
{
// checkfor cheap CS_IME style first...
if(GetClassLong((HWND)wParam,GCL_STYLE)&CS_IME)
gotolCallNextHook;

// getclass name of the window that is being created
LPCTSTRpszClassName;
TCHARszClassName[_countof("ime")+1];
if(DWORD_PTR(lpcs->lpszClass) > 0xffff)
{
pszClassName=lpcs->lpszClass;
}
else
{
szClassName[0]='\0';
GlobalGetAtomName((ATOM)lpcs->lpszClass,szClassName,_countof(szClassName));
pszClassName=szClassName;
}

// alittle more expensive to test this way, but necessary...
if(::AfxInvariantStrICmp(pszClassName,_T("ime")) == 0)
gotolCallNextHook;
}

ASSERT(wParam !=NULL);// should be non-NULL HWND
HWNDhWnd = (HWND)wParam;
WNDPROColdWndProc;
if (pWndInit !=NULL)
{
AFX_MANAGE_STATE(pWndInit->m_pModuleState);

// thewindow should not be in the permanent map at this time
ASSERT(CWnd::FromHandlePermanent(hWnd) ==NULL);

//connect the HWND to pWndInit...
pWndInit->Attach(hWnd);
// allowother subclassing to occur first
pWndInit->PreSubclassWindow();

WNDPROC*pOldWndProc =pWndInit->GetSuperWndProcAddr();
ASSERT(pOldWndProc !=NULL);

//subclass the window with standard AfxWndProc
WNDPROCafxWndProc =AfxGetAfxWndProc();
oldWndProc= (WNDPROC)SetWindowLongPtr(hWnd,GWLP_WNDPROC,
(DWORD_PTR)afxWndProc);
ASSERT(oldWndProc !=NULL);
if(oldWndProc !=afxWndProc)
*pOldWndProc=oldWndProc;

pThreadState->m_pWndInit =NULL;
}
else
{
ASSERT(!bContextIsDLL); // should never get here

staticATOMs_atomMenu= 0;
boolbSubclass =true;

if(s_atomMenu == 0)
{
WNDCLASSEXwc;
memset(&wc, 0,sizeof(WNDCLASSEX));
wc.cbSize =sizeof(WNDCLASSEX);
s_atomMenu= (ATOM)::AfxCtxGetClassInfoEx(NULL,_T("#32768"),
&wc);
}

// Donot subclass menus.
if(s_atomMenu != 0)
{
ATOMatomWnd = (ATOM)::GetClassLongPtr(hWnd,GCW_ATOM);
if(atomWnd ==s_atomMenu)
bSubclass =false;
}
else
{
TCHARszClassName[256];
if(::GetClassName(hWnd,szClassName, 256))
{
szClassName[255]=NULL;
if(_tcscmp(szClassName,_T("#32768"))== 0)
bSubclass =false;
}
}
if(bSubclass)
{
//subclass the window with the proc which does gray backgrounds
oldWndProc= (WNDPROC)GetWindowLongPtr(hWnd,GWLP_WNDPROC);
if(oldWndProc !=NULL&&GetProp(hWnd,_afxOldWndProc)
==NULL)
{
SetProp(hWnd,_afxOldWndProc,oldWndProc);
if((WNDPROC)GetProp(hWnd,_afxOldWndProc)==oldWndProc)
{
GlobalAddAtom(_afxOldWndProc);
SetWindowLongPtr(hWnd,GWLP_WNDPROC, (DWORD_PTR)_AfxActivationWndProc);
ASSERT(oldWndProc!=NULL);
}
}
}
}
}

lCallNextHook:
LRESULT
lResult = CallNextHookEx(pThreadState->m_hHookOldCbtFilter,code,
wParam,lParam);

#ifndef
_AFXDLL
if (bContextIsDLL)
{
::UnhookWindowsHookEx(pThreadState->m_hHookOldCbtFilter);
pThreadState->m_hHookOldCbtFilter =NULL;
}
#endif
return
lResult;
}

//
LRESULT
CALLBACK
AfxWndProc(HWNDhWnd,UINT
nMsg, WPARAM
wParam, LPARAM
lParam)
{
// specialmessage which identifies the window as using AfxWndProc
if (nMsg ==WM_QUERYAFXWNDPROC)
return1;

// all othermessages route through message map
CWnd*
pWnd = CWnd::FromHandlePermanent(hWnd);
ASSERT(pWnd !=NULL);
ASSERT(pWnd==NULL ||pWnd->m_hWnd==hWnd);
if (pWnd ==NULL ||pWnd->m_hWnd!=hWnd)
return::DefWindowProc(hWnd,nMsg,wParam,lParam);
return
AfxCallWndProc(pWnd,hWnd,nMsg,wParam,lParam);
}

//
LRESULT
AFXAPI AfxCallWndProc(CWnd*pWnd,HWNDhWnd,UINTnMsg,
WPARAM
wParam = 0, LPARAMlParam = 0)
{
_AFX_THREAD_STATE*pThreadState =_afxThreadState.GetData();
MSG
oldState = pThreadState->m_lastSentMsg; // save for nesting
pThreadState->m_lastSentMsg.hwnd=hWnd;
pThreadState->m_lastSentMsg.message=nMsg;
pThreadState->m_lastSentMsg.wParam=wParam;
pThreadState->m_lastSentMsg.lParam=lParam;

#ifdef
_DEBUG
_AfxTraceMsg(_T("WndProc"),&pThreadState->m_lastSentMsg);
#endif

// Catchexceptions thrown outside the scope of a callback
// in debugbuilds and warn the user.
LRESULT
lResult;
TRY
{
#ifndef
_AFX_NO_OCC_SUPPORT
// specialcase for WM_DESTROY
if ((nMsg ==WM_DESTROY)&& (pWnd->m_pCtrlCont !=NULL))
pWnd->m_pCtrlCont->OnUIActivate(NULL);
#endif

// specialcase for WM_INITDIALOG
CRectrectOld;
DWORDdwStyle = 0;
if (nMsg ==WM_INITDIALOG)
_AfxPreInitDialog(pWnd, &rectOld,&dwStyle);

// delegateto object's WindowProc

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

// morespecial case for WM_INITDIALOG
if (nMsg ==WM_INITDIALOG)
_AfxPostInitDialog(pWnd,rectOld,dwStyle);
}
CATCH_ALL(e)
{
lResult=
AfxProcessWndProcException(e, &pThreadState->m_lastSentMsg);
TRACE(traceAppMsg, 0,"Warning:Uncaught exception in WindowProc (returning %ld).\n",
lResult);
DELETE_EXCEPTION(e);
}
END_CATCH_ALL

pThreadState->m_lastSentMsg =oldState;
return
lResult;
}

//
LRESULT
CWnd::WindowProc(UINTmessage,WPARAMwParam,LPARAMlParam)
{
// OnWndMsg doesmost of the work, except for DefWindowProc call
LRESULT
lResult = 0;
if (!OnWndMsg(message,wParam,lParam,&lResult))
lResult=
DefWindowProc(message,wParam,lParam);
return
lResult;
}

//
BOOL
CWnd::OnWndMsg(UINTmessage,WPARAMwParam,LPARAMlParam,LRESULT*pResult)
{
LRESULT
lResult = 0;
union
MessageMapFunctions mmf;
mmf.pfn = 0;
CInternalGlobalLockwinMsgLock;
// special casefor commands
if (message ==WM_COMMAND)
{

if (OnCommand(wParam,lParam))
{
lResult= 1;
gotoLReturnTrue;
}
return
FALSE;
}

// special casefor notifies

if (message ==
WM_NOTIFY)
{
NMHDR*pNMHDR = (NMHDR*)lParam;
if (pNMHDR->hwndFrom!=NULL &&OnNotify(wParam,lParam,&lResult))
gotoLReturnTrue;
return
FALSE;
}

// special casefor activation

if (message ==
WM_ACTIVATE)
_AfxHandleActivate(this,wParam,CWnd::FromHandle((HWND)lParam));

// special casefor set cursor HTERROR

if (message ==
WM_SETCURSOR&&

_AfxHandleSetCursor(this, (short)LOWORD(lParam),HIWORD(lParam)))
{
lResult= 1;
goto
LReturnTrue;
}

// special casefor windows that contain windowless ActiveX controls
BOOL
bHandled;

bHandled=
FALSE;
if ((m_pCtrlCont !=NULL)&& (m_pCtrlCont->m_nWindowlessControls > 0))
{
if (((message>=WM_MOUSEFIRST) && (message <=AFX_WM_MOUSELAST))||
((message>=
WM_KEYFIRST) && (message <=
WM_IME_KEYLAST))||
((message>=
WM_IME_SETCONTEXT) && (message <=
WM_IME_KEYUP)))
{
bHandled =
m_pCtrlCont->HandleWindowlessMessage(message,wParam,lParam,&lResult);
}
}
if (bHandled)
{
goto
LReturnTrue;
}

const AFX_MSGMAP*
pMessageMap;pMessageMap =
GetMessageMap();
UINT
iHash; iHash =(LOWORD((DWORD_PTR)pMessageMap) ^message)& (iHashMax-1);
winMsgLock.Lock(CRIT_WINMSGCACHE);
AFX_MSG_CACHE*pMsgCache;pMsgCache= &_afxMsgCache[iHash];
const
AFX_MSGMAP_ENTRY* lpEntry;
if (message ==pMsgCache->nMsg &&pMessageMap==pMsgCache->pMessageMap)
{
// cache hit
lpEntry=
pMsgCache->lpEntry;
winMsgLock.Unlock();
if (lpEntry ==NULL)
returnFALSE;

// cache hit,and it needs to be handled
if (message < 0xC000)
gotoLDispatch;
else
gotoLDispatchRegistered;
}
else
{
// not incache, look for it
pMsgCache->nMsg =message;
pMsgCache->pMessageMap =pMessageMap;

for (/* pMessageMap already init'ed */;pMessageMap->pfnGetBaseMap!=NULL;
pMessageMap= (*pMessageMap->pfnGetBaseMap)())
{
// Note:catch not so common but fatal mistake!!
// BEGIN_MESSAGE_MAP(CMyWnd, CMyWnd)
ASSERT(pMessageMap != (*pMessageMap->pfnGetBaseMap)());
if(message < 0xC000)
{
//constant window message
if((lpEntry =AfxFindMessageEntry(pMessageMap->lpEntries,
message,0, 0)) !=NULL)
{
pMsgCache->lpEntry =lpEntry;
winMsgLock.Unlock();
gotoLDispatch;
}
}
else
{
//registered windows message
lpEntry=
pMessageMap->lpEntries;
while((lpEntry =AfxFindMessageEntry(lpEntry, 0xC000, 0, 0)) !=NULL)
{
UINT*pnID = (UINT*)(lpEntry->nSig);
ASSERT(*pnID >= 0xC000 || *pnID== 0);
// must be successfully registered
if(*pnID ==message)
{
pMsgCache->lpEntry=lpEntry;
winMsgLock.Unlock();
goto
LDispatchRegistered;
}
lpEntry++; // keep lookingpast this one
}
}
}

pMsgCache->lpEntry =NULL;
winMsgLock.Unlock();
return
FALSE;
}

LDispatch:
ASSERT(message < 0xC000);

mmf.pfn =lpEntry->pfn;

switch (lpEntry->nSig)
{
default:
ASSERT(FALSE);
break;
case
AfxSig_l_p:
{
CPointpoint(lParam);
lResult= (this->*mmf.pfn_l_p)(point);
break;
}
case
AfxSig_b_D_v:
lResult= (this->*mmf.pfn_b_D)(CDC::FromHandle(reinterpret_cast<HDC>(wParam)));
break;

case
AfxSig_b_b_v:
lResult= (this->*mmf.pfn_b_b)(static_cast<BOOL>(wParam));
break;

case
AfxSig_b_u_v:
lResult= (this->*mmf.pfn_b_u)(static_cast<UINT>(wParam));
break;

case
AfxSig_b_h_v:
lResult= (this->*mmf.pfn_b_h)(reinterpret_cast<HANDLE>(wParam));
break;

case
AfxSig_i_u_v:
lResult= (this->*mmf.pfn_i_u)(static_cast<UINT>(wParam));
break;

case
AfxSig_C_v_v:
lResult=
reinterpret_cast<LRESULT>((this->*mmf.pfn_C_v)());
break;

case
AfxSig_v_u_W:
(this->*mmf.pfn_v_u_W)(static_cast<UINT>(wParam),
CWnd::FromHandle(reinterpret_cast<HWND>(lParam)));
break;

case
AfxSig_u_u_v:
lResult= (this->*mmf.pfn_u_u)(static_cast<UINT>(wParam));
break;

case
AfxSig_b_v_v:
lResult= (this->*mmf.pfn_b_v)();
break;

case
AfxSig_b_W_uu:
lResult= (this->*mmf.pfn_b_W_u_u)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),
LOWORD(lParam),HIWORD(lParam));
break;

case
AfxSig_b_W_COPYDATASTRUCT:
lResult= (this->*mmf.pfn_b_W_COPYDATASTRUCT)(
CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),
reinterpret_cast<COPYDATASTRUCT*>(lParam));
break;

case
AfxSig_b_v_HELPINFO:
lResult= (this->*mmf.pfn_b_HELPINFO)(reinterpret_cast<LPHELPINFO>(lParam));
break;

case
AfxSig_CTLCOLOR:
{
//special case for OnCtlColor to avoid too many temporary objects
ASSERT(message ==WM_CTLCOLOR);
AFX_CTLCOLOR*pCtl =reinterpret_cast<AFX_CTLCOLOR*>(lParam);
CDCdcTemp;
dcTemp.m_hDC =pCtl->hDC;
CWndwndTemp;
wndTemp.m_hWnd =pCtl->hWnd;
UINTnCtlType =pCtl->nCtlType;
// ifnot coming from a permanent window, use stack temporary
CWnd*pWnd =CWnd::FromHandlePermanent(wndTemp.m_hWnd);
if(pWnd ==NULL)
{
#ifndef
_AFX_NO_OCC_SUPPORT
//determine the site of the OLE control if it is one
COleControlSite*pSite;
if(m_pCtrlCont !=NULL&& (pSite = (COleControlSite*)
m_pCtrlCont->m_siteMap.GetValueAt(wndTemp.m_hWnd))!=NULL)
{
wndTemp.m_pCtrlSite =pSite;
}
#endif
pWnd= &wndTemp;
}
HBRUSHhbr = (this->*mmf.pfn_B_D_W_u)(&dcTemp,pWnd,nCtlType);
// fastdetach of temporary objects
dcTemp.m_hDC =NULL;
wndTemp.m_hWnd =NULL;
lResult=
reinterpret_cast<LRESULT>(hbr);
}
break;

case
AfxSig_CTLCOLOR_REFLECT:
{
//special case for CtlColor to avoid too many temporary objects
ASSERT(message ==WM_REFLECT_BASE+WM_CTLCOLOR);
AFX_CTLCOLOR*pCtl =reinterpret_cast<AFX_CTLCOLOR*>(lParam);
CDCdcTemp;
dcTemp.m_hDC =pCtl->hDC;
UINTnCtlType =pCtl->nCtlType;
HBRUSHhbr = (this->*mmf.pfn_B_D_u)(&dcTemp,nCtlType);
// fastdetach of temporary objects
dcTemp.m_hDC =NULL;
lResult=
reinterpret_cast<LRESULT>(hbr);
}
break;

case
AfxSig_i_u_W_u:
lResult= (this->*mmf.pfn_i_u_W_u)(LOWORD(wParam),
CWnd::FromHandle(reinterpret_cast<HWND>(lParam)),HIWORD(wParam));
break;

case
AfxSig_i_uu_v:
lResult= (this->*mmf.pfn_i_u_u)(LOWORD(wParam),HIWORD(wParam));
break;

case
AfxSig_i_W_uu:
lResult= (this->*mmf.pfn_i_W_u_u)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),
LOWORD(lParam),HIWORD(lParam));
break;

case
AfxSig_i_v_s:
lResult= (this->*mmf.pfn_i_s)(reinterpret_cast<LPTSTR>(lParam));
break;

case
AfxSig_l_w_l:
lResult= (this->*mmf.pfn_l_w_l)(wParam,lParam);
break;

case
AfxSig_l_uu_M:
lResult= (this->*mmf.pfn_l_u_u_M)(LOWORD(wParam),HIWORD(wParam),
CMenu::FromHandle(reinterpret_cast<HMENU>(lParam)));
break;

case
AfxSig_v_b_h:
(this->*mmf.pfn_v_b_h)(static_cast<BOOL>(wParam),
reinterpret_cast<HANDLE>(lParam));
break;

case
AfxSig_v_h_v:
(this->*mmf.pfn_v_h)(reinterpret_cast<HANDLE>(wParam));
break;

case
AfxSig_v_h_h:
(this->*mmf.pfn_v_h_h)(reinterpret_cast<HANDLE>(wParam),
reinterpret_cast<HANDLE>(lParam));
break;

case
AfxSig_v_v_v:
(this->*mmf.pfn_v_v)();
break;

case
AfxSig_v_u_v:
(this->*mmf.pfn_v_u)(static_cast<UINT>(wParam));
break;

case
AfxSig_v_u_u:
(this->*mmf.pfn_v_u_u)(static_cast<UINT>(wParam),static_cast<UINT>(lParam));
break;

case
AfxSig_v_uu_v:
(this->*mmf.pfn_v_u_u)(LOWORD(wParam),HIWORD(wParam));
break;

case
AfxSig_v_v_ii:
(this->*mmf.pfn_v_i_i)(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));
break;

case
AfxSig_v_u_uu:
(this->*mmf.pfn_v_u_u_u)(static_cast<UINT>(wParam),LOWORD(lParam),HIWORD(lParam));
break;

case
AfxSig_v_u_ii:
(this->*mmf.pfn_v_u_i_i)(static_cast<UINT>(wParam),LOWORD(lParam),HIWORD(lParam));
break;

case
AfxSig_v_w_l:
(this->*mmf.pfn_v_w_l)(wParam,lParam);
break;

case
AfxSig_MDIACTIVATE:
(this->*mmf.pfn_v_b_W_W)(m_hWnd ==reinterpret_cast<HWND>(lParam),
CWnd::FromHandle(reinterpret_cast<HWND>(lParam)),
CWnd::FromHandle(reinterpret_cast<HWND>(wParam)));
break;

case
AfxSig_v_D_v:
(this->*mmf.pfn_v_D)(CDC::FromHandle(reinterpret_cast<HDC>(wParam)));
break;

case
AfxSig_v_M_v:
(this->*mmf.pfn_v_M)(CMenu::FromHandle(reinterpret_cast<HMENU>(wParam)));
break;

case
AfxSig_v_M_ub:
(this->*mmf.pfn_v_M_u_b)(CMenu::FromHandle(reinterpret_cast<HMENU>(wParam)),
GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));
break;

case
AfxSig_v_W_v:
(this->*mmf.pfn_v_W)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)));
break;

case
AfxSig_v_v_W:
(this->*mmf.pfn_v_W)(CWnd::FromHandle(reinterpret_cast<HWND>(lParam)));
break;

case
AfxSig_v_W_uu:
(this->*mmf.pfn_v_W_u_u)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),LOWORD(lParam),
HIWORD(lParam));
break;

case
AfxSig_v_W_p:
{
CPointpoint(lParam);
(this->*mmf.pfn_v_W_p)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),point);
}
break;

case
AfxSig_v_W_h:
(this->*mmf.pfn_v_W_h)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),
reinterpret_cast<HANDLE>(lParam));
break;

case
AfxSig_ACTIVATE:
(this->*mmf.pfn_v_u_W_b)(LOWORD(wParam),
CWnd::FromHandle(reinterpret_cast<HWND>(lParam)),HIWORD(wParam));
break;

case
AfxSig_SCROLL:
case
AfxSig_SCROLL_REFLECT:
{
//special case for WM_VSCROLL and WM_HSCROLL
ASSERT(message ==WM_VSCROLL||message ==WM_HSCROLL||
message==
WM_VSCROLL+WM_REFLECT_BASE||
message == WM_HSCROLL+WM_REFLECT_BASE);
intnScrollCode = (short)LOWORD(wParam);
intnPos = (short)HIWORD(wParam);
if(lpEntry->nSig==AfxSig_SCROLL)
(this->*mmf.pfn_v_u_u_W)(nScrollCode,nPos,
CWnd::FromHandle(reinterpret_cast<HWND>(lParam)));
else
(this->*mmf.pfn_v_u_u)(nScrollCode,nPos);
}
break;

case
AfxSig_v_v_s:
(this->*mmf.pfn_v_s)(reinterpret_cast<LPTSTR>(lParam));
break;

case
AfxSig_v_u_cs:
(this->*mmf.pfn_v_u_cs)(static_cast<UINT>(wParam),reinterpret_cast<LPCTSTR>(lParam));
break;

case
AfxSig_OWNERDRAW:
(this->*mmf.pfn_v_i_s)(static_cast<int>(wParam),reinterpret_cast<LPTSTR>(lParam));
lResult=
TRUE;
break;

case
AfxSig_i_i_s:
lResult= (this->*mmf.pfn_i_i_s)(static_cast<int>(wParam),reinterpret_cast<LPTSTR>(lParam));
break;

case
AfxSig_u_v_p:
{
CPointpoint(lParam);
lResult= (this->*mmf.pfn_u_p)(point);
}
break;

case
AfxSig_u_v_v:
lResult= (this->*mmf.pfn_u_v)();
break;

case
AfxSig_v_b_NCCALCSIZEPARAMS:
(this->*mmf.pfn_v_b_NCCALCSIZEPARAMS)(static_cast<BOOL>(wParam),
reinterpret_cast<NCCALCSIZE_PARAMS*>(lParam));
break;

case
AfxSig_v_v_WINDOWPOS:
(this->*mmf.pfn_v_v_WINDOWPOS)(reinterpret_cast<WINDOWPOS*>(lParam));
break;

case
AfxSig_v_uu_M:
(this->*mmf.pfn_v_u_u_M)(LOWORD(wParam),HIWORD(wParam),reinterpret_cast<HMENU>(lParam));
break;

case
AfxSig_v_u_p:
{
CPointpoint(lParam);
(this->*mmf.pfn_v_u_p)(static_cast<UINT>(wParam),point);
}
break;

case
AfxSig_SIZING:
(this->*mmf.pfn_v_u_pr)(static_cast<UINT>(wParam),reinterpret_cast<LPRECT>(lParam));
lResult=
TRUE;
break;

case
AfxSig_MOUSEWHEEL:
lResult= (this->*mmf.pfn_b_u_s_p)(LOWORD(wParam),
(short)HIWORD(wParam),
CPoint(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam)));
if (!lResult)
returnFALSE;
break;
case
AfxSig_MOUSEHWHEEL:
(this->*mmf.pfn_MOUSEHWHEEL)(LOWORD(wParam),(short)HIWORD(wParam),
CPoint(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam)));
break;
case
AfxSig_l:
lResult= (this->*mmf.pfn_l_v)();
if (lResult != 0)
returnFALSE;
break;
case
AfxSig_u_W_u:
lResult= (this->*mmf.pfn_u_W_u)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),static_cast<UINT>(lParam));
break;
case
AfxSig_v_u_M:
(this->*mmf.pfn_v_u_M)(static_cast<UINT>(wParam),CMenu::FromHandle(reinterpret_cast<HMENU>(lParam)));
break;
case
AfxSig_u_u_M:
lResult= (this->*mmf.pfn_u_u_M)(static_cast<UINT>(wParam),CMenu::FromHandle(reinterpret_cast<HMENU>(lParam)));
break;
case
AfxSig_u_v_MENUGETOBJECTINFO:
lResult= (this->*mmf.pfn_u_v_MENUGETOBJECTINFO)(reinterpret_cast<MENUGETOBJECTINFO*>(lParam));
break;
case
AfxSig_v_M_u:
(this->*mmf.pfn_v_M_u)(CMenu::FromHandle(reinterpret_cast<HMENU>(wParam)),static_cast<UINT>(lParam));
break;
case
AfxSig_v_u_LPMDINEXTMENU:
(this->*mmf.pfn_v_u_LPMDINEXTMENU)(static_cast<UINT>(wParam),reinterpret_cast<LPMDINEXTMENU>(lParam));
break;
case
AfxSig_APPCOMMAND:
(this->*mmf.pfn_APPCOMMAND)(CWnd::FromHandle(reinterpret_cast<HWND>(wParam)),static_cast<UINT>(GET_APPCOMMAND_LPARAM(lParam)),static_cast<UINT>(GET_DEVICE_LPARAM(lParam)),static_cast<UINT>(GET_KEYSTATE_LPARAM(lParam)));
lResult=
TRUE;
break;
case
AfxSig_RAWINPUT:
(this->*mmf.pfn_RAWINPUT)(static_cast<UINT>(GET_RAWINPUT_CODE_WPARAM(wParam)),reinterpret_cast<HRAWINPUT>(lParam));
break;
case
AfxSig_u_u_u:
lResult= (this->*mmf.pfn_u_u_u)(static_cast<UINT>(wParam),static_cast<UINT>(lParam));
break;
case
AfxSig_MOUSE_XBUTTON:
(this->*mmf.pfn_MOUSE_XBUTTON)(static_cast<UINT>(GET_KEYSTATE_WPARAM(wParam)),static_cast<UINT>(GET_XBUTTON_WPARAM(wParam)),CPoint(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam)));
lResult=
TRUE;
break;
case
AfxSig_MOUSE_NCXBUTTON:
(this->*mmf.pfn_MOUSE_NCXBUTTON)(static_cast<short>(GET_NCHITTEST_WPARAM(wParam)),static_cast<UINT>(GET_XBUTTON_WPARAM(wParam)),CPoint(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam)));
lResult=
TRUE;
break;
case
AfxSig_INPUTLANGCHANGE:
(this->*mmf.pfn_INPUTLANGCHANGE)(static_cast<BYTE>(wParam),static_cast<UINT>(lParam));
lResult=
TRUE;
break;
case
AfxSig_INPUTDEVICECHANGE:
(this->*mmf.pfn_INPUTDEVICECHANGE)(GET_DEVICE_CHANGE_LPARAM(wParam));
break;
case
AfxSig_v_u_hkl:
(this->*mmf.pfn_v_u_h)(static_cast<UINT>(wParam),reinterpret_cast<HKL>(lParam));
break;
}
goto
LReturnTrue;

LDispatchRegistered:
// for registered windows messages
ASSERT(message >= 0xC000);
ASSERT(sizeof(mmf) ==sizeof(mmf.pfn));
mmf.pfn =lpEntry->pfn;
lResult= (this->*mmf.pfn_l_w_l)(wParam,lParam);

LReturnTrue:
if (pResult !=NULL)
*pResult=
lResult;
return
TRUE;
}

// wincore.cpp
LRESULT
CWnd::DefWindowProc(UINTnMsg,WPARAMwParam,LPARAMlParam)
{
if (m_pfnSuper !=NULL)
return::CallWindowProc(m_pfnSuper,m_hWnd,nMsg,wParam,lParam);

WNDPROC
pfnWndProc;
if ((pfnWndProc = *GetSuperWndProcAddr())==NULL)
return::DefWindowProc(m_hWnd,nMsg,wParam,lParam);
else
return::CallWindowProc(pfnWndProc,m_hWnd,nMsg,wParam,lParam);
}

//
BOOL
CWnd::OnCommand(WPARAMwParam,LPARAMlParam)
// return TRUE ifcommand invocation was attempted
{
UINT
nID = LOWORD(wParam);
HWND
hWndCtrl = (HWND)lParam;
int
nCode = HIWORD(wParam);

// defaultrouting for command messages (through closure table)

if (hWndCtrl ==NULL)
{
// zero IDsfor normal commands are not allowed
if (nID == 0)
returnFALSE;

// make surecommand has not become disabled before routing
CTestCmdUIstate;
state.m_nID =nID;
OnCmdMsg(nID,CN_UPDATE_COMMAND_UI,&state,NULL);
if (!state.m_bEnabled)
{
TRACE(traceAppMsg, 0,"Warning:not executing disabled command %d\n",nID);
returnTRUE;
}

// menu oraccelerator
nCode=
CN_COMMAND;
}
else
{
// controlnotification
ASSERT(nID == 0 || ::IsWindow(hWndCtrl));

if (_afxThreadState->m_hLockoutNotifyWindow==m_hWnd)
returnTRUE; // locked out - ignore control notification

// reflectnotification to child window control
if (ReflectLastMsg(hWndCtrl))
returnTRUE; // eaten by child

// zero IDsfor normal commands are not allowed
if (nID == 0)
returnFALSE;
}

#ifdef
_DEBUG
if (nCode < 0 &&nCode!= (int)0x8000)
TRACE(traceAppMsg, 0,"ImplementationWarning: control notification = $%X.\n",
nCode);
#endif

return
OnCmdMsg(nID,
nCode, NULL,
NULL);
}

BOOL
CFrameWnd::OnCommand(WPARAMwParam,LPARAMlParam)
// return TRUE ifcommand invocation was attempted
{
HWND
hWndCtrl = (HWND)lParam;
UINT
nID = LOWORD(wParam);

CFrameWnd*pFrameWnd =GetTopLevelFrame();
ENSURE_VALID(pFrameWnd);
if (pFrameWnd->m_bHelpMode&&hWndCtrl ==NULL &&
nID!=
ID_HELP && nID !=
ID_DEFAULT_HELP&& nID !=
ID_CONTEXT_HELP)
{
// route ashelp
if (!SendMessage(WM_COMMANDHELP,0,HID_BASE_COMMAND+nID))
SendMessage(WM_COMMAND,ID_DEFAULT_HELP);
return
TRUE;
}

// route asnormal command
return
CWnd::OnCommand(wParam,lParam);
}

BOOL CFrameWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra,

AFX_CMDHANDLERINFO* pHandlerInfo)

{

CPushRoutingFrame push(this);

// pump through current view FIRST

CView* pView = GetActiveView();

if (pView != NULL &&
pView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

// then pump through frame

if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

// last but not least, pump through app

CWinApp* pApp = AfxGetApp();

if (pApp != NULL && pApp->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

return FALSE;

}

BOOL CView::OnCmdMsg(UINT nID, int nCode, void* pExtra,

AFX_CMDHANDLERINFO* pHandlerInfo)

{

// first pump through pane

if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

// then pump through document

if (m_pDocument != NULL)

{

// special state for saving view before routing to document

CPushRoutingView push(this);

return
m_pDocument->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);

}

return FALSE;

}

//

BOOL CCmdTarget::OnCmdMsg(UINT nID, int nCode, void* pExtra,

AFX_CMDHANDLERINFO* pHandlerInfo)

{

#ifndef _AFX_NO_OCC_SUPPORT

// OLE control events are a special case

if (nCode == CN_EVENT)

{

ENSURE(afxOccManager != NULL);

return afxOccManager->OnEvent(this, nID, (AFX_EVENT*)pExtra, pHandlerInfo);

}

#endif // !_AFX_NO_OCC_SUPPORT

// determine the message number and code (packed into nCode)

const AFX_MSGMAP* pMessageMap;

const AFX_MSGMAP_ENTRY* lpEntry;

UINT nMsg = 0;

#ifndef _AFX_NO_DOCOBJECT_SUPPORT

if (nCode == CN_OLECOMMAND)

{

BOOL bResult = FALSE;

const AFX_OLECMDMAP* pOleCommandMap;

const AFX_OLECMDMAP_ENTRY* pEntry;

ENSURE_ARG(pExtra != NULL);

COleCmdUI* pUI = (COleCmdUI*) pExtra;

const GUID* pguidCmdGroup = pUI->m_pguidCmdGroup;

#ifdef _AFXDLL

for (pOleCommandMap = GetCommandMap(); pOleCommandMap->pfnGetBaseMap != NULL && !bResult;

pOleCommandMap = pOleCommandMap->pfnGetBaseMap())

#else

for (pOleCommandMap = GetCommandMap(); pOleCommandMap != NULL && !bResult;

pOleCommandMap = pOleCommandMap->pBaseMap)

#endif

{

for (pEntry = pOleCommandMap->lpEntries;

pEntry->cmdID != 0 && pEntry->nID != 0 && !bResult;

pEntry++)

{

if (nID == pEntry->cmdID &&

IsEqualNULLGuid(pguidCmdGroup, pEntry->pguid))

{

pUI->m_nID = pEntry->nID;

bResult = TRUE;

}

}

}

return bResult;

}

#endif

if (nCode != CN_UPDATE_COMMAND_UI)

{

nMsg = HIWORD(nCode);

nCode = LOWORD(nCode);

}

// for backward compatibility HIWORD(nCode)==0 is WM_COMMAND

if (nMsg == 0)

nMsg = WM_COMMAND;

// look through message map to see if it applies to us

for (pMessageMap = GetMessageMap(); pMessageMap->pfnGetBaseMap != NULL;

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

{

// Note: catches BEGIN_MESSAGE_MAP(CMyClass, CMyClass)!

ASSERT(pMessageMap != (*pMessageMap->pfnGetBaseMap)());

lpEntry = AfxFindMessageEntry(pMessageMap->lpEntries, nMsg, nCode, nID);

if (lpEntry != NULL)

{

// found it

#ifdef _DEBUG

if (nCode == CN_COMMAND)

TRACE(traceCmdRouting, 1, "SENDING command id 0x%04X to %hs target.\n", nID,

GetRuntimeClass()->m_lpszClassName);

else if (nCode > CN_COMMAND)

TRACE(traceCmdRouting, 1, "SENDING control notification %d from control id 0x%04X to %hs window.\n",

nCode, nID, GetRuntimeClass()->m_lpszClassName);

#endif //_DEBUG

return _AfxDispatchCmdMsg(this, nID, nCode,

lpEntry->pfn, pExtra, lpEntry->nSig, pHandlerInfo);

}

}

return FALSE; // not handled

}

BOOL CDocument::OnCmdMsg(UINT nID, int nCode, void* pExtra,

AFX_CMDHANDLERINFO* pHandlerInfo)

{

if (CCmdTarget::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

// otherwise check template

if (m_pDocTemplate != NULL &&

m_pDocTemplate->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))

return TRUE;

return FALSE;

}

BOOL CDocTemplate::OnCmdMsg(UINT nID, int nCode, void* pExtra,

AFX_CMDHANDLERINFO* pHandlerInfo)

{

BOOL bReturn;

CCmdTarget* pFactory = DYNAMIC_DOWNCAST(CCmdTarget, m_pAttachedFactory);

if (nCode == CN_OLE_UNREGISTER && pFactory != NULL)

bReturn =
pFactory->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);

else

bReturn =
CCmdTarget::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);

return bReturn;

}