/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
        dhcphand.cpp
                DHCP specifc handler base classes

    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "dhcphand.h"
#include "snaputil.h"  // For CGUIDArray
#include "extract.h"   // For ExtractInternalFormat
#include "nodes.h"
#include "classmod.h"

STDMETHODIMP
CMTDhcpHandler::DestroyHandler( ITFSNode *pNode )
{
    // Destroy any open property sheets
    DestroyPropSheets();

    return CMTHandler::DestroyHandler( pNode );

} // CMTDhcpHandler::DestroyHandler()

//
// Called by the result handler when a command comes in that isn't handled 
// by the result handler.  If appropriate it passes it to the scope pane hander.
//
HRESULT
CMTDhcpHandler::HandleScopeCommand
(
        MMC_COOKIE      cookie, 
        int                             nCommandID,
        LPDATAOBJECT    pDataObject
)
{
    HRESULT             hr = hrOK;
    SPITFSNode          spNode;
    DATA_OBJECT_TYPES   dwType = CCT_RESULT;

    if (IS_SPECIAL_DATAOBJECT(pDataObject))
    {
        dwType = CCT_SCOPE;
    }
    else
    {
        if (pDataObject)
        {
                        SPINTERNAL                  spInternal;

            spInternal = ::ExtractInternalFormat(pDataObject);
                        if (spInternal)
                                dwType = spInternal->m_type;
        }
    }

    if (dwType == CCT_SCOPE)
    {
        // call the handler to take care of this
            CORg (m_spNodeMgr->FindNode(cookie, &spNode));

        hr = OnCommand(spNode, nCommandID, dwType, pDataObject, (ULONG) spNode->GetData(TFS_DATA_TYPE));
    }
        
Error:
    return hr;
}

//
// Called by the result handler to add the scope pane menu items to the menu
// where appropriate.  Puts scope pane menu items in when action menu is clicked
// and the message view has focus as well as when a right click happens in the white 
// space of the result pane.
//
HRESULT
CMTDhcpHandler::HandleScopeMenus
(
        MMC_COOKIE                              cookie,
        LPDATAOBJECT                    pDataObject, 
        LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
        long *                                  pInsertionAllowed
)
{
    HRESULT             hr = hrOK;
    SPITFSNode          spNode;
    DATA_OBJECT_TYPES   dwType = CCT_RESULT;

    if (IS_SPECIAL_DATAOBJECT(pDataObject))
    {
        dwType = CCT_SCOPE;
    }
    else
    {
        if (pDataObject)
        {
                        SPINTERNAL                  spInternal;

            spInternal = ::ExtractInternalFormat(pDataObject);
                        if (spInternal)
                                dwType = spInternal->m_type;
        }
    }

    if (dwType == CCT_SCOPE)
    {
        // call the normal handler to put up the menu items
            CORg (m_spNodeMgr->FindNode(cookie, &spNode));

        hr = OnAddMenuItems(spNode, pContextMenuCallback, pDataObject, CCT_SCOPE, (ULONG) spNode->GetData(TFS_DATA_TYPE), pInsertionAllowed);
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
        CMTDhcpHandler::Command
                Description
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CMTDhcpHandler::Command
(
    ITFSComponent * pComponent, 
        MMC_COOKIE              cookie, 
        int                             nCommandID,
        LPDATAOBJECT    pDataObject
)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());

        HRESULT hr = S_OK;

    // this may have come from the scope pane handler, so pass it up
    hr = HandleScopeCommand(cookie, nCommandID, pDataObject);

    return hr;
}


/*!--------------------------------------------------------------------------
        CMTDhcpHandler::AddMenuItems
                Over-ride this to add our view menu item
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CMTDhcpHandler::AddMenuItems
(
    ITFSComponent *         pComponent, 
        MMC_COOKIE                              cookie,
        LPDATAOBJECT                    pDataObject, 
        LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
        long *                                  pInsertionAllowed
)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

        HRESULT hr = S_OK;

    // figure out if we need to pass this to the scope pane menu handler
    hr = HandleScopeMenus(cookie, pDataObject, pContextMenuCallback, pInsertionAllowed);
    
    return hr;
}

/*---------------------------------------------------------------------------
        CMTDhcpHandler::OnChangeState
                Description
        Author: EricDav
 ---------------------------------------------------------------------------*/
void CMTDhcpHandler::OnChangeState
(
        ITFSNode * pNode
)
{
        // Increment the state to the next position
        switch (m_nState)
        {
                case notLoaded:
                case loaded:
                case unableToLoad:
                        {
                                m_nState = loading;
                                m_dwErr = 0;
                        }
                        break;

                case loading:
                        {
                                m_nState = (m_dwErr != 0) ? unableToLoad : loaded;
                
                if (m_dwErr)
                {
                    CString strTitle, strBody;
                    IconIdentifier icon;

                    GetErrorMessages(strTitle, strBody, &icon);

                    if (!strBody.IsEmpty())
                        ShowMessage(pNode, strTitle, strBody, icon);
                    else
                        ClearMessage(pNode);
                }
                else
                {
                    ClearMessage(pNode);
                }

                m_fSilent = FALSE;
                        }
                        break;
        
                default:
                        ASSERT(FALSE);
        }

    // check to make sure we are still the visible node in the UI
    if (m_bSelected)
    {
        UpdateStandardVerbs(pNode, pNode->GetData(TFS_DATA_TYPE));

        SendUpdateToolbar(pNode, m_bSelected);
    }

    // Now check and see if there is a new image for this state for this handler
        int nImage, nOpenImage;

        nImage = GetImageIndex(FALSE);
        nOpenImage = GetImageIndex(TRUE);

        if (nImage >= 0)
                pNode->SetData(TFS_DATA_IMAGEINDEX, nImage);

        if (nOpenImage >= 0)
                pNode->SetData(TFS_DATA_OPENIMAGEINDEX, nOpenImage);
        
        VERIFY(SUCCEEDED(pNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM)));
}

 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::GetErrorMessages
                Default message view text for errors
        Author: EricDav
 ---------------------------------------------------------------------------*/
void CMTDhcpHandler::GetErrorMessages
(
    CString & strTitle, 
    CString & strBody, 
    IconIdentifier * icon
)
{
    TCHAR chMesg [4000] = {0};
    BOOL bOk ;

    UINT nIdPrompt = (UINT) m_dwErr;
    CString strTemp;

    strTitle.LoadString(IDS_SERVER_MESSAGE_CONNECT_FAILED_TITLE);

    bOk = LoadMessage(nIdPrompt, chMesg, sizeof(chMesg)/sizeof(chMesg[0]));

    AfxFormatString1(strBody, IDS_SERVER_MESSAGE_CONNECT_FAILED_BODY, chMesg);

    strTemp.LoadString(IDS_SERVER_MESSAGE_CONNECT_FAILED_REFRESH);
    strBody += strTemp;

    if (icon)
        *icon = Icon_Error;
}


 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::UpdateStandardVerbs
                Tells the IComponent to update the verbs for this node
        Author: EricDav
 ---------------------------------------------------------------------------*/
void
CMTDhcpHandler::UpdateStandardVerbs
(
    ITFSNode * pNode,
    LONG_PTR   dwNodeType
)
{
    HRESULT                             hr = hrOK;
    SPIComponentData    spCompData;
        SPIConsole                      spConsole;
    IDataObject*                pDataObject;

    m_spNodeMgr->GetComponentData(&spCompData);

    CORg ( spCompData->QueryDataObject(NULL, CCT_RESULT, &pDataObject) );

    CORg ( m_spNodeMgr->GetConsole(&spConsole) );

    CORg ( spConsole->UpdateAllViews(pDataObject, 
                                     reinterpret_cast<LONG_PTR>(pNode), 
                                     RESULT_PANE_UPDATE_VERBS) ); 

    pDataObject->Release();
        
Error:
    return;
}

 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::SendUpdateToolbar
                Tells the IComponent to update the verbs for this node
        Author: EricDav
 ---------------------------------------------------------------------------*/
void
CMTDhcpHandler::SendUpdateToolbar
(
    ITFSNode * pNode,
    BOOL       fSelected
)
{
    HRESULT                             hr = hrOK;
    SPIComponentData    spCompData;
        SPIConsole                      spConsole;
    IDataObject*                pDataObject = NULL;
    CToolbarInfo *      pToolbarInfo = NULL;

    COM_PROTECT_TRY
    {
        m_spNodeMgr->GetComponentData(&spCompData);

        CORg ( spCompData->QueryDataObject(NULL, CCT_RESULT, &pDataObject) );

        CORg ( m_spNodeMgr->GetConsole(&spConsole) );

        pToolbarInfo = new CToolbarInfo;

        pToolbarInfo->spNode.Set(pNode);
        pToolbarInfo->fSelected = fSelected;
        
        CORg ( spConsole->UpdateAllViews(pDataObject, 
                                         reinterpret_cast<LONG_PTR>(pToolbarInfo), 
                                         DHCPSNAP_UPDATE_TOOLBAR) ); 

    }
    COM_PROTECT_CATCH

    COM_PROTECT_ERROR_LABEL; 

    if (pDataObject)
        pDataObject->Release();              

    if (pToolbarInfo)
        delete pToolbarInfo;

    return;
}


 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::ExpandNode
                Expands/compresses this node
        Author: EricDav
 ---------------------------------------------------------------------------*/
void
CMTDhcpHandler::ExpandNode
(
    ITFSNode *  pNode,
    BOOL        fExpand
)
{
    SPIComponentData    spCompData;
    SPIDataObject       spDataObject;
    LPDATAOBJECT        pDataObject;
    SPIConsole          spConsole;
    HRESULT             hr = hrOK;

    // don't expand the node if we are handling the EXPAND_SYNC message,
    // this screws up the insertion of item, getting duplicates.
    if (!m_fExpandSync)
    {
        m_spNodeMgr->GetComponentData(&spCompData);

            CORg ( spCompData->QueryDataObject((MMC_COOKIE) pNode, CCT_SCOPE, &pDataObject) );
        spDataObject = pDataObject;

        CORg ( m_spNodeMgr->GetConsole(&spConsole) );
            CORg ( spConsole->UpdateAllViews(pDataObject, TRUE, RESULT_PANE_EXPAND) ); 
    }

Error:
    return;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnCreateDataObject
                -
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CMTDhcpHandler::OnCreateDataObject
(
    ITFSComponent *     pComponent,
        MMC_COOKIE              cookie, 
        DATA_OBJECT_TYPES       type, 
        IDataObject **          ppDataObject
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    Assert(ppDataObject != NULL);

        CDataObject *       pObject = NULL;
        SPIDataObject       spDataObject;

    pObject = new CDataObject;
        spDataObject = pObject; // do this so that it gets released correctly
                                                
    Assert(pObject != NULL);

    if (cookie == MMC_MULTI_SELECT_COOKIE)
    {
        CreateMultiSelectData(pComponent, pObject);
    }

    // Save cookie and type for delayed rendering
    pObject->SetType(type);
    pObject->SetCookie(cookie);

    // Store the coclass with the data object
    pObject->SetClsid(*(m_spTFSComponentData->GetCoClassID()));

        pObject->SetTFSComponentData(m_spTFSComponentData);

    return  pObject->QueryInterface(IID_IDataObject, 
                                                                        reinterpret_cast<void**>(ppDataObject));
}

HRESULT
CMTDhcpHandler::CreateMultiSelectData(ITFSComponent * pComponent, CDataObject * pObject)
{
    HRESULT hr = hrOK;

    // build the list of selected nodes
        CTFSNodeList listSelectedNodes;
    CGUIDArray   rgGuids;
    UINT         cb;
    GUID*        pGuid;

    COM_PROTECT_TRY
    {
        CORg (BuildSelectedItemList(pComponent, &listSelectedNodes));

        // collect all of the unique guids
        while (listSelectedNodes.GetCount() > 0)
            {
                    SPITFSNode   spCurNode;
            const GUID * pGuid1;

                    spCurNode = listSelectedNodes.RemoveHead();
            pGuid1 = spCurNode->GetNodeType();
        
            rgGuids.AddUnique(*pGuid1);
        }

        // now put the information in the data object
        pObject->SetMultiSelDobj();
        cb = (UINT)(rgGuids.GetSize() * sizeof(GUID));
        
        pGuid = new GUID[UINT(rgGuids.GetSize())];
        CopyMemory(pGuid, rgGuids.GetData(), cb);
        
        pObject->SetMultiSelData((BYTE*)pGuid, cb);

        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::SaveColumns
                -
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CMTDhcpHandler::SaveColumns
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT             hr = hrOK;
    LONG_PTR            dwNodeType;
    int                 nCol = 0;
    int                 nColWidth;
    SPITFSNode          spNode, spRootNode;
    SPIHeaderCtrl       spHeaderCtrl;
    BOOL                bDirty = FALSE;

    if (m_spTFSCompData->GetTaskpadState(GetTaskpadIndex()))
        return hr;

    if (IsMessageView())
        return hr;

    CORg (m_spNodeMgr->FindNode(cookie, &spNode));
    CORg (pComponent->GetHeaderCtrl(&spHeaderCtrl));
    
    dwNodeType = spNode->GetData(TFS_DATA_TYPE);

    while (aColumns[dwNodeType][nCol] != 0)
    {
        hr = spHeaderCtrl->GetColumnWidth(nCol, &nColWidth);
        if (SUCCEEDED(hr) && 
            (nColWidth != 0) &&
            aColumnWidths[dwNodeType][nCol] != nColWidth)
        {
            aColumnWidths[dwNodeType][nCol] = nColWidth;
            bDirty = TRUE;
        }

        nCol++;
    }

    if (bDirty)
    {
        CORg (m_spNodeMgr->GetRootNode(&spRootNode));
                spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnExpandSync
                Handles the MMCN_EXPANDSYNC notifcation 
        We need to do syncronous enumeration.  We'll fire off the background 
        thread like before, but we'll wait for it to exit before we return.
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CMTDhcpHandler::OnExpandSync
(
    ITFSNode *      pNode, 
    LPDATAOBJECT    pDataObject, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    HRESULT hr = hrOK;
    MSG msg;

    m_fExpandSync = TRUE;

    hr = OnExpand(pNode, pDataObject, CCT_SCOPE, arg, lParam);

    // wait for the background thread to exit
    WaitForSingleObject(m_hThread, INFINITE);
    
    // The background thread posts messages to a hidden window to 
    // pass data back to the main thread. The messages won't go through since we are
    // blocking the main thread.  The data goes on a queue in the query object
    // which the handler has a pointer to so we can just fake the notification.
    if (m_spQuery.p)
        OnNotifyHaveData((LPARAM) m_spQuery.p);

    // Tell MMC we handled this message
    MMC_EXPANDSYNC_STRUCT * pES = reinterpret_cast<MMC_EXPANDSYNC_STRUCT *>(lParam);
    if (pES)
        pES->bHandled = TRUE;

    m_fExpandSync = FALSE;

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultSelect
                Handles the MMCN_SELECT notifcation 
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CMTDhcpHandler::OnResultSelect
(
        ITFSComponent * pComponent, 
        LPDATAOBJECT    pDataObject, 
    MMC_COOKIE      cookie,
        LPARAM                  arg, 
        LPARAM                  lParam
)
{
    SPIConsoleVerb  spConsoleVerb;
    SPITFSNode      spNode;
    HRESULT         hr = hrOK;
    SPINTERNAL          spInternal;
    BOOL            bMultiSelect = FALSE;

    CORg (pComponent->GetConsoleVerb(&spConsoleVerb));
    
    spInternal = ::ExtractInternalFormat(pDataObject);
    
    if (spInternal && 
        spInternal->m_cookie == MMC_MULTI_SELECT_COOKIE)
    {
        CORg (pComponent->GetSelectedNode(&spNode));
        bMultiSelect = TRUE;
    }
    else
    {
        CORg (m_spNodeMgr->FindNode(cookie, &spNode));
    }

    UpdateConsoleVerbs(spConsoleVerb, spNode->GetData(TFS_DATA_TYPE), bMultiSelect);

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnRefresh
                Default implementation for the refresh functionality
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnRefresh
(
        ITFSNode *              pNode,
        LPDATAOBJECT    pDataObject,
        DWORD                   dwType,
        LPARAM                  arg,
        LPARAM                  param
)
{
    HRESULT hr = hrOK;
    
    if (m_bExpanded == FALSE)
    {
        // we cannot refresh/add items to a node that hasn't been expanded yet.
        return hr;
    }

    BOOL bLocked = IsLocked();
    if (bLocked)
    {
        // cannot do refresh on locked node, the UI should prevent this
        return hr; 
    }
    
    pNode->DeleteAllChildren(TRUE);
    
    int nVisible, nTotal;
    pNode->GetChildCount(&nVisible, &nTotal);
    Assert(nVisible == 0);
    Assert(nTotal == 0);
    
    m_bExpanded = FALSE;
    OnExpand(pNode, pDataObject, dwType, arg, param); // will spawn a thread to do enumeration
    
    if (m_spTFSCompData->GetTaskpadState(GetTaskpadIndex()) && m_bSelected)
    {
        // tell the taskpad to update
        SPIConsole  spConsole;
        
        m_spTFSCompData->GetConsole(&spConsole);
        spConsole->SelectScopeItem(m_spNode->GetData(TFS_DATA_SCOPEID));
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultUpdateView
                Implementation of ITFSResultHandler::OnResultUpdateView
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CMTDhcpHandler::OnResultUpdateView
(
    ITFSComponent *pComponent, 
    LPDATAOBJECT  pDataObject, 
    LPARAM        data, 
    LPARAM        hint
)
{
        HRESULT hr = hrOK;

    if (hint == RESULT_PANE_UPDATE_VERBS)
    {
            SPIConsoleVerb  spConsoleVerb;
        SPITFSNode      spNode;

        CORg (pComponent->GetConsoleVerb(&spConsoleVerb));

        spNode.Set(reinterpret_cast<ITFSNode *>(data));

        UpdateConsoleVerbs(spConsoleVerb, spNode->GetData(TFS_DATA_TYPE));
    }
    else 
    if (hint == DHCPSNAP_UPDATE_TOOLBAR)
    {
        SPIToolbar spToolbar;
        CToolbarInfo * pToolbarInfo;

        CORg (pComponent->GetToolbar(&spToolbar));

        pToolbarInfo = reinterpret_cast<CToolbarInfo *>(data);

        if (pToolbarInfo && spToolbar)
        {
            UpdateToolbar(spToolbar, pToolbarInfo->spNode->GetData(TFS_DATA_TYPE), pToolbarInfo->fSelected);
        }
    }
    else
    {
        return CBaseResultHandler::OnResultUpdateView(pComponent, pDataObject, data, hint);
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultContextHelp
                Implementation of ITFSResultHandler::OnResultContextHelp
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CMTDhcpHandler::OnResultContextHelp
(
    ITFSComponent * pComponent, 
    LPDATAOBJECT    pDataObject, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT         hr = hrOK;
    SPIDisplayHelp  spDisplayHelp;
    SPIConsole      spConsole;

    pComponent->GetConsole(&spConsole);

    hr = spConsole->QueryInterface (IID_IDisplayHelp, (LPVOID*) &spDisplayHelp);
        ASSERT (SUCCEEDED (hr));
        if ( SUCCEEDED (hr) )
        {
        LPCTSTR pszHelpFile = m_spTFSCompData->GetHTMLHelpFileName();
        if (pszHelpFile == NULL)
            goto Error;

        CString szHelpFilePath;
            UINT nLen = ::GetWindowsDirectory (szHelpFilePath.GetBufferSetLength(2 * MAX_PATH), 2 * MAX_PATH);
            if (nLen == 0)
        {
                    hr = E_FAIL;
            goto Error;
        }

            szHelpFilePath.ReleaseBuffer();
        szHelpFilePath += g_szDefaultHelpTopic;

                hr = spDisplayHelp->ShowTopic (T2OLE ((LPTSTR)(LPCTSTR) szHelpFilePath));
                ASSERT (SUCCEEDED (hr));
    }

Error:
    return hr;
}

 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::UpdateStandardVerbs
                Updates the standard verbs depending upon the state of the node
        Author: EricDav
 ---------------------------------------------------------------------------*/
void
CMTDhcpHandler::UpdateConsoleVerbs
(
    IConsoleVerb * pConsoleVerb,
    LONG_PTR       dwNodeType,
    BOOL           bMultiSelect
)
{
    BOOL                bStates[ARRAYLEN(g_ConsoleVerbs)];      
    MMC_BUTTON_STATE *  ButtonState;
    int                 i;
    
    if (bMultiSelect)
    {
        ButtonState = g_ConsoleVerbStatesMultiSel[dwNodeType];
        for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = TRUE);
    }
    else
    {
        ButtonState = g_ConsoleVerbStates[dwNodeType];
        switch (m_nState)
        {
            case loaded:
                for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = TRUE);
                break;
    
            case notLoaded:
            case loading:
                for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = FALSE);
                bStates[MMC_VERB_DELETE & 0x000F] = TRUE;
                break;

            case unableToLoad:
                for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = FALSE);
                bStates[MMC_VERB_REFRESH & 0x000F] = TRUE;
                bStates[MMC_VERB_DELETE & 0x000F] = TRUE;
                break;
        }
    }

    EnableVerbs(pConsoleVerb, ButtonState, bStates);
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::EnableVerbs
                Enables the toolbar buttons
        Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CMTDhcpHandler::EnableVerbs
(
    IConsoleVerb *      pConsoleVerb,
    MMC_BUTTON_STATE    ButtonState[],
    BOOL                bState[]
)
{
    if (pConsoleVerb == NULL)
    {
        Assert(FALSE);
        return;
    }

    for (int i=0; i < ARRAYLEN(g_ConsoleVerbs); ++i)
    {
        if (ButtonState[i] == ENABLED)
        {
            // unhide this button before enabling
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       HIDDEN, 
                                       FALSE);
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       ButtonState[i], 
                                       bState[i]);
        }
        else
        {
            // hide this button
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       HIDDEN, 
                                       TRUE);
        }
    }

        pConsoleVerb->SetDefaultVerb(m_verbDefault);
}


 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::UpdateToolbar
                Updates the toolbar depending upon the state of the node
        Author: EricDav
 ---------------------------------------------------------------------------*/
void
CMTDhcpHandler::UpdateToolbar
(
    IToolbar *  pToolbar,
    LONG_PTR    dwNodeType,
    BOOL        bSelect
)
{
    // Enable/disable toolbar buttons
    int i;
    BOOL aEnable[TOOLBAR_IDX_MAX];

    switch (m_nState)
    {
        case loaded:
            for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = TRUE);
            break;
        
        case notLoaded:
        case loading:
            for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);
            break;

        case unableToLoad:
            for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);
            aEnable[TOOLBAR_IDX_REFRESH] = TRUE;
            break;
    }

    // if we are deselecting, then disable all
    if (!bSelect)
        for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);

    EnableToolbar(pToolbar,
                  g_SnapinButtons,
                  ARRAYLEN(g_SnapinButtons),
                  g_SnapinButtonStates[dwNodeType],
                  aEnable);
}

 /*!--------------------------------------------------------------------------
        CMTDhcpHandler::UserResultNotify
                We override this to handle toolbar notification
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CMTDhcpHandler::UserResultNotify
(
        ITFSNode *      pNode, 
        LPARAM          dwParam1, 
        LPARAM          dwParam2
)
{
    HRESULT hr = hrOK;

    switch (dwParam1)
    {
        case DHCP_MSG_CONTROLBAR_NOTIFY:
            hr = OnResultControlbarNotify(pNode, reinterpret_cast<LPDHCPTOOLBARNOTIFY>(dwParam2));
            break;

        default:
            // we don't handle this message.  Forward it down the line...
            hr = CHandler::UserResultNotify(pNode, dwParam1, dwParam2);
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::UserNotify
                We override this to handle toolbar notification
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CMTDhcpHandler::UserNotify
(
        ITFSNode *      pNode, 
        LPARAM          dwParam1, 
        LPARAM          dwParam2
)
{
    HRESULT hr = hrOK;

    switch (dwParam1)
    {
        case DHCP_MSG_CONTROLBAR_NOTIFY:
            hr = OnControlbarNotify(pNode, reinterpret_cast<LPDHCPTOOLBARNOTIFY>(dwParam2));
            break;

        default:
            // we don't handle this message.  Forward it down the line...
            hr = CHandler::UserNotify(pNode, dwParam1, dwParam2);
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultRefresh
                Call into the MTHandler to do a refresh
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnResultRefresh
(
    ITFSComponent *     pComponent,
    LPDATAOBJECT        pDataObject,
    MMC_COOKIE          cookie,
    LPARAM              arg,
    LPARAM              lParam
)
{
        HRESULT     hr = hrOK;
    SPITFSNode  spNode;

        CORg (m_spNodeMgr->FindNode(cookie, &spNode));

    OnRefresh(spNode, pDataObject, 0, arg, lParam);

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultControlbarNotify
                Our implementation of the toobar handlers
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnResultControlbarNotify
(
    ITFSNode *          pNode, 
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;

    // mark this node as selected
    m_bSelected = pToolbarNotify->bSelect;
    
    SPITFSNode          spParent;
    SPITFSNodeHandler   spNodeHandler;

    switch (pToolbarNotify->event)
    {
        case MMCN_BTN_CLICK:
            // forward the button click to the parent because our result pane
            // items don't have any functions for the toolbar
            // our result pane items only use the standard verbs
            CORg(pNode->GetParent(&spParent));
            CORg(spParent->GetHandler(&spNodeHandler));

            if (spNodeHandler)
                            CORg( spNodeHandler->UserNotify(spParent, 
                                                (LPARAM) DHCP_MSG_CONTROLBAR_NOTIFY, 
                                                (LPARAM) pToolbarNotify) );
            break;

        case MMCN_SELECT:
            if (pNode->IsContainer())
            {
                hr = OnUpdateToolbarButtons(pNode, 
                                            pToolbarNotify);
            }
            break;

        default:
            Assert(FALSE);
            break;
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnControlbarNotify
                Our implementation of the toobar handlers
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnControlbarNotify
(
    ITFSNode *          pNode, 
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;
    
    // mark this node as selected
    m_bSelected = pToolbarNotify->bSelect;
    
    switch (pToolbarNotify->event)
    {
        case MMCN_BTN_CLICK:
            hr = OnToolbarButtonClick(pNode, 
                                      pToolbarNotify);
            break;

        case MMCN_SELECT:
            hr = OnUpdateToolbarButtons(pNode, 
                                        pToolbarNotify);
            break;

        default:
            Assert(FALSE);
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnToolbarButtonClick
                Default implementation of OnToolbarButtonClick
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnToolbarButtonClick
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    // forward this command to the normal command handler
    return OnCommand(pNode, (long) pToolbarNotify->id, (DATA_OBJECT_TYPES) 0, NULL, 0);    
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnUpdateToolbarButtons
                Default implementation of OnUpdateToolbarButtons
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnUpdateToolbarButtons
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    HRESULT hr = hrOK;

    if (pToolbarNotify->bSelect)
    {
        BOOL    bAttach = FALSE;
    
        // check to see if we should attach this toolbar
        for (int i = 0; i < TOOLBAR_IDX_MAX; i++)
        {
            if (g_SnapinButtonStates[pNode->GetData(TFS_DATA_TYPE)][i] == ENABLED)
            {
                bAttach = TRUE; 
                break;
            }
        }

        // attach the toolbar and enable the appropriate buttons
        if (pToolbarNotify->pControlbar)
        {
            if (bAttach)
            {
                pToolbarNotify->pControlbar->Attach(TOOLBAR, pToolbarNotify->pToolbar);
                UpdateToolbar(pToolbarNotify->pToolbar, pNode->GetData(TFS_DATA_TYPE), pToolbarNotify->bSelect);
            }
            else
            {
                pToolbarNotify->pControlbar->Detach(pToolbarNotify->pToolbar);
            }
        }
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::EnableToolbar
                Enables the toolbar buttons
        Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CMTDhcpHandler::EnableToolbar
(
    LPTOOLBAR           pToolbar, 
    MMCBUTTON           rgSnapinButtons[], 
    int                 nRgSize,
    MMC_BUTTON_STATE    ButtonState[],
    BOOL                bState[]
)
{
    if (pToolbar == NULL)
    {
        Assert(FALSE);
        return;
    }

    for (int i=0; i < nRgSize; ++i)
    {
        if (rgSnapinButtons[i].idCommand != 0)
        {
            if (ButtonState[i] == ENABLED)
            {
                // unhide this button before enabling
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         HIDDEN, 
                                         FALSE);
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         ButtonState[i], 
                                         bState[i]);
            }
            else
            {
                // hide this button
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         HIDDEN, 
                                         TRUE);
            }
        }
    }
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnRefreshStats
                Default implementation for the Stats refresh functionality
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnRefreshStats
(
        ITFSNode *              pNode,
        LPDATAOBJECT    pDataObject,
        DWORD                   dwType,
        LPARAM                  arg,
        LPARAM                  param
)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());

        HRESULT                         hr = hrOK;
        SPITFSNode                      spNode;
        SPITFSNodeHandler       spHandler;
        ITFSQueryObject *       pQuery = NULL;
        
//    if (m_bExpanded == FALSE)
//    {
        // we cannot get statistics if the node hasn't been expanded yet
//        return hr;
//    }

    // only do stats refresh if the server was loaded correctly.
    if (m_nState == unableToLoad)
        return hr;

    BOOL bLocked = IsLocked();
        if (bLocked)
    {
        // cannot refresh stats if this node is locked
                return hr; 
    }

    Lock();

        //OnChangeState(pNode);

        pQuery = OnCreateQuery(pNode);
        Assert(pQuery);

        // notify the UI to change icon, if needed
        //Verify(SUCCEEDED(pComponentData->ChangeNode(this, SCOPE_PANE_CHANGE_ITEM_ICON)));

        Verify(StartBackgroundThread(pNode, m_spTFSCompData->GetHiddenWnd(), pQuery));
        
        pQuery->Release();

    return hrOK;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnResultUpdateOptions
                Updates the result pane of any of the option nodes
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CMTDhcpHandler::OnResultUpdateOptions
(
    ITFSComponent *     pComponent,
        ITFSNode *                  pNode,
    CClassInfoArray *   pClassInfoArray,
    COptionValueEnum *  aEnum[],
    int                 aImages[],
    int                 nCount
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT             hr = hrOK;
    CDhcpOption *       pOption;

    //
    // Walk the list of children to see if there's anything
        // to put in the result pane
        //
    SPITFSNodeEnum  spNodeEnum;
    ITFSNode *      pCurrentNode;
    ULONG           nNumReturned = 0;
    SPIResultData   spResultData;
    int             i;

    if (IsMessageView())
        return hr;

    CORg ( pComponent->GetResultData(&spResultData) );

    spResultData->DeleteAllRsltItems();

    pNode->DeleteAllChildren( TRUE );

    for (i = 0; i < nCount; i++)
    {
        while (pOption = aEnum[i]->Next())
        {
            BOOL bValid = TRUE;
            BOOL bAdded = FALSE;

            pNode->GetEnum(&spNodeEnum);

                spNodeEnum->Next(1, &pCurrentNode, &nNumReturned);
            while (nNumReturned)
                {
                // so the node gets release correctly
                SPITFSNode spCurNode;
                spCurNode = pCurrentNode;

                        //
                        // All containers go into the scope pane and automatically get 
                        // put into the result pane for us by the MMC
                        //
                    CDhcpOptionItem * pCurOption = GETHANDLER(CDhcpOptionItem, pCurrentNode);
        
                if (!pCurrentNode->IsContainer())
                        {
                    if ( lstrlen(pCurOption->GetClassName()) > 0 && 
                         !pClassInfoArray->IsValidClass(pCurOption->GetClassName()) )
                    {
                        // user class is no longer valid
                        bValid = FALSE;
                        Trace2("CMTDhcpHandler::OnResultUpdateOptions - Filtering option %d, user class %s\n", pCurOption->GetOptionId(), pOption->GetClassName());
                        break;
                    }
                    else
                    if ( pOption->IsVendor() &&
                         !pClassInfoArray->IsValidClass(pOption->GetVendor()) )
                    {
                        // the vendor class for this option has gone away
                        bValid = FALSE;
                        Trace2("CMTDhcpHandler::OnResultUpdateOptions - Filtering option %d, vendor class %s\n", pCurOption->GetOptionId(), pOption->GetVendor());
                        break;
                    }
                    else
                    if ( pCurOption->GetOptionId() == pOption->QueryId() &&
                         (lstrcmp(pCurOption->GetVendor(), pOption->GetVendor()) == 0) &&
                         (lstrcmp(pCurOption->GetClassName(), pOption->GetClassName()) == 0) )
                    {
                        // option has already been created, just need to re-add to the result pane
                        // update the value in case it has changed
                        bAdded = TRUE;
                        break;
                    }
                        }

                spNodeEnum->Next(1, &pCurrentNode, &nNumReturned);
                }

            if (!bAdded && bValid)
            {
                CDhcpOptionItem *   pOptionItem;
                SPITFSNode          spNode;

                if ( lstrlen(pOption->GetClassName()) > 0 && 
                     !pClassInfoArray->IsValidClass(pOption->GetClassName()) )
                {
                    // the user class for this option has gone away
                }
                else
                if ( pOption->IsVendor() &&
                     !pClassInfoArray->IsValidClass(pOption->GetVendor()) )
                {
                    // the vendor class for this option has gone away
                }
                else
                {
                    // option hasn't been added to the UI yet.  Make it so.
                    pOptionItem = new CDhcpOptionItem(m_spTFSCompData, pOption, aImages[i]);

                    CORg (CreateLeafTFSNode(&spNode,
                                            &GUID_DhcpOptionNodeType,
                                            pOptionItem,
                                            pOptionItem,
                                            m_spNodeMgr));

                        // Tell the handler to initialize any specific data
                        pOptionItem->InitializeNode(spNode);

                    // extra addref to keep the node alive while it is on the list
                        spNode->SetVisibilityState(TFS_VIS_HIDE);
                        pNode->AddChild(spNode);
                    pOptionItem->Release();

                    AddResultPaneItem(pComponent, spNode);
                }
            }

            spNodeEnum.Set(NULL);
        }
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
        Class:  CDhcpHandler
 ---------------------------------------------------------------------------*/

//
// Called by the result handler when a command comes in that isn't handled 
// by the result handler.  If appropriate it passes it to the scope pane hander.
//
HRESULT
CDhcpHandler::HandleScopeCommand
(
        MMC_COOKIE      cookie, 
        int                             nCommandID,
        LPDATAOBJECT    pDataObject
)
{
    HRESULT             hr = hrOK;
    SPITFSNode          spNode;
    DATA_OBJECT_TYPES   dwType = CCT_RESULT;

    if (IS_SPECIAL_DATAOBJECT(pDataObject))
    {
        dwType = CCT_SCOPE;
    }
    else
    {
        if (pDataObject)
        {
                        SPINTERNAL                  spInternal;

            spInternal = ::ExtractInternalFormat(pDataObject);
                        if (spInternal)
                                dwType = spInternal->m_type;
        }
    }

    if (dwType == CCT_SCOPE)
    {
        // call the handler to take care of this
            CORg (m_spNodeMgr->FindNode(cookie, &spNode));

        hr = OnCommand(spNode, nCommandID, dwType, pDataObject, (ULONG) spNode->GetData(TFS_DATA_TYPE));
    }
        
Error:
    return hr;
}

//
// Called by the result handler to add the scope pane menu items to the menu
// where appropriate.  Puts scope pane menu items in when action menu is clicked
// and the message view has focus as well as when a right click happens in the white 
// space of the result pane.
//
HRESULT
CDhcpHandler::HandleScopeMenus
(
        MMC_COOKIE                              cookie,
        LPDATAOBJECT                    pDataObject, 
        LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
        long *                                  pInsertionAllowed
)
{
    HRESULT             hr = hrOK;
    SPITFSNode          spNode;
    DATA_OBJECT_TYPES   dwType = CCT_RESULT;

    if (IS_SPECIAL_DATAOBJECT(pDataObject))
    {
        dwType = CCT_SCOPE;
    }
    else
    {
        if (pDataObject)
        {
                        SPINTERNAL                  spInternal;

            spInternal = ::ExtractInternalFormat(pDataObject);
                        if (spInternal)
                                dwType = spInternal->m_type;
        }
    }

    if (dwType == CCT_SCOPE)
    {
        // call the normal handler to put up the menu items
            CORg (m_spNodeMgr->FindNode(cookie, &spNode));

        hr = OnAddMenuItems(spNode, pContextMenuCallback, pDataObject, CCT_SCOPE, (ULONG) spNode->GetData(TFS_DATA_TYPE), pInsertionAllowed);
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
        CDhcpHandler::Command
                Description
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpHandler::Command
(
    ITFSComponent * pComponent, 
        MMC_COOKIE              cookie, 
        int                             nCommandID,
        LPDATAOBJECT    pDataObject
)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());

        HRESULT hr = S_OK;

    // this may have come from the scope pane handler, so pass it up
    hr = HandleScopeCommand(cookie, nCommandID, pDataObject);

    return hr;
}


/*!--------------------------------------------------------------------------
        CDhcpHandler::AddMenuItems
                Over-ride this to add our view menu item
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpHandler::AddMenuItems
(
    ITFSComponent *         pComponent, 
        MMC_COOKIE                              cookie,
        LPDATAOBJECT                    pDataObject, 
        LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
        long *                                  pInsertionAllowed
)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

        HRESULT hr = S_OK;

    // figure out if we need to pass this to the scope pane menu handler
    hr = HandleScopeMenus(cookie, pDataObject, pContextMenuCallback, pInsertionAllowed);
    
    return hr;
}

 
 /*!--------------------------------------------------------------------------
        CDhcpHandler::SaveColumns
                -
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpHandler::SaveColumns
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT             hr = hrOK;
    LONG_PTR            dwNodeType;
    int                 nCol = 0;
    int                 nColWidth;
    SPITFSNode          spNode, spRootNode;
    SPIHeaderCtrl       spHeaderCtrl;
    BOOL                bDirty = FALSE;

    if (m_spTFSCompData->GetTaskpadState(GetTaskpadIndex()))
        return hr;

    CORg (m_spNodeMgr->FindNode(cookie, &spNode));
    CORg (pComponent->GetHeaderCtrl(&spHeaderCtrl));
    
    dwNodeType = spNode->GetData(TFS_DATA_TYPE);

    while (aColumns[dwNodeType][nCol] != 0)
    {
        hr = spHeaderCtrl->GetColumnWidth(nCol, &nColWidth);
        if (SUCCEEDED(hr) &&
            (nColWidth != 0) &&
            aColumnWidths[dwNodeType][nCol] != nColWidth)
        {
            aColumnWidths[dwNodeType][nCol] = nColWidth;
            bDirty = TRUE;
        }

        nCol++;
    }

    if (bDirty)
    {
        CORg (m_spNodeMgr->GetRootNode(&spRootNode));
                spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CMTDhcpHandler::OnCreateDataObject
                -
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpHandler::OnCreateDataObject
(
    ITFSComponent *     pComponent,
        MMC_COOKIE                      cookie, 
        DATA_OBJECT_TYPES       type, 
        IDataObject **          ppDataObject
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    Assert(ppDataObject != NULL);

        CDataObject *   pObject = NULL;
        SPIDataObject   spDataObject;
        
        pObject = new CDataObject;
        spDataObject = pObject; // do this so that it gets released correctly
                                                
    Assert(pObject != NULL);

    if (cookie == MMC_MULTI_SELECT_COOKIE)
    {
        CreateMultiSelectData(pComponent, pObject);
    }

    // Save cookie and type for delayed rendering
    pObject->SetType(type);
    pObject->SetCookie(cookie);

    // Store the coclass with the data object
    pObject->SetClsid(*(m_spTFSComponentData->GetCoClassID()));

        pObject->SetTFSComponentData(m_spTFSComponentData);

    return  pObject->QueryInterface(IID_IDataObject, 
                                                                        reinterpret_cast<void**>(ppDataObject));
}

HRESULT
CDhcpHandler::CreateMultiSelectData(ITFSComponent * pComponent, CDataObject * pObject)
{
    HRESULT hr = hrOK;

    // build the list of selected nodes
        CTFSNodeList listSelectedNodes;
    CGUIDArray   rgGuids;
    UINT         cb;
    GUID*        pGuid;

    COM_PROTECT_TRY
    {
        CORg (BuildSelectedItemList(pComponent, &listSelectedNodes));

        // collect all of the unique guids
        while (listSelectedNodes.GetCount() > 0)
            {
                    SPITFSNode   spCurNode;
                    spCurNode = listSelectedNodes.RemoveHead();
            pGuid = ( GUID * ) spCurNode->GetNodeType();
        
            rgGuids.AddUnique(*pGuid);
        }

        // now put the information in the data object
        pObject->SetMultiSelDobj();
        cb = (UINT) (rgGuids.GetSize() * sizeof(GUID));
        
        pGuid = new GUID[(UINT)rgGuids.GetSize()];
        CopyMemory(pGuid, rgGuids.GetData(), cb);
        
        pObject->SetMultiSelData((BYTE*)pGuid, cb);

        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH

    return hr;
}

 /*---------------------------------------------------------------------------
        CDhcpHandler::OnResultDelete
                Description
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpHandler::OnResultDelete
(
        ITFSComponent * pComponent, 
        LPDATAOBJECT    pDataObject,
        MMC_COOKIE              cookie, 
        LPARAM                  arg, 
        LPARAM                  lParam
)
{
        HRESULT hr = hrOK;

        Trace0("CDhcpHandler::OnResultDelete received\n");

        // translate this call to the parent and let it handle deletion 
        // of result pane items
        SPITFSNode spNode, spParent;
        SPITFSResultHandler spParentRH;

        CORg (m_spNodeMgr->FindNode(cookie, &spNode));
        CORg (spNode->GetParent(&spParent));

        if (spParent == NULL)
                return hr;

        CORg (spParent->GetResultHandler(&spParentRH));

        CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_DELETE, arg, lParam));

Error:
        return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::OnResultContextHelp
                Implementation of ITFSResultHandler::OnResultContextHelp
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpHandler::OnResultContextHelp
(
    ITFSComponent * pComponent, 
    LPDATAOBJECT    pDataObject, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT         hr = hrOK;
    SPIDisplayHelp  spDisplayHelp;
    SPIConsole      spConsole;

    pComponent->GetConsole(&spConsole);

    hr = spConsole->QueryInterface (IID_IDisplayHelp, (LPVOID*) &spDisplayHelp);
        ASSERT (SUCCEEDED (hr));
        if ( SUCCEEDED (hr) )
        {
        LPCTSTR pszHelpFile = m_spTFSCompData->GetHTMLHelpFileName();
        if (pszHelpFile == NULL)
            goto Error;

        CString szHelpFilePath;
            UINT nLen = ::GetWindowsDirectory (szHelpFilePath.GetBufferSetLength(2 * MAX_PATH), 2 * MAX_PATH);
            if (nLen == 0)
        {
                    hr = E_FAIL;
            goto Error;
        }

        szHelpFilePath.ReleaseBuffer();
            szHelpFilePath += g_szDefaultHelpTopic;

                hr = spDisplayHelp->ShowTopic (T2OLE ((LPTSTR)(LPCTSTR) szHelpFilePath));
                ASSERT (SUCCEEDED (hr));
    }

Error:
    return hr;
}

 /*!--------------------------------------------------------------------------
        CDhcpHandler::UserResultNotify
                We override this to handle toolbar notification
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpHandler::UserResultNotify
(
        ITFSNode *      pNode, 
        LPARAM          dwParam1, 
        LPARAM          dwParam2
)
{
    HRESULT hr = hrOK;

    switch (dwParam1)
    {
        case DHCP_MSG_CONTROLBAR_NOTIFY:
            hr = OnResultControlbarNotify(pNode, reinterpret_cast<LPDHCPTOOLBARNOTIFY>(dwParam2));
            break;

        default:
            // we don't handle this message.  Forward it down the line...
            hr = CHandler::UserResultNotify(pNode, dwParam1, dwParam2);
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::UserNotify
                We override this to handle toolbar notification
        Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpHandler::UserNotify
(
        ITFSNode *      pNode, 
        LPARAM          dwParam1, 
        LPARAM          dwParam2
)
{
    HRESULT hr = hrOK;

    switch (dwParam1)
    {
        case DHCP_MSG_CONTROLBAR_NOTIFY:
            hr = OnControlbarNotify(pNode, reinterpret_cast<LPDHCPTOOLBARNOTIFY>(dwParam2));
            break;

        default:
            // we don't handle this message.  Forward it down the line...
            hr = CHandler::UserNotify(pNode, dwParam1, dwParam2);
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::OnResultControlbarNotify
                On a result pane notification all we can do is enable/hide buttons.
        We cannot attach/detach toolbars.
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpHandler::OnResultControlbarNotify
(
    ITFSNode *          pNode, 
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;

    SPITFSNode          spParent;
    SPITFSNodeHandler   spNodeHandler;

    switch (pToolbarNotify->event)
    {
        case MMCN_BTN_CLICK:
            // forward the button click to the parent because our result pane
            // items don't have any functions for the toolbar
            // our result pane items only use the standard verbs
            CORg(pNode->GetParent(&spParent));
            CORg(spParent->GetHandler(&spNodeHandler));

            if (spNodeHandler)
                            CORg( spNodeHandler->UserNotify(spParent, 
                                                DHCP_MSG_CONTROLBAR_NOTIFY, 
                                                (LPARAM) pToolbarNotify) );
            break;

        case MMCN_SELECT:
            if (!pNode->IsContainer())
            {
                // use the parent's toolbar info
                SPITFSNode spParentNode;
                pNode->GetParent(&spParentNode);
                
                hr = OnUpdateToolbarButtons(spParentNode, 
                                            pToolbarNotify);
            }
            else
            {
                hr = OnUpdateToolbarButtons(pNode, 
                                            pToolbarNotify);
            }

            break;

        default:
            Assert(FALSE);
            break;
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::OnControlbarNotify
                Our implementation of the toobar handlers
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpHandler::OnControlbarNotify
(
    ITFSNode *          pNode, 
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;

    switch (pToolbarNotify->event)
    {
        case MMCN_BTN_CLICK:
            hr = OnToolbarButtonClick(pNode, 
                                      pToolbarNotify);
            break;

        case MMCN_SELECT:
            hr = OnUpdateToolbarButtons(pNode, 
                                        pToolbarNotify);
            break;

        default:
            Assert(FALSE);
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::OnToolbarButtonClick
                Default implementation of OnToolbarButtonClick
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpHandler::OnToolbarButtonClick
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    // forward this command to the normal command handler
    return OnCommand(pNode, (long) pToolbarNotify->id, (DATA_OBJECT_TYPES) 0, NULL, 0);    
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::OnUpdateToolbarButtons
                Default implementation of OnUpdateToolbarButtons
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpHandler::OnUpdateToolbarButtons
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    HRESULT hr = hrOK;

    LONG_PTR dwNodeType = pNode->GetData(TFS_DATA_TYPE);

    if (pToolbarNotify->bSelect)
    {
        BOOL bAttach = FALSE;

        // check to see if we should attach this toolbar
        for (int i = 0; i < TOOLBAR_IDX_MAX; i++)
        {
            if (g_SnapinButtonStates[pNode->GetData(TFS_DATA_TYPE)][i] == ENABLED)
            {
                bAttach = TRUE; 
                break;
            }
        }

        // attach the toolbar and enable the appropriate buttons
        if (pToolbarNotify->pControlbar)
        {
            if (bAttach)
            {
                // attach the toolbar and enable the appropriate buttons
                pToolbarNotify->pControlbar->Attach(TOOLBAR, pToolbarNotify->pToolbar);

                EnableToolbar(pToolbarNotify->pToolbar,
                              g_SnapinButtons,
                              ARRAYLEN(g_SnapinButtons),
                              g_SnapinButtonStates[dwNodeType]);
            }
            else
            {
                pToolbarNotify->pControlbar->Detach(pToolbarNotify->pToolbar);
            }
        }
    }
    else
    {
        // disable the buttons
        EnableToolbar(pToolbarNotify->pToolbar,
                      g_SnapinButtons,
                      ARRAYLEN(g_SnapinButtons),
                      g_SnapinButtonStates[dwNodeType],
                      FALSE);
    }

    return hr;
}

/*!--------------------------------------------------------------------------
        CDhcpHandler::EnableToolbar
                Enables the toolbar buttons
        Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpHandler::EnableToolbar
(
    LPTOOLBAR           pToolbar, 
    MMCBUTTON           rgSnapinButtons[], 
    int                 nRgSize,
    MMC_BUTTON_STATE    ButtonState[],
    BOOL                bState
)
{
    for (int i=0; i < nRgSize; ++i)
    {
        if (rgSnapinButtons[i].idCommand != 0)
        {
            if (ButtonState[i] == ENABLED)
            {
                // unhide this button before enabling
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         HIDDEN, 
                                         FALSE);
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         ButtonState[i], 
                                         bState);
            }
            else
            {
                // hide this button
                pToolbar->SetButtonState(rgSnapinButtons[i].idCommand, 
                                         HIDDEN, 
                                         TRUE);
            }

        }
    }
}


/*!--------------------------------------------------------------------------
        CDhcpHandler::OnResultSelect
                Handles the MMCN_SELECT notifcation 
        Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpHandler::OnResultSelect
(
        ITFSComponent * pComponent, 
        LPDATAOBJECT    pDataObject, 
    MMC_COOKIE      cookie,
        LPARAM                  arg, 
        LPARAM                  lParam
)
{
    SPIConsoleVerb  spConsoleVerb;
    SPITFSNode      spNode;
    HRESULT         hr = hrOK;
    BOOL            bStates[ARRAYLEN(g_ConsoleVerbs)];
    int             i;

    CORg (pComponent->GetConsoleVerb(&spConsoleVerb));
    CORg (m_spNodeMgr->FindNode(cookie, &spNode));

    for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = TRUE);

    EnableVerbs(spConsoleVerb, g_ConsoleVerbStates[spNode->GetData(TFS_DATA_TYPE)], bStates);

Error:
    return hr;
}


/*!--------------------------------------------------------------------------
        CMTDhcpHandler::EnableVerbs
                Enables the toolbar buttons
        Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpHandler::EnableVerbs
(
    IConsoleVerb *      pConsoleVerb,
    MMC_BUTTON_STATE    ButtonState[],
    BOOL                bState[]
)
{
    if (pConsoleVerb == NULL)
    {
        Assert(FALSE);
        return;
    }

    for (int i=0; i < ARRAYLEN(g_ConsoleVerbs); ++i)
    {
        if (ButtonState[i] == ENABLED)
        {
            // unhide this button before enabling
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       HIDDEN, 
                                       FALSE);
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       ButtonState[i], 
                                       bState[i]);
        }
        else
        {
            // hide this button
            pConsoleVerb->SetVerbState(g_ConsoleVerbs[i], 
                                       HIDDEN, 
                                       TRUE);
        }
    }

        pConsoleVerb->SetDefaultVerb(m_verbDefault);
}