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 #include<atlcom.h> 37 #include <stdio.h> 38 #include <com/sun/star/bridge/ModelDependent.hpp> 39 #include <com/sun/star/bridge/XBridgeSupplier2.hpp> 40 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 41 #include <com/sun/star/script/XInvocation.hpp> 42 #include <oletest/XCallback.hpp> 43 #include <rtl/process.h> 44 #include <com/sun/star/uno/Reference.h> 45 #include <cppuhelper/servicefactory.hxx> 46 #include <rtl/string.h> 47 48 49 50 using namespace com::sun::star::lang; 51 using namespace com::sun::star::uno; 52 using namespace com::sun::star::script; 53 using namespace com::sun::star::bridge; 54 using namespace com::sun::star::bridge::ModelDependent; 55 using namespace cppu; 56 using namespace rtl; 57 HRESULT doTest(); 58 bool incrementMultidimensionalIndex( 59 sal_Int32 dimensions, 60 const sal_Int32 * parDimensionLengths, 61 sal_Int32 * parMultidimensionalIndex); 62 63 int __cdecl _tmain( int /*argc*/, _TCHAR * /*argv[]*/ ) 64 { 65 HRESULT hr; 66 if( FAILED( hr=CoInitialize(NULL))) 67 { 68 _tprintf(_T("CoInitialize failed \n")); 69 return -1; 70 } 71 72 73 if( FAILED(hr=doTest())) 74 { 75 _com_error err( hr); 76 const TCHAR * errMsg= err.ErrorMessage(); 77 MessageBox( NULL, errMsg, "Test failed", MB_ICONERROR); 78 } 79 80 CoUninitialize(); 81 return 0; 82 } 83 84 85 86 87 HRESULT doTest() 88 { 89 HRESULT hr= S_OK; 90 long j = 0; 91 SAFEARRAY* par; 92 CComDispatchDriver disp; 93 CComVariant result; 94 CComVariant param1; 95 CComPtr<IUnknown> spUnkFactory; 96 if( SUCCEEDED( spUnkFactory.CoCreateInstance(L"com.sun.star.ServiceManager"))) 97 { 98 disp= spUnkFactory; 99 param1= L"oletest.OleTest"; 100 disp.Invoke1( L"createInstance", ¶m1, &result); 101 102 disp= result.pdispVal; 103 104 // disp contains now oletest.OleTest 105 106 // one dimensional array 107 par= SafeArrayCreateVector( VT_UI1, 0, 5); 108 unsigned char arbyte[]= { 1,2,3,4,5}; 109 for(long i= 0; i < 5;i++) 110 hr= SafeArrayPutElement( par, &i, &arbyte[i]); 111 112 result.Clear(); 113 param1.vt= VT_ARRAY| VT_UI1; 114 param1.byref= par; 115 disp.Invoke1(L"methodByte", ¶m1, &result); 116 SafeArrayDestroy( par); 117 118 119 // two dimensional array 120 SAFEARRAYBOUND bounds[2]; 121 // least significant dimension first, Dimension 1 122 bounds[0].cElements= 3; 123 bounds[0].lLbound= 0; 124 // Dimension 2 125 bounds[1].cElements= 2; 126 bounds[1].lLbound= 0; 127 par= SafeArrayCreate( VT_I4, 2, bounds ); 128 129 long uBound1; 130 long uBound2; 131 hr= SafeArrayGetUBound( par, 1, &uBound1); 132 hr= SafeArrayGetUBound( par, 2, &uBound2); 133 134 long index2[2]; 135 memset( index2, 0, 2 * sizeof( long) ); 136 long dimLengths[]={3,2}; 137 138 long data; 139 do 140 { 141 data= index2[1] * 3 + index2[0] +1; 142 hr= SafeArrayPutElement( par, index2, &data); 143 }while( incrementMultidimensionalIndex( 2, dimLengths, index2) ); 144 145 long* pdata; 146 long (*dataL)[2][3]; 147 hr= SafeArrayAccessData( par, (void**)&pdata); 148 dataL= (long(*)[2][3])pdata; 149 150 for (long i= 0; i < 2; i ++) 151 { 152 for(long j= 0; j < 3; j++) 153 data= (*dataL)[i][j]; 154 } 155 hr= SafeArrayUnaccessData(par); 156 157 result.Clear(); 158 param1.vt= VT_ARRAY | VT_I4; 159 param1.byref= par; 160 disp.Invoke1(L"methodSequence", ¶m1, &result); 161 162 SAFEARRAY* arRet= result.parray; 163 164 for(long i= 0; i < 2 ; i++) 165 { 166 CComVariant varx; 167 varx.Clear(); 168 hr= SafeArrayGetElement( arRet, &i, &varx); 169 SAFEARRAY* ari= varx.parray; 170 171 for( j= 0; j < 3; j++) 172 { 173 CComVariant varj; 174 varj.Clear(); 175 hr= SafeArrayGetElement( ari, &j, &varj); 176 } 177 178 179 180 } 181 SafeArrayDestroy( par); 182 } 183 184 return hr; 185 } 186 187 // left index is least significant 188 bool incrementMultidimensionalIndex( 189 sal_Int32 dimensions, 190 const sal_Int32 * parDimensionLengths, 191 sal_Int32 * parMultidimensionalIndex) 192 { 193 if( dimensions < 1) 194 return sal_False; 195 196 bool ret= sal_True; 197 bool carry= sal_True; // to get into the while loop 198 199 sal_Int32 currentDimension= 0; //most significant is 1 200 while( carry) 201 { 202 parMultidimensionalIndex[ currentDimension ]++; 203 // if carryover, set index to 0 and handle carry on a level above 204 if( parMultidimensionalIndex[ currentDimension] > (parDimensionLengths[ currentDimension] - 1)) 205 parMultidimensionalIndex[ currentDimension]= 0; 206 else 207 carry= sal_False; 208 209 currentDimension ++; 210 // if dimensions drops below 1 and carry is set than then all indices are 0 again 211 // this is signalled by returning sal_False 212 if( currentDimension > dimensions - 1 && carry) 213 { 214 carry= sal_False; 215 ret= sal_False; 216 } 217 } 218 return ret; 219 } 220