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

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

对话框与窗口

开发平台：

Visual C++

XTPPropertyGridItem.cpp：源码内容
  1. // XTPPropertyGridItem.cpp : implementation of the CXTPPropertyGridItem 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/XTPVC80Helpers.h"
  23. #include "Common/XTPDrawHelpers.h"
  24. #include "Common/XTPImageManager.h"
  25. #include "Common/XTPMarkupRender.h"
  27. #include "XTPPropertyGridInplaceEdit.h"
  28. #include "XTPPropertyGridInplaceButton.h"
  29. #include "XTPPropertyGridInplaceList.h"
  30. #include "XTPPropertyGridItem.h"
  31. #include "XTPPropertyGrid.h"
  32. #include "XTPPropertyGridDefines.h"
  35. #ifdef _DEBUG
  36. #define new DEBUG_NEW
  37. #undef THIS_FILE
  38. static char THIS_FILE[] = __FILE__;
  39. #endif
  41. /////////////////////////////////////////////////////////////////////////////
  42. // CXTPPropertyGridItem
  44. IMPLEMENT_DYNAMIC(CXTPPropertyGridItem, CCmdTarget)
  46. CXTPPropertyGridItem::CXTPPropertyGridItem(LPCTSTR lpszCaption, LPCTSTR strValue, CString* pBindString)
  47. {
  49. Init();
  50. SetPrompt(lpszCaption);
  51. m_strDefaultValue = m_strValue = strValue;
  53. BindToString(pBindString);
  54. }
  57. CXTPPropertyGridItem::CXTPPropertyGridItem(UINT nID, LPCTSTR strValue, CString* pBindString)
  58. {
  59. Init();
  60. m_nID = nID;
  62. CString strPrompt;
  63. if (strPrompt.LoadString(nID))
  64. {
  65. SetPrompt(strPrompt);
  66. }
  68. m_strDefaultValue = m_strValue = strValue;
  69. BindToString(pBindString);
  70. }
  72. CXTPPropertyGridItem::~CXTPPropertyGridItem()
  73. {
  74. Clear();
  76. XTPMarkupReleaseElement(m_pMarkupUIElement);
  77. }
  79. void CXTPPropertyGridItem::Clear()
  80. {
  81. if (m_pGrid && m_pGrid->m_pSelected == this)
  82. {
  83. m_pGrid->m_pSelected = NULL;
  84. }
  86. if (m_pGrid && m_pGrid->m_pHotButton && m_pInplaceButtons)
  87. {
  88. for (int i = 0; i < m_pInplaceButtons->GetCount(); i++)
  89. {
  90. if (m_pInplaceButtons->GetAt(i) == m_pGrid->m_pHotButton)
  91. {
  92. m_pGrid->m_pHotButton = NULL;
  93. break;
  94. }
  95. }
  96. }
  98. if (m_pGrid && GetInplaceList().m_pItem == this)
  99. {
  100. GetInplaceList().DestroyItem();
  101. }
  102. if (m_pGrid && GetInplaceEdit().m_pItem == this)
  103. {
  104. GetInplaceEdit().DestroyItem();
  105. }
  107. if (m_pChilds)
  108. {
  109. m_pChilds->Clear();
  110. CMDTARGET_RELEASE(m_pChilds);
  111. }
  113. if (m_pConstraints)
  114. {
  115. m_pConstraints->m_pItem = NULL;
  116. CMDTARGET_RELEASE(m_pConstraints);
  117. }
  119. CMDTARGET_RELEASE(m_pValueMetrics);
  120. CMDTARGET_RELEASE(m_pCaptionMetrics);
  121. CMDTARGET_RELEASE(m_pInplaceButtons);
  123. SAFE_DELETE(m_pInplaceControls);
  125. m_pGrid = NULL;
  126. }
  128. void CXTPPropertyGridItem::SetPrompt(LPCTSTR lpszPrompt)
  129. {
  130. if (lpszPrompt == 0)
  131. return;
  133. LPCTSTR lpszDescription = _tcschr(lpszPrompt, _T('n'));
  135. CString strCaption;
  137. if (lpszDescription == NULL)
  138. {
  139. strCaption = lpszPrompt;
  140. }
  141. else
  142. {
  143. int nLen = (int)(lpszDescription - lpszPrompt);
  144. LPTSTR lpszCaption = strCaption.GetBufferSetLength(nLen);
  145. MEMCPY_S(lpszCaption, lpszPrompt, nLen * sizeof(TCHAR));
  147. m_strDescription = lpszDescription + 1;
  148. }
  150. SetCaption(strCaption);
  151. }
  154. void CXTPPropertyGridItem::Init()
  155. {
  156. m_bHidden = FALSE;
  157. m_bExpanded = FALSE;
  158. m_nIndex = -1;
  159. m_bVisible = FALSE;
  160. m_pParent = 0;
  161. m_pGrid = 0;
  162. m_nIndent = 0;
  163. m_strValue = "";
  164. m_bReadOnly = FALSE;
  165. m_bCategory = FALSE;
  166. m_nID = 0;
  167. m_nFlags = xtpGridItemHasEdit;
  168. m_pConstraints = new CXTPPropertyGridItemConstraints(this);
  169. m_pInplaceButtons = new CXTPPropertyGridInplaceButtons(this);
  170. m_pInplaceControls = new CXTPPropertyGridInplaceControls();
  171. m_pConstraints->SetCurrent(-1);
  172. m_pBindString = 0;
  173. m_bConstraintEdit = FALSE;
  175. m_bAutoComplete = FALSE;
  177. m_nLinesCount = 1;
  178. m_nHeight = -1;
  180. m_nDropDownItemCount = 10;
  182. m_bExpandable = TRUE;
  184. m_bUseMask = FALSE;
  185. m_bPassword = FALSE;
  186. m_chPrompt = _T('*');
  188. m_dwData = 0;
  189. m_dwEditStyle = ES_AUTOHSCROLL;
  191. m_pMarkupUIElement = NULL;
  193. EnableAutomation();
  195. m_pValueMetrics = 0;
  196. m_pCaptionMetrics = 0;
  199. m_pChilds = new CXTPPropertyGridItems();
  200. }
  202. void CXTPPropertyGridItem::OnAddChildItem()
  203. {
  204. if (!m_bCategory) SetFlags(m_nFlags);
  205. }
  207. void CXTPPropertyGridItem::SetFlags(UINT nFlags)
  208. {
  209. ASSERT(!m_bCategory || ((nFlags & xtpGridItemHasEdit) == 0));
  210. m_nFlags = nFlags;
  212. m_pInplaceButtons->Remove(XTP_ID_PROPERTYGRID_EXPANDBUTTON);
  213. m_pInplaceButtons->Remove(XTP_ID_PROPERTYGRID_COMBOBUTTON);
  215. if (m_nFlags & xtpGridItemHasExpandButton)
  216. m_pInplaceButtons->AddExpandButton();
  218. if (m_nFlags & xtpGridItemHasComboButton)
  219. m_pInplaceButtons->AddComboButton();
  220. }
  222. UINT CXTPPropertyGridItem::GetFlags() const
  223. {
  224. return m_nFlags;
  225. }
  227. CXTPPropertyGridItemMetrics* CXTPPropertyGridItem::GetValueMetrics() const
  228. {
  229. if (m_pValueMetrics == 0)
  230. m_pValueMetrics = new CXTPPropertyGridItemMetrics(m_pGrid->GetPaintManager());
  231. return m_pValueMetrics;
  232. }
  234. CXTPPropertyGridItemMetrics* CXTPPropertyGridItem::GetCaptionMetrics() const
  235. {
  236. if (m_pCaptionMetrics == 0)
  237. m_pCaptionMetrics = new CXTPPropertyGridItemMetrics(m_pGrid->GetPaintManager());
  238. return m_pCaptionMetrics;
  239. }
  241. CXTPPropertyGridItemMetrics* CXTPPropertyGridItem::GetMetrics(BOOL bValueMetrics, BOOL bCreate /*= TRUE*/) const
  242. {
  243. if (bCreate)
  244. return bValueMetrics ? GetValueMetrics() : GetCaptionMetrics();
  246. return bValueMetrics ? m_pValueMetrics : m_pCaptionMetrics;
  247. }
  249. CXTPPropertyGridItem* CXTPPropertyGridItem::AddChildItem(CXTPPropertyGridItem* pItem)
  250. {
  251. return InsertChildItem(m_pChilds->GetCount(), pItem);
  252. }
  254. void CXTPPropertyGridItem::SetIndent(int nIndent)
  255. {
  256. m_nIndent = nIndent;
  258. for (int i = 0; i < m_pChilds->GetCount(); i++)
  259. {
  260. m_pChilds->GetAt(i)->SetIndent(nIndent + 1);
  261. }
  262. }
  264. CXTPPropertyGridItem* CXTPPropertyGridItem::InsertChildItem(int nIndex, CXTPPropertyGridItem* pItem)
  265. {
  266. ASSERT(pItem);
  267. if (!pItem)
  268. return NULL;
  270. ASSERT(!pItem->IsCategory() || IsCategory());
  271. ASSERT(m_pGrid != NULL);
  272. if (!m_pGrid)
  273. return pItem;
  275. if (nIndex < 0 || nIndex > m_pChilds->GetCount())
  276. nIndex = m_pChilds->GetCount();
  278. m_pChilds->InsertAt(nIndex, pItem);
  279. pItem->m_pGrid = m_pGrid;
  281. ASSERT(pItem->m_pParent == NULL);
  282. pItem->m_pParent = this;
  283. pItem->SetIndent(m_nIndent + 1);
  285. pItem->OnCaptionChanged();
  287. pItem->OnAddChildItem();
  289. if (m_bVisible)
  290. {
  291. if (m_bExpanded) m_pGrid->SetPropertySort(m_pGrid->m_properetySort, TRUE);
  292. else if (m_pGrid->GetSafeHwnd() && m_pChilds->GetCount() == 1) m_pGrid->Invalidate(FALSE);
  293. }
  295. return pItem;
  296. }
  298. void CXTPPropertyGridItem::Move(CXTPPropertyGridItem* pParent, int nIndex /* = -1 */)
  299. {
  300. if (!pParent)
  301. return;
  303. InternalAddRef();
  304. Remove();
  305. pParent->InsertChildItem(nIndex, this);
  306. }
  308. void CXTPPropertyGridItem::Collapse()
  309. {
  310. if (!m_bExpanded) return;
  312. if (m_pGrid->m_nLockUpdate == 0)
  313. {
  314. if (m_pGrid->GetSafeHwnd() && m_bVisible)
  315. {
  316. m_pGrid->_DoCollapse(this);
  317. m_pGrid->OnSelectionChanged();
  318. }
  319. }
  321. m_bExpanded = FALSE;
  323. m_pGrid->SendNotifyMessage(XTP_PGN_ITEMEXPANDCHANGED, (LPARAM)this);
  324. }
  326. void CXTPPropertyGridItem::Expand()
  327. {
  328. if (m_bExpanded) return;
  330. if (m_pGrid->m_nLockUpdate == 0)
  331. {
  332. if (m_pGrid->GetSafeHwnd() && m_bVisible)
  333. {
  334. m_pGrid->_DoExpand(this, m_nIndex);
  335. m_pGrid->_RefreshIndexes();
  336. m_pGrid->OnSelectionChanged();
  337. }
  338. }
  340. m_bExpanded = TRUE;
  342. m_pGrid->SendNotifyMessage(XTP_PGN_ITEMEXPANDCHANGED, (LPARAM)this);
  344. }
  346. BOOL CXTPPropertyGridItem::HasParent(CXTPPropertyGridItem* pParent)
  347. {
  348. if (m_pParent == NULL) return FALSE;
  349. if (m_pParent == pParent) return TRUE;
  350. return m_pParent->HasParent(pParent);
  351. }
  353. void CXTPPropertyGridItem::Select()
  354. {
  355. ASSERT(m_pGrid);
  356. if (!m_pGrid)
  357. return;
  359. if (!m_bVisible)
  360. return;
  362. if (m_pGrid->GetStyle() & LBS_MULTIPLESEL)
  363. {
  364. m_pGrid->SelItemRange(FALSE, 0, m_pGrid->GetCount());
  365. m_pGrid->SetSel(m_nIndex);
  366. }
  367. else
  368. {
  369. m_pGrid->SetCurSel(m_nIndex);
  370. }
  371. m_pGrid->OnSelectionChanged();
  372. }
  374. void CXTPPropertyGridItem::OnDeselect()
  375. {
  376. if (m_pGrid) m_pGrid->FocusInplaceButton(NULL);
  377. OnValidateEdit();
  379. for (int i = m_pInplaceControls->GetCount() - 1; i >= 0; i--)
  380. {
  381. CXTPPropertyGridInplaceControl* pControl = m_pInplaceControls->GetAt(i);
  382. pControl->OnDestroyWindow();
  383. }
  384. }
  386. void CXTPPropertyGridItem::OnValidateEdit()
  387. {
  388. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  389. wndEdit.HideWindow();
  391. if (wndEdit.GetSafeHwnd() && wndEdit.m_pItem == this)
  392. {
  393. CString strValue;
  394. wndEdit.GetWindowText(strValue);
  395. wndEdit.m_pItem = NULL;
  397. if (wndEdit.m_bCancel)
  398. {
  399. OnCancelEdit();
  400. }
  401. else if (wndEdit.m_bEditMode && OnAfterEdit(strValue))
  402. {
  403. if (m_strValue != strValue && !wndEdit.m_bCancel)
  404. {
  405. OnValueChanged(strValue);
  406. }
  407. }
  408. }
  409. }
  411. void CXTPPropertyGridItem::SetEditText(const CString& str)
  412. {
  413. if (!m_pGrid) return;
  415. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  416. if (wndEdit.GetSafeHwnd() && wndEdit.m_pItem == this)
  417. {
  418. wndEdit.SetWindowText(str);
  419. }
  420. }
  422. void CXTPPropertyGridItem::SetMultiLinesCount(int nLinesCount)
  423. {
  424. if (m_nLinesCount == nLinesCount)
  425. return;
  427. m_nLinesCount = nLinesCount;
  429. RefreshHeight();
  430. }
  432. void CXTPPropertyGridItem::SetHeight(int nHeight)
  433. {
  434. if (m_nHeight == nHeight)
  435. return;
  437. m_nHeight = nHeight;
  439. RefreshHeight();
  440. }
  442. void CXTPPropertyGridItem::RefreshHeight()
  443. {
  444. if (IsVisible() && m_pGrid->GetSafeHwnd() && m_pGrid->GetStyle() & LBS_OWNERDRAWVARIABLE && m_nIndex >= 0)
  445. {
  446. MEASUREITEMSTRUCT measureItemStruct =
  447. {
  448. ODT_LISTBOX, 0, m_nIndex, 0, 0, (ULONG_PTR)this
  449. };
  450. m_pGrid->MeasureItem(&measureItemStruct);
  451. m_pGrid->SetItemHeight(m_nIndex, measureItemStruct.itemHeight);
  452. m_pGrid->Invalidate(FALSE);
  453. }
  454. }
  456. void CXTPPropertyGridItem::SetValue(CString strValue)
  457. {
  458. m_strValue = strValue;
  460. if (m_pBindString)
  461. {
  462. *m_pBindString = strValue;
  463. }
  465. SetEditText(m_strValue);
  467. for (int i = m_pInplaceControls->GetCount() - 1; i >= 0; i--)
  468. {
  469. CXTPPropertyGridInplaceControl* pControl = m_pInplaceControls->GetAt(i);
  470. pControl->OnValueChanged();
  471. }
  473. SAFE_INVALIDATE(m_pGrid);
  474. }
  476. void CXTPPropertyGridItem::OnValueChanged(CString strValue)
  477. {
  478. if (!m_pGrid)
  479. return;
  481. SetValue(strValue);
  482. SAFE_INVALIDATE(m_pGrid);
  483. m_pGrid->SendNotifyMessage(XTP_PGN_ITEMVALUE_CHANGED, (LPARAM)this);
  484. }
  486. BOOL CXTPPropertyGridItem::OnRequestEdit()
  487. {
  488. XTP_PROPERTYGRID_NOTIFYEDIT notify;
  489. notify.bCancel = FALSE;
  490. notify.pItem = this;
  492. if (m_pGrid)
  493. {
  494. m_pGrid->SendNotifyMessage(XTP_PGN_REQUESTEDIT, (LPARAM)&notify);
  495. }
  496. return !notify.bCancel;
  497. }
  499. BOOL CXTPPropertyGridItem::OnAfterEdit(CString& strValue)
  500. {
  501. if (!m_pGrid)
  502. return FALSE;
  504. XTP_PROPERTYGRID_NOTIFYEDIT notify;
  505. notify.bCancel = FALSE;
  506. notify.strValue = strValue;
  507. notify.pItem = this;
  509. if (m_pGrid)
  510. {
  511. m_pGrid->SendNotifyMessage(XTP_PGN_AFTEREDIT, (LPARAM)&notify);
  512. strValue = notify.strValue;
  513. }
  514. return !notify.bCancel;
  515. }
  517. void CXTPPropertyGridItem::OnCancelEdit()
  518. {
  519. XTP_PROPERTYGRID_NOTIFYEDIT notify;
  520. notify.bCancel = FALSE;
  521. notify.pItem = this;
  523. if (m_pGrid)
  524. {
  525. m_pGrid->SendNotifyMessage(XTP_PGN_CANCELEDIT, (LPARAM)&notify);
  526. }
  527. }
  530. void CXTPPropertyGridItem::OnSelect()
  531. {
  532. ASSERT(m_bVisible);
  534. CString strValue(m_strValue);
  536. if (m_pInplaceControls->GetCount() > 0)
  537. {
  538. CRect rcValue(GetInplaceWindowsRect());
  540. for (int i = m_pInplaceControls->GetCount() - 1; i >= 0; i--)
  541. {
  542. CXTPPropertyGridInplaceControl* pControl = m_pInplaceControls->GetAt(i);
  543. pControl->OnCreateWindow(rcValue);
  544. }
  545. }
  547. if (m_nFlags & xtpGridItemHasEdit)
  548. {
  549. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  551. wndEdit.SetValue(strValue);
  552. wndEdit.Create(this, GetValueRect());
  553. wndEdit.SetReadOnly(GetReadOnly() || m_bConstraintEdit);
  554. }
  555. else
  556. {
  557. GetInplaceEdit().HideWindow();
  558. }
  559. }
  561. DWORD CXTPPropertyGridItem::GetEditStyle() const
  562. {
  563. return WS_CHILD | (m_bPassword ? ES_PASSWORD: 0) | (IsMultiLine() ? ES_MULTILINE : 0) | m_dwEditStyle;
  564. }
  566. void CXTPPropertyGridItem::OnInplaceButtonDown(CXTPPropertyGridInplaceButton* pButton)
  567. {
  568. if (GetReadOnly())
  569. return;
  571. if (m_pGrid->SendNotifyMessage(XTP_PGN_INPLACEBUTTONDOWN, (LPARAM)pButton) == TRUE)
  572. return;
  574. if ((pButton->GetID() == XTP_ID_PROPERTYGRID_COMBOBUTTON) && !m_pConstraints->IsEmpty() && OnRequestEdit())
  575. {
  576. GetInplaceList().Create(this, GetItemRect());
  577. m_pGrid->Invalidate(FALSE);
  578. }
  579. }
  581. CRect CXTPPropertyGridItem::GetInplaceWindowsRect()
  582. {
  583. ASSERT(m_bVisible);
  584. CRect rc = GetItemRect();
  585. CRect rcValue(m_pGrid->GetDividerPos() + 1, rc.top + 1, rc.right, rc.bottom - 1);
  587. if (IsInplaceButtonsVisible())
  588. {
  589. for (int i = 0; i < m_pInplaceButtons->GetCount(); i++)
  590. rcValue.right -= m_pInplaceButtons->GetAt(i)->GetWidth();
  591. }
  593. m_pGrid->GetPaintManager()->AdjustItemValueRect(this, rcValue);
  595. return rcValue;
  596. }
  598. CRect CXTPPropertyGridItem::GetValueRect()
  599. {
  600. CRect rcValue = GetInplaceWindowsRect();
  602. for (int i = m_pInplaceControls->GetCount() - 1; i >= 0; i--)
  603. {
  604. CXTPPropertyGridInplaceControl* pControl = m_pInplaceControls->GetAt(i);
  605. pControl->OnAdjustValueRect(rcValue);
  606. }
  608. return rcValue;
  609. }
  611. CRect CXTPPropertyGridItem::GetItemRect() const
  612. {
  613. CRect rc;
  614. m_pGrid->GetItemRect(m_nIndex, rc);
  615. return rc;
  616. }
  618. BOOL CXTPPropertyGridItem::OnChar(UINT nChar)
  619. {
  620. ASSERT(nChar != VK_TAB);
  622. if ((m_nFlags & xtpGridItemHasEdit) && (nChar != VK_ESCAPE))
  623. {
  624. OnSelect();
  626. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  627. if (wndEdit.GetSafeHwnd() && wndEdit.IsWindowVisible() && wndEdit.GetItem() == this)
  628. {
  629. wndEdit.SetFocus();
  630. wndEdit.SetSel(0, -1);
  631. if ((nChar != VK_TAB) && (wndEdit.GetItem() == this)) wndEdit.SendMessage(WM_CHAR, nChar);
  632. }
  634. return TRUE;
  635. }
  636. else if (nChar == VK_TAB)
  637. {
  638. if (m_pInplaceButtons->GetCount() > 0)
  639. {
  640. m_pGrid->GetPropertyGrid()->OnNavigate(xtpGridUIInplaceEdit, TRUE, this);
  641. }
  642. }
  643. return FALSE;
  644. }
  646. BOOL CXTPPropertyGridItem::IsValueChanged() const
  647. {
  648. return m_strDefaultValue != m_strValue;
  649. }
  651. void CXTPPropertyGridItem::ResetValue()
  652. {
  653. OnValueChanged(m_strDefaultValue);
  654. }
  656. void CXTPPropertyGridItem::SetDefaultValue(LPCTSTR lpszDefaultValue)
  657. {
  658. m_strDefaultValue = lpszDefaultValue;
  659. }
  661. void CXTPPropertyGridItem::OnLButtonUp(UINT /*nFlags*/, CPoint /*point*/)
  662. {
  664. }
  666. BOOL CXTPPropertyGridItem::PtInValueRect(CPoint point)
  667. {
  668. CRect rc(GetValueRect());
  669. return rc.PtInRect(point);
  670. }
  672. void CXTPPropertyGridItem::OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
  673. {
  674. CXTPPropertyGridInplaceButton* pInplaceButton = m_pInplaceButtons->HitTest(point);
  675. if (pInplaceButton && IsInplaceButtonsVisible())
  676. {
  677. OnSelect();
  678. return;
  679. }
  681. if (HasChilds() && IsExpandable())
  682. {
  683. if (m_bExpanded)
  684. Collapse();
  685. else
  686. Expand();
  687. }
  688. else
  689. {
  690. OnSelect();
  692. if (m_nFlags & xtpGridItemHasEdit)
  693. {
  694. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  695. if (wndEdit.GetSafeHwnd() && wndEdit.IsWindowVisible() && wndEdit.GetItem() == this)
  696. {
  697. wndEdit.SetFocus();
  699. if (wndEdit.GetItem() == this && !GetReadOnly() && wndEdit.SelectConstraint(+1, TRUE))
  700. {
  701. OnValidateEdit();
  703. }
  704. else
  705. {
  706. wndEdit.SetSel(0, -1);
  707. }
  708. }
  709. }
  710. else if (!GetReadOnly())
  711. {
  712. SelectNextConstraint();
  713. }
  714. }
  715. }
  717. BOOL CXTPPropertyGridItem::SelectNextConstraint()
  718. {
  719. CXTPPropertyGridItemConstraints* pList = GetConstraints();
  720. if (pList->IsEmpty())
  721. return FALSE;
  723. if (!OnRequestEdit())
  724. return FALSE;
  726. int nIndex = pList->FindConstraint(m_strValue);
  728. nIndex += +1;
  729. if (nIndex >= pList->GetCount()) nIndex = 0;
  730. if (nIndex < 0) nIndex = (ULONG)pList->GetCount() - 1;
  732. CString strValue = pList->GetAt(nIndex);
  734. if (!OnAfterEdit(strValue))
  735. return FALSE;
  737. pList->SetCurrent(nIndex);
  738. OnValueChanged(strValue);
  739. return TRUE;
  740. }
  742. BOOL CXTPPropertyGridItem::OnLButtonDown(UINT nFlags, CPoint point)
  743. {
  744. BOOL bOldSelected = IsSelected();
  746. if (GetGrid()->GetStyle() & LBS_MULTIPLESEL)
  747. {
  748. GetGrid()->Default();
  749. GetGrid()->OnSelectionChanged();
  750. ReleaseCapture();
  752. }
  753. else
  754. Select();
  756. CXTPPropertyGridInplaceButton* pInplaceButton = m_pInplaceButtons->HitTest(point);
  757. if (pInplaceButton && IsInplaceButtonsVisible())
  758. {
  759. if (!bOldSelected && !m_pGrid->GetPropertyGrid()->GetShowInplaceButtonsAlways())
  760. return TRUE;
  761. pInplaceButton->OnLButtonDown(nFlags, point);
  762. return TRUE;
  763. }
  765. int nOffset = (m_nIndent - (IsCategory() ? 0 : 1)) * XTP_PGI_EXPAND_BORDER;
  767. if ((point.x >= nOffset && point.x <= XTP_PGI_EXPAND_BORDER + nOffset) && IsExpandable())
  768. {
  769. if (m_bExpanded)
  770. Collapse();
  771. else
  772. Expand();
  773. }
  775. if ((m_nFlags & xtpGridItemHasEdit) && PtInValueRect(point))
  776. {
  777. mouse_event(GetSystemMetrics(SM_SWAPBUTTON) ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
  778. }
  780. if (m_nFlags == xtpGridItemHasComboButton && PtInValueRect(point) && !GetReadOnly()
  781. && (m_pInplaceButtons->GetCount() == 1) && !IsCategory())
  782. {
  783. OnInplaceButtonDown(m_pInplaceButtons->GetAt(0));
  784. }
  786. return TRUE;
  787. }
  789. void CXTPPropertyGridItem::BindToString(CString* pBindString)
  790. {
  791. m_pBindString = pBindString;
  792. if (m_pBindString)
  793. {
  794. *m_pBindString = m_strValue;
  795. }
  796. }
  798. void CXTPPropertyGridItem::OnBeforeInsert()
  799. {
  800. if (m_pBindString && *m_pBindString != m_strValue)
  801. {
  802. m_strValue = *m_pBindString;
  803. }
  804. }
  806. void CXTPPropertyGridItem::EnsureVisible()
  807. {
  808. if (!m_bVisible)
  809. {
  810. CXTPPropertyGridItem* pItem = GetParentItem();
  812. while (pItem)
  813. {
  814. pItem->Expand();
  815. pItem = pItem->GetParentItem();
  816. }
  817. }
  819. if (!m_bVisible || (m_nIndex == -1))
  820. return;
  822. if (m_nIndex < m_pGrid->GetTopIndex())
  823. {
  824. m_pGrid->SetTopIndex(m_nIndex);
  825. return;
  826. }
  828. int top = 0;
  829. int nTopIndex = m_pGrid->GetTopIndex();
  830. int bottom = CXTPClientRect(m_pGrid).bottom;
  832. for (int i = nTopIndex; i < m_pGrid->GetCount(); i++)
  833. {
  834. int nRowHeight = m_pGrid->GetItemHeight(i);
  836. if (top + nRowHeight > bottom)
  837. break;
  839. if (i == m_nIndex)
  840. return;
  842. top += nRowHeight;
  843. }
  845. int nHeight = bottom;
  846. for (top = m_nIndex; top >= 0; top--)
  847. {
  848. int nRowHeight = m_pGrid->GetItemHeight(top);
  850. if (nHeight - nRowHeight < 0)
  851. {
  852. if (top != m_nIndex)
  853. top++;
  854. break;
  855. }
  857. nHeight -= nRowHeight;
  858. }
  859. m_pGrid->SetTopIndex(top);
  860. }
  862. CXTPPropertyGridInplaceEdit& CXTPPropertyGridItem::GetInplaceEdit()
  863. {
  864. if (m_pGrid) return *m_pGrid->m_pGrid->m_pInplaceEdit;
  866. static CXTPPropertyGridInplaceEdit  wndEdit;
  867. return wndEdit;
  868. }
  870. CXTPPropertyGridInplaceList& CXTPPropertyGridItem::GetInplaceList()
  871. {
  872. if (m_pGrid) return *m_pGrid->m_pGrid->m_pInplaceListBox;
  874. static CXTPPropertyGridInplaceList  wndListBox;
  875. return wndListBox;
  876. }
  878. BOOL CXTPPropertyGridItem::IsInplaceButtonsVisible() const
  879. {
  880. if (!m_pGrid)
  881. return FALSE;
  883. if (!IsSelected() && !m_pGrid->GetPropertyGrid()->GetShowInplaceButtonsAlways())
  884. return FALSE;
  886. return !GetReadOnly() && m_pInplaceButtons->GetCount() > 0;
  887. }
  889. CXTPPropertyGridInplaceButtons* CXTPPropertyGridItem::GetInplaceButtons() const
  890. {
  891. return m_pInplaceButtons;
  892. }
  894. CXTPPropertyGridInplaceControls* CXTPPropertyGridItem::GetInplaceControls() const
  895. {
  896. return m_pInplaceControls;
  897. }
  899. // Deletes the item.
  900. void CXTPPropertyGridItem::Remove()
  901. {
  902. if (!m_pGrid)
  903. return;
  905. CXTPPropertyGridItems* pItems = GetParentItem() == 0 ? m_pGrid->m_pCategories : GetParentItem()->m_pChilds;
  906. ASSERT(pItems);
  907. int nIndex = pItems ? pItems->Find(this) : -1;
  909. if (nIndex == -1)
  910. return;
  912. pItems->m_arrItems.RemoveAt(nIndex);
  914. m_pParent = NULL;
  916. if (m_pGrid) m_pGrid->Refresh();
  917. InternalRelease();
  918. }
  920. BOOL CXTPPropertyGridItem::IsHidden() const
  921. {
  922. return m_bHidden;
  923. }
  924. void CXTPPropertyGridItem::SetHidden(BOOL bHidden)
  925. {
  926. if (bHidden == m_bHidden)
  927. return;
  929. m_bHidden = bHidden;
  931. m_pGrid->Refresh();
  932. }
  934. BOOL CXTPPropertyGridItem::HasVisibleChilds() const
  935. {
  936. for (int i = 0; i < m_pChilds->GetCount(); i++)
  937. {
  938. if (!m_pChilds->GetAt(i)->IsHidden())
  939. return TRUE;
  940. }
  941. return FALSE;
  942. }
  944. BOOL CXTPPropertyGridItem::IsSelected() const
  945. {
  946. if (!m_pGrid->GetSafeHwnd())
  947. return FALSE;
  949. if (!m_bVisible)
  950. return FALSE;
  952. int nCount = m_pGrid->GetSelCount();
  954. if (nCount != LB_ERR && nCount > 1)
  955. {
  956. CArray<int,int> arr;
  958. arr.SetSize(nCount);
  959. m_pGrid->GetSelItems(nCount, arr.GetData());
  961. for (int i = 0; i < nCount; i++)
  962. {
  963. if (arr[i] == m_nIndex)
  964. return TRUE;
  965. }
  966. }
  968. return m_pGrid && m_pGrid->GetSelectedItem() == this;
  969. }
  971. void CXTPPropertyGridItem::Refresh(BOOL bInvalidate /*= TRUE*/)
  972. {
  973. if (m_pGrid && m_pGrid->GetSafeHwnd())
  974. {
  975. if (IsSelected())
  976. {
  977. OnDeselect();
  978. OnSelect();
  980. }
  981. if (bInvalidate)
  982. {
  983. m_pGrid->Invalidate(FALSE);
  984. }
  985. }
  986. }
  988. void CXTPPropertyGridItem::SetReadOnly(BOOL bReadOnly)
  989. {
  990. if (m_bReadOnly != bReadOnly)
  991. {
  992. m_bReadOnly = bReadOnly;
  993. Refresh(TRUE);
  994. }
  995. }
  997. void CXTPPropertyGridItem::SetMask(LPCTSTR strMask, LPCTSTR strLiteral, TCHAR chPrompt /*= _T('_')*/)
  998. {
  999. m_bUseMask = TRUE;
  1000. m_strMask = strMask;
  1001. m_strLiteral = strLiteral;
  1002. m_chPrompt = chPrompt;
  1003. Refresh(FALSE);
  1004. }
  1006. CString CXTPPropertyGridItem::GetViewValue()
  1007. {
  1008. CString str = GetValue();
  1009. if (m_bPassword)
  1010. {
  1011. return CString(m_chPrompt, str.GetLength());
  1012. }
  1013. return str;
  1014. }
  1016. CString CXTPPropertyGridItem::GetMaskedText() const
  1017. {
  1018. if (m_bUseMask)
  1019. {
  1020. int nLength = m_strValue.GetLength();
  1022. CString strBuffer;
  1023. for (int i = 0; i < nLength; ++i)
  1024. {
  1025. if (m_strLiteral[i] == m_chPrompt)
  1026. {
  1027. strBuffer += m_strValue.GetAt(i);
  1028. }
  1029. }
  1031. return strBuffer;
  1032. }
  1033. else
  1034. {
  1035. return m_strValue;
  1036. }
  1037. }
  1039. void CXTPPropertyGridItem::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  1040. {
  1041. if (m_nHeight != -1)
  1042. {
  1043. lpMeasureItemStruct->itemHeight = m_nHeight;
  1044. }
  1045. else if (m_nLinesCount > 1)
  1046. {
  1047. lpMeasureItemStruct->itemHeight = (lpMeasureItemStruct->itemHeight - 4) * m_nLinesCount + 4;
  1049. }
  1050. }
  1053. void CXTPPropertyGridItem::SetMaskedText(LPCTSTR lpszMaskedText)
  1054. {
  1055. CString strMaskedText = lpszMaskedText;
  1057. if (m_bUseMask)
  1058. {
  1059. int nLen = strMaskedText.GetLength();
  1060. int x = 0;
  1062. m_strValue = m_strLiteral;
  1064. for (int i = 0; (i < m_strValue.GetLength()) && (x < nLen); i++)
  1065. {
  1066. if (strMaskedText[x] == m_strValue[i])
  1067. {
  1068. x++;
  1069. }
  1070. else if (m_strValue[i] == m_chPrompt)
  1071. {
  1072. m_strValue.SetAt(i, strMaskedText[x]);
  1073. x++;
  1074. }
  1075. }
  1076. }
  1077. else
  1078. {
  1079. m_strValue = strMaskedText;
  1080. }
  1082. SetValue(m_strValue);
  1083. }
  1085. void CXTPPropertyGridItem::SetDescription(LPCTSTR lpszDescription)
  1086. {
  1087. m_strDescription = lpszDescription;
  1088. if (IsSelected()) GetGrid()->GetParent()->Invalidate(FALSE);
  1089. }
  1091. int CXTPPropertyGridItem::GetIndex() const
  1092. {
  1093. return m_nIndex;
  1094. }
  1097. void CXTPPropertyGridItem::OnDrawItemConstraint(CDC* pDC, CXTPPropertyGridItemConstraint* pConstraint, CRect rc, BOOL bSelected)
  1098. {
  1099. GetGrid()->GetPaintManager()->DrawInplaceListItem(pDC, pConstraint, rc, bSelected);
  1100. }
  1102. CSize CXTPPropertyGridItem::OnMergeItemConstraint(CDC* pDC, CXTPPropertyGridItemConstraint* pConstraint)
  1103. {
  1104. int nThumbLength = GetSystemMetrics(SM_CXHTHUMB);
  1106. CSize sz = pDC->GetTextExtent(pConstraint->m_strConstraint);
  1108. return CSize(sz.cx + nThumbLength * 2, sz.cy + 3);
  1109. }
  1111. void CXTPPropertyGridItem::SetFocusToInplaceControl()
  1112. {
  1113. CXTPPropertyGridInplaceEdit& wndEdit = GetInplaceEdit();
  1115. if (wndEdit.GetSafeHwnd() && wndEdit.GetItem() == this)
  1116. {
  1117. wndEdit.SetFocus();
  1118. wndEdit.SetSel(0, -1);
  1119. }
  1120. }
  1122. void CXTPPropertyGridItem::AddComboButton()
  1123. {
  1124. GetInplaceButtons()->AddComboButton();
  1125. }
  1127. void CXTPPropertyGridItem::AddExpandButton()
  1128. {
  1129. GetInplaceButtons()->AddExpandButton();
  1130. }
  1132. CXTPPropertyGridInplaceSlider* CXTPPropertyGridItem::AddSliderControl()
  1133. {
  1134. CXTPPropertyGridInplaceSlider* pSlider = new CXTPPropertyGridInplaceSlider(this);
  1135. m_pInplaceControls->Add(pSlider);
  1137. return pSlider;
  1138. }
  1140. CXTPPropertyGridInplaceSpinButton* CXTPPropertyGridItem::AddSpinButton()
  1141. {
  1142. CXTPPropertyGridInplaceSpinButton* pSpinButton = new CXTPPropertyGridInplaceSpinButton(this);
  1143. m_pInplaceControls->Add(pSpinButton);
  1145. return pSpinButton;
  1146. }
  1148. void CXTPPropertyGridItem::OnCaptionChanged()
  1149. {
  1150. XTPMarkupReleaseElement(m_pMarkupUIElement);
  1152. if (!m_pGrid || !m_pGrid->m_pGrid)
  1153. return;
  1155. if (m_pGrid->m_pGrid->GetMarkupContext())
  1156. {
  1157. m_pMarkupUIElement = XTPMarkupParseText(m_pGrid->m_pGrid->GetMarkupContext(), GetCaption());
  1158. }
  1160. if (m_bVisible && m_pGrid->GetSafeHwnd())
  1161. m_pGrid->InvalidateRect(GetItemRect(), FALSE);
  1162. }
  1165. //////////////////////////////////////////////////////////////////////////
  1166. // Accessible
  1168. CCmdTarget* CXTPPropertyGridItem::GetAccessible()
  1169. {
  1170. return this;
  1171. }
  1173. HRESULT CXTPPropertyGridItem::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  1174. {
  1175. SAFE_MANAGE_STATE(m_pModuleState);
  1177. *ppdispParent = NULL;
  1179. return m_pGrid->InternalQueryInterface(&IID_IAccessible, (void**)ppdispParent);
  1180. }
  1182. HRESULT CXTPPropertyGridItem::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1183. {
  1184. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1185. return E_INVALIDARG;
  1187. CString strCaption = GetCaption();
  1189. *pszName = strCaption.AllocSysString();
  1190. return S_OK;
  1191. }
  1193. HRESULT CXTPPropertyGridItem::GetAccessibleDescription(VARIANT varChild, BSTR* pszDescription)
  1194. {
  1195. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1196. return E_INVALIDARG;
  1198. *pszDescription = GetDescription().AllocSysString();
  1199. return S_OK;
  1200. }
  1202. HRESULT CXTPPropertyGridItem::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1203. {
  1204. if (!pvarRole)
  1205. return E_INVALIDARG;
  1207. pvarRole->vt = VT_EMPTY;
  1209. if (GetChildIndex(&varChild) == CHILDID_SELF)
  1210. {
  1211. pvarRole->vt = VT_I4;
  1212. pvarRole->lVal = ROLE_SYSTEM_ROW;
  1213. return S_OK;
  1214. }
  1216. return E_INVALIDARG;
  1217. }
  1219. HRESULT CXTPPropertyGridItem::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  1220. {
  1221. if (!pvarState)
  1222. return E_INVALIDARG;
  1224. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1225. return E_INVALIDARG;
  1227. pvarState->vt = VT_I4;
  1228. pvarState->lVal = STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_SELECTABLE |
  1229. (IsSelected() ? STATE_SYSTEM_FOCUSED : 0);
  1231. if (!IsVisible())
  1232. pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
  1234. if (GetReadOnly())
  1235. pvarState->lVal |= STATE_SYSTEM_READONLY;
  1237. return S_OK;
  1238. }
  1241. HRESULT CXTPPropertyGridItem::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  1242. {
  1243. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  1245. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1246. return E_INVALIDARG;
  1248. if (!m_pGrid->GetSafeHwnd())
  1249. return S_OK;
  1251. CRect rcItem;
  1252. m_pGrid->GetItemRect(GetIndex(), &rcItem);
  1253. m_pGrid->ClientToScreen(&rcItem);
  1255. *pxLeft = rcItem.left;
  1256. *pyTop = rcItem.top;
  1257. *pcxWidth = rcItem.Width();
  1258. *pcyHeight = rcItem.Height();
  1260. return S_OK;
  1261. }
  1263. HRESULT CXTPPropertyGridItem::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  1264. {
  1265. if (pvarID == NULL)
  1266. return E_INVALIDARG;
  1268. pvarID->vt = VT_EMPTY;
  1270. if (!m_pGrid->GetSafeHwnd())
  1271. return S_FALSE;
  1273. if (!CXTPWindowRect(m_pGrid).PtInRect(CPoint(xLeft, yTop)))
  1274. return S_FALSE;
  1276. pvarID->vt = VT_I4;
  1277. pvarID->lVal = 0;
  1279. CRect rcItem;
  1280. m_pGrid->GetItemRect(GetIndex(), &rcItem);
  1281. m_pGrid->ClientToScreen(&rcItem);
  1283. if (!rcItem.PtInRect(CPoint(xLeft, yTop)))
  1284. return S_FALSE;
  1286. return S_OK;
  1287. }
  1289. HRESULT CXTPPropertyGridItem::AccessibleSelect(long /*flagsSelect*/, VARIANT varChild)
  1290. {
  1291. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1292. return E_INVALIDARG;
  1294. Select();
  1296. return S_OK;
  1297. }
  1299. HRESULT CXTPPropertyGridItem::GetAccessibleValue(VARIANT varChild, BSTR* pszValue)
  1300. {
  1301. if (GetChildIndex(&varChild) != CHILDID_SELF)
  1302. return E_INVALIDARG;
  1304. *pszValue = GetValue().AllocSysString();
  1305. return S_OK;
  1306. }
  1309. /////////////////////////////////////////////////////////////////////////////
  1310. // CXTPPropertyGridItems
  1312. CXTPPropertyGridItems::CXTPPropertyGridItems()
  1313. {
  1315. }
  1317. void CXTPPropertyGridItems::Clear()
  1318. {
  1319. CXTPPropertyGridView* pGrid = GetCount() > 0 ? m_arrItems[0]->m_pGrid : 0;
  1321. if (pGrid)
  1322. {
  1323. if (pGrid->m_nLockUpdate == 0)
  1324. pGrid->ResetContent();
  1325. pGrid->m_nLockUpdate++;
  1326. }
  1328. for (int i = 0; i < GetCount(); i++)
  1329. {
  1330. m_arrItems[i]->Clear();
  1331. m_arrItems[i]->InternalRelease();
  1332. }
  1333. m_arrItems.RemoveAll();
  1335. if (pGrid)
  1336. {
  1337. pGrid->m_nLockUpdate--;
  1338. if (pGrid->m_nLockUpdate == 0)
  1339. pGrid->Refresh();
  1340. }
  1341. }
  1343. CXTPPropertyGridItem* CXTPPropertyGridItems::GetAt(int nIndex) const
  1344. {
  1345. if (nIndex >= 0 && nIndex < GetCount())
  1346. {
  1347. return m_arrItems.GetAt(nIndex);
  1348. }
  1349. return 0;
  1350. }
  1352. void CXTPPropertyGridItems::RemoveAt (int nIndex)
  1353. {
  1354. CXTPPropertyGridItem* pItem = GetAt(nIndex);
  1356. if (pItem)
  1357. {
  1358. m_arrItems.RemoveAt(nIndex);
  1360. if (pItem->GetGrid())
  1361. {
  1362. pItem->GetGrid()->Refresh();
  1363. }
  1365. pItem->InternalRelease();
  1366. }
  1367. }
  1369. int CXTPPropertyGridItems::Find(CXTPPropertyGridItem* pItem) const
  1370. {
  1371. for (int i = 0; i < GetCount(); i++)
  1372. {
  1373. if (m_arrItems[i] == pItem)
  1374. return i;
  1375. }
  1376. return -1;
  1377. }
  1380. void CXTPPropertyGridItems::AddTail(CXTPPropertyGridItems* pItems)
  1381. {
  1382. ASSERT(this != pItems);
  1384. for (int i = 0; i < pItems->GetCount(); i++)
  1385. {
  1386. AddTail(pItems->GetAt(i));
  1387. }
  1388. }
  1390. int CXTPPropertyGridItems::CompareFunc(const CXTPPropertyGridItem** ppItem1, const CXTPPropertyGridItem** ppItem2)
  1391. {
  1392. return (*ppItem1)->GetCaption().Compare((*ppItem2)->GetCaption());
  1393. }
  1395. void CXTPPropertyGridItems::Sort()
  1396. {
  1397. typedef int (_cdecl *GENERICCOMPAREFUNC)(const void *, const void*);
  1399. qsort(m_arrItems.GetData(), m_arrItems.GetSize(), sizeof(CXTPPropertyGridItem*), (GENERICCOMPAREFUNC)CompareFunc);
  1400. }
  1402. CXTPPropertyGridItem* CXTPPropertyGridItems::FindItem(LPCTSTR strCaption) const
  1403. {
  1404. for (int i = 0; i < GetCount(); i++)
  1405. {
  1406. CXTPPropertyGridItem* pItem = GetAt(i);
  1407. if (pItem->GetCaption().Compare(strCaption) == 0)
  1408. return pItem;
  1410. CXTPPropertyGridItem* pChild = pItem->m_pChilds->FindItem(strCaption);
  1411. if (pChild) return pChild;
  1412. }
  1413. return NULL;
  1414. }
  1416. CXTPPropertyGridItem* CXTPPropertyGridItems::FindItem(UINT nID) const
  1417. {
  1418. for (int i = 0; i < GetCount(); i++)
  1419. {
  1420. CXTPPropertyGridItem* pItem = GetAt(i);
  1421. if (pItem->GetID() == nID)
  1422. return pItem;
  1424. CXTPPropertyGridItem* pChild = pItem->m_pChilds->FindItem(nID);
  1425. if (pChild) return pChild;
  1426. }
  1427. return NULL;
  1428. }
  1432. //////////////////////////////////////////////////////////////////////////
  1433. // CXTPPropertyGridItemConstraint
  1434. CXTPPropertyGridItemConstraint::CXTPPropertyGridItemConstraint()
  1435. {
  1436. m_nIndex = 0;
  1437. m_dwData = 0;
  1438. m_nImage = -1;
  1439. m_pItem = 0;
  1440. }
  1442. CXTPImageManagerIcon* CXTPPropertyGridItemConstraint::GetImage() const
  1443. {
  1444. ASSERT(m_pItem);
  1446. if (!m_pItem)
  1447. return NULL;
  1449. if (m_nImage == -1)
  1450. return NULL;
  1452. return m_pItem->GetGrid()->GetImageManager()->GetImage(m_nImage, 0);
  1453. }
  1455. /////////////////////////////////////////////////////////////////////////////
  1456. // CXTPPropertyGridItemConstraints
  1458. // Summary: Constructs a CXTPPropertyGridItemConstraints object
  1459. CXTPPropertyGridItemConstraints::CXTPPropertyGridItemConstraints(CXTPPropertyGridItem* pItem)
  1460. {
  1461. m_pItem = pItem;
  1462. m_nCurrent = -1;
  1464. }
  1466. CXTPPropertyGridItemConstraints::~CXTPPropertyGridItemConstraints()
  1467. {
  1468. RemoveAll();
  1469. }
  1471. CXTPPropertyGridItemConstraint* CXTPPropertyGridItemConstraints::AddConstraint(LPCTSTR str, DWORD_PTR dwData, int nImage)
  1472. {
  1473. CXTPPropertyGridItemConstraint* pConstaint = new CXTPPropertyGridItemConstraint();
  1475. pConstaint->m_strConstraint = str;
  1476. pConstaint->m_dwData = dwData;
  1477. pConstaint->m_nIndex = (int)m_arrConstraints.Add(pConstaint);
  1478. pConstaint->m_pItem = m_pItem;
  1479. pConstaint->m_nImage = nImage;
  1481. SAFE_CALLPTR(m_pItem, OnConstraintsChanged());
  1483. return pConstaint;
  1484. }
  1486. CString CXTPPropertyGridItemConstraints::GetAt(int nIndex) const
  1487. {
  1488. return nIndex >= 0 && nIndex < GetCount() ? m_arrConstraints.GetAt(nIndex)->m_strConstraint : _T("");
  1489. }
  1491. void CXTPPropertyGridItemConstraints::RemoveAll()
  1492. {
  1493. for (int i = 0; i < GetCount(); i++)
  1494. m_arrConstraints[i]->InternalRelease();
  1495. m_arrConstraints.RemoveAll();
  1497. SAFE_CALLPTR(m_pItem, OnConstraintsChanged());
  1498. }
  1500. void CXTPPropertyGridItemConstraints::RemoveAt(int nIndex)
  1501. {
  1502. m_arrConstraints[nIndex]->InternalRelease();
  1503. m_arrConstraints.RemoveAt(nIndex);
  1505. for (int i = nIndex; i < GetCount(); i++)
  1506. m_arrConstraints[i]->m_nIndex = i;
  1508. SAFE_CALLPTR(m_pItem, OnConstraintsChanged());
  1509. }
  1511. int CXTPPropertyGridItemConstraints::FindConstraint(LPCTSTR str) const
  1512. {
  1513. for (int i = 0; i < GetCount(); i++)
  1514. {
  1515. if (GetAt(i).CompareNoCase(str) == 0)
  1516. return i;
  1517. }
  1518. return -1;
  1519. }
  1521. int CXTPPropertyGridItemConstraints::FindConstraint(DWORD_PTR dwData) const
  1522. {
  1523. for (int i = 0; i < GetCount(); i++)
  1524. {
  1525. if (dwData == GetConstraintAt(i)->m_dwData)
  1526. return i;
  1527. }
  1528. return -1;
  1529. }
  1531. CXTPPropertyGridItemConstraint* CXTPPropertyGridItemConstraints::GetConstraintAt(int nIndex) const
  1532. {
  1533. return m_arrConstraints[nIndex];
  1534. }
  1536. int CXTPPropertyGridItemConstraints::CompareFunc(const CXTPPropertyGridItemConstraint** ppConstraint1, const CXTPPropertyGridItemConstraint** ppConstraint2)
  1537. {
  1538. return (*ppConstraint1)->m_strConstraint.Compare((*ppConstraint2)->m_strConstraint);
  1540. }
  1542. void CXTPPropertyGridItemConstraints::Sort()
  1543. {
  1544. typedef int (_cdecl *GENERICCOMPAREFUNC)(const void *, const void*);
  1546. qsort(m_arrConstraints.GetData(), (size_t)m_arrConstraints.GetSize(), sizeof(CXTPPropertyGridItemConstraint*), (GENERICCOMPAREFUNC)CompareFunc);
  1547. }
  1550. //////////////////////////////////////////////////////////////////////////
  1551. // CXTPPropertyGridItemCategory
  1553. CXTPPropertyGridItemCategory::CXTPPropertyGridItemCategory(LPCTSTR strCaption)
  1554. :CXTPPropertyGridItem(strCaption)
  1555. {
  1556. m_bCategory = TRUE;
  1557. m_nFlags = 0;
  1558. }
  1560. CXTPPropertyGridItemCategory::CXTPPropertyGridItemCategory(UINT nID)
  1561. :CXTPPropertyGridItem(nID)
  1562. {
  1563. m_bCategory = TRUE;
  1564. m_nFlags = 0;
  1565. }
  1571. ///////////////////////////////////////////////////////////////////////////////////
  1572. //  Acteve X Methods
  1573. //
  1576. BEGIN_INTERFACE_MAP(CXTPPropertyGridItem, CCmdTarget)
  1577. INTERFACE_PART(CXTPPropertyGridItem, IID_IAccessible, ExternalAccessible)
  1578. END_INTERFACE_MAP()