Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
propvar.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 65k
Category:

Windows Kernel

Development Platform:

Visual C++

propvar.cpp：Code Content
  1. //-------------------------------------------------------------------------//
  2. //
  3. //  PropVar.cpp
  4. //
  5. //-------------------------------------------------------------------------//
  6. #include "pch.h"
  7. #include <stdio.h>
  8. #include "propVar.h"
  10. //-------------------------------------------------------------------------//
  11. static LPCWSTR clipformats[] = 
  12. {
  13.     L"CF_TEXT",           // 1
  14.     L"CF_BITMAP",         // 2
  15.     L"CF_METAFILEPICT",   // 3
  16.     L"CF_SYLK",           // 4
  17.     L"CF_DIF",            // 5
  18.     L"CF_TIFF",           // 6
  19.     L"CF_OEMTEXT",        // 7
  20.     L"CF_DIB",            // 8
  21.     L"CF_PALETTE",        // 9
  22.     L"CF_PENDATA",        // 10
  23.     L"CF_RIFF",           // 11
  24.     L"CF_WAVE",           // 12
  25.     L"CF_UNICODETEXT",    // 13
  26.     L"CF_ENHMETAFILE",    // 14
  27.     L"CF_HDROP",          // 15
  28.     L"CF_LOCALE",         // 16
  29. } ;
  30. #define NUM_CLIPFORMATS sizeof(clipformats)/sizeof(LPCWSTR)
  32. //-------------------------------------------------------------------------//
  33. //  Global PROPVARARIANT utility functions
  34. //-------------------------------------------------------------------------//
  36. //-------------------------------------------------------------------------//
  37. //  Determins the size of the data contained by a PROPVARIANT instance.
  38. //  The returned value does not included the size of the PROPVARIANT structure
  39. //  itself.
  40. HRESULT PropVariantSize( 
  41.     IN const PROPVARIANT& var, 
  42.     OUT ULONG& cbDataSize, 
  43.     OUT OPTIONAL PROPVARIANT_ALLOCTYPE* pdwAllocType )
  44. {
  45.     HRESULT hr = S_OK ;
  46.     ULONG   i ;
  47.     
  48.     cbDataSize  = 0 ;
  49.     
  50.     PROPVARIANT_ALLOCTYPE dwAllocType ;
  51.     if( !pdwAllocType ) pdwAllocType = &dwAllocType ;
  52.     *pdwAllocType = PVAT_NOALLOC ;
  54.     #define PROPVARIANT_VECTOR_SIZE( member ) 
  55.             (sizeof(var.member) + (var.member.cElems * sizeof(*var.member.pElems)))
  56.     
  57.     switch( var.vt )
  58.     {
  59.         case VT_EMPTY:
  60.         case VT_NULL:
  61.         case VT_ILLEGAL:
  62.             break ;
  63.                         
  64.         case VT_UI1:
  65.             cbDataSize = sizeof(var.bVal) ;
  66.             break ;
  68.         case VT_I2:
  69.             cbDataSize = sizeof(var.iVal) ;
  70.             break ;
  72.         case VT_UI2:
  73.             cbDataSize = sizeof(var.uiVal) ;
  74.             break ;
  75.             
  76.         case VT_BOOL:
  77.             cbDataSize = sizeof(var.boolVal) ;
  78.             break ;
  80.         case VT_I4:
  81.             cbDataSize = sizeof(var.lVal) ;
  82.             break ;
  83.  
  84.         case VT_UI4:
  85.             cbDataSize = sizeof(var.ulVal) ;
  86.             break ;
  88.         case VT_R4:
  89.             cbDataSize = sizeof(var.fltVal) ;
  90.             break ;
  92.         case VT_ERROR:
  93.             cbDataSize = sizeof(var.scode) ;
  94.             break ;
  96.         case VT_I8:
  97.             cbDataSize = sizeof(var.hVal) ;
  98.             break ;
  100.         case VT_UI8:
  101.             cbDataSize = sizeof(var.uhVal) ;
  103.         case VT_R8:
  104.             cbDataSize = sizeof(var.dblVal) ;
  105.             break ;
  107.         case VT_CY:
  108.             cbDataSize = sizeof(var.cyVal) ;
  109.             break ;
  111.         case VT_DATE:
  112.             cbDataSize = sizeof(var.date) ;
  113.             break ;
  115.         case VT_FILETIME:
  116.             cbDataSize = sizeof(var.filetime) ;
  117.             break ;
  118.         
  119.         case VT_CLSID:
  120.             cbDataSize = var.puuid ? sizeof(*var.puuid) : 0 ;
  121.             *pdwAllocType = PVAT_SYSALLOC ;
  122.             break ;
  124.         case VT_BLOB:
  125.             cbDataSize = sizeof(BLOB) + var.blob.cbSize ;
  126.             *pdwAllocType = PVAT_COMPLEX ;
  127.             break ;
  129.         case VT_CF :
  130.             cbDataSize = var.pclipdata ? sizeof(CLIPDATA) + CBPCLIPDATA( *var.pclipdata ) : 0 ;
  131.             *pdwAllocType = PVAT_COMPLEX ;
  132.             break ;
  134.         case VT_BSTR:
  135.             cbDataSize  = var.bstrVal ? (lstrlenW( var.bstrVal ) + 1) * sizeof(WCHAR) : 0 ;
  136.             *pdwAllocType = PVAT_STRINGALLOC ;
  137.             break ;
  139.         case VT_LPSTR:
  140.             cbDataSize  = var.pszVal ? (lstrlenA( var.pszVal ) + 1) * sizeof(CHAR) : 0 ;
  141.             *pdwAllocType = PVAT_SYSALLOC ;
  142.             break ;
  143.             
  144.         case VT_LPWSTR:
  145.             cbDataSize  = var.pwszVal ? (lstrlenW( var.pwszVal ) + 1) * sizeof(WCHAR) : 0 ;
  146.             *pdwAllocType = PVAT_SYSALLOC ;
  147.             break ;
  149.         case VT_VECTOR | VT_UI1:
  150.             cbDataSize = PROPVARIANT_VECTOR_SIZE( caub ) ;
  151.             *pdwAllocType = PVAT_COMPLEX ;
  152.             break ;
  154.         case VT_VECTOR | VT_I2:
  155.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cai ) ;
  156.             *pdwAllocType = PVAT_COMPLEX ;
  157.             break ;
  159.         case VT_VECTOR | VT_UI2:
  160.             cbDataSize = PROPVARIANT_VECTOR_SIZE( caui ) ;
  161.             *pdwAllocType = PVAT_COMPLEX ;
  162.             break ;
  164.         case VT_VECTOR | VT_I4:
  165.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cal ) ;
  166.             *pdwAllocType = PVAT_COMPLEX ;
  167.             break ;
  169.         case VT_VECTOR | VT_UI4:
  170.             cbDataSize = PROPVARIANT_VECTOR_SIZE( caul ) ;
  171.             *pdwAllocType = PVAT_COMPLEX ;
  172.             break ;
  174.         case VT_VECTOR | VT_I8:
  175.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cah ) ;
  176.             *pdwAllocType = PVAT_COMPLEX ;
  177.             break ;
  179.         case VT_VECTOR | VT_UI8:
  180.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cauh ) ;
  181.             *pdwAllocType = PVAT_COMPLEX ;
  182.             break ;
  184.         case VT_VECTOR | VT_R4:
  185.             cbDataSize = PROPVARIANT_VECTOR_SIZE( caflt ) ;
  186.             *pdwAllocType = PVAT_COMPLEX ;
  187.             break ;
  189.         case VT_VECTOR | VT_R8:
  190.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cadbl ) ;
  191.             *pdwAllocType = PVAT_COMPLEX ;
  192.             break ;
  194.         case VT_VECTOR | VT_CY:
  195.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cacy ) ;
  196.             *pdwAllocType = PVAT_COMPLEX ;
  197.             break ;
  199.         case VT_VECTOR | VT_DATE:
  200.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cadate ) ;
  201.             *pdwAllocType = PVAT_COMPLEX ;
  202.             break ;
  204.         case VT_VECTOR | VT_BOOL:
  205.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cabool ) ;
  206.             *pdwAllocType = PVAT_COMPLEX ;
  207.             break ;
  209.         case VT_VECTOR | VT_ERROR:
  210.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cascode ) ;
  211.             *pdwAllocType = PVAT_COMPLEX ;
  212.             break ;
  214.         case VT_VECTOR | VT_FILETIME:
  215.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cafiletime ) ;
  216.             *pdwAllocType = PVAT_COMPLEX ;
  217.             break ;
  219.         case VT_VECTOR | VT_CLSID:
  220.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cauuid ) ;
  221.             *pdwAllocType = PVAT_COMPLEX ;
  222.             break ;
  224.         case VT_VECTOR | VT_BSTR:
  225.             cbDataSize = PROPVARIANT_VECTOR_SIZE( cabstr ) ;
  226.             for( i=0; i < var.cabstr.cElems; i++ )
  227.                 cbDataSize += ((var.cabstr.pElems[i]==NULL) ? lstrlenW( var.cabstr.pElems[i] ) + 1 : 0) ;
  228.             *pdwAllocType = PVAT_COMPLEX ;
  229.             break ;
  231.         case VT_VECTOR | VT_LPSTR:
  232.             cbDataSize = PROPVARIANT_VECTOR_SIZE( calpstr ) ;
  233.             for( i=0; i < var.calpstr.cElems; i++ )
  234.                 cbDataSize += ((var.calpstr.pElems[i]==NULL) ? lstrlenA( var.calpstr.pElems[i] ) + 1 : 0) ;
  235.             *pdwAllocType = PVAT_COMPLEX ;
  236.             break ;
  238.         case VT_VECTOR | VT_LPWSTR:
  239.             cbDataSize = PROPVARIANT_VECTOR_SIZE( calpwstr ) ;
  240.             for( i=0; i < var.calpwstr.cElems; i++ )
  241.                 cbDataSize += ((var.calpwstr.pElems[i]==NULL) ? lstrlenW( var.calpwstr.pElems[i] ) + 1 : 0) ;
  242.             *pdwAllocType = PVAT_COMPLEX ;
  243.             break ;
  245.         case VT_VECTOR | VT_CF:
  246.             //caclipdata; 
  247.         case VT_VECTOR | VT_VARIANT:
  248.             //capropvar;  
  249.             *pdwAllocType = PVAT_COMPLEX ;
  250.             hr = E_NOTIMPL ;
  251.             break ;
  253.         case VT_STREAM:
  254.         case VT_STORAGE:
  255.             *pdwAllocType = PVAT_SYSALLOC ;
  256.             hr = E_NOTIMPL ;
  257.             break ;
  259.         default:
  260.             return E_UNEXPECTED ;
  261.     }
  263.     return hr ;
  264. }
  266. //-------------------------------------------------------------------------//
  267. //  Writes the data contained by a PROPVARIANT instance to single, contiguous 
  268. //  memory buffer.
  269. HRESULT PropVariantWriteMem( IN const PROPVARIANT& var, OUT BYTE* pBuf, IN ULONG cbBuf )
  270. {
  271.     HRESULT hr ;
  272.     
  273.     #define PROPVARIANT_TYPECAST_COPY( buf, cbBuf, type, member ) 
  274.                 { if( cbBuf < sizeof(type) ) return E_OUTOFMEMORY ; 
  275.                   (*((type*)buf)) = var.member ; 
  276.                   buf   += sizeof(var.member) ; 
  277.                   cbBuf -= sizeof(var.member) ; } 
  279.     ULONG   cbDataSize = 0, 
  280.             cb ;            // scratch
  281.     
  282.     if( !SUCCEEDED( (hr = PropVariantSize( var, cbDataSize, NULL )) ) )
  283.         return hr ;
  285.     //  Ensure cbBuf is large enough to contain the data
  286.     if( cbDataSize + sizeof(VARTYPE) > cbBuf )
  287.     {
  288.         ASSERT( FALSE ) ;
  289.         return E_OUTOFMEMORY ;
  290.     }
  292.     //  Copy vartype
  293.     PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, VARTYPE, vt ) ;
  294.     hr = S_OK ;
  295.     
  296.     switch( var.vt )
  297.     {
  298.         case VT_EMPTY:
  299.         case VT_NULL:
  300.         case VT_ILLEGAL:
  301.             break ;
  302.                         
  303.         case VT_UI1:
  304.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, UCHAR, bVal ) ;
  305.             break ;
  307.         case VT_I2:
  308.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, SHORT, iVal ) ;
  309.             break ;
  311.         case VT_UI2:
  312.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, USHORT, uiVal ) ;
  313.             break ;
  314.             
  315.         case VT_BOOL:
  316.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, VARIANT_BOOL, boolVal ) ;
  317.             break ;
  319.         case VT_I4:
  320.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, long, lVal) ;
  321.             break ;
  322.  
  323.         case VT_UI4:
  324.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, ULONG, ulVal) ;
  325.             break ;
  327.         case VT_R4:
  328.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, float, fltVal) ;
  329.             break ;
  331.         case VT_ERROR:
  332.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, SCODE, scode) ;
  333.             break ;
  335.         case VT_I8:
  336.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, LARGE_INTEGER, hVal) ;
  337.             break ;
  339.         case VT_UI8:
  340.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, ULARGE_INTEGER, uhVal) ;
  342.         case VT_R8:
  343.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, double, dblVal) ;
  344.             break ;
  346.         case VT_CY:
  347.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, CY, cyVal) ;
  348.             break ;
  350.         case VT_DATE:
  351.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, DATE, date) ;
  352.             break ;
  354.         case VT_FILETIME:
  355.             PROPVARIANT_TYPECAST_COPY( pBuf, cbBuf, FILETIME, filetime) ;
  356.             break ;
  357.         
  358.         case VT_CLSID:
  359.             cbBuf = min( cbBuf, sizeof(*var.puuid) ) ;
  360.             memcpy( pBuf, var.puuid, cbBuf ) ;
  361.             break ;
  363.         case VT_BSTR:
  364.             cb = min( cbBuf-1, lstrlenW( var.bstrVal )*sizeof(WCHAR) ) ;
  365.             lstrcpynW( (WCHAR*)pBuf, var.bstrVal, cb+1 ) ;
  366.             cbBuf -= (cb + 1) ;
  367.             break ;
  369.         case VT_LPSTR:
  370.             cb = min( cbBuf-1, lstrlenA( var.pszVal )*sizeof(CHAR) ) ;
  371.             lstrcpynA( (CHAR*)pBuf, var.pszVal, cb+1 ) ;
  372.             cbBuf -= (cb + 1) ;
  373.             break ;
  374.             
  375.         case VT_LPWSTR:
  376.             cb = min( cbBuf-1, lstrlenW( var.pwszVal )*sizeof(WCHAR) ) ;
  377.             lstrcpynW( (WCHAR*)pBuf, var.pwszVal, cb+1 ) ;
  378.             cbBuf -= (cb + 1) ;
  379.             break ;
  381.         case VT_BLOB:
  382.         case VT_CF :
  383.         case VT_VECTOR | VT_UI1:
  384.         case VT_VECTOR | VT_I2:
  385.         case VT_VECTOR | VT_UI2:
  386.         case VT_VECTOR | VT_I4:
  387.         case VT_VECTOR | VT_UI4:
  388.         case VT_VECTOR | VT_I8:
  389.         case VT_VECTOR | VT_UI8:
  390.         case VT_VECTOR | VT_R4:
  391.         case VT_VECTOR | VT_R8:
  392.         case VT_VECTOR | VT_CY:
  393.         case VT_VECTOR | VT_DATE:
  394.         case VT_VECTOR | VT_BOOL:
  395.         case VT_VECTOR | VT_ERROR:
  396.         case VT_VECTOR | VT_FILETIME:
  397.         case VT_VECTOR | VT_BSTR:
  398.         case VT_VECTOR | VT_LPSTR:
  399.         case VT_VECTOR | VT_LPWSTR:
  400.         case VT_VECTOR | VT_CLSID:
  401.         case VT_VECTOR | VT_CF:
  402.         case VT_VECTOR | VT_VARIANT:
  403.         case VT_STREAM:
  404.         case VT_STORAGE:
  405.             hr = E_NOTIMPL ;
  406.             break ;
  408.         default:
  409.             hr = E_UNEXPECTED ;
  410.     }
  412.     return hr ;
  413. }
  415. //-------------------------------------------------------------------------//
  416. //  Reads the data contained by a PROPVARIANT instance to single, contiguous 
  417. //  memory buffer.
  418. HRESULT PropVariantReadMem( IN BYTE* pBuf, OUT PROPVARIANT& var )
  419. {
  420.     HRESULT     hr = S_OK ;
  421.     PROPVARIANT varTmp ;
  422.     
  423.     PropVariantInit( &var ) ;
  424.     PropVariantInit( &varTmp ) ;
  426.     if( !pBuf ) return E_POINTER ;
  428.     #define PROPVARIANT_TYPECAST_ASSIGN( buf, type, val ) 
  429.         { varTmp.val = *((type*)buf) ; buf += sizeof(type) ; }
  431.     //  Determine type
  432.     PROPVARIANT_TYPECAST_ASSIGN( pBuf, VARTYPE, vt ) ;
  434.     switch( varTmp.vt )
  435.     {
  436.         case VT_EMPTY:
  437.         case VT_NULL:
  438.         case VT_ILLEGAL:
  439.             break ;
  440.                         
  441.         case VT_UI1:
  442.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, UCHAR, bVal ) ;
  443.             break ;
  445.         case VT_I2:
  446.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, SHORT, iVal ) ;
  447.             break ;
  449.         case VT_UI2:
  450.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, USHORT, uiVal ) ;
  451.             break ;
  452.             
  453.         case VT_BOOL:
  454.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, VARIANT_BOOL, boolVal ) ;
  455.             break ;
  457.         case VT_I4:
  458.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, long, lVal) ;
  459.             break ;
  460.  
  461.         case VT_UI4:
  462.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, ULONG, ulVal) ;
  463.             break ;
  465.         case VT_R4:
  466.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, float, fltVal) ;
  467.             break ;
  469.         case VT_ERROR:
  470.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, SCODE, scode) ;
  471.             break ;
  473.         case VT_I8:
  474.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, LARGE_INTEGER, hVal) ;
  475.             break ;
  477.         case VT_UI8:
  478.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, ULARGE_INTEGER, uhVal) ;
  480.         case VT_R8:
  481.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, double, dblVal) ;
  482.             break ;
  484.         case VT_CY:
  485.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, CY, cyVal) ;
  486.             break ;
  488.         case VT_DATE:
  489.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, DATE, date) ;
  490.             break ;
  492.         case VT_FILETIME:
  493.             PROPVARIANT_TYPECAST_ASSIGN( pBuf, FILETIME, filetime) ;
  494.             break ;
  495.         
  496.         case VT_CLSID:
  497.             varTmp.puuid = (CLSID*)pBuf ;
  498.             break ;
  500.         case VT_BSTR:
  501.             varTmp.bstrVal = (BSTR)pBuf ;
  502.             break ;
  504.         case VT_LPSTR:
  505.             varTmp.pszVal = (LPSTR)pBuf ;
  506.             break ;
  507.             
  508.         case VT_LPWSTR:
  509.             varTmp.pwszVal = (LPWSTR)pBuf ;
  510.             break ;
  512.         case VT_BLOB:
  513.         case VT_CF :
  514.         case VT_VECTOR | VT_UI1:
  515.         case VT_VECTOR | VT_I2:
  516.         case VT_VECTOR | VT_UI2:
  517.         case VT_VECTOR | VT_I4:
  518.         case VT_VECTOR | VT_UI4:
  519.         case VT_VECTOR | VT_I8:
  520.         case VT_VECTOR | VT_UI8:
  521.         case VT_VECTOR | VT_R4:
  522.         case VT_VECTOR | VT_R8:
  523.         case VT_VECTOR | VT_CY:
  524.         case VT_VECTOR | VT_DATE:
  525.         case VT_VECTOR | VT_BOOL:
  526.         case VT_VECTOR | VT_ERROR:
  527.         case VT_VECTOR | VT_FILETIME:
  528.         case VT_VECTOR | VT_BSTR:
  529.         case VT_VECTOR | VT_LPSTR:
  530.         case VT_VECTOR | VT_LPWSTR:
  531.         case VT_VECTOR | VT_CLSID:
  532.         case VT_VECTOR | VT_CF:
  533.         case VT_VECTOR | VT_VARIANT:
  534.         case VT_STREAM:
  535.         case VT_STORAGE:
  536.             hr = E_NOTIMPL ;
  537.             break ;
  539.         default:
  540.             hr = E_UNEXPECTED ;
  541.     }
  543.     if( SUCCEEDED( hr ) )
  544.         ::PropVariantCopy( &var, &varTmp ) ;
  546.     return hr ;
  547. }
  549. //-------------------------------------------------------------------------//
  550. HRESULT PropVariantToBstr( const PROPVARIANT* pvar, UINT nCodePage, ULONG dwFlags, LPCTSTR pszFmt, OUT BSTR* pbstrText )
  551. {
  552.     ASSERT( pvar ) ;
  553.     ASSERT( pbstrText ) ;
  555.     HRESULT     hr = E_FAIL ;
  556.     LCID        lcid = GetUserDefaultLCID() ;
  557.     const DWORD cchNumBuf   = 32 ;
  558.     
  559.     UNREFERENCED_PARAMETER( pszFmt ) ;
  560.     USES_CONVERSION ;
  562.     *pbstrText = NULL ;
  564.     switch( pvar->vt )
  565.     {
  566.         case VT_EMPTY:
  567.         case VT_NULL:
  568.         case VT_ILLEGAL:
  569.             *pbstrText = SysAllocString( L"" ) ;
  570.             return S_OK ;   // return blank
  572.         case VT_UI1:
  573.             return VarBstrFromUI1( pvar->bVal, lcid, dwFlags, pbstrText ) ;
  575.         case VT_I2:
  576.             return VarBstrFromI2( pvar->iVal, lcid, dwFlags, pbstrText ) ;
  578.         case VT_UI2:
  579.             return VarBstrFromUI2(  pvar->uiVal, lcid, dwFlags, pbstrText );
  580.             
  581.         case VT_BOOL:
  582.             return VarBstrFromBool( pvar->boolVal, lcid, dwFlags, pbstrText ) ;
  584.         case VT_I4:
  585.             return VarBstrFromI4( pvar->lVal, lcid, dwFlags, pbstrText ) ;
  586.  
  587.         case VT_UI4:
  588.             return VarBstrFromUI4( pvar->ulVal, lcid, dwFlags, pbstrText );
  590.         case VT_R4:
  591.             return VarBstrFromR4( pvar->fltVal, lcid, dwFlags, pbstrText ) ;
  593.         case VT_ERROR:
  594.             return VarBstrFromUI4( pvar->scode, lcid, dwFlags, pbstrText );
  596.         case VT_I8:
  597.         case VT_UI8:
  598.             if( (*pbstrText = SysAllocStringLen( NULL, cchNumBuf ))!=NULL )
  599.             {
  600.                 if( pvar->vt==VT_I8 ? _i64tow( pvar->hVal.QuadPart, *pbstrText, 10 )!=NULL :
  601.                                     _ui64tow( pvar->hVal.QuadPart, *pbstrText, 10 )!=NULL )
  602.                     return TRUE ;
  603.                 SysFreeString( *pbstrText ) ;
  604.                 *pbstrText = NULL ;
  605.             }
  606.             break ; 
  608.         case VT_R8:
  609.             return VarBstrFromR8( pvar->dblVal, lcid, dwFlags, pbstrText ) ;
  611.         case VT_CY:
  612.             return VarBstrFromCy( pvar->cyVal, lcid, dwFlags , pbstrText ) ;
  614.         case VT_DATE:
  615.             return VarBstrFromDate( pvar->date, lcid, VAR_DATEVALUEONLY, pbstrText ) ;
  617.         case VT_FILETIME:
  618.         {
  619.             SYSTEMTIME  st ;
  620.             DATE        d ;
  622.             if( pvar->filetime.dwLowDateTime == 0L &&
  623.                 pvar->filetime.dwHighDateTime ==0L )
  624.             {
  625.                 *pbstrText = SysAllocString( L"" ) ;
  626.                 return S_OK ;
  627.             }
  629.             if( FileTimeToSystemTime( &pvar->filetime, &st ) &&
  630.                 SystemTimeToVariantTime( &st, &d ) )
  631.             {
  632.                 return VarBstrFromDate( d, lcid, VAR_DATEVALUEONLY, pbstrText ) ;
  633.             }
  634.             break ;
  635.         }
  636.         
  637.         case VT_CLSID:
  638.             if( pvar->puuid )
  639.             {
  640.                 LPWSTR pwsz = NULL ;
  641.                 //  Note: we can't hand back this directly, because the
  642.                 //  caller expects a BSTR that should be freed with SysFreeString.
  643.                 if( SUCCEEDED( (hr = StringFromCLSID( *pvar->puuid, &pwsz )) ) )
  644.                 {
  645.                     *pbstrText = SysAllocString( pwsz ) ;
  646.                     CoTaskMemFree( pwsz ) ; // free intermediate buffer.
  647.                     if( *pbstrText ) 
  648.                         return S_OK ;
  649.                     break ;
  650.                 }
  651.             }
  652.             else
  653.             {
  654.                 if( (*pbstrText = SysAllocString( L"" ))!=NULL )
  655.                     return S_OK ;
  656.             }
  657.             break ;
  659.         case VT_BLOB:
  660.             if( pvar->blob.pBlobData != NULL )
  661.                 *pbstrText = SysAllocString( L"..." ) ;
  662.             else
  663.                 *pbstrText = SysAllocString( L"" ) ;
  664.             return S_OK ;
  666.         case VT_CF :
  667.         {
  668.             long cf = 0 ;
  669.             
  670.             if( pvar->pclipdata ) 
  671.                 cf = pvar->pclipdata->ulClipFmt ;
  672.             if( cf > 0 )
  673.             {
  674.                 if( (*pbstrText = SysAllocString( clipformats[cf-1] ))!=NULL )
  675.                     return S_OK ;
  676.             }
  677.             break ;
  678.         }
  680.         case VT_BSTR:
  681.             if( (*pbstrText = SysAllocString( pvar->bstrVal ? pvar->bstrVal : L"" ))!=NULL )
  682.                 return S_OK ;
  683.             break ;
  685.         case VT_LPSTR:
  686.             if( (*pbstrText = SysAllocString( pvar->pszVal ? A2W( pvar->pszVal ) : L"" )) != NULL )
  687.                 return S_OK ;
  688.             break ;
  689.             
  690.         case VT_LPWSTR:
  691.             if( (*pbstrText = SysAllocString( pvar->pwszVal ? pvar->pwszVal : L"" )) != NULL )
  692.                 return S_OK ;
  693.             break ;
  695.         case VT_VECTOR | VT_UI1:
  696.             //pvar->caub;     
  697.         case VT_VECTOR | VT_I2:
  698.             //pvar->cai;      
  699.         case VT_VECTOR | VT_UI2:
  700.             //pvar->caui;     
  701.         case VT_VECTOR | VT_I4:
  702.             //pvar->cal;      
  703.         case VT_VECTOR | VT_UI4:
  704.             //pvar->caul;     
  705.         case VT_VECTOR | VT_I8:
  706.             //pvar->cah;      
  707.         case VT_VECTOR | VT_UI8:
  708.             //pvar->cauh;     
  709.         case VT_VECTOR | VT_R4:
  710.             //pvar->caflt;    
  711.         case VT_VECTOR | VT_R8:
  712.             //pvar->cadbl;    
  713.         case VT_VECTOR | VT_CY:
  714.             //pvar->cacy;     
  715.         case VT_VECTOR | VT_DATE:
  716.             //pvar->cadate;   
  717.         case VT_VECTOR | VT_BSTR:
  718.             //pvar->cabstr;   
  719.         case VT_VECTOR | VT_BOOL:
  720.             //pvar->cabool;   
  721.         case VT_VECTOR | VT_ERROR:
  722.             //pvar->cascode;  
  723.         case VT_VECTOR | VT_LPSTR:
  724.             //pvar->calpstr;  
  725.         case VT_VECTOR | VT_LPWSTR:
  726.             //pvar->calpwstr; 
  727.         case VT_VECTOR | VT_FILETIME:
  728.             //pvar->cafiletime; 
  729.         case VT_VECTOR | VT_CLSID:
  730.             //pvar->cauuid;     
  731.         case VT_VECTOR | VT_CF:
  732.             //pvar->caclipdata; 
  733.         case VT_VECTOR | VT_VARIANT:
  734.             //pvar->capropvar;  
  735.             return E_NOTIMPL ;
  737.         //  Unsupported types
  738.         case VT_STREAM:
  739.         case VT_STORAGE:
  740.             return E_NOTIMPL ;
  742.         //  Illegal types for OLE properties
  743.         default:
  744.             return ERROR_INVALID_DATA ;
  745.     }
  747.     return hr ;
  748. }
  750. //-------------------------------------------------------------------------//
  751. HRESULT PropVariantToString( const PROPVARIANT* pvar, UINT nCodePage, ULONG dwFlags, LPCTSTR pszFmt, OUT LPTSTR pszText, IN ULONG cchTextMax )
  752. {
  753.     BSTR    bstrText = NULL ;
  754.     HRESULT hr = PropVariantToBstr( pvar, nCodePage, dwFlags, pszFmt, &bstrText ) ;
  756.     if( SUCCEEDED( hr ) )
  757.     {
  758.         lstrcpyn( pszText, W2T( bstrText ), cchTextMax ) ;
  759.         SysFreeString( bstrText ) ;
  760.     }
  761.     return hr ;
  762. }
  764. //-------------------------------------------------------------------------//
  765. HRESULT PropVariantFromBstr( 
  766.     IN const BSTR bstrText, 
  767.     IN UINT nCodePage, 
  768.     IN ULONG dwFlags, 
  769.     IN LPCTSTR pszFmt, 
  770.     OUT PROPVARIANT* pvar )
  771. {
  772.     UNREFERENCED_PARAMETER( pszFmt ) ;
  773.     ASSERT( pvar ) ;
  775.     HRESULT     hr = E_FAIL ;
  776.     LCID        lcid = GetUserDefaultLCID() ;
  777.     VARTYPE     vtSave = pvar->vt ;
  779.     if( !( bstrText && *bstrText ) )
  780.     {
  781.         //  We're being passed an empty string, so simply zero out
  782.         //  and restore the current VARTYPE.
  783.         PropVariantClear( pvar ) ;
  784.         pvar->vt = vtSave ;
  785.         return S_OK ;
  786.     }
  787.     
  788.     USES_CONVERSION ;
  790.     switch( vtSave )
  791.     {
  792.         case VT_EMPTY:
  793.         case VT_NULL:
  794.         case VT_ILLEGAL:
  795.             // Clear ourselves always.
  796.             PropVariantClear( pvar ) ;
  797.             pvar->vt = vtSave ;
  798.             return S_OK ;   
  800.         case VT_UI1:
  801.             hr = VarUI1FromStr( bstrText, lcid, dwFlags, &pvar->bVal ) ;
  802.             break ;
  804.         case VT_I2:
  805.             hr = VarI2FromStr( bstrText, lcid, dwFlags, &pvar->iVal ) ;
  806.             break ;
  808.         case VT_UI2:
  809.             hr = VarUI2FromStr(  bstrText, lcid, dwFlags, &pvar->uiVal ) ;
  810.             break ;
  811.             
  812.         case VT_BOOL:
  813.             hr = VarBoolFromStr( bstrText, lcid, dwFlags, &pvar->boolVal ) ;
  814.             break ;
  816.         case VT_I4:
  817.             hr = VarI4FromStr( bstrText, lcid, dwFlags, &pvar->lVal ) ;
  818.             break ;
  819.  
  820.         case VT_UI4:
  821.             hr = VarUI4FromStr(  bstrText, lcid, dwFlags, &pvar->ulVal ) ;
  822.             {
  823.             }
  824.             break ;
  826.         case VT_R4:
  827.             if( SUCCEEDED( (hr = VarR4FromStr( bstrText, lcid, dwFlags, &pvar->fltVal )) ) )
  828.             {
  829.             }
  830.             break ;
  832.         case VT_ERROR:
  833.             if( SUCCEEDED( (hr = VarI4FromStr( bstrText, lcid, dwFlags, &pvar->scode )) ) )
  834.             {
  835.             }
  836.             break ;
  838.         //case VT_I8:
  839.         //    return _i64tot( hVal.QuadPart, pszBuf, 10 ) ; 
  841.         //case VT_UI8:
  842.         //    return _ui64tot( hVal.QuadPart, pszBuf, 10 ) ; 
  844.         case VT_R8:
  845.             if( SUCCEEDED( (hr = VarR8FromStr( bstrText, lcid, dwFlags, &pvar->dblVal )) ) )
  846.             {
  847.             }
  848.             break ;
  850.         case VT_CY:
  851.             if( SUCCEEDED( (hr = VarCyFromStr( bstrText, lcid, dwFlags , &pvar->cyVal )) ) )
  852.             {
  853.             }
  854.             break ;
  856.         case VT_DATE:
  857.             if( SUCCEEDED( (hr = VarDateFromStr( bstrText, lcid, VAR_DATEVALUEONLY, &pvar->date )) ) )
  858.             {
  859.             }
  860.             break ;
  862.         case VT_FILETIME:
  863.         {
  864.             FILETIME    ft ;
  865.             SYSTEMTIME  st ;
  866.             DATE        d ;
  868.             if( bstrText && *bstrText )
  869.             {
  870.                 if( SUCCEEDED( (hr = VarDateFromStr( bstrText, lcid, VAR_DATEVALUEONLY, &d )) ) &&
  871.                     VariantTimeToSystemTime( d, &st ) &&
  872.                     SystemTimeToFileTime( &st, &ft ) )
  873.                 {
  874.                     pvar->filetime = ft ;
  875.                     return S_OK ;
  876.                 }
  877.             }
  878.             else
  879.             {
  880.                 memset( &pvar->filetime, 0, sizeof(pvar->filetime) ) ;
  881.                 return S_OK ;
  882.             }
  883.             break ;
  884.         }
  885.         
  886.         case VT_CLSID:
  887.             {
  888.                 CLSID clsid ;
  889.                 if( SUCCEEDED( (hr = CLSIDFromString( bstrText, &clsid )) ) )
  890.                 {
  891.                     PropVariantClear( pvar ) ;
  892.                     if( NULL == (pvar->puuid = (CLSID*)CoTaskMemAlloc( sizeof(clsid) )) )
  893.                         return E_OUTOFMEMORY ;
  894.                     *pvar->puuid = clsid ;
  895.                     pvar->vt = vtSave ;
  896.                     return S_OK ;
  897.                 }
  898.             }
  899.             break ;
  901.         case VT_BSTR:
  902.             PropVariantClear( pvar ) ;
  903.             pvar->bstrVal = SysAllocString( bstrText ) ;
  904.             pvar->vt = vtSave ;
  905.             return S_OK ;
  907.         case VT_LPSTR:
  908.         {
  909.             PropVariantClear( pvar ) ;
  910.             int cb = sizeof(CHAR) * (lstrlenA( W2A(bstrText) ) + 1) ;
  911.             if( NULL == (pvar->pszVal = (LPSTR)CoTaskMemAlloc( cb )) )
  912.                 return E_OUTOFMEMORY ;
  914.             memcpy( pvar->pszVal, W2A( bstrText ), cb ) ;
  915.             pvar->vt = vtSave ;
  916.             return S_OK ;
  917.         }
  918.             
  919.         case VT_LPWSTR:
  920.         {
  921.             PropVariantClear( pvar ) ;
  922.             int cb = sizeof(WCHAR) * (lstrlenW( bstrText ) + 1) ;
  923.             if( NULL == (pvar->pwszVal = (LPWSTR)CoTaskMemAlloc( cb )) )
  924.                 return E_OUTOFMEMORY ;
  926.             memcpy( pvar->pwszVal, bstrText, cb ) ;
  927.             pvar->vt = vtSave ;
  928.             return S_OK ;
  929.         }
  931.         case VT_VECTOR | VT_UI1:
  932.             //pvar->caub;     
  933.         case VT_VECTOR | VT_I2:
  934.             //pvar->cai;      
  935.         case VT_VECTOR | VT_UI2:
  936.             //pvar->caui;     
  937.         case VT_VECTOR | VT_I4:
  938.             //pvar->cal;      
  939.         case VT_VECTOR | VT_UI4:
  940.             //pvar->caul;     
  941.         case VT_VECTOR | VT_I8:
  942.             //pvar->cah;      
  943.         case VT_VECTOR | VT_UI8:
  944.             //pvar->cauh;     
  945.         case VT_VECTOR | VT_R4:
  946.             //pvar->caflt;    
  947.         case VT_VECTOR | VT_R8:
  948.             //pvar->cadbl;    
  949.         case VT_VECTOR | VT_CY:
  950.             //pvar->cacy;     
  951.         case VT_VECTOR | VT_DATE:
  952.             //pvar->cadate;   
  953.         case VT_VECTOR | VT_BSTR:
  954.             //pvar->cabstr;   
  955.         case VT_VECTOR | VT_BOOL:
  956.             //pvar->cabool;   
  957.         case VT_VECTOR | VT_ERROR:
  958.             //pvar->cascode;  
  959.         case VT_VECTOR | VT_LPSTR:
  960.             //pvar->calpstr;  
  961.         case VT_VECTOR | VT_LPWSTR:
  962.             //pvar->calpwstr; 
  963.         case VT_VECTOR | VT_FILETIME:
  964.             //pvar->cafiletime; 
  965.         case VT_VECTOR | VT_CLSID:
  966.             //pvar->cauuid;     
  967.         case VT_VECTOR | VT_CF:
  968.             //pvar->caclipdata; 
  969.         case VT_VECTOR | VT_VARIANT:
  970.             //pvar->capropvar;  
  971.             return E_NOTIMPL ;
  973.         //  Illegal types for which to assign value from display text.
  974.         case VT_BLOB:
  975.         case VT_CF :
  976.         case VT_STREAM:
  977.         case VT_STORAGE:
  978.             return E_INVALIDARG ;
  980.         //  Illegal types for OLE properties
  981.         default:
  982.             return ERROR_INVALID_DATA ;
  983.     }
  985.     return hr ;
  986. }
  988. //-------------------------------------------------------------------------//
  989. HRESULT PropVariantFromString( 
  990.     IN LPCTSTR pszText, 
  991.     IN UINT nCodePage, 
  992.     IN ULONG dwFlags, 
  993.     IN LPCTSTR pszFmt, 
  994.     OUT PROPVARIANT* pvar )
  995. {
  996.     HRESULT hr = E_FAIL ;
  997.     BSTR    bstrText = NULL ;
  998.     USES_CONVERSION ; 
  1000.     if( pszText )
  1001.         if( (bstrText = SysAllocString( T2W( (LPTSTR)pszText ) )) == NULL )
  1002.             return E_OUTOFMEMORY ;
  1004.     hr = PropVariantFromBstr( bstrText, nCodePage, dwFlags, pszFmt, pvar ) ;
  1005.     
  1006.     if( bstrText )
  1007.         SysFreeString( bstrText ) ;
  1008.     return hr ;
  1009. }
  1011. //-------------------------------------------------------------------------//
  1012. //  Generates a 32-bit hash value for the contents of a PROPVARIANT instance.
  1013. HRESULT PropVariantHash( IN const PROPVARIANT& var, OUT ULONG& dwHash )
  1014. {
  1015.     HRESULT     hr ;
  1016.     ULONG       cbVar = 0 ;
  1017.     const BYTE* pVar = NULL ;
  1018.     
  1019.     dwHash = var.vt ;
  1021.     if( !SUCCEEDED( (hr = PropVariantSize( var, cbVar, NULL )) ) )
  1022.         return hr ;
  1024.     switch( var.vt )
  1025.     {
  1026.         case VT_EMPTY:
  1027.         case VT_NULL:
  1028.         case VT_ILLEGAL:
  1029.             break ;
  1031.         case VT_I1:
  1032.         case VT_UI1:
  1033.         case VT_I2:
  1034.         case VT_UI2:
  1035.         case VT_I4:
  1036.         case VT_UI4:
  1037.         case VT_I8:
  1038.         case VT_UI8:
  1039.         case VT_R4:
  1040.         case VT_R8:
  1041.         case VT_CY:
  1042.         case VT_DATE:
  1043.         case VT_ERROR:
  1044.         case VT_BOOL:
  1045.         case VT_INT:
  1046.         case VT_FILETIME:
  1047.             pVar = &var.bVal ; break ;
  1049.         case VT_BSTR:
  1050.             pVar = (const BYTE*)var.bstrVal ;  break ;
  1051.         case VT_CLSID:
  1052.             pVar = (const BYTE*)var.puuid ;    break ;
  1053.         case VT_LPSTR:
  1054.             pVar = (const BYTE*)var.pszVal ;   break ;
  1055.         case VT_LPWSTR:
  1056.             pVar = (const BYTE*)var.pwszVal ;  break ;
  1058.         case VT_CF:
  1059.         case VT_BLOB:
  1060.         case VT_DISPATCH:
  1061.         case VT_STREAM:
  1062.         case VT_STORAGE:
  1063.         case VT_STREAMED_OBJECT:
  1064.         case VT_STORED_OBJECT:
  1065.         case VT_BLOB_OBJECT:
  1067.         case VT_VECTOR | VT_UI1:
  1068.             //CAUB caub;
  1069.         case VT_VECTOR | VT_I2:
  1070.             //CAI cai;
  1071.         case VT_VECTOR | VT_UI2:
  1072.             //CAUI caui;
  1073.         case VT_VECTOR | VT_BOOL:
  1074.             //CABOOL cabool;
  1075.         case VT_VECTOR | VT_I4:
  1076.             //CAL cal;
  1077.         case VT_VECTOR | VT_UI4:
  1078.             //CAUL caul;
  1079.         case VT_VECTOR | VT_R4:
  1080.             //CAFLT caflt;
  1081.         case VT_VECTOR | VT_ERROR:
  1082.             //CASCODE cascode;
  1083.         case VT_VECTOR | VT_I8:
  1084.             //CAH cah;
  1085.         case VT_VECTOR | VT_UI8:
  1086.             //CAUH cauh;
  1087.         case VT_VECTOR | VT_R8:
  1088.             //CADBL cadbl;
  1089.         case VT_VECTOR | VT_CY:
  1090.             //CACY cacy;
  1091.         case VT_VECTOR | VT_DATE:
  1092.             //CADATE cadate;
  1093.         case VT_VECTOR | VT_FILETIME:
  1094.             //CAFILETIME cafiletime;
  1095.         case VT_VECTOR | VT_CLSID:
  1096.             //CACLSID cauuid;
  1098.         case VT_VECTOR | VT_BSTR:
  1099.             //CABSTR cabstr;
  1100.         case VT_VECTOR | VT_LPSTR:
  1101.             //CALPSTR calpstr;
  1102.         case VT_VECTOR | VT_LPWSTR:
  1103.             //CALPWSTR calpwstr;
  1104.         case VT_VECTOR | VT_CF:
  1105.             //CACLIPDATA caclipdata;
  1106.         case VT_VECTOR | VT_BLOB:
  1107.             //CABSTRBLOB cabstrblob;
  1108.         //case VT_VECTOR | :
  1109.             //CAPROPVARIANT capropvar;
  1110.             return E_NOTIMPL ;
  1111.     }
  1112.     
  1113.     if( pVar )
  1114.     {
  1115.         for( ULONG i=0; i<cbVar; i++ )
  1116.             dwHash += pVar[i] ;
  1117.     }
  1118.     return S_OK ;
  1119. }
  1121. //-------------------------------------------------------------------------//
  1122. //  Writes the value of a PROPVARIANT to the registry
  1123. HRESULT PropVariantWriteRegistry( HKEY hKey, LPCTSTR pszValueName, IN const PROPVARIANT& var )
  1124. {
  1125.     HRESULT  hr ;
  1126.     DWORD    cbVal = 0 ;
  1127.     LPBYTE   pBuf = NULL ;
  1128.     
  1129.     //  Determine size of data
  1130.     if( !SUCCEEDED( (hr = ::PropVariantSize( var, cbVal, NULL )) ) )
  1131.         return hr ;
  1133.     //  Allocate buffer
  1134.     cbVal += sizeof(VARTYPE) ;
  1135.     if( (pBuf = new BYTE[cbVal])==NULL )
  1136.         return E_OUTOFMEMORY ;
  1137.     memset( pBuf, 0, cbVal ) ;
  1139.     //  Copy to contiguous memory, write to registry.
  1140.     if( SUCCEEDED( (hr = PropVariantWriteMem( var, pBuf, cbVal )) ) )
  1141.     {
  1142.         hr = HRESULT_FROM_WIN32( RegSetValueEx( hKey, pszValueName, 0L, REG_BINARY, 
  1143.                                  pBuf, cbVal ) ) ;
  1144.     }
  1146.     delete [] pBuf ;
  1147.     return hr ;
  1148. }
  1150. //-------------------------------------------------------------------------//
  1151. //  Reads the value of a PROPVARIANT from the registry
  1152. HRESULT PropVariantReadRegistry( HKEY hKey, LPCTSTR pszValueName, OUT PROPVARIANT& var )
  1153. {
  1154.     HRESULT hr ;
  1155.     ULONG   dwErr ;
  1156.     DWORD dwType = REG_BINARY,
  1157.           cbVal = sizeof(var.vt) ;
  1159.     PropVariantInit( &var ) ;
  1161.     dwErr = RegQueryValueEx( hKey, pszValueName, 0L, &dwType, (LPBYTE)&var.vt, &cbVal ) ;
  1163.     if( !SUCCEEDED( (hr = HRESULT_FROM_WIN32( dwErr )) ) )
  1164.     {
  1165.         if( dwErr == ERROR_MORE_DATA )
  1166.         {
  1167.             LPBYTE pBuf = NULL ;
  1168.             if( (pBuf = new BYTE[cbVal+1])==NULL )
  1169.                 return E_OUTOFMEMORY ;
  1171.             dwErr = RegQueryValueEx( hKey, pszValueName, 0L, &dwType, pBuf, &cbVal ) ;
  1172.             if( SUCCEEDED( (hr = HRESULT_FROM_WIN32( dwErr )) ) )
  1173.                 hr = PropVariantReadMem( pBuf, var ) ;
  1175.             delete [] pBuf ;
  1176.         }
  1177. #ifdef TRACE
  1178.         else
  1179.         {
  1180.             TRACE( TEXT("Failed to read PROPVARIANT (VARTYPE %d) from registry (%ld)n"), var.vt, dwErr ) ;
  1181.         }
  1182. #endif TRACE
  1183.     }
  1184.     return hr ;
  1185. }                           
  1187. //-------------------------------------------------------------------------//
  1188. //  Comparison helpers
  1189. #define NUMERIC_COMPARE( a, b )      (((a)>(b)) ? 1 : ((a)<(b)) ? -1 : 0)
  1190. #define POINTER_COMPARE( a, b, cb )  (((a)&&(b)) ? memcmp( (a), (b), (cb) ) : 
  1191.                                       (a) ? 1 : (b) ? -1 : 0)
  1193. inline int TEXT_COMPAREW( LPWSTR psz1, LPWSTR psz2, ULONG uFlags )
  1194. {
  1195.     if( psz1 && psz2 )
  1196.         return (uFlags & PVCF_IGNORECASE) ? lstrcmpiW( psz1, psz2 ) :
  1197.                                             lstrcmpW( psz1, psz2 );
  1198.                          
  1199.     else if( psz1 && *psz1 )
  1200.         return 1 ;
  1201.     else if( psz2 && *psz2 )
  1202.         return -1 ;
  1203.     return 0 ;
  1204. }
  1206. inline int TEXT_COMPAREA( LPSTR psz1, LPSTR psz2, ULONG uFlags )
  1207. {
  1208.     if( psz1 && psz2 )
  1209.         return (uFlags & PVCF_IGNORECASE) ? lstrcmpiA( psz1, psz2 ) :
  1210.                                             lstrcmpA( psz1, psz2 ) ;    
  1211.     else if( psz1 && *psz1 )
  1212.         return 1 ;
  1213.     else if( psz2 && *psz2 )
  1214.         return -1 ;
  1215.     return 0 ;
  1216. }
  1218. int DATETIME_COMPARE( const SYSTEMTIME* pst1, const SYSTEMTIME* pst2, ULONG uFlags )
  1219. {
  1220.     int nRet = 0;
  1222.     if( uFlags & PVCF_IGNOREDATE )
  1223.     {
  1224.         if( (nRet = NUMERIC_COMPARE( pst1->wHour, pst2->wHour )) != 0 )
  1225.             if( (nRet = NUMERIC_COMPARE( pst1->wMinute, pst2->wMinute )) == 0 )
  1226.                 if( (nRet = NUMERIC_COMPARE( pst1->wSecond, pst2->wSecond )) == 0 )
  1227.                     nRet = NUMERIC_COMPARE( pst1->wMilliseconds, pst2->wMilliseconds );
  1228.     }
  1229.     else if( uFlags & PVCF_IGNORETIME )
  1230.     {
  1231.         if( (nRet = NUMERIC_COMPARE( pst1->wYear, pst2->wYear )) == 0 )
  1232.             if( (nRet = NUMERIC_COMPARE( pst1->wMonth, pst2->wMonth )) == 0 )
  1233.                 nRet = NUMERIC_COMPARE( pst1->wDay, pst2->wDay );
  1234.     }
  1235.     else
  1236.     {
  1237.         nRet = memcmp( pst1, pst2, sizeof(*pst1) );
  1238.     }
  1240.     return nRet;
  1241. }
  1243. //-------------------------------------------------------------------------//
  1244. //  Compares the values of two PROPVARIANT instances; returns -1 if var1 is 
  1245. //  less than var2, 1 if va1 is greater than var2, and 0 if the two values
  1246. //  are equal.
  1247. int PropVariantCompare( const PROPVARIANT& var1, const PROPVARIANT& var2, ULONG uFlags )
  1248. {
  1249.     int iRet = 0 ;
  1250.     
  1251.     //  Compare VARTYPE.
  1252.     if( var1.vt != var2.vt ) 
  1253.         return NUMERIC_COMPARE( var1.vt, var2.vt ) ;
  1255.     //  Compare data
  1256.     switch( var1.vt )
  1257.     {
  1258.         case VT_EMPTY:
  1259.         case VT_NULL:
  1260.         case VT_ILLEGAL:
  1261.             return 0 ;
  1263.         case VT_UI1:
  1264.             return NUMERIC_COMPARE( var1.bVal, var2.bVal ) ;
  1266.         case VT_I2:
  1267.             return NUMERIC_COMPARE( var1.iVal, var2.iVal ) ;
  1269.         case VT_UI2:
  1270.             return NUMERIC_COMPARE( var1.uiVal, var2.uiVal );
  1271.             
  1272.         case VT_BOOL:
  1273.             return NUMERIC_COMPARE( var1.boolVal, var2.boolVal ) ;
  1275.         case VT_I4:
  1276.             return NUMERIC_COMPARE( var1.lVal, var2.lVal ) ;
  1277.  
  1278.         case VT_UI4:
  1279.             return NUMERIC_COMPARE( var1.ulVal, var2.ulVal );
  1281.         case VT_R4:
  1282.             return NUMERIC_COMPARE( var1.fltVal, var2.fltVal ) ;
  1284.         case VT_ERROR:
  1285.             return NUMERIC_COMPARE( var1.scode, var2.scode );
  1287.         case VT_I8:
  1288.             return NUMERIC_COMPARE( var1.hVal.QuadPart, var2.hVal.QuadPart ) ;
  1290.         case VT_UI8:
  1291.             return NUMERIC_COMPARE( var1.uhVal.QuadPart, var2.uhVal.QuadPart ) ;
  1293.         case VT_R8:
  1294.             return NUMERIC_COMPARE( var1.dblVal, var2.dblVal ) ;
  1296.         case VT_CY:
  1297.             return memcmp( &var1.cyVal, &var2.cyVal, sizeof(CY) ) ;
  1299.         case VT_DATE:
  1300.         {
  1301.             if( 0 == (uFlags & (PVCF_IGNOREDATE|PVCF_IGNORETIME)) )
  1302.                 return NUMERIC_COMPARE( var1.date, var2.date ) ;
  1304.             SYSTEMTIME st1, st2;
  1305.             VariantTimeToSystemTime( var1.date, &st1 );
  1306.             VariantTimeToSystemTime( var2.date, &st2 );
  1307.             return DATETIME_COMPARE( &st1, &st2, uFlags );
  1308.         }
  1310.         case VT_FILETIME:
  1311.         {
  1312.             if( 0 == (uFlags & (PVCF_IGNOREDATE|PVCF_IGNORETIME)) )
  1313.                 return memcmp( &var1.filetime, &var2.filetime, sizeof(FILETIME) ) ;
  1315.             SYSTEMTIME st1, st2;
  1316.             FileTimeToSystemTime( &var1.filetime, &st1 );
  1317.             FileTimeToSystemTime( &var2.filetime, &st2 );
  1319.             return DATETIME_COMPARE( &st1, &st2, uFlags );
  1320.         }
  1321.         
  1322.         case VT_CLSID:
  1323.             return POINTER_COMPARE( var1.puuid, var2.puuid, sizeof(CLSID) ) ;
  1325.         case VT_BLOB:
  1326.             if( (iRet = POINTER_COMPARE( var1.blob.pBlobData, var2.blob.pBlobData,
  1327.                                         min( var1.blob.cbSize, var2.blob.cbSize ) ))==0 )
  1328.                 iRet = NUMERIC_COMPARE( var1.blob.cbSize, var2.blob.cbSize ) ;
  1329.             return iRet ;
  1331.         case VT_CF :
  1332.             if( (iRet = NUMERIC_COMPARE( (DWORD_PTR)var1.pclipdata, (DWORD_PTR)var2.pclipdata ))==0 &&
  1333.                 var1.pclipdata && var2.pclipdata &&
  1334.                 (iRet = NUMERIC_COMPARE( var1.pclipdata->ulClipFmt, var2.pclipdata->ulClipFmt ))==0 &&
  1335.                 (iRet = POINTER_COMPARE( var1.pclipdata->pClipData, var2.pclipdata->pClipData,
  1336.                                          min( var1.pclipdata->cbSize, var2.pclipdata->cbSize ) ))==0 )
  1337.             {                
  1338.                 iRet = NUMERIC_COMPARE( var1.pclipdata->cbSize, var2.pclipdata->cbSize ) ;
  1339.             }
  1340.             return iRet ;
  1342.         case VT_BSTR:
  1343.             return TEXT_COMPAREW( var1.bstrVal, var2.bstrVal, uFlags ) ;
  1345.         case VT_LPSTR:
  1346.             return TEXT_COMPAREA( var1.pszVal, var2.pszVal, uFlags ) ;
  1347.             
  1348.         case VT_LPWSTR:
  1349.             return TEXT_COMPAREW( var1.pwszVal, var2.pwszVal, uFlags ) ;
  1351.         case VT_VECTOR | VT_UI1:
  1352.             //caub;     
  1353.         case VT_VECTOR | VT_I2:
  1354.             //cai;      
  1355.         case VT_VECTOR | VT_UI2:
  1356.             //caui;     
  1357.         case VT_VECTOR | VT_I4:
  1358.             //cal;      
  1359.         case VT_VECTOR | VT_UI4:
  1360.             //caul;     
  1361.         case VT_VECTOR | VT_I8:
  1362.             //cah;      
  1363.         case VT_VECTOR | VT_UI8:
  1364.             //cauh;     
  1365.         case VT_VECTOR | VT_R4:
  1366.             //caflt;    
  1367.         case VT_VECTOR | VT_R8:
  1368.             //cadbl;    
  1369.         case VT_VECTOR | VT_CY:
  1370.             //cacy;     
  1371.         case VT_VECTOR | VT_DATE:
  1372.             //cadate;   
  1373.         case VT_VECTOR | VT_BSTR:
  1374.             //cabstr;   
  1375.         case VT_VECTOR | VT_BOOL:
  1376.             //cabool;   
  1377.         case VT_VECTOR | VT_ERROR:
  1378.             //cascode;  
  1379.         case VT_VECTOR | VT_LPSTR:
  1380.             //calpstr;  
  1381.         case VT_VECTOR | VT_LPWSTR:
  1382.             //calpwstr; 
  1383.         case VT_VECTOR | VT_FILETIME:
  1384.             //cafiletime; 
  1385.         case VT_VECTOR | VT_CLSID:
  1386.             //cauuid;     
  1387.         case VT_VECTOR | VT_CF:
  1388.             //caclipdata; 
  1389.         case VT_VECTOR | VT_VARIANT:
  1390.             //capropvar;  
  1391.             break ;  //BUGBUG: Need to implement comparisons of these types.
  1393.         case VT_STREAM:
  1394.         case VT_STORAGE:
  1395.             break ;  //BUGBUG: Need to implement comparisons of these types.
  1396.     }
  1398.     return iRet ;
  1399. }
  1401. //-------------------------------------------------------------------------//
  1402. // A PROPVARIANT can hold a few more types than a VARIANT can.  We convert the types that are
  1403. // only supported by a PROPVARIANT into equivalent VARIANT types.
  1404. HRESULT PropVariantToVariant( IN const PROPVARIANT *pPropVar, OUT VARIANT *pVar)
  1405. {
  1406.     HRESULT hr = E_FAIL ;
  1407.     ASSERT(pPropVar && pVar);
  1409.     // if pVar isn't empty, this will properly free before overwriting it
  1410.     VariantClear(pVar);
  1412.     switch(pPropVar->vt)
  1413.     {
  1414.         case VT_LPSTR: 
  1415.         {
  1416.             int len = lstrlenA(pPropVar->pszVal);
  1417.             pVar->bstrVal = SysAllocStringLen(NULL, len);
  1418.             if (pVar->bstrVal)
  1419.             {
  1420.                 pVar->vt = VT_BSTR;
  1421.                 MultiByteToWideChar(CP_ACP, 0, pPropVar->pszVal, len, pVar->bstrVal, len);
  1422.                 hr = S_OK ;
  1423.             }
  1425.             break;
  1426.         }
  1428.         case VT_LPWSTR:
  1429.             pVar->bstrVal = SysAllocString(pPropVar->pwszVal);
  1430.             if (pVar->bstrVal)
  1431.             {
  1432.                 pVar->vt = VT_BSTR;
  1433.                 hr = S_OK ;
  1434.             }
  1435.             break;
  1437.         case VT_FILETIME:
  1438.         {
  1439.             SYSTEMTIME st;
  1440.             pVar->vt = VT_DATE;
  1441.             FileTimeToSystemTime(&pPropVar->filetime, &st);
  1442.             SystemTimeToVariantTime(&st, &pVar->date); // delay load...
  1443.             hr = S_OK ;
  1444.             break;
  1445.         }
  1447.         case VT_UI2:
  1448.             if (pPropVar->uiVal < 0x8000)
  1449.             {
  1450.                 pVar->vt = VT_I2;
  1451.                 pVar->iVal = (signed short) pPropVar->uiVal;
  1452.                 hr = S_OK ;
  1453.             }
  1454.             break;
  1456.         case VT_UI4:
  1457.             if (pPropVar->ulVal < 0x80000000)
  1458.             {
  1459.                 pVar->vt = VT_I4;
  1460.                 pVar->lVal = (signed int) pPropVar->ulVal;
  1461.                 hr = S_OK ;
  1462.             }
  1463.             break;
  1465.         case VT_CLSID:
  1466.             if( pPropVar->puuid )
  1467.             {
  1468.                 LPOLESTR pwszPuuid ;
  1469.                 if( SUCCEEDED( (hr = StringFromCLSID( *pPropVar->puuid, &pwszPuuid )) ) )
  1470.                 {
  1471.                     if( NULL == (pVar->bstrVal = SysAllocString( pwszPuuid )) )
  1472.                         hr = E_OUTOFMEMORY ;
  1473.                     else
  1474.                     {
  1475.                         pVar->vt = VT_BSTR;
  1476.                         hr = S_OK ;
  1477.                     }
  1478.                     CoTaskMemFree( pwszPuuid ) ;
  1479.                 }
  1480.             }
  1481.             break;
  1483.         case VT_BLOB:
  1484.         case VT_STREAM:
  1485.         case VT_STORAGE:
  1486.         case VT_BLOB_OBJECT:
  1487.         case VT_STREAMED_OBJECT:
  1488.         case VT_STORED_OBJECT:
  1489.         case VT_CF:
  1490.             ASSERT(0); // leave the output cleared
  1491.             hr = E_NOTIMPL ;
  1492.             break;
  1494.         default:
  1495.             VariantCopy(pVar, (VARIANT *)pPropVar);
  1496.             hr = S_OK ;
  1497.             break;
  1498.     }
  1499.     return hr ;
  1500. }
  1502. //-------------------------------------------------------------------------//
  1503. //  nullifies time fields in a SYSTEMTIME structure.
  1504. void SystemTimeMakeTimeless( SYSTEMTIME* pst )
  1505. {
  1506.     //  note: If the block is non-null, we set the hour to noon to avoid 
  1507.     //  date shifting across daylight savings time boundaries.
  1508.     pst->wHour = ( pst->wYear || pst->wMonth || pst->wDay ) ? 12 : 0;
  1509.     pst->wMinute = pst->wSecond = pst->wMilliseconds = 0;
  1510. }
  1512. //-------------------------------------------------------------------------//
  1513. //  nullifies time fields in a date/time propvariant.
  1514. HRESULT PropVariantMakeTimeless( PROPVARIANT* pvar )
  1515. {
  1516.     ASSERT(pvar);
  1517.     
  1518.     HRESULT     hr = S_FALSE;
  1519.     SYSTEMTIME  st;
  1521.     switch( pvar->vt )
  1522.     {
  1523.         case VT_FILETIME:
  1524.         {
  1525.             FileTimeToSystemTime( &pvar->filetime, &st );
  1526.             SystemTimeMakeTimeless( &st );
  1527.             hr = S_OK;
  1528.             SystemTimeToFileTime( &st, &pvar->filetime );
  1529.             break;
  1530.         }
  1532.         case VT_DATE:
  1533.             VariantTimeToSystemTime( pvar->date, &st );
  1534.             SystemTimeMakeTimeless( &st );
  1535.             hr = S_OK;
  1536.             SystemTimeToVariantTime( &st, &pvar->date );
  1537.             break;
  1538.     }
  1539.     return hr;
  1540. }
  1542. //-------------------------------------------------------------------------//
  1543. //  class CPropVariant : public PROPVARIANT  
  1544. //-------------------------------------------------------------------------//
  1546. //-------------------------------------------------------------------------//
  1547. HRESULT CPropVariant::GetDisplayText( 
  1548.     OUT LPTSTR pszText, 
  1549.     IN int cchText, 
  1550.     IN OPTIONAL LPCTSTR pszFmt,
  1551.     IN OPTIONAL ULONG dwFlags ) const
  1552. {
  1553.     return PropVariantToString( this, GetACP(), dwFlags, pszFmt, pszText, cchText ) ;
  1554. }
  1556. //-------------------------------------------------------------------------//
  1557. HRESULT CPropVariant::GetDisplayText( 
  1558.     OUT BSTR& bstrText,
  1559.     IN OPTIONAL LPCTSTR pszFmt,
  1560.     IN OPTIONAL ULONG dwFlags ) const
  1561. {
  1562.     return PropVariantToBstr( this, GetACP(), dwFlags, pszFmt, &bstrText ) ;
  1563. }
  1565. //-------------------------------------------------------------------------//
  1566. HRESULT CPropVariant::AssignFromDisplayText( IN LPCTSTR pszText, IN OPTIONAL LPCTSTR pszFmt )
  1567. {
  1568.     return PropVariantFromString( pszText, GetACP(), 0L, NULL, this ) ;
  1569. }
  1571. //-------------------------------------------------------------------------//
  1572. HRESULT CPropVariant::AssignFromDisplayText( IN const BSTR bstrText, IN OPTIONAL LPCTSTR pszFmt )
  1573. {
  1574.     return PropVariantFromBstr( bstrText, GetACP(), 0L, NULL, this ) ;
  1575. }
  1577. //-------------------------------------------------------------------------//
  1578. void CPropVariant::Attach( IN OUT PROPVARIANT* pSrc )
  1579. {
  1580. ASSERT( pSrc ) ;
  1581.     // Initialize ourselves
  1582.     Clear();
  1583. // Copy the source contents
  1584. memcpy( (PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT) );
  1585.     //  Empty the source and assume control of the data.
  1586. PropVariantInit( pSrc ) ;
  1587. }
  1589. //-------------------------------------------------------------------------//
  1590. void CPropVariant::Detach( OUT PROPVARIANT* pDest )
  1591. {
  1592.     ASSERT( pDest ) ;
  1594.     // Initialize the target
  1595. PropVariantClear( pDest ) ;
  1597.     // Copy out our contents and revoke control.
  1598. memcpy( pDest, this, sizeof(PROPVARIANT)) ;
  1600.     //  Initialize ourselves
  1601.     PropVariantInit( this ) ;
  1602. }
  1604. //-------------------------------------------------------------------------//
  1605. CPropVariant& CPropVariant::operator=( const CPropVariant& src )
  1606. {
  1607.     Clear() ;
  1608.     ::PropVariantCopy( this, &src ) ;   //  BUGBUG: This will leak on free.
  1609.     return *this ;
  1610. }
  1612. //-------------------------------------------------------------------------//
  1613. CPropVariant& CPropVariant::operator=( const PROPVARIANT& src )
  1614. {
  1615.     Clear() ;
  1616.     ::PropVariantCopy( this, &src ) ;   //  BUGBUG: This will leak on free.
  1617.     return *this ;
  1618. }
  1620. //-------------------------------------------------------------------------//
  1621. CPropVariant& CPropVariant::operator=( const BYTE& src )
  1622. {
  1623.     Clear() ;
  1624.     bVal = src ;
  1625.     vt = VT_UI1 ;
  1626.     return *this ;
  1627. }
  1629. //-------------------------------------------------------------------------//
  1630. CPropVariant& CPropVariant::operator=( const SHORT& src )
  1631. {
  1632.     Clear() ;
  1633.     iVal = src ;
  1634.     vt = VT_I2 ;
  1635.     return *this ;
  1636. }
  1638. //-------------------------------------------------------------------------//
  1639. CPropVariant& CPropVariant::operator=( const USHORT& src )
  1640. {
  1641.     Clear() ;
  1642.     uiVal = src ;
  1643.     vt = VT_UI2 ;
  1644.     return *this ;
  1645. }
  1647. //-------------------------------------------------------------------------//
  1648. CPropVariant& CPropVariant::operator=( const bool& src )
  1649. {
  1650.     Clear() ;
  1651. #pragma warning(disable: 4310) // cast truncates constant value
  1652.     boolVal = src ? VARIANT_TRUE : VARIANT_FALSE ;
  1653. #pragma warning(default: 4310) // cast truncates constant value
  1654.     vt = VT_BOOL ;
  1655.     return *this ;
  1656. }
  1658. //-------------------------------------------------------------------------//
  1659. CPropVariant& CPropVariant::operator=( const LONG& src )
  1660. {
  1661.     Clear() ;
  1662.     lVal = src ;
  1663.     vt = VT_I4 ;
  1664.     return *this ;
  1665. }
  1667. //-------------------------------------------------------------------------//
  1668. CPropVariant& CPropVariant::operator=( const ULONG& src )
  1669. {
  1670.     Clear() ;
  1671.     ulVal = src ;
  1672.     vt = VT_UI4 ;
  1673.     return *this ;
  1674. }
  1676. //-------------------------------------------------------------------------//
  1677. CPropVariant& CPropVariant::operator=( const FLOAT& src )
  1678. {
  1679.     Clear() ;
  1680.     fltVal = src ;
  1681.     vt = VT_R4 ;
  1682.     return *this ;
  1683. }
  1685. //-------------------------------------------------------------------------//
  1686. CPropVariant& CPropVariant::operator=( const LARGE_INTEGER& src )
  1687. {
  1688.     Clear() ;
  1689.     hVal = src ;
  1690.     vt = VT_I8 ;
  1691.     return *this ;
  1692. }
  1694. //-------------------------------------------------------------------------//
  1695. CPropVariant& CPropVariant::operator=( const ULARGE_INTEGER& src )
  1696. {
  1697.     Clear() ;
  1698.     uhVal = src ;
  1699.     vt = VT_UI8 ;
  1700.     return *this ;
  1701. }
  1703. //-------------------------------------------------------------------------//
  1704. CPropVariant& CPropVariant::operator=( const DOUBLE& src )
  1705. {
  1706.     Clear() ;
  1707.     dblVal = src ;
  1708.     vt = VT_R8 ;
  1709.     return *this ;
  1710. }
  1712. //-------------------------------------------------------------------------//
  1713. CPropVariant& CPropVariant::operator=( const CY& src )
  1714. {
  1715.     Clear() ;
  1716.     cyVal = src ;
  1717.     vt = VT_CY ;
  1718.     return *this ;
  1719. }
  1721. //-------------------------------------------------------------------------//
  1722. CPropVariant& CPropVariant::operator=( const FILETIME& src )
  1723. {
  1724.     Clear() ;
  1725.     filetime = src ;
  1726.     vt = VT_FILETIME ;
  1727.     return *this ;
  1728. }
  1730. //-------------------------------------------------------------------------//
  1731. CPropVariant& CPropVariant::operator=( const CLSID& src )
  1732. {
  1733.     Clear() ;
  1734.     if( (puuid = (CLSID*)AllocAndCopy( &src, sizeof(src) ))!=NULL )
  1735.         vt = VT_CLSID ;
  1736.     return *this ;
  1737. }
  1739. //-------------------------------------------------------------------------//
  1740. CPropVariant& CPropVariant::operator=( const BLOB& src )
  1741. {
  1742.     Clear() ;
  1743.     if( src.pBlobData != NULL && src.cbSize != 0 )
  1744.     {
  1745.         if( (blob.pBlobData = (LPBYTE)AllocAndCopy( src.pBlobData, src.cbSize ))!=NULL )
  1746.         {
  1747.             blob.cbSize = src.cbSize ;
  1748.             vt = VT_BLOB ;
  1749.         }
  1750.     }
  1752.     return *this ;
  1753. }
  1755. //-------------------------------------------------------------------------//
  1756. CPropVariant& CPropVariant::operator=( const CLIPDATA& src )
  1757. {
  1758.     Clear() ;
  1759.     if( (pclipdata = (CLIPDATA*)AllocAndCopy( &src, sizeof(src) ))!=NULL )
  1760.     {
  1761.         pclipdata->pClipData = NULL ;
  1762.         ULONG cb = src.pClipData ? CBPCLIPDATA( src ) : 0 ;
  1764.         if( cb!=0 && (pclipdata->pClipData = (LPBYTE)AllocAndCopy( src.pClipData, cb ))!=NULL )
  1765.             vt = VT_CF ;
  1766.         else
  1767.         {
  1768.             CoTaskMemFree( pclipdata ) ;
  1769.             pclipdata = NULL ;
  1770.         }
  1771.     }
  1772.     return *this ;
  1773. }
  1775. //-------------------------------------------------------------------------//
  1776. CPropVariant& CPropVariant::operator=( IStream* src )
  1777. {
  1778.     Clear() ;
  1779.     pStream = src ;
  1780.     vt = VT_STREAM ;
  1781.     return *this ;
  1782. }
  1784. //-------------------------------------------------------------------------//
  1785. CPropVariant& CPropVariant::operator=( IStorage* src )
  1786. {
  1787.     Clear() ;
  1788.     pStorage = src ;
  1789.     vt = VT_STORAGE ;
  1790.     return *this ;
  1791. }
  1793. //-------------------------------------------------------------------------//
  1794. CPropVariant& CPropVariant::operator=( const BSTR& src )
  1795. {
  1796.     Clear() ;
  1797.     if( (bstrVal = AllocString( src ))!=NULL )
  1798.         vt = VT_BSTR ;
  1799.     return *this ;
  1800. }
  1802. //-------------------------------------------------------------------------//
  1803. CPropVariant& CPropVariant::operator=( const LPSTR src )
  1804. {
  1805.     int cch ;
  1806.     
  1807.     Clear() ;
  1808.     if( src && (cch = lstrlenA( src ) + 1)> 1 )    {
  1809.         if( (pszVal = (LPSTR)AllocAndCopy( src, cch * sizeof(CHAR) ))!=NULL )
  1810.             vt = VT_LPSTR ;
  1811.     }
  1813.     return *this ;
  1814. }
  1816. //-------------------------------------------------------------------------//
  1817. CPropVariant& CPropVariant::operator=( const LPWSTR src )
  1818. {
  1819.     int cch ;
  1820.     
  1821.     Clear() ;
  1822.     if( src && (cch = lstrlenW( src ) + 1)> 1 )    {
  1823.         if( (pwszVal = (LPWSTR)AllocAndCopy( src, cch * sizeof(WCHAR) ))!=NULL )
  1824.             vt = VT_LPWSTR ;
  1825.     }
  1827.     return *this ;
  1828. }
  1830. //-------------------------------------------------------------------------//
  1831. //  Helper template function for vector type assignments
  1832. template <class CATYPE>
  1833. BOOL PropVectorAssignShallow( OUT CATYPE& caDest, OUT VARTYPE& vt, IN const CATYPE& caSrc, IN VARTYPE vtElems )
  1834. {
  1835. #pragma warning( disable : 4244 )   // conversion from 'typeA' to 'typeA', possible loss of data
  1836.     PVOID*  ppvAlloc = (PVOID*)&caDest.pElems ;
  1837.     ULONG   cb = caSrc.cElems * sizeof(*caSrc.pElems) ;
  1839.     if( ((*ppvAlloc) = CoTaskMemAlloc( cb ))!=NULL )
  1840.     {
  1841.         memcpy( caDest.pElems, caSrc.pElems, cb ) ;
  1842.         caDest.cElems = caSrc.cElems ;
  1843.         vt = VT_VECTOR|vtElems ;
  1844.         return TRUE ;
  1845.     }
  1846.     return FALSE ;
  1847. #pragma warning( default : 4244 )   // conversion from 'typeA' to 'typeA', possible loss of data
  1848. }
  1850. //-------------------------------------------------------------------------//
  1851. CPropVariant& CPropVariant::operator=( const CAUB& src )
  1852. {
  1853.     Clear() ;
  1854.     PropVectorAssignShallow( caub, vt, src, VT_UI1 ) ; 
  1855.     return *this ;
  1856. }
  1858. //-------------------------------------------------------------------------//
  1859. CPropVariant& CPropVariant::operator=( const CAI& src )
  1860. {
  1861.     Clear() ;
  1862.     PropVectorAssignShallow( cai, vt, src, VT_I2 ) ; 
  1863.     return *this ;
  1864. }
  1866. //-------------------------------------------------------------------------//
  1867. CPropVariant& CPropVariant::operator=( const CAUI& src )
  1868. {
  1869.     Clear() ;
  1870.     PropVectorAssignShallow( caui, vt, src, VT_UI2 ) ; 
  1871.     return *this ;
  1872. }
  1874. //-------------------------------------------------------------------------//
  1875. CPropVariant& CPropVariant::operator=( const CABOOL& src )
  1876. {
  1877.     Clear() ;
  1878.     PropVectorAssignShallow( cabool, vt, src, VT_BOOL ) ; 
  1879.     return *this ;
  1880. }
  1882. //-------------------------------------------------------------------------//
  1883. CPropVariant& CPropVariant::operator=( const CAL& src )
  1884. {
  1885.     Clear() ;
  1886.     PropVectorAssignShallow( cal, vt, src, VT_I4 ) ; 
  1887.     return *this ;
  1888. }
  1890. //-------------------------------------------------------------------------//
  1891. CPropVariant& CPropVariant::operator=( const CAUL& src )
  1892. {
  1893.     Clear() ;
  1894.     PropVectorAssignShallow( caul, vt, src, VT_UI4 ) ; 
  1895.     return *this ;
  1896. }
  1898. //-------------------------------------------------------------------------//
  1899. CPropVariant& CPropVariant::operator=( const CAFLT& src )
  1900. {
  1901.     Clear() ;
  1902.     PropVectorAssignShallow( caflt, vt, src, VT_R4 ) ; 
  1903.     return *this ;
  1904. }
  1906. //-------------------------------------------------------------------------//
  1907. CPropVariant& CPropVariant::operator=( const CASCODE& src )
  1908. {
  1909.     Clear() ;
  1910.     PropVectorAssignShallow( cascode, vt, src, VT_ERROR ) ; 
  1911.     return *this ;
  1912. }
  1914. //-------------------------------------------------------------------------//
  1915. CPropVariant& CPropVariant::operator=( const CAH& src )
  1916. {
  1917.     Clear() ;
  1918.     PropVectorAssignShallow( cah, vt, src, VT_I8 ) ; 
  1919.     return *this ;
  1920. }
  1922. //-------------------------------------------------------------------------//
  1923. CPropVariant& CPropVariant::operator=( const CAUH& src )
  1924. {
  1925.     Clear() ;
  1926.     PropVectorAssignShallow( cauh, vt, src, VT_UI8 ) ; 
  1927.     return *this ;
  1928. }
  1930. //-------------------------------------------------------------------------//
  1931. CPropVariant& CPropVariant::operator=( const CADBL& src )
  1932. {
  1933.     Clear() ;
  1934.     PropVectorAssignShallow( cadbl, vt, src, VT_R8 ) ; 
  1935.     return *this ;
  1936. }
  1938. //-------------------------------------------------------------------------//
  1939. CPropVariant& CPropVariant::operator=( const CACY& src )
  1940. {
  1941.     Clear() ;
  1942.     PropVectorAssignShallow( cacy, vt, src, VT_CY ) ; 
  1943.     return *this ;
  1944. }
  1946. //-------------------------------------------------------------------------//
  1947. CPropVariant& CPropVariant::operator=( const CADATE& src )
  1948. {
  1949.     Clear() ;
  1950.     PropVectorAssignShallow( cadate, vt, src, VT_DATE ) ; 
  1951.     return *this ;
  1952. }
  1954. //-------------------------------------------------------------------------//
  1955. CPropVariant& CPropVariant::operator=( const CAFILETIME& src )
  1956. {
  1957.     Clear() ;
  1958.     PropVectorAssignShallow( cafiletime, vt, src, VT_FILETIME ) ; 
  1959.     return *this ;
  1960. }
  1962. //-------------------------------------------------------------------------//
  1963. CPropVariant& CPropVariant::operator=( const CACLSID& src )
  1964. {
  1965.     Clear() ;
  1966.     PropVectorAssignShallow( cauuid, vt, src, VT_CLSID ) ; 
  1967.     return *this ;
  1968. }
  1970. //-------------------------------------------------------------------------//
  1971. CPropVariant& CPropVariant::operator=( const CACLIPDATA& src )
  1972. {
  1973.     Clear() ;
  1974.     if( PropVectorAssignShallow( caclipdata, vt, src, VT_CF ) )
  1975.     {
  1976.         for( ULONG i=0, cb; i<src.cElems; i++ )
  1977.         {
  1978.             caclipdata.pElems[i].cbSize     = 0 ;
  1979.             caclipdata.pElems[i].pClipData  = NULL ;
  1980.             
  1981.             if( (cb = CBPCLIPDATA( src.pElems[i] ))!=0 &&
  1982.                 src.pElems[i].pClipData!=NULL )
  1983.             {
  1984.                 if( (caclipdata.pElems[i].pClipData = 
  1985.                         (BYTE*)AllocAndCopy( src.pElems[i].pClipData, cb ))!=NULL )
  1986.                     caclipdata.pElems[i].cbSize = src.pElems[i].cbSize ;
  1987.             }
  1988.         }
  1989.     }
  1990.     return *this ;
  1991. }
  1993. //-------------------------------------------------------------------------//
  1994. CPropVariant& CPropVariant::operator=( const CABSTR& src )
  1995. {
  1996.     Clear() ;
  1997.     //  Do shallow copy    
  1998.     if( PropVectorAssignShallow( cabstr, vt, src, VT_BSTR ) )
  1999.     {
  2000.         //  Do deep copy
  2001.         for( ULONG i=0; i<src.cElems; i++ )
  2002.         {
  2003.             cabstr.pElems[i] = src.pElems[i]==NULL ? 
  2004.                 NULL : SysAllocString( src.pElems[i] ) ;
  2005.         }
  2006.     }
  2007.     return *this ;
  2008. }
  2010. //-------------------------------------------------------------------------//
  2011. CPropVariant& CPropVariant::operator=( const CALPSTR& src )
  2012. {
  2013.     Clear() ;
  2014.     //  Do shallow copy
  2015.     if( PropVectorAssignShallow( calpstr, vt, src, VT_LPSTR ) )
  2016.     {
  2017.         //  Do deep copy
  2018.         for( ULONG i=0; i<src.cElems; i++ )
  2019.         {
  2020.             if( src.pElems[i]!=NULL )
  2021.             {
  2022.                 UINT cch = lstrlenA( src.pElems[i] )+1 ;
  2023.                 calpstr.pElems[i] = (LPSTR)AllocAndCopy( src.pElems[i], cch ) ;
  2024.             }
  2025.         }
  2026.     }
  2027.     return *this ;
  2028. }
  2030. //-------------------------------------------------------------------------//
  2031. CPropVariant& CPropVariant::operator=( const CALPWSTR& src )
  2032. {
  2033.     Clear() ;
  2034.     //  Do shallow copy
  2035.     if( PropVectorAssignShallow( calpwstr, vt, src, VT_LPWSTR ) )
  2036.     {
  2037.         //  Do deep copy
  2038.         for( ULONG i=0; i<src.cElems; i++ )
  2039.         {
  2040.             if( src.pElems[i]!=NULL )
  2041.             {
  2042.                 UINT cch = lstrlenW( src.pElems[i] )+1 ;
  2043.                 calpwstr.pElems[i] = (LPWSTR)AllocAndCopy( src.pElems[i], cch ) ;
  2044.             }
  2045.         }
  2046.     }
  2047.     return *this ;
  2048. }
  2050. //-------------------------------------------------------------------------//
  2051. CPropVariant& CPropVariant::operator=( const CAPROPVARIANT& src )
  2052. {
  2053.     Clear() ;
  2054.     if( PropVectorAssignShallow( capropvar, vt, src, VT_VARIANT ) )
  2055.     {
  2056.         for( ULONG i=0; i<src.cElems; i++ )
  2057.             ::PropVariantCopy( &capropvar.pElems[i], &src.pElems[i] ) ;    
  2058.     }
  2059.     return *this ;
  2060. }
  2062. //-------------------------------------------------------------------------//
  2063. int CPropVariant::CompareText( 
  2064.     const CPropVariant& varOther, 
  2065.     ULONG uFlags,
  2066.     IN OPTIONAL LPCTSTR pszFmt, 
  2067.     IN OPTIONAL ULONG dwFlags ) const
  2068. {
  2069.     BSTR    bstrThis  = NULL, 
  2070.             bstrOther = NULL;
  2071.     HRESULT hrThis, 
  2072.             hrOther ;
  2073.     int     iRet = 0 ;
  2075.     hrThis  = GetDisplayText( bstrThis, pszFmt, dwFlags ) ;
  2076.     hrOther = varOther.GetDisplayText( bstrOther, pszFmt, dwFlags ) ;
  2078.     if( SUCCEEDED( hrThis ) && SUCCEEDED( hrOther ) )
  2079.         iRet = uFlags & PVCF_IGNORECASE ? lstrcmpiW( bstrThis, bstrOther ) :
  2080.                                           lstrcmpW( bstrThis, bstrOther ) ;
  2081.     else if( SUCCEEDED( hrThis ) )
  2082.         iRet = 1 ;
  2083.     else if( SUCCEEDED( hrOther ) )
  2084.         iRet = -1 ;
  2086.     SysFreeString( bstrThis ) ;
  2087.     SysFreeString( bstrOther ) ;
  2088.     
  2089.     return iRet ;
  2090. }
  2092. //-------------------------------------------------------------------------//
  2093. //  Write to registry
  2094. HRESULT CPropVariant::WriteValue( HKEY hKey, LPCTSTR pszValueName ) const
  2095. {
  2096.     return PropVariantWriteRegistry( hKey, pszValueName, *this ) ;
  2097. }
  2099. //-------------------------------------------------------------------------//
  2100. //  Read from registry
  2101. HRESULT CPropVariant::ReadValue( HKEY hKey, LPCTSTR pszValueName )
  2102. {
  2103.     Clear() ;
  2104.     return PropVariantReadRegistry( hKey, pszValueName, *this ) ;
  2105. }                           
  2108. //-------------------------------------------------------------------------//
  2109. //  class CDisplayPropVariant : public CPropVariant 
  2110. //-------------------------------------------------------------------------//
  2112. //-------------------------------------------------------------------------//
  2113. //  Generates display text for the object, optionally using the provided
  2114. //  formatting string
  2115. HRESULT CDisplayPropVariant::CreateDisplayText( 
  2116.     IN OPTIONAL LPCTSTR pszFmt,
  2117.     IN OPTIONAL ULONG dwFlags )
  2118. {
  2119.     BSTR    bstrDisplay = NULL ;
  2120.     HRESULT hr = GetDisplayText( bstrDisplay, pszFmt, dwFlags ) ;
  2121.     if( SUCCEEDED( hr ) )
  2122.         SetDisplayText( bstrDisplay ) ;
  2124.     return hr ;
  2125. }
  2126. //-------------------------------------------------------------------------//
  2127. void CDisplayPropVariant::SetDisplayTextT( IN LPCTSTR pszDisplay )
  2128. {
  2129.     BSTR bstrDisplay = NULL ;
  2131.     if( pszDisplay )
  2132.     {
  2133.         USES_CONVERSION ;
  2134.         bstrDisplay = SysAllocString( T2W( (LPTSTR)pszDisplay ) ) ;
  2135.     }
  2137.     SetDisplayText( bstrDisplay ) ;
  2138. }
  2139. //-------------------------------------------------------------------------//
  2140. //  Assigns display text.
  2141. void CDisplayPropVariant::SetDisplayText( BSTR bstrDisplay )
  2142. {
  2143.     if( m_bstrDisplay )
  2144.     {
  2145.         SysFreeString( m_bstrDisplay ) ;
  2146.         m_bstrDisplay = NULL ;
  2147.     }
  2148.     m_bstrDisplay = SysAllocString( bstrDisplay ) ;
  2149. }
  2152. //-------------------------------------------------------------------------//
  2153. //  class CPropertyUID : public tagPUID
  2154. //-------------------------------------------------------------------------//
  2156. //-------------------------------------------------------------------------//
  2157. //  hashing method for class CPropertyUID
  2158. ULONG CPropertyUID::Hash() const 
  2159. { 
  2160.     int   cb = sizeof(fmtid) ; 
  2161.     ULONG nHash = 0 ;
  2162.     BYTE* p = (BYTE*)&fmtid ;
  2163.     while( cb-- )
  2164.         nHash += *p++ ;
  2165.     nHash += propid ;
  2166.     return  nHash ;
  2167. }