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

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

对话框与窗口

开发平台：

Visual C++

XTPControl.cpp：源码内容
  1. // XTPControl.cpp : implementation of the CXTPControl 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"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPImageManager.h"
  28. #include "XTPControl.h"
  29. #include "XTPControls.h"
  30. #include "XTPMouseManager.h"
  31. #include "XTPCommandBar.h"
  32. #include "XTPPaintManager.h"
  33. #include "XTPToolbar.h"
  34. #include "XTPCommandBars.h"
  35. #include "XTPPopupBar.h"
  36. #include "XTPCustomizeTools.h"
  37. #include "XTPSoundManager.h"
  41. #ifdef _DEBUG
  42. #define new DEBUG_NEW
  43. #undef THIS_FILE
  44. static char THIS_FILE[] = __FILE__;
  45. #endif
  47. IMPLEMENT_DYNAMIC(CXTPControlAction, CCmdTarget)
  49. //////////////////////////////////////////////////////////////////////////
  50. // CXTPControlAction
  52. CXTPControlAction::CXTPControlAction(CXTPControlActions* pActions)
  53. {
  55. m_nId = 0;
  56. m_nIconId = 0;
  57. m_nHelpId = 0;
  58. m_nTag = 0;
  59. m_bVisible = TRUE;
  60. m_bChecked = FALSE;
  61. m_bEnabled = TRUE;
  63. m_pTarget = NULL;
  65. m_pActions = pActions;
  66. }
  68. CXTPControlAction::~CXTPControlAction()
  69. {
  70. ASSERT(m_arrControls.GetSize() == 0);
  72. if (m_pTarget)
  73. {
  74. CMDTARGET_RELEASE(m_pTarget);
  75. }
  76. }
  78. void CXTPControlAction::AddControl(CXTPControl* pControl)
  79. {
  80. for (int i = 0; i < m_arrControls.GetSize(); i++)
  81. {
  82. if (m_arrControls[i] == pControl)
  83. return;
  84. }
  86. m_arrControls.Add(pControl);
  88. pControl->m_bEnabled = -1;
  89. pControl->m_bChecked = -1;
  90. pControl->m_nId = m_nId;
  92. pControl->m_strCaption.Empty();
  93. pControl->m_strTooltipText.Empty();
  94. pControl->m_strDescriptionText.Empty();
  95. pControl->m_strCategory.Empty();
  96. pControl->m_strShortcutText.Empty();
  97. pControl->m_strKeyboardTip.Empty();
  98. }
  101. void CXTPControlAction::RemoveControl(CXTPControl* pControl)
  102. {
  103. for (int i = 0; i < m_arrControls.GetSize(); i++)
  104. {
  105. if (m_arrControls[i] == pControl)
  106. {
  107. m_arrControls.RemoveAt(i);
  109. pControl->m_bEnabled = TRUE;
  110. pControl->m_bChecked = FALSE;
  111. return;
  112. }
  113. }
  114. }
  116. void CXTPControlAction::OnChanged(int nProperty)
  117. {
  118. for (int i = 0; i < m_arrControls.GetSize(); i++)
  119. {
  120. m_arrControls[i]->OnActionChanged(nProperty);
  121. }
  122. }
  124. void CXTPControlAction::OnChanging(int nProperty)
  125. {
  126. for (int i = 0; i < m_arrControls.GetSize(); i++)
  127. {
  128. m_arrControls[i]->OnActionChanging(nProperty);
  129. }
  130. }
  132. void CXTPControlAction::RedrawControls()
  133. {
  134. for (int i = 0; i < m_arrControls.GetSize(); i++)
  135. {
  136. m_arrControls[i]->RedrawParent();
  137. }
  138. }
  140. void CXTPControlAction::RepositionControls()
  141. {
  142. for (int i = 0; i < m_arrControls.GetSize(); i++)
  143. {
  144. m_arrControls[i]->DelayLayoutParent();
  145. }
  146. }
  148. void CXTPControlAction::OnRemoved()
  149. {
  150. while (m_arrControls.GetSize() > 0)
  151. {
  152. m_arrControls[0]->SetAction(NULL);
  153. }
  154. }
  156. void CXTPControlAction::SetCaption(UINT nIDCaption)
  157. {
  158. CString strCaption;
  159. if (strCaption.LoadString(nIDCaption))
  160. {
  161. SetCaption(strCaption);
  162. }
  163. }
  165. void CXTPControlAction::SetCaption(LPCTSTR lpszCaption)
  166. {
  167. CString strCaption(lpszCaption);
  168. int nShortCutPos = strCaption.Find ('t');
  169. if (nShortCutPos != -1)
  170. {
  171. strCaption.ReleaseBuffer(nShortCutPos);
  172. }
  174. if (m_strCaption != strCaption)
  175. {
  176. OnChanging(3);
  177. m_strCaption = strCaption;
  178. OnChanged(3);
  180. RepositionControls();
  181. }
  182. }
  184. void CXTPControlAction::SetEditHint(LPCTSTR lpszEditHint)
  185. {
  186. if (m_strEditHint != lpszEditHint)
  187. {
  188. OnChanging(4);
  189. m_strEditHint = lpszEditHint;
  190. OnChanged(4);
  191. }
  192. }
  194. void CXTPControlAction::SetPrompt(LPCTSTR lpszPrompt)
  195. {
  196. if (lpszPrompt == NULL || lpszPrompt[0] == _T(''))
  197. return;
  199. if (_tcschr(lpszPrompt, _T('n')) != NULL)
  200. {
  201. AfxExtractSubString(m_strTooltipText, lpszPrompt, 1);
  202. AfxExtractSubString(m_strDescriptionText, lpszPrompt, 0);
  203. }
  204. else
  205. {
  206. m_strDescriptionText = m_strTooltipText = lpszPrompt;
  207. }
  209. if (m_strKeyboardTip.IsEmpty())
  210. {
  211. AfxExtractSubString(m_strKeyboardTip, lpszPrompt, 3);
  212. }
  213. }
  215. BOOL CXTPControlAction::GetEnabled() const
  216. {
  217. if (GetCommandBars()->IsCustomizeMode())
  218. return TRUE;
  220. return m_bEnabled;
  221. }
  223. CXTPCommandBars* CXTPControlAction::GetCommandBars() const
  224. {
  225. return m_pActions->m_pCommandBars;
  226. }
  228. CXTPControl* CXTPControlAction::GetControl(int nIndex) const
  229. {
  230. return m_arrControls[nIndex];
  231. }
  233. int CXTPControlAction::GetCount() const
  234. {
  235. return (int)m_arrControls.GetSize();
  236. }
  239. //////////////////////////////////////////////////////////////////////////
  240. // CXTPControlActions
  242. CXTPControlActions::CXTPControlActions(CXTPCommandBars* pCommandBars)
  243. {
  244. m_pCommandBars = pCommandBars;
  246. }
  248. CXTPControlActions::~CXTPControlActions()
  249. {
  250. RemoveAll();
  251. }
  253. CXTPControlAction* CXTPControlActions::GetAt(int nIndex) const
  254. {
  255. return m_arrActions.GetAt(nIndex);
  256. }
  258. int CXTPControlActions::GetCount() const
  259. {
  260. return (int)m_arrActions.GetSize();
  261. }
  263. CXTPControlAction* CXTPControlActions::FindAction(int nId) const
  264. {
  265. if (nId <= 0 || nId >= 0xFFFFFFF)
  266. return NULL;
  268. int num = GetCount();
  269. if (num == 0)
  270. return NULL;
  272. CXTPControlAction* const* lo = m_arrActions.GetData();
  273. CXTPControlAction* const* hi = lo + (num - 1);
  274. CXTPControlAction* const* mid;
  276. while (lo <= hi)
  277. {
  278. int half = num / 2;
  279. if (half)
  280. {
  281. mid = lo + (num & 1 ? half : (half - 1));
  283. if ((*mid)->GetID() == nId)
  284. return (*mid);
  286. if ((*mid)->GetID() > nId)
  287. {
  288. hi = mid - 1;
  289. num = num & 1 ? half : half - 1;
  290. }
  291. else
  292. {
  293. lo = mid + 1;
  294. num = half;
  295. }
  296. }
  297. else if (num)
  298. return (*lo)->GetID() == nId ? (*lo) : NULL;
  299. else
  300. break;
  301. }
  303. return NULL;
  304. }
  306. void CXTPControlActions::RemoveAll()
  307. {
  308. for (int i = 0; i < GetCount(); i++)
  309. {
  310. CXTPControlAction* pAction = GetAt(i);
  312. pAction->OnRemoved();
  313. pAction->InternalRelease();
  314. }
  315. m_arrActions.RemoveAll();
  316. }
  318. void CXTPControlActions::Remove(int nId)
  319. {
  320. for (int i = 0; i < GetCount(); i++)
  321. {
  322. CXTPControlAction* pAction = GetAt(i);
  324. if (pAction->GetID() == nId)
  325. {
  326. m_arrActions.RemoveAt(i);
  327. pAction->OnRemoved();
  328. pAction->InternalRelease();
  329. return;
  330. }
  331. }
  332. }
  334. void CXTPControlActions::Insert(CXTPControlAction* pAction)
  335. {
  336. int nIndex = 0;
  337. for (; nIndex < GetCount(); nIndex++)
  338. {
  339. if (GetAt(nIndex)->GetID() > pAction->GetID())
  340. break;
  341. }
  343. m_arrActions.InsertAt(nIndex, pAction);
  344. }
  346. void CXTPControlActions::SetActionId(CXTPControlAction* pAction, int nId)
  347. {
  348. ASSERT(FindAction(nId) == NULL);
  349. pAction->m_nId = nId;
  350. }
  352. CXTPControlAction* CXTPControlActions::Add(int nId, CXTPControlAction* pAction)
  353. {
  354. SetActionId(pAction, nId);
  356. CString strPrompt;
  357. if (XTPResourceManager()->LoadString(&strPrompt, nId))
  358. {
  359. pAction->SetPrompt(strPrompt);
  360. }
  362. Insert(pAction);
  364. return pAction;
  365. }
  367. CXTPControlAction* CXTPControlActions::Add(int nId)
  368. {
  369. CXTPControlAction* pAction = FindAction(nId);
  370. if (pAction)
  371. return pAction;
  373. pAction = new CXTPControlAction(this);
  374. return Add(nId, pAction);
  375. }
  377. void CXTPControlActions::CreateFromMenu(CMenu* pMenu)
  378. {
  379. int nCount = ::GetMenuItemCount(pMenu->m_hMenu);
  381. for (int nIndex = 0; nIndex < nCount; nIndex++)
  382. {
  383. // Check to see if the item is a separator, we don't want
  384. // to use GetMenuItemID(i) because it may not equal zero.
  386. MENUITEMINFO info = { sizeof(MENUITEMINFO), MIIM_TYPE | MIIM_STATE};
  387. ::GetMenuItemInfo(pMenu->m_hMenu, nIndex, TRUE, &info);
  389. int nID = (int)pMenu->GetMenuItemID(nIndex);
  390. BOOL bSeparator = ((info.fType & MFT_SEPARATOR) == MFT_SEPARATOR) || (nID == 0);
  392. if (!bSeparator)
  393. {
  394. CMenu* pPopupMenu = pMenu->GetSubMenu(nIndex);
  396. CString strCaption;
  397. XTPResourceManager()->GetMenuLocaleString(pMenu, nIndex, strCaption, MF_BYPOSITION);
  399. if (pPopupMenu)
  400. {
  401. nID = 0;
  402. }
  404. int iPos = strCaption.Find(_T('t'));
  405. if (pPopupMenu &&  iPos > 0)
  406. {
  407. nID = _ttoi(strCaption.Mid(iPos + 1));
  408. strCaption.ReleaseBuffer(iPos);
  409. }
  411. if (nID > 0)
  412. {
  413. CXTPControlAction* pAction = Add(nID);
  415. pAction->SetCaption(strCaption);
  417. CString strPrompt;
  418. if (XTPResourceManager()->LoadString(&strPrompt, nID))
  419. {
  420. pAction->SetPrompt(strPrompt);
  421. }
  422. }
  424. if (pPopupMenu)
  425. {
  426. CreateFromMenu(pPopupMenu);
  427. }
  428. }
  429. }
  430. }
  433. //////////////////////////////////////////////////////////////////////////
  434. // CXTPControl
  436. CXTPControl::CXTPControl()
  437. {
  438. EnableAutomation();
  441. m_nId = 0;
  442. m_nIconId = 0;
  443. m_nHelpId = 0;
  444. m_nCustomIconId = 0;
  445. m_nTag = 0;
  446. m_nIndex = 0;
  447. m_dwFlags = 0;
  448. m_rcControl.SetRectEmpty();
  449. m_rcRow.SetRectEmpty();
  451. m_pParent = 0;
  452. m_pControls = 0;
  453. m_bExpanded = FALSE;
  455. m_bChecked = FALSE;
  456. m_bEnabled = TRUE;
  457. m_bBeginGroup = FALSE;
  458. m_bEnabled = TRUE;
  459. m_bTemporary = FALSE;
  460. m_bSelected = FALSE;
  461. m_bPressed = FALSE;
  463. m_bWrap = FALSE;
  465. m_dwHideFlags = xtpNoHide;
  466. m_controlType = xtpControlError;
  468. m_bDefaultItem = FALSE;
  469. m_buttonStyle = xtpButtonAutomatic;
  470. m_buttonCustomStyle = xtpButtonUndefined;
  471. m_buttonRibbonStyle = xtpButtonAutomatic;
  473. m_bCloseSubMenuOnClick = TRUE;
  475. m_pRibbonGroup = NULL;
  477. m_pAction = 0;
  479. m_nWidth = 0;
  480. m_nHeight = 0;
  481. m_szIcon = CSize(0, 0);
  483. m_nExecuteOnPressInterval = 0;
  484. }
  486. CXTPControl::~CXTPControl()
  487. {
  488. if (m_pAction)
  489. {
  490. m_pAction->RemoveControl(this);
  491. m_pAction = NULL;
  492. }
  493. }
  495. void CXTPControl::SetAction(CXTPControlAction* pAction)
  496. {
  497. if (m_pAction)
  498. {
  499. m_pAction->RemoveControl(this);
  500. m_pAction = NULL;
  501. }
  503. if (pAction)
  504. {
  505. m_pAction = pAction;
  506. m_pAction->AddControl(this);
  507. }
  508. }
  510. void CXTPControl::OnRemoved()
  511. {
  512. SetAction(NULL);
  513. }
  515. XTPButtonStyle CXTPControl::GetStyle() const
  516. {
  517. return m_buttonCustomStyle != xtpButtonUndefined ? m_buttonCustomStyle :
  518. m_buttonStyle != xtpButtonAutomatic ? m_buttonStyle :
  519. m_buttonRibbonStyle != xtpButtonAutomatic || !m_pParent ? m_buttonRibbonStyle : m_pParent->GetDefaultButtonStyle();
  520. }
  522. CSize CXTPControl::GetSize(CDC* pDC)
  523. {
  524. return GetPaintManager()->DrawControl(pDC, this, FALSE);
  525. }
  527. void CXTPControl::Draw(CDC* pDC)
  528. {
  529. GetPaintManager()->DrawControl(pDC, this);
  530. }
  532. void CXTPControl::DelayRedrawParent()
  533. {
  534. if (m_pParent && IsWindow(m_pParent->GetSafeHwnd()))
  535. ((CXTPCommandBar*)m_pParent)->DelayRedraw();
  536. }
  538. void CXTPControl::DelayLayoutParent()
  539. {
  540. if (m_pParent) m_pParent->DelayLayout();
  541. }
  543. void CXTPControl::RedrawParent(BOOL bAnimate)
  544. {
  545. if (!IsVisible())
  546. return;
  548. if (m_pParent) m_pParent->Redraw(GetRect(), bAnimate);
  549. }
  551. void CXTPControl::ScreenToClient(CPoint* point)
  552. {
  553. ASSERT(m_pParent);
  554. if (m_pParent)
  555. ((CWnd*)m_pParent)->ScreenToClient(point);
  556. }
  559. BOOL CXTPControl::OnSetSelected(int bSelected)
  560. {
  561. if (bSelected == m_bSelected)
  562. return FALSE;
  564. if (IsKeyboardSelected(bSelected) && m_pParent->m_nPopuped != GetIndex())
  565. m_pParent->SetPopuped(-1);
  567. m_bSelected = bSelected;
  569. m_pParent->OnControlSelected(bSelected, this);
  571. if (GetEnabled() || IsKeyboardSelected(bSelected) || !bSelected)
  572. RedrawParent(!bSelected);
  574. return TRUE;
  575. }
  577. void CXTPControl::OnMouseHover()
  578. {
  579. if (m_pParent->SetPopuped(-1))
  580. {
  581. if (m_pParent->IsTrackingMode() == TRUE_POPUP && m_pParent->GetPosition() != xtpBarPopup)
  582. m_pParent->SetTrackingMode(FALSE);
  583. }
  584. }
  586. void CXTPControl::SetPrompt(LPCTSTR lpszPrompt)
  587. {
  588. if (lpszPrompt == NULL || lpszPrompt[0] == _T(''))
  589. return;
  591. if (_tcschr(lpszPrompt, _T('n')) != NULL)
  592. {
  593. AfxExtractSubString(m_strTooltipText, lpszPrompt, 1);
  594. AfxExtractSubString(m_strDescriptionText, lpszPrompt, 0);
  595. }
  596. else
  597. {
  598. m_strDescriptionText = m_strTooltipText = lpszPrompt;
  599. }
  601. if (m_strCaption.IsEmpty())
  602. {
  603. if (!AfxExtractSubString(m_strCaption, lpszPrompt, 2))
  604. {
  605. m_strCaption = m_strTooltipText;
  606. OnCaptionChanged();
  607. }
  608. }
  610. if (m_strKeyboardTip.IsEmpty())
  611. {
  612. AfxExtractSubString(m_strKeyboardTip, lpszPrompt, 3);
  613. }
  614. }
  616. void CXTPControl::SetID(int nId)
  617. {
  618. if (m_nId == nId)
  619. return;
  621. CString strPrompt;
  623. if (XTPResourceManager()->LoadString(&strPrompt, nId))
  624. {
  625. SetPrompt(strPrompt);
  626. }
  628. m_nId = nId;
  629. }
  631. void CXTPControl::OnActionChanged(int nProperty)
  632. {
  633. if (nProperty == 3)
  634. {
  635. OnCaptionChanged();
  636. }
  637. }
  639. void CXTPControl::SetCaption(UINT nIDCaption)
  640. {
  641. CString strCaption;
  642. if (strCaption.LoadString(nIDCaption))
  643. {
  644. SetCaption(strCaption);
  645. }
  646. }
  648. void CXTPControl::SetCaption(LPCTSTR lpszCaption)
  649. {
  650. CString strCaption(lpszCaption);
  651. BOOL bDelayLayout = FALSE;
  653. int nShortCutPos = strCaption.Find ('t');
  654. if (nShortCutPos != -1)
  655. {
  656. CString strShortcutTextAuto = strCaption.Mid(nShortCutPos + 1);
  658. if (m_strShortcutTextAuto != strShortcutTextAuto)
  659. {
  660. m_strShortcutTextAuto = strShortcutTextAuto;
  661. bDelayLayout = TRUE;
  662. }
  663. strCaption.ReleaseBuffer(nShortCutPos);
  664. }
  666. if (m_strCaption != strCaption)
  667. {
  668. m_strCaption = strCaption;
  669. OnCaptionChanged();
  670. bDelayLayout = TRUE;
  671. }
  673. if (bDelayLayout)
  674. {
  675. DelayLayoutParent();
  676. }
  677. }
  679. AFX_INLINE void NotifyExecute(CXTPControl* pControl, CWnd* pOwner)
  680. {
  681. NMXTPCONTROL tagNMCONTROL;
  682. if (pControl->NotifySite(pOwner, CBN_XTP_EXECUTE, &tagNMCONTROL) == 0)
  683. {
  684. pOwner->SendMessage(WM_COMMAND, pControl->GetID());
  685. }
  686. }
  688. //Click Helper
  689. void CXTPControl::ClickToolBarButton(CRect rcActiveRect)
  690. {
  691. #define XTP_TID_CLICKTICK 0x10AD
  693. if (rcActiveRect.IsRectEmpty())
  694. rcActiveRect = m_rcControl;
  696. m_pParent->SetPopuped(-1);
  697. m_pParent->SetSelected(m_nIndex);
  698. m_bPressed = TRUE;
  699. RedrawParent();
  701. InternalAddRef();
  703. BOOL bExecuteOnTimer = m_nExecuteOnPressInterval > 0;
  704. CWnd* pOwner = m_pParent->GetOwnerSite();
  706. m_pParent->SetCapture();
  707. HWND hWndCapture = m_pParent->GetSafeHwnd();
  708. CPoint pt(0, 0);
  709. BOOL bClick = FALSE;
  711. if (bExecuteOnTimer)
  712. {
  713. m_pParent->SetTimer(XTP_TID_CLICKTICK, m_nExecuteOnPressInterval, NULL);
  714. NotifyExecute(this, pOwner);
  715. }
  717. while (::GetCapture() == hWndCapture)
  718. {
  719. MSG msg;
  720. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  722. if (msg.message == WM_LBUTTONUP)
  723. {
  724. bClick = m_bSelected && ((!pt.x && !pt.y) || rcActiveRect.PtInRect(pt));
  725. break;
  726. }
  728. if (m_pParent == NULL)
  729. break;
  731. if (msg.message == WM_TIMER && msg.wParam == XTP_TID_CLICKTICK)
  732. {
  733. if (m_bSelected)
  734. {
  735. NotifyExecute(this, pOwner);
  736. }
  737. }
  739. if (msg.message == WM_MOUSEMOVE)
  740. {
  741. pt = CPoint(LOWORD(msg.lParam), HIWORD(msg.lParam));
  742. if (OnSetSelected(rcActiveRect.PtInRect(pt)))
  743. {
  744. RedrawParent();
  745. }
  746. continue;
  747. }
  749. DispatchMessage (&msg);
  750. }
  752. if (bExecuteOnTimer && m_pParent->GetSafeHwnd())
  753. {
  754. m_pParent->KillTimer(XTP_TID_CLICKTICK);
  755. }
  757. m_bPressed = bClick && !bExecuteOnTimer && NeedPressOnExecute() ? TRUE_KEYBOARD : FALSE;
  759. ReleaseCapture();
  761. if (m_bSelected && m_pParent)
  762. {
  763. m_pParent->SetSelected(-1);
  764. m_bSelected = FALSE;
  765. m_pParent->m_nClickedControl = GetIndex();
  766. }
  768. if (bClick && !bExecuteOnTimer)
  769. {
  770. OnExecute();
  772. if (m_bPressed)
  773. {
  774. m_bPressed = FALSE;
  775. RedrawParent();
  776. }
  777. }
  778. else
  779. {
  780. RedrawParent();
  781. }
  783. InternalRelease();
  784. }
  786. LRESULT CXTPControl::NotifySite(UINT code)
  787. {
  788. if (!m_pParent)
  789. return 0;
  791. NMXTPCONTROL tagNMCONTROL;
  792. return NotifySite(m_pParent->GetOwnerSite(), code, &tagNMCONTROL);
  793. }
  795. LRESULT CXTPControl::NotifySite(UINT code, NMXTPCONTROL* pNM)
  796. {
  797. if (!m_pParent)
  798. return 0;
  800. return NotifySite(m_pParent->GetOwnerSite(), code, pNM);
  801. }
  803. LRESULT CXTPControl::NotifySite(CWnd* pSite, UINT code, NMXTPCONTROL* pNM)
  804. {
  805. if (pSite == 0)
  806. {
  807. if (!m_pParent)
  808. return 0;
  810. pSite = m_pParent->GetOwnerSite();
  811. }
  813. pNM->hdr.code = code ;
  814. pNM->hdr.idFrom = GetID();
  815. pNM->hdr.hwndFrom = 0;
  816. pNM->pControl = this;
  818. LRESULT lResult = pSite->SendMessage(WM_XTP_COMMAND, GetID(), (LPARAM)pNM);
  820. if (lResult || !m_pParent)
  821. return lResult;
  823. AFX_NOTIFY notify;
  824. notify.pResult = &lResult;
  825. notify.pNMHDR = (NMHDR*)pNM;
  827. if (pSite->OnCmdMsg(GetID(), MAKELONG(code, WM_NOTIFY), &notify, NULL))
  828. {
  829. return lResult;
  830. }
  832. return 0;
  833. }
  836. BOOL CXTPControl::NeedPressOnExecute() const
  837. {
  838. if (m_pParent && m_pParent->GetPosition() == xtpBarPopup)
  839. return FALSE;
  841. return TRUE;
  842. }
  844. void CXTPControl::OnExecute()
  845. {
  846. XTPSoundManager()->PlaySystemSound(xtpSoundMenuCommand);
  848. m_bPressed = NeedPressOnExecute() ? TRUE_KEYBOARD : FALSE;
  850. CXTPCommandBar* pCommandBar = m_pParent->GetRootParent();
  851. BOOL bRecursePopup = pCommandBar->m_bRecursePopup;
  853. CWnd* pOwner = m_pParent->GetOwnerSite();
  854. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  856. if (pCommandBars)
  857. {
  858. if (m_nId) pCommandBars->SetCommandUsed(m_nId);
  860. CXTPPopupBar* pPopupBar = DYNAMIC_DOWNCAST(CXTPPopupBar, m_pParent);
  861. if (pPopupBar && pPopupBar->GetControlPopup() && ((CXTPControl*)pPopupBar->GetControlPopup())->GetID())
  862. {
  863. pCommandBars->SetCommandUsed(((CXTPControl*)pPopupBar->GetControlPopup())->GetID());
  864. }
  865. }
  867. if (pCommandBar->m_pReturnCmd)
  868. {
  869. if (bRecursePopup)
  870. pCommandBar->OnTrackLost();
  871. else pCommandBars->ClosePopups();
  873. *pCommandBar->m_pReturnCmd = m_nId;
  874. return;
  875. }
  878. InternalAddRef();
  880. if (m_bCloseSubMenuOnClick)
  881. {
  882. if (bRecursePopup)
  883. pCommandBar->OnTrackLost();
  884. else if (pCommandBars)
  885. pCommandBars->ClosePopups();
  886. else
  887. XTPMouseManager()->SendTrackLost();
  888. }
  890. if (m_nId == 0)
  891. {
  892. InternalRelease();
  893. return;
  894. }
  896. NotifyExecute(this, pOwner);
  898. if ((!m_bCloseSubMenuOnClick || m_bPressed) && m_pParent)
  899. {
  900. m_bPressed = FALSE;
  902. m_pParent->OnIdleUpdateCmdUI(0, 0);
  903. RedrawParent();
  904. }
  906. InternalRelease();
  907. }
  909. BOOL CXTPControl::IsCursorOver() const
  910. {
  911. CPoint pt;
  912. GetCursorPos(&pt);
  913. m_pParent->ScreenToClient(&pt);
  914. return m_rcControl.PtInRect(pt);
  915. }
  917. void CXTPControl::Copy(CXTPControl* pControl, BOOL /*bRecursive*/)
  918. {
  919. m_nId = pControl->m_nId;
  920. SetAction(pControl->GetAction());
  922. m_nTag = pControl->m_nTag;
  923. m_dwFlags = pControl->m_dwFlags;
  924. m_controlType = pControl->m_controlType;
  925. m_strCaption = pControl->m_strCaption;
  926. m_strShortcutText = pControl->m_strShortcutText;
  927. m_strShortcutTextAuto = pControl->m_strShortcutTextAuto;
  928. m_strTooltipText = pControl->m_strTooltipText;
  929. m_strDescriptionText = pControl->m_strDescriptionText;
  930. m_strParameter = pControl->m_strParameter;
  931. m_strKeyboardTip = pControl->m_strKeyboardTip;
  932. m_nCustomIconId = pControl->m_nCustomIconId;
  933. m_nIconId = pControl->m_nIconId;
  934. m_nHelpId = pControl->m_nHelpId;
  935. m_bTemporary = pControl->m_bTemporary;
  936. m_strCustomCaption = pControl->m_strCustomCaption;
  937. m_strCategory = pControl->m_strCategory;
  938. m_dwHideFlags = pControl->m_dwHideFlags;
  939. m_bDefaultItem = pControl->m_bDefaultItem;
  940. m_bEnabled = pControl->m_bEnabled;
  941. m_bChecked = pControl->m_bChecked;
  942. m_buttonCustomStyle = pControl->m_buttonCustomStyle;
  943. m_buttonStyle = pControl->m_buttonStyle;
  945. m_nWidth = max(GetCustomizeMinWidth(), pControl->m_nWidth);
  946. m_nHeight = pControl->m_nHeight;
  948. m_szIcon = pControl->m_szIcon;
  950. m_bBeginGroup = pControl->m_bBeginGroup;
  952. m_bCloseSubMenuOnClick = pControl->m_bCloseSubMenuOnClick;
  953. m_nExecuteOnPressInterval = pControl->m_nExecuteOnPressInterval;
  955. m_mapDocTemplatesAssigned.Copy(pControl->m_mapDocTemplatesAssigned);
  956. m_mapDocTemplatesExcluded.Copy(pControl->m_mapDocTemplatesExcluded);
  958. OnCaptionChanged();
  959. }
  961. BOOL CXTPControl::Compare(CXTPControl* pOther)
  962. {
  963. if (GetStyle() != pOther->GetStyle())
  964. return FALSE;
  966. if (GetType() != pOther->GetType())
  967. return FALSE;
  969. if (GetID() != pOther->GetID())
  970. return FALSE;
  972. if (GetFlags() != pOther->GetFlags())
  973. return FALSE;
  975. if (GetBeginGroup() != pOther->GetBeginGroup())
  976. return FALSE;
  978. if (GetIconId() != pOther->GetIconId())
  979. return FALSE;
  981. if (m_strCaption != pOther->m_strCaption)
  982. return FALSE;
  984. if (m_strTooltipText != pOther->m_strTooltipText)
  985. return FALSE;
  987. if (m_strDescriptionText != pOther->m_strDescriptionText)
  988. return FALSE;
  990. if (m_strCustomCaption != pOther->m_strCustomCaption)
  991. return FALSE;
  993. if (m_buttonCustomStyle != pOther->m_buttonCustomStyle)
  994. return FALSE;
  996. if (m_strParameter != pOther->m_strParameter)
  997. return FALSE;
  999. if ((m_dwHideFlags & xtpHideCustomize) != (pOther->m_dwHideFlags & xtpHideCustomize))
  1000. return FALSE;
  1002. if (m_nWidth != pOther->m_nWidth)
  1003. return FALSE;
  1005. return TRUE;
  1006. }
  1008. IMPLEMENT_XTP_CONTROL(CXTPControl, CCmdTarget)
  1011. BOOL CXTPControl::IsCustomizeMode() const
  1012. {
  1013. return m_pParent ? m_pParent->IsCustomizeMode() : FALSE;
  1014. }
  1016. void CXTPControl::OnInvertTracker(CDC* pDC, CRect rect)
  1017. {
  1018. ASSERT(!rect.IsRectEmpty());
  1020. pDC->InvertRect(CRect(rect.left, rect.top, rect.right, rect.top + 2));
  1021. pDC->InvertRect(CRect(rect.left, rect.bottom - 2, rect.right, rect.bottom));
  1022. pDC->InvertRect(CRect(rect.left, rect.top + 2, rect.left + 2, rect.bottom - 2));
  1023. pDC->InvertRect(CRect(rect.right - 2, rect.top + 2, rect.right, rect.bottom - 2));
  1025. }
  1027. void CXTPControl::OnCustomizeMouseMove(CPoint point)
  1028. {
  1029. if (IsCustomizeResizeAllow() && m_rcControl.PtInRect(point) && ((point.x - m_rcControl.left <= 2) || (m_rcControl.right - point.x <= 2)))
  1030. {
  1031. ::SetCursor(XTPResourceManager()->LoadCursor(XTP_IDC_VRESIZE));
  1032. }
  1033. }
  1035. BOOL CXTPControl::CustomizeStartResize(CPoint point)
  1036. {
  1037. if (m_rcControl.PtInRect(point) && ((point.x - m_rcControl.left <= 2) || (m_rcControl.right - point.x <= 2)))
  1038. {
  1039. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  1040. ASSERT(pCommandBars);
  1041. ASSERT(pCommandBars->m_pDragSelected == this);
  1042. pCommandBars->m_pDragSelected = NULL;
  1043. m_pParent->Redraw();
  1044. m_pParent->UpdateWindow();
  1046. CRect rectTracker = m_rcControl;
  1047. m_pParent->ClientToScreen(rectTracker);
  1049. m_pParent->SetCapture();
  1050. ::SetCursor(XTPResourceManager()->LoadCursor(XTP_IDC_VRESIZE));
  1052. CDC* pDC = 0;
  1054. CWnd* pWnd = CWnd::GetDesktopWindow();
  1055. if (pWnd->LockWindowUpdate())
  1056. pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  1057. else
  1058. pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE);
  1060. OnInvertTracker(pDC, rectTracker);
  1061. int nMinWidth = GetCustomizeMinWidth();
  1062. BOOL bLeftAnchor = (point.x - m_rcControl.left <= 2);
  1064. LONG& lTrackerAnchor = bLeftAnchor ? rectTracker.left : rectTracker.right;
  1065. int nOffset = bLeftAnchor ? m_rcControl.left - point.x : m_rcControl.right - point.x;
  1067. BOOL bAccept = FALSE;
  1068. while (CWnd::GetCapture() == m_pParent)
  1069. {
  1070. MSG msg;
  1071. if (!GetMessage(&msg, NULL, 0, 0))
  1072. break;
  1074. if (msg.message == WM_MOUSEMOVE)
  1075. {
  1076. point = CPoint(msg.lParam);
  1077. m_pParent->ClientToScreen(&point);
  1078. point.x += nOffset;
  1080. point.x = bLeftAnchor ? min(point.x, rectTracker.right - nMinWidth) :
  1081. max(point.x, rectTracker.left + nMinWidth);
  1083. if (lTrackerAnchor != point.x)
  1084. {
  1085. OnInvertTracker(pDC, rectTracker);
  1086. lTrackerAnchor = point.x;
  1087. OnInvertTracker(pDC, rectTracker);
  1088. }
  1089. }
  1090. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  1091. else if (msg.message == WM_LBUTTONUP)
  1092. {
  1093. bAccept = TRUE;
  1094. break;
  1095. }
  1096. else  ::DispatchMessage(&msg);
  1097. }
  1099. OnInvertTracker(pDC, rectTracker);
  1101. if (CWnd::GetCapture() == m_pParent) ReleaseCapture();
  1103. pWnd->UnlockWindowUpdate();
  1104. if (pDC != NULL)
  1105. {
  1106. pWnd->ReleaseDC(pDC);
  1107. pDC = NULL;
  1108. }
  1110. pCommandBars->m_pDragSelected = this;
  1112. int nWidth = rectTracker.Width();
  1114. if (bAccept && rectTracker.Width() != m_rcControl.Width())
  1115. {
  1116. if (GetParent()->GetType() == xtpBarTypePopup)
  1117. nWidth -= GetPaintManager()->GetPopupBarGripperWidth(GetParent());
  1119. SetWidth(nWidth);
  1120. m_pParent->OnRecalcLayout();
  1121. }
  1122. m_pParent->Redraw();
  1124. return TRUE;
  1126. }
  1128. return FALSE;
  1129. }
  1131. void CXTPControl::CustomizeStartDrag(CPoint pt)
  1132. {
  1133. ASSERT(m_pParent);
  1134. if (!m_pParent)
  1135. return;
  1137. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  1138. ASSERT(pCommandBars);
  1139. if (!pCommandBars)
  1140. return;
  1142. if ((pCommandBars->m_pDragSelected == this) && IsCustomizeResizeAllow() &&
  1143. CustomizeStartResize(pt))
  1144. {
  1145. return;
  1146. }
  1148. pCommandBars->SetDragControl(this);
  1150. CXTPCustomizeDropSource* pDropSource = pCommandBars->GetDropSource();
  1151. DROPEFFECT dropEffect = pDropSource->DoDragDrop(this);
  1153. if (dropEffect == DROPEFFECT_NONE || dropEffect == DROPEFFECT_MOVE)
  1154. {
  1155. CXTPCommandBar* pParent = m_pParent;
  1156. pParent->SetPopuped(-1);
  1157. pParent->SetSelected(-1);
  1159. if (pCommandBars->GetDragControl() == this)
  1160. pCommandBars->SetDragControl(NULL);
  1163. if (GetBeginGroup() && m_nIndex < m_pControls->GetCount() - 1)
  1164. m_pControls->GetAt(m_nIndex + 1)->SetBeginGroup(TRUE);
  1166. if (m_nIndex == 0 && m_pControls->GetCount() > 1)
  1167. m_pControls->GetAt(1)->SetBeginGroup(FALSE);
  1169. m_pControls->Remove(this);
  1171. pParent->OnRecalcLayout();
  1172. }
  1173. pCommandBars->SetDragControl(pCommandBars->GetDragControl());
  1174. }
  1176. void CXTPControl::OnCustomizeDragOver(CXTPControl* /*pDataObject*/, CPoint /*point*/, DROPEFFECT& /*dropEffect*/)
  1177. {
  1178. m_pParent->SetPopuped(-1);
  1179. m_pParent->SetSelected(-1);
  1180. }
  1181. BOOL CXTPControl::IsCustomizeDragOverAvail(CXTPCommandBar* /*pCommandBar*/, CPoint /*point*/, DROPEFFECT& /*dropEffect*/)
  1182. {
  1183. return TRUE;
  1184. }
  1186. BOOL CXTPControl::IsCustomizeResizeAllow() const
  1187. {
  1188. return FALSE;
  1189. }
  1191. CXTPImageManager* CXTPControl::GetImageManager() const
  1192. {
  1193. if (m_pParent)
  1194. return m_pParent->GetImageManager();
  1196. if (m_pControls)
  1197. {
  1198. CXTPCommandBars* pCommandBars = m_pControls->GetCommandBars();
  1199. if (pCommandBars)
  1200. return pCommandBars->GetImageManager();
  1201. }
  1202. return XTPImageManager();
  1203. }
  1204. CXTPPaintManager* CXTPControl::GetPaintManager() const
  1205. {
  1206. if (m_pParent)
  1207. return m_pParent->GetPaintManager();
  1209. if (m_pControls)
  1210. {
  1211. CXTPCommandBars* pCommandBars = m_pControls->GetCommandBars();
  1212. if (pCommandBars)
  1213. return pCommandBars->GetPaintManager();
  1214. }
  1215. return XTPPaintManager();
  1217. }
  1218. CXTPImageManagerIcon* CXTPControl::GetImage(int nWidth) const
  1219. {
  1220. if (GetIconId() != 0)
  1221. return GetImageManager()->GetImage(GetIconId(), nWidth);
  1222. return NULL;
  1224. }
  1226. void CXTPControl::SetExpanded(BOOL bExpanded)
  1227. {
  1228. m_bExpanded = bExpanded;
  1229. if (!bExpanded) SetHideFlags(GetHideFlags() & ~xtpHideExpand);
  1230. }
  1232. BOOL CXTPControl::IsItemDefault() const
  1233. {
  1234. return m_bDefaultItem;
  1235. }
  1237. void CXTPControl::SetItemDefault(BOOL bDefault)
  1238. {
  1239. if (bDefault != m_bDefaultItem)
  1240. {
  1241. m_bDefaultItem = bDefault;
  1242. DelayLayoutParent();
  1243. }
  1244. }
  1246. void CXTPControl::SetFlags(DWORD dwFlags)
  1247. {
  1248. m_dwFlags = dwFlags;
  1249. }
  1251. DWORD CXTPControl::GetFlags() const
  1252. {
  1253. return m_dwFlags;
  1254. }
  1256. BOOL CXTPControl::IsCustomizeMovable() const
  1257. {
  1258. if (m_pParent && m_pParent->IsCustomizable() && ((GetFlags() & xtpFlagNoMovable) == 0))
  1259. return TRUE;
  1261. if (!m_pParent)
  1262. return FALSE;
  1263. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  1265. if (pCommandBars && pCommandBars->m_bDesignerMode)
  1266. return TRUE;
  1268. return FALSE;
  1269. }
  1271. void CXTPControl::CDocTemplateMap::Copy(CDocTemplateMap& map)
  1272. {
  1273. RemoveAll();
  1275. UINT nIDResource;
  1276. BOOL bValue;
  1277. POSITION pos = map.GetStartPosition();
  1278. while (pos)
  1279. {
  1280. map.GetNextAssoc(pos, nIDResource, bValue);
  1281. SetAt(nIDResource, bValue);
  1282. }
  1283. }
  1285. CXTPControl* CXTPControl::FromUI(CCmdUI* pCmdUI)
  1286. {
  1287. CXTPCommandBar* pCommandBar = DYNAMIC_DOWNCAST(CXTPCommandBar, pCmdUI->m_pOther);
  1288. if (!pCommandBar)
  1289. return NULL;
  1291. CXTPControls* pControls = pCommandBar->GetControls();
  1292. if ((int)pCmdUI->m_nIndex < pControls->GetCount())
  1293. return pControls->GetAt(pCmdUI->m_nIndex);
  1295. return NULL;
  1297. }
  1299. BOOL CXTPControl::OnLButtonDblClk(CPoint point)
  1300. {
  1301. OnClick(FALSE, point);
  1302. return TRUE;
  1303. }
  1305. void CXTPControl::Reset()
  1306. {
  1307. if (m_nCustomIconId != 0 || !m_strCustomCaption.IsEmpty() || m_buttonCustomStyle != xtpButtonUndefined)
  1308. {
  1309. m_nCustomIconId = 0;
  1310. m_buttonCustomStyle = xtpButtonUndefined;
  1312. if (!m_strCustomCaption.IsEmpty())
  1313. {
  1314. m_strCustomCaption = _T("");
  1315. OnCaptionChanged();
  1316. }
  1317. GetParent()->OnRecalcLayout();
  1318. }
  1319. }
  1321. void CXTPControl::SetCustomIcon(HICON hIcon)
  1322. {
  1323. CXTPImageManager* pImageManager = GetImageManager();
  1324. if (pImageManager)
  1325. {
  1326. m_nCustomIconId = pImageManager->AddCustomIcon(hIcon);
  1327. }
  1328. }
  1330. CSize CXTPControl::GetButtonSize() const
  1331. {
  1332. return m_pParent->GetButtonSize();
  1333. }
  1335. CSize CXTPControl::GetIconSize() const
  1336. {
  1337. if (m_szIcon != CSize(0, 0))
  1338. return m_szIcon;
  1340. return m_pParent->GetIconSize();
  1341. }
  1344. #ifndef _XTP_INCLUDE_RIBBON
  1345. BOOL CXTPControl::HasDwmCompositedRect() const
  1346. {
  1347. return FALSE;
  1348. }
  1349. #endif
  1351. void CXTPControl::OnUnderlineActivate()
  1352. {
  1353. OnExecute();
  1354. }
  1356. BOOL CXTPControl::IsCaptionVisible() const
  1357. {
  1358. if (GetParent()->GetType() == xtpBarTypePopup)
  1359. return TRUE;
  1361. if (GetCaption().IsEmpty())
  1362. return FALSE;
  1364. XTPButtonStyle buttonStyle = GetStyle();
  1366. if ((buttonStyle == xtpButtonCaption) || (buttonStyle == xtpButtonIconAndCaption) || (buttonStyle == xtpButtonIconAndCaptionBelow))
  1367. return TRUE;
  1369. if (buttonStyle == xtpButtonIcon)
  1370. return FALSE;
  1372. switch (GetType())
  1373. {
  1374. case xtpControlPopup:
  1375. case xtpControlLabel:
  1376. case xtpControlCheckBox:
  1377. case xtpControlRadioButton:
  1378. return TRUE;
  1380. case xtpControlButton:
  1381. case xtpControlButtonPopup:
  1382. case xtpControlSplitButtonPopup:
  1383. CXTPImageManagerIcon* pImage = GetImage(0);
  1384. return pImage == NULL;
  1385. }
  1386. return FALSE;
  1387. }
  1390. CCmdTarget* CXTPControl::GetAccessible()
  1391. {
  1392. return this;
  1393. }
  1395. HRESULT CXTPControl::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  1396. {
  1397. SAFE_MANAGE_STATE(m_pModuleState);
  1399. *ppdispParent = NULL;
  1401. if (m_pParent)
  1402. {
  1403. *ppdispParent = m_pParent->GetIDispatch(TRUE);
  1404. return S_OK;
  1405. }
  1406. return E_FAIL;
  1407. }
  1409. HRESULT CXTPControl::GetAccessibleChildCount(long FAR* pChildCount)
  1410. {
  1411. if (pChildCount == 0)
  1412. return E_INVALIDARG;
  1414. *pChildCount = GetCommandBar() ? 1 : 0;
  1416. return S_OK;
  1417. }
  1418. HRESULT CXTPControl::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  1419. {
  1420. SAFE_MANAGE_STATE(m_pModuleState);
  1422. *ppdispChild = NULL;
  1424. if (GetChildIndex(&varChild) == 1)
  1425. {
  1426. CXTPCommandBar* pCommandBar = GetCommandBar();
  1427. if (pCommandBar)
  1428. {
  1429. *ppdispChild = pCommandBar->GetIDispatch(TRUE);
  1430. }
  1431. }
  1433. return S_OK;
  1434. }
  1436. HRESULT CXTPControl::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1437. {
  1438. SAFE_MANAGE_STATE(m_pModuleState);
  1440. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1441. return E_INVALIDARG;
  1443. CString strCaption = GetCaption();
  1444. CXTPPaintManager::StripMnemonics(strCaption);
  1446. if (!GetShortcutText().IsEmpty())
  1447. strCaption = strCaption + _T('t') + GetShortcutText();
  1449. if (strCaption.IsEmpty())
  1450. {
  1451. strCaption = GetTooltip();
  1452. }
  1454. *pszName = strCaption.AllocSysString();
  1455. return S_OK;
  1456. }
  1458. HRESULT CXTPControl::GetAccessibleDescription(VARIANT varChild, BSTR* pszDescription)
  1459. {
  1460. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1461. return E_INVALIDARG;
  1463. *pszDescription = GetDescription().AllocSysString();
  1464. return S_OK;
  1465. }
  1467. HRESULT CXTPControl::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1468. {
  1469. pvarRole->vt = VT_EMPTY;
  1471. if (m_pParent && m_pParent->GetSafeHwnd() && GetChildIndex(&varChild) == CHILDID_SELF)
  1472. {
  1473. pvarRole->vt = VT_I4;
  1474. pvarRole->lVal = m_pParent->GetType() == xtpBarTypeNormal || m_pParent->GetType() == xtpBarTypeRibbon ?
  1475. GetCommandBar() ? ROLE_SYSTEM_BUTTONMENU: ROLE_SYSTEM_PUSHBUTTON : ROLE_SYSTEM_MENUITEM;
  1476. return S_OK;
  1477. }
  1479. return E_INVALIDARG;
  1480. }
  1482. HRESULT CXTPControl::AccessibleSelect(long /*flagsSelect*/, VARIANT varChild)
  1483. {
  1484. SAFE_MANAGE_STATE(m_pModuleState);
  1486. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1487. return E_INVALIDARG;
  1489. if (m_pParent && m_pParent->GetSafeHwnd())
  1490. {
  1491. m_pParent->SetTrackingMode(TRUE, FALSE);
  1492. m_pParent->SetSelected(m_nIndex, TRUE);
  1493. }
  1495. return S_OK;
  1496. }
  1498. #ifndef STATE_SYSTEM_HASPOPUP
  1499. #define STATE_SYSTEM_HASPOPUP   (0x40000000)
  1500. #endif //STATE_SYSTEM_HASPOPUP
  1503. HRESULT CXTPControl::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  1504. {
  1505. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1506. return E_INVALIDARG;
  1508. pvarState->vt = VT_I4;
  1509. pvarState->lVal = STATE_SYSTEM_FOCUSABLE |
  1510. (m_bSelected ? STATE_SYSTEM_FOCUSED | STATE_SYSTEM_SELECTED | STATE_SYSTEM_HOTTRACKED : 0);
  1512. if (!m_pParent->IsVisible() || !IsVisible())
  1513. pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
  1515. if (!GetEnabled())
  1516. pvarState->lVal |= STATE_SYSTEM_UNAVAILABLE;
  1518. if (GetChecked())
  1519. pvarState->lVal |= STATE_SYSTEM_CHECKED;
  1521. if (GetPressed())
  1522. pvarState->lVal |= STATE_SYSTEM_PRESSED;
  1524. if (GetCommandBar())
  1525. pvarState->lVal |= STATE_SYSTEM_HASPOPUP;
  1527. return S_OK;
  1528. }
  1530. HRESULT CXTPControl::GetAccessibleDefaultAction(VARIANT varChild, BSTR* pszDefaultAction)
  1531. {
  1532. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1533. return E_INVALIDARG;
  1535. *pszDefaultAction = SysAllocString(L"Click");
  1537. return S_OK;
  1538. }
  1540. HRESULT CXTPControl::AccessibleDoDefaultAction(VARIANT varChild)
  1541. {
  1542. SAFE_MANAGE_STATE(m_pModuleState);
  1544. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1545. return E_INVALIDARG;
  1547. OnClick(TRUE);
  1549. return S_OK;
  1550. }
  1553. HRESULT CXTPControl::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  1554. {
  1555. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  1557. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1558. return E_INVALIDARG;
  1560. if (!m_pParent->GetSafeHwnd())
  1561. return S_OK;
  1563. if (!IsVisible())
  1564. return S_OK;
  1566. CRect rcControl = GetRect();
  1567. m_pParent->ClientToScreen(&rcControl);
  1569. *pxLeft = rcControl.left;
  1570. *pyTop = rcControl.top;
  1571. *pcxWidth = rcControl.Width();
  1572. *pcyHeight = rcControl.Height();
  1574. return S_OK;
  1575. }
  1577. HRESULT CXTPControl::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  1578. {
  1579. if (pvarID == NULL)
  1580. return E_INVALIDARG;
  1582. pvarID->vt = VT_EMPTY;
  1584. if (!m_pParent->GetSafeHwnd())
  1585. return S_FALSE;
  1587. if (!CXTPWindowRect(m_pParent).PtInRect(CPoint(xLeft, yTop)))
  1588. return S_FALSE;
  1590. pvarID->vt = VT_I4;
  1591. pvarID->lVal = 0;
  1593. CPoint pt(xLeft, yTop);
  1594. m_pParent->ScreenToClient(&pt);
  1596. if (!GetRect().PtInRect(pt))
  1597. return S_FALSE;
  1599. return S_OK;
  1600. }
  1602. void CXTPControl::SetVisible(BOOL bVisible)
  1603. {
  1604. DWORD dwHideFlags = m_dwHideFlags;
  1605. if (!bVisible) SetHideFlags(m_dwHideFlags | xtpHideGeneric); else SetHideFlags(m_dwHideFlags & ~xtpHideGeneric);
  1606. if (dwHideFlags != m_dwHideFlags) DelayLayoutParent();
  1607. }
  1611. BEGIN_INTERFACE_MAP(CXTPControl, CCmdTarget)
  1612. INTERFACE_PART(CXTPControl, IID_IAccessible, ExternalAccessible)
  1613. END_INTERFACE_MAP()