1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_extensions.hxx" 26 27 #pragma warning (disable: 4917) 28 #include <windows.h> 29 #include <comdef.h> 30 #include <tchar.h> 31 #include <atlbase.h> 32 extern CComModule _Module; 33 #include<atlcom.h> 34 35 #include <stdio.h> 36 #include <com/sun/star/bridge/ModelDependent.hpp> 37 #include <com/sun/star/bridge/XBridgeSupplier2.hpp> 38 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 39 #include <com/sun/star/uno/XComponentContext.hpp> 40 #include <com/sun/star/lang/XMultiComponentFactory.hpp> 41 42 #include <oletest/XTestSequence.hpp> 43 #include <rtl/process.h> 44 #include <com/sun/star/uno/Reference.h> 45 #include <cppuhelper/servicefactory.hxx> 46 #include <cppuhelper/bootstrap.hxx> 47 #include <rtl/string.h> 48 49 50 CComModule _Module; 51 BEGIN_OBJECT_MAP(ObjectMap) 52 END_OBJECT_MAP() 53 54 #include "smartarray.h" 55 using namespace com::sun::star::bridge; 56 using namespace com::sun::star::bridge::ModelDependent; 57 using namespace com::sun::star::lang; 58 using namespace com::sun::star::uno; 59 using namespace oletest; 60 using namespace cppu; 61 using namespace rtl; 62 HRESULT doTest(); 63 HRESULT InitializeParameter(); 64 void printResultVariantArray( VARIANT & var); 65 void printVariant( VARIANT & var); 66 67 68 69 70 int __cdecl _tmain( int argc, _TCHAR * argv[] ) 71 { 72 HRESULT hr; 73 if( FAILED( hr=CoInitialize(NULL))) 74 { 75 _tprintf(_T("CoInitialize failed \n")); 76 return -1; 77 } 78 79 80 _Module.Init( ObjectMap, GetModuleHandle( NULL)); 81 82 if( FAILED(hr=doTest())) 83 { 84 _com_error err( hr); 85 const TCHAR * errMsg= err.ErrorMessage(); 86 MessageBox( NULL, errMsg, "Test failed", MB_ICONERROR); 87 } 88 89 90 _Module.Term(); 91 CoUninitialize(); 92 return 0; 93 } 94 char _c[]={ 1,2,3,4,5}; 95 short _short[]={0xffff, 1, 11 ,111, 1111 }; 96 unsigned short _ushort[]={0xffff, 1, 11 ,111, 1111 }; 97 long _long[]= { 0xffffffff, 11, 111 ,1111, 1111 }; 98 unsigned long _ulong[]= { 0xffffffff, 11, 111 ,1111, 1111 }; 99 float _float[]= { 12345.f, 1234.5f, 123.45f, 12.345f, 1.2345f}; 100 double _double[]= {12345, 1234.5, 123.45, 12.345, 1.2345}; 101 102 CComVariant _variant[]= {L"variant 1", L"variant2", L"variant3"}; 103 wchar_t _wchar[]= {L'1', L'2', L'3', L'A', L' '}; 104 BSTR _bstr[]={L"Ich", L"bin", L"ein", L"Hamburger", L"Jung"}; 105 SmartArray<char> arByte( _c, 5, VT_I1); 106 SmartArray< short> arShort( _short, 5, VT_I2); 107 //SmartArray< unsigned short> arUShort( _ushort, 5, VT_UI2); 108 SmartArray< long> arLong( _long, 5, VT_I4); 109 //SmartArray< unsigned long> arULong( _ulong, 5, VT_UI4); 110 //SmartArray< float> arFloat( _float, 5, VT_R4 ); 111 SmartArray< double> arDouble( _double, 5, VT_R8 ); 112 //SmartArray< unsigned short> arWChar( _wchar, 5, VT_UI2 ); 113 SmartArray< wchar_t* > arString( _bstr, 5, VT_BSTR); 114 SmartArray< VARIANT > arVariant( _variant, 3, VT_VARIANT); 115 116 117 HRESULT doTest() 118 { 119 HRESULT hr; 120 USES_CONVERSION; 121 CComPtr<IUnknown> spUnkMgr; 122 123 putenv("UNO_TYPES=types.rdb"); 124 putenv("UNO_SERVICES=services.rdb"); 125 Reference<XComponentContext> xContext = defaultBootstrap_InitialComponentContext(); 126 127 Reference< XMultiComponentFactory > mgr = xContext->getServiceManager();//createRegistryServiceFactory( OUString(L"services.rdb")); 128 Reference< XInterface > xIntSupplier= mgr->createInstanceWithContext( 129 OUString(L"com.sun.star.bridge.OleBridgeSupplierVar1"), xContext); 130 Reference< XBridgeSupplier2 > xSuppl( xIntSupplier, UNO_QUERY); 131 Reference <XInterface> xOletest= mgr->createInstanceWithContext( 132 OUString(L"oletest.OleTest"), xContext); 133 Any any; 134 any <<= xOletest; 135 sal_uInt8 arId[16]; 136 rtl_getGlobalProcessId( arId); 137 Any target= xSuppl->createBridge( any, Sequence<sal_Int8>( (sal_Int8*)arId, 16), UNO, OLE); 138 CComDispatchDriver oletest; 139 if (target.getValueTypeClass() == getCppuType((sal_uInt32*) 0).getTypeClass()) 140 { 141 VARIANT* pVariant = *(VARIANT**)target.getValue(); 142 143 oletest= pVariant->pdispVal; 144 145 VariantClear(pVariant); 146 CoTaskMemFree(pVariant); 147 } 148 149 CComVariant varRet; 150 CComVariant varParam1; 151 CComVariant varParam2; 152 CComVariant varParam3; 153 CComVariant varParam4; 154 155 long value= 100; 156 varParam1.vt= VT_I1 | VT_BYREF; 157 varParam1.plVal= &value; 158 159 // Testing the caching of DISPIDs and the process of aquiring member information 160 // on demand in IDispatch::Invoke 161 // Step through the corresponding IDispatch implementation of the ole bridge 162 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varParam1, &varRet); 163 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varParam1, &varRet); 164 // Name ok but different case 165 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout_methodByte"), &varParam1, &varRet); 166 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout_methodByte"), &varParam1, &varRet); 167 // not existing member 168 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout"), &varParam1, &varRet); 169 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"Testinout"), &varParam1, &varRet); 170 171 // Property 172 varParam1.vt= VT_ARRAY | VT_I1; 173 varParam1.parray= (SAFEARRAY*)arByte; 174 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); 175 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); 176 // Name ok but different case 177 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varParam1); 178 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varParam1); 179 // not existing member 180 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attr"), &varParam1); 181 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"attr"), &varParam1); 182 183 // PropertyGet 184 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varRet); 185 186 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varRet); 187 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrByte"), &varRet); 188 //not existing member 189 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrBy"), &varRet); 190 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"attrBy"), &varRet); 191 192 DISPID dispid; 193 LPOLESTR method= L"methodByte"; 194 hr = oletest.p->GetIDsOfNames(IID_NULL, &method, 1, LOCALE_USER_DEFAULT, &dispid); 195 196 197 CComVariant arg[1]; 198 arg[0].vt= VT_ARRAY | VT_I1; 199 arg[0].parray= (SAFEARRAY*)arByte; 200 DISPPARAMS params={ arg,0,1,0}; 201 202 hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, 203 DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); 204 205 hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, 206 DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); 207 208 // different case 209 LPOLESTR method2= L"MEthodByte"; 210 hr = oletest.p->GetIDsOfNames(IID_NULL, &method2, 1, LOCALE_USER_DEFAULT, &dispid); 211 212 hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, 213 DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); 214 215 hr = oletest.p->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, 216 DISPATCH_METHOD | DISPATCH_PROPERTYPUT, ¶ms, &varRet, NULL, NULL); 217 218 LPOLESTR attrib= L"AttrByte"; 219 hr = oletest.p->GetIDsOfNames(IID_NULL, &attrib, 1, LOCALE_USER_DEFAULT, &dispid); 220 221 hr = oletest.p->Invoke( dispid, IID_NULL, LOCALE_USER_DEFAULT, 222 DISPATCH_METHOD | DISPATCH_PROPERTYPUTREF, ¶ms, &varRet, NULL, NULL); 223 224 hr = oletest.p->Invoke( dispid, IID_NULL, LOCALE_USER_DEFAULT, 225 DISPATCH_METHOD | DISPATCH_PROPERTYGET, ¶ms, &varRet, NULL, NULL); 226 227 228 229 CComVariant varByteArray; 230 varByteArray.vt= VT_ARRAY | VT_I1; 231 varByteArray.parray= (SAFEARRAY*)arByte; 232 CComVariant varShortArray; 233 varShortArray.vt= VT_ARRAY | VT_I2; 234 varShortArray.parray= (SAFEARRAY*)arShort; 235 CComVariant varLongArray; 236 varLongArray.vt= VT_ARRAY | VT_I4; 237 varLongArray.parray= (SAFEARRAY*)arLong; 238 CComVariant varDoubleArray; 239 varDoubleArray.vt= VT_ARRAY | VT_R8; 240 varDoubleArray.parray= (SAFEARRAY*)arDouble; 241 CComVariant varStringArray; 242 varStringArray.vt= VT_ARRAY | VT_BSTR; 243 varStringArray.parray= (SAFEARRAY*)arString; 244 CComVariant varArray; 245 varArray.vt= VT_ARRAY | VT_VARIANT; 246 varArray.parray= (SAFEARRAY*)arVariant; 247 248 FONTDESC fd={ sizeof( fd), L"ARIAL", 10, FW_NORMAL, 0, 0, 0, 0}; 249 250 251 CComPtr< IUnknown > unk1; 252 CComPtr< IUnknown > unk2; 253 CComPtr< IUnknown > unk3; 254 255 IUnknown* _unknown[3]; 256 hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk1.p); 257 hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk2.p); 258 hr= OleCreateFontIndirect( &fd, __uuidof( IUnknown), (void**)&unk3.p); 259 _unknown[0]= unk1; 260 _unknown[1]= unk2; 261 _unknown[2]= unk3; 262 SmartArray<IUnknown*> arUnknown( _unknown, 3, VT_UNKNOWN); 263 264 CComVariant varUnkArray; 265 varUnkArray.vt= VT_ARRAY | VT_UNKNOWN; 266 varUnkArray.parray= (SAFEARRAY*)arUnknown; 267 268 // preparing out parameter; 269 char byteOut; 270 CComVariant varOutByte; //### 271 varOutByte.vt= VT_BYREF | VT_UI1; 272 V_I1REF(&varOutByte)= &byteOut; 273 short shortOut; 274 CComVariant varOutShort; //### 275 varOutShort.vt= VT_BYREF | VT_I2; 276 V_I2REF( &varOutShort)= &shortOut; 277 long longOut; 278 CComVariant varOutLong; //### 279 varOutLong.vt= VT_BYREF | VT_I4; 280 V_I4REF( &varOutLong)= &longOut; 281 double doubleOut; 282 CComVariant varOutDouble; //### 283 varOutDouble.vt= VT_BYREF | VT_R8; 284 V_R8REF( &varOutDouble)= &doubleOut; 285 BSTR bstrOut= NULL; 286 CComVariant varOutString; //### 287 varOutString.vt= VT_BYREF | VT_BSTR; 288 V_BSTRREF(&varOutString)= &bstrOut; 289 CComVariant variantOut; 290 CComVariant varOutAny; //### 291 varOutAny.vt= VT_BYREF | VT_VARIANT; 292 V_VARIANTREF(&varOutAny)= &variantOut; 293 294 CComPtr<IDispatch> dispOut; 295 CComVariant varOutXInterface; //### 296 varOutXInterface.vt= VT_BYREF |VT_DISPATCH; 297 V_DISPATCHREF(&varOutXInterface)= &dispOut.p; 298 299 // In Parameter ( all of type Sequence ########################################################### 300 OutputDebugString( _T("In parameter of type Sequence ###########################################\n" 301 "The functions return the Sequence parameter \n\n")); 302 303 OutputDebugStringA("methodByte | Params: \n"); 304 printVariant( varByteArray); 305 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodByte"), &varByteArray, &varRet); 306 OutputDebugStringA("methodByte | return value \n"); 307 printVariant( varRet); 308 309 OutputDebugStringA("methodShort | Params: \n"); 310 printVariant( varShortArray); 311 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodShort"), &varShortArray, &varRet); 312 OutputDebugStringA("methodShort | return value \n"); 313 printVariant( varRet); 314 315 OutputDebugStringA("methodLong | Params: \n"); 316 printVariant( varLongArray); 317 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodLong"), &varLongArray, &varRet); 318 OutputDebugStringA("methodLong | return value \n"); 319 printVariant( varRet); 320 321 OutputDebugStringA("methodDouble | Params: \n"); 322 printVariant( varDoubleArray); 323 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodDouble"), &varDoubleArray, &varRet); 324 OutputDebugStringA("methodDouble | return value \n"); 325 printVariant( varRet); 326 327 OutputDebugStringA("methodString | Params: \n"); 328 printVariant( varStringArray); 329 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodString"), &varStringArray, &varRet); 330 OutputDebugStringA("methodString | return value \n"); 331 printVariant( varRet); 332 333 OutputDebugStringA("methodAny | Params: \n"); 334 printVariant( varArray); 335 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodAny"), &varArray, &varRet); 336 OutputDebugStringA("methodAny | return value \n"); 337 printVariant( varRet); 338 339 OutputDebugStringA("methodXInterface | Params: \n"); 340 printVariant( varUnkArray); 341 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"methodXInterface"), &varUnkArray, &varRet); 342 OutputDebugStringA("methodAny | return value \n"); 343 printVariant( varRet); 344 345 // Out Parameter ########################################################################### 346 OutputDebugString( _T("Out parameter ###########################################\n\n")); 347 348 OutputDebugString(_T("testout_methodByte \n")); 349 hr= oletest.InvokeN(static_cast<LPCOLESTR>(L"testout_methodByte"), &varOutByte, 1, &varRet); 350 OutputDebugString(_T("testout_methodByte | out value: \n")); 351 printVariant( varOutByte); 352 353 OutputDebugString(_T("testout_methodShort \n")); 354 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodShort"), &varOutShort, &varRet); 355 OutputDebugString(_T("testout_methodShort | out value: \n")); 356 printVariant( varOutShort); 357 358 OutputDebugString(_T("testout_methodLong \n")); 359 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodLong"), &varOutLong, &varRet); 360 OutputDebugString(_T("testout_methodLong | out value: \n")); 361 printVariant( varOutLong); 362 363 OutputDebugString(_T("testout_methodDouble \n")); 364 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodDouble"), &varOutDouble, &varRet); 365 OutputDebugString(_T("testout_methodDouble | out value: \n")); 366 printVariant( varOutDouble); 367 368 OutputDebugString(_T("testout_methodString \n")); 369 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodString"), &varOutString, &varRet); 370 OutputDebugString(_T("testout_methodString | out value: \n")); 371 printVariant( varOutString); 372 373 OutputDebugString(_T("testout_methodAny \n")); 374 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodAny"), &varOutAny, &varRet); 375 OutputDebugString(_T("methodAny | out value: \n")); 376 printVariant( varOutAny); 377 378 OutputDebugString(_T("testout_methodXInterface \n")); 379 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testout_methodXInterface"), &varOutXInterface, &varRet); 380 OutputDebugString(_T("methodAny | out value: \n")); 381 printVariant( varOutXInterface); 382 CComDispatchDriver outDisp( *varOutXInterface.ppdispVal); 383 CComVariant varAttr3; 384 outDisp.GetPropertyByName(L"AttrAny2", &varAttr3); 385 ATLTRACE("property OleTest.AttrAny2: %s", W2T(varAttr3.bstrVal)); 386 387 OutputDebugString(_T("testout_methodMulParams1 ( 2 out Parameter) \n")); 388 long longOut2=0; 389 CComVariant _params[2]; 390 longOut=0; 391 _params[0]= varOutLong; 392 _params[1].vt= VT_BYREF | VT_I4; 393 V_I4REF(& _params[1])= &longOut2; 394 hr= oletest.InvokeN( static_cast<LPCOLESTR>(L"testout_methodMulParams1"), (VARIANT*)&_params, 2); 395 OutputDebugString(_T("testout_methodMulParams1 | out values: \n")); 396 printVariant( _params[1]); 397 printVariant( _params[0]); 398 399 OutputDebugString(_T("testout_methodMulParams2 ( 3 out Parameter) \n")); 400 CComVariant _params2[3]; 401 _params2[2]= varOutLong; 402 _params2[1].vt= VT_BYREF | VT_I4; 403 V_I4REF(& _params2[1])= &longOut2; 404 _params2[0]= varOutString; 405 hr= oletest.InvokeN( static_cast<LPCOLESTR>( L"testout_methodMulParams2"), (VARIANT*)&_params2, 3); 406 OutputDebugString(_T("testout_methodMulParams2 | out values: \n")); 407 printVariant( _params2[2]); 408 printVariant( _params2[1]); 409 printVariant( _params2[0]); 410 411 OutputDebugString(_T("testout_methodMulParams3 ( 1 in and 1 out Parameter) \n")); 412 CComVariant _params3[2]; 413 _params3[1]= CComBSTR(L" In string"); 414 _params3[0]= varOutString; 415 hr= oletest.InvokeN( static_cast<LPCOLESTR>( L"testout_methodMulParams3"), (VARIANT*)&_params3, 2); 416 OutputDebugString(_T("testout_methodMulParams3 | out values: \n")); 417 printVariant( _params3[1]); 418 printVariant( _params3[0]); 419 420 //In Out Parameter ########################################################################### 421 OutputDebugString( _T("In Out parameter ###########################################\n\n")); 422 423 *V_I1REF(&varOutByte)= 5; 424 ATLTRACE(_T("testinout_methodByte | in value: %d \n"), *V_I1REF(&varOutByte)); 425 hr= oletest.InvokeN(static_cast<LPCOLESTR>(L"testinout_methodByte"), &varOutByte, 1, &varRet); 426 OutputDebugString(_T("testinout_methodByte | out value: \n")); 427 printVariant( varOutByte); 428 429 OutputDebugString(_T("testinout_methodShort | in value= 1000 \n")); 430 *V_UI2REF(&varOutShort)= 1000; 431 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodShort"), &varOutShort, &varRet); 432 OutputDebugString(_T("testinout_methodShort | out value: \n")); 433 printVariant( varOutShort); 434 435 OutputDebugString(_T("testinout_methodLong | in value= 10000 \n")); 436 *V_UI4REF(&varOutLong)= 10000; 437 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodLong"), &varOutLong, &varRet); 438 OutputDebugString(_T("testinout_methodLong | out value: \n")); 439 printVariant( varOutLong); 440 441 *V_R8REF(&varOutDouble)= 3.14; 442 ATLTRACE(_T("testinou_methodDouble in value: %f \n"),*V_R8REF(&varOutDouble)); 443 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodDouble"), &varOutDouble, &varRet); 444 OutputDebugString(_T("testinout_methodDouble | out value: \n")); 445 printVariant( varOutDouble); 446 447 SysFreeString( *V_BSTRREF(&varOutString)); 448 *V_BSTRREF(&varOutString)= SysAllocString( L"this is a in string"); 449 ATLTRACE(_T("testinout_methodString | value: %s \n"), W2T(*V_BSTRREF(&varOutString))); 450 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodString"), &varOutString, &varRet); 451 OutputDebugString(_T("testinout_methodString | out value: \n")); 452 printVariant( varOutString); 453 454 CComVariant var1(CComBSTR(L" this is a string in a VARIANT")); 455 CComVariant outVar1; 456 outVar1.vt= VT_BYREF | VT_VARIANT; 457 outVar1.pvarVal= &var1; 458 ATLTRACE(_T("testinout_methodAny | parameter: %s\n"), W2T(var1.bstrVal)); 459 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodAny"), &varOutAny, &varRet); 460 OutputDebugString(_T("testinout_methodAny | out value: \n")); 461 printVariant( varOutAny); 462 463 CComPtr< IUnknown > objectIn = unk1; 464 CComVariant varOutIFace; 465 varOutIFace.vt= VT_BYREF | VT_UNKNOWN; 466 varOutIFace.ppunkVal= &objectIn.p; 467 (*varOutIFace.ppunkVal)->AddRef(); 468 OutputDebugString(_T("testinout_methodXInterface | in value: \n")); 469 printVariant(varOutIFace); 470 hr= oletest.Invoke1(static_cast<LPCOLESTR>(L"testinout_methodXInterface"), &varOutIFace, &varRet); 471 OutputDebugString(_T("testinout_methodXInterface | out value: \n")); 472 printVariant( varOutIFace); 473 474 // Properties ###################################################################### 475 OutputDebugString( _T(" Properties ###########################################\n\n")); 476 477 OutputDebugString(_T("set property \"AttrByte\" | value")); 478 //CComVariant propArByte; 479 //propArByte.vt= VT_ARRAY | VT_I1; 480 varParam1.parray= (SAFEARRAY*)arByte; 481 printVariant( varParam1); 482 hr= oletest.PutPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varParam1); 483 OutputDebugString(_T("get property \"AttrByte\" | value:")); 484 varRet.Clear(); 485 hr= oletest.GetPropertyByName( static_cast<LPCOLESTR>(L"AttrByte"), &varRet); 486 printVariant( varRet); 487 488 489 return S_OK; 490 491 492 } 493 494 495 void printVariant( VARIANT & _var) 496 { 497 HRESULT hr; 498 USES_CONVERSION; 499 CComVariant var; 500 hr= VariantCopyInd( &var, &_var); 501 if( var.vt & VT_ARRAY) 502 { 503 VARTYPE type= var.vt ^ VT_ARRAY; 504 SAFEARRAY * sarray= var.parray; 505 long lbound; 506 long ubound; 507 hr= SafeArrayGetLBound( sarray, 1, &lbound); 508 hr= SafeArrayGetUBound( sarray, 1, &ubound); 509 long count= ubound - lbound + 1; 510 char charValue; 511 BYTE byteValue; 512 short shortValue; 513 long longValue; 514 double doubleValue; 515 IUnknown* unkValue; 516 BSTR bstrValue; 517 OutputDebugString( _T("# Array \n")); 518 for( long i= 0; i < count; i++) 519 { 520 // CComVariant variantValue; 521 TCHAR *buf[256]; 522 wsprintf( (TCHAR*)buf, _T("%d : "), i); 523 OutputDebugString( (TCHAR*)buf); 524 VARIANT varTemp; 525 VariantInit( &varTemp); 526 VARIANT variantValue; 527 VariantInit( &variantValue); 528 switch( type) 529 { 530 case VT_UI1: 531 hr= SafeArrayGetElement( sarray, &i, &byteValue); 532 varTemp.vt= VT_UI1; 533 V_UI1( &varTemp)= byteValue; 534 printVariant( varTemp); 535 break; 536 case VT_I1: 537 hr= SafeArrayGetElement( sarray, &i, &charValue); 538 varTemp.vt= VT_I1; 539 V_I1( &varTemp)= charValue; 540 printVariant( varTemp); 541 break; 542 case VT_I2: 543 hr= SafeArrayGetElement( sarray, &i, &shortValue); 544 varTemp.vt= VT_I2; 545 V_I2( &varTemp)= shortValue; 546 printVariant( varTemp); 547 break; 548 549 case VT_UI2: 550 case VT_I4: 551 hr= SafeArrayGetElement( sarray, &i, &longValue); 552 varTemp.vt= VT_I4; 553 V_I4( &varTemp)= longValue; 554 printVariant( varTemp); 555 break; 556 case VT_R8: 557 hr= SafeArrayGetElement( sarray, &i, &doubleValue); 558 varTemp.vt= VT_R8; 559 V_R8( &varTemp)= doubleValue; 560 printVariant( varTemp); 561 break; 562 case VT_BSTR: 563 hr= SafeArrayGetElement( sarray, &i, &bstrValue); 564 varTemp.vt= VT_BSTR; 565 varTemp.bstrVal= bstrValue; 566 printVariant( varTemp); 567 break; 568 case VT_VARIANT: 569 hr= SafeArrayGetElement( sarray, &i, &varTemp); 570 printVariant( varTemp); 571 break; 572 573 case VT_UNKNOWN: 574 hr= SafeArrayGetElement( sarray, &i, &unkValue); 575 varTemp.vt= VT_UNKNOWN; 576 varTemp.punkVal= unkValue; 577 printVariant( varTemp); 578 break; 579 } 580 581 VariantClear( &varTemp); 582 VariantClear( &variantValue); 583 } 584 585 } 586 else 587 { 588 TCHAR buf[256]; 589 switch (var.vt) 590 { 591 case VT_I1: wsprintf( (TCHAR*)buf, _T(" VT_I1: %d \n"), V_I1( &var) ); 592 break; 593 case VT_UI1: wsprintf( (TCHAR*)buf, _T(" VT_UI1: %d \n"), V_I1( &var) ); 594 break; 595 596 case VT_I2: wsprintf( (TCHAR*)buf, _T(" VT_I2: %d \n"), V_I2( &var) ); 597 break; 598 case VT_I4: wsprintf( (TCHAR*)buf, _T(" VT_I4: %d \n"), V_I4( &var) ); 599 break; 600 case VT_R8: 601 { 602 603 // int decimal, sign; 604 // char *buffer; 605 // int precision = 14; 606 // double source = 3.1415926535; 607 608 // buffer = _ecvt( V_R8(&var), precision, &decimal, &sign ); 609 sprintf( (TCHAR*)buf, _T(" VT_R8: %f \n"),V_R8( &var) ); 610 break; 611 } 612 case VT_UNKNOWN: 613 // The object implement IFont 614 { 615 CComDispatchDriver disp( var.punkVal); 616 CComVariant ret; 617 hr= disp.GetPropertyByName( static_cast<LPCOLESTR>(L"Name"), &ret); 618 wsprintf( (TCHAR*)buf, _T(" VT_UNKNOWN: property \"Name\": %s \n"), W2T(ret.bstrVal)); 619 break; 620 } 621 case VT_DISPATCH: 622 // The object implement IFont 623 { 624 CComDispatchDriver disp( var.punkVal); 625 CComVariant ret; 626 if( SUCCEEDED( hr= disp.GetPropertyByName( static_cast<LPCOLESTR>(L"Name"), &ret))) 627 wsprintf( (TCHAR*)buf, _T(" VT_DISPATCH: property \"Name\": %s \n"), W2T(ret.bstrVal)); 628 else 629 wsprintf( (TCHAR*)buf, _T(" VT_DISPATCH \n")); 630 631 break; 632 } 633 634 635 case VT_BSTR: 636 { 637 TCHAR* str= W2T( var.bstrVal); 638 wsprintf( (TCHAR*)buf, _T(" VT_BSTR: %s \n"), str); 639 } 640 break; 641 default: 642 wsprintf( (TCHAR*)buf, _T("\n")); 643 644 } 645 646 OutputDebugString( (TCHAR*) buf); 647 } 648 649 return; 650 651 } 652 653