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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 进程与线程 > 查看源码
XListCtrl.cpp
资源名称：多线程实例.rar　[点击查看]
上传用户：dfzycw
上传日期：2010-01-10
资源大小：66k
文件大小：56k
源码类别：

进程与线程

开发平台：

Visual C++

XListCtrl.cpp：源码内容
  1. // XListCtrl.cpp  Version 1.3
  2. //
  3. // Author:  Hans Dietrich
  4. //          hdietrich2@hotmail.com
  5. //
  6. // This code is based on "Neat Stuff to do in List Controls Using Custom Draw"
  7. // by Michael Dunn. See http://www.codeproject.com/listctrl/lvcustomdraw.asp
  8. //
  9. // Thanks to David Patrick for pointing out how to subclass header control
  10. // if CXListCtrl is created via Create() instead of via dialog template.
  11. //
  12. // This software is released into the public domain.
  13. // You are free to use it in any way you like.
  14. //
  15. // This software is provided "as is" with no expressed
  16. // or implied warranty.  I accept no liability for any
  17. // damage or loss of business that this software may cause.
  18. //
  19. ///////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "XListCtrl.h"
  24. #ifdef _DEBUG
  25. #define new DEBUG_NEW
  26. #undef THIS_FILE
  27. static char THIS_FILE[] = __FILE__;
  28. #endif
  30. UINT NEAR WM_XLISTCTRL_COMBO_SELECTION  = ::RegisterWindowMessage(_T("WM_XLISTCTRL_COMBO_SELECTION"));
  31. UINT NEAR WM_XLISTCTRL_CHECKBOX_CLICKED = ::RegisterWindowMessage(_T("WM_XLISTCTRL_CHECKBOX_CLICKED"));
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CXListCtrl
  36. BEGIN_MESSAGE_MAP(CXListCtrl, CListCtrl)
  37. //{{AFX_MSG_MAP(CXListCtrl)
  38. ON_NOTIFY_REFLECT_EX(NM_CLICK, OnClick)
  39. ON_NOTIFY_REFLECT_EX(LVN_COLUMNCLICK, OnColumnClick)
  40. ON_WM_CREATE()
  41. ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
  42. ON_WM_DESTROY()
  43. ON_WM_LBUTTONDOWN()
  44. ON_WM_PAINT()
  45. ON_WM_SYSCOLORCHANGE()
  46. //}}AFX_MSG_MAP
  47. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  48. ON_WM_TIMER()
  49. ON_REGISTERED_MESSAGE(WM_XCOMBOLIST_VK_ESCAPE, OnComboEscape)
  50. ON_REGISTERED_MESSAGE(WM_XCOMBOLIST_VK_RETURN, OnComboReturn)
  51. ON_REGISTERED_MESSAGE(WM_XCOMBOLIST_KEYDOWN, OnComboKeydown)
  52. ON_REGISTERED_MESSAGE(WM_XCOMBOLIST_LBUTTONUP, OnComboLButtonUp)
  53. #endif
  54. #ifndef NO_XLISTCTRL_TOOL_TIPS
  55. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  56. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  57. #endif
  58. END_MESSAGE_MAP()
  61. ///////////////////////////////////////////////////////////////////////////////
  62. // ctor
  63. CXListCtrl::CXListCtrl()
  64. {
  66. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  67. m_bComboIsClicked       = FALSE;
  68. m_nComboItem            = 0;
  69. m_nComboSubItem         = 0;
  70. m_pListBox              = NULL;
  71. m_bFontIsCreated        = FALSE;
  72. m_strInitialComboString = _T("");
  73. #endif
  75. m_dwExtendedStyleX      = 0;
  76. m_bHeaderIsSubclassed   = FALSE;
  78. m_cr3DFace              = ::GetSysColor(COLOR_3DFACE);
  79. m_cr3DHighLight         = ::GetSysColor(COLOR_3DHIGHLIGHT);
  80. m_cr3DShadow            = ::GetSysColor(COLOR_3DSHADOW);
  81. m_crBtnFace             = ::GetSysColor(COLOR_BTNFACE);
  82. m_crBtnShadow           = ::GetSysColor(COLOR_BTNSHADOW);
  83. m_crBtnText             = ::GetSysColor(COLOR_BTNTEXT);
  84. m_crGrayText            = ::GetSysColor(COLOR_GRAYTEXT);
  85. m_crHighLight           = ::GetSysColor(COLOR_HIGHLIGHT);
  86. m_crHighLightText       = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
  87. m_crWindow              = ::GetSysColor(COLOR_WINDOW);
  88. m_crWindowText          = ::GetSysColor(COLOR_WINDOWTEXT);
  89. }
  91. ///////////////////////////////////////////////////////////////////////////////
  92. // dtor
  93. CXListCtrl::~CXListCtrl()
  94. {
  95. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  96. if (m_pListBox)
  97. delete m_pListBox;
  98. #endif
  99. }
  101. ///////////////////////////////////////////////////////////////////////////////
  102. // PreSubclassWindow
  103. void CXListCtrl::PreSubclassWindow()
  104. {
  105. CListCtrl::PreSubclassWindow();
  107. // for Dialog based applications, this is a good place
  108. // to subclass the header control because the OnCreate()
  109. // function does not get called.
  111. SubclassHeaderControl();
  112. }
  114. ///////////////////////////////////////////////////////////////////////////////
  115. // OnCreate
  116. int CXListCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
  117. {
  118. if (CListCtrl::OnCreate(lpCreateStruct) == -1)
  119. {
  120. ASSERT(FALSE);
  121. return -1;
  122. }
  124. // When the CXListCtrl object is created via a call to Create(), instead
  125. // of via a dialog box template, we must subclass the header control
  126. // window here because it does not exist when the PreSubclassWindow()
  127. // function is called.
  129. SubclassHeaderControl();
  131. return 0;
  132. }
  134. ///////////////////////////////////////////////////////////////////////////////
  135. // SubclassHeaderControl
  136. void CXListCtrl::SubclassHeaderControl()
  137. {
  138. if (m_bHeaderIsSubclassed)
  139. return;
  141. // if the list control has a header control window, then
  142. // subclass it
  144. // Thanks to Alberto Gattegno and Alon Peleg牋and their article
  145. // "A Multiline Header Control Inside a CListCtrl" for easy way
  146. // to determine if the header control exists.
  148. CHeaderCtrl* pHeader = GetHeaderCtrl();
  149. if (pHeader)
  150. {
  151. VERIFY(m_HeaderCtrl.SubclassWindow(pHeader->m_hWnd));
  152. m_bHeaderIsSubclassed = TRUE;
  153. }
  154. }
  156. ///////////////////////////////////////////////////////////////////////////////
  157. // OnClick
  158. BOOL CXListCtrl::OnClick(NMHDR*, LRESULT* pResult)
  159. {
  160. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  161. UnpressComboButton();
  162. #endif
  163. *pResult = 0;
  164. return FALSE; // return FALSE to send message to parent also -
  165. // NOTE:  MSDN documentation is incorrect
  166. }
  168. ///////////////////////////////////////////////////////////////////////////////
  169. // OnCustomDraw
  170. void CXListCtrl::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
  171. {
  172. NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  174. // Take the default processing unless we set this to something else below.
  175. *pResult = CDRF_DODEFAULT;
  177. // First thing - check the draw stage. If it's the control's prepaint
  178. // stage, then tell Windows we want messages for every item.
  180. if (pLVCD->nmcd.dwDrawStage == CDDS_PREPAINT)
  181. {
  182. *pResult = CDRF_NOTIFYITEMDRAW;
  183. }
  184. else if (pLVCD->nmcd.dwDrawStage == CDDS_ITEMPREPAINT)
  185. {
  186. // This is the notification message for an item.  We'll request
  187. // notifications before each subitem's prepaint stage.
  189. *pResult = CDRF_NOTIFYSUBITEMDRAW;
  190. }
  191. else if (pLVCD->nmcd.dwDrawStage == (CDDS_ITEMPREPAINT | CDDS_SUBITEM))
  192. {
  193. // This is the prepaint stage for a subitem. Here's where we set the
  194. // item's text and background colors. Our return value will tell
  195. // Windows to draw the subitem itself, but it will use the new colors
  196. // we set here.
  198. int nItem = static_cast<int> (pLVCD->nmcd.dwItemSpec);
  199. int nSubItem = pLVCD->iSubItem;
  201. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) pLVCD->nmcd.lItemlParam;
  202. ASSERT(pXLCD);
  204. COLORREF crText  = m_crWindowText;
  205. COLORREF crBkgnd = m_crWindow;
  207. if (pXLCD)
  208. {
  209. crText  = pXLCD[nSubItem].crText;
  210. crBkgnd = pXLCD[nSubItem].crBackground;
  212. if (!pXLCD[0].bEnabled)
  213. crText = m_crGrayText;
  214. }
  216. // store the colors back in the NMLVCUSTOMDRAW struct
  217. pLVCD->clrText = crText;
  218. pLVCD->clrTextBk = crBkgnd;
  220. CDC* pDC = CDC::FromHandle(pLVCD->nmcd.hdc);
  221. CRect rect;
  222. GetSubItemRect(nItem, nSubItem, LVIR_BOUNDS, rect);
  224. if (pXLCD && (pXLCD[nSubItem].bShowProgress))
  225. {
  226. DrawProgress(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  228. *pResult = CDRF_SKIPDEFAULT; // We've painted everything.
  229. }
  230. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  231. else if (pXLCD && (pXLCD[nSubItem].bCombo))
  232. {
  233. if (GetItemState(nItem, LVIS_SELECTED))
  234. DrawComboBox(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  235. else
  236. DrawText(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  238. *pResult = CDRF_SKIPDEFAULT; // We've painted everything.
  239. }
  240. #endif
  241. else if (pXLCD && (pXLCD[nSubItem].nCheckedState != -1))
  242. {
  243. DrawCheckbox(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  245. *pResult = CDRF_SKIPDEFAULT; // We've painted everything.
  246. }
  247. else
  248. {
  249. rect.left += DrawImage(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  251. DrawText(nItem, nSubItem, pDC, crText, crBkgnd, rect, pXLCD);
  253. *pResult = CDRF_SKIPDEFAULT; // We've painted everything.
  254. }
  255. }
  256. }
  258. ///////////////////////////////////////////////////////////////////////////////
  259. // DrawProgress
  260. void CXListCtrl::DrawProgress(int nItem,
  261.   int nSubItem,
  262.   CDC *pDC,
  263.   COLORREF crText,
  264.   COLORREF crBkgnd,
  265.   CRect& rect,
  266.   XLISTCTRLDATA *pXLCD)
  267. {
  268. UNUSED_ALWAYS(nItem);
  270. ASSERT(pDC);
  271. ASSERT(pXLCD);
  273. rect.bottom -= 1;
  274. rect.left += 1; // leave margin in case row is highlighted
  275. rect.right -= 2;
  277. // draw border
  279. CPen graypen(PS_SOLID, 1, m_crBtnShadow);
  280. CPen *pOldPen = pDC->SelectObject(&graypen);
  282. pDC->MoveTo(rect.left, rect.bottom);
  283. pDC->LineTo(rect.right+1, rect.bottom);
  285. pDC->MoveTo(rect.left, rect.top);
  286. pDC->LineTo(rect.right, rect.top);
  288. pDC->MoveTo(rect.left, rect.top);
  289. pDC->LineTo(rect.left, rect.bottom);
  291. pDC->MoveTo(rect.right, rect.top);
  292. pDC->LineTo(rect.right, rect.bottom);
  294. // fill interior with light gray
  295. CRect InteriorRect;
  296. InteriorRect = rect;
  297. InteriorRect.left += 1;
  298. InteriorRect.top += 1;
  299. pDC->FillSolidRect(InteriorRect, RGB(224,224,224));
  301. // finish drawing border
  302. CPen blackpen(PS_SOLID, 1, RGB(0,0,0));
  303. pDC->SelectObject(&blackpen);
  305. pDC->MoveTo(rect.left+1, rect.top+1);
  306. pDC->LineTo(rect.right, rect.top+1);
  308. pDC->MoveTo(rect.left+1, rect.top+1);
  309. pDC->LineTo(rect.left+1, rect.bottom);
  311. pDC->SelectObject(pOldPen);
  313. if (pXLCD[nSubItem].nProgressPercent > 0)
  314. {
  315. // draw progress bar and text
  317. CRect LeftRect, RightRect;
  318. LeftRect = rect;
  319. LeftRect.left += 2;
  320. LeftRect.top += 2;
  321. RightRect = LeftRect;
  322. int w = (LeftRect.Width() * pXLCD[nSubItem].nProgressPercent) / 100;
  323. LeftRect.right = LeftRect.left + w;
  324. RightRect.left = LeftRect.right + 1;
  325. pDC->FillSolidRect(LeftRect, m_crHighLight);
  327. if (pXLCD[nSubItem].bShowProgressMessage)
  328. {
  329. CString str, format;
  330. format = pXLCD[nSubItem].strProgressMessage;
  331. if (format.IsEmpty())
  332. str.Format(_T("%d%%"), pXLCD[nSubItem].nProgressPercent);
  333. else
  334. str.Format(format, pXLCD[nSubItem].nProgressPercent);
  336. pDC->SetBkMode(TRANSPARENT);
  338. CRect TextRect;
  339. TextRect = rect;
  340. TextRect.DeflateRect(1, 1);
  341. TextRect.top += 1;
  343. CRgn rgn;
  344. rgn.CreateRectRgn(LeftRect.left, LeftRect.top, LeftRect.right, LeftRect.bottom);
  345. pDC->SelectClipRgn(&rgn);
  346. pDC->SetTextColor(crBkgnd);
  347. pDC->DrawText(str, &TextRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  349. rgn.DeleteObject();
  350. rgn.CreateRectRgn(RightRect.left, RightRect.top, RightRect.right, RightRect.bottom);
  351. pDC->SelectClipRgn(&rgn);
  352. pDC->SetTextColor(crText);
  353. pDC->DrawText(str, &TextRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
  354. rgn.DeleteObject();
  355. pDC->SelectClipRgn(NULL);
  356. }
  357. }
  358. }
  360. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  362. ///////////////////////////////////////////////////////////////////////////////
  363. // DrawComboBox
  364. void CXListCtrl::DrawComboBox(int nItem,
  365.   int nSubItem,
  366.   CDC *pDC,
  367.   COLORREF crText,
  368.   COLORREF crBkgnd,
  369.   CRect& rect,
  370.   XLISTCTRLDATA *pXLCD)
  371. {
  372. UNUSED_ALWAYS(crText);
  373. UNUSED_ALWAYS(crBkgnd);
  375. ASSERT(pDC);
  376. ASSERT(pXLCD);
  378. #ifdef _DEBUG
  379. DWORD dwExStyle = GetExtendedStyle();
  380. if ((dwExStyle & LVS_EX_FULLROWSELECT) == 0)
  381. {
  382. TRACE(_T("XListCtrl: combo boxes require LVS_EX_FULLROWSELECT stylen"));
  383. ASSERT(FALSE);
  384. }
  385. #endif
  387. rect.bottom += 1; // bottom edge is white, so this doesn't matter
  388. rect.left += 1; // leave margin in case row is highlighted
  389. rect.right -= 2;
  391. // draw border
  393. CPen pen(PS_SOLID, 1, m_crBtnShadow);
  394. CPen *pOldPen = pDC->SelectObject(&pen);
  396. pDC->MoveTo(rect.left, rect.bottom-2);
  397. pDC->LineTo(rect.right, rect.bottom-2);
  399. pDC->MoveTo(rect.left, rect.top);
  400. pDC->LineTo(rect.right, rect.top);
  402. pDC->MoveTo(rect.left, rect.top);
  403. pDC->LineTo(rect.left, rect.bottom-2);
  405. pDC->MoveTo(rect.right, rect.top);
  406. pDC->LineTo(rect.right, rect.bottom-1);
  408. CPen blackpen(PS_SOLID, 1, RGB(0,0,0));
  409. pDC->SelectObject(&blackpen);
  411. // fill interior with white
  412. CRect InteriorRect;
  413. InteriorRect = rect;
  414. InteriorRect.DeflateRect(2, 2);
  415. pDC->FillSolidRect(InteriorRect, RGB(255,255,255));
  417. // set arrow rect
  418. CRect ArrowRect;
  419. ArrowRect = rect;
  420. ArrowRect.right += 1;
  421. ArrowRect.left = ArrowRect.right - ArrowRect.Height();
  422. ArrowRect.DeflateRect(2, 2);
  424. CString str;
  425. str = GetItemText(nItem, nSubItem);
  427. if (str.IsEmpty())
  428. {
  429. // subitem text is empty, try to get from listbox strings
  430. if (pXLCD[nSubItem].psa)
  431. {
  432. int index = 0;
  433. if ((pXLCD[nSubItem].nInitialComboSel >= 0) &&
  434. (pXLCD[nSubItem].psa->GetSize() > pXLCD[nSubItem].nInitialComboSel))
  435. {
  436. index = pXLCD[nSubItem].nInitialComboSel;
  437. str = pXLCD[nSubItem].psa->GetAt(index);
  438. SetItemText(nItem, nSubItem, str);
  439. }
  440. }
  441. }
  443. if (!str.IsEmpty())
  444. {
  445. // draw text
  446. CRect TextRect;
  447. TextRect = rect;
  448. TextRect.top -= 1;
  449. TextRect.left += 2;
  450. TextRect.right = ArrowRect.left - 1;
  452. pDC->SetBkMode(TRANSPARENT);
  453. COLORREF cr = m_crWindowText;
  454. if (!pXLCD[0].bEnabled)
  455. cr = m_crGrayText;
  456. pDC->SetTextColor(cr);
  457. pDC->SetBkColor(m_crWindow);
  458. UINT nFormat = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
  459. pDC->DrawText(str, &TextRect, nFormat);
  460. }
  462. if (!pXLCD[nSubItem].bComboIsClicked)
  463. {
  464. // draw depressed combobox
  465. pDC->DrawEdge(&ArrowRect, EDGE_RAISED, BF_RECT);
  466. ArrowRect.DeflateRect(2, 2);
  467. pDC->FillSolidRect(ArrowRect, m_crBtnFace);
  469. // draw the downarrow using blackpen
  470. int x = ArrowRect.left + 1;
  471. int y = ArrowRect.top + 2;
  472. int k = 5;
  473. for (int i = 0; i < 3; i++)
  474. {
  475. pDC->MoveTo(x, y);
  476. pDC->LineTo(x+k, y);
  477. x++;
  478. y++;
  479. k -= 2;
  480. }
  481. }
  482. else
  483. {
  484. // draw normal combobox
  485. m_rectComboButton = ArrowRect;
  486. CBrush brush(m_cr3DShadow);
  487. pDC->FrameRect(&ArrowRect, &brush);
  488. ArrowRect.DeflateRect(1, 1);
  489. pDC->FillSolidRect(ArrowRect, m_crBtnFace);
  491. // draw the downarrow using blackpen
  492. int x = ArrowRect.left + 3;
  493. int y = ArrowRect.top + 4;
  494. int k = 5;
  495. for (int i = 0; i < 3; i++)
  496. {
  497. pDC->MoveTo(x, y);
  498. pDC->LineTo(x+k, y);
  499. x++;
  500. y++;
  501. k -= 2;
  502. }
  504. // show listbox if not already shown
  505. if (!m_pListBox)
  506. {
  507. // create and populate the combo's listbox
  508. m_pListBox = new CXComboList(this);
  509. ASSERT(m_pListBox);
  511. if (m_pListBox)
  512. {
  513. m_nComboItem = nItem;
  514. m_nComboSubItem = nSubItem;
  516. m_rectComboList = rect;
  517. m_rectComboList.right -= 1;
  518. m_rectComboList.top += rect.Height() - 1;
  520. m_rectComboList.bottom = m_rectComboList.top +
  521. (pXLCD[nSubItem].nComboListHeight) * (rect.Height() - 2);
  522. ClientToScreen(&m_rectComboList);
  524. CString szClassName = AfxRegisterWndClass(CS_CLASSDC|CS_SAVEBITS,
  525.   LoadCursor(NULL, IDC_ARROW));
  527. BOOL bSuccess = m_pListBox->CreateEx(0, szClassName, _T(""),
  528. WS_POPUP | WS_VISIBLE /*| WS_VSCROLL*/ | WS_BORDER,
  529. m_rectComboList,
  530. this, 0, NULL);
  532. if (!bSuccess)
  533. {
  534. }
  535. else
  536. {
  537. m_strInitialComboString = _T("");
  539. if (!m_bFontIsCreated)
  540. {
  541. // use font from list control
  542. CFont *font = pDC->GetCurrentFont();
  543. if (font)
  544. {
  545. LOGFONT lf;
  546. font->GetLogFont(&lf);
  547. m_ListboxFont.CreateFontIndirect(&lf);
  548. m_bFontIsCreated = TRUE;
  549. }
  550. }
  552. if (m_bFontIsCreated)
  553. m_pListBox->SetFont(&m_ListboxFont, FALSE);
  555. if (pXLCD[nSubItem].psa)
  556. {
  557. CString s;
  558. for (int i = 0; i < pXLCD[nSubItem].psa->GetSize(); i++)
  559. {
  560. s = pXLCD[nSubItem].psa->GetAt(i);
  561. if (!s.IsEmpty())
  562. m_pListBox->AddString(s);
  563. }
  564. }
  566. int index = 0;
  567. if (str.IsEmpty())
  568. {
  569. // str is empty, try to get from first listbox string
  570. if (m_pListBox->GetCount() > 0)
  571. m_pListBox->GetText(0, str);
  573. SetItemText(nItem, nSubItem, str);
  574. }
  575. else
  576. {
  577. // set listbox selection from subitem text
  578. index = m_pListBox->FindStringExact(-1, str);
  579. if (index == LB_ERR)
  580. index = 0;
  581. }
  582. m_pListBox->SetCurSel(index);
  583. m_pListBox->GetText(index, m_strInitialComboString);
  584. m_pListBox->SetActive(11);
  585. }
  586. }
  587. }
  588. }
  589. pDC->SelectObject(pOldPen);
  590. }
  592. #endif
  594. ///////////////////////////////////////////////////////////////////////////////
  595. // DrawCheckbox
  596. void CXListCtrl::DrawCheckbox(int nItem,
  597.   int nSubItem,
  598.   CDC *pDC,
  599.   COLORREF crText,
  600.   COLORREF crBkgnd,
  601.   CRect& rect,
  602.   XLISTCTRLDATA *pXLCD)
  603. {
  604. ASSERT(pDC);
  605. ASSERT(pXLCD);
  607. GetDrawColors(nItem, nSubItem, crText, crBkgnd);
  609. pDC->FillSolidRect(&rect, crBkgnd);
  611. CRect chkboxrect;
  612. chkboxrect = rect;
  613. chkboxrect.bottom -= 1;
  614. chkboxrect.left += 9; // line up checkbox with header checkbox
  615. chkboxrect.right = chkboxrect.left + chkboxrect.Height(); // width = height
  617. CString str;
  618. str = GetItemText(nItem, nSubItem);
  620. if (str.IsEmpty())
  621. {
  622. // center the checkbox
  624. chkboxrect.left = rect.left + rect.Width()/2 - chkboxrect.Height()/2 - 1;
  625. chkboxrect.right = chkboxrect.left + chkboxrect.Height();
  626. }
  628. // fill rect around checkbox with white
  629. pDC->FillSolidRect(&chkboxrect, m_crWindow);
  631. chkboxrect.left += 1;
  633. // draw border
  634. pDC->DrawEdge(&chkboxrect, EDGE_SUNKEN, BF_RECT);
  636. if (pXLCD[nSubItem].nCheckedState == 1)
  637. {
  638. CPen *pOldPen = NULL;
  640. CPen graypen(PS_SOLID, 1, m_crGrayText);
  641. CPen blackpen(PS_SOLID, 1, RGB(0,0,0));
  643. if (pXLCD[0].bEnabled)
  644. pOldPen = pDC->SelectObject(&blackpen);
  645. else
  646. pOldPen = pDC->SelectObject(&graypen);
  648. // draw the checkmark
  649. int x = chkboxrect.left + 9;
  650. ASSERT(x < chkboxrect.right);
  651. int y = chkboxrect.top + 3;
  652. int i;
  653. for (i = 0; i < 4; i++)
  654. {
  655. pDC->MoveTo(x, y);
  656. pDC->LineTo(x, y+3);
  657. x--;
  658. y++;
  659. }
  660. for (i = 0; i < 3; i++)
  661. {
  662. pDC->MoveTo(x, y);
  663. pDC->LineTo(x, y+3);
  664. x--;
  665. y--;
  666. }
  668. if (pOldPen)
  669. pDC->SelectObject(pOldPen);
  670. }
  672. if (!str.IsEmpty())
  673. {
  674. pDC->SetBkMode(TRANSPARENT);
  675. pDC->SetTextColor(crText);
  676. pDC->SetBkColor(crBkgnd);
  677. CRect textrect;
  678. textrect = rect;
  679. textrect.left = chkboxrect.right + 4;
  681. pDC->DrawText(str, &textrect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
  682. }
  683. }
  685. ///////////////////////////////////////////////////////////////////////////////
  686. // GetDrawColors
  687. void CXListCtrl::GetDrawColors(int nItem,
  688.    int nSubItem,
  689.    COLORREF& colorText,
  690.    COLORREF& colorBkgnd)
  691. {
  692. DWORD dwStyle    = GetStyle();
  693. DWORD dwExStyle  = GetExtendedStyle();
  695. COLORREF crText  = colorText;
  696. COLORREF crBkgnd = colorBkgnd;
  698. if (GetItemState(nItem, LVIS_SELECTED))
  699. {
  700. if (dwExStyle & LVS_EX_FULLROWSELECT)
  701. {
  702. // selected?  if so, draw highlight background
  703. crText  = m_crHighLightText;
  704. crBkgnd = m_crHighLight;
  706. // has focus?  if not, draw gray background
  707. if (m_hWnd != ::GetFocus())
  708. {
  709. if (dwStyle & LVS_SHOWSELALWAYS)
  710. {
  711. crText  = m_crWindowText;
  712. crBkgnd = m_crBtnFace;
  713. }
  714. else
  715. {
  716. crText  = colorText;
  717. crBkgnd = colorBkgnd;
  718. }
  719. }
  720. }
  721. else // not full row select
  722. {
  723. if (nSubItem == 0)
  724. {
  725. // selected?  if so, draw highlight background
  726. crText  = m_crHighLightText;
  727. crBkgnd = m_crHighLight;
  729. // has focus?  if not, draw gray background
  730. if (m_hWnd != ::GetFocus())
  731. {
  732. if (dwStyle & LVS_SHOWSELALWAYS)
  733. {
  734. crText  = m_crWindowText;
  735. crBkgnd = m_crBtnFace;
  736. }
  737. else
  738. {
  739. crText  = colorText;
  740. crBkgnd = colorBkgnd;
  741. }
  742. }
  743. }
  744. }
  745. }
  747. colorText = crText;
  748. colorBkgnd = crBkgnd;
  749. }
  751. ///////////////////////////////////////////////////////////////////////////////
  752. // DrawImage
  753. int CXListCtrl::DrawImage(int nItem,
  754.   int nSubItem,
  755.   CDC* pDC,
  756.   COLORREF crText,
  757.   COLORREF crBkgnd,
  758.   CRect rect,
  759.      XLISTCTRLDATA *pXLCD)
  760. {
  761. GetDrawColors(nItem, nSubItem, crText, crBkgnd);
  763. pDC->FillSolidRect(&rect, crBkgnd);
  765. int nWidth = 0;
  766. rect.left += m_HeaderCtrl.GetSpacing();
  768. CImageList* pImageList = GetImageList(LVSIL_SMALL);
  769. if (pImageList)
  770. {
  771. SIZE sizeImage;
  772. sizeImage.cx = sizeImage.cy = 0;
  773. IMAGEINFO info;
  775. int nImage = -1;
  776. if (pXLCD)
  777. nImage = pXLCD[nSubItem].nImage;
  779. if (nImage == -1)
  780. return 0;
  782. if (pImageList->GetImageInfo(nImage, &info))
  783. {
  784. sizeImage.cx = info.rcImage.right - info.rcImage.left;
  785. sizeImage.cy = info.rcImage.bottom - info.rcImage.top;
  786. }
  788. if (nImage >= 0)
  789. {
  790. if (rect.Width() > 0)
  791. {
  792. POINT point;
  794. point.y = rect.CenterPoint().y - (sizeImage.cy >> 1);
  795. point.x = rect.left;
  797. SIZE size;
  798. size.cx = rect.Width() < sizeImage.cx ? rect.Width() : sizeImage.cx;
  799. size.cy = rect.Height() < sizeImage.cy ? rect.Height() : sizeImage.cy;
  801. // save image list background color
  802. COLORREF rgb = pImageList->GetBkColor();
  804. // set image list background color
  805. pImageList->SetBkColor(crBkgnd);
  806. pImageList->DrawIndirect(pDC, nImage, point, size, CPoint(0, 0));
  807. pImageList->SetBkColor(rgb);
  809. nWidth = sizeImage.cx + m_HeaderCtrl.GetSpacing();
  810. }
  811. }
  812. }
  814. return nWidth;
  815. }
  817. ///////////////////////////////////////////////////////////////////////////////
  818. // DrawText
  819. void CXListCtrl::DrawText(int nItem,
  820.   int nSubItem,
  821.   CDC *pDC,
  822.   COLORREF crText,
  823.   COLORREF crBkgnd,
  824.   CRect& rect,
  825.   XLISTCTRLDATA *pXLCD)
  826. {
  827. ASSERT(pDC);
  828. ASSERT(pXLCD);
  830. GetDrawColors(nItem, nSubItem, crText, crBkgnd);
  832. pDC->FillSolidRect(&rect, crBkgnd);
  834. CString str;
  835. str = GetItemText(nItem, nSubItem);
  837. if (!str.IsEmpty())
  838. {
  839. // get text justification
  840. HDITEM hditem;
  841. hditem.mask = HDI_FORMAT;
  842. m_HeaderCtrl.GetItem(nSubItem, &hditem);
  843. int nFmt = hditem.fmt & HDF_JUSTIFYMASK;
  844. UINT nFormat = DT_VCENTER | DT_SINGLELINE;
  845. if (nFmt == HDF_CENTER)
  846. nFormat |= DT_CENTER;
  847. else if (nFmt == HDF_LEFT)
  848. nFormat |= DT_LEFT;
  849. else
  850. nFormat |= DT_RIGHT;
  852. CFont *pOldFont = NULL;
  853. CFont boldfont;
  855. // check if bold specified for subitem
  856. if (pXLCD && pXLCD[nSubItem].bBold)
  857. {
  858. CFont *font = pDC->GetCurrentFont();
  859. if (font)
  860. {
  861. LOGFONT lf;
  862. font->GetLogFont(&lf);
  863. lf.lfWeight = FW_BOLD;
  864. boldfont.CreateFontIndirect(&lf);
  865. pOldFont = pDC->SelectObject(&boldfont);
  866. }
  867. }
  868. pDC->SetBkMode(TRANSPARENT);
  869. pDC->SetTextColor(crText);
  870. pDC->SetBkColor(crBkgnd);
  871. pDC->DrawText(str, &rect, nFormat);
  872. if (pOldFont)
  873. pDC->SelectObject(pOldFont);
  874. }
  875. }
  877. ///////////////////////////////////////////////////////////////////////////////
  878. // GetSubItemRect
  879. BOOL CXListCtrl::GetSubItemRect(int nItem,
  880. int nSubItem,
  881. int nArea,
  882. CRect& rect)
  883. {
  884. ASSERT(nItem >= 0);
  885. ASSERT(nItem < GetItemCount());
  886. if ((nItem < 0) || nItem >= GetItemCount())
  887. return FALSE;
  888. ASSERT(nSubItem >= 0);
  889. ASSERT(nSubItem < GetColumns());
  890. if ((nSubItem < 0) || nSubItem >= GetColumns())
  891. return FALSE;
  893. BOOL bRC = CListCtrl::GetSubItemRect(nItem, nSubItem, nArea, rect);
  895. // if nSubItem == 0, the rect returned by CListCtrl::GetSubItemRect
  896. // is the entire row, so use left edge of second subitem
  898. if (nSubItem == 0)
  899. {
  900. if (GetColumns() > 1)
  901. {
  902. CRect rect1;
  903. bRC = GetSubItemRect(nItem, 1, LVIR_BOUNDS, rect1);
  904. rect.right = rect1.left;
  905. }
  906. }
  908. return bRC;
  909. }
  911. ///////////////////////////////////////////////////////////////////////////////
  912. // OnLButtonDown
  913. void CXListCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  914. {
  915. TRACE(_T("in CXListCtrl::OnLButtonDownn"));
  917. int nItem = -1;
  918. CRect rect;
  920. int i;
  921. for (i = 0; i < GetItemCount(); i++)
  922. {
  923. if (CListCtrl::GetItemRect(i, &rect, LVIR_BOUNDS))
  924. {
  925. if (rect.PtInRect(point))
  926. {
  927. nItem = i;
  928. break;
  929. }
  930. }
  931. }
  933. if (nItem == -1)
  934. {
  935. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  936. if (m_pListBox)
  937. OnComboEscape(0, 0);
  938. #endif
  939. }
  940. else
  941. {
  942. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  943. if (!pXLCD)
  944. {
  945. return;
  946. }
  948. if (!pXLCD[0].bEnabled)
  949. return;
  951. CRect rect;
  953. int nSubItem = -1;
  955. // check if a subitem checkbox was clicked
  957. for (i = 0; i < GetColumns(); i++)
  958. {
  959. GetSubItemRect(nItem, i, LVIR_BOUNDS, rect);
  960. if (rect.PtInRect(point))
  961. {
  962. nSubItem = i;
  963. break;
  964. }
  965. }
  967. if (nSubItem == -1)
  968. {
  969. // -1 = no checkbox for this subitem
  971. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  972. if (m_pListBox)
  973. {
  974. OnComboEscape(0, 0);
  975. }
  976. #endif
  977. }
  978. else
  979. {
  980. if (pXLCD[nSubItem].nCheckedState >= 0)
  981. {
  982. int nChecked = pXLCD[nSubItem].nCheckedState;
  984. nChecked = (nChecked == 0) ? 1 : 0;
  986. pXLCD[nSubItem].nCheckedState = nChecked;
  988. UpdateSubItem(nItem, nSubItem);
  990. CWnd *pWnd = GetParent();
  991. if (!pWnd)
  992. pWnd = GetOwner();
  993. if (pWnd && ::IsWindow(pWnd->m_hWnd))
  994. pWnd->SendMessage(WM_XLISTCTRL_CHECKBOX_CLICKED, 
  995. nItem, nSubItem);
  997. // now update checkbox in header
  999. // -1 = no checkbox in column header
  1000. if (GetHeaderCheckedState(nSubItem) != XHEADERCTRL_NO_IMAGE)
  1001. {
  1002. int nCheckedCount = CountCheckedItems(nSubItem);
  1004. if (nCheckedCount == GetItemCount())
  1005. SetHeaderCheckedState(nSubItem, XHEADERCTRL_CHECKED_IMAGE);
  1006. else
  1007. SetHeaderCheckedState(nSubItem, XHEADERCTRL_UNCHECKED_IMAGE);
  1008. }
  1009. }
  1010. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  1011. else if (pXLCD[nSubItem].bCombo)
  1012. {
  1013. if (m_pListBox)
  1014. {
  1015. m_pListBox->DestroyWindow();
  1016. delete m_pListBox;
  1017. m_pListBox = NULL;
  1018. }
  1020. rect.left = rect.right - rect.Height();
  1021. if (point.x >= rect.left && point.y <= rect.right)
  1022. {
  1023. pXLCD[nSubItem].bComboIsClicked = TRUE;
  1024. m_bComboIsClicked = TRUE;
  1025. m_nComboItem = nItem;
  1026. m_nComboSubItem = nSubItem;
  1027. UpdateSubItem(nItem, nSubItem);
  1028. SetTimer(1, 100, NULL);
  1029. }
  1030. }
  1031. else if (m_pListBox)
  1032. {
  1033. OnComboEscape(0, 0);
  1034. }
  1035. #endif
  1036. }
  1037. }
  1039. CListCtrl::OnLButtonDown(nFlags, point);
  1040. }
  1042. ///////////////////////////////////////////////////////////////////////////////
  1043. // OnPaint
  1044. void CXListCtrl::OnPaint()
  1045. {
  1046.     Default();
  1047. if (GetItemCount() <= 0)
  1048. {
  1049. CDC* pDC = GetDC();
  1050. int nSavedDC = pDC->SaveDC();
  1052. CRect rc;
  1053. GetWindowRect(&rc);
  1054. ScreenToClient(&rc);
  1055. CHeaderCtrl* pHC = GetHeaderCtrl();
  1056. if (pHC != NULL)
  1057. {
  1058. CRect rcH;
  1059. pHC->GetItemRect(0, &rcH);
  1060. rc.top += rcH.bottom;
  1061. }
  1062. rc.top += 10;
  1063. CString strText;
  1064. strText = _T("There are no items to show in this view.");
  1066. COLORREF crText = m_crWindowText;
  1067. COLORREF crBkgnd = m_crWindow;
  1069. CBrush brush(crBkgnd);
  1070. pDC->FillRect(rc, &brush);
  1072. pDC->SetTextColor(crText);
  1073. pDC->SetBkColor(crBkgnd);
  1074. pDC->SelectStockObject(ANSI_VAR_FONT);
  1075. pDC->DrawText(strText, -1, rc, DT_CENTER | DT_WORDBREAK | DT_NOPREFIX | DT_NOCLIP);
  1076. pDC->RestoreDC(nSavedDC);
  1077. ReleaseDC(pDC);
  1078. }
  1079. }
  1081. ///////////////////////////////////////////////////////////////////////////////
  1082. // InsertItem
  1083. int CXListCtrl::InsertItem(const LVITEM* pItem)
  1084. {
  1085. ASSERT(pItem->iItem >= 0);
  1086. if (pItem->iItem < 0)
  1087. return -1;
  1089. int index = CListCtrl::InsertItem(pItem);
  1091. if (index < 0)
  1092. return index;
  1094. XLISTCTRLDATA *pXLCD = new XLISTCTRLDATA [GetColumns()];
  1095. ASSERT(pXLCD);
  1096. if (!pXLCD)
  1097. return -1;
  1099. pXLCD[0].crText       = m_crWindowText;
  1100. pXLCD[0].crBackground = m_crWindow;
  1101. pXLCD[0].nImage       = pItem->iImage;
  1103. CListCtrl::SetItemData(index, (DWORD) pXLCD);
  1105. return index;
  1106. }
  1108. ///////////////////////////////////////////////////////////////////////////////
  1109. // InsertItem
  1110. int CXListCtrl::InsertItem(int nItem, LPCTSTR lpszItem)
  1111. {
  1112. ASSERT(nItem >= 0);
  1113. if (nItem < 0)
  1114. return -1;
  1116. return InsertItem(nItem,
  1117.   lpszItem,
  1118.   m_crWindowText,
  1119.   m_crWindow);
  1120. }
  1122. ///////////////////////////////////////////////////////////////////////////////
  1123. // InsertItem
  1124. int CXListCtrl::InsertItem(int nItem,
  1125.    LPCTSTR lpszItem,
  1126.    COLORREF crText,
  1127.    COLORREF crBackground)
  1128. {
  1129. ASSERT(nItem >= 0);
  1130. if (nItem < 0)
  1131. return -1;
  1133. int index = CListCtrl::InsertItem(nItem, lpszItem);
  1135. if (index < 0)
  1136. return index;
  1138. XLISTCTRLDATA *pXLCD = new XLISTCTRLDATA [GetColumns()];
  1139. ASSERT(pXLCD);
  1140. if (!pXLCD)
  1141. return -1;
  1143. pXLCD[0].crText       = crText;
  1144. pXLCD[0].crBackground = crBackground;
  1145. pXLCD[0].nImage       = -1;
  1147. CListCtrl::SetItemData(index, (DWORD) pXLCD);
  1149. return index;
  1150. }
  1152. ///////////////////////////////////////////////////////////////////////////////
  1153. // SetItem
  1154. int CXListCtrl::SetItem(const LVITEM* pItem)
  1155. {
  1156. ASSERT(pItem->iItem >= 0);
  1157. if (pItem->iItem < 0)
  1158. return -1;
  1160. BOOL rc = CListCtrl::SetItem(pItem);
  1162. if (!rc)
  1163. return FALSE;
  1165. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(pItem->iItem);
  1166. if (pXLCD)
  1167. {
  1168. pXLCD[pItem->iSubItem].nImage = pItem->iImage;
  1169. UpdateSubItem(pItem->iItem, pItem->iSubItem);
  1170. rc = TRUE;
  1171. }
  1172. else
  1173. {
  1174. rc = FALSE;
  1175. }
  1177. return rc;
  1178. }
  1180. ///////////////////////////////////////////////////////////////////////////////
  1181. // SetItemImage
  1182. BOOL CXListCtrl::SetItemImage(int nItem, int nSubItem, int nImage)
  1183. {
  1184. ASSERT(nItem >= 0);
  1185. ASSERT(nItem < GetItemCount());
  1186. if ((nItem < 0) || nItem >= GetItemCount())
  1187. return FALSE;
  1188. ASSERT(nSubItem >= 0);
  1189. ASSERT(nSubItem < GetColumns());
  1190. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1191. return FALSE;
  1193. BOOL rc = TRUE;
  1195. if (nItem < 0)
  1196. return FALSE;
  1198. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1199. if (pXLCD)
  1200. {
  1201. pXLCD[nSubItem].nImage = nImage;
  1202. }
  1204. UpdateSubItem(nItem, nSubItem);
  1206. return rc;
  1207. }
  1209. ///////////////////////////////////////////////////////////////////////////////
  1210. // SetItemText
  1211. BOOL CXListCtrl::SetItemText(int nItem, int nSubItem, LPCTSTR lpszText)
  1212. {
  1213. ASSERT(nItem >= 0);
  1214. ASSERT(nItem < GetItemCount());
  1215. if ((nItem < 0) || nItem >= GetItemCount())
  1216. return FALSE;
  1217. ASSERT(nSubItem >= 0);
  1218. ASSERT(nSubItem < GetColumns());
  1219. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1220. return FALSE;
  1222. BOOL rc = CListCtrl::SetItemText(nItem, nSubItem, lpszText);
  1224. UpdateSubItem(nItem, nSubItem);
  1226. return rc;
  1227. }
  1229. ///////////////////////////////////////////////////////////////////////////////
  1230. // SetItemText
  1231. //
  1232. // This function will set the text and colors for a subitem.  If lpszText
  1233. // is NULL, only the colors will be set.  If a color value is -1, the display
  1234. // color will be set to the default Windows color.
  1235. //
  1236. BOOL CXListCtrl::SetItemText(int nItem, int nSubItem, LPCTSTR lpszText,
  1237. COLORREF crText, COLORREF crBackground)
  1238. {
  1239. ASSERT(nItem >= 0);
  1240. ASSERT(nItem < GetItemCount());
  1241. if ((nItem < 0) || nItem >= GetItemCount())
  1242. return FALSE;
  1243. ASSERT(nSubItem >= 0);
  1244. ASSERT(nSubItem < GetColumns());
  1245. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1246. return FALSE;
  1248. BOOL rc = TRUE;
  1250. if (nItem < 0)
  1251. return FALSE;
  1253. if (lpszText)
  1254. rc = CListCtrl::SetItemText(nItem, nSubItem, lpszText);
  1256. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1257. if (pXLCD)
  1258. {
  1259. pXLCD[nSubItem].crText       = (crText == -1) ? m_crWindowText : crText;
  1260. pXLCD[nSubItem].crBackground = (crBackground == -1) ? m_crWindow : crBackground;
  1261. }
  1263. UpdateSubItem(nItem, nSubItem);
  1265. return rc;
  1266. }
  1268. ///////////////////////////////////////////////////////////////////////////////
  1269. // DeleteItem
  1270. BOOL CXListCtrl::DeleteItem(int nItem)
  1271. {
  1272. ASSERT(nItem >= 0);
  1273. ASSERT(nItem < GetItemCount());
  1274. if ((nItem < 0) || nItem >= GetItemCount())
  1275. return FALSE;
  1277. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1278. if (pXLCD)
  1279. delete [] pXLCD;
  1280. CListCtrl::SetItemData(nItem, 0);
  1281. return CListCtrl::DeleteItem(nItem);
  1282. }
  1284. ///////////////////////////////////////////////////////////////////////////////
  1285. // DeleteAllItems
  1286. BOOL CXListCtrl::DeleteAllItems()
  1287. {
  1288. int n = GetItemCount();
  1289. for (int i = 0; i < n; i++)
  1290. {
  1291. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(i);
  1292. if (pXLCD)
  1293. delete [] pXLCD;
  1294. CListCtrl::SetItemData(i, 0);
  1295. }
  1297. return CListCtrl::DeleteAllItems();
  1298. }
  1300. ///////////////////////////////////////////////////////////////////////////////
  1301. // OnDestroy
  1302. void CXListCtrl::OnDestroy()
  1303. {
  1304. int n = GetItemCount();
  1305. for (int i = 0; i < n; i++)
  1306. {
  1307. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(i);
  1308. if (pXLCD)
  1309. delete [] pXLCD;
  1310. CListCtrl::SetItemData(i, 0);
  1311. }
  1313. CListCtrl::OnDestroy();
  1314. }
  1316. ///////////////////////////////////////////////////////////////////////////////
  1317. // SetProgress
  1318. //
  1319. // This function creates a progress bar in the specified subitem.  The
  1320. // UpdateProgress function may then be called to update the progress
  1321. // percent.  If bShowProgressText is TRUE, either the default text
  1322. // of "n%" or the custom percent text (lpszProgressText) will be
  1323. // displayed.  If bShowProgressText is FALSE, only the progress bar
  1324. // will be displayed, with no text.
  1325. //
  1326. // Note that the lpszProgressText string should include the format
  1327. // specifier "%d":  e.g., "Pct %d%%"
  1328. //
  1329. BOOL CXListCtrl::SetProgress(int nItem,
  1330.  int nSubItem,
  1331.  BOOL bShowProgressText /*= TRUE*/,
  1332.  LPCTSTR lpszProgressText /*= NULL*/)
  1333. {
  1334. ASSERT(nItem >= 0);
  1335. ASSERT(nItem < GetItemCount());
  1336. if ((nItem < 0) || nItem >= GetItemCount())
  1337. return FALSE;
  1338. ASSERT(nSubItem >= 0);
  1339. ASSERT(nSubItem < GetColumns());
  1340. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1341. return FALSE;
  1343. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1344. if (!pXLCD)
  1345. {
  1346. return FALSE;
  1347. }
  1349. pXLCD[nSubItem].bShowProgress        = TRUE;
  1350. pXLCD[nSubItem].nProgressPercent     = 0;
  1351. pXLCD[nSubItem].bShowProgressMessage = bShowProgressText;
  1352. pXLCD[nSubItem].strProgressMessage   = lpszProgressText;
  1354. UpdateSubItem(nItem, nSubItem);
  1356. return TRUE;
  1357. }
  1359. ///////////////////////////////////////////////////////////////////////////////
  1360. // DeleteProgress
  1361. void CXListCtrl::DeleteProgress(int nItem, int nSubItem)
  1362. {
  1363. ASSERT(nItem >= 0);
  1364. ASSERT(nItem < GetItemCount());
  1365. if ((nItem < 0) || nItem >= GetItemCount())
  1366. return;
  1367. ASSERT(nSubItem >= 0);
  1368. ASSERT(nSubItem < GetColumns());
  1369. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1370. return;
  1372. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1373. if (!pXLCD)
  1374. {
  1375. return;
  1376. }
  1378. pXLCD[nSubItem].bShowProgress = FALSE;
  1379. pXLCD[nSubItem].nProgressPercent = 0;
  1381. UpdateSubItem(nItem, nSubItem);
  1382. }
  1384. ///////////////////////////////////////////////////////////////////////////////
  1385. // UpdateProgress
  1386. void CXListCtrl::UpdateProgress(int nItem, int nSubItem, int nPercent)
  1387. {
  1388. ASSERT(nItem >= 0);
  1389. ASSERT(nItem < GetItemCount());
  1390. if ((nItem < 0) || nItem >= GetItemCount())
  1391. return;
  1392. ASSERT(nSubItem >= 0);
  1393. ASSERT(nSubItem < GetColumns());
  1394. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1395. return;
  1397. ASSERT(nPercent >= 0 && nPercent <= 100);
  1399. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1400. if (!pXLCD)
  1401. {
  1402. return;
  1403. }
  1405. pXLCD[nSubItem].nProgressPercent = nPercent;
  1407. UpdateSubItem(nItem, nSubItem);
  1408. }
  1410. ///////////////////////////////////////////////////////////////////////////////
  1411. // SetCheckbox
  1412. BOOL CXListCtrl::SetCheckbox(int nItem, int nSubItem, int nCheckedState)
  1413. {
  1414. ASSERT(nItem >= 0);
  1415. ASSERT(nItem < GetItemCount());
  1416. if ((nItem < 0) || nItem >= GetItemCount())
  1417. return FALSE;
  1418. ASSERT(nSubItem >= 0);
  1419. ASSERT(nSubItem < GetColumns());
  1420. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1421. return FALSE;
  1422. ASSERT(nCheckedState == 0 || nCheckedState == 1 || nCheckedState == -1);
  1424. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1425. if (!pXLCD)
  1426. {
  1427. return FALSE;
  1428. }
  1430. // update checkbox in subitem
  1432. pXLCD[nSubItem].nCheckedState = nCheckedState;
  1434. UpdateSubItem(nItem, nSubItem);
  1436. // now update checkbox in column header
  1438. // -1 = no checkbox in column header
  1439. if (GetHeaderCheckedState(nSubItem) != XHEADERCTRL_NO_IMAGE)
  1440. {
  1441. int nCheckedCount = CountCheckedItems(nSubItem);
  1443. if (nCheckedCount == GetItemCount())
  1444. SetHeaderCheckedState(nSubItem, XHEADERCTRL_CHECKED_IMAGE);
  1445. else
  1446. SetHeaderCheckedState(nSubItem, XHEADERCTRL_UNCHECKED_IMAGE);
  1447. }
  1449. return TRUE;
  1450. }
  1452. ///////////////////////////////////////////////////////////////////////////////
  1453. // GetCheckbox
  1454. int CXListCtrl::GetCheckbox(int nItem, int nSubItem)
  1455. {
  1456. ASSERT(nItem >= 0);
  1457. ASSERT(nItem < GetItemCount());
  1458. if ((nItem < 0) || nItem >= GetItemCount())
  1459. return -1;
  1460. ASSERT(nSubItem >= 0);
  1461. ASSERT(nSubItem < GetColumns());
  1462. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1463. return -1;
  1465. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1466. if (!pXLCD)
  1467. {
  1468. return -1;
  1469. }
  1471. return pXLCD[nSubItem].nCheckedState;
  1472. }
  1474. ///////////////////////////////////////////////////////////////////////////////
  1475. // GetEnabled
  1476. //
  1477. // Note that GetEnabled and SetEnabled only Get/Set the enabled flag from
  1478. // subitem 0, since this is a per-row flag.
  1479. //
  1480. BOOL CXListCtrl::GetEnabled(int nItem)
  1481. {
  1482. ASSERT(nItem >= 0);
  1483. ASSERT(nItem < GetItemCount());
  1484. if ((nItem < 0) || nItem >= GetItemCount())
  1485. return FALSE;
  1487. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1488. if (!pXLCD)
  1489. {
  1490. return FALSE;
  1491. }
  1493. return pXLCD[0].bEnabled;
  1494. }
  1496. ///////////////////////////////////////////////////////////////////////////////
  1497. // SetEnabled
  1498. BOOL CXListCtrl::SetEnabled(int nItem, BOOL bEnable)
  1499. {
  1500. ASSERT(nItem >= 0);
  1501. ASSERT(nItem < GetItemCount());
  1502. if ((nItem < 0) || nItem >= GetItemCount())
  1503. return FALSE;
  1505. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1506. if (!pXLCD)
  1507. {
  1508. return FALSE;
  1509. }
  1511. pXLCD[0].bEnabled = bEnable;
  1513. CRect rect;
  1514. GetItemRect(nItem, &rect, LVIR_BOUNDS);
  1515. InvalidateRect(&rect);
  1516. UpdateWindow();
  1518. return TRUE;
  1519. }
  1521. ///////////////////////////////////////////////////////////////////////////////
  1522. // SetBold
  1523. BOOL CXListCtrl::SetBold(int nItem, int nSubItem, BOOL bBold)
  1524. {
  1525. ASSERT(nItem >= 0);
  1526. ASSERT(nItem < GetItemCount());
  1527. if ((nItem < 0) || nItem >= GetItemCount())
  1528. return FALSE;
  1529. ASSERT(nSubItem >= 0);
  1530. ASSERT(nSubItem < GetColumns());
  1531. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1532. return FALSE;
  1534. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1535. if (!pXLCD)
  1536. {
  1537. return FALSE;
  1538. }
  1540. // update bold flag
  1541. pXLCD[nSubItem].bBold = bBold;
  1543. UpdateSubItem(nItem, nSubItem);
  1545. return TRUE;
  1546. }
  1548. ///////////////////////////////////////////////////////////////////////////////
  1549. // GetBold
  1550. BOOL CXListCtrl::GetBold(int nItem, int nSubItem)
  1551. {
  1552. ASSERT(nItem >= 0);
  1553. ASSERT(nItem < GetItemCount());
  1554. if ((nItem < 0) || nItem >= GetItemCount())
  1555. return FALSE;
  1556. ASSERT(nSubItem >= 0);
  1557. ASSERT(nSubItem < GetColumns());
  1558. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1559. return FALSE;
  1561. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1562. if (!pXLCD)
  1563. {
  1564. return FALSE;
  1565. }
  1567. // update bold flag
  1568. return pXLCD[nSubItem].bBold;
  1569. }
  1571. ///////////////////////////////////////////////////////////////////////////////
  1572. // SetComboBox
  1573. //
  1574. // Note:  SetItemText may also be used to set the initial combo selection.
  1575. //
  1576. BOOL CXListCtrl::SetComboBox(int nItem,
  1577.  int nSubItem,
  1578.  BOOL bEnableCombo,
  1579.  CStringArray *psa,
  1580.  int nComboListHeight,
  1581.  int nInitialComboSel)
  1582. {
  1583. ASSERT(nItem >= 0);
  1584. ASSERT(nItem < GetItemCount());
  1585. if ((nItem < 0) || nItem >= GetItemCount())
  1586. return FALSE;
  1587. ASSERT(nSubItem >= 0);
  1588. ASSERT(nSubItem < GetColumns());
  1589. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1590. return FALSE;
  1591. ASSERT(psa);
  1592. if (!psa)
  1593. return FALSE;
  1594. ASSERT(nComboListHeight > 0);
  1595. ASSERT(nInitialComboSel >= 0 && nInitialComboSel < psa->GetSize());
  1596. if ((nInitialComboSel < 0) || (nInitialComboSel >= psa->GetSize()))
  1597. nInitialComboSel = 0;
  1599. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1600. if (!pXLCD)
  1601. {
  1602. return FALSE;
  1603. }
  1605. // update flag
  1606. pXLCD[nSubItem].bCombo = bEnableCombo;
  1608. if (bEnableCombo)
  1609. {
  1610. pXLCD[nSubItem].psa = psa;
  1611. pXLCD[nSubItem].nComboListHeight = nComboListHeight;
  1612. pXLCD[nSubItem].nInitialComboSel = nInitialComboSel;
  1614. if (pXLCD[nSubItem].psa)
  1615. {
  1616. int index = 0;
  1617. if ((pXLCD[nSubItem].nInitialComboSel >= 0) &&
  1618. (pXLCD[nSubItem].psa->GetSize() > pXLCD[nSubItem].nInitialComboSel))
  1619. {
  1620. index = pXLCD[nSubItem].nInitialComboSel;
  1621. CString str;
  1622. str = pXLCD[nSubItem].psa->GetAt(index);
  1623. SetItemText(nItem, nSubItem, str);
  1624. }
  1625. }
  1626. }
  1628. UpdateSubItem(nItem, nSubItem);
  1630. return TRUE;
  1631. }
  1633. ///////////////////////////////////////////////////////////////////////////////
  1634. // GetComboText
  1635. //
  1636. // Actually this does nothing more than GetItemText()
  1637. //
  1638. CString CXListCtrl::GetComboText(int nItem, int nSubItem)
  1639. {
  1640. ASSERT(nItem >= 0);
  1641. ASSERT(nItem < GetItemCount());
  1642. if ((nItem < 0) || nItem >= GetItemCount())
  1643. return _T("");
  1644. ASSERT(nSubItem >= 0);
  1645. ASSERT(nSubItem < GetColumns());
  1646. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1647. return _T("");
  1649. CString str;
  1650. str = _T("");
  1652. str = GetItemText(nItem, nSubItem);
  1654. return str;
  1655. }
  1657. ///////////////////////////////////////////////////////////////////////////////
  1658. // SetCurSel
  1659. BOOL CXListCtrl::SetCurSel(int nItem)
  1660. {
  1661. return SetItemState(nItem, LVIS_FOCUSED | LVIS_SELECTED,
  1662. LVIS_FOCUSED | LVIS_SELECTED);
  1663. }
  1665. ///////////////////////////////////////////////////////////////////////////////
  1666. // GetCurSel - returns selected item number, or -1 if no item selected
  1667. //
  1668. // Note:  for single-selection lists only
  1669. //
  1670. int CXListCtrl::GetCurSel()
  1671. {
  1672. POSITION pos = GetFirstSelectedItemPosition();
  1673. int nSelectedItem = -1;
  1674. if (pos != NULL)
  1675. nSelectedItem = GetNextSelectedItem(pos);
  1676. return nSelectedItem;
  1677. }
  1679. ///////////////////////////////////////////////////////////////////////////////
  1680. // UpdateSubItem
  1681. void CXListCtrl::UpdateSubItem(int nItem, int nSubItem)
  1682. {
  1683. ASSERT(nItem >= 0);
  1684. ASSERT(nItem < GetItemCount());
  1685. if ((nItem < 0) || nItem >= GetItemCount())
  1686. return;
  1687. ASSERT(nSubItem >= 0);
  1688. ASSERT(nSubItem < GetColumns());
  1689. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1690. return;
  1692. CRect rect;
  1693. if (nSubItem == -1)
  1694. {
  1695. GetItemRect(nItem, &rect, LVIR_BOUNDS);
  1696. }
  1697. else
  1698. {
  1699. GetSubItemRect(nItem, nSubItem, LVIR_BOUNDS, rect);
  1700. }
  1702. InvalidateRect(&rect);
  1703. UpdateWindow();
  1704. }
  1706. ///////////////////////////////////////////////////////////////////////////////
  1707. // GetColumns
  1708. int CXListCtrl::GetColumns()
  1709. {
  1710. return GetHeaderCtrl()->GetItemCount();
  1711. }
  1713. ///////////////////////////////////////////////////////////////////////////////
  1714. // GetItemData
  1715. //
  1716. // The GetItemData and SetItemData functions allow for app-specific data
  1717. // to be stored, by using an extra field in the XLISTCTRLDATA struct.
  1718. //
  1719. DWORD CXListCtrl::GetItemData(int nItem)
  1720. {
  1721. ASSERT(nItem >= 0);
  1722. ASSERT(nItem < GetItemCount());
  1723. if ((nItem < 0) || nItem >= GetItemCount())
  1724. return 0;
  1726. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1727. if (!pXLCD)
  1728. {
  1729. return 0;
  1730. }
  1732. return pXLCD->dwItemData;
  1733. }
  1735. ///////////////////////////////////////////////////////////////////////////////
  1736. // SetItemData
  1737. BOOL CXListCtrl::SetItemData(int nItem, DWORD dwData)
  1738. {
  1739. ASSERT(nItem >= 0);
  1740. ASSERT(nItem < GetItemCount());
  1741. if ((nItem < 0) || nItem >= GetItemCount())
  1742. return FALSE;
  1744. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1745. if (!pXLCD)
  1746. {
  1747. return FALSE;
  1748. }
  1750. pXLCD->dwItemData = dwData;
  1752. return TRUE;
  1753. }
  1755. ///////////////////////////////////////////////////////////////////////////////
  1756. // GetHeaderCheckedState
  1757. //
  1758. // The GetHeaderCheckedState and SetHeaderCheckedState may be used to toggle
  1759. // the checkbox in a column header.
  1760. //     0 = no checkbox
  1761. //     1 = unchecked
  1762. //     2 = checked
  1763. //
  1764. int CXListCtrl::GetHeaderCheckedState(int nSubItem)
  1765. {
  1766. ASSERT(nSubItem >= 0);
  1767. ASSERT(nSubItem < GetColumns());
  1768. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1769. return -1;
  1771. HDITEM hditem;
  1773. // use the image index (0 or 1) to indicate the checked status
  1774. hditem.mask = HDI_IMAGE;
  1775. m_HeaderCtrl.GetItem(nSubItem, &hditem);
  1776. return hditem.iImage;
  1777. }
  1779. ///////////////////////////////////////////////////////////////////////////////
  1780. // SetHeaderCheckedState
  1781. BOOL CXListCtrl::SetHeaderCheckedState(int nSubItem, int nCheckedState)
  1782. {
  1783. ASSERT(nSubItem >= 0);
  1784. ASSERT(nSubItem < GetColumns());
  1785. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1786. return FALSE;
  1787. ASSERT(nCheckedState == 0 || nCheckedState == 1 || nCheckedState == 2);
  1789. HDITEM hditem;
  1791. hditem.mask = HDI_IMAGE;
  1792. hditem.iImage = nCheckedState;
  1793. m_HeaderCtrl.SetItem(nSubItem, &hditem);
  1795. return TRUE;
  1796. }
  1798. ///////////////////////////////////////////////////////////////////////////////
  1799. // OnColumnClick
  1800. BOOL CXListCtrl::OnColumnClick(NMHDR* pNMHDR, LRESULT* pResult)
  1801. {
  1802. NMLISTVIEW* pnmlv = (NMLISTVIEW*)pNMHDR;
  1804. int nSubItem = pnmlv->iSubItem;
  1806. int nCheckedState = GetHeaderCheckedState(nSubItem);
  1808. // 0 = no checkbox
  1809. if (nCheckedState != XHEADERCTRL_NO_IMAGE)
  1810. {
  1811. nCheckedState = (nCheckedState == 1) ? 2 : 1;
  1812. SetHeaderCheckedState(nSubItem, nCheckedState);
  1814. m_HeaderCtrl.UpdateWindow();
  1816. for (int nItem = 0; nItem < GetItemCount(); nItem++)
  1817. {
  1818. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1819. if (!pXLCD)
  1820. {
  1821. continue;
  1822. }
  1824. if (pXLCD[nSubItem].nCheckedState != -1)
  1825. {
  1826. pXLCD[nSubItem].nCheckedState = nCheckedState - 1;
  1827. UpdateSubItem(nItem, nSubItem);
  1828. }
  1829. }
  1830. }
  1832. *pResult = 0;
  1833. return FALSE; // return FALSE to send message to parent also -
  1834. // NOTE:  MSDN documentation is incorrect
  1835. }
  1837. ///////////////////////////////////////////////////////////////////////////////
  1838. // CountCheckedItems
  1839. int CXListCtrl::CountCheckedItems(int nSubItem)
  1840. {
  1841. ASSERT(nSubItem >= 0);
  1842. ASSERT(nSubItem < GetColumns());
  1843. if ((nSubItem < 0) || nSubItem >= GetColumns())
  1844. return 0;
  1846. int nCount = 0;
  1848. for (int nItem = 0; nItem < GetItemCount(); nItem++)
  1849. {
  1850. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  1851. if (!pXLCD)
  1852. {
  1853. continue;
  1854. }
  1856. if (pXLCD[nSubItem].nCheckedState == 1)
  1857. nCount++;
  1858. }
  1860. return nCount;
  1861. }
  1863. ///////////////////////////////////////////////////////////////////////////////
  1864. // OnSysColorChange
  1865. void CXListCtrl::OnSysColorChange()
  1866. {
  1867. TRACE(_T("in CXListCtrl::OnSysColorChangen"));
  1869. CListCtrl::OnSysColorChange();
  1871. m_cr3DFace        = ::GetSysColor(COLOR_3DFACE);
  1872. m_cr3DHighLight   = ::GetSysColor(COLOR_3DHIGHLIGHT);
  1873. m_cr3DShadow      = ::GetSysColor(COLOR_3DSHADOW);
  1874. m_crBtnFace       = ::GetSysColor(COLOR_BTNFACE);
  1875. m_crBtnShadow     = ::GetSysColor(COLOR_BTNSHADOW);
  1876. m_crBtnText       = ::GetSysColor(COLOR_BTNTEXT);
  1877. m_crGrayText      = ::GetSysColor(COLOR_GRAYTEXT);
  1878. m_crHighLight     = ::GetSysColor(COLOR_HIGHLIGHT);
  1879. m_crHighLightText = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
  1880. m_crWindow        = ::GetSysColor(COLOR_WINDOW);
  1881. m_crWindowText    = ::GetSysColor(COLOR_WINDOWTEXT);
  1882. }
  1885. #ifndef DO_NOT_INCLUDE_XCOMBOLIST
  1887. ///////////////////////////////////////////////////////////////////////////////
  1888. // UnpressComboButton
  1889. void CXListCtrl::UnpressComboButton()
  1890. {
  1891. static BOOL bFlag = FALSE;
  1892. if (bFlag)
  1893. return;
  1894. bFlag = TRUE;
  1896. if (m_bComboIsClicked)
  1897. {
  1898. if (m_nComboItem >= 0 && m_nComboItem < GetItemCount())
  1899. {
  1900. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(m_nComboItem);
  1902. if (pXLCD)
  1903. {
  1904. if (m_nComboSubItem >= 0 && m_nComboSubItem < GetColumns())
  1905. {
  1906. pXLCD[m_nComboSubItem].bComboIsClicked = FALSE;
  1908. UpdateSubItem(m_nComboItem, m_nComboSubItem);
  1909. }
  1910. }
  1911. }
  1912. }
  1913. m_bComboIsClicked = FALSE;
  1914. bFlag = FALSE;
  1915. }
  1917. ///////////////////////////////////////////////////////////////////////////////
  1918. // OnTimer
  1919. //
  1920. // Timer usage:
  1921. //    1 - used to check if combo button needs to be unpressed,set in
  1922. //        OnLButtonDown (when combo button is clicked)
  1923. //    2 - used to close combo listbox, set in OnComboEscape (user hits Escape
  1924. //        or listbox loses focus)
  1925. //    3 - used to get combo listbox selection, then close combo listbox,
  1926. //        set in OnComboReturn and OnComboLButtonUp (user hits Enter
  1927. //        or clicks on item in listbox)
  1928. //    4 - used to get combo listbox selection, set in OnComboKeydown (for
  1929. //        example, user hits arrow key in listbox)
  1930. //
  1931. void CXListCtrl::OnTimer(UINT nIDEvent)
  1932. {
  1933. if (nIDEvent == 1) // timer set when combo button is clicked
  1934. {
  1935. if (m_bComboIsClicked)
  1936. {
  1937. POINT point;
  1938. ::GetCursorPos(&point);
  1939. ScreenToClient(&point);
  1941. if (!m_rectComboButton.PtInRect(point))
  1942. {
  1943. UnpressComboButton();
  1944. }
  1945. }
  1946. else if (m_pListBox)
  1947. {
  1948. m_pListBox->SetActive(11);
  1949. }
  1950. else
  1951. {
  1952. KillTimer(nIDEvent);
  1953. }
  1954. }
  1955. else if (nIDEvent == 2) // close combo listbox
  1956. {
  1957. KillTimer(nIDEvent);
  1959. if (m_pListBox)
  1960. {
  1961. m_pListBox->DestroyWindow();
  1962. delete m_pListBox;
  1963. }
  1964. m_pListBox = NULL;
  1965. }
  1966. else if (nIDEvent == 3) // get combo listbox selection, then close combo listbox
  1967. {
  1968. KillTimer(nIDEvent);
  1970. if (m_pListBox)
  1971. {
  1972. CString str;
  1973. int i = m_pListBox->GetCurSel();
  1974. if (i != LB_ERR)
  1975. {
  1976. m_pListBox->GetText(i, str);
  1978. if ((m_nComboItem >= 0 && m_nComboItem < GetItemCount()) &&
  1979. (m_nComboSubItem >= 0 && m_nComboSubItem < GetColumns()))
  1980. {
  1981. SetItemText(m_nComboItem, m_nComboSubItem, str);
  1983. UpdateSubItem(m_nComboItem, m_nComboSubItem);
  1985. CWnd *pWnd = GetParent();
  1986. if (!pWnd)
  1987. pWnd = GetOwner();
  1988. if (pWnd && ::IsWindow(pWnd->m_hWnd))
  1989. pWnd->SendMessage(WM_XLISTCTRL_COMBO_SELECTION, 
  1990. m_nComboItem, m_nComboSubItem);
  1991. }
  1992. }
  1994. m_pListBox->DestroyWindow();
  1995. delete m_pListBox;
  1996. }
  1997. m_pListBox = NULL;
  1998. }
  1999. else if (nIDEvent == 4) // get combo listbox selection
  2000. {
  2001. KillTimer(nIDEvent);
  2003. if (m_pListBox)
  2004. {
  2005. CString str;
  2006. int i = m_pListBox->GetCurSel();
  2007. if (i != LB_ERR)
  2008. {
  2009. m_pListBox->GetText(i, str);
  2011. if ((m_nComboItem >= 0 && m_nComboItem < GetItemCount()) &&
  2012. (m_nComboSubItem >= 0 && m_nComboSubItem < GetColumns()))
  2013. {
  2014. SetItemText(m_nComboItem, m_nComboSubItem, str);
  2016. UpdateSubItem(m_nComboItem, m_nComboSubItem);
  2017. }
  2018. }
  2019. }
  2020. }
  2021. }
  2023. ///////////////////////////////////////////////////////////////////////////////
  2024. // OnComboEscape
  2025. LRESULT CXListCtrl::OnComboEscape(WPARAM, LPARAM)
  2026. {
  2027. KillTimer(1);
  2028. SetTimer(2, 50, NULL);
  2030. // restore original string
  2031. SetItemText(m_nComboItem, m_nComboSubItem, m_strInitialComboString);
  2033. UpdateSubItem(m_nComboItem, m_nComboSubItem);
  2035. return 0;
  2036. }
  2038. ///////////////////////////////////////////////////////////////////////////////
  2039. // OnComboReturn
  2040. LRESULT CXListCtrl::OnComboReturn(WPARAM, LPARAM)
  2041. {
  2042. TRACE(_T("in CXListCtrl::OnComboReturnn"));
  2043. KillTimer(1);
  2044. SetTimer(3, 50, NULL);
  2045. return 0;
  2046. }
  2048. ///////////////////////////////////////////////////////////////////////////////
  2049. // OnComboLButtonUp
  2050. LRESULT CXListCtrl::OnComboLButtonUp(WPARAM, LPARAM)
  2051. {
  2052. TRACE(_T("in CXListCtrl::OnComboLButtonUpn"));
  2053. KillTimer(1);
  2054. SetTimer(3, 50, NULL);
  2055. return 0;
  2056. }
  2058. ///////////////////////////////////////////////////////////////////////////////
  2059. // OnComboKeydown
  2060. LRESULT CXListCtrl::OnComboKeydown(WPARAM, LPARAM)
  2061. {
  2062. SetTimer(4, 50, NULL);
  2063. return 0;
  2064. }
  2066. #endif
  2068. #ifndef NO_XLISTCTRL_TOOL_TIPS
  2070. ///////////////////////////////////////////////////////////////////////////////
  2071. // OnToolHitTest
  2072. int CXListCtrl::OnToolHitTest(CPoint point, TOOLINFO * pTI) const
  2073. {
  2074. LVHITTESTINFO lvhitTestInfo;
  2076. lvhitTestInfo.pt = point;
  2078. int nItem = ListView_SubItemHitTest(this->m_hWnd, &lvhitTestInfo);
  2079. int nSubItem = lvhitTestInfo.iSubItem;
  2080. TRACE(_T("in CToolTipListCtrl::OnToolHitTest: %d,%dn"), nItem, nSubItem);
  2082. UINT nFlags = lvhitTestInfo.flags;
  2084. // nFlags is 0 if the SubItemHitTest fails
  2085. // Therefore, 0 & <anything> will equal false
  2086. if (nFlags & LVHT_ONITEMLABEL)
  2087. {
  2088. // If it did fall on a list item,
  2089. // and it was also hit one of the
  2090. // item specific subitems we wish to show tool tips for
  2092. // get the client (area occupied by this control
  2093. RECT rcClient;
  2094. GetClientRect(&rcClient);
  2096. // fill in the TOOLINFO structure
  2097. pTI->hwnd = m_hWnd;
  2098. pTI->uId = (UINT) (nItem * 1000 + nSubItem + 1);
  2099. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2100. pTI->rect = rcClient;
  2102. return pTI->uId; // By returning a unique value per listItem,
  2103. // we ensure that when the mouse moves over another
  2104. // list item, the tooltip will change
  2105. }
  2106. else
  2107. {
  2108. //Otherwise, we aren't interested, so let the message propagate
  2109. return -1;
  2110. }
  2111. }
  2113. ///////////////////////////////////////////////////////////////////////////////
  2114. // OnToolTipText
  2115. BOOL CXListCtrl::OnToolTipText(UINT /*id*/, NMHDR * pNMHDR, LRESULT * pResult)
  2116. {
  2117. UINT nID = pNMHDR->idFrom;
  2118. TRACE(_T("in CXListCtrl::OnToolTipText: id=%dn"), nID);
  2120. // check if this is the automatic tooltip of the control
  2121. if (nID == 0) 
  2122. return TRUE; // do not allow display of automatic tooltip,
  2123. // or our tooltip will disappear
  2125. // handle both ANSI and UNICODE versions of the message
  2126. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  2127. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  2129. *pResult = 0;
  2131. // get the mouse position
  2132. const MSG* pMessage;
  2133. pMessage = GetCurrentMessage();
  2134. ASSERT(pMessage);
  2135. CPoint pt;
  2136. pt = pMessage->pt; // get the point from the message
  2137. ScreenToClient(&pt); // convert the point's coords to be relative to this control
  2139. // see if the point falls onto a list item
  2141. LVHITTESTINFO lvhitTestInfo;
  2143. lvhitTestInfo.pt = pt;
  2145. int nItem = SubItemHitTest(&lvhitTestInfo);
  2146. int nSubItem = lvhitTestInfo.iSubItem;
  2148. UINT nFlags = lvhitTestInfo.flags;
  2150. // nFlags is 0 if the SubItemHitTest fails
  2151. // Therefore, 0 & <anything> will equal false
  2152. if (nFlags & LVHT_ONITEMLABEL)
  2153. {
  2154. // If it did fall on a list item,
  2155. // and it was also hit one of the
  2156. // item specific subitems we wish to show tooltips for
  2158. CString strToolTip;
  2159. strToolTip = _T("");
  2161. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  2162. if (pXLCD)
  2163. {
  2164. strToolTip = pXLCD[nSubItem].strToolTip;
  2165. }
  2167. if (!strToolTip.IsEmpty())
  2168. {
  2169. // If there was a CString associated with the list item,
  2170. // copy it's text (up to 80 characters worth, limitation 
  2171. // of the TOOLTIPTEXT structure) into the TOOLTIPTEXT 
  2172. // structure's szText member
  2174. #ifndef _UNICODE
  2175. if (pNMHDR->code == TTN_NEEDTEXTA)
  2176. lstrcpyn(pTTTA->szText, strToolTip, 80);
  2177. else
  2178. _mbstowcsz(pTTTW->szText, strToolTip, 80);
  2179. #else
  2180. if (pNMHDR->code == TTN_NEEDTEXTA)
  2181. _wcstombsz(pTTTA->szText, strToolTip, 80);
  2182. else
  2183. lstrcpyn(pTTTW->szText, strToolTip, 80);
  2184. #endif
  2185. return FALSE;  // we found a tool tip,
  2186. }
  2187. }
  2189. return FALSE; // we didn't handle the message, let the 
  2190. // framework continue propagating the message
  2191. }
  2193. ///////////////////////////////////////////////////////////////////////////////
  2194. // SetItemToolTipText
  2195. BOOL CXListCtrl::SetItemToolTipText(int nItem, int nSubItem, LPCTSTR lpszToolTipText)
  2196. {
  2197. ASSERT(nItem >= 0);
  2198. ASSERT(nItem < GetItemCount());
  2199. if ((nItem < 0) || nItem >= GetItemCount())
  2200. return FALSE;
  2201. ASSERT(nSubItem >= 0);
  2202. ASSERT(nSubItem < GetColumns());
  2203. if ((nSubItem < 0) || nSubItem >= GetColumns())
  2204. return FALSE;
  2206. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  2207. if (!pXLCD)
  2208. {
  2209. return FALSE;
  2210. }
  2212. pXLCD[nSubItem].strToolTip = lpszToolTipText;
  2214. return TRUE;
  2215. }
  2217. ///////////////////////////////////////////////////////////////////////////////
  2218. // GetItemToolTipText
  2219. CString CXListCtrl::GetItemToolTipText(int nItem, int nSubItem)
  2220. {
  2221. CString strToolTip;
  2222. strToolTip = _T("");
  2224. ASSERT(nItem >= 0);
  2225. ASSERT(nItem < GetItemCount());
  2226. if ((nItem < 0) || nItem >= GetItemCount())
  2227. return strToolTip;
  2228. ASSERT(nSubItem >= 0);
  2229. ASSERT(nSubItem < GetColumns());
  2230. if ((nSubItem < 0) || nSubItem >= GetColumns())
  2231. return strToolTip;
  2233. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  2234. if (pXLCD)
  2235. {
  2236. strToolTip = pXLCD[nSubItem].strToolTip;
  2237. }
  2239. return strToolTip;
  2240. }
  2242. ///////////////////////////////////////////////////////////////////////////////
  2243. // DeleteAllToolTips
  2244. void CXListCtrl::DeleteAllToolTips()
  2245. {
  2246. int nRow = GetItemCount();
  2247. int nCol = GetColumns();
  2249. for (int nItem = 0; nItem < nRow; nItem++)
  2250. {
  2251. XLISTCTRLDATA *pXLCD = (XLISTCTRLDATA *) CListCtrl::GetItemData(nItem);
  2252. if (pXLCD)
  2253. for (int nSubItem = 0; nSubItem < nCol; nSubItem++)
  2254. pXLCD[nSubItem].strToolTip = _T("");
  2255. }
  2256. }
  2258. #endif