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

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

对话框与窗口

开发平台：

Visual C++

XTCheckListBox.cpp：源码内容
  1. // XTCheckListBox.cpp : implementation of the CXTCheckListBox 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"
  22. #include "Resource.h"
  24. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  25. #include "Common/XTPResourceManager.h"
  26. #include "Common/XTPWinThemeWrapper.h"
  28. #include "XTGlobal.h"
  30. #include "XTListBox.h"
  31. #include "XTCheckListBox.h"
  33. #ifndef LAYOUT_BITMAPORIENTATIONPRESERVED
  34. #define LAYOUT_BITMAPORIENTATIONPRESERVED  0x00000008
  35. #endif
  37. #ifdef _DEBUG
  38. #define new DEBUG_NEW
  39. #undef THIS_FILE
  40. static char THIS_FILE[] = __FILE__;
  41. #endif
  43. /////////////////////////////////////////////////////////////////////////////
  44. // CXTCheckListState
  46. CXTCheckListBox::CCheckListState::CCheckListState(BOOL bListBox3D)
  47. {
  48. CBitmap bitmap;
  49. VERIFY(XTPResourceManager()->LoadBitmap(&bitmap, !bListBox3D ? XT_IDB_CHECKLISTBOX : XT_IDB_CHECKLISTBOX_3D));
  51. BITMAP bm;
  52. bitmap.GetObject(sizeof(BITMAP), &bm);
  53. m_sizeCheck.cx = bm.bmWidth / 3;
  54. m_sizeCheck.cy = bm.bmHeight;
  55. m_hbitmapCheck = (HBITMAP)bitmap.Detach();
  56. }
  58. CXTCheckListBox::CCheckListState::~CCheckListState()
  59. {
  60. if (m_hbitmapCheck != NULL)
  61. ::DeleteObject(m_hbitmapCheck);
  62. }
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CHECK_DATA
  67. struct CXTCheckListBox::CHECK_DATA
  68. {
  69. public:
  70. int m_nCheck;
  71. BOOL m_bEnabled;
  72. DWORD_PTR m_dwUserData;
  74. CHECK_DATA()
  75. {
  76. m_nCheck = 0;
  77. m_bEnabled = TRUE;
  78. m_dwUserData = 0;
  79. }
  80. };
  82. /////////////////////////////////////////////////////////////////////////////
  83. // CXTCheckListBox
  85. CXTCheckListBox::CXTCheckListBox(BOOL bListBox3D /* = FALSE */)
  86. : m_checkListState(bListBox3D)
  87. , m_cyText(0)
  88. , m_nStyle(0)
  89. {
  91. }
  93. CXTCheckListBox::~CXTCheckListBox()
  94. {
  96. }
  98. IMPLEMENT_DYNAMIC(CXTCheckListBox, CXTListBox)
  100. BEGIN_MESSAGE_MAP(CXTCheckListBox, CXTListBox)
  101. //{{AFX_MSG_MAP(CXTCheckListBox)
  102. ON_WM_LBUTTONDOWN()
  103. ON_WM_KEYDOWN()
  104. ON_WM_CREATE()
  105. ON_WM_LBUTTONDBLCLK()
  106. ON_MESSAGE(WM_SETFONT, OnSetFont)
  107. ON_MESSAGE(LB_ADDSTRING, OnLBAddString)
  108. ON_MESSAGE(LB_FINDSTRING, OnLBFindString)
  109. ON_MESSAGE(LB_FINDSTRINGEXACT, OnLBFindStringExact)
  110. ON_MESSAGE(LB_GETITEMDATA, OnLBGetItemData)
  111. ON_MESSAGE(LB_GETTEXT, OnLBGetText)
  112. ON_MESSAGE(LB_INSERTSTRING, OnLBInsertString)
  113. ON_MESSAGE(LB_SELECTSTRING, OnLBSelectString)
  114. ON_MESSAGE(LB_SETITEMDATA, OnLBSetItemData)
  115. ON_MESSAGE(LB_SETITEMHEIGHT, OnLBSetItemHeight)
  116. //}}AFX_MSG_MAP
  117. END_MESSAGE_MAP()
  119. BOOL CXTCheckListBox::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  120. {
  121. if (!(dwStyle & LBS_OWNERDRAWVARIABLE)) //must be one or the other
  122. {
  123. dwStyle |= LBS_OWNERDRAWFIXED;
  124. }
  126. return CXTListBox::Create(dwStyle, rect, pParentWnd, nID);
  127. }
  129. void CXTCheckListBox::SetCheckStyle(UINT nStyle)
  130. {
  131. ASSERT(
  132. nStyle == 0 ||
  133. nStyle == BS_CHECKBOX ||
  134. nStyle == BS_AUTOCHECKBOX ||
  135. nStyle == BS_AUTO3STATE ||
  136. nStyle == BS_3STATE);
  138. m_nStyle = nStyle;
  139. }
  141. void CXTCheckListBox::SetCheck(int nIndex, int nCheck)
  142. {
  143. ASSERT(::IsWindow(m_hWnd));
  145. if (nCheck == 2)
  146. {
  147. if (m_nStyle == BS_CHECKBOX || m_nStyle == BS_AUTOCHECKBOX)
  148. return;
  149. }
  151. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  152. if (lResult != LB_ERR)
  153. {
  155. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  157. if (pState == NULL)
  158. pState = new CHECK_DATA;
  160. pState->m_nCheck = nCheck;
  161. VERIFY(DefWindowProc(LB_SETITEMDATA, nIndex, (LPARAM)pState) != LB_ERR);
  163. InvalidateCheck(nIndex);
  164. }
  165. }
  167. int CXTCheckListBox::GetCheck(int nIndex)
  168. {
  169. ASSERT(::IsWindow(m_hWnd));
  171. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  172. if (lResult != LB_ERR)
  173. {
  174. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  175. if (pState != NULL)
  176. return pState->m_nCheck;
  177. }
  178. return 0; // The default
  179. }
  181. void CXTCheckListBox::Enable(int nIndex, BOOL bEnabled)
  182. {
  183. ASSERT(::IsWindow(m_hWnd));
  185. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  186. if (lResult != LB_ERR)
  187. {
  188. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  190. if (pState == NULL)
  191. pState = new CHECK_DATA;
  193. pState->m_bEnabled = bEnabled;
  194. VERIFY(DefWindowProc(LB_SETITEMDATA, nIndex, (LPARAM)pState) != LB_ERR);
  196. InvalidateItem(nIndex);
  197. }
  198. }
  200. int CXTCheckListBox::IsEnabled(int nIndex)
  201. {
  202. ASSERT(::IsWindow(m_hWnd));
  204. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  205. if (lResult != LB_ERR)
  206. {
  207. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  208. if (pState != NULL)
  209. return pState->m_bEnabled;
  210. }
  211. return TRUE; // The default
  212. }
  214. CRect CXTCheckListBox::OnGetCheckPosition(CRect, CRect rectCheckBox)
  215. {
  216. return rectCheckBox;
  217. }
  219. void CXTCheckListBox::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  220. {
  221. // Must be LBS_OWNERDRAWVARIABLE or LBS_OWNERDRAWFIXED and LBS_HASSTRINGS
  222. ASSERT(GetStyle() & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE));
  223. ASSERT(GetStyle() & (LBS_HASSTRINGS));
  226. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  227. CRect rcItem(lpDIS->rcItem);
  228. rcItem.left += 2;
  230. if (((LONG)(lpDIS->itemID) >= 0) &&
  231. (lpDIS->itemAction & (ODA_DRAWENTIRE | ODA_SELECT)))
  232. {
  233. int cyItem = GetItemHeight(lpDIS->itemID);
  234. BOOL fDisabled = !IsWindowEnabled() || !IsEnabled(lpDIS->itemID);
  236. COLORREF newTextColor = fDisabled ?
  237. RGB(0x80, 0x80, 0x80) : GetSysColor(COLOR_WINDOWTEXT);  // light gray
  238. COLORREF oldTextColor = pDC->SetTextColor(newTextColor);
  240. COLORREF newBkColor = GetSysColor(COLOR_WINDOW);
  241. COLORREF oldBkColor = pDC->SetBkColor(newBkColor);
  243. if (newTextColor == newBkColor)
  244. newTextColor = RGB(0xC0, 0xC0, 0xC0);   // dark gray
  246. if (!fDisabled && ((lpDIS->itemState & ODS_SELECTED) != 0))
  247. {
  248. pDC->SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
  249. pDC->SetBkColor(GetSysColor(COLOR_HIGHLIGHT));
  250. }
  252. if (m_cyText == 0)
  253. VERIFY(cyItem >= CalcMinimumItemHeight());
  255. CString strText;
  256. GetText(lpDIS->itemID, strText);
  258. pDC->ExtTextOut(rcItem.left + 2, rcItem.top,
  259. ETO_OPAQUE, &rcItem, strText, strText.GetLength(), NULL);
  261. pDC->SetTextColor(oldTextColor);
  262. pDC->SetBkColor(oldBkColor);
  263. }
  265. if ((lpDIS->itemAction & ODA_FOCUS) != 0)
  266. pDC->DrawFocusRect(&rcItem);
  267. }
  271. int CXTCheckListBox::GetFontHeight()
  272. {
  273. CWindowDC dc(NULL); // get the screen device context
  275. // select the control's font into the window dc.
  276. CFont* pOldFont = dc.SelectObject(GetFont());
  278. // get the text metrics for the device context that
  279. // is using the control's font, this will give us the
  280. // height in pixels that's what we will use for the
  281. // list item's height.
  282. TEXTMETRIC tm;
  283. dc.GetTextMetrics(&tm);
  285. // restore the dc with it's original font.
  286. dc.SelectObject(pOldFont);
  288. // return the desired row height.
  289. return tm.tmHeight;
  290. }
  292. void CXTCheckListBox::MeasureItem(LPMEASUREITEMSTRUCT lpMIS)
  293. {
  294. lpMIS->itemHeight = m_checkListState.m_sizeCheck.cy + ::GetSystemMetrics(SM_CYEDGE);
  295. }
  297. bool CXTCheckListBox::Init()
  298. {
  299. if (!CXTListBox::Init())
  300. return false;
  302. // If windows XP themes are supported, initialize the
  303. // theme wrapper used to display the check boxes.
  304. m_themeHelper.OpenThemeData(m_hWnd, L"BUTTON");
  306. return true;
  307. }
  309. bool CXTCheckListBox::PreDrawItemThemed(CDC* pDC, DRAWITEMSTRUCT &drawItem, int nCheck, int cyItem)
  310. {
  311. bool bRet = false;
  313. // Draw the check boxes using the theme API's only if the app is themed.
  314. if (m_themeHelper.IsAppThemeReady())
  315. {
  316. BOOL bEnabled = IsWindowEnabled() && IsEnabled(drawItem.itemID);
  318. int nState = 0;
  320. switch (nCheck)
  321. {
  322. case 0: // not checked
  323. nState = (bEnabled ? CBS_UNCHECKEDNORMAL : CBS_UNCHECKEDDISABLED);
  324. break;
  325. case 1: // checked
  326. nState = (bEnabled ? CBS_CHECKEDNORMAL : CBS_CHECKEDDISABLED);
  327. break;
  328. case 2: // intermediate
  329. nState = (bEnabled ? CBS_MIXEDNORMAL : CBS_MIXEDDISABLED);
  330. break;
  331. }
  333. SIZE size;
  335. if (SUCCEEDED(m_themeHelper.GetThemePartSize(pDC->m_hDC, BP_CHECKBOX, nState, NULL, TS_TRUE, &size)))
  336. {
  337. CRect rectCheck = drawItem.rcItem;
  338. rectCheck.left += 1;
  339. rectCheck.top += max(0, (cyItem - size.cy) / 2);
  340. rectCheck.right = rectCheck.left + size.cx;
  341. rectCheck.bottom = rectCheck.top + size.cy;
  343. CRect rectItem = drawItem.rcItem;
  344. rectItem.right = rectItem.left + size.cx + 2;
  346. CRect rectCheckBox = OnGetCheckPosition(rectItem, rectCheck);
  348. if (SUCCEEDED(m_themeHelper.DrawThemeBackground(pDC->m_hDC, BP_CHECKBOX, nState, &rectCheckBox, NULL)))
  349. {
  350. bRet = true;
  351. }
  352. }
  353. }
  354. return bRet;
  355. }
  357. void CXTCheckListBox::PreDrawItemNonThemed(CDC* pDC, DRAWITEMSTRUCT &drawItem, int nCheck, int cyItem)
  358. {
  359. CDC bitmapDC;
  360. if (bitmapDC.CreateCompatibleDC(pDC))
  361. {
  362. // redraw background.
  363. pDC->FillSolidRect(&drawItem.rcItem,
  364. ::GetSysColor(COLOR_WINDOW));
  366. #if _MSC_VER >= 1200 // MFC 6.0
  367. // Change Compatible DC to LTR since the bitmap is LTR
  368. DWORD dwLayoutBitmapDC = bitmapDC.GetLayout();
  369. bitmapDC.SetLayout(0);
  370. #endif
  372. HBITMAP hOldBitmap = (HBITMAP)::SelectObject(bitmapDC.m_hDC, m_checkListState.m_hbitmapCheck);
  374. CRect rectCheck = drawItem.rcItem;
  375. rectCheck.left += 1;
  376. rectCheck.top += max(0, (cyItem - m_checkListState.m_sizeCheck.cy) / 2);
  377. rectCheck.right = rectCheck.left + m_checkListState.m_sizeCheck.cx;
  378. rectCheck.bottom = rectCheck.top + m_checkListState.m_sizeCheck.cy;
  380. CRect rectItem = drawItem.rcItem;
  381. rectItem.right = rectItem.left + m_checkListState.m_sizeCheck.cx + 2;
  382. CRect rectCheckBox = OnGetCheckPosition(rectItem, rectCheck);
  384. pDC->FillSolidRect(rectItem, pDC->GetBkColor());
  386. #if _MSC_VER >= 1200 // MFC 6.0
  387. DWORD dwLayoutDC = pDC->GetLayout();
  389. // Change destination DC layout to preserve bitmap orientation
  390. pDC->SetLayout(dwLayoutDC | LAYOUT_BITMAPORIENTATIONPRESERVED);
  391. #endif
  393. pDC->BitBlt(rectCheckBox.left, rectCheckBox.top,
  394. m_checkListState.m_sizeCheck.cx, m_checkListState.m_sizeCheck.cy, &bitmapDC,
  395. m_checkListState.m_sizeCheck.cx * nCheck, 0, SRCCOPY);
  397. #if _MSC_VER >= 1200 // MFC 6.0
  398. // Restore DC layout
  399. pDC->SetLayout(dwLayoutDC);
  401. bitmapDC.SetLayout(dwLayoutBitmapDC);
  402. #endif
  403. ::SelectObject(bitmapDC.m_hDC, hOldBitmap);
  404. }
  405. }
  408. void CXTCheckListBox::PreDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  409. {
  410. DRAWITEMSTRUCT drawItem;
  411. MEMCPY_S(&drawItem, lpDrawItemStruct, sizeof(DRAWITEMSTRUCT));
  413. if ((((LONG)drawItem.itemID) >= 0) &&
  414. ((drawItem.itemAction & (ODA_DRAWENTIRE | ODA_SELECT)) != 0))
  415. {
  416. int cyItem = GetItemHeight(drawItem.itemID);
  418. CDC* pDC = CDC::FromHandle(drawItem.hDC);
  420. COLORREF newBkColor = GetSysColor(COLOR_WINDOW);
  422. BOOL fDisabled = !IsWindowEnabled() || !IsEnabled(drawItem.itemID);
  423. if ((drawItem.itemState & ODS_SELECTED) && !fDisabled)
  424. newBkColor = GetSysColor(COLOR_HIGHLIGHT);
  426. COLORREF oldBkColor = pDC->SetBkColor(newBkColor);
  428. int nCheck = GetCheck(drawItem.itemID);
  430. if (!PreDrawItemThemed(pDC, drawItem, nCheck, cyItem))
  431. {
  432. PreDrawItemNonThemed(pDC, drawItem, nCheck, cyItem);
  433. }
  435. pDC->SetBkColor(oldBkColor);
  436. }
  438. if (drawItem.itemData != 0 && drawItem.itemData != (UINT)LB_ERR)
  439. {
  440. CHECK_DATA* pState = (CHECK_DATA*)drawItem.itemData;
  441. drawItem.itemData = pState->m_dwUserData;
  442. }
  443. drawItem.rcItem.left = drawItem.rcItem.left + m_checkListState.m_sizeCheck.cx + 2;
  445. DrawItem(&drawItem);
  446. }
  448. /*
  449. void CXTCheckListBox::PreDrawItem(LPDRAWITEMSTRUCT lpDIS)
  450. {
  451. DRAWITEMSTRUCT drawItem;
  453. MEMCPY_S(&drawItem, lpDIS, sizeof(DRAWITEMSTRUCT));
  455. if ((((LONG)drawItem.itemID) >= 0) &&
  456. ((drawItem.itemAction & (ODA_DRAWENTIRE | ODA_SELECT)) != 0))
  457. {
  458. int cyItem = GetItemHeight(drawItem.itemID);
  460. CDC* pDC = CDC::FromHandle(drawItem.hDC);
  462. COLORREF newBkColor = GetSysColor(COLOR_WINDOW);
  463. COLORREF oldBkColor = pDC->SetBkColor(newBkColor);
  465. CDC bitmapDC;
  466. if (bitmapDC.CreateCompatibleDC(pDC))
  467. {
  468. int nCheck = GetCheck(drawItem.itemID);
  469. HBITMAP hOldBitmap = (HBITMAP)::SelectObject(bitmapDC.m_hDC, m_checkListState.m_hbitmapCheck);
  471. CRect rectCheck = drawItem.rcItem;
  472. rectCheck.left += 1;
  473. rectCheck.top += 1 + __max(0, (cyItem - m_checkListState.m_sizeCheck.cy) / 2);
  474. rectCheck.right = rectCheck.left + m_checkListState.m_sizeCheck.cx;
  475. rectCheck.bottom = rectCheck.top + m_checkListState.m_sizeCheck.cy;
  477. CRect rectItem = drawItem.rcItem;
  478. rectItem.right = rectItem.left + m_checkListState.m_sizeCheck.cx + 2;
  480. CRect rectCheckBox = OnGetCheckPosition(rectItem, rectCheck);
  482. CBrush brush(newBkColor);
  483. pDC->FillRect(rectItem, &brush);
  485. pDC->BitBlt(rectCheckBox.left, rectCheckBox.top,
  486. m_checkListState.m_sizeCheck.cx, m_checkListState.m_sizeCheck.cy, &bitmapDC,
  487. m_checkListState.m_sizeCheck.cx * nCheck, 0, SRCCOPY);
  489. ::SelectObject(bitmapDC.m_hDC, hOldBitmap);
  490. brush.DeleteObject();
  491. }
  492. pDC->SetBkColor(oldBkColor);
  493. bitmapDC.DeleteDC();
  494. }
  496. if (drawItem.itemData != 0 && drawItem.itemData != (UINT)LB_ERR)
  497. {
  498. CHECK_DATA* pState = (CHECK_DATA*)drawItem.itemData;
  499. drawItem.itemData = pState->m_dwUserData;
  500. }
  501. drawItem.rcItem.left = drawItem.rcItem.left + m_checkListState.m_sizeCheck.cx + 2;
  503. DrawItem(&drawItem);
  504. }*/
  506. void CXTCheckListBox::PreMeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  507. {
  508. int cyItem = CalcMinimumItemHeight();
  510. MEASUREITEMSTRUCT measureItem;
  512. MEMCPY_S(&measureItem, lpMeasureItemStruct, sizeof(MEASUREITEMSTRUCT));
  514. measureItem.itemHeight = cyItem;
  515. measureItem.itemWidth = (UINT)-1;
  517. // WINBUG: Windows95 and Windows NT disagree on what this value
  518. // should be.  According to the docs, they are both wrong
  519. if (GetStyle() & LBS_OWNERDRAWVARIABLE)
  520. {
  521. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, measureItem.itemID, 0);
  522. if (lResult != LB_ERR)
  523. measureItem.itemData = (UINT)lResult;
  524. else
  525. measureItem.itemData = 0;
  527. // WINBUG: This is only done in the LBS_OWNERDRAWVARIABLE case
  528. // because Windows 95 does not initialize itemData to zero in the
  529. // case of LBS_OWNERDRAWFIXED list boxes (it is stack garbage).
  530. if (measureItem.itemData != 0 && measureItem.itemData != (UINT)LB_ERR)
  531. {
  532. CHECK_DATA* pState = (CHECK_DATA*)measureItem.itemData;
  533. measureItem.itemData = pState->m_dwUserData;
  534. }
  535. }
  537. MeasureItem(&measureItem);
  539. lpMeasureItemStruct->itemHeight = max(measureItem.itemHeight, (UINT) cyItem);
  540. lpMeasureItemStruct->itemWidth = measureItem.itemWidth;
  541. }
  543. int CXTCheckListBox::PreCompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct)
  544. {
  545. COMPAREITEMSTRUCT compareItem;
  547. MEMCPY_S(&compareItem, lpCompareItemStruct, sizeof(COMPAREITEMSTRUCT));
  549. if (compareItem.itemData1 != 0 && compareItem.itemData1 != (UINT)LB_ERR)
  550. {
  551. CHECK_DATA* pState = (CHECK_DATA*)compareItem.itemData1;
  552. compareItem.itemData1 = pState->m_dwUserData;
  553. }
  554. if (compareItem.itemData2 != 0 && compareItem.itemData2 != (UINT)LB_ERR)
  555. {
  556. CHECK_DATA* pState = (CHECK_DATA*)compareItem.itemData2;
  557. compareItem.itemData2 = pState->m_dwUserData;
  558. }
  559. return CompareItem(&compareItem);
  560. }
  562. void CXTCheckListBox::PreDeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct)
  563. {
  564. DELETEITEMSTRUCT deleteItem;
  566. MEMCPY_S(&deleteItem, lpDeleteItemStruct, sizeof(DELETEITEMSTRUCT));
  568. // WINBUG: The following if block is required because Windows NT
  569. // version 3.51 does not properly fill out the LPDELETEITEMSTRUCT.
  570. if (deleteItem.itemData == 0)
  571. {
  572. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, deleteItem.itemID, 0);
  573. if (lResult != LB_ERR)
  574. deleteItem.itemData = (UINT)lResult;
  575. }
  577. if (deleteItem.itemData != 0 && deleteItem.itemData != (UINT)LB_ERR)
  578. {
  579. CHECK_DATA* pState = (CHECK_DATA*)deleteItem.itemData;
  580. deleteItem.itemData = pState->m_dwUserData;
  581. delete pState;
  582. }
  583. DeleteItem(&deleteItem);
  584. }
  586. BOOL CXTCheckListBox::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  587. {
  588. switch (message)
  589. {
  590. case WM_DRAWITEM:
  591. ASSERT(pResult == NULL);       // no return value expected
  592. PreDrawItem((LPDRAWITEMSTRUCT)lParam);
  593. break;
  594. case WM_MEASUREITEM:
  595. ASSERT(pResult == NULL);       // no return value expected
  596. PreMeasureItem((LPMEASUREITEMSTRUCT)lParam);
  597. break;
  598. case WM_COMPAREITEM:
  599. ASSERT(pResult != NULL);       // return value expected
  600. if (pResult == NULL)
  601. break;
  602. *pResult = PreCompareItem((LPCOMPAREITEMSTRUCT)lParam);
  603. break;
  604. case WM_DELETEITEM:
  605. ASSERT(pResult == NULL);       // no return value expected
  606. PreDeleteItem((LPDELETEITEMSTRUCT)lParam);
  607. break;
  608. default:
  609. return CXTListBox::OnChildNotify(message, wParam, lParam, pResult);
  610. }
  611. return TRUE;
  612. }
  614. void CXTCheckListBox::PreSubclassWindow()
  615. {
  616. CXTListBox::PreSubclassWindow();
  617. #ifdef _DEBUG
  618. // CCheckListBoxes must be owner drawn
  619. ASSERT(GetStyle() & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE));
  620. #endif
  621. }
  623. int CXTCheckListBox::CalcMinimumItemHeight()
  624. {
  625. int nResult;
  627. if ((GetStyle() & (LBS_HASSTRINGS | LBS_OWNERDRAWFIXED)) ==
  628. (LBS_HASSTRINGS | LBS_OWNERDRAWFIXED))
  629. {
  630. CClientDC dc(this);
  631. CFont* pOldFont = dc.SelectObject(GetFont());
  632. TEXTMETRIC tm;
  633. VERIFY (dc.GetTextMetrics (&tm));
  634. dc.SelectObject(pOldFont);
  636. m_cyText = tm.tmHeight;
  637. nResult = max(m_checkListState.m_sizeCheck.cy + 1, m_cyText);
  638. }
  639. else
  640. {
  641. nResult = m_checkListState.m_sizeCheck.cy + 1;
  642. }
  644. return nResult;
  645. }
  647. void CXTCheckListBox::InvalidateCheck(int nIndex)
  648. {
  649. CRect rect;
  651. GetItemRect(nIndex, rect);
  652. rect.right = rect.left + m_checkListState.m_sizeCheck.cx + 2;
  653. InvalidateRect(rect, FALSE);
  654. }
  656. void CXTCheckListBox::InvalidateItem(int nIndex)
  657. {
  658. CRect rect;
  659. GetItemRect(nIndex, rect);
  660. InvalidateRect(rect, FALSE);
  661. }
  663. int CXTCheckListBox::CheckFromPoint(CPoint point, BOOL& bInCheck)
  664. {
  665. // assume did not hit anything
  666. bInCheck = FALSE;
  667. int nIndex = -1;
  669. if ((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_MULTICOLUMN)) == LBS_OWNERDRAWFIXED)
  670. {
  671. // optimized case for ownerdraw fixed, single column
  672. int cyItem = GetItemHeight(0);
  673. if (point.y < cyItem * GetCount())
  674. {
  675. nIndex = GetTopIndex() + point.y / cyItem;
  676. if (point.x < m_checkListState.m_sizeCheck.cx + 2)
  677. ++bInCheck;
  678. }
  679. }
  680. else
  681. {
  682. // general case for ownerdraw variable or multiple column
  683. int i;
  684. for (i = GetTopIndex(); i < GetCount(); i++)
  685. {
  686. CRect itemRect;
  687. GetItemRect(i, &itemRect);
  688. if (itemRect.PtInRect(point))
  689. {
  690. nIndex = i;
  691. if (point.x < itemRect.left + m_checkListState.m_sizeCheck.cx + 2)
  692. ++bInCheck;
  693. break;
  694. }
  695. }
  696. }
  697. return nIndex;
  698. }
  700. void CXTCheckListBox::SetSelectionCheck(int nCheck)
  701. {
  702. int iSelectedItem, nSelectedItems = GetSelCount();
  704. if (nSelectedItems > 0)
  705. {
  706. CArray<int, int&> rgiSelectedItems;
  707. rgiSelectedItems.SetSize(nSelectedItems);
  708. int* piSelectedItems = rgiSelectedItems.GetData();
  710. GetSelItems(nSelectedItems, piSelectedItems);
  711. for (iSelectedItem = 0; iSelectedItem < nSelectedItems; iSelectedItem++)
  712. {
  713. if (IsEnabled(piSelectedItems[iSelectedItem]))
  714. {
  715. SetCheck(piSelectedItems[iSelectedItem], nCheck);
  716. InvalidateCheck(piSelectedItems[iSelectedItem]);
  717. }
  718. }
  719. }
  720. }
  722. void CXTCheckListBox::OnLButtonDown(UINT nFlags, CPoint point)
  723. {
  724. CRect itemRect;
  725. CRect clientRect;
  727. GetClientRect(clientRect);
  729. int nIndex;
  730. for (nIndex = GetTopIndex(); nIndex < GetCount(); nIndex++)
  731. {
  732. GetItemRect(nIndex, &itemRect);
  733. if (!clientRect.PtInRect(itemRect.TopLeft()))
  734. break;
  735. if (itemRect.PtInRect(point) && IsEnabled(nIndex))
  736. {
  737. if (m_nStyle != BS_CHECKBOX && m_nStyle != BS_3STATE)
  738. {
  739. if (point.x - itemRect.left < m_checkListState.m_sizeCheck.cx + 2)
  740. {
  741. CWnd* pParent = GetParent();
  742. ASSERT_VALID(pParent);
  743. int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  744. int nCheck = GetCheck(nIndex);
  745. nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  746. SetCheck(nIndex, (nCheck + 1) % nModulo);
  747. InvalidateCheck(nIndex);
  748. CXTListBox::OnLButtonDown(nFlags, point);
  750. // Inform of check
  751. pParent->SendMessage(WM_COMMAND,
  752. MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  753. (LPARAM)m_hWnd);
  754. return;
  756. }
  757. }
  758. else
  759. return; // Swallow LButtons for disabled items
  760. }
  761. }
  763. // do default listbox selection logic
  764. CXTListBox::OnLButtonDown(nFlags, point);
  765. }
  767. void CXTCheckListBox::OnLButtonDblClk(UINT nFlags, CPoint point)
  768. {
  769. CRect itemRect;
  770. CRect clientRect;
  772. GetClientRect(clientRect);
  774. int nIndex;
  775. for (nIndex = GetTopIndex(); nIndex < GetCount(); nIndex++)
  776. {
  777. GetItemRect(nIndex, &itemRect);
  778. if (!clientRect.PtInRect(itemRect.TopLeft()))
  779. break;
  780. if (itemRect.PtInRect(point) && IsEnabled(nIndex))
  781. {
  782. if (m_nStyle != BS_CHECKBOX && m_nStyle != BS_3STATE)
  783. {
  784. CWnd* pParent = GetParent();
  785. ASSERT_VALID(pParent);
  786. int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  787. int nCheck = GetCheck(nIndex);
  788. nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  789. SetCheck(nIndex, (nCheck + 1) % nModulo);
  790. InvalidateCheck(nIndex);
  791. CXTListBox::OnLButtonDown(nFlags, point);
  793. // Inform of check
  794. pParent->SendMessage(WM_COMMAND,
  795. MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  796. (LPARAM)m_hWnd);
  797. return;
  799. }
  800. else
  801. return; // Swallow LButtons for disabled items
  802. }
  803. }
  805. CXTListBox::OnLButtonDblClk(nFlags, point);
  806. }
  808. void CXTCheckListBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  809. {
  810. if (nChar == VK_SPACE)
  811. {
  812. int nIndex = GetCaretIndex();
  813. CWnd* pParent = GetParent();
  814. ASSERT_VALID(pParent);
  816. if (nIndex != LB_ERR)
  817. {
  818. if (m_nStyle != BS_CHECKBOX && m_nStyle != BS_3STATE)
  819. {
  820. if ((GetStyle() & LBS_MULTIPLESEL) != 0)
  821. {
  822. if (IsEnabled(nIndex))
  823. {
  824. BOOL bSelected = GetSel(nIndex);
  825. if (bSelected)
  826. {
  827. int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  828. int nCheck = GetCheck(nIndex);
  829. nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  830. SetCheck(nIndex, (nCheck + 1) % nModulo);
  832. // Inform of check
  833. pParent->SendMessage(WM_COMMAND,
  834. MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  835. (LPARAM)m_hWnd);
  836. }
  837. SetSel(nIndex, !bSelected);
  838. }
  839. else
  840. SetSel(nIndex, FALSE); // unselect disabled items
  842. return;
  843. }
  844. else
  845. {
  846. // If there is a selection, the space bar toggles that check,
  847. // all other keys are the same as a standard listbox.
  849. if (IsEnabled(nIndex))
  850. {
  851. int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  852. int nCheck = GetCheck(nIndex);
  853. nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  854. int nNewCheck = (nCheck + 1)%nModulo;
  855. SetCheck(nIndex, nNewCheck);
  857. InvalidateCheck(nIndex);
  859. if (GetStyle() & LBS_EXTENDEDSEL)
  860. {
  861. // The listbox is a multi-select listbox, and the user
  862. // clicked on a selected check, so change the check on all
  863. // of the selected items.
  864. SetSelectionCheck(nNewCheck);
  865. }
  867. // Inform of check
  868. pParent->SendMessage(WM_COMMAND,
  869. MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  870. (LPARAM)m_hWnd);
  871. }
  872. else
  873. SetSel(nIndex, FALSE); // unselect disabled items
  875. return;
  876. }
  877. }
  878. }
  879. }
  880. CXTListBox::OnKeyDown(nChar, nRepCnt, nFlags);
  881. }
  883. int CXTCheckListBox::OnCreate(LPCREATESTRUCT lpCreateStruct)
  884. {
  885. if (CXTListBox::OnCreate(lpCreateStruct) == -1)
  886. return -1;
  888. if ((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS)) ==
  889. (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  890. {
  891. SetItemHeight(0, CalcMinimumItemHeight());
  892. }
  894. return 0;
  895. }
  897. LRESULT CXTCheckListBox::OnSetFont(WPARAM , LPARAM)
  898. {
  899. Default();
  901. if ((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS)) ==
  902. (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  903. {
  904. SetItemHeight(0, CalcMinimumItemHeight());
  905. }
  907. return 0;
  908. }
  910. LRESULT CXTCheckListBox::OnLBAddString(WPARAM wParam, LPARAM lParam)
  911. {
  912. CHECK_DATA* pState = NULL;
  914. if (!(GetStyle() & LBS_HASSTRINGS))
  915. {
  916. pState = new CHECK_DATA;
  918. pState->m_dwUserData = lParam;
  919. lParam = (LPARAM)pState;
  920. }
  922. LRESULT lResult = DefWindowProc(LB_ADDSTRING, wParam, lParam);
  924. if (lResult == LB_ERR && pState != NULL)
  925. delete pState;
  927. return lResult;
  928. }
  930. LRESULT CXTCheckListBox::OnLBFindString(WPARAM wParam, LPARAM lParam)
  931. {
  932. if (GetStyle() & LBS_HASSTRINGS)
  933. return DefWindowProc(LB_FINDSTRING, wParam, lParam);
  935. int nIndex = (int)wParam;
  936. if (nIndex == -1) nIndex = 0;
  938. for (; nIndex < GetCount(); nIndex++)
  939. if ((UINT_PTR)lParam == GetItemData(nIndex))
  940. return nIndex;
  942. return LB_ERR;
  943. }
  945. LRESULT CXTCheckListBox::OnLBFindStringExact(WPARAM wParam, LPARAM lParam)
  946. {
  947. if (GetStyle() & (LBS_HASSTRINGS | LBS_SORT))
  948. return DefWindowProc(LB_FINDSTRINGEXACT, wParam, lParam);
  950. int nIndex = (int)wParam;
  951. if (nIndex == -1) nIndex = 0;
  953. for (; nIndex < GetCount(); nIndex++)
  954. if ((UINT_PTR)lParam == GetItemData(nIndex))
  955. return nIndex;
  957. return LB_ERR;
  958. }
  960. LRESULT CXTCheckListBox::OnLBGetItemData(WPARAM wParam, LPARAM lParam)
  961. {
  962. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, wParam, lParam);
  964. if (lResult != LB_ERR)
  965. {
  966. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  968. if (pState == NULL)
  969. return 0; // default
  971. lResult = pState->m_dwUserData;
  972. }
  973. return lResult;
  974. }
  976. LRESULT CXTCheckListBox::OnLBGetText(WPARAM wParam, LPARAM lParam)
  977. {
  978. LRESULT lResult = DefWindowProc(LB_GETTEXT, wParam, lParam);
  980. if (GetStyle() & LBS_HASSTRINGS)
  981. return lResult;
  983. if (lResult != LB_ERR)
  984. {
  985. CHECK_DATA* pState = (CHECK_DATA*)lParam;
  987. if (pState != NULL)
  988. lParam = pState->m_dwUserData;
  989. }
  990. return lResult;
  991. }
  993. LRESULT CXTCheckListBox::OnLBInsertString(WPARAM wParam, LPARAM lParam)
  994. {
  995. CHECK_DATA* pState = NULL;
  997. if (!(GetStyle() & LBS_HASSTRINGS))
  998. {
  999. pState = new CHECK_DATA;
  1000. pState->m_dwUserData = lParam;
  1001. lParam = (LPARAM)pState;
  1002. }
  1004. LRESULT lResult = DefWindowProc(LB_INSERTSTRING, wParam, lParam);
  1006. if (lResult == LB_ERR && pState != NULL)
  1007. delete pState;
  1009. return lResult;
  1010. }
  1012. LRESULT CXTCheckListBox::OnLBSelectString(WPARAM wParam, LPARAM lParam)
  1013. {
  1014. if (GetStyle() & LBS_HASSTRINGS)
  1015. return DefWindowProc(LB_SELECTSTRING, wParam, lParam);
  1017. int nIndex = (int)wParam;
  1018. if (nIndex == -1) nIndex = 0;
  1020. for (; nIndex < GetCount(); nIndex++)
  1021. if ((UINT_PTR)lParam == GetItemData(nIndex))
  1022. {
  1023. SetCurSel(nIndex);
  1024. return nIndex;
  1025. }
  1027. return LB_ERR;
  1028. }
  1030. LRESULT CXTCheckListBox::OnLBSetItemData(WPARAM wParam, LPARAM lParam)
  1031. {
  1032. LRESULT lResult = DefWindowProc(LB_GETITEMDATA, wParam, 0);
  1034. if (lResult != LB_ERR)
  1035. {
  1036. CHECK_DATA* pState = (CHECK_DATA*)lResult;
  1038. if (pState == NULL)
  1039. pState = new CHECK_DATA;
  1041. pState->m_dwUserData = lParam;
  1042. lResult = DefWindowProc(LB_SETITEMDATA, wParam, (LPARAM)pState);
  1044. if (lResult == LB_ERR)
  1045. delete pState;
  1046. }
  1047. return lResult;
  1048. }
  1050. LRESULT CXTCheckListBox::OnLBSetItemHeight(WPARAM wParam, LPARAM lParam)
  1051. {
  1052. int nHeight = max(CalcMinimumItemHeight(), (int)LOWORD(lParam));
  1053. return DefWindowProc(LB_SETITEMHEIGHT, wParam, MAKELPARAM(nHeight, 0));
  1054. }