windows-xp/Source/XPSP1/NT/admin/snapin/dfsadmin/dfsgui/mmcroot.cpp

/*++
Module Name:

    MmcRoot.cpp

Abstract:

    This module contains the implementation for CMmcDfsRoot. This is an class 
  for MMC display related calls for the first level node(the DfsRoot nodes)
  Also contains members and method to be able to manipulate IDfsRoot object
  and add the same to the MMC Console
--*/

#include "stdafx.h"
#include <winuser.h>
#include "DfsGUI.h"
#include "Utils.h"      // For the LoadStringFromResource method
#include "MenuEnum.h"    // Contains the menu and toolbar command ids
#include "resource.h"    // For the Resource ID for strings, etc.
#include "MmcAdmin.h"    // For class CMmcDfsAdmin
#include "MmcRoot.h"
#include "MmcJP.h"      // For deleteing the child Junction points in the destructor of the root object
#include "MmcRep.h"
#include "DfsEnums.h"    // For DFS_TYPE_STANDALONE and other DfsRoot declarations
#include "AddToDfs.h"
#include "LinkFilt.h"
#include "DfsNodes.h"       // For Node GUIDs
#include "DfsWiz.h"      // For the wizard pages, CCreateDfsRootWizPage1, 2, ...
#include <lmdfs.h>
#include "permpage.h"
#include "ldaputils.h"

const int CMmcDfsRoot::m_iIMAGEINDEX = 0;
const int CMmcDfsRoot::m_iOPENIMAGEINDEX = 0;

//////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor For   _JUNCTION_LIST

JP_LIST_NODE :: JP_LIST_NODE (CMmcDfsJunctionPoint* i_pMmcJP)      
{
  pJPoint = i_pMmcJP;
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// destructor

JP_LIST_NODE :: ~JP_LIST_NODE ()
{
  SAFE_RELEASE(pJPoint);
}

CMmcDfsRoot::CMmcDfsRoot(
    IN IDfsRoot*            i_pDfsRoot,
    IN CMmcDfsAdmin*        i_pMmcDfsAdmin,
    IN LPCONSOLE2           i_lpConsole,  
    IN ULONG                i_ulLinkFilterMaxLimit, // = FILTERDFSLINKS_MAXLIMIT_DEFAULT,
    IN FILTERDFSLINKS_TYPE  i_lLinkFilterType,      // = FILTERDFSLINKS_TYPE_NO_FILTER,
    IN BSTR                 i_bstrLinkFilterName    // = NULL
    )
{
    dfsDebugOut((_T("CMmcDfsRoot::CMmcDfsRoot this=%p\n"), this));

    MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pDfsRoot);
    MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pMmcDfsAdmin);
    MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_lpConsole);

    HRESULT    hr = S_OK;
    m_DfsRoot = i_pDfsRoot;      // Save the IDfsRoot pointer
    m_pParent = i_pMmcDfsAdmin;  // Save the parent pointer
    m_lpConsole = i_lpConsole;    // Save the console pointer

    hr = m_DfsRoot->get_RootEntryPath(&m_bstrRootEntryPath);    // Get the Root entrypath.
    MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);

    hr = m_DfsRoot->get_DfsType((long *)&m_lDfsRootType);      // Get dfsroot type from the IDfsRoot
    MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);

    if (DFS_TYPE_FTDFS == m_lDfsRootType)
    {
        CComBSTR bstrDomainName;
        CComBSTR bstrDfsName;
        hr = m_DfsRoot->get_DomainName(&bstrDomainName);
        MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
        hr = m_DfsRoot->get_DfsName(&bstrDfsName);
        MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
        hr = GetDfsRootDisplayName(bstrDomainName, bstrDfsName, &m_bstrDisplayName);
        MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);

        m_bNewSchema = (S_OK == GetSchemaVersionEx(bstrDomainName, FALSE));
    } else
    {
        m_bstrDisplayName = m_bstrRootEntryPath;
        MMC_DISP_CTOR_RETURN_OUTOFMEMORY_IF_NULL((BSTR)m_bstrDisplayName);

        CComBSTR bstrServer, bstrShare;
        hr = m_DfsRoot->GetOneDfsHost(&bstrServer, &bstrShare);
        MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);

        m_bNewSchema = (S_OK == GetSchemaVersionEx(bstrServer));
    }
  
    m_lpConsoleNameSpace = NULL;

    m_CLSIDNodeType = s_guidDfsRootNodeType;
    m_bstrDNodeType = s_tchDfsRootNodeType;

    m_lRootJunctionState = DFS_JUNCTION_STATE_UNASSIGNED;

    m_ulLinkFilterMaxLimit = i_ulLinkFilterMaxLimit;
    m_lLinkFilterType = i_lLinkFilterType;
    if (i_bstrLinkFilterName)
        m_bstrLinkFilterName = i_bstrLinkFilterName;
    else
        m_bstrLinkFilterName.Empty();

    m_bShowFRS = FALSE;
}



CMmcDfsRoot::~CMmcDfsRoot(
  )
{
    // Silently close all outstanding property sheets.
    CloseAllPropertySheets(TRUE);

    // Clean up display objects of children and result pane.
    CleanScopeChildren();
    CleanResultChildren();

    if ((IReplicaSet *)m_piReplicaSet)
        m_piReplicaSet.Release();

    dfsDebugOut((_T("CMmcDfsRoot::~CMmcDfsRoot this=%p\n"), this));
}




STDMETHODIMP
CMmcDfsRoot::AddItemToScopePane(
  IN LPCONSOLENAMESPACE     i_lpConsoleNameSpace,
  IN HSCOPEITEM             i_hItemParent
  )
/*++

Routine Description:

This routine adds the current item(itself) to the Scope pane.

Arguments:

    lpConsoleNameSpace  -  The interface which tells add item to the scope pane. A callback

    hItemParent      -  The handle of the parent. The current item is added as this 
              item's child

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpConsoleNameSpace);
    RETURN_INVALIDARG_IF_NULL(i_hItemParent);

    HRESULT hr = S_OK;
    BOOL    bReplicaSetExist = FALSE;
    hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);

    if (SUCCEEDED(hr))
    {
        SCOPEDATAITEM  ScopeItemDfsRoot;
        ZeroMemory(&ScopeItemDfsRoot, sizeof(ScopeItemDfsRoot));

        ScopeItemDfsRoot.mask = SDI_IMAGE | SDI_OPENIMAGE | SDI_PARAM | SDI_STR | SDI_PARENT;
        ScopeItemDfsRoot.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
        ScopeItemDfsRoot.nOpenImage = CMmcDfsRoot::m_iOPENIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
        ScopeItemDfsRoot.lParam = reinterpret_cast<LPARAM>(this);
        ScopeItemDfsRoot.displayname = (unsigned short *) MMC_CALLBACK;
        ScopeItemDfsRoot.relativeID = i_hItemParent;

        hr = i_lpConsoleNameSpace->InsertItem(&ScopeItemDfsRoot);
        RETURN_IF_FAILED(hr);

        m_hScopeItem = ScopeItemDfsRoot.ID;

        m_lpConsoleNameSpace = i_lpConsoleNameSpace;
    }

    return S_OK;
}




STDMETHODIMP 
CMmcDfsRoot::AddMenuItems(  
  IN LPCONTEXTMENUCALLBACK  i_lpContextMenuCallback, 
  IN LPLONG                 i_lpInsertionAllowed
  )
/*++

Routine Description:

This routine adds a context menu using the ContextMenuCallback provided.

Arguments:

    lpContextMenuCallback - A callback(function pointer) that is used to add the menu items

    lpInsertionAllowed - Specifies what menus can be added and where they can be added.

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpContextMenuCallback);

    // select the node to populate m_MmcRepList
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    enum 
    {  
        IDM_CONTEXTMENU_COMMAND_MAX = IDM_ROOT_MAX,
        IDM_CONTEXTMENU_COMMAND_MIN = IDM_ROOT_MIN
    };

    LONG    lInsertionPoints [IDM_CONTEXTMENU_COMMAND_MAX - IDM_CONTEXTMENU_COMMAND_MIN + 1] = { 
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP,
                        CCM_INSERTIONPOINTID_PRIMARY_TOP
                        };
      
    BOOL    bReplicaSetExist = FALSE;
    HRESULT hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
    RETURN_IF_FAILED(hr);
    
    for (int iCommandID = IDM_CONTEXTMENU_COMMAND_MIN,iMenuResource = IDS_MENUS_ROOT_TOP_NEW_DFS_LINK;
        iCommandID <= IDM_CONTEXTMENU_COMMAND_MAX; 
        iCommandID++,iMenuResource++ )
    {
        CONTEXTMENUITEM    ContextMenuItem;  // The structure which contains menu information
        ZeroMemory(&ContextMenuItem, sizeof(ContextMenuItem));

        switch (iCommandID)
        {
        case IDM_ROOT_TOP_NEW_ROOT_REPLICA:
            {
                if (DFS_TYPE_STANDALONE == m_lDfsRootType)    
                    continue;
                break;
            }
        case IDM_ROOT_TOP_DELETE_DISPLAYED_DFS_LINKS:
            {
                if (m_MmcJPList.empty())
                    continue;
                break;
            }
        case IDM_ROOT_TOP_REPLICATION_TOPOLOGY:
            {
                if (bReplicaSetExist || (1 >= m_MmcRepList.size()) || (DFS_TYPE_STANDALONE == m_lDfsRootType))
                    continue;
                break;
            }
        case IDM_ROOT_TOP_SHOW_REPLICATION:
            {
                if (!bReplicaSetExist || m_bShowFRS)
                    continue;
                break;
            }
        case IDM_ROOT_TOP_HIDE_REPLICATION:
            {
                if (!bReplicaSetExist || !m_bShowFRS)
                    continue;
                break;
            }
        case IDM_ROOT_TOP_STOP_REPLICATION:
            {
                if (!bReplicaSetExist)
                    continue;
                break;
            }
        case IDM_ROOT_TOP_NEW_DFS_LINK:
        case IDM_ROOT_TOP_CHECK_STATUS:
        case IDM_ROOT_TOP_FILTER_DFS_LINKS:
            { // excluded when empty root container
                if (m_MmcRepList.empty())
                    continue;
                break;
            }
        }

        CComBSTR bstrMenuText;
        CComBSTR bstrStatusBarText;
        hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, NULL, &bstrStatusBarText);
        RETURN_IF_FAILED(hr);  
    
        ContextMenuItem.strName = bstrMenuText;  // Assign the menu text
        ContextMenuItem.strStatusBarText = bstrStatusBarText;  // Assign the menu help text
        ContextMenuItem.lInsertionPointID = lInsertionPoints[iCommandID - IDM_CONTEXTMENU_COMMAND_MIN];
        ContextMenuItem.lCommandID = iCommandID;

        LONG        lInsertionFlag = 0;
        switch(ContextMenuItem.lInsertionPointID)  // Checking for permission to add menus
        {
        case CCM_INSERTIONPOINTID_PRIMARY_TOP:
            lInsertionFlag = CCM_INSERTIONALLOWED_TOP;
            break;
        case CCM_INSERTIONPOINTID_PRIMARY_NEW:
            lInsertionFlag = CCM_INSERTIONALLOWED_NEW;
            break;
        case CCM_INSERTIONPOINTID_PRIMARY_TASK:
            lInsertionFlag = CCM_INSERTIONALLOWED_TASK;
            break;
        case CCM_INSERTIONPOINTID_PRIMARY_VIEW:
            lInsertionFlag = CCM_INSERTIONALLOWED_VIEW;
            break;
        default:
            break;
        }

        if (*i_lpInsertionAllowed & lInsertionFlag)
        {
            hr = i_lpContextMenuCallback->AddItem(&ContextMenuItem);
            RETURN_IF_FAILED(hr);
        }

    } // for

    return hr;
}



STDMETHODIMP 
CMmcDfsRoot::GetScopeDisplayInfo(
  IN OUT  LPSCOPEDATAITEM    io_pScopeDataItem
  )
/*++

Routine Description:

Returns the information required for MMC display for this item.

Arguments:

    i_pScopeDataItem - The ScopeItem which specifies what display information is required

--*/
{
    RETURN_INVALIDARG_IF_NULL(io_pScopeDataItem);

    HRESULT hr = S_OK;

    if (SDI_STR & io_pScopeDataItem->mask)  // MMC wants the displaystring
    {
        ULONG     ulTotalNumOfJPs = 0;
        hr = m_DfsRoot->get_CountOfDfsJunctionPoints((long*)&ulTotalNumOfJPs);
        RETURN_IF_FAILED(hr);

        if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER ||
            m_MmcJPList.size() < ulTotalNumOfJPs)
        {
            m_bstrFullDisplayName.Empty();
            hr = FormatMessageString(&m_bstrFullDisplayName,
                        0,
                        IDS_DFSROOT_DISPLAY_STRING,
                        m_bstrDisplayName);
            RETURN_IF_FAILED(hr);

            io_pScopeDataItem->displayname = m_bstrFullDisplayName;
        } else
        {
            io_pScopeDataItem->displayname = m_bstrDisplayName;
        }
    }
  
    if (SDI_IMAGE & io_pScopeDataItem->mask)  // MMC wants the image index for the item
        io_pScopeDataItem->nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;

    if (SDI_OPENIMAGE & io_pScopeDataItem->mask)  // MMC wants the image index for the item
        io_pScopeDataItem->nOpenImage = CMmcDfsRoot::m_iOPENIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;

    return hr;
}




STDMETHODIMP 
CMmcDfsRoot::GetResultDisplayInfo(
  IN OUT LPRESULTDATAITEM    io_pResultDataItem
  )
/*++

Routine Description:

Returns the information required for MMC display for this item.

Arguments:

    io_pResultDataItem - The ResultItem which specifies what display information is required

--*/
{
  RETURN_INVALIDARG_IF_NULL(io_pResultDataItem);

  if (RDI_IMAGE & io_pResultDataItem->mask)  // MMC wants the image index for the item
    io_pResultDataItem->nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;

  if (RDI_STR & io_pResultDataItem->mask)  // MMC wants the text for the item
  {    
    if (0 == io_pResultDataItem->nCol)      // Return the Dfs Root display name
      io_pResultDataItem->str = m_bstrDisplayName;
  }

  return S_OK;
}



STDMETHODIMP 
CMmcDfsRoot::Command(
  IN LONG      i_lCommandID
  ) 
/*++

Routine Description:

Action to be taken on a context menu selection or click is takes place.

Arguments:

    lCommandID - The Command ID of the menu for which action has to be taken

--*/
{ 
    HRESULT    hr = S_OK;

    switch (i_lCommandID)
    {
    case IDM_ROOT_TOP_NEW_DFS_LINK:
        hr = OnCreateNewJunctionPoint ();
        break;
    case IDM_ROOT_TOP_NEW_ROOT_REPLICA:
        hr = OnNewRootReplica();
        break;
    case IDM_ROOT_TOP_CHECK_STATUS:
        hr = OnCheckStatus();
        break;
    case IDM_ROOT_TOP_DELETE_DISPLAYED_DFS_LINKS:
        hr = OnDeleteDisplayedDfsLinks();
        break;
    case IDM_ROOT_TOP_DELETE_DFS_ROOT:      // Delete the Current dfs root
        hr = OnDeleteDfsRoot();
        break;
    case IDM_ROOT_TOP_DELETE_CONNECTION_TO_DFS_ROOT:  // "Delete Connection to Dfs Root"
        hr = OnDeleteConnectionToDfsRoot();
        break;
    case IDM_ROOT_TOP_FILTER_DFS_LINKS:
        hr = OnFilterDfsLinks();
        break;
    case IDM_ROOT_TOP_REPLICATION_TOPOLOGY:
        hr = OnNewReplicaSet();
        break;
    case IDM_ROOT_TOP_SHOW_REPLICATION:
    case IDM_ROOT_TOP_HIDE_REPLICATION:
        m_bShowFRS = !m_bShowFRS;
        hr = OnShowReplication();
        break;
    case IDM_ROOT_TOP_STOP_REPLICATION:
        hr = OnStopReplication(TRUE);
        if (FAILED(hr))
            DisplayMessageBoxForHR(hr);
        break;
    default:
        hr = E_INVALIDARG;
        break;
    }

    return hr; 
}

HRESULT CMmcDfsRoot::_InitReplicaSet()
{
    HRESULT hr = S_OK;
    if (m_lDfsRootType != DFS_TYPE_FTDFS)
        return S_FALSE;  // no replica set associate with standalone root

    BOOL bReplicaSetExist = FALSE;
    CComBSTR bstrDC;
    hr = m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);
    RETURN_IF_FAILED(hr);

    if (!bReplicaSetExist)
    {
        if ((IReplicaSet *)m_piReplicaSet)
            m_piReplicaSet.Release();

        return S_FALSE;  // no replica set associate with it
    }

    if ((IReplicaSet *)m_piReplicaSet)
    {
        CComBSTR bstrTargetedDC;
        hr = m_piReplicaSet->get_TargetedDC(&bstrTargetedDC);
        if (FAILED(hr) || lstrcmpi(bstrTargetedDC, bstrDC))
        {
            // something is wrong or we're using a different DC, re-init m_piReplicaSet
            m_piReplicaSet.Release();
        }
    }

    if (!m_piReplicaSet)
    {
        CComBSTR bstrDomain;
        hr = m_DfsRoot->get_DomainName(&bstrDomain);
        RETURN_IF_FAILED(hr);

        CComBSTR bstrReplicaSetDN;
        hr = m_DfsRoot->get_ReplicaSetDN(&bstrReplicaSetDN);
        RETURN_IF_FAILED(hr);

        //
        // read info of the replica set from DS
        //
        hr = CoCreateInstance(CLSID_ReplicaSet, NULL, CLSCTX_INPROC_SERVER, IID_IReplicaSet, (void**) &m_piReplicaSet);
        RETURN_IF_FAILED(hr);

        hr = m_piReplicaSet->Initialize(bstrDomain, bstrReplicaSetDN);
        if (FAILED(hr))
        {
            m_piReplicaSet.Release();
            return hr;
        }
    }

    return hr;
}

HRESULT CMmcDfsRoot::OnNewReplicaSet()
{
    //
    // refresh to pick up possible namespace updates on targets by others
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    BOOL    bReplicaSetExist = FALSE;
    m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
    if (bReplicaSetExist) // replica set exist, return
        return S_OK;

    CComBSTR bstrDomain;
    hr = m_DfsRoot->get_DomainName(&bstrDomain);
    RETURN_IF_FAILED(hr);

    CComBSTR bstrReplicaSetDN;
    hr = m_DfsRoot->get_ReplicaSetDN(&bstrReplicaSetDN);
    RETURN_IF_FAILED(hr);

    CNewReplicaSet      ReplicaSetInfo;
    hr = ReplicaSetInfo.Initialize(bstrDomain, bstrReplicaSetDN, &m_MmcRepList);
    RETURN_IF_FAILED(hr);
    
    CNewReplicaSetPage0      WizPage0;
    CNewReplicaSetPage1      WizPage1(&ReplicaSetInfo);
    CNewReplicaSetPage2      WizPage2(&ReplicaSetInfo, IsNewSchema());
    //CNewReplicaSetPage3      WizPage3(&ReplicaSetInfo);

    CComPtr<IPropertySheetCallback>  pPropSheetCallback;  // MMC Callback used to add pages
    hr = m_lpConsole->QueryInterface(IID_IPropertySheetCallback, reinterpret_cast<void**>(&pPropSheetCallback));
    RETURN_IF_FAILED(hr);

    CComPtr<IPropertySheetProvider>  pPropSheetProvider;  // MMC callback used to handle wizard
    hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
    RETURN_IF_FAILED(hr);

    //
    // Create the wizard
    //
    hr = pPropSheetProvider->CreatePropertySheet(  
                                _T(""), // title
                                FALSE,  // Wizard and not property sheet.
                                0,      // Cookie
                                NULL,   // IDataobject
                                MMC_PSO_NEWWIZARDTYPE);  // Creation flags

    RETURN_IF_FAILED(hr);

    hr = pPropSheetCallback->AddPage(WizPage0.Create());
    RETURN_IF_FAILED(hr);
    hr = pPropSheetCallback->AddPage(WizPage1.Create());
    RETURN_IF_FAILED(hr);
    hr = pPropSheetCallback->AddPage(WizPage2.Create());
    RETURN_IF_FAILED(hr);
    /*hr = pPropSheetCallback->AddPage(WizPage3.Create());
    RETURN_IF_FAILED(hr); */

    // Ask the provider to use the pages from the callback
    hr = pPropSheetProvider->AddPrimaryPages(
                                //(IComponentData *)(m_pParent->m_pScopeManager),
                                NULL,
                                TRUE,    // Don't create a notify handle
                                NULL, 
                                TRUE    // Scope pane (not result pane)
                                );
    RETURN_IF_FAILED(hr);

    //
    // Display the wizard
    //
    HWND hwndParent = NULL;
    hr = m_lpConsole->GetMainWindow(&hwndParent);
    RETURN_IF_FAILED(hr);

    hr = pPropSheetProvider->Show((LONG_PTR)hwndParent, 0);
    RETURN_IF_FAILED(hr);

    //
    // handle th result
    //
    if (S_OK == ReplicaSetInfo.m_hr)
    {
        //
        // store the interface pointer
        //
        m_piReplicaSet = ReplicaSetInfo.m_piReplicaSet;
        m_DfsRoot->put_ReplicaSetExist(TRUE);

        //
        // update icon
        //
        SCOPEDATAITEM      ScopeDataItem;
        ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
        ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
        ScopeDataItem.ID = m_hScopeItem;

        hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
        RETURN_IF_FAILED(hr);

        if (SUCCEEDED(hr))
        {
            ScopeDataItem.nImage += 4;
            ScopeDataItem.nOpenImage += 4;
            hr = m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
        }

        m_lpConsole->SelectScopeItem(m_hScopeItem);
    }

    return hr;
}

HRESULT CMmcDfsRoot::OnShowReplication()
{
    BOOL bShowFRS = m_bShowFRS; // save it because refresh will reset it to FALSE

    //
    // refresh to pick up possible namespace updates on targets by others
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    DFS_REPLICA_LIST::iterator i;
    if (bShowFRS)
    {
        //
        // init m_piReplicaSet
        //
        hr = _InitReplicaSet();
        if (S_OK != hr) // no replica set, do nothing and return
            return S_OK;

        //
        // fill in each alternate m_bstrFRSColumnText and m_bstrStatusText
        //
        for (i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
        {
            ((*i)->pReplica)->ShowReplicationInfo(m_piReplicaSet);
        }

        m_bShowFRS = TRUE;
    }

    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);

    m_lpConsole->SelectScopeItem(m_hScopeItem);

    return hr;
}

HRESULT 
CMmcDfsRoot::OnStopReplication(BOOL bConfirm /* = FALSE */)
{
    //
    // refresh to pick up possible namespace updates on targets by others
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    BOOL    bReplicaSetExist = FALSE;
    m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
    if (!bReplicaSetExist) // replica set doesn't exist, return
        return S_OK;

    if (bConfirm)
    {
        hr = ConfirmOperationOnDfsRoot(IDS_MSG_STOP_REPLICATION);
        if (S_OK != hr) return hr;
    }

    //
    // init m_piReplicaSet
    //
    hr = _InitReplicaSet();
    if (S_OK != hr) // no replica set, return
        return hr;

    hr = m_piReplicaSet->Delete();
    if (SUCCEEDED(hr))
    {
        m_piReplicaSet.Release();
        hr = m_DfsRoot->put_ReplicaSetExist(FALSE);

        SCOPEDATAITEM     ScopeDataItem;
        ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
        ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
        ScopeDataItem.ID = m_hScopeItem;
        hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
        if (SUCCEEDED(hr))
        {
            ScopeDataItem.nImage -= 4;
            ScopeDataItem.nOpenImage -= 4;
            (void) m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
        }

        m_lpConsole->SelectScopeItem(m_hScopeItem);
    }

    return hr;
}

STDMETHODIMP 
CMmcDfsRoot::OnNewRootReplica(
  )
/*++

Routine Description:

  Action to be taken on menu command "New Root Replica Member".
  Here is a wizard is used to guide the user through the process of 
  Deciding a new server and share.
--*/
{
    // Select this node to make sure m_MmcRepList populated
    m_lpConsole->SelectScopeItem(m_hScopeItem);

  RETURN_INVALIDARG_IF_NULL((IConsole*)m_lpConsole);

  CREATEDFSROOTWIZINFO      CreateWizInfo;    // 0 initializes all members to 0. Necessary
  CreateWizInfo.pMMCAdmin = m_pParent;
  CreateWizInfo.bRootReplica = true;            // Set the flag that says this is for root replica

                  // Set the domain name and the dfs type
  HRESULT hr = m_DfsRoot->get_DomainName(&CreateWizInfo.bstrSelectedDomain);
  RETURN_IF_FAILED(hr);

  CreateWizInfo.DfsType = DFS_TYPE_FTDFS;
  hr = m_DfsRoot->get_DfsName(&CreateWizInfo.bstrDfsRootName);
  RETURN_IF_FAILED(hr);

  CCreateDfsRootWizPage4      WizPage4(&CreateWizInfo);
  CCreateDfsRootWizPage5      WizPage5(&CreateWizInfo);
  CCreateDfsRootWizPage7      WizPage7(&CreateWizInfo);

  // Get the required interfaces from IConsole2.
  CComPtr<IPropertySheetCallback>  pPropSheetCallback;  // MMC Callback used to add pages
  hr = m_lpConsole->QueryInterface(IID_IPropertySheetCallback, reinterpret_cast<void**>(&pPropSheetCallback));
  RETURN_IF_FAILED(hr);

  CComPtr<IPropertySheetProvider>  pPropSheetProvider;  // MMC callback used to handle wizard
  hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
  RETURN_IF_FAILED(hr);

  // Create the wizard
  hr = pPropSheetProvider->CreatePropertySheet(  
                _T(""),          // Property sheet title. Should not be null so send empty string.
                FALSE,          // Wizard and not property sheet.
                0,            // Cookie
                NULL,          // IDataobject
                MMC_PSO_NEWWIZARDTYPE);  // Creation flags

  RETURN_IF_FAILED(hr);


  // Create the pages for the wizard. Use the handle return to add to our wizard
  hr = pPropSheetCallback->AddPage(WizPage4.Create());
  RETURN_IF_FAILED(hr);
  hr = pPropSheetCallback->AddPage(WizPage5.Create());
  RETURN_IF_FAILED(hr);
  hr = pPropSheetCallback->AddPage(WizPage7.Create());
  RETURN_IF_FAILED(hr);


  _ASSERT(NULL != (m_pParent->m_pScopeManager));
  // Ask the provider to use the pages from the callback
  hr = pPropSheetProvider->AddPrimaryPages(  (IComponentData *)(m_pParent->m_pScopeManager), 
                        TRUE,    // Don't create a notify handle
                        NULL, 
                        TRUE    // Scope pane (not result pane)
                        );
  RETURN_IF_FAILED(hr);
  
  HWND              hwndMainWin = 0;  // MMC main window. Used to make it modal
  hr = m_lpConsole->GetMainWindow(&hwndMainWin);      // Get the main MMC window 
  RETURN_IF_FAILED(hr);
  
  // Display the wizard
  hr = pPropSheetProvider->Show((LONG_PTR)hwndMainWin,  // Parent window of the wizard
                  0          // Starting page
                  );  
  RETURN_IF_FAILED(hr);

  if (CreateWizInfo.bDfsSetupSuccess)
  {
      return OnRefresh(); // to pick the most recent root targets and links
  }

  return (S_OK);
}




STDMETHODIMP 
CMmcDfsRoot::SetColumnHeader(
  IN LPHEADERCTRL2     i_piHeaderControl
  )
{
    RETURN_INVALIDARG_IF_NULL(i_piHeaderControl);

    CComBSTR  bstrColumn0;
    HRESULT hr = LoadStringFromResource(IDS_RESULT_COLUMN_ROOTREPLICA, &bstrColumn0);
    RETURN_IF_FAILED(hr);

    i_piHeaderControl->InsertColumn(0, bstrColumn0, LVCFMT_LEFT, DFS_NAME_COLUMN_WIDTH);

    if (m_bShowFRS)
    {
        CComBSTR  bstrColumn1;
        hr = LoadStringFromResource(IDS_RESULT_COLUMN_FRS, &bstrColumn1);
        RETURN_IF_FAILED(hr);

        i_piHeaderControl->InsertColumn(1, bstrColumn1, LVCFMT_LEFT, MMCLV_AUTO);
    }

    return hr;
}




STDMETHODIMP 
CMmcDfsRoot::OnDeleteConnectionToDfsRoot(
  BOOLEAN              i_bForRemoveDfs
  )
/*++

Routine Description:

Used to delete the current object. Both to remove from Scope and from list

--*/
{
    // check outstanding property sheet, discontinue if any.
    HRESULT hr = CloseAllPropertySheets(FALSE);
    if (S_OK != hr)
        return hr;

    // Confirm with the user, if he wants to delete this connection
    hr = ConfirmOperationOnDfsRoot(i_bForRemoveDfs ? IDS_MSG_DELETE_DFSROOT : IDS_MSG_DELETE_CONNECTION_TO_DFSROOT);
    if (S_OK != hr) return hr;

    // select the root node
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    CWaitCursor wait;

    CleanScopeChildren();

    // Delete the item from Scope Pane
    hr = m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);
    RETURN_IF_FAILED(hr);

    // Delete it from the internal list
    hr = m_pParent->DeleteMmcRootNode(this);
    RETURN_IF_FAILED(hr);
  
    Release();  // delete this CMmcDfsRoot object

    return S_OK;
}

// Delete the node from m_MmcJPList
STDMETHODIMP
CMmcDfsRoot::DeleteMmcJPNode(
  IN CMmcDfsJunctionPoint*    i_pJPoint
  )
{
  RETURN_INVALIDARG_IF_NULL(i_pJPoint);

  dfsDebugOut((_T("CMmcDfsRoot::DeleteMmcJPNode %p, size=%d\n"), i_pJPoint, m_MmcJPList.size()));

  for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
  {
    if ((*i)->pJPoint == i_pJPoint)
    {
      m_MmcJPList.erase(i);
      break;
    }
  }

  return(S_OK);
}

HRESULT 
CMmcDfsRoot::ConfirmOperationOnDfsRoot(int idString)
/*++

Routine Description:

Used to confirm with the user, if he wants to delete the connection to the Dfs Root

Return value:

  S_OK, if the user wants to delete.
  S_FALSE, if the user decided not to continue with the operation.
--*/
{
  // Confirm delete operation
  CComBSTR  bstrAppName;
  HRESULT   hr = LoadStringFromResource(IDS_APPLICATION_NAME, &bstrAppName);
  RETURN_IF_FAILED(hr);
  
  CComBSTR  bstrFormattedMessage;
  hr = FormatResourceString(idString, m_bstrDisplayName, &bstrFormattedMessage);
  RETURN_IF_FAILED(hr);

  // Return now, if the user doesn't want to continue
  CThemeContextActivator activator;
  if (IDYES != ::MessageBox(::GetActiveWindow(), bstrFormattedMessage, bstrAppName, MB_YESNO | MB_ICONEXCLAMATION | MB_APPLMODAL))
  {
    return S_FALSE;
  }

  return S_OK;
}

HRESULT 
CMmcDfsRoot::ConfirmDeleteDisplayedDfsLinks(
  )
{
  // Confirm delete operation
  CComBSTR  bstrAppName;
  HRESULT   hr = LoadStringFromResource(IDS_APPLICATION_NAME, &bstrAppName);
  RETURN_IF_FAILED(hr);
  
  CComBSTR  bstrMessage;
  hr = LoadStringFromResource(IDS_MSG_DELETE_DISPLAYEDDFSLINKS, &bstrMessage);
  RETURN_IF_FAILED(hr);

  // Return now, if the user doesn't want to continue
  CThemeContextActivator activator;
  if (IDYES != ::MessageBox(::GetActiveWindow(), bstrMessage, bstrAppName, MB_YESNO | MB_ICONEXCLAMATION | MB_APPLMODAL))
  {
    return S_FALSE;
  }

  return S_OK;
}


STDMETHODIMP 
CMmcDfsRoot::EnumerateScopePane(
  IN LPCONSOLENAMESPACE     i_lpConsoleNameSpace,
  IN HSCOPEITEM             i_hParent
  )
/*++

Routine Description:

To eumerate(add) items in the scope pane. Junction points in this case

Arguments:

  i_lpConsoleNameSpace - The callback used to add items to the Scope pane

    i_hParent -  HSCOPEITEM of the parent under which all the items will be added.

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpConsoleNameSpace);
    RETURN_INVALIDARG_IF_NULL(i_hParent);

    HRESULT hr = m_DfsRoot->put_EnumFilterType(m_lLinkFilterType);
    RETURN_IF_FAILED(hr);

    if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
    {
        hr = m_DfsRoot->put_EnumFilter(m_bstrLinkFilterName);
        RETURN_IF_FAILED(hr);
    }

    CComPtr<IEnumVARIANT>   pJPEnum;
    hr = m_DfsRoot->get__NewEnum((IUnknown**) (&pJPEnum));
    RETURN_IF_FAILED(hr);

    hr = m_DfsRoot->get_CountOfDfsJunctionPointsFiltered((long*)&m_ulCountOfDfsJunctionPointsFiltered);
    RETURN_IF_FAILED(hr);

    VARIANT varJPObject;
    VariantInit(&varJPObject);
    ULONG   ulCount = 0;

    while ( ulCount < m_ulLinkFilterMaxLimit && S_OK == (hr = pJPEnum->Next(1, &varJPObject, NULL)) )
    {
        CComPtr<IDfsJunctionPoint>  pDfsJPObject;  
        pDfsJPObject = (IDfsJunctionPoint*) varJPObject.pdispVal;
      
                    // Create the object to be used for MMC display
        CMmcDfsJunctionPoint* pMMCJPObject = new CMmcDfsJunctionPoint (pDfsJPObject, this, i_lpConsoleNameSpace);
        if (!pMMCJPObject)
        {
            hr = E_OUTOFMEMORY;
        } else
        {
            hr = pMMCJPObject->m_hrValueFromCtor;

            if (SUCCEEDED(hr))    
                hr = pMMCJPObject->AddItemToScopePane(i_hParent);

            if (SUCCEEDED(hr))
            {
                JP_LIST_NODE *pJPList = new JP_LIST_NODE (pMMCJPObject);
                if (!pJPList)
                    hr = E_OUTOFMEMORY;
                else
                    m_MmcJPList.push_back(pJPList);
            }

            if (FAILED(hr))
                delete pMMCJPObject;
        }

        VariantClear(&varJPObject);

        if (FAILED(hr))
            break;

        ulCount++;
    }

    return hr;
}


STDMETHODIMP 
CMmcDfsRoot::SetConsoleVerbs(
  IN  LPCONSOLEVERB      i_lpConsoleVerb
  ) 
/*++

Routine Description:

  Routine used to set the console verb settings.
  Sets all of them except Open off. 
  For all scope pane items, default verb is "open'. For result items, 
  it is "properties"


Arguments:

    i_lpConsoleVerb -  The callback used to handle console verbs


--*/
{
  RETURN_INVALIDARG_IF_NULL(i_lpConsoleVerb);

  i_lpConsoleVerb->SetVerbState(MMC_VERB_COPY, HIDDEN, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_PASTE, HIDDEN, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_RENAME, HIDDEN, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_DELETE, HIDDEN, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_OPEN, HIDDEN, TRUE);
    
  i_lpConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, TRUE);
  i_lpConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, TRUE);
            
  i_lpConsoleVerb->SetDefaultVerb(MMC_VERB_OPEN); //For scope items, default verb is "open"

  return S_OK; 
}


STDMETHODIMP 
CMmcDfsRoot :: OnCreateNewJunctionPoint(
  ) 
/*++

Routine Description:

  This method handles the creation of new Junction Points.
  Display a dialog box to get the user input.

--*/
{
    CAddToDfs   AddToDfsDlg;  //Add To Dfs Dialog Object
    HRESULT     hr = AddToDfsDlg.put_ParentPath(m_bstrRootEntryPath);
    RETURN_IF_FAILED(hr);

    hr = AddToDfsDlg.DoModal();          // Display the dialog box
    RETURN_IF_NOT_S_OK(hr);

    hr = OnRefresh(); 
    if (S_FALSE == hr)
    {
        //
        // this root has been deleted by other means, scope pane has been refreshed,
        // ask user to retry
        //
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    CComBSTR bstrJPName;
    hr = AddToDfsDlg.get_JPName(&bstrJPName);
    RETURN_IF_FAILED(hr);

    CComBSTR    bstrServerName;
    hr = AddToDfsDlg.get_Server(&bstrServerName);
    RETURN_IF_FAILED(hr);

    CComBSTR    bstrShareName;
    hr = AddToDfsDlg.get_Share(&bstrShareName);
    RETURN_IF_FAILED(hr);

    CComBSTR    bstrComment;
    hr = AddToDfsDlg.get_Comment(&bstrComment);
    RETURN_IF_FAILED(hr);

    long        lTimeout = 0;
    hr = AddToDfsDlg.get_Time(&lTimeout);
    RETURN_IF_FAILED(hr);

    /* we allow interlink at the junction level
                      // Is it a Dfs based path? These are not allowed.
        if (IsDfsPath(bstrSharePath))
        {
            DisplayMessageBoxWithOK(IDS_MSG_MID_JUNCTION, bstrSharePath);    
            return(S_OK);
        }
    */

    hr = OnCreateNewJunctionPoint(bstrJPName, bstrServerName, bstrShareName, bstrComment, lTimeout);
    if (FAILED(hr))
    {
        DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_FAILED_TO_CREATE_JUNCTION_POINT);
    }

    return hr;
}




STDMETHODIMP 
CMmcDfsRoot :: OnCreateNewJunctionPoint(
  IN LPCTSTR          i_szJPName,
  IN LPCTSTR          i_szServerName,
  IN LPCTSTR          i_szShareName,
  IN LPCTSTR          i_szComment,
  IN long             i_lTimeout
  ) 
/*++

Routine Description:

  This method handles the creation of new Junction Points.
  It is called by the method that display the message box

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_szJPName);
    RETURN_INVALIDARG_IF_NULL(i_szServerName);
    RETURN_INVALIDARG_IF_NULL(i_szShareName);
    RETURN_INVALIDARG_IF_NULL(i_szComment);

    VARIANT varJPObject;
    VariantInit(&varJPObject);

    HRESULT hr = m_DfsRoot->CreateJunctionPoint(
                                            (LPTSTR)i_szJPName, 
                                            (LPTSTR)i_szServerName, 
                                            (LPTSTR)i_szShareName, 
                                            (LPTSTR)i_szComment,
                                            i_lTimeout,
                                            &varJPObject);
    RETURN_IF_FAILED(hr);

    // Add the newly created junction point to scope pane if matches the filter
    if ( m_MmcJPList.size() < m_ulLinkFilterMaxLimit &&
         FilterMatch(i_szJPName, m_lLinkFilterType, m_bstrLinkFilterName) )
    {
        m_ulCountOfDfsJunctionPointsFiltered++;

        CComPtr<IDfsJunctionPoint> pDfsJPObject = (IDfsJunctionPoint*)varJPObject.pdispVal;

                          // Create the object to be used for MMC display
        CMmcDfsJunctionPoint* pMMCJPObject = new CMmcDfsJunctionPoint(pDfsJPObject, this, m_lpConsoleNameSpace);
  
        if (!pMMCJPObject)
        {
            hr = E_OUTOFMEMORY;
        } else
        {
            hr = pMMCJPObject->m_hrValueFromCtor;

            if (SUCCEEDED(hr))
                hr = pMMCJPObject->AddItemToScopePane(m_hScopeItem);

            if (SUCCEEDED(hr))
            {
                JP_LIST_NODE* pJPList = new JP_LIST_NODE(pMMCJPObject);
                if (!pJPList)
                    hr = E_OUTOFMEMORY;
                else
                    m_MmcJPList.push_back(pJPList);
            }

                        // Select the newly added scope item.
            if (SUCCEEDED(hr))
            {
                m_lpConsole->SelectScopeItem(pMMCJPObject->m_hScopeItem);
            } else
                delete pMMCJPObject;
        }
    }

    VariantClear(&varJPObject);

    return hr;
}



STDMETHODIMP 
CMmcDfsRoot::DoDelete() 
/*++

Routine Description:

  This method allows the item to delete itself.
  Called when DEL key is pressed or when the "Delete" context menu
  item is selected.

--*/
{ 
  return OnDeleteConnectionToDfsRoot();
}




STDMETHODIMP CMmcDfsRoot::OnDeleteDfsRoot()
{
    // Select this node to make sure m_MmcRepList populated
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    // check outstanding property sheet, discontinue if any.
    HRESULT hr = CloseAllPropertySheets(FALSE);
    if (S_OK != hr)
        return hr;

    if (DFS_TYPE_STANDALONE == m_lDfsRootType)
    {
        hr = OnDeleteConnectionToDfsRoot(true);

        if (S_OK == hr)
        {
            CComBSTR bstrDfsServer;
            CComBSTR bstrRootShare;
            hr = m_DfsRoot->GetOneDfsHost(&bstrDfsServer, &bstrRootShare);

            if (SUCCEEDED(hr))
                return _DeleteDfsRoot(bstrDfsServer, bstrRootShare, NULL);
        }

        if (FAILED(hr))
            DisplayMessageBoxForHR(hr);

        return hr;
    }

    // Confirm with the user, if he wants to delete this dfs root
    hr = ConfirmOperationOnDfsRoot(IDS_MSG_DELETE_DFSROOT);
    if (S_OK != hr) return hr;

    //
    // delete the replica set associated with the root (the internal link)
    //
    hr = OnStopReplication();
    if (S_FALSE == hr)
    {
        // this root has already been deleted by others, no more reference
        // OnStopReplication has already called OnRefresh and popped up the msgbox
        return hr;
    }

    //  
    // delete the rest of replica sets related to this Dfs root
    //
    (void)m_DfsRoot->DeleteAllReplicaSets();

    //
    // remove root alternates
    //
    UINT nSize = m_MmcRepList.size();
    DFS_REPLICA_LIST::iterator i;
    while (nSize >= 1)
    {
        i = m_MmcRepList.begin();

        hr = (*i)->pReplica->RemoveReplica();
        BREAK_IF_FAILED(hr);

        nSize--;
    }

    if (FAILED(hr))
        DisplayMessageBoxForHR(hr);

    return hr;
}

STDMETHODIMP CMmcDfsRoot::OnDeleteDisplayedDfsLinks()
{
    // make sure all property pages are closed
    HRESULT hr = ClosePropertySheetsOfAllLinks(FALSE);
    if (S_OK != hr)
        return hr; // property page found, discontinue

    // Confirm with the user, if he wants to delete all the displayed dfs links
    hr = ConfirmDeleteDisplayedDfsLinks();
    if (S_OK != hr) return hr;

    //
    // refresh to pick up possible namespace updates by other means on root targets
    //
    hr = OnRefresh();
    if (S_FALSE == hr)
    {
        //
        // this root has been deleted by other means, scope pane has been refreshed,
        // ask user to retry
        //
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    ULONG ulSize = m_MmcJPList.size();

    BOOL bSetNoFilter = TRUE;
    if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
    {
        ULONG     ulNumOfJPsFiltered = 0;
        m_DfsRoot->get_CountOfDfsJunctionPointsFiltered((long*)&ulNumOfJPsFiltered);

        if (ulNumOfJPsFiltered > ulSize)
            bSetNoFilter = FALSE;
    }

    DFS_JUNCTION_LIST::iterator i;
    while (ulSize >= 1)
    {
        i = m_MmcJPList.begin();

        hr = ((*i)->pJPoint)->OnRemoveJP(FALSE);
        BREAK_IF_FAILED(hr);

        ulSize--;
    }

    if (FAILED(hr))
    {
        DisplayMessageBoxForHR(hr);
    } else
    {
        if (bSetNoFilter)
            m_lLinkFilterType = FILTERDFSLINKS_TYPE_NO_FILTER;

                // Enumerate Junction points
        (void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);

        m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
        m_lpConsole->SelectScopeItem(m_hScopeItem);
    }

    return hr;
}

STDMETHODIMP 
CMmcDfsRoot :: OnFilterDfsLinks(
  ) 
/*++

Routine Description:

  This method handles the link filter options.
  Display a dialog box to get the user input.

--*/
{
    HRESULT         hr = ClosePropertySheetsOfAllLinks(FALSE);
    if (S_OK != hr)
        return hr; // property sheet found, discontinue

    CFilterDfsLinks FilterDfsLinksDlg;
    hr = FilterDfsLinksDlg.put_EnumFilterType(m_lLinkFilterType);
    RETURN_IF_FAILED(hr);

    if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
    {
        hr = FilterDfsLinksDlg.put_EnumFilter(m_bstrLinkFilterName);
        RETURN_IF_FAILED(hr);
    }

    hr = FilterDfsLinksDlg.put_MaxLimit(m_ulLinkFilterMaxLimit);
    RETURN_IF_FAILED(hr);

    hr = FilterDfsLinksDlg.DoModal(); 
    RETURN_IF_NOT_S_OK(hr);

    CWaitCursor wait;

    ULONG ulMaxLimit = 0;
    hr = FilterDfsLinksDlg.get_MaxLimit(&ulMaxLimit);
    RETURN_IF_FAILED(hr);

    FILTERDFSLINKS_TYPE lLinkFilterType = FILTERDFSLINKS_TYPE_NO_FILTER;
    hr = FilterDfsLinksDlg.get_EnumFilterType(&lLinkFilterType);
    RETURN_IF_FAILED(hr);

    CComBSTR bstrFilterName;
    if (lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
    {
        hr = FilterDfsLinksDlg.get_EnumFilter(&bstrFilterName);
        RETURN_IF_FAILED(hr);
    }

    m_lLinkFilterType = lLinkFilterType;
    m_bstrLinkFilterName = bstrFilterName;
    m_ulLinkFilterMaxLimit = ulMaxLimit;

    dfsDebugOut((_T("m_lLinkFilterType=%d, m_bstrLinkFilterName=%s, m_ulLinkFilterMaxLimit=%d\n"),
        m_lLinkFilterType,
        m_bstrLinkFilterName,
        m_ulLinkFilterMaxLimit));

    return OnRefresh();
}

HRESULT
CMmcDfsRoot::SetDescriptionBarText(
  IN LPRESULTDATA            i_lpResultData
  )
/*++

Routine Description:

  A routine used set the text in the Description bar above 
  the result view.

Arguments:
  i_lpResultData  -  Pointer to the IResultData callback which is
            used to set the description text

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpResultData);

    CComBSTR  bstrTextForDescriptionBar;
    HRESULT   hr = FormatResourceString(IDS_DESCRIPTION_BAR_TEXT_ROOT, m_bstrDisplayName, &bstrTextForDescriptionBar);

    if (SUCCEEDED(hr))
        hr = i_lpResultData->SetDescBarText(bstrTextForDescriptionBar);

    return hr;
}

HRESULT
CMmcDfsRoot::SetStatusText(
  IN LPCONSOLE2            i_lpConsole
  )
/*++

Routine Description:

  Set the text in the Status bar.

Arguments:
  i_lpConsole  - IConsole2 from IComponent

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpConsole);

    HRESULT hr = S_OK;

    ULONG   ulTotalNumOfJPs = 0;
    hr = m_DfsRoot->get_CountOfDfsJunctionPoints((long*)&ulTotalNumOfJPs);
    RETURN_IF_FAILED(hr);

    ULONG   ulDisplayedNumOfJPs = m_MmcJPList.size();

    CComBSTR  bstrText;
    hr = FormatMessageString(&bstrText, 0,
        IDS_STATUS_BAR_TEXT_ROOT, ulDisplayedNumOfJPs, ulTotalNumOfJPs);

    if (SUCCEEDED(hr))
        hr = i_lpConsole->SetStatusText(bstrText);

    return hr;
}

STDMETHODIMP  
CMmcDfsRoot::EnumerateResultPane(
  IN OUT IResultData*      io_pResultData
  )
/*++

Routine Description:

To eumerate(add) items in the result pane. Root level Replicas in this case

Arguments:

  io_pResultData - The callback used to add items to the Result pane

--*/
{
    RETURN_INVALIDARG_IF_NULL(io_pResultData);

    HRESULT   hr = S_OK;

    if (m_MmcRepList.empty())
    {
        CComPtr<IEnumVARIANT>       pRepEnum;
        hr = m_DfsRoot->get_RootReplicaEnum((IUnknown**) &pRepEnum);
        RETURN_IF_FAILED(hr);

        VARIANT varReplicaObject;
        VariantInit(&varReplicaObject);

        while ( S_OK == (hr = pRepEnum->Next(1, &varReplicaObject, NULL)) )
        {
            CComPtr<IDfsReplica> pReplicaObject = (IDfsReplica*) varReplicaObject.pdispVal;

            CMmcDfsReplica*   pMMCReplicaObject = new CMmcDfsReplica(pReplicaObject, this);
            if (!pMMCReplicaObject)
            {
                hr = E_OUTOFMEMORY;
            } else
            {
              hr = pMMCReplicaObject->m_hrValueFromCtor;
              if (SUCCEEDED(hr))
                  hr = pMMCReplicaObject->AddItemToResultPane(io_pResultData);

              if (SUCCEEDED(hr))
                {
                    REP_LIST_NODE* pRepNode = new REP_LIST_NODE (pMMCReplicaObject);
                    if (!pRepNode)
                        hr = E_OUTOFMEMORY;
                    else
                        m_MmcRepList.push_back(pRepNode);
                }

                if (FAILED(hr))
                    delete pMMCReplicaObject;
            }

            VariantClear(&varReplicaObject);

            if (FAILED(hr))
                break;
        } // while
    }
    else
    {
                // The replicas of this junction are already enumerated,
                // and the list exists, just add result items.
        for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
        {
            hr = ((*i)->pReplica)->AddItemToResultPane(io_pResultData);
            BREAK_IF_FAILED(hr);
        }
    }

  return hr;
}

STDMETHODIMP 
CMmcDfsRoot::QueryPagesFor(
  )
/*++

Routine Description:

  Used to decide whether the object wants to display property pages.
  Returning S_OK typically results in a call to CreatePropertyPages.

--*/
{
    //
    // refresh to pick up possible namespace updates by others
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr; // no property page
    }

    return S_OK; // since we want to display a propertysheet.
}


// Creates and passes back the pages to be displayed
STDMETHODIMP 
CMmcDfsRoot::CreatePropertyPages(
  IN LPPROPERTYSHEETCALLBACK      i_lpPropSheetCallback,
  IN LONG_PTR                i_lNotifyHandle
  )
/*++

Routine Description:

  Used to display the property sheet pages

Arguments:

  i_lpPropSheetCallback  -  The callback used to create the propertysheet.
  i_lNotifyHandle      -  Notify handle used by the property page

Return value:

  S_OK since we want to display a propertysheet.

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_lpPropSheetCallback);

    m_lpConsole->SelectScopeItem(m_hScopeItem);

    CWaitCursor WaitCursor;
    HRESULT             hr = S_OK;

    do {
        hr = m_PropPage.Initialize((IDfsRoot*)m_DfsRoot, NULL);
        BREAK_IF_FAILED(hr);

                    // Create the page for the replica set.
                    // Pass it to the Callback
        HPROPSHEETPAGE  h_proppage = m_PropPage.Create();
        if (!h_proppage)
            hr = HRESULT_FROM_WIN32(::GetLastError());
        BREAK_IF_FAILED(hr);

                  // Pass on the notify data to the Property Page
        hr = m_PropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
        BREAK_IF_FAILED(hr);

        hr = i_lpPropSheetCallback->AddPage(h_proppage);
        BREAK_IF_FAILED(hr);

        //
        // Create "Replica Set" page
        //
        hr = CreateFrsPropertyPage(i_lpPropSheetCallback, i_lNotifyHandle);
        if (FAILED(hr))
        {
            DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_REPPAGE_ERROR);
            hr = S_OK; // allow the other tabs to be brought up
        }

        //
        // Create "Publish" page
        //
        hr = CreatePublishPropertyPage(i_lpPropSheetCallback, i_lNotifyHandle);
        if (FAILED(hr))
        {
            DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_PUBLISHPAGE_ERROR);
            hr = S_OK; // allow the other tabs to be brought up
        }

/*
        //
        // Create Security property page for Fault Tolerance DFS root
        //
        if (DFS_TYPE_FTDFS == m_lDfsRootType)
        {
            LPTSTR          lpszLDAPRoot = NULL;
            PLDAP           pldap = NULL;

            do {
                CComBSTR    bstrDomainName;
                hr = m_DfsRoot->get_DomainName(&bstrDomainName);
                BREAK_IF_FAILED(hr);

                CComBSTR    bstrDfsName;
                hr = m_DfsRoot->get_DfsName(&bstrDfsName);
                BREAK_IF_FAILED(hr);

                CComBSTR    bstrServerName;
                hr =  ConnectToDS(bstrDomainName, &pldap, &bstrServerName);
                BREAK_IF_FAILED(hr);
    
                hr = GetLDAPRootPath(pldap, &lpszLDAPRoot);
                BREAK_IF_FAILED(hr);

                CComBSTR bstrSystemDN;
                CComBSTR bstrDfsConfigDN;
                CComBSTR bstrFTRootDN;
                if (FAILED(hr = ExtendDN(CN_SYSTEM, lpszLDAPRoot, &bstrSystemDN)) ||
                    FAILED(hr = ExtendDN(CN_DFSCONFIGURATION, bstrSystemDN, &bstrDfsConfigDN)) ||
                    FAILED(hr = ExtendDN(bstrDfsName, bstrDfsConfigDN, &bstrFTRootDN)) )
                break;
    
                CComBSTR bstrObjectPath;
                bstrObjectPath = _T("LDAP://");
                bstrObjectPath += bstrServerName;
                bstrObjectPath += _T("/");
                bstrObjectPath += bstrFTRootDN;

                hr = CreateDfsSecurityPage(
                                            i_lpPropSheetCallback,
                                            bstrObjectPath,
                                            NULL,
                                            DSSI_IS_ROOT);
            } while (0);

            if (pldap) CloseConnectionToDS(pldap);
            if (lpszLDAPRoot) free(lpszLDAPRoot);
        }
*/
    } while (0);

    if (FAILED(hr))
        DisplayMessageBoxForHR(hr);

    return hr;
}

STDMETHODIMP 
CMmcDfsRoot::CreateFrsPropertyPage
(
  IN LPPROPERTYSHEETCALLBACK    i_lpPropSheetCallback,
  IN LONG_PTR                   i_lNotifyHandle
)
{
    //
    // init m_piReplicaSet
    //
    HRESULT hr = _InitReplicaSet();
    if (S_OK != hr) return hr;

    CComBSTR bstrType;
    hr = m_piReplicaSet->get_Type(&bstrType);
    RETURN_IF_FAILED(hr);

    if (lstrcmpi(bstrType, FRS_RSTYPE_DFS))
        return hr;

    //
    // set initial values on the property page
    //
    hr = m_frsPropPage.Initialize(m_piReplicaSet);
    RETURN_IF_FAILED(hr);

    //
    // create the property page
    //
    HPROPSHEETPAGE  h_frsproppage = m_frsPropPage.Create();
    if (!h_frsproppage)
        return HRESULT_FROM_WIN32(::GetLastError());

    //
    // pass on the notify data to the Property Page
    //
    hr = m_frsPropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
    RETURN_IF_FAILED(hr);

    //
    // AddPage
    //
    return i_lpPropSheetCallback->AddPage(h_frsproppage);
}

STDMETHODIMP 
CMmcDfsRoot::CreatePublishPropertyPage
(
  IN LPPROPERTYSHEETCALLBACK    i_lpPropSheetCallback,
  IN LONG_PTR                   i_lNotifyHandle
)
{
    //
    // check schema version
    //
    if (!m_bNewSchema)
        return S_FALSE;

    //
    // check group policy
    //
    if (!CheckPolicyOnSharePublish())
        return S_FALSE;

    //
    // create the property page
    //
    HPROPSHEETPAGE  hpage = m_publishPropPage.Create();
    if (!hpage)
        return HRESULT_FROM_WIN32(::GetLastError());

    m_publishPropPage.Initialize(m_DfsRoot);

    //
    // pass on the notify data to the Property Page
    //
    HRESULT hr = m_publishPropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
    RETURN_IF_FAILED(hr);

    //
    // AddPage
    //
    return i_lpPropSheetCallback->AddPage(hpage);
}

STDMETHODIMP 
CMmcDfsRoot::PropertyChanged(
    )
/*++

Routine Description:

  Used to update the properties.

--*/
{
    return S_OK;
}

HRESULT 
CMmcDfsRoot::ToolbarSelect(
  IN const LONG          i_lArg,
  IN  IToolbar*          i_pToolBar
  )
/*++

Routine Description:

  Handle a select event for a toolbar
  Create a toolbar, it it doesn't exist.
  Attach the toolbar and enable the buttons, if the event for a selection.
  Disable the buttons, if the event was for a deselection

Arguments:
  i_lArg        -  The argument passed to the actual method.
  i_pToolBar      -  Pointer to Toolbar.

--*/
{ 
    RETURN_INVALIDARG_IF_NULL(i_pToolBar);

    BOOL    bSelect = (BOOL) HIWORD(i_lArg);  // Is the event for selection?
  
    EnableToolbarButtons(i_pToolBar, IDT_ROOT_MIN, IDT_ROOT_MAX, bSelect);

    if (bSelect)          // Should we disable or enable the toolbar?
    {
        BOOL    bReplicaSetExist = FALSE;
        HRESULT hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
        RETURN_IF_FAILED(hr);
    
        if(DFS_TYPE_STANDALONE == m_lDfsRootType)
        {
            i_pToolBar->SetButtonState(IDT_ROOT_NEW_ROOT_REPLICA, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_NEW_ROOT_REPLICA, HIDDEN, TRUE);
        }

        if (m_MmcJPList.empty())
        {
            i_pToolBar->SetButtonState(IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS, HIDDEN, TRUE);
        }

        if (bReplicaSetExist || 1 >= m_MmcRepList.size())
        {
            i_pToolBar->SetButtonState(IDT_ROOT_REPLICATION_TOPOLOGY, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_REPLICATION_TOPOLOGY, HIDDEN, TRUE);
        }

        if (!bReplicaSetExist)
        {
            i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, HIDDEN, TRUE);
            i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, HIDDEN, TRUE);
            i_pToolBar->SetButtonState(IDT_ROOT_STOP_REPLICATION, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_STOP_REPLICATION, HIDDEN, TRUE);
        } else
        {
            if (m_bShowFRS)
            {
                i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, ENABLED, FALSE);
                i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, HIDDEN, TRUE);
            } else
            {
                i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, ENABLED, FALSE);
                i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, HIDDEN, TRUE);
            }
        }

        // excluded when empty root container
        if (m_MmcRepList.empty())
        {
            i_pToolBar->SetButtonState(IDT_ROOT_NEW_DFS_LINK, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_NEW_DFS_LINK, HIDDEN, TRUE);
            i_pToolBar->SetButtonState(IDT_ROOT_CHECK_STATUS, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_CHECK_STATUS, HIDDEN, TRUE);
            i_pToolBar->SetButtonState(IDT_ROOT_FILTER_DFS_LINKS, ENABLED, FALSE);
            i_pToolBar->SetButtonState(IDT_ROOT_FILTER_DFS_LINKS, HIDDEN, TRUE);
        }
    }

    return S_OK; 
}




HRESULT
CMmcDfsRoot::CreateToolbar(
  IN const LPCONTROLBAR      i_pControlbar,
  IN const LPEXTENDCONTROLBAR          i_lExtendControlbar,
  OUT  IToolbar**          o_ppToolBar
  )
/*++

Routine Description:

  Create the toolbar.
  Involves the actual toolbar creation call, creating the bitmap and adding it
  and finally adding the buttons to the toolbar

Arguments:
  i_pControlbar    -  The controlbar used to create toolbar.
  i_lExtendControlbar  -  The object implementing IExtendControlbar. This is 
              the class exposed to MMC.
  o_ppToolBar      -  The Toolbar pointer.
--*/
{
    RETURN_INVALIDARG_IF_NULL(i_pControlbar);
    RETURN_INVALIDARG_IF_NULL(i_lExtendControlbar);
    RETURN_INVALIDARG_IF_NULL(o_ppToolBar);

                      // Create the toolbar
    HRESULT hr = i_pControlbar->Create(TOOLBAR, i_lExtendControlbar, reinterpret_cast<LPUNKNOWN*>(o_ppToolBar));
    RETURN_IF_FAILED(hr);

                      // Add the bitmap to the toolbar
    hr = AddBitmapToToolbar(*o_ppToolBar, IDB_ROOT_TOOLBAR);
    RETURN_IF_FAILED(hr);

    int      iButtonPosition = 0;    // The first button position
    for (int iCommandID = IDT_ROOT_MIN, iMenuResource = IDS_MENUS_ROOT_TOP_NEW_DFS_LINK;
        iCommandID <= IDT_ROOT_MAX; 
        iCommandID++,iMenuResource++,iButtonPosition++)
    {
        CComBSTR bstrMenuText;
        CComBSTR bstrToolTipText;
        hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, &bstrToolTipText, NULL);
        RETURN_IF_FAILED(hr);  

        MMCBUTTON      ToolbarButton;
        ZeroMemory(&ToolbarButton, sizeof ToolbarButton);
        ToolbarButton.nBitmap  = iButtonPosition;
        ToolbarButton.idCommand = iCommandID;
        ToolbarButton.fsState = TBSTATE_ENABLED;
        ToolbarButton.fsType = TBSTYLE_BUTTON;
        ToolbarButton.lpButtonText = bstrMenuText; // not used anyway
        ToolbarButton.lpTooltipText = bstrToolTipText;

                          // Add the button to the toolbar
        hr = (*o_ppToolBar)->InsertButton(iButtonPosition, &ToolbarButton);
        BREAK_IF_FAILED(hr);
    }

    return hr;
}



STDMETHODIMP 
CMmcDfsRoot::ToolbarClick(
  IN const LPCONTROLBAR            i_pControlbar, 
  IN const LPARAM                i_lParam
  ) 
/*++

Routine Description:

  Action to take on a click on a toolbar

Arguments:
  i_pControlbar    -  The controlbar used to create toolbar.
  i_lParam      -  The lparam to the actual notify. This is the command id of
              the button on which a click occurred.
--*/
{ 
    RETURN_INVALIDARG_IF_NULL(i_pControlbar);

    HRESULT hr = S_OK;

    switch(i_lParam)
    {
    case IDT_ROOT_NEW_DFS_LINK:
        hr = OnCreateNewJunctionPoint ();
        break;
    case IDT_ROOT_NEW_ROOT_REPLICA:
        hr = OnNewRootReplica();
        break;
    case IDT_ROOT_CHECK_STATUS:
        hr = OnCheckStatus();
        break;
    case IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS:
        hr = OnDeleteDisplayedDfsLinks();
        break;
    case IDT_ROOT_DELETE_CONNECTION_TO_DFS_ROOT:
        hr = OnDeleteConnectionToDfsRoot();
        break;
    case IDT_ROOT_DELETE_DFS_ROOT:
        hr = OnDeleteDfsRoot();
        break;
    case IDT_ROOT_FILTER_DFS_LINKS:
        hr = OnFilterDfsLinks();
        break;
    case IDT_ROOT_REPLICATION_TOPOLOGY:
        hr = OnNewReplicaSet();
        break;
    case IDT_ROOT_SHOW_REPLICATION:
    case IDT_ROOT_HIDE_REPLICATION:
        m_bShowFRS = !m_bShowFRS;
        hr = OnShowReplication();
        break;
    case IDT_ROOT_STOP_REPLICATION:
        hr = OnStopReplication(TRUE);
        if (FAILED(hr))
            DisplayMessageBoxForHR(hr);
        break;
    default:
        hr = E_INVALIDARG;
        break;
    };

    return hr; 
}

HRESULT
CMmcDfsRoot::ClosePropertySheet(BOOL bSilent)
{
    if (!m_PropPage.m_hWnd && !m_frsPropPage.m_hWnd && !m_publishPropPage.m_hWnd)
        return S_OK; // no outstanding property sheet, return S_OK;

    //
    // handle property sheet for the root
    //
    CComPtr<IPropertySheetProvider>  pPropSheetProvider;
    HRESULT hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
    if (FAILED(hr))
    {
        hr = S_OK; // ignore the QI failure
    } else
    {
        //
        // find outstanding property sheet and bring it to foreground
        //
        hr = pPropSheetProvider->FindPropertySheet((MMC_COOKIE)m_hScopeItem, NULL, this);
        if (S_OK == hr)
        {
            if (!bSilent)
            {
                //
                // ask user to close it, return S_FALSE to quit user's operation
                //
                DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_PROPERTYPAGE_NOTCLOSED);
                return S_FALSE;
            } else
            {
                //
                // silently close the property sheet, return S_OK
                //
                if (m_PropPage.m_hWnd)
                    ::SendMessage(m_PropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);

                if (m_frsPropPage.m_hWnd)
                    ::SendMessage(m_frsPropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);

                if (m_publishPropPage.m_hWnd)
                    ::SendMessage(m_publishPropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);
            }
        } else
        {
            hr = S_OK; // no outstanding property sheet, return S_OK
        }
    }

    //
    // reset HWND
    //
    m_PropPage.m_hWnd = NULL;
    m_frsPropPage.m_hWnd = NULL;
    m_publishPropPage.m_hWnd = NULL;

    return hr;
}

HRESULT
CMmcDfsRoot::ClosePropertySheetsOfAllLinks(BOOL bSilent)
{
    HRESULT hr = S_OK;

    //
    // handle property sheets for its links
    //
    if (!m_MmcJPList.empty())
    {
        for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
        {
            hr = ((*i)->pJPoint)->ClosePropertySheet(bSilent);
            if (!bSilent && S_FALSE == hr)
                return S_FALSE; // found an outstanding one for a link, return S_FALSE to quit user's operation
        }
    }

    return S_OK;
}

// Close all outstanding property sheets for its own and its links
// Return: S_OK if there is no open property sheet, or they have all been closed silently
// Return: S_FALSE if an open sheet is found and msgbox poped up to remind user of closing it
HRESULT
CMmcDfsRoot::CloseAllPropertySheets(BOOL bSilent)
{
    //
    // handle property sheet for the root
    //
    HRESULT hr = ClosePropertySheet(bSilent);


    if (!bSilent && S_FALSE == hr)
        return S_FALSE;

    //
    // handle property sheets for its links
    //
    return ClosePropertySheetsOfAllLinks(bSilent);
}

HRESULT
CMmcDfsRoot::OnRefresh()
{
    // Select this node first
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    CWaitCursor wait;
    HRESULT     hr = S_OK;

    // silently close outstanding property sheet.        
    CloseAllPropertySheets(TRUE);

    CleanScopeChildren();
    CleanResultChildren();

    m_bShowFRS = FALSE;
    if ((IReplicaSet *)m_piReplicaSet)
        m_piReplicaSet.Release();

                  // Re-Initialize!
    hr = m_DfsRoot->Initialize(m_bstrRootEntryPath);
    if (S_OK != hr) // failt to init the root, or no such root any more, we have to stop managing the root
    {
        if (FAILED(hr))
            DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_STOP_MANAGING_ROOT);

        // Delete the item from Scope Pane
        (void)m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);

        // Delete it from the internal list
        (void)m_pParent->DeleteMmcRootNode(this);

        Release();  // delete this CMmcDfsRoot object

        return S_FALSE;
    }

    BOOL bReplicaSetExist = FALSE;
    CComBSTR bstrDC;
    (void)m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);

                // Enumerate Junction points
    (void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);

    // set the root icon
    if (m_lpConsoleNameSpace != NULL)
    {
        SCOPEDATAITEM      ScopeDataItem;
        ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
        ScopeDataItem.ID = m_hScopeItem;

        hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
        if (SUCCEEDED(hr))
        {
            ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
            ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
            ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);

            m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
        }
    }

                // Re-Display Result Pane.
    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);

                  // Set the selected item in scope pane to this node
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    return S_OK;
}

HRESULT
CMmcDfsRoot::OnRefreshFilteredLinks()
{
    // Select this node first
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    CWaitCursor wait;

    HRESULT     hr = S_OK;

    CleanScopeChildren();
    CleanResultChildren();

    m_bShowFRS = FALSE;
    if ((IReplicaSet *)m_piReplicaSet)
        m_piReplicaSet.Release();

    BOOL bReplicaSetExist = FALSE;
    CComBSTR bstrDC;
    hr = m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);
    if (FAILED(hr))
    {
        return OnRefresh(); // fail to access info, see if the root can be contacted or not
    }

                // Enumerate Junction points
    (void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);

    // set the root icon
    if (m_lpConsoleNameSpace != NULL)
    {
        SCOPEDATAITEM      ScopeDataItem;
        ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
        ScopeDataItem.ID = m_hScopeItem;

        hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
        if (SUCCEEDED(hr))
        {
            ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
            ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
            ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);

            m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
        }
    }

    // re-display the result pane items
    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);

                  // Set the selected item in scope pane to this node
    m_lpConsole->SelectScopeItem(m_hScopeItem);

    return S_OK;
}

HRESULT
CMmcDfsRoot::_DeleteDfsRoot(
    IN BSTR    i_bstrServerName,
    IN BSTR    i_bstrShareName,
    IN BSTR    i_bstrFtDfsName
     )
{
/*++

Routine Description:

  Helper member function to actually delete (Stop hosting) the Dfs Root.
  This is also called to delete root level replica.

Arguments:
  
  i_bstrServerName - The server on which the Dfs has to be torn down.
  i_bRootReplica - This DfsRoot is been torn down as Root Replica.
  i_bstrFtDfsName - The FtDfs name of the Dfs. NULL for Standalone Dfs.

--*/
    RETURN_INVALIDARG_IF_NULL(i_bstrServerName);
    RETURN_INVALIDARG_IF_NULL(i_bstrShareName);

    CWaitCursor    WaitCursor;  // Display the wait cursor
    HRESULT hr = m_DfsRoot->DeleteDfsHost(i_bstrServerName, i_bstrShareName, FALSE);
    BOOL bFTDfs = (i_bstrFtDfsName && *i_bstrFtDfsName);

    if (bFTDfs)
    {
        if (FAILED(hr) && HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) != hr)
        {
            if (IDYES == DisplayMessageBox(
                                    GetActiveWindow(), 
                                    MB_YESNO | MB_ICONEXCLAMATION, 
                                    hr, 
                                    IDS_MSG_WIZ_DELETE_FAILURE_RETRY, 
                                    i_bstrServerName))
            {
                // force delete
                hr = m_DfsRoot->DeleteDfsHost(i_bstrServerName, i_bstrShareName, TRUE);
            } else
            {
                // leave it alone
                hr = S_FALSE;
            }
        }
    }

    if (FAILED(hr))
        DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_WIZ_DELETE_FAILURE, i_bstrServerName);

    //
    // delete volume object if it's standalone
    //
    if (SUCCEEDED(hr) && !bFTDfs)
    {
        (void) ModifySharePublishInfoOnSARoot(
                                               i_bstrServerName,
                                               i_bstrShareName,
                                               FALSE,
                                               NULL,
                                               NULL,
                                               NULL,
                                               NULL
                                               );
    }

    return hr;
}

STDMETHODIMP CMmcDfsRoot::CleanScopeChildren()
{
    HRESULT hr = S_OK;

    if (!m_MmcJPList.empty())
    {
        // clean up the display objects
        for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
        {
            delete (*i);
        }

        m_MmcJPList.erase(m_MmcJPList.begin(), m_MmcJPList.end());

        // Delete all child items from scope pane.
        if (m_lpConsoleNameSpace)
        {
            HSCOPEITEM        hChild = NULL;
            MMC_COOKIE        lCookie = 0;

            while (SUCCEEDED(hr = m_lpConsoleNameSpace->GetChildItem(m_hScopeItem, &hChild, &lCookie)) && hChild)
            {
                (void)m_lpConsoleNameSpace->DeleteItem(hChild, TRUE);
            }
        }
    }

    return S_OK;
}


STDMETHODIMP CMmcDfsRoot::CleanResultChildren(
    )
{
    if (!m_MmcRepList.empty())
    {
        // delete display object
        for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
        {
            delete (*i);
        }

        m_MmcRepList.erase(m_MmcRepList.begin(), m_MmcRepList.end());

        // delete result pane items
        m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 0);
    }

    return(S_OK);
}

STDMETHODIMP CMmcDfsRoot::RefreshResultChildren(
    )
{
    CleanResultChildren();

    m_DfsRoot->RefreshRootReplicas();

    // Send View change notification for all veiws.
    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);

    return(S_OK);
}

STDMETHODIMP CMmcDfsRoot::ViewChange(
    IResultData*    i_pResultData,
    LONG_PTR        i_lHint
  )
/*++

Routine Description:

  This method handles the MMCN_VIEW_CHANGE notification.
  This updates the result view for the scope node on which the
  UpdateAllViews was called.

  if (0 == i_lHint) clean result pane only.

--*/
{
    RETURN_INVALIDARG_IF_NULL(i_pResultData);

    i_pResultData->DeleteAllRsltItems();

    if (i_lHint)
        EnumerateResultPane(i_pResultData);

    return(S_OK);
}


STDMETHODIMP CMmcDfsRoot::AddResultPaneItem(
  CMmcDfsReplica*    i_pReplicaDispObject
  )
/*++

Routine Description:

  This method adds a new replica object to the list of replicas displayed
  in the result view.

Arguments:

  i_pReplicaDispObject - The CMmcReplica display object pointer..

--*/
{
    REP_LIST_NODE*  pNewReplica = new REP_LIST_NODE(i_pReplicaDispObject);
    if (!pNewReplica)
        return E_OUTOFMEMORY;

    m_MmcRepList.push_back(pNewReplica);

          // Re-display to display this item.
    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);

    return S_OK;
}

//
// This function is called when deleting a link from the scope pane
//
STDMETHODIMP CMmcDfsRoot::RemoveJP(LPCTSTR i_pszDisplayName)
{
    if (!i_pszDisplayName)
        return E_INVALIDARG;

    //
    // refresh to pick up possible namespace updates on links by other means
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has already been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    //
    // locate the correct link to remove, then call back.
    //
    for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
    {
        if (!lstrcmpi((*i)->pJPoint->m_bstrDisplayName, i_pszDisplayName))
        {
            hr = (*i)->pJPoint->OnRemoveJP();
            break;
        }
    }

    return hr;
}

//
// This function is called when removing a target from the result pane
//
STDMETHODIMP CMmcDfsRoot::RemoveReplica(LPCTSTR i_pszDisplayName)
{
    if (!i_pszDisplayName)
        return E_INVALIDARG;

    //
    // refresh to pick up possible namespace updates on root targets by other means
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has already been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    //
    // locate the correct target to remove, then call back
    //
    for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
    {
        if (!lstrcmpi((*i)->pReplica->m_bstrDisplayName, i_pszDisplayName))
        {
            hr = (*i)->pReplica->RemoveReplica();
            break;
        }
    }

    return hr;
}

STDMETHODIMP CMmcDfsRoot::RemoveResultPaneItem(
  CMmcDfsReplica*    i_pReplicaDispObject
  )
/*++

Routine Description:

  This method removes a replica object from the list of replicas displayed
  in the result view.

Arguments:

  i_pReplicaDispObject - The CMmcReplica display object pointer..

--*/
{
  dfsDebugOut((_T("CMmcDfsRoot::RemoveResultPaneItem jplist=%d, replist=%d\n"),
    m_MmcJPList.size(), m_MmcRepList.size()));

                // Remove item from list.
  for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
  {
    if ((*i)->pReplica == i_pReplicaDispObject)
    {
      delete (*i);
      m_MmcRepList.erase(i);
      break;
    }
  }

              // Last node is removed.
  if (m_MmcRepList.empty())
  {
    // silently close any open property sheet
    CloseAllPropertySheets(TRUE);

    CleanScopeChildren();

    // Delete the item from Scope Pane
    HRESULT hr = m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);
    RETURN_IF_FAILED(hr);

        // Delete it from the internal list
    hr = m_pParent->DeleteMmcRootNode(this);
    RETURN_IF_FAILED(hr);

    Release(); // delete this CMmsDfsRoot object
  }
  else
  {
                  // Re-display to remove this item.
    m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
  }

  return S_OK;
}

STDMETHODIMP 
CMmcDfsRoot::OnCheckStatus() 
{ 
    //
    // refresh to pick up possible namespace updates on targets by others
    //
    HRESULT hr = OnRefresh();
    if (S_FALSE == hr)
    {
        // this root has been deleted by others, no more reference
        DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
        return hr;
    }

    CWaitCursor wait;

    UINT nTotal = m_MmcRepList.size();
    _ASSERT(nTotal != 0);

    UINT nMappingOn = 0;
    UINT nMappingOff = 0;
    UINT nUnreachable = 0;
                // Update state of all replicas also.
    for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
    {
        (*i)->pReplica->OnCheckStatus();

        switch ((*i)->pReplica->m_lReplicaState)
        {
        case DFS_REPLICA_STATE_ONLINE:
            nMappingOn++;
            break;
        case DFS_REPLICA_STATE_OFFLINE:
            nMappingOff++;
            break;
        case DFS_REPLICA_STATE_UNREACHABLE:
            nUnreachable++;
            break;
        default:
            _ASSERT(FALSE);
            break;
        }
    }

    long lDfsState = DFS_STATE_REACHABLE;
    hr = m_DfsRoot->get_State(&lDfsState);
    RETURN_IF_FAILED(hr);

    if (DFS_STATE_REACHABLE == lDfsState)
    {
        if (nTotal == nMappingOn)
        {
            m_lRootJunctionState = DFS_JUNCTION_STATE_ALL_REP_OK;
        } else if (nTotal != (nMappingOff + nUnreachable))
        {
            m_lRootJunctionState = DFS_JUNCTION_STATE_NOT_ALL_REP_OK;
        } else
        {
            m_lRootJunctionState = DFS_JUNCTION_STATE_UNREACHABLE;
        }
    } else
    {
        m_lRootJunctionState = DFS_JUNCTION_STATE_UNREACHABLE;
    }

    BOOL    bReplicaSetExist = FALSE;
    hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
    RETURN_IF_FAILED(hr);

    if (m_lpConsoleNameSpace)
    {
        SCOPEDATAITEM     ScopeDataItem;
        ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
        ScopeDataItem.ID = m_hScopeItem;
        hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);// Get the item data
        RETURN_IF_FAILED(hr);

        ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;              // Set the image flag
        ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0) + m_lRootJunctionState;  // Specify the bitmap to use
        ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0) + m_lRootJunctionState;  // Specify the bitmap to use

        hr = m_lpConsoleNameSpace->SetItem(&ScopeDataItem);    // set the updated item data
        RETURN_IF_FAILED(hr);
    }

    return hr;
}

HRESULT CMmcDfsRoot::GetIReplicaSetPtr(IReplicaSet** o_ppiReplicaSet)
{
    RETURN_INVALIDARG_IF_NULL(o_ppiReplicaSet);

    HRESULT hr = _InitReplicaSet();
    if (S_OK == hr)
    {
        m_piReplicaSet->AddRef();
        *o_ppiReplicaSet = m_piReplicaSet;
    }

    return hr;
}