1542 lines
45 KiB
C++
1542 lines
45 KiB
C++
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
ATLKview.cpp
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "coldlg.h" // columndlg
|
|
#include "column.h" // ComponentConfigStream
|
|
#include "rtrui.h"
|
|
#include "globals.h" // IP CB defaults
|
|
#include "resource.h"
|
|
#include "machine.h"
|
|
#include "mstatus.h"
|
|
#include "rrasqry.h"
|
|
#include "dvsview.h"
|
|
#include "cservice.h"
|
|
#include "rrasqry.h"
|
|
#include "rtrres.h"
|
|
#include "rtrutilp.h"
|
|
#include "refresh.h"
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Keep this in sync with the column ids in ATLKview.h
|
|
---------------------------------------------------------------------------*/
|
|
extern const ContainerColumnInfo s_rgDVSViewColumnInfo[];
|
|
|
|
const ContainerColumnInfo s_rgDVSViewColumnInfo[] =
|
|
{
|
|
{ IDS_DMV_COL_SERVERNAME, CON_SORT_BY_STRING, TRUE, COL_MACHINE_NAME},
|
|
{ IDS_DMV_COL_SERVERTYPE, CON_SORT_BY_STRING, TRUE, COL_BIG_STRING},
|
|
{ IDS_DMV_COL_BUILDNO, CON_SORT_BY_STRING, FALSE, COL_SMALL_NUM },
|
|
{ IDS_DMV_COL_STATE, CON_SORT_BY_STRING, TRUE, COL_STRING },
|
|
{ IDS_DMV_COL_PORTSINUSE, CON_SORT_BY_DWORD, TRUE, COL_SMALL_NUM},
|
|
{ IDS_DMV_COL_PORTSTOTAL, CON_SORT_BY_DWORD, TRUE, COL_SMALL_NUM},
|
|
{ IDS_DMV_COL_UPTIME, CON_SORT_BY_DWORD, TRUE, COL_DURATION },
|
|
};
|
|
|
|
|
|
|
|
DMVNodeData::DMVNodeData()
|
|
{
|
|
#ifdef DEBUG
|
|
StrCpyA(m_szDebug, "DMVNodeData");
|
|
#endif
|
|
}
|
|
|
|
DMVNodeData::~DMVNodeData()
|
|
{
|
|
// This will actually call Release();
|
|
m_spMachineData.Free();
|
|
}
|
|
|
|
HRESULT DMVNodeData::MergeMachineNodeData(MachineNodeData* pData)
|
|
{
|
|
if((MachineNodeData*)m_spMachineData)
|
|
m_spMachineData->Merge(*pData);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void FillInNumberData(DMVNodeData *pNodeData, UINT iIndex,DWORD dwData)
|
|
{
|
|
TCHAR szNumber[32];
|
|
|
|
FormatNumber(dwData, szNumber, DimensionOf(szNumber), FALSE);
|
|
pNodeData->m_rgData[iIndex].m_stData = szNumber;
|
|
pNodeData->m_rgData[iIndex].m_dwData = dwData;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVNodeData::InitNodeData
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVNodeData::InitDMVNodeData(ITFSNode *pNode, MachineNodeData *pMachineData)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
DMVNodeData * pData = NULL;
|
|
|
|
pData = new DMVNodeData;
|
|
Assert(pData);
|
|
|
|
pData->m_spMachineData.Free();
|
|
pData->m_spMachineData = pMachineData;
|
|
pMachineData->AddRef();
|
|
|
|
SET_DMVNODEDATA(pNode, pData);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DMVNodeData::FreeAdminNodeData
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DMVNodeData::FreeDMVNodeData(ITFSNode *pNode)
|
|
{
|
|
DMVNodeData * pData = GET_DMVNODEDATA(pNode);
|
|
delete pData;
|
|
|
|
SET_DMVNODEDATA(pNode, NULL);
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
DomainStatusHandler implementation
|
|
---------------------------------------------------------------------------*/
|
|
|
|
DomainStatusHandler::DomainStatusHandler(ITFSComponentData *pCompData)
|
|
: BaseContainerHandler(pCompData, DM_COLUMNS_DVSUM,s_rgDVSViewColumnInfo),
|
|
// m_ulConnId(0),
|
|
m_ulRefreshConnId(0),
|
|
m_ulStatsConnId(0)
|
|
{
|
|
m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
|
|
m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
|
|
m_pQData=NULL;
|
|
}
|
|
|
|
DomainStatusHandler::~DomainStatusHandler()
|
|
{
|
|
}
|
|
|
|
|
|
STDMETHODIMP DomainStatusHandler::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 if ( riid == IID_IRtrAdviseSink )
|
|
*ppv = &m_IRtrAdviseSink;
|
|
else
|
|
return BaseContainerHandler::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;
|
|
}
|
|
|
|
|
|
|
|
// assign auto refresh object from root handler
|
|
HRESULT DomainStatusHandler::SetExternalRefreshObject(RouterRefreshObject *pRefresh)
|
|
{
|
|
Assert(!m_spRefreshObject);
|
|
|
|
m_spRefreshObject = pRefresh;
|
|
if(pRefresh)
|
|
pRefresh->AddRef();
|
|
return S_OK;
|
|
};
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::DestroyHandler
|
|
Implementation of ITFSNodeHandler::DestroyHandler
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::DestroyHandler(ITFSNode *pNode)
|
|
{
|
|
if ( m_ulRefreshConnId )
|
|
{
|
|
if ( (RouterRefreshObject*)m_spRefreshObject )
|
|
m_spRefreshObject->UnadviseRefresh(m_ulRefreshConnId);
|
|
}
|
|
m_ulRefreshConnId = 0;
|
|
|
|
if ( m_ulStatsConnId )
|
|
{
|
|
if ( (RouterRefreshObject*)m_spRefreshObject )
|
|
m_spRefreshObject->UnadviseRefresh(m_ulStatsConnId);
|
|
}
|
|
m_ulStatsConnId = 0;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::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
|
|
DomainStatusHandler::HasPropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::CreatePropertyPages
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
DomainStatusHandler::CreatePropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LPDATAOBJECT pDataObject,
|
|
LONG_PTR handle,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = hrOK;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Menu data structure for our menus
|
|
---------------------------------------------------------------------------*/
|
|
|
|
ULONG DomainStatusHandler::RebuildServerFlags(const SRouterNodeMenu *pMenuData,
|
|
INT_PTR pUserData)
|
|
{
|
|
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
|
|
Assert(pData);
|
|
DWORD dw = pData->m_pConfigStream->m_RQPersist.m_v_pQData.size();
|
|
|
|
return (dw > 1) ? MF_ENABLED : MF_GRAYED;
|
|
}
|
|
|
|
|
|
static const SRouterNodeMenu s_rgDVSNodeMenu[] =
|
|
{
|
|
// Add items that go on the top menu here
|
|
{ IDS_DMV_MENU_ADDSVR, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
|
|
{ IDS_DMV_MENU_REBUILDSVRLIST, DomainStatusHandler::RebuildServerFlags,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
};
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnAddMenuItems
|
|
Implementation of ITFSNodeHandler::OnAddMenuItems
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::OnAddMenuItems(
|
|
ITFSNode *pNode,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
LPDATAOBJECT lpDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType,
|
|
long *pInsertionAllowed)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
DomainStatusHandler::SMenuData menuData;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
menuData.m_spNode.Set(pNode);
|
|
menuData.m_pConfigStream = m_pConfigStream;
|
|
|
|
hr = AddArrayOfMenuItems(pNode, s_rgDVSNodeMenu,
|
|
DimensionOf(s_rgDVSNodeMenu),
|
|
pContextMenuCallback,
|
|
*pInsertionAllowed,
|
|
reinterpret_cast<INT_PTR>(&menuData));
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnCommand
|
|
Implementation of ITFSNodeHandler::OnCommand
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::OnCommand(ITFSNode *pNode, long nCommandId,
|
|
DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT pDataObject,
|
|
DWORD dwType)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = S_OK;
|
|
RegKey regkey;
|
|
SPITFSNode spParent;
|
|
SPITFSNodeHandler spHandler;
|
|
|
|
Assert(pNode);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
switch ( nCommandId )
|
|
{
|
|
case IDS_DMV_MENU_ADDSVR:
|
|
case IDS_DMV_MENU_REBUILDSVRLIST:
|
|
pNode->GetParent(&spParent);
|
|
spParent->GetHandler(&spHandler);
|
|
spHandler->OnCommand(spParent,nCommandId,CCT_RESULT, NULL, 0);
|
|
break;
|
|
|
|
case IDS_MENU_REFRESH:
|
|
// do it in background thread
|
|
if ((RouterRefreshObject*)m_spRefreshObject )
|
|
m_spRefreshObject->Refresh();
|
|
|
|
break;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnExpand
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::OnExpand(ITFSNode *pNode,LPDATAOBJECT pDataObject, DWORD dwType, LPARAM arg,LPARAM lParam)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPIEnumInterfaceInfo spEnumIf;
|
|
SPIInterfaceInfo spIf;
|
|
SPIRtrMgrInterfaceInfo spRmIf;
|
|
SPIInfoBase spInfoBase;
|
|
|
|
Assert(m_pServerList);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
list< MachineNodeData * >::iterator it;
|
|
|
|
//iterate the lazy list for server nodes to add server handlers
|
|
for (it=m_pServerList->m_listServerHandlersToExpand.begin();
|
|
it!= m_pServerList->m_listServerHandlersToExpand.end() ; it++ )
|
|
{
|
|
AddServerNode(pNode, *it);
|
|
m_bExpanded=false;
|
|
}
|
|
|
|
// Refresh the entire status node in background thread
|
|
if((RouterRefreshObject*)m_spRefreshObject)
|
|
{
|
|
UpdateUIItems(pNode);
|
|
m_spRefreshObject->Refresh();
|
|
}
|
|
else // if no refresh object, refresh it in main thread
|
|
SynchronizeNode(pNode);
|
|
|
|
// clear the lazy list
|
|
m_pServerList->RemoveAllServerHandlers();
|
|
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
m_bExpanded = TRUE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::GetString
|
|
Implementation of ITFSNodeHandler::GetString
|
|
We don't need to do anything, since our root node is an extension
|
|
only and thus can't do anything to the node text.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(LPCTSTR) DomainStatusHandler::GetString(ITFSNode *pNode, int nCol)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
if ( m_stTitle.IsEmpty() )
|
|
m_stTitle.LoadString(IDS_DVS_SUMMARYNODE);
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return m_stTitle;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnCreateDataObject
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
SPIDataObject spdo;
|
|
CDataObject* pdo = NULL;
|
|
|
|
pdo= new CDataObject;
|
|
spdo = pdo;
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pdo->SetType(type);
|
|
pdo->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pdo->SetClsid(*(m_spTFSCompData->GetCoClassID()));
|
|
|
|
pdo->SetTFSComponentData(m_spTFSCompData);
|
|
|
|
*ppDataObject = spdo.Transfer();
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::Init
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::Init(DMVConfigStream *pConfigStream, CServerList* pSList)
|
|
{
|
|
HRESULT hr=S_OK;
|
|
|
|
m_pConfigStream = pConfigStream;
|
|
|
|
Assert(pSList);
|
|
m_pServerList=pSList;
|
|
|
|
m_bExpanded=FALSE;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::ConstructNode
|
|
Initializes the root node (sets it up).
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::ConstructNode(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
if ( pNode == NULL )
|
|
return hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// Need to initialize the data for the root node
|
|
pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_DOMAIN);
|
|
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_DOMAIN);
|
|
pNode->SetData(TFS_DATA_SCOPEID, 0);
|
|
|
|
// This is a leaf node in the scope pane
|
|
pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);
|
|
|
|
m_cookie = reinterpret_cast<LONG_PTR>(pNode);
|
|
pNode->SetData(TFS_DATA_COOKIE, m_cookie);
|
|
|
|
pNode->SetNodeType(&GUID_DomainStatusNodeType);
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::AddServerNode
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::AddServerNode(ITFSNode *pParent, MachineNodeData* pMachineData)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
Assert(pParent);
|
|
Assert(pMachineData);
|
|
|
|
DomainStatusServerHandler * pHandler;
|
|
SPITFSResultHandler spHandler;
|
|
SPITFSNode spNode;
|
|
|
|
// Create the handler for this node
|
|
pHandler = new DomainStatusServerHandler(m_spTFSCompData);
|
|
spHandler = pHandler;
|
|
CORg( pHandler->Init(pParent, m_pConfigStream) );
|
|
|
|
// Create a result item node (or a leaf node)
|
|
CORg( CreateLeafTFSNode(&spNode,
|
|
NULL,
|
|
static_cast<ITFSNodeHandler *>(pHandler),
|
|
static_cast<ITFSResultHandler *>(pHandler),
|
|
m_spNodeMgr) );
|
|
CORg( pHandler->ConstructNode(spNode, pMachineData) );
|
|
|
|
// set information for auto refresh
|
|
if(m_spRefreshObject)
|
|
{
|
|
pHandler->SetExternalRefreshObject(m_spRefreshObject);
|
|
m_spRefreshObject->AddStatusNode(this, spNode);
|
|
}
|
|
|
|
// The data for this node will be set by the SynchronizeNode() call
|
|
// in the code that calls this function.
|
|
|
|
CORg( spNode->SetVisibilityState(TFS_VIS_SHOW) );
|
|
CORg( spNode->Show() );
|
|
CORg( pParent->AddChild(spNode) );
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::AddMenuItems
|
|
Implementation of ITFSResultHandler::AddMenuItems
|
|
Use this to add commands to the context menu of the blank areas
|
|
of the result pane.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::AddMenuItems(ITFSComponent *pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObject,
|
|
LPCONTEXTMENUCALLBACK pCallback,
|
|
long *pInsertionAllowed)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spNode;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
// Call through to the regular OnAddMenuItems
|
|
hr = OnAddMenuItems(spNode,
|
|
pCallback,
|
|
pDataObject,
|
|
CCT_RESULT,
|
|
TFS_COMPDATA_CHILD_CONTEXTMENU,
|
|
pInsertionAllowed);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::Command
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusHandler::Command(ITFSComponent *pComponent,
|
|
MMC_COOKIE cookie,
|
|
int nCommandID,
|
|
LPDATAOBJECT pDataObject)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
SPITFSNode spNode;
|
|
HRESULT hr = hrOK;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
hr = OnCommand(spNode,
|
|
nCommandID,
|
|
CCT_RESULT,
|
|
pDataObject,
|
|
TFS_COMPDATA_CHILD_CONTEXTMENU);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
ImplementEmbeddedUnknown(DomainStatusHandler, IRtrAdviseSink)
|
|
|
|
STDMETHODIMP DomainStatusHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
|
|
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
|
|
{
|
|
InitPThis(DomainStatusHandler, IRtrAdviseSink);
|
|
SPITFSNode spThisNode;
|
|
SPITFSNode spRootNode;
|
|
SPITFSNodeEnum spEnumNode;
|
|
SPIEnumInterfaceInfo spEnumIf;
|
|
SPIInterfaceInfo spIf;
|
|
SPIRtrMgrInterfaceInfo spRmIf;
|
|
SPIInfoBase spInfoBase;
|
|
BOOL fPleaseAdd;
|
|
BOOL fFound;
|
|
InterfaceNodeData * pData;
|
|
HRESULT hr = hrOK;
|
|
|
|
pThis->m_spNodeMgr->FindNode(pThis->m_cookie, &spThisNode);
|
|
|
|
if ( dwObjectType == ROUTER_OBJ_RmProtIf )
|
|
{
|
|
}
|
|
else
|
|
if ( dwChangeType == ROUTER_REFRESH )
|
|
{
|
|
if ( ulConn == pThis->m_ulStatsConnId )
|
|
{
|
|
// pThis->m_ATLKGroupStats.PostRefresh();
|
|
}
|
|
else
|
|
// pThis->SynchronizeNode(spThisNode);
|
|
;
|
|
}
|
|
|
|
// update all the machine node icons
|
|
spThisNode->GetParent(&spRootNode);
|
|
hr = DMVRootHandler::UpdateAllMachineIcons(spRootNode);
|
|
|
|
|
|
//Error:
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::GetServerInfo
|
|
Gets the information for the specified summary node.
|
|
Author: FlorinT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::GetServerInfo(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr=S_OK;
|
|
DMVNodeData *pData;
|
|
MachineNodeData *pMachineData;
|
|
|
|
pData = GET_DMVNODEDATA(pNode);
|
|
Assert(pData);
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
// Do a refresh of the data in the machine node data.
|
|
pMachineData->Load();
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::SynchronizeIcon
|
|
-
|
|
Author: FlorinT
|
|
----------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::SynchronizeIcon(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
DMVNodeData *pData;
|
|
MachineNodeData *pMachineData;
|
|
DomainStatusServerHandler::SMenuData menuData;
|
|
LPARAM imageIndex;
|
|
|
|
pData = GET_DMVNODEDATA(pNode);
|
|
Assert(pData);
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
imageIndex = pMachineData->GetServiceImageIndex();
|
|
pNode->SetData(TFS_DATA_IMAGEINDEX, imageIndex);
|
|
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, imageIndex);
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::SynchronizeData
|
|
-
|
|
Author: FlorinT
|
|
----------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::SynchronizeData(ITFSNode *pNode)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = hrOK;
|
|
DMVNodeData *pData;
|
|
MachineNodeData *pMachineData;
|
|
|
|
pData = GET_DMVNODEDATA(pNode);
|
|
Assert(pData);
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
if(pMachineData->m_stMachineName.GetLength() == 0)
|
|
pData->m_rgData[DVS_SI_SERVERNAME].m_stData = GetLocalMachineName();
|
|
else
|
|
pData->m_rgData[DVS_SI_SERVERNAME].m_stData = pMachineData->m_stMachineName;
|
|
|
|
pData->m_rgData[DVS_SI_SERVERTYPE].m_stData = pMachineData->m_stServerType;
|
|
pData->m_rgData[DVS_SI_BUILDNO].m_stData = pMachineData->m_stBuildNo;
|
|
|
|
pData->m_rgData[DVS_SI_STATE].m_stData = pMachineData->m_stState;
|
|
if (pMachineData->m_fStatsRetrieved)
|
|
{
|
|
FillInNumberData(pData, DVS_SI_PORTSINUSE, pMachineData->m_dwPortsInUse);
|
|
FillInNumberData(pData, DVS_SI_PORTSTOTAL, pMachineData->m_dwPortsTotal);
|
|
|
|
if (pMachineData->m_routerType == ServerType_Rras)
|
|
{
|
|
FormatDuration(pMachineData->m_dwUpTime,
|
|
pData->m_rgData[DVS_SI_UPTIME].m_stData,
|
|
1,
|
|
FDFLAG_DAYS | FDFLAG_HOURS | FDFLAG_MINUTES);
|
|
pData->m_rgData[DVS_SI_UPTIME].m_dwData = pMachineData->m_dwUpTime;
|
|
}
|
|
else
|
|
{
|
|
// This is a non-steelhead RAS server, so we don't
|
|
// have the uptime information.
|
|
pData->m_rgData[DVS_SI_UPTIME].m_stData.LoadString(IDS_NOT_AVAILABLE);
|
|
pData->m_rgData[DVS_SI_UPTIME].m_dwData = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pData->m_rgData[DVS_SI_PORTSINUSE].m_stData = c_szDash;
|
|
pData->m_rgData[DVS_SI_PORTSINUSE].m_dwData = 0;
|
|
pData->m_rgData[DVS_SI_PORTSTOTAL].m_stData = c_szDash;
|
|
pData->m_rgData[DVS_SI_PORTSTOTAL].m_dwData = 0;
|
|
pData->m_rgData[DVS_SI_UPTIME].m_stData = c_szDash;
|
|
pData->m_rgData[DVS_SI_UPTIME].m_dwData = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::UpdateSubItemUI
|
|
-
|
|
Author: WeiJiang
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::SynchronizeSubItem(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
hr = GetServerInfo(pNode);
|
|
if (hr == hrOK)
|
|
hr = UpdateSubItemUI(pNode);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::UpdateSubItemUI
|
|
-
|
|
Author: WeiJiang
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::UpdateSubItemUI(ITFSNode *pNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
hr = SynchronizeData(pNode);
|
|
if (hr == hrOK)
|
|
hr = SynchronizeIcon(pNode);
|
|
{// update the corresponding machine node
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
pNode->ChangeNode(RESULT_PANE_CHANGE_ITEM);
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::UpdateUIItems
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::UpdateUIItems(ITFSNode *pThisNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spNode;
|
|
CWaitCursor cw;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
pThisNode->GetEnum(&spNodeEnum);
|
|
while(spNodeEnum->Next(1, &spNode, NULL) == hrOK)
|
|
{
|
|
hr = UpdateSubItemUI(spNode);
|
|
spNode.Release();
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::SynchronizeNode
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::SynchronizeNode(ITFSNode *pThisNode)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spNode;
|
|
CWaitCursor cw;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
pThisNode->GetEnum(&spNodeEnum);
|
|
while(spNodeEnum->Next(1, &spNode, NULL) == hrOK)
|
|
{
|
|
|
|
hr = SynchronizeSubItem(spNode);
|
|
if (hr == hrOK)
|
|
spNode->ChangeNode(RESULT_PANE_CHANGE_ITEM);
|
|
|
|
spNode.Release();
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::GetDVSData
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::GetDVServerData(ITFSNode *pThisNode)
|
|
{
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnResultShow
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::OnResultShow(ITFSComponent *pTFSComponent,
|
|
MMC_COOKIE cookie,
|
|
LPARAM arg,
|
|
LPARAM lParam)
|
|
{
|
|
BOOL bSelect = (BOOL) arg;
|
|
HRESULT hr = hrOK;
|
|
SPIRouterRefresh spRefresh;
|
|
SPITFSNode spNode;
|
|
|
|
BaseContainerHandler::OnResultShow(pTFSComponent, cookie, arg, lParam);
|
|
|
|
if ( bSelect )
|
|
{
|
|
hr = OnResultRefresh(pTFSComponent, NULL, cookie, arg, lParam);
|
|
}
|
|
|
|
// Un/Register for refresh advises
|
|
if ((RouterRefreshObject*)m_spRefreshObject )
|
|
{
|
|
if ( bSelect )
|
|
{
|
|
if ( m_ulRefreshConnId == 0 )
|
|
m_spRefreshObject->AdviseRefresh(&m_IRtrAdviseSink, &m_ulRefreshConnId, 0);
|
|
if ( m_ulStatsConnId == 0 )
|
|
m_spRefreshObject->AdviseRefresh(&m_IRtrAdviseSink, &m_ulStatsConnId, 0);
|
|
}
|
|
else
|
|
{
|
|
if ( m_ulRefreshConnId )
|
|
m_spRefreshObject->UnadviseRefresh(m_ulRefreshConnId);
|
|
m_ulRefreshConnId = 0;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::OnResultRefresh
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusHandler::OnResultRefresh(ITFSComponent * pComponent,
|
|
LPDATAOBJECT pDataObject,
|
|
MMC_COOKIE cookie,
|
|
LPARAM arg,
|
|
LPARAM lParam)
|
|
{
|
|
SPITFSNode spThisNode;
|
|
CWaitCursor cw;
|
|
|
|
m_spResultNodeMgr->FindNode(cookie, &spThisNode);
|
|
|
|
return OnCommand(spThisNode, IDS_MENU_REFRESH, CCT_RESULT, NULL, 0);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusHandler::CompareItems
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(int) DomainStatusHandler::CompareItems(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookieA,
|
|
MMC_COOKIE cookieB,
|
|
int nCol)
|
|
{
|
|
// Get the strings from the nodes and use that as a basis for
|
|
// comparison.
|
|
SPITFSNode spNode;
|
|
SPITFSResultHandler spResult;
|
|
|
|
m_spNodeMgr->FindNode(cookieA, &spNode);
|
|
spNode->GetResultHandler(&spResult);
|
|
return spResult->CompareItems(pComponent, cookieA, cookieB, nCol);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Class: DomainStatusServerHandler
|
|
---------------------------------------------------------------------------*/
|
|
|
|
DomainStatusServerHandler::DomainStatusServerHandler(ITFSComponentData *pCompData)
|
|
: BaseResultHandler(pCompData, DM_COLUMNS_DVSUM)
|
|
{
|
|
m_rgButtonState[MMC_VERB_DELETE_INDEX] = ENABLED;
|
|
m_bState[MMC_VERB_DELETE_INDEX] = TRUE;
|
|
|
|
// m_verbDefault = MMC_VERB_PROPERTIES;
|
|
}
|
|
|
|
DomainStatusServerHandler::~DomainStatusServerHandler()
|
|
{
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::ConstructNode
|
|
Initializes the Domain node (sets it up).
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusServerHandler::ConstructNode(ITFSNode *pNode, MachineNodeData *pMachineData)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
int i;
|
|
|
|
if ( pNode == NULL )
|
|
return hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
pNode->SetData(TFS_DATA_SCOPEID, 0);
|
|
|
|
pNode->SetData(TFS_DATA_COOKIE, reinterpret_cast<LONG_PTR>(pNode));
|
|
|
|
pNode->SetNodeType(&GUID_DVSServerNodeType);
|
|
|
|
DMVNodeData::InitDMVNodeData(pNode, pMachineData);
|
|
}
|
|
COM_PROTECT_CATCH
|
|
return hr;
|
|
}
|
|
|
|
HRESULT DomainStatusServerHandler::SetExternalRefreshObject(RouterRefreshObject *pRefresh)
|
|
{
|
|
Assert(!m_spRefreshObject); // set twice is not allowed
|
|
Assert(pRefresh);
|
|
m_spRefreshObject = pRefresh;
|
|
if(m_spRefreshObject)
|
|
m_spRefreshObject->AddRef();
|
|
|
|
return S_OK;
|
|
};
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::GetString
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(LPCTSTR) DomainStatusServerHandler::GetString(ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
int nCol)
|
|
{
|
|
Assert(m_spNodeMgr);
|
|
|
|
SPITFSNode spNode;
|
|
DMVNodeData *pData;
|
|
ConfigStream * pConfig;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
Assert(spNode);
|
|
|
|
pData = GET_DMVNODEDATA(spNode);
|
|
Assert(pData);
|
|
|
|
pComponent->GetUserData((LONG_PTR *) &pConfig);
|
|
Assert(pConfig);
|
|
|
|
return pData->m_rgData[pConfig->MapColumnToSubitem(DM_COLUMNS_DVSUM, nCol)].m_stData;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::OnCreateDataObject
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
SPIDataObject spdo;
|
|
CDataObject* pdo = NULL;
|
|
|
|
pdo= new CDataObject;
|
|
spdo = pdo;
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pdo->SetType(type);
|
|
pdo->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pdo->SetClsid(*(m_spTFSCompData->GetCoClassID()));
|
|
|
|
pdo->SetTFSComponentData(m_spTFSCompData);
|
|
|
|
*ppDataObject = spdo.Transfer();
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::OnCreateDataObject
|
|
Implementation of ITFSResultHandler::OnCreateDataObject
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::OnCreateDataObject(ITFSComponent *pComp,
|
|
MMC_COOKIE cookie,
|
|
DATA_OBJECT_TYPES type,
|
|
IDataObject **ppDataObject)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
SPIDataObject spdo;
|
|
CDataObject* pdo = NULL;
|
|
|
|
pdo= new CDataObject;
|
|
spdo = pdo;
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pdo->SetType(type);
|
|
pdo->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pdo->SetClsid(*(m_spTFSCompData->GetCoClassID()));
|
|
|
|
pdo->SetTFSComponentData(m_spTFSCompData);
|
|
|
|
*ppDataObject = spdo.Transfer();
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::RefreshInterface
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
void DomainStatusServerHandler::RefreshInterface(MMC_COOKIE cookie)
|
|
{
|
|
SPITFSNode spNode;
|
|
SPITFSNode spParent;
|
|
SPITFSNodeHandler spHandler;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
// Can't do it for a single node at this time, just refresh the
|
|
// whole thing.
|
|
spNode->GetParent(&spParent);
|
|
spParent->GetHandler(&spHandler);
|
|
|
|
spHandler->OnCommand(spParent,
|
|
IDS_MENU_REFRESH,
|
|
CCT_RESULT, NULL, 0);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::Init
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusServerHandler::Init(ITFSNode *pParent, DMVConfigStream *pConfigStream)
|
|
{
|
|
BaseResultHandler::Init(NULL, pParent);
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::DestroyResultHandler
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::DestroyResultHandler(MMC_COOKIE cookie)
|
|
{
|
|
SPITFSNode spNode;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
if((RouterRefreshObject*)m_spRefreshObject)
|
|
{
|
|
m_spRefreshObject->RemoveStatusNode(spNode);
|
|
}
|
|
|
|
DMVNodeData::FreeDMVNodeData(spNode);
|
|
|
|
CHandler::DestroyResultHandler(cookie);
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
This is the list of commands that will show up for the result pane
|
|
nodes.
|
|
---------------------------------------------------------------------------*/
|
|
struct SIPServerNodeMenu
|
|
{
|
|
ULONG m_sidMenu; // string/command id for this menu item
|
|
ULONG (DomainStatusServerHandler:: *m_pfnGetMenuFlags)(DomainStatusServerHandler::SMenuData *);
|
|
ULONG m_ulPosition;
|
|
};
|
|
|
|
static const SRouterNodeMenu s_rgServerMenu[] =
|
|
{
|
|
// Add items that go at the top here
|
|
{ IDS_MENU_RTRWIZ, DomainStatusServerHandler::QueryService,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
{ IDS_DMV_MENU_REMOVESERVICE, DomainStatusServerHandler::QueryService,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
{ IDS_DMV_MENU_REFRESH, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
{ IDS_DMV_MENU_REBUILDSVRLIST, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
{ IDS_DMV_MENU_REMOVEFROMDIR, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
|
|
{ IDS_DMV_MENU_START, DomainStatusServerHandler::QueryService,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK},
|
|
{ IDS_DMV_MENU_STOP, DomainStatusServerHandler::QueryService,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK},
|
|
{ IDS_MENU_PAUSE_SERVICE, MachineHandler::GetPauseFlags,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK },
|
|
|
|
{ IDS_MENU_RESUME_SERVICE, MachineHandler::GetPauseFlags,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK },
|
|
|
|
{ IDS_MENU_RESTART_SERVICE, MachineHandler::QueryService,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK }
|
|
};
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Use this menu for servers which we cannot connect to.
|
|
---------------------------------------------------------------------------*/
|
|
static const SRouterNodeMenu s_rgBadConnectionServerMenu[] =
|
|
{
|
|
// Add items that go at the top here
|
|
{ IDS_DMV_MENU_REFRESH, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
{ IDS_DMV_MENU_REBUILDSVRLIST, 0,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP},
|
|
};
|
|
|
|
|
|
ULONG DomainStatusServerHandler::QueryService(const SRouterNodeMenu *pMenuData,
|
|
INT_PTR pUserData)
|
|
{
|
|
// This relies on the fact that the DomainStatusServerHandler::SMenuData
|
|
// is derived from the MachineHandler::SMenuData
|
|
return MachineHandler::GetServiceFlags(pMenuData, pUserData);
|
|
}
|
|
|
|
|
|
ULONG DomainStatusServerHandler::GetPauseFlags(const SRouterNodeMenu *pMenuData,
|
|
INT_PTR pUserData)
|
|
{
|
|
// This relies on the fact that the DomainStatusServerHandler::SMenuData
|
|
// is derived from the MachineHandler::SMenuData
|
|
return MachineHandler::GetPauseFlags(pMenuData, pUserData);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::AddMenuItems
|
|
Implementation of ITFSResultHandler::AddMenuItems
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::AddMenuItems(
|
|
ITFSComponent *pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT lpDataObject,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
long *pInsertionAllowed)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
SPITFSNode spNode;
|
|
DomainStatusServerHandler::SMenuData menuData;
|
|
DMVNodeData *pData;
|
|
MachineNodeData * pMachineData;
|
|
SRouterNodeMenu * prgMenu;
|
|
DWORD cMenu;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
pData = GET_DMVNODEDATA(spNode);
|
|
Assert(pData);
|
|
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
if (pMachineData->m_machineState != machine_connected)
|
|
{
|
|
prgMenu = (SRouterNodeMenu *) s_rgBadConnectionServerMenu;
|
|
cMenu = DimensionOf(s_rgBadConnectionServerMenu);
|
|
}
|
|
else
|
|
{
|
|
prgMenu = (SRouterNodeMenu *) s_rgServerMenu;
|
|
cMenu = DimensionOf(s_rgServerMenu);
|
|
}
|
|
|
|
// Now go through and add our menu items
|
|
menuData.m_spNode.Set(spNode);
|
|
menuData.m_pMachineConfig = &(pMachineData->m_MachineConfig);
|
|
|
|
hr = AddArrayOfMenuItems(spNode,
|
|
prgMenu,
|
|
cMenu,
|
|
pContextMenuCallback,
|
|
*pInsertionAllowed,
|
|
(INT_PTR) &menuData);
|
|
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::Command
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::Command(ITFSComponent *pComponent,
|
|
MMC_COOKIE cookie,
|
|
int nCommandID,
|
|
LPDATAOBJECT pDataObject)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
SPITFSNode spNode;
|
|
SPITFSNode spNodeMach;
|
|
SPITFSNode spParent;
|
|
SPITFSResultHandler spResult;
|
|
SPITFSNodeHandler spHandler;
|
|
HRESULT hr = hrOK;
|
|
DMVNodeData *pData;
|
|
MachineNodeData * pMachineData;
|
|
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
|
|
switch ( nCommandID )
|
|
{
|
|
case IDS_DMV_MENU_REFRESH:
|
|
hr = DomainStatusHandler::SynchronizeSubItem(spNode);
|
|
|
|
case IDS_MENU_RTRWIZ:
|
|
case IDS_DMV_MENU_START:
|
|
case IDS_DMV_MENU_STOP:
|
|
case IDS_DMV_MENU_REMOVESERVICE:
|
|
case IDS_MENU_PAUSE_SERVICE:
|
|
case IDS_MENU_RESUME_SERVICE:
|
|
case IDS_MENU_RESTART_SERVICE:
|
|
pData = GET_DMVNODEDATA(spNode);
|
|
Assert(pData);
|
|
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
m_spNodeMgr->FindNode(pMachineData->m_cookie, &spNodeMach);
|
|
spNodeMach->GetHandler(&spHandler);
|
|
|
|
hr = spHandler->OnCommand(spNodeMach,nCommandID,CCT_RESULT,NULL, 0);
|
|
|
|
break;
|
|
|
|
case IDS_DMV_MENU_REBUILDSVRLIST:
|
|
// Forward the refresh request to the parent node
|
|
//$ todo : is this really needed? This should check to see what
|
|
// node has the selection.
|
|
spParent.Release();
|
|
spHandler.Release();
|
|
|
|
spNode->GetParent(&spParent);
|
|
spParent->GetHandler(&spHandler);
|
|
spHandler->OnCommand(spParent,nCommandID,CCT_RESULT, NULL, 0);
|
|
break;
|
|
|
|
case IDS_DMV_MENU_REMOVEFROMDIR:
|
|
pData = GET_DMVNODEDATA(spNode);
|
|
Assert(pData);
|
|
|
|
pMachineData = pData->m_spMachineData;
|
|
Assert(pMachineData);
|
|
|
|
hr = RRASDelRouterIdObj( pMachineData->m_stMachineName );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::HasPropertyPages
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::HasPropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
return hrFalse;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::CreatePropertyPages
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::CreatePropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LPDATAOBJECT pDataObject,
|
|
LONG_PTR handle,
|
|
DWORD dwType)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::CreatePropertyPages
|
|
Implementation of ResultHandler::CreatePropertyPages
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP DomainStatusServerHandler::CreatePropertyPages
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LPDATAOBJECT pDataObject,
|
|
LONG_PTR handle
|
|
)
|
|
{
|
|
// Forward this call onto the NodeHandler::CreatePropertyPages
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spNode;
|
|
|
|
Assert( m_spNodeMgr );
|
|
|
|
CORg( m_spNodeMgr->FindNode(cookie, &spNode) );
|
|
|
|
// Call the ITFSNodeHandler::CreatePropertyPages
|
|
hr = CreatePropertyPages(spNode, lpProvider, pDataObject, handle, 0);
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::OnResultDelete
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusServerHandler::OnResultDelete(ITFSComponent *pComponent,
|
|
LPDATAOBJECT pDataObject,
|
|
MMC_COOKIE cookie,
|
|
LPARAM arg,
|
|
LPARAM param)
|
|
{
|
|
SPITFSNode spNode;
|
|
m_spNodeMgr->FindNode(cookie, &spNode);
|
|
return OnRemoveServer(spNode);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
DomainStatusServerHandler::OnRemoveServer
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT DomainStatusServerHandler::OnRemoveServer(ITFSNode *pNode)
|
|
{
|
|
SPITFSNodeHandler spHoldHandler;
|
|
SPITFSNode spParent;
|
|
SPITFSNode spGrandParent;
|
|
SPITFSNode spthis;
|
|
SPITFSNode spMachineNode;
|
|
DMVNodeData* pData;
|
|
MachineNodeData * pMachineData;
|
|
|
|
Assert(pNode);
|
|
|
|
pNode->GetParent( &spParent );
|
|
Assert( spParent );
|
|
|
|
// Addref this node so that it won't get deleted before we're out
|
|
// of this function
|
|
spHoldHandler.Set( this );
|
|
spthis.Set( pNode );
|
|
|
|
// Look for the machine node
|
|
pData = GET_DMVNODEDATA( pNode );
|
|
Assert( pData );
|
|
pMachineData = pData->m_spMachineData;
|
|
m_spNodeMgr->FindNode(pMachineData->m_cookie, &spMachineNode);
|
|
|
|
// delete the machine node (the node in the scope pane)
|
|
spParent->GetParent( &spGrandParent );
|
|
Assert( spGrandParent );
|
|
spGrandParent->RemoveChild( spMachineNode );
|
|
|
|
// fetch & delete server node (the node in the result pane)
|
|
spParent->RemoveChild( pNode );
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(int) DomainStatusServerHandler::CompareItems(ITFSComponent * pComponent,
|
|
MMC_COOKIE cookieA,
|
|
MMC_COOKIE cookieB,
|
|
int nCol)
|
|
{
|
|
ConfigStream * pConfig;
|
|
pComponent->GetUserData((LONG_PTR *) &pConfig);
|
|
Assert(pConfig);
|
|
|
|
int nSubItem = pConfig->MapColumnToSubitem(m_ulColumnId, nCol);
|
|
|
|
|
|
if (pConfig->GetSortCriteria(m_ulColumnId, nCol) == CON_SORT_BY_DWORD)
|
|
{
|
|
SPITFSNode spNodeA, spNodeB;
|
|
DMVNodeData * pNodeDataA = NULL;
|
|
DMVNodeData * pNodeDataB = NULL;
|
|
|
|
m_spNodeMgr->FindNode(cookieA, &spNodeA);
|
|
m_spNodeMgr->FindNode(cookieB, &spNodeB);
|
|
|
|
pNodeDataA = GET_DMVNODEDATA(spNodeA);
|
|
Assert(pNodeDataA);
|
|
|
|
pNodeDataB = GET_DMVNODEDATA(spNodeB);
|
|
Assert(pNodeDataB);
|
|
|
|
// Note: if the values are both zero, we need to do
|
|
// a string comparison (to distinuguish true zero
|
|
// from a NULL data).
|
|
// e.g. "0" vs. "-"
|
|
|
|
if ((pNodeDataA->m_rgData[nSubItem].m_dwData == 0 ) &&
|
|
(pNodeDataB->m_rgData[nSubItem].m_dwData == 0))
|
|
{
|
|
return StriCmpW(GetString(pComponent, cookieA, nCol),
|
|
GetString(pComponent, cookieB, nCol));
|
|
}
|
|
else
|
|
return pNodeDataA->m_rgData[nSubItem].m_dwData -
|
|
pNodeDataB->m_rgData[nSubItem].m_dwData;
|
|
|
|
}
|
|
else
|
|
return StriCmpW(GetString(pComponent, cookieA, nCol),
|
|
GetString(pComponent, cookieB, nCol));
|
|
}
|
|
|