mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3252 lines
92 KiB
3252 lines
92 KiB
#include <malloc.h>
|
|
#include <urlint.h>
|
|
#include <map_kv.h>
|
|
#include "coll.hxx"
|
|
#ifndef unix
|
|
#include "COleTime.hxx"
|
|
#else
|
|
#include "coletime.hxx"
|
|
#endif /* unix */
|
|
#include "cvar.hxx"
|
|
|
|
//void * _cdecl operator new(size_t sizeEl, ULONG cEl);
|
|
void * _cdecl operator new(size_t sizeEl, COleVariant *pCVar);
|
|
|
|
void * _cdecl operator new(size_t sizeEl, COleVariant *pCVar)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
struct AFX_EXCEPTION_LINK
|
|
{
|
|
#ifdef _AFX_OLD_EXCEPTIONS
|
|
union
|
|
{
|
|
_AFX_JUMPBUF m_jumpBuf;
|
|
struct
|
|
{
|
|
void (PASCAL* pfnCleanup)(AFX_EXCEPTION_LINK* pLink);
|
|
void* pvData; // extra data follows
|
|
} m_callback; // callback for cleanup (nType != 0)
|
|
};
|
|
UINT m_nType; // 0 for setjmp, !=0 for user extension
|
|
#endif //!_AFX_OLD_EXCEPTIONS
|
|
|
|
AFX_EXCEPTION_LINK* m_pLinkPrev; // previous top, next in handler chain
|
|
CException* m_pException; // current exception (NULL in TRY block)
|
|
|
|
AFX_EXCEPTION_LINK(); // for initialization and linking
|
|
~AFX_EXCEPTION_LINK() // for cleanup and unlinking
|
|
{ AfxTryCleanup(); };
|
|
};
|
|
*/
|
|
#define TRY { AFX_EXCEPTION_LINK _afxExceptionLink; try {
|
|
|
|
#define CATCH(class, e) } catch (class* e) \
|
|
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \
|
|
_afxExceptionLink.m_pException = e;
|
|
|
|
#define AND_CATCH(class, e) } catch (class* e) \
|
|
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \
|
|
_afxExceptionLink.m_pException = e;
|
|
|
|
#define END_CATCH } }
|
|
|
|
|
|
#define THROW(e) throw e
|
|
#define THROW_LAST() (AfxThrowLastCleanup(), throw)
|
|
|
|
// Advanced macros for smaller code
|
|
#define CATCH_ALL(e) } catch (CException* e) \
|
|
{ { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
|
|
_afxExceptionLink.m_pException = e;
|
|
|
|
#define AND_CATCH_ALL(e) } catch (CException* e) \
|
|
{ { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
|
|
_afxExceptionLink.m_pException = e;
|
|
|
|
#define END_CATCH_ALL } } }
|
|
|
|
#define END_TRY } catch (CException* e) \
|
|
{ ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
|
|
_afxExceptionLink.m_pException = e; } }
|
|
|
|
#define AFX_OLE_FALSE 0
|
|
#define AFX_OLE_TRUE (-1)
|
|
|
|
#ifndef _DEBUG
|
|
#define USES_CONVERSION int _convert; _convert
|
|
#else
|
|
#define USES_CONVERSION int _convert = 0;
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
#define UNUSED(x)
|
|
#else
|
|
#define UNUSED(x) x
|
|
#endif
|
|
#define UNUSED_ALWAYS(x) x
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global UNICODE<>ANSI translation helpers
|
|
|
|
LPWSTR AFXAPI AfxA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars);
|
|
LPSTR AFXAPI AfxW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars);
|
|
|
|
#define A2CW(lpa) (\
|
|
((LPCSTR)lpa == NULL) ? NULL : (\
|
|
_convert = (lstrlenA(lpa)+1),\
|
|
(LPCWSTR)AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\
|
|
)\
|
|
)
|
|
|
|
#define A2W(lpa) (\
|
|
((LPCSTR)lpa == NULL) ? NULL : (\
|
|
_convert = (lstrlenA(lpa)+1),\
|
|
AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\
|
|
)\
|
|
)
|
|
|
|
#define W2CA(lpw) (\
|
|
((LPCWSTR)lpw == NULL) ? NULL : (\
|
|
_convert = (wcslen(lpw)+1)*2,\
|
|
(LPCSTR)AfxW2AHelper((LPSTR) alloca(_convert), lpw, _convert)\
|
|
)\
|
|
)
|
|
|
|
#define W2A(lpw) (\
|
|
((LPCWSTR)lpw == NULL) ? NULL : (\
|
|
_convert = (wcslen(lpw)+1)*2,\
|
|
AfxW2AHelper((LPSTR) alloca(_convert), lpw, _convert)\
|
|
)\
|
|
)
|
|
|
|
|
|
#if defined(_UNICODE)
|
|
// in these cases the default (TCHAR) is the same as OLECHAR
|
|
#define DEVMODEOLE DEVMODEW
|
|
#define LPDEVMODEOLE LPDEVMODEW
|
|
#define TEXTMETRICOLE TEXTMETRICW
|
|
#define LPTEXTMETRICOLE LPTEXTMETRICW
|
|
inline size_t ocslen(LPCOLESTR x) { return wcslen(x); }
|
|
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return wcscpy(dest, src); }
|
|
inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
|
|
inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
|
|
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
|
|
inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
|
|
inline LPOLESTR TASKSTRINGT2OLE(LPOLESTR lp) { return lp; }
|
|
inline LPTSTR TASKSTRINGOLE2T(LPOLESTR lp) { return lp; }
|
|
inline LPDEVMODEW DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
|
|
inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODEW lp) { return lp; }
|
|
inline LPTEXTMETRICW TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
|
|
inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRICW lp) { return lp; }
|
|
inline BSTR BSTR2TBSTR(BSTR bstr) { return bstr;}
|
|
#elif defined(OLE2ANSI)
|
|
// in these cases the default (TCHAR) is the same as OLECHAR
|
|
#define DEVMODEOLE DEVMODEA
|
|
#define LPDEVMODEOLE LPDEVMODEA
|
|
#define TEXTMETRICOLE TEXTMETRICA
|
|
#define LPTEXTMETRICOLE LPTEXTMETRICA
|
|
inline size_t ocslen(LPCOLESTR x) { return lstrlenA(x); }
|
|
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpyA(dest, src); }
|
|
inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
|
|
inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
|
|
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
|
|
inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
|
|
inline LPOLESTR TASKSTRINGT2OLE(LPOLESTR lp) { return lp; }
|
|
inline LPTSTR TASKSTRINGOLE2T(LPOLESTR lp) { return lp; }
|
|
inline LPDEVMODE DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
|
|
inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODE lp) { return lp; }
|
|
inline LPTEXTMETRIC TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
|
|
inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRIC lp) { return lp; }
|
|
inline BSTR BSTR2TBSTR(BSTR bstr) { return bstr; }
|
|
#else
|
|
#define DEVMODEOLE DEVMODEW
|
|
#define LPDEVMODEOLE LPDEVMODEW
|
|
#define TEXTMETRICOLE TEXTMETRICW
|
|
#define LPTEXTMETRICOLE LPTEXTMETRICW
|
|
inline size_t ocslen(LPCOLESTR x) { return wcslen(x); }
|
|
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return wcscpy(dest, src); }
|
|
#define T2COLE(lpa) A2CW(lpa)
|
|
#define T2OLE(lpa) A2W(lpa)
|
|
#define OLE2CT(lpo) W2CA(lpo)
|
|
#define OLE2T(lpo) W2A(lpo)
|
|
#define TASKSTRINGT2OLE(lpa) AfxTaskStringA2W(lpa)
|
|
#define TASKSTRINGOLE2T(lpo) AfxTaskStringW2A(lpo)
|
|
#define DEVMODEOLE2T(lpo) DEVMODEW2A(lpo)
|
|
#define DEVMODET2OLE(lpa) DEVMODEA2W(lpa)
|
|
#define TEXTMETRICOLE2T(lptmw) TEXTMETRICW2A(lptmw)
|
|
#define TEXTMETRICT2OLE(lptma) TEXTMETRICA2W(lptma)
|
|
#define BSTR2TBSTR(bstr) AfxBSTR2ABSTR(bstr)
|
|
#endif
|
|
|
|
#ifdef OLE2ANSI
|
|
#define W2OLE W2A
|
|
#define W2COLE W2CA
|
|
#define OLE2W A2W
|
|
#define OLE2CW A2CW
|
|
inline LPOLESTR A2OLE(LPSTR lp) { return lp; }
|
|
inline LPCOLESTR A2COLE(LPCSTR lp) { return lp; }
|
|
inline LPSTR OLE2A(LPOLESTR lp) { return lp; }
|
|
inline LPCSTR OLE2CA(LPCOLESTR lp) { return lp; }
|
|
#else
|
|
#define A2OLE A2W
|
|
#define A2COLE A2CW
|
|
#define OLE2A W2A
|
|
#define OLE2CA W2CA
|
|
inline LPOLESTR W2OLE(LPWSTR lp) { return lp; }
|
|
inline LPCOLESTR W2COLE(LPCWSTR lp) { return lp; }
|
|
inline LPWSTR OLE2W(LPOLESTR lp) { return lp; }
|
|
inline LPCWSTR OLE2CW(LPCOLESTR lp) { return lp; }
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// helpers
|
|
|
|
static void PASCAL CheckError(SCODE sc);
|
|
static BOOL PASCAL CompareSafeArrays(SAFEARRAY* parray1, SAFEARRAY* parray2);
|
|
static void PASCAL CreateOneDimArray(VARIANT& varSrc, DWORD dwSize);
|
|
static void PASCAL CopyBinaryData(SAFEARRAY* parray,
|
|
const void* pSrc, DWORD dwSize);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleVariant class
|
|
|
|
COleVariant::COleVariant(const VARIANT& varSrc)
|
|
{
|
|
AfxVariantInit(this);
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
}
|
|
|
|
COleVariant::COleVariant(LPCVARIANT pSrc)
|
|
{
|
|
AfxVariantInit(this);
|
|
CheckError(::VariantCopy(this, (LPVARIANT)pSrc));
|
|
}
|
|
|
|
COleVariant::COleVariant(const COleVariant& varSrc)
|
|
{
|
|
AfxVariantInit(this);
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
}
|
|
|
|
COleVariant::COleVariant(LPCTSTR lpszSrc, VARTYPE vtSrc)
|
|
{
|
|
USES_CONVERSION;
|
|
ASSERT(vtSrc == VT_BSTR || vtSrc == VT_BSTRT);
|
|
UNUSED(vtSrc);
|
|
|
|
vt = VT_BSTR;
|
|
bstrVal = NULL;
|
|
|
|
if (lpszSrc != NULL)
|
|
{
|
|
#ifndef _UNICODE
|
|
if (vtSrc == VT_BSTRT)
|
|
{
|
|
int nLen = lstrlen(lpszSrc);
|
|
bstrVal = ::SysAllocStringByteLen(lpszSrc, nLen);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
bstrVal = ::SysAllocString(T2COLE(lpszSrc));
|
|
}
|
|
|
|
/*
|
|
BUGBUG:
|
|
if (bstrVal == NULL)
|
|
AfxThrowMemoryException();
|
|
*/
|
|
}
|
|
}
|
|
|
|
void COleVariant::SetString(LPCTSTR lpszSrc, VARTYPE vtSrc)
|
|
{
|
|
USES_CONVERSION;
|
|
ASSERT(vtSrc == VT_BSTR || vtSrc == VT_BSTRT);
|
|
UNUSED(vtSrc);
|
|
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
|
|
vt = VT_BSTR;
|
|
bstrVal = NULL;
|
|
|
|
if (lpszSrc != NULL)
|
|
{
|
|
#ifndef _UNICODE
|
|
if (vtSrc == VT_BSTRT)
|
|
{
|
|
int nLen = lstrlen(lpszSrc);
|
|
bstrVal = ::SysAllocStringByteLen(lpszSrc, nLen);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
bstrVal = ::SysAllocString(T2COLE(lpszSrc));
|
|
}
|
|
|
|
/*
|
|
BUGBUG:
|
|
if (bstrVal == NULL)
|
|
AfxThrowMemoryException();
|
|
*/
|
|
}
|
|
}
|
|
|
|
COleVariant::COleVariant(short nSrc, VARTYPE vtSrc)
|
|
{
|
|
ASSERT(vtSrc == VT_I2 || vtSrc == VT_BOOL);
|
|
|
|
if (vtSrc == VT_BOOL)
|
|
{
|
|
vt = VT_BOOL;
|
|
if (nSrc == FALSE)
|
|
V_BOOL(this) = AFX_OLE_FALSE;
|
|
else
|
|
V_BOOL(this) = AFX_OLE_TRUE;
|
|
}
|
|
else
|
|
{
|
|
vt = VT_I2;
|
|
iVal = nSrc;
|
|
}
|
|
}
|
|
|
|
COleVariant::COleVariant(long lSrc, VARTYPE vtSrc)
|
|
{
|
|
ASSERT(vtSrc == VT_I4 || vtSrc == VT_ERROR || vtSrc == VT_BOOL);
|
|
|
|
if (vtSrc == VT_ERROR)
|
|
{
|
|
vt = VT_ERROR;
|
|
scode = lSrc;
|
|
}
|
|
else if (vtSrc == VT_BOOL)
|
|
{
|
|
vt = VT_BOOL;
|
|
if (lSrc == FALSE)
|
|
V_BOOL(this) = AFX_OLE_FALSE;
|
|
else
|
|
V_BOOL(this) = AFX_OLE_TRUE;
|
|
}
|
|
else
|
|
{
|
|
vt = VT_I4;
|
|
lVal = lSrc;
|
|
}
|
|
}
|
|
|
|
// Operations
|
|
void COleVariant::Clear()
|
|
{
|
|
VERIFY(::VariantClear(this) == NOERROR);
|
|
}
|
|
|
|
void COleVariant::ChangeType(VARTYPE vartype, LPVARIANT pSrc)
|
|
{
|
|
// If pSrc is NULL, convert type in place
|
|
if (pSrc == NULL)
|
|
pSrc = this;
|
|
if (pSrc != this || vartype != vt)
|
|
CheckError(::VariantChangeType(this, pSrc, 0, vartype));
|
|
}
|
|
|
|
void COleVariant::Attach(VARIANT& varSrc)
|
|
{
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
|
|
// give control of data to COleVariant
|
|
memcpy(this, &varSrc, sizeof(varSrc));
|
|
varSrc.vt = VT_EMPTY;
|
|
}
|
|
|
|
VARIANT COleVariant::Detach()
|
|
{
|
|
VARIANT varResult = *this;
|
|
vt = VT_EMPTY;
|
|
return varResult;
|
|
}
|
|
|
|
// Literal comparison. Types and values must match.
|
|
BOOL COleVariant::operator==(const VARIANT& var) const
|
|
{
|
|
if (&var == this)
|
|
return TRUE;
|
|
|
|
// Variants not equal if types don't match
|
|
if (var.vt != vt)
|
|
return FALSE;
|
|
|
|
// Check type specific values
|
|
switch (vt)
|
|
{
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
return TRUE;
|
|
|
|
case VT_BOOL:
|
|
return V_BOOL(&var) == V_BOOL(this);
|
|
|
|
case VT_UI1:
|
|
return var.bVal == bVal;
|
|
|
|
case VT_I2:
|
|
return var.iVal == iVal;
|
|
|
|
case VT_I4:
|
|
return var.lVal == lVal;
|
|
|
|
case VT_CY:
|
|
return (var.cyVal.Hi == cyVal.Hi && var.cyVal.Lo == cyVal.Lo);
|
|
|
|
case VT_R4:
|
|
return var.fltVal == fltVal;
|
|
|
|
case VT_R8:
|
|
return var.dblVal == dblVal;
|
|
|
|
case VT_DATE:
|
|
return var.date == date;
|
|
|
|
case VT_BSTR:
|
|
return SysStringByteLen(var.bstrVal) == SysStringByteLen(bstrVal) &&
|
|
memcmp(var.bstrVal, bstrVal, SysStringByteLen(bstrVal)) == 0;
|
|
|
|
case VT_ERROR:
|
|
return var.scode == scode;
|
|
|
|
case VT_DISPATCH:
|
|
case VT_UNKNOWN:
|
|
return var.punkVal == punkVal;
|
|
|
|
default:
|
|
if (vt & VT_ARRAY && !(vt & VT_BYREF))
|
|
return CompareSafeArrays(var.parray, parray);
|
|
else
|
|
ASSERT(FALSE); // VT_BYREF not supported
|
|
// fall through
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(const VARIANT& varSrc)
|
|
{
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(LPCVARIANT pSrc)
|
|
{
|
|
CheckError(::VariantCopy(this, (LPVARIANT)pSrc));
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(const COleVariant& varSrc)
|
|
{
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(const LPCTSTR lpszSrc)
|
|
{
|
|
USES_CONVERSION;
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
|
|
vt = VT_BSTR;
|
|
if (lpszSrc == NULL)
|
|
bstrVal = NULL;
|
|
else
|
|
{
|
|
bstrVal = ::SysAllocString(T2COLE(lpszSrc));
|
|
/*
|
|
BUGBUG:
|
|
if (bstrVal == NULL)
|
|
AfxThrowMemoryException();
|
|
*/
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(const CString& strSrc)
|
|
{
|
|
USES_CONVERSION;
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
|
|
vt = VT_BSTR;
|
|
bstrVal = ::SysAllocString(T2COLE(strSrc));
|
|
/*
|
|
BUGBUG:
|
|
if (bstrVal == NULL)
|
|
AfxThrowMemoryException();
|
|
*/
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(BYTE nSrc)
|
|
{
|
|
// Free up previous VARIANT if necessary
|
|
if (vt != VT_UI1)
|
|
{
|
|
Clear();
|
|
vt = VT_UI1;
|
|
}
|
|
|
|
bVal = nSrc;
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(short nSrc)
|
|
{
|
|
if (vt == VT_I2)
|
|
iVal = nSrc;
|
|
else if (vt == VT_BOOL)
|
|
{
|
|
if (nSrc == FALSE)
|
|
V_BOOL(this) = AFX_OLE_FALSE;
|
|
else
|
|
V_BOOL(this) = AFX_OLE_TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
vt = VT_I2;
|
|
iVal = nSrc;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(long lSrc)
|
|
{
|
|
if (vt == VT_I4)
|
|
lVal = lSrc;
|
|
else if (vt == VT_ERROR)
|
|
scode = lSrc;
|
|
else if (vt == VT_BOOL)
|
|
{
|
|
if (lSrc == FALSE)
|
|
V_BOOL(this) = AFX_OLE_FALSE;
|
|
else
|
|
V_BOOL(this) = AFX_OLE_TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Free up previous VARIANT
|
|
Clear();
|
|
vt = VT_I4;
|
|
lVal = lSrc;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
const COleVariant& COleVariant::operator=(const COleCurrency& curSrc)
|
|
{
|
|
// Free up previous VARIANT if necessary
|
|
if (vt != VT_CY)
|
|
{
|
|
Clear();
|
|
vt = VT_CY;
|
|
}
|
|
|
|
cyVal = curSrc.m_cur;
|
|
return *this;
|
|
}
|
|
*/
|
|
const COleVariant& COleVariant::operator=(float fltSrc)
|
|
{
|
|
// Free up previous VARIANT if necessary
|
|
if (vt != VT_R4)
|
|
{
|
|
Clear();
|
|
vt = VT_R4;
|
|
}
|
|
|
|
fltVal = fltSrc;
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(double dblSrc)
|
|
{
|
|
// Free up previous VARIANT if necessary
|
|
if (vt != VT_R8)
|
|
{
|
|
Clear();
|
|
vt = VT_R8;
|
|
}
|
|
|
|
dblVal = dblSrc;
|
|
return *this;
|
|
}
|
|
|
|
const COleVariant& COleVariant::operator=(const COleDateTime& dateSrc)
|
|
{
|
|
// Free up previous VARIANT if necessary
|
|
if (vt != VT_DATE)
|
|
{
|
|
Clear();
|
|
vt = VT_DATE;
|
|
}
|
|
|
|
date = dateSrc.m_dt;
|
|
return *this;
|
|
}
|
|
/*
|
|
const COleVariant& COleVariant::operator=(const CByteArray& arrSrc)
|
|
{
|
|
int nSize = arrSrc.GetSize();
|
|
|
|
// Set the correct type and make sure SafeArray can hold data
|
|
CreateOneDimArray(*this, (DWORD)nSize);
|
|
|
|
// Copy the data into the SafeArray
|
|
CopyBinaryData(parray, arrSrc.GetData(), (DWORD)nSize);
|
|
|
|
return *this;
|
|
}
|
|
const COleVariant& COleVariant::operator=(const CLongBinary& lbSrc)
|
|
{
|
|
// Set the correct type and make sure SafeArray can hold data
|
|
CreateOneDimArray(*this, lbSrc.m_dwDataLength);
|
|
|
|
// Copy the data into the SafeArray
|
|
BYTE* pData = (BYTE*)::GlobalLock(lbSrc.m_hData);
|
|
CopyBinaryData(parray, pData, lbSrc.m_dwDataLength);
|
|
::GlobalUnlock(lbSrc.m_hData);
|
|
|
|
return *this;
|
|
}
|
|
*/
|
|
|
|
void AFXAPI AfxVariantInit(LPVARIANT pVar)
|
|
{
|
|
memset(pVar, 0, sizeof(*pVar));
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
CDumpContext& AFXAPI operator <<(CDumpContext& dc, COleVariant varSrc)
|
|
{
|
|
LPCVARIANT pSrc = (LPCVARIANT)varSrc;
|
|
|
|
dc << "\nCOleVariant Object:";
|
|
dc << "\n\t vt = " << pSrc->vt;
|
|
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
if (pSrc->vt & VT_BYREF || pSrc->vt & VT_ARRAY)
|
|
return dc;
|
|
|
|
switch (pSrc->vt)
|
|
{
|
|
case VT_BOOL:
|
|
return dc << "\n\t VT_BOOL = " << V_BOOL(pSrc);
|
|
|
|
case VT_UI1:
|
|
return dc << "\n\t bVal = " << pSrc->bVal;
|
|
|
|
case VT_I2:
|
|
return dc << "\n\t iVal = " << pSrc->iVal;
|
|
|
|
case VT_I4:
|
|
return dc << "\n\t lVal = " << pSrc->lVal;
|
|
|
|
case VT_CY:
|
|
{
|
|
COleVariant var(varSrc);
|
|
var.ChangeType(VT_BSTR);
|
|
return dc << "\n\t cyVal = " << (LPCTSTR)var.bstrVal;
|
|
}
|
|
|
|
case VT_R4:
|
|
return dc << "\n\t fltVal = " << pSrc->fltVal;
|
|
|
|
case VT_R8:
|
|
return dc << "\n\t dblVal = " << pSrc->dblVal;
|
|
|
|
case VT_DATE:
|
|
{
|
|
COleVariant var(varSrc);
|
|
var.ChangeType(VT_BSTR);
|
|
return dc << "\n\t date = " << (LPCTSTR)var.bstrVal;
|
|
}
|
|
|
|
case VT_BSTR:
|
|
return dc << "\n\t bstrVal = " << (LPCTSTR)pSrc->bstrVal;
|
|
|
|
case VT_ERROR:
|
|
return dc << "\n\t scode = " << pSrc->scode;
|
|
|
|
case VT_DISPATCH:
|
|
case VT_UNKNOWN:
|
|
return dc << "\n\t punkVal = " << pSrc->punkVal;
|
|
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
return dc;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return dc;
|
|
}
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
|
|
#ifdef _with_archive_
|
|
CArchive& AFXAPI operator<<(CArchive& ar, COleVariant varSrc)
|
|
{
|
|
LPCVARIANT pSrc = (LPCVARIANT)varSrc;
|
|
|
|
ar << pSrc->vt;
|
|
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
if (pSrc->vt & VT_BYREF || pSrc->vt & VT_ARRAY)
|
|
return ar;
|
|
|
|
switch (pSrc->vt)
|
|
{
|
|
case VT_BOOL:
|
|
return ar << (WORD)V_BOOL(pSrc);
|
|
|
|
case VT_UI1:
|
|
return ar << pSrc->bVal;
|
|
|
|
case VT_I2:
|
|
return ar << (WORD)pSrc->iVal;
|
|
|
|
case VT_I4:
|
|
return ar << pSrc->lVal;
|
|
|
|
case VT_CY:
|
|
ar << pSrc->cyVal.Lo;
|
|
return ar << pSrc->cyVal.Hi;
|
|
|
|
case VT_R4:
|
|
return ar << pSrc->fltVal;
|
|
|
|
case VT_R8:
|
|
return ar << pSrc->dblVal;
|
|
|
|
case VT_DATE:
|
|
return ar << pSrc->date;
|
|
|
|
case VT_BSTR:
|
|
{
|
|
DWORD nLen = SysStringByteLen(pSrc->bstrVal);
|
|
ar << nLen;
|
|
if (nLen > 0)
|
|
ar.Write(pSrc->bstrVal, nLen * sizeof(BYTE));
|
|
|
|
return ar;
|
|
}
|
|
|
|
case VT_ERROR:
|
|
return ar << pSrc->scode;
|
|
|
|
#ifdef _WITH_PUNK_
|
|
case VT_DISPATCH:
|
|
case VT_UNKNOWN:
|
|
{
|
|
LPPERSISTSTREAM pPersistStream;
|
|
//BUGBUG
|
|
//CArchiveStream stm(&ar);
|
|
|
|
// QI for IPersistStream or IPeristStreamInit
|
|
SCODE sc = pSrc->punkVal->QueryInterface(
|
|
IID_IPersistStream, (void**)&pPersistStream);
|
|
//#ifndef _AFX_NO_OCC_SUPPORT
|
|
#ifdef _AFX_OCC_SUPPORT
|
|
if (FAILED(sc))
|
|
sc = pSrc->punkVal->QueryInterface(
|
|
IID_IPersistStreamInit, (void**)&pPersistStream);
|
|
#endif
|
|
CheckError(sc);
|
|
|
|
TRY
|
|
{
|
|
// Get and archive the CLSID (GUID)
|
|
CLSID clsid;
|
|
CheckError(pPersistStream->GetClassID(&clsid));
|
|
ar << clsid.Data1;
|
|
ar << clsid.Data2;
|
|
ar << clsid.Data3;
|
|
ar.Write(&clsid.Data4[0], sizeof clsid.Data4);
|
|
|
|
// Always assume object is dirty
|
|
CheckError(pPersistStream->Save(&stm, TRUE));
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
pPersistStream->Release();
|
|
THROW_LAST();
|
|
}
|
|
END_CATCH_ALL
|
|
pPersistStream->Release();
|
|
}
|
|
return ar;
|
|
#endif //_WITH_PUNK_
|
|
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
// do nothing
|
|
return ar;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return ar;
|
|
}
|
|
}
|
|
|
|
CArchive& AFXAPI operator>>(CArchive& ar, COleVariant& varSrc)
|
|
{
|
|
LPVARIANT pSrc = &varSrc;
|
|
|
|
// Free up current data if necessary
|
|
if (pSrc->vt != VT_EMPTY)
|
|
VariantClear(pSrc);
|
|
ar >> pSrc->vt;
|
|
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
if (pSrc->vt & VT_BYREF || pSrc->vt & VT_ARRAY)
|
|
return ar;
|
|
|
|
switch (pSrc->vt)
|
|
{
|
|
case VT_BOOL:
|
|
return ar >> (WORD&)V_BOOL(pSrc);
|
|
|
|
case VT_UI1:
|
|
return ar >> pSrc->bVal;
|
|
|
|
case VT_I2:
|
|
return ar >> (WORD&)pSrc->iVal;
|
|
|
|
case VT_I4:
|
|
return ar >> pSrc->lVal;
|
|
|
|
case VT_CY:
|
|
ar >> pSrc->cyVal.Lo;
|
|
return ar >> pSrc->cyVal.Hi;
|
|
|
|
case VT_R4:
|
|
return ar >> pSrc->fltVal;
|
|
|
|
case VT_R8:
|
|
return ar >> pSrc->dblVal;
|
|
|
|
case VT_DATE:
|
|
return ar >> pSrc->date;
|
|
|
|
case VT_BSTR:
|
|
{
|
|
DWORD nLen;
|
|
ar >> nLen;
|
|
if (nLen > 0)
|
|
{
|
|
pSrc->bstrVal = SysAllocStringByteLen(NULL, nLen);
|
|
//BUGBUG:
|
|
//if (pSrc->bstrVal == NULL)
|
|
// AfxThrowMemoryException();
|
|
|
|
ar.Read(pSrc->bstrVal, nLen * sizeof(BYTE));
|
|
}
|
|
else
|
|
pSrc->bstrVal = NULL;
|
|
|
|
return ar;
|
|
}
|
|
break;
|
|
|
|
case VT_ERROR:
|
|
return ar >> pSrc->scode;
|
|
|
|
#ifdef _WITH_PUNK_
|
|
case VT_DISPATCH:
|
|
case VT_UNKNOWN:
|
|
{
|
|
LPPERSISTSTREAM pPersistStream = NULL;
|
|
CArchiveStream stm(&ar);
|
|
|
|
// Retrieve the CLSID (GUID) and create an instance
|
|
CLSID clsid;
|
|
ar >> clsid.Data1;
|
|
ar >> clsid.Data2;
|
|
ar >> clsid.Data3;
|
|
ar.Read(&clsid.Data4[0], sizeof clsid.Data4);
|
|
|
|
// Create the object
|
|
SCODE sc = CoCreateInstance(clsid, NULL, CLSCTX_ALL | CLSCTX_REMOTE_SERVER,
|
|
pSrc->vt == VT_UNKNOWN ? IID_IUnknown : IID_IDispatch,
|
|
(void**)&pSrc->punkVal);
|
|
if (sc == E_INVALIDARG)
|
|
{
|
|
// may not support CLSCTX_REMOTE_SERVER, so try without
|
|
sc = CoCreateInstance(clsid, NULL,
|
|
CLSCTX_ALL & ~CLSCTX_REMOTE_SERVER,
|
|
pSrc->vt == VT_UNKNOWN ? IID_IUnknown : IID_IDispatch,
|
|
(void**)&pSrc->punkVal);
|
|
}
|
|
CheckError(sc);
|
|
|
|
TRY
|
|
{
|
|
// QI for IPersistStream or IPeristStreamInit
|
|
sc = pSrc->punkVal->QueryInterface(
|
|
IID_IPersistStream, (void**)&pPersistStream);
|
|
#ifndef _AFX_NO_OCC_SUPPORT
|
|
if (FAILED(sc))
|
|
sc = pSrc->punkVal->QueryInterface(
|
|
IID_IPersistStreamInit, (void**)&pPersistStream);
|
|
#endif
|
|
CheckError(sc);
|
|
|
|
// Always assumes object is dirty
|
|
CheckError(pPersistStream->Load(&stm));
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
// Clean up
|
|
if (pPersistStream != NULL)
|
|
pPersistStream->Release();
|
|
|
|
pSrc->punkVal->Release();
|
|
THROW_LAST();
|
|
}
|
|
END_CATCH_ALL
|
|
|
|
pPersistStream->Release();
|
|
}
|
|
return ar;
|
|
#endif //_WITH_PUNK_
|
|
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
// do nothing
|
|
return ar;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return ar;
|
|
}
|
|
}
|
|
#endif //_with_archive_
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleVariant Helpers
|
|
|
|
template<>
|
|
void AFXAPI ConstructElements(COleVariant* pElements, int nCount)
|
|
{
|
|
ASSERT(nCount == 0 ||
|
|
AfxIsValidAddress(pElements, nCount * sizeof(COleVariant)));
|
|
|
|
for (; nCount--; ++pElements)
|
|
new(pElements) COleVariant;
|
|
}
|
|
|
|
template<>
|
|
void AFXAPI DestructElements(COleVariant* pElements, int nCount)
|
|
{
|
|
ASSERT(nCount == 0 ||
|
|
AfxIsValidAddress(pElements, nCount * sizeof(COleVariant)));
|
|
|
|
for (; nCount--; ++pElements)
|
|
pElements->~COleVariant();
|
|
}
|
|
|
|
template<>
|
|
void AFXAPI CopyElements(COleVariant* pDest, const COleVariant* pSrc, int nCount)
|
|
{
|
|
ASSERT(nCount == 0 ||
|
|
AfxIsValidAddress(pDest, nCount * sizeof(COleVariant)));
|
|
ASSERT(nCount == 0 ||
|
|
AfxIsValidAddress(pSrc, nCount * sizeof(COleVariant)));
|
|
|
|
for (; nCount--; ++pDest, ++pSrc)
|
|
*pDest = *pSrc;
|
|
}
|
|
|
|
#ifdef _with_archive_
|
|
template<>
|
|
void AFXAPI SerializeElements(CArchive& ar, COleVariant* pElements, int nCount)
|
|
{
|
|
ASSERT(nCount == 0 ||
|
|
AfxIsValidAddress(pElements, nCount * sizeof(COleVariant)));
|
|
|
|
if (ar.IsStoring())
|
|
{
|
|
for (; nCount--; ++pElements)
|
|
ar << *pElements;
|
|
}
|
|
else
|
|
{
|
|
for (; nCount--; ++pElements)
|
|
ar >> *pElements;
|
|
}
|
|
}
|
|
#endif //_with_archive_
|
|
|
|
#ifdef _DEBUG
|
|
template<>
|
|
void AFXAPI DumpElements(CDumpContext& dc, COleVariant* pElements, int nCount)
|
|
{
|
|
for (; nCount--; ++pElements)
|
|
dc << *pElements;
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
template<>
|
|
UINT AFXAPI HashKey(const struct tagVARIANT& var)
|
|
{
|
|
switch (var.vt)
|
|
{
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
return 0;
|
|
case VT_I2:
|
|
return HashKey((DWORD)var.iVal);
|
|
case VT_I4:
|
|
return HashKey((DWORD)var.lVal);
|
|
case VT_R4:
|
|
return (UINT)(var.fltVal / 16);
|
|
case VT_R8:
|
|
case VT_CY:
|
|
return (UINT)(var.dblVal / 16);
|
|
case VT_BOOL:
|
|
return HashKey((DWORD)V_BOOL(&var));
|
|
case VT_ERROR:
|
|
return HashKey((DWORD)var.scode);
|
|
case VT_DATE:
|
|
return (UINT)(var.date / 16);
|
|
case VT_BSTR:
|
|
return HashKey(var.bstrVal);
|
|
case VT_DISPATCH:
|
|
case VT_UNKNOWN:
|
|
return HashKey((DWORD_PTR)var.punkVal);
|
|
|
|
default:
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
ASSERT(FALSE);
|
|
|
|
// Fall through
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void PASCAL CheckError(SCODE sc)
|
|
{
|
|
if (FAILED(sc))
|
|
{
|
|
/*
|
|
BUGBUG:
|
|
if (sc == E_OUTOFMEMORY)
|
|
AfxThrowMemoryException();
|
|
else
|
|
AfxThrowOleException(sc);
|
|
*/
|
|
}
|
|
}
|
|
static BOOL PASCAL CompareSafeArrays(SAFEARRAY* parray1, SAFEARRAY* parray2)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef _CURRENCY_ALSO_
|
|
static BOOL PASCAL CompareSafeArrays(SAFEARRAY* parray1, SAFEARRAY* parray2)
|
|
{
|
|
BOOL bCompare = FALSE;
|
|
|
|
// If one is NULL they must both be NULL to compare
|
|
if (parray1 == NULL || parray2 == NULL)
|
|
{
|
|
return parray1 == parray2;
|
|
}
|
|
|
|
// Dimension must match and if 0, then arrays compare
|
|
DWORD dwDim1 = ::SafeArrayGetDim(parray1);
|
|
DWORD dwDim2 = ::SafeArrayGetDim(parray2);
|
|
if (dwDim1 != dwDim2)
|
|
return FALSE;
|
|
else if (dwDim1 == 0)
|
|
return TRUE;
|
|
|
|
// Element size must match
|
|
DWORD dwSize1 = ::SafeArrayGetElemsize(parray1);
|
|
DWORD dwSize2 = ::SafeArrayGetElemsize(parray2);
|
|
if (dwSize1 != dwSize2)
|
|
return FALSE;
|
|
|
|
long* pLBound1 = NULL;
|
|
long* pLBound2 = NULL;
|
|
long* pUBound1 = NULL;
|
|
long* pUBound2 = NULL;
|
|
|
|
void* pData1 = NULL;
|
|
void* pData2 = NULL;
|
|
|
|
TRY
|
|
{
|
|
// Bounds must match
|
|
pLBound1 = new long[dwDim1];
|
|
pLBound2 = new long[dwDim2];
|
|
pUBound1 = new long[dwDim1];
|
|
pUBound2 = new long[dwDim2];
|
|
|
|
size_t nTotalElements = 1;
|
|
|
|
// Get and compare bounds
|
|
for (DWORD dwIndex = 0; dwIndex < dwDim1; dwIndex++)
|
|
{
|
|
CheckError(::SafeArrayGetLBound(
|
|
parray1, dwIndex+1, &pLBound1[dwIndex]));
|
|
CheckError(::SafeArrayGetLBound(
|
|
parray2, dwIndex+1, &pLBound2[dwIndex]));
|
|
CheckError(::SafeArrayGetUBound(
|
|
parray1, dwIndex+1, &pUBound1[dwIndex]));
|
|
CheckError(::SafeArrayGetUBound(
|
|
parray2, dwIndex+1, &pUBound2[dwIndex]));
|
|
|
|
// Check the magnitude of each bound
|
|
if (pUBound1[dwIndex] - pLBound1[dwIndex] !=
|
|
pUBound2[dwIndex] - pLBound2[dwIndex])
|
|
{
|
|
delete[] pLBound1;
|
|
delete[] pLBound2;
|
|
delete[] pUBound1;
|
|
delete[] pUBound2;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// Increment the element count
|
|
nTotalElements *= pUBound1[dwIndex] - pLBound1[dwIndex] + 1;
|
|
}
|
|
|
|
// Access the data
|
|
CheckError(::SafeArrayAccessData(parray1, &pData1));
|
|
CheckError(::SafeArrayAccessData(parray2, &pData2));
|
|
|
|
// Calculate the number of bytes of data and compare
|
|
size_t nSize = nTotalElements * dwSize1;
|
|
int nOffset = memcmp(pData1, pData2, nSize);
|
|
bCompare = nOffset == 0;
|
|
|
|
// Release the array locks
|
|
CheckError(::SafeArrayUnaccessData(parray1));
|
|
CheckError(::SafeArrayUnaccessData(parray2));
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
// Clean up bounds arrays
|
|
delete[] pLBound1;
|
|
delete[] pLBound2;
|
|
delete[] pUBound1;
|
|
delete[] pUBound2;
|
|
|
|
// Release the array locks
|
|
if (pData1 != NULL)
|
|
CheckError(::SafeArrayUnaccessData(parray1));
|
|
if (pData2 != NULL)
|
|
CheckError(::SafeArrayUnaccessData(parray2));
|
|
|
|
THROW_LAST();
|
|
}
|
|
END_CATCH_ALL
|
|
|
|
// Clean up bounds arrays
|
|
delete[] pLBound1;
|
|
delete[] pLBound2;
|
|
delete[] pUBound1;
|
|
delete[] pUBound2;
|
|
|
|
return bCompare;
|
|
}
|
|
|
|
static void PASCAL CreateOneDimArray(VARIANT& varSrc, DWORD dwSize)
|
|
{
|
|
UINT nDim;
|
|
|
|
// Clear VARIANT and re-create SafeArray if necessary
|
|
if (varSrc.vt != (VT_UI1 | VT_ARRAY) ||
|
|
(nDim = ::SafeArrayGetDim(varSrc.parray)) != 1)
|
|
{
|
|
VERIFY(::VariantClear(&varSrc) == NOERROR);
|
|
varSrc.vt = VT_UI1 | VT_ARRAY;
|
|
|
|
SAFEARRAYBOUND bound;
|
|
bound.cElements = dwSize;
|
|
bound.lLbound = 0;
|
|
varSrc.parray = ::SafeArrayCreate(VT_UI1, 1, &bound);
|
|
if (varSrc.parray == NULL)
|
|
AfxThrowMemoryException();
|
|
}
|
|
else
|
|
{
|
|
// Must redimension array if necessary
|
|
long lLower, lUpper;
|
|
CheckError(::SafeArrayGetLBound(varSrc.parray, 1, &lLower));
|
|
CheckError(::SafeArrayGetUBound(varSrc.parray, 1, &lUpper));
|
|
|
|
// Upper bound should always be greater than lower bound
|
|
long lSize = lUpper - lLower;
|
|
if (lSize < 0)
|
|
{
|
|
ASSERT(FALSE);
|
|
lSize = 0;
|
|
|
|
}
|
|
|
|
if ((DWORD)lSize != dwSize)
|
|
{
|
|
SAFEARRAYBOUND bound;
|
|
bound.cElements = dwSize;
|
|
bound.lLbound = lLower;
|
|
CheckError(::SafeArrayRedim(varSrc.parray, &bound));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void PASCAL CopyBinaryData(SAFEARRAY* parray, const void* pvSrc, DWORD dwSize)
|
|
{
|
|
// Access the data, copy it and unaccess it.
|
|
void* pDest;
|
|
CheckError(::SafeArrayAccessData(parray, &pDest));
|
|
memcpy(pDest, pvSrc, dwSize);
|
|
CheckError(::SafeArrayUnaccessData(parray));
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleCurrency class helpers
|
|
|
|
// Return the highest order bit composing dwTarget in wBit
|
|
#define HI_BIT(dwTarget, wBit) \
|
|
do \
|
|
{ \
|
|
if (dwTarget != 0) \
|
|
for (wBit = 32; (dwTarget & (0x00000001 << wBit-1)) == 0; wBit--);\
|
|
else \
|
|
wBit = 0; \
|
|
} while (0)
|
|
|
|
// Left shift an (assumed unsigned) currency by wBits
|
|
#define LSHIFT_UCUR(cur, wBits) \
|
|
do \
|
|
{ \
|
|
for (WORD wTempBits = wBits; wTempBits > 0; wTempBits--) \
|
|
{ \
|
|
cur.m_cur.Hi = ((DWORD)cur.m_cur.Hi << 1); \
|
|
cur.m_cur.Hi |= (cur.m_cur.Lo & 0x80000000) >> 31; \
|
|
cur.m_cur.Lo = cur.m_cur.Lo << 1; \
|
|
} \
|
|
} while (0)
|
|
|
|
// Right shift an (assumed unsigned) currency by wBits
|
|
#define RSHIFT_UCUR(cur, wBits) \
|
|
do \
|
|
{ \
|
|
for (WORD wTempBits = wBits; wTempBits > 0; wTempBits--) \
|
|
{ \
|
|
cur.m_cur.Lo = cur.m_cur.Lo >> 1; \
|
|
cur.m_cur.Lo |= (cur.m_cur.Hi & 0x00000001) << 31; \
|
|
cur.m_cur.Hi = ((DWORD)cur.m_cur.Hi >> 1); \
|
|
} \
|
|
} while (0)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleCurrency class (internally currency is 8-byte int scaled by 10,000)
|
|
|
|
COleCurrency::COleCurrency(long nUnits, long nFractionalUnits)
|
|
{
|
|
SetCurrency(nUnits, nFractionalUnits);
|
|
SetStatus(valid);
|
|
}
|
|
|
|
const COleCurrency& COleCurrency::operator=(CURRENCY cySrc)
|
|
{
|
|
m_cur = cySrc;
|
|
SetStatus(valid);
|
|
return *this;
|
|
}
|
|
|
|
const COleCurrency& COleCurrency::operator=(const COleCurrency& curSrc)
|
|
{
|
|
m_cur = curSrc.m_cur;
|
|
m_status = curSrc.m_status;
|
|
return *this;
|
|
}
|
|
|
|
const COleCurrency& COleCurrency::operator=(const VARIANT& varSrc)
|
|
{
|
|
if (varSrc.vt != VT_CY)
|
|
{
|
|
TRY
|
|
{
|
|
COleVariant varTemp(varSrc);
|
|
varTemp.ChangeType(VT_CY);
|
|
m_cur = varTemp.cyVal;
|
|
SetStatus(valid);
|
|
}
|
|
// Catch COleException from ChangeType, but not CMemoryException
|
|
CATCH(COleException, e)
|
|
{
|
|
// Not able to convert VARIANT to CURRENCY
|
|
m_cur.Hi = 0;
|
|
m_cur.Lo = 0;
|
|
SetStatus(invalid);
|
|
DELETE_EXCEPTION(e);
|
|
}
|
|
END_CATCH
|
|
}
|
|
else
|
|
{
|
|
m_cur = varSrc.cyVal;
|
|
SetStatus(valid);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
BOOL COleCurrency::operator<(const COleCurrency& cur) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(cur.GetStatus() == valid);
|
|
|
|
return((m_cur.Hi == cur.m_cur.Hi) ?
|
|
(m_cur.Lo < cur.m_cur.Lo) : (m_cur.Hi < cur.m_cur.Hi));
|
|
}
|
|
|
|
BOOL COleCurrency::operator>(const COleCurrency& cur) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(cur.GetStatus() == valid);
|
|
|
|
return((m_cur.Hi == cur.m_cur.Hi) ?
|
|
(m_cur.Lo > cur.m_cur.Lo) : (m_cur.Hi > cur.m_cur.Hi));
|
|
}
|
|
|
|
BOOL COleCurrency::operator<=(const COleCurrency& cur) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(cur.GetStatus() == valid);
|
|
|
|
return((m_cur.Hi == cur.m_cur.Hi) ?
|
|
(m_cur.Lo <= cur.m_cur.Lo) : (m_cur.Hi < cur.m_cur.Hi));
|
|
}
|
|
|
|
BOOL COleCurrency::operator>=(const COleCurrency& cur) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(cur.GetStatus() == valid);
|
|
|
|
return((m_cur.Hi == cur.m_cur.Hi) ?
|
|
(m_cur.Lo >= cur.m_cur.Lo) : (m_cur.Hi > cur.m_cur.Hi));
|
|
}
|
|
|
|
COleCurrency COleCurrency::operator+(const COleCurrency& cur) const
|
|
{
|
|
COleCurrency curResult;
|
|
|
|
// If either operand Null, result Null
|
|
if (GetStatus() == null || cur.GetStatus() == null)
|
|
{
|
|
curResult.SetStatus(null);
|
|
return curResult;
|
|
}
|
|
|
|
// If either operand Invalid, result Invalid
|
|
if (GetStatus() == invalid || cur.GetStatus() == invalid)
|
|
{
|
|
curResult.SetStatus(invalid);
|
|
return curResult;
|
|
}
|
|
|
|
// Add separate CURRENCY components
|
|
curResult.m_cur.Hi = m_cur.Hi + cur.m_cur.Hi;
|
|
curResult.m_cur.Lo = m_cur.Lo + cur.m_cur.Lo;
|
|
|
|
// Increment Hi if Lo overflows
|
|
if (m_cur.Lo > curResult.m_cur.Lo)
|
|
curResult.m_cur.Hi++;
|
|
|
|
// Overflow if operands same sign and result sign different
|
|
if (!((m_cur.Hi ^ cur.m_cur.Hi) & 0x80000000) &&
|
|
((m_cur.Hi ^ curResult.m_cur.Hi) & 0x80000000))
|
|
{
|
|
curResult.SetStatus(invalid);
|
|
}
|
|
|
|
return curResult;
|
|
}
|
|
|
|
COleCurrency COleCurrency::operator-(const COleCurrency& cur) const
|
|
{
|
|
COleCurrency curResult;
|
|
|
|
// If either operand Null, result Null
|
|
if (GetStatus() == null || cur.GetStatus() == null)
|
|
{
|
|
curResult.SetStatus(null);
|
|
return curResult;
|
|
}
|
|
|
|
// If either operand Invalid, result Invalid
|
|
if (GetStatus() == invalid || cur.GetStatus() == invalid)
|
|
{
|
|
curResult.SetStatus(invalid);
|
|
return curResult;
|
|
}
|
|
|
|
// Subtract separate CURRENCY components
|
|
curResult.m_cur.Hi = m_cur.Hi - cur.m_cur.Hi;
|
|
curResult.m_cur.Lo = m_cur.Lo - cur.m_cur.Lo;
|
|
|
|
// Decrement Hi if Lo overflows
|
|
if (m_cur.Lo < curResult.m_cur.Lo)
|
|
curResult.m_cur.Hi--;
|
|
|
|
// Overflow if operands not same sign and result not same sign
|
|
if (((m_cur.Hi ^ cur.m_cur.Hi) & 0x80000000) &&
|
|
((m_cur.Hi ^ curResult.m_cur.Hi) & 0x80000000))
|
|
{
|
|
curResult.SetStatus(invalid);
|
|
}
|
|
|
|
return curResult;
|
|
}
|
|
|
|
COleCurrency COleCurrency::operator-() const
|
|
{
|
|
// If operand not Valid, just return
|
|
if (!GetStatus() == valid)
|
|
return *this;
|
|
|
|
COleCurrency curResult;
|
|
|
|
// Negating MIN_CURRENCY,will set invalid
|
|
if (m_cur.Hi == 0x80000000 && m_cur.Lo == 0x00000000)
|
|
{
|
|
curResult.SetStatus(invalid);
|
|
}
|
|
|
|
curResult.m_cur.Hi = ~m_cur.Hi;
|
|
curResult.m_cur.Lo = -(long)m_cur.Lo;
|
|
|
|
// If cy was -1 make sure Hi correctly set
|
|
if (curResult.m_cur.Lo == 0)
|
|
curResult.m_cur.Hi++;
|
|
|
|
return curResult;
|
|
}
|
|
|
|
COleCurrency COleCurrency::operator*(long nOperand) const
|
|
{
|
|
// If operand not Valid, just return
|
|
if (!GetStatus() == valid)
|
|
return *this;
|
|
|
|
COleCurrency curResult(m_cur);
|
|
DWORD nTempOp;
|
|
|
|
// Return now if one operand is 0 (optimization)
|
|
if ((m_cur.Hi == 0x00000000 && m_cur.Lo == 0x00000000) || nOperand == 0)
|
|
{
|
|
curResult.m_cur.Hi = 0;
|
|
curResult.m_cur.Lo = 0;
|
|
return curResult;
|
|
}
|
|
|
|
// Handle only valid case of multiplying MIN_CURRENCY
|
|
if (m_cur.Hi == 0x80000000 && m_cur.Lo == 0x00000000 && nOperand == 1)
|
|
return curResult;
|
|
|
|
// Compute absolute values.
|
|
if (m_cur.Hi < 0)
|
|
curResult = -curResult;
|
|
|
|
nTempOp = labs(nOperand);
|
|
|
|
// Check for overflow
|
|
if (curResult.m_cur.Hi != 0)
|
|
{
|
|
WORD wHiBitCur, wHiBitOp;
|
|
HI_BIT(curResult.m_cur.Hi, wHiBitCur);
|
|
HI_BIT(nTempOp, wHiBitOp);
|
|
|
|
// 63-bit limit on result. (n bits)*(m bits) = (n+m-1) bits.
|
|
if (wHiBitCur + wHiBitOp - 1 > 63)
|
|
{
|
|
// Overflow!
|
|
curResult.SetStatus(invalid);
|
|
|
|
// Set to maximum negative value
|
|
curResult.m_cur.Hi = 0x80000000;
|
|
curResult.m_cur.Lo = 0x00000000;
|
|
|
|
return curResult;
|
|
}
|
|
}
|
|
|
|
// Break up into WORDs
|
|
WORD wCy4, wCy3, wCy2, wCy1, wL2, wL1;
|
|
|
|
wCy4 = HIWORD(curResult.m_cur.Hi);
|
|
wCy3 = LOWORD(curResult.m_cur.Hi);
|
|
wCy2 = HIWORD(curResult.m_cur.Lo);
|
|
wCy1 = LOWORD(curResult.m_cur.Lo);
|
|
|
|
wL2 = HIWORD(nTempOp);
|
|
wL1 = LOWORD(nTempOp);
|
|
|
|
// Multiply each set of WORDs
|
|
DWORD dwRes11, dwRes12, dwRes21, dwRes22;
|
|
DWORD dwRes31, dwRes32, dwRes41; // Don't need dwRes42
|
|
|
|
dwRes11 = wCy1 * wL1;
|
|
dwRes12 = wCy1 * wL2;
|
|
dwRes21 = wCy2 * wL1;
|
|
dwRes22 = wCy2 * wL2;
|
|
|
|
dwRes31 = wCy3 * wL1;
|
|
dwRes32 = wCy3 * wL2;
|
|
dwRes41 = wCy4 * wL1;
|
|
|
|
// Add up low order pieces
|
|
dwRes11 += dwRes12<<16;
|
|
curResult.m_cur.Lo = dwRes11 + (dwRes21<<16);
|
|
|
|
// Check if carry required
|
|
if (dwRes11 < dwRes12<<16 || (DWORD)curResult.m_cur.Lo < dwRes11)
|
|
curResult.m_cur.Hi = 1;
|
|
else
|
|
curResult.m_cur.Hi = 0;
|
|
|
|
// Add up the high order pieces
|
|
curResult.m_cur.Hi += dwRes31 + (dwRes32<<16) + (dwRes41<<16) +
|
|
dwRes22 + (dwRes12>>16) + (dwRes21>>16);
|
|
|
|
// Compute result sign
|
|
if ((m_cur.Hi ^ nOperand) & 0x80000000)
|
|
curResult = -curResult;
|
|
|
|
return curResult;
|
|
}
|
|
|
|
COleCurrency COleCurrency::operator/(long nOperand) const
|
|
{
|
|
// If operand not Valid, just return
|
|
if (!GetStatus() == valid)
|
|
return *this;
|
|
|
|
COleCurrency curTemp(m_cur);
|
|
DWORD nTempOp;
|
|
|
|
// Check for divide by 0
|
|
if (nOperand == 0)
|
|
{
|
|
curTemp.SetStatus(invalid);
|
|
|
|
// Set to maximum negative value
|
|
curTemp.m_cur.Hi = 0x80000000;
|
|
curTemp.m_cur.Lo = 0x00000000;
|
|
|
|
return curTemp;
|
|
}
|
|
|
|
// Compute absolute values
|
|
if (curTemp.m_cur.Hi < 0)
|
|
curTemp = -curTemp;
|
|
|
|
nTempOp = labs(nOperand);
|
|
|
|
// Optimization - division is simple if Hi == 0
|
|
if (curTemp.m_cur.Hi == 0x0000)
|
|
{
|
|
curTemp.m_cur.Lo = m_cur.Lo / nTempOp;
|
|
|
|
// Compute result sign
|
|
if ((m_cur.Hi ^ nOperand) & 0x80000000)
|
|
curTemp = -curTemp;
|
|
|
|
return curTemp;
|
|
}
|
|
|
|
// Now curTemp represents remainder
|
|
COleCurrency curResult; // Initializes to zero
|
|
COleCurrency curTempResult;
|
|
COleCurrency curOperand;
|
|
|
|
curOperand.m_cur.Lo = nTempOp;
|
|
|
|
WORD wHiBitRem;
|
|
WORD wScaleOp;
|
|
|
|
// Quit if remainder can be truncated
|
|
while (curTemp >= curOperand)
|
|
{
|
|
// Scale up and divide Hi portion
|
|
HI_BIT(curTemp.m_cur.Hi, wHiBitRem);
|
|
|
|
if (wHiBitRem != 0)
|
|
wHiBitRem += 32;
|
|
else
|
|
HI_BIT(curTemp.m_cur.Lo, wHiBitRem);
|
|
|
|
WORD wShift = (WORD)(64 - wHiBitRem);
|
|
LSHIFT_UCUR(curTemp, wShift);
|
|
|
|
// If Operand bigger than Hi it must be scaled
|
|
wScaleOp = (WORD)((nTempOp > (DWORD)curTemp.m_cur.Hi) ? 1 : 0);
|
|
|
|
// Perform synthetic division
|
|
curTempResult.m_cur.Hi =
|
|
(DWORD)curTemp.m_cur.Hi / (nTempOp >> wScaleOp);
|
|
|
|
// Scale back to get correct result and remainder
|
|
RSHIFT_UCUR(curTemp, wShift);
|
|
wShift = (WORD)(wShift - wScaleOp);
|
|
RSHIFT_UCUR(curTempResult, wShift);
|
|
|
|
// Now calculate result and remainder
|
|
curResult += curTempResult;
|
|
curTemp -= curTempResult * nTempOp;
|
|
}
|
|
|
|
// Compute result sign
|
|
if ((m_cur.Hi ^ nOperand) & 0x80000000)
|
|
curResult = -curResult;
|
|
|
|
return curResult;
|
|
}
|
|
|
|
void COleCurrency::SetCurrency(long nUnits, long nFractionalUnits)
|
|
{
|
|
COleCurrency curUnits; // Initializes to 0
|
|
COleCurrency curFractionalUnits; // Initializes to 0
|
|
|
|
// Set temp currency value to Units (need to multiply by 10,000)
|
|
curUnits.m_cur.Lo = (DWORD)labs(nUnits);
|
|
curUnits = curUnits * 10000;
|
|
if (nUnits < 0)
|
|
curUnits = -curUnits;
|
|
|
|
curFractionalUnits.m_cur.Lo = (DWORD)labs(nFractionalUnits);
|
|
if (nFractionalUnits < 0)
|
|
curFractionalUnits = -curFractionalUnits;
|
|
|
|
// Now add together Units and FractionalUnits
|
|
*this = curUnits + curFractionalUnits;
|
|
|
|
SetStatus(valid);
|
|
}
|
|
|
|
BOOL COleCurrency::ParseCurrency(LPCTSTR lpszCurrency,
|
|
DWORD dwFlags, LCID lcid)
|
|
{
|
|
USES_CONVERSION;
|
|
CString strCurrency = lpszCurrency;
|
|
|
|
SCODE sc;
|
|
if ( FAILED(sc = VarCyFromStr((LPOLESTR)T2COLE(strCurrency),
|
|
lcid, dwFlags, &m_cur)))
|
|
{
|
|
if (sc == DISP_E_TYPEMISMATCH)
|
|
{
|
|
// Can't convert string to CURRENCY, set 0 & invalid
|
|
m_cur.Hi = 0x00000000;
|
|
m_cur.Lo = 0x00000000;
|
|
SetStatus(invalid);
|
|
return FALSE;
|
|
}
|
|
else if (sc == DISP_E_OVERFLOW)
|
|
{
|
|
// Can't convert string to CURRENCY, set max neg & invalid
|
|
m_cur.Hi = 0x80000000;
|
|
m_cur.Lo = 0x00000000;
|
|
SetStatus(invalid);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("\nCOleCurrency VarCyFromStr call failed.\n\t");
|
|
if (sc == E_OUTOFMEMORY)
|
|
AfxThrowMemoryException();
|
|
else
|
|
AfxThrowOleException(sc);
|
|
}
|
|
}
|
|
|
|
SetStatus(valid);
|
|
return TRUE;
|
|
}
|
|
|
|
CString COleCurrency::Format(DWORD dwFlags, LCID lcid) const
|
|
{
|
|
USES_CONVERSION;
|
|
CString strCur;
|
|
|
|
// If null, return empty string
|
|
if (GetStatus() == null)
|
|
return strCur;
|
|
|
|
// If invalid, return Currency resource string
|
|
if (GetStatus() == invalid)
|
|
{
|
|
VERIFY(strCur.LoadString(AFX_IDS_INVALID_CURRENCY));
|
|
return strCur;
|
|
}
|
|
|
|
COleVariant var;
|
|
// Don't need to trap error. Should not fail due to type mismatch
|
|
CheckError(VarBstrFromCy(m_cur, lcid, dwFlags, &V_BSTR(&var)));
|
|
var.vt = VT_BSTR;
|
|
return OLE2CT(V_BSTR(&var));
|
|
}
|
|
|
|
|
|
// serialization
|
|
#ifdef _DEBUG
|
|
CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleCurrency curSrc)
|
|
{
|
|
dc << "\nCOleCurrency Object:";
|
|
dc << "\n\tm_status = " << (long)curSrc.m_status;
|
|
|
|
COleVariant var(curSrc);
|
|
var.ChangeType(VT_CY);
|
|
return dc << "\n\tCurrency = " << (LPCTSTR)var.bstrVal;
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
#ifdef _with_archive_
|
|
CArchive& AFXAPI operator<<(CArchive& ar, COleCurrency curSrc)
|
|
{
|
|
ar << (long)curSrc.m_status;
|
|
ar << curSrc.m_cur.Hi;
|
|
return ar << curSrc.m_cur.Lo;
|
|
}
|
|
|
|
CArchive& AFXAPI operator>>(CArchive& ar, COleCurrency& curSrc)
|
|
{
|
|
ar >> (long&)curSrc.m_status;
|
|
ar >> curSrc.m_cur.Hi;
|
|
return ar >> curSrc.m_cur.Lo;
|
|
}
|
|
#endif //_with_archive_
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleDateTime class HELPER definitions
|
|
|
|
// Verifies will fail if the needed buffer size is too large
|
|
#define MAX_TIME_BUFFER_SIZE 128 // matches that in timecore.cpp
|
|
#define MIN_DATE (-657434L) // about year 100
|
|
#define MAX_DATE 2958465L // about year 9999
|
|
|
|
// Half a second, expressed in days
|
|
#define HALF_SECOND (1.0/172800.0)
|
|
|
|
// One-based array of days in year at month start
|
|
static int rgMonthDays[13] =
|
|
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
|
|
|
|
static BOOL OleDateFromTm(WORD wYear, WORD wMonth, WORD wDay,
|
|
WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest);
|
|
static BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest);
|
|
static void TmConvertToStandardFormat(struct tm& tmSrc);
|
|
static double DoubleFromDate(DATE dt);
|
|
static DATE DateFromDouble(double dbl);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleDateTime class
|
|
|
|
COleDateTime PASCAL COleDateTime::GetCurrentTime()
|
|
{
|
|
return COleDateTime(::time(NULL));
|
|
}
|
|
|
|
int COleDateTime::GetYear() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_year;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetMonth() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_mon;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetDay() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_mday;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetHour() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_hour;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetMinute() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_min;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetSecond() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_sec;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetDayOfWeek() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_wday;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
int COleDateTime::GetDayOfYear() const
|
|
{
|
|
struct tm tmTemp;
|
|
|
|
if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
|
|
return tmTemp.tm_yday;
|
|
else
|
|
return AFX_OLE_DATETIME_ERROR;
|
|
}
|
|
|
|
const COleDateTime& COleDateTime::operator=(const VARIANT& varSrc)
|
|
{
|
|
if (varSrc.vt != VT_DATE)
|
|
{
|
|
TRY
|
|
{
|
|
COleVariant varTemp(varSrc);
|
|
varTemp.ChangeType(VT_DATE);
|
|
m_dt = varTemp.date;
|
|
SetStatus(valid);
|
|
}
|
|
// Catch COleException from ChangeType, but not CMemoryException
|
|
CATCH(COleException, e)
|
|
{
|
|
// Not able to convert VARIANT to DATE
|
|
DELETE_EXCEPTION(e);
|
|
m_dt = 0;
|
|
SetStatus(invalid);
|
|
}
|
|
END_CATCH
|
|
}
|
|
else
|
|
{
|
|
m_dt = varSrc.date;
|
|
SetStatus(valid);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleDateTime& COleDateTime::operator=(DATE dtSrc)
|
|
{
|
|
m_dt = dtSrc;
|
|
SetStatus(valid);
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleDateTime& COleDateTime::operator=(const time_t& timeSrc)
|
|
{
|
|
// Convert time_t to struct tm
|
|
tm *ptm = localtime(&timeSrc);
|
|
|
|
if (ptm != NULL)
|
|
{
|
|
m_status = OleDateFromTm((WORD)ptm->tm_year + 1900,
|
|
(WORD)(ptm->tm_mon + 1), (WORD)ptm->tm_mday,
|
|
(WORD)ptm->tm_hour, (WORD)ptm->tm_min,
|
|
(WORD)ptm->tm_sec, m_dt) ? valid : invalid;
|
|
}
|
|
else
|
|
{
|
|
// Local time must have failed (timsSrc before 1/1/70 12am)
|
|
SetStatus(invalid);
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleDateTime& COleDateTime::operator=(const SYSTEMTIME& systimeSrc)
|
|
{
|
|
m_status = OleDateFromTm(systimeSrc.wYear, systimeSrc.wMonth,
|
|
systimeSrc.wDay, systimeSrc.wHour, systimeSrc.wMinute,
|
|
systimeSrc.wSecond, m_dt) ? valid : invalid;
|
|
|
|
return *this;
|
|
}
|
|
|
|
const COleDateTime& COleDateTime::operator=(const FILETIME& filetimeSrc)
|
|
{
|
|
// Assume UTC FILETIME, so convert to LOCALTIME
|
|
FILETIME filetimeLocal;
|
|
if (!FileTimeToLocalFileTime( &filetimeSrc, &filetimeLocal))
|
|
{
|
|
#ifdef _DEBUG
|
|
DWORD dwError = GetLastError();
|
|
TRACE1("\nFileTimeToLocalFileTime failed. Error = %lu.\n\t", dwError);
|
|
#endif // _DEBUG
|
|
m_status = invalid;
|
|
}
|
|
else
|
|
{
|
|
// Take advantage of SYSTEMTIME -> FILETIME conversion
|
|
SYSTEMTIME systime;
|
|
m_status = FileTimeToSystemTime(&filetimeLocal, &systime) ?
|
|
valid : invalid;
|
|
|
|
// At this point systime should always be valid, but...
|
|
if (GetStatus() == valid)
|
|
{
|
|
m_status = OleDateFromTm(systime.wYear, systime.wMonth,
|
|
systime.wDay, systime.wHour, systime.wMinute,
|
|
systime.wSecond, m_dt) ? valid : invalid;
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
BOOL COleDateTime::operator<(const COleDateTime& date) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(date.GetStatus() == valid);
|
|
|
|
// Handle negative dates
|
|
return DoubleFromDate(m_dt) < DoubleFromDate(date.m_dt);
|
|
}
|
|
|
|
BOOL COleDateTime::operator>(const COleDateTime& date) const
|
|
{ ASSERT(GetStatus() == valid);
|
|
ASSERT(date.GetStatus() == valid);
|
|
|
|
// Handle negative dates
|
|
return DoubleFromDate(m_dt) > DoubleFromDate(date.m_dt);
|
|
}
|
|
|
|
BOOL COleDateTime::operator<=(const COleDateTime& date) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(date.GetStatus() == valid);
|
|
|
|
// Handle negative dates
|
|
return DoubleFromDate(m_dt) <= DoubleFromDate(date.m_dt);
|
|
}
|
|
|
|
BOOL COleDateTime::operator>=(const COleDateTime& date) const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
ASSERT(date.GetStatus() == valid);
|
|
|
|
// Handle negative dates
|
|
return DoubleFromDate(m_dt) >= DoubleFromDate(date.m_dt);
|
|
}
|
|
|
|
COleDateTime COleDateTime::operator+(const COleDateTimeSpan& dateSpan) const
|
|
{
|
|
COleDateTime dateResult; // Initializes m_status to valid
|
|
|
|
// If either operand NULL, result NULL
|
|
if (GetStatus() == null || dateSpan.GetStatus() == null)
|
|
{
|
|
dateResult.SetStatus(null);
|
|
return dateResult;
|
|
}
|
|
|
|
// If either operand invalid, result invalid
|
|
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
|
|
{
|
|
dateResult.SetStatus(invalid);
|
|
return dateResult;
|
|
}
|
|
|
|
// Compute the actual date difference by adding underlying dates
|
|
dateResult = DateFromDouble(DoubleFromDate(m_dt) + dateSpan.m_span);
|
|
|
|
// Validate within range
|
|
dateResult.CheckRange();
|
|
|
|
return dateResult;
|
|
}
|
|
|
|
COleDateTime COleDateTime::operator-(const COleDateTimeSpan& dateSpan) const
|
|
{
|
|
COleDateTime dateResult; // Initializes m_status to valid
|
|
|
|
// If either operand NULL, result NULL
|
|
if (GetStatus() == null || dateSpan.GetStatus() == null)
|
|
{
|
|
dateResult.SetStatus(null);
|
|
return dateResult;
|
|
}
|
|
|
|
// If either operand invalid, result invalid
|
|
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
|
|
{
|
|
dateResult.SetStatus(invalid);
|
|
return dateResult;
|
|
}
|
|
|
|
// Compute the actual date difference by subtracting underlying dates
|
|
dateResult = DateFromDouble(DoubleFromDate(m_dt) - dateSpan.m_span);
|
|
|
|
// Validate within range
|
|
dateResult.CheckRange();
|
|
|
|
return dateResult;
|
|
}
|
|
|
|
COleDateTimeSpan COleDateTime::operator-(const COleDateTime& date) const
|
|
{
|
|
COleDateTimeSpan spanResult;
|
|
|
|
// If either operand NULL, result NULL
|
|
if (GetStatus() == null || date.GetStatus() == null)
|
|
{
|
|
spanResult.SetStatus(COleDateTimeSpan::null);
|
|
return spanResult;
|
|
}
|
|
|
|
// If either operand invalid, result invalid
|
|
if (GetStatus() == invalid || date.GetStatus() == invalid)
|
|
{
|
|
spanResult.SetStatus(COleDateTimeSpan::invalid);
|
|
return spanResult;
|
|
}
|
|
|
|
// Return result (span can't be invalid, so don't check range)
|
|
return DoubleFromDate(m_dt) - DoubleFromDate(date.m_dt);
|
|
}
|
|
|
|
BOOL COleDateTime::SetDateTime(int nYear, int nMonth, int nDay,
|
|
int nHour, int nMin, int nSec)
|
|
{
|
|
return m_status = OleDateFromTm((WORD)nYear, (WORD)nMonth,
|
|
(WORD)nDay, (WORD)nHour, (WORD)nMin, (WORD)nSec, m_dt) ?
|
|
valid : invalid;
|
|
}
|
|
|
|
BOOL COleDateTime::ParseDateTime(LPCTSTR lpszDate, DWORD dwFlags, LCID lcid)
|
|
{
|
|
USES_CONVERSION;
|
|
CString strDate = lpszDate;
|
|
|
|
SCODE sc;
|
|
if (FAILED(sc = VarDateFromStr((LPOLESTR)T2COLE(strDate), lcid,
|
|
dwFlags, &m_dt)))
|
|
{
|
|
if (sc == DISP_E_TYPEMISMATCH)
|
|
{
|
|
// Can't convert string to date, set 0 and invalidate
|
|
m_dt = 0;
|
|
SetStatus(invalid);
|
|
return FALSE;
|
|
}
|
|
else if (sc == DISP_E_OVERFLOW)
|
|
{
|
|
// Can't convert string to date, set -1 and invalidate
|
|
m_dt = -1;
|
|
SetStatus(invalid);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("\nCOleDateTime VarDateFromStr call failed.\n\t");
|
|
if (sc == E_OUTOFMEMORY)
|
|
AfxThrowMemoryException();
|
|
else
|
|
AfxThrowOleException(sc);
|
|
}
|
|
}
|
|
|
|
SetStatus(valid);
|
|
return TRUE;
|
|
}
|
|
|
|
CString COleDateTime::Format(DWORD dwFlags, LCID lcid) const
|
|
{
|
|
USES_CONVERSION;
|
|
CString strDate;
|
|
|
|
// If null, return empty string
|
|
if (GetStatus() == null)
|
|
return strDate;
|
|
|
|
// If invalid, return DateTime resource string
|
|
if (GetStatus() == invalid)
|
|
{
|
|
VERIFY(strDate.LoadString(AFX_IDS_INVALID_DATETIME));
|
|
return strDate;
|
|
}
|
|
|
|
COleVariant var;
|
|
// Don't need to trap error. Should not fail due to type mismatch
|
|
CheckError(VarBstrFromDate(m_dt, lcid, dwFlags, &V_BSTR(&var)));
|
|
var.vt = VT_BSTR;
|
|
return OLE2CT(V_BSTR(&var));
|
|
}
|
|
|
|
CString COleDateTime::Format(LPCTSTR pFormat) const
|
|
{
|
|
CString strDate;
|
|
struct tm tmTemp;
|
|
|
|
// If null, return empty string
|
|
if (GetStatus() == null)
|
|
return strDate;
|
|
|
|
// If invalid, return DateTime resource string
|
|
if (GetStatus() == invalid || !TmFromOleDate(m_dt, tmTemp))
|
|
{
|
|
VERIFY(strDate.LoadString(AFX_IDS_INVALID_DATETIME));
|
|
return strDate;
|
|
}
|
|
|
|
// Convert tm from afx internal format to standard format
|
|
TmConvertToStandardFormat(tmTemp);
|
|
|
|
// Fill in the buffer, disregard return value as it's not necessary
|
|
LPTSTR lpszTemp = strDate.GetBufferSetLength(MAX_TIME_BUFFER_SIZE);
|
|
_tcsftime(lpszTemp, strDate.GetLength(), pFormat, &tmTemp);
|
|
strDate.ReleaseBuffer();
|
|
|
|
return strDate;
|
|
}
|
|
|
|
CString COleDateTime::Format(UINT nFormatID) const
|
|
{
|
|
CString strFormat;
|
|
VERIFY(strFormat.LoadString(nFormatID) != 0);
|
|
return Format(strFormat);
|
|
}
|
|
|
|
void COleDateTime::CheckRange()
|
|
{
|
|
if (m_dt > MAX_DATE || m_dt < MIN_DATE) // about year 100 to about 9999
|
|
SetStatus(invalid);
|
|
}
|
|
|
|
// serialization
|
|
#ifdef _DEBUG
|
|
CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleDateTime dateSrc)
|
|
{
|
|
dc << "\nCOleDateTime Object:";
|
|
dc << "\n\tm_status = " << (long)dateSrc.m_status;
|
|
|
|
COleVariant var(dateSrc);
|
|
var.ChangeType(VT_BSTR);
|
|
|
|
return dc << "\n\tdate = " << (LPCTSTR)var.bstrVal;
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
#ifdef _with_archive_
|
|
CArchive& AFXAPI operator<<(CArchive& ar, COleDateTime dateSrc)
|
|
{
|
|
ar << (long)dateSrc.m_status;
|
|
return ar << dateSrc.m_dt;
|
|
}
|
|
|
|
CArchive& AFXAPI operator>>(CArchive& ar, COleDateTime& dateSrc)
|
|
{
|
|
ar >> (long&)dateSrc.m_status;
|
|
return ar >> dateSrc.m_dt;
|
|
}
|
|
#endif //_with_archive_
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleDateTimeSpan class helpers
|
|
|
|
#define MAX_DAYS_IN_SPAN 3615897L
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleDateTimeSpan class
|
|
long COleDateTimeSpan::GetHours() const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
|
|
double dblTemp;
|
|
|
|
// Truncate days and scale up
|
|
dblTemp = modf(m_span, &dblTemp);
|
|
return (long)(dblTemp * 24);
|
|
}
|
|
|
|
long COleDateTimeSpan::GetMinutes() const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
|
|
double dblTemp;
|
|
|
|
// Truncate hours and scale up
|
|
dblTemp = modf(m_span * 24, &dblTemp);
|
|
return (long)(dblTemp * 60);
|
|
}
|
|
|
|
long COleDateTimeSpan::GetSeconds() const
|
|
{
|
|
ASSERT(GetStatus() == valid);
|
|
|
|
double dblTemp;
|
|
|
|
// Truncate minutes and scale up
|
|
dblTemp = modf(m_span * 24 * 60, &dblTemp);
|
|
return (long)(dblTemp * 60);
|
|
}
|
|
|
|
const COleDateTimeSpan& COleDateTimeSpan::operator=(double dblSpanSrc)
|
|
{
|
|
m_span = dblSpanSrc;
|
|
SetStatus(valid);
|
|
return *this;
|
|
}
|
|
|
|
const COleDateTimeSpan& COleDateTimeSpan::operator=(const COleDateTimeSpan& dateSpanSrc)
|
|
{
|
|
m_span = dateSpanSrc.m_span;
|
|
m_status = dateSpanSrc.m_status;
|
|
return *this;
|
|
}
|
|
|
|
COleDateTimeSpan COleDateTimeSpan::operator+(const COleDateTimeSpan& dateSpan) const
|
|
{
|
|
COleDateTimeSpan dateSpanTemp;
|
|
|
|
// If either operand Null, result Null
|
|
if (GetStatus() == null || dateSpan.GetStatus() == null)
|
|
{
|
|
dateSpanTemp.SetStatus(null);
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
// If either operand Invalid, result Invalid
|
|
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
|
|
{
|
|
dateSpanTemp.SetStatus(invalid);
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
// Add spans and validate within legal range
|
|
dateSpanTemp.m_span = m_span + dateSpan.m_span;
|
|
dateSpanTemp.CheckRange();
|
|
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
COleDateTimeSpan COleDateTimeSpan::operator-(const COleDateTimeSpan& dateSpan) const
|
|
{
|
|
COleDateTimeSpan dateSpanTemp;
|
|
|
|
// If either operand Null, result Null
|
|
if (GetStatus() == null || dateSpan.GetStatus() == null)
|
|
{
|
|
dateSpanTemp.SetStatus(null);
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
// If either operand Invalid, result Invalid
|
|
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
|
|
{
|
|
dateSpanTemp.SetStatus(invalid);
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
// Subtract spans and validate within legal range
|
|
dateSpanTemp.m_span = m_span - dateSpan.m_span;
|
|
dateSpanTemp.CheckRange();
|
|
|
|
return dateSpanTemp;
|
|
}
|
|
|
|
void COleDateTimeSpan::SetDateTimeSpan(
|
|
long lDays, int nHours, int nMins, int nSecs)
|
|
{
|
|
// Set date span by breaking into fractional days (all input ranges valid)
|
|
m_span = lDays + ((double)nHours)/24 + ((double)nMins)/(24*60) +
|
|
((double)nSecs)/(24*60*60);
|
|
|
|
SetStatus(valid);
|
|
}
|
|
|
|
CString COleDateTimeSpan::Format(LPCTSTR pFormat) const
|
|
{
|
|
CString strSpan;
|
|
struct tm tmTemp;
|
|
|
|
// If null, return empty string
|
|
if (GetStatus() == null)
|
|
return strSpan;
|
|
|
|
// If invalid, return DateTimeSpan resource string
|
|
if (GetStatus() == invalid || !TmFromOleDate(m_span, tmTemp))
|
|
{
|
|
VERIFY(strSpan.LoadString(AFX_IDS_INVALID_DATETIMESPAN));
|
|
return strSpan;
|
|
}
|
|
|
|
// Convert tm from afx internal format to standard format
|
|
TmConvertToStandardFormat(tmTemp);
|
|
|
|
// Fill in the buffer, disregard return value as it's not necessary
|
|
LPTSTR lpszTemp = strSpan.GetBufferSetLength(MAX_TIME_BUFFER_SIZE);
|
|
_tcsftime(lpszTemp, strSpan.GetLength(), pFormat, &tmTemp);
|
|
strSpan.ReleaseBuffer();
|
|
|
|
return strSpan;
|
|
}
|
|
|
|
CString COleDateTimeSpan::Format(UINT nFormatID) const
|
|
{
|
|
CString strFormat;
|
|
VERIFY(strFormat.LoadString(nFormatID) != 0);
|
|
return Format(strFormat);
|
|
}
|
|
|
|
void COleDateTimeSpan::CheckRange()
|
|
{
|
|
if(m_span < -MAX_DAYS_IN_SPAN || m_span > MAX_DAYS_IN_SPAN)
|
|
SetStatus(invalid);
|
|
}
|
|
|
|
// serialization
|
|
#ifdef _DEBUG
|
|
CDumpContext& AFXAPI operator<<(CDumpContext& dc, COleDateTimeSpan dateSpanSrc)
|
|
{
|
|
dc << "\nCOleDateTimeSpan Object:";
|
|
dc << "\n\tm_status = " << (long)dateSpanSrc.m_status;
|
|
|
|
COleVariant var(dateSpanSrc.m_span);
|
|
var.ChangeType(VT_BSTR);
|
|
|
|
return dc << "\n\tdateSpan = " << (LPCTSTR)var.bstrVal;
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
#ifdef _with_archive_
|
|
CArchive& AFXAPI operator<<(CArchive& ar, COleDateTimeSpan dateSpanSrc)
|
|
{
|
|
ar << (long)dateSpanSrc.m_status;
|
|
return ar << dateSpanSrc.m_span;
|
|
}
|
|
|
|
CArchive& AFXAPI operator>>(CArchive& ar, COleDateTimeSpan& dateSpanSrc)
|
|
{
|
|
ar >> (long&)dateSpanSrc.m_status;
|
|
return ar >> dateSpanSrc.m_span;
|
|
}
|
|
#endif //_with_archive_
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleDateTime class HELPERS - implementation
|
|
|
|
BOOL OleDateFromTm(WORD wYear, WORD wMonth, WORD wDay,
|
|
WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest)
|
|
{
|
|
// Validate year and month (ignore day of week and milliseconds)
|
|
if (wYear > 9999 || wMonth < 1 || wMonth > 12)
|
|
return FALSE;
|
|
|
|
// Check for leap year and set the number of days in the month
|
|
BOOL bLeapYear = ((wYear & 3) == 0) &&
|
|
((wYear % 100) != 0 || (wYear % 400) == 0);
|
|
|
|
int nDaysInMonth =
|
|
rgMonthDays[wMonth] - rgMonthDays[wMonth-1] +
|
|
((bLeapYear && wDay == 29 && wMonth == 2) ? 1 : 0);
|
|
|
|
// Finish validating the date
|
|
if (wDay < 1 || wDay > nDaysInMonth ||
|
|
wHour > 23 || wMinute > 59 ||
|
|
wSecond > 59)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Cache the date in days and time in fractional days
|
|
long nDate;
|
|
double dblTime;
|
|
|
|
//It is a valid date; make Jan 1, 1AD be 1
|
|
nDate = wYear*365L + wYear/4 - wYear/100 + wYear/400 +
|
|
rgMonthDays[wMonth-1] + wDay;
|
|
|
|
// If leap year and it's before March, subtract 1:
|
|
if (wMonth <= 2 && bLeapYear)
|
|
--nDate;
|
|
|
|
// Offset so that 12/30/1899 is 0
|
|
nDate -= 693959L;
|
|
|
|
dblTime = (((long)wHour * 3600L) + // hrs in seconds
|
|
((long)wMinute * 60L) + // mins in seconds
|
|
((long)wSecond)) / 86400.;
|
|
|
|
dtDest = (double) nDate + ((nDate >= 0) ? dblTime : -dblTime);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest)
|
|
{
|
|
// The legal range does not actually span year 0 to 9999.
|
|
if (dtSrc > MAX_DATE || dtSrc < MIN_DATE) // about year 100 to about 9999
|
|
return FALSE;
|
|
|
|
long nDays; // Number of days since Dec. 30, 1899
|
|
long nDaysAbsolute; // Number of days since 1/1/0
|
|
long nSecsInDay; // Time in seconds since midnight
|
|
long nMinutesInDay; // Minutes in day
|
|
|
|
long n400Years; // Number of 400 year increments since 1/1/0
|
|
long n400Century; // Century within 400 year block (0,1,2 or 3)
|
|
long n4Years; // Number of 4 year increments since 1/1/0
|
|
long n4Day; // Day within 4 year block
|
|
// (0 is 1/1/yr1, 1460 is 12/31/yr4)
|
|
long n4Yr; // Year within 4 year block (0,1,2 or 3)
|
|
BOOL bLeap4 = TRUE; // TRUE if 4 year block includes leap year
|
|
|
|
double dblDate = dtSrc; // tempory serial date
|
|
|
|
// If a valid date, then this conversion should not overflow
|
|
nDays = (long)dblDate;
|
|
|
|
// Round to the second
|
|
dblDate += ((dtSrc > 0.0) ? HALF_SECOND : -HALF_SECOND);
|
|
|
|
nDaysAbsolute = (long)dblDate + 693959L; // Add days from 1/1/0 to 12/30/1899
|
|
|
|
dblDate = fabs(dblDate);
|
|
nSecsInDay = (long)((dblDate - floor(dblDate)) * 86400.);
|
|
|
|
// Calculate the day of week (sun=1, mon=2...)
|
|
// -1 because 1/1/0 is Sat. +1 because we want 1-based
|
|
tmDest.tm_wday = (int)((nDaysAbsolute - 1) % 7L) + 1;
|
|
|
|
// Leap years every 4 yrs except centuries not multiples of 400.
|
|
n400Years = (long)(nDaysAbsolute / 146097L);
|
|
|
|
// Set nDaysAbsolute to day within 400-year block
|
|
nDaysAbsolute %= 146097L;
|
|
|
|
// -1 because first century has extra day
|
|
n400Century = (long)((nDaysAbsolute - 1) / 36524L);
|
|
|
|
// Non-leap century
|
|
if (n400Century != 0)
|
|
{
|
|
// Set nDaysAbsolute to day within century
|
|
nDaysAbsolute = (nDaysAbsolute - 1) % 36524L;
|
|
|
|
// +1 because 1st 4 year increment has 1460 days
|
|
n4Years = (long)((nDaysAbsolute + 1) / 1461L);
|
|
|
|
if (n4Years != 0)
|
|
n4Day = (long)((nDaysAbsolute + 1) % 1461L);
|
|
else
|
|
{
|
|
bLeap4 = FALSE;
|
|
n4Day = (long)nDaysAbsolute;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Leap century - not special case!
|
|
n4Years = (long)(nDaysAbsolute / 1461L);
|
|
n4Day = (long)(nDaysAbsolute % 1461L);
|
|
}
|
|
|
|
if (bLeap4)
|
|
{
|
|
// -1 because first year has 366 days
|
|
n4Yr = (n4Day - 1) / 365;
|
|
|
|
if (n4Yr != 0)
|
|
n4Day = (n4Day - 1) % 365;
|
|
}
|
|
else
|
|
{
|
|
n4Yr = n4Day / 365;
|
|
n4Day %= 365;
|
|
}
|
|
|
|
// n4Day is now 0-based day of year. Save 1-based day of year, year number
|
|
tmDest.tm_yday = (int)n4Day + 1;
|
|
tmDest.tm_year = n400Years * 400 + n400Century * 100 + n4Years * 4 + n4Yr;
|
|
|
|
// Handle leap year: before, on, and after Feb. 29.
|
|
if (n4Yr == 0 && bLeap4)
|
|
{
|
|
// Leap Year
|
|
if (n4Day == 59)
|
|
{
|
|
/* Feb. 29 */
|
|
tmDest.tm_mon = 2;
|
|
tmDest.tm_mday = 29;
|
|
goto DoTime;
|
|
}
|
|
|
|
// Pretend it's not a leap year for month/day comp.
|
|
if (n4Day >= 60)
|
|
--n4Day;
|
|
}
|
|
|
|
// Make n4DaY a 1-based day of non-leap year and compute
|
|
// month/day for everything but Feb. 29.
|
|
++n4Day;
|
|
|
|
// Month number always >= n/32, so save some loop time */
|
|
for (tmDest.tm_mon = (n4Day >> 5) + 1;
|
|
n4Day > rgMonthDays[tmDest.tm_mon]; tmDest.tm_mon++);
|
|
|
|
tmDest.tm_mday = (int)(n4Day - rgMonthDays[tmDest.tm_mon-1]);
|
|
|
|
DoTime:
|
|
if (nSecsInDay == 0)
|
|
tmDest.tm_hour = tmDest.tm_min = tmDest.tm_sec = 0;
|
|
else
|
|
{
|
|
tmDest.tm_sec = (int)nSecsInDay % 60L;
|
|
nMinutesInDay = nSecsInDay / 60L;
|
|
tmDest.tm_min = (int)nMinutesInDay % 60;
|
|
tmDest.tm_hour = (int)nMinutesInDay / 60;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TmConvertToStandardFormat(struct tm& tmSrc)
|
|
{
|
|
// Convert afx internal tm to format expected by runtimes (_tcsftime, etc)
|
|
tmSrc.tm_year -= 1900; // year is based on 1900
|
|
tmSrc.tm_mon -= 1; // month of year is 0-based
|
|
tmSrc.tm_wday -= 1; // day of week is 0-based
|
|
tmSrc.tm_yday -= 1; // day of year is 0-based
|
|
}
|
|
|
|
double DoubleFromDate(DATE dt)
|
|
{
|
|
// No problem if positive
|
|
if (dt >= 0)
|
|
return dt;
|
|
|
|
// If negative, must convert since negative dates not continuous
|
|
// (examples: -1.25 to -.75, -1.50 to -.50, -1.75 to -.25)
|
|
double temp = ceil(dt);
|
|
return temp - (dt - temp);
|
|
}
|
|
|
|
DATE DateFromDouble(double dbl)
|
|
{
|
|
// No problem if positive
|
|
if (dbl >= 0)
|
|
return dbl;
|
|
|
|
// If negative, must convert since negative dates not continuous
|
|
// (examples: -.75 to -1.25, -.50 to -1.50, -.25 to -1.75)
|
|
double temp = floor(dbl); // dbl is now whole part
|
|
return temp + (temp - dbl);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COleSafeArray class
|
|
COleSafeArray::COleSafeArray(const SAFEARRAY& saSrc, VARTYPE vtSrc)
|
|
{
|
|
AfxSafeArrayInit(this);
|
|
vt = vtSrc | VT_ARRAY;
|
|
CheckError(::SafeArrayCopy((LPSAFEARRAY)&saSrc, &parray));
|
|
m_dwDims = GetDim();
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
COleSafeArray::COleSafeArray(LPCSAFEARRAY pSrc, VARTYPE vtSrc)
|
|
{
|
|
AfxSafeArrayInit(this);
|
|
vt = vtSrc | VT_ARRAY;
|
|
CheckError(::SafeArrayCopy((LPSAFEARRAY)pSrc, &parray));
|
|
m_dwDims = GetDim();
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
COleSafeArray::COleSafeArray(const COleSafeArray& saSrc)
|
|
{
|
|
AfxSafeArrayInit(this);
|
|
*this = saSrc;
|
|
m_dwDims = GetDim();
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
COleSafeArray::COleSafeArray(const VARIANT& varSrc)
|
|
{
|
|
AfxSafeArrayInit(this);
|
|
*this = varSrc;
|
|
m_dwDims = GetDim();
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
COleSafeArray::COleSafeArray(LPCVARIANT pSrc)
|
|
{
|
|
AfxSafeArrayInit(this);
|
|
*this = pSrc;
|
|
m_dwDims = GetDim();
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
// Operations
|
|
void COleSafeArray::Attach(VARIANT& varSrc)
|
|
{
|
|
ASSERT(varSrc.vt & VT_ARRAY);
|
|
|
|
// Free up previous safe array if necessary
|
|
Clear();
|
|
|
|
// give control of data to COleSafeArray
|
|
memcpy(this, &varSrc, sizeof(varSrc));
|
|
varSrc.vt = VT_EMPTY;
|
|
}
|
|
|
|
VARIANT COleSafeArray::Detach()
|
|
{
|
|
VARIANT varResult = *this;
|
|
vt = VT_EMPTY;
|
|
return varResult;
|
|
}
|
|
|
|
// Assignment operators
|
|
COleSafeArray& COleSafeArray::operator=(const COleSafeArray& saSrc)
|
|
{
|
|
ASSERT(saSrc.vt & VT_ARRAY);
|
|
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&saSrc));
|
|
return *this;
|
|
}
|
|
|
|
COleSafeArray& COleSafeArray::operator=(const VARIANT& varSrc)
|
|
{
|
|
ASSERT(varSrc.vt & VT_ARRAY);
|
|
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
return *this;
|
|
}
|
|
|
|
COleSafeArray& COleSafeArray::operator=(LPCVARIANT pSrc)
|
|
{
|
|
ASSERT(pSrc->vt & VT_ARRAY);
|
|
|
|
CheckError(::VariantCopy(this, (LPVARIANT)pSrc));
|
|
return *this;
|
|
}
|
|
|
|
COleSafeArray& COleSafeArray::operator=(const COleVariant& varSrc)
|
|
{
|
|
ASSERT(varSrc.vt & VT_ARRAY);
|
|
|
|
CheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
|
|
return *this;
|
|
}
|
|
|
|
// Comparison operators
|
|
BOOL COleSafeArray::operator==(const SAFEARRAY& saSrc) const
|
|
{
|
|
return CompareSafeArrays(parray, (LPSAFEARRAY)&saSrc);
|
|
}
|
|
|
|
BOOL COleSafeArray::operator==(LPCSAFEARRAY pSrc) const
|
|
{
|
|
return CompareSafeArrays(parray, (LPSAFEARRAY)pSrc);
|
|
}
|
|
|
|
BOOL COleSafeArray::operator==(const COleSafeArray& saSrc) const
|
|
{
|
|
if (vt != saSrc.vt)
|
|
return FALSE;
|
|
|
|
return CompareSafeArrays(parray, saSrc.parray);
|
|
}
|
|
|
|
BOOL COleSafeArray::operator==(const VARIANT& varSrc) const
|
|
{
|
|
if (vt != varSrc.vt)
|
|
return FALSE;
|
|
|
|
return CompareSafeArrays(parray, varSrc.parray);
|
|
}
|
|
|
|
BOOL COleSafeArray::operator==(LPCVARIANT pSrc) const
|
|
{
|
|
if (vt != pSrc->vt)
|
|
return FALSE;
|
|
|
|
return CompareSafeArrays(parray, pSrc->parray);
|
|
}
|
|
|
|
BOOL COleSafeArray::operator==(const COleVariant& varSrc) const
|
|
{
|
|
if (vt != varSrc.vt)
|
|
return FALSE;
|
|
|
|
return CompareSafeArrays(parray, varSrc.parray);
|
|
}
|
|
|
|
void COleSafeArray::CreateOneDim(VARTYPE vtSrc, DWORD dwElements,
|
|
void* pvSrcData, long nLBound)
|
|
{
|
|
ASSERT(dwElements > 0);
|
|
|
|
// Setup the bounds and create the array
|
|
SAFEARRAYBOUND rgsabound;
|
|
rgsabound.cElements = dwElements;
|
|
rgsabound.lLbound = nLBound;
|
|
Create(vtSrc, 1, &rgsabound);
|
|
|
|
// Copy over the data if neccessary
|
|
if (pvSrcData != NULL)
|
|
{
|
|
void* pvDestData;
|
|
AccessData(&pvDestData);
|
|
memcpy(pvDestData, pvSrcData, GetElemSize() * dwElements);
|
|
UnaccessData();
|
|
}
|
|
}
|
|
|
|
DWORD COleSafeArray::GetOneDimSize()
|
|
{
|
|
ASSERT(GetDim() == 1);
|
|
|
|
long nUBound, nLBound;
|
|
|
|
GetUBound(1, &nUBound);
|
|
GetLBound(1, &nLBound);
|
|
|
|
return nUBound + 1 - nLBound;
|
|
}
|
|
|
|
void COleSafeArray::ResizeOneDim(DWORD dwElements)
|
|
{
|
|
ASSERT(GetDim() == 1);
|
|
|
|
SAFEARRAYBOUND rgsabound;
|
|
|
|
rgsabound.cElements = dwElements;
|
|
rgsabound.lLbound = 0;
|
|
|
|
Redim(&rgsabound);
|
|
}
|
|
|
|
void COleSafeArray::Create(VARTYPE vtSrc, DWORD dwDims, DWORD* rgElements)
|
|
{
|
|
ASSERT(rgElements != NULL);
|
|
|
|
// Allocate and fill proxy array of bounds (with lower bound of zero)
|
|
SAFEARRAYBOUND* rgsaBounds = new SAFEARRAYBOUND[dwDims];
|
|
|
|
for (DWORD dwIndex = 0; dwIndex < dwDims; dwIndex++)
|
|
{
|
|
// Assume lower bound is 0 and fill in element count
|
|
rgsaBounds[dwIndex].lLbound = 0;
|
|
rgsaBounds[dwIndex].cElements = rgElements[dwIndex];
|
|
}
|
|
|
|
TRY
|
|
{
|
|
Create(vtSrc, dwDims, rgsaBounds);
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
// Must free up memory
|
|
delete [] rgsaBounds;
|
|
THROW_LAST();
|
|
}
|
|
END_CATCH_ALL
|
|
|
|
delete [] rgsaBounds;
|
|
}
|
|
|
|
void COleSafeArray::Create(VARTYPE vtSrc, DWORD dwDims, SAFEARRAYBOUND* rgsabound)
|
|
{
|
|
ASSERT(dwDims > 0);
|
|
ASSERT(rgsabound != NULL);
|
|
|
|
// Validate the VARTYPE for SafeArrayCreate call
|
|
ASSERT(!(vtSrc & VT_ARRAY));
|
|
ASSERT(!(vtSrc & VT_BYREF));
|
|
ASSERT(!(vtSrc & VT_VECTOR));
|
|
ASSERT(vtSrc != VT_EMPTY);
|
|
ASSERT(vtSrc != VT_NULL);
|
|
|
|
// Free up old safe array if necessary
|
|
Clear();
|
|
|
|
parray = ::SafeArrayCreate(vtSrc, dwDims, rgsabound);
|
|
|
|
if (parray == NULL)
|
|
AfxThrowMemoryException();
|
|
|
|
vt = unsigned short(vtSrc | VT_ARRAY);
|
|
m_dwDims = dwDims;
|
|
m_dwElementSize = GetElemSize();
|
|
}
|
|
|
|
void COleSafeArray::AccessData(void** ppvData)
|
|
{
|
|
CheckError(::SafeArrayAccessData(parray, ppvData));
|
|
}
|
|
|
|
void COleSafeArray::UnaccessData()
|
|
{
|
|
CheckError(::SafeArrayUnaccessData(parray));
|
|
}
|
|
|
|
void COleSafeArray::AllocData()
|
|
{
|
|
CheckError(::SafeArrayAllocData(parray));
|
|
}
|
|
|
|
void COleSafeArray::AllocDescriptor(DWORD dwDims)
|
|
{
|
|
CheckError(::SafeArrayAllocDescriptor(dwDims, &parray));
|
|
}
|
|
|
|
void COleSafeArray::Copy(LPSAFEARRAY* ppsa)
|
|
{
|
|
CheckError(::SafeArrayCopy(parray, ppsa));
|
|
}
|
|
|
|
void COleSafeArray::GetLBound(DWORD dwDim, long* pLbound)
|
|
{
|
|
CheckError(::SafeArrayGetLBound(parray, dwDim, pLbound));
|
|
}
|
|
|
|
void COleSafeArray::GetUBound(DWORD dwDim, long* pUbound)
|
|
{
|
|
CheckError(::SafeArrayGetUBound(parray, dwDim, pUbound));
|
|
}
|
|
|
|
void COleSafeArray::GetElement(long* rgIndices, void* pvData)
|
|
{
|
|
CheckError(::SafeArrayGetElement(parray, rgIndices, pvData));
|
|
}
|
|
|
|
void COleSafeArray::PtrOfIndex(long* rgIndices, void** ppvData)
|
|
{
|
|
CheckError(::SafeArrayPtrOfIndex(parray, rgIndices, ppvData));
|
|
}
|
|
|
|
void COleSafeArray::PutElement(long* rgIndices, void* pvData)
|
|
{
|
|
CheckError(::SafeArrayPutElement(parray, rgIndices, pvData));
|
|
}
|
|
|
|
void COleSafeArray::Redim(SAFEARRAYBOUND* psaboundNew)
|
|
{
|
|
CheckError(::SafeArrayRedim(parray, psaboundNew));
|
|
}
|
|
|
|
void COleSafeArray::Lock()
|
|
{
|
|
CheckError(::SafeArrayLock(parray));
|
|
}
|
|
|
|
void COleSafeArray::Unlock()
|
|
{
|
|
CheckError(::SafeArrayUnlock(parray));
|
|
}
|
|
|
|
void COleSafeArray::Destroy()
|
|
{
|
|
CheckError(::SafeArrayDestroy(parray));
|
|
}
|
|
|
|
void COleSafeArray::DestroyData()
|
|
{
|
|
CheckError(::SafeArrayDestroyData(parray));
|
|
}
|
|
|
|
void COleSafeArray::DestroyDescriptor()
|
|
{
|
|
CheckError(::SafeArrayDestroyDescriptor(parray));
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// COleSafeArray Helpers
|
|
void AFXAPI AfxSafeArrayInit(COleSafeArray* psa)
|
|
{
|
|
memset(psa, 0, sizeof(*psa));
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Simple field formatting to text item - see dlgdata.cpp for base types
|
|
void AFXAPI DDX_Text(CDataExchange* pDX, int nIDC, COleDateTime& value)
|
|
{
|
|
HWND hWndCtrl = pDX->PrepareEditCtrl(nIDC);
|
|
if (pDX->m_bSaveAndValidate)
|
|
{
|
|
int nLen = ::GetWindowTextLength(hWndCtrl);
|
|
CString strTemp;
|
|
|
|
::GetWindowText(hWndCtrl, strTemp.GetBufferSetLength(nLen), nLen+1);
|
|
strTemp.ReleaseBuffer();
|
|
|
|
if (!value.ParseDateTime(strTemp)) // throws exception
|
|
{
|
|
// Can't convert string to datetime
|
|
AfxMessageBox(AFX_IDP_PARSE_DATETIME);
|
|
pDX->Fail(); // throws exception
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CString strTemp = value.Format();
|
|
AfxSetWindowText(hWndCtrl, strTemp);
|
|
}
|
|
}
|
|
|
|
void AFXAPI DDX_Text(CDataExchange* pDX, int nIDC, COleCurrency& value)
|
|
{
|
|
HWND hWndCtrl = pDX->PrepareEditCtrl(nIDC);
|
|
if (pDX->m_bSaveAndValidate)
|
|
{
|
|
int nLen = ::GetWindowTextLength(hWndCtrl);
|
|
CString strTemp;
|
|
|
|
::GetWindowText(hWndCtrl, strTemp.GetBufferSetLength(nLen), nLen+1);
|
|
strTemp.ReleaseBuffer();
|
|
|
|
if (!value.ParseCurrency(strTemp)) // throws exception
|
|
{
|
|
// Can't convert string to currency
|
|
AfxMessageBox(AFX_IDP_PARSE_CURRENCY);
|
|
pDX->Fail(); // throws exception
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CString strTemp = value.Format();
|
|
AfxSetWindowText(hWndCtrl, strTemp);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#endif //_CURRENCY_ALSO_
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COleVariant::Save
|
|
//
|
|
// Synopsis: saves a variant to a stream
|
|
//
|
|
// Arguments: [pStm] --
|
|
// [fClearDirty] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 1-15-1997 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes: BUGBUG:NOT COMPLETE!
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT COleVariant::Save(IStream *pStm, BOOL fClearDirty)
|
|
{
|
|
LPVARIANT pSrc = (LPVARIANT)this;
|
|
HRESULT hr = NOERROR;
|
|
ULONG cbSaved;
|
|
COleVariant CVar;
|
|
|
|
if (pSrc->vt & VT_BYREF || pSrc->vt & VT_ARRAY)
|
|
{
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
pSrc = (LPVARIANT)&CVar;
|
|
}
|
|
|
|
// write the variant
|
|
hr = pStm->Write(pSrc, sizeof(VARIANT), &cbSaved);
|
|
TransAssert(( sizeof(VARIANT) == cbSaved));
|
|
if (hr == NOERROR)
|
|
{
|
|
switch (pSrc->vt)
|
|
{
|
|
case VT_DISPATCH:
|
|
TransAssert((FALSE));
|
|
hr = E_FAIL;
|
|
break;
|
|
|
|
case VT_UNKNOWN:
|
|
{
|
|
ULONG cbInterface = 0;
|
|
IUnknown *pUnk = pSrc->punkVal;
|
|
|
|
hr = CoGetMarshalSizeMax(&cbInterface, IID_IUnknown, pUnk, MSHCTX_LOCAL, 0, MSHLFLAGS_NORMAL);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
// write the size of
|
|
hr = pStm->Write(&cbInterface, sizeof(ULONG), &cbSaved);
|
|
// need to marshal table strong
|
|
hr = CoMarshalInterface(pStm, IID_IUnknown, pUnk, MSHCTX_LOCAL, 0, MSHLFLAGS_NORMAL);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
default:
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
// do nothing
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
{
|
|
DWORD nLen = SysStringByteLen(pSrc->bstrVal);
|
|
hr = pStm->Write(&nLen, sizeof(DWORD), &cbSaved);
|
|
if ( (hr == NOERROR)
|
|
&& (nLen > 0))
|
|
{
|
|
hr = pStm->Write(pSrc->bstrVal, nLen * sizeof(BYTE), &cbSaved);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
#ifdef _unused_
|
|
case VT_BOOL:
|
|
hr = pStm->Write((WORD)V_BOOL(pSrc), sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_UI1:
|
|
hr = pStm->Write(pSrc->bVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_I2:
|
|
hr = pStm->Write((WORD)pSrc->iVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_I4:
|
|
hr = pStm->Write(pSrc->lVal, sizeof(DWORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_CY:
|
|
hr = pStm->Write(pSrc->cyVal.Lo, sizeof(WORD), &cbSaved);
|
|
hr = pStm->Write(pSrc->cyVal.Hi, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_R4:
|
|
hr = pStm->Write(pSrc->fltVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_R8:
|
|
hr = pStm->Write(pSrc->dblVal, sizeof(DOUBLE), &cbSaved);
|
|
break;
|
|
|
|
case VT_DATE:
|
|
hr = pStm->Write(pSrc->date;
|
|
break;
|
|
|
|
case VT_ERROR:
|
|
hr = pStm->Write(pSrc->scode;
|
|
break;
|
|
#endif //_unused_
|
|
}
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COleVariant::Load
|
|
//
|
|
// Synopsis: loads a variant from a stream
|
|
//
|
|
// Arguments: [pStm] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 1-15-1997 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes: BUGBUG:NOT COMPLETE!
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT COleVariant::Load(IStream *pStm)
|
|
{
|
|
LPVARIANT pSrc = (LPVARIANT)this;
|
|
HRESULT hr = NOERROR;
|
|
ULONG cbSaved;
|
|
COleVariant CVar;
|
|
|
|
// Read the variant
|
|
hr = pStm->Read(pSrc, sizeof(VARIANT), &cbSaved);
|
|
TransAssert(( sizeof(VARIANT) == cbSaved));
|
|
|
|
if (pSrc->vt & VT_BYREF || pSrc->vt & VT_ARRAY)
|
|
{
|
|
// No support for VT_BYREF & VT_ARRAY
|
|
pSrc = (LPVARIANT)&CVar;
|
|
}
|
|
|
|
if (hr == NOERROR)
|
|
{
|
|
switch (pSrc->vt)
|
|
{
|
|
case VT_DISPATCH:
|
|
TransAssert((FALSE));
|
|
hr = E_FAIL;
|
|
break;
|
|
|
|
|
|
case VT_UNKNOWN:
|
|
{
|
|
ULONG cbInterface = 0;
|
|
IUnknown *pUnk = 0;
|
|
|
|
// write the size of
|
|
hr = pStm->Read(&cbInterface, sizeof(ULONG), &cbSaved);
|
|
|
|
if ( (hr == S_OK)
|
|
&& cbInterface)
|
|
{
|
|
|
|
hr = CoUnmarshalInterface(pStm, IID_IUnknown, (void **) &pUnk);
|
|
if(hr == S_OK)
|
|
{
|
|
pSrc->punkVal = pUnk;
|
|
}
|
|
else
|
|
{
|
|
pSrc->punkVal = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSrc->punkVal = 0;
|
|
}
|
|
hr = NOERROR;
|
|
}
|
|
break;
|
|
|
|
|
|
default:
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
// do nothing
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
{
|
|
DWORD nLen = 0;
|
|
hr = pStm->Read(&nLen, sizeof(DWORD), &cbSaved);
|
|
|
|
if (nLen > 0)
|
|
{
|
|
pSrc->bstrVal = SysAllocStringByteLen(NULL, nLen);
|
|
|
|
if (pSrc->bstrVal)
|
|
{
|
|
hr = pStm->Read(pSrc->bstrVal, nLen * sizeof(BYTE), &cbSaved);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
#ifdef _unused_
|
|
case VT_BOOL:
|
|
hr = pStm->Read((WORD)V_BOOL(pSrc), sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_UI1:
|
|
hr = pStm->Read(pSrc->bVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_I2:
|
|
hr = pStm->Read((WORD)pSrc->iVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_I4:
|
|
hr = pStm->Read(pSrc->lVal, sizeof(DWORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_CY:
|
|
hr = pStm->Read(pSrc->cyVal.Lo, sizeof(WORD), &cbSaved);
|
|
hr = pStm->Read(pSrc->cyVal.Hi, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_R4:
|
|
hr = pStm->Read(pSrc->fltVal, sizeof(WORD), &cbSaved);
|
|
break;
|
|
|
|
case VT_R8:
|
|
hr = pStm->Read(pSrc->dblVal, sizeof(DOUBLE), &cbSaved);
|
|
break;
|
|
|
|
case VT_DATE:
|
|
hr = pStm->Read(pSrc->date;
|
|
break;
|
|
|
|
case VT_ERROR:
|
|
hr = pStm->Read(pSrc->scode;
|
|
break;
|
|
#endif //_unused_
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|