| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_extensions.hxx" |
| |
| #pragma warning (disable: 4917) |
| #include <windows.h> |
| #include <comdef.h> |
| #include <tchar.h> |
| #include <atlbase.h> |
| extern CComModule _Module; |
| #include<atlcom.h> |
| |
| #include <stdio.h> |
| #include <com/sun/star/bridge/ModelDependent.hpp> |
| #include <com/sun/star/bridge/XBridgeSupplier2.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/uno/XComponentContext.hpp> |
| #include <com/sun/star/lang/XMultiComponentFactory.hpp> |
| |
| #include <oletest/XTestSequence.hpp> |
| #include <rtl/process.h> |
| #include <com/sun/star/uno/Reference.h> |
| #include <cppuhelper/servicefactory.hxx> |
| #include <cppuhelper/bootstrap.hxx> |
| #include <rtl/string.h> |
| |
| |
| CComModule _Module; |
| BEGIN_OBJECT_MAP(ObjectMap) |
| END_OBJECT_MAP() |
| |
| #include "smartarray.h" |
| using namespace com::sun::star::bridge; |
| using namespace com::sun::star::bridge::ModelDependent; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::uno; |
| using namespace oletest; |
| using namespace cppu; |
| using namespace rtl; |
| HRESULT doTest(); |
| HRESULT InitializeParameter(); |
| void printResultVariantArray( VARIANT & var); |
| void printVariant( VARIANT & var); |
| |
| |
| |
| |
| int __cdecl _tmain( int argc, _TCHAR * argv[] ) |
| { |
| HRESULT hr; |
| if( FAILED( hr=CoInitialize(NULL))) |
| { |
| _tprintf(_T("CoInitialize failed \n")); |
| return -1; |
| } |
| |
| |
| _Module.Init( ObjectMap, GetModuleHandle( NULL)); |
| |
| if( FAILED(hr=doTest())) |
| { |
| _com_error err( hr); |
| const TCHAR * errMsg= err.ErrorMessage(); |
| MessageBox( NULL, errMsg, "Test failed", MB_ICONERROR); |
| } |
| |
| |
| _Module.Term(); |
| CoUninitialize(); |
| return 0; |
| } |
| char _c[]={ 1,2,3,4,5}; |
| short _short[]={0xffff, 1, 11 ,111, 1111 }; |
| unsigned short _ushort[]={0xffff, 1, 11 ,111, 1111 }; |
| long _long[]= { 0xffffffff, 11, 111 ,1111, 1111 }; |
| unsigned long _ulong[]= { 0xffffffff, 11, 111 ,1111, 1111 }; |
| float _float[]= { 12345.f, 1234.5f, 123.45f, 12.345f, 1.2345f}; |
| double _double[]= {12345, 1234.5, 123.45, 12.345, 1.2345}; |
| |
| CComVariant _variant[]= {L"variant 1", L"variant2", L"variant3"}; |
| wchar_t _wchar[]= {L'1', L'2', L'3', L'A', L' '}; |
| BSTR _bstr[]={L"Ich", L"bin", L"ein", L"Hamburger", L"Jung"}; |
| SmartArray<char> arByte( _c, 5, VT_I1); |
| SmartArray< short> arShort( _short, 5, VT_I2); |
| //SmartArray< unsigned short> arUShort( _ushort, 5, VT_UI2); |
| SmartArray< long> arLong( _long, 5, VT_I4); |
| //SmartArray< unsigned long> arULong( _ulong, 5, VT_UI4); |
| //SmartArray< float> arFloat( _float, 5, VT_R4 ); |
| SmartArray< double> arDouble( _double, 5, VT_R8 ); |
| //SmartArray< unsigned short> arWChar( _wchar, 5, VT_UI2 ); |
| SmartArray< wchar_t* > arString( _bstr, 5, VT_BSTR); |
| SmartArray< VARIANT > arVariant( _variant, 3, VT_VARIANT); |
| |
| |
| HRESULT doTest() |
| { |
| HRESULT hr; |
| USES_CONVERSION; |
| CComPtr<IUnknown> spUnkMgr; |
| |
| putenv("UNO_TYPES=types.rdb"); |
| putenv("UNO_SERVICES=services.rdb"); |
| Reference<XComponentContext> xContext = defaultBootstrap_InitialComponentContext(); |
| |
| Reference< XMultiComponentFactory > mgr = xContext->getServiceManager();//createRegistryServiceFactory( OUString(L"services.rdb")); |
| Reference< XInterface > xIntSupplier= mgr->createInstanceWithContext( |
| OUString(L"com.sun.star.bridge.OleBridgeSupplierVar1"), xContext); |
| Reference< XBridgeSupplier2 > xSuppl( xIntSupplier, UNO_QUERY); |
| Reference <XInterface> xOletest= mgr->createInstanceWithContext( |
| OUString(L"oletest.OleTest"), xContext); |
| Any any; |
| any <<= xOletest; |
| sal_uInt8 arId[16]; |
| rtl_getGlobalProcessId( arId); |
| Any target= xSuppl->createBridge( any, Sequence<sal_Int8>( (sal_Int8*)arId, 16), UNO, OLE); |
| CComDispatchDriver oletest; |
| if (target.getValueTypeClass() == getCppuType((sal_uInt32*) 0).getTypeClass()) |
| { |
| VARIANT* pVariant = *(VARIANT**)target.getValue(); |
| |
| oletest= pVariant->pdispVal; |
| |
| VariantClear(pVariant); |
| CoTaskMemFree(pVariant); |
| } |
| |
| CComVariant varRet; |
| CComVariant varParam1; |
| CComVariant varParam2; |
| CComVariant varParam3; |
| CComVariant varParam4; |
| |
| long value= 100; |
| varParam1.vt= VT_I1 | VT_BYREF; |
| varParam1.plVal= &value; |
| |
| // Testing the caching of DISPIDs and the process of aquiring member information |
| // on demand in IDispatch::Invoke |
| // Step through the corresponding IDispatch implementation of the ole bridge |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varParam1, &varRet); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varParam1, &varRet); |
| // Name ok but different case |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout_methodByte"), &varParam1, &varRet); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout_methodByte"), &varParam1, &varRet); |
| // not existing member |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout"), &varParam1, &varRet); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout"), &varParam1, &varRet); |
| |
| // Property |
| varParam1.vt= VT_ARRAY | VT_I1; |
| varParam1.parray= (SAFEARRAY*)arByte; |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); |
| // Name ok but different case |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varParam1); |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varParam1); |
| // not existing member |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attr"), &varParam1); |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attr"), &varParam1); |
| |
| // PropertyGet |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varRet); |
| |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varRet); |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varRet); |
| //not existing member |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrBy"), &varRet); |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrBy"), &varRet); |
| |
| DISPID dispid; |
| LPOLESTR method= L"methodByte"; |
| hr = oletest.p->GetIDsOfNames(IID_NULL, &method, 1, LOCALE_USER_DEFAULT, &dispid); |
| |
| |
| CComVariant arg[1]; |
| arg[0].vt= VT_ARRAY | VT_I1; |
| arg[0].parray= (SAFEARRAY*)arByte; |
| DISPPARAMS params={ arg,0,1,0}; |
| |
| hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); |
| |
| hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); |
| |
| // different case |
| LPOLESTR method2= L"MEthodByte"; |
| hr = oletest.p->GetIDsOfNames(IID_NULL, &method2, 1, LOCALE_USER_DEFAULT, &dispid); |
| |
| hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); |
| |
| hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); |
| |
| LPOLESTR attrib= L"AttrByte"; |
| hr = oletest.p->GetIDsOfNames(IID_NULL, &attrib, 1, LOCALE_USER_DEFAULT, &dispid); |
| |
| hr = oletest.p->Invoke( dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYPUTREF, ¶ms, &varRet, NULL, NULL); |
| |
| hr = oletest.p->Invoke( dispid, IID_NULL, LOCALE_USER_DEFAULT, |
| DISPATCH_METHOD | DISPATCH_PROPERTYGET, ¶ms, &varRet, NULL, NULL); |
| |
| |
| |
| CComVariant varByteArray; |
| varByteArray.vt= VT_ARRAY | VT_I1; |
| varByteArray.parray= (SAFEARRAY*)arByte; |
| CComVariant varShortArray; |
| varShortArray.vt= VT_ARRAY | VT_I2; |
| varShortArray.parray= (SAFEARRAY*)arShort; |
| CComVariant varLongArray; |
| varLongArray.vt= VT_ARRAY | VT_I4; |
| varLongArray.parray= (SAFEARRAY*)arLong; |
| CComVariant varDoubleArray; |
| varDoubleArray.vt= VT_ARRAY | VT_R8; |
| varDoubleArray.parray= (SAFEARRAY*)arDouble; |
| CComVariant varStringArray; |
| varStringArray.vt= VT_ARRAY | VT_BSTR; |
| varStringArray.parray= (SAFEARRAY*)arString; |
| CComVariant varArray; |
| varArray.vt= VT_ARRAY | VT_VARIANT; |
| varArray.parray= (SAFEARRAY*)arVariant; |
| |
| FONTDESC fd={ sizeof( fd), L"ARIAL", 10, FW_NORMAL, 0, 0, 0, 0}; |
| |
| |
| CComPtr< IUnknown > unk1; |
| CComPtr< IUnknown > unk2; |
| CComPtr< IUnknown > unk3; |
| |
| IUnknown* _unknown[3]; |
| hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk1.p); |
| hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk2.p); |
| hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk3.p); |
| _unknown[0]= unk1; |
| _unknown[1]= unk2; |
| _unknown[2]= unk3; |
| SmartArray<IUnknown*> arUnknown( _unknown, 3, VT_UNKNOWN); |
| |
| CComVariant varUnkArray; |
| varUnkArray.vt= VT_ARRAY | VT_UNKNOWN; |
| varUnkArray.parray= (SAFEARRAY*)arUnknown; |
| |
| // preparing out parameter; |
| char byteOut; |
| CComVariant varOutByte; //### |
| varOutByte.vt= VT_BYREF | VT_UI1; |
| V_I1REF(&varOutByte)= &byteOut; |
| short shortOut; |
| CComVariant varOutShort; //### |
| varOutShort.vt= VT_BYREF | VT_I2; |
| V_I2REF( &varOutShort)= &shortOut; |
| long longOut; |
| CComVariant varOutLong; //### |
| varOutLong.vt= VT_BYREF | VT_I4; |
| V_I4REF( &varOutLong)= &longOut; |
| double doubleOut; |
| CComVariant varOutDouble; //### |
| varOutDouble.vt= VT_BYREF | VT_R8; |
| V_R8REF( &varOutDouble)= &doubleOut; |
| BSTR bstrOut= NULL; |
| CComVariant varOutString; //### |
| varOutString.vt= VT_BYREF | VT_BSTR; |
| V_BSTRREF(&varOutString)= &bstrOut; |
| CComVariant variantOut; |
| CComVariant varOutAny; //### |
| varOutAny.vt= VT_BYREF | VT_VARIANT; |
| V_VARIANTREF(&varOutAny)= &variantOut; |
| |
| CComPtr<IDispatch> dispOut; |
| CComVariant varOutXInterface; //### |
| varOutXInterface.vt= VT_BYREF |VT_DISPATCH; |
| V_DISPATCHREF(&varOutXInterface)= &dispOut.p; |
| |
| // In Parameter ( all of type Sequence ########################################################### |
| OutputDebugString( _T("In parameter of type Sequence ###########################################\n" |
| "The functions return the Sequence parameter \n\n")); |
| |
| OutputDebugStringA("methodByte | Params: \n"); |
| printVariant( varByteArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodByte"), &varByteArray, &varRet); |
| OutputDebugStringA("methodByte | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodShort | Params: \n"); |
| printVariant( varShortArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodShort"), &varShortArray, &varRet); |
| OutputDebugStringA("methodShort | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodLong | Params: \n"); |
| printVariant( varLongArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodLong"), &varLongArray, &varRet); |
| OutputDebugStringA("methodLong | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodDouble | Params: \n"); |
| printVariant( varDoubleArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodDouble"), &varDoubleArray, &varRet); |
| OutputDebugStringA("methodDouble | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodString | Params: \n"); |
| printVariant( varStringArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodString"), &varStringArray, &varRet); |
| OutputDebugStringA("methodString | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodAny | Params: \n"); |
| printVariant( varArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodAny"), &varArray, &varRet); |
| OutputDebugStringA("methodAny | return value \n"); |
| printVariant( varRet); |
| |
| OutputDebugStringA("methodXInterface | Params: \n"); |
| printVariant( varUnkArray); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodXInterface"), &varUnkArray, &varRet); |
| OutputDebugStringA("methodAny | return value \n"); |
| printVariant( varRet); |
| |
| // Out Parameter ########################################################################### |
| OutputDebugString( _T("Out parameter ###########################################\n\n")); |
| |
| OutputDebugString(_T("testout_methodByte \n")); |
| hr= oletest.InvokeN(static_cast<LPCOLESTR>(L"testout_methodByte"), &varOutByte, 1, &varRet); |
| OutputDebugString(_T("testout_methodByte | out value: \n")); |
| printVariant( varOutByte); |
| |
| OutputDebugString(_T("testout_methodShort \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodShort"), &varOutShort, &varRet); |
| OutputDebugString(_T("testout_methodShort | out value: \n")); |
| printVariant( varOutShort); |
| |
| OutputDebugString(_T("testout_methodLong \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodLong"), &varOutLong, &varRet); |
| OutputDebugString(_T("testout_methodLong | out value: \n")); |
| printVariant( varOutLong); |
| |
| OutputDebugString(_T("testout_methodDouble \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodDouble"), &varOutDouble, &varRet); |
| OutputDebugString(_T("testout_methodDouble | out value: \n")); |
| printVariant( varOutDouble); |
| |
| OutputDebugString(_T("testout_methodString \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodString"), &varOutString, &varRet); |
| OutputDebugString(_T("testout_methodString | out value: \n")); |
| printVariant( varOutString); |
| |
| OutputDebugString(_T("testout_methodAny \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodAny"), &varOutAny, &varRet); |
| OutputDebugString(_T("methodAny | out value: \n")); |
| printVariant( varOutAny); |
| |
| OutputDebugString(_T("testout_methodXInterface \n")); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodXInterface"), &varOutXInterface, &varRet); |
| OutputDebugString(_T("methodAny | out value: \n")); |
| printVariant( varOutXInterface); |
| CComDispatchDriver outDisp( *varOutXInterface.ppdispVal); |
| CComVariant varAttr3; |
| outDisp.GetPropertyByName(L"AttrAny2", &varAttr3); |
| ATLTRACE("property OleTest.AttrAny2: %s", W2T(varAttr3.bstrVal)); |
| |
| OutputDebugString(_T("testout_methodMulParams1 ( 2 out Parameter) \n")); |
| long longOut2=0; |
| CComVariant _params[2]; |
| longOut=0; |
| _params[0]= varOutLong; |
| _params[1].vt= VT_BYREF | VT_I4; |
| V_I4REF(& _params[1])= &longOut2; |
| hr= oletest.InvokeN( static_cast<LPCOLESTR>(L"testout_methodMulParams1"), (VARIANT*)&_params, 2); |
| OutputDebugString(_T("testout_methodMulParams1 | out values: \n")); |
| printVariant( _params[1]); |
| printVariant( _params[0]); |
| |
| OutputDebugString(_T("testout_methodMulParams2 ( 3 out Parameter) \n")); |
| CComVariant _params2[3]; |
| _params2[2]= varOutLong; |
| _params2[1].vt= VT_BYREF | VT_I4; |
| V_I4REF(& _params2[1])= &longOut2; |
| _params2[0]= varOutString; |
| hr= oletest.InvokeN( static_cast<LPCOLESTR>( L"testout_methodMulParams2"), (VARIANT*)&_params2, 3); |
| OutputDebugString(_T("testout_methodMulParams2 | out values: \n")); |
| printVariant( _params2[2]); |
| printVariant( _params2[1]); |
| printVariant( _params2[0]); |
| |
| OutputDebugString(_T("testout_methodMulParams3 ( 1 in and 1 out Parameter) \n")); |
| CComVariant _params3[2]; |
| _params3[1]= CComBSTR(L" In string"); |
| _params3[0]= varOutString; |
| hr= oletest.InvokeN( static_cast<LPCOLESTR>( L"testout_methodMulParams3"), (VARIANT*)&_params3, 2); |
| OutputDebugString(_T("testout_methodMulParams3 | out values: \n")); |
| printVariant( _params3[1]); |
| printVariant( _params3[0]); |
| |
| //In Out Parameter ########################################################################### |
| OutputDebugString( _T("In Out parameter ###########################################\n\n")); |
| |
| *V_I1REF(&varOutByte)= 5; |
| ATLTRACE(_T("testinout_methodByte | in value: %d \n"), *V_I1REF(&varOutByte)); |
| hr= oletest.InvokeN(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varOutByte, 1, &varRet); |
| OutputDebugString(_T("testinout_methodByte | out value: \n")); |
| printVariant( varOutByte); |
| |
| OutputDebugString(_T("testinout_methodShort | in value= 1000 \n")); |
| *V_UI2REF(&varOutShort)= 1000; |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodShort"), &varOutShort, &varRet); |
| OutputDebugString(_T("testinout_methodShort | out value: \n")); |
| printVariant( varOutShort); |
| |
| OutputDebugString(_T("testinout_methodLong | in value= 10000 \n")); |
| *V_UI4REF(&varOutLong)= 10000; |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodLong"), &varOutLong, &varRet); |
| OutputDebugString(_T("testinout_methodLong | out value: \n")); |
| printVariant( varOutLong); |
| |
| *V_R8REF(&varOutDouble)= 3.14; |
| ATLTRACE(_T("testinou_methodDouble in value: %f \n"),*V_R8REF(&varOutDouble)); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodDouble"), &varOutDouble, &varRet); |
| OutputDebugString(_T("testinout_methodDouble | out value: \n")); |
| printVariant( varOutDouble); |
| |
| SysFreeString( *V_BSTRREF(&varOutString)); |
| *V_BSTRREF(&varOutString)= SysAllocString( L"this is a in string"); |
| ATLTRACE(_T("testinout_methodString | value: %s \n"), W2T(*V_BSTRREF(&varOutString))); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodString"), &varOutString, &varRet); |
| OutputDebugString(_T("testinout_methodString | out value: \n")); |
| printVariant( varOutString); |
| |
| CComVariant var1(CComBSTR(L" this is a string in a VARIANT")); |
| CComVariant outVar1; |
| outVar1.vt= VT_BYREF | VT_VARIANT; |
| outVar1.pvarVal= &var1; |
| ATLTRACE(_T("testinout_methodAny | parameter: %s\n"), W2T(var1.bstrVal)); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodAny"), &varOutAny, &varRet); |
| OutputDebugString(_T("testinout_methodAny | out value: \n")); |
| printVariant( varOutAny); |
| |
| CComPtr< IUnknown > objectIn = unk1; |
| CComVariant varOutIFace; |
| varOutIFace.vt= VT_BYREF | VT_UNKNOWN; |
| varOutIFace.ppunkVal= &objectIn.p; |
| (*varOutIFace.ppunkVal)->AddRef(); |
| OutputDebugString(_T("testinout_methodXInterface | in value: \n")); |
| printVariant(varOutIFace); |
| hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodXInterface"), &varOutIFace, &varRet); |
| OutputDebugString(_T("testinout_methodXInterface | out value: \n")); |
| printVariant( varOutIFace); |
| |
| // Properties ###################################################################### |
| OutputDebugString( _T(" Properties ###########################################\n\n")); |
| |
| OutputDebugString(_T("set property \"AttrByte\" | value")); |
| //CComVariant propArByte; |
| //propArByte.vt= VT_ARRAY | VT_I1; |
| varParam1.parray= (SAFEARRAY*)arByte; |
| printVariant( varParam1); |
| hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); |
| OutputDebugString(_T("get property \"AttrByte\" | value:")); |
| varRet.Clear(); |
| hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varRet); |
| printVariant( varRet); |
| |
| |
| return S_OK; |
| |
| |
| } |
| |
| |
| void printVariant( VARIANT & _var) |
| { |
| HRESULT hr; |
| USES_CONVERSION; |
| CComVariant var; |
| hr= VariantCopyInd( &var, &_var); |
| if( var.vt & VT_ARRAY) |
| { |
| VARTYPE type= var.vt ^ VT_ARRAY; |
| SAFEARRAY * sarray= var.parray; |
| long lbound; |
| long ubound; |
| hr= SafeArrayGetLBound( sarray, 1, &lbound); |
| hr= SafeArrayGetUBound( sarray, 1, &ubound); |
| long count= ubound - lbound + 1; |
| char charValue; |
| BYTE byteValue; |
| short shortValue; |
| long longValue; |
| double doubleValue; |
| IUnknown* unkValue; |
| BSTR bstrValue; |
| OutputDebugString( _T("# Array \n")); |
| for( long i= 0; i < count; i++) |
| { |
| // CComVariant variantValue; |
| TCHAR *buf[256]; |
| wsprintf( (TCHAR*)buf, _T("%d : "), i); |
| OutputDebugString( (TCHAR*)buf); |
| VARIANT varTemp; |
| VariantInit( &varTemp); |
| VARIANT variantValue; |
| VariantInit( &variantValue); |
| switch( type) |
| { |
| case VT_UI1: |
| hr= SafeArrayGetElement( sarray, &i, &byteValue); |
| varTemp.vt= VT_UI1; |
| V_UI1( &varTemp)= byteValue; |
| printVariant( varTemp); |
| break; |
| case VT_I1: |
| hr= SafeArrayGetElement( sarray, &i, &charValue); |
| varTemp.vt= VT_I1; |
| V_I1( &varTemp)= charValue; |
| printVariant( varTemp); |
| break; |
| case VT_I2: |
| hr= SafeArrayGetElement( sarray, &i, &shortValue); |
| varTemp.vt= VT_I2; |
| V_I2( &varTemp)= shortValue; |
| printVariant( varTemp); |
| break; |
| |
| case VT_UI2: |
| case VT_I4: |
| hr= SafeArrayGetElement( sarray, &i, &longValue); |
| varTemp.vt= VT_I4; |
| V_I4( &varTemp)= longValue; |
| printVariant( varTemp); |
| break; |
| case VT_R8: |
| hr= SafeArrayGetElement( sarray, &i, &doubleValue); |
| varTemp.vt= VT_R8; |
| V_R8( &varTemp)= doubleValue; |
| printVariant( varTemp); |
| break; |
| case VT_BSTR: |
| hr= SafeArrayGetElement( sarray, &i, &bstrValue); |
| varTemp.vt= VT_BSTR; |
| varTemp.bstrVal= bstrValue; |
| printVariant( varTemp); |
| break; |
| case VT_VARIANT: |
| hr= SafeArrayGetElement( sarray, &i, &varTemp); |
| printVariant( varTemp); |
| break; |
| |
| case VT_UNKNOWN: |
| hr= SafeArrayGetElement( sarray, &i, &unkValue); |
| varTemp.vt= VT_UNKNOWN; |
| varTemp.punkVal= unkValue; |
| printVariant( varTemp); |
| break; |
| } |
| |
| VariantClear( &varTemp); |
| VariantClear( &variantValue); |
| } |
| |
| } |
| else |
| { |
| TCHAR buf[256]; |
| switch (var.vt) |
| { |
| case VT_I1: wsprintf( (TCHAR*)buf, _T(" VT_I1: %d \n"), V_I1( &var) ); |
| break; |
| case VT_UI1: wsprintf( (TCHAR*)buf, _T(" VT_UI1: %d \n"), V_I1( &var) ); |
| break; |
| |
| case VT_I2: wsprintf( (TCHAR*)buf, _T(" VT_I2: %d \n"), V_I2( &var) ); |
| break; |
| case VT_I4: wsprintf( (TCHAR*)buf, _T(" VT_I4: %d \n"), V_I4( &var) ); |
| break; |
| case VT_R8: |
| { |
| |
| // int decimal, sign; |
| // char *buffer; |
| // int precision = 14; |
| // double source = 3.1415926535; |
| |
| // buffer = _ecvt( V_R8(&var), precision, &decimal, &sign ); |
| sprintf( (TCHAR*)buf, _T(" VT_R8: %f \n"),V_R8( &var) ); |
| break; |
| } |
| case VT_UNKNOWN: |
| // The object implement IFont |
| { |
| CComDispatchDriver disp( var.punkVal); |
| CComVariant ret; |
| hr= disp.GetPropertyByName( static_cast<LPCOLESTR>(L"Name"), &ret); |
| wsprintf( (TCHAR*)buf, _T(" VT_UNKNOWN: property \"Name\": %s \n"), W2T(ret.bstrVal)); |
| break; |
| } |
| case VT_DISPATCH: |
| // The object implement IFont |
| { |
| CComDispatchDriver disp( var.punkVal); |
| CComVariant ret; |
| if( SUCCEEDED( hr= disp.GetPropertyByName( static_cast<LPCOLESTR>(L"Name"), &ret))) |
| wsprintf( (TCHAR*)buf, _T(" VT_DISPATCH: property \"Name\": %s \n"), W2T(ret.bstrVal)); |
| else |
| wsprintf( (TCHAR*)buf, _T(" VT_DISPATCH \n")); |
| |
| break; |
| } |
| |
| |
| case VT_BSTR: |
| { |
| TCHAR* str= W2T( var.bstrVal); |
| wsprintf( (TCHAR*)buf, _T(" VT_BSTR: %s \n"), str); |
| } |
| break; |
| default: |
| wsprintf( (TCHAR*)buf, _T("\n")); |
| |
| } |
| |
| OutputDebugString( (TCHAR*) buf); |
| } |
| |
| return; |
| |
| } |
| |