able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/activec/conui/treectrl.cpp

2178 lines
61 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// TreeCtrl.cpp : implementation file
//
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1999
//
// File: amctreectrl.cpp
//
// Contents: AMC Tree control implementation
//
// History: 16-Jul-96 WayneSc Created
//
//
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "AMCDoc.h" // AMC Console Document
#include "amcview.h"
#include "childfrm.h"
#include "macros.h"
#include "AMCPriv.h"
#include "AMC.h"
#include "mainfrm.h"
#include "TreeCtrl.h"
#include "resource.h"
#include "guidhelp.h" // LoadRootDisplayName
#include "histlist.h"
#include "websnk.h"
#include "webctrl.h"
#include "..\inc\mmcutil.h"
#include "amcmsgid.h"
#include "resultview.h"
#include "eventlock.h"
extern "C" UINT dbg_count;
//############################################################################
//############################################################################
//
// Traces
//
//############################################################################
//############################################################################
#ifdef DBG
CTraceTag tagTree(TEXT("Tree View"), TEXT("Tree View"));
#endif //DBG
//############################################################################
//############################################################################
//
// Implementation of class CTreeViewMap
//
//############################################################################
//############################################################################
/*+-------------------------------------------------------------------------*
*
* CTreeViewMap::ScOnItemAdded
*
* PURPOSE: Called when an item is added. Indexes the item.
*
* PARAMETERS:
* TVINSERTSTRUCT * pTVInsertStruct :
* HTREEITEM hti :
* HMTNODE hMTNode :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CTreeViewMap::ScOnItemAdded (TVINSERTSTRUCT *pTVInsertStruct, HTREEITEM hti, HMTNODE hMTNode)
{
DECLARE_SC(sc, TEXT("CTreeViewMap::ScOnItemAdded"));
// validate parameters
sc = ScCheckPointers(pTVInsertStruct);
if(sc)
return sc;
if(!hti || !hMTNode)
return (sc = E_INVALIDARG);
// create a new map info structure.
TreeViewMapInfo *pMapInfo = new TreeViewMapInfo;
if(!pMapInfo)
return (sc = E_OUTOFMEMORY);
// fill in the values
pMapInfo->hNode = CAMCTreeView::NodeFromLParam (pTVInsertStruct->item.lParam);
pMapInfo->hti = hti;
pMapInfo->hMTNode = hMTNode;
// set up the indexes
ASSERT(m_hMTNodeMap.find(pMapInfo->hMTNode) == m_hMTNodeMap.end());
ASSERT(m_hNodeMap.find(pMapInfo->hNode) == m_hNodeMap.end());
m_hMTNodeMap [pMapInfo->hMTNode] = pMapInfo;
m_hNodeMap [pMapInfo->hNode] = pMapInfo;
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CTreeViewMap::ScOnItemDeleted
*
* PURPOSE: Called when a tree item is deleted. Removes the item from the
* indexes.
*
* PARAMETERS:
* HNODE hNode :
* HTREEITEM hti :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CTreeViewMap::ScOnItemDeleted (HNODE hNode, HTREEITEM hti)
{
DECLARE_SC(sc, TEXT("CTreeViewMap::ScOnItemDeleted"));
// validate parameters
sc = ScCheckPointers((LPVOID) hNode, (LPVOID) hti);
if(sc)
return sc;
// remove the TreeViewMapInfo pointer from all the maps
HNodeLookupMap::iterator iter = m_hNodeMap.find(hNode);
if(iter == m_hNodeMap.end())
return (sc = E_UNEXPECTED);
TreeViewMapInfo *pMapInfo = iter->second; // find the map info structure.
if(!pMapInfo)
return (sc = E_UNEXPECTED);
HMTNODE hMTNode = pMapInfo->hMTNode;
#ifdef DBG
// verify that the same structure is pointed to by the other maps.
ASSERT(m_hMTNodeMap.find(hMTNode)->second == pMapInfo);
#endif
m_hMTNodeMap.erase(hMTNode);
m_hNodeMap.erase(hNode);
// finally delete the TreeViewMapInfo structure
delete pMapInfo;
return sc;
}
// Fast lookup methods
/*+-------------------------------------------------------------------------*
*
* CTreeViewMap::ScGetHNodeFromHMTNode
*
* PURPOSE: Quickly (log n time) retrieves the HNODE for an HMTNODE.
*
* PARAMETERS:
* HMTNODE hMTNode :
* ou t :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CTreeViewMap::ScGetHNodeFromHMTNode (HMTNODE hMTNode, /*out*/ HNODE* phNode) // fast conversion from hNode to hMTNode.
{
DECLARE_SC(sc, TEXT("CTreeViewMap::ScGetHNode"));
// validate parameters
sc = ScCheckPointers((LPVOID) hMTNode, phNode);
if(sc)
return sc;
// find the mapinfo structure.
HMTNodeLookupMap::iterator iter = m_hMTNodeMap.find(hMTNode);
if(iter == m_hMTNodeMap.end())
return (sc = ScFromMMC(IDS_NODE_NOT_FOUND));
TreeViewMapInfo *pMapInfo = iter->second; // find the map info structure.
if(!pMapInfo)
return (sc = E_UNEXPECTED);
*phNode = pMapInfo->hNode;
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CTreeViewMap::ScGetHTreeItemFromHNode
*
* PURPOSE: Quickly (log n time) retrieves the HTREEITEM for an HNODE.
*
* PARAMETERS:
* HNODE hNode :
* ou t :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CTreeViewMap::ScGetHTreeItemFromHNode(HNODE hNode, /*out*/ HTREEITEM* phti) // fast conversion from HTREEITEM to HNODE
{
DECLARE_SC(sc, TEXT("CTreeViewMap::ScGetHTreeItem"));
// validate parameters
sc = ScCheckPointers((LPVOID) hNode, phti);
if(sc)
return sc;
// find the mapinfo structure.
HNodeLookupMap::iterator iter = m_hNodeMap.find(hNode);
if(iter == m_hNodeMap.end())
return (sc = E_UNEXPECTED);
TreeViewMapInfo *pMapInfo = iter->second; // find the map info structure.
if(!pMapInfo)
return (sc = E_UNEXPECTED);
*phti = pMapInfo->hti;
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CTreeViewMap::ScGetHTreeItemFromHMTNode
*
* PURPOSE: Quickly (log n time) retrieves the HTREEITEM for an HMTNODE.
*
* PARAMETERS:
* HMTNODE hMTNode :
* ou t :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CTreeViewMap::ScGetHTreeItemFromHMTNode(HMTNODE hMTNode, /*out*/ HTREEITEM* phti) // fast conversion from HMTNode to HTREEITEM.
{
DECLARE_SC(sc, TEXT("CTreeViewMap::ScGetHTreeItem"));
// validate parameters
//sc = ScCheckPointers(hMTNode, phti);
if(sc)
return sc;
// find the mapinfo structure.
HMTNodeLookupMap::iterator iter = m_hMTNodeMap.find(hMTNode);
if(iter == m_hMTNodeMap.end())
return (sc = E_UNEXPECTED);
TreeViewMapInfo *pMapInfo = iter->second; // find the map info structure.
if(!pMapInfo)
return (sc = E_UNEXPECTED);
*phti = pMapInfo->hti;
return sc;
}
//############################################################################
//############################################################################
//
// Implementation of class CAMCTreeView
//
//############################################################################
//############################################################################
/////////////////////////////////////////////////////////////////////////////
// CAMCTreeView
DEBUG_DECLARE_INSTANCE_COUNTER(CAMCTreeView);
CAMCTreeView::CAMCTreeView()
: m_FontLinker (this)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CAMCTreeView);
m_fInCleanUp = FALSE;
m_fInExpanding = FALSE;
m_pAMCView = NULL;
SetHasList(TRUE);
SetTempSelectedItem (NULL);
ASSERT (!IsTempSelectionActive());
AddObserver(static_cast<CTreeViewObserver&>(m_treeMap)); // add an observer to this control.
}
CAMCTreeView::~CAMCTreeView()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(CAMCTreeView);
// Smart pointer are released during their destructor
}
IMPLEMENT_DYNCREATE(CAMCTreeView, CTreeView)
BEGIN_MESSAGE_MAP(CAMCTreeView, CTreeView)
//{{AFX_MSG_MAP(CAMCTreeView)
ON_WM_CREATE()
ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelChanged)
ON_NOTIFY_REFLECT(TVN_SELCHANGING, OnSelChanging)
ON_NOTIFY_REFLECT(TVN_GETDISPINFO, OnGetDispInfo)
ON_NOTIFY_REFLECT(TVN_ITEMEXPANDING, OnItemExpanding)
ON_NOTIFY_REFLECT(TVN_ITEMEXPANDED, OnItemExpanded)
ON_WM_DESTROY()
ON_WM_KEYDOWN()
ON_WM_SYSKEYDOWN()
ON_WM_SYSCHAR()
ON_WM_MOUSEACTIVATE()
ON_WM_SETFOCUS()
ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnBeginDrag)
ON_NOTIFY_REFLECT(TVN_BEGINRDRAG, OnBeginRDrag)
ON_WM_KILLFOCUS()
//}}AFX_MSG_MAP
ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
END_MESSAGE_MAP()
/*+-------------------------------------------------------------------------*
* CAMCTreeView::ScSetTempSelection
*
* Applies temporary selection to the specified HTREEITEM.
*--------------------------------------------------------------------------*/
SC CAMCTreeView::ScSetTempSelection (HTREEITEM htiTempSelect)
{
AFX_MANAGE_STATE (AfxGetAppModuleState());
DECLARE_SC (sc, _T("CAMCTreeView::ScSetTempSelection"));
/*
* Don't use ScSetTempSelection(NULL) to remove temporary selection;
* use ScRemoveTempSelection instead.
*/
ASSERT (htiTempSelect != NULL);
if (htiTempSelect == NULL)
return (sc = E_FAIL);
/*
* If this fails, you must first call ScRemoveTempSelection to remove
* the temporary selection state (TVIS_SELECTED) from the current
* temporary selection.
*/
ASSERT (!IsTempSelectionActive());
SetTempSelectedItem (htiTempSelect);
ASSERT (GetTempSelectedItem() == htiTempSelect);
HTREEITEM htiSelected = GetSelectedItem();
if (htiSelected != htiTempSelect)
{
SetItemState (htiSelected, 0, TVIS_SELECTED);
SetItemState (htiTempSelect, TVIS_SELECTED, TVIS_SELECTED);
}
ASSERT (IsTempSelectionActive());
return (sc);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::ScRemoveTempSelection
*
* Removes the temporary selection from the current temporarily selected
* item, if there is one, and restores it to the item that was selected
* when the temp selection was applied.
*--------------------------------------------------------------------------*/
SC CAMCTreeView::ScRemoveTempSelection ()
{
AFX_MANAGE_STATE (AfxGetAppModuleState());
DECLARE_SC (sc, _T("CAMCTreeView::ScRemoveTempSelection"));
if (!IsTempSelectionActive())
return (sc = S_FALSE);
HTREEITEM htiTempSelect = GetTempSelectedItem();
HTREEITEM htiSelected = GetSelectedItem();
if (htiTempSelect != htiSelected)
{
SetItemState (htiTempSelect, 0, TVIS_SELECTED);
SetItemState (htiSelected, TVIS_SELECTED, TVIS_SELECTED);
}
SetTempSelectedItem (NULL);
ASSERT (!IsTempSelectionActive());
return (sc);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::ScReselect
*
*
*--------------------------------------------------------------------------*/
SC CAMCTreeView::ScReselect ()
{
AFX_MANAGE_STATE (AfxGetAppModuleState());
NM_TREEVIEW nmtv;
nmtv.itemOld.hItem = nmtv.itemNew.hItem = GetSelectedItem();
if (nmtv.itemOld.hItem)
{
nmtv.itemOld.lParam = nmtv.itemNew.lParam = GetItemData(nmtv.itemOld.hItem);
LRESULT lUnused;
OnSelChangingWorker (&nmtv, &lUnused);
OnSelChangedWorker (&nmtv, &lUnused);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
// CAMCTreeView message handlers
BOOL CAMCTreeView::PreCreateWindow(CREATESTRUCT& cs)
{
cs.style |= TVS_EDITLABELS | TVS_HASBUTTONS | TVS_HASLINES | TVS_SHOWSELALWAYS;
cs.dwExStyle |= WS_EX_CLIENTEDGE;
// do not paint over the children
cs.style |= WS_CLIPCHILDREN;
return CTreeView::PreCreateWindow(cs);
}
INodeCallback* CAMCTreeView::GetNodeCallback()
{
return m_pAMCView->GetNodeCallback();
}
inline IScopeTreeIter* CAMCTreeView::GetScopeIterator()
{
return m_pAMCView->GetScopeIterator();
}
inline IScopeTree* CAMCTreeView::GetScopeTree()
{
return m_pAMCView->GetScopeTree();
}
void CAMCTreeView::OnGetDispInfo(NMHDR* pNMHDR, LRESULT* pResult)
{
HRESULT hr;
TV_DISPINFO* ptvdi = (TV_DISPINFO*)pNMHDR;
HNODE hNode = NodeFromLParam (ptvdi->item.lParam);
ASSERT(m_pAMCView != NULL);
INodeCallback* spCallback = GetNodeCallback();
ASSERT(spCallback != NULL);
if (hNode)
{
if (ptvdi->item.mask & TVIF_TEXT)
{
tstring strName;
hr = spCallback->GetDisplayName(hNode, strName);
if (hr != S_OK)
{
ptvdi->item.pszText[0] = _T('\0');
ASSERT(FALSE);
}
else
{
// copy the text, but not too much
ASSERT (!IsBadWritePtr (ptvdi->item.pszText, ptvdi->item.cchTextMax));
_tcsncpy (ptvdi->item.pszText, strName.data(), ptvdi->item.cchTextMax);
/*
* _tcsncpy won't terminate the destination if the
* source is bigger than the buffer; make sure the
* string is NULL-terminated
*/
ptvdi->item.pszText[ptvdi->item.cchTextMax-1] = _T('\0');
/*
* If this is the selected item and it's text has changed,
* fire an event so observers can know.
*/
if ((m_strSelectedItemText != strName.data()) &&
(GetSelectedItem() == ptvdi->item.hItem))
{
m_strSelectedItemText = strName.data();
SC sc = ScFireEvent (CTreeViewObserver::ScOnSelectedItemTextChanged,
(LPCTSTR) m_strSelectedItemText);
if (sc)
sc.TraceAndClear();
}
}
}
int nImage, nSelectedImage;
hr = spCallback->GetImages(hNode, &nImage, &nSelectedImage);
#ifdef DBG
if (hr != S_OK)
{
ASSERT(nImage == 0 && nSelectedImage == 0);
}
#endif
if (ptvdi->item.mask & TVIF_IMAGE)
ptvdi->item.iImage = nImage;
if (ptvdi->item.mask & TVIF_SELECTEDIMAGE)
ptvdi->item.iSelectedImage = nSelectedImage;
// We will get this request once, the first time the scope item comes into view
if (ptvdi->item.mask & TVIF_CHILDREN)
{
ptvdi->item.cChildren = (spCallback->IsExpandable(hNode) != S_FALSE);
// set children to fixed value, to avoid any more callbacks
SetCountOfChildren(ptvdi->item.hItem, ptvdi->item.cChildren);
}
}
else
{
ASSERT(0 && "OnGetDispInfo(HNODE is NULL)");
}
*pResult = 0;
}
//
// Description: This method will set the folders Button(+/-) on or
// of depending on the value of bState
//
// Parameters:
// hItem: the tree item affected
// bState: TRUE = Enable for folder to show it has children
// FALSE = Disable for folder to show it has NO children
//
void CAMCTreeView::SetButton(HTREEITEM hItem, BOOL bState)
{
ASSERT(hItem != NULL);
TV_ITEM item;
ZeroMemory(&item, sizeof(item));
item.hItem = hItem;
item.mask = TVIF_HANDLE | TVIF_CHILDREN;
item.cChildren = bState;
SetItem(&item);
}
//
// Description: This method will populate hItem's(parent folder) children into
// the tree control.
//
// Parameters:
// hItem: the parent
//
BOOL CAMCTreeView::ExpandNode(HTREEITEM hItem)
{
TRACE_METHOD(CAMCTreeView, ExpandNode);
// not frequently, but... snap-in will display the dialog, dismissing that will
// activate the frame again. Tree item will be automatically selected if there
// is none selected yet. Following will prevent the recursion.
if (m_fInExpanding)
return FALSE;
HRESULT hr;
// Get the HNODE from the tree node
HNODE hNode = GetItemNode(hItem);
ASSERT(hNode != NULL);
ASSERT(m_pAMCView != NULL);
HMTNODE hMTNode;
INodeCallback* spCallback = GetNodeCallback();
ASSERT(spCallback != NULL);
hr = spCallback->GetMTNode(hNode, &hMTNode);
ASSERT(hr == S_OK);
if (hr == S_OK)
{
// The notify will return S_FALSE to indicate already expanded
// or E_xxxx to indicate an error.
hr = spCallback->Notify(hNode, NCLBK_EXPAND, FALSE, 0);
if (hr == S_FALSE)
{
__try
{
m_fInExpanding = TRUE;
hr = spCallback->Notify(hNode, NCLBK_EXPAND, TRUE, 0);
}
__finally
{
m_fInExpanding = FALSE;
}
if (SUCCEEDED(hr))
{
IScopeTreeIter* spIterator = m_pAMCView->GetScopeIterator();
hr = spIterator->SetCurrent(hMTNode);
HMTNODE hMTChildNode;
// Get the child for the current iterator node and add
// them to this tree
if (spIterator->Child(&hMTChildNode) == S_OK)
{
IScopeTree* spScopeTree = m_pAMCView->GetScopeTree();
HNODE hNewNode;
unsigned int nFetched = 0;
if (spIterator->SetCurrent(hMTChildNode) == S_OK)
{
HMTNODE hCurrentChildNode = hMTChildNode;
do
{
// Get the children and convert them to HNODEs
// and add them to the tree
hr = spIterator->Next(1, &hCurrentChildNode,
&nFetched);
if (hr != S_OK || nFetched <= 0)
break;
// Insert node into the tree control
spScopeTree->CreateNode(hCurrentChildNode,
reinterpret_cast<LONG_PTR>(m_pAMCView->GetViewData()),
FALSE, &hNewNode);
#include "pushwarn.h"
#pragma warning(disable: 4552) // "!=" operator has no effect
VERIFY(InsertNode(hItem, hNewNode) != NULL);
#include "popwarn.h"
// give 'em a chance to do the "preload" thing, if applicable
spCallback->PreLoad (hNewNode);
} while (1);
}
}
spCallback->Notify(hNode, NCLBK_EXPANDED, 0, 0);
}
}
}
return SUCCEEDED(hr);
}
HTREEITEM CAMCTreeView::InsertNode(HTREEITEM hParent, HNODE hNode,
HTREEITEM hInsertAfter)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::InsertNode"));
ASSERT(hParent != NULL);
ASSERT(hNode != NULL);
HRESULT hr;
TV_INSERTSTRUCT tvInsertStruct;
TV_ITEM& item = tvInsertStruct.item;
ZeroMemory(&tvInsertStruct, sizeof(tvInsertStruct));
// Insert item at the end of the hItem chain
tvInsertStruct.hParent = hParent;
tvInsertStruct.hInsertAfter = hInsertAfter;
item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN |
TVIF_PARAM | TVIF_TEXT;
item.pszText = LPSTR_TEXTCALLBACK;
item.lParam = LParamFromNode (hNode);
INodeCallback* spCallback = GetNodeCallback();
ASSERT(spCallback != NULL);
// Set callback mode for children, so we don't have to determine this
// until the scope item becomes visible (it can be expensive).
item.cChildren = I_CHILDRENCALLBACK;
spCallback->GetImages(hNode, &item.iImage, &item.iSelectedImage);
HTREEITEM hti = InsertItem(&tvInsertStruct);
HMTNODE hMTNode = NULL;
sc = spCallback->GetMTNode(hNode, &hMTNode);
if(sc)
sc.TraceAndClear();
// send an event to all interested observers
sc = ScFireEvent(CTreeViewObserver::ScOnItemAdded, &tvInsertStruct, hti, hMTNode);
if(sc)
sc.TraceAndClear();
if (hParent != TVI_ROOT && hti != NULL)
SetCountOfChildren(hParent, 1);
return hti;
}
void CAMCTreeView::ResetNode(HTREEITEM hItem)
{
if (hItem == NULL)
return;
TV_ITEM item;
ZeroMemory(&item, sizeof(item));
item.hItem = hItem;
item.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_PARAM | TVIF_SELECTEDIMAGE |
TVIF_STATE | TVIF_TEXT | TVIF_CHILDREN;
item.pszText = LPSTR_TEXTCALLBACK;
item.iImage = I_IMAGECALLBACK;
item.iSelectedImage = I_IMAGECALLBACK;
item.cChildren = I_CHILDRENCALLBACK;
item.lParam = GetItemData(hItem);
SetItem(&item);
}
void CAMCTreeView::OnItemExpanding(NMHDR* pNMHDR, LRESULT* pResult)
{
TRACE_METHOD(CAMCTreeView, OnItemExpanding);
HRESULT hr;
NM_TREEVIEW* pNotify = (NM_TREEVIEW*)pNMHDR;
ASSERT(pNotify != NULL);
HTREEITEM &hItem = pNotify->itemNew.hItem;
ASSERT(hItem != NULL);
BOOL bExpand = FALSE;
// Iteratate the folders below this item
if (pNotify->action == TVE_EXPAND)
{
/*
* Bug 333971: Node expansion might take awhile. Supply a wait cursor
* for all of the UI-challenged snap-ins out there.
*/
SetCursor (LoadCursor (NULL, IDC_WAIT));
ExpandNode(hItem);
bExpand = TRUE;
/*
* return the arrow
*/
SetCursor (LoadCursor (NULL, IDC_ARROW));
}
INodeCallback* pCallback = GetNodeCallback();
ASSERT(pCallback != NULL);
HNODE hNode = GetItemNode (hItem);
pCallback->Notify(hNode, NCLBK_SETEXPANDEDVISUALLY, bExpand, 0);
// If item has no children remove the + sign
if (GetChildItem(hItem) == NULL)
SetButton(hItem, FALSE);
*pResult = 0;
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnItemExpanded
*
* TVN_ITEMEXPANDED handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnItemExpanded(NMHDR* pNMHDR, LRESULT* pResult)
{
DECLARE_SC (sc, _T("CAMCTreeView::OnItemExpanded"));
NM_TREEVIEW* pnmtv = (NM_TREEVIEW*)pNMHDR;
sc = ScCheckPointers (pnmtv);
if (sc)
return;
/*
* Bug 23153: when collapsing, totally collapse the tree beneath the
* collapsing item. We do this in OnItemExpanded rather than
* OnItemExpanding so we won't see the collapse happen.
*/
if (pnmtv->action == TVE_COLLAPSE)
{
CWaitCursor wait;
CollapseChildren (pnmtv->itemNew.hItem);
}
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::CollapseChildren
*
* Collapses each descendent node of htiParent.
*--------------------------------------------------------------------------*/
void CAMCTreeView::CollapseChildren (HTREEITEM htiParent)
{
HTREEITEM htiChild;
for (htiChild = GetChildItem (htiParent);
htiChild != NULL;
htiChild = GetNextItem (htiChild, TVGN_NEXT))
{
Expand (htiChild, TVE_COLLAPSE);
CollapseChildren (htiChild);
}
}
void CAMCTreeView::OnDeSelectNode(HNODE hNode)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::OnDeSelectNode"));
{
// tell all interested observers about the deselection.
// NOTE: the order is important - legacy snapins believe they can access the
// result pane at this point and have the items still there.
// But this is intermediate state, so Com events are locked out until the
// results are cleared.
// see windows bug (ntbug09) bug# 198660. (10/11/00)
LockComEventInterface(AppEvents);
sc = ScFireEvent(CTreeViewObserver::ScOnItemDeselected, hNode);
if(sc)
return;
// Ensure the result view is clean.
if (HasList())
{
// First findout if the result view is properly
// set in the nodemgr by asking IFramePrivate.
IFramePrivatePtr spFrame = m_spResultData;
if (NULL != spFrame)
{
BOOL bIsResultViewSet = FALSE;
sc = spFrame->IsResultViewSet(&bIsResultViewSet);
// The result view is set, clean it up.
if (bIsResultViewSet)
{
m_spResultData->DeleteAllRsltItems();
m_spResultData->ResetResultData();
}
}
}
}
// don't have a valid result pane type anymore.
SetHasList(false);
}
// Note that OnSelectNode will return S_FALSE if the snap-in changes
// the selection during the process of selecting the requested node.
// A caller that gets an S_FALSE should assume that a different node
// is selected and continue accordingly.
HRESULT CAMCTreeView::OnSelectNode(HTREEITEM hItem, HNODE hNode)
{
DECLARE_SC(sc, _T("CAMCTreeView::OnSelectNode"));
if (!hItem)
{
TraceError(_T("Null hItem ptr\n"), sc);
sc = S_FALSE;
return sc.ToHr();
}
if (!hNode)
{
TraceError(_T("Null hNode ptr\n"), sc);
sc = S_FALSE;
return sc.ToHr();
}
// First ensure that the node has been enumerated by calling expand node.
ExpandNode(hItem);
// set up the AMCView correctly.
BOOL bAddSubFolders = FALSE;
sc = m_pAMCView->ScOnSelectNode(hNode, bAddSubFolders);
if(sc)
return sc.ToHr();
SetHasList(m_pAMCView->HasList());
// add subfolders if necessary.
if(bAddSubFolders)
{
sc = AddSubFolders(hItem, m_spResultData);
if (sc)
return sc.ToHr();
}
if (HasList())
m_spResultData->SetLoadMode(FALSE); // SetLoadMode(FALSE) was called by CAMCView::OnSelectNode.
// Need to change so that both calls are from the same function.
// get the node callback
INodeCallback* spNodeCallBack = GetNodeCallback();
sc = ScCheckPointers(spNodeCallBack, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// send preload notify to children
HTREEITEM hti = GetChildItem (hItem);
while (hti != NULL)
{
HNODE hNode = GetItemNode (hti);
if (hNode != 0)
spNodeCallBack->PreLoad (hNode);
hti = GetNextItem(hti, TVGN_NEXT);
}
return S_OK;
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::SetNavigatingWithKeyboard
*
*
*--------------------------------------------------------------------------*/
void CAMCTreeView::SetNavigatingWithKeyboard (bool fKeyboardNav)
{
/*
* if the requested state doesn't match the current state,
* change the current state to match the request
*/
if (fKeyboardNav != IsNavigatingWithKeyboard())
{
m_spKbdNavDelay = std::auto_ptr<CKeyboardNavDelay>(
(fKeyboardNav)
? new CKeyboardNavDelay (this)
: NULL /*assigning NULL deletes*/);
}
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnSelChanging
*
* TVN_SELCHANGING handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnSelChanging(NMHDR* pNMHDR, LRESULT* pResult)
{
*pResult = 0;
if (!IsNavigatingWithKeyboard())
OnSelChangingWorker ((NM_TREEVIEW*) pNMHDR, pResult);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnSelChanged
*
* TVN_SELCHANGED handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnSelChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pnmtv = (NM_TREEVIEW*) pNMHDR;
*pResult = 0;
if (IsNavigatingWithKeyboard())
m_spKbdNavDelay->ScStopTimer();
SetNavigatingWithKeyboard (pnmtv->action == TVC_BYKEYBOARD);
bool fDelayedSelection = IsNavigatingWithKeyboard() &&
!m_spKbdNavDelay->ScStartTimer(pnmtv).IsError();
if (!fDelayedSelection)
OnSelChangedWorker (pnmtv, pResult);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::CKeyboardNavDelay::CKeyboardNavDelay
*
*
*--------------------------------------------------------------------------*/
CAMCTreeView::CKeyboardNavDelay::CKeyboardNavDelay (CAMCTreeView* pTreeView) :
m_pTreeView (pTreeView)
{
ZeroMemory (&m_nmtvSelChanged, sizeof (m_nmtvSelChanged));
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::CKeyboardNavDelay::OnTimer
*
* Called when the keyboard navigation delay timer fires. When that happens,
* we need to perform the selection
*--------------------------------------------------------------------------*/
void CAMCTreeView::CKeyboardNavDelay::OnTimer()
{
/*
* we don't need any more ticks from this timer (ignoring errors)
*/
ScStopTimer();
Trace (tagKeyboardNavDelay, _T("Applying delayed scope selection change"));
LRESULT lUnused = 0;
m_pTreeView->OnSelChangedWorker (&m_nmtvSelChanged, &lUnused);
m_pTreeView->SetNavigatingWithKeyboard (false);
/*
* HANDS OFF! CAMCTreeView::SetNavigatingWithKeyboard deleted this object!
*/
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::CKeyboardNavDelay::ScStartTimer
*
*
*--------------------------------------------------------------------------*/
SC CAMCTreeView::CKeyboardNavDelay::ScStartTimer(NMTREEVIEW* pnmtv)
{
DECLARE_SC (sc, _T("CAMCTreeView:CKeyboardNavDelay::ScStartTimer"));
/*
* let the base class start the timer
*/
sc = BaseClass::ScStartTimer();
if (sc)
return (sc);
/*
* copy the notification struct so we can send it when our timer ticks
*/
m_nmtvSelChanged = *pnmtv;
return (sc);
}
void CAMCTreeView::OnSelChangedWorker(NM_TREEVIEW* pnmtv, LRESULT* pResult)
{
TRACE_METHOD(CAMCTreeView, OnSelChangedWorker);
if (m_fInCleanUp == TRUE)
return;
// See which pane has focus. Some snapins/ocx may steal the focus
// so we restore the focus after selecting the node.
ASSERT (m_pAMCView != NULL);
const CConsoleView::ViewPane ePane = m_pAMCView->GetFocusedPane();
//
// Select the new node
//
// Disable drawing to avoid seeing intermediate tree states.
UpdateWindow();
HRESULT hr = OnSelectNode(pnmtv->itemNew.hItem, (HNODE)pnmtv->itemNew.lParam);
if (hr == S_OK)
{
CStandardToolbar* pStdToolbar = m_pAMCView->GetStdToolbar();
ASSERT(NULL != pStdToolbar);
if (NULL != pStdToolbar)
{
pStdToolbar->ScEnableUpOneLevel(GetRootItem() != pnmtv->itemNew.hItem);
pStdToolbar->ScEnableExportList(m_pAMCView->HasListOrListPad());
}
*pResult = 0;
}
else if (hr == S_FALSE)
{
// snap-in changed the selection on us, so don't continue with this node.
return;
}
else
{
// something wrong with the node we are trying to select, reselect the old one
// SelectItem(pnmtv->itemOld.hItem);
MMCMessageBox(IDS_SNAPIN_FAILED_INIT);
*pResult = hr;
}
/*
* Even if the active view hasn't changed always restore the active view.
* Reason being, for OCX's even though they have the focus, they require
* MMC to inform that OCX being selected. (see bug: 180964)
*/
switch (ePane)
{
case CConsoleView::ePane_ScopeTree:
{
// if another view was made active, switch it back.
// View could still be active, but have focus stolen by
// a snap-in or ocx, so ensure view has focus too.
CFrameWnd* pFrame = GetParentFrame();
if (pFrame->GetActiveView() != this)
pFrame->SetActiveView(this);
else if (::GetFocus() != m_hWnd)
SetFocus();
break;
}
case CConsoleView::ePane_Results:
// If the result pane has the focus before and after
// the node was selected, then the last event snapin
// receives is scope selected which is incorrect.
// So we first set scope pane as active view but do
// not send notifications. Then we set result pane
// as active view which sends scope de-select and
// result pane select.
// Set Scope pane as active view and we also want to
// be notified about this active view so that our
// view activation observers will know who is the
// active view.
GetParentFrame()->SetActiveView(this, true);
// Now set result pane as active view and ask for notifications.
m_pAMCView->ScDeferSettingFocusToResultPane();
break;
case CConsoleView::ePane_None:
// no pane is active, do nothing
break;
default:
m_pAMCView->ScSetFocusToPane (ePane);
break;
}
/*
* Bug 345402: Make sure the focus rect is on the list control (if it
* actually has the focus) to wake up any accessibility tools that might
* be watching for input and focus changes.
*/
m_pAMCView->ScJiggleListViewFocus ();
}
void CAMCTreeView::OnSelChangingWorker (NM_TREEVIEW* pnmtv, LRESULT* pResult)
{
TRACE_METHOD(CAMCTreeView, OnSelChangingWorker);
if (m_fInCleanUp == TRUE)
return;
//
// De-select the current node
//
OnDeSelectNode ((HNODE)pnmtv->itemOld.lParam);
*pResult = 0;
}
HRESULT CAMCTreeView::AddSubFolders(MTNODEID* pIDs, int length)
{
ASSERT(pIDs != NULL && length != 0);
HRESULT hr = E_FAIL;
// first make sure the specified node is expanded in the tree ctrl
HTREEITEM hti = ExpandNode(pIDs, length, TRUE, false /*bExpandVisually*/);
ASSERT(hti != NULL);
// if successful, add the node's subfolders to the list view
if (hti != NULL)
{
hr = AddSubFolders(hti, m_spResultData);
ASSERT(SUCCEEDED(hr));
}
return hr;
}
HRESULT CAMCTreeView::AddSubFolders(HTREEITEM hti, LPRESULTDATA pResultData)
{
HRESULT hr;
RESULTDATAITEM tRDI;
::ZeroMemory(&tRDI, sizeof(tRDI));
tRDI.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
tRDI.nCol = 0;
tRDI.str = MMC_TEXTCALLBACK;
tRDI.nImage = MMC_IMAGECALLBACK;
tRDI.nIndex = -1;
hti = GetChildItem(hti);
ASSERT(m_pAMCView != NULL);
INodeCallback* spCallback = GetNodeCallback();
ASSERT(spCallback != NULL);
while (hti != NULL)
{
HNODE hNode = GetItemNode (hti);
if (hNode != 0)
{
tRDI.lParam = LParamFromNode (hNode);
hr = pResultData->InsertItem(&tRDI);
CHECK_HRESULT(hr);
if (SUCCEEDED(hr))
hr = spCallback->SetResultItem(hNode, tRDI.itemID);
// add custom image if any
spCallback->AddCustomFolderImage (hNode, m_spRsltImageList);
}
hti = GetNextItem(hti, TVGN_NEXT);
}
return S_OK;
}
int CAMCTreeView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
DECLARE_SC (sc, _T("CAMCTreeView::OnCreate"));
TRACE_METHOD(CAMCTreeView, OnCreate);
if (CTreeView::OnCreate(lpCreateStruct) == -1)
return -1;
m_pAMCView = ::GetAMCView (this);
ASSERT(m_pAMCView != NULL);
IScopeTree* spScopeTree = m_pAMCView->GetScopeTree();
ASSERT(spScopeTree != NULL);
HIMAGELIST hImageList;
spScopeTree->GetImageList(reinterpret_cast<PLONG_PTR>(&hImageList));
CBitmap bmp;
bmp.LoadBitmap(MAKEINTRESOURCE(IDB_AMC_NODES16));
int i = ImageList_AddMasked(hImageList, (HBITMAP) bmp.GetSafeHandle(), RGB(255,0,255));
ASSERT(i != -1 && "ImageList_Add failed.");
TreeView_SetImageList( *this, hImageList, TVSIL_NORMAL );
sc = ScRegisterAsDropTarget(m_hWnd);
if (sc)
return (-1);
sc = CreateNodeManager();
if (sc)
return (-1);
return 0;
}
BOOL CAMCTreeView::DestroyWindow()
{
TRACE_METHOD(CAMCTreeView, DestroyWindow);
CleanUp();
return CTreeView::DestroyWindow();
}
void
CAMCTreeView::DeleteNode(
HTREEITEM htiToDelete,
BOOL fDeleteThis)
{
// Ensure curr sel is not a child of the item to be deleted.
for (HTREEITEM hti = GetSelectedItem();
hti != NULL;
hti = GetParentItem(hti))
{
if (htiToDelete == hti)
{
if (fDeleteThis == TRUE)
{
hti = GetParentItem(hti);
if (hti)
SelectItem(hti);
}
break;
}
}
// There are two paths to this function. Path 1, the view is deleted and there is no
// longer a root node. Path 2. When a node is manually deleted, the selection is updated
// in CAMCView::OnUpdateSelectionForDelete, therefore, the above code traverses to the root node
ASSERT(hti == NULL || fDeleteThis == FALSE);
SDeleteNodeInfo dniLocal = {htiToDelete, hti, fDeleteThis};
_DeleteNode(dniLocal);
}
void CAMCTreeView::_DeleteNode(SDeleteNodeInfo& dni)
{
ASSERT(&dni != NULL);
ASSERT(dni.htiToDelete != NULL);
if (dni.htiToDelete == NULL)
return;
SDeleteNodeInfo dniLocal = {GetChildItem(dni.htiToDelete),
dni.htiSelected, TRUE};
// delete all the child nodes of the node being deleted
while (dniLocal.htiToDelete != NULL)
{
_DeleteNode(dniLocal);
dniLocal.htiToDelete = GetChildItem(dni.htiToDelete);
}
if (dni.fDeleteThis == TRUE)
{
// Reset the temp selection cache.
// This deals with items that are right click selected (temporary) on the context
// menu
if (IsTempSelectionActive() && (GetTempSelectedItem() == dni.htiToDelete))
{
SC sc = ScRemoveTempSelection ();
if (sc)
sc.TraceAndClear();
}
HNODE hNode = (HNODE)GetItemData(dni.htiToDelete);
HTREEITEM htiParentOfItemToDelete = GetParentItem(dni.htiToDelete);
// If the item is in list view remove it. We do not want to do this
// if it is virtual list or if selected item is "Console Root"
// in which case then parent is NULL.
if (HasList() && !m_pAMCView->IsVirtualList() &&
(NULL != htiParentOfItemToDelete) &&
(htiParentOfItemToDelete == dni.htiSelected) )
{
HRESULTITEM itemID;
HRESULT hr;
hr = m_spResultData->FindItemByLParam(LParamFromNode(hNode), &itemID);
if (SUCCEEDED(hr))
{
hr = m_spResultData->DeleteItem(itemID, 0);
ASSERT(SUCCEEDED(hr));
}
}
// tell the tree control to nuke it
DeleteItem(dni.htiToDelete);
// send an event to all interested observers
SC sc = ScFireEvent(CTreeViewObserver::ScOnItemDeleted, hNode, dni.htiToDelete);
if(sc)
sc.TraceAndClear();
// tell the master tree to nuke it.
m_pAMCView->GetScopeTree()->DestroyNode(hNode);
// maintain history
m_pAMCView->GetHistoryList()->DeleteEntry (hNode);
}
}
void CAMCTreeView::DeleteScopeTree()
{
DECLARE_SC(sc, _T("CAMCTreeView::DeleteScopeTree"));
m_fInCleanUp = TRUE;
// Release the ResultView from the IFrame in the primary snapin in
// the selected node.
// This is necessary to release the result view if the selected node
// is a snap-in node.
// Free all the nodes
HTREEITEM htiRoot = GetRootItem();
if (htiRoot != NULL)
DeleteNode(htiRoot, TRUE);
// First findout if the result view is properly
// set in the nodemgr by asking IFramePrivate.
IFramePrivatePtr spFrame = m_spResultData;
if (NULL != spFrame)
{
BOOL bIsResultViewSet = FALSE;
sc = spFrame->IsResultViewSet(&bIsResultViewSet);
// The result view is set, clean it up.
if (bIsResultViewSet)
sc = m_spResultData->DeleteAllRsltItems();
}
m_fInCleanUp = FALSE;
}
void CAMCTreeView::CleanUp()
{
TRACE_METHOD(CAMCTreeView, CleanUp);
m_fInCleanUp = TRUE;
m_spNodeManager = NULL;
m_spHeaderCtrl = NULL;
m_spResultData = NULL;
m_spRsltImageList = NULL;
m_spScopeData = NULL;
m_fInCleanUp = FALSE;
}
void CAMCTreeView::OnDestroy()
{
TRACE_METHOD(CAMCTreeView, OnDestroy);
//CleanUp();
CTreeView::OnDestroy();
CleanUp();
}
HRESULT CAMCTreeView::CreateNodeManager(void)
{
TRACE_METHOD(CAMCTreeView, CreateNodeManager);
if (m_spScopeData)
return S_OK;
#if _MSC_VER >= 1100
IFramePrivatePtr pIFrame(CLSID_NodeInit, NULL, MMC_CLSCTX_INPROC);
#else
IFramePrivatePtr pIFrame(CLSID_NodeInit, MMC_CLSCTX_INPROC);
#endif
ASSERT(pIFrame != NULL); if (pIFrame == NULL) return E_FAIL;
m_spScopeData = pIFrame;
m_spHeaderCtrl = pIFrame;
if (m_spHeaderCtrl)
pIFrame->SetHeader(m_spHeaderCtrl);
m_spResultData = pIFrame;
m_spRsltImageList = pIFrame;
m_spNodeManager = pIFrame;
pIFrame->SetComponentID(TVOWNED_MAGICWORD);
return S_OK;
}
HTREEITEM CAMCTreeView::GetClickedNode()
{
TV_HITTESTINFO tvhi;
tvhi.pt = (POINT)GetCaretPos();
tvhi.flags = TVHT_ONITEMLABEL;
tvhi.hItem = 0;
HTREEITEM htiClicked = HitTest(&tvhi);
return htiClicked;
}
void CAMCTreeView::GetCountOfChildren(HTREEITEM hItem, LONG* pcChildren)
{
TV_ITEM tvi;
tvi.hItem = hItem;
tvi.mask = TVIF_CHILDREN;
tvi.cChildren = 0;
GetItem(&tvi);
*pcChildren = tvi.cChildren;
}
void CAMCTreeView::SetCountOfChildren(HTREEITEM hItem, int cChildren)
{
TV_ITEM tvi;
tvi.hItem = hItem;
tvi.mask = TVIF_HANDLE | TVIF_CHILDREN;
tvi.cChildren = cChildren;
SetItem(&tvi);
}
HTREEITEM CAMCTreeView::FindNode(HTREEITEM hti, MTNODEID id)
{
INodeCallback* pCallback = GetNodeCallback();
static MTNODEID nID = -1;
static HRESULT hr = S_OK;
hr = pCallback->GetMTNodeID(GetItemNode(hti), &nID);
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
return NULL;
if (nID == id)
return hti;
HTREEITEM htiTemp = GetChildItem(hti);
if (htiTemp != NULL)
htiTemp = FindNode(htiTemp, id);
if (htiTemp == NULL)
{
htiTemp = GetNextSiblingItem(hti);
if (htiTemp != NULL)
htiTemp = FindNode(htiTemp, id);
}
return htiTemp;
}
HTREEITEM CAMCTreeView::FindSiblingItem(HTREEITEM hti, MTNODEID id)
{
INodeCallback* pCallback = GetNodeCallback();
if (!pCallback)
return NULL;
static MTNODEID nID = -1;
static HRESULT hr = S_OK;
while (hti != NULL)
{
hr = pCallback->GetMTNodeID(GetItemNode(hti), &nID);
if (FAILED(hr))
return NULL;
if (nID == id)
return hti;
hti = GetNextSiblingItem(hti);
}
return NULL;
}
//+-------------------------------------------------------------------
//
// Member: CAMCTreeView::SelectNode
//
// Synopsis: Given path to a node, select the node. If bSelectExactNode
// is false then walk the path as much as possible and select
// the last node in the best matched path. If bSelectExactNode
// is true then select the node if available else do nothing.
//
// Arguments: [pIDs] - [in] Array of node-id's (the path)
// [length] - [in] length of the above array
// [bSelectExactNode] - [in] select the exact node or not?
//
// Returns: SC, return ScFromMMC(IDS_NODE_NOT_FOUND) if select exact node is specified
// and it cannot be selected
//
//--------------------------------------------------------------------
SC CAMCTreeView::ScSelectNode(MTNODEID* pIDs, int length, bool bSelectExactNode /*= false*/)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::ScSelectNode"));
sc = ScCheckPointers(pIDs);
if (sc)
return sc;
if (m_fInExpanding)
return (sc);
HTREEITEM hti = GetRootItem();
sc = ScCheckPointers( (void*)hti, E_UNEXPECTED);
if (sc)
return sc;
if (pIDs[0] != ROOTNODEID)
return (sc = E_INVALIDARG);
INodeCallback* pCallback = GetNodeCallback();
sc = ScCheckPointers(pCallback, E_UNEXPECTED);
if (sc)
return sc;
MTNODEID nID = 0;
sc = pCallback->GetMTNodeID(GetItemNode(hti), &nID);
if (sc)
return sc;
bool bExactNodeFound = false;
for (int i=0; i<length; ++i)
{
if (pIDs[i] == nID)
break;
}
for (++i; i < length; ++i)
{
if (GetChildItem(hti) == NULL)
Expand(hti, TVE_EXPAND);
hti = FindSiblingItem(GetChildItem(hti), pIDs[i]);
if (hti == NULL)
break;
}
if (length == i)
bExactNodeFound = true;
if (hti)
{
// If exact node is to be selected make sure we have walked through the entire path.
if ( (bSelectExactNode) && (! bExactNodeFound) )
return ScFromMMC(IDS_NODE_NOT_FOUND); // do not trace this error.
if (GetSelectedItem() == hti)
ScReselect();
else
SelectItem(hti);
}
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCTreeView::Expand
*
* PURPOSE: Expands a particular tree item. This is just a wrapper around the
* tree control's expand method, which allows items to be expanded
* without changing the visual appearance of the tree.
*
* PARAMETERS:
* HTREEITEM hItem :
* UINT nCode :
* bool bExpandVisually :
*
* RETURNS:
* BOOL
*
*+-------------------------------------------------------------------------*/
BOOL
CAMCTreeView::Expand(HTREEITEM hItem, UINT nCode, bool bExpandVisually)
{
if( (nCode==TVE_EXPAND) && (!bExpandVisually) )
{
bool bExpand = true;
// code repeated here from OnItemExpand - we just mimic the effect of TVN_ITEMEXPANDING.
ExpandNode(hItem);
INodeCallback* pCallback = GetNodeCallback();
ASSERT(pCallback != NULL);
HNODE hNode = GetItemNode(hItem);
pCallback->Notify(hNode, NCLBK_SETEXPANDEDVISUALLY, bExpand, 0);
// If item has no children remove the + sign
if (GetChildItem(hItem) == NULL)
SetButton(hItem, FALSE);
return true;
}
else
return Expand(hItem, nCode);
}
/*+-------------------------------------------------------------------------*
*
* CAMCTreeView::ExpandNode
*
* PURPOSE: Expands a particular node in the tree.
*
* PARAMETERS:
* MTNODEID* pIDs :
* int length :
* bool bExpand :
* bool bExpandVisually : valid only if bExpand is true. If bExpandVisually
* is true, the items appear in the tree. If false,
* the tree appears unchanged, although items have been
* added.
*
* RETURNS:
* HTREEITEM
*
*+-------------------------------------------------------------------------*/
HTREEITEM
CAMCTreeView::ExpandNode(MTNODEID* pIDs, int length, bool bExpand, bool bExpandVisually)
{
HTREEITEM hti = GetRootItem();
ASSERT(hti != NULL);
ASSERT(pIDs[0] == ROOTNODEID);
INodeCallback* pCallback = GetNodeCallback();
if (!pCallback)
return NULL;
MTNODEID nID = 0;
HRESULT hr = pCallback->GetMTNodeID(GetItemNode(hti), &nID);
if (FAILED(hr))
return NULL;
for (int i=0; i<length; ++i)
{
if (pIDs[i] == nID)
break;
}
for (++i; i < length; ++i)
{
if (GetChildItem(hti) == NULL)
Expand(hti, TVE_EXPAND, bExpandVisually);
hti = FindSiblingItem(GetChildItem(hti), pIDs[i]);
if (hti == NULL)
break;
}
if (hti)
Expand(hti, bExpand ? TVE_EXPAND : TVE_COLLAPSE, bExpandVisually);
return hti;
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnKeyDown
*
* WM_KEYDOWN handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch (nChar)
{
case VK_DELETE:
if (m_pAMCView->IsVerbEnabled(MMC_VERB_DELETE))
{
HTREEITEM hti = GetSelectedItem();
if (hti != NULL)
{
HNODE hNodeSel = GetItemNode(hti);
ASSERT(hNodeSel != NULL);
INodeCallback* pNC = GetNodeCallback();
ASSERT(pNC != NULL);
pNC->Notify(hNodeSel, NCLBK_DELETE, TRUE, 0);
}
return;
}
break;
}
CTreeView::OnKeyDown(nChar, nRepCnt, nFlags);
}
#ifdef DBG
void CAMCTreeView::DbgDisplayNodeName(HNODE hNode)
{
ASSERT(hNode != NULL);
INodeCallback* spCallback = GetNodeCallback();
ASSERT(spCallback != NULL);
tstring strName;
HRESULT hr = spCallback->GetDisplayName(hNode, strName);
::MMCMessageBox( strName.data() );
}
void CAMCTreeView::DbgDisplayNodeName(HTREEITEM hti)
{
DbgDisplayNodeName((HNODE)GetItemData(hti));
}
#endif
/*+-------------------------------------------------------------------------*
*
* CAMCTreeView::OnSysKeyDown and CAMCTreeView::OnSysChar
*
* PURPOSE: Handle the WM_SYSKEYDOWN and WM_SYSCHAR messages. Note:
* VK_RETURN causes a beep if handled in WM_SYSKEYDOWN. And VK_LEFT and
* VK_RIGHT don't cause a WM_SYSCHAR. Thats why we need to handle these
* differently.
*
* PARAMETERS:
* UINT nChar :
* UINT nRepCnt :
* UINT nFlags :
*
* RETURNS:
* void
*
*+-------------------------------------------------------------------------*/
void CAMCTreeView::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch (nChar)
{
case VK_LEFT:
case VK_RIGHT:
{
CWnd* pwndParent = GetParent();
ASSERT(pwndParent != NULL);
if (pwndParent != NULL)
pwndParent->SendMessage (WM_SYSKEYDOWN, nChar,
MAKELPARAM (nRepCnt, nFlags));
return;
}
default:
break;
}
CTreeView::OnSysKeyDown(nChar, nRepCnt, nFlags);
}
void CAMCTreeView::OnSysChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::OnSysChar"));
switch (nChar)
{
case VK_RETURN:
{
INodeCallback* pCallback = GetNodeCallback();
CAMCView* pAMCView = GetAMCView();
sc = ScCheckPointers(pAMCView, pCallback, E_UNEXPECTED);
if (sc)
return;
if (! pAMCView->IsVerbEnabled(MMC_VERB_PROPERTIES))
return;
HTREEITEM hti = GetSelectedItem();
if (!hti)
break;
HNODE hNode = (HNODE)GetItemData(hti);
if (hNode != 0)
pCallback->Notify(hNode, NCLBK_PROPERTIES, TRUE, 0);
return;
}
default:
break;
}
CTreeView::OnSysChar(nChar, nRepCnt, nFlags);
}
BOOL CAMCTreeView::OnCmdMsg( UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo )
{
// Do normal command routing
if (CTreeView::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
return TRUE;
// if view didn't handle it, give parent view a chance
if (m_pAMCView != NULL)
return static_cast<CWnd*>(m_pAMCView)->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
else
return FALSE;
}
void CAMCTreeView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
switch (lHint)
{
case VIEW_UPDATE_DELETE_EMPTY_VIEW:
{
if (!m_pAMCView)
{
CWnd* pWnd = GetParent();
ASSERT(pWnd != NULL);
m_pAMCView = reinterpret_cast<CAMCView*>(pWnd);
}
ASSERT(m_pAMCView != NULL);
if (m_pAMCView)
m_pAMCView->OnDeleteEmptyView();
}
break;
default:
break;
}
}
int CAMCTreeView::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
{
/*------------------------------------------------------------------------*/
/* Short out the WM_MOUSEACTIVATE here to prevent default processing, */
/* which is to send the message on to succeeding parent windows until */
/* one answers the message. In our case, it goes all the way up to */
/* the main frame, which invariably decides to activate. This is a */
/* problem for two reasons: */
/* */
/* 1. On the way back down from the main frame, the message passes */
/* through CAMCView, which lets CView::OnMouseActivate do the */
/* work. CView::OnMouseActivate will set itself (CAMCView) as */
/* the active view, which in turn causes focus to be set to */
/* the view. CAMCView never wants the focus, since it is just */
/* a frame for the scope and result panes, so it will deflect */
/* the activation to the scope pane (CAMCTreeView) in */
/* CAMCView::OnSetFocus, which is where we want it to be. If */
/* we short out the processing here, we avoid excessive focus */
/* churn. It is essential that CAMCTreeView::OnSetFocus set */
/* itself as the active view to keep the bookkeeping straight. */
/* */
/* 2. If we don't short out here and avoid excessive focus churn, */
/* we have a problem with sometimes erroneously entering rename */
/* mode when the tree isn't active and the user clicks (once) on */
/* the selected item. An ordinary activation sequence goes like */
/* this: WM_MOUSEACTIVATE, WM_xBUTTONDOWN, WM_SETFOUS -- all to */
/* the tree view. The tree's button down processing doesn't enter */
/* the label edit (i.e. rename) sequence because it recognizes */
/* that it doesn't have the focus when the click happens. When */
/* the tree view is a CView, as in this case, CView::OnMouseActivate */
/* sets the focus to the tree view, causing the activation sequence */
/* to look like this: WM_MOUSEACTIVATE, WM_SETFOCUS, WM_xBUTTONDOWN. */
/* Now the tree's button down processing sees that the tree has */
/* the focus, so it enters label edit mode. BUG! Shorting out */
/* here (and relying on CAMCTreeView::OnSetFocus to properly activate */
/* the view) fixes all that. */
/*------------------------------------------------------------------------*/
return (MA_ACTIVATE);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnSetFocus
*
* WM_SETFOCUS handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnSetFocus(CWnd* pOldWnd)
{
Trace(tagTree, TEXT("OnSetFocus"));
/*
* if this view has the focus, it should be the active view
*/
GetParentFrame()->SetActiveView (this);
CTreeView::OnSetFocus(pOldWnd);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnKillFocus
*
* WM_KILLFOCUS handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnKillFocus(CWnd* pNewWnd)
{
Trace(tagTree, TEXT("OnKillFocus"));
CTreeView::OnKillFocus(pNewWnd);
/*
* Bug 114948 (from the "Windows NT Bugs" database, aka "the overlapping
* rectangle problem"): The tree control has code to invalidate the
* selected item when focus is lost. If we have a temp selection, we've
* made a temporary item appear selected by fiddling with TVIS_SELECTED
* states (see ScSet/RemoveTempSelection). We need to do it that way
* instead of sending TVM_SELECTITEM so we don't get unwanted
* TVN_SELCHANGED notifications, but it has the side effect of fooling
* the tree control's WM_KILLFOCUS handler into invalidating the non-temp
* selected item instead of the item that is really showing selection, the
* temp item.
*
* This bug was originally fixed with a sledgehammer, specifically by
* forcing the entire main frame and all of its children to be totally
* redrawn after displaying any context menu. This caused bug 139541
* (in the "Windows Bugs" database).
*
* A much more surgical fix to 114948, which also avoids 139541, is to
* manually invalidate the temporarily selected item. It's important
* that we do this after calling the base class so it will be redrawn
* in the "we don't have the focus" color (usually gray), rather than
* the standard selection color.
*/
if (IsTempSelectionActive())
{
CRect rectItem;
GetItemRect (GetTempSelectedItem(), rectItem, false);
RedrawWindow (rectItem);
}
}
void CAMCTreeView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::OnActivateView"));
#ifdef DBG
Trace(tagTree, _T("TreeView::OnActivateView (%s, pAct=0x%08x, pDeact=0x%08x))\n"),
(bActivate) ? _T("true") : _T("false"), pActivateView, pDeactiveView);
#endif
if ( (pActivateView != pDeactiveView) &&
(bActivate) )
{
sc = ScFireEvent(CTreeViewObserver::ScOnTreeViewActivated);
if (sc)
sc.TraceAndClear();
}
CTreeView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}
/*+-------------------------------------------------------------------------*
* CAMCTreeView::OnCustomDraw
*
* NM_CUSTOMDRAW handler for CAMCTreeView.
*--------------------------------------------------------------------------*/
void CAMCTreeView::OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult)
{
NMCUSTOMDRAW* pnmcd = reinterpret_cast<NMCUSTOMDRAW *>(pNMHDR);
ASSERT (CWnd::FromHandle (pnmcd->hdr.hwndFrom) == this);
*pResult = m_FontLinker.OnCustomDraw (pnmcd);
}
/*+-------------------------------------------------------------------------*
* CTreeFontLinker::GetItemText
*
*
*--------------------------------------------------------------------------*/
std::wstring CTreeFontLinker::GetItemText (NMCUSTOMDRAW* pnmcd) const
{
USES_CONVERSION;
HTREEITEM hItem = reinterpret_cast<HTREEITEM>(pnmcd->dwItemSpec);
CTreeCtrl& tc = m_pTreeView->GetTreeCtrl();
return (std::wstring (T2CW (tc.GetItemText (hItem))));
}
//+-------------------------------------------------------------------
//
// Member: CAMCTreeView::ScGetTreeItemIconInfo
//
// Synopsis: Get the given node's small icon.
//
// Arguments: [hNode] - for which info is needed.
// [phIcon] - [out], ptr to HICON.
//
// Note: Caller calls DestroyIcon on the HICON returned.
//
// Returns: SC
//
//--------------------------------------------------------------------
SC CAMCTreeView::ScGetTreeItemIconInfo(HNODE hNode, HICON *phIcon)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::ScGetTreeItemIconInfo"));
sc = ScCheckPointers(hNode, phIcon);
if (sc)
return sc;
INodeCallback* spNodeCallBack = GetNodeCallback();
sc = ScCheckPointers(spNodeCallBack, m_pAMCView, E_UNEXPECTED);
if (sc)
return sc;
// Get the index.
int nImage = -1;
int nSelectedImage = -1;
sc = spNodeCallBack->GetImages(hNode, &nImage, &nSelectedImage);
if (sc)
return sc;
// Get the imagelist.
HIMAGELIST hImageList = NULL;
hImageList = TreeView_GetImageList(GetSafeHwnd(), TVSIL_NORMAL);
if (! hImageList)
return (sc = E_FAIL);
*phIcon = ImageList_GetIcon(hImageList, nImage, ILD_TRANSPARENT);
if (!*phIcon)
return (sc = E_FAIL);
return sc;
}
/*+-------------------------------------------------------------------------*
*
* CAMCTreeView::ScRenameScopeNode
*
* PURPOSE: put the specified scope node into rename mode.
*
* PARAMETERS:
* HMTNODE hMTNode :
*
* RETURNS:
* SC
*
*+-------------------------------------------------------------------------*/
SC
CAMCTreeView::ScRenameScopeNode(HMTNODE hMTNode)
{
DECLARE_SC(sc, TEXT("CAMCTreeView::ScRenameScopeNode"));
if(!IsWindowVisible())
return (sc = E_FAIL);
HTREEITEM hti = NULL;
sc = m_treeMap.ScGetHTreeItemFromHMTNode(hMTNode, &hti);
if(sc)
return sc;
// must have the focus to rename
if (::GetFocus() != m_hWnd)
SetFocus();
if(NULL==EditLabel(hti))
return (sc = E_FAIL); // if for any reason the operation failed, return an error
return sc;
}
Reference in a new issue Copy permalink