source-engine/hammer/grouplist.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements a list view for visgroups. Supports drag and drop, and
//			posts a registered windows message to the list view's parent window
//			when visgroups are hidden or shown.
//
//=============================================================================//

#include "stdafx.h"
#include "hammer.h"
#include "GroupList.h"
#include "MapDoc.h"
#include "MapSolid.h"
#include "MapWorld.h"
#include "GlobalFunctions.h"
#include "VisGroup.h"

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

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


static const unsigned int g_uToggleStateMsg = ::RegisterWindowMessage(GROUPLIST_MSG_TOGGLE_STATE);
static const unsigned int g_uLeftDragDropMsg = ::RegisterWindowMessage(GROUPLIST_MSG_LEFT_DRAG_DROP);
static const unsigned int g_uRightDragDropMsg = ::RegisterWindowMessage(GROUPLIST_MSG_RIGHT_DRAG_DROP);
static const unsigned int g_uSelChangeMsg = ::RegisterWindowMessage(GROUPLIST_MSG_SEL_CHANGE);


BEGIN_MESSAGE_MAP(CGroupList, CTreeCtrl)
	//{{AFX_MSG_MAP(CGroupList)
	ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnBegindrag)
	ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, OnEndlabeledit)
	ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelChange)
	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()


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CGroupList::CGroupList(void)
{
	m_pDragImageList = NULL;
	m_hDragItem = NULL;
	m_bRButtonDown = false;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CGroupList::~CGroupList(void)
{
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGroupList::EnableChecks(void)
{
	if (!m_cNormalImageList.GetSafeHandle())
	{
		m_cNormalImageList.Create(IDB_VISGROUPSTATUS, 16, 1, RGB(255, 255, 255));
		m_cNormalImageList.SetOverlayImage(1, 1);
		m_cNormalImageList.SetOverlayImage(2, 2);
	}

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


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pVisGroup - 
//			hItemParent - 
//-----------------------------------------------------------------------------
void CGroupList::AddVisGroupRecursive(CVisGroup *pVisGroup, HTREEITEM hItemParent)
{
	HTREEITEM hItem = InsertItem(pVisGroup->GetName(), hItemParent, TVI_LAST);
	if (hItem != NULL)
	{
		SetItemData(hItem, (DWORD)pVisGroup);

		// Add the item to our flattened list.
//		VisGroupTreeItem_t item;
//		item.pVisGroup = pVisGroup;
//		item.hItem = hItem;
//		m_TreeItems.AddToTail(item);
		m_VisGroups.AddToTail(pVisGroup);
		
		int nCount = pVisGroup->GetChildCount();
		for (int i = 0; i < nCount; i++)
		{
			CVisGroup *pChild = pVisGroup->GetChild(i);
			AddVisGroupRecursive(pChild, hItem);
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pGroup - 
//-----------------------------------------------------------------------------
void CGroupList::AddVisGroup(CVisGroup *pGroup)
{
	AddVisGroupRecursive(pGroup, TVI_ROOT);
}


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


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


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGroupList::EnsureVisible(CVisGroup *pVisGroup)
{
	//DBG("EnsureVisible: %s\n", pVisGroup->GetName());
	HTREEITEM hItem = FindVisGroupItem(pVisGroup);
	if (hItem)
	{
		CTreeCtrl::EnsureVisible(hItem);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGroupList::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);
			}
		}
	}
}


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


//-----------------------------------------------------------------------------
// Purpose: Returns the tree item in the given subtree associated with the given
//			visgroup, NULL if none.
//-----------------------------------------------------------------------------
HTREEITEM CGroupList::FindVisGroupItemRecursive(HTREEITEM hItem, CVisGroup *pVisGroup)
{
	if (hItem)
	{
		CVisGroup *pVisGroupCheck = (CVisGroup *)GetItemData(hItem);
		if (pVisGroupCheck == pVisGroup)
		{
			return hItem;
		}

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

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

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the tree item associated with the given visgroup, NULL if none.
//-----------------------------------------------------------------------------
HTREEITEM CGroupList::FindVisGroupItem(CVisGroup *pVisGroup)
{
	HTREEITEM hItem = GetRootItem();
	while (hItem)
	{
		HTREEITEM hFound = FindVisGroupItemRecursive(hItem, pVisGroup);
		if (hFound)
		{
			return hFound;
		}

		hItem = GetNextItem(hItem, TVGN_NEXT);
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the currently selected visgroup in the tree control.
//-----------------------------------------------------------------------------
CVisGroup *CGroupList::GetSelectedVisGroup(void)
{
	HTREEITEM hItem = GetSelectedItem();
	if (hItem)
	{
		return (CVisGroup *)GetItemData(hItem);
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CGroupList::OnLButtonDown(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::OnLButtonDown(nFlags, point);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CGroupList::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_ONITEMICON)
			{
				//
				// Notify our parent window that this item's state has changed.
				//
				CWnd *pwndParent = GetParent();
				if (pwndParent != NULL)
				{
					int nCheckState = GetCheck(hItemHit);
					if (!nCheckState)
					{
						nCheckState = 1;
					}
					else
					{
						nCheckState = 0;
					}

					CVisGroup *pGroup = (CVisGroup *)GetItemData(hItemHit);
					pwndParent->PostMessage(g_uToggleStateMsg, (WPARAM)pGroup, 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);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CGroupList::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);
}


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


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

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

	pVisGroup->SetName(pInfo->item.pszText);
	pResult[0] = TRUE;
}


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


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pt - 
//			hItem - 
//-----------------------------------------------------------------------------
void CGroupList::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();
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CGroupList::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);
}


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

	m_bRButtonDown = false;

	if (!m_hDragItem)
	{
		CTreeCtrl::OnContextMenu(pWnd, point);
		return;
	}

	Drop(DROP_RIGHT, 0, point);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nFlags - 
//			point - 
//-----------------------------------------------------------------------------
void CGroupList::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 CGroupList::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.
	//
	CVisGroup *pDragGroup = (CVisGroup *)GetItemData(hDragItem);

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

	CVisGroup *pDropGroup = NULL;
	if (hDropItem)
	{
		pDropGroup = (CVisGroup *)GetItemData(hDropItem);
	}

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

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


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : nIDEvent - 
//-----------------------------------------------------------------------------
void CGroupList::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 CGroupList::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 CGroupList::SelectVisGroup(CVisGroup *pVisGroup)
{
	//DBG("SelectVisGroup: %s\n", pVisGroup->GetName());
	HTREEITEM hItem = FindVisGroupItem(pVisGroup);
	if (hItem)
	{
		Select(hItem, TVGN_CARET);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sets the check status for the given group.
// Input  : pVisGroup - 
//			nCheckState - 0=not checked, 1=checked, -1=gray check (undefined)
//-----------------------------------------------------------------------------
void CGroupList::SetCheck(CVisGroup *pVisGroup, int nCheckState)
{
	HTREEITEM hItem = FindVisGroupItem(pVisGroup);
	if (hItem)
	{
		UINT uState = INDEXTOOVERLAYMASK(0);
		if (nCheckState == 1)
		{
			uState = INDEXTOOVERLAYMASK(1);
		}
		else if (nCheckState != 0)
		{
			uState = INDEXTOOVERLAYMASK(2);
		}

		SetItemState(hItem, uState, TVIS_OVERLAYMASK);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Returns the check state for the given visgroup.
// Input  : pVisGroup - 
//-----------------------------------------------------------------------------
int CGroupList::GetCheck(CVisGroup *pVisGroup)
{
	HTREEITEM hItem = FindVisGroupItem(pVisGroup);
	if (hItem)
	{
		return GetCheck(hItem);
	}

	return 0;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CGroupList::GetCheck(HTREEITEM hItem)
{
	UINT uState = (GetItemState(hItem, TVIS_OVERLAYMASK) & TVIS_OVERLAYMASK);
	if (uState == INDEXTOOVERLAYMASK(1))
	{
		return 1;
	}
	else if (uState == INDEXTOOVERLAYMASK(0))
	{
		return 0;
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Purpose: Returns the number of visgroups in the whole tree.
//-----------------------------------------------------------------------------
int CGroupList::GetVisGroupCount()
{
	return m_VisGroups.Count();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CVisGroup *CGroupList::GetVisGroup(int nIndex)
{
	return m_VisGroups.Element(nIndex);
}


//-----------------------------------------------------------------------------
// Purpose: Updates the tree control item text with the new group name.
//-----------------------------------------------------------------------------
void CGroupList::UpdateVisGroup(CVisGroup *pVisGroup)
{
	HTREEITEM hItem = FindVisGroupItem(pVisGroup);
	if (hItem)
	{
		SetItemText(hItem, pVisGroup->GetName());
	}
}

int CGroupList::GetGroupPairCount(void)
{
	return m_GroupPairs.Count();
}

void CGroupList::SaveVisGroupExpandStates()
{
	for ( int i = 0; i < GetVisGroupCount(); i++ )
	{
		CVisGroup *thisGroup = GetVisGroup(i);
		GroupListPair newPair;
		for ( int j = 0; j < GetGroupPairCount(); j++ )
		{
			GroupListPair thisPair = m_GroupPairs.Element( j );
			if ( thisGroup == thisPair.pVisGroup )
			{
				m_GroupPairs.Remove( j );
				break;
			}
		}

		HTREEITEM thisItem = FindVisGroupItem( thisGroup );
		newPair.pVisGroup = thisGroup;
		newPair.bExpanded = false;
		if ( thisItem && (GetItemState( thisItem, TVIS_EXPANDED) & TVIS_EXPANDED) )
		{
			newPair.bExpanded = true;
		}
		m_GroupPairs.AddToTail( newPair );
	}
}

void CGroupList::RestoreVisGroupExpandStates()
{
	ExpandAll();
	for ( int i = 0; i <  GetGroupPairCount(); i++ )
	{
		GroupListPair thisPair = m_GroupPairs.Element( i );
		HTREEITEM thisItem = FindVisGroupItem( thisPair.pVisGroup );
		if ( thisItem )
		{
			if ( thisPair.bExpanded )
			{
				Expand(thisItem, TVE_EXPAND);
			}
			else
			{
				Expand( thisItem, TVE_COLLAPSE );				
			}
		}
	}
}