VARIANT类型和值的转换函数-msdn

小灰灰 2022-03-27 09:10 265阅读 0赞

//http://technet.microsoft.com/en-us/subscriptions/aa379016%28v=vs.85%29.aspx
    
    
    /*
    
    Sample has Bug
    pwszChildStorageName[ cchChildStorageName-1 ] = L'\0';
    //Delete
    //--cchChildStorageName;
    
    wcsncpy_s( pwszChildStorageName, cchChildStorageName,
    pwszStorageName, cchChildStorageName );
    //Delete
    //cchChildStorageName -= wcslen(pwszStorageName);
    
    wcsncat_s( pwszChildStorageName, cchChildStorageName,
    L"\\", cchChildStorageName );
    //Delete
    //cchChildStorageName -= 2;
    
    wcsncat_s( pwszChildStorageName, cchChildStorageName,
    statstg.pwcsName, cchChildStorageName );
    
    Reason:Buffer is too small.
    
    */
    
    //+===================================================================
    //
    // To Build:   cl /GX enumall.cpp
    //
    // The following code example dumps all the properties in all property
    // sets of a storage file.
    //
    //+===================================================================
    
    
    #define UNICODE
    #define _UNICODE
    
    #include <stdio.h>
    #include <windows.h>
    
    #pragma comment( lib, "ole32.lib" )
    
    //+-------------------------------------------------------------------
    //
    //  ConvertVarTypeToString
    //  
    //  Generate a string for a given PROPVARIANT variable type (VT). 
    //  For the given vt, write the string to pwszType, which is a buffer
    //  of size cchType characters.
    //
    //+-------------------------------------------------------------------
    
    void
    ConvertVarTypeToString( VARTYPE vt, WCHAR *pwszType, ULONG cchType )
    {
        const WCHAR *pwszModifier;
    
        // Ensure that the output string is terminated
        // (wcsncpy does not guarantee termination)
    
        pwszType[ cchType-1 ] = L'\0';
        --cchType;
    
        // Create a string using the basic type.
    
        switch( vt & VT_TYPEMASK )
        {
        case VT_EMPTY:
            wcsncpy_s( pwszType, cchType, L"VT_EMPTY", cchType );
            break;
        case VT_NULL:
            wcsncpy_s( pwszType, cchType, L"VT_NULL", cchType );
            break;
        case VT_I2:
            wcsncpy_s( pwszType, cchType, L"VT_I2", cchType );
            break;
        case VT_I4:
            wcsncpy_s( pwszType, cchType, L"VT_I4", cchType );
            break;
        case VT_I8:
            wcsncpy_s( pwszType, cchType, L"VT_I8", cchType );
            break;
        case VT_UI2:
            wcsncpy_s( pwszType, cchType, L"VT_UI2", cchType );
            break;
        case VT_UI4:
            wcsncpy_s( pwszType, cchType, L"VT_UI4", cchType );
            break;
        case VT_UI8:
            wcsncpy_s( pwszType, cchType, L"VT_UI8", cchType );
            break;
        case VT_R4:
            wcsncpy_s( pwszType, cchType, L"VT_R4", cchType );
            break;
        case VT_R8:
            wcsncpy_s( pwszType, cchType, L"VT_R8", cchType );
            break;
        case VT_CY:
            wcsncpy_s( pwszType, cchType, L"VT_CY", cchType );
            break;
        case VT_DATE:
            wcsncpy_s( pwszType, cchType, L"VT_DATE", cchType );
            break;
        case VT_BSTR:
            wcsncpy_s( pwszType, cchType, L"VT_BSTR", cchType );
            break;
        case VT_ERROR:
            wcsncpy_s( pwszType, cchType, L"VT_ERROR", cchType );
            break;
        case VT_BOOL:
            wcsncpy_s( pwszType, cchType, L"VT_BOOL", cchType );
            break;
        case VT_VARIANT:
            wcsncpy_s( pwszType, cchType, L"VT_VARIANT", cchType );
            break;
        case VT_DECIMAL:
            wcsncpy_s( pwszType, cchType, L"VT_DECIMAL", cchType );
            break;
        case VT_I1:
            wcsncpy_s( pwszType, cchType, L"VT_I1", cchType );
            break;
        case VT_UI1:
            wcsncpy_s( pwszType, cchType, L"VT_UI1", cchType );
            break;
        case VT_INT:
            wcsncpy_s( pwszType, cchType, L"VT_INT", cchType );
            break;
        case VT_UINT:
            wcsncpy_s( pwszType, cchType, L"VT_UINT", cchType );
            break;
        case VT_VOID:
            wcsncpy_s( pwszType, cchType, L"VT_VOID", cchType );
            break;
        case VT_SAFEARRAY:
            wcsncpy_s( pwszType, cchType, L"VT_SAFEARRAY", cchType );
            break;
        case VT_USERDEFINED:
            wcsncpy_s( pwszType, cchType, L"VT_USERDEFINED", cchType );
            break;
        case VT_LPSTR:
            wcsncpy_s( pwszType, cchType, L"VT_LPSTR", cchType );
            break;
        case VT_LPWSTR:
            wcsncpy_s( pwszType, cchType, L"VT_LPWSTR", cchType );
            break;
        case VT_RECORD:
            wcsncpy_s( pwszType, cchType, L"VT_RECORD", cchType );
            break;
        case VT_FILETIME:
            wcsncpy_s( pwszType, cchType, L"VT_FILETIME", cchType );
            break;
        case VT_BLOB:
            wcsncpy_s( pwszType, cchType, L"VT_BLOB", cchType );
            break;
        case VT_STREAM:
            wcsncpy_s( pwszType, cchType, L"VT_STREAM", cchType );
            break;
        case VT_STORAGE:
            wcsncpy_s( pwszType, cchType, L"VT_STORAGE", cchType );
            break;
        case VT_STREAMED_OBJECT:
            wcsncpy_s( pwszType, cchType, L"VT_STREAMED_OBJECT", cchType );
            break;
        case VT_STORED_OBJECT:
            wcsncpy_s( pwszType, cchType, L"VT_BLOB_OBJECT", cchType );
            break;
        case VT_CF:
            wcsncpy_s( pwszType, cchType, L"VT_CF", cchType );
            break;
        case VT_CLSID:
            wcsncpy_s( pwszType, cchType, L"VT_CLSID", cchType );
            break;
        default:
            _snwprintf_s( pwszType, cchType, cchType, L"Unknown (%d)", 
                        vt & VT_TYPEMASK );
            break;
        }
    
        // Adjust cchType for the added characters.
    
        cchType -= wcslen(pwszType);
    
        // Add the type modifiers, if present.
    
        if( vt & VT_VECTOR )
        {
            pwszModifier = L" | VT_VECTOR";        
            wcsncat_s( pwszType, cchType, pwszModifier, cchType );
            cchType -= wcslen( pwszModifier );
        }
    
        if( vt & VT_ARRAY )
        {
            pwszModifier = L" | VT_ARRAY";        
            wcsncat_s( pwszType, cchType, pwszModifier, cchType );
            cchType -= wcslen( pwszModifier );
        }
    
        if( vt & VT_RESERVED )
        {
            pwszModifier = L" | VT_RESERVED";        
            wcsncat_s( pwszType, cchType, pwszModifier, cchType );
            cchType -= wcslen( pwszModifier );
        }
    
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  ConvertValueToString
    //  
    //  Generate a string for the value in a given PROPVARIANT structure.
    //  The most common types are supported; that is, those that can be
    //  displayed with printf.  For other types, only an ellipses (...) 
    //  is displayed.
    //
    //  The property to create a string from is in propvar, the resulting
    //  string is placed into pwszValue, which is a buffer with space for
    //  cchValue characters (including the string terminator).
    //
    //+-------------------------------------------------------------------
    
    void
    ConvertValueToString( const PROPVARIANT &propvar,
                          WCHAR *pwszValue,
                          ULONG cchValue )
    {
        // Ensure that the output string is terminated
    
        pwszValue[ cchValue - 1 ] = L'\0';
        --cchValue;
    
        // Based on the type, put the value into pwszValue as a string.
    
        switch( propvar.vt )
        {
        case VT_EMPTY:
            wcsncpy_s( pwszValue, cchValue, L"", cchValue );
            break;
        case VT_NULL:
            wcsncpy_s( pwszValue, cchValue, L"", cchValue );
            break;
        case VT_I2:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%i", propvar.iVal );
            break;
        case VT_I4:
        case VT_INT:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%li", propvar.lVal );
            break;
        case VT_I8:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%I64i", propvar.hVal );
            break;
        case VT_UI2:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%u", propvar.uiVal );
            break;
        case VT_UI4:
        case VT_UINT:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%lu", propvar.ulVal );
            break;
        case VT_UI8:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%I64u", propvar.uhVal );
            break;
        case VT_R4:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%f", propvar.fltVal );
            break;
        case VT_R8:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%lf", propvar.dblVal );
            break;
        case VT_BSTR:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"\"%s\"", 
                         propvar.bstrVal );
            break;
        case VT_ERROR:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"0x%08X", propvar.scode );
            break;
        case VT_BOOL:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%s",
                   VARIANT_TRUE == propvar.boolVal ? L"True" : L"False" );
            break;
        case VT_I1:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%i", propvar.cVal );
            break;
        case VT_UI1:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%u", propvar.bVal );
            break;
        case VT_VOID:
            wcsncpy_s( pwszValue, cchValue, L"", cchValue );
            break;
        case VT_LPSTR:
            if( 0 > _snwprintf_s( pwszValue, cchValue, cchValue, 
                                 L"\"%hs\"", propvar.pszVal ))
                // String is too large for pwszValue
                wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
            break;
        case VT_LPWSTR:
            if( 0 > _snwprintf_s( pwszValue, cchValue, cchValue, 
                                 L"\"%s\"", propvar.pwszVal ))
                // String is too large for pwszValue
                wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
            break;
        case VT_FILETIME:
            _snwprintf_s( pwszValue, cchValue, cchValue, L"%08x:%08x",
                         propvar.filetime.dwHighDateTime,
                         propvar.filetime.dwLowDateTime );
            break;
        case VT_CLSID:
            pwszValue[0] = L'\0';
            StringFromGUID2( *propvar.puuid, pwszValue, cchValue );
            break;
        default:
            wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
            break;
        }
    
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  DisplayProperty
    //
    //  Dump the ID, name, type, and value of a property.
    //
    //+-------------------------------------------------------------------
    
    void
    DisplayProperty( const PROPVARIANT &propvar, 
                     const STATPROPSTG &statpropstg )
    {
        WCHAR wsz[ MAX_PATH + 1 ];
    
        ConvertVarTypeToString( statpropstg.vt, wsz, 
                                sizeof(wsz)/sizeof(wsz[0]) );
    
        wprintf( L"   -------------------------------------------------\n"
                 L"   PropID = %-5d VarType = %-23s",
                 statpropstg.propid, wsz );
    
        if( NULL != statpropstg.lpwstrName )
            wprintf( L" Name = %s", statpropstg.lpwstrName );
    
        ConvertValueToString( propvar, wsz, sizeof(wsz)/sizeof(wsz[0]) );
    
        wprintf( L"\n   Value = %s\n", wsz ); 
    
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  DisplayPropertySet
    //
    //  Dump all the properties into a given property set.
    //
    //+-------------------------------------------------------------------
    
    void
    DisplayPropertySet( FMTID fmtid,
                        const WCHAR *pwszStorageName,
                        IPropertyStorage *pPropStg )
    {
        IEnumSTATPROPSTG *penum = NULL;
        HRESULT hr = S_OK;
        STATPROPSTG statpropstg;
        PROPVARIANT propvar;
        PROPSPEC propspec;
        PROPID propid;
        WCHAR *pwszFriendlyName = NULL;
    
        // This string will hold a string-formatted FMTID. It must
        // be 38 characters, plus the terminator character.
        // For best practice, create a moderately longer string.
        WCHAR wszFMTID[ 64 ] = { L"" };
    
        PropVariantInit( &propvar );
        memset( &statpropstg, 0, sizeof(statpropstg) );
    
        try
        {
            // Display the ID of the property set.
    
            StringFromGUID2( fmtid,
                             wszFMTID,
                             sizeof(wszFMTID)/sizeof(wszFMTID[0]) );
            wprintf( L"\n Property Set %s\n", wszFMTID );
    
            // If this is a common property set, display.
    
            if( FMTID_SummaryInformation == fmtid )
             wprintf( L"   (SummaryInformation property set)\n" );
            else if( FMTID_DocSummaryInformation == fmtid )
             wprintf( L"   (DocumentSummaryInformation property set)\n" );
            else if( FMTID_UserDefinedProperties == fmtid )
                wprintf( L"   (UserDefined property set)\n" );
    
            // Also display the name of the storage that contains
            // this property set.
    
            wprintf( L"   in \"%s\":\n", pwszStorageName );
    
            // If this property set has a friendly name, display it now.
            // (Property names are stored in the special dictionary
            // property - the name of the property set is indicated by
            // naming the dictionary property itself.)
    
            propid = PID_DICTIONARY;
            pwszFriendlyName = NULL;
    
            hr = pPropStg->ReadPropertyNames( 1, &propid, 
                                              &pwszFriendlyName );
            if( S_OK == hr )
            {
                wprintf( L"   (Friendly name is \"%s\")\n\n", 
                         pwszFriendlyName );
                CoTaskMemFree( pwszFriendlyName );
                pwszFriendlyName = NULL;
            }
            else
                wprintf( L"\n" );
    
            // Get a property enumerator.
    
            hr = pPropStg->Enum( &penum );
            if( FAILED(hr) ) 
                throw L"Failed IPropertyStorage::Enum";
    
            // Get the first property in the enumeration.
    
            hr = penum->Next( 1, &statpropstg, NULL );
    
            // Loop through and display each property.  The 'Next'
            // call above, and at the bottom of the while loop,
            // will return S_OK if it returns another property,
            // S_FALSE if there are no more properties,
            // and anything else is an error.
    
            while( S_OK == hr )
            {
    
                // Read the property out of the property set
    
                PropVariantInit( &propvar );
                propspec.ulKind = PRSPEC_PROPID;
                propspec.propid = statpropstg.propid;
    
                hr = pPropStg->ReadMultiple( 1, &propspec, &propvar );
                if( FAILED(hr) ) 
                    throw L"Failed IPropertyStorage::ReadMultiple";
    
                // Display the property value, type, and so on.
    
                DisplayProperty( propvar, statpropstg );
    
                // Free buffers allocated during the read, and
                // by the enumerator.
    
                PropVariantClear( &propvar );
                CoTaskMemFree( statpropstg.lpwstrName );
                statpropstg.lpwstrName = NULL;
    
                // Move to the next property in the enumeration
    
                hr = penum->Next( 1, &statpropstg, NULL );
            }
            if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSTG::Next";
        }
        catch( LPCWSTR pwszErrorMessage )
        {
            wprintf( L"Error in DumpPropertySet: %s (hr = %08x)\n",
                     pwszErrorMessage, hr );
        }
    
        if( NULL != penum )
            penum->Release();
    
        if( NULL != statpropstg.lpwstrName )
            CoTaskMemFree( statpropstg.lpwstrName );
    
        PropVariantClear( &propvar );
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  DisplayPropertySetsInStorage
    //
    //  Dump the property sets in the top level of a given storage.
    //
    //+-------------------------------------------------------------------
    
    void
    DisplayPropertySetsInStorage( const WCHAR *pwszStorageName, 
                                  IPropertySetStorage *pPropSetStg )
    {
        IEnumSTATPROPSETSTG *penum = NULL;
        HRESULT hr = S_OK;
        IPropertyStorage *pPropStg = NULL;
        STATPROPSETSTG statpropsetstg;
    
        try
        {
            // Get a property-set enumerator, which only enumerates
            // the property sets at this level of the storage, not 
            // its child objects.
    
            hr = pPropSetStg->Enum( &penum );
            if( FAILED(hr) ) 
                throw L"failed IPropertySetStorage::Enum";
    
            // Get the first property set in the enumeration.
            // (The field used to open the property set is
            // statpropsetstg.fmtid.
    
            memset( &statpropsetstg, 0, sizeof(statpropsetstg) );
            hr = penum->Next( 1, &statpropsetstg, NULL );
    
            // Loop through all the property sets.
    
            while( S_OK == hr )
            {
                // Open the property set.
    
                hr = pPropSetStg->Open( statpropsetstg.fmtid,
                                        STGM_READ | STGM_SHARE_EXCLUSIVE,
                                        &pPropStg );
                if( FAILED(hr) ) 
                    throw L"failed IPropertySetStorage::Open";
    
                // Display the properties in the property set.
    
                DisplayPropertySet( statpropsetstg.fmtid,
                                    pwszStorageName,
                                    pPropStg );
    
                pPropStg->Release();
                pPropStg = NULL;
    
                // Get the FMTID of the next property set in the
                // enumeration.
    
                hr = penum->Next( 1, &statpropsetstg, NULL );
    
            }
            if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSETSTG::Next";
    
            // Special-case handling for the UserDefined property set:
            // This property set actually lives inside the well-known
            // DocumentSummaryInformation property set. It is the only
            // property set which is allowed to live inside another
            // (and exists for legacy compatibility).  It does not get
            // included in a normal enumeration, so verify that it is
            // done explicitly. Look for it when the end of the
            // enumerator is reached.
    
            hr = pPropSetStg->Open( FMTID_UserDefinedProperties,
                                    STGM_READ | STGM_SHARE_EXCLUSIVE,
                                    &pPropStg );
            if( SUCCEEDED(hr) )
            {
                DisplayPropertySet( FMTID_UserDefinedProperties,
                                    pwszStorageName,
                                    pPropStg );
                pPropStg->Release();
                                        pPropStg = NULL;
            }
    
        }
        catch( LPCWSTR pwszErrorMessage )
        {
            wprintf( L"Error in DumpPropertySetsInStorage: 
                     %s (hr = %08x)\n",
                     pwszErrorMessage, hr );
        }
    
        if( NULL != pPropStg )
            pPropStg->Release();
        if( NULL != penum )
            penum->Release();
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  DisplayStorageTree
    //
    //  Dump all the property sets in the given storage and recursively in
    //  all its child objects.
    //
    //+-------------------------------------------------------------------
    
    void
    DisplayStorageTree( const WCHAR *pwszStorageName, IStorage *pStg )
    {
        IPropertySetStorage *pPropSetStg = NULL;
        IStorage *pStgChild = NULL;
        WCHAR *pwszChildStorageName = NULL;
        IEnumSTATSTG *penum = NULL;
        HRESULT hr = S_OK;
        STATSTG statstg;
    
        memset( &statstg, 0, sizeof(statstg) );
    
        try
        {
            // Dump the property sets at this storage level
    
            hr = pStg->QueryInterface( IID_IPropertySetStorage,
                                 reinterpret_cast<void**>(&pPropSetStg) );
            if( FAILED(hr) )
              throw 
              L"Failed IStorage::QueryInterface(IID_IPropertySetStorage)";
    
            DisplayPropertySetsInStorage( pwszStorageName, pPropSetStg );
    
            // Get an enumerator for this storage.
    
            hr = pStg->EnumElements( NULL, NULL, NULL, &penum );
            if( FAILED(hr) ) throw L"failed IStorage::Enum";
    
            // Get the name of the first element (stream/storage)
            // in the enumeration.  As usual, 'Next' will return
            // S_OK if it returns an element of the enumerator,
            // S_FALSE if there are no more elements, and an
            // error otherwise.
    
            hr = penum->Next( 1, &statstg, 0 );
    
            // Loop through all the child objects of this storage.
    
            while( S_OK == hr )
            {
                // Verify that this is a storage that is not a property
                // set, because the property sets are displayed above).
                // If the first character of its name is the '\005'
                // reserved character, it is a stream /storage property
                // set.
    
                if( STGTY_STORAGE == statstg.type
                    &&
                    L'\005' != statstg.pwcsName[0] )
                {
                    // Indicates normal storage, not a propset.
                    // Open the storage.
    
                    ULONG cchChildStorageName;
    
                    hr = pStg->OpenStorage( statstg.pwcsName,
                                         NULL,
                                         STGM_READ | STGM_SHARE_EXCLUSIVE,
                                         NULL, 0,
                                         &pStgChild );
                    if( FAILED(hr) ) 
                        throw L"failed IStorage::OpenStorage";
    
                    // Compose a name of the form 
                    // "Storage\ChildStorage\..." for display purposes.
                    // First, allocate it.
    
                    cchChildStorageName = wcslen(pwszStorageName)
                                            + wcslen(statstg.pwcsName)
                                            + 2  // For two "\" chars
                                            + 1; // For string terminator
    
                    pwszChildStorageName = 
                                      new WCHAR[ cchChildStorageName ];
                    if( NULL == pwszChildStorageName )
                    {
                        hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
                        throw L"couldn't allocate memory";
                    }
    
                    // Terminate the name.
    
                    pwszChildStorageName[ cchChildStorageName-1 ] = L'\0';
                    --cchChildStorageName;
    
                    // Build the name.
    
                    wcsncpy_s( pwszChildStorageName, cchChildStorageName,
                             pwszStorageName, cchChildStorageName );
                    cchChildStorageName -= wcslen(pwszStorageName);
    
                    wcsncat_s( pwszChildStorageName, cchChildStorageName,
                             L"\\", cchChildStorageName );
                    cchChildStorageName -= 2;
    
                    wcsncat_s( pwszChildStorageName, cchChildStorageName,
                             statstg.pwcsName, cchChildStorageName );
    
                    // Dump all property sets under this child storage.
    
                    DisplayStorageTree( pwszChildStorageName, pStgChild );
    
                    pStgChild->Release();
                    pStgChild = NULL;
    
                    delete[] pwszChildStorageName;
                    pwszChildStorageName = NULL;
                }
    
                // Move to the next element in the enumeration of 
                // this storage.
    
                CoTaskMemFree( statstg.pwcsName );
                statstg.pwcsName = NULL;
    
                hr = penum->Next( 1, &statstg, 0 );
            }
            if( FAILED(hr) ) throw L"failed IEnumSTATSTG::Next";
        }
        catch( LPCWSTR pwszErrorMessage )
        {
            wprintf( L"Error in DumpStorageTree: %s (hr = %08x)\n",
                     pwszErrorMessage, hr );
        }
    
        // Cleanup before returning.
    
        if( NULL != statstg.pwcsName )
            CoTaskMemFree( statstg.pwcsName );
        if( NULL != pStgChild )
            pStgChild->Release();
        if( NULL != pStg )
            pStg->Release();
        if( NULL != penum )
            penum->Release();
        if( NULL != pwszChildStorageName )
            delete[] pwszChildStorageName;
        
    }
    
    
    //+-------------------------------------------------------------------
    //
    //  wmain
    //
    //  Dump all the property sets in a file which is a storage.
    //
    //+-------------------------------------------------------------------
    
    extern "C" void wmain( int cArgs, WCHAR *rgwszArgs[] )
    {
        HRESULT hr = S_OK;
        IStorage *pStg = NULL;
    
        // Display usage information if necessary.
    
        if( 1 == cArgs
            ||
            0 == wcscmp( L"-?", rgwszArgs[1] )
            ||
            0 == wcscmp( L"/?", rgwszArgs[1] ))
        {
            printf( "\n"
                    "Purpose:  Enumerate all properties in all\n"
                    "          property sets for a storage file\n"
                    "Usage:    PropDump <filename>\n"
                    "E.g.:     PropDump word.doc\n"
                    "\n" );
            exit(0);
        }
    
        // Open the root storage.
    
        hr = StgOpenStorageEx( rgwszArgs[1],
                               STGM_READ | STGM_SHARE_DENY_WRITE,
                               STGFMT_ANY,
                               0,
                               NULL,
                               NULL,
                               IID_IStorage,
                               reinterpret_cast<void**>(&pStg) );
    
        // Dump all the properties in all the property sets within this
        // storage.
    
        if( FAILED(hr) )
        {
            wprintf( L"Error: couldn't open storage \"%s\" 
                     (hr = %08x)\n",
                     rgwszArgs[1], hr );
        }
        else
        {
            printf( "\nDisplaying all property sets ...\n" );
            DisplayStorageTree( rgwszArgs[1], pStg );
            pStg->Release();
        }
    
    
    }