extensions/test/ole/OleClient/funcs.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 #include <atlbase.h>
  32 #include <stdio.h>
  33 #include "cppuhelper/bootstrap.hxx"
  34 #include "rtl/process.h"
  35 #include "typelib/typedescription.hxx"
  36
  37 #include "com/sun/star/bridge/ModelDependent.hpp"
  38 #include "com/sun/star/bridge/XBridgeSupplier2.hpp"
  39 #include "com/sun/star/uno/TypeClass.hpp"
  40 #include "com/sun/star/script/XInvocation.hpp"
  41 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  42 #include "com/sun/star/uno/XComponentContext.hpp"
  43 #include <com/sun/star/bridge/oleautomation/NamedArgument.hpp>
  44 #include "rtl/ustring.hxx"
  45
  46 using namespace com::sun::star::bridge;
  47 using namespace com::sun::star::bridge::ModelDependent;
  48 using namespace com::sun::star::uno;
  49 using namespace com::sun::star::lang;
  50 using namespace com::sun::star::script;
  51 using namespace com::sun::star::bridge::oleautomation;
  52 using namespace rtl;
  53 using namespace cppu;
  54
  55 template< class T >
  56 bool equalSequences(const Sequence<T>& seqIn, const Sequence<Any> & returned);
  57
  58
  59 Reference< XMultiServiceFactory > objectFactory;//
  60
  61
  62 Reference<XMultiServiceFactory> getMultiServiceFactory()
  63 {
  64     static Reference< XMultiServiceFactory > factory;
  65     if( ! objectFactory.is() )
  66     {
  67         Reference<XComponentContext> context = defaultBootstrap_InitialComponentContext();
  68         factory = Reference<XMultiServiceFactory>( context->getServiceManager(), UNO_QUERY);
  69
  70     }
  71     return factory;
  72 }
  73
  74 Reference<XInvocation> getComObject( OUString progId)
  75 {
  76     HRESULT hr= S_OK;
  77     Reference< XInvocation > ret;
  78 //  Reference<XMultiServiceFactory> fac;
  79     if(  ! objectFactory.is())
  80     {   Reference<XMultiServiceFactory> mgr= getMultiServiceFactory();
  81         Reference<XInterface> xInt= mgr->createInstance(
  82             OUString(L"com.sun.star.bridge.oleautomation.Factory"));
  83         objectFactory= Reference<XMultiServiceFactory>::query(  xInt);
  84     }
  85
  86     if( objectFactory.is())
  87     {
  88         Reference<XInterface> xIntAx= objectFactory->createInstance( progId.getStr());
  89         if( xIntAx.is() )
  90         {
  91             Reference< XInvocation > xInv( xIntAx, UNO_QUERY);
  92             ret= xInv;
  93         }
  94     }
  95     return ret;
  96 }
  97
  98 Reference<XInvocation> convertComObject( IUnknown* pUnk)
  99 {
 100     Reference< XMultiServiceFactory > mgr= getMultiServiceFactory();
 101     Reference< XInterface > xIntSupplier= mgr->createInstance(OUString(L"com.sun.star.bridge.OleBridgeSupplier2"));
 102     Reference< XBridgeSupplier2 > xSuppl( xIntSupplier, UNO_QUERY);
 103
 104     Any any;
 105     CComVariant var( pUnk);
 106     any <<= ( sal_uInt32)&var;
 107     sal_uInt8 arId[16];
 108     rtl_getGlobalProcessId( arId);
 109     Any target= xSuppl->createBridge( any, Sequence<sal_Int8>( (sal_Int8*)arId, 16), OLE, UNO );
 110
 111     Reference<XInvocation> ret;
 112     target>>= ret;
 113     return ret;
 114 }
 115
 116 /*
 117   Parameter values contains the expected return values. The value at index 0
 118   correspond to parameter 0 (left - most). For parameters which are not out or
 119   in/out the value must be a void any.
 120
 121   The number of items in value must be the
 122   same as the number of provided parameter during the  call on the  method.
 123
 124   The parameter outArgs, indices correspond to the sequences which are
 125   arguments to XInvocation::invoke
 126  */
 127 bool checkOutArgs(const Sequence<Any> & outArgs,
 128                   const Sequence<sal_Int16> & indices, const Sequence<Any> & values)
 129 {
 130     if (values.getLength() != outArgs.getLength())
 131         return false;
 132     //iterate over all parameters. i represents the parameter index
 133     for (int i = 0; i < values.getLength(); i++)
 134     {
 135         if (values[i].getValueType() == getVoidCppuType())
 136             continue;
 137         //out parameter
 138         //Based on the parameter index find the correspondent out value
 139         int indexOutSeq = -1;
 140         for (int iIndices = indices.getLength() - 1; iIndices >= 0; iIndices --)
 141         {
 142             if (indices[iIndices] == i)
 143             {
 144                 indexOutSeq = iIndices;
 145                 break;
 146             }
 147         }
 148         if (indexOutSeq == -1)
 149             return false;
 150
 151         Any value;
 152         Any out;
 153         values[i] >>= value;
 154         outArgs[indexOutSeq] >>=out;
 155         NamedArgument naVal;
 156         NamedArgument naOut;
 157         value >>= naVal;
 158         out >>= naOut;
 159         if (values[i].getValueType() == getCppuType((NamedArgument *) 0))
 160         {
 161             NamedArgument inNamed;
 162             values[i] >>= inNamed;
 163             value <<= inNamed.Value;
 164         }
 165         if (value != outArgs[indexOutSeq])
 166             return false;
 167     }
 168     return true;
 169 }
 170
 171 /* The returned sequence always contains Any elements
 172 */
 173 bool equalSequences(const Any& orig, const Any& returned)
 174 {
 175     if (orig.getValueTypeClass() != TypeClass_SEQUENCE)
 176     {
 177         OSL_ASSERT(0);
 178         return false;
 179     }
 180     TypeDescription td(orig.getValueTypeRef());
 181     typelib_IndirectTypeDescription * indirect_td = (typelib_IndirectTypeDescription *) td.get();
 182
 183     switch (indirect_td->pType->eTypeClass)
 184     {
 185         case TypeClass_CHAR:
 186             {
 187                 Sequence<sal_Unicode> seq;
 188                 orig >>= seq;
 189                 Sequence<Any> seq2;
 190                 returned >>= seq2;
 191                 return equalSequences(seq, seq2);
 192             }
 193         case TypeClass_BOOLEAN:
 194             {
 195                 Sequence<sal_Bool> seq;
 196                 orig >>= seq;
 197                 Sequence<Any> seq2;
 198                 returned >>= seq2;
 199                 return equalSequences(seq, seq2);
 200             }
 201         case TypeClass_BYTE:
 202             {
 203                 Sequence<sal_Int8> seq;
 204                 orig >>= seq;
 205                 Sequence<Any> seq2;
 206                 returned >>= seq2;
 207                 return equalSequences(seq, seq2);
 208             }
 209         case TypeClass_SHORT:
 210             {
 211                 Sequence<sal_Int16> seq;
 212                 orig >>= seq;
 213                 Sequence<Any> seq2;
 214                 returned >>= seq2;
 215                 return equalSequences(seq, seq2);
 216             }
 217         case TypeClass_LONG:
 218             {
 219                 Sequence<sal_Int32> seq;
 220                 orig >>= seq;
 221                 Sequence<Any> seq2;
 222                 returned >>= seq2;
 223                 return equalSequences(seq, seq2);
 224             }
 225         case TypeClass_FLOAT:
 226             {
 227                 Sequence<float> seq;
 228                 orig >>= seq;
 229                 Sequence<Any> seq2;
 230                 returned >>= seq2;
 231                 return equalSequences(seq, seq2);
 232             }
 233         case TypeClass_DOUBLE:
 234             {
 235                 Sequence<double> seq;
 236                 orig >>= seq;
 237                 Sequence<Any> seq2;
 238                 returned >>= seq2;
 239                 return equalSequences(seq, seq2);
 240             }
 241         case TypeClass_STRING:
 242             {
 243                 Sequence<OUString> seq;
 244                 orig >>= seq;
 245                 Sequence<Any> seq2;
 246                 returned >>= seq2;
 247                 return equalSequences(seq, seq2);
 248             }
 249         case TypeClass_ANY:
 250             {
 251                 Sequence<Any> seq;
 252                 orig >>= seq;
 253                 Sequence<Any> seq2;
 254                 returned >>= seq2;
 255                 return equalSequences(seq, seq2);
 256             }
 257         case TypeClass_SEQUENCE:
 258             {
 259                 //Sequence<sal_Unicode> seq;
 260                 //orig >>= seq;
 261                 //Sequence<Any> seq2;
 262                 //returned >>= seq2;
 263                 //return equalSequences(seq, seq2);
 264                 break;
 265             }
 266         case TypeClass_INTERFACE:
 267             {
 268                 Sequence<Reference<XInvocation> > seq;
 269                 orig >>= seq;
 270                 Sequence<Any> seq2;
 271                 returned >>= seq2;
 272                 return equalSequences(seq, seq2);
 273             }
 274         default:
 275             return false;
 276     }
 277     return false;
 278 }
 279
 280 template< class T >
 281 bool equalSequences(const Sequence<T>& seqIn, const Sequence<Any> & seqOut)
 282 {
 283     if (seqIn.getLength() != seqOut.getLength())
 284         return false;
 285     int len = seqIn.getLength();
 286     for (int i = 0; i < len; i++)
 287     {
 288         Any anyIn;
 289         anyIn <<= seqIn[i];
 290         Any anyOut = seqOut[i];
 291         if (anyIn != anyOut)
 292             return false;
 293     }
 294
 295     return true;
 296 }
 297
 298 void printSequence( Sequence<Any>& val)
 299 {
 300
 301 //  typelib_TypeDescription* desc;
 302 //  val.getValueTypeDescription( &desc);
 303 //  typelib_typedescription_release( desc);
 304
 305     USES_CONVERSION;
 306     char buff[1024];
 307     buff[0]=0;
 308     char tmpBuf[1024];
 309     tmpBuf[0]=0;
 310     sal_Int32 i;
 311
 312     for( i=0; i< val.getLength(); i++)
 313     {
 314         Any& elem= val[i];
 315         switch ( elem.getValueTypeClass())
 316         {
 317         case TypeClass_BYTE:
 318              sprintf( tmpBuf, "sal_Int8 %d \n", *(sal_Int8*)elem.getValue());
 319              break;
 320         case TypeClass_SHORT:
 321              sprintf( tmpBuf, "sal_Int16 %d \n", *(sal_Int16*)elem.getValue());
 322              break;
 323         case TypeClass_LONG:
 324              sprintf( tmpBuf, "sal_Int32 %d \n", *(sal_Int32*)elem.getValue());
 325              break;
 326         case TypeClass_DOUBLE:
 327              sprintf( tmpBuf, "double %f \n", *(double*)elem.getValue());
 328              break;
 329         case TypeClass_FLOAT:
 330              sprintf( tmpBuf, "float %f \n", *(float*)elem.getValue());
 331              break;
 332         case TypeClass_STRING:
 333              sprintf( tmpBuf, "%S \n", (*(OUString*)elem.getValue()).getStr());
 334              break;
 335         case TypeClass_INTERFACE:
 336             {
 337             // we assume that the interface is XInvocation of a AxTestControls.Basic component.
 338             Reference<XInvocation> inv;
 339             elem>>= inv;
 340             if( inv.is())
 341             {
 342                 Any prpVal= inv->getValue( OUString( L"prpString"));
 343                 sprintf( tmpBuf, "Property prpString: %S \n", (*(OUString*)prpVal.getValue()).getStr());
 344             }
 345             break;
 346             }
 347         default:break;
 348         }
 349         strcat( buff, tmpBuf);
 350
 351     }
 352
 353     MessageBox( NULL, A2T(buff), _T("clientTest: printing Sequence elements"), MB_OK);
 354 }