home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / winfrm.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  64.3 KB  |  2,359 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 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 related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12. #ifndef _DDEHEADER_INCLUDED_
  13. #include <dde.h>        // for DDE execute shell requests
  14. #endif
  15.  
  16. #ifdef AFX_CORE4_SEG
  17. #pragma code_seg(AFX_CORE4_SEG)
  18. #endif
  19.  
  20. #ifdef _DEBUG
  21. #undef THIS_FILE
  22. static char THIS_FILE[] = __FILE__;
  23. #endif
  24.  
  25. #define new DEBUG_NEW
  26.  
  27. /////////////////////////////////////////////////////////////////////////////
  28. // CRect for creating windows with the default position/size
  29.  
  30. const AFX_DATADEF CRect CFrameWnd::rectDefault(
  31.     WCE_IF(0,CW_USEDEFAULT), WCE_IF(0,CW_USEDEFAULT),
  32.     WCE_IF(CW_USEDEFAULT,0 /* 2*CW_USEDEFAULT */), WCE_IF(CW_USEDEFAULT,0 /* 2*CW_USEDEFAULT */));
  33.  
  34. /////////////////////////////////////////////////////////////////////////////
  35. // CFrameWnd
  36.  
  37. #if !defined(_WIN32_WCE)
  38. // register for Windows 95 or Windows NT 3.51
  39. AFX_STATIC UINT _afxMsgMouseWheel =
  40.    (((::GetVersion() & 0x80000000) && LOBYTE(LOWORD(::GetVersion()) == 4)) ||
  41.      (!(::GetVersion() & 0x80000000) && LOBYTE(LOWORD(::GetVersion()) == 3)))
  42.      ? ::RegisterWindowMessage(MSH_MOUSEWHEEL) : 0;
  43. #endif // _WIN32_WCE
  44.  
  45. BEGIN_MESSAGE_MAP(CFrameWnd, CWnd)
  46.     //{{AFX_MSG_MAP(CFrameWnd)
  47. WCE_DEL    ON_WM_INITMENU()
  48.     ON_WM_INITMENUPOPUP()
  49. WCE_DEL    ON_WM_MENUSELECT()
  50. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  51.     ON_MESSAGE(WM_POPMESSAGESTRING, OnPopMessageString)
  52.     ON_MESSAGE(WM_SETMESSAGESTRING, OnSetMessageString)
  53.     ON_MESSAGE(WM_HELPPROMPTADDR, OnHelpPromptAddr)
  54. #endif // _WIN32_WCE_NO_CONTROLBARS
  55.     ON_MESSAGE_VOID(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  56. WCE_DEL ON_WM_ENTERIDLE()
  57.     ON_WM_HSCROLL()
  58.     ON_WM_VSCROLL()
  59.     ON_WM_SETFOCUS()
  60.     ON_WM_CREATE()
  61.     ON_WM_DESTROY()
  62.     ON_WM_CLOSE()
  63.     ON_WM_SIZE()
  64.     ON_WM_ERASEBKGND()
  65.     ON_WM_ACTIVATE()
  66. WCE_DEL    ON_WM_NCACTIVATE()
  67.     ON_WM_SYSCOMMAND()
  68. WCE_DEL    ON_WM_DROPFILES()
  69. WCE_DEL    ON_WM_QUERYENDSESSION()
  70. WCE_DEL    ON_WM_ENDSESSION()
  71. #if !defined(_WIN32_WCE_NO_CURSOR)
  72.     ON_WM_SETCURSOR()
  73. #endif // _WIN32_WCE_NO_CURSOR
  74.     ON_WM_ENABLE()
  75.     // OLE palette support
  76.     ON_WM_QUERYNEWPALETTE()
  77.     ON_WM_PALETTECHANGED()
  78.     ON_MESSAGE(WM_COMMANDHELP, OnCommandHelp)
  79.     ON_MESSAGE(WM_HELPHITTEST, OnHelpHitTest)
  80.     ON_MESSAGE(WM_ACTIVATETOPLEVEL, OnActivateTopLevel)
  81.     // turning on and off standard frame gadgetry
  82. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  83.     ON_UPDATE_COMMAND_UI(ID_VIEW_STATUS_BAR, OnUpdateControlBarMenu)
  84.     ON_COMMAND_EX(ID_VIEW_STATUS_BAR, OnBarCheck)
  85.     ON_UPDATE_COMMAND_UI(ID_VIEW_TOOLBAR, OnUpdateControlBarMenu)
  86.     ON_COMMAND_EX(ID_VIEW_TOOLBAR, OnBarCheck)
  87.     ON_UPDATE_COMMAND_UI(ID_VIEW_REBAR, OnUpdateControlBarMenu)
  88.     ON_COMMAND_EX(ID_VIEW_REBAR, OnBarCheck)
  89.     // turning on and off standard mode indicators
  90.     ON_UPDATE_COMMAND_UI(ID_INDICATOR_CAPS, OnUpdateKeyIndicator)
  91.     ON_UPDATE_COMMAND_UI(ID_INDICATOR_NUM, OnUpdateKeyIndicator)
  92.     ON_UPDATE_COMMAND_UI(ID_INDICATOR_SCRL, OnUpdateKeyIndicator)
  93.     ON_UPDATE_COMMAND_UI(ID_INDICATOR_KANA, OnUpdateKeyIndicator)
  94. #endif // _WIN32_WCE_NO_CONTROLBARS
  95.     // standard help handling
  96. WCE_DEL ON_UPDATE_COMMAND_UI(ID_CONTEXT_HELP, OnUpdateContextHelp)
  97.     // toolbar "tooltip" notification
  98. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  99. #if !defined(_WIN32_WCE_NO_TOOLTIPS)
  100.     ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  101.     ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  102. #endif // _WIN32_WCE_NO_TOOLTIPS
  103. #endif // _WIN32_WCE_NO_CONTROLBARS
  104.     //}}AFX_MSG_MAP
  105.     // message handling for standard DDE commands
  106. WCE_DEL    ON_MESSAGE(WM_DDE_INITIATE, OnDDEInitiate)
  107. WCE_DEL    ON_MESSAGE(WM_DDE_EXECUTE, OnDDEExecute)
  108. WCE_DEL    ON_MESSAGE(WM_DDE_TERMINATE, OnDDETerminate)
  109. WCE_DEL ON_REGISTERED_MESSAGE(_afxMsgMouseWheel, OnRegisteredMouseWheel)
  110. END_MESSAGE_MAP()
  111.  
  112. /////////////////////////////////////////////////////////////////////////////
  113. // CFrameWnd construction/destruction
  114.  
  115. CFrameWnd::CFrameWnd()
  116. {
  117.     ASSERT(m_hWnd == NULL);
  118.  
  119.     m_nWindow = -1;                 // unknown window ID
  120.     m_bAutoMenuEnable = TRUE;       // auto enable on by default
  121.     m_lpfnCloseProc = NULL;
  122.     m_hMenuDefault = NULL;
  123.     m_hAccelTable = NULL;
  124.     m_nIDHelp = 0;
  125.     m_nIDTracking = 0;
  126.     m_nIDLastMessage = 0;
  127.     m_pViewActive = NULL;
  128.  
  129.     m_cModalStack = 0;              // initialize modality support
  130.     m_phWndDisable = NULL;
  131. #if !defined(_WIN32_WCE)
  132.     m_pNotifyHook = NULL;
  133. #endif // _WIN32_WCE
  134.     m_hMenuAlt = NULL;
  135.     m_nIdleFlags = 0;               // no idle work at start
  136.     m_rectBorder.SetRectEmpty();
  137.  
  138.     m_bHelpMode = HELP_INACTIVE;    // not in Shift+F1 help mode
  139.     m_dwPromptContext = 0;
  140.  
  141.     m_pNextFrameWnd = NULL;         // not in list yet
  142.  
  143.     m_bInRecalcLayout = FALSE;
  144. #if !defined(_WIN32_WCE_NO_DOCKBARS)
  145.     m_pFloatingFrameClass = NULL;
  146. #endif // _WIN32_WCE_NO_DOCKBARS
  147.     m_nShowDelay = -1;              // no delay pending
  148.  
  149.     m_poCommandBar = this;
  150.     AddFrameWnd();
  151. }
  152.  
  153. CFrameWnd::~CFrameWnd()
  154. {
  155.     RemoveFrameWnd();
  156.     if (m_phWndDisable != NULL)
  157.         delete[] (void*)m_phWndDisable;
  158. }
  159.  
  160. void CFrameWnd::AddFrameWnd()
  161. {
  162.     // hook it into the CFrameWnd list
  163.     AFX_MODULE_THREAD_STATE* pState = _AFX_CMDTARGET_GETSTATE()->m_thread;
  164.     pState->m_frameList.AddHead(this);
  165. }
  166.  
  167. void CFrameWnd::RemoveFrameWnd()
  168. {
  169.     // remove this frame window from the list of frame windows
  170.     AFX_MODULE_THREAD_STATE* pState = _AFX_CMDTARGET_GETSTATE()->m_thread;
  171.     pState->m_frameList.Remove(this);
  172. }
  173.  
  174. /////////////////////////////////////////////////////////////////////////////
  175. // Special processing etc
  176.  
  177. BOOL CFrameWnd::LoadAccelTable(LPCTSTR lpszResourceName)
  178. {
  179.     ASSERT(m_hAccelTable == NULL);  // only do once
  180.     ASSERT(lpszResourceName != NULL);
  181.  
  182.     HINSTANCE hInst = AfxFindResourceHandle(lpszResourceName, RT_ACCELERATOR);
  183.     m_hAccelTable = ::LoadAccelerators(hInst, lpszResourceName);
  184.     return (m_hAccelTable != NULL);
  185. }
  186.  
  187. HACCEL CFrameWnd::GetDefaultAccelerator()
  188. {
  189.     // use document specific accelerator table over m_hAccelTable
  190.     HACCEL hAccelTable = m_hAccelTable;
  191.     HACCEL hAccel;
  192.     CDocument* pDoc = GetActiveDocument();
  193.     if (pDoc != NULL && (hAccel = pDoc->GetDefaultAccelerator()) != NULL)
  194.         hAccelTable = hAccel;
  195.  
  196.     return hAccelTable;
  197. }
  198.  
  199. BOOL CFrameWnd::PreTranslateMessage(MSG* pMsg)
  200. {
  201.     // check for special cancel modes for combo boxes
  202.     if (pMsg->message == WM_LBUTTONDOWN || pMsg->message == WCE_IF(WM_LBUTTONDOWN,WM_NCLBUTTONDOWN))
  203.         AfxCancelModes(pMsg->hwnd);    // filter clicks
  204.  
  205.     // allow tooltip messages to be filtered
  206.     if (CWnd::PreTranslateMessage(pMsg))
  207.         return TRUE;
  208.  
  209. #if !defined(_WIN32_WCE)
  210. #ifndef _AFX_NO_OLE_SUPPORT
  211.     // allow hook to consume message
  212.     if (m_pNotifyHook != NULL && m_pNotifyHook->OnPreTranslateMessage(pMsg))
  213.         return TRUE;
  214. #endif
  215. #endif // _WIN32_WCE
  216.  
  217.     if (pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
  218.     {
  219.         // finally, translate the message
  220.         HACCEL hAccel = GetDefaultAccelerator();
  221.         return hAccel != NULL &&  ::TranslateAccelerator(m_hWnd, hAccel, pMsg);
  222.     }
  223.     return FALSE;
  224. }
  225.  
  226. void CFrameWnd::PostNcDestroy()
  227. {
  228.     // default for frame windows is to allocate them on the heap
  229.     //  the default post-cleanup is to 'delete this'.
  230.     // never explicitly call 'delete' on a CFrameWnd, use DestroyWindow instead
  231.     delete this;
  232. }
  233.  
  234. void CFrameWnd::OnPaletteChanged(CWnd* pFocusWnd)
  235. {
  236.     CWnd::OnPaletteChanged(pFocusWnd);
  237. #if !defined(_WIN32_WCE)
  238. #ifndef _AFX_NO_OLE_SUPPORT
  239.     if (m_pNotifyHook != NULL)
  240.         m_pNotifyHook->OnPaletteChanged(pFocusWnd);
  241. #endif
  242. #endif // _WIN32_WCE
  243. }
  244.  
  245. BOOL CFrameWnd::OnQueryNewPalette()
  246. {
  247. #if !defined(_WIN32_WCE)
  248. #ifndef _AFX_NO_OLE_SUPPORT
  249.     if (m_pNotifyHook != NULL && m_pNotifyHook->OnQueryNewPalette())
  250.         return TRUE;
  251. #endif
  252. #endif // _WIN32_WCE
  253.     return CWnd::OnQueryNewPalette();
  254. }
  255.  
  256. /////////////////////////////////////////////////////////////////////////////
  257. // CFrameWnd support for context sensitive help.
  258.  
  259. #if !defined(_WIN32_WCE)
  260. void CFrameWnd::ExitHelpMode()
  261. {
  262.     // if not in help mode currently, this is a no-op
  263.     if (!m_bHelpMode)
  264.         return;
  265.  
  266.     // only post new WM_EXITHELPMODE message if one doesn't already exist
  267.     //  in the queue.
  268.     MSG msg;
  269.     if (!::PeekMessage(&msg, m_hWnd, WM_EXITHELPMODE, WM_EXITHELPMODE,
  270.         PM_REMOVE|PM_NOYIELD))
  271.     {
  272.         VERIFY(::PostMessage(m_hWnd, WM_EXITHELPMODE, 0, 0));
  273.     }
  274.  
  275.     // release capture if this window has it
  276.     if (::GetCapture() == m_hWnd)
  277.         ReleaseCapture();
  278.  
  279.     CFrameWnd* pFrameWnd = GetTopLevelFrame();
  280.     ASSERT_VALID(pFrameWnd);
  281.     pFrameWnd->m_bHelpMode = m_bHelpMode = HELP_INACTIVE;
  282.     PostMessage(WM_KICKIDLE);   // trigger idle update
  283. }
  284. #endif // _WIN32_WCE
  285.  
  286. #if !defined(_WIN32_WCE_NO_CURSOR)
  287. BOOL CFrameWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  288. {
  289.     CFrameWnd* pFrameWnd = GetTopLevelFrame();
  290.     ASSERT_VALID(pFrameWnd);
  291.     if (pFrameWnd->m_bHelpMode)
  292.     {
  293.         SetCursor(afxData.hcurHelp);
  294.         return TRUE;
  295.     }
  296.     return CWnd::OnSetCursor(pWnd, nHitTest, message);
  297. }
  298. #endif // _WIN32_WCE_NO_CURSOR
  299.  
  300. LRESULT CFrameWnd::OnCommandHelp(WPARAM, LPARAM lParam)
  301. {
  302.     if (lParam == 0)
  303.     {
  304.         if (IsTracking())
  305.             lParam = HID_BASE_COMMAND+m_nIDTracking;
  306.         else
  307.             lParam = HID_BASE_RESOURCE+m_nIDHelp;
  308.     }
  309.     if (lParam != 0)
  310.     {
  311.         CWinApp* pApp = AfxGetApp();
  312.         if (pApp != NULL)
  313.             pApp->WinHelp(lParam);
  314.         return TRUE;
  315.     }
  316.     return FALSE;
  317. }
  318.  
  319. LRESULT CFrameWnd::OnHelpHitTest(WPARAM, LPARAM)
  320. {
  321.     if (m_nIDHelp != 0)
  322.         return HID_BASE_RESOURCE+m_nIDHelp;
  323.     else
  324.         return 0;
  325. }
  326.  
  327. BOOL CFrameWnd::OnCommand(WPARAM wParam, LPARAM lParam)
  328.     // return TRUE if command invocation was attempted
  329. {
  330.     HWND hWndCtrl = (HWND)lParam;
  331.     UINT nID = LOWORD(wParam);
  332.  
  333.     CFrameWnd* pFrameWnd = GetTopLevelFrame();
  334.     ASSERT_VALID(pFrameWnd);
  335.     if (pFrameWnd->m_bHelpMode && hWndCtrl == NULL &&
  336.         nID != ID_HELP && nID != ID_DEFAULT_HELP && nID != ID_CONTEXT_HELP)
  337.     {
  338.         // route as help
  339.         if (!SendMessage(WM_COMMANDHELP, 0, HID_BASE_COMMAND+nID))
  340.             SendMessage(WM_COMMAND, ID_DEFAULT_HELP);
  341.         return TRUE;
  342.     }
  343.  
  344.     // route as normal command
  345.     return CWnd::OnCommand(wParam, lParam);
  346. }
  347.  
  348. /////////////////////////////////////////////////////////////////////////////
  349. // CFrameWnd support for modality
  350.  
  351. BOOL AFXAPI AfxIsDescendant(HWND hWndParent, HWND hWndChild)
  352.     // helper for detecting whether child descendent of parent
  353.     //  (works with owned popups as well)
  354. {
  355.     ASSERT(::IsWindow(hWndParent));
  356.     ASSERT(::IsWindow(hWndChild));
  357.  
  358.     do
  359.     {
  360.         if (hWndParent == hWndChild)
  361.             return TRUE;
  362.  
  363.         hWndChild = AfxGetParentOwner(hWndChild);
  364.     } while (hWndChild != NULL);
  365.  
  366.     return FALSE;
  367. }
  368.  
  369. #if defined(_WIN32_WCE)
  370. void CFrameWnd::BeginModalState() 
  371. { 
  372.     ASSERT(m_hWnd != NULL); 
  373.     ASSERT(::IsWindow(m_hWnd)); 
  374.  
  375.     // allow stacking, but don't do anything 
  376.     if (++m_cModalStack > 1) 
  377.         return; 
  378.  
  379.     // determine top-level parent, since that is the true parent of any 
  380.     //  modeless windows anyway... 
  381.     CWnd* pParent = GetTopLevelParent(); 
  382.  
  383.     UINT    nCount = 0; 
  384.     HWND    hWnd = m_hWnd; 
  385.     if (::IsWindowEnabled(hWnd) && (CWnd::FromHandlePermanent(hWnd) != NULL) &&  
  386.         AfxIsDescendant(pParent->m_hWnd, hWnd) && (::SendMessage(hWnd, WM_DISABLEMODAL, 0, 0) == 0)) 
  387.     {
  388.         ++nCount;
  389.     }
  390.     if (nCount == 0)
  391.         return;
  392.  
  393.     m_phWndDisable = new HWND[nCount+1];
  394.  
  395.     // disable all windows connected to this frame (and add them to the list)
  396.     // WinCE supports only a single window
  397.     UINT nIndex = 0;
  398.     hWnd = m_hWnd;
  399.     if (::IsWindowEnabled(hWnd) && (CWnd::FromHandlePermanent(hWnd) != NULL) && 
  400.         AfxIsDescendant(pParent->m_hWnd, hWnd) && (::SendMessage(hWnd, WM_DISABLEMODAL, 0, 0) == 0))
  401.     {
  402.         ::EnableWindow(hWnd, FALSE);
  403.         ASSERT(nIndex < nCount);
  404.         m_phWndDisable[nIndex] = hWnd;
  405.         ++nIndex;
  406.     }
  407.  
  408.     // terminate the list with a NULL
  409.     ASSERT(nIndex < nCount+1);
  410.     m_phWndDisable[nIndex] = NULL;
  411. }
  412. #else // _WIN32_WCE
  413. void CFrameWnd::BeginModalState()
  414. {
  415.     ASSERT(m_hWnd != NULL);
  416.     ASSERT(::IsWindow(m_hWnd));
  417.  
  418.     // allow stacking, but don't do anything
  419.     if (++m_cModalStack > 1)
  420.         return;
  421.  
  422.     // determine top-level parent, since that is the true parent of any
  423.     //  modeless windows anyway...
  424.     CWnd* pParent = GetTopLevelParent();
  425.  
  426.     // first count all windows that need to be disabled
  427.     UINT nCount = 0;
  428.     HWND hWnd = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
  429.     while (hWnd != NULL)
  430.     {
  431.         if (::IsWindowEnabled(hWnd) &&
  432.             CWnd::FromHandlePermanent(hWnd) != NULL &&
  433.             AfxIsDescendant(pParent->m_hWnd, hWnd) &&
  434.             ::SendMessage(hWnd, WM_DISABLEMODAL, 0, 0) == 0)
  435.         {
  436.             ++nCount;
  437.         }
  438.         hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  439.     }
  440.     if (nCount == 0)
  441.         return;
  442.  
  443.     m_phWndDisable = new HWND[nCount+1];
  444.  
  445.     // disable all windows connected to this frame (and add them to the list)
  446.     UINT nIndex = 0;
  447.     hWnd = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
  448.     while (hWnd != NULL)
  449.     {
  450.         if (::IsWindowEnabled(hWnd) &&
  451.             CWnd::FromHandlePermanent(hWnd) != NULL &&
  452.             AfxIsDescendant(pParent->m_hWnd, hWnd) &&
  453.             ::SendMessage(hWnd, WM_DISABLEMODAL, 0, 0) == 0)
  454.         {
  455.             ::EnableWindow(hWnd, FALSE);
  456.             ASSERT(nIndex < nCount);
  457.             m_phWndDisable[nIndex] = hWnd;
  458.             ++nIndex;
  459.         }
  460.         hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  461.     }
  462.  
  463.     // terminate the list with a NULL
  464.     ASSERT(nIndex < nCount+1);
  465.     m_phWndDisable[nIndex] = NULL;
  466. }
  467. #endif // _WIN32_WCE
  468.  
  469. void CFrameWnd::EndModalState()
  470. {
  471.     // pop one off the stack (don't undo modalness unless stack is down to zero)
  472.     if (m_cModalStack == 0 || --m_cModalStack > 0 || m_phWndDisable == NULL)
  473.         return;
  474.  
  475.     // enable all the windows disabled by BeginModalState
  476.     ASSERT(m_phWndDisable != NULL);
  477.     UINT nIndex = 0;
  478.     while (m_phWndDisable[nIndex] != NULL)
  479.     {
  480.         ASSERT(m_phWndDisable[nIndex] != NULL);
  481.         if (::IsWindow(m_phWndDisable[nIndex]))
  482.             ::EnableWindow(m_phWndDisable[nIndex], TRUE);
  483.         ++nIndex;
  484.     }
  485.     delete[] (void*)m_phWndDisable;
  486.     m_phWndDisable = NULL;
  487. }
  488.  
  489. void CFrameWnd::ShowOwnedWindows(BOOL bShow)
  490. {
  491.     // walk through all top-level windows
  492.     HWND hWnd = ::GetWindow(::WCE_FCTN(GetDesktopWindow)(), GW_CHILD);
  493.     while (hWnd != NULL)
  494.     {
  495.         CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
  496.         if (pWnd != NULL && m_hWnd != hWnd && AfxIsDescendant(m_hWnd, hWnd))
  497.         {
  498.             DWORD dwStyle = ::GetWindowLong(hWnd, GWL_STYLE);
  499.             if (!bShow && (dwStyle & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE)
  500.             {
  501.                 ::ShowWindow(hWnd, SW_HIDE);
  502.                 pWnd->m_nFlags |= WF_TEMPHIDE;
  503.             }
  504.             else if (bShow && (dwStyle & (WS_VISIBLE|WS_DISABLED)) == 0 &&
  505.                 (pWnd->m_nFlags & WF_TEMPHIDE))
  506.             {
  507.                 ::ShowWindow(hWnd, SW_SHOWNOACTIVATE);
  508.                 pWnd->m_nFlags &= ~WF_TEMPHIDE;
  509.             }
  510.         }
  511.         hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  512.     }
  513. }
  514.  
  515. void CFrameWnd::OnEnable(BOOL bEnable)
  516. {
  517.     if (bEnable && (m_nFlags & WF_STAYDISABLED))
  518.     {
  519.         // Work around for MAPI support. This makes sure the main window
  520.         // remains disabled even when the mail system is booting.
  521.         EnableWindow(FALSE);
  522.         ::SetFocus(NULL);
  523.         return;
  524.     }
  525.  
  526.     // only for top-level (and non-owned) windows
  527.     if (GetParent() != NULL)
  528.         return;
  529.  
  530.     // this causes modal dialogs to be "truly modal"
  531.     if (!bEnable && !InModalState())
  532.     {
  533.         ASSERT((m_nFlags & WF_MODALDISABLE) == 0);
  534.         m_nFlags |= WF_MODALDISABLE;
  535.         BeginModalState();
  536.     }
  537.     else if (bEnable && (m_nFlags & WF_MODALDISABLE))
  538.     {
  539.         m_nFlags &= ~WF_MODALDISABLE;
  540.         EndModalState();
  541.  
  542.         // cause normal focus logic to kick in
  543.         if (::GetActiveWindow() == m_hWnd)
  544.             SendMessage(WM_ACTIVATE, WA_ACTIVE);
  545.     }
  546.  
  547.     // force WM_NCACTIVATE because Windows may think it is unecessary
  548. #if !defined(_WIN32_WCE)
  549.     if (bEnable && (m_nFlags & WF_STAYACTIVE))
  550.         SendMessage(WM_NCACTIVATE, TRUE);
  551.     // force WM_NCACTIVATE for floating windows too
  552. #endif // _WIN32_WCE
  553. #if !defined(_WIN32_WCE_NO_DOCKBARS)
  554.     NotifyFloatingWindows(bEnable ? FS_ENABLE : FS_DISABLE);
  555. #endif // _WIN32_WCE_NO_DOCKBARS
  556. }
  557.  
  558. #if !defined(_WIN32_WCE_NO_DOCKBARS)
  559. void CFrameWnd::NotifyFloatingWindows(DWORD dwFlags)
  560. {
  561.     ASSERT_VALID(this);
  562.     ASSERT(m_hWnd != NULL);
  563.  
  564.     // get top level parent frame window first unless this is a child window
  565.     CFrameWnd* pParent = (GetStyle() & WS_CHILD) ? this : GetTopLevelFrame();
  566.     ASSERT(pParent != NULL);
  567.     if (dwFlags & (FS_DEACTIVATE|FS_ACTIVATE))
  568.     {
  569.         // update parent window activation state
  570.         BOOL bActivate = !(dwFlags & FS_DEACTIVATE);
  571.         BOOL bEnabled = pParent->IsWindowEnabled();
  572.  
  573.         if (bActivate && bEnabled && pParent != this)
  574.         {
  575.             // Excel will try to Activate itself when it receives a
  576.             // WM_NCACTIVATE so we need to keep it from doing that here.
  577.             m_nFlags |= WF_KEEPMINIACTIVE;
  578.             pParent->SendMessage(WM_NCACTIVATE, TRUE);
  579.             m_nFlags &= ~WF_KEEPMINIACTIVE;
  580.         }
  581.         else
  582.         {
  583.             pParent->SendMessage(WM_NCACTIVATE, FALSE);
  584.         }
  585.     }
  586.  
  587.     // then update the state of all floating windows owned by the parent
  588.     HWND hWnd = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
  589.     while (hWnd != NULL)
  590.     {
  591.         if (AfxIsDescendant(pParent->m_hWnd, hWnd))
  592.             ::SendMessage(hWnd, WM_FLOATSTATUS, dwFlags, 0);
  593.         hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  594.     }
  595. }
  596. #endif // _WIN32_WCE_NO_DOCKBARS
  597.  
  598. /////////////////////////////////////////////////////////////////////////////
  599. // CFrameWnd second phase creation
  600.  
  601. BOOL CFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
  602. {
  603.     if (cs.lpszClass == NULL)
  604.     {
  605.         VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));
  606.         cs.lpszClass = _afxWndFrameOrView;  // COLOR_WINDOW background
  607.     }
  608.  
  609.     if ((cs.style & FWS_ADDTOTITLE) && afxData.bWin4)
  610.         cs.style |= FWS_PREFIXTITLE;
  611.  
  612. #if !defined(_WIN32_WCE)
  613. // WinCE: FrameWindows should not have borders.
  614.     if (afxData.bWin4)
  615.         cs.dwExStyle |= WS_EX_CLIENTEDGE;
  616. #endif // _WIN32_WCE
  617.  
  618.     return TRUE;
  619. }
  620.  
  621. BOOL CFrameWnd::Create(LPCTSTR lpszClassName,
  622.     LPCTSTR lpszWindowName,
  623.     DWORD dwStyle,
  624.     const RECT& rect,
  625.     CWnd* pParentWnd,
  626.     LPCTSTR lpszMenuName,
  627.     DWORD dwExStyle,
  628.     CCreateContext* pContext)
  629. {
  630.     HMENU hMenu = NULL;
  631. #if defined(_WIN32_WCE)
  632. // WinCE: cache the menu resource id for old command bar compatibility
  633.     m_lpszMenuName = lpszMenuName;
  634. #else // _WIN32_WCE
  635.     if (lpszMenuName != NULL)
  636.     {
  637.         // load in a menu that will get destroyed when window gets destroyed
  638.         HINSTANCE hInst = AfxFindResourceHandle(lpszMenuName, RT_MENU);
  639.         if ((hMenu = ::LoadMenu(hInst, lpszMenuName)) == NULL)
  640.         {
  641.             TRACE0("Warning: failed to load menu for CFrameWnd.\n");
  642.             PostNcDestroy();            // perhaps delete the C++ object
  643.             return FALSE;
  644.         }
  645.     }
  646. #endif // _WIN32_WCE
  647.  
  648.     m_strTitle = lpszWindowName;    // save title for later
  649.  
  650.     if (!CreateEx(dwExStyle, lpszClassName, lpszWindowName, dwStyle,
  651.         rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
  652.         pParentWnd->GetSafeHwnd(), hMenu, (LPVOID)pContext))
  653.     {
  654.         TRACE0("Warning: failed to create CFrameWnd.\n");
  655.         if (hMenu != NULL)
  656.             DestroyMenu(hMenu);
  657.         return FALSE;
  658.     }
  659.  
  660. #if defined(_WIN32_WCE)
  661. //WinCE: set icon image for taskbar
  662.     if(lpszMenuName != NULL)
  663.     {
  664.         HICON hIcon = NULL;
  665.         HINSTANCE hInst = AfxFindResourceHandle(lpszMenuName, RT_ICON);
  666.         if ((hIcon = (HICON)::LoadImage(hInst, lpszMenuName,  
  667.             IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR)) != NULL)
  668.         {
  669.             PostMessage(WM_SETICON, FALSE, (LPARAM)hIcon);
  670.         }
  671.     }
  672. #endif // _WIN32_WCE
  673.     return TRUE;
  674. }
  675.  
  676. CWnd* CFrameWnd::CreateView(CCreateContext* pContext, UINT nID)
  677. {
  678.     ASSERT(m_hWnd != NULL);
  679.     ASSERT(::IsWindow(m_hWnd));
  680.     ASSERT(pContext != NULL);
  681.     ASSERT(pContext->m_pNewViewClass != NULL);
  682.  
  683.     // Note: can be a CWnd with PostNcDestroy self cleanup
  684.     CWnd* pView = (CWnd*)pContext->m_pNewViewClass->CreateObject();
  685.     if (pView == NULL)
  686.     {
  687.         TRACE1("Warning: Dynamic create of view type %hs failed.\n",
  688.             pContext->m_pNewViewClass->m_lpszClassName);
  689.         return NULL;
  690.     }
  691.     ASSERT_KINDOF(CWnd, pView);
  692.  
  693. #if defined(_WIN32_WCE)
  694.     RECT rcMain;
  695.     ::GetClientRect( m_hWnd, &rcMain );
  696.     CRect initRect(0, 0, rcMain.right, rcMain.bottom);
  697.  
  698.     // views are always created with a border! 
  699.     if (!pView->Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,    initRect, this, nID, pContext))
  700.     {
  701.         TRACE0("Warning: could not create view for frame.\n");
  702.         return NULL;        // can't continue without a view
  703.     }
  704. #else // _WIN32_WCE
  705.     // views are always created with a border!
  706.     if (!pView->Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
  707.         CRect(0,0,0,0), this, nID, pContext))
  708.     {
  709.         TRACE0("Warning: could not create view for frame.\n");
  710.         return NULL;        // can't continue without a view
  711.     }
  712.  
  713.     if (afxData.bWin4 && (pView->GetExStyle() & WS_EX_CLIENTEDGE))
  714.     {
  715.         // remove the 3d style from the frame, since the view is
  716.         //  providing it.
  717.         // make sure to recalc the non-client area
  718.         ModifyStyleEx(WS_EX_CLIENTEDGE, 0, SWP_FRAMECHANGED);
  719.     }
  720. #endif // _WIN32_WCE
  721.     return pView;
  722. }
  723.  
  724. BOOL CFrameWnd::OnCreateClient(LPCREATESTRUCT, CCreateContext* pContext)
  725. {
  726.     // default create client will create a view if asked for it
  727.     if (pContext != NULL && pContext->m_pNewViewClass != NULL)
  728.     {
  729.         if (CreateView(pContext, AFX_IDW_PANE_FIRST) == NULL)
  730.             return FALSE;
  731.     }
  732.     return TRUE;
  733. }
  734.  
  735. int CFrameWnd::OnCreate(LPCREATESTRUCT lpcs)
  736. {
  737.     CCreateContext* pContext = (CCreateContext*)lpcs->lpCreateParams;
  738.     return OnCreateHelper(lpcs, pContext);
  739. }
  740.  
  741. int CFrameWnd::OnCreateHelper(LPCREATESTRUCT lpcs, CCreateContext* pContext)
  742. {
  743.     if (CWnd::OnCreate(lpcs) == -1)
  744.         return -1;
  745.  
  746.     // create special children first
  747.     if (!OnCreateClient(lpcs, pContext))
  748.     {
  749.         TRACE0("Failed to create client pane/view for frame.\n");
  750.         return -1;
  751.     }
  752.  
  753.     // post message for initial message string
  754.     PostMessage(WM_SETMESSAGESTRING, AFX_IDS_IDLEMESSAGE);
  755.  
  756.     // make sure the child windows have been properly sized
  757.     RecalcLayout();
  758.  
  759.     return 0;   // create ok
  760. }
  761.  
  762. LPCTSTR CFrameWnd::GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource)
  763. {
  764.     ASSERT_VALID_IDR(nIDResource);
  765.     HINSTANCE hInst = AfxFindResourceHandle(
  766.         MAKEINTRESOURCE(nIDResource), RT_GROUP_ICON);
  767.     HICON hIcon = ::LoadIcon(hInst, MAKEINTRESOURCE(nIDResource));
  768.     if (hIcon != NULL)
  769.     {
  770.         CREATESTRUCT cs;
  771.         memset(&cs, 0, sizeof(CREATESTRUCT));
  772.         cs.style = dwDefaultStyle;
  773.         PreCreateWindow(cs);
  774.             // will fill lpszClassName with default WNDCLASS name
  775.             // ignore instance handle from PreCreateWindow.
  776.  
  777.         WNDCLASS wndcls;
  778.         if (cs.lpszClass != NULL &&
  779.             GetClassInfo(AfxGetInstanceHandle(), cs.lpszClass, &wndcls) &&
  780.             wndcls.hIcon != hIcon)
  781.         {
  782.             // register a very similar WNDCLASS
  783.             return AfxRegisterWndClass(wndcls.style,
  784.                 wndcls.hCursor, wndcls.hbrBackground, hIcon);
  785.         }
  786.     }
  787.     return NULL;        // just use the default
  788. }
  789.  
  790. BOOL CFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
  791.     CWnd* pParentWnd, CCreateContext* pContext)
  792. {
  793.     // only do this once
  794.     ASSERT_VALID_IDR(nIDResource);
  795.     ASSERT(m_nIDHelp == 0 || m_nIDHelp == nIDResource);
  796.  
  797.     m_nIDHelp = nIDResource;    // ID for help context (+HID_BASE_RESOURCE)
  798.  
  799.     CString strFullString;
  800.     if (strFullString.LoadString(nIDResource))
  801.         AfxExtractSubString(m_strTitle, strFullString, 0);    // first sub-string
  802.  
  803.     VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));
  804.  
  805.     // attempt to create the window
  806.     LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);
  807.     LPCTSTR lpszTitle = m_strTitle;
  808.     if (!Create(lpszClass, lpszTitle, WCE_IF(WS_VISIBLE, dwDefaultStyle), rectDefault,
  809.       pParentWnd, MAKEINTRESOURCE(nIDResource), 0L, pContext))
  810.     {
  811.         return FALSE;   // will self destruct on failure normally
  812.     }
  813.  
  814.     // save the default menu handle
  815.     ASSERT(m_hWnd != NULL);
  816.  
  817.     // load accelerator resource
  818.     LoadAccelTable(MAKEINTRESOURCE(nIDResource));
  819.  
  820.     if (pContext == NULL)   // send initial update
  821.         SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
  822.  
  823.     return TRUE;
  824. }
  825.  
  826. void CFrameWnd::OnUpdateFrameMenu(HMENU hMenuAlt)
  827. {
  828.     if (hMenuAlt == NULL)
  829.     {
  830.         // attempt to get default menu from document
  831.         CDocument* pDoc = GetActiveDocument();
  832.         if (pDoc != NULL)
  833.             hMenuAlt = pDoc->GetDefaultMenu();
  834.         // use default menu stored in frame if none from document
  835.         if (hMenuAlt == NULL)
  836.             hMenuAlt = m_hMenuDefault;
  837.     }
  838.     // finally, set the menu
  839.     ::WCE_FCTN(SetMenu)(m_hWnd, hMenuAlt);
  840. }
  841.  
  842. void CFrameWnd::InitialUpdateFrame(CDocument* pDoc, BOOL bMakeVisible)
  843. {
  844.     // if the frame does not have an active view, set to first pane
  845.     CView* pView = NULL;
  846.     if (GetActiveView() == NULL)
  847.     {
  848.         CWnd* pWnd = GetDescendantWindow(AFX_IDW_PANE_FIRST, TRUE);
  849.         if (pWnd != NULL && pWnd->IsKindOf(RUNTIME_CLASS(CView)))
  850.         {
  851.             pView = (CView*)pWnd;
  852.             SetActiveView(pView, FALSE);
  853.         }
  854.     }
  855.  
  856.     if (bMakeVisible)
  857.     {
  858.         // send initial update to all views (and other controls) in the frame
  859.         SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
  860.  
  861.         // give view a chance to save the focus (CFormView needs this)
  862.         if (pView != NULL)
  863.             pView->OnActivateFrame(WA_INACTIVE, this);
  864.  
  865.         // finally, activate the frame
  866.         // (send the default show command unless the main desktop window)
  867.         int nCmdShow = -1;      // default
  868.         CWinApp* pApp = AfxGetApp();
  869.         if (pApp != NULL && pApp->m_pMainWnd == this)
  870.         {
  871.             nCmdShow = pApp->m_nCmdShow; // use the parameter from WinMain
  872.             pApp->m_nCmdShow = -1; // set to default after first time
  873.         }
  874.         ActivateFrame(nCmdShow);
  875.         if (pView != NULL)
  876.             pView->OnActivateView(TRUE, pView, pView);
  877.     }
  878.  
  879.     // update frame counts and frame title (may already have been visible)
  880.     if (pDoc != NULL)
  881.         pDoc->UpdateFrameCounts();
  882.     OnUpdateFrameTitle(TRUE);
  883. }
  884.  
  885. /////////////////////////////////////////////////////////////////////////////
  886. // CFrameWnd closing down
  887.  
  888. void CFrameWnd::OnClose()
  889. {
  890.     if (m_lpfnCloseProc != NULL && !(*m_lpfnCloseProc)(this))
  891.         return;
  892.  
  893.     // Note: only queries the active document
  894.     CDocument* pDocument = GetActiveDocument();
  895.     if (pDocument != NULL && !pDocument->CanCloseFrame(this))
  896.     {
  897.         // document can't close right now -- don't close it
  898.         return;
  899.     }
  900.     CWinApp* pApp = AfxGetApp();
  901.     if (pApp != NULL && pApp->m_pMainWnd == this)
  902.     {
  903.         // attempt to save all documents
  904.         if (pDocument == NULL && !pApp->SaveAllModified())
  905.             return;     // don't close it
  906.  
  907.         // hide the application's windows before closing all the documents
  908.         pApp->HideApplication();
  909.  
  910.         // close all documents first
  911.         pApp->CloseAllDocuments(FALSE);
  912.  
  913. #if !defined(_WIN32_WCE_NO_OLE)
  914.         // don't exit if there are outstanding component objects
  915.         if (!AfxOleCanExitApp())
  916.         {
  917.             // take user out of control of the app
  918.             AfxOleSetUserCtrl(FALSE);
  919.  
  920.             // don't destroy the main window and close down just yet
  921.             //  (there are outstanding component (OLE) objects)
  922.             return;
  923.         }
  924. #endif // _WIN32_WCE_NO_OLE
  925.  
  926.         // there are cases where destroying the documents may destroy the
  927.         //  main window of the application.
  928.         if (!afxContextIsDLL && pApp->m_pMainWnd == NULL)
  929.         {
  930.             AfxPostQuitMessage(0);
  931.             return;
  932.         }
  933.     }
  934.  
  935.     // detect the case that this is the last frame on the document and
  936.     // shut down with OnCloseDocument instead.
  937.     if (pDocument != NULL && pDocument->m_bAutoDelete)
  938.     {
  939.         BOOL bOtherFrame = FALSE;
  940.         POSITION pos = pDocument->GetFirstViewPosition();
  941.         while (pos != NULL)
  942.         {
  943.             CView* pView = pDocument->GetNextView(pos);
  944.             ASSERT_VALID(pView);
  945.             if (pView->GetParentFrame() != this)
  946.             {
  947.                 bOtherFrame = TRUE;
  948.                 break;
  949.             }
  950.         }
  951.         if (!bOtherFrame)
  952.         {
  953.             pDocument->OnCloseDocument();
  954.             return;
  955.         }
  956.  
  957.         // allow the document to cleanup before the window is destroyed
  958.         pDocument->PreCloseFrame(this);
  959.     }
  960.  
  961.     // then destroy the window
  962.     DestroyWindow();
  963. }
  964.  
  965. void CFrameWnd::OnDestroy()
  966. {
  967. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  968.     DestroyDockBars();
  969. #endif // _WIN32_WCE_NO_DOCKBARS
  970.  
  971.     // reset menu to default before final shutdown
  972.     if (m_hMenuDefault != NULL && ::WCE_FCTN(GetMenu)(m_hWnd) != m_hMenuDefault)
  973.     {
  974.         ::WCE_FCTN(SetMenu)(m_hWnd, m_hMenuDefault);
  975.         ASSERT(::WCE_FCTN(GetMenu)(m_hWnd) == m_hMenuDefault);
  976.     }
  977.  
  978. #if !defined(_WIN32_WCE)
  979.     // Automatically quit when the main window is destroyed.
  980.     CWinApp* pApp = AfxGetApp();
  981.     if (pApp != NULL && pApp->m_pMainWnd == this)
  982.     {
  983.         // closing the main application window
  984.         ::WinHelp(m_hWnd, NULL, HELP_QUIT, 0L);
  985.  
  986.         // will call PostQuitMessage in CWnd::OnNcDestroy
  987.     }
  988. #endif // _WIN32_WCE
  989.  
  990.     CWnd::OnDestroy();
  991. }
  992.  
  993. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  994. void CFrameWnd::RemoveControlBar(CControlBar *pBar)
  995. {
  996.     POSITION pos = m_listControlBars.Find(pBar);
  997.     if (pos != NULL)
  998.         m_listControlBars.RemoveAt(pos);
  999. }
  1000. #endif // _WIN32_WCE_NO_CONTROLBARS
  1001.  
  1002. /////////////////////////////////////////////////////////////////////////////
  1003. // CFrameWnd command/message routing
  1004.  
  1005. BOOL CFrameWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra,
  1006.     AFX_CMDHANDLERINFO* pHandlerInfo)
  1007. {
  1008.     CPushRoutingFrame push(this);
  1009.  
  1010.     // pump through current view FIRST
  1011.     CView* pView = GetActiveView();
  1012.     if (pView != NULL && pView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  1013.         return TRUE;
  1014.  
  1015.     // then pump through frame
  1016.     if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  1017.         return TRUE;
  1018.  
  1019.     // last but not least, pump through app
  1020.     CWinApp* pApp = AfxGetApp();
  1021.     if (pApp != NULL && pApp->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  1022.         return TRUE;
  1023.  
  1024.     return FALSE;
  1025. }
  1026.  
  1027. // Delegate scroll messages to active view as well
  1028. void CFrameWnd::OnHScroll(UINT, UINT, CScrollBar*)
  1029. {
  1030.     CWnd* pActiveView = GetActiveView();
  1031.     if (pActiveView != NULL)
  1032.     {
  1033.         const MSG* pMsg = GetCurrentMessage();
  1034.         pActiveView->SendMessage(WM_HSCROLL, pMsg->wParam, pMsg->lParam);
  1035.     }
  1036. }
  1037.  
  1038. void CFrameWnd::OnVScroll(UINT, UINT, CScrollBar*)
  1039. {
  1040.     CWnd* pActiveView = GetActiveView();
  1041.     if (pActiveView != NULL)
  1042.     {
  1043.         const MSG* pMsg = GetCurrentMessage();
  1044.         pActiveView->SendMessage(WM_VSCROLL, pMsg->wParam, pMsg->lParam);
  1045.     }
  1046. }
  1047.  
  1048. LRESULT CFrameWnd::OnActivateTopLevel(WPARAM wParam, LPARAM lParam)
  1049. {
  1050.     CWnd::OnActivateTopLevel(wParam, lParam);
  1051.  
  1052. #if !defined(_WIN32_WCE)
  1053.     // exit Shift+F1 help mode on activation changes
  1054.     ExitHelpMode();
  1055.  
  1056. #ifndef _AFX_NO_OLE_SUPPORT
  1057.     // allow OnFrameWindowActivate to be sent to in-place items
  1058.     if (m_pNotifyHook != NULL)
  1059.     {
  1060.         // activate when active and when not minimized
  1061.         m_pNotifyHook->OnActivate(
  1062.             LOWORD(wParam) != WA_INACTIVE && !HIWORD(wParam));
  1063.     }
  1064. #endif
  1065. #endif // _WIN32_WCE
  1066.  
  1067.     // deactivate current active view
  1068.     if (AfxGetThread()->m_pMainWnd == this)
  1069.     {
  1070.         CView* pActiveView = GetActiveView();
  1071.         if (pActiveView == NULL)
  1072.             pActiveView = GetActiveFrame()->GetActiveView();
  1073.         if (pActiveView != NULL)
  1074.             pActiveView->OnActivateView(FALSE, pActiveView, pActiveView);
  1075.     }
  1076.  
  1077.     // force idle processing to update any key state indicators
  1078.     PostMessage(WM_KICKIDLE);
  1079.  
  1080.     return 0;
  1081. }
  1082.  
  1083. void CFrameWnd::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized)
  1084. {
  1085.     CWnd::OnActivate(nState, pWndOther, bMinimized);
  1086.  
  1087.     // get top level frame unless this is a child window
  1088.     // determine if window should be active or not
  1089.     CFrameWnd* pTopLevel = (GetStyle() & WS_CHILD) ? this : GetTopLevelFrame();
  1090.     ASSERT(pTopLevel != NULL);
  1091.     CWnd* pActive = (nState == WA_INACTIVE ? pWndOther : this);
  1092.     BOOL bStayActive =
  1093.         (pTopLevel == pActive ||
  1094.         (pTopLevel == pActive->GetTopLevelFrame() &&
  1095.         (pActive == pTopLevel ||
  1096.             pActive->SendMessage(WM_FLOATSTATUS, FS_SYNCACTIVE) != 0)));
  1097.     pTopLevel->m_nFlags &= ~WF_STAYACTIVE;
  1098.     if (bStayActive)
  1099.         pTopLevel->m_nFlags |= WF_STAYACTIVE;
  1100.  
  1101. #if !defined(_WIN32_WCE_NO_DOCKBARS)
  1102.     // sync floating windows to the new state
  1103.     NotifyFloatingWindows(bStayActive ? FS_ACTIVATE : FS_DEACTIVATE);
  1104. #endif // _WIN32_WCE_NO_DOCKBARS
  1105.  
  1106.     // get active view (use active frame if no active view)
  1107.     CView* pActiveView = GetActiveView();
  1108.     if (pActiveView == NULL)
  1109.         pActiveView = GetActiveFrame()->GetActiveView();
  1110.  
  1111.     // when frame gets activated, re-activate current view
  1112.     if (pActiveView != NULL)
  1113.     {
  1114.         if (nState != WA_INACTIVE && !bMinimized)
  1115.             pActiveView->OnActivateView(TRUE, pActiveView, pActiveView);
  1116.  
  1117.         // always notify the view of frame activations
  1118.         pActiveView->OnActivateFrame(nState, this);
  1119.     }
  1120. }
  1121.  
  1122. #if !defined(_WIN32_WCE)
  1123. BOOL CFrameWnd::OnNcActivate(BOOL bActive)
  1124. {
  1125.     // stay active if WF_STAYACTIVE bit is on
  1126.     if (m_nFlags & WF_STAYACTIVE)
  1127.         bActive = TRUE;
  1128.  
  1129.     // but do not stay active if the window is disabled
  1130.     if (!IsWindowEnabled())
  1131.         bActive = FALSE;
  1132.  
  1133.     // do not call the base class because it will call Default()
  1134.     //  and we may have changed bActive.
  1135.     return (BOOL)DefWindowProc(WM_NCACTIVATE, bActive, 0L);
  1136. }
  1137. #endif // _WIN32_WCE
  1138.  
  1139. void CFrameWnd::OnSysCommand(UINT nID, LONG lParam)
  1140. {
  1141.     CFrameWnd* pFrameWnd = GetTopLevelFrame();
  1142.     ASSERT_VALID(pFrameWnd);
  1143.  
  1144.     // set status bar as appropriate
  1145.     UINT nItemID = (nID & 0xFFF0);
  1146.  
  1147.     // don't interfere with system commands if not in help mode
  1148. #if !defined(_WIN32_WCE)
  1149.     if (pFrameWnd->m_bHelpMode)
  1150.     {
  1151.         switch (nItemID)
  1152.         {
  1153.         case SC_SIZE:
  1154.         case SC_MOVE:
  1155.         case SC_MINIMIZE:
  1156.         case SC_MAXIMIZE:
  1157.         case SC_NEXTWINDOW:
  1158.         case SC_PREVWINDOW:
  1159.         case SC_CLOSE:
  1160.         case SC_RESTORE:
  1161.         case SC_TASKLIST:
  1162.             if (!SendMessage(WM_COMMANDHELP, 0,
  1163.               HID_BASE_COMMAND+ID_COMMAND_FROM_SC(nItemID)))
  1164.                 SendMessage(WM_COMMAND, ID_DEFAULT_HELP);
  1165.             return;
  1166.         }
  1167.     }
  1168. #endif // _WIN32_WCE
  1169.  
  1170.     // call default functionality
  1171.     CWnd::OnSysCommand(nID, lParam);
  1172. }
  1173.  
  1174. /////////////////////////////////////////////////////////////////////////////
  1175. // default frame processing
  1176.  
  1177. #if !defined(_WIN32_WCE)
  1178. // default drop processing will attempt to open the file
  1179. void CFrameWnd::OnDropFiles(HDROP hDropInfo)
  1180. {
  1181.     SetActiveWindow();      // activate us first !
  1182.     UINT nFiles = ::DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
  1183.  
  1184.     CWinApp* pApp = AfxGetApp();
  1185.     ASSERT(pApp != NULL);
  1186.     for (UINT iFile = 0; iFile < nFiles; iFile++)
  1187.     {
  1188.         TCHAR szFileName[_MAX_PATH];
  1189.         ::DragQueryFile(hDropInfo, iFile, szFileName, _MAX_PATH);
  1190.         pApp->OpenDocumentFile(szFileName);
  1191.     }
  1192.     ::DragFinish(hDropInfo);
  1193. }
  1194.  
  1195. // query end session for main frame will attempt to close it all down
  1196. BOOL CFrameWnd::OnQueryEndSession()
  1197. {
  1198.     CWinApp* pApp = AfxGetApp();
  1199.     if (pApp != NULL && pApp->m_pMainWnd == this)
  1200.         return pApp->SaveAllModified();
  1201.  
  1202.     return TRUE;
  1203. }
  1204.  
  1205. // when Windows session ends, close all documents
  1206. void CFrameWnd::OnEndSession(BOOL bEnding)
  1207. {
  1208.     if (!bEnding)
  1209.         return;
  1210.  
  1211.     CWinApp* pApp = AfxGetApp();
  1212.     if (pApp != NULL && pApp->m_pMainWnd == this)
  1213.     {
  1214.         AfxOleSetUserCtrl(TRUE);    // keeps from randomly shutting down
  1215.         pApp->CloseAllDocuments(TRUE);
  1216.  
  1217.         // allow application to save settings, etc.
  1218.         pApp->ExitInstance();
  1219.     }
  1220. }
  1221. #endif // _WIN32_WCE
  1222.  
  1223. #if !defined(_WIN32_WCE)
  1224. /////////////////////////////////////////////////////////////////////////////
  1225. // Support for Shell DDE Execute messages
  1226.  
  1227. LRESULT CFrameWnd::OnDDEInitiate(WPARAM wParam, LPARAM lParam)
  1228. {
  1229.     CWinApp* pApp = AfxGetApp();
  1230.     if (pApp != NULL && 
  1231.         LOWORD(lParam) != 0 && HIWORD(lParam) != 0 &&
  1232.         (ATOM)LOWORD(lParam) == pApp->m_atomApp &&
  1233.         (ATOM)HIWORD(lParam) == pApp->m_atomSystemTopic)
  1234.     {
  1235.         // make duplicates of the incoming atoms (really adding a reference)
  1236.         TCHAR szAtomName[_MAX_PATH];
  1237.         VERIFY(GlobalGetAtomName(pApp->m_atomApp,
  1238.             szAtomName, _MAX_PATH - 1) != 0);
  1239.         VERIFY(GlobalAddAtom(szAtomName) == pApp->m_atomApp);
  1240.         VERIFY(GlobalGetAtomName(pApp->m_atomSystemTopic,
  1241.             szAtomName, _MAX_PATH - 1) != 0);
  1242.         VERIFY(GlobalAddAtom(szAtomName) == pApp->m_atomSystemTopic);
  1243.  
  1244.         // send the WM_DDE_ACK (caller will delete duplicate atoms)
  1245.         ::SendMessage((HWND)wParam, WM_DDE_ACK, (WPARAM)m_hWnd,
  1246.             MAKELPARAM(pApp->m_atomApp, pApp->m_atomSystemTopic));
  1247.     }
  1248.     return 0L;
  1249. }
  1250.  
  1251. // always ACK the execute command - even if we do nothing
  1252. LRESULT CFrameWnd::OnDDEExecute(WPARAM wParam, LPARAM lParam)
  1253. {
  1254.     // unpack the DDE message
  1255.     UINT unused;
  1256.     HGLOBAL hData;
  1257.     VERIFY(UnpackDDElParam(WM_DDE_EXECUTE, lParam, &unused, (UINT*)&hData));
  1258.  
  1259.     // get the command string
  1260.     TCHAR szCommand[_MAX_PATH * 2];
  1261.     LPCTSTR lpsz = (LPCTSTR)GlobalLock(hData);
  1262.     lstrcpyn(szCommand, lpsz, _countof(szCommand));
  1263.     GlobalUnlock(hData);
  1264.  
  1265.     // acknowledge now - before attempting to execute
  1266.     ::PostMessage((HWND)wParam, WM_DDE_ACK, (WPARAM)m_hWnd,
  1267.         ReuseDDElParam(lParam, WM_DDE_EXECUTE, WM_DDE_ACK,
  1268.         (UINT)0x8000, (UINT)hData));
  1269.  
  1270.     // don't execute the command when the window is disabled
  1271.     if (!IsWindowEnabled())
  1272.     {
  1273.         TRACE1("Warning: DDE command '%s' ignored because window is disabled.\n",
  1274.             szCommand);
  1275.         return 0;
  1276.     }
  1277.  
  1278.     // execute the command
  1279.     if (!AfxGetApp()->OnDDECommand(szCommand))
  1280.         TRACE1("Error: failed to execute DDE command '%s'.\n", szCommand);
  1281.  
  1282.     return 0L;
  1283. }
  1284.  
  1285. LRESULT CFrameWnd::OnDDETerminate(WPARAM wParam, LPARAM lParam)
  1286. {
  1287.     ::PostMessage((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)m_hWnd, lParam);
  1288.     return 0L;
  1289. }
  1290. #endif // _WIN32_WCE
  1291.  
  1292. /////////////////////////////////////////////////////////////////////////////
  1293. // CFrameWnd attributes
  1294.  
  1295. CView* CFrameWnd::GetActiveView() const
  1296. {
  1297.     ASSERT(m_pViewActive == NULL ||
  1298.         m_pViewActive->IsKindOf(RUNTIME_CLASS(CView)));
  1299.     return m_pViewActive;
  1300. }
  1301.  
  1302. void CFrameWnd::SetActiveView(CView* pViewNew, BOOL bNotify)
  1303. {
  1304. #ifdef _DEBUG
  1305.     if (pViewNew != NULL)
  1306.     {
  1307.         ASSERT(IsChild(pViewNew));
  1308.         ASSERT_KINDOF(CView, pViewNew);
  1309.     }
  1310. #endif //_DEBUG
  1311.  
  1312.     CView* pViewOld = m_pViewActive;
  1313.     if (pViewNew == pViewOld)
  1314.         return;     // do not re-activate if SetActiveView called more than once
  1315.  
  1316.     m_pViewActive = NULL;   // no active for the following processing
  1317.  
  1318.     // deactivate the old one
  1319.     if (pViewOld != NULL)
  1320.         pViewOld->OnActivateView(FALSE, pViewNew, pViewOld);
  1321.  
  1322.     // if the OnActivateView moves the active window,
  1323.     //    that will veto this change
  1324.     if (m_pViewActive != NULL)
  1325.         return;     // already set
  1326.     m_pViewActive = pViewNew;
  1327.  
  1328.     // activate
  1329.     if (pViewNew != NULL && bNotify)
  1330.         pViewNew->OnActivateView(TRUE, pViewNew, pViewOld);
  1331. }
  1332.  
  1333. /////////////////////////////////////////////////////////////////////////////
  1334. // Special view swapping/activation
  1335.  
  1336. void CFrameWnd::OnSetFocus(CWnd* pOldWnd)
  1337. {
  1338.     if (m_pViewActive != NULL)
  1339.         m_pViewActive->SetFocus();
  1340.     else
  1341.         CWnd::OnSetFocus(pOldWnd);
  1342. }
  1343.  
  1344. CDocument* CFrameWnd::GetActiveDocument()
  1345. {
  1346.     ASSERT_VALID(this);
  1347.     CView* pView = GetActiveView();
  1348.     if (pView != NULL)
  1349.         return pView->GetDocument();
  1350.     return NULL;
  1351. }
  1352.  
  1353. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  1354. void CFrameWnd::ShowControlBar(CControlBar* pBar, BOOL bShow, BOOL bDelay)
  1355. {
  1356.     ASSERT(pBar != NULL);
  1357.     CFrameWnd* pParentFrame = pBar->GetDockingFrame();
  1358.     ASSERT(pParentFrame->GetTopLevelParent() == GetTopLevelParent());
  1359.         // parent frame of bar must be related
  1360.  
  1361.     if (bDelay)
  1362.     {
  1363.         pBar->DelayShow(bShow);
  1364.         pParentFrame->DelayRecalcLayout();
  1365.     }
  1366.     else
  1367.     {
  1368.         pBar->SetWindowPos(NULL, 0, 0, 0, 0,
  1369.             SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|
  1370.             (bShow ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  1371.         // call DelayShow to clear any contradictory DelayShow
  1372.         pBar->DelayShow(bShow);
  1373.         if (bShow || !pBar->IsFloating())
  1374.             pParentFrame->RecalcLayout(FALSE);
  1375.     }
  1376.  
  1377. #if !defined(_WIN32_WCE_NO_DOCKBARS)
  1378.     // show or hide the floating frame as appropriate
  1379.     if (pBar->IsFloating())
  1380.     {
  1381.         int nVisCount = pBar->m_pDockBar != NULL ?
  1382.             pBar->m_pDockBar->GetDockedVisibleCount() : bShow ? 1 : 0;
  1383.         if (nVisCount == 1 && bShow)
  1384.         {
  1385.             pParentFrame->m_nShowDelay = -1;
  1386.             if (bDelay)
  1387.             {
  1388.                 pParentFrame->m_nShowDelay = SW_SHOWNA;
  1389.                 pParentFrame->RecalcLayout(FALSE);
  1390.             }
  1391.             else
  1392.                 pParentFrame->ShowWindow(SW_SHOWNA);
  1393.         }
  1394.         else if (nVisCount == 0)
  1395.         {
  1396.             ASSERT(!bShow);
  1397.             pParentFrame->m_nShowDelay = -1;
  1398.             if (bDelay)
  1399.                 pParentFrame->m_nShowDelay = SW_HIDE;
  1400.             else
  1401.                 pParentFrame->ShowWindow(SW_HIDE);
  1402.         }
  1403.         else if (!bDelay)
  1404.         {
  1405.             pParentFrame->RecalcLayout(FALSE);
  1406.         }
  1407.     }
  1408. #endif // _WIN32_WCE_NO_DOCKBARS
  1409. }
  1410. #endif // _WIN32_WCE_NO_CONTROLBARS
  1411.  
  1412. /////////////////////////////////////////////////////////////////////////////
  1413. // Command prompts
  1414.  
  1415. #if !defined(_WIN32_WCE)
  1416. void CFrameWnd::OnInitMenu(CMenu* pMenu)
  1417. {
  1418. #ifndef _AFX_NO_OLE_SUPPORT
  1419.     // allow hook to consume message
  1420.     if (m_pNotifyHook != NULL)
  1421.     {
  1422. #ifdef _AFXDLL
  1423.         ASSERT(m_pModuleState != NULL);
  1424.         if (m_pModuleState->m_dwVersion >= 0x423)
  1425. #endif
  1426.             m_pNotifyHook->OnInitMenu(pMenu);
  1427. #endif
  1428.     }
  1429.  
  1430.     Default();
  1431. }
  1432. #endif // _WIN32_WCE
  1433.  
  1434. void CFrameWnd::OnInitMenuPopup(CMenu* pMenu, UINT nIndex, BOOL bSysMenu)
  1435. {
  1436.     AfxCancelModes(m_hWnd);
  1437.  
  1438.     if (bSysMenu)
  1439.         return;     // don't support system menu
  1440.  
  1441. #if !defined(_WIN32_WCE)
  1442. #ifndef _AFX_NO_OLE_SUPPORT
  1443.     // allow hook to consume message
  1444.     if (m_pNotifyHook != NULL)
  1445.     {
  1446. #ifdef _AFXDLL
  1447.         ASSERT(m_pModuleState != NULL);
  1448.         if (m_pModuleState->m_dwVersion >= 0x423)
  1449. #endif
  1450.             if (m_pNotifyHook->OnInitMenuPopup(pMenu, nIndex, bSysMenu))
  1451.                 return;
  1452.     }
  1453. #endif
  1454. #endif // _WIN32_WCE
  1455.  
  1456.     ASSERT(pMenu != NULL);
  1457.     // check the enabled state of various menu items
  1458.  
  1459.     CCmdUI state;
  1460.     state.m_pMenu = pMenu;
  1461.     ASSERT(state.m_pOther == NULL);
  1462.     ASSERT(state.m_pParentMenu == NULL);
  1463.  
  1464.     // determine if menu is popup in top-level menu and set m_pOther to
  1465.     //  it if so (m_pParentMenu == NULL indicates that it is secondary popup)
  1466.     HMENU hParentMenu;
  1467.     if (AfxGetThreadState()->m_hTrackingMenu == pMenu->m_hMenu)
  1468.         state.m_pParentMenu = pMenu;    // parent == child for tracking popup
  1469.     else if ((hParentMenu = ::WCE_FCTN(GetMenu)(m_hWnd)) != NULL)
  1470.     {
  1471.         CWnd* pParent = GetTopLevelParent();
  1472.             // child windows don't have menus -- need to go to the top!
  1473.         if (pParent != NULL &&
  1474.             (hParentMenu = ::WCE_FCTN(GetMenu)(pParent->m_hWnd)) != NULL)
  1475.         {
  1476.             int nIndexMax = ::WCE_FCTN(GetMenuItemCount)(hParentMenu);
  1477.             for (int nIndex = 0; nIndex < nIndexMax; nIndex++)
  1478.             {
  1479.                 if (::GetSubMenu(hParentMenu, nIndex) == pMenu->m_hMenu)
  1480.                 {
  1481.                     // when popup is found, m_pParentMenu is containing menu
  1482.                     state.m_pParentMenu = CMenu::FromHandle(hParentMenu);
  1483.                     break;
  1484.                 }
  1485.             }
  1486.         }
  1487.     }
  1488.  
  1489.     state.m_nIndexMax = pMenu->GetMenuItemCount();
  1490.     for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax;
  1491.       state.m_nIndex++)
  1492.     {
  1493.         state.m_nID = pMenu->GetMenuItemID(state.m_nIndex);
  1494.         if (state.m_nID == 0)
  1495.             continue; // menu separator or invalid cmd - ignore it
  1496.  
  1497.         ASSERT(state.m_pOther == NULL);
  1498.         ASSERT(state.m_pMenu != NULL);
  1499.         if (state.m_nID == (UINT)-1)
  1500.         {
  1501.             // possibly a popup menu, route to first item of that popup
  1502.             state.m_pSubMenu = pMenu->GetSubMenu(state.m_nIndex);
  1503.             if (state.m_pSubMenu == NULL ||
  1504.                 (state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
  1505.                 state.m_nID == (UINT)-1)
  1506.             {
  1507.                 continue;       // first item of popup can't be routed to
  1508.             }
  1509.             state.DoUpdate(this, FALSE);    // popups are never auto disabled
  1510.         }
  1511.         else
  1512.         {
  1513.             // normal menu item
  1514.             // Auto enable/disable if frame window has 'm_bAutoMenuEnable'
  1515.             //    set and command is _not_ a system command.
  1516.             state.m_pSubMenu = NULL;
  1517.             state.DoUpdate(this, m_bAutoMenuEnable && state.m_nID < 0xF000);
  1518.         }
  1519.  
  1520.         // adjust for menu deletions and additions
  1521.         UINT nCount = pMenu->GetMenuItemCount();
  1522.         if (nCount < state.m_nIndexMax)
  1523.         {
  1524.             state.m_nIndex -= (state.m_nIndexMax - nCount);
  1525.             while (state.m_nIndex < nCount &&
  1526.                 pMenu->GetMenuItemID(state.m_nIndex) == state.m_nID)
  1527.             {
  1528.                 state.m_nIndex++;
  1529.             }
  1530.         }
  1531.         state.m_nIndexMax = nCount;
  1532.     }
  1533. }
  1534.  
  1535. #if !defined(_WIN32_WCE)
  1536. void CFrameWnd::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
  1537. {
  1538.     CFrameWnd* pFrameWnd = GetTopLevelFrame();
  1539.     ASSERT_VALID(pFrameWnd);
  1540.  
  1541. #ifndef _AFX_NO_OLE_SUPPORT
  1542.     // allow hook to consume message
  1543.     if (m_pNotifyHook != NULL)
  1544.     {
  1545. #ifdef _AFXDLL
  1546.         ASSERT(m_pModuleState != NULL);
  1547.         if (m_pModuleState->m_dwVersion >= 0x423)
  1548. #endif
  1549.             if (m_pNotifyHook->OnMenuSelect(nItemID, nFlags, hSysMenu))
  1550.                 return;
  1551.     }
  1552. #endif
  1553.  
  1554.     // set the tracking state (update on idle)
  1555.     if (nFlags == 0xFFFF)
  1556.     {
  1557.         // cancel menu operation (go back to idle now)
  1558.         m_nFlags &= ~WF_NOPOPMSG;
  1559.         if (!pFrameWnd->m_bHelpMode)
  1560.             m_nIDTracking = AFX_IDS_IDLEMESSAGE;
  1561.         else
  1562.             m_nIDTracking = AFX_IDS_HELPMODEMESSAGE;
  1563.         SendMessage(WM_SETMESSAGESTRING, (WPARAM)m_nIDTracking);
  1564.         ASSERT(m_nIDTracking == m_nIDLastMessage);
  1565.  
  1566.         // update right away
  1567.         CWnd* pWnd = GetMessageBar();
  1568.         if (pWnd != NULL)
  1569.             pWnd->UpdateWindow();
  1570.     }
  1571.     else
  1572.     {
  1573.         if (nItemID == 0 || nFlags & (MF_SEPARATOR|MF_POPUP))
  1574.         {
  1575.             // nothing should be displayed
  1576.             m_nIDTracking = 0;
  1577.         }
  1578.         else if (nItemID >= 0xF000 && nItemID < 0xF1F0) // max of 31 SC_s
  1579.         {
  1580.             // special strings table entries for system commands
  1581.             m_nIDTracking = ID_COMMAND_FROM_SC(nItemID);
  1582.             ASSERT(m_nIDTracking >= AFX_IDS_SCFIRST &&
  1583.                 m_nIDTracking < AFX_IDS_SCFIRST + 31);
  1584.         }
  1585.         else if (nItemID >= AFX_IDM_FIRST_MDICHILD)
  1586.         {
  1587.             // all MDI Child windows map to the same help id
  1588.             m_nIDTracking = AFX_IDS_MDICHILD;
  1589.         }
  1590.         else
  1591.         {
  1592.             // track on idle
  1593.             m_nIDTracking = nItemID;
  1594.         }
  1595.         pFrameWnd->m_nFlags |= WF_NOPOPMSG;
  1596.     }
  1597.  
  1598.     // when running in-place, it is necessary to cause a message to
  1599.     //  be pumped through the queue.
  1600.     if (m_nIDTracking != m_nIDLastMessage && GetParent() != NULL)
  1601.         PostMessage(WM_KICKIDLE);
  1602. }
  1603. #endif // _WIN32_WCE
  1604.  
  1605. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  1606. void CFrameWnd::GetMessageString(UINT nID, CString& rMessage) const
  1607. {
  1608.     // load appropriate string
  1609.     LPTSTR lpsz = rMessage.GetBuffer(255);
  1610.     if (AfxLoadString(nID, lpsz) != 0)
  1611.     {
  1612.         // first newline terminates actual string
  1613.         lpsz = _tcschr(lpsz, '\n');
  1614.         if (lpsz != NULL)
  1615.             *lpsz = '\0';
  1616.     }
  1617.     else
  1618.     {
  1619.         // not found
  1620.         TRACE1("Warning: no message line prompt for ID 0x%04X.\n", nID);
  1621.     }
  1622.     rMessage.ReleaseBuffer();
  1623. }
  1624.  
  1625. LRESULT CFrameWnd::OnPopMessageString(WPARAM wParam, LPARAM lParam)
  1626. {
  1627.     if (m_nFlags & WF_NOPOPMSG)
  1628.         return 0;
  1629.  
  1630.     return SendMessage(WM_SETMESSAGESTRING, wParam, lParam);
  1631. }
  1632.  
  1633. LRESULT CFrameWnd::OnSetMessageString(WPARAM wParam, LPARAM lParam)
  1634. {
  1635.     UINT nIDLast = m_nIDLastMessage;
  1636.     m_nFlags &= ~WF_NOPOPMSG;
  1637.  
  1638.     CWnd* pMessageBar = GetMessageBar();
  1639.     if (pMessageBar != NULL)
  1640.     {
  1641.         LPCTSTR lpsz = NULL;
  1642.         CString strMessage;
  1643.  
  1644.         // set the message bar text
  1645.         if (lParam != 0)
  1646.         {
  1647.             ASSERT(wParam == 0);    // can't have both an ID and a string
  1648.             lpsz = (LPCTSTR)lParam; // set an explicit string
  1649.         }
  1650.         else if (wParam != 0)
  1651.         {
  1652.             // map SC_CLOSE to PREVIEW_CLOSE when in print preview mode
  1653.             if (wParam == AFX_IDS_SCCLOSE && m_lpfnCloseProc != NULL)
  1654.                 wParam = AFX_IDS_PREVIEW_CLOSE;
  1655.  
  1656.             // get message associated with the ID indicated by wParam
  1657.             GetMessageString(wParam, strMessage);
  1658.             lpsz = strMessage;
  1659.         }
  1660.         pMessageBar->SetWindowText(lpsz);
  1661.  
  1662.         // update owner of the bar in terms of last message selected
  1663.         CFrameWnd* pFrameWnd = pMessageBar->GetParentFrame();
  1664.         if (pFrameWnd != NULL)
  1665.         {
  1666.             pFrameWnd->m_nIDLastMessage = (UINT)wParam;
  1667.             pFrameWnd->m_nIDTracking = (UINT)wParam;
  1668.         }
  1669.     }
  1670.  
  1671.     m_nIDLastMessage = (UINT)wParam;    // new ID (or 0)
  1672.     m_nIDTracking = (UINT)wParam;       // so F1 on toolbar buttons work
  1673.     return nIDLast;
  1674. }
  1675.  
  1676. LRESULT CFrameWnd::OnHelpPromptAddr(WPARAM, LPARAM)
  1677. {
  1678.     return (LRESULT)&m_dwPromptContext;
  1679. }
  1680.  
  1681. CWnd* CFrameWnd::GetMessageBar()
  1682. {
  1683.     return GetDescendantWindow(AFX_IDW_STATUS_BAR, TRUE);
  1684. }
  1685.  
  1686. #if !defined(_WIN32_WCE)
  1687. void CFrameWnd::OnEnterIdle(UINT nWhy, CWnd* pWho)
  1688. {
  1689.     CWnd::OnEnterIdle(nWhy, pWho);
  1690.  
  1691.     if (nWhy != MSGF_MENU || m_nIDTracking == m_nIDLastMessage)
  1692.         return;
  1693.  
  1694.     SetMessageText(m_nIDTracking);
  1695.     ASSERT(m_nIDTracking == m_nIDLastMessage);
  1696. }
  1697. #endif // _WIN32_WCE
  1698.  
  1699. void CFrameWnd::SetMessageText(LPCTSTR lpszText)
  1700. {
  1701.     SendMessage(WM_SETMESSAGESTRING, 0, (LPARAM)lpszText);
  1702. }
  1703.  
  1704. void CFrameWnd::SetMessageText(UINT nID)
  1705. {
  1706.     SendMessage(WM_SETMESSAGESTRING, (WPARAM)nID);
  1707. }
  1708.  
  1709. /////////////////////////////////////////////////////////////////////////////
  1710. // CFrameWnd standard control bar management
  1711.  
  1712. #if defined(_WIN32_WCE_NO_DOCKBARS)
  1713. void CFrameWnd::DestroyDockBars()
  1714. {
  1715.     POSITION pos = m_listControlBars.GetHeadPosition();
  1716.     while (pos != NULL)
  1717.     {
  1718.         CControlBar* pControlBar = (CControlBar*)m_listControlBars.GetNext(pos);
  1719.         ASSERT(pControlBar != NULL);
  1720.         pControlBar->DestroyWindow();
  1721.     }
  1722. }
  1723. #else // _WIN32_WCE_NO_DOCKBARS
  1724. void CFrameWnd::DestroyDockBars()
  1725. {
  1726.     // create a list of all the dock bars
  1727.     // this is necessary because m_listControlBars will change
  1728.     // as the dock bars and floating frames are destroyed
  1729.     CPtrList listDockBars;
  1730.     POSITION pos = m_listControlBars.GetHeadPosition();
  1731.     while (pos != NULL)
  1732.     {
  1733.         DockBar* pDockBar = (CDockBar*)m_listControlBars.GetNext(pos);
  1734.         ASSERT(pDockBar != NULL);
  1735.         if (pDockBar->IsDockBar())
  1736.             listDockBars.AddTail(pDockBar);
  1737.     }
  1738.     pos = listDockBars.GetHeadPosition();
  1739.     while (pos != NULL)
  1740.     {
  1741.         CDockBar* pDockBar = (CDockBar*)listDockBars.GetNext(pos);
  1742.         if (pDockBar->m_bFloating)
  1743.         {
  1744.             CFrameWnd* pFrameWnd = pDockBar->GetParentFrame();
  1745.             ASSERT_VALID(pFrameWnd);
  1746.             pFrameWnd->DestroyWindow();
  1747.         }
  1748.         else
  1749.             pDockBar->DestroyWindow();
  1750.     }
  1751. }
  1752. #endif // _WIN32_WCE_NO_DOCKBARS
  1753.  
  1754. CControlBar* CFrameWnd::GetControlBar(UINT nID)
  1755. {
  1756.     if (nID == 0)
  1757.         return NULL;
  1758.     POSITION pos = m_listControlBars.GetHeadPosition();
  1759.     while (pos != NULL)
  1760.     {
  1761.         CControlBar* pBar = (CControlBar*)m_listControlBars.GetNext(pos);
  1762.         ASSERT(pBar != NULL);
  1763.         if (_AfxGetDlgCtrlID(pBar->m_hWnd) == nID)
  1764.         {
  1765.             ASSERT_KINDOF(CControlBar, pBar);
  1766.             return pBar;
  1767.         }
  1768.     }
  1769.     return NULL;
  1770. }
  1771.  
  1772. void CFrameWnd::OnUpdateControlBarMenu(CCmdUI* pCmdUI)
  1773. {
  1774.     ASSERT(ID_VIEW_STATUS_BAR == AFX_IDW_STATUS_BAR);
  1775.     ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
  1776.     ASSERT(ID_VIEW_REBAR == AFX_IDW_REBAR);
  1777.  
  1778.     CControlBar* pBar = GetControlBar(pCmdUI->m_nID);
  1779.     if (pBar != NULL)
  1780.     {
  1781.         pCmdUI->SetCheck((pBar->GetStyle() & WS_VISIBLE) != 0);
  1782.         return;
  1783.     }
  1784.     pCmdUI->ContinueRouting();
  1785. }
  1786.  
  1787. BOOL CFrameWnd::OnBarCheck(UINT nID)
  1788. {
  1789.     ASSERT(ID_VIEW_STATUS_BAR == AFX_IDW_STATUS_BAR);
  1790.     ASSERT(ID_VIEW_TOOLBAR == AFX_IDW_TOOLBAR);
  1791.     ASSERT(ID_VIEW_REBAR == AFX_IDW_REBAR);
  1792.  
  1793.     CControlBar* pBar = GetControlBar(nID);
  1794.     if (pBar != NULL)
  1795.     {
  1796.         ShowControlBar(pBar, (pBar->GetStyle() & WS_VISIBLE) == 0, FALSE);
  1797.         return TRUE;
  1798.     }
  1799.     return FALSE;
  1800. }
  1801.  
  1802. #if !defined(_WIN32_WCE_NO_TOOLTIPS)
  1803. BOOL CFrameWnd::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
  1804. {
  1805.     ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
  1806.  
  1807.     // need to handle both ANSI and UNICODE versions of the message
  1808.     TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  1809.     TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  1810.     TCHAR szFullText[256];
  1811.     CString strTipText;
  1812.     UINT nID = pNMHDR->idFrom;
  1813.     if (pNMHDR->code == TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
  1814.         pNMHDR->code == TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND))
  1815.     {
  1816.         // idFrom is actually the HWND of the tool
  1817.         nID = _AfxGetDlgCtrlID((HWND)nID);
  1818.     }
  1819.  
  1820.     if (nID != 0) // will be zero on a separator
  1821.     {
  1822.         // don't handle the message if no string resource found
  1823.         if (AfxLoadString(nID, szFullText) == 0)
  1824.             return FALSE;
  1825.  
  1826.         // this is the command id, not the button index
  1827.         AfxExtractSubString(strTipText, szFullText, 1, '\n');
  1828.     }
  1829. #ifndef _UNICODE
  1830.     if (pNMHDR->code == TTN_NEEDTEXTA)
  1831.         lstrcpyn(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1832.     else
  1833.         _mbstowcsz(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1834. #else
  1835.     if (pNMHDR->code == TTN_NEEDTEXTA)
  1836.         _wcstombsz(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1837.     else
  1838.         lstrcpyn(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1839. #endif
  1840.     *pResult = 0;
  1841.  
  1842.     // bring the tooltip window above other popup windows
  1843.     ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
  1844.         SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER);
  1845.  
  1846.     return TRUE;    // message was handled
  1847. }
  1848. #endif // _WIN32_WCE_NO_TOOLTIPS
  1849.  
  1850.  
  1851. /////////////////////////////////////////////////////////////////////////////
  1852. // Support for standard status bar
  1853.  
  1854. void CFrameWnd::OnUpdateKeyIndicator(CCmdUI* pCmdUI)
  1855. {
  1856.     UINT nVK;
  1857.     UINT flag = 0x0001;
  1858.  
  1859.     switch (pCmdUI->m_nID)
  1860.     {
  1861.     case ID_INDICATOR_CAPS:
  1862.         nVK = VK_CAPITAL;
  1863.         break;
  1864.  
  1865.     case ID_INDICATOR_NUM:
  1866.         nVK = VK_NUMLOCK;
  1867.         break;
  1868.  
  1869.     case ID_INDICATOR_SCRL:
  1870.         nVK = VK_SCROLL;
  1871.         break;
  1872.  
  1873.     case ID_INDICATOR_KANA:
  1874.         nVK = VK_KANA;
  1875.         // WINBUG: Special case for Windows 3.x.  The wrong bit was toggled
  1876.         // in those systems so this must be special cased.  This is fixed
  1877.         // on systems whose version is 4.x or greater.
  1878.         if (!afxData.bWin4)
  1879.             flag = 0x8000;
  1880.         break;
  1881.  
  1882.     default:
  1883.         TRACE1("Warning: OnUpdateKeyIndicator - unknown indicator 0x%04X.\n",
  1884.             pCmdUI->m_nID);
  1885.         pCmdUI->ContinueRouting();
  1886.         return; // not for us
  1887.     }
  1888.  
  1889.     pCmdUI->Enable(::GetKeyState(nVK) & flag);
  1890.         // enable static text based on toggled key state
  1891.     ASSERT(pCmdUI->m_bEnableChanged);
  1892. }
  1893. #endif // _WIN32_WCE_NO_CONTROLBARS
  1894.  
  1895.  
  1896. #if !defined(_WIN32_WCE)
  1897. void CFrameWnd::OnUpdateContextHelp(CCmdUI* pCmdUI)
  1898. {
  1899.     if (AfxGetMainWnd() == this)
  1900.         pCmdUI->SetCheck(!!m_bHelpMode);
  1901.     else
  1902.         pCmdUI->ContinueRouting();
  1903. }
  1904. #endif // _WIN32_WCE
  1905.  
  1906. /////////////////////////////////////////////////////////////////////////////
  1907. // Setting title of frame window - UISG standard
  1908.  
  1909. void CFrameWnd::OnUpdateFrameTitle(BOOL bAddToTitle)
  1910. {
  1911.     if ((GetStyle() & FWS_ADDTOTITLE) == 0)
  1912.         return;     // leave it alone!
  1913.  
  1914. #if !defined(_WIN32_WCE)
  1915. #ifndef _AFX_NO_OLE_SUPPORT
  1916.     // allow hook to set the title (used for OLE support)
  1917.     if (m_pNotifyHook != NULL && m_pNotifyHook->OnUpdateFrameTitle())
  1918.         return;
  1919. #endif
  1920. #endif // _WIN32_WCE
  1921.  
  1922.     CDocument* pDocument = GetActiveDocument();
  1923.     if (bAddToTitle && pDocument != NULL)
  1924.         UpdateFrameTitleForDocument(pDocument->GetTitle());
  1925.     else
  1926.         UpdateFrameTitleForDocument(NULL);
  1927. }
  1928.  
  1929. void CFrameWnd::UpdateFrameTitleForDocument(LPCTSTR lpszDocName)
  1930. {
  1931.     // copy first part of title loaded at time of frame creation
  1932.     TCHAR szText[256+_MAX_PATH];
  1933.  
  1934.     if (GetStyle() & FWS_PREFIXTITLE)
  1935.     {
  1936.         szText[0] = '\0';   // start with nothing
  1937.  
  1938.         // get name of currently active view
  1939.         if (lpszDocName != NULL)
  1940.         {
  1941.             lstrcpy(szText, lpszDocName);
  1942.             // add current window # if needed
  1943.             if (m_nWindow > 0)
  1944.                 wsprintf(szText + lstrlen(szText), _T(":%d"), m_nWindow);
  1945.             lstrcat(szText, _T(" - "));
  1946.         }
  1947.         lstrcat(szText, m_strTitle);
  1948.     }
  1949.     else
  1950.     {
  1951.         // get name of currently active view
  1952.         lstrcpy(szText, m_strTitle);
  1953.         if (lpszDocName != NULL)
  1954.         {
  1955.             lstrcat(szText, _T(" - "));
  1956.             lstrcat(szText, lpszDocName);
  1957.             // add current window # if needed
  1958.             if (m_nWindow > 0)
  1959.                 wsprintf(szText + lstrlen(szText), _T(":%d"), m_nWindow);
  1960.         }
  1961.     }
  1962.  
  1963.     // set title if changed, but don't remove completely
  1964.     // Note: will be excessive for MDI Frame with maximized child
  1965.     AfxSetWindowText(m_hWnd, szText);
  1966. }
  1967.  
  1968. /////////////////////////////////////////////////////////////////////////////
  1969.  
  1970. #if !defined(_WIN32_WCE)
  1971. void CFrameWnd::OnSetPreviewMode(BOOL bPreview, CPrintPreviewState* pState)
  1972. {
  1973.     // default implementation changes control bars, menu and main pane window
  1974.  
  1975. #ifndef _AFX_NO_OLE_SUPPORT
  1976.     CFrameWnd* pActiveFrame = GetActiveFrame();
  1977.     ASSERT_VALID(pActiveFrame);
  1978.     if (bPreview && pActiveFrame->m_pNotifyHook != NULL)
  1979.         pActiveFrame->m_pNotifyHook->OnDocActivate(FALSE);
  1980. #endif
  1981.  
  1982.     // Set visibility of standard ControlBars (only the first 32)
  1983.     DWORD dwOldStates = 0;
  1984.     POSITION pos = m_listControlBars.GetHeadPosition();
  1985.     while (pos != NULL)
  1986.     {
  1987.         CControlBar* pBar = (CControlBar*)m_listControlBars.GetNext(pos);
  1988.         ASSERT_VALID(pBar);
  1989.         UINT nID = _AfxGetDlgCtrlID(pBar->m_hWnd);
  1990.         if (nID >= AFX_IDW_CONTROLBAR_FIRST && nID <= AFX_IDW_CONTROLBAR_FIRST+31)
  1991.         {
  1992.             DWORD dwMask = 1L << (nID - AFX_IDW_CONTROLBAR_FIRST);
  1993.             if (pBar->IsVisible())
  1994.                 dwOldStates |= dwMask;      // save if previously visible
  1995.             if (!pBar->IsDockBar() || nID != AFX_IDW_DOCKBAR_FLOAT)
  1996.                 ShowControlBar(pBar, (pState->dwStates & dwMask), TRUE);
  1997.         }
  1998.     }
  1999.     pState->dwStates = dwOldStates; // save for restore
  2000.  
  2001.     if (bPreview)
  2002.     {
  2003.         // Entering Print Preview
  2004.         ASSERT(m_lpfnCloseProc == NULL);    // no chaining
  2005.         m_lpfnCloseProc = pState->lpfnCloseProc;
  2006.  
  2007.         // show any modeless dialogs, popup windows, float tools, etc
  2008.         ShowOwnedWindows(FALSE);
  2009.  
  2010.         // Hide the main pane
  2011.         HWND hWnd = ::GetDlgItem(m_hWnd, pState->nIDMainPane);
  2012.         ASSERT(hWnd != NULL);       // must be one that we are hiding!
  2013.         ::ShowWindow(hWnd, SW_HIDE);
  2014.  
  2015.         // Get rid of the menu first (will resize the window)
  2016.         pState->hMenu = ::GetMenu(m_hWnd);
  2017.         if (pState->hMenu != NULL)
  2018.         {
  2019.             // Invalidate before SetMenu since we are going to replace
  2020.             //  the frame's client area anyway
  2021.             Invalidate();
  2022.             SetMenu(NULL);
  2023.             m_nIdleFlags &= ~idleMenu;  // avoid any idle menu processing
  2024.         }
  2025.  
  2026.         // Save the accelerator table and remove it.
  2027.         pState->hAccelTable = m_hAccelTable;
  2028.         m_hAccelTable = NULL;
  2029.         LoadAccelTable(MAKEINTRESOURCE(AFX_IDR_PREVIEW_ACCEL));
  2030.  
  2031.         // Make room for the PreviewView by changing AFX_IDW_PANE_FIRST's ID
  2032.         //  to AFX_IDW_PREVIEW_FIRST
  2033.         if (pState->nIDMainPane != AFX_IDW_PANE_FIRST)
  2034.             hWnd = ::GetDlgItem(m_hWnd, AFX_IDW_PANE_FIRST);
  2035.         if (hWnd != NULL)
  2036.             _AfxSetDlgCtrlID(hWnd, AFX_IDW_PANE_SAVE);
  2037.  
  2038. #ifdef _DEBUG
  2039.         if ((::GetWindowLong(m_hWnd, GWL_STYLE) & (WS_HSCROLL|WS_VSCROLL)) != 0)
  2040.             TRACE0("Warning: scroll bars in frame windows may cause unusual behaviour.\n");
  2041. #endif
  2042.     }
  2043.     else
  2044.     {
  2045.         // Leaving Preview
  2046.         m_lpfnCloseProc = NULL;
  2047.  
  2048.         // shift original AFX_IDW_PANE_FIRST back to its rightful ID
  2049.         HWND hWnd = ::GetDlgItem(m_hWnd, AFX_IDW_PANE_SAVE);
  2050.         if (hWnd != NULL)
  2051.         {
  2052.             HWND hWndTemp = ::GetDlgItem(m_hWnd, AFX_IDW_PANE_FIRST);
  2053.             if (hWndTemp != NULL)
  2054.                 _AfxSetDlgCtrlID(hWndTemp, AFX_IDW_PANE_SAVE);
  2055.             _AfxSetDlgCtrlID(hWnd, AFX_IDW_PANE_FIRST);
  2056.         }
  2057.  
  2058.         // put the menu back in place if it was removed before
  2059.         if (pState->hMenu != NULL)
  2060.         {
  2061.             // Invalidate before SetMenu since we are going to replace
  2062.             //  the frame's client area anyway
  2063.             Invalidate();
  2064.             ::SetMenu(m_hWnd, pState->hMenu);
  2065.         }
  2066.  
  2067.         // recalc layout now, before showing the main pane
  2068. #ifndef _AFX_NO_OLE_SUPPORT
  2069.         if (pActiveFrame->m_pNotifyHook != NULL)
  2070.             pActiveFrame->m_pNotifyHook->OnDocActivate(TRUE);
  2071. #endif
  2072.         RecalcLayout();
  2073.  
  2074.         // now show main pane that was hidden
  2075.         if (pState->nIDMainPane != AFX_IDW_PANE_FIRST)
  2076.             hWnd = ::GetDlgItem(m_hWnd, pState->nIDMainPane);
  2077.         ASSERT(hWnd != NULL);
  2078.         ::ShowWindow(hWnd, SW_SHOW);
  2079.  
  2080.         // Restore the Accelerator table
  2081.         m_hAccelTable = pState->hAccelTable;
  2082.  
  2083.         // show any modeless dialogs, popup windows, float tools, etc
  2084.         ShowOwnedWindows(TRUE);
  2085.     }
  2086. }
  2087. #endif // _WIN32_WCE
  2088.  
  2089. void CFrameWnd::DelayUpdateFrameMenu(HMENU hMenuAlt)
  2090. {
  2091.     m_hMenuAlt = hMenuAlt;
  2092.     m_nIdleFlags |= idleMenu;
  2093. }
  2094.  
  2095. void CFrameWnd::OnIdleUpdateCmdUI()
  2096. {
  2097.     // update menu if necessary
  2098.     if (m_nIdleFlags & idleMenu)
  2099.         OnUpdateFrameMenu(m_hMenuAlt);
  2100.  
  2101.     // update title if necessary
  2102.     if (m_nIdleFlags & idleTitle)
  2103.         OnUpdateFrameTitle(TRUE);
  2104.  
  2105.     // recalc layout if necessary
  2106.     if (m_nIdleFlags & idleLayout)
  2107.     {
  2108.         RecalcLayout(m_nIdleFlags & idleNotify);
  2109.         UpdateWindow();
  2110.     }
  2111.  
  2112. #if !defined(_WIN32_WCE_NO_TOOLTIPS)
  2113.     // set the current message string if necessary
  2114.     if (m_nIDTracking != m_nIDLastMessage)
  2115.     {
  2116.         SetMessageText(m_nIDTracking);
  2117.         ASSERT(m_nIDTracking == m_nIDLastMessage);
  2118.     }
  2119. #endif // _WIN32_WCE_NO_TOOLTIPS
  2120.     m_nIdleFlags = 0;
  2121. }
  2122.  
  2123. CFrameWnd* CFrameWnd::GetActiveFrame()
  2124. {
  2125.     // by default, the active frame is the frame itself (MDI is different)
  2126.     return this;
  2127. }
  2128.  
  2129. void CFrameWnd::RecalcLayout(BOOL bNotify)
  2130. {
  2131.     if (m_bInRecalcLayout)
  2132.         return;
  2133.  
  2134.     m_bInRecalcLayout = TRUE;
  2135.     // clear idle flags for recalc layout if called elsewhere
  2136.     if (m_nIdleFlags & idleNotify)
  2137.         bNotify = TRUE;
  2138.     m_nIdleFlags &= ~(idleLayout|idleNotify);
  2139.  
  2140. #if !defined(_WIN32_WCE)
  2141. #ifndef _AFX_NO_OLE_SUPPORT
  2142.     // call the layout hook -- OLE support uses this hook
  2143.     if (bNotify && m_pNotifyHook != NULL)
  2144.         m_pNotifyHook->OnRecalcLayout();
  2145. #endif
  2146. #endif // _WIN32_WCE
  2147.  
  2148.     // reposition all the child windows (regardless of ID)
  2149.     if (GetStyle() & FWS_SNAPTOBARS)
  2150.     {
  2151.         CRect rect(0, 0, 32767, 32767);
  2152.         RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposQuery,
  2153.             &rect, &rect, FALSE);
  2154.         RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposExtra,
  2155.             &m_rectBorder, &rect, TRUE);
  2156.         CalcWindowRect(&rect);
  2157.         SetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(),
  2158.             SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
  2159.     }
  2160.     else
  2161.         RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposExtra, &m_rectBorder);
  2162.     m_bInRecalcLayout = FALSE;
  2163. }
  2164.  
  2165. #if !defined(_WIN32_WCE_NO_OLE)
  2166. // CFrameWnd implementation of OLE border space negotiation
  2167. BOOL CFrameWnd::NegotiateBorderSpace(UINT nBorderCmd, LPRECT lpRectBorder)
  2168. {
  2169.     CRect border, request;
  2170.  
  2171.     switch (nBorderCmd)
  2172.     {
  2173.     case borderGet:
  2174.         ASSERT(lpRectBorder != NULL);
  2175.         RepositionBars(0, 0xffff, AFX_IDW_PANE_FIRST, reposQuery,
  2176.             lpRectBorder);
  2177.         break;
  2178.  
  2179.     case borderRequest:
  2180.         return TRUE;
  2181.  
  2182.     case borderSet:
  2183.         if (lpRectBorder == NULL)
  2184.         {
  2185.             if (!m_rectBorder.IsRectNull())
  2186.             {
  2187.                 // releasing all border space -- recalc needed
  2188.                 m_rectBorder.SetRectEmpty();
  2189.                 return TRUE;
  2190.             }
  2191.             // original rect is empty & lpRectBorder is NULL, no recalc needed
  2192.             return FALSE;
  2193.         }
  2194.         if (!::EqualRect(m_rectBorder, lpRectBorder))
  2195.         {
  2196.             // the rects are different -- recalc needed
  2197.             m_rectBorder.CopyRect(lpRectBorder);
  2198.             return TRUE;
  2199.         }
  2200.         return FALSE;   // no recalc needed
  2201.  
  2202.     default:
  2203.         ASSERT(FALSE);  // invalid CFrameWnd::BorderCmd
  2204.     }
  2205.  
  2206.     return TRUE;
  2207. }
  2208. #endif // _WIN32_WCE_NO_OLE
  2209.  
  2210. void CFrameWnd::OnSize(UINT nType, int cx, int cy)
  2211. {
  2212.     CWnd::OnSize(nType, cx, cy);    // important for MDI Children
  2213.     if (nType != SIZE_MINIMIZED)
  2214.         RecalcLayout();
  2215. }
  2216.  
  2217. BOOL CFrameWnd::OnEraseBkgnd(CDC* pDC)
  2218. {
  2219.     if (m_pViewActive != NULL)
  2220.         return TRUE;        // active view will erase/paint itself
  2221.     // for view-less frame just use the default background fill
  2222.     return CWnd::OnEraseBkgnd(pDC);
  2223. }
  2224.  
  2225. #if !defined(_WIN32_WCE)
  2226. LRESULT CFrameWnd::OnRegisteredMouseWheel(WPARAM wParam, LPARAM lParam)
  2227. {
  2228.     // convert from MSH_MOUSEWHEEL to WM_MOUSEWHEEL
  2229.  
  2230.     WORD keyState = 0;
  2231.     keyState |= (::GetKeyState(VK_CONTROL) < 0) ? MK_CONTROL : 0;
  2232.     keyState |= (::GetKeyState(VK_SHIFT) < 0) ? MK_SHIFT : 0;
  2233.  
  2234.     LRESULT lResult;
  2235.     HWND hwFocus = ::GetFocus();
  2236.     const HWND hwDesktop = ::GetDesktopWindow();
  2237.  
  2238.     if (hwFocus == NULL)
  2239.         lResult = SendMessage(WM_MOUSEWHEEL, (wParam << 16) | keyState, lParam);
  2240.     else
  2241.     {
  2242.         do {
  2243.             lResult = ::SendMessage(hwFocus, WM_MOUSEWHEEL,
  2244.                 (wParam << 16) | keyState, lParam);
  2245.             hwFocus = ::GetParent(hwFocus);
  2246.         }
  2247.         while (lResult == 0 && hwFocus != NULL && hwFocus != hwDesktop);
  2248.     }
  2249.     return lResult;
  2250. }
  2251. #endif // _WIN32_WCE
  2252.  
  2253. void CFrameWnd::ActivateFrame(int nCmdShow)
  2254.     // nCmdShow is the normal show mode this frame should be in
  2255. {
  2256.     // translate default nCmdShow (-1)
  2257.     if (nCmdShow == -1)
  2258.     {
  2259.         if (!IsWindowVisible())
  2260.             nCmdShow = SW_SHOWNORMAL;
  2261.         else if (IsIconic())
  2262.             nCmdShow = SW_RESTORE;
  2263.     }
  2264.  
  2265.     // bring to top before showing
  2266.     BringToTop(nCmdShow);
  2267.  
  2268.     if (nCmdShow != -1)
  2269.     {
  2270.         // show the window as specified
  2271.         ShowWindow(nCmdShow);
  2272.  
  2273.         // and finally, bring to top after showing
  2274.         BringToTop(nCmdShow);
  2275.     }
  2276. }
  2277.  
  2278. void CFrameWnd::BringToTop(int nCmdShow)
  2279. {
  2280.     // place the window on top except for certain nCmdShow
  2281.     if (nCmdShow != SW_HIDE &&
  2282.         nCmdShow != SW_MINIMIZE && nCmdShow != SW_SHOWMINNOACTIVE &&
  2283.         nCmdShow != SW_SHOWNA && nCmdShow != SW_SHOWNOACTIVATE)
  2284.     {
  2285.         // if no last active popup, it will return m_hWnd
  2286.         HWND hWndLastPop = ::WCE_FCTN(GetLastActivePopup)(m_hWnd);
  2287.         ::BringWindowToTop(hWndLastPop);
  2288.     }
  2289. }
  2290.  
  2291. /////////////////////////////////////////////////////////////////////////////
  2292. // CFrameWnd Diagnostics
  2293.  
  2294. #ifdef _DEBUG
  2295. void CFrameWnd::AssertValid() const
  2296. {
  2297.     CWnd::AssertValid();
  2298.     if (m_pViewActive != NULL)
  2299.         ASSERT_VALID(m_pViewActive);
  2300. }
  2301.  
  2302. void CFrameWnd::Dump(CDumpContext& dc) const
  2303. {
  2304.     CWnd::Dump(dc);
  2305.  
  2306.     dc << "m_hAccelTable = " << (UINT)m_hAccelTable;
  2307.     dc << "\nm_nWindow = " << m_nWindow;
  2308.     dc << "\nm_nIDHelp = " << m_nIDHelp;
  2309.     dc << "\nm_nIDTracking = " << m_nIDTracking;
  2310.     dc << "\nm_nIDLastMessage = " << m_nIDLastMessage;
  2311.     if (m_pViewActive != NULL)
  2312.         dc << "\nwith active view: " << m_pViewActive;
  2313.     else
  2314.         dc << "\nno active view";
  2315.  
  2316.     dc << "\n";
  2317. }
  2318. #endif //_DEBUG
  2319.  
  2320. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  2321. /////////////////////////////////////////////////////////////////////////////
  2322. // CControlBar segmentation
  2323.  
  2324. CFrameWnd* CControlBar::GetDockingFrame() const
  2325. {
  2326.     CFrameWnd* pFrameWnd = GetParentFrame();
  2327.     if (pFrameWnd == NULL)
  2328.         pFrameWnd = m_pDockSite;
  2329.  
  2330.     ASSERT(pFrameWnd != NULL);
  2331.     ASSERT_KINDOF(CFrameWnd, pFrameWnd);
  2332.     return pFrameWnd;
  2333. }
  2334.  
  2335. BOOL CControlBar::IsFloating() const
  2336. {
  2337. #if defined(_WIN32_WCE_NO_DOCKBARS)
  2338.     return FALSE;
  2339. #else // _WIN32_WCE_NO_DOCKBARS
  2340.     if (IsDockBar())
  2341.         return ((CDockBar*)this)->m_bFloating;
  2342.     else
  2343.         return m_pDockBar != NULL && m_pDockBar->m_bFloating;
  2344. #endif // _WIN32_WCE_NO_DOCKBARS
  2345. }
  2346. #endif // _WIN32_WCE_NO_CONTROLBARS
  2347.  
  2348. #ifdef AFX_INIT_SEG
  2349. #pragma code_seg(AFX_INIT_SEG)
  2350. #endif
  2351.  
  2352. // in this file for IsKindOf library granularity (IsKindOf references these)
  2353. IMPLEMENT_DYNCREATE(CFrameWnd, CWnd)
  2354. IMPLEMENT_DYNAMIC(CView, CWnd)
  2355. #if !defined(_WIN32_WCE_NO_CONTROLBARS)
  2356. IMPLEMENT_DYNAMIC(CControlBar, CWnd)
  2357. #endif // _WIN32_WCE_NO_CONTROLBARS
  2358. /////////////////////////////////////////////////////////////////////////////
  2359.