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

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

对话框与窗口

开发平台：

Visual C++

XTPPropertyGridInplaceEdit.cpp：源码内容
  1. // PropertyGripInplaceEdit.cpp : implementation of the CPropertyGripInplaceEdit 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"
  25. #include "XTPPropertyGridInplaceEdit.h"
  26. #include "XTPPropertyGridInplaceButton.h"
  27. #include "XTPPropertyGridInplaceList.h"
  28. #include "XTPPropertyGridItem.h"
  29. #include "XTPPropertyGridInplaceEdit.h"
  30. #include "XTPPropertyGrid.h"
  31. #include "XTPPropertyGridDefines.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. /////////////////////////////////////////////////////////////////////////////
  40. // CXTPPropertyGridInplaceEdit
  42. CXTPPropertyGridInplaceEdit::CXTPPropertyGridInplaceEdit()
  43. : m_pItem(0)
  44. , m_pGrid(0)
  45. {
  46. m_clrBack = 0;
  47. m_bDelayCreate = FALSE;
  48. m_bCreated = FALSE;
  49. m_bCancel = FALSE;
  50. m_bEditMode = FALSE;
  51. m_bCheckAutoComplete = FALSE;
  52. m_bIgnoreEditChanged = FALSE;
  53. }
  55. CXTPPropertyGridInplaceEdit::~CXTPPropertyGridInplaceEdit()
  56. {
  57. }
  59. IMPLEMENT_DYNAMIC(CXTPPropertyGridInplaceEdit, CEdit)
  61. BEGIN_MESSAGE_MAP(CXTPPropertyGridInplaceEdit, CXTMaskEditT<CEdit>)
  62. ON_MASKEDIT_REFLECT()
  63. //{{AFX_MSG_MAP(CXTPPropertyGridInplaceEdit)
  64. ON_WM_CTLCOLOR_REFLECT()
  65. ON_CONTROL_REFLECT(EN_KILLFOCUS, OnEnKillfocus)
  66. ON_CONTROL_REFLECT(EN_SETFOCUS, OnEnSetfocus)
  67. ON_CONTROL_REFLECT(EN_CHANGE, OnEnChange)
  68. ON_WM_LBUTTONDBLCLK()
  69. ON_WM_KEYDOWN()
  70. ON_WM_GETDLGCODE()
  71. ON_WM_CHAR()
  72. ON_WM_SYSKEYDOWN()
  73. ON_WM_STYLECHANGED()
  74. //}}AFX_MSG_MAP
  75. END_MESSAGE_MAP()
  77. /////////////////////////////////////////////////////////////////////////////
  78. // CXTPPropertyGridInplaceEdit message handlers
  80. void CXTPPropertyGridInplaceEdit::SetValue(LPCTSTR strValue)
  81. {
  82. m_strValue = strValue;
  83. }
  85. void CXTPPropertyGridInplaceEdit::HideWindow()
  86. {
  87. if (m_hWnd)
  88. {
  89. ShowWindow(SW_HIDE);
  90. }
  91. }
  93. void CXTPPropertyGridInplaceEdit::OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct)
  94. {
  95. if (nStyleType == GWL_EXSTYLE && lpStyleStruct->styleNew & WS_EX_LAYOUTRTL)
  96. {
  97. HideWindow();
  98. m_bDelayCreate = TRUE;
  99. }
  101. CEdit::OnStyleChanged(nStyleType, lpStyleStruct);
  102. }
  104. void CXTPPropertyGridInplaceEdit::Create(CXTPPropertyGridItem* pItem, CRect rect)
  105. {
  106. ASSERT(pItem && pItem->GetGrid());
  107. if (!pItem || !pItem->GetGrid())
  108. return;
  110. m_pGrid = pItem->GetGrid();
  111. m_pItem = pItem;
  112. m_bCreated = FALSE;
  113. m_bEditMode = FALSE;
  114. m_bCancel = FALSE;
  115. m_bCheckAutoComplete = FALSE;
  117. DWORD dwEditStyle = m_pItem->GetEditStyle();
  119. if (m_hWnd)
  120. {
  121. DWORD dwStyle = (WS_CHILD | WS_VISIBLE | ES_READONLY) | (m_pGrid->GetExStyle() & WS_EX_LAYOUTRTL ? ES_RIGHT : 0);
  123. if ((GetStyle() | dwStyle) != (dwEditStyle | dwStyle))
  124. m_bDelayCreate = TRUE;
  126. if (GetExStyle() & WS_EX_LAYOUTRTL)
  127. m_bDelayCreate = TRUE;
  129. if (m_bDelayCreate)
  130. DestroyWindow();
  131. }
  133. if (!m_hWnd)
  134. {
  135. CEdit::Create(dwEditStyle, rect, m_pGrid, 0);
  136. }
  138. m_bDelayCreate = FALSE;
  140. if (m_pItem->m_bPassword)
  141. CEdit::SetPasswordChar(pItem->m_chPrompt);
  143. if (m_pItem->GetMetrics(TRUE, FALSE))
  144. {
  145. CEdit::SetLimitText(m_pItem->GetMetrics(TRUE, FALSE)->m_nMaxLength);
  146. }
  147. else
  148. {
  149. CEdit::SetLimitText(0);
  150. }
  152. SetFont(m_pGrid->GetPaintManager()->GetItemFont(pItem, TRUE));
  153. SetWindowText(m_strValue);
  154. SetWindowPos(0, rect.left, rect.top, rect.Width(), rect.Height(), SWP_NOZORDER | SWP_SHOWWINDOW);
  156. SetMargins(3, 3);
  158. SetUseMask(m_pItem->m_bUseMask);
  159. if (m_pItem->m_bUseMask)
  160. {
  161. SetEditMask(m_pItem->m_strMask, m_pItem->m_strLiteral, m_pItem->m_strValue);
  162. SetPromptChar(m_pItem->m_chPrompt);
  163. }
  165. m_bCreated = TRUE;
  166. }
  168. HBRUSH CXTPPropertyGridInplaceEdit::CtlColor(CDC* pDC, UINT /*nCtlColor*/)
  169. {
  170. CXTPPropertyGridPaintManager* pPaintManager = m_pGrid ? m_pGrid->GetPaintManager() : 0;
  172. if (!m_pItem || !pPaintManager)
  173. return 0;
  175. pDC->SetTextColor(pPaintManager->GetItemTextColor(m_pItem, TRUE));
  177. COLORREF clr = pPaintManager->GetItemBackColor(m_pItem, TRUE);
  179. if (clr != m_clrBack || !m_brBack.GetSafeHandle())
  180. {
  181. m_brBack.DeleteObject();
  182. m_brBack.CreateSolidBrush(clr);
  183. m_clrBack = clr;
  185. }
  187. pDC->SetBkColor(m_clrBack);
  190. return m_brBack;
  191. }
  193. void CXTPPropertyGridInplaceEdit::OnEnSetfocus()
  194. {
  195. if (!m_pGrid)
  196. return;
  198. m_pGrid->Invalidate(FALSE);
  201. if (m_pItem && !m_pItem->OnRequestEdit())
  202. m_pGrid->SetFocus();
  204. m_bEditMode = TRUE;
  205. }
  207. void CXTPPropertyGridInplaceEdit::OnEnKillfocus()
  208. {
  209. if (!m_pGrid)
  210. return;
  212. if (m_pItem)
  213. {
  214. m_pItem->OnValidateEdit();
  215. if (m_pGrid) m_pGrid->Invalidate(FALSE);
  216. }
  218. }
  220. void CXTPPropertyGridInplaceEdit::OnEnChange()
  221. {
  222. if (!m_bCreated || m_bIgnoreEditChanged)
  223. return;
  225. if (m_pItem && m_pGrid && !m_pItem->GetReadOnly() && m_pItem->m_bAutoComplete
  226. && !m_pItem->GetConstraintEdit() && m_bCheckAutoComplete)
  227. {
  228. m_bCheckAutoComplete = FALSE;
  230. CXTPPropertyGridItemConstraints* pList = m_pItem->GetConstraints();
  231. if (!pList->IsEmpty())
  232. {
  233. CString strWindowText;
  234. GetWindowText(strWindowText);
  235. int nLength = strWindowText.GetLength();
  238. // Currently selected range
  239. int nStart = 0, nEnd = 0;
  240. GetSel(nStart, nEnd);
  241. if (nStart == nEnd && nLength == nEnd && nLength > 0)
  242. {
  243. for (int nIndex = 0; nIndex < pList->GetCount(); nIndex += 1)
  244. {
  245. CString strWindowTextNew = pList->GetAt(nIndex);
  247. if (strWindowTextNew.GetLength() > nLength &&
  248. strWindowText.CompareNoCase(strWindowTextNew.Left(nLength)) == 0)
  249. {
  250. m_bIgnoreEditChanged = TRUE;
  251. SetWindowText(strWindowTextNew);
  252. SetSel(strWindowTextNew.GetLength(), nLength);
  253. m_bIgnoreEditChanged = FALSE;
  254. break;
  255. }
  256. }
  257. }
  258. }
  259. }
  261. if (m_pItem && m_pGrid)
  262. {
  263. ASSERT(m_pItem);
  264. m_pGrid->SendNotifyMessage(XTP_PGN_EDIT_CHANGED, (LPARAM)this);
  265. }
  266. }
  268. UINT CXTPPropertyGridInplaceEdit::OnGetDlgCode()
  269. {
  270. return DLGC_WANTALLKEYS;
  271. }
  273. void CXTPPropertyGridInplaceEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  274. {
  275. if (nChar == VK_TAB) return;
  277. if ((nChar == VK_RETURN) && (GetStyle() & ES_WANTRETURN))
  278. {
  279. CXTMaskEditT<CEdit>::OnChar(nChar, nRepCnt, nFlags);
  280. return;
  281. }
  283. if (nChar == VK_ESCAPE || nChar == VK_RETURN)
  284. {
  285. m_pGrid->SetFocus();
  286. return;
  287. }
  289. if (m_pItem && !m_pItem->GetReadOnly() && m_pItem->GetConstraintEdit())
  290. {
  291. CXTPPropertyGridItemConstraints* pList = m_pItem->GetConstraints();
  292. if (!pList->IsEmpty())
  293. {
  295. CString strWindowText;
  296. GetWindowText(strWindowText);
  297. int nIndex = pList->FindConstraint(strWindowText);
  298. int nIndexStart = nIndex == -1 ? pList->GetCount() - 1 : nIndex;
  300. CString strSeach ((TCHAR)nChar);
  302. do
  303. {
  305. nIndex = nIndex < pList->GetCount() - 1 ? nIndex + 1 : 0;
  306. CString str = pList->GetAt(nIndex);
  308. if (strSeach.CompareNoCase(str.Left(1)) == 0)
  309. {
  310. SetWindowText(str);
  311. pList->SetCurrent(nIndex);
  312. SetSel(0, -1);
  313. return;
  314. }
  316. }
  317. while (nIndex != nIndexStart);
  319. return;
  320. }
  321. }
  323. m_bCheckAutoComplete = (nChar != VK_DELETE) && (nChar != VK_BACK);
  325. CXTMaskEditT<CEdit>::OnChar(nChar, nRepCnt, nFlags);
  326. }
  328. void CXTPPropertyGridInplaceEdit::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  329. {
  330. if (!m_pItem)
  331. return;
  333. if (nChar == VK_TAB && m_pGrid)
  334. {
  335. ((CXTPPropertyGrid*)m_pGrid->GetParent())->OnNavigate(
  336. xtpGridUIInplaceEdit, GetKeyState(VK_SHIFT) >= 0, m_pItem);
  337. return;
  338. }
  339. else if (nChar == VK_ESCAPE)
  340. {
  341. m_bCancel = TRUE;
  342. m_bCheckAutoComplete = FALSE;
  343. SetWindowText(m_strValue);
  344. return ;
  345. }
  346. else if (nChar == VK_RETURN)
  347. {
  348. return ;
  349. }
  350. else if (nChar == VK_F4)
  351. {
  352. CXTPPropertyGridInplaceButton* pButton = m_pItem->GetInplaceButtons()->Find(XTP_ID_PROPERTYGRID_COMBOBUTTON);
  353. if (pButton)
  354. m_pItem->OnInplaceButtonDown(pButton);
  355. }
  356. else if (nChar == VK_DOWN || nChar == VK_UP)
  357. {
  358. if (m_pItem != NULL && !m_pItem->GetReadOnly())
  359. {
  360. if (SelectConstraint(nChar == VK_DOWN ? +1 : -1, FALSE))
  361. {
  362. SetSel(0, -1);
  363. return ;
  364. }
  365. }
  366. }
  367. m_bCheckAutoComplete = (nChar != VK_DELETE) && (nChar != VK_BACK);
  369. CXTMaskEditT<CEdit>::OnKeyDown(nChar, nRepCnt, nFlags);
  370. }
  372. void CXTPPropertyGridInplaceEdit::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  373. {
  374. if ((nChar == VK_DOWN || nChar == VK_UP) && m_pItem)
  375. {
  376. CXTPPropertyGridInplaceButton* pButton = m_pItem->GetInplaceButtons()->Find(XTP_ID_PROPERTYGRID_COMBOBUTTON);
  377. if (pButton)
  378. m_pItem->OnInplaceButtonDown(pButton);
  379. }
  381. CXTMaskEditT<CEdit>::OnSysKeyDown(nChar, nRepCnt, nFlags);
  382. }
  384. BOOL CXTPPropertyGridInplaceEdit::SelectConstraint(int nDirection, BOOL bCircle)
  385. {
  386. CXTPPropertyGridItemConstraints* pList = m_pItem->GetConstraints();
  387. if (pList->IsEmpty())
  388. return FALSE;
  390. CString str;
  391. GetWindowText(str);
  392. int nIndex = pList->FindConstraint(str);
  394. if (nIndex == -1)
  395. return FALSE;
  397. nIndex += nDirection;
  398. if (nIndex >= pList->GetCount()) nIndex = bCircle ? 0 : (ULONG)pList->GetCount() - 1;
  399. if (nIndex < 0) nIndex = bCircle ? (ULONG)pList->GetCount() - 1 : 0;
  401. m_bCheckAutoComplete = FALSE;
  402. SetWindowText(pList->GetAt(nIndex));
  403. pList->SetCurrent(nIndex);
  405. return TRUE;
  406. }
  408. void CXTPPropertyGridInplaceEdit::OnLButtonDblClk(UINT nFlags, CPoint point)
  409. {
  410. if (m_pGrid && m_pItem != NULL && !m_pItem->GetReadOnly() && SelectConstraint(+1, TRUE))
  411. {
  412. m_pGrid->SetFocus();
  413. return;
  414. }
  415. CXTMaskEditT<CEdit>::OnLButtonDblClk(nFlags, point);
  416. }
  418. void CXTPPropertyGridInplaceEdit::DestroyItem()
  419. {
  420. // reset variables to defaults.
  421. m_pItem = NULL;
  422. m_pGrid = NULL;
  423. m_strValue.Empty();
  424. m_brBack.DeleteObject();
  426. // destroy the window.
  427. //DestroyWindow();
  428. if (::IsWindow(m_hWnd)) ShowWindow(SW_HIDE);
  429. }
  432. BOOL CXTPPropertyGridInplaceEdit::PreTranslateMessage(MSG* pMsg)
  433. {
  434. if (pMsg->message == WM_KEYDOWN && IsDialogMessage(pMsg))
  435. return TRUE;
  437. return CXTMaskEditT<CEdit>::PreTranslateMessage(pMsg);
  438. }
  441. //////////////////////////////////////////////////////////////////////////
  442. // CXTPPropertyGridInplaceControl
  444. CXTPPropertyGridInplaceControl::CXTPPropertyGridInplaceControl(CXTPPropertyGridItem* pItem)
  445. {
  446. m_pItem = pItem;
  447. m_nWidth = 0;
  448. }
  450. void CXTPPropertyGridInplaceControl::OnFinalRelease()
  451. {
  452. if (m_hWnd != NULL)
  453. DestroyWindow();
  455. CCmdTarget::OnFinalRelease();
  456. }
  458. void CXTPPropertyGridInplaceControl::OnDestroyWindow()
  459. {
  460. DestroyWindow();
  461. }
  463. void CXTPPropertyGridInplaceControl::OnValueChanged()
  464. {
  466. }
  468. BEGIN_MESSAGE_MAP(CXTPPropertyGridInplaceControl, CWnd)
  469. ON_WM_CHAR()
  470. ON_WM_KEYDOWN()
  471. ON_WM_GETDLGCODE()
  472. END_MESSAGE_MAP()
  475. UINT CXTPPropertyGridInplaceControl::OnGetDlgCode()
  476. {
  477. return CWnd::OnGetDlgCode() | DLGC_WANTTAB;
  478. }
  480. void CXTPPropertyGridInplaceControl::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  481. {
  482. if (nChar == VK_TAB) return;
  484. CWnd::OnChar(nChar, nRepCnt, nFlags);
  485. }
  487. void CXTPPropertyGridInplaceControl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  488. {
  489. if (nChar == VK_TAB && m_pItem)
  490. {
  491. ((CXTPPropertyGrid*)m_pItem->GetGrid()->GetParent())->OnNavigate(
  492. xtpGridUIInplaceControl, GetKeyState(VK_SHIFT) >= 0, m_pItem);
  493. return;
  494. }
  496. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  497. }
  499. //////////////////////////////////////////////////////////////////////////
  500. // CXTPPropertyGridInplaceSlider
  502. CXTPPropertyGridInplaceSlider::CXTPPropertyGridInplaceSlider(CXTPPropertyGridItem* pItem)
  503. : CXTPPropertyGridInplaceControl(pItem)
  504. {
  505. m_nMin = 0;
  506. m_nMax = 100;
  508. m_nValue = 0;
  510. m_clrBack = COLORREF_NULL;
  513. }
  515. BEGIN_MESSAGE_MAP(CXTPPropertyGridInplaceSlider, CXTPPropertyGridInplaceControl)
  516. ON_WM_CTLCOLOR_REFLECT()
  517. ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
  518. END_MESSAGE_MAP()
  520. int CXTPPropertyGridInplaceSlider::CalcualteEditWidth()
  521. {
  522. if (m_nWidth != 0)
  523. return m_nWidth;
  525. CWindowDC dc(m_pItem->GetGrid());
  526. CXTPFontDC font (&dc, m_pItem->GetGrid()->GetFont());
  528. CString strMax;
  529. strMax.Format(_T("%i"), m_nMax);
  531. CString strMin;
  532. strMin.Format(_T("%i"), m_nMin);
  534. int nWidth = max(dc.GetTextExtent(strMax).cx, dc.GetTextExtent(strMin).cx) + 6;
  536. return nWidth;
  537. }
  539. void CXTPPropertyGridInplaceSlider::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  540. {
  541. LPNMCUSTOMDRAW lpCustDraw = (LPNMCUSTOMDRAW)pNMHDR;
  543. if(lpCustDraw->dwDrawStage == CDDS_PREPAINT)
  544. {
  545. int nValue = GetSliderCtrl()->GetPos();
  546. if (nValue != m_nValue)
  547. {
  548. m_nValue = nValue;
  549. CString strValue;
  550. strValue.Format(_T("%i"), nValue);
  552. m_pItem->SetValue(strValue);
  553. m_pItem->OnValueChanged(strValue);
  555. m_pItem->GetGrid()->Invalidate(FALSE);
  556. }
  557. }
  559. *pResult = CDRF_DODEFAULT;
  560. }
  562. void CXTPPropertyGridInplaceSlider::OnCreateWindow(CRect& rcValue)
  563. {
  564. CRect rcSlider(rcValue);
  566. if (m_nWidth > 0)
  567. {
  568. rcSlider.left = rcSlider.right - m_nWidth;
  570. if (rcSlider.left < rcValue.left)
  571. return;
  573. rcValue.right -= m_nWidth;
  574. }
  575. else
  576. {
  577. int nWidth = CalcualteEditWidth();
  578. rcSlider.left += nWidth;
  580. if (rcSlider.right < rcSlider.left)
  581. return;
  583. rcValue.right = rcValue.left + nWidth;
  584. }
  586. if (!m_hWnd)
  587. {
  588. VERIFY(AfxDeferRegisterClass(AFX_WNDCOMMCTL_BAR_REG));
  590. Create(TRACKBAR_CLASS, NULL, WS_CHILD | TBS_HORZ | WS_TABSTOP, rcSlider, (CWnd*)m_pItem->GetGrid(), 0);
  591. }
  593. m_nValue = _ttol(m_pItem->GetValue());
  594. GetSliderCtrl()->SetRange(m_nMin, m_nMax, TRUE);
  595. GetSliderCtrl()->SetPos(m_nValue);
  596. GetSliderCtrl()->EnableWindow(!m_pItem->GetReadOnly());
  598. MoveWindow(rcSlider);
  599. ShowWindow(SW_SHOW);
  600. }
  602. HBRUSH CXTPPropertyGridInplaceSlider::CtlColor(CDC* pDC, UINT /*nCtlColor*/)
  603. {
  604. CXTPPropertyGridView* pGrid = m_pItem ? m_pItem->GetGrid() : 0;
  605. CXTPPropertyGridPaintManager* pPaintManager = pGrid ? pGrid->GetPaintManager() : 0;
  607. if (!m_pItem || !pPaintManager)
  608. return 0;
  610. pDC->SetTextColor(pPaintManager->GetItemTextColor(m_pItem, TRUE));
  612. COLORREF clr = pPaintManager->GetItemBackColor(m_pItem, TRUE);
  614. if (clr != m_clrBack || !m_brBack.GetSafeHandle())
  615. {
  616. m_brBack.DeleteObject();
  617. m_brBack.CreateSolidBrush(clr);
  618. m_clrBack = clr;
  619. }
  621. pDC->SetBkColor(m_clrBack);
  624. return m_brBack;
  625. }
  627. void CXTPPropertyGridInplaceSlider::OnAdjustValueRect(CRect& rcValue)
  628. {
  629. if (!m_hWnd)
  630. return;
  632. if (m_nWidth > 0)
  633. {
  634. rcValue.right -= m_nWidth;
  635. return;
  636. }
  638. int nWidth = CalcualteEditWidth();
  640. if (rcValue.left + nWidth > rcValue.right)
  641. return;
  643. rcValue.right = rcValue.left + nWidth;
  644. }
  646. void CXTPPropertyGridInplaceSlider::OnValueChanged()
  647. {
  648. int nValue = _ttol(m_pItem->GetValue());
  649. int nValueRange = max(m_nMin, min(m_nMax, nValue));
  651. if (nValueRange != m_nValue || nValueRange != nValue)
  652. {
  653. m_nValue = nValueRange;
  655. CString str;
  656. str.Format(_T("%i"), nValueRange);
  657. m_pItem->SetValue(str);
  659. if (m_hWnd) GetSliderCtrl()->SetPos(m_nValue);
  660. }
  661. }
  663. //////////////////////////////////////////////////////////////////////////
  664. // CXTPPropertyGridInplaceSpinButton
  666. CXTPPropertyGridInplaceSpinButton::CXTPPropertyGridInplaceSpinButton(CXTPPropertyGridItem* pItem)
  667. : CXTPPropertyGridInplaceControl(pItem)
  668. {
  669. m_nMin = 0;
  670. m_nMax = 100;
  671. m_nWidth = GetSystemMetrics(SM_CXVSCROLL);
  674. }
  676. BEGIN_MESSAGE_MAP(CXTPPropertyGridInplaceSpinButton, CXTPPropertyGridInplaceControl)
  677. ON_NOTIFY_REFLECT(UDN_DELTAPOS, OnDeltapos)
  678. END_MESSAGE_MAP()
  680. #define AFX_WNDCOMMCTL_UPDOWN_REG 0x00040
  682. void CXTPPropertyGridInplaceSpinButton::OnCreateWindow(CRect& rcValue)
  683. {
  684. CRect rcButton(rcValue);
  686. rcButton.left = rcButton.right - m_nWidth;
  687. rcValue.right -= m_nWidth;
  689. if (!m_hWnd)
  690. {
  691. VERIFY(AfxDeferRegisterClass(AFX_WNDCOMMCTL_UPDOWN_REG));
  693. Create(UPDOWN_CLASS, NULL, WS_CHILD | UDS_ARROWKEYS, rcButton, (CWnd*)m_pItem->GetGrid(), 0);
  694. }
  696. int nValue = _ttol(m_pItem->GetValue());
  697. GetSpinButtonCtrl()->SetPos(nValue);
  698. GetSpinButtonCtrl()->SendMessage(UDM_SETRANGE32, (WPARAM)m_nMin, (LPARAM)m_nMax);
  699. GetSpinButtonCtrl()->EnableWindow(!m_pItem->GetReadOnly());
  701. MoveWindow(rcButton);
  702. ShowWindow(SW_SHOW);
  703. }
  705. void CXTPPropertyGridInplaceSpinButton::OnDeltapos(NMHDR *pNMHDR, LRESULT *pResult)
  706. {
  707. LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
  709. m_pItem->OnValidateEdit();
  710. long nValue = _ttol(m_pItem->GetValue()) + pNMUpDown->iDelta;
  712. nValue = max(m_nMin, min(m_nMax, nValue));
  714. CString str;
  715. str.Format(_T("%i"), nValue);
  716. m_pItem->OnValueChanged(str);
  718. *pResult = 1;
  719. }
  722. void CXTPPropertyGridInplaceSpinButton::OnAdjustValueRect(CRect& rcValue)
  723. {
  724. if (m_hWnd)
  725. {
  726. rcValue.right -= m_nWidth;
  727. }
  728. }
  730. void CXTPPropertyGridInplaceSpinButton::OnValueChanged()
  731. {
  732. int nValue = _ttol(m_pItem->GetValue());
  733. int nValueRange = max(m_nMin, min(m_nMax, nValue));
  735. if (nValue != nValueRange)
  736. {
  737. CString str;
  738. str.Format(_T("%i"), nValueRange);
  740. m_pItem->SetValue(str);
  741. }
  742. }
  743. //////////////////////////////////////////////////////////////////////////
  744. // CXTPPropertyGridInplaceControls
  747. CXTPPropertyGridInplaceControls::CXTPPropertyGridInplaceControls()
  748. {
  750. }
  752. CXTPPropertyGridInplaceControls::~CXTPPropertyGridInplaceControls()
  753. {
  754. RemoveAll();
  755. }
  757. void CXTPPropertyGridInplaceControls::RemoveAll()
  758. {
  759. for (int i = 0; i < (int)m_arrControls.GetSize(); i++)
  760. {
  761. m_arrControls[i]->InternalRelease();
  762. }
  763. m_arrControls.RemoveAll();
  764. }
  766. int CXTPPropertyGridInplaceControls::GetCount() const
  767. {
  768. return (int)m_arrControls.GetSize();
  769. }
  771. void CXTPPropertyGridInplaceControls::Add(CXTPPropertyGridInplaceControl* pWindow)
  772. {
  773. m_arrControls.Add(pWindow);
  774. }
  776. CXTPPropertyGridInplaceControl* CXTPPropertyGridInplaceControls::GetAt(int nIndex)
  777. {
  778. return m_arrControls[nIndex];
  779. }