helpers.cpp

vc++与visio 安装VISIO office（推荐2003以上版本）必须安装visio office 否则程序无法运行 安装VisioSDK（推荐2003以上版本） 默认安装路径为<

//	~VSafeArray - Destructor
//
//	<summary>
//	Destructor for the VSafeArray class.
//	</summary>
//
//	Return Value:
//	None
//
VSafeArray::~VSafeArray()
{
	Destroy();
}

//	Create - Create a SafeArray.
//
//	<summary>
//	Create a SafeArray and initialize the VSafeArray member variables to refer
//	to the new SafeArray.
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray::Create(VARTYPE vt,
						   unsigned int nDims,
						   SAFEARRAYBOUND FAR* pBounds)
{
	HRESULT hr= NOERROR;

	Destroy();	//	Forget about anything we currently point to...

	m_nDims= nDims;
	m_vt= vt;
	m_pSA= SafeArrayCreate(vt, nDims, pBounds);

	if (NULL==m_pSA)
		hr= E_OUTOFMEMORY;

	return hr;
}

//	Destroy - Free the SafeArray member data
//
//	<summary>
//	Free and SafeArray data stored in the VSafeArray object.
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray::Destroy(void)
{
	HRESULT hr= NOERROR;

	if (NULL!=m_pSA)
	{
		hr= SafeArrayDestroy(m_pSA);
		m_pSA= NULL;
	}

	return hr;
}

//	GetDimensions - Get the VSafeArray dimensions.
//
//	<summary>
//	Get the array dimensions for the SafeArray member data.
//	</summary>
//
//	Return Value:
//	unsigned int - number of dimensions in the SafeArray.
//
unsigned int VSafeArray::GetDimensions(void)
{
	if (DIM_UNINITIALIZED==m_nDims && NULL!=m_pSA)
	{
		m_nDims= SafeArrayGetDim(m_pSA);
	}

	return m_nDims;
}

//	GetNumberElements - Get the number of elements in a particular dimension
//
//	<summary>
//	Get the number of elements in a particular dimension of the SafeArray.
//	</summary>
//
//	Return Value:
//	long - the number of elements in the dimension
//
long VSafeArray::GetNumberElements(unsigned int nDim /*= 1*/)
{
	return GetUpper(nDim)-GetLower(nDim)+1;
}

//	GetLower - Get the lower bound for a dimension.
//
//	<summary>
//	Get the lower bound for a dimension of the SafeArray
//	</summary>
//
//	Return Value:
//	long - the lower bound of the dimension
//
long VSafeArray::GetLower(unsigned int nDim /*= 1*/)
{
	long nRet= 0;

	if (DIM_UNINITIALIZED!=nDim && NULL!=m_pSA)
	{
		long nLower= 0;
		if (SUCCEEDED(SafeArrayGetLBound(m_pSA, nDim, &nLower)))
		{
			nRet= nLower;
		}
	}

	return nRet;
}

//	GetUpper - Get the upper bound for a dimension.
//
//	<summary>
//	Get the upper bound for a dimension of the SafeArray
//	</summary>
//
//	Return Value:
//	long - the upper bound of the dimension
//
long VSafeArray::GetUpper(unsigned int nDim /*= 1*/)
{
	long nRet= 0;

	if (DIM_UNINITIALIZED!=nDim && NULL!=m_pSA)
	{
		long nUpper= 0;
		if (SUCCEEDED(SafeArrayGetUBound(m_pSA, nDim, &nUpper)))
		{
			nRet= nUpper;
		}
	}

	return nRet;
}

//	PutElement - Put a value in the SafeArray
//
//	<summary>
//	Put a value in the SafeArray based on a set of indices into the array
//	dimensions.
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray::PutElement(long* pnIndices, void const* pData)
{
	HRESULT hr= E_FAIL;

	if (NULL!=m_pSA)
	{
		hr= SafeArrayPutElement(m_pSA, pnIndices, (void *) pData);
	}

	return hr;
}

//	GetElement - Get a value from the SafeArray
//
//	<summary>
//	Get values from the SafeArray based on a set of indices into the array
//	dimensions.
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray::GetElement(long* pnIndices, void* pData)
{
	HRESULT hr= E_FAIL;

	if (NULL!=m_pSA)
	{
		hr= SafeArrayGetElement(m_pSA, pnIndices, pData);
	}

	return hr;
}

//	operator SAFEARRAY FAR* const - Get const access to the SafeArray member 
//	variable
//
//	<summary>
//	Get const access to the SafeArray member variable.
//	</summary>
//
//	Return Value:
//	SAFEARRAY FAR*const - a constant pointer to the SafeArray member variable.
//
VSafeArray::operator SAFEARRAY FAR* const (void) const
{
	return m_pSA;
}

//	operator SAFEARRAY FAR* FAR* const - Get access to the address of the
//	SafeArray member variable.
//
//	<summary>
//	Get access to the address of the SafeArray member variable.
//	</summary>
//
//	Return Value:
//	SAFEARRAY FAR* FAR* - a pointer to the SafeArrayMember variable
//
VSafeArray::operator SAFEARRAY FAR* FAR* (void) const
{
	return (SAFEARRAY FAR* FAR*) &m_pSA;
}

//	LPLPSAFEARRAY - Get access to the address of the SafeArray member variable.
//
//	<summary>
//	Get access to the address of the SafeArray member variable.
//	</summary>
//
//	Return Value:
//	SAFEARRAY FAR* FAR* - a pointer to the SafeArrayMember variable
//
SAFEARRAY FAR* FAR* VSafeArray::LPLPSAFEARRAY(void)
{
	//	Call this function when you are passing the SAFEARRAY ** to a method
	//	which is going to fill in the SAFEARRAY for you. ('out' args)
	Destroy();
	return &m_pSA;
}

//	PutShort - Set a short value in a 1-d VSafeArray
//
//	<summary>
//	Set a short value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutShort(long nIndex, short n)
{
	//	ASSERT(VT_I2==m_vt);
	return PutElement(&nIndex, &n);
}

//	PutLong - Set a long value in a 1-d VSafeArray
//
//	<summary>
//	Set a long value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutLong(long nIndex, long n)
{
	//	ASSERT(VT_I4==m_vt);
	return PutElement(&nIndex, &n);
}

//	PutDouble - Set a double value in a 1-d VSafeArray
//
//	<summary>
//	Set a double value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutDouble(long nIndex, double d)
{
	//	ASSERT(VT_R8==m_vt);
	return PutElement(&nIndex, &d);
}

//	PutBstr - Set a BSTR value in a 1-d VSafeArray
//
//	<summary>
//	Set a BSTR value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutBstr(long nIndex, BSTR bstr)
{
	//	ASSERT(VT_BSTR==m_vt);
	return PutElement(&nIndex, bstr);
}

//	PutVariant - Set a VARIANT value in a 1-d VSafeArray
//
//	<summary>
//	Set a VARIANT value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutVariant(long nIndex, const VARIANT &v)
{
	//	ASSERT(VT_VARIANT==m_vt);
	return PutElement(&nIndex, &v);
}

//	PutObject - Set an LPUNKNOWN value in a 1-d VSafeArray
//
//	<summary>
//	Set a LPUNKNOWN value in a 1-d VSafeArray
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
HRESULT VSafeArray1D::PutObject(long nIndex, LPUNKNOWN pUnk)
{
	//	ASSERT(VT_UNKNOWN==m_vt || VT_DISPATCH==m_vt);
	return PutElement(&nIndex, pUnk);
}

//	GetShort - Get a short value from a 1-d VSafeArray
//
//	<summary>
//	Get a short value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	short - the value in the array at nIndex position
//
short VSafeArray1D::GetShort(long nIndex)
{
	short n= 0;
	//	ASSERT(VT_I2==m_vt);
	if (FAILED(GetElement(&nIndex, &n)))
	{
		n= -1;
	}
	return n;
}

//	GetLong - Get a long value from a 1-d VSafeArray
//
//	<summary>
//	Get a long value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	long - the value in the array at nIndex position
//
long VSafeArray1D::GetLong(long nIndex)
{
	long n= 0L;
	//	ASSERT(VT_I4==m_vt);
	if (FAILED(GetElement(&nIndex, &n)))
	{
		n= -1L;
	}
	return n;
}

//	GetDouble - Get a double value from a 1-d VSafeArray
//
//	<summary>
//	Get a double value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	double - the value in the array at nIndex position
//
double VSafeArray1D::GetDouble(long nIndex)
{
	double d= 0.0;
	//	ASSERT(VT_R8==m_vt);
	if (FAILED(GetElement(&nIndex, &d)))
	{
		d= -1.0;
	}
	return d;
}

//	GetBstr - Get a BSTR value from a 1-d VSafeArray
//
//	<summary>
//	Get a BSTR value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	BSTR - the value in the array at nIndex position
//
BSTR VSafeArray1D::GetBstr(long nIndex)
{
	BSTR bstr= NULL;
	//	ASSERT(VT_BSTR==m_vt);
	if (FAILED(GetElement(&nIndex, &bstr)))
	{
		bstr= NULL;
	}
	//	non-NULL return MUST be SysFreeStringed
	return bstr;
}

//	GetVariant - Get a VARIANT value from a 1-d VSafeArray
//
//	<summary>
//	Get a VARIANT value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	VARIANT - the value in the array at nIndex position
//
VARIANT VSafeArray1D::GetVariant(long nIndex)
{
	VARIANT v;
	//	ASSERT(VT_VARIANT==m_vt);
	VariantInit(&v);
	if (FAILED(GetElement(&nIndex, &v)))
	{
		V_VT(&v)= VT_EMPTY;
		V_NONE(&v)= 0;
	}
	//	return MUST be VariantCleared
	return v;
}

//	GetObject - Get a LPUNKNOWN value from a 1-d VSafeArray
//
//	<summary>
//	Get a LPUNKNOWN value from a 1-d VSafeArray.
//	</summary>
//
//	Return Value:
//	LPUNKNOWN - the value in the array at nIndex position
//
LPUNKNOWN VSafeArray1D::GetObject(long nIndex)
{
	LPUNKNOWN pUnk= NULL;
	//	ASSERT(VT_UNKNOWN==m_vt || VT_DISPATCH==m_vt);
	if (FAILED(GetElement(&nIndex, &pUnk)) || NULL == pUnk)
	{
		pUnk= NULL;
	}
	else
	{
		pUnk->AddRef();
		//	non-NULL return MUST be Released...
	}
	return pUnk;
}

//	ConvertToSTR - Convert a VString to an LPTSTR
//
//	<summary>
//	Converts the string stored in a VString (CString subclass) to an LPTSTR.
//	</summary>
//
//	Return Value:
//	HRESULT - NOERROR or some HRESULT error code
//
#ifdef MFC_HELPERS

HRESULT VString::ConvertToLPTSTR(LPTSTR pStr, ULONG* pnBytes)
{
	//	*pnBytes should be size of pStr buffer on entry
	//	*pnBytes is size needed if E_FAIL is returned
	//	*pnBytes is size copied if NOERROR is returned

	if (NULL==pStr || NULL==pnBytes)
		return E_POINTER;

	if (pnBytes == NULL)
	{
		return E_INVALIDARG;
	}

	LPCTSTR pData = (LPCTSTR)*this;
	ULONG nStrLen = _tcslen(pData);	
	ULONG nBufferSize = (nStrLen + 1) * sizeof(TCHAR);	
	ULONG ul = 0;

	if((*pnBytes) < nBufferSize )
	{
	
		*pnBytes = nBufferSize;
		*pStr = 0;
		return E_FAIL;
	}
	else
	{
		if (pStr == NULL)
		{
			return E_INVALIDARG;
		}

		_tcsncpy(pStr, pData, nStrLen);

		pStr[nStrLen] = 0;
		*pnBytes = nBufferSize;

	}
	return NOERROR;
}
#endif //	MFC_HELPERS