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