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

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

对话框与窗口

开发平台：

Visual C++

XTPRibbonPopups.cpp：源码内容
  1. // XTPRibbonPopups.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
  55. #define IDSYS_SCROLL 17821
  58. class CXTPRibbonScrollableBar::CControlGroupsScroll : public CXTPControlButton
  59. {
  60. public:
  61. CControlGroupsScroll(BOOL bScrollLeft)
  62. {
  63. SetFlags(xtpFlagSkipFocus | xtpFlagNoMovable);
  64. m_bScrollLeft = bScrollLeft;
  65. }
  67. void Draw(CDC* pDC)
  68. {
  69. ((CXTPRibbonTheme*)GetParent()->GetPaintManager())->DrawRibbonScrollButton(pDC, this, m_bScrollLeft);
  70. }
  72. virtual void OnClick(BOOL /*bKeyboard  = FALSE */, CPoint /*pt  = CPoint */)
  73. {
  74. if (GetKeyState(VK_LBUTTON) >= 0)
  75. return;
  77. m_bPressed = TRUE;
  79. CXTPRibbonScrollableBar* pScrollableBar = GetScrollableBar(m_pParent);
  81. pScrollableBar->OnGroupsScroll(m_bScrollLeft);
  83. int cmsTimer = GetDoubleClickTime() * 4 / 5;
  84. m_pParent->SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
  85. BOOL bFirst = TRUE;
  87. m_pParent->SetCapture();
  89. while (::GetCapture() == m_pParent->GetSafeHwnd() && IsVisible())
  90. {
  91. MSG msg;
  93. if (!::GetMessage(&msg, NULL, 0, 0))
  94. {
  95. AfxPostQuitMessage((int)msg.wParam);
  96. break;
  97. }
  99. if (msg.message == WM_TIMER && msg.wParam == IDSYS_SCROLL)
  100. {
  101. pScrollableBar->OnGroupsScroll(m_bScrollLeft);
  103. if (bFirst)
  104. {
  105. cmsTimer = GetDoubleClickTime() / 10;
  106. m_pParent->SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
  107. }
  108. bFirst = FALSE;
  109. }
  110. else if (msg.message == WM_LBUTTONUP)
  111. {
  112. break;
  113. }
  114. else
  115. {
  116. TranslateMessage(&msg);
  117. DispatchMessage(&msg);
  118. }
  119. }
  121. ReleaseCapture();
  122. m_pParent->KillTimer(IDSYS_SCROLL);
  124. m_bPressed = FALSE;
  125. if (!IsVisible()) m_bSelected = FALSE;
  126. RedrawParent(FALSE);
  127. }
  129. protected:
  130. BOOL m_bScrollLeft;
  131. };
  133. CXTPRibbonBarMorePopupToolBar::CXTPRibbonBarMorePopupToolBar(CXTPRibbonBar* pRibbonBar)
  134. {
  135. m_bTrackOnHover = FALSE;
  136. m_rcBorders = CRect(3, 3, 3, 3);
  137. m_pRibbonBar = pRibbonBar;
  138. }
  140. IMPLEMENT_DYNAMIC(CXTPRibbonBarMorePopupToolBar, CXTPPopupToolBar)
  142. void CXTPRibbonBarMorePopupToolBar::FillCommandBarEntry(CDC* pDC)
  143. {
  144. CXTPRibbonTheme* pPaintManager = (CXTPRibbonTheme*)GetPaintManager();
  145. pPaintManager->FillMorePopupToolBarEntry(pDC, this);
  146. }
  148. CSize CXTPRibbonBarMorePopupToolBar::GetIconSize() const
  149. {
  150. return m_pRibbonBar->GetIconSize();
  151. }
  152. CSize CXTPRibbonBarMorePopupToolBar::GetButtonSize() const
  153. {
  154. return m_pRibbonBar->GetButtonSize();
  155. }
  157. CXTPRibbonScrollableBar::CXTPRibbonScrollableBar()
  158. {
  159. m_pParent = NULL;
  160. m_pControlScrollGroupsLeft = NULL;
  161. m_pControlScrollGroupsRight = NULL;
  162. m_pHighlightedGroup = NULL;
  164. m_nGroupsScrollPos = 0;
  165. }
  167. void CXTPRibbonScrollableBar::InitScrollableBar(CXTPCommandBar* pParent)
  168. {
  169. m_pControlScrollGroupsRight = pParent->GetControls()->Add(new CControlGroupsScroll(FALSE));
  170. m_pControlScrollGroupsLeft = pParent->GetControls()->Add(new CControlGroupsScroll(TRUE));
  171. m_nGroupsScrollPos = 0;
  172. m_pParent = pParent;
  173. }
  175. void CXTPRibbonScrollableBar::ShowScrollableRect(CXTPRibbonGroups* pGroups, CRect rc)
  176. {
  177. int nGroupsScrollPos = pGroups->GetScrollPos();
  178. CRect rcGroups(GetGroupsRect());
  180. if (rc.left < 12 && m_pControlScrollGroupsLeft->IsVisible())
  181. {
  182. nGroupsScrollPos = nGroupsScrollPos + rc.left - 12;
  183. if (nGroupsScrollPos < 0) nGroupsScrollPos = 0;
  184. }
  185. else if (rc.right > rcGroups.right && m_pControlScrollGroupsRight->IsVisible())
  186. {
  187. nGroupsScrollPos = nGroupsScrollPos + rc.right - rcGroups.Width() + 12;
  188. if (nGroupsScrollPos < 0) nGroupsScrollPos = 0;
  189. }
  191. if (nGroupsScrollPos != m_nGroupsScrollPos)
  192. {
  193. m_nGroupsScrollPos = nGroupsScrollPos;
  194. pGroups->GetParentTab()->GetParent()->OnRecalcLayout();
  195. }
  196. }
  198. void CXTPRibbonScrollableBar::EnableGroupsScroll(BOOL bScrollLeft, BOOL bScrollRight)
  199. {
  200. ASSERT(m_pControlScrollGroupsRight);
  201. ASSERT(m_pControlScrollGroupsLeft);
  202. if (!m_pControlScrollGroupsRight || !m_pControlScrollGroupsLeft)
  203. return;
  205. CRect rcGroups(GetGroupsRect());
  207. if (bScrollLeft)
  208. {
  209. m_pControlScrollGroupsLeft->SetHideFlag(xtpHideScroll, FALSE);
  210. m_pControlScrollGroupsLeft->SetRect(CRect(rcGroups.left - 1, rcGroups.top, rcGroups.left + 12, rcGroups.bottom));
  211. }
  212. else
  213. {
  214. m_pControlScrollGroupsLeft->SetHideFlag(xtpHideScroll, TRUE);
  215. }
  217. if (bScrollRight)
  218. {
  219. m_pControlScrollGroupsRight->SetHideFlag(xtpHideScroll, FALSE);
  220. m_pControlScrollGroupsRight->SetRect(CRect(rcGroups.right - 12, rcGroups.top, rcGroups.right + 1, rcGroups.bottom));
  221. }
  222. else
  223. {
  224. m_pControlScrollGroupsRight->SetHideFlag(xtpHideScroll, TRUE);
  225. }
  226. }
  230. //////////////////////////////////////////////////////////////////////////
  231. // CXTPRibbonTabPopupToolBar
  233. CXTPRibbonTabPopupToolBar::CXTPRibbonTabPopupToolBar(CXTPRibbonTab* pRibbonTab)
  234. {
  236. InitScrollableBar(this);
  238. m_pRibbonBar = pRibbonTab->GetRibbonBar();
  239. m_pRibbonTab = (CXTPRibbonTab*)pRibbonTab->GetRuntimeClass()->CreateObject();
  241. m_pRibbonTab->m_pParent = this;
  242. m_pRibbonTab->m_pRibbonBar = m_pRibbonBar;
  244. m_pRibbonTab->Copy(pRibbonTab);
  246. m_pRibbonTab->SetRect(pRibbonTab->GetRect());
  248. m_bTrackOnHover = FALSE;
  249. SetFlags(xtpFlagSmartLayout);
  251. EnableAnimation(m_pRibbonBar->IsAnimationEnabled());
  252. }
  254. CXTPRibbonTabPopupToolBar::~CXTPRibbonTabPopupToolBar()
  255. {
  256. m_pRibbonTab->OnRemoved();
  257. m_pRibbonTab->InternalRelease();
  258. }
  260. CRect CXTPRibbonTabPopupToolBar::GetGroupsRect() const
  261. {
  262. return m_rcGroups;
  263. }
  265. void CXTPRibbonTabPopupToolBar::OnGroupsScroll(BOOL bScrollLeft)
  266. {
  267. int nGroupsScrollPos = m_pRibbonTab->GetGroups()->GetScrollPos();
  269. SetPopuped(-1);
  270. HideKeyboardTips();
  272. if (bScrollLeft)
  273. {
  274. nGroupsScrollPos -= 40;
  275. if (nGroupsScrollPos < 0)
  276. nGroupsScrollPos = 0;
  277. }
  278. else
  279. {
  280. nGroupsScrollPos += 40;
  281. }
  283. if (nGroupsScrollPos != m_nGroupsScrollPos)
  284. {
  285. m_nGroupsScrollPos = nGroupsScrollPos;
  286. OnRecalcLayout();
  287. }
  288. }
  290. void CXTPRibbonTabPopupToolBar::EnsureVisible(CXTPControl* pControl)
  291. {
  292. if (pControl->GetRibbonGroup() &&
  293. (m_pControlScrollGroupsLeft->IsVisible() || m_pControlScrollGroupsRight->IsVisible()))
  294. {
  295. ShowScrollableRect(m_pRibbonTab->GetGroups(), pControl->GetRect());
  296. }
  297. }
  299. void CXTPRibbonTabPopupToolBar::CreateKeyboardTips()
  300. {
  301. CreateGroupKeyboardTips(m_pRibbonTab);
  302. }
  304. CSize CXTPRibbonTabPopupToolBar::CalcDynamicLayout(int, DWORD /*nMode*/)
  305. {
  306. CRect rcRibbonBar;
  307. m_pRibbonBar->GetWindowRect(rcRibbonBar);
  309. CRect rcRibbonTab = m_pRibbonTab->GetRect();
  310. m_pRibbonBar->ClientToScreen(rcRibbonTab);
  312. CRect rcWork = XTPMultiMonitor()->GetWorkArea(rcRibbonTab);
  314. int nHeight = m_pRibbonBar->CalcGroupsHeight();
  315. int nWidth = rcRibbonBar.Width();
  317. m_ptPopup.y = m_rcExclude.bottom;
  318. m_ptPopup.x = rcRibbonBar.left;
  320. if (m_ptPopup.x < rcWork.left)
  321. {
  322. nWidth -= rcWork.left - m_ptPopup.x;
  323. m_ptPopup.x = rcWork.left;
  324. }
  326. if (m_ptPopup.x + nWidth > rcWork.right)
  327. {
  328. nWidth = rcWork.right - m_ptPopup.x - 4;
  329. }
  331. if (m_ptPopup.y + nHeight > rcWork.bottom)
  332. {
  333. m_ptPopup.y = m_rcExclude.top - nHeight;
  334. }
  336. CClientDC dc(this);
  337. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this));
  339. UpdateShortcuts();
  341. m_rcGroups.SetRect(0, 0, nWidth, nHeight);
  342. m_pRibbonTab->GetGroups()->CalcDynamicSize(&dc, m_rcGroups.Width(), LM_COMMIT,
  343. CRect(m_rcGroups.left + 4, m_rcGroups.top + 3, 6, 3));
  345. m_rcTearOffGripper.SetRectEmpty();
  348. return CSize(nWidth, nHeight);
  349. }
  351. void CXTPRibbonTabPopupToolBar::DrawCommandBar(CDC* pDC, CRect rcClipBox)
  352. {
  353. CXTPRibbonTheme* pPaintManager = (CXTPRibbonTheme*)GetPaintManager();
  355. pPaintManager->FillTabPopupToolBar(pDC, this);
  356. pPaintManager->FillGroupRect(pDC, m_pRibbonTab, m_rcGroups);
  357. pDC->SetBkMode(TRANSPARENT);
  359. CXTPRibbonGroups* pGroups = m_pRibbonTab->GetGroups();
  360. for (int i = 0; i < pGroups->GetCount(); i++)
  361. {
  362. CXTPRibbonGroup* pGroup = pGroups->GetAt(i);
  364. if (pGroup->IsVisible() && CRect().IntersectRect(rcClipBox, pGroup->GetRect()))
  365. {
  366. pGroup->Draw(pDC, rcClipBox);
  367. }
  368. }
  370. if (m_pControlScrollGroupsLeft->IsVisible())
  371. {
  372. m_pControlScrollGroupsLeft->Draw(pDC);
  373. }
  375. if (m_pControlScrollGroupsRight->IsVisible())
  376. {
  377. m_pControlScrollGroupsRight->Draw(pDC);
  378. }
  379. }
  381. CSize CXTPRibbonTabPopupToolBar::GetButtonSize() const
  382. {
  383. return m_pRibbonBar->GetButtonSize();
  384. }
  386. CSize CXTPRibbonTabPopupToolBar::GetIconSize() const
  387. {
  388. return m_pRibbonBar->GetIconSize();
  390. }
  392. CRect CXTPRibbonTabPopupToolBar::CalculatePopupRect(CPoint ptPopup, CSize sz)
  393. {
  394. return CRect(ptPopup, sz);
  395. }
  397. CXTPRibbonGroup* CXTPRibbonTabPopupToolBar::HitTestGroup(CPoint point) const
  398. {
  399. if (!m_rcGroups.PtInRect(point))
  400. return NULL;
  402. return m_pRibbonTab->GetGroups()->HitTest(point);
  403. }
  405. BOOL CXTPRibbonTabPopupToolBar::IsKeyboardCuesVisible() const
  406. {
  407. return m_pRibbonBar->IsKeyboardCuesVisible();
  408. }
  410. void CXTPRibbonTabPopupToolBar::OnKeyboardTip(CXTPCommandBarKeyboardTip* pTip)
  411. {
  412. CXTPControl* pControl = DYNAMIC_DOWNCAST(CXTPControl, pTip->m_pOwner);
  413. if (pControl)
  414. {
  416. if (pTip->m_bVisible == FALSE && pControl->GetHideFlags() == xtpHideWrap)
  417. {
  418. CXTPRibbonGroup* pGroup = pControl->GetRibbonGroup();
  419. if (pGroup && pGroup->GetControlGroupPopup())
  420. {
  421. EnsureVisible(pGroup->GetControlGroupPopup());
  422. pGroup->GetControlGroupPopup()->OnUnderlineActivate();
  424. int nIndex = pGroup->IndexOf(pControl);
  426. CXTPCommandBar* pPopupToolBar = pGroup->GetControlGroupPopup()->GetCommandBar();
  427. if (pPopupToolBar && pPopupToolBar->IsTrackingMode() && nIndex >= 0 &&
  428. nIndex < pPopupToolBar->GetControlCount())
  429. {
  430. pPopupToolBar->GetControl(nIndex)->OnUnderlineActivate();
  432. }
  433. }
  435. return;
  436. }
  438. if (pControl->IsVisible())
  439. {
  440. pControl->OnUnderlineActivate();
  441. }
  443. return;
  444. }
  445. }
  447. BEGIN_MESSAGE_MAP(CXTPRibbonTabPopupToolBar, CXTPPopupToolBar)
  448. //{{AFX_MSG_MAP(CXTPRibbonBar)
  449. ON_WM_MOUSEMOVE()
  450. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  451. //}}AFX_MSG_MAP
  452. END_MESSAGE_MAP()
  454. void CXTPRibbonScrollableBar::HighlightGroup(CXTPRibbonGroup* pHighlightedGroup)
  455. {
  456. if (m_pHighlightedGroup)
  457. {
  458. CRect rcRedraw(m_pHighlightedGroup->GetRect());
  459. m_pHighlightedGroup = NULL;
  461. m_pParent->Redraw(rcRedraw);
  462. }
  464. m_pHighlightedGroup = pHighlightedGroup;
  466. if (m_pHighlightedGroup)
  467. {
  468. m_pParent->Redraw(m_pHighlightedGroup->GetRect());
  469. }
  470. }
  472. void CXTPRibbonTabPopupToolBar::OnMouseMove(UINT nFlags, CPoint point)
  473. {
  474. CXTPCommandBars* pCommandBars = GetCommandBars ();
  475. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  477. BOOL bMouseLocked = pMouseManager->IsMouseLocked() || !pMouseManager->IsTopParentActive(m_hWnd)
  478. || pMouseManager->IsTrackedLock(this) || m_nPopuped != -1;
  480. CXTPRibbonGroup* pHighlightedGroup = bMouseLocked || !m_pRibbonBar->GetRibbonPaintManager()->m_bHotTrackingGroups ?
  481. NULL : HitTestGroup(point);
  483. if (pHighlightedGroup != m_pHighlightedGroup)
  484. {
  485. HighlightGroup(pHighlightedGroup);
  487. if (m_pHighlightedGroup)
  488. {
  489. pMouseManager->TrackMouseLeave(*this);
  490. }
  491. }
  493. CXTPPopupToolBar::OnMouseMove(nFlags, point);
  494. }
  496. BOOL CXTPRibbonTabPopupToolBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  497. {
  498. HighlightGroup(NULL);
  500. return CXTPPopupToolBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard);
  501. }
  503. void CXTPRibbonTabPopupToolBar::OnMouseLeave()
  504. {
  505. HighlightGroup(NULL);
  507. CXTPPopupToolBar::OnMouseLeave();
  508. }
  510. BOOL CXTPRibbonTabPopupToolBar::ProcessSpecialKey(XTPSpecialKey key)
  511. {
  512. if (key != xtpKeyEscape)
  513. HideKeyboardTips();
  515. if (CXTPRibbonScrollableBar::ProcessSpecialKey(key))
  516. return TRUE;
  518. if (key == xtpKeyEscape && !m_pRibbonBar->m_bKeyboardSelect)
  519. {
  520. GetCommandBars()->ClosePopups();
  521. return TRUE;
  522. }
  524. return CXTPPopupToolBar::ProcessSpecialKey(key);
  525. }
  527. INT_PTR CXTPRibbonTabPopupToolBar::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  528. {
  529. INT_PTR nHit = CXTPPopupToolBar::OnToolHitTest(point, pTI);
  530. if (nHit == -1)
  531. return -1;
  533. if (pTI != NULL && pTI->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX) && m_pToolTipContext
  534. && m_pToolTipContext->IsShowTitleAndDescription())
  535. {
  536. XTP_TOOLTIP_CONTEXT* tc = ((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo;
  537. if (tc && tc->pObject && ((CXTPControl*)tc->pObject)->GetRibbonGroup())
  538. {
  539. tc->rcExclude = m_rcGroups;
  540. }
  541. }
  543. return nHit;
  544. }
  546. IMPLEMENT_DYNAMIC(CXTPRibbonTabPopupToolBar, CXTPPopupToolBar)
  548. CXTPRibbonScrollableBar* AFX_CDECL GetScrollableBar(CXTPCommandBar* pCommandBar)
  549. {
  550. if (pCommandBar->IsRibbonBar())
  551. return (CXTPRibbonScrollableBar*)(CXTPRibbonBar*)(pCommandBar);
  553. if (pCommandBar->IsKindOf(RUNTIME_CLASS(CXTPRibbonTabPopupToolBar)))
  554. return (CXTPRibbonScrollableBar*)(CXTPRibbonTabPopupToolBar*)(pCommandBar);
  556. if (pCommandBar->IsKindOf(RUNTIME_CLASS(CXTPRibbonGroupPopupToolBar)))
  557. return (CXTPRibbonScrollableBar*)(CXTPRibbonGroupPopupToolBar*)(pCommandBar);
  559. return 0;
  560. }
  563. //////////////////////////////////////////////////////////////////////////
  564. // CXTPRibbonGroupPopupToolBar
  566. IMPLEMENT_XTP_COMMANDBAR(CXTPRibbonGroupPopupToolBar, CXTPPopupToolBar)
  568. CXTPRibbonGroupPopupToolBar::CXTPRibbonGroupPopupToolBar(CXTPRibbonGroup* pRibbonGroup /*= NULL*/)
  569. {
  570. if (!pRibbonGroup)
  571. {
  572. m_pRibbonBar = NULL;
  573. m_pRibbonGroup = NULL;
  574. m_pParentGroup = NULL;
  575. return;
  576. }
  577. m_pParent = this;
  578. m_pRibbonBar = pRibbonGroup->GetRibbonBar();
  579. m_pRibbonGroup = (CXTPRibbonGroup*)pRibbonGroup->GetRuntimeClass()->CreateObject();
  580. m_pRibbonGroup->m_pParent = this;
  581. m_pRibbonGroup->m_pRibbonBar = m_pRibbonBar;
  582. m_pParentGroup = pRibbonGroup;
  584. m_pRibbonGroup->OnGroupAdded();
  585. m_pRibbonGroup->Copy(pRibbonGroup);
  587. int nHeight = m_pRibbonBar->GetRibbonPaintManager()->GetGroupCaptionHeight();
  588. m_rcBorders.SetRect(2, 2, 3, nHeight + 1);
  590. m_bTrackOnHover = FALSE;
  591. SetFlags(xtpFlagSmartLayout);
  593. EnableAnimation(m_pRibbonBar->IsAnimationEnabled());
  594. }
  596. CXTPRibbonGroupPopupToolBar::~CXTPRibbonGroupPopupToolBar()
  597. {
  598. m_pRibbonGroup->OnGroupRemoved();
  599. m_pRibbonGroup->InternalRelease();
  600. }
  602. CSize CXTPRibbonGroupPopupToolBar::CalcDynamicLayout(int, DWORD /*nMode*/)
  603. {
  604. m_bDynamicLayout = TRUE;
  606. CClientDC dc(this);
  607. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this));
  609. UpdateShortcuts();
  611. int nGroupHeight = m_pRibbonBar->CalcGroupsHeight();
  613. m_pRibbonGroup->OnBeforeCalcSize(&dc);
  614. int nWidth = m_pRibbonGroup->OnCalcDynamicSize(&dc);
  615. m_pRibbonGroup->OnAdjustBorders(nWidth, CRect(0, 0, 0, 0));
  616. m_pRibbonGroup->OnAfterCalcSize();
  618. m_rcTearOffGripper.SetRectEmpty();
  620. m_bDynamicLayout = FALSE;
  622. return CSize(nWidth + m_rcBorders.left + m_rcBorders.right, nGroupHeight - 7);
  623. }
  625. void CXTPRibbonGroupPopupToolBar::DrawCommandBar(CDC* pDC, CRect rcClipBox)
  626. {
  627. m_pRibbonBar->GetRibbonPaintManager()->FillGroupPopupToolBar(pDC, m_pRibbonGroup, this);
  629. m_pRibbonGroup->Draw(pDC, rcClipBox);
  630. }
  632. void CXTPRibbonGroupPopupToolBar::CreateKeyboardTips()
  633. {
  634. if (!m_pParentGroup)
  635. return;
  637. CXTPRibbonTab* pSelectedTab = m_pParentGroup->GetParentTab();
  639. for (int i = 0; i < pSelectedTab->GetGroups()->GetCount(); i++)
  640. {
  641. CXTPRibbonGroup* pGroup = pSelectedTab->GetGroups()->GetAt(i);
  642. BOOL bVisible = pGroup->IsVisible() && m_pParentGroup == pGroup;
  644. if (bVisible)
  645. {
  646. pGroup = m_pRibbonGroup;
  647. }
  649. for (int j = 0; j < pGroup->GetCount(); j++)
  650. {
  651. CXTPControl* pControl = pGroup->GetAt(j);
  652. CreateControlKeyboardTips(pControl, NULL, bVisible);
  653. }
  655. if ((pGroup->GetControlGroupOption()->GetHideFlags() & xtpHideGeneric) == 0)
  656. {
  657. CreateControlKeyboardTips(pGroup->GetControlGroupOption(), NULL, bVisible);
  658. }
  660. CreateControlKeyboardTips(pGroup->GetControlGroupPopup(), _T("Z"), bVisible);
  661. }
  662. }
  664. CXTPRibbonGroup* CXTPRibbonGroupPopupToolBar::HitTestGroup(CPoint point) const
  665. {
  666. if (m_pRibbonGroup && m_pRibbonGroup->GetRect().PtInRect(point))
  667. return m_pRibbonGroup;
  669. return NULL;
  670. }
  673. CSize CXTPRibbonGroupPopupToolBar::GetIconSize() const
  674. {
  675. return m_pRibbonBar->GetIconSize();
  676. }
  678. CSize CXTPRibbonGroupPopupToolBar::GetButtonSize() const
  679. {
  680. return m_pRibbonBar->GetButtonSize();
  681. }
  683. void CXTPRibbonGroupPopupToolBar::OnGroupsScroll(BOOL /*bScrollLeft*/)
  684. {
  685. }
  687. CRect CXTPRibbonGroupPopupToolBar::GetGroupsRect() const
  688. {
  689. return CXTPClientRect(this);
  690. }
  692. BOOL CXTPRibbonGroupPopupToolBar::ProcessSpecialKey(XTPSpecialKey key)
  693. {
  694. if (key != xtpKeyEscape)
  695. HideKeyboardTips();
  697. if (CXTPRibbonScrollableBar::ProcessSpecialKey(key))
  698. return TRUE;
  700. return CXTPPopupToolBar::ProcessSpecialKey(key);
  701. }
  704. BEGIN_MESSAGE_MAP(CXTPRibbonGroupPopupToolBar, CXTPPopupToolBar)
  705. //{{AFX_MSG_MAP(CXTPRibbonBar)
  706. ON_WM_MOUSEMOVE()
  707. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  708. //}}AFX_MSG_MAP
  709. END_MESSAGE_MAP()
  711. void CXTPRibbonGroupPopupToolBar::OnMouseMove(UINT nFlags, CPoint point)
  712. {
  713. CXTPCommandBars* pCommandBars = GetCommandBars ();
  714. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  716. BOOL bMouseLocked = pMouseManager->IsMouseLocked() || !pMouseManager->IsTopParentActive(m_hWnd)
  717. || pMouseManager->IsTrackedLock(this) || m_nPopuped != -1;
  719. CXTPRibbonGroup* pHighlightedGroup = bMouseLocked || !m_pRibbonBar->GetRibbonPaintManager()->m_bHotTrackingGroups ?
  720. NULL : m_pRibbonGroup;
  722. if (pHighlightedGroup != m_pHighlightedGroup)
  723. {
  724. HighlightGroup(pHighlightedGroup);
  726. if (m_pHighlightedGroup)
  727. {
  728. pMouseManager->TrackMouseLeave(*this);
  729. }
  730. }
  732. CXTPPopupToolBar::OnMouseMove(nFlags, point);
  733. }
  735. BOOL CXTPRibbonGroupPopupToolBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  736. {
  737. HighlightGroup(NULL);
  739. return CXTPPopupToolBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard);
  740. }
  742. void CXTPRibbonGroupPopupToolBar::OnMouseLeave()
  743. {
  744. HighlightGroup(NULL);
  746. CXTPPopupToolBar::OnMouseLeave();
  747. }
  749. BOOL CXTPRibbonGroupPopupToolBar::IsKeyboardCuesVisible() const
  750. {
  751. return m_pRibbonBar->IsKeyboardCuesVisible();
  752. }