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

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

对话框与窗口

开发平台：

Visual C++

XTListBase.cpp：源码内容
  1. // XTListCtrl.cpp : implementation of the CXTListCtrl class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPResourceManager.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPWinThemeWrapper.h"
  26. #include "Common/XTPSystemHelpers.h"
  27. #include "Common/XTPDrawHelpers.h"
  29. #include "XTGlobal.h"
  30. #include "XTVC50Helpers.h"
  31. #include "XTHeaderCtrl.h"
  32. #include "XTListBase.h"
  33. #include "XTRegistryManager.h"
  34. #include "XTColorRef.h"
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  42. CXTListBase::CXTListBase()
  43. : m_bAutoFont(false)
  44. , m_bAutoSave(false)
  45. , m_bRowColor(false)
  46. , m_bListColor(false)
  47. , m_bSortColor(false)
  48. , m_bAscending(true)
  49. , m_bNoColSizing(false)
  50. , m_nMinColWidth(0)
  51. , m_nMaxColWidth(0)
  52. , m_nSortedCol(-1)
  53. , m_crListText((COLORREF)-1)
  54. , m_crListBack((COLORREF)-1)
  55. , m_crSortText((COLORREF)-1)
  56. , m_crSortBack((COLORREF)-1)
  57. {
  58. RefreshMetrics();
  59. }
  61. CXTListBase::~CXTListBase()
  62. {
  63. }
  65. void CXTListBase::RefreshMetrics()
  66. {
  67. // update column metrics.
  68. m_nMaxColWidth = ::GetSystemMetrics(SM_CXFULLSCREEN);
  70. CXTColorRef crSortBack(GetListBackColor());
  71. crSortBack.subtract(RGB(8, 8, 8));
  73. // set sort background and text colors
  74. m_crSortText = GetListTextColor();
  75. m_crSortBack = crSortBack;
  76. }
  78. CXTListBase::ROWCOLOR* CXTListBase::Lookup(int iRow)
  79. {
  80. if (m_arRowColor.GetCount() == 0)
  81. return NULL;
  83. for (POSITION pos = m_arRowColor.GetHeadPosition(); pos;)
  84. {
  85. ROWCOLOR& rowColor = m_arRowColor.GetNext(pos);
  86. if (rowColor.iRow == iRow)
  87. return &rowColor;
  88. }
  89. return NULL;
  90. }
  92. void CXTListBase::SetRowColor(int iRow, COLORREF crText, COLORREF crBack, BOOL bRedraw /*= TRUE*/)
  93. {
  94. ROWCOLOR* lpRowClr = Lookup(iRow);
  95. if (lpRowClr)
  96. {
  97. lpRowClr->crText = crText;
  98. lpRowClr->crBack = crBack;
  99. }
  100. else
  101. {
  102. // initialize row color struct.
  103. ROWCOLOR rowclr;
  104. rowclr.iRow = iRow;
  105. rowclr.crText = crText;
  106. rowclr.crBack = crBack;
  108. m_arRowColor.AddHead(rowclr);
  109. }
  111. if (!m_pListCtrl || !m_pListCtrl->GetSafeHwnd() || !bRedraw)
  112. return;
  114. // Redraw window if row is visible
  115. const int nTopIndex = m_pListCtrl->GetTopIndex();
  116. const int nBotIndex = nTopIndex + m_pListCtrl->GetCountPerPage();
  117. if (iRow >= nTopIndex && iRow <= nBotIndex)
  118. {
  119. m_pListCtrl->RedrawWindow();
  120. }
  122. }
  124. void CXTListBase::SetRowColor(ROWCOLOR* lpRowColor, BOOL bRedraw)
  125. {
  126. SetRowColor(lpRowColor->iRow, lpRowColor->crText, lpRowColor->crBack, bRedraw);
  127. }
  129. void CXTListBase::RemoveRowColors()
  130. {
  131. m_arRowColor.RemoveAll();
  132. }
  134. void CXTListBase::ImplAttach(CListCtrl* pListCtrl)
  135. {
  136. m_pListCtrl = (CListCtrl_Friendly *)pListCtrl;
  137. }
  139. bool CXTListBase::MoveRow(int nFrom, int nTo)
  140. {
  141. // Can't move to the same place, or from or to a negative index
  142. if ((nFrom == nTo) || (nFrom < 0) || (nTo < 0))
  143. {
  144. return false;
  145. }
  147. // First Copy the row to the new location
  148. int iRemove = CopyRow(nFrom, nTo);
  149. if (iRemove != -1)
  150. {
  151. return (m_pListCtrl->DeleteItem(iRemove) == TRUE);
  152. }
  154. return false;
  155. }
  157. int CXTListBase::CopyRow(int nFrom, int nTo)
  158. {
  159. // Can't move to the same place, or from or to a negative index
  160. if ((nFrom == nTo) || (nFrom < 0) || (nTo < 0))
  161. {
  162. return -1;
  163. }
  165. //Copy the row to the new index
  166. TCHAR szLabel[ 256 ];
  168. LV_ITEM lvi;
  169. ::ZeroMemory(&lvi, sizeof(LV_ITEM));
  171. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  172. lvi.pszText = szLabel;
  173. lvi.iItem = nFrom;
  174. lvi.cchTextMax = _countof(szLabel);
  175. m_pListCtrl->GetItem(&lvi);
  177. lvi.iItem = nTo;
  178. m_pListCtrl->InsertItem(&lvi);
  180. // If row has been inserted before original
  181. // increment the original
  182. if (nFrom > nTo)
  183. {
  184. nFrom++;
  185. }
  187. //Loop through subitems
  188. int i;
  189. for (i = 1; i < GetColumnCount(); i++)
  190. {
  191. CString strLabel = m_pListCtrl->GetItemText(nFrom, i);
  192. if (!strLabel.IsEmpty())
  193. {
  194. m_pListCtrl->SetItemText(
  195. nTo, i, strLabel);
  196. }
  197. }
  199. return nFrom;
  200. }
  202. int CXTListBase::GetColumnCount()
  203. {
  204. // if we are not in report mode return error.
  205. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  206. return -1;
  208. // get a pointer to the header control, if NULL return error.
  209. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  210. if (pHeaderCtrl == NULL)
  211. return -1;
  213. return pHeaderCtrl->GetItemCount();
  214. }
  216. BOOL CXTListBase::ModifyExtendedStyle(DWORD dwRemove, DWORD dwAdd)
  217. {
  218. ASSERT(m_pListCtrl != NULL && m_pListCtrl->m_hWnd != NULL);
  219. if (!m_pListCtrl)
  220. return FALSE;
  222. DWORD dwStyle = (DWORD)::SendMessage(m_pListCtrl->m_hWnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
  223. DWORD dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
  225. if (dwStyle == dwNewStyle)
  226. return FALSE;
  228. ::SendMessage(m_pListCtrl->m_hWnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwNewStyle);
  229. return TRUE;
  230. }
  232. void CXTListBase::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  233. {
  234. NMLVCUSTOMDRAW* lpLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  235. *pResult = CDRF_DODEFAULT;
  237. switch (lpLVCD->nmcd.dwDrawStage)
  238. {
  239. case CDDS_PREPAINT:
  240. *pResult = CDRF_NOTIFYITEMDRAW;
  241. break;
  243. case CDDS_PREPAINT | CDDS_ITEM:
  244. *pResult = CDRF_NOTIFYSUBITEMDRAW;
  245. break;
  247. case CDDS_PREPAINT | CDDS_ITEM | CDDS_SUBITEM:
  248. {
  249. ROWCOLOR* lpRowColor = Lookup((int)lpLVCD->nmcd.dwItemSpec);
  250. BOOL bUseSortColor = (m_bSortColor && (lpLVCD->iSubItem == m_nSortedCol));
  251. BOOL bUseRowColor = (m_bRowColor && lpRowColor);
  253. // if the item is selected use system default.
  254. if (bUseRowColor && m_pListCtrl->GetItemState(
  255. (int)lpLVCD->nmcd.dwItemSpec, LVIS_SELECTED) == LVIS_SELECTED)
  256. {
  257. bUseRowColor = FALSE;
  258. }
  260. // if the window is disabled use system default.
  261. if (!m_pListCtrl->IsWindowEnabled())
  262. {
  263. lpLVCD->clrText = ::GetSysColor(COLOR_WINDOWTEXT);
  264. lpLVCD->clrTextBk = ::GetSysColor(COLOR_3DFACE);
  265. }
  267. // user defined sort color.
  268. else if (bUseSortColor && !bUseRowColor)
  269. {
  270. lpLVCD->clrText = GetSortTextColor();
  271. lpLVCD->clrTextBk = GetSortBackColor();
  272. }
  274. // use user defined row color.
  275. else if (bUseRowColor)
  276. {
  277. lpLVCD->clrText = lpRowColor->crText;
  278. lpLVCD->clrTextBk = lpRowColor->crBack;
  280. if (bUseSortColor)
  281. {
  282. CXTColorRef crTextBack(lpLVCD->clrTextBk);
  283. crTextBack.blend(GetSortBackColor(), 50);
  284. lpLVCD->clrTextBk = crTextBack;
  285. }
  286. }
  288. // user defined list color.
  289. else if (m_bListColor)
  290. {
  291. lpLVCD->clrText = GetListTextColor();
  292. lpLVCD->clrTextBk = GetListBackColor();
  293. }
  295. // default color.
  296. else
  297. {
  298. lpLVCD->clrText = ::GetSysColor(COLOR_WINDOWTEXT);
  299. lpLVCD->clrTextBk = ::GetSysColor(COLOR_WINDOW);
  300. }
  302. break;
  303. }
  304. }
  305. }
  307. int CXTListBase::SetSortImage(int nCol, BOOL bAsc)
  308. {
  309. int iPrev = m_nSortedCol;
  311. m_nSortedCol = nCol;
  312. m_bAscending = (bAsc == TRUE);
  314. CXTHeaderCtrl* pHeaderCtrl = DYNAMIC_DOWNCAST(CXTHeaderCtrl, m_pListCtrl->GetDlgItem(0));
  315. if (pHeaderCtrl && ::IsWindow(pHeaderCtrl->m_hWnd))
  316. {
  317. return pHeaderCtrl->SetSortImage(nCol, bAsc);
  318. }
  320. return iPrev;
  321. }
  323. BOOL CXTListBase::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  324. {
  325. HD_NOTIFY *pHDNotify = (HD_NOTIFY*)lParam;
  327. switch (pHDNotify->hdr.code)
  328. {
  329. case HDN_ITEMCLICKA:
  330. case HDN_ITEMCLICKW:
  331. {
  332. CXTFlatHeaderCtrl* pHeaderCtrl = GetFlatHeaderCtrl();
  333. if (pHeaderCtrl)
  334. {
  335. // left mouse button.
  336. if (pHDNotify->iButton == 0)
  337. {
  338. if (pHDNotify->iItem == m_nSortedCol)
  339. {
  340. m_bAscending = !m_bAscending;
  341. }
  342. else
  343. {
  344. m_bAscending = true;
  345. }
  346. }
  348. // right mouse button.
  349. else if (pHDNotify->iButton == 1)
  350. {
  351. m_bAscending = pHeaderCtrl->GetAscending() ? true : false;
  352. }
  353. else
  354. {
  355. break;
  356. }
  358. // set sort image for header.
  359. m_nSortedCol = pHDNotify->iItem;
  360. pHeaderCtrl->SetSortImage (m_nSortedCol, m_bAscending);
  362. // sort list.
  363. SortList (m_nSortedCol, m_bAscending);
  364. }
  365. }
  366. break;
  368. case HDN_ITEMCHANGINGA:
  369. case HDN_ITEMCHANGINGW:
  370. case HDN_ENDTRACK:
  371. {
  372. if (pHDNotify->pitem->mask & HDI_WIDTH)
  373. {
  374. if (pHDNotify->pitem->cxy < m_nMinColWidth)
  375. pHDNotify->pitem->cxy = m_nMinColWidth;
  376. }
  377. }
  378. break;
  380. case HDN_DIVIDERDBLCLICKA:
  381. case HDN_DIVIDERDBLCLICKW:
  382. case HDN_BEGINTRACKW:
  383. case HDN_BEGINTRACKA:
  384. {
  385. if (!m_bNoColSizing)
  386. break;
  388. *pResult = TRUE;
  389. return TRUE;
  390. }
  391. }
  393. return m_pListCtrl->CListCtrl::OnNotify(wParam, lParam, pResult);
  394. }
  396. bool CXTListBase::SortList(int nCol, bool bAscending)
  397. {
  398. #ifdef _DEBUG
  399. TRACE2("Column sort on column index %d, ascending=%dn", nCol, bAscending);
  400. #else
  401. UNREFERENCED_PARAMETER(nCol);
  402. UNREFERENCED_PARAMETER(bAscending);
  403. #endif
  405. return true;
  406. }
  408. int CXTListBase::AddColumn(LPCTSTR lpszColHeading, int nWidth/*= -1*/, int nFormat/*= LVCFMT_LEFT*/)
  409. {
  410. // if we are not in report mode return error.
  411. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  412. return -1;
  414. // get a pointer to the header control, if NULL return error.
  415. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  416. if (pHeaderCtrl == NULL)
  417. return -1;
  419. int iIndex = pHeaderCtrl->GetItemCount();
  420. if (nWidth == -1)
  421. {
  422. // Get the column width of the previous column from header control
  423. HD_ITEM hd_item;
  424. hd_item.mask = HDI_WIDTH;               //indicate that we want the width
  425. pHeaderCtrl->GetItem(iIndex - 1, &hd_item);
  426. nWidth = hd_item.cxy;
  427. }
  429. return m_pListCtrl->InsertColumn(iIndex, lpszColHeading, nFormat, nWidth, iIndex);
  430. }
  432. bool CXTListBase::BuildColumns(int nCols, int* nWidth, int* nColString)
  433. {
  434. int i;
  435. for (i = 0; i < nCols; ++i)
  436. {
  437. CString strColumn;
  438. if (!strColumn.LoadString(nColString[i]))
  439. {
  440. }
  442. if (m_pListCtrl->InsertColumn(i, strColumn, LVCFMT_LEFT, nWidth[i], i) == -1)
  443. {
  444. return false;
  445. }
  446. }
  448. return true;
  449. }
  451. bool CXTListBase::BuildColumns(int nCols, int* nWidth, CString* strColString)
  452. {
  453. int i;
  454. for (i = 0; i < nCols; ++i)
  455. {
  456. if (m_pListCtrl->InsertColumn(i, strColString[i], LVCFMT_LEFT, nWidth[i], i) == -1)
  457. {
  458. return false;
  459. }
  460. }
  462. return true;
  463. }
  465. int CXTListBase::HitTestEx(CPoint& point, int* nCol) const
  466. {
  467. int colnum = 0;
  468. int row = m_pListCtrl->HitTest(point, NULL);
  470. if (nCol) *nCol = 0;
  472. // Make sure that the ListView is in LVS_REPORT
  473. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  474. return row;
  476. // Get the top and bottom row visible
  477. row = m_pListCtrl->GetTopIndex();
  478. int bottom = row + m_pListCtrl->GetCountPerPage();
  479. if (bottom > m_pListCtrl->GetItemCount())
  480. bottom = m_pListCtrl->GetItemCount();
  482. // get a pointer to the header control, if NULL return error.
  483. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  484. if (pHeaderCtrl == NULL)
  485. return -1;
  487. // Get the number of columns
  488. int nColumnCount = pHeaderCtrl->GetItemCount();
  490. // Loop through the visible rows
  491. for (; row <= bottom; row++)
  492. {
  493. // Get bounding rect of item and check whether point falls in it.
  494. CRect rect;
  495. m_pListCtrl->GetItemRect(row, &rect, LVIR_BOUNDS);
  496. if (rect.PtInRect(point))
  497. {
  498. // Now find the column
  499. for (colnum = 0; colnum < nColumnCount; colnum++)
  500. {
  501. int colwidth = m_pListCtrl->GetColumnWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, colnum));
  502. if (point.x >= rect.left
  503. && point.x <= (rect.left + colwidth))
  504. {
  505. if (nCol) *nCol = colnum;
  506. return row;
  507. }
  508. rect.left += colwidth;
  509. }
  510. }
  511. }
  512. return -1;
  513. }
  515. bool CXTListBase::SubclassHeader(bool bBoldFont/*= false*/)
  516. {
  517. // if we are not in report mode return false.
  518. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  519. return false;
  521. // header was already subclassed!
  522. if (::IsWindow(m_flatHeader.GetSafeHwnd()))
  523. return false;
  525. // Get the windows handle to the header control for the
  526. // list control then subclass the control.
  527. HWND hWndHeader = _xtGetHeaderCtrl()->GetSafeHwnd();
  528. if (!m_flatHeader.SubclassWindow (hWndHeader))
  529. return false;
  531. // finish header initialization.
  532. m_flatHeader.InitializeHeader(bBoldFont);
  533. return true;
  534. }
  536. void CXTListBase::AutoSaveColumns(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault)
  537. {
  538. m_bAutoSave = true;
  540. // initialize registry strings.
  541. if (lpszSection == NULL)
  542. m_strSection = _T("Settings");
  543. else
  544. m_strSection = lpszSection;
  546. if (lpszEntry == NULL)
  547. m_strEntry = _T("Column Info");
  548. else
  549. m_strEntry = lpszEntry;
  551. if (lpszDefault != NULL)
  552. m_strDefault = lpszDefault;
  554. LoadColumnWidths();
  555. }
  557. void CXTListBase::SaveColumnWidths()
  558. {
  559. // if we are not in report mode return.
  560. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  561. return;
  563. // get a pointer to the header control.
  564. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  565. if (pHeaderCtrl == NULL)
  566. return;
  568. CString strValue;
  569. int i;
  570. for (i = 0; i < pHeaderCtrl->GetItemCount(); ++i)
  571. {
  572. CString strTemp;
  573. strTemp.Format(_T("%d,"), m_pListCtrl->GetColumnWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, i)));
  574. strValue += strTemp;
  575. }
  577. CXTRegistryManager regManager;
  578. regManager.WriteProfileString(m_strSection, m_strEntry, strValue);
  579. }
  581. void CXTListBase::LoadColumnWidths()
  582. {
  583. // if we are not in report mode return.
  584. if ((GetWindowLong(m_pListCtrl->m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
  585. return;
  587. // get a pointer to the header control.
  588. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  589. if (pHeaderCtrl == NULL)
  590. return;
  592. int i;
  593. for (i = 0; i < pHeaderCtrl->GetItemCount(); ++i)
  594. SetStoredWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, i));
  595. }
  597. void CXTListBase::SetStoredWidth(int nCol)
  598. {
  599. int nWidth = GetStoredWidth(nCol);
  600. m_pListCtrl->SetColumnWidth(nCol, nWidth);
  601. }
  603. int CXTListBase::GetStoredWidth(int nCol)
  604. {
  605. // get the value from the registry.
  606. CXTRegistryManager regManager;
  607. CString strValue = regManager.GetProfileString(
  608. m_strSection, m_strEntry, m_strDefault);
  610. // extract the sub string to get the column width.
  611. CString strSubString;
  612. AfxExtractSubString(strSubString, strValue, nCol, _T(','));
  614. // return the width from the registry.
  615. return _ttoi(strSubString);
  616. }
  618. void CXTListBase::OnDestroy()
  619. {
  620. if (m_bAutoSave) SaveColumnWidths();
  621. }
  623. void CXTListBase::AutoSizeColumn(int nCol/*= -1*/)
  624. {
  625. // Call this after your list control is filled
  626. m_pListCtrl->SetRedraw (FALSE);
  628. int nMinCol = nCol < 0 ? 0 : nCol;
  629. int nMaxCol = nCol < 0 ? GetColumnCount()-1 : nCol;
  631. // get a pointer to the header control.
  632. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  633. if (!::IsWindow(pHeaderCtrl->GetSafeHwnd()))
  634. return;
  636. for (nCol = nMinCol; nCol <= nMaxCol; nCol++)
  637. {
  638. m_pListCtrl->SetColumnWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, nCol), LVSCW_AUTOSIZE);
  639. int wc1 = m_pListCtrl->GetColumnWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, nCol));
  640. int wc2 = 0;
  642. CWindowDC dc(NULL);
  643. CFont* pOF = dc.SelectObject(pHeaderCtrl->GetFont());
  645. TCHAR szColText[256];
  646. szColText[0] = _T('');
  648. LVCOLUMN lvc;
  649. lvc.mask = LVCF_TEXT;
  650. lvc.pszText = szColText;
  651. lvc.cchTextMax = _countof(szColText);
  653. ListView_GetColumn(m_pListCtrl->m_hWnd, nCol, &lvc);
  655. CSize size = dc.GetTextExtent(szColText);
  656. wc2 = size.cx;
  658. dc.SelectObject(pOF);
  660. wc2 += 12; // add padding.
  662. CXTFlatHeaderCtrl* pFlatHeaderCtrl = GetFlatHeaderCtrl();
  663. if (pFlatHeaderCtrl && pFlatHeaderCtrl->HasSortArrow())
  664. {
  665. if (m_nSortedCol == Header_OrderToIndex(pHeaderCtrl->m_hWnd, nCol))
  666. wc2 += 24; // add padding.
  667. }
  669. int wc = __max(m_nMinColWidth, __max(wc1, wc2));
  671. if (wc > m_nMaxColWidth)
  672. wc = m_nMaxColWidth;
  674. // set the column width.
  675. m_pListCtrl->SetColumnWidth(nCol, wc);
  676. }
  678. m_pListCtrl->SetRedraw();
  679. m_pListCtrl->Invalidate();
  680. }
  682. BOOL CXTListBase::OnEraseBkgnd(CDC* /*pDC*/)
  683. {
  684. return TRUE;
  685. }
  687. LRESULT CXTListBase::OnPrintClient(WPARAM wParam, LPARAM lParam)
  688. {
  689. m_pListCtrl->CWnd::DefWindowProc(WM_ERASEBKGND, wParam, 0);
  690. return m_pListCtrl->CWnd::DefWindowProc(WM_PRINTCLIENT, wParam, lParam);
  691. }
  693. void CXTListBase::OnPaint()
  694. {
  695. // background is already filled in gray
  696. CPaintDC dc(m_pListCtrl);
  698. bool bReportView = ((::GetWindowLong(m_pListCtrl->m_hWnd,
  699. GWL_STYLE) & LVS_TYPEMASK) == LVS_REPORT);
  701. // Get the client rect.
  702. CRect rectClient;
  703. m_pListCtrl->GetClientRect(&rectClient);
  705. // Exclude the header control from being re-painted.
  706. CHeaderCtrl* pHeaderCtrl = NULL;
  707. if (bReportView)
  708. {
  709. // Get a pointer to the header control.
  710. pHeaderCtrl = _xtGetHeaderCtrl();
  711. if (pHeaderCtrl && ::IsWindow(pHeaderCtrl->m_hWnd))
  712. {
  713. CRect rcHeader;
  714. pHeaderCtrl->GetWindowRect(&rcHeader);
  715. m_pListCtrl->ScreenToClient(&rcHeader);
  716. dc.ExcludeClipRect(&rcHeader);
  717. }
  718. }
  720. // define the background fill color.
  721. COLORREF crBackColor = GetListBackColor();
  723. if (!m_pListCtrl->IsWindowEnabled())
  724. crBackColor = ::GetSysColor(COLOR_3DFACE);
  726. // Paint to a memory device context to help
  727. // eliminate screen flicker.
  728. CXTPBufferDC memDC(dc);
  729. memDC.FillSolidRect(rectClient, crBackColor);
  731. if (pHeaderCtrl && ::IsWindow(pHeaderCtrl->m_hWnd))
  732. {
  733. CRect rcCol;
  734. m_pListCtrl->GetClientRect(&rcCol);
  736. SCROLLINFO si;
  737. ::ZeroMemory(&si, sizeof(SCROLLINFO));
  738. si.cbSize = sizeof(SCROLLINFO);
  739. si.fMask = SIF_POS;
  741. m_pListCtrl->GetScrollInfo(SB_HORZ, &si);
  742. rcCol.left -= si.nPos;
  744. for (int iCol = 0; iCol <= pHeaderCtrl->GetItemCount(); iCol++)
  745. {
  746. int iColWidth = m_pListCtrl->GetColumnWidth(Header_OrderToIndex(pHeaderCtrl->m_hWnd, iCol));
  747. rcCol.right = rcCol.left + iColWidth;
  749. if (m_bSortColor && (Header_OrderToIndex(pHeaderCtrl->m_hWnd, iCol) == m_nSortedCol))
  750. {
  751. memDC.FillSolidRect(&rcCol, GetSortBackColor());
  752. break;
  753. }
  755. rcCol.left += iColWidth;
  756. }
  757. }
  759. // Now let the window do its default painting...
  760. m_pListCtrl->CWnd::DefWindowProc(WM_PAINT, (WPARAM)memDC.m_hDC, 0);
  762. // Refresh the header control.
  763. if (pHeaderCtrl && ::IsWindow(pHeaderCtrl->m_hWnd))
  764. {
  765. pHeaderCtrl->Invalidate();
  766. pHeaderCtrl->UpdateWindow();
  767. }
  768. }
  770. bool CXTListBase::Init()
  771. {
  772. if (!::IsWindow(m_pListCtrl->GetSafeHwnd()))
  773. return false;
  775. // NOTE: using auto font will also reset the font
  776. // for the header control.
  777. if (m_bAutoFont)
  778. {
  779. m_pListCtrl->SetFont(&XTAuxData().font);
  780. }
  782. return true;
  783. }
  785. void CXTListBase::OnSettingChange(UINT /*uFlags*/, LPCTSTR /*lpszSection*/)
  786. {
  787. RefreshMetrics();
  788. }
  790. CHeaderCtrl* CXTListBase::_xtGetHeaderCtrl() const
  791. {
  792. if (m_pListCtrl == NULL)
  793. return NULL;
  795. CHeaderCtrl * const pHeaderCtrl =
  796. (CHeaderCtrl*)m_pListCtrl->GetDlgItem(0);
  798. // The follow code will ASSERT if you are trying to access the header
  799. // control prior to adding columns to the list control.  If you are
  800. // calling SubclassHeader(), you need to make sure that the call to
  801. // SubClassHeader() is placed after your columns have been inserted.
  803. ASSERT(pHeaderCtrl != NULL);
  804. return pHeaderCtrl;
  805. }
  807. CXTFlatHeaderCtrl* CXTListBase::GetFlatHeaderCtrl() const
  808. {
  809. CHeaderCtrl* pHeaderCtrl = _xtGetHeaderCtrl();
  811. if (!pHeaderCtrl->IsKindOf(RUNTIME_CLASS(CXTFlatHeaderCtrl)))
  812. return NULL;
  814. return (CXTFlatHeaderCtrl*)pHeaderCtrl;
  815. }