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

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

对话框与窗口

开发平台：

Visual C++

XTPRibbonBar.cpp：源码内容
  1. // XTPRibbonBar.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME RIBBON 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/XTPImageManager.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPPropExchange.h"
  27. #include "Common/XTPToolTipContext.h"
  29. #include "CommandBars/resource.h"
  30. #include "CommandBars/XTPShortcutManager.h"
  31. #include "CommandBars/XTPCommandBars.h"
  32. #include "CommandBars/XTPPopupBar.h"
  33. #include "CommandBars/XTPControlExt.h"
  34. #include "CommandBars/XTPMouseManager.h"
  35. #include "CommandBars/XTPControlPopup.h"
  36. #include "CommandBars/XTPControlButton.h"
  37. #include "CommandBars/XTPOffice2007FrameHook.h"
  38. #include "CommandBars/XTPCustomizeTools.h"
  40. #include "XTPRibbonTab.h"
  41. #include "XTPRibbonTheme.h"
  42. #include "XTPRibbonQuickAccessControls.h"
  43. #include "XTPRibbonGroups.h"
  44. #include "XTPRibbonGroup.h"
  45. #include "XTPRibbonControlTab.h"
  46. #include "XTPRibbonBar.h"
  47. #include "XTPRibbonSystemButton.h"
  49. #ifdef _DEBUG
  50. #define new DEBUG_NEW
  51. #undef THIS_FILE
  52. static char THIS_FILE[] = __FILE__;
  53. #endif
  56. IMPLEMENT_XTP_COMMANDBAR(CXTPRibbonBar, CXTPMenuBar)
  58. class CXTPRibbonBar::CControlQuickAccessCommand : public CXTPControlButton
  59. {
  60. public:
  61. CControlQuickAccessCommand(CXTPControls* pQuickAccessControls, CXTPControl* pControlOriginal)
  62. {
  63. m_pControlOriginal = pControlOriginal;
  64. m_pQuickAccessControls = pQuickAccessControls;
  65. m_pQuickAccessControl = 0;
  66. }
  68. void SetQuickAccessControl(CXTPControl* pQuickAccessControl)
  69. {
  70. m_pQuickAccessControl = pQuickAccessControl;
  71. SetChecked(TRUE);
  72. }
  74. void OnExecute()
  75. {
  76. CXTPControlButton::OnExecute();
  78. if (m_pQuickAccessControl)
  79. {
  80. m_pQuickAccessControls->Remove(m_pQuickAccessControl);
  81. }
  82. else
  83. {
  84. CXTPControl* pControl = m_pQuickAccessControls->AddClone(m_pControlOriginal, -1, TRUE);
  85. pControl->SetHideFlag(xtpHideCustomize, FALSE);
  86. }
  88. m_pQuickAccessControls->GetParent()->OnRecalcLayout();
  89. }
  91. protected:
  92. CXTPControl* m_pControlOriginal;
  93. CXTPControl* m_pQuickAccessControl;
  94. CXTPControls* m_pQuickAccessControls;
  95. };
  98. class CXTPRibbonBar::CControlCaptionButton : public CXTPControlButton
  99. {
  100. public:
  101. CControlCaptionButton(CXTPOffice2007FrameHook* pFrame)
  102. {
  103. m_pFrame = pFrame;
  104. m_bTemporary = TRUE;
  105. SetFlags(xtpFlagNoMovable | xtpFlagSkipFocus | xtpFlagManualUpdate);
  106. }
  107. protected:
  108. void Draw(CDC* pDC)
  109. {
  110. ((CXTPRibbonBar*)GetParent())->GetRibbonPaintManager()->
  111. DrawRibbonFrameCaptionButton(pDC, GetRect(), GetID(), GetSelected(), GetPressed(), m_bEnabled && m_pFrame->IsFrameActive());
  112. }
  114. void OnExecute()
  115. {
  116. GetParent()->GetSite()->PostMessage(WM_SYSCOMMAND, GetID(), 0);
  117. }
  119. protected:
  120. CXTPOffice2007FrameHook* m_pFrame;
  121. };
  123. class CXTPRibbonBarControlQuickAccessPopup: public CXTPControlPopup
  124. {
  125. DECLARE_XTP_CONTROL(CXTPRibbonBarControlQuickAccessPopup)
  127. public:
  128. CXTPRibbonBarControlQuickAccessPopup()
  129. {
  130. m_bTemporary = TRUE;
  131. SetFlags(xtpFlagNoMovable | xtpFlagManualUpdate);
  132. }
  133. CSize GetSize(CDC* /*pDC*/)
  134. {
  135. CXTPRibbonTheme* pPaintManager = (CXTPRibbonTheme*)m_pParent->GetPaintManager();
  136. return CSize(pPaintManager->GetEditHeight() * 13 / 22, pPaintManager->GetEditHeight());
  137. }
  138. void Draw(CDC* pDC)
  139. {
  140. ((CXTPRibbonBar*)GetParent()->GetRootParent())->GetRibbonPaintManager()->DrawRibbonQuickAccessButton(pDC, this);
  141. }
  143. BOOL OnSetPopup(BOOL bPopup)
  144. {
  145. if (bPopup)
  146. {
  147. if (m_pCommandBar)
  148. m_pCommandBar->InternalRelease();
  150. CXTPRibbonBar* pRibbonBar = (CXTPRibbonBar*)GetParent()->GetRootParent();
  152. m_pCommandBar = pRibbonBar->CreateContextMenu(this);
  153. }
  155. return CXTPControlPopup::OnSetPopup(bPopup);
  156. }
  158. };
  160. IMPLEMENT_XTP_CONTROL(CXTPRibbonBarControlQuickAccessPopup, CXTPControlPopup)
  163. class CXTPRibbonBar::CControlQuickAccessMorePopup: public CXTPControlPopup
  164. {
  165. public:
  166. CControlQuickAccessMorePopup()
  167. {
  168. m_bTemporary = TRUE;
  169. SetFlags(xtpFlagNoMovable | xtpFlagManualUpdate);
  170. }
  171. CSize GetSize(CDC* /*pDC*/)
  172. {
  173. CXTPRibbonTheme* pPaintManager = (CXTPRibbonTheme*)m_pParent->GetPaintManager();
  174. return CSize(pPaintManager->GetEditHeight() * 13 / 22, pPaintManager->GetEditHeight());
  175. }
  176. void Draw(CDC* pDC)
  177. {
  178. ((CXTPRibbonBar*)GetParent())->GetRibbonPaintManager()->DrawRibbonQuickAccessMoreButton(pDC, this);
  179. }
  181. BOOL OnSetPopup(BOOL bPopup)
  182. {
  183. if (bPopup)
  184. {
  185. if (m_pCommandBar)
  186. m_pCommandBar->InternalRelease();
  188. m_pCommandBar = ((CXTPRibbonBar*)GetParent())->CreateMoreQuickAccessContextMenu();
  189. }
  191. return CXTPControlPopup::OnSetPopup(bPopup);
  192. }
  194. };
  197. /////////////////////////////////////////////////////////////////////////////
  198. // CXTPRibbonBar
  200. CXTPRibbonBar::CXTPRibbonBar()
  201. {
  202. m_pQuickAccessControls = new CXTPRibbonQuickAccessControls;
  203. m_pQuickAccessControls->SetParent(this);
  205. m_pControls->InternalRelease();
  206. m_pControls = new CXTPRibbonControls;
  207. m_pControls->SetParent(this);
  209. m_bShowCaptionAlways = TRUE;
  211. m_pHighlightedGroup = NULL;
  213. m_dwStyle = 0;
  214. m_rcTabControl.SetRectEmpty();
  215. m_rcGroups.SetRectEmpty();
  216. m_rcCaption.SetRectEmpty();
  217. m_rcCaptionText.SetRectEmpty();
  218. m_rcHeader.SetRectEmpty();
  220. m_bMinimizeOnDblClick = FALSE;
  222. InitScrollableBar(this);
  224. m_pControlQuickAccess = m_pControls->Add(new CXTPRibbonBarControlQuickAccessPopup, XTP_ID_RIBBONCONTROLQUICKACCESS, NULL, -1, TRUE);
  225. m_pControlQuickAccessMore = m_pControls->Add(new CControlQuickAccessMorePopup, XTP_ID_RIBBONCONTROLQUICKACCESSMORE, NULL, -1, TRUE);
  227. m_pControlTab = (CXTPRibbonControlTab*)m_pControls->Add(new CXTPRibbonControlTab, XTP_ID_RIBBONCONTROLTAB, NULL, -1, TRUE);
  229. m_dwFlags = xtpFlagIgnoreSetMenuMessage | xtpFlagStretched;
  231. m_bCustomizable = FALSE;
  232. m_bGroupsVisible = TRUE;
  233. m_bTabsVisible = TRUE;
  235. m_nMinVisibleWidth = 250;
  237. m_bMinimized = FALSE;
  239. m_pFrameHook = NULL;
  240. m_pControlSystemButton = NULL;
  242. m_bRibbonBarVisible = TRUE;
  243. m_bGroupReducedChanged = FALSE;
  245. m_bShowQuickAccessBelow = FALSE;
  246. m_bShowQuickAccess = TRUE;
  248. m_pContextHeaders = new CXTPRibbonTabContextHeaders;
  250. m_bMultiLine = TRUE;
  252. m_bAllowQuickAccessDuplicates = FALSE;
  253. m_bAllowQuickAccessCustomization = TRUE;
  255. m_nGroupsHeight = 0;
  256. m_nQuickAccessHeight = 0;
  258. m_nGroupsScrollPos = 0;
  260. m_bAllowMinimize = TRUE;
  262. EnableDoubleBuffer();
  263. EnableAnimation();
  264. }
  266. CXTPRibbonTheme* CXTPRibbonBar::GetRibbonPaintManager() const
  267. {
  268. CXTPPaintManager* pPaintManager = GetPaintManager();
  269. ASSERT(pPaintManager->BaseTheme() == xtpThemeRibbon);
  271. return (CXTPRibbonTheme*)pPaintManager;
  272. }
  275. CXTPRibbonBar::~CXTPRibbonBar()
  276. {
  277. if (m_pControlTab)
  278. {
  279. m_pControlTab->DeleteAllItems();
  280. }
  282. if (m_pQuickAccessControls)
  283. {
  284. m_pQuickAccessControls->RemoveAll();
  285. }
  287. CMDTARGET_RELEASE(m_pQuickAccessControls);
  288. SAFE_DELETE(m_pFrameHook);
  289. SAFE_DELETE(m_pContextHeaders);
  290. }
  292. void CXTPRibbonBar::OnRemoved()
  293. {
  294. SAFE_DELETE(m_pFrameHook);
  296. if (m_pQuickAccessControls)
  297. {
  298. m_pQuickAccessControls->RemoveAll();
  299. }
  300. if (m_pControlTab)
  301. {
  302. m_pControlTab->DeleteAllItems();
  303. }
  305. CXTPMenuBar::OnRemoved();
  306. }
  309. CXTPControlPopup* CXTPRibbonBar::AddSystemButton(int nID)
  310. {
  311. if (m_pControlSystemButton)
  312. return m_pControlSystemButton;
  314. m_pControlSystemButton = (CXTPControlPopup*)GetControls()->InsertAt(new CXTPRibbonControlSystemButton, 0);
  316. if (nID > 0) m_pControlSystemButton->SetID(nID);
  318. CXTPPopupBar* pCommandBar = new CXTPRibbonSystemPopupBar();
  319. pCommandBar->SetCommandBars(GetCommandBars());
  321. m_pControlSystemButton->SetCommandBar(pCommandBar);
  322. pCommandBar->InternalRelease();
  324. return m_pControlSystemButton;
  325. }
  327. void CXTPRibbonBar::EnableFrameTheme(BOOL bEnable)
  328. {
  329. CXTPOffice2007FrameHook* pFrameHook = m_pFrameHook;
  331. if (!bEnable)
  332. {
  333. if (pFrameHook)
  334. {
  335. m_pControls->Remove(m_pControls->FindControl(SC_CLOSE));
  336. m_pControls->Remove(m_pControls->FindControl(SC_RESTORE));
  337. m_pControls->Remove(m_pControls->FindControl(SC_MAXIMIZE));
  338. m_pControls->Remove(m_pControls->FindControl(SC_MINIMIZE));
  340. m_pFrameHook = NULL;
  341. SAFE_DELETE(pFrameHook);
  343. OnRecalcLayout();
  344. }
  345. }
  346. else
  347. {
  348. if (!pFrameHook)
  349. {
  350. m_pFrameHook = new CXTPOffice2007FrameHook();
  351. m_pFrameHook->EnableOffice2007Frame(GetCommandBars());
  352. ASSERT(m_pFrameHook->m_pRibbonBar == this);
  353. }
  354. }
  355. }
  357. BOOL CXTPRibbonBar::IsFrameThemeEnabled() const
  358. {
  359. return m_pFrameHook != NULL;
  360. }
  362. CXTPRibbonTab* CXTPRibbonBar::GetSelectedTab() const
  363. {
  364. if (m_pControlTab == NULL)
  365. return NULL;
  367. return (CXTPRibbonTab*)m_pControlTab->GetSelectedItem();
  368. }
  370. BOOL CXTPRibbonBar::OnTabChanging(CXTPRibbonTab* pTab)
  371. {
  372. NMXTPTABCHANGE nm;
  373. nm.pTab = pTab;
  375. return (BOOL)m_pControlTab->NotifySite(TCN_SELCHANGING, &nm);
  376. }
  378. void CXTPRibbonBar::OnTabChanged(CXTPRibbonTab* pTab)
  379. {
  380. NMXTPTABCHANGE nm;
  381. nm.pTab = pTab;
  383. m_pControlTab->NotifySite(TCN_SELCHANGE, &nm);
  384. }
  386. int CXTPRibbonBar::GetCurSel() const
  387. {
  388. return m_pControlTab->GetCurSel();
  389. }
  391. void CXTPRibbonBar::SetCurSel(int nIndex)
  392. {
  393. m_pControlTab->SetCurSel(nIndex);
  395. }
  397. CXTPRibbonTab* CXTPRibbonBar::InsertTab(int nItem, int nID)
  398. {
  399. CString strCaption;
  400. VERIFY(strCaption.LoadString(nID));
  402. return InsertTab(nItem, strCaption, nID);
  403. }
  405. CXTPRibbonTab* CXTPRibbonBar::InsertTab(int nItem, LPCTSTR lpszCaption, int nID)
  406. {
  407. CXTPRibbonTab* pItem = (CXTPRibbonTab*)m_pControlTab->AddItem(nItem, new CXTPRibbonTab());
  408. pItem->m_pRibbonBar = this;
  409. pItem->m_pParent = this;
  410. pItem->SetCaption(lpszCaption);
  411. pItem->SetID(nID);
  413. if (nItem == 0 && GetCurSel() == -1)
  414. {
  415. SetCurSel(0);
  416. }
  418. m_bTrackOnHover = FALSE;
  419. m_barType = xtpBarTypeRibbon;
  421. return pItem;
  422. }
  424. CXTPRibbonTab* CXTPRibbonBar::AddTab(int nID)
  425. {
  426. return InsertTab(m_pControlTab->GetItemCount(), nID);
  427. }
  429. CXTPRibbonTab* CXTPRibbonBar::AddTab(LPCTSTR lpszCaption)
  430. {
  431. return InsertTab(m_pControlTab->GetItemCount(), lpszCaption, 0);
  432. }
  434. void CXTPRibbonBar::RebuildControls(CXTPRibbonTab* pSelected)
  435. {
  436. m_nGroupsScrollPos = 0;
  438. if (IsRibbonMinimized())
  439. pSelected = NULL;
  441. for (int i = GetControlCount() - 1; i >= 0; i--)
  442. {
  443. CXTPControl* pControl = m_pControls->GetAt(i);
  444. CXTPRibbonGroup* pGroup = pControl->GetRibbonGroup();
  446. if ((pGroup != NULL) && (pGroup->GetParentTab() != pSelected || !pGroup->m_bVisible))
  447. {
  448. pControl->SetHideFlag(xtpHideRibbonTab, TRUE);
  449. }
  450. else
  451. {
  452. pControl->SetHideFlag(xtpHideRibbonTab, FALSE);
  453. }
  454. }
  455. }
  458. BEGIN_MESSAGE_MAP(CXTPRibbonBar, CXTPMenuBar)
  459. //{{AFX_MSG_MAP(CXTPRibbonBar)
  460. ON_WM_LBUTTONDOWN()
  461. ON_WM_RBUTTONUP()
  462. ON_WM_LBUTTONDBLCLK()
  463. ON_WM_SYSCOLORCHANGE()
  464. ON_WM_MOUSEMOVE()
  465. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  466. ON_WM_CREATE()
  467. ON_WM_SETCURSOR()
  468. ON_WM_SHOWWINDOW()
  469. ON_WM_RBUTTONDOWN()
  470. ON_COMMAND_RANGE(XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSBELOW, XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSABOVE, OnCustomizePlaceQuickAccess)
  471. ON_MESSAGE(WM_XTP_COMMAND, OnCustomizeCommand)
  472. ON_WM_NCHITTEST_EX()
  473. //}}AFX_MSG_MAP
  474. END_MESSAGE_MAP()
  477. /////////////////////////////////////////////////////////////////////////////
  478. // CXTPRibbonBar message handlers
  480. int CXTPRibbonBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  481. {
  482. if (CXTPMenuBar::OnCreate(lpCreateStruct) == -1)
  483. return -1;
  485. SetupHook();
  487. return 0;
  488. }
  490. void CXTPRibbonBar::OnShowWindow(BOOL bShow, UINT nStatus)
  491. {
  492. CXTPMenuBar::OnShowWindow(bShow, nStatus);
  494. if (IsFrameThemeEnabled() && bShow != m_bRibbonBarVisible)
  495. {
  496. m_bRibbonBarVisible = bShow;
  497. m_pFrameHook->RecalcFrameLayout();
  498. }
  499. }
  501. void CXTPRibbonBar::SetVisible(BOOL bVisible)
  502. {
  503. BOOL bOldVisible = IsVisible();
  505. CXTPMenuBar::SetVisible(bVisible);
  507. if (IsFrameThemeEnabled() && bOldVisible != IsVisible())
  508. {
  509. m_pFrameHook->RecalcFrameLayout();
  510. }
  511. }
  513. int CXTPRibbonBar::GetQuickAccessHeight() const
  514. {
  515. return m_nQuickAccessHeight;
  517. }
  519. int CXTPRibbonBar::CalcQuickAccessHeight()
  520. {
  521. CClientDC dc(this);
  522. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this, FALSE));
  524. int nQuickAccessHeight = GetButtonSize().cy + 4;
  526. for (int i = 0; i < m_pQuickAccessControls->GetCount(); i++)
  527. {
  528. CXTPControl* pControl = m_pQuickAccessControls->GetAt(i);
  529. if (!pControl->IsVisible())
  530. continue;
  532. int nHeight = pControl->GetSize(&dc).cy + 4;
  533. if (nHeight > nQuickAccessHeight)
  534. nQuickAccessHeight = nHeight;
  535. }
  536. return nQuickAccessHeight;
  537. }
  539. CSize CXTPRibbonBar::CalcDockingLayout(int nLength, DWORD dwMode, int /*nWidth*/)
  540. {
  541. BOOL bRibbonBarVisible = nLength >= m_nMinVisibleWidth;
  542. m_bGroupReducedChanged = FALSE;
  544. CXTPWindowRect rc(GetSite());
  545. if (rc.Height() < m_nMinVisibleWidth)
  546. bRibbonBarVisible = FALSE;
  548. if (bRibbonBarVisible != m_bRibbonBarVisible)
  549. {
  550. m_bRibbonBarVisible =  bRibbonBarVisible;
  552. if (IsFrameThemeEnabled())
  553. {
  554. m_pFrameHook->DelayRecalcFrameLayout();
  555. }
  556. }
  558. if (!bRibbonBarVisible)
  559. {
  560. return CSize(nLength, 0);
  561. }
  563. int nCaptionHeight = GetCaptionHeight() + GetRibbonTopBorder();
  564. int nHeight = nCaptionHeight + GetTabsHeight() + GetGroupsHeight();
  566. m_nQuickAccessHeight = CalcQuickAccessHeight();
  568. if (IsQuickAccessBelowRibbon())
  569. {
  570. nHeight += m_nQuickAccessHeight + 1;
  571. }
  574. if (!IsGroupsVisible() && !IsQuickAccessBelowRibbon())
  575. {
  576. nHeight += 2;
  577. }
  579. if (dwMode & LM_COMMIT)
  580. {
  581. Reposition(nLength, nHeight);
  582. }
  586. if (m_bGroupReducedChanged)
  587. {
  588. OnUpdateCmdUI();
  589. m_bGroupReducedChanged = FALSE;
  590. }
  592. if ((m_nIdleFlags & xtpIdleLayout) && (dwMode & LM_COMMIT))
  593. {
  594. m_nIdleFlags &= ~xtpIdleLayout;
  595. Redraw();
  596. }
  598. return CSize(nLength, nHeight);
  599. }
  601. int CXTPRibbonBar::GetTabsHeight() const
  602. {
  603. return m_bTabsVisible ? GetRibbonPaintManager()->m_nTabsHeight : 2;
  604. }
  606. int CXTPRibbonBar::CalcGroupsHeight()
  607. {
  608. if (m_nGroupsHeight > 0)
  609. return m_nGroupsHeight;
  611. int nHeight = GetRibbonPaintManager()->GetEditHeight() * 3;
  612. int nCaptionHeight = GetRibbonPaintManager()->GetGroupCaptionHeight();
  614. return nHeight + nCaptionHeight + 10;
  615. }
  617. int CXTPRibbonBar::GetGroupsHeight()
  618. {
  619. return IsGroupsVisible() ? CalcGroupsHeight() : 0;
  620. }
  622. BOOL CXTPRibbonBar::IsGroupsVisible() const
  623. {
  624. return m_bGroupsVisible && GetSelectedTab() != NULL && !m_bMinimized;
  625. }
  627. void CXTPRibbonBar::SetGroupsVisible(BOOL bVisible)
  628. {
  629. if (bVisible != m_bGroupsVisible)
  630. {
  631. m_bGroupsVisible = bVisible;
  632. OnRecalcLayout();
  633. }
  634. }
  636. BOOL CXTPRibbonBar::IsTabsVisible() const
  637. {
  638. return m_bTabsVisible;
  639. }
  641. void CXTPRibbonBar::SetTabsVisible(BOOL bVisible)
  642. {
  643. if (bVisible != m_bTabsVisible)
  644. {
  645. m_bTabsVisible = bVisible;
  646. OnRecalcLayout();
  647. }
  648. }
  650. BOOL CXTPRibbonBar::IsQuickAccessControl(CXTPControl* pControl) const
  651. {
  652. if (pControl == m_pControlQuickAccess)
  653. return TRUE;
  655. if (pControl == m_pControlQuickAccessMore)
  656. return TRUE;
  658. if (pControl->GetRibbonGroup())
  659. return FALSE;
  661. if (m_pQuickAccessControls == NULL)
  662. return FALSE;
  664. for (int i = 0; i < m_pQuickAccessControls->GetCount(); i++)
  665. {
  666. if (m_pQuickAccessControls->GetAt(i) == pControl)
  667. return TRUE;
  668. }
  669. return FALSE;
  670. }
  672. int CXTPRibbonBar::GetCaptionHeight() const
  673. {
  674. if (!IsFrameThemeEnabled() && !m_bShowCaptionAlways)
  675. return 0;
  677. int nHeight = GetRibbonPaintManager()->GetRibbonCaptionHeight();
  679. if (!IsQuickAccessVisible() || IsQuickAccessBelowRibbon())
  680. return nHeight;
  682. int nQuickAccessHeight = GetQuickAccessHeight();
  683. nQuickAccessHeight = max(nQuickAccessHeight, GetTabsHeight() - 2);
  685. if (nHeight >= nQuickAccessHeight)
  686. return nHeight;
  688. return nQuickAccessHeight;
  689. }
  691. void CXTPRibbonBar::Reposition(int cx, int cy)
  692. {
  693. CClientDC dc(this);
  694. int nTabsHeight = GetTabsHeight();
  695. int nGroupsHeight = GetGroupsHeight();
  696. BOOL bFrameThemeEnabled = IsFrameThemeEnabled();
  697. BOOL bShowCaption = bFrameThemeEnabled || m_bShowCaptionAlways;
  699. int nQuickAccessHeight = m_nQuickAccessHeight;
  701. int i;
  703. CRect rcTabControl(2, 0, cx - 2, nTabsHeight);
  704. CRect rcRibbonGroups(0, nTabsHeight, cx, nTabsHeight + nGroupsHeight);
  706. int nFrameBorder = 4;
  708. if (bShowCaption)
  709. {
  710. nFrameBorder = m_pFrameHook ? m_pFrameHook->GetFrameBorder() : 0;
  711. int nRibbonTopBorder = GetRibbonTopBorder();
  712. int nCaptionOffset = nRibbonTopBorder - nFrameBorder;
  714. m_rcCaption.SetRect(-nFrameBorder, nCaptionOffset, cx + nFrameBorder, GetCaptionHeight() + nRibbonTopBorder);
  715. rcTabControl.OffsetRect(0, m_rcCaption.Height() + nCaptionOffset);
  716. rcRibbonGroups.OffsetRect(0, m_rcCaption.Height() + nCaptionOffset);
  718. m_rcCaptionText.SetRect(0, 0, cx, m_rcCaption.bottom);
  719. m_rcHeader.SetRect(0, 0, cx, m_rcCaption.bottom);
  721. if (!m_pFrameHook) m_rcCaptionText.SetRectEmpty();
  722. }
  723. else
  724. {
  725. m_rcCaption.SetRectEmpty();
  726. m_rcCaptionText.SetRectEmpty();
  727. m_rcHeader.SetRectEmpty();
  728. }
  730. CArray<CXTPControl*, CXTPControl*> arrFreeControls;
  731. CArray<CXTPControl*, CXTPControl*> arrQuickAccessControls;
  733. for (i = 0; i < GetControlCount(); i++)
  734. {
  735. CXTPControl* pControl = GetControl(i);
  737. if (IsQuickAccessControl(pControl))
  738. {
  739. arrQuickAccessControls.Add(pControl);
  740. }
  741. else
  742. {
  743. if (!pControl->IsVisible())
  744. continue;
  746. if (pControl->GetRibbonGroup() != NULL)
  747. continue;
  749. if (pControl->GetID() >= SC_MINIMIZE && pControl->GetID() <= SC_RESTORE)
  750. continue;
  752. if (pControl == m_pControlSystemButton || pControl == m_pControlScrollGroupsLeft ||
  753. pControl == m_pControlScrollGroupsRight)
  754. continue;
  756. if (pControl == m_pControlTab)
  757. continue;
  759. arrFreeControls.Add(pControl);
  760. }
  761. }
  763. int nCorner = nQuickAccessHeight + nTabsHeight - 3;
  765. if (m_bShowQuickAccess && m_bShowQuickAccessBelow)
  766. {
  767. m_rcQuickAccess.SetRect(0, rcRibbonGroups.bottom, cx, rcRibbonGroups.bottom + nQuickAccessHeight);
  768. }
  769. else
  770. {
  771. m_rcQuickAccess.SetRect(3 + nCorner, m_rcCaption.top + nFrameBorder - 2, m_rcCaption.right, m_rcCaption.top + nFrameBorder - 2 + nQuickAccessHeight - 1);
  772. }
  774. int nLeft = 2;
  775. int nRight = cx - 2;
  777. if (m_pControlSystemButton)
  778. {
  779. CSize szControl(nCorner, nCorner - 1);
  780. int nTop = m_rcCaption.top + nFrameBorder - 1;
  782. if (!bShowCaption)
  783. {
  784. szControl = m_pControlSystemButton->GetSize(&dc);
  785. nTop = rcTabControl.top + (nTabsHeight - szControl.cy) / 2;
  786. }
  787. else if (!m_bTabsVisible)
  788. {
  789. szControl = m_pControlSystemButton->GetSize(&dc);
  790. nTop = m_rcCaption.top + (m_rcCaption.Height() - szControl.cy) / 2;
  791. m_rcQuickAccess.left = 3 + szControl.cx + 12;
  792. }
  793. nLeft = 0;
  795. CRect rcControl(nLeft, nTop, nLeft + szControl.cx, nTop + szControl.cy);
  796. nLeft += szControl.cx;
  798. m_pControlSystemButton->SetHideWrap(!bShowCaption && !m_bTabsVisible);
  799. m_pControlSystemButton->SetRect(rcControl);
  800. m_pControlSystemButton->SetWrap(TRUE);
  801. }
  803. for (i = 0; i < (int)arrFreeControls.GetSize(); i++)
  804. {
  805. CXTPControl* pControl = arrFreeControls.GetAt(i);
  807. if (pControl->GetFlags() & xtpFlagRightAlign)
  808. continue;
  810. pControl->SetHideFlag(xtpHideDockingPosition, !m_bTabsVisible);
  811. if (!pControl->IsVisible())
  812. continue;
  814. CSize szControl = pControl->GetSize(&dc);
  815. int nTop = rcTabControl.top + (nTabsHeight - szControl.cy) / 2;
  817. if (pControl->GetBeginGroup())
  818. nLeft += 6;
  820. CRect rcControl(nLeft, nTop, nLeft + szControl.cx, nTop + szControl.cy);
  821. nLeft += szControl.cx;
  823. pControl->SetHideWrap(FALSE);
  824. pControl->SetRect(rcControl);
  825. pControl->SetRowRect(CRect(2, rcTabControl.top, cy - 2, rcTabControl.bottom));
  826. pControl->SetWrap(FALSE);
  827. }
  829. int nLeftTab = nLeft;
  830. BOOL bQuickAccessNearTabs = m_bShowQuickAccess && !m_bShowQuickAccessBelow && !bShowCaption;
  832. if (bQuickAccessNearTabs)
  833. {
  834. nLeft += 5;
  835. m_rcQuickAccess.left = nLeft;
  836. m_rcQuickAccess.top = rcTabControl.top;
  837. m_rcQuickAccess.bottom = rcTabControl.bottom;
  838. }
  839. else
  840. {
  841. nLeft = m_rcQuickAccess.left + (m_bShowQuickAccessBelow ? 2 : 0);
  842. }
  844. nRight = m_bShowQuickAccess && m_bShowQuickAccessBelow ? cx - 2 - 13 :
  845. IsDwmEnabled() ? cx - 115 : cx - m_rcCaption.Height() * 3;
  847. if (m_pControlQuickAccessMore) m_pControlQuickAccessMore->SetHideFlag(xtpHideGeneric, TRUE);
  848. BOOL bQuickAccessMoreVisible = FALSE;
  849. BOOL bQuickAccessFound = FALSE;
  851. for (i = 0; i < (int)arrQuickAccessControls.GetSize(); i++)
  852. {
  853. CXTPControl* pControl = arrQuickAccessControls.GetAt(i);
  855. if (!m_bShowQuickAccess)
  856. pControl->SetHideFlag(xtpHideWrap, TRUE);
  857. else if (pControl != m_pControlQuickAccessMore)
  858. pControl->SetHideFlag(xtpHideWrap, bQuickAccessMoreVisible);
  859. if (!bShowCaption && !m_bTabsVisible)
  860. pControl->SetHideFlag(xtpHideWrap, TRUE);
  862. if (pControl == m_pControlQuickAccess && bQuickAccessFound &&
  863. !bQuickAccessNearTabs && !m_bShowQuickAccessBelow)
  864. nLeft += 12;
  866. if (!pControl->IsVisible())
  867. continue;
  869. BOOL bSpecial = pControl == m_pControlQuickAccessMore || pControl == m_pControlQuickAccess;
  871. CSize szControl = pControl->GetSize(&dc);
  872. int nTop = m_rcQuickAccess.top + (m_rcQuickAccess.Height() - szControl.cy + 1) / 2;
  874. if (!bSpecial && !m_bShowQuickAccessBelow && !bQuickAccessNearTabs)
  875. {
  876. nTop += 2;
  877. }
  878. if (!bSpecial)
  879. {
  880. bQuickAccessFound = TRUE;
  881. }
  883. if (!bSpecial && (nLeft + szControl.cx > nRight))
  884. {
  885. bQuickAccessMoreVisible = TRUE;
  886. pControl->SetHideFlag(xtpHideWrap, bQuickAccessMoreVisible);
  887. m_pControlQuickAccessMore->SetHideFlag(xtpHideGeneric, FALSE);
  888. continue;
  889. }
  891. CRect rcControl(nLeft, nTop, nLeft + szControl.cx, nTop + szControl.cy);
  893. if (bQuickAccessNearTabs || !bSpecial)
  894. nLeft += szControl.cx;
  896. pControl->SetHideWrap(FALSE);
  897. pControl->SetRect(rcControl);
  898. pControl->SetRowRect(m_rcQuickAccess);
  899. pControl->SetWrap(FALSE);
  900. }
  901. if (!m_bShowQuickAccessBelow) m_rcQuickAccess.right = nLeft;
  903. if (!bQuickAccessNearTabs) nLeft = nLeftTab;
  904. nRight = cx;
  906. for (i = (int)arrFreeControls.GetSize() - 1; i >= 0; i--)
  907. {
  908. CXTPControl* pControl = arrFreeControls.GetAt(i);
  910. if ((pControl->GetFlags() & xtpFlagRightAlign) == 0)
  911. continue;
  913. pControl->SetHideFlag(xtpHideDockingPosition, !m_bTabsVisible);
  914. if (!pControl->IsVisible())
  915. continue;
  917. CSize szControl = pControl->GetSize(&dc);
  918. int nTop = rcTabControl.top + (nTabsHeight - szControl.cy) / 2;
  920. CRect rcControl = CRect(nRight - szControl.cx, nTop, nRight, nTop + szControl.cy);
  921. nRight -= szControl.cx;
  923. pControl->SetHideWrap(FALSE);
  924. pControl->SetRect(rcControl);
  925. pControl->SetRowRect(CRect(2, rcTabControl.top, cy - 2, rcTabControl.bottom));
  926. pControl->SetWrap(TRUE);
  927. pControl->SetBeginGroup(FALSE);
  928. }
  930. if (!m_bTabsVisible) rcTabControl.bottom = rcTabControl.top;
  932. if (nLeft + 6 > nRight)
  933. m_rcTabControl.SetRectEmpty();
  934. else
  935. m_rcTabControl = CRect(nLeft, rcTabControl.top, nRight, rcTabControl.bottom + 1);
  937. if (m_pControlTab)
  938. {
  939. m_pControlTab->SetHideFlag(xtpHideGeneric, !m_bTabsVisible);
  941. m_pControlTab->SetRect(m_rcTabControl);
  942. GetTabPaintManager()->RepositionTabControl(m_pControlTab, &dc, m_rcTabControl);
  943. }
  945. RepositionGroups(&dc, rcRibbonGroups);
  947. RepositionCaptionButtons();
  949. if (bShowCaption)
  950. {
  951. RepositionContextHeaders();
  952. }
  953. }
  957. void CXTPRibbonBar::AddCaptionButton(int nId, BOOL bAdd, BOOL bEnabled, CRect& rcCaption)
  958. {
  959. CXTPControl* pButton = m_pControls->FindControl(nId);
  961. if (!pButton && bAdd)
  962. {
  963. pButton = m_pControls->Add(new CControlCaptionButton(m_pFrameHook), nId, NULL, -1, TRUE);
  965. CString strCaption;
  966. CMenu* pMenu = GetSite()->GetSystemMenu(FALSE);
  967. if (pMenu)
  968. {
  969. pMenu->GetMenuString(nId, strCaption, MF_BYCOMMAND);
  970. int nIndex = strCaption.Find(_T('t'));
  971. if (nIndex > 0)
  972. {
  973. strCaption = strCaption.Left(nIndex);
  974. }
  975. }
  976. if (pButton->GetAction())
  977. {
  978. pButton->GetAction()->SetCaption(_T(""));
  979. pButton->GetAction()->SetDescription(NULL);
  980. }
  982. pButton->SetDescription(NULL);
  983. pButton->SetCaption(_T(""));
  984. pButton->SetTooltip(strCaption);
  985. }
  986. else if (pButton && !bAdd)
  987. {
  988. m_pControls->Remove(pButton);
  989. }
  991. if (bAdd)
  992. {
  993. CRect rcButton(rcCaption.right - rcCaption.Height(), rcCaption.top, rcCaption.right, rcCaption.bottom);
  994. pButton->SetRect(rcButton);
  995. rcCaption.right -= rcButton.Width();
  996. pButton->SetEnabled(bEnabled);
  997. }
  998. }
  1000. BOOL CXTPRibbonBar::ShrinkContextHeaders(int nLeft, int nRight)
  1001. {
  1002. int i, nCount = m_pContextHeaders->GetCount();
  1004. for (i = 0; i < nCount; i++)
  1005. {
  1006. CXTPRibbonTabContextHeader* pHeader =  m_pContextHeaders->GetHeader(i);
  1007. if (pHeader->m_rcRect.left < nLeft)
  1008. {
  1009. pHeader->m_rcRect.left = nLeft;
  1010. if (pHeader->m_rcRect.Width()  < 40)
  1011. {
  1012. pHeader->m_rcRect.right = nLeft + 40;
  1013. }
  1014. nLeft = pHeader->m_rcRect.right;
  1015. }
  1016. else break;
  1017. }
  1018. for (i = nCount - 1; i >= 0; i--)
  1019. {
  1020. CXTPRibbonTabContextHeader* pHeader =  m_pContextHeaders->GetHeader(i);
  1021. if (pHeader->m_rcRect.right > nRight)
  1022. {
  1023. pHeader->m_rcRect.right = nRight;
  1024. if (pHeader->m_rcRect.Width()  < 40)
  1025. {
  1026. pHeader->m_rcRect.left = nRight - 40;
  1027. }
  1028. nRight = pHeader->m_rcRect.left;
  1030. if (nRight < nLeft)
  1031. return FALSE;
  1032. }
  1033. else break;
  1034. }
  1036. return TRUE;
  1037. }
  1039. BOOL CXTPRibbonBar::IsCaptionVisible() const
  1040. {
  1041. return IsFrameThemeEnabled() || m_bShowCaptionAlways;
  1042. }
  1044. void CXTPRibbonBar::RepositionContextHeaders()
  1045. {
  1046. m_pContextHeaders->RemoveAll();
  1048. CXTPRibbonTabContextHeader* pPreviousHeader = NULL;
  1050. if (!IsCaptionVisible())
  1051. return;
  1053. int nCount = GetTabCount();
  1054. if (nCount == 0)
  1055. return;
  1057. if (!IsQuickAccessBelowRibbon() && IsQuickAccessVisible() && !m_pFrameHook)
  1058. m_rcHeader.left = m_rcQuickAccess.right + (m_pControlQuickAccess ? m_pControlQuickAccess->GetRect().Width() + 2 : 12);
  1060. int i;
  1061. for (i = 0; i < nCount; i++)
  1062. {
  1063. CXTPRibbonTab* pTab = GetTab(i);
  1064. pTab->m_pContextHeader = NULL;
  1065. if (!pTab->IsVisible())
  1066. continue;
  1068. if (pTab->GetContextColor() == xtpRibbonTabContextColorNone || pTab->GetContextCaption().IsEmpty())
  1069. {
  1070. pPreviousHeader = NULL;
  1071. continue;
  1072. }
  1073. if (pPreviousHeader && pPreviousHeader->m_color == pTab->GetContextColor() &&
  1074. pPreviousHeader->m_strCaption == pTab->GetContextCaption())
  1075. {
  1076. pPreviousHeader->m_rcRect.right = pTab->GetRect().right;
  1077. pPreviousHeader->m_pLastTab = pTab;
  1078. pTab->m_pContextHeader = pPreviousHeader;
  1079. }
  1080. else
  1081. {
  1082. CXTPRibbonTabContextHeader* pHeader = new CXTPRibbonTabContextHeader(pTab);
  1084. pHeader->m_rcRect.SetRect(pTab->GetRect().left, m_rcCaption.top + 4, pTab->GetRect().right, m_rcCaption.bottom);
  1086. m_pContextHeaders->Add(pHeader);
  1088. pPreviousHeader = pHeader;
  1089. }
  1090. }
  1092. nCount = m_pContextHeaders->GetCount();
  1093. if (nCount == 0)
  1094. return;
  1096. if (!ShrinkContextHeaders(m_rcHeader.left, m_rcHeader.right))
  1097. {
  1098. m_pContextHeaders->RemoveAll();
  1099. return;
  1100. }
  1102. CRect rcHeaders(m_pContextHeaders->GetHeader(0)->m_rcRect.left, m_rcCaption.top + 6,
  1103. m_pContextHeaders->GetHeader(nCount - 1)->m_rcRect.right, m_rcCaption.bottom);
  1105. int nCaptionLength = m_rcCaptionText.Width();
  1106. CRect rcCaptionText(m_rcCaptionText);
  1108. if (CRect().IntersectRect(rcCaptionText, rcHeaders))
  1109. {
  1110. if (rcCaptionText.CenterPoint().x > rcHeaders.CenterPoint().x)
  1111. {
  1112. if (m_rcHeader.right - rcHeaders.right < nCaptionLength)
  1113. {
  1114. m_rcCaptionText.left = rcHeaders.right;
  1115. m_rcCaptionText.right = m_rcHeader.right;
  1116. }
  1117. else
  1118. {
  1119. m_rcCaptionText.left = rcHeaders.right;
  1120. m_rcCaptionText.right = rcHeaders.right + nCaptionLength;
  1121. }
  1122. }
  1123. else
  1124. {
  1125. if (rcHeaders.left - m_rcHeader.left < nCaptionLength)
  1126. {
  1127. m_rcCaptionText.left = m_rcHeader.left;
  1128. m_rcCaptionText.right = rcHeaders.left;
  1129. }
  1130. else
  1131. {
  1132. m_rcCaptionText.left = rcHeaders.left - nCaptionLength;
  1133. m_rcCaptionText.right = rcHeaders.left;
  1134. }
  1135. }
  1136. }
  1137. }
  1139. int CXTPRibbonBar::GetRibbonTopBorder() const
  1140. {
  1141. return m_pFrameHook && m_pFrameHook->IsDwmEnabled() ? m_pFrameHook->GetFrameBorder() : 0;
  1142. }
  1144. void CXTPRibbonBar::RepositionCaptionButtons()
  1145. {
  1146. if (!IsFrameThemeEnabled())
  1147. {
  1148. return;
  1149. }
  1151. CRect rcQuickAccess = m_rcQuickAccess;
  1152. if (m_bShowQuickAccessBelow || !m_bShowQuickAccess)
  1153. {
  1154. m_rcHeader.left += 70;
  1155. }
  1156. else
  1157. {
  1158. rcQuickAccess.right += (m_pControlQuickAccess ? m_pControlQuickAccess->GetRect().Width() + 2 : 12);
  1159. m_rcHeader.left = rcQuickAccess.right;
  1160. }
  1162. CWnd* pSite = GetSite();
  1163. DWORD dwStyle = pSite->GetStyle();
  1164. DWORD dwExStyle = pSite->GetExStyle();
  1165. BOOL bToolWindow = (dwExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW;
  1167. int nFrameBorder = GetRibbonTopBorder();
  1169. m_rcHeader.DeflateRect(0, nFrameBorder, 0, 3);
  1171. BOOL bDwmEnabled = m_pFrameHook->IsDwmEnabled();
  1173. BOOL bEnableClose = TRUE;
  1174. BOOL bMaximized = (dwStyle & WS_MAXIMIZE) == WS_MAXIMIZE;
  1175. BOOL bSysMenu = (dwStyle & WS_SYSMENU);
  1176. BOOL bEnabledMaximize = ((dwStyle & WS_MAXIMIZEBOX) == WS_MAXIMIZEBOX);
  1177. BOOL bEnabledMinimize = ((dwStyle & WS_MINIMIZEBOX) == WS_MINIMIZEBOX);
  1178. BOOL bShowMinMaxButtons = !bToolWindow && bSysMenu && (bEnabledMaximize || bEnabledMinimize);
  1179. BOOL bShowCloseButton = bSysMenu;
  1180. if (bSysMenu && !bToolWindow)
  1181. {
  1182. CMenu* pMenu = GetSite()->GetSystemMenu(FALSE);
  1183. if (pMenu && pMenu->GetMenuState(SC_CLOSE, MF_BYCOMMAND) & (MF_DISABLED | MF_GRAYED)) bEnableClose = FALSE;
  1184. }
  1185. if (bMaximized && (dwStyle & WS_CHILD))
  1186. {
  1187. bShowMinMaxButtons = bShowCloseButton = FALSE;
  1188. }
  1190. AddCaptionButton(SC_CLOSE, !bDwmEnabled && bShowCloseButton, bEnableClose, m_rcHeader);
  1191. AddCaptionButton(SC_RESTORE, !bDwmEnabled && bShowMinMaxButtons && bMaximized, bEnabledMaximize, m_rcHeader);
  1192. AddCaptionButton(SC_MAXIMIZE, !bDwmEnabled && bShowMinMaxButtons && !bMaximized, bEnabledMaximize, m_rcHeader);
  1193. AddCaptionButton(SC_MINIMIZE, !bDwmEnabled && bShowMinMaxButtons, bEnabledMinimize, m_rcHeader);
  1195. if (bDwmEnabled)
  1196. m_rcHeader.right -= 100;
  1198. m_rcCaptionText.SetRect(m_rcCaptionText.left + 70, m_rcHeader.top, m_rcHeader.right, m_rcHeader.bottom);
  1201. CClientDC dc(this);
  1202. CXTPFontDC font(&dc, &GetRibbonPaintManager()->m_fontFrameCaption);
  1204. GetSite()->GetWindowText(m_strCaptionText);
  1206. int nCaptionLength = dc.GetTextExtent(m_strCaptionText).cx + 20;
  1207. nCaptionLength = min(m_rcCaptionText.Width(), nCaptionLength);
  1209. CRect rcCaptionText(m_rcCaptionText);
  1210. rcCaptionText.left += (rcCaptionText.Width() - nCaptionLength) / 2;
  1211. rcCaptionText.right = rcCaptionText.left + nCaptionLength;
  1213. if (CRect().IntersectRect(rcQuickAccess, rcCaptionText))
  1214. {
  1215. nCaptionLength = min(m_rcHeader.Width(), nCaptionLength);
  1216. rcCaptionText.left = m_rcHeader.left + (m_rcHeader.Width() - nCaptionLength) / 2;
  1217. rcCaptionText.right = rcCaptionText.left + nCaptionLength;
  1218. }
  1220. m_rcCaptionText = rcCaptionText;
  1222. }
  1224. void CXTPRibbonBar::RepositionGroups(CDC* pDC, CRect rcGroups)
  1225. {
  1226. m_rcGroups = rcGroups;
  1228. CXTPRibbonTab* pTab = GetSelectedTab();
  1229. if (!pTab)
  1230. return;
  1232. CXTPRibbonGroups* pGroups = pTab->GetGroups();
  1234. pGroups->CalcDynamicSize(pDC, rcGroups.Width(), LM_COMMIT, CRect(rcGroups.left + 4, rcGroups.top + 3, 6, 3));
  1235. }
  1237. void CXTPRibbonBar::EnsureVisible(CXTPControl* pControl)
  1238. {
  1239. if (pControl->GetRibbonGroup())
  1240. {
  1241. if (pControl->GetRibbonGroup()->GetParentTab() != GetSelectedTab())
  1242. {
  1243. pControl->GetRibbonGroup()->GetParentTab()->Select();
  1244. }
  1245. }
  1247. if (GetSelectedTab() && pControl->GetRibbonGroup() &&
  1248. (m_pControlScrollGroupsLeft->IsVisible() || m_pControlScrollGroupsRight->IsVisible()))
  1249. {
  1250. ShowScrollableRect(GetSelectedTab()->GetGroups(), pControl->GetRect());
  1251. }
  1252. }
  1254. void CXTPRibbonBar::OnGroupsScroll(BOOL bScrollLeft)
  1255. {
  1256. if (!GetSelectedTab())
  1257. return;
  1259. GetCommandBars()->ClosePopups();
  1260. HideKeyboardTips();
  1262. int nGroupsScrollPos = GetSelectedTab()->GetGroups()->m_nGroupsScrollPos;
  1264. if (bScrollLeft)
  1265. {
  1266. nGroupsScrollPos -= 40;
  1267. if (nGroupsScrollPos < 0)
  1268. nGroupsScrollPos = 0;
  1269. }
  1270. else
  1271. {
  1272. nGroupsScrollPos += 40;
  1273. }
  1275. if (nGroupsScrollPos != m_nGroupsScrollPos)
  1276. {
  1277. m_nGroupsScrollPos = nGroupsScrollPos;
  1278. OnRecalcLayout();
  1279. }
  1280. }
  1283. CXTPTabPaintManager* CXTPRibbonBar::GetTabPaintManager() const
  1284. {
  1285. return GetRibbonPaintManager()->GetTabPaintManager();
  1286. }
  1288. void CXTPRibbonBar::DrawCommandBar(CDC* pDC, CRect rcClipBox)
  1289. {
  1290. #if 0
  1291. _int64 nPerfomanceEnd;
  1292. _int64 nPerfomanceStart;
  1294. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceStart);
  1295. #endif
  1297. pDC->SetBkMode(TRANSPARENT);
  1299. CXTPPaintManager* pPaintManager = GetPaintManager();
  1301. GetRibbonPaintManager()->FillRibbonBar(pDC, this);
  1303. if (IsFrameThemeEnabled() && CRect().IntersectRect(m_rcCaption, rcClipBox))
  1304. {
  1305. GetRibbonPaintManager()->DrawRibbonFrameCaption(pDC, this, m_pFrameHook->m_bActive);
  1306. }
  1307. else if (m_bShowCaptionAlways && CRect().IntersectRect(m_rcCaption, rcClipBox))
  1308. {
  1309. GetRibbonPaintManager()->DrawRibbonFrameCaptionBar(pDC, this);
  1310. }
  1312. CXTPRibbonTab* pSlectedTab = GetSelectedTab();
  1314. if (IsGroupsVisible())
  1315. {
  1316. GetRibbonPaintManager()->FillGroupRect(pDC, pSlectedTab, m_rcGroups);
  1317. }
  1319. GetTabPaintManager()->m_bDrawTextHidePrefix = !IsKeyboardCuesVisible();
  1321. if (m_pControlTab && CRect().IntersectRect(rcClipBox, m_rcTabControl))
  1322. {
  1323. GetTabPaintManager()->DrawTabControl(m_pControlTab, pDC, m_rcTabControl);
  1324. }
  1326. int i;
  1328. if (pSlectedTab && IsGroupsVisible())
  1329. {
  1330. CXTPRibbonGroups* pGroups = pSlectedTab->GetGroups();
  1331. for (i = 0; i < pGroups->GetCount(); i++)
  1332. {
  1333. CXTPRibbonGroup* pGroup = pGroups->GetAt(i);
  1335. if (pGroup->IsVisible() && CRect().IntersectRect(rcClipBox, pGroup->GetRect()))
  1336. {
  1337. pGroup->Draw(pDC, rcClipBox);
  1338. }
  1339. }
  1340. }
  1342. BOOL bFirst = TRUE;
  1344. for (i = 0; i < GetControlCount(); i++)
  1345. {
  1346. CXTPControl* pControl = GetControl(i);
  1347. if (!pControl->IsVisible())
  1348. continue;
  1350. if (pControl->GetRibbonGroup() != NULL)
  1351. continue;
  1353. if (pControl->GetBeginGroup() && !bFirst)
  1354. {
  1355. pPaintManager->DrawCommandBarSeparator(pDC, this, pControl);
  1356. }
  1357. bFirst = FALSE;
  1358. CRect rc(pControl->GetRect());
  1360. if (CRect().IntersectRect(rcClipBox, rc))
  1361. {
  1362. CXTPFontDC font(pDC, pPaintManager->GetCommandBarFont(this, pControl->IsItemDefault()));
  1363. pControl->Draw(pDC);
  1364. }
  1365. }
  1368. CXTPCommandBars* pCommandBars = GetCommandBars();
  1370. if (pCommandBars && pCommandBars->IsCustomizeMode())
  1371. {
  1372. if (pCommandBars->GetDragControl() && pCommandBars->GetDragControl()->GetParent() == this &&
  1373. pCommandBars->GetDragControl()->IsVisible())
  1374. {
  1375. CRect rc = pCommandBars->GetDragControl()->GetRect();
  1376. pDC->Draw3dRect(rc, 0, 0);
  1377. rc.DeflateRect(1, 1);
  1378. pDC->Draw3dRect(rc, 0, 0);
  1379. }
  1381. if (!m_rcMarker.IsRectEmpty())
  1382. {
  1383. CustomizeDrawMarker(pDC);
  1384. }
  1385. }
  1386. #if 0
  1387. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceEnd);
  1388. TRACE(_T("TotalCounter = %i n"), int(nPerfomanceEnd - nPerfomanceStart));
  1389. #endif
  1390. }
  1392. void CXTPRibbonBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  1393. {
  1394. int nHit = HitTestCaption(point);
  1396. if ((nHit == HTNOWHERE) && IsFrameThemeEnabled() && m_pContextHeaders->HitTest(point))
  1397. nHit = HTCAPTION;
  1399. if (nHit == HTCAPTION)
  1400. {
  1401. CWnd* pSite = GetSite();
  1402. ClientToScreen(&point);
  1404. ::DefWindowProc(pSite->GetSafeHwnd(), WM_NCLBUTTONDBLCLK, nHit, MAKELPARAM(point.x, point.y));
  1405. return;
  1406. }
  1408. CXTPTabManagerItem* pItem = m_pControlTab->HitTest(point);
  1409. if (pItem && pItem == GetSelectedTab() && m_bAllowMinimize)
  1410. {
  1411. if (IsRibbonMinimized())
  1412. {
  1413. SetRibbonMinimized(FALSE);
  1414. }
  1415. else if (m_bMinimizeOnDblClick)
  1416. {
  1417. SetRibbonMinimized(TRUE);
  1418. }
  1419. m_bMinimizeOnDblClick = TRUE;
  1420. }
  1422. CXTPMenuBar::OnLButtonDblClk(nFlags, point);
  1423. }
  1425. int CXTPRibbonBar::HitTestCaption(CPoint point) const
  1426. {
  1427. if (IsCustomizeMode())
  1428. return HTNOWHERE;
  1430. if (!IsFrameThemeEnabled())
  1431. return HTNOWHERE;
  1433. if (m_rcCaption.PtInRect(point) && m_pControls->HitTest(point) == 0)
  1434. {
  1435. if (m_pContextHeaders->HitTest(point))
  1436. return HTNOWHERE;
  1438. DWORD dwStyle = GetSite()->GetStyle();
  1440. if ((point.y < m_rcCaption.top + 5) && (dwStyle & WS_SIZEBOX) && ((dwStyle & WS_MAXIMIZE) == 0))
  1441. return HTTOP;
  1443. return HTCAPTION;
  1444. }
  1445. return HTNOWHERE;
  1446. }
  1448. BOOL CXTPRibbonBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1449. {
  1450. CPoint pt;
  1451. GetCursorPos(&pt);
  1452. ScreenToClient(&pt);
  1453. int nHit = HitTestCaption(pt);
  1455. if (nHit >= HTSIZEFIRST && nHit <= HTSIZELAST)
  1456. {
  1457. CWnd* pSite = GetSite();
  1458. pSite->SendMessage(WM_SETCURSOR, (WPARAM)pSite->m_hWnd, MAKELPARAM(nHit, message));
  1459. return TRUE;
  1461. }
  1463. return CXTPMenuBar::OnSetCursor(pWnd, nHitTest, message);
  1464. }
  1466. void CXTPRibbonBar::OnLButtonDown(UINT nFlags, CPoint point)
  1467. {
  1468. m_bMinimizeOnDblClick = m_pControlTab->HitTest(point) == GetSelectedTab();
  1470. if (m_bMinimizeOnDblClick && IsRibbonMinimized() && !m_pControlTab->IsPopupBarTracking())
  1471. m_bMinimizeOnDblClick = FALSE;
  1473. CXTPRibbonTabContextHeader* pContextHeader = m_pContextHeaders->HitTest(point);
  1474. if (pContextHeader)
  1475. {
  1476. pContextHeader->m_pFirstTab->Select();
  1477. return;
  1478. }
  1480. int nHit = HitTestCaption(point);
  1482. if (nHit != HTNOWHERE)
  1483. {
  1484. CWnd* pSite = GetSite();
  1485. ClientToScreen(&point);
  1487. GetCommandBars()->ClosePopups();
  1488. UpdateWindow();
  1490. if (pSite->GetStyle() & WS_MAXIMIZE)
  1491. return;
  1493. if (nHit == HTCAPTION)
  1494. {
  1495. ::DefWindowProc(pSite->GetSafeHwnd(), WM_NCLBUTTONDOWN, HTCAPTION, MAKELPARAM(point.x, point.y));
  1496. }
  1497. else if (nHit >= HTSIZEFIRST && nHit <= HTSIZELAST)
  1498. {
  1499. ::DefWindowProc(pSite->GetSafeHwnd(), WM_NCLBUTTONDOWN, nHit, MAKELPARAM(point.x, point.y));
  1500. }
  1501. return;
  1502. }
  1504. if (m_rcTabControl.PtInRect(point))
  1505. {
  1506. GetCommandBars()->ClosePopups();
  1507. }
  1509. if (m_bMinimizeOnDblClick)
  1510. {
  1512. CXTPMenuBar::OnLButtonDown(nFlags, point);
  1513. return;
  1514. }
  1516. if (!m_pControlTab->PerformClick(m_hWnd, point))
  1517. {
  1518. CXTPMenuBar::OnLButtonDown(nFlags, point);
  1519. return;
  1520. }
  1521. else if (IsRibbonMinimized())
  1522. {
  1523. m_pControlTab->ShowPopupBar(FALSE);
  1524. m_bMinimizeOnDblClick = TRUE;
  1526. }
  1527. }
  1529. BOOL CXTPRibbonBar::IsRibbonMinimized() const
  1530. {
  1531. return m_bMinimized;
  1532. }
  1534. void CXTPRibbonBar::SetRibbonMinimized(BOOL bMinimized)
  1535. {
  1536. if (m_bMinimized != bMinimized)
  1537. {
  1538. m_bMinimized = bMinimized;
  1540. if (!m_bMinimized && GetSelectedTab() == NULL)
  1541. {
  1542. m_pControlTab->SetSelectedItem(m_pControlTab->FindNextFocusable(-1, +1));
  1543. }
  1545. RebuildControls(GetSelectedTab());
  1547. //m_pControlTab->RedrawControl(NULL, TRUE);
  1549. OnRecalcLayout();
  1551. GetCommandBars()->ClosePopups();
  1552. }
  1553. }
  1555. void CXTPRibbonBar::OnPopupRButtonUp(CXTPCommandBar* pCommandBar, CPoint point)
  1556. {
  1557. if (!m_bShowQuickAccess)
  1558. return;
  1560. CXTPPopupBar* pPopupBar = DYNAMIC_DOWNCAST(CXTPPopupBar, pCommandBar);
  1561. if (pPopupBar && pPopupBar->GetControlPopup())
  1562. {
  1563. if (pPopupBar->GetControlPopup()->GetID() == XTP_ID_RIBBONCONTROLQUICKACCESS ||
  1564. pPopupBar->GetControlPopup()->GetID() == XTP_ID_RIBBONCONTROLQUICKACCESSMORE)
  1565. return;
  1566. }
  1568. pCommandBar->SetPopuped(-1, FALSE);
  1570. CXTPControl* pControl = pCommandBar->GetControls()->HitTest(point);
  1571. if (pControl)
  1572. {
  1573. ShowContextMenu(point, pControl);
  1574. return;
  1575. }
  1577. CXTPRibbonScrollableBar* pScrollable = GetScrollableBar(pCommandBar);
  1578. if (pScrollable)
  1579. {
  1580. CXTPRibbonGroup* pGroup = pScrollable->HitTestGroup(point);
  1581. if (pGroup && pGroup->GetRect().bottom - GetRibbonPaintManager()->m_nGroupCaptionHeight < point.y)
  1582. {
  1583. ShowContextMenu(point, pGroup->GetControlGroupPopup());
  1584. return;
  1585. }
  1586. }
  1587. }
  1589. void CXTPRibbonBar::OnRButtonUp(UINT nFlags, CPoint point)
  1590. {
  1591. int nHit = HitTestCaption(point);
  1593. if (nHit == HTCAPTION)
  1594. {
  1595. GetCommandBars()->ClosePopups();
  1596. UpdateWindow();
  1598. CWnd* pSite = GetSite();
  1599. ClientToScreen(&point);
  1600. pSite->SendMessage(0x0313, (WPARAM)pSite->GetSafeHwnd(), MAKELPARAM(point.x, point.y));
  1601. return;
  1602. }
  1604. if (IsCustomizeMode())
  1605. return;
  1607. CXTPControl* pControl = m_pControls->HitTest(point);
  1609. if (pControl && GetSite()->SendMessage(WM_XTP_CONTROLRBUTTONUP, (WPARAM)(LPPOINT)&point, (LPARAM)pControl) == TRUE)
  1610. return;
  1612. if (pControl && pControl->OnRButtonUp(point))
  1613. return;
  1615. if (pControl)
  1616. {
  1617. ShowContextMenu(point, pControl);
  1618. return;
  1619. }
  1621. CXTPRibbonGroup* pGroup = HitTestGroup(point);
  1622. if (pGroup && pGroup->GetRect().bottom - GetRibbonPaintManager()->m_nGroupCaptionHeight < point.y)
  1623. {
  1624. ShowContextMenu(point, pGroup->GetControlGroupPopup());
  1625. return;
  1626. }
  1628. if (m_rcQuickAccess.PtInRect(point))
  1629. {
  1630. ShowContextMenu(point, m_pControlTab);
  1631. return;
  1632. }
  1634. CWnd::OnRButtonUp(nFlags, point);
  1635. }
  1638. void CXTPRibbonBar::OnSysColorChange()
  1639. {
  1640. CXTPMenuBar::OnSysColorChange();
  1642. GetRibbonPaintManager()->RefreshMetrics();
  1643. m_pControlTab->Reposition();
  1644. }
  1646. void CXTPRibbonBar::RefreshSysButtons()
  1647. {
  1648. CXTPMenuBar::RefreshSysButtons();
  1650. if (IsFrameThemeEnabled())
  1651. {
  1652. CString strWindowText;
  1653. GetSite()->GetWindowText(strWindowText);
  1655. if (strWindowText != m_strCaptionText)
  1656. DelayLayout();
  1657. }
  1658. }
  1660. INT_PTR CXTPRibbonBar::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1661. {
  1662. INT_PTR nHit = m_pControlTab ? m_pControlTab->PerformToolHitTest(m_hWnd, point, pTI) : -1;
  1663. if (nHit != -1)
  1664. return nHit;
  1666. nHit = CXTPMenuBar::OnToolHitTest(point, pTI);
  1667. if (nHit == -1)
  1668. return -1;
  1670. if (pTI != NULL && pTI->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX) && m_pToolTipContext
  1671. && m_pToolTipContext->IsShowTitleAndDescription())
  1672. {
  1673. XTP_TOOLTIP_CONTEXT* tc = ((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo;
  1674. if (tc && tc->pObject && ((CXTPControl*)tc->pObject)->GetRibbonGroup())
  1675. {
  1676. tc->rcExclude = m_rcGroups;
  1677. }
  1678. }
  1680. return nHit;
  1681. }
  1683. CXTPRibbonGroup* CXTPRibbonBar::HitTestGroup(CPoint point) const
  1684. {
  1685. CXTPRibbonTab* pTab = GetSelectedTab();
  1686. if (!pTab)
  1687. return NULL;
  1689. if (!IsGroupsVisible())
  1690. return NULL;
  1692. if (!m_rcGroups.PtInRect(point))
  1693. return NULL;
  1695. if (m_pControlScrollGroupsLeft && m_pControlScrollGroupsLeft->IsVisible() &&
  1696. m_pControlScrollGroupsLeft->GetRect().PtInRect(point))
  1697. return NULL;
  1699. if (m_pControlScrollGroupsRight && m_pControlScrollGroupsRight->IsVisible() &&
  1700. m_pControlScrollGroupsRight->GetRect().PtInRect(point))
  1701. return NULL;
  1703. return pTab->GetGroups()->HitTest(point);
  1704. }
  1706. BOOL CXTPRibbonBar::IsDwmEnabled() const
  1707. {
  1708. return m_pFrameHook && m_pFrameHook->IsDwmEnabled();
  1709. }
  1711. LRESULT CXTPRibbonBar::OnNcHitTest(CPoint point)
  1712. {
  1713. if (IsDwmEnabled())
  1714. {
  1715. LRESULT lResult = 0;
  1716. CXTPWinDwmWrapper().DefWindowProc(GetSite()->GetSafeHwnd(), WM_NCHITTEST, 0, MAKELPARAM(point.x, point.y), &lResult);
  1718. if (lResult == HTMINBUTTON || lResult == HTMAXBUTTON || lResult == HTCLOSE || lResult == HTHELP)
  1719. {
  1720. return HTTRANSPARENT;
  1721. }
  1722. }
  1724. return CXTPMenuBar::OnNcHitTest(point);
  1725. }
  1727. void CXTPRibbonBar::OnMouseMove(UINT nFlags, CPoint point)
  1728. {
  1729. CXTPCommandBars* pCommandBars = GetCommandBars ();
  1730. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  1732. BOOL bMouseLocked = pMouseManager->IsMouseLocked() || !pMouseManager->IsTopParentActive(m_hWnd)
  1733. || pMouseManager->IsTrackedLock(this) || m_nPopuped != -1;
  1735. CXTPRibbonGroup* pHighlightedGroup = bMouseLocked || !GetRibbonPaintManager()->m_bHotTrackingGroups ?
  1736. NULL : HitTestGroup(point);
  1738. if (pHighlightedGroup != m_pHighlightedGroup)
  1739. {
  1740. HighlightGroup(pHighlightedGroup);
  1742. if (m_pHighlightedGroup)
  1743. {
  1744. pMouseManager->TrackMouseLeave(*this);
  1745. }
  1746. }
  1748. if (!bMouseLocked && m_pControlTab)
  1749. {
  1750. m_pControlTab->PerformMouseMove(m_hWnd, point);
  1751. }
  1753. CXTPMenuBar::OnMouseMove(nFlags, point);
  1754. }
  1756. void CXTPRibbonBar::OnMouseLeave()
  1757. {
  1758. if (m_pControlTab) m_pControlTab->PerformMouseMove(m_hWnd, CPoint(-1, -1));
  1760. HighlightGroup(NULL);
  1762. CXTPMenuBar::OnMouseLeave();
  1763. }
  1765. CXTPRibbonTab* CXTPRibbonBar::GetTab(int nIndex) const
  1766. {
  1767. return (CXTPRibbonTab*)m_pControlTab->GetItem(nIndex);
  1768. }
  1770. int CXTPRibbonBar::GetTabCount() const
  1771. {
  1772. return m_pControlTab->GetItemCount();
  1773. }
  1777. BOOL CXTPRibbonBar::PreviewAccel(UINT chAccel)
  1778. {
  1779. if (GetKeyState(VK_CONTROL) < 0)
  1780. return FALSE;
  1782. CXTPCommandBars* pCommandBars = GetCommandBars();
  1784. if (chAccel == (UINT)VK_MENU && GetTabCount() > 0)
  1785. {
  1786. pCommandBars->ClosePopups();
  1787. pCommandBars->ShowKeyboardCues(TRUE);
  1788. pCommandBars->m_keyboardTips.nLevel = 1;
  1790. if (IsRibbonMinimized())
  1791. {
  1792. SetTrackingMode(TRUE, TRUE, TRUE);
  1793. }
  1794. else
  1795. {
  1796. SetTrackingMode(TRUE, FALSE, TRUE);
  1798. SetSelected(m_pControlTab->GetIndex(), TRUE);
  1799. m_pControlTab->SetFocused(TRUE);
  1800. }
  1802. return TRUE;
  1803. }
  1805. if (chAccel > '0' && chAccel <= '9')
  1806. {
  1807. int nIndex = chAccel - '0' - 1;
  1808. CXTPControl* pControl = m_pQuickAccessControls->GetVisibleAt(nIndex);
  1810. if (pControl && pControl->GetEnabled())
  1811. {
  1812. nIndex = pControl->GetIndex();
  1814. pCommandBars->ClosePopups();
  1815. pCommandBars->ShowKeyboardCues(TRUE);
  1816. pCommandBars->m_keyboardTips.nLevel = 2;
  1818. SetTrackingMode(TRUE, FALSE, TRUE);
  1819. SetSelected(nIndex, TRUE);
  1821. pControl->OnUnderlineActivate();
  1823. return TRUE;
  1824. }
  1825. }
  1827. for (int i = 0; i < GetTabCount(); i++)
  1828. {
  1829. CXTPRibbonTab* pTab = GetTab(i);
  1831. CString strCaption = pTab->GetCaption();
  1832. if (!strCaption.IsEmpty() && pTab->IsEnabled() && pTab->IsVisible())
  1833. {
  1834. int nAmpIndex = strCaption.Find(_T('&'));
  1835. BOOL bFound = nAmpIndex > -1 && nAmpIndex < strCaption.GetLength() - 1;
  1837. if (bFound && CXTPShortcutManager::CompareAccelKey(strCaption[nAmpIndex + 1], chAccel))
  1838. {
  1840. if (!IsTrackingMode())
  1841. pCommandBars->ClosePopups();
  1843. pCommandBars->ShowKeyboardCues(TRUE);
  1845. m_bKeyboardSelect = TRUE;
  1846. pCommandBars->m_keyboardTips.nLevel = 1;
  1847. SetCurSel(i);
  1849. SetTrackingMode(TRUE, FALSE, TRUE);
  1850. SetSelected(m_pControlTab->GetIndex(), TRUE);
  1851. m_pControlTab->SetFocused(TRUE);
  1853. if (!IsRibbonMinimized()) pCommandBars->ShowKeyboardTips(this, 2);
  1855. m_pControlTab->ShowPopupBar(TRUE);
  1857. return TRUE;
  1858. }
  1859. }
  1860. }
  1862. return FALSE;
  1863. }
  1865. BOOL CXTPRibbonBar::IsKeyboardCuesVisible() const
  1866. {
  1867. CXTPCommandBars* pCommandBars = GetCommandBars();
  1868. if (!pCommandBars)
  1869. return TRUE;
  1871. if (pCommandBars->GetCommandBarsOptions()->bShowKeyboardTips)
  1872. return FALSE;
  1874. return pCommandBars->m_bKeyboardCuesVisible;
  1875. }
  1877. BOOL CXTPRibbonBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  1878. {
  1879. m_pControlTab->PerformMouseMove(m_hWnd, CPoint(-1, -1));
  1881. if (m_bTracking || bMode) HighlightGroup(NULL);
  1883. return CXTPMenuBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard);
  1884. }
  1886. BOOL CXTPRibbonBar::IsAllowQuickAccessControl(CXTPControl* pControl)
  1887. {
  1888. if (!pControl)
  1889. return FALSE;
  1891. if (!m_bAllowQuickAccessDuplicates)
  1892. {
  1893. CXTPControl* pControlQuickAccess = m_pQuickAccessControls->FindDuplicate(pControl);
  1894. if (pControlQuickAccess)
  1895. {
  1896. return FALSE;
  1897. }
  1898. }
  1900. if (pControl->IsKindOf(RUNTIME_CLASS(CXTPRibbonGroupControlPopup)))
  1901. {
  1902. return pControl->GetID() > 0;
  1903. }
  1905. if ((pControl->GetFlags() & xtpFlagNoMovable) == 0)
  1906. return TRUE;
  1908. return FALSE;
  1909. }
  1911. void CXTPRibbonBar::ShowContextMenu(CPoint point, CXTPControl* pSelectedControl)
  1912. {
  1913. if (!pSelectedControl)
  1914. return;
  1916. pSelectedControl->GetParent()->ClientToScreen(&point);
  1918. CXTPPopupBar* pPopupBar = CreateContextMenu(pSelectedControl);
  1919. if (!pPopupBar)
  1920. return;
  1922. CWnd* pSite = m_bShowQuickAccess ? this : GetOwnerSite();
  1924. CXTPMouseManager* pMouseManager = XTPMouseManager();
  1926. if (pPopupBar->GetControls()->GetVisibleCount() > 0)
  1927. {
  1928. BOOL bLocked = pMouseManager->IsMouseLocked();
  1929. if (bLocked) pMouseManager->UnlockMouseMove();
  1931. CXTPCommandBars::TrackPopupMenu(pPopupBar, TPM_RIGHTBUTTON | (pSelectedControl->GetParent() == this ? 0 : TPM_RECURSE),
  1932. point.x, point.y, pSite, NULL, pSite);
  1934. if (bLocked) pMouseManager->LockMouseMove();
  1935. }
  1937. pPopupBar->InternalRelease();
  1938. }
  1940. CXTPPopupBar* CXTPRibbonBar::CreateMoreQuickAccessContextMenu()
  1941. {
  1942. CXTPPopupBar* pPopupBar = new CXTPRibbonBarMorePopupToolBar(this);
  1944. for (int i = 0; i < m_pQuickAccessControls->GetCount(); i++)
  1945. {
  1946. CXTPControl* pControl = m_pQuickAccessControls->GetAt(i);
  1947. if (pControl->GetHideFlags() & xtpHideWrap)
  1948. {
  1949. CXTPControl* pClone = pPopupBar->GetControls()->AddClone(pControl);
  1950. pClone->SetHideFlag(xtpHideWrap, FALSE);
  1951. }
  1952. }
  1954. CXTPControl* pClone = pPopupBar->GetControls()->AddClone(m_pControlQuickAccess);
  1955. pClone->SetHideFlag(xtpHideWrap, FALSE);
  1957. pPopupBar->SetWidth(300);
  1959. return pPopupBar;
  1960. }
  1963. CXTPPopupBar* CXTPRibbonBar::CreateContextMenu(CXTPControl* pSelectedControl)
  1964. {
  1965. if (!m_bShowQuickAccess)
  1966. {
  1967. CXTPPopupBar* pPopupBar = GetCommandBars()->GetToolbarsPopup();
  1968. GetSite()->SendMessage(WM_XTP_TOOLBARCONTEXTMENU, (WPARAM)this, (LPARAM)pPopupBar);
  1969. return pPopupBar;
  1970. }
  1972. if (!pSelectedControl)
  1973. return NULL;
  1975. if (pSelectedControl->GetType() == xtpControlGallery &&
  1976. ((CXTPControlPopup*)pSelectedControl)->GetCommandBar() == NULL &&
  1977. DYNAMIC_DOWNCAST(CXTPPopupBar, pSelectedControl->GetParent()))
  1978. {
  1979. pSelectedControl = ((CXTPPopupBar*)pSelectedControl->GetParent())->GetControlPopup();
  1980. }
  1981. CXTPCommandBars* pCommandBars = GetCommandBars();
  1983. BOOL bMoreMenu = pSelectedControl->GetID() == XTP_ID_RIBBONCONTROLQUICKACCESS;
  1985. CMenu menu;
  1986. if (!XTPResourceManager()->LoadMenu(&menu, bMoreMenu ? XTP_IDR_RIBBONCUSTOMIZEMENUMORE : XTP_IDR_RIBBONCUSTOMIZEMENU))
  1987. return NULL;
  1989. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(pCommandBars);
  1990. pPopupBar->SetOwner(this);
  1991. pPopupBar->LoadMenu(menu.GetSubMenu(0));
  1993. CXTPControl* pControlToolbars = pPopupBar->GetControls()->InsertAt(new CXTPControlToolbars, bMoreMenu ? 0 : 2);
  1994. pControlToolbars->SetBeginGroup(TRUE);
  1996. BOOL bQuickAccess = IsQuickAccessControl(pSelectedControl);
  1998. BOOL bAllow = IsAllowQuickAccessControl(pSelectedControl);
  1999. BOOL bSystem = (pSelectedControl->GetFlags() & xtpFlagNoMovable) || pSelectedControl->IsTemporary();
  2001. for (int i = 0; i < pPopupBar->GetControlCount(); i++)
  2002. {
  2003. CXTPControl* pControl = pPopupBar->GetControl(i);
  2005. if (pControl->GetID() == XTP_ID_RIBBONCUSTOMIZE_MORE)
  2006. pControl->SetID(XTP_ID_RIBBONCUSTOMIZE);
  2008. if (pControl->GetID() == XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSBELOW_MORE)
  2009. pControl->SetID(XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSBELOW);
  2011. if (pControl->GetID() == XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSABOVE_MORE)
  2012. pControl->SetID(XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSABOVE);
  2014. switch(pControl->GetID())
  2015. {
  2016. case XTP_ID_RIBBONCUSTOMIZE_REMOVE:
  2017. pControl->SetVisible(bQuickAccess && !bSystem && m_bAllowQuickAccessCustomization);
  2018. pControl->SetTag((DWORD_PTR)pSelectedControl);
  2019. break;
  2021. case XTP_ID_RIBBONCUSTOMIZE_ADD:
  2022. pControl->SetVisible(!bQuickAccess && !bSystem && m_bAllowQuickAccessCustomization);
  2023. pControl->SetEnabled(bAllow);
  2024. pControl->SetTag((DWORD_PTR)pSelectedControl);
  2025. break;
  2027. case XTP_ID_RIBBONCUSTOMIZE:
  2028. if (!m_bAllowQuickAccessCustomization)
  2029. {
  2030. if (pCommandBars->IsCustomizeAvail())
  2031. pControl->SetCaption(XTP_IDS_CUSTOMIZE);
  2032. else
  2033. pControl->SetVisible(FALSE);
  2034. }
  2035. break;
  2037. case XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSBELOW:
  2038. pControl->SetVisible(m_bShowQuickAccess && !m_bShowQuickAccessBelow);
  2039. break;
  2041. case XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSABOVE:
  2042. pControl->SetVisible(m_bShowQuickAccess && m_bShowQuickAccessBelow);
  2043. break;
  2045. case XTP_ID_RIBBONCUSTOMIZE_LABEL:
  2046. pControl = pPopupBar->GetControls()->SetControlType(i, xtpControlLabel);
  2047. pControl->SetFlags(xtpFlagSkipFocus);
  2048. pControl->SetItemDefault(TRUE);
  2049. pControl->SetVisible(m_bAllowQuickAccessCustomization && GetQuickAccessControls()->GetOriginalControls());
  2050. break;
  2052. case XTP_ID_RIBBONCUSTOMIZE_MINIMIZE:
  2053. pControl->SetVisible(m_bAllowMinimize);
  2054. pControl->SetChecked(m_bMinimized);
  2055. if (GetTabCount() == 0)
  2056. pControl->SetEnabled(FALSE);
  2057. break;
  2059. case XTP_ID_RIBBONCUSTOMIZE_COMMANDS:
  2060. {
  2061. pControl->SetHideFlags(xtpHideGeneric);
  2062. CXTPControls* pCommands = GetQuickAccessControls()->GetOriginalControls();
  2063. if (!pCommands)
  2064. continue;
  2066. if (!m_bAllowQuickAccessCustomization)
  2067. continue;
  2069. for (int j = 0; j < pCommands->GetCount(); j++)
  2070. {
  2071. CXTPControl* pControlOriginal = pCommands->GetAt(j);
  2073. CControlQuickAccessCommand* pControlCommand = new CControlQuickAccessCommand(GetQuickAccessControls(), pControlOriginal);
  2074. pPopupBar->GetControls()->Add(pControlCommand, 0, NULL, i, TRUE);
  2075. pControlCommand->SetCaption(pControlOriginal->GetCaption());
  2077. CXTPControl* pControlQuickAccess = GetQuickAccessControls()->FindDuplicate(pControlOriginal);
  2078. if (pControlQuickAccess)
  2079. {
  2080. pControlCommand->SetQuickAccessControl(pControlQuickAccess);
  2081. }
  2083. i++;
  2084. }
  2086. }
  2087. break;
  2089. default:
  2090. continue;
  2091. }
  2092. pControl->SetFlags(pControl->GetFlags() | xtpFlagManualUpdate);
  2093. }
  2095. GetSite()->SendMessage(WM_XTP_TOOLBARCONTEXTMENU, (WPARAM)this, (LPARAM)pPopupBar);
  2097. return pPopupBar;
  2098. }
  2100. void CXTPRibbonBar::SelectNextTab(BOOL bNext)
  2101. {
  2102. m_pControlTab->PerformKeyDown(m_hWnd, !bNext ? VK_LEFT : VK_RIGHT);
  2103. }
  2105. int CXTPRibbonBar::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  2106. {
  2107. if (IsTrackingMode() && nMessage == WM_CONTEXTMENU)
  2108. {
  2109. if (lParam != -1)
  2110. return TRUE;
  2112. CXTPControl* pControl = GetControl(m_nSelected);
  2113. if (!pControl)
  2114. return TRUE;
  2116. ShowContextMenu(pControl->GetRect().TopLeft(), pControl);
  2117. return TRUE;
  2118. }
  2120. if (IsTrackingMode() && nMessage == WM_MOUSEWHEEL && !GetCommandBars()->GetMouseManager()->IsMouseLocked()
  2121. && !IsKeyboardTipsVisible())
  2122. {
  2123. SelectNextTab((short)HIWORD(wParam) <= 0);
  2124. return TRUE;
  2125. }
  2127. return CXTPMenuBar::OnHookMessage(hWnd, nMessage, wParam, lParam, lResult);
  2128. }
  2131. void CXTPRibbonBar::OnRButtonDown(UINT nFlags, CPoint point)
  2132. {
  2133. CXTPCommandBars* pCommandBars = GetCommandBars();
  2134. if (!pCommandBars) return;
  2136. if (IsCustomizeMode())
  2137. {
  2138. CXTPCommandBar::OnRButtonDown(nFlags, point);
  2139. return;
  2140. }
  2142. SetTrackingMode(FALSE);
  2144. int nHit = HitTestCaption(point);
  2145. if (nHit != HTNOWHERE)
  2146. return;
  2148. CXTPControl* pControl = m_pControls->HitTest(point);
  2150. if (pControl && pControl->OnRButtonDown(point))
  2151. return;
  2152. }
  2154. void CXTPRibbonBar::OnCustomizePlaceQuickAccess(UINT nCommand)
  2155. {
  2156. GetCommandBars()->ClosePopups();
  2157. ShowQuickAccessBelowRibbon(nCommand == XTP_ID_RIBBONCUSTOMIZE_QUICKACCESSBELOW);
  2158. }
  2160. LRESULT CXTPRibbonBar::OnCustomizeCommand(WPARAM wParam, LPARAM lParam)
  2161. {
  2162. NMXTPCONTROL* tagNMCONTROL = (NMXTPCONTROL*)lParam;
  2163. CXTPControl* pControl = (CXTPControl*)tagNMCONTROL->pControl->GetTag();
  2165. if (wParam == XTP_ID_RIBBONCUSTOMIZE_ADD)
  2166. {
  2167. GetCommandBars()->ClosePopups();
  2169. m_bInRecalcLayout = TRUE;
  2170. pControl = m_pQuickAccessControls->AddClone(pControl, -1, TRUE);
  2172. pControl->SetBeginGroup(FALSE);
  2173. pControl->SetVisible(TRUE);
  2175. if (pControl->GetType() == xtpControlGallery || pControl->GetType() == xtpControlPopup)
  2176. pControl->SetStyle(xtpButtonIcon);
  2177. else
  2178. pControl->SetStyle(xtpButtonAutomatic);
  2180. m_bInRecalcLayout = FALSE;
  2182. OnRecalcLayout();
  2184. return TRUE;
  2185. }
  2187. if (wParam == XTP_ID_RIBBONCUSTOMIZE_REMOVE)
  2188. {
  2189. m_pQuickAccessControls->Remove(pControl);
  2190. OnRecalcLayout();
  2192. return TRUE;
  2193. }
  2195. if (wParam == XTP_ID_RIBBONCUSTOMIZE)
  2196. {
  2197. GetCommandBars()->ClosePopups();
  2198. CWnd* pOwner = GetOwnerSite();
  2200. if (pOwner->SendMessage(WM_XTP_COMMAND, wParam, lParam) == 0)
  2201. {
  2202. pOwner->SendMessage(WM_COMMAND, wParam);
  2203. }
  2205. return TRUE;
  2206. }
  2208. if (wParam == XTP_ID_RIBBONCUSTOMIZE_MINIMIZE)
  2209. {
  2210. SetRibbonMinimized(!IsRibbonMinimized());
  2211. return TRUE;
  2212. }
  2215. return FALSE;
  2216. }
  2218. BOOL CXTPRibbonBar::ShouldSerializeBar()
  2219. {
  2220. return TRUE;
  2221. }
  2223. void CXTPRibbonBar::GenerateCommandBarList(DWORD& nID, CXTPCommandBarList* pCommandBarList, XTP_COMMANDBARS_PROPEXCHANGE_PARAM* pParam)
  2224. {
  2225. if (IsCustomizable())
  2226. {
  2227. CXTPMenuBar::GenerateCommandBarList(nID, pCommandBarList, pParam);
  2228. }
  2229. else
  2230. {
  2231. if (!pCommandBarList->Lookup(this))
  2232. {
  2233. pCommandBarList->Add(this);
  2234. InternalAddRef();
  2236. ASSERT(m_nBarID != 0);
  2238. m_pQuickAccessControls->GenerateCommandBarList(nID, pCommandBarList, pParam);
  2239. }
  2240. }
  2241. }
  2243. void CXTPRibbonBar::RestoreCommandBarList(CXTPCommandBarList* pCommandBarList)
  2244. {
  2245. if (IsCustomizable())
  2246. {
  2247. CXTPMenuBar::RestoreCommandBarList(pCommandBarList);
  2248. }
  2249. else
  2250. {
  2251. m_pQuickAccessControls->RestoreCommandBarList(pCommandBarList);
  2252. }
  2253. }
  2255. void CXTPRibbonBar::DoPropExchange(CXTPPropExchange* pPX)
  2256. {
  2257. if (pPX->IsLoading())
  2258. {
  2259. ASSERT(pPX->m_dwData != 0);
  2260. if (pPX->m_dwData) SetCommandBars(((XTP_COMMANDBARS_PROPEXCHANGE_PARAM*)pPX->m_dwData)->pCommandBars);
  2261. }
  2263. PX_Bool(pPX, _T("ShowQuickAccessBelow"), m_bShowQuickAccessBelow, FALSE);
  2265. if (pPX->GetSchema() > _XTP_SCHEMA_103)
  2266. PX_Bool(pPX, _T("Minimized"), m_bMinimized, FALSE);
  2268. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  2269. PX_Bool(pPX, _T("Customizable"), m_bCustomizable, FALSE);
  2271. if (IsCustomizable())
  2272. {
  2273. CXTPMenuBar::DoPropExchange(pPX);
  2275. CXTPPropExchangeSection secSystemButton(pPX->GetSection(_T("SystemButton")));
  2276. BOOL bSystemButton = m_pControlSystemButton != NULL;
  2277. PX_Bool(&secSystemButton, _T("SystemButton"), bSystemButton, TRUE);
  2279. if (bSystemButton && pPX->IsLoading())
  2280. {
  2281. GetControls()->Remove(m_pControlSystemButton);
  2282. m_pControlSystemButton = NULL;
  2283. PX_Object(&secSystemButton, m_pControlSystemButton, RUNTIME_CLASS(CXTPRibbonControlSystemButton));
  2284. GetControls()->InsertAt(m_pControlSystemButton, 0);
  2285. }
  2286. else if (bSystemButton && pPX->IsStoring())
  2287. {
  2288. PX_Object(&secSystemButton, m_pControlSystemButton, RUNTIME_CLASS(CXTPRibbonControlSystemButton));
  2289. }
  2291. CXTPPropExchangeSection secTabs(pPX->GetSection(_T("Tabs")));
  2292. m_pControlTab->DoPropExchange(&secTabs);
  2294. }
  2296. CXTPPropExchangeSection secControls(pPX->GetSection(_T("QuickAccessControls")));
  2297. m_pQuickAccessControls->DoPropExchange(&secControls);
  2299. }
  2301. void CXTPRibbonBar::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive /*= FALSE*/)
  2302. {
  2303. CXTPRibbonBar* pRibbonBar = (CXTPRibbonBar*)pCommandBar;
  2305. m_bShowQuickAccessBelow = pRibbonBar->m_bShowQuickAccessBelow;
  2307. m_bMinimized = pRibbonBar->m_bMinimized;
  2309. if (m_bMinimized)
  2310. {
  2311. m_pControlTab->SetSelectedItem(NULL);
  2312. }
  2314. if (pRibbonBar->IsCustomizable())
  2315. {
  2316. CXTPMenuBar::Copy(pCommandBar, bRecursive);
  2318. m_pControlTab->Copy(pRibbonBar->m_pControlTab);
  2320. GetControls()->Remove(m_pControlSystemButton);
  2321. m_pControlSystemButton = NULL;
  2323. if (pRibbonBar->m_pControlSystemButton)
  2324. {
  2325. m_pControlSystemButton = (CXTPControlPopup*)GetControls()->AddClone(pRibbonBar->m_pControlSystemButton,
  2326. 0, TRUE);
  2327. }
  2328. RebuildControls(GetSelectedTab());
  2329. }
  2331. m_pQuickAccessControls->RemoveAll();
  2333. for (int i = 0; i < pRibbonBar->GetQuickAccessControls()->GetCount(); i++)
  2334. {
  2335. m_pQuickAccessControls->AddClone(pRibbonBar->GetQuickAccessControls()->GetAt(i), -1, FALSE);
  2336. }
  2337. }
  2339. void CXTPRibbonBar::MergeToolBar(CXTPCommandBar* pCommandBar, BOOL /*bSilent*/)
  2340. {
  2341. Copy(pCommandBar, FALSE);
  2342. }
  2344. CXTPRibbonTab* CXTPRibbonBar::FindTab(int nId) const
  2345. {
  2346. return m_pControlTab->FindTab(nId);
  2347. }
  2349. CXTPRibbonGroup* CXTPRibbonBar::FindGroup(int nId) const
  2350. {
  2351. for (int i = 0; i < GetTabCount(); i++)
  2352. {
  2353. CXTPRibbonTab* pTab = GetTab(i);
  2354. CXTPRibbonGroup* pGroup = pTab->FindGroup(nId);
  2356. if (pGroup)
  2357. return pGroup;
  2358. }
  2359. return NULL;
  2360. }
  2362. void CXTPRibbonBar::ShowQuickAccessBelowRibbon(BOOL bBelow)
  2363. {
  2364. m_bShowQuickAccessBelow = bBelow;
  2366. OnRecalcLayout();
  2368. if (IsDwmEnabled())
  2369. {
  2370. UpdateWindow();
  2371. m_pFrameHook->UpdateFrameRegion();
  2372. }
  2373. else if (IsFrameThemeEnabled())
  2374. {
  2375. m_pFrameHook->GetSite()->SendMessage(WM_NCPAINT);
  2376. }
  2377. }
  2379. BOOL CXTPRibbonBar::IsQuickAccessBelowRibbon() const
  2380. {
  2381. return m_bShowQuickAccessBelow;
  2382. }
  2384. void CXTPRibbonBar::RemoveAllTabs()
  2385. {
  2386. m_pControlTab->DeleteAllItems();
  2387. }
  2389. void CXTPRibbonBar::RemoveTab(int nIndex)
  2390. {
  2391. CXTPRibbonTab* pTab = GetTab(nIndex);
  2392. if (!pTab)
  2393. return;
  2395. pTab->Remove();
  2396. }
  2398. CSize CXTPRibbonBar::GetButtonSize() const
  2399. {
  2400. if (m_szButtons != CSize(0)) return m_szButtons;
  2402. int nHeight = GetPaintManager()->GetControlHeight();
  2403. return CSize(nHeight, nHeight);
  2404. }
  2406. void CXTPRibbonBar::SetFontHeight(int nFontHeight)
  2407. {
  2408. GetRibbonPaintManager()->SetFontHeight(nFontHeight);
  2410. OnRecalcLayout();
  2412. if (IsDwmEnabled())
  2413. {
  2414. UpdateWindow();
  2415. m_pFrameHook->UpdateFrameRegion();
  2416. }
  2417. if (m_pFrameHook)
  2418. {
  2419. m_pFrameHook->RedrawFrame();
  2420. }
  2421. }
  2423. int CXTPRibbonBar::GetFontHeight() const
  2424. {
  2425. return GetRibbonPaintManager()->GetFontHeight();
  2426. }
  2427. //////////////////////////////////////////////////////////////////////////
  2428. //////////////////////////////////////////////////////////////////////////
  2429. void CXTPRibbonBar::OnKeyboardTip(CXTPCommandBarKeyboardTip* pTip)
  2430. {
  2431. CXTPControl* pControl = DYNAMIC_DOWNCAST(CXTPControl, pTip->m_pOwner);
  2432. if (pControl)
  2433. {
  2435. if (pTip->m_bVisible == FALSE && pControl->GetHideFlags() == xtpHideWrap)
  2436. {
  2437. CXTPRibbonGroup* pGroup = pControl->GetRibbonGroup();
  2438. if (pGroup && pGroup->GetControlGroupPopup())
  2439. {
  2440. EnsureVisible(pGroup->GetControlGroupPopup());
  2441. pGroup->GetControlGroupPopup()->OnUnderlineActivate();
  2443. int nIndex = pGroup->IndexOf(pControl);
  2445. CXTPCommandBar* pPopupToolBar = pGroup->GetControlGroupPopup()->GetCommandBar();
  2446. if (pPopupToolBar && pPopupToolBar->IsTrackingMode() && nIndex >= 0 &&
  2447. nIndex < pPopupToolBar->GetControlCount())
  2448. {
  2449. GetCommandBars()->ShowKeyboardTips(pPopupToolBar);
  2451. pPopupToolBar->GetControl(nIndex)->OnUnderlineActivate();
  2453. }
  2454. }
  2456. return;
  2457. }
  2459. if (pControl->IsVisible())
  2460. {
  2461. pControl->OnUnderlineActivate();
  2462. }
  2464. return;
  2465. }
  2467. CXTPRibbonTab* pTab = DYNAMIC_DOWNCAST(CXTPRibbonTab, pTip->m_pOwner);
  2468. if (pTab)
  2469. {
  2470. SetCurSel(pTab->GetIndex());
  2472. SetTrackingMode(TRUE, FALSE, TRUE);
  2473. SetSelected(m_pControlTab->GetIndex(), TRUE);
  2474. m_pControlTab->SetFocused(TRUE);
  2476. m_pControlTab->ShowPopupBar(TRUE);
  2478. if (!IsRibbonMinimized()) GetCommandBars()->ShowKeyboardTips(this, 2);
  2480. return;
  2481. }
  2482. }
  2484. void CXTPRibbonScrollableBar::CreateControlKeyboardTips(CXTPControl* pControl, LPCTSTR lpszPrefix, BOOL bVisible)
  2485. {
  2486. if (!pControl || (pControl->GetFlags() & xtpFlagSkipFocus))
  2487. return;
  2489. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  2490. CXTPRibbonTheme* pPaintManager = (CXTPRibbonTheme*)pCommandBars->GetPaintManager();
  2491. CRect rcGroups = GetGroupsRect();
  2493. if (pControl->GetCaption().IsEmpty() && pControl->GetKeyboardTip().IsEmpty())
  2494. return;
  2496. CXTPRibbonGroup* pGroup = pControl->GetRibbonGroup();
  2497. ASSERT(pGroup);
  2498. if (!pGroup)
  2499. return;
  2501. CRect rc(pControl->GetRect());
  2503. CPoint pt(rc.left + 21, pControl->GetRect().bottom - 4);
  2504. DWORD dwAlign = DT_TOP;
  2506. CRect rcGroup = pGroup->GetRect();
  2507. CRect rcCaption(rcGroup.left, rcGroup.bottom - pPaintManager->GetGroupCaptionHeight() + 2, rcGroup.right, rcGroup.bottom);
  2508. rcGroup.bottom = rcCaption.top;
  2510. if (CRect().IntersectRect(rc, rcCaption))
  2511. {
  2512. pt = CPoint(rc.CenterPoint().x, rcGroups.bottom - 6);
  2513. dwAlign = DT_TOP | DT_CENTER;
  2514. }
  2515. else if (pControl->GetStyle() == xtpButtonIconAndCaptionBelow && rc.Height() > rcGroup.Height() / 2)
  2516. {
  2517. pt = CPoint(rc.CenterPoint().x, rcGroup.bottom - 2);
  2518. dwAlign = DT_CENTER | DT_VCENTER;
  2519. }
  2520. else if (pControl->GetType() == xtpControlGallery)
  2521. {
  2522. pt = CPoint(rc.right, rcGroup.bottom - 2);
  2523. dwAlign = DT_CENTER | DT_VCENTER;
  2524. }
  2525. else if (rc.CenterPoint().y < rcGroup.top + rcGroup.Height() * 1 / 3)
  2526. {
  2527. pt = CPoint(rc.left + 11, rcGroup.top + 2);
  2528. dwAlign = DT_LEFT | DT_VCENTER;
  2529. }
  2530. else if (rc.CenterPoint().y > rcGroup.top + rcGroup.Height() * 2 / 3)
  2531. {
  2532. pt = CPoint(rc.left + 11, rcGroup.bottom - 2);
  2533. dwAlign = DT_LEFT | DT_VCENTER;
  2534. }
  2535. else
  2536. {
  2537. pt = CPoint(rc.left + 11, rcGroup.CenterPoint().y - 1);
  2538. dwAlign = DT_LEFT | DT_VCENTER;
  2539. }
  2540. if (pControl->GetType() == xtpControlCheckBox || pControl->GetType() == xtpControlRadioButton)
  2541. {
  2542. pt.x = rc.left + 6;
  2543. }
  2544. if ((pControl->GetType() == xtpControlComboBox || pControl->GetType() == xtpControlEdit)
  2545. && pControl->GetStyle() == xtpButtonAutomatic)
  2546. {
  2547. pt.x = rc.CenterPoint().x;
  2548. dwAlign |= DT_CENTER;
  2549. }
  2551. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars, pControl, pControl->GetCaption(), pt, dwAlign, pControl->GetEnabled());
  2553. if (!pControl->GetKeyboardTip().IsEmpty())
  2554. {
  2555. pWnd->m_strTip = pControl->GetKeyboardTip();
  2556. }
  2558. if (lpszPrefix)
  2559. {
  2560. pWnd->m_strPrefix = lpszPrefix;
  2561. }
  2563. CRect rcIntersect; rcIntersect.IntersectRect(rcGroups, rc);
  2564. pWnd->m_bVisible = bVisible && (rcIntersect == rc) && (pControl->IsVisible());
  2566. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  2567. }
  2569. void CXTPRibbonScrollableBar::CreateGroupKeyboardTips(CXTPRibbonTab* pSelectedTab)
  2570. {
  2571. for (int i = 0; i < pSelectedTab->GetGroups()->GetCount(); i++)
  2572. {
  2573. CXTPRibbonGroup* pGroup = pSelectedTab->GetGroups()->GetAt(i);
  2574. BOOL bVisible = pGroup->IsVisible();
  2576. for (int j = 0; j < pGroup->GetCount(); j++)
  2577. {
  2578. CXTPControl* pControl = pGroup->GetAt(j);
  2579. CreateControlKeyboardTips(pControl, NULL, bVisible);
  2580. }
  2582. if ((pGroup->GetControlGroupOption()->GetHideFlags() & xtpHideGeneric) == 0)
  2583. {
  2584. CreateControlKeyboardTips(pGroup->GetControlGroupOption(), NULL, bVisible);
  2585. }
  2587. CreateControlKeyboardTips(pGroup->GetControlGroupPopup(), _T("Z"), bVisible);
  2588. }
  2589. }
  2591. void CXTPRibbonBar::CreateKeyboardTips()
  2592. {
  2593. CXTPCommandBars* pCommandBars = GetCommandBars();
  2594. if (!pCommandBars)
  2595. return;
  2597. if (pCommandBars->m_keyboardTips.nLevel == 1)
  2598. {
  2599. int i;
  2602. int k = 1;
  2603. for (i = 0; i < m_pQuickAccessControls->GetCount(); i++)
  2604. {
  2605. CXTPControl* pControl = m_pQuickAccessControls->GetAt(i);
  2606. if (!pControl->IsVisible())
  2607. continue;
  2609. CPoint pt(pControl->GetRect().CenterPoint().x, pControl->GetRect().bottom - 11);
  2610. CString strCaption;
  2611. if (k < 10)
  2612. {
  2613. strCaption.Format(_T("%i"), k);
  2614. }
  2615. else if (k < 19)
  2616. {
  2617. strCaption.Format(_T("0%i"), k - 9);
  2618. }
  2619. else break;
  2620. k++;
  2622. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars, pControl, strCaption, pt, DT_CENTER | DT_TOP, pControl->GetEnabled());
  2624. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  2625. }
  2627. for (i = 0; i < GetTabCount(); i++)
  2628. {
  2629. CXTPRibbonTab* pTab = GetTab(i);
  2631. CString strCaption = pTab->GetCaption();
  2632. if (!strCaption.IsEmpty() && pTab->IsEnabled() && pTab->IsVisible())
  2633. {
  2634. CPoint pt(pTab->GetRect().CenterPoint().x, pTab->GetRect().bottom - 9);
  2636. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars, pTab, strCaption, pt, DT_CENTER | DT_TOP, TRUE);
  2638. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  2639. }
  2640. }
  2642. if (m_pControlSystemButton)
  2643. {
  2644. CPoint pt(m_pControlSystemButton->GetRect().CenterPoint().x, m_pControlSystemButton->GetRect().CenterPoint().y);
  2646. CXTPCommandBarKeyboardTip* pWnd = new CXTPCommandBarKeyboardTip(pCommandBars,
  2647. m_pControlSystemButton, m_pControlSystemButton->GetCaption(), pt, DT_VCENTER | DT_CENTER, m_pControlSystemButton->GetEnabled());
  2649. pCommandBars->m_keyboardTips.arr.Add(pWnd);
  2651. }
  2652. }
  2654. if (pCommandBars->m_keyboardTips.nLevel == 2)
  2655. {
  2656. CreateGroupKeyboardTips(GetSelectedTab());
  2657. }
  2658. }
  2660. CSize CXTPRibbonBar::GetIconSize() const
  2661. {
  2662. CXTPCommandBars* pCommandBars = GetCommandBars();
  2664. return m_szIcons != CSize(0) ? m_szIcons:
  2665. (pCommandBars->GetCommandBarsOptions()->szIcons != CSize(0) ?
  2666. pCommandBars->GetCommandBarsOptions()->szIcons : GetAutoIconSize(FALSE));
  2667. }
  2669. void CXTPRibbonBar::OnCustomizeDrop(CXTPControl* pDataObject, DROPEFFECT& dropEffect, CPoint ptDrop, CPoint ptDrag)
  2670. {
  2671. CXTPCommandBars* pCommandBars = GetCommandBars();
  2672. ASSERT(pCommandBars);
  2673. if (!pCommandBars)
  2674. return;
  2676. CRect rcMarker;
  2677. int nDropIndex;
  2678. BOOL bDropAfter;
  2680. CustomizeFindDropIndex (pDataObject, ptDrop, rcMarker, nDropIndex, bDropAfter);
  2682. CXTPControl* pDropControl = nDropIndex != -1 ? GetControl(nDropIndex) : NULL;
  2684. if (nDropIndex == -1 || pDataObject != pDropControl)
  2685. {
  2686. CXTPRibbonGroup* pGroup = pDropControl ? pDropControl->GetRibbonGroup() : NULL;
  2688. if (bDropAfter) nDropIndex++;
  2690. SetPopuped(-1);
  2691. SetSelected(-1);
  2693. BOOL bBeginGroup = FALSE;
  2694. if (bDropAfter == FALSE && nDropIndex >= 0 && nDropIndex < GetControlCount())
  2695. {
  2696. bBeginGroup = GetControl(nDropIndex)->GetBeginGroup();
  2697. if (bBeginGroup)
  2698. {
  2699. GetControl(nDropIndex)->SetBeginGroup(FALSE);
  2700. }
  2701. }
  2704. CXTPControl* pClone = NULL;
  2706. if (pGroup != NULL)
  2707. {
  2708. pClone = pGroup->AddClone(pDataObject, pGroup->IndexOf(pDropControl) + (bDropAfter ? 1 : 0));
  2709. }
  2710. else
  2711. {
  2712. pClone = m_pControls->AddClone(pDataObject, nDropIndex);
  2714. }
  2716. pClone->SetBeginGroup(bBeginGroup);
  2717. pCommandBars->SetDragControl(pClone);
  2719. }
  2720. else
  2721. {
  2722. if (abs(ptDrag.x - ptDrop.x) > 4 || abs(ptDrag.y - ptDrop.y) > 4)
  2723. {
  2724. CXTPControl* pControl = GetControl(nDropIndex);
  2725. ASSERT(pDataObject == pControl);
  2726. pControl->SetBeginGroup(bDropAfter && nDropIndex != 0);
  2727. }
  2729. dropEffect = DROPEFFECT_CANCEL;
  2730. }
  2731. OnRecalcLayout();
  2733. m_rcMarker.SetRectEmpty();
  2734. Redraw();
  2735. }
  2737. #define xtpKeyDown xtpKeyPopup
  2738. #define xtpKeyUp xtpKeyBack
  2740. CRect CXTPRibbonScrollableBar::_GetBoundRect(CXTPControl* pControl, BOOL bSelected, XTPSpecialKey key)
  2741. {
  2742. CRect rc(pControl->GetRect());
  2744. if (pControl->GetRibbonGroup() && DYNAMIC_DOWNCAST(CXTPRibbonGroupOption, pControl))
  2745. {
  2746. rc = pControl->GetRibbonGroup()->GetCaptionRect();
  2747. rc.DeflateRect(4, 0, 4, 0);
  2748. }
  2749. else if (!bSelected && (key == xtpKeyDown || key == xtpKeyUp) && !pControl->GetRibbonGroup() && DYNAMIC_DOWNCAST(CXTPRibbonBarControlQuickAccessPopup, pControl))
  2750. {
  2751. rc.right = CXTPClientRect(pControl->GetParent()).right;
  2752. }
  2753. else if (bSelected && key == xtpKeyUp && DYNAMIC_DOWNCAST(CXTPRibbonControlTab, pControl))
  2754. {
  2755. if (((CXTPRibbonControlTab*)pControl)->GetSelectedItem())
  2756. {
  2757. rc = ((CXTPRibbonControlTab*)pControl)->GetSelectedItem()->GetRect();
  2758. }
  2759. }
  2761. return rc;
  2762. }
  2764. BOOL CXTPRibbonBar::ProcessSpecialKey(XTPSpecialKey key)
  2765. {
  2766. if (key != xtpKeyEscape)
  2767. HideKeyboardTips();
  2769. if (CXTPRibbonScrollableBar::ProcessSpecialKey(key))
  2770. return TRUE;
  2772. return CXTPMenuBar::ProcessSpecialKey(key);
  2773. }
  2775. BOOL CXTPRibbonScrollableBar::ProcessSpecialKey(XTPSpecialKey key)
  2776. {
  2777. CXTPControl* pSelected = m_pParent->GetSelected();
  2779. if (!pSelected)
  2780. return FALSE;
  2782. if (key == xtpKeyReturn || key == xtpKeySpace)
  2783. {
  2784. if (pSelected->IsFocused())
  2785. pSelected->OnClick(TRUE);
  2786. else
  2787. pSelected->OnUnderlineActivate();
  2789. return TRUE;
  2790. }
  2792. if (key != xtpKeyDown && key != xtpKeyUp && key != xtpKeyLeft && key != xtpKeyRight)
  2793. return FALSE;
  2795. CRect rcCondidate(0, 0, 0, 0);
  2796. CRect rcSelected = _GetBoundRect(pSelected, TRUE, key);
  2797. int nSelCenter = rcSelected.CenterPoint().y;
  2798. CXTPControl* pCondidate = NULL;
  2799. CXTPControl* pFirst = NULL;
  2800. int nCount = m_pParent->GetControlCount();
  2802. if (key == xtpKeyRight)
  2803. {
  2804. for (int i = 0; i < nCount; i++)
  2805. {
  2806. CXTPControl* pControl = m_pParent->GetControl(i);
  2807. if (pControl == pSelected || !pControl->IsVisible(xtpHideScroll) || (pControl->GetFlags() & xtpFlagSkipFocus))
  2808. continue;
  2810. CRect rc = _GetBoundRect(pControl, FALSE, key);
  2812. if (((rc.top + 1 >= rcSelected.top && rc.top < rcSelected.bottom) || (rcSelected.top + 1 >= rc.top && rcSelected.top < rc.bottom)))
  2813. {
  2814. if ((rc.left >= rcSelected.right) && ((pCondidate == NULL) || (rc.left < rcCondidate.left) ||
  2815. (rc.left == rcCondidate.left && abs(rc.CenterPoint().y - nSelCenter) < abs(rcCondidate.CenterPoint().y - nSelCenter))))
  2816. {
  2817. pCondidate = pControl;
  2818. rcCondidate = rc;
  2819. }
  2821. if (pFirst == NULL || rc.left < pFirst->GetRect().left ||
  2822. (rc.left == pFirst->GetRect().left && abs(rc.CenterPoint().y - nSelCenter) < abs(pFirst->GetRect().CenterPoint().y - nSelCenter)))
  2823. {
  2824. pFirst = pControl;
  2825. }
  2826. }
  2827. }
  2828. }
  2829. else if (key == xtpKeyLeft)
  2830. {
  2831. for (int i = 0; i < nCount; i++)
  2832. {
  2833. CXTPControl* pControl = m_pParent->GetControl(i);
  2834. if (pControl == pSelected || !pControl->IsVisible(xtpHideScroll) || (pControl->GetFlags() & xtpFlagSkipFocus))
  2835. continue;
  2837. CRect rc = _GetBoundRect(pControl, FALSE, key);
  2839. if (((rc.top + 1 >= rcSelected.top && rc.top < rcSelected.bottom) || (rcSelected.top + 1 >= rc.top && rcSelected.top < rc.bottom)))
  2840. {
  2841. if ((rc.right <= rcSelected.left) && ((pCondidate == NULL) || (rc.right > rcCondidate.right) ||
  2842. (rc.right == rcCondidate.right && abs(rc.CenterPoint().y - nSelCenter) < abs(rcCondidate.CenterPoint().y - nSelCenter))))
  2843. {
  2844. pCondidate = pControl;
  2845. rcCondidate = rc;
  2846. }
  2848. if (pFirst == NULL || rc.right >= pFirst->GetRect().right ||
  2849. (rc.right == pFirst->GetRect().right && abs(rc.CenterPoint().y - nSelCenter) < abs(pFirst->GetRect().CenterPoint().y - nSelCenter)))
  2850. {
  2851. pFirst = pControl;
  2852. }
  2853. }
  2854. }
  2855. }
  2856. else if (key == xtpKeyDown)
  2857. {
  2858. nSelCenter = rcSelected.CenterPoint().x;
  2860. for (int i = 0; i < nCount; i++)
  2861. {
  2862. CXTPControl* pControl = m_pParent->GetControl(i);
  2863. if (pControl == pSelected || !pControl->IsVisible(xtpHideScroll) || (pControl->GetFlags() & xtpFlagSkipFocus))
  2864. continue;
  2866. CRect rc = _GetBoundRect(pControl, FALSE, key);
  2868. if (((rc.left + 1 >= rcSelected.left && rc.left < rcSelected.right) || (rcSelected.left + 1 >= rc.left && rcSelected.left < rc.right)))
  2869. {
  2870. if ((rc.top >= rcSelected.bottom) && ((pCondidate == NULL) || (rc.top < rcCondidate.top) ||
  2871. (rc.top == rcCondidate.top && abs(rc.CenterPoint().x - nSelCenter) < abs(rcCondidate.CenterPoint().x - nSelCenter))))
  2872. {
  2873. pCondidate = pControl;
  2874. rcCondidate = rc;
  2875. }
  2876. }
  2877. }
  2878. }
  2879. else if (key == xtpKeyUp)
  2880. {
  2881. nSelCenter = rcSelected.CenterPoint().x;
  2883. for (int i = 0; i < nCount; i++)
  2884. {
  2885. CXTPControl* pControl = m_pParent->GetControl(i);
  2886. if (pControl == pSelected || !pControl->IsVisible(xtpHideScroll) || (pControl->GetFlags() & xtpFlagSkipFocus))
  2887. continue;
  2889. CRect rc = _GetBoundRect(pControl, FALSE, key);
  2891. if (((rc.left + 1 >= rcSelected.left && rc.left < rcSelected.right) || (rcSelected.left + 1 >= rc.left && rcSelected.left < rc.right)))
  2892. {
  2893. if ((rc.bottom <= rcSelected.top) && ((pCondidate == NULL) || (rc.bottom > rcCondidate.bottom) ||
  2894. (rc.bottom == rcCondidate.bottom && abs(rc.CenterPoint().x - nSelCenter) < abs(rcCondidate.CenterPoint().x - nSelCenter))))
  2895. {
  2896. pCondidate = pControl;
  2897. rcCondidate = rc;
  2898. }
  2899. }
  2900. }
  2901. }
  2903. if (pCondidate)
  2904. {
  2905. m_pParent->SetSelected(pCondidate->GetIndex(), key == xtpKeyRight || key == xtpKeyDown ? TRUE_KEYBOARD_NEXT : TRUE_KEYBOARD_PREV);
  2906. }
  2907. else if (pFirst)
  2908. {
  2909. m_pParent->SetSelected(pFirst->GetIndex(), key == xtpKeyRight || key == xtpKeyDown? TRUE_KEYBOARD_NEXT : TRUE_KEYBOARD_PREV);
  2910. }
  2913. return TRUE;
  2914. }