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

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

对话框与窗口

开发平台：

Visual C++

XTPPopupBar.cpp：源码内容
  1. // XTPPopupBar.cpp : implementation of the CXTPPopupBar 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/XTPDrawHelpers.h"
  26. #include "Common/XTPColorManager.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPToolTipContext.h"
  29. #include "Common/XTPHookManager.h"
  31. #include "XTPPopupBar.h"
  32. #include "XTPPaintManager.h"
  33. #include "XTPControls.h"
  34. #include "XTPControl.h"
  35. #include "XTPControlButton.h"
  36. #include "XTPShortcutManager.h"
  37. #include "XTPControlPopup.h"
  38. #include "XTPToolBar.h"
  39. #include "XTPCommandBars.h"
  40. #include "XTPMouseManager.h"
  41. #include "XTPSoundManager.h"
  43. #ifdef _DEBUG
  44. #define new DEBUG_NEW
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #endif
  49. double CXTPPopupBar::m_dMaxWidthDivisor = 1.0/3.0;
  51. #ifndef EVENT_SYSTEM_MENUPOPUPSTART
  52. #define EVENT_SYSTEM_MENUPOPUPSTART     0x0006
  53. #define EVENT_SYSTEM_MENUPOPUPEND       0x0007
  54. #define OBJID_MENU 0xFFFFFFFD
  55. #endif
  57. #define TID_HOVERUP 5001
  58. #define TID_HOVERDOWN 5002
  59. #define TID_TEAROFFSELECTED 5003
  60. #define TID_EXPANDHOVER 5004
  63. class CXTPPopupBar::CControlExpandButton: public CXTPControlButton
  64. {
  65. public:
  66. CControlExpandButton()
  67. {
  68. m_controlType = xtpControlButton;
  69. m_dwFlags = xtpFlagManualUpdate | xtpFlagNoMovable | xtpFlagSkipFocus | xtpFlagShowPopupBarTip;
  70. }
  71. void Draw(CDC* pDC);
  72. virtual void OnExecute();
  73. };
  75. void CXTPPopupBar::CControlExpandButton::Draw(CDC* pDC)
  76. {
  77. GetPaintManager()->DrawSpecialControl(pDC, xtpButtonExpandMenu, this, m_pParent, TRUE, NULL);
  78. }
  80. void CXTPPopupBar::CControlExpandButton::OnExecute()
  81. {
  82. ((CXTPPopupBar*)m_pParent)->ExpandBar();
  83. }
  86. IMPLEMENT_XTP_COMMANDBAR(CXTPPopupBar, CXTPCommandBar)
  88. CXTPPopupBar::CXTPPopupBar()
  89. {
  90. m_scrollInfo.Init(this, TID_HOVERUP, TID_HOVERDOWN);
  92. m_barType = xtpBarTypePopup;
  93. m_barPosition = xtpBarPopup;
  95. m_pControlPopup = 0;
  96. m_ptPopup = 0;
  97. m_rcExclude.SetRectEmpty();
  98. m_rcTearOffGripper.SetRectEmpty();
  99. m_rcResizeGripper.SetRectEmpty();
  100. m_bResizable = FALSE;
  101. m_popupFlags = xtpPopupRight;
  102. m_bDynamicLayout = FALSE;
  104. m_bTearOffPopup = FALSE;
  105. m_bTearOffTracking = FALSE;
  106. m_nTearOffID = 0;
  107. m_nTearOffWidth = 0;
  109. m_bShowShadow = TRUE;
  110. m_rcBorders = CRect(2, 4, 2, 4);
  111. m_bExpanding = FALSE;
  113. m_nMRUWidth = 0;
  114. m_bDoubleGripper = FALSE;
  116. m_pTearOffBar = NULL;
  117. m_szTearOffBar = CSize(0, 0);
  118. m_nTearOffTimer = 0;
  120. m_bContextMenu = FALSE;
  122. }
  124. CXTPPopupBar* CXTPPopupBar::CreatePopupBar(CXTPCommandBars* pCommandBars)
  125. {
  126. CXTPPopupBar* pPopupBar = (CXTPPopupBar*)CXTPCommandBars::m_pPopupBarClass->CreateObject();
  127. pPopupBar->SetCommandBars(pCommandBars);
  128. return pPopupBar;
  129. }
  131. CXTPPopupBar::~CXTPPopupBar()
  132. {
  133. }
  135. void CXTPPopupBar::SetTearOffPopup(LPCTSTR strCaption, UINT nID, int nWidth)
  136. {
  137. if (nID == 0)
  138. {
  139. m_bTearOffPopup = FALSE;
  140. }
  141. else
  142. {
  143. m_bTearOffPopup = TRUE;
  144. m_strTearOffCaption = strCaption;
  145. m_nTearOffID = nID;
  146. m_nTearOffWidth = nWidth;
  147. }
  148. }
  149. BOOL CXTPPopupBar::IsTearOffPopup(CString& strCaption, UINT& nID, int& nWidth)
  150. {
  151. strCaption = m_strTearOffCaption;
  152. nID = m_nTearOffID;
  153. nWidth = m_nTearOffWidth;
  155. return m_bTearOffPopup;
  156. }
  158. BOOL CXTPPopupBar::IsVisible() const
  159. {
  160. return (m_hWnd != 0) && IsWindowVisible();
  161. }
  163. void CXTPPopupBar::ExpandBar()
  164. {
  165. if (m_bExpanded == FALSE && m_bCollapsed == TRUE)
  166. {
  167. SAFE_CALLPTR(m_pToolTipContext, CancelToolTips());
  169. m_bExpanding = TRUE;
  170. m_bExpanded = TRUE;
  171. SetPopuped(-1);
  172. SetSelected(-1);
  173. OnRecalcLayout();
  174. XTPMouseManager()->SetForceExpanded(TRUE);
  175. XTPMouseManager()->IgnoreLButtonUp();
  176. }
  177. }
  179. BOOL CXTPPopupBar::Create()
  180. {
  181. if (m_hWnd)
  182. return TRUE;
  184. CXTPCommandBars* pCommandBars = GetCommandBars();
  185. UINT nClassStyle = !pCommandBars || pCommandBars->GetCommandBarsOptions()->bUseSystemSaveBitsStyle ? CS_SAVEBITS | CS_DBLCLKS : CS_DBLCLKS;
  187. CXTPDrawHelpers::RegisterWndClass(0, _T("XTPPopupBar"), nClassStyle);
  189. int nLayoutRTL = pCommandBars && pCommandBars->IsLayoutRTL() ? WS_EX_LAYOUTRTL : 0;
  190. if (!pCommandBars && GetImageManager()->IsDrawReverted() == 1) nLayoutRTL = WS_EX_LAYOUTRTL;
  192. if (!CreateEx(WS_EX_TOOLWINDOW | nLayoutRTL, _T("XTPPopupBar"), 0, MFS_SYNCACTIVE | WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, CRect(0, 0, 0, 0), GetSite(), 0))
  193. return FALSE;
  195. SetWindowText(m_strTitle);
  197. return TRUE;
  198. }
  200. #ifndef SPI_GETMENUANIMATION
  201. #define SPI_GETMENUANIMATION                0x1002
  202. #endif
  204. #ifndef SPI_GETMENUFADE
  205. #define SPI_GETMENUFADE                     0x1012
  206. #endif
  209. XTPAnimationType CXTPPopupBar::GetAnimationType() const
  210. {
  211. CXTPCommandBars* pCommandBars = GetCommandBars();
  212. if (pCommandBars)
  213. {
  214. if (GetWindow(GW_CHILD))
  215. return xtpAnimateNone;
  217. XTPAnimationType animationType = pCommandBars->GetCommandBarsOptions()->animationType;
  219. switch (animationType)
  220. {
  221. case xtpAnimateWindowsDefault:
  222. {
  223. BOOL bEnabled = FALSE;
  224. if (!SystemParametersInfo(SPI_GETMENUANIMATION, 0, &bEnabled, 0))
  225. return xtpAnimateNone;
  227. if (!bEnabled)
  228. return xtpAnimateNone;
  230. BOOL bFadeAnimation = FALSE;
  232. if (!SystemParametersInfo(SPI_GETMENUFADE, 0, &bFadeAnimation, 0))
  233. return xtpAnimateSlide;
  235. animationType = bFadeAnimation ? xtpAnimateFade : xtpAnimateSlide;
  236. }
  237. break;
  239. // choose any animation based on a random number
  240. case xtpAnimateRandom:
  241. {
  242. switch (RAND_S() % 3)
  243. {
  244. case 0:
  245. animationType = xtpAnimateFade;
  246. break;
  248. case 1:
  249. animationType = xtpAnimateSlide;
  250. break;
  252. default:
  253. animationType = xtpAnimateUnfold;
  254. break;
  255. }
  256. }
  257. break;
  258. }
  260. return animationType;
  261. }
  262. return xtpAnimateNone;
  264. }
  266. void CXTPPopupBar::OnControlsChanged()
  267. {
  268. m_nSelected = -1;
  269. m_nPopuped = -1;
  271. OnRecalcLayout();
  272. }
  274. void CXTPPopupBar::RecalcSizeLayout()
  275. {
  276. if (!m_bDynamicLayout && GetSafeHwnd() && IsTrackingMode())
  277. {
  278. CSize sz = CalcDynamicLayout(0, 0);
  279. CXTPWindowRect rcWindow(this);
  281. BOOL bRTL = GetExStyle() & WS_EX_LAYOUTRTL;
  283. CRect rc = !bRTL ? CRect(CPoint(rcWindow.left, rcWindow.top), sz) : CRect(CPoint(rcWindow.right - sz.cx, rcWindow.top), sz);
  285. if (rc == rcWindow)
  286. {
  287. Redraw();
  288. return;
  289. }
  291. CXTPCommandBars* pCommandBars = GetCommandBars();
  292. BOOL bShowKeyboardTips = IsKeyboardTipsVisible();
  293. if (bShowKeyboardTips && pCommandBars) pCommandBars->HideKeyboardTips();
  295. SetWindowRgn(NULL, FALSE);
  297. CXTPPaintManager* pPaintManager = GetPaintManager();
  299. SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  300. pPaintManager->SetCommandBarRegion(this);
  302. pPaintManager->GetShadowManager()->OffsetShadow(this, rc.Size() - rcWindow.Size());
  304. Redraw();
  305. }
  306. }
  308. void CXTPPopupBar::OnRecalcLayout()
  309. {
  310. if (!m_bDynamicLayout && GetSafeHwnd() && IsTrackingMode())
  311. {
  313. UpdateShortcuts();
  314. UpdateFlags();
  316. CRect rc = CalculatePopupRect(m_ptPopup, CalcDynamicLayout(0, 0));
  317. CXTPWindowRect rcWindow(this);
  319. if (!m_bExpanding && rc == rcWindow)
  320. {
  321. Redraw();
  322. return;
  323. }
  325. CXTPCommandBars* pCommandBars = GetCommandBars();
  326. BOOL bShowKeyboardTips = IsKeyboardTipsVisible();
  327. if (bShowKeyboardTips && pCommandBars) pCommandBars->HideKeyboardTips();
  329. CXTPPaintManager* pPaintManager = GetPaintManager();
  330. pPaintManager->GetShadowManager()->RemoveShadow(this);
  332. BOOL bChanged = FALSE;
  334. if (m_bExpanding)
  335. {
  336. BOOL bExpandDown = rcWindow.bottom < rc.bottom;
  338. XTPAnimationType animationType = GetAnimationType();
  339. if (IsAnimateType(animationType))
  340. {
  341. CDC* pDC = GetDesktopWindow()->GetDC();
  343. CBitmap bmp;
  344. bmp.CreateCompatibleBitmap(pDC, rc.Width(), rc.Height());
  345. CXTPCompatibleDC dcWindow(pDC, &bmp);
  347. dcWindow.BitBlt(0, 0, rc.Width(), rc.Height(), pDC, rc.left, rc.top, SRCCOPY);
  348. GetDesktopWindow()->ReleaseDC(pDC);
  350. ShowWindow(SW_HIDE);
  351. GetSite()->UpdateWindow();
  353. SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOREDRAW);
  354. pPaintManager->SetCommandBarRegion(this);
  355. bChanged = TRUE;
  357. CWindowDC paintDC(this);
  358. CXTPClientRect rcClientPost(this);
  360. BOOL dwLayout = CXTPDrawHelpers::IsContextRTL(&paintDC);
  361. CXTPDrawHelpers::SetContextRTL(&paintDC, FALSE);
  362. paintDC.BitBlt(0, 0, rc.Width(), rc.Height(), &dcWindow, 0, 0, SRCCOPY);
  363. CXTPDrawHelpers::SetContextRTL(&paintDC, dwLayout);
  366. CXTPBufferDC animationDC(paintDC, rcClientPost);
  367. DrawCommandBar(&animationDC, rcClientPost);
  369. // Animation
  370. pPaintManager->AnimateExpanding(this, &paintDC, &animationDC, bExpandDown);
  371. }
  372. XTPSoundManager()->PlaySystemSound(xtpSoundMenuPopup);
  373. }
  375. if (!bChanged)
  376. {
  377. SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
  378. pPaintManager->SetCommandBarRegion(this);
  379. }
  381. if (m_barPosition == xtpBarPopup && m_bShowShadow && pPaintManager->m_bShowShadow && !IsCustomizeMode())
  382. pPaintManager->GetShadowManager()->SetShadow(this, m_rcExclude);
  384. if (m_pControlPopup)
  385. m_pControlPopup->UpdateShadow();
  387. Redraw();
  389. if (bShowKeyboardTips)
  390. {
  391. PostMessage(WM_TIMER, XTP_TID_SHOWKEYBOARDTIPS);
  392. }
  394. m_bExpanding = FALSE;
  395. }
  396. }
  398. void CXTPPopupBar::_MakeSameWidth(int nStart, int nLast, int nWidth)
  399. {
  400. for (int i = nStart; i < nLast; i++)
  401. {
  402. CXTPControl* pControl = GetControl(i);
  403. if (!pControl || pControl->GetParent() != this || !pControl->IsVisible())
  404. continue;
  406. CRect rc = pControl->GetRect();
  407. pControl->SetRect(CRect(rc.left, rc.top, rc.left + nWidth, rc.bottom));
  408. }
  409. }
  411. CRect CXTPPopupBar::GetBorders()
  412. {
  413. if (m_barType == xtpBarTypeNormal)
  414. return m_rcBorders;
  416. return GetPaintManager()->GetCommandBarBorders(this);
  417. }
  419. CSize CXTPPopupBar::CalcDynamicLayout(int nLength, DWORD /*nMode*/)
  420. {
  421. m_bDynamicLayout = TRUE;
  423. CClientDC dc(this);
  424. CXTPFontDC font(&dc, GetPaintManager()->GetCommandBarFont(this));
  426. RECT rcWork;
  427. SystemParametersInfo(SPI_GETWORKAREA, NULL, &rcWork, 0);
  429. CRect rcBorders = GetBorders();
  430. CSize szTearOffGripper(0);
  431. if (m_bTearOffPopup)
  432. {
  433. szTearOffGripper = GetPaintManager()->DrawTearOffGripper(&dc, 0, FALSE, FALSE);
  434. rcBorders.top += szTearOffGripper.cy;
  435. }
  437. if (m_barType == xtpBarTypeNormal)
  438. {
  439. UpdateShortcuts();
  441. CSize sz = m_pControls->CalcDynamicSize(&dc, GetWidth(), LM_COMMIT | LM_HORZ | LM_POPUP, rcBorders);
  443. m_rcTearOffGripper.SetRect(rcBorders.left, rcBorders.top - szTearOffGripper.cy, sz.cx - rcBorders.right, rcBorders.top);
  444. m_rcResizeGripper.SetRectEmpty();
  446. m_bDynamicLayout = FALSE;
  448. return sz;
  449. }
  451. CXTPControl* pControlGallery = GetControls()->FindControl(xtpControlGallery, -1, TRUE, FALSE);
  453. m_bResizable = pControlGallery ? pControlGallery->IsCustomizeResizeAllow() : 0;
  454. CSize szResizeGripper(0);
  455. if (m_bResizable)
  456. {
  457. szResizeGripper.cy = m_bResizable != 2 ? 11 : 8;
  458. rcBorders.bottom += szResizeGripper.cy;
  459. }
  461. if (nLength == 0)
  462. {
  463. for (int i = 0; i < GetControlCount(); i++)
  464. {
  465. CXTPControl* pControl = GetControl(i);
  466. if (!pControl || pControl->GetParent() != this)
  467. continue;
  469. pControl->OnCalcDynamicSize(0);
  470. }
  472. UpdateExpandingState();
  473. UpdateShortcuts();
  474. }
  477. CXTPControl* pButtonExpand = m_pControls->FindControl(XTP_ID_POPUPBAR_EXPAND);
  478. CSize szButtonExpand(0);
  479. if (m_bCollapsed)
  480. {
  481. szButtonExpand = GetPaintManager()->DrawSpecialControl(&dc, xtpButtonExpandMenu, NULL, this, FALSE, NULL);
  482. rcBorders.bottom += szButtonExpand.cy;
  484. if (!pButtonExpand)
  485. pButtonExpand = m_pControls->Add(new CControlExpandButton(), XTP_ID_POPUPBAR_EXPAND, _T(""), -1, TRUE);
  486. pButtonExpand->SetHideFlags(xtpHideGeneric);
  487. }
  488. else if (pButtonExpand) pButtonExpand->SetHideFlags(xtpHideGeneric);
  490. CSize sz = m_pControls->CalcPopupSize(&dc, nLength, GetWidth(), rcBorders);
  492. if (m_bCollapsed)
  493. {
  494. pButtonExpand->SetHideFlags(xtpNoHide);
  495. pButtonExpand->SetRect(CRect(rcBorders.left, sz.cy - rcBorders.bottom, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom + szButtonExpand.cy));
  496. }
  498. m_rcTearOffGripper.SetRect(rcBorders.left, rcBorders.top - szTearOffGripper.cy, sz.cx - rcBorders.right, rcBorders.top);
  499. m_rcResizeGripper.SetRect(rcBorders.left, sz.cy - rcBorders.bottom, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom + szResizeGripper.cy);
  501. m_bDynamicLayout = FALSE;
  503. return sz;
  504. }
  506. CRect CXTPPopupBar::CalculatePopupRect(CPoint ptPopup, CSize sz)
  507. {
  508. RECT rcWork = m_rcExclude.IsRectEmpty() ? XTPMultiMonitor()->GetWorkArea(ptPopup) : XTPMultiMonitor()->GetWorkArea(m_rcExclude);
  509. RECT rcScreen = m_rcExclude.IsRectEmpty() ? XTPMultiMonitor()->GetScreenArea(ptPopup) : XTPMultiMonitor()->GetScreenArea(m_rcExclude);
  511. // If point is on the screen, but not in the work area, then the point
  512. // must be inside an AppBar.
  513. if (m_rcExclude.IsRectEmpty() && PtInRect(&rcScreen, ptPopup) && !PtInRect(&rcWork, ptPopup))
  514. {
  515. rcWork = rcScreen;
  516. }
  518. if (!m_rcExclude.IsRectEmpty() && !CRect().IntersectRect(&rcWork, m_rcExclude) && CRect().IntersectRect(&rcScreen, m_rcExclude))
  519. {
  520. rcWork = rcScreen;
  521. }
  523. rcWork.bottom -= 5;  // for shadow
  525. CPoint ptCenterRect = m_rcExclude.CenterPoint();
  526. BOOL bScroll = FALSE, bWrap = FALSE;
  527. CXTPCommandBars* pCommandars = GetCommandBars();
  528. BOOL bNoScroll = (pCommandars ? pCommandars->GetCommandBarsOptions()->bWrapLargePopups : FALSE) || m_bMultiLine;
  530. if (m_rcExclude.Height() == 0 && (m_popupFlags & xtpPopupUp))
  531. ptPopup.y = ptPopup.y - sz.cy;
  533. if (m_rcExclude.Height() == 0 && ptPopup.y > rcWork.bottom)
  534. {
  535. ptPopup.y = ptPopup.y - sz.cy;
  536. }
  537. else if (ptPopup.y + sz.cy > rcWork.bottom)
  538. {
  539. if (m_rcExclude.Height() == 0)
  540. {
  541. ptPopup.y = (ptPopup.y < (rcWork.bottom - rcWork.top)/2 ? rcWork.bottom : ptPopup.y)- sz.cy;
  542. }
  543. else
  544. {
  545. if (m_popupFlags & xtpPopupDown)
  546. {
  547. ptPopup.y = m_rcExclude.top - sz.cy;
  549. if (ptPopup.y < rcWork.top)
  550. {
  551. if (bNoScroll)
  552. {
  553. m_popupFlags &= ~xtpPopupDown;
  554. if (m_pControlPopup && (m_pControlPopup->GetType() != xtpControlComboBox || GetParentCommandBar()->GetType() == xtpBarTypePopup))
  555. {
  556. m_rcExclude = m_pControlPopup->GetRect();
  558. AdjustExcludeRect(m_rcExclude, TRUE);
  559. GetParentCommandBar()->ClientToScreen(m_rcExclude);
  560. }
  562. if (m_popupFlags & xtpPopupLeft)
  563. {
  564. ptPopup.y = rcWork.bottom - sz.cy;
  565. }
  566. else
  567. {
  568. ptPopup.x = m_rcExclude.right;
  569. ptPopup.y = rcWork.bottom - sz.cy;
  570. }
  571. }
  572. else
  573. {
  574. bScroll = TRUE;
  575. if (ptCenterRect.y > (rcWork.bottom - rcWork.top)/2)
  576. {
  577. ptPopup.y = rcWork.top;
  578. sz.cy = m_rcExclude.top - rcWork.top;
  579. }
  580. else
  581. {
  582. ptPopup.y = m_rcExclude.bottom;
  583. sz.cy = rcWork.bottom - ptPopup.y;
  584. }
  585. }
  586. }
  587. }
  588. else
  589. {
  590. ptPopup.y = rcWork.bottom - sz.cy;
  591. }
  592. }
  594. if (ptPopup.y < rcWork.top) ptPopup.y = rcWork.top;
  596. if (ptPopup.y + sz.cy > rcWork.bottom && ptPopup.y == rcWork.top)
  597. {
  598. if (bNoScroll)
  599. {
  600. bWrap = TRUE;
  601. }
  602. else
  603. {
  604. sz.cy = rcWork.bottom - ptPopup.y;
  605. bScroll = TRUE;
  606. }
  607. }
  608. }
  610. if (bWrap && !m_bMultiLine && (GetType() == xtpBarTypePopup))
  611. {
  612. sz = CalcDynamicLayout(rcWork.bottom - rcWork.top, 0);
  613. }
  615. if (m_popupFlags == (xtpPopupLeft | xtpPopupDown) && m_rcExclude.Width() != 0)
  616. ptPopup.x = m_rcExclude.right - sz.cx;
  617. else if (m_popupFlags & xtpPopupLeft && m_rcExclude.Width() != 0)
  618. ptPopup.x = m_rcExclude.left - sz.cx;
  619. else if ((m_popupFlags & xtpPopupLeft) && m_rcExclude.Width() == 0)
  620. ptPopup.x -= sz.cx;
  622. if (ptPopup.x + sz.cx > rcWork.right)
  623. {
  624. if (m_rcExclude.Width() == 0 && ptPopup.x > rcWork.right)
  625. ptPopup.x = ptPopup.x - sz.cx;
  626. else if (m_rcExclude.Width() == 0)
  627. ptPopup.x = rcWork.right - sz.cx;
  628. else
  629. {
  630. ptPopup.x = (m_popupFlags & xtpPopupDown ? rcWork.right : m_rcExclude.left) - sz.cx ;
  631. m_popupFlags |= xtpPopupLeft;
  632. }
  633. if (ptPopup.x < rcWork.left)
  634. ptPopup.x = rcWork.left;
  635. }
  636. else if (ptPopup.x < rcWork.left)
  637. {
  638. if (m_rcExclude.Width() != 0)
  639. {
  640. ptPopup.x = m_popupFlags & xtpPopupDown ? rcWork.left : m_rcExclude.right;
  641. m_popupFlags &= ~xtpPopupLeft;
  642. }
  643. else if (m_popupFlags & xtpPopupLeft)
  644. {
  645. ptPopup.x = rcWork.left;
  646. m_popupFlags &= ~xtpPopupLeft;
  647. }
  648. }
  650. m_scrollInfo.bScroll = bScroll && (GetType() == xtpBarTypePopup && GetPosition() == xtpBarPopup);
  651. if (m_scrollInfo.bScroll)
  652. {
  653. m_scrollInfo.nScrollFirst = 0;
  654. AdjustScrolling(&sz);
  655. }
  657. return CRect(ptPopup, sz);
  658. }
  660. void CXTPPopupBar::UpdateLocation(CSize sz)
  661. {
  662. CRect rc = CalculatePopupRect(m_ptPopup, sz);
  663. SetWindowPos(&CWnd::wndTopMost, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_SHOWWINDOW | (IsWindowVisible() ? SWP_NOZORDER : 0));
  664. }
  666. void CXTPPopupBar::AdjustScrolling(LPSIZE lpSize, BOOL bDown, BOOL bInvalidate)
  667. {
  668. CSize sz = lpSize ? *lpSize : CXTPWindowRect(this).Size();
  670. m_scrollInfo.btnDown.m_rc.SetRectEmpty();
  671. m_scrollInfo.btnUp.m_rc.SetRectEmpty();
  672. int nCount = GetControlCount();
  673. CRect rcBorders = GetBorders();
  675. int nSeparator = GetPaintManager()->DrawCommandBarSeparator(NULL, this, NULL, FALSE).cy;
  677. CSize szTearOffGripper(0);
  678. if (m_bTearOffPopup)
  679. {
  680. szTearOffGripper = GetPaintManager()->DrawTearOffGripper(NULL, 0, FALSE, FALSE);
  681. rcBorders.top += szTearOffGripper.cy;
  682. }
  683. if (m_bResizable)
  684. {
  685. rcBorders.bottom += m_rcResizeGripper.Height();
  686. }
  688. CXTPControl* pButtonExpand = m_pControls->FindControl(XTP_ID_POPUPBAR_EXPAND);
  689. CSize szButtonExpand(0);
  691. if (m_bCollapsed)
  692. {
  693. szButtonExpand = GetPaintManager()->DrawSpecialControl(NULL, xtpButtonExpandMenu, NULL, this, FALSE, NULL);
  694. rcBorders.bottom += szButtonExpand.cy;
  696. if (!pButtonExpand)
  697. pButtonExpand = m_pControls->Add(new CControlExpandButton(), XTP_ID_POPUPBAR_EXPAND, _T(""), -1, TRUE);
  698. pButtonExpand->SetHideFlags(xtpHideGeneric);
  699. }
  700. else if (pButtonExpand) pButtonExpand->SetHideFlags(xtpHideGeneric);
  703. int nScrollHeight = 16;
  704. int i;
  706. if (!bDown)
  707. {
  708. if (m_scrollInfo.nScrollFirst == 1)
  709. m_scrollInfo.nScrollFirst = 0;
  711. int nPos = rcBorders.top;
  712. if (m_scrollInfo.nScrollFirst != 0)
  713. {
  714. nPos += nScrollHeight;
  715. m_scrollInfo.btnDown.m_rc.SetRect(rcBorders.left, rcBorders.top, sz.cx - rcBorders.right, nPos);
  716. }
  718. ASSERT(m_scrollInfo.nScrollFirst < nCount && m_scrollInfo.nScrollFirst >= 0);
  720. BOOL bFirst = TRUE;
  721. for (i = m_scrollInfo.nScrollFirst; i < nCount ; i++)
  722. {
  723. CXTPControl* pControl = GetControl(i);
  724. pControl->SetHideFlag(xtpHideScroll, FALSE);
  726. if (!pControl->IsVisible())
  727. continue;
  729. int nItemHeight = pControl->GetRect().Height();
  730. if (pControl->GetBeginGroup()) nPos += nSeparator;
  732. if (sz.cy - (nPos + nItemHeight) < nScrollHeight + rcBorders.bottom)
  733. {
  734. if (!bFirst)
  735. break;
  736. else
  737. nItemHeight = sz.cy - rcBorders.bottom - rcBorders.top;
  738. }
  740. bFirst = FALSE;
  741. pControl->SetRect(CRect(rcBorders.left, nPos, sz.cx - rcBorders.right, nPos + nItemHeight));
  743. nPos += nItemHeight;
  744. }
  745. for (int j = i; j < nCount; j++)
  746. {
  747. GetControl(j)->SetHideFlag(xtpHideScroll, TRUE);
  748. }
  750. m_scrollInfo.nScrollLast = i;
  752. if (i != nCount)
  753. {
  754. m_scrollInfo.btnUp.m_rc.SetRect(rcBorders.left, sz.cy - rcBorders.bottom - nScrollHeight, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom);
  755. }
  756. }
  757. else
  758. {
  759. if (m_scrollInfo.nScrollLast == nCount - 1)
  760. m_scrollInfo.nScrollLast = nCount;
  762. int nPos = sz.cy - rcBorders.bottom;
  763. if (m_scrollInfo.nScrollLast != nCount)
  764. {
  765. nPos -= nScrollHeight;
  766. m_scrollInfo.btnUp.m_rc.SetRect(rcBorders.left, sz.cy - rcBorders.bottom - nScrollHeight, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom);
  767. }
  769. ASSERT(m_scrollInfo.nScrollLast <= nCount && m_scrollInfo.nScrollLast > 0);
  771. for (i = m_scrollInfo.nScrollLast - 1 ; i >= 0 ; i--)
  772. {
  773. CXTPControl* pControl = GetControl(i);
  774. pControl->SetHideFlag(xtpHideScroll, FALSE);
  776. if (!pControl->IsVisible())
  777. continue;
  779. int nItemHeight = pControl->GetRect().Height();
  781. if (nPos - nItemHeight < nScrollHeight)
  782. {
  783. break;
  784. }
  785. pControl->SetRect(CRect(rcBorders.left, nPos - nItemHeight, sz.cx - rcBorders.right, nPos));
  787. nPos -= nItemHeight;
  788. if (pControl->GetBeginGroup()) nPos -= nSeparator;
  789. }
  791. for (int j = i; j >= 0; j--)
  792. {
  793. GetControl(j)->SetHideFlag(xtpHideScroll, TRUE);
  794. }
  796. m_scrollInfo.nScrollFirst = i + 1;
  798. if (i != -1)
  799. {
  800. m_scrollInfo.btnDown.m_rc.SetRect(rcBorders.left, rcBorders.top, sz.cx - rcBorders.right, rcBorders.top + nScrollHeight);
  801. }
  802. }
  803. if (m_bCollapsed)
  804. {
  805. pButtonExpand->SetHideFlags(xtpNoHide);
  806. pButtonExpand->SetRect(CRect(rcBorders.left, sz.cy - rcBorders.bottom, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom +  szButtonExpand.cy));
  807. }
  808. m_rcTearOffGripper.SetRect(rcBorders.left, rcBorders.top - szTearOffGripper.cy, sz.cx - rcBorders.right, rcBorders.top);
  809. if (m_bResizable) m_rcResizeGripper.SetRect(rcBorders.left, sz.cy - rcBorders.bottom, sz.cx - rcBorders.right, sz.cy - rcBorders.bottom + m_rcResizeGripper.Height());
  811. if (bInvalidate) Redraw();
  812. }
  814. void CXTPCommandBar::UpdateShortcuts()
  815. {
  816. CXTPCommandBars* pCommandBars = GetCommandBars();
  817. if (!pCommandBars)
  818. return;
  820. if (!pCommandBars->GetCommandBarsOptions()->bAutoUpdateShortcuts)
  821. return;
  823. for (int i = 0; i < GetControlCount(); i++)
  824. {
  825. CXTPControl* pControl = GetControl(i);
  826. if (!pControl || pControl->GetParent() != this || !pControl->IsVisible())
  827. continue;
  829. CString strShortcut;
  830. if (pControl->GetID() != 0)
  831. {
  832. pCommandBars->GetShortcutManager()->FindDefaultAccelerator(pControl->GetID(), strShortcut);
  833. pControl->m_strShortcutTextAuto = strShortcut;
  834. }
  835. }
  836. }
  838. void CXTPPopupBar::AdjustExcludeRect(CRect& rc, BOOL bVertical)
  839. {
  840. m_pControlPopup->AdjustExcludeRect(rc, bVertical);
  841. }
  843. AFX_INLINE BOOL IsVerticalPosition(CXTPCommandBar* pCommandBar)
  844. {
  845. return IsVerticalPosition(pCommandBar->GetPosition()) ||
  846. (pCommandBar->GetType() == xtpBarTypePopup && pCommandBar->GetPosition() == xtpBarFloating);
  847. }
  849. void CXTPPopupBar::UpdateFlags()
  850. {
  851. if (m_pControlPopup)
  852. {
  853. BOOL bLayoutRTL = IsLayoutRTL();
  856. CXTPCommandBar* pParent = GetParentCommandBar();
  857. ASSERT(pParent);
  858. if (!pParent)
  859. return;
  861. m_popupFlags = xtpPopupRight;
  863. if (m_pControlPopup->m_dwFlags & xtpFlagLeftPopup || bLayoutRTL) m_popupFlags |= xtpPopupLeft;
  865. if (pParent->GetFlags() & xtpFlagSmartLayout && pParent->GetPosition() == xtpBarPopup)
  866. {
  867. m_popupFlags |= xtpPopupDown;
  868. }
  869. else if (!IsVerticalPosition(pParent))
  870. {
  871. m_popupFlags |= xtpPopupDown;
  872. }
  873. else
  874. {
  875. if (pParent->GetPosition() == xtpBarRight || (pParent->GetType() == xtpBarTypePopup &&
  876. pParent->IsPopupBar() && ((CXTPPopupBar*)pParent)->m_popupFlags & xtpPopupLeft))
  877. m_popupFlags = xtpPopupLeft;
  878. }
  880. m_rcExclude = m_pControlPopup->GetRect();
  882. if (m_pControlPopup->GetType() == xtpControlComboBox && pParent->GetType() != xtpBarTypePopup)
  883. {
  884. m_popupFlags |= xtpPopupDown;
  885. }
  886. else AdjustExcludeRect(m_rcExclude, IsVerticalPosition(pParent));
  888. pParent->ClientToScreen(m_rcExclude);
  890. m_ptPopup.x = (m_popupFlags & xtpPopupDown) ? m_rcExclude.left : m_rcExclude.right;
  891. m_ptPopup.y = (m_popupFlags & xtpPopupDown) ? m_rcExclude.bottom : m_rcExclude.top;
  892. }
  893. }
  896. void CXTPPopupBar::UpdateExpandingState()
  897. {
  898. CXTPCommandBars* pCommandBars = GetCommandBars();
  899. if (!pCommandBars)
  900. return;
  902. int i;
  904. if (pCommandBars->GetCommandBarsOptions()->bAlwaysShowFullMenus)
  905. {
  906. for (i = 0; i < GetControlCount(); i++)
  907. {
  908. CXTPControl* pControl = GetControl(i);
  909. if (!pControl || pControl->GetParent() != this)
  910. continue;
  912. pControl->SetExpanded(FALSE);
  913. }
  914. m_bExpanded = TRUE;
  915. return;
  916. }
  918. m_bCollapsed = FALSE;
  920. BOOL bCollapsedExists = FALSE;
  921. for (i = 0; i < GetControlCount(); i++)
  922. {
  923. CXTPControl* pControl = GetControl(i);
  924. if (!pControl || pControl->GetParent() != this)
  925. continue;
  927. BOOL bVisible = pControl->IsVisible(xtpHideExpand | xtpHideScroll);
  929. if (pCommandBars->IsControlHidden(pControl))
  930. {
  931. pControl->SetExpanded(bVisible);
  932. }
  933. else
  934. {
  935. pControl->SetExpanded(FALSE);
  937. if (pControl->GetID() != XTP_ID_POPUPBAR_EXPAND && bVisible)
  938. bCollapsedExists = TRUE;
  939. }
  940. }
  942. for (i = 0; i < GetControlCount(); i++)
  943. {
  944. CXTPControl* pControl = GetControl(i);
  945. if (!pControl || pControl->GetParent() != this)
  946. continue;
  948. pControl->SetHideFlag(xtpHideExpand, FALSE);
  950. if (pControl->GetExpanded())
  951. {
  952. if (!m_bExpanded && bCollapsedExists)
  953. {
  954. pControl->SetHideFlag(xtpHideExpand, TRUE);
  955. m_bCollapsed = TRUE;
  956. }
  957. }
  958. }
  959. }
  961. void CXTPPopupBar::Animate()
  962. {
  963. CXTPCommandBar* pParentCommandBar = GetParentCommandBar();
  965. BOOL bAnimate = pParentCommandBar ? pParentCommandBar->m_bAnimatePopup : TRUE;
  967. if (bAnimate)
  968. {
  969. if (IsCustomizeMode() || GetWindow(GW_CHILD))
  970. bAnimate = FALSE;
  971. }
  973. BOOL bRegionChanged = FALSE;
  976. if (bAnimate)
  977. {
  978. XTPAnimationType animationType = GetAnimationType();
  979. if (IsAnimateType(animationType))
  980. {
  982. if (m_pControlPopup)
  983. {
  984. m_pControlPopup->RedrawParent();
  985. m_pControlPopup->GetParent()->UpdateWindow();
  986. }
  988. GetSite()->UpdateWindow();
  990. CClientDC paintDC(this);
  991. CXTPClientRect rcClient(this);
  992. CXTPWindowRect rcWindow(this);
  994. CXTPBufferDC animationDC(paintDC, rcClient);
  995. DrawCommandBar(&animationDC, rcClient);
  997. CDC* pDC = GetDesktopWindow()->GetDC();
  999. BOOL dwLayout = CXTPDrawHelpers::IsContextRTL(&paintDC);
  1000. CXTPDrawHelpers::SetContextRTL(&paintDC, FALSE);
  1001. paintDC.BitBlt(0, 0, rcClient.Width(), rcClient.Height(), pDC, rcWindow.left, rcWindow.top, SRCCOPY);
  1002. GetDesktopWindow()->ReleaseDC(pDC);
  1003. CXTPDrawHelpers::SetContextRTL(&paintDC, dwLayout);
  1005. GetPaintManager()->SetCommandBarRegion(this);
  1006. bRegionChanged = TRUE;
  1007. // Animation
  1008. GetPaintManager()->Animate(&paintDC, &animationDC, rcClient, animationType);
  1009. }
  1010. }
  1012. if (pParentCommandBar) pParentCommandBar->m_bAnimatePopup = FALSE;
  1013. if (!bRegionChanged) GetPaintManager()->SetCommandBarRegion(this);
  1015. }
  1019. BOOL CXTPPopupBar::Popup(CXTPControlPopup* pControlPopup, BOOL bSelectFirst)
  1020. {
  1021. m_pControlPopup = pControlPopup;
  1023. if (!Create())
  1024. return FALSE;
  1026. if (m_pToolTipContext)
  1027. {
  1028. m_pToolTipContext->CancelToolTips();
  1029. }
  1031. LockRedraw();
  1033. CWnd* pWndOwner = GetOwnerSite();
  1034. if (pWndOwner) pWndOwner->SendMessage(WM_XTP_INITCOMMANDSPOPUP, 0, (LPARAM)this);
  1036. m_bTearOffSelected = FALSE;
  1038. m_bCollapsed = FALSE;
  1039. m_bExpanded = IsCustomizeMode() || XTPMouseManager()->IsForceExpanded();
  1041. UpdateFlags();
  1043. UpdateLocation(CalcDynamicLayout(0, 0));
  1045. if (!m_hWnd)
  1046. {
  1047. UnlockRedraw();
  1048. return FALSE;
  1049. }
  1051. if (m_pControlPopup && m_pControlPopup->m_pParent->GetSafeHwnd() == NULL)
  1052. {
  1053. UnlockRedraw();
  1054. DestroyWindow();
  1055. return FALSE;
  1056. }
  1058. SetTrackingMode(TRUE, bSelectFirst, bSelectFirst);
  1060. m_nIdleFlags &= ~xtpIdleLayout;
  1061. OnIdleUpdateCmdUI(TRUE, 0L);
  1063. if (!m_hWnd)
  1064. {
  1065. UnlockRedraw();
  1066. return FALSE;
  1067. }
  1069. Animate();
  1070. XTPSoundManager()->PlaySystemSound(xtpSoundMenuPopup);
  1072. CXTPPaintManager* pPaintManager = GetPaintManager();
  1074. if (pPaintManager && m_barPosition == xtpBarPopup && m_bShowShadow && pPaintManager->m_bShowShadow && !IsCustomizeMode())
  1075. {
  1076. pPaintManager->GetShadowManager()->RemoveShadow(this);
  1077. pPaintManager->GetShadowManager()->SetShadow(this, m_rcExclude);
  1078. }
  1080. m_nIdleFlags |= xtpIdleLayout;
  1081. UnlockRedraw();
  1083. return TRUE;
  1084. }
  1086. BOOL CXTPPopupBar::Popup(int x, int y, LPCRECT rcExclude)
  1087. {
  1088. m_ptPopup = CPoint(x, y);
  1089. if (rcExclude) m_rcExclude = *rcExclude;
  1090. return Popup(NULL);
  1091. }
  1093. BEGIN_MESSAGE_MAP(CXTPPopupBar, CXTPCommandBar)
  1094. ON_WM_MOUSEMOVE()
  1095. ON_WM_MOUSEACTIVATE()
  1096. ON_WM_LBUTTONDOWN()
  1097. ON_WM_SETCURSOR()
  1098. ON_WM_TIMER()
  1099. ON_WM_NCACTIVATE()
  1100. ON_WM_NCCREATE()
  1101. ON_MESSAGE(WM_FLOATSTATUS, OnFloatStatus)
  1102. END_MESSAGE_MAP()
  1104. void CXTPPopupBar::SwitchTearOffTracking(BOOL bShow, CPoint point)
  1105. {
  1106. CXTPCommandBars* pCommandBars = GetCommandBars();
  1107. ASSERT(pCommandBars);
  1108. if (!pCommandBars)
  1109. return;
  1111. ShowWindow(bShow ? SW_SHOWNA : SW_HIDE);
  1113. if (!bShow)
  1114. {
  1115. if (m_pTearOffBar == NULL)
  1116. {
  1117. m_pTearOffBar = pCommandBars->GetToolBar(m_nTearOffID);
  1118. if (m_pTearOffBar != NULL)
  1119. {
  1120. m_pTearOffBar->SetPosition(xtpBarFloating);
  1121. m_pTearOffBar->SetVisible(TRUE);
  1122. pCommandBars->RecalcFrameLayout();
  1123. }
  1124. }
  1125. if (m_pTearOffBar == NULL)
  1126. {
  1128. m_pTearOffBar = pCommandBars->AddCustomBar(m_strTearOffCaption, m_nTearOffID, TRUE);
  1129. m_pTearOffBar->m_nMRUWidth = m_nTearOffWidth;
  1131. for (int i = 0; i < GetControlCount(); i++)
  1132. {
  1133. CXTPControl* pControl = GetControl(i);
  1134. if (!pControl || pControl->GetParent() != this)
  1135. continue;
  1137. if (pControl->GetID() != XTP_ID_POPUPBAR_EXPAND)
  1138. {
  1139. CXTPControl* pControlClone = m_pTearOffBar->GetControls()->AddClone(pControl);
  1140. pControlClone->SetHideFlags(pControlClone->GetHideFlags() & ~(xtpHideScroll | xtpHideExpand));
  1141. }
  1142. }
  1144. }
  1145. ASSERT(m_pTearOffBar);
  1147. pCommandBars->GetSite()->SendMessage(WM_XTP_TEAROFFDONE, (WPARAM)m_pTearOffBar, (LPARAM)this);
  1149. m_szTearOffBar = m_pTearOffBar->CalcDynamicLayout(-1, LM_MRUWIDTH | LM_HORZ | LM_COMMIT);
  1150. CPoint pt(point.x - m_szTearOffBar.cx / 2, point.y - 10);
  1151. m_pTearOffBar->MoveWindow(pt.x, pt.y, m_szTearOffBar.cx, m_szTearOffBar.cy);
  1152. m_pTearOffBar->OnInitialUpdate();
  1153. m_pTearOffBar->Redraw();
  1156. }
  1157. else
  1158. {
  1159. if (m_pTearOffBar)
  1160. {
  1161. m_pTearOffBar->SetVisible(FALSE);
  1162. m_pTearOffBar = 0;
  1163. }
  1165. }
  1166. }
  1168. void CXTPPopupBar::TrackResize()
  1169. {
  1170. // don't handle if capture already set
  1171. if (::GetCapture() != NULL)
  1172. return;
  1174. BOOL bLayoutRTL = IsLayoutRTL();
  1176. CXTPControl* pControl = GetControls()->FindControl(xtpControlGallery, -1, TRUE, FALSE);
  1177. if (!pControl)
  1178. return;
  1179. CSize szControl(pControl->GetWidth(), pControl->GetRect().Height());
  1180. CSize szControlInit = szControl;
  1181. CSize szControlMin(pControl->GetCustomizeMinWidth(), pControl->GetCustomizeMinHeight());
  1183. SetPopuped(-1);
  1184. SetSelected(-1);
  1186. BOOL bResizeWidth = m_bResizable & 1;
  1187. BOOL bResizeHeight = m_bResizable & 2;
  1189. // set capture to the window which received this message
  1190. SetCapture();
  1191. ASSERT(m_hWnd == ::GetCapture());
  1193. CPoint pt(0, 0);
  1194. GetCursorPos(&pt);
  1196. // get messages until capture lost or cancelled/accepted
  1197. while (::GetCapture() == m_hWnd)
  1198. {
  1199. MSG msg;
  1201. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  1202. {
  1203. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  1204. break;
  1205. DispatchMessage(&msg);
  1206. }
  1208. if (!::GetMessage(&msg, NULL, 0, 0))
  1209. {
  1210. AfxPostQuitMessage((int)msg.wParam);
  1211. break;
  1212. }
  1214. if (msg.message == WM_LBUTTONUP)
  1215. break;
  1216. else if (msg.message == WM_MOUSEMOVE && pt != msg.pt)
  1217. {
  1218. if (bLayoutRTL)
  1219. szControl += CSize(pt.x - msg.pt.x, msg.pt.y - pt.y);
  1220. else
  1221. szControl += CSize(msg.pt.x - pt.x, msg.pt.y - pt.y);
  1223. if (bResizeWidth) pControl->SetWidth(max(szControl.cx, szControlMin.cx));
  1224. if (bResizeHeight) pControl->SetHeight(max(szControl.cy, szControlMin.cy));
  1225. RecalcSizeLayout();
  1227. pt = msg.pt;
  1228. }
  1229. else if (msg.message == WM_KEYDOWN)
  1230. {
  1231. if (msg.wParam == VK_ESCAPE)
  1232. {
  1233. if (bResizeWidth) pControl->SetWidth(szControlInit.cx);
  1234. if (bResizeHeight) pControl->SetHeight(szControlInit.cy);
  1235. RecalcSizeLayout();
  1236. break;
  1237. }
  1238. }
  1239. else
  1240. DispatchMessage(&msg);
  1242. }
  1244. ReleaseCapture();
  1245. }
  1247. void CXTPPopupBar::TrackTearOff()
  1248. {
  1249. m_pTearOffBar = NULL;
  1250. CRect rcGripper = m_rcTearOffGripper;
  1251. ClientToScreen(&rcGripper);
  1253. BOOL bShow = TRUE;
  1254. // don't handle if capture already set
  1255. if (::GetCapture() != NULL)
  1256. return;
  1258. // set capture to the window which received this message
  1259. SetCapture();
  1260. ASSERT(this == CWnd::GetCapture());
  1262. CPoint pt(0, 0);
  1263. // get messages until capture lost or cancelled/accepted
  1264. while (CWnd::GetCapture() == this)
  1265. {
  1266. MSG msg;
  1268. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  1269. {
  1270. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  1271. break;
  1272. DispatchMessage(&msg);
  1273. }
  1275. if (!::GetMessage(&msg, NULL, 0, 0))
  1276. {
  1277. AfxPostQuitMessage((int)msg.wParam);
  1278. break;
  1279. }
  1281. if (msg.message == WM_LBUTTONUP)
  1282. break;
  1283. else if (msg.message == WM_MOUSEMOVE && pt != msg.pt)
  1284. {
  1285. pt = msg.pt;
  1286. BOOL bState = !(pt.x > rcGripper.right + 10 || pt.x < rcGripper.left - 10 ||
  1287. pt.y > rcGripper.bottom + 10 || pt.y < rcGripper.top - 10);
  1288. if (bState != bShow)
  1289. {
  1290. bShow = bState;
  1291. SwitchTearOffTracking(bState, pt);
  1292. }
  1294. if (m_pTearOffBar != NULL)
  1295. {
  1296. CPoint point(pt.x - m_szTearOffBar.cx / 2, pt.y - 10);
  1297. m_pTearOffBar->MoveWindow(point.x, point.y, m_szTearOffBar.cx, m_szTearOffBar.cy);
  1299. }
  1301. }
  1302. else if (msg.message == WM_KEYDOWN)
  1303. {
  1304. if (msg.wParam == VK_ESCAPE)
  1305. {
  1306. break;
  1307. }
  1308. }
  1309. else
  1310. DispatchMessage(&msg);
  1312. }
  1314. ReleaseCapture();
  1315. if (m_pTearOffBar)
  1316. {
  1317. GetCommandBars()->ClosePopups();
  1318. }
  1319. }
  1321. BOOL CXTPPopupBar::_MouseInResizeGripper(const POINT& pt)
  1322. {
  1323. if (m_rcResizeGripper.PtInRect(pt))
  1324. {
  1325. if (m_bResizable == 2)
  1326. {
  1327. return TRUE;
  1328. }
  1330. CRect rcResizeGripper(m_rcResizeGripper);
  1331. rcResizeGripper.left = rcResizeGripper.right - rcResizeGripper.Height();
  1332. if (rcResizeGripper.PtInRect(pt))
  1333. {
  1334. return TRUE;
  1335. }
  1336. }
  1337. return FALSE;
  1338. }
  1340. BOOL CXTPPopupBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1341. {
  1342. if (m_bResizable)
  1343. {
  1344. POINT pt;
  1345. GetCursorPos(&pt);
  1346. ScreenToClient(&pt);
  1348. if (_MouseInResizeGripper(pt))
  1349. {
  1350. SetCursor(AfxGetApp()->LoadStandardCursor(m_bResizable == 2 ? IDC_SIZENS : IsLayoutRTL() ? IDC_SIZENESW : IDC_SIZENWSE));
  1351. return TRUE;
  1352. }
  1353. }
  1355. return CXTPCommandBar::OnSetCursor(pWnd, nHitTest, message);
  1356. }
  1358. void CXTPPopupBar::OnLButtonDown(UINT nFlags, CPoint point)
  1359. {
  1360. if (m_bTearOffPopup && m_rcTearOffGripper.PtInRect(point) && !IsCustomizeMode())
  1361. {
  1362. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
  1364. CXTPMouseManager* pMouseManager = XTPMouseManager();
  1366. pMouseManager->LockMouseMove();
  1367. m_bTearOffTracking = TRUE;
  1368. TrackTearOff();
  1369. m_bTearOffTracking = FALSE;
  1370. pMouseManager->UnlockMouseMove();
  1372. pMouseManager->RefreshCursor();
  1373. return;
  1374. }
  1376. if (m_bResizable && _MouseInResizeGripper(point))
  1377. {
  1378. CXTPMouseManager* pMouseManager = XTPMouseManager();
  1380. pMouseManager->LockMouseMove();
  1381. TrackResize();
  1382. pMouseManager->UnlockMouseMove();
  1384. pMouseManager->RefreshCursor();
  1385. return;
  1386. }
  1388. CXTPCommandBar::OnLButtonDown(nFlags, point);
  1389. }
  1391. BOOL CXTPPopupBar::DestroyWindow()
  1392. {
  1393. if (!GetSafeHwnd())
  1394. return CXTPCommandBar::DestroyWindow();
  1396. CWnd* pWnd = GetWindow(GW_CHILD);
  1397. if (!pWnd)
  1398. return CXTPCommandBar::DestroyWindow();
  1400. CWnd* pWndParent = GetSite();
  1402. while (pWnd)
  1403. {
  1404. CWnd* pWndNext = pWnd->GetWindow(GW_HWNDNEXT);
  1406. pWnd->ShowWindow(SW_HIDE);
  1407. pWnd->SetParent(pWndParent);
  1409. pWnd = pWndNext;
  1410. }
  1411. return CXTPCommandBar::DestroyWindow();
  1412. }
  1414. BOOL CXTPPopupBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  1415. {
  1416. if (!CXTPCommandBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard))
  1417. return FALSE;
  1419. CWnd* pWnd = GetSite();
  1421. if (!bMode)
  1422. {
  1423. AccessibleNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPEND, m_hWnd, OBJID_MENU, 0);
  1425. DestroyWindow();
  1427. CXTPCommandBar* pParentCommandBar = GetParentCommandBar();
  1428. if (pParentCommandBar)
  1429. pParentCommandBar->SetPopuped(-1);
  1431. if (pWnd && ::IsWindow(pWnd->m_hWnd)) pWnd->SendMessage(WM_XTP_UNINITCOMMANDSPOPUP, 0, (LPARAM)this);
  1433. Sleep(1);
  1435. m_pControlPopup = 0;
  1437. }
  1438. else
  1439. {
  1440. AccessibleNotifyWinEvent(EVENT_SYSTEM_MENUPOPUPSTART, m_hWnd, OBJID_MENU, 0);
  1441. }
  1442. if (pWnd && ::IsWindow(pWnd->m_hWnd)) pWnd->UpdateWindow();
  1444. return TRUE;
  1445. }
  1448. void CXTPPopupBar::OnMouseMove(UINT nFlags, CPoint point)
  1449. {
  1450. if (m_nLockRecurse > 0)
  1451. return;
  1453. if (GetParentCommandBar() != NULL && CXTPClientRect(this).PtInRect(point))
  1454. {
  1455. // restore selection
  1456. GetParentCommandBar()->SetSelected(m_pControlPopup->GetIndex());
  1457. }
  1459. if (m_scrollInfo.bScroll)
  1460. {
  1461. if (m_scrollInfo.btnUp.OnMouseMove(point) ||
  1462. m_scrollInfo.btnDown.OnMouseMove(point))
  1463. {
  1464. SetPopuped(-1);
  1465. }
  1466. }
  1468. if (m_bTearOffPopup && !IsCustomizeMode() && m_rcTearOffGripper.PtInRect(point) && !m_bTearOffSelected)
  1469. {
  1470. SetSelected(-1);
  1471. SetPopuped(-1);
  1472. m_nTearOffTimer = SetTimer(TID_TEAROFFSELECTED, 80, NULL);
  1473. }
  1475. CXTPCommandBar::OnMouseMove(nFlags, point);
  1476. }
  1478. CXTPCommandBar* CXTPPopupBar::GetParentCommandBar() const
  1479. {
  1480. return m_pControlPopup ? m_pControlPopup->GetParent() : NULL;
  1481. }
  1483. int CXTPPopupBar::OnMouseActivate(CWnd* /*pDesktopWnd*/, UINT /*nHitTest*/, UINT /*message*/)
  1484. {
  1485. return MA_NOACTIVATE;
  1486. }
  1488. BOOL CXTPPopupBar::OnNcActivate(BOOL bActive)
  1489. {
  1490. return bActive ? FALSE : CWnd::OnNcActivate(bActive);
  1491. }
  1493. BOOL CXTPPopupBar::OnNcCreate(LPCREATESTRUCT lpCreateStruct)
  1494. {
  1495. if (!CXTPCommandBar::OnNcCreate(lpCreateStruct))
  1496. return FALSE;
  1498. if (GetStyle() & MFS_SYNCACTIVE)
  1499. {
  1500. // syncronize activation state with top level parent
  1501. CWnd* pParentWnd = GetTopLevelParent();
  1502. ASSERT(pParentWnd != NULL);
  1503. if (!pParentWnd)
  1504. return FALSE;
  1506. CWnd* pActiveWnd = GetForegroundWindow();
  1507. BOOL bActive = (pParentWnd == pActiveWnd) ||
  1508. (pParentWnd->GetLastActivePopup() == pActiveWnd &&
  1509. pActiveWnd->SendMessage(WM_FLOATSTATUS, FS_SYNCACTIVE) != 0);
  1511. // the WM_FLOATSTATUS does the actual work
  1512. SendMessage(WM_FLOATSTATUS, bActive ? FS_ACTIVATE : FS_DEACTIVATE);
  1513. }
  1516. return TRUE;
  1517. }
  1520. LRESULT CXTPPopupBar::OnFloatStatus(WPARAM wParam, LPARAM)
  1521. {
  1522. // FS_SYNCACTIVE is used to detect MFS_SYNCACTIVE windows
  1523. LRESULT lResult = ((GetStyle() & MFS_SYNCACTIVE) && (wParam & FS_SYNCACTIVE));
  1524. return lResult;
  1525. }
  1529. void CXTPPopupBar::DrawCommandBar(CDC* pDC, CRect rcClipBox)
  1530. {
  1531. CXTPCommandBar::DrawCommandBar(pDC, rcClipBox);
  1533. if (m_scrollInfo.bScroll)
  1534. {
  1535. if (!m_scrollInfo.btnUp.m_rc.IsRectEmpty())
  1536. {
  1537. CPoint pt = m_scrollInfo.btnUp.m_rc.CenterPoint();
  1538. GetPaintManager()->Triangle(pDC, CPoint(pt.x - 3, pt.y), CPoint(pt.x + 3, pt.y), CPoint(pt.x, pt.y + 3), GetXtremeColor(COLOR_BTNTEXT));
  1539. }
  1540. if (!m_scrollInfo.btnDown.m_rc.IsRectEmpty())
  1541. {
  1542. CPoint pt = m_scrollInfo.btnDown.m_rc.CenterPoint();
  1543. GetPaintManager()->Triangle(pDC, CPoint(pt.x - 3, pt.y), CPoint(pt.x + 3, pt.y), CPoint(pt.x, pt.y - 3), GetXtremeColor(COLOR_BTNTEXT));
  1544. }
  1545. }
  1547. if (m_bTearOffPopup && GetControlCount() > 0)
  1548. {
  1549. GetPaintManager()->DrawTearOffGripper(pDC, m_rcTearOffGripper, m_bTearOffSelected, TRUE);
  1550. }
  1552. if (!m_rcResizeGripper.IsRectEmpty() && m_bResizable)
  1553. {
  1554. GetPaintManager()->DrawPopupResizeGripper(pDC, m_rcResizeGripper, m_bResizable);
  1555. }
  1556. }
  1559. BOOL CXTPPopupBar::SetSelected(int nSelected, BOOL bKeyboard)
  1560. {
  1561. if (!CXTPCommandBar::SetSelected(nSelected, bKeyboard))
  1562. return FALSE;
  1564. if (m_nSelected != -1 && !bKeyboard && (GetControl(m_nSelected)->GetID() == XTP_ID_POPUPBAR_EXPAND))
  1565. {
  1566. CXTPCommandBars* pCommandBars = GetCommandBars();
  1567. ASSERT(pCommandBars);
  1569. if (pCommandBars->GetCommandBarsOptions()->bShowFullAfterDelay)
  1570. {
  1571. SetTimer(TID_EXPANDHOVER, s_nExpandHoverDelay, NULL);
  1572. }
  1573. }
  1574. else
  1575. {
  1576. KillTimer(TID_EXPANDHOVER);
  1578. }
  1580. if (m_scrollInfo.bScroll && m_nSelected != -1)
  1581. {
  1582. if (GetControl(m_nSelected)->GetHideFlags() & xtpHideScroll)
  1583. {
  1584. if (m_nSelected >= m_scrollInfo.nScrollLast)
  1585. {
  1586. m_scrollInfo.nScrollLast = m_nSelected + 1;
  1587. AdjustScrolling(NULL, TRUE, TRUE);
  1588. }
  1589. else
  1590. {
  1591. m_scrollInfo.nScrollFirst = m_nSelected;
  1592. AdjustScrolling(NULL, FALSE, TRUE);
  1593. }
  1594. }
  1595. }
  1597. return TRUE;
  1598. }
  1600. void CXTPPopupBar::OnTimer(UINT_PTR nIDEvent)
  1601. {
  1602. int nCount = GetControlCount();
  1604. switch (nIDEvent)
  1605. {
  1606. case TID_HOVERUP:
  1607. if (m_scrollInfo.nScrollLast == nCount)
  1608. {
  1609. m_scrollInfo.btnUp.KillTimer();
  1610. return;
  1611. }
  1612. m_scrollInfo.nScrollLast++;
  1613. AdjustScrolling(NULL, TRUE, TRUE);
  1615. break;
  1617. case TID_HOVERDOWN:
  1618. if (m_scrollInfo.nScrollFirst == 0)
  1619. {
  1620. m_scrollInfo.btnDown.KillTimer() ;
  1621. return;
  1622. }
  1623. m_scrollInfo.nScrollFirst--;
  1624. AdjustScrolling(NULL, FALSE, TRUE);
  1625. break;
  1627. case TID_TEAROFFSELECTED:
  1628. {
  1629. CPoint pt;
  1630. GetCursorPos(&pt);
  1631. ScreenToClient(&pt);
  1632. if (!m_bTearOffSelected && m_rcTearOffGripper.PtInRect(pt))
  1633. {
  1634. m_bTearOffSelected = TRUE;
  1635. Redraw();
  1636. }
  1637. if (m_bTearOffSelected && !m_rcTearOffGripper.PtInRect(pt) && !m_bTearOffTracking)
  1638. {
  1639. m_bTearOffSelected = FALSE;
  1640. Redraw();
  1641. KillTimer(m_nTearOffTimer);
  1642. }
  1643. }
  1644. break;
  1646. case TID_EXPANDHOVER:
  1647. if (m_nSelected != -1 && GetControl(m_nSelected)->GetID() == XTP_ID_POPUPBAR_EXPAND)
  1648. {
  1649. GetControl(m_nSelected)->OnExecute();
  1650. }
  1652. KillTimer(TID_EXPANDHOVER);
  1653. break;
  1654. }
  1656. CXTPCommandBar::OnTimer(nIDEvent);
  1657. }
  1659. BOOL CXTPPopupBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  1660. {
  1661. if (m_bCollapsed)
  1662. {
  1663. if (nChar == VK_DOWN)
  1664. {
  1665. if (GetKeyState(VK_CONTROL) < 0 || m_pControls->GetNext(m_nSelected, +1) <= m_nSelected)
  1666. {
  1667. ExpandBar();
  1668. }
  1669. }
  1670. }
  1671. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1672. }
  1674. void CXTPPopupBar::SetDefaultItem(UINT uItem, BOOL fByPos)
  1675. {
  1676. CXTPControl* pControl = fByPos ? m_pControls->GetAt(uItem) : m_pControls->FindControl(xtpControlError, uItem, TRUE, FALSE);
  1677. if (pControl)
  1678. {
  1679. pControl->SetItemDefault(TRUE);
  1680. }
  1681. }
  1683. UINT CXTPPopupBar::GetDefaultItem(UINT /*gmdiFlags*/, BOOL fByPos)
  1684. {
  1685. for (int i = 0; i < GetControlCount(); i++)
  1686. {
  1687. CXTPControl* pControl = GetControl(i);
  1688. if (!pControl || pControl->GetParent() != this || !pControl->IsVisible())
  1689. continue;
  1691. if (pControl->IsItemDefault())
  1692. {
  1693. return fByPos ? pControl->GetIndex() : pControl->GetID();
  1694. }
  1695. }
  1696. return (UINT)-1;
  1697. }
  1699. void CXTPPopupBar::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive)
  1700. {
  1701. ASSERT_KINDOF(CXTPPopupBar, pCommandBar);
  1703. CXTPCommandBar::Copy(pCommandBar, bRecursive);
  1705. m_bTearOffPopup = ((CXTPPopupBar*)pCommandBar)->m_bTearOffPopup;
  1706. m_strTearOffCaption = ((CXTPPopupBar*)pCommandBar)->m_strTearOffCaption;
  1707. m_nTearOffID = ((CXTPPopupBar*)pCommandBar)->m_nTearOffID;
  1708. m_nTearOffWidth = ((CXTPPopupBar*)pCommandBar)->m_nTearOffWidth;
  1710. m_bShowShadow = ((CXTPPopupBar*)pCommandBar)->m_bShowShadow;
  1711. m_rcBorders = ((CXTPPopupBar*)pCommandBar)->m_rcBorders;
  1712. m_bContextMenu = ((CXTPPopupBar*)pCommandBar)->m_bContextMenu;
  1713. }
  1715. void CXTPPopupBar::SetPopupToolBar(BOOL bToolBarType)
  1716. {
  1717. m_barType = bToolBarType ? xtpBarTypeNormal : xtpBarTypePopup;
  1718. }
  1720. ////////////////////////////////////////////////////////////////////////////
  1721. //
  1723. IMPLEMENT_XTP_COMMANDBAR(CXTPPopupToolBar, CXTPPopupBar)
  1725. CXTPPopupToolBar::CXTPPopupToolBar()
  1726. {
  1727. m_barType = xtpBarTypeNormal;
  1728. }
  1730. CSize CXTPPopupToolBar::CalcDynamicLayout(int, DWORD /*nMode*/)
  1731. {
  1732. return CXTPPopupBar::CalcDynamicLayout(0, 0);
  1733. }
  1735. CXTPPopupToolBar* CXTPPopupToolBar::CreatePopupToolBar(CXTPCommandBars* pCommandBars)
  1736. {
  1737. CXTPPopupToolBar* pPopupBar = (CXTPPopupToolBar*)CXTPCommandBars::m_pPopupToolBarClass->CreateObject();
  1738. pPopupBar->SetCommandBars(pCommandBars);
  1739. return pPopupBar;
  1740. }