windows-server-2003/shell/osshell/snapins/devmgr/snapin/cfolder.cpp

/*++

Copyright (C) Microsoft Corporation

Module Name:

    cfolder.cpp

Abstract:

    This module implements CFolder and its releated classes.

Author:

    William Hsieh (williamh) created

Revision History:


--*/
#include "devmgr.h"
#include "clsgenpg.h"
#include "devgenpg.h"
#include "devdrvpg.h"
#include "devpopg.h"
#include "devdetpg.h"
#include "hwprof.h"
#include "devrmdlg.h"
#include "printer.h"
#include <devguid.h>
#include <initguid.h>
#include <oleacc.h>


const TCHAR* OCX_TREEVIEW = TEXT("{CD6C7868-5864-11D0-ABF0-0020AF6B0B7A}");

const MMCMENUITEM ViewDevicesMenuItems[TOTAL_VIEWS] =
{
    {IDS_VIEW_DEVICESBYTYPE, IDS_MENU_STATUS_DEVBYTYPE, IDM_VIEW_DEVICESBYTYPE, VIEW_DEVICESBYTYPE},
    {IDS_VIEW_DEVICESBYCONNECTION, IDS_MENU_STATUS_DEVBYCONNECTION, IDM_VIEW_DEVICESBYCONNECTION, VIEW_DEVICESBYCONNECTION},
    {IDS_VIEW_RESOURCESBYTYPE, IDS_MENU_STATUS_RESBYTYPE, IDM_VIEW_RESOURCESBYTYPE, VIEW_RESOURCESBYTYPE},
    {IDS_VIEW_RESOURCESBYCONNECTION, IDS_MENU_STATUS_RESBYCONNECTION, IDM_VIEW_RESOURCESBYCONNECTION, VIEW_RESOURCESBYCONNECTION}
};

const RESOURCEID ResourceTypes[TOTAL_RESOURCE_TYPES] =
{
    ResType_Mem,
    ResType_IO,
    ResType_DMA,
    ResType_IRQ
};


///////////////////////////////////////////////////////////////////
/// CScopeItem implementations
///

BOOL
CScopeItem::Create()
{
    m_strName.LoadString(g_hInstance, m_iNameStringId);
    m_strDesc.LoadString(g_hInstance, m_iDescStringId);
    return TRUE;
}

HRESULT
CScopeItem::GetDisplayInfo(
                          LPSCOPEDATAITEM pScopeDataItem
                          )
{
    if (!pScopeDataItem) {
        return E_INVALIDARG;
    }

    if (SDI_STR & pScopeDataItem->mask) {
        pScopeDataItem->displayname = (LPTSTR)(LPCTSTR)m_strName;
    }

    if (SDI_IMAGE & pScopeDataItem->mask) {
        pScopeDataItem->nImage = m_iImage;
    }

    if (SDI_OPENIMAGE & pScopeDataItem->mask) {
        pScopeDataItem->nOpenImage = m_iOpenImage;
    }

    return S_OK;
}

BOOL
CScopeItem::EnumerateChildren(
                             int Index,
                             CScopeItem** ppScopeItem
                             )
{
    if (!ppScopeItem || Index >= m_listChildren.GetCount()) {
        return FALSE;
    }

    POSITION pos = m_listChildren.FindIndex(Index);
    *ppScopeItem = m_listChildren.GetAt(pos);

    return TRUE;
}

HRESULT
CScopeItem::Reset()
{
    //
    // We have not enumerated!
    //
    m_Enumerated = FALSE;

    //
    // If there are folders created from this scope item,
    // walk through all of them and tell each one
    // to reset the cached machine object
    //
    HRESULT hr = S_OK;

    if (!m_listFolder.IsEmpty()) {
        CFolder* pFolder;
        POSITION pos = m_listFolder.GetHeadPosition();

        while (NULL != pos) {
            pFolder = m_listFolder.GetNext(pos);
            hr = pFolder->Reset();
        }
    }

    return hr;
}

CCookie*
CScopeItem::FindSelectedCookieData(
                                  CResultView** ppResultView
                                  )
{
    CFolder* pFolder;
    CResultView* pResultView;

    //
    // This routine returns the Selected Cookie in the result view if it has
    // the focus.  This is done by locating the folder from the scopeitem.
    // If the folder is not selected, the current result view is accessed to
    // get the current selected cookie.  If any of these fail a NULL value is
    // returned.  Optionally the current CResultView class is returned.
    //
    POSITION pos = m_listFolder.GetHeadPosition();

    while (NULL != pos) {
        pFolder = m_listFolder.GetNext(pos);

        if (this == pFolder->m_pScopeItem) {
            if (!pFolder->m_bSelect &&
                (pResultView = pFolder->GetCurResultView()) != NULL) {
                if (ppResultView) {
                    *ppResultView = pResultView;
                }

                return pResultView->GetSelectedCookie();
            }
        }
    }

    return NULL;
}

CScopeItem::~CScopeItem()
{
    if (!m_listChildren.IsEmpty()) {
        CScopeItem* pChild;
        POSITION pos;

        pos = m_listChildren.GetHeadPosition();

        while (NULL != pos) {
            pChild = m_listChildren.GetNext(pos);
            delete pChild;
        }

        m_listChildren.RemoveAll();
    }

    if (!m_listFolder.IsEmpty()) {
        POSITION pos;
        pos = m_listFolder.GetHeadPosition();

        while (NULL != pos) {
            //
            // DO NOT delete it!!!!
            //
            (m_listFolder.GetNext(pos))->Release();
        }

        m_listFolder.RemoveAll();
    }
}

CFolder*
CScopeItem::CreateFolder(
                        CComponent* pComponent
                        )
{
    ASSERT(pComponent);

    CFolder* pFolder;
    pFolder = new CFolder(this, pComponent);

    if (pFolder) {
        m_listFolder.AddTail(pFolder);
        pFolder->AddRef();
    }

    else {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }

    return pFolder;
}

HRESULT
CScopeItem::AddMenuItems(
                        LPCONTEXTMENUCALLBACK pCallback,
                        long* pInsertionAllowed
                        )
{
    CCookie* pSelectedCookie;
    CResultView* pResultView;

    if ((pSelectedCookie = FindSelectedCookieData(&pResultView)) != NULL) {
        //
        // Add menu items for the Action menu.
        //
        return pResultView->AddMenuItems(pSelectedCookie, pCallback,
                                         pInsertionAllowed, FALSE);
    }

    else {
        return S_OK;
    }
}

HRESULT
CScopeItem::MenuCommand(
                       long lCommandId
                       )
{
    CCookie* pSelectedCookie;
    CResultView* pResultView;

    if ((pSelectedCookie = FindSelectedCookieData(&pResultView)) != NULL) {
        //
        // Handle menu requests for the Action menu.
        //
        return pResultView->MenuCommand(pSelectedCookie, lCommandId);
    }

    else {
        return S_OK;
    }
}

HRESULT
CScopeItem::QueryPagesFor()
{
    //
    // We do not have property pages for scope item
    //
    CCookie* pSelectedCookie;

    if ((pSelectedCookie = FindSelectedCookieData(NULL)) != NULL) {
        return S_OK;
    }

    else {
        return S_FALSE;
    }
}

HRESULT
CScopeItem::CreatePropertyPages(
                               LPPROPERTYSHEETCALLBACK lpProvider,
                               LONG_PTR handle
                               )
{
    CCookie* pSelectedCookie;
    CResultView* pResultView;

    if ((pSelectedCookie = FindSelectedCookieData(&pResultView)) != NULL) {
        return pResultView->CreatePropertyPages(pSelectedCookie, lpProvider, handle);
    }

    else {
        return S_OK;
    }
}


///////////////////////////////////////////////////////////////////
/// CFolder implementations
///

CFolder::CFolder(
                CScopeItem* pScopeItem,
                CComponent* pComponent
                )
{
    ASSERT(pScopeItem && pComponent);

    m_pScopeItem = pScopeItem;
    m_pComponent = pComponent;
    m_Show = FALSE;
    m_pMachine = NULL;
    m_bSelect = FALSE;
    m_pOleTaskString = NULL;
    m_Ref = 0;
    m_FirstTimeOnShow = TRUE;
    m_Signature = FOLDER_SIGNATURE_DEVMGR;
    m_pViewTreeByType = NULL;
    m_pViewTreeByConnection = NULL;
    m_pViewResourcesByType = NULL;
    m_pViewResourcesByConnection = NULL;
    m_CurViewType = VIEW_DEVICESBYTYPE;
    m_pCurView = m_pViewTreeByType;
    m_ShowHiddenDevices = FALSE;
}

CFolder::~CFolder()
{
    if (m_pViewTreeByType) {
        delete m_pViewTreeByType;
    }

    if (m_pViewTreeByConnection) {
        delete m_pViewTreeByConnection;
    }

    if (m_pViewResourcesByType) {
        delete m_pViewResourcesByType;
    }

    if (m_pViewResourcesByConnection) {
        delete m_pViewResourcesByConnection;
    }
}

HRESULT
CFolder::Compare(
                MMC_COOKIE cookieA,
                MMC_COOKIE cookieB,
                int  nCol,
                int* pnResult
                )
{
    UNREFERENCED_PARAMETER(cookieA);
    UNREFERENCED_PARAMETER(cookieB);
    UNREFERENCED_PARAMETER(nCol);
    
    ASSERT(pnResult);

    //
    // We do not have anything in the result pane, thus
    // comparision makes no sense.
    //
    *pnResult = 0;

    return S_OK;
}

HRESULT
CFolder::GetDisplayInfo(
                       LPRESULTDATAITEM pResultDataItem
                       )
{
    if (!pResultDataItem) {
        return E_POINTER;
    }

    ASSERT(m_pScopeItem);

    //
    // This only take care of scope pane item (displaying scope pane node
    // on the result pane). The derived classes should take care of
    // result items.
    //
    if (RDI_STR & pResultDataItem->mask) {
        if (0 == pResultDataItem->nCol) {
            if (m_pOleTaskString)
                FreeOleTaskString(m_pOleTaskString);
            m_pOleTaskString = AllocOleTaskString(m_pScopeItem->GetNameString());

            if (m_pOleTaskString) {
                pResultDataItem->str = m_pOleTaskString;
            }

            else {
                m_strScratch = m_pScopeItem->GetNameString();
                pResultDataItem->str = (LPTSTR)(LPCTSTR)m_strScratch;
            }
        }

        else if (2 == pResultDataItem->nCol) {
            if (m_pOleTaskString) {
                FreeOleTaskString(m_pOleTaskString);
            }

            m_pOleTaskString = AllocOleTaskString(m_pScopeItem->GetDescString());

            if (m_pOleTaskString) {
                pResultDataItem->str = m_pOleTaskString;
            }

            else {
                m_strScratch = m_pScopeItem->GetDescString();
                pResultDataItem->str = (LPTSTR)(LPCTSTR)m_strScratch;
            }
        }

        else {
            return S_FALSE;
        }
    }

    if (RDI_IMAGE & pResultDataItem->mask) {
        pResultDataItem->nImage = m_pScopeItem->GetImageIndex();
    }

    return S_OK;
}

HRESULT
CFolder::AddMenuItems(
                     CCookie* pCookie,
                     LPCONTEXTMENUCALLBACK pCallback,
                     long* pInsertionAllowed
                     )
{
    ASSERT(pCookie);

    HRESULT hr = S_OK;

    //
    // If the cookie points to a scope item, add view menu items
    //
    if (NULL == pCookie->GetResultItem()) {

        ASSERT(m_pScopeItem == pCookie->GetScopeItem());

        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW) {
            long Flags;

            for (int i = 0; i < TOTAL_VIEWS; i++) {
                if (m_CurViewType == ViewDevicesMenuItems[i].Type) {
                    Flags = MF_ENABLED | MF_CHECKED | MFT_RADIOCHECK;
                }

                else {
                    Flags = MF_ENABLED;
                }

                hr = AddMenuItem(pCallback,
                                 ViewDevicesMenuItems[i].idName,
                                 ViewDevicesMenuItems[i].idStatusBar,
                                 ViewDevicesMenuItems[i].lCommandId,
                                 CCM_INSERTIONPOINTID_PRIMARY_VIEW,
                                 Flags,
                                 0);
                if (FAILED(hr)) {
                    break;
                }
            }

            //
            // Add "Show hidden devices" menu item
            //
            if (SUCCEEDED(hr)) {
                hr = AddMenuItem(pCallback, 0, 0, 0, CCM_INSERTIONPOINTID_PRIMARY_VIEW,
                                 MF_ENABLED, CCM_SPECIAL_SEPARATOR);

                if (SUCCEEDED(hr)) {
                    if (m_ShowHiddenDevices) {
                        Flags = MF_ENABLED | MF_CHECKED;
                    }

                    else {
                        Flags = MF_ENABLED;
                    }

                    hr = AddMenuItem(pCallback, IDS_SHOW_ALL, IDS_MENU_STATUS_HIDDEN_DEVICES, IDM_SHOW_ALL,
                                     CCM_INSERTIONPOINTID_PRIMARY_VIEW, Flags, 0);
                }
            }
        }
    }

    else {
        if (m_pCurView) {
            //
            // Add menu items for the Context menu in the result pane.
            //
            hr = m_pCurView->AddMenuItems(pCookie, pCallback,
                                          pInsertionAllowed, TRUE);
        }

        else {
            hr = S_OK;
        }
    }

    return hr;
}

HRESULT
CFolder::MenuCommand(
                    CCookie* pCookie,
                    long lCommandId
                    )
{
    if (NULL == pCookie->GetResultItem()) {
        ASSERT(m_pScopeItem == pCookie->GetScopeItem());

        //
        // Convert menu id to view type;
        //
        VIEWTYPE ViewType = m_CurViewType;
        BOOL fShowHiddenDevices = m_ShowHiddenDevices;

        switch (lCommandId) {
        case IDM_VIEW_DEVICESBYTYPE:
            ViewType = VIEW_DEVICESBYTYPE;
            break;

        case IDM_VIEW_DEVICESBYCONNECTION:
            ViewType = VIEW_DEVICESBYCONNECTION;
            break;

        case IDM_VIEW_RESOURCESBYTYPE:
            ViewType = VIEW_RESOURCESBYTYPE;
            break;

        case IDM_VIEW_RESOURCESBYCONNECTION:
            ViewType = VIEW_RESOURCESBYCONNECTION;
            break;

        case IDM_SHOW_ALL:
            fShowHiddenDevices = !fShowHiddenDevices;
            break;

        default:
            //not view menu. do nothing
            return S_OK;
            break;
        }

        if (!SelectView(ViewType, fShowHiddenDevices)) {
            return HRESULT_FROM_WIN32(GetLastError());
        }

        //
        // Reselect the scopeitem
        //
        return m_pComponent->m_pConsole->SelectScopeItem(*m_pScopeItem);
    }

    else {
        if (m_pCurView) {
            //
            // Handle menu requests for the Context menu in the result pane.
            //
            return m_pCurView->MenuCommand(pCookie, lCommandId);
        }

        else {
            return S_OK;
        }
    }
}

HRESULT
CFolder::QueryPagesFor(
                      CCookie* pCookie
                      )
{
    //
    // We do not have property pages for scope item
    //
    if (NULL == pCookie->GetResultItem()) {
        ASSERT(m_pScopeItem == pCookie->GetScopeItem());

        return S_FALSE;
    }

    //
    // The cookie points to result item, let the current
    // view handle it
    //
    if (m_pCurView) {
        return m_pCurView->QueryPagesFor(pCookie);
    }

    else {
        return S_FALSE;
    }
}

HRESULT
CFolder::CreatePropertyPages(
                            CCookie* pCookie,
                            LPPROPERTYSHEETCALLBACK lpProvider,
                            LONG_PTR handle
                            )
{
    if (NULL == pCookie->GetResultItem()) {
        ASSERT(m_pScopeItem == pCookie->GetScopeItem());

        return S_OK;
    }

    if (m_pCurView) {
        return m_pCurView->CreatePropertyPages(pCookie, lpProvider, handle);
    }

    else {
        return S_OK;
    }
}

BOOL
CFolder::SelectView(
                   VIEWTYPE ViewType,
                   BOOL     fShowHiddenDevices
                   )
{
    CResultView* pNewView;

    if (m_CurViewType == ViewType &&
        m_ShowHiddenDevices == fShowHiddenDevices &&
        m_pCurView) {
        return TRUE;
    }

    switch (ViewType) {
    case VIEW_DEVICESBYTYPE:
        if (!m_pViewTreeByType) {
            m_pViewTreeByType = new CViewTreeByType();

            if (m_pViewTreeByType) {

                m_pViewTreeByType->SetFolder(this);
            }
        }

        pNewView = m_pViewTreeByType;
        break;

    case VIEW_DEVICESBYCONNECTION:
        if (!m_pViewTreeByConnection) {
            m_pViewTreeByConnection = new CViewTreeByConnection();

            if (m_pViewTreeByConnection) {

                m_pViewTreeByConnection->SetFolder(this);
            }
        }

        pNewView = m_pViewTreeByConnection;
        break;

    case VIEW_RESOURCESBYTYPE:
        if (!m_pViewResourcesByType) {
            m_pViewResourcesByType = new CViewResourceTree(IDS_STATUS_RESOURCES_BYTYPE);

            if (m_pViewResourcesByType) {

                m_pViewResourcesByType->SetFolder(this);
            }
        }

        pNewView = m_pViewResourcesByType;
        break;

    case VIEW_RESOURCESBYCONNECTION:
        if (!m_pViewResourcesByConnection) {
            m_pViewResourcesByConnection = new CViewResourceTree(IDS_STATUS_RESOURCES_BYCONN);

            if (m_pViewResourcesByConnection) {

                m_pViewResourcesByConnection->SetFolder(this);
            }
        }

        pNewView = m_pViewResourcesByConnection;
        break;

    default:
        pNewView = NULL;
        break;
    }

    if (pNewView) {
        //
        // Let the view know that it is being diselected.
        //
        if (m_pCurView) {
            if (m_CurViewType != ViewType) {
                m_pComponent->SetDirty();
            }
        }

        //
        // Let the new active view know that it is being selected.
        //
        m_pCurView = pNewView;
        m_CurViewType = ViewType;
        m_ShowHiddenDevices = fShowHiddenDevices;
    }

    return TRUE;
}

HRESULT
CFolder::OnShow(
               BOOL fShow
               )
{
    if (fShow && !m_pMachine) {

        ASSERT(m_pComponent);

        if (!m_pComponent->AttachFolderToMachine(this, &m_pMachine)) {
            
            return HRESULT_FROM_WIN32(GetLastError());
        }
    }

    m_Show = fShow;

    if (m_pMachine) {

        if (!SelectView(m_CurViewType, m_ShowHiddenDevices)) {
            
            return E_UNEXPECTED;
        }

        if (m_pCurView) {
            
            if (m_FirstTimeOnShow && m_Show) {
                
                int ReturnValue;

                //
                // Subsequent calls are not the first time anymore.
                //
                m_FirstTimeOnShow = FALSE;

                //
                // This is the first time we show the folder.
                // Put up a message box to warn user if
                // (1) The machine is a remote machine or
                // (2) The user does not have the Adminstator privilege.
                // (3) We can not connect to the remote machine
                //
                ASSERT(m_pComponent && m_pComponent->m_pConsole);

                //
                // Connect to a remote machine
                //
                if (!m_pMachine->IsLocal()) {
                    
                    if (!VerifyMachineName(m_pMachine->GetRemoteMachineFullName())) {
                        //
                        // Display a warning if we cannot connect to the remote machine
                        //
                        String strWarningFormat;
                        String strWarningMsg;
                        LPVOID lpLastError = NULL;

                        if (strWarningFormat.LoadString(g_hInstance, IDS_INVALID_COMPUTER_NAME) &&
                            FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                          FORMAT_MESSAGE_FROM_SYSTEM | 
                                          FORMAT_MESSAGE_IGNORE_INSERTS,
                                          NULL,
                                          GetLastError(),
                                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                          (LPTSTR)&lpLastError,
                                          0,
                                          NULL)) {

                            strWarningMsg.Format((LPTSTR)strWarningFormat,
                                      m_pMachine->GetMachineDisplayName(), 
                                      lpLastError);

                            m_pComponent->m_pConsole->MessageBox((LPTSTR)strWarningMsg,
                                                                 (LPCTSTR)g_strDevMgr,
                                                                 MB_ICONERROR | MB_OK,
                                                                 &ReturnValue);
                        }

                        if (lpLastError) {

                            LocalFree(lpLastError);
                        }
                    } else {
                        //
                        // Otherwise display a warning that we are connect to a remote machine and
                        // device manager will run in a neutered mode.
                        //
                        String strMsg;
                        String strWarningMsg;
                        
                        if (strMsg.LoadString(g_hInstance, IDS_REMOTE_WARNING2) &&
                            strWarningMsg.LoadString(g_hInstance, IDS_REMOTE_WARNING1)) {
                            
                            strWarningMsg += strMsg;
                            m_pComponent->m_pConsole->MessageBox((LPCTSTR)strWarningMsg,
                                                                 (LPCTSTR)g_strDevMgr,
                                                                 MB_ICONEXCLAMATION | MB_OK,
                                                                 &ReturnValue);
                        }
                    }
                } else if (!g_IsAdmin) {
                    //
                    // If we are running locally but the user does not have 
                    // sufficient privileges then tell the user we will run
                    // in read-only mode.
                    //
                    String strWarningMsg;
                    strWarningMsg.LoadString(g_hInstance, IDS_NOADMIN_WARNING);
                    m_pComponent->m_pConsole->MessageBox(strWarningMsg,
                                                         (LPCTSTR)g_strDevMgr,
                                                         MB_ICONEXCLAMATION | MB_OK,
                                                         &ReturnValue);
                }
            }

            return m_pCurView->OnShow(fShow);
        }
    }

    return S_OK;
}

HRESULT
CFolder::OnRestoreView(
                      BOOL* pfHandled
                      )
{
    ASSERT(pfHandled);

    if (!pfHandled) {
        return E_INVALIDARG;
    }

    HRESULT hr = OnShow(TRUE);

    if (SUCCEEDED(hr)) {
        *pfHandled = TRUE;
    }

    return hr;
}

HRESULT
CFolder::GetResultViewType(
                          LPOLESTR* ppViewType,
                          long*     pViewOptions
                          )
{
    ASSERT(pViewOptions);

    if (!SelectView(m_CurViewType, m_ShowHiddenDevices)) {
        return E_UNEXPECTED;
    }

    if (m_pCurView) {
        return m_pCurView->GetResultViewType(ppViewType, pViewOptions);
    }

    *pViewOptions  = MMC_VIEW_OPTIONS_NONE;

    return S_FALSE;
}

HRESULT
CFolder::Reset()
{
    //
    // Delete all views so that we will create new ones
    // when OnShow is called.
    //
    if (m_pViewTreeByType) {
        delete m_pViewTreeByType;
        m_pViewTreeByType = NULL;
    }

    if (m_pViewTreeByConnection) {
        delete m_pViewTreeByConnection;
        m_pViewTreeByConnection = NULL;
    }

    if (m_pViewResourcesByType) {
        delete m_pViewResourcesByType;
        m_pViewResourcesByType = NULL;
    }

    if (m_pViewResourcesByConnection) {
        delete m_pViewResourcesByConnection;
        m_pViewResourcesByConnection = NULL;
    }

    m_pCurView = NULL;
    m_FirstTimeOnShow = TRUE;
    m_pMachine = NULL;

    return S_OK;
}

HRESULT
CFolder::MachinePropertyChanged(
                               CMachine* pMachine
                               )
{
    //
    // Ignore the tvNotify(SELCHANGED) messages while the tree is changed.
    //
    if (m_pCurView) {
        m_pCurView->SetSelectOk(FALSE);
    }

    if (pMachine) {
        m_pMachine = pMachine;
    }

    if (m_pViewTreeByType) {
        m_pViewTreeByType->MachinePropertyChanged(pMachine);
    }

    if (m_pViewTreeByConnection) {
        m_pViewTreeByConnection->MachinePropertyChanged(pMachine);
    }

    if (m_pViewResourcesByType) {
        m_pViewResourcesByType->MachinePropertyChanged(pMachine);
    }

    if (m_pViewResourcesByConnection) {
        m_pViewResourcesByConnection->MachinePropertyChanged(pMachine);
    }

    if (m_pCurView) {
        m_pCurView->SetSelectOk(TRUE);
    }

    if (m_Show && pMachine) {
        OnShow(TRUE);
    }

    return S_OK;
}

HRESULT
CFolder::GetPersistData(
                       PBYTE pBuffer,
                       int BufferSize
                       )
{
    DEVMGRFOLDER_STATES states;
    states.Type = COOKIE_TYPE_SCOPEITEM_DEVMGR;
    states.CurViewType = m_CurViewType;
    states.ShowHiddenDevices = m_ShowHiddenDevices;

    if (BufferSize && !pBuffer) {
        return E_INVALIDARG;
    }

    if (BufferSize >= sizeof(states)) {
        ::memcpy(pBuffer, &states, sizeof(states));
        return S_OK;
    }

    return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
}

HRESULT
CFolder::SetPersistData(
                       PBYTE pData,
                       int Size
                       )
{
    if (!pData) {
        return E_POINTER;
    }

    if (!Size) {
        ASSERT(FALSE);
        return E_INVALIDARG;
    }

    PDEVMGRFOLDER_STATES pStates = (PDEVMGRFOLDER_STATES)pData;

    if (COOKIE_TYPE_SCOPEITEM_DEVMGR == pStates->Type) {
        if ((VIEW_DEVICESBYTYPE == pStates->CurViewType) ||
            (VIEW_DEVICESBYCONNECTION == pStates->CurViewType) ||
            (VIEW_RESOURCESBYTYPE == pStates->CurViewType) ||
            (VIEW_RESOURCESBYCONNECTION == pStates->CurViewType)) {
            m_CurViewType = pStates->CurViewType;

            if (m_pCurView) {
                m_pCurView->OnShow(TRUE);
            }

            m_ShowHiddenDevices = pStates->ShowHiddenDevices;

            return S_OK;
        }
    }

    return E_UNEXPECTED;
}

HRESULT
CFolder::tvNotify(
                 HWND hwndTV,
                 CCookie* pCookie,
                 TV_NOTIFY_CODE Code,
                 LPARAM arg,
                 LPARAM param
                 )
{
    if (m_pCurView) {
        return m_pCurView->tvNotify(hwndTV, pCookie, Code, arg, param);
    }

    else {
        return S_FALSE;
    }
}

HRESULT
CFolder::OnOcxNotify(
                    MMC_NOTIFY_TYPE event,
                    LPARAM arg,
                    LPARAM param
                    )
{
    if (m_pCurView) {
        return m_pCurView->OnOcxNotify(event, arg, param);
    }

    return S_OK;
}

/////////////////////////////////////////////////////////////////////
//// CResultView implementations
////

CResultView::~CResultView()
{
    if (m_pCookieComputer) {
        if (m_pIDMTVOCX) {
            m_pIDMTVOCX->DeleteAllItems();
        }

        delete m_pCookieComputer;
    }

    if (m_pIDMTVOCX) {
        m_pIDMTVOCX->Release();
    }

    DestroySavedTreeStates();
}

HRESULT
CResultView::OnShow(
                   BOOL fShow
                   )
{
    if (!fShow) {
        return S_OK;
    }

    SafeInterfacePtr<IUnknown> pUnk;
    HRESULT hr;
    CComponent* pComponent = m_pFolder->m_pComponent;
    ASSERT(pComponent);
    ASSERT(pComponent->m_pConsole);

    hr  = S_OK;

    if (NULL == m_pIDMTVOCX) {
        hr = pComponent->m_pConsole->QueryResultView(&pUnk);

        if (SUCCEEDED(hr)) {
            //
            // Get our OCX private interface
            //
            hr = pUnk->QueryInterface(IID_IDMTVOCX, (void**)&m_pIDMTVOCX);
        }

        if (SUCCEEDED(hr)) {
            m_pIDMTVOCX->Connect(pComponent, (MMC_COOKIE)this);
            m_hwndTV = m_pIDMTVOCX->GetWindowHandle();
            m_pIDMTVOCX->SetActiveConnection((MMC_COOKIE)this);
            
            //
            // Set up the annotation map for screen readers.
            //
            IAccPropServices *pAccPropSvc = NULL;
            hr = CoCreateInstance(CLSID_AccPropServices, 
                                  NULL,
                                  CLSCTX_SERVER,
                                  IID_IAccPropServices,
                                  (void**)&pAccPropSvc);
            
            if ((hr == S_OK) && pAccPropSvc) {
                pAccPropSvc->SetHwndPropStr(m_hwndTV, (DWORD)OBJID_CLIENT, 0, PROPID_ACC_DESCRIPTIONMAP, (LPTSTR)m_stringAnnotationMap);
                pAccPropSvc->Release();
            }
            
            DisplayTree();

            String strStartupCommand;
            String strStartupDeviceId;

            strStartupCommand = GetStartupCommand();
            strStartupDeviceId = GetStartupDeviceId();

            if (!strStartupCommand.IsEmpty() && !strStartupDeviceId.IsEmpty() &&
                !strStartupCommand.CompareNoCase(DEVMGR_COMMAND_PROPERTY)) {
                hr = DoProperties(m_hwndTV, m_pSelectedCookie);
            }
        }
    }

    else {
        m_pIDMTVOCX->SetActiveConnection((MMC_COOKIE)this);

        if (!DisplayTree()) {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
    }

    return hr;
}

inline
LPCTSTR
CResultView::GetStartupDeviceId()
{
    return m_pFolder->m_pComponent->GetStartupDeviceId();
}

inline
LPCTSTR
CResultView::GetStartupCommand()
{
    return m_pFolder->m_pComponent->GetStartupCommand();
}

//
// This function is called when  machine states have changed.
//
// INPUT:
//      pMachine -- if NULL, the machine is being destroy.
//
// OUTPUT:
//      stanard OLE return code
HRESULT
CResultView::MachinePropertyChanged(
                                   CMachine* pMachine
                                   )
{
    if (pMachine) {
        m_pMachine = pMachine;
    }

    else {
        //
        // pMachine is NULL, the CMachine we associated with is being destroyed.
        //
        if (m_pCookieComputer) {
            ASSERT(!m_pSelectedItem && m_listExpandedItems.IsEmpty());

            //
            // Save the expanded states
            //
            SaveTreeStates(m_pCookieComputer);

            m_pIDMTVOCX->DeleteAllItems();
            m_pIDMTVOCX->SetImageList(TVSIL_NORMAL, NULL);

            delete m_pCookieComputer;

            //
            // Reset these because they are no longer valid.
            //
            m_pCookieComputer = NULL;
        }
    }

    return S_OK;
}

//
// This function saves the subtree states rooted by pCookieStart.
// It creates an identifier for each expanded node and inserts
// the identifier to the class memember, m_listExpandedItems.
//
// It also saves the selected cookie by creating an identifier and
// saving it in m_pSelectedItem.
//
// This function may throw CMemoryException
//
// INPUT:
//      pCookieStart -- subtree root
// OUTPUT:
//      NONE
void
CResultView::SaveTreeStates(
                           CCookie* pCookieStart
                           )
{
    CItemIdentifier* pItem;

    //
    // If we have a selected item, create an identifier for it
    //
    if (m_pSelectedCookie) {
        m_pSelectedItem = m_pSelectedCookie->GetResultItem()->CreateIdentifier();
        m_pSelectedCookie = NULL;
    }

    while (pCookieStart) {
        if (pCookieStart->IsFlagsOn(COOKIE_FLAGS_EXPANDED)) {
            pItem = pCookieStart->GetResultItem()->CreateIdentifier();
            m_listExpandedItems.AddTail(pItem);
        }

        if (pCookieStart->GetChild()) {
            SaveTreeStates(pCookieStart->GetChild());
        }

        pCookieStart = pCookieStart->GetSibling();
    }
}

void
CResultView::DestroySavedTreeStates()
{
    if (!m_listExpandedItems.IsEmpty()) {
        POSITION pos;
        pos = m_listExpandedItems.GetHeadPosition();

        while (NULL != pos) {
            delete m_listExpandedItems.GetNext(pos);
        }

        m_listExpandedItems.RemoveAll();
    }

    if (m_pSelectedItem) {
        delete m_pSelectedItem;
        m_pSelectedItem = NULL;
    }
}

//
// This function restores the expanded and selected state for the cookie.
//
// INPUT:
//      pCookie -- cookie to restore states for
// OUTPUT:
//      NONE
void
CResultView::RestoreSavedTreeState(
                                  CCookie* pCookie
                                  )
{
    //
    // If the cookie was expanded before, mark it so that DisplayTree
    // will expand it.
    //
    if (!m_listExpandedItems.IsEmpty()) {
        POSITION pos = m_listExpandedItems.GetHeadPosition();
        CItemIdentifier* pItem;

        while (NULL != pos) {
            pItem = m_listExpandedItems.GetNext(pos);

            if (*pItem == *pCookie) {
                pCookie->TurnOnFlags(COOKIE_FLAGS_EXPANDED);
                break;
            }
        }
    }

    if (m_pSelectedItem && (*m_pSelectedItem == *pCookie)) {
        m_pSelectedCookie = pCookie;
    }
}

BOOL
CResultView::DisplayTree()
{
    BOOL Result = FALSE;

    ASSERT(m_pIDMTVOCX);

    ::SendMessage(m_hwndTV, WM_SETREDRAW, FALSE, 0L);

    //
    // Ignore the tvNotify(SELCHANGED) messages while the tree is changed.
    //
    SetSelectOk(FALSE);

    m_pIDMTVOCX->DeleteAllItems();

    //
    // Only display the tree if there is something to display
    //
    if (m_pCookieComputer) {

        m_pIDMTVOCX->SetImageList(TVSIL_NORMAL, m_pMachine->DiGetClassImageList());
        m_pIDMTVOCX->SetStyle(TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT);

        BOOL HasProblem = FALSE;

        //
        // Walks down the tree started from m_pCookieComputer
        //
        Result = DisplaySubtree(NULL, m_pCookieComputer, &HasProblem);

        if (HasProblem && Result) {
            m_pIDMTVOCX->Expand(TVE_EXPAND, (HTREEITEM)m_pCookieComputer->m_lParam);
        }

        //
        // If we have a pre-selected item, use it. Otherwise, use computer
        // as the selected node.
        //
        HTREEITEM hSelectedItem = (m_pSelectedCookie && m_pSelectedCookie->m_lParam) ?
                                  (HTREEITEM)m_pSelectedCookie->m_lParam :
                                  (HTREEITEM)m_pCookieComputer->m_lParam;
        SetSelectOk(TRUE);

        if (hSelectedItem) {
            m_pIDMTVOCX->SelectItem(TVGN_CARET, hSelectedItem);
            m_pIDMTVOCX->EnsureVisible(hSelectedItem);
        }
    }

    ::SendMessage(m_hwndTV, WM_SETREDRAW, TRUE, 0L);
    InvalidateRect(m_hwndTV, NULL, TRUE);

    return Result;
}

//
// This function walks through the given cookie subtree rooted by pCookie
// and insert each node into the TreeView OCX.
// INPUT:
//      htiParent -- HTREEITEM for the new cookie to be inserted
//                   if NULL is given, TVI_ROOT is assumed.
//      pCookie   -- the subtree root cookie to be displayed.
// OUTPUT:
//      none.
//
BOOL
CResultView::DisplaySubtree(
                           HTREEITEM htiParent,
                           CCookie* pCookie,
                           BOOL* pReportProblem
                           )
{
    TV_INSERTSTRUCT ti;
    CResultItem* pRltItem;
    HTREEITEM hti;
    BOOL bResource;
    BOOL fShowHiddenDevices = m_pFolder->ShowHiddenDevices();

    while (pCookie) {
        pRltItem = pCookie->GetResultItem();
        ti.item.state = INDEXTOOVERLAYMASK(0);
        bResource = FALSE;

        //
        // The cookie is not yet in the treeview.
        //
        pCookie->m_lParam = 0;

        if (COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
            CDevice* pDevice = (CDevice*)pRltItem;

            //
            // This is a hidden device and we are not showing hidden devices
            //
            // Note that we need to special case these devices because they
            // are not shown in the tree view, but their visible children are shown.
            //
            if (!fShowHiddenDevices && pDevice->IsHidden()) {

                //
                // If the cookie has children, display them
                //
                CCookie* pCookieChild = pCookie->GetChild();
                BOOL ChildProblem = FALSE;

                if (pCookieChild) {
                    DisplaySubtree(htiParent, pCookieChild, &ChildProblem);
                }

                //
                // Continue on with the next device. This will skip all of the display
                // code below.
                //
                pCookie = pCookie->GetSibling();
                continue;
            }

            //
            // If the device is disabled then set the OVERLAYMASK to the Red X
            //
            if (pDevice->IsDisabled()) {
                ti.item.state = INDEXTOOVERLAYMASK(IDI_DISABLED_OVL - IDI_CLASSICON_OVERLAYFIRST + 1);
                *pReportProblem = TRUE;
            }

            //
            // If the device has a problem then set the OVERLAYMASK to the Yellow !
            //
            else if (pDevice->HasProblem()) {
                ti.item.state = INDEXTOOVERLAYMASK(IDI_PROBLEM_OVL - IDI_CLASSICON_OVERLAYFIRST + 1);
                *pReportProblem = TRUE;
            }

            //
            // if the device does not present, then set the state to TVIS_CUT. This grays out
            // the icon a bit so it looks like a ghost icon.
            //
            else if (pDevice->IsPhantom()) {
                ti.item.state = TVIS_CUT;
            }
        }

        else if (COOKIE_TYPE_RESULTITEM_CLASS == pCookie->GetType()) {
            CClass* pClass = (CClass*)pRltItem;

            //
            // If we don't have any devices to show for this class, or this
            // is a NoDisplayClass and we are not showing hidden devices,
            // then just get our next sibling and continue without showing
            // this class.
            //
            if ((0 == pClass->GetNumberOfDevices(fShowHiddenDevices)) ||
                (!fShowHiddenDevices && pClass->NoDisplay())) {

                //
                // Continue on with the next device. This will skip all of the display
                // code below.
                //
                pCookie = pCookie->GetSibling();
                continue;
            }
        }

        //
        // Is this a resource?
        //
        else if (COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType() ||
                 COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
                 COOKIE_TYPE_RESULTITEM_RESOURCE_DMA == pCookie->GetType() ||
                 COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ == pCookie->GetType()) {
            bResource = TRUE;

            //
            // If this is a FORCED CONFIG resource then overlay the forced
            // config icon
            //
            if (((CResource*)pCookie->GetResultItem())->IsForced()) {
                ti.item.state = INDEXTOOVERLAYMASK(IDI_FORCED_OVL-IDI_CLASSICON_OVERLAYFIRST+1);
            }
        }


        ti.hParent = (htiParent != NULL) ? htiParent : TVI_ROOT;
        ti.hInsertAfter = TVI_SORT;
        ti.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE;
        ti.item.iImage = ti.item.iSelectedImage = pRltItem->GetImageIndex();

        if (bResource) {
            ti.item.pszText = (LPTSTR)((CResource*)pRltItem)->GetViewName();
        }

        else {
            ti.item.pszText = (LPTSTR)pRltItem->GetDisplayName();
        }

        ti.item.lParam = (LPARAM)pCookie;
        ti.item.stateMask = TVIS_OVERLAYMASK | TVIS_CUT;
        hti = m_pIDMTVOCX->InsertItem(&ti);

        //
        // Save the HTREEITEM
        //
        pCookie->m_lParam = (LPARAM)hti;

        if (NULL != hti) {
            //
            // If the cookie has children, display them
            //
            CCookie* pCookieChild = pCookie->GetChild();
            BOOL ChildProblem = FALSE;

            if (pCookieChild) {
                if (bResource && htiParent &&
                    GetDescriptionStringID() == IDS_STATUS_RESOURCES_BYTYPE) {
                    //
                    // This is a child of a resource being viewed by type,
                    // so the tree needs to be flattened.  This is done by
                    // using the same parent.
                    //
                    DisplaySubtree(htiParent, pCookieChild, &ChildProblem);
                }

                else {
                    DisplaySubtree(hti, pCookieChild, &ChildProblem);
                }
            }

            //
            // If any of the device's children have a problem, or if
            // it was previously expanded, then expand it.
            //
            if (ChildProblem || pCookie->IsFlagsOn(COOKIE_FLAGS_EXPANDED)) {
                m_pIDMTVOCX->Expand(TVE_EXPAND, hti);
            }

            //
            // Propogate the child's problem state back to the parent
            //
            *pReportProblem |= ChildProblem;
        }

        pCookie = pCookie->GetSibling();
    }

    return TRUE;
}

HRESULT
CResultView::GetResultViewType(
                              LPOLESTR* ppViewType,
                              long*     pViewOptions
                              )
{
    ASSERT(ppViewType && pViewOptions);

    //
    // The caller is responsible for freeing the memory we allocated.
    //
    LPOLESTR polestr;
    polestr = AllocOleTaskString(OCX_TREEVIEW);

    if (!polestr) {
        return E_OUTOFMEMORY;
    }

    *ppViewType = polestr;

    //
    // We have not list view options
    //
    *pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;

    return S_OK;
}

HRESULT
CResultView::AddMenuItems(
                         CCookie* pCookie,
                         LPCONTEXTMENUCALLBACK pCallback,
                         long*   pInsertionAllowed,
                         BOOL fContextMenu                   // True if for result view context menu
                         )
{
    HRESULT hr = S_OK;
    CDevice* pDevice = NULL;

    if (CCM_INSERTIONALLOWED_TOP & *pInsertionAllowed) {
        switch (pCookie->GetType()) {
        case COOKIE_TYPE_RESULTITEM_DEVICE:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_DMA:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_IO:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY:
            if (m_pMachine->IsLocal() && g_IsAdmin) {
                if (COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
                    pDevice = (CDevice*) pCookie->GetResultItem();
                } else {
                    //
                    // This is a resource item, get the pointer for the device
                    // object from the resource object.
                    //
                    CResource* pResource = (CResource*) pCookie->GetResultItem();
                    if (pResource) {
                        pDevice = pResource->GetDevice();
                    }
                }

                if (pDevice == NULL) {
                    break;
                }
                
                CClass* pClass = pDevice->GetClass();

                //
                // All devices can have their driver's updated except for legacy devices.
                //
                if (!IsEqualGUID(*pClass, GUID_DEVCLASS_LEGACYDRIVER)) {
                    hr = AddMenuItem(pCallback, IDS_UPDATEDRIVER, 
                                     IDS_MENU_STATUS_UPDATEDRIVER, IDM_UPDATEDRIVER,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_ENABLED, 0);
                }

                //
                // Only show the Enable/Disable menu item if the device
                // can be disabled.
                //
                if (pDevice->IsDisableable()) {
                    if (pDevice->IsStateDisabled()) {
                        hr = AddMenuItem(pCallback, IDS_ENABLE, 
                                         IDS_MENU_STATUS_ENABLE, IDM_ENABLE,
                                         CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                         MF_ENABLED, 0);
                    } else {
                        hr = AddMenuItem(pCallback, IDS_DISABLE, 
                                         IDS_MENU_STATUS_DISABLE, IDM_DISABLE,
                                         CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                         MF_ENABLED, 0);
                    }
                }

                //
                // Only show the uninstall menu item if the device can be
                // uninstalled.
                //
                if (SUCCEEDED(hr) &&
                    pDevice->IsUninstallable()) {
                    hr = AddMenuItem(pCallback, IDS_REMOVE, 
                                     IDS_MENU_STATUS_REMOVE, IDM_REMOVE,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_ENABLED, 0);
                }
            }

            // FALL THROUGH........

        case COOKIE_TYPE_RESULTITEM_CLASS:
            if (g_IsAdmin) {

                if (SUCCEEDED(hr)) {
                    hr = AddMenuItem(pCallback, 0, 0, 0,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_ENABLED, CCM_SPECIAL_SEPARATOR);
                }
                if (SUCCEEDED(hr)) {
                    hr = AddMenuItem(pCallback, IDS_REFRESH,
                                     IDS_MENU_STATUS_SCAN_CHANGES, IDM_REFRESH,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_ENABLED, 0);
                }
            }

            if (fContextMenu) {
                if (SUCCEEDED(hr)) {
                    hr = AddMenuItem(pCallback, 0, 0, 0,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_ENABLED, CCM_SPECIAL_SEPARATOR);
                }
                if (SUCCEEDED(hr)) {
                    hr = AddMenuItem(pCallback, IDS_PROPERTIES, 
                                     IDS_MENU_STATUS_PROPERTIES, IDM_PROPERTIES,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                     MF_DEFAULT, CCM_SPECIAL_DEFAULT_ITEM);
                }
            }

            break;

        case COOKIE_TYPE_RESULTITEM_COMPUTER:
        case COOKIE_TYPE_RESULTITEM_RESTYPE:
            if (g_IsAdmin) {
            
                hr = AddMenuItem(pCallback, IDS_REFRESH,
                                 IDS_MENU_STATUS_SCAN_CHANGES, IDM_REFRESH,
                                 CCM_INSERTIONPOINTID_PRIMARY_TOP,
                                 MF_ENABLED, 0);
            }
            break;

        default:
            break;
        }
    }

    return hr;
}

// This function handles menu command for the device tree.
//
// INPUT: pCookie  -- the cookie
//        lCommandId -- the command. See AddMenuItems for valid command
//                      id for each type of cookie.
//
// OUTPUT:  HRESULT S_OK if succeeded.
//                  S_XXX error code.

HRESULT
CResultView::MenuCommand(
                        CCookie* pCookie,
                        long     lCommandId
                        )
{
    HRESULT hr = S_OK;

    //TRACE1(TEXT("Menu command, commandid = %lx\n"), lCommandId);
    ASSERT(pCookie);

    CResultItem* pResultItem = pCookie->GetResultItem();
    ASSERT(pResultItem);

    CDevice* pDevice = NULL;

    switch (pCookie->GetType()) {
    case COOKIE_TYPE_RESULTITEM_DEVICE:
        pDevice = (CDevice*)pResultItem;
        break;

    case COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_DMA:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_IO:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY:
        CResource* pResource = (CResource*)pResultItem;
        if (pResource) {
            pDevice = pResource->GetDevice();
        }
        break;
    }

    switch (lCommandId) {
    case IDM_UPDATEDRIVER:
        if (pDevice) {
            BOOL Installed;
            DWORD RestartFlags = 0;
            DWORD Status = 0, Problem = 0;

            //
            // If the device has the DN_WILL_BE_REMOVED flag set and the user is
            // attempting to update the driver then we will prompt them for a 
            // reboot and include text in the prompt that explains this device
            // is in the process of being removed.
            //
            if (pDevice->GetStatus(&Status, &Problem) &&
                (Status & DN_WILL_BE_REMOVED)) {

                PromptForRestart(m_hwndTV, DI_NEEDRESTART, IDS_WILL_BE_REMOVED_NO_UPDATE_DRIVER);
            
            } else {
                //
                // Disable Refreshing while the Update Driver Wizard is up.
                //
                pDevice->m_pMachine->EnableRefresh(FALSE);
    
                HCURSOR hCursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
    
                Installed = pDevice->m_pMachine->InstallDevInst(m_hwndTV, pDevice->GetDeviceID(), TRUE, &RestartFlags);
    
                if (hCursorOld) {
                    SetCursor(hCursorOld);
                }
    
                //
                // Prompt for a restart if one is needed.  If the user does NOT answer
                // YES to the restart dialog then schedule a refresh since we might not
                // get one from a WM_DEVICECHANGE.
                //
                if (m_pMachine->IsLocal()) {
                    if (PromptForRestart(NULL, RestartFlags) == IDNO) {
                        pDevice->m_pMachine->ScheduleRefresh();
                    }
                }
    
                //
                // Enable Refreshing now that we are done updating the driver.
                //
                pDevice->m_pMachine->EnableRefresh(TRUE);
            }
        }
        break;

    case IDM_ENABLE:
    case IDM_DISABLE:
        if (pDevice) {
            DWORD RestartFlags = 0;
            DWORD Status = 0, Problem = 0;
            
            //
            // If the device has the DN_WILL_BE_REMOVED flag set and the user is
            // attempting to enable/disable the driver then we will prompt them for a 
            // reboot and include text in the prompt that explains this device
            // is in the process of being removed.
            //
            if (pDevice->GetStatus(&Status, &Problem) &&
                (Status & DN_WILL_BE_REMOVED)) {

                PromptForRestart(m_hwndTV, DI_NEEDRESTART, IDS_WILL_BE_REMOVED_NO_CHANGE_SETTINGS);
            
            } else {

                RestartFlags = pDevice->EnableDisableDevice(m_hwndTV,
                                                            (lCommandId == IDM_ENABLE));
    
                //
                // Update the toolbar buttons since the device just changed.
                //
                m_pFolder->m_pComponent->UpdateToolbar(pCookie);
    
                //
                // Prompt for a Restart if we are running locally.  
                // The PromptForRestart() API checks the flags to determine
                // if a restart is actually needed.
                //
                if (m_pMachine->IsLocal()) {
                    if (PromptForRestart(NULL, RestartFlags) == IDNO) {
                        m_pMachine->ScheduleRefresh();
                    }
                }
            }
        }
        break;

    case IDM_REMOVE:
        if (pDevice) {
            hr = RemoveDevice(pDevice);
        }
        break;

    case IDM_REFRESH:
        //
        // This will force every attached folder to recreate
        // its machine data
        //
        ASSERT(m_pMachine);

        if (!m_pMachine->Reenumerate()) {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
        break;

    case IDM_PROPERTIES:
        hr = DoProperties(m_hwndTV, pCookie);
        break;

    default:
        hr = S_OK;
        break;
    }

    return hr;
}

// This function reports if property pages are available for the
// given cookie. Returning S_FALSE,  the cookie's "properties" menu
// item will not displayed.
//
// INPUT: pCookie  -- the cookie
//
// OUTPUT:  HRESULT S_OK if pages are available for the cookie.
//                  S_FALSE if no pages are available for the cookie.
HRESULT
CResultView::QueryPagesFor(
                          CCookie* pCookie
                          )
{
    ASSERT(pCookie);

    if (COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ == pCookie->GetType() ||
        COOKIE_TYPE_RESULTITEM_RESOURCE_DMA == pCookie->GetType() ||
        COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
        COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType() ||
        COOKIE_TYPE_RESULTITEM_CLASS == pCookie->GetType() ||
        COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
        return S_OK;
    }

    return S_FALSE;
}

// This function creates property page(s) for the given cookie.
//
// INPUT: pCookie  -- the cookie
//        lpProvider -- interface pointer to IPROPERTYSHEETCALLBACK
//                      used to add HPROPSHEETPAGE to the property sheet.
//        handle     -- handle for property change notification
//                      The handle is required for MMCPropertyChangeNotify
//                      API.
// OUTPUT:  HRESULT S_OK if succeeded.
//                  S_FALSE if no pages are added.
//                  S_XXX error code.
HRESULT
CResultView::CreatePropertyPages(
                                CCookie* pCookie,
                                LPPROPERTYSHEETCALLBACK lpProvider,
                                LONG_PTR    handle
                                )
{
//
// Design issue:
// We depend on the general page to do some houeskeeping works on the
// property sheet which is owned  and controlled by MMC running in a
// separate thread. General page is always the first page and its window
// is always created. If we need to subclass the property sheet someday,
// having our own General page always assure that we will get the window
// handle to the property sheet.
//
// The most important housekeeping work the General page does is to inform the
// associate device or class when a property sheet is being created
// or destroyed. A device can not be removed if it has a property sheet
// running. The machine can not refresh the device tree if there are property
// sheet(s) running on any devices/classes it contains. Property sheets
// created by a folder should be canceled when the folder is being
// destroyed.
//
// So far, no class installers have attempted to add their own General
// page and I believe it will be true in the future because 1). the page
// is too complicated and overloaded with features(and hard to implement) and
// 2). no major gains can be obtained by implementing a new one.
// To warn the developers who does their own General page,we will have a
// message box warn them about this and proceed with OUR general page.
//
    ASSERT(pCookie);

    CPropSheetData* ppsd = NULL;
    CMachine* pNewMachine = NULL;

    switch (pCookie->GetType()) {
    case COOKIE_TYPE_RESULTITEM_CLASS:
        CClass* pClass;
        pClass = (CClass*) pCookie->GetResultItem();
        ASSERT(pClass);
        
        //
        // Create a new CMachine object that just contains this specific device
        // and it's class.  We need to do this since the CDevice and CClass of 
        // the cookie that was passed into this API will get destroyed whenever
        // we get a WM_DEVICECHANGE notification.
        //
        PVOID Context;
        pNewMachine = new CMachine(m_pMachine->GetMachineFullName());

        CClass* pNewClass;

        if (pNewMachine->Initialize(NULL, NULL, *pClass) &&
            pNewMachine->GetFirstClass(&pNewClass, Context) &&
            pNewClass) {

            pNewMachine->m_ParentMachine = m_pMachine;
            m_pMachine->AttachChildMachine(pNewMachine);
            pNewMachine->SetPropertySheetShouldDestroy();

            ppsd = &pNewClass->m_psd;
    
            if (ppsd->Create(g_hInstance, m_hwndTV, MAX_PROP_PAGES, handle)) {
                CDevInfoList* pClassDevInfo;
    
                //
                // The CDevInfoList object is maintained by the CClass
                // object.
                //
                pClassDevInfo = pNewClass->GetDevInfoList();
    
                if (pClassDevInfo && pClassDevInfo->DiGetClassDevPropertySheet(NULL, 
                                                                               &ppsd->m_psh, 
                                                                               MAX_PROP_PAGES, 
                                                                               pNewMachine->IsLocal() ?
                                                                               DIGCDP_FLAG_ADVANCED : 
                                                                               DIGCDP_FLAG_REMOTE_ADVANCED)) {
                    if (pClassDevInfo->DiGetFlags(NULL) & DI_GENERALPAGE_ADDED) {
                        TCHAR szText[MAX_PATH];
                        LoadResourceString(IDS_GENERAL_PAGE_WARNING, szText,
                                           ARRAYLEN(szText));
    
                        int ReturnValue;
                        m_pFolder->m_pComponent->m_pConsole->MessageBox(
                                                                       szText, pNewClass->GetDisplayName(),
                                                                       MB_ICONEXCLAMATION | MB_OK, &ReturnValue);
                        //
                        // fall through to create our general page.
                        //
                    }
    
                    SafePtr<CClassGeneralPage> GenPagePtr;
                    CClassGeneralPage* pGenPage;
                    pGenPage = new CClassGeneralPage;
    
                    if (pGenPage) {
                        GenPagePtr.Attach(pGenPage);
                        HPROPSHEETPAGE hPage = pGenPage->Create(pNewClass);
    
                        //
                        // General page has to be the first page
                        //
                        if (ppsd->InsertPage(hPage, 0)) {
                            GenPagePtr.Detach();
                        } else {
                            ::DestroyPropertySheetPage(hPage);
                        }
                    }
                }
            }
        }
        break;

    case COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_DMA:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_IO:
    case COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY:
    case COOKIE_TYPE_RESULTITEM_DEVICE:
        CDevice* pDevice;
        CDevice* pNewDevice;

        pNewDevice = NULL;

        if (COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
            pDevice = (CDevice*) pCookie->GetResultItem();
        } else {
            //
            // This is a resource item, get the pointer for the device
            // object from the resource object.
            //
            CResource* pResource = (CResource*) pCookie->GetResultItem();
            ASSERT(pResource);
            pDevice = pResource->GetDevice();
        }
        ASSERT(pDevice);

        //
        // Create a new CMachine object that just contains this specific device
        // and it's class.  We need to do this since the CDevice and CClass of 
        // the cookie that was passed into this API will get destroyed whenever
        // we get a WM_DEVICECHANGE notification.
        //
        PVOID DeviceContext;
        pNewMachine = new CMachine(m_pMachine->GetMachineFullName());

        if (pNewMachine->Initialize(NULL, pDevice->GetDeviceID()) &&
            pNewMachine->GetFirstDevice(&pNewDevice, DeviceContext) &&
            pNewDevice) {

            pNewMachine->m_ParentMachine = m_pMachine;
            m_pMachine->AttachChildMachine(pNewMachine);
            pNewMachine->SetPropertySheetShouldDestroy();

            ppsd = &pNewDevice->m_psd;
    
            if (ppsd->Create(g_hInstance, m_hwndTV, MAX_PROP_PAGES, handle)) {
    
                //
                // Add any class/device specific property pages
                //
                pNewMachine->DiGetClassDevPropertySheet(*pNewDevice, 
                                                        &ppsd->m_psh, 
                                                        MAX_PROP_PAGES, 
                                                        pNewMachine->IsLocal() ?
                                                            DIGCDP_FLAG_ADVANCED :
                                                            DIGCDP_FLAG_REMOTE_ADVANCED);
    
                //
                // Add the general tab
                //
                DWORD DiFlags = pNewMachine->DiGetFlags(*pNewDevice);
                SafePtr<CDeviceGeneralPage> GenPagePtr;
    
                if (DiFlags & DI_GENERALPAGE_ADDED) {
                    TCHAR szText[MAX_PATH];
                    LoadResourceString(IDS_GENERAL_PAGE_WARNING, szText,
                                       ARRAYLEN(szText));
    
                    int ReturnValue;
                    m_pFolder->m_pComponent->m_pConsole->MessageBox(
                                                                   szText, pNewDevice->GetDisplayName(),
                                                                   MB_ICONEXCLAMATION | MB_OK, &ReturnValue);
                    //
                    // fall through to create our general page.
                    //
                }
    
                CDeviceGeneralPage* pGenPage = new CDeviceGeneralPage;
    
                if (pGenPage) {
                    GenPagePtr.Attach(pGenPage);
                    HPROPSHEETPAGE hPage = pGenPage->Create(pNewDevice);
    
                    if (hPage) {
                        //
                        // General page has to be the first page
                        //
                        if (ppsd->InsertPage(hPage, 0)) {
                            GenPagePtr.Detach();
                        } else {
                            ::DestroyPropertySheetPage(hPage);
                        }
                    }
                }
    
                //
                // Add the driver tab
                //
                SafePtr<CDeviceDriverPage> DrvPagePtr;
    
                if (!(DiFlags & DI_DRIVERPAGE_ADDED)) {
                    CDeviceDriverPage* pPage = new CDeviceDriverPage;
    
                    if (pPage) {
                        DrvPagePtr.Attach(pPage);
                        HPROPSHEETPAGE hPage = pPage->Create(pNewDevice);
    
                        if (hPage) {
                            if (ppsd->InsertPage(hPage)) {
                                DrvPagePtr.Detach();
                            } else {
                                ::DestroyPropertySheetPage(hPage);
                            }
                        }
                    }
                }
    
    
                //
                // add the details tab
                //
                // If the environment variable DEVMGR_SHOW_DETAILS does exist and it
                // is not 0 then we will show the details tab
                //
                TCHAR Buffer[MAX_PATH];
                DWORD BufferLen;
    
                if (((BufferLen = ::GetEnvironmentVariable(TEXT("DEVMGR_SHOW_DETAILS"),
                                                           Buffer,
                                                           ARRAYLEN(Buffer))) != 0) &&
                    ((BufferLen > 1) ||
                     (lstrcmp(Buffer, TEXT("0"))))) {
    
                    SafePtr<CDeviceDetailsPage> DetailsPagePtr;
    
                    CDeviceDetailsPage* pDetailsPage = new CDeviceDetailsPage;
                    DetailsPagePtr.Attach(pDetailsPage);
                    HPROPSHEETPAGE hPage = pDetailsPage->Create(pNewDevice);
    
                    if (hPage) {
                        if (ppsd->InsertPage(hPage)) {
                            DetailsPagePtr.Detach();
                        } else {
                            ::DestroyPropertySheetPage(hPage);
                        }
                    }
                }
    
                //
                // Add the resource tab
                //
                if (pNewDevice->HasResources() && !(DiFlags & DI_RESOURCEPAGE_ADDED)) {
                    pNewMachine->DiGetExtensionPropSheetPage(*pNewDevice,
                                                            AddPropPageCallback,
                                                            SPPSR_SELECT_DEVICE_RESOURCES,
                                                            (LPARAM)ppsd
                                                           );
                }
    
#ifndef _WIN64
                DWORD DiFlagsEx = pNewMachine->DiGetExFlags(*pNewDevice);
                
                //
                // Add the power management tab
                //
                if (pNewMachine->IsLocal() && !(DiFlagsEx & DI_FLAGSEX_POWERPAGE_ADDED)) {
                    //
                    // Check if the device support power management
                    //
                    CPowerShutdownEnable ShutdownEnable;
                    CPowerWakeEnable WakeEnable;
    
                    if (ShutdownEnable.Open(pNewDevice->GetDeviceID()) || WakeEnable.Open(pNewDevice->GetDeviceID())) {
                        ShutdownEnable.Close();
                        WakeEnable.Close();
                        SafePtr<CDevicePowerMgmtPage> PowerMgmtPagePtr;
                        CDevicePowerMgmtPage* pPowerPage = new CDevicePowerMgmtPage;
    
                        if (pPowerPage) {
                            PowerMgmtPagePtr.Attach(pPowerPage);
                            HPROPSHEETPAGE hPage = pPowerPage->Create(pNewDevice);
    
                            if (hPage) {
                                if (ppsd->InsertPage(hPage)) {
                                    PowerMgmtPagePtr.Detach();
                                } else {
                                    ::DestroyPropertySheetPage(hPage);
                                }
                            }
                        }
                    }
                }
#endif
    
                //
                // Add any Bus specific property pages if this is the local machine
                //
                if (pNewMachine->IsLocal()) {
                    CBusPropPageProvider* pBusPropPageProvider = new CBusPropPageProvider();
    
                    if (pBusPropPageProvider) {
                        SafePtr<CBusPropPageProvider> ProviderPtr;
                        ProviderPtr.Attach(pBusPropPageProvider);
    
                        if (pBusPropPageProvider->EnumPages(pNewDevice, ppsd)) {
                            ppsd->AddProvider(pBusPropPageProvider);
                            ProviderPtr.Detach();
                        }
                    }
                }
            }
        }
        break;

    default:
        break;
    }

    if (ppsd &&
        ppsd->m_psh.nPages) {
        PROPSHEETHEADER& psh = ppsd->m_psh;

        for (UINT Index = 0; Index < psh.nPages; Index++) {
            lpProvider->AddPage(psh.phpage[Index]);
        }
        return S_OK;
    }

    //
    // If we didn't add any pages then we need to delete the new CMachine we
    // created.
    //
    if (pNewMachine) {

        delete pNewMachine;
    }

    //
    // No pages are added, return S_FALSE so that the responsible
    // Component can do its clean up
    //
    return S_FALSE;
}

// This function handles notification codes from the TV OCX.
//
//  INPUT:
//      hwndTV  -- the Window handle of the TV OCX.
//      pCookie -- the cookie
//      Code    -- notification code.
//      arg     -- argument to the given notification code.
//      param   -- another parameter to the given notificaton code.
//
//  OUTPUT:
//      HRESULT -- S_OK if this function has processed the notification
//                 and the caller should not do any further processing.
//                 S_FALSE if the caller should do more processing.
HRESULT
CResultView::tvNotify(
                     HWND hwndTV,
                     CCookie* pCookie,
                     TV_NOTIFY_CODE Code,
                     LPARAM arg,
                     LPARAM param
                     )
{
    HRESULT hr;

    UNREFERENCED_PARAMETER(arg);

    if (m_hwndTV != hwndTV) {
        return S_FALSE;
    }

    //
    // Presume that we do not handle the notification
    //
    hr = S_FALSE;

    switch (Code) {
    case TV_NOTIFY_CODE_DBLCLK:
        if ((TVHT_ONITEM & param) &&
            (COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_DMA == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType())) {
            if (SUCCEEDED(DoProperties(hwndTV, pCookie)))
                hr = S_OK;
        }
        break;

    case TV_NOTIFY_CODE_CONTEXTMENU:
        if (SUCCEEDED(DoContextMenu(hwndTV, pCookie, (POINT*)param)))
            hr = S_OK;
        break;

    case TV_NOTIFY_CODE_EXPANDED:
        if (TVE_EXPAND & param) {
            pCookie->TurnOnFlags(COOKIE_FLAGS_EXPANDED);
        } else if (TVE_COLLAPSE & param) {
            pCookie->TurnOffFlags(COOKIE_FLAGS_EXPANDED);
        }
        ASSERT(S_FALSE == hr);
        break;

    case TV_NOTIFY_CODE_FOCUSCHANGED:
        // gaining the focus, set the console verbs and toolbar buttons
        if (param) {
            UpdateConsoleVerbs(pCookie);
            m_pFolder->m_pComponent->UpdateToolbar(pCookie);
        }
        break;

    case TV_NOTIFY_CODE_SELCHANGED:
        if (m_SelectOk) {
            // These messages are ignored while the tree is being changed.
            m_pSelectedCookie = pCookie;

            UpdateConsoleVerbs(pCookie);
            m_pFolder->m_pComponent->UpdateToolbar(pCookie);
        }

        break;

    case TV_NOTIFY_CODE_KEYDOWN:
        if (VK_RETURN == param) {
            if (COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ == pCookie->GetType() ||
                COOKIE_TYPE_RESULTITEM_RESOURCE_DMA == pCookie->GetType() ||
                COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
                COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType() ||
                COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType() ||
                COOKIE_TYPE_RESULTITEM_CLASS == pCookie->GetType()) {
                if (SUCCEEDED(DoProperties(hwndTV, pCookie)))
                    hr = S_OK;
            }
        }

        else if (VK_DELETE == param &&
                 COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
            
            //
            // Remove the selected device
            //
            CDevice* pDevice = (CDevice*)pCookie->GetResultItem();
            RemoveDevice(pDevice);
        }
        break;

    case TV_NOTIFY_CODE_RCLICK:
    case TV_NOTIFY_CODE_CLICK:
        if (pCookie && pCookie->m_lParam) {
            m_pIDMTVOCX->SelectItem(TVGN_CARET, (HTREEITEM)pCookie->m_lParam);
        }

    case TV_NOTIFY_CODE_GETDISPINFO:
    default:
        ASSERT(S_FALSE == hr);
        break;
    }

    return hr;
}

//
// This function updates console verbs based on the selected cookie type.
//
HRESULT
CResultView::UpdateConsoleVerbs(
                               CCookie* pCookie
                               )
{
    BOOL bPropertiesEnabled = FALSE;
    BOOL bPrintEnabled = FALSE;

    if (!m_pFolder->m_bSelect) {

        switch (pCookie->GetType()) {
        
        case COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_DMA:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_IO:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY:
        case COOKIE_TYPE_RESULTITEM_CLASS:
        case COOKIE_TYPE_RESULTITEM_DEVICE:
            bPropertiesEnabled = TRUE;
            bPrintEnabled = TRUE;
            break;
    
        case COOKIE_TYPE_RESULTITEM_COMPUTER:
            bPrintEnabled = TRUE;
            break;
    
        default:
            break;
        }
    }

    //
    // Only show the Print button/Action menu item when a something is selected.
    //
    if (bPrintEnabled) {

        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, FALSE);
        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PRINT, ENABLED, TRUE);

    } else {

        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, TRUE);
    }

    //
    // Only show the properties button/Action menu item when a device/class is selected.
    //
    if (bPropertiesEnabled) {
        
        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, HIDDEN, FALSE);
        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, TRUE);
        m_pFolder->m_pComponent->m_pConsoleVerb->SetDefaultVerb(MMC_VERB_PROPERTIES);
    
    } else {

        m_pFolder->m_pComponent->m_pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, HIDDEN, TRUE);
        m_pFolder->m_pComponent->m_pConsoleVerb->SetDefaultVerb(MMC_VERB_NONE);
    }

    return S_OK;
}

HRESULT
CResultView::OnOcxNotify(
                        MMC_NOTIFY_TYPE event,
                        LPARAM arg,
                        LPARAM param
                        )
{
    HRESULT hr = S_OK;
    TV_ITEM TI;

    UNREFERENCED_PARAMETER(arg);

    switch (event) {
    case MMCN_BTN_CLICK:
        if ((MMC_CONSOLE_VERB)param == MMC_VERB_PROPERTIES) {
            ASSERT(m_pIDMTVOCX);
            TI.hItem = m_pIDMTVOCX->GetSelectedItem();

            if (TI.hItem) {
                TI.mask = TVIF_PARAM;
                hr =  m_pIDMTVOCX->GetItem(&TI);

                if (SUCCEEDED(hr)) {
                    hr = DoProperties(m_hwndTV,  (CCookie*)TI.lParam);
                }
            }
        }
        break;

    case MMCN_PRINT:
        hr = DoPrint();
        break;

    case MMCN_SELECT:
        ASSERT(m_pIDMTVOCX);
        TI.hItem = m_pIDMTVOCX->GetSelectedItem();

        if (TI.hItem) {
            TI.mask = TVIF_PARAM;
            hr = m_pIDMTVOCX->GetItem(&TI);

            if (SUCCEEDED(hr)) {
                hr = UpdateConsoleVerbs((CCookie*)TI.lParam);    
            }
        }
        break;

    default:
        break;
    }

    return hr;
}

// This function creates the propperty sheet for the given cookie.
// INPUT:
//      hwndTV  -- the window handle to the TV OCX, used as the parent
//                 window of the property sheet.
//      pCookie -- the cookie.
// OUTPUT:
//      HRESULT S_OK if the function succeeded.
//              S_FALSE if no property sheet will be created.
//              S_XXXX other error.
HRESULT
CResultView::DoProperties(
                         HWND hwndTV,
                         CCookie* pCookie
                         )
{
    HRESULT hr;

    //
    // If a property sheet is aleady up for the node, bring the
    // property sheet to the foreground.
    //
    HWND hWnd = NULL;

    if (COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
        CDevice* pDevice = (CDevice*)pCookie->GetResultItem();
        ASSERT(pDevice);
        hWnd = pDevice->m_pMachine->GetDeviceWindowHandle(pDevice->GetDeviceID());
    }

    else if (COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_DMA == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
             COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType()) {
        //
        // This is a resource item, get the pointer for the device
        // object from the resource object.
        //
        CResource* pResource = (CResource*) pCookie->GetResultItem();
        ASSERT(pResource);
        CDevice* pDevice = pResource->GetDevice();
        ASSERT(pDevice);
        hWnd = pDevice->m_pMachine->GetDeviceWindowHandle(pDevice->GetDeviceID());
    }

    else if (COOKIE_TYPE_RESULTITEM_CLASS == pCookie->GetType()) {
        CClass* pClass = (CClass*)pCookie->GetResultItem();
        ASSERT(pClass);
        hWnd = pClass->m_pMachine->GetClassWindowHandle(*pClass);
    }

    if (hWnd) {
        //
        // Notify the property sheet that it should go to foreground
        // Do not call SetForegroundWindow here because the subclassed
        // treeview control will grab the focus right after
        // we have brought the property sheet to foreground.
        //
        ::PostMessage(hWnd, PSM_QUERYSIBLINGS, QSC_TO_FOREGROUND, 0L);
        return S_OK;
    }

    //
    // No property sheet is up for this cookie, create a brand new property
    // sheet for it.
    //
    SafeInterfacePtr<IComponent> pComponent;
    SafeInterfacePtr<IPropertySheetProvider> pSheetProvider;
    SafeInterfacePtr<IDataObject> pDataObject;
    SafeInterfacePtr<IExtendPropertySheet> pExtendSheet;
    pComponent.Attach((IComponent*) m_pFolder->m_pComponent);

    if (FAILED(pComponent->QueryInterface(IID_IExtendPropertySheet, (void**) &pExtendSheet)) ||
        FAILED(pComponent->QueryDataObject((MMC_COOKIE)pCookie, CCT_RESULT, &pDataObject)) ||
        FAILED(m_pFolder->m_pComponent->m_pConsole->QueryInterface(IID_IPropertySheetProvider,
                                                                   (void**) &pSheetProvider)) ||
        S_OK == pSheetProvider->FindPropertySheet((MMC_COOKIE)pCookie, pComponent, pDataObject) ||
        S_OK != pExtendSheet->QueryPagesFor(pDataObject)) {
        return S_FALSE;
    }

    hr = pSheetProvider->CreatePropertySheet(
                                            pCookie->GetResultItem()->GetDisplayName(),
                                            TRUE, // not wizard
                                            (MMC_COOKIE)pCookie, pDataObject,
                                            MMC_PSO_NOAPPLYNOW  // do not want the apply button
                                            );
    if (SUCCEEDED(hr)) {
        HWND hNotifyWindow;

        if (!SUCCEEDED(m_pFolder->m_pComponent->m_pConsole->GetMainWindow(&hNotifyWindow)))
            hNotifyWindow = NULL;

        hNotifyWindow = FindWindowEx(hNotifyWindow, NULL, TEXT("MDIClient"), NULL);
        hNotifyWindow = FindWindowEx(hNotifyWindow, NULL, TEXT("MMCChildFrm"), NULL);
        hNotifyWindow = FindWindowEx(hNotifyWindow, NULL, TEXT("MMCView"), NULL);
        hr = pSheetProvider->AddPrimaryPages(pComponent, TRUE, hNotifyWindow, FALSE);

        if (SUCCEEDED(hr)) {
            pSheetProvider->AddExtensionPages();
            hr = pSheetProvider->Show((LONG_PTR)hwndTV, 0);
        } else {
            //
            // Failed to add primary Component's property page, destroy
            // the property sheet
            //
            pSheetProvider->Show(-1, 0);
        }
    }

    return hr;
}

// This function creates a context menu for the given cookie
// INPUT:
//      hwndTV  -- the TV OCX window, as the window the context menu to be
//                 attached to.
//      pCookie -- the cookie
//      pPoint  -- the location where the context menu should anchor in
//                 screen coordinate.
HRESULT
CResultView::DoContextMenu(
                          HWND hwndTV,
                          CCookie* pCookie,
                          POINT* pPoint
                          )
{
    HRESULT hr = S_FALSE;
    CMachine *pMachine = NULL;

    //
    // ISSUE: JasonC 8/14/99
    //
    // If we have a valid cookie then we need to get the CMachine for the given
    // cookie if there is one.  Then we need to disable refreshing while the
    // context menu is being displayed.  The reason for this is that if we
    // refresh while the menu is displayed but before the user chooses an option
    // then the cookie is no longer valid.  The real problem here is that we rebuild
    // all of the classes on a refresh which makes any cookie floating around invalid.
    // I am sure that there is more of these bugs lurking around in the code and this
    // needs to be addressed by a better overall change after NT 5.0.
    //
    if (pCookie) {
        CDevice *pDevice;
        CResource *pResource;
        CClass *pClass;

        switch (pCookie->GetType()) {
        
        case COOKIE_TYPE_RESULTITEM_DEVICE:
            pDevice = (CDevice*)pCookie->GetResultItem();
            if (pDevice) {
                pMachine = pDevice->m_pMachine;
            }
            break;

        case COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_DMA:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_IO:
        case COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY:
            pResource = (CResource*)pCookie->GetResultItem();
            if (pResource) {
                pDevice = pResource->GetDevice();

                if (pDevice) {
                    pMachine = pDevice->m_pMachine;
                }
            }
            break;

        case COOKIE_TYPE_RESULTITEM_CLASS:
            pClass = (CClass*)pCookie->GetResultItem();
            if (pClass) {
                pMachine = pClass->m_pMachine;
            }
            break;

        default:
            pMachine = NULL;
        }
    }

    //
    // Disable Refreshing while the context menu is up.
    //
    if (pMachine) {
        pMachine->EnableRefresh(FALSE);
    }

    SafeInterfacePtr<IDataObject> pDataObject;
    SafeInterfacePtr<IContextMenuProvider> pMenuProvider;
    SafeInterfacePtr<IComponent> pComponent;
    pComponent.Attach((IComponent*)m_pFolder->m_pComponent);
    m_hwndTV = hwndTV;

    if (FAILED(pComponent->QueryDataObject((MMC_COOKIE)pCookie, CCT_RESULT, &pDataObject)) ||
        FAILED(m_pFolder->m_pComponent->m_pConsole->QueryInterface(IID_IContextMenuProvider,
                                                                   (void**)&pMenuProvider))) {
        hr = S_FALSE;
        goto clean0;
    }

    pMenuProvider->EmptyMenuList();
    CONTEXTMENUITEM MenuItem;
    MenuItem.strName = NULL;
    MenuItem.strStatusBarText = NULL;
    MenuItem.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
    MenuItem.lInsertionPointID = 0;
    MenuItem.fFlags = 0;
    MenuItem.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

    if (SUCCEEDED(pMenuProvider->AddItem(&MenuItem)) &&
        SUCCEEDED(pMenuProvider->AddPrimaryExtensionItems(pComponent,
                                                          pDataObject)) &&
        SUCCEEDED(pMenuProvider->AddThirdPartyExtensionItems(pDataObject))) {
        long Selected;
        pMenuProvider->ShowContextMenu(hwndTV, pPoint->x, pPoint->y, &Selected);
        hr = S_OK;
        goto clean0;
    }

    clean0:

    //
    // Enable Refreshing again now that the context menu is gone
    //
    if (pMachine) {
        pMachine->EnableRefresh(TRUE);
    }

    return hr;
}

HRESULT
CResultView::DoPrint()
{
    DWORD ReportTypeEnableMask;
    ReportTypeEnableMask = REPORT_TYPE_MASK_ALL;
    HTREEITEM hSelectedItem;
    CCookie* pCookie = NULL;

    m_pMachine->EnableRefresh(FALSE);

    if (m_pIDMTVOCX) {

        hSelectedItem = m_pIDMTVOCX->GetSelectedItem();

        if (hSelectedItem) {

            TV_ITEM TI;
            TI.hItem = hSelectedItem;
            TI.mask = TVIF_PARAM;

            if (SUCCEEDED(m_pIDMTVOCX->GetItem(&TI))) {

                pCookie = (CCookie*)TI.lParam;
            }
        }
    }

    if (!pCookie || (COOKIE_TYPE_RESULTITEM_RESOURCE_IRQ != pCookie->GetType() &&
                     COOKIE_TYPE_RESULTITEM_RESOURCE_DMA != pCookie->GetType() &&
                     COOKIE_TYPE_RESULTITEM_RESOURCE_IO != pCookie->GetType() &&
                     COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY != pCookie->GetType() &&
                     COOKIE_TYPE_RESULTITEM_DEVICE != pCookie->GetType() &&
                     COOKIE_TYPE_RESULTITEM_CLASS != pCookie->GetType())) {

        ReportTypeEnableMask &= ~(REPORT_TYPE_MASK_CLASSDEVICE);
    }

    if (!g_PrintDlg.PrintDlg(m_pMachine->OwnerWindow(), ReportTypeEnableMask)) {

        m_pMachine->EnableRefresh(TRUE);
        return S_OK;
    }

    if (!g_PrintDlg.HDC()) {

        m_pMachine->EnableRefresh(TRUE);
        return E_OUTOFMEMORY;
    }

    //
    // Create the printer
    //
    CPrinter  ThePrinter(m_pMachine->OwnerWindow(), g_PrintDlg.HDC());
    TCHAR DocTitle[MAX_PATH];
    LoadString(g_hInstance, IDS_PRINT_DOC_TITLE, DocTitle, ARRAYLEN(DocTitle));
    int PrintStatus = 0;

    switch (g_PrintDlg.ReportType()) {
    case REPORT_TYPE_SUMMARY:
        PrintStatus = ThePrinter.StartDoc(DocTitle);

        if (PrintStatus) {
            
            ThePrinter.SetPageTitle(IDS_PRINT_SUMMARY_PAGE_TITLE);
            PrintStatus = ThePrinter.PrintResourceSummary(*m_pMachine);
        }
        break;

    case REPORT_TYPE_CLASSDEVICE:
        ASSERT(pCookie);
        PrintStatus = ThePrinter.StartDoc(DocTitle);

        if (PrintStatus) {

            ThePrinter.SetPageTitle(IDS_PRINT_CLASSDEVICE_PAGE_TITLE);

            if (COOKIE_TYPE_RESULTITEM_CLASS == pCookie->GetType()) {
                
                PrintStatus = ThePrinter.PrintClass((CClass*)pCookie->GetResultItem());

            } else {
                
                CDevice* pDevice;

                if (COOKIE_TYPE_RESULTITEM_DEVICE == pCookie->GetType()) {
                    
                    pDevice = (CDevice*) pCookie->GetResultItem();
                
                } else {
                    
                    //
                    // This is a resource item, get the pointer for the
                    // device object from the resource object.
                    //
                    CResource* pResource = (CResource*) pCookie->GetResultItem();
                    ASSERT(pResource);
                    pDevice = pResource->GetDevice();
                }

                ASSERT(pDevice);
                PrintStatus = ThePrinter.PrintDevice(pDevice);
            }
        }
        break;

    case REPORT_TYPE_SUMMARY_CLASSDEVICE:
        PrintStatus = ThePrinter.StartDoc(DocTitle);

        if (PrintStatus) {
            
            ThePrinter.SetPageTitle(IDS_PRINT_SUMMARY_CLASSDEVICE_PAGE_TITLE);
            PrintStatus = ThePrinter.PrintAll(*m_pMachine);
        }
        break;

    default:
        ASSERT(FALSE);
        break;
    }

    //
    // Flush the last page
    //
    ThePrinter.FlushPage();

    if (PrintStatus) {

        ThePrinter.EndDoc();
    
    } else {

        ThePrinter.AbortDoc();
    }

    m_pMachine->EnableRefresh(TRUE);

    return S_OK;
}

HRESULT
CResultView::RemoveDevice(
                         CDevice* pDevice
                         )
{
    //
    // Must be an admin and on the local machine to remove a device.
    //
    if (!m_pMachine->IsLocal() || !g_IsAdmin) {
        
        return S_FALSE;
    }

    //
    // Make sure the device can be uninstalled
    //
    if (!pDevice->IsUninstallable()) {

        return S_FALSE;
    }

    //
    // Make sure there is no property sheet up for this device.
    // If it does exist, show a message box for the user and bring up
    // the property sheet to the foreground if the user
    // agree to do so.
    //
    HWND hwndPropSheet;
    hwndPropSheet = pDevice->m_psd.GetWindowHandle();
    int MsgBoxResult;
    TCHAR szText[MAX_PATH];

    if (hwndPropSheet) {
        LoadResourceString(IDS_PROPSHEET_WARNING, szText, ARRAYLEN(szText));
        MsgBoxResult = m_pFolder->m_pComponent->MessageBox(szText,
                                                           pDevice->GetDisplayName(),
                                                           MB_ICONEXCLAMATION | MB_OKCANCEL);

        if (IDOK == MsgBoxResult) {
            SetForegroundWindow(hwndPropSheet);
        }

        //
        // Can not wait for the property sheet because it is running
        // in a separate thread.
        //
        return S_OK;
    }

    BOOL Refresh = (pDevice->IsPhantom() || 
                    pDevice->HasProblem() || 
                    !pDevice->IsStarted());

    CRemoveDevDlg TheDlg(pDevice);

    //
    // Before removing device, disable refresh. This effectively disables
    // device change notification processing. While we are in the middle
    // of removing device, it is not a good idea to process any
    // device change notification. When the removal is done,
    // we will re-enable the refresh.
    //
    m_pMachine->EnableRefresh(FALSE);

    if (IDOK == TheDlg.DoModal(m_hwndTV, (LPARAM) &TheDlg)) {
        DWORD DiFlags;
        DiFlags = m_pMachine->DiGetFlags(*pDevice);

        //
        // We don't check to see if we are running locally at this
        // point because we won't let the user remove the device in
        // the first place if we are not running locally.
        //
        if (PromptForRestart(NULL, DiFlags, IDS_REMOVEDEV_RESTART) == IDNO) {

            Refresh = TRUE;
        }

        //
        // Enable refresh since we disabled it in the beginning.
        //
        // We only need to force a refresh here if the device that
        // was removed was a Phantom device or a device that is not
        // started.  This is because Phantom devices don't have kernel
        // devnodes and so they won't generate a WM_DEVICECHANGE like 
        // live started devnodes will.
        //
        if (Refresh) {

            m_pMachine->ScheduleRefresh();
        }

        m_pMachine->EnableRefresh(TRUE);
    }

    else {
        m_pMachine->EnableRefresh(TRUE);
    }

    return S_OK;
}

/////////////////////////////////////////////////////////////////////
//// CViewDeviceTree implementations
////

HRESULT
CViewDeviceTree::OnShow(
                       BOOL fShow
                       )
{
    if (!fShow) {
        return S_OK;
    }

    if (!m_pCookieComputer) {
        CreateDeviceTree();
    }

    return CResultView::OnShow(fShow);
}

// This function creates a the root device for the device tree.
// INPUT:
//      NONE.
// OUTPUT:
//      TRUE if the device is created(Rooted at m_pCookieComputer).
//      FALSE if the device is not created.
BOOL
CViewDeviceTree::CreateDeviceTree()
{
    ASSERT(NULL == m_pCookieComputer);
    m_pMachine = m_pFolder->m_pMachine;

    //
    // We shouldn't be here if there is not a machine created.
    //
    ASSERT(m_pMachine);

    CComputer* pComputer = m_pMachine->m_pComputer;

    //
    // Make sure there is at least a computer
    //
    if (pComputer) {
        m_pCookieComputer = new CCookie(COOKIE_TYPE_RESULTITEM_COMPUTER);

        if (m_pCookieComputer) {

            m_pCookieComputer->SetResultItem(pComputer);
            m_pCookieComputer->SetScopeItem(m_pFolder->m_pScopeItem);

            //
            // Make sure that the computer is expanded and selected.
            //
            m_pCookieComputer->TurnOnFlags(COOKIE_FLAGS_EXPANDED);

            //
            // If there was no selection, choose the computer
            //
            if (!m_pSelectedItem || (*m_pSelectedItem == *m_pCookieComputer)) {
                m_pSelectedCookie = m_pCookieComputer;
            }

            return TRUE;
        }
    }

    return FALSE;
}

/////////////////////////////////////////////////////////////////////
//// CViewTreeByType implementations
////

// This function creates a "view-by-type: device tree rooted at
// m_pCookieComputer.
//
// INPUT:
//      NONE.
// OUTPUT:
//      TRUE if the tree is created successfully.
//      FALSE if tree is not created.
BOOL
CViewTreeByType::CreateDeviceTree()
{
    if (!CViewDeviceTree::CreateDeviceTree()) {
        return FALSE;
    }

    ASSERT(m_pCookieComputer);
    CClass* pClass;
    CDevice* pDevice;
    CCookie* pCookieClass;
    CCookie* pCookieClassParent;
    CCookie* pCookieClassSibling;
    CCookie* pCookieDevice;
    CCookie* pCookieDeviceParent;
    CCookie* pCookieDeviceSibling;

    //
    // Do not have sibling at this moment;
    //
    pCookieClassSibling = NULL;

    //
    // All classes are children of computer
    //
    pCookieClassParent = m_pCookieComputer;

    pCookieDeviceParent;
    pCookieDeviceSibling;
    String strStartupDeviceId;
    strStartupDeviceId = GetStartupDeviceId();
    PVOID ContextClass, ContextDevice;

    if (m_pMachine->GetFirstClass(&pClass, ContextClass)) {
        do {
            //
            // We do not display a class if it does not have any
            // devices in it.
            //
            if (pClass->GetNumberOfDevices(TRUE)) {
                pCookieClass = new CCookie(COOKIE_TYPE_RESULTITEM_CLASS);
                pCookieClass->SetResultItem(pClass);
                pCookieClass->SetScopeItem(m_pFolder->m_pScopeItem);

                //
                // If the class was expanded before, mark it
                // so that DisplayTree will expand it
                //
                RestoreSavedTreeState(pCookieClass);

                //
                // No sibling: this is the first child
                //
                if (pCookieClassParent && !pCookieClassSibling) {
                    pCookieClassParent->SetChild(pCookieClass);
                }

                pCookieClass->SetParent(pCookieClassParent);

                if (pCookieClassSibling) {
                    pCookieClassSibling->SetSibling(pCookieClass);
                }

                pCookieClassSibling = pCookieClass;

                //
                // Classes are parent of devices
                //
                pCookieDeviceParent = pCookieClass;
                pCookieDeviceSibling = NULL;

                if (pClass->GetFirstDevice(&pDevice, ContextDevice)) {
                    do {
                        pCookieDevice = new CCookie(COOKIE_TYPE_RESULTITEM_DEVICE);
                        pCookieDevice->SetResultItem(pDevice);
                        pCookieDevice->SetScopeItem(m_pFolder->m_pScopeItem);

                        if (!strStartupDeviceId.IsEmpty() &&
                            !strStartupDeviceId.CompareNoCase(pDevice->GetDeviceID())) {
                            m_pSelectedCookie = pCookieDevice;
                        } else {
                            if (m_pSelectedItem && (*m_pSelectedItem == *pCookieDevice)) {
                                m_pSelectedCookie = pCookieDevice;
                            }
                        }

                        //
                        // No sibling: this is the first child
                        //
                        if (pCookieDeviceParent && !pCookieDeviceSibling) {
                            pCookieDeviceParent->SetChild(pCookieDevice);
                        }

                        pCookieDevice->SetParent(pCookieDeviceParent);

                        if (pCookieDeviceSibling) {
                            pCookieDeviceSibling->SetSibling(pCookieDevice);
                        }

                        pCookieDeviceSibling = pCookieDevice;

                    } while (pClass->GetNextDevice(&pDevice, ContextDevice));
                }
            }

        } while (m_pMachine->GetNextClass(&pClass, ContextClass));
    }

    DestroySavedTreeStates();

    return TRUE;
}

/////////////////////////////////////////////////////////////////////
//// CViewTreeByConnection implementations
////

BOOL
CViewTreeByConnection::CreateDeviceTree()
{
    if (!CViewDeviceTree::CreateDeviceTree()) {
        return FALSE;
    }

    ASSERT(m_pCookieComputer);
    CComputer* pComputer = (CComputer*)m_pCookieComputer->GetResultItem();
    CDevice* pDeviceStart = pComputer->GetChild();
    ASSERT(pDeviceStart);

    //
    // Collect all the normal devices.
    //
    CreateSubtree(m_pCookieComputer, NULL, pDeviceStart);

    //
    // Add phantom devices to m_pCookieComputer subtree.
    //
    PVOID Context;

    if (m_pMachine->GetFirstDevice(&pDeviceStart, Context)) {
        //
        // Locate the end of the CookieComputer Sibling list to add the
        // phantom devices to.
        //
        CCookie* pCookieSibling = NULL;
        CCookie* pNext = m_pCookieComputer->GetChild();

        while (pNext != NULL) {
            pCookieSibling = pNext;
            pNext = pCookieSibling->GetSibling();
        }

        do {
            if (pDeviceStart->IsPhantom()) {
                CCookie* pCookie;
                pCookie = new CCookie(COOKIE_TYPE_RESULTITEM_DEVICE);
                pCookie->SetResultItem(pDeviceStart);
                pCookie->SetScopeItem(m_pFolder->m_pScopeItem);

                if (pCookieSibling) {
                    pCookieSibling->SetSibling(pCookie);
                } else {
                    m_pCookieComputer->SetChild(pCookie);
                }

                pCookie->SetParent(m_pCookieComputer);
                pCookieSibling = pCookie;

                //
                // See if we have to expand the node
                //
                RestoreSavedTreeState(pCookie);
            }

        } while (m_pMachine->GetNextDevice(&pDeviceStart, Context));
    }

    DestroySavedTreeStates();

    return TRUE;
}

//
//This function creates a cookie subtree by walking down the
//a device subtree led by the given pDeviceStart
//INPUT:
//  pCookieParent -- the parent of the newly created subtree
//  pCookieSibling -- the sibling of the newly create subtree
//  pDeviceStart   -- the device to start with
//
//OUTPUT:
//  TRUE if the subtree is created and inserted successfully.
//
// This function may throw CMemoryException
//
BOOL
CViewTreeByConnection::CreateSubtree(
                                    CCookie* pCookieParent,
                                    CCookie* pCookieSibling,
                                    CDevice* pDeviceStart
                                    )
{
    CCookie* pCookie;
    CDevice* pDeviceChild;
    String strStartupDeviceId;
    CClass*  pClass;
    strStartupDeviceId = GetStartupDeviceId();

    while (pDeviceStart) {
        pClass = pDeviceStart->GetClass();

        pCookie = new CCookie(COOKIE_TYPE_RESULTITEM_DEVICE);

        if (pCookie) {
            pCookie->SetResultItem(pDeviceStart);
            pCookie->SetScopeItem(m_pFolder->m_pScopeItem);

            if (!strStartupDeviceId.IsEmpty() &&
                !strStartupDeviceId.CompareNoCase(pDeviceStart->GetDeviceID())) {
                m_pSelectedCookie = pCookie;
            }

            //
            // No sibling: this is the first child
            //
            if (pCookieParent && !pCookieSibling) {
                pCookieParent->SetChild(pCookie);
            }

            pCookie->SetParent(pCookieParent);

            if (pCookieSibling) {
                pCookieSibling->SetSibling(pCookie);
            }

            //
            // See if we have to expand the node
            //
            RestoreSavedTreeState(pCookie);

            pDeviceChild = pDeviceStart->GetChild();

            if (pDeviceChild) {
                CreateSubtree(pCookie, NULL, pDeviceChild);
            }

            pCookieSibling = pCookie;

        }

        pDeviceStart = pDeviceStart->GetSibling();
    }

    return TRUE;
}

/////////////////////////////////////////////////////////////////////
//// CViewResourceTree implementations
////

CViewResourceTree::~CViewResourceTree()
{
    int i;

    //
    // Destroy all the CResource objects
    //
    for (i = 0; i < TOTAL_RESOURCE_TYPES; i++) {
        if (m_pResourceList[i]) {
            delete m_pResourceList[i];
            m_pResourceList[i] = NULL;
        }

        if (m_pResourceType[i]) {
            delete m_pResourceType[i];
            m_pResourceType[i] = NULL;
        }
    }
}

//
// This functions handle MMC standard MMCN_SHOW command
//
// This function may throw CMemoryException
//
HRESULT
CViewResourceTree::OnShow(
                         BOOL fShow
                         )
{
    if (!fShow) {
        return S_OK;
    }

    if (!m_pCookieComputer) {
        CreateResourceTree();
    }

    return CResultView::OnShow(fShow);
}

//
// This function creates resource lists and cookie trees.
// The resources are recorded in the member m_pResourceList[]
// and the cookie tree is rooted at m_pCookieComputer[];
//
// This function may throw CMemoryException
//
void
CViewResourceTree::CreateResourceTree()
{
    int i;
    CCookie* pCookieTypeSibling = NULL;

    ASSERT(!m_pCookieComputer);
    m_pMachine = m_pFolder->m_pMachine;
    ASSERT(m_pMachine);

    //
    // Make sure there is at least a computer.
    //
    if (!m_pMachine->m_pComputer) {
        return;
    }

    m_pCookieComputer = new CCookie(COOKIE_TYPE_RESULTITEM_COMPUTER);

    if (!m_pCookieComputer) {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return;
    }

    m_pCookieComputer->SetResultItem(m_pMachine->m_pComputer);
    m_pCookieComputer->SetScopeItem(m_pFolder->m_pScopeItem);
    m_pCookieComputer->TurnOnFlags(COOKIE_FLAGS_EXPANDED);

    //
    // If no selected item recorded, default to the computer node
    //
    if (!m_pSelectedItem || (*m_pSelectedItem == *m_pCookieComputer)) {
        m_pSelectedCookie = m_pCookieComputer;
    }

    //
    // Check each resource type (mem, io, dma, irq) and create a result item
    // if resources exist for the resource type.
    //
    for (i = 0; i < TOTAL_RESOURCE_TYPES; i++) {
        RESOURCEID ResType = ResourceTypes[i];

        //
        // If there is an existing m_pResourceList then delete it.
        //
        if (m_pResourceList[i]) {
            delete m_pResourceList[i];    
        }

        m_pResourceList[i] = new CResourceList(m_pMachine, ResType);

        PVOID Context;
        CResource* pRes;

        if (m_pResourceList[i] && 
            m_pResourceList[i]->GetFirst(&pRes, Context)) {
            //
            // Resource items exist, create the resource type result item.
            //
            CCookie* pCookieFirst = NULL;

            //
            // If there is an existing m_pResourceType then delete it.
            //
            if (m_pResourceType[i]) {
                delete m_pResourceType[i];
            }

            m_pResourceType[i] = new CResourceType(m_pMachine, ResType);

            CCookie* pCookieType = new CCookie(COOKIE_TYPE_RESULTITEM_RESTYPE);

            if (pCookieType) {
                pCookieType->SetResultItem(m_pResourceType[i]);
                pCookieType->SetScopeItem(m_pFolder->m_pScopeItem);
                pCookieType->SetParent(m_pCookieComputer);

                if (pCookieTypeSibling) {
                    pCookieTypeSibling->SetSibling(pCookieType);
                } else {
                    m_pCookieComputer->SetChild(pCookieType);
                }
                pCookieTypeSibling = pCookieType;

                RestoreSavedTreeState(pCookieType);

                //
                // Create the resource result item for each resource.
                //
                while (pRes) {
                    CCookie* pCookie = new CCookie(CookieType(ResType));
                    pCookie->SetResultItem(pRes);
                    pCookie->SetScopeItem(m_pFolder->m_pScopeItem);

                    if (pCookieFirst) {
                        InsertCookieToTree(pCookie, pCookieFirst, TRUE);
                    } else {
                        pCookieFirst = pCookie;
                        pCookieType->SetChild(pCookie);
                        pCookie->SetParent(pCookieType);
                    }
                    RestoreSavedTreeState(pCookie);

                    //
                    // Get the next resource item.
                    //
                    m_pResourceList[i]->GetNext(&pRes, Context);
                }
            }
        }
    }

    //
    // The saved tree states have been merged into the newly
    // create cookie tree. destroy the states
    //
    DestroySavedTreeStates();
}

//
// This function insert the given cookie into a existing cookie subtree
// rooted at pCookieRoot.  If the resource is I/O or MEMORY then the cookie is
// inserted as a child of any resource it is enclosed by.
//
//INPUT:
//     pCookie -- the cookie to be inserted.
//     pCookieRoot -- the subtree root cookie
//     ForcedInsert -- TRUE to insert the cookie as the sibling of
//                     of pCookieRoot.
//OUTPUT:
//  None
BOOL
CViewResourceTree::InsertCookieToTree(
                                     CCookie* pCookie,
                                     CCookie* pCookieRoot,
                                     BOOL     ForcedInsert
                                     )
{
    CResource* pResRef;
    CResource* pResThis = (CResource*)pCookie->GetResultItem();
    CCookie* pCookieLast = NULL;

    while (pCookieRoot) {
        //
        // Only check for enclosed resources for I/O and MEMORY.
        //
        if (COOKIE_TYPE_RESULTITEM_RESOURCE_IO == pCookie->GetType() ||
            COOKIE_TYPE_RESULTITEM_RESOURCE_MEMORY == pCookie->GetType()) {
            pResRef = (CResource*)pCookieRoot->GetResultItem();

            if (pResThis->EnclosedBy(*pResRef)) {
                //
                // This cookie is either the pCookieRoot child or grand child
                // figure out which one it is
                //
                if (!pCookieRoot->GetChild()) {
                    pCookieRoot->SetChild(pCookie);
                    pCookie->SetParent(pCookieRoot);
                } else if (!InsertCookieToTree(pCookie, pCookieRoot->GetChild(), FALSE)) {
                    //
                    // The cookie is not a grand child of pCookieRoot.
                    // search for the last child of pCookieRoot
                    //
                    CCookie* pCookieSibling;
                    pCookieSibling = pCookieRoot->GetChild();

                    while (pCookieSibling->GetSibling()) {
                        pCookieSibling = pCookieSibling->GetSibling();
                    }

                    pCookieSibling->SetSibling(pCookie);
                    pCookie->SetParent(pCookieRoot);
                }

                return TRUE;
            }
        }

        pCookieLast = pCookieRoot;
        pCookieRoot = pCookieRoot->GetSibling();
    }

    if (ForcedInsert) {
        if (pCookieLast) {
            //
            // When we reach here, pCookieLast is the last child
            //
            pCookieLast->SetSibling(pCookie);
            pCookie->SetParent(pCookieLast->GetParent());
        }

        return TRUE;
    }

    return FALSE;
}

/////////////////////////////////////////////////////////////////////
//// CBusPropPageProvider implementations
////

//
// This function loads the bus property sheet pages provider
// to enumerate pages for the device
// INPUT:
//      pDevice -- object represents the device
//      ppsd    -- object represents where property pages should be added
// OUTPUT:
//      TRUE if succeeded.
//      FLASE if no pages are added.
BOOL
CBusPropPageProvider::EnumPages(
                               CDevice* pDevice,
                               CPropSheetData* ppsd
                               )
{
    ASSERT(!m_hDll);

    //
    // Enum bus property pages if there are any
    // if the a bus guid can not be found on the device, no bus property pages
    //
    String strBusGuid;

    if (pDevice->m_pMachine->CmGetBusGuidString(pDevice->GetDevNode(), strBusGuid)) {
        CSafeRegistry regDevMgr;
        CSafeRegistry regBusTypes;
        CSafeRegistry regBus;

        if (regDevMgr.Open(HKEY_LOCAL_MACHINE, REG_PATH_DEVICE_MANAGER) &&
            regBusTypes.Open(regDevMgr, REG_STR_BUS_TYPES) &&
            regBus.Open(regBusTypes, strBusGuid)) {
            String strEnumPropPage;

            if (regBus.GetValue(REGSTR_VAL_ENUMPROPPAGES_32, strEnumPropPage)) {
                PROPSHEET_PROVIDER_PROC PropPageProvider;

                if (LoadEnumPropPage32(strEnumPropPage, &m_hDll, (FARPROC*)&PropPageProvider)) {
                    SP_PROPSHEETPAGE_REQUEST PropPageRequest;
                    PropPageRequest.cbSize = sizeof(PropPageRequest);
                    PropPageRequest.DeviceInfoSet = (HDEVINFO)*(pDevice->m_pMachine);
                    PropPageRequest.DeviceInfoData = *pDevice;
                    PropPageRequest.PageRequested = SPPSR_ENUM_ADV_DEVICE_PROPERTIES;

                    if (PropPageProvider(&PropPageRequest,
                                         (LPFNADDPROPSHEETPAGE)AddPropPageCallback,
                                         (LPARAM)ppsd
                                        ))
                        return TRUE;
                }
            }
        }
    }

    return FALSE;
}