treelistctrl.cpp

一个关于数据结结的

	lpRect->bottom	= m_rcTreeList.bottom;

	return m_rcTreeList.IsRectEmpty();
}

int CTreeListCtrl::GetTopIndex()
{
	// retrieve index of first visible item ( list )
	return GetScrollPos( SB_VERT );
}

int CTreeListCtrl::GetCountPerPage()
{
	// retrieve rows of visible item of one page ( list )
	return m_rcTreeList.Height() / GetItemHeight() + 1;
}

BOOL CTreeListCtrl::GetOrigin( LPPOINT lpPoint )
{
	// retrieve origin point of a list ( list )
	lpPoint->x = m_rcTreeList.left;
	lpPoint->y = m_rcTreeList.top;
	return TRUE;
}

UINT CTreeListCtrl::GetSelectedCount()
{
	// retrieve count of selected item ( list )
	return m_arSelects.GetSize();
}

BOOL CTreeListCtrl::SetColumnOrderArray( int iCount, LPINT piArray )
{
	// set show order of columns
	m_arShows.RemoveAll();

	for( int iShow=0; iShow<iCount; iShow++ )
		m_arShows.Add( piArray[iShow] );

	Invalidate();

	return TRUE;
}

BOOL CTreeListCtrl::GetColumnOrderArray( LPINT piArray, int iCount )
{
	// retrieve column show order
	if( iCount <= 0 )
		iCount = m_arShows.GetSize();

	for( int iShow=0; iShow<m_arShows.GetSize(); iShow++ )
		piArray[iShow] = m_arShows[iShow];

	Invalidate();

	return TRUE;
}

CTreeListHeaderCtrl* CTreeListCtrl::GetHeaderCtrl()
{
	// retrieve header control
	return &m_wndHeader;
}

int CTreeListCtrl::GetSelectionMark()
{
	// retrieve selection 
	POSITION pos = GetFirstSelectedItemPosition();
	return GetTreeListItem( GetNextSelectedItem( pos ) );
}

int CTreeListCtrl::SetSelectionMark( int iIndex )
{
	// set selection mark of an item
	int nItem = GetSelectionMark();
	SelectItem( GetTreeListItem( iIndex ), 0, FALSE );

	Invalidate();

	return nItem;
}

void CTreeListCtrl::SetFont()
{
	// set font with font of parent window
	CWnd* pWnd = GetParent();
	if( pWnd == NULL )
		return;

	CFont* pFont = pWnd->GetFont();
	if( pFont == NULL )
		return;

	LOGFONT lf;
	pFont->GetLogFont(&lf);
	m_Font.DeleteObject();
	m_Font.CreateFontIndirect(&lf);

	Invalidate();
}

CFont* CTreeListCtrl::GetFont()
{
	// retrieve font
	return &m_Font;
}

DWORD CTreeListCtrl::SetStyle( DWORD dwStyle )
{
	// set style of treelist control
	DWORD dwoldStyle = m_dwStyle;
	m_dwStyle = dwStyle;

	if( !(m_dwStyle&TLC_TREELIST ) )
	{
		m_dwStyle &= ~TLC_TREELINE;
		m_dwStyle &= ~TLC_ROOTLINE;
		m_dwStyle &= ~TLC_BUTTON;	
	}

	if( !(m_dwStyle&TLC_HGRID) )
	{
		m_dwStyle &= ~TLC_TGRID;
		m_dwStyle &= ~TLC_HGRID_EXT;
		m_dwStyle &= ~TLC_HGRID_FULL;
	}

	if( !(m_dwStyle&TLC_VGRID) )
	{
		m_dwStyle &= ~TLC_VGRID_EXT;
	}

	if( m_dwStyle&TLC_HGRID && m_dwStyle&TLC_VGRID )
	{
		if( m_dwStyle&TLC_HGRID_EXT && !(m_dwStyle&TLC_VGRID_EXT) )
			m_dwStyle &= ~( TLC_HGRID_EXT | TLC_VGRID_EXT );
		if( !(m_dwStyle&TLC_HGRID_EXT) && m_dwStyle&TLC_VGRID_EXT )
			m_dwStyle &= ~( TLC_HGRID_EXT | TLC_VGRID_EXT );
	}

	if( !(m_dwStyle&TLC_HEADER) )
	{
		m_dwStyle &= ~TLC_HEADDRAGDROP;
		m_dwStyle &= ~TLC_HEADFULLDRAG;
	}

	if( GetStyle()&TLC_HEADDRAGDROP )
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()|TLHS_DRAGDROP );
	else
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()&~TLHS_DRAGDROP );
	
	if( GetStyle()&TLC_HEADFULLDRAG )
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()|TLHS_FULLDRAG );
	else
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()&~TLHS_FULLDRAG );

	if( GetStyle()&TLC_HEADER )
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()|TLHS_SHOWHEAD );
	else
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()&~TLHS_SHOWHEAD );

	if( GetStyle()&TLC_HOTTRACK )
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()|TLHS_HOTTRACK );
	else
		m_wndHeader.SetStyle( m_wndHeader.GetStyle()&~TLHS_HOTTRACK );

	Invalidate();

	return dwoldStyle;
}

DWORD CTreeListCtrl::GetStyle()
{
	// retrieve treelist control style
	return m_dwStyle;
}

void CTreeListCtrl::SetState( DWORD dwAddState, DWORD dwRemoveState )
{
	// set retrieve state of control
	m_dwState |= dwAddState;
	m_dwState &=~dwRemoveState;
	return; 
}

DWORD CTreeListCtrl::GetState( DWORD nStateMask )
{
	// retrieve state of control
	return m_dwState&nStateMask;
}

int CTreeListCtrl::GetSelectColumn()
{
	// retrieve select column
	return m_iSelCol;
}

int CTreeListCtrl::GetColumnCount()
{
	// retrieve column count
	return GetColumns();
}

int CTreeListCtrl::GetVisibleCount( CTreeListItem* pParent )
{
	// retrieve visible rows
	if( pParent == m_pRootItem )
		return pParent->m_nVisibleChild - 1;
	else
		return pParent->m_nVisibleChild;
}

void CTreeListCtrl::StatChildAdd( CTreeListItem* pItem, int nChild, int nVisibleChild )
{
	// stat. number of child & visible child on any level when add some new child
	ASSERT( pItem != NULL );
	
	if( pItem->m_pParent == NULL )
		return;
	
	CTreeListItem* pParent = pItem->m_pParent;

	pParent->m_nChild			+= nChild;

	if( pParent->GetState()&TLIS_EXPANDED )
	{
		pParent->m_nVisibleChild	+= nVisibleChild;
		StatChildAdd( pParent, nChild, nVisibleChild );
	}
	else
	{
		StatChildAdd( pParent, nChild, 0 );
	}
}

void CTreeListCtrl::StatChildDel( CTreeListItem* pItem, int nChild, int nVisibleChild )
{
	// stat. number of child & visible child on any level when add some new child
	ASSERT( pItem != NULL );
	
	if( pItem->m_pParent == NULL )
		return;
	
	CTreeListItem* pParent = pItem->m_pParent;
	
	pParent->m_nChild			-= nChild;
	
	if( pParent->GetState()&TLIS_EXPANDED )
	{
		pParent->m_nVisibleChild	-= nVisibleChild;
		StatChildDel( pParent, nChild, nVisibleChild );
	}
	else
	{
		StatChildDel( pParent, nChild, 0 );
	}
}

void CTreeListCtrl::StatExpand( CTreeListItem* pItem )
{
	// stat. number of child & visible child on any level when expand an item
	ASSERT( pItem != NULL );
	if( pItem->m_pChild == NULL )
		return;

	int nVisibleChild = 0;
	
	CTreeListItem* pChild = pItem->m_pChild;
	while( pChild != NULL )
	{
		nVisibleChild += pChild->m_nVisibleChild;
		pChild = pChild->m_pNext;
	}
	pItem->m_nVisibleChild += nVisibleChild;
	
	CTreeListItem* pParent = pItem->m_pParent;
	while( pParent != NULL )
	{
		pParent->m_nVisibleChild += nVisibleChild;
		pParent = pParent->m_pParent;
	}

	return;
}

void CTreeListCtrl::StatCollapse( CTreeListItem* pItem )
{
	// stat. number of child & visible child on any level when collapse an item
	ASSERT( pItem != NULL );
	if( pItem->m_pChild == NULL )
		return;

	int nVisibleChild = 0;

	CTreeListItem* pChild = pItem->m_pChild;
	while( pChild != NULL )
	{
		nVisibleChild += pChild->m_nVisibleChild;
		pChild = pChild->m_pNext;
	}
	pItem->m_nVisibleChild -= nVisibleChild;

	CTreeListItem* pParent = pItem->m_pParent;
	while( pParent != NULL )
	{
		pParent->m_nVisibleChild -= nVisibleChild;
		pParent = pParent->m_pParent;
	}

	return;
}

void CTreeListCtrl::SetItemCheck( CTreeListItem* pItem, BOOL bAutoCheck )
{
	// auto set check status ( include parent and child )
	LRESULT lResult;

	lResult = Notify( TLN_ITEMCHECK, pItem, 0 );
	if( lResult == -1 )
		return;

	if( bAutoCheck )
		pItem->SetCheck( !pItem->GetCheck() );

	if( m_dwStyle&TLC_NOAUTOCHECK )
		return;

	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();

	return;
}

void CTreeListCtrl::SetItemLock( CTreeListItem* pItem, BOOL bAutoLock )
{
	// auto set lock status ( include parent and child )
	LRESULT lResult;

	lResult = Notify( TLN_ITEMLOCK, pItem, 0 );
	if( lResult == -1 )
		return;

	if( bAutoLock )
		pItem->SetLock( !pItem->GetLock() );

	if( m_dwStyle&TLC_NOAUTOLOCK )
		return;

	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();

	return;
}

void CTreeListCtrl::SetItemParentStatus( CTreeListItem* pItem, DWORD dwMask )
{
	// set parent items status;
	CTreeListItem* pParent;
	pParent = pItem->m_pParent;

	DWORD dwShow;

	if( pParent == NULL )
		return;

	ASSERT( dwMask == TLIS_CHECKEDMASK || dwMask == TLIS_LOCKEDMASK );
	if( dwMask == TLIS_CHECKEDMASK )
		dwShow = TLIS_SHOWCHECKBOX;
	else
		dwShow = TLIS_SHOWLOCKBOX;
		

	DWORD dwAdd = 0;
	DWORD dwRemove = 0;
	CTreeListItem* pNext = pItem->m_pParent->m_pChild;
	if( pNext->GetState()&dwShow )
		dwAdd |= pNext->GetState();
	while( pNext != NULL )
	{
		if( pNext->GetState()&dwShow )
			dwAdd |= pNext->GetState();
		pNext = pNext->m_pNext;
	}
	dwAdd		 =  dwAdd;
	dwRemove	 = ~dwAdd;
	dwAdd		&=  dwMask;
	dwRemove	&=  dwMask;

	pParent->SetState( dwAdd, dwRemove );
	SetItemParentStatus( pParent, dwMask );

	return;
}


void CTreeListCtrl::SetItemChildStatus( CTreeListItem* pItem, DWORD dwAdd, DWORD dwRemove )
{
	// set child items status
	CTreeListItem* pChild;
	pChild = pItem->m_pChild;

	while( pChild != NULL )
	{
		if( pChild->m_pChild != NULL )
			SetItemChildStatus( pChild, dwAdd, dwRemove );

		pChild->SetState( dwAdd, dwRemove );
		pChild = pChild->m_pNext;
	}

	return;
}

CTreeListItem* CTreeListCtrl::GetFirstShowItem( int nShowItem )
{
	// retrieve first visible item after n visible items
	if( nShowItem < 0 )
		return NULL;

	if( nShowItem >= m_pRootItem->m_nVisibleChild )
		return NULL;
	
	CTreeListItem* pItem = m_pRootItem->m_pChild;
	while( nShowItem != 0 )
	{
		ASSERT( nShowItem > 0 );

		if( nShowItem < pItem->m_nVisibleChild )
		{
			nShowItem --;
			pItem = pItem->m_pChild;
		}
		else
		{
			nShowItem -= pItem->m_nVisibleChild;
			pItem = pItem->m_pNext;
		}
	}

	return pItem;
}

CTreeListItem* CTreeListCtrl::GetNextShowItem( CTreeListItem* pItem, BOOL bChild )
{
	// retrieve next visible item
	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;

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

	return NULL;
}

BOOL CTreeListCtrl::OnEraseBkgnd(CDC* pDC) 
{
	// wm_erasebkgnd
	return TRUE;
}

void CTreeListCtrl::OnPaint() 
{
	// wm_paint
	CPaintDC dc(this);
	CPalette* pPalette = NULL;

	if( dc.GetDeviceCaps(RASTERCAPS)&RC_PALETTE )
	{
		pPalette = dc.SelectPalette( &m_Palette, FALSE );
		dc.RealizePalette();
	}

	dc.ExcludeClipRect( m_rcHeader );

	if( GetState( TLS_OFFSCREENBUFFER ) )
	{
		CTreeListDC TreeListDC(&dc);
		DrawCtrl( &TreeListDC );
	}
	else
	{
		DrawCtrl( &dc );
	}

	if( pPalette != NULL && dc.GetDeviceCaps(RASTERCAPS)&RC_PALETTE )
	{
		dc.SelectPalette( pPalette, FALSE );
	}
}

void CTreeListCtrl::DrawCtrl( CDC* pDC )
{
	// draw the control
	CRect rcClip;
	if( pDC->GetClipBox( &rcClip ) == ERROR )
		return;

	DrawBkgnd( pDC, rcClip );
	DrawItems( pDC, rcClip );
}

void CTreeListCtrl::DrawBkgnd( CDC* pDC, CRect rcClip )
{
	// draw background
	CRect rectClip;
	if (pDC->GetClipBox(&rectClip) == ERROR)
		return;

	if( CWnd::GetStyle()&WS_DISABLED )
	{
		if( m_dwStyle&TLC_BKGNDIMAGE )
		{
			DrawBkgndBmp( pDC, rcClip, &m_bmpBkDisable );
		}
		else if( m_dwStyle&TLC_BKGNDCOLOR )
		{
			pDC->FillSolidRect( rectClip, m_crBkDisable );
		}
		else
		{
			pDC->FillSolidRect( rectClip, m_crBkDisable_0 );
		}
	}
	else
	{
		if( m_dwStyle&TLC_BKGNDIMAGE )
		{
			DrawBkgndBmp( pDC, rcClip, &m_bmpBkBitmap );
		}
		else if( m_dwStyle&TLC_BKGNDCOLOR )
		{
			pDC->FillSolidRect( rectClip, m_crBkColor );
		}
		else
		{
			pDC->FillSolidRect( rectClip, m_crBkColor_0 );