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

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

对话框与窗口

开发平台：

Visual C++

XTPPropertyGridView.cpp：源码内容
  1. // XTPPropertyGridView.cpp : implementation of the CXTPPropertyGridView class.
  2. //
  3. // This file is a part of the XTREME PROPERTYGRID 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 "Common/Resource.h"
  24. #include "Common/XTPDrawHelpers.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPResourceManager.h"
  27. #include "Common/XTPToolTipContext.h"
  29. #include "XTPPropertyGridInplaceEdit.h"
  30. #include "XTPPropertyGridInplaceButton.h"
  31. #include "XTPPropertyGridInplaceList.h"
  32. #include "XTPPropertyGridItem.h"
  33. #include "XTPPropertyGrid.h"
  34. #include "XTPPropertyGridDefines.h"
  35. #include "XTPPropertyGridPaintManager.h"
  37. #ifdef _DEBUG
  38. #define new DEBUG_NEW
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #endif
  44. const UINT PGV_HIT_SPLITTER = 0x100;
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CXTPPropertyGridToolTip
  49. CXTPPropertyGridToolTip::CXTPPropertyGridToolTip()
  50. {
  51. m_pGrid = NULL;
  52. }
  54. BEGIN_MESSAGE_MAP(CXTPPropertyGridToolTip, CWnd)
  55. //{{AFX_MSG_MAP(CXTPPropertyGridView)
  56. ON_WM_ERASEBKGND()
  57. ON_WM_PAINT()
  58. ON_WM_NCHITTEST_EX()
  59. //}}AFX_MSG_MAP
  60. END_MESSAGE_MAP()
  62. LRESULT CXTPPropertyGridToolTip::OnNcHitTest(CPoint /*point*/)
  63. {
  64. return (LRESULT)HTTRANSPARENT;
  65. }
  66. void CXTPPropertyGridToolTip::Create(CXTPPropertyGridView* pParentWnd)
  67. {
  68. CWnd::CreateEx(0, AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)), _T(""), WS_POPUP, CXTPEmptyRect(), pParentWnd, 0);
  69. m_pGrid = pParentWnd;
  71. }
  73. void CXTPPropertyGridToolTip::Activate(BOOL bActive, CXTPPropertyGridItem* pItem, BOOL bValuePart)
  74. {
  75. if (bActive)
  76. {
  77. ASSERT(pItem);
  78. m_fnt.DeleteObject();
  79. LOGFONT lf;
  80. m_pGrid->GetPaintManager()->GetItemFont(pItem, bValuePart)->GetLogFont(&lf);
  82. m_fnt.CreateFontIndirect(&lf);
  84. CString strText;
  85. GetWindowText(strText);
  86. CWindowDC dc(this);
  87. CXTPFontDC font(&dc, &m_fnt);
  88. CXTPWindowRect rc (this);
  89. rc.right = rc.left + dc.GetTextExtent(strText).cx + 8;
  91. CRect rcWork = XTPMultiMonitor()->GetWorkArea();
  93. if (rc.right > rcWork.right)
  94. rc.OffsetRect(rcWork.right - rc.right, 0);
  96. if (rc.left < rcWork.left)
  97. rc.OffsetRect(rcWork.left - rc.left, 0);
  99. MoveWindow(rc);
  100. ShowWindow(SW_SHOWNOACTIVATE);
  101. }
  102. else
  103. {
  104. DestroyWindow();
  105. }
  106. }
  108. BOOL CXTPPropertyGridToolTip::OnEraseBkgnd(CDC*)
  109. {
  110. return TRUE;
  111. }
  113. void CXTPPropertyGridToolTip::OnPaint()
  114. {
  115. CPaintDC dc(this);
  116. CXTPClientRect rc(this);
  118. COLORREF clrText = GetXtremeColor(COLOR_INFOTEXT);
  119. dc.FillSolidRect(rc, GetXtremeColor(COLOR_INFOBK));
  120. dc.Draw3dRect(rc, clrText, clrText);
  122. CString strText;
  123. GetWindowText(strText);
  124. dc.SetTextColor(clrText);
  125. dc.SetBkMode(TRANSPARENT);
  127. CXTPFontDC font(&dc, &m_fnt);
  128. CRect rcText(rc);
  129. rcText.left += 4;
  131. dc.DrawText(strText, rcText, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  133. }
  135. /////////////////////////////////////////////////////////////////////////////
  136. // CXTPPropertyGridView
  138. CXTPPropertyGridView::CXTPPropertyGridView()
  139. {
  140. m_properetySort = xtpGridSortCategorized;
  142. m_dDivider = .5;
  143. m_bAutoDivider = TRUE;
  145. m_bTracking = FALSE;
  147. m_bVariableSplitterPos = TRUE;
  149. m_pSelected = NULL;
  150. m_pCategories = new CXTPPropertyGridItems();
  152. m_hCursor = XTPResourceManager()->LoadCursor(XTP_IDC_HSPLITBAR);
  153. m_nLockUpdate = 0;
  154. m_pGrid = NULL;
  155. m_nItemHeight = 0;
  157. m_pFocusedButton = NULL;
  158. m_pHotButton = NULL;
  160. EnableAutomation();
  161. }
  163. CXTPPropertyGridView::~CXTPPropertyGridView()
  164. {
  165. m_wndTip.DestroyWindow();
  166. DestroyWindow();
  168. m_pCategories->Clear();
  169. m_pCategories->InternalRelease();
  171. }
  173. IMPLEMENT_DYNAMIC(CXTPPropertyGridView, CListBox)
  175. BEGIN_MESSAGE_MAP(CXTPPropertyGridView, CListBox)
  176. //{{AFX_MSG_MAP(CXTPPropertyGridView)
  177. ON_WM_ERASEBKGND()
  178. ON_WM_PAINT()
  179. ON_WM_NCPAINT()
  180. ON_WM_NCCALCSIZE()
  181. ON_WM_LBUTTONDOWN()
  182. ON_WM_RBUTTONDOWN()
  183. ON_WM_LBUTTONDBLCLK()
  184. ON_CONTROL_REFLECT(LBN_SELCHANGE, OnSelectionChanged)
  185. ON_WM_SETCURSOR()
  186. ON_WM_LBUTTONUP()
  187. ON_WM_CAPTURECHANGED()
  188. ON_WM_MOUSEMOVE()
  189. ON_WM_SIZE()
  190. ON_WM_KEYDOWN()
  191. ON_WM_SYSKEYDOWN()
  193. ON_WM_KEYUP()
  194. ON_WM_SYSKEYUP()
  196. ON_WM_CHAR()
  197. ON_WM_GETDLGCODE()
  199. ON_WM_VSCROLL()
  200. ON_WM_MOUSEWHEEL()
  202. ON_WM_SETFOCUS()
  203. ON_WM_KILLFOCUS()
  205. ON_MESSAGE(WM_GETOBJECT, OnGetObject)
  207. //}}AFX_MSG_MAP
  208. END_MESSAGE_MAP()
  210. /////////////////////////////////////////////////////////////////////////////
  211. // CXTPPropertyGridView message handlers
  212. void CXTPPropertyGridView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
  213. {
  214. if (GetScrollBarCtrl(SB_VERT) == pScrollBar)
  215. {
  216. OnScrollControl();
  217. }
  218. else
  219. {
  220. CListBox::OnVScroll(nSBCode, nPos, pScrollBar);
  221. }
  222. }
  224. struct CXTPPropertyGridView::WNDRECT
  225. {
  226. HWND hWnd;
  227. RECT rc;
  228. };
  230. LRESULT CXTPPropertyGridView::OnScrollControl()
  231. {
  232. if (GetCount() == 0)
  233. return 0;
  235. CArray<WNDRECT, WNDRECT&> arrRects;
  237. SetRedraw(FALSE);
  239. RECT rcTopOrig = {0, 0, 0, 0};
  240. GetItemRect(0, &rcTopOrig);
  242. HWND hWnd = ::GetWindow(m_hWnd, GW_CHILD);
  243. while (hWnd)
  244. {
  245. if (GetWindowLong(hWnd, GWL_STYLE) & WS_VISIBLE)
  246. {
  247. RECT rc;
  248. ::GetWindowRect(hWnd, &rc);
  250. WNDRECT wndRect;
  251. wndRect.hWnd = hWnd;
  252. wndRect.rc = rc;
  253. arrRects.Add(wndRect);
  254. }
  256. hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  257. }
  259. LRESULT lResult = Default();
  261. SetRedraw(TRUE);
  263. RECT rcTopDest = {0, 0, 0, 0};
  264. GetItemRect(0, &rcTopDest);
  265. int nOffset = rcTopDest.top - rcTopOrig.top;
  267. for (int i = 0; i < (int)arrRects.GetSize(); i++)
  268. {
  269. WNDRECT& wndRect = arrRects[i];
  270. RECT rc = wndRect.rc;
  271. ScreenToClient(&rc);
  273. ::OffsetRect(&rc, 0, nOffset);
  274. ::SetWindowPos(wndRect.hWnd, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
  275. SWP_NOACTIVATE | SWP_NOZORDER);
  276. }
  278. RedrawWindow(0, 0, RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ALLCHILDREN);
  280. return lResult;
  281. }
  283. BOOL CXTPPropertyGridView::OnMouseWheel(UINT /*nFlags*/, short /*zDelta*/, CPoint /*pt*/)
  284. {
  285. return (BOOL)OnScrollControl();
  286. }
  289. void CXTPPropertyGridView::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  290. {
  291. lpMeasureItemStruct->itemHeight = m_nItemHeight;
  293. GetPaintManager()->MeasureItem(lpMeasureItemStruct);
  294. }
  297. void CXTPPropertyGridView::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  298. {
  299. ASSERT(lpDrawItemStruct->CtlType == ODT_LISTBOX);
  301. CXTPPropertyGridItem* pItem = (CXTPPropertyGridItem*)lpDrawItemStruct->itemData;
  302. CXTPPropertyGridPaintManager* pPaintManager = GetPaintManager();
  304. if (pItem == NULL)
  305. return;
  307. if ((int)lpDrawItemStruct->itemID == GetCount() - 1)
  308. {
  309. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  310. CXTPClientRect rc(this);
  311. rc.top = lpDrawItemStruct->rcItem.bottom;
  312. pDC->FillSolidRect(rc, pPaintManager->GetItemMetrics()->m_clrBack);
  313. }
  315. if (!((m_pGrid->GetStyle() & XTP_PGS_OWNERDRAW) &&
  316. (SendNotifyMessage(XTP_PGN_DRAWITEM, (LPARAM)lpDrawItemStruct) == TRUE)))
  317. {
  318. pPaintManager->DrawItem(lpDrawItemStruct);
  319. }
  320. }
  322. BOOL CXTPPropertyGridView::OnEraseBkgnd(CDC*)
  323. {
  324. return TRUE;
  325. }
  327. void CXTPPropertyGridView::OnPaint()
  328. {
  329. CPaintDC dc(this);
  330. CXTPClientRect rc(this);
  331. CXTPBufferDC buffer(dc, rc);
  333. ASSERT(m_pGrid);
  334. GetPaintManager()->FillPropertyGridView(&buffer);
  336. CWnd::DefWindowProc(WM_PAINT, (WPARAM)buffer.m_hDC, 0);
  337. }
  339. void CXTPPropertyGridView::OnNcPaint()
  340. {
  341. Default();
  343. CWindowDC dc(this);
  345. CXTPWindowRect rc(this);
  346. rc.OffsetRect(-rc.TopLeft());
  348. ASSERT(m_pGrid);
  349. GetPaintManager()->DrawPropertyGridBorder(&dc, rc, FALSE);
  350. }
  352. void CXTPPropertyGridView::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
  353. {
  354. GetPaintManager()->DrawPropertyGridBorder(NULL, lpncsp->rgrc[0], TRUE);
  356. CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  357. }
  359. CXTPPropertyGridItem* CXTPPropertyGridView::InsertCategory(int nIndex, LPCTSTR strCaption, CXTPPropertyGridItem* pCategory)
  360. {
  361. ASSERT(nIndex >= 0 && nIndex <= m_pCategories->GetCount());
  363. if (nIndex < 0 || nIndex > m_pCategories->GetCount())
  364. nIndex = m_pCategories->GetCount();
  366. if (pCategory == NULL)
  367. pCategory = new CXTPPropertyGridItem(strCaption);
  369. SetPropertySort(xtpGridSortCategorized);
  371. pCategory->m_pGrid = this;
  372. pCategory->m_bCategory = TRUE;
  373. pCategory->m_nFlags = 0;
  376. m_pCategories->InsertAt(nIndex, pCategory);
  378. pCategory->OnCaptionChanged();
  380. if (m_hWnd)
  381. {
  382. int nInsertAt = (nIndex >= m_pCategories->GetCount() - 1) ? GetCount() : m_pCategories->GetAt(nIndex + 1)->m_nIndex;
  383. InsertItem(pCategory, nInsertAt);
  384. }
  385. _RefreshIndexes();
  388. return pCategory;
  390. }
  392. CXTPPropertyGridItem* CXTPPropertyGridView::AddCategory(LPCTSTR strCaption, CXTPPropertyGridItem* pCategory)
  393. {
  394. return InsertCategory(m_pCategories->GetCount(), strCaption, pCategory);
  395. }
  397. void CXTPPropertyGridView::Refresh()
  398. {
  399. _RefreshIndexes();
  400. SetPropertySort(m_properetySort, TRUE);
  402. SAFE_INVALIDATE(m_pGrid);
  403. }
  405. void CXTPPropertyGridView::ResetContent()
  406. {
  407. if (m_pSelected)
  408. {
  409. m_pSelected->OnDeselect();
  410. m_pSelected = NULL;
  411. m_pGrid->OnSelectionChanged(NULL);
  412. }
  414. if (m_hWnd)
  415. {
  416. for (int i = 0; i < GetCount(); i++)
  417. {
  418. CXTPPropertyGridItem* pItem = (CXTPPropertyGridItem*)GetItemDataPtr(i);
  419. ASSERT(pItem);
  420. if (!pItem)
  421. continue;
  422. pItem->SetVisible(FALSE);
  423. }
  425. CListBox::ResetContent();
  427. CFont* pFont = &GetPaintManager()->GetItemMetrics()->m_fontNormal;
  429. SetFont(pFont, FALSE);
  431. CWindowDC dc(this);
  432. CXTPFontDC font(&dc, pFont);
  433. m_nItemHeight = dc.GetTextExtent(_T(" "), 1).cy + 4;
  435. SetItemHeight(0, m_nItemHeight);
  436. }
  437. }
  439. void CXTPPropertyGridView::SetPropertySort(XTPPropertyGridSortOrder sort, BOOL bRrefresh, BOOL bSetRedraw)
  440. {
  441. if (m_nLockUpdate > 0)
  442. {
  443. m_properetySort = sort;
  444. return;
  445. }
  447. if (sort == m_properetySort && !bRrefresh)
  448. return;
  450. if (!m_hWnd)
  451. return;
  453. if (bSetRedraw) SetRedraw(FALSE);
  455. CXTPPropertyGridItem* pTopItem = bRrefresh ? GetItem(GetTopIndex()) : NULL;
  456. CXTPPropertyGridItem* pSelected = GetSelectedItem();
  458. ResetContent();
  460. if (sort == xtpGridSortCategorized)
  461. {
  462. for (int i = 0; i < m_pCategories->GetCount(); i++)
  463. {
  464. CXTPPropertyGridItem* pCategory = m_pCategories->GetAt(i);
  465. InsertItem(pCategory, GetCount());
  466. }
  467. }
  468. else if (sort == xtpGridSortAlphabetical || sort == xtpGridSortNoSort)
  469. {
  470. CXTPPropertyGridItems lstItems;
  471. int i;
  472. for (i = 0; i < m_pCategories->GetCount(); i++)
  473. {
  474. CXTPPropertyGridItem* pCategory = m_pCategories->GetAt(i);
  475. if (!pCategory->IsHidden())
  476. lstItems.AddTail(pCategory->m_pChilds);
  477. }
  479. if (sort != xtpGridSortNoSort)
  480. lstItems.Sort();
  482. for (i = 0; i < lstItems.GetCount(); i++)
  483. {
  484. CXTPPropertyGridItem* pItem = lstItems.GetAt(i);
  485. InsertItem(pItem, GetCount());
  486. }
  487. }
  488. else
  489. {
  490. ASSERT(FALSE);
  491. }
  493. _RefreshIndexes();
  495. if (pTopItem && pTopItem->IsVisible())
  496. {
  497. SetTopIndex(pTopItem->m_nIndex);
  498. }
  500. if (pSelected)
  501. {
  502. pSelected->Select();
  503. }
  504. OnSelectionChanged();
  506. if (bSetRedraw) SetRedraw(TRUE);
  508. if (sort != m_properetySort)
  509. {
  510. m_properetySort = sort;
  511. m_pGrid->OnSortChanged();
  512. }
  513. }
  515. void CXTPPropertyGridView::SetDividerPos(int nDivider)
  516. {
  517. double dWidth = (double)CXTPWindowRect(this).Width();
  519. if (!m_bAutoDivider)
  520. {
  521. m_dDivider = nDivider;
  522. m_dDivider = __max(m_dDivider, 1.0);
  524. if (dWidth != 0)
  525. {
  526. m_dDivider = __min(m_dDivider, dWidth);
  527. }
  528. }
  529. else
  530. {
  531. m_dDivider = dWidth == 0 ? .5 : (double)nDivider / dWidth;
  533. m_dDivider = __max(m_dDivider, .1);
  534. m_dDivider = __min(m_dDivider, .85);
  535. }
  536. }
  538. int CXTPPropertyGridView::GetDividerPos() const
  539. {
  540. return int(m_dDivider * (m_bAutoDivider ? CXTPWindowRect(this).Width() : 1));
  541. }
  543. void CXTPPropertyGridView::LockDivider()
  544. {
  545. m_dDivider = GetDividerPos();
  546. m_bAutoDivider = FALSE;
  547. }
  549. int  CXTPPropertyGridView::InsertItem(CXTPPropertyGridItem* pItem, int nIndex)
  550. {
  551. if (m_nLockUpdate > 0) return 0;
  552. if (!m_hWnd) return 0;
  554. if (pItem->IsHidden())
  555. return 0;
  557. pItem->OnBeforeInsert();
  558. nIndex = (int)::SendMessage(m_hWnd, LB_INSERTSTRING, nIndex, (LPARAM)pItem);
  560. ASSERT(nIndex != -1);
  561. SetItemDataPtr(nIndex, pItem);
  563. if (GetStyle() & LBS_OWNERDRAWVARIABLE)
  564. {
  565. MEASUREITEMSTRUCT measureItemStruct =
  566. {
  567. ODT_LISTBOX, 0, nIndex, 0, m_nItemHeight, (ULONG_PTR)pItem
  568. };
  569. MeasureItem(&measureItemStruct);
  570. SetItemHeight(nIndex, measureItemStruct.itemHeight);
  571. }
  573. pItem->SetVisible(TRUE);
  575. int nItemsInserted = 1;
  577. if (pItem->m_bExpanded)
  578. {
  579. nItemsInserted += _DoExpand(pItem, nIndex);
  580. }
  582. return nItemsInserted;
  583. }
  585. int CXTPPropertyGridView::_DoExpand(CXTPPropertyGridItem* pItem, int nIndex)
  586. {
  587. int nStart = nIndex;
  589. for (int i = 0; i < pItem->GetChilds()->GetCount(); i++)
  590. {
  591. CXTPPropertyGridItem* pChild = pItem->GetChilds()->GetAt(i);
  593. nIndex += InsertItem(pChild, nIndex + 1);
  595. }
  596. return nIndex - nStart;
  597. }
  599. void CXTPPropertyGridView::_RefreshIndexes()
  600. {
  601. if (m_hWnd)
  602. {
  603. for (int i = 0; i < GetCount(); i++)
  604. {
  605. CXTPPropertyGridItem* pItem = (CXTPPropertyGridItem*)GetItemDataPtr(i);
  606. ASSERT(pItem);
  607. if (!pItem)
  608. continue;
  610. if (pItem->m_nIndex != i)
  611. {
  612. pItem->m_nIndex = i;
  613. pItem->OnIndexChanged();
  614. }
  615. }
  616. }
  617. }
  619. void CXTPPropertyGridView::_DoCollapse(CXTPPropertyGridItem* pItem)
  620. {
  621. ASSERT(pItem);
  622. if (!pItem)
  623. return;
  624. ASSERT(pItem->m_bExpanded);
  625. int nIndex = pItem->m_nIndex + 1;
  627. while (nIndex < GetCount())
  628. {
  629. CXTPPropertyGridItem* pChild = (CXTPPropertyGridItem*)GetItemDataPtr(nIndex);
  630. ASSERT(pChild);
  631. if (!pChild || !pChild->HasParent(pItem))
  632. break;
  634. pChild->SetVisible(FALSE);
  635. DeleteString(nIndex);
  636. }
  637. _RefreshIndexes();
  638. }
  640. CXTPPropertyGridItem* CXTPPropertyGridView::GetItem(int nIndex) const
  641. {
  642. if (nIndex < 0 || nIndex >= GetCount())
  643. return 0;
  645. CXTPPropertyGridItem* pItem = (CXTPPropertyGridItem*)GetItemDataPtr(nIndex);
  647. if ((ULONG_PTR)pItem == (ULONG_PTR)(-1))
  648. return NULL;
  650. ASSERT(pItem);
  652. return pItem;
  653. }
  655. void CXTPPropertyGridView::SwitchExpandState(int nItem)
  656. {
  657. CXTPPropertyGridItem* pItem = GetItem(nItem);
  658. if (!pItem || !pItem->IsExpandable())
  659. return;
  661. if (pItem->m_bExpanded)
  662. pItem->Collapse();
  663. else
  664. pItem->Expand();
  665. }
  667. void CXTPPropertyGridView::OnLButtonDown(UINT nFlags, CPoint point)
  668. {
  669. if (HitTest(point) == PGV_HIT_SPLITTER)
  670. {
  671. SetFocus();
  672. SetCapture();
  673. if (m_pSelected) m_pSelected->OnValidateEdit();
  675. m_bTracking = TRUE;
  676. return;
  677. }
  680. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  681. if (pItem)
  682. {
  683. SetFocus();
  685. if (GetFocus() != this)
  686. return;
  688. if ((ItemFromPoint(point) == pItem) && pItem->OnLButtonDown(nFlags, point))
  689. return;
  690. }
  692. CListBox::OnLButtonDown(nFlags, point);
  693. }
  695. CXTPPropertyGridItem* CXTPPropertyGridView::ItemFromPoint(CPoint point) const
  696. {
  697. BOOL bOutside = FALSE;
  698. int nIndex = CListBox::ItemFromPoint(point, bOutside);
  699. if (nIndex != -1 && !bOutside)
  700. {
  701. CXTPPropertyGridItem* pItem  = GetItem(nIndex);
  702. if (!pItem)
  703. return NULL;
  705. if (GetStyle() & LBS_OWNERDRAWVARIABLE)
  706. {
  707. CRect rc;
  708. GetItemRect(nIndex, rc);
  709. if (!rc.PtInRect(point))
  710. return NULL;
  711. }
  713. return pItem;
  714. }
  715. return NULL;
  716. }
  718. void CXTPPropertyGridView::FocusInplaceButton(CXTPPropertyGridInplaceButton* pButton)
  719. {
  720. if (pButton != m_pFocusedButton)
  721. {
  722. if (pButton) SetFocus();
  723. m_pFocusedButton = pButton;
  724. Invalidate(FALSE);
  725. }
  726. }
  728. void CXTPPropertyGridView::OnMouseMove(UINT nFlags, CPoint point)
  729. {
  730. if (m_bTracking)
  731. {
  732. SetDividerPos(point.x);
  734. if (m_pSelected) m_pSelected->OnSelect();
  735. Invalidate(FALSE);
  736. return;
  737. }
  739. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  740. CXTPPropertyGridInplaceButton* pButton = NULL;
  742. if (pItem)
  743. pButton = pItem->GetInplaceButtons()->HitTest(point);
  745. if (pButton != m_pHotButton)
  746. {
  747. m_pHotButton = pButton;
  748. Invalidate(FALSE);
  749. TRACKMOUSEEVENT tme =
  750. {
  751. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, 0
  752. };
  753. _TrackMouseEvent (&tme);
  754. }
  756. ShowToolTip(point);
  758. CListBox::OnMouseMove(nFlags, point);
  759. }
  761. void CXTPPropertyGridView::OnLButtonUp(UINT nFlags, CPoint point)
  762. {
  763. if (m_bTracking)
  764. {
  765. ReleaseCapture();
  766. m_bTracking = FALSE;
  767. }
  769. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  771. if (pItem)
  772. {
  773. pItem->OnLButtonUp(nFlags, point);
  774. }
  776. CListBox::OnLButtonUp(nFlags, point);
  777. }
  779. void CXTPPropertyGridView::OnCaptureChanged(CWnd* pWnd)
  780. {
  781. m_bTracking = FALSE;
  783. CListBox::OnCaptureChanged(pWnd);
  784. }
  786. void CXTPPropertyGridView::OnLButtonDblClk(UINT nFlags, CPoint point)
  787. {
  788. CListBox::OnLButtonDblClk(nFlags, point);
  790. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  792. if (pItem)
  793. {
  794. pItem->OnLButtonDblClk(nFlags, point);
  797. if (pItem == ItemFromPoint(point))
  798. {
  799. SendNotifyMessage(XTP_PGN_DBLCLICK, (LPARAM)pItem);
  800. }
  801. }
  802. }
  804. void CXTPPropertyGridView::OnRButtonDown(UINT nFlags, CPoint point)
  805. {
  806. CListBox::OnRButtonDown(nFlags, point);
  808. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  810. if (pItem)
  811. {
  812. pItem->OnRButtonDown(nFlags, point);
  815. if (pItem == ItemFromPoint(point))
  816. {
  817. SendNotifyMessage(XTP_PGN_RCLICK, (LPARAM)pItem);
  818. }
  819. }
  820. }
  822. LRESULT CXTPPropertyGridView::SendNotifyMessage(WPARAM wParam, LPARAM lParam)
  823. {
  824. ASSERT(m_pGrid);
  825. if (!m_pGrid)
  826. return 0;
  828. return m_pGrid->SendNotifyMessage(wParam, lParam);
  829. }
  831. CXTPPropertyGridItem* CXTPPropertyGridView::GetSelectedItem()
  832. {
  833. return m_hWnd ? GetItem(GetCurSel()) : 0;
  834. }
  836. void CXTPPropertyGridView::OnChar(UINT nChar, UINT nRepCntr, UINT nFlags)
  837. {
  838. if (m_bTracking) return;
  840. if (m_pFocusedButton && nChar != VK_TAB)
  841. return;
  843. if (::GetFocus() != m_hWnd)
  844. return;
  846. CXTPPropertyGridItem* pItem = GetSelectedItem();
  848. if (nChar == '+' && pItem && pItem->HasChilds() && pItem->IsExpandable() && !pItem->m_bExpanded)
  849. {
  850. pItem->Expand();
  851. return;
  852. }
  853. if (nChar == '-' && pItem && pItem->HasChilds() && pItem->IsExpandable() && pItem->m_bExpanded)
  854. {
  855. pItem->Collapse();
  856. return;
  857. }
  858. if (nChar == VK_TAB)
  859. {
  860. if (m_pFocusedButton)
  861. {
  862. BOOL bForward = GetKeyState(VK_SHIFT) >= 0;
  863. m_pGrid->OnNavigate(bForward ? xtpGridUIInplaceEdit : xtpGridUIViewNext, bForward, pItem);
  864. }
  865. else
  866. {
  867. m_pGrid->OnNavigate(xtpGridUIView, GetKeyState(VK_SHIFT) >= 0, pItem);
  868. }
  869. return;
  870. }
  871. if (pItem && (nChar != VK_RETURN || !pItem->HasChilds()))
  872. {
  873. if (pItem->OnChar(nChar))
  874. return;
  875. }
  877. CWnd::OnChar(nChar, nRepCntr, nFlags);
  878. }
  880. UINT CXTPPropertyGridView::OnGetDlgCode()
  881. {
  882. return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTCHARS;
  883. }
  885. INT_PTR CXTPPropertyGridView::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  886. {
  888. ASSERT_VALID(this);
  889. ASSERT(::IsWindow(m_hWnd));
  891. // check child windows first by calling CControlBar
  892. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  893. if (nHit != -1)
  894. return nHit;
  896. if (m_pHotButton)
  897. {
  898. CString strTip = m_pHotButton->GetTooltip();
  899. if (strTip.GetLength() == 0)
  900. return -1;
  902. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, m_pHotButton->GetRect(),
  903. m_pHotButton->GetID(), strTip);
  905. return m_pHotButton->GetID();
  906. }
  908. CXTPPropertyGridItem* pItem = ItemFromPoint(point);
  909. if (pItem)
  910. {
  911. nHit = pItem->GetID();
  913. CString strTip = pItem->GetTooltip();
  914. if (strTip.GetLength() == 0)
  915. return -1;
  917. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, pItem->GetItemRect(),
  918. nHit, strTip, strTip, pItem->GetDescription(), GetImageManager());
  920. return nHit;
  921. }
  922. return -1;
  923. }
  926. void CXTPPropertyGridView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  927. {
  928. CListBox::OnKeyUp(nChar, nRepCnt, nFlags);
  929. }
  931. void CXTPPropertyGridView::OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  932. {
  933. CListBox::OnSysKeyUp(nChar, nRepCnt, nFlags);
  934. }
  936. void CXTPPropertyGridView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  937. {
  939. CXTPPropertyGridItem* pItem = GetSelectedItem();
  941. if (m_pFocusedButton && m_pFocusedButton->GetItem() == pItem)
  942. {
  943. m_pFocusedButton->OnKeyDown(nChar);
  944. return;
  945. }
  947. if ((GetKeyState(VK_CONTROL) < 0) && (nChar == VK_RIGHT || nChar == VK_LEFT))
  948. {
  949. CXTPDrawHelpers::KeyToLayout(this, nChar);
  951. SetDividerPos(GetDividerPos() + (nChar == VK_RIGHT ? 3 : -3));
  953. if (m_pSelected) m_pSelected->OnSelect();
  954. Invalidate(FALSE);
  956. return;
  957. }
  959. if (nChar == VK_RIGHT)
  960. {
  961. if (pItem && pItem->HasChilds() && !pItem->m_bExpanded && pItem->IsExpandable())
  962. {
  963. pItem->Expand();
  964. return;
  965. }
  966. }
  967. else if (nChar == VK_LEFT)
  968. {
  969. if (pItem && pItem->HasChilds() && pItem->m_bExpanded && pItem->IsExpandable())
  970. {
  971. pItem->Collapse();
  972. return;
  973. }
  974. }
  975. if (nChar == VK_RETURN)
  976. {
  977. SwitchExpandState(GetCurSel());
  978. return ;
  979. }
  980. if (nChar == VK_F4 && m_pSelected)
  981. {
  982. CXTPPropertyGridInplaceButton* pButton = m_pSelected->GetInplaceButtons()->Find(XTP_ID_PROPERTYGRID_COMBOBUTTON);
  983. if (pButton)
  984. m_pSelected->OnInplaceButtonDown(pButton);
  985. }
  987. if (m_pSelected && m_pSelected->OnKeyDown(nChar))
  988. {
  989. return;
  990. }
  993. CListBox::OnKeyDown(nChar, nRepCnt, nFlags);
  994. }
  996. void CXTPPropertyGridView::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  997. {
  999. if ((nChar == VK_DOWN || nChar == VK_UP) && m_pSelected)
  1000. {
  1001. CXTPPropertyGridInplaceButton* pButton = m_pSelected->GetInplaceButtons()->Find(XTP_ID_PROPERTYGRID_COMBOBUTTON);
  1002. if (pButton)
  1003. m_pSelected->OnInplaceButtonDown(pButton);
  1004. }
  1006. CListBox::OnSysKeyDown(nChar, nRepCnt, nFlags);
  1007. }
  1009. BOOL CXTPPropertyGridView::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1010. {
  1011. static BOOL bRelay = FALSE;
  1012. if (m_wndTip.GetSafeHwnd() && m_wndTip.IsWindowVisible() && !bRelay)
  1013. {
  1014. bRelay = TRUE;
  1015. RelayToolTipEvent(message);
  1016. bRelay = FALSE;
  1017. }
  1019. if (message == WM_MOUSELEAVE && m_pHotButton)
  1020. {
  1021. m_pHotButton = NULL;
  1022. Invalidate(FALSE);
  1023. }
  1025. if (m_pGrid->GetToolTipContext())
  1026. {
  1027. m_pGrid->GetToolTipContext()->FilterToolTipMessage(this, message, wParam, lParam);
  1028. }
  1030. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1031. }
  1034. void CXTPPropertyGridView::OnSelectionChanged()
  1035. {
  1036. CXTPPropertyGridItem* pItem = GetSelectedItem();
  1038. if (m_pSelected) m_pSelected->OnDeselect();
  1039. if (pItem) pItem->OnSelect();
  1041. m_pSelected = pItem;
  1043. if (m_pSelected) m_pGrid->OnSelectionChanged(m_pSelected);
  1044. }
  1046. int CXTPPropertyGridView::HitTest(CPoint point) const
  1047. {
  1048. if (!m_bVariableSplitterPos)
  1049. return -1;
  1051. int nDivider = GetDividerPos();
  1053. if ((point.x > nDivider - 4 && point.x <= nDivider + 2) && (GetCount() > 0))
  1054. return PGV_HIT_SPLITTER;
  1056. return -1;
  1057. }
  1059. BOOL CXTPPropertyGridView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1060. {
  1061. if (nHitTest == HTCLIENT)
  1062. {
  1063. CPoint point;
  1065. GetCursorPos(&point);
  1066. ScreenToClient(&point);
  1068. if (HitTest(point) == PGV_HIT_SPLITTER)
  1069. {
  1070. SetCursor(m_hCursor);
  1071. return TRUE;
  1072. }
  1073. }
  1075. return CListBox::OnSetCursor(pWnd, nHitTest, message);
  1076. }
  1078. void CXTPPropertyGridView::OnSize(UINT nType, int cx, int cy)
  1079. {
  1080. CListBox::OnSize(nType, cx, cy);
  1082. OnSelectionChanged();
  1084. Invalidate(FALSE);
  1085. }
  1088. // ToolTips routings
  1090. void CXTPPropertyGridView::_ShowToolTip(CRect rcBound, CRect rcText, CXTPPropertyGridItem* pItem, BOOL bValuePart)
  1091. {
  1092. if (!m_wndTip.GetSafeHwnd())
  1093. return;
  1095. m_wndTip.SetWindowText(m_strTipText);
  1096. m_wndTip.MoveWindow(rcText);
  1097. m_wndTip.Activate(TRUE, pItem, bValuePart);
  1099. m_rcToolTip = rcBound;
  1101. TRACKMOUSEEVENT tme =
  1102. {
  1103. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, 0
  1104. };
  1105. _TrackMouseEvent (&tme);
  1106. }
  1108. CSize CXTPPropertyGridView::_GetTextExtent(const CString& str, CXTPPropertyGridItem* pItem, BOOL bValuePart)
  1109. {
  1110. CWindowDC dc(this);
  1111. CXTPFontDC font(&dc, GetPaintManager()->GetItemFont(pItem, bValuePart));
  1112. return dc.GetTextExtent(str);
  1113. }
  1115. void CXTPPropertyGridView::ShowToolTip(CPoint pt)
  1116. {
  1117. if (CXTPMouseMonitor::IsMouseHooked())
  1118. return;
  1120. if (!m_pGrid->m_bEnableTooltips)
  1121. return;
  1123. if (!m_wndTip.GetSafeHwnd())
  1124. {
  1125. m_wndTip.Create(this);
  1126. }
  1128. if (m_pHotButton)
  1129. return;
  1131. CXTPPropertyGridItem* pItem = ItemFromPoint(pt);
  1133. if (!pItem || pItem->IsCategory() || !pItem->GetTooltip().IsEmpty())
  1134. return;
  1136. int nDividerPos = GetDividerPos();
  1138. CRect rc = pItem->GetItemRect();
  1139. CRect rcCaption(rc.left, rc.top, rc.left + nDividerPos, rc.bottom);
  1141. if (rcCaption.PtInRect(pt))
  1142. {
  1143. if (m_strTipText == pItem->GetCaption())
  1144. return;
  1146. if (pItem->GetMarkupUIElement())
  1147. return;
  1149. m_strTipText = pItem->GetCaption();
  1151. ClientToScreen(&rcCaption);
  1153. CRect rcCaptionText(rcCaption);
  1154. rcCaptionText.left += pItem->m_nIndent * XTP_PGI_EXPAND_BORDER + 3 - 3 -1;
  1155. rcCaptionText.top--;
  1156. GetPaintManager()->AdjustItemCaptionRect(pItem, rcCaptionText);
  1158. int nTextExtent = _GetTextExtent(m_strTipText, pItem, FALSE).cx;
  1160. if (nTextExtent + 3 > rcCaptionText.Width())
  1161. {
  1162. if (GetExStyle() & WS_EX_LAYOUTRTL)
  1163. {
  1164. rcCaptionText.left = rcCaption.right - nTextExtent - 7 - (pItem->m_nIndent * XTP_PGI_EXPAND_BORDER);
  1166. }
  1168. _ShowToolTip(rcCaption, rcCaptionText, pItem, FALSE);
  1169. }
  1170. }
  1171. else
  1172. {
  1173. if (m_strTipText == pItem->GetViewValue())
  1174. return;
  1176. if (pItem->IsMultiLine())
  1177. return;
  1179. m_strTipText = pItem->GetViewValue();
  1181. if (GetFocus() && GetFocus()->IsKindOf(RUNTIME_CLASS(CXTPPropertyGridInplaceEdit)))
  1182. {
  1183. if (((CXTPPropertyGridInplaceEdit*)(GetFocus()))->GetItem() == pItem)
  1184. return;
  1185. }
  1187. CRect rcValue(rc.left + nDividerPos, rc.top, rc.right, rc.bottom);
  1188. ClientToScreen(&rcValue);
  1190. CRect rcValueText = pItem->GetValueRect();
  1191. rcValueText.InflateRect(1, 2, 0, 1);
  1192. ClientToScreen(&rcValueText);
  1194. int nTextExtent = _GetTextExtent(m_strTipText, pItem, TRUE).cx;
  1196. if (nTextExtent + 3 > rcValueText.Width())
  1197. {
  1198. if (GetExStyle() & WS_EX_LAYOUTRTL)
  1199. {
  1200. rcValueText.left = rcValueText.right - 8 - nTextExtent;
  1202. }
  1203. _ShowToolTip(rcValue, rcValueText, pItem, TRUE);
  1204. }
  1205. }
  1206. }
  1209. void CXTPPropertyGridView::RelayToolTipEvent(UINT message)
  1210. {
  1211. if (m_wndTip.GetSafeHwnd() && m_wndTip.IsWindowVisible())
  1212. {
  1213. CRect rc;
  1214. m_wndTip.GetWindowRect(rc);
  1216. CPoint pt;
  1217. GetCursorPos(&pt);
  1219. if (!m_rcToolTip.PtInRect(pt) || m_pHotButton)
  1220. {
  1221. m_strTipText = "";
  1222. m_wndTip.Activate(FALSE, 0, 0);
  1223. }
  1225. switch (message)
  1226. {
  1227. case WM_MOUSEWHEEL:
  1228. m_strTipText = "";
  1229. m_wndTip.Activate(FALSE, 0, 0);
  1230. break;
  1232. case WM_KEYDOWN:
  1233. case WM_SYSKEYDOWN:
  1234. case WM_LBUTTONDOWN:
  1235. case WM_RBUTTONDOWN:
  1236. case WM_MBUTTONDOWN:
  1237. case WM_LBUTTONUP:
  1238. case WM_RBUTTONUP:
  1239. case WM_MBUTTONUP:
  1240. case WM_MOUSELEAVE:
  1241. m_wndTip.Activate(FALSE, 0, 0);
  1242. break;
  1243. }
  1244. }
  1246. }
  1249. void CXTPPropertyGridView::OnSetFocus(CWnd* pOldWnd)
  1250. {
  1251. m_pFocusedButton = NULL;
  1253. CListBox::OnSetFocus(pOldWnd);
  1255. if (GetStyle() & LBS_MULTIPLESEL)
  1256. Invalidate(FALSE);
  1258. }
  1259. void CXTPPropertyGridView::OnKillFocus (CWnd* pNewWnd)
  1260. {
  1261. m_pFocusedButton = NULL;
  1263. CListBox::OnKillFocus(pNewWnd);
  1265. if (GetStyle() & LBS_MULTIPLESEL)
  1266. Invalidate(FALSE);
  1268. }
  1271. CXTPPropertyGridPaintManager* CXTPPropertyGridView::GetPaintManager() const
  1272. {
  1273. return m_pGrid->GetPaintManager();
  1274. }
  1276. CXTPImageManager* CXTPPropertyGridView::GetImageManager() const
  1277. {
  1278. return m_pGrid->GetImageManager();
  1279. }
  1281. //////////////////////////////////////////////////////////////////////////
  1282. // Accessible
  1284. LRESULT CXTPPropertyGridView::OnGetObject(WPARAM wParam, LPARAM lParam)
  1285. {
  1286. if (lParam != OBJID_CLIENT)
  1287. return (LRESULT)Default();
  1289. LPUNKNOWN lpUnknown = GetInterface(&IID_IAccessible);
  1290. if (!lpUnknown)
  1291. return E_FAIL;
  1293. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  1294. }
  1296. BEGIN_INTERFACE_MAP(CXTPPropertyGridView, CCmdTarget)
  1297. INTERFACE_PART(CXTPPropertyGridView, IID_IAccessible, ExternalAccessible)
  1298. END_INTERFACE_MAP()
  1300. CCmdTarget* CXTPPropertyGridView::GetAccessible()
  1301. {
  1302. return this;
  1303. }
  1305. HRESULT CXTPPropertyGridView::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  1306. {
  1307. *ppdispParent = NULL;
  1309. if (GetSafeHwnd())
  1310. {
  1311. return AccessibleObjectFromWindow(GetSafeHwnd(), OBJID_WINDOW, IID_IDispatch, (void**)ppdispParent);
  1312. }
  1313. return E_FAIL;
  1314. }
  1316. HRESULT CXTPPropertyGridView::GetAccessibleChildCount(long FAR* pChildCount)
  1317. {
  1318. if (pChildCount == 0)
  1319. {
  1320. return E_INVALIDARG;
  1321. }
  1323. *pChildCount = CListBox::GetCount();
  1324. return S_OK;
  1325. }
  1327. HRESULT CXTPPropertyGridView::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  1328. {
  1329. *ppdispChild = NULL;
  1330. int nChild = GetChildIndex(&varChild);
  1332. if (nChild <= 0)
  1333. {
  1334. return E_INVALIDARG;
  1335. }
  1337. CXTPPropertyGridItem* pItem = GetItem(nChild - 1);
  1338. if (!pItem)
  1339. {
  1340. return E_INVALIDARG;
  1341. }
  1343. *ppdispChild = pItem->GetIDispatch(TRUE);
  1344. return S_OK;
  1345. }
  1347. HRESULT CXTPPropertyGridView::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1348. {
  1349. int nChild = GetChildIndex(&varChild);
  1351. if (nChild == CHILDID_SELF || nChild == -1)
  1352. {
  1353. *pszName = SysAllocString(L"Properties Window");
  1354. return S_OK;
  1355. }
  1357. return E_INVALIDARG;
  1358. }
  1360. HRESULT CXTPPropertyGridView::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1361. {
  1362. pvarRole->vt = VT_EMPTY;
  1363. int nChild = GetChildIndex(&varChild);
  1365. if (nChild == CHILDID_SELF)
  1366. {
  1367. pvarRole->vt = VT_I4;
  1368. pvarRole->lVal = ROLE_SYSTEM_TABLE;
  1369. return S_OK;
  1370. }
  1372. return E_INVALIDARG;
  1373. }
  1375. HRESULT CXTPPropertyGridView::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  1376. {
  1377. pvarState->vt = VT_I4;
  1378. pvarState->lVal = 0;
  1379. int nChild = GetChildIndex(&varChild);
  1381. if (nChild == CHILDID_SELF)
  1382. {
  1383. pvarState->lVal = STATE_SYSTEM_FOCUSABLE;
  1384. }
  1386. return S_OK;
  1387. }
  1390. HRESULT CXTPPropertyGridView::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  1391. {
  1392. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  1394. if (!GetSafeHwnd())
  1395. return S_OK;
  1397. CRect rc;
  1398. GetWindowRect(&rc);
  1400. int nChild = GetChildIndex(&varChild);
  1402. if (nChild != CHILDID_SELF)
  1403. {
  1404. return E_INVALIDARG;
  1405. }
  1407. *pxLeft = rc.left;
  1408. *pyTop = rc.top;
  1409. *pcxWidth = rc.Width();
  1410. *pcyHeight = rc.Height();
  1412. return S_OK;
  1413. }
  1415. HRESULT CXTPPropertyGridView::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  1416. {
  1417. if (pvarID == NULL)
  1418. return E_INVALIDARG;
  1420. pvarID->vt = VT_EMPTY;
  1422. if (!GetSafeHwnd())
  1423. return S_FALSE;
  1425. if (!CXTPWindowRect(this).PtInRect(CPoint(xLeft, yTop)))
  1426. return S_FALSE;
  1428. pvarID->vt = VT_I4;
  1429. pvarID->lVal = CHILDID_SELF;
  1431. CPoint pt(xLeft, yTop);
  1432. ScreenToClient(&pt);
  1434. CXTPPropertyGridItem* pItem = ItemFromPoint(pt);
  1436. if (pItem)
  1437. {
  1438. pvarID->vt = VT_DISPATCH;
  1439. pvarID->pdispVal = pItem->GetIDispatch(TRUE);
  1440. }
  1442. return S_OK;
  1443. }