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

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

对话框与窗口

开发平台：

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 "Pane.h"
  24. #include "MainFrm.h"
  26. //#define VISIO_EDIT_BACKGROUND
  27. //#define VISIO_OFFICE2003_THEME
  28. BOOL m_bMinMaxSample = FALSE;
  30. #ifdef _DEBUG
  31. #define new DEBUG_NEW
  32. #endif
  34. using namespace XTPDockingPanePaintThemes;
  36. class CCustomTheme :  public CXTPDockingPaneGripperedTheme
  37. {
  38. virtual void DrawCaption(CDC* pDC, CXTPDockingPaneTabbedContainer* pPane, CRect rc)
  39. {
  40. CRect rcCaption(0, 2, rc.right, m_nTitleHeight + 1);
  42. // Drawing Frame
  43. pDC->FillSolidRect(rcCaption, GetSysColor(COLOR_3DFACE));
  44. pDC->Draw3dRect(1, rc.top + 1, rc.Width() -1, rcCaption.bottom + 1, GetSysColor(COLOR_WINDOW), GetSysColor(COLOR_WINDOW));
  45. pDC->Draw3dRect(0, rc.top, rc.Width() - 1 , rcCaption.bottom + 2, GetSysColor(COLOR_3DSHADOW), GetSysColor(COLOR_3DSHADOW));
  47. COLORREF clrText = GetSysColor(COLOR_BTNTEXT);
  49. rcCaption.right -= 3;
  50. DrawCaptionButtons(pDC, pPane->GetCaptionButtons(), rcCaption, clrText, 14, 2, FALSE);
  52. // Drawing Title
  53. if (pPane->GetSelected())
  54. {
  55. CRect rcText(rcCaption.left + 4, rcCaption.top + 1, rcCaption.right, rcCaption.bottom);
  57. pDC->SetTextColor(clrText);
  58. CXTPFontDC font(pDC, &m_fntTitle);
  59. pDC->DrawText(pPane->GetSelected()->GetTitle(), rcText, DT_SINGLELINE|DT_END_ELLIPSIS|DT_VCENTER);
  60. }
  61. }
  63. };
  67. // CMainFrame
  69. IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
  71. BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
  72. ON_WM_CREATE()
  73. ON_COMMAND_RANGE(IDR_PANE1, IDR_PANE10, OnShowPane)
  75. ON_COMMAND(ID_THEME_DEFAULT, OnThemeDefault)
  76. ON_COMMAND(ID_THEME_OFFICE, OnThemeOffice)
  77. ON_COMMAND(ID_THEME_OFFICE2003, OnThemeOffice2003)
  78. ON_COMMAND(ID_THEME_WINXP, OnThemeWinXP)
  79. ON_COMMAND(ID_THEME_GRIPPERED, OnThemeGrippered)
  80. ON_COMMAND(ID_THEME_WHIDBEY, OnThemeWhidbey)
  81. ON_COMMAND(ID_THEME_SHORTCUTBAR2003, OnThemeShortcutBar2003)
  82. ON_COMMAND(ID_THEME_EXPLORER, OnThemeExplorer)
  83. ON_COMMAND(ID_THEME_OFFICE2007, OnThemeOffice2007)
  84. ON_COMMAND(ID_THEME_WORD2007, OnThemeWord2007)
  85. ON_UPDATE_COMMAND_UI_RANGE(ID_THEME_DEFAULT, ID_THEME_CUSTOM4, OnUpdateTheme)
  87. ON_MESSAGE(XTPWM_DOCKINGPANE_NOTIFY, OnDockingPaneNotify)
  88. ON_COMMAND(ID_LAYOUT_EDITOR, OnLayoutEditor)
  89. ON_UPDATE_COMMAND_UI(ID_LAYOUT_EDITOR, OnUpdateLayoutEditor)
  90. ON_COMMAND(ID_LAYOUT_RUN, OnLayoutRun)
  91. ON_UPDATE_COMMAND_UI(ID_LAYOUT_RUN, OnUpdateLayoutRun)
  92. ON_WM_DESTROY()
  94. ON_COMMAND(ID_THEME_VISIO_OFFICE2000, OnThemeVisio2000)
  95. ON_COMMAND(ID_THEME_VISIO, OnThemeVisio)
  96. ON_COMMAND(ID_THEME_VISIO_OFFICE2003, OnThemeVisio2003)
  98. ON_COMMAND(ID_THEME_CUSTOM, OnThemeCustom)
  99. ON_COMMAND(ID_THEME_CUSTOM2, OnThemeCustom2)
  100. ON_COMMAND(ID_THEME_CUSTOM3, OnThemeCustom3)
  101. ON_COMMAND(ID_THEME_CUSTOM4, OnThemeCustom4)
  103. ON_COMMAND(ID_LAYOUT_LOADFROMFILE, OnLoadFromFile)
  104. ON_COMMAND(ID_LAYOUT_SAVETOFILE, OnSaveToFile)
  105. ON_COMMAND(ID_LAYOUT_LOADFROMRESOURCE, OnLoadFromResource)
  107. ON_COMMAND(ID_DOCKINGPANE_HIDECLIENT, OnHideClient)
  108. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_HIDECLIENT, OnUpdateHideClient)
  110. ON_COMMAND(ID_DOCKINGPANE_USESPLITTERTRACKER, OnUseSplitterTracker)
  111. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_USESPLITTERTRACKER, OnUpdateUseSplitterTracker)
  113. ON_COMMAND(ID_DOCKINGPANE_THEMEDFLOATINGFRAMES, OnThemedFloatingFrames)
  114. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_THEMEDFLOATINGFRAMES, OnUpdateThemedFloatingFrames)
  116. ON_COMMAND(ID_DOCKINGCONTEXT_ALPHACONTEXT, OnAlphaContext)
  117. ON_UPDATE_COMMAND_UI(ID_DOCKINGCONTEXT_ALPHACONTEXT, OnUpdateAlphaContext)
  119. ON_COMMAND(ID_DOCKINGCONTEXT_DOCKINGSTICKERS, OnDockingStickers)
  120. ON_UPDATE_COMMAND_UI(ID_DOCKINGCONTEXT_DOCKINGSTICKERS, OnUpdateDockingStickers)
  122. ON_COMMAND(ID_DOCKINGPANE_MINMAXSAMPLE, OnMinMaxSamlpe)
  123. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_MINMAXSAMPLE, OnUpdateMinMaxSamlpe)
  124. ON_WM_GETMINMAXINFO()
  127. ON_COMMAND(ID_DOCKINGPANE_CAPTIONBUTTONS_CLOSEBUTTON, OnCaptionButtonClose)
  128. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONBUTTONS_CLOSEBUTTON, OnUpdateCaptionButtonClose)
  129. ON_COMMAND(ID_DOCKINGPANE_CAPTIONBUTTONS_AUTOHIDEBUTTON, OnCaptionButtonAutoHide)
  130. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONBUTTONS_AUTOHIDEBUTTON, OnUpdateCaptionButtonAutoHide)
  131. ON_COMMAND(ID_DOCKINGPANE_CAPTIONBUTTONS_MENUBUTTON, OnCaptionButtonMenu)
  132. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONBUTTONS_MENUBUTTON, OnUpdateCaptionButtonMenu)
  133. ON_COMMAND(ID_DOCKINGPANE_CAPTIONBUTTONS_MAXIMIZERESTOREBUTTON, OnCaptionButtonMaximize)
  134. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONBUTTONS_MAXIMIZERESTOREBUTTON, OnUpdateCaptionButtonMaximize)
  136. ON_COMMAND(ID_DOCKINGPANE_CAPTIONS_VISIBLE, OnCaptionVisible)
  137. ON_COMMAND(ID_DOCKINGPANE_CAPTIONS_HORIZONTAL, OnCaptionHorizontal)
  138. ON_COMMAND(ID_DOCKINGPANE_CAPTIONS_VERTICAL, OnCaptionVertical)
  139. ON_COMMAND(ID_DOCKINGPANE_CAPTIONS_AUTOBYSIZE, OnCaptionAutoBySize)
  140. ON_COMMAND(ID_DOCKINGPANE_CAPTIONS_AUTOBYPOSITION, OnCaptionAutoByPosition)
  142. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONS_VISIBLE, OnUpdateCaptionVisible)
  143. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONS_HORIZONTAL, OnUpdateCaptionHorizontal)
  144. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONS_VERTICAL, OnUpdateCaptionVertical)
  145. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONS_AUTOBYSIZE, OnUpdateCaptionAutoBySize)
  146. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CAPTIONS_AUTOBYPOSITION, OnUpdateCaptionAutoByPosition)
  148. ON_COMMAND(ID_DOCKINGPANE_CLOSEBUTTONAFFECTS, OnCloseButtonAffects)
  149. ON_COMMAND(ID_DOCKINGPANE_AUTOHIDEBUTTONAFFECTS, OnAutoHideButtonAffects)
  151. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_CLOSEBUTTONAFFECTS, OnUpdateCloseButtonAffects)
  152. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_AUTOHIDEBUTTONAFFECTS, OnUpdateAutoHideButtonAffects)
  154. ON_COMMAND(ID_DOCKINGCONTEXT_SHOWWHILEDRAGGING, OnShowContentsWhileDragging)
  155. ON_UPDATE_COMMAND_UI(ID_DOCKINGCONTEXT_SHOWWHILEDRAGGING, OnUpdateShowContentsWhileDragging)
  157. ON_COMMAND(ID_DOCKINGPANE_STICKYFLOATINGFRAMES, OnStickyFloatingFrames)
  158. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_STICKYFLOATINGFRAMES, OnUpdateStickyFloatingFrames)
  160. ON_COMMAND(ID_DOCKINGPANE_TRANSPARENTFLOATINGFRAMES, OnTransparentFloatingFrames)
  161. ON_UPDATE_COMMAND_UI(ID_DOCKINGPANE_TRANSPARENTFLOATINGFRAMES, OnUpdateTransparentFloatingFrames)
  163. ON_COMMAND(ID_DOCKINGCONTEXT_ENABLESIDEDOCKING, OnEnableSideDocking)
  164. ON_UPDATE_COMMAND_UI(ID_DOCKINGCONTEXT_ENABLESIDEDOCKING, OnUpdateEnableSideDocking)
  167. ON_COMMAND(XTP_ID_CUSTOMIZE, OnCustomize)
  168. ON_WM_CLOSE()
  170. END_MESSAGE_MAP()
  172. static UINT indicators[] =
  173. {
  174. ID_SEPARATOR,           // status line indicator
  175. ID_INDICATOR_CAPS,
  176. ID_INDICATOR_NUM,
  177. ID_INDICATOR_SCRL,
  178. };
  181. // CMainFrame construction/destruction
  183. CMainFrame::CMainFrame()
  184. : m_pEditorLayout(NULL)
  185. , m_pRunLayout(NULL)
  186. {
  187. }
  189. CMainFrame::~CMainFrame()
  190. {
  191. }
  193. int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  194. {
  195. if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
  196. return -1;
  198. LOGFONT lfIcon;
  199. VERIFY( ::SystemParametersInfo( SPI_GETICONTITLELOGFONT, sizeof( lfIcon ), &lfIcon, 0 ) );
  200. m_fntEdit.CreateFontIndirect(&lfIcon);
  204. if (!m_wndStatusBar.Create(this) ||
  205. !m_wndStatusBar.SetIndicators(indicators,
  206.   sizeof(indicators)/sizeof(UINT)))
  207. {
  208. TRACE0("Failed to create status barn");
  209. return -1;      // fail to create
  210. }
  212. if (!InitCommandBars())
  213. return -1;
  215. XTPPaintManager()->SetTheme(xtpThemeOfficeXP);
  217. CXTPCommandBars* pCommandBars = GetCommandBars();
  219. CXTPCommandBar* pMenuBar = pCommandBars->SetMenu(_T("Menu Bar"), IDR_MAINFRAME);
  220. pMenuBar->SetFlags(xtpFlagAddMDISysPopup);
  223. CXTPToolBar* pCommandBar = (CXTPToolBar*)pCommandBars->Add(_T("Standard"), xtpBarTop);
  224. if (!pCommandBar ||
  225. !pCommandBar->LoadToolBar(IDR_MAINFRAME))
  226. {
  227. TRACE0("Failed to create toolbarn");
  228. return -1;
  229. }
  231. // Load the previous state for toolbars and menus.
  232. LoadCommandBars(_T("CommandBars"));
  235. // Initialize the docking pane manager and set the
  236. // initial them for the docking panes.  Do this only after all
  237. // control bars objects have been created and docked.
  238. m_paneManager.InstallDockingPanes(this);
  239. SetDockingPaneTheme(xtpPaneThemeOffice2003);
  240. m_paneManager.SetFloatingFrameCaption(_T("Panes"));
  241. m_paneManager.SetStickyFloatingFrames(TRUE);
  242. m_paneManager.SetThemedFloatingFrames(TRUE);
  244. m_paneManager.SetSideDockingMargin(CRect(2, 2, 2, 2));
  245. m_paneManager.EnableSideDocking();
  247. m_paneManager.EnableKeyboardNavigate();
  249. // Create docking panes.
  250. CXTPDockingPane* pwndPane1 = m_paneManager.CreatePane(
  251. IDR_PANE1, CRect(0, 0,200, 120), xtpPaneDockTop);
  252. m_paneManager.CreatePane(
  253. IDR_PANE2, CRect(0, 0,200, 120), xtpPaneDockLeft, pwndPane1);
  254. CXTPDockingPane* pwndPane3 = m_paneManager.CreatePane(
  255. IDR_PANE3, CRect(0, 0,200, 120), xtpPaneDockLeft);
  256. CXTPDockingPane* pwndPane4 = m_paneManager.CreatePane(
  257. IDR_PANE4, CRect(0, 0,200, 120), xtpPaneDockTop, pwndPane3);
  258. CXTPDockingPane* pwndPane5 = m_paneManager.CreatePane(
  259. IDR_PANE5, CRect(0, 0,200, 120), xtpPaneDockLeft, pwndPane4);
  260. CXTPDockingPane* pwndPane6 = m_paneManager.CreatePane(
  261. IDR_PANE6, CRect(0, 0,200, 120), xtpPaneDockTop, pwndPane5);
  262. CXTPDockingPane* pwndPane7 = m_paneManager.CreatePane(
  263. IDR_PANE7, CRect(0, 0,200, 120), xtpPaneDockTop, pwndPane6);
  264. CXTPDockingPane* pwndPane8 = m_paneManager.CreatePane(
  265. IDR_PANE8, CRect(0, 0,200, 120), xtpPaneDockRight);
  266. CXTPDockingPane* pwndPane9 = m_paneManager.CreatePane(
  267. IDR_PANE9, CRect(0, 0,200, 120), xtpPaneDockBottom, pwndPane8);
  268. CXTPDockingPane* pwndPane10 = m_paneManager.CreatePane(
  269. IDR_PANE10, CRect(0, 0,200, 120), xtpPaneDockBottom, pwndPane9);
  271. // Create the layout manager for run mode.  Layouts define how
  272. // the panes will appear when docked, you can define multiple
  273. // layouts.
  275. // If "RunLayout" layout does not exist, save the current configuration
  276. // as "RunLayout", otherwise load previous state.
  277. m_pRunLayout = m_paneManager.CreateLayout();
  278. if (!m_pRunLayout->Load(_T("RunLayout"))) {
  279. m_paneManager.GetLayout(m_pRunLayout);
  280. }
  282. // Initialize the default layout for "EditorLayout".
  283. m_paneManager.AttachPane(
  284. pwndPane9, pwndPane8);
  285. m_paneManager.AttachPane(
  286. pwndPane6, pwndPane1);
  287. m_paneManager.AttachPane(
  288. pwndPane4, pwndPane7);
  289. m_paneManager.HidePane(
  290. pwndPane7);
  292. CXTPDockingPaneSidePanel* pPanel = m_paneManager.DockSidePane(pwndPane10, xtpPaneDockRight, CRect(0, 100, 120, 300));
  293. pPanel->Collapse();
  295. // If "EditorLayout" layout does not exist, save the current configuration
  296. // as "EditorLayout", otherwise load previous state and set it as the active
  297. // layout.
  298. m_pEditorLayout = m_paneManager.CreateLayout();
  300. if (m_pEditorLayout->Load(_T("EditorLayout"))) {
  301. m_paneManager.SetLayout(m_pEditorLayout);
  302. }
  303. else {
  304. m_paneManager.GetLayout(m_pEditorLayout);
  305. }
  307. // Get a pointer to IDR_PANE1 and set the title.
  308. CXTPDockingPane* pPane = m_paneManager.FindPane(IDR_PANE1);
  309. ASSERT(pPane);
  310. if (pPane) {
  311. pPane->SetTitle(_T("Pane 1 - Long TitlenPane 1"));
  312. }
  314. // Get a pointer to IDR_PANE2 and set the title.
  315. pPane = m_paneManager.FindPane(IDR_PANE2);
  316. ASSERT(pPane);
  317. if (pPane) {
  318. pPane->SetTitle(_T("Pane 2 - No CloseablenPane 2"));
  319. pPane->SetOptions(xtpPaneNoCloseable);
  320. }
  322. // Get a pointer to IDR_PANE3 and set the title.
  323. pPane = m_paneManager.FindPane(IDR_PANE3);
  324. ASSERT(pPane);
  325. if (pPane) {
  326. pPane->SetTitle(_T("Pane 3 - No HideablenPane 3"));
  327. pPane->SetOptions(xtpPaneNoHideable);
  328. }
  331. m_bEditor = TRUE;
  333. // Set the icons for the docking pane tabs.
  334. int nIDs1[] = {IDR_PANE1, IDR_PANE2, IDR_PANE3, IDR_PANE4, IDR_PANE5};
  335. m_paneManager.SetIcons(IDB_BITMAP1, nIDs1, 5, RGB(0, 255, 0));
  337. int nIDs2[] = {IDR_PANE6, IDR_PANE7, IDR_PANE8, IDR_PANE9, IDR_PANE10};
  338. m_paneManager.SetIcons(IDB_BITMAP2, nIDs2, 5, RGB(0, 255, 0));
  340. if (XTPOffice2007Images()->IsValid())
  341. {
  342. OnThemeOffice2007();
  343. }
  344. else
  345. {
  346. OnThemeOffice2003();
  347. }
  349. return 0;
  350. }
  352. BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
  353. {
  354. if( !CMDIFrameWnd::PreCreateWindow(cs) )
  355. return FALSE;
  357. cs.lpszClass = _T("XTPMainFrame");
  358. CXTPDrawHelpers::RegisterWndClass(AfxGetInstanceHandle(), cs.lpszClass, 
  359. CS_DBLCLKS, AfxGetApp()->LoadIcon(IDR_MAINFRAME));
  361. return TRUE;
  362. }
  365. // CMainFrame diagnostics
  367. #ifdef _DEBUG
  368. void CMainFrame::AssertValid() const
  369. {
  370. CMDIFrameWnd::AssertValid();
  371. }
  373. void CMainFrame::Dump(CDumpContext& dc) const
  374. {
  375. CMDIFrameWnd::Dump(dc);
  376. }
  378. #endif //_DEBUG
  380. LRESULT CMainFrame::OnDockingPaneNotify(WPARAM wParam, LPARAM lParam)
  381. {
  382. if (wParam == XTP_DPN_SHOWWINDOW)
  383. {
  384. // get a pointer to the docking pane being shown.
  385. CXTPDockingPane* pPane = (CXTPDockingPane*)lParam;
  386. if (!pPane->IsValid())
  387. {
  388. int nIndex = pPane->GetID() - IDR_PANE1;
  389. ASSERT(nIndex >=0 &&  nIndex < sizeof(m_wndPanes) / sizeof(m_wndPanes[0]));
  390. CEditPane& wndEdit = m_wndPanes[nIndex];
  392. // create and attach the edit control for this pane.
  393. if (!::IsWindow(wndEdit.m_hWnd))
  394. {
  395. if (!wndEdit.CreateEx(WS_EX_STATICEDGE, _T("EDIT"), _T(""),
  396. WS_CHILD|ES_AUTOVSCROLL|ES_MULTILINE, CRect(0, 0,200, 120), this, pPane->GetID()))
  397. {
  398. TRACE0( "Error creating pane edit control.n" );
  399. }
  400. wndEdit.SetFont(&m_fntEdit);
  402. AdjustStyle(m_paneManager.GetCurrentTheme());
  403. }
  405. pPane->Attach(&wndEdit);
  406. }
  408. return TRUE; // handled
  409. }
  411. if (wParam == XTP_DPN_CONTEXTMENU)
  412. {
  413. XTP_DOCKINGPANE_CLICK* pClick = (XTP_DOCKINGPANE_CLICK*)lParam;
  415. CMenu menu;
  416. VERIFY(menu.LoadMenu(IDR_POPUP_PANES));
  417. CMenu* pPopup = menu.GetSubMenu(0);
  418. TrackPopupMenu(pPopup->GetSafeHmenu(), TPM_RIGHTBUTTON, pClick->pt.x, pClick->pt.y, 0, AfxGetMainWnd()->GetSafeHwnd(), 0);
  420. return TRUE;
  421. }
  423. return FALSE;
  424. }
  426. void CMainFrame::AdjustStyle(XTPDockingPanePaintTheme theme)
  427. {
  428. BOOL bBorder = FALSE, bStaticEdge = FALSE, bClientEdge = FALSE;
  429. switch(theme)
  430. {
  431. case xtpPaneThemeOffice: bStaticEdge = TRUE;    break;
  432. case xtpPaneThemeDefault: bBorder = TRUE; break;
  433. case xtpPaneThemeGrippered: bClientEdge = TRUE; break;
  434. }
  436. for (int i = 0; i < sizeof(m_wndPanes) / sizeof(m_wndPanes[0]); i++)
  437. {
  438. if (!m_wndPanes[i].m_hWnd)
  439. {
  440. if (!m_wndPanes[i].CreateEx(WS_EX_STATICEDGE, _T("EDIT"), _T(""),
  441. WS_CHILD|ES_AUTOVSCROLL|ES_MULTILINE, CRect(0, 0,0, 0), this, IDR_PANE1 + i))
  442. {
  443. TRACE0( "Error creating pane edit control.n" );
  444. }
  445. m_wndPanes[i].SetFont(&m_fntEdit);
  447. }
  448. m_wndPanes[i].ModifyStyle(bBorder? 0: WS_BORDER, bBorder? WS_BORDER: 0, SWP_FRAMECHANGED|SWP_DRAWFRAME);
  449. m_wndPanes[i].ModifyStyleEx(bStaticEdge? 0: WS_EX_STATICEDGE, bStaticEdge? WS_EX_STATICEDGE: 0, SWP_FRAMECHANGED|SWP_DRAWFRAME );
  450. m_wndPanes[i].ModifyStyleEx(bClientEdge? 0: WS_EX_CLIENTEDGE, bClientEdge? WS_EX_CLIENTEDGE: 0, SWP_FRAMECHANGED|SWP_DRAWFRAME );
  451. }
  452. }
  453. // CMainFrame message handlers
  455. void CMainFrame::OnShowPane(UINT nID)
  456. {
  457. m_paneManager.ShowPane(nID);
  458. }
  461. void CMainFrame::SwitchLayout()
  462. {
  463. if (m_bMinMaxSample)
  464. OnMinMaxSamlpe();
  466. if (m_bEditor)
  467. {
  468. m_paneManager.GetLayout(m_pEditorLayout);
  469. m_paneManager.SetLayout(m_pRunLayout);
  470. } else
  471. {
  472. m_paneManager.GetLayout(m_pRunLayout);
  473. m_paneManager.SetLayout(m_pEditorLayout);
  474. }
  475. m_bEditor = !m_bEditor;
  476. }
  478. void CMainFrame::OnLayoutEditor()
  479. {
  480. if (!m_bEditor) SwitchLayout();
  482. }
  484. void CMainFrame::OnLayoutRun()
  485. {
  486. if (m_bEditor) SwitchLayout();
  487. }
  489. void CMainFrame::OnUpdateLayoutEditor(CCmdUI *pCmdUI)
  490. {
  491. pCmdUI->SetCheck(m_bEditor);
  492. }
  494. void CMainFrame::OnUpdateLayoutRun(CCmdUI *pCmdUI)
  495. {
  496. pCmdUI->SetCheck(!m_bEditor);
  497. }
  499. void CMainFrame::OnDestroy()
  500. {
  501. if (m_bMinMaxSample)
  502. {
  503. OnMinMaxSamlpe();
  504. }
  506. CMDIFrameWnd::OnDestroy();
  508. m_paneManager.GetLayout(m_bEditor? m_pEditorLayout: m_pRunLayout);
  510. m_pEditorLayout->Save(_T("EditorLayout"));
  511. m_pRunLayout->Save(_T("RunLayout"));
  514. delete m_pEditorLayout;
  515. delete m_pRunLayout;
  516. }
  518. void CMainFrame::OnThemeDefault()
  519. {
  520. AdjustStyle(xtpPaneThemeDefault);
  521. SetDockingPaneTheme(xtpPaneThemeDefault);
  522. m_nSelectedTheme = ID_THEME_DEFAULT;
  524. SetCommandBarsTheme(xtpThemeOffice2000);
  525. }
  526. void CMainFrame::OnThemeOffice()
  527. {
  528. AdjustStyle(xtpPaneThemeOffice);
  529. SetDockingPaneTheme(xtpPaneThemeOffice);
  530. m_nSelectedTheme = ID_THEME_OFFICE;
  532. SetCommandBarsTheme(xtpThemeOfficeXP);
  534. }
  536. void CMainFrame::OnThemeWhidbey()
  537. {
  538. AdjustStyle(xtpPaneThemeOffice);
  539. SetDockingPaneTheme(xtpPaneThemeVisualStudio2005);
  540. m_nSelectedTheme = ID_THEME_WHIDBEY;
  542. SetCommandBarsTheme(xtpThemeWhidbey);
  544. }
  546. void CMainFrame::OnThemeExplorer()
  547. {
  548. AdjustStyle(xtpPaneThemeGrippered);
  549. SetDockingPaneTheme(xtpPaneThemeExplorer);
  550. m_nSelectedTheme = ID_THEME_EXPLORER;
  552. SetCommandBarsTheme(xtpThemeNativeWinXP);
  554. }
  556. void CMainFrame::SetCommandBarsTheme(XTPPaintTheme paintTheme)
  557. {
  558. CXTPPaintManager::SetTheme(paintTheme);
  560. EnableOffice2007Frame(paintTheme == xtpThemeRibbon ? GetCommandBars() : NULL);
  562. GetCommandBars()->RedrawCommandBars();
  563. }
  565. void CMainFrame::OnThemeOffice2007()
  566. {
  567. AdjustStyle(xtpPaneThemeOffice);
  568. SetDockingPaneTheme(xtpPaneThemeOffice2007);
  569. m_nSelectedTheme = ID_THEME_OFFICE2007;
  571. SetCommandBarsTheme(xtpThemeRibbon);
  573. }
  575. void CMainFrame::OnThemeWord2007()
  576. {
  577. AdjustStyle(xtpPaneThemeOffice);
  578. SetDockingPaneTheme(xtpPaneThemeWord2007);
  579. m_nSelectedTheme = ID_THEME_WORD2007;
  581. SetCommandBarsTheme(xtpThemeRibbon);
  583. }
  585. void CMainFrame::OnThemeOffice2003()
  586. {
  587. AdjustStyle(xtpPaneThemeOffice);
  588. SetDockingPaneTheme(xtpPaneThemeOffice2003);
  589. m_nSelectedTheme = ID_THEME_OFFICE2003;
  591. SetCommandBarsTheme(xtpThemeOffice2003);
  592. }
  594. void CMainFrame::SetDockingPaneTheme(XTPDockingPanePaintTheme theme)
  595. {
  596. m_paneManager.SetClientMargin(theme == xtpPaneThemeOffice2007 ? 3 : 0);
  597. m_paneManager.SetTheme(theme);
  598. }
  600. void CMainFrame::OnThemeShortcutBar2003()
  601. {
  602. AdjustStyle(xtpPaneThemeOffice);
  603. SetDockingPaneTheme(xtpPaneThemeShortcutBar2003);
  604. m_nSelectedTheme = ID_THEME_SHORTCUTBAR2003;
  606. SetCommandBarsTheme(xtpThemeOffice2003);
  607. }
  609. void CMainFrame::OnThemeWinXP()
  610. {
  611. AdjustStyle(xtpPaneThemeGrippered);
  612. SetDockingPaneTheme(xtpPaneThemeNativeWinXP);
  613. m_nSelectedTheme = ID_THEME_WINXP;
  615. SetCommandBarsTheme(xtpThemeNativeWinXP);
  617. }
  621. void CMainFrame::OnThemeGrippered()
  622. {
  623. AdjustStyle(xtpPaneThemeGrippered);
  624. SetDockingPaneTheme(xtpPaneThemeGrippered);
  625. m_nSelectedTheme = ID_THEME_GRIPPERED;
  627. m_paneManager.GetPaintManager()->GetTabPaintManager()->m_clientFrame = xtpTabFrameBorder;
  629. SetCommandBarsTheme(xtpThemeOffice2000);
  631. }
  633. void CMainFrame::OnThemeVisio()
  634. {
  635. AdjustStyle(xtpPaneThemeVisio);
  636. SetDockingPaneTheme(xtpPaneThemeVisio);
  637. m_nSelectedTheme = ID_THEME_VISIO;
  639. SetCommandBarsTheme(xtpThemeOfficeXP);
  641. }
  643. void CMainFrame::OnThemeVisio2003()
  644. {
  645. AdjustStyle(xtpPaneThemeVisio);
  646. SetDockingPaneTheme(xtpPaneThemeOffice2003);
  647. m_nSelectedTheme = ID_THEME_VISIO_OFFICE2003;
  649. m_paneManager.GetPaintManager()->GetTabPaintManager()->SetAppearance(xtpTabAppearanceVisio);
  650. m_paneManager.GetPaintManager()->GetTabPaintManager()->SetColor(xtpTabColorOffice2003);
  651. m_paneManager.GetPaintManager()->GetTabPaintManager()->m_bHotTracking = TRUE;
  653. m_paneManager.GetPaintManager()->GetPanelPaintManager()->SetColor(xtpTabColorOffice2003);
  656. SetCommandBarsTheme(xtpThemeOffice2003);
  658. }
  660. void CMainFrame::OnThemeVisio2000()
  661. {
  662. AdjustStyle(xtpPaneThemeVisio);
  663. SetDockingPaneTheme(xtpPaneThemeDefault);
  664. m_nSelectedTheme = ID_THEME_VISIO_OFFICE2000;
  666. m_paneManager.GetPaintManager()->GetTabPaintManager()->SetAppearance(xtpTabAppearanceVisio);
  668. SetCommandBarsTheme(xtpThemeOffice2000);
  669. }
  672. void CMainFrame::OnThemeCustom()
  673. {
  674. AdjustStyle(xtpPaneThemeCustom);
  675. m_paneManager.SetCustomTheme(new CCustomTheme());
  676. m_nSelectedTheme = ID_THEME_CUSTOM;
  678. SetCommandBarsTheme(xtpThemeOfficeXP);
  680. }
  682. void CMainFrame::OnThemeCustom2()
  683. {
  684. AdjustStyle(xtpPaneThemeGrippered);
  685. m_paneManager.SetCustomTheme(new CXTPDockingPaneDefaultTheme());
  686. m_nSelectedTheme = ID_THEME_CUSTOM2;
  688. CXTPTabPaintManager* pTabPaintManager = m_paneManager.GetPaintManager()->GetTabPaintManager();
  690. pTabPaintManager->SetPosition(xtpTabPositionTop);
  691. pTabPaintManager->m_clientFrame = xtpTabFrameBorder;
  694. SetCommandBarsTheme(xtpThemeOffice2000);
  696. }
  698. void CMainFrame::OnThemeCustom3()
  699. {
  700. AdjustStyle(xtpPaneThemeOffice);
  701. m_nSelectedTheme = ID_THEME_CUSTOM3;
  703. m_paneManager.SetCustomTheme(new CXTPDockingPaneOfficeTheme());
  704. m_paneManager.GetPaintManager()->GetTabPaintManager()->SetAppearance(xtpTabAppearanceStateButtons);
  705. m_paneManager.GetPaintManager()->GetPanelPaintManager()->SetAppearance(xtpTabAppearanceStateButtons);
  707. SetCommandBarsTheme(xtpThemeOfficeXP);
  709. }
  711. void CMainFrame::OnThemeCustom4()
  712. {
  713. AdjustStyle(xtpPaneThemeVisio);
  714. m_nSelectedTheme = ID_THEME_CUSTOM4;
  716. m_paneManager.SetCustomTheme(new CXTPDockingPaneOfficeTheme());
  718. CXTPTabPaintManager* pTabPaintManager = m_paneManager.GetPaintManager()->GetTabPaintManager();
  719. pTabPaintManager->SetAppearance(xtpTabAppearanceExcel);
  720. pTabPaintManager->m_clientFrame = xtpTabFrameBorder;
  722. pTabPaintManager = m_paneManager.GetPaintManager()->GetPanelPaintManager();
  723. pTabPaintManager->SetAppearance(xtpTabAppearanceExcel);
  726. SetCommandBarsTheme(xtpThemeOfficeXP);
  728. }
  730. void CMainFrame::OnUpdateTheme(CCmdUI *pCmdUI)
  731. {
  732. pCmdUI->SetCheck(m_nSelectedTheme == pCmdUI->m_nID);
  733. }
  736. void CMainFrame::OnHideClient()
  737. {
  738. m_paneManager.HideClient(!m_paneManager.IsClientHidden());
  739. }
  741. void CMainFrame::OnUpdateHideClient(CCmdUI *pCmdUI)
  742. {
  743. pCmdUI->SetCheck(m_paneManager.IsClientHidden()? TRUE: FALSE);
  744. }
  746. void CMainFrame::OnUseSplitterTracker()
  747. {
  748. m_paneManager.UseSplitterTracker(!m_paneManager.IsSplitterTrackerUsed());
  749. }
  751. void CMainFrame::OnUpdateUseSplitterTracker(CCmdUI *pCmdUI)
  752. {
  753. pCmdUI->SetCheck(m_paneManager.IsSplitterTrackerUsed()? TRUE: FALSE);
  754. }
  756. void CMainFrame::OnThemedFloatingFrames()
  757. {
  758. m_paneManager.SetThemedFloatingFrames(!m_paneManager.IsThemedFloatingFrames());
  759. }
  760. void CMainFrame::OnUpdateThemedFloatingFrames(CCmdUI *pCmdUI)
  761. {
  762. pCmdUI->SetCheck(m_paneManager.IsThemedFloatingFrames()? TRUE: FALSE);
  763. }
  765. void CMainFrame::OnAlphaContext()
  766. {
  767. m_paneManager.SetAlphaDockingContext(!m_paneManager.IsAlphaDockingContext());
  769. }
  770. void CMainFrame::OnUpdateAlphaContext(CCmdUI *pCmdUI)
  771. {
  772. pCmdUI->SetCheck(m_paneManager.IsAlphaDockingContext()? TRUE: FALSE);
  773. }
  775. void CMainFrame::OnDockingStickers()
  776. {
  777. m_paneManager.SetShowDockingContextStickers(!m_paneManager.IsShowDockingContextStickers());
  778. }
  779. void CMainFrame::OnUpdateDockingStickers(CCmdUI *pCmdUI)
  780. {
  781. if (m_paneManager.IsAlphaDockingContext())
  782. {
  783. pCmdUI->SetCheck(m_paneManager.IsShowDockingContextStickers()? TRUE: FALSE);
  784. }
  785. else
  786. {
  787. pCmdUI->Enable(FALSE);
  788. }
  789. }
  791. void CMainFrame::OnMinMaxSamlpe()
  792. {
  793. m_bMinMaxSample = !m_bMinMaxSample;
  795. if (m_bMinMaxSample)
  796. {
  797. CXTPDockingPane* pPane = m_paneManager.FindPane(IDR_PANE1);
  798. ASSERT(pPane);
  799. pPane->SetMinTrackSize(CSize(100, 100));
  800. pPane->SetMaxTrackSize(CSize(150, 150));
  802. pPane = m_paneManager.FindPane(IDR_PANE2);
  803. ASSERT(pPane);
  804. pPane->SetMinTrackSize(CSize(130, 130));
  805. pPane->SetMaxTrackSize(CSize(130, 130));
  806. }
  807. else
  808. {
  809. CXTPDockingPane* pPane = m_paneManager.FindPane(IDR_PANE1);
  810. ASSERT(pPane);
  811. pPane->SetMinTrackSize(CSize(0, 0));
  812. pPane->SetMaxTrackSize(CSize(32000, 32000));
  814. pPane = m_paneManager.FindPane(IDR_PANE2);
  815. ASSERT(pPane);
  816. pPane->SetMinTrackSize(CSize(0, 0));
  817. pPane->SetMaxTrackSize(CSize(32000, 32000));
  818. }
  820. for (int i = 0; i < sizeof(m_wndPanes) / sizeof(m_wndPanes[0]); i++)
  821. {
  822. if (m_wndPanes[i].m_hWnd)
  823. {
  824. m_wndPanes[i].OnSize(0, 0, 0);
  825. m_wndPanes[i].RedrawWindow();
  827. }
  828. }
  829. m_paneManager.RedrawPanes();
  830. }
  832. void CMainFrame::OnUpdateMinMaxSamlpe(CCmdUI *pCmdUI)
  833. {
  834. pCmdUI->SetCheck(m_bMinMaxSample);
  835. }
  841. void CMainFrame::OnLoadFromFile()
  842. {
  843. CXTPDockingPaneLayout* pLayout = m_bEditor? m_pEditorLayout: m_pRunLayout;
  845. CString strFilter = _T("XML Document(*.xml)|*.xml|All files (*.*)|*.*||");
  846. CFileDialog fd(TRUE, _T("xml"), NULL, OFN_HIDEREADONLY|OFN_FILEMUSTEXIST, strFilter);
  847. if (fd.DoModal() == IDOK)
  848. {
  849. #ifndef _XTP_EXCLUDE_XML
  850. if (pLayout->LoadFromFile(fd.GetPathName(), _T("Common")))
  851. {
  852. m_paneManager.SetLayout(pLayout);
  853. }
  854. #else
  855. CFile file(fd.GetPathName(), CFile::modeRead);
  856. CArchive ar(&file, CArchive::load);
  858. pLayout->Serialize(ar);
  859. if (pLayout->IsValid())
  860. {
  861. m_paneManager.SetLayout(pLayout);
  862. }
  864. #endif
  865. }
  866. }
  868. void CMainFrame::OnSaveToFile()
  869. {
  870. CXTPDockingPaneLayout* pLayout = m_bEditor? m_pEditorLayout: m_pRunLayout;
  872. CString strFilter = _T("XML Document(*.xml)|*.xml|All files (*.*)|*.*||");
  873. CFileDialog fd(FALSE, _T("xml"), NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, strFilter);
  874. if (fd.DoModal() == IDOK)
  875. {
  876. #ifndef _XTP_EXCLUDE_XML
  878. m_paneManager.GetLayout(pLayout);
  879. pLayout->SaveToFile(fd.GetPathName(), _T("Common"));
  880. #else
  881. m_paneManager.GetLayout(pLayout);
  882. CFile file(fd.GetPathName(), CFile::modeCreate|CFile::modeWrite);
  883. CArchive ar(&file, CArchive::store);
  885. pLayout->Serialize(ar);
  887. #endif
  888. }
  890. }
  892. void CMainFrame::OnLoadFromResource()
  893. {
  895. #ifndef _XTP_EXCLUDE_XML
  897. LPCTSTR lpszResourceName = MAKEINTRESOURCE(IDR_SPIRAL);
  899. CXTPPropExchangeXMLNode px(TRUE, NULL, _T("DockingPaneLayouts"));
  901. if (px.LoadFromResource(AfxGetInstanceHandle(), lpszResourceName, RT_HTML))
  902. {
  903. CXTPDockingPaneLayout* pLayout = m_bEditor? m_pEditorLayout: m_pRunLayout;
  904. CXTPPropExchangeSection pxCommon(px.GetSection(_T("Common")));
  906. if (pLayout->DoPropExchange(&pxCommon))
  907. {
  908. m_paneManager.SetLayout(pLayout);
  909. }
  911. }
  913. #endif
  915. }
  918. void CMainFrame::OnCustomize()
  919. {
  920. // Get a pointer to the command bars object.
  921. CXTPCommandBars* pCommandBars = GetCommandBars();
  922. if(pCommandBars != NULL)
  923. {
  924. // Instanciate the customize dialog object.
  925. CXTPCustomizeSheet dlg(pCommandBars);
  927. // Add the options page to the customize dialog.
  928. CXTPCustomizeOptionsPage pageOptions(&dlg);
  929. dlg.AddPage(&pageOptions);
  931. // Add the commands page to the customize dialog.
  932. CXTPCustomizeCommandsPage* pCommands = dlg.GetCommandsPage();
  933. pCommands->AddCategories(IDR_PaneTYPE);
  935. // Use the command bar manager to initialize the
  936. // customize dialog.
  937. pCommands->InsertAllCommandsCategory();
  938. pCommands->InsertBuiltInMenus(IDR_PaneTYPE);
  939. pCommands->InsertNewMenuCategory();
  941. // Dispaly the dialog.
  942. dlg.DoModal();
  943. }
  944. }
  946. void CMainFrame::OnClose()
  947. {
  948. // Save the current state for toolbars and menus.
  949. SaveCommandBars(_T("CommandBars"));
  950. CMDIFrameWnd::OnClose();
  951. }
  955. void CMainFrame::OnGetMinMaxInfo(LPMINMAXINFO pMinMaxInfo)
  956. {
  957. CMDIFrameWnd::OnGetMinMaxInfo(pMinMaxInfo);
  959. if (m_bMinMaxSample)
  960. {
  961. CXTPWindowRect rcWindow(this);
  963. CRect rcTopPane= m_paneManager.GetTopPane()->GetPaneWindowRect();
  965. CSize szBorder = rcWindow.Size() - rcTopPane.Size();
  967. MINMAXINFO mmi;
  968. m_paneManager.GetTopPane()->GetMinMaxInfo(&mmi);
  970. pMinMaxInfo->ptMinTrackSize = CPoint(mmi.ptMinTrackSize) + szBorder;
  971. }
  972. }
  975. //////////////////////////////////////////////////////////////////////////
  976. // CEditPane
  978. CEditPane::CEditPane()
  979. {
  980. }
  982. LRESULT CEditPane::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  983. {
  984. if (message == WM_NCPAINT && GetExStyle() & WS_EX_STATICEDGE)
  985. {
  986. CRect rc;
  987. GetWindowRect(&rc);
  988. CWindowDC dc(this);
  989. rc.OffsetRect(-rc.TopLeft());
  991. COLORREF clrFrame = ((CMainFrame*)AfxGetMainWnd())->m_paneManager.GetPaintManager()->GetXtremeColor(XPCOLOR_FRAME);
  993. dc.Draw3dRect(rc, clrFrame, clrFrame);
  994. return TRUE;
  995. }
  996. return CXTPEdit::WindowProc(message, wParam, lParam);
  997. }
  1000. BEGIN_MESSAGE_MAP(CEditPane, CXTPEdit)
  1001. ON_WM_CTLCOLOR_REFLECT()
  1002. ON_WM_SIZE()
  1003. END_MESSAGE_MAP()
  1005. HBRUSH CEditPane::CtlColor(CDC* pDC, UINT /*nCtlColor*/)
  1006. {
  1007. static CBrush brush(RGB(0xFF, 230, 191));
  1009. pDC->SetBkMode(TRANSPARENT);
  1011. if (!m_bMinMaxSample)
  1012. return GetSysColorBrush(COLOR_WINDOW);
  1014. CXTPDockingPaneManager& paneManager = ((CMainFrame*)AfxGetMainWnd())->m_paneManager;
  1016. CXTPDockingPane* pPane = paneManager.FindPane(GetDlgCtrlID());
  1018. if (pPane)
  1019. {
  1020. MINMAXINFO mmi;
  1021. pPane->GetMinMaxInfo(&mmi);
  1023. if (mmi.ptMinTrackSize.x > 0)
  1024. {
  1025. return brush;
  1026. }
  1027. }
  1028. return GetSysColorBrush(COLOR_WINDOW);
  1029. }
  1031. void CEditPane::OnSize(UINT nType, int cx, int cy)
  1032. {
  1033. CEdit::OnSize(nType, cx, cy);
  1035. if (!m_bMinMaxSample || (cx == 0 && cy == 0))
  1036. return;
  1037. CXTPDockingPaneManager& paneManager = ((CMainFrame*)AfxGetMainWnd())->m_paneManager;
  1039. CXTPDockingPane* pPane = paneManager.FindPane(GetDlgCtrlID());
  1041. if (pPane)
  1042. {
  1043. MINMAXINFO mmi;
  1044. pPane->GetMinMaxInfo(&mmi);
  1046. CString strInfo;
  1048. if (mmi.ptMinTrackSize.x > 0)
  1049. {
  1050. CXTPWindowRect rc(this);
  1052. strInfo.Format(_T("Tracking Size:rnMin (%i, %i)rnMax (%i, %i)rnCurrent (%i, %i)"),
  1053. mmi.ptMinTrackSize.x, mmi.ptMinTrackSize.y, mmi.ptMaxTrackSize.x, mmi.ptMaxTrackSize.y, rc.Width(), rc.Height());
  1054. }
  1055. SetWindowText(strInfo);
  1056. }
  1057. }
  1060. void CMainFrame::OnSetPreviewMode(BOOL bPreview, CPrintPreviewState* pState)
  1061. {
  1063. // Toggle CommandBars
  1064. GetCommandBars()->OnSetPreviewMode(bPreview);
  1067. // Toggle Docking Panes.
  1068. m_paneManager.OnSetPreviewMode(bPreview);
  1071. CMDIFrameWnd::OnSetPreviewMode(bPreview, pState);
  1072. }
  1075. void CMainFrame::SwitchDefaultPaneOptions(XTPDockingPaneOptions dwOption)
  1076. {
  1077. DWORD dwOptions = m_paneManager.GetDefaultPaneOptions();
  1079. m_paneManager.SetDefaultPaneOptions(dwOptions & dwOption? dwOptions & ~dwOption: dwOptions | dwOption);
  1080. m_paneManager.RecalcFramesLayout();
  1081. }
  1083. void CMainFrame::OnCaptionButtonClose()
  1084. {
  1085. SwitchDefaultPaneOptions(xtpPaneNoCloseable);
  1086. }
  1088. void CMainFrame::OnUpdateCaptionButtonClose(CCmdUI* pCmdUI)
  1089. {
  1090. pCmdUI->SetCheck(m_paneManager.GetDefaultPaneOptions() & xtpPaneNoCloseable? FALSE: TRUE);
  1092. }
  1094. void CMainFrame::OnCaptionButtonAutoHide()
  1095. {
  1096. SwitchDefaultPaneOptions(xtpPaneNoHideable);
  1098. }
  1100. void CMainFrame::OnUpdateCaptionButtonAutoHide(CCmdUI* pCmdUI)
  1101. {
  1102. pCmdUI->SetCheck(m_paneManager.GetDefaultPaneOptions() & xtpPaneNoHideable? FALSE: TRUE);
  1103. }
  1105. void CMainFrame::OnCaptionButtonMenu()
  1106. {
  1107. SwitchDefaultPaneOptions(xtpPaneHasMenuButton);
  1109. }
  1111. void CMainFrame::OnUpdateCaptionButtonMenu(CCmdUI* pCmdUI)
  1112. {
  1113. pCmdUI->SetCheck(m_paneManager.GetDefaultPaneOptions() & xtpPaneHasMenuButton? TRUE: FALSE);
  1114. }
  1116. void CMainFrame::OnCaptionButtonMaximize()
  1117. {
  1118. m_paneManager.ShowCaptionMaximizeButton(!m_paneManager.IsCaptionMaximizeButtonsVisible());
  1119. }
  1121. void CMainFrame::OnUpdateCaptionButtonMaximize(CCmdUI* pCmdUI)
  1122. {
  1123. pCmdUI->SetCheck(m_paneManager.IsCaptionMaximizeButtonsVisible()? TRUE: FALSE);
  1125. }
  1127. void CMainFrame::OnCaptionVisible()
  1128. {
  1129. m_paneManager.GetPaintManager()->m_bShowCaption = !m_paneManager.GetPaintManager()->m_bShowCaption;
  1130. m_paneManager.RedrawPanes();
  1131. }
  1133. void CMainFrame::OnCaptionHorizontal()
  1134. {
  1135. m_paneManager.SetCaptionDirection(xtpPaneCaptionHorizontal);
  1136. }
  1138. void CMainFrame::OnCaptionVertical()
  1139. {
  1140. m_paneManager.SetCaptionDirection(xtpPaneCaptionVertical);
  1141. }
  1143. void CMainFrame::OnCaptionAutoBySize()
  1144. {
  1145. m_paneManager.SetCaptionDirection(xtpPaneCaptionAutoBySize);
  1146. }
  1148. void CMainFrame::OnCaptionAutoByPosition()
  1149. {
  1150. m_paneManager.SetCaptionDirection(xtpPaneCaptionAutoByPosition);
  1151. }
  1153. void CMainFrame::OnUpdateCaptionVisible(CCmdUI* pCmdUI)
  1154. {
  1155. pCmdUI->SetCheck(m_paneManager.GetPaintManager()->m_bShowCaption? TRUE: FALSE);
  1156. }
  1158. void CMainFrame::OnUpdateCaptionHorizontal(CCmdUI* pCmdUI)
  1159. {
  1160. pCmdUI->SetCheck(m_paneManager.GetCaptionDirection() == xtpPaneCaptionHorizontal? TRUE: FALSE);
  1161. }
  1163. void CMainFrame::OnUpdateCaptionVertical(CCmdUI* pCmdUI)
  1164. {
  1165. pCmdUI->SetCheck(m_paneManager.GetCaptionDirection() == xtpPaneCaptionVertical? TRUE: FALSE);
  1166. }
  1168. void CMainFrame::OnUpdateCaptionAutoBySize(CCmdUI* pCmdUI)
  1169. {
  1170. pCmdUI->SetCheck(m_paneManager.GetCaptionDirection() == xtpPaneCaptionAutoBySize? TRUE: FALSE);
  1171. }
  1173. void CMainFrame::OnUpdateCaptionAutoByPosition(CCmdUI* pCmdUI)
  1174. {
  1175. pCmdUI->SetCheck(m_paneManager.GetCaptionDirection() == xtpPaneCaptionAutoByPosition? TRUE: FALSE);
  1176. }
  1178. void CMainFrame::OnCloseButtonAffects()
  1179. {
  1180. m_paneManager.m_bCloseGroupOnButtonClick = !m_paneManager.m_bCloseGroupOnButtonClick;
  1181. }
  1183. void CMainFrame::OnAutoHideButtonAffects()
  1184. {
  1185. m_paneManager.m_bHideGroupOnButtonClick = !m_paneManager.m_bHideGroupOnButtonClick;
  1186. }
  1188. void CMainFrame::OnUpdateCloseButtonAffects(CCmdUI* pCmdUI)
  1189. {
  1190. pCmdUI->SetCheck(m_paneManager.m_bCloseGroupOnButtonClick? FALSE: TRUE);
  1191. }
  1193. void CMainFrame::OnUpdateAutoHideButtonAffects(CCmdUI* pCmdUI)
  1194. {
  1195. pCmdUI->SetCheck(m_paneManager.m_bHideGroupOnButtonClick? FALSE: TRUE);
  1196. }
  1199. void CMainFrame::OnUpdateShowContentsWhileDragging(CCmdUI* pCmdUI)
  1200. {
  1201. pCmdUI->SetCheck(m_paneManager.GetShowContentsWhileDragging()? TRUE: FALSE);
  1202. }
  1204. void CMainFrame::OnShowContentsWhileDragging()
  1205. {
  1206. m_paneManager.SetShowContentsWhileDragging(!m_paneManager.GetShowContentsWhileDragging());
  1207. }
  1209. void CMainFrame::OnStickyFloatingFrames()
  1210. {
  1211. m_paneManager.SetStickyFloatingFrames(!m_paneManager.IsStickyFloatingFrames());
  1212. }
  1214. void CMainFrame::OnUpdateStickyFloatingFrames(CCmdUI* pCmdUI)
  1215. {
  1216. pCmdUI->SetCheck(m_paneManager.IsStickyFloatingFrames() ? TRUE: FALSE);
  1217. }
  1219. void CMainFrame::OnTransparentFloatingFrames()
  1220. {
  1221. m_paneManager.SetFloatingFramesOpacity(m_paneManager.GetFloatingFramesOpacity() != 255 ? 255 : 200);
  1222. }
  1224. void CMainFrame::OnUpdateTransparentFloatingFrames(CCmdUI* pCmdUI)
  1225. {
  1226. pCmdUI->SetCheck(m_paneManager.GetFloatingFramesOpacity() != 255);
  1227. }
  1229. void CMainFrame::OnEnableSideDocking()
  1230. {
  1231. m_paneManager.EnableSideDocking(!m_paneManager.IsSideDockingEnabled());
  1232. }
  1234. void CMainFrame::OnUpdateEnableSideDocking(CCmdUI* pCmdUI)
  1235. {
  1236. pCmdUI->SetCheck(m_paneManager.IsSideDockingEnabled());
  1237. }