windows-server-2003/net/mmc/mprsnap/dmvroot.cpp

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