csgo/cstrike15_src/hammer/treelist.cpp

//========= Copyright © 1996-2009, Valve Corporation, All rights reserved. ====
//
// A tree of checkable items. Can have multiple root-level items. Supports drag and drop
// and posts a registered Windows message to the tree's parent window when items
// are checked, unchecked, dragged & dropped, and when selection changes.
//
//=============================================================================

#include "stdafx.h"
#include "treelist.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

//
// Timer IDs.
//
enum
{
	TIMER_GROUP_DRAG_SCROLL = 1,
};


// TODO: Make these messages unique per instance so a window can contain more than one of these controls
static const unsigned int g_uToggleStateMsg = ::RegisterWindowMessage(TREELIST_MSG_TOGGLE_STATE);
static const unsigned int g_uLeftDragDropMsg = ::RegisterWindowMessage(TREELIST_MSG_LEFT_DRAG_DROP);
static const unsigned int g_uRightDragDropMsg = ::RegisterWindowMessage(TREELIST_MSG_RIGHT_DRAG_DROP);
static const unsigned int g_uSelChangeMsg = ::RegisterWindowMessage(TREELIST_MSG_SEL_CHANGE);
static const unsigned int g_uKeyDownMsg = ::RegisterWindowMessage(TREELIST_MSG_KEY_DOWN);


BEGIN_MESSAGE_MAP(CTreeList, CTreeCtrl)
	//{{AFX_MSG_MAP(CGroupList)
	ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnBegindrag)
	ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, OnEndLabelEdit)
	ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelChange)
	ON_NOTIFY_REFLECT(TVN_KEYDOWN, OnKeyDown)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_TIMER()
	ON_WM_CONTEXTMENU()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CTreeList::CTreeList()
{
	m_pDragImageList = NULL;
	m_hDragItem = NULL;
	m_bRButtonDown = false;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CTreeList::~CTreeList()
{
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::EnableChecks()
{
	if (!m_cNormalImageList.GetSafeHandle())
	{
		// TODO: pass the image list in?
		#define IDB_TREELISTCHECKS 223
		m_cNormalImageList.Create(IDB_TREELISTCHECKS, 16, 1, RGB(255, 255, 255));
		m_cNormalImageList.SetOverlayImage(1, 1);
		m_cNormalImageList.SetOverlayImage(2, 2);
	}

	CTreeCtrl::SetImageList(&m_cNormalImageList, TVSIL_STATE);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::AddItem(void *pItem, void *pParent, const char *pText, bool bHasCheckBox )
{
	HTREEITEM hParent = TVI_ROOT;
	if (pParent)
	{
		// FIXME: recursive lookup for every add is sucky
		hParent = FindHTreeItem(pParent);
	}
	
	HTREEITEM hItem = InsertItem(pText, hParent, TVI_LAST);
	if (hItem != NULL)
	{
		SetItemData(hItem, (DWORD)pItem);
		m_Items.AddToTail(pItem);

		if ( bHasCheckBox )
		{
			SetItemState( hItem, INDEXTOSTATEIMAGEMASK( 1 ), TVIS_STATEIMAGEMASK );
		}
		else
		{
			SetItemState( hItem, INDEXTOSTATEIMAGEMASK( 0 ), TVIS_STATEIMAGEMASK );
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static void UnsetItemData_R( CTreeCtrl *pCtrl, HTREEITEM hItem )
{
	pCtrl->SetItemData( hItem, 0 );
	
	HTREEITEM hChildItem = pCtrl->GetChildItem( hItem );

	while( hChildItem != NULL )
	{
		UnsetItemData_R( pCtrl, hChildItem );
		hChildItem = pCtrl->GetNextItem(hChildItem, TVGN_NEXT);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::DeleteAllItems()
{
	// Un-set all item data because sometimes during a delete it'll trigger selection change notifications
	// which might crash things later.
	if ( GetSafeHwnd() && m_Items.Count() > 0 )
	{
		UnsetItemData_R( this, TVI_ROOT );
	}
	
	DeleteItem(TVI_ROOT);
	m_Items.RemoveAll();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::EnsureVisible(void *pItem)
{
	//DBG("EnsureVisible: %s\n", pVisGroup->GetName());
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		CTreeCtrl::EnsureVisible(hItem);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::ExpandRecursive(HTREEITEM hItem)
{
	if (hItem)
	{
		Expand(hItem, TVE_EXPAND);

		if (ItemHasChildren(hItem))
		{
			HTREEITEM hChildItem = GetChildItem(hItem);
			while (hChildItem != NULL)
			{
				ExpandRecursive(hChildItem);
				hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
			}
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::ExpandAll()
{
	HTREEITEM hItem = GetRootItem();
	while (hItem)
	{
		ExpandRecursive(hItem);
		hItem = GetNextItem(hItem, TVGN_NEXT);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::ExpandItem(void *pItem)
{
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		Expand(hItem, TVE_EXPAND);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::CollapseItem(void *pItem)
{
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		Expand(hItem, TVE_COLLAPSE);
	}
}


//-----------------------------------------------------------------------------
// Returns the HTREEITEM in the given subtree associated with the given
// item pointer, NULL if none.
//-----------------------------------------------------------------------------
HTREEITEM CTreeList::FindHTreeItemRecursive(HTREEITEM hItem, void *pItem)
{
	if (hItem)
	{
		void *pItemCheck = (void *)GetItemData(hItem);
		if (pItemCheck == pItem)
		{
			return hItem;
		}

		if (ItemHasChildren(hItem))
		{
			HTREEITEM hChildItem = GetChildItem(hItem);
			while (hChildItem != NULL)
			{
				HTREEITEM hFoundItem = FindHTreeItemRecursive(hChildItem, pItem);
				if (hFoundItem)
				{
					return hFoundItem;
				}

				hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
			}
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Returns the HTREEITEM associated with the given item pointer, NULL if none.
//-----------------------------------------------------------------------------
HTREEITEM CTreeList::FindHTreeItem(void *pItem)
{
	HTREEITEM hItem = GetRootItem();
	while (hItem)
	{
		HTREEITEM hFound = FindHTreeItemRecursive(hItem, pItem);
		if (hFound)
		{
			return hFound;
		}

		hItem = GetNextItem(hItem, TVGN_NEXT);
	}

	return NULL;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void *CTreeList::GetSelectedItem()
{
	HTREEITEM hItem = CTreeCtrl::GetSelectedItem();
	if (hItem)
	{
		return (void *)GetItemData(hItem);
	}

	return NULL;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CTreeList::GetSelectedIndex()
{
	int nItem = -1;

	void *pItem = GetSelectedItem();
	if ( pItem )
	{
		for ( int i = 0; i < m_Items.Count(); i++ )
		{
			if ( m_Items[i] == pItem )
			{
				nItem = i;
				break;
			}
		}
	}

	return nItem;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnLButtonDown(UINT nFlags, CPoint point) 
{
	unsigned int uFlags;
	HTREEITEM hItemHit = HitTest(point, &uFlags);
	if (hItemHit != NULL)
	{
		if (uFlags & TVHT_ONITEMSTATEICON)
		{
			// Don't forward to the base if they clicked on the check box.
			// This prevents undesired expansion/collapse of tree.
			return;
		}
	}

	CTreeCtrl::OnLButtonDown(nFlags, point);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnLButtonUp(UINT nFlags, CPoint point) 
{
	KillTimer(TIMER_GROUP_DRAG_SCROLL);
	ReleaseCapture();

	if (!m_hDragItem)
	{
		unsigned int uFlags;
		HTREEITEM hItemHit = HitTest(point, &uFlags);
		if (hItemHit != NULL)
		{
			if (uFlags & TVHT_ONITEMSTATEICON)
			{
				//
				// Notify our parent window that this item's state has changed.
				//
				CWnd *pwndParent = GetParent();
				if (pwndParent != NULL)
				{
					// TODO: might need a way to cycle through three states: on, off, grey
					int nCheckState = GetCheck(hItemHit);
					if (!nCheckState)
					{
						nCheckState = 1;
					}
					else
					{
						nCheckState = 0;
					}

					void *pItem = (void *)GetItemData(hItemHit);
					pwndParent->PostMessage(g_uToggleStateMsg, (WPARAM)pItem, nCheckState);
				}

				// Don't forward to the base if they clicked on the check box.
				// This prevents undesired expansion/collapse of tree.
				return;
			}
		}

		CTreeCtrl::OnLButtonUp(nFlags, point);
		return;
	}

	Drop(DROP_LEFT, nFlags, point);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	unsigned int uFlags;
	HTREEITEM hItemHit = HitTest(point, &uFlags);
	if (hItemHit != NULL)
	{
		if (uFlags & TVHT_ONITEMICON)
		{
			// Don't forward to the base if they clicked on the check box.
			// This prevents undesired expansion/collapse of tree.
			return;
		}
	}

	CTreeCtrl::OnLButtonDblClk(nFlags, point);
}


//-----------------------------------------------------------------------------
// Forwards selection change notifications to our parent window.
//		pNMHDR - 
//		pResult - 
//-----------------------------------------------------------------------------
void CTreeList::OnSelChange(NMHDR *pNMHDR, LRESULT *pResult)
{
	CWnd *pwndParent = GetParent();
	if (pwndParent != NULL)
	{
		pwndParent->PostMessage( g_uSelChangeMsg, (WPARAM)GetDlgCtrlID(), 0 );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnEndLabelEdit(NMHDR *pNMHDR, LRESULT *pResult) 
{
	NMTVDISPINFO *pInfo = (NMTVDISPINFO *)pNMHDR;
	if (!pInfo->item.pszText)
		return;

	void *pItem = (void *)GetItemData(pInfo->item.hItem);
	Assert(pItem);
	if (!pItem)
		return;

	OnRenameItem(pItem, pInfo->item.pszText);

	pResult[0] = TRUE;
}


//-----------------------------------------------------------------------------
// Begins dragging an item in the tree list. The drag image is
// created and anchored relative to the mouse cursor.
//		pNMHDR - 
//		pResult - 
//-----------------------------------------------------------------------------
void CTreeList::OnBegindrag(NMHDR *pNMHDR, LRESULT *pResult) 
{
	NMTREEVIEW *ptv = (NMTREEVIEW *)pNMHDR;
	BeginDrag(ptv->ptDrag, ptv->itemNew.hItem);
	*pResult = 0;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnKeyDown( NMHDR *pNMHDR, LRESULT *pResult )
{
	NMTVKEYDOWN *pKeyDown = (NMTVKEYDOWN *)pNMHDR;
	CWnd *pwndParent = GetParent();
	if (pwndParent != NULL)
	{
		pwndParent->PostMessage(g_uKeyDownMsg, (WPARAM)pKeyDown->wVKey, (LPARAM)pKeyDown->flags);
	}
	*pResult = 0;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::BeginDrag(CPoint point, HTREEITEM hItem) 
{
	m_hDragItem = hItem;
	if (m_hDragItem)
	{
		m_pDragImageList = CreateDragImage(m_hDragItem);
		if (m_pDragImageList)
		{
			CPoint ptHotSpot(0, 0);
			m_pDragImageList->BeginDrag(0, ptHotSpot);
			m_pDragImageList->DragEnter(this, point);
			SelectDropTarget(NULL);
		}

		// Timer handles scrolling the list control when dragging outside the window bounds.
		SetTimer(TIMER_GROUP_DRAG_SCROLL, 300, NULL);

		SetCapture();
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnRButtonDown(UINT nFlags, CPoint point)
{
	m_bRButtonDown = true;
	m_ptRButtonDown = point;
	m_hDragItem = NULL;
	SetCapture();

	// Chaining to the base class causes us never to receive the button up message
	// for a right click without drag, so we don't do that.
	//CTreeCtrl::OnRButtonDown(nFlags, point);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::OnContextMenu(CWnd *pWnd, CPoint point)
{
	KillTimer(TIMER_GROUP_DRAG_SCROLL);
	ReleaseCapture();

	m_bRButtonDown = false;

	if (!m_hDragItem)
	{
		// TODO: Need to invoke the correct context menu for this tree list. Currently no one uses this.
		CTreeCtrl::OnContextMenu(pWnd, point);
		return;
	}

	Drop(DROP_RIGHT, 0, point);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CTreeList::OnRButtonUp(UINT nFlags, CPoint point)
{
	KillTimer(TIMER_GROUP_DRAG_SCROLL);
	ReleaseCapture();

	m_bRButtonDown = false;

	if (!m_hDragItem)
	{
		CTreeCtrl::OnRButtonUp(nFlags, point);
		return;
	}

	Drop(DROP_RIGHT, nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : eDropType - 
//			nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CTreeList::Drop(DropType_t eDropType, UINT nFlags, CPoint point)
{
	SelectDropTarget(NULL);

	HTREEITEM hDragItem = m_hDragItem;
	m_hDragItem = NULL;

	//
	// We are dragging. Drop!
	//
	if (m_pDragImageList)
	{
		m_pDragImageList->DragLeave(this);
		m_pDragImageList->EndDrag();
		delete m_pDragImageList;
		m_pDragImageList = NULL;
	}

	//
	// Get the group that we were dragging.
	//
	void *pDragItem = (void *)GetItemData(hDragItem);

	//
	// Determine what group was dropped onto.
	//
	HTREEITEM hDropItem = HitTest(point);
	if (hDropItem == hDragItem)
	{
		return;
	}

	void *pDropItem = NULL;
	if (hDropItem)
	{
		pDropItem = (void *)GetItemData(hDropItem);
	}

	if (pDragItem == pDropItem)
	{
		// Shouldn't happen, but just in case.
		return;
	}

	CWnd *pwndParent = GetParent();
	if (pwndParent != NULL)
	{
		if (eDropType == DROP_LEFT)
		{
			pwndParent->PostMessage(g_uLeftDragDropMsg, (WPARAM)pDragItem, (LPARAM)pDropItem);
		}
		else
		{
			pwndParent->PostMessage(g_uRightDragDropMsg, (WPARAM)pDragItem, (LPARAM)pDropItem);
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nIDEvent - 
//-----------------------------------------------------------------------------
void CTreeList::OnTimer(UINT nIDEvent) 
{
	//DBG("OnTimer\n");
	switch (nIDEvent)
	{
		case TIMER_GROUP_DRAG_SCROLL:
		{
			CPoint point;
			GetCursorPos(&point);

			CRect rect;
			GetWindowRect(&rect);

			if (!rect.PtInRect(point))
			{
				if (point.y > rect.bottom)
				{
					// scroll down
					int nCount = GetVisibleCount();
					HTREEITEM hItem = GetFirstVisibleItem();
					for (int i = 1; i < nCount; i++)
					{
						hItem = GetNextVisibleItem(hItem);
					}

					hItem = GetNextVisibleItem(hItem);

					if (hItem)
					{
						CTreeCtrl::EnsureVisible(hItem);
					}
				}
				else if (point.y < rect.top)
				{
					HTREEITEM hItem = GetFirstVisibleItem();
					HTREEITEM hPrevVisible = this->GetPrevVisibleItem(hItem);
					if (hPrevVisible)
					{
						// scroll up
						CTreeCtrl::EnsureVisible(hPrevVisible);
					}
				}
			}

			break;
		}
	
		default:
		{
			CTreeCtrl::OnTimer(nIDEvent);
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CTreeList::OnMouseMove(UINT nFlags, CPoint point) 
{
	CTreeCtrl::OnMouseMove(nFlags, point);

	if (m_bRButtonDown && !m_hDragItem && (point.x != m_ptRButtonDown.x) && (point.y != m_ptRButtonDown.y))
	{
		// First mouse move since a right button down. Start dragging.
		HTREEITEM hItem = HitTest(m_ptRButtonDown);
		BeginDrag(point, hItem);
	}

	if (!m_hDragItem)
	{
		return;
	}

	if (m_pDragImageList)
	{
		m_pDragImageList->DragMove(point);
	}

	//
	// Highlight the item we hit.
	//
	HTREEITEM hItem = HitTest(point);
	if (hItem == GetDropHilightItem())
	{
		return;
	}

	// hide image first
	if (m_pDragImageList)
	{
		m_pDragImageList->DragLeave(this);
		m_pDragImageList->DragShowNolock(FALSE);
	}

	SelectDropTarget(hItem);

	if (m_pDragImageList)
	{
		m_pDragImageList->DragEnter(this, point);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTreeList::SelectItem(void *pItem)
{
	//DBG("SelectTreeListItem: %s\n", pVisGroup->GetName());
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		Select(hItem, TVGN_CARET);
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::SelectNearestItem( int nItem )
{
	if ( ( m_Items.Count() > 0 ) && ( m_Items.Count() <= nItem ) )
	{
		nItem = m_Items.Count() - 1;
	}
	
	if ( m_Items.IsValidIndex( nItem ) )
	{
		SelectItem( m_Items[nItem] );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::EnsureVisible( int nItem )
{
	if ( ( m_Items.Count() > 0 ) && ( m_Items.Count() <= nItem ) )
	{
		nItem = m_Items.Count() - 1;
	}
	
	if ( m_Items.IsValidIndex( nItem ) )
	{
		EnsureVisible( m_Items[nItem] );
	}
}


//-----------------------------------------------------------------------------
// Sets the check status for the given item.
//		pItem - 
//		nCheckState - 0=not checked, 1=checked, -1=gray check (undefined)
//-----------------------------------------------------------------------------
void CTreeList::SetCheck(void *pItem, int nCheckState)
{
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		UINT uState = INDEXTOSTATEIMAGEMASK(1);
		if (nCheckState == 1)
		{
			uState = INDEXTOSTATEIMAGEMASK(2);
		}
		else if (nCheckState != 0)
		{
			uState = INDEXTOSTATEIMAGEMASK(3);
		}

		SetItemState(hItem, uState, TVIS_STATEIMAGEMASK);
	}
}


//-----------------------------------------------------------------------------
// Returns the check state for the given item.
//-----------------------------------------------------------------------------
int CTreeList::GetCheck(void *pItem)
{
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		return GetCheck(hItem);
	}

	return 0;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CTreeList::GetCheck(HTREEITEM hItem)
{
	UINT uState = (GetItemState(hItem, TVIS_STATEIMAGEMASK) & TVIS_STATEIMAGEMASK);
	if (uState == INDEXTOSTATEIMAGEMASK(2))
	{
		return 1;
	}
	else if (uState == INDEXTOSTATEIMAGEMASK(1))
	{
		return 0;
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the number of visgroups in the whole tree.
//-----------------------------------------------------------------------------
int CTreeList::GetItemCount()
{
	return m_Items.Count();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void *CTreeList::GetItem(int nIndex)
{
	return m_Items.Element(nIndex);
}


//-----------------------------------------------------------------------------
// Updates the tree control item text with the new group name.
//-----------------------------------------------------------------------------
void CTreeList::UpdateItem(void *pItem, const char *pszText)
{
	HTREEITEM hItem = FindHTreeItem(pItem);
	if (hItem)
	{
		SetItemText(hItem, pszText);
	}
}


//-----------------------------------------------------------------------------
// Stores the expanded/collapsed state into a data member for retrieval later.
//-----------------------------------------------------------------------------
void CTreeList::SaveTreeListExpandStates()
{
	for ( int i = 0; i < GetItemCount(); i++ )
	{
		void *pItem = GetItem(i);
		TreeListItemState_t newState;
		for ( int j = 0; j < m_ItemState.Count(); j++ )
		{
			TreeListItemState_t thisPair = m_ItemState.Element( j );
			if ( pItem == thisPair.pItem )
			{
				m_ItemState.Remove( j );
				break;
			}
		}

		HTREEITEM hItem = FindHTreeItem( pItem );
		newState.pItem = pItem;
		newState.bExpanded = false;
		if ( hItem && (GetItemState( hItem, TVIS_EXPANDED) & TVIS_EXPANDED) )
		{
			newState.bExpanded = true;
		}
		m_ItemState.AddToTail( newState );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CTreeList::RestoreTreeListExpandStates()
{
	ExpandAll();
	for ( int i = 0; i < m_ItemState.Count(); i++ )
	{
		TreeListItemState_t thisPair = m_ItemState.Element( i );
		HTREEITEM thisItem = FindHTreeItem( thisPair.pItem );
		if ( thisItem )
		{
			if ( thisPair.bExpanded )
			{
				Expand(thisItem, TVE_EXPAND);
			}
			else
			{
				Expand( thisItem, TVE_COLLAPSE );				
			}
		}
	}
}