windows-xp/Source/XPSP1/NT/admin/snapin/mycomput/compdata.cpp

// compdata.cpp : Implementation of CMyComputerComponentData

#include "stdafx.h"
#include <lmerr.h>			// For Lan Manager API error codes and return value types.
#include <lmcons.h>		// For Lan Manager API constants.
#include <lmapibuf.h>		// For NetApiBufferFree.
#include <lmdfs.h>			// For DFS APIs.
#include <lmserver.h>		// For getting a domain of a server.

#include "macros.h"
USE_HANDLE_MACROS("MMCFMGMT(compdata.cpp)")

#include "dataobj.h"
#include "compdata.h"
#include "cookie.h"
#include "snapmgr.h"
#include "stdutils.h" // IsLocalComputername
#include "chooser2.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


#include "stdcdata.cpp" // CComponentData implementation
#include "chooser2.cpp" // CHOOSER2_PickTargetComputer implementation

// Helper function to convert message in NETMSG.DLL
int DisplayNetMsgError (
        HWND hWndParent, 
		const CString& computerName, 
        NET_API_STATUS dwErr, 
        CString& displayedMessage);

//
// CMyComputerComponentData
//

CMyComputerComponentData::CMyComputerComponentData()
: m_pRootCookie( NULL )
, m_dwFlagsPersist( 0 )
, m_fAllowOverrideMachineName( FALSE )
, m_bCannotConnect (false)
, m_bMessageView (false)
{
    //
    // We must refcount the root cookie, since a dataobject for it
    // might outlive the IComponentData.  JonN 9/2/97
    //
    m_pRootCookie = new CMyComputerCookie( MYCOMPUT_COMPUTER );
    ASSERT(NULL != m_pRootCookie);
// JonN 10/27/98 All CRefcountedObject's start with refcount==1
//    m_pRootCookie->AddRef();
    SetHtmlHelpFileName (L"compmgmt.chm");
}

CMyComputerComponentData::~CMyComputerComponentData()
{
    m_pRootCookie->Release();
    m_pRootCookie = NULL;
}

DEFINE_FORWARDS_MACHINE_NAME( CMyComputerComponentData, m_pRootCookie )

CCookie& CMyComputerComponentData::QueryBaseRootCookie()
{
    ASSERT(NULL != m_pRootCookie);
	return (CCookie&)*m_pRootCookie;
}


STDMETHODIMP CMyComputerComponentData::CreateComponent(LPCOMPONENT* ppComponent)
{
	MFC_TRY;

    ASSERT(ppComponent != NULL);

    CComObject<CMyComputerComponent>* pObject;
    CComObject<CMyComputerComponent>::CreateInstance(&pObject);
    ASSERT(pObject != NULL);
	pObject->SetComponentDataPtr( (CMyComputerComponentData*)this );

    return pObject->QueryInterface(IID_IComponent,
                    reinterpret_cast<void**>(ppComponent));

	MFC_CATCH;
}

HRESULT CMyComputerComponentData::LoadIcons(LPIMAGELIST pImageList, BOOL /*fLoadLargeIcons*/)
{
	HINSTANCE hInstance = AfxGetInstanceHandle();
	ASSERT(hInstance != NULL);

	// Structure to map a Resource ID to an index of icon
	struct RESID2IICON
		{
		UINT uIconId;	// Icon resource ID
		int iIcon;		// Index of the icon in the image list
		};
	const static RESID2IICON rgzLoadIconList[] =
		{
		// Misc icons
		{ IDI_COMPUTER, iIconComputer },
		{ IDI_COMPFAIL, iIconComputerFail },
		{ IDI_SYSTEMTOOLS, iIconSystemTools },
		{ IDI_STORAGE, iIconStorage },
		{ IDI_SERVERAPPS, iIconServerApps },

		{ 0, 0} // Must be last
		};


	for (int i = 0; rgzLoadIconList[i].uIconId != 0; i++)
		{
	    HICON hIcon = LoadIcon(AfxGetInstanceHandle(),MAKEINTRESOURCE(rgzLoadIconList[i].uIconId));
		ASSERT(NULL != hIcon && "Icon ID not found in resources");
		HRESULT hr = pImageList->ImageListSetIcon((PLONG_PTR)hIcon, rgzLoadIconList[i].iIcon);
		ASSERT(SUCCEEDED(hr) && "Unable to add icon to ImageList");
		}

    return S_OK;
}


CString g_strMyComputer;
CString g_strSystemTools;
CString g_strServerApps;
CString g_strStorage;

BOOL g_fScopeStringsLoaded = FALSE;

void LoadGlobalCookieStrings()
{
	if (!g_fScopeStringsLoaded )
	{
		g_fScopeStringsLoaded = TRUE;
		VERIFY( g_strMyComputer.LoadString(IDS_SCOPE_MYCOMPUTER) );
		VERIFY( g_strSystemTools.LoadString(IDS_SCOPE_SYSTEMTOOLS) );
		VERIFY( g_strServerApps.LoadString(IDS_SCOPE_SERVERAPPS) );
		VERIFY( g_strStorage.LoadString(IDS_SCOPE_STORAGE) );
	}
}

// returns TRUE iff the child nodes should be added
// CODEWORK this is probably no longer necessary, we always return true
bool CMyComputerComponentData::ValidateMachine(const CString &sName, bool bDisplayErr)
{
	CWaitCursor			waitCursor;
	int					iRetVal = IDYES;
	SERVER_INFO_101*	psvInfo101 = 0;
	DWORD				dwr = ERROR_SUCCESS;
	DWORD				dwServerType = SV_TYPE_NT;

	m_bMessageView = false;

	// passed-in name is not the same as local machine
	if ( !IsLocalComputername(sName) )
	{
		dwr = ::NetServerGetInfo((LPTSTR)(LPCTSTR)sName,
				101, (LPBYTE*)&psvInfo101);
		if (dwr == ERROR_SUCCESS)
		{
			ASSERT( NULL != psvInfo101 );
			dwServerType = psvInfo101->sv101_type;
			::NetApiBufferFree (psvInfo101);
		}
		if (bDisplayErr && (dwr != ERROR_SUCCESS || !(SV_TYPE_NT & dwServerType)) )
		{
			CString	computerName (sName);

			if ( computerName.IsEmpty () )
			{
				DWORD	dwSize = MAX_COMPUTERNAME_LENGTH + 1 ;
				VERIFY (::GetComputerName (
						computerName.GetBufferSetLength (dwSize),
						&dwSize));
				computerName.ReleaseBuffer ();
			}
			else
			{
				// Strip off the leading whack-whack
				if ( computerName.Find (L"\\\\") == 0 )
				{
					computerName = computerName.GetBuffer (computerName.GetLength ()) + 2;
					computerName.ReleaseBuffer ();
				}
			}

			CString	text;
			CString	caption;
			bool	bMessageDisplayed = false;

			switch (dwr)
			{
			case ERROR_NETWORK_UNREACHABLE:
				text.FormatMessage (IDS_CANT_CONNECT_TO_MACHINE_NETWORK_UNREACHABLE,
						computerName);
				break;

			case ERROR_NETNAME_DELETED:
				text.FormatMessage (IDS_CANT_CONNECT_TO_MACHINE_NETNAME_DELETED,
						computerName);
				break;

			case ERROR_SUCCESS:
				ASSERT( !(SV_TYPE_NT & dwServerType) );
				text.FormatMessage (IDS_CANT_CONNECT_TO_NON_NT_COMPUTER,
						computerName);
				dwr = ERROR_BAD_NETPATH;
				break;

			case ERROR_ACCESS_DENIED:
				// We will interpret this as success.
				return true;

			case ERROR_BAD_NETPATH:
			default:
				{
					HWND	hWndParent = 0;
					m_pConsole->GetMainWindow (&hWndParent);
					iRetVal = DisplayNetMsgError (hWndParent, computerName, 
							dwr, m_strMessageViewMsg);
					bMessageDisplayed = true;
					m_bMessageView = true;
					return false;
				}
				break;
			}


			if ( !bMessageDisplayed )
			{
				VERIFY (caption.LoadString (IDS_TASKPADTITLE_COMPUTER));
				m_pConsole->MessageBox (text, caption,
						MB_ICONINFORMATION | MB_YESNO, &iRetVal);
			}
		}
	}

	if (IDYES != iRetVal)
	{
		// revert to local computer focus
		QueryRootCookie().SetMachineName (L"");

		// Set the persistent name.  If we are managing the local computer
		// this name should be empty.
		m_strMachineNamePersist = L"";

		VERIFY (SUCCEEDED (ChangeRootNodeName (L"")) );
		iRetVal = IDYES;
		dwr = ERROR_SUCCESS;
	}


	m_bCannotConnect = (ERROR_SUCCESS != dwr);

	// Change root node icon
	SCOPEDATAITEM item;
	::ZeroMemory (&item, sizeof (SCOPEDATAITEM));
	item.mask = SDI_IMAGE | SDI_OPENIMAGE;
	item.nImage = (m_bCannotConnect) ? iIconComputerFail : iIconComputer;
	item.nOpenImage = item.nImage;
	item.ID = QueryBaseRootCookie ().m_hScopeItem;
	VERIFY (SUCCEEDED (m_pConsoleNameSpace->SetItem (&item)));

	return true;
}

HRESULT CMyComputerComponentData::OnNotifyExpand(LPDATAOBJECT lpDataObject, BOOL bExpanding, HSCOPEITEM hParent)
{
	ASSERT( NULL != lpDataObject &&
	        NULL != hParent &&
			NULL != m_pConsoleNameSpace );

	if (!bExpanding)
		return S_OK;

	//
	// CODEWORK This code will not work if My Computer becomes an extension,
	// since the RawCookie format will not be available.
	// WARNING cookie cast
	//
	CCookie* pBaseParentCookie = NULL;
	HRESULT hr = ExtractData( lpDataObject,
		                      CMyComputerDataObject::m_CFRawCookie,
							  reinterpret_cast<PBYTE>(&pBaseParentCookie),
							  sizeof(pBaseParentCookie) );
	ASSERT( SUCCEEDED(hr) );
	CMyComputerCookie* pParentCookie = ActiveCookie(pBaseParentCookie);
	ASSERT( NULL != pParentCookie );

	// save the HSCOPEITEM of the root node
	if ( NULL == pParentCookie->m_hScopeItem )
	{
		pParentCookie->m_hScopeItem = hParent;

		// Ensure root node name is formatted correctly.
		CString	machineName	= pParentCookie->QueryNonNULLMachineName ();

		hr = ChangeRootNodeName (machineName);
	}
	else
	{
		ASSERT( pParentCookie->m_hScopeItem == hParent );
	}

	switch ( pParentCookie->m_objecttype )
	{
		// This node type has a child
		case MYCOMPUT_COMPUTER:
			break;

		// This node type has no children in this snapin but may have dynamic extensions
		case MYCOMPUT_SERVERAPPS:
			return ExpandServerApps( hParent, pParentCookie );

		// These node types have no children
		case MYCOMPUT_SYSTEMTOOLS:
		case MYCOMPUT_STORAGE:
			return S_OK;

		default:
			TRACE( "CMyComputerComponentData::EnumerateScopeChildren bad parent type\n" );
			ASSERT( FALSE );
			return S_OK;
	}

	if ( NULL == hParent ||
		 !((pParentCookie->m_listScopeCookieBlocks).IsEmpty()) )
	{
		ASSERT(FALSE);
		return S_OK;
	}

	LoadGlobalCookieStrings();

	hr = AddScopeNodes (hParent, *pParentCookie);

	return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//
//	AddScopeNodes
//
//	Purpose: Add the nodes that appear immediately below the root node
//
///////////////////////////////////////////////////////////////////////////////
HRESULT CMyComputerComponentData::AddScopeNodes (HSCOPEITEM hParent, CMyComputerCookie& rParentCookie)
{
	if ( !(rParentCookie.m_listScopeCookieBlocks.IsEmpty()) )
	{
		return S_OK; // scope cookies already present
	}

	HRESULT	hr = S_OK;
	LPCWSTR lpcszMachineName = rParentCookie.QueryNonNULLMachineName();

	if ( ValidateMachine (lpcszMachineName, true) )
	{
		SCOPEDATAITEM tSDItem;
		::ZeroMemory(&tSDItem,sizeof(tSDItem));
		tSDItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_STATE | SDI_PARAM | SDI_PARENT;
		tSDItem.displayname = MMC_CALLBACK;
		tSDItem.relativeID = hParent;
		tSDItem.nState = 0;


		// Create new cookies


		CMyComputerCookie* pNewCookie = new CMyComputerCookie(
			MYCOMPUT_SYSTEMTOOLS,
			lpcszMachineName );
		rParentCookie.m_listScopeCookieBlocks.AddHead(
			(CBaseCookieBlock*)pNewCookie );
		// WARNING cookie cast
		tSDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pNewCookie);
		tSDItem.nImage = QueryImage( *pNewCookie, FALSE );
		tSDItem.nOpenImage = QueryImage( *pNewCookie, TRUE );
		hr = m_pConsoleNameSpace->InsertItem(&tSDItem);
		ASSERT(SUCCEEDED(hr));
		pNewCookie->m_hScopeItem = tSDItem.ID;
		ASSERT( NULL != pNewCookie->m_hScopeItem );

		pNewCookie = new CMyComputerCookie(
			MYCOMPUT_STORAGE,
			lpcszMachineName );
		rParentCookie.m_listScopeCookieBlocks.AddHead(
			(CBaseCookieBlock*)pNewCookie );
		// WARNING cookie cast
		tSDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pNewCookie);
		tSDItem.nImage = QueryImage( *pNewCookie, FALSE );
		tSDItem.nOpenImage = QueryImage( *pNewCookie, TRUE );
		hr = m_pConsoleNameSpace->InsertItem(&tSDItem);
		ASSERT(SUCCEEDED(hr));
		pNewCookie->m_hScopeItem = tSDItem.ID;
		ASSERT( NULL != pNewCookie->m_hScopeItem );

		pNewCookie = new CMyComputerCookie(
			MYCOMPUT_SERVERAPPS,
			lpcszMachineName );
		rParentCookie.m_listScopeCookieBlocks.AddHead(
			(CBaseCookieBlock*)pNewCookie );
		// WARNING cookie cast
		tSDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pNewCookie);
		tSDItem.nImage = QueryImage( *pNewCookie, FALSE );
		tSDItem.nOpenImage = QueryImage( *pNewCookie, TRUE );
		hr = m_pConsoleNameSpace->InsertItem(&tSDItem);
		ASSERT(SUCCEEDED(hr));
		pNewCookie->m_hScopeItem = tSDItem.ID;
		ASSERT( NULL != pNewCookie->m_hScopeItem );
	}
	else
		hr = S_FALSE;

	return hr;
}


HRESULT CMyComputerComponentData::OnNotifyDelete(LPDATAOBJECT /*lpDataObject*/)
{
	// CODEWORK The user hit the Delete key, I should deal with this
	return S_OK;
}


HRESULT CMyComputerComponentData::OnNotifyRelease(LPDATAOBJECT /*lpDataObject*/, HSCOPEITEM /*hItem*/)
{
	// JonN 01/26/00: COMPMGMT is never an extension
	return S_OK;
}


HRESULT CMyComputerComponentData::OnNotifyPreload(LPDATAOBJECT /*lpDataObject*/, HSCOPEITEM hRootScopeItem)
{
	ASSERT (m_fAllowOverrideMachineName);

	QueryBaseRootCookie ().m_hScopeItem = hRootScopeItem;
	CString		machineName = QueryRootCookie ().QueryNonNULLMachineName();

	return ChangeRootNodeName (machineName);
}

// global space to store the string handed back to GetDisplayInfo()
// CODEWORK should use "bstr" for ANSI-ization
CString g_strResultColumnText;

BSTR CMyComputerComponentData::QueryResultColumnText(
	CCookie& basecookieref,
	int nCol )
{
	CMyComputerCookie& cookieref = (CMyComputerCookie&)basecookieref;
#ifndef UNICODE
#error not ANSI-enabled
#endif
	switch ( cookieref.m_objecttype )
	{
		case MYCOMPUT_COMPUTER:
			if (COLNUM_COMPUTER_NAME == nCol)
				return const_cast<BSTR>(((LPCTSTR)g_strMyComputer));
			break;
		case MYCOMPUT_SYSTEMTOOLS:
			if (COLNUM_COMPUTER_NAME == nCol)
				return const_cast<BSTR>(((LPCTSTR)g_strSystemTools));
			break;
		case MYCOMPUT_SERVERAPPS:
			if (COLNUM_COMPUTER_NAME == nCol)
				return const_cast<BSTR>(((LPCTSTR)g_strServerApps));
			break;
		case MYCOMPUT_STORAGE:
			if (COLNUM_COMPUTER_NAME == nCol)
				return const_cast<BSTR>(((LPCTSTR)g_strStorage));
			break;

		default:
			TRACE( "CMyComputerComponentData::EnumerateScopeChildren bad parent type\n" );
			ASSERT( FALSE );
			break;
	}

	return L"";
}

int CMyComputerComponentData::QueryImage(CCookie& basecookieref, BOOL /*fOpenImage*/)
{
	CMyComputerCookie& cookieref = (CMyComputerCookie&)basecookieref;
	switch ( cookieref.m_objecttype )
	{
		case MYCOMPUT_COMPUTER:
			if ( m_bCannotConnect )
				return iIconComputerFail;
			else
				return iIconComputer;

		case MYCOMPUT_SYSTEMTOOLS:
			return iIconSystemTools;

		case MYCOMPUT_SERVERAPPS:
			return iIconServerApps;

		case MYCOMPUT_STORAGE:
			return iIconStorage;

		default:
			TRACE( "CMyComputerComponentData::QueryImage bad parent type\n" );
			ASSERT( FALSE );
			break;
	}
	return iIconComputer;
}


///////////////////////////////////////////////////////////////////////////////
/// IExtendPropertySheet

STDMETHODIMP CMyComputerComponentData::QueryPagesFor(LPDATAOBJECT pDataObject)
{
	MFC_TRY;

	if (NULL == pDataObject)
	{
		ASSERT(FALSE);
		return E_POINTER;
	}

	DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
	HRESULT hr = ExtractData( pDataObject, CMyComputerDataObject::m_CFDataObjectType, (PBYTE)&dataobjecttype, sizeof(dataobjecttype) );
	if ( FAILED(hr) )
		return hr;
	if (CCT_SNAPIN_MANAGER == dataobjecttype)
		return S_OK; // Snapin Manager dialog

	CCookie* pBaseParentCookie = NULL;
	hr = ExtractData( pDataObject,
	                  CMyComputerDataObject::m_CFRawCookie,
	                  reinterpret_cast<PBYTE>(&pBaseParentCookie),
	                  sizeof(pBaseParentCookie) );
	ASSERT( SUCCEEDED(hr) );
	CMyComputerCookie* pParentCookie = ActiveCookie(pBaseParentCookie);
	ASSERT( NULL != pParentCookie );
	if ( MYCOMPUT_COMPUTER == pParentCookie->m_objecttype )
		return S_OK; // allow extensibility

	return S_FALSE;

	MFC_CATCH;
}

STDMETHODIMP CMyComputerComponentData::CreatePropertyPages(
	LPPROPERTYSHEETCALLBACK pCallBack,
	LONG_PTR /*handle*/,		// This handle must be saved in the property page object to notify the parent when modified
	LPDATAOBJECT pDataObject)
{
	MFC_TRY;

	if (NULL == pCallBack || NULL == pDataObject)
	{
		ASSERT(FALSE);
		return E_POINTER;
	}

	DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
	HRESULT hr = ExtractData( pDataObject, CMyComputerDataObject::m_CFDataObjectType, (PBYTE)&dataobjecttype, sizeof(dataobjecttype) );
	if (CCT_SNAPIN_MANAGER != dataobjecttype)
	{
		CCookie* pBaseParentCookie = NULL;
		hr = ExtractData( pDataObject,
		                  CMyComputerDataObject::m_CFRawCookie,
		                  reinterpret_cast<PBYTE>(&pBaseParentCookie),
		                  sizeof(pBaseParentCookie) );
		ASSERT( SUCCEEDED(hr) );
		CMyComputerCookie* pParentCookie = ActiveCookie(pBaseParentCookie);
		ASSERT( NULL != pParentCookie );
		if ( MYCOMPUT_COMPUTER == pParentCookie->m_objecttype )
			return S_OK; // allow extensibility
		return S_FALSE;
	}

	//
	// Note that once we have established that this is a CCT_SNAPIN_MANAGER cookie,
	// we don't care about its other properties.  A CCT_SNAPIN_MANAGER cookie is
	// equivalent to a BOOL flag asking for the Node Properties page instead of a
	// managed object property page.  JonN 10/9/96
	//

	CMyComputerGeneral * pPage = new CMyComputerGeneral();
	pPage->SetCaption(IDS_SCOPE_MYCOMPUTER);

	// Initialize state of object
	ASSERT(NULL != m_pRootCookie);
	pPage->InitMachineName(m_pRootCookie->QueryTargetServer());
	pPage->SetOutputBuffers(
		OUT &m_strMachineNamePersist,
		OUT &m_fAllowOverrideMachineName,
		OUT &m_pRootCookie->m_strMachineName);	// Effective machine name

	HPROPSHEETPAGE hPage=CreatePropertySheetPage(&pPage->m_psp);
	hr = pCallBack->AddPage(hPage);
	ASSERT( SUCCEEDED(hr) );

	return S_OK;

	MFC_CATCH;
}

STDMETHODIMP CMyComputerComponentData::AddMenuItems(
                    IDataObject*          piDataObject,
                    IContextMenuCallback* piCallback,
                    long*                 pInsertionAllowed)
{
	MFC_TRY;
	TRACE_METHOD(CMyComputerComponent,AddMenuItems);
	TEST_NONNULL_PTR_PARAM(piDataObject);
	TEST_NONNULL_PTR_PARAM(piCallback);
	TEST_NONNULL_PTR_PARAM(pInsertionAllowed);
	TRACE( "CMyComputerComponentData: extending menu\n" );

	CCookie* pBaseParentCookie = NULL;
	HRESULT hr = ExtractData (piDataObject,
	                          CMyComputerDataObject::m_CFRawCookie,
	                          reinterpret_cast<PBYTE>(&pBaseParentCookie),
	                          sizeof(pBaseParentCookie) );
	if ( FAILED (hr) )
	{
		ASSERT (FALSE);
		return S_OK;
	}
	CMyComputerCookie* pCookie = ActiveCookie (pBaseParentCookie);
	if ( !pCookie )
	{
		ASSERT (FALSE);
		return S_OK;
	}

	if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_TOP )
	{
		if ( MYCOMPUT_COMPUTER == pCookie->m_objecttype &&
				QueryBaseRootCookie ().m_hScopeItem)
		{
			hr = ::LoadAndAddMenuItem (piCallback,
					IDM_CHANGE_COMPUTER_TOP, IDM_CHANGE_COMPUTER_TOP,
					CCM_INSERTIONPOINTID_PRIMARY_TOP,
					0,
					AfxGetInstanceHandle ());
		}
	}

	if ( *pInsertionAllowed & CCM_INSERTIONALLOWED_TASK )
	{
		if ( MYCOMPUT_COMPUTER == pCookie->m_objecttype &&
				QueryBaseRootCookie ().m_hScopeItem)
		{
			hr = ::LoadAndAddMenuItem (piCallback,
					IDM_CHANGE_COMPUTER_TASK, IDM_CHANGE_COMPUTER_TASK,
					CCM_INSERTIONPOINTID_PRIMARY_TASK,
					0,
					AfxGetInstanceHandle ());
		}
	}
	return hr;
	
    MFC_CATCH;
} // CMyComputerComponentData::AddMenuItems()

STDMETHODIMP CMyComputerComponentData::Command(
                    LONG            lCommandID,
                    IDataObject*    piDataObject )
{
    MFC_TRY;

    TRACE_METHOD(CMyComputerComponentData,Command);
    TEST_NONNULL_PTR_PARAM(piDataObject);
    TRACE( "CMyComputerComponentData::Command: command %ld selected\n", lCommandID );

	switch (lCommandID)
	{
	case IDM_CHANGE_COMPUTER_TASK:
	case IDM_CHANGE_COMPUTER_TOP:
		{
			ASSERT (QueryBaseRootCookie ().m_hScopeItem);
			return OnChangeComputer (piDataObject);
		}
		break;

	default:
		ASSERT(FALSE);
		break;
	}

    return S_OK;

    MFC_CATCH;

} // CMyComputerComponentData::Command()


///////////////////////////////////////////////////////////////////////////////
//
//	OnChangeComputer ()
//
//  Purpose:	Change the machine managed by the snapin
//
//	Input:		piDataObject - the selected node.  This should be the root node
//								the snapin.
//  Output:		Returns S_OK on success
//
///////////////////////////////////////////////////////////////////////////////

//      1. Launch object picker and get new computer name
//      2. Change root node text
//      3. Save new computer name to persistent name
//      4. Delete subordinate nodes
//      5. Re-add subordinate nodes
HRESULT CMyComputerComponentData::OnChangeComputer(IDataObject * piDataObject)
{
	MFC_TRY;
	HWND    hWndParent = NULL;
	HRESULT	hr = m_pConsole->GetMainWindow (&hWndParent);
	CComBSTR sbstrTargetComputer;
	//
	// JonN 12/7/99 using CHOOSER2
	//
	if ( CHOOSER2_PickTargetComputer( AfxGetInstanceHandle(),
	                                  hWndParent,
	                                  &sbstrTargetComputer ) )
	{
		CString strTargetComputer = sbstrTargetComputer;
		strTargetComputer.MakeUpper ();

		// added IsLocalComputername 1/27/99 JonN
		// If the user chooses the local computer, treat that as if they had chosen
		// "Local Computer" in Snapin Manager.  This means that there is no way to
		// reset the snapin to target explicitly at this computer without either
		// reloading the snapin from Snapin Manager, or going to a different computer.
		// When the Choose Target Computer UI is revised, we can make this more
		// consistent with Snapin Manager.
		if ( IsLocalComputername( strTargetComputer ) )
			strTargetComputer = L"";

		QueryRootCookie().SetMachineName (strTargetComputer);

		// Set the persistent name.  If we are managing the local computer
		// this name should be empty.
		m_strMachineNamePersist = strTargetComputer;

		hr = ChangeRootNodeName (strTargetComputer);
		if ( SUCCEEDED(hr) )
		{
			// Delete subordinates and re-add
			HSCOPEITEM	hRootScopeItem = QueryBaseRootCookie ().m_hScopeItem;
			MMC_COOKIE	lCookie = 0;
			HSCOPEITEM	hChild = 0;
							
			do {
				hr = m_pConsoleNameSpace->GetChildItem (hRootScopeItem,
						&hChild, &lCookie);
				if ( S_OK != hr )
					break;

				hr = m_pConsoleNameSpace->DeleteItem (hChild, TRUE);
				ASSERT (SUCCEEDED (hr));
				if ( !SUCCEEDED(hr) )
					break;

				CMyComputerCookie* pCookie =
						reinterpret_cast <CMyComputerCookie*> (lCookie);
				if ( !pCookie )
					continue;

				CMyComputerCookie&	rootCookie = QueryRootCookie();
				POSITION			pos1 = 0;
				POSITION			pos2 = 0;
				CBaseCookieBlock*	pScopeCookie = 0;

				for ( pos1 = rootCookie.m_listScopeCookieBlocks.GetHeadPosition ();
					  ( pos2 = pos1) != NULL;
											   )
				{
					pScopeCookie = rootCookie.m_listScopeCookieBlocks.GetNext (pos1);
					ASSERT (pScopeCookie);
					if ( pScopeCookie == pCookie )
					{
						rootCookie.m_listScopeCookieBlocks.RemoveAt (pos2);
						pScopeCookie->Release ();
					}
				}
			} while (S_OK == hr);

			hr = AddScopeNodes (hRootScopeItem, QueryRootCookie ());
			hr = m_pConsole->UpdateAllViews (piDataObject, 0, HINT_SELECT_ROOT_NODE);
		}
	}

	return hr;
	MFC_CATCH;
}

///////////////////////////////////////////////////////////////////////////////
//
//	ChangeRootNodeName ()
//
//  Purpose:	Change the text of the root node
//
//	Input:		newName - the new machine name that the snapin manages
//  Output:		Returns S_OK on success
//
///////////////////////////////////////////////////////////////////////////////
HRESULT CMyComputerComponentData::ChangeRootNodeName(const CString & newName)
{
	MFC_TRY;
	ASSERT (QueryBaseRootCookie ().m_hScopeItem);
	if ( !QueryBaseRootCookie ().m_hScopeItem )
		return E_UNEXPECTED;

	CString		machineName (newName);
	CString		formattedName = FormatDisplayName (machineName);


	SCOPEDATAITEM	item;
	::ZeroMemory (&item, sizeof (SCOPEDATAITEM));
	item.mask = SDI_STR;
	item.displayname = (LPTSTR) (LPCTSTR) formattedName;
	item.ID = QueryBaseRootCookie ().m_hScopeItem;

	return m_pConsoleNameSpace->SetItem (&item);
	MFC_CATCH;
}


CString FormatDisplayName(CString machineName)
{
	CString	formattedName;

	// If strDisplayName is empty, then this manages the local machine.  Get
	// the local machine name.  Then format the computer name with the snapin
	// name
	if (machineName.IsEmpty())
	{
		VERIFY (formattedName.LoadString (IDS_SCOPE_MYCOMPUTER_LOCAL_MACHINE));
	}
	else
	{
		// strip off the leading whackWhack
		if ( machineName.Find (L"\\\\") == 0 )
		{
			machineName = machineName.GetBuffer (machineName.GetLength ()) + 2;
			machineName.ReleaseBuffer ();
		}
		machineName.MakeUpper ();
		formattedName.FormatMessage (IDS_SCOPE_MYCOMPUTER_ON_MACHINE, machineName);
	}


	return formattedName;
}


int DisplayNetMsgError (HWND hWndParent, const CString& computerName, NET_API_STATUS dwErr, CString& displayedMessage)
{
	int	retVal = IDNO;

	AFX_MANAGE_STATE (AfxGetStaticModuleState ());
	LPVOID	lpMsgBuf = 0;
	HMODULE hNetMsgDLL = ::LoadLibrary (L"netmsg.dll");
	if ( hNetMsgDLL )
	{
		::FormatMessage (
				FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE,
				hNetMsgDLL,
				dwErr,
				MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
				(LPTSTR) &lpMsgBuf, 0, NULL);
			
		// Display the string.
		CString	text;
		CString	caption;
	
		text.FormatMessage (IDS_CANT_CONNECT_TO_MACHINE, (LPCWSTR) computerName, (LPTSTR) lpMsgBuf);
		VERIFY (caption.LoadString (IDS_TASKPADTITLE_COMPUTER));

		retVal = ::MessageBox (hWndParent, text, caption, MB_ICONWARNING | MB_OK);

		displayedMessage = text;

		// Free the buffer.
		::LocalFree (lpMsgBuf);

		::FreeLibrary (hNetMsgDLL);
	}

	return retVal;
}