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

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

对话框与窗口

开发平台：

Visual C++

XTPToolBar.cpp：源码内容
  1. // XTPToolBar.cpp : implementation of the CXTPToolBar 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/XTPVC80Helpers.h"
  25. #include "Common/XTPVC50Helpers.h"
  26. #include "Common/XTPResourceManager.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPColorManager.h"
  29. #include "Common/XTPDrawHelpers.h"
  30. #include "Common/XTPToolTipContext.h"
  32. #include "XTPToolBar.h"
  33. #include "XTPCommandBars.h"
  34. #include "XTPDockBar.h"
  35. #include "XTPControls.h"
  36. #include "XTPControl.h"
  37. #include "XTPPaintManager.h"
  38. #include "XTPMouseManager.h"
  39. #include "XTPControlPopup.h"
  40. #include "XTPPopupBar.h"
  41. #include "XTPControlButton.h"
  42. #include "XTPDockContext.h"
  43. #include "XTPShortcutManager.h"
  45. #ifdef _DEBUG
  46. #define new DEBUG_NEW
  47. #undef THIS_FILE
  48. static char THIS_FILE[] = __FILE__;
  49. #endif
  51. #define _XTP_CBRS_ALL            0x0040FFFFL
  53. IMPLEMENT_XTP_COMMANDBAR(CXTPToolBar, CXTPCommandBar)
  55. class CXTPToolBar::CControlButtonHide: public CXTPControlButton
  56. {
  57. public:
  58. CControlButtonHide()
  59. {
  60. m_dwFlags = xtpFlagManualUpdate | xtpFlagSkipFocus | xtpFlagNoMovable;
  61. }
  62. void Draw(CDC* pDC);
  63. void SetBeginGroup(BOOL /*bBeginGroup*/)
  64. {
  65. }
  66. void OnExecute()
  67. {
  68. ASSERT(m_pParent);
  69. if (m_pParent) ((CXTPToolBar*)m_pParent)->SetVisible(FALSE);
  70. }
  71. virtual BOOL IsCustomizeMovable() const
  72. {
  73. return FALSE;
  74. }
  75. };
  77. void CXTPToolBar::CControlButtonHide::Draw(CDC* pDC)
  78. {
  79. GetPaintManager()->DrawSpecialControl(pDC, xtpButtonHideFloating, this, m_pParent, TRUE, NULL);
  80. }
  82. class CXTPToolBar::CControlButtonCustomize: public CXTPControlButton
  83. {
  84. public:
  85. CControlButtonCustomize()
  86. {
  87. m_pControl = NULL;
  88. m_pToolBar = NULL;
  89. }
  90. virtual void OnExecute()
  91. {
  92. ASSERT(m_pParent);
  93. if (!m_pParent)
  94. return;
  95. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  96. ASSERT(pCommandBars);
  97. if (!pCommandBars)
  98. return;
  99. pCommandBars->GetCommandBarsOptions()->bDirtyState = TRUE;
  101. if (m_pControl)
  102. {
  103. if (m_pControl->GetHideFlags() & xtpHideCustomize)
  104. m_pControl->SetHideFlag(xtpHideCustomize, FALSE);
  105. else m_pControl->SetHideFlag(xtpHideCustomize, TRUE);
  107. SetChecked((m_pControl->GetHideFlags() & xtpHideCustomize) == 0);
  108. m_pControl->GetParent()->OnRecalcLayout();
  109. m_pParent->InvalidateParents();
  110. }
  111. if (m_pToolBar)
  112. {
  113. pCommandBars->ClosePopups();
  114. m_pToolBar->Reset(TRUE);
  115. }
  116. }
  118. CXTPControl* m_pControl;
  119. CXTPToolBar* m_pToolBar;
  120. };
  123. class CXTPToolBar::CControlButtonExpand: public CXTPControlPopup
  124. {
  125. public:
  126. CControlButtonExpand()
  127. {
  128. m_controlType = xtpControlButtonPopup;
  129. m_bHiddenExists = FALSE;
  130. m_dwFlags = xtpFlagLeftPopup | xtpFlagManualUpdate | xtpFlagNoMovable;
  131. m_pCommandBar = CXTPPopupBar::CreatePopupBar(0);
  132. }
  133. void Draw(CDC* pDC);
  134. BOOL OnSetPopup(BOOL bPopup);
  135. void SetRect(CRect rcControl)
  136. {
  137. m_rcControl = rcControl;
  138. m_bHiddenExists = IsHiddenExists();
  139. };
  140. void SetBeginGroup(BOOL /*bBeginGroup*/)
  141. {
  142. }
  143. BOOL IsHiddenExists();
  144. virtual BOOL IsCaptionVisible() const
  145. {
  146. return FALSE;
  147. }
  148. virtual BOOL IsCustomizeMovable() const
  149. {
  150. return FALSE;
  151. }
  152. private:
  153. BOOL m_bHiddenExists;
  154. };
  156. BOOL CXTPToolBar::CControlButtonExpand::IsHiddenExists()
  157. {
  158. for (int i = 0; i < m_pParent->GetControlCount(); i++)
  159. {
  160. if (m_pParent->GetControl(i)->GetHideFlags() == xtpHideWrap)
  161. return TRUE;
  162. }
  163. return FALSE;
  164. }
  166. void CXTPToolBar::CControlButtonExpand::Draw(CDC* pDC)
  167. {
  168. GetPaintManager()->DrawSpecialControl(pDC, m_pParent->GetPosition() == xtpBarFloating ?
  169. xtpButtonExpandFloating: xtpButtonExpandToolbar, this, m_pParent, TRUE, &m_bHiddenExists);
  170. }
  172. BOOL CXTPToolBar::CControlButtonExpand::OnSetPopup(BOOL bPopup)
  173. {
  174. m_bPopup = bPopup;
  175. if (bPopup)
  176. {
  177. if (m_pCommandBar)
  178. m_pCommandBar->InternalRelease();
  180. m_pCommandBar = NULL;
  181. CWnd* pSite = m_pParent->GetSite();
  182. if (pSite)
  183. {
  184. XTP_COMMANDBARS_CREATEBAR cs;
  185. ZeroMemory(&cs, sizeof(cs));
  186. cs.bExpandBar = TRUE;
  188. if (pSite->SendMessage(WM_XTP_CREATECOMMANDBAR, 0, (LPARAM)&cs) != 0)
  189. {
  190. m_pCommandBar = DYNAMIC_DOWNCAST(CXTPPopupBar, cs.pCommandBar);
  191. }
  192. }
  193. if (m_pCommandBar == NULL) m_pCommandBar = CXTPPopupToolBar::CreatePopupToolBar(m_pParent->GetCommandBars());
  194. m_pCommandBar->EnableCustomization(FALSE);
  196. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  197. if (pCommandBars && ((CXTPToolBar*)m_pParent)->m_pDockContext)
  198. {
  199. pCommandBars->GetHiddenControls((CXTPToolBar*)m_pParent, m_pCommandBar);
  201. if (pCommandBars->GetCommandBarsOptions()->bShowExpandButtonAlways || pCommandBars->IsCustomizeAvail())
  202. {
  203. CXTPControlPopup* pControl = (CXTPControlPopup*)m_pCommandBar->GetControls()->Add(xtpControlPopup, XTP_ID_CUSTOMIZE_ADDORREMOVE);
  204. pControl->SetFlags(xtpFlagManualUpdate);
  206. pControl->SetBeginGroup(m_pCommandBar->GetControlCount() > 1);
  207. pCommandBars->GetAddOrRemovePopup((CXTPToolBar*)m_pParent, pControl->GetCommandBar());
  208. }
  209. }
  210. else
  211. {
  212. ((CXTPToolBar*)m_pParent)->_GetHiddenControls(m_pCommandBar);
  213. }
  215. m_pCommandBar->Popup(this, IsKeyboardSelected(GetSelected()));
  217. }
  218. else
  219. {
  220. ASSERT(m_pCommandBar);
  221. if (m_pCommandBar) m_pCommandBar->SetTrackingMode(FALSE);
  223. }
  224. RedrawParent();
  225. return TRUE;
  226. }
  229. CXTPToolBar::CXTPToolBar()
  230. {
  231. m_pDockBar = 0;
  232. m_pDockContext = 0;
  233. m_bBuiltIn = TRUE;
  234. m_bTearOff = FALSE;
  236. m_bCloseable = TRUE;
  237. m_bTemporary = FALSE;
  238. m_bShowExpandButton = TRUE;
  240. m_bPreviewMode = m_bPreviewVisible = FALSE;
  242. m_bContextMenuPresent = TRUE;
  243. m_bInRecalcLayout = FALSE;
  245. m_pDockContext = new CXTPDockContext(this);
  246. m_dwFlags = xtpFlagAlignAny | xtpFlagFloating | xtpFlagHideWrap;
  249. CXTPDrawHelpers::RegisterWndClass(0, _T("XTPToolBar"), CS_DBLCLKS);
  250. }
  252. BOOL CXTPToolBar::CreateToolBar(DWORD dwStyle, CWnd* pParentWnd, UINT nID)
  253. {
  254. m_dwStyle = dwStyle & _XTP_CBRS_ALL;
  255. dwStyle = dwStyle & ~_XTP_CBRS_ALL;
  257. dwStyle = dwStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
  259. if (!CWnd::CreateEx(0, _T("XTPToolBar"), NULL, dwStyle, CRect(0, 0, 0, 0), pParentWnd, nID))
  260. return FALSE;
  262. m_barPosition = xtpBarTop;
  264. SAFE_DELETE(m_pDockContext);
  265. m_dwFlags &= ~ (xtpFlagAlignAny | xtpFlagFloating | xtpFlagHideWrap);
  267. if ((m_dwStyle & CBRS_TOOLTIPS) && m_pCommandBars == 0)
  268. EnableToolTips();
  270. return TRUE;
  272. }
  274. void CXTPToolBar::EnableDocking(DWORD dwFlags)
  275. {
  276. ASSERT(m_pCommandBars);
  277. m_dwFlags = dwFlags;
  278. }
  280. CXTPToolBar::~CXTPToolBar()
  281. {
  282. SAFE_DELETE(m_pDockContext)
  283. }
  287. BOOL CXTPCommandBar::SetButtons(UINT* pButtons, int nCount)
  288. {
  289. m_pControls->RemoveAll();
  291. BOOL bSeparator = FALSE;
  293. CWnd* pSite = GetSite();
  295. for (int i = 0; i < nCount; i++)
  296. {
  297. if (pButtons[i] == 0)
  298. bSeparator = TRUE;
  299. else
  300. {
  301. XTPControlType controlType = xtpControlButton;
  302. XTPButtonStyle buttonStyle = xtpButtonAutomatic;
  303. CXTPControl* pControl = NULL;
  304. UINT nID = pButtons[i];
  306. XTP_COMMANDBARS_CREATECONTROL cs;
  308. if (pSite)
  309. {
  310. cs.nID = nID;
  311. cs.pControl = NULL;
  312. cs.bToolBar = TRUE;
  313. cs.pMenu = NULL;
  314. cs.nIndex = i;
  315. cs.strCaption = GetTitle();
  316. cs.controlType = controlType;
  317. cs.pCommandBar = this;
  318. cs.buttonStyle = buttonStyle;
  320. if (pSite->SendMessage(WM_XTP_BEFORECREATECONTROL, 0, (LPARAM)&cs) != 0)
  321. {
  322. pControl = cs.pControl;
  323. controlType = cs.controlType;
  324. buttonStyle = cs.buttonStyle;
  325. nID = cs.nID;
  326. }
  327. }
  329. if (pControl == NULL)
  330. {
  331. pControl = m_pControls->Add(controlType, nID);
  332. if (pControl)
  333. {
  334. pControl->SetStyle(buttonStyle);
  335. if (controlType == xtpControlPopup) pControl->SetIconId(nID);
  336. }
  337. }
  338. else m_pControls->Add(pControl, nID);
  340. if (bSeparator)
  341. {
  342. pControl->SetBeginGroup(TRUE);
  343. bSeparator = FALSE;
  344. }
  346. if (pSite)
  347. {
  348. cs.pControl = pControl;
  349. pSite->SendMessage(WM_XTP_AFTERCREATECONTROL, 0, (LPARAM)&cs);
  350. }
  351. }
  352. }
  353. return TRUE;
  354. }
  356. BOOL CXTPToolBar::LoadToolBar(UINT nIDResource, BOOL bLoadIcons)
  357. {
  358. m_nBarID = nIDResource;
  360. if (!CXTPCommandBar::LoadToolBar(nIDResource, bLoadIcons))
  361. return FALSE;
  363. m_pControls->CreateOriginalControls();
  365. return TRUE;
  366. }
  368. BOOL CXTPCommandBar::LoadToolBar(UINT nIDResource, BOOL bLoadIcons)
  369. {
  370. LPCTSTR lpszResourceName = MAKEINTRESOURCE(nIDResource);
  372. struct CToolBarData
  373. {
  374. WORD wVersion;
  375. WORD wWidth;
  376. WORD wHeight;
  377. WORD wItemCount;
  378. WORD* items()
  379. { return (WORD*)(this + 1); }
  380. };
  382. m_pControls->RemoveAll();
  383. ASSERT(GetControlCount() == 0);
  385. ASSERT_VALID(this);
  386. ASSERT(lpszResourceName != NULL);
  387. if (!lpszResourceName)
  388. return FALSE;
  390. // determine location of the bitmap in resource fork
  391. HINSTANCE hInst = AfxFindResourceHandle(lpszResourceName, RT_TOOLBAR);
  392. if (!hInst)
  393. return FALSE;
  394. HRSRC hRsrc = ::FindResource(hInst, lpszResourceName, RT_TOOLBAR);
  395. if (hRsrc == NULL)
  396. return FALSE;
  398. HGLOBAL hGlobal = LoadResource(hInst, hRsrc);
  399. if (hGlobal == NULL)
  400. return FALSE;
  402. CToolBarData* pData = (CToolBarData*)LockResource(hGlobal);
  403. if (pData == NULL)
  404. return FALSE;
  406. ASSERT(pData->wVersion == 1);
  408. int i;
  409. UINT* pItems = new UINT[pData->wItemCount];
  411. for (i = 0; i < pData->wItemCount; i++)
  412. pItems[i] = pData->items()[i];
  414. BOOL bResult = SetButtons(pItems, pData->wItemCount);
  416. if (bLoadIcons)
  417. {
  418. CXTPImageManager* pImageManager = GetImageManager();
  420. if (!pImageManager->SetIcons(nIDResource, pItems,
  421. pData->wItemCount, CSize(pData->wWidth, pData->wHeight)))
  422. bResult = FALSE;
  424. if (pData->wWidth != 16)
  425. {
  426. SetIconSize(CSize(pData->wWidth, pData->wHeight));
  427. }
  428. }
  430. delete[] pItems;
  432. UnlockResource(hGlobal);
  433. FreeResource(hGlobal);
  436. return bResult;
  437. }
  440. BOOL CXTPToolBar::SetPosition(XTPBarPosition barPosition)
  441. {
  442. CXTPCommandBars* pCommandBars = GetCommandBars();
  443. if (!pCommandBars)
  444. return FALSE;
  446. if (IsDockingPosition(barPosition))
  447. {
  448. if (!pCommandBars->DockCommandBar(this, barPosition))
  449. return FALSE;
  451. }
  452. else if (barPosition == xtpBarFloating)
  453. {
  454. if (!pCommandBars->FloatCommandBar(this))
  455. return FALSE;
  457. }
  458. else
  459. return FALSE;
  461. ASSERT(m_barPosition == barPosition);
  463. return TRUE;
  464. }
  467. BEGIN_MESSAGE_MAP(CXTPToolBar, CXTPCommandBar)
  468. ON_WM_SETCURSOR()
  469. ON_WM_RBUTTONDOWN()
  471. ON_WM_NCCREATE()
  472. ON_WM_NCACTIVATE()
  473. ON_MESSAGE(WM_FLOATSTATUS, OnFloatStatus)
  474. ON_WM_MOUSEACTIVATE()
  475. ON_WM_LBUTTONDOWN()
  476. ON_WM_NCHITTEST_EX()
  477. ON_WM_NCLBUTTONDOWN()
  478. ON_WM_SETFOCUS()
  479. ON_WM_CLOSE()
  480. ON_MESSAGE(WM_SIZEPARENT, OnSizeParent)
  481. ON_WM_LBUTTONDBLCLK()
  482. END_MESSAGE_MAP()
  486. BOOL CXTPToolBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  487. {
  488. if (GetShowGripper() && (IsDockingPosition(GetPosition())) &&
  489. m_pDockContext && ((m_dwFlags & (xtpFlagAlignAny | xtpFlagFloating)) != 0))
  490. {
  491. CXTPClientRect rcGripper(this);
  492. CRect rcBorder = GetPaintManager()->GetCommandBarBorders(this);
  493. CSize szGripper = GetPaintManager()->DrawCommandBarGripper(NULL, this, FALSE);
  495. if (IsDialogBar())
  496. {
  497. rcGripper.right = rcGripper.left + rcBorder.left + szGripper.cx;
  498. rcGripper.left += 3;
  499. rcGripper.bottom = rcGripper.top + rcBorder.top + szGripper.cy;
  500. }
  501. else if (IsVerticalPosition(GetPosition()))
  502. {
  503. rcGripper.bottom = rcGripper.top + rcBorder.top + szGripper.cy;
  504. }
  505. else
  506. {
  507. rcGripper.right = rcGripper.left + rcBorder.left + szGripper.cx;
  508. }
  510. POINT pt;
  511. GetCursorPos(&pt);
  512. ScreenToClient(&pt);
  514. if (rcGripper.PtInRect(pt))
  515. {
  516. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
  517. return TRUE;
  518. }
  519. }
  521. return CXTPCommandBar::OnSetCursor(pWnd, nHitTest, message);
  522. }
  524. INT_PTR CXTPCommandBar::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  525. {
  527. ASSERT_VALID(this);
  528. ASSERT(::IsWindow(m_hWnd));
  530. if (IsTrackingMode() == TRUE_POPUP && GetPosition() != xtpBarPopup)
  531. return -1;
  533. if (m_nPopuped != -1)
  534. return -1;
  536. BOOL bToolBarAccelTips = FALSE;
  537. CXTPCommandBars* pCommandBars = GetCommandBars();
  538. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  540. if (pMouseManager->IsMouseLocked() || pMouseManager->IsTrackedLock(this))
  541. return -1;
  543. if (pCommandBars)
  544. {
  545. if (!pCommandBars->GetCommandBarsOptions()->bToolBarScreenTips)
  546. return -1;
  548. bToolBarAccelTips = pCommandBars->GetCommandBarsOptions()->bToolBarAccelTips;
  549. }
  551. CXTPControl* pControl = m_pControls->HitTest(point);
  552. if (!pControl)
  553. return -1;
  555. if (m_barType == xtpBarTypePopup && (!pCommandBars || (!pCommandBars->GetCommandBarsOptions()->bShowPopupBarToolTips &&
  556. ((pControl->GetFlags() & xtpFlagShowPopupBarTip) == 0))))
  557. {
  558. return -1;
  559. }
  562. INT_PTR nHit = pControl->OnToolHitTest(point, pTI);
  563. if (nHit != -1)
  564. {
  565. if (pTI->hwnd != m_hWnd)
  566. return -1;
  568. if (pTI != NULL && pTI->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX))
  569. {
  570. if (((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo != NULL) ((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo->pObject = pControl;
  571. }
  573. return nHit;
  574. }
  576. nHit = pControl->GetIconId();
  577. CRect rect = pControl->GetRect();
  579. CString strTip = pControl->GetTooltip();
  580. if (strTip.GetLength() == 0)
  581. return -1;
  584. CString strShortcut = pControl->m_strShortcutText;
  585. if (pCommandBars && bToolBarAccelTips)
  586. {
  587. if (strShortcut.IsEmpty())
  588. {
  589. strShortcut = pControl->m_strShortcutTextAuto;
  590. if (!pCommandBars->GetShortcutManager()->FindDefaultAccelerator((UINT)pControl->GetID(), strShortcut))
  591. strShortcut.Empty();
  592. }
  594. if ((strShortcut.GetLength() > 0) && (strTip[0] != '<'))
  595. {
  596. strTip += _T(" (") + strShortcut +_T(")");
  597. }
  598. }
  600. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, rect, nHit,
  601. strTip, strTip, pControl->GetDescription(), GetImageManager());
  603. if (pTI != NULL && pTI->cbSize == sizeof(XTP_TOOLTIP_TOOLINFO_EX))
  604. {
  605. if (((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo != NULL) ((XTP_TOOLTIP_TOOLINFO_EX*)pTI)->pToolInfo->pObject = pControl;
  606. }
  608. // found matching rect, return the ID of the button
  609. return nHit != 0 ? nHit : -1;
  610. }
  614. void CXTPToolBar::OnRButtonDown(UINT nFlags, CPoint point)
  615. {
  616. CXTPControl* pControl = m_pControls->HitTest(point);
  617. if (pControl && pControl->OnRButtonDown(point))
  618. return;
  620. CXTPCommandBars* pCommandBars = GetCommandBars();
  621. if (!pCommandBars) return;
  623. if (IsCustomizeMode())
  624. {
  625. CXTPCommandBar::OnRButtonDown(nFlags, point);
  626. return;
  627. }
  629. SetTrackingMode(FALSE);
  630. SetSelected(-1);
  631. Redraw();
  633. ClientToScreen(&point);
  635. pCommandBars->ContextMenu(this, point);
  636. }
  639. BOOL CXTPToolBar::Create(CWnd* pParentWnd, BOOL bFloat)
  640. {
  641. if (!IsWindow(m_hWnd))
  642. {
  643. DWORD dwStyle = (bFloat ? WS_POPUP : WS_CHILD) | MFS_SYNCACTIVE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
  645. CPoint pt = m_pDockContext ? m_pDockContext->m_ptMRUFloatPos : CPoint(100, 100);
  647. CXTPCommandBars* pCommandBars = GetCommandBars();
  648. int nLayoutRTL = pCommandBars && pCommandBars->IsLayoutRTL() ? WS_EX_LAYOUTRTL : 0;
  650. if (!CWnd::CreateEx(nLayoutRTL, _T("XTPToolBar"), m_strTitle, dwStyle, CRect(pt, CSize(0, 0)), pParentWnd, 0))
  651. return FALSE;
  653. ShowWindow(SW_SHOWNA);
  654. }
  656. if (!bFloat)
  657. {
  658. ModifyStyle(WS_POPUP, WS_CHILD);
  659. }
  660. else
  661. {
  662. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)0);
  663. ModifyStyle(WS_CHILD, WS_POPUP | MFS_SYNCACTIVE);
  664. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)pParentWnd->m_hWnd);
  665. }
  667. return TRUE;
  668. }
  670. CRect CXTPToolBar::GetBorders()
  671. {
  672. if (GetPosition() == xtpBarFloating)
  673. {
  674. return CRect(3, 3, 3, 3);
  675. }
  677. CRect rcBorder = GetPaintManager()->GetCommandBarBorders(this);
  679. if (GetShowGripper())
  680. rcBorder.TopLeft() += GetPaintManager()->DrawCommandBarGripper(NULL, this, FALSE);
  682. return rcBorder;
  683. }
  685. CSize CXTPToolBar::CalcDockingLayout(int nLength, DWORD dwMode, int nWidth)
  686. {
  687. CClientDC dc(this);
  688. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this));
  689. CXTPControlPopup* pPopupExp = NULL;
  691. CRect rcBorder(GetBorders());
  693. CXTPControl* pHide = m_pControls->FindControl(XTP_ID_TOOLBAR_HIDE);
  694. if (pHide)
  695. {
  696. pHide->SetHideFlags(xtpHideGeneric);
  697. }
  699. BOOL bShowExpandButtonAlways = FALSE;
  700. CXTPCommandBars* pCommandBars = GetCommandBars();
  701. if (pCommandBars) bShowExpandButtonAlways = pCommandBars->GetCommandBarsOptions()->bShowExpandButtonAlways;
  703. BOOL bCommit = TRUE;
  704. CSize sz = 0;
  706. if (m_bShowExpandButton)
  707. {
  709. pPopupExp = (CXTPControlPopup*)m_pControls->FindControl(XTP_ID_TOOLBAR_EXPAND);
  710. if (!pPopupExp)
  711. {
  712. pPopupExp = (CXTPControlPopup*)m_pControls->Add(new CControlButtonExpand(), XTP_ID_TOOLBAR_EXPAND, _T(""), -1, TRUE);
  713. }
  714. pPopupExp->SetHideFlags(xtpHideGeneric);
  716. if (bShowExpandButtonAlways)
  717. {
  718. if (dwMode & LM_HORZDOCK)
  719. rcBorder.right += 11;
  720. else
  721. rcBorder.bottom += 11;
  722. }
  723. else
  724. {
  725. if (dwMode & LM_COMMIT)
  726. {
  727. sz = m_pControls->CalcDynamicSize(&dc, nLength, dwMode, rcBorder, nWidth);
  728. if (((CControlButtonExpand*)pPopupExp)->IsHiddenExists())
  729. {
  730. if (dwMode & LM_HORZDOCK)
  731. rcBorder.right += 11; else rcBorder.bottom += 11;
  733. }
  734. else
  735. {
  736. bCommit = FALSE;
  737. pPopupExp = NULL;
  738. }
  739. }
  740. else
  741. {
  742. sz = m_pControls->CalcDynamicSize(&dc, nLength, dwMode, rcBorder, nWidth);
  743. CSize szMin = m_pControls->CalcDynamicSize(&dc, 1, dwMode, rcBorder, nWidth);
  745. if (m_pControls->GetVisibleCount() > 1)
  746. {
  747. if (dwMode & LM_HORZDOCK)
  748. sz.cx = max(sz.cx, szMin.cx + 11); else
  749. sz.cy = max(sz.cy, szMin.cy + 11);
  750. }
  753. pPopupExp = NULL;
  754. bCommit = FALSE;
  755. }
  757. }
  758. }
  760. if (bCommit)
  761. sz = m_pControls->CalcDynamicSize(&dc, nLength, dwMode, rcBorder, nWidth);
  763. if (pPopupExp)
  764. {
  765. pPopupExp->SetHideFlags(xtpNoHide);
  766. GetPaintManager()->DrawSpecialControl(0, xtpButtonExpandToolbar, pPopupExp, this, FALSE, &sz);
  767. }
  769. if ((m_nIdleFlags & xtpIdleLayout) && (dwMode & LM_COMMIT))
  770. {
  771. m_nIdleFlags &= ~xtpIdleLayout;
  772. Redraw();
  773. }
  775. return sz;
  776. }
  778. CSize CXTPToolBar::CalcDynamicLayout(int nLength, DWORD nMode)
  779. {
  780. ASSERT(!(nMode & LM_HORZDOCK || nMode & LM_VERTDOCK));
  782. CClientDC dc(this);
  783. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this));
  785. int nTitleSize = GetPaintManager()->DrawCommandBarGripper(&dc, this, FALSE).cy;
  787. CRect rcBorder(GetBorders());
  788. rcBorder.top += nTitleSize + 1;
  790. CXTPControlPopup* pPopupExp = NULL;
  792. CXTPControl* pHide = NULL;
  794. if (IsCloseable())
  795. {
  796. pHide = m_pControls->FindControl(XTP_ID_TOOLBAR_HIDE);
  797. if (!pHide)
  798. {
  799. pHide = (CXTPControlPopup*)m_pControls->Add(new CControlButtonHide(), XTP_ID_TOOLBAR_HIDE, _T(""), -1, TRUE);
  800. }
  802. pHide->SetHideFlags(xtpHideGeneric);
  803. }
  805. if (m_bShowExpandButton && m_pCommandBars)
  806. {
  807. pPopupExp = (CXTPControlPopup*)m_pControls->FindControl(XTP_ID_TOOLBAR_EXPAND);
  808. if (!pPopupExp)
  809. {
  810. pPopupExp = (CXTPControlPopup*)m_pControls->Add(new CControlButtonExpand(), XTP_ID_TOOLBAR_EXPAND, _T(""), -1, TRUE);
  811. }
  812. pPopupExp->SetHideFlags(xtpHideGeneric);
  813. }
  815. CSize sz;
  816. if (m_barType == xtpBarTypePopup)
  817. {
  818. UpdateShortcuts();
  819. sz = m_pControls->CalcPopupSize(&dc, 0, 0, rcBorder);
  820. }
  821. else
  822. sz = m_pControls->CalcDynamicSize(&dc, nLength, nMode, rcBorder);
  824. int nLeft = sz.cx - 3;
  825. if (pHide)
  826. {
  827. pHide->SetHideFlags(xtpNoHide);
  828. pHide->SetRect(CRect(nLeft - nTitleSize, 3, nLeft, 3 + nTitleSize));
  829. nLeft -= nTitleSize;
  831. if (pPopupExp) pPopupExp->SetWrap(TRUE);
  832. }
  834. BOOL bShowExpandButtonAlways = TRUE;
  835. CXTPCommandBars* pCommandBars = GetCommandBars();
  836. if (pCommandBars) bShowExpandButtonAlways = pCommandBars->GetCommandBarsOptions()->bShowExpandButtonAlways;
  838. if (pPopupExp && nLeft - nTitleSize > 0 && bShowExpandButtonAlways)
  839. {
  840. pPopupExp->SetWrap(TRUE);
  841. pPopupExp->SetHideFlags(xtpNoHide);
  842. pPopupExp->SetRect(CRect(nLeft - nTitleSize, 3, nLeft, 3 + nTitleSize));
  843. }
  845. if ((m_nIdleFlags & xtpIdleLayout) && (nMode & LM_COMMIT))
  846. {
  847. m_nIdleFlags &= ~xtpIdleLayout;
  848. Redraw();
  849. }
  851. return sz;
  852. }
  854. void CXTPToolBar::OnRecalcLayout()
  855. {
  856. if (!GetSafeHwnd())
  857. return;
  859. if (!IsVisible())
  860. return;
  862. if (m_bInRecalcLayout)
  863. return;
  865. m_bInRecalcLayout = TRUE;
  867. if (m_barPosition != xtpBarFloating)
  868. {
  869. CXTPCommandBars* pCommandBars = GetCommandBars();
  870. if (pCommandBars)
  871. {
  872. pCommandBars->RecalcFrameLayout();
  873. }
  874. else
  875. {
  876. CWnd* pSite = GetSite();
  877. CXTPClientRect rc(pSite);
  878. if (pSite) pSite->SendMessage(WM_SIZE, 0, MAKELPARAM(rc.Width(), rc.Height()));
  879. }
  880. }
  881. else if (IsVisible())
  882. {
  883. CSize sz = CalcDynamicLayout(-1, LM_MRUWIDTH | LM_HORZ | LM_COMMIT);
  884. CRect rc;
  885. GetWindowRect(&rc);
  886. MoveWindow(rc.left, rc.top, sz.cx, sz.cy, TRUE);
  887. }
  889. Redraw();
  891. m_bInRecalcLayout = FALSE;
  892. }
  894. BOOL CXTPToolBar::OnNcCreate(LPCREATESTRUCT lpCreateStruct)
  895. {
  896. if (!CXTPCommandBar::OnNcCreate(lpCreateStruct))
  897. return FALSE;
  899. if (GetStyle() & MFS_SYNCACTIVE)
  900. {
  901. // syncronize activation state with top level parent
  902. CWnd* pParentWnd = GetTopLevelParent();
  903. ASSERT(pParentWnd != NULL);
  904. if (!pParentWnd)
  905. return FALSE;
  907. CWnd* pActiveWnd = GetForegroundWindow();
  908. BOOL bActive = (pParentWnd == pActiveWnd) ||
  909. (pParentWnd->GetLastActivePopup() == pActiveWnd &&
  910. pActiveWnd->SendMessage(WM_FLOATSTATUS, FS_SYNCACTIVE) != 0);
  912. // the WM_FLOATSTATUS does the actual work
  913. SendMessage(WM_FLOATSTATUS, bActive ? FS_ACTIVATE : FS_DEACTIVATE);
  914. }
  917. return TRUE;
  918. }
  921. LRESULT CXTPToolBar::OnFloatStatus(WPARAM wParam, LPARAM)
  922. {
  923. // FS_SYNCACTIVE is used to detect MFS_SYNCACTIVE windows
  924. LRESULT lResult = ((GetStyle() & MFS_SYNCACTIVE) && (wParam & FS_SYNCACTIVE));
  926. if (m_barPosition != xtpBarFloating || !m_bVisible)
  927. return lResult;
  929. BOOL bSyncActivate = TRUE;
  930. CXTPCommandBars* pCommandBars = GetCommandBars();
  931. if (pCommandBars) bSyncActivate = pCommandBars->GetCommandBarsOptions()->bSyncFloatingBars;
  933. if (bSyncActivate)
  934. {
  935. if ((wParam & FS_DEACTIVATE) && !IsTopParentActive())
  936. {
  937. SetWindowPos(NULL, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
  938. }
  939. if ((wParam & FS_ACTIVATE) && !IsWindowVisible() && IsTopParentActive())
  940. {
  941. // check if parent invisible or minimized window
  942. DWORD dwStyle = ::GetWindowLong(::GetForegroundWindow(), GWL_STYLE);
  943. if ((dwStyle & WS_VISIBLE) && !(dwStyle & WS_MINIMIZE))
  944. SetWindowPos(NULL, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
  946. }
  947. }
  949. if (wParam & (FS_SHOW | FS_HIDE))
  950. {
  951. SetWindowPos(NULL, 0, 0, 0, 0,
  952. ((wParam & FS_SHOW) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW) | SWP_NOZORDER |
  953. SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
  954. }
  955. if (wParam & (FS_ENABLE | FS_DISABLE))
  956. EnableWindow((wParam & FS_ENABLE) != 0);
  958. return lResult;
  959. }
  961. BOOL CXTPToolBar::IsFloatingFrameFocused() const
  962. {
  963. if (!IsTopParentActive())
  964. return FALSE;
  966. CWnd* pWnd = CWnd::GetFocus();
  968. while (pWnd && IsWindow(pWnd->GetSafeHwnd()))
  969. {
  970. pWnd = pWnd->GetParentFrame();
  972. if (DYNAMIC_DOWNCAST(CMiniFrameWnd, pWnd))
  973. return TRUE;
  974. }
  975. return FALSE;
  976. }
  978. int CXTPToolBar::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
  979. {
  980. if (m_barPosition == xtpBarFloating || IsFloatingFrameFocused() || IsCustomizeMode())
  981. return MA_NOACTIVATE;
  983. return CWnd::OnMouseActivate(pDesktopWnd, nHitTest, message);
  984. }
  986. BOOL CXTPToolBar::OnNcActivate(BOOL bActive)
  987. {
  988. return bActive ? FALSE : CWnd::OnNcActivate(bActive);
  989. }
  991. void CXTPToolBar::OnLButtonDown(UINT nFlags, CPoint point)
  992. {
  993. if (m_barPosition == xtpBarFloating)
  994. SetWindowPos(&CWnd::wndTop, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
  997. if (m_pControls->HitTest(point) == NULL)
  998. {
  999. m_pCommandBars->ClosePopups();
  1001. if (m_pDockContext && ((m_dwFlags & (xtpFlagAlignAny | xtpFlagFloating)) != 0))
  1002. {
  1003. ClientToScreen(&point);
  1004. m_pDockContext->StartDrag(point);
  1005. }
  1006. }
  1007. else
  1008. {
  1009. CXTPCommandBar::OnLButtonDown(nFlags, point);
  1010. }
  1011. }
  1013. void CXTPToolBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  1014. {
  1015. if (m_pControls->HitTest(point) == NULL)
  1016. {
  1017. if (m_pDockContext)
  1018. {
  1019. m_pDockContext->ToggleDocking();
  1020. return;
  1021. }
  1022. }
  1024. CXTPCommandBar::OnLButtonDblClk(nFlags, point);
  1025. }
  1027. LRESULT CXTPToolBar::OnNcHitTest(CPoint point)
  1028. {
  1029. if (m_barPosition != xtpBarFloating)
  1030. return CXTPCommandBar::OnNcHitTest(point);
  1032. if (m_barType == xtpBarTypePopup)
  1033. return CXTPCommandBar::OnNcHitTest(point);
  1035. CRect rectWindow;
  1036. GetWindowRect(&rectWindow);
  1037. rectWindow.InflateRect(-3, -3);
  1039. if (point.y < rectWindow.top) return HTTOP;
  1040. if (point.y >= rectWindow.bottom) return HTBOTTOM;
  1041. if (point.x < rectWindow.left) return HTLEFT;
  1042. if (point.x >= rectWindow.right) return HTRIGHT;
  1044. return CXTPCommandBar::OnNcHitTest(point);
  1045. }
  1047. void CXTPToolBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
  1048. {
  1049. if (!m_pDockContext)
  1050. return;
  1052. if (nHitTest >= HTSIZEFIRST && nHitTest <= HTSIZELAST)
  1053. {
  1054. ActivateTopParent();
  1055. SetWindowPos(&CWnd::wndTop, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
  1057. m_pCommandBars->ClosePopups();
  1058. m_pDockContext->StartResize(nHitTest, point);
  1059. return;
  1060. }
  1062. CXTPCommandBar::OnNcLButtonDown(nHitTest, point);
  1063. }
  1067. void CXTPToolBar::OnClose()
  1068. {
  1069. }
  1071. BOOL CXTPToolBar::IsWindowVisible() const
  1072. {
  1073. return GetSafeHwnd() && IsVisible() && CWnd::IsWindowVisible() && !CXTPWindowRect(this).IsRectEmpty();
  1074. }
  1076. void CXTPToolBar::SetVisible(BOOL bVisible)
  1077. {
  1078. if (m_bVisible == bVisible)
  1079. return;
  1081. m_bVisible = bVisible;
  1083. if (!bVisible)
  1084. {
  1085. SetTrackingMode(FALSE);
  1086. }
  1088. ShowWindow(bVisible ? SW_SHOWNA : SW_HIDE);
  1090. CXTPCommandBars* pCommandBars = GetCommandBars();
  1092. if (bVisible)
  1093. {
  1094. OnRecalcLayout();
  1095. }
  1096. else if (IsDockingPosition(m_barPosition))
  1097. {
  1098. if (pCommandBars)
  1099. {
  1100. pCommandBars->RecalcFrameLayout();
  1101. }
  1102. else
  1103. {
  1104. CWnd* pSite = GetSite();
  1105. CXTPClientRect rc(pSite);
  1106. if (pSite) pSite->SendMessage(WM_SIZE, 0, MAKELPARAM(rc.Width(), rc.Height()));
  1107. }
  1108. }
  1111. if (pCommandBars)
  1112. {
  1113. BOOL bRemove = m_bTearOff && !bVisible;
  1115. pCommandBars->GetSite()->SendMessage(WM_XTP_TOOLBARVISIBLECHANGED, (WPARAM)this, (LPARAM)m_bVisible);
  1117. if (bRemove)
  1118. pCommandBars->Remove(this);
  1120. pCommandBars->GetCommandBarsOptions()->bDirtyState = TRUE;
  1121. }
  1122. }
  1127. LRESULT CXTPToolBar::OnSizeParent(WPARAM, LPARAM lParam)
  1128. {
  1129. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  1131. if (GetStyle() & WS_VISIBLE)
  1132. {
  1133. // align the control bar
  1134. CRect rect;
  1135. rect.CopyRect(&lpLayout->rect);
  1137. CSize sizeAvail = rect.Size();  // maximum size available
  1139. // get maximum requested size
  1140. DWORD dwMode = LM_HORZDOCK | LM_HORZ | LM_COMMIT;
  1141. if (GetFlags() & xtpFlagStretched) dwMode |= LM_STRETCH;
  1142. if (GetFlags() & xtpFlagHideWrap) dwMode |= LM_HIDEWRAP;
  1146. if (lpLayout->hDWP == NULL) dwMode &= ~LM_COMMIT;
  1148. CSize size = CalcDockingLayout(sizeAvail.cx, dwMode);
  1150. size.cx = min(size.cx, sizeAvail.cx);
  1151. size.cy = min(size.cy, sizeAvail.cy);
  1153. lpLayout->sizeTotal.cy += size.cy;
  1154. lpLayout->sizeTotal.cx = max(lpLayout->sizeTotal.cx, size.cx);
  1155. lpLayout->rect.top += size.cy;
  1157. rect.right = rect.left + size.cx;
  1158. rect.bottom = rect.top + size.cy;
  1160. // only resize the window if doing layout and not just rect query
  1161. if (lpLayout->hDWP != NULL)
  1162. AfxRepositionWindow(lpLayout, m_hWnd, &rect);
  1164. Redraw();
  1165. }
  1166. return 0;
  1167. }
  1169. CSize CXTPCommandBar::GetAutoIconSize(BOOL bLarge) const
  1170. {
  1171. return GetPaintManager()->GetAutoIconSize(bLarge);
  1172. }
  1175. CSize CXTPCommandBar::GetIconSize() const
  1176. {
  1177. CXTPCommandBars* pCommandBars = GetCommandBars();
  1179. if (!pCommandBars)
  1180. return m_szIcons != CSize(0) ? m_szIcons : CSize(16, 16);
  1182. if (GetType() == xtpBarTypePopup)
  1183. {
  1184. return m_szIcons != CSize(0) ? m_szIcons : pCommandBars->m_pOptions->szPopupIcons != CSize(0) ? pCommandBars->m_pOptions->szPopupIcons : GetAutoIconSize(FALSE);
  1185. }
  1187. CSize sz = m_szIcons != CSize(0) ? m_szIcons: (pCommandBars->m_pOptions->szIcons != CSize(0) ? pCommandBars->m_pOptions->szIcons : GetAutoIconSize(FALSE));
  1189. if (pCommandBars->m_pOptions->bLargeIcons && m_szButtons == CSize(0))
  1190. {
  1191. sz = pCommandBars->m_pOptions->szLargeIcons != CSize(0) ? pCommandBars->m_pOptions->szLargeIcons : GetAutoIconSize(TRUE);
  1192. }
  1194. return sz;
  1195. }
  1197. CSize CXTPCommandBar::GetLargeIconSize(BOOL bAutoSize) const
  1198. {
  1199. CXTPCommandBars* pCommandBars = GetCommandBars();
  1201. if (!pCommandBars)
  1202. return m_szIcons != CSize(0) ? CSize(2 * m_szIcons.cx, 2 * m_szIcons.cy) : CSize(32, 32);
  1204. CSize sz = m_szIcons != CSize(0) ? m_szIcons: (pCommandBars->m_pOptions->szIcons != CSize(0) ?
  1205. pCommandBars->m_pOptions->szIcons : CSize(16, 16));
  1207. if (m_szButtons == CSize(0))
  1208. {
  1209. sz = pCommandBars->m_pOptions->szLargeIcons != CSize(0) ?
  1210. pCommandBars->m_pOptions->szLargeIcons : (bAutoSize ? GetAutoIconSize(TRUE) : CSize(sz.cx * 2, sz.cy * 2));
  1211. }
  1213. return sz;
  1214. }
  1217. CSize CXTPCommandBar::GetButtonSize() const
  1218. {
  1219. if (m_szButtons != CSize(0)) return m_szButtons;
  1221. CSize szIcon = GetIconSize();
  1222. return CSize(szIcon.cx + 6, szIcon.cy + 6);
  1223. }
  1225. void CXTPCommandBar::ShowTextBelowIcons(BOOL bTextBelow)
  1226.  {
  1227. m_bTextBelow = bTextBelow;
  1228. DelayLayout();
  1229. }
  1231. BOOL CXTPCommandBar::IsTextBelowIcons() const
  1232. {
  1233. if (m_bTextBelow != XTP_BOOL_DEFAULT)
  1234. return m_bTextBelow;
  1236. CXTPCommandBars* pCommandBars = GetCommandBars();
  1237. if (pCommandBars)
  1238. {
  1239. return pCommandBars->m_pOptions->bShowTextBelowIcons;
  1240. }
  1241. return FALSE;
  1242. }
  1245. int CXTPToolBar::_FindNearest(CXTPControls* pControls, CXTPControl* pFind, int nPos, BOOL /*bVisible*/) const
  1246. {
  1247. if (pFind == NULL)
  1248. return -1;
  1250. int nResult = -1;
  1252. for (int i = nPos; i < pControls->GetCount(); i++)
  1253. {
  1254. CXTPControl* pControl = pControls->GetAt(i);
  1256. if (pControl->GetID() == pFind->GetID() && pControl->GetType() == pFind->GetType())
  1257. {
  1258. return i;
  1259. }
  1260. }
  1261. return nResult;
  1262. }
  1265. void CXTPToolBar::Reset(BOOL bShowWarningMessage)
  1266. {
  1267. if (m_bBuiltIn && m_nBarID != 0 && IsCustomizable())
  1268. {
  1269. if (bShowWarningMessage)
  1270. {
  1271. CString strMessage, strTitle = GetTitle(), strReset;
  1273. VERIFY(XTPResourceManager()->LoadString(&strReset, XTP_IDS_CONFIRM_RESET));
  1274. strMessage.Format(strReset, (LPCTSTR)strTitle);
  1276. CXTPPushRoutingFrame push(GetFrameSite());
  1278. if (XTPResourceManager()->ShowMessageBox(strMessage, MB_ICONWARNING | MB_OKCANCEL) != IDOK)
  1279. return;
  1280. }
  1282. if (m_pControls->m_pOriginalControls != NULL)
  1283. {
  1284. m_pControls->RemoveAll();
  1286. CXTPControls* pControls = m_pControls->m_pOriginalControls;
  1287. for (int i = 0; i < pControls->GetCount(); i++)
  1288. {
  1289. CXTPControl* pControl = pControls->GetAt(i);
  1290. if (!pControl->m_bTemporary)
  1291. m_pControls->AddClone(pControl, -1, TRUE);
  1292. }
  1294. }
  1295. else
  1296. {
  1297. LoadToolBar(m_nBarID, FALSE);
  1298. }
  1300. CWnd* pWnd = GetSite();
  1301. if (pWnd && ::IsWindow(pWnd->m_hWnd)) pWnd->SendMessage(WM_XTP_CUSTOMIZATION_RESETTOOLBAR, 0, (LPARAM)this);
  1303. OnInitialUpdate();
  1304. OnRecalcLayout();
  1305. }
  1306. }
  1308. void CXTPToolBar::BuildCustomizePopup(CXTPCommandBar* pExpandBar)
  1309. {
  1310. CXTPCommandBars* pCommandBars = GetCommandBars();
  1311. if (!pCommandBars)
  1312. return;
  1314. CXTPControls* pOriginalControls = m_pControls->m_pOriginalControls ? m_pControls->m_pOriginalControls->Duplicate(FALSE) : new CXTPControls();
  1315. ASSERT(pOriginalControls);
  1317. int nOriginal = 0;
  1318. int nToolBar = 0;
  1320. while (nToolBar < GetControlCount())
  1321. {
  1322. if ((GetControl(nToolBar)->GetHideFlags() & xtpHideCustomize) != 0)
  1323. {
  1324. int nSelected = m_nSelected;
  1325. int nPopuped = m_nPopuped;
  1326. GetControls()->Remove(nToolBar);
  1327. if (nPopuped != -1) m_nPopuped = nPopuped + (nToolBar < nPopuped ? - 1 : 0);
  1328. if (nSelected != -1) m_nSelected = nSelected + (nToolBar < nSelected ? - 1 : 0);
  1329. }
  1330. else
  1331. nToolBar++;
  1333. }
  1335. nToolBar = 0;
  1337. while (nOriginal < pOriginalControls->GetCount() || nToolBar < GetControlCount())
  1338. {
  1339. CXTPControl* pOriginal = nOriginal < pOriginalControls->GetCount() ? pOriginalControls->GetAt(nOriginal) : NULL;
  1340. CXTPControl* pControl = nToolBar < GetControlCount() ? m_pControls->GetAt(nToolBar) : NULL;
  1343. int nNearest = _FindNearest(m_pControls, pOriginal, nToolBar, TRUE);
  1344. int nNearestOriginal = _FindNearest(pOriginalControls, pControl, nOriginal);
  1346. if (nNearest == -1 && pOriginal)
  1347. {
  1348. int nSelected = m_nSelected;
  1349. int nPopuped = m_nPopuped;
  1350. pControl = m_pControls->AddClone(pOriginal, nToolBar);
  1351. if (nPopuped != -1) m_nPopuped = nPopuped + (nToolBar <= nPopuped ? 1 : 0);
  1352. if (nSelected != -1) m_nSelected = nSelected + (nToolBar <= nSelected ? 1 : 0);
  1353. nNearestOriginal = nToolBar;
  1355. pControl->SetHideFlag(xtpHideCustomize, TRUE);
  1356. nOriginal++;
  1357. nToolBar++;
  1358. }
  1359. else
  1360. {
  1361. if (nNearest == nToolBar) nOriginal++;
  1362. else if (nNearestOriginal != -1) pOriginalControls->Remove(nNearestOriginal);
  1363. nToolBar++;
  1364. }
  1365. ASSERT(pControl);
  1367. if (!pControl)
  1368. {
  1369. continue;
  1370. }
  1371. if (pControl->GetID() == XTP_ID_TOOLBAR_HIDE || pControl->GetID() == XTP_ID_TOOLBAR_EXPAND)
  1372. {
  1373. continue;
  1374. }
  1375. if (pControl->GetAction() && !pControl->GetAction()->IsVisible())
  1376. continue;
  1378. if ((pControl->GetHideFlags() & (xtpHideGeneric | xtpHideDocTemplate | xtpHideRibbonTab)) != 0)
  1379. {
  1380. continue;
  1381. }
  1382. if (!pControl->IsCustomizeMovable())
  1383. {
  1384. continue;
  1385. }
  1388. CControlButtonCustomize* pButton = (CControlButtonCustomize*)pExpandBar->GetControls()->Add(new CControlButtonCustomize(), 0);
  1389. pButton->SetCaption(pControl->GetCaption());
  1391. XTPControlType controlType = pControl->GetType();
  1392. if ((controlType == xtpControlPopup) || (controlType == xtpControlButtonPopup) || (controlType == xtpControlSplitButtonPopup) || (controlType == xtpControlButton))
  1393. pButton->SetIconId(pControl->GetIconId());
  1395. CString strShortcut = pControl->m_strShortcutText;
  1396. if (strShortcut.IsEmpty())
  1397. pCommandBars->GetShortcutManager()->FindDefaultAccelerator(pControl->GetID(), strShortcut);
  1398. pButton->SetShortcutText(strShortcut);
  1399. pButton->SetEnabled(nNearestOriginal != -1);
  1400. pButton->SetChecked((pControl->GetHideFlags() & xtpHideCustomize) == 0);
  1401. pButton->m_pControl = pControl;
  1402. }
  1404. pOriginalControls->InternalRelease();
  1406. if (m_pControls->m_pOriginalControls && !m_bTearOff && m_bBuiltIn)
  1407. {
  1408. CControlButtonCustomize* pButton = (CControlButtonCustomize*)pExpandBar->GetControls()->Add(new CControlButtonCustomize(), XTP_ID_CUSTOMIZE_RESET);
  1409. pButton->SetFlags(xtpFlagManualUpdate);
  1411. pButton->SetBeginGroup(TRUE);
  1412. pButton->m_pToolBar = this;
  1413. }
  1414. }
  1417. void CXTPToolBar::OnSetPreviewMode(BOOL bPreview)
  1418. {
  1419. if (m_bPreviewMode == bPreview)
  1420. return;
  1422. m_bPreviewMode = bPreview;
  1424. if (bPreview)
  1425. {
  1426. m_bPreviewVisible = m_bVisible;
  1427. if (m_bVisible)
  1428. {
  1429. m_bVisible = FALSE;
  1430. ShowWindow(SW_HIDE);
  1431. }
  1432. }
  1433. else if (m_bPreviewVisible)
  1434. {
  1435. m_bVisible = TRUE;
  1436. ShowWindow(SW_SHOWNA);
  1438. if (GetType() == xtpBarTypeMenuBar)
  1439. {
  1440. CFrameWnd* pFrameWnd = GetFrameSite();
  1441. if (pFrameWnd && pFrameWnd->GetSafeHwnd()) pFrameWnd->OnUpdateFrameMenu(0);
  1442. }
  1444. }
  1445. }
  1447. void CXTPToolBar::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive)
  1448. {
  1449. CXTPCommandBar::Copy(pCommandBar, bRecursive);
  1451. m_bBuiltIn = ((CXTPToolBar*)pCommandBar)->m_bBuiltIn;
  1452. m_bTearOff = ((CXTPToolBar*)pCommandBar)->m_bTearOff;
  1453. m_bCloseable = ((CXTPToolBar*)pCommandBar)->m_bCloseable;
  1455. }
  1457. BOOL CXTPToolBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  1458. {
  1459. if (m_pDockContext == NULL && nChar == VK_TAB && GetParent())
  1460. {
  1461. CWnd* pWndNext = GetParent()->GetNextDlgTabItem(this,
  1462. (GetKeyState(VK_SHIFT) < 0));
  1464. if (pWndNext != NULL && pWndNext != this)
  1465. {
  1466. pWndNext->SetFocus();
  1467. SetTrackingMode(FALSE);
  1469. return TRUE;
  1470. }
  1471. }
  1472. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1473. }
  1475. void CXTPToolBar::OnSetFocus(CWnd* pOldWnd)
  1476. {
  1477. if (!m_hwndFocus && pOldWnd) m_hwndFocus = pOldWnd->GetSafeHwnd();
  1478. CXTPCommandBar::OnSetFocus(pOldWnd);
  1480. if (m_pDockContext == NULL)
  1481. {
  1482. SetTrackingMode(TRUE, TRUE);
  1483. }
  1485. }
  1487. BOOL CXTPToolBar::ShouldSerializeBar()
  1488. {
  1489. if (!IsCustomizable())
  1490. return FALSE;
  1492. if (GetControls()->GetOriginalControls() && !GetControls()->IsChanged())
  1493. return FALSE;
  1495. return TRUE;
  1497. }