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