treelistctrl.cpp

一个关于数据结结的

	else
		lResult = pWnd->SendMessage( WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nm );

	return lResult;	
}

LRESULT CTreeListCtrl::NotifyDrop( DWORD dwMessage, CTreeListCtrl* pSource , CTreeListItem* pItem )
{
	// notify drop messages
	NMTREELISTDROP nm;
	nm.hdr.hwndFrom	= GetSafeHwnd();
	nm.hdr.idFrom	= GetDlgCtrlID();
	nm.hdr.code		= dwMessage;

	nm.pSource	= pSource;
	nm.pItem	= pItem;

	CWnd* pWnd		= GetParent();
	LRESULT lResult = 0;

	if( pWnd == NULL )
		lResult = 0;
	else
		lResult = pWnd->SendMessage( WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nm );

	return lResult;	
}

void CTreeListCtrl::Layout()
{
	// layout size
	if( !IsWindow( m_wndHeader.GetSafeHwnd() ) )
		return;

	if( !IsWindow( m_wndTip.GetSafeHwnd() ) )
		return;

	m_wndTip.Hide();

	SetAllScroll();

	GetClientRect( &m_rcClient );
	m_rcHeader		= m_rcClient;
	m_rcTreeList	= m_rcClient;

	m_wndHeader.SendMessage( HDM_LAYOUT, (WPARAM)0, (LPARAM)&m_rcHeader );

	if( m_rcHeader.Height() == 0 )
	{
		m_rcTreeList = m_rcClient;
	}
	else if( m_rcHeader.Height() == m_rcClient.Height() )
	{
		m_rcTreeList.top	= m_rcHeader.bottom;
		m_rcTreeList.bottom = m_rcHeader.bottom;
	}
	else
	{
		m_rcTreeList.top	= m_rcHeader.bottom;
	}

	SetAllScroll();

	return;
}
int CTreeListCtrl::GetWidth()
{
	// retrieve total width
	int nWidth = 0;

	for( int iShow=0; iShow<m_arShows.GetSize(); iShow++ )
	{
		CTreeListColumnInfo* pColumnInfo;
		int iCol;

		iCol = m_arShows[iShow];
		pColumnInfo = (CTreeListColumnInfo*)m_arColumns[iCol];

		nWidth += pColumnInfo->m_nWidth;
	}

	return nWidth;
}

int CTreeListCtrl::GetHeight()
{
	// retrieve total height
	return GetItemHeight() * GetVisibleCount();
}

int CTreeListCtrl::GetColumns()
{
	// retrieve total number of columns
	return m_arColumns.GetSize();
}

int CTreeListCtrl::GetCount()
{
	// retrieve a count of the items in treelist control
	return m_pRootItem->m_nChild - 1;
}

CImageList* CTreeListCtrl::GetImageList()
{
	// retrieve global point of image list
	return m_pImageList;
}

void CTreeListCtrl::SetImageList( CImageList* pImageList )
{
	// set global point of image list
	ASSERT_VALID( pImageList );
	m_pImageList = pImageList;

	Invalidate();
}

CTreeListItem* CTreeListCtrl::GetNextItem( CTreeListItem* pItem, UINT nCode )
{
	// retrieve next item specified by pItem
	CTreeListItem* pRetItem = NULL;

	switch( nCode )
	{
	case TLGN_ROOT:				pRetItem = GetRootItem();					break;
	case TLGN_NEXT:				pRetItem = GetNextSiblingItem( pItem );		break;
	case TLGN_PREVIOUS:			pRetItem = GetPrevSiblingItem( pItem );		break;
	case TLGN_PARENT:			pRetItem = GetParentItem( pItem );			break;
	case TLGN_CHILD:			pRetItem = GetChildItem( pItem );			break;
	case TLGN_FIRSTVISIBLE:		pRetItem = GetFirstVisibleItem();			break;
	case TLGN_NEXTVISIBLE:		pRetItem = GetNextVisibleItem( pItem );		break;
	case TLGN_PREVIOUSVISIBLE:	pRetItem = GetPrevVisibleItem( pItem );		break;
	case TLGN_DROPHILITE:		pRetItem = NULL;							break;
	case TLGN_CARET:			pRetItem = GetSelectedItem();				break;
	case TLGN_NEXTSELECT:		pRetItem = GetNextSelectedItem( pItem );	break;
	default:					pRetItem = NULL;							break;
	}

	return pRetItem;
}

BOOL CTreeListCtrl::ItemHasChildren( CTreeListItem* pItem )
{
	// determine whether the treelist item specified by pItem has a child item
	ASSERT( pItem != NULL );

	if( pItem->m_pChild == NULL )
		return FALSE;

	return TRUE;
}

CTreeListItem* CTreeListCtrl::GetChildItem( CTreeListItem* pItem )
{
	// retrieve first child item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->m_pChild;
}

CTreeListItem* CTreeListCtrl::GetNextSiblingItem( CTreeListItem* pItem )
{
	// retrieve next sibling item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->m_pNext;
}

CTreeListItem* CTreeListCtrl::GetPrevSiblingItem( CTreeListItem* pItem )
{
	// retrieve prev sibling item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->m_pPrev;
}

CTreeListItem* CTreeListCtrl::GetParentItem( CTreeListItem* pItem )
{
	// retrieve parent item specified by pItem
	ASSERT( pItem != NULL );
	if( pItem->m_pParent == m_pRootItem )
		return NULL;
	else
		return pItem->m_pParent;
}

CTreeListItem* CTreeListCtrl::GetFirstVisibleItem()
{
	// retrieve first visible item of treelist
	if( m_pRootItem->m_pChild != NULL )
		return m_pRootItem->m_pChild;

	return NULL;
}

CTreeListItem* CTreeListCtrl::GetNextVisibleItem( CTreeListItem* pItem )
{
	// retrieve next visible item of treelist
	ASSERT( pItem != NULL );

	return GetNextVisibleItem( pItem, TRUE );
}

CTreeListItem* CTreeListCtrl::GetNextVisibleItem( CTreeListItem* pItem, BOOL bChild )
{
	// retrieve next visible item of treelist
	ASSERT( pItem != NULL );

	if( pItem->GetState()&TLIS_EXPANDED )
		if( bChild && pItem->m_pChild != NULL )
			return pItem->m_pChild;

	if( pItem->m_pNext != NULL )
		return pItem->m_pNext;

	if( pItem != m_pRootItem )
	{
		pItem = pItem->m_pParent;
		if( pItem != m_pRootItem )
			return GetNextVisibleItem( pItem, FALSE );
	}

	return NULL;
}

CTreeListItem* CTreeListCtrl::GetPrevVisibleItem( CTreeListItem* pItem )
{
	// retrieve previous visible item of treelist
	ASSERT( pItem != NULL );

	return GetPrevVisibleItem( pItem, TRUE );
}

CTreeListItem* CTreeListCtrl::GetPrevVisibleItem( CTreeListItem* pItem, BOOL bChild )
{
	// retrieve previous visible item of treelist
	ASSERT( pItem != NULL );

	if( pItem->m_pPrev != NULL )
	{
		pItem = pItem->m_pPrev;
		if( pItem->GetState()&TLIS_EXPANDED && pItem->m_pChild != NULL )
		{
			pItem = GetLastVisibleItem( pItem );
		}
		return pItem;
	}

	pItem = pItem->m_pParent;
	if( pItem != m_pRootItem )
		return pItem;

	return FALSE;
}

CTreeListItem* CTreeListCtrl::GetLastVisibleItem( CTreeListItem* pItem )
{
	// retrieve last visible child item of item specified by pItem
	ASSERT( pItem != NULL && pItem->m_pChild != NULL );

	CTreeListItem* pChild;
	pChild = pItem->m_pChild;

	while( pChild->m_pNext != NULL )
	{
		pChild = pChild->m_pNext;
	}

	if( pChild->GetState()&TLIS_EXPANDED && pChild->m_pChild != NULL  )
		return GetLastVisibleItem( pChild );
	else
		return pChild;
}


CTreeListItem* CTreeListCtrl::GetSelectedItem()
{
	// always retrieve first selected item
	POSITION pos = GetFirstSelectedItemPosition();
	return GetNextSelectedItem( pos );
}

CTreeListItem* CTreeListCtrl::GetNextSelectedItem( CTreeListItem* pItem )
{
	// retrieve next selected item specified by pItem
	if( pItem == NULL )
		return NULL;

	if( pItem == m_pRootItem && m_arSelects.GetSize() > 0 )
		return (CTreeListItem*)m_arSelects[0];

	for( int iSel = 0; iSel<m_arSelects.GetSize()-1; iSel++ )
	{
		if( pItem == (CTreeListItem*)m_arSelects[iSel] )
			return (CTreeListItem*)m_arSelects[iSel+1];
	}

	return NULL;
}

CTreeListItem* CTreeListCtrl::GetRootItem()
{
	// retrieve root item of treelist control
	return m_pRootItem->m_pChild;
}

DWORD CTreeListCtrl::GetItemState( CTreeListItem* pItem, DWORD nStateMask )
{
	// retrieve status of item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->GetState( nStateMask );
}

void CTreeListCtrl::SetItemState( CTreeListItem* pItem, DWORD dwAddState, DWORD dwRemoveState )
{
	// set status of item specified by pItem
	ASSERT( pItem != NULL );
	pItem->SetState( dwAddState, dwRemoveState );
	Invalidate();
}

void CTreeListCtrl::GetItemImage( CTreeListItem* pItem, int& nImage, int& nExpandImage, int& nSelectedImage, int& nExpandSelectedImage )
{
	// retrieve images of item specified by pItem
	ASSERT( pItem != NULL );
	pItem->GetImage( nImage, nExpandImage, nSelectedImage, nExpandSelectedImage );
}

void CTreeListCtrl::SetItemImage( CTreeListItem* pItem, int nImage, int nExpandImage, int nSelectedImage, int nExpandSelectedImage )
{
	// set images of item specified by pItem
	ASSERT( pItem != NULL );
	pItem->SetState( TLIS_SHOWTREEIMAGE );
	pItem->SetImage( nImage, nExpandImage, nSelectedImage, nExpandSelectedImage );
	Invalidate();
}	

LPCTSTR	CTreeListCtrl::GetItemText( CTreeListItem* pItem, int nSubItem )
{
	// retrieve text of item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->GetText( nSubItem );
}

BOOL CTreeListCtrl::SetItemText( CTreeListItem* pItem, LPCTSTR lpszText, int nSubItem )
{
	// set text of item specified by pItem
	ASSERT( pItem != NULL );
	BOOL bRet = pItem->SetText( lpszText, nSubItem );
	Invalidate();
	return bRet;
}

DWORD CTreeListCtrl::GetItemData( CTreeListItem* pItem )
{
	// retrieve 32-bit data of item specified by pItem
	ASSERT( pItem != NULL );
	return pItem->GetData();
}

void CTreeListCtrl::SetItemData( CTreeListItem* pItem, DWORD dwData )
{
	// set 32-bit data of item specified by pItem
	ASSERT( pItem != NULL );
	pItem->SetData( dwData );
}

int CTreeListCtrl::GetVisibleCount()
{
	// retrieve the  number of visible items in the treelist control
	return GetVisibleCount( m_pRootItem );
}

int CTreeListCtrl::GetItemHeight()
{
	// retrieve the height of the item
	return m_nItemHeight;
}

int CTreeListCtrl::SetItemHeight( int cyHeight )
{
	// set the height of the item
	int nOldHeight = m_nItemHeight;

	if( cyHeight == -1 )
	{
		ASSERT( m_Font.m_hObject != NULL );

		LOGFONT lf;
		m_Font.GetLogFont( &lf );
	
		if( lf.lfHeight < 0 )
		{
			m_nItemHeight = -lf.lfHeight + 5;
		}
		else if( lf.lfHeight == 0 )
		{
			m_nItemHeight = DEFAULT_HEIGHT;
		}
		else
		{
			m_nItemHeight = lf.lfHeight + 5;
		}
	}
	else
	{
		m_nItemHeight = cyHeight;
	}

	if( m_nItemHeight % 2 == 1 )
		m_nItemHeight ++;

	Invalidate();

	return nOldHeight;
}

COLORREF CTreeListCtrl::GetBkColor( int nColor )
{
	// set background color of treelist control
	COLORREF clr;

	switch( nColor )
	{
	case 0:		clr = m_crBkColor_0;		break;
	case 1:		clr = m_crBkColor_1;		break;
	case 2:		clr = m_crBkColor_2;		break;
	default:	clr = m_crBkColor;		break;
	}

	return clr;
}

COLORREF CTreeListCtrl::SetBkColor( COLORREF clr, int nColor )
{
	// retrieve background color of treelist control
	COLORREF oldclr;

	switch( nColor )
	{
	case 0:		oldclr = m_crBkColor_0;		m_crBkColor_0 = clr;		break;
	case 1:		oldclr = m_crBkColor_1;		m_crBkColor_1 = clr;		break;
	case 2:		oldclr = m_crBkColor_2;		m_crBkColor_2 = clr;		break;
	default:	oldclr = m_crBkColor;		m_crBkColor = clr;		break;
	}

	Invalidate();
	return oldclr;
}

COLORREF CTreeListCtrl::GetTextColor()
{
	// retrieve the color of the text
	return m_crText;
}

COLORREF CTreeListCtrl::SetTextColor( COLORREF clr )
{
	// set the color of the text
	COLORREF oldclr;
	oldclr = m_crText;
	m_crText = clr;

	Invalidate();

	return m_crText;
}

int CTreeListCtrl::GetCheck( CTreeListItem* pItem )
{
	// retrieve an item checked box state
	ASSERT( pItem != NULL );
	return pItem->GetCheck();
}

void CTreeListCtrl::SetCheck( CTreeListItem* pItem, BOOL bCheck )
{
	// set an item checked box state
	ASSERT( pItem != NULL );
	pItem->SetCheck( bCheck );
	
	if( pItem->GetCheck() )
	{
		SetItemChildStatus( pItem, TLIS_CHECKED, TLIS_CHECKED_NULL );
		SetItemParentStatus( pItem, TLIS_CHECKEDMASK );
	}
	else
	{
		SetItemChildStatus( pItem, TLIS_CHECKED_NULL, TLIS_CHECKED );
		SetItemParentStatus( pItem, TLIS_CHECKEDMASK );
	}

	Invalidate();
}

int CTreeListCtrl::GetLock( CTreeListItem* pItem )
{
	// retrieve an item locked box state
	ASSERT( pItem != NULL );
	return pItem->GetLock();
}

void CTreeListCtrl::SetLock( CTreeListItem* pItem, BOOL bLock )
{
	// set an item locked box state
	ASSERT( pItem != NULL );
	pItem->SetLock( bLock );

	if( pItem->GetLock() )
	{
		SetItemChildStatus( pItem, TLIS_LOCKED, TLIS_LOCKED_NULL );
		SetItemParentStatus( pItem, TLIS_LOCKEDMASK );
	}
	else
	{
		SetItemChildStatus( pItem, TLIS_LOCKED_NULL, TLIS_LOCKED );
		SetItemParentStatus( pItem, TLIS_LOCKEDMASK );
	}
	Invalidate();
}

BOOL CTreeListCtrl::GetItemRect( CTreeListItem* pItem, LPRECT lpRect )
{
	// retrieve rect of an item
	int nFirstRow	=	GetScrollPos( SB_VERT );
	int	nShowRows	=	m_rcTreeList.Height() / GetItemHeight() + 1;

	CRect rcItem;
	rcItem.SetRect( 0, 0, GetWidth(), GetItemHeight() );
	rcItem.OffsetRect( m_rcTreeList.left, m_rcTreeList.top );
	rcItem.OffsetRect( -GetScrollPos( SB_HORZ ), 0 );

	for( int i = nFirstRow; i<= nFirstRow + nShowRows && i < GetVisibleCount(); i++ )
	{
		CTreeListItem* pShowItem = GetFirstShowItem( i );
		if( pShowItem == pItem )
		{
			lpRect->left	= rcItem.left;
			lpRect->right	= rcItem.right;
			lpRect->top		= rcItem.top;
			lpRect->bottom	= rcItem.bottom;

//			lpRect->top		+= 1;
//			lpRect->bottom	-= 1;

			return TRUE;
		}

		rcItem.OffsetRect( 0, GetItemHeight() );
	}
	return FALSE;
}

BOOL CTreeListCtrl::GetItemRect( CTreeListItem* pItem, int iSubItem, LPRECT lpRect, BOOL bTextOnly )
{
	// retrieve rect of a column of an item
	CRect rcItem;
	
	if( GetItemRect( pItem, rcItem ) )
	{
		int nColPos = 0;
		CTreeListColumnInfo* pColumnInfo;

		for( int iShow = 0; iShow < m_arShows.GetSize(); iShow++, nColPos += pColumnInfo->GetWidth() )
		{
			int iCol;