windows-xp/Source/XPSP1/NT/admin/activec/nodemgr/dummysi.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1999 - 1999
//
//  File:       dummysi.cpp
//
//  Contents:  If a snapin creation fails a Dummy snapin is created,
//             this file contains the dummy snapin implementation.
//
//--------------------------------------------------------------------------

#include "stdafx.h"
#include "dummysi.h"
#include "regutil.h"


const CLSID CLSID_Dummy    = {0x82c37898,0x7808,0x11d1,{0xa1,0x90,0x00,0x00,0xf8,0x75,0xb1,0x32}};
const GUID IID_CDummySnapinCD = {0xe683b257, 0x3ca9, 0x454a, {0xae, 0xb9, 0x7, 0x64, 0xdd, 0x31, 0xb1, 0xe8}};

//+-------------------------------------------------------------------
//
//  Class:      CDummySnapinCD
//
//  Purpose:    Dummy snapin's ComponentData.
//
//  Notes:      Dummy snapin should implement all 3 persist interfaces
//              or None. So let us implement none.
//
//--------------------------------------------------------------------

class CDummySnapinCD :
    public IComponentData,
    public CComObjectRoot

{
public:

// ATL Maps
DECLARE_NOT_AGGREGATABLE(CDummySnapinCD)

BEGIN_COM_MAP(CDummySnapinCD)
    COM_INTERFACE_ENTRY(IComponentData)
    COM_INTERFACE_ENTRY_IID(IID_CDummySnapinCD, CDummySnapinCD)
END_COM_MAP()

    CDummySnapinCD() : m_eReason(eNoReason) {}
    ~CDummySnapinCD() {}

// IComponentData interface members
    STDMETHOD(Initialize)(LPUNKNOWN pUnknown);
    STDMETHOD(CreateComponent)(LPCOMPONENT* ppComponent);
    STDMETHOD(Notify)(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param);
    STDMETHOD(Destroy)();
    STDMETHOD(QueryDataObject)(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject);
    STDMETHOD(GetDisplayInfo)(SCOPEDATAITEM* pScopeDataItem);
    STDMETHOD(CompareObjects)(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB);

    void  SetDummyCreateReason(EDummyCreateReason eReason) { m_eReason = eReason; }
    EDummyCreateReason GetDummyCreateReason() const { return m_eReason;}

    const CLSID& GetFailedSnapinCLSID() { return m_clsid;}
    void SetFailedSnapinCLSID(const CLSID& clsid) { m_clsid = clsid; }

private:
    EDummyCreateReason m_eReason;       // Reason for dummy creation.
    CLSID              m_clsid;         // Class ID of the snapin that could not be created.
};

DEFINE_COM_SMARTPTR(CDummySnapinCD);   // CDummySnapinCDPtr

//+-------------------------------------------------------------------
//
//  Class:      CDataObject
//
//  Purpose:    Dummy snapin's IDataObject implementation.
//
//--------------------------------------------------------------------
class CDataObject:
    public IDataObject,
    public CComObjectRoot
{
public:

// ATL Maps
DECLARE_NOT_AGGREGATABLE(CDataObject)

BEGIN_COM_MAP(CDataObject)
    COM_INTERFACE_ENTRY(IDataObject)
END_COM_MAP()

    CDataObject();
    ~CDataObject() {}

// IDataObject overrides
    STDMETHOD(GetDataHere) (FORMATETC *pformatetc, STGMEDIUM *pmedium);
// Not Implemented
private:
    STDMETHOD(GetData)(LPFORMATETC lpFormatetcIn, LPSTGMEDIUM lpMedium)
    { return E_NOTIMPL; };
    STDMETHOD(EnumFormatEtc)(DWORD dwDirection, LPENUMFORMATETC* ppEnumFormatEtc)
    { return E_NOTIMPL; };
    STDMETHOD(QueryGetData)(LPFORMATETC lpFormatetc)
    { return E_NOTIMPL; };
    STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC lpFormatetcIn, LPFORMATETC lpFormatetcOut)
    { return E_NOTIMPL; };
    STDMETHOD(SetData)(LPFORMATETC lpFormatetc, LPSTGMEDIUM lpMedium, BOOL bRelease)
    { return E_NOTIMPL; };
    STDMETHOD(DAdvise)(LPFORMATETC lpFormatetc, DWORD advf, LPADVISESINK pAdvSink, LPDWORD pdwConnection)
    { return E_NOTIMPL; };
    STDMETHOD(DUnadvise)(DWORD dwConnection)
    { return E_NOTIMPL; };
    STDMETHOD(EnumDAdvise)(LPENUMSTATDATA* ppEnumAdvise)
    { return E_NOTIMPL; };

public:
    static UINT s_cfInternal;      // Our custom clipboard format
    static UINT s_cfDisplayName;   // Our test for a node
    static UINT s_cfNodeType;
    static UINT s_cfSnapinClsid;
};

//+-------------------------------------------------------------------
//
//  Class:      CDummySnapinC
//
//  Purpose:    Dummy snapin's IComponent implementation.
//
//--------------------------------------------------------------------
class CDummySnapinC:
    public IComponent,
    public CComObjectRoot
{
private:
    LPCONSOLE       m_pConsole;
    CDummySnapinCD* m_pComponentData;

public:
    void SetComponentData(CDummySnapinCD* pCompData)
    {
        m_pComponentData = pCompData;
    }

public:

// ATL Maps
DECLARE_NOT_AGGREGATABLE(CDummySnapinC)

BEGIN_COM_MAP(CDummySnapinC)
    COM_INTERFACE_ENTRY(IComponent)
END_COM_MAP()

    CDummySnapinC() :m_pConsole(NULL), m_pComponentData(NULL) {}
    ~CDummySnapinC() {}

    //
    // IComponent interface members
    //
    STDMETHOD(Initialize) (LPCONSOLE lpConsole);
    STDMETHOD(Notify) (LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param);
    STDMETHOD(Destroy) (MMC_COOKIE cookie);
    STDMETHOD(GetResultViewType) (MMC_COOKIE cookie,  LPOLESTR* ppViewType, long* pViewOptions);
    STDMETHOD(QueryDataObject) (MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject);
    STDMETHOD(GetDisplayInfo) (RESULTDATAITEM*  pResultDataItem);
    STDMETHOD(CompareObjects) (LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB);
};

//+-------------------------------------------------------------------
//
//  Member:     ScCreateDummySnapin
//
//  Synopsis:   Create a dummy snapin.
//
//  Arguments:  [ppICD]   -  Ptr to dummy snapins IComponentData.
//              [eReason] -  Reason for creating dummy snapin.
//              [clsid]   -  Class ID of the snapin that could not be created.
//
//--------------------------------------------------------------------
SC ScCreateDummySnapin (IComponentData ** ppICD, EDummyCreateReason eReason, const CLSID& clsid)
{
    DECLARE_SC(sc, TEXT("ScCreateDummySnapin"));

    sc = ScCheckPointers(ppICD);
    if(sc)
        return sc;

    ASSERT(eNoReason != eReason);

    *ppICD = NULL;

    CComObject<CDummySnapinCD>* pDummySnapinCD;
    sc = CComObject<CDummySnapinCD>::CreateInstance (&pDummySnapinCD);
    if (sc)
        return sc;

    if (NULL == pDummySnapinCD)
        return (sc = E_UNEXPECTED);

    pDummySnapinCD->SetDummyCreateReason(eReason);
    pDummySnapinCD->SetFailedSnapinCLSID(clsid);

    IComponentDataPtr spComponentData = pDummySnapinCD;
    if(spComponentData == NULL)
    {
        delete pDummySnapinCD;
        return (sc = E_UNEXPECTED);
    }

    *ppICD = spComponentData;
    if(NULL == *ppICD)
    {
        delete pDummySnapinCD;
        return (sc = E_UNEXPECTED);
    }

    (*ppICD)->AddRef(); //addref for client

    return sc;
}

//+-------------------------------------------------------------------
//
//  Member:     ReportSnapinInitFailure
//
//  Synopsis:   Get the name of the snapin provided class id.
//
//  Arguments:  [strClsid] - Class id of the snapin.
//              [szName]   - Name of the snapin.
//
//--------------------------------------------------------------------
void ReportSnapinInitFailure(const CLSID& clsid)
{
    DECLARE_SC(sc, _T("ReportSnapinInitFailure"));

    // snapin name
    CStr strMessage;
    strMessage.LoadString(GetStringModule(), IDS_SNAPIN_FAILED_INIT_NAME);

    CCoTaskMemPtr<WCHAR> spszClsid;
    sc = StringFromCLSID(clsid, &spszClsid);
    if (sc)
        return;

    USES_CONVERSION;
    tstring strSnapName;
    bool bSuccess = GetSnapinNameFromCLSID(clsid, strSnapName);
    if (false == bSuccess)
    {
        TraceError(_T("GetSnapinName call in ReportSnapinInitFailure failed."), sc);

        // signal unknown name of snapin and continue
        if ( !strSnapName.LoadString( GetStringModule(), IDS_UnknownSnapinName ) )
            strSnapName = _T("<unknown>");
    }

    strMessage += strSnapName.data();

    // clsid
    CStr strClsid2;
    strClsid2.LoadString(GetStringModule(), IDS_SNAPIN_FAILED_INIT_CLSID);
    strClsid2 += OLE2T(spszClsid);

    // construct the error message
    CStr strError;
    strError.LoadString(GetStringModule(), IDS_SNAPIN_FAILED_INIT);

    strError += strMessage;
    strError += strClsid2;

    MMCErrorBox(strError, MB_OK|MB_TASKMODAL);

    return;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::Initialize
//
//  Synopsis:   Does nothing.
//
//  Arguments:  [pUnknown] - IConsole2 ptr.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::Initialize (LPUNKNOWN pUnknown)
{ return S_OK; }

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::CreateComponent
//
//  Synopsis:   Creates a CDummySnapinC object.
//
//  Arguments:  [ppComponent] - Ptr to created component.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::CreateComponent (LPCOMPONENT* ppComponent)
{
    SC sc = E_FAIL;

    CComObject<CDummySnapinC>* pDummySnapinC;
    sc = CComObject<CDummySnapinC>::CreateInstance (&pDummySnapinC);
    if (sc)
        goto Error;

    if (NULL == pDummySnapinC)
        goto Error;

    pDummySnapinC->SetComponentData(this);
    sc = pDummySnapinC->QueryInterface(IID_IComponent, reinterpret_cast<void**>(ppComponent));

Cleanup:
    return HrFromSc(sc);

Error:
    TraceError(TEXT("CDummySnapinCD::CreateComponent"), sc);
     goto Cleanup;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::Notify
//
//  Synopsis:   Right now does not handle any events.
//
//  Arguments:  [lpDataObject] - Ptr to created component.
//              [event]        - Event type.
//              [arg, param)   - event specific data.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::Notify (LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
    return S_OK;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::Destroy
//
//  Synopsis:   Right now does nothing to destroy.
//
//  Arguments:  None
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::Destroy ()
{ return S_OK; }

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::QuertDataObject
//
//  Synopsis:   Get IDataObject.
//
//  Arguments:  [cookie]       - Snapin specific data.
//              [type]         - data obj type, Scope/Result/Snapin mgr...
//              [ppDataObject] - IDataObject ptr.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::QueryDataObject (MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject)
{
    SC sc = E_FAIL;

    CComObject<CDataObject>* pDataObject;
    sc = CComObject<CDataObject>::CreateInstance (&pDataObject);
    if (sc)
        goto Error;

    if (NULL == pDataObject)
        goto Error;

    sc = pDataObject->QueryInterface(IID_IDataObject, reinterpret_cast<void**>(ppDataObject));

Cleanup:
    return HrFromSc(sc);

Error:
    TraceError(TEXT("CDummySnapinCD::QueryDataObject"), sc);
     goto Cleanup;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::GetDisplayInfo
//
//  Synopsis:   Display info call back.
//              (Right now there is nothing to display, no enumerated item).
//
//  Arguments:  [pScopeDataItem] - Snapin should fill this struct for Display info.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::GetDisplayInfo (SCOPEDATAITEM* pScopeDataItem)
{ return S_OK; }

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinCD::CompareObjects
//
//  Synopsis:   Used for sort / find prop sheet...
//              (Right now do nothing as we have only one item).
//
//  Arguments:  [lpDataObjectA] - IDataObject of first item.
//              [lpDataObjectB] - IDataObject of second item.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinCD::CompareObjects (LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{ return S_OK; }

#define MY_CF_SNAPIN_INTERNAL L"DUMMY SNAPIN"

// global(s)
const GUID GUID_DummyNode = {
    0x82c37899,
    0x7808,
    0x11d1,
    {0xa1, 0x90, 0x00, 0x00, 0xf8, 0x75, 0xb1, 0x32}
};

// statics
UINT CDataObject::s_cfInternal = 0;
UINT CDataObject::s_cfDisplayName = 0;
UINT CDataObject::s_cfNodeType = 0;
UINT CDataObject::s_cfSnapinClsid = 0;

CDataObject::CDataObject()
{
    USES_CONVERSION;
    s_cfInternal    = RegisterClipboardFormat (W2T(MY_CF_SNAPIN_INTERNAL));
    s_cfDisplayName = RegisterClipboardFormat (W2T(CCF_DISPLAY_NAME));
    s_cfNodeType    = RegisterClipboardFormat (W2T(CCF_NODETYPE));
    s_cfSnapinClsid = RegisterClipboardFormat (W2T(CCF_SNAPIN_CLASSID));
}

//+-------------------------------------------------------------------
//
//  Member:     CDataObject::GetDataHere
//
//  Synopsis:   IDataObject::GetDataHere.
//
//  Arguments:  [pformatetc]
//              [pmedium]
//
//--------------------------------------------------------------------
HRESULT CDataObject::GetDataHere (FORMATETC *pformatetc, STGMEDIUM *pmedium)
{
    SC sc = DV_E_FORMATETC;

    IStream * pstm = NULL;
    sc = CreateStreamOnHGlobal (pmedium->hGlobal, FALSE, &pstm);
    if (pstm) {

       const CLIPFORMAT cf = pformatetc->cfFormat;

       if (cf == s_cfDisplayName) {
          LPTSTR pszName = _T("Display Manager (Version 2)");
          sc = pstm->Write (pszName, sizeof(TCHAR)*(1+_tcslen (pszName)), NULL);
       } else
       if (cf == s_cfInternal) {
          CDataObject * pThis = this;
          sc = pstm->Write (pThis, sizeof(CDataObject *), NULL);
       } else
       if (cf == s_cfNodeType) {
          const GUID * pguid;
          pguid = &GUID_DummyNode;
          sc = pstm->Write ((PVOID)pguid, sizeof(GUID), NULL);
       } else
       if (cf == s_cfSnapinClsid) {
          sc = pstm->Write (&CLSID_Dummy, sizeof(CLSID_Dummy), NULL);
       } else {
          sc = DV_E_FORMATETC;
          // don't ASSERT
          // _ASSERT(hresult == S_OK);
       }
       pstm->Release();
    }

    return HrFromSc(sc);
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::Initialize
//
//  Synopsis:   Just store given ICOnsole2.
//
//  Arguments:  [lpConsole] - IConsole2 ptr.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::Initialize (LPCONSOLE lpConsole)
{
    m_pConsole = lpConsole;
    if (m_pConsole)
        m_pConsole->AddRef();

    return S_OK;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::Notify
//
//  Synopsis:   Right now handle only MMCN_SHOW to display
//              IMessageView with failure message.
//
//  Arguments:  [lpDataObject] - Ptr to created component.
//              [event]        - Event type.
//              [arg, param)   - event specific data.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::Notify (LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
    DECLARE_SC(sc, _T("CDummySnapinC::Notify"));
    sc = S_FALSE; // Default ret val.

    switch(event)
    {
    case MMCN_SHOW: // Display error message during MMCN_SHOW, TRUE.
        {
            if (FALSE == arg)
                break;

            // First get the IUnknown of Result Pane.
            LPUNKNOWN lpUnkn = NULL;
            sc = m_pConsole->QueryResultView(&lpUnkn);

            if (sc)
                return sc.ToHr();

            // Now get the message view.
            IMessageViewPtr spMessageView;
            sc = lpUnkn->QueryInterface(IID_IMessageView, reinterpret_cast<void**>(&spMessageView));
            lpUnkn->Release();

            if (sc)
                return sc.ToHr();

            // Got the message view, not set the title and text.
            CStr strTempForLoading; // Temp object for loading string from resources.

            sc = spMessageView->Clear();
            if (sc)
                return sc.ToHr();

            strTempForLoading.LoadString(GetStringModule(), IDS_SNAPIN_CREATE_FAILED);

            USES_CONVERSION;
            sc = spMessageView->SetTitleText( T2OLE((LPTSTR)(LPCTSTR)strTempForLoading));
            if (sc)
                return sc.ToHr();

            sc = spMessageView->SetIcon(Icon_Error);
            if (sc)
                return sc.ToHr();

            //////////////////////////////////
            // The body text is as follows  //
            //      Reason.                 //
            //      Snapin Name.            //
            //      Snapin Class ID.        //
            //////////////////////////////////

            tstring szBodyText;       // Body text for message view.

            if (m_pComponentData->GetDummyCreateReason() == eSnapPolicyFailed)
                strTempForLoading.LoadString(GetStringModule(), IDS_SNAPIN_POLICYFAILURE);
            else
                strTempForLoading.LoadString(GetStringModule(), IDS_SNAPIN_FAILED);

            // Reason for failure.
            szBodyText = strTempForLoading + _T('\n');

            // Snapin name.
            CStr strSnapName;
            strTempForLoading.LoadString(GetStringModule(), IDS_SNAPIN_FAILED_INIT_NAME);
            szBodyText += strTempForLoading;

            CCoTaskMemPtr<WCHAR> spszClsid;
            sc = StringFromCLSID(m_pComponentData->GetFailedSnapinCLSID(), &spszClsid);
            if (sc)
                return sc.ToHr();

            // Get the snapin name.
            tstring szSnapinName;
            bool bSucc = GetSnapinNameFromCLSID(m_pComponentData->GetFailedSnapinCLSID(), szSnapinName);
            if (false == bSucc)
            {
                sc = E_FAIL;
                TraceError(_T("GetSnapinName call in CDummySnapinC::Notify failed."), sc);
                return sc.ToHr();
            }

            szBodyText += szSnapinName;
            szBodyText += _T("\n");

            // Now add the snapin class id.
            strTempForLoading.LoadString(GetStringModule(), IDS_SNAPIN_FAILED_INIT_CLSID);
            szBodyText += strTempForLoading;
            szBodyText += OLE2T(spszClsid);

            sc = spMessageView->SetBodyText( T2COLE(szBodyText.data()));
        }
        break;

    default:
        break;
    }

    return sc.ToHr();
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::Destroy
//
//  Synopsis:   Release the cached IConsole2 ptr.
//
//  Arguments:  None
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::Destroy (MMC_COOKIE cookie)
{
    if (m_pConsole)
        m_pConsole->Release();

    return S_OK;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::GetResultViewType
//
//  Synopsis:   Specify the message view as result view type.
//
//  Arguments:  [cookie]       - Snapin supplied param.
//              [ppViewType]   - View Name (OCX - GUID, WEB - URL name).
//              [pViewOptions] - View options
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::GetResultViewType (MMC_COOKIE cookie,  LPOLESTR* ppViewType, long* pViewOptions)
{
    SC sc;

    TCHAR szBuffer[MAX_PATH * 2];

    // We want to display the error message using the message view.
    LPOLESTR lpClsid = NULL;
    sc = StringFromCLSID(CLSID_MessageView, &lpClsid);

    USES_CONVERSION;
    if (!sc.IsError())
    {
        // Use the message view to display error message.
        _tcscpy (szBuffer, OLE2T(lpClsid));
        ::CoTaskMemFree(lpClsid);
    }
    else
    {
        // Conversion failed, display default error page.
        _tcscpy (szBuffer, _T("res://"));
        ::GetModuleFileName (NULL, szBuffer + _tcslen(szBuffer), MAX_PATH);
        _tcscat (szBuffer, _T("/error.htm"));
    }

    *ppViewType = (OLECHAR *)::CoTaskMemAlloc (sizeof(OLECHAR)*(1+_tcslen(szBuffer)));
    if (!*ppViewType)
    {
        sc = E_OUTOFMEMORY;
        goto Error;
    }

    wcscpy (*ppViewType, T2OLE(szBuffer));

Cleanup:
    return HrFromSc(sc);
Error:
    TraceError(TEXT("CDummySnapinC::GetResultViewType"), sc);
    goto Cleanup;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::QuertDataObject
//
//  Synopsis:   Get IDataObject.
//
//  Arguments:  [cookie]       - Snapin specific data.
//              [type]         - data obj type, Scope/Result/Snapin mgr...
//              [ppDataObject] - IDataObject ptr.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::QueryDataObject (MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject)
{
    SC sc = E_FAIL;

    CComObject<CDataObject>* pDataObject;
    sc = CComObject<CDataObject>::CreateInstance (&pDataObject);
    if (sc)
        goto Error;

    if (NULL == pDataObject)
        goto Error;

    sc = pDataObject->QueryInterface(IID_IDataObject, reinterpret_cast<void**>(ppDataObject));

Cleanup:
    return HrFromSc(sc);
Error:
    TraceError(TEXT("CDummySnapinC::QueryDataObject"), sc);
    goto Cleanup;
}

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::GetDisplayInfo
//
//  Synopsis:   Display info call back.
//              (Right now there is nothing to display, no result items).
//
//  Arguments:  [pResultDataItem] - Snapin should fill this struct for Display info.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::GetDisplayInfo (RESULTDATAITEM*  pResultDataItem)
{ return S_OK; }

//+-------------------------------------------------------------------
//
//  Member:     CDummySnapinC::CompareObjects
//
//  Synopsis:   Used for sort / find prop sheet...
//              (Right now do nothing as we dont have any result items).
//
//  Arguments:  [lpDataObjectA] - IDataObject of first item.
//              [lpDataObjectB] - IDataObject of second item.
//
//--------------------------------------------------------------------
HRESULT CDummySnapinC::CompareObjects (LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{ return S_OK; }

#include "scopndcb.h"

//+-------------------------------------------------------------------
//
//  Member:      CNodeCallback::IsDummySnapin
//
//  Synopsis:    Given the node see if it is dummy snapin.
//
//  Arguments:   [hNode]        - [in] Node selection context.
//               [bDummySnapin] - [out] Is this dummy snapin?
//
//  Returns:     SC
//
//--------------------------------------------------------------------
HRESULT CNodeCallback::IsDummySnapin (/*[in]*/HNODE hNode, /*[out]*/bool& bDummySnapin)
{
    DECLARE_SC(sc, _T("CNodeCallback::IsDummySnapin"));
    sc = ScCheckPointers( (void*) hNode);
    if (sc)
        return sc.ToHr();

    bDummySnapin = false;

    CNode *pNode = CNode::FromHandle(hNode);
    sc = ScCheckPointers(pNode, E_UNEXPECTED);
    if (sc)
        return sc.ToHr();

    CMTNode *pMTNode = pNode->GetMTNode();
    sc = ScCheckPointers(pMTNode, E_UNEXPECTED);
    if (sc)
        return sc.ToHr();

    CComponentData *pComponentData = pMTNode->GetPrimaryComponentData();
    sc = ScCheckPointers(pComponentData, E_UNEXPECTED);
    if (sc)
        return sc.ToHr();

    IComponentData* pIComponentData = pComponentData->GetIComponentData();
    sc = ScCheckPointers(pIComponentData, E_UNEXPECTED);
    if (sc)
        return sc.ToHr();

    CDummySnapinCDPtr spDummyCD = pIComponentData;
    if (spDummyCD)
        bDummySnapin = true;

    return (sc.ToHr());
}