|
|
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//
// File: PropVar.c
//
// Purpose: This file provides Office-aware routines which
// operate on PropVariants. They are Office-aware in
// that they only operate on the subset of
// VarTypes which are used by Office.
//
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
#include "priv.h"
#pragma hdrstop
/////////////////////////////////////////////////////////////////////////////////
//
// Function: FPropVarLoad
//
// Purpse: Load data into a PropVariant. If the target PropVariant
// already contains data, it will be freed.
//
// Note that new memory is allocated, if necessary, to hold
// the data in the PropVariant. Also note that the
// resulting PropVariant should be freed by the caller using
// PropVariantClear.
//
// Inputs: LPPROPVARIANT - to be loaded. This should be a valid
// (i.e. intialized) PropVariant.
// VARTYPE - of the new PropVariant (must be a member of
// the limited set used by Office).
// LPVOID - Either the data to be loaded, or a pointer
// to such data, depending on the type.
//
// Output: TRUE if and only if successful.
//
/////////////////////////////////////////////////////////////////////////////////
BOOLFPropVarLoad ( LPPROPVARIANT lppropvar, VARTYPE vt, LPVOID const lpv ){ // ------
// Locals
// ------
BOOL fSuccess = FALSE; // Return code
ULONG cch, cb;
// ----------
// Initialize
// ----------
Assert (lppropvar != NULL); Assert (lpv != NULL);
// Free any data currently in the PropVariant.
PropVariantClear (lppropvar);
// ---------------------------------------------------
// Set the value of the PropVariant based on the type.
// ---------------------------------------------------
switch (vt) { // Strings
case VT_LPTSTR:
// Determine the character and byte count.
cch = CchTszLen(lpv); // Doesn't include the NULL.
cb = CBTSTR(lpv); // *Does* include the NULL.
// Allocate memory in the PropVariant.
lppropvar->pszVal = CoTaskMemAlloc (cb); if (lppropvar->pszVal == NULL) { MESSAGE(TEXT("Couldn't allocate new VT_LPTSTR")); goto Exit; }
// Copy the string to the PropVariant and terminate it.
PbSzNCopy (lppropvar->pszVal, lpv, cch); ((LPTSTR)lppropvar->pszVal)[cch] = TEXT('\0');
break;
// DWORDs
case VT_I4:
lppropvar->lVal = *(DWORD*) lpv; break;
// FileTime
case VT_FILETIME:
PbMemCopy (&lppropvar->filetime, lpv, sizeof(FILETIME)); break;
// Double
case VT_R8: PbMemCopy (&lppropvar->dblVal, lpv, sizeof(double)); break;
// Bool
case VT_BOOL: lppropvar->boolVal = *(VARIANT_BOOL*) lpv ? VARIANT_TRUE : VARIANT_FALSE; break;
// Invalid type.
default: MESSAGE(TEXT("Invalid VarType")); goto Exit; }
// Set the VT of the PropVariant, and we're done.
lppropvar->vt = vt;
// ----
// Exit
// ----
fSuccess = TRUE;
Exit: return (fSuccess);
} // FPropVarLoad
////////////////////////////////////////////////////////////////////////////////
//
// Function: FCoStrToWStr
//
// Purpose: Convert a COM string (ANSI) to a COM wide-string.
// ("COM" because the string is allocated using
// the COM heap).
//
// Inputs: LPWSTR* - The converted string.
// LPSTR - The original string.
// UINT - The ANSI code page.
//
// Output: TRUE if and only if successful.
//
////////////////////////////////////////////////////////////////////////////////
BOOLFCoStrToWStr( LPWSTR *lplpwstr, const LPSTR lpstr, UINT uCodePage){ // ------
// Locals
// ------
BOOL fSuccess = FALSE; // Return value.
ULONG cchBuffer = 0; // Size of converted string (includes NULL).
Assert (lpstr != NULL && lplpwstr != NULL);
// ------------------
// Convert the string
// ------------------
// Make two passes. The first will calculate the
// size of the target buffer, the second will actually
// make the conversion.
*lplpwstr = NULL;
while (TRUE) { cchBuffer = MultiByteToWideChar( uCodePage, // Source code page
0, // Default flags
lpstr, // Source string
-1, // Default length
*lplpwstr, // Destination string
cchBuffer ); // Max dest string characters.
// Is this the second pass (when the conversion should
// have taken place)?
if (*lplpwstr != NULL) { // If we got a good result, then we're done.
if (cchBuffer != 0) { break; }
// 0 was returned. There was an error.
else { AssertSz (0, TEXT("Couldn't convert MBCS to Wide")); goto Exit; } }
// Otherwise, this is the first pass. We need to
// allocate a buffer.
else { // We should have gotten a positive buffer size.
if (cchBuffer == 0) { AssertSz(0, TEXT("MultiByteToWideChar returned invalid target buffer size")); goto Exit; }
// Allocate memory for the converted string.
else { *lplpwstr = (LPWSTR) CoTaskMemAlloc( cchBuffer * 2 ); if ( *lplpwstr == NULL) { AssertSz (0, TEXT("Could not allocate memory for wide string")); goto Exit; } } } // if( *lplpwstr != NULL ... else
} // while (TRUE)
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
// If there was a problem, free the Unicode string.
if (!fSuccess) { CoTaskMemFree (*lplpwstr); *lplpwstr = NULL; }
return (fSuccess);
} // FCoStrToWStr
////////////////////////////////////////////////////////////////////////////////
//
// Function: FCoWStrToStr
//
// Purpose: Convert a COM wide-string to an ANSI string.
// ("COM" because the string is allocated using
// the COM heap).
//
// Inputs: LPSTR* - The converted string.
// LPWSTR - The source string.
// UINT - The ANSI code page.
//
// Output: TRUE if and only if successful.
//
////////////////////////////////////////////////////////////////////////////////
BOOLFCoWStrToStr( LPSTR *lplpstr, const LPWSTR lpwstr, UINT uCodePage){ // ------
// Locals
// ------
BOOL fSuccess = FALSE; // Return result
ULONG cch; // Charcters in original string (w/o NULL).
ULONG cbBuffer = 0; // Size of target buffer (including NULL)
Assert (lpwstr != NULL && lplpstr != NULL);
// ------------------
// Convert the String
// ------------------
// We'll make two calls to WideCharToMultiByte.
// In the first, we'll determine the size required
// for the multi-byte string. We'll use this
// to allocate memory. In the second pass, we'll actually
// make the conversion.
cch = CchWszLen( lpwstr ); // How big is the source string?
*lplpstr = NULL; // Initialize the target buffer.
while (TRUE) { cbBuffer = WideCharToMultiByte( uCodePage, // Source code page
0, // Default flags
lpwstr, // Source string
cch + 1, // # chars in wide string (including NULL)
*lplpstr, // Destination string
cbBuffer, // Size of destination buffer
NULL, NULL ); // No default character
// Is this the second pass (when the conversion should
// have taken place)?
if (*lplpstr != NULL) { // If we got a good result, then we're done.
if (cbBuffer != 0) { break; }
// 0 was returned. There was an error.
else { AssertSz (0, TEXT("Couldn't convert Wide to MBCS")); goto Exit; } }
// Otherwise, this is the first pass. We need to
// allocate a buffer.
else { // We should have gotten a positive buffer size.
if (cbBuffer == 0) { AssertSz(0, TEXT("WideCharMultiByte returned invalid target buffer size")); goto Exit; }
// Allocate memory for the converted string.
else { *lplpstr = (LPSTR) CoTaskMemAlloc( cbBuffer ); if ( *lplpstr == NULL) { AssertSz (0, TEXT("Could not allocate memory for wide string")); goto Exit; } } } // if( lpstr != NULL ... else
} // while (TRUE)
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
// If there was a problem, free the new string.
if (!fSuccess) { CoTaskMemFree (*lplpstr); *lplpstr = NULL; }
return (fSuccess);
} // FCoWStrToStr
//////////////////////////////////////////////////////////////////////////////
//
// Function: FPropVarConvertString
//
// Purpose: Convert a PropVariant from VT_LPSTR to VT_LPWSTR,
// or vice-versa. The correct direction is inferred
// from the input. The source PropVariant is not
// modified.
//
// If the PropVariant is a Vector, all elements are
// converted.
//
// Inputs: LPPROPVARIANT - The buffer in which to put the
// converted PropVariant.
// LPPROPVARIANT - The source of the conversion.
// UINT - The code page of VT_LPSTRs.
//
// Output: TRUE if successful. If unsuccessful, the original
// PropVariant will be returned unmodified.
//
// Pre-Conditions:
// The input must be either a VT_LPSTR or a VT_LPWSTR
// (with or without the VT_VECTOR bit set).
// &&
// The destination PropVariant is VT_EMPTY.
// &&
// The code page must not be CP_WINUNICODE (Unicode
// LPSTRs are not legal in the SumInfo property sets).
//
//////////////////////////////////////////////////////////////////////////////
BOOL FPropVarConvertString( LPPROPVARIANT lppropvarDest, const LPPROPVARIANT lppropvarSource, UINT uCodePage){
// ------
// Locals
// ------
BOOL fSuccess = FALSE; // Return code.
BOOL fConvertToAnsi; // Indicates the direction of the conversion.
LPSTR *lplpstrDest; // Pointer to pointer to a converted string.
LPSTR lpstrSource; // Pointer to a string to be converted.
ULONG cElems; // The number of strings still requiring conversion
ULONG ulIndex = 0; // Index into vector (if this VT is a vector)
// ----------
// Initialize
// ----------
Assert(lppropvarDest != NULL && lppropvarSource != NULL); Assert(lppropvarDest->vt == VT_EMPTY); Assert(uCodePage != CP_WINUNICODE);
// Determine the direction of the conversion.
fConvertToAnsi = (lppropvarSource->vt & ~VT_VECTOR) == VT_LPSTR ? FALSE : TRUE;
// -----------------------------------
// Initialize based on the Vector bit.
// -----------------------------------
if (lppropvarSource->vt & VT_VECTOR) { // We're a vector.
cElems = lppropvarSource->calpstr.cElems;
// Allocate an array of string pointers, putting it in
// lppropvarDest.
lppropvarDest->calpstr.pElems = CoTaskMemAlloc( cElems * sizeof(*lppropvarDest->calpstr.pElems) ); if (lppropvarDest->calpstr.pElems == NULL) { AssertSz(0,TEXT("Couldn't allocate memory for pElemsNew")); goto Exit; }
// Fill this new buffer so we don't get confused in the error path.
FillBuf (lppropvarDest->calpstr.pElems, 0, cElems * sizeof(*lppropvarDest->calpstr.pElems));
lppropvarDest->calpstr.cElems = cElems;
// Initialize the pointers for the first string to convert.
lplpstrDest = &lppropvarDest->calpstr.pElems[ 0 ]; lpstrSource = lppropvarSource->calpstr.pElems[ 0 ];
} // if (lppropvar->vt & VT_VECTOR)
else { // We're not a vector, initialize to the only string.
cElems = 1;
lplpstrDest = &lppropvarDest->pszVal; lpstrSource = lppropvarSource->pszVal; }
// ---------------------
// Convert the String(s)
// ---------------------
while (cElems) {
if (fConvertToAnsi) { if (!FCoWStrToStr ((LPSTR*)lplpstrDest, (LPWSTR) lpstrSource, uCodePage)) { goto Exit; } } else { if (!FCoStrToWStr ((LPWSTR*) lplpstrDest, (LPSTR) lpstrSource, uCodePage)) { goto Exit; } }
// Move on to the next entry, if there is one.
if (--cElems) { ulIndex++; lplpstrDest = &lppropvarDest->calpstr.pElems[ ulIndex ]; lpstrSource = lppropvarSource->calpstr.pElems[ ulIndex ];
} // if (--cElems)
} // while (cElems)
// Switch the destination VT to VT_LPSTR (for ansi strings) or VT_LPWSTR
// (for Unicode strings), preserving all other bits.
lppropvarDest->vt = (lppropvarSource->vt & ~(VT_LPSTR|VT_LPWSTR)) | (fConvertToAnsi ? VT_LPSTR : VT_LPWSTR);
// ----
// Exit
// ----
fSuccess = TRUE;
Exit:
if (!fSuccess) PropVariantClear (lppropvarDest);
return( fSuccess );
} // FPropVarConvertString
////////////////////////////////////////////////////////////////////////////////
//
// Function: FPropVarCopyToBuf
//
// Purpose: Copy the value from a PropVariant to a buffer.
// (The caller indicates how large the buffer is).
// The VarType of the PropVar must be from the
// valid Office sub-set.
//
// Inputs: LPPROPVARIANT - The source.
// DWORD - The size of the target buffer.
// LPVOID - The target buffer.
//
// Output: TRUE if successful.
//
////////////////////////////////////////////////////////////////////////////////
BOOLFPropVarCopyToBuf (LPPROPVARIANT const lppropvar, DWORD cbMax, LPVOID lpvBuf){ // ------
// Locals
// ------
BOOL fSuccess = FALSE; DWORD cb;
// ----------------
// Check the inputs
// ----------------
Assert (lppropvar != NULL); Assert (lpvBuf != NULL);
// ---------------------
// Copy, based on the VT
// ---------------------
switch (lppropvar->vt) { // File Time
case VT_FILETIME : if (cbMax < sizeof(FILETIME)) return(FALSE); PbMemCopy (lpvBuf, &lppropvar->filetime, sizeof(FILETIME)); break;
// Double
case VT_R8: if (cbMax < sizeof(double)) return(FALSE); PbMemCopy (lpvBuf, &lppropvar->dblVal, sizeof(double));
// Boolean
case VT_BOOL: if (cbMax < sizeof(WORD)) return(FALSE);
*(WORD *)lpvBuf = (WORD)lppropvar->boolVal; break;
// DWORD
case VT_I4: if (cbMax < sizeof(DWORD)) return(FALSE);
*(DWORD *)lpvBuf = (DWORD)lppropvar->ulVal; break;
// String
case VT_LPTSTR: if (lppropvar->pszVal == NULL) return(FALSE);
// Calculate the number of characters to copy (not
// including the NULL). But don't let it exceed
// cbMax - sizeof('\0').
cb = min ( CchTszLen ((LPTSTR)lppropvar->pszVal) * sizeof(TCHAR), cbMax - sizeof(TCHAR));
PbMemCopy(lpvBuf, lppropvar->pszVal, cb); ((LPTSTR) lpvBuf)[ cb/sizeof(TCHAR) ] = TEXT('\0'); break;
// Invalid type.
default : AssertSz (0, TEXT("Invalid type in FPropVarCopyToBuf")); goto Exit;
} // switch (lppropvar->vt)
fSuccess = TRUE;
// ----
// Exit
// ----
Exit:
return (fSuccess);
} // FPropVarCopyToBuf
|
