home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / src / winctrl3.cpp < prev    next >
C/C++ Source or Header  |  1998-06-16  |  23KB  |  859 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_CORE4_SEG
  14. #pragma code_seg(AFX_CORE4_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. #define new DEBUG_NEW
  23.  
  24. /////////////////////////////////////////////////////////////////////////////
  25. // _AFX_CHECKLIST_STATE
  26.  
  27. class _AFX_CHECKLIST_STATE : public CNoTrackObject
  28. {
  29. public:
  30.     _AFX_CHECKLIST_STATE();
  31.     virtual ~_AFX_CHECKLIST_STATE();
  32.  
  33.     HBITMAP m_hbitmapCheck;
  34.     CSize m_sizeCheck;
  35. };
  36.  
  37. _AFX_CHECKLIST_STATE::_AFX_CHECKLIST_STATE()
  38. {
  39.     CBitmap bitmap;
  40.  
  41. #ifndef _AFX_NO_CTL3D_SUPPORT
  42.     if (afxData.bWin4 || AfxGetCtl3dState()->m_pfnSubclassDlgEx != NULL)
  43. #else
  44.     if (afxData.bWin4)
  45. #endif
  46.         VERIFY(bitmap.LoadBitmap(AFX_IDB_CHECKLISTBOX_95));
  47.     else
  48.         VERIFY(bitmap.LoadBitmap(AFX_IDB_CHECKLISTBOX_NT));
  49.  
  50.     BITMAP bm;
  51.     bitmap.GetObject(sizeof (BITMAP), &bm);
  52.     m_sizeCheck.cx = bm.bmWidth / 3;
  53.     m_sizeCheck.cy = bm.bmHeight;
  54.     m_hbitmapCheck = (HBITMAP)bitmap.Detach();
  55. }
  56.  
  57. _AFX_CHECKLIST_STATE::~_AFX_CHECKLIST_STATE()
  58. {
  59.     if (m_hbitmapCheck != NULL)
  60.         ::DeleteObject(m_hbitmapCheck);
  61. }
  62.  
  63. EXTERN_PROCESS_LOCAL(_AFX_CHECKLIST_STATE, _afxChecklistState)
  64.  
  65. /////////////////////////////////////////////////////////////////////////////
  66. // AFX_CHECK_DATA
  67.  
  68. struct AFX_CHECK_DATA
  69. {
  70. public:
  71.     int m_nCheck;
  72.     BOOL m_bEnabled;
  73.     DWORD m_dwUserData;
  74.  
  75.     AFX_CHECK_DATA()
  76.     {
  77.         m_nCheck = 0;
  78.         m_bEnabled = TRUE;
  79.         m_dwUserData = 0;
  80.     };
  81. };
  82.  
  83. /////////////////////////////////////////////////////////////////////////////
  84. // CCheckListBox
  85.  
  86. BEGIN_MESSAGE_MAP(CCheckListBox, CListBox)
  87.     //{{AFX_MSG_MAP(CCheckListBox)
  88.     ON_WM_LBUTTONDOWN()
  89.     ON_WM_KEYDOWN()
  90.     ON_WM_CREATE()
  91.     ON_WM_LBUTTONDBLCLK()
  92.     ON_MESSAGE(WM_SETFONT, OnSetFont)
  93.     ON_MESSAGE(LB_ADDSTRING, OnLBAddString)
  94.     ON_MESSAGE(LB_FINDSTRING, OnLBFindString)
  95.     ON_MESSAGE(LB_FINDSTRINGEXACT, OnLBFindStringExact)
  96.     ON_MESSAGE(LB_GETITEMDATA, OnLBGetItemData)
  97.     ON_MESSAGE(LB_GETTEXT, OnLBGetText)
  98.     ON_MESSAGE(LB_INSERTSTRING, OnLBInsertString)
  99.     ON_MESSAGE(LB_SELECTSTRING, OnLBSelectString)
  100.     ON_MESSAGE(LB_SETITEMDATA, OnLBSetItemData)
  101.     ON_MESSAGE(LB_SETITEMHEIGHT, OnLBSetItemHeight)
  102.     //}}AFX_MSG_MAP
  103. END_MESSAGE_MAP()
  104.  
  105. BOOL CCheckListBox::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  106. {
  107.     if (!(dwStyle & LBS_OWNERDRAWVARIABLE)) //must be one or the other
  108.         dwStyle |= LBS_OWNERDRAWFIXED;
  109.     return CListBox::Create(dwStyle, rect, pParentWnd, nID);
  110. }
  111.  
  112. void CCheckListBox::SetCheckStyle(UINT nStyle)
  113. {
  114.     ASSERT(nStyle == 0 || nStyle == BS_CHECKBOX ||
  115.         nStyle == BS_AUTOCHECKBOX || nStyle == BS_AUTO3STATE ||
  116.         nStyle == BS_3STATE);
  117.  
  118.     m_nStyle = nStyle;
  119. }
  120.  
  121. void CCheckListBox::SetCheck(int nIndex, int nCheck)
  122. {
  123.     ASSERT(::IsWindow(m_hWnd));
  124.  
  125.     if (nCheck == 2)
  126.     {
  127.         if (m_nStyle == BS_CHECKBOX || m_nStyle == BS_AUTOCHECKBOX)
  128.             return;
  129.     }
  130.  
  131.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  132.     if (lResult != LB_ERR)
  133.     {
  134.  
  135.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  136.  
  137.         if (pState == NULL)
  138.             pState = new AFX_CHECK_DATA;
  139.  
  140.         pState->m_nCheck = nCheck;
  141.         VERIFY(DefWindowProc(LB_SETITEMDATA, nIndex, (LPARAM)pState) != LB_ERR);
  142.  
  143.         InvalidateCheck(nIndex);
  144.     }
  145. }
  146.  
  147. int CCheckListBox::GetCheck(int nIndex)
  148. {
  149.     ASSERT(::IsWindow(m_hWnd));
  150.  
  151.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  152.     if (lResult != LB_ERR)
  153.     {
  154.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  155.         if (pState != NULL)
  156.             return pState->m_nCheck;
  157.     }
  158.     return 0; // The default
  159. }
  160.  
  161. void CCheckListBox::Enable(int nIndex, BOOL bEnabled)
  162. {
  163.     ASSERT(::IsWindow(m_hWnd));
  164.  
  165.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  166.     if (lResult != LB_ERR)
  167.     {
  168.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  169.  
  170.         if (pState == NULL)
  171.             pState = new AFX_CHECK_DATA;
  172.  
  173.         pState->m_bEnabled = bEnabled;
  174.         VERIFY(DefWindowProc(LB_SETITEMDATA, nIndex, (LPARAM)pState) != LB_ERR);
  175.  
  176.         InvalidateItem(nIndex);
  177.     }
  178. }
  179.  
  180. int CCheckListBox::IsEnabled(int nIndex)
  181. {
  182.     ASSERT(::IsWindow(m_hWnd));
  183.  
  184.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, nIndex, 0);
  185.     if (lResult != LB_ERR)
  186.     {
  187.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  188.         if (pState != NULL)
  189.             return pState->m_bEnabled;
  190.     }
  191.     return TRUE; // The default
  192. }
  193.  
  194. CRect CCheckListBox::OnGetCheckPosition(CRect, CRect rectCheckBox)
  195. {
  196.     return rectCheckBox;
  197. }
  198.  
  199. void CCheckListBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  200. {
  201.     // You must override DrawItem and MeasureItem for LBS_OWNERDRAWVARIABLE
  202.     ASSERT((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS)) ==
  203.         (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS));
  204.  
  205.     CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  206.  
  207.     if (((LONG)(lpDrawItemStruct->itemID) >= 0) &&
  208.         (lpDrawItemStruct->itemAction & (ODA_DRAWENTIRE | ODA_SELECT)))
  209.     {
  210.         int cyItem = GetItemHeight(lpDrawItemStruct->itemID);
  211.         BOOL fDisabled = !IsWindowEnabled() || !IsEnabled(lpDrawItemStruct->itemID);
  212.  
  213.         COLORREF newTextColor = fDisabled ?
  214.             RGB(0x80, 0x80, 0x80) : GetSysColor(COLOR_WINDOWTEXT);  // light gray
  215.         COLORREF oldTextColor = pDC->SetTextColor(newTextColor);
  216.  
  217.         COLORREF newBkColor = GetSysColor(COLOR_WINDOW);
  218.         COLORREF oldBkColor = pDC->SetBkColor(newBkColor);
  219.  
  220.         if (newTextColor == newBkColor)
  221.             newTextColor = RGB(0xC0, 0xC0, 0xC0);   // dark gray
  222.  
  223.         if (!fDisabled && ((lpDrawItemStruct->itemState & ODS_SELECTED) != 0))
  224.         {
  225.             pDC->SetTextColor(GetSysColor(COLOR_HIGHLIGHTTEXT));
  226.             pDC->SetBkColor(GetSysColor(COLOR_HIGHLIGHT));
  227.         }
  228.  
  229.         if (m_cyText == 0)
  230.             VERIFY(cyItem >= CalcMinimumItemHeight());
  231.  
  232.         CString strText;
  233.         GetText(lpDrawItemStruct->itemID, strText);
  234.  
  235.         pDC->ExtTextOut(lpDrawItemStruct->rcItem.left,
  236.             lpDrawItemStruct->rcItem.top + max(0, (cyItem - m_cyText) / 2),
  237.             ETO_OPAQUE, &(lpDrawItemStruct->rcItem), strText, strText.GetLength(), NULL);
  238.  
  239.         pDC->SetTextColor(oldTextColor);
  240.         pDC->SetBkColor(oldBkColor);
  241.     }
  242.  
  243.     if ((lpDrawItemStruct->itemAction & ODA_FOCUS) != 0)
  244.         pDC->DrawFocusRect(&(lpDrawItemStruct->rcItem));
  245. }
  246.  
  247. void CCheckListBox::MeasureItem(LPMEASUREITEMSTRUCT)
  248. {
  249.     // You must override DrawItem and MeasureItem for LBS_OWNERDRAWVARIABLE
  250.     ASSERT((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS)) ==
  251.         (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS));
  252. }
  253.  
  254. void CCheckListBox::PreDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  255. {
  256.     _AFX_CHECKLIST_STATE* pChecklistState = _afxChecklistState;
  257.  
  258.     DRAWITEMSTRUCT drawItem;
  259.     memcpy(&drawItem, lpDrawItemStruct, sizeof(DRAWITEMSTRUCT));
  260.  
  261.     if ((((LONG)drawItem.itemID) >= 0) &&
  262.        ((drawItem.itemAction & (ODA_DRAWENTIRE | ODA_SELECT)) != 0))
  263.     {
  264.         int cyItem = GetItemHeight(drawItem.itemID);
  265.  
  266.         CDC* pDC = CDC::FromHandle(drawItem.hDC);
  267.  
  268.         COLORREF newBkColor = GetSysColor(COLOR_WINDOW);
  269.  
  270.         BOOL fDisabled = !IsWindowEnabled() || !IsEnabled(drawItem.itemID);
  271.         if ((drawItem.itemState & ODS_SELECTED) && !fDisabled)
  272.             newBkColor = GetSysColor(COLOR_HIGHLIGHT);
  273.  
  274.         COLORREF oldBkColor = pDC->SetBkColor(newBkColor);
  275.  
  276.         CDC bitmapDC;
  277.         if (bitmapDC.CreateCompatibleDC(pDC))
  278.         {
  279.             int nCheck = GetCheck(drawItem.itemID);
  280.             HBITMAP hOldBitmap = (HBITMAP)::SelectObject(bitmapDC.m_hDC, pChecklistState->m_hbitmapCheck);
  281.  
  282.             CRect rectCheck = drawItem.rcItem;
  283.             rectCheck.left += 1;
  284.             rectCheck.top += 1 + max(0, (cyItem - pChecklistState->m_sizeCheck.cy) / 2);
  285.             rectCheck.right = rectCheck.left + pChecklistState->m_sizeCheck.cx;
  286.             rectCheck.bottom = rectCheck.top + pChecklistState->m_sizeCheck.cy;
  287.  
  288.             CRect rectItem = drawItem.rcItem;
  289.             rectItem.right = rectItem.left + pChecklistState->m_sizeCheck.cx + 2;
  290.  
  291.             CRect rectCheckBox = OnGetCheckPosition(rectItem, rectCheck);
  292.  
  293.             ASSERT(rectCheck.IntersectRect(rectItem, rectCheckBox));
  294.             ASSERT((rectCheck == rectCheckBox) && (rectCheckBox.Size() == pChecklistState->m_sizeCheck));
  295.  
  296.             CBrush brush(newBkColor);
  297.             pDC->FillRect(rectItem, &brush);
  298.  
  299.             pDC->BitBlt(rectCheckBox.left, rectCheckBox.top,
  300.                 pChecklistState->m_sizeCheck.cx, pChecklistState->m_sizeCheck.cy, &bitmapDC,
  301.                 pChecklistState->m_sizeCheck.cx  * nCheck, 0, SRCCOPY);
  302.  
  303.             ::SelectObject(bitmapDC.m_hDC, hOldBitmap);
  304.         }
  305.         pDC->SetBkColor(oldBkColor);
  306.     }
  307.  
  308.     if (drawItem.itemData != 0 && drawItem.itemData != LB_ERR)
  309.     {
  310.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)drawItem.itemData;
  311.         drawItem.itemData = pState->m_dwUserData;
  312.     }
  313.     drawItem.rcItem.left = drawItem.rcItem.left + pChecklistState->m_sizeCheck.cx + 2;
  314.  
  315.     DrawItem(&drawItem);
  316. }
  317.  
  318. void CCheckListBox::PreMeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  319. {
  320.     int cyItem = CalcMinimumItemHeight();
  321.  
  322.     MEASUREITEMSTRUCT measureItem;
  323.     memcpy(&measureItem, lpMeasureItemStruct, sizeof(MEASUREITEMSTRUCT));
  324.  
  325.     measureItem.itemHeight = cyItem;
  326.     measureItem.itemWidth  = (UINT)-1;
  327.  
  328.     // WINBUG: Windows95 and Windows NT disagree on what this value
  329.     // should be.  According to the docs, they are both wrong
  330.     if (GetStyle() & LBS_OWNERDRAWVARIABLE)
  331.     {
  332.         LRESULT lResult = DefWindowProc(LB_GETITEMDATA, measureItem.itemID, 0);
  333.         if (lResult != LB_ERR)
  334.             measureItem.itemData = (UINT)lResult;
  335.         else
  336.             measureItem.itemData = 0;
  337.  
  338.         // WINBUG: This is only done in the LBS_OWNERDRAWVARIABLE case
  339.         // because Windows 95 does not initialize itemData to zero in the
  340.         // case of LBS_OWNERDRAWFIXED list boxes (it is stack garbage).
  341.         if (measureItem.itemData != 0 && measureItem.itemData != LB_ERR)
  342.         {
  343.             AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)measureItem.itemData;
  344.             measureItem.itemData = pState->m_dwUserData;
  345.         }
  346.     }
  347.  
  348.     MeasureItem(&measureItem);
  349.  
  350.     lpMeasureItemStruct->itemHeight = max(measureItem.itemHeight,(UINT) cyItem);
  351.     lpMeasureItemStruct->itemWidth = measureItem.itemWidth;
  352. }
  353.  
  354. int CCheckListBox::PreCompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct)
  355. {
  356.     COMPAREITEMSTRUCT compareItem;
  357.     memcpy(&compareItem, lpCompareItemStruct, sizeof(COMPAREITEMSTRUCT));
  358.  
  359.     if (compareItem.itemData1 != 0 && compareItem.itemData1 != LB_ERR)
  360.     {
  361.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)compareItem.itemData1;
  362.         compareItem.itemData1 = pState->m_dwUserData;
  363.     }
  364.     if (compareItem.itemData2 != 0 && compareItem.itemData2 != LB_ERR)
  365.     {
  366.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)compareItem.itemData2;
  367.         compareItem.itemData2 = pState->m_dwUserData;
  368.     }
  369.     return CompareItem(&compareItem);
  370. }
  371.  
  372. void CCheckListBox::PreDeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct)
  373. {
  374.     DELETEITEMSTRUCT deleteItem;
  375.     memcpy(&deleteItem, lpDeleteItemStruct, sizeof(DELETEITEMSTRUCT));
  376.  
  377.     // WINBUG: The following if block is required because Windows NT
  378.     // version 3.51 does not properly fill out the LPDELETEITEMSTRUCT.
  379.     if (deleteItem.itemData == 0)
  380.     {
  381.         LRESULT lResult = DefWindowProc(LB_GETITEMDATA, deleteItem.itemID, 0);
  382.         if (lResult != LB_ERR)
  383.             deleteItem.itemData = (UINT)lResult;
  384.     }
  385.  
  386.     if (deleteItem.itemData != 0 && deleteItem.itemData != LB_ERR)
  387.     {
  388.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)deleteItem.itemData;
  389.         deleteItem.itemData = pState->m_dwUserData;
  390.         delete pState;
  391.     }
  392.     DeleteItem(&deleteItem);
  393. }
  394.  
  395. BOOL CCheckListBox::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam,
  396.     LRESULT* pResult)
  397. {
  398.     switch (message)
  399.     {
  400.     case WM_DRAWITEM:
  401.         ASSERT(pResult == NULL);       // no return value expected
  402.         PreDrawItem((LPDRAWITEMSTRUCT)lParam);
  403.         break;
  404.     case WM_MEASUREITEM:
  405.         ASSERT(pResult == NULL);       // no return value expected
  406.         PreMeasureItem((LPMEASUREITEMSTRUCT)lParam);
  407.         break;
  408.     case WM_COMPAREITEM:
  409.         ASSERT(pResult != NULL);       // return value expected
  410.         *pResult = PreCompareItem((LPCOMPAREITEMSTRUCT)lParam);
  411.         break;
  412.     case WM_DELETEITEM:
  413.         ASSERT(pResult == NULL);       // no return value expected
  414.         PreDeleteItem((LPDELETEITEMSTRUCT)lParam);
  415.         break;
  416.     default:
  417.         return CListBox::OnChildNotify(message, wParam, lParam, pResult);
  418.     }
  419.     return TRUE;
  420. }
  421.  
  422. #ifdef _DEBUG
  423. void CCheckListBox::PreSubclassWindow()
  424. {
  425.     CListBox::PreSubclassWindow();
  426.  
  427.     // CCheckListBoxes must be owner drawn
  428.     ASSERT(GetStyle() & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE));
  429. }
  430. #endif
  431.  
  432. int CCheckListBox::CalcMinimumItemHeight()
  433. {
  434.     int nResult;
  435.  
  436.     _AFX_CHECKLIST_STATE* pChecklistState = _afxChecklistState;
  437.  
  438.     if ((GetStyle() & (LBS_HASSTRINGS | LBS_OWNERDRAWFIXED)) ==
  439.         (LBS_HASSTRINGS | LBS_OWNERDRAWFIXED))
  440.     {
  441.         CClientDC dc(this);
  442.         CFont* pOldFont = dc.SelectObject(GetFont());
  443.         TEXTMETRIC tm;
  444.         VERIFY (dc.GetTextMetrics ( &tm ));
  445.         dc.SelectObject(pOldFont);
  446.  
  447.         m_cyText = tm.tmHeight;
  448.         nResult = max(pChecklistState->m_sizeCheck.cy + 1, m_cyText);
  449.     }
  450.     else
  451.     {
  452.         nResult = pChecklistState->m_sizeCheck.cy + 1;
  453.     }
  454.  
  455.     return nResult;
  456. }
  457.  
  458. void CCheckListBox::InvalidateCheck(int nIndex)
  459. {
  460.     CRect rect;
  461.     _AFX_CHECKLIST_STATE* pChecklistState = _afxChecklistState;
  462.  
  463.     GetItemRect(nIndex, rect);
  464.     rect.right = rect.left + pChecklistState->m_sizeCheck.cx + 2;
  465.     InvalidateRect(rect, FALSE);
  466. }
  467.  
  468. void CCheckListBox::InvalidateItem(int nIndex)
  469. {
  470.     CRect rect;
  471.     GetItemRect(nIndex, rect);
  472.     InvalidateRect(rect, FALSE);
  473. }
  474.  
  475. int CCheckListBox::CheckFromPoint(CPoint point, BOOL& bInCheck)
  476. {
  477.     // assume did not hit anything
  478.     bInCheck = FALSE;
  479.     int nIndex = -1;
  480.  
  481.     _AFX_CHECKLIST_STATE* pChecklistState = _afxChecklistState;
  482.     if ((GetStyle() & (LBS_OWNERDRAWFIXED|LBS_MULTICOLUMN)) == LBS_OWNERDRAWFIXED)
  483.     {
  484.         // optimized case for ownerdraw fixed, single column
  485.         int cyItem = GetItemHeight(0);
  486.         if (point.y < cyItem * GetCount())
  487.         {
  488.             nIndex = GetTopIndex() + point.y / cyItem;
  489.             if (point.x < pChecklistState->m_sizeCheck.cx + 2)
  490.                 ++bInCheck;
  491.         }
  492.     }
  493.     else
  494.     {
  495.         // general case for ownerdraw variable or multiple column
  496.         for (int i = GetTopIndex(); i < GetCount(); i++)
  497.         {
  498.             CRect itemRect;
  499.             GetItemRect(i, &itemRect);
  500.             if (itemRect.PtInRect(point))
  501.             {
  502.                 nIndex = i;
  503.                 if (point.x < itemRect.left + pChecklistState->m_sizeCheck.cx + 2)
  504.                     ++bInCheck;
  505.                 break;
  506.             }
  507.         }
  508.     }
  509.     return nIndex;
  510. }
  511.  
  512. void CCheckListBox::SetSelectionCheck( int nCheck )
  513. {
  514.    int* piSelectedItems;
  515.    int nSelectedItems;
  516.    int iSelectedItem;
  517.  
  518.    nSelectedItems = GetSelCount();
  519.    if( nSelectedItems > 0 )
  520.    {
  521.       piSelectedItems = (int*)_alloca( nSelectedItems*sizeof( int ) );
  522.       GetSelItems( nSelectedItems, piSelectedItems );
  523.       for( iSelectedItem = 0; iSelectedItem < nSelectedItems; iSelectedItem++ )
  524.       {
  525.          if( IsEnabled( piSelectedItems[iSelectedItem] ) )
  526.          {
  527.             SetCheck( piSelectedItems[iSelectedItem], nCheck );
  528.             InvalidateCheck( piSelectedItems[iSelectedItem] );
  529.          }
  530.       }
  531.    }
  532. }
  533.  
  534. void CCheckListBox::OnLButtonDown(UINT nFlags, CPoint point)
  535. {
  536.    SetFocus();
  537.  
  538.    // determine where the click is
  539.    BOOL bInCheck;
  540.    int nIndex = CheckFromPoint(point, bInCheck);
  541.  
  542.    // if the item is disabled, then eat the click
  543.    if (!IsEnabled(nIndex))
  544.       return;
  545.  
  546.    if (m_nStyle != BS_CHECKBOX && m_nStyle != BS_3STATE)
  547.    {
  548.       // toggle the check mark automatically if the check mark was hit
  549.       if (bInCheck)
  550.       {
  551.          CWnd* pParent = GetParent();
  552.          ASSERT_VALID( pParent );
  553.  
  554.             int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  555.          int nCheck;
  556.          int nNewCheck;
  557.  
  558.          nCheck = GetCheck( nIndex );
  559.          nCheck = (nCheck == nModulo) ? nCheck-1 : nCheck;
  560.          nNewCheck = (nCheck+1)%nModulo;
  561.          SetCheck( nIndex, nNewCheck );
  562.          InvalidateCheck( nIndex );
  563.  
  564.          if( (GetStyle()&(LBS_EXTENDEDSEL|LBS_MULTIPLESEL)) && GetSel(
  565.             nIndex ) )
  566.          {
  567.             // The listbox is a multi-select listbox, and the user clicked on
  568.             // a selected check, so change the check on all of the selected
  569.             // items.
  570.             SetSelectionCheck( nNewCheck );
  571.          }
  572.          else
  573.          {
  574.             CListBox::OnLButtonDown( nFlags, point );
  575.          }
  576.  
  577.          // Inform parent of check
  578.          pParent->SendMessage( WM_COMMAND, MAKEWPARAM( GetDlgCtrlID(),
  579.             CLBN_CHKCHANGE ), (LPARAM)m_hWnd );
  580.          return;
  581.       }
  582.    }
  583.  
  584.     // do default listbox selection logic
  585.    CListBox::OnLButtonDown( nFlags, point );
  586. }
  587.  
  588. void CCheckListBox::OnLButtonDblClk(UINT nFlags, CPoint point)
  589. {
  590.     BOOL bInCheck;
  591.     CheckFromPoint(point, bInCheck);
  592.  
  593.     if (bInCheck)
  594.     {
  595.         // Double and single clicks act the same on the check box!
  596.         OnLButtonDown(nFlags, point);
  597.         return;
  598.     }
  599.  
  600.     CListBox::OnLButtonDblClk(nFlags, point);
  601. }
  602.  
  603. void CCheckListBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  604. {
  605.     if (nChar == VK_SPACE)
  606.     {
  607.         int nIndex = GetCaretIndex();
  608.         CWnd* pParent = GetParent();
  609.         ASSERT_VALID(pParent);
  610.  
  611.         if (nIndex != LB_ERR)
  612.         {
  613.             if (m_nStyle != BS_CHECKBOX && m_nStyle != BS_3STATE)
  614.             {
  615.                 if ((GetStyle() & LBS_MULTIPLESEL) != 0)
  616.                 {
  617.                     if (IsEnabled(nIndex))
  618.                     {
  619.                         BOOL bSelected = GetSel(nIndex);
  620.                         if (bSelected)
  621.                         {
  622.                             int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  623.                             int nCheck = GetCheck(nIndex);
  624.                             nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  625.                             SetCheck(nIndex, (nCheck + 1) % nModulo);
  626.  
  627.                             // Inform of check
  628.                             pParent->SendMessage(WM_COMMAND,
  629.                                 MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  630.                                 (LPARAM)m_hWnd);
  631.                         }
  632.                         SetSel(nIndex, !bSelected);
  633.                     }
  634.                     else
  635.                         SetSel(nIndex, FALSE); // unselect disabled items
  636.  
  637.                     return;
  638.                 }
  639.                 else
  640.                 {
  641.                     // If there is a selection, the space bar toggles that check,
  642.                     // all other keys are the same as a standard listbox.
  643.  
  644.                     if (IsEnabled(nIndex))
  645.                     {
  646.                         int nModulo = (m_nStyle == BS_AUTO3STATE) ? 3 : 2;
  647.                         int nCheck = GetCheck(nIndex);
  648.                         nCheck = (nCheck == nModulo) ? nCheck - 1 : nCheck;
  649.                   int nNewCheck = (nCheck+1)%nModulo;
  650.                         SetCheck(nIndex, nNewCheck);
  651.  
  652.                         InvalidateCheck(nIndex);
  653.  
  654.                   if( GetStyle()&LBS_EXTENDEDSEL )
  655.                   {
  656.                      // The listbox is a multi-select listbox, and the user
  657.                      // clicked on a selected check, so change the check on all
  658.                      // of the selected items.
  659.                      SetSelectionCheck( nNewCheck );
  660.                   }
  661.  
  662.                         // Inform of check
  663.                         pParent->SendMessage(WM_COMMAND,
  664.                             MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE),
  665.                             (LPARAM)m_hWnd);
  666.                     }
  667.                     else
  668.                         SetSel(nIndex, FALSE); // unselect disabled items
  669.  
  670.                     return;
  671.                 }
  672.             }
  673.         }
  674.     }
  675.     CListBox::OnKeyDown(nChar, nRepCnt, nFlags);
  676. }
  677.  
  678. int CCheckListBox::OnCreate(LPCREATESTRUCT lpCreateStruct)
  679. {
  680.     if (CListBox::OnCreate(lpCreateStruct) == -1)
  681.         return -1;
  682.  
  683.     if ((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  684.         == (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  685.         SetItemHeight(0, CalcMinimumItemHeight());
  686.  
  687.     return 0;
  688. }
  689.  
  690. LRESULT CCheckListBox::OnSetFont(WPARAM , LPARAM)
  691. {
  692.     Default();
  693.  
  694.     if ((GetStyle() & (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  695.         == (LBS_OWNERDRAWFIXED | LBS_HASSTRINGS))
  696.         SetItemHeight(0, CalcMinimumItemHeight());
  697.  
  698.     return 0;
  699. }
  700.  
  701. LRESULT CCheckListBox::OnLBAddString(WPARAM wParam, LPARAM lParam)
  702. {
  703.     AFX_CHECK_DATA* pState = NULL;
  704.  
  705.     if (!(GetStyle() & LBS_HASSTRINGS))
  706.     {
  707.         pState = new AFX_CHECK_DATA;
  708.  
  709.         pState->m_dwUserData = lParam;
  710.         lParam = (LPARAM)pState;
  711.     }
  712.  
  713.     LRESULT lResult = DefWindowProc(LB_ADDSTRING, wParam, lParam);
  714.  
  715.     if (lResult == LB_ERR && pState != NULL)
  716.         delete pState;
  717.  
  718.     return lResult;
  719. }
  720.  
  721. LRESULT CCheckListBox::OnLBFindString(WPARAM wParam, LPARAM lParam)
  722. {
  723.     if (GetStyle() & LBS_HASSTRINGS)
  724.         return DefWindowProc(LB_FINDSTRING, wParam, lParam);
  725.  
  726.     int nIndex = wParam;
  727.     if (nIndex == -1) nIndex = 0;
  728.  
  729.     for(; nIndex < GetCount(); nIndex++)
  730.         if ((DWORD)lParam == GetItemData(nIndex))
  731.             return nIndex;
  732.  
  733.     return LB_ERR;
  734. }
  735.  
  736. LRESULT CCheckListBox::OnLBFindStringExact(WPARAM wParam, LPARAM lParam)
  737. {
  738.     if (GetStyle() & (LBS_HASSTRINGS | LBS_SORT))
  739.         return DefWindowProc(LB_FINDSTRINGEXACT, wParam, lParam);
  740.  
  741.     int nIndex = wParam;
  742.     if (nIndex == -1) nIndex = 0;
  743.  
  744.     for(; nIndex < GetCount(); nIndex++)
  745.         if ((DWORD)lParam == GetItemData(nIndex))
  746.             return nIndex;
  747.  
  748.     return LB_ERR;
  749. }
  750.  
  751. LRESULT CCheckListBox::OnLBGetItemData(WPARAM wParam, LPARAM lParam)
  752. {
  753.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, wParam, lParam);
  754.  
  755.     if (lResult != LB_ERR)
  756.     {
  757.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  758.  
  759.         if (pState == NULL)
  760.             return 0; // default
  761.  
  762.         lResult = pState->m_dwUserData;
  763.     }
  764.     return lResult;
  765. }
  766.  
  767. LRESULT CCheckListBox::OnLBGetText(WPARAM wParam, LPARAM lParam)
  768. {
  769.     LRESULT lResult = DefWindowProc(LB_GETTEXT, wParam, lParam);
  770.  
  771.     if (GetStyle() & LBS_HASSTRINGS)
  772.         return lResult;
  773.  
  774.     if (lResult != LB_ERR)
  775.     {
  776.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lParam;
  777.  
  778.         if (pState != NULL)
  779.             lParam = pState->m_dwUserData;
  780.     }
  781.     return lResult;
  782. }
  783.  
  784. LRESULT CCheckListBox::OnLBInsertString(WPARAM wParam, LPARAM lParam)
  785. {
  786.     AFX_CHECK_DATA* pState = NULL;
  787.  
  788.     if (!(GetStyle() & LBS_HASSTRINGS))
  789.     {
  790.         pState = new AFX_CHECK_DATA;
  791.         pState->m_dwUserData = lParam;
  792.         lParam = (LPARAM)pState;
  793.     }
  794.  
  795.     LRESULT lResult = DefWindowProc(LB_INSERTSTRING, wParam, lParam);
  796.  
  797.     if (lResult == LB_ERR && pState != NULL)
  798.         delete pState;
  799.  
  800.     return lResult;
  801. }
  802.  
  803. LRESULT CCheckListBox::OnLBSelectString(WPARAM wParam, LPARAM lParam)
  804. {
  805.     if (GetStyle() & LBS_HASSTRINGS)
  806.         return DefWindowProc(LB_SELECTSTRING, wParam, lParam);
  807.  
  808.     int nIndex = wParam;
  809.     if (nIndex == -1) nIndex = 0;
  810.  
  811.     for(; nIndex < GetCount(); nIndex++)
  812.         if ((DWORD)lParam == GetItemData(nIndex))
  813.         {
  814.             SetCurSel(nIndex);
  815.             return nIndex;
  816.         }
  817.  
  818.     return LB_ERR;
  819. }
  820.  
  821. LRESULT CCheckListBox::OnLBSetItemData(WPARAM wParam, LPARAM lParam)
  822. {
  823.     LRESULT lResult = DefWindowProc(LB_GETITEMDATA, wParam, 0);
  824.  
  825.     if (lResult != LB_ERR)
  826.     {
  827.         AFX_CHECK_DATA* pState = (AFX_CHECK_DATA*)lResult;
  828.  
  829.         if (pState == NULL)
  830.             pState = new AFX_CHECK_DATA;
  831.  
  832.         pState->m_dwUserData = lParam;
  833.         lResult = DefWindowProc(LB_SETITEMDATA, wParam, (LPARAM)pState);
  834.  
  835.         if (lResult == LB_ERR)
  836.             delete pState;
  837.     }
  838.     return lResult;
  839. }
  840.  
  841. LRESULT CCheckListBox::OnLBSetItemHeight(WPARAM wParam, LPARAM lParam)
  842. {
  843.     int nHeight = max(CalcMinimumItemHeight(),(int)LOWORD(lParam));
  844.     return DefWindowProc(LB_SETITEMHEIGHT, wParam, MAKELPARAM(nHeight,0));
  845. }
  846.  
  847. #ifdef AFX_INIT_SEG
  848. #pragma code_seg(AFX_INIT_SEG)
  849. #endif
  850.  
  851. IMPLEMENT_DYNAMIC(CCheckListBox, CListBox)
  852.  
  853. #pragma warning(disable: 4074)
  854. #pragma init_seg(lib)
  855.  
  856. PROCESS_LOCAL(_AFX_CHECKLIST_STATE, _afxChecklistState)
  857.  
  858. /////////////////////////////////////////////////////////////////////////////
  859.