Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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: */