xref: /trunk/main/extensions/test/ole/AxTestComponents/Basic.cpp (revision 520fa26520b0e796579cd98364c4c8e80094d346)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#include "stdafx.h"
//#include "AxTestComponents.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, "%d \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 dimensionals 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;
    long length3;

    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, "(%d,%d): %d\n", index[1], index[0], longVal);
                    break;
                case VT_UI1:
                    hr= SafeArrayGetElement( val, index, &longVal);
                    sprintf( tmpBuf, "(%d,%d): %d\n", index[1], index[0], (unsigned char)longVal);
                    break;
                case VT_VARIANT:
                    hr= SafeArrayGetElement( val, index, &var );
                    sprintf( tmpBuf, "(%d,%d):  %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);
        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, "(%d,%d,%d): %d\n", index[2], index[1], index[0], longVal);
                        break;
                    case VT_UI1:
                        hr= SafeArrayGetElement( val, index, &longVal);
                        sprintf( tmpBuf, "(%d,%d,%d): %d\n", index[2], index[1], index[0], (unsigned char)longVal);
                        break;

                    case VT_VARIANT:
                        hr= SafeArrayGetElement( val, index, &var );
                        sprintf( tmpBuf, "(%d,%d,%d):  %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;
}