Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

845 lines
20 KiB

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