extensions/test/ole/OleConverterVar1/convTest.cxx

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