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