| /************************************************************** |
| * |
| * 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; |
| } |