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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > ActiveX/DCOM/ATL > 查看源码
PageListCtrl.cpp
资源名称：propgrid.zip　[点击查看]
上传用户：yangzi5763
上传日期：2007-01-02
资源大小：239k
文件大小：35k
源码类别：

ActiveX/DCOM/ATL

开发平台：

Visual C++

PageListCtrl.cpp：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Revision By: Mihai Filimon
  4.   Revised on 10/15/98 9:30:26 AM
  5.   Comments: PageListCtrl.cpp : implementation file
  6.  ************************************/
  8. #include "stdafx.h"
  9. #include "XPropertiesWnd.h"
  10. #include "PageListCtrl.h"
  11. #include "XFloorPropertiesWnd.h"
  12. #include "XPropertiesWndCtl.h"
  13. #include "gdi.h"
  14. #include <afxpriv.h>
  16. #ifdef _DEBUG
  17. #define new DEBUG_NEW
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  24. /////////////////////////////////////////////////////////////////////////////
  25. // CPageListCtrl
  27. IMPLEMENT_DYNCREATE(CPageListCtrl, CListCtrl)
  29. BOOL CPageListCtrl::m_bAutoResizingColumns = TRUE;
  30. CAsControls CPageListCtrl::m_asControls;
  31. COLORREF CPageListCtrl::m_rgbDisableItem = GetSysColor(COLOR_GRAYTEXT);
  32. COLORREF CPageListCtrl::m_rgbEnableItem = RGB(0,0,0);
  33. #define NULLPOINT CPoint(-1,-1)
  35. // Function name : CPageListCtrl::CPageListCtrl
  36. // Description     : Default consturctor
  37. // Return type : 
  38. CPageListCtrl::CPageListCtrl(CXPropertiesWndCtrl* pControl, int nHeight)
  39. {
  40. m_pControl = pControl;
  41. m_nHeight = nHeight;
  42. m_nIndexPage = -1;
  43. m_hIconDown = AfxGetApp()->LoadIcon(IDI_ICON_DOWN);
  44. m_hIconUp = AfxGetApp()->LoadIcon(IDI_ICON_UP);
  45. m_hIconDots = AfxGetApp()->LoadIcon(IDI_ICON_DOTS);
  46. m_hIconReturn = AfxGetApp()->LoadIcon(IDI_ICON_RETURN);
  47. m_hIconLink = AfxGetApp()->LoadIcon(IDI_ICON_LINK);
  48. m_hIconFont = m_hIconDots;
  49. m_hIconClick = AfxGetApp()->LoadIcon(IDI_ICON_CLICK);
  50. m_pEditControl = NULL;
  51. m_nOpenedProperty = -1;
  52. m_ptnCapture = NULLPOINT;
  53. m_nColumnName = -1;
  54. m_nColumnValue = -1;
  55. m_pDrawFont = NULL;
  56. }
  58. // Function name : CPageListCtrl::SetIndexPage
  59. // Description     : Save the window of page into control
  60. // Return type : void 
  61. // Argument         : long nIndexPage
  62. void CPageListCtrl::SetIndexPage(long nIndexPage)
  63. {
  64. m_nIndexPage = nIndexPage;
  65. }
  67. // Function name : CPageListCtrl::GetIndexPage
  68. // Description     : return the index of page
  69. // Return type : const long 
  70. const long CPageListCtrl::GetIndexPage()
  71. {
  72. return m_nIndexPage;
  73. }
  75. // Function name : CPageListCtrl::~CPageListCtrl
  76. // Description     : Virtual Destructor
  77. // Return type : 
  78. CPageListCtrl::~CPageListCtrl()
  79. {
  80. ResetEditControl();
  81. }
  83. BEGIN_MESSAGE_MAP(CPageListCtrl, CListCtrl)
  84. //{{AFX_MSG_MAP(CPageListCtrl)
  85. ON_WM_CREATE()
  86. ON_NOTIFY_REFLECT(LVN_ENDLABELEDIT, OnEndlabeledit)
  87. ON_WM_SIZE()
  88. ON_WM_LBUTTONDOWN()
  89. ON_WM_DRAWITEM_REFLECT()
  90. ON_WM_MEASUREITEM()
  91. ON_NOTIFY_REFLECT(LVN_ITEMCHANGED, OnItemchanged)
  92. ON_WM_KEYDOWN()
  93. ON_WM_LBUTTONDBLCLK()
  94. ON_WM_LBUTTONUP()
  95. ON_WM_MOUSEMOVE()
  96. ON_WM_KILLFOCUS()
  97. ON_NOTIFY_REFLECT(LVN_INSERTITEM, OnInsertitem)
  98. ON_NOTIFY_REFLECT(LVN_ITEMCHANGING, OnItemchanging)
  99. ON_WM_RBUTTONDOWN()
  100. ON_WM_RBUTTONDBLCLK()
  101. ON_WM_SETCURSOR()
  102. ON_NOTIFY_REFLECT(LVN_DELETEITEM, OnDeleteitem)
  103. //}}AFX_MSG_MAP
  104. END_MESSAGE_MAP()
  106. BEGIN_EVENTSINK_MAP( CPageListCtrl, CListCtrl )
  107. ON_EVENT( CPageListCtrl, IDNCOMBOBOX, 2 /*ChangedItem*/, OnChangedItem, VTS_I4)
  108. END_EVENTSINK_MAP()
  110. /////////////////////////////////////////////////////////////////////////////
  111. // CPageListCtrl message handlers
  113. // Function name : CPageListCtrl::OnNew
  114. // Description     : Called after new operator
  115. // Return type : void 
  116. // Argument         : CWnd* pParentWnd
  117. // Argument         : UINT nID
  118. void CPageListCtrl::OnNew(CWnd* pParentWnd, UINT nID)
  119. {
  120. Create(WS_CLIPCHILDREN | WS_CHILD | WS_VISIBLE | LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER | LVS_REPORT | GetDefaultStyle() , CRect(0,0,0,0), pParentWnd, nID);
  121. ListView_SetExtendedListViewStyle(m_hWnd, GetDefaultExStyle());
  122. }
  124. // Function name : CPageListCtrl::GetDefaultStyle
  125. // Description     : Called by void CPageListCtrl::OnNew(CWnd* pParentWnd, UINT nID)
  126. // Return type : const UINT 
  127. const UINT CPageListCtrl::GetDefaultStyle()
  128. {
  129. return LVS_SINGLESEL | LVS_OWNERDRAWFIXED;
  130. }
  132. // Function name : CPageListCtrl::GetDefaultExStyle
  133. // Description     : 
  134. // Return type : const UINT 
  135. const UINT CPageListCtrl::GetDefaultExStyle()
  136. {
  137. return LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES;
  138. }
  140. // Function name : CPageListCtrl::OnCreate
  141. // Description     : Called to Init control 
  142. // Return type : int 
  143. // Argument         : LPCREATESTRUCT lpCreateStruct
  144. int CPageListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  145. {
  146. if (CListCtrl::OnCreate(lpCreateStruct) == -1)
  147. return -1;
  149. if (!OnInit())
  150. {
  151. #ifdef _DEBUG
  152. TRACE0("Warning: Cannot create PageListCtrl.n");
  153. #endif
  155. return -1;
  156. }
  158. return 0;
  159. }
  161. // Function name : CPageListCtrl::OnInit
  162. // Description     : Initilalize the control
  163. // Return type : BOOL 
  164. BOOL CPageListCtrl::OnInit()
  165. {
  166. // Insert two columns for name and value
  167. int i = 0;
  168. while (GetColumn(i++,NULL));
  169. m_nColumnName = InsertColumn(i, _T("Name"), LVCFMT_LEFT, 96);
  170. m_nColumnValue = InsertColumn(i + 1, _T("Value"), LVCFMT_LEFT, 128);
  171. //Create the item font
  172. LOGFONT logFont;
  173. if (::GetObject(GetControlWnd()->m_itemFont.GetFontHandle(), sizeof(LOGFONT), &logFont))
  174. CreateItemFont((const LOGFONT*)&logFont);
  175. //Create the tooltips if neccessarly
  176. if (GetControlWnd()->m_bToolTips)
  177. m_toolTip.Create(this);
  178. return TRUE;
  179. }
  181. // Function name : CPageListCtrl::OnEndlabeledit
  182. // Description     : On EndEdit label
  183. // Return type : void 
  184. // Argument         : NMHDR* pNMHDR
  185. // Argument         : LRESULT* pResult
  186. void CPageListCtrl::OnEndlabeledit(NMHDR* pNMHDR, LRESULT* pResult) 
  187. {
  188. LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
  190. CString item; GetEditControl()->GetWindowText(item);
  191. if (item.IsEmpty())
  192. DeleteItemVrt(pDispInfo->item.iItem);
  193. else
  194. SetItemText(pDispInfo->item.iItem, pDispInfo->item.iSubItem, item);
  196. *pResult = 0;
  197. }
  199. void CPageListCtrl::Save(CString & stream)
  200. {
  201. }
  203. // Function name : CPageListCtrlDesign::Load
  204. // Description     : Call to load items in design/runtime time. Depend on case
  205. // Return type : void 
  206. // Argument         : CString & stream
  207. void CPageListCtrl::Load(CString & stream)
  208. {
  209. if (::IsWindow(m_hWnd))
  210. {
  211. DeleteAll();
  212. CString sItem;
  213. int i = 0;
  214. AfxExtractSubString(sItem, stream, i, _cPagesSeparator);
  215. while (!sItem.IsEmpty())
  216. {
  217. CString sItem0, sItem1, sItem2, sItem3;
  218. AfxExtractSubString(sItem0, sItem, 0, TCHAR('\'));
  219. AfxExtractSubString(sItem1, sItem, 1, TCHAR('\'));
  220. AfxExtractSubString(sItem2, sItem, 2, TCHAR('\'));
  221. AfxExtractSubString(sItem3, sItem, 3, TCHAR('\'));
  222. OnLoad(sItem0, sItem1, sItem2, sItem3);
  223. AfxExtractSubString(sItem, stream, ++i, _cPagesSeparator);
  224. }
  225. }
  226. }
  228. // Function name : CPageListCtrl::OnLoad
  229. // Description     : Called from Load function, to insert a new prop
  230. // Return type : int 
  231. // Argument         : LPCTSTR lpszName
  232. // Argument         : LPCTSTR lpszAs
  233. // Argument         : LPCTSTR lpszType
  234. // Argument         : LPCTSTR lpszGroup
  235. int CPageListCtrl::OnLoad(LPCTSTR lpszName, LPCTSTR lpszAs, LPCTSTR lpszType, LPCTSTR lpszGroup)
  236. {
  237. static const CString enable(_T("Enable"));
  238. static const CString grayed(_T("Grayed"));
  239. int nItem = InsertItemVrt(GetItemCount(), lpszName, MAKELPARAM(m_asControls.GetID(lpszAs), enable.CompareNoCase(lpszType) == 0 ? 0 : (grayed.CompareNoCase(lpszType)) == 0 ? 1 : 2), lpszGroup);
  240. return nItem;
  241. }
  243. // Function name : CPageListCtrl::IsGrayedItem
  244. // Description     : 
  245. // Return type : BOOL 
  246. // Argument         : int nItem
  247. BOOL CPageListCtrl::IsGrayedItem(int nIndex)
  248. {
  249. if (nIndex >= 0)
  250. if (nIndex < GetItemCount())
  251. return HIWORD(GetItemData(nIndex)) == 1;
  252. return FALSE;
  253. }
  255. // Function name : CPageListCtrl::IsBlackItem
  256. // Description     : 
  257. // Return type : BOOL 
  258. // Argument         : int nItem
  259. BOOL CPageListCtrl::IsBlackItem(int nIndex)
  260. {
  261. if (nIndex >= 0)
  262. if (nIndex < GetItemCount())
  263. return HIWORD(GetItemData(nIndex)) == 2;
  264. return NULL;
  265. }
  267. // Function name : CPageListCtrl::IsEnableItem
  268. // Description     : Return TRUE or FALSE case on Enable disable
  269. // Return type : BOOL 
  270. // Argument         : int nIndex
  271. BOOL CPageListCtrl::IsEnableItem(int nIndex)
  272. {
  273. if (nIndex >= 0)
  274. if (nIndex < GetItemCount())
  275. return HIWORD(GetItemData(nIndex)) == 0;
  276. return FALSE;
  277. }
  279. // Function name : CPageListCtrl::IsEditItem
  280. // Description     : Edit Item
  281. // Return type : BOOL 
  282. // Argument         : int nItem
  283. BOOL CPageListCtrl::IsEditItem(int nItem)
  284. {
  285. return CString(GetItemAsControl(nItem)).CompareNoCase(_T("Edit")) == 0;
  286. }
  288. BOOL CPageListCtrl::IsButtonItem(int nItem)
  289. {
  290. return (CString(GetItemAsControl(nItem)).CompareNoCase(_T("Button")) == 0) ||
  291. (CString(GetItemAsControl(nItem)).CompareNoCase(_T("Return")) == 0) || 
  292. (CString(GetItemAsControl(nItem)).CompareNoCase(_T("Link")) == 0) ||
  293. (CString(GetItemAsControl(nItem)).CompareNoCase(_T("Font")) == 0);
  294. }
  296. // Function name : CPageListCtrl::GetItemAsControl
  297. // Description     : Get as string the as of item
  298. // Return type : LPCTSTR 
  299. // Argument         : int nIndex
  300. LPCTSTR CPageListCtrl::GetItemAsControl(int nIndex)
  301. {
  302. if (nIndex >= 0)
  303. if (nIndex < GetItemCount())
  304. return m_asControls.GetName(LOWORD(GetItemData(nIndex)));
  305. return NULL;
  306. }
  308. // Function name : CPageListCtrl::ResizeColumns
  309. // Description     : Resize the last column, such that the sum of widths is equal with width of client rect
  310. // Return type : void 
  311. // Argument         : int cx
  312. // Argument         : int cy
  313. void CPageListCtrl::ResizeColumns()
  314. {
  315. if (m_bAutoResizingColumns)
  316. {
  317. LV_COLUMN lColumn; lColumn.mask = LVCF_WIDTH;
  318. CRect rect; GetClientRect(rect);
  319. if (!rect.IsRectEmpty())
  320. {
  321. if (GetColumn(0,&lColumn))
  322. {
  323. int s = 0, i = 0;
  324. for (i = 0; GetColumn(i, &lColumn); i++, s += lColumn.cx);
  325. i--;
  326. SetColumnWidth(i, abs(rect.Width() - (s - GetColumnWidth(i))));
  327. }
  328. // One penible bug
  329. SendMessage(WM_HSCROLL, MAKEWPARAM( SB_ENDSCROLL, 0), NULL);
  330. }
  331. }
  332. }
  334. // Function name : CPageListCtrl::OnSize
  335. // Description     : On resize control
  336. // Return type : void 
  337. // Argument         : UINT nType
  338. // Argument         : int cx
  339. // Argument         : int cy
  340. void CPageListCtrl::OnSize(UINT nType, int cx, int cy) 
  341. {
  342. CListCtrl::OnSize(nType, cx, cy);
  344. ResizeColumns();
  345. }
  347. // Function name : CPageListCtrl::GetLastRect
  348. // Description     : Return rect of item nItem and subitme nSubItem
  349. // Return type : CRect 
  350. // Argument         : int nItem
  351. // Argument         : int nSubItem
  352. CRect CPageListCtrl::GetLastRect(int nItem)
  353. {
  354. CRect rResult;
  355. GetItemRect(nItem, rResult, LVIR_BOUNDS);
  356. rResult.left = rResult.right - GetColumnWidth(m_nColumnValue);
  357. rResult.OffsetRect(2,0);
  358. return rResult;
  359. }
  361. // Function name : CPageListCtrl::OpenEditing
  362. // Description     : Open editing mode
  363. // Return type : BOOL 
  364. // Argument         : int nItem
  365. // Argument         : CPoint point
  366. BOOL CPageListCtrl::OpenEditing(int nItem, LPARAM lParam)
  367. {
  368. if (IsEnableItem(nItem))
  369. {
  370. if (CreateEditControl(nItem))
  371. {
  372. if (m_nOpenedProperty != nItem)
  373. GetEditingControl()->Load();
  374. m_nOpenedProperty = nItem;
  375. }
  376. else m_nOpenedProperty = -1;
  377. return TRUE;
  378. }
  379. return FALSE;
  380. }
  382. // Function name : CPageListCtrl::GetWindowEditing
  383. // Description     : 
  384. // Return type : CWnd* 
  385. CWnd* CPageListCtrl::GetWindowEditing()
  386. {
  387. if (CControlsWnd* pEditControl = GetEditingControl())
  388. return pEditControl->GetWindow();
  389. return NULL;
  390. }
  392. // Function name : CPageListCtrl::CloseEditing
  393. // Description     : Close editing mode
  394. // Return type : void 
  395. void CPageListCtrl::CloseEditing()
  396. {
  397. }
  399. // Function name : CPageListCtrl::NextItem
  400. // Description     : 
  401. // Return type : void 
  402. // Argument         : int nItem
  403. void CPageListCtrl::NextItem(int nItem)
  404. {
  405. if (IsEnableItem(nItem))
  406. if (CControlsWnd* pEditControl = GetEditingControl())
  407. pEditControl->OnNextItem();
  408. }
  410. // Function name : CPageListCtrl::OnKeyDown
  411. // Description     : Press SPACE, start edit item
  412. // Return type : void 
  413. // Argument         : UINT nChar
  414. // Argument         : UINT nRepCnt
  415. // Argument         : UINT nFlags
  416. void CPageListCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  417. {
  418. switch (nChar)
  419. {
  420. case VK_PRIOR:
  421. case VK_NEXT:
  422. case VK_END:
  423. case VK_HOME:
  424. case VK_LEFT:
  425. case VK_UP:
  426. case VK_RIGHT:
  427. case VK_DOWN:
  428. {
  429. CListCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
  430. break;
  431. }
  432. case VK_DELETE:
  433. {
  434. if (CXPropertiesWndCtrl* pControlWnd = GetControlWnd())
  435. if (CControlsWnd* pEditControl = GetEditingControl())
  436. pControlWnd->FireDelete((short)pEditControl->GetWindowNotify()->m_nIndexPage, (short)pEditControl->GetSelectedItem());
  437. break;
  438. }
  439. default:
  440. {
  441. if (CControlsWnd* pEditControl = GetEditingControl())
  442. {
  443. BOOL bEdit = pEditControl->IsKindOf(RUNTIME_CLASS(CControlsWnd_CEdit));
  444. if (bEdit || ( nChar == VK_F4) || (nChar == VK_RETURN))
  445. {
  446. pEditControl->Show();
  447. if (bEdit)
  448. pEditControl->GetWindow()->PostMessage(WM_KEYDOWN, nChar, nFlags);
  449. }
  450. if (nChar == VK_SPACE)
  451. NextItem(pEditControl->GetSelectedItem());
  452. }
  453. break;
  454. }
  455. }
  456. }
  458. // Function name : CPageListCtrl::OnRButtonDown
  459. // Description     : 
  460. // Return type : void 
  461. // Argument         : UINT nFlags
  462. // Argument         : CPoint point
  463. void CPageListCtrl::OnRButtonDown(UINT nFlags, CPoint point) 
  464. {
  465. }
  467. // Function name : CPageListCtrl::OnRButtonDblClk
  468. // Description     : 
  469. // Return type : void 
  470. // Argument         : UINT nFlags
  471. // Argument         : CPoint point
  472. void CPageListCtrl::OnRButtonDblClk(UINT nFlags, CPoint point) 
  473. {
  474. }
  476. // Function name : CPageListCtrl::CheckEditMode
  477. // Description     : 
  478. // Return type : BOOL 
  479. // Argument         : CPoint point
  480. // Argument         : int nSelected
  481. BOOL CPageListCtrl::CheckEditMode(int nItem, CPoint point, int nSelected)
  482. {
  483. if (nItem>=0)
  484. if (IsEnableItem(nItem))
  485. // In item as edit  control must click twice.
  486. if (IsEditItem(nItem))
  487. return nItem == nSelected;
  488. else
  489. // You must click in button
  490. if (!m_btnRect.IsRectEmpty())
  491. return m_btnRect.PtInRect(point);
  492. return FALSE;
  493. }
  495. // Function name : CPageListCtrl::OnLButtonDblClk
  496. // Description     : If user dblclk the combos move next item
  497. // Return type : void 
  498. // Argument         : UINT nFlags
  499. // Argument         : CPoint point
  500. void CPageListCtrl::OnLButtonDblClk(UINT nFlags, CPoint point) 
  501. {
  502. if ((m_btnRect.IsRectEmpty()) || ((!m_btnRect.IsRectEmpty()) && (!m_btnRect.PtInRect(point))))
  503. {
  504. int nItem = HitTest(point);
  505. if (nItem >= 0)
  506. NextItem(nItem);
  507. }
  508. }
  510. // Function name : CPageListCtrl::DrawButton
  511. // Description     : 
  512. // Return type : void 
  513. // Argument         : CDC * pDC
  514. // Argument         : CRect rB
  515. // Argument         : int nItem
  516. // Argument         : BOOL bClick
  517. void CPageListCtrl::DrawButton(CDC * pDC, CRect rB, int nItem, BOOL bClick)
  518. {
  519. int type = LOWORD(GetItemData(nItem));
  521. if (type != ID_MENUAS_GROUP)
  522. {
  523. CDC* pDCDraw = pDC;
  524. if (!pDC)
  525. pDCDraw = GetDC();
  527. rB.InflateRect(-1,-1);
  528. pDCDraw->FillRect(rB, &CBrush(RGB(192,192,192)));
  529. pDCDraw->DrawEdge(rB, EDGE_RAISED, BF_RECT);
  530. rB.InflateRect(-1,-1);
  532. HICON hIcon = m_hIconDown;
  533. if (IsButtonItem(nItem))
  534. {
  535. switch (type)
  536. {
  537. case ID_MENUAS_BUTTON:
  538. {
  539. hIcon = m_hIconDots;
  540. break;
  541. }
  542. case ID_MENUAS_RETURN:
  543. {
  544. hIcon = m_hIconReturn;
  545. break;
  546. }
  547. case ID_MENUAS_LINK:
  548. {
  549. hIcon = m_hIconLink;
  550. break;
  551. }
  552. case ID_MENUAS_FONT:
  553. {
  554. hIcon = m_hIconFont;
  555. break;
  556. }
  557. }
  559. }
  561. pDCDraw->DrawIcon(rB.left, rB.top, hIcon );
  562. if (bClick)
  563. pDCDraw->DrawIcon(rB.left, rB.top, m_hIconClick);
  565. if (!pDC)
  566. ReleaseDC(pDCDraw);
  567. }
  568. }
  570. #define GetColorItem(sItem) CControlsWnd_CColorComboBox::GetColor(sItem)
  571. #define formatDrawText DT_VCENTER | DT_SINGLELINE | DT_LEFT
  573. // Function name : CPageListCtrl::UserPaint
  574. // Description     : If user want to paint something ...
  575. // Return type : void 
  576. // Argument         : int nItem
  577. // Argument         : CDC * pDC
  578. // Argument         : CRect rect
  579. BOOL CPageListCtrl::UserPaint(int nItem, CDC * pDC, CRect rect)
  580. {
  581. // Type of item is in LOWORD of GetItemData(nItem)
  582. CGdiStack stack;
  583. switch (LOWORD(GetItemData(nItem)))
  584. {
  585. case ID_MENUAS_COLORCOMBOBOX:
  586. {
  587. CRect rColor(rect); rColor.right = rColor.left + rColor.Height();
  588. rect.left = rColor.right + 4;
  589. rColor.InflateRect(-2,-2); rColor.OffsetRect(0,1);
  590. CString sItem = GetItemText(nItem, m_nColumnValue);
  591. pDC->FillRect(rColor, &CBrush(GetColorItem(sItem)));
  592. pDC->FrameRect(rColor, &CBrush(RGB(0,0,0)));
  593. pDC->DrawText(sItem, rect, formatDrawText);
  594. return TRUE;
  595. }
  596. case ID_MENUAS_FONT:
  597. {
  598. if (CControlsWnd_CFont* pFontControl = (CControlsWnd_CFont*)CControlsWnd::LookupControl(this, nItem))
  599. {
  600. CFont font;
  601. LOGFONT logFont;
  602. memcpy(&logFont, pFontControl->GetLogFont(), sizeof(logFont));
  603. logFont.lfHeight = min(rect.Height() - 2, abs(logFont.lfHeight));
  604. font.CreateFontIndirect(&logFont);
  605. stack.Push(pDC, &font);
  606. COLORREF oColor = pDC->SetTextColor(pFontControl->GetColorFont());
  607. pDC->DrawText(GetItemText(nItem, m_nColumnValue), rect, formatDrawText);
  608. pDC->SetTextColor(oColor);
  609. stack.Pop();
  610. font.DeleteObject();
  611. return TRUE;
  612. }
  613. return FALSE;
  614. }
  615. }
  616. return FALSE;
  617. }
  619. // Function name : CPageListCtrl::OnBeginDrawItem
  620. // Description     : 
  621. // Return type : void 
  622. // Argument         :  CDC* pDC
  623. // Argument         : int nItem
  624. // Argument         : LPARAM itemData
  625. void CPageListCtrl::OnBeginDrawItem( CDC* pDC, int nItem, LPARAM itemData )
  626. {
  627. m_pDrawFont = GetControlWnd()->SelectFontObject(pDC, GetControlWnd()->m_itemFont);
  628. }
  630. // Function name : CPageListCtrl::OnEndDrawItem
  631. // Description     : 
  632. // Return type : void 
  633. // Argument         :  CDC* pDC
  634. // Argument         : int nItem
  635. // Argument         : LPARAM itemData
  636. void CPageListCtrl::OnEndDrawItem( CDC* pDC, int nItem, LPARAM itemData)
  637. {
  638. pDC->SelectObject(m_pDrawFont);
  639. }
  641. // Function name : CPageListCtrl::DrawItem
  642. // Description     : 
  643. // Return type : void 
  644. // Argument         : LPDRAWITEMSTRUCT lpDrawItemStruct
  645. void CPageListCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
  646. {
  648. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  650. CRect rectDraw(lpDrawItemStruct->rcItem), rectItem(rectDraw);
  651. int nItem = lpDrawItemStruct->itemID;
  652. CRect rectAll; GetItemRect(nItem, rectAll, LVIR_BOUNDS);
  653. BOOL bFocused = GetFocus() && (GetItemState(nItem, LVIS_FOCUSED) == LVIS_FOCUSED);
  654. BOOL bSelected = GetItemState(nItem, LVIS_SELECTED) == LVIS_SELECTED;
  655. if (bFocused && bSelected) m_btnRect.SetRectEmpty();
  656. BOOL bEnabled = IsEnableItem(nItem);
  657. BOOL bEdit = IsEditItem(nItem);
  658. LV_COLUMN lColumn; lColumn.mask = LVCF_WIDTH;
  659. rectItem.left += 2;
  660. pDC->SetTextColor(bEnabled ? (bSelected & bFocused ? RGB(255,255,255) : m_rgbEnableItem) : (IsGrayedItem(nItem) ? m_rgbDisableItem : RGB(0,0,0)));
  661. CBrush brush(bEnabled & bSelected ? (bFocused ? RGB(0,0,128) : RGB(192,192,192)) : RGB(255,255,255));
  662. pDC->FillRect(rectAll, &CBrush(RGB(255,255,255)));
  664. OnBeginDrawItem( pDC, nItem, lpDrawItemStruct->itemData );
  666. int i = 0;
  667. BOOL bEditMode = IsEditMode() && bFocused;
  668. BOOL bUser = FALSE;
  669. for (i = 0; GetColumn(i, &lColumn); i++, rectItem.left += lColumn.cx + 2)
  670. {
  671. rectItem.right = rectItem.left + lColumn.cx;
  672. if (i == m_nColumnValue)
  673. bUser = UserPaint(nItem, pDC, rectItem);
  674. else
  675. if ( i == m_nColumnName )
  676. {
  677. CRect r(rectItem);
  678. r.OffsetRect(-2,0);r.right -= 2;
  679. pDC->FillRect(r, &brush);
  680. if (bFocused && !bEnabled)
  681. {
  682. r.InflateRect(0,-1);
  683. r.bottom++;
  684. pDC->FrameRect(r, &CBrush(RGB(0,0,0)));
  685. }
  686. }
  687. if (!bUser)
  688. pDC->DrawText(GetItemText(nItem, i), rectItem, formatDrawText);
  689. if ( i == m_nColumnName)
  690. pDC->SetTextColor(!bEditMode ? RGB(0,0,0) : GetControlWnd()->m_rgbEditColor);
  691. }
  693. OnEndDrawItem(pDC, nItem, lpDrawItemStruct->itemData);
  695. pDC->SetTextColor(RGB(0,0,0));
  697. i--;
  698. if (!(bFocused && !bEnabled))
  699. {
  700. if (!bEdit)
  701. if (bFocused && bSelected)
  702. {
  703. CRect rB(rectAll);
  704. rB.top++;
  705. rB.left = rB.right - (GetSystemMetrics(SM_CXHSCROLL) + 2);
  706. if (rB.left < rB.right)
  707. if (rB.Width() < GetColumnWidth(i))
  708. {
  709. m_btnRect = rB;
  710. DrawButton(pDC, m_btnRect, nItem, FALSE);
  711. }
  712. }
  713. }
  714. }
  716. // Function name : CPageListCtrl::OnMeasureItem
  717. // Description     : Measure the item
  718. // Return type : void 
  719. // Argument         : int nIDCtl
  720. // Argument         : LPMEASUREITEMSTRUCT lpMeasureItemStruct
  721. void CPageListCtrl::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
  722. {
  723. ASSERT (nIDCtl == GetDlgCtrlID());
  724. lpMeasureItemStruct->itemHeight = m_nHeight;
  726. CListCtrl::OnMeasureItem(nIDCtl, lpMeasureItemStruct);
  727. }
  729. // Function name : CPageListCtrl::GetControlWnd
  730. // Description     : Return pointer to class tha create this control. In fact * to CXPropertiesWndCtrl
  731. // Return type : CXPropertiesWndCtrl* 
  732. CXPropertiesWndCtrl* CPageListCtrl::GetControlWnd()
  733. {
  734. return m_pControl;
  735. }
  737. // Function name : CPageListCtrl::GetFloorWnd
  738. // Description     : Return pointer to OLE Control xFloorWnd as Window
  739. // Return type : CXFloorPropertiesWnd* 
  740. CXFloorPropertiesWnd* CPageListCtrl::GetFloorWnd()
  741. {
  742. if (GetControlWnd())
  743. return &GetControlWnd()->m_xFloorWnd;
  744. return NULL;
  745. }
  747. // Function name : CPageListCtrl::OnInsertitem
  748. // Description     : Called after insert item
  749. // Return type : void 
  750. // Argument         : NMHDR* pNMHDR
  751. // Argument         : LRESULT* pResult
  752. void CPageListCtrl::OnInsertitem(NMHDR* pNMHDR, LRESULT* pResult) 
  753. {
  754. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  755. /*
  756. if (GetControlWnd())
  757. SetDefaultValue(pNMListView->iItem, GetItemText(pNMListView->iItem, m_nColumnValue));
  758. */
  759. *pResult = 0;
  760. }
  762. // Function name : CPageListCtrl::OnItemchanging
  763. // Description     : 
  764. // Return type : void 
  765. // Argument         : NMHDR* pNMHDR
  766. // Argument         : LRESULT* pResult
  767. void CPageListCtrl::OnItemchanging(NMHDR* pNMHDR, LRESULT* pResult) 
  768. {
  769. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  771. if (CXPropertiesWndCtrl* pControlWnd = GetControlWnd())
  772. {
  773. }
  775. *pResult = 0;
  776. }
  778. // Function name : CPageListCtrl::OnItemchanged
  779. // Description     : Fire to user a event as SelectItem(int nIndexPage, int nIndexItem)
  780. // Return type : void 
  781. // Argument         : NMHDR* pNMHDR
  782. // Argument         : LRESULT* pResult
  783. void CPageListCtrl::OnItemchanged(NMHDR* pNMHDR, LRESULT* pResult) 
  784. {
  785. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  787. // Generate a fire event as user select a item (In fact when, user changes the items, the fire will be auomaticlay generated
  788. if (CXPropertiesWndCtrl* pControlWnd = GetControlWnd())
  789. {
  790. int nPage = GetFloorWnd()->GetActivePage();
  791. if (pNMListView->uNewState & LVIS_SELECTED)
  792. {
  793. ResetEditControl();
  794. pControlWnd->FireSelectItem(nPage ,pNMListView->iItem);
  795. OpenEditing(pNMListView->iItem);
  796. }
  797. else
  798. if (pNMListView->uNewState == 0)
  799. if (pNMListView->uChanged == LVIS_DROPHILITED)
  800. {
  802. if (GetItemState(pNMListView->iItem, LVIS_SELECTED | LVIS_FOCUSED) == 0)
  803. pControlWnd->FireUnselectItem(nPage,pNMListView->iItem);
  804. }
  805. }
  807. *pResult = 0;
  808. }
  810. // Function name : CPageListCtrl::OnKillFocus
  811. // Description     : 
  812. // Return type : void 
  813. // Argument         : CWnd* pNewWnd
  814. void CPageListCtrl::OnKillFocus(CWnd* pNewWnd) 
  815. {
  816. CListCtrl::OnKillFocus(pNewWnd);
  818. if (CControlsWnd* pEditControl = GetEditingControl())
  819. pEditControl->Close(FALSE);
  820. }
  822. // Function name : CPageListCtrl::WindowProc
  823. // Description     : 
  824. // Return type : LRESULT 
  825. // Argument         : UINT message
  826. // Argument         : WPARAM wParam
  827. // Argument         : LPARAM lParam
  828. LRESULT CPageListCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  829. {
  830. switch (message)
  831. {
  832. case WM_KEYDOWN:
  833. case WM_SYSKEYDOWN:
  834. case WM_SYSKEYUP:
  835. case WM_KEYUP:
  836. {
  837. if (IsEditMode())
  838. if (CWnd* pWnd = GetWindowEditing())
  839. return pWnd->SendMessage(message, wParam, lParam);
  840. break;
  841. }
  842. case WM_VSCROLL:
  843. case WM_HSCROLL:
  844. {
  845. ResetEditControl();
  846. break;
  847. }
  848. }
  850. if (::IsWindow(m_toolTip.GetSafeHwnd()))
  851. {
  852. MSG msg = {m_hWnd, message, wParam, lParam};
  853. m_toolTip.RelayEvent(&msg);
  854. }
  856. return CListCtrl::WindowProc(message, wParam, lParam);
  857. }
  859. // Function name : CPageListCtrl::ResetEditControl
  860. // Description     : Is called every time, when you change the current selectio in pagelistctrl
  861. // Return type : void 
  862. void CPageListCtrl::ResetEditControl()
  863. {
  864. if (CControlsWnd* pEditControl = GetEditingControl())
  865. m_pEditControl = pEditControl->Delete();
  866. }
  868. // Function name : CPageListCtrl::CreateEditControl
  869. // Description     : Creae edit control. Not window
  870. // Return type : BOOL 
  871. // Argument         : int nItem
  872. BOOL CPageListCtrl::CreateEditControl(int nItem)
  873. {
  874. if (!GetEditingControl())
  875. m_pEditControl = CControlsWnd::Create(GetItemAsControl(nItem), this, nItem, m_nColumnValue );
  876. return GetEditingControl() != NULL;
  877. }
  879. // Function name : CPageListCtrl::GetPropertyName
  880. // Description     : Return the property name
  881. // Return type : CString 
  882. // Argument         : int nIndexProperty
  883. CString CPageListCtrl::GetPropertyName(int nIndexProperty)
  884. {
  885. return GetItemText(nIndexProperty, m_nColumnName);
  886. }
  888. // Function name : CPageListCtrl::GetDefaultValue
  889. // Description     : Return the default value of property nIndexProperty
  890. // Return type : CString 
  891. // Argument         : int nIndexProperty
  892. const CString CPageListCtrl::GetDefaultValue(int nIndexProperty)
  893. {
  894. return GetItemText(nIndexProperty, m_nColumnValue);
  895. }
  897. // Function name : CPageListCtrl::SetDefaultValue
  898. // Description     : Set default value
  899. // Return type : BOOL 
  900. // Argument         : int nIndexProperty
  901. // Argument         : LPCTSTR lpszdefaultValue
  902. BOOL CPageListCtrl::SetDefaultValue(int nIndexProperty, LPCTSTR lpszdefaultValue)
  903. {
  904. if (nIndexProperty >= 0)
  905. if (nIndexProperty < GetItemCount())
  906. {
  907. CString sValue(lpszdefaultValue);
  908. SetItemText(nIndexProperty, m_nColumnValue, sValue.IsEmpty() ? (LPCTSTR)NULL : (LPCTSTR)sValue);
  909. return TRUE;
  910. }
  911. return FALSE;
  912. }
  914. // Function name : CPageListCtrl::SetPropertyName
  915. // Description     : Set the property Name
  916. // Return type : void 
  917. // Argument         : int nIndexProperty
  918. // Argument         : LPCTSTR lpszPropertyName
  919. void CPageListCtrl::SetPropertyName(int nIndexProperty, LPCTSTR lpszPropertyName)
  920. {
  921. if (nIndexProperty >= 0)
  922. if (nIndexProperty < GetItemCount())
  923. SetItemText(nIndexProperty, 0, lpszPropertyName);
  924. }
  926. // Function name : CPageListCtrl::GetActiveProperty
  927. // Description     : return the active property
  928. // Return type : int 
  929. int CPageListCtrl::GetActiveProperty()
  930. {
  931. return GetNextItem(-1, LVNI_SELECTED);
  932. }
  934. // Function name : CPageListCtrl::SetActiveProperty
  935. // Description     : Set the active property
  936. // Return type : void 
  937. // Argument         : int nIndexProperty
  938. void CPageListCtrl::SetActiveProperty(int nIndexProperty)
  939. {
  940. SetItemState(nIndexProperty, LVNI_SELECTED , LVNI_SELECTED);
  941. }
  943. BOOL CPageListCtrl::PreTranslateMessage(MSG* pMsg) 
  944. {
  945. // TODO: Add your specialized code here and/or call the base class
  947. return CListCtrl::PreTranslateMessage(pMsg);
  948. }
  950. // Function name : CPageListCtrl::CreateItemFont
  951. // Description     : Create a font for items
  952. // Return type : BOOL 
  953. // Argument         : const LOGFONT * pLogFont
  954. BOOL CPageListCtrl::CreateItemFont(const LOGFONT * pLogFont)
  955. {
  956. m_itemFont.DeleteObject();
  957. return m_itemFont.CreateFontIndirect(pLogFont);
  958. }
  960. // Function name : CPageListCtrl::IsEditMode
  961. // Description     : return TRUE if is edit mode
  962. // Return type : BOOL 
  963. BOOL CPageListCtrl::IsEditMode()
  964. {
  965. if (CControlsWnd* pEditControl = GetEditingControl())
  966. return pEditControl->IsVisible();
  967. return FALSE;
  968. }
  970. // Function name : CPageListCtrl::GetControl
  971. // Description     : Return the control from nIndex item.
  972. // Return type : CControlsWnd* 
  973. // Argument         : int nIndex
  974. CControlsWnd* CPageListCtrl::GetControl(int nIndex, BOOL bDelete)
  975. {
  976. // We will try to create and then delete one control. In this way, I will
  977. // find if the control is destroyble or not.
  978. if (CControlsWnd* pControl = CControlsWnd::Create(GetItemAsControl(nIndex), this, nIndex, m_nColumnValue))
  979. if (bDelete)
  980. {
  981. pControl->Delete();
  982. // Check if after Delete function the pControl has a valid vTable or not
  983. // If it is valid, that means that this object is either CControlsWnd_CADORComboBox or ...
  984. // a control non delete.
  985. if (AfxIsValidAddress(*(void**)pControl, sizeof(void*), FALSE))
  986. return pControl;
  987. }
  988. else
  989. return pControl;
  990. return NULL;
  991. }
  993. // Function name : CPageListCtrl::OnSetCursor
  994. // Description     : 
  995. // Return type : BOOL 
  996. // Argument         : CWnd* pWnd
  997. // Argument         : UINT nHitTest
  998. // Argument         : UINT message
  999. BOOL CPageListCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1000. {
  1001. if (IsSizingLine())
  1002. {
  1003. ::SetCursor(AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(IDC_SIZEWE)));
  1004. return TRUE;
  1005. }
  1007. return CListCtrl::OnSetCursor(pWnd, nHitTest, message);
  1008. }
  1010. // Function name : CPageListCtrl::IsSizingLine
  1011. // Description     : Return TRUE if mouse point is over the first right side of first column
  1012. // Return type : BOOL 
  1013. BOOL CPageListCtrl::IsSizingLine()
  1014. {
  1015. if (m_bAutoResizingColumns)
  1016. if (GetControlWnd()->m_bResizeFirstColumn) 
  1017. {
  1018. DWORD lPoint = ::GetMessagePos();
  1019. CPoint p(LOWORD(lPoint), HIWORD(lPoint));
  1020. ScreenToClient(&p);
  1021. CRect rect; GetClientRect(rect);
  1022. int i = -1, x = 0;
  1023. while ( ++i <= m_nColumnName ) x += GetColumnWidth(i);
  1024. rect.left = x - 2;
  1025. rect.right = x + 2;
  1026. return rect.PtInRect(p);
  1027. }
  1028. return FALSE;
  1029. }
  1031. // Function name : CPageListCtrl::OnLButtonDown
  1032. // Description     : User click mouse in runtime time
  1033. // Return type : void 
  1034. // Argument         : UINT nFlags
  1035. // Argument         : CPoint point
  1036. void CPageListCtrl::OnLButtonDown(UINT nFlags, CPoint point) 
  1037. {
  1038. SetFocus();
  1040. if (IsSizingLine())
  1041. {
  1042. ResetEditControl();
  1043. SetCapture();
  1044. m_ptnCapture = point;
  1045. return;
  1046. }
  1047. // continue the operation ...
  1048. m_nSelected = GetActiveProperty();
  1049. int nItem = HitTest(point);
  1050. if (nItem >= 0)
  1051. {
  1052. SetItemState(nItem, LVNI_SELECTED | LVNI_FOCUSED, LVNI_FOCUSED | LVNI_SELECTED);
  1053. EnsureVisible(nItem, FALSE);
  1054. }
  1055. }
  1057. // Function name : CPageListCtrl::IsMouseCaptured
  1058. // Description     : 
  1059. // Return type : BOOL 
  1060. BOOL CPageListCtrl::IsMouseCaptured()
  1061. {
  1062. return m_ptnCapture != NULLPOINT;
  1063. }
  1065. // Function name : CPageListCtrl::InvalidateNew
  1066. // Description     : 
  1067. // Return type : void 
  1068. void CPageListCtrl::InvalidateNew()
  1069. {
  1070. if (CBitmap* pBitmap = Preview(this, RGB(255,255,255)))
  1071. {
  1072. CGdiStack stack;
  1073. CDC* pDC = GetDC();
  1074. CDC dcMem;
  1075. CRect rect; GetClientRect(rect);
  1076. if (dcMem.CreateCompatibleDC(pDC))
  1077. {
  1078. stack.Push(&dcMem, pBitmap);
  1079. pDC->BitBlt(0,0,rect.Width(),rect.Height(),&dcMem, 0,0, SRCCOPY);
  1080. stack.Pop();
  1081. }
  1082. ReleaseDC(pDC);
  1083. pBitmap->DeleteObject();
  1084. delete pBitmap;
  1085. }
  1086. else Invalidate();
  1087. }
  1089. // Function name : CPageListCtrl::OnMouseMove
  1090. // Description     : 
  1091. // Return type : void 
  1092. // Argument         : UINT nFlags
  1093. // Argument         : CPoint point
  1094. void CPageListCtrl::OnMouseMove(UINT nFlags, CPoint point) 
  1095. {
  1096. if (IsMouseCaptured())
  1097. {
  1098. CRect rect; GetClientRect(rect);
  1099. int rMin = rect.Width() / 6, rMax = rect.Width() - rMin;
  1100. int newWidth = GetColumnWidth( m_nColumnName ) + ( point.x - m_ptnCapture.x );
  1101. if ((newWidth >= rMin) && (newWidth <= rMax))
  1102. {
  1103. ModifyStyle(WS_VISIBLE, 0, SWP_NOREDRAW);
  1104. SetColumnWidth(m_nColumnName, newWidth );
  1105. ResizeColumns();
  1106. ModifyStyle(0, WS_VISIBLE, SWP_NOREDRAW);
  1107. InvalidateNew();
  1108. m_ptnCapture = point;
  1109. }
  1110. }
  1111. CListCtrl::OnMouseMove(nFlags, point);
  1112. }
  1114. // Function name : CPageListCtrl::OnLButtonUp
  1115. // Description     : 
  1116. // Return type : void 
  1117. // Argument         : UINT nFlags
  1118. // Argument         : CPoint point
  1119. void CPageListCtrl::OnLButtonUp(UINT nFlags, CPoint point) 
  1120. {
  1121. CListCtrl::OnLButtonUp(nFlags, point);
  1123. int nItem = HitTest(point);
  1124. if (IsMouseCaptured()) // is mouse captured
  1125. {
  1126. ReleaseCapture();
  1127. m_ptnCapture = NULLPOINT;
  1128. CreateEditControl(nItem);
  1129. }
  1131. if (CControlsWnd* pEditControl = GetEditingControl())
  1132. {
  1133. if (CheckEditMode(nItem, point, m_nSelected))
  1134. {
  1135. EnsureVisible(nItem, TRUE);
  1136. pEditControl->Show();
  1137. }
  1138. }
  1139. }
  1141. // Function name : CPageListCtrl::OnDeleteitem
  1142. // Description     : 
  1143. // Return type : void 
  1144. // Argument         : NMHDR* pNMHDR
  1145. // Argument         : LRESULT* pResult
  1146. void CPageListCtrl::OnDeleteitem(NMHDR* pNMHDR, LRESULT* pResult) 
  1147. {
  1148. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  1150. *pResult = 0;
  1151. }
  1153. // Function name : CPageListCtrl::OnFontChanged
  1154. // Description     : Called when font is changed
  1155. // Return type : void 
  1156. void CPageListCtrl::OnFontChanged()
  1157. {
  1158. // do nothing
  1159. }
  1161. // Function name : CPageListCtrl::InsertItemVrt
  1162. // Description     : Called when new property is added into control
  1163. // Return type : int 
  1164. // Argument         : int nItem
  1165. // Argument         : LPCTSTR lpszItemName
  1166. // Argument         : LPARAM lParam
  1167. // Description lParam parameter: MAKELPARAM(asControl, asType)
  1168. int CPageListCtrl::InsertItemVrt(int nItem, LPCTSTR lpszItemName, LPARAM lParam, LPCTSTR lpszGroup)
  1169. {
  1170. // Just insert into list control
  1171. int nResult = InsertItem(nItem, _T(""));
  1172. if (nResult >= 0)
  1173. {
  1174. SetItemText(nResult, m_nColumnName, lpszItemName);
  1175. SetItemData(nResult, lParam);
  1176. }
  1177. return nResult;
  1178. }
  1180. // Function name : CPageListCtrl::DeleteItemVrt
  1181. // Description     : Called when one property need to be deleted
  1182. // Return type : BOOL 
  1183. // Argument         : int nItem
  1184. BOOL CPageListCtrl::DeleteItemVrt(int nItem)
  1185. {
  1186. return DeleteItem(nItem);
  1187. }
  1189. // Function name : CPageListCtrl::Expand
  1190. // Description     : Do nothing
  1191. // Return type : void 
  1192. // Argument         : int nItem
  1193. // Argument         : BOOL &bExppanded
  1194. void CPageListCtrl::Expand(int nItem, BOOL &bExppanded)
  1195. {
  1196. }
  1198. // Function name : CPageListCtrl::GetEditingControl
  1199. // Description     : Return the editing control.
  1200. // Return type : CControlsWnd* 
  1201. CControlsWnd* CPageListCtrl::GetEditingControl()
  1202. {
  1203. if (m_pEditControl)
  1204. if (AfxIsValidAddress(*(void**)&*m_pEditControl, sizeof(void*), FALSE))
  1205. return m_pEditControl;
  1206. return NULL;
  1207. }
  1209. // Function name : CPageListCtrl::DeleteAll
  1210. // Description     : 
  1211. // Return type : void 
  1212. void CPageListCtrl::DeleteAll()
  1213. {
  1214. DeleteAllItems();
  1215. }
  1217. // Function name : CPageListCtrl::OnChangedItem
  1218. // Description     : Called by one NCombo when selection is changed into control
  1219. // We will propagate the seelction throw the my controls.
  1220. // Return type : void 
  1221. // Argument         : long nItem
  1222. void CPageListCtrl::OnChangedItem(long nItem)
  1223. {
  1224. if (CControlsWnd* pControl = GetEditingControl())
  1225. if (pControl->IsKindOf(RUNTIME_CLASS(CControlsWnd_CNComboBox)))
  1226. {
  1227. CString sItem;
  1228. pControl->OnSelectItem(sItem, nItem);
  1229. }
  1230. }