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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > ListView/ListBox > 查看源码
ListCtrlEx.cpp
资源名称：listclass1.zip　[点击查看]
上传用户：lyghuaxia
上传日期：2007-01-02
资源大小：8k
文件大小：19k
源码类别：

ListView/ListBox

开发平台：

Visual C++

ListCtrlEx.cpp：源码内容
  1. // ListCtrlEx.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  6. #ifdef _DEBUG
  7. #define new DEBUG_NEW
  8. #undef THIS_FILE
  9. static char THIS_FILE[] = __FILE__;
  10. #endif
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CHeaderCtrlEx
  13. CHeaderCtrlEx::CHeaderCtrlEx()
  14. : marker_rect(0,0,0,0)
  15. {
  16. m_pWidth = NULL;
  17. m_bDragging = FALSE;
  18. m_bCheckForDrag = FALSE;
  19. m_fpDragCol = NULL;
  20. m_pOwnerWnd = NULL;
  21. m_bDragEnable = false;
  22. }
  24. CHeaderCtrlEx::CHeaderCtrlEx(CWnd *pWnd, void (CWnd::*fpDragCol)(int, int))
  25. : marker_rect(0,0,0,0)
  26. {
  27. m_pWidth = NULL;
  28. m_bDragging = FALSE;
  29. m_bCheckForDrag = FALSE;
  30. m_fpDragCol = fpDragCol;
  31. m_pOwnerWnd = pWnd;
  32. m_bDragEnable = false;
  33. }
  35. CHeaderCtrlEx::~CHeaderCtrlEx()
  36. {
  37. }
  39. BEGIN_MESSAGE_MAP(CHeaderCtrlEx, CHeaderCtrl)
  40. //{{AFX_MSG_MAP(CHeaderCtrlEx)
  41. ON_WM_MOUSEMOVE()
  42. ON_WM_LBUTTONUP()
  43. ON_WM_LBUTTONDOWN()
  44. //}}AFX_MSG_MAP
  45. END_MESSAGE_MAP()
  47. /////////////////////////////////////////////////////////////////////////////
  48. // Public Properties
  49. //
  50. // EnableDrag(bool bDrag=true): Enable or disable column header dragging
  51. //
  52. /////////////////////////////////////////////////////////////////////////////
  54. bool CHeaderCtrlEx::EnableDrag(bool bDrag)
  55. {
  56. bool bOld = m_bDragEnable;
  57. m_bDragEnable = bDrag;
  59. return bOld;
  60. }
  62. //End Properties
  63. /////////////////////////////////////////////////////////////////////////////
  65. /////////////////////////////////////////////////////////////////////////////
  66. // CHeaderCtrlEx message handlers
  68. void CHeaderCtrlEx::OnMouseMove(UINT nFlags, CPoint point)
  69. {
  70. if(m_bDragEnable) {
  71. if( (MK_LBUTTON & nFlags) == 0) {
  72. // The left mouse button is not pressed - so reset flags
  73. m_bCheckForDrag = FALSE;
  74. m_bDragging = FALSE;
  75. }
  76. else if( m_bDragging ) {
  77. // Get column number that falls under the mouse
  78. int i=0, cx = 0;
  79. if( point.x > 0 )
  80. for( i = 0; i < GetItemCount(); i++ ) {
  81. if( point.x >= cx && point.x < cx + m_pWidth[i] )
  82. break;
  83. cx += m_pWidth[i];
  84. }
  85. if( i != m_nDropPos ) {
  86. m_nDropPos = i;
  87. CRect rect;
  88. GetWindowRect( &rect );
  89. // Invalidate area occupied by previous marker
  90. InvalidateRect( &marker_rect );
  92. // Draw a new marker
  93. CClientDC dc(this);
  94. POINT pts[3];
  95. pts[0].x = cx;
  96. pts[1].x = cx - rect.Height()/4;
  97. pts[2].x = cx + rect.Height()/4;
  98. pts[0].y = rect.Height();
  99. pts[1].y = pts[2].y = rect.Height()/2;
  100. dc.Polygon( pts, 3 );
  102. // save marker information
  103. marker_rect.left = cx - (rect.Height()/4 + 1);
  104. marker_rect.top = rect.Height() - (rect.Height()/2 + 1);
  105. marker_rect.right = cx + (rect.Height()/4 + 1);
  106. marker_rect.bottom = rect.Height() + 1;
  107. }
  108. return;
  109. }
  110. else if( m_bCheckForDrag ) {
  111. // The mouse button was pressed over a column header
  112. // and now the mouse has moved - so start drag
  113. m_bCheckForDrag = FALSE;
  114. m_bDragging = TRUE;
  115. m_nDropPos = m_nDragCol;
  116. SetCapture();
  118. // Store information for later use
  119. int iCount = GetItemCount();
  120. HD_ITEM hd_item;
  121. m_pWidth = new int[iCount];
  122. for( int i = 0; i < iCount; i++ ) {
  123. hd_item.mask = HDI_WIDTH;
  124. GetItem( i, &hd_item );
  125. m_pWidth[i] = hd_item.cxy;
  126. }
  127. return;
  128. }
  129. }
  131. CHeaderCtrl::OnMouseMove(nFlags, point);
  132. }
  134. void CHeaderCtrlEx::OnLButtonDown(UINT nFlags, CPoint point)
  135. {
  136. if(m_bDragEnable) {
  137. // Determine if mouse was pressed over a column header
  138. HD_HITTESTINFO hd_hittestinfo;
  139. hd_hittestinfo.pt = point;
  140. SendMessage(HDM_HITTEST, 0, (LPARAM)(&hd_hittestinfo));
  141. if( hd_hittestinfo.flags == HHT_ONHEADER ) {
  142. m_nDragCol = hd_hittestinfo.iItem;
  143. m_bCheckForDrag = TRUE;
  144. }
  145. }
  147. CHeaderCtrl::OnLButtonDown(nFlags, point);
  148. }
  150. void CHeaderCtrlEx::OnLButtonUp(UINT nFlags, CPoint point)
  151. {
  152. if(m_bDragEnable) {
  153. ASSERT( m_pOwnerWnd != NULL && m_fpDragCol != NULL );
  154. if( m_bDragging ) {
  155. m_bDragging = FALSE;
  156. delete[] m_pWidth;
  157. ReleaseCapture();
  158. Invalidate();
  159. // Call the callback function.
  160. if( m_nDragCol != m_nDropPos && m_nDragCol != m_nDropPos -1 )
  161. (m_pOwnerWnd->*m_fpDragCol)( m_nDragCol, m_nDropPos );
  162. }
  163. }
  165. CHeaderCtrl::OnLButtonUp(nFlags, point);
  166. }
  168. void CHeaderCtrlEx::SetCallback( CWnd* pWnd, void (CWnd::*fpDragCol)(int, int) )
  169. {
  170. m_fpDragCol = fpDragCol;
  171. m_pOwnerWnd = pWnd;
  172. }
  174. //End CHeaderCtrlEx
  175. /////////////////////////////////////////////////////////////////////////////
  177. /////////////////////////////////////////////////////////////////////////////
  178. // CListCtrlEx
  180. //Constructor for the list data structure
  181. CListCtrlEx::ListData::ListData(const DWORD dwOld, const CString &strTxt, const COleDateTime Start)
  182. {
  183. dwOldData = dwOld;
  184. strText = strTxt;
  185. BaseTime = Start;
  186. }
  188. CListCtrlEx::CListCtrlEx()
  189. {
  190. nSortedCol = -1; 
  191. bSortAscending = TRUE;
  192. m_nNumCols = 0;
  193. m_pTypes = NULL;
  194. m_ctStart.SetStatus(COleDateTime::invalid);
  195. m_bSort = false;
  196. m_nHighlight = HIGHLIGHT_NORMAL;
  198. m_headerctrl.SetCallback( this, (void (CWnd::*)(int, int))DragColumn );
  199. }
  201. CListCtrlEx::~CListCtrlEx()
  202. {
  203. delete m_pTypes;
  204. }
  207. BEGIN_MESSAGE_MAP(CListCtrlEx, CListCtrl)
  208. //{{AFX_MSG_MAP(CListCtrlEx)
  209. ON_WM_PAINT()
  210. ON_WM_SETFOCUS()
  211. ON_WM_KILLFOCUS()
  212. ON_WM_LBUTTONDOWN()
  213. ON_WM_LBUTTONUP()
  214. ON_WM_MOUSEMOVE()
  215. //}}AFX_MSG_MAP
  216. ON_NOTIFY(HDN_ITEMCLICKA, 0, OnHeaderClicked) 
  217. ON_NOTIFY(HDN_ITEMCLICKW, 0, OnHeaderClicked)
  218. END_MESSAGE_MAP()
  220. /////////////////////////////////////////////////////////////////////////////
  221. //Public Properties
  222. //
  223. // SetHighlightType(int hilite): Set highlight type
  224. // EnableSort(bool bSort=true): Enable sorting by column
  225. // SetColumnTypes(unsigned char* pColTypes, unsigned nColCnt):
  226. // Set the column sort types
  227. // EnableHeaderDrag(bool bDrag=true}: Enable column header dragging
  228. // SetBaseTime(CString strTime): Set the base time for 24hr clock
  229. //
  230. /////////////////////////////////////////////////////////////////////////////
  232. int CListCtrlEx::SetHighlightType(int hilite)
  233. {
  234. int oldhilite = m_nHighlight;
  235. if( hilite <= HIGHLIGHT_ROW )
  236. {
  237. m_nHighlight = hilite;
  238. //set to ownerdraw for full row highlighting
  239. if(hilite > HIGHLIGHT_NORMAL)
  240. ModifyStyle(0, LVS_OWNERDRAWFIXED);
  241. Invalidate();
  242. }
  244. return oldhilite;
  245. }
  247. bool CListCtrlEx::EnableSort(bool bSort)
  248. {
  249. bool bOldSort = m_bSort;
  250. m_bSort = bSort;
  252. return bOldSort;
  253. }
  255. bool CListCtrlEx::SetColumnTypes(unsigned char* pColTypes, unsigned nColCnt)
  256. {
  257. delete m_pTypes;
  258. m_pTypes = new unsigned char[nColCnt];
  259. if(m_pTypes == NULL) {
  260. m_nNumCols = 0;
  261. return false;
  262. }
  264. for(unsigned i=0; i<nColCnt; i++) {
  265. if(pColTypes[i] > LVEX_LAST) {
  266. m_nNumCols = 0;
  267. delete m_pTypes;
  268. return false;
  269. }
  270. m_pTypes[i] = pColTypes[i];
  271. }
  273. m_nNumCols = nColCnt;
  275. return true;
  276. }
  278. bool CListCtrlEx::EnableHeaderDrag(bool bDrag)
  279. {
  280. return m_headerctrl.EnableDrag(bDrag);
  281. }
  283. bool CListCtrlEx::SetBaseTime(CString strTime)
  284. {
  285. COleDateTime ctNew;
  286. //there can only be one base time for all columns
  287. //this function should only be called once
  288. ASSERT(m_ctStart.GetStatus() == COleDateTime::invalid);
  290. ctNew.ParseDateTime(strTime);
  291. if(ctNew.GetStatus() != COleDateTime::invalid) {
  292. m_ctStart = ctNew;
  293. return true;
  294. }
  296. return false;
  297. }
  299. //End Properties
  300. /////////////////////////////////////////////////////////////////////////////
  302. /////////////////////////////////////////////////////////////////////////////
  303. // Highlighting
  304. //
  305. /////////////////////////////////////////////////////////////////////////////
  307. void CListCtrlEx::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  308. {
  309. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  310. CRect rcItem(lpDrawItemStruct->rcItem);
  311. int nItem = lpDrawItemStruct->itemID;
  312. CImageList* pImageList; // Save dc state
  313. int nSavedDC = pDC->SaveDC();
  314. CBrush WndBrush(::GetSysColor(COLOR_WINDOW));
  315. CBrush HltBrush(::GetSysColor(COLOR_HIGHLIGHT));
  317. // Get item image and state info
  318. LV_ITEM lvi;
  319. lvi.mask = LVIF_IMAGE | LVIF_STATE;
  320. lvi.iItem = nItem;
  321. lvi.iSubItem = 0;
  322. lvi.stateMask = 0xFFFF; // get all state flags
  323. GetItem(&lvi);
  325. // Should the item be highlighted
  326. BOOL bHighlight =((lvi.state & LVIS_DROPHILITED)
  327. || ( (lvi.state & LVIS_SELECTED)
  328. && ((GetFocus() == this)
  329. || (GetStyle() & LVS_SHOWSELALWAYS))));
  331. // Get rectangles for drawing
  332. CRect rcBounds, rcLabel, rcIcon;
  333. GetItemRect(nItem, rcBounds, LVIR_BOUNDS);
  334. GetItemRect(nItem, rcLabel, LVIR_LABEL);
  335. GetItemRect(nItem, rcIcon, LVIR_ICON);
  336. CRect rcCol( rcBounds ); 
  337. CString sLabel = GetItemText( nItem, 0 );
  339. // Labels are offset by a certain amount  
  340. // This offset is related to the width of a space character
  341. int offset = pDC->GetTextExtent(_T(" "), 1 ).cx*2;
  342. CRect rcHighlight;
  343. CRect rcWnd;
  344. int nExt;
  345. switch(m_nHighlight) {
  346. case HIGHLIGHT_NORMAL: 
  347. nExt = pDC->GetOutputTextExtent(sLabel).cx + offset;
  348. rcHighlight = rcLabel;
  349. if( rcLabel.left + nExt < rcLabel.right )
  350. rcHighlight.right = rcLabel.left + nExt;
  351. break;
  352. case HIGHLIGHT_ALLCOLUMNS:
  353. rcHighlight = rcBounds;
  354. rcHighlight.left = rcLabel.left;
  355. break;
  356. case HIGHLIGHT_ROW:
  357. GetClientRect(&rcWnd);
  358. rcHighlight = rcBounds;
  359. rcHighlight.left = rcLabel.left;
  360. rcHighlight.right = rcWnd.right;
  361. break;
  362. default:
  363. rcHighlight = rcLabel;
  364. }
  366. // Draw the background color
  367. if( bHighlight ) {
  368. pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  369. pDC->SetBkColor(::GetSysColor(COLOR_HIGHLIGHT));
  370. pDC->FillRect(rcHighlight, &HltBrush);
  371. }
  372. else
  373. pDC->FillRect(rcHighlight, &WndBrush);
  375. // Set clip region
  376. rcCol.right = rcCol.left + GetColumnWidth(0);
  377. CRgn rgn;
  378. rgn.CreateRectRgnIndirect(&rcCol);
  379. pDC->SelectClipRgn(&rgn);
  380. rgn.DeleteObject();
  382. // Draw state icon
  383. if (lvi.state & LVIS_STATEIMAGEMASK) {
  384. int nImage = ((lvi.state & LVIS_STATEIMAGEMASK)>>12) - 1;
  385. pImageList = GetImageList(LVSIL_STATE);
  386. if (pImageList) {
  387. pImageList->Draw(pDC, nImage,
  388. CPoint(rcCol.left, rcCol.top), ILD_TRANSPARENT);
  389. }
  390. }
  392. // Draw normal and overlay icon
  393. pImageList = GetImageList(LVSIL_SMALL);
  394. if (pImageList) {
  395. UINT nOvlImageMask=lvi.state & LVIS_OVERLAYMASK;
  396. pImageList->Draw(pDC, lvi.iImage, 
  397. CPoint(rcIcon.left, rcIcon.top),
  398. (bHighlight?ILD_BLEND50:0) | ILD_TRANSPARENT | nOvlImageMask );
  399. }
  400. // Draw item label - Column 0
  401. rcLabel.left += offset/2;
  402. rcLabel.right -= offset;
  403. pDC->DrawText(sLabel,-1,rcLabel,DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP 
  404. | DT_VCENTER | DT_END_ELLIPSIS);
  406. // Draw labels for remaining columns
  407. LV_COLUMN lvc;
  408. lvc.mask = LVCF_FMT | LVCF_WIDTH;
  409. if(m_nHighlight == HIGHLIGHT_NORMAL) // Highlight only first column
  410. {
  411. pDC->SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
  412. pDC->SetBkColor(::GetSysColor(COLOR_WINDOW));
  413. }
  414. rcBounds.right = rcHighlight.right > rcBounds.right ? rcHighlight.right :
  415. rcBounds.right; rgn.CreateRectRgnIndirect(&rcBounds);
  416. pDC->SelectClipRgn(&rgn);    
  417. for(int nColumn = 1; GetColumn(nColumn, &lvc); nColumn++) {
  418. rcCol.left = rcCol.right;
  419. rcCol.right += lvc.cx;
  421. // Draw the background if needed
  422. if( m_nHighlight == HIGHLIGHT_NORMAL )
  423. pDC->FillRect(rcCol, &HltBrush);
  424. sLabel = GetItemText(nItem, nColumn);
  425. if (sLabel.GetLength() == 0)
  426. continue;
  428. // Get the text justification
  429. UINT nJustify = DT_LEFT;
  430. switch(lvc.fmt & LVCFMT_JUSTIFYMASK)
  431. {
  432. case LVCFMT_RIGHT:
  433. nJustify = DT_RIGHT;
  434. break;
  435. case LVCFMT_CENTER:
  436. nJustify = DT_CENTER;
  437. break;
  438. default:
  439. break;
  440. }
  441. rcLabel = rcCol;
  442. rcLabel.left += offset;
  443. rcLabel.right -= offset;
  444. pDC->DrawText(sLabel, -1, rcLabel, nJustify | DT_SINGLELINE | 
  445. DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS);
  446. }
  448. // Draw focus rectangle if item has focus
  449. if (lvi.state & LVIS_FOCUSED && (GetFocus() == this))
  450. pDC->DrawFocusRect(rcHighlight);
  452. // Restore dc
  453. pDC->RestoreDC( nSavedDC );
  454. WndBrush.DeleteObject();
  455. HltBrush.DeleteObject();
  456. }
  458. void CListCtrlEx::OnPaint() 
  459. {
  460. // in full row select mode, we need to extend the clipping region
  461. // so we can paint a selection all the way to the right
  462. if (m_nHighlight == HIGHLIGHT_ROW &&
  463. (GetStyle() & LVS_TYPEMASK) == LVS_REPORT ) {
  464. CRect rcBounds;
  465. GetItemRect(0, rcBounds, LVIR_BOUNDS);
  466. CRect rcClient;
  467. GetClientRect(&rcClient);
  468. if(rcBounds.right < rcClient.right) {
  469. CPaintDC dc(this);
  470. CRect rcClip;
  471. dc.GetClipBox(rcClip);
  472. rcClip.left = min(rcBounds.right-1, rcClip.left);
  473. rcClip.right = rcClient.right;
  474. InvalidateRect(rcClip, FALSE);
  475. }
  476. }
  478. CListCtrl::OnPaint();
  479. }
  481. void CListCtrlEx::OnSetFocus(CWnd* pOldWnd) 
  482. {
  483. CListCtrl::OnSetFocus(pOldWnd);
  485. // check if we are getting focus from label edit box
  486. if(pOldWnd!=NULL && pOldWnd->GetParent()==this)
  487. return;
  488. // repaint items that should change appearance
  489. if((GetStyle() & LVS_TYPEMASK)==LVS_REPORT)
  490. RepaintSelectedItems();
  491. }
  493. void CListCtrlEx::OnKillFocus(CWnd* pNewWnd) 
  494. {
  495. CListCtrl::OnKillFocus(pNewWnd);
  497. // check if we are losing focus to label edit box
  498. if(pNewWnd != NULL && pNewWnd->GetParent() == this)
  499. return;
  500. // repaint items that should change appearance
  501. if((GetStyle() & LVS_TYPEMASK) == LVS_REPORT)
  502. RepaintSelectedItems();
  503. }
  505. void CListCtrlEx::RepaintSelectedItems()
  506. {
  507. CRect rcBounds, rcLabel;
  509. // Invalidate focused item so it can repaint 
  510. int nItem = GetNextItem(-1, LVNI_FOCUSED);
  512. if(nItem != -1)
  513. {
  514. GetItemRect(nItem, rcBounds, LVIR_BOUNDS);
  515. GetItemRect(nItem, rcLabel, LVIR_LABEL);
  516. rcBounds.left = rcLabel.left;
  518. InvalidateRect(rcBounds, FALSE);
  519. }
  521. // Invalidate selected items depending on LVS_SHOWSELALWAYS
  522. if(!(GetStyle() & LVS_SHOWSELALWAYS))
  523. {
  524. for(nItem = GetNextItem(-1, LVNI_SELECTED);
  525. nItem != -1; nItem = GetNextItem(nItem, LVNI_SELECTED))
  526. {
  527. GetItemRect(nItem, rcBounds, LVIR_BOUNDS);
  528. GetItemRect(nItem, rcLabel, LVIR_LABEL);
  529. rcBounds.left = rcLabel.left;
  531. InvalidateRect(rcBounds, FALSE);
  532. }
  533. }
  535. UpdateWindow();
  536. }
  538. //places check marks in state icon boxes when clicked
  539. void CListCtrlEx::OnLButtonDown(UINT nFlags, CPoint point) 
  540. {
  541. UINT uFlags = 0;
  542. int nHitItem = HitTest(point, &uFlags);
  544. BOOL bHit = FALSE;
  545. if (uFlags & LVHT_ONITEMSTATEICON)
  546. bHit = TRUE;
  548. if (bHit) {
  549. UINT nState = GetItemState(nHitItem, LVIS_STATEIMAGEMASK);
  550. if(nState == INDEXTOSTATEIMAGEMASK(1))
  551. SetItemState(nHitItem, INDEXTOSTATEIMAGEMASK(2), LVIS_STATEIMAGEMASK);
  552. else
  553. SetItemState(nHitItem, INDEXTOSTATEIMAGEMASK(1), LVIS_STATEIMAGEMASK);
  554. }
  556. CListCtrl::OnLButtonDown(nFlags, point);
  557. }
  559. //End Hilighting
  560. //////////////////////////////////////////////////////////////////////
  562. //////////////////////////////////////////////////////////////////////
  563. //Sorting by columns
  564. //
  565. //////////////////////////////////////////////////////////////////////
  567. void CListCtrlEx::OnHeaderClicked(NMHDR* pNMHDR, LRESULT* pResult)
  568. {
  569. HD_NOTIFY *phdn = (HD_NOTIFY *) pNMHDR;
  571. if(phdn->iButton == 0 && m_bSort)// Button is the left mouse button 
  572. {
  573. // User clicked on header using left mouse button
  574. if(phdn->iItem == nSortedCol)
  575. bSortAscending = !bSortAscending;
  576. else
  577. bSortAscending = TRUE;
  579. nSortedCol = phdn->iItem;
  580. int NumItems = GetItemCount();
  582. // replace Item data with pointer to ListData structure
  583. for (int i = 0; i < NumItems; i++) {
  584. DWORD dwData = GetItemData(i); // save current data to restore it later
  585. CString strText = GetItemText(i, nSortedCol);
  587. SetItemData(i, (DWORD)new ListData(dwData, strText, m_ctStart));
  588. }
  590. SortItems(Compare, bSortAscending | (m_pTypes[nSortedCol] << 8));
  592. for(i=0; i<NumItems; i++) {
  593. ListData* pData = (ListData*)GetItemData(i);
  594. SetItemData(i, pData->dwOldData);
  595. delete pData;
  597. }
  598. }
  599. *pResult = 0;
  600. }
  602. int CALLBACK CListCtrlEx::Compare(LPARAM lParam1, LPARAM lParam2, LPARAM 
  603.  lParSortAsc)
  604. {
  605. CString str1 = ((ListData*)lParam1)->strText;
  606. CString str2 = ((ListData*)lParam2)->strText;
  608. unsigned char Type = unsigned char(lParSortAsc >> 8);
  610. // restore data type and sort order from lParamSort
  611. // if lParamSort positive - ascending sort order, negative - descending
  612. int  sOrder = (lParSortAsc & 0xFF) ? 1 : -1; 
  613. COleDateTime t1, t2, bTime = ((ListData*)lParam1)->BaseTime;
  615. switch (Type) {
  616. //Date time column(s) with 24 hr base time
  617. case  LVEX_TIME_BASE://most people will never use this
  618. if (t1.ParseDateTime(str1) && t2.ParseDateTime(str2))
  619. {
  620. if(bTime.GetStatus() != COleDateTime::invalid && 
  621. t1 < bTime)
  622. {
  623. t1 += COleDateTimeSpan(1, 0, 0, 0);
  624. }
  625. if(bTime.GetStatus() != COleDateTime::invalid &&
  626. t2 < bTime)
  627. {
  628. t2 += COleDateTimeSpan(1, 0, 0, 0);
  629. }
  631. return (t1 < t2 ? -1 : 1 )*sOrder;
  632. }
  633. else
  634. return 0;
  635. //Date time column(s) no base time
  636. case  LVEX_TIME:
  637. if (t1.ParseDateTime(str1) && t2.ParseDateTime(str2))
  638. return (t1 < t2 ? -1 : 1 )*sOrder;
  639. else
  640. return 0;
  641. //integer number columns
  642. case  LVEX_NUM:
  643. return (atol(str1) - atol(str2))*sOrder;
  644. //float number columns
  645. case  LVEX_NUM_FLOAT:
  646. return (atof(str1) < atof(str2) ? -1 : 1)*sOrder;
  647. //text columns (no case)
  648. case  LVEX_NOCASE:
  649. return str1.CompareNoCase(str2)*sOrder;
  650. //text columns (case sensitive)
  651. case LVEX_CASE:
  652. return (str1.Compare(str2))*sOrder;
  653. }
  655. return 0;
  656. }
  658. //End Sorting
  659. //////////////////////////////////////////////////////////////////////////
  661. //////////////////////////////////////////////////////////////////////
  662. //Drag Column Headers
  663. //
  664. //////////////////////////////////////////////////////////////////////
  666. void CListCtrlEx::DragColumn(int source, int dest)
  667. {
  668. TCHAR sColText[160];
  670. // Insert a column at dest
  671. LV_COLUMN lv_col;
  672. lv_col.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
  673. lv_col.pszText = sColText;
  674. lv_col.cchTextMax = 159;
  675. GetColumn( source, &lv_col );
  676. lv_col.iSubItem = dest;
  677. InsertColumn( dest, &lv_col );
  679. // Adjust source col number since it might have changed