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

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

对话框与窗口

开发平台：

Visual C++

XTPCommandBar.cpp：源码内容
  1. // XTPCommandBar.cpp : implementation of the CXTPCommandBar 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/XTPDrawHelpers.h"
  25. #include "Common/XTPImageManager.h"
  26. #include "Common/XTPToolTipContext.h"
  28. #include "XTPCommandBar.h"
  29. #include "XTPControls.h"
  30. #include "XTPControl.h"
  31. #include "XTPMouseManager.h"
  32. #include "XTPKeyboardManager.h"
  33. #include "XTPPopupBar.h"
  34. #include "XTPControlPopup.h"
  35. #include "XTPPaintManager.h"
  36. #include "XTPShortcutManager.h"
  37. #include "XTPCustomizeTools.h"
  38. #include "XTPToolBar.h"
  39. #include "XTPCommandBars.h"
  40. #include "XTPCustomizeSheet.h"
  41. #include "XTPCommandBarAnimation.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. #ifndef CBRS_GRIPPER
  51. #define CBRS_GRIPPER                    0x00400000L
  52. #endif
  54. int CXTPCommandBar::s_nHoverDelay = 300;
  55. int CXTPCommandBar::s_nExpandDelay = 5000;
  56. int CXTPCommandBar::s_nExpandHoverDelay = 900;
  58. //////////////////////////////////////////////////////////////////////////
  59. // CXTPCommandBarList
  62. CXTPCommandBarList::~CXTPCommandBarList()
  63. {
  64. RemoveAll();
  65. }
  67. CXTPCommandBar* CXTPCommandBarList::GetAt(int nIndex) const
  68. {
  69. return nIndex >= 0 && nIndex < m_arrBars.GetSize() ? m_arrBars[nIndex] : NULL;
  70. }
  72. int CXTPCommandBarList::GetCount() const
  73. {
  74. return (int)m_arrBars.GetSize();
  75. }
  77. CXTPCommandBar* CXTPCommandBarList::Add(CXTPCommandBar* pCommandBar)
  78. {
  79. m_arrBars.Add(pCommandBar);
  80. return pCommandBar;
  81. }
  83. BOOL CXTPCommandBarList::Lookup(CXTPCommandBar* pCommandBar) const
  84. {
  85. for (int i = 0; i < GetCount(); i++)
  86. {
  87. if (GetAt(i) == pCommandBar)
  88. return TRUE;
  89. }
  90. return FALSE;
  91. }
  93. void CXTPCommandBarList::RemoveAll()
  94. {
  95. for (int i = 0; i < GetCount(); i++)
  96. {
  97. CXTPCommandBar* pBar = GetAt(i);
  98. pBar->InternalRelease();
  99. }
  100. m_arrBars.RemoveAll();
  101. }
  103. void CXTPCommandBarList::Remove(CXTPCommandBar* pCommandBar)
  104. {
  105. for (int i = 0; i < GetCount(); i++)
  106. {
  107. if (GetAt(i) == pCommandBar)
  108. {
  109. m_arrBars.RemoveAt(i);
  110. pCommandBar->InternalRelease();
  111. }
  112. }
  113. }
  115. CXTPCommandBar* CXTPCommandBarList::FindCommandBar(UINT nBarID) const
  116. {
  117. for (int i = 0; i < GetCount(); i++)
  118. {
  119. CXTPCommandBar* pBar = GetAt(i);
  120. if (pBar->GetBarID() == nBarID)
  121. return pBar;
  122. }
  123. return NULL;
  124. }
  126. //////////////////////////////////////////////////////////////////////////
  127. // CXTPCommandBar
  129. IMPLEMENT_XTP_COMMANDBAR(CXTPCommandBar, CWnd)
  131. CXTPCommandBar::CXTPCommandBar()
  132. {
  133. EnableAutomation();
  136. m_pCommandBars = 0;
  137. m_nIdleFlags = 0;
  138. m_barType = xtpBarTypeNormal;
  139. m_buttonStyle = xtpButtonAutomatic;
  141. m_pControls = (CXTPControls*) CXTPControls::CreateObject();
  142. m_pControls->SetParent(this);
  144. m_barPosition = xtpBarNone;
  145. m_bTracking = FALSE;
  147. m_nClickedControl = -1;
  148. m_nSelected = -1;
  149. m_nPopuped = -1;
  150. m_hwndFocus = 0;
  151. m_dwFlags = 0;
  152. m_bVisible = TRUE;
  153. m_pOwner = NULL;
  154. m_bGrabFocus = TRUE;
  156. m_nBarID = 0;
  157. m_pSite = 0;
  159. m_nWrapMargin = 0;
  161. m_szIcons = CSize(0, 0);
  162. m_szButtons = CSize(0, 0);
  164. m_nMRUWidth = 32767;
  166. m_dwStyle = CBRS_GRIPPER;
  167. m_bCustomizable = TRUE;
  169. m_nStateFlags = 0;
  171. m_rcMarker.SetRectEmpty();
  172. m_dwData = 0;
  173. m_pReturnCmd = NULL;
  174. m_bTrackOnHover = TRUE;
  176. m_bCustomizeDialogPresent = TRUE;
  177. m_bTextBelow = XTP_BOOL_DEFAULT;
  178. m_bExecOnRButton = FALSE;
  179. m_bIgnoreUpdateHandler = FALSE;
  180. m_bRecursePopup = FALSE;
  181. m_nLockRecurse = 0;
  183. m_pPaintManager = NULL;
  184. m_pImageManager = NULL;
  186. m_bKeyboardSelect = FALSE;
  188. m_nLockRedraw = 0;
  189. m_pToolTipContext = 0;
  191. m_bComboBar = FALSE;
  193. m_bMultiLine = FALSE;
  195. m_bAnimatePopup = FALSE;
  196. m_bVerticalMarker = FALSE;
  198. m_pAnimation = new CXTPCommandBarAnimation(this);
  199. }
  201. CXTPCommandBar::~CXTPCommandBar()
  202. {
  204. if (IsTrackingMode()) SetTrackingMode(FALSE);
  206. XTPHookManager()->RemoveAll(this);
  207. XTPMouseManager()->RemoveSelected(this);
  209. if (m_pControls)
  210. {
  211. m_pControls->RemoveAll();
  212. m_pControls->SetParent(NULL);
  214. CMDTARGET_RELEASE(m_pControls);
  215. }
  217. CMDTARGET_RELEASE(m_pPaintManager);
  219. CMDTARGET_RELEASE(m_pImageManager)
  221. CMDTARGET_RELEASE(m_pToolTipContext);
  223. delete m_pAnimation;
  224. }
  226. void CXTPCommandBar::SetControls(CXTPControls* pControls)
  227. {
  228. CMDTARGET_RELEASE(m_pControls);
  230. m_pControls = pControls;
  232. if (m_pControls)
  233. {
  234. m_pControls->SetParent(this);
  235. }
  236. }
  238. void CXTPCommandBar::OnRemoved()
  239. {
  240. if (IsTrackingMode()) SetTrackingMode(FALSE);
  242. XTPHookManager()->RemoveAll(this);
  243. XTPMouseManager()->RemoveSelected(this);
  245. if (m_pControls)
  246. {
  247. m_pControls->RemoveAll();
  248. }
  250. DestroyWindow();
  251. }
  253. void CXTPCommandBar::OnFinalRelease()
  254. {
  255. if (m_hWnd != NULL)
  256. DestroyWindow();
  258. CCmdTarget::OnFinalRelease();
  259. }
  262. BEGIN_MESSAGE_MAP(CXTPCommandBar, CWnd)
  263. ON_WM_MOUSEMOVE()
  264. ON_MESSAGE(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  265. ON_MESSAGE_VOID(WM_INITIALUPDATE, OnInitialUpdate)
  266. ON_WM_CREATE()
  267. ON_WM_DESTROY()
  269. ON_WM_LBUTTONDOWN()
  270. ON_WM_LBUTTONDBLCLK()
  271. ON_WM_ERASEBKGND()
  272. ON_WM_PAINT()
  273. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  275. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  277. ON_MESSAGE(WM_HELPHITTEST, OnHelpHitTest)
  278. ON_WM_NCHITTEST_EX()
  279. ON_WM_NCLBUTTONDOWN()
  281. ON_WM_TIMER()
  282. ON_WM_LBUTTONUP()
  283. ON_WM_RBUTTONUP()
  284. ON_WM_RBUTTONDOWN()
  285. ON_WM_NCMOUSEMOVE()
  287. ON_MESSAGE(WM_GETOBJECT, OnGetObject)
  289. END_MESSAGE_MAP()
  292. // CXTPCommandBar message handlers
  294. int CXTPCommandBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  295. {
  296. if (CWnd::OnCreate(lpCreateStruct) == -1)
  297. return -1;
  299. CXTPCommandBars* pCommandBars = GetCommandBars() ;
  301. if (m_barPosition != xtpBarListBox && pCommandBars)
  302. {
  303. pCommandBars->GetDropSource()->Register(this);
  304. }
  306. if (pCommandBars)
  307. {
  308. CMDTARGET_RELEASE(m_pToolTipContext);
  310. m_pToolTipContext = pCommandBars->GetToolTipContext();
  311. CMDTARGET_ADDREF(m_pToolTipContext);
  312. }
  313. else if (m_barType != xtpBarTypePopup)
  314. {
  315. EnableToolTips();
  316. }
  318. return 0;
  319. }
  320. void CXTPCommandBar::OnDestroy()
  321. {
  322. if (m_barPosition != xtpBarListBox)
  323. {
  324. CXTPCommandBars* pCommandBars = GetCommandBars();
  325. if (pCommandBars)
  326. {
  327. pCommandBars->GetDropSource()->UnRegister(this);
  328. }
  329. }
  331. if (IsTrackingMode()) SetTrackingMode(FALSE);
  333. m_pAnimation->OnDestroy();
  335. CWnd::OnDestroy();
  336. }
  338. BOOL CXTPCommandBar::IsMouseLocked() const
  339. {
  340. return !m_bComboBar && (GetCommandBars()->GetMouseManager()->IsMouseLocked());
  342. }
  344. void CXTPCommandBar::OnMouseMove(UINT /*nFlags*/, CPoint point)
  345. {
  346. CXTPCommandBars* pCommandBars = GetCommandBars ();
  347. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  349. BOOL bActive = IsTrackingMode() || pMouseManager->IsTopParentActive(m_hWnd);
  351. if (!m_hWnd || pMouseManager->IsTrackedLock(this) ||
  352. (!bActive && GetPosition() != xtpBarPopup) || IsMouseLocked())
  353. return;
  355. if (pCommandBars && pCommandBars->IsCustomizeMode())
  356. {
  357. CXTPControl* pControl = pCommandBars->m_pDragSelected;
  358. if (pControl)
  359. pControl->OnCustomizeMouseMove(point);
  360. return;
  361. }
  363. if (m_nPopuped != -1 && !m_bTrackOnHover)
  364. return;
  366. BOOL bLockSelected = ((GetPosition() != xtpBarPopup) || m_nPopuped != -1) || m_bKeyboardSelect;
  367. int nSelected = (IsTrackingMode() && bLockSelected) ? m_nSelected : -1;
  369. CXTPControl* pControl = m_pControls->HitTest(point);
  370. if (pControl)
  371. {
  372. nSelected = pControl->GetIndex();
  373. pMouseManager->TrackMouseLeave(*this);
  374. pControl->OnMouseMove(point);
  375. }
  377. SetSelected(nSelected);
  378. }
  380. void CXTPCommandBar::OnMouseLeave()
  381. {
  382. if (!IsMouseLocked() && !(IsTrackingMode() && (GetPosition() != xtpBarPopup || m_nPopuped != -1)) && (m_nLockRecurse == 0))
  383. SetSelected(-1);
  384. }
  385. void CXTPCommandBar::OnNcMouseMove(UINT nHitTest, CPoint point)
  386. {
  387. OnMouseLeave();
  388. CWnd::OnNcMouseMove(nHitTest, point);
  389. }
  391. void CXTPCommandBar::OnTrackEnter()
  392. {
  393. SetSelected(-1);
  394. }
  398. void CXTPCommandBar::OnLButtonDown(UINT nFlags, CPoint point)
  399. {
  400. CXTPControl* pControl = m_pControls->HitTest(point);
  402. if ((m_nPopuped != -1) && (GetPosition() == xtpBarPopup && GetType() == xtpBarTypeNormal)
  403. && (!pControl || pControl->GetIndex() != m_nPopuped))
  404. {
  405. if (m_nPopuped == m_nSelected) SetSelected(-1);
  406. SetPopuped(-1);
  407. }
  409. if (pControl)
  410. {
  412. if (!IsCustomizeMode() && (pControl->IsCustomizeMovable()) &&
  413. DYNAMIC_DOWNCAST(CXTPToolBar, this) && (GetKeyState(VK_MENU) < 0))
  414. {
  415. CXTPCommandBars* pCommandBars = GetCommandBars();
  416. if (pCommandBars && pCommandBars->IsCustomizeAvail() && pCommandBars->GetCommandBarsOptions()->bAltDragCustomization)
  417. {
  418. pCommandBars->SetQuickCustomizeMode(TRUE);
  420. SetPopuped(-1);
  421. SetSelected(-1);
  422. pControl->CustomizeStartDrag(point);
  424. pCommandBars->SetQuickCustomizeMode(FALSE);
  425. pCommandBars->RecalcFrameLayout();
  426. pCommandBars->ClosePopups();
  427. return;
  428. }
  429. }
  432. if (!IsCustomizeMode() || pControl->IsCustomizeMovable())
  433. pControl->OnClick(FALSE, point);
  434. return;
  435. }
  436. CWnd::OnLButtonDown(nFlags, point);
  437. }
  439. void CXTPCommandBar::OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
  440. {
  441. if (IsCustomizeMode())
  442. return;
  444. CXTPControl* pControl = m_pControls->HitTest(point);
  445. if (pControl)
  446. {
  447. pControl->OnLButtonDblClk(point);
  448. }
  449. }
  451. void CXTPCommandBar::OnLButtonUp(UINT nFlags, CPoint point)
  452. {
  453. if (IsCustomizeMode())
  454. return;
  456. CXTPControl* pControl = m_pControls->HitTest(point);
  457. if (pControl)
  458. {
  459. pControl->OnLButtonUp(point);
  460. return;
  461. }
  462. CWnd::OnLButtonUp(nFlags, point);
  463. }
  465. void CXTPCommandBar::OnRButtonUp(UINT /*nFlags*/, CPoint point)
  466. {
  467. if (IsCustomizeMode())
  468. return;
  470. CXTPControl* pControl = m_pControls->HitTest(point);
  472. if (pControl)
  473. {
  474. if (GetSite()->SendMessage(WM_XTP_CONTROLRBUTTONUP, (WPARAM)(LPPOINT)&point, (LPARAM)pControl) == TRUE)
  475. return;
  477. if (GetRootParent()->m_bExecOnRButton)
  478. {
  479. pControl->OnLButtonUp(point);
  480. return;
  481. }
  483. if (pControl->OnRButtonUp(point))
  484. return;
  485. }
  487. CXTPCommandBar* pCommandBar = GetRootParent();
  488. if (pCommandBar && pCommandBar != this)
  489. {
  490. pCommandBar->OnPopupRButtonUp(this, point);
  491. }
  492. }
  494. void CXTPCommandBar::EnsureVisible(CXTPControl* /*pControl*/)
  495. {
  497. }
  499. BOOL CXTPCommandBar::SetSelected(int nSelected, BOOL bKeyboard)
  500. {
  501. if (m_nSelected == nSelected)
  502. return FALSE;
  504. m_bKeyboardSelect = bKeyboard;
  506. if (!GetSafeHwnd())
  507. return FALSE;
  510. if (m_nSelected != -1)
  511. {
  512. CXTPControl* pSelected = GetControl(m_nSelected);
  513. if (pSelected) pSelected->OnMouseMove(CPoint(-1, -1));
  514. if (pSelected) pSelected->OnSetSelected(FALSE);
  515. }
  517. m_nSelected = nSelected;
  519. if (m_nSelected != -1)
  520. {
  521. CXTPControl* pSelected = GetControl(nSelected);
  522. ASSERT(pSelected);
  523. if (!pSelected)
  524. return FALSE;
  526. if (bKeyboard)
  527. EnsureVisible(pSelected);
  529. pSelected->OnSetSelected(bKeyboard ? max(TRUE_KEYBOARD_NEXT, bKeyboard) : TRUE);
  531. if (IsTrackingMode()) AccessibleNotifyWinEvent(EVENT_OBJECT_FOCUS , m_hWnd, OBJID_MENU, m_nSelected + 1);
  533. XTPMouseManager()->SetSelected(this);
  534. if (!bKeyboard && m_bTrackOnHover) SetTimer(XTP_TID_HOVER, s_nHoverDelay, NULL);
  535. }
  536. else
  537. {
  538. KillTimer(XTP_TID_HOVER);
  539. }
  541. return TRUE;
  542. }
  544. BOOL CXTPCommandBar::SetPopuped(int nPopuped, BOOL bKeyboard)
  545. {
  546. if (m_nPopuped == nPopuped)
  547. return FALSE;
  549. if (m_nPopuped != -1)
  550. {
  551. CXTPControl* pControl = GetControl(m_nPopuped);
  552. m_nPopuped = -1;
  553. pControl->OnSetPopup(FALSE);
  554. }
  556. if (nPopuped != -1)
  557. {
  558. CXTPControl* pControl = GetControl(nPopuped);
  559. if (!pControl || !pControl->GetEnabled())
  560. {
  561. return FALSE;
  562. }
  564. m_nPopuped = nPopuped;
  565. SetTrackingMode(TRUE_POPUP, FALSE, bKeyboard);
  566. SetSelected(nPopuped, bKeyboard);
  568. if (!pControl->OnSetPopup(TRUE))
  569. {
  570. m_nPopuped = -1;
  571. return FALSE;
  572. }
  574. CXTPCommandBars* pCommandBars = GetCommandBars();
  575. if (pCommandBars && pCommandBars->GetCommandBarsOptions()->bShowFullAfterDelay && m_hWnd)
  576. {
  577. SetTimer(XTP_TID_EXPANDED_POPUP, s_nExpandDelay, NULL);
  578. }
  580. }
  582. return TRUE;
  583. }
  586. LRESULT CXTPCommandBar::OnIdleUpdateCmdUI(WPARAM, LPARAM)
  587. {
  588. if (GetSafeHwnd() && (GetStyle() & WS_VISIBLE))
  589. {
  590. UpdateDocTemplateControls();
  592. OnUpdateCmdUI();
  594. if (m_nIdleFlags & xtpIdleRedraw)
  595. {
  596. Redraw();
  597. }
  598. if (m_nIdleFlags & xtpIdleLayout)
  599. {
  600. OnRecalcLayout();
  601. m_nIdleFlags &= ~xtpIdleLayout;
  602. }
  604. }
  605. return 0L;
  606. }
  608. class CXTPCommandBar::CCommandBarCmdUI : public CCmdUI
  609. {
  610. public:
  611. CCommandBarCmdUI()
  612. {
  613. m_bCheckedChanged = FALSE;
  614. m_pControl = 0;
  615. }
  617. public: // re-implementations only
  618. virtual void Enable(BOOL bOn);
  619. virtual void SetCheck(int nCheck);
  620. virtual void SetText(LPCTSTR lpszText);
  622. public:
  623. CXTPControl* m_pControl;
  624. BOOL m_bCheckedChanged;
  626. };
  628. void CXTPCommandBar::CCommandBarCmdUI::Enable(BOOL bOn)
  629. {
  630. m_bEnableChanged = TRUE;
  632. ASSERT(m_pControl != NULL);
  633. if (!m_pControl)
  634. return;
  636. if (m_pControl->GetAction())
  637. {
  638. m_pControl->SetEnabled(bOn ? -1 : FALSE);
  639. }
  640. else
  641. {
  642. m_pControl->SetEnabled(bOn);
  644. if (!bOn && !m_bCheckedChanged) m_pControl->SetChecked(FALSE);
  645. }
  646. }
  648. void CXTPCommandBar::CCommandBarCmdUI::SetCheck(int nCheck)
  649. {
  650. ASSERT(nCheck >= 0 && nCheck <= 2); // 0 =>off, 1 =>on, 2 =>indeterminate
  651. m_bCheckedChanged = TRUE;
  653. ASSERT(m_pControl != NULL);
  654. if (!m_pControl)
  655. return;
  657. m_pControl->SetChecked(nCheck);
  658. }
  660. void CXTPCommandBar::CCommandBarCmdUI::SetText(LPCTSTR lpszCaption)
  661. {
  662. ASSERT(m_pControl != NULL);
  663. if (!m_pControl)
  664. return;
  666. m_pControl->SetCaption(lpszCaption);
  667. }
  670. void CXTPCommandBar::OnInitialUpdate()
  671. {
  672. // update the indicators before becoming visible
  673. OnIdleUpdateCmdUI(TRUE, 0L);
  674. }
  676. void CXTPCommandBar::OnUpdateCmdUI()
  677. {
  678. if (!GetSafeHwnd())
  679. return;
  681. CWnd* pTarget = GetOwnerSite();
  682. CXTPCommandBars* pCommandBars = GetCommandBars();
  683. BOOL bDisableIfNoHndler = pCommandBars ? pCommandBars->GetCommandBarsOptions()->bDisableCommandIfNoHandler : FALSE;
  685. if (!pTarget)
  686. return;
  688. CXTPControl* pControl;
  691. BOOL bIgnoreUpdateHandler = GetRootParent()->m_bIgnoreUpdateHandler;
  693. CCommandBarCmdUI state;
  694. state.m_pOther = this;
  696. for (state.m_nIndex = 0; (int)state.m_nIndex < GetControlCount(); state.m_nIndex++)
  697. {
  698. pControl = m_pControls->GetAt(state.m_nIndex);
  700. if (!pControl->IsVisible(xtpHideScroll | xtpHideGeneric | xtpHideExpand))
  701. continue;
  703. pControl->OnIdleUpdate();
  705. if (bIgnoreUpdateHandler || (pControl->m_dwFlags & xtpFlagManualUpdate))
  706. continue;
  708. state.m_pControl = pControl;
  709. state.m_nID = pControl->GetID();
  710. state.m_bCheckedChanged = FALSE;
  711. state.m_bEnableChanged = FALSE;
  713. if (CWnd::OnCmdMsg(0,
  714. MAKELONG((int)CN_UPDATE_COMMAND_UI, WM_COMMAND + WM_REFLECT_BASE),
  715. &state, NULL))
  716. continue;
  718. // allow the toolbar itself to have update handlers
  719. if (CWnd::OnCmdMsg(state.m_nID, (int)CN_UPDATE_COMMAND_UI, &state, NULL))
  720. continue;
  722. if (pCommandBars && pCommandBars->IsCustomizeMode())
  723. {
  724. if (pControl->m_bEnabled != (BOOL)-1)
  725. {
  726. state.Enable(TRUE);
  727. }
  728. }
  729. else
  730. // allow the owner to process the update
  731. state.DoUpdate(pTarget, bDisableIfNoHndler);
  732. }
  734. // update the dialog controls added to the toolbar
  735. UpdateDialogControls(pTarget, bDisableIfNoHndler);
  737. }
  739. BOOL CXTPControls::LoadMenu(CMenu* pMenu)
  740. {
  741. if (!pMenu)
  742. return FALSE;
  744. BOOL bSeparator = FALSE;
  745. int nCount = ::GetMenuItemCount(pMenu->m_hMenu);
  746. MENUITEMINFO info;
  748. for (int i = 0; i < nCount; i++)
  749. {
  750. ZeroMemory(&info, sizeof(MENUITEMINFO));
  751. info.cbSize = sizeof(MENUITEMINFO);
  752. info.fMask = MIIM_TYPE | MIIM_STATE;
  754. // Check to see if the item is a separator, we don't want
  755. // to use GetMenuItemID(i) because it may not equal zero.
  756. ::GetMenuItemInfo(pMenu->m_hMenu, i, TRUE, &info);
  758. if (((info.fType & MFT_SEPARATOR) == MFT_SEPARATOR) || (pMenu->GetMenuItemID(i) == 0))
  759. bSeparator = TRUE;
  760. else
  761. {
  762. CXTPControl* pControl = AddMenuItem(pMenu, i);
  764. if (!pControl)
  765. continue;
  767. if (((info.fType & MFT_MENUBARBREAK) == MFT_MENUBARBREAK) || ((info.fType & MFT_MENUBREAK) == MFT_MENUBREAK))
  768. {
  769. pControl->SetFlags(pControl->GetFlags() | xtpFlagWrapRow);
  770. pControl->SetBeginGroup((info.fType & MFT_MENUBARBREAK) ? TRUE : FALSE);
  771. }
  772. if (bSeparator)
  773. {
  774. pControl->SetBeginGroup(TRUE);
  775. bSeparator = FALSE;
  776. }
  777. if (pControl->GetAction() == NULL && info.fState & MFS_CHECKED)
  778. {
  779. pControl->SetChecked(TRUE);
  780. }
  781. if (pControl->GetAction() == NULL && info.fState & MFS_DISABLED)
  782. {
  783. pControl->SetEnabled(FALSE);
  784. }
  785. }
  786. }
  787. return TRUE;
  788. }
  790. BOOL CXTPCommandBar::LoadMenu(CMenu* pMenu, BOOL bRemoveControls)
  791. {
  792. if (!pMenu || !::IsMenu(pMenu->m_hMenu))
  793. return FALSE;
  795. if (bRemoveControls)
  796. m_pControls->RemoveAll();
  798. if (!m_pControls->LoadMenu(pMenu))
  799. return FALSE;
  801. CFrameWnd* pFrame = GetParentFrame();
  802. if (pFrame) pFrame->DelayRecalcLayout();
  803. return TRUE;
  804. }
  810. BOOL CXTPCommandBar::ProcessSpecialKey(XTPSpecialKey key)
  811. {
  812. if (key == xtpKeySpace)
  813. {
  814. if (GetType() == xtpBarTypeMenuBar)
  815. {
  816. GetCommandBars()->ClosePopups();
  817. GetSite()->PostMessage(WM_SYSCOMMAND, SC_KEYMENU, (LPARAM)_T(' '));
  818. return TRUE;
  819. }
  820. return FALSE;
  821. }
  823. if (key == xtpKeyLeft) key = xtpKeyPrev;
  824. if (key == xtpKeyRight) key = xtpKeyNext;
  826. BOOL bPopupToolBar = (GetPosition() == xtpBarPopup && GetType() == xtpBarTypeNormal);
  828. if (key == xtpKeyNext || key == xtpKeyPrev)
  829. HideKeyboardTips();
  831. if (m_nSelected != -1 && m_nSelected == m_nPopuped && bPopupToolBar)
  832. {
  833. if (key == xtpKeyNext)
  834. return FALSE;
  836. if (key == xtpKeyPrev)
  837. key = xtpKeyBack;
  838. }
  839. else if (key == xtpKeyBack && m_nPopuped == -1 && m_nSelected != -1 && (bPopupToolBar || !GetParentCommandBar()))
  840. {
  841. CXTPControlPopup* pControlPopup = DYNAMIC_DOWNCAST(CXTPControlPopup, GetControl(m_nSelected));
  842. if (pControlPopup && pControlPopup->GetEnabled())
  843. key = xtpKeyPopup;
  844. }
  845. if (((key == xtpKeyPopup) || (key == xtpKeyBack)) && m_nPopuped == -1 && (bPopupToolBar || (GetPosition() == xtpBarFloating)))
  846. {
  847. int nDirection = key == xtpKeyPopup ? +1 : -1;
  849. if (m_nSelected == -1)
  850. {
  851. SetSelected(m_pControls->GetNext(-1, nDirection), nDirection ? TRUE_KEYBOARD_NEXT : TRUE_KEYBOARD_PREV);
  852. return TRUE;
  853. }
  855. CXTPControlPopup* pControlPopup = DYNAMIC_DOWNCAST(CXTPControlPopup, GetControl(m_nSelected));
  856. if (!pControlPopup || !pControlPopup->GetEnabled())
  857. {
  858. CXTPControl* pSelected = GetControl(m_nSelected), *pNextSelected = NULL;
  859. int nSelected = m_nSelected;
  860. ASSERT(pSelected);
  861. CRect rcSelected = pSelected->GetRect();
  862. CRect rcSelectedRow = pSelected->m_rcRow;
  864. do
  865. {
  866. nSelected = m_pControls->GetNext(nSelected, nDirection);
  867. ASSERT(nSelected != -1);
  869. CXTPControl* pCondidate = GetControl(nSelected);
  870. CRect rcNextSelected = pCondidate->GetRect(), rcNextSelectedRow = pCondidate->GetRowRect();
  872. if (pNextSelected && (pNextSelected->m_rcRow.top == rcNextSelectedRow.top)
  873. && ((rcNextSelected.left <= rcSelected.left && (rcNextSelected.left > pNextSelected->GetRect().left))
  874. || (rcNextSelected.left >= rcSelected.left && (pNextSelected->GetRect().left > rcNextSelected.left))))
  875. {
  876. pNextSelected = pCondidate;
  877. }
  878. else if (!pNextSelected && rcNextSelectedRow.top != rcSelectedRow.top && !rcNextSelectedRow.IsRectEmpty())
  879. {
  880. pNextSelected = pCondidate;
  881. }
  882. else if (pNextSelected)
  883. {
  884. SetSelected(pNextSelected->GetIndex(), nDirection > 0 ? TRUE_KEYBOARD_NEXT : TRUE_KEYBOARD_PREV);
  885. break;
  886. }
  888. }
  889. while ((nSelected != m_nSelected) && (nSelected != -1));
  891. return TRUE;
  892. }
  893. }
  895. switch (key)
  896. {
  897. case xtpKeyNext:
  898. SetSelected(m_pControls->GetNext(m_nSelected, +1), TRUE_KEYBOARD_NEXT);
  899. return TRUE;
  901. case xtpKeyPrev:
  902. SetSelected(m_pControls->GetNext(m_nSelected, -1), TRUE_KEYBOARD_PREV);
  903. return TRUE;
  905. case xtpKeyHome:
  906. SetSelected(m_pControls->GetNext(-1, +1), TRUE_KEYBOARD_NEXT);
  907. return TRUE;
  909. case xtpKeyEnd:
  910. SetSelected(m_pControls->GetNext(GetControlCount(), -1), TRUE_KEYBOARD_PREV);
  911. return TRUE;
  913. case xtpKeyPopup:
  914. if (m_nSelected != -1 && m_nSelected != m_nPopuped)
  915. {
  916. GetControl(m_nSelected)->OnSetSelected(TRUE_KEYBOARD_NEXT);
  917. return SetPopuped(m_nSelected);
  918. }
  919. break;
  921. case xtpKeyBack:
  922. if (m_nPopuped != -1)
  923. {
  924. SetPopuped(-1);
  925. SetTrackingMode(TRUE, FALSE);
  926. return TRUE;
  927. }
  928. break;
  930. case xtpKeyEscape:
  931. {
  932. int nLevel = IsKeyboardTipsVisible();
  933. if (nLevel > 1)
  934. {
  935. GetCommandBars()->ShowKeyboardTips(this, nLevel - 1);
  936. return TRUE;
  937. }
  938. if (GetParentCommandBar() != NULL)
  939. GetParentCommandBar()->SetTrackingMode(TRUE, FALSE);
  941. SetTrackingMode(FALSE);
  942. }
  943. return TRUE;
  945. case xtpKeyReturn:
  946. if (m_nSelected != -1)
  947. {
  948. GetControl(m_nSelected)->OnSetSelected(TRUE_KEYBOARD_NEXT);
  949. GetControl(m_nSelected)->OnClick(TRUE);
  950. }
  951. return TRUE;
  953. }
  954. return FALSE;
  955. }
  957. BOOL CXTPCommandBar::IsHelpMode() const
  958. {
  959. CFrameWnd* pFrame = GetFrameSite();
  960. return pFrame && pFrame->m_bHelpMode;
  961. }
  963. BOOL CXTPCommandBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  964. {
  965. CXTPCommandBars* pCommandBars = GetCommandBars();
  967. if (pCommandBars && pCommandBars->IsCustomizeMode())
  968. {
  969. return FALSE_EXIT;
  970. }
  972. if (IsHelpMode())
  973. return FALSE_EXIT;
  975. if (m_nLockRecurse > 0)
  976. return TRUE;
  978. InternalAddRef();
  980. GetSite()->SendMessage(WM_XTP_COMMANDBARKEYDOWN, (WPARAM)&nChar, (LPARAM)this);
  982. if (InternalRelease() == 0)
  983. return TRUE;
  985. CXTPControl* pControl = GetControl(m_nSelected);
  987. if (pControl && pControl->IsFocused())
  988. {
  989. BOOL bResult = pControl->OnHookKeyDown(nChar, lParam);
  991. if ((bResult == TRUE) || (bResult == FALSE_EXIT))
  992. return bResult;
  993. }
  995. if (!GetSafeHwnd())
  996. return TRUE;
  998. switch (nChar)
  999. {
  1000. case VK_TAB:
  1001. {
  1002. if ((GetKeyState(VK_CONTROL) < 0) && pCommandBars)
  1003. {
  1004. CXTPCommandBar* pToolBar = GetRootParent();
  1006. if (DYNAMIC_DOWNCAST(CXTPToolBar, pToolBar))
  1007. {
  1008. if (pCommandBars->SetToolBarFocus((CXTPToolBar*)pToolBar, GetKeyState(VK_SHIFT) >= 0 ? +1 : -1))
  1009. return TRUE;
  1010. }
  1011. }
  1013. ProcessSpecialKey(GetKeyState(VK_SHIFT) >= 0 ? xtpKeyNext : xtpKeyPrev);
  1015. pControl = GetControl(m_nSelected);
  1016. if (pControl && pControl->IsFocusable())
  1017. pControl->SetFocused(TRUE);
  1019. return TRUE;
  1020. }
  1022. case VK_RETURN: return ProcessSpecialKey(xtpKeyReturn);
  1023. case VK_ESCAPE: return ProcessSpecialKey(xtpKeyEscape);
  1025. case VK_SPACE:
  1026. if (ProcessSpecialKey(xtpKeySpace))
  1027. return TRUE;
  1028. }
  1030. if (::GetFocus() && ::IsChild(m_hWnd, ::GetFocus()))
  1031. return FALSE_EXIT;
  1033. BOOL bHoriz = m_barPosition == xtpBarTop || m_barPosition == xtpBarBottom || m_barPosition == xtpBarFloating
  1034. || (m_barPosition == xtpBarPopup && m_barType == xtpBarTypeNormal) ;
  1036. BOOL bLayoutRTL = IsLayoutRTL();
  1038. switch (nChar)
  1039. {
  1040. case VK_LEFT: return ProcessSpecialKey(bHoriz ? (bLayoutRTL ? xtpKeyRight: xtpKeyLeft) : (bLayoutRTL ? xtpKeyPopup : xtpKeyBack));
  1041. case VK_RIGHT: return ProcessSpecialKey(bHoriz ? (bLayoutRTL ? xtpKeyLeft : xtpKeyRight) : (!bLayoutRTL ? xtpKeyPopup : xtpKeyBack));
  1042. case VK_UP: return ProcessSpecialKey(bHoriz ? xtpKeyBack : xtpKeyPrev);
  1043. case VK_DOWN: return ProcessSpecialKey(bHoriz ? xtpKeyPopup : xtpKeyNext);
  1044. case VK_HOME: return ProcessSpecialKey(xtpKeyHome);
  1045. case VK_END: return ProcessSpecialKey(xtpKeyEnd);
  1046. }
  1048. if (nChar && MapVirtualKey(nChar, 2))
  1049. {
  1050. if (IsKeyboardTipsVisible() && GetKeyState(VK_CONTROL) >= 0)
  1051. {
  1052. OnKeyboardTipChar(nChar);
  1053. return TRUE;
  1054. }
  1056. if (pCommandBars && DYNAMIC_DOWNCAST(CXTPToolBar, this))
  1057. {
  1058. if (pCommandBars->OnFrameAccel(nChar))
  1059. return TRUE;
  1060. }
  1062. BOOL bSelectOnly = FALSE;
  1063. int nIndex = GetKeyState(VK_CONTROL) < 0 ? -1 : FindAccelEx(nChar, bSelectOnly);
  1064. if (nIndex != -1)
  1065. {
  1066. SetSelected(nIndex, TRUE_KEYBOARD_NEXT);
  1068. if (!bSelectOnly)
  1069. {
  1070. GetControl(nIndex)->OnUnderlineActivate();
  1071. }
  1072. return TRUE;
  1073. }
  1074. if (nChar != VK_SHIFT && nChar != VK_CONTROL) MessageBeep(0);
  1075. }
  1077. return TRUE;
  1078. }
  1080. void CXTPCommandBar::HideKeyboardTips()
  1081. {
  1082. CXTPCommandBars* pCommandBars = GetCommandBars();
  1083. if (pCommandBars) pCommandBars->HideKeyboardTips();
  1084. }
  1086. void CXTPCommandBar::OnKeyboardTip(CXTPCommandBarKeyboardTip* pTip)
  1087. {
  1088. CXTPControl* pControl = DYNAMIC_DOWNCAST(CXTPControl, pTip->m_pOwner);
  1089. if (pControl)
  1090. {
  1091. pControl->OnUnderlineActivate();
  1092. return;
  1093. }
  1095. CXTPToolBar* pToolBar = DYNAMIC_DOWNCAST(CXTPToolBar, pTip->m_pOwner);
  1096. if (pToolBar)
  1097. {
  1098. pToolBar->GetCommandBars()->SetToolBarFocus(pToolBar, FALSE);
  1099. }
  1100. }
  1102. void CXTPCommandBar::OnKeyboardTipChar(UINT chAccel)
  1103. {
  1104. CXTPCommandBars* pCommandBars = GetCommandBars();
  1105. if (!pCommandBars)
  1106. return;
  1108. for (int i = 0; i < (int)pCommandBars->m_keyboardTips.arr.GetSize(); i++)
  1109. {
  1110. CXTPCommandBarKeyboardTip* pTip = pCommandBars->m_keyboardTips.arr[i];
  1111. if (pTip->m_strTip.GetLength() > pCommandBars->m_keyboardTips.nKey)
  1112. {
  1113. if (CXTPShortcutManager::CompareAccelKey(pTip->m_strTip[pCommandBars->m_keyboardTips.nKey], chAccel))
  1114. {
  1115. if (pTip->m_strTip.GetLength() - 1 > pCommandBars->m_keyboardTips.nKey)
  1116. {
  1117. pCommandBars->m_keyboardTips.nKey++;
  1119. CString str = pTip->m_strTip.Left(pCommandBars->m_keyboardTips.nKey);
  1120. for (int j = (int)pCommandBars->m_keyboardTips.arr.GetSize() - 1; j >= 0; j--)
  1121. {
  1122. pTip = pCommandBars->m_keyboardTips.arr[j];
  1123. if (pTip->m_strTip.Left(pCommandBars->m_keyboardTips.nKey) != str)
  1124. {
  1125. pCommandBars->m_keyboardTips.arr.RemoveAt(j);
  1126. pTip->DestroyWindow();
  1127. delete pTip;
  1128. }
  1129. }
  1130. }
  1131. else
  1132. {
  1133. if (pTip->m_bEnabled)
  1134. OnKeyboardTip(pTip);
  1135. else
  1136. MessageBeep(0);
  1137. }
  1138. return;
  1139. }
  1140. }
  1141. }
  1143. if (chAccel != VK_SHIFT && chAccel != VK_CONTROL) MessageBeep(0);
  1144. }
  1146. BOOL CXTPCommandBar::Popup(CXTPControlPopup* /*pControlPopup*/, BOOL)
  1147. {
  1148. return FALSE;
  1149. }
  1151. BOOL CXTPCommandBar::OnEraseBkgnd(CDC* /*pDC*/)
  1152. {
  1153. return TRUE;
  1154. }
  1156. int CXTPCommandBar::OnHookMessage(HWND /*hWnd*/, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& /*lResult*/)
  1157. {
  1158. if (IsTrackingMode())
  1159. {
  1160. switch (nMessage)
  1161. {
  1162. case WM_KEYDOWN:
  1163. return OnHookKeyDown((UINT)wParam, lParam);
  1165. case WM_MOUSEWHEEL:
  1166. {
  1167. CXTPControl* pControl = GetControl(m_nSelected);
  1169. if (pControl && pControl->IsFocused())
  1170. {
  1171. pControl->OnHookMouseWheel(LOWORD(wParam), (short) HIWORD(wParam),
  1172. CPoint(LOWORD(lParam), HIWORD(lParam)));
  1173. }
  1175. return TRUE;
  1176. }
  1177. }
  1178. }
  1179. return FALSE;
  1180. }
  1182. void CXTPCommandBar::OnTrackLost()
  1183. {
  1184. SetTrackingMode(FALSE);
  1185. }
  1187. BOOL CXTPCommandBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  1188. {
  1189. if (m_bTracking && bMode || m_bTracking == bMode)
  1190. {
  1191. m_bTracking = bMode;
  1192. return FALSE;
  1193. }
  1195. m_bTracking = bMode;
  1197. CXTPCommandBars* pCommandBars = GetCommandBars();
  1198. CXTPMouseManager* pMouseManager = pCommandBars->GetMouseManager();
  1200. if (bMode)
  1201. {
  1202. if (GetType() == xtpBarTypeMenuBar)
  1203. GetSite()->SendMessage(WM_XTP_INITMENU, (WPARAM)this);
  1205. m_bAnimatePopup = !bSelectFirst && !bKeyboard;
  1206. m_bKeyboardSelect = bKeyboard;
  1208. if (m_bGrabFocus)
  1209. {
  1210. if (m_hwndFocus == 0)
  1211. m_hwndFocus = ::GetFocus() ? ::GetFocus() : GetSite()->GetSafeHwnd();
  1212. ::HideCaret(m_hwndFocus);
  1213. }
  1215. pMouseManager->SetTrack(this, FALSE);
  1217. XTPKeyboardManager()->HookKeyboard(this);
  1219. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  1221. if (bSelectFirst)
  1222. {
  1223. SetSelected(m_pControls->GetNext(-1, +1), TRUE_KEYBOARD_NEXT);
  1224. }
  1226. }
  1227. else
  1228. {
  1229. m_bAnimatePopup = FALSE;
  1230. m_bKeyboardSelect = FALSE;
  1232. pMouseManager->RemoveTrack(this);
  1234. XTPKeyboardManager()->UnhookKeyboard(this);
  1236. SetPopuped(-1);
  1237. if (bSelectFirst) SetSelected(-1);
  1239. if (m_hwndFocus && m_bGrabFocus)
  1240. {
  1241. ::ShowCaret(m_hwndFocus);
  1242. m_hwndFocus = 0;
  1243. }
  1245. Redraw();
  1247. if (!pMouseManager->IsTrackedLock())
  1248. pMouseManager->SetForceExpanded(FALSE);
  1250. if (m_hWnd && GetFocus() == this && GetParent())
  1251. {
  1252. CWnd* pWndNext = GetParent()->GetNextDlgTabItem(this);
  1253. if (pWndNext != NULL)
  1254. pWndNext->SetFocus();
  1255. }
  1256. m_nLockRecurse = 0;
  1257. }
  1259. if (pCommandBars)
  1260. {
  1261. pCommandBars->OnTrackingModeChanged(this, bMode);
  1262. }
  1264. return TRUE;
  1265. }
  1268. int CXTPCommandBar::GetControlCount() const
  1269. {
  1270. return m_pControls->GetCount();
  1271. }
  1273. CXTPControl* CXTPCommandBar::GetControl(int nIndex) const
  1274. {
  1275. //Ensure the index falls within the correct range.
  1276. if ((nIndex >= 0) && (nIndex < GetControlCount()))
  1277. {
  1278. return m_pControls->GetAt(nIndex);
  1279. }
  1280. return NULL;
  1281. }
  1283. void CXTPCommandBar::OnTimer(UINT_PTR nIDEvent)
  1284. {
  1285. CWnd::OnTimer(nIDEvent);
  1287. if (nIDEvent == XTP_TID_SHOWKEYBOARDTIPS)
  1288. {
  1289. CXTPMouseManager* pMouseManager = GetCommandBars()->GetMouseManager();
  1290. int nCount = (int)pMouseManager->GetTrackArray().GetSize();
  1291. CXTPCommandBar* pCommandBar = nCount > 0 ? pMouseManager->GetTrackArray().GetAt(nCount - 1) : 0;
  1293. if (pCommandBar == this && !IsKeyboardTipsVisible()) GetCommandBars()->ShowKeyboardTips(this);
  1294. }
  1295. if (nIDEvent == XTP_TID_ANIMATION)
  1296. {
  1297. m_pAnimation->OnAnimate();
  1298. return;
  1299. }
  1301. if (nIDEvent == XTP_TID_HOVER && m_nLockRecurse == 0)
  1302. {
  1303. KillTimer(XTP_TID_HOVER);
  1305. if (m_nSelected != -1)
  1306. GetControl(m_nSelected)->OnMouseHover();
  1307. }
  1308. if (nIDEvent == XTP_TID_EXPANDED_POPUP && m_nLockRecurse == 0)
  1309. {
  1310. KillTimer(XTP_TID_EXPANDED_POPUP);
  1312. if (m_nPopuped != -1 && m_nSelected == m_nPopuped)
  1313. {
  1314. CXTPControlPopup* pControl = DYNAMIC_DOWNCAST(CXTPControlPopup, GetControl(m_nSelected));
  1315. if (pControl && pControl->IsCursorOver())
  1316. {
  1317. pControl->ExpandCommandBar();
  1318. }
  1319. }
  1320. }
  1321. }
  1323. void CXTPCommandBar::OnControlsChanged()
  1324. {
  1325. m_nSelected = -1;
  1326. m_nPopuped = -1;
  1327. DelayLayout();
  1328. }
  1330. void CXTPCommandBar::Redraw(LPCRECT lpRect, BOOL bAnimate)
  1331. {
  1332. if (m_nLockRedraw > 0)
  1333. {
  1334. m_nIdleFlags |= xtpIdleRedraw;
  1335. return;
  1336. }
  1338. if (lpRect == NULL)
  1339. {
  1340. m_nIdleFlags &= ~xtpIdleRedraw;
  1341. }
  1343. if (m_hWnd && IsVisible())
  1344. {
  1345. m_pAnimation->RedrawRect(lpRect, bAnimate);
  1346. }
  1347. }
  1349. void CXTPCommandBar::EnableAnimation(BOOL bEnable)
  1350. {
  1351. m_pAnimation->m_bAnimation = bEnable;
  1352. Redraw();
  1353. }
  1355. BOOL CXTPCommandBar::IsAnimationEnabled() const
  1356. {
  1357. return m_pAnimation->m_bAnimation;
  1358. }
  1360. void CXTPCommandBar::EnableDoubleBuffer(BOOL bEnable)
  1361. {
  1362. m_pAnimation->m_bDoubleBuffer = bEnable;
  1363. }
  1365. void CXTPCommandBar::SetShowGripper(BOOL bShow)
  1366. {
  1367. if (bShow)
  1368. m_dwStyle |= CBRS_GRIPPER;
  1369. else
  1370. m_dwStyle &= ~CBRS_GRIPPER;
  1371. }
  1373. BOOL CXTPCommandBar::GetShowGripper() const
  1374. {
  1375. return m_dwStyle & CBRS_GRIPPER ? TRUE : FALSE;
  1376. }
  1378. void CXTPCommandBar::OnPaint()
  1379. {
  1380. CPaintDC paintDC(this);
  1381. m_pAnimation->OnPaint(paintDC);
  1382. }
  1384. LRESULT CXTPCommandBar::OnPrintClient(WPARAM wParam, LPARAM)
  1385. {
  1386. CDC* pDC = CDC::FromHandle((HDC)wParam);
  1387. if (pDC)
  1388. {
  1389. DrawCommandBar(pDC, CXTPClientRect(this));
  1390. }
  1391. return TRUE;
  1392. }
  1394. CRect CXTPCommandBar::GetBorders()
  1395. {
  1396. return GetPaintManager()->GetCommandBarBorders(this);
  1397. }
  1399. void CXTPCommandBar::FillCommandBarEntry(CDC* pDC)
  1400. {
  1401. CXTPPaintManager* pPaintManager = GetPaintManager();
  1402. pPaintManager->FillCommandBarEntry(pDC, this);
  1403. }
  1405. void CXTPCommandBar::DrawCommandBar(CDC* pDC, CRect rcClipBox)
  1406. {
  1407. #if 0
  1408. _int64 nPerfomanceEnd;
  1409. _int64 nPerfomanceStart;
  1411. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceStart);
  1412. #endif
  1414. if (!pDC || !pDC->GetSafeHdc())
  1415. return;
  1417. CXTPPaintManager* pPaintManager = GetPaintManager();
  1418. CXTPCommandBars* pCommandBars = GetCommandBars();
  1420. FillCommandBarEntry(pDC);
  1422. if (GetShowGripper() || GetPosition() == xtpBarFloating)
  1423. pPaintManager->DrawCommandBarGripper(pDC, this);
  1425. pDC->SetBkMode (TRANSPARENT);
  1427. BOOL bFirst = TRUE;
  1428. for (int i = 0; i < GetControlCount(); i++)
  1429. {
  1430. CXTPControl* pControl = GetControl(i);
  1431. if (!pControl || pControl->GetParent() != this || !pControl->IsVisible())
  1432. continue;
  1434. if (pControl->GetBeginGroup() && !bFirst)
  1435. {
  1436. pPaintManager->DrawCommandBarSeparator(pDC, this, pControl);
  1437. }
  1438. bFirst = FALSE;
  1440. if (CRect().IntersectRect(rcClipBox, pControl->GetRect()))
  1441. {
  1442. CXTPFontDC font(pDC, pPaintManager->GetCommandBarFont(this, pControl->IsItemDefault()));
  1443. pControl->Draw(pDC);
  1444. }
  1446. if (pCommandBars && pCommandBars->IsCustomizeMode() && (pCommandBars->m_pDragSelected == pControl))
  1447. {
  1448. CRect rc = pControl->GetRect();
  1449. pDC->Draw3dRect(rc, 0, 0);
  1450. rc.DeflateRect(1, 1);
  1451. pDC->Draw3dRect(rc, 0, 0);
  1452. }
  1453. }
  1455. if (pCommandBars && pCommandBars->IsCustomizeMode() && !m_rcMarker.IsRectEmpty())
  1456. {
  1457. CustomizeDrawMarker(pDC);
  1458. }
  1460. #if 0
  1461. QueryPerformanceCounter((LARGE_INTEGER*)&nPerfomanceEnd);
  1462. TRACE(_T("TotalCounter = %i n"), int(nPerfomanceEnd - nPerfomanceStart));
  1463. #endif
  1464. }
  1466. void CXTPCommandBar::CustomizeDrawMarker(CDC* pDC)
  1467. {
  1469. CBrush brush(GetXtremeColor(COLOR_3DFACE));
  1470. CBrush* pBrush = (CBrush*)pDC->SelectObject(&brush);
  1472. if (m_bVerticalMarker)
  1473. {
  1474. pDC->PatBlt(m_rcMarker.left, m_rcMarker.top, 1, m_rcMarker.Height(), PATINVERT);
  1475. pDC->PatBlt(m_rcMarker.left + 1, m_rcMarker.top + 1, 1, m_rcMarker.Height() - 2, PATINVERT);
  1476. pDC->PatBlt(m_rcMarker.left + 2, m_rcMarker.top + 2, m_rcMarker.Width() - 4, 2, PATINVERT);
  1477. pDC->PatBlt(m_rcMarker.right - 1, m_rcMarker.top, 1, m_rcMarker.Height(), PATINVERT);
  1478. pDC->PatBlt(m_rcMarker.right - 2, m_rcMarker.top + 1, 1, m_rcMarker.Height() - 2, PATINVERT);
  1480. }
  1481. else
  1482. {
  1483. pDC->PatBlt(m_rcMarker.left, m_rcMarker.top, m_rcMarker.Width(), 1, PATINVERT);
  1484. pDC->PatBlt(m_rcMarker.left + 1, m_rcMarker.top + 1, m_rcMarker.Width() - 2, 1, PATINVERT);
  1485. pDC->PatBlt(m_rcMarker.left + 2, m_rcMarker.top + 2, 2, m_rcMarker.Height() - 4, PATINVERT);
  1486. pDC->PatBlt(m_rcMarker.left, m_rcMarker.bottom - 1, m_rcMarker.Width(), 1, PATINVERT);
  1487. pDC->PatBlt(m_rcMarker.left + 1, m_rcMarker.bottom - 2, m_rcMarker.Width() - 2, 1, PATINVERT);
  1488. }
  1490. pDC->SelectObject(pBrush);
  1491. }
  1494. int CXTPCommandBar::FindAccel(TCHAR chAccel) const
  1495. {
  1496. for (int i = 0; i < GetControlCount(); i++)
  1497. {
  1498. CXTPControl* pControl = GetControl(i);
  1499. if (!pControl || pControl->GetParent() != this || !pControl->IsVisible())
  1500. continue;
  1502. CString strCaption = pControl->GetCaption();
  1503. int nAmdIndex = strCaption.Find(_T('&'));
  1504. if (nAmdIndex == -1 || nAmdIndex == strCaption.GetLength() - 1)
  1505. continue;
  1506. TCHAR ch = CXTPShortcutManager::ToUpper(strCaption[nAmdIndex + 1]);
  1507. if (chAccel == ch)
  1508. {
  1509. return pControl->GetIndex();
  1510. }
  1511. }
  1512. return -1;
  1513. }
  1516. int CXTPCommandBar::FindAccelEx(UINT chAccel, BOOL& bSelectOnly) const
  1517. {
  1518. int nItem = m_pControls->GetNext(m_nSelected, +1);
  1519. if (nItem == -1)
  1520. return -1;
  1522. bSelectOnly = FALSE;
  1524. int nStart = nItem;
  1526. int nAmpCondidate = -1, nCondidate = -1;
  1528. do
  1529. {
  1530. CXTPControl* pControl = GetControl(nItem);
  1531. ASSERT(pControl);
  1532. if (!pControl)
  1533. return -1;
  1535. CString strCaption = pControl->GetCaption();
  1536. if (!strCaption.IsEmpty() && pControl->GetEnabled())
  1537. {
  1538. int nAmpIndex = strCaption.Find(_T('&'));
  1539. BOOL bFound = nAmpIndex > -1 && nAmpIndex < strCaption.GetLength() - 1;
  1541. if (CXTPShortcutManager::CompareAccelKey(strCaption[bFound ? nAmpIndex + 1 : 0], chAccel))
  1542. {
  1543. if (bFound)
  1544. {
  1545. if (nAmpCondidate == -1)
  1546. nAmpCondidate = pControl->GetIndex();
  1547. else
  1548. {
  1549. bSelectOnly = TRUE;
  1550. return nAmpCondidate;
  1551. }
  1552. }
  1553. else
  1554. {
  1555. if (nCondidate == -1)
  1556. nCondidate = pControl->GetIndex();
  1557. else
  1558. {
  1559. bSelectOnly = TRUE;
  1560. }
  1561. }
  1562. }
  1563. }
  1564. nItem = m_pControls->GetNext(nItem, +1, TRUE, FALSE, FALSE);
  1565. }
  1566. while (nItem != nStart);
  1568. return nAmpCondidate != -1 ? nAmpCondidate : nCondidate;
  1569. }
  1571. CFrameWnd* CXTPCommandBar::GetFrameSite() const
  1572. {
  1573. CWnd* pSite = GetSite();
  1575. return pSite && pSite->IsFrameWnd() ? (CFrameWnd*)pSite : NULL;
  1576. }
  1578. CWnd* CXTPCommandBar::GetSite() const
  1579. {
  1580. CXTPCommandBars* pCommandBars = GetCommandBars();
  1581. if (pCommandBars)
  1582. return pCommandBars->GetSite();
  1584. CXTPCommandBar* pRoot = GetRootParent();
  1586. if (pRoot->m_pSite) return pRoot->m_pSite;
  1587. if (pRoot->m_hWnd) return pRoot->GetOwner();
  1589. return AfxGetMainWnd();
  1590. }
  1592. CWnd* CXTPCommandBar::GetOwnerSite() const
  1593. {
  1594. CXTPCommandBar* pRoot = (CXTPCommandBar*)this;
  1595. CXTPCommandBar* pParent = pRoot->GetParentCommandBar();
  1597. while (pRoot)
  1598. {
  1599. if (pRoot->m_pOwner != NULL)
  1600. return pRoot->m_pOwner;
  1602. if (pRoot->m_hWndOwner != NULL)
  1603. return CWnd::FromHandle(pRoot->m_hWndOwner);
  1605. if (!pParent)
  1606. return pRoot->GetSite();
  1608. pRoot = pParent;
  1609. pParent = pRoot->GetParentCommandBar();
  1610. }
  1612. ASSERT(FALSE);
  1613. return NULL;
  1614. }
  1616. CXTPCommandBar* CXTPCommandBar::GetRootParent() const
  1617. {
  1618. CXTPCommandBar* pRoot = (CXTPCommandBar*)this;
  1619. CXTPCommandBar* pParent = pRoot->GetParentCommandBar();
  1621. while (pParent != NULL)
  1622. {
  1623. pRoot = pParent;
  1624. pParent = pRoot->GetParentCommandBar();
  1625. }
  1627. return pRoot;
  1628. }
  1630. CXTPCommandBars* CXTPCommandBar::GetCommandBars() const
  1631. {
  1632. const CXTPCommandBar* pCommandBar = this;
  1633. do
  1634. {
  1635. if (pCommandBar->m_pCommandBars)
  1636. return pCommandBar->m_pCommandBars;
  1638. pCommandBar = pCommandBar->GetParentCommandBar();
  1640. }
  1641. while (pCommandBar != NULL);
  1643. return NULL;
  1644. }
  1646. BOOL CXTPCommandBar::IsCustomizeMode() const
  1647. {
  1648. CXTPCommandBars* pCommandBars = GetCommandBars();
  1649. return pCommandBars ? pCommandBars->IsCustomizeMode() : FALSE;
  1650. }
  1653. DROPEFFECT CXTPCommandBar::OnCustomizeDragEnter(CXTPControl* pDataObject, CPoint point)
  1654. {
  1655. m_rcMarker.SetRectEmpty();
  1657. return OnCustomizeDragOver(pDataObject, point);
  1658. }
  1660. void CXTPCommandBar::OnCustomizeDragLeave()
  1661. {
  1662. if (!m_rcMarker.IsRectEmpty())
  1663. {
  1664. m_rcMarker.SetRectEmpty();
  1665. Redraw();
  1666. }
  1667. }
  1669. void CXTPCommandBar::CustomizeFindDropIndex(CXTPControl* pDataObject, const CPoint& point,
  1670. CRect& rcMarker, int& nDropIndex, BOOL& bDropAfter)
  1671. {
  1673. CXTPControl* pControlMarker = NULL;
  1674. int nOffset = -1;
  1675. int nCount = GetControlCount();
  1677. BOOL bVert = (m_barPosition == xtpBarLeft || m_barPosition == xtpBarRight || m_barType == xtpBarTypePopup);
  1679. for (int i = 0; i < nCount; i++)
  1680. {
  1681. CXTPControl* pControl = GetControl(i);
  1683. if (!pControl->IsVisible() || !pControl->IsCustomizeMovable())
  1684. continue;
  1686. CRect rc = pControl->GetRect();
  1688. if (!m_bMultiLine)
  1689. {
  1690. if (pControl->GetWrap())
  1691. {
  1692. nOffset = -1;
  1693. if (!bVert && rc.top > point.y) break;
  1694. else if (bVert && rc.right < point.x) break;
  1695. }
  1696. }
  1697. else if (!bVert)
  1698. {
  1699. if (point.y < rc.top || point. y > rc.bottom)
  1700. continue;
  1701. }
  1702. else
  1703. {
  1704. if (point.x < rc.left || point. x > rc.right)
  1705. continue;
  1706. }
  1708. if (bVert)
  1709. {
  1710. if (nOffset == -1 || nOffset > abs(rc.CenterPoint().y - point.y))
  1711. {
  1712. nOffset = abs(rc.CenterPoint().y - point.y);
  1713. pControlMarker = pControl;
  1715. bDropAfter = rc.CenterPoint().y < point.y;
  1717. if (bDropAfter)
  1718. {
  1719. if (i >= nCount - 1 || GetControl(i + 1)->GetBeginGroup())
  1720. rcMarker.SetRect(rc.left, rc.bottom - 6, rc.right, rc.bottom);
  1721. else
  1722. rcMarker.SetRect(rc.left, rc.bottom, rc.right, rc.bottom + 6);
  1723. }
  1724. else
  1725. {
  1726. rcMarker.SetRect(rc.left, rc.top, rc.right, rc.top + 6);
  1728. }
  1730. }
  1732. }
  1733. else
  1734. {
  1735. if (nOffset == -1 || nOffset > abs(rc.CenterPoint().x - point.x))
  1736. {
  1737. nOffset = abs(rc.CenterPoint().x - point.x);
  1738. pControlMarker = pControl;
  1740. bDropAfter = rc.CenterPoint().x < point.x;
  1742. if (bDropAfter)
  1743. {
  1744. if (i >= nCount - 1 || GetControl(i + 1)->GetBeginGroup() || GetControl(i + 1)->GetWrap())
  1745. rcMarker.SetRect(rc.right - 6, rc.top, rc.right, rc.bottom);
  1746. else
  1747. rcMarker.SetRect(rc.right, rc.top, rc.right + 6, rc.bottom);
  1748. }
  1749. else
  1750. {
  1751. rcMarker.SetRect(rc.left, rc.top, rc.left + 6, rc.bottom);
  1752. }
  1753. }
  1754. }
  1755. m_bVerticalMarker = bVert;
  1756. }
  1758. if (pControlMarker == NULL)
  1759. {
  1760. CRect rc;
  1761. GetClientRect(&rc);
  1762. if (IsRibbonBar())
  1763. {
  1764. rcMarker.SetRectEmpty();
  1765. }
  1766. else
  1767. {
  1768. rcMarker.SetRect(rc.left + 2, rc.top + 2, rc.left + 8, rc.bottom - 2);
  1769. bDropAfter = TRUE;
  1770. }
  1771. nDropIndex = -1;
  1772. m_bVerticalMarker = FALSE;
  1773. }
  1774. else
  1775. {
  1776. nDropIndex = pControlMarker->GetIndex();
  1777. }
  1779. if (pDataObject == pControlMarker)
  1780. rcMarker.SetRectEmpty();
  1781. }
  1784. DROPEFFECT CXTPCommandBar::OnCustomizeDragOver(CXTPControl* pDataObject, CPoint point)
  1785. {
  1786. if (!IsCustomizable() || !(GetStyle() & WS_VISIBLE))
  1787. return DROPEFFECT_NONE;
  1789. ASSERT(pDataObject);
  1791. CRect rcMarker;
  1792. int nDropIndex;
  1793. BOOL bDropAfter;
  1794. CustomizeFindDropIndex (pDataObject, point, rcMarker, nDropIndex, bDropAfter);
  1796. DROPEFFECT dropEffect = (DROPEFFECT)-1;
  1798. CXTPControl* pControl = m_pControls->HitTest(point);
  1799. if (pControl)
  1800. {
  1801. if (GetParentCommandBar() == NULL && m_nPopuped != pControl->GetIndex())
  1802. {
  1803. XTPMouseManager()->SendTrackLost();
  1804. }
  1806. pControl->OnCustomizeDragOver(pDataObject, point, dropEffect);
  1807. }
  1809. if (!pDataObject->IsCustomizeDragOverAvail(this, point, dropEffect))
  1810. return DROPEFFECT_NONE;
  1812. m_rcMarker = rcMarker;
  1814. Redraw();
  1816. return dropEffect;
  1817. }
  1819. void CXTPCommandBar::OnCustomizeDrop(CXTPControl* pDataObject, DROPEFFECT& dropEffect, CPoint ptDrop, CPoint ptDrag)
  1820. {
  1821. CXTPCommandBars* pCommandBars = GetCommandBars();
  1822. ASSERT(pCommandBars);
  1823. if (!pCommandBars)
  1824. return;
  1826. CRect rcMarker;
  1827. int nDropIndex;
  1828. BOOL bDropAfter;
  1830. CustomizeFindDropIndex (pDataObject, ptDrop, rcMarker, nDropIndex, bDropAfter);
  1832. if (nDropIndex == -1 || pDataObject != GetControl(nDropIndex))
  1833. {
  1834. if (bDropAfter) nDropIndex++;
  1836. SetPopuped(-1);
  1837. SetSelected(-1);
  1839. BOOL bBeginGroup = FALSE;
  1840. if (bDropAfter == FALSE && nDropIndex >= 0 && nDropIndex < GetControlCount())
  1841. {
  1842. bBeginGroup = GetControl(nDropIndex)->GetBeginGroup();
  1843. if (bBeginGroup)
  1844. {
  1845. GetControl(nDropIndex)->SetBeginGroup(FALSE);
  1846. }
  1847. }
  1849. CXTPControl* pClone = m_pControls->AddClone(pDataObject, nDropIndex);
  1850. pClone->SetBeginGroup(bBeginGroup);
  1851. pCommandBars->SetDragControl(pClone);
  1853. }
  1854. else
  1855. {
  1856. if (abs(ptDrag.x - ptDrop.x) > 4 || abs(ptDrag.y - ptDrop.y) > 4)
  1857. {
  1858. CXTPControl* pControl = GetControl(nDropIndex);
  1859. ASSERT(pDataObject == pControl);
  1860. pControl->SetBeginGroup(bDropAfter && nDropIndex != 0);
  1861. }
  1863. dropEffect = DROPEFFECT_CANCEL;
  1864. }
  1865. OnRecalcLayout();
  1867. m_rcMarker.SetRectEmpty();
  1868. Redraw();
  1869. }
  1871. void CXTPCommandBar::OnRButtonDown(UINT nFlags, CPoint point)
  1872. {
  1873. CXTPControl* pControl = m_pControls->HitTest(point);
  1874. if (pControl && pControl->OnRButtonDown(point))
  1875. return;
  1877. if (pControl && m_bCustomizable && IsCustomizeMode())
  1878. {
  1879. if (pControl->IsVisible() && pControl->IsCustomizeMovable())
  1880. {
  1881. SetPopuped(-1);
  1882. SetSelected(-1);
  1884. CXTPCommandBars* pCommandBars = GetCommandBars();
  1885. ASSERT(pCommandBars);
  1886. CXTPCustomizeDropSource* pDropSource = pCommandBars->GetDropSource();
  1887. ASSERT(pDropSource);
  1889. pCommandBars->SetDragControl(pControl);
  1891. if (pDropSource->GetSheet())
  1892. {
  1893. ClientToScreen(&point);
  1894. pDropSource->GetSheet()->ContextMenu(point);
  1895. }
  1896. }
  1897. return;
  1898. }
  1900. CWnd::OnRButtonDown(nFlags, point);
  1901. }
  1903. void CXTPCommandBar::InvalidateParents()
  1904. {
  1905. Redraw();
  1906. CXTPCommandBar* pCommandBar = GetParentCommandBar();
  1907. if (pCommandBar) pCommandBar->InvalidateParents();
  1908. }
  1910. void CXTPCommandBar::OnControlSelected(BOOL bSelected, CXTPControl* pControl)
  1911. {
  1912. if (!pControl)
  1913. return;
  1915. GetSite()->SendMessage(WM_XTP_CONTROLSELECTED, bSelected ? (WPARAM)pControl : 0);
  1917. CXTPCommandBars* pCommandBars = GetCommandBars();
  1918. if (pCommandBars)
  1919. {
  1920. pCommandBars->m_nIDHelpTracking = bSelected ? pControl->GetHelpId() : 0;
  1921. }
  1924. if (pControl && (pControl->GetIndex() == m_nClickedControl))
  1925. {
  1926. if (!bSelected)
  1927. m_nClickedControl = -1;
  1928. return;
  1929. }
  1930. m_nClickedControl = -1;
  1932. SetStatusText(bSelected ? pControl->GetDescription() : _T(""));
  1933. }
  1935. BOOL CXTPCommandBar::SetStatusText(const CString& strDescription)
  1936. {
  1937. CXTPCommandBars* pCommandBars = GetCommandBars();
  1938. CWnd* pOwner = pCommandBars ? pCommandBars->GetSite() : GetSite();
  1940. if (pCommandBars && !pCommandBars->GetCommandBarsOptions()->bFlyByStatus)
  1941. return TRUE;
  1943. if (strDescription.IsEmpty())
  1944. {
  1945. pOwner->SendMessage(WM_POPMESSAGESTRING, AFX_IDS_IDLEMESSAGE);
  1946. }
  1947. else
  1948. {
  1949. pOwner->SendMessage(WM_SETMESSAGESTRING, 0, (LPARAM)(LPCTSTR)strDescription);
  1950. }
  1951. return TRUE;
  1952. }
  1956. void CXTPCommandBar::SetPaintManager(CXTPPaintManager* pPaintManager)
  1957. {
  1958. if (m_pPaintManager)
  1959. m_pPaintManager->InternalRelease();
  1961. m_pPaintManager = pPaintManager;
  1963. if (m_pPaintManager)
  1964. {
  1965. m_pPaintManager->RefreshMetrics();
  1966. }
  1967. }
  1969. CXTPPaintManager* CXTPCommandBar::GetPaintManager() const
  1970. {
  1971. if (m_pPaintManager)
  1972. return m_pPaintManager;
  1974. CXTPCommandBars* pCommandBars = GetCommandBars();
  1975. if (pCommandBars)
  1976. return pCommandBars->GetPaintManager();
  1978. CXTPCommandBar* pRoot = GetRootParent();
  1979. if (pRoot->m_pPaintManager)
  1980. return pRoot->m_pPaintManager;
  1982. return XTPPaintManager();
  1983. }
  1985. void CXTPCommandBar::SetImageManager(CXTPImageManager* pImageManager)
  1986. {
  1987. if (m_pImageManager)
  1988. m_pImageManager->InternalRelease();
  1990. m_pImageManager = pImageManager;
  1992. }
  1994. CXTPImageManager* CXTPCommandBar::GetImageManager() const
  1995. {
  1996. if (m_pImageManager)
  1997. return m_pImageManager;
  1999. CXTPCommandBars* pCommandBars = GetCommandBars();
  2000. if (pCommandBars)
  2001. return pCommandBars->GetImageManager();
  2003. CXTPCommandBar* pRoot = GetRootParent();
  2004. if (pRoot->m_pImageManager)
  2005. return pRoot->m_pImageManager;
  2007. return XTPImageManager();
  2008. }
  2011. void CXTPCommandBar::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive)
  2012. {
  2013. m_barType = pCommandBar->m_barType;
  2014. m_barPosition = pCommandBar->m_barPosition;
  2015. m_nBarID = pCommandBar->m_nBarID;
  2016. m_dwFlags = pCommandBar->m_dwFlags;
  2017. m_dwStyle = pCommandBar->m_dwStyle;
  2018. m_strTitle = pCommandBar->m_strTitle;
  2019. m_bCustomizable = pCommandBar->m_bCustomizable;
  2020. m_nMRUWidth = pCommandBar->m_nMRUWidth;
  2021. m_szIcons = pCommandBar->m_szIcons;
  2022. m_szButtons = pCommandBar->m_szButtons;
  2023. m_pCommandBars = pCommandBar->m_pCommandBars;
  2024. m_buttonStyle = pCommandBar->m_buttonStyle;
  2026. m_pControls->Copy(pCommandBar->GetControls(), bRecursive);
  2027. }
  2029. UINT CXTPCommandBar::GetActiveDocTemplate() const
  2030. {
  2031. CXTPCommandBars* pCommandBars = GetCommandBars();
  2032. if (!pCommandBars)
  2033. return 0;
  2035. return pCommandBars->GetActiveDocTemplate();
  2036. }
  2038. void CXTPCommandBar::UpdateDocTemplateControls()
  2039. {
  2040. UINT nIDResource = GetActiveDocTemplate();
  2042. if (nIDResource == 0)
  2043. return;
  2045. BOOL bRecalcLayout = FALSE;
  2046. BOOL bValue;
  2048. for (int i = 0; i < GetControlCount(); i++)
  2049. {
  2050. CXTPControl* pControl = GetControl(i);
  2051. if (!pControl || pControl->GetParent() != this)
  2052. continue;
  2054. if (pControl->m_mapDocTemplatesAssigned.GetCount() > 0)
  2055. {
  2056. BOOL bVisible = pControl->m_mapDocTemplatesAssigned.Lookup(nIDResource, bValue);
  2057. if (pControl->SetHideFlag(xtpHideDocTemplate, !bVisible)) bRecalcLayout = TRUE;
  2059. }
  2060. if (pControl->m_mapDocTemplatesExcluded.GetCount() > 0)
  2061. {
  2062. BOOL bVisible = !pControl->m_mapDocTemplatesExcluded.Lookup(nIDResource, bValue);
  2063. if (pControl->SetHideFlag(xtpHideDocTemplate, !bVisible)) bRecalcLayout = TRUE;
  2064. }
  2065. }
  2067. if (bRecalcLayout)
  2068. m_nIdleFlags |= xtpIdleLayout;
  2069. }
  2071. void CXTPCommandBar::SetFlags(DWORD dwFlagsAdd, DWORD dwFlagsRemove)
  2072. {
  2073. m_dwFlags |= dwFlagsAdd;
  2074. m_dwFlags &= ~dwFlagsRemove;
  2075. }
  2078. LRESULT CXTPCommandBar::OnHelpHitTest(WPARAM, LPARAM lParam)
  2079. {
  2080. ASSERT_VALID(this);
  2082. CXTPControl* pControl = m_pControls->HitTest(CPoint((DWORD)lParam));
  2084. if (pControl != NULL)
  2085. return HID_BASE_COMMAND + pControl->GetHelpId();
  2087. UINT nID = _AfxGetDlgCtrlID(m_hWnd);
  2088. return nID != 0 ? HID_BASE_CONTROL + nID : 0;
  2089. }
  2091. LRESULT CXTPCommandBar::OnNcHitTest(CPoint point)
  2092. {
  2093. if (IsHelpMode())
  2094. {
  2095. ScreenToClient(&point);
  2097. CXTPControl* pControl = m_pControls->HitTest(point);
  2098. if (pControl && pControl->GetID() <= 0 && IsPopupControlType(pControl->GetType()))
  2099. return HTMENU;
  2101. return HTCLIENT;
  2102. }
  2104. return (LRESULT)CWnd::OnNcHitTest(point);
  2106. }
  2108. void CXTPCommandBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
  2109. {
  2110. if (IsHelpMode())
  2111. {
  2112. ScreenToClient(&point);
  2113. OnLButtonDown(0, point);
  2114. return;
  2115. }
  2116. CWnd::OnNcLButtonDown(nHitTest, point);
  2117. }
  2119. void CXTPCommandBar::SetWidth(int nWidth)
  2120. {
  2121. m_nMRUWidth = nWidth;
  2122. }
  2124. int CXTPCommandBar::GetWidth() const
  2125. {
  2126. return m_nMRUWidth;
  2127. }
  2129. BOOL CXTPCommandBar::IsLayoutRTL() const
  2130. {
  2131. return m_hWnd && GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_RTLREADING);
  2132. }
  2134. int CXTPCommandBar::OnMouseHitTest(CPoint pt)
  2135. {
  2136. CXTPWindowRect rcWindow(this);
  2137. if (!rcWindow.PtInRect(pt))
  2138. return HTNOWHERE;
  2140. if (GetPosition() != xtpBarPopup)
  2141. return HTCLIENT;
  2143. CRgn rgn;
  2144. rgn.CreateRectRgn(0, 0, 0, 0);
  2145. int nRegion = GetWindowRgn(rgn);
  2146. if (nRegion == ERROR || nRegion == NULLREGION)
  2147. return HTCLIENT;
  2149. pt.Offset(-rcWindow.TopLeft());
  2150. if (!::PtInRegion(rgn, pt.x, pt.y))
  2151. return HTNOWHERE;
  2153. return HTCLIENT;
  2154. }
  2157. //////////////////////////////////////////////////////////////////////////
  2158. //
  2160. CCmdTarget* CXTPCommandBar::GetAccessible()
  2161. {
  2162. return this;
  2163. }
  2165. HRESULT CXTPCommandBar::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  2166. {
  2167. *ppdispParent = NULL;
  2169. CXTPPopupBar* pPopupBar = DYNAMIC_DOWNCAST(CXTPPopupBar, this);
  2170. if (pPopupBar)
  2171. {
  2172. if (pPopupBar->m_pControlPopup)
  2173. {
  2174. *ppdispParent = pPopupBar->m_pControlPopup->GetIDispatch(TRUE);
  2175. return S_OK;
  2176. }
  2178. }
  2179. else if (GetSafeHwnd())
  2180. {
  2181. return AccessibleObjectFromWindow(GetSafeHwnd(), OBJID_WINDOW, IID_IDispatch, (void**)ppdispParent);
  2182. }
  2183. return E_FAIL;
  2184. }
  2186. HRESULT CXTPCommandBar::GetAccessibleChildCount(long FAR* pChildCount)
  2187. {
  2188. if (pChildCount == 0)
  2189. return E_INVALIDARG;
  2191. *pChildCount = GetControlCount();
  2193. return S_OK;
  2194. }
  2195. HRESULT CXTPCommandBar::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  2196. {
  2197. *ppdispChild = NULL;
  2198. int nChild = GetChildIndex(&varChild);
  2200. if (nChild > 0 && nChild <= GetControlCount())
  2201. {
  2202. CXTPControl* pControl = GetControl(nChild - 1);
  2203. if (pControl)
  2204. {
  2205. *ppdispChild = pControl->GetIDispatch(TRUE);
  2206. }
  2207. }
  2209. return S_OK;
  2210. }
  2212. HRESULT CXTPCommandBar::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  2213. {
  2214. int nChild = GetChildIndex(&varChild);
  2216. if (nChild == CHILDID_SELF || nChild == -1)
  2217. {
  2218. CString strCaption = GetTitle();
  2219. *pszName = strCaption.AllocSysString();
  2220. return S_OK;
  2221. }
  2223. if (nChild > 0 && nChild <= GetControlCount())
  2224. {
  2225. CXTPControl* pControl = GetControl(nChild - 1);
  2226. CString strCaption = pControl->GetCaption();
  2227. CXTPPaintManager::StripMnemonics(strCaption);
  2229. if (!pControl->GetShortcutText().IsEmpty())
  2230. strCaption = strCaption + _T('t') + pControl->GetShortcutText();
  2232. *pszName = strCaption.AllocSysString();
  2233. return S_OK;
  2234. }
  2235. return E_INVALIDARG;
  2236. }
  2238. HRESULT CXTPCommandBar::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  2239. {
  2240. pvarRole->vt = VT_EMPTY;
  2241. int nChild = GetChildIndex(&varChild);
  2243. if (nChild == CHILDID_SELF)
  2244. {
  2245. pvarRole->vt = VT_I4;
  2246. pvarRole->lVal = GetType() == xtpBarTypeMenuBar ? ROLE_SYSTEM_MENUBAR :
  2247. GetType() == xtpBarTypePopup ? ROLE_SYSTEM_MENUPOPUP : ROLE_SYSTEM_TOOLBAR;
  2248. return S_OK;
  2249. }
  2251. if (nChild > 0)
  2252. {
  2253. pvarRole->vt = VT_I4;
  2254. pvarRole->lVal = ROLE_SYSTEM_MENUITEM;
  2255. return S_OK;
  2256. }
  2258. return E_INVALIDARG;
  2259. }
  2261. HRESULT CXTPCommandBar::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  2262. {
  2263. pvarState->vt = VT_I4;
  2264. pvarState->lVal = 0;
  2265. int nChild = GetChildIndex(&varChild);
  2267. if (!IsVisible())
  2268. pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
  2270. if (nChild > 0 && nChild <= GetControlCount())
  2271. {
  2272. pvarState->lVal |= STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_SELECTABLE |
  2273. (m_nSelected == nChild - 1 ? STATE_SYSTEM_FOCUSED | STATE_SYSTEM_SELECTED | STATE_SYSTEM_HOTTRACKED : 0);
  2274. }
  2276. return S_OK;
  2277. }
  2280. HRESULT CXTPCommandBar::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  2281. {
  2282. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  2284. if (!GetSafeHwnd())
  2285. return S_OK;
  2287. CRect rc;
  2288. GetWindowRect(&rc);
  2290. int nChild = GetChildIndex(&varChild);
  2292. if (nChild > 0 && nChild <= GetControlCount())
  2293. {
  2294. CXTPControl* pControl = GetControl(nChild - 1);
  2295. CRect rcControl = pControl->GetRect();
  2297. rc = CRect(CPoint(rc.left + rcControl.left, rc.top + rcControl.top), rcControl.Size());
  2299. }
  2301. *pxLeft = rc.left;
  2302. *pyTop = rc.top;
  2303. *pcxWidth = rc.Width();
  2304. *pcyHeight = rc.Height();
  2306. return S_OK;
  2307. }
  2309. HRESULT CXTPCommandBar::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  2310. {
  2311. if (pvarID == NULL)
  2312. return E_INVALIDARG;
  2314. pvarID->vt = VT_EMPTY;
  2316. if (!GetSafeHwnd())
  2317. return S_FALSE;
  2319. if (!CXTPWindowRect(this).PtInRect(CPoint(xLeft, yTop)))
  2320. return S_FALSE;
  2322. pvarID->vt = VT_I4;
  2323. pvarID->lVal = 0;
  2325. CPoint pt(xLeft, yTop);
  2326. ScreenToClient(&pt);
  2328. CXTPControl* pControl = GetControls()->HitTest(pt);
  2329. if (pControl)
  2330. {
  2331. pvarID->vt = VT_DISPATCH;
  2332. pvarID->pdispVal = pControl->GetIDispatch(TRUE);
  2333. }
  2335. return S_OK;
  2336. }
  2339. LRESULT CXTPCommandBar::OnGetObject(WPARAM wParam, LPARAM lParam)
  2340. {
  2341. if (lParam > 0 && lParam < 0xFFFFFF)
  2342. {
  2343. CXTPControl* pControl = GetControls()->FindControl((int)lParam);
  2344. if (pControl)
  2345. {
  2346. LPUNKNOWN lpUnknown = pControl->GetInterface(&IID_IAccessible);
  2347. if (!lpUnknown)
  2348. return E_FAIL;
  2350. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  2351. }
  2352. }
  2354. if (lParam != OBJID_CLIENT && lParam != OBJID_MENU)
  2355. return (LRESULT)Default();
  2357. LPUNKNOWN lpUnknown = GetInterface(&IID_IAccessible);
  2358. if (!lpUnknown)
  2359. return E_FAIL;
  2361. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  2362. }
  2364. void CXTPCommandBar::FilterToolTipMessage(UINT message, WPARAM wParam, LPARAM lParam)
  2365. {
  2366. if (m_pToolTipContext)
  2367. {
  2368. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  2369. }
  2370. }
  2372. BOOL CXTPCommandBar::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  2373. {
  2374. FilterToolTipMessage(message, wParam, lParam);
  2376. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  2377. }
  2383. BEGIN_INTERFACE_MAP(CXTPCommandBar, CCmdTarget)
  2384. INTERFACE_PART(CXTPCommandBar, IID_IAccessible, ExternalAccessible)
  2385. END_INTERFACE_MAP()