//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 1999.
//
// File: propbase.hxx
//
// Contents: Headers for common property handling routines
//
// Classes: CUtlPropInfo,
// CUtlProps
//
// History: 10-28-97 danleg Created from monarch uprops.hpp
//
//----------------------------------------------------------------------------
#pragma once
//
// Constants and Static Struct
//
#define DEFAULT_MACHINE L"."
const ULONG DWORDSNEEDEDPERSET = 2;
const ULONG DWORDSNEEDEDTOTAL = DWORDSNEEDEDPERSET * 5;
//
// Macros
//
#define INRANGE(z,zmin,zmax) ( (zmin) <= (z) && (z) <= (zmax) )
//
// Utility functions
//
// Bit array routines.
// Two versions: one for a single DWORD, one for arrays.
// Note that you pass in not a bit mask, but the bit number.
// i.e. dwBit = 0,1,2,3,4...31 instead of 1,2,4,8,0x10,0x20...
inline void SETBIT( DWORD &dwFlags, DWORD dwBit )
{
dwFlags |= 1 << dwBit;
}
inline void CLEARBIT( DWORD &dwFlags, DWORD dwBit )
{
dwFlags &= ~ (1<<dwBit);
}
inline DWORD TESTBIT( DWORD &dwFlags, DWORD dwBit )
{
return (dwFlags & (1<<dwBit)) != 0;
}
// Routines based on array-of-DWORD.
// Use these like a bit array, from 0...n-1.
#define DivDword(dw) (dw >> 5) // dw / 32 = dw / (sizeof(DWORD)*8)
#define ModDword(dw) (dw & (32-1)) // dw % 32
#define DwordSizeofBits(nBits) (nBits/32+1) // Use in array declarations
inline void SETBIT( DWORD rgdwFlags[], const DWORD dwBit )
{
rgdwFlags[DivDword(dwBit)] |= 1 << ModDword(dwBit);
}
inline void CLEARBIT( DWORD rgdwFlags[], const DWORD dwBit )
{
rgdwFlags[DivDword(dwBit)] &= ~( 1 << ModDword(dwBit) );
}
#define CLEARBITARRAY( rgdwFlags ) RtlZeroMemory( rgdwFlags, sizeof(rgdwFlags) )
inline DWORD TESTBIT( const DWORD rgdwFlags[], const DWORD dwBit )
{
//old//Note: Not {0,1}, but from {0...2^32-1}.
// Note: Now returns {0,1}.
return ( rgdwFlags[DivDword(dwBit)] & ( 1 << ModDword(dwBit) ) ) != 0;
}
#undef DivDWord
#undef ModDWord
//
// Forward Declarations
//
class CColumnIds;
//
// Constants and Static Struct
//
// leave plenty of space for localization.
const ULONG CCH_GETPROPERTYINFO_DESCRIP_BUFFER_SIZE = 256;
const DWORD GETPROPINFO_ALLPROPIDS = 0x0001;
const DWORD GETPROPINFO_NOTSUPPORTED = 0x0002;
const DWORD GETPROPINFO_ERRORSOCCURRED = 0x0004;
const DWORD GETPROPINFO_VALIDPROP = 0x0008;
const DWORD GETPROP_ALLPROPIDS = 0x0001;
const DWORD GETPROP_NOTSUPPORTED = 0x0002;
const DWORD GETPROP_ERRORSOCCURRED = 0x0004;
const DWORD GETPROP_VALIDPROP = 0x0008;
const DWORD GETPROP_PROPSINERROR = 0x0010;
const DWORD SETPROP_BADOPTION = 0x0001;
const DWORD SETPROP_NOTSUPPORTED = 0x0002;
const DWORD SETPROP_VALIDPROP = 0x0004;
const DWORD SETPROP_ERRORS = 0x0008;
const DWORD SETPROP_COLUMN_LEVEL = 0x0010;
const DWORD DBINTERNFLAGS_NOCHANGE = 0x00000000;
const DWORD DBINTERNFLAGS_CHANGED = 0x00000001;
const DWORD DBINTERNFLAGS_CHEAPTOREQ = 0x00000002;
const DWORD DBINTERNFLAGS_INERROR = 0x00000004;
const DWORD DBINTERNFLAGS_INERRORSAVED = 0x00000008;
const DWORD DBINTERNFLAGS_TOTRUE = 0x80000000;
// Additional Property Flags needed internally
const DWORD DBPROPFLAGS_CHANGE = 0x80000000;
// Flags for controlling UPROPSETS
const DWORD UPROPSET_HIDDEN = 0x00000001;
const DWORD UPROPSET_PASSTHROUGH = 0x00000002;
// Rules for GetPropertiesArgChk
const DWORD ARGCHK_PROPERTIESINERROR = 0x00000001;
//
// STRUCTURE DEFINITIONS
//
typedef struct tagPropColId* PPROPCOLID;
typedef struct tagUPROPVAL
{
DBPROPOPTIONS dwOption;
DWORD dwFlags;
VARIANT vValue;
} UPROPVAL;
typedef struct tagUPROPINFO
{
DBPROPID dwPropId;
LPCWSTR pwszDesc;
VARTYPE VarType;
DBPROPFLAGS dwFlags;
} UPROPINFO;
typedef struct tagUPROP
{
ULONG cPropIds;
UPROPINFO** rgpUPropInfo;
UPROPVAL* pUPropVal;
} UPROP;
typedef struct tagUPROPSET
{
const GUID* pPropSet;
ULONG cUPropInfo;
const UPROPINFO* pUPropInfo;
DWORD dwFlags;
} UPROPSET;
//+-------------------------------------------------------------------------
//
// Class: CUtlPropInfo
//
// Purpose: Base class for property storage
//
// History: 11-12-97 danleg Created from Monarch
//
//--------------------------------------------------------------------------
class CUtlPropInfo
{
public:
//
// Ctor / Dtor
//
CUtlPropInfo();
virtual ~CUtlPropInfo() { };
SCODE GetPropertyInfo ( ULONG cPropertySets,
const DBPROPIDSET rgPropertySets[],
ULONG * pcPropertyInfoSets,
DBPROPINFOSET ** prgPropertyInfoSets,
WCHAR ** ppDescBuffer );
//
// Get the count of propsets.
//
ULONG GetUPropSetCount() { return _cUPropSet; }
//
// Reset the count of propsets.
//
void SetUPropSetCount( ULONG c ) { _cUPropSet = c; }
//
// Pure Virtual
//
virtual SCODE InitAvailUPropSets(
ULONG * pcUPropSet,
UPROPSET ** ppUPropSet,
ULONG * pcElemPerSupported )=0;
virtual SCODE InitUPropSetsSupported(
DWORD * rgdwSupported )=0;
//
// Load a localized description
//
virtual ULONG LoadDescription ( LPCWSTR pwszDesc,
PWSTR pwszBuff,
ULONG cchBuff )=0;
protected:
//
// Initialization routine called called from constructors of derived
// classes.
//
void FInit();
private:
//
// Count of UPropSet items
//
ULONG _cUPropSet;
//
// Pointer to UPropset items
//
UPROPSET * _pUPropSet;
//
// Count of UPropSet Indexes
//
ULONG _cPropSetDex;
//
// Pointer to Array of UPropSet Index values
//
XArray<ULONG> _xaiPropSetDex;
//
// Number of DWORDS per UPropSet to indicate supported UPropIds
//
ULONG _cElemPerSupported;
//
// Pointer to array of DWORDs indicating supported UPropIds
//
XArray<DWORD> _xadwSupported;
//
// Member functions
//
// Retrieve the property id pointer
SCODE GetUPropInfoPtr ( ULONG iPropSetDex,
DBPROPID dwPropertyId,
UPROPINFO ** ppUPropInfo );
// Retrieve the property set indexes that match this property set.
SCODE GetPropertySetIndex( const GUID * pPropertySet );
// Determine the number of description buffers needed
ULONG CalcDescripBuffers( ULONG cPropInfoSet,
DBPROPINFOSET* pPropInfoSet );
};
//+-------------------------------------------------------------------------
//
// Class: CUtlProps
//
// Purpose: Base class for property storage
//
// History: 11-12-97 danleg Created from Monarch
//
//--------------------------------------------------------------------------
class CUtlProps
{
public:
//
// Ctor / Dtor
//
CUtlProps( DWORD dwFlags = 0 );
virtual ~CUtlProps();
//
// Fill default values again.
//
SCODE FillDefaultValues(ULONG ulPropSetTarget = ULONG_MAX);
//
// Check the arguments for Retrieve Properties
//
void GetPropertiesArgChk( const ULONG cPropertySets,
const DBPROPIDSET rgPropertySets[],
ULONG * pcProperties,
DBPROPSET ** prgProperties );
//
// Check the arguments for Set Properties
//
static void SetPropertiesArgChk( const ULONG cPropertySets,
const DBPROPSET rgPropertySets[] );
//
// Retrieve Properties
//
SCODE GetProperties ( const ULONG cPropertySets,
const DBPROPIDSET rgPropertySets[],
ULONG * pcProperties,
DBPROPSET ** prgProperties );
//
// Set Properties
//
SCODE SetProperties ( const ULONG cPropertySets,
const DBPROPSET rgPropertySets[] );
inline void SetPropertyInError(
const ULONG iPropSet,
const ULONG iPropId );
inline void ClearPropertyInError( ) ;
BOOL IsPropSet ( const GUID * pguidPropSet,
DBPROPID dwPropId );
SCODE GetPropValue ( const GUID * pguidPropSet,
DBPROPID dwPropId,
VARIANT * pvValue );
SCODE SetPropValue ( const GUID * pguidPropSet,
DBPROPID dwPropId,
VARIANT * pvValue );
SCODE CopyUPropVal ( ULONG iPropSet,
UPROPVAL * rgUPropVal );
//
// Virtuals functions
//
virtual SCODE GetIndexofPropSet( const GUID * pPropSet,
ULONG * pulCurSet );
virtual SCODE GetIndexofPropIdinPropSet(
ULONG iCurSet,
DBPROPID dwPropertyId,
ULONG * piCurPropId );
//
// Pure Virtuals
//
virtual SCODE InitAvailUPropSets( ULONG * pcUPropSet,
UPROPSET ** ppUPropSet,
ULONG * pcElemPerSupported )=0;
virtual SCODE GetDefaultValue ( ULONG iPropSet,
DBPROPID dwPropId,
DWORD * dwOption,
VARIANT * pVar )=0;
virtual SCODE IsValidValue ( ULONG iCurSet,
DBPROP * pDBProp )=0;
virtual SCODE InitUPropSetsSupported( DWORD * rgdwSupported) = 0;
//
// Inlined functions
//
inline ULONG GetUPropSetCount() { return _cUPropSet; }
inline void SetUPropSetCount( ULONG c ) { _cUPropSet = c; }
//
// NOTE: The following functions depend on all prior properties in the
// array being writable. This is because the UPROP array contains only
// writable elements, and the UPROPINFO array contains writable and
// read-only elements. If this is a problem, we would need to define
// which one it came from and add the appropriate asserts...
//
// Get DBPROPOPTIONS_xx
inline DWORD GetPropOption ( ULONG iPropSet,
ULONG iProp );
// Set DBPROPOPTIONS_xx
inline void SetPropOption ( ULONG iPropSet,
ULONG iProp,
DWORD dwOption );
//
// Determine if property is required and variant_true
//
inline BOOL IsRequiredTrue ( ULONG iPropSet,
ULONG iProp );
inline DWORD GetInternalFlags( ULONG iPropSet,
ULONG iProp );
inline void AddInternalFlags( ULONG iPropSet,
ULONG iProp,
DWORD dwFlag );
inline void RemoveInternalFlags (
ULONG iPropSet,
ULONG iProp,
DWORD dwFlag );
inline VARIANT * GetVariant ( ULONG iPropSet,
ULONG iProp );
inline SCODE SetVariant ( ULONG iPropSet,
ULONG iProp,
VARIANT * pv );
inline void SetValEmpty ( ULONG iPropSet,
ULONG iProp );
inline BOOL IsEmpty ( ULONG iPropSet,
ULONG iProp );
inline void SetValBool ( ULONG iPropSet,
ULONG iProp,
VARIANT_BOOL bVal );
inline VARIANT_BOOL GetValBool ( ULONG iPropSet,
ULONG iProp );
inline void SetValShort ( ULONG iPropSet,
ULONG iProp,
SHORT iVal );
inline SHORT GetValShort ( ULONG iPropSet,
ULONG iProp );
inline void SetValLong ( ULONG iPropSet,
ULONG iProp,
LONG lVal );
inline LONG GetValLong ( ULONG iPropSet,
ULONG iProp );
inline SCODE SetValString ( ULONG iPropSet,
ULONG iProp,
const WCHAR * pwsz );
inline const WCHAR * GetValString(
ULONG iPropSet,
ULONG iProp );
inline const GUID * GetGuid ( ULONG iPropSet);
inline DWORD GetPropID ( ULONG iPropSet,
ULONG iProp );
inline VARTYPE GetExpectedVarType( ULONG iPropSet,
ULONG iProp );
// Inline Methods
inline void CopyAvailUPropSets( ULONG * pcUPropSet,
UPROPSET ** ppUPropSet,
ULONG * pcElemPerSupported );
inline void CopyUPropSetsSupported(
XArray<DWORD> & xadwSupported );
inline void CopyUPropInfo ( ULONG iPropSet,
XArray<UPROPINFO*> & xapUPropInfo );
protected:
//
// Number of DWORDS per UPropSet to indicate supported UPropIds
//
ULONG _cElemPerSupported;
//
// Pointer to array of DWORDs indicating supported UPropIds
//
XArray<DWORD> _xadwSupported;
//
// Pointer to array of DWORDs indicating if property is in error
//
XArray<DWORD> _xadwPropsInError;
//
// Initialization Method
//
virtual void FInit ( CUtlProps * pCopyMe = NULL );
private:
//
// Count of UPropSet items
//
ULONG _cUPropSet;
//
//Pointer to UPropset items
//
UPROPSET * _pUPropSet;
XArray<UPROP> _xaUProp;
//
// Count of Hidden items
//
ULONG _cUPropSetHidden;
//
// Configuration flags
//
DWORD _dwFlags;
//
// Count of UPropSet Indexes
//
ULONG _cPropSetDex;
//
// Pointer to Array of UPropSet Index values
//
XArray<ULONG> _xaiPropSetDex;
void FreeMemory ( );
ULONG GetCountofWritablePropsInPropSet(
ULONG iPropSet );
ULONG GetUPropValIndex( ULONG iCurset,
DBPROPID dwPropId);
SCODE SetProperty ( ULONG iCurSet,
ULONG iCurProp,
DBPROP * pDBProp);
//
// Retrieve the property set indexes that
// match this property set.
//
SCODE GetPropertySetIndex( GUID * pPropertySet );
};
// --------------------------------------------------------------------------
// -------------------- I N L I N E F U N C T I O N S ----------------------
// --------------------------------------------------------------------------
inline void CUtlProps::CopyAvailUPropSets
(
ULONG* pcUPropSet,
UPROPSET** ppUPropSet,
ULONG* pcElemPerSupported
)
{
Win4Assert( pcUPropSet && ppUPropSet && pcElemPerSupported );
*pcUPropSet = _cUPropSet;
*ppUPropSet = _pUPropSet;
*pcElemPerSupported = _cElemPerSupported;
}
inline void CUtlProps::CopyUPropSetsSupported
(
XArray<DWORD> & xadwSupported
)
{
// if the passed in array already has elements, we will leak
Win4Assert( xadwSupported.IsNull() );
xadwSupported.Init( _xadwSupported );
//RtlCopyMemory( xadwSupported.GetPointer(),
// _xadwSupported.GetPointer(),
// _cUPropSet * _cElemPerSupported * sizeof(DWORD) );
}
inline void CUtlProps::CopyUPropInfo
(
ULONG iPropSet,
XArray<UPROPINFO*> & xapUPropInfo
)
{
Win4Assert( xapUPropInfo.IsNull() );
Win4Assert( iPropSet < _cUPropSet );
xapUPropInfo.Init( _xaUProp[iPropSet].cPropIds );
RtlCopyMemory( xapUPropInfo.GetPointer(),
_xaUProp[iPropSet].rgpUPropInfo,
xapUPropInfo.SizeOf() );
}
inline void CUtlProps::ClearPropertyInError()
{
Win4Assert( !_xadwPropsInError.IsNull() );
RtlZeroMemory( _xadwPropsInError.GetPointer(), _cUPropSet * _cElemPerSupported * sizeof(DWORD) );
};
// Save a few lines by defining a common set of asserts.
#define is_proper_range \
( (iPropSet < _cUPropSet) \
&& (iProp < _pUPropSet[iPropSet].cUPropInfo) \
&& (iProp < _xaUProp[iPropSet].cPropIds) )
// Set Property Ids that should be in Error
inline void CUtlProps::SetPropertyInError
(
const ULONG iPropSet,
const ULONG iProp
)
{
SETBIT(&(_xadwPropsInError[iPropSet * _cElemPerSupported]), iProp);
};
// determine if the property is Required and VARIANT_TRUE
inline BOOL CUtlProps::IsRequiredTrue(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
Win4Assert(_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_BOOL);
Win4Assert(V_BOOL(&_xaUProp[iPropSet].pUPropVal[iProp].vValue) == VARIANT_TRUE
|| V_BOOL(&_xaUProp[iPropSet].pUPropVal[iProp].vValue) == VARIANT_FALSE);
return( !(_xaUProp[iPropSet].pUPropVal[iProp].dwFlags & DBINTERNFLAGS_INERROR) &&
(_xaUProp[iPropSet].pUPropVal[iProp].dwOption == DBPROPOPTIONS_REQUIRED) &&
(V_BOOL(&_xaUProp[iPropSet].pUPropVal[iProp].vValue) == VARIANT_TRUE) );
};
// Get DBPROPOPTIONS_xx
inline DWORD CUtlProps::GetPropOption(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return _xaUProp[iPropSet].pUPropVal[iProp].dwOption;
}
inline void CUtlProps::SetPropOption(ULONG iPropSet, ULONG iProp, DWORD dwOption)
{
Win4Assert( is_proper_range );
_xaUProp[iPropSet].pUPropVal[iProp].dwOption = dwOption;
}
inline DWORD CUtlProps::GetInternalFlags(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return _xaUProp[iPropSet].pUPropVal[iProp].dwFlags;
}
inline void CUtlProps::AddInternalFlags(ULONG iPropSet, ULONG iProp, DWORD dwFlags)
{
Win4Assert( is_proper_range );
_xaUProp[iPropSet].pUPropVal[iProp].dwFlags |= dwFlags;
}
inline void CUtlProps::RemoveInternalFlags(ULONG iPropSet, ULONG iProp, DWORD dwFlags)
{
Win4Assert( is_proper_range );
_xaUProp[iPropSet].pUPropVal[iProp].dwFlags &= ~dwFlags;
}
inline VARIANT * CUtlProps::GetVariant(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return & _xaUProp[iPropSet].pUPropVal[iProp].vValue;
}
inline SCODE CUtlProps::SetVariant(ULONG iPropSet, ULONG iProp, VARIANT *pv )
{
Win4Assert( is_proper_range );
// Does VariantClear first.
return VariantCopy( &_xaUProp[iPropSet].pUPropVal[iProp].vValue, pv );
}
inline void CUtlProps::SetValEmpty(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
VariantClear( &_xaUProp[iPropSet].pUPropVal[iProp].vValue );
}
inline BOOL CUtlProps::IsEmpty(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return ( _xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_EMPTY);
}
inline void CUtlProps::SetValBool(ULONG iPropSet, ULONG iProp, VARIANT_BOOL bVal )
{
Win4Assert( is_proper_range );
// Note that we accept any "true" value.
VariantClear(&_xaUProp[iPropSet].pUPropVal[iProp].vValue);
_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt = VT_BOOL;
V_BOOL(&_xaUProp[iPropSet].pUPropVal[iProp].vValue)
= (bVal ? VARIANT_TRUE : VARIANT_FALSE);
}
inline VARIANT_BOOL CUtlProps::GetValBool(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
Win4Assert(_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_BOOL);
return V_BOOL(&_xaUProp[iPropSet].pUPropVal[iProp].vValue);
}
inline void CUtlProps::SetValShort(ULONG iPropSet, ULONG iProp, SHORT iVal )
{
Win4Assert( is_proper_range );
VariantClear(&_xaUProp[iPropSet].pUPropVal[iProp].vValue);
_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt = VT_I2;
_xaUProp[iPropSet].pUPropVal[iProp].vValue.iVal = iVal;
}
inline SHORT CUtlProps::GetValShort(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
Win4Assert(_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_I2);
return _xaUProp[iPropSet].pUPropVal[iProp].vValue.iVal;
}
inline void CUtlProps::SetValLong(ULONG iPropSet, ULONG iProp, LONG lVal )
{
Win4Assert( is_proper_range );
VariantClear(&_xaUProp[iPropSet].pUPropVal[iProp].vValue);
_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt = VT_I4;
_xaUProp[iPropSet].pUPropVal[iProp].vValue.lVal = lVal;
}
// Get value as long
inline LONG CUtlProps::GetValLong(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
Win4Assert(_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_I4);
return _xaUProp[iPropSet].pUPropVal[iProp].vValue.lVal;
}
// Set value as string
inline SCODE CUtlProps::SetValString(ULONG iPropSet, ULONG iProp, const WCHAR *pwsz )
{
Win4Assert( is_proper_range );
VARIANT *pv = &_xaUProp[iPropSet].pUPropVal[iProp].vValue;
VariantClear(pv);
pv->bstrVal = SysAllocString(pwsz);
if ( pv->bstrVal )
pv->vt = VT_BSTR;
else
return E_FAIL;
// See if this was used for non-string type.
// Typically this is an easy way to pass integer as a string.
if ( GetExpectedVarType(iPropSet,iProp) == VT_BSTR )
return NOERROR;
if ( pwsz[0] != L'\0' )
return VariantChangeType( pv, pv, 0, GetExpectedVarType(iPropSet,iProp) );
// Set to "", which for non-string means empty.
SysFreeString(pv->bstrVal);
pv->vt = VT_EMPTY;
return NOERROR;
}
inline const WCHAR * CUtlProps::GetValString(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
Win4Assert(_xaUProp[iPropSet].pUPropVal[iProp].vValue.vt == VT_BSTR);
return _xaUProp[iPropSet].pUPropVal[iProp].vValue.bstrVal;
}
inline const GUID * CUtlProps::GetGuid(ULONG iPropSet)
{
Win4Assert(iPropSet < _cUPropSet);
return _pUPropSet[iPropSet].pPropSet;
}
inline DWORD CUtlProps::GetPropID(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return _pUPropSet[iPropSet].pUPropInfo[iProp].dwPropId;
}
inline VARTYPE CUtlProps::GetExpectedVarType(ULONG iPropSet, ULONG iProp)
{
Win4Assert( is_proper_range );
return _pUPropSet[iPropSet].pUPropInfo[iProp].VarType;
}
#undef is_proper_range