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

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

对话框与窗口

开发平台：

Visual C++

XTPRibbonGroups.cpp：源码内容
  1. // XTPRibbonGroups.cpp: implementation of the CXTPRibbonGroups class.
  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"
  23. #include "Common/XTPImageManager.h"
  24. #include "Common/XTPPropExchange.h"
  26. #include "CommandBars/XTPControl.h"
  27. #include "CommandBars/XTPControlPopup.h"
  28. #include "CommandBars/XTPControls.h"
  29. #include "CommandBars/XTPControlGallery.h"
  31. #include "XTPRibbonGroup.h"
  32. #include "XTPRibbonGroups.h"
  33. #include "XTPRibbonTab.h"
  34. #include "XTPRibbonBar.h"
  35. #include "XTPRibbonTheme.h"
  37. #ifdef _DEBUG
  38. #undef THIS_FILE
  39. static char THIS_FILE[]=__FILE__;
  40. #define new DEBUG_NEW
  41. #endif
  43. //////////////////////////////////////////////////////////////////////
  44. // Construction/Destruction
  45. //////////////////////////////////////////////////////////////////////
  47. CXTPRibbonGroups::CXTPRibbonGroups()
  48. {
  49. m_pParentTab = NULL;
  50. m_nGroupsScrollPos = 0;
  53. }
  55. CXTPRibbonGroups::~CXTPRibbonGroups()
  56. {
  57. RemoveAll();
  58. }
  60. void CXTPRibbonGroups::RemoveAll()
  61. {
  62. for (int nIndex = 0; nIndex < GetCount(); nIndex++)
  63. {
  64. CXTPRibbonGroup* pGroup = GetAt(nIndex);
  65. pGroup->OnGroupRemoved();
  66. pGroup->InternalRelease();
  67. }
  68. m_arrGroups.RemoveAll();
  69. RefreshIndexes();
  70. }
  72. void CXTPRibbonGroups::RefreshIndexes()
  73. {
  74. for (int nIndex = 0; nIndex < GetCount(); nIndex++)
  75. {
  76. CXTPRibbonGroup* pGroup = GetAt(nIndex);
  77. pGroup->m_nIndex = nIndex;
  78. }
  79. }
  81. CXTPRibbonBar* CXTPRibbonGroups::GetRibbonBar() const
  82. {
  83. return m_pParentTab->GetRibbonBar();
  84. }
  86. CXTPRibbonGroup* CXTPRibbonGroups::Add(LPCTSTR lpszCaption, int nId)
  87. {
  88. return InsertAt(GetCount(), lpszCaption, nId);
  89. }
  91. CXTPRibbonGroup* CXTPRibbonGroups::InsertAt(int nIndex, CXTPRibbonGroup* pGroup)
  92. {
  93. pGroup->m_pGroups = this;
  94. pGroup->m_pRibbonBar = m_pParentTab->GetRibbonBar();
  95. pGroup->m_pParent = m_pParentTab->GetParent();
  97. m_arrGroups.InsertAt(nIndex, pGroup);
  99. RefreshIndexes();
  101. pGroup->OnGroupAdded();
  103. return pGroup;
  104. }
  106. CXTPRibbonGroup* CXTPRibbonGroups::InsertAt(int nIndex, LPCTSTR lpszCaption, int nId)
  107. {
  108. CXTPRibbonGroup* pGroup = new CXTPRibbonGroup;
  109. pGroup->SetID(nId);
  110. pGroup->SetCaption(lpszCaption);
  112. InsertAt(nIndex, pGroup);
  114. pGroup->LoadToolBar(nId);
  116. return pGroup;
  117. }
  119. void CXTPRibbonGroups::Remove(int nIndex)
  120. {
  121. if ((nIndex >= 0) && (nIndex < GetCount()))
  122. {
  123. CXTPRibbonGroup* pGroup = GetAt(nIndex);
  124. ASSERT(pGroup);
  126. pGroup->OnGroupRemoved();
  127. m_arrGroups.RemoveAt(nIndex);
  128. pGroup->InternalRelease();
  129. RefreshIndexes();
  130. }
  131. }
  133. CXTPRibbonGroup* CXTPRibbonGroups::HitTest(CPoint point) const
  134. {
  135. for (int nIndex = 0; nIndex < GetCount(); nIndex++)
  136. {
  137. CXTPRibbonGroup* pGroup = GetAt(nIndex);
  138. if (pGroup->IsVisible() && pGroup->GetRect().PtInRect(point))
  139. {
  140. return pGroup;
  141. }
  142. }
  144. return NULL;
  146. }
  148. void CXTPRibbonGroups::Copy(CXTPRibbonGroups* pGroups)
  149. {
  150. RemoveAll();
  152. for (int nIndex = 0; nIndex < pGroups->GetCount(); nIndex++)
  153. {
  154. CXTPRibbonGroup* pGroup = pGroups->GetAt(nIndex);
  155. CXTPRibbonGroup* pClone = (CXTPRibbonGroup*)pGroup->GetRuntimeClass()->CreateObject();
  156. InsertAt(nIndex, pClone);
  158. pClone->Copy(pGroup);
  159. pClone->m_pGroups = this;
  160. }
  161. }
  164. //
  166. struct CXTPRibbonGroup::CONTROLINFO
  167. {
  168. CRect rcControl;
  169. CRect rcRow;
  170. CSize szControl;
  171. BOOL bHide;
  172. BOOL bWrap;
  173. BOOL bBeginGroup;
  174. BOOL bWrapGroup;
  175. XTPButtonStyle buttonStyle;
  176. CXTPControl* pControl;
  177. int nTailWidth;
  179. void EnsureButtonSize(CDC* pDC)
  180. {
  181. if (buttonStyle != pControl->GetStyle())
  182. {
  183. buttonStyle = pControl->GetStyle();
  184. szControl = pControl->GetSize(pDC);
  185. }
  186. }
  187. void Attach(CDC* pDC, CXTPControl* p)
  188. {
  189. pControl = p;
  190. rcRow.SetRectEmpty();
  192. szControl = pControl->GetSize(pDC);
  193. rcControl = pControl->GetRect();
  194. bBeginGroup = pControl->GetBeginGroup();
  195. bWrapGroup = bBeginGroup || (pControl->GetFlags() & xtpFlagWrapRow);
  196. buttonStyle = pControl->GetStyle();
  197. bWrap = bHide = FALSE;
  198. nTailWidth = 0;
  199. }
  201. void Detach()
  202. {
  203. pControl->SetHideWrap(bHide);
  204. pControl->SetRowRect(rcRow);
  205. if (!bHide)
  206. pControl->SetRect(rcControl);
  207. pControl->SetWrap(bWrap);
  208. }
  209. };
  211. struct CXTPRibbonGroup::LAYOUTINFO
  212. {
  213. CONTROLINFO* pControls;
  214. int nControlCount;
  215. int nMinWidth;
  216. int nWidth;
  217. BOOL bOldReduced;
  218. };
  220. BOOL CXTPRibbonGroup::OnExtendSize(int nWidthAvail)
  221. {
  222. int nDataCount = m_pLayoutInfo->nControlCount;
  223. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  225. for (int i = nDataCount - 1; i >= 0; i--)
  226. {
  227. if (pData[i].pControl->GetType() == xtpControlGallery &&
  228. ((CXTPControlGallery*)pData[i].pControl)->IsResizable() & 1)
  229. {
  230. CXTPControlGallery* pGallery = (CXTPControlGallery*)pData[i].pControl;
  231. int cx = pGallery->GetItems() ? pGallery->GetItems()->GetItemSize().cx : 0;
  233. if (cx > 0 && cx <= nWidthAvail)
  234. {
  235. int nCount = pGallery->GetItems()->GetItemCount();
  236. CRect rcBorders = pGallery->GetBorders();
  237. int nMaxWidth = nCount * cx + rcBorders.left + rcBorders.right;
  239. if (pData[i].szControl.cx + cx <= nMaxWidth)
  240. {
  241. pData[i].szControl.cx = min(nMaxWidth,
  242.  pData[i].szControl.cx + int(nWidthAvail / cx) * cx);
  244. return TRUE;
  245. }
  246. }
  248. return FALSE;
  249. }
  250. }
  252. return FALSE;
  253. }
  255. BOOL CXTPRibbonGroup::OnReduceSize(int nLevel, int nWidthAvail)
  256. {
  257. if (m_pLayoutInfo == NULL)
  258. return FALSE;
  260. if (m_pLayoutInfo->nWidth < m_pLayoutInfo->nMinWidth)
  261. {
  262. if (nLevel == 2 && m_pLayoutInfo->nWidth > 16)
  263. {
  264. m_pLayoutInfo->nMinWidth = max(m_pLayoutInfo->nWidth, m_pLayoutInfo->nMinWidth - nWidthAvail);
  265. return TRUE;
  266. }
  268. return FALSE;
  269. }
  271. BOOL bReduced = FALSE;
  273. int nResultHeight = GetRibbonBar()->CalcGroupsHeight() - 2 -
  274. GetRibbonBar()->GetRibbonPaintManager()->GetGroupCaptionHeight() ;
  276. int nButtonSize = GetRibbonBar()->GetButtonSize().cy;
  278. int nControlsPerGroup = int(nResultHeight / nButtonSize);
  280. int nDataCount = m_pLayoutInfo->nControlCount;
  281. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  284. bReduced = FALSE;
  287. int* pButtons = new int[nControlsPerGroup];
  289. if (nLevel == 0 && !m_bControlsGrouping && m_nAllowReduce > nLevel)
  290. {
  291. if (nControlsPerGroup > 1)
  292. {
  293. for (int i = nDataCount - 1; i >= 2; i--)
  294. {
  295. if (pData[i].bWrapGroup)
  296. continue;
  298. int nItems = 0;
  300. for (int j = i; j  >= 0; j--)
  301. {
  302. CONTROLINFO* pControl = &pData[j];
  304. if ((nItems == nControlsPerGroup - 1 || !pControl->bWrapGroup)
  305. && pControl->pControl->m_buttonRibbonStyle == xtpButtonIconAndCaptionBelow
  306. && pControl->pControl->GetType() != xtpControlGallery)
  307. {
  308. pButtons[nItems] = j;
  309. nItems += 1;
  310. }
  311. else
  312. {
  313. break;
  314. }
  315. if (nItems == nControlsPerGroup)
  316. break;
  317. }
  319. if (nItems == nControlsPerGroup)
  320. {
  321. for (int k = 0; k < nItems; k++)
  322. pData[pButtons[k]].pControl->m_buttonRibbonStyle = xtpButtonIconAndCaption;
  323. bReduced = TRUE;
  324. break;
  325. }
  326. }
  327. }
  328. }
  330. if (nLevel == 1 && !m_bControlsGrouping && m_nAllowReduce > nLevel)
  331. {
  332. if (nControlsPerGroup > 1)
  333. {
  335. for (int i = nDataCount - 1; i >= 2; i--)
  336. {
  337. if (pData[i].bWrapGroup)
  338. continue;
  340. int nItems = 0;
  341. BOOL bFound = FALSE;
  342. int j;
  344. for (j = i; j  >= 0; j--)
  345. {
  346. CONTROLINFO* pControl = &pData[j];
  348. if ((nItems == nControlsPerGroup - 1 || !pControl->bWrapGroup)
  349. && pControl->pControl->GetType() != xtpControlGallery)
  350. {
  351. pButtons[nItems] = j;
  352. nItems += 1;
  353. bFound = bFound || pControl->pControl->m_buttonRibbonStyle == xtpButtonIconAndCaptionBelow;
  354. }
  355. else
  356. {
  357. break;
  358. }
  359. if (nItems == nControlsPerGroup)
  360. break;
  361. }
  362. i = j;
  363. if (nItems == nControlsPerGroup && bFound)
  364. {
  365. for (int k = 0; k < nItems; k++)
  366. pData[pButtons[k]].pControl->m_buttonRibbonStyle = xtpButtonIconAndCaption;
  368. bReduced = TRUE;
  369. break;
  370. }
  371. }
  372. }
  373. }
  375. if (nLevel == 1 && m_bControlsGrouping && m_nRowCount == 2 && m_nAllowReduce > nLevel)
  376. {
  377. m_nRowCount = 3;
  378. bReduced = TRUE;
  379. }
  381. if (nLevel == 2 && !bReduced && !m_bControlsGrouping && m_nAllowReduce > nLevel)
  382. {
  383. if (nControlsPerGroup > 1)
  384. {
  385. for (int i = nDataCount - 1; i >= 2; i--)
  386. {
  387. if (pData[i].bWrapGroup)
  388. continue;
  390. int nItems = 0;
  391. int nLeft = 0;
  393. for (int j = i; j  >= 0; j--)
  394. {
  395. CONTROLINFO* pControl = &pData[j];
  397. int nOffset = pControl->rcControl.left;
  398. if (nItems != 0 && (nOffset != nLeft))
  399. break;
  401. if ((nItems == nControlsPerGroup - 1 || !pControl->bWrapGroup)
  402. && pControl->pControl->m_buttonRibbonStyle == xtpButtonIconAndCaption
  403. && pControl->pControl->GetType() != xtpControlGallery)
  404. {
  405. pButtons[nItems] = j;
  406. nItems += 1;
  407. nLeft = nOffset;
  408. }
  409. else
  410. {
  411. break;
  412. }
  413. if (nItems == nControlsPerGroup)
  414. break;
  415. }
  417. if (nItems == nControlsPerGroup && GetCount() > nControlsPerGroup)
  418. {
  419. for (int k = 0; k < nItems; k++)
  420. pData[pButtons[k]].pControl->m_buttonRibbonStyle = xtpButtonIcon;
  421. bReduced = TRUE;
  422. break;
  423. }
  424. }
  425. }
  426. }
  428. if (nLevel == 2 && !bReduced && !m_bControlsGrouping && m_nAllowReduce > nLevel)
  429. {
  430. for (int i = nDataCount - 1; i >= 0; i--)
  431. {
  432. if (pData[i].pControl->GetType() == xtpControlGallery &&
  433. pData[i].pControl->m_buttonRibbonStyle != xtpButtonIconAndCaptionBelow)
  434. {
  435. pData[i].pControl->m_buttonRibbonStyle = xtpButtonIconAndCaptionBelow;
  436. bReduced = TRUE;
  437. break;
  438. }
  439. }
  440. }
  442. delete[] pButtons;
  445. if (nLevel == 3)
  446. {
  447. if (nDataCount > 1 && !m_bReduced && m_nAllowReduce > nLevel)
  448. {
  449. m_bReduced = TRUE;
  451. for (int j = 0; j < nDataCount; j++)
  452. {
  453. CONTROLINFO* pControl = &pData[j];
  454. pControl->bHide = TRUE;
  455. }
  457. bReduced = TRUE;
  458. }
  459. }
  461. return bReduced;
  462. }
  464. void CXTPRibbonGroup::OnBeforeCalcSize(CDC* pDC)
  465. {
  466. CSize szLargeIcon = GetRibbonBar()->GetLargeIconSize(FALSE);
  468. m_pLayoutInfo = new LAYOUTINFO;
  469. m_pLayoutInfo->pControls = NULL;
  470. m_pLayoutInfo->nMinWidth = GetMinimumWidth(pDC);
  471. m_pLayoutInfo->bOldReduced = m_bReduced;
  473. int nVisibleCount = 0;
  474. int j;
  476. for (j = 0; j < GetCount(); j++)
  477. {
  478. CXTPControl* pControl = GetAt(j);
  480. if (pControl->IsVisible(xtpHideWrap))
  481. {
  482. nVisibleCount++;
  483. }
  484. }
  486. m_pLayoutInfo->nControlCount = nVisibleCount;
  488. if (nVisibleCount == 0)
  489. return;
  491. m_pLayoutInfo->pControls = new CONTROLINFO[nVisibleCount];
  493. int k = 0;
  495. for (j = 0; j < GetCount(); j++)
  496. {
  497. CXTPControl* pControl = GetAt(j);
  499. if (pControl->IsVisible(xtpHideWrap))
  500. {
  501. pControl->m_buttonRibbonStyle = xtpButtonAutomatic;
  503. if (!m_bControlsGrouping && pControl->GetStyle() == xtpButtonAutomatic && pControl->GetType() != xtpControlGallery)
  504. {
  505. BOOL bDrawImage = pControl->GetIconId() > 0 ?
  506. pControl->GetImageManager()->IsPrimaryImageExists(pControl->GetIconId(), szLargeIcon.cx) != NULL: FALSE;
  508. pControl->m_buttonRibbonStyle = bDrawImage? xtpButtonIconAndCaptionBelow : xtpButtonIconAndCaption;
  509. }
  511. m_pLayoutInfo->pControls[k].Attach(pDC, pControl);
  512. k++;
  513. }
  514. }
  517. ASSERT(k == nVisibleCount);
  519. m_bReduced = FALSE;
  520. m_nRowCount = 2;
  521. }
  523. void CXTPRibbonGroup::OnAfterCalcSize()
  524. {
  525. if (!m_pLayoutInfo)
  526. return;
  528. for (int i = 0; i < m_pLayoutInfo->nControlCount; i++)
  529. {
  530. if (i == 0)
  531. m_pLayoutInfo->pControls[i].bWrap = TRUE;
  533. m_pLayoutInfo->pControls[i].Detach();
  534. }
  536. if (m_pLayoutInfo->bOldReduced && !m_bReduced)
  537. {
  538. GetRibbonBar()->m_bGroupReducedChanged = TRUE;
  540. }
  542. delete[] m_pLayoutInfo->pControls;
  543. delete m_pLayoutInfo;
  544. }
  546. int CXTPRibbonGroup::_WrapSpecialDynamicSize(int nWidth, BOOL bIncludeTail)
  547. {
  548. int nDataCount = m_pLayoutInfo->nControlCount;
  549. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  551. int nWraps = 0, x = 0;
  553. for (int i = 0; i < nDataCount; i++)
  554. {
  555. CONTROLINFO* pControl = &pData[i];
  557. pControl->bWrap = FALSE;
  558. CSize szControl = pControl->szControl;
  559. BOOL bBeginGroup = pControl->bBeginGroup && i > 0;
  560. BOOL bWrapGroup = pControl->bWrapGroup && i > 0;
  562. if (bWrapGroup && (pControl->pControl->GetFlags() & xtpFlagWrapRow))
  563. {
  564. x = szControl.cx;
  565. pControl->bWrap = TRUE;
  566. nWraps++;
  567. continue;
  568. }
  569. else if (bWrapGroup)
  570. {
  571. if ((bIncludeTail && (x + pControl->nTailWidth >= nWidth))
  572. || (!bIncludeTail && nWraps == 0 && (x + pControl->nTailWidth >= nWidth)))
  573. {
  574. x = szControl.cx;
  575. pControl->bWrap = TRUE;
  576. nWraps++;
  577. continue;
  578. }
  579. }
  581. if (bBeginGroup)
  582. x += 3;
  584. x += szControl.cx;
  585. }
  586. return nWraps;
  587. }
  589. int CXTPRibbonGroup::_GetSizeSpecialDynamicSize()
  590. {
  591. int nTotalWidth = 0, x = 0, y = 0, nRowHeight = 0;
  593. int nDataCount = m_pLayoutInfo->nControlCount;
  594. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  596. for (int i = 0; i < nDataCount; i++)
  597. {
  598. CONTROLINFO* pControl = &pData[i];
  600. CSize szControl = pControl->szControl;
  602. if (pControl->bWrap)
  603. {
  604. x = 0;
  605. y += nRowHeight;
  606. }
  607. else
  608. {
  609. BOOL bBeginGroup = pControl->bBeginGroup && i > 0;
  611. if (bBeginGroup)
  612. x += 3;
  613. }
  615. pControl->rcControl.SetRect(2 + x, y, 2 + x + szControl.cx, y + szControl.cy);
  617. x += szControl.cx;
  618. nRowHeight = max(nRowHeight, szControl.cy);
  619. nTotalWidth = max(nTotalWidth, x);
  620. }
  621. return nTotalWidth + 4;
  622. }
  624. BOOL CXTPRibbonGroup::_FindBestWrapSpecialDynamicSize()
  625. {
  626. int nMax = _GetSizeSpecialDynamicSize();
  627. int nMin = 0, nMid = 0;
  629. int nCurrent = _WrapSpecialDynamicSize(nMin, TRUE);
  630. int nTarget = 2;
  631. if (nCurrent < nTarget)
  632. return FALSE;
  634. if (nCurrent == nTarget)
  635. return TRUE;
  637. while (nMin < nMax)
  638. {
  639. nMid = (nMin + nMax) / 2;
  640. nCurrent = _WrapSpecialDynamicSize(nMid, TRUE);
  642. if (nCurrent <= nTarget)
  643. {
  644. nMax = nMid;
  645. }
  646. else
  647. {
  648. if (nMin == nMid)
  649. {
  650. _WrapSpecialDynamicSize(nMax, TRUE);
  651. break;
  652. }
  653. nMin = nMid;
  654. }
  655. }
  657. return TRUE;
  658. }
  660. int CXTPRibbonGroup::_CalcSpecialDynamicSize(CDC* /*pDC*/)
  661. {
  662. int nResultHeight = GetRibbonBar()->CalcGroupsHeight() - 9 -
  663. GetRibbonBar()->GetRibbonPaintManager()->GetGroupCaptionHeight();
  665. int i;
  667. int nDataCount = m_pLayoutInfo->nControlCount;
  668. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  670. int nTailWidth = 0;
  671. for (i = nDataCount - 1; i >= 0; i--)
  672. {
  673. CONTROLINFO* pControl = &pData[i];
  675. CSize szControl = pControl->szControl;
  677. nTailWidth += szControl.cx;
  678. pControl->nTailWidth = nTailWidth;
  680. if (pControl->bWrapGroup)
  681. {
  682. nTailWidth = 0;
  683. }
  684. }
  686. int nBaseHeight = GetRibbonBar()->GetRibbonPaintManager()->GetEditHeight();
  688. int nRowCount = _WrapSpecialDynamicSize(32000, FALSE) + 1;
  689. int nTotalWidth = 0;
  691. if (nRowCount == 1)
  692. {
  693. nRowCount = 3;
  694. nTotalWidth = _GetSizeSpecialDynamicSize();
  696. BOOL bAllow3Row = nResultHeight >= nBaseHeight * 3;
  697. BOOL bAllow2Row = nResultHeight >= nBaseHeight * 2 ;
  699. if (!bAllow2Row)
  700. {
  701. _WrapSpecialDynamicSize(32000, FALSE);
  702. nRowCount = 1;
  704. }
  705. else
  706. {
  707. if (!(bAllow3Row && m_nRowCount == 3 && _FindBestWrapSpecialDynamicSize()))
  708. {
  709. nRowCount = _WrapSpecialDynamicSize(nTotalWidth / 2, FALSE) + 1;
  710. }
  711. }
  712. }
  714. nTotalWidth = _GetSizeSpecialDynamicSize();
  716. int nOffset = (nResultHeight + 1 - nBaseHeight * nRowCount) / (nRowCount + 1);
  717. int nTotalOffset = nOffset;
  718. int nRow = 0;
  720. for (i = 0; i < nDataCount; i++)
  721. {
  722. CONTROLINFO* pControl = &pData[i];
  724. if (i > 0 && pControl->bWrap)
  725. {
  726. nOffset = (nResultHeight - nBaseHeight * nRowCount - nTotalOffset) / (nRowCount - nRow);
  727. nTotalOffset += nOffset;
  728. nRow++;
  729. }
  731. pControl->rcControl.OffsetRect(0, nTotalOffset);
  733. }
  736. m_pLayoutInfo->nWidth = nTotalWidth;
  738. return max(m_pLayoutInfo->nWidth, m_pLayoutInfo->nMinWidth);
  739. }
  741. int CXTPRibbonGroup::OnCalcDynamicSize(CDC* pDC)
  742. {
  743. if (m_bReduced)
  744. {
  745. CSize szControl = GetControlGroupPopup()->GetSize(pDC);
  746. return m_pLayoutInfo->nWidth = szControl.cx - 5;
  747. }
  749. if (m_bControlsGrouping)
  750. return _CalcSpecialDynamicSize(pDC);
  752. int nResultHeight = GetRibbonBar()->CalcGroupsHeight() - 9 -
  753. GetRibbonBar()->GetRibbonPaintManager()->GetGroupCaptionHeight() ;
  755. CSize sizeResult(0, nResultHeight);
  758. int dyPrev = 0, dxPrev = 0, x = 2;
  760. int nDataCount = m_pLayoutInfo->nControlCount;
  761. CONTROLINFO* pData = m_pLayoutInfo->pControls;
  763. for (int i = 0; i < nDataCount; i++)
  764. {
  765. CONTROLINFO* pControl = &pData[i];
  767. BOOL bFullRow = pControl->pControl->GetStyle() == xtpButtonIconAndCaptionBelow;
  768. pControl->EnsureButtonSize(pDC);
  769. CSize szControl = pControl->szControl;
  771. int dx = szControl.cx;
  772. int dy = szControl.cy;
  774. BOOL bBeginGroup = pControl->bBeginGroup && i > 0;
  775. BOOL bWrapGroup = pControl->bWrapGroup && i > 0;
  777. if (bBeginGroup)
  778. x += 6;
  780. if (i > 0 && !bWrapGroup && !bFullRow && dyPrev + dy <= nResultHeight)
  781. {
  782. pControl->rcControl.SetRect(x, dyPrev, x + dx, dyPrev + dy);
  784. dxPrev = max(dxPrev, dx);
  785. }
  786. else
  787. {
  788. x += dxPrev;
  789. pControl->rcControl.SetRect(x, 0, x + dx, dy);
  790. dxPrev = dx;
  791. }
  792. sizeResult.cx = max(x + dx, sizeResult.cx);
  794. dyPrev = pControl->rcControl.bottom;
  795. }
  797. m_pLayoutInfo->nWidth = sizeResult.cx + 2;
  799. return max(m_pLayoutInfo->nWidth, m_pLayoutInfo->nMinWidth);
  800. }
  802. void CXTPRibbonGroups::_ReduceSmartLayoutToolBar(CDC* pDC, int* pWidth, int nWidth)
  803. {
  804. int nResult = _CalcSmartLayoutToolBar(pWidth);
  805. if (nResult <= nWidth)
  806. {
  807. if (nResult == nWidth)
  808. return;
  810. for (int i = GetCount() - 1; i >= 0; i--)
  811. {
  812. CXTPRibbonGroup* pGroup = GetAt(i);
  813. if (!pGroup->IsVisible())
  814. continue;
  816. if (pGroup->OnExtendSize(nWidth - nResult))
  817. {
  818. pWidth[i] = pGroup->OnCalcDynamicSize(pDC);
  819. break;
  820. }
  821. }
  823. return;
  824. }
  826. BOOL bReduced = FALSE;
  828. do
  829. {
  830. bReduced = FALSE;
  832. for (int nLevel = 0; nLevel < 4; nLevel++)
  833. {
  834. for (int i = GetCount() - 1; i >= 0; i--)
  835. {
  836. CXTPRibbonGroup* pGroup = GetAt(i);
  837. if (!pGroup->IsVisible())
  838. continue;
  840. if (pGroup->OnReduceSize(nLevel, nResult - nWidth))
  841. {
  842. int nGroupWidth = pGroup->OnCalcDynamicSize(pDC);
  844. nResult -= (pWidth[i] - nGroupWidth);
  845. pWidth[i] = nGroupWidth;
  847. bReduced = TRUE;
  848. break;
  849. }
  850. }
  852. if (bReduced)
  853. break;
  854. }
  856. if (bReduced && nResult <= nWidth)
  857. {
  858. return;
  859. }
  860. }
  861. while (bReduced);
  862. }
  864. int CXTPRibbonGroups::_CalcSmartLayoutToolBar(int* pWidth)
  865. {
  866. int nWidth = 0;
  867. for (int i = 0; i < GetCount(); i++)
  868. {
  869. nWidth += pWidth[i];
  871. if (i != GetCount() - 1 && pWidth[i] != 0)
  872. {
  873. nWidth += 7;
  874. }
  875. }
  876. return nWidth;
  877. }
  880. void CXTPRibbonGroup::CenterColumn(int nFirstItem, int nLastItem, int nGroupHeight)
  881. {
  882. int nHeight = 0;
  883. int i;
  884. for (i = nFirstItem; i <= nLastItem; i++)
  885. {
  886. CONTROLINFO* pControl = &m_pLayoutInfo->pControls[i];
  888. if (pControl->bHide)
  889. continue;
  891. nHeight +=pControl->rcControl.Height();
  892. }
  894. if (nHeight >= nGroupHeight)
  895. return;
  897. int nItems = nLastItem - nFirstItem + 1;
  898. int nOffset = (nGroupHeight - nHeight) / (nItems + 1);
  900. for (i = nFirstItem; i <= nLastItem; i++)
  901. {
  902. CONTROLINFO* pControl = &m_pLayoutInfo->pControls[i];
  904. if (pControl->bHide)
  905. continue;
  907. pControl->rcControl.OffsetRect(0, nOffset);
  908. nOffset += nOffset;
  909. }
  910. }
  912. void CXTPRibbonGroup::OnAdjustBorders(int nWidth, CRect rcBorder)
  913. {
  914. CXTPRibbonTheme* pPaintManager = GetRibbonBar()->GetRibbonPaintManager();
  915. int nGroupCaptionHeigh = pPaintManager->GetGroupCaptionHeight();
  916. int nGroupHeight = GetRibbonBar()->CalcGroupsHeight();
  917. int nGroupClientHeight = nGroupHeight - 2 - 3 - 2;
  919. int i;
  920. BOOL bFirstItem = TRUE;
  921. int nFirstItem = 0;
  922. int nColumn = 0;
  923. BOOL bCenterItems = m_bControlsCentering;
  924. if (IsControlsGrouping())
  925. bCenterItems = FALSE;
  927. int nControlCount = m_pLayoutInfo ? m_pLayoutInfo->nControlCount : 0;
  929. int nLeftOffset = 2;
  930. if (m_pLayoutInfo && m_bControlsCentering && m_pLayoutInfo->nWidth < m_pLayoutInfo->nMinWidth && nWidth == m_pLayoutInfo->nMinWidth)
  931. nLeftOffset = 2 + (m_pLayoutInfo->nMinWidth - m_pLayoutInfo->nWidth) / 2;
  933. for (i = 0; i < nControlCount; i++)
  934. {
  935. CONTROLINFO* pControl = &m_pLayoutInfo->pControls[i];
  937. if (pControl->bHide)
  938. continue;
  940. pControl->rcControl.OffsetRect(rcBorder.left + nLeftOffset, rcBorder.top + 2);
  941. pControl->rcRow = CRect(rcBorder.left, rcBorder.top,
  942. rcBorder.left + nWidth, rcBorder.top + nGroupClientHeight - nGroupCaptionHeigh);
  944. if (bCenterItems && !bFirstItem)
  945. {
  946. if (nColumn != pControl->rcControl.left)
  947. {
  948. CenterColumn(nFirstItem, i - 1, nGroupClientHeight - nGroupCaptionHeigh - 3);
  949. nColumn = pControl->rcControl.left;
  950. nFirstItem = i;
  951. }
  952. }
  953. else
  954. {
  955. bFirstItem = FALSE;
  956. nColumn = pControl->rcControl.left;
  957. }
  958. }
  959. if (bCenterItems && nControlCount > 0) CenterColumn(nFirstItem, m_pLayoutInfo->nControlCount - 1, nGroupClientHeight - nGroupCaptionHeigh - 3);
  961. int nBeginGroup = rcBorder.left;
  962. int nEndGroup = nBeginGroup + nWidth + 5;
  964. SetRect(CRect(nBeginGroup, rcBorder.top, nEndGroup,  rcBorder.top + nGroupClientHeight));
  965. }
  968. void CXTPRibbonGroups::CalcDynamicSize(CDC* pDC, int nLength, DWORD /*dwMode*/, const CRect& rcBorder)
  969. {
  970. CXTPRibbonScrollableBar* pScrollableBar = GetScrollableBar(m_pParentTab->GetParent());
  972. int nCount = GetCount();
  974. if (nCount == 0)
  975. {
  976. pScrollableBar->EnableGroupsScroll(FALSE, FALSE);
  977. return;
  978. }
  980. int* pData = new int[nCount];
  981. int i;
  983. for (i = 0; i < nCount; i++)
  984. {
  985. CXTPRibbonGroup* pGroup = GetAt(i);
  986. if (pGroup->IsVisible())
  987. {
  988. pGroup->OnBeforeCalcSize(pDC);
  989. }
  990. }
  992. for (i = 0; i < nCount; i++)
  993. {
  994. CXTPRibbonGroup* pGroup = GetAt(i);
  995. pData[i] = pGroup->IsVisible() ? pGroup->OnCalcDynamicSize(pDC) : 0;
  996. }
  998. int nGroupsLength = nLength - rcBorder.right - rcBorder.left;
  1000. _ReduceSmartLayoutToolBar(pDC, pData, nGroupsLength);
  1002. CRect rcBorders = rcBorder;
  1004. int nTotalWidth = -7;
  1006. for (i = 0; i < nCount; i++)
  1007. {
  1008. CXTPRibbonGroup* pGroup = GetAt(i);
  1009. if (pGroup->IsVisible())
  1010. {
  1011. nTotalWidth += pData[i] + 2 + 5;
  1012. }
  1013. }
  1015. int nScrollPos = pScrollableBar->m_nGroupsScrollPos;
  1017. if (nTotalWidth > nGroupsLength)
  1018. {
  1019. if (nScrollPos > nTotalWidth - nGroupsLength)
  1020. {
  1021. nScrollPos = nTotalWidth - nGroupsLength;
  1022. }
  1023. }
  1024. else
  1025. {
  1026. nScrollPos = 0;
  1027. }
  1028. if (nScrollPos < 0) nScrollPos = 0;
  1030. m_nGroupsScrollPos = nScrollPos;
  1032. pScrollableBar->EnableGroupsScroll(nScrollPos > 0, nTotalWidth - nGroupsLength - nScrollPos > 0);
  1034. rcBorders.left -= nScrollPos;
  1036. for (i = 0; i < nCount; i++)
  1037. {
  1038. CXTPRibbonGroup* pGroup = GetAt(i);
  1039. if (pGroup->IsVisible())
  1040. {
  1041. pGroup->OnAdjustBorders(pData[i], rcBorders);
  1042. rcBorders.left += pData[i] + 2 + 5;
  1043. }
  1044. }
  1046. for (i = 0; i < nCount; i++)
  1047. {
  1048. CXTPRibbonGroup* pGroup = GetAt(i);
  1049. if (pGroup->IsVisible())
  1050. {
  1051. pGroup->OnAfterCalcSize();
  1052. }
  1053. }
  1055. delete[] pData;
  1056. }
  1058. void CXTPRibbonGroup::DoPropExchange(CXTPPropExchange* pPX)
  1059. {
  1060. PX_Int(pPX, _T("Id"), m_nId, 0);
  1061. PX_Int(pPX, _T("IconId"), m_nIconId, 0);
  1062. PX_Bool(pPX, _T("ShowOptionButton"), m_bShowOptionButton, FALSE);
  1063. PX_String(pPX, _T("Caption"), m_strCaption, _T(""));
  1064. PX_Bool(pPX, _T("ControlsGrouping"), m_bControlsGrouping, FALSE);
  1065. PX_Bool(pPX, _T("ControlsCentering"), m_bControlsCentering, FALSE);
  1066. PX_Bool(pPX, _T("Visible"), m_bVisible, TRUE);
  1068. if (pPX->IsStoring())
  1069. {
  1070. CXTPPropExchangeSection secControls(pPX->GetSection(_T("Controls")));
  1072. long nCount = 0;
  1073. int i;
  1074. for (i = 0; i < m_arrControls.GetSize(); i++)
  1075. {
  1076. CXTPControl* pControl = GetAt(i);
  1077. if (!pControl->IsTemporary()) nCount++;
  1078. }
  1080. CXTPPropExchangeEnumeratorPtr pEnumerator(secControls->GetEnumerator(_T("Control")));
  1081. POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);
  1083. for (i = 0; i < (int)m_arrControls.GetSize(); i++)
  1084. {
  1085. CXTPControl* pControl = GetAt(i);
  1086. if (!pControl->IsTemporary())
  1087. {
  1088. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1089. PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));
  1090. }
  1091. }
  1092. }
  1093. else
  1094. {
  1095. m_pGroups = (CXTPRibbonGroups*)pPX->m_pOwner;
  1096. m_pParent = m_pRibbonBar = m_pGroups->GetRibbonBar();
  1098. OnGroupAdded();
  1100. CXTPPropExchangeSection secControls(pPX->GetSection(_T("Controls")));
  1102. CXTPPropExchangeEnumeratorPtr pEnumerator(secControls->GetEnumerator(_T("Control")));
  1103. POSITION posEnum = pEnumerator->GetPosition(0, FALSE);
  1105. RemoveAll();
  1107. while (posEnum)
  1108. {
  1109. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1111. CXTPControl* pControl = NULL;
  1112. PX_Object(&secItem, pControl, RUNTIME_CLASS(CXTPControl));
  1114. if (!pControl)
  1115. AfxThrowArchiveException(CArchiveException::badClass);
  1117. pControl->m_pRibbonGroup = this;
  1118. pControl->InternalAddRef();
  1119. m_pRibbonBar->GetControls()->InsertAt(pControl, m_pControlGroupOption->GetIndex());
  1121. m_arrControls.Add(pControl);
  1122. }
  1123. }
  1125. CXTPPropExchangeSection secControlGroupOption(pPX->GetSection(_T("ControlGroupOption")));
  1126. m_pControlGroupOption->DoPropExchange(&secControlGroupOption);
  1128. CXTPPropExchangeSection secControlGroupPopup(pPX->GetSection(_T("ControlGroupPopup")));
  1129. m_pControlGroupPopup->DoPropExchange(&secControlGroupPopup);
  1130. }
  1132. void CXTPRibbonGroups::DoPropExchange(CXTPPropExchange* pPX)
  1133. {
  1134. if (pPX->IsStoring())
  1135. {
  1136. long nCount = GetCount();
  1137. int i;
  1139. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Group")));
  1140. POSITION posEnum = pEnumerator->GetPosition(nCount, FALSE);
  1142. for (i = 0; i < nCount; i++)
  1143. {
  1144. CXTPRibbonGroup* pGroup = GetAt(i);
  1146. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1147. PX_Object(&secItem, pGroup, RUNTIME_CLASS(CXTPRibbonGroup));
  1148. }
  1149. }
  1150. else
  1151. {
  1152. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Group")));
  1153. POSITION posEnum = pEnumerator->GetPosition(0, FALSE);
  1155. RemoveAll();
  1157. while (posEnum)
  1158. {
  1159. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1160. secItem->m_pOwner = this;
  1161. CXTPRibbonGroup* pGroup = NULL;
  1162. PX_Object(&secItem, pGroup, RUNTIME_CLASS(CXTPRibbonGroup));
  1164. if (!pGroup)
  1165. AfxThrowArchiveException(CArchiveException::badClass);
  1167. m_arrGroups.Add(pGroup);
  1168. RefreshIndexes();
  1169. }
  1170. }
  1171. }