| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_extensions.hxx" |
| |
| #include <atlbase.h> |
| #include <stdio.h> |
| #include "cppuhelper/bootstrap.hxx" |
| #include "rtl/process.h" |
| #include "typelib/typedescription.hxx" |
| |
| #include "com/sun/star/bridge/ModelDependent.hpp" |
| #include "com/sun/star/bridge/XBridgeSupplier2.hpp" |
| #include "com/sun/star/uno/TypeClass.hpp" |
| #include "com/sun/star/script/XInvocation.hpp" |
| #include "com/sun/star/lang/XMultiServiceFactory.hpp" |
| #include "com/sun/star/uno/XComponentContext.hpp" |
| #include <com/sun/star/bridge/oleautomation/NamedArgument.hpp> |
| #include "rtl/ustring.hxx" |
| |
| using namespace com::sun::star::bridge; |
| using namespace com::sun::star::bridge::ModelDependent; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::script; |
| using namespace com::sun::star::bridge::oleautomation; |
| using namespace rtl; |
| using namespace cppu; |
| |
| template< class T > |
| bool equalSequences(const Sequence<T>& seqIn, const Sequence<Any> & returned); |
| |
| |
| Reference< XMultiServiceFactory > objectFactory;// |
| |
| |
| Reference<XMultiServiceFactory> getMultiServiceFactory() |
| { |
| static Reference< XMultiServiceFactory > factory; |
| if( ! objectFactory.is() ) |
| { |
| Reference<XComponentContext> context = defaultBootstrap_InitialComponentContext(); |
| factory = Reference<XMultiServiceFactory>( context->getServiceManager(), UNO_QUERY); |
| |
| } |
| return factory; |
| } |
| |
| Reference<XInvocation> getComObject( OUString progId) |
| { |
| HRESULT hr= S_OK; |
| Reference< XInvocation > ret; |
| // Reference<XMultiServiceFactory> fac; |
| if( ! objectFactory.is()) |
| { Reference<XMultiServiceFactory> mgr= getMultiServiceFactory(); |
| Reference<XInterface> xInt= mgr->createInstance( |
| OUString(L"com.sun.star.bridge.oleautomation.Factory")); |
| objectFactory= Reference<XMultiServiceFactory>::query( xInt); |
| } |
| |
| if( objectFactory.is()) |
| { |
| Reference<XInterface> xIntAx= objectFactory->createInstance( progId.getStr()); |
| if( xIntAx.is() ) |
| { |
| Reference< XInvocation > xInv( xIntAx, UNO_QUERY); |
| ret= xInv; |
| } |
| } |
| return ret; |
| } |
| |
| Reference<XInvocation> convertComObject( IUnknown* pUnk) |
| { |
| Reference< XMultiServiceFactory > mgr= getMultiServiceFactory(); |
| Reference< XInterface > xIntSupplier= mgr->createInstance(OUString(L"com.sun.star.bridge.OleBridgeSupplier2")); |
| Reference< XBridgeSupplier2 > xSuppl( xIntSupplier, UNO_QUERY); |
| |
| Any any; |
| CComVariant var( pUnk); |
| any <<= ( sal_uInt32)&var; |
| sal_uInt8 arId[16]; |
| rtl_getGlobalProcessId( arId); |
| Any target= xSuppl->createBridge( any, Sequence<sal_Int8>( (sal_Int8*)arId, 16), OLE, UNO ); |
| |
| Reference<XInvocation> ret; |
| target>>= ret; |
| return ret; |
| } |
| |
| /* |
| Parameter values contains the expected return values. The value at index 0 |
| correspond to parameter 0 (left - most). For parameters which are not out or |
| in/out the value must be a void any. |
| |
| The number of items in value must be the |
| same as the number of provided parameter during the call on the method. |
| |
| The parameter outArgs, indices correspond to the sequences which are |
| arguments to XInvocation::invoke |
| */ |
| bool checkOutArgs(const Sequence<Any> & outArgs, |
| const Sequence<sal_Int16> & indices, const Sequence<Any> & values) |
| { |
| if (values.getLength() != outArgs.getLength()) |
| return false; |
| //iterate over all parameters. i represents the parameter index |
| for (int i = 0; i < values.getLength(); i++) |
| { |
| if (values[i].getValueType() == getVoidCppuType()) |
| continue; |
| //out parameter |
| //Based on the parameter index find the correspondent out value |
| int indexOutSeq = -1; |
| for (int iIndices = indices.getLength() - 1; iIndices >= 0; iIndices --) |
| { |
| if (indices[iIndices] == i) |
| { |
| indexOutSeq = iIndices; |
| break; |
| } |
| } |
| if (indexOutSeq == -1) |
| return false; |
| |
| Any value; |
| Any out; |
| values[i] >>= value; |
| outArgs[indexOutSeq] >>=out; |
| NamedArgument naVal; |
| NamedArgument naOut; |
| value >>= naVal; |
| out >>= naOut; |
| if (values[i].getValueType() == getCppuType((NamedArgument *) 0)) |
| { |
| NamedArgument inNamed; |
| values[i] >>= inNamed; |
| value <<= inNamed.Value; |
| } |
| if (value != outArgs[indexOutSeq]) |
| return false; |
| } |
| return true; |
| } |
| |
| /* The returned sequence always contains Any elements |
| */ |
| bool equalSequences(const Any& orig, const Any& returned) |
| { |
| if (orig.getValueTypeClass() != TypeClass_SEQUENCE) |
| { |
| OSL_ASSERT(0); |
| return false; |
| } |
| TypeDescription td(orig.getValueTypeRef()); |
| typelib_IndirectTypeDescription * indirect_td = (typelib_IndirectTypeDescription *) td.get(); |
| |
| switch (indirect_td->pType->eTypeClass) |
| { |
| case TypeClass_CHAR: |
| { |
| Sequence<sal_Unicode> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_BOOLEAN: |
| { |
| Sequence<sal_Bool> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_BYTE: |
| { |
| Sequence<sal_Int8> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_SHORT: |
| { |
| Sequence<sal_Int16> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_LONG: |
| { |
| Sequence<sal_Int32> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_FLOAT: |
| { |
| Sequence<float> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_DOUBLE: |
| { |
| Sequence<double> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_STRING: |
| { |
| Sequence<OUString> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_ANY: |
| { |
| Sequence<Any> seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| case TypeClass_SEQUENCE: |
| { |
| //Sequence<sal_Unicode> seq; |
| //orig >>= seq; |
| //Sequence<Any> seq2; |
| //returned >>= seq2; |
| //return equalSequences(seq, seq2); |
| break; |
| } |
| case TypeClass_INTERFACE: |
| { |
| Sequence<Reference<XInvocation> > seq; |
| orig >>= seq; |
| Sequence<Any> seq2; |
| returned >>= seq2; |
| return equalSequences(seq, seq2); |
| } |
| default: |
| return false; |
| } |
| return false; |
| } |
| |
| template< class T > |
| bool equalSequences(const Sequence<T>& seqIn, const Sequence<Any> & seqOut) |
| { |
| if (seqIn.getLength() != seqOut.getLength()) |
| return false; |
| int len = seqIn.getLength(); |
| for (int i = 0; i < len; i++) |
| { |
| Any anyIn; |
| anyIn <<= seqIn[i]; |
| Any anyOut = seqOut[i]; |
| if (anyIn != anyOut) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void printSequence( Sequence<Any>& val) |
| { |
| |
| // typelib_TypeDescription* desc; |
| // val.getValueTypeDescription( &desc); |
| // typelib_typedescription_release( desc); |
| |
| USES_CONVERSION; |
| char buff[1024]; |
| buff[0]=0; |
| char tmpBuf[1024]; |
| tmpBuf[0]=0; |
| sal_Int32 i; |
| |
| for( i=0; i< val.getLength(); i++) |
| { |
| Any& elem= val[i]; |
| switch ( elem.getValueTypeClass()) |
| { |
| case TypeClass_BYTE: |
| sprintf( tmpBuf, "sal_Int8 %d \n", *(sal_Int8*)elem.getValue()); |
| break; |
| case TypeClass_SHORT: |
| sprintf( tmpBuf, "sal_Int16 %d \n", *(sal_Int16*)elem.getValue()); |
| break; |
| case TypeClass_LONG: |
| sprintf( tmpBuf, "sal_Int32 %d \n", *(sal_Int32*)elem.getValue()); |
| break; |
| case TypeClass_DOUBLE: |
| sprintf( tmpBuf, "double %f \n", *(double*)elem.getValue()); |
| break; |
| case TypeClass_FLOAT: |
| sprintf( tmpBuf, "float %f \n", *(float*)elem.getValue()); |
| break; |
| case TypeClass_STRING: |
| sprintf( tmpBuf, "%S \n", (*(OUString*)elem.getValue()).getStr()); |
| break; |
| case TypeClass_INTERFACE: |
| { |
| // we assume that the interface is XInvocation of a AxTestControls.Basic component. |
| Reference<XInvocation> inv; |
| elem>>= inv; |
| if( inv.is()) |
| { |
| Any prpVal= inv->getValue( OUString( L"prpString")); |
| sprintf( tmpBuf, "Property prpString: %S \n", (*(OUString*)prpVal.getValue()).getStr()); |
| } |
| break; |
| } |
| default:break; |
| } |
| strcat( buff, tmpBuf); |
| |
| } |
| |
| MessageBox( NULL, A2T(buff), _T("clientTest: printing Sequence elements"), MB_OK); |
| } |
