listviewctrlex.cpp

beereader source code

        }

        if (bSelected || bAlwaysSelected)
        {
          if (rcSubItemSelection.left > rcSubItem.left)
          {
            // fill area left from selection with background color
            CRect rc(rcSubItem);
            rc.right = rcSubItemSelection.left-1;
            CBrush brush(dwBkColor);
            pDC->FillRect(rc, &brushBk);
          }

          // fill selection area with highlight color
          pDC->FillRect(rcSubItemSelection, &brushHiLite);

          // fill area right from selection with background color
          if (rcSubItemSelection.right < rcSubItem.right)
          {
            CRect rc(rcSubItem);
            rc.left = rcSubItemSelection.right+1;
            CBrush brush(dwBkColor);
            pDC->FillRect(rc, &brushBk);
          }

          pDC->SetBkColor  (dwHiLiteBk);
          pDC->SetTextColor(
            bSelected ? GetSysColor(COLOR_HIGHLIGHTTEXT) : dwNormalText);
          bHiLite = true;
        }
      }
      else
        if (bFullRowSelected)
        {
          pDC->FillRect    (rcSubItem, &brushHiLite);
          pDC->SetBkColor  (dwHiLiteBk);
          pDC->SetTextColor(
            bSelected ? GetSysColor(COLOR_HIGHLIGHTTEXT) : dwNormalText);
          bHiLite = true;
        }

    if (!bHiLite)
    {
      pDC->FillRect    (rcSubItem, &brushBk);
      pDC->SetBkColor  (dwBkColor);
      pDC->SetTextColor(dwNormalText);
    }

    if (nIndex == 0 && !m_bKeepLabelLeft || nColumn == 0 && m_bKeepLabelLeft)
    {
      CRect rcIcon;

      if (GetStateIconRect(pItem->iItem, rcIcon))
        DrawStateIcon(pDC, pItem, rcIcon);

      if (GetRealSubItemRect(pItem->iItem, 0, LVIR_ICON, rcIcon))
        DrawSmallIcon(pDC, pItem, rcIcon);
    }

    //检测是否显示粗体字.
    ASSERT( m_pListCtrl );
	CItemData* pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(pItem->iItem) );
    
	BOOL bBoldText = FALSE;

	if( pData )
	   bBoldText =pData->GetBold();
	CFont Boldfont;
	CFont* oldfont = NULL;
	if( bBoldText )
	{
	    LOGFONT lf;
		CFont* font = pDC->GetCurrentFont();
		font->GetLogFont(&lf);
        lf.lfWeight = FW_BOLD;
		VERIFY(Boldfont.CreateFontIndirect(&lf));  
		oldfont = (CFont*)pDC->SelectObject(&Boldfont);
		
	}

	if( pData->GetRedFlag() )
		pDC->SetTextColor(RGB(255,0,0));

    DrawSubItemText(pDC, pSubItem, &lvc, rcText);

	if( bBoldText )
	{
	    pDC->SelectObject( oldfont );  
	}

    if (nIndex > 0)
    {
      delete[] pSubItem->pszText;
      delete pSubItem;
    }
  }

  delete[] pItem->pszText;
  delete pItem;

  // Wenn der Eintrag den Fokus hat, Fokusrechteck zeichnen
	if (bItemHasFocus) pDC->DrawFocusRect(rcSelection);
}

/*** Draw the label of an item or subitem ************************************/
void CListBase::DrawSubItemText(CDC* pDC, LVITEM* pItem, LVCOLUMN* pColumn,
                                LPRECT pRect)
{
  if (*pItem->pszText)
  {
    int nWidth = pRect->right - pRect->left;

    if (nWidth > 0)
    {
      CString strLabel(pItem->pszText);

      MakeShortString(pDC, strLabel, nWidth);
      pDC->DrawText  (strLabel, -1, pRect,
                      (pColumn->fmt & LVCFMT_CENTER ? DT_CENTER :
                       pColumn->fmt & LVCFMT_RIGHT  ? DT_RIGHT  : DT_LEFT) |
                       DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);

    }
  }
}

/*** Draw small icon *********************************************************/
void CListBase::DrawSmallIcon(CDC* pDC, LVITEM* pItem, LPRECT pRect)
{
  ASSERT(m_pListCtrl);

  if (pItem->iImage > 0)
  {
    CImageList* pimglst = m_pListCtrl->GetImageList(LVSIL_SMALL);

    if (pimglst)
    {
      IMAGEINFO imgInfo;

      if (pimglst->GetImageInfo(pItem->iImage, &imgInfo))
      {
        pimglst->DrawIndirect(
          pDC, pItem->iImage, CPoint(pRect->left, pRect->top),
          CSize(__min(pRect->right - pRect->left + 1,
                      imgInfo.rcImage.right - imgInfo.rcImage.left),
                __min(pRect->bottom - pRect->top + 1,
                      imgInfo.rcImage.bottom - imgInfo.rcImage.top)),
          CPoint(0, 0),
          pItem->state & LVIS_SELECTED &&
          m_pListCtrl->GetFocus() == m_pListCtrl ? ILD_SELECTED : ILD_NORMAL,
          SRCCOPY, CLR_NONE);
      }
    }
  }
}

/*** Draw state icon *********************************************************/
void CListBase::DrawStateIcon(CDC* pDC, LVITEM* pItem, LPRECT pRect)
{
  ASSERT(m_pListCtrl);

  int nImage = (pItem->state & LVIS_STATEIMAGEMASK) >> 12;

  if (nImage > 0)
  {
    CImageList* pimglst = m_pListCtrl->GetImageList(LVSIL_STATE);

    if (pimglst)
    {
      IMAGEINFO imgInfo;
      // image indices are zero-based
      if (pimglst->GetImageInfo(--nImage, &imgInfo))
      {
        pimglst->DrawIndirect(
        pDC, nImage, CPoint(pRect->left, pRect->top),
        CSize(__min(pRect->right - pRect->left + 1,
                    imgInfo.rcImage.right - imgInfo.rcImage.left),
              __min(pRect->bottom - pRect->top + 1,
                    imgInfo.rcImage.bottom - imgInfo.rcImage.top)),
        CPoint(0, 0),
        pItem->state & LVIS_SELECTED &&
        m_pListCtrl->GetFocus() == m_pListCtrl ? ILD_SELECTED : ILD_NORMAL,
        SRCCOPY, CLR_NONE);
      }
    }
  }
}

/*** Enable or disable sort icon *********************************************/
void CListBase::EnableSortIcon(bool bEnable, int nSortColumn)
{
  ASSERT(m_pListCtrl);
  ASSERT(m_pListCtrl->GetHeaderCtrl());
  m_bSortIconEnabled = bEnable;
  m_nSortColumn      = nSortColumn;
  m_pListCtrl->GetHeaderCtrl()->SetImageList(&m_imglstSortIcons);
  SetSortIcon                               ();  // display or hide sort icon
}

/*** Calculate width of item or subitem label ********************************/
int CListBase::GetLabelWidth(CDC* pDC, LVITEM* pItem, int nMaxWidth) const
{
  if (nMaxWidth > 0 && *pItem->pszText)
  {
    CString strLabel(pItem->pszText);

    MakeShortString(pDC, strLabel, nMaxWidth);
    return pDC->GetTextExtent(strLabel).cx;
  }
  else
    return 0;
}

/*** Determines which list view item, if any, is at a specified position *****/
int CListBase::HitTest(CPoint pt, UINT* pFlags)
{
  ASSERT(m_pListCtrl);

  int nItem = m_pListCtrl->CListCtrl::HitTest(pt, pFlags);

  if (m_pListCtrl->GetStyle() & LVS_OWNERDRAWFIXED && nItem >= 0 && pFlags)
    if (*pFlags == LVHT_ONITEM)
    {
      CRect rc;
      if (GetRealSubItemRect(nItem, 0, LVIR_LABEL, rc) && rc.PtInRect(pt))
        *pFlags = LVHT_ONITEMLABEL;
      else if (GetRealSubItemRect(nItem, 0, LVIR_ICON, rc) && rc.PtInRect(pt))
        *pFlags = LVHT_ONITEMICON;
      else if (GetStateIconRect(nItem, rc) && rc.PtInRect(pt))
        *pFlags = LVHT_ONITEMSTATEICON;
    }

  return nItem;
}

/*** Return the order in the header control of a subitem, based on its index */
int CListBase::IndexToOrder(int nIndex)
{
  ASSERT(m_pListCtrl);
  ASSERT(m_pListCtrl->GetHeaderCtrl());

  HDITEM headerItem = {HDI_ORDER};
  return m_pListCtrl->GetHeaderCtrl()->GetItem(nIndex, &headerItem) ?
         headerItem.iOrder : -1;

}

/*** Small icon always should be kept left ***********************************/
bool CListBase::KeepLabelLeft(bool bKeepLeft)
{
  bool bSuccess = true;

  if (bKeepLeft)
    if ((m_pListCtrl->GetStyle() & LVS_OWNERDRAWFIXED) == 0)
    {
      bKeepLeft = false;
      bSuccess  = false;
    }

  m_bKeepLabelLeft = bKeepLeft;
  return bSuccess;
}

/*** Protected member functions **********************************************/

/*** Add a new column to the listview control ********************************/
int CListBase::InsertColumn(int nCol, const LVCOLUMN* pColumn)
{
  ASSERT(m_pListCtrl);

  if (nCol == 0) m_nFormatOfSubItem0 = pColumn->fmt;
  nCol = m_pListCtrl->CListCtrl::InsertColumn(nCol, pColumn);
  if (nCol == 0) JustifyFirstColumn(pColumn->fmt);
  return nCol;
}

int CListBase::InsertColumn(int nCol, LPCTSTR lpszColumnHeading,
                            int nFormat, int nWidth, int nSubItem)
{
  ASSERT(m_pListCtrl);

  if (nCol == 0) m_nFormatOfSubItem0 = nFormat;
  nCol = m_pListCtrl->CListCtrl::InsertColumn(nCol, lpszColumnHeading, nFormat,
                                              nWidth, nSubItem);
  if (nCol == 0) JustifyFirstColumn(nFormat);
  return nCol;
}

/*** 重载InsertItem函数，加入项辅助类 ***/
  int CListBase::InsertItem(  const LVITEM* pItem )
  {
	  ASSERT( m_pListCtrl );
	  
	  CItemData* pData = new CItemData();
	  ASSERT(pData);
     
	  int iRet = m_pListCtrl->CListCtrl::InsertItem(pItem);
	  pData->SetIndex(iRet);
	  m_pListCtrl->CListCtrl::SetItemData( iRet,(DWORD)pData );
	  m_ItemDatas.Add( pData );

	  return iRet;
  }

  int CListBase::InsertItem( int nItem, LPCTSTR lpszItem )
  {
      ASSERT( m_pListCtrl );
	  
	  CItemData* pData = new CItemData();
	  ASSERT(pData);
     
	  int iRet = m_pListCtrl->CListCtrl::InsertItem(nItem,lpszItem);
	  pData->SetIndex(iRet);
	  m_pListCtrl->CListCtrl::SetItemData( iRet,(DWORD)pData );
	  m_ItemDatas.Add( pData );

	  return iRet;
  }

  int CListBase::InsertItem( int nItem, LPCTSTR lpszItem, int nImage )
  {
       ASSERT( m_pListCtrl );
	  
	  CItemData* pData = new CItemData();
	  ASSERT(pData);
     
	  int iRet = m_pListCtrl->CListCtrl::InsertItem(nItem,lpszItem,nImage);
	  pData->SetIndex(iRet);
	  m_pListCtrl->CListCtrl::SetItemData( iRet, (DWORD)pData );
	  m_ItemDatas.Add( pData );

	  return iRet;
  }
  
  int CListBase::InsertItem( UINT nMask, int nItem, LPCTSTR lpszItem, UINT nState, UINT nStateMask, int nImage, LPARAM lParam )
  {
	  ASSERT(m_pListCtrl);
      
	  CItemData* pData = new CItemData();
	  ASSERT(pData);
      int iRet = m_pListCtrl->CListCtrl::InsertItem( nMask,nItem,lpszItem,nState,nStateMask,nImage,lParam);
	  pData->SetIndex(iRet);
	  m_pListCtrl->CListCtrl::SetItemData( iRet, (DWORD)pData );
	  m_ItemDatas.Add( pData );

	  if( nMask&LVIF_PARAM )
		  SetItemData(iRet,(DWORD)lParam);
	  
	  return iRet;

  }
  /*** 重载删除项函数，释放辅助类对象 ***/
  BOOL CListBase::DeleteItem(  int nItem )
  {
      ASSERT( m_pListCtrl );

	  CItemData* pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(nItem) );
	  if( pData ) RemoveItemData(pData);

	  return  m_pListCtrl->CListCtrl::DeleteItem( nItem );
  }

  BOOL CListBase::DeleteAllItems( )
  {
      ASSERT( m_pListCtrl );

	  CItemData* pData = NULL;

	  for( int i=0; i < m_pListCtrl->CListCtrl::GetItemCount(); i++ )
	  {
	      pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(i) );
		  if( pData ) RemoveItemData(pData);;
	  }

	  return m_pListCtrl->CListCtrl::DeleteAllItems();
  }

  BOOL CListBase::RemoveItemData( CItemData* pData )
  {
	  if( !pData ) return FALSE;
      
	  CItemData* pd = NULL;
	  for( int i=0 ;i<m_ItemDatas.GetSize();i++)
	  {
		  pd = (CItemData*)m_ItemDatas.GetAt(i);
		  if( pd == pData )
		  {
			  delete( pData);
			  m_ItemDatas.RemoveAt(i);
			  return TRUE;
		  }
	  }
	  return FALSE;
  }

  /*** 重载SetItemData和GetItemData函数，处理项外部关联数据 ***/
  DWORD CListBase::GetItemData( int nItem ) const
  {
      ASSERT( m_pListCtrl );
	  
	  CItemData* pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(nItem) );
	  ASSERT(pData);

	  return  pData->GetData();	
  }

  BOOL CListBase::SetItemData( int nItem, DWORD dwData )
  {
      ASSERT( m_pListCtrl );

	  CItemData* pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(nItem) );      
	  ASSERT( pData );
	  pData->SetData( dwData );

	  return TRUE;
  }

  /*** 设置或获取项的粗体状态 ***/
  void  CListBase::SetBoldItem( int nItem, BOOL bBold )
  {
      ASSERT( m_pListCtrl );
      
	  if( nItem >= m_pListCtrl->CListCtrl::GetItemCount() || nItem < 0 ) return ;

	  CItemData* pData = reinterpret_cast<CItemData*>( m_pListCtrl->CListCtrl::GetItemData(nItem) );      
	  ASSERT( pData );
	  if( pData->GetBold() != bBold )
	  {
	      pData->SetBold( bBold );
		  m_pListCtrl->CListCtrl::RedrawItems( nItem,nItem );
	  }
  }

  BOOL  CListBase::GetBoldItem( int nItem )