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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > TreeView控件 > 查看源码
Tsyslistviewex.cpp
资源名称：MultColumnTreeListControl.zip　[点击查看]
上传用户：maicowu
上传日期：2007-01-02
资源大小：87k
文件大小：32k
源码类别：

TreeView控件

开发平台：

Visual C++

Tsyslistviewex.cpp：源码内容
  2. /************************************
  3.   REVISION LOG ENTRY
  4.   Revision By: Mihai Filimon
  5.   Revised on 5/22/98 9:23:23 AM
  6.   Comments: Tsyslistviewex.cpp : implementation file
  7.  ************************************/
  9. #include "stdafx.h"
  10. #include "Tsyslistviewex.h"
  11. #include "resource.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. #define scanCodeS 0x13
  21. /////////////////////////////////////////////////////////////////////////////
  22. // CTsyslistviewex
  24. TCHAR CTsyslistviewex::m_cImageTextSeparator = TCHAR(':');
  27. // Function name : CTsyslistviewex::CTsyslistviewex
  28. // Description     : constructor
  29. // In contructor u must set the height of item list. (MeasureItem is called before
  30. // PreSubclassWindow!). U can not modify item height at runtime, therefore.
  31. // Return type : void
  32. // Argument         : int nHeightRel ; set item height
  33. CTsyslistviewex::CTsyslistviewex(int nHeightRel)
  34. {
  35. m_fctDrawItem = CTsyslistviewex::DrawItemNoGrid;
  36. m_nHeightRel = nHeightRel;
  37. m_bSorted = false;
  38. m_bSortWhenClickHeader = TRUE;
  39. m_nSortItems = 0;
  40. m_nIProgress = 0;
  41. m_bSaveHeader = false;
  42. ResetBoldLines();
  43. }
  45. // Function name : CTsyslistviewex::~CTsyslistviewex
  46. // Description     : destructor
  47. // Return type : void
  48. CTsyslistviewex::~CTsyslistviewex()
  49. {
  50. // Remove the CTColumnBitmap from m_bmpColumns
  51. POSITION posBmp = m_bmpColumns.GetStartPosition( );
  52. while (posBmp)
  53. {
  54. CTColumnBitmap* pBitmap = NULL;
  55. int nColumn = 0;
  56. m_bmpColumns.GetNextAssoc( posBmp , nColumn,  pBitmap );
  57. if (pBitmap)
  58. delete pBitmap;
  59. }
  60. m_bmpColumns.RemoveAll();
  62. // Remove the CTColumnBitmap from m_bmpCells
  63. posBmp = m_bmpCells.GetStartPosition( );
  64. while (posBmp)
  65. {
  66. CTColumnBitmap* pBitmap = NULL;
  67. DWORD nKey = 0;
  68. m_bmpCells.GetNextAssoc( posBmp , nKey,  pBitmap );
  69. if (pBitmap)
  70. delete pBitmap;
  71. }
  72. m_bmpCells.RemoveAll();
  73. }
  75. // Function name : CTsyslistviewex::IsHeaderSaved
  76. // Description     : accessor: header saved
  77. // Return type : BOOL ;Return TRUE if EnableSaveHeader was called
  78. BOOL CTsyslistviewex::IsHeaderSaved()
  79. {
  80. return m_bSaveHeader;
  81. }
  83. // Function name : CTsyslistviewex::GetRegisteredSort
  84. // Description     : Read form registry in dest for Sort:ID. 
  85. // Return type : BOOL ; Return TRUE if key exist.
  86. // Argument         : CString & dest ; string to put value into
  87. BOOL CTsyslistviewex::GetRegisteredSort(CString & dest)
  88. {
  89. BOOL bResult = false;
  90. if (IsHeaderSaved())
  91. {
  92. CString secid; secid.Format(_T("Sort:%08X"), GetDlgCtrlID());
  93. CString result = AfxGetApp()->GetProfileString(LIST_SECTION, secid, _T("Default"));
  94. if (result != _T("Default"))
  95. {
  96. dest = result;
  97. bResult = true;
  98. }
  99. }
  100. return bResult;
  101. }
  103. // Function name : CTsyslistviewex::SaveHeader
  104. // Description     : Save widths and sort columns in registry in fromat:
  105. // Header:ID = Column1:C:126, ...
  106. // Sort:ID = 1D,2,3 ...
  107. // Return type : void 
  108. void CTsyslistviewex::SaveHeader()
  109. {
  110. if (IsHeaderSaved())
  111. {
  112. CString secid; secid.Format(_T("Header:%08X"), GetDlgCtrlID());
  113. AfxGetApp()->WriteProfileString(LIST_SECTION, secid, (LPCTSTR)GetHeaderString());
  114. secid.Format(_T("Sort:%08X"), GetDlgCtrlID());
  115. AfxGetApp()->WriteProfileString(LIST_SECTION, secid, (LPCTSTR)GetHeaderSortString());
  116. }
  117. }
  119. BEGIN_MESSAGE_MAP(CTsyslistviewex, CListCtrl)
  120. //{{AFX_MSG_MAP(CTsyslistviewex)
  121. ON_WM_LBUTTONDOWN()
  122. ON_NOTIFY_REFLECT(LVN_COLUMNCLICK, OnColumnclick)
  123. ON_WM_CHAR()
  124. //}}AFX_MSG_MAP
  125. ON_WM_MEASUREITEM_REFLECT()
  126. END_MESSAGE_MAP()
  128. /////////////////////////////////////////////////////////////////////////////
  129. // CTsyslistviewex message handlers
  131. // Function name : CTsyslistviewex::PreSubclassWindow
  132. // Description     : Called when user subclass list control form resource
  133. // Return type : void 
  134. void CTsyslistviewex::PreSubclassWindow( )
  135. {
  136. // Must be owner draw and report mode....
  137. ModifyStyle(LVS_SMALLICON | LVS_LIST | LVS_ICON , LVS_OWNERDRAWFIXED | LVS_REPORT);
  139. m_pOldHeaderCtrl = GetDlgItem(0);
  141. // Create different fonts..
  142. if (CFont* pFont = GetFont())
  143. {
  144. LOGFONT lf;
  145. pFont->GetLogFont(&lf);
  146. lf.lfWeight = FW_BOLD;
  147. m_boldFont.CreateFontIndirect(&lf);
  148. lf.lfWeight = FW_NORMAL;
  149. lf.lfItalic = TRUE;
  150. m_italicFont.CreateFontIndirect(&lf);
  151. lf.lfWeight = FW_BOLD;
  152. lf.lfItalic = TRUE;
  153. m_italicBoldFont.CreateFontIndirect(&lf);
  154. }
  156. SetWindowLong(m_hWnd, GWL_USERDATA , LIST_SUBCLASSED);
  157. }
  159. // Function name : CTsyslistviewex::OnLButtonDown
  160. // Description     : If user click in list ctrl, test item, subItem
  161. // Return type : void 
  162. // Argument         : UINT nFlags
  163. // Argument         : CPoint point
  164. void CTsyslistviewex::OnLButtonDown(UINT nFlags, CPoint point)
  165. {
  166. SetFocus();
  167. int item = -1, subItem = -1 ;
  168. item = HitTestEx(point, subItem);
  169. CListCtrl::OnLButtonDown(nFlags, point);
  170. }
  172. // Function name : CTsyslistviewex::MakeShortString
  173. // Description     : Return shorted string lpszLong in device pDC
  174. // Return type : LPCTSTR 
  175. // Argument         : CDC* pDC
  176. // Argument         : LPCTSTR lpszLong
  177. // Argument         : int nColumnLen
  178. // Argument         : int nOffset
  179. LPCTSTR CTsyslistviewex::MakeShortString(CDC* pDC, LPCTSTR lpszLong, int nColumnLen, int nOffset)
  180. {
  181. static const TCHAR szThreeDots[] = _T("...");
  182. static TCHAR szShort[MAX_PATH];
  184. int nStringLen = strlen(lpszLong);
  186. if(nStringLen == 0 ||
  187. (pDC->GetTextExtent(lpszLong, nStringLen).cx + nOffset) <= nColumnLen)
  188. {
  189. return(lpszLong);
  190. }
  192. strcpy(szShort,lpszLong);
  193. int nAddLen = pDC->GetTextExtent(szThreeDots,strlen(szThreeDots)).cx;
  195. for(int i = nStringLen-1; i > 0; i--)
  196. {
  197. szShort[i] = '';
  198. if((pDC->GetTextExtent(szShort, i).cx + nOffset + nAddLen)
  199. <= nColumnLen)
  200. {
  201. break;
  202. }
  203. }
  205. strcat(szShort, szThreeDots);
  206. return(szShort);
  207. }
  209. // Function name : CTsyslistviewex::DrawCell
  210. // Description     : Draw at pDC in drawRect cell(nItem,nColumn) with format
  211. // Return type : void 
  212. // Argument         : CDC* pDC
  213. // Argument         : CRect& drawRect
  214. // Argument         : int nItem
  215. // Argument         : int nColumn
  216. void CTsyslistviewex::DrawCell(CDC* pDC, CRect& drawRect, DWORD format, int nItem, int nColumn)
  217. {
  218. static TCHAR szBuff[MAX_PATH];
  219. LPCTSTR pszText;
  220. GetItemText(nItem, nColumn, szBuff, sizeof(szBuff));
  221. {
  222. CTColumnBitmap* pBitmap = GetBitmapCell(GetItemData(nItem),nColumn);
  223. int dxBitmap = 0;
  224. CString sImageBitmap, sText(szBuff);
  225. if (pBitmap)
  226. {
  227. dxBitmap = min(pBitmap->GetWidth(),drawRect.Width());
  228. int p = sText.Find(m_cImageTextSeparator);
  229. sImageBitmap = sText.Left(max(0,p));
  230. sText = sText.Mid(p + 1);
  231. if (p < 0)
  232. {
  233. sImageBitmap = sText;
  234. sText.Empty();
  235. }
  236. }
  239. pszText = MakeShortString(pDC, (LPCTSTR)sText, (drawRect.right - (drawRect.left + dxBitmap + OFFSET)), OFFSET);
  240. if (*pszText != TCHAR(''))
  241. {
  242. UINT nJustify = DT_LEFT;    
  243. if(pszText == sText)
  244. {
  245. switch(format & LVCFMT_JUSTIFYMASK)
  246. {
  247. case LVCFMT_RIGHT:
  248. nJustify = DT_RIGHT;
  249. break;
  250. case LVCFMT_CENTER:
  251. nJustify = DT_CENTER;
  252. break;
  253. default:
  254. break;
  255. }
  256. }
  257. drawRect.left = drawRect.left + dxBitmap + OFFSET;
  258. pDC->DrawText(pszText, -1, drawRect, nJustify | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER);
  259. drawRect.left = drawRect.left -(dxBitmap + OFFSET);
  260. }
  262. if (dxBitmap)
  263. {
  264. int nImageColumn = atoi(sImageBitmap);
  265. int x = drawRect.left;
  266. CRect rectImage = pBitmap->GetRectImage(nImageColumn);
  267. pBitmap->Put(nImageColumn, pDC, x , drawRect.top + (drawRect.Height() - rectImage.Height())/2, dxBitmap);
  268. }
  269. }
  271. }
  273. // Function name : CTsyslistviewex::DrawItemGrid
  274. // Description     : Draw item with grid lines
  275. // Return type : void 
  276. // Argument         : LPDRAWITEMSTRUCT lpDrawItemStruct
  277. void CTsyslistviewex::DrawItemGrid(LPDRAWITEMSTRUCT lpDrawItemStruct)
  278. {
  279. // device contextul itemului
  280. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  282. // dreptunghiul corespunzator itemului
  283. CRect rcItem(lpDrawItemStruct->rcItem);
  285. // identificatorul itemului
  286. int nItem = lpDrawItemStruct->itemID;
  289. BYTE value = 0;
  290. CFont* pOldFont = NULL;
  291. if (m_mapRowsBold.Lookup(lpDrawItemStruct->itemData, value))
  292. pOldFont = (CFont*)pDC->SelectObject(&m_boldFont);
  293. if (m_mapRowsItalic.Lookup(lpDrawItemStruct->itemData, value))
  294. {
  295. CFont* pF = (CFont*)pDC->SelectObject(&m_italicFont);
  296. if (pOldFont)
  297. pF = (CFont*)pDC->SelectObject(&m_italicBoldFont);
  298. else
  299. pOldFont = pF;
  300. }
  302. // culori
  303. COLORREF clrTextSave, clrBkSave;
  304. // get item data
  305. LV_ITEM lvi;
  306. lvi.mask = LVIF_STATE;
  307. lvi.iItem = nItem;
  308. lvi.iSubItem = 0;
  309. lvi.stateMask = 0xFFFF; // get all state flags
  310. GetItem(&lvi);
  312. BOOL bFocus = ((lvi.state & LVIS_FOCUSED) == LVIS_FOCUSED);
  313. BOOL bSelected = (GetStyle() & LVS_SHOWSELALWAYS) && (lvi.state & LVIS_SELECTED);
  314. bSelected = bSelected || (lvi.state & LVIS_DROPHILITED);
  316. // set colors if item is selected
  317. CRect rcAllLabels;
  318. GetItemRect(nItem, rcAllLabels, LVIR_BOUNDS);
  320. if (bSelected)
  321. {
  322. clrTextSave = pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  323. clrBkSave = pDC->SetBkColor(::GetSysColor(COLOR_HIGHLIGHT));
  324. }
  326. pDC->FillRect(rcAllLabels, &CBrush(::GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_WINDOW)));
  328. // draw item
  329. CBrush brush(RGB(128,128,128));
  330. GetItemRect(nItem, rcItem, LVIR_LABEL);
  331. LV_COLUMN lvc;
  332.  lvc.mask = LVCF_FMT | LVCF_WIDTH;
  333. rcItem.OffsetRect(-OFFSET,0);
  334. for(int nColumn = 0; GetColumn(nColumn, &lvc); nColumn++)
  335. {
  336. rcItem.right = rcItem.left + lvc.cx;
  338. CRect drawRect(rcItem);
  339. drawRect.InflateRect(-1,-1);
  340. pDC->FrameRect(drawRect, &brush);
  341. drawRect.OffsetRect(1,0);
  342. drawRect.InflateRect(-2,0);
  344. DrawCell(pDC,drawRect,lvc.fmt, nItem,nColumn);
  346. rcItem.left = rcItem.right;
  347. }
  349. pDC->SelectObject(pOldFont);
  351. // draw focus rectangle if item has focus
  352. if (bFocus)
  353. pDC->DrawFocusRect(rcAllLabels);
  355. // set original colors if item was selected
  356. if (bSelected)
  357. {
  358. pDC->SetTextColor(clrTextSave);
  359. pDC->SetBkColor(clrBkSave);
  360. }
  361. }
  363. // Function name : CTsyslistviewex::DrawItemNoGrid
  364. // Description     : Draw item without grid lines.
  365. // Return type : void 
  366. // Argument         : LPDRAWITEMSTRUCT lpDrawItemStruct
  367. void CTsyslistviewex::DrawItemNoGrid(LPDRAWITEMSTRUCT lpDrawItemStruct)
  368. {
  369. // device contextul itemului
  370. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  372. // dreptunghiul corespunzator itemului
  373. CRect rcItem(lpDrawItemStruct->rcItem);
  375. // identificatorul itemului
  376. int nItem = lpDrawItemStruct->itemID;
  378. BYTE value = 0;
  379. CFont* pOldFont = NULL;
  380. if (m_mapRowsBold.Lookup(lpDrawItemStruct->itemData, value))
  381. pOldFont = (CFont*)pDC->SelectObject(&m_boldFont);
  383. if (m_mapRowsItalic.Lookup(lpDrawItemStruct->itemData, value))
  384. {
  385. CFont* pF = (CFont*)pDC->SelectObject(&m_italicFont);
  386. if (pOldFont)
  387. pF = (CFont*)pDC->SelectObject(&m_italicBoldFont);
  388. else
  389. pOldFont = pF;
  390. }
  392. // culori
  393. COLORREF clrTextSave, clrBkSave;
  395. // get item data
  396. LV_ITEM lvi;
  397. lvi.mask = LVIF_STATE;
  398. lvi.iItem = nItem;
  399. lvi.iSubItem = 0;
  400. lvi.stateMask = 0xFFFF; // get all state flags
  401. GetItem(&lvi);
  403. BOOL bFocus = ((lvi.state & LVIS_FOCUSED) == LVIS_FOCUSED);
  404. BOOL bSelected = (GetStyle() & LVS_SHOWSELALWAYS) && (lvi.state & LVIS_SELECTED);
  405. bSelected = bSelected || (lvi.state & LVIS_DROPHILITED);
  407. // set colors if item is selected
  408. CRect rcAllLabels;
  409. GetItemRect(nItem, rcAllLabels, LVIR_BOUNDS);
  411. if (bSelected)
  412. {
  413. clrTextSave = pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  414. clrBkSave = pDC->SetBkColor(::GetSysColor(COLOR_HIGHLIGHT));
  415. }
  417. pDC->FillRect(rcAllLabels, &CBrush(::GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_WINDOW)));
  419. // draw item
  420. CBrush brush(RGB(0,0,0));
  421. GetItemRect(nItem, rcItem, LVIR_LABEL);
  422. LV_COLUMN lvc;
  423.  lvc.mask = LVCF_FMT | LVCF_WIDTH;
  424. rcItem.OffsetRect(-OFFSET,0);
  425. for(int nColumn = 0; GetColumn(nColumn, &lvc); nColumn++)
  426. {
  427. rcItem.right = rcItem.left + lvc.cx;
  428. CRect drawRect(rcItem);
  429. drawRect.InflateRect(-1,-1);
  430. drawRect.OffsetRect(2,0);
  431. drawRect.InflateRect(-4,0);
  433. DrawCell(pDC,drawRect,lvc.fmt, nItem,nColumn);
  435. rcItem.left = rcItem.right;
  436. }
  438. pDC->SelectObject(pOldFont);
  441. // draw focus rectangle if item has focus
  442. if (bFocus)
  443. pDC->DrawFocusRect(rcAllLabels);
  446. // set original colors if item was selected
  447. if (bSelected)
  448. {
  449. pDC->SetTextColor(clrTextSave);
  450. pDC->SetBkColor(clrBkSave);
  451. }
  452. }
  454. // Function name : CTsyslistviewex::DrawItem
  455. // Description     : Draw one item. m_fctDrawItem is set in ViewGridLines(BOOL bEnable ).
  456. // Return type : void 
  457. // Argument         : LPDRAWITEMSTRUCT lpDrawItemStruct
  458. void CTsyslistviewex::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  459. {
  460. (this->*m_fctDrawItem)(lpDrawItemStruct);
  461. }
  463. // Function name : CTsyslistviewex::HitTestEx
  464. // Description     : Check if point is in on of list's cell. Return row(return value) an column (subItem)
  465. // Return type : int 
  466. // Argument         : CPoint point
  467. // Argument         : int& subItem
  468. int CTsyslistviewex::HitTestEx(CPoint point, int& subItem)
  469. {
  470. CRect rect; int item = -1;
  471. subItem = -1;
  472. if (GetItemRect(0, rect, LVIR_LABEL))
  473. {
  474. CRect hRect = rect;
  475. hRect.OffsetRect((abs(hRect.left) - hRect.left)/2,0);
  476. item = HitTest(CPoint(int((hRect.left + hRect.right)/2), point.y));
  477. }
  478. if (item>=0)
  479. {
  480. int ccx = rect.left;
  481. LV_COLUMN lvc;lvc.mask = LVCF_WIDTH;
  482. for(int nColumn = 0; GetColumn(nColumn, &lvc); nColumn++, ccx += lvc.cx)
  483. if ((point.x >= ccx) && (point.x < ccx + lvc.cx))
  484. {
  485. subItem = nColumn;
  486. break;
  487. }
  488. }
  489. item = subItem >= 0 ? item : -1;
  490. return item;
  491. }
  493. // Function name : CTsyslistviewex::GetSubItemRect
  494. // Description     : Return the rect of subitem subItem
  495. // Return type : BOOL ; TRUE if succeeded
  496. // Argument         : int item ; item - row position
  497. // Argument         : int subItem ; subItem - column position 
  498. // Argument         : CRect & rect ; CRect to complete
  499. BOOL CTsyslistviewex::GetSubItemRect(int item, int subItem, CRect & rect)
  500. {
  501. if (subItem >= 0)
  502. if (GetItemRect(item, rect, LVIR_LABEL))
  503. {
  504. int ccx = rect.TopLeft().x;
  505. LV_COLUMN lvc;lvc.mask = LVCF_WIDTH;
  506. if (GetColumn(subItem, &lvc))
  507. {
  508. int dx = lvc.cx;
  509. for (int nColumn = 0; nColumn < subItem && GetColumn(nColumn, &lvc); nColumn++)
  510. ccx += lvc.cx;
  511. rect = CRect(CPoint(ccx,rect.TopLeft().y),CPoint(ccx + dx,rect.BottomRight().y));
  512. return TRUE;
  513. }
  514. }
  515. return FALSE;
  516. }
  518. // Function name : CTsyslistviewex::MeasureItem
  519. // Description     : see contructor CTsyslistviewex(int nHeightRel)
  520. // Return type : void 
  521. // Argument         : LPMEASUREITEMSTRUCT lpMeasureItem ; finds StructHeight of item needed to set m_nHeightRel
  522. void CTsyslistviewex::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  523. {
  524. lpMeasureItemStruct->itemHeight += m_nHeightRel;
  525. }
  527. // Function name : CTsyslistviewex::ViewGridLines
  528. // Description     : Enable or disable draw grid lines.
  529. // Return type : void 
  530. // Argument         : BOOL bEnable ; TRUE to enable
  531. void CTsyslistviewex::ViewGridLines(BOOL bEnable )
  532. {
  534. m_fctDrawItem = bEnable ? CTsyslistviewex::DrawItemGrid : CTsyslistviewex::DrawItemNoGrid;
  535. Invalidate();
  537. }
  539. // Function name : CTsyslistviewex::ExpandHeader
  540. // Description     : Try to put all columns from list control in client rect.
  541. // Return type : void 
  542. void CTsyslistviewex::ExpandHeader()
  543. {
  544. const offsetMarginHeader = 8;
  545. CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);
  546. CRect rect; GetClientRect(rect);
  547. int dxRect = rect.Width() - 2;
  548. int dxHeader = 0, i = 0; BOOL bColumn = true;
  549. int nLastColumn = pHeader->GetItemCount() - 1;
  550. if (nLastColumn >= 0)
  551. {
  552. HD_ITEM item; item.mask = HDI_WIDTH;
  553. for (i = 0; i < nLastColumn && (pHeader->GetItem(i, &item)); i++)
  554. dxHeader += item.cxy ;
  555. BOOL bStop = false;
  556. do
  557. {
  558. pHeader->GetItem(nLastColumn, &item);
  559. int icx = dxRect - dxHeader;
  560. bStop = icx >=0;
  561. if (!bStop)
  562. icx = offsetMarginHeader / 2;
  563. item.cxy = icx;
  564. pHeader->SetItem(nLastColumn, &item);
  565. if (bStop)
  566. return;
  567. ASSERT (icx >= 0);
  568. nLastColumn--;
  569. pHeader->GetItem(nLastColumn, &item);
  570. dxHeader = dxHeader - item.cxy + icx;
  571. }
  572. while (nLastColumn>=0);
  574. }
  575. }
  577. // Function name : CTsyslistviewex::AddSortCallBack
  578. // Description     : Attach to an column nColumn
  579. //   comparing function:
  580. // typedef int (*COLUMNCALLBACKCOMPARE) (const wchar_t *stringi, const wchar_t *stringj)
  581. //   return values:
  582. // -1 for stringi < stringj
  583. //  0 for stringi == stringj
  584. // +1 for stringi > stringj
  585. // Return type : void 
  586. // Argument         : int nColumn
  587. // Argument         : COLUMNCALLBACKCOMPARE pCallBack
  588. void CTsyslistviewex::AddSortCallBack(int nColumn, COLUMNCALLBACKCOMPARE pCallBack)
  589. {
  590. // Already u must call EnableSort...
  591. ASSERT (m_sortColumns.m_pListCtrl == this);
  592. // pCallBack must be nenul...
  593. ASSERT (pCallBack != NULL);
  594. m_sortColumns.Add(nColumn, pCallBack);
  595. }
  597. // Function name : CTsyslistviewex::EnableSaveHeader
  598. // Description     : Enable or disable save widths of listctrl
  599. //   Must call it before attach this list control attach to record set
  600. //   (!)In InitInstance, u must call: SetRegistryKey(AfxGetAppName());
  601. // Return type : void 
  602. // Argument         : BOOL bEnable ; TRUE to enable
  603. void CTsyslistviewex::EnableSaveHeader(BOOL bEnable)
  604. {
  605. // The control must already subclassed....
  606. ASSERT ((GetWindowLong(m_hWnd, GWL_USERDATA) & LIST_MASKCLASS) == LIST_SUBCLASSED);
  607. m_bSaveHeader = bEnable;
  608. }
  610. // Function name : CTsyslistviewex::EnableSort
  611. // Description     : Enable or disable sort procedure.
  612. // Return type : void 
  613. // Argument         : BOOL bEnable ; TRUE to enable
  614. void CTsyslistviewex::EnableSort(BOOL bEnable)
  615. {
  616. CWnd* pWnd = bEnable ? &m_wndSortHeaderEx : m_pOldHeaderCtrl;
  617. pWnd->SubclassDlgItem(0,this);
  618. m_bSorted = bEnable;
  620. m_sortColumns.AttachControl(bEnable ? this : NULL);
  621. }
  623. // Function name : CTsyslistviewex::OnColumnclick
  624. // Description     : SortClick handler (if m_bSortWhenClickHeader is set)
  625. // Return type : void 
  626. // Argument         : NMHDR* pNMHDR
  627. // Argument         : LRESULT* pResult
  628. void CTsyslistviewex::OnColumnclick(NMHDR* pNMHDR, LRESULT* pResult) 
  629. {
  630. NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
  631. *pResult = 0;
  633. if (m_bSorted)
  634. {
  635. GetAsyncKeyState(VK_CONTROL);
  636. BOOL bControl = GetAsyncKeyState(VK_CONTROL);
  638. int iNewSortColumn = pNMListView->iSubItem;
  639. BOOL bAsc = true;
  640. int nPosition = 0;
  641. BOOL bSortedColumn = m_wndSortHeaderEx.GetColumnOrder(iNewSortColumn, bAsc, nPosition);
  642. if (!bControl && !bSortedColumn)
  643. m_wndSortHeaderEx.ResetSortColumns();
  644. if (bSortedColumn)
  645. if (!bAsc)
  646. {
  647. m_wndSortHeaderEx.DeleteColumnOrder(iNewSortColumn);
  648. iNewSortColumn = -1;
  649. }
  650. else
  651. bAsc = !bAsc;
  653. if (iNewSortColumn >= 0)
  654. m_wndSortHeaderEx.SetColumnOrder(iNewSortColumn, bAsc);
  656. if (m_bSortWhenClickHeader)
  657. SortAllItems();
  658. }
  660. }
  662. // Function name : CTsyslistviewex::AttachBitmap
  663. // Description     : Attach a bitmap image to a column
  664. // Return type : BOOL 
  665. // Argument         : int nColumn ; column to put immage into
  666. // Argument         : UINT nIDBitmap ; bitmap identifier
  667. // Argument         : int nImageWidth ; bitmap width
  668. // Argument         : int nImageHeight ; bitmap height
  669. // Argument         : int nRowImage ; sub-bitmap index (for multi-icon bitmaps)
  670. BOOL CTsyslistviewex::AttachBitmap(int nColumn, UINT nIDBitmap, int nImageWidth, int nImageHeight, int nRowImage)
  671. {
  672. CTColumnBitmap* pBitmap = NULL;
  673. if (pBitmap = new CTColumnBitmap(nIDBitmap, nImageWidth, nImageHeight, nRowImage))
  674. {
  675. ASSERT(pBitmap->IsLoad());
  676. if (CTColumnBitmap* pOldBitmap = GetBitmapColumn(nColumn))
  677. delete pOldBitmap;
  678. m_bmpColumns[nColumn] = pBitmap;
  679. return TRUE;
  680. }
  681. return FALSE;
  682. }
  684. // Function name : CTHxgrid::ComposeKeyForCell
  685. // Description     : Return a key identifier for search in maps.
  686. // Return type : DWORD 
  687. // Argument         : short nIDRow
  688. // Argument         : short nColumn
  689. DWORD CTsyslistviewex::ComposeKeyForCell(USHORT nIDRow, USHORT nColumn)
  690. {
  691. return MAKELONG(nColumn,nIDRow);
  692. }
  694. // Function name : CTsyslistviewex::AttachBitmapCell
  695. // Description     : Attach a bitmap to a cell.
  696. // Return type : BOOL 
  697. // Argument         : USHORT nIDRow - cell is on item witch contain in userdata nIDRow
  698. // Argument         : USHORT nColumn - cell is on column nColumn
  699. // Argument         : UINT nIDBitmap - Resource identifier of bitmap.
  700. // Argument         : int nImageWidth - Width of bitmap cell.
  701. // Argument         : int nImageHeight - Height of bitmap cell
  702. // Argument         : int nRowImage - sub-bitmap index (for multi-icon bitmaps)
  703. BOOL CTsyslistviewex::AttachBitmapCell(USHORT nIDRow, USHORT nColumn, UINT nIDBitmap, int nImageWidth, int nImageHeight, int nRowImage)
  704. {
  705. CTColumnBitmap* pBitmap = NULL;
  706. if (pBitmap = new CTColumnBitmap(nIDBitmap, nImageWidth, nImageHeight, nRowImage))
  707. {
  708. ASSERT(pBitmap->IsLoad());
  709. if (CTColumnBitmap* pOldBitmap = GetBitmapCell(nIDRow,nColumn))
  710. delete pOldBitmap;
  711. m_bmpCells[ComposeKeyForCell(nIDRow, nColumn)] = pBitmap;
  712. return TRUE;
  713. }
  714. return FALSE;
  715. }
  717. // Function name : CTsyslistviewex::GetBitmapColumn
  718. // Description     : Return pointer to CTColumnBitmap object if nColumn is registered
  719. // as column of bitmaps.
  720. // Return type : CTColumnBitmap* 
  721. // Argument         : int nColumn
  722. CTColumnBitmap* CTsyslistviewex::GetBitmapColumn(int nColumn)
  723. {
  724. CTColumnBitmap* pOldBitmap = NULL;
  725. m_bmpColumns.Lookup(nColumn, pOldBitmap);
  726. return pOldBitmap;
  727. }
  729. // Function name : CTsyslistviewex::GetBitmapCell
  730. // Description     : Return pointer to CTColumnBitmap object if cell from (Item with nIDRow userdata,nColumn) is registered
  731. // as bitmap cell.
  732. // Return type : CTColumnBitmap* 
  733. // Argument         : DWORD nIDRow
  734. // Argument         : int nColumn
  735. CTColumnBitmap* CTsyslistviewex::GetBitmapCell(DWORD nIDRow, int nColumn)
  736. {
  737. CTColumnBitmap* pOldBitmap = GetBitmapColumn(nColumn);
  738. if (pOldBitmap == NULL)
  739. m_bmpCells.Lookup(ComposeKeyForCell((USHORT)nIDRow,(USHORT)nColumn), pOldBitmap);
  740. return pOldBitmap;
  741. }
  743. // Function name : CTsyslistviewex::SortAllItems
  744. // Description     : Call sort items specified by lpszColumnsSort. lpszColumnsSort can be: _T("0,2D,1A"),
  745. //   and this means that order of sort is column 0 ascending, the next, 2 descending
  746. //   This procedure take all column for order from lpszColumnsSort, and reset old
  747. //   columns sort.
  748. //   (!) Stop relay event in all recordsets in SortAllItems().
  749. // Return type : void 
  750. // Argument         : LPCTSTR lpszColumnsSort
  751. void CTsyslistviewex::SortAllItems(LPCTSTR lpszColumnsSort)
  752. {
  753. // Already call EnableSort...
  754. ASSERT ( m_bSorted );
  755. LPCTSTR lpszCurrentColumnsSort = lpszColumnsSort;
  756. CString sRegisterColumnsSort; sRegisterColumnsSort.Empty();
  757. if (GetRegisteredSort(sRegisterColumnsSort))
  758. lpszCurrentColumnsSort = (LPCTSTR)sRegisterColumnsSort;
  759. CString column; int i = 0;
  760. m_wndSortHeaderEx.ResetSortColumns();
  761. do 
  762. {
  763. AfxExtractSubString(column, lpszCurrentColumnsSort, i++, ',');
  764. if (!column.IsEmpty())
  765. {
  766. TCHAR cAsc = column[column.GetLength()-1];
  767. BOOL bAsc = true;
  768. if (!iswdigit(cAsc))
  769. {
  770. ASSERT (cAsc == 'A' || cAsc == 'D');
  771. if (cAsc == 'D')
  772. bAsc = !bAsc;
  773. column = column.Left(column.GetLength()-1);
  774. }
  775. int nColumn = atoi((LPCTSTR)column);
  776. m_wndSortHeaderEx.SetColumnOrder(nColumn, bAsc);
  777. }
  778. }
  779. while (!column.IsEmpty());
  780. SortAllItems();
  781. }
  783. // Function name : CTsyslistviewex::SortAllItems
  784. // Description     : sort all items according to header flags
  785. //   (!) Stop relay event in all recordsets.
  786. // Return type : void 
  787. void CTsyslistviewex::SortAllItems()
  788. {
  789. ASSERT ( m_bSorted );
  790. m_sortColumns.ResetOrderColumn();
  791. int column = 0;
  792. BOOL bAsc = true;
  793. for (int iPosition = 1; m_wndSortHeaderEx.GetPositionColumn(iPosition, bAsc, column); iPosition++ )
  794. m_sortColumns.AddOrderColumn(column,bAsc ? 1 : -1);
  795. if (m_sortColumns.GetCountOrderColumn())
  796. {
  797. AfxGetApp()->DoWaitCursor(1);
  798. m_sortColumns.Sort();
  799. AfxGetApp()->DoWaitCursor(-1);
  800. }
  801. SaveHeader();
  802. }
  804. // Function name : CTsyslistviewex::GetCountColumn
  805. // Description     : Return number of columns from control.
  806. // Return type : int ; columns count
  807. int CTsyslistviewex::GetCountColumn()
  808. {
  809. return ((CHeaderCtrl*)GetDlgItem(0))->GetItemCount();
  810. }
  812. // Function name : CTsyslistviewex::Progress
  813. // Description     : displays the progress bar
  814. // Return type : void 
  815. // Argument         : int nPercent ; 0 - progress bar set top middle, 100 progress bar is off
  816. void CTsyslistviewex::Progress(int nPercent)
  817. {
  818. if (!m_wndProgress.GetSafeHwnd())
  819. {
  820. const int dyProgress = 20;
  821. CRect rect; GetWindowRect(rect);
  822. ScreenToClient(rect);
  823. int dxProgress = rect.Width() * 3 / 4;
  824. rect.top += (rect.Height() - dyProgress) / 2;
  825. rect.bottom = rect.top + dyProgress ;
  826. rect.left += (rect.Width() - dxProgress) / 2;
  827. rect.right = rect.left + dxProgress;
  828. m_wndProgress.Create(WS_CHILD | WS_BORDER | WS_VISIBLE, rect, this, GetDlgCtrlID());
  829. }
  830. m_wndProgress.SetPos(nPercent);
  831. if (nPercent == 100)
  832. m_wndProgress.DestroyWindow();
  833. }
  835. // Function name : CTsyslistviewex::ResetBoldLines
  836. // Description     : reset all bold lines
  837. // Return type : void 
  838. void CTsyslistviewex::ResetBoldLines()
  839. {
  840. m_mapRowsBold.RemoveAll();
  841. }
  843. // Function name : CTsyslistviewex::SetBoldRow
  844. // Description     : If lParam == NULL then set bold for focused line.
  845. // Return type : void 
  846. // Argument         : LPARAM lParam
  847. // Argument         : BOOL bBold
  848. // Argument         : BOOL bInvalidate
  849. void CTsyslistviewex::SetBoldRow(LPARAM lParam, BOOL bBold, BOOL bInvalidate)
  850. {
  851. if (m_boldFont.GetSafeHandle())
  852. {
  853. if (!lParam)
  854. lParam = GetItemData(GetNextItem(-1, LVNI_FOCUSED));
  855. if (bBold)
  856. m_mapRowsBold[lParam] = 1;
  857. else
  858. m_mapRowsBold.RemoveKey(lParam);
  860. if (bInvalidate)
  861. Invalidate(false);
  862. }
  863. }
  865. // Function name : CTsyslistviewex::SetItalicRow
  866. // Description     : If lParam == NULL then set italic for focused line.
  867. // Return type : void 
  868. // Argument         : LPARAM lParam
  869. // Argument         : BOOL bItalic
  870. // Argument         : BOOL bInvalidate
  871. void CTsyslistviewex::SetItalicRow(LPARAM lParam, BOOL bItalic, BOOL bInvalidate)
  872. {
  873. if (m_italicFont.GetSafeHandle())
  874. {
  875. if (!lParam)
  876. lParam = GetItemData(GetNextItem(-1, LVNI_FOCUSED));
  877. if (bItalic)
  878. m_mapRowsItalic[lParam] = 1;
  879. else
  880. m_mapRowsItalic.RemoveKey(lParam);
  882. if (bInvalidate)
  883. Invalidate(false);
  884. }
  885. }
  887. // Function name : CTsyslistviewex::DeselectAll
  888. // Description     : Deselect all items from control
  889. // Return type : void 
  890. void CTsyslistviewex::DeselectAll()
  891. {
  892. int iCurrent = GetNextItem(-1, LVIS_SELECTED);
  893. while (iCurrent >= 0)
  894. {
  895. SetItemState(iCurrent, ~LVIS_SELECTED, LVIS_SELECTED);
  896. iCurrent = GetNextItem(iCurrent, LVIS_SELECTED);
  897. }
  898. }
  900. // Function name : CTsyslistviewex::SelectItem
  901. // Description     : Deselect all items, and select one item.
  902. // Return type : void 
  903. // Argument         : int i ; item index
  904. void CTsyslistviewex::SelectItem(int i)
  905. {
  906. DeselectAll();
  907. SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
  908. EnsureVisible(i,false);
  909. }
  911. // Function name : CTsyslistviewex::GetHeaderSortString
  912. // Description     : Called in SaveAllItems(), returns header format string
  913. // Return type : CString ; sort header as string, for save it in the registry
  914. CString CTsyslistviewex::GetHeaderSortString()
  915. {
  916. CString result; result.Empty();
  917. if (m_bSorted)
  918. {
  919. int nPosition = 1;
  920. int nColumn = NULL;
  921. BOOL bAsc = true;
  922. while (m_wndSortHeaderEx.GetPositionColumn(nPosition++, bAsc, nColumn))
  923. {
  924. CString sColumn; sColumn.Format(_T("%i%s,"),nColumn, (bAsc ? _T("") : _T("D")));
  925. result += sColumn;
  926. }
  927. if (!result.IsEmpty())
  928. result = result.Left(result.GetLength() - 1);
  929. }
  930. return result;
  931. }
  933. // Function name : CTsyslistviewex::GetHeaderString
  934. // Description     : Return the header format string
  935. // Return type : CString ; header formated as: ColumnName1:FormatColumn1:WidthColumn1,...
  936. CString CTsyslistviewex::GetHeaderString()
  937. {
  938. CString result; result.Empty();
  939. LV_COLUMN column; 
  940.    TCHAR pszText[MAX_PATH];
  941.  column.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH;
  942.  column.pszText = pszText;
  943.  column.cchTextMax = MAX_PATH;
  944. for (int i = 0; GetColumn(i, &column); i++)
  945. {
  946. TCHAR f = TCHAR('L');
  947. switch (column.fmt & LVCFMT_JUSTIFYMASK)
  948. {
  949. case LVCFMT_RIGHT:
  950. f = TCHAR('R');
  951. break;
  952. case LVCFMT_CENTER:
  953. f = TCHAR('C');
  954. break;
  955. }
  956. CString w; w.Format(_T("%i"), column.cx);
  957. result = result + column.pszText + TCHAR(':') + w + TCHAR(':') + f + TCHAR(',');
  958. column.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH;
  959. }
  960. return result.Left(result.GetLength() - (result.IsEmpty() ? 0 : 1)); // last ,
  961. }
  963. // Function name : CTsyslistviewex::OnNotify
  964. // Description     : Called when item width changed. If necessarly the widths are saved in registry.
  965. // Return type : BOOL 
  966. // Argument         : WPARAM wParam
  967. // Argument         : LPARAM lParam
  968. // Argument         : LRESULT* pResult
  969. BOOL CTsyslistviewex::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult) 
  970. {
  971. if ((int)wParam == 0)
  972. if (GetDlgItem(0)->IsWindowVisible())
  973. {
  974. switch (((HD_NOTIFY*)lParam)->hdr.code)
  975. {
  976. case HDN_ITEMCHANGEDA:
  977. case HDN_ITEMCHANGEDW:
  978. SaveHeader();
  979. break;
  980. }
  981. }
  983. return CListCtrl::OnNotify(wParam, lParam, pResult);
  984. }
  986. // Function name : CTsyslistviewex::NeedCX
  987. // Description     : Calc total width of listctrl
  988. // Return type : int ; listctrl width
  989. int CTsyslistviewex::NeedCX()
  990. {
  991. int result = 0;
  992. LV_COLUMN lvc; lvc.mask = LVCF_WIDTH;
  993. for (int i = 0; GetColumn(i, &lvc); i++)
  994. result += lvc.cx;
  995. return result;
  996. }
  998. // Function name : CTsyslistviewex::NeedCY
  999. // Description     : Calc partial visible height of listctrl
  1000. // Return type : int ; visible height of listctrl
  1001. int CTsyslistviewex::NeedCY()
  1002. {
  1003. CRect rect; GetClientRect(rect); int hRect = rect.Height();
  1004. CRect rcItem;
  1005. int result = 0;
  1006. for (int i = GetTopIndex(); GetItemRect(i, rcItem,LVIR_LABEL) && result + rcItem.Height() < hRect; i++ )
  1007. result += rcItem.Height();
  1008. return result;
  1009. }
  1011. // Function name : CTsyslistviewex::OnChar
  1012. // Description     : Treat specialy CTRL+S for sorting, if m_bSortWhenClickHeader is FALSE
  1013. // Return type : void 
  1014. // Argument         : UINT nChar
  1015. // Argument         : UINT nRepCnt
  1016. // Argument         : UINT nFlags
  1017. void CTsyslistviewex::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1018. {
  1019. if (!m_bSortWhenClickHeader)
  1020. if (GetKeyState(VK_CONTROL) < 0)
  1021. if (nChar == scanCodeS)
  1022. SortAllItems();
  1024. CListCtrl::OnChar(nChar, nRepCnt, nFlags);
  1025. }
  1027. // Function name : CTsyslistviewex::GetCountRowsBold
  1028. // Description     : Return count of bold rows
  1029. // Return type : int 
  1030. int CTsyslistviewex::GetCountRowsBold()
  1031. {
  1032. return m_mapRowsBold.GetCount();
  1033. }
  1035. // Function name : CTsyslistviewex::GetCountRowsItalic
  1036. // Description     : Return count of italic rows
  1037. // Return type : int 
  1038. int CTsyslistviewex::GetCountRowsItalic()
  1039. {
  1040. return m_mapRowsItalic.GetCount();
  1041. }
  1043. // Function name : CTsyslistview32::SetHeader
  1044. // Description     : 
  1045. // Return type : BOOL 
  1046. // Argument         : CListCtrl * pList
  1047. // Argument         : CString newHeader
  1048. BOOL CTsyslistviewex::SetHeader(CListCtrl * pList, CString newHeader)
  1049. {
  1050. CHeaderCtrl* pHeader = (CHeaderCtrl*)pList->GetDlgItem(0);
  1051. if (pHeader)
  1052. {
  1053. while (pHeader->GetItemCount()) pHeader->DeleteItem(0);
  1054. int i = 0; CString rString; rString.Empty();
  1055. CMap<TCHAR,TCHAR,int,int> justifyMap;
  1056. justifyMap['L'] = LVCFMT_LEFT;
  1057. justifyMap['C'] = LVCFMT_CENTER;
  1058. justifyMap['R'] = LVCFMT_RIGHT;
  1060. do
  1061. {
  1062. AfxExtractSubString(rString, newHeader, i, ',');
  1063. if (!rString.IsEmpty())
  1064. {
  1065. CString columnName;
  1066. AfxExtractSubString(columnName, rString, 0, ':');
  1068. CString columnWidth;
  1069. AfxExtractSubString(columnWidth, rString, 1, ':');
  1070. if (columnWidth.IsEmpty()) columnWidth = _T("128"); // default value
  1072. CString columnJustify;
  1073. AfxExtractSubString(columnJustify, rString, 2, ':');
  1074. int justify = LVCFMT_LEFT;
  1075. if (!columnJustify.IsEmpty())
  1076. justifyMap.Lookup(columnJustify[0], justify);
  1077. pList->InsertColumn(i,columnName, justify, _wtoi((const wchar_t*)columnWidth.GetBuffer(0)));
  1078. i++;
  1079. }
  1080. } while (!rString.IsEmpty());
  1081. }
  1082. return (pHeader != NULL);
  1083. }