mirror of https://github.com/lianthony/NT4.0
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.
502 lines
18 KiB
502 lines
18 KiB
// norvarnt.cpp : implementation of the CVariantHandler class
|
|
//
|
|
// This class was written in order to standardize what VT_ value types
|
|
// (e.g., VT_I4, VT_BSTR, VT_R4) are valid for each possible 'C' data
|
|
// type (e.g., long, short, string).
|
|
|
|
#include "stdafx.h" // Gotta have it (precompile headers...)
|
|
#include <oleauto.h> // Needed for VARIANT stuff...
|
|
#include "norvarnt.h" // For this class...
|
|
#include "common.h" // Publics for the Controls (for errors)
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CVariantHandler construction/destruction
|
|
|
|
_declspec (dllexport) CVariantHandler::CVariantHandler()
|
|
{
|
|
// MUST use non-default constructor (or default constructor
|
|
// in conjunction with Setvariant(...) ), therefore
|
|
// Initialized is set to FALSE...
|
|
m_Initialized = FALSE;
|
|
}
|
|
|
|
_declspec (dllexport) CVariantHandler::~CVariantHandler()
|
|
{
|
|
}
|
|
|
|
_declspec (dllexport) CVariantHandler::CVariantHandler(const VARIANT FAR& Variant)
|
|
{
|
|
// Initialized is set to TRUE as the correct
|
|
// (i.e., non-default) constructor was used!!!
|
|
m_Initialized = TRUE;
|
|
|
|
// Copy the variant value in...
|
|
m_Variant = Variant;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SetVariant(const VARIANT FAR& Variant)
|
|
//
|
|
// Sets the Variant.
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// VARIANT FAR& - reference to Variant data member to be accessed.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// none
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) void CVariantHandler::SetVariant(const VARIANT FAR& Variant)
|
|
{
|
|
// Initialized is set to TRUE as this function was called...
|
|
m_Initialized = TRUE;
|
|
|
|
// Copy the variant value in...
|
|
m_Variant = Variant;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetLong( long &Value,
|
|
// const long &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the long value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_I4
|
|
// VT_I2
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// long &Value - reference to long value to be returned
|
|
//
|
|
// long &Default - reference to the Default value to be returned if
|
|
// the EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetLong( long &Value,
|
|
const long &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_I4 ) //
|
|
Value = m_Variant.lVal; // Longs accept I4
|
|
else if ( Type == VT_I2 ) //
|
|
Value = m_Variant.iVal; // and I2
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetShort( short &Value,
|
|
// const short &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the short value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_I2
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// short &Value - reference to short value to be returned
|
|
//
|
|
// short &Default - reference to the Default value to be returned if
|
|
// the EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetShort( short &Value,
|
|
const short &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_I2 ) //
|
|
Value = m_Variant.iVal; // Shorts accept I2
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetCString( CString &Value,
|
|
// const CString &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the CString value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_BSTR
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// CString &Value - reference to CString value to be returned
|
|
//
|
|
// CString &Default - The Default value to be returned if the
|
|
// EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetCString( CString &Value,
|
|
const CString &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_BSTR ) //
|
|
Value = m_Variant.bstrVal; // CString accept BSTR
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetBool( BOOL &Value,
|
|
// const BOOL &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the boolean value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_BOOL
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// BOOL &Value - reference to boolean value to be returned
|
|
//
|
|
// BOOL &Default - reference to the Default value to be returned if
|
|
// the EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetBool( BOOL &Value,
|
|
const BOOL &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_BOOL ) //
|
|
Value = m_Variant.bVal; // Shorts accept booleans
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetFloat( float &Value,
|
|
// const float &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the float (4 byte real) value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_R4
|
|
// VT_I2
|
|
// VT_I4
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// float &Value - reference to boolean value to be returned
|
|
//
|
|
// float &Default - reference to the Default value to be returned if
|
|
// the EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetFloat( float &Value,
|
|
const float &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_R4 ) //
|
|
Value = m_Variant.fltVal; // Floats accept R4
|
|
else if ( Type == VT_I2 ) //
|
|
Value = (float)m_Variant.iVal; // I2
|
|
else if ( Type == VT_I4 ) //
|
|
Value = (float)m_Variant.lVal; // I4
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// long CVariantHandler::GetDouble( double &Value,
|
|
// const double &Default,
|
|
// const BOOL EmptyIsError)
|
|
//
|
|
// Gets the double (8 byte real) value of a Variant data item.
|
|
//
|
|
// Currently allows values of type:
|
|
// VT_R8
|
|
// VT_R4
|
|
// VT_I2
|
|
// VT_I4
|
|
//
|
|
// INPUT PARAMETERS:
|
|
//
|
|
// double &Value - reference to boolean value to be returned
|
|
//
|
|
// double &Default - reference to the Default value to be returned if
|
|
// the EmptyIsError parameter is set to FALSE and the
|
|
// Variant is VT_EMPTY.
|
|
//
|
|
// BOOL EmptyIsError - TRUE will cause a VT_EMPTY Variant to return a
|
|
// WI_INVALIDVARIANTTYPE error.
|
|
//
|
|
// Note that this is the default such that a call
|
|
// of type GetLong(X) can simply be coded to allow
|
|
// no default case.
|
|
//
|
|
// FALSE will cause a VT_Empty Variant to return
|
|
// the specified Default.
|
|
//
|
|
// Note that as EmptyIsDefault is the last parameter
|
|
// in order to specify a value of FALSE a value for
|
|
// the Default parameter MUST be specified.
|
|
//
|
|
// OUTPUT:
|
|
//
|
|
// 0 - success.
|
|
// WI_INVALIDVARIANTTYPE - Invalid Variant Type.
|
|
// WI_INVALIDEMPTYVARIANT - Invalid EMPTY variant
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
_declspec (dllexport) long CVariantHandler::GetDouble( double &Value,
|
|
const double &Default,
|
|
const BOOL EmptyIsError /* = TRUE */)
|
|
{
|
|
// MUST use the non-default constructor...
|
|
ASSERT(m_Initialized == TRUE);
|
|
|
|
// Assume success...
|
|
long RetVal = 0;
|
|
|
|
// Get the Variant's type (once for efficiency!)
|
|
VARTYPE Type = m_Variant.vt;
|
|
|
|
// Get the value from the Variant...
|
|
if ( Type == VT_ERROR )
|
|
{
|
|
// See if Empty is to be treated as an error or as 'use default'...
|
|
if ( EmptyIsError )
|
|
RetVal = WI_INVALIDEMPTYVARIANT;
|
|
else
|
|
Value = Default;
|
|
}
|
|
else if ( Type == VT_R8 ) //
|
|
Value = m_Variant.dblVal; // Doubles accept R8
|
|
else if ( Type == VT_R4 ) //
|
|
Value = (double)m_Variant.fltVal; // R4
|
|
else if ( Type == VT_I2 ) //
|
|
Value = (double)m_Variant.iVal; // I2
|
|
else if ( Type == VT_I4 ) //
|
|
Value = (double)m_Variant.lVal; // I4
|
|
else //
|
|
RetVal = WI_INVALIDVARIANTTYPE; // Anything else is an error...
|
|
|
|
return RetVal;
|
|
}
|