windows-nt/Source/XPSP1/NT/shell/ext/docpropv3/propertycacheitem.cpp

//
//  Copyright 2001 - Microsoft Corporation
//
//
//  Created By:
//      Geoff Pease (GPease)    23-JAN-2001
//
//  Maintained By:
//      Geoff Pease (GPease)    23-JAN-2001
//
#include "pch.h"
#include "DocProp.h"
#include "DefProp.h"
#include "PropertyCacheItem.h"
#pragma hdrstop


// ***************************************************************************
//
//  Class statics
//
// ***************************************************************************
WCHAR CPropertyCacheItem::_szMultipleString[ MAX_PATH ] = { 0 };


// ***************************************************************************
//
//  Constructor / Destructor / Initialization
//
// ***************************************************************************


//
//  CreateInstance
//
HRESULT
CPropertyCacheItem::CreateInstance(
    CPropertyCacheItem ** ppItemOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    Assert( NULL != ppItemOut );

    CPropertyCacheItem * pthis = new CPropertyCacheItem;
    if ( NULL != pthis )
    {
        hr = THR( pthis->Init( ) );
        if ( SUCCEEDED( hr ) )
        {
            *ppItemOut = pthis;
        }
        else
        {
            pthis->Destroy( );
        }
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    HRETURN( hr );
}

//
//  Constructor
//
CPropertyCacheItem::CPropertyCacheItem( void )
{
    TraceFunc( "" );

    Assert( NULL == _pNext );

    Assert( FALSE == _fReadOnly );
    Assert( FALSE == _fDirty );
    Assert( IsEqualIID( _fmtid, CLSID_NULL ) );
    Assert( 0 == _propid );
    Assert( VT_EMPTY == _vt );
    Assert( 0 == _uCodePage );
    Assert( VT_EMPTY == _propvar.vt );

    Assert( 0 == _idxDefProp );
    Assert( NULL == _ppui );
    Assert( 0 == _wszTitle[ 0 ] );
    Assert( 0 == _wszDesc[ 0 ] );
    Assert( 0 == _wszValue[ 0 ] );
    Assert( 0 == _wszHelpFile[ 0 ] );
    Assert( NULL == _pDefVals );

    TraceFuncExit( );
}

//
//  Initialization
//
HRESULT
CPropertyCacheItem::Init( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _idxDefProp = -1L;

    HRETURN( hr );
}

//
//  Destructor
//
CPropertyCacheItem::~CPropertyCacheItem( void )
{
    TraceFunc( "" );

    if ( NULL != _ppui )
    {
        _ppui->Release( );
    }

    if ( NULL != _pDefVals )
    {
        for ( ULONG idx = 0; NULL != _pDefVals[ idx ].pszName; idx ++ )
        {
            TraceFree( _pDefVals[ idx ].pszName );
        }
        TraceFree( _pDefVals );
    }

    TraceFuncExit( );
}

//
//  Description:
//      Attempts to destroy the property item.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::Destroy( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    delete this;

    HRETURN( hr );
}


// ***************************************************************************
//
//  Private Methods
//
// ***************************************************************************


//
//  Description:
//      Looks in our "default property list" for a matching fmtid/propid
//      combination and sets _idxDefProp to that index.
//
//  Return Values:
//      S_OK
//          Success!
//
//      HRESULT_FROM_WIN32(ERROR_NOT_FOUND)
//          Entry was not found. _idxDefProp is invalid.
//          
HRESULT
CPropertyCacheItem::FindDefPropertyIndex( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    if ( -1L == _idxDefProp )
    {
        ULONG idx;

        for ( idx = 0; NULL != g_rgDefPropertyItems[ idx ].pFmtID; idx ++ )
        {
            if ( IsEqualPFID( _fmtid, *g_rgDefPropertyItems[ idx ].pFmtID )
              && _propid == g_rgDefPropertyItems[ idx ].propID
               )
            {
                _idxDefProp = idx;
                break;
            }
        }

        if ( -1L == _idxDefProp )
        {
            //  don't wrap.
            hr = HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
        }
    }

    HRETURN( hr );
}

//
//  Description:
//      Check the static member _szMultipleString to make sure it has been
//      loaded.
//
void
CPropertyCacheItem::EnsureMultipleStringLoaded( void )
{
    TraceFunc( "" );

    if ( 0 == _szMultipleString[ 0 ] )
    {
        int iRet = LoadString( g_hInstance, IDS_COMPOSITE_MISMATCH, _szMultipleString, ARRAYSIZE(_szMultipleString) );
        AssertMsg( 0 != iRet, "Missing string resource?" );
    }

    TraceFuncExit( );
}


// ***************************************************************************
//
//  Public Methods
//
// ***************************************************************************


//
//  Description:
//      Stores a IPropetyUI interface to be used for translating the property
//      "properties" into different forms.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetPropertyUIHelper( 
    IPropertyUI * ppuiIn 
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    //
    //  If we have an existing helper, release it.
    //

    if ( NULL != _ppui )
    {
        _ppui->Release( );
    }

    _ppui = ppuiIn;

    if ( NULL != _ppui )
    {
        _ppui->AddRef( );
    }

    HRETURN( hr );
}

//
//  Description:
//      Retrieves a copy (AddRef'ed) of the IPropertyUI interface that this 
//      property item is using.
//
//  Return Values:
//      S_OK
//          Success! pppuiOut is valid.
//
//      S_FALSE
//          Success, but pppuiOut is NULL.
//
//      E_POINTER
//          pppuiOut is NULL.
//
//      other HRESULTs.
//
HRESULT
CPropertyCacheItem::GetPropertyUIHelper( 
    IPropertyUI ** pppuiOut
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    if ( NULL == pppuiOut )
        goto InvalidPointer;

    //
    //  If we have an existing helper, release it.
    //

    if ( NULL == _ppui )
    {
        *pppuiOut = NULL;
        hr = S_FALSE;
    }
    else
    {
        hr = THR( _ppui->TYPESAFEQI( *pppuiOut ) );
    }

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Changes the _pNext member variable
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetNextItem( 
    CPropertyCacheItem * pNextIn 
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _pNext = pNextIn;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the _pNext member variable
//
//  Return Values:
//      S_OK
//          Success!
//
//      S_FALSE
//             
//
//      E_POINTER
//          ppNextOut is NULL.
//
HRESULT
CPropertyCacheItem::GetNextItem( 
    CPropertyCacheItem ** ppNextOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL != ppNextOut )
    {
        *ppNextOut = _pNext;

        if ( NULL == _pNext )
        {
            hr = S_FALSE;
        }
        else
        {
            hr = S_OK;
        }
    }
    else
    {
        hr = THR( E_POINTER );
    }

    HRETURN( hr );
}

//
//  Description:
//      Sets the FMTID of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetFmtId( 
    const FMTID * pFmtIdIn
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _fmtid = *pFmtIdIn;
    _idxDefProp = -1;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the FMTID of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          pfmtidOut is invalid.
//
HRESULT
CPropertyCacheItem::GetFmtId( 
    FMTID * pfmtidOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL != pfmtidOut )
    {
        *pfmtidOut = _fmtid;
        hr = S_OK;
    }
    else
    {
        hr = THR( E_POINTER );
    }

    HRETURN( hr );
}

//
//  Description:
//      Sets the PROPID of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetPropId( 
    PROPID propidIn 
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _propid = propidIn;
    _idxDefProp = -1;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the PROPID of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          ppropidOut is invalid.
//
HRESULT
CPropertyCacheItem::GetPropId( 
    PROPID * ppropidOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppropidOut )
        goto InvalidPointer;

    *ppropidOut = _propid;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Sets the VARTYPE of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetDefaultVarType( 
    VARTYPE vtIn 
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _vt = vtIn;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the VARTYPE of the property.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          pvtOut is invalid.
//
HRESULT
CPropertyCacheItem::GetDefaultVarType( 
    VARTYPE * pvtOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL != pvtOut )
    {
        switch ( _vt )
        {
        case VT_VECTOR | VT_VARIANT:
            Assert( _propvar.capropvar.cElems == 2 );
            *pvtOut = _propvar.capropvar.pElems[ 1 ].vt;
            hr = S_OK;
            break;

        case VT_VECTOR | VT_LPSTR:
            *pvtOut = VT_LPSTR;
            hr = S_OK;
            break;

        case VT_VECTOR | VT_LPWSTR:
            *pvtOut = VT_LPWSTR;
            hr = S_OK;
            break;

        default:
            *pvtOut = _vt;
            hr = S_OK;
            break;
        }
    }
    else
    {
        hr = E_POINTER;
    }

    HRETURN( hr );
}

//
//  Description:
//      Stores the Code Page for the property value.
//
//  Return Values:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::SetCodePage( 
    UINT uCodePageIn 
    )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _uCodePage = uCodePageIn;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the Code Page for the property value.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          puCodePageOut is NULL.
//
HRESULT
CPropertyCacheItem::GetCodePage( 
    UINT * puCodePageOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL != puCodePageOut )
    {
        *puCodePageOut = _uCodePage;
        hr = S_OK;
    }
    else
    {
        hr = THR( E_POINTER );
    }

    HRETURN( hr );
}

//
//  Description:
//      Retrieves the property name for this property to be display in the UI.
//      The pointer handed out does not need to be freed.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          ppwszOut is NULL.
//
//      E_UNEXPECTED
//          Need to call SetPropertyUIHelper( ) before calling this method.
//
//      HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR)
//          The resource string is malformed.
//
//      other HRESULTs
//
HRESULT
CPropertyCacheItem::GetPropertyTitle(
    LPCWSTR * ppwszOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppwszOut )
        goto InvalidPointer;

    *ppwszOut = NULL;

    if ( NULL == _ppui )
        goto UnexpectedState;

    hr = THR( _ppui->GetDisplayName( _fmtid, _propid, PUIFNF_DEFAULT, _wszTitle, ARRAYSIZE(_wszTitle) ) );
    //  Even if this fails, the buffer will still be valid and empty.

    *ppwszOut = _wszTitle;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;

UnexpectedState:
    hr = THR( E_UNEXPECTED );
    goto Cleanup;
}

//
//  Description:
//      Retrieves the property name for this property to be display in the UI.
//      The pointer handed out does not need to be freed.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          ppwszOut is NULL.
//
//      E_UNEXPECTED
//          Need to call SetPropertyUIHelper( ) before calling this method.
//
//      HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR)
//          The resource string is malformed.
//
//      other HRESULTs
//
HRESULT
CPropertyCacheItem::GetPropertyDescription(
    LPCWSTR * ppwszOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppwszOut )
        goto InvalidPointer;

    *ppwszOut = NULL;

    if ( NULL == _ppui )
        goto UnexpectedState;

    hr = THR( _ppui->GetPropertyDescription( _fmtid, _propid, _wszDesc, ARRAYSIZE(_wszDesc) ) );
    // if it failed, the buffer will still be valid and empty.

    *ppwszOut = _wszDesc;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;

UnexpectedState:
    hr = THR( E_UNEXPECTED );
    goto Cleanup;
}

//
//  Description:
//      Retrieves the help information about a property. The pointer handed 
//      out to the help file does not need to be freed.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          ppwszFileOut or puHelpIDOut is NULL.
//
//      E_UNEXPECTED
//          Need to call SetPropertyUIHelper( ) before calling this method.
//
//      other HRESULTs
//
HRESULT
CPropertyCacheItem::GetPropertyHelpInfo( 
      LPCWSTR * ppwszFileOut
    , UINT *   puHelpIDOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if (( NULL == ppwszFileOut ) || ( NULL == puHelpIDOut ))
        goto InvalidPointer;

    *ppwszFileOut = NULL;
    *puHelpIDOut  = 0;

    if ( NULL == _ppui )
        goto UnexpectedState;

    hr = THR( _ppui->GetHelpInfo( _fmtid, _propid, _wszHelpFile, ARRAYSIZE(_wszHelpFile), puHelpIDOut ) );
    if ( FAILED( hr ) )
        goto Cleanup;

    *ppwszFileOut = _wszHelpFile;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;

UnexpectedState:
    hr = THR( E_UNEXPECTED );
    goto Cleanup;
}

//
//  Description:
//      Retrieves a LPWSTR the to a buffer (own by the property) that can
//      used to display the property as a string. The pointer handed out
//      does not need to be freed.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          ppwszOut is NULL.
//
//      E_UNEXPECTED
//          Need to call SetPropertyUIHelper( ) before calling this method.
//
//      other HRESULTs
//
HRESULT
CPropertyCacheItem::GetPropertyStringValue(
      LPCWSTR * ppwszOut
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppwszOut )
        goto InvalidPointer;

    *ppwszOut = NULL;

    if ( NULL == _ppui )
        goto UnexpectedState;

    //
    //  If the property has been marked to indicate multiple values, then
    //  return the "< multiple values >" string.
    //

    if ( _fMultiple )
    {
        EnsureMultipleStringLoaded( );
        *ppwszOut = _szMultipleString;
        hr = S_OK;
        goto Cleanup;
    }

    if ( ( VT_VECTOR | VT_VARIANT ) == _vt )
    {
        Assert( 2 == _propvar.capropvar.cElems );

        hr = THR( _ppui->FormatForDisplay( _fmtid, _propid, &_propvar.capropvar.pElems[ 1 ], PUIFFDF_DEFAULT, _wszValue, ARRAYSIZE(_wszValue) ) );
        if ( FAILED( hr ) )
            goto Cleanup;
    }
    else
    {
        hr = THR( _ppui->FormatForDisplay( _fmtid, _propid, &_propvar, PUIFFDF_DEFAULT, _wszValue, ARRAYSIZE(_wszValue) ) );
        if ( FAILED( hr ) )
            goto Cleanup;
    }

    *ppwszOut = _wszValue;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;

UnexpectedState:
    hr = THR( E_UNEXPECTED );
    goto Cleanup;
}

//
//  Description:
//      Retrieves the Image Index for a property.
//
//  Return Values:
//      S_OK
//          Success!
//
//      E_POINTER
//          piImageOut is NULL.
//
HRESULT
CPropertyCacheItem::GetImageIndex( 
      int * piImageOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == piImageOut )
        goto InvalidPointer;

    //  Initlize to read-only
    *piImageOut = PTI_PROP_READONLY;

    if ( !_fReadOnly )
    {
        //  don't wrap - this can fail
        hr = FindDefPropertyIndex( );
        if ( S_OK == hr )
        {
            if ( !g_rgDefPropertyItems[ _idxDefProp ].fReadOnly )
            {
                *piImageOut = PTI_PROP_READWRITE;
            }
        }
    }

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Retrieves the Property Folder IDentifer (PFID) for this property.
//
//  Return Values:
//      S_OK
//          Success!
//
//      S_FALSE
//          Call succeeded, but there isn't a PFID for this property.
//
//      E_POINTER
//          ppdifOut is NULL.
//
HRESULT
CPropertyCacheItem::GetPFID( 
      const PFID ** ppPFIDOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppPFIDOut )
        goto InvalidPointer;

    *ppPFIDOut = NULL;

    // don't wrap - this can fail.
    hr = FindDefPropertyIndex( );
    if ( S_OK == hr )
    {
        *ppPFIDOut = g_rgDefPropertyItems[ _idxDefProp ].ppfid;
    }
    
    if ( NULL == *ppPFIDOut )
    {
        hr = S_FALSE;
    }

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Retrieves the CLSID of the control to CoCreate( ) to edit this property.
//      The object must support the IEditVariantsInPlace interface. This method
//      will return S_FALSE (pclsidOut will be CLSID_NULL) is the property is
//      read-only.
//
//  Return Values:
//      S_OK
//          Success!
//
//      S_FALSE
//          Success, but the CLSID is CLSID_NULL.
//
//      E_POINTER
//          pclsidOut is NULL.
//
//      other HRESULTs
//
HRESULT
CPropertyCacheItem::GetControlCLSID(
    CLSID * pclsidOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == pclsidOut )
        goto InvalidPointer;

    // don't wrap - this can fail.
    hr = FindDefPropertyIndex( );
    if ( FAILED( hr ) )
        goto Cleanup;

    //
    //  If it is read-only, return S_FALSE and a CLSID of CLSID_NULL.
    //

    if ( g_rgDefPropertyItems[ _idxDefProp ].fReadOnly )
    {
        *pclsidOut = CLSID_NULL;
        hr = S_FALSE;
        goto Cleanup;
    }

    *pclsidOut = *g_rgDefPropertyItems[ _idxDefProp ].pclsidControl;

    if ( CLSID_NULL == *pclsidOut )
    {
        hr = S_FALSE;
    }

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Retrieve the current property value in the form on a variant. If the
//      property is backed by multiple sources, then S_FALSE is returned and
//      the variant is empty.
//
//  Return Value:
//      S_OK
//          Success!
//
//      S_FALSE
//          Multiple value property. Variant is empty.
//
//      E_POINTER
//          ppvarOut is NULL.
//
//      E_FAIL
//          Property is READ-ONLY.
//
//      other HRESULTs.
//
STDMETHODIMP 
CPropertyCacheItem::GetPropertyValue(
    PROPVARIANT ** ppvarOut 
    )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( NULL == ppvarOut )
        goto InvalidPointer;

    *ppvarOut = &_propvar;

    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;
}

//
//  Description:
//      Marks the property as being dirty.
//
//  Return Values:
//      S_OK
//          Success!
//
//      other HRESULTs.
//
STDMETHODIMP 
CPropertyCacheItem::MarkDirty( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _fDirty = TRUE;
    _fMultiple = FALSE;

    HRETURN( hr );
}

//
//  Description:
//      Checks to see if the property has been marked dirty.
//
//  Return Values:
//      S_OK
//          Success and the property is dirty.
//
//      S_FALSE
//          Success and the proprety is clean.
//
STDMETHODIMP 
CPropertyCacheItem::IsDirty( void )
{
    TraceFunc( "" );

    HRESULT hr;

    if ( _fDirty )
    {
        hr = S_OK;
    }
    else
    {
        hr = S_FALSE;
    }

    HRETURN( hr );
}

//
//  Description:
//      Marks the property read-only.
//
//  Return Values:
//      S_OK
//          Success!
//
STDMETHODIMP
CPropertyCacheItem::MarkReadOnly( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _fReadOnly = TRUE;

    HRETURN( hr );
}

//
//  Description:
//      Retrieves an array of pointer to an array of strings that are 
//      zero-indexed. This is used for properties that have well-known
//      enumerated states that are indexed (such as "Status").
//
//  Return Values:
//      S_OK
//          Success!
//
//      S_FALSE
//          Proprety doesn't support enumerated states.
//
//      E_INVALIDARG
//          ppDefValOut is NULL.
//      
//      other HRESULTs.
//
STDMETHODIMP
CPropertyCacheItem::GetStateStrings( 
    DEFVAL ** ppDefValOut
    )
{
    TraceFunc( "" );

    HRESULT hr;
    ULONG   idx;
    ULONG   idxEnd;

    //
    //  Check parameters.
    //

    if ( NULL == ppDefValOut )
        goto InvalidPointer;

    *ppDefValOut = NULL;

    if ( NULL == _ppui )
        goto UnexpectedState;

    // don't wrap - this can fail.
    hr = FindDefPropertyIndex( );
    if ( FAILED( hr ) )
        goto Cleanup;

    if ( !g_rgDefPropertyItems[ _idxDefProp ].fEnumeratedValues )
    {
        hr = S_FALSE;   
        goto Cleanup;
    }

    if ( NULL != _pDefVals )
    {
        *ppDefValOut = _pDefVals;
        hr = S_OK;
        goto Cleanup;
    }

    AssertMsg( NULL != g_rgDefPropertyItems[ _idxDefProp ].pDefVals, "Why did one mark this property as ENUM, but provide no items?" );

    //
    //  Since we moved all the string in SHELL32, we need to use our table
    //  enumerate the property values to retrieve all the strings. Since
    //  our table is read-only, we need to allocate a copy of the DEFVALs
    //  for this property and have PropertyUI fill in the blanks.
    //

    _pDefVals = (DEFVAL *) TraceAlloc( HEAP_ZERO_MEMORY, sizeof(DEFVAL) * g_rgDefPropertyItems[ _idxDefProp ].cDefVals );
    if ( NULL == _pDefVals )
        goto OutOfMemory;

    CopyMemory( _pDefVals, g_rgDefPropertyItems[ _idxDefProp ].pDefVals, sizeof(DEFVAL) * g_rgDefPropertyItems[ _idxDefProp ].cDefVals );

    idxEnd = g_rgDefPropertyItems[ _idxDefProp ].cDefVals - 1;  // the last entry is always { 0, NULL }
    for ( idx = 0; idx < idxEnd; idx ++ )
    {
        PROPVARIANT propvar;

        propvar.vt    = g_rgDefPropertyItems[ _idxDefProp ].vt;
        propvar.ulVal = g_rgDefPropertyItems[ _idxDefProp ].pDefVals[ idx ].ulVal;

        _pDefVals[ idx ].pszName = (LPTSTR) TraceAlloc( HEAP_ZERO_MEMORY, sizeof(_wszValue) );
        if ( NULL == _pDefVals[ idx ].pszName )
            goto OutOfMemory;

        hr = THR( _ppui->FormatForDisplay( _fmtid, _propid, &propvar, PUIFFDF_DEFAULT, _pDefVals[ idx ].pszName, ARRAYSIZE(_wszValue) ) );
        if ( FAILED( hr ) )
            goto Cleanup;
    }

    *ppDefValOut = _pDefVals;
    hr = S_OK;

Cleanup:
    HRETURN( hr );

InvalidPointer:
    hr = THR( E_POINTER );
    goto Cleanup;

OutOfMemory:
    hr = E_OUTOFMEMORY;
    goto Cleanup;

UnexpectedState:
    hr = THR( E_UNEXPECTED );
    goto Cleanup;
}

//
//  Description:
//      Marks a property as having multiple values. This should only be called
//      when multiple source documents have been selected and the values are
//      all different.
//
//  Return Value:
//      S_OK
//          Success!
//
HRESULT
CPropertyCacheItem::MarkMultiple( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    _fMultiple = TRUE;
    PropVariantClear( &_propvar );

    HRETURN( hr );
}