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