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

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

对话框与窗口

开发平台：

Visual C++

XTPPropertyGrid.cpp：源码内容
  1. // XTPPropertyGrid.cpp : implementation of the CXTPPropertyGrid 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 "Resource.h"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPVC80Helpers.h"
  27. #include "Common/XTPDrawHelpers.h"
  28. #include "Common/XTPImageManager.h"
  29. #include "Common/XTPToolTipContext.h"
  30. #include "Common/XTPMarkupRender.h"
  32. #include "XTPPropertyGridInplaceEdit.h"
  33. #include "XTPPropertyGridInplaceButton.h"
  34. #include "XTPPropertyGridInplaceList.h"
  35. #include "XTPPropertyGridItem.h"
  36. #include "XTPPropertyGrid.h"
  37. #include "XTPPropertyGridDefines.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. const int SPLITTER_HEIGHT = 3;
  46. const int TOOLBAR_HEIGHT = 25;
  48. //////////////////////////////////////////////////////////////////////////
  49. // CXTPPropertyGridUpdateContext
  51. CXTPPropertyGridUpdateContext::CXTPPropertyGridUpdateContext()
  52. {
  53. m_nSelected = 0;
  54. m_nTopIndex = 0;
  55. m_propertySort = xtpGridSortAlphabetical;
  58. }
  60. //////////////////////////////////////////////////////////////////////////
  61. // CXTPPropertyGridVerb
  63. CXTPPropertyGridVerb::CXTPPropertyGridVerb()
  64. {
  65. m_nID = 0;
  66. m_nIndex = -1;
  67. m_pVerbs = 0;
  69. }
  71. //////////////////////////////////////////////////////////////////////////
  72. // CXTPPropertyGridVerbs
  74. CXTPPropertyGridVerbs::CXTPPropertyGridVerbs()
  75. {
  76. m_pGrid = 0;
  79. }
  81. CXTPPropertyGridVerbs::~CXTPPropertyGridVerbs()
  82. {
  83. for (int i = 0; i < m_arrVerbs.GetSize(); i++)
  84. m_arrVerbs[i]->InternalRelease();
  85. }
  87. void CXTPPropertyGridVerbs::RemoveAll()
  88. {
  89. if (IsEmpty())
  90. return;
  92. for (int i = 0; i < m_arrVerbs.GetSize(); i++)
  93. m_arrVerbs[i]->InternalRelease();
  95. m_arrVerbs.RemoveAll();
  97. m_pGrid->OnVerbsChanged();
  98. }
  100. int CXTPPropertyGridVerbs::GetCount() const
  101. {
  102. return (int)m_arrVerbs.GetSize();
  103. }
  105. void CXTPPropertyGridVerbs::Add(LPCTSTR strCaption, UINT nID)
  106. {
  107. CXTPPropertyGridVerb* pVerb = new CXTPPropertyGridVerb();
  109. pVerb->m_nID = nID;
  110. pVerb->m_strCaption = strCaption;
  111. pVerb->m_pVerbs = this;
  112. pVerb->m_rcPart.SetRectEmpty();
  113. pVerb->m_ptClick = CPoint(0);
  115. pVerb->m_nIndex = (UINT)m_arrVerbs.Add(pVerb);
  117. m_pGrid->OnVerbsChanged();
  118. }
  121. /////////////////////////////////////////////////////////////////////////////
  122. // CXTPPropertyGridToolBar
  124. CXTPPropertyGridToolBar::CXTPPropertyGridToolBar()
  125. {
  126. m_cxLeftBorder = m_cxRightBorder = m_cyBottomBorder = m_cyTopBorder = 0;
  127. }
  129. CXTPPropertyGridToolBar::~CXTPPropertyGridToolBar()
  130. {
  131. }
  133. BEGIN_MESSAGE_MAP(CXTPPropertyGridToolBar, CToolBar)
  134. //{{AFX_MSG_MAP(CToolBar)
  135. ON_WM_PAINT()
  136. ON_WM_ERASEBKGND()
  137. ON_WM_NCCALCSIZE()
  138. ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
  139. //}}AFX_MSG_MAP
  140. END_MESSAGE_MAP()
  142. void CXTPPropertyGridToolBar::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  143. {
  144. NMLVCUSTOMDRAW* lpLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  145. *pResult = CDRF_DODEFAULT;
  147. switch (lpLVCD->nmcd.dwDrawStage)
  148. {
  149. case CDDS_PREPAINT:
  150. CWnd* pGrid = GetParent();
  151. HBRUSH hBrush = (HBRUSH)pGrid->GetParent()->SendMessage(WM_CTLCOLORSTATIC,
  152. (WPARAM)lpLVCD->nmcd.hdc, (LPARAM)pGrid->m_hWnd);
  154. ::FillRect(lpLVCD->nmcd.hdc, &lpLVCD->nmcd.rc, hBrush ? hBrush : GetSysColorBrush(COLOR_3DFACE));
  155. break;
  156. }
  157. }
  160. BOOL CXTPPropertyGridToolBar::OnEraseBkgnd(CDC*)
  161. {
  162. return TRUE;
  163. }
  165. void CXTPPropertyGridToolBar::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* /*lpncsp*/)
  166. {
  167. }
  169. void CXTPPropertyGridToolBar::OnPaint()
  170. {
  171. CPaintDC dc(this);
  173. CXTPClientRect rc(this);
  174. CXTPBufferDC memDC(dc, rc);
  175. memDC.FillSolidRect(rc, GetXtremeColor(COLOR_3DFACE));
  177. CToolBar::DefWindowProc(WM_PAINT, (WPARAM)memDC.m_hDC, 0);
  178. }
  180. void CXTPPropertyGridToolBar::OnUpdateCmdUI(CFrameWnd* /*pTarget*/, BOOL /*bDisableIfNoHndler*/)
  181. {
  182. }
  184. BOOL CXTPPropertyGridToolBar::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  185. {
  186. CXTPPropertyGrid* pGrid = (CXTPPropertyGrid*)GetParent();
  187. if (pGrid->GetToolTipContext())
  188. {
  189. pGrid->GetToolTipContext()->FilterToolTipMessage(this, message, wParam, lParam);
  190. }
  192. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  193. }
  196. /////////////////////////////////////////////////////////////////////////////
  197. // CXTPPropertyGrid
  199. CXTPPropertyGrid::CXTPPropertyGrid()
  200. : m_bHelpVisible(TRUE)
  201. , m_bToolBarVisible(FALSE)
  202. , m_nHelpHeight(58)
  203. , m_bPreSubclassWindow(TRUE)
  204. {
  205. RegisterWindowClass();
  207. m_pView = 0;
  209. m_hCursorSplit = XTPResourceManager()->LoadCursor(XTP_IDC_VSPLITBAR);
  211. m_hCursorHand = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649));
  213. if (m_hCursorHand == 0)
  214. m_hCursorHand = XTPResourceManager()->LoadCursor(XTP_IDC_HAND);
  217. m_pPaintManager = new CXTPPropertyGridPaintManager(this);
  218. m_pPaintManager->RefreshMetrics();
  220. m_themeCurrent = xtpGridThemeDefault;
  222. m_pVerbs = new CXTPPropertyGridVerbs;
  223. m_pVerbs->m_pGrid = this;
  225. m_nVerbsHeight = 25;
  226. m_nFocusedVerb = -1;
  227. m_bVerbActivate = FALSE;
  228. m_bVerbsVisible = FALSE;
  229. m_bEnableTooltips = TRUE;
  231. m_bTabItems = FALSE;
  232. m_bTabCaptions = TRUE;
  233. m_bVariableItemsHeight = FALSE;
  235. m_borderStyle = xtpGridBorderStaticEdge;
  237. m_bShowInplaceButtonsAlways = FALSE;
  239. LOGFONT lfIcon;
  240. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  241. lfIcon.lfWeight = FW_NORMAL;
  242. lfIcon.lfItalic = FALSE;
  243. VERIFY(m_pPaintManager->GetItemMetrics()->m_fontNormal.CreateFontIndirect(&lfIcon));
  245. lfIcon.lfWeight = FW_BOLD;
  246. VERIFY(m_pPaintManager->GetItemMetrics()->m_fontBold.CreateFontIndirect(&lfIcon));
  248. m_bHighlightChanged = FALSE;
  250. m_pImageManager = new CXTPImageManager;
  252. m_pInplaceEdit = new CXTPPropertyGridInplaceEdit;
  253. m_pInplaceListBox = new CXTPPropertyGridInplaceList;
  255. m_bVariableHelpHeight = TRUE;
  257. m_pToolTipContext = new CXTPToolTipContext;
  259. m_bHideSelection = FALSE;
  261. m_bMultiSelect = FALSE;
  263. m_pMarkupContext = NULL;
  266. }
  268. BOOL CXTPPropertyGrid::RegisterWindowClass(HINSTANCE hInstance /*= NULL*/)
  269. {
  270. return XTPDrawHelpers()->RegisterWndClass(hInstance, XTPPROPERTYGRID_CLASSNAME, 0);
  271. }
  273. CXTPPropertyGrid::~CXTPPropertyGrid()
  274. {
  275. if (m_pView)
  276. {
  277. delete m_pView;
  278. }
  280. CMDTARGET_RELEASE(m_pVerbs);
  281. CMDTARGET_RELEASE(m_pImageManager);
  283. SAFE_DELETE(m_pInplaceEdit);
  284. SAFE_DELETE(m_pInplaceListBox);
  286. CMDTARGET_RELEASE(m_pPaintManager);
  288. CMDTARGET_RELEASE(m_pToolTipContext);
  290. XTPMarkupReleaseContext(m_pMarkupContext);
  291. }
  293. void CXTPPropertyGrid::SetInplaceEdit(CXTPPropertyGridInplaceEdit*  pInplaceEdit)
  294. {
  295. ASSERT(pInplaceEdit);
  297. SAFE_DELETE(m_pInplaceEdit);
  298. m_pInplaceEdit = pInplaceEdit;
  299. }
  301. void CXTPPropertyGrid::SetInplaceList(CXTPPropertyGridInplaceList*  pInplaceList)
  302. {
  303. ASSERT(pInplaceList);
  305. SAFE_DELETE(m_pInplaceListBox);
  306. m_pInplaceListBox = pInplaceList;
  307. }
  310. CXTPPropertyGridView* CXTPPropertyGrid::CreateView() const
  311. {
  312. return new CXTPPropertyGridView();
  313. }
  315. CXTPPropertyGridView& CXTPPropertyGrid::GetGridView() const
  316. {
  317. if (m_pView == 0)
  318. {
  319. m_pView = CreateView();
  320. m_pView->m_pGrid = (CXTPPropertyGrid*)this;
  321. }
  323. return *m_pView;
  324. }
  326. IMPLEMENT_DYNAMIC(CXTPPropertyGrid, CWnd)
  328. BEGIN_MESSAGE_MAP(CXTPPropertyGrid, CWnd)
  329. //{{AFX_MSG_MAP(CXTPPropertyGrid)
  330. ON_WM_ERASEBKGND()
  331. ON_WM_PAINT()
  332. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  333. ON_WM_SETFOCUS()
  334. ON_WM_KILLFOCUS()
  335. ON_WM_SIZE()
  336. ON_WM_SETCURSOR()
  337. ON_WM_LBUTTONDOWN()
  338. ON_WM_LBUTTONUP()
  339. ON_COMMAND(XTP_IDC_PROPERTYGRID_ALPHABETIC, OnSortAlphabetic)
  340. ON_COMMAND(XTP_IDC_PROPERTYGRID_CATEGORIZED, OnSortCategorized)
  341. ON_WM_SYSCOLORCHANGE()
  342. ON_WM_KEYDOWN()
  343. ON_WM_GETDLGCODE()
  344. //}}AFX_MSG_MAP
  345. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  346. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  347. END_MESSAGE_MAP()
  349. UINT CXTPPropertyGrid::OnGetDlgCode()
  350. {
  351. return DLGC_WANTALLKEYS;
  352. }
  354. BOOL CXTPPropertyGrid::CreateGridView(DWORD dwListStyle)
  355. {
  356. CXTPEmptyRect rect;
  358. if (dwListStyle == NULL)
  359. {
  360. dwListStyle = m_bVariableItemsHeight ? LBS_OWNERDRAWVARIABLE | LBS_NOINTEGRALHEIGHT :
  361. LBS_OWNERDRAWFIXED | LBS_NOINTEGRALHEIGHT;
  362. }
  364. if (m_bMultiSelect)
  365. {
  366. dwListStyle |= LBS_MULTIPLESEL | LBS_EXTENDEDSEL;
  367. }
  369. // Must be owner draw.
  370. ASSERT((dwListStyle & (LBS_OWNERDRAWVARIABLE|LBS_OWNERDRAWFIXED)) != 0);
  372. m_bVariableItemsHeight = (dwListStyle & LBS_OWNERDRAWVARIABLE) != 0;
  374. if (!GetGridView().CreateEx(0, _T("LISTBOX"), NULL,
  375. WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE |
  376. LBS_NOTIFY | WS_VSCROLL | WS_TABSTOP | dwListStyle, rect, this, 0))
  377. {
  378. TRACE0("Error creating property grid view.n");
  379. return FALSE;
  380. }
  382. GetGridView().ResetContent();
  383. SetStandardColors();
  385. return TRUE;
  386. }
  388. BOOL CXTPPropertyGrid::Create(const RECT& rect, CWnd* pParentWnd, UINT nID, DWORD dwListStyle /*= LBS_OWNERDRAWFIXED|LBS_NOINTEGRALHEIGHT*/)
  389. {
  390. if (!CreateEx(0, XTPPROPERTYGRID_CLASSNAME, _T(""),
  391. WS_TABSTOP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD | WS_GROUP, rect, pParentWnd, nID))
  392. {
  393. TRACE0("Error creating property grid.n");
  394. return FALSE;
  395. }
  397. if (!CreateGridView(dwListStyle))
  398. return FALSE;
  400. Reposition(rect.right - rect.left, rect.bottom - rect.top);
  402. SetWindowPos(NULL, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
  403. SWP_SHOWWINDOW|SWP_NOZORDER);
  405. return TRUE;
  406. }
  408. BOOL CXTPPropertyGrid::PreCreateWindow(CREATESTRUCT& cs)
  409. {
  410. if (!CWnd::PreCreateWindow(cs))
  411. return FALSE;
  413. //
  414. // PreCreateWindow is called when a control is dynamically
  415. // created. We want to set m_bPreSubclassWindow to FALSE
  416. // here so the control is initialized from CWnd::Create and
  417. // not CWnd::PreSubclassWindow.
  418. //
  420. m_bPreSubclassWindow = FALSE;
  422. return TRUE;
  423. }
  425. void CXTPPropertyGrid::PreSubclassWindow()
  426. {
  427. CWnd::PreSubclassWindow();
  429. if (m_bPreSubclassWindow)
  430. {
  431. // Initialize the control.
  432. VERIFY(CreateGridView(NULL));
  434. Reposition();
  435. }
  436. }
  438. void CXTPPropertyGrid::SetVariableItemsHeight(BOOL bVariable /*= TRUE*/)
  439. {
  440. if (m_bVariableItemsHeight == bVariable)
  441. return;
  443. m_bVariableItemsHeight = bVariable;
  445. RecreateView();
  446. }
  448. void CXTPPropertyGrid::RecreateView()
  449. {
  450. CXTPPropertyGridView& wndView = GetGridView();
  451. if (!wndView.GetSafeHwnd())
  452. return;
  454. wndView.ResetContent();
  455. wndView.DestroyWindow();
  457. DWORD dwListStyle = m_bVariableItemsHeight ? LBS_OWNERDRAWVARIABLE | LBS_NOINTEGRALHEIGHT : LBS_OWNERDRAWFIXED | LBS_NOINTEGRALHEIGHT;
  458. if (m_bMultiSelect)
  459. {
  460. dwListStyle |= LBS_MULTIPLESEL | LBS_EXTENDEDSEL;
  461. }
  463. VERIFY(GetGridView().CreateEx(0, _T("LISTBOX"), NULL, WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE | LBS_NOTIFY | WS_VSCROLL | WS_TABSTOP | dwListStyle, CXTPEmptyRect(), this, 0));
  465. wndView.Refresh();
  467. Reposition();
  468. }
  470. void CXTPPropertyGrid::EnableMultiSelect(BOOL bMultiSelect)
  471. {
  472. if (m_bMultiSelect == bMultiSelect)
  473. return;
  475. m_bMultiSelect = bMultiSelect;
  477. RecreateView();
  478. }
  480. /////////////////////////////////////////////////////////////////////////////
  481. // CXTPPropertyGrid message handlers
  483. BOOL CXTPPropertyGrid::OnEraseBkgnd(CDC*)
  484. {
  485. return TRUE;
  486. }
  488. void CXTPPropertyGrid::OnPaint()
  489. {
  490. CPaintDC dcPaint(this);
  491. CXTPBufferDC dc(dcPaint);
  493. m_pPaintManager->FillPropertyGrid(&dc);
  494. }
  496. LRESULT CXTPPropertyGrid::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  497. {
  498. CDC* pDC = CDC::FromHandle((HDC)wParam);
  499. if (pDC)
  500. {
  501. m_pPaintManager->FillPropertyGrid(pDC);
  502. }
  504. return TRUE;
  505. }
  507. CWnd* CXTPPropertyGrid::GetNextGridTabItem(BOOL bForward)
  508. {
  509. CWnd* pThis = this;
  510. CWnd* pParent = pThis->GetParent();
  512. if (!pThis || !pParent)
  513. {
  514. ASSERT(FALSE);
  515. return 0 ;
  516. }
  518. if ((pParent->GetExStyle() & WS_EX_CONTROLPARENT) && (pParent->GetStyle() & WS_CHILD))
  519. {
  520. pParent = pParent->GetParent();
  521. }
  523. CWnd* pNextItem = pParent->GetNextDlgTabItem(pThis, bForward);
  525. if (pNextItem == pThis)
  526. return NULL;
  528. return pNextItem;
  529. }
  531. void CXTPPropertyGrid::OnNavigate(XTPPropertyGridUI nUIElement, BOOL bForward, CXTPPropertyGridItem* pItem)
  532. {
  533. int nNextElement = bForward ? +1 : -1;
  534. int nUI = nUIElement + nNextElement;
  536. CXTPPropertyGridView& wndView = GetGridView();
  538. if (pItem == NULL)
  539. pItem = wndView.GetSelectedItem();
  541. if (m_bTabItems)
  542. nUIElement = (XTPPropertyGridUI)-3;
  544. while (nUI != nUIElement)
  545. {
  546. if (nUI == xtpGridUIViewPrev)
  547. {
  548. nUI += nNextElement;
  550. if (m_bTabItems)
  551. {
  552. int nIndex = !bForward && pItem ? pItem->m_nIndex - 1 : 0;
  553. if (nIndex >= 0)
  554. {
  555. wndView.SetFocus();
  556. wndView.SetCurSel(nIndex);
  557. wndView.OnSelectionChanged();
  559. if (bForward)
  560. return;
  562. nUI = xtpGridUIInplaceButton;
  563. pItem = wndView.GetSelectedItem();
  564. }
  565. }
  566. }
  567. if (nUI == xtpGridUIView)
  568. {
  569. if (m_bTabCaptions)
  570. {
  571. wndView.SetFocus();
  572. wndView.FocusInplaceButton(NULL);
  573. return;
  574. }
  575. nUI += nNextElement;
  576. }
  577. if (nUI == xtpGridUIInplaceEdit)
  578. {
  579. if (pItem && pItem->GetFlags() & xtpGridItemHasEdit)
  580. {
  581. pItem->OnSelect();
  582. pItem->SetFocusToInplaceControl();
  583. return;
  584. }
  585. nUI += nNextElement;
  586. }
  587. if (nUI == xtpGridUIInplaceControl)
  588. {
  589. if (pItem && pItem->GetInplaceControls()->GetCount() > 0)
  590. {
  591. CWnd* pWnd = pItem->GetInplaceControls()->GetAt(0);
  592. if (pWnd && pWnd->GetSafeHwnd() && pWnd->GetStyle() & WS_TABSTOP)
  593. {
  594. pWnd->SetFocus();
  595. return;
  596. }
  597. }
  598. nUI += nNextElement;
  599. }
  600. if (nUI == xtpGridUIInplaceButton)
  601. {
  602. if (pItem && pItem->IsInplaceButtonsVisible())
  603. {
  604. CXTPPropertyGridInplaceButtons* pButtons = pItem->GetInplaceButtons();
  606. if (wndView.m_pFocusedButton && wndView.m_pFocusedButton->GetItem() == pItem)
  607. {
  608. int nIndex = wndView.m_pFocusedButton->GetIndex();
  609. if (bForward && nIndex < pButtons->GetCount() -1)
  610. {
  611. wndView.FocusInplaceButton(pButtons->GetAt(nIndex + 1));
  612. return;
  613. }
  614. else if (!bForward && nIndex > 0)
  615. {
  616. wndView.FocusInplaceButton(pButtons->GetAt(nIndex - 1));
  617. return;
  618. }
  619. }
  620. else
  621. {
  622. wndView.FocusInplaceButton(pButtons->GetAt(bForward ? 0 : pButtons->GetCount() - 1));
  623. return;
  624. }
  625. }
  626. nUI += nNextElement;
  627. }
  628. if (nUI == xtpGridUIViewNext)
  629. {
  630. if (m_bTabItems)
  631. {
  632. int nIndex = bForward ? (pItem ? pItem->m_nIndex + 1 : 0) : wndView.GetCount() - 1;
  633. if (nIndex < wndView.GetCount())
  634. {
  635. wndView.SetFocus();
  636. wndView.SetCurSel(nIndex);
  637. wndView.OnSelectionChanged();
  639. if (bForward)
  640. {
  641. if (!m_bTabCaptions)
  642. {
  643. nUI = xtpGridUIView;
  644. }
  645. else
  646. return;
  647. }
  648. pItem = wndView.GetSelectedItem();
  649. }
  650. }
  652. nUI += nNextElement;
  653. }
  654. if (nUI == xtpGridUIVerb)
  655. {
  656. if (IsVerbsVisible())
  657. {
  658. m_nFocusedVerb = bForward ? 0 : m_pVerbs->GetCount() - 1;
  659. m_bVerbActivate = TRUE;
  660. SetFocus();
  661. m_bVerbActivate = FALSE;
  662. Invalidate(FALSE);
  663. return;
  664. }
  665. nUI += nNextElement;
  666. }
  667. if (nUI == xtpGridUIParentNext || nUI == xtpGridUIParentPrev)
  668. {
  670. CWnd* pWndNext = GetNextGridTabItem(!bForward);
  672. if (pWndNext != NULL)
  673. {
  674. pWndNext->SetFocus();
  675. return;
  676. }
  678. nUI = (nUI == xtpGridUIParentNext) ? xtpGridUIViewPrev : xtpGridUIVerb;
  679. }
  680. if (nUI < xtpGridUIParentPrev || nUI > xtpGridUIParentNext)
  681. {
  682. ASSERT(FALSE);
  683. return;
  684. }
  685. }
  686. }
  688. void CXTPPropertyGrid::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  689. {
  690. if (m_nFocusedVerb != -1 && IsVerbsVisible())
  691. {
  692. if (m_nFocusedVerb >= m_pVerbs->GetCount())
  693. m_nFocusedVerb = m_pVerbs->GetCount() -1;
  695. BOOL bForward = GetKeyState(VK_SHIFT) >= 0;
  696. CXTPDrawHelpers::KeyToLayout(this, nChar);
  698. if ((nChar == VK_TAB) && bForward && (m_nFocusedVerb == m_pVerbs->GetCount() -1))
  699. {
  700. OnNavigate(xtpGridUIVerb, TRUE, NULL);
  701. return;
  703. }
  704. else if ((nChar == VK_TAB) && !bForward && (m_nFocusedVerb == 0))
  705. {
  706. OnNavigate(xtpGridUIVerb, FALSE, NULL);
  707. return;
  708. }
  709. else if (nChar == VK_RIGHT || nChar == VK_DOWN || ((nChar == VK_TAB) && bForward))
  710. {
  711. m_nFocusedVerb++;
  712. if (m_nFocusedVerb >= m_pVerbs->GetCount())
  713. m_nFocusedVerb = 0;
  714. Invalidate(FALSE);
  715. }
  716. else if (nChar == VK_LEFT || nChar == VK_UP || nChar == VK_TAB)
  717. {
  718. m_nFocusedVerb--;
  719. if (m_nFocusedVerb < 0)
  720. m_nFocusedVerb = m_pVerbs->GetCount() -1;
  721. Invalidate(FALSE);
  722. }
  723. else if (nChar == VK_RETURN)
  724. {
  725. CRect rcPart = m_pVerbs->GetAt(m_nFocusedVerb)->GetPart();
  726. OnVerbClick(m_nFocusedVerb, CPoint(rcPart.left, rcPart.bottom));
  727. }
  728. }
  730. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  731. }
  733. void CXTPPropertyGrid::OnKillFocus(CWnd* pNewWnd)
  734. {
  735. if (m_nFocusedVerb != -1)
  736. {
  737. m_nFocusedVerb = -1;
  738. Invalidate(FALSE);
  739. }
  740. CWnd::OnKillFocus(pNewWnd);
  741. }
  743. void CXTPPropertyGrid::OnSetFocus(CWnd* pOldWnd)
  744. {
  745. if (!m_bVerbActivate)
  746. {
  747. if (pOldWnd && pOldWnd == GetNextGridTabItem(FALSE) && GetKeyState(VK_SHIFT) < 0)
  748. {
  749. OnNavigate(xtpGridUIParentNext, FALSE, NULL);
  750. }
  751. else if (pOldWnd && pOldWnd == GetNextGridTabItem(TRUE) && GetKeyState(VK_SHIFT) >= 0)
  752. {
  753. OnNavigate(xtpGridUIParentPrev, TRUE, NULL);
  754. }
  755. else
  756. {
  757. GetGridView().SetFocus();
  758. }
  759. }
  760. else
  761. {
  762. CWnd::OnSetFocus(pOldWnd);
  763. }
  764. }
  766. void CXTPPropertyGrid::OnSize(UINT nType, int cx, int cy)
  767. {
  768. CWnd::OnSize(nType, cx, cy);
  770. if (!GetGridView().GetSafeHwnd())
  771. return;
  773. Reposition(cx, cy);
  774. }
  776. int CXTPPropertyGrid::HitTest(CPoint pt)
  777. {
  778. CXTPClientRect rc(this);
  780. if (m_bHelpVisible)
  781. {
  782. CRect rcSplitter(CPoint(rc.left, rc.bottom - SPLITTER_HEIGHT - m_nHelpHeight), CSize(rc.Width(), SPLITTER_HEIGHT));
  784. if (m_bVariableHelpHeight && rcSplitter.PtInRect(pt))
  785. return xtpGridHitHelpSplitter;
  787. rc.bottom -= SPLITTER_HEIGHT + m_nHelpHeight;
  788. }
  789. if (IsVerbsVisible())
  790. {
  791. CRect rcSplitter(CPoint(rc.left, rc.bottom - SPLITTER_HEIGHT - m_nVerbsHeight), CSize(rc.Width(), SPLITTER_HEIGHT));
  793. if (rcSplitter.PtInRect(pt))
  794. return xtpGridHitVerbsSplitter;
  796. CRect rcVerbs(rc);
  797. rcVerbs.top = rc.bottom - m_nVerbsHeight;
  799. if (rcVerbs.PtInRect(pt))
  800. {
  801. CWindowDC dc(this);
  802. int nIndex = m_pPaintManager->HitTestVerbs(&dc, rcVerbs, pt);
  803. if (nIndex != -1)
  804. {
  805. return xtpGridHitFirstVerb + nIndex;
  806. }
  807. }
  808. }
  810. return xtpGridHitError;
  811. }
  813. BOOL CXTPPropertyGrid::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  814. {
  815. if (nHitTest == HTCLIENT)
  816. {
  817. CPoint point;
  819. GetCursorPos(&point);
  820. ScreenToClient(&point);
  822. int nHit = HitTest(point);
  824. if (nHit == xtpGridHitHelpSplitter || nHit == xtpGridHitVerbsSplitter)
  825. {
  826. SetCursor(m_hCursorSplit);
  827. return TRUE;
  828. }
  829. if ((nHit != -1) && (nHit >= xtpGridHitFirstVerb))
  830. {
  831. SetCursor(m_hCursorHand);
  832. return TRUE;
  833. }
  834. }
  836. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  837. }
  839. void CXTPPropertyGrid::OnInvertTracker(CRect rect)
  840. {
  841. ASSERT_VALID(this);
  842. ASSERT(!rect.IsRectEmpty());
  843. ASSERT((GetStyle() & WS_CLIPCHILDREN) == 0);
  845. // pat-blt without clip children on
  846. CDC* pDC = GetDC();
  848. CBrush brush(GetXtremeColor(COLOR_3DFACE));
  849. CBrush* pBrush = (CBrush*)pDC->SelectObject(&brush);
  850. pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
  851. pDC->SelectObject(pBrush);
  853. ReleaseDC(pDC);
  854. }
  856. void CXTPPropertyGrid::OnSelectionChanged(CXTPPropertyGridItem* pItem)
  857. {
  858. if (!m_hWnd)
  859. return;
  861. CXTPClientRect rc(this);
  862. CRect rcHelp(rc);
  863. rcHelp.top = rc.bottom - m_nHelpHeight;
  865. if (pItem) SendNotifyMessage(XTP_PGN_SELECTION_CHANGED, (LPARAM)pItem);
  867. InvalidateRect(rcHelp, FALSE);
  868. }
  870. void CXTPPropertyGrid::OnVerbsChanged()
  871. {
  872. if (m_bVerbsVisible != IsVerbsVisible() && GetGridView().m_nLockUpdate == 0)
  873. {
  874. Reposition();
  875. }
  876. else if (GetSafeHwnd() && GetGridView().m_nLockUpdate == 0)
  877. {
  878. Invalidate(FALSE);
  879. }
  880. }
  882. void CXTPPropertyGrid::OnVerbClick(int nIndex, CPoint pt)
  883. {
  884. ClientToScreen(&pt);
  885. ASSERT(nIndex < m_pVerbs->GetCount());
  887. CXTPPropertyGridVerb* pVerb = m_pVerbs->GetAt(nIndex);
  888. pVerb->m_ptClick = pt;
  890. SendNotifyMessage(XTP_PGN_VERB_CLICK, (LPARAM)pVerb);
  891. }
  893. void CXTPPropertyGrid::OnLButtonUp(UINT nFlags, CPoint point)
  894. {
  895. if ((m_nFocusedVerb != -1) && (m_nFocusedVerb == HitTest(point) - xtpGridHitFirstVerb))
  896. {
  897. OnVerbClick(m_nFocusedVerb, point);
  898. }
  899. else
  900. {
  901. CWnd::OnLButtonUp(nFlags, point);
  902. }
  904. }
  906. void CXTPPropertyGrid::OnLButtonDown(UINT nFlags, CPoint point)
  907. {
  908. int nHitTest = HitTest(point);
  910. if ((nHitTest != -1) && (nHitTest >= xtpGridHitFirstVerb))
  911. {
  912. m_nFocusedVerb = nHitTest - xtpGridHitFirstVerb;
  913. m_bVerbActivate = TRUE;
  914. SetFocus();
  915. m_bVerbActivate = FALSE;
  916. Invalidate(FALSE);
  917. return;
  919. }
  920. SetFocus();
  922. if ((nHitTest == xtpGridHitHelpSplitter) || (nHitTest == xtpGridHitVerbsSplitter))
  923. {
  924. SetCapture();
  925. CXTPClientRect rc(this);
  926. BOOL bHelpHitTest = nHitTest == xtpGridHitHelpSplitter;
  928. CRect rcAvail = bHelpHitTest ? CRect(0, 20 + TOOLBAR_HEIGHT, rc.right, rc.bottom) :
  929. CRect(0, 20 + TOOLBAR_HEIGHT, rc.right, rc.bottom - (IsHelpVisible() ? m_nHelpHeight + SPLITTER_HEIGHT : 0));
  931. ModifyStyle(WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0, FALSE);
  933. m_rectTracker.SetRect(0, point.y, rc.Width(), point.y + 3);
  935. OnInvertTracker(m_rectTracker);
  937. BOOL bAccept = FALSE;
  938. while (GetCapture() == this)
  939. {
  940. MSG msg;
  941. if (!GetMessage(&msg, NULL, 0, 0))
  942. break;
  944. if (msg.message == WM_MOUSEMOVE)
  945. {
  946. point = CPoint(msg.lParam);
  947. point.y = __min(point.y, rcAvail.bottom - 20);
  948. point.y = __max((int)point.y, int(rcAvail.top));
  950. if (m_rectTracker.top != point.y)
  951. {
  952. OnInvertTracker(m_rectTracker);
  953. m_rectTracker.OffsetRect(0, point.y - m_rectTracker.top);
  954. OnInvertTracker(m_rectTracker);
  955. }
  956. }
  957. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  958. else if (msg.message == WM_LBUTTONUP)
  959. {
  960. bAccept = TRUE;
  961. break;
  962. }
  963. else  ::DispatchMessage(&msg);
  964. }
  966. ReleaseCapture();
  968. if (bAccept)
  969. {
  970. if (bHelpHitTest) m_nHelpHeight = rcAvail.bottom - m_rectTracker.top -2; else
  971. m_nVerbsHeight = rcAvail.bottom - m_rectTracker.top -2;
  972. Reposition(rc.Width(), rc.Height());
  973. }
  974. Invalidate(FALSE);
  975. ModifyStyle(0, WS_CLIPCHILDREN | WS_CLIPSIBLINGS, FALSE);
  976. return;
  977. }
  979. CWnd::OnLButtonDown(nFlags, point);
  980. }
  982. void CXTPPropertyGrid::Reposition()
  983. {
  984. if (GetSafeHwnd() == 0)
  985. return;
  987. CXTPClientRect rc(this);
  988. Reposition(rc.Width(), rc.Height());
  989. }
  991. void CXTPPropertyGrid::Reposition(int cx, int cy)
  992. {
  993. if (GetGridView().m_nLockUpdate > 0)
  994. return;
  996. if (GetSafeHwnd() == 0)
  997. return;
  999. CRect rcView(0, 0, cx, cy);
  1001. int nMinViewHeight = 20 + (m_bToolBarVisible ? TOOLBAR_HEIGHT : 0);
  1003. if (m_bHelpVisible)
  1004. {
  1005. if (cy > nMinViewHeight && cy - m_nHelpHeight - SPLITTER_HEIGHT < nMinViewHeight && m_bVariableHelpHeight)
  1006. {
  1007. m_nHelpHeight = max(0, cy - SPLITTER_HEIGHT - nMinViewHeight);
  1008. }
  1010. rcView.bottom -= m_nHelpHeight + SPLITTER_HEIGHT;
  1011. }
  1013. if (IsVerbsVisible())
  1014. {
  1015. rcView.bottom -= m_nVerbsHeight + SPLITTER_HEIGHT;
  1016. }
  1018. m_bVerbsVisible = IsVerbsVisible();
  1020. if (m_bToolBarVisible)
  1021. {
  1022. ASSERT(m_wndToolbar.GetSafeHwnd());
  1023. CRect rcToolBar(0, 0, cx, TOOLBAR_HEIGHT);
  1024. m_wndToolbar.MoveWindow(rcToolBar);
  1026. rcView.top += TOOLBAR_HEIGHT;
  1027. }
  1029. GetGridView().MoveWindow(rcView);
  1030. GetGridView().Invalidate(FALSE);
  1031. Invalidate(FALSE);
  1032. }
  1034. void CXTPPropertyGrid::CreateToolbar()
  1035. {
  1036. #if _MSC_VER < 1200
  1037. m_wndToolbar.Create(this, TBSTYLE_TRANSPARENT | TBSTYLE_FLAT | WS_CHILD | WS_VISIBLE | WS_BORDER, 0);
  1038. #else
  1039. m_wndToolbar.CreateEx(this, TBSTYLE_TRANSPARENT | TBSTYLE_FLAT, WS_BORDER | WS_CHILD | WS_VISIBLE | CBRS_ALIGN_TOP);
  1040. #endif
  1042. VERIFY(XTPResourceManager()->LoadToolBar(&m_wndToolbar, XTP_IDR_PROPERTYGRID_TOOLBAR));
  1043. }
  1045. void CXTPPropertyGrid::ShowToolBar(BOOL bShow)
  1046. {
  1047. if (bShow && !m_wndToolbar.GetSafeHwnd())
  1048. {
  1049. CreateToolbar();
  1050. }
  1051. else
  1052. {
  1053. if (m_wndToolbar.GetSafeHwnd())
  1054. m_wndToolbar.ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  1055. }
  1057. m_bToolBarVisible = bShow;
  1059. Reposition();
  1060. RefreshToolBarButtons();
  1061. }
  1063. void CXTPPropertyGrid::RefreshToolBarButtons()
  1064. {
  1065. if (m_bToolBarVisible)
  1066. {
  1067. m_wndToolbar.GetToolBarCtrl().SetState(XTP_IDC_PROPERTYGRID_CATEGORIZED, TBSTATE_ENABLED | (GetGridView().m_properetySort == xtpGridSortCategorized ? TBSTATE_CHECKED : 0));
  1068. m_wndToolbar.GetToolBarCtrl().SetState(XTP_IDC_PROPERTYGRID_ALPHABETIC, TBSTATE_ENABLED | (GetGridView().m_properetySort == xtpGridSortAlphabetical ? TBSTATE_CHECKED : 0));
  1069. }
  1070. }
  1072. void CXTPPropertyGrid::ShowHelp(BOOL bShow)
  1073. {
  1074. m_bHelpVisible = bShow;
  1076. Reposition();
  1077. }
  1079. void CXTPPropertyGrid::OnSortAlphabetic()
  1080. {
  1081. SetPropertySort(xtpGridSortAlphabetical);
  1082. }
  1084. void CXTPPropertyGrid::OnSortCategorized()
  1085. {
  1086. SetPropertySort(xtpGridSortCategorized);
  1087. }
  1089. void CXTPPropertyGrid::OnSortChanged()
  1090. {
  1091. RefreshToolBarButtons();
  1092. OnSelectionChanged(NULL);
  1093. SendNotifyMessage(XTP_PGN_SORTORDER_CHANGED, (LPARAM)GetDlgCtrlID());
  1094. }
  1096. LRESULT CXTPPropertyGrid::SendNotifyMessage(WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/)
  1097. {
  1098. return GetOwner()->SendMessage(XTPWM_PROPERTYGRID_NOTIFY, wParam, lParam);
  1099. }
  1101. void CXTPPropertyGrid::SetStandardColors()
  1102. {
  1103. m_pPaintManager->GetItemMetrics()->SetDefaultValues();
  1105. m_pPaintManager->RefreshMetrics();
  1106. RedrawControl();
  1107. }
  1109. void CXTPPropertyGrid::RedrawControl()
  1110. {
  1111. if (GetSafeHwnd())
  1112. {
  1113. RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_INVALIDATE | RDW_ERASE);
  1114. }
  1115. }
  1117. void CXTPPropertyGrid::SetCustomColors(
  1118. COLORREF clrHelpBack, COLORREF clrHelpFore, COLORREF clrViewLine,
  1119. COLORREF clrViewBack, COLORREF clrViewFore, COLORREF clrCategoryFore)
  1120. {
  1121. CXTPPropertyGridItemMetrics* pMetrics = m_pPaintManager->GetItemMetrics();
  1123. pMetrics->m_clrHelpBack.SetCustomValue(clrHelpBack);
  1124. pMetrics->m_clrHelpFore.SetCustomValue(clrHelpFore);
  1125. pMetrics->m_clrLine.SetCustomValue(clrViewLine);
  1126. pMetrics->m_clrBack.SetCustomValue(clrViewBack);
  1127. pMetrics->m_clrFore.SetCustomValue(clrViewFore);
  1128. pMetrics->m_clrCategoryFore.SetCustomValue(clrCategoryFore);
  1130. RedrawControl();
  1131. }
  1133. void CXTPPropertyGrid::ResetContent()
  1134. {
  1135. m_pVerbs->RemoveAll();
  1136. GetGridView().ResetContent();
  1138. GetGridView().m_nLockUpdate++;
  1139. GetGridView().m_pCategories->Clear();
  1140. GetGridView().m_nLockUpdate--;
  1141. }
  1143. CXTPPropertyGridItems* CXTPPropertyGrid::GetCategories() const
  1144. {
  1145. return GetGridView().m_pCategories;
  1146. }
  1148. CXTPPropertyGridItem* CXTPPropertyGrid::AddCategory(int nID, CXTPPropertyGridItem* pCategory)
  1149. {
  1150. CString strCaption;
  1151. VERIFY(strCaption.LoadString(nID));
  1152. CXTPPropertyGridItem* pItem = GetGridView().AddCategory(strCaption, pCategory);
  1153. pItem->SetID(nID);
  1154. return pItem;
  1155. }
  1157. CXTPPropertyGridItem* CXTPPropertyGrid::InsertCategory(int nIndex, int nID, CXTPPropertyGridItem* pCategory)
  1158. {
  1159. CString strCaption;
  1160. VERIFY(strCaption.LoadString(nID));
  1161. CXTPPropertyGridItem* pItem = GetGridView().InsertCategory(nIndex, strCaption, pCategory);
  1162. pItem->SetID(nID);
  1163. return pItem;
  1164. }
  1167. void CXTPPropertyGrid::SetFont(CFont* pFont)
  1168. {
  1169. LOGFONT lf;
  1170. if (pFont->GetLogFont(&lf))
  1171. {
  1172. CXTPPropertyGridItemMetrics* pMetrics = m_pPaintManager->GetItemMetrics();
  1174. pMetrics->m_fontNormal.DeleteObject();
  1175. pMetrics->m_fontBold.DeleteObject();
  1177. lf.lfWeight = FW_NORMAL;
  1178. VERIFY(pMetrics->m_fontNormal.CreateFontIndirect(&lf));
  1180. lf.lfWeight = FW_BOLD;
  1181. VERIFY(pMetrics->m_fontBold.CreateFontIndirect(&lf));
  1183. if (m_pInplaceEdit->GetSafeHwnd())
  1184. {
  1185. m_pInplaceEdit->SetFont(&pMetrics->m_fontNormal);
  1186. }
  1188. Refresh();
  1189. }
  1190. }
  1192. void CXTPPropertyGrid::Refresh()
  1193. {
  1194. GetGridView().SetPropertySort(GetPropertySort(), TRUE);
  1195. }
  1198. void CXTPPropertyGrid::SaveExpandingState(CXTPPropertyGridItems* pItems, CXTPPropertyGridUpdateContext& context)
  1199. {
  1200. int nTopIndex = GetGridView().GetTopIndex();
  1202. for (int nItem = 0; nItem < pItems->GetCount(); nItem++)
  1203. {
  1204. CXTPPropertyGridItem* pItem = pItems->GetAt(nItem);
  1206. if (pItem->GetID() != 0)
  1207. {
  1208. if (pItem->HasChilds())
  1209. {
  1210. BOOL bExpanded = pItem->IsExpanded();
  1211. context.m_mapState.SetAt(pItem->GetID(), bExpanded);
  1212. }
  1214. if (pItem->IsSelected()) context.m_nSelected = pItem->GetID();
  1215. if (pItem->GetIndex() == nTopIndex) context.m_nTopIndex= pItem->GetID();
  1216. }
  1217. SaveExpandingState(pItem->GetChilds(), context);
  1218. }
  1219. }
  1221. void CXTPPropertyGrid::RestoreExpandingState(CXTPPropertyGridItems* pItems, CXTPPropertyGridUpdateContext& context)
  1222. {
  1223. for (int nItem = 0; nItem < pItems->GetCount(); nItem++)
  1224. {
  1225. CXTPPropertyGridItem* pItem = pItems->GetAt(nItem);
  1227. BOOL bExpanded;
  1228. if (pItem->GetID() != 0 && context.m_mapState.Lookup(pItem->GetID(), bExpanded))
  1229. {
  1230. if (bExpanded)
  1231. pItem->Expand();
  1232. else
  1233. pItem->Collapse();
  1234. }
  1235. RestoreExpandingState(pItem->GetChilds(), context);
  1236. }
  1237. }
  1239. void CXTPPropertyGrid::BeginUpdate(CXTPPropertyGridUpdateContext& context, BOOL bResetContent)
  1240. {
  1241. GetGridView().m_nLockUpdate = 1;
  1242. GetGridView().SetRedraw(FALSE);
  1244. context.m_nSelected = 0;
  1245. context.m_nTopIndex = 0;
  1246. context.m_propertySort = GetPropertySort();
  1248. if (bResetContent)
  1249. {
  1250. SaveExpandingState(GetCategories(), context);
  1251. ResetContent();
  1252. }
  1253. else
  1254. {
  1255. GetGridView().ResetContent();
  1256. }
  1257. }
  1259. void CXTPPropertyGrid::EndUpdate(CXTPPropertyGridUpdateContext& context)
  1260. {
  1261. RestoreExpandingState(GetCategories(), context);
  1262. GetGridView().m_nLockUpdate = 0;
  1264. GetGridView().SetPropertySort(context.m_propertySort, TRUE, FALSE);
  1265. if (context.m_nSelected > 0 || context.m_nTopIndex > 0)
  1266. {
  1267. for (int i = 0; i < GetGridView().GetCount(); i++)
  1268. {
  1269. CXTPPropertyGridItem* pItem = GetGridView().GetItem(i);
  1271. if (context.m_nTopIndex > 0 && pItem && pItem->GetID() == context.m_nTopIndex)
  1272. {
  1273. SetTopIndex(pItem->GetIndex());
  1274. context.m_nTopIndex = 0;
  1275. if (context.m_nSelected == 0)
  1276. break;
  1277. }
  1279. if (context.m_nSelected > 0 && pItem && pItem->GetID() == context.m_nSelected)
  1280. {
  1281. pItem->Select();
  1282. break;
  1283. }
  1284. }
  1285. }
  1287. GetGridView().SetRedraw(TRUE);
  1289. Reposition();
  1290. }
  1292. void CXTPPropertyGrid::SetVerbsHeight(int nHeight)
  1293. {
  1294. ASSERT(nHeight > 0);
  1295. m_nVerbsHeight = nHeight;
  1297. Reposition();
  1298. }
  1300. void CXTPPropertyGrid::SetHelpHeight(int nHeight)
  1301. {
  1303. ASSERT(nHeight > 0);
  1304. m_nHelpHeight = nHeight;
  1306. Reposition();
  1307. }
  1309. void CXTPPropertyGrid::SetViewDivider(double dDivider)
  1310. {
  1311. ASSERT(dDivider > 0 && dDivider < 1);
  1312. GetGridView().m_dDivider = dDivider;
  1314. Reposition();
  1315. }
  1317. double CXTPPropertyGrid::GetViewDivider() const
  1318. {
  1319. return GetGridView().m_dDivider;
  1320. }
  1322. void CXTPPropertyGrid::SetViewDividerPos(int nDivider, BOOL bLockDivider /*= FALSE*/)
  1323. {
  1324. if (bLockDivider)
  1325. {
  1326. GetGridView().LockDivider();
  1327. }
  1329. GetGridView().SetDividerPos(nDivider);
  1331. Reposition();
  1332. }
  1334. CXTPPropertyGridItem* CXTPPropertyGrid::GetSelectedItem() const
  1335. {
  1336. return GetGridView().GetSelectedItem();
  1337. }
  1339. CXTPPropertyGridItem* CXTPPropertyGrid::GetItem(int nIndex) const
  1340. {
  1341. return GetGridView().GetItem(nIndex);
  1342. }
  1344. int CXTPPropertyGrid::GetSelectedItems(CArray<int, int>* pItems) const
  1345. {
  1346. CXTPPropertyGridView* pView = &GetGridView();
  1348. if (pView->GetStyle() & LBS_MULTIPLESEL)
  1349. {
  1350. int nCount = pView->GetSelCount();
  1351. if (!pItems)
  1352. return nCount;
  1354. pItems->SetSize(nCount);
  1355. pView->GetSelItems(nCount, pItems->GetData());
  1356. }
  1357. else
  1358. {
  1359. CXTPPropertyGridItem* pItem = GetSelectedItem();
  1360. if (!pItems)
  1361. return pItem ? 1 : 0;
  1363. if (pItem)
  1364. {
  1365. pItems->RemoveAll();
  1366. pItems->Add(pItem->GetIndent());
  1367. }
  1369. }
  1371. return (int)pItems->GetSize();
  1372. }
  1374. int CXTPPropertyGrid::GetTopIndex() const
  1375. {
  1376. return GetGridView().GetTopIndex();
  1377. }
  1379. void CXTPPropertyGrid::SetTopIndex(int nIndex)
  1380. {
  1381. GetGridView().SetTopIndex(nIndex);
  1382. }
  1384. void CXTPPropertyGrid::SetTheme(XTPPropertyGridPaintTheme paintTheme)
  1385. {
  1386. if (paintTheme == xtpGridThemeDefault) SetCustomTheme(new CXTPPropertyGridPaintManager(this));
  1387. else if (paintTheme == xtpGridThemeCool) SetCustomTheme(new CXTPPropertyGridCoolTheme(this));
  1388. else if (paintTheme == xtpGridThemeDelphi) SetCustomTheme(new CXTPPropertyGridDelphiTheme(this));
  1389. else if (paintTheme == xtpGridThemeNativeWinXP) SetCustomTheme(new CXTPPropertyGridNativeXPTheme(this));
  1390. else if (paintTheme == xtpGridThemeOffice2003) SetCustomTheme(new CXTPPropertyGridOffice2003Theme(this));
  1391. else if (paintTheme == xtpGridThemeSimple) SetCustomTheme(new CXTPPropertyGridSimpleTheme(this));
  1392. else if (paintTheme == xtpGridThemeWhidbey) SetCustomTheme(new CXTPPropertyGridWhidbeyTheme(this));
  1393. else if (paintTheme == xtpGridThemeOfficeXP) SetCustomTheme(new CXTPPropertyGridOfficeXPTheme(this));
  1394. else if (paintTheme == xtpGridThemeOffice2007) SetCustomTheme(new CXTPPropertyGridOffice2007Theme(this));
  1395. else
  1396. {
  1397. ASSERT(FALSE);
  1398. }
  1400. m_themeCurrent = paintTheme;
  1401. }
  1403. void CXTPPropertyGrid::SetCustomTheme(CXTPPropertyGridPaintManager* pPaintManager)
  1404. {
  1405. CXTPPropertyGridItemMetrics* pMetrics = m_pPaintManager->m_pMetrics;
  1406. m_pPaintManager->m_pMetrics = 0;
  1408. ASSERT(m_pPaintManager);
  1409. CMDTARGET_RELEASE(m_pPaintManager);
  1411. m_pPaintManager = pPaintManager;
  1413. CMDTARGET_RELEASE(m_pPaintManager->m_pMetrics);
  1414. m_pPaintManager->m_pMetrics = pMetrics;
  1415. m_pPaintManager->RefreshMetrics();
  1417. RedrawControl();
  1418. }
  1420. CXTPImageManager* CXTPPropertyGrid::GetImageManager() const
  1421. {
  1422. return m_pImageManager ? m_pImageManager : XTPImageManager();
  1423. }
  1425. void CXTPPropertyGrid::SetImageManager(CXTPImageManager* pImageManager)
  1426. {
  1427. if (m_pImageManager)
  1428. m_pImageManager->InternalRelease();
  1430. m_pImageManager = pImageManager;
  1431. }
  1433. void CXTPPropertyGrid::OnSysColorChange()
  1434. {
  1435. CWnd::OnSysColorChange();
  1437. m_pPaintManager->RefreshMetrics();
  1438. RedrawControl();
  1439. }
  1441. BOOL CXTPPropertyGrid::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
  1442. {
  1443. ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
  1445. // need to handle both ANSI and UNICODE versions of the message
  1446. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  1447. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  1449. CString strTipText;
  1451. // don't handle the message if no string resource found
  1452. if (!XTPResourceManager()->LoadString(&strTipText, (UINT)pNMHDR->idFrom))
  1453. return FALSE;
  1455. #ifndef _UNICODE
  1456. if (pNMHDR->code == TTN_NEEDTEXTA)
  1457. lstrcpyn(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1458. else
  1459. _mbstowcsz(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1460. #else
  1461. if (pNMHDR->code == TTN_NEEDTEXTA)
  1462. _wcstombsz(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1463. else
  1464. lstrcpyn(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1465. #endif
  1466. *pResult = 0;
  1468. // bring the tooltip window above other popup windows
  1469. ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
  1470. SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOOWNERZORDER);
  1472. return TRUE;    // message was handled
  1473. }
  1476. BOOL CXTPPropertyGrid::IsLayoutRTL() const
  1477. {
  1478. return GetExStyle() & WS_EX_LAYOUTRTL ? TRUE : FALSE;
  1479. }
  1481. void CXTPPropertyGrid::SetLayoutRTL(CWnd* pWnd, BOOL bRTLLayout)
  1482. {
  1483. pWnd->ModifyStyleEx(bRTLLayout ? 0 : WS_EX_LAYOUTRTL, !bRTLLayout ? 0 : WS_EX_LAYOUTRTL);
  1485. // walk through HWNDs to avoid creating temporary CWnd objects
  1486. // unless we need to call this function recursively
  1487. for (CWnd* pChild = pWnd->GetWindow(GW_CHILD); pChild != NULL;
  1488. pChild = pChild->GetWindow(GW_HWNDNEXT))
  1489. {
  1491. // send to child windows after parent
  1492. SetLayoutRTL(pChild, bRTLLayout);
  1493. }
  1494. }
  1497. void CXTPPropertyGrid::SetLayoutRTL(BOOL bRightToLeft)
  1498. {
  1499. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  1500. return;
  1502. SetLayoutRTL(this, bRightToLeft);
  1504. if (m_pInplaceEdit && m_pInplaceEdit->GetSafeHwnd())
  1505. {
  1506. m_pInplaceEdit->HideWindow();
  1507. m_pInplaceEdit->m_bDelayCreate = TRUE;
  1508. }
  1510. if (GetSelectedItem()) GetSelectedItem()->OnSelect();
  1512. Reposition();
  1513. RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_INVALIDATE | RDW_ERASE);
  1514. }
  1517. void CXTPPropertyGrid::SetBorderStyle(XTPPropertyGridBorderStyle borderStyle)
  1518. {
  1519. m_borderStyle = borderStyle;
  1521. Reposition();
  1523. if (GetGridView().GetSafeHwnd())
  1524. {
  1525. GetGridView().SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
  1526. }
  1527. }
  1529. XTPPropertyGridBorderStyle CXTPPropertyGrid::GetBorderStyle() const
  1530. {
  1531. return m_borderStyle;
  1532. }
  1534. void CXTPPropertyGrid::EnableMarkup(BOOL bEnable)
  1535. {
  1536. if (bEnable && m_pMarkupContext)
  1537. return;
  1539. XTPMarkupReleaseContext(m_pMarkupContext);
  1541. if (bEnable)
  1542. {
  1543. m_pMarkupContext = XTPMarkupCreateContext(m_hWnd);
  1544. }
  1545. }