1600 lines
39 KiB
C++
1600 lines
39 KiB
C++
|
|
#ifndef _CPROPVAR_HXX_
|
|
#define _CPROPVAR_HXX_
|
|
|
|
#ifndef _MAC
|
|
#include <wtypes.h>
|
|
#include <objidl.h>
|
|
#include <oaidl.h>
|
|
#endif
|
|
|
|
#include "CHResult.hxx"
|
|
#include <olechar.h>
|
|
|
|
|
|
#ifndef ASSERT
|
|
#if DBG==1
|
|
#ifdef _MAC
|
|
#define ASSERT(assertion) PROPASSERT(assertion)
|
|
#else
|
|
#include "debnot.h"
|
|
#define ASSERT(assertion) {if(!(assertion)) Win4AssertEx(__FILE__, __LINE__, (#assertion));}
|
|
#endif
|
|
#else
|
|
#define ASSERT(assertion)
|
|
#endif
|
|
#endif
|
|
|
|
class CClipData;
|
|
class CBlob;
|
|
class CPropVariant;
|
|
|
|
|
|
|
|
|
|
class CClipData : private CLIPDATA
|
|
{
|
|
public:
|
|
|
|
~CClipData()
|
|
{
|
|
if( NULL != pClipData)
|
|
CoTaskMemFree( pClipData);
|
|
}
|
|
|
|
CClipData()
|
|
{
|
|
cbSize = sizeof( ulClipFmt );
|
|
ulClipFmt = (ULONG) -1;
|
|
pClipData = NULL;
|
|
}
|
|
|
|
CClipData( ULONG ul, const void *p, ULONG cb )
|
|
{
|
|
HRESULT hr;
|
|
this->CClipData::CClipData();
|
|
hr = Set( ul, p, cb );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
|
|
CClipData( LPSTR psz )
|
|
{
|
|
this->CClipData::CClipData( (ULONG) -1, psz, strlen(psz) + 1 );
|
|
}
|
|
|
|
CClipData( LPWSTR pwsz )
|
|
{
|
|
this->CClipData::CClipData( (ULONG) -1, pwsz,
|
|
sizeof(WCHAR) * (wcslen(pwsz) + 1) );
|
|
}
|
|
|
|
CClipData( CClipData &cClipData )
|
|
{
|
|
HRESULT hr;
|
|
hr = Set( cClipData.ulClipFmt,
|
|
cClipData.pClipData,
|
|
cClipData.cbSize - sizeof(ulClipFmt));
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
|
|
CClipData& operator =(CClipData &cClipData)
|
|
{
|
|
HRESULT hr;
|
|
hr = Set( cClipData.ulClipFmt,
|
|
cClipData.pClipData,
|
|
cClipData.cbSize - sizeof(ulClipFmt));
|
|
ASSERT( SUCCEEDED(hr) );
|
|
return( *this );
|
|
}
|
|
|
|
HRESULT Set( ULONG ul, const void *p, ULONG cb )
|
|
{
|
|
if( NULL != pClipData )
|
|
{
|
|
cb = sizeof( ulClipFmt );
|
|
ulClipFmt = (ULONG) -1;
|
|
CoTaskMemFree( pClipData );
|
|
}
|
|
|
|
if( NULL != p )
|
|
{
|
|
pClipData = (BYTE*) CoTaskMemAlloc( cb );
|
|
if( NULL == pClipData )
|
|
return( (HRESULT) E_OUTOFMEMORY );
|
|
|
|
memcpy( pClipData, p, cb );
|
|
}
|
|
|
|
cbSize = sizeof( ulClipFmt ) + cb;
|
|
ulClipFmt = ul;
|
|
|
|
return( S_OK );
|
|
}
|
|
|
|
|
|
operator const CLIPDATA*()
|
|
{
|
|
return( this );
|
|
}
|
|
operator CLIPDATA*()
|
|
{
|
|
return( this );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define INVALID_SUBSCRIPT 0
|
|
|
|
template< VARENUM tpltVT, class tpltType >
|
|
void TCPropVarAssignmentOperator( CPropVariant *pThis, tpltType Type )
|
|
{
|
|
if( INVALID_SUBSCRIPT == pThis->wReserved1 )
|
|
{
|
|
PropVariantClear(pThis);
|
|
pThis->Set(tpltVT, (void*) &Type, INVALID_SUBSCRIPT );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if( !(pThis->vt & VT_VECTOR)
|
|
||
|
|
(pThis->vt & ~VT_VECTOR) != tpltVT )
|
|
{
|
|
WORD wReserved1Save = pThis->wReserved1;
|
|
PropVariantClear(pThis);
|
|
pThis->wReserved1 = wReserved1Save;
|
|
}
|
|
|
|
pThis->Set( tpltVT | VT_VECTOR, (void*) &Type, pThis->wReserved1 - 1);
|
|
pThis->wReserved1 = INVALID_SUBSCRIPT;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template< VARENUM tpltVT, class TCountedArray, class TProperty >
|
|
TProperty
|
|
TCPropVarConversionOperator( CPropVariant *pThis, TCountedArray *pca, TProperty *pSingleton )
|
|
{
|
|
if( pThis->vt & VT_VECTOR )
|
|
{
|
|
ASSERT( pThis->vt == (tpltVT | VT_VECTOR)
|
|
||
|
|
pThis->vt == (VT_VARIANT | VT_VECTOR) );
|
|
ASSERT( pThis->wReserved1 > 0 );
|
|
|
|
if( pThis->wReserved1 > 0
|
|
&&
|
|
pca->cElems > 0
|
|
&&
|
|
pThis->wReserved1 <= (pca->cElems) )
|
|
{
|
|
USHORT usSubscript = pThis->wReserved1 - 1;
|
|
pThis->wReserved1 = 0;
|
|
|
|
if( (pThis->vt & ~VT_VECTOR) == VT_VARIANT )
|
|
return( (TProperty) *(CPropVariant*)(PROPVARIANT*)
|
|
&((CAPROPVARIANT*)pca)->pElems[usSubscript] );
|
|
else
|
|
return( pca->pElems[ usSubscript ] );
|
|
}
|
|
else
|
|
{
|
|
throw CHRESULT( (HRESULT) E_INVALIDARG, OLESTR("Index not set on conversion of vector") );
|
|
|
|
// This unnecessary statement avoids a compiler error.
|
|
return pca->pElems[ 0 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT( vt == tpltVT );
|
|
return( *pSingleton );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define DECLARE_CPROPVARIANT_ASSIGNMENT_OPERATOR(Type) \
|
|
CPropVariant & operator =( Type);
|
|
|
|
#define DEFINE_CPROPVARIANT_ASSIGNMENT_OPERATOR(VT, Type ) \
|
|
\
|
|
CPropVariant & CPropVariant::operator =( Type pType) \
|
|
{ \
|
|
if( INVALID_SUBSCRIPT == wReserved1 ) \
|
|
{ \
|
|
PropVariantClear(this); \
|
|
this->CPropVariant::CPropVariant(pType); \
|
|
return (*this); \
|
|
} \
|
|
else \
|
|
{ \
|
|
if( !(vt & VT_VECTOR) \
|
|
|| \
|
|
(vt & ~VT_VECTOR) != VT_##VT ) \
|
|
{ \
|
|
WORD wReserved1Save = wReserved1; \
|
|
PropVariantClear(this); \
|
|
this->CPropVariant::CPropVariant( VT_##VT, \
|
|
wReserved1Save ); \
|
|
wReserved1 = wReserved1Save; \
|
|
} \
|
|
\
|
|
Set##VT( pType, wReserved1 - 1); \
|
|
wReserved1 = 0; \
|
|
return (*this); \
|
|
} \
|
|
}
|
|
|
|
#define DECLARE_CPROPVARIANT_CONVERSION_OPERATOR(VarType) \
|
|
operator VarType();
|
|
|
|
#define DEFINE_CPROPVARIANT_CONVERSION_OPERATOR(VarType, CAName, SingletonName) \
|
|
CPropVariant::operator VarType() \
|
|
{ \
|
|
if( vt & VT_VECTOR ) \
|
|
{ \
|
|
ASSERT( vt == (VT_##VarType | VT_VECTOR) \
|
|
|| \
|
|
vt == (VT_VARIANT | VT_VECTOR) ); \
|
|
ASSERT( wReserved1 > 0 ); \
|
|
\
|
|
if( wReserved1 > 0 \
|
|
&& \
|
|
##CAName.cElems > 0 \
|
|
&& \
|
|
wReserved1 <= (##CAName.cElems) ) \
|
|
{ \
|
|
USHORT usSubscript = wReserved1 - 1; \
|
|
wReserved1 = 0; \
|
|
if( (vt & ~VT_VECTOR) == VT_VARIANT ) \
|
|
return( capropvar.pElems[ usSubscript ].##SingletonName );\
|
|
else \
|
|
return( ##CAName.pElems[ usSubscript ] ); \
|
|
} \
|
|
else \
|
|
return( NULL ); \
|
|
} \
|
|
else \
|
|
{ \
|
|
ASSERT( vt == VT_##VarType ); \
|
|
return( ##SingletonName ); \
|
|
} \
|
|
}
|
|
|
|
|
|
class CPropVariant : public tagPROPVARIANT
|
|
{
|
|
|
|
public:
|
|
|
|
// --------------------------------
|
|
// Default Constructor & Destructor
|
|
// --------------------------------
|
|
|
|
CPropVariant()
|
|
{
|
|
Init();
|
|
wReserved1 = INVALID_SUBSCRIPT;
|
|
}
|
|
|
|
~CPropVariant()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
CPropVariant( CPropVariant &cpropvar )
|
|
{
|
|
Init();
|
|
PropVariantCopy( this, &cpropvar );
|
|
}
|
|
|
|
// -------------------
|
|
// Generic Set routine
|
|
// -------------------
|
|
|
|
void Set( VARTYPE vtSet, void *pv, ULONG pos );
|
|
|
|
|
|
|
|
// ------------------------------------------------------------
|
|
// Constructors, assignment operators, and conversion functions
|
|
// ------------------------------------------------------------
|
|
|
|
// VT_I1 (CHAR)
|
|
|
|
CPropVariant(CHAR c)
|
|
{
|
|
Init();
|
|
SetI1(c);
|
|
}
|
|
void SetI1(CHAR c)
|
|
{
|
|
Clear();
|
|
vt = VT_I1;
|
|
cVal = c;
|
|
}
|
|
void SetI1( CHAR c, ULONG pos )
|
|
{
|
|
if( vt != (VT_I1 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &c, sizeof(c) );
|
|
vt = VT_I1 | VT_VECTOR;
|
|
}
|
|
UCHAR GetI1()
|
|
{
|
|
_ValidateGet( VT_I1 );
|
|
return( cVal );
|
|
}
|
|
UCHAR GetI1( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_I1, pos );
|
|
return( cac.pElems[pos] );
|
|
}
|
|
CPropVariant & operator =(CHAR c)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_I1,CHAR>(this, c );
|
|
return (*this);
|
|
}
|
|
operator CHAR()
|
|
{
|
|
return TCPropVarConversionOperator<VT_I1,CAC,CHAR>
|
|
( this, &cac, &cVal );
|
|
}
|
|
|
|
|
|
// VT_UI1 (UCHAR)
|
|
|
|
CPropVariant(UCHAR b)
|
|
{
|
|
Init();
|
|
SetUI1(b);
|
|
}
|
|
void SetUI1(UCHAR b)
|
|
{
|
|
Clear();
|
|
vt = VT_UI1;
|
|
bVal = b;
|
|
}
|
|
void SetUI1( UCHAR b, ULONG pos )
|
|
{
|
|
if( vt != (VT_UI1 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &b, sizeof(b) );
|
|
vt = VT_UI1 | VT_VECTOR;
|
|
}
|
|
UCHAR GetUI1()
|
|
{
|
|
_ValidateGet( VT_UI1 );
|
|
return( bVal );
|
|
}
|
|
UCHAR GetUI1( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_UI1, pos );
|
|
return( caub.pElems[pos] );
|
|
}
|
|
CPropVariant & operator =(UCHAR b)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_UI1,UCHAR>(this, b );
|
|
return (*this);
|
|
}
|
|
operator UCHAR()
|
|
{
|
|
return TCPropVarConversionOperator<VT_UI1,CAUB,UCHAR>
|
|
( this, &caub, &bVal );
|
|
}
|
|
|
|
|
|
// VT_I2 (short)
|
|
|
|
CPropVariant(short i)
|
|
{
|
|
Init();
|
|
SetI2(i);
|
|
}
|
|
void SetI2(short i)
|
|
{
|
|
Clear();
|
|
vt = VT_I2;
|
|
iVal = i;
|
|
}
|
|
void SetI2( short i, ULONG pos )
|
|
{
|
|
if( vt != (VT_I2 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &i, sizeof(i) );
|
|
vt = VT_I2 | VT_VECTOR;
|
|
}
|
|
short GetI2()
|
|
{
|
|
_ValidateGet( VT_I2 );
|
|
return(iVal);
|
|
}
|
|
short GetI2( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_I2, pos );
|
|
return( cai.pElems[pos] );
|
|
}
|
|
CPropVariant & operator =(short i)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_I2,short>(this, i);
|
|
return (*this);
|
|
}
|
|
operator short()
|
|
{
|
|
return TCPropVarConversionOperator<VT_I2,CAI,short>
|
|
( this, &cai, &iVal );
|
|
}
|
|
|
|
|
|
// VT_UI2 (USHORT)
|
|
|
|
CPropVariant(USHORT ui)
|
|
{
|
|
Init();
|
|
SetUI2(ui);
|
|
}
|
|
void SetUI2(USHORT ui)
|
|
{
|
|
Clear();
|
|
vt = VT_UI2;
|
|
uiVal = ui;
|
|
}
|
|
void SetUI2( USHORT ui, ULONG pos )
|
|
{
|
|
if( vt != (VT_UI2 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &ui, sizeof(ui) );
|
|
vt = VT_UI2 | VT_VECTOR;
|
|
}
|
|
USHORT GetUI2()
|
|
{
|
|
_ValidateGet( VT_UI2 );
|
|
return( uiVal );
|
|
}
|
|
USHORT GetUI2( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_UI2, pos );
|
|
return( caui.pElems[pos] );
|
|
}
|
|
CPropVariant & operator =(USHORT ui)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_UI2,USHORT>(this, ui);
|
|
return (*this);
|
|
}
|
|
operator USHORT()
|
|
{
|
|
return TCPropVarConversionOperator<VT_UI2,CAUI,USHORT>
|
|
( this, &caui, &uiVal );
|
|
}
|
|
|
|
// VT_I4 (long)
|
|
|
|
CPropVariant(long l)
|
|
{
|
|
Init();
|
|
SetI4(l);
|
|
}
|
|
void SetI4(long l)
|
|
{
|
|
Clear();
|
|
vt = VT_I4;
|
|
lVal = l;
|
|
}
|
|
void SetI4( long l, ULONG pos )
|
|
{
|
|
if( vt != (VT_I4 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &l, sizeof(l) );
|
|
vt = VT_I4 | VT_VECTOR;
|
|
}
|
|
long GetI4()
|
|
{
|
|
_ValidateGet( VT_I4 );
|
|
return( lVal );
|
|
}
|
|
long GetI4( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_I4, pos );
|
|
return( cal.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator =(long l)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_I4,long>(this, l);
|
|
return (*this);
|
|
}
|
|
CPropVariant & operator =(int i) // Assume sizeof(int)==sizeof(long)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_I4,long>(this, i);
|
|
return (*this);
|
|
}
|
|
operator long()
|
|
{
|
|
return TCPropVarConversionOperator<VT_I4,CAL,long>
|
|
( this, &cal, &lVal );
|
|
}
|
|
|
|
// VT_INT (long)
|
|
|
|
void SetINT(long l)
|
|
{
|
|
Clear();
|
|
vt = VT_INT;
|
|
intVal = l;
|
|
}
|
|
long GetINT()
|
|
{
|
|
_ValidateGet( VT_INT );
|
|
return( intVal );
|
|
}
|
|
|
|
// VT_UI4 (ULONG)
|
|
|
|
CPropVariant(ULONG ul)
|
|
{
|
|
Init();
|
|
SetUI4(ul);
|
|
}
|
|
void SetUI4(ULONG ul)
|
|
{
|
|
Clear();
|
|
vt = VT_UI4;
|
|
ulVal = ul;
|
|
}
|
|
void SetUI4( ULONG ul, ULONG pos )
|
|
{
|
|
if( vt != (VT_UI4 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &ul, sizeof(ul) );
|
|
vt = VT_UI4 | VT_VECTOR;
|
|
}
|
|
ULONG GetUI4()
|
|
{
|
|
_ValidateGet( VT_UI4 );
|
|
return( ulVal );
|
|
}
|
|
ULONG GetUI4( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_UI4, pos );
|
|
return( caul.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator =(ULONG ul)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_UI4,ULONG>(this, ul);
|
|
return (*this);
|
|
}
|
|
operator ULONG()
|
|
{
|
|
return TCPropVarConversionOperator<VT_UI4,CAUL,ULONG>
|
|
( this, &caul, &ulVal );
|
|
}
|
|
|
|
// VT_UINT (unsigned long)
|
|
|
|
void SetUINT(ULONG ul)
|
|
{
|
|
Clear();
|
|
vt = VT_UINT;
|
|
uintVal = ul;
|
|
}
|
|
long GetUINT()
|
|
{
|
|
_ValidateGet( VT_UINT );
|
|
return( uintVal );
|
|
}
|
|
|
|
// VT_I8 (LARGE_INTEGER)
|
|
|
|
CPropVariant(LARGE_INTEGER h)
|
|
{
|
|
Init();
|
|
SetI8(h);
|
|
}
|
|
void SetI8(LARGE_INTEGER h)
|
|
{
|
|
Clear();
|
|
vt = VT_I8;
|
|
hVal = h;
|
|
}
|
|
void SetI8( LARGE_INTEGER h, ULONG pos )
|
|
{
|
|
if( vt != (VT_I8 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &h, sizeof(h) );
|
|
vt = VT_I8 | VT_VECTOR;
|
|
}
|
|
LARGE_INTEGER GetI8()
|
|
{
|
|
_ValidateGet( VT_I8 );
|
|
return( hVal );
|
|
}
|
|
LARGE_INTEGER GetI8( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_I8, pos );
|
|
return( cah.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(LARGE_INTEGER h)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_I8,LARGE_INTEGER>(this, h);
|
|
return (*this);
|
|
}
|
|
operator LARGE_INTEGER()
|
|
{
|
|
return TCPropVarConversionOperator<VT_I8,CAH,LARGE_INTEGER>
|
|
( this, &cah, &hVal );
|
|
}
|
|
|
|
// VT_UI8 (ULARGE_INTEGER)
|
|
|
|
CPropVariant(ULARGE_INTEGER uh)
|
|
{
|
|
Init();
|
|
SetUI8(uh);
|
|
}
|
|
void SetUI8(ULARGE_INTEGER uh)
|
|
{
|
|
Clear();
|
|
vt = VT_UI8;
|
|
uhVal = uh;
|
|
}
|
|
void SetUI8( ULARGE_INTEGER uh, ULONG pos )
|
|
{
|
|
if( vt != (VT_UI8 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &uh, sizeof(uh) );
|
|
vt = VT_UI8 | VT_VECTOR;
|
|
}
|
|
ULARGE_INTEGER GetUI8()
|
|
{
|
|
_ValidateGet( VT_UI8 );
|
|
return( uhVal );
|
|
}
|
|
ULARGE_INTEGER GetUI8( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_UI8, pos );
|
|
return( cauh.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(ULARGE_INTEGER uh)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_UI8,ULARGE_INTEGER>(this, uh);
|
|
return (*this);
|
|
}
|
|
operator ULARGE_INTEGER()
|
|
{
|
|
return TCPropVarConversionOperator<VT_UI8,CAUH,ULARGE_INTEGER>
|
|
( this, &cauh, &uhVal );
|
|
}
|
|
|
|
// VT_R4 (float)
|
|
|
|
CPropVariant(float flt)
|
|
{
|
|
Init();
|
|
SetR4(flt);
|
|
}
|
|
void SetR4(float flt)
|
|
{
|
|
Clear();
|
|
vt = VT_R4;
|
|
fltVal = flt;
|
|
}
|
|
void SetR4( float flt, ULONG pos )
|
|
{
|
|
if( vt != (VT_R4 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &flt, sizeof(flt) );
|
|
vt = VT_R4 | VT_VECTOR;
|
|
}
|
|
float GetR4()
|
|
{
|
|
_ValidateGet( VT_R4 );
|
|
return( fltVal );
|
|
}
|
|
float GetR4( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_R4, pos );
|
|
return( caflt.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(float flt)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_R4,float>(this, flt);
|
|
return (*this);
|
|
}
|
|
operator float()
|
|
{
|
|
return TCPropVarConversionOperator<VT_R4,CAFLT,float>
|
|
( this, &caflt, &fltVal );
|
|
}
|
|
|
|
// VT_R8 (double)
|
|
|
|
CPropVariant(double dbl)
|
|
{
|
|
Init();
|
|
SetR8(dbl);
|
|
}
|
|
void SetR8(double dbl)
|
|
{
|
|
Clear();
|
|
vt = VT_R8;
|
|
dblVal = dbl;
|
|
}
|
|
void SetR8( double dbl, ULONG pos )
|
|
{
|
|
if( vt != (VT_R8 | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &dbl, sizeof(dbl) );
|
|
vt = VT_R8 | VT_VECTOR;
|
|
}
|
|
double GetR8()
|
|
{
|
|
_ValidateGet( VT_R8 );
|
|
return( dblVal );
|
|
}
|
|
double GetR8( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_R8, pos );
|
|
return( cadbl.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(double dbl)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_R8,double>(this, dbl);
|
|
return (*this);
|
|
}
|
|
operator double()
|
|
{
|
|
return TCPropVarConversionOperator<VT_R8,CADBL,double>
|
|
( this, &cadbl, &dblVal );
|
|
}
|
|
|
|
// VT_CY (CY)
|
|
|
|
CPropVariant(CY cy)
|
|
{
|
|
Init();
|
|
SetCY(cy);
|
|
}
|
|
void SetCY(const CY &cy)
|
|
{
|
|
Clear();
|
|
vt = VT_CY;
|
|
cyVal = cy;
|
|
}
|
|
void SetCY( const CY &cy, ULONG pos )
|
|
{
|
|
if( vt != (VT_CY | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &cy, sizeof(cy) );
|
|
vt = VT_CY | VT_VECTOR;
|
|
}
|
|
CPropVariant & operator=(const CY &cy)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_CY,CY>(this, cy);
|
|
return (*this);
|
|
}
|
|
CY GetCY()
|
|
{
|
|
_ValidateGet( VT_CY );
|
|
return( cyVal );
|
|
}
|
|
CY GetCY( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_CY, pos );
|
|
return( cacy.pElems[ pos ] );
|
|
}
|
|
operator CY()
|
|
{
|
|
return TCPropVarConversionOperator<VT_CY,CACY,CY>
|
|
( this, &cacy, &cyVal );
|
|
}
|
|
|
|
// VT_FILETIME (FILETIME)
|
|
|
|
CPropVariant(const FILETIME &filetime)
|
|
{
|
|
Init();
|
|
SetFILETIME(filetime);
|
|
}
|
|
void SetFILETIME(const FILETIME &ft)
|
|
{
|
|
Clear();
|
|
vt = VT_FILETIME;
|
|
filetime = ft;
|
|
}
|
|
void SetFILETIME( const FILETIME &ft, ULONG pos )
|
|
{
|
|
if( vt != (VT_FILETIME | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &ft, sizeof(ft) );
|
|
vt = VT_FILETIME | VT_VECTOR;
|
|
}
|
|
FILETIME GetFILETIME()
|
|
{
|
|
_ValidateGet( VT_FILETIME );
|
|
return( filetime );
|
|
}
|
|
FILETIME GetFILETIME( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_FILETIME, pos );
|
|
return( cafiletime.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(const FILETIME &ft)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_FILETIME,FILETIME>(this, ft);
|
|
return (*this);
|
|
}
|
|
operator FILETIME()
|
|
{
|
|
return TCPropVarConversionOperator<VT_FILETIME,CAFILETIME,FILETIME>
|
|
( this, &cafiletime, &filetime );
|
|
}
|
|
|
|
|
|
// VT_CLSID (CLSID)
|
|
|
|
CPropVariant(CLSID *pclsid)
|
|
{
|
|
Init();
|
|
SetCLSID(pclsid);
|
|
}
|
|
void SetCLSID(const CLSID *pclsid);
|
|
void SetCLSID(const CLSID &clsid)
|
|
{
|
|
SetCLSID( &clsid );
|
|
}
|
|
void SetCLSID(const CLSID *pclsid, unsigned pos);
|
|
void SetCLSID(const CLSID &clsid, unsigned pos )
|
|
{
|
|
if( vt != (VT_CLSID | VT_VECTOR) )
|
|
{
|
|
Clear();
|
|
vt = VT_CLSID | VT_VECTOR;
|
|
}
|
|
SetCLSID( &clsid, pos );
|
|
}
|
|
CLSID* GetCLSID()
|
|
{
|
|
_ValidateGet( VT_CLSID );
|
|
return( puuid );
|
|
}
|
|
CLSID* GetCLSID( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_CLSID, pos );
|
|
return( &cauuid.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(const CLSID *pclsid)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_CLSID,const CLSID*>(this, pclsid);
|
|
return( *this );
|
|
}
|
|
CPropVariant & operator=(const CLSID &clsid)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_CLSID,const CLSID*>(this, &clsid);
|
|
return( *this );
|
|
}
|
|
operator CLSID()
|
|
{
|
|
return TCPropVarConversionOperator<VT_CLSID,CACLSID,CLSID>
|
|
( this, &cauuid, puuid );
|
|
}
|
|
|
|
|
|
|
|
// VT_STREAM (IStream*)
|
|
|
|
CPropVariant( IStream *pStm )
|
|
{
|
|
Init();
|
|
SetSTREAM( pStm );
|
|
}
|
|
void SetSTREAM( IStream *pStm )
|
|
{
|
|
Clear();
|
|
vt = VT_STREAM;
|
|
pStream = pStm;
|
|
|
|
if( NULL != pStream )
|
|
pStream->AddRef();
|
|
}
|
|
IStream* GetSTREAM()
|
|
{
|
|
_ValidateGet( VT_STREAM );
|
|
return( pStream );
|
|
}
|
|
CPropVariant & operator= ( IStream *pStm )
|
|
{
|
|
Clear();
|
|
SetSTREAM( pStm );
|
|
return (*this);
|
|
}
|
|
operator IStream*()
|
|
{
|
|
return( GetSTREAM() );
|
|
}
|
|
|
|
|
|
// VT_VERSIONED_STREAM
|
|
|
|
CPropVariant( VERSIONEDSTREAM& verstream )
|
|
{
|
|
Init();
|
|
SetVERSIONEDSTREAM( &verstream );
|
|
}
|
|
void SetVERSIONEDSTREAM( VERSIONEDSTREAM *pverstream)
|
|
{
|
|
Clear();
|
|
vt = VT_VERSIONED_STREAM;
|
|
|
|
pVersionedStream = (LPVERSIONEDSTREAM) CoTaskMemAlloc( sizeof(*pVersionedStream) );
|
|
if( NULL == pVersionedStream )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Failed CoTaskMemAlloc for VT_VERSIONED_STREAM") );
|
|
|
|
pVersionedStream->guidVersion = pverstream->guidVersion;
|
|
|
|
if( NULL != pverstream->pStream )
|
|
pverstream->pStream->AddRef();
|
|
pVersionedStream->pStream = pverstream->pStream;
|
|
}
|
|
VERSIONEDSTREAM GetVERSIONEDSTREAM()
|
|
{
|
|
_ValidateGet( VT_VERSIONED_STREAM );
|
|
return( *pVersionedStream );
|
|
}
|
|
CPropVariant & operator= ( VERSIONEDSTREAM &verstream )
|
|
{
|
|
Clear();
|
|
SetVERSIONEDSTREAM( &verstream );
|
|
return (*this);
|
|
}
|
|
operator VERSIONEDSTREAM()
|
|
{
|
|
return( GetVERSIONEDSTREAM() );
|
|
}
|
|
|
|
|
|
// VT_STORAGE (IStorage*)
|
|
|
|
CPropVariant( IStorage *pStg )
|
|
{
|
|
Init();
|
|
SetSTORAGE( pStg );
|
|
}
|
|
void SetSTORAGE( IStorage *pStg )
|
|
{
|
|
vt = VT_STORAGE;
|
|
pStorage = pStg;
|
|
|
|
if( NULL != pStorage )
|
|
pStorage->AddRef();
|
|
}
|
|
IStorage* GetSTORAGE()
|
|
{
|
|
_ValidateGet( VT_STORAGE );
|
|
return( pStorage );
|
|
}
|
|
CPropVariant & operator = ( IStorage *pStg )
|
|
{
|
|
Clear();
|
|
SetSTORAGE( pStg );
|
|
return (*this);
|
|
}
|
|
operator IStorage*()
|
|
{
|
|
return( GetSTORAGE() );
|
|
}
|
|
|
|
|
|
// VT_LPSTR (LPSTR)
|
|
|
|
CPropVariant( const LPSTR psz )
|
|
{
|
|
Init();
|
|
SetLPSTR(psz);
|
|
}
|
|
void SetLPSTR(const LPSTR psz)
|
|
{
|
|
Clear();
|
|
pszVal = (LPSTR) CoTaskMemAlloc( strlen(psz) + 1 );
|
|
if( NULL == pszVal )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Failed CoTaskMemAlloc for VT_LPSTR") );
|
|
vt = VT_LPSTR;
|
|
strcpy( pszVal, psz );
|
|
}
|
|
void SetLPSTR( const LPSTR psz, ULONG pos )
|
|
{
|
|
if( vt != (VT_LPSTR | VT_VECTOR) ) Clear();
|
|
_AddStringToVector( pos, psz, strlen(psz) + 1, VT_LPSTR );
|
|
vt = VT_LPSTR | VT_VECTOR;
|
|
}
|
|
LPSTR GetLPSTR()
|
|
{
|
|
_ValidateGet( VT_LPSTR );
|
|
return( pszVal );
|
|
}
|
|
LPSTR GetLPSTR( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_LPSTR, pos );
|
|
return( calpstr.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(const LPSTR psz)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_LPSTR,LPSTR>(this, psz);
|
|
return (*this);
|
|
}
|
|
operator LPSTR()
|
|
{
|
|
return TCPropVarConversionOperator<VT_LPSTR,CALPSTR,LPSTR>
|
|
( this, &calpstr, &pszVal );
|
|
}
|
|
|
|
|
|
// VT_LPWSTR (LPWSTR)
|
|
|
|
CPropVariant( const LPWSTR pwsz )
|
|
{
|
|
Init();
|
|
SetLPWSTR(pwsz);
|
|
}
|
|
void SetLPWSTR(const LPWSTR pwsz)
|
|
{
|
|
Clear();
|
|
pwszVal = (LPWSTR) CoTaskMemAlloc( sizeof(WCHAR) * (wcslen(pwsz) + 1) );
|
|
if( NULL == pwszVal )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Failed CoTaskMemAlloc for VT_LPWSTR") );
|
|
vt = VT_LPWSTR;
|
|
wcscpy( pwszVal, pwsz );
|
|
}
|
|
void SetLPWSTR( const LPWSTR pwsz, ULONG pos )
|
|
{
|
|
if( vt != (VT_LPWSTR | VT_VECTOR) ) Clear();
|
|
_AddStringToVector( pos, pwsz, 2 * (wcslen(pwsz) + 1), VT_LPWSTR );
|
|
vt = VT_LPWSTR | VT_VECTOR;
|
|
}
|
|
LPWSTR GetLPWSTR()
|
|
{
|
|
_ValidateGet( VT_LPWSTR );
|
|
return( pwszVal );
|
|
}
|
|
LPWSTR GetLPWSTR( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_LPWSTR, pos );
|
|
return( calpwstr.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(const LPWSTR pwsz)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_LPWSTR,LPWSTR>(this, pwsz);
|
|
return (*this);
|
|
}
|
|
operator LPWSTR()
|
|
{
|
|
return TCPropVarConversionOperator<VT_LPWSTR,CALPWSTR,LPWSTR>
|
|
( this, &calpwstr, &pwszVal );
|
|
}
|
|
|
|
|
|
// VT_CF (CLIPDATA*)
|
|
|
|
CPropVariant( const CLIPDATA *pclip )
|
|
{
|
|
Init();
|
|
SetCF(pclip);
|
|
}
|
|
void SetCF( const CLIPDATA *pclip );
|
|
void SetCF( const CLIPDATA *pclip, ULONG pos );
|
|
CLIPDATA* GetCF()
|
|
{
|
|
_ValidateGet( VT_CF );
|
|
return( pclipdata );
|
|
}
|
|
CLIPDATA* GetCF( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_CF, pos );
|
|
return( &caclipdata.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator= ( const CLIPDATA *pclip )
|
|
{
|
|
TCPropVarAssignmentOperator<VT_CF,const CLIPDATA*>(this, pclip);
|
|
return (*this);
|
|
}
|
|
CPropVariant & operator= ( const CLIPDATA &clip )
|
|
{
|
|
TCPropVarAssignmentOperator<VT_CF,const CLIPDATA*>(this, &clip);
|
|
return (*this);
|
|
}
|
|
CPropVariant & operator= ( CClipData &cclipdata )
|
|
{
|
|
// This parameter should be const, but when it is, the compiler won't
|
|
// convert it to (const CLIPDATA*).
|
|
|
|
TCPropVarAssignmentOperator<VT_CF,const CLIPDATA*>(this, (const CLIPDATA*)cclipdata);
|
|
return (*this);
|
|
}
|
|
operator CLIPDATA*()
|
|
{
|
|
// We can't use TCPropVarConversionOperator template, because the caclipdata
|
|
// member holds different types (CLIPDATA) than does the pclipdata
|
|
// member (CLIPDATA*). The template assumes that the singleton properties
|
|
// and vector properties are of the same type.
|
|
|
|
if( wReserved1 > 0 )
|
|
{
|
|
USHORT usSubscript = wReserved1 - 1;
|
|
wReserved1 = 0;
|
|
return GetCF( usSubscript );
|
|
}
|
|
else
|
|
{
|
|
return GetCF();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// VT_BLOB (BLOB*)
|
|
|
|
CPropVariant(const BLOB &blobIn)
|
|
{
|
|
Init();
|
|
SetBLOB(blobIn);
|
|
}
|
|
void SetBLOB(const BLOB &blobIn)
|
|
{
|
|
Clear();
|
|
blob.pBlobData = (BYTE*) CoTaskMemAlloc( blobIn.cbSize );
|
|
if( NULL == blob.pBlobData )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("CPropVariant couldn't alloc for VT_BLOB") );
|
|
|
|
memcpy( blob.pBlobData, blobIn.pBlobData, blobIn.cbSize );
|
|
blob.cbSize = blobIn.cbSize;
|
|
vt = VT_BLOB;
|
|
}
|
|
BLOB GetBLOB()
|
|
{
|
|
_ValidateGet( VT_BLOB );
|
|
return( blob );
|
|
}
|
|
CPropVariant & operator=(const BLOB &blobIn)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_BLOB,BLOB>(this, blobIn);
|
|
return (*this);
|
|
}
|
|
operator BLOB()
|
|
{
|
|
return( GetBLOB() );
|
|
}
|
|
|
|
|
|
CPropVariant( const CBlob &cblobIn )
|
|
{
|
|
Init();
|
|
SetBLOB( *(BLOB*) &cblobIn );
|
|
}
|
|
CPropVariant &operator = (CBlob &cblobIn)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_BLOB,BLOB>(this, *(BLOB*)&cblobIn );
|
|
return( *this );
|
|
}
|
|
|
|
|
|
|
|
// VT_BSTR (BSTR)
|
|
|
|
|
|
void SetBSTR(const BSTR bstrIn)
|
|
{
|
|
Clear();
|
|
bstrVal = SysAllocString( bstrIn );
|
|
if( NULL == bstrIn )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Failed CoTaskMemAlloc for VT_BSTR") );
|
|
vt = VT_BSTR;
|
|
}
|
|
void SetBSTR( const BSTR bstrIn, ULONG pos );
|
|
LPWSTR GetBSTR()
|
|
{
|
|
_ValidateGet( VT_BSTR );
|
|
return( bstrVal );
|
|
}
|
|
LPWSTR GetBSTR( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_BSTR, pos );
|
|
return( cabstr.pElems[ pos ] );
|
|
}
|
|
|
|
|
|
// VT_BOOL (VARIANT_BOOL)
|
|
|
|
void SetBOOL( VARIANT_BOOL boolIn)
|
|
{
|
|
Clear();
|
|
boolVal = boolIn;
|
|
vt = VT_BOOL;
|
|
}
|
|
void SetBOOL( VARIANT_BOOL boolIn, ULONG pos )
|
|
{
|
|
if( vt != (VT_BOOL | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &boolIn, sizeof(boolIn) );
|
|
vt = VT_BOOL | VT_VECTOR;
|
|
}
|
|
BOOL GetBOOL()
|
|
{
|
|
_ValidateGet( VT_BOOL );
|
|
return( boolVal );
|
|
}
|
|
BOOL GetBOOL( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_BOOL, pos );
|
|
return( cabool.pElems[ pos ] );
|
|
}
|
|
|
|
// VT_ERROR (SCODE)
|
|
|
|
void SetERROR( SCODE scodeIn)
|
|
{
|
|
Clear();
|
|
scode = scodeIn;
|
|
vt = VT_ERROR;
|
|
}
|
|
void SetERROR( SCODE scodeIn, ULONG pos )
|
|
{
|
|
if( vt != (VT_ERROR | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &scodeIn, sizeof(scodeIn) );
|
|
vt = VT_ERROR | VT_VECTOR;
|
|
}
|
|
BOOL GetERROR()
|
|
{
|
|
_ValidateGet( VT_ERROR );
|
|
return( scode );
|
|
}
|
|
BOOL GetERROR( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_ERROR, pos );
|
|
return( cascode.pElems[ pos ] );
|
|
}
|
|
|
|
// VT_DATE (DATE)
|
|
|
|
void SetDATE( DATE dateIn)
|
|
{
|
|
Clear();
|
|
date = dateIn;
|
|
vt = VT_DATE;
|
|
}
|
|
void SetDATE( DATE dateIn, ULONG pos)
|
|
{
|
|
if( vt != (VT_DATE | VT_VECTOR) ) Clear();
|
|
_AddScalerToVector( pos, &dateIn, sizeof(dateIn) );
|
|
vt = VT_DATE | VT_VECTOR;
|
|
}
|
|
DATE GetDATE()
|
|
{
|
|
_ValidateGet( VT_DATE );
|
|
return( date );
|
|
}
|
|
DATE GetDATE( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_DATE, pos );
|
|
return( cadate.pElems[ pos ] );
|
|
}
|
|
|
|
// VT_VARIANT (PROPVARIANT)
|
|
|
|
void SetPROPVARIANT( PROPVARIANT &propvar, ULONG pos );
|
|
PROPVARIANT &GetPROPVARIANT( ULONG pos )
|
|
{
|
|
_ValidateGet( VT_VARIANT, pos );
|
|
return( capropvar.pElems[ pos ] );
|
|
}
|
|
CPropVariant & operator=(PROPVARIANT &propvar);
|
|
operator PROPVARIANT&()
|
|
{
|
|
return( GetPROPVARIANT( wReserved1 ) );
|
|
}
|
|
|
|
|
|
// VT_DECIMAL (DECIMAL)
|
|
|
|
void SetDECIMAL( const DECIMAL &decimal )
|
|
{
|
|
Clear();
|
|
decVal = decimal;
|
|
vt = VT_DECIMAL;
|
|
}
|
|
DECIMAL GetDECIMAL()
|
|
{
|
|
_ValidateGet( VT_DECIMAL );
|
|
return( decVal );
|
|
}
|
|
|
|
CPropVariant & operator=(const DECIMAL &decimal)
|
|
{
|
|
TCPropVarAssignmentOperator<VT_DECIMAL,DECIMAL>(this, decimal);
|
|
return (*this);
|
|
}
|
|
operator DECIMAL()
|
|
{
|
|
return( GetDECIMAL() );
|
|
}
|
|
|
|
public:
|
|
|
|
CPropVariant & operator[] (int nSubscript)
|
|
{
|
|
wReserved1 = (WORD) nSubscript + 1;
|
|
return (*this);
|
|
}
|
|
|
|
LPPROPVARIANT operator&()
|
|
{
|
|
return( this );
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
VARTYPE VarType() const
|
|
{
|
|
return( vt );
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
PropVariantClear( this );
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
PropVariantInit( this );
|
|
wReserved1 = INVALID_SUBSCRIPT;
|
|
}
|
|
|
|
ULONG Count() const
|
|
{
|
|
if( vt & VT_VECTOR )
|
|
return caui.cElems;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
void SetVarType(VARTYPE vtNew)
|
|
{
|
|
PropVariantClear( this );
|
|
vt = vtNew;
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
static HRESULT Compare( PROPVARIANT* ppropvar1, PROPVARIANT *ppropvar2 );
|
|
|
|
private:
|
|
|
|
VOID *_AddStringToVector(
|
|
unsigned pos,
|
|
const VOID *pv,
|
|
ULONG cb,
|
|
VARTYPE vtNew );
|
|
|
|
VOID *_AddScalerToVector(
|
|
unsigned pos,
|
|
const VOID *pv,
|
|
ULONG cb);
|
|
|
|
void _ValidateGet( const VARTYPE vtGet )
|
|
{
|
|
if( vtGet != vt )
|
|
throw CHRESULT( (HRESULT) ERROR_INVALID_DATATYPE, OLESTR("Attempt to get incorrect type") );
|
|
}
|
|
|
|
void _ValidateGet( const VARTYPE vtGet, const ULONG pos )
|
|
{
|
|
_ValidateGet( vtGet | VT_VECTOR );
|
|
|
|
if( INVALID_SUBSCRIPT == pos
|
|
||
|
|
pos >= caub.cElems
|
|
)
|
|
{
|
|
throw CHRESULT( (HRESULT) ERROR_INVALID_DATATYPE, OLESTR("Attempt to get a non-existent vector element") );
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CPropSpec : public PROPSPEC
|
|
{
|
|
public:
|
|
|
|
CPropSpec()
|
|
{
|
|
ulKind = PRSPEC_PROPID;
|
|
propid = 0;
|
|
}
|
|
|
|
~CPropSpec()
|
|
{
|
|
FreeResources();
|
|
this->CPropSpec::CPropSpec();
|
|
}
|
|
|
|
void FreeResources()
|
|
{
|
|
if( PRSPEC_LPWSTR == ulKind )
|
|
{
|
|
CoTaskMemFree( lpwstr );
|
|
lpwstr = NULL;
|
|
}
|
|
}
|
|
|
|
void Alloc( ULONG cch )
|
|
{
|
|
ULONG cb = sizeof(OLECHAR)*cch + sizeof(OLECHAR);
|
|
lpwstr = (LPOLESTR) CoTaskMemAlloc( cb );
|
|
}
|
|
|
|
|
|
|
|
operator PROPSPEC*()
|
|
{
|
|
return( this );
|
|
}
|
|
|
|
PROPSPEC* operator&()
|
|
{
|
|
return( this );
|
|
}
|
|
operator CPropSpec&()
|
|
{
|
|
return( *this );
|
|
}
|
|
|
|
CPropSpec( LPCOLESTR posz )
|
|
{
|
|
memset( this, 0, sizeof(PROPSPEC) );
|
|
this->operator=(posz);
|
|
}
|
|
CPropSpec & operator = (LPCOLESTR posz)
|
|
{
|
|
FreeResources();
|
|
|
|
Alloc( ocslen(posz) );
|
|
if( NULL != lpwstr )
|
|
{
|
|
ocscpy( lpwstr, posz );
|
|
ulKind = PRSPEC_LPWSTR;
|
|
}
|
|
|
|
return( *this );
|
|
}
|
|
|
|
CPropSpec & operator = (PROPID propidNew)
|
|
{
|
|
FreeResources();
|
|
|
|
ulKind = PRSPEC_PROPID;
|
|
propid = propidNew;
|
|
|
|
return( *this );
|
|
}
|
|
|
|
OLECHAR & operator[]( int i )
|
|
{
|
|
ulKind = PRSPEC_LPWSTR;
|
|
return( this->lpwstr[ i ] );
|
|
}
|
|
|
|
OLECHAR & operator[]( ULONG i )
|
|
{
|
|
ulKind = PRSPEC_LPWSTR;
|
|
return( this->lpwstr[ i ] );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
class CBlob : public BLOB
|
|
{
|
|
public:
|
|
|
|
~CBlob()
|
|
{
|
|
if( NULL != pBlobData )
|
|
CoTaskMemFree( pBlobData );
|
|
}
|
|
|
|
CBlob( LPSTR psz )
|
|
{
|
|
ULONG cb = 0;
|
|
|
|
if( NULL != psz )
|
|
{
|
|
cb = strlen( psz ) + sizeof(CHAR);
|
|
}
|
|
|
|
pBlobData = (BYTE*) CoTaskMemAlloc( cb );
|
|
if( NULL == pBlobData )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Couldn't allocate for CBlob") );
|
|
|
|
cbSize = cb;
|
|
memcpy( pBlobData, psz, cbSize );
|
|
}
|
|
|
|
CBlob( LPWSTR pwsz )
|
|
{
|
|
ULONG cb = 0;
|
|
|
|
if( NULL != pwsz )
|
|
{
|
|
cb = wcslen( pwsz ) + sizeof(WCHAR);
|
|
}
|
|
|
|
pBlobData = (BYTE*) CoTaskMemAlloc( cb + sizeof(cb) );
|
|
if( NULL == pBlobData )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Couldn't allocate for CBlob") );
|
|
|
|
cbSize = cb;
|
|
memcpy( pBlobData, pwsz, cbSize );
|
|
}
|
|
|
|
CBlob( ULONG cb )
|
|
{
|
|
pBlobData = (BYTE*) CoTaskMemAlloc( cb );
|
|
if( NULL == pBlobData )
|
|
throw CHRESULT( (HRESULT) E_OUTOFMEMORY, OLESTR("Couldn't allocate for CBlob") );
|
|
|
|
cbSize = cb;
|
|
memset( pBlobData, 0, cb );
|
|
}
|
|
|
|
CBlob( int cb )
|
|
{
|
|
this->CBlob::CBlob( (ULONG) cb );
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
inline BOOL operator == ( CPropVariant &cpropvar1, CPropVariant &cpropvar2 )
|
|
{
|
|
return( S_OK == CPropVariant::Compare(&cpropvar1, &cpropvar2) );
|
|
}
|
|
inline BOOL operator == ( CPropVariant &cpropvar, PROPVARIANT &propvar )
|
|
{
|
|
return( (HRESULT) S_OK == CPropVariant::Compare(&cpropvar, &propvar) );
|
|
}
|
|
inline BOOL operator == ( PROPVARIANT &propvar, CPropVariant &cpropvar )
|
|
{
|
|
return( (HRESULT) S_OK == CPropVariant::Compare(&cpropvar, &propvar) );
|
|
}
|
|
inline BOOL operator == ( PROPVARIANT propvar1, PROPVARIANT propvar2)
|
|
{
|
|
return( (HRESULT) S_OK == CPropVariant::Compare(&propvar1, &propvar2) );
|
|
}
|
|
|
|
inline BOOL operator != ( CPropVariant &cpropvar1, CPropVariant &cpropvar2 )
|
|
{
|
|
return( (HRESULT) S_FALSE == CPropVariant::Compare(&cpropvar1, &cpropvar2) );
|
|
}
|
|
inline BOOL operator != ( CPropVariant &cpropvar, PROPVARIANT &propvar )
|
|
{
|
|
return( (HRESULT) S_FALSE == CPropVariant::Compare(&cpropvar, &propvar) );
|
|
}
|
|
inline BOOL operator != ( PROPVARIANT &propvar, CPropVariant &cpropvar )
|
|
{
|
|
return( (HRESULT) S_FALSE == CPropVariant::Compare(&cpropvar, &propvar) );
|
|
}
|
|
inline BOOL operator != ( PROPVARIANT &propvar1, PROPVARIANT &propvar2)
|
|
{
|
|
return( (HRESULT) S_FALSE == CPropVariant::Compare(&propvar1, &propvar2) );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif // !_CPROPVAR_HXX_
|