/*++

Copyright (C) 1997-1999  Microsoft Corporation

Module Name:

    compdata.cpp

Abstract:

    This module implemets CComponentData class

Author:

    William Hsieh (williamh) created

Revision History:


--*/

#include "devmgr.h"
#include "factory.h"
#include "genpage.h"

const WCHAR* const DM_COMPDATA_SIGNATURE = L"Device Manager";

CComponentData::CComponentData()
{
    m_pScope = NULL;
    m_pConsole = NULL;
    m_pCookieRoot = NULL;
    m_pScopeItemRoot = NULL;
    
    //
    // Static scope item default to device manager
    //
    m_ctRoot = COOKIE_TYPE_SCOPEITEM_DEVMGR;
    m_hwndMain = NULL;
    m_pMachine = NULL;
    m_IsDirty = FALSE;
    
    //
    // Increment object count(used by CanUnloadNow)
    //
    ::InterlockedIncrement(&CClassFactory::s_Objects);
    m_Ref = 1;
}

CComponentData::~CComponentData()
{

    //
    // All QIed interfaces should be released during
    // Destroy method
    //
    ASSERT(NULL == m_pScope);
    ASSERT(NULL == m_pConsole);
    ASSERT(NULL == m_pCookieRoot);
    
    //
    // decrement object count(used by CanUnloadNow)
    //
    ::InterlockedDecrement(&CClassFactory::s_Objects);

}

//
// IUnknown interface
//
ULONG
CComponentData::AddRef()
{
    ::InterlockedIncrement((LONG*)&m_Ref);
    return m_Ref;
}

ULONG
CComponentData::Release()
{
    ::InterlockedDecrement((LONG*)&m_Ref);
    
    if (!m_Ref)
    {
        delete this;
        return 0;
    }

    return m_Ref;
}

STDMETHODIMP
CComponentData::QueryInterface(
    REFIID  riid,
    void**  ppv
    )
{
    if (!ppv)
    {
        return E_INVALIDARG;
    }

    HRESULT hr = S_OK;


    if (IsEqualIID(riid, IID_IUnknown))
    {
        *ppv = (IUnknown*)(IComponentData*)this;
    }
    
    else if (IsEqualIID(riid, IID_IComponentData))
    {
        *ppv = (IComponentData*)this;
    }
    
    else if (IsEqualIID(riid, IID_IExtendContextMenu))
    {
        *ppv = (IExtendContextMenu*)this;
    }
    
    else if (IsEqualIID(riid, IID_IExtendPropertySheet))
    {
        *ppv = (IExtendPropertySheet*)this;
    }
    
    else if (IsEqualIID(riid, IID_IPersistStream))
    {
        *ppv = (IPersistStream*)this;
    }
    
    else if (IsEqualIID(riid, IID_ISnapinHelp))
    {
        *ppv = (ISnapinHelp*)this;
    }
    
    else
    {
        *ppv = NULL;
        hr = E_NOINTERFACE;
    }
    
    if (SUCCEEDED(hr))
    {
        AddRef();
    }

    return hr;
}


/////////////////////////////////////////////////////////////////////////////
//  IComponentData implementation
///

STDMETHODIMP
CComponentData::Initialize(
    LPUNKNOWN pUnknown
    )
{
    if (!pUnknown)
    {
        return E_INVALIDARG;
    }

    HRESULT hr;
    
    try
    {
        //
        // This function should be called only once.
        //
        ASSERT(NULL == m_pScope);
    
        //
        // Get the IConsoleNameSpace interface
        //
        hr = pUnknown->QueryInterface(IID_IConsoleNameSpace, (void**)&m_pScope);
        if (SUCCEEDED(hr))
        {
            hr = pUnknown->QueryInterface(IID_IConsole, (void**)&m_pConsole);
            
            if (SUCCEEDED(hr))
            {
                //
                // Retreive the console main window. It will be used
                // as the parent window of property sheets and
                // parent handle for setupapi calls
                //
                m_pConsole->GetMainWindow(&m_hwndMain);
                LoadScopeIconsForScopePane();
            }
            else
            {
                //
                // Unable to the IConsole Interface
                //
                m_pScope->Release();
            }
        }
    }
    
    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }
    
    return hr;
}

// This function creates a new CComponent
// A Component will be created when a new "window" is being created.
//
STDMETHODIMP
CComponentData::CreateComponent(
    LPCOMPONENT* ppComponent
    )
{
    HRESULT hr;

    if (!ppComponent)
    {
        return E_INVALIDARG;
    }

    try
    {
        CComponent* pComponent = new CComponent(this);
        
        //
        // Return the IComponent interface
        //
        hr = pComponent->QueryInterface(IID_IComponent, (void**)ppComponent);
        pComponent->Release();
        
        if (SUCCEEDED(hr))
        {
            hr = CreateScopeItems();
    
            if (SUCCEEDED(hr))
            {
                hr = pComponent->CreateFolderList(m_pCookieRoot);
            }
            else
            {
                pComponent->Release();
                *ppComponent = NULL;
            }
        }
    }
    
    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }
    
    return hr;
}

STDMETHODIMP
CComponentData::Notify(
    LPDATAOBJECT lpDataObject,
    MMC_NOTIFY_TYPE event,
    LPARAM    arg,
    LPARAM    param
    )
{
    HRESULT hr;
    try
    {
        //
        // On MMCN_PROPERTY_CHANGE event, lpDataObject is invalid
        // Donot touch it.
        //
        if (MMCN_PROPERTY_CHANGE == event)
        {
            PPROPERTY_CHANGE_INFO pPCI = (PPROPERTY_CHANGE_INFO) param;
            
            if (pPCI && PCT_STARTUP_INFODATA == pPCI->Type)
            {
                PSTARTUP_INFODATA pSI = (PSTARTUP_INFODATA)&pPCI->InfoData;
                ASSERT(pSI->Size == sizeof(STARTUP_INFODATA));
                
                if (pSI->MachineName[0] != _T('\0'))
                {
                    m_strMachineName = pSI->MachineName;
                }
                
                m_ctRoot = pSI->ct;
                SetDirty();
            }

            return S_OK;
        }

        else if (MMCN_EXPAND == event)
        {
            return OnExpand(lpDataObject, arg, param);
        }
        
        else if (MMCN_REMOVE_CHILDREN == event)
        {
            //
            // This is basically a hack!!!!
            // When the target computer is switched in Computer Management
            // snapin(we are an extention to it), we basically get
            // a MMCN_REMOVE_CHILDREN followed by MMCN_EXPAND.
            // The right thing for MMC to do is to create a new IComponent
            // for each new machine so that each IComponent can maintain
            // its own states(thus, its own folders).
            // Well, it is not a perfect world and we are forced to use
            // the old IComponent. So here we notify each scope node
            // which in turns will notify all the CFolders.
            //
            // After reset, each folder does not attach to any CMachine object
            // (thus, its m_pMachine will be NULL). Each folder will attach
            // to the new machine object when its OnShow method is called
            // the very "first" time.
            //
            if (!IsPrimarySnapin() && m_pScopeItemRoot)
            {
                ResetScopeItem(m_pScopeItemRoot);
            }

            return S_OK;
        }
    
        ASSERT(m_pScope);
        INTERNAL_DATA tID;
        hr = ExtractData(lpDataObject, CDataObject::m_cfSnapinInternal,
                 (PBYTE)&tID, sizeof(tID));
    
    
        if (SUCCEEDED(hr))
        {
            switch (event) {
            case MMCN_DELETE:
                hr = OnDelete(tID.cookie, arg, param);
                break;
            case MMCN_RENAME:
                hr = OnRename(tID.cookie, arg, param);
                break;
            case MMCN_CONTEXTMENU:
                hr = OnContextMenu(tID.cookie, arg, param);
                break;
            case MMCN_BTN_CLICK:
                hr = OnBtnClick(tID.cookie, arg, param);
                break;
            default:
                hr = S_OK;
                break;
            }
        }
    }
    
    catch(CMemoryException* e)
    {
        e->Delete();
        hr = E_OUTOFMEMORY;
    }

    return hr;
}


STDMETHODIMP
CComponentData::GetDisplayInfo(
    SCOPEDATAITEM* pScopeDataItem
    )
{
    if (!pScopeDataItem)
    {
        return E_INVALIDARG;
    }

    try
    {
        //
        // IComponentData::GetDisplayInfo only deals with scope pane items.
        // Snapin's IComponent::GetDisplayInfo will deal with result pane items
        //
        CCookie* pCookie = (CCookie*) pScopeDataItem->lParam;
        ASSERT(pCookie);
        return pCookie->GetScopeItem()->GetDisplayInfo(pScopeDataItem);
    }
    
    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        return E_OUTOFMEMORY;
    }
}

STDMETHODIMP
CComponentData::Destroy()
{
    if (m_pCookieRoot) 
    {
        delete m_pCookieRoot;
        m_pCookieRoot = NULL;
    }

    if (m_pScopeItemRoot) 
    {
        delete m_pScopeItemRoot;
    }

    if (m_pScope) 
    {
        m_pScope->Release();
        m_pScope = NULL;
    }
    
    if (m_pConsole)
    {
        m_pConsole->Release();
        m_pConsole = NULL;
    }

    return S_OK;
}

STDMETHODIMP
CComponentData::QueryDataObject(
    MMC_COOKIE cookie,
    DATA_OBJECT_TYPES type,
    LPDATAOBJECT* ppDataObject
    )
{
    CDataObject* pDataObject;
    COOKIE_TYPE  ct;
    CCookie* pCookie;

    try
    {
        pCookie = GetActiveCookie(cookie);
        
        if (NULL == pCookie)
        {
            ct = m_ctRoot;
        }
        else
        {
            ct = pCookie->GetType();
        }
    
        pDataObject = new CDataObject;
        pDataObject->Initialize(type, ct, pCookie, m_strMachineName);
        pDataObject->AddRef();
        *ppDataObject = pDataObject;
    }
    
    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        return E_OUTOFMEMORY;
    }
    
    return S_OK;
}

STDMETHODIMP
CComponentData::CompareObjects(
    LPDATAOBJECT lpDataObjectA,
    LPDATAOBJECT lpDataObjectB
    )
{
    HRESULT hr;
    
    try
    {
        INTERNAL_DATA tID_A, tID_B;
        hr = ExtractData(lpDataObjectA, CDataObject::m_cfSnapinInternal,
                 (PBYTE)&tID_A, sizeof(tID_A));
        
        if (SUCCEEDED(hr))
        {
            hr = ExtractData(lpDataObjectB, CDataObject::m_cfSnapinInternal,
                     (PBYTE)&tID_B, sizeof(tID_B));
            
            if (SUCCEEDED(hr))
            {
                hr = (tID_A.ct == tID_B.ct && tID_A.cookie == tID_B.cookie &&
                       tID_A.dot == tID_B.dot) ? S_OK : S_FALSE;
            }
        }
    }
    
    catch(CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }
    
    return hr;
}



///////////////////////////////////////////////////////////////////
//// IExtendPropertySheet implementation
////
STDMETHODIMP
CComponentData::QueryPagesFor(
    LPDATAOBJECT lpDataObject
    )
{
    HRESULT hr;

    if (!lpDataObject)
    {
        return E_INVALIDARG;
    }

    try
    {
        INTERNAL_DATA tID;
        hr = ExtractData(lpDataObject, CDataObject::m_cfSnapinInternal,
                 (PBYTE)&tID, sizeof(tID));
        
        if (SUCCEEDED(hr))
        {
            CScopeItem* pScopeItem;
            pScopeItem = FindScopeItem(tID.cookie);
            
            if (CCT_SNAPIN_MANAGER == tID.dot && COOKIE_TYPE_SCOPEITEM_DEVMGR == tID.ct)
            {
                hr = S_OK;
            }

            else if (pScopeItem)
            {
                hr = pScopeItem->QueryPagesFor();
            }
            
            else
            {
                hr = S_FALSE;
            }
        }
    }

    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }
    
    return hr;
}

STDMETHODIMP
CComponentData::CreatePropertyPages(
    LPPROPERTYSHEETCALLBACK lpProvider,
    LONG_PTR handle,
    LPDATAOBJECT lpDataObject
    )
{
    if (!lpProvider || !lpDataObject)
    {
        return E_INVALIDARG;
    }

    HRESULT hr;

    try
    {
        INTERNAL_DATA tID;
        hr = ExtractData(lpDataObject, CDataObject::m_cfSnapinInternal,
                 reinterpret_cast<BYTE*>(&tID), sizeof(tID)
                 );
        
        if (SUCCEEDED(hr))
        {
            CScopeItem* pScopeItem = FindScopeItem(tID.cookie);
            if (CCT_SNAPIN_MANAGER == tID.dot && COOKIE_TYPE_SCOPEITEM_DEVMGR == tID.ct)
            {
                hr = DoStartupProperties(lpProvider, handle, lpDataObject);
            }
            
            else if (pScopeItem)
            {
                hr = pScopeItem->CreatePropertyPages(lpProvider, handle);
            }

            else
            {
                hr = S_OK;
            }
        }
    }
    
    catch(CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }
    
    return hr;
}


////////////////////////////////////////////////////////////
//// IExtendContextMenu implemantation
////
STDMETHODIMP
CComponentData::AddMenuItems(
    LPDATAOBJECT lpDataObject,
    LPCONTEXTMENUCALLBACK pCallbackUnknown,
    long *pInsertionAllowed
    )
{
    if (!lpDataObject || !pCallbackUnknown || !pInsertionAllowed)
    {
        return E_INVALIDARG;
    }

    return S_OK;
}

STDMETHODIMP
CComponentData::Command(
    long nCommandID,
    LPDATAOBJECT lpDataObject
    )
{
    if (!lpDataObject)
    {
        return E_INVALIDARG;
    }

    return S_OK;
}

HRESULT
CComponentData::CreateCookieSubtree(
    CScopeItem* pScopeItem,
    CCookie* pCookieParent
    )
{
    ASSERT(pScopeItem);

    CScopeItem* pChild;
    CCookie* pCookieSibling;
    pCookieSibling = NULL;
    int Index = 0;

    while (pScopeItem->EnumerateChildren(Index, &pChild))
    {
        CCookie* pCookie;
        
        pCookie =  new CCookie(pChild->GetType());
        
        if (pCookie) {
        
            pCookie->SetScopeItem(pChild);
            
            if (!pCookieSibling)
            {
                pCookieParent->SetChild(pCookie);
            }
            else
            {
                pCookieSibling->SetSibling(pCookie);
            }
            
            pCookie->SetParent(pCookieParent);
            
            if (pChild->GetChildCount())
            {
                CreateCookieSubtree(pChild, pCookie);
            }
            
            pCookieSibling = pCookie;
        }

        Index++;
    }

    return S_OK;
}
////////////////////////////////////////////////////////////
/// IPersistStream implementation
///
STDMETHODIMP
CComponentData::GetClassID(
    CLSID* pClassID
    )
{
    if(!pClassID)
    {
        return E_INVALIDARG;
    }

    *pClassID = GetCoClassID();
    return S_OK;
}

STDMETHODIMP
CComponentData::IsDirty()
{
    return m_IsDirty ? S_OK : S_FALSE;
}



STDMETHODIMP
CComponentData::Load(
    IStream* pStm
    )
{
    HRESULT hr;
    SafeInterfacePtr<IStream> StmPtr(pStm);

    //
    // Fix up the MachineName that we got from the command line if there was one.
    // We need to prepend "\\" to the MachineName if it does not start with two
    // backslashes, and then we will verify the machine name by calling CM_Connect_Machine
    // to verify that this user has access to that machine.  If they do not then we
    // will set the MachineName to NULL.
    //
    if (!g_strStartupMachineName.IsEmpty())
    {
        if (_T('\\') != g_strStartupMachineName[0])
        {
            g_strStartupMachineName = TEXT("\\\\") + g_strStartupMachineName;
        }

        if (!VerifyMachineName(g_strStartupMachineName))
        {
            g_strStartupMachineName.Empty();
        }
    }

    COMPDATA_PERSISTINFO Info;
    ULONG BytesRead;

    ASSERT(pStm);
    
    //
    // Read the persist data and verify that we have the right data
    //
    hr = pStm->Read(&Info, sizeof(Info), &BytesRead);
        
    if (SUCCEEDED(hr) && 
        (BytesRead >= sizeof(Info)) &&
        (Info.Size >= sizeof(Info)) &&
        (!wcscmp(Info.Signature, DM_COMPDATA_SIGNATURE)))
    {
        try
        {
            m_ctRoot = Info.RootCookie;
            m_strMachineName.Empty();

            if (UNICODE_NULL != Info.ComputerFullName[0])
            {
#ifdef UNICODE
                m_strMachineName = Info.ComputerFullName;
#else
                CHAR ComputerNameA[MAX_PATH + 3];
                WideCharToMultiByte(CP_ACP, 0, Info.ComputerFullName, -1,
                    ComputerNameA, sizeof(ComputerNameA) / sizeof(CHAR), NULL, ULL);
                m_strMachineName = ComputerNameA;
#endif
            }
    
            if (COOKIE_TYPE_SCOPEITEM_DEVMGR == m_ctRoot)
            {
                //
                // Parameters from command line has the priority
                //
                if (!g_strStartupMachineName.IsEmpty())
                {
                    m_strMachineName = g_strStartupMachineName;
                }
                
                m_strStartupDeviceId = g_strStartupDeviceId;
                m_strStartupCommand = g_strStartupCommand;
            }
    
            hr = CreateScopeItems();
            if (SUCCEEDED(hr))
            {
                if (!m_pMachine)
                {
                    if (!g_MachineList.CreateMachine(m_hwndMain, m_strMachineName, &m_pMachine))
                    {
                        hr = HRESULT_FROM_WIN32(GetLastError());
                    }
                }
            }
        }

        catch(CMemoryException* e)
        {
            e->Delete();
            MsgBoxParam(m_hwndMain, 0, 0, 0);
            hr = E_OUTOFMEMORY;
        }
    }

    m_IsDirty = FALSE;

    return hr;
}

STDMETHODIMP
CComponentData::Save(
    IStream* pStm,
    BOOL fClearDirty
    )
{
    SafeInterfacePtr<IStream> StmPtr(pStm);

    HRESULT hr;

    try
    {
        COMPDATA_PERSISTINFO Info;
        Info.Size = sizeof(Info);
        Info.RootCookie = m_ctRoot;
        wcscpy(Info.Signature, DM_COMPDATA_SIGNATURE);
    
        //
        // Assuming it is on local machine. The machine name is saved
        // in UNICODE
        //
        Info.ComputerFullName[0] = UNICODE_NULL;
        if (m_strMachineName.GetLength())
#ifdef UNICODE
            wcscpy(Info.ComputerFullName, m_strMachineName);
#else
            MultiByteToWideChar((CP_ACP, 0, chBuffer, -1, Info.ComputerFullName,
                     sizeof(Info.ComputerFullName) / sizeof(WCHAR));
#endif
        
            hr = pStm->Write(&Info, sizeof(Info), NULL);
    }

    catch (CMemoryException* e)
    {
        e->Delete();
        MsgBoxParam(m_hwndMain, 0, 0, 0);
        hr = E_OUTOFMEMORY;
    }

    if (fClearDirty)
    {
        m_IsDirty = FALSE;
    }
    
    return hr;
}

STDMETHODIMP
CComponentData::GetSizeMax(
    ULARGE_INTEGER* pcbSize
    )
{
    if (!pcbSize)
    {
        return E_INVALIDARG;
    }

    int len;
    len = sizeof(m_ctRoot) + sizeof(len) +  (m_strMachineName.GetLength() + 1) * sizeof(TCHAR);
    ULISet32(*pcbSize, len);
    
    return S_OK;
}

//
// Method to support html help.
//
//
STDMETHODIMP
CComponentData::GetHelpTopic(
    LPOLESTR* lpCompileHelpFile
    )
{
    if (!lpCompileHelpFile)
    {
        return E_INVALIDARG;
    }

    *lpCompileHelpFile = NULL;
    UINT Size;
    TCHAR HelpFile[MAX_PATH];
    
    Size = GetSystemWindowsDirectory(HelpFile, ARRAYLEN(HelpFile));
    
    if (Size && Size < ARRAYLEN(HelpFile))
    {
        StrCatN(HelpFile, DEVMGR_HTML_HELP_FILE_NAME, ARRAYLEN(HelpFile));
        *lpCompileHelpFile = AllocOleTaskString(HelpFile);
    }

    return S_OK;
}

CScopeItem*
CComponentData::FindScopeItem(
    MMC_COOKIE cookie
    )
{
    CCookie* pCookie = GetActiveCookie(cookie);
    if (pCookie)
    return pCookie->GetScopeItem();
    return NULL;
}

//
// This function loads icons for the scope items
//
HRESULT
CComponentData::LoadScopeIconsForScopePane()
{
    ASSERT(m_pScope);
    ASSERT(m_pConsole);

    LPIMAGELIST lpScopeImage;
    HRESULT hr;
    
    hr = m_pConsole->QueryScopeImageList(&lpScopeImage);
    
    if (SUCCEEDED(hr))
    {
        HICON hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_DEVMGR));
        
        if (hIcon)
        {
            hr = lpScopeImage->ImageListSetIcon((PLONG_PTR)hIcon, IMAGE_INDEX_DEVMGR);
            DestroyIcon(hIcon);
        }
        
        hr = lpScopeImage->Release();
    }

    return hr;
}

//
// This function create the startup wizard property sheet
//
// INPUT:
//  lpProvider -- Interface for us to add pages
//  handle     -- notify console handle
//  lpDataObject -- the data object
//
// OUTPUT:
//   standard OLE HRESULT

HRESULT
CComponentData::DoStartupProperties(
    LPPROPERTYSHEETCALLBACK lpProvider,
    LONG_PTR handle,
    LPDATAOBJECT lpDataObject
    )
{
    CGeneralPage* pGenPage;
    HPROPSHEETPAGE hPage;
    
    pGenPage = new CGeneralPage();

    if (pGenPage) 
    {
        hPage = pGenPage->Create(handle);
        
        if (hPage)
        {
            lpProvider->AddPage(hPage);
            
            //
            // If no console handle is provided, we have to use
            // our call back function
            //
            if(!handle)
            {
                pGenPage->SetOutputBuffer(&m_strMachineName, &m_ctRoot);
            }
    
            return S_OK;
        }
    
        else
        {
            throw &g_MemoryException;
        }
    }

    else
    {
        throw &g_MemoryException;
    }

    return E_OUTOFMEMORY;
}

//
// This function creates all the necessary classes represent
// our scope items
//
HRESULT
CComponentData::CreateScopeItems()
{
    //
    // All classes are linked by cookie with m_pCookieRoot
    // points to the "root" scope item
    //
    if (!m_pScopeItemRoot)
    {
        switch (m_ctRoot)
        {
        case COOKIE_TYPE_SCOPEITEM_DEVMGR:
            m_pScopeItemRoot = new CScopeItem(COOKIE_TYPE_SCOPEITEM_DEVMGR,
                                              IMAGE_INDEX_DEVMGR,
                                              OPEN_IMAGE_INDEX_DEVMGR,
                                              IDS_NAME_DEVMGR,
                                              IDS_DESC_DEVMGR,
                                              IDS_DISPLAYNAME_SCOPE_DEVMGR);
            break;
            
        default:
            ASSERT(FALSE);
            break;
        }
        
        if (m_pScopeItemRoot->Create())
        {
            //
            // Bind scope items and cookies together.
            // Cookies know its scopeitem.
            // Scopeitems do not know cookies.
            //
            m_pCookieRoot = new CCookie(m_ctRoot);
            
            if (m_pCookieRoot)
            {
                ASSERT(m_pScopeItemRoot->GetType() == m_ctRoot);
                m_pCookieRoot->SetScopeItem(m_pScopeItemRoot);
                CreateCookieSubtree(m_pScopeItemRoot, m_pCookieRoot);
            }
        }
    }
    
    return S_OK;
}


//
// This function resets the given scopeitem.
//
HRESULT
CComponentData::ResetScopeItem(
    CScopeItem* pScopeItem
    )
{
    HRESULT hr = S_OK;
    
    if (pScopeItem)
    {
        CScopeItem* pChild;
        int Index;
        Index = 0;
        
        while (SUCCEEDED(hr) && pScopeItem->EnumerateChildren(Index, &pChild))
        {
            hr = ResetScopeItem(pChild);
            Index++;
        }
        
        if (SUCCEEDED(hr))
        {
            return pScopeItem->Reset();
        }
    }

    return hr;
}