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

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

对话框与窗口

开发平台：

Visual C++

XTPControls.cpp：源码内容
  1. // XTPControls.cpp : implementation of the CXTPControls class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPImageManager.h"
  25. #include "Common/XTPResourceManager.h"
  27. #include "XTPControls.h"
  28. #include "XTPCommandBar.h"
  29. #include "XTPPopupBar.h"
  30. #include "XTPControl.h"
  31. #include "XTPControlButton.h"
  32. #include "XTPControlPopup.h"
  33. #include "XTPControlComboBox.h"
  34. #include "XTPControlEdit.h"
  35. #include "XTPControlCustom.h"
  36. #include "XTPControlGallery.h"
  37. #include "XTPControlExt.h"
  38. #include "XTPToolBar.h"
  39. #include "XTPCommandBars.h"
  40. #include "XTPPaintManager.h"
  42. #ifdef _DEBUG
  43. #define new DEBUG_NEW
  44. #undef THIS_FILE
  45. static char THIS_FILE[] = __FILE__;
  46. #endif
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CCommandBarControls
  51. IMPLEMENT_DYNCREATE(CXTPControls, CCmdTarget)
  52. IMPLEMENT_DYNCREATE(CXTPOriginalControls, CXTPControls)
  54. CXTPControls::CXTPControls()
  55. {
  56. EnableAutomation();
  59. m_pParent = 0;
  60. m_pCommandBars = 0;
  62. m_pOriginalControls = 0;
  63. m_bOriginalControls = FALSE;
  64. }
  66. CXTPControls::~CXTPControls()
  67. {
  68. RemoveAll();
  70. CMDTARGET_RELEASE(m_pOriginalControls);
  71. }
  73. CXTPOriginalControls::CXTPOriginalControls()
  74. {
  75. m_bOriginalControls = TRUE;
  76. }
  78. CXTPCommandBars* CXTPControls::GetCommandBars() const
  79. {
  80. return m_pParent ? m_pParent->GetCommandBars() : m_pCommandBars;
  81. }
  82. void CXTPControls::SetCommandBars(CXTPCommandBars* pCommandBars)
  83. {
  84. m_pCommandBars = pCommandBars;
  85. }
  87. void CXTPControls::RefreshIndexes()
  88. {
  89. for (int nIndex = 0; nIndex < GetCount(); nIndex++)
  90. {
  91. CXTPControl* pControl = GetAt(nIndex);
  92. pControl->m_nIndex = nIndex;
  93. pControl->m_pControls = this;
  94. pControl->SetParent(m_pParent);
  95. }
  96. if (m_pParent)
  97. {
  98. m_pParent->OnControlsChanged();
  99. }
  100. }
  102. void CXTPControls::SetParent(CXTPCommandBar* pParent)
  103. {
  104. m_pParent = pParent;
  105. if (GetCount() > 0) RefreshIndexes();
  106. }
  109. CXTPControl* CXTPControls::AddMenuItem(CMenu* pMenu, int nIndex)
  110. {
  111. CMenu* pPopupMenu = pMenu->GetSubMenu(nIndex);
  113. CXTPControl* pControl = NULL;
  114. UINT nID = pMenu->GetMenuItemID(nIndex);
  116. BOOL bDefaultItem = (int)::GetMenuDefaultItem(pMenu->m_hMenu, TRUE, GMDI_USEDISABLED) == nIndex;
  118. if (nID == AFX_IDM_FIRST_MDICHILD)
  119. return NULL;
  121. CString strCaption;
  122. XTPResourceManager()->GetMenuLocaleString(pMenu, nIndex, strCaption, MF_BYPOSITION);
  124. if (pPopupMenu)
  125. {
  126. int iPos = strCaption.Find(_T('t'));
  127. if (pPopupMenu &&  iPos > 0)
  128. {
  129. nID = _ttoi(strCaption.Mid(iPos + 1));
  130. if (nID > 0) strCaption.ReleaseBuffer(iPos);
  131. }
  132. }
  135. CWnd* pSite = m_pCommandBars ? m_pCommandBars->GetSite() :
  136. m_pParent ? m_pParent->GetOwnerSite() : NULL;
  138. CXTPCommandBars* pCommandBars = GetCommandBars();
  140. XTPControlType controlType = pPopupMenu ? xtpControlPopup : xtpControlButton;
  142. XTPButtonStyle buttonStyle = xtpButtonAutomatic;
  144. XTP_COMMANDBARS_CREATECONTROL cs;
  146. if (pSite)
  147. {
  148. cs.nID = nID;
  149. cs.pControl = NULL;
  150. cs.bToolBar = FALSE;
  151. cs.pCommandBar = m_pParent;
  152. cs.pMenu = pMenu;
  153. cs.nIndex = nIndex;
  154. cs.strCaption = strCaption;
  155. cs.controlType = controlType;
  156. cs.buttonStyle = buttonStyle;
  158. if (pSite->SendMessage(WM_XTP_BEFORECREATECONTROL, 0, (LPARAM)&cs) != 0)
  159. {
  160. pControl = cs.pControl;
  161. controlType = cs.controlType;
  162. strCaption = cs.strCaption;
  163. nID = cs.nID;
  164. buttonStyle = cs.buttonStyle;
  165. }
  166. }
  168. if (pControl == NULL)
  169. {
  170. switch (controlType)
  171. {
  172. case xtpControlButton:
  173. if (nID == XTP_ID_WINDOWLIST) pControl = (CXTPControl*)CXTPControlWindowList::CreateObject();
  174. else if (nID == XTP_ID_WORKSPACE_ACTIONS) pControl = (CXTPControl*)CXTPControlWorkspaceActions::CreateObject();
  175. else if (nID == ID_VIEW_TOOLBAR) pControl = (CXTPControl*)CXTPControlToolbars::CreateObject();
  176. else if (nID == ID_OLE_VERB_FIRST && strCaption == _T("<<OLE VERBS GO HERE>>")) pControl = (CXTPControl*)CXTPControlOleItems::CreateObject();
  177. else if (nID == ID_FILE_MRU_FILE1) pControl = (CXTPControl*)CXTPControlRecentFileList::CreateObject();
  178. else pControl = (CXTPControl*)CXTPControlButton::CreateObject();
  179. break;
  181. case xtpControlComboBox:
  182. pControl = (CXTPControl*)CXTPControlComboBox::CreateObject();
  183. break;
  185. case xtpControlEdit:
  186. pControl = (CXTPControl*)CXTPControlEdit::CreateObject();
  187. break;
  188. case xtpControlLabel:
  189. pControl = (CXTPControl*)CXTPControlLabel::CreateObject();
  190. break;
  192. case xtpControlCheckBox:
  193. pControl = (CXTPControl*)CXTPControlCheckBox::CreateObject();
  194. break;
  196. case xtpControlRadioButton:
  197. pControl = (CXTPControl*)CXTPControlRadioButton::CreateObject();
  198. break;
  200. case xtpControlGallery:
  201. pControl = (CXTPControl*)CXTPControlGallery::CreateObject();
  202. break;
  204. case xtpControlPopup:
  205. case xtpControlSplitButtonPopup:
  206. case xtpControlButtonPopup:
  207. pControl = CXTPControlPopup::CreateControlPopup(controlType);
  208. CXTPPopupBar* pPopupBar = 0;
  209. CString strCaptionPopup(strCaption);
  210. CXTPPaintManager::StripMnemonics(strCaptionPopup);
  212. if (pSite)
  213. {
  214. XTP_COMMANDBARS_CREATEBAR cb;
  215. ZeroMemory(&cb, sizeof(cb));
  216. cb.bPopup = TRUE;
  217. cb.lpcstrCaption = strCaptionPopup;
  218. cb.nID = nID;
  220. if (pSite->SendMessage(WM_XTP_CREATECOMMANDBAR, 0, (LPARAM)&cb) != 0)
  221. {
  222. pPopupBar = DYNAMIC_DOWNCAST(CXTPPopupBar, cb.pCommandBar);
  223. strCaptionPopup = cb.lpcstrCaption;
  224. }
  225. }
  227. if (pPopupBar == NULL) pPopupBar = CXTPPopupBar::CreatePopupBar(pCommandBars);
  228. pPopupBar->SetTitle(strCaptionPopup);
  232. CMenu menu;
  233. if (!pPopupMenu && nID > 0 && menu.LoadMenu(nID))
  234. {
  235. pPopupMenu = menu.GetSubMenu(0);
  236. }
  237. if (pPopupMenu) pPopupBar->LoadMenu(pPopupMenu, FALSE);
  239. ((CXTPControlPopup*)pControl)->m_pCommandBar = pPopupBar;
  241. break;
  242. }
  244. ASSERT(pControl);
  245. if (!pControl)
  246. return NULL;
  247. pControl->m_controlType = controlType;
  248. pControl->SetStyle(buttonStyle);
  249. }
  251. CXTPControlAction* pAction = pCommandBars->FindAction(nID);
  253. if (pControl->GetAction() != NULL)
  254. {
  256. }
  257. else if (pAction || (pCommandBars->IsActionsEnabled() && nID > 0 && nID < 0xFFFFFFF))
  258. {
  259. if (pAction == NULL) pAction = pCommandBars->CreateAction(nID);
  260. pControl->SetAction(pAction);
  262. if (pAction->m_strCaption.IsEmpty())
  263. pAction->SetCaption(strCaption);
  264. }
  265. else
  266. {
  267. pControl->SetID(nID);
  268. pControl->SetCaption(strCaption);
  269. }
  271. if (bDefaultItem) pControl->SetItemDefault(bDefaultItem);
  273. m_arrControls.InsertAt(GetCount(), pControl);
  274. OnControlAdded(pControl);
  276. if (pSite)
  277. {
  278. cs.pControl = pControl;
  279. pSite->SendMessage(WM_XTP_AFTERCREATECONTROL, 0, (LPARAM)&cs);
  280. }
  283. return pControl;
  284. }
  286. void CXTPControls::OnControlAdded(CXTPControl* /*pControl*/)
  287. {
  288. RefreshIndexes();
  289. }
  291. void CXTPControls::OnControlRemoved(CXTPControl* pControl)
  292. {
  293. pControl->m_pControls = NULL;
  294. pControl->OnRemoved();
  296. pControl->m_pParent = NULL;
  298. RefreshIndexes();
  299. }
  302. CXTPControl* CXTPControls::Add(XTPControlType controlType, int nId, LPCTSTR strParameter, int nBefore, BOOL bTemporary)
  303. {
  304. CXTPControl* pControl = NULL;
  305. CXTPCommandBars* pCommandBars = GetCommandBars();
  307. switch (controlType)
  308. {
  309. case xtpControlCustom:
  310. return Add(new CXTPControlCustom(), nId, strParameter, nBefore, bTemporary);
  312. case xtpControlButton:
  313. if (nId == XTP_ID_WINDOWLIST) pControl = (CXTPControl*)CXTPControlWindowList::CreateObject();
  314. else if (nId == XTP_ID_WORKSPACE_ACTIONS) pControl = (CXTPControl*)CXTPControlWorkspaceActions::CreateObject();
  315. else if (nId == ID_VIEW_TOOLBAR) pControl = (CXTPControl*)CXTPControlToolbars::CreateObject();
  316. else if (nId == XTP_ID_FILE_MRU) pControl = (CXTPControl*)CXTPControlRecentFileList::CreateObject();
  317. else
  318. pControl = (CXTPControl*)CXTPControlButton::CreateObject();
  319. break;
  321. case xtpControlComboBox:
  322. pControl = (CXTPControl*)CXTPControlComboBox::CreateObject();
  323. break;
  325. case xtpControlLabel:
  326. pControl = (CXTPControl*)CXTPControlLabel::CreateObject();
  327. break;
  329. case xtpControlCheckBox:
  330. pControl = (CXTPControl*)CXTPControlCheckBox::CreateObject();
  331. break;
  333. case xtpControlRadioButton:
  334. pControl = (CXTPControl*)CXTPControlRadioButton::CreateObject();
  335. break;
  337. case xtpControlGallery:
  338. pControl = (CXTPControl*)CXTPControlGallery::CreateObject();
  339. break;
  341. case xtpControlEdit:
  342. pControl = (CXTPControl*)CXTPControlEdit::CreateObject();
  343. break;
  345. case xtpControlPopup:
  346. case xtpControlSplitButtonPopup:
  347. case xtpControlButtonPopup:
  348. CXTPControlPopup* pControlPopup = (CXTPControlPopup*)CXTPControlPopup::CreateObject();
  349. CXTPPopupBar* pPopupBar = 0;
  351. CMenu menu;
  352. if (nId > 0)
  353. {
  354. CString strCaption;
  355. CMenu* pPopupMenu = NULL;
  357. if (menu.LoadMenu(nId))
  358. {
  359. pPopupMenu = menu.GetSubMenu(0);
  360. XTPResourceManager()->GetMenuLocaleString(&menu, 0, strCaption, MF_BYPOSITION);
  361. }
  363. CWnd* pSite = m_pCommandBars ? m_pCommandBars->GetSite() :
  364. m_pParent ? m_pParent->GetOwnerSite() : NULL;
  366. if (pSite)
  367. {
  368. XTP_COMMANDBARS_CREATEBAR cs;
  369. ZeroMemory(&cs, sizeof(cs));
  370. cs.bPopup = TRUE;
  371. cs.lpcstrCaption = strCaption;
  372. cs.nID = nId;
  374. if (pSite->SendMessage(WM_XTP_CREATECOMMANDBAR, 0, (LPARAM)&cs) != 0)
  375. {
  376. pPopupBar = DYNAMIC_DOWNCAST(CXTPPopupBar, cs.pCommandBar);
  377. }
  378. }
  379. if (pPopupBar == NULL) pPopupBar = CXTPPopupBar::CreatePopupBar(GetCommandBars());
  380. pControlPopup->SetCaption(strCaption);
  381. if (pPopupMenu)
  382. {
  383. pPopupBar->LoadMenu(pPopupMenu);
  384. }
  386. }
  388. if (pPopupBar == NULL) pPopupBar = CXTPPopupBar::CreatePopupBar(pCommandBars);
  389. pControlPopup->m_pCommandBar = pPopupBar;
  391. pControl = pControlPopup;
  392. break;
  393. }
  395. ASSERT(pControl);
  396. if (!pControl)
  397. return NULL;
  398. pControl->m_controlType = controlType;
  400. return Add(pControl, nId, strParameter, nBefore, bTemporary);
  401. }
  403. CXTPControl* CXTPControls::Add(CXTPControl* pControl, int nId, LPCTSTR strParameter, int nBefore, BOOL bTemporary)
  404. {
  405. ASSERT(pControl);
  406. if (!pControl)
  407. return NULL;
  409. pControl->m_strParameter = strParameter;
  410. pControl->m_bTemporary = bTemporary;
  412. CXTPCommandBars* pCommandBars = GetCommandBars();
  414. CXTPControlAction* pAction = pCommandBars->FindAction(nId);
  416. if (pControl->GetAction() != NULL)
  417. {
  419. }
  420. else if (pAction != NULL)
  421. {
  422. pControl->SetAction(pAction);
  423. }
  424. else if (pCommandBars->IsActionsEnabled() && nId > 0 && nId < 0xFFFFFFF)
  425. {
  426. if ((nId >= XTP_COMMANDBARS_RESOURCE_FIRST && nId <= XTP_COMMANDBARS_RESOURCE_LAST)
  427. || (nId >= 35000 && nId <= 35003))
  428. {
  429. if (!pAction)
  430. {
  431. pControl->SetID(nId);
  432. }
  433. }
  434. else
  435. {
  436. pAction = pCommandBars->CreateAction(nId);
  437. pControl->SetAction(pAction);
  438. }
  439. }
  440. else
  441. {
  442. pControl->SetID(nId);
  443. }
  445. return InsertAt(pControl, nBefore);
  446. }
  448. CXTPControl* CXTPControls::InsertAt(CXTPControl* pControl, int nBefore)
  449. {
  450. if (nBefore < 0 || nBefore >= GetCount())
  451. nBefore = GetCount();
  453. ASSERT(pControl);
  455. m_arrControls.InsertAt(nBefore, pControl);
  456. OnControlAdded(pControl);
  458. return pControl;
  459. }
  461. CXTPControl* CXTPControls::Add(CXTPControl* pControl)
  462. {
  463. return InsertAt(pControl, -1);
  464. }
  466. CXTPControl* CXTPControls::AddClone(CXTPControl* pControl, int nBefore, BOOL bRecursive)
  467. {
  468. CXTPControl* pClone = (CXTPControl*)pControl->GetRuntimeClass()->CreateObject();
  469. ASSERT(pClone);
  470. if (!pClone)
  471. return NULL;
  473. InsertAt(pClone, nBefore);
  474. pClone->Copy(pControl, bRecursive);
  476. return pClone;
  477. }
  481. void CXTPControls::RemoveAll()
  482. {
  483. for (int nIndex = GetCount() - 1; nIndex >= 0; nIndex--)
  484. {
  485. CXTPControl* pControl = GetAt(nIndex);
  487. if (OnControlRemoving(pControl))
  488. continue;
  490. m_arrControls.RemoveAt(nIndex);
  492. OnControlRemoved(pControl);
  494. pControl->SetParent(NULL);
  495. pControl->InternalRelease();
  496. }
  497. }
  499. CXTPControl* CXTPControls::GetFirst() const
  500. {
  501. return GetCount() > 0 ? GetAt(0) : NULL;
  502. }
  504. void CXTPControls::GetNext(CXTPControl*& pControl) const
  505. {
  506. pControl = (!pControl || pControl->m_nIndex >= GetCount() - 1) ? 0 : GetAt(pControl->m_nIndex + 1);
  507. }
  509. CXTPControl* CXTPControls::FindControl(int nId) const
  510. {
  511. return FindControl(xtpControlError, nId, FALSE, FALSE);
  512. }
  514. CXTPControl* CXTPControls::FindControl(XTPControlType type, int nId, BOOL bVisible, BOOL bRecursive) const
  515. {
  516. for (int nIndex = 0; nIndex < GetCount(); nIndex++)
  517. {
  518. CXTPControl* pControl = GetAt(nIndex);
  519. if ((type == xtpControlError || pControl->GetType() == type) &&
  520. (!bVisible || pControl->IsVisible()) &&
  521. (nId == -1 || nId == pControl->GetID()))
  522. return pControl;
  524. if (bRecursive)
  525. {
  526. CXTPCommandBar* pBar = pControl->GetCommandBar();
  527. if (pBar)
  528. {
  529. pControl = pBar->GetControls()->FindControl(type, nId, bVisible, bRecursive);
  530. if (pControl != NULL) return pControl;
  531. }
  532. }
  533. }
  534. return NULL;
  535. }
  537. BOOL CXTPControls::OnControlRemoving(CXTPControl* /*pControl*/)
  538. {
  539. return FALSE;
  540. }
  542. void CXTPControls::Remove(CXTPControl* pControl)
  543. {
  544. if (pControl && pControl->m_pControls == this)
  545. {
  546. if (pControl->GetSelected())
  547. m_pParent->SetSelected(-1);
  549. ASSERT(pControl->m_pControls == this);
  551. //Ensure the index falls within the correct range.
  552. if ((pControl->m_nIndex >= 0) && (pControl->m_nIndex < GetCount()))
  553. {
  554. ASSERT(m_arrControls[pControl->m_nIndex] == pControl);
  556. if (OnControlRemoving(pControl))
  557. return;
  559. m_arrControls.RemoveAt(pControl->m_nIndex);
  561. OnControlRemoved(pControl);
  563. pControl->SetParent(NULL);
  564. pControl->InternalRelease();
  565. }
  566. }
  567. }
  569. void CXTPControls::Remove(int nIndex)
  570. {
  571. CXTPControl* pControl = GetAt(nIndex);
  572. Remove(pControl);
  573. }
  575. CXTPControl* CXTPControls::SetControlType(int nIndex, XTPControlType type)
  576. {
  577. return SetControlType(GetAt(nIndex), type);
  578. }
  581. CXTPControl* CXTPControls::SetControlType(CXTPControl* pControl, XTPControlType type)
  582. {
  583. ASSERT(pControl->m_pControls == this);
  584. ASSERT(pControl);
  586. if (IsPopupControlType(pControl->GetType()) && IsPopupControlType(type))
  587. {
  588. pControl->m_controlType = type;
  589. return pControl;
  590. }
  592. CXTPControl* pNew = Add(type, 0, _T(""), pControl->GetIndex() + 1, FALSE);
  593. pNew->CXTPControl::Copy(pControl, FALSE);
  594. pNew->m_controlType = type;
  596. Remove(pControl);
  598. return pNew;
  600. }
  603. long CXTPControls::GetNext(long nIndex, int nDirection, BOOL bKeyboard, BOOL bSkipTemporary, BOOL bSkipCollapsed) const
  604. {
  605. ASSERT(nDirection == +1 || nDirection == -1);
  606. if (GetCount() == 0) return -1;
  608. long nNext = nIndex + nDirection;
  610. if (nDirection == -1 && nIndex == -1)
  611. {
  612. nNext = GetCount() - 1;
  613. }
  615. DWORD nSkipVisible = xtpHideScroll | (!bSkipCollapsed ? xtpHideExpand : 0);
  617. BOOL bCircle = FALSE;
  619. while (nNext != nIndex)
  620. {
  621. if (nNext >= GetCount())
  622. {
  623. if ((nIndex == -1 && nDirection == +1) || bCircle) return -1;
  624. nNext = 0;
  625. bCircle = TRUE;
  626. }
  627. if (nNext < 0)
  628. {
  629. if ((nIndex == -1 && nDirection == -1) || bCircle) return -1;
  630. nNext = GetCount() - 1;
  631. bCircle = TRUE;
  632. }
  634. if ((GetAt(nNext)->IsVisible(nSkipVisible)) && (!bKeyboard || !(GetAt(nNext)->m_dwFlags & xtpFlagSkipFocus)))
  635. {
  636. if (!bSkipTemporary || !GetAt(nNext)->m_bTemporary)
  637. return nNext;
  638. }
  639. nNext += nDirection;
  640. }
  641. return nNext;
  642. }
  644. CXTPControl* CXTPControls::HitTest(CPoint point) const
  645. {
  646. for (int i = 0; i < GetCount(); i++)
  647. {
  648. CXTPControl* pControl = GetAt(i);
  650. if (pControl->IsVisible())
  651. {
  652. if (pControl->m_rcControl.PtInRect(point))
  653. return pControl;
  654. }
  656. }
  657. return NULL;
  658. }
  661. struct CXTPControls::XTPBUTTONINFO  // struct for CalcDynamicSize ;
  662. {
  663. CRect rcControl;
  664. CRect rcRow;
  665. CSize szControl;
  666. BOOL bVisible;
  667. BOOL bWrap;
  668. BOOL bHide;
  669. BOOL bBeginGroup;
  670. XTPButtonStyle buttonStyle;
  671. CXTPControl* pControl;
  672. CSize szSeparators;
  673. int nWrapMargin;
  675. void EnsureButtonSize(CDC* pDC)
  676. {
  677. if (buttonStyle != pControl->GetStyle())
  678. {
  679. buttonStyle = pControl->GetStyle();
  680. szControl = pControl->GetSize(pDC);
  681. }
  682. }
  683. void Attach(CDC* pDC, CXTPControl* p)
  684. {
  685. pControl = p;
  686. bHide = bWrap = FALSE;
  687. rcRow.SetRectEmpty();
  689. szControl = pControl->GetSize(pDC);
  690. rcControl = pControl->GetRect();
  691. bBeginGroup = pControl->GetBeginGroup();
  692. bVisible = pControl->IsVisible(xtpHideWrap);
  693. buttonStyle = pControl->GetStyle();
  694. }
  696. void Detach()
  697. {
  698. pControl->SetHideWrap(bHide);
  699. pControl->SetRowRect(rcRow);
  700. if (!bHide)
  701. pControl->SetRect(rcControl);
  702. pControl->SetWrap(bWrap);
  703. }
  705. };
  707. CSize CXTPControls::_CalcSize(XTPBUTTONINFO* pData, BOOL bVert)
  708. {
  709. const CSize& szSeparators = pData->szSeparators;
  710. const int nWrapMargin = pData->nWrapMargin;
  712. CPoint cur(0, 0);
  713. CSize sizeResult(0, 0);
  714. int nRow = 0;
  715. BOOL bFirst = TRUE;
  716. for (int i = 0; i < GetCount(); i++)
  717. {
  718. XTPBUTTONINFO* pControl = &pData[i];
  720. if (!pControl->bVisible || pControl->bHide)
  721. continue;
  723. CSize szControl = pControl->szControl;
  725. if (bVert)
  726. {
  727. if (pControl->bBeginGroup && !pControl->bWrap && !bFirst)
  728. cur.y += szSeparators.cx;
  731. if (pControl->bWrap)
  732. {
  733. cur.x -= nRow + (pControl->bBeginGroup ? szSeparators.cy : nWrapMargin);
  734. nRow = cur.y = 0;
  735. }
  736. nRow = max(nRow, szControl.cx);
  738. pControl->rcControl.SetRect(cur.x - szControl.cx, cur.y, cur.x , cur.y + szControl.cy);
  740. sizeResult.cx = max(szControl.cx - cur.x, sizeResult.cx);
  741. sizeResult.cy = max(cur.y + szControl.cy, sizeResult.cy);
  743. cur.y += szControl.cy;
  745. }
  746. else
  747. {
  749. if (pControl->bBeginGroup && !pControl->bWrap && !bFirst)
  750. cur.x += szSeparators.cx;
  752. if (pControl->bWrap)
  753. {
  754. cur.y += nRow + (pControl->bBeginGroup ? szSeparators.cy : nWrapMargin);
  755. nRow = cur.x = 0;
  756. }
  757. nRow = max(nRow, szControl.cy);
  759. pControl->rcControl.SetRect(cur.x, cur.y, cur.x + szControl.cx, cur.y + szControl.cy);
  761. sizeResult.cx = max(cur.x + szControl.cx, sizeResult.cx);
  762. sizeResult.cy = max(cur.y + szControl.cy, sizeResult.cy);
  764. cur.x += szControl.cx;
  765. }
  766. bFirst = FALSE;
  767. }
  768. return sizeResult;
  769. }
  771. int CXTPControls::_WrapToolBar(XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode)
  772. {
  773. int nResult = 0, x = 0;
  774. BOOL bVert = dwMode & LM_VERTDOCK;
  775. BOOL bFirst = TRUE;
  776. int nSeparator = bVert ? pData->szSeparators.cy : pData->szSeparators.cx;
  778. for (int i = 0; i < GetCount(); i++)
  779. {
  780. XTPBUTTONINFO* pControl = &pData[i];
  781. pControl->bHide = FALSE;
  782. pControl->bWrap = FALSE;
  784. if (!pControl->bVisible)
  785. continue;
  787. int dx = bVert ? pControl->szControl.cy : pControl->szControl.cx;
  789. if (pControl->bBeginGroup && !bFirst)
  790. dx += nSeparator;
  792. BOOL bWrap = (x + dx > nWidth) || ((dwMode & LM_POPUP) && pControl->bBeginGroup && !bFirst);
  794. BOOL bRowWrap = FALSE;
  795. if (pControl->pControl->GetFlags() & xtpFlagWrapRow)
  796. bRowWrap = TRUE;
  798. if (bRowWrap)
  799. {
  800. x = bVert ? pData[i].szControl.cy : pData[i].szControl.cx;
  801. pControl->bWrap = TRUE;
  802. nResult++;
  803. }
  804. else if (bWrap)
  805. {
  806. if (dwMode & LM_HIDEWRAP && !bFirst)
  807. {
  808. BOOL bWrapRowFound = FALSE;
  809. for (int j = i; j < GetCount(); j++)
  810. {
  811. if (pData[j].pControl->GetFlags() & xtpFlagWrapRow)
  812. {
  813. bWrapRowFound = TRUE;
  814. i = j - 1;
  815. break;
  816. }
  817. pData[j].bHide = TRUE;
  818. }
  819. dwMode |= LM_STRETCH;
  821. if (bWrapRowFound)
  822. continue;
  824. return nResult;
  825. }
  827. for (int j = i; j >= 0 && pData[j].bWrap == FALSE; j--)
  828. {
  829. // Find last separator
  830. if (pData[j].bBeginGroup && pData[j].bVisible)
  831. {
  832. i = j;
  833. break;
  834. }
  835. }
  836. x = bVert ? pData[i].szControl.cy : pData[i].szControl.cx;
  838. pData[i].bWrap = TRUE;
  839. if (!(dwMode & LM_HIDEWRAP)) dwMode |= LM_STRETCH;
  840. nResult++;
  841. }
  842. else
  843. x += dx;
  845. bFirst = FALSE;
  847. }
  848. return nResult + 1;
  849. }
  851. void  CXTPControls::_SizePopupToolBar(XTPBUTTONINFO* pData, DWORD dwMode)
  852. {
  853. CSize sizeMax, sizeMin, sizeMid;
  855. // Wrap ToolBar vertically
  856. _WrapToolBar(pData, 0, dwMode);
  857. sizeMin = _CalcSize(pData, FALSE);
  859. // Wrap ToolBar horizontally
  860. _WrapToolBar(pData, 32767, dwMode);
  861. sizeMax = _CalcSize(pData, FALSE);
  863. while (sizeMin.cx < sizeMax.cx)
  864. {
  865. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  867. _WrapToolBar(pData, sizeMid.cx, dwMode);
  868. sizeMid = _CalcSize(pData, FALSE);
  870. if (sizeMid.cy > sizeMid.cx)
  871. {
  872. if (sizeMin == sizeMid)
  873. return;
  875. sizeMin = sizeMid;
  876. }
  877. else if (sizeMid.cy < sizeMid.cx)
  878. sizeMax = sizeMid;
  879. else
  880. return;
  881. }
  882. }
  884. void  CXTPControls::_SizeFloatableBar(XTPBUTTONINFO* pData, int nLength, DWORD dwMode)
  885. {
  886. if (! (dwMode & LM_LENGTHY))
  887. {
  888. int nMin, nMax, nTarget, nCurrent, nMid;
  890. // Wrap ToolBar as specified
  891. nMax = nLength;
  892. nTarget = _WrapToolBar(pData, nMax, dwMode);
  894. // Wrap ToolBar vertically
  895. nMin = 0;
  896. nCurrent = _WrapToolBar(pData, nMin, dwMode);
  898. if (nCurrent != nTarget)
  899. {
  900. while (nMin < nMax)
  901. {
  902. nMid = (nMin + nMax) / 2;
  903. nCurrent = _WrapToolBar(pData, nMid, dwMode);
  905. if (nCurrent == nTarget)
  906. nMax = nMid;
  907. else
  908. {
  909. if (nMin == nMid)
  910. {
  911. _WrapToolBar(pData, nMax, dwMode);
  912. break;
  913. }
  914. nMin = nMid;
  915. }
  916. }
  917. }
  918. CSize size = _CalcSize(pData, FALSE);
  919. _WrapToolBar(pData, size.cx, dwMode);
  920. }
  921. else
  922. {
  923. CSize sizeMax, sizeMin, sizeMid;
  925. // Wrap ToolBar vertically
  926. _WrapToolBar(pData, 0, dwMode);
  927. sizeMin = _CalcSize(pData, FALSE);
  929. // Wrap ToolBar horizontally
  930. _WrapToolBar(pData, 32767, dwMode);
  931. sizeMax = _CalcSize(pData, FALSE);
  933. while (sizeMin.cx < sizeMax.cx)
  934. {
  935. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  936. _WrapToolBar(pData, sizeMid.cx, dwMode);
  937. sizeMid = _CalcSize(pData, FALSE);
  939. if (nLength < sizeMid.cy)
  940. {
  941. if (sizeMin == sizeMid)
  942. {
  943. _WrapToolBar(pData, sizeMax.cx, dwMode);
  944. return;
  945. }
  946. sizeMin = sizeMid;
  947. }
  948. else if (nLength > sizeMid.cy)
  949. sizeMax = sizeMid;
  950. else
  951. return;
  952. }
  953. }
  954. }
  955. void CXTPControls::_CenterControlsInRow(XTPBUTTONINFO* pData, int nFirst, int nLast, int nHeight, BOOL bVert, CSize sizeResult, CRect rcBorder)
  956. {
  957. for (int i = nFirst; i < nLast; i++)
  958. {
  959. XTPBUTTONINFO* pControl = &pData[i];
  960. CRect rc = pControl->rcControl;
  962. if (bVert)
  963. {
  964. pControl->rcRow.SetRect(rc.right - nHeight, rcBorder.top, rc.right, sizeResult.cy + rcBorder.top);
  965. if (!(m_pParent->GetFlags() & xtpFlagSmartLayout)) pControl->rcControl.OffsetRect(-(nHeight - rc.Width())/2, 0);
  966. }
  967. else
  968. {
  969. pControl->rcRow.SetRect(rcBorder.left, rc.top, sizeResult.cx + rcBorder.left, rc.top + nHeight);
  971. if (!(m_pParent->GetFlags() & xtpFlagSmartLayout)) pControl->rcControl.OffsetRect(0, (nHeight - rc.Height())/2);
  972. }
  973. }
  975. }
  977. void CXTPControls::_AdjustBorders(XTPBUTTONINFO* pData, CSize& sizeResult, DWORD dwMode, CRect rcBorder)
  978. {
  979. if (dwMode & LM_COMMIT)
  980. {
  981. BOOL bVert = dwMode & LM_VERTDOCK;
  982. int nFirstInRow = 0;
  983. int nHeight = 0;
  984. int nBarHeight = 0;
  986. for (int i = 0; i < GetCount(); i++)
  987. {
  988. XTPBUTTONINFO* pControl = &pData[i];
  990. if (!pControl->bVisible || pControl->bHide)
  991. continue;
  993. pControl->rcControl.OffsetRect(rcBorder.left, rcBorder.top);
  994. if (bVert) pControl->rcControl.OffsetRect(sizeResult.cx, 0);
  996. if (pControl->bWrap)
  997. {
  998. _CenterControlsInRow(pData, nFirstInRow, i, nHeight, bVert, sizeResult, rcBorder);
  999. nFirstInRow = i;
  1000. nHeight = 0;
  1001. }
  1003. nBarHeight = bVert ? sizeResult.cx : sizeResult.cy;
  1004. nHeight = max(nHeight, bVert ? pControl->rcControl.Width() : pControl->rcControl.Height());
  1005. }
  1006. _CenterControlsInRow(pData, nFirstInRow, GetCount(), nFirstInRow == 0 ? nBarHeight : nHeight, bVert, sizeResult, rcBorder);
  1007. }
  1009. sizeResult += CSize(rcBorder.left + rcBorder.right, rcBorder.top + rcBorder.bottom);
  1010. }
  1012. void CXTPControls::_MoveRightAlligned(XTPBUTTONINFO* pData, CSize sizeResult, CRect rcBorder, DWORD dwMode)
  1013. {
  1014. BOOL bVert = dwMode & LM_VERTDOCK;
  1015. int nRight = bVert ? sizeResult.cy - rcBorder.bottom : sizeResult.cx - rcBorder.right;
  1017. int i;
  1018. for (i = GetCount() - 1; i >= 0; i--)
  1019. {
  1020. XTPBUTTONINFO* pControl = &pData[i];
  1022. if (!pControl->bVisible || pControl->bHide)
  1023. continue;
  1025. if (!(GetAt(i)->m_dwFlags & xtpFlagRightAlign))
  1026. break;
  1028. CRect rc = pControl->rcControl;
  1029. if (!bVert)
  1030. {
  1031. if (nRight - rc.Width() < rcBorder.right)
  1032. break;
  1034. pControl->rcControl.SetRect(nRight - rc.Width(), rc.top, nRight, rc.bottom);
  1035. nRight -= rc.Width();
  1036. }
  1037. else
  1038. {
  1039. if (nRight - rc.Height() < rcBorder.top)
  1040. break;
  1042. pControl->rcControl.SetRect(rc.left, nRight - rc.Height(), rc.right, nRight);
  1043. nRight -= rc.Height();
  1044. }
  1045. if (pControl->bWrap)
  1046. break;
  1047. }
  1049. int nStretchAvail = -1;
  1050. int nStretchedCount = 0;
  1051. BOOL bSkipRightAligned = FALSE;
  1053. nRight = bVert ? sizeResult.cy - rcBorder.bottom : sizeResult.cx - rcBorder.right;
  1054. int nLastInRow = GetCount() - 1;
  1056. for (i = GetCount() - 1; i >= 0; i--)
  1057. {
  1058. XTPBUTTONINFO* pControl = &pData[i];
  1060. if (pControl->bVisible && !pControl->bHide)
  1061. {
  1062. if (!bSkipRightAligned && (GetAt(i)->m_dwFlags & xtpFlagRightAlign))
  1063. {
  1064. nRight = pControl->rcControl.left;
  1065. nLastInRow = i - 1;
  1066. }
  1067. else if (GetAt(i)->m_dwFlags & xtpFlagControlStretched)
  1068. {
  1069. nStretchedCount++;
  1070. bSkipRightAligned = TRUE;
  1071. }
  1073. if ((nStretchAvail == -1) && (nLastInRow >= i))
  1074. {
  1075. nStretchAvail = nRight - (!bVert ? pControl->rcControl.right : pControl->rcControl.bottom);
  1076. }
  1077. }
  1079. if ((pControl->bVisible && !pControl->bHide && pControl->bWrap) || (i == 0))
  1080. {
  1081. if (nStretchedCount > 0 && nStretchAvail > 0)
  1082. {
  1083. int nOffset = 0;
  1084. for (int j = i; j <= nLastInRow; j++)
  1085. {
  1086. pControl = &pData[j];
  1088. if (!pControl->bVisible || pControl->bHide)
  1089. continue;
  1091. CRect rc = pControl->rcControl;
  1092. if (!bVert)
  1093. pControl->rcControl.SetRect(nOffset + rc.left, rc.top, nOffset + rc.right, rc.bottom);
  1094. else
  1095. pControl->rcControl.SetRect(rc.left, nOffset + rc.top, rc.right, nOffset + rc.bottom);
  1097. if ((GetAt(j)->m_dwFlags & xtpFlagControlStretched) && (nStretchedCount > 0))
  1098. {
  1099. int nStretchedOffset = nStretchAvail / nStretchedCount;
  1100. if (!bVert)
  1101. pControl->rcControl.right += nStretchedOffset;
  1102. else
  1103. pControl->rcControl.bottom += nStretchedOffset;
  1105. nStretchAvail -= nStretchedOffset;
  1106. nStretchedCount--;
  1107. nOffset += nStretchedOffset;
  1108. }
  1109. }
  1111. }
  1113. nRight = bVert ? sizeResult.cy - rcBorder.bottom : sizeResult.cx - rcBorder.right;
  1114. bSkipRightAligned = TRUE;
  1115. nLastInRow = i - 1;
  1116. nStretchAvail = -1;
  1117. nStretchedCount = 0;
  1118. }
  1119. }
  1120. }
  1122. int CXTPControls::GetVisibleCount(BOOL bIgnoreWraps) const
  1123. {
  1124. DWORD nFlags = bIgnoreWraps ? 0 : xtpHideWrap;
  1125. int nCount = 0;
  1126. for (int i = 0; i < GetCount(); i++)
  1127. {
  1128. if (GetAt(i)->IsVisible(nFlags)) nCount++;
  1129. }
  1130. return nCount;
  1131. }
  1133. CXTPControl* CXTPControls::GetVisibleAt(int nIndex, BOOL bIgnoreWraps) const
  1134. {
  1135. DWORD nFlags = bIgnoreWraps ? 0 : xtpHideWrap;
  1137. for (int i = 0; i < GetCount(); i++)
  1138. {
  1139. if (GetAt(i)->IsVisible(nFlags))
  1140. {
  1141. if (nIndex == 0)
  1142. return GetAt(i);
  1143. nIndex--;
  1144. }
  1145. }
  1146. return NULL;
  1147. }
  1149. CSize CXTPControls::_ReduceSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode)
  1150. {
  1151. CSize sizeResult(0, 0);
  1152. BOOL bReduced = FALSE;
  1153. BOOL bVert = dwMode & LM_VERTDOCK;
  1155. do
  1156. {
  1157. bReduced = FALSE;
  1159. if (!bReduced)
  1160. {
  1161. for (int i = GetCount() - 1; i >= 2; i--)
  1162. {
  1163. XTPBUTTONINFO* pControl = &pData[i];
  1164. if (!pControl->bVisible || pControl->bBeginGroup)
  1165. continue;
  1167. int nItems = 0;
  1168. int nButtons[3] = {0, 0, 0};
  1170. for (int j = i; j  >= 0; j--)
  1171. {
  1172. pControl = &pData[j];
  1173. if (!pControl->bVisible)
  1174. continue;
  1176. if ((nItems == 2 || !pControl->bBeginGroup) && GetAt(j)->m_buttonStyle == xtpButtonIconAndCaptionBelow)
  1177. {
  1178. nButtons[nItems] = j;
  1179. nItems += 1;
  1180. }
  1181. else
  1182. {
  1183. break;
  1184. }
  1185. if (nItems == 3)
  1186. break;
  1187. }
  1189. if (nItems == 3)
  1190. {
  1191. GetAt(nButtons[0])->m_buttonStyle = xtpButtonIconAndCaption;
  1192. GetAt(nButtons[1])->m_buttonStyle = xtpButtonIconAndCaption;
  1193. GetAt(nButtons[2])->m_buttonStyle = xtpButtonIconAndCaption;
  1194. bReduced = TRUE;
  1195. break;
  1196. }
  1197. }
  1198. }
  1200. if (!bReduced)
  1201. {
  1202. for (int i = GetCount() - 1; i >= 2; i--)
  1203. {
  1204. XTPBUTTONINFO* pControl = &pData[i];
  1205. if (!pControl->bVisible || pControl->bBeginGroup)
  1206. continue;
  1208. int nItems = 0;
  1209. int nButtons[3] = {0, 0, 0};
  1210. BOOL bFound = FALSE;
  1211. int j;
  1213. for (j = i; j  >= 0; j--)
  1214. {
  1215. pControl = &pData[j];
  1216. if (!pControl->bVisible)
  1217. continue;
  1219. if ((nItems == 2 || !pControl->bBeginGroup))
  1220. {
  1221. nButtons[nItems] = j;
  1222. nItems += 1;
  1223. bFound = bFound || GetAt(j)->m_buttonStyle == xtpButtonIconAndCaptionBelow;
  1224. }
  1225. else
  1226. {
  1227. break;
  1228. }
  1229. if (nItems == 3)
  1230. break;
  1231. }
  1232. i = j;
  1233. if (nItems == 3 && bFound)
  1234. {
  1235. GetAt(nButtons[0])->m_buttonStyle = xtpButtonIconAndCaption;
  1236. GetAt(nButtons[1])->m_buttonStyle = xtpButtonIconAndCaption;
  1237. GetAt(nButtons[2])->m_buttonStyle = xtpButtonIconAndCaption;
  1238. bReduced = TRUE;
  1239. break;
  1240. }
  1241. }
  1242. }
  1244. if (!bReduced)
  1245. {
  1246. for (int i = GetCount() - 1; i >= 2; i--)
  1247. {
  1248. XTPBUTTONINFO* pControl = &pData[i];
  1249. if (!pControl->bVisible || pControl->bBeginGroup)
  1250. continue;
  1252. int nItems = 0;
  1253. int nButtons[3] = {0, 0, 0};
  1254. int nLeft = 0;
  1256. for (int j = i; j  >= 0; j--)
  1257. {
  1258. pControl = &pData[j];
  1259. if (!pControl->bVisible)
  1260. continue;
  1262. int nOffset = (bVert ? pControl->rcControl.top : pControl->rcControl.left);
  1263. if (nItems != 0 && (nOffset != nLeft))
  1264. break;
  1266. if ((nItems == 2 || !pControl->bBeginGroup) && GetAt(j)->m_buttonStyle == xtpButtonIconAndCaption)
  1267. {
  1268. nButtons[nItems] = j;
  1269. nItems += 1;
  1270. nLeft = nOffset;
  1271. }
  1272. else
  1273. {
  1274. break;
  1275. }
  1276. if (nItems == 3)
  1277. break;
  1278. }
  1280. if (nItems == 3)
  1281. {
  1282. GetAt(nButtons[0])->m_buttonStyle = xtpButtonIcon;
  1283. GetAt(nButtons[1])->m_buttonStyle = xtpButtonIcon;
  1284. GetAt(nButtons[2])->m_buttonStyle = xtpButtonIcon;
  1285. bReduced = TRUE;
  1286. break;
  1287. }
  1288. }
  1289. }
  1291. sizeResult = _CalcSmartLayoutToolBar(pDC, pData, dwMode);
  1292. if ((bVert ? sizeResult.cy : sizeResult.cx) < nWidth)
  1293. return sizeResult;
  1294. }
  1295. while (bReduced);
  1297. if (dwMode & LM_HIDEWRAP)
  1298. {
  1299. BOOL bFirst = TRUE;
  1301. for (int i = 0; i < GetCount(); i++)
  1302. {
  1303. XTPBUTTONINFO* pControl = &pData[i];
  1304. if (!pControl->bVisible)
  1305. continue;
  1307. if (!bFirst && ((bVert ? pControl->rcControl.bottom : pControl->rcControl.right) > nWidth))
  1308. {
  1309. GetAt(i)->m_buttonStyle = xtpButtonIcon;
  1310. pControl->bHide = TRUE;
  1311. }
  1312. bFirst = FALSE;
  1313. }
  1314. return _CalcSmartLayoutToolBar(pDC, pData, dwMode);
  1315. }
  1317. return sizeResult;
  1319. }
  1321. CSize CXTPControls::_CalcSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, DWORD& dwMode)
  1322. {
  1323. BOOL bFirst = TRUE;
  1324. BOOL bVert = dwMode & LM_VERTDOCK;
  1326. CSize szLargeIcon = m_pParent->GetLargeIconSize(TRUE);
  1327. int nResultHeight = szLargeIcon.cy + 7 + m_pParent->GetPaintManager()->GetSplitDropDownHeight();
  1328. CSize sizeResult(0, nResultHeight);
  1331. int dyPrev = 0, dxPrev = 0, x = 0;
  1333. for (int i = 0; i < GetCount(); i++)
  1334. {
  1335. XTPBUTTONINFO* pControl = &pData[i];
  1336. if (!pControl->bVisible || pControl->bHide)
  1337. continue;
  1339. BOOL bFullRow = GetAt(i)->m_buttonStyle == xtpButtonIconAndCaptionBelow;
  1340. pControl->EnsureButtonSize(pDC);
  1341. CSize szControl = pControl->szControl;
  1343. int dx = bVert ? szControl.cy : szControl.cx;
  1344. int dy = !bVert ? szControl.cy : szControl.cx;
  1346. BOOL bBeginGroup = pControl->bBeginGroup && !bFirst;
  1347. if (bBeginGroup)
  1348. x += 6;
  1350. if (!bFirst && !bBeginGroup && !bFullRow && dyPrev + dy <= nResultHeight)
  1351. {
  1352. if (bVert)
  1353. pControl->rcControl.SetRect(-dyPrev - dy, x, -dyPrev,  x + dx);
  1354. else
  1355. pControl->rcControl.SetRect(x, dyPrev, x + dx, dyPrev + dy);
  1357. dxPrev = max(dxPrev, dx);
  1358. }
  1359. else
  1360. {
  1361. x += dxPrev;
  1362. if (bVert)
  1363. pControl->rcControl.SetRect(-dy, x, 0, x + dx);
  1364. else
  1365. pControl->rcControl.SetRect(x, 0, x + dx, dy);
  1367. sizeResult.cy = max(dy, sizeResult.cy);
  1368. dxPrev = dx;
  1369. }
  1370. sizeResult.cx = max(x + dx, sizeResult.cx);
  1372. bFirst = FALSE;
  1373. dyPrev = bVert ? -pControl->rcControl.left : pControl->rcControl.bottom;
  1374. }
  1376. return bVert ? CSize(sizeResult.cy, sizeResult.cx) : sizeResult;
  1378. }
  1380. CSize CXTPControls::_WrapSmartLayoutToolBar(CDC* pDC, XTPBUTTONINFO* pData, int nWidth, DWORD& dwMode)
  1381. {
  1382. BOOL bVert = dwMode & LM_VERTDOCK;
  1383. CSize szLargeIcon = m_pParent->GetLargeIconSize(FALSE);
  1385. for (int i = 0; i < GetCount(); i++)
  1386. {
  1387. XTPBUTTONINFO* pControl = &pData[i];
  1388. if (!pControl->bVisible)
  1389. continue;
  1391. BOOL bDrawImage = GetAt(i)->GetIconId() > 0 ?
  1392. GetAt(i)->GetImageManager()->IsPrimaryImageExists(GetAt(i)->GetIconId(), szLargeIcon.cx) != NULL: FALSE;
  1394. pControl->bHide = FALSE;
  1395. pControl->bWrap = FALSE;
  1396. GetAt(i)->m_buttonStyle = bDrawImage? xtpButtonIconAndCaptionBelow : xtpButtonIconAndCaption;
  1397. }
  1398. CSize sizeResult = _CalcSmartLayoutToolBar(pDC, pData, dwMode);
  1400. if ((bVert ? sizeResult.cy : sizeResult.cx) > nWidth)
  1401. {
  1402. sizeResult = _ReduceSmartLayoutToolBar(pDC, pData, nWidth, dwMode);
  1403. dwMode |= LM_STRETCH;
  1404. }
  1406. return sizeResult;
  1407. }
  1409. CSize CXTPControls::CalcDynamicSize(CDC* pDC, int nLength, DWORD dwMode, const CRect& rcBorder, int nWidth)
  1410. {
  1411. CSize sizeResult(0, 0);
  1412. CSize szSeparators(m_pParent->GetPaintManager()->DrawCommandBarSeparator(pDC, m_pParent, NULL, FALSE));
  1413. int i;
  1415. for (i = GetCount() - 1; i >= 0; i--)
  1416. {
  1417. GetAt(i)->OnCalcDynamicSize(dwMode);
  1418. }
  1420. if (GetVisibleCount() > 0)
  1421. {
  1423. XTPBUTTONINFO* pData = new XTPBUTTONINFO[GetCount()];
  1424. for (int j = 0; j < GetCount(); j++)
  1425. pData[j].Attach(pDC, GetAt(j));
  1427. pData->szSeparators = szSeparators;
  1428. pData->nWrapMargin = m_pParent->m_nWrapMargin;
  1430. if (dwMode & LM_MRUWIDTH)
  1431. {
  1432. nLength = m_pParent->m_nMRUWidth;
  1433. }
  1435. if ((m_pParent->GetFlags() & xtpFlagSmartLayout))
  1436. {
  1437. if (dwMode & LM_VERTDOCK)
  1438. {
  1439. sizeResult = _WrapSmartLayoutToolBar(pDC, pData, nLength - rcBorder.top - rcBorder.bottom, dwMode);
  1440. }
  1441. else
  1442. {
  1443. sizeResult = _WrapSmartLayoutToolBar(pDC, pData, nLength - rcBorder.right - rcBorder.left, dwMode);
  1444. }
  1446. }
  1447. else
  1448. {
  1450. if (dwMode & LM_POPUP)
  1451. {
  1452. _WrapToolBar(pData, m_pParent->m_nMRUWidth, dwMode);
  1453. CSize sz = _CalcSize(pData, FALSE);
  1455. if ((sz.cy > sz.cx * 3) && (m_pParent->m_nMRUWidth <= 0))
  1456. {
  1457. _SizePopupToolBar(pData, dwMode);
  1458. }
  1459. else
  1460. {
  1461. _WrapToolBar(pData, sz.cx , dwMode);
  1462. }
  1464. }
  1465. else if (dwMode & LM_HORZDOCK)
  1466. {
  1467. _WrapToolBar(pData, nLength - rcBorder.right - rcBorder.left, dwMode);
  1468. }
  1469. else if (dwMode & LM_VERTDOCK)
  1470. {
  1471. _WrapToolBar(pData, nLength - rcBorder.top - rcBorder.bottom, dwMode);
  1472. }
  1473. else
  1474. {
  1475. _SizeFloatableBar(pData, nLength - ((dwMode & LM_LENGTHY) ? rcBorder.top + rcBorder.bottom : rcBorder.right + rcBorder.left), dwMode);
  1476. }
  1479. sizeResult = _CalcSize(pData, dwMode & LM_VERTDOCK);
  1480. }
  1482. if (nWidth > 0)
  1483. {
  1484. if (dwMode & LM_HORZDOCK)
  1485. sizeResult.cy = max(nWidth - rcBorder.top - rcBorder.bottom, sizeResult.cy);
  1486. else
  1487. sizeResult.cx = max(nWidth - rcBorder.right - rcBorder.left, sizeResult.cx);
  1488. }
  1490. if (dwMode & LM_STRETCH)
  1491. {
  1492. if (dwMode & LM_VERTDOCK)
  1493. sizeResult.cy = max(nLength - rcBorder.top - rcBorder.bottom, sizeResult.cy);
  1494. else
  1495. sizeResult.cx = max(nLength - rcBorder.right - rcBorder.left, sizeResult.cx);
  1497. }
  1498. _AdjustBorders(pData, sizeResult, dwMode, rcBorder);
  1500. if (dwMode & LM_COMMIT)
  1501. {
  1502. if (!(m_pParent->GetFlags() & xtpFlagSmartLayout))
  1503. _MoveRightAlligned(pData, sizeResult, rcBorder, dwMode);
  1504. for (i = 0; i < GetCount(); i++) pData[i].Detach();
  1505. }
  1506. delete[] pData;
  1507. }
  1508. else
  1509. {
  1510. sizeResult = CSize (23, 22) + CSize(rcBorder.left + rcBorder.right, rcBorder.top + rcBorder.bottom);
  1511. if (dwMode & LM_HORZDOCK) sizeResult.cy = max(nWidth, sizeResult.cy);
  1512. else sizeResult.cx = max(nWidth, sizeResult.cx);
  1513. }
  1515. return sizeResult;
  1518. }
  1520. void CXTPControls::_MakeSameWidth(int nStart, int nLast, int nWidth)
  1521. {
  1522. for (int i = nStart; i < nLast; i++)
  1523. {
  1524. CXTPControl* pControl = GetAt(i);
  1525. if (!pControl || pControl->GetParent() != m_pParent || !pControl->IsVisible())
  1526. continue;
  1528. CRect rc = pControl->GetRect();
  1529. pControl->SetRect(CRect(rc.left, rc.top, rc.left + nWidth, rc.bottom));
  1530. }
  1531. }
  1533. CSize CXTPControls::CalcPopupSize(CDC* pDC, int nLength, int nMRUWidth, const CRect& rcBorder)
  1534. {
  1535. RECT rcWork;
  1536. SystemParametersInfo(SPI_GETWORKAREA, NULL, &rcWork, 0);
  1538. int i;
  1540. CSize szSeparators(m_pParent->GetPaintManager()->DrawCommandBarSeparator(NULL, m_pParent, NULL, FALSE));
  1543. CRect rcControl;
  1544. int yPos = rcBorder.top, nWidthColumn = 0, xPos = rcBorder.left, nFirstInColumn = 0, nHeight = 0;
  1546. m_pParent->m_bMultiLine = FALSE;
  1547. int nCount = GetCount();
  1549. BOOL bFirst = TRUE;
  1550. for (i = 0; i < nCount; i++)
  1551. {
  1552. CXTPControl* pControl = GetAt(i);
  1553. if (!pControl || pControl->GetParent() != m_pParent)
  1554. continue;
  1556. pControl->SetHideFlag(xtpHideScroll, FALSE);
  1557. if (!pControl->IsVisible())
  1558. continue;
  1560. CXTPFontDC fontControl(pDC, m_pParent->GetPaintManager()->GetCommandBarFont(m_pParent, pControl->IsItemDefault()));
  1561. CSize szControl = pControl->GetSize(pDC);
  1563. pControl->SetWrap(FALSE);
  1565. if ((pControl->GetFlags() & xtpFlagWrapRow && !bFirst) || (nLength > 0 && szControl.cy + yPos > nLength - rcBorder.bottom))
  1566. {
  1567. _MakeSameWidth(nFirstInColumn, i, nWidthColumn);
  1569. nHeight = max(yPos - rcBorder.top, nHeight);
  1570. yPos = rcBorder.top;
  1571. xPos += nWidthColumn + (pControl->GetBeginGroup() ? szSeparators.cx : 0);
  1572. pControl->SetWrap(TRUE);
  1573. nFirstInColumn = i;
  1574. nWidthColumn = 0;
  1575. m_pParent->m_bMultiLine = TRUE;
  1576. }
  1577. else if (pControl->GetBeginGroup() && !bFirst)
  1578. {
  1579. yPos += szSeparators.cy;
  1580. }
  1582. bFirst = FALSE;
  1585. if (!GetParent()->IsResizable() && CXTPPopupBar::m_dMaxWidthDivisor > 0 && szControl.cx > (CXTPPopupBar::m_dMaxWidthDivisor * rcWork.right))
  1586. szControl.cx = int(CXTPPopupBar::m_dMaxWidthDivisor * rcWork.right);
  1588. pControl->SetRect(CRect(xPos, yPos, xPos + szControl.cx, yPos + szControl.cy));
  1589. yPos += szControl.cy;
  1591. if (nWidthColumn < szControl.cx) nWidthColumn = szControl.cx;
  1592. }
  1593. if (nMRUWidth > 0 && nMRUWidth < 30000)
  1594. nWidthColumn = nMRUWidth - rcBorder.left - rcBorder.right;
  1596. _MakeSameWidth(nFirstInColumn, GetCount(), nWidthColumn);
  1599. int nWidth = xPos - rcBorder.left + nWidthColumn;
  1600. nHeight = max(yPos - rcBorder.top, nHeight);
  1602. for (i = 0; i < nCount; i++)
  1603. {
  1604. CXTPControl* pControl = GetAt(i);
  1605. pControl->SetRowRect(CRect(pControl->GetRect().left, rcBorder.top, pControl->GetRect().right, rcBorder.top + nHeight));
  1606. }
  1608. nWidth = max(24, nWidth);
  1609. nHeight = (nHeight == 0 ? 22 : nHeight);
  1611. return CSize(nWidth + rcBorder.left + rcBorder.right, nHeight + rcBorder.bottom + rcBorder.top);
  1612. }
  1614. void CXTPControls::Copy(CXTPControls* pControls, BOOL bRecursive)
  1615. {
  1616. RemoveAll();
  1618. for (int i = 0; i < pControls->GetCount(); i++)
  1619. {
  1620. if (!pControls->GetAt(i)->m_bTemporary)
  1621. AddClone(pControls->GetAt(i), -1, bRecursive);
  1622. }
  1624. if (pControls->m_pOriginalControls)
  1625. {
  1626. SetOriginalControls((CXTPOriginalControls*)pControls->m_pOriginalControls->Duplicate(bRecursive));
  1627. }
  1628. else
  1629. {
  1630. SetOriginalControls(NULL);
  1631. }
  1633. }
  1635. CXTPControls* CXTPControls::Duplicate(BOOL bRecursive)
  1636. {
  1637. CXTPControls* pControls = (CXTPControls*)GetRuntimeClass()->CreateObject();
  1638. for (int i = 0; i < GetCount(); i++)
  1639. {
  1640. if (!GetAt(i)->m_bTemporary)
  1641. pControls->AddClone(GetAt(i), -1, bRecursive);
  1642. }
  1644. if (m_pOriginalControls)
  1645. {
  1646. pControls->SetOriginalControls((CXTPOriginalControls*)m_pOriginalControls->Duplicate(bRecursive));
  1647. }
  1649. return pControls;
  1650. }
  1653. void CXTPControls::ClearOriginalControls()
  1654. {
  1655. CMDTARGET_RELEASE(m_pOriginalControls);
  1656. }
  1659. void CXTPControls::CreateOriginalControls()
  1660. {
  1661. ClearOriginalControls();
  1663. CXTPOriginalControls* pControls = new CXTPOriginalControls();
  1664. for (int i = 0; i < GetCount(); i++)
  1665. {
  1666. if (!GetAt(i)->m_bTemporary)
  1667. pControls->AddClone(GetAt(i), -1, TRUE);
  1668. }
  1670. SetOriginalControls(pControls);
  1671. }
  1673. void CXTPControls::SetOriginalControls(CXTPOriginalControls* pControls)
  1674. {
  1675. ClearOriginalControls();
  1676. m_pOriginalControls = pControls;
  1677. }
  1679. void CXTPControls::MoveBefore(CXTPControl* pControl, int nBefore)
  1680. {
  1681. ASSERT(pControl);
  1682. if (!pControl)
  1683. return;
  1684. ASSERT(pControl->GetControls() == this);
  1686. if (pControl->GetIndex() < nBefore) nBefore--;
  1688. m_arrControls.RemoveAt(pControl->GetIndex());
  1689. m_arrControls.InsertAt(nBefore, pControl);
  1690. RefreshIndexes();
  1691. }
  1693. BOOL CXTPControls::Compare(const CXTPControls* pOther)
  1694. {
  1695. int j = 0, i = 0;
  1696. while (i < GetCount() || j < pOther->GetCount())
  1697. {
  1698. while (i < GetCount() && GetAt(i)->m_bTemporary)
  1699. {
  1700. i++;
  1701. }
  1702. while (j < pOther->GetCount() && pOther->GetAt(j)->m_bTemporary)
  1703. {
  1704. j++;
  1705. }
  1707. if (i < GetCount() && j < pOther->GetCount())
  1708. {
  1709. if (!GetAt(i)->Compare(pOther->GetAt(j)))
  1710. return FALSE;
  1711. }
  1712. else
  1713. {
  1714. if (i < GetCount() || j < pOther->GetCount())
  1715. return FALSE;
  1716. }
  1718. i++;
  1719. j++;
  1720. }
  1722. return TRUE;
  1723. }
  1725. BOOL CXTPControls::IsChanged() const
  1726. {
  1727. if (!m_pOriginalControls)
  1728. return TRUE;
  1730. return !m_pOriginalControls->Compare(this);
  1731. }
  1733. int CXTPControls::CommandToIndex(int nIDFind) const
  1734. {
  1735. for (int iIndex = 0; iIndex < m_arrControls.GetSize(); ++iIndex)
  1736. {
  1737. CXTPControl* pControl = m_arrControls.GetAt(iIndex);
  1739. if (pControl && pControl->GetID() == nIDFind)
  1740. return iIndex;
  1741. }
  1742. return -1;
  1743. }