![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to window.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / src|
Return to window.cpp CVS log | Up to [WindowsNT SDKs] / mstools / mfc / src |
1.1 root 1: // This is a part of the Microsoft Foundation Classes C++ library.
2: // Copyright (C) 1992 Microsoft Corporation
3: // All rights reserved.
4: //
5: // This source code is only intended as a supplement to the
6: // Microsoft Foundation Classes Reference and Microsoft
7: // QuickHelp documentation provided with the library.
8: // See these sources for detailed information regarding the
9: // Microsoft Foundation Classes product.
10:
11:
12: #include "afxwin.h"
13: #pragma hdrstop
14:
15: #include "winhand_.h"
16: #include "window_.h"
17:
18: #ifdef AFX_CORE_SEG
19: #pragma code_seg(AFX_CORE_SEG)
20: #endif
21:
22: #ifdef _DEBUG
23: #include "trace_.h"
24: #undef THIS_FILE
25: static char BASED_CODE THIS_FILE[] = __FILE__;
26: #define new DEBUG_NEW
27: #endif
28:
29: /////////////////////////////////////////////////////////////////////////////
30: // CHandleMap implementation
31:
32: CObject*
33: CHandleMap::FromHandle(HANDLE h)
34: {
35: if (h == NULL)
36: return NULL;
37:
38: void* p;
39: if (LookupPermanent(h, p))
40: return (CObject*)p; // return permanent one
41: else if (LookupTemporary(h, p))
42: return (CObject*)p; // return last temporary one
43:
44: // This handle wasn't created by us, so we must create a temporary
45: // C++ object to wrap it. We don't want the user to see this memory
46: // allocation, so we turn tracing off.
47: #ifdef _DEBUG
48: BOOL bEnable = AfxEnableMemoryTracking(FALSE);
49: #endif
50: CObject* pTemp = NewTempObject(h);
51: #ifdef _NTWIN
52: temporaryMap.SetAt((LPVOID)h, pTemp);
53: #else
54: temporaryMap.SetAt((WORD)h, pTemp);
55: #endif
56: #ifdef _DEBUG
57: AfxEnableMemoryTracking(bEnable);
58: #endif
59: return pTemp;
60: }
61:
62: void
63: CHandleMap::DeleteTemp()
64: {
65: POSITION pos = temporaryMap.GetStartPosition();
66: while (pos != NULL)
67: {
68: #ifdef _NTWIN
69: LPVOID h; // not used
70: #else
71: WORD h; // not used
72: #endif
73: void* p;
74: temporaryMap.GetNextAssoc(pos, h, p);
75: DeleteTempObject((CObject*)p); // free it up
76: }
77:
78: temporaryMap.RemoveAll(); // free up dictionary links etc
79: }
80:
81: /////////////////////////////////////////////////////////////////////////////
82: IMPLEMENT_DYNAMIC(CButton, CWnd)
83: IMPLEMENT_DYNAMIC(CListBox, CWnd)
84: IMPLEMENT_DYNAMIC(CComboBox, CWnd)
85:
86: IMPLEMENT_DYNAMIC(CWnd, CObject)
87:
88:
89: char NEAR _afxWnd[] = "AfxWnd";
90: char NEAR _afxMDIFrameWnd[] = "AfxMDIFrameWnd";
91: char NEAR _afxFrameWnd[] = "AfxFrameWnd";
92:
93:
94: /////////////////////////////////////////////////////////////////////////////
95: // Special bootstrap globals
96:
97: static CWnd* pWndInit = NULL;
98: static CDialog* pDlgInit = NULL;
99:
100: /////////////////////////////////////////////////////////////////////////////
101: // Official way to send message to a CWnd
102:
103: struct CLastState
104: {
105: MSG msg;
106: };
107: static CLastState NEAR lastState;
108: // global for last state of call to 'WindowProc'
109:
110: LONG _AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT message,
111: UINT wParam, LONG lParam)
112: {
113: LONG lResult;
114: CLastState oldState = lastState; // save for nesting
115:
116: lastState.msg.hwnd = hWnd;
117: lastState.msg.message = message;
118: lastState.msg.wParam = wParam;
119: lastState.msg.lParam = lParam;
120:
121: #ifdef _DEBUG
122: if (afxTraceFlags & 4)
123: AfxTraceMsg("WndProc", &lastState.msg);
124: #endif
125:
126: // Catch exceptions thrown outside the scope of a callback
127: // in debug builds and warn the user.
128: TRY
129: {
130: lResult = pWnd->WindowProc(message, wParam, lParam);
131: }
132: CATCH (CException, e)
133: {
134: if (message == WM_CREATE)
135: lResult = -1;
136: else
137: lResult = 0;
138: TRACE("Warning: Uncaught exception in WindowProc (returning %ld)\n",
139: lResult);
140: ASSERT(FALSE);
141: }
142: END_CATCH
143:
144: lastState = oldState;
145: return lResult;
146: }
147:
148: const MSG* CWnd::GetCurrentMessage()
149: {
150: // fill in time and position when asked for
151: lastState.msg.time = ::GetMessageTime();
152: *((DWORD*)&lastState.msg.pt) = ::GetMessagePos();
153: return &lastState.msg;
154: }
155:
156: LONG CWnd::Default()
157: // call DefWindowProc with the last message
158: {
159: return DefWindowProc(lastState.msg.message,
160: lastState.msg.wParam, lastState.msg.lParam);
161: }
162:
163: /////////////////////////////////////////////////////////////////////////////
164: // Map from HWND to CWnd*
165:
166: class NEAR CWndHandleMap : public CHandleMap
167: {
168: public:
169: CObject* NewTempObject(HANDLE h)
170: {
171: // don't add in permanent
172: CWnd* p = new CWnd();
173: p->m_hWnd = (HWND)h; // set after constructed
174: return p;
175: }
176: void DeleteTempObject(CObject* ob)
177: {
178: ASSERT(ob->IsKindOf(RUNTIME_CLASS(CWnd)));
179: ((CWnd*)ob)->m_hWnd = NULL; // clear before destructed
180: delete ob;
181: }
182: CWndHandleMap()
183: { }
184: };
185: static CWndHandleMap NEAR hWndMap;
186:
187: CWnd*
188: CWnd::FromHandle(HWND hWnd)
189: {
190: return (CWnd*)hWndMap.FromHandle(hWnd);
191: }
192:
193: CWnd*
194: CWnd::FromHandlePermanent(HWND hWnd)
195: {
196: // only look in the permanent map - does no allocations
197: void* p;
198: return (hWndMap.LookupPermanent(hWnd, p)) ? (CWnd*)p : NULL;
199: }
200:
201: void
202: CWnd::DeleteTempMap()
203: {
204: hWndMap.DeleteTemp();
205: }
206:
207: BOOL
208: CWnd::Attach(HWND hWnd)
209: {
210: ASSERT(m_hWnd == NULL); // only attach once, detach on destroy
211: if (hWnd == NULL)
212: return FALSE;
213: hWndMap.SetPermanent(m_hWnd = hWnd, this);
214: return TRUE;
215: }
216:
217: HWND
218: CWnd::Detach()
219: {
220: HWND hWnd;
221: if ((hWnd = m_hWnd) != NULL)
222: hWndMap.RemovePermanent(m_hWnd);
223: m_hWnd = NULL;
224: return hWnd;
225: }
226:
227:
228: /////////////////////////////////////////////////////////////////////////////
229: // One main WndProc for all CWnd's and derived classes
230:
231: LONG FAR PASCAL AFX_EXPORT
232: AfxWndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam)
233: {
234: register CWnd* pWnd;
235:
236: pWnd = CWnd::FromHandlePermanent(hWnd);
237: ASSERT(pWnd != NULL);
238: ASSERT(pWnd->m_hWnd == hWnd);
239:
240: LONG lResult = _AfxCallWndProc(pWnd, hWnd, message, wParam, lParam);
241:
242: return lResult;
243: }
244:
245: // Special case for remaining dialog cases
246: // Most messages will go through the window proc (AfxWndProc) of the
247: // subclassed dialog. Some messages like WM_SETFONT and WM_INITDIALOG
248: // are sent directly to the dialog proc only. These messages cannot be
249: // passed on to DefWindowProc() or infinite recursion will result!
250: // In responding to these messages, you shouldn't call the Default handler
251: LONG FAR PASCAL AFX_EXPORT
252: _AfxDlgProc(HWND hWnd, register UINT message, UINT wParam, LONG lParam)
253: {
254: register CDialog* pDlg;
255:
256: // test for special case (Win 3.0 will call dialog proc instead
257: // of SendMessage for these two messages).
258: if (message != WM_SETFONT && message != WM_INITDIALOG)
259: return 0L; // normal handler
260:
261: // assume it is already wired up to a permanent one
262: pDlg = (CDialog*) CWnd::FromHandlePermanent(hWnd);
263: ASSERT(pDlg != NULL);
264: ASSERT(pDlg->m_hWnd == hWnd);
265:
266: // prepare for callback, make it look like message map call
267: LONG lResult = 0;
268: CLastState oldState = lastState; // save for nesting
269:
270: lastState.msg.hwnd = hWnd;
271: lastState.msg.message = message;
272: lastState.msg.wParam = wParam;
273: lastState.msg.lParam = lParam;
274:
275: TRY
276: {
277: if (message == WM_SETFONT)
278: pDlg->OnSetFont(CFont::FromHandle((HFONT)wParam));
279: else // WM_INITDIALOG
280: lResult = pDlg->OnInitDialog();
281: }
282: CATCH (CException, e)
283: {
284: // fall through
285: TRACE("Warning: something went wrong in dialog init\n");
286: pDlg->EndDialog(IDCANCEL); // something went wrong
287: ASSERT(FALSE);
288: }
289: END_CATCH
290:
291: lastState = oldState;
292: return lResult;
293: }
294:
295: /////////////////////////////////////////////////////////////////////////////
296: // Window creation hook
297: #ifdef STRICT
298: static HHOOK pfnOldSendMsgHook = NULL;
299: #else
300: static HOOKPROC pfnOldSendMsgHook = NULL;
301: #endif
302:
303: #pragma optimize("q", off) // disable pcode opt (Win 3.0 compatibility)
304:
305: void FAR PASCAL AFX_EXPORT
306: _AfxSendMsgHook(int code, UINT wParam, LONG lParam)
307: {
308: struct HOOKINFO // Hook info struct passed by send message hook
309: {
310: LONG lParam;
311: UINT wParam;
312: UINT msg;
313: HWND hWnd;
314: };
315: HOOKINFO FAR* hookInfo;
316:
317: if (code < 0)
318: {
319: ::DefHookProc(code, wParam, lParam, &pfnOldSendMsgHook);
320: return;
321: }
322:
323: ASSERT(pWndInit != NULL);
324: hookInfo = (HOOKINFO FAR*)lParam;
325: HWND hWnd = hookInfo->hWnd;
326:
327: // ignore non-creation messages
328: if (hookInfo->msg != WM_GETMINMAXINFO &&
329: hookInfo->msg != WM_NCCREATE)
330: {
331: // not being constructed
332: return;
333: }
334:
335: // Connect the HWND to pWndInit...
336: pWndInit->Attach(hWnd);
337:
338: // Subclass the window by replacing its window proc addr...
339: WNDPROC oldWndProc = (WNDPROC)::SetWindowLong(hWnd, GWL_WNDPROC,
340: (DWORD)AfxWndProc);
341: if (oldWndProc != (WNDPROC)AfxWndProc)
342: {
343: *(pWndInit->GetSuperWndProcAddr()) = oldWndProc; // save if not default
344: }
345:
346: // Unhook the send message hook since we don't need it any more
347: ::UnhookWindowsHook(WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook);
348: pWndInit = NULL;
349: }
350:
351: #pragma optimize("", on) // return to default optimizations
352:
353: void _AfxHookWindowCreate(register CWnd* pWnd)
354: {
355: #ifndef _WINDLL
356: if (_afxSetWindowsHookExProc == NULL)
357: {
358: pfnOldSendMsgHook = ::SetWindowsHook(WH_CALLWNDPROC,
359: (HOOKPROC)_AfxSendMsgHook);
360: }
361: else
362: {
363: #ifdef STRICT
364: #ifdef _NTWIN
365: pfnOldSendMsgHook = (HHOOK)(*_afxSetWindowsHookExProc)(
366: WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook, NULL, 0);
367: #else
368: pfnOldSendMsgHook = (HHOOK)(*_afxSetWindowsHookExProc)(
369: WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook, AfxGetInstanceHandle(),
370: GetCurrentTask());
371: #endif
372: #else
373: #ifdef _NTWIN
374: pfnOldSendMsgHook = (HOOKPROC)(*_afxSetWindowsHookExProc)(
375: WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook, NULL, 0);
376: #else
377: pfnOldSendMsgHook = (HOOKPROC)(*_afxSetWindowsHookExProc)(
378: WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook, AfxGetInstanceHandle(),
379: GetCurrentTask());
380: #endif
381: #endif
382: }
383: #else // _WINDLL
384: pfnOldSendMsgHook = ::SetWindowsHook(WH_CALLWNDPROC,
385: (HOOKPROC)_AfxSendMsgHook);
386: #endif // _WINDLL
387:
388: ASSERT(pWnd != NULL);
389: ASSERT(pWnd->m_hWnd == NULL); // only do once
390:
391: ASSERT(pWndInit == NULL); // hook not already in progress
392: pWndInit = pWnd;
393: }
394:
395: BOOL _AfxUnhookWindowCreate()
396: // return TRUE if already unhooked
397: {
398: if (pWndInit == NULL)
399: return TRUE; // already unhooked => window create success
400: ::UnhookWindowsHook(WH_CALLWNDPROC, (HOOKPROC)_AfxSendMsgHook);
401: pWndInit = NULL;
402: return FALSE;
403: }
404:
405: /////////////////////////////////////////////////////////////////////////////
406: // CWnd creation
407:
408: BOOL CWnd::CreateEx(DWORD dwExStyle, LPCSTR lpClassName,
409: LPCSTR lpWindowName, DWORD dwStyle,
410: int x, int y, int nWidth, int nHeight,
411: HWND hWndParent, HMENU nIDorHMenu)
412: {
413: _AfxHookWindowCreate(this);
414: HWND hWnd = ::CreateWindowEx(dwExStyle, lpClassName,
415: lpWindowName, dwStyle, x, y, nWidth, nHeight,
416: hWndParent, nIDorHMenu, AfxGetInstanceHandle(), NULL);
417:
418: _AfxUnhookWindowCreate();
419: if (hWnd == NULL)
420: return NULL;
421: ASSERT(hWnd == m_hWnd); // should have been set in send msg hook
422: return TRUE;
423: }
424:
425: // for child windows
426: BOOL CWnd::Create(LPCSTR lpClassName,
427: LPCSTR lpWindowName, DWORD dwStyle,
428: const RECT& rect,
429: const CWnd* pParentWnd, UINT nID)
430: {
431: ASSERT(pParentWnd != NULL);
432:
433: if (lpClassName == NULL)
434: lpClassName = _afxWnd;
435:
436: return CreateEx(0, lpClassName, lpWindowName,
437: dwStyle | WS_CHILD,
438: rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
439: pParentWnd->GetSafeHwnd(), (HMENU)nID);
440: }
441:
442: CWnd::~CWnd()
443: {
444: DestroyWindow();
445: }
446:
447:
448: #ifdef _NTWIN
449: struct _AFXCTLCOLOR {
450: HWND hWnd;
451: HDC hDC;
452: UINT nCtlType;
453: };
454:
455: LRESULT CWnd::OnNTCtlColor(WPARAM wParam, LPARAM lParam)
456: {
457: struct _AFXCTLCOLOR ctl;
458:
459: ctl.hDC = (HDC)wParam;
460: ctl.hWnd = (HWND)lParam;
461: ctl.nCtlType = GetCurrentMessage()->message - WM_CTLCOLORMSGBOX;
462:
463: ASSERT(ctl.nCtlType >= CTLCOLOR_MSGBOX);
464: ASSERT(ctl.nCtlType <= CTLCOLOR_STATIC);
465:
466: return SendMessage(WM_CTLCOLOR, 0, (LPARAM)&ctl);
467: }
468: #endif
469:
470: void CWnd::OnDestroy()
471: {
472: #ifndef _WINDLL
473: // Automatically quit when the main window is destroyed.
474: if (AfxGetApp()->m_pMainWnd == this)
475: ::PostQuitMessage(0);
476: #endif // _WINDLL
477: Default();
478: }
479:
480: void CWnd::OnNcDestroy()
481: {
482: // WM_NCDESTROY is the absolute LAST message sent.
483: if (AfxGetApp()->m_pMainWnd == this)
484: AfxGetApp()->m_pMainWnd = NULL;
485:
486: Default();
487: Detach();
488: ASSERT(m_hWnd == NULL);
489:
490: // call special post-cleanup routine
491: PostNcDestroy();
492: }
493:
494: void CWnd::PostNcDestroy()
495: {
496: // default to nothing
497: }
498:
499: #ifdef _DEBUG
500: void CWnd::AssertValid() const
501: {
502: ASSERT(m_hWnd == NULL ||
503: (m_hWnd == (HWND)1 && this == &CWnd::wndBottom) ||
504: ::IsWindow(m_hWnd));
505: void* p;
506: ASSERT(m_hWnd == NULL ||
507: (m_hWnd == (HWND)1 && this == &CWnd::wndBottom) ||
508: hWndMap.LookupPermanent(m_hWnd, p) ||
509: hWndMap.LookupTemporary(m_hWnd, p));
510: }
511:
512: void CWnd::Dump(CDumpContext& dc) const
513: {
514: CObject::Dump(dc);
515:
516: dc << "with window information:\n";
517: dc << "m_hWnd = " << (void NEAR*)m_hWnd;
518:
519: if ((UINT)m_hWnd > 1)
520: {
521: char szBuf [64];
522:
523: GetWindowText(szBuf, sizeof (szBuf));
524: dc << "\ncaption = \"" << szBuf << "\"";
525:
526: ::GetClassName(m_hWnd, szBuf, sizeof (szBuf));
527: dc << "\nclass name = \"" << szBuf << "\"";
528:
529: CRect rect;
530: GetWindowRect(&rect);
531: dc << "\nrect = " << rect;
532:
533: dc << "\nparent CWnd* = " << (void*)GetParent();
534:
535: dc << "\nstyle = " << (void FAR*)::GetWindowLong(m_hWnd, GWL_STYLE);
536: if (::GetWindowLong(m_hWnd, GWL_STYLE) & WS_CHILD)
537: dc << "\nid = " << ::GetWindowWord(m_hWnd, GWW_ID);
538: }
539: }
540: #endif
541:
542: BOOL
543: CWnd::DestroyWindow()
544: {
545: if (m_hWnd == NULL)
546: return FALSE;
547:
548: void* p;
549: BOOL bInPermanentMap = hWndMap.LookupPermanent(m_hWnd, p);
550: BOOL bRet = ::DestroyWindow(m_hWnd);
551: // Note that 'this' may have been deleted at this point.
552: if (bInPermanentMap)
553: {
554: // Should have been detached by OnNcDestroy
555: ASSERT(!hWndMap.LookupPermanent(m_hWnd, p));
556: }
557: else
558: {
559: // Detach after DestroyWindow called just in case
560: Detach();
561: }
562: return bRet;
563: }
564:
565: /////////////////////////////////////////////////////////////////////////////
566: // Default CWnd implementation
567:
568: LONG CWnd::DefWindowProc(UINT nMsg, UINT wParam, LONG lParam)
569: {
570: WNDPROC pfnWndProc;
571:
572: if ((pfnWndProc = *GetSuperWndProcAddr()) == NULL)
573: return ::DefWindowProc(m_hWnd, nMsg, wParam, lParam);
574: else
575: #ifdef STRICT
576: return ::CallWindowProc(pfnWndProc, m_hWnd, nMsg, wParam, lParam);
577: #else
578: return ::CallWindowProc((FARPROC)pfnWndProc, m_hWnd, nMsg, wParam, lParam);
579: #endif
580: }
581:
582: WNDPROC* CWnd::GetSuperWndProcAddr()
583: {
584: static WNDPROC pfnSuper = NULL;
585: ASSERT(pfnSuper == NULL); // should never be changed !!!
586: // if this is non-NULL, then a derived class of CWnd
587: // forgot to override 'superWndProc' as well as 'className'
588: return &pfnSuper;
589: }
590:
591: BOOL CWnd::PreTranslateMessage(MSG*)
592: {
593: // no default processing
594: return FALSE;
595: }
596:
597: /////////////////////////////////////////////////////////////////////////////
598: // CWnd will delegate owner draw messages to self drawing controls
599:
600: // Drawing: for all 4 control types
601: void CWnd::OnDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
602: {
603: UINT nType;
604: if ((nType = lpDrawItemStruct->CtlType) == ODT_MENU)
605: {
606: CMenu* pMenu = CMenu::FromHandle((HMENU)lpDrawItemStruct->hwndItem);
607: if (pMenu != NULL)
608: {
609: pMenu->DrawItem(lpDrawItemStruct);
610: return;
611: }
612: }
613: else
614: {
615: CWnd* pChild = CWnd::FromHandlePermanent(lpDrawItemStruct->hwndItem);
616: if (pChild != NULL)
617: {
618: if (nType == ODT_BUTTON &&
619: pChild->IsKindOf(RUNTIME_CLASS(CButton)))
620: {
621: ((CButton*)pChild)->DrawItem(lpDrawItemStruct);
622: return;
623: }
624: else if (nType == ODT_LISTBOX &&
625: pChild->IsKindOf(RUNTIME_CLASS(CListBox)))
626: {
627: ((CListBox*)pChild)->DrawItem(lpDrawItemStruct);
628: return;
629: }
630: else if (nType == ODT_COMBOBOX &&
631: pChild->IsKindOf(RUNTIME_CLASS(CComboBox)))
632: {
633: ((CComboBox*)pChild)->DrawItem(lpDrawItemStruct);
634: return;
635: }
636: }
637: }
638: // not handled - do default
639: Default();
640: }
641:
642: // Drawing: for all 4 control types
643: int CWnd::OnCompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct)
644: {
645: CWnd* pChild = CWnd::FromHandlePermanent(lpCompareItemStruct->hwndItem);
646: if (pChild != NULL)
647: {
648: UINT nType = lpCompareItemStruct->CtlType;
649: if (nType == ODT_LISTBOX &&
650: pChild->IsKindOf(RUNTIME_CLASS(CListBox)))
651: {
652: return ((CListBox*)pChild)->CompareItem(lpCompareItemStruct);
653: }
654: else if (nType == ODT_COMBOBOX &&
655: pChild->IsKindOf(RUNTIME_CLASS(CComboBox)))
656: {
657: return ((CComboBox*)pChild)->CompareItem(lpCompareItemStruct);
658: }
659: }
660: // not handled - do default
661: return (int)Default();
662: }
663:
664: void CWnd::OnDeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct)
665: {
666: CWnd* pChild = CWnd::FromHandlePermanent(lpDeleteItemStruct->hwndItem);
667: if (pChild != NULL)
668: {
669: UINT nType = lpDeleteItemStruct->CtlType;
670: if (nType == ODT_LISTBOX &&
671: pChild->IsKindOf(RUNTIME_CLASS(CListBox)))
672: {
673: ((CListBox*)pChild)->DeleteItem(lpDeleteItemStruct);
674: return;
675: }
676: else if (nType == ODT_COMBOBOX &&
677: pChild->IsKindOf(RUNTIME_CLASS(CComboBox)))
678: {
679: ((CComboBox*)pChild)->DeleteItem(lpDeleteItemStruct);
680: return;
681: }
682: }
683: // not handled - do default
684: Default();
685: }
686:
687:
688: static CMenu* FindPopupMenuFromID(CMenu* pMenu, UINT nID)
689: {
690: // walk through all items, looking for ID match
691: UINT nItems = pMenu->GetMenuItemCount();
692: for (int iItem = 0; iItem < (int)nItems; iItem++)
693: {
694: if (pMenu->GetMenuState(iItem, MF_BYPOSITION) & MF_POPUP)
695: {
696: // recurse to child popup
697: CMenu* pPopup = FindPopupMenuFromID(pMenu->GetSubMenu(iItem), nID);
698: // try recursing
699: if (pPopup != NULL)
700: return pPopup;
701: }
702: else if (pMenu->GetMenuItemID(iItem) == nID)
703: {
704: // it is a normal item inside our popup
705: return pMenu;
706: }
707: }
708: // not found
709: return NULL;
710: }
711:
712: // Measure item implementation relies on unique control/menu IDs
713: void CWnd::OnMeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
714: {
715: UINT nType;
716: if ((nType = lpMeasureItemStruct->CtlType) == ODT_MENU)
717: {
718: ASSERT(lpMeasureItemStruct->CtlID == 0);
719: CMenu* pMenu = FindPopupMenuFromID(GetMenu(),
720: lpMeasureItemStruct->itemID);
721: if (pMenu != NULL)
722: {
723: pMenu->MeasureItem(lpMeasureItemStruct);
724: return;
725: }
726: else
727: {
728: TRACE("Warning: unknown WM_MEASUREITEM request for"
729: " menu item 0x%04X\n", lpMeasureItemStruct->itemID);
730: }
731: }
732: else
733: {
734: HWND hWndChild = ::GetDlgItem(m_hWnd, lpMeasureItemStruct->CtlID);
735: CWnd* pChild;
736: if (hWndChild != NULL &&
737: (pChild = CWnd::FromHandlePermanent(hWndChild)) != NULL)
738: {
739: if (nType == ODT_LISTBOX &&
740: pChild->IsKindOf(RUNTIME_CLASS(CListBox)))
741: {
742: ((CListBox*)pChild)->MeasureItem(lpMeasureItemStruct);
743: return;
744: }
745: else if (nType == ODT_COMBOBOX &&
746: pChild->IsKindOf(RUNTIME_CLASS(CComboBox)))
747: {
748: ((CComboBox*)pChild)->MeasureItem(lpMeasureItemStruct);
749: return;
750: }
751: }
752: }
753: // not handled - do default
754: Default();
755: }
756:
757: /////////////////////////////////////////////////////////////////////////////
758: // CFrameWnd
759:
760: IMPLEMENT_DYNAMIC(CFrameWnd, CWnd)
761:
762: CFrameWnd::CFrameWnd()
763: {
764: ASSERT(m_hWnd == NULL);
765: m_hAccelTable = NULL;
766: }
767:
768: CFrameWnd::~CFrameWnd()
769: {
770: if (m_hAccelTable != NULL)
771: ::FreeResource(m_hAccelTable);
772: }
773:
774: void CFrameWnd::PostNcDestroy()
775: {
776: // default for frame windows is to allocate them on the heap
777: // the default post-cleanup is to 'delete this'.
778: // never explicitly call 'delete' on a CFrameWnd, use DestroyWindow instead
779: delete this;
780: }
781:
782: #ifdef _DEBUG
783: void CFrameWnd::AssertValid() const
784: {
785: CWnd::AssertValid();
786: }
787:
788: void CFrameWnd::Dump(CDumpContext& dc) const
789: {
790: CWnd::Dump(dc);
791: dc << "\nm_hAccelTable = " << (UINT) m_hAccelTable;
792: }
793: #endif
794:
795: BOOL CFrameWnd::LoadAccelTable(LPCSTR lpAccelTableName)
796: {
797: ASSERT(m_hAccelTable == NULL); // only do once
798: ASSERT(lpAccelTableName != NULL);
799:
800: m_hAccelTable = ::LoadAccelerators(AfxGetResourceHandle(),
801: lpAccelTableName);
802: return (m_hAccelTable != NULL);
803: }
804:
805: /////////////////////////////////////////////////////////////////////////////
806: // Creation and window tree access
807:
808: BOOL CFrameWnd::Create(LPCSTR lpClassName,
809: LPCSTR lpWindowName,
810: DWORD dwStyle, const RECT& rect,
811: const CWnd* pParentWnd,
812: LPCSTR lpMenuName)
813: {
814: HMENU hMenu = NULL;
815:
816: if (lpClassName == NULL)
817: lpClassName = _afxFrameWnd;
818:
819: if (lpMenuName != NULL)
820: {
821: // load in a menu that will get destroyed when window gets destroyed
822: hMenu = ::LoadMenu(AfxGetResourceHandle(), lpMenuName);
823: if (hMenu == NULL)
824: {
825: TRACE("Warning: failed to load menu for CFrameWnd\n");
826: return FALSE;
827: }
828: }
829:
830: if (!CreateEx(0L, lpClassName, lpWindowName, dwStyle,
831: rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
832: pParentWnd->GetSafeHwnd(), hMenu))
833: {
834: TRACE("Warning: failed to create CFrameWnd\n");
835: return FALSE;
836: }
837: return TRUE;
838: }
839:
840: CFrameWnd* CFrameWnd::GetChildFrame()
841: {
842: return this;
843: }
844:
845: CFrameWnd* CFrameWnd::GetParentFrame()
846: {
847: return this;
848: }
849:
850: BOOL CFrameWnd::PreTranslateMessage(MSG* pMsg)
851: {
852: return (m_hAccelTable != NULL &&
853: ::TranslateAccelerator(m_hWnd, m_hAccelTable, pMsg));
854: }
855:
856:
857: /////////////////////////////////////////////////////////////////////////////
858: // Additional helpers for WNDCLASS init
859:
860: const char* AfxRegisterWndClass(UINT nClassStyle,
861: HCURSOR hCursor, HBRUSH hbrBackground, HICON hIcon)
862: {
863: // Returns a temporary string name for the class
864: // Save in a CString if you want to use it for a long time
865: WNDCLASS wndcls;
866: static char szName[64]; // 1 global string
867:
868: // generate a synthetic name for this class
869: if (hCursor == NULL && hbrBackground == NULL && hIcon == NULL)
870: wsprintf(szName, "Afx:%x", nClassStyle);
871: else
872: wsprintf(szName, "Afx:%x:%x:%x:%x", nClassStyle,
873: (UINT) hCursor, (UINT) hbrBackground, (UINT) hIcon);
874:
875: // see if the class already exists
876: if (::GetClassInfo(AfxGetInstanceHandle(), szName, &wndcls))
877: {
878: // already registered, assert everything is good
879: ASSERT(wndcls.style == nClassStyle);
880: ASSERT(wndcls.hIcon == hIcon);
881: ASSERT(wndcls.hCursor == hCursor);
882: ASSERT(wndcls.hbrBackground == hbrBackground);
883: return szName;
884: }
885:
886: // otherwise we need to register a new class
887: wndcls.style = nClassStyle;
888: wndcls.lpfnWndProc = AfxWndProc;
889: wndcls.cbClsExtra = wndcls.cbWndExtra = 0;
890: wndcls.hInstance = AfxGetInstanceHandle();
891: wndcls.hIcon = hIcon;
892: wndcls.hCursor = hCursor;
893: wndcls.hbrBackground = hbrBackground;
894: wndcls.lpszMenuName = NULL;
895: wndcls.lpszClassName = szName;
896: if (!::RegisterClass(&wndcls))
897: AfxThrowResourceException();
898: return szName;
899: }
900:
901:
902:
903: /////////////////////////////////////////////////////////////////////////////
904: // Dialogs have 2-phase construction
905:
906: IMPLEMENT_DYNAMIC(CDialog, CWnd)
907:
908: CDialog::CDialog()
909: {
910: ASSERT(m_hWnd == NULL);
911:
912: m_hBrushCtlBk = NULL;
913: VERIFY(SetCtlBkColor(::GetSysColor(COLOR_BTNFACE)));
914: }
915:
916: CDialog::~CDialog()
917: {
918: if (m_hBrushCtlBk != NULL)
919: ::DeleteObject(m_hBrushCtlBk);
920: m_hBrushCtlBk = NULL;
921: }
922:
923: #ifdef _DEBUG
924: void
925: CDialog::AssertValid() const
926: {
927: CWnd::AssertValid();
928: ASSERT(m_hWnd != (HWND)1);
929: }
930: #endif
931:
932: // Modeless
933: BOOL
934: CDialog::Create(LPCSTR lpTemplateName, CWnd* pParentWnd)
935: {
936: if (pParentWnd == NULL)
937: pParentWnd = AfxGetApp()->m_pMainWnd;
938:
939: _AfxHookWindowCreate(this);
940: HWND hWnd = ::CreateDialog(AfxGetResourceHandle(),
941: lpTemplateName, pParentWnd->GetSafeHwnd(),
942: (DLGPROC)_AfxDlgProc);
943: _AfxUnhookWindowCreate();
944:
945: return (m_hWnd = hWnd) != NULL;
946: }
947:
948: BOOL
949: CDialog::CreateIndirect(const void FAR* lpDialogTemplate,
950: CWnd* pParentWnd)
951: {
952: if (pParentWnd == NULL)
953: pParentWnd = AfxGetApp()->m_pMainWnd;
954:
955: _AfxHookWindowCreate(this);
956: #ifdef _NTWIN
957: HWND hWnd = ::CreateDialogIndirect(AfxGetResourceHandle(),
958: (LPDLGTEMPLATE)lpDialogTemplate, pParentWnd->GetSafeHwnd(),
959: (DLGPROC)_AfxDlgProc);
960: #else
961: HWND hWnd = ::CreateDialogIndirect(AfxGetResourceHandle(),
962: lpDialogTemplate, pParentWnd->GetSafeHwnd(),
963: (DLGPROC)_AfxDlgProc);
964: #endif
965: _AfxUnhookWindowCreate();
966:
967: return (m_hWnd = hWnd) != NULL;
968: }
969:
970: void
971: CDialog::OnSetFont(CFont*)
972: {
973: // ignore it
974: }
975:
976: BOOL
977: CDialog::OnInitDialog()
978: {
979: return TRUE; // set focus to first one
980: }
981:
982:
983: BOOL
984: CDialog::SetCtlBkColor(COLORREF clrCtlBk)
985: {
986: if (m_hBrushCtlBk != NULL)
987: ::DeleteObject(m_hBrushCtlBk);
988: m_hBrushCtlBk = NULL;
989:
990: if (clrCtlBk == 0xFFFFFFFF)
991: {
992: // -1 means do not handle any WM_CTLCOLOR messages
993: ASSERT(m_hBrushCtlBk == NULL);
994: return TRUE;
995: }
996:
997: m_hBrushCtlBk = ::CreateSolidBrush(clrCtlBk);
998: return m_hBrushCtlBk != NULL ? TRUE : FALSE;
999: }
1000:
1001: HBRUSH
1002: CDialog::OnCtlColor(CDC* pDC, CWnd* /* pWnd */, UINT nCtlColor)
1003: {
1004: if (m_hBrushCtlBk == NULL ||
1005: nCtlColor == CTLCOLOR_LISTBOX ||
1006: nCtlColor == CTLCOLOR_EDIT ||
1007: nCtlColor == CTLCOLOR_MSGBOX)
1008: return (HBRUSH)Default();
1009:
1010: // Use new look AFX colors
1011: // Set the background color for controls
1012: LOGBRUSH logbrush;
1013: if (::GetObject(m_hBrushCtlBk, sizeof(LOGBRUSH), (LPSTR)&logbrush) != 0)
1014: {
1015: pDC->SetBkColor(logbrush.lbColor);
1016: }
1017: else
1018: {
1019: TRACE("Warning: couldn't set background color for CTLCOLOR\n");
1020: }
1021: return m_hBrushCtlBk;
1022: }
1023:
1024: BEGIN_MESSAGE_MAP(CDialog, CWnd)
1025: ON_WM_CTLCOLOR()
1026: END_MESSAGE_MAP()
1027:
1028: /////////////////////////////////////////////////////////////////////////////
1029: // Dialog Proc support
1030:
1031: BOOL
1032: CDialog::PreTranslateMessage(MSG* pMsg)
1033: {
1034: // for modeless processing (or modal)
1035: ASSERT(m_hWnd != NULL);
1036:
1037: // filter both messages to dialog and from children
1038: return ::IsDialogMessage(m_hWnd, pMsg);
1039: }
1040:
1041: WNDPROC*
1042: CDialog::GetSuperWndProcAddr()
1043: {
1044: static WNDPROC pfnSuper;
1045: return &pfnSuper;
1046: }
1047:
1048: /////////////////////////////////////////////////////////////////////////////
1049: // CModalDialog
1050:
1051: IMPLEMENT_DYNAMIC(CModalDialog, CDialog)
1052:
1053: BEGIN_MESSAGE_MAP(CModalDialog, CDialog)
1054: ON_COMMAND(IDOK, OnOK)
1055: ON_COMMAND(IDCANCEL, OnCancel)
1056: END_MESSAGE_MAP()
1057:
1058: // Constructors just save parameters
1059: CModalDialog::CModalDialog(LPCSTR lpTemplateName, CWnd* pParentWnd)
1060: {
1061: m_lpDialogTemplate = lpTemplateName;
1062: m_hDialogTemplate = NULL;
1063: m_pParentWnd = pParentWnd;
1064: }
1065:
1066: CModalDialog::CModalDialog(UINT nIDTemplate, CWnd* pParentWnd)
1067: {
1068: m_lpDialogTemplate = MAKEINTRESOURCE(nIDTemplate);
1069: m_hDialogTemplate = NULL;
1070: m_pParentWnd = pParentWnd;
1071: }
1072:
1073: BOOL
1074: CModalDialog::CreateIndirect(HANDLE hDialogTemplate)
1075: {
1076: // must be called on an empty constructed CModalDialog
1077: ASSERT(m_lpDialogTemplate == NULL);
1078: ASSERT(m_hDialogTemplate == NULL);
1079:
1080: m_hDialogTemplate = hDialogTemplate;
1081: return TRUE; // always ok (DoModal actually brings up dialog)
1082: }
1083:
1084: #ifdef _DEBUG
1085: void
1086: CModalDialog::AssertValid() const
1087: {
1088: CDialog::AssertValid();
1089: }
1090:
1091: void
1092: CModalDialog::Dump(CDumpContext& dc) const
1093: {
1094: CDialog::Dump(dc);
1095: dc << "\nm_lpDialogTemplate = " << m_lpDialogTemplate << "\n";
1096: dc << "m_hDialogTemplate = " << m_hDialogTemplate << "\n";
1097: dc << "m_pParentWnd = " << (void *)m_pParentWnd;
1098: }
1099: #endif
1100:
1101: int
1102: CModalDialog::DoModal()
1103: {
1104: HWND hWndParent;
1105: int nResult;
1106:
1107: // can be constructed with a resource template or CreateIndirect
1108: ASSERT(m_lpDialogTemplate != NULL || m_hDialogTemplate != NULL);
1109:
1110: // find parent HWND
1111: if (m_pParentWnd != NULL)
1112: hWndParent = m_pParentWnd->m_hWnd;
1113: else
1114: hWndParent = AfxGetApp()->m_pMainWnd->GetSafeHwnd();
1115:
1116: _AfxHookWindowCreate(this);
1117: if (m_lpDialogTemplate != NULL)
1118: {
1119: nResult = ::DialogBox(AfxGetResourceHandle(), m_lpDialogTemplate,
1120: hWndParent, (DLGPROC)_AfxDlgProc);
1121: }
1122: else
1123: {
1124: #ifdef _NTWIN
1125: nResult = ::DialogBoxIndirect(AfxGetResourceHandle(),
1126: (LPDLGTEMPLATE)m_hDialogTemplate, hWndParent, (DLGPROC)_AfxDlgProc);
1127: #else
1128: nResult = ::DialogBoxIndirect(AfxGetResourceHandle(), m_hDialogTemplate,
1129: hWndParent, (DLGPROC)_AfxDlgProc);
1130: #endif
1131: }
1132:
1133: _AfxUnhookWindowCreate(); // just in case
1134: Detach(); // just in case
1135: return nResult;
1136: }
1137:
1138: /////////////////////////////////////////////////////////////////////////////
1139: // Standard CModalDialog implementation
1140:
1141: void
1142: CModalDialog::OnOK()
1143: {
1144: EndDialog(IDOK);
1145: }
1146:
1147: void
1148: CModalDialog::OnCancel()
1149: {
1150: EndDialog(IDCANCEL);
1151: }
1152:
1153: /////////////////////////////////////////////////////////////////////////////
1154: // CRect for creating windows with the default position/size
1155: const CRect NEAR CFrameWnd::rectDefault(CW_USEDEFAULT, CW_USEDEFAULT,
1156: 0 /* 2*CW_USEDEFAULT */, 0 /* 2*CW_USEDEFAULT */);
1157:
1158: // CWnds for setting z-order with SetWindowPos's pWndInsertAfter parameter
1159: const CWnd NEAR CWnd::wndTop((HWND)0);
1160: const CWnd NEAR CWnd::wndBottom((HWND)1);
1161: const CWnd NEAR CWnd::wndTopMost((HWND)-1);
1162: const CWnd NEAR CWnd::wndNoTopMost((HWND)-2);
1163:
1164: /////////////////////////////////////////////////////////////////////////////
1165: // Message table implementation
1166:
1167: CMessageMap CWnd::messageMap =
1168: {
1169: NULL, // end of chain of message maps
1170: (CMessageEntry FAR*) &CWnd::_messageEntries
1171: };
1172:
1173: CMessageMap* CWnd::GetMessageMap() const
1174: {
1175: return &CWnd::messageMap;
1176: }
1177:
1178:
1179: CMessageEntry BASED_CODE CWnd::_messageEntries[] =
1180: {
1181: ON_WM_COMPAREITEM()
1182: ON_WM_MEASUREITEM()
1183: ON_WM_DRAWITEM()
1184: ON_WM_DELETEITEM()
1185: ON_WM_CTLCOLOR()
1186: ON_WM_DESTROY()
1187: ON_WM_NCDESTROY()
1188: #ifdef _NTWIN
1189: ON_MESSAGE(WM_CTLCOLORMSGBOX, OnNTCtlColor)
1190: ON_MESSAGE(WM_CTLCOLOREDIT, OnNTCtlColor)
1191: ON_MESSAGE(WM_CTLCOLORLISTBOX, OnNTCtlColor)
1192: ON_MESSAGE(WM_CTLCOLORBTN, OnNTCtlColor)
1193: ON_MESSAGE(WM_CTLCOLORDLG, OnNTCtlColor)
1194: ON_MESSAGE(WM_CTLCOLORSCROLLBAR, OnNTCtlColor)
1195: ON_MESSAGE(WM_CTLCOLORSTATIC, OnNTCtlColor)
1196: #endif
1197:
1198: { 0, 0, AfxSig_end, (AFX_PMSG)0 }
1199: };
1200:
1201: union MessageMapFunctions
1202: {
1203: AFX_PMSG pfn; // generic member function pointer
1204:
1205: // specific type safe variants
1206: BOOL (CWnd::*pfn_bD)(CDC *);
1207: BOOL (CWnd::*pfn_bb)(BOOL);
1208: BOOL (CWnd::*pfn_bWww)(CWnd*, UINT, UINT);
1209: HBRUSH (CWnd::*pfn_hDWw)(CDC *, CWnd*, UINT);
1210: int (CWnd::*pfn_iwWw)(UINT, CWnd*, UINT);
1211: int (CWnd::*pfn_iWww)(CWnd*, UINT, UINT);
1212: int (CWnd::*pfn_is)(LPSTR);
1213: LONG (CWnd::*pfn_lwl)(UINT, LONG);
1214: LONG (CWnd::*pfn_lwwM)(UINT, UINT, CMenu *);
1215: void (CWnd::*pfn_vv)(void);
1216:
1217: void (CWnd::*pfn_vw)(UINT);
1218: void (CWnd::*pfn_vww)(UINT, UINT);
1219: void (CWnd::*pfn_vvii)(int, int);
1220: void (CWnd::*pfn_vwww)(UINT, UINT, UINT);
1221: void (CWnd::*pfn_vwii)(UINT, int, int);
1222: void (CWnd::*pfn_vwl)(UINT, LONG);
1223: void (CWnd::*pfn_vbWW)(BOOL, CWnd*, CWnd*);
1224: void (CWnd::*pfn_vD)(CDC *);
1225: void (CWnd::*pfn_vM)(CMenu *);
1226: void (CWnd::*pfn_vMwb)(CMenu *, UINT, BOOL);
1227:
1228: void (CWnd::*pfn_vW)(CWnd*);
1229: void (CWnd::*pfn_vWww)(CWnd*, UINT, UINT);
1230: void (CWnd::*pfn_vWh)(CWnd*, HANDLE);
1231: void (CWnd::*pfn_vwW)(UINT, CWnd*);
1232: void (CWnd::*pfn_vwWb)(UINT, CWnd*, BOOL);
1233: void (CWnd::*pfn_vwwW)(UINT, UINT, CWnd*);
1234: void (CWnd::*pfn_vs)(LPSTR);
1235: UINT (CWnd::*pfn_wp)(CPoint);
1236: UINT (CWnd::*pfn_wv)(void);
1237: BOOL (CWnd::*pfn_bh)(HANDLE);
1238: void (CWnd::*pfn_vPOS)(WINDOWPOS FAR*);
1239: void (CWnd::*pfn_vCALC)(NCCALCSIZE_PARAMS FAR*);
1240: #ifdef _NTWIN
1241: void (CWnd::*pfn_vwp)(UINT, CPoint);
1242: void (CWnd::*pfn_vwwh)(UINT, UINT, HANDLE);
1243: #endif
1244: };
1245:
1246: /////////////////////////////////////////////////////////////////////////////
1247: // Routines for fast search of message maps
1248:
1249:
1250: // Hand tuned routine
1251:
1252: #pragma optimize("qgel", off) // assembler cannot be globally optimized
1253:
1254: #ifdef _NTWIN
1255: // C versions of search routines
1256: static inline CMessageEntry FAR*
1257: FindMessageEntry(CMessageEntry FAR* lpEntry, UINT nMsg, UINT nID)
1258: {
1259: while (lpEntry->nSig != AfxSig_end)
1260: {
1261: if (lpEntry->nMessage == nMsg && lpEntry->nID == nID)
1262: return lpEntry;
1263: lpEntry++;
1264: }
1265: return NULL; // not found
1266: }
1267:
1268: #else
1269: static CMessageEntry FAR* NEAR
1270: FindMessageEntry(CMessageEntry FAR* lpEntry, UINT nMsg, UINT nID)
1271: {
1272: _asm
1273: {
1274: LES BX,lpEntry
1275: MOV AX,nMsg
1276: MOV DX,nID
1277: __loop:
1278: MOV CX,WORD PTR ES:[BX+4] ; nSig (0 => end)
1279: JCXZ __failed
1280: CMP AX,WORD PTR ES:[BX] ; nMessage
1281: JE __found_1
1282: __next:
1283: ADD BX,SIZE CMessageEntry
1284: JMP __loop
1285: __found_1:
1286: CMP DX,WORD PTR ES:[BX+2] ; nID
1287: JNE __next
1288: // found a match
1289: MOV WORD PTR lpEntry,BX
1290: MOV WORD PTR lpEntry+2,ES
1291: JMP __end
1292: __failed:
1293: XOR AX,AX
1294: MOV WORD PTR lpEntry,AX
1295: MOV WORD PTR lpEntry+2,AX
1296: __end:
1297: }
1298: return lpEntry;
1299: }
1300: #endif //_NTWIN
1301:
1302: #pragma optimize("", on) // return to default optimizations
1303:
1304:
1305: /////////////////////////////////////////////////////////////////////////////
1306:
1307: #ifndef iHashMax
1308: // iHashMax must be a power of two
1309: #ifdef _NEARDATA
1310: #define iHashMax 64
1311: #else
1312: #define iHashMax 256
1313: #endif
1314: #endif
1315:
1316: struct MsgCache
1317: {
1318: UINT nMsg;
1319: CMessageEntry FAR* lpEntry;
1320: CMessageMap* pMessageMap;
1321: };
1322:
1323: MsgCache _afxMsgCache[iHashMax];
1324:
1325: LONG
1326: CWnd::WindowProc(UINT nMsg, UINT wParam, LONG lParam)
1327: {
1328: register CMessageMap* pMessageMap;
1329: CMessageEntry FAR* lpEntry;
1330:
1331: if (nMsg == WM_COMMAND) // special case for commands
1332: {
1333: if (OnCommand(wParam, lParam))
1334: return 1L; // command handled
1335: else
1336: return (LONG)DefWindowProc(nMsg, wParam, lParam); // call default handler
1337: }
1338:
1339: pMessageMap = GetMessageMap();
1340: UINT iHash = (_AFX_FP_OFF(pMessageMap) ^ nMsg) & (iHashMax-1);
1341: MsgCache& msgCache = _afxMsgCache[iHash];
1342:
1343: if (nMsg == msgCache.nMsg && pMessageMap == msgCache.pMessageMap)
1344: {
1345: // Cache hit
1346: lpEntry = msgCache.lpEntry;
1347: if (lpEntry == NULL)
1348: return (LONG)DefWindowProc(nMsg, wParam, lParam);
1349: else if (nMsg < 0xC000)
1350: goto LDispatch;
1351: else
1352: goto LDispatchRegistered;
1353: }
1354: else
1355: {
1356: // not in cache, look for it
1357: msgCache.nMsg = nMsg;
1358: msgCache.pMessageMap = pMessageMap;
1359:
1360: for (/* pMessageMap already init'ed */; pMessageMap != NULL;
1361: pMessageMap = pMessageMap->pBaseMessageMap)
1362: {
1363: // This may loop forever if the message maps are not properly
1364: // chained together. Make sure each window class's message map
1365: // points to the base window class's message map.
1366:
1367: if (nMsg < 0xC000)
1368: {
1369: // constant window message
1370: if ((lpEntry = FindMessageEntry(pMessageMap->lpEntries,
1371: nMsg, 0)) != NULL)
1372: {
1373: msgCache.lpEntry = lpEntry;
1374: goto LDispatch;
1375: }
1376: }
1377: else
1378: {
1379: // registered windows message
1380: lpEntry = pMessageMap->lpEntries;
1381:
1382: while ((lpEntry = FindMessageEntry(lpEntry, 0xC000, 0)) != NULL)
1383: {
1384: UINT NEAR* pnID = (UINT NEAR*)(lpEntry->nSig);
1385: ASSERT(*pnID >= 0xC000);
1386: // must be successfully registered
1387: if (*pnID == nMsg)
1388: {
1389: msgCache.lpEntry = lpEntry;
1390: goto LDispatchRegistered;
1391: }
1392: lpEntry++; // keep looking past this one
1393: }
1394: }
1395: }
1396:
1397: msgCache.lpEntry = NULL;
1398: return DefWindowProc(nMsg, wParam, lParam);
1399: }
1400: ASSERT(FALSE); // not reached
1401:
1402:
1403: LDispatch:
1404: ASSERT(nMsg < 0xC000);
1405: union MessageMapFunctions mmf;
1406: mmf.pfn = lpEntry->pfn;
1407:
1408: switch (lpEntry->nSig)
1409: {
1410: default:
1411: ASSERT(FALSE);
1412: return 0;
1413:
1414: case AfxSig_bD:
1415: return (this->*mmf.pfn_bD)(CDC::FromHandle((HDC)wParam));
1416:
1417: case AfxSig_bb:
1418: return (this->*mmf.pfn_bb)((BOOL)wParam);
1419:
1420: case AfxSig_bWww:
1421: return (this->*mmf.pfn_bWww)(CWnd::FromHandle((HWND)wParam),
1422: LOWORD(lParam), HIWORD(lParam));
1423:
1424: #ifdef _NTWIN
1425: case AfxSig_hDWw:
1426: {
1427: ASSERT(nMsg == WM_CTLCOLOR);
1428: struct _AFXCTLCOLOR* pCtl = (struct _AFXCTLCOLOR*)lParam;
1429: return (LONG)((this->*mmf.pfn_hDWw)( CDC::FromHandle(pCtl->hDC),
1430: CWnd::FromHandle(pCtl->hWnd), pCtl->nCtlType));
1431: }
1432: #else
1433: case AfxSig_hDWw:
1434: return (LONG)(UINT)(this->*mmf.pfn_hDWw)(CDC::FromHandle((HDC)wParam),
1435: CWnd::FromHandle((HWND)LOWORD(lParam)), HIWORD(lParam));
1436: #endif
1437:
1438: #ifndef _NTWIN
1439: case AfxSig_iwWw:
1440: return (this->*mmf.pfn_iwWw)(wParam, CWnd::FromHandle((HWND)LOWORD(lParam)),
1441: HIWORD(lParam));
1442: #else
1443: case AfxSig_iwWw:
1444: return (this->*mmf.pfn_iwWw)(LOWORD(wParam),
1445: CWnd::FromHandle((HWND)lParam),
1446: HIWORD(wParam));
1447: #endif
1448:
1449: case AfxSig_iWww:
1450: return (this->*mmf.pfn_iWww)(CWnd::FromHandle((HWND)wParam),
1451: LOWORD(lParam), HIWORD(lParam));
1452:
1453: case AfxSig_is:
1454: return (this->*mmf.pfn_is)((LPSTR)lParam);
1455:
1456: case AfxSig_lwl:
1457: return (this->*mmf.pfn_lwl)(wParam, lParam);
1458:
1459: #ifndef _NTWIN
1460: case AfxSig_lwwM:
1461: return (this->*mmf.pfn_lwwM)(wParam, LOWORD(lParam),
1462: CMenu::FromHandle((HMENU)HIWORD(lParam)));
1463: #else
1464: case AfxSig_lwwM:
1465: return (this->*mmf.pfn_lwwM)((UINT)LOWORD(wParam), (UINT)HIWORD(wParam),
1466: (CMenu*)CMenu::FromHandle((HMENU)lParam));
1467: #endif
1468:
1469: case AfxSig_vv:
1470: (this->*mmf.pfn_vv)();
1471: return 0;
1472:
1473:
1474: case AfxSig_vw: // AfxSig_vb:
1475: (this->*mmf.pfn_vw)(wParam);
1476: return 0;
1477:
1478: case AfxSig_vww:
1479: #ifndef _NTWIN
1480: (this->*mmf.pfn_vww)(wParam, LOWORD(lParam));
1481: #else
1482: (this->*mmf.pfn_vww)(wParam, lParam);
1483: #endif
1484: return 0;
1485:
1486: case AfxSig_vvii:
1487: (this->*mmf.pfn_vvii)(LOWORD(lParam), HIWORD(lParam));
1488: return 0;
1489:
1490: #ifdef _NTWIN
1491: case AfxSig_vwwh:
1492: (this->*mmf.pfn_vwwh)(LOWORD(wParam), HIWORD(wParam), (HANDLE)lParam);
1493: return 0;
1494: #endif
1495:
1496: case AfxSig_vwww:
1497: (this->*mmf.pfn_vwww)(wParam, LOWORD(lParam), HIWORD(lParam));
1498: return 0;
1499:
1500: case AfxSig_vwii:
1501: (this->*mmf.pfn_vwii)(wParam, LOWORD(lParam), HIWORD(lParam));
1502: return 0;
1503:
1504: case AfxSig_vwl:
1505: (this->*mmf.pfn_vwl)(wParam, lParam);
1506: return 0;
1507:
1508: #ifndef _NTWIN
1509: case AfxSig_vbWW:
1510: (this->*mmf.pfn_vbWW)((BOOL)wParam,
1511: CWnd::FromHandle((HWND)LOWORD(lParam)),
1512: CWnd::FromHandle((HWND)HIWORD(lParam)));
1513: return 0;
1514: #else
1515: case AfxSig_vbWW:
1516: (this->*mmf.pfn_vbWW)(m_hWnd == (HWND)lParam,
1517: CWnd::FromHandle((HWND)lParam),
1518: CWnd::FromHandle((HWND)wParam));
1519: return 0;
1520: #endif
1521:
1522: case AfxSig_vD:
1523: (this->*mmf.pfn_vD)(CDC::FromHandle((HDC)wParam));
1524: return 0;
1525:
1526: case AfxSig_vM:
1527: (this->*mmf.pfn_vM)(CMenu::FromHandle((HMENU)wParam));
1528: return 0;
1529:
1530: case AfxSig_vMwb:
1531: (this->*mmf.pfn_vMwb)(CMenu::FromHandle((HMENU)wParam),
1532: LOWORD(lParam), (BOOL)HIWORD(lParam));
1533: return 0;
1534:
1535:
1536: case AfxSig_vW:
1537: (this->*mmf.pfn_vW)(CWnd::FromHandle((HWND)wParam));
1538: return 0;
1539:
1540: case AfxSig_vWww:
1541: (this->*mmf.pfn_vWww)(CWnd::FromHandle((HWND)wParam), LOWORD(lParam),
1542: HIWORD(lParam));
1543: return 0;
1544:
1545: #ifndef _NTWIN
1546: case AfxSig_vWh:
1547: (this->*mmf.pfn_vWh)(CWnd::FromHandle((HWND)wParam),
1548: (HANDLE)LOWORD(lParam));
1549: return 0;
1550: #else
1551: case AfxSig_vWh:
1552: (this->*mmf.pfn_vWh)(CWnd::FromHandle((HWND)wParam),
1553: (HANDLE)lParam);
1554: return 0;
1555: #endif
1556:
1557: #ifndef _NTWIN
1558: case AfxSig_vwW:
1559: (this->*mmf.pfn_vwW)(wParam, CWnd::FromHandle((HWND)LOWORD(lParam)));
1560: return 0;
1561: #else
1562: case AfxSig_vwW:
1563: (this->*mmf.pfn_vwW)(wParam, CWnd::FromHandle((HWND)lParam));
1564: return 0;
1565: #endif
1566:
1567: #ifndef _NTWIN
1568: case AfxSig_vwWb:
1569: (this->*mmf.pfn_vwWb)(wParam, CWnd::FromHandle((HWND)LOWORD(lParam)),
1570: (BOOL)HIWORD(lParam));
1571: return 0;
1572: #else
1573: case AfxSig_vwWb:
1574: (this->*mmf.pfn_vwWb)((UINT)(LOWORD(wParam)),
1575: CWnd::FromHandle((HWND)lParam),
1576: (BOOL)(!(!(HIWORD(wParam)))));
1577: return 0;
1578: #endif //_NTWIN
1579:
1580: #ifndef _NTWIN
1581: case AfxSig_vwwW:
1582: (this->*mmf.pfn_vwwW)(wParam, LOWORD(lParam),
1583: CWnd::FromHandle((HWND)HIWORD(lParam)));
1584: return 0;
1585: #else
1586: case AfxSig_vwwW:
1587: (this->*mmf.pfn_vwwW)(LOWORD(wParam), HIWORD(wParam),
1588: CWnd::FromHandle((HWND)lParam));
1589: return 0;
1590: #endif
1591:
1592: case AfxSig_vs:
1593: (this->*mmf.pfn_vs)((LPSTR)lParam);
1594: return 0;
1595:
1596: #ifndef _NTWIN
1597: case AfxSig_wp:
1598: return (this->*mmf.pfn_wp)(*(CPoint*)&lParam);
1599: #else
1600: case AfxSig_wp:
1601: {
1602: CPoint point((DWORD)lParam);
1603: return (this->*mmf.pfn_wp)(point);
1604: }
1605:
1606: case AfxSig_vwp:
1607: {
1608: CPoint point((DWORD)lParam);
1609: (this->*mmf.pfn_vwp)(wParam, point);
1610: return 0;
1611: }
1612: #endif
1613:
1614: case AfxSig_wv: // AfxSig_bv, AfxSig_wv
1615: return (this->*mmf.pfn_wv)();
1616:
1617: case AfxSig_bh:
1618: return (this->*mmf.pfn_bh)((HANDLE)wParam);
1619:
1620: case AfxSig_vCALC:
1621: (this->*mmf.pfn_vCALC)((NCCALCSIZE_PARAMS FAR*)lParam);
1622: return 0;
1623:
1624: case AfxSig_vPOS:
1625: (this->*mmf.pfn_vPOS)((WINDOWPOS FAR*)lParam);
1626: return 0;
1627: }
1628: ASSERT(FALSE); // not reached
1629:
1630: LDispatchRegistered: // for registered windows messages
1631: ASSERT(nMsg >= 0xC000);
1632: mmf.pfn = lpEntry->pfn;
1633: return (this->*mmf.pfn_lwl)(wParam, lParam);
1634: }
1635:
1636: BOOL CWnd::OnCommand(UINT wParam, LONG lParam)
1637: {
1638: #ifdef _NTWIN
1639: UINT nID = LOWORD(wParam);
1640: HWND hWndCtrl = (HWND)lParam;
1641: UINT nNotifyCode = HIWORD(wParam); // control specific
1642: #else
1643: UINT nID = wParam;
1644: HWND hWndCtrl = (HWND)LOWORD(lParam);
1645: UINT nNotifyCode = HIWORD(lParam); // control specific
1646: #endif
1647: if (nID == 0)
1648: return FALSE; // 0 control IDs are not allowed !
1649:
1650: // default routing for command messages (through closure table)
1651: if (hWndCtrl == NULL)
1652: nNotifyCode = 0; // accelerators are not special
1653:
1654: // check in message map table for matching control ID
1655: register CMessageMap* pMessageMap;
1656: register CMessageEntry FAR* lpEntry;
1657:
1658: for (pMessageMap = GetMessageMap(); pMessageMap != NULL;
1659: pMessageMap = pMessageMap->pBaseMessageMap)
1660: {
1661: if ((lpEntry = FindMessageEntry(pMessageMap->lpEntries,
1662: nNotifyCode, nID)) != NULL)
1663: {
1664: #ifdef _DEBUG
1665: // diagnostic trace reporting of command notifications
1666: if (afxTraceFlags & 8) // if command reporting
1667: {
1668: if (nNotifyCode == 0)
1669: {
1670: TRACE("SENDING command %d to %s window\n", nID,
1671: GetRuntimeClass()->m_pszClassName);
1672: }
1673: else if (afxTraceFlags & 4) // if verbose windows messages
1674: {
1675: TRACE("SENDING control notification %d from control id %d "
1676: "to %s window\n", nNotifyCode, nID,
1677: GetRuntimeClass()->m_pszClassName);
1678: }
1679: }
1680: #endif
1681: // dispatch it
1682: (this->*lpEntry->pfn)();
1683: return TRUE; // handled
1684: }
1685: }
1686:
1687: #ifdef _DEBUG
1688: if (afxTraceFlags & 8)
1689: {
1690: if (nNotifyCode == 0)
1691: {
1692: TRACE("IGNORING command %d sent to %s window\n", nID,
1693: GetRuntimeClass()->m_pszClassName);
1694: }
1695: else if (afxTraceFlags & 4) // if verbose windows messages
1696: {
1697: TRACE("IGNORING control notification %d from control id %d "
1698: "to %s window\n", nNotifyCode, nID,
1699: GetRuntimeClass()->m_pszClassName);
1700: }
1701: }
1702: #endif
1703:
1704: return FALSE; // not handled
1705: }
1706:
1707:
1708:
1709: /////////////////////////////////////////////////////////////////////////////
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.