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