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.
1347 lines
38 KiB
1347 lines
38 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
root.cpp
|
|
Root node information (the root node is not displayed
|
|
in the MMC framework but contains information such as
|
|
all of the subnodes in this snapin).
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "machine.h"
|
|
#include "rtrcfg.h"
|
|
#include "resource.h"
|
|
#include "ncglobal.h" // network console global defines
|
|
#include "htmlhelp.h"
|
|
#include "dmvstrm.h"
|
|
#include "dmvroot.h"
|
|
#include "dvsview.h"
|
|
#include "refresh.h"
|
|
#include "refrate.h"
|
|
#include "rtrres.h"
|
|
|
|
unsigned int g_cfMachineName = RegisterClipboardFormat(L"MMC_SNAPIN_MACHINE_NAME");
|
|
|
|
// result message view stuff
|
|
#define ROOT_MESSAGE_MAX_STRING 5
|
|
|
|
typedef enum _ROOT_MESSAGES
|
|
{
|
|
ROOT_MESSAGE_MAIN,
|
|
ROOT_MESSAGE_MAX
|
|
};
|
|
|
|
UINT g_uRootMessages[ROOT_MESSAGE_MAX][ROOT_MESSAGE_MAX_STRING] =
|
|
{
|
|
{IDS_ROOT_MESSAGE_TITLE, Icon_Information, IDS_ROOT_MESSAGE_BODY1, IDS_ROOT_MESSAGE_BODY2, 0},
|
|
};
|
|
|
|
|
|
DEBUG_DECLARE_INSTANCE_COUNTER(DMVRootHandler)
|
|
|
|
// DMVRootHandler implementation
|
|
/*
|
|
extern const ContainerColumnInfo s_rgATLKInterfaceStatsColumnInfo[];
|
|
|
|
extern const ContainerColumnInfo s_rgATLKGroupStatsColumnInfo[];
|
|
|
|
struct _ViewInfoColumnEntry
|
|
{
|
|
UINT m_ulId;
|
|
UINT m_cColumns;
|
|
const ContainerColumnInfo *m_prgColumn;
|
|
};
|
|
*/
|
|
|
|
DMVRootHandler::DMVRootHandler(ITFSComponentData *pCompData)
|
|
: RootHandler(pCompData),
|
|
m_ulConnId(0),
|
|
m_fAddedProtocolNode(FALSE)
|
|
// m_dwRefreshInterval(DEFAULT_REFRESH_INTERVAL)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(DMVRootHandler)
|
|
|
|
//create one qeneral query placeholder
|
|
m_ConfigStream.m_RQPersist.createQry(1);
|
|
|
|
m_bExpanded=false;
|
|
}
|
|
|
|
DMVRootHandler::~DMVRootHandler()
|
|
{
|
|
m_spServerNodesRefreshObject.Release();
|
|
m_spSummaryModeRefreshObject.Free();
|
|
|
|
DEBUG_DECREMENT_INSTANCE_COUNTER(DMVRootHandler);
|
|
};
|
|
|
|
|
|
STDMETHODIMP DMVRootHandler::QueryInterface(REFIID riid, LPVOID *ppv)
|
|
{
|
|
// Is the pointer bad?
|
|
if ( ppv == NULL )
|
|
return E_INVALIDARG;
|
|
|
|
// Place NULL in *ppv in case of failure
|
|
*ppv = NULL;
|
|
|
|
// This is the non-delegating IUnknown implementation
|
|
if ( riid == IID_IUnknown )
|
|
*ppv = (LPVOID) this;
|
|
else
|
|
return RootHandler::QueryInterface(riid, ppv);
|
|
|
|
// If we're going to return an interface, AddRef it first
|
|
if ( *ppv )
|
|
{
|
|
((LPUNKNOWN) *ppv)->AddRef();
|
|
return hrOK;
|
|
}
|
|
else
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//// IPersistStream interface members
|
|
STDMETHODIMP DMVRootHandler::GetClassID
|
|
(
|
|
CLSID *pClassID
|
|
)
|
|
{
|
|
ASSERT(pClassID != NULL);
|
|
|
|
// Copy the CLSID for this snapin
|
|
*pClassID = CLSID_RouterSnapin;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
// Global refresh is to be shareed by multiple machine nodes and status node
|
|
// in case of this snapin is created as extension, it not being used
|
|
HRESULT DMVRootHandler::GetSummaryNodeRefreshObject(RouterRefreshObject** ppRefresh)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
HWND hWndSync = m_spTFSCompData->GetHiddenWnd();
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// If there is no sync window, then there is no refresh object
|
|
// ------------------------------------------------------------
|
|
if (hWndSync
|
|
|| m_spSummaryModeRefreshObject) // added by WeiJiang 10/29/98 to allow external RefreshObject
|
|
{
|
|
if (!m_spSummaryModeRefreshObject)
|
|
{
|
|
try{
|
|
RouterRefreshObject* pRefresh = new RouterRefreshObject(hWndSync);
|
|
m_spSummaryModeRefreshObject = pRefresh;
|
|
m_RefreshGroup.Join(pRefresh);
|
|
}catch(...)
|
|
{
|
|
|
|
}
|
|
|
|
if(m_spSummaryModeRefreshObject)
|
|
{
|
|
if(m_ConfigStream.m_dwRefreshInterval)
|
|
{
|
|
if(m_ConfigStream.m_bAutoRefresh)
|
|
m_spSummaryModeRefreshObject->Start(m_ConfigStream.m_dwRefreshInterval);
|
|
else
|
|
m_spSummaryModeRefreshObject->SetRefreshInterval(m_ConfigStream.m_dwRefreshInterval);
|
|
}
|
|
}
|
|
}
|
|
if (ppRefresh)
|
|
{
|
|
*ppRefresh = m_spSummaryModeRefreshObject;
|
|
(*ppRefresh)->AddRef();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ppRefresh)
|
|
*ppRefresh = NULL;
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Global refresh is to be shareed by multiple machine nodes and status node
|
|
// in case of this snapin is created as extension, it not being used
|
|
HRESULT DMVRootHandler::GetServerNodesRefreshObject(IRouterRefresh** ppRefresh)
|
|
{
|
|
|
|
HRESULT hr = hrOK;
|
|
HWND hWndSync = m_spTFSCompData->GetHiddenWnd();
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// If there is no sync window, then there is no refresh object
|
|
// ------------------------------------------------------------
|
|
if (hWndSync
|
|
|| (IRouterRefresh*)m_spServerNodesRefreshObject) // added by WeiJiang 10/29/98 to allow external RefreshObject
|
|
{
|
|
if ((IRouterRefresh*)m_spServerNodesRefreshObject == NULL)
|
|
{
|
|
RouterRefreshObject* pRefresh = new RouterRefreshObject(hWndSync);
|
|
if(pRefresh)
|
|
{
|
|
m_spServerNodesRefreshObject = pRefresh;
|
|
m_RefreshGroup.Join(pRefresh);
|
|
if(m_ConfigStream.m_dwRefreshInterval)
|
|
{
|
|
if(m_ConfigStream.m_bAutoRefresh)
|
|
m_spServerNodesRefreshObject->Start(m_ConfigStream.m_dwRefreshInterval);
|
|
else
|
|
m_spServerNodesRefreshObject->SetRefreshInterval(m_ConfigStream.m_dwRefreshInterval);
|
|
}
|
|
}
|
|
}
|
|
if (ppRefresh)
|
|
{
|
|
*ppRefresh = m_spServerNodesRefreshObject;
|
|
(*ppRefresh)->AddRef();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ppRefresh)
|
|
*ppRefresh = NULL;
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::Init
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::Init(ITFSNode* pNode)
|
|
{
|
|
m_ConfigStream.Init(this, pNode);
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::OnExpand
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::OnExpand(ITFSNode *pNode,LPDATAOBJECT pDataObject, DWORD dwType, LPARAM arg,LPARAM lParam)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
// For now create a new node handler for each new node,
|
|
// this is rather bogus as it can get expensive. We can
|
|
// consider creating only a single node handler for each
|
|
// node type.
|
|
MachineHandler * pHandler = NULL;
|
|
SPITFSNodeHandler spHandler;
|
|
SPITFSNodeHandler spStatusHandler;
|
|
SPITFSNode spNodeS;
|
|
SPITFSNode spNodeM;
|
|
|
|
DomainStatusHandler * pStatusHandler = NULL;
|
|
DWORD dw;
|
|
int i;
|
|
list<MachineNodeData *>::iterator itor;
|
|
SPMachineNodeData spMachineData;
|
|
MachineNodeData * pMachineData;
|
|
SPIRouterRefresh spServerNodesRefresh;
|
|
SPRouterRefreshObject spSummaryNodeRefresh;
|
|
CString stMachineName;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
if (dwType & TFS_COMPDATA_EXTENSION)
|
|
{
|
|
// we are extending the network management snapin.
|
|
// Add a node for the machine
|
|
// specified in the data object.
|
|
stMachineName = Extract<TCHAR>(pDataObject, (CLIPFORMAT) g_cfMachineName, COMPUTERNAME_LEN_MAX);
|
|
|
|
//create a machine handler
|
|
pHandler = new MachineHandler(m_spTFSCompData);
|
|
|
|
// Create a new machine data
|
|
spMachineData = new MachineNodeData;
|
|
spMachineData->Init(stMachineName);
|
|
|
|
// Do this so that it will get released correctly
|
|
spHandler = pHandler;
|
|
pHandler->Init(stMachineName, NULL, NULL, NULL);
|
|
|
|
if(!spServerNodesRefresh)
|
|
GetServerNodesRefreshObject(&spServerNodesRefresh);
|
|
|
|
if((IRouterRefresh*)spServerNodesRefresh)
|
|
CORg(pHandler->SetExternalRefreshObject(spServerNodesRefresh));
|
|
|
|
if(stMachineName.GetLength() == 0)
|
|
stMachineName = GetLocalMachineName();
|
|
|
|
// Create the root node for this sick puppy
|
|
CORg( CreateContainerTFSNode(&spNodeM,
|
|
&GUID_RouterMachineNodeType,
|
|
pHandler,
|
|
pHandler /* result handler */,
|
|
m_spNodeMgr) );
|
|
Assert(spNodeM);
|
|
|
|
spNodeM->SetData(TFS_DATA_COOKIE, (LONG_PTR)(ITFSNode*)spNodeM);
|
|
|
|
CORg(pHandler->ConstructNode(spNodeM, stMachineName, spMachineData) );
|
|
|
|
pHandler->SetExtensionStatus(spNodeM, TRUE);
|
|
|
|
// Make the node immediately visible
|
|
spNodeM->SetVisibilityState(TFS_VIS_SHOW);
|
|
pNode->AddChild(spNodeM);
|
|
|
|
}
|
|
else
|
|
{
|
|
//create a summary node
|
|
if (!m_spStatusNode) // changed by Wei Jiang !m_bExpanded)
|
|
{
|
|
pStatusHandler = new DomainStatusHandler(m_spTFSCompData);
|
|
Assert(pStatusHandler);
|
|
m_pStatusHandler = pStatusHandler;
|
|
spStatusHandler.Set(spHandler);
|
|
|
|
CORg( pStatusHandler->Init(&m_ConfigStream, &m_serverlist) );
|
|
|
|
if(!spSummaryNodeRefresh)
|
|
GetSummaryNodeRefreshObject(&spSummaryNodeRefresh);
|
|
|
|
if((RouterRefreshObject*)spSummaryNodeRefresh)
|
|
CORg(pStatusHandler->SetExternalRefreshObject(spSummaryNodeRefresh));
|
|
|
|
spHandler = pStatusHandler;
|
|
|
|
CORg( CreateContainerTFSNode(&spNodeS,
|
|
&GUID_DVSServerNodeType,
|
|
static_cast<ITFSNodeHandler *>(pStatusHandler),
|
|
static_cast<ITFSResultHandler *>(pStatusHandler),
|
|
m_spNodeMgr) );
|
|
|
|
Assert(spNodeS);
|
|
m_spStatusNode.Set(spNodeS);
|
|
|
|
// Call to the node handler to init the node data
|
|
pStatusHandler->ConstructNode(spNodeS);
|
|
// Make the node immediately visible
|
|
spNodeS->SetVisibilityState(TFS_VIS_SHOW);
|
|
pNode->AddChild(spNodeS);
|
|
spHandler.Release();
|
|
}
|
|
else
|
|
{
|
|
spNodeS.Set(m_spStatusNode);
|
|
spNodeS->GetHandler(&spStatusHandler);
|
|
}
|
|
|
|
// iterate the lazy list looking for machine nodes to create
|
|
for (itor = m_serverlist.m_listServerNodesToExpand.begin();
|
|
itor != m_serverlist.m_listServerNodesToExpand.end() ;
|
|
itor++ )
|
|
{
|
|
pMachineData = *itor;
|
|
|
|
//create a machine handler
|
|
pHandler = new MachineHandler(m_spTFSCompData);
|
|
|
|
// Do this so that it will get released correctly
|
|
spHandler.Release();
|
|
spHandler = pHandler;
|
|
|
|
CORg(pHandler->Init(pMachineData->m_stMachineName,
|
|
NULL, spStatusHandler, spNodeS));
|
|
if(!(IRouterRefresh*)spServerNodesRefresh)
|
|
GetServerNodesRefreshObject(&spServerNodesRefresh);
|
|
|
|
if((IRouterRefresh*)spServerNodesRefresh)
|
|
CORg(pHandler->SetExternalRefreshObject(spServerNodesRefresh));
|
|
|
|
// Create the root node for this sick puppy
|
|
CORg( CreateContainerTFSNode(&spNodeM,
|
|
&GUID_RouterMachineNodeType,
|
|
pHandler,
|
|
pHandler /* result handler */,
|
|
m_spNodeMgr) );
|
|
Assert(spNodeM);
|
|
spNodeM->SetData(TFS_DATA_COOKIE, (LONG_PTR)(ITFSNode*)spNodeM);
|
|
|
|
// if the machine is local, then find the name,
|
|
// but not change the name on the list
|
|
// so, when persist the list, empty string will be persisted
|
|
//
|
|
// This is incorrect. For the local machine case, we
|
|
// expect the NULL string to be passed down. It should
|
|
// be transparent to this layer whether the machine is
|
|
// local or not.
|
|
// ----------------------------------------------------
|
|
|
|
if (pMachineData && pMachineData->m_stMachineName.GetLength() != 0)
|
|
stMachineName = pMachineData->m_stMachineName;
|
|
else
|
|
stMachineName.Empty();
|
|
|
|
CORg( pHandler->ConstructNode(spNodeM, stMachineName, pMachineData) );
|
|
|
|
// Make the node immediately visible
|
|
spNodeM->SetVisibilityState(TFS_VIS_SHOW);
|
|
pNode->AddChild(spNodeM);
|
|
spNodeM.Release();
|
|
}
|
|
|
|
// Now that we've gone through the entire list, we have
|
|
// to release the objects.
|
|
m_serverlist.RemoveAllServerNodes();
|
|
|
|
Assert(m_serverlist.m_listServerNodesToExpand.size() == 0);
|
|
}
|
|
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
m_bExpanded = true;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::OnCreateDataObject
|
|
Implementation of ITFSNodeHandler::OnCreateDataObject
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DMVRootHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// If we haven't created the sub nodes yet, we still have to
|
|
// create a dataobject.
|
|
CDataObject * pObject = NULL;
|
|
SPIDataObject spDataObject;
|
|
SPITFSNode spNode;
|
|
SPITFSNodeHandler spHandler;
|
|
|
|
pObject = new CDataObject;
|
|
spDataObject = pObject; // do this so that it gets released correctly
|
|
Assert(pObject != NULL);
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pObject->SetType(type);
|
|
pObject->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pObject->SetClsid(*(m_spTFSCompData->GetCoClassID()));
|
|
|
|
pObject->SetTFSComponentData(m_spTFSCompData);
|
|
|
|
hr = pObject->QueryInterface(IID_IDataObject,
|
|
reinterpret_cast<void**>(ppDataObject));
|
|
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
// ImplementEmbeddedUnknown(ATLKRootHandler, IRtrAdviseSink)
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::DestroyHandler
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DMVRootHandler::DestroyHandler(ITFSNode *pNode)
|
|
{
|
|
m_ulConnId = 0;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::HasPropertyPages
|
|
Implementation of ITFSNodeHandler::HasPropertyPages
|
|
NOTE: the root node handler has to over-ride this function to
|
|
handle the snapin manager property page (wizard) case!!!
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
DMVRootHandler::HasPropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
return S_FALSE;
|
|
|
|
HRESULT hr = hrOK;
|
|
|
|
if ( dwType & TFS_COMPDATA_CREATE )
|
|
{
|
|
// This is the case where we are asked to bring up property
|
|
// pages when the user is adding a new snapin. These calls
|
|
// are forwarded to the root node to handle.
|
|
//
|
|
// We do have a property page on startup.
|
|
hr = hrOK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::CreatePropertyPages
|
|
Implementation of ITFSNodeHandler::CreatePropertyPages
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
DMVRootHandler::CreatePropertyPages(
|
|
ITFSNode * pNode,
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LPDATAOBJECT pDataObject,
|
|
LONG_PTR handle,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
HPROPSHEETPAGE hPage;
|
|
|
|
Assert(pNode->GetData(TFS_DATA_COOKIE) == 0);
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::GetString
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(LPCTSTR) DMVRootHandler::GetString(ITFSNode *pNode, int nCol)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
static CString str;
|
|
|
|
if ( m_strDomainName.GetLength() == 0 )
|
|
{
|
|
if ( str.GetLength() == 0 )
|
|
str.LoadString(IDS_DMV_NODENAME_ROOT);
|
|
|
|
return (LPCTSTR)str;
|
|
|
|
}
|
|
else
|
|
return (LPCTSTR) m_strDomainName;
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Menu data structure for our menus
|
|
---------------------------------------------------------------------------*/
|
|
|
|
static const SRouterNodeMenu s_rgDMVNodeMenu[] =
|
|
{
|
|
// Add items that go on the top menu here
|
|
{ IDS_DMV_MENU_ADDSVR, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
|
|
{ IDS_MENU_SEPARATOR, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP },
|
|
|
|
{ IDS_MENU_AUTO_REFRESH, DMVRootHandler::GetAutoRefreshFlags,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP },
|
|
|
|
{ IDS_MENU_REFRESH_RATE, DMVRootHandler::GetAutoRefreshFlags,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP },
|
|
|
|
};
|
|
|
|
ULONG DMVRootHandler::GetAutoRefreshFlags(const SRouterNodeMenu *pMenuData,
|
|
INT_PTR pUserData)
|
|
{
|
|
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
|
|
Assert(pData);
|
|
|
|
ULONG uStatus = MF_GRAYED;
|
|
|
|
SPIRouterRefresh spRefresh;
|
|
|
|
pData->m_pDMVRootHandler->GetServerNodesRefreshObject(&spRefresh);
|
|
if ((IRouterRefresh*)spRefresh)
|
|
{
|
|
uStatus = MF_ENABLED;
|
|
if (pMenuData->m_sidMenu == IDS_MENU_AUTO_REFRESH && (spRefresh->IsRefreshStarted() == hrOK))
|
|
{
|
|
uStatus |= MF_CHECKED;
|
|
}
|
|
}
|
|
|
|
return uStatus;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnAddMenuItems
|
|
Implementation of ITFSNodeHandler::OnAddMenuItems
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DMVRootHandler::OnAddMenuItems(
|
|
ITFSNode *pNode,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
LPDATAOBJECT lpDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType,
|
|
long *pInsertionAllowed)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
DMVRootHandler::SMenuData menuData;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
menuData.m_spNode.Set(pNode);
|
|
menuData.m_pDMVRootHandler = this; // non-AddRef'd !
|
|
|
|
// Uncomment if you have items to add
|
|
hr = AddArrayOfMenuItems(pNode, s_rgDMVNodeMenu,
|
|
DimensionOf(s_rgDMVNodeMenu),
|
|
pContextMenuCallback,
|
|
*pInsertionAllowed,
|
|
reinterpret_cast<INT_PTR>(&menuData));
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::QryAddServer
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::QryAddServer(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dw=0;
|
|
POSITION pos;
|
|
CString szServer;
|
|
|
|
RRASQryData qd;
|
|
qd.dwCatFlag=RRAS_QRY_CAT_NONE;
|
|
|
|
CWaitCursor wait;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
if ( FHrSucceeded(hr=::RRASOpenQryDlg(NULL,qd)) )
|
|
{
|
|
if ( (hr!=S_OK) || (qd.dwCatFlag==RRAS_QRY_CAT_NONE) )
|
|
return hr;
|
|
|
|
if (qd.dwCatFlag==RRAS_QRY_CAT_MACHINE || qd.dwCatFlag == RRAS_QRY_CAT_THIS )
|
|
{ //specific machine query; add to array
|
|
m_ConfigStream.m_RQPersist.add_Qry(qd);
|
|
}
|
|
else
|
|
{ //position 0 is the non-machine singleton query
|
|
RRASQryData& qdGen=*(m_ConfigStream.m_RQPersist.m_v_pQData[0]);
|
|
if (!( (qdGen.dwCatFlag==qd.dwCatFlag) &&
|
|
(qdGen.strScope=qd.strScope) &&
|
|
(qdGen.strFilter=qd.strFilter) ))
|
|
{
|
|
qdGen.dwCatFlag=qd.dwCatFlag;
|
|
qdGen.strScope=qd.strScope;
|
|
qdGen.strFilter=qd.strFilter;
|
|
}
|
|
}
|
|
|
|
CStringArray sa;
|
|
::RRASExecQry(qd, dw, sa);
|
|
//if there is only one server selected, select it
|
|
hr = AddServersToList(sa,pNode);
|
|
if ( S_OK == hr && (qd.dwCatFlag==RRAS_QRY_CAT_MACHINE || qd.dwCatFlag == RRAS_QRY_CAT_THIS ))
|
|
{
|
|
|
|
//select the scope item...
|
|
//create a background thread to select the current node?
|
|
//this sucks...
|
|
//it really does...
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AfxMessageBox(IDS_DVS_DOMAINVIEWQRY);
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT DMVRootHandler::ExecServerQry(ITFSNode* pNode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dw=0;
|
|
CString szServer;
|
|
SPITFSNode spParent;
|
|
CStringArray sa;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
for (int i=0;i<m_ConfigStream.m_RQPersist.m_v_pQData.size(); i++ )
|
|
{
|
|
RRASQryData& QData=*(m_ConfigStream.m_RQPersist.m_v_pQData[i]);
|
|
|
|
if (QData.dwCatFlag==RRAS_QRY_CAT_NONE)
|
|
continue;
|
|
|
|
sa.RemoveAll();
|
|
|
|
hr=::RRASExecQry(QData, dw, sa);
|
|
|
|
if (!FHrSucceeded(hr))
|
|
{
|
|
TRACE0("RRASExexQry failed for this query\n");
|
|
continue;
|
|
}
|
|
|
|
hr = AddServersToList(sa, pNode);
|
|
|
|
if (! FHrSucceeded(hr) )
|
|
AfxMessageBox(IDS_DVS_DOMAINVIEWQRY);
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
#define ___CAN_NOT_PUT_LOCAL_MACHINE_BY_NAME_AFTER_PUT_IN_LOCAL_
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::AddServersToList
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::AddServersToList(const CStringArray& sa, ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
bool found;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spNode;
|
|
MachineNodeData *pMachineData = NULL;
|
|
|
|
// check for duplicate servernames
|
|
for (int j = 0; j < sa.GetSize(); j++)
|
|
{
|
|
found=false;
|
|
|
|
// Go through the list of nodes and check for nodes with
|
|
// the same server name.
|
|
spNodeEnum.Release();
|
|
CORg( pNode->GetEnum(&spNodeEnum) );
|
|
|
|
while ( spNodeEnum->Next(1, &spNode, NULL) == hrOK)
|
|
{
|
|
// Now get the data for this node (need to see if this is
|
|
// a machine node).
|
|
if (*(spNode->GetNodeType()) == GUID_DVSServerNodeType || *(spNode->GetNodeType()) == GUID_RouterMachineNodeType )
|
|
{
|
|
/*
|
|
DMVNodeData * pData = GET_DMVNODEDATA( spNode );
|
|
Assert(pData);
|
|
pMachineData = pData->m_spMachineData;
|
|
*/
|
|
pMachineData = GET_MACHINENODEDATA(spNode);
|
|
Assert(pMachineData);
|
|
|
|
#ifdef ___CAN_NOT_PUT_LOCAL_MACHINE_BY_NAME_AFTER_PUT_IN_LOCAL_
|
|
if (pMachineData->m_stMachineName.CompareNoCase(sa[j]) == 0 || (pMachineData->m_fLocalMachine && sa[j].IsEmpty()))
|
|
#else
|
|
if ((pMachineData->m_stMachineName.CompareNoCase(sa[j]) == 0 && !pMachineData->m_fAddedAsLocal)
|
|
|| (pMachineData->m_fAddedAsLocal && sa[j].IsEmpty()))
|
|
#endif
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
spNode.Release();
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
// add to working serverlist
|
|
m_serverlist.AddServer(sa[j]);
|
|
}
|
|
}
|
|
|
|
Error:
|
|
// this causes the unexpanded server lists to be processed
|
|
hr = OnExpand(pNode, NULL, 0, 0, 0 );
|
|
if (hr == S_OK && m_spStatusNode && m_pStatusHandler)
|
|
hr = m_pStatusHandler->OnExpand(m_spStatusNode, NULL, 0, 0, 0 );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::LoadPeristedServerList
|
|
Adds the list of persisted servers to the list of
|
|
servers to be added to the UI.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::LoadPersistedServerList()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
if ( m_ConfigStream.m_RQPersist.m_v_pSData.size() > 0 )
|
|
m_serverlist.removeall();
|
|
|
|
for (int i=0;i<m_ConfigStream.m_RQPersist.m_v_pSData.size(); i++ )
|
|
{
|
|
m_serverlist.AddServer( *(m_ConfigStream.m_RQPersist.m_v_pSData[i]) );
|
|
}
|
|
}
|
|
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::LoadPersistedServerListFromNode
|
|
Reloads the persisted server list.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::LoadPersistedServerListFromNode()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spNode;
|
|
SPITFSNode spRootNode;
|
|
MachineNodeData *pMachineData = NULL;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// Remove all servers from the of persisted list of servers
|
|
m_ConfigStream.m_RQPersist.removeAllSrv();
|
|
|
|
CORg(m_spNodeMgr->GetRootNode(&spRootNode));
|
|
// replace with above (weijiang) -- using NodeMgr
|
|
//CORg( m_spStatusNode->GetParent(&spRootNode) );
|
|
|
|
// Go through the list of nodes and check for nodes with
|
|
// the same server name.
|
|
CORg( spRootNode->GetEnum(&spNodeEnum) );
|
|
|
|
|
|
while ( spNodeEnum->Next(1, &spNode, NULL) == hrOK)
|
|
{
|
|
// Now get the data for this node (need to see if this is
|
|
// a machine node).
|
|
if (*(spNode->GetNodeType()) == GUID_RouterMachineNodeType)
|
|
{
|
|
//DMVNodeData * pData = GET_DMVNODEDATA( spNode );
|
|
//Assert(pData);
|
|
//pMachineData = pData->m_spMachineData;
|
|
pMachineData = GET_MACHINENODEDATA(spNode);
|
|
Assert(pMachineData);
|
|
|
|
CString str;
|
|
if(!pMachineData->m_fAddedAsLocal)
|
|
str = pMachineData->m_stMachineName;
|
|
m_ConfigStream.m_RQPersist.add_Srv( str );
|
|
}
|
|
spNode.Release();
|
|
}
|
|
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::OnCommand
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DMVRootHandler::OnCommand(ITFSNode *pNode, long nCommandId,
|
|
DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT pDataObject,
|
|
DWORD dwType)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = S_OK;
|
|
RegKey regkey;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
switch ( nCommandId )
|
|
{
|
|
case IDS_DMV_MENU_ADDSVR:
|
|
Assert( pNode);
|
|
QryAddServer( pNode );
|
|
break;
|
|
case IDS_DMV_MENU_REBUILDSVRLIST:
|
|
m_serverlist.removeall();
|
|
m_spStatusNode.Release(); // wei Jiang
|
|
|
|
// delete all the other nodes
|
|
CORg(pNode->DeleteAllChildren(TRUE));
|
|
|
|
ExecServerQry( pNode);
|
|
GetConfigStream()->SetDirty(TRUE);
|
|
break;
|
|
case IDS_MENU_REFRESH_RATE:
|
|
{
|
|
CRefRateDlg refrate;
|
|
SPIRouterRefresh spServerRefresh;
|
|
SPRouterRefreshObject spStatusRefresh;
|
|
DWORD rate;
|
|
|
|
if(FAILED(GetServerNodesRefreshObject(&spServerRefresh)))
|
|
break;
|
|
|
|
if(!spServerRefresh)
|
|
break;
|
|
|
|
spServerRefresh->GetRefreshInterval(&rate);
|
|
refrate.m_cRefRate = rate;
|
|
if (refrate.DoModal() == IDOK)
|
|
{
|
|
spServerRefresh->SetRefreshInterval(refrate.m_cRefRate);
|
|
// Summary Node
|
|
|
|
if(FAILED(GetSummaryNodeRefreshObject(&spStatusRefresh)))
|
|
break;
|
|
if(!spStatusRefresh)
|
|
break;
|
|
spStatusRefresh->SetRefreshInterval(refrate.m_cRefRate);
|
|
}
|
|
GetConfigStream()->SetDirty(TRUE);
|
|
|
|
}
|
|
break;
|
|
case IDS_MENU_AUTO_REFRESH:
|
|
{
|
|
SPIRouterRefresh spServerRefresh;
|
|
SPRouterRefreshObject spStatusRefresh;
|
|
|
|
if(FAILED(GetServerNodesRefreshObject(&spServerRefresh)))
|
|
break;
|
|
|
|
if(!spServerRefresh)
|
|
break;
|
|
|
|
|
|
|
|
if (spServerRefresh->IsRefreshStarted() == hrOK)
|
|
spServerRefresh->Stop();
|
|
else
|
|
{
|
|
DWORD rate;
|
|
spServerRefresh->GetRefreshInterval(&rate);
|
|
spServerRefresh->Start(rate);
|
|
}
|
|
|
|
// Summary Node
|
|
if(FAILED(GetSummaryNodeRefreshObject(&spStatusRefresh)))
|
|
break;
|
|
|
|
if(!spStatusRefresh)
|
|
break;
|
|
|
|
if (spStatusRefresh->IsRefreshStarted() == hrOK)
|
|
spStatusRefresh->Stop();
|
|
else
|
|
{
|
|
DWORD rate;
|
|
spStatusRefresh->GetRefreshInterval(&rate);
|
|
spStatusRefresh->Start(rate);
|
|
}
|
|
GetConfigStream()->SetDirty(TRUE);
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
}
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP DMVRootHandler::UserNotify(ITFSNode *pNode, LPARAM lParam, LPARAM lParam2)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
switch (lParam)
|
|
{
|
|
case DMV_DELETE_SERVER_ENTRY:
|
|
{
|
|
LPCTSTR pszServer = (LPCTSTR) lParam2;
|
|
m_serverlist.RemoveServer(pszServer);
|
|
}
|
|
break;
|
|
default:
|
|
hr = RootHandler::UserNotify(pNode, lParam, lParam2);
|
|
break;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT DMVRootHandler::UpdateAllMachineIcons(ITFSNode* pRootNode)
|
|
{
|
|
SPITFSNodeEnum spMachineEnum;
|
|
SPITFSNode spMachineNode;
|
|
SPITFSNodeHandler spNodeHandler;
|
|
HRESULT hr = S_OK;
|
|
|
|
pRootNode->GetEnum(&spMachineEnum);
|
|
while(hr == hrOK && spMachineEnum->Next(1, &spMachineNode, NULL) == hrOK)
|
|
{
|
|
if ((*spMachineNode->GetNodeType()) == GUID_RouterMachineNodeType)
|
|
{
|
|
spNodeHandler.Release();
|
|
spMachineNode->GetHandler(&spNodeHandler);
|
|
hr = spNodeHandler->UserNotify(spMachineNode, MACHINE_SYNCHRONIZE_ICON, NULL);
|
|
}
|
|
spMachineNode.Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
BaseRouterHandler::OnResultContextHelp
|
|
-
|
|
Author: MikeG (a-migall)
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::OnResultContextHelp(ITFSComponent * pComponent,
|
|
LPDATAOBJECT pDataObject,
|
|
MMC_COOKIE cookie,
|
|
LPARAM arg,
|
|
LPARAM lParam)
|
|
{
|
|
// Not used...
|
|
UNREFERENCED_PARAMETER(pDataObject);
|
|
UNREFERENCED_PARAMETER(cookie);
|
|
UNREFERENCED_PARAMETER(arg);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
return HrDisplayHelp(pComponent,
|
|
m_spTFSCompData->GetHTMLHelpFileName(),
|
|
_T("\\help\\rrasconcepts.chm::/sag_RRAStopnode.htm"));
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::AddMenuItems
|
|
Over-ride this to add our view menu item
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
DMVRootHandler::AddMenuItems
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObject,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
long * pInsertionAllowed
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = S_OK;
|
|
SPITFSNode spNode;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
// Call through to the regular OnAddMenuItems
|
|
hr = OnAddMenuItems(spNode,
|
|
pContextMenuCallback,
|
|
pDataObject,
|
|
CCT_RESULT,
|
|
TFS_COMPDATA_CHILD_CONTEXTMENU,
|
|
pInsertionAllowed);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::Command
|
|
Handles commands for the current view
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
DMVRootHandler::Command
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
int nCommandID,
|
|
LPDATAOBJECT pDataObject
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
switch (nCommandID)
|
|
{
|
|
case MMCC_STANDARD_VIEW_SELECT:
|
|
break;
|
|
|
|
default:
|
|
{
|
|
SPITFSNode spNode;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
hr = OnCommand(spNode,
|
|
nCommandID,
|
|
CCT_RESULT,
|
|
pDataObject,
|
|
TFS_COMPDATA_CHILD_CONTEXTMENU);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
DMVRootHandler::OnGetResultViewType
|
|
Return the result view that this node is going to support
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
DMVRootHandler::OnGetResultViewType
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPOLESTR * ppViewType,
|
|
long * pViewOptions
|
|
)
|
|
{
|
|
LPWSTR lpwszFormat = L"res://%s\\mprsnap.dll/welcome.htm";
|
|
LPWSTR lpwszURL = NULL;
|
|
WCHAR wszSystemDirectory[MAX_PATH+1] = {0};
|
|
|
|
GetSystemDirectoryW ( wszSystemDirectory, MAX_PATH);
|
|
//we will have a few extra bytes allocated. But that's fine
|
|
lpwszURL = (LPWSTR)CoTaskMemAlloc( ( ::lstrlen(wszSystemDirectory) + ::lstrlen(lpwszFormat) ) * sizeof(WCHAR) );
|
|
if ( lpwszURL )
|
|
{
|
|
wsprintf( lpwszURL, lpwszFormat, wszSystemDirectory );
|
|
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
|
|
*ppViewType = lpwszURL;
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
//return BaseRouterHandler::OnGetResultViewType(pComponent, cookie, ppViewType, pViewOptions);
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::OnResultSelect
|
|
Update the result message here.
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVRootHandler::OnResultSelect(ITFSComponent *pComponent,
|
|
LPDATAOBJECT pDataObject,
|
|
MMC_COOKIE cookie,
|
|
LPARAM arg,
|
|
LPARAM lParam)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spRootNode;
|
|
|
|
CORg(RootHandler::OnResultSelect(pComponent, pDataObject, cookie, arg, lParam));
|
|
|
|
CORg(m_spNodeMgr->GetRootNode(&spRootNode));
|
|
|
|
UpdateResultMessage(spRootNode);
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVRootHandler::UpdateResultMessage
|
|
Determines what (if anything) to put in the result pane message
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
void DMVRootHandler::UpdateResultMessage(ITFSNode * pNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
int nMessage = ROOT_MESSAGE_MAIN; // default
|
|
int i;
|
|
CString strTitle, strBody, strTemp;
|
|
|
|
// now build the text strings
|
|
// first entry is the title
|
|
strTitle.LoadString(g_uRootMessages[nMessage][0]);
|
|
|
|
// second entry is the icon
|
|
// third ... n entries are the body strings
|
|
|
|
for (i = 2; g_uRootMessages[nMessage][i] != 0; i++)
|
|
{
|
|
strTemp.LoadString(g_uRootMessages[nMessage][i]);
|
|
strBody += strTemp;
|
|
}
|
|
|
|
ShowMessage(pNode, strTitle, strBody, (IconIdentifier) g_uRootMessages[nMessage][1]);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// implementation of CServerList
|
|
//------------------------------------------------------------------------
|
|
|
|
HRESULT CServerList::AddServer(const CString& servername)
|
|
{
|
|
HRESULT hr=S_OK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
SPMachineNodeData spMachineData;
|
|
|
|
spMachineData = new MachineNodeData;
|
|
|
|
spMachineData->Init(servername);
|
|
m_listServerNodesToExpand.push_back(spMachineData);
|
|
spMachineData->AddRef();
|
|
|
|
m_listServerHandlersToExpand.push_back(spMachineData);
|
|
spMachineData->AddRef();
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CServerList::RemoveServer(LPCTSTR pszServerName)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
COM_PROTECT_TRY
|
|
{
|
|
list< MachineNodeData * >::iterator it;
|
|
MachineNodeData * pData = NULL;
|
|
|
|
for (it= m_listServerHandlersToExpand.begin();
|
|
it!= m_listServerHandlersToExpand.end() ; it++ )
|
|
{
|
|
pData = *it;
|
|
}
|
|
|
|
if (pData)
|
|
{
|
|
pData->Release();
|
|
m_listServerHandlersToExpand.remove(pData);
|
|
}
|
|
|
|
pData = NULL;
|
|
|
|
for (it= m_listServerNodesToExpand.begin();
|
|
it!= m_listServerNodesToExpand.end() ; it++ )
|
|
{
|
|
pData = *it;
|
|
}
|
|
|
|
if (pData)
|
|
{
|
|
pData->Release();
|
|
m_listServerNodesToExpand.remove(pData);
|
|
}
|
|
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CServerList::RemoveAllServerNodes()
|
|
{
|
|
while (!m_listServerNodesToExpand.empty())
|
|
{
|
|
m_listServerNodesToExpand.front()->Release();
|
|
m_listServerNodesToExpand.pop_front();
|
|
}
|
|
return hrOK;
|
|
}
|
|
|
|
HRESULT CServerList::RemoveAllServerHandlers()
|
|
{
|
|
while (!m_listServerHandlersToExpand.empty())
|
|
{
|
|
m_listServerHandlersToExpand.front()->Release();
|
|
m_listServerHandlersToExpand.pop_front();
|
|
}
|
|
return hrOK;
|
|
}
|
|
|
|
HRESULT CServerList::removeall()
|
|
{
|
|
HRESULT hr=S_OK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
RemoveAllServerNodes();
|
|
RemoveAllServerHandlers();
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|