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

/*
    provider.cpp
        Tapi provider node handler

    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "provider.h"       // Provider node definition
#include "EditUser.h"       // user editor
#include "server.h"
#include "tapi.h"

/*---------------------------------------------------------------------------
    Class CProviderHandler implementation
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
    Constructor and destructor
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
CProviderHandler::CProviderHandler
(
    ITFSComponentData * pComponentData
) : CTapiHandler(pComponentData)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    m_deviceType = DEVICE_LINE;
}


CProviderHandler::~CProviderHandler()
{
}

/*!--------------------------------------------------------------------------
    CProviderHandler::InitializeNode
        Initializes node specific data
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::InitializeNode
(
    ITFSNode * pNode
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    
    CString strTemp;

    BuildDisplayName(&strTemp);
    
    SetDisplayName(strTemp);

    // Make the node immediately visible
    pNode->SetVisibilityState(TFS_VIS_SHOW);
    pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
    pNode->SetData(TFS_DATA_IMAGEINDEX, ICON_IDX_FOLDER_CLOSED);
    pNode->SetData(TFS_DATA_OPENIMAGEINDEX, ICON_IDX_FOLDER_OPEN);
    pNode->SetData(TFS_DATA_USER, (LPARAM) this);
    pNode->SetData(TFS_DATA_TYPE, TAPISNAP_PROVIDER);
    pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);

    SetColumnStringIDs(&aColumns[TAPISNAP_PROVIDER][0]);
    SetColumnWidths(&aColumnWidths[TAPISNAP_PROVIDER][0]);

    return hrOK;
}

/*---------------------------------------------------------------------------
	CProviderHandler::OnCreateNodeId2
		Returns a unique string for this node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CProviderHandler::OnCreateNodeId2(ITFSNode * pNode, CString & strId, DWORD * dwFlags)
{
    const GUID * pGuid = pNode->GetNodeType();

    CString strProviderId, strGuid;

    StringFromGUID2(*pGuid, strGuid.GetBuffer(256), 256);
    strGuid.ReleaseBuffer();

    strProviderId.Format(_T("%d"), m_dwProviderID);

    strId = m_spTapiInfo->GetComputerName() + strProviderId + strGuid;

    return hrOK;
}

/*---------------------------------------------------------------------------
    CProviderHandler::GetImageIndex
        -
    Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CProviderHandler::GetImageIndex(BOOL bOpenImage) 
{
    int nIndex = -1;

    return nIndex;
}


/*---------------------------------------------------------------------------
    Overridden base handler functions
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
    CProviderHandler::OnAddMenuItems
        Adds context menu items for the provider scope pane node
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::OnAddMenuItems
(
    ITFSNode *              pNode,
    LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
    LPDATAOBJECT            lpDataObject, 
    DATA_OBJECT_TYPES       type, 
    DWORD                   dwType,
    long *                  pInsertionAllowed
)
{ 
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    LONG        fFlags = 0, fLoadingFlags = 0;
    HRESULT     hr = S_OK;
    CString     strMenuItem;
/*
    if ( m_nState != loaded )
    {
        fFlags |= MF_GRAYED;
    }

    if ( m_nState == loading)
    {
        fLoadingFlags = MF_GRAYED;
    }
*/
    //Bug 305657 We cannot configure TSP remotely
    if (!m_spTapiInfo->IsLocalMachine() || !m_spTapiInfo->IsAdmin())
    {
        fFlags |= MF_GRAYED;
    }

    if (type == CCT_SCOPE)
    {
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
            if (m_dwFlags & AVAILABLEPROVIDER_CONFIGURABLE)
            {
                strMenuItem.LoadString(IDS_CONFIGURE_PROVIDER);
                hr = LoadAndAddMenuItem( pContextMenuCallback, 
                                         strMenuItem, 
                                         IDS_CONFIGURE_PROVIDER,
                                         CCM_INSERTIONPOINTID_PRIMARY_TOP, 
                                         fFlags );
                ASSERT( SUCCEEDED(hr) );
            }
        }
    }

    return hr; 
}

/*!--------------------------------------------------------------------------
    CProviderHandler::AddMenuItems
        Adds context menu items for virtual list box (result pane) items
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::AddMenuItems
(
    ITFSComponent *         pComponent, 
    MMC_COOKIE              cookie,
    LPDATAOBJECT            pDataObject, 
    LPCONTEXTMENUCALLBACK   pContextMenuCallback, 
    long *                  pInsertionAllowed
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT     hr = hrOK;
    CString     strMenuItem;
    SPINTERNAL  spInternal;
    LONG        fFlags = 0;
    int         nIndex;
    DWORD       dwFlags;
    CTapiDevice tapiDevice;

    spInternal = ExtractInternalFormat(pDataObject);

    // virtual listbox notifications come to the handler of the node that is selected.
    // check to see if this notification is for a virtual listbox item or this provider
    // node itself.
    if (spInternal->HasVirtualIndex())
    {
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
            CTapiConfigInfo     tapiConfigInfo;

            m_spTapiInfo->GetConfigInfo(&tapiConfigInfo);

            if (m_spTapiInfo->IsAdmin() && 
                tapiConfigInfo.m_dwFlags & TAPISERVERCONFIGFLAGS_ISSERVER)
            {
                fFlags = 0;
            }
            else
            {
                fFlags = MF_GRAYED;
            }

            //  Check to see if this device can ONLY be used locally, if
            //  so, gray the edit user menu item
            nIndex = spInternal->GetVirtualIndex();
            m_spTapiInfo->GetDeviceInfo(m_deviceType, &tapiDevice, m_dwProviderID, nIndex);
            if (m_deviceType == DEVICE_PHONE ||
                m_spTapiInfo->GetDeviceFlags (
                    tapiDevice.m_dwProviderID,
                    tapiDevice.m_dwPermanentID,
                    &dwFlags
                    ) ||
                (dwFlags & LINEDEVCAPFLAGS_LOCAL)
                )
            {
                fFlags = MF_GRAYED;
            }

            strMenuItem.LoadString(IDS_EDIT_USERS);
            hr = LoadAndAddMenuItem( pContextMenuCallback, 
                                     strMenuItem, 
                                     IDS_EDIT_USERS,
                                     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
                                     fFlags );
            ASSERT( SUCCEEDED(hr) );
        }
    }

    if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW)
    {
        strMenuItem.LoadString(IDS_VIEW_LINES);
        hr = LoadAndAddMenuItem( pContextMenuCallback, 
                                 strMenuItem, 
                                 IDS_VIEW_LINES,
                                 CCM_INSERTIONPOINTID_PRIMARY_VIEW, 
                                 (m_deviceType == DEVICE_LINE) ? MF_CHECKED : 0 );
        ASSERT( SUCCEEDED(hr) );
        
        strMenuItem.LoadString(IDS_VIEW_PHONES);
        hr = LoadAndAddMenuItem( pContextMenuCallback, 
                                 strMenuItem, 
                                 IDS_VIEW_PHONES,
                                 CCM_INSERTIONPOINTID_PRIMARY_VIEW, 
                                 (m_deviceType == DEVICE_PHONE) ? MF_CHECKED : 0 );
        ASSERT( SUCCEEDED(hr) );
    }

    return hr;
}

/*---------------------------------------------------------------------------
    CProviderHandler::OnCommand
        Handles context menu commands for provider scope pane node
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::OnCommand
(
    ITFSNode *          pNode, 
    long                nCommandId, 
    DATA_OBJECT_TYPES   type, 
    LPDATAOBJECT        pDataObject, 
    DWORD               dwType
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT hr = S_OK;

    switch (nCommandId)
    {
        case IDS_CONFIGURE_PROVIDER:
            OnConfigureProvider(pNode);
            break;

        default:
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::Command
        Handles context menu commands for virtual listbox items
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::Command
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    int             nCommandID,
    LPDATAOBJECT    pDataObject
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT hr = S_OK;
    SPITFSNode spNode;

    m_spResultNodeMgr->FindNode(cookie, &spNode);

    switch (nCommandID)
    {
        case IDS_EDIT_USERS:
            OnEditUsers(pComponent,  pDataObject, cookie);
            break;
        
        case IDS_VIEW_LINES:
            m_deviceType = DEVICE_LINE;

            // clear the listbox then set the size
            SetColumnInfo();
            UpdateColumnText(pComponent);
            UpdateListboxCount(spNode, TRUE);
            UpdateListboxCount(spNode);
            break;

        case IDS_VIEW_PHONES:
            m_deviceType = DEVICE_PHONE;

            // clear the listbox then set the size
            SetColumnInfo();
            UpdateColumnText(pComponent);
            UpdateListboxCount(spNode, TRUE);
            UpdateListboxCount(spNode);
            break;

        default:
            break;
    }

    return hr;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::HasPropertyPages
        Implementation of ITFSNodeHandler::HasPropertyPages
    NOTE: the root node handler has to over-ride this function to 
    handle the snapin manager property page (wizard) case!!!
    
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::HasPropertyPages
(
    ITFSNode *          pNode,
    LPDATAOBJECT        pDataObject, 
    DATA_OBJECT_TYPES   type, 
    DWORD               dwType
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    
    return hrFalse;
}

/*---------------------------------------------------------------------------
    CProviderHandler::CreatePropertyPages
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::CreatePropertyPages
(
    ITFSNode *              pNode,
    LPPROPERTYSHEETCALLBACK lpProvider,
    LPDATAOBJECT            pDataObject, 
    LONG_PTR                handle, 
    DWORD                   dwType
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    DWORD       dwError;
    DWORD       dwDynDnsFlags;

    //
    // Create the property page
    //
    SPIComponentData spComponentData;
    m_spNodeMgr->GetComponentData(&spComponentData);

    //CServerProperties * pServerProp = new CServerProperties(pNode, spComponentData, m_spTFSCompData, NULL);

    //
    // Object gets deleted when the page is destroyed
    //
    Assert(lpProvider != NULL);

    //return pServerProp->CreateModelessSheet(lpProvider, handle);
    return hrFalse;
}

/*---------------------------------------------------------------------------
    CProviderHandler::OnPropertyChange
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnPropertyChange
(   
    ITFSNode *      pNode, 
    LPDATAOBJECT    pDataobject, 
    DWORD           dwType, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    //CServerProperties * pServerProp = reinterpret_cast<CServerProperties *>(lParam);

    LONG_PTR changeMask = 0;

    // tell the property page to do whatever now that we are back on the
    // main thread
    //pServerProp->OnPropertyChange(TRUE, &changeMask);

    //pServerProp->AcknowledgeNotify();

    if (changeMask)
        pNode->ChangeNode(changeMask);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CProviderHandler::OnExpand
        Handles enumeration of a scope item
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnExpand
(
    ITFSNode *      pNode, 
    LPDATAOBJECT    pDataObject,
    DWORD           dwType,
    LPARAM          arg, 
    LPARAM          param
)
{
    HRESULT hr = hrOK;

    if (m_bExpanded) 
        return hr;
    
    // do the default handling
    CORg (CTapiHandler::OnExpand(pNode, pDataObject, dwType, arg, param));

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::OnResultSelect
        Handles the MMCN_SELECT notifcation 
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnResultSelect
(
    ITFSComponent * pComponent, 
    LPDATAOBJECT    pDataObject, 
    MMC_COOKIE      cookie,
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT         hr = hrOK;
    SPINTERNAL      spInternal;
    SPIConsole      spConsole;
    SPIConsoleVerb  spConsoleVerb;
    SPITFSNode      spNode;
    BOOL            bStates[ARRAYLEN(g_ConsoleVerbs)];
    int             i;
    LONG_PTR        dwNodeType;
    BOOL            fSelect = HIWORD(arg);

    if (!fSelect)
        return hr;

    if (m_spTapiInfo)
    {
        // Get the current count
        i = m_spTapiInfo->GetDeviceCount(m_deviceType, m_dwProviderID);

        // now notify the virtual listbox
        CORg ( m_spNodeMgr->GetConsole(&spConsole) );
        CORg ( spConsole->UpdateAllViews(pDataObject, i, RESULT_PANE_SET_VIRTUAL_LB_SIZE) ); 
    }

    // now update the verbs...
    spInternal = ExtractInternalFormat(pDataObject);
    Assert(spInternal);

    // virtual listbox notifications come to the handler of the node that is selected.
    // check to see if this notification is for a virtual listbox item or the active
    // registrations node itself.
    CORg (pComponent->GetConsoleVerb(&spConsoleVerb));

    if (spInternal->HasVirtualIndex())
    {
        // we gotta do special stuff for the virtual index items
        dwNodeType = TAPISNAP_DEVICE;
        for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = FALSE);
    }
    else
    {
        // enable/disable delete depending if the provider supports it
        CORg (m_spNodeMgr->FindNode(cookie, &spNode));
        dwNodeType = spNode->GetData(TFS_DATA_TYPE);

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

        //Per XZhang, hide "delete" context menu of provider nodes on remote machines
        if (!m_spTapiInfo->IsLocalMachine() || !m_spTapiInfo->IsAdmin() || (m_dwFlags & AVAILABLEPROVIDER_REMOVABLE) == 0)
        {
            bStates[MMC_VERB_DELETE & 0x000F] = FALSE;
        }
    }

    EnableVerbs(spConsoleVerb, g_ConsoleVerbStates[dwNodeType], bStates);

COM_PROTECT_ERROR_LABEL;
    return hr;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::OnDelete
        The base handler calls this when MMC sends a MMCN_DELETE for a 
        scope pane item.  We just call our delete command handler.
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnDelete
(
    ITFSNode *  pNode, 
    LPARAM      arg, 
    LPARAM      lParam
)
{
    return OnDelete(pNode);
}

/*---------------------------------------------------------------------------
    CProviderHandler::OnGetResultViewType
        Return the result view that this node is going to support
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnGetResultViewType
(
    ITFSComponent * pComponent, 
    MMC_COOKIE            cookie, 
    LPOLESTR *      ppViewType,
    long *          pViewOptions
)
{
    if (cookie != NULL)
    {
        *pViewOptions = MMC_VIEW_OPTIONS_OWNERDATALIST | MMC_VIEW_OPTIONS_MULTISELECT;
    }

    return S_FALSE;
}

/*---------------------------------------------------------------------------
    CProviderHandler::GetVirtualImage
        Returns the image index for virtual listbox items
    Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CProviderHandler::GetVirtualImage
(
    int     nIndex
)
{
    return ICON_IDX_MACHINE;
}

/*---------------------------------------------------------------------------
    CProviderHandler::GetVirtualString
        returns a pointer to the string for virtual listbox items
    Author: EricDav
 ---------------------------------------------------------------------------*/
LPCWSTR 
CProviderHandler::GetVirtualString
(
    int     nIndex,
    int     nCol
)
{
    // check our cache to see if we have this one.
    //TapiStrRecord * ptsr = m_RecList.FindItem(nIndex);
    CString         strStatus;
    TapiStrRecord   tsr;

    if (!m_mapRecords.Lookup(nIndex, tsr))
    {
        Trace1("CProviderHandler::GetVirtualString - Index %d not in TAPI string cache\n", nIndex);
        
        // doesn't exist in our cache, need to add this one.
        if (!BuildTapiStrRecord(nIndex, tsr))
        {
            Trace0("CProviderHandler::BuildTapiStrRecord failed!\n");
        }

        //m_RecList.AddTail(ptsr);
        m_mapRecords.SetAt(nIndex, tsr);
    }
    
    if (!m_mapStatus.Lookup(nIndex, strStatus))
    {
        Trace1("CProviderHandler::GetVirtualString - Index %d not in status cache\n", nIndex);

        if (!BuildStatus(nIndex, strStatus))
        {
            Trace0("CProviderHandler::BuildStatus failed!\n");
        }
    }

    switch (nCol)
    {
        case 0:
            return tsr.strName;
            break;

        case 1:
            return tsr.strUsers;
            break;

        case 2:
            return strStatus;
            break;

        default:
            Panic0("CProviderHandler::GetVirtualString - Unknown column!\n");
            break;
    }

    return NULL;
}

/*---------------------------------------------------------------------------
    CProviderHandler::CacheHint
        MMC tells us which items it will need before it requests things
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::CacheHint
(
    int nStartIndex, 
    int nEndIndex
)
{
    HRESULT hr = hrOK;;

    Trace2("CacheHint - Start %d, End %d\n", nStartIndex, nEndIndex);
    
    // the virtual listbox stores no strings and gives us cache hints for
    // everything, including individual querries.  To avoid thrashing, only
    // clear our the cache if the request is large.
    if ((nEndIndex - nStartIndex) > 2)
    {
        m_mapRecords.RemoveAll();
    }

    TapiStrRecord   tsr;
    CString         strStatus;

    for (int i = nStartIndex; i <= nEndIndex; i++)
    {
        if (!BuildTapiStrRecord(i, tsr))
            continue; 

        m_mapRecords.SetAt(i, tsr);

        // only refresh status records if they don't exist.  Only the auto refresh
        // background thread cleans out the map...
        if (!m_mapStatus.Lookup(i, strStatus))
        {
            BuildStatus(i, strStatus);
            m_mapStatus.SetAt(i, strStatus);
        }
    }

    return hr;
}

/*---------------------------------------------------------------------------
    CProviderHandler::SortItems
        We are responsible for sorting of virtual listbox items
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CProviderHandler::SortItems
(
    int     nColumn, 
    DWORD   dwSortOptions, 
    LPARAM    lUserParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    BEGIN_WAIT_CURSOR

    switch (nColumn)
    {
        case 0:
            m_spTapiInfo->SortDeviceInfo(m_deviceType, m_dwProviderID, INDEX_TYPE_NAME, dwSortOptions);
            break;
        case 1:
            m_spTapiInfo->SortDeviceInfo(m_deviceType, m_dwProviderID, INDEX_TYPE_USERS, dwSortOptions);
            break;
//      case 2:
//          m_spTapiInfo->SortDeviceInfo(m_deviceType, m_dwProviderID, INDEX_TYPE_STATUS, dwSortOptions);
//          break;
    }
    END_WAIT_CURSOR

    return hrOK;
}

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

    pComponent->GetSelectedNode(&spSelectedNode);
    if (spSelectedNode == NULL)
        return S_OK; // no selection for our IComponentData

    if ( hint == TAPISNAP_UPDATE_STATUS )
    {
        SPINTERNAL spInternal = ExtractInternalFormat(pDataObject);
        ITFSNode * pNode = reinterpret_cast<ITFSNode *>(spInternal->m_cookie);
        SPITFSNode spSelectedNode;

        pComponent->GetSelectedNode(&spSelectedNode);

        if (pNode == spSelectedNode)
        {       
            Trace1("CProviderHandler::OnResultUpdateView - Provider %x is selected, invalidating listbox.\n", m_dwProviderID);
            
            // if we are the selected node, then we need to update
            SPIResultData spResultData;

            CORg (pComponent->GetResultData(&spResultData));
            CORg (spResultData->SetItemCount((int) data, MMCLV_UPDATE_NOSCROLL));
        }
    }
    else
    {
        // we don't handle this message, let the base class do it.
        return CTapiHandler::OnResultUpdateView(pComponent, pDataObject, data, hint);
    }

COM_PROTECT_ERROR_LABEL;

    return hr;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::OnResultItemClkOrDblClk
        The user had double clicked on a line/phone.  Invoke the edit users.
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnResultItemClkOrDblClk
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam, 
    BOOL            bDoubleClick
)
{
    HRESULT hr = hrOK;

    if (bDoubleClick)
    {
        // first check to see if we are selected
        SPITFSNode spSelectedNode;
        pComponent->GetSelectedNode(&spSelectedNode);

        SPITFSNode spNode;
        m_spResultNodeMgr->FindNode(cookie, &spNode);

        if (spSelectedNode == spNode)
        {
            CTapiConfigInfo     tapiConfigInfo;

            m_spTapiInfo->GetConfigInfo(&tapiConfigInfo);

            // check to see if they have access rights
            if (m_spTapiInfo->IsAdmin() && 
                tapiConfigInfo.m_dwFlags & TAPISERVERCONFIGFLAGS_ISSERVER)
            {
                // double click on a line/phone entry.  
                SPIDataObject spDataObject;

                CORg (pComponent->GetCurrentDataObject(&spDataObject));

                OnEditUsers(pComponent, spDataObject, cookie);
            }
        }
        else
        {
            // we are being double clicked to open 
            // let the base class handle this
            return CTapiHandler::OnResultItemClkOrDblClk(pComponent, cookie, arg, lParam, bDoubleClick);
        }
    }

Error:
    return S_OK;
}

/*!--------------------------------------------------------------------------
    CProviderHandler::LoadColumns
        Set the correct column header and then call the base class
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::LoadColumns
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    SetColumnInfo();

    return CTapiHandler::LoadColumns(pComponent, cookie, arg, lParam);
}

/*---------------------------------------------------------------------------
    Command handlers
 ---------------------------------------------------------------------------*/

 /*---------------------------------------------------------------------------
    CProviderHandler::OnConfigureProvider
        Configures a service provider
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnConfigureProvider
(
    ITFSNode * pNode
)
{
    HRESULT hr = hrOK;

    Assert(m_spTapiInfo);

    hr = m_spTapiInfo->ConfigureProvider(m_dwProviderID, NULL);
    if (FAILED(hr))
    {
        ::TapiMessageBox(WIN32_FROM_HRESULT(hr));
    }

    return hr;
}

 /*---------------------------------------------------------------------------
    CProviderHandler::OnDelete
        Removes a service provider
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CProviderHandler::OnDelete
(
    ITFSNode * pNode
)
{
    HRESULT         hr = hrOK;
    SPITFSNode      spNode;
    CString         strMessage;

    pNode->GetParent(&spNode);

    CTapiServer * pServer = GETHANDLER(CTapiServer, spNode);

    // Ask the user to make sure
    AfxFormatString2(strMessage, IDS_WARN_PROVIDER_DELETE, m_strProviderName, pServer->GetName());
    
    if (AfxMessageBox(strMessage, MB_YESNO) == IDYES)
    {
        Assert(m_spTapiInfo);

        hr = m_spTapiInfo->RemoveProvider(m_dwProviderID, NULL);
        if (FAILED(hr))
        {
            ::TapiMessageBox(WIN32_FROM_HRESULT(hr));
        }
        else
        {
            // remove from the UI
            SPITFSNode spParent;
            CORg (pNode->GetParent(&spParent));
        
            CORg (spParent->RemoveChild(pNode));

            // update the list of installed providers
            CORg (m_spTapiInfo->EnumProviders());
        }
    }

Error:
    return hr;
}

 /*---------------------------------------------------------------------------
    CProviderHandler::OnEditUsers
        Allows different users to be assigned to a device
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::OnEditUsers
(
    ITFSComponent * pComponent, 
    LPDATAOBJECT    pDataObject,
    MMC_COOKIE      cookie
)
{
    SPITFSNode  spNode;
    SPINTERNAL  spInternal;
    int         nIndex;
    DWORD       dwFlags;
    CTapiDevice tapiDevice;
    HRESULT     hr = hrOK;

    spInternal = ExtractInternalFormat(pDataObject);

    // virtual listbox notifications come to the handler of the node that is selected.
    // assert that this notification is for a virtual listbox item 
    Assert(spInternal);
    if (!spInternal->HasVirtualIndex() || m_deviceType == DEVICE_PHONE)
        return hr;

    nIndex = spInternal->GetVirtualIndex();
    Trace1("OnEditUsers - edit users for index %d\n", nIndex);
    
    m_spTapiInfo->GetDeviceInfo(m_deviceType, &tapiDevice, m_dwProviderID, nIndex);

    //  Check to see if this device can be remoted
    hr = m_spTapiInfo->GetDeviceFlags (
        tapiDevice.m_dwProviderID,
        tapiDevice.m_dwPermanentID,
        &dwFlags
        );
    if (hr || (dwFlags & LINEDEVCAPFLAGS_LOCAL))
    {
        return hr;
    }
    
    CEditUsers  dlgEditUsers(&tapiDevice);
    
    if (dlgEditUsers.DoModal() == IDOK)
    {
        if (dlgEditUsers.IsDirty())
        {
            hr = m_spTapiInfo->SetDeviceInfo(m_deviceType, &tapiDevice);
            if (FAILED(hr))
            {
                TapiMessageBox(WIN32_FROM_HRESULT(hr));
            }
            else
            {
                pComponent->GetSelectedNode(&spNode);
            
                // clear the listbox then set the size
                UpdateListboxCount(spNode, TRUE);
                UpdateListboxCount(spNode);
            }
        }
    }

    return hr;
}

/*---------------------------------------------------------------------------
    CProviderHandler::UpdateStatus
        -
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::UpdateStatus
(
    ITFSNode * pNode
)
{
    HRESULT             hr = hrOK;
    SPIComponentData    spComponentData;
    SPIConsole          spConsole;
    IDataObject *       pDataObject;
    SPIDataObject       spDataObject;
    int                 i = 0;
    
    Trace1("CProviderHandler::UpdateStatus - Updating status for provider %x\n", m_dwProviderID);
    
    // clear our status strings
    m_mapStatus.RemoveAll();

    // force the listbox to update.  We do this by setting the count and 
    // telling it to invalidate the data
    CORg(m_spNodeMgr->GetComponentData(&spComponentData));
    CORg(m_spNodeMgr->GetConsole(&spConsole));
    
    // grab a data object to use
    CORg(spComponentData->QueryDataObject((MMC_COOKIE) pNode, CCT_RESULT, &pDataObject) );
    spDataObject = pDataObject;

    i = m_spTapiInfo->GetDeviceCount(m_deviceType, m_dwProviderID);
    CORg(spConsole->UpdateAllViews(pDataObject, i, TAPISNAP_UPDATE_STATUS));

COM_PROTECT_ERROR_LABEL;

    return hr;
}

/*---------------------------------------------------------------------------
    Misc functions
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
    CProviderHandler::BuildDisplayName
        Builds the string that goes in the UI for this server
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::BuildDisplayName
(
    CString * pstrDisplayName
)
{
    if (pstrDisplayName)
    {
        CString strName;

        *pstrDisplayName = GetDisplayName();
    }

    return hrOK;
}

/*---------------------------------------------------------------------------
    CProviderHandler::InitData
        Initializes data for this node
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::InitData
(
    CTapiProvider & tapiProvider,
    ITapiInfo *     pTapiInfo
)
{
    m_strProviderName = tapiProvider.m_strName;
    m_dwProviderID = tapiProvider.m_dwProviderID;
    m_dwFlags = tapiProvider.m_dwFlags;

    m_spTapiInfo.Set(pTapiInfo);

    SetDisplayName(m_strProviderName);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CProviderHandler::BuildTapiStrRecord
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL
CProviderHandler::BuildTapiStrRecord(int nIndex, TapiStrRecord & tsr)
{
    HRESULT             hr = hrOK;
    CTapiDevice         tapiDevice;
    CString             strTemp;
    int                 i;

    if (!m_spTapiInfo)
        return FALSE;

    COM_PROTECT_TRY
    {
        CORg (m_spTapiInfo->GetDeviceInfo(m_deviceType, &tapiDevice, m_dwProviderID, nIndex));

        // set the index for this record
        //tsr.nIndex = nIndex;

        // name
        tsr.strName = tapiDevice.m_strName;

        // users
        tsr.strUsers.Empty();
        for (i = 0; i < tapiDevice.m_arrayUsers.GetSize(); i++)
        {
            if (!tapiDevice.m_arrayUsers[i].m_strFullName.IsEmpty())
            {
                tsr.strUsers += tapiDevice.m_arrayUsers[i].m_strFullName;
            }
            else
            {
                tsr.strUsers += tapiDevice.m_arrayUsers[i].m_strName;
            }

            if ((i + 1) != tapiDevice.m_arrayUsers.GetSize())
                tsr.strUsers += _T(", ");
        }
        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH

    return SUCCEEDED(hr);
}

/*---------------------------------------------------------------------------
    CProviderHandler::BuildStatus
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL
CProviderHandler::BuildStatus(int nIndex, CString & strStatus)
{
    HRESULT hr = hrOK;

    // status
    hr = m_spTapiInfo->GetDeviceStatus(m_deviceType, &strStatus, m_dwProviderID, nIndex, NULL);
    
    if (strStatus.IsEmpty())
        strStatus.LoadString(IDS_NO_STATUS);

    return SUCCEEDED(hr);
}

/*---------------------------------------------------------------------------
    CProviderHandler::UpdateListboxCount
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::UpdateListboxCount(ITFSNode * pNode, BOOL bClear)
{
    HRESULT             hr = hrOK;
    SPIComponentData    spCompData;
    SPIConsole          spConsole;
    IDataObject*        pDataObject;
    SPIDataObject       spDataObject;
    LONG_PTR            command;               
    int i;

    COM_PROTECT_TRY
    {
        if (!m_spTapiInfo || bClear)
        {
            command = RESULT_PANE_CLEAR_VIRTUAL_LB;
            i = 0;
        }
        else
        {
            command = RESULT_PANE_SET_VIRTUAL_LB_SIZE;
            i = m_spTapiInfo->GetDeviceCount(m_deviceType, m_dwProviderID);
        }

        m_spNodeMgr->GetComponentData(&spCompData);

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

        CORg ( m_spNodeMgr->GetConsole(&spConsole) );
    
        CORg ( spConsole->UpdateAllViews(spDataObject, i, command) ); 

        COM_PROTECT_ERROR_LABEL;
    }
    COM_PROTECT_CATCH

    return hr;
}

/*---------------------------------------------------------------------------
    CProviderHandler::SetColumnInfo
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
void
CProviderHandler::SetColumnInfo()
{
    // set the correct column header
    if (m_deviceType == DEVICE_LINE)
    {
        aColumns[TAPISNAP_PROVIDER][0] = IDS_LINE_NAME;
    }
    else
    {
        aColumns[TAPISNAP_PROVIDER][0] = IDS_PHONE_NAME;
    }
}

/*---------------------------------------------------------------------------
    CProviderHandler::UpdateColumnText
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CProviderHandler::UpdateColumnText(ITFSComponent * pComponent)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    SPIHeaderCtrl spHeaderCtrl;
    pComponent->GetHeaderCtrl(&spHeaderCtrl);

    CString str;
    int i = 0;

    while (TRUE)
    {
        if ( 0 == aColumns[TAPISNAP_PROVIDER][i] )
            break;
        
        str.LoadString(aColumns[TAPISNAP_PROVIDER][i]);
        
        spHeaderCtrl->SetColumnText(i, const_cast<LPTSTR>((LPCWSTR)str));

        i++;
    }

    return hrOK;

}

/*---------------------------------------------------------------------------
    Background thread functionality
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
    CProviderHandler::OnCreateQuery
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CProviderHandler::OnCreateQuery(ITFSNode * pNode)
{
    CProviderHandlerQueryObj* pQuery = 
        new CProviderHandlerQueryObj(m_spTFSCompData, m_spNodeMgr);
    
    //pQuery->m_strServer = NULL;
    
    return pQuery;
}

/*---------------------------------------------------------------------------
    CProviderHandlerQueryObj::Execute()
        Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP
CProviderHandlerQueryObj::Execute()
{
    return hrFalse;
}