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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > ListView/ListBox > 查看源码
ListCtrlEx.cpp
资源名称：CListCtrlExDemo.zip　[点击查看]
上传用户：zhouyunkk
上传日期：2022-07-16
资源大小：98k
文件大小：29k
源码类别：

ListView/ListBox

开发平台：

Visual C++

ListCtrlEx.cpp：源码内容
  1. // ListCtrlEx.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "ListCtrlEx.h"
  8. CListCtrlEx::EditorInfo::EditorInfo()
  9. :m_pfnInitEditor(NULL)
  10. ,m_pfnEndEditor(NULL)
  11. ,m_pWnd(NULL)
  12. ,m_bReadOnly(false)
  13. {
  14. }
  15. CListCtrlEx::EditorInfo::EditorInfo(PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd *pWnd)
  16. :m_pfnInitEditor(pfnInitEditor)
  17. ,m_pfnEndEditor(pfnEndEditor)
  18. ,m_pWnd(pWnd)
  19. ,m_bReadOnly(false)
  20. {
  21. }
  23. CListCtrlEx::CellInfo::CellInfo(int nColumn)
  24. :m_clrBack(-1)
  25. ,m_clrText(-1)
  26. ,m_dwUserData(NULL)
  27. ,m_nColumn(nColumn)
  28. {
  30. }
  31. CListCtrlEx::CellInfo::CellInfo(int nColumn, COLORREF clrBack, COLORREF clrText, DWORD_PTR dwUserData)
  32. :m_clrBack(clrBack)
  33. ,m_clrText(clrText)
  34. ,m_dwUserData(dwUserData)
  35. ,m_nColumn(nColumn)
  36. {
  37. }
  38. CListCtrlEx::CellInfo::CellInfo(int nColumn, EditorInfo eiEditor, COLORREF clrBack, COLORREF clrText, DWORD_PTR dwUserData)
  39. :m_clrBack(clrBack)
  40. ,m_clrText(clrText)
  41. ,m_dwUserData(dwUserData)
  42. ,m_eiEditor(eiEditor)
  43. ,m_nColumn(nColumn)
  44. {
  45. }
  46. CListCtrlEx::CellInfo::CellInfo(int nColumn, EditorInfo eiEditor, DWORD_PTR dwUserData)
  47. :m_clrBack(-1)
  48. ,m_clrText(-1)
  49. ,m_dwUserData(dwUserData)
  50. ,m_eiEditor(eiEditor)
  51. ,m_nColumn(nColumn)
  52. {
  53. }
  55. CListCtrlEx::ColumnInfo::ColumnInfo(int nColumn)
  56. :m_eiEditor()
  57. ,m_clrBack(-1)
  58. ,m_clrText(-1)
  59. ,m_nColumn(nColumn)
  60. ,m_eSort(None)
  61. ,m_eCompare(NotSet)
  62. ,m_fnCompare(NULL)
  63. {
  64. }
  65. CListCtrlEx::ColumnInfo::ColumnInfo(int nColumn, PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd *pWnd)
  66. :m_eiEditor(pfnInitEditor, pfnEndEditor, pWnd)
  67. ,m_nColumn(nColumn)
  68. ,m_clrBack(-1)
  69. ,m_clrText(-1)
  70. ,m_eSort(None)
  71. ,m_eCompare(NotSet)
  72. ,m_fnCompare(NULL)
  73. {
  74. }
  75. CListCtrlEx::ItemData::ItemData(DWORD_PTR dwUserData)
  76. :m_clrBack(0xFFFFFFFF)
  77. ,m_clrText(0xFFFFFFFF)
  78. ,m_dwUserData(dwUserData)
  79. {
  80. }
  81. CListCtrlEx::ItemData::ItemData(COLORREF clrBack, COLORREF clrText, DWORD_PTR dwUserData)
  82. :m_clrBack(clrBack)
  83. ,m_clrText(clrText)
  84. ,m_dwUserData(dwUserData)
  85. {
  86. }
  87. CListCtrlEx::ItemData::~ItemData()
  88. {
  89. while(m_aCellInfo.GetCount()>0)
  90. {
  91. CellInfo *pInfo = (CellInfo*)m_aCellInfo.GetAt(0);
  92. m_aCellInfo.RemoveAt(0);
  93. delete pInfo;
  94. }
  95. }
  96. // CListCtrlEx
  98. IMPLEMENT_DYNAMIC(CListCtrlEx, CListCtrl)
  100. CListCtrlEx::CListCtrlEx()
  101. :m_pEditor(NULL)
  102. ,m_nEditingRow(-1)
  103. ,m_nEditingColumn(-1)
  104. ,m_msgHook()
  105. ,m_nRow(-1)
  106. ,m_nColumn(-1)
  107. ,m_bHandleDelete(FALSE)
  108. ,m_nSortColumn(-1)
  109. ,m_fnCompare(NULL)
  110. ,m_hAccel(NULL)
  111. ,m_dwSortData(NULL)
  112. , m_bInvokeAddNew(FALSE)
  113. {
  114. #ifndef _WIN32_WCE
  115. EnableActiveAccessibility();
  116. #endif
  118. }
  119. #define ID_EDITOR_CTRL 5000
  120. CListCtrlEx::~CListCtrlEx()
  121. {
  122. DeleteAllItemsData();
  123. DeleteAllColumnInfo();
  124. }
  127. BEGIN_MESSAGE_MAP(CListCtrlEx, CListCtrl)
  128. ON_NOTIFY_REFLECT_EX(NM_DBLCLK, &CListCtrlEx::OnNMDblclk)
  129. ON_NOTIFY_REFLECT_EX(NM_CUSTOMDRAW, &CListCtrlEx::OnNMCustomdraw)
  130. ON_NOTIFY_REFLECT(LVN_COLUMNCLICK, &CListCtrlEx::OnHdnItemclick)
  131. END_MESSAGE_MAP()
  135. // CListCtrlEx message handlers
  138. // Retrieves the data (lParam) associated with a particular item.
  139. DWORD_PTR CListCtrlEx::GetItemData(int nItem) const
  140. {
  142. ItemData* pData = (ItemData*)GetItemDataInternal(nItem);
  143. if(!pData) return NULL;
  144. return pData->m_dwUserData;
  145. }
  146. // Retrieves the data (lParam) associated with a particular item.
  147. DWORD_PTR CListCtrlEx::GetItemDataInternal(int nItem) const
  148. {
  149. return CListCtrl::GetItemData(nItem);
  150. }
  151. int CListCtrlEx::InsertItem(int nItem, LPCTSTR lpszItem)
  152. {
  153. int ret = CListCtrl::InsertItem(nItem, lpszItem);
  154. SetItemData(ret, 0);
  155. return ret;
  156. }
  157. int CListCtrlEx::InsertItem(int nItem, LPCTSTR lpszItem, int nImage)
  158. {
  159. int ret = CListCtrl::InsertItem(nItem, lpszItem, nImage);
  160. SetItemData(ret, 0);
  161. return ret;
  162. }
  163. int CListCtrlEx::InsertItem(const LVITEM* pItem)
  164. {
  165. int ret = 0;
  166. LVITEM pI = *pItem;
  167. if(pItem && (pItem->mask & LVIF_PARAM))
  168. {
  169. pI.mask &= (~LVIF_PARAM);
  170. }
  171. ret = CListCtrl::InsertItem(&pI);
  172. SetItemData(ret, pItem->lParam);
  173. return ret;
  174. }
  175. // Sets the data (lParam) associated with a particular item.
  176. BOOL CListCtrlEx::SetItemData(int nItem, DWORD_PTR dwData)
  177. {
  178. ItemData* pData = (ItemData*)GetItemDataInternal(nItem);
  179. if(!pData)
  180. {
  181. pData = new ItemData(dwData);
  182. m_aItemData.Add(pData);
  183. }
  184. else
  185. pData->m_dwUserData = dwData;
  186. return CListCtrl::SetItemData(nItem, (DWORD_PTR)pData);
  187. }
  189. // Removes a single item from the control.
  190. BOOL CListCtrlEx::DeleteItem(int nItem)
  191. {
  192. DeleteItemData(nItem);
  193. return CListCtrl::DeleteItem(nItem);
  194. }
  195. // Removes all items from the control.
  196. BOOL CListCtrlEx::DeleteAllItems()
  197. {
  198. int nCount = this->GetItemCount();
  199. DeleteAllItemsData();
  200. return CListCtrl::DeleteAllItems();
  201. }
  202. BOOL CListCtrlEx::DeleteAllItemsData( )
  203. {
  204. while(m_aItemData.GetCount()>0)
  205. {
  206. ItemData* pData = (ItemData*)m_aItemData.GetAt(0);
  207. if(pData) delete pData;
  208. m_aItemData.RemoveAt(0);
  209. }
  211. return TRUE;
  212. }
  213. BOOL CListCtrlEx::DeleteItemData(int nItem)
  214. {
  215. if(nItem < 0 || nItem > GetItemCount()) return FALSE;
  216. ItemData* pData = (ItemData*)CListCtrl::GetItemData(nItem);
  218. INT_PTR nCount = m_aItemData.GetCount();
  219. for(INT_PTR i = 0; i < nCount && pData; i++)
  220. {
  221. if(m_aItemData.GetAt(i) == pData)
  222. {
  223. m_aItemData.RemoveAt(i);
  224. break;
  225. }
  226. }
  228. if(pData) delete pData;
  230. return TRUE;
  231. }
  232. BOOL CListCtrlEx::DeleteAllColumnInfo( )
  233. {
  234. while(m_aColumnInfo.GetCount()>0)
  235. {
  236. ColumnInfo* pData = (ColumnInfo*)m_aColumnInfo.GetAt(0);
  237. if(pData) delete pData;
  238. m_aColumnInfo.RemoveAt(0);
  239. }
  241. return TRUE;
  242. }
  243. BOOL CListCtrlEx::DeleteColumnInfo(int nColumn)
  244. {
  245. if(nColumn < 0 || nColumn > GetColumnCount()) return FALSE;
  246. ColumnInfo* pData = (ColumnInfo*)GetColumnInfo(nColumn);
  248. INT_PTR nCount = m_aColumnInfo.GetCount();
  249. for(INT_PTR i = 0; i < nCount && pData; i++)
  250. {
  251. if(m_aColumnInfo.GetAt(i) == pData)
  252. {
  253. m_aColumnInfo.RemoveAt(i);
  254. break;
  255. }
  256. }
  258. if(pData) delete pData;
  260. return TRUE;
  261. }
  263. void CListCtrlEx::SetColumnEditor(int nColumn, PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd* pWnd)
  264. {
  265. ColumnInfo* pColInfo = GetColumnInfo(nColumn);
  266. if(!pColInfo)
  267. { 
  268. pColInfo = new ColumnInfo(nColumn);  
  269. m_aColumnInfo.Add(pColInfo);
  270. }
  271. pColInfo->m_eiEditor.m_pfnInitEditor = pfnInitEditor;
  272. pColInfo->m_eiEditor.m_pfnEndEditor = pfnEndEditor;
  273. pColInfo->m_eiEditor.m_pWnd = pWnd;
  275. }
  277. void CListCtrlEx::SetColumnEditor(int nColumn, CWnd* pWnd)
  278. {
  279. SetColumnEditor(nColumn, NULL, NULL, pWnd);
  280. }
  281. void CListCtrlEx::SetRowEditor(int nRow, CWnd* pWnd)
  282. {
  283. SetRowEditor(nRow, NULL, NULL, pWnd);
  284. }
  285. void CListCtrlEx::SetRowEditor(int nRow, PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd* pWnd)
  286. {
  287. ItemData* pData = (ItemData*)GetItemDataInternal(nRow);
  288. if(!pData)
  289. { 
  290. SetItemData(nRow, 0);
  291. pData = (ItemData*)GetItemDataInternal(nRow);
  292. }
  293. pData->m_eiEditor.m_pfnInitEditor = pfnInitEditor;
  294. pData->m_eiEditor.m_pfnEndEditor = pfnEndEditor;
  295. pData->m_eiEditor.m_pWnd = pWnd;
  297. }
  299. CListCtrlEx::ColumnInfo* CListCtrlEx::GetColumnInfo(int nColumn)
  300. {
  301. INT_PTR nCount = m_aColumnInfo.GetCount();
  302. for(INT_PTR i = 0; i < nCount; i++)
  303. {
  304. ColumnInfo* pColInfo = (ColumnInfo*)m_aColumnInfo.GetAt(i);
  305. if(pColInfo->m_nColumn == nColumn) return pColInfo;
  306. }
  307. return NULL;
  308. }
  309. int CListCtrlEx::FindItem(LVFINDINFO* pFindInfo, int nStart ) const
  310. {
  311. if(pFindInfo->flags & LVIF_PARAM)
  312. {
  313. int nCount = GetItemCount();
  314. for(int i = nStart+1; i < nCount; i++)
  315. {
  316. if(pFindInfo->lParam == GetItemData(i)) return i;
  317. }
  318. return -1;
  319. }
  320. else
  321. {
  322. return CListCtrl::FindItem(pFindInfo, nStart);
  323. }
  324. }
  325. int CListCtrlEx::GetItemIndexFromData(DWORD_PTR dwData)
  326. {
  327. LVFINDINFO find;
  328. find.flags = LVFI_PARAM;
  329. find.lParam = dwData;
  330. return CListCtrl::FindItem(&find);
  331. }
  332. int CALLBACK CListCtrlEx::CompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  333. {
  334. CListCtrlEx *This = reinterpret_cast<CListCtrlEx*>(lParamSort);
  335. ColumnInfo *pColInfo;
  336. int nSort = 0;
  337. int nCompare = 0;
  339. if(!This) return 0;
  340. if(!(This->m_nSortColumn < 0 || This->m_nSortColumn >= This->GetColumnCount()) )
  341. {
  342. pColInfo = This->GetColumnInfo(This->m_nSortColumn);
  343. if(pColInfo && (pColInfo->m_eSort & SortBits)) 
  344. {
  345. nSort = pColInfo->m_eSort & Ascending ? 1: -1 ;
  346. if(!This->m_fnCompare && pColInfo->m_fnCompare) This->m_fnCompare = pColInfo->m_fnCompare;
  347. }
  348. }
  349. if(This->m_fnCompare && This->m_fnCompare != &CListCtrlEx::CompareProc) 
  350. {
  351. ItemData *pD1 = reinterpret_cast<ItemData*>(lParam1);
  352. ItemData *pD2 = reinterpret_cast<ItemData*>(lParam2);
  353. if(pD1) lParam1 = pD1->m_dwUserData;
  354. if(pD2) lParam2 = pD2->m_dwUserData;
  355. nCompare = This->m_fnCompare(lParam1, lParam2, This->m_dwSortData?This->m_dwSortData:This->m_nSortColumn);
  356. if(!This->m_dwSortData && nSort) 
  357. {
  358. return nCompare * nSort;
  359. }
  360. }
  361. if(!nSort) return 0;
  363. int nLeft = This->GetItemIndexFromData(lParam1); 
  364. int nRight = This->GetItemIndexFromData(lParam2);
  366. if(nLeft < 0) nLeft = lParam1;
  367. if(nRight < 0) nRight = lParam2;
  368. int nCount = This->GetItemCount();
  369. if(nLeft < 0 || nRight < 0 || nLeft >= nCount || nRight >= nCount) return 0;
  370. nCompare = Compare(nLeft, nRight, lParamSort);
  371. return (nCompare * nSort);
  372. }
  373. void CListCtrlEx::OnHdnItemclick(NMHDR *pNMHDR, LRESULT *pResult)
  374. {
  375. NM_LISTVIEW*  phdr = reinterpret_cast<NM_LISTVIEW*>(pNMHDR);
  376. SortOnColumn(phdr->iSubItem, TRUE);
  377. *pResult = 0;
  378. //return FALSE;
  379. }
  380. BOOL CListCtrlEx::SortItems(PFNLVCOMPARE pfnCompare, DWORD_PTR dwData)
  381. {
  382. int nCount = GetItemCount();
  383. DWORD_PTR dwEditingItemData = 0;
  384. if(m_nEditingRow >= 0 && m_nEditingRow < nCount)
  385.  dwEditingItemData = GetItemDataInternal(m_nEditingRow);
  386. CString dbg;
  387. dbg.Format("nBefore : %d", m_nEditingRow);
  388. OutputDebugString(dbg);
  389. m_fnCompare = pfnCompare;
  390. m_dwSortData = dwData;
  391. BOOL ret = CListCtrl::SortItems(CompareProc, (DWORD_PTR)this);
  392. m_fnCompare = NULL;
  393. m_dwSortData = NULL;
  394. if(dwEditingItemData) 
  395. m_nEditingRow = GetItemIndexFromData(dwEditingItemData);
  397. dbg.Format("nAfter : %d", m_nEditingRow);
  398. OutputDebugString(dbg);
  399. return ret;
  400. }
  402. BOOL CListCtrlEx::SortOnColumn(int nColumn, BOOL bChangeOrder)
  403. {
  404. ColumnInfo *pColInfo;
  405. if((pColInfo = GetColumnInfo(nColumn)) && (pColInfo->m_eSort & SortBits ))
  406. {
  407. if(pColInfo->m_eSort & Auto)
  408. {
  409. pColInfo->m_eSort =(Sort)((pColInfo->m_eSort & (Ascending | Descending)) ? pColInfo->m_eSort : pColInfo->m_eSort | Descending);
  410. if(bChangeOrder) pColInfo->m_eSort = (Sort)(pColInfo->m_eSort ^ (Ascending | Descending));
  411. }
  412. CHeaderCtrl *pHdr = this->GetHeaderCtrl();
  413. HDITEM hd;
  414. hd.mask = HDI_FORMAT;
  415. if(pHdr)
  416. {
  417. pHdr->GetItem(m_nSortColumn, &hd);
  418. hd.fmt = hd.fmt & ~(HDF_SORTDOWN|HDF_SORTUP);
  419. pHdr->SetItem(m_nSortColumn, &hd);
  420. }
  421. m_nSortColumn = nColumn;
  422. CListCtrl::SortItems(CompareProc, (DWORD_PTR)this);
  423. if(pHdr)
  424. {
  425. pHdr->GetItem(nColumn, &hd);
  426. hd.fmt = hd.fmt & ~(HDF_SORTDOWN|HDF_SORTUP);
  427. hd.fmt |= pColInfo->m_eSort & Ascending ? HDF_SORTUP : HDF_SORTDOWN;
  428. pHdr->SetItem(nColumn, &hd);
  429. }
  430. return TRUE;
  431. }
  432. return FALSE;
  433. }
  435. BOOL CListCtrlEx::OnNMDblclk(NMHDR *pNMHDR, LRESULT *pResult)
  436. {
  437. NM_LISTVIEW *pNMListView = (NM_LISTVIEW *)pNMHDR;
  438. if(!pNMListView) return FALSE;
  439. int nItem = pNMListView->iItem, nSubItem = pNMListView->iSubItem;
  441. *pResult = DisplayEditor(nItem, nSubItem);
  443. return *pResult;
  444. }
  446. BOOL CListCtrlEx::EnsureSubItemVisible(int nItem, int nSubItem, CRect *pRect)
  447. {
  448. BOOL ret = EnsureVisible(nItem, FALSE);
  449. CRect rect;
  450. GetSubItemRect(nItem, nSubItem, LVIR_LABEL, rect);
  451. CRect rtList;
  452. GetClientRect(&rtList);
  453. if(rect.right > rtList.Width()) Scroll(CSize( rect.Width() > rtList.Width()?rect.left : rect.right - rtList.Width(), 0));
  454. if(rect.left < 0) Scroll(CSize(rect.left));
  455. if(pRect)
  456. {
  457. GetSubItemRect(nItem, nSubItem, LVIR_LABEL, rect);
  458. rect.right = min(rect.right, rtList.Width()-4);
  459. *pRect = rect;
  460. }
  461. return ret;
  462. }
  463. BOOL CListCtrlEx::DisplayEditor(int nItem, int nSubItem)
  464. {
  465. int nCount = GetItemCount();
  466. DWORD_PTR dwEditingItemData = 0;
  467. if(nItem >= 0 && nItem < nCount)
  468.  dwEditingItemData = GetItemDataInternal(nItem);
  469. HideEditor();
  470. if(dwEditingItemData) 
  471. nItem = GetItemIndexFromData(dwEditingItemData);
  472. if(nItem < 0 || nItem > nCount || nSubItem < 0 || nSubItem > this->GetColumnCount() 
  473. || IsColumnReadOnly(nSubItem) || IsRowReadOnly(nItem) || IsCellReadOnly(nItem, nSubItem)) return FALSE;
  474. CRect rectSubItem;
  475. //GetSubItemRect(nItem, nSubItem, LVIR_LABEL, rectSubItem);
  476. EnsureSubItemVisible(nItem, nSubItem, &rectSubItem);
  478. CellInfo *pCellInfo = GetCellInfo(nItem, nSubItem);
  479. ColumnInfo *pColInfo = GetColumnInfo(nSubItem);
  480. ItemData *pRowInfo = (ItemData *)GetItemDataInternal(nItem);
  482. m_pEditor = &m_eiDefEditor;
  483. BOOL bReadOnly = FALSE;
  484. if(pColInfo && !(bReadOnly|= pColInfo->m_eiEditor.m_bReadOnly) && pColInfo->m_eiEditor.IsSet())
  485. {
  486. m_pEditor = &pColInfo->m_eiEditor;
  487. }
  488. if(pRowInfo && !(bReadOnly|= pRowInfo->m_eiEditor.m_bReadOnly) && pRowInfo->m_eiEditor.IsSet())
  489. {
  490. m_pEditor = &pRowInfo->m_eiEditor;
  491. }
  492. if(pCellInfo && !(bReadOnly|= pCellInfo->m_eiEditor.m_bReadOnly) && pCellInfo->m_eiEditor.IsSet())
  493. {
  494. m_pEditor = &pCellInfo->m_eiEditor;
  495. }
  496. if(bReadOnly || !m_pEditor || !m_pEditor->IsSet() || m_pEditor->m_bReadOnly){m_pEditor = NULL; return  FALSE;}
  498. m_nEditingRow = nItem;
  499. m_nEditingColumn = nSubItem;
  500. m_nRow = nItem;
  501. m_nColumn = nSubItem;
  502. CString text =  GetItemText(nItem, nSubItem);
  503. if(m_pEditor->m_pfnInitEditor) 
  504. m_pEditor->m_pfnInitEditor(&m_pEditor->m_pWnd, nItem, nSubItem, text, GetItemData(nItem), this, TRUE);
  506. if(!m_pEditor->m_pWnd) return  FALSE;
  507. SelectItem(-1, FALSE);
  508. if(!m_pEditor->m_pfnInitEditor) m_pEditor->m_pWnd->SetWindowText(text);
  510. m_pEditor->m_pWnd->SetParent(this);
  511. m_pEditor->m_pWnd->SetOwner(this);
  513. ASSERT(m_pEditor->m_pWnd->GetParent() == this);
  514. m_pEditor->m_pWnd->SetWindowPos(NULL, rectSubItem.left, rectSubItem.top, rectSubItem.Width(), rectSubItem.Height(), SWP_SHOWWINDOW);
  515. m_pEditor->m_pWnd->ShowWindow(SW_SHOW);
  516. m_pEditor->m_pWnd->SetFocus();
  518. m_msgHook.Attach(m_pEditor->m_pWnd->m_hWnd, this->m_hWnd);
  520. return TRUE;
  521. }
  523. CListCtrlEx::CellInfo* CListCtrlEx::GetCellInfo(int nItem, int nSubItem)
  524. {
  525. ItemData* pData = (ItemData*)GetItemDataInternal(nItem);
  526. if(pData == NULL) return NULL;
  527. INT_PTR nCount = pData->m_aCellInfo.GetCount();
  528. for(INT_PTR i = 0; i < nCount; i++)
  529. {
  530. CellInfo *pInfo = (CellInfo*)pData->m_aCellInfo.GetAt(i);
  531. if(pInfo && pInfo->m_nColumn == nSubItem) return pInfo;
  532. }
  533. return NULL;
  534. }
  536. void CListCtrlEx::HideEditor(BOOL bUpdate)
  537. {
  538. CSingleLock lock(&m_oLock, TRUE);
  539. if(lock.IsLocked() && m_msgHook.Detach())
  540. {
  541. if(m_pEditor && m_pEditor->m_pWnd)
  542. {
  543. m_pEditor->m_pWnd->ShowWindow(SW_HIDE);
  544. CString text;
  545. DWORD_PTR dwData = 0;
  546. if(GetItemCount() > m_nEditingRow)
  547. {
  548. text =  GetItemText(m_nEditingRow, m_nEditingColumn);
  549. dwData = GetItemData(m_nEditingRow);
  550. }
  551. else
  552. {
  553. bUpdate = FALSE;
  554. }
  555. if(m_pEditor->m_pfnEndEditor)
  556. {
  557. bUpdate = m_pEditor->m_pfnEndEditor(&m_pEditor->m_pWnd, m_nEditingRow, m_nEditingColumn, text, dwData, this, bUpdate);
  558. }
  559. else
  560. {
  561. m_pEditor->m_pWnd->GetWindowText(text);
  562. }
  563. if(bUpdate)
  564. {
  565. SetItemText(m_nEditingRow, m_nEditingColumn, text);
  566. }
  567. if(GetItemCount() > m_nEditingRow) Update(m_nEditingRow);
  568. if(bUpdate == -1) SortOnColumn(m_nEditingColumn);
  569. m_pEditor = NULL;
  570. }
  571. }
  572. lock.Unlock();
  573. }
  575. int CListCtrlEx::GetColumnCount(void)
  576. {
  577. CHeaderCtrl *pHdr = GetHeaderCtrl();
  578. if(pHdr) return pHdr->GetItemCount();
  579. int i = 0;
  580. LVCOLUMN col;
  581. col.mask = LVCF_WIDTH;
  582. while(GetColumn(i++, &col));
  583. return i;
  584. }
  586. BOOL CListCtrlEx::PreTranslateMessage(MSG* pMsg)
  587. {
  588. if((m_hAccel && GetParent() && GetFocus() == this && ::TranslateAccelerator(GetParent()->m_hWnd, m_hAccel, pMsg))) return TRUE;
  590. if(pMsg->message == WM_KEYDOWN )
  591. {
  592. if( pMsg->wParam == VK_TAB && (GetKeyState(VK_CONTROL)>>8 != -1))
  593. {
  594. int nCount = GetItemCount();
  595. int nColCount = GetColumnCount();
  596. if(m_pEditor && m_pEditor->m_pWnd && m_pEditor->m_pWnd->m_hWnd == pMsg->hwnd)
  597. {
  598. PostMessage(pMsg->message, pMsg->wParam, pMsg->lParam);
  599. return TRUE;
  600. }
  601. bool bShiftPressed = (GetKeyState(VK_SHIFT)>>8 == -1);
  602. if(!bShiftPressed && nCount == 0 && OnAddNew())
  603. {
  604. nCount = GetItemCount();
  605. m_nColumn = 0;
  606. }
  607. if(nCount > 0 && nColCount > 0)
  608. {
  609. BOOL bContinue;
  610. do
  611. {
  612. bContinue = FALSE;
  613. if(m_nRow < 0 || m_nColumn < 0)
  614. { 
  615. m_nRow = bShiftPressed ? nCount - 1: 0; 
  616. m_nColumn = bShiftPressed ? nColCount - 1: 0;
  617. }
  618. else if(m_nRow >= nCount || m_nColumn >= nColCount)
  619. {
  620. m_nRow = bShiftPressed ? nCount - 1: 0 ; 
  621. m_nColumn = bShiftPressed ? nColCount - 1: 0;
  622. }
  623. else
  624. {
  625. m_nColumn += (bShiftPressed ? -1 : 1);
  626. if(m_nColumn <0 || m_nColumn >= nColCount)
  627. {
  628. m_nRow += (bShiftPressed ? -1 : 1);
  629. m_nColumn = (bShiftPressed ? nColCount-1 : 0);
  630. }
  631. }
  633. if(m_bInvokeAddNew && ((m_nRow == nCount -1 && m_nColumn >= nColCount)||m_nRow >= nCount))
  634. {
  635. HideEditor();
  636. if(OnAddNew())
  637. {
  638. nCount = GetItemCount();
  639. m_nColumn = 0;
  640. }
  641. else return TRUE;
  642. }
  643. if(m_nRow >= 0 && m_nRow < nCount && m_nColumn >= 0 && m_nColumn < nColCount )
  644. {
  645. if(DisplayEditor(m_nRow, m_nColumn))
  646. return TRUE;
  647. bContinue = TRUE;
  648. }
  649. }while(bContinue);
  650. }
  651. }
  652. else if( pMsg->wParam == VK_DELETE  && m_bHandleDelete)
  653. {
  654. DeleteSelectedItems();
  655. return TRUE;
  656. }
  657. }
  658. return CListCtrl::PreTranslateMessage(pMsg);
  660. }
  662. BOOL CListCtrlEx::OnNMCustomdraw(NMHDR *pNMHDR, LRESULT *pResult)
  663. {
  664. LPNMLVCUSTOMDRAW lplvcd = reinterpret_cast<LPNMLVCUSTOMDRAW>(pNMHDR);
  666. int iRow = lplvcd->nmcd.dwItemSpec;
  667. int iCol = lplvcd->iSubItem;
  668. *pResult = 0;
  669. switch(lplvcd->nmcd.dwDrawStage)
  670. {
  671. case CDDS_PREPAINT:
  672. *pResult = CDRF_NOTIFYSUBITEMDRAW;          // ask for subitem notifications.
  673. break;
  675. case CDDS_ITEMPREPAINT:
  676. *pResult = CDRF_NOTIFYSUBITEMDRAW;
  677. break;
  678. case CDDS_ITEMPREPAINT|CDDS_SUBITEM:
  679. {
  680. COLORREF clrBack = 0xFFFFFFFF;
  681. COLORREF clrText = 0xFFFFFFFF;
  683. *pResult = CDRF_DODEFAULT;
  684. CellInfo *pCell = GetCellInfo(iRow, iCol);
  685. if(pCell)
  686. {
  687. clrBack = pCell->m_clrBack;
  688. clrText = pCell->m_clrText;
  689. }
  690. if(clrBack == 0xFFFFFFFF && clrText == 0xFFFFFFFF)
  691. {
  692. ItemData* pData = (ItemData*)GetItemDataInternal(iRow);
  693. if(pData)
  694. {
  695. clrBack = pData->m_clrBack;
  696. clrText = pData->m_clrText;
  697. }
  698. }
  699. if(clrBack == 0xFFFFFFFF && clrText == 0xFFFFFFFF)
  700. {
  701. ColumnInfo *pInfo = GetColumnInfo(iCol);
  702. if(pInfo)
  703. {
  704. clrBack = pInfo->m_clrBack;
  705. clrText = pInfo->m_clrText;
  706. }
  707. }
  708. if(clrBack != 0xFFFFFFFF)
  709. {
  710. lplvcd->clrTextBk = clrBack;
  711. *pResult  = CDRF_NEWFONT;
  712. }
  713. else
  714. {
  715. if(clrBack != m_clrDefBack)
  716. {
  717. lplvcd->clrTextBk = m_clrDefBack;
  718. *pResult  = CDRF_NEWFONT;
  719. }
  720. }
  721. if(clrText != 0xFFFFFFFF)
  722. {
  723. lplvcd->clrText = clrText;
  724. *pResult  = CDRF_NEWFONT;
  725. }
  726. else
  727. {
  728. if(clrText != m_clrDefText)
  729. {
  730. lplvcd->clrText = m_clrDefText;
  731. *pResult  = CDRF_NEWFONT;
  732. }
  733. }
  734. }
  735. break;
  737. default:
  738. *pResult = CDRF_DODEFAULT;
  739. }
  740. if(*pResult == 0 || *pResult == CDRF_DODEFAULT)
  741. return FALSE;
  742. else
  743. return TRUE;
  744. }
  746. void CListCtrlEx::SetRowColors(int nItem, COLORREF clrBk, COLORREF clrText)
  747. {
  749. ItemData* pData = (ItemData*)GetItemDataInternal(nItem);
  750. if(!pData) SetItemData(nItem, 0);
  751. pData = (ItemData*)GetItemDataInternal(nItem);
  752. if(!pData) return;
  754. pData->m_clrText = clrText;
  755. pData->m_clrBack = clrBk;
  756. Update(nItem);
  757. }
  758. BOOL CListCtrlEx::AddItem(int ItemIndex, int SubItemIndex, LPCTSTR ItemText, int ImageIndex)
  759. {
  760. LV_ITEM lvItem;
  761. lvItem.mask = LVIF_TEXT;
  762. lvItem.iItem = ItemIndex;
  763. lvItem.iSubItem = SubItemIndex;
  764. lvItem.pszText = (LPTSTR) ItemText;
  765. if(ImageIndex != -1){
  766. lvItem.mask |= LVIF_IMAGE;
  767. lvItem.iImage |= LVIF_IMAGE;
  768. }
  769. if(SubItemIndex == 0)
  770. return InsertItem(&lvItem);
  771. return SetItem(&lvItem);
  772. }
  773. LRESULT CListCtrlEx::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  774. {
  775. if(message == UM_HIDEEDITOR)
  776. {
  777. HideEditor((BOOL)wParam);
  778. }
  779. return CListCtrl::WindowProc(message, wParam, lParam);
  780. }
  782. void CListCtrlEx::SetColumnColors(int nColumn, COLORREF clrBack, COLORREF clrText)
  783. {
  784. if(nColumn < 0 || nColumn >= GetColumnCount()) return;
  786. ColumnInfo* pColInfo = GetColumnInfo(nColumn);
  787. if(!pColInfo)
  788. { 
  789. pColInfo = new ColumnInfo(nColumn);  
  790. m_aColumnInfo.Add(pColInfo);
  791. }
  793. pColInfo->m_clrBack = clrBack;
  794. pColInfo->m_clrText = clrText;
  796. }
  797. void CListCtrlEx::SetCellColors(int nRow, int nColumn, COLORREF clrBack, COLORREF clrText)
  798. {
  799. if(nRow < 0 || nRow >= GetItemCount() || nColumn < 0 || nColumn >= GetColumnCount()) return;
  800. CellInfo* pCellInfo = GetCellInfo(nRow, nColumn);
  801. if(!pCellInfo)
  802. { 
  803. SetCellData(nRow, nColumn, 0);
  804. }
  805. pCellInfo = GetCellInfo(nRow, nColumn);
  806. ASSERT(pCellInfo);
  807. pCellInfo->m_clrBack = clrBack;
  808. pCellInfo->m_clrText = clrText;
  810. }
  811. void CListCtrlEx::PreSubclassWindow()
  812. {
  813. m_clrDefBack = GetTextBkColor();
  814. m_clrDefText = GetTextColor();
  815. CListCtrl::PreSubclassWindow();
  816. SetExtendedStyle(LVS_EX_FULLROWSELECT);
  817. ModifyStyle(0, LVS_REPORT );
  818. }
  820. BOOL CListCtrlEx::SetCellData(int nItem, int nSubItem, DWORD_PTR dwData)
  821. {
  822. if(nItem < 0 || nItem >= GetItemCount() || nSubItem < 0 || nSubItem >= GetColumnCount()) return FALSE;
  823. CellInfo* pCellInfo = GetCellInfo(nItem, nSubItem);
  824. if(!pCellInfo)
  825. { 
  826. pCellInfo = new CellInfo(nSubItem);
  827. ItemData *pData = (ItemData*)GetItemDataInternal(nItem);
  828. if(!pData)
  829. {
  830. SetItemData(nItem, 0);
  831. pData = (ItemData*)GetItemDataInternal(nItem);
  832. }
  833. pData->m_aCellInfo.Add(pCellInfo);
  834. }
  835. pCellInfo->m_dwUserData = dwData;
  837. return TRUE;
  838. }
  840. DWORD_PTR CListCtrlEx::GetCellData(int nItem, int nSubItem)
  841. {
  842. CellInfo* pCellInfo = GetCellInfo(nItem, nSubItem);
  843. if(pCellInfo) return pCellInfo->m_dwUserData;
  844. else return 0;
  845. }
  847. void CListCtrlEx::SetCellEditor(int nRow, int nColumn, PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd* pWnd)
  848. {
  849. if(nRow < 0 || nRow >= GetItemCount() || nColumn < 0 || nColumn >= GetColumnCount()) return;
  850. CellInfo* pCellInfo = GetCellInfo(nRow, nColumn);
  851. if(!pCellInfo)
  852. { 
  853. SetCellData(nRow, nColumn, 0);
  854. pCellInfo = (CellInfo*)GetCellInfo(nRow, nColumn);
  855. ASSERT(pCellInfo);
  856. }
  858. pCellInfo->m_eiEditor.m_pfnInitEditor = pfnInitEditor;
  859. pCellInfo->m_eiEditor.m_pfnEndEditor = pfnEndEditor;
  860. pCellInfo->m_eiEditor.m_pWnd = pWnd;
  862. }
  864. void CListCtrlEx::SetCellEditor(int nRow, int nColumn, CWnd* pWnd)
  865. {
  866. SetCellEditor(nRow, nColumn, NULL, NULL, pWnd);
  867. }
  870. void CListCtrlEx::SetDefaultEditor(PFNEDITORCALLBACK pfnInitEditor, PFNEDITORCALLBACK pfnEndEditor, CWnd* pWnd)
  871. {
  872. m_eiDefEditor.m_pfnInitEditor = pfnInitEditor;
  873. m_eiDefEditor.m_pfnEndEditor = pfnEndEditor;
  874. m_eiDefEditor.m_pWnd = pWnd;
  875. }
  877. void CListCtrlEx::SetDefaultEditor(CWnd* pWnd)
  878. {
  879. SetDefaultEditor(NULL, NULL, pWnd);
  880. }
  882. void CListCtrlEx::SetColumnReadOnly(int nColumn, bool bReadOnly)
  883. {
  884. if(nColumn < 0 || nColumn >= GetColumnCount()) return;
  885. ColumnInfo *pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  886. if(!pInfo) SetColumnEditor(nColumn, (CWnd*)NULL);
  887. pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  888. ASSERT(pInfo);
  889. pInfo->m_eiEditor.m_bReadOnly = bReadOnly;
  890. }
  892. void CListCtrlEx::SetColumnSorting(int nColumn, Sort eSort, Comparer eComparer)
  893. {
  894. if(nColumn < 0 || nColumn >= GetColumnCount() || !(eSort & SortBits)) return;
  895. ColumnInfo *pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  896. if(!pInfo) SetColumnEditor(nColumn, (CWnd*)NULL);
  897. pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  898. ASSERT(pInfo);
  899. pInfo->m_eSort = eSort;
  900. pInfo->m_eCompare = eComparer;
  901. pInfo->m_fnCompare = NULL;
  902. }
  903. void CListCtrlEx::SetColumnSorting(int nColumn, Sort eSort, PFNLVCOMPARE fnCallBack)
  904. {
  905. if(nColumn < 0 || nColumn >= GetColumnCount() || !(eSort & SortBits)) return;
  906. ColumnInfo *pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  907. if(!pInfo) SetColumnEditor(nColumn, (CWnd*)NULL);
  908. pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  909. ASSERT(pInfo);
  910. pInfo->m_eSort = eSort;
  911. pInfo->m_eCompare = NotSet;
  912. pInfo->m_fnCompare = fnCallBack;
  913. }
  914. void CListCtrlEx::SetCellReadOnly(int nRow, int nColumn, bool bReadOnly )
  915. {
  916. if(nRow < 0 || nRow >= GetItemCount() || nColumn < 0 || nColumn >= GetColumnCount()) return;
  918. CellInfo *pInfo = (CellInfo*)GetCellInfo(nRow, nColumn);
  919. if(!pInfo) SetCellEditor(nRow, nColumn, (CWnd*)NULL);
  920. pInfo = (CellInfo*)GetCellInfo(nRow, nColumn);
  921. ASSERT(pInfo);
  922. pInfo->m_eiEditor.m_bReadOnly = bReadOnly;
  923. }
  924. void CListCtrlEx::SetRowReadOnly(int nRow, bool bReadOnly)
  925. {
  926. if(nRow < 0 || nRow >= GetItemCount() ) return;
  928. ItemData *pInfo = (ItemData*)GetItemDataInternal(nRow);
  929. if(!pInfo) SetItemData(nRow, 0);
  930. pInfo = (ItemData*)GetItemDataInternal(nRow);
  931. ASSERT(pInfo);
  932. pInfo->m_eiEditor.m_bReadOnly = bReadOnly;
  933. }
  935. BOOL CListCtrlEx::IsColumnReadOnly(int nColumn)
  936. {
  937. if(nColumn < 0 || nColumn >= GetColumnCount()) return FALSE;
  938. ColumnInfo *pInfo = (ColumnInfo*)GetColumnInfo(nColumn);
  939. if( pInfo )
  940. {
  941.  return pInfo->m_eiEditor.m_bReadOnly;
  942. }
  943. return FALSE;
  944. }
  946. BOOL CListCtrlEx::IsRowReadOnly(int nRow)
  947. {
  948. if(nRow < 0 || nRow >= GetItemCount() ) return FALSE;
  949. ItemData *pInfo = (ItemData*)GetItemDataInternal(nRow);
  950. if( pInfo )
  951. {
  952.  return pInfo->m_eiEditor.m_bReadOnly;
  953. }
  954. return FALSE;
  955. }
  957. BOOL CListCtrlEx::IsCellReadOnly(int nRow, int nColumn)
  958. {
  959. if(nRow < 0 || nRow >= GetItemCount() || nColumn < 0 || nColumn >= GetColumnCount()) return FALSE;
  961. CellInfo *pInfo = (CellInfo*)GetCellInfo(nRow, nColumn);
  962. if( pInfo )
  963. {
  964.  return pInfo->m_eiEditor.m_bReadOnly;
  965. }
  966. else
  967. return (IsRowReadOnly(nRow) || IsColumnReadOnly(nColumn));
  968. }
  970. void CListCtrlEx::DeleteSelectedItems(void)
  971. {
  972. int nItem = -1;
  973. while((nItem = GetNextItem(-1, LVNI_SELECTED)) >= 0)
  974. {
  975. DeleteItem(nItem);
  976. }
  977. }
  978. void CListCtrlEx::HandleDeleteKey(BOOL bHandle)
  979. {
  980. m_bHandleDelete = bHandle;
  981. }
  982. void CListCtrlEx::SelectItem(int nItem, BOOL bSelect)
  983. {
  984. if(nItem < 0)
  985. {
  986. int nIndex = -1;
  987. while((nIndex = this->GetNextItem(nIndex, bSelect ? LVNI_ALL : LVNI_SELECTED)) >= 0)
  988. {
  989. this->SetItemState(nIndex, (bSelect ? LVIS_SELECTED: 0 ), LVIS_SELECTED);
  990. }
  991. }
  992. else
  993. {
  994. this->SetItemState(nItem, (bSelect ? LVIS_SELECTED: 0 ), LVIS_SELECTED);
  995. }
  996. }
  998. BOOL CListCtrlEx::DeleteAllColumns(void)
  999. {
  1000. while(DeleteColumn(0));
  1001. return (GetColumnCount() == 0);
  1002. }
  1004. BOOL CListCtrlEx::Reset(void)
  1005. {
  1006. return (DeleteAllItems() &&
  1007. DeleteAllColumns());
  1008. }
  1009. int CListCtrlEx::Compare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  1010. {
  1011. CListCtrlEx *This = (CListCtrlEx *)lParamSort;
  1012. if(!This || This->m_nSortColumn < 0 || This->m_nSortColumn >= This->GetColumnCount()) return 0;
  1013. int nSubItem = This->m_nSortColumn;
  1014. ColumnInfo *pInfo = This->GetColumnInfo(nSubItem);
  1015. if(!pInfo) return 0;
  1017. CString strLeft = This->GetItemText(lParam1, nSubItem);
  1018. CString strRight = This->GetItemText(lParam2, nSubItem);
  1020. switch(pInfo->m_eCompare)
  1021. {
  1022. case Int:
  1023. return CompareInt(strLeft, strRight);
  1024. case Double:
  1025. return CompareDouble(strLeft, strRight);
  1026. case StringNoCase:
  1027. return CompareStringNoCase(strLeft, strRight);
  1028. case StringNumber:
  1029. return CompareNumberString(strLeft, strRight);
  1030. case StringNumberNoCase:
  1031. return CompareNumberStringNoCase(strLeft, strRight);
  1032. case String:
  1033. return CompareString(strLeft, strRight);
  1034. case Date:
  1035. return CompareDate(strLeft, strRight);
  1036. case NotSet:
  1037. return 0;
  1038. default:
  1039. return CompareString(strLeft, strRight);
  1040. }
  1041. return CompareString(strLeft, strRight);
  1042. }
  1043. int CListCtrlEx::CompareInt(LPCSTR pLeftText, LPCSTR pRightText)
  1044. {
  1045. return (int)(atol(pLeftText) - atol(pRightText));
  1046. }
  1047. int CListCtrlEx::CompareDouble(LPCSTR pLeftText, LPCSTR pRightText)
  1048. {
  1049. return (int)(atof(pLeftText) - atof(pRightText));
  1050. }
  1051. int CListCtrlEx::CompareString(LPCSTR pLeftText, LPCSTR pRightText)
  1052. {
  1053. return CString(pLeftText).Compare(pRightText);
  1054. }
  1055. int CListCtrlEx::CompareNumberString(LPCSTR pLeftText, LPCSTR pRightText)
  1056. {
  1057. LONGLONG l1 = atol(pLeftText);
  1058. LONGLONG l2 = atol(pRightText);
  1059. if(l1 && l2 && (l1 - l2))
  1060. {
  1061. CString str1, str2;
  1062. str1.Format("%ld", l1);
  1063. str2.Format("%ld", l2);
  1064. CString left(pLeftText);
  1065. CString right(pRightText);
  1066. if(str1.GetLength() == left.GetLength() && str2.GetLength() == right.GetLength()) return (int) (l1 - l2);
  1067. }
  1068. return CString(pLeftText).Compare(pRightText);
  1069. }
  1070. int CListCtrlEx::CompareNumberStringNoCase(LPCSTR pLeftText, LPCSTR pRightText)
  1071. {
  1072. LONGLONG l1 = atol(pLeftText);
  1073. LONGLONG l2 = atol(pRightText);
  1074. if(l1 && l2 && (l1 - l2))
  1075. {
  1076. CString str1, str2;
  1077. str1.Format("%ld", l1);
  1078. str2.Format("%ld", l2);
  1079. CString left(pLeftText);
  1080. CString right(pRightText);
  1081. if(str1.GetLength() == left.GetLength() && str2.GetLength() == right.GetLength()) return (int) (l1 - l2);
  1082. }
  1083. return CString(pLeftText).CompareNoCase(pRightText);
  1084. }
  1085. int CListCtrlEx::CompareStringNoCase(LPCSTR pLeftText, LPCSTR pRightText)
  1086. {
  1087. return CString(pLeftText).CompareNoCase(pRightText);
  1088. }
  1089. int CListCtrlEx::CompareDate(LPCSTR pLeftText, LPCSTR pRightText)
  1090. {
  1091. COleDateTime dL, dR;
  1092. dL.ParseDateTime(pLeftText);
  1093. dR.ParseDateTime(pRightText);
  1094. return (dL == dR ? 0 :(dL < dR ? -1 : 1));
  1095. }
  1098. BOOL CListCtrlEx::PreCreateWindow(CREATESTRUCT& cs)
  1099. {
  1100. cs.dwExStyle |= LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES;
  1102. return CListCtrl::PreCreateWindow(cs);
  1103. }