extensions/test/ole/cppToUno/testcppuno.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #pragma warning(disable: 4917)
  22 #if !defined WIN32_LEAN_AND_MEAN
  23 # define WIN32_LEAN_AND_MEAN
  24 #endif
  25 #include <windows.h>
  26 #include <comdef.h>
  27 #include <atlbase.h>
  28 #include <atlcom.h>
  29 #include <stdio.h>
  30 #include <com/sun/star/bridge/ModelDependent.hpp>
  31 #include <com/sun/star/bridge/XBridgeSupplier2.hpp>
  32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  33 #include <oletest/XCallback.hpp>
  34 #include <rtl/process.h>
  35 #include <cppuhelper/servicefactory.hxx>
  36 #include <rtl/string.h>
  37
  38
  39 using namespace com::sun::star::lang;
  40 using namespace com::sun::star::uno;
  41 using namespace com::sun::star::bridge;
  42 using namespace com::sun::star::bridge::ModelDependent;
  43 using namespace cppu;
  44
  45 HRESULT doTest();
  46 bool incrementMultidimensionalIndex(
  47     sal_Int32 dimensions,
  48     const sal_Int32 * parDimensionLengths,
  49     sal_Int32 * parMultidimensionalIndex);
  50
  51 int SAL_CALL main( int /*argc*/, char** /*argv*/ )
  52 {
  53     HRESULT hr;
  54     if( FAILED( hr=CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
  55     {
  56         printf("CoInitializeEx failed \n");
  57         return -1;
  58     }
  59
  60
  61     if( FAILED(hr=doTest()))
  62     {
  63         _com_error err( hr);
  64         const CHAR * errMsg= err.ErrorMessage();
  65         MessageBoxA( NULL, errMsg, "Test failed", MB_ICONERROR);
  66     }
  67
  68     CoUninitialize();
  69     return 0;
  70 }
  71
  72
  73 HRESULT doTest()
  74 {
  75     HRESULT hr= S_OK;
  76     long j = 0;
  77     SAFEARRAY* par;
  78     CComDispatchDriver disp;
  79     CComVariant result;
  80     CComVariant param1;
  81     CComPtr<IUnknown> spUnkFactory;
  82     if( SUCCEEDED( spUnkFactory.CoCreateInstance(L"com.sun.star.ServiceManager")))
  83     {
  84         disp= spUnkFactory;
  85         param1= L"oletest.OleTest";
  86         disp.Invoke1( L"createInstance", &param1, &result);
  87
  88         disp= result.pdispVal;
  89
  90         // disp contains now oletest.OleTest
  91
  92         // one dimensional array
  93         par= SafeArrayCreateVector( VT_UI1, 0, 5);
  94         unsigned char arbyte[]= { 1,2,3,4,5};
  95         for(long i= 0; i < 5;i++)
  96             hr= SafeArrayPutElement( par, &i, &arbyte[i]);
  97
  98         result.Clear();
  99         param1.vt= VT_ARRAY| VT_UI1;
 100         param1.byref= par;
 101         disp.Invoke1(L"methodByte", &param1, &result);
 102         SafeArrayDestroy( par);
 103
 104
 105         // two dimensional array
 106         SAFEARRAYBOUND bounds[2];
 107         // least significant dimension first, Dimension 1
 108         bounds[0].cElements= 3;
 109         bounds[0].lLbound= 0;
 110         // Dimension 2
 111         bounds[1].cElements= 2;
 112         bounds[1].lLbound= 0;
 113         par= SafeArrayCreate( VT_I4, 2, bounds );
 114
 115         long uBound1;
 116         long uBound2;
 117         hr= SafeArrayGetUBound( par, 1, &uBound1);
 118         hr= SafeArrayGetUBound( par, 2, &uBound2);
 119
 120         long index2[2];
 121         memset( index2, 0, 2 * sizeof( long) );
 122         long dimLengths[]={3,2};
 123
 124         long data;
 125         do
 126         {
 127             data= index2[1] * 3 + index2[0] +1;
 128             hr= SafeArrayPutElement( par, index2, &data);
 129         }while( incrementMultidimensionalIndex( 2, dimLengths, index2) );
 130
 131         long* pdata;
 132         long (*dataL)[2][3];
 133         hr= SafeArrayAccessData( par, (void**)&pdata);
 134         dataL= (long(*)[2][3])pdata;
 135
 136         for (long i= 0; i < 2; i ++)
 137         {
 138             for(long j= 0; j < 3; j++)
 139                 data= (*dataL)[i][j];
 140         }
 141         hr= SafeArrayUnaccessData(par);
 142
 143         result.Clear();
 144         param1.vt= VT_ARRAY | VT_I4;
 145         param1.byref= par;
 146         disp.Invoke1(L"methodSequence", &param1, &result);
 147
 148         SAFEARRAY* arRet= result.parray;
 149
 150         for(long i= 0; i < 2 ; i++)
 151         {
 152             CComVariant varx;
 153             varx.Clear();
 154             hr= SafeArrayGetElement( arRet, &i, &varx);
 155             SAFEARRAY* ari= varx.parray;
 156
 157             for( j= 0; j < 3; j++)
 158             {
 159                 CComVariant varj;
 160                 varj.Clear();
 161                 hr= SafeArrayGetElement( ari, &j, &varj);
 162             }
 163
 164
 165         }
 166         SafeArrayDestroy( par);
 167     }
 168
 169     return hr;
 170 }
 171
 172 // left index is least significant
 173 bool incrementMultidimensionalIndex(
 174     sal_Int32 dimensions,
 175     const sal_Int32 * parDimensionLengths,
 176     sal_Int32 * parMultidimensionalIndex)
 177 {
 178     if( dimensions < 1)
 179         return sal_False;
 180
 181     bool ret= sal_True;
 182     bool carry= sal_True; // to get into the while loop
 183
 184     sal_Int32 currentDimension= 0; //most significant is 1
 185     while( carry)
 186     {
 187         parMultidimensionalIndex[ currentDimension ]++;
 188         // if carryover, set index to 0 and handle carry on a level above
 189         if( parMultidimensionalIndex[ currentDimension] > (parDimensionLengths[ currentDimension] - 1))
 190             parMultidimensionalIndex[ currentDimension]= 0;
 191         else
 192             carry= sal_False;
 193
 194         currentDimension ++;
 195         // if dimensions drops below 1 and carry is set than then all indices are 0 again
 196         // this is signalled by returning sal_False
 197         if( currentDimension > dimensions - 1 && carry)
 198         {
 199             carry= sal_False;
 200             ret= sal_False;
 201         }
 202     }
 203     return ret;
 204 }
 205
 206 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */