//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;
}
1072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
