开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
MainFrm.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：18k
源码类别：

对话框与窗口

开发平台：

Visual C++

MainFrm.cpp：源码内容
  1. // MainFrm.cpp : implementation of the CMainFrame class
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "MDITabWindow.h"
  24. #include "MainFrm.h"
  26. #pragma warning(disable:4510)
  27. #pragma warning(disable:4610)
  29. #ifdef _DEBUG
  30. #define new DEBUG_NEW
  31. #undef THIS_FILE
  32. static char THIS_FILE[] = __FILE__;
  33. #endif
  35. class CCommandBars : public CXTPCommandBars
  36. {
  37. DECLARE_DYNCREATE(CCommandBars)
  39. UINT GetActiveDocTemplate()
  40. {
  41. CXTPDockingPaneManager& paneManage = ((CMainFrame*)GetSite())->m_paneManager;
  43. if (paneManage.GetActivePane())
  44. {
  45. CFrameWnd* pActiveFrame = DYNAMIC_DOWNCAST(CFrameWnd, paneManage.GetActivePane()->GetChild());
  46. if (pActiveFrame)
  47. {
  48. CString str;
  49. pActiveFrame->GetActiveDocument()->GetDocTemplate()->GetDocString(str, CDocTemplate::docName);
  51. return str == _T("Bounce") ? IDR_BOUNCETYPE : IDR_HELLOTYPE;
  52. }
  53. }
  55. return CXTPCommandBars::GetActiveDocTemplate();
  56. }
  57. };
  59. IMPLEMENT_DYNCREATE(CCommandBars, CXTPCommandBars);
  61. class CDockingFrameWnd : public CFrameWnd
  62. {
  63. public:
  64. CDockingFrameWnd(){};
  65. DECLARE_DYNAMIC(CDockingFrameWnd);
  66. };
  67. IMPLEMENT_DYNAMIC(CDockingFrameWnd, CFrameWnd);
  70. CFrameWnd* CMainFrame::GetParentDockingFrame(CWnd* pWnd)
  71. {
  72. if (pWnd)
  73. {
  74. return DYNAMIC_DOWNCAST(CDockingFrameWnd, pWnd->GetParentFrame());
  75. }
  76. return NULL;
  77. }
  80. /////////////////////////////////////////////////////////////////////////////
  81. // CMainFrame
  83. IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
  85. BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
  86. //{{AFX_MSG_MAP(CMainFrame)
  87. ON_WM_CREATE()
  88. ON_WM_DESTROY()
  89. ON_COMMAND(ID_VIEW_THEME_OFFICE2000, OnViewThemeOffice2000)
  90. ON_COMMAND(ID_VIEW_THEME_OFFICEXP, OnViewThemeOfficexp)
  91. ON_COMMAND(ID_VIEW_THEME_OFFICE2003, OnViewThemeOffice2003)
  92. ON_COMMAND(ID_VIEW_THEME_NATIVEXP, OnViewThemeNativexp)
  93. ON_UPDATE_COMMAND_UI(ID_VIEW_THEME_OFFICE2000, OnUpdateViewThemeOffice2000)
  94. ON_UPDATE_COMMAND_UI(ID_VIEW_THEME_OFFICEXP, OnUpdateViewThemeOfficexp)
  95. ON_UPDATE_COMMAND_UI(ID_VIEW_THEME_OFFICE2003, OnUpdateViewThemeOffice2003)
  96. ON_UPDATE_COMMAND_UI(ID_VIEW_THEME_NATIVEXP, OnUpdateViewThemeNativexp)
  97. ON_MESSAGE(WM_XTP_PRETRANSLATEMOUSEMSG, OnTabbarMouseMsg)
  98. ON_COMMAND(ID_TOGGLE_DOCK, OnToggleTabsTopBottom)
  99. ON_COMMAND(ID_WINDOW_CLOSE_ALL, OnWindowCloseAll)
  100. ON_UPDATE_COMMAND_UI(ID_WINDOW_CLOSE_ALL, OnUpdateWindowCloseAll)
  101. ON_COMMAND(ID_WINDOW_DOCKABLE, OnWindowDockable)
  102. ON_MESSAGE(XTPWM_DOCKINGPANE_NOTIFY, OnDockingPaneNotify)
  103. ON_UPDATE_COMMAND_UI(ID_WINDOW_DOCKABLE, OnUpdateWindowDockable)
  104. ON_COMMAND(ID_WINDOW_HIDE, OnWindowHide)
  105. ON_COMMAND(ID_WINDOW_HIDEALL, OnWindowHideall)
  106. ON_COMMAND(ID_WINDOW_AUTOHIDE, OnWindowAutohide)
  107. ON_UPDATE_COMMAND_UI(ID_WINDOW_AUTOHIDE, OnUpdateWindowAutohide)
  108. ON_UPDATE_COMMAND_UI(ID_WINDOW_HIDEALL, OnUpdateWindowHideall)
  109. ON_COMMAND(ID_TOGGLE_TABS, OnToggleTabs)
  110. ON_COMMAND(XTP_ID_CUSTOMIZE, OnCustomize)
  111. ON_WM_CLOSE()
  112. ON_UPDATE_COMMAND_UI(ID_TOGGLE_TABS, OnUpdateToggleTabs)
  113. //}}AFX_MSG_MAP
  114. ON_XTP_CREATECONTROL()
  115. END_MESSAGE_MAP()
  117. static UINT indicators[] =
  118. {
  119. ID_SEPARATOR,           // status line indicator
  120. ID_INDICATOR_CAPS,
  121. ID_INDICATOR_NUM,
  122. ID_INDICATOR_SCRL,
  123. };
  127. /////////////////////////////////////////////////////////////////////////////
  128. // CMainFrame construction/destruction
  130. CMainFrame::CMainFrame()
  131. {
  132. m_nCount = 0;
  134. }
  136. CMainFrame::~CMainFrame()
  137. {
  138. }
  140. int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  141. {
  142. if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
  143. return -1;
  145. if (!m_wndStatusBar.Create(this) ||
  146. !m_wndStatusBar.SetIndicators(indicators,
  147. sizeof(indicators)/sizeof(UINT)))
  148. {
  149. TRACE0("Failed to create status barn");
  150. return -1;      // fail to create
  151. }
  153. if (!InitCommandBars( RUNTIME_CLASS(CCommandBars)))
  154. return -1;
  156. CXTPPaintManager::SetTheme(xtpThemeOfficeXP);
  158. CXTPCommandBars* pCommandBars = GetCommandBars();
  160. pCommandBars->SetMenu(_T("Menu Bar"), IDR_MAINFRAME);
  162. CXTPToolBar* pStandardBar = (CXTPToolBar*)pCommandBars->Add(_T("Standard"), xtpBarTop);
  163. if (!pStandardBar ||
  164. !pStandardBar->LoadToolBar(IDR_MAINFRAME))
  165. {
  166. TRACE0("Failed to create toolbarn");
  167. }
  169. XTPImageManager()->SetIcons(IDR_COLORS);
  171. m_paneManager.InstallDockingPanes(this);
  172. m_paneManager.SetTheme(xtpPaneThemeOffice);
  174. int nIDIcons[] = {1, 2};
  175. m_paneManager.SetIcons(IDB_BITMAP_ICONS, nIDIcons, 2, RGB(255, 255, 255));
  177. VERIFY(m_MTIClientWnd.Attach(this, TRUE));
  178. m_MTIClientWnd.EnableToolTips();
  180. LoadCommandBars(_T("CommandBars2"));
  182. return 0;
  183. }
  185. BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
  186. {
  187. if( !CMDIFrameWnd::PreCreateWindow(cs) )
  188. return FALSE;
  190. cs.lpszClass = _T("XTPMainFrame");
  191. CXTPDrawHelpers::RegisterWndClass(AfxGetInstanceHandle(), cs.lpszClass, 
  192. CS_DBLCLKS, AfxGetApp()->LoadIcon(IDR_MAINFRAME));
  194. return TRUE;
  195. }
  197. /////////////////////////////////////////////////////////////////////////////
  198. // CMainFrame diagnostics
  200. #ifdef _DEBUG
  201. void CMainFrame::AssertValid() const
  202. {
  203. CMDIFrameWnd::AssertValid();
  204. }
  206. void CMainFrame::Dump(CDumpContext& dc) const
  207. {
  208. CMDIFrameWnd::Dump(dc);
  209. }
  211. #endif //_DEBUG
  213. /////////////////////////////////////////////////////////////////////////////
  214. // CMainFrame message handlers
  217. void CMainFrame::OnDestroy()
  218. {
  219. CMDIFrameWnd::OnDestroy();
  221. m_MTIClientWnd.Detach();
  223. }
  225. void CMainFrame::OnViewThemeOffice2000()
  226. {
  227. m_paneManager.SetTheme(xtpPaneThemeDefault);
  229. CXTPPaintManager::SetTheme(xtpThemeOffice2000);
  230. GetCommandBars()->RedrawCommandBars();
  231. }
  233. void CMainFrame::OnViewThemeOfficexp()
  234. {
  235. m_paneManager.SetTheme(xtpPaneThemeOffice);
  237. CXTPPaintManager::SetTheme(xtpThemeOfficeXP);
  238. GetCommandBars()->RedrawCommandBars();
  239. }
  241. void CMainFrame::OnViewThemeOffice2003()
  242. {
  243. m_paneManager.SetTheme(xtpPaneThemeOffice2003);
  245. CXTPPaintManager::SetTheme(xtpThemeOffice2003);
  246. GetCommandBars()->RedrawCommandBars();
  247. }
  249. void CMainFrame::OnViewThemeNativexp()
  250. {
  251. m_paneManager.SetTheme(xtpPaneThemeDefault);
  253. CXTPPaintManager::SetTheme(xtpThemeNativeWinXP);
  254. GetCommandBars()->RedrawCommandBars();
  255. }
  257. void CMainFrame::OnUpdateViewThemeOffice2000(CCmdUI* pCmdUI)
  258. {
  259. pCmdUI->SetCheck(XTPPaintManager()->GetCurrentTheme() == xtpThemeOffice2000);
  260. }
  262. void CMainFrame::OnUpdateViewThemeOfficexp(CCmdUI* pCmdUI)
  263. {
  264. pCmdUI->SetCheck(XTPPaintManager()->GetCurrentTheme() == xtpThemeOfficeXP);
  265. }
  267. void CMainFrame::OnUpdateViewThemeOffice2003(CCmdUI* pCmdUI)
  268. {
  269. pCmdUI->SetCheck(XTPPaintManager()->GetCurrentTheme() == xtpThemeOffice2003);
  270. }
  272. void CMainFrame::OnUpdateViewThemeNativexp(CCmdUI* pCmdUI)
  273. {
  274. pCmdUI->SetCheck(XTPPaintManager()->GetCurrentTheme() == xtpThemeNativeWinXP);
  275. }
  280. LRESULT CMainFrame::OnTabbarMouseMsg(WPARAM wParam,LPARAM lParam)
  281. {
  282. if (wParam != WM_RBUTTONDOWN)
  283. return FALSE;
  285. CPoint point = CPoint((DWORD)lParam);
  287. CXTPTabManagerItem* pItem =  m_MTIClientWnd.HitTest(point);
  288. if (pItem)
  289. {
  290. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CMDIChildWnd, CWnd::FromHandle(pItem->GetHandle()));
  291. if (!pFrame)
  292. return FALSE;
  294. MDIActivate(pFrame);
  295. pFrame->GetActiveView()->SetFocus();
  297. m_MTIClientWnd.Refresh();
  299. CMenu menu;
  300. VERIFY(menu.LoadMenu(IDR_POPUP_TABS));
  301. CMenu* pPopup = menu.GetSubMenu(0);
  304. m_MTIClientWnd.WorkspaceToScreen(&point);
  307. CXTPPopupBar* pPopupBar = (CXTPPopupBar*) CXTPPopupBar::CreatePopupBar(GetCommandBars());
  308. VERIFY(pPopupBar->LoadMenu(pPopup));
  309. pPopupBar->GetControls()->FindControl(xtpControlPopup, -1, TRUE, FALSE)->SetEnabled(XTPPaintManager()->GetCurrentTheme() == xtpThemeOffice2003);
  312. VERIFY(pPopupBar->Popup(point.x, point.y, NULL));
  314. while ( pPopupBar->IsTrackingMode() )
  315. {
  316. AfxGetApp()->PumpMessage();
  317. }
  318. pPopupBar->InternalRelease();
  321. m_MTIClientWnd.Refresh();
  322. return TRUE;
  323. }
  326. CMenu menuPopup;
  327. menuPopup.CreatePopupMenu();
  328. menuPopup.AppendMenu(MF_STRING, ID_WINDOW_CLOSE_ALL, _T("&Close All"));
  329. menuPopup.AppendMenu(MF_STRING, ID_TOGGLE_DOCK, _T("&Toggle Docking"));
  331. m_MTIClientWnd.WorkspaceToScreen(&point);
  332. CXTPCommandBars::TrackPopupMenu(&menuPopup, TPM_RIGHTBUTTON, point.x, point.y, AfxGetMainWnd());
  334. m_MTIClientWnd.Refresh();
  336. return TRUE;
  337. }
  339. void CMainFrame::OnToggleTabsTopBottom(void)
  340. {
  341. if (m_MTIClientWnd.GetPaintManager()->GetPosition() == xtpTabPositionTop)
  342. m_MTIClientWnd.GetPaintManager()->SetPosition(xtpTabPositionBottom);
  343. else
  344. m_MTIClientWnd.GetPaintManager()->SetPosition(xtpTabPositionTop);
  346. m_MTIClientWnd.Refresh();
  347. }
  349. void CMainFrame::OnToggleTabs()
  350. {
  351. }
  353. void CMainFrame::OnUpdateToggleTabs(CCmdUI* pCmdUI)
  354. {
  355. pCmdUI->SetCheck(m_MTIClientWnd.IsAttached());
  356. }
  358. void CMainFrame::OnWindowCloseAll()
  359. {
  360. CXTPDockingPaneInfoList& lstPanes = m_paneManager.GetPaneList();
  361. POSITION pos = lstPanes.GetHeadPosition();
  362. while (pos)
  363. {
  364. CXTPDockingPane* pPane = lstPanes.GetNext(pos);
  365. m_paneManager.DestroyPane(pPane);
  366. }
  368. AfxGetApp()->CloseAllDocuments(FALSE);
  369. }
  372. void CMainFrame::ReparentAllChildren(CFrameWnd *pFrameOld, CFrameWnd* pFrameNew)
  373. {
  374. CPtrList childList;
  375. CWnd* pChild;
  377. for (pChild = pFrameOld->GetTopWindow(); pChild != NULL; pChild = pChild->GetNextWindow(GW_HWNDNEXT))
  378. childList.AddTail(pChild);
  380. POSITION pos = childList.GetHeadPosition();
  381. while (pos != NULL)
  382. {
  383. pChild = (CWnd*)childList.GetNext(pos);
  384. pChild->SetParent(pFrameNew);
  385. }
  386. }
  388. BOOL CMainFrame::ActivateDockableFrame(CFrameWnd* pFrameNew)
  389. {
  390. if(!pFrameNew) return FALSE;
  392. pFrameNew->SendMessage(WM_ACTIVATE, WA_ACTIVE);
  393. pFrameNew->ActivateFrame(-1);
  394. pFrameNew->OnUpdateFrameTitle(TRUE);
  395. return TRUE;
  396. }
  398. void CMainFrame::OnUpdateWindowDockable(CCmdUI* pCmdUI)
  399. {
  400. pCmdUI->SetCheck(GetParentDockingFrame(GetFocus()) !=NULL);
  401. }
  404. void CMainFrame::UnDockFrame(CFrameWnd* pFrameOld, CXTPDockingPane* pPane)
  405. {
  406. class CFriendlyDocTemplate: private CMultiDocTemplate
  407. {
  408. friend class CMainFrame;
  409. };
  411. CDocument* pDocument = pFrameOld->GetActiveDocument();
  412. if (!pDocument)
  413. return;
  415. CFriendlyDocTemplate* pTemplate = (CFriendlyDocTemplate*)pDocument->GetDocTemplate();
  417. // Create frame without any child view
  418. CRuntimeClass* pViewClassSave = pTemplate->m_pViewClass;
  419. pTemplate->m_pViewClass = NULL;
  420. CFrameWnd* pFrameNew = pTemplate->CreateNewFrame(pDocument, NULL);
  421. pTemplate->m_pViewClass = pViewClassSave;
  423. ReparentAllChildren(pFrameOld, pFrameNew);
  425. pFrameOld->DestroyWindow();
  427. // activate the first view.
  428. CView* pView = NULL;
  429. if (pFrameNew->GetActiveView() == NULL)
  430. {
  431. CPtrList childList;
  432. CWnd* pChild = pFrameNew->GetTopWindow();
  433. while ( pChild != NULL && pView == NULL)
  434. {
  435. ASSERT_KINDOF(CWnd, pChild);
  436. if (pChild->IsKindOf(RUNTIME_CLASS(CView)))
  437. {
  438. pView = (CView*)pChild;
  439. pFrameNew->SetActiveView(pView,FALSE);
  440. }
  441. pChild = pChild->GetNextWindow(GW_HWNDNEXT);
  442. }
  443. }
  445. ActivateDockableFrame(pFrameNew);
  447. pFrameNew->ModifyStyleEx(WS_EX_CLIENTEDGE, 0, SWP_FRAMECHANGED);
  449. pPane->Detach();
  450. m_paneManager.ClosePane(pPane);
  451. m_MTIClientWnd.Refresh();
  452. }
  454. void CMainFrame::DockFrame(CFrameWnd* pFrameOld)
  455. {
  457. CDocument* pDocument = pFrameOld->GetActiveDocument();
  459. if (!pDocument)
  460. return;
  462. CString strTitle = pDocument->GetTitle();
  464. CFrameWnd* pFrameNew = new CDockingFrameWnd;
  466. CCreateContext context;
  467. context.m_pCurrentDoc = pDocument;
  469. pFrameNew->Create(NULL, NULL, WS_CHILD, CRect(0, 0, 0, 0), this, NULL, 0, &context);
  471. ReparentAllChildren(pFrameOld, pFrameNew);
  473. pFrameOld->DestroyWindow();
  476. CView* pView = NULL;
  477. if (pFrameNew->GetActiveView() == NULL)
  478. {
  479. CPtrList childList;
  480. CWnd* pChild = pFrameNew->GetTopWindow();
  481. while ( pChild != NULL && pView == NULL)
  482. {
  483. ASSERT_KINDOF(CWnd, pChild);
  484. if (pChild->IsKindOf(RUNTIME_CLASS(CView)))
  485. {
  486. pView = (CView*)pChild;
  487. pFrameNew->SetActiveView(pView,FALSE);
  488. }
  489. pChild = pChild->GetNextWindow(GW_HWNDNEXT);
  490. }
  491. }
  493. ActivateDockableFrame(pFrameNew);
  495. pFrameNew->ModifyStyleEx(WS_EX_CLIENTEDGE, 0);
  497. int nID = ++m_nCount;
  499. CXTPDockingPane* pwndPane = m_paneManager.CreatePane(
  500. nID, CRect(0, 0,200, 120), (XTPDockingPaneDirection)(RAND_S()%4), m_paneManager.GetClientPane());
  502. pwndPane->SetTitle(strTitle);
  504. CString str;
  505. pDocument->GetDocTemplate()->GetDocString(str, CDocTemplate::docName);
  507. pwndPane->SetIconID(str == _T("Bounce")? 2: 1);
  510. m_mapPanes.SetAt(nID, pFrameNew);
  512. m_MTIClientWnd.UpdateContents();
  513. }
  516. void CMainFrame::OnWindowDockable()
  517. {
  518. CFrameWnd* pFrame = GetParentDockingFrame(GetFocus());
  520. if (pFrame)
  521. {
  522. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)pFrame->GetParent();
  523. CXTPDockingPane* pPane = pContainer->GetSelected();
  524. ASSERT(pPane);
  525. ASSERT(pPane->GetChild() == pFrame);
  527. UnDockFrame(pFrame, pPane);
  529. }
  530. else
  531. {
  532. CMDIChildWnd* pFrameOld = MDIGetActive();
  533. if (pFrameOld) DockFrame(pFrameOld);
  534. }
  535. }
  538. LRESULT CMainFrame::OnDockingPaneNotify(WPARAM wParam, LPARAM lParam)
  539. {
  540. if (wParam == XTP_DPN_SHOWWINDOW)
  541. {
  542. // get a pointer to the docking pane being shown.
  543. CXTPDockingPane* pPane = (CXTPDockingPane*)lParam;
  544. if (!pPane->IsValid())
  545. {
  546. CWnd* pWnd = NULL;
  547. if (m_mapPanes.Lookup(pPane->GetID(), pWnd))
  548. {
  549. pPane->Attach(pWnd);
  550. }
  551. }
  553. return TRUE; // handled
  554. }
  556. if (wParam == XTP_DPN_CONTEXTMENU)
  557. {
  558. XTP_DOCKINGPANE_CLICK* pClick = (XTP_DOCKINGPANE_CLICK*)lParam;
  560. CXTPDockingPane* pPopupPane = pClick->pPane;
  561. if (!pPopupPane) 
  562. return FALSE;
  564. CPoint pos;
  565. GetCursorPos(&pos);
  567. CMenu menu;
  568. VERIFY(menu.LoadMenu(IDR_POPUP_PANES));
  569. CMenu* pPopup = menu.GetSubMenu(0);
  570. pPopupPane->SetFocus();
  572. CXTPCommandBars::TrackPopupMenu(pPopup, TPM_RIGHTBUTTON, pos.x, pos.y, this);
  574. return TRUE;
  575. }
  577. if (wParam == XTP_DPN_ACTION)
  578. {
  579. XTP_DOCKINGPANE_ACTION* pAction = (XTP_DOCKINGPANE_ACTION*)lParam;
  581. if (pAction->action == xtpPaneActionActivated)
  582. {
  583. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CFrameWnd, pAction->pPane->GetChild());
  585. if (pFrame)
  586. {
  587. CDocument* pDocument = pFrame->GetActiveDocument();
  588. if (pDocument)
  589. {
  590. HMENU hMenuAlt = ((CMultiDocTemplate*)pDocument->GetDocTemplate())->m_hMenuShared;
  591. ::SendMessage(m_hWndMDIClient, WM_MDISETMENU, (WPARAM)hMenuAlt, NULL);
  592. }
  593. }
  595. return TRUE;
  596. }
  598. if (pAction->action == xtpPaneActionDeactivated)
  599. {
  600. CMDIChildWnd* pFrame = MDIGetActive();
  601. if (pFrame)
  602. {
  603. pFrame->OnUpdateFrameMenu(TRUE, pFrame, 0);
  604. }
  605. else
  606. {
  607. OnUpdateFrameMenu(0);
  608. }
  609. }
  611. return TRUE;
  612. }
  614. return FALSE;
  615. }
  619. BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
  620. {
  621. CFrameWnd* pFrame = GetParentDockingFrame(GetFocus());
  623. if (pFrame)
  624. {
  625. // let the view have first crack at the command
  626. if (pFrame->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  627. return TRUE;
  629. return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  630. }
  633. return CXTPMDIFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  634. }
  636. BOOL CMainFrame::OnCommand(WPARAM wParam, LPARAM lParam)
  637. {
  638. CFrameWnd* pFrame = GetParentDockingFrame(GetFocus());
  640. if (pFrame)
  641. {
  642. // let the view have first crack at the command
  643. if (AfxCallWndProc(pFrame,
  644. pFrame->m_hWnd,
  645. WM_COMMAND, wParam, lParam) != 0)
  646. return TRUE; // handled by child
  647. }
  649. return CMDIFrameWnd::OnCommand(wParam, lParam);
  650. }
  654. void CMainFrame::OnWindowHide()
  655. {
  656. CFrameWnd* pFrame = GetParentDockingFrame(GetFocus());
  658. if (pFrame)
  659. {
  660. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)pFrame->GetParent();
  661. CXTPDockingPane* pPane = pContainer->GetSelected();
  663. pPane->Close();
  664. }
  665. else
  666. {
  667. CWnd* pActiveChildWnd = MDIGetActive(NULL);
  668. if (pActiveChildWnd)
  669. pActiveChildWnd->SendMessage(WM_COMMAND, ID_FILE_CLOSE);
  670. }
  671. }
  673. void CMainFrame::OnWindowHideall()
  674. {
  675. CXTPDockingPaneInfoList& lstPanes = m_paneManager.GetPaneList();
  676. POSITION pos = lstPanes.GetHeadPosition();
  677. while (pos)
  678. {
  679. CXTPDockingPane* pPane = lstPanes.GetNext(pos);
  680. if (!pPane->IsClosed() && !pPane->IsHidden())
  681. m_paneManager.HidePane(pPane);
  682. }
  684. }
  686. void CMainFrame::OnWindowAutohide()
  687. {
  688. CFrameWnd* pFrame = GetParentDockingFrame(GetFocus());
  690. if (pFrame)
  691. {
  692. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)pFrame->GetParent();
  693. CXTPDockingPane* pPane = pContainer->GetSelected();
  695. pPane->Hide();
  696. }
  697. }
  699. void CMainFrame::OnUpdateWindowAutohide(CCmdUI* pCmdUI)
  700. {
  702. pCmdUI->Enable(GetParentDockingFrame(GetFocus()) != NULL);
  704. }
  705. void CMainFrame::OnUpdateWindowCloseAll(CCmdUI *pCmdUI)
  706. {
  707. pCmdUI->Enable(MDIGetActive() != NULL);
  708. }
  710. void CMainFrame::OnUpdateWindowHideall(CCmdUI* pCmdUI)
  711. {
  712. pCmdUI->Enable(m_paneManager.GetPaneList().GetCount() > 0);
  714. }
  716. int CMainFrame::OnCreateControl(LPCREATECONTROLSTRUCT /*lpCreateControl*/)
  717. {
  719. return FALSE;
  720. }
  723. void CMainFrame::OnCustomize()
  724. {
  725. CXTPCustomizeSheet cs(GetCommandBars());
  728. CXTPCustomizeOptionsPage pageOptions(&cs);
  729. cs.AddPage(&pageOptions);
  732. CXTPCustomizeCommandsPage* pCommands = cs.GetCommandsPage();
  733. pCommands->AddCategories(IDR_MAINFRAME);
  735. pCommands->InsertAllCommandsCategory();
  736. pCommands->InsertBuiltInMenus(IDR_MAINFRAME);
  737. pCommands->InsertNewMenuCategory();
  740. cs.DoModal();
  741. }
  744. void CMainFrame::OnClose()
  745. {
  746. SaveCommandBars(_T("CommandBars2"));
  748. CFrameWnd::OnClose();
  749. }