windows-xp/Source/XPSP1/NT/admin/activec/inc/resultview.h

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 2000
//
//  File:       ResultViewInfo.h
//
//  History:    Jan-18-2000 VivekJ Added
//--------------------------------------------------------------------------
#ifndef _RESULTVIEW_H
#define _RESULTVIEW_H

/*+-------------------------------------------------------------------------*
 * class CResultViewType
 *
 *
 * PURPOSE: Provides a wrapper for the RESULT_VIEW_TYPE_INFO structure, and
 *          is used for communication between conui and nodemgr.
 *
 *+-------------------------------------------------------------------------*/
class CResultViewType : public CXMLObject
{
    typedef std::wstring wstring; // only wide strings are needed here.

protected:
    virtual void Persist(CPersistor &persistor);

    DEFINE_XML_TYPE(XML_TAG_RESULTVIEWTYPE);

public:
    CResultViewType();
    CResultViewType &   operator =(RESULT_VIEW_TYPE_INFO &rvti); // conversion from a RESULT_VIEW_TYPE_INFO structure

    bool operator != (const CResultViewType& rvt) const;

    // the default copy constructor and assignment operators are sufficient

    MMC_VIEW_TYPE   GetType()        const  {return m_viewType;}
    DWORD           GetListOptions() const  {return m_dwListOptions;}
    DWORD           GetHTMLOptions() const  {return m_dwHTMLOptions;}
    DWORD           GetOCXOptions()  const  {return m_dwOCXOptions;}
    DWORD           GetMiscOptions() const  {return m_dwMiscOptions;}

    BOOL            HasList()        const  {return (m_viewType==MMC_VIEW_TYPE_LIST);}
    BOOL            HasWebBrowser()  const  {return (m_viewType==MMC_VIEW_TYPE_HTML);}
    BOOL            HasOCX()         const  {return (m_viewType==MMC_VIEW_TYPE_OCX);}

    LPCOLESTR       GetURL()         const  {return m_strURL.data();}
    LPCOLESTR       GetOCX()         const  {return m_strOCX.data();}

    LPUNKNOWN       GetOCXUnknown()  const  {return m_spUnkControl;} // returns the IUnknown of the OCX.

    bool            IsPersistableViewDescriptionValid() const {return m_bPersistableViewDescriptionValid;}
    bool            IsMMC12LegacyData()                 const {return !IsPersistableViewDescriptionValid();}

    SC              ScInitialize(LPOLESTR & pszView, long lMiscOptions); // the legacy case.
    SC              ScGetOldTypeViewOptions(long* plViewOptions) const;
    SC              ScReset();

// functions specific to nodemgr. Do NOT add any member variables in this section.
#ifdef _NODEMGR_DLL_
    SC              ScInitialize(RESULT_VIEW_TYPE_INFO &rvti);

    SC              ScGetResultViewTypeInfo(RESULT_VIEW_TYPE_INFO& rvti) const;
#endif _NODEMGR_DLL_


private:
    bool            m_bPersistableViewDescriptionValid;
    bool            m_bInitialized;

    MMC_VIEW_TYPE   m_viewType;

    wstring         m_strURL;
    wstring         m_strOCX;           // for snapins that implement IComponent only.
    wstring         m_strPersistableViewDescription;

    DWORD           m_dwMiscOptions;
    DWORD           m_dwListOptions;
    DWORD           m_dwHTMLOptions;
    DWORD           m_dwOCXOptions;

    CComPtr<IUnknown>   m_spUnkControl;     // a smart pointer for the control created by the snapin.

};

inline CResultViewType::CResultViewType()
:
  m_viewType(MMC_VIEW_TYPE_LIST), // the default view type
  m_dwMiscOptions(0),
  m_dwListOptions(0),
  m_dwHTMLOptions(0),
  m_dwOCXOptions(0),
  m_bPersistableViewDescriptionValid(false),
  m_bInitialized(false)
{
}

//+-------------------------------------------------------------------
//
//  Member:      CResultViewType::ScReset
//
//  Synopsis:
//
//  Arguments:
//
//  Returns:     SC
//
//--------------------------------------------------------------------
inline SC CResultViewType::ScReset ()
{
    DECLARE_SC(sc, _T("CResultViewType::ScReset"));

    m_viewType         = MMC_VIEW_TYPE_LIST; // the default view type
    m_dwMiscOptions    = 0;
    m_dwListOptions    = 0;
    m_dwHTMLOptions    = 0;
    m_dwOCXOptions     = 0;

    m_bPersistableViewDescriptionValid = false;
    m_bInitialized     = false;

    return (sc);
}


/*+-------------------------------------------------------------------------*
 *
 * CResultViewType::operator!=
 *
 * PURPOSE: Operator != (Used by CViewSettings which is used by CMemento).
 *
 * NOTE:    For MMC2 compare only persistable view desc for MMC1.2 compare all
 *          parameters.
 *
 *+-------------------------------------------------------------------------*/
inline
bool CResultViewType::operator != (const CResultViewType& rvt) const
{
    if (m_bInitialized != rvt.m_bInitialized)
        return true;

    if (m_bPersistableViewDescriptionValid)
    {
        if (m_strPersistableViewDescription != rvt.m_strPersistableViewDescription)
            return true;

        return false;
    }

    // Legacy case MMC1.2, should compare other parameters.
    switch(m_viewType)
    {
    default:
        ASSERT(FALSE && _T("Unknown view type"));
        break;

    case MMC_VIEW_TYPE_LIST:
        if ( (m_viewType != rvt.m_viewType) ||
             (m_dwMiscOptions != rvt.m_dwMiscOptions) ||
             (m_dwListOptions != rvt.m_dwListOptions) )
        {
            return true;
        }
        break;

    case MMC_VIEW_TYPE_HTML:
        if ( (m_viewType != rvt.m_viewType) ||
             (m_dwMiscOptions != rvt.m_dwMiscOptions) ||
             (m_dwHTMLOptions != rvt.m_dwHTMLOptions) ||
             (m_strURL != rvt.m_strURL) )
        {
            return true;
        }

        break;

    case MMC_VIEW_TYPE_OCX:
        if ( (m_viewType != rvt.m_viewType) ||
             (m_dwMiscOptions != rvt.m_dwMiscOptions) ||
             (m_dwOCXOptions  != rvt.m_dwOCXOptions) ||
             (m_strOCX != rvt.m_strOCX) )
        {
            return true;
        }
        break;
    }

    return false;
}

/*+-------------------------------------------------------------------------*
 *
 * CResultViewType::ScInitialize
 *
 * PURPOSE: Initializes the class from parameters returned by IComponent::
 *          GetResultViewType
 *
 * PARAMETERS:
 *    LPOLESTR  ppViewType :
 *    long      lViewOptions :
 *
 * RETURNS:
 *    SC
 *
 * NOTE:     This is for MMC1.2 compatible GetResultViewType.
 *
 *+-------------------------------------------------------------------------*/
inline
SC CResultViewType::ScInitialize(LPOLESTR & pszView, long lViewOptions)
{
    DECLARE_SC(sc, TEXT("CResultViewType::ScInitialize"));

    m_bInitialized = true;

    m_bPersistableViewDescriptionValid = false; // the legacy case - we don't have a persistable view description.

    // MMC_VIEW_OPTIONS_NOLISTVIEWS is a special case - it goes to the dwMiscOptions
    if(lViewOptions & MMC_VIEW_OPTIONS_NOLISTVIEWS)
        m_dwMiscOptions |= RVTI_MISC_OPTIONS_NOLISTVIEWS;

    // check whether the type of view is a web page or OCX.
    if ( (NULL == pszView) || (_T('\0') == pszView[0]) )
    {
        // the result pane is a standard list
        m_viewType = MMC_VIEW_TYPE_LIST;

        m_dwListOptions = 0;

        // convert the view options from the old bits to the new ones
        if(lViewOptions & MMC_VIEW_OPTIONS_OWNERDATALIST)                   m_dwListOptions |= RVTI_LIST_OPTIONS_OWNERDATALIST;
        if(lViewOptions & MMC_VIEW_OPTIONS_MULTISELECT)                     m_dwListOptions |= RVTI_LIST_OPTIONS_MULTISELECT;
        if(lViewOptions & MMC_VIEW_OPTIONS_FILTERED)                        m_dwListOptions |= RVTI_LIST_OPTIONS_FILTERED;
        if(lViewOptions & MMC_VIEW_OPTIONS_USEFONTLINKING)                  m_dwListOptions |= RVTI_LIST_OPTIONS_USEFONTLINKING;
        if(lViewOptions & MMC_VIEW_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST)   m_dwListOptions |= RVTI_LIST_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST;
        if(lViewOptions & MMC_VIEW_OPTIONS_LEXICAL_SORT)                    m_dwListOptions |= RVTI_LIST_OPTIONS_LEXICAL_SORT;

    }
    else
    {
        // the result pane is a web page or an OCX.

        if (L'{' == pszView[0]) // the hacky way of ensuring that the result view is an OCX
        {
            m_viewType = MMC_VIEW_TYPE_OCX;
            m_strOCX   = pszView;

            // If the snapin says "create new" then do not "cache the ocx"
            if(!(lViewOptions & MMC_VIEW_OPTIONS_CREATENEW))   m_dwOCXOptions |= RVTI_OCX_OPTIONS_CACHE_OCX;

            if(lViewOptions & MMC_VIEW_OPTIONS_NOLISTVIEWS)    m_dwOCXOptions |= RVTI_OCX_OPTIONS_NOLISTVIEW;
        }
        else
        {
            m_viewType = MMC_VIEW_TYPE_HTML;
            m_strURL   = pszView;

            if(lViewOptions & MMC_VIEW_OPTIONS_NOLISTVIEWS)    m_dwHTMLOptions |= RVTI_HTML_OPTIONS_NOLISTVIEW;
        }
    }

    // make sure we free the allocated memory.
    if(pszView != NULL)
    {
        ::CoTaskMemFree(pszView);
        pszView = NULL; // NOTE: pszView is a reference, so this changes the in parameter.
    }

    return sc;
}

//+-------------------------------------------------------------------
//
//  Member:     CResultViewType::Persist
//
//  Synopsis:   persist to / from XML document.
//
//  Arguments:  [persistor]  - target or source.
//
//--------------------------------------------------------------------
inline
void CResultViewType::Persist(CPersistor& persistor)
{
    if ( (! m_bInitialized) &&
         (persistor.IsStoring()) )
    {
        SC sc;
        (sc = E_UNEXPECTED).Throw();
    }
    else
        m_bInitialized = true;

    if (persistor.IsLoading())
        m_bPersistableViewDescriptionValid = persistor.HasElement(XML_TAG_RESULTVIEW_DESCRIPTION, NULL);

    if (m_bPersistableViewDescriptionValid)
    {
        CPersistor persistorDesc(persistor, XML_TAG_RESULTVIEW_DESCRIPTION);
        persistorDesc.PersistContents(m_strPersistableViewDescription);
        return;
    }

    // Legacy code for MMC1.2
    {
        int &viewType = (int&) m_viewType;

        // define the table to map enumeration values to strings
        static const EnumLiteral mappedViewTypes[] =
        {
            { MMC_VIEW_TYPE_LIST,   XML_ENUM_MMC_VIEW_TYPE_LIST },
            { MMC_VIEW_TYPE_HTML,   XML_ENUM_MMC_VIEW_TYPE_HTML },
            { MMC_VIEW_TYPE_OCX,    XML_ENUM_MMC_VIEW_TYPE_OCX },
        };

        const size_t countof_types = sizeof(mappedViewTypes)/sizeof(mappedViewTypes[0]);
        // create wrapper to persist flag values as strings
        CXMLEnumeration viewTypePersistor(viewType, mappedViewTypes, countof_types );
        // persist the wrapper
        persistor.PersistAttribute(XML_ATTR_VIEW_SETTINGS_TYPE, viewTypePersistor);

        switch(m_viewType)
        {
        case MMC_VIEW_TYPE_LIST:
            {
                // define the table to map enumeration flags to strings
                static const EnumLiteral mappedLVOptions[] =
                {
                    { RVTI_LIST_OPTIONS_OWNERDATALIST,      XML_BITFLAG_LIST_OPTIONS_OWNERDATALIST },
                    { RVTI_LIST_OPTIONS_MULTISELECT,        XML_BITFLAG_LIST_OPTIONS_MULTISELECT },
                    { RVTI_LIST_OPTIONS_FILTERED,           XML_BITFLAG_LIST_OPTIONS_FILTERED },
                    { RVTI_LIST_OPTIONS_USEFONTLINKING,     XML_BITFLAG_LIST_OPTIONS_USEFONTLINKING },
                    { RVTI_LIST_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST,  XML_BITFLAG_LIST_OPTIONS_NO_SCOPE_ITEMS },
                    { RVTI_LIST_OPTIONS_LEXICAL_SORT,       XML_BITFLAG_LIST_OPTIONS_LEXICAL_SORT },
                };

                const size_t countof_options = sizeof(mappedLVOptions)/sizeof(mappedLVOptions[0]);

                // create wrapper to persist flag values as strings
                CXMLBitFlags optPersistor(m_dwListOptions, mappedLVOptions, countof_options);
                persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_OPTIONS, optPersistor);
            }
            break;

        case MMC_VIEW_TYPE_HTML:
            {
                // NOT USED - persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_OPTIONS, m_dwHTMLOptions);
                m_dwHTMLOptions = 0;
                persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_URL_STRING, m_strURL);
            }
            break;

        case MMC_VIEW_TYPE_OCX:
            {
                // define the table to map enumeration flags to strings
                static const EnumLiteral mappedOCXOptions[] =
                {
                    { RVTI_OCX_OPTIONS_CACHE_OCX,      XML_BITFLAG_OCX_OPTIONS_CACHE_OCX },
                };

                const size_t countof_options = sizeof(mappedOCXOptions)/sizeof(mappedOCXOptions[0]);

                // create wrapper to persist flag values as strings
                CXMLBitFlags optPersistor(m_dwOCXOptions, mappedOCXOptions, countof_options);
                // persist the wrapper
                persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_OPTIONS, optPersistor);
                persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_OCX_STRING, m_strOCX);
            }
            break;

        default:
            ASSERT(FALSE && _T("Unknown MMC_VIEW_TYPE"));
            break;
        }

        // define the table to map enumeration flags to strings
        static const EnumLiteral mappedMiscOptions[] =
        {
            { RVTI_MISC_OPTIONS_NOLISTVIEWS,  _T("Misc_NoListViews") },
        };

        const size_t countof_miscoptions = sizeof(mappedMiscOptions)/sizeof(mappedMiscOptions[0]);

        // create wrapper to persist flag values as strings
        CXMLBitFlags miscPersistor(m_dwMiscOptions, mappedMiscOptions, countof_miscoptions);
        // persist the wrapper
        persistor.PersistAttribute(XML_ATTR_RESULTVIEWTYPE_MISC_OPTIONS, miscPersistor);
    }
}


/*+-------------------------------------------------------------------------*
 *
 * CResultViewType::ScGetOldTypeViewOptions
 *
 * PURPOSE: This method is for compatibility with MMC1.2. It makes MMC1.2 compatible
 *          view option for MMCN_RESTORE_VIEW.
 *
 * PARAMETERS:
 *    [out] long*      plViewOptions :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
inline SC
CResultViewType::ScGetOldTypeViewOptions(long* plViewOptions) const
{
    DECLARE_SC(sc, TEXT("CResultViewType::ScInitialize"));
    sc = ScCheckPointers(plViewOptions);
    if (sc)
        return sc;

    *plViewOptions = 0;

    if(! m_bInitialized)
        return (sc = E_UNEXPECTED); // should be initialized.

    if (m_bPersistableViewDescriptionValid)
        return (sc = E_UNEXPECTED); // Not MMC1.2 type data.

    if (HasWebBrowser())
    {
        if (m_dwMiscOptions & RVTI_MISC_OPTIONS_NOLISTVIEWS)
            *plViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;

        return sc;
    }

    if (HasList())
    {
        if(m_dwListOptions & RVTI_LIST_OPTIONS_OWNERDATALIST)  *plViewOptions |= MMC_VIEW_OPTIONS_OWNERDATALIST;
        if(m_dwListOptions & RVTI_LIST_OPTIONS_MULTISELECT)    *plViewOptions |= MMC_VIEW_OPTIONS_MULTISELECT;
        if(m_dwListOptions & RVTI_LIST_OPTIONS_FILTERED)       *plViewOptions |= MMC_VIEW_OPTIONS_FILTERED;
        if(m_dwListOptions & RVTI_LIST_OPTIONS_USEFONTLINKING) *plViewOptions |= MMC_VIEW_OPTIONS_USEFONTLINKING;
        if(m_dwListOptions & RVTI_LIST_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST) *plViewOptions |= MMC_VIEW_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST;
        if(m_dwListOptions & RVTI_LIST_OPTIONS_LEXICAL_SORT)   *plViewOptions |= MMC_VIEW_OPTIONS_LEXICAL_SORT;

        return sc;
    }
    else if(HasOCX())
    {
        // NOTE: The CREATENEW flag has the opposite sense of the CACHE_OCX flag.
        if(!(m_dwOCXOptions  & RVTI_OCX_OPTIONS_CACHE_OCX))    *plViewOptions |= MMC_VIEW_OPTIONS_CREATENEW;
        if (m_dwMiscOptions & RVTI_MISC_OPTIONS_NOLISTVIEWS)    *plViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;

        return sc;
    }

    return (sc = E_UNEXPECTED);
}


#ifdef _NODEMGR_DLL_
/*+-------------------------------------------------------------------------*
 *
 * CResultViewType::ScInitialize
 *
 * PURPOSE: Initializes the class from a RESULT_VIEW_TYPE_INFO structure.
 *
 * PARAMETERS:
 *    RESULT_VIEW_TYPE_INFO & rvti :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
inline SC
CResultViewType::ScInitialize(RESULT_VIEW_TYPE_INFO &rvti)
{
    DECLARE_SC(sc, TEXT("CResultViewType::ScInitialize"));

    if(m_bInitialized)
        return (sc = E_UNEXPECTED); // should not try to initialize twice

    m_bInitialized = true;

    // make sure we have a persistable view description.
    if(!rvti.pstrPersistableViewDescription)
    {
        sc = E_INVALIDARG;
        TraceSnapinError(TEXT("Parameter 'pstrPersistableViewDescription' in structure 'RESULT_VIEW_TYPE_INFO' is NULL"), sc);
        return sc;
    }

    // copy the description
    m_strPersistableViewDescription     = rvti.pstrPersistableViewDescription;
    ::CoTaskMemFree(rvti.pstrPersistableViewDescription);
    rvti.pstrPersistableViewDescription = NULL; // just to make sure we don't try to use it
    m_bPersistableViewDescriptionValid  = true;

    // validate the view type
    m_viewType = rvti.eViewType;
    if( (m_viewType != MMC_VIEW_TYPE_LIST) &&
        (m_viewType != MMC_VIEW_TYPE_OCX)  &&
        (m_viewType != MMC_VIEW_TYPE_HTML) )
    {
        sc = E_INVALIDARG;
        TraceSnapinError(TEXT("Parameter 'eViewType' in structure 'RESULT_VIEW_TYPE_INFO' is invalid"), sc);
        return sc;
    }

    // validate the various view options
    switch(m_viewType)
    {
    default:
        ASSERT(0 && "Should not come here");
        return (sc = E_INVALIDARG);
        break;

    case MMC_VIEW_TYPE_LIST:
        if(rvti.dwListOptions & ~( RVTI_LIST_OPTIONS_NONE                          |
                                   RVTI_LIST_OPTIONS_OWNERDATALIST                 | RVTI_LIST_OPTIONS_MULTISELECT    |
                                   RVTI_LIST_OPTIONS_FILTERED                      | RVTI_LIST_OPTIONS_USEFONTLINKING |
                                   RVTI_LIST_OPTIONS_EXCLUDE_SCOPE_ITEMS_FROM_LIST | RVTI_LIST_OPTIONS_LEXICAL_SORT   |
								   RVTI_LIST_OPTIONS_ALLOWPASTE )
                                   )
        {
            sc = E_INVALIDARG;
            TraceSnapinError(TEXT("Parameter 'dwListOptions' in structure 'RESULT_VIEW_TYPE_INFO' is invalid"), sc);
            return sc;
        }

        m_dwListOptions = rvti.dwListOptions;

        break;

    case MMC_VIEW_TYPE_HTML:
        // if the view type is HTML, make sure that no flags are set. If snapins wrongly set this flag, it could break our well
        // intentioned effort to add future expansion
        if(rvti.dwHTMLOptions & ~( RVTI_HTML_OPTIONS_NONE |
                                   RVTI_HTML_OPTIONS_NOLISTVIEW) )
        {
            sc = E_INVALIDARG;
            TraceSnapinError(TEXT("Parameter 'dwHTMLOptions' in structure 'RESULT_VIEW_TYPE_INFO' must be zero"), sc);
            return sc;
        }

        // make sure we have a valid URL
        if(NULL == rvti.pstrURL)
        {
            sc = E_INVALIDARG;
            TraceSnapinError(TEXT("Parameter 'pstrURL' in structure 'RESULT_VIEW_TYPE_INFO' cannot be NULL"), sc);
            return sc;
        }

        m_dwHTMLOptions = 0;

        // copy the URL
        m_strURL     = rvti.pstrURL;
        ::CoTaskMemFree(rvti.pstrURL);
        rvti.pstrURL = NULL; // just to make sure we don't try to use it

        break;

    case MMC_VIEW_TYPE_OCX:
        if(rvti.dwOCXOptions & ~( RVTI_OCX_OPTIONS_NONE |
                                  RVTI_OCX_OPTIONS_NOLISTVIEW |
                                  RVTI_OCX_OPTIONS_CACHE_OCX) )
        {
            sc = E_INVALIDARG;
            TraceSnapinError(TEXT("Parameter 'dwOCXOptions' in structure 'RESULT_VIEW_TYPE_INFO' is invalid"), sc);
            return sc;
        }

        // if an OCX was specified, must have a valid OCX control IUnknown
        if(rvti.pUnkControl == NULL)
        {
            sc = E_INVALIDARG;
            TraceSnapinError(TEXT("No OCX specified in parameter 'pUnkControl' of structure 'RESULT_VIEW_TYPE_INFO'"), sc);
            return sc;
        }

        m_dwOCXOptions = rvti.dwOCXOptions;
        m_spUnkControl = rvti.pUnkControl; // does an addref, but rvti.ppUnkControl already had an addref set by the snapin. So need to release it once.
		rvti.pUnkControl->Release();
        break;
    }


    return sc;
}


//+-------------------------------------------------------------------
//
//  Member:      CResultViewType::ScGetResultViewTypeInfo
//
//  Synopsis:    Fill the RESULT_VIEW_TYPE_INFO struct and return.
//
//  Arguments:   [rvti] - Fill the struct and return.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
inline SC
CResultViewType::ScGetResultViewTypeInfo (RESULT_VIEW_TYPE_INFO& rvti) const
{
    DECLARE_SC(sc, _T("CResultViewType::ScGetResultViewTypeInfo"));

    if(! m_bInitialized)
        return (sc = E_UNEXPECTED);

    ZeroMemory(&rvti, sizeof(rvti));
    rvti.pstrPersistableViewDescription = NULL;

    // must have a persistable description
    if (!IsPersistableViewDescriptionValid())
        return (sc = E_UNEXPECTED);

    rvti.pstrPersistableViewDescription = (LPOLESTR)
         CoTaskMemAlloc( (1 + wcslen(m_strPersistableViewDescription.data())) * sizeof(OLECHAR));
    sc = ScCheckPointers(rvti.pstrPersistableViewDescription, E_OUTOFMEMORY);
    if (sc)
        return sc;

    // copy over the description string.
    wcscpy(rvti.pstrPersistableViewDescription, m_strPersistableViewDescription.data());


    return (sc);
}
#endif _NODEMGR_DLL_

#endif //_RESULTVIEW_H