summaryrefslogtreecommitdiffstats
path: root/extensions/test/ole/AxTestComponents/Basic.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'extensions/test/ole/AxTestComponents/Basic.cpp')
-rw-r--r--extensions/test/ole/AxTestComponents/Basic.cpp1356
1 files changed, 1356 insertions, 0 deletions
diff --git a/extensions/test/ole/AxTestComponents/Basic.cpp b/extensions/test/ole/AxTestComponents/Basic.cpp
new file mode 100644
index 000000000..8aad56e8a
--- /dev/null
+++ b/extensions/test/ole/AxTestComponents/Basic.cpp
@@ -0,0 +1,1356 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "stdafx.h"
+#include "Basic.h"
+
+
+
+// CBasic
+CBasic::CBasic(): m_cPrpByte(0),m_nPrpShort(0),m_lPrpLong(0),m_fPrpFloat(0), m_dPrpDouble(0),m_PrpArray(0),
+m_safearray(NULL), m_bool(VARIANT_FALSE),
+m_arByte(0), m_arShort(0), m_arLong(0), m_arString(0), m_arVariant(0), m_arFloat(0),
+m_arDouble(0), m_arObject(0), m_arByteDim2(0), m_date(0.), m_scode(0)
+
+{
+ memset(&m_cy, 0, sizeof(CY));
+ memset(&m_decimal, 0, sizeof(DECIMAL));
+}
+
+CBasic::~CBasic()
+{
+ SafeArrayDestroy(m_safearray);
+ SafeArrayDestroy(m_arByte);
+ SafeArrayDestroy(m_arShort);
+ SafeArrayDestroy(m_arLong);
+ SafeArrayDestroy(m_arString);
+ SafeArrayDestroy(m_arVariant);
+ SafeArrayDestroy(m_arFloat);
+ SafeArrayDestroy(m_arDouble);
+ SafeArrayDestroy(m_arObject);
+ SafeArrayDestroy(m_arByteDim2);
+
+}
+STDMETHODIMP CBasic::inBool(VARIANT_BOOL val)
+{
+ m_bool = val;
+ return S_OK;
+}
+STDMETHODIMP CBasic::inByte(unsigned char val)
+{
+ m_byte = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inShort(short val)
+{
+ m_short = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inLong(long val)
+{
+ m_long = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inString(BSTR val)
+{
+ m_bstr = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inFloat(float val)
+{
+ m_float = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inDouble(double val)
+{
+ m_double = val;
+
+ CComVariant varDest;
+ CComVariant varSource(val);
+ HRESULT hr = VariantChangeType(&varDest, &varSource, 0, VT_BSTR);
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inVariant(VARIANT val)
+{
+ m_var1 = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inArray(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_safearray)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, &m_safearray)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inObject(IDispatch *val)
+{
+ m_obj = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutBool(VARIANT_BOOL* val)
+{
+ VARIANT_BOOL aBool = *val;
+ *val = m_bool;
+ m_bool = aBool;
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::inoutByte(unsigned char* val)
+{
+ unsigned char aByte = *val;
+ *val = m_byte;
+ m_byte = aByte;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutShort(short *val)
+{
+ short aShort = *val;
+ *val = m_short;
+ m_short = aShort;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutLong(long *val)
+{
+ long aLong = *val;
+ *val = m_long;
+ m_long = aLong;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutString(BSTR *val)
+{
+ CComBSTR aStr = *val;
+ HRESULT hr = S_OK;
+ if (FAILED( hr = m_bstr.CopyTo(val)))
+ return hr;
+ m_bstr = aStr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutFloat(float *val)
+{
+ float aFloat = *val;
+ *val = m_float;
+ m_float = aFloat;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutDouble(double *val)
+{
+ double aDouble = *val;
+ *val = m_double;
+ m_double = aDouble;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutVariant(VARIANT *val)
+{
+ CComVariant aVar = *val;
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy(val, &m_var1)))
+ return hr;
+ m_var1 = aVar;
+ return S_OK;
+}
+
+/* The array contains VARIANT according to IDL.
+ If the VARIANTs contain strings then we append "out" to each string.
+*/
+STDMETHODIMP CBasic::inoutArray(LPSAFEARRAY *val)
+{
+ SAFEARRAY* aAr = NULL;
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayCopy(*val, &aAr)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_safearray, val)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(aAr, & m_safearray)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutObject(IDispatch **val)
+{
+ CComPtr<IDispatch> disp = *val;
+ if (*val)
+ (*val)->Release();
+ *val = m_obj;
+ if (*val)
+ (*val)->AddRef();
+ m_obj = disp;
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::outBool(VARIANT_BOOL* val)
+{
+ *val = m_bool;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outByte(unsigned char *val)
+{
+ *val= m_byte;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outShort(short *val)
+{
+ *val= m_short;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outLong(long *val)
+{
+ *val= m_long;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outString(BSTR *val)
+{
+ *val= SysAllocString(m_bstr);
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outFloat(float *val)
+{
+ *val= m_float;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outDouble(double *val)
+{
+ *val= m_double;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outVariant(VARIANT *val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy(val, &m_var1)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outArray(LPSAFEARRAY *val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayCopy(m_safearray, val)))
+ return false;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outObject(IDispatch* *val)
+{
+ *val = m_obj;
+ if (m_obj)
+ (*val)->AddRef();
+
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::get_prpBool(VARIANT_BOOL* pVal)
+{
+ if (!pVal) return E_POINTER;
+ *pVal = m_bool;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpBool(VARIANT_BOOL val)
+{
+ m_bool = val;
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::get_prpByte(unsigned char *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_cPrpByte;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpByte(unsigned char newVal)
+{
+ m_cPrpByte= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpShort(short *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_nPrpShort;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpShort(short newVal)
+{
+ m_nPrpShort= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpLong(long *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_lPrpLong;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpLong(long newVal)
+{
+ m_lPrpLong= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpString(BSTR *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ m_bstrPrpString.CopyTo( pVal );
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpString(BSTR newVal)
+{
+ m_bstrPrpString= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpFloat(float *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_fPrpFloat;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpFloat(float newVal)
+{
+ m_fPrpFloat= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpDouble(double *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_dPrpDouble;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpDouble(double newVal)
+{
+ m_dPrpDouble= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpVariant(VARIANT *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy( pVal, &m_PropVariant)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::put_prpVariant(VARIANT newVal)
+{
+ m_PropVariant= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpArray(LPSAFEARRAY *pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayCopy( m_PrpArray, pVal)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::put_prpArray(LPSAFEARRAY newVal)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy( m_PrpArray)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy( newVal, &m_PrpArray)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::get_prpObject(IDispatch **pVal)
+{
+ if( !pVal)
+ return E_POINTER;
+ *pVal= m_PrpObject;
+ if( *pVal != NULL)
+ (*pVal)->AddRef();
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpObject(IDispatch *newVal)
+{
+ m_PrpObject= newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::mixed1(
+ /* [out][in] */ unsigned char *aChar,
+ /* [out][in] */ float *aFloat,
+ /* [out][in] */ VARIANT *aVar)
+
+{
+ HRESULT hr= S_OK;
+ inoutByte(aChar);
+ inoutFloat(aFloat);
+ inoutVariant(aVar);
+ return hr;
+}
+
+
+
+
+// VT_UI1
+
+STDMETHODIMP CBasic::inSequenceLong(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arLong)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arLong)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceByte( LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arByte)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arByte)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceShort(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arShort)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arShort)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceString(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arString)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arString)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceFloat(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arFloat)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arFloat)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceDouble(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arDouble)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arDouble)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceObject(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arObject)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arObject)))
+ return hr;
+ return hr;
+}
+
+void CBasic::printArray( LPSAFEARRAY val, BSTR message, VARTYPE type)
+{
+
+ HRESULT hr= S_OK;
+ USES_CONVERSION;
+ long lbound=0;
+ long ubound= 0;
+ hr= SafeArrayGetLBound( val, 1, &lbound);
+ hr= SafeArrayGetUBound( val, 1, &ubound);
+ long length= ubound - lbound +1;
+
+ CComVariant varElement;
+ char buf[1024];
+ sprintf( buf,"%s", W2A(message));
+
+ for( long i= 0; i < length ; i++)
+ {
+ char tmp[1024];
+ long data=0;
+ CComVariant var;
+ switch( type)
+ {
+ case VT_UI1:
+ case VT_I2:
+ case VT_I4:
+ case VT_ERROR:
+ hr= SafeArrayGetElement( val, &i, (void*)&data);
+ sprintf( tmp, "%ld \n", *(long*)&data);
+ break;
+ case VT_BSTR:
+ hr= SafeArrayGetElement( val, &i, (void*)&data);
+ sprintf( tmp, "%S \n", (BSTR)data);
+ break;
+ case VT_VARIANT:
+ hr= SafeArrayGetElement( val, &i, &var);
+ sprintf( tmp, "%x \n", var.byref);
+ break;
+ case VT_R4:
+ hr= SafeArrayGetElement( val, &i, (void*)&data);
+ sprintf( tmp, "%f \n", *(float*) &data);
+ break;
+ case VT_R8: ;
+ hr= SafeArrayGetElement( val, &i, (void*)&data);
+ sprintf( tmp, "%f \n", *(double*) &data);
+ break;
+ case VT_DISPATCH:
+ // we assume the objects are instances of this component and have the
+ // property prpString set.
+ hr= SafeArrayGetElement( val, &i, (void*)&data);
+ IDispatch* pdisp= ( IDispatch*) data;
+ CComDispatchDriver driver( pdisp);
+ CComVariant var;
+ if( pdisp)
+ {
+ driver.GetPropertyByName(L"prpString", &var);
+ sprintf( tmp, "%x : %S \n", *(long*)&data, var.bstrVal);
+ }
+ else
+ sprintf( tmp, "%x\n", *(long*)&data);
+ }
+
+ strcat( buf, tmp);
+ }
+ MessageBox( NULL, _T(A2T(buf)), _T("AxTestComponents.Basic"), MB_OK);
+
+}
+// V_ERROR OLECHAR VARIANT VT_UI1
+
+STDMETHODIMP CBasic::outSequenceByte(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arByte, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceShort(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arShort, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceLong(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arLong, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceString(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arString, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceFloat(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arFloat, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceDouble(LPSAFEARRAY* val)
+{
+ HRESULT hr= S_OK;
+ hr = SafeArrayCopy(m_arDouble, val);
+ return hr;
+}
+
+STDMETHODIMP CBasic::outSequenceObject(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ hr = SafeArrayCopy(m_arObject, val);
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutSequenceByte(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arByte, val)))
+ return hr;
+ m_arByte = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceShort(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arShort, val)))
+ return hr;
+ m_arShort = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceLong(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arLong, val)))
+ return hr;
+ m_arLong = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceString(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arString, val)))
+ return hr;
+ m_arString = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceFloat(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arFloat, val)))
+ return hr;
+ m_arFloat = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceDouble(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arDouble, val)))
+ return hr;
+ m_arDouble = arTemp;
+ return hr;
+}
+
+STDMETHODIMP CBasic::inoutSequenceObject(LPSAFEARRAY* val)
+{
+ HRESULT hr = S_OK;
+ SAFEARRAY *arTemp = NULL;
+ if (FAILED(hr = SafeArrayCopy(*val, &arTemp)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(m_arObject, val)))
+ return hr;
+ m_arObject = arTemp;
+ return hr;
+}
+
+// 2-dimensional Array
+STDMETHODIMP CBasic::inMulDimArrayLong(LPSAFEARRAY val)
+{
+ printMulArray( val, VT_I4);
+ return S_OK;
+}
+// 2-dimensional Array
+STDMETHODIMP CBasic::inMulDimArrayVariant(LPSAFEARRAY val)
+{
+ printMulArray( val, VT_VARIANT);
+ return S_OK;
+}
+// 3-dimensional Array
+STDMETHODIMP CBasic::inMulDimArrayLong2(LPSAFEARRAY val)
+{
+ printMulArray( val, VT_I4);
+ return S_OK;
+}
+// 3-dimensional Array
+STDMETHODIMP CBasic::inMulDimArrayVariant2(LPSAFEARRAY val)
+{
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::inMulDimArrayByte(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arByteDim2)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arByteDim2)))
+ return hr;
+ return hr;
+}
+// 3-dimensionales array
+STDMETHODIMP CBasic::inMulDimArrayByte2(LPSAFEARRAY val)
+{
+
+ // TODO: Add your implementation code here
+ //printMulArray( val, VT_UI1);
+ return S_OK;
+}
+
+// supports 2 and 3 dimensional SAFEARRAY with elements of long or VARIANT
+void CBasic::printMulArray( SAFEARRAY* val, VARTYPE type)
+{
+ HRESULT hr= S_OK;
+ UINT dims= SafeArrayGetDim( val);
+ long lbound1;
+ long ubound1;
+ long lbound2;
+ long ubound2;
+ long lbound3;
+ long ubound3;
+ long length1;
+ long length2;
+
+ char buff[4096];
+ buff[0]=0;
+
+ if( dims == 2)
+ {
+ hr= SafeArrayGetLBound( val, 1, &lbound1);
+ hr= SafeArrayGetUBound( val, 1, &ubound1);
+ length1= ubound1 - lbound1 +1;
+
+ hr= SafeArrayGetLBound( val, 2, &lbound2);
+ hr= SafeArrayGetUBound( val, 2, &ubound2);
+ length2= ubound2 - lbound2 + 1;
+ char tmpBuf[1024];
+ tmpBuf[0]=0;
+ long index[2];
+ for( long i= 0; i< length2; i++)
+ {
+ for( long j= 0; j<length1; j++)
+ {
+ index[0]= j;
+ index[1]= i;
+ long longVal;
+ CComVariant var;
+ switch( type)
+ {
+ case VT_I4:
+ hr= SafeArrayGetElement( val, index, &longVal);
+ sprintf( tmpBuf, "(%ld,%ld): %ld\n", index[1], index[0], longVal);
+ break;
+ case VT_UI1:
+ hr= SafeArrayGetElement( val, index, &longVal);
+ sprintf( tmpBuf, "(%ld,%ld): %d\n", index[1], index[0], (unsigned char)longVal);
+ break;
+ case VT_VARIANT:
+ hr= SafeArrayGetElement( val, index, &var );
+ sprintf( tmpBuf, "(%ld,%ld): %d (vartype %d)\n", index[1], index[0], var.byref, var.vt);
+ break;
+ }
+ strcat( buff,tmpBuf);
+ }
+
+ }
+
+
+ }
+ else if( dims == 3 )
+ {
+ hr= SafeArrayGetLBound( val, 1, &lbound1);
+ hr= SafeArrayGetUBound( val, 1, &ubound1);
+ length1= ubound1 - lbound1 +1;
+
+ hr= SafeArrayGetLBound( val, 2, &lbound2);
+ hr= SafeArrayGetUBound( val, 2, &ubound2);
+ length2= ubound2 - lbound2 + 1;
+
+ hr= SafeArrayGetLBound( val, 3, &lbound3);
+ hr= SafeArrayGetUBound( val, 3, &ubound3);
+ long length3= ubound3 - lbound3 +1;
+ char tmpBuf[1024];
+ tmpBuf[0]=0;
+ long index[3];
+ for( long i= 0; i< length3; i++)
+ {
+ for( long j= 0; j<length2; j++)
+ {
+ for( long k= 0; k<length1; k++)
+ {
+ index[0]= k;
+ index[1]= j;
+ index[2]= i;
+ long longVal;
+ CComVariant var;
+ switch( type)
+ {
+ case VT_I4:
+ hr= SafeArrayGetElement( val, index, &longVal);
+ sprintf( tmpBuf, "(%ld,%ld,%ld): %ld\n", index[2], index[1], index[0], longVal);
+ break;
+ case VT_UI1:
+ hr= SafeArrayGetElement( val, index, &longVal);
+ sprintf( tmpBuf, "(%ld,%ld,%ld): %d\n", index[2], index[1], index[0], (unsigned char)longVal);
+ break;
+
+ case VT_VARIANT:
+ hr= SafeArrayGetElement( val, index, &var );
+ sprintf( tmpBuf, "(%ld,%ld,%ld): %d (vartype %d)\n", index[2], index[1], index[0], var.byref, var.vt);
+ break;
+ }
+ strcat( buff,tmpBuf);
+ }
+ }
+
+ }
+
+ }
+
+ MessageBox( NULL, A2T( buff), _T("AxTestControl.Basic"), MB_OK);
+
+
+}
+
+
+
+
+STDMETHODIMP CBasic::outMore(long* val1, long* val2)
+{
+ // TODO: Add your implementation code here
+ *val1= 111;
+ *val2= 112;
+ return S_OK;
+}
+// If an optional parameter was not provided then the respective member will
+// not be set
+STDMETHODIMP CBasic::optional1(/*[in]*/ long val1, /*[in, optional]*/ VARIANT* val2)
+{
+ m_long = val1;
+ if (val2->vt != VT_ERROR)
+ m_var1 = *val2;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::optional2(/*[out]*/ long* val1,/*[out, optional]*/ VARIANT* val2)
+{
+ HRESULT hr = S_OK;
+ *val1 = m_long;
+
+ if (val2->vt != VT_ERROR)
+ hr = VariantCopy(val2, & m_var1);
+ return hr;
+}
+
+STDMETHODIMP CBasic::optional3(/*[in, optional]*/ VARIANT* val1,/*[in, optional]*/ VARIANT* val2)
+{
+ //if (val1->vt != VT_ERROR)
+ m_var1 = *val1;
+
+ //if (val2->vt != VT_ERROR)
+ m_var2 = *val2;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::optional4(/*[in, out, optional]*/ VARIANT* val1,
+ /*[in, out, optional]*/ VARIANT* val2)
+{
+ HRESULT hr = S_OK;
+ //return the previously set in values
+ if (val1->vt != VT_ERROR)
+ {
+ CComVariant var1(*val1);
+ if (FAILED(hr = VariantCopy(val1, & m_var1)))
+ return hr;
+ m_var1 = var1;
+ }
+ if (val2->vt != VT_ERROR)
+ {
+ CComVariant var2(*val2);
+ if (FAILED(hr = VariantCopy(val2, & m_var2)))
+ return hr;
+ m_var2 = var2;
+ }
+ return hr;
+}
+
+STDMETHODIMP CBasic::optional5(/*[out, optional]*/ VARIANT* val1,
+ /*[out, optional]*/ VARIANT* val2)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy(val1, &m_var1)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val2, &m_var2)))
+ return hr;
+ return hr;
+}
+
+STDMETHODIMP CBasic::defaultvalue1(/*[in, defaultvalue(10)]*/ long val1,
+ /*[in, defaultvalue(3.14)]*/ double* val2,
+ // /*[in, defaultvalue(10)]*/ VARIANT val3,
+ /*[in, defaultvalue(100)]*/ VARIANT* val4)
+{
+ m_long = val1;
+ m_double = *val2;
+// m_var1 = val3;
+ m_var2 = *val4;
+ return S_OK;
+}
+STDMETHODIMP CBasic::defaultvalue2(/*[in, out, defaultvalue(10)]*/ long* val1,
+ /*[in, out, defaultvalue(3.14)]*/ double* val2,
+ // /*[in, out, defaultvalue(10)]*/ VARIANT* val3,
+ /*[in, out, defaultvalue(100)]*/ VARIANT* val4)
+{
+ HRESULT hr = S_OK;
+ long aLong = *val1;
+ double aDouble = *val2;
+// CComVariant var1(*val3);
+ CComVariant var2(*val4);
+ *val1 = m_long;
+ *val2 = m_double;
+ //if (FAILED(hr = VariantCopy(val3, &m_var1)))
+ // return hr;
+ if (FAILED(hr = VariantCopy(val4, &m_var2)))
+ return hr;
+ m_long = aLong;
+ m_double = aDouble;
+// m_var1 = var1;
+ m_var2 = var2;
+ return hr;
+}
+/* val2 contains the variable argument list. If no such arguments are supplied
+ then the safearray is invalid. SafeArrayCopy then returns E_INVALIDARG
+*/
+STDMETHODIMP CBasic::varargfunc1(/*[in]*/ long val1,/*[in]*/ LPSAFEARRAY val2)
+{
+ m_long = val1;
+
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_safearray)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val2, & m_safearray)))
+ {
+ if (hr != E_INVALIDARG)
+ return hr;
+ }
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::varargfunc2(/*[out]*/ long* val1, /*[out]*/ SAFEARRAY ** val2)
+{
+ *val1 = m_long;
+ HRESULT hr = SafeArrayCopy(m_safearray, val2);
+ return hr;
+}
+
+STDMETHODIMP CBasic::inSequenceByteDim2(LPSAFEARRAY val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = SafeArrayDestroy(m_arByteDim2)))
+ return hr;
+ if (FAILED(hr = SafeArrayCopy(val, & m_arByteDim2)))
+ return hr;
+ return hr;
+}
+
+
+STDMETHODIMP CBasic::inCurrency(CY val)
+{
+ m_cy = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outCurrency(CY* val)
+{
+ *val = m_cy;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutCurrency(CY* val)
+{
+ CY tmp = *val;
+ *val = m_cy;
+ m_cy = tmp;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inDate(DATE val)
+{
+ m_date = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outDate(DATE* val)
+{
+ *val = m_date;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutDate(DATE* val)
+{
+ DATE tmp = *val;
+ *val = m_date;
+ m_date = tmp;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpCurrency(CY* pVal)
+{
+ *pVal = m_cy;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpCurrency(CY newVal)
+{
+ m_cy = newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpDate(DATE* pVal)
+{
+ *pVal = m_date;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpDate(DATE newVal)
+{
+ m_date = newVal;
+ return S_OK;
+}
+
+//VT_I4 DECIMAL_NEG //tagVARIANT DISPATCH_PROPERTYPUT
+STDMETHODIMP CBasic::inDecimal(DECIMAL val)
+{
+ m_decimal = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outDecimal(DECIMAL* val)
+{
+ * val = m_decimal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutDecimal(DECIMAL* val)
+{
+ DECIMAL tmp;
+ tmp = * val;
+ * val = m_decimal;
+ m_decimal = tmp;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpDecimal(DECIMAL* pVal)
+{
+ * pVal = m_decimal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpDecimal(DECIMAL newVal)
+{
+ m_decimal = newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inSCode(SCODE val)
+{
+ m_scode = val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outScode(SCODE* val)
+{
+ * val = m_scode;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutSCode(SCODE* val)
+{
+ SCODE tmp = *val;
+ * val = m_scode;
+ m_scode = tmp;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpSCode(SCODE* pVal)
+{
+ * pVal = m_scode;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpSCode(SCODE newVal)
+{
+ m_scode = newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inrefLong(LONG* val)
+{
+ m_long = * val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inrefVariant(VARIANT* val)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy( & m_var1, val)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inrefDecimal(DECIMAL* val)
+{
+ m_decimal = * val;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpRefLong(long* pVal)
+{
+ *pVal = m_long;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::putref_prpRefLong(long* newVal)
+{
+ m_long = * newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prprefVariant(VARIANT* pVal)
+{
+ HRESULT hr = S_OK;
+ hr = VariantCopy(pVal, & m_var1);
+ return hr;
+}
+
+STDMETHODIMP CBasic::putref_prprefVariant(VARIANT* newVal)
+{
+ m_var1 = * newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prprefDecimal(DECIMAL* pVal)
+{
+ * pVal = m_decimal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::putref_prprefDecimal(DECIMAL* newVal)
+{
+ m_decimal = *newVal;
+ return S_OK;
+}
+
+
+STDMETHODIMP CBasic::optional6(VARIANT* val1, VARIANT* val2, VARIANT* val3, VARIANT* val4)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = m_var1.Copy(val1)))
+ return hr;
+ if (FAILED(hr = m_var2.Copy(val2)))
+ return hr;
+ if (FAILED(hr = m_var3.Copy(val3)))
+ return hr;
+ if (FAILED(hr = m_var4.Copy(val4)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::optional7(VARIANT* val1, VARIANT* val2, VARIANT* val3, VARIANT* val4)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(hr = VariantCopy(val1, & m_var1)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val2, & m_var2)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val3, & m_var3)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val4, & m_var4)))
+ return hr;
+
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpMultiArg1(VARIANT* val1, VARIANT* val2, VARIANT* pVal)
+{
+ HRESULT hr = S_OK;
+ CComVariant tmp1(*val1);
+ CComVariant tmp2(*val2);
+
+ if (FAILED(hr = VariantCopy(val1, & m_var1)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val2, & m_var2)))
+ return hr;
+ m_var1 = tmp1;
+ m_var2 = tmp2;
+ if (FAILED(hr = VariantCopy(pVal, & m_var3)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpMultiArg1(VARIANT* val1, VARIANT* val2, VARIANT* newVal)
+{
+ HRESULT hr = S_OK;
+ CComVariant tmp1( * val1);
+ CComVariant tmp2( * val2);
+
+ if (FAILED(hr = VariantCopy(val1, & m_var1)))
+ return hr;
+ if (FAILED(hr = VariantCopy(val2, & m_var2)))
+ return hr;
+ m_var1 = tmp1;
+ m_var2 = tmp2;
+
+ m_var3 = *newVal;
+ return S_OK;
+}
+
+// tagVARIANT DISPATCH_PROPERTYPUT DISPID_PROPERTYPUT VARIANTARG LOCALE_USER_DEFAULT
+
+STDMETHODIMP CBasic::get_prpMultiArg2(VARIANT val1, VARIANT* pVal)
+{
+ HRESULT hr = S_OK;
+ m_var1 = val1;
+
+ if (FAILED(hr = VariantCopy(pVal, & m_var2)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpMultiArg2(VARIANT val1, VARIANT newVal)
+{
+ m_var1 = val1;
+ m_var2 = newVal;
+ return S_OK;
+}
+
+// returns the values set by prpMultiArg2
+STDMETHODIMP CBasic::prpMultiArg2GetValues(VARIANT* val1, VARIANT* valProperty)
+{
+ HRESULT hr = S_OK;
+ if (FAILED(VariantCopy(val1, & m_var1)))
+ return hr;
+ if (FAILED(VariantCopy(valProperty, & m_var2)))
+ return hr;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpMultiArg3(LONG* val1, LONG* pVal)
+{
+ long aLong = *val1;
+ *val1 = m_long;
+ m_long = aLong;
+
+ * pVal = m_long2;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpMultiArg3(LONG* val1, LONG newVal)
+{
+ long aLong = *val1;
+ *val1 = m_long;
+ m_long = aLong;
+
+ m_long2 = newVal;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inUnknown(IUnknown* val)
+{
+ m_unknown = val;
+
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::outUnknown(IUnknown** val)
+{
+ m_unknown.CopyTo(val);
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::inoutUnknown(IUnknown** val)
+{
+ CComPtr<IUnknown> tmp = *val;
+ m_unknown.CopyTo(val);
+ m_unknown = tmp;
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::get_prpUnknown(IUnknown** pVal)
+{
+ m_prpUnknown.CopyTo(pVal);
+ return S_OK;
+}
+
+STDMETHODIMP CBasic::put_prpUnknown(IUnknown* newVal)
+{
+ m_prpUnknown = newVal;
+ return S_OK;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */