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

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

对话框与窗口

开发平台：

Visual C++

XTPCommandBars.cpp：源码内容
  1. // XTPCommandBars.cpp : implementation of the CXTPCommandBars class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS 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 "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPColorManager.h"
  26. #include "Common/XTPImageManager.h"
  27. #include "Common/XTPIntel80Helpers.h"
  28. #include "Common/XTPVc50Helpers.h"
  29. #include "Common/XTPPropExchange.h"
  30. #include "Common/XTPToolTipContext.h"
  31. #include "TabManager/XTPTabManager.h"
  33. #include "XTPDockBar.h"
  34. #include "XTPMenuBar.h"
  35. #include "XTPShortcutManager.h"
  36. #include "XTPPaintManager.h"
  37. #include "XTPKeyboardManager.h"
  38. #include "XTPMouseManager.h"
  39. #include "XTPControls.h"
  40. #include "XTPControlComboBox.h"
  41. #include "XTPCustomizeTools.h"
  42. #include "XTPCommandBars.h"
  43. #include "XTPSoundManager.h"
  44. #include "XTPControlExt.h"
  45. #include "XTPTabClientWnd.h"
  46. #include "XTPReBar.h"
  48. #ifdef _XTP_INCLUDE_RIBBON
  49. #include "Ribbon/XTPRibbonBar.h"
  50. #endif
  54. #ifdef _DEBUG
  55. #define new DEBUG_NEW
  56. #undef THIS_FILE
  57. static char THIS_FILE[] = __FILE__;
  58. #endif
  60. CRuntimeClass* CXTPCommandBars::m_pToolBarClass = RUNTIME_CLASS(CXTPToolBar);
  61. CRuntimeClass* CXTPCommandBars::m_pMenuBarClass = RUNTIME_CLASS(CXTPMenuBar);
  62. CRuntimeClass* CXTPCommandBars::m_pPopupBarClass = RUNTIME_CLASS(CXTPPopupBar);
  63. CRuntimeClass* CXTPCommandBars::m_pPopupToolBarClass = RUNTIME_CLASS(CXTPPopupToolBar);
  64. CRuntimeClass* CXTPCommandBars::m_pDockBarClass = RUNTIME_CLASS(CXTPDockBar);
  67. //////////////////////////////////////////////////////////////////////////
  69. CXTPCommandBarsContextMenus::CXTPCommandBarsContextMenus(CXTPCommandBars* pCommandBars)
  70. : CXTPCommandBarList(pCommandBars)
  71. {
  72. }
  74. CXTPCommandBar* CXTPCommandBarsContextMenus::Add(CXTPCommandBar* pPopupBar)
  75. {
  76. ASSERT_KINDOF(CXTPPopupBar, pPopupBar);
  77. m_arrBars.Add(pPopupBar);
  78. ((CXTPPopupBar*)pPopupBar)->m_bContextMenu = TRUE;
  79. return pPopupBar;
  80. }
  82. CXTPCommandBar* CXTPCommandBarsContextMenus::Add(UINT nIDBar, LPCTSTR strCaption, CMenu* pSubMenu)
  83. {
  84. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(m_pCommandBars);
  85. m_arrBars.Add(pPopupBar);
  87. pPopupBar->LoadMenu(pSubMenu);
  88. pPopupBar->SetBarID(nIDBar);
  90. pPopupBar->SetTitle(strCaption);
  92. pPopupBar->GetControls()->CreateOriginalControls();
  93. pPopupBar->m_bContextMenu = TRUE;
  95. return pPopupBar;
  96. }
  98. CXTPCommandBar* CXTPCommandBarsContextMenus::Add(UINT nIDBar)
  99. {
  100. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(m_pCommandBars);
  101. m_arrBars.Add(pPopupBar);
  103. CMenu menu;
  104. if (!menu.LoadMenu(nIDBar))
  105. return pPopupBar;
  107. CMenu* pSubMenu = menu.GetSubMenu(0);
  108. if (!pSubMenu)
  109. return pPopupBar;
  111. pPopupBar->LoadMenu(pSubMenu);
  112. pPopupBar->SetBarID(nIDBar);
  114. CString strCaption;
  115. XTPResourceManager()->GetMenuLocaleString(&menu, 0, strCaption, MF_BYPOSITION);
  116. CXTPDrawHelpers::StripMnemonics(strCaption);
  118. pPopupBar->SetTitle(strCaption);
  120. pPopupBar->GetControls()->CreateOriginalControls();
  121. pPopupBar->m_bContextMenu = TRUE;
  123. return pPopupBar;
  124. }
  128. //////////////////////////////////////////////////////////////////////////
  129. // CXTPCommandBarsOptions
  131. CXTPCommandBarsOptions::CXTPCommandBarsOptions()
  132. {
  133. bAlwaysShowFullMenus = TRUE;
  134. bShowFullAfterDelay = TRUE;
  135. bToolBarScreenTips = TRUE;
  136. bToolBarAccelTips = FALSE;
  137. bLargeIcons = FALSE;
  138. bShowExpandButtonAlways = TRUE;
  140. szIcons = szLargeIcons = CSize(0);
  141. szPopupIcons = CSize(0, 0);
  143. bSyncFloatingBars = TRUE;
  144. bDblClickFloat = FALSE;
  145. bShowTextBelowIcons = FALSE;
  147. animationType = xtpAnimateWindowsDefault;
  148. bAltDragCustomization = TRUE;
  150. bAutoHideUnusedPopups = TRUE;
  152. bDirtyState = FALSE;
  153. bShowPopupBarToolTips = FALSE;
  154. bAutoUpdateShortcuts = TRUE;
  156. keyboardCuesUse = xtpKeyboardCuesUseAll;
  157. keyboardCuesShow = xtpKeyboardCuesShowAlways;
  158. bFlyByStatus = TRUE;
  160. bUseAltNumPadKeys = FALSE;
  161. bUseSystemSaveBitsStyle = TRUE;
  163. bDisableCommandIfNoHandler = TRUE;
  165. bWrapLargePopups = FALSE;
  167. bShowKeyboardTips = FALSE;
  168. m_pCommandBars = 0;
  170. EnableAutomation();
  172. }
  174. #ifndef SPI_GETMENUUNDERLINES
  175. #define SPI_GETMENUUNDERLINES 0x100A
  176. #endif
  178. void CXTPCommandBarsOptions::ShowKeyboardCues(XTPKeyboardCuesShow keyboardCues)
  179. {
  180. keyboardCuesShow = keyboardCues;
  182. m_pCommandBars->m_bUseKeyboardCues = FALSE;
  183. m_pCommandBars->m_bKeyboardCuesVisible = keyboardCues != xtpKeyboardCuesShowNever;
  185. if (keyboardCues == xtpKeyboardCuesShowWindowsDefault)
  186. {
  187. BOOL bRetVal = TRUE;
  188. if (::SystemParametersInfo(SPI_GETMENUUNDERLINES, 0, &bRetVal, 0))
  189. {
  190. if (!bRetVal)
  191. {
  192. m_pCommandBars->m_bUseKeyboardCues = TRUE;
  193. m_pCommandBars->m_bKeyboardCuesVisible = FALSE;
  194. }
  195. }
  196. }
  197. }
  199. XTPKeyboardCuesShow CXTPCommandBarsOptions::GetShowKeyboardCues() const
  200. {
  201. return keyboardCuesShow;
  202. }
  206. CXTPCommandBars* CXTPCommandBars::CreateCommandBars()
  207. {
  208. CXTPCommandBars* pCommandBars = (CXTPCommandBars*)CXTPCommandBars::CreateObject();
  209. return pCommandBars;
  210. }
  213. // CXTPCommandBars
  215. IMPLEMENT_DYNCREATE(CXTPCommandBars, CCmdTarget)
  217. CXTPCommandBars::CXTPCommandBars()
  218. : m_pFrame (0)
  219. , m_nDefaultMenuID(0)
  220. {
  221. ZeroMemory(m_pDocks, 4 * sizeof(CXTPDockBar*));
  222. m_pDragSelected = NULL;
  224. m_bQuickCustomizeMode = m_bCustomizeMode = FALSE;
  225. m_bCustomizeAvail = FALSE;
  226. m_pDropSource = new CXTPCustomizeDropSource(this);
  228. m_pPaintManager = NULL;
  229. m_pImageManager = NULL;
  230. m_pMouseManager = NULL;
  231. m_pKeyboardManager = NULL;
  233. m_pOptions = new CXTPCommandBarsOptions;
  234. m_pOptions->m_pCommandBars = this;
  236. m_pDesignerControls = NULL;
  238. m_bIgnoreShiftMenuKey = FALSE;
  240. EnableAutomation();
  242. m_bRecalcLayout = FALSE;
  243. m_bRightToLeft = FALSE;
  245. m_pToolTipContext = new CXTPToolTipContext;
  246. m_pToolTipContext->ModifyToolTipStyle(TTS_NOPREFIX, 0);
  247. m_bUseKeyboardCues = FALSE;
  248. m_bKeyboardCuesVisible = TRUE;
  250. m_pShortcutManager = new CXTPShortcutManager(this);
  252. m_nIDHelpTracking = 0;
  254. m_bDesignerMode = FALSE;
  256. m_keyboardTips.pBar = NULL;
  257. m_keyboardTips.nLevel = 0;
  258. m_keyboardTips.nKey = 0;
  261. m_pActions = new CXTPControlActions(this);
  262. m_bEnableActions = FALSE;
  264. m_pContextMenus = new CXTPCommandBarsContextMenus(this);
  266. }
  268. CXTPCommandBars::~CXTPCommandBars()
  269. {
  270. CMDTARGET_RELEASE(m_pDragSelected);
  271. CMDTARGET_RELEASE(m_pDesignerControls);
  273. m_pContextMenus->RemoveAll();
  274. CMDTARGET_RELEASE(m_pContextMenus);
  276. RemoveAll();
  278. for (int i = 0; i < 4; i++)
  279. {
  280. if (m_pDocks[i])
  281. {
  282. m_pDocks[i]->DestroyWindow();
  283. delete m_pDocks[i];
  284. }
  285. }
  287. delete m_pDropSource;
  289. CMDTARGET_RELEASE(m_pPaintManager);
  290. CMDTARGET_RELEASE(m_pImageManager);
  291. CMDTARGET_RELEASE(m_pToolTipContext);
  292. CMDTARGET_RELEASE(m_pShortcutManager);
  294. CMDTARGET_RELEASE(m_pOptions);
  296. XTPSoundManager()->StopThread();
  298. if (m_pActions)
  299. {
  300. m_pActions->RemoveAll();
  301. CMDTARGET_RELEASE(m_pActions);
  302. }
  303. }
  305. BOOL IsToolBarVisible(CXTPToolBar* pCommandBar)
  306. {
  307. return pCommandBar&& pCommandBar->IsWindowVisible();
  308. }
  311. void CXTPCommandBars::EnableActions()
  312. {
  313. ASSERT(!m_bEnableActions);
  314. m_bEnableActions = TRUE;
  315. }
  317. CXTPControlAction* CXTPCommandBars::CreateAction(int nId)
  318. {
  319. return m_pActions->Add(nId);
  320. }
  322. CXTPControlAction* CXTPCommandBars::FindAction(int nId) const
  323. {
  324. return this == NULL ? NULL : m_pActions->FindAction(nId);
  325. }
  327. CXTPMenuBar* CXTPCommandBars::GetMenuBar() const
  328. {
  329. return DYNAMIC_DOWNCAST(CXTPMenuBar, GetToolBar(XTP_IDR_MENUBAR));
  330. }
  332. CXTPMenuBar* CXTPCommandBars::SetMenu(LPCTSTR strName, UINT nID)
  333. {
  334. CXTPMenuBar* pMenuBar = (CXTPMenuBar*) m_pMenuBarClass->CreateObject();
  335. ASSERT(pMenuBar);
  336. if (!pMenuBar)
  337. return NULL;
  339. pMenuBar->m_pCommandBars = this;
  341. pMenuBar->SetTitle(strName);
  342. pMenuBar->m_nBarID = XTP_IDR_MENUBAR;
  344. if (!pMenuBar->SetPosition(xtpBarTop) ||
  345. !pMenuBar->LoadMenuBar(nID))
  346. {
  347. delete pMenuBar;
  348. return NULL;
  349. }
  351. if (nID > 0)
  352. {
  353. pMenuBar->m_pControls->CreateOriginalControls();
  354. m_nDefaultMenuID = nID;
  355. }
  357. m_arrBars.Add(pMenuBar);
  359. return pMenuBar;
  360. }
  362. void CXTPCommandBars::RecalcFrameLayout(BOOL bDelay)
  363. {
  364. if (m_bRecalcLayout)
  365. return;
  367. if (!m_pFrame->GetSafeHwnd())
  368. return;
  370. CFrameWnd* pFrame = m_pFrame->IsFrameWnd() ? (CFrameWnd*)m_pFrame : NULL;
  371. if (pFrame)
  372. {
  373. if (bDelay)
  374. pFrame->DelayRecalcLayout(FALSE);
  375. else
  376. pFrame->RecalcLayout(FALSE);
  377. }
  378. else
  379. {
  380. CXTPClientRect rc(m_pFrame);
  381. m_pFrame->SendMessage(WM_SIZE, 0, MAKELPARAM(rc.Width(), rc.Height()));
  382. }
  383. }
  385. void CXTPCommandBars::IdleRecalcLayout()
  386. {
  387. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CFrameWnd, GetSite());
  388. if (pFrame)
  389. {
  390. if (pFrame->m_nIdleFlags & CFrameWnd::idleLayout)
  391. {
  392. pFrame->RecalcLayout(FALSE);
  393. pFrame->m_nIdleFlags &= ~CFrameWnd::idleLayout;
  394. }
  395. }
  396. }
  398. void CXTPCommandBars::OnToolBarAdded(CXTPToolBar* pToolBar)
  399. {
  400. ASSERT(pToolBar);
  402. CXTPReBar* pReBar = GetFrameReBar();
  403. if (pReBar)
  404. {
  405. pReBar->AddToolBar(pToolBar, RBBS_GRIPPERALWAYS | RBBS_BREAK);
  406. }
  407. }
  409. void CXTPCommandBars::OnToolBarRemoved(CXTPToolBar* pToolBar)
  410. {
  411. ASSERT(pToolBar);
  413. CXTPReBar* pReBar = GetFrameReBar();
  414. if (pReBar)
  415. {
  416. pReBar->DeleteToolBar(pToolBar);
  417. }
  418. }
  420. CXTPReBar* CXTPCommandBars::GetFrameReBar() const
  421. {
  422. if (!m_pFrame->GetSafeHwnd())
  423. return NULL;
  425. return DYNAMIC_DOWNCAST(CXTPReBar, m_pFrame->GetDlgItem(AFX_IDW_REBAR));
  426. }
  428. CXTPToolBar* CXTPCommandBars::AddCustomBar(LPCTSTR lpcstrCaption, UINT nID, BOOL bTearOffBar)
  429. {
  430. ASSERT(nID != 0);
  432. CXTPToolBar* pCommandBar = (CXTPToolBar*) m_pToolBarClass->CreateObject();
  433. pCommandBar->m_pCommandBars = this;
  435. XTP_COMMANDBARS_CREATEBAR cs;
  436. ZeroMemory(&cs, sizeof(cs));
  437. cs.bCustomBar = TRUE;
  438. cs.bTearOffBar = bTearOffBar;
  439. cs.lpcstrCaption = lpcstrCaption;
  440. cs.pCommandBar = pCommandBar;
  441. cs.nID = nID;
  443. m_pFrame->SendMessage(WM_XTP_CREATECOMMANDBAR, 0, (LPARAM)&cs);
  445. ASSERT(pCommandBar == cs.pCommandBar);
  447. ASSERT(pCommandBar);
  448. pCommandBar->m_strTitle = lpcstrCaption;
  450. if (!pCommandBar->SetPosition(bTearOffBar ? xtpBarFloating : xtpBarTop))
  451. {
  452. delete pCommandBar;
  453. return NULL;
  454. }
  456. m_arrBars.Add(pCommandBar);
  458. pCommandBar->SetBarID(nID);
  459. pCommandBar->m_bBuiltIn = FALSE;
  460. pCommandBar->m_bTearOff = bTearOffBar;
  462. if (!bTearOffBar) RecalcFrameLayout();
  464. OnToolBarAdded(pCommandBar);
  466. return pCommandBar;
  467. }
  469. CXTPShortcutManager* CXTPCommandBars::GetShortcutManager() const
  470. {
  471. return m_pShortcutManager;
  472. }
  474. void CXTPCommandBars::SetShortcutManager(CXTPShortcutManager* pShortcutManager)
  475. {
  476. CMDTARGET_RELEASE(m_pShortcutManager);
  477. m_pShortcutManager = pShortcutManager;
  478. }
  481. CXTPToolBar* CXTPCommandBars::Add(LPCTSTR strName, XTPBarPosition xtpPosition, CRuntimeClass* pToolbarClass)
  482. {
  483. if (!pToolbarClass)
  484. pToolbarClass = m_pToolBarClass;
  486. ASSERT(pToolbarClass && pToolbarClass->IsDerivedFrom(RUNTIME_CLASS(CXTPToolBar)));
  487. ASSERT(IsDockingPosition(xtpPosition) || xtpPosition == xtpBarFloating);
  488. if (!pToolbarClass)
  489. return NULL;
  491. CXTPToolBar* pCommandBar = (CXTPToolBar*) pToolbarClass->CreateObject();
  492. ASSERT(pCommandBar);
  493. if (!pCommandBar)
  494. return NULL;
  496. pCommandBar->m_pCommandBars = this;
  497. pCommandBar->m_strTitle = strName;
  499. if (!pCommandBar->SetPosition(xtpPosition))
  500. {
  501. delete pCommandBar;
  502. return NULL;
  503. }
  505. m_arrBars.Add(pCommandBar);
  507. return pCommandBar;
  508. }
  510. void CXTPCommandBars::EnableDocking()
  511. {
  512. const DWORD dwDockBarMap[4][2] =
  513. {
  514. { AFX_IDW_DOCKBAR_TOP, CBRS_TOP   },
  515. { AFX_IDW_DOCKBAR_BOTTOM, CBRS_BOTTOM },
  516. { AFX_IDW_DOCKBAR_LEFT, CBRS_LEFT   },
  517. { AFX_IDW_DOCKBAR_RIGHT, CBRS_RIGHT  },
  518. };
  520. CWnd* pParentFrame = GetSite();
  521. ASSERT(pParentFrame);
  523. for (int i = 0; i < 4; i++)
  524. {
  525. ASSERT(!m_pDocks[i]);
  527. CXTPDockBar* pDockBar = (CXTPDockBar*)m_pDockBarClass->CreateObject();
  528. pDockBar->m_pCommandBars = this;
  530. if (!pDockBar->Create(pParentFrame,
  531. WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CHILD | WS_VISIBLE |
  532. dwDockBarMap[i][1], dwDockBarMap[i][0]))
  533. {
  534. AfxThrowResourceException();
  535. }
  536. m_pDocks[i] = pDockBar;
  537. }
  538. }
  540. CXTPDockBar* CXTPCommandBars::CanDock(CPoint pt, CXTPDockBar* pMainDock) const
  541. {
  542. CRect rc;
  543. if (pMainDock)
  544. {
  545. pMainDock->GetWindowRect(&rc);
  546. if (pMainDock->m_dwStyle & CBRS_ORIENT_HORZ &&
  547. rc.top - 20 < pt.y && rc.bottom + 20 > pt.y && rc.left - 20 < pt.x && rc.right + 20 > pt.x)
  548. return pMainDock;
  549. if (pMainDock->m_dwStyle & CBRS_ORIENT_VERT &&
  550. rc.left - 20 < pt.x && rc.right + 20 > pt.x && rc.top - 20 < pt.y && rc.bottom + 20 > pt.y)
  551. return pMainDock;
  552. }
  553. for (int i = 0; i < 4; i++)
  554. {
  555. m_pDocks[i]->GetWindowRect(&rc);
  556. if (m_pDocks[i]->m_dwStyle & CBRS_ORIENT_HORZ &&
  557. rc.top - 20 < pt.y && rc.bottom + 20 > pt.y && rc.left - 20 < pt.x && rc.right + 20 > pt.x)
  558. return m_pDocks[i];
  559. if (m_pDocks[i]->m_dwStyle & CBRS_ORIENT_VERT &&
  560. rc.left - 20 < pt.x && rc.right + 20 > pt.x && rc.top - 20 < pt.y && rc.bottom + 20 > pt.y)
  561. return m_pDocks[i];
  562. }
  563. return NULL;
  564. }
  566. BOOL CXTPCommandBars::DockCommandBar(CXTPToolBar* pBar, LPRECT lpRect, CXTPDockBar* pDockBar)
  567. {
  568. ASSERT(pDockBar);
  569. if (!pDockBar)
  570. return FALSE;
  572. if (!pBar->Create(m_pFrame, FALSE))
  573. return FALSE;
  575. pDockBar->DockCommandBar(pBar, lpRect);
  576. pBar->m_barPosition = pDockBar->GetPosition();
  578. return TRUE;
  579. }
  581. BOOL CXTPCommandBars::DockCommandBar(CXTPToolBar* pBar, XTPBarPosition xtpPosition)
  582. {
  583. CXTPDockBar* pDockBar = GetDockBar(xtpPosition);
  584. ASSERT(pDockBar);
  586. return DockCommandBar(pBar, NULL, pDockBar);
  587. }
  589. BOOL CXTPCommandBars::FloatCommandBar(CXTPToolBar* pBar)
  590. {
  591. if (!pBar->Create(m_pFrame, TRUE))
  592. {
  593. return FALSE;
  594. }
  595. if (pBar->m_pDockBar != NULL)
  596. {
  597. pBar->m_pDockBar->RemoveCommandBar(pBar);
  598. pBar->m_pDockBar = NULL;
  600. }
  601. pBar->m_barPosition = xtpBarFloating;
  603. return TRUE;
  604. }
  606. void CXTPCommandBars::DelayRedrawCommandBars()
  607. {
  608. for (int i = 0; i < GetCount(); i++)
  609. {
  610. CXTPToolBar* pBar = GetAt(i);
  611. if (pBar->IsVisible() && pBar->GetSafeHwnd())
  612. {
  613. pBar->DelayRedraw();
  614. }
  615. }
  616. }
  618. void CXTPCommandBars::InvalidateCommandBars()
  619. {
  620. for (int i = 0; i < GetCount(); i++)
  621. {
  622. CXTPToolBar* pBar = GetAt(i);
  623. if (pBar->IsVisible() && pBar->GetSafeHwnd())
  624. {
  625. pBar->Redraw();
  626. }
  627. }
  628. }
  630. void CXTPCommandBars::RedrawCommandBars()
  631. {
  632. m_bRecalcLayout = TRUE;
  634. for (int i = 0; i < GetCount(); i++)
  635. {
  636. CXTPToolBar* pBar = GetAt(i);
  638. for (int j = 0; j < pBar->GetControlCount(); j++)
  639. {
  640. pBar->GetControl(j)->OnThemeChanged();
  641. }
  643. if (pBar->IsVisible())
  644. {
  645. pBar->OnRecalcLayout();
  646. }
  647. }
  649. CWnd* pSite = GetSite();
  651. CMDIFrameWnd* pMDIFrame = DYNAMIC_DOWNCAST(CMDIFrameWnd, pSite);
  652. if (pMDIFrame)
  653. {
  654. CXTPTabClientWnd* pClient = DYNAMIC_DOWNCAST(CXTPTabClientWnd, CWnd::FromHandle(pMDIFrame->m_hWndMDIClient));
  655. if (pClient)
  656. pClient->Refresh();
  657. }
  659. for (HWND hWndChild = ::GetTopWindow(pSite->m_hWnd); hWndChild != NULL;
  660. hWndChild = GetWindow(hWndChild, GW_HWNDNEXT))
  661. {
  662. CWnd* pWnd = CWnd::FromHandlePermanent(hWndChild);
  663. if (pWnd != NULL)
  664. pWnd->Invalidate(FALSE);
  665. }
  668. m_bRecalcLayout = FALSE;
  669. RecalcFrameLayout();
  671. pSite->SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
  672. pSite->SendMessage(WM_NCPAINT);
  673. }
  675. BOOL CXTPCommandBar::IsKeyboardCuesVisible() const
  676. {
  677. CXTPCommandBars* pCommandBars = GetCommandBars();
  678. if (!pCommandBars)
  679. return TRUE;
  681. return pCommandBars->m_bKeyboardCuesVisible;
  682. }
  685. CXTPCommandBarKeyboardTip::CXTPCommandBarKeyboardTip(CXTPCommandBars* pCommandBars, CCmdTarget* pOwner, LPCTSTR lpszCaption, CPoint pt, DWORD dwAlign, BOOL bEnabled)
  686. {
  687. m_pOwner = pOwner;
  688. m_strCaption = lpszCaption;
  689. m_pCommandBars = pCommandBars;
  690. m_pt = pt;
  691. m_strTip.Empty();
  692. m_bEnabled = bEnabled;
  693. m_dwAlign = dwAlign;
  694. m_bVisible = TRUE;
  695. m_bExplicit = FALSE;
  696. }
  698. BEGIN_MESSAGE_MAP(CXTPCommandBarKeyboardTip, CWnd)
  699. ON_WM_PAINT()
  700. ON_WM_NCHITTEST_EX()
  701. END_MESSAGE_MAP()
  703. LRESULT CXTPCommandBarKeyboardTip::OnNcHitTest(CPoint /*point*/)
  704. {
  705. return (LRESULT)HTTRANSPARENT;
  706. }
  708. void CXTPCommandBarKeyboardTip::OnPaint()
  709. {
  710. CPaintDC dc(this);
  711. m_pCommandBars->GetPaintManager()->DrawKeyboardTip(&dc, this, FALSE);
  712. }
  714. BOOL CXTPCommandBar::IsKeyboardTipsVisible() const
  715. {
  716. CXTPCommandBars* pCommandBars = GetCommandBars();
  717. if (pCommandBars && pCommandBars->m_keyboardTips.pBar == this && pCommandBars->m_keyboardTips.nLevel > 0)
  718. return pCommandBars->m_keyboardTips.nLevel;
  720. return FALSE;
  721. }
  723. void CXTPCommandBar::CreateKeyboardTips()
  724. {
  725. CXTPCommandBars* pCommandBars = GetCommandBars();
  726. if (!pCommandBars)
  727. return;
  729. for (int i = 0; i < GetControlCount(); i++)
  730. {
  731. CXTPControl* pControl = GetControl(i);
  732. if (!pControl->IsVisible() || pControl->GetCaption().IsEmpty() || (pControl->GetFlags() & xtpFlagSkipFocus))
  733. continue;
  735. if (pControl->GetType() == xtpControlGallery)
  736. continue;
  738. CPoint pt(pControl->GetRect().left + 12, pControl->GetRect().bottom - 11);
  740. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars, pControl, pControl->GetCaption(), pt, DT_TOP, pControl->GetEnabled());
  742. if (!pControl->GetKeyboardTip().IsEmpty())
  743. {
  744. pWnd->m_strTip = pControl->GetKeyboardTip();
  745. }
  747. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  748. }
  750. if (GetParentCommandBar() == 0)
  751. {
  752. for (int j = 0; j < pCommandBars->GetCount(); j++)
  753. {
  754. CXTPToolBar* pToolBar = pCommandBars->GetAt(j);
  755. if (pToolBar == this || !IsToolBarVisible(pToolBar))
  756. continue;
  757. CXTPWindowRect rc(pToolBar);
  759. CPoint pt(rc.left, rc.top);
  760. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars, pToolBar, pToolBar->GetTitle(), pt, DT_TOP | DT_LEFT, TRUE);
  762. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  763. }
  764. }
  765. }
  767. #ifndef LWA_ALPHA
  768. #define LWA_ALPHA               0x00000002
  769. #endif
  770. #ifndef WS_EX_LAYERED
  771. #define WS_EX_LAYERED           0x00080000
  772. #endif
  773. typedef BOOL (WINAPI *PFNSETLAYEREDWINDOWATTRIBUTES) (HWND hwnd, COLORREF crKey, BYTE bAlpha, DWORD dwFlags);
  775. void CXTPCommandBars::ShowKeyboardTips(CXTPCommandBar* pCommandBar, int nLevel)
  776. {
  777. HideKeyboardTips();
  779. if (!m_pOptions->bShowKeyboardTips)
  780. return;
  782. if (!pCommandBar->GetSafeHwnd())
  783. return;
  785. GetToolTipContext()->CancelToolTips();
  787. pCommandBar->UpdateWindow();
  789. m_keyboardTips.pBar = pCommandBar;
  790. m_keyboardTips.nLevel = nLevel;
  791. m_keyboardTips.nKey = 0;
  793. pCommandBar->CreateKeyboardTips();
  795. if (m_keyboardTips.arr.GetSize() == 0)
  796. {
  797. m_keyboardTips.pBar = NULL;
  798. return;
  799. }
  801. CXTPPaintManager* pPaintManager = GetPaintManager();
  802. CClientDC dc(pCommandBar);
  803. CXTPFontDC font(&dc, &pPaintManager->m_fontToolTip);
  805. int i;
  806. for (i = (int)m_keyboardTips.arr.GetSize() - 1; i >= 0; i--)
  807. {
  808. CXTPCommandBarKeyboardTip* pWnd = m_keyboardTips.arr[i];
  810. pWnd->m_bExplicit = !pWnd->m_strTip.IsEmpty();
  812. if (pWnd->m_bExplicit)
  813. continue;
  815. if (pWnd->m_strCaption.IsEmpty())
  816. {
  817. pWnd->DestroyWindow();
  818. delete pWnd;
  819. m_keyboardTips.arr.RemoveAt(i);
  820. continue;
  821. }
  822. pWnd->m_strCaption.MakeUpper();
  824. int nAmdIndex = pWnd->m_strCaption.Find(_T('&'));
  826. if (nAmdIndex != -1 && pWnd->m_strCaption[nAmdIndex + 1] == _T('&'))
  827. nAmdIndex = FIND_S(pWnd->m_strCaption, _T('&'), nAmdIndex + 2);
  829. if (pWnd->m_strPrefix.IsEmpty())
  830. pWnd->m_strTip = pWnd->m_strCaption.GetAt(nAmdIndex + 1); // nAmdIndex can be -1.
  831. else pWnd->m_strTip = pWnd->m_strPrefix;
  832. }
  834. int nCount = (int)m_keyboardTips.arr.GetSize();
  836. for (i = 0; i < nCount; i++)
  837. {
  838. CXTPCommandBarKeyboardTip* pWndBase = m_keyboardTips.arr[i];
  840. CString strTip = pWndBase->m_strTip;
  841. CArray<CXTPCommandBarKeyboardTip*, CXTPCommandBarKeyboardTip*> arr;
  842. arr.Add(pWndBase);
  843. int j;
  844. CString strUsed = _T("& ");
  846. for ( j = i + 1; j < nCount; j++)
  847. {
  848. CXTPCommandBarKeyboardTip* pWnd = m_keyboardTips.arr[j];
  849. if (pWnd->m_strTip[0] == strTip[0])
  850. {
  851. arr.Add(pWnd);
  853. if (pWnd->m_strTip.GetLength() == 2)
  854. {
  855. strUsed += pWnd->m_strTip[1];
  856. }
  857. }
  858. }
  860. if (arr.GetSize() < 2)
  861. continue;
  863. int k = 1;
  865. for (j = 0; j < (int)arr.GetSize(); j++)
  866. {
  867. CXTPCommandBarKeyboardTip* pWnd = arr[j];
  868. if (pWnd->m_strTip.GetLength() > 1)
  869. continue;
  871. TCHAR chAccel = 0;
  872. CString& strCaption = pWnd->m_strCaption;
  873. int n;
  875. for (n = 0; n < strCaption.GetLength() - 1; n++)
  876. {
  877. if ((strCaption[n] == ' ') && (strUsed.Find(strCaption[n + 1]) == -1))
  878. {
  879. chAccel = strCaption[n + 1];
  880. strUsed += chAccel;
  881. break;
  882. }
  883. }
  885. if (chAccel == 0)
  886. {
  887. int nStart = strCaption[0] == _T('&') ? 1 : 0;
  888. if (strCaption[nStart] == pWnd->m_strTip[0])
  889. nStart++;
  891. for (n = nStart; n < strCaption.GetLength(); n++)
  892. {
  893. if (strUsed.Find(strCaption[n]) == -1)
  894. {
  895. chAccel = pWnd->m_strCaption[n];
  896. strUsed += chAccel;
  897. break;
  898. }
  899. }
  900. }
  902. if (chAccel == 0)
  903. {
  904. CString str;
  905. str.Format(_T("%i"), k);
  906. chAccel = str[0];
  907. k++;
  908. }
  910. pWnd->m_strTip += chAccel;
  911. }
  912. }
  914. BOOL bLayoutRTL = IsLayoutRTL();
  916. for (i = 0; i < nCount; i++)
  917. {
  918. CXTPCommandBarKeyboardTip* pWnd = m_keyboardTips.arr[i];
  919. if (!pWnd->m_bVisible)
  920. continue;
  922. CSize sz = dc.GetTextExtent(pWnd->m_strTip);
  923. sz = CSize(max(sz.cx + 6, 16), max(sz.cy + 2, 15));
  925. CPoint pt = pWnd->m_pt;
  926. if (DYNAMIC_DOWNCAST(CWnd, pWnd->m_pOwner) == 0)
  927. pCommandBar->ClientToScreen(&pt);
  929. CRect rc(CPoint(pt.x - (pWnd->m_dwAlign & DT_CENTER ?  sz.cx / 2 : bLayoutRTL || (pWnd->m_dwAlign & DT_RIGHT) ? sz.cx : 0),
  930. pt.y - (pWnd->m_dwAlign & DT_VCENTER ?  sz.cy / 2 : pWnd->m_dwAlign & DT_BOTTOM ? sz.cy : 0)), sz);
  932. BOOL bLayered = pPaintManager->m_pfnSetLayeredWindowAttributes && !pWnd->m_bEnabled;
  934. pWnd->CreateEx((bLayered ? WS_EX_LAYERED : 0) | WS_EX_TOOLWINDOW, AfxRegisterWndClass(CS_SAVEBITS), 0, WS_POPUP, rc, pCommandBar, 0);
  936. pWnd->SetWindowPos(&CWnd::wndTop, rc.left, rc.top, rc.Width(), rc.Height(),  SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  938. pPaintManager->DrawKeyboardTip(0, pWnd, TRUE);
  940. if (bLayered)
  941. {
  942. ((PFNSETLAYEREDWINDOWATTRIBUTES)pPaintManager->m_pfnSetLayeredWindowAttributes)(pWnd->m_hWnd, 0x00, 150, LWA_ALPHA);
  943. }
  944. }
  946. for (i = 0; i < nCount; i++)
  947. {
  948. CXTPCommandBarKeyboardTip* pWnd = m_keyboardTips.arr[i];
  949. if (pWnd->m_bVisible)
  950. pWnd->SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  951. }
  952. }
  954. void CXTPCommandBars::HideKeyboardTips()
  955. {
  956. if (m_keyboardTips.arr.GetSize() == 0)
  957. return;
  959. for (int i = 0; i < (int)m_keyboardTips.arr.GetSize(); i++)
  960. {
  961. m_keyboardTips.arr[i]->DestroyWindow();
  962. delete m_keyboardTips.arr[i];
  963. }
  965. m_keyboardTips.arr.RemoveAll();
  966. m_keyboardTips.pBar = 0;
  967. m_keyboardTips.nLevel = 0;
  968. m_keyboardTips.nKey = 0;
  969. }
  971. void CXTPCommandBars::ShowKeyboardCues(BOOL bShow)
  972. {
  973. if (m_bCustomizeMode)
  974. bShow = TRUE;
  976. if (m_bUseKeyboardCues && m_bKeyboardCuesVisible != bShow)
  977. {
  978. m_bKeyboardCuesVisible = bShow;
  979. InvalidateCommandBars();
  980. }
  981. }
  983. void CXTPCommandBars::OnTrackingModeChanged(CXTPCommandBar* pCommandBar, int bMode)
  984. {
  985. pCommandBar;
  987. CXTPMouseManager* pMouseManager = GetMouseManager();
  989. if (bMode == FALSE && m_bUseKeyboardCues && !pMouseManager->IsTrackedLock(0))
  990. {
  991. ShowKeyboardCues(FALSE);
  992. }
  994. if (m_keyboardTips.nLevel > 0 && m_pOptions->bShowKeyboardTips)
  995. {
  996. HideKeyboardTips();
  998. if (pMouseManager->IsTrackedLock(0))
  999. {
  1000. CXTPCommandBar* pCommandBarTop = pMouseManager->GetTrackArray().GetAt(pMouseManager->GetTrackArray().GetSize() - 1);
  1001. if (pCommandBarTop->m_bKeyboardSelect)
  1002. {
  1003. pCommandBarTop->PostMessage(WM_TIMER, XTP_TID_SHOWKEYBOARDTIPS);
  1004. }
  1005. }
  1006. }
  1008. GetToolTipContext()->CancelToolTips();
  1010. }
  1012. CXTPMouseManager* CXTPCommandBars::GetMouseManager() const
  1013. {
  1014. if (this == NULL)
  1015. return XTPMouseManager();
  1017. if (m_pMouseManager != NULL)
  1018. return m_pMouseManager;
  1020. return m_pMouseManager = XTPMouseManager();
  1021. }
  1023. CXTPKeyboardManager* CXTPCommandBars::GetKeyboardManager() const
  1024. {
  1025. if (this == NULL)
  1026. return XTPKeyboardManager();
  1028. if (m_pKeyboardManager != NULL)
  1029. return m_pKeyboardManager;
  1031. return m_pKeyboardManager = XTPKeyboardManager();
  1032. }
  1035. CXTPControl* CXTPCommandBars::_GetNextControl(CXTPControls*& pControls, int nIndex) const
  1036. {
  1037. int nNextIndex = pControls->GetNext(nIndex, +1);
  1039. if (m_pOptions->keyboardCuesUse & xtpKeyboardCuesUseAll
  1040. && nNextIndex <= nIndex)
  1041. {
  1042. CXTPToolBar* pToolBar = (CXTPToolBar*)pControls->GetParent();
  1043. CXTPToolBar* pStartBar = pToolBar;
  1045. for (;;)
  1046. {
  1047. pToolBar = GetAt(GetNextVisible(FindIndex(pToolBar), +1));
  1048. ASSERT(pToolBar);
  1050. pControls = pToolBar->GetControls();
  1051. nNextIndex = pControls->GetNext(-1, +1);
  1053. if (nNextIndex != -1)
  1054. break;
  1056. if (pToolBar == pStartBar)
  1057. return NULL;
  1058. }
  1059. }
  1061. return pControls->GetAt(nNextIndex);
  1062. }
  1064. CXTPControl* CXTPCommandBars::FindAccel(CXTPCommandBar* pCommandBar, UINT chAccel, BOOL& bSelectOnly) const
  1065. {
  1066. ASSERT(pCommandBar->IsVisible());
  1068. CXTPControls* pControls = pCommandBar->GetControls();
  1070. CXTPControl* pControl = _GetNextControl(pControls, pCommandBar->m_nSelected);
  1071. if (pControl == NULL)
  1072. return NULL;
  1074. bSelectOnly = FALSE;
  1076. CXTPControl* pStart = pControl, *pAmpCondidate = NULL, *pCondidate = NULL;
  1078. do
  1079. {
  1080. ASSERT(pControl);
  1082. CString strCaption = pControl->IsCaptionVisible() ? pControl->GetCaption() : _T("");
  1083. if (!strCaption.IsEmpty() && pControl->GetEnabled() && pControl->GetRibbonGroup() == NULL)
  1084. {
  1085. int nAmpIndex = strCaption.Find(_T('&'));
  1086. BOOL bFound = nAmpIndex > -1 && nAmpIndex < strCaption.GetLength() - 1;
  1088. if (CXTPShortcutManager::CompareAccelKey(strCaption[bFound ? nAmpIndex + 1 : 0], chAccel) &&
  1089. (bFound || ((m_pOptions->keyboardCuesUse & xtpKeyboardCuesUseAmpersandOnly) == 0)))
  1090. {
  1091. if (bFound)
  1092. {
  1093. if (pAmpCondidate == NULL)
  1094. pAmpCondidate = pControl;
  1095. else
  1096. {
  1097. bSelectOnly = TRUE;
  1098. return pAmpCondidate;
  1099. }
  1100. }
  1101. else if (pControl->GetParent()->GetType() == xtpBarTypeMenuBar || pControl->GetParent()->IsTrackingMode())
  1102. {
  1103. if (pCondidate == NULL)
  1104. pCondidate = pControl;
  1105. else
  1106. {
  1107. bSelectOnly = TRUE;
  1108. }
  1109. }
  1110. }
  1111. }
  1113. pControl = _GetNextControl(pControls, pControl->GetIndex());
  1115. ASSERT(pControl != 0);
  1116. if (pControl == NULL)
  1117. break;
  1118. }
  1119. while (pControl != pStart);
  1121. return pAmpCondidate ? pAmpCondidate : pCondidate;
  1122. }
  1124. void CXTPCommandBars::ClosePopups() const
  1125. {
  1126. CXTPMouseManager* pMouseManage = this == NULL ? XTPMouseManager() : GetMouseManager();
  1127. pMouseManage->SendTrackLost();
  1128. }
  1130. BOOL CXTPCommandBars::OnFrameAccel(UINT chAccel)
  1131. {
  1132. if (m_pOptions->keyboardCuesUse == xtpKeyboardCuesUseNone)
  1133. return FALSE;
  1135. if ((chAccel >= VK_NUMPAD0 && chAccel <= VK_NUMPAD9) && !m_pOptions->bUseAltNumPadKeys)
  1136. return FALSE;
  1138. if (MapVirtualKey(chAccel, 2) == 0)
  1139. return FALSE;
  1141. CXTPToolBar* pMenuBar = GetMenuBar();
  1142. CXTPToolBar* pCommandBar = IsToolBarVisible(pMenuBar) ? pMenuBar : NULL;
  1144. for (int i = 0; i < GetCount(); i++)
  1145. {
  1146. CXTPToolBar* pToolBar = GetAt(i);
  1148. if (pToolBar->IsTrackingMode())
  1149. {
  1150. pCommandBar = pToolBar;
  1151. break;
  1152. }
  1154. if (m_pOptions->keyboardCuesUse & xtpKeyboardCuesUseAll && pCommandBar == NULL && IsToolBarVisible(pToolBar))
  1155. pCommandBar = pToolBar;
  1156. }
  1157. if (!pCommandBar)
  1158. return FALSE;
  1160. if (IsToolBarVisible(pCommandBar))
  1161. {
  1162. if (pCommandBar->PreviewAccel(chAccel))
  1163. {
  1164. return TRUE;
  1165. }
  1167. BOOL bSelectOnly;
  1168. CXTPControl* pControl = FindAccel(pCommandBar, chAccel, bSelectOnly);
  1169. if (pControl)
  1170. {
  1171. int nIndex = pControl->GetIndex();
  1172. pCommandBar = (CXTPToolBar*)pControl->GetParent();
  1174. if (!pCommandBar->IsTrackingMode())
  1175. ClosePopups();
  1177. ShowKeyboardCues(TRUE);
  1179. m_keyboardTips.nLevel = 1;
  1181. pCommandBar->SetTrackingMode(TRUE, FALSE, TRUE);
  1182. pCommandBar->SetSelected(nIndex, TRUE);
  1184. if (!bSelectOnly)
  1185. {
  1186. pControl->OnUnderlineActivate();
  1187. }
  1189. return TRUE;
  1190. }
  1191. }
  1192. return FALSE;
  1193. }
  1195. BOOL CXTPCommandBars::PreTranslateFrameMessage(MSG* pMsg)
  1196. {
  1197. if ((pMsg->message == WM_SYSKEYDOWN) && (HIWORD(pMsg->lParam) & KF_ALTDOWN)
  1198. && !GetMouseManager()->IsMouseLocked() && !GetMouseManager()->IsTrackedLock(0)
  1199. && GetMouseManager()->IsTopParentActive(m_pFrame->GetSafeHwnd()))
  1200. {
  1201. if (pMsg->wParam == VK_MENU)
  1202. {
  1203. ShowKeyboardCues(TRUE);
  1204. return FALSE;
  1205. }
  1207. if ((!m_bIgnoreShiftMenuKey || !(::GetKeyState(VK_SHIFT) & 0x8000)))
  1208. {
  1209. UINT chAccel = (UINT)pMsg->wParam;
  1211. if (chAccel)
  1212. {
  1213. if (OnFrameAccel(chAccel))
  1214. return TRUE;
  1215. }
  1216. }
  1217. }
  1219. if ((pMsg->message == WM_SYSKEYUP || pMsg->message == WM_KEYUP) && m_bUseKeyboardCues && m_bKeyboardCuesVisible &&
  1220. !GetMouseManager()->IsTrackedLock(0))
  1221. {
  1222. ShowKeyboardCues(FALSE);
  1223. }
  1226. if ((pMsg->message == WM_CONTEXTMENU || pMsg->message == WM_SYSKEYUP)
  1227. && GetMouseManager()->IsTrackedLock(0))
  1228. {
  1229. XTPKeyboardManager()->ProcessKeyboardHooks(WM_CONTEXTMENU, pMsg->wParam, pMsg->lParam);
  1230. return TRUE;
  1231. }
  1233. if (pMsg->message == WM_MOUSEWHEEL)
  1234. {
  1235. if (XTPKeyboardManager()->IsKeyboardHooked())
  1236. {
  1237. return XTPKeyboardManager()->ProcessKeyboardHooks(WM_MOUSEWHEEL, pMsg->wParam, pMsg->lParam);
  1238. }
  1239. #ifdef _XTP_INCLUDE_RIBBON
  1240. else
  1241. {
  1242. CXTPCommandBar* pMenuBar = GetMenuBar();
  1243. CPoint pt;
  1244. GetCursorPos(&pt);
  1246. if (pMenuBar && pMenuBar->GetType() == xtpBarTypeRibbon && CXTPWindowRect(pMenuBar).PtInRect(pt))
  1247. {
  1248. ((CXTPRibbonBar*)pMenuBar)->SelectNextTab((short)HIWORD(pMsg->wParam) <= 0);
  1249. return TRUE;
  1250. }
  1251. }
  1252. #endif
  1253. }
  1255. if (pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
  1256. {
  1257. if (GetShortcutManager()->TranslateAccelerator(pMsg))
  1258. return TRUE;
  1259. }
  1262. return FALSE;
  1263. }
  1265. void CXTPCommandBars::UpdateCommandBars() const
  1266. {
  1267. for (int i = 0; i < GetCount(); i++)
  1268. {
  1269. CXTPCommandBar* pBar = GetAt(i);
  1270. pBar->OnIdleUpdateCmdUI(TRUE, TRUE);
  1271. }
  1272. }
  1274. BOOL CXTPCommandBars::OnFrameWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1275. {
  1276. if (message == WM_IDLEUPDATECMDUI)
  1277. {
  1278. for (int i = 0; i < GetCount(); i++)
  1279. {
  1280. CXTPCommandBar* pBar = GetAt(i);
  1282. if (pBar->GetPosition() == xtpBarFloating)
  1283. {
  1284. pBar->OnIdleUpdateCmdUI(TRUE, TRUE);
  1285. }
  1286. }
  1287. }
  1288. if (message == WM_SYSCOLORCHANGE)
  1289. {
  1290. XTPColorManager()->RefreshColors();
  1291. GetPaintManager()->RefreshMetrics();
  1292. GetImageManager()->RefreshAll();
  1294. GetSite()->RedrawWindow(FALSE);
  1295. RedrawCommandBars();
  1296. }
  1297. if (message == WM_SETTINGCHANGE)
  1298. {
  1299. GetPaintManager()->RefreshMetrics();
  1301. GetSite()->RedrawWindow(FALSE);
  1302. RedrawCommandBars();
  1303. }
  1304. if (message == WM_CLOSE)
  1305. {
  1306. if (m_pDropSource->m_pSheet != NULL)
  1307. {
  1308. return TRUE;
  1309. }
  1310. }
  1311. if (message == WM_COMMAND)
  1312. {
  1313. CWnd* pWnd = CWnd::GetFocus();
  1314. if (pWnd && pWnd->IsKindOf(RUNTIME_CLASS(CXTPEdit)) && ((CXTPEdit*)pWnd)->OnCommand(wParam, lParam))
  1315. {
  1316. if (pResult != NULL)
  1317. *pResult = 1;
  1318. return TRUE;
  1319. }
  1321. if (LOWORD(wParam) == ID_HELP && GetHelpTrackingId() > 0)
  1322. {
  1323. AFX_CMDHANDLERINFO info;
  1324. info.pTarget = NULL;
  1326. if (GetSite()->OnCmdMsg(ID_HELP, CN_COMMAND, NULL, &info))
  1327. {
  1328. GetSite()->SendMessage(WM_COMMANDHELP, 0, HID_BASE_COMMAND +  GetHelpTrackingId());
  1329. return TRUE;
  1330. }
  1331. }
  1332. }
  1334. switch (message)
  1335. {
  1336. case WM_ACTIVATEAPP:
  1337. if (!wParam)
  1338. ClosePopups();
  1339. return FALSE;
  1341. case WM_SYSCOMMAND:
  1342. if ((wParam == 0 || LOWORD(wParam) != 0) && wParam != SC_KEYMENU && !IsCustomizeMode())
  1343. ClosePopups();
  1344. return FALSE;
  1345. }
  1347. return FALSE;
  1348. }
  1350. void CXTPCommandBars::SetLayoutRTL(CWnd* pWnd, BOOL bRTLLayout)
  1351. {
  1352. DWORD dwRTLStyle = WS_EX_LAYOUTRTL;
  1354. if (pWnd->IsKindOf(RUNTIME_CLASS(CXTPEdit)))
  1355. {
  1356. pWnd->ModifyStyleEx(0, dwRTLStyle);
  1357. return;
  1358. }
  1360. pWnd->ModifyStyleEx(bRTLLayout ? 0 : dwRTLStyle, !bRTLLayout ? 0 : dwRTLStyle);
  1362. // walk through HWNDs to avoid creating temporary CWnd objects
  1363. // unless we need to call this function recursively
  1364. for (CWnd* pChild = pWnd->GetWindow(GW_CHILD); pChild != NULL;
  1365. pChild = pChild->GetWindow(GW_HWNDNEXT))
  1366. {
  1368. // send to child windows after parent
  1369. SetLayoutRTL(pChild, bRTLLayout);
  1370. }
  1371. }
  1374. void CXTPCommandBars::SetLayoutRTL(BOOL bRightToLeft)
  1375. {
  1376. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  1377. return;
  1379. if (m_bRightToLeft == bRightToLeft)
  1380. return;
  1382. m_bRightToLeft = bRightToLeft;
  1384. int i;
  1386. for (i = 0; i < 4; i++)
  1387. {
  1388. if (m_pDocks[i])
  1389. {
  1390. SetLayoutRTL(m_pDocks[i], m_bRightToLeft);
  1391. }
  1392. }
  1394. for (i = 0; i < GetCount(); i++)
  1395. {
  1396. CXTPToolBar* pToolBar = GetAt(i);
  1397. if (pToolBar->GetPosition() == xtpBarFloating)
  1398. {
  1399. SetLayoutRTL(pToolBar, m_bRightToLeft);
  1400. }
  1401. }
  1403. CWnd* pStatusBar = GetSite()->GetDlgItem(AFX_IDW_STATUS_BAR);
  1404. if (pStatusBar)
  1405. {
  1406. SetLayoutRTL(pStatusBar, m_bRightToLeft);
  1407. }
  1409. GetImageManager()->DrawReverted(2);
  1410. RedrawCommandBars();
  1411. }
  1413. BOOL CXTPCommandBars::IsLayoutRTL() const
  1414. {
  1415. if (GetSite()->GetExStyle() & WS_EX_LAYOUTRTL)
  1416. return TRUE;
  1418. return m_bRightToLeft;
  1419. }
  1421. CXTPControl* CXTPCommandBars::FindControl(XTPControlType type, UINT nId, BOOL bVisible, BOOL bRecursive) const
  1422. {
  1424. for (int i = GetCount() - 1; i >= 0; i--)
  1425. {
  1426. CXTPToolBar* pBar = GetAt(i);
  1428. if (!bVisible || pBar->IsVisible())
  1429. {
  1430. CXTPControl* pControl = pBar->GetControls()->FindControl(type, nId, bVisible, bRecursive);
  1431. if (pControl != NULL) return pControl;
  1432. }
  1433. }
  1434. return NULL;
  1435. }
  1437. void CXTPPopupBar::PumpMessage()
  1438. {
  1439. CXTPMouseManager* pMouseManager = XTPMouseManager();
  1441. while (IsTrackingMode())
  1442. {
  1443. MSG msg;
  1444. if (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
  1445. {
  1446. if (pMouseManager->PreviewTackLost(this, &msg))
  1447. {
  1448. SetTrackingMode(FALSE);
  1449. break;
  1450. }
  1452. if (!::GetMessage(&msg, NULL, 0, 0))
  1453. break;
  1455. if (!IsTrackingMode())
  1456. {
  1457. ::PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam);
  1458. break;
  1459. }
  1461. if (msg.message != WM_KICKIDLE && !AfxGetThread()->PreTranslateMessage(&msg))
  1462. {
  1463. // process this message
  1464. ::TranslateMessage(&msg);
  1465. ::DispatchMessage(&msg);
  1466. }
  1467. }
  1468. else
  1469. {
  1470. WaitMessage();
  1471. }
  1472. }
  1473. }
  1475. BOOL CXTPCommandBars::TrackPopupMenu(UINT nBarID, UINT nFlags, int x, int y, LPCRECT rcExclude)
  1476. {
  1477. CXTPPopupBar* pPopup = (CXTPPopupBar*)m_pContextMenus->FindCommandBar(nBarID);
  1478. if (!pPopup)
  1479. return FALSE;
  1481. return TrackPopupMenu(pPopup, nFlags, x, y, GetSite(), rcExclude);
  1483. }
  1485. BOOL CXTPCommandBars::TrackPopupMenu(CXTPPopupBar* pPopup, UINT nFlags, int x, int y, CWnd* pWnd, LPCRECT rcExclude, CWnd* pWndOwner)
  1486. {
  1487. ASSERT(pPopup);
  1488. if (!pPopup)
  1489. {
  1490. return FALSE;
  1491. }
  1493. const MSG& msg = AfxGetThreadState()->m_lastSentMsg;
  1494. if (msg.message == WM_CONTEXTMENU && msg.lParam == MAKELPARAM(-1, -1) && pPopup->GetCommandBars())
  1495. pPopup->GetCommandBars()->ShowKeyboardCues(TRUE);
  1497. if (!pWnd)
  1498. pWnd = pPopup->GetSite();
  1500. pPopup->m_pSite = pWnd ;
  1501. pPopup->m_pOwner = pWndOwner;
  1503. if (pWnd && pWnd->GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_RIGHT))
  1504. nFlags |= TPM_RIGHTALIGN;
  1506. UINT nReturn = TRUE;
  1507. pPopup->m_pReturnCmd = NULL;
  1509. if (nFlags & TPM_RETURNCMD)
  1510. {
  1511. pPopup->m_pReturnCmd = &nReturn;
  1512. nReturn = 0;
  1513. }
  1514. pPopup->m_bExecOnRButton = nFlags & TPM_RIGHTBUTTON;
  1515. pPopup->m_bIgnoreUpdateHandler = nFlags & TPM_NONOTIFY;
  1516. pPopup->m_popupFlags = (nFlags & TPM_RIGHTALIGN) ? xtpPopupLeft | xtpPopupDown : xtpPopupDown;
  1518. BOOL bRecurse = nFlags & TPM_RECURSE;
  1519. pPopup->m_bRecursePopup = bRecurse;
  1521. CXTPMouseManager* pMouseManager = XTPMouseManager();
  1524. if (!bRecurse)
  1525. {
  1526. pMouseManager->SendTrackLost();
  1527. ReleaseCapture();
  1528. }
  1529. else
  1530. {
  1531. pMouseManager->SendTrackLostRecurse();
  1532. pMouseManager->LockTrackRecurse(TRUE);
  1533. }
  1534. pMouseManager->IgnoreLButtonUp();
  1536. if (!pPopup->Popup(x, y, rcExclude))
  1537. {
  1538. return FALSE;
  1539. }
  1541. pPopup->PumpMessage();
  1543. if (bRecurse)
  1544. {
  1545. pMouseManager->LockTrackRecurse(FALSE);
  1546. }
  1548. return nReturn;
  1549. }
  1551. BOOL CXTPCommandBars::TrackPopupMenuEx(CMenu* pMenu, UINT nFlags, int x, int y, CWnd* pWndOwner, LPTPMPARAMS lptpm)
  1552. {
  1553. CXTPPopupBar* pPopup = CXTPPopupBar::CreatePopupBar(this);
  1555. pPopup->m_pSite = GetSite();
  1556. pPopup->m_pCommandBars = this;
  1558. CRect rcExclude;
  1559. rcExclude.SetRectEmpty();
  1560. if (lptpm) rcExclude = lptpm->rcExclude;
  1562. if (!pPopup->LoadMenu(pMenu))
  1563. {
  1564. pPopup->InternalRelease();
  1565. return FALSE;
  1566. }
  1568. BOOL bResult = TrackPopupMenu(pPopup, nFlags, x, y, GetSite(), rcExclude, pWndOwner);
  1570. pPopup->InternalRelease();
  1572. return bResult;
  1573. }
  1575. BOOL CXTPCommandBars::TrackPopupMenu(CMenu* pMenu, UINT nFlags, int x, int y, CWnd* pWnd, LPCRECT rcExclude, CWnd* pWndOwner, CXTPCommandBars* pCommandBars)
  1576. {
  1577. CXTPPopupBar* pPopup = CXTPPopupBar::CreatePopupBar(pCommandBars);
  1579. pPopup->m_pSite = pWnd;
  1580. pPopup->m_pOwner = pWndOwner;
  1581. pPopup->m_pCommandBars = pCommandBars;
  1584. if (!pPopup->LoadMenu(pMenu))
  1585. {
  1586. pPopup->InternalRelease();
  1587. return FALSE;
  1588. }
  1590. if (pCommandBars)
  1591. {
  1592. const MSG& msg = AfxGetThreadState()->m_lastSentMsg;
  1593. if (msg.message == WM_CONTEXTMENU && msg.lParam == MAKELPARAM(-1, -1))
  1594. pCommandBars->ShowKeyboardCues(TRUE);
  1595. }
  1597. BOOL bResult = TrackPopupMenu(pPopup, nFlags, x, y, pWnd, rcExclude, pWndOwner);
  1599. pPopup->InternalRelease();
  1601. return bResult;
  1602. }
  1607. CXTPPopupBar* CXTPCommandBars::GetToolbarsPopup()
  1608. {
  1609. CXTPPopupBar* pPopup = CXTPPopupBar::CreatePopupBar(this);
  1611. CXTPControlToolbars::CreateToolbarMenu(pPopup, 0, ID_VIEW_TOOLBAR, TRUE);
  1613. return pPopup;
  1614. }
  1616. void CXTPCommandBars::ContextMenu(CXTPToolBar* pToolBar, CPoint point)
  1617. {
  1618. if (IsCustomizeMode())
  1619. return;
  1621. CXTPPopupBar* pPopup = GetToolbarsPopup();
  1623. GetSite()->SendMessage(WM_XTP_TOOLBARCONTEXTMENU, (WPARAM)pToolBar, (LPARAM)pPopup);
  1625. if (pPopup && pPopup->GetControlCount() > 0)
  1626. {
  1627. pPopup->m_popupFlags = IsLayoutRTL() ? xtpPopupLeft : xtpPopupRight;
  1628. ClosePopups();
  1630. pPopup->Popup(point.x, point.y, NULL);
  1632. pPopup->PumpMessage();
  1633. }
  1635. CMDTARGET_RELEASE(pPopup);
  1636. }
  1638. CXTPToolBar* CXTPCommandBars::GetAt(int nIndex) const
  1639. {
  1640. if (nIndex >= 0 && nIndex < GetCount())
  1641. return m_arrBars.GetAt(nIndex);
  1643. return 0;
  1644. }
  1646. void CXTPCommandBars::ToggleVisible(int nIndex)
  1647. {
  1648. ASSERT(nIndex >= 0 && nIndex < GetCount());
  1650. CXTPToolBar* pBar = GetAt(nIndex);
  1651. if (pBar)
  1652. {
  1653. pBar->SetVisible(!pBar->IsVisible());
  1654. }
  1656. m_pOptions->bDirtyState = TRUE;
  1657. }
  1659. CXTPToolBar* CXTPCommandBars::GetToolBar(UINT nID) const
  1660. {
  1661. if (nID == 0)
  1662. return NULL;
  1664. for (int i = 0; i < GetCount(); i++)
  1665. {
  1666. CXTPToolBar* pBar = GetAt(i);
  1668. ASSERT(pBar != NULL);
  1669. if (pBar && (pBar->m_nBarID == nID))
  1670. return pBar;
  1671. }
  1672. return NULL;
  1673. }
  1675. void CXTPToolBar::_GetHiddenControls(CXTPCommandBar* pExpandBar)
  1676. {
  1677. for (int j = 0; j < GetControlCount(); j++)
  1678. {
  1679. CXTPControl* pControl = GetControl(j);
  1681. if (pControl->GetHideFlags() == xtpHideWrap)
  1682. {
  1683. CXTPControl* pControlClone = pExpandBar->GetControls()->AddClone(pControl);
  1684. pControlClone->SetHideFlags(0);
  1685. pControlClone->SetBeginGroup(FALSE);
  1686. }
  1687. }
  1688. }
  1690. void CXTPCommandBars::GetHiddenControls(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar)
  1691. {
  1692. if (pToolBar->m_pDockBar == 0) return;
  1694. CXTPDockBar* pDock = pToolBar->m_pDockBar;
  1695. int nPos = pDock->FindBar(pToolBar);
  1696. if (nPos == -1) return;
  1698. CXTPDockBar::CToolBarArray arrBars;
  1699. pDock->GetVisibleToolbars(nPos, arrBars);
  1700. for (int i = 0; i < arrBars.GetSize(); i++)
  1701. {
  1702. CXTPToolBar* pToolBarRow = arrBars[i];
  1703. pToolBarRow->_GetHiddenControls(pExpandBar);
  1704. }
  1705. }
  1707. void CXTPCommandBars::_GetAddOrRemovePopup(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar)
  1708. {
  1709. CXTPControlPopup* pButton = (CXTPControlPopup*)pExpandBar->GetControls()->Add(xtpControlPopup, 0);
  1710. pButton->SetFlags(xtpFlagManualUpdate);
  1711. pButton->SetCaption(CXTPControlWindowList::ConstructCaption(pToolBar->GetTitle(), 0));
  1713. BOOL bEnabled = m_bCustomizeAvail && pToolBar->m_bBuiltIn && pToolBar->m_bCustomizable;
  1715. pButton->SetEnabled(bEnabled);
  1716. if (bEnabled)
  1717. {
  1718. pToolBar->BuildCustomizePopup(pButton->GetCommandBar());
  1719. ASSERT_KINDOF(CXTPPopupBar, pButton->GetCommandBar());
  1720. ((CXTPPopupBar*)pButton->GetCommandBar())->SetDoubleGripper();
  1721. }
  1722. }
  1724. void CXTPCommandBars::GetAddOrRemovePopup(CXTPToolBar* pToolBar, CXTPCommandBar* pExpandBar)
  1725. {
  1726. if (pToolBar->m_pDockBar == 0)
  1727. {
  1728. _GetAddOrRemovePopup(pToolBar, pExpandBar);
  1729. }
  1730. else
  1731. {
  1732. CXTPDockBar* pDock = pToolBar->m_pDockBar;
  1733. int nPos = pDock->FindBar(pToolBar);
  1734. if (nPos == -1)
  1735. {
  1736. _GetAddOrRemovePopup(pToolBar, pExpandBar);
  1737. }
  1738. else
  1739. {
  1740. CXTPDockBar::CToolBarArray arrBars;
  1741. pDock->GetVisibleToolbars(nPos, arrBars);
  1742. for (int i = 0; i < arrBars.GetSize(); i++)
  1743. {
  1744. _GetAddOrRemovePopup(arrBars[i], pExpandBar);
  1745. }
  1746. }
  1747. }
  1749. if (m_bCustomizeAvail)
  1750. {
  1751. CXTPControl* pControlCustomize = pExpandBar->GetControls()->Add(xtpControlButton, XTP_ID_CUSTOMIZE);
  1752. pControlCustomize->SetBeginGroup(TRUE);
  1753. }
  1754. }
  1757. void CXTPCommandBars::SetQuickCustomizeMode(BOOL bMode)
  1758. {
  1759. m_pOptions->bDirtyState = TRUE;
  1760. m_bCustomizeMode = m_bQuickCustomizeMode = bMode;
  1761. SetDragControl(NULL);
  1763. ShowKeyboardCues(m_bCustomizeMode);
  1764. }
  1766. void CXTPCommandBars::SetCustomizeMode(BOOL bMode)
  1767. {
  1768. m_pOptions->bDirtyState = TRUE;
  1769. m_bCustomizeMode = bMode;
  1770. SetDragControl(NULL);
  1772. for (int i = 0; i < GetCount(); i++)
  1773. {
  1774. CXTPToolBar* pBar = GetAt(i);
  1776. pBar->DelayRedraw();
  1777. pBar->OnIdleUpdateCmdUI(TRUE, TRUE);
  1778. }
  1779. RecalcFrameLayout();
  1781. ShowKeyboardCues(m_bCustomizeMode);
  1782. }
  1784. void CXTPCommandBars::SetDragControl(CXTPControl* pControl)
  1785. {
  1786. if (m_pDragSelected != pControl)
  1787. {
  1789. CXTPControl* pDragSelected = m_pDragSelected;
  1790. m_pDragSelected = pControl;
  1792. if (pDragSelected != NULL)
  1793. {
  1794. pDragSelected->RedrawParent();
  1795. pDragSelected->InternalRelease();
  1796. }
  1798. if (m_pDragSelected)
  1799. {
  1800. m_pDragSelected->RedrawParent(FALSE);
  1801. m_pDragSelected->InternalAddRef();
  1802. }
  1804. CWnd* pWnd = m_pDropSource->m_pSheet ? (CWnd*)m_pDropSource->m_pSheet : m_pFrame;
  1805. if (pWnd && pWnd->GetSafeHwnd())
  1806. {
  1807. pWnd->SendMessage(WM_XTP_DRAGCONTROLCHANGED);
  1808. }
  1809. }
  1810. }
  1812. void CXTPCommandBars::RemoveAll()
  1813. {
  1814. m_bRecalcLayout = TRUE;
  1816. for (int i = 0; i < GetCount(); i++)
  1817. {
  1818. CXTPToolBar* pToolBar = GetAt(i);
  1820. if (pToolBar->GetSafeHwnd())
  1821. {
  1822. pToolBar->ShowWindow(SW_HIDE);
  1823. pToolBar->m_bVisible = FALSE;
  1824. }
  1826. if (pToolBar->m_pDockBar != NULL)
  1827. {
  1828. pToolBar->m_pDockBar->RemoveCommandBar(pToolBar);
  1829. pToolBar->m_pDockBar = NULL;
  1830. }
  1832. OnToolBarRemoved(pToolBar);
  1833. pToolBar->OnRemoved();
  1835. pToolBar->InternalRelease();
  1836. }
  1837. m_arrBars.RemoveAll();
  1839. m_bRecalcLayout = FALSE;
  1840. RecalcFrameLayout(TRUE);
  1842. }
  1844. void CXTPCommandBars::Remove(CXTPToolBar* pToolBar)
  1845. {
  1846. ASSERT(pToolBar);
  1847. if (!pToolBar)
  1848. return;
  1850. int i = FindIndex(pToolBar);
  1851. if (i == -1)
  1852. return;
  1854. if (pToolBar->GetSafeHwnd())
  1855. {
  1856. pToolBar->ShowWindow(SW_HIDE);
  1857. }
  1858. pToolBar->m_bVisible = FALSE;
  1860. if (pToolBar->m_pDockBar != NULL)
  1861. {
  1862. pToolBar->m_pDockBar->RemoveCommandBar(pToolBar);
  1863. pToolBar->m_pDockBar = NULL;
  1864. RecalcFrameLayout();
  1865. }
  1867. OnToolBarRemoved(pToolBar);
  1868. pToolBar->OnRemoved();
  1870. m_arrBars.RemoveAt(i);
  1871. pToolBar->InternalRelease();
  1872. }
  1874. void CXTPCommandBars::SetSite(CWnd* pFrame)
  1875. {
  1876. m_pFrame = pFrame;
  1878. if (pFrame->GetSafeHwnd())
  1879. {
  1880. AFX_CMDHANDLERINFO info;
  1881. info.pTarget = NULL;
  1883. m_bCustomizeAvail = pFrame->CWnd::OnCmdMsg(XTP_ID_CUSTOMIZE, CN_COMMAND, this, &info);
  1884. }
  1886. m_bRightToLeft = m_pFrame->GetExStyle() & WS_EX_LAYOUTRTL;
  1887. }
  1891. void CXTPCommandBars::HideCommands(const UINT* pCommands, int nCount)
  1892. {
  1893. ASSERT(pCommands);
  1894. if (!pCommands)
  1895. return;
  1897. for (int i = 0; i < nCount; i++)
  1898. HideCommand(pCommands[i]);
  1899. }
  1901. void CXTPCommandBars::HideCommand(UINT nCommand)
  1902. {
  1903. m_pOptions->m_mapHiddenCommands.SetAt(nCommand, TRUE);
  1904. }
  1907. BOOL CXTPCommandBars::IsControlHidden(CXTPControl* pControl)
  1908. {
  1909. BOOL bCommandHidden = IsCommandHidden(pControl->GetID());
  1911. if (m_pOptions->bAutoHideUnusedPopups && !bCommandHidden && IsPopupControlType(pControl->GetType()))
  1912. {
  1913. CXTPCommandBar* pCommandBar = pControl->GetCommandBar();
  1914. if (!pCommandBar)
  1915. return FALSE;
  1917. int nCount = pCommandBar->GetControlCount();
  1919. if (nCount == 0)
  1920. return FALSE;
  1922. for (int i = 0; i < nCount; i++)
  1923. {
  1924. if (!IsControlHidden(pCommandBar->GetControl(i)))
  1925. return FALSE;
  1926. }
  1928. return TRUE;
  1930. }
  1931. return bCommandHidden;
  1932. }
  1934. BOOL CXTPCommandBars::IsCommandHidden(UINT nCommand)
  1935. {
  1936. BOOL bCommand;
  1938. if (!m_pOptions->m_mapHiddenCommands.Lookup(nCommand, bCommand))
  1939. return FALSE;
  1941. if (m_pOptions->m_mapUsedCommands.Lookup(nCommand, bCommand))
  1942. return FALSE;
  1944. return TRUE;
  1945. }
  1947. void CXTPCommandBars::SetCommandUsed(UINT nCommand)
  1948. {
  1949. if (IsCommandHidden(nCommand))
  1950. {
  1951. m_pOptions->m_mapUsedCommands.SetAt(nCommand, TRUE);
  1952. m_pOptions->bDirtyState = TRUE;
  1953. }
  1954. }
  1955. void CXTPCommandBars::ResetUsageData()
  1956. {
  1957. m_pOptions->m_mapUsedCommands.RemoveAll();
  1958. m_pOptions->bDirtyState = TRUE;
  1959. }
  1962. const TCHAR _xtpCommandBarOptionsSection[] = _T("%s-Options");
  1964. void PX_UintMap(CXTPPropExchange* pPX, LPCTSTR pszPropName, CMap<UINT, UINT, BOOL, BOOL>& mapValue)
  1965. {
  1966. if (pPX->IsAllowBlobValues())
  1967. {
  1968. PX_Serialize(pPX, pszPropName, &mapValue);
  1969. return;
  1970. }
  1972. CXTPPropExchangeSection secMap(pPX->GetSection(pszPropName));
  1974. UINT nID;
  1975. if (pPX->IsStoring())
  1976. {
  1977. secMap->WriteCount((DWORD)mapValue.GetCount());
  1978. BOOL bValue;
  1979. int i = 0;
  1980. POSITION pos = mapValue.GetStartPosition();
  1981. while (pos)
  1982. {
  1983. CString strSection;
  1984. strSection.Format(_T("Item%i"), i++);
  1986. mapValue.GetNextAssoc(pos, nID, bValue);
  1988. PX_Long(&secMap, strSection, (long&)nID, 0);
  1989. }
  1990. }
  1991. else
  1992. {
  1993. mapValue.RemoveAll();
  1995. int nCount = secMap->ReadCount();
  1996. for (int i = 0; i < nCount; i++)
  1997. {
  1998. CString strSection;
  1999. strSection.Format(_T("Item%i"), i);
  2000. PX_Long(&secMap, strSection, (long&)nID, 0);
  2002. mapValue.SetAt(nID, TRUE);
  2003. }
  2004. }
  2005. }
  2007. void CXTPCommandBarsOptions::DoPropExchange(CXTPPropExchange* pPX, BOOL bUserOptionsOnly)
  2008. {
  2009. pPX->UseDefaultOnLoad(FALSE);
  2010. pPX->UseDefaultOnSave(FALSE);
  2012. XTP_COMMANDBARS_ICONSINFO* pInfo = m_pCommandBars->GetPaintManager()->GetIconsInfo();
  2013. DWORD dwSchema = _XTP_SCHEMA_CURRENT;
  2015. PX_DWord(pPX, _T("Schema"), dwSchema, _XTP_SCHEMA_CURRENT);
  2016. PX_Bool(pPX, _T("AlwaysShowFullMenus"), bAlwaysShowFullMenus, TRUE);
  2017. PX_Bool(pPX, _T("ShowFullAfterDelay"), bShowFullAfterDelay, TRUE);
  2018. PX_Bool(pPX, _T("ToolBarScreenTips"), bToolBarScreenTips, TRUE);
  2019. PX_Bool(pPX, _T("ToolBarAccelTips"), bToolBarAccelTips, FALSE);
  2020. PX_Bool(pPX, _T("LargeIcons"), bLargeIcons, FALSE);
  2022. if ((dwSchema > _XTP_SCHEMA_875) && !(pPX->IsStoring() && pPX->IsAllowDefaultValues() && m_mapUsedCommands.IsEmpty()))
  2023. PX_UintMap(pPX, _T("UsedCommands"), m_mapUsedCommands);
  2025. if ((dwSchema > _XTP_SCHEMA_875) || bUserOptionsOnly)
  2026. PX_Enum(pPX, _T("Animation"), animationType, xtpAnimateWindowsDefault);
  2029. if (!bUserOptionsOnly)
  2030. {
  2031. PX_Bool(pPX, _T("SyncFloatingBars"), bSyncFloatingBars, TRUE);
  2032. PX_Bool(pPX, _T("ShowExpandButtonAlways"), bShowExpandButtonAlways, TRUE);
  2033. PX_Size(pPX, _T("IconsSize"), szIcons, CSize(0, 0));
  2034. PX_Size(pPX, _T("LargeIconsSize"), szLargeIcons, CSize(0, 0));
  2036. if (!(pPX->IsStoring() && pPX->IsAllowDefaultValues() && m_mapHiddenCommands.IsEmpty()))
  2037. PX_UintMap(pPX, _T("HiddenCommands"), m_mapHiddenCommands);
  2039. PX_Bool(pPX, _T("IconsWithShadow"), pInfo->bIconsWithShadow, FALSE);
  2040. PX_Bool(pPX, _T("UseDisabledIcons"), pInfo->bUseDisabledIcons, TRUE);
  2041. PX_Bool(pPX, _T("UseFadedIcons"), pInfo->bUseFadedIcons, TRUE);
  2043. if (dwSchema > _XTP_SCHEMA_875)
  2044. {
  2045. PX_Bool(pPX, _T("SyncFloatingBars"), bSyncFloatingBars, TRUE);
  2046. PX_Bool(pPX, _T("ShowExpandButtonAlways"), bShowExpandButtonAlways, TRUE);
  2047. PX_Bool(pPX, _T("DblClickFloat"), bDblClickFloat, FALSE);
  2048. PX_Bool(pPX, _T("ShowTextBelowIcons"), bShowTextBelowIcons, FALSE);
  2049. PX_Bool(pPX, _T("AltDragCustomization"), bAltDragCustomization, TRUE);
  2050. PX_Bool(pPX, _T("AutoHideUnusedPopups"), bAutoHideUnusedPopups, TRUE);
  2051. PX_Size(pPX, _T("PopupIconsSize"), szPopupIcons, CSize(0, 0));
  2052. }
  2054. if (dwSchema > _XTP_SCHEMA_95)
  2055. {
  2056. PX_DWord(pPX, _T("KeyboardCuesUse"), keyboardCuesUse, xtpKeyboardCuesUseAll);
  2057. PX_Enum(pPX, _T("KeyboardCuesShow"), keyboardCuesShow, xtpKeyboardCuesShowAlways);
  2059. if (pPX->IsLoading()) ShowKeyboardCues(keyboardCuesShow);
  2060. }
  2061. }
  2063. }
  2064. void CXTPCommandBarsOptions::Serialize(CArchive& ar)
  2065. {
  2066. CXTPPropExchangeArchive px(ar);
  2067. DoPropExchange(&px);
  2068. }
  2071. void CXTPCommandBars::SaveOptions(LPCTSTR lpszProfileName)
  2072. {
  2073. TCHAR szSection[256];
  2074. wsprintf(szSection, _xtpCommandBarOptionsSection, lpszProfileName);
  2076. CXTPPropExchangeSection px(FALSE, szSection);
  2077. px->EmptySection();
  2078. m_pOptions->DoPropExchange(&px, TRUE);
  2079. }
  2082. void CXTPCommandBars::LoadOptions(LPCTSTR lpszProfileName)
  2083. {
  2084. TCHAR szSection[256];
  2085. wsprintf(szSection, _xtpCommandBarOptionsSection, lpszProfileName);
  2087. CXTPPropExchangeSection px(TRUE, szSection);
  2088. m_pOptions->DoPropExchange(&px, TRUE);
  2090. }
  2092. void CXTPCommandBars::SetTheme(XTPPaintTheme paintTheme)
  2093. {
  2094. SetPaintManager(CXTPPaintManager::CreateTheme(paintTheme));
  2095. }
  2098. void CXTPCommandBars::SetPaintManager(CXTPPaintManager* pPaintManager)
  2099. {
  2100. if (m_pPaintManager)
  2101. m_pPaintManager->InternalRelease();
  2103. m_pPaintManager = pPaintManager;
  2105. if (m_pPaintManager)
  2106. {
  2107. m_pPaintManager->RefreshMetrics();
  2108. }
  2110. for (int i = 0; i < GetCount(); i++)
  2111. {
  2112. GetAt(i)->OnPaintManagerChanged();
  2113. }
  2115. GetImageManager()->RefreshAll();
  2116. RedrawCommandBars();
  2117. }
  2119. void CXTPCommandBars::SetImageManager(CXTPImageManager* pImageManager)
  2120. {
  2121. ASSERT(m_pImageManager == NULL);
  2122. m_pImageManager = pImageManager;
  2124. GetImageManager()->RefreshAll();
  2125. }
  2127. CXTPPaintManager* CXTPCommandBars::GetPaintManager() const
  2128. {
  2129. if (m_pPaintManager)
  2130. return m_pPaintManager;
  2131. return XTPPaintManager();
  2133. }
  2134. CXTPImageManager* CXTPCommandBars::GetImageManager() const
  2135. {
  2136. if (m_pImageManager)
  2137. return m_pImageManager;
  2138. return XTPImageManager();
  2139. }
  2141. void CXTPCommandBars::LoadDesignerBars(CArchive& ar)
  2142. {
  2143. CXTPPropExchangeArchive px(ar);
  2144. LoadDesignerBars(&px);
  2145. }
  2147. void CXTPCommandBars::LoadDesignerBars(CXTPPropExchange* pPX)
  2148. {
  2149. try
  2150. {
  2151. //////////////////////////////////////////////////////////////////////////
  2152. // Load Docking Position and Controls
  2153. XTP_COMMANDBARS_PROPEXCHANGE_PARAM param;
  2154. param.bSerializeControls = TRUE;
  2155. param.bSerializeDesignerControls = TRUE;
  2156. param.bSerializeImages = TRUE;
  2157. param.bSerializeOptions = TRUE;
  2158. param.bSerializeActions = TRUE;
  2160. DoPropExchange(pPX, &param);
  2162. }
  2163. catch (CMemoryException* pEx)
  2164. {
  2165. pEx->Delete ();
  2166. }
  2167. catch (CArchiveException* pEx)
  2168. {
  2169. pEx->Delete ();
  2170. }
  2171. }
  2174. CDocTemplate* CXTPCommandBars::FindDocTemplate(CMDIChildWnd* pChild)
  2175. {
  2176. USES_PROTECTED_ACCESS(CXTPCommandBars, CMDIChildWnd, HMENU, m_hMenuShared)
  2178. CMultiDocTemplate* pTemplate = DYNAMIC_DOWNCAST(CMultiDocTemplate, pChild->GetActiveDocument()->GetDocTemplate());
  2179. if (!pTemplate)
  2180. return NULL;
  2182. HMENU hMenuShared = PROTECTED_ACCESS(CMDIChildWnd, pChild, m_hMenuShared);
  2184. if ((hMenuShared == 0) || (pTemplate->m_hMenuShared == hMenuShared))
  2185. return pTemplate;
  2187. POSITION pos = AfxGetApp()->GetFirstDocTemplatePosition();
  2189. while (pos)
  2190. {
  2191. pTemplate = DYNAMIC_DOWNCAST(CMultiDocTemplate, AfxGetApp()->GetNextDocTemplate(pos));
  2193. if (pTemplate && pTemplate->m_hMenuShared == hMenuShared)
  2194. return pTemplate;
  2195. }
  2198. return NULL;
  2199. }
  2202. UINT CXTPCommandBars::GetActiveDocTemplate()
  2203. {
  2204. #pragma warning(disable:4510)
  2205. #pragma warning(disable:4610)
  2207. USES_PROTECTED_ACCESS(CXTPCommandBars, CDocTemplate, UINT, m_nIDResource)
  2208. USES_PROTECTED_ACCESS(CXTPCommandBars, CFrameWnd, UINT, m_nIDHelp)
  2210. CMDIFrameWnd* pFrame = DYNAMIC_DOWNCAST(CMDIFrameWnd, GetSite());
  2212. if (!pFrame)
  2213. return 0;
  2215. UINT nIDResource = (WORD)m_nDefaultMenuID;
  2217. CMDIChildWnd* pChild = pFrame->MDIGetActive();
  2218. if (pChild)
  2219. {
  2220. if (pChild->GetActiveDocument())
  2221. {
  2222. CDocTemplate* pDocTemplate = FindDocTemplate(pChild);
  2223. if (!pDocTemplate)
  2224. return 0;
  2225. nIDResource = PROTECTED_ACCESS(CDocTemplate, pDocTemplate, m_nIDResource);
  2226. }
  2227. else
  2228. {
  2229. nIDResource = PROTECTED_ACCESS(CFrameWnd, pChild, m_nIDHelp);
  2230. }
  2231. }
  2233. return nIDResource;
  2234. }
  2237. void CXTPCommandBars::OnSetPreviewMode (BOOL bPreview)
  2238. {
  2239. GetShortcutManager()->DisableShortcuts(bPreview);
  2241. int nCount = GetCount();
  2242. for (int i = 0; i < nCount; i++)
  2243. {
  2244. CXTPToolBar* pBar = GetAt(i);
  2245. pBar->OnSetPreviewMode(bPreview);
  2246. }
  2247. }
  2249. CXTPToolTipContext* CXTPCommandBars::GetToolTipContext() const
  2250. {
  2251. return m_pToolTipContext;
  2252. }
  2255. int CXTPCommandBars::FindIndex(CXTPToolBar* pToolBar) const
  2256. {
  2257. int nCount = GetCount();
  2258. for (int i = 0; i < nCount; i++)
  2259. {
  2260. CXTPToolBar* pBar = GetAt(i);
  2261. if (pBar == pToolBar)
  2262. return i;
  2263. }
  2264. return -1;
  2265. }
  2267. int CXTPCommandBars::GetNextVisible(long nIndex, int nDirection) const
  2268. {
  2269. ASSERT(nDirection == +1 || nDirection == -1);
  2270. if (GetCount() == 0) return -1;
  2272. long nNext = nIndex + nDirection;
  2274. if (nDirection == -1 && nIndex == -1)
  2275. {
  2276. nNext = GetCount() - 1;
  2277. }
  2279. BOOL bCircle = FALSE;
  2281. while (nNext != nIndex)
  2282. {
  2283. if (nNext >= GetCount())
  2284. {
  2285. if ((nIndex == -1 && nDirection == +1) || bCircle) return -1;
  2286. nNext = 0;
  2287. bCircle = TRUE;
  2288. }
  2289. if (nNext < 0)
  2290. {
  2291. if ((nIndex == -1 && nDirection == -1) || bCircle) return -1;
  2292. nNext = GetCount() - 1;
  2293. bCircle = TRUE;
  2294. }
  2296. if (GetAt(nNext)->IsWindowVisible())
  2297. return nNext;
  2299. nNext += nDirection;
  2300. }
  2301. return nNext;
  2302. }
  2304. BOOL CXTPCommandBars::SetToolBarFocus(CXTPToolBar* pCommandBar, BOOL bNext /*= FALSE*/)
  2305. {
  2306. if (!pCommandBar)
  2307. return FALSE;
  2309. if (bNext)
  2310. {
  2311. if (GetCount() < 2)
  2312. return FALSE;
  2314. int nIndex = FindIndex(pCommandBar);
  2315. int nNextIndex = GetNextVisible(nIndex, bNext);
  2316. if (nIndex == nNextIndex || nNextIndex == -1)
  2317. return FALSE;
  2319. pCommandBar = GetAt(nNextIndex);
  2320. }
  2321. ClosePopups();
  2323. ShowKeyboardCues(TRUE);
  2324. m_keyboardTips.nLevel = 1;
  2326. pCommandBar->SetTrackingMode(TRUE, FALSE, TRUE);
  2327. pCommandBar->SetSelected(pCommandBar->GetControls()->GetNext(-1, +1, TRUE, pCommandBar->GetType() == xtpBarTypeMenuBar), TRUE_KEYBOARD_NEXT);
  2329. return TRUE;
  2330. }