| /************************************************************** | |
| * | |
| * 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_basic.hxx" | |
| //#include <stl_queue.h> | |
| #include <vos/mutex.hxx> | |
| #include <vcl/svapp.hxx> | |
| #ifndef _TOOLERR_HXX //autogen | |
| #include <tools/errcode.hxx> | |
| #endif | |
| #include <svl/hint.hxx> | |
| #include <cppuhelper/implbase1.hxx> | |
| #include <cppuhelper/implbase2.hxx> | |
| #include <cppuhelper/exc_hlp.hxx> | |
| #include <cppuhelper/typeprovider.hxx> | |
| #include <cppuhelper/interfacecontainer.hxx> | |
| #include <comphelper/extract.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <rtl/strbuf.hxx> | |
| #include <com/sun/star/script/ArrayWrapper.hpp> | |
| #include <com/sun/star/script/NativeObjectWrapper.hpp> | |
| #include <com/sun/star/uno/XComponentContext.hpp> | |
| #include <com/sun/star/uno/DeploymentException.hpp> | |
| #include <com/sun/star/lang/XTypeProvider.hpp> | |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/lang/XServiceInfo.hpp> | |
| #include <com/sun/star/beans/PropertyAttribute.hpp> | |
| #include <com/sun/star/beans/PropertyConcept.hpp> | |
| #include <com/sun/star/beans/MethodConcept.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/script/BasicErrorException.hpp> | |
| #include <com/sun/star/script/XAllListener.hpp> | |
| #include <com/sun/star/script/XInvocationAdapterFactory.hpp> | |
| #include <com/sun/star/script/XTypeConverter.hpp> | |
| #include <com/sun/star/script/XDefaultProperty.hpp> | |
| #include <com/sun/star/script/XDirectInvocation.hpp> | |
| #include <com/sun/star/container/XNameAccess.hpp> | |
| #include <com/sun/star/container/XHierarchicalNameAccess.hpp> | |
| #include <com/sun/star/reflection/XIdlArray.hpp> | |
| #include <com/sun/star/reflection/XIdlReflection.hpp> | |
| #include <com/sun/star/reflection/XIdlClassProvider.hpp> | |
| #include <com/sun/star/reflection/XServiceConstructorDescription.hpp> | |
| #include <com/sun/star/bridge/oleautomation/NamedArgument.hpp> | |
| #include <com/sun/star/bridge/oleautomation/Date.hpp> | |
| #include <com/sun/star/bridge/oleautomation/Decimal.hpp> | |
| #include <com/sun/star/bridge/oleautomation/Currency.hpp> | |
| #include <com/sun/star/bridge/oleautomation/XAutomationObject.hpp> | |
| using com::sun::star::uno::Reference; | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::reflection; | |
| using namespace com::sun::star::beans; | |
| using namespace com::sun::star::script; | |
| using namespace com::sun::star::container; | |
| using namespace com::sun::star::bridge; | |
| using namespace cppu; | |
| #include<basic/sbstar.hxx> | |
| #include<basic/sbuno.hxx> | |
| #include<basic/sberrors.hxx> | |
| #include<sbunoobj.hxx> | |
| #include"sbjsmod.hxx" | |
| #include<basic/basmgr.hxx> | |
| #include<sbintern.hxx> | |
| #include<runtime.hxx> | |
| #include<math.h> | |
| #include <hash_map> | |
| #include <com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp> | |
| #include <com/sun/star/reflection/XConstantsTypeDescription.hpp> | |
| TYPEINIT1(SbUnoMethod,SbxMethod) | |
| TYPEINIT1(SbUnoProperty,SbxProperty) | |
| TYPEINIT1(SbUnoObject,SbxObject) | |
| TYPEINIT1(SbUnoClass,SbxObject) | |
| TYPEINIT1(SbUnoService,SbxObject) | |
| TYPEINIT1(SbUnoServiceCtor,SbxMethod) | |
| TYPEINIT1(SbUnoSingleton,SbxObject) | |
| typedef WeakImplHelper1< XAllListener > BasicAllListenerHelper; | |
| // Flag, um immer ueber Invocation zu gehen | |
| //#define INVOCATION_ONLY | |
| // Identifier fuer die dbg_-Properies als Strings anlegen | |
| static char const ID_DBG_SUPPORTEDINTERFACES[] = "Dbg_SupportedInterfaces"; | |
| static char const ID_DBG_PROPERTIES[] = "Dbg_Properties"; | |
| static char const ID_DBG_METHODS[] = "Dbg_Methods"; | |
| static ::rtl::OUString aSeqLevelStr( RTL_CONSTASCII_USTRINGPARAM("[]") ); | |
| static ::rtl::OUString defaultNameSpace( RTL_CONSTASCII_USTRINGPARAM("ooo.vba") ); | |
| // Gets the default property for an uno object. Note: There is some | |
| // redirection built in. The property name specifies the name | |
| // of the default property. | |
| bool SbUnoObject::getDefaultPropName( SbUnoObject* pUnoObj, String& sDfltProp ) | |
| { | |
| bool result = false; | |
| Reference< XDefaultProperty> xDefaultProp( pUnoObj->maTmpUnoObj, UNO_QUERY ); | |
| if ( xDefaultProp.is() ) | |
| { | |
| sDfltProp = xDefaultProp->getDefaultPropertyName(); | |
| if ( sDfltProp.Len() ) | |
| result = true; | |
| } | |
| return result; | |
| } | |
| SbxVariable* getDefaultProp( SbxVariable* pRef ) | |
| { | |
| SbxVariable* pDefaultProp = NULL; | |
| if ( pRef->GetType() == SbxOBJECT ) | |
| { | |
| SbxObject* pObj = PTR_CAST(SbxObject,(SbxVariable*) pRef); | |
| if ( !pObj ) | |
| { | |
| SbxBase* pObjVarObj = pRef->GetObject(); | |
| pObj = PTR_CAST(SbxObject,pObjVarObj); | |
| } | |
| if ( pObj && pObj->ISA(SbUnoObject) ) | |
| { | |
| SbUnoObject* pUnoObj = PTR_CAST(SbUnoObject,(SbxObject*)pObj); | |
| pDefaultProp = pUnoObj->GetDfltProperty(); | |
| } | |
| } | |
| return pDefaultProp; | |
| } | |
| Reference< XComponentContext > getComponentContext_Impl( void ) | |
| { | |
| static Reference< XComponentContext > xContext; | |
| // Haben wir schon CoreReflection, sonst besorgen | |
| if( !xContext.is() ) | |
| { | |
| Reference< XMultiServiceFactory > xFactory = comphelper::getProcessServiceFactory(); | |
| Reference< XPropertySet > xProps( xFactory, UNO_QUERY ); | |
| OSL_ASSERT( xProps.is() ); | |
| if (xProps.is()) | |
| { | |
| xProps->getPropertyValue( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ) >>= xContext; | |
| OSL_ASSERT( xContext.is() ); | |
| } | |
| } | |
| return xContext; | |
| } | |
| // CoreReflection statisch speichern | |
| Reference< XIdlReflection > getCoreReflection_Impl( void ) | |
| { | |
| static Reference< XIdlReflection > xCoreReflection; | |
| // Haben wir schon CoreReflection, sonst besorgen | |
| if( !xCoreReflection.is() ) | |
| { | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| if( xContext.is() ) | |
| { | |
| xContext->getValueByName( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection") ) ) | |
| >>= xCoreReflection; | |
| OSL_ENSURE( xCoreReflection.is(), "### CoreReflection singleton not accessible!?" ); | |
| } | |
| if( !xCoreReflection.is() ) | |
| { | |
| throw DeploymentException( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible") ), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| return xCoreReflection; | |
| } | |
| // CoreReflection statisch speichern | |
| Reference< XHierarchicalNameAccess > getCoreReflection_HierarchicalNameAccess_Impl( void ) | |
| { | |
| static Reference< XHierarchicalNameAccess > xCoreReflection_HierarchicalNameAccess; | |
| if( !xCoreReflection_HierarchicalNameAccess.is() ) | |
| { | |
| Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl(); | |
| if( xCoreReflection.is() ) | |
| { | |
| xCoreReflection_HierarchicalNameAccess = | |
| Reference< XHierarchicalNameAccess >( xCoreReflection, UNO_QUERY ); | |
| } | |
| } | |
| return xCoreReflection_HierarchicalNameAccess; | |
| } | |
| // Hold TypeProvider statically | |
| Reference< XHierarchicalNameAccess > getTypeProvider_Impl( void ) | |
| { | |
| static Reference< XHierarchicalNameAccess > xAccess; | |
| // Haben wir schon CoreReflection, sonst besorgen | |
| if( !xAccess.is() ) | |
| { | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| if( xContext.is() ) | |
| { | |
| xContext->getValueByName( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theTypeDescriptionManager") ) ) | |
| >>= xAccess; | |
| OSL_ENSURE( xAccess.is(), "### TypeDescriptionManager singleton not accessible!?" ); | |
| } | |
| if( !xAccess.is() ) | |
| { | |
| throw DeploymentException( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM | |
| ("/singletons/com.sun.star.reflection.theTypeDescriptionManager singleton not accessible") ), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| return xAccess; | |
| } | |
| // Hold TypeConverter statically | |
| Reference< XTypeConverter > getTypeConverter_Impl( void ) | |
| { | |
| static Reference< XTypeConverter > xTypeConverter; | |
| // Haben wir schon CoreReflection, sonst besorgen | |
| if( !xTypeConverter.is() ) | |
| { | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| if( xContext.is() ) | |
| { | |
| Reference<XMultiComponentFactory> xSMgr = xContext->getServiceManager(); | |
| xTypeConverter = Reference<XTypeConverter>( | |
| xSMgr->createInstanceWithContext( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter")), | |
| xContext ), UNO_QUERY ); | |
| } | |
| if( !xTypeConverter.is() ) | |
| { | |
| throw DeploymentException( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM | |
| ("com.sun.star.script.Converter service not accessible") ), | |
| Reference< XInterface >() ); | |
| } | |
| } | |
| return xTypeConverter; | |
| } | |
| // #111851 factory function to create an OLE object | |
| SbUnoObject* createOLEObject_Impl( const String& aType ) | |
| { | |
| static Reference< XMultiServiceFactory > xOLEFactory; | |
| static bool bNeedsInit = true; | |
| if( bNeedsInit ) | |
| { | |
| bNeedsInit = false; | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| if( xContext.is() ) | |
| { | |
| Reference<XMultiComponentFactory> xSMgr = xContext->getServiceManager(); | |
| xOLEFactory = Reference<XMultiServiceFactory>( | |
| xSMgr->createInstanceWithContext( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.bridge.OleObjectFactory")), | |
| xContext ), UNO_QUERY ); | |
| } | |
| } | |
| SbUnoObject* pUnoObj = NULL; | |
| if( xOLEFactory.is() ) | |
| { | |
| // some type names available in VBA can not be directly used in COM | |
| ::rtl::OUString aOLEType = aType; | |
| if ( aOLEType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SAXXMLReader30" ) ) ) ) | |
| aOLEType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Msxml2.SAXXMLReader.3.0" ) ); | |
| Reference< XInterface > xOLEObject = xOLEFactory->createInstance( aOLEType ); | |
| if( xOLEObject.is() ) | |
| { | |
| Any aAny; | |
| aAny <<= xOLEObject; | |
| pUnoObj = new SbUnoObject( aType, aAny ); | |
| } | |
| } | |
| return pUnoObj; | |
| } | |
| namespace | |
| { | |
| void lcl_indent( ::rtl::OUStringBuffer& _inout_rBuffer, sal_Int32 _nLevel ) | |
| { | |
| while ( _nLevel-- > 0 ) | |
| _inout_rBuffer.appendAscii( " " ); | |
| } | |
| } | |
| void implAppendExceptionMsg( ::rtl::OUStringBuffer& _inout_rBuffer, const Exception& _e, const ::rtl::OUString& _rExceptionType, sal_Int32 _nLevel ) | |
| { | |
| _inout_rBuffer.appendAscii( "\n" ); | |
| lcl_indent( _inout_rBuffer, _nLevel ); | |
| _inout_rBuffer.appendAscii( "Type: " ); | |
| if ( _rExceptionType.isEmpty() ) | |
| _inout_rBuffer.appendAscii( "Unknown" ); | |
| else | |
| _inout_rBuffer.append( _rExceptionType ); | |
| _inout_rBuffer.appendAscii( "\n" ); | |
| lcl_indent( _inout_rBuffer, _nLevel ); | |
| _inout_rBuffer.appendAscii( "Message: " ); | |
| _inout_rBuffer.append( _e.Message ); | |
| } | |
| // Fehlermeldungs-Message bei Exception zusammenbauen | |
| ::rtl::OUString implGetExceptionMsg( const Exception& e, const ::rtl::OUString& aExceptionType_ ) | |
| { | |
| ::rtl::OUStringBuffer aMessageBuf; | |
| implAppendExceptionMsg( aMessageBuf, e, aExceptionType_, 0 ); | |
| return aMessageBuf.makeStringAndClear(); | |
| } | |
| String implGetExceptionMsg( const Any& _rCaughtException ) | |
| { | |
| OSL_PRECOND( _rCaughtException.getValueTypeClass() == TypeClass_EXCEPTION, "implGetExceptionMsg: illegal argument!" ); | |
| if ( _rCaughtException.getValueTypeClass() != TypeClass_EXCEPTION ) | |
| return String(); | |
| return implGetExceptionMsg( *static_cast< const Exception* >( _rCaughtException.getValue() ), _rCaughtException.getValueTypeName() ); | |
| } | |
| Any convertAny( const Any& rVal, const Type& aDestType ) | |
| { | |
| Any aConvertedVal; | |
| Reference< XTypeConverter > xConverter = getTypeConverter_Impl(); | |
| try | |
| { | |
| aConvertedVal = xConverter->convertTo( rVal, aDestType ); | |
| } | |
| catch( const IllegalArgumentException& ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( ::cppu::getCaughtException() ) ); | |
| return aConvertedVal; | |
| } | |
| catch( CannotConvertException& e2 ) | |
| { | |
| String aCannotConvertExceptionName | |
| ( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.lang.IllegalArgumentException" ) ); | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( e2, aCannotConvertExceptionName ) ); | |
| return aConvertedVal; | |
| } | |
| return aConvertedVal; | |
| } | |
| // #105565 Special Object to wrap a strongly typed Uno Any | |
| TYPEINIT1(SbUnoAnyObject,SbxObject) | |
| // TODO: Spaeter auslagern | |
| Reference<XIdlClass> TypeToIdlClass( const Type& rType ) | |
| { | |
| // void als Default-Klasse eintragen | |
| Reference<XIdlClass> xRetClass; | |
| typelib_TypeDescription * pTD = 0; | |
| rType.getDescription( &pTD ); | |
| if( pTD ) | |
| { | |
| ::rtl::OUString sOWName( pTD->pTypeName ); | |
| Reference< XIdlReflection > xRefl = getCoreReflection_Impl(); | |
| xRetClass = xRefl->forName( sOWName ); | |
| } | |
| return xRetClass; | |
| } | |
| // Exception type unknown | |
| template< class EXCEPTION > | |
| String implGetExceptionMsg( const EXCEPTION& e ) | |
| { | |
| return implGetExceptionMsg( e, ::getCppuType( &e ).getTypeName() ); | |
| } | |
| // Error-Message fuer WrappedTargetExceptions | |
| String implGetWrappedMsg( const WrappedTargetException& e ) | |
| { | |
| String aMsg; | |
| Any aWrappedAny = e.TargetException; | |
| Type aExceptionType = aWrappedAny.getValueType(); | |
| // Really an Exception? | |
| if( aExceptionType.getTypeClass() == TypeClass_EXCEPTION ) | |
| { | |
| Exception& e_ = *( (Exception*)aWrappedAny.getValue() ); | |
| aMsg = implGetExceptionMsg( e_, String( aExceptionType.getTypeName() ) ); | |
| } | |
| // Otherwise use WrappedTargetException itself | |
| else | |
| { | |
| aMsg = implGetExceptionMsg( e ); | |
| } | |
| return aMsg; | |
| } | |
| void implHandleBasicErrorException( BasicErrorException& e ) | |
| { | |
| SbError nError = StarBASIC::GetSfxFromVBError( (sal_uInt16)e.ErrorCode ); | |
| StarBASIC::Error( nError, e.ErrorMessageArgument ); | |
| } | |
| void implHandleWrappedTargetException( const Any& _rWrappedTargetException ) | |
| { | |
| Any aExamine( _rWrappedTargetException ); | |
| // completely strip the first InvocationTargetException, its error message isn't of any | |
| // interest to the user, it just says something like "invoking the UNO method went wrong.". | |
| InvocationTargetException aInvocationError; | |
| if ( aExamine >>= aInvocationError ) | |
| aExamine = aInvocationError.TargetException; | |
| BasicErrorException aBasicError; | |
| SbError nError( ERRCODE_BASIC_EXCEPTION ); | |
| ::rtl::OUStringBuffer aMessageBuf; | |
| // strip any other WrappedTargetException instances, but this time preserve the error messages. | |
| WrappedTargetException aWrapped; | |
| sal_Int32 nLevel = 0; | |
| while ( aExamine >>= aWrapped ) | |
| { | |
| // special handling for BasicErrorException errors | |
| if ( aWrapped.TargetException >>= aBasicError ) | |
| { | |
| nError = StarBASIC::GetSfxFromVBError( (sal_uInt16)aBasicError.ErrorCode ); | |
| aMessageBuf.append( aBasicError.ErrorMessageArgument ); | |
| aExamine.clear(); | |
| break; | |
| } | |
| // append this round's message | |
| implAppendExceptionMsg( aMessageBuf, aWrapped, aExamine.getValueTypeName(), nLevel ); | |
| if ( aWrapped.TargetException.getValueTypeClass() == TypeClass_EXCEPTION ) | |
| // there is a next chain element | |
| aMessageBuf.appendAscii( "\nTargetException:" ); | |
| // next round | |
| aExamine = aWrapped.TargetException; | |
| ++nLevel; | |
| } | |
| if ( aExamine.getValueTypeClass() == TypeClass_EXCEPTION ) | |
| { | |
| // the last element in the chain is still an exception, but no WrappedTargetException | |
| implAppendExceptionMsg( aMessageBuf, *static_cast< const Exception* >( aExamine.getValue() ), aExamine.getValueTypeName(), nLevel ); | |
| } | |
| StarBASIC::Error( nError, aMessageBuf.makeStringAndClear() ); | |
| } | |
| static void implHandleAnyException( const Any& _rCaughtException ) | |
| { | |
| BasicErrorException aBasicError; | |
| WrappedTargetException aWrappedError; | |
| if ( _rCaughtException >>= aBasicError ) | |
| { | |
| implHandleBasicErrorException( aBasicError ); | |
| } | |
| else if ( _rCaughtException >>= aWrappedError ) | |
| { | |
| implHandleWrappedTargetException( _rCaughtException ); | |
| } | |
| else | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, implGetExceptionMsg( _rCaughtException ) ); | |
| } | |
| } | |
| // NativeObjectWrapper handling | |
| struct ObjectItem | |
| { | |
| SbxObjectRef m_xNativeObj; | |
| ObjectItem( void ) | |
| {} | |
| ObjectItem( SbxObject* pNativeObj ) | |
| : m_xNativeObj( pNativeObj ) | |
| {} | |
| }; | |
| static std::vector< ObjectItem > GaNativeObjectWrapperVector; | |
| void clearNativeObjectWrapperVector( void ) | |
| { | |
| GaNativeObjectWrapperVector.clear(); | |
| } | |
| sal_uInt32 lcl_registerNativeObjectWrapper( SbxObject* pNativeObj ) | |
| { | |
| sal_uInt32 nIndex = GaNativeObjectWrapperVector.size(); | |
| GaNativeObjectWrapperVector.push_back( ObjectItem( pNativeObj ) ); | |
| return nIndex; | |
| } | |
| SbxObject* lcl_getNativeObject( sal_uInt32 nIndex ) | |
| { | |
| SbxObjectRef xRetObj; | |
| if( nIndex < GaNativeObjectWrapperVector.size() ) | |
| { | |
| ObjectItem& rItem = GaNativeObjectWrapperVector[ nIndex ]; | |
| xRetObj = rItem.m_xNativeObj; | |
| } | |
| return xRetObj; | |
| } | |
| // Von Uno nach Sbx wandeln | |
| SbxDataType unoToSbxType( TypeClass eType ) | |
| { | |
| SbxDataType eRetType = SbxVOID; | |
| switch( eType ) | |
| { | |
| case TypeClass_INTERFACE: | |
| case TypeClass_TYPE: | |
| case TypeClass_STRUCT: | |
| case TypeClass_EXCEPTION: eRetType = SbxOBJECT; break; | |
| /* folgende Typen lassen wir erstmal weg | |
| case TypeClass_SERVICE: break; | |
| case TypeClass_CLASS: break; | |
| case TypeClass_TYPEDEF: break; | |
| case TypeClass_UNION: break; | |
| case TypeClass_ARRAY: break; | |
| */ | |
| case TypeClass_ENUM: eRetType = SbxLONG; break; | |
| case TypeClass_SEQUENCE: | |
| eRetType = (SbxDataType) ( SbxOBJECT | SbxARRAY ); | |
| break; | |
| /* | |
| case TypeClass_VOID: break; | |
| case TypeClass_UNKNOWN: break; | |
| */ | |
| case TypeClass_ANY: eRetType = SbxVARIANT; break; | |
| case TypeClass_BOOLEAN: eRetType = SbxBOOL; break; | |
| case TypeClass_CHAR: eRetType = SbxCHAR; break; | |
| case TypeClass_STRING: eRetType = SbxSTRING; break; | |
| case TypeClass_FLOAT: eRetType = SbxSINGLE; break; | |
| case TypeClass_DOUBLE: eRetType = SbxDOUBLE; break; | |
| //case TypeClass_OCTET: break; | |
| case TypeClass_BYTE: eRetType = SbxINTEGER; break; | |
| //case TypeClass_INT: eRetType = SbxINT; break; | |
| case TypeClass_SHORT: eRetType = SbxINTEGER; break; | |
| case TypeClass_LONG: eRetType = SbxLONG; break; | |
| case TypeClass_HYPER: eRetType = SbxSALINT64; break; | |
| //case TypeClass_UNSIGNED_OCTET: break; | |
| case TypeClass_UNSIGNED_SHORT: eRetType = SbxUSHORT; break; | |
| case TypeClass_UNSIGNED_LONG: eRetType = SbxULONG; break; | |
| case TypeClass_UNSIGNED_HYPER: eRetType = SbxSALUINT64;break; | |
| //case TypeClass_UNSIGNED_INT: eRetType = SbxUINT; break; | |
| //case TypeClass_UNSIGNED_BYTE: eRetType = SbxUSHORT; break; | |
| default: break; | |
| } | |
| return eRetType; | |
| } | |
| SbxDataType unoToSbxType( const Reference< XIdlClass >& xIdlClass ) | |
| { | |
| SbxDataType eRetType = SbxVOID; | |
| if( xIdlClass.is() ) | |
| { | |
| TypeClass eType = xIdlClass->getTypeClass(); | |
| eRetType = unoToSbxType( eType ); | |
| } | |
| return eRetType; | |
| } | |
| static void implSequenceToMultiDimArray( SbxDimArray*& pArray, Sequence< sal_Int32 >& indices, Sequence< sal_Int32 >& sizes, const Any& aValue, sal_Int32& dimension, sal_Bool bIsZeroIndex, Type* pType = NULL ) | |
| { | |
| Type aType = aValue.getValueType(); | |
| TypeClass eTypeClass = aType.getTypeClass(); | |
| sal_Int32 indicesIndex = indices.getLength() -1; | |
| sal_Int32 dimCopy = dimension; | |
| if ( eTypeClass == TypeClass_SEQUENCE ) | |
| { | |
| Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( aType ); | |
| Reference< XIdlArray > xIdlArray = xIdlTargetClass->getArray(); | |
| typelib_TypeDescription * pTD = 0; | |
| aType.getDescription( &pTD ); | |
| Type aElementType( ((typelib_IndirectTypeDescription *)pTD)->pType ); | |
| ::typelib_typedescription_release( pTD ); | |
| sal_Int32 nLen = xIdlArray->getLen( aValue ); | |
| for ( sal_Int32 index = 0; index < nLen; ++index ) | |
| { | |
| Any aElementAny = xIdlArray->get( aValue, (sal_uInt32)index ); | |
| // This detects the dimension were currently processing | |
| if ( dimCopy == dimension ) | |
| { | |
| ++dimCopy; | |
| if ( sizes.getLength() < dimCopy ) | |
| { | |
| sizes.realloc( sizes.getLength() + 1 ); | |
| sizes[ sizes.getLength() - 1 ] = nLen; | |
| indices.realloc( indices.getLength() + 1 ); | |
| indicesIndex = indices.getLength() - 1; | |
| } | |
| } | |
| if ( bIsZeroIndex ) | |
| indices[ dimCopy - 1 ] = index; | |
| else | |
| indices[ dimCopy - 1] = index + 1; | |
| implSequenceToMultiDimArray( pArray, indices, sizes, aElementAny, dimCopy, bIsZeroIndex, &aElementType ); | |
| } | |
| } | |
| else | |
| { | |
| if ( indices.getLength() < 1 ) | |
| { | |
| // Should never ever get here ( indices.getLength() | |
| // should equal number of dimensions in the array ) | |
| // And that should at least be 1 ! | |
| // #QUESTION is there a better error? | |
| StarBASIC::Error( SbERR_INVALID_OBJECT ); | |
| return; | |
| } | |
| SbxDataType eSbxElementType = unoToSbxType( pType ? pType->getTypeClass() : aValue.getValueTypeClass() ); | |
| if ( !pArray ) | |
| { | |
| pArray = new SbxDimArray( eSbxElementType ); | |
| sal_Int32 nIndexLen = indices.getLength(); | |
| // Dimension the array | |
| for ( sal_Int32 index = 0; index < nIndexLen; ++index ) | |
| { | |
| if ( bIsZeroIndex ) | |
| pArray->unoAddDim32( 0, sizes[ index ] - 1); | |
| else | |
| pArray->unoAddDim32( 1, sizes[ index ] ); | |
| } | |
| } | |
| if ( pArray ) | |
| { | |
| SbxVariableRef xVar = new SbxVariable( eSbxElementType ); | |
| unoToSbxValue( (SbxVariable*)xVar, aValue ); | |
| sal_Int32* pIndices = indices.getArray(); | |
| pArray->Put32( (SbxVariable*)xVar, pIndices ); | |
| } | |
| } | |
| } | |
| void unoToSbxValue( SbxVariable* pVar, const Any& aValue ) | |
| { | |
| Type aType = aValue.getValueType(); | |
| TypeClass eTypeClass = aType.getTypeClass(); | |
| switch( eTypeClass ) | |
| { | |
| case TypeClass_TYPE: | |
| { | |
| // Map Type to IdlClass | |
| Type aType_; | |
| aValue >>= aType_; | |
| Reference<XIdlClass> xClass = TypeToIdlClass( aType_ ); | |
| Any aClassAny; | |
| aClassAny <<= xClass; | |
| // SbUnoObject instanzieren | |
| String aName; | |
| SbUnoObject* pSbUnoObject = new SbUnoObject( aName, aClassAny ); | |
| SbxObjectRef xWrapper = (SbxObject*)pSbUnoObject; | |
| // #51475 Wenn das Objekt ungueltig ist null liefern | |
| if( pSbUnoObject->getUnoAny().getValueType().getTypeClass() == TypeClass_VOID ) | |
| { | |
| pVar->PutObject( NULL ); | |
| } | |
| else | |
| { | |
| pVar->PutObject( xWrapper ); | |
| } | |
| } | |
| break; | |
| // Interfaces und Structs muessen in ein SbUnoObject gewrappt werden | |
| case TypeClass_INTERFACE: | |
| case TypeClass_STRUCT: | |
| case TypeClass_EXCEPTION: | |
| { | |
| if( eTypeClass == TypeClass_STRUCT ) | |
| { | |
| ArrayWrapper aWrap; | |
| NativeObjectWrapper aNativeObjectWrapper; | |
| if ( (aValue >>= aWrap) ) | |
| { | |
| SbxDimArray* pArray = NULL; | |
| Sequence< sal_Int32 > indices; | |
| Sequence< sal_Int32 > sizes; | |
| sal_Int32 dimension = 0; | |
| implSequenceToMultiDimArray( pArray, indices, sizes, aWrap.Array, dimension, aWrap.IsZeroIndex ); | |
| if ( pArray ) | |
| { | |
| SbxDimArrayRef xArray = pArray; | |
| sal_uInt16 nFlags = pVar->GetFlags(); | |
| pVar->ResetFlag( SBX_FIXED ); | |
| pVar->PutObject( (SbxDimArray*)xArray ); | |
| pVar->SetFlags( nFlags ); | |
| } | |
| else | |
| pVar->PutEmpty(); | |
| break; | |
| } | |
| else if ( (aValue >>= aNativeObjectWrapper) ) | |
| { | |
| sal_uInt32 nIndex = 0; | |
| if( (aNativeObjectWrapper.ObjectId >>= nIndex) ) | |
| { | |
| SbxObject* pObj = lcl_getNativeObject( nIndex ); | |
| pVar->PutObject( pObj ); | |
| } | |
| else | |
| pVar->PutEmpty(); | |
| break; | |
| } | |
| else | |
| { | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| { | |
| oleautomation::Date aDate; | |
| if( (aValue >>= aDate) ) | |
| { | |
| pVar->PutDate( aDate.Value ); | |
| break; | |
| } | |
| else | |
| { | |
| oleautomation::Decimal aDecimal; | |
| if( (aValue >>= aDecimal) ) | |
| { | |
| pVar->PutDecimal( aDecimal ); | |
| break; | |
| } | |
| else | |
| { | |
| oleautomation::Currency aCurrency; | |
| if( (aValue >>= aCurrency) ) | |
| { | |
| sal_Int64 nValue64 = aCurrency.Value; | |
| SbxINT64 aInt64; | |
| aInt64.nHigh = | |
| sal::static_int_cast< sal_Int32 >( | |
| nValue64 >> 32); | |
| aInt64.nLow = (sal_uInt32)( nValue64 & 0xffffffff ); | |
| pVar->PutCurrency( aInt64 ); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // SbUnoObject instanzieren | |
| String aName; | |
| SbUnoObject* pSbUnoObject = new SbUnoObject( aName, aValue ); | |
| //If this is called externally e.g. from the scripting | |
| //framework then there is no 'active' runtime the default property will not be set up | |
| //only a vba object will have XDefaultProp set anyway so... this | |
| //test seems a bit of overkill | |
| //if ( SbiRuntime::isVBAEnabled() ) | |
| { | |
| String sDfltPropName; | |
| if ( SbUnoObject::getDefaultPropName( pSbUnoObject, sDfltPropName ) ) | |
| pSbUnoObject->SetDfltProperty( sDfltPropName ); | |
| } | |
| SbxObjectRef xWrapper = (SbxObject*)pSbUnoObject; | |
| // #51475 Wenn das Objekt ungueltig ist null liefern | |
| if( pSbUnoObject->getUnoAny().getValueType().getTypeClass() == TypeClass_VOID ) | |
| { | |
| pVar->PutObject( NULL ); | |
| } | |
| else | |
| { | |
| pVar->PutObject( xWrapper ); | |
| } | |
| } | |
| break; | |
| /* folgende Typen lassen wir erstmal weg | |
| case TypeClass_SERVICE: break; | |
| case TypeClass_CLASS: break; | |
| case TypeClass_TYPEDEF: break; | |
| case TypeClass_UNION: break; | |
| case TypeClass_ENUM: break; | |
| case TypeClass_ARRAY: break; | |
| */ | |
| case TypeClass_ENUM: | |
| { | |
| sal_Int32 nEnum = 0; | |
| enum2int( nEnum, aValue ); | |
| pVar->PutLong( nEnum ); | |
| } | |
| break; | |
| case TypeClass_SEQUENCE: | |
| { | |
| Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( aType ); | |
| Reference< XIdlArray > xIdlArray = xIdlTargetClass->getArray(); | |
| sal_Int32 i, nLen = xIdlArray->getLen( aValue ); | |
| typelib_TypeDescription * pTD = 0; | |
| aType.getDescription( &pTD ); | |
| OSL_ASSERT( pTD && pTD->eTypeClass == typelib_TypeClass_SEQUENCE ); | |
| Type aElementType( ((typelib_IndirectTypeDescription *)pTD)->pType ); | |
| ::typelib_typedescription_release( pTD ); | |
| // In Basic Array anlegen | |
| SbxDimArrayRef xArray; | |
| SbxDataType eSbxElementType = unoToSbxType( aElementType.getTypeClass() ); | |
| xArray = new SbxDimArray( eSbxElementType ); | |
| if( nLen > 0 ) | |
| { | |
| xArray->unoAddDim32( 0, nLen - 1 ); | |
| // Elemente als Variablen eintragen | |
| for( i = 0 ; i < nLen ; i++ ) | |
| { | |
| // Elemente wandeln | |
| Any aElementAny = xIdlArray->get( aValue, (sal_uInt32)i ); | |
| SbxVariableRef xVar = new SbxVariable( eSbxElementType ); | |
| unoToSbxValue( (SbxVariable*)xVar, aElementAny ); | |
| // Ins Array braten | |
| xArray->Put32( (SbxVariable*)xVar, &i ); | |
| } | |
| } | |
| else | |
| { | |
| xArray->unoAddDim( 0, -1 ); | |
| } | |
| // Array zurueckliefern | |
| sal_uInt16 nFlags = pVar->GetFlags(); | |
| pVar->ResetFlag( SBX_FIXED ); | |
| pVar->PutObject( (SbxDimArray*)xArray ); | |
| pVar->SetFlags( nFlags ); | |
| // #54548, Die Parameter duerfen hier nicht weggehauen werden | |
| //pVar->SetParameters( NULL ); | |
| } | |
| break; | |
| /* | |
| case TypeClass_VOID: break; | |
| case TypeClass_UNKNOWN: break; | |
| case TypeClass_ANY: | |
| { | |
| // Any rausholen und konvertieren | |
| //Any* pAny = (Any*)aValue.get(); | |
| //if( pAny ) | |
| //unoToSbxValue( pVar, *pAny ); | |
| } | |
| break; | |
| */ | |
| case TypeClass_BOOLEAN: pVar->PutBool( *(sal_Bool*)aValue.getValue() ); break; | |
| case TypeClass_CHAR: | |
| { | |
| pVar->PutChar( *(sal_Unicode*)aValue.getValue() ); | |
| break; | |
| } | |
| case TypeClass_STRING: { ::rtl::OUString val; aValue >>= val; pVar->PutString( String( val ) ); } break; | |
| case TypeClass_FLOAT: { float val = 0; aValue >>= val; pVar->PutSingle( val ); } break; | |
| case TypeClass_DOUBLE: { double val = 0; aValue >>= val; pVar->PutDouble( val ); } break; | |
| //case TypeClass_OCTET: break; | |
| case TypeClass_BYTE: { sal_Int8 val = 0; aValue >>= val; pVar->PutInteger( val ); } break; | |
| //case TypeClass_INT: break; | |
| case TypeClass_SHORT: { sal_Int16 val = 0; aValue >>= val; pVar->PutInteger( val ); } break; | |
| case TypeClass_LONG: { sal_Int32 val = 0; aValue >>= val; pVar->PutLong( val ); } break; | |
| case TypeClass_HYPER: { sal_Int64 val = 0; aValue >>= val; pVar->PutInt64( val ); } break; | |
| //case TypeClass_UNSIGNED_OCTET:break; | |
| case TypeClass_UNSIGNED_SHORT: { sal_uInt16 val = 0; aValue >>= val; pVar->PutUShort( val ); } break; | |
| case TypeClass_UNSIGNED_LONG: { sal_uInt32 val = 0; aValue >>= val; pVar->PutULong( val ); } break; | |
| case TypeClass_UNSIGNED_HYPER: { sal_uInt64 val = 0; aValue >>= val; pVar->PutUInt64( val ); } break; | |
| //case TypeClass_UNSIGNED_INT: break; | |
| //case TypeClass_UNSIGNED_BYTE: break; | |
| default: pVar->PutEmpty(); break; | |
| } | |
| } | |
| // Reflection fuer Sbx-Typen liefern | |
| Type getUnoTypeForSbxBaseType( SbxDataType eType ) | |
| { | |
| Type aRetType = getCppuVoidType(); | |
| switch( eType ) | |
| { | |
| //case SbxEMPTY: eRet = TypeClass_VOID; break; | |
| case SbxNULL: aRetType = ::getCppuType( (const Reference< XInterface > *)0 ); break; | |
| case SbxINTEGER: aRetType = ::getCppuType( (sal_Int16*)0 ); break; | |
| case SbxLONG: aRetType = ::getCppuType( (sal_Int32*)0 ); break; | |
| case SbxSINGLE: aRetType = ::getCppuType( (float*)0 ); break; | |
| case SbxDOUBLE: aRetType = ::getCppuType( (double*)0 ); break; | |
| case SbxCURRENCY: aRetType = ::getCppuType( (oleautomation::Currency*)0 ); break; | |
| case SbxDECIMAL: aRetType = ::getCppuType( (oleautomation::Decimal*)0 ); break; | |
| case SbxDATE: { | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| aRetType = ::getCppuType( (double*)0 ); | |
| else | |
| aRetType = ::getCppuType( (oleautomation::Date*)0 ); | |
| } | |
| break; | |
| // case SbxDATE: aRetType = ::getCppuType( (double*)0 ); break; | |
| case SbxSTRING: aRetType = ::getCppuType( (::rtl::OUString*)0 ); break; | |
| //case SbxOBJECT: break; | |
| //case SbxERROR: break; | |
| case SbxBOOL: aRetType = ::getCppuType( (sal_Bool*)0 ); break; | |
| case SbxVARIANT: aRetType = ::getCppuType( (Any*)0 ); break; | |
| //case SbxDATAOBJECT: break; | |
| case SbxCHAR: aRetType = ::getCppuType( (sal_Unicode*)0 ); break; | |
| case SbxBYTE: aRetType = ::getCppuType( (sal_Int8*)0 ); break; | |
| case SbxUSHORT: aRetType = ::getCppuType( (sal_uInt16*)0 ); break; | |
| case SbxULONG: aRetType = ::getCppuType( (sal_uInt32*)0 ); break; | |
| //case SbxLONG64: break; | |
| //case SbxULONG64: break; | |
| // Maschinenabhaengige zur Sicherheit auf Hyper abbilden | |
| case SbxINT: aRetType = ::getCppuType( (sal_Int32*)0 ); break; | |
| case SbxUINT: aRetType = ::getCppuType( (sal_uInt32*)0 ); break; | |
| //case SbxVOID: break; | |
| //case SbxHRESULT: break; | |
| //case SbxPOINTER: break; | |
| //case SbxDIMARRAY: break; | |
| //case SbxCARRAY: break; | |
| //case SbxUSERDEF: break; | |
| //case SbxLPSTR: break; | |
| //case SbxLPWSTR: break; | |
| //case SbxCoreSTRING: break; | |
| default: break; | |
| } | |
| return aRetType; | |
| } | |
| // Konvertierung von Sbx nach Uno ohne bekannte Zielklasse fuer TypeClass_ANY | |
| Type getUnoTypeForSbxValue( SbxValue* pVal ) | |
| { | |
| Type aRetType = getCppuVoidType(); | |
| if( !pVal ) | |
| return aRetType; | |
| // SbxType nach Uno wandeln | |
| SbxDataType eBaseType = pVal->SbxValue::GetType(); | |
| if( eBaseType == SbxOBJECT ) | |
| { | |
| SbxBaseRef xObj = (SbxBase*)pVal->GetObject(); | |
| if( !xObj ) | |
| { | |
| // #109936 No error any more | |
| // StarBASIC::Error( SbERR_INVALID_OBJECT ); | |
| aRetType = getCppuType( static_cast<Reference<XInterface> *>(0) ); | |
| return aRetType; | |
| } | |
| if( xObj->ISA(SbxDimArray) ) | |
| { | |
| SbxBase* pObj = (SbxBase*)xObj; | |
| SbxDimArray* pArray = (SbxDimArray*)pObj; | |
| short nDims = pArray->GetDims(); | |
| Type aElementType = getUnoTypeForSbxBaseType( (SbxDataType)(pArray->GetType() & 0xfff) ); | |
| TypeClass eElementTypeClass = aElementType.getTypeClass(); | |
| // Normal case: One dimensional array | |
| sal_Int32 nLower, nUpper; | |
| if( nDims == 1 && pArray->GetDim32( 1, nLower, nUpper ) ) | |
| { | |
| if( eElementTypeClass == TypeClass_VOID || eElementTypeClass == TypeClass_ANY ) | |
| { | |
| // Wenn alle Elemente des Arrays vom gleichen Typ sind, wird | |
| // der genommen, sonst wird das ganze als Any-Sequence betrachtet | |
| sal_Bool bNeedsInit = sal_True; | |
| sal_Int32 nSize = nUpper - nLower + 1; | |
| sal_Int32 nIdx = nLower; | |
| for( sal_Int32 i = 0 ; i < nSize ; i++,nIdx++ ) | |
| { | |
| SbxVariableRef xVar = pArray->Get32( &nIdx ); | |
| Type aType = getUnoTypeForSbxValue( (SbxVariable*)xVar ); | |
| if( bNeedsInit ) | |
| { | |
| if( aType.getTypeClass() == TypeClass_VOID ) | |
| { | |
| // #88522 | |
| // if only first element is void: different types -> []any | |
| // if all elements are void: []void is not allowed -> []any | |
| aElementType = getCppuType( (Any*)0 ); | |
| break; | |
| } | |
| aElementType = aType; | |
| bNeedsInit = sal_False; | |
| } | |
| else if( aElementType != aType ) | |
| { | |
| // Verschiedene Typen -> AnySequence | |
| aElementType = getCppuType( (Any*)0 ); | |
| break; | |
| } | |
| } | |
| } | |
| ::rtl::OUString aSeqTypeName( aSeqLevelStr ); | |
| aSeqTypeName += aElementType.getTypeName(); | |
| aRetType = Type( TypeClass_SEQUENCE, aSeqTypeName ); | |
| } | |
| // #i33795 Map also multi dimensional arrays to corresponding sequences | |
| else if( nDims > 1 ) | |
| { | |
| if( eElementTypeClass == TypeClass_VOID || eElementTypeClass == TypeClass_ANY ) | |
| { | |
| // For this check the array's dim structure does not matter | |
| sal_uInt32 nFlatArraySize = pArray->Count32(); | |
| sal_Bool bNeedsInit = sal_True; | |
| for( sal_uInt32 i = 0 ; i < nFlatArraySize ; i++ ) | |
| { | |
| SbxVariableRef xVar = pArray->SbxArray::Get32( i ); | |
| Type aType = getUnoTypeForSbxValue( (SbxVariable*)xVar ); | |
| if( bNeedsInit ) | |
| { | |
| if( aType.getTypeClass() == TypeClass_VOID ) | |
| { | |
| // if only first element is void: different types -> []any | |
| // if all elements are void: []void is not allowed -> []any | |
| aElementType = getCppuType( (Any*)0 ); | |
| break; | |
| } | |
| aElementType = aType; | |
| bNeedsInit = sal_False; | |
| } | |
| else if( aElementType != aType ) | |
| { | |
| // Verschiedene Typen -> AnySequence | |
| aElementType = getCppuType( (Any*)0 ); | |
| break; | |
| } | |
| } | |
| } | |
| ::rtl::OUString aSeqTypeName; | |
| for( short iDim = 0 ; iDim < nDims ; iDim++ ) | |
| aSeqTypeName += aSeqLevelStr; | |
| aSeqTypeName += aElementType.getTypeName(); | |
| aRetType = Type( TypeClass_SEQUENCE, aSeqTypeName ); | |
| } | |
| } | |
| // Kein Array, sondern... | |
| else if( xObj->ISA(SbUnoObject) ) | |
| { | |
| aRetType = ((SbUnoObject*)(SbxBase*)xObj)->getUnoAny().getValueType(); | |
| } | |
| // SbUnoAnyObject? | |
| else if( xObj->ISA(SbUnoAnyObject) ) | |
| { | |
| aRetType = ((SbUnoAnyObject*)(SbxBase*)xObj)->getValue().getValueType(); | |
| } | |
| // Sonst ist es ein Nicht-Uno-Basic-Objekt -> default==void liefern | |
| } | |
| // Kein Objekt, Basistyp konvertieren | |
| else | |
| { | |
| aRetType = getUnoTypeForSbxBaseType( eBaseType ); | |
| } | |
| return aRetType; | |
| } | |
| // Deklaration Konvertierung von Sbx nach Uno mit bekannter Zielklasse | |
| Any sbxToUnoValue( SbxVariable* pVar, const Type& rType, Property* pUnoProperty = NULL ); | |
| // Konvertierung von Sbx nach Uno ohne bekannte Zielklasse fuer TypeClass_ANY | |
| Any sbxToUnoValueImpl( SbxVariable* pVar, bool bBlockConversionToSmallestType = false ) | |
| { | |
| SbxDataType eBaseType = pVar->SbxValue::GetType(); | |
| if( eBaseType == SbxOBJECT ) | |
| { | |
| SbxBaseRef xObj = (SbxBase*)pVar->GetObject(); | |
| if( xObj.Is() ) | |
| { | |
| if( xObj->ISA(SbUnoAnyObject) ) | |
| return ((SbUnoAnyObject*)(SbxBase*)xObj)->getValue(); | |
| if( xObj->ISA(SbClassModuleObject) ) | |
| { | |
| Any aRetAny; | |
| SbClassModuleObject* pClassModuleObj = (SbClassModuleObject*)(SbxBase*)xObj; | |
| SbModule* pClassModule = pClassModuleObj->getClassModule(); | |
| if( pClassModule->createCOMWrapperForIface( aRetAny, pClassModuleObj ) ) | |
| return aRetAny; | |
| } | |
| if( !xObj->ISA(SbUnoObject) ) | |
| { | |
| // Create NativeObjectWrapper to identify object in case of callbacks | |
| SbxObject* pObj = PTR_CAST(SbxObject,pVar->GetObject()); | |
| if( pObj != NULL ) | |
| { | |
| NativeObjectWrapper aNativeObjectWrapper; | |
| sal_uInt32 nIndex = lcl_registerNativeObjectWrapper( pObj ); | |
| aNativeObjectWrapper.ObjectId <<= nIndex; | |
| Any aRetAny; | |
| aRetAny <<= aNativeObjectWrapper; | |
| return aRetAny; | |
| } | |
| } | |
| } | |
| } | |
| Type aType = getUnoTypeForSbxValue( pVar ); | |
| TypeClass eType = aType.getTypeClass(); | |
| if( !bBlockConversionToSmallestType ) | |
| { | |
| // #79615 Choose "smallest" represention for int values | |
| // because up cast is allowed, downcast not | |
| switch( eType ) | |
| { | |
| case TypeClass_FLOAT: | |
| case TypeClass_DOUBLE: | |
| { | |
| double d = pVar->GetDouble(); | |
| if( d == floor( d ) ) | |
| { | |
| if( d >= -128 && d <= 127 ) | |
| aType = ::getCppuType( (sal_Int8*)0 ); | |
| else if( d >= SbxMININT && d <= SbxMAXINT ) | |
| aType = ::getCppuType( (sal_Int16*)0 ); | |
| else if( d >= -SbxMAXLNG && d <= SbxMAXLNG ) | |
| aType = ::getCppuType( (sal_Int32*)0 ); | |
| } | |
| break; | |
| } | |
| case TypeClass_SHORT: | |
| { | |
| sal_Int16 n = pVar->GetInteger(); | |
| if( n >= -128 && n <= 127 ) | |
| aType = ::getCppuType( (sal_Int8*)0 ); | |
| break; | |
| } | |
| case TypeClass_LONG: | |
| { | |
| sal_Int32 n = pVar->GetLong(); | |
| if( n >= -128 && n <= 127 ) | |
| aType = ::getCppuType( (sal_Int8*)0 ); | |
| else if( n >= SbxMININT && n <= SbxMAXINT ) | |
| aType = ::getCppuType( (sal_Int16*)0 ); | |
| break; | |
| } | |
| case TypeClass_UNSIGNED_SHORT: | |
| { | |
| sal_uInt16 n = pVar->GetUShort(); | |
| if( n <= 255 ) | |
| aType = ::getCppuType( (sal_uInt8*)0 ); | |
| break; | |
| } | |
| case TypeClass_UNSIGNED_LONG: | |
| { | |
| sal_uInt32 n = pVar->GetLong(); | |
| if( n <= 255 ) | |
| aType = ::getCppuType( (sal_uInt8*)0 ); | |
| else if( n <= SbxMAXUINT ) | |
| aType = ::getCppuType( (sal_uInt16*)0 ); | |
| break; | |
| } | |
| default: break; | |
| } | |
| } | |
| return sbxToUnoValue( pVar, aType ); | |
| } | |
| // Helper function for StepREDIMP | |
| static Any implRekMultiDimArrayToSequence( SbxDimArray* pArray, | |
| const Type& aElemType, short nMaxDimIndex, short nActualDim, | |
| sal_Int32* pActualIndices, sal_Int32* pLowerBounds, sal_Int32* pUpperBounds ) | |
| { | |
| sal_Int32 nSeqLevel = nMaxDimIndex - nActualDim + 1; | |
| ::rtl::OUString aSeqTypeName; | |
| sal_Int32 i; | |
| for( i = 0 ; i < nSeqLevel ; i++ ) | |
| aSeqTypeName += aSeqLevelStr; | |
| aSeqTypeName += aElemType.getTypeName(); | |
| Type aSeqType( TypeClass_SEQUENCE, aSeqTypeName ); | |
| // Create Sequence instance | |
| Any aRetVal; | |
| Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( aSeqType ); | |
| xIdlTargetClass->createObject( aRetVal ); | |
| // Alloc sequence according to array bounds | |
| sal_Int32 nUpper = pUpperBounds[nActualDim]; | |
| sal_Int32 nLower = pLowerBounds[nActualDim]; | |
| sal_Int32 nSeqSize = nUpper - nLower + 1; | |
| Reference< XIdlArray > xArray = xIdlTargetClass->getArray(); | |
| xArray->realloc( aRetVal, nSeqSize ); | |
| sal_Int32& ri = pActualIndices[nActualDim]; | |
| for( ri = nLower,i = 0 ; ri <= nUpper ; ri++,i++ ) | |
| { | |
| Any aElementVal; | |
| if( nActualDim < nMaxDimIndex ) | |
| { | |
| aElementVal = implRekMultiDimArrayToSequence( pArray, aElemType, | |
| nMaxDimIndex, nActualDim + 1, pActualIndices, pLowerBounds, pUpperBounds ); | |
| } | |
| else | |
| { | |
| SbxVariable* pSource = pArray->Get32( pActualIndices ); | |
| aElementVal = sbxToUnoValue( pSource, aElemType ); | |
| } | |
| try | |
| { | |
| // In die Sequence uebernehmen | |
| xArray->set( aRetVal, i, aElementVal ); | |
| } | |
| catch( const IllegalArgumentException& ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( ::cppu::getCaughtException() ) ); | |
| } | |
| catch (IndexOutOfBoundsException&) | |
| { | |
| StarBASIC::Error( SbERR_OUT_OF_RANGE ); | |
| } | |
| } | |
| return aRetVal; | |
| } | |
| // Map old interface | |
| Any sbxToUnoValue( SbxVariable* pVar ) | |
| { | |
| return sbxToUnoValueImpl( pVar ); | |
| } | |
| // Funktion, um einen globalen Bezeichner im | |
| // UnoScope zu suchen und fuer Sbx zu wrappen | |
| static bool implGetTypeByName( const String& rName, Type& rRetType ) | |
| { | |
| bool bSuccess = false; | |
| Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl(); | |
| if( xTypeAccess->hasByHierarchicalName( rName ) ) | |
| { | |
| Any aRet = xTypeAccess->getByHierarchicalName( rName ); | |
| Reference< XTypeDescription > xTypeDesc; | |
| aRet >>= xTypeDesc; | |
| if( xTypeDesc.is() ) | |
| { | |
| rRetType = Type( xTypeDesc->getTypeClass(), xTypeDesc->getName() ); | |
| bSuccess = true; | |
| } | |
| } | |
| return bSuccess; | |
| } | |
| // Konvertierung von Sbx nach Uno mit bekannter Zielklasse | |
| Any sbxToUnoValue( SbxVariable* pVar, const Type& rType, Property* pUnoProperty ) | |
| { | |
| Any aRetVal; | |
| // #94560 No conversion of empty/void for MAYBE_VOID properties | |
| if( pUnoProperty && pUnoProperty->Attributes & PropertyAttribute::MAYBEVOID ) | |
| { | |
| if( pVar->IsEmpty() ) | |
| return aRetVal; | |
| } | |
| SbxDataType eBaseType = pVar->SbxValue::GetType(); | |
| if( eBaseType == SbxOBJECT ) | |
| { | |
| SbxBaseRef xObj = (SbxBase*)pVar->GetObject(); | |
| if( xObj.Is() && xObj->ISA(SbUnoAnyObject) ) | |
| { | |
| return ((SbUnoAnyObject*)(SbxBase*)xObj)->getValue(); | |
| } | |
| } | |
| TypeClass eType = rType.getTypeClass(); | |
| switch( eType ) | |
| { | |
| case TypeClass_INTERFACE: | |
| case TypeClass_STRUCT: | |
| case TypeClass_EXCEPTION: | |
| { | |
| Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( rType ); | |
| // Null-Referenz? | |
| if( pVar->IsNull() && eType == TypeClass_INTERFACE ) | |
| { | |
| Reference< XInterface > xRef; | |
| ::rtl::OUString aClassName = xIdlTargetClass->getName(); | |
| Type aClassType( xIdlTargetClass->getTypeClass(), aClassName.getStr() ); | |
| aRetVal.setValue( &xRef, aClassType ); | |
| } | |
| else | |
| { | |
| // #112368 Special conversion for Decimal, Currency and Date | |
| if( eType == TypeClass_STRUCT ) | |
| { | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| { | |
| if( rType == ::getCppuType( (oleautomation::Decimal*)0 ) ) | |
| { | |
| oleautomation::Decimal aDecimal; | |
| pVar->fillAutomationDecimal( aDecimal ); | |
| aRetVal <<= aDecimal; | |
| break; | |
| } | |
| else if( rType == ::getCppuType( (oleautomation::Currency*)0 ) ) | |
| { | |
| SbxINT64 aInt64 = pVar->GetCurrency(); | |
| oleautomation::Currency aCurrency; | |
| sal_Int64& rnValue64 = aCurrency.Value; | |
| rnValue64 = aInt64.nHigh; | |
| rnValue64 <<= 32; | |
| rnValue64 |= aInt64.nLow; | |
| aRetVal <<= aCurrency; | |
| break; | |
| } | |
| else if( rType == ::getCppuType( (oleautomation::Date*)0 ) ) | |
| { | |
| oleautomation::Date aDate; | |
| aDate.Value = pVar->GetDate(); | |
| aRetVal <<= aDate; | |
| break; | |
| } | |
| } | |
| } | |
| SbxBaseRef pObj = (SbxBase*)pVar->GetObject(); | |
| if( pObj && pObj->ISA(SbUnoObject) ) | |
| { | |
| aRetVal = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny(); | |
| } | |
| else | |
| { | |
| // #109936 NULL object -> NULL XInterface | |
| Reference<XInterface> xInt; | |
| aRetVal <<= xInt; | |
| } | |
| } | |
| } | |
| break; | |
| case TypeClass_TYPE: | |
| { | |
| if( eBaseType == SbxOBJECT ) | |
| { | |
| // XIdlClass? | |
| Reference< XIdlClass > xIdlClass; | |
| SbxBaseRef pObj = (SbxBase*)pVar->GetObject(); | |
| if( pObj && pObj->ISA(SbUnoObject) ) | |
| { | |
| Any aUnoAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny(); | |
| aUnoAny >>= xIdlClass; | |
| } | |
| if( xIdlClass.is() ) | |
| { | |
| ::rtl::OUString aClassName = xIdlClass->getName(); | |
| Type aType( xIdlClass->getTypeClass(), aClassName.getStr() ); | |
| aRetVal <<= aType; | |
| } | |
| } | |
| else if( eBaseType == SbxSTRING ) | |
| { | |
| // String representing type? | |
| String aTypeName = pVar->GetString(); | |
| Type aType; | |
| bool bSuccess = implGetTypeByName( aTypeName, aType ); | |
| if( bSuccess ) | |
| aRetVal <<= aType; | |
| } | |
| } | |
| break; | |
| /* folgende Typen lassen wir erstmal weg | |
| case TypeClass_SERVICE: break; | |
| case TypeClass_CLASS: break; | |
| case TypeClass_TYPEDEF: break; | |
| case TypeClass_UNION: break; | |
| case TypeClass_ENUM: break; | |
| case TypeClass_ARRAY: break; | |
| */ | |
| // Array -> Sequence | |
| case TypeClass_ENUM: | |
| { | |
| aRetVal = int2enum( pVar->GetLong(), rType ); | |
| } | |
| break; | |
| case TypeClass_SEQUENCE: | |
| { | |
| SbxBaseRef xObj = (SbxBase*)pVar->GetObject(); | |
| if( xObj && xObj->ISA(SbxDimArray) ) | |
| { | |
| SbxBase* pObj = (SbxBase*)xObj; | |
| SbxDimArray* pArray = (SbxDimArray*)pObj; | |
| short nDims = pArray->GetDims(); | |
| // Normal case: One dimensional array | |
| sal_Int32 nLower, nUpper; | |
| if( nDims == 1 && pArray->GetDim32( 1, nLower, nUpper ) ) | |
| { | |
| sal_Int32 nSeqSize = nUpper - nLower + 1; | |
| // Instanz der geforderten Sequence erzeugen | |
| Reference< XIdlClass > xIdlTargetClass = TypeToIdlClass( rType ); | |
| xIdlTargetClass->createObject( aRetVal ); | |
| Reference< XIdlArray > xArray = xIdlTargetClass->getArray(); | |
| xArray->realloc( aRetVal, nSeqSize ); | |
| // Element-Type | |
| ::rtl::OUString aClassName = xIdlTargetClass->getName(); | |
| typelib_TypeDescription * pSeqTD = 0; | |
| typelib_typedescription_getByName( &pSeqTD, aClassName.pData ); | |
| OSL_ASSERT( pSeqTD ); | |
| Type aElemType( ((typelib_IndirectTypeDescription *)pSeqTD)->pType ); | |
| // Reference< XIdlClass > xElementClass = TypeToIdlClass( aElemType ); | |
| // Alle Array-Member umwandeln und eintragen | |
| sal_Int32 nIdx = nLower; | |
| for( sal_Int32 i = 0 ; i < nSeqSize ; i++,nIdx++ ) | |
| { | |
| SbxVariableRef xVar = pArray->Get32( &nIdx ); | |
| // Wert von Sbx nach Uno wandeln | |
| Any aAnyValue = sbxToUnoValue( (SbxVariable*)xVar, aElemType ); | |
| try | |
| { | |
| // In die Sequence uebernehmen | |
| xArray->set( aRetVal, i, aAnyValue ); | |
| } | |
| catch( const IllegalArgumentException& ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( ::cppu::getCaughtException() ) ); | |
| } | |
| catch (IndexOutOfBoundsException&) | |
| { | |
| StarBASIC::Error( SbERR_OUT_OF_RANGE ); | |
| } | |
| } | |
| } | |
| // #i33795 Map also multi dimensional arrays to corresponding sequences | |
| else if( nDims > 1 ) | |
| { | |
| // Element-Type | |
| typelib_TypeDescription * pSeqTD = 0; | |
| Type aCurType( rType ); | |
| sal_Int32 nSeqLevel = 0; | |
| Type aElemType; | |
| do | |
| { | |
| ::rtl::OUString aTypeName = aCurType.getTypeName(); | |
| typelib_typedescription_getByName( &pSeqTD, aTypeName.pData ); | |
| OSL_ASSERT( pSeqTD ); | |
| if( pSeqTD->eTypeClass == typelib_TypeClass_SEQUENCE ) | |
| { | |
| aCurType = Type( ((typelib_IndirectTypeDescription *)pSeqTD)->pType ); | |
| nSeqLevel++; | |
| } | |
| else | |
| { | |
| aElemType = aCurType; | |
| break; | |
| } | |
| } | |
| while( true ); | |
| if( nSeqLevel == nDims ) | |
| { | |
| sal_Int32* pLowerBounds = new sal_Int32[nDims]; | |
| sal_Int32* pUpperBounds = new sal_Int32[nDims]; | |
| sal_Int32* pActualIndices = new sal_Int32[nDims]; | |
| for( short i = 1 ; i <= nDims ; i++ ) | |
| { | |
| sal_Int32 lBound, uBound; | |
| pArray->GetDim32( i, lBound, uBound ); | |
| short j = i - 1; | |
| pActualIndices[j] = pLowerBounds[j] = lBound; | |
| pUpperBounds[j] = uBound; | |
| } | |
| aRetVal = implRekMultiDimArrayToSequence( pArray, aElemType, | |
| nDims - 1, 0, pActualIndices, pLowerBounds, pUpperBounds ); | |
| delete[] pUpperBounds; | |
| delete[] pLowerBounds; | |
| delete[] pActualIndices; | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| /* | |
| case TypeClass_VOID: break; | |
| case TypeClass_UNKNOWN: break; | |
| */ | |
| // Bei Any die Klassen-unabhaengige Konvertierungs-Routine nutzen | |
| case TypeClass_ANY: | |
| { | |
| aRetVal = sbxToUnoValueImpl( pVar ); | |
| } | |
| break; | |
| case TypeClass_BOOLEAN: | |
| { | |
| sal_Bool b = pVar->GetBool(); | |
| aRetVal.setValue( &b, getBooleanCppuType() ); | |
| break; | |
| } | |
| case TypeClass_CHAR: | |
| { | |
| sal_Unicode c = pVar->GetChar(); | |
| aRetVal.setValue( &c , getCharCppuType() ); | |
| break; | |
| } | |
| case TypeClass_STRING: aRetVal <<= pVar->GetOUString(); break; | |
| case TypeClass_FLOAT: aRetVal <<= pVar->GetSingle(); break; | |
| case TypeClass_DOUBLE: aRetVal <<= pVar->GetDouble(); break; | |
| //case TypeClass_OCTET: break; | |
| case TypeClass_BYTE: | |
| { | |
| sal_Int16 nVal = pVar->GetInteger(); | |
| sal_Bool bOverflow = sal_False; | |
| if( nVal < -128 ) | |
| { | |
| bOverflow = sal_True; | |
| nVal = -128; | |
| } | |
| else if( nVal > 127 ) | |
| { | |
| bOverflow = sal_True; | |
| nVal = 127; | |
| } | |
| if( bOverflow ) | |
| StarBASIC::Error( ERRCODE_BASIC_MATH_OVERFLOW ); | |
| sal_Int8 nByteVal = (sal_Int8)nVal; | |
| aRetVal <<= nByteVal; | |
| break; | |
| } | |
| //case TypeClass_INT: break; | |
| case TypeClass_SHORT: aRetVal <<= (sal_Int16)( pVar->GetInteger() ); break; | |
| case TypeClass_LONG: aRetVal <<= (sal_Int32)( pVar->GetLong() ); break; | |
| case TypeClass_HYPER: aRetVal <<= (sal_Int64)( pVar->GetInt64() ); break; | |
| //case TypeClass_UNSIGNED_OCTET:break; | |
| case TypeClass_UNSIGNED_SHORT: aRetVal <<= (sal_uInt16)( pVar->GetUShort() ); break; | |
| case TypeClass_UNSIGNED_LONG: aRetVal <<= (sal_uInt32)( pVar->GetULong() ); break; | |
| case TypeClass_UNSIGNED_HYPER: aRetVal <<= (sal_uInt64)( pVar->GetUInt64() ); break; | |
| //case TypeClass_UNSIGNED_INT: break; | |
| //case TypeClass_UNSIGNED_BYTE: break; | |
| default: break; | |
| } | |
| return aRetVal; | |
| } | |
| // Dbg-Hilfsmethode zum Auslesen der in einem Object implementierten Interfaces | |
| String Impl_GetInterfaceInfo( const Reference< XInterface >& x, const Reference< XIdlClass >& xClass, sal_uInt16 nRekLevel ) | |
| { | |
| Type aIfaceType = ::getCppuType( (const Reference< XInterface > *)0 ); | |
| static Reference< XIdlClass > xIfaceClass = TypeToIdlClass( aIfaceType ); | |
| String aRetStr; | |
| for( sal_uInt16 i = 0 ; i < nRekLevel ; i++ ) | |
| aRetStr.AppendAscii( " " ); | |
| aRetStr += String( xClass->getName() ); | |
| ::rtl::OUString aClassName = xClass->getName(); | |
| Type aClassType( xClass->getTypeClass(), aClassName.getStr() ); | |
| // Pruefen, ob das Interface wirklich unterstuetzt wird | |
| if( !x->queryInterface( aClassType ).hasValue() ) | |
| { | |
| aRetStr.AppendAscii( " (ERROR: Not really supported!)\n" ); | |
| } | |
| // Gibt es Super-Interfaces | |
| else | |
| { | |
| aRetStr.AppendAscii( "\n" ); | |
| // Super-Interfaces holen | |
| Sequence< Reference< XIdlClass > > aSuperClassSeq = xClass->getSuperclasses(); | |
| const Reference< XIdlClass >* pClasses = aSuperClassSeq.getConstArray(); | |
| sal_uInt32 nSuperIfaceCount = aSuperClassSeq.getLength(); | |
| for( sal_uInt32 j = 0 ; j < nSuperIfaceCount ; j++ ) | |
| { | |
| const Reference< XIdlClass >& rxIfaceClass = pClasses[j]; | |
| if( !rxIfaceClass->equals( xIfaceClass ) ) | |
| aRetStr += Impl_GetInterfaceInfo( x, rxIfaceClass, nRekLevel + 1 ); | |
| } | |
| } | |
| return aRetStr; | |
| } | |
| String getDbgObjectNameImpl( SbUnoObject* pUnoObj ) | |
| { | |
| String aName; | |
| if( pUnoObj ) | |
| { | |
| aName = pUnoObj->GetClassName(); | |
| if( !aName.Len() ) | |
| { | |
| Any aToInspectObj = pUnoObj->getUnoAny(); | |
| TypeClass eType = aToInspectObj.getValueType().getTypeClass(); | |
| Reference< XInterface > xObj; | |
| if( eType == TypeClass_INTERFACE ) | |
| xObj = *(Reference< XInterface >*)aToInspectObj.getValue(); | |
| if( xObj.is() ) | |
| { | |
| Reference< XServiceInfo > xServiceInfo( xObj, UNO_QUERY ); | |
| if( xServiceInfo.is() ) | |
| aName = xServiceInfo->getImplementationName(); | |
| } | |
| } | |
| } | |
| return aName; | |
| } | |
| String getDbgObjectName( SbUnoObject* pUnoObj ) | |
| { | |
| String aName = getDbgObjectNameImpl( pUnoObj ); | |
| if( !aName.Len() ) | |
| aName.AppendAscii( "Unknown" ); | |
| String aRet; | |
| if( aName.Len() > 20 ) | |
| aRet.AppendAscii( "\n" ); | |
| aRet.AppendAscii( "\"" ); | |
| aRet += aName; | |
| aRet.AppendAscii( "\":" ); | |
| return aRet; | |
| } | |
| String getBasicObjectTypeName( SbxObject* pObj ) | |
| { | |
| String aName; | |
| if( pObj ) | |
| { | |
| SbUnoObject* pUnoObj = PTR_CAST(SbUnoObject,pObj); | |
| if( pUnoObj ) | |
| aName = getDbgObjectNameImpl( pUnoObj ); | |
| } | |
| return aName; | |
| } | |
| bool checkUnoObjectType( SbUnoObject* pUnoObj, const ::rtl::OUString& rClass ) | |
| { | |
| Any aToInspectObj = pUnoObj->getUnoAny(); | |
| TypeClass eType = aToInspectObj.getValueType().getTypeClass(); | |
| if( eType != TypeClass_INTERFACE ) | |
| return false; | |
| const Reference< XInterface > x = *(Reference< XInterface >*)aToInspectObj.getValue(); | |
| // Return true for XInvocation based objects as interface type names don't count then | |
| Reference< XInvocation > xInvocation( x, UNO_QUERY ); | |
| if( xInvocation.is() ) | |
| return true; | |
| bool result = false; | |
| Reference< XTypeProvider > xTypeProvider( x, UNO_QUERY ); | |
| if( xTypeProvider.is() ) | |
| { | |
| /* Although interfaces in the ooo.vba namespace obey the IDL rules and | |
| have a leading 'X', in Basic we want to be able to do something | |
| like 'Dim wb As Workbooks' or 'Dim lb As MSForms.Label'. Here we | |
| add a leading 'X' to the class name and a leading dot to the entire | |
| type name. This results e.g. in '.XWorkbooks' or '.MSForms.XLabel' | |
| which matches the interface names 'ooo.vba.excel.XWorkbooks' or | |
| 'ooo.vba.msforms.XLabel'. | |
| */ | |
| ::rtl::OUString aClassName( sal_Unicode( '.' ) ); | |
| sal_Int32 nClassNameDot = rClass.lastIndexOf( '.' ); | |
| if( nClassNameDot >= 0 ) | |
| aClassName += rClass.copy( 0, nClassNameDot + 1 ) + ::rtl::OUString( sal_Unicode( 'X' ) ) + rClass.copy( nClassNameDot + 1 ); | |
| else | |
| aClassName += ::rtl::OUString( sal_Unicode( 'X' ) ) + rClass; | |
| Sequence< Type > aTypeSeq = xTypeProvider->getTypes(); | |
| const Type* pTypeArray = aTypeSeq.getConstArray(); | |
| sal_uInt32 nIfaceCount = aTypeSeq.getLength(); | |
| for( sal_uInt32 j = 0 ; j < nIfaceCount ; j++ ) | |
| { | |
| const Type& rType = pTypeArray[j]; | |
| Reference<XIdlClass> xClass = TypeToIdlClass( rType ); | |
| if( !xClass.is() ) | |
| { | |
| DBG_ERROR("failed to get XIdlClass for type"); | |
| break; | |
| } | |
| ::rtl::OUString aInterfaceName = xClass->getName(); | |
| if ( aInterfaceName.equals( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.bridge.oleautomation.XAutomationObject" ) ) ) ) | |
| { | |
| // there is a hack in the extensions/source/ole/oleobj.cxx to return the typename of the automation object, lets check if it | |
| // matches | |
| Reference< XInvocation > xInv( aToInspectObj, UNO_QUERY ); | |
| if ( xInv.is() ) | |
| { | |
| rtl::OUString sTypeName; | |
| xInv->getValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("$GetTypeName") ) ) >>= sTypeName; | |
| if ( sTypeName.isEmpty() || sTypeName.equals( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("IDispatch") ) ) ) | |
| // can't check type, leave it pass | |
| result = true; | |
| else | |
| result = sTypeName.equals( rClass ); | |
| } | |
| break; // finished checking automation object | |
| } | |
| // match interface name with passed class name | |
| OSL_TRACE("Checking if object implements %s", OUStringToOString( aClassName, RTL_TEXTENCODING_UTF8 ).getStr() ); | |
| if ( (aClassName.getLength() < aInterfaceName.getLength()) && | |
| aInterfaceName.matchIgnoreAsciiCase( aClassName, aInterfaceName.getLength() - aClassName.getLength() ) ) | |
| { | |
| result = true; | |
| break; | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| // Dbg-Hilfsmethode zum Auslesen der in einem Object implementierten Interfaces | |
| String Impl_GetSupportedInterfaces( SbUnoObject* pUnoObj ) | |
| { | |
| Any aToInspectObj = pUnoObj->getUnoAny(); | |
| // #54898: Nur TypeClass Interface zulasssen | |
| TypeClass eType = aToInspectObj.getValueType().getTypeClass(); | |
| String aRet; | |
| if( eType != TypeClass_INTERFACE ) | |
| { | |
| aRet.AppendAscii( RTL_CONSTASCII_STRINGPARAM(ID_DBG_SUPPORTEDINTERFACES) ); | |
| aRet.AppendAscii( " not available.\n(TypeClass is not TypeClass_INTERFACE)\n" ); | |
| } | |
| else | |
| { | |
| // Interface aus dem Any besorgen | |
| const Reference< XInterface > x = *(Reference< XInterface >*)aToInspectObj.getValue(); | |
| // XIdlClassProvider-Interface ansprechen | |
| Reference< XIdlClassProvider > xClassProvider( x, UNO_QUERY ); | |
| Reference< XTypeProvider > xTypeProvider( x, UNO_QUERY ); | |
| aRet.AssignAscii( "Supported interfaces by object " ); | |
| String aObjName = getDbgObjectName( pUnoObj ); | |
| aRet += aObjName; | |
| aRet.AppendAscii( "\n" ); | |
| if( xTypeProvider.is() ) | |
| { | |
| // Interfaces der Implementation holen | |
| Sequence< Type > aTypeSeq = xTypeProvider->getTypes(); | |
| const Type* pTypeArray = aTypeSeq.getConstArray(); | |
| sal_uInt32 nIfaceCount = aTypeSeq.getLength(); | |
| for( sal_uInt32 j = 0 ; j < nIfaceCount ; j++ ) | |
| { | |
| const Type& rType = pTypeArray[j]; | |
| Reference<XIdlClass> xClass = TypeToIdlClass( rType ); | |
| if( xClass.is() ) | |
| { | |
| aRet += Impl_GetInterfaceInfo( x, xClass, 1 ); | |
| } | |
| else | |
| { | |
| typelib_TypeDescription * pTD = 0; | |
| rType.getDescription( &pTD ); | |
| String TypeName( ::rtl::OUString( pTD->pTypeName ) ); | |
| aRet.AppendAscii( "*** ERROR: No IdlClass for type \"" ); | |
| aRet += TypeName; | |
| aRet.AppendAscii( "\"\n*** Please check type library\n" ); | |
| } | |
| } | |
| } | |
| else if( xClassProvider.is() ) | |
| { | |
| DBG_ERROR( "XClassProvider not supported in UNO3" ); | |
| } | |
| } | |
| return aRet; | |
| } | |
| // Dbg-Hilfsmethode SbxDataType -> String | |
| String Dbg_SbxDataType2String( SbxDataType eType ) | |
| { | |
| String aRet( RTL_CONSTASCII_USTRINGPARAM("Unknown Sbx-Type!") ); | |
| switch( +eType ) | |
| { | |
| case SbxEMPTY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxEMPTY") ); break; | |
| case SbxNULL: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxNULL") ); break; | |
| case SbxINTEGER: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINTEGER") ); break; | |
| case SbxLONG: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLONG") ); break; | |
| case SbxSINGLE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxSINGLE") ); break; | |
| case SbxDOUBLE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDOUBLE") ); break; | |
| case SbxCURRENCY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCURRENCY") ); break; | |
| case SbxDECIMAL: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDECIMAL") ); break; | |
| case SbxDATE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDATE") ); break; | |
| case SbxSTRING: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxSTRING") ); break; | |
| case SbxOBJECT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxOBJECT") ); break; | |
| case SbxERROR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxERROR") ); break; | |
| case SbxBOOL: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxBOOL") ); break; | |
| case SbxVARIANT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxVARIANT") ); break; | |
| case SbxDATAOBJECT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDATAOBJECT") ); break; | |
| case SbxCHAR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCHAR") ); break; | |
| case SbxBYTE: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxBYTE") ); break; | |
| case SbxUSHORT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUSHORT") ); break; | |
| case SbxULONG: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG") ); break; | |
| case SbxLONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLONG64") ); break; | |
| case SbxULONG64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxULONG64") ); break; | |
| case SbxSALINT64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINT64") ); break; | |
| case SbxSALUINT64: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUINT64") ); break; | |
| case SbxINT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxINT") ); break; | |
| case SbxUINT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUINT") ); break; | |
| case SbxVOID: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxVOID") ); break; | |
| case SbxHRESULT: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxHRESULT") ); break; | |
| case SbxPOINTER: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxPOINTER") ); break; | |
| case SbxDIMARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxDIMARRAY") ); break; | |
| case SbxCARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCARRAY") ); break; | |
| case SbxUSERDEF: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxUSERDEF") ); break; | |
| case SbxLPSTR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLPSTR") ); break; | |
| case SbxLPWSTR: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxLPWSTR") ); break; | |
| case SbxCoreSTRING: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxCoreSTRING" ) ); break; | |
| case SbxOBJECT | SbxARRAY: aRet = String( RTL_CONSTASCII_USTRINGPARAM("SbxARRAY") ); break; | |
| default: break; | |
| } | |
| return aRet; | |
| } | |
| // Dbg-Hilfsmethode zum Anzeigen der Properties eines SbUnoObjects | |
| String Impl_DumpProperties( SbUnoObject* pUnoObj ) | |
| { | |
| String aRet( RTL_CONSTASCII_USTRINGPARAM("Properties of object ") ); | |
| String aObjName = getDbgObjectName( pUnoObj ); | |
| aRet += aObjName; | |
| // Uno-Infos auswerten, um Arrays zu erkennen | |
| Reference< XIntrospectionAccess > xAccess = pUnoObj->getIntrospectionAccess(); | |
| if( !xAccess.is() ) | |
| { | |
| Reference< XInvocation > xInvok = pUnoObj->getInvocation(); | |
| if( xInvok.is() ) | |
| xAccess = xInvok->getIntrospection(); | |
| } | |
| if( !xAccess.is() ) | |
| { | |
| aRet.AppendAscii( "\nUnknown, no introspection available\n" ); | |
| return aRet; | |
| } | |
| Sequence<Property> props = xAccess->getProperties( PropertyConcept::ALL - PropertyConcept::DANGEROUS ); | |
| sal_uInt32 nUnoPropCount = props.getLength(); | |
| const Property* pUnoProps = props.getConstArray(); | |
| SbxArray* pProps = pUnoObj->GetProperties(); | |
| sal_uInt16 nPropCount = pProps->Count(); | |
| sal_uInt16 nPropsPerLine = 1 + nPropCount / 30; | |
| for( sal_uInt16 i = 0; i < nPropCount; i++ ) | |
| { | |
| SbxVariable* pVar = pProps->Get( i ); | |
| if( pVar ) | |
| { | |
| String aPropStr; | |
| if( (i % nPropsPerLine) == 0 ) | |
| aPropStr.AppendAscii( "\n" ); | |
| // Typ und Namen ausgeben | |
| // Ist es in Uno eine Sequence? | |
| SbxDataType eType = pVar->GetFullType(); | |
| sal_Bool bMaybeVoid = sal_False; | |
| if( i < nUnoPropCount ) | |
| { | |
| const Property& rProp = pUnoProps[ i ]; | |
| // #63133: Bei MAYBEVOID Typ aus Uno neu konvertieren, | |
| // damit nicht immer nur SbxEMPTY ausgegben wird. | |
| if( rProp.Attributes & PropertyAttribute::MAYBEVOID ) | |
| { | |
| eType = unoToSbxType( rProp.Type.getTypeClass() ); | |
| bMaybeVoid = sal_True; | |
| } | |
| if( eType == SbxOBJECT ) | |
| { | |
| Type aType = rProp.Type; | |
| if( aType.getTypeClass() == TypeClass_SEQUENCE ) | |
| eType = (SbxDataType) ( SbxOBJECT | SbxARRAY ); | |
| } | |
| } | |
| aPropStr += Dbg_SbxDataType2String( eType ); | |
| if( bMaybeVoid ) | |
| aPropStr.AppendAscii( "/void" ); | |
| aPropStr.AppendAscii( " " ); | |
| aPropStr += pVar->GetName(); | |
| if( i == nPropCount - 1 ) | |
| aPropStr.AppendAscii( "\n" ); | |
| else | |
| aPropStr.AppendAscii( "; " ); | |
| aRet += aPropStr; | |
| } | |
| } | |
| return aRet; | |
| } | |
| // Dbg-Hilfsmethode zum Anzeigen der Methoden eines SbUnoObjects | |
| String Impl_DumpMethods( SbUnoObject* pUnoObj ) | |
| { | |
| String aRet( RTL_CONSTASCII_USTRINGPARAM("Methods of object ") ); | |
| String aObjName = getDbgObjectName( pUnoObj ); | |
| aRet += aObjName; | |
| // XIntrospectionAccess, um die Typen der Parameter auch ausgeben zu koennen | |
| Reference< XIntrospectionAccess > xAccess = pUnoObj->getIntrospectionAccess(); | |
| if( !xAccess.is() ) | |
| { | |
| Reference< XInvocation > xInvok = pUnoObj->getInvocation(); | |
| if( xInvok.is() ) | |
| xAccess = xInvok->getIntrospection(); | |
| } | |
| if( !xAccess.is() ) | |
| { | |
| aRet.AppendAscii( "\nUnknown, no introspection available\n" ); | |
| return aRet; | |
| } | |
| Sequence< Reference< XIdlMethod > > methods = xAccess->getMethods | |
| ( MethodConcept::ALL - MethodConcept::DANGEROUS ); | |
| const Reference< XIdlMethod >* pUnoMethods = methods.getConstArray(); | |
| SbxArray* pMethods = pUnoObj->GetMethods(); | |
| sal_uInt16 nMethodCount = pMethods->Count(); | |
| if( !nMethodCount ) | |
| { | |
| aRet.AppendAscii( "\nNo methods found\n" ); | |
| return aRet; | |
| } | |
| sal_uInt16 nPropsPerLine = 1 + nMethodCount / 30; | |
| for( sal_uInt16 i = 0; i < nMethodCount; i++ ) | |
| { | |
| SbxVariable* pVar = pMethods->Get( i ); | |
| if( pVar ) | |
| { | |
| String aPropStr; | |
| if( (i % nPropsPerLine) == 0 ) | |
| aPropStr.AppendAscii( "\n" ); | |
| // Methode ansprechen | |
| const Reference< XIdlMethod >& rxMethod = pUnoMethods[i]; | |
| // Ist es in Uno eine Sequence? | |
| SbxDataType eType = pVar->GetFullType(); | |
| if( eType == SbxOBJECT ) | |
| { | |
| Reference< XIdlClass > xClass = rxMethod->getReturnType(); | |
| if( xClass.is() && xClass->getTypeClass() == TypeClass_SEQUENCE ) | |
| eType = (SbxDataType) ( SbxOBJECT | SbxARRAY ); | |
| } | |
| // Name und Typ ausgeben | |
| aPropStr += Dbg_SbxDataType2String( eType ); | |
| aPropStr.AppendAscii( " " ); | |
| aPropStr += pVar->GetName(); | |
| aPropStr.AppendAscii( " ( " ); | |
| // get-Methode darf keinen Parameter haben | |
| Sequence< Reference< XIdlClass > > aParamsSeq = rxMethod->getParameterTypes(); | |
| sal_uInt32 nParamCount = aParamsSeq.getLength(); | |
| const Reference< XIdlClass >* pParams = aParamsSeq.getConstArray(); | |
| if( nParamCount > 0 ) | |
| { | |
| for( sal_uInt16 j = 0; j < nParamCount; j++ ) | |
| { | |
| String aTypeStr = Dbg_SbxDataType2String( unoToSbxType( pParams[ j ] ) ); | |
| aPropStr += aTypeStr; | |
| if( j < nParamCount - 1 ) | |
| aPropStr.AppendAscii( ", " ); | |
| } | |
| } | |
| else | |
| aPropStr.AppendAscii( "void" ); | |
| aPropStr.AppendAscii( " ) " ); | |
| if( i == nMethodCount - 1 ) | |
| aPropStr.AppendAscii( "\n" ); | |
| else | |
| aPropStr.AppendAscii( "; " ); | |
| aRet += aPropStr; | |
| } | |
| } | |
| return aRet; | |
| } | |
| TYPEINIT1(AutomationNamedArgsSbxArray,SbxArray) | |
| // Implementation SbUnoObject | |
| void SbUnoObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType, | |
| const SfxHint& rHint, const TypeId& rHintType ) | |
| { | |
| if( bNeedIntrospection ) | |
| doIntrospection(); | |
| const SbxHint* pHint = PTR_CAST(SbxHint,&rHint); | |
| if( pHint ) | |
| { | |
| SbxVariable* pVar = pHint->GetVar(); | |
| SbxArray* pParams = pVar->GetParameters(); | |
| SbUnoProperty* pProp = PTR_CAST(SbUnoProperty,pVar); | |
| SbUnoMethod* pMeth = PTR_CAST(SbUnoMethod,pVar); | |
| if( pProp ) | |
| { | |
| bool bInvocation = pProp->isInvocationBased(); | |
| if( pHint->GetId() == SBX_HINT_DATAWANTED ) | |
| { | |
| // Test-Properties | |
| sal_Int32 nId = pProp->nId; | |
| if( nId < 0 ) | |
| { | |
| // Id == -1: Implementierte Interfaces gemaess ClassProvider anzeigen | |
| if( nId == -1 ) // Property ID_DBG_SUPPORTEDINTERFACES" | |
| { | |
| String aRetStr = Impl_GetSupportedInterfaces( this ); | |
| pVar->PutString( aRetStr ); | |
| } | |
| // Id == -2: Properties ausgeben | |
| else if( nId == -2 ) // Property ID_DBG_PROPERTIES | |
| { | |
| // Jetzt muessen alle Properties angelegt werden | |
| implCreateAll(); | |
| String aRetStr = Impl_DumpProperties( this ); | |
| pVar->PutString( aRetStr ); | |
| } | |
| // Id == -3: Methoden ausgeben | |
| else if( nId == -3 ) // Property ID_DBG_METHODS | |
| { | |
| // Jetzt muessen alle Properties angelegt werden | |
| implCreateAll(); | |
| String aRetStr = Impl_DumpMethods( this ); | |
| pVar->PutString( aRetStr ); | |
| } | |
| return; | |
| } | |
| if( !bInvocation && mxUnoAccess.is() ) | |
| { | |
| try | |
| { | |
| // Wert holen | |
| Reference< XPropertySet > xPropSet( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY ); | |
| Any aRetAny = xPropSet->getPropertyValue( pProp->GetName() ); | |
| // Die Nutzung von getPropertyValue (statt ueber den Index zu gehen) ist | |
| // nicht optimal, aber die Umstellung auf XInvocation steht ja ohnehin an | |
| // Ansonsten kann auch FastPropertySet genutzt werden | |
| // Wert von Uno nach Sbx uebernehmen | |
| unoToSbxValue( pVar, aRetAny ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| else if( bInvocation && mxInvocation.is() ) | |
| { | |
| try | |
| { | |
| // Wert holen | |
| Any aRetAny = mxInvocation->getValue( pProp->GetName() ); | |
| // Wert von Uno nach Sbx uebernehmen | |
| unoToSbxValue( pVar, aRetAny ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| } | |
| else if( pHint->GetId() == SBX_HINT_DATACHANGED ) | |
| { | |
| if( !bInvocation && mxUnoAccess.is() ) | |
| { | |
| if( pProp->aUnoProp.Attributes & PropertyAttribute::READONLY ) | |
| { | |
| StarBASIC::Error( SbERR_PROP_READONLY ); | |
| return; | |
| } | |
| // Wert von Uno nach Sbx uebernehmen | |
| Any aAnyValue = sbxToUnoValue( pVar, pProp->aUnoProp.Type, &pProp->aUnoProp ); | |
| try | |
| { | |
| // Wert setzen | |
| Reference< XPropertySet > xPropSet( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY ); | |
| xPropSet->setPropertyValue( pProp->GetName(), aAnyValue ); | |
| // Die Nutzung von getPropertyValue (statt ueber den Index zu gehen) ist | |
| // nicht optimal, aber die Umstellung auf XInvocation steht ja ohnehin an | |
| // Ansonsten kann auch FastPropertySet genutzt werden | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| else if( bInvocation && mxInvocation.is() ) | |
| { | |
| // Wert von Uno nach Sbx uebernehmen | |
| Any aAnyValue = sbxToUnoValueImpl( pVar ); | |
| try | |
| { | |
| // Wert setzen | |
| mxInvocation->setValue( pProp->GetName(), aAnyValue ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| } | |
| } | |
| else if( pMeth ) | |
| { | |
| bool bInvocation = pMeth->isInvocationBased(); | |
| if( pHint->GetId() == SBX_HINT_DATAWANTED ) | |
| { | |
| // Anzahl Parameter -1 wegen Param0 == this | |
| sal_uInt32 nParamCount = pParams ? ((sal_uInt32)pParams->Count() - 1) : 0; | |
| Sequence<Any> args; | |
| sal_Bool bOutParams = sal_False; | |
| sal_uInt32 i; | |
| if( !bInvocation && mxUnoAccess.is() ) | |
| { | |
| // Infos holen | |
| const Sequence<ParamInfo>& rInfoSeq = pMeth->getParamInfos(); | |
| const ParamInfo* pParamInfos = rInfoSeq.getConstArray(); | |
| sal_uInt32 nUnoParamCount = rInfoSeq.getLength(); | |
| sal_uInt32 nAllocParamCount = nParamCount; | |
| // Ueberschuessige Parameter ignorieren, Alternative: Error schmeissen | |
| if( nParamCount > nUnoParamCount ) | |
| { | |
| nParamCount = nUnoParamCount; | |
| nAllocParamCount = nParamCount; | |
| } | |
| else if( nParamCount < nUnoParamCount ) | |
| { | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| { | |
| // Check types | |
| bool bError = false; | |
| for( i = nParamCount ; i < nUnoParamCount ; i++ ) | |
| { | |
| const ParamInfo& rInfo = pParamInfos[i]; | |
| const Reference< XIdlClass >& rxClass = rInfo.aType; | |
| if( rxClass->getTypeClass() != TypeClass_ANY ) | |
| { | |
| bError = true; | |
| StarBASIC::Error( SbERR_NOT_OPTIONAL ); | |
| } | |
| } | |
| if( !bError ) | |
| nAllocParamCount = nUnoParamCount; | |
| } | |
| } | |
| if( nAllocParamCount > 0 ) | |
| { | |
| args.realloc( nAllocParamCount ); | |
| Any* pAnyArgs = args.getArray(); | |
| for( i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| const ParamInfo& rInfo = pParamInfos[i]; | |
| const Reference< XIdlClass >& rxClass = rInfo.aType; | |
| //const XIdlClassRef& rxClass = pUnoParams[i]; | |
| com::sun::star::uno::Type aType( rxClass->getTypeClass(), rxClass->getName() ); | |
| // ACHTUNG: Bei den Sbx-Parametern den Offset nicht vergessen! | |
| pAnyArgs[i] = sbxToUnoValue( pParams->Get( (sal_uInt16)(i+1) ), aType ); | |
| // Wenn es nicht schon feststeht pruefen, ob Out-Parameter vorliegen | |
| if( !bOutParams ) | |
| { | |
| ParamMode aParamMode = rInfo.aMode; | |
| if( aParamMode != ParamMode_IN ) | |
| bOutParams = sal_True; | |
| } | |
| } | |
| } | |
| } | |
| else if( bInvocation && pParams && mxInvocation.is() ) | |
| { | |
| bool bOLEAutomation = true; | |
| // TODO: bOLEAutomation = xOLEAutomation.is() | |
| AutomationNamedArgsSbxArray* pArgNamesArray = NULL; | |
| if( bOLEAutomation ) | |
| pArgNamesArray = PTR_CAST(AutomationNamedArgsSbxArray,pParams); | |
| args.realloc( nParamCount ); | |
| Any* pAnyArgs = args.getArray(); | |
| bool bBlockConversionToSmallestType = pINST->IsCompatibility(); | |
| if( pArgNamesArray ) | |
| { | |
| Sequence< ::rtl::OUString >& rNameSeq = pArgNamesArray->getNames(); | |
| ::rtl::OUString* pNames = rNameSeq.getArray(); | |
| Any aValAny; | |
| for( i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| sal_uInt16 iSbx = (sal_uInt16)(i+1); | |
| // ACHTUNG: Bei den Sbx-Parametern den Offset nicht vergessen! | |
| aValAny = sbxToUnoValueImpl( pParams->Get( iSbx ), | |
| bBlockConversionToSmallestType ); | |
| ::rtl::OUString aParamName = pNames[iSbx]; | |
| if( !aParamName.isEmpty() ) | |
| { | |
| oleautomation::NamedArgument aNamedArgument; | |
| aNamedArgument.Name = aParamName; | |
| aNamedArgument.Value = aValAny; | |
| pAnyArgs[i] <<= aNamedArgument; | |
| } | |
| else | |
| { | |
| pAnyArgs[i] = aValAny; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| for( i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| // ACHTUNG: Bei den Sbx-Parametern den Offset nicht vergessen! | |
| pAnyArgs[i] = sbxToUnoValueImpl( pParams->Get( (sal_uInt16)(i+1) ), | |
| bBlockConversionToSmallestType ); | |
| } | |
| } | |
| } | |
| // Methode callen | |
| GetSbData()->bBlockCompilerError = sal_True; // #106433 Block compiler errors for API calls | |
| try | |
| { | |
| if( !bInvocation && mxUnoAccess.is() ) | |
| { | |
| Any aRetAny = pMeth->m_xUnoMethod->invoke( getUnoAny(), args ); | |
| // Wert von Uno nach Sbx uebernehmen | |
| unoToSbxValue( pVar, aRetAny ); | |
| // Muessen wir Out-Parameter zurueckkopieren? | |
| if( bOutParams ) | |
| { | |
| const Any* pAnyArgs = args.getConstArray(); | |
| // Infos holen | |
| const Sequence<ParamInfo>& rInfoSeq = pMeth->getParamInfos(); | |
| const ParamInfo* pParamInfos = rInfoSeq.getConstArray(); | |
| sal_uInt32 j; | |
| for( j = 0 ; j < nParamCount ; j++ ) | |
| { | |
| const ParamInfo& rInfo = pParamInfos[j]; | |
| ParamMode aParamMode = rInfo.aMode; | |
| if( aParamMode != ParamMode_IN ) | |
| unoToSbxValue( (SbxVariable*)pParams->Get( (sal_uInt16)(j+1) ), pAnyArgs[ j ] ); | |
| } | |
| } | |
| } | |
| else if( bInvocation && mxInvocation.is() ) | |
| { | |
| Reference< XDirectInvocation > xDirectInvoke; | |
| if ( pMeth->needsDirectInvocation() ) | |
| xDirectInvoke.set( mxInvocation, UNO_QUERY ); | |
| Any aRetAny; | |
| if ( xDirectInvoke.is() ) | |
| aRetAny = xDirectInvoke->directInvoke( pMeth->GetName(), args ); | |
| else | |
| { | |
| Sequence< sal_Int16 > OutParamIndex; | |
| Sequence< Any > OutParam; | |
| aRetAny = mxInvocation->invoke( pMeth->GetName(), args, OutParamIndex, OutParam ); | |
| const sal_Int16* pIndices = OutParamIndex.getConstArray(); | |
| sal_uInt32 nLen = OutParamIndex.getLength(); | |
| if( nLen ) | |
| { | |
| const Any* pNewValues = OutParam.getConstArray(); | |
| for( sal_uInt32 j = 0 ; j < nLen ; j++ ) | |
| { | |
| sal_Int16 iTarget = pIndices[ j ]; | |
| if( iTarget >= (sal_Int16)nParamCount ) | |
| break; | |
| unoToSbxValue( (SbxVariable*)pParams->Get( (sal_uInt16)(j+1) ), pNewValues[ j ] ); | |
| } | |
| } | |
| } | |
| // Wert von Uno nach Sbx uebernehmen | |
| unoToSbxValue( pVar, aRetAny ); | |
| } | |
| // #55460, Parameter hier weghauen, da das in unoToSbxValue() | |
| // bei Arrays wegen #54548 nicht mehr gemacht wird | |
| if( pParams ) | |
| pVar->SetParameters( NULL ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| GetSbData()->bBlockCompilerError = sal_False; // #106433 Unblock compiler errors | |
| } | |
| } | |
| else | |
| SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType ); | |
| } | |
| } | |
| #ifdef INVOCATION_ONLY | |
| // Aus USR | |
| Reference< XInvocation > createDynamicInvocationFor( const Any& aAny ); | |
| #endif | |
| SbUnoObject::SbUnoObject( const String& aName_, const Any& aUnoObj_ ) | |
| : SbxObject( aName_ ) | |
| , bNeedIntrospection( sal_True ) | |
| , bNativeCOMObject( sal_False ) | |
| { | |
| static Reference< XIntrospection > xIntrospection; | |
| // Default-Properties von Sbx wieder rauspruegeln | |
| Remove( XubString( RTL_CONSTASCII_USTRINGPARAM("Name") ), SbxCLASS_DONTCARE ); | |
| Remove( XubString( RTL_CONSTASCII_USTRINGPARAM("Parent") ), SbxCLASS_DONTCARE ); | |
| // Typ des Objekts pruefen | |
| TypeClass eType = aUnoObj_.getValueType().getTypeClass(); | |
| Reference< XInterface > x; | |
| if( eType == TypeClass_INTERFACE ) | |
| { | |
| // Interface aus dem Any besorgen | |
| x = *(Reference< XInterface >*)aUnoObj_.getValue(); | |
| if( !x.is() ) | |
| return; | |
| } | |
| Reference< XTypeProvider > xTypeProvider; | |
| #ifdef INVOCATION_ONLY | |
| // Invocation besorgen | |
| mxInvocation = createDynamicInvocationFor( aUnoObj_ ); | |
| #else | |
| // Hat das Object selbst eine Invocation? | |
| mxInvocation = Reference< XInvocation >( x, UNO_QUERY ); | |
| xTypeProvider = Reference< XTypeProvider >( x, UNO_QUERY ); | |
| #endif | |
| if( mxInvocation.is() ) | |
| { | |
| // #94670: This is WRONG because then the MaterialHolder doesn't refer | |
| // to the object implementing XInvocation but to the object passed to | |
| // the invocation service!!! | |
| // mxMaterialHolder = Reference< XMaterialHolder >::query( mxInvocation ); | |
| // ExactName holen | |
| mxExactNameInvocation = Reference< XExactName >::query( mxInvocation ); | |
| // Rest bezieht sich nur auf Introspection | |
| if( !xTypeProvider.is() ) | |
| { | |
| bNeedIntrospection = sal_False; | |
| return; | |
| } | |
| // Ignore introspection based members for COM objects to avoid | |
| // hiding of equally named COM symbols, e.g. XInvocation::getValue | |
| Reference< oleautomation::XAutomationObject > xAutomationObject( aUnoObj_, UNO_QUERY ); | |
| if( xAutomationObject.is() ) | |
| bNativeCOMObject = sal_True; | |
| } | |
| maTmpUnoObj = aUnoObj_; | |
| //*** Namen bestimmen *** | |
| sal_Bool bFatalError = sal_True; | |
| // Ist es ein Interface oder eine struct? | |
| sal_Bool bSetClassName = sal_False; | |
| String aClassName_; | |
| if( eType == TypeClass_STRUCT || eType == TypeClass_EXCEPTION ) | |
| { | |
| // Struct ist Ok | |
| bFatalError = sal_False; | |
| // #67173 Echten Klassen-Namen eintragen | |
| if( aName_.Len() == 0 ) | |
| { | |
| aClassName_ = String( aUnoObj_.getValueType().getTypeName() ); | |
| bSetClassName = sal_True; | |
| } | |
| } | |
| else if( eType == TypeClass_INTERFACE ) | |
| { | |
| // #70197 Interface geht immer durch Typ im Any | |
| bFatalError = sal_False; | |
| // Nach XIdlClassProvider-Interface fragen | |
| Reference< XIdlClassProvider > xClassProvider( x, UNO_QUERY ); | |
| if( xClassProvider.is() ) | |
| { | |
| // #67173 Echten Klassen-Namen eintragen | |
| if( aName_.Len() == 0 ) | |
| { | |
| Sequence< Reference< XIdlClass > > szClasses = xClassProvider->getIdlClasses(); | |
| sal_uInt32 nLen = szClasses.getLength(); | |
| if( nLen ) | |
| { | |
| const Reference< XIdlClass > xImplClass = szClasses.getConstArray()[ 0 ]; | |
| if( xImplClass.is() ) | |
| { | |
| aClassName_ = String( xImplClass->getName() ); | |
| bSetClassName = sal_True; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if( bSetClassName ) | |
| SetClassName( aClassName_ ); | |
| // Weder Interface noch Struct -> FatalError | |
| if( bFatalError ) | |
| { | |
| StarBASIC::FatalError( ERRCODE_BASIC_EXCEPTION ); | |
| return; | |
| } | |
| // #67781 Introspection erst on demand durchfuehren | |
| } | |
| SbUnoObject::~SbUnoObject() | |
| { | |
| } | |
| // #76470 Introspection on Demand durchfuehren | |
| void SbUnoObject::doIntrospection( void ) | |
| { | |
| static Reference< XIntrospection > xIntrospection; | |
| if( !bNeedIntrospection ) | |
| return; | |
| bNeedIntrospection = sal_False; | |
| if( !xIntrospection.is() ) | |
| { | |
| // Introspection-Service holen | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() ); | |
| if ( xFactory.is() ) | |
| { | |
| Reference< XInterface > xI = xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.beans.Introspection") ); | |
| if (xI.is()) | |
| xIntrospection = Reference< XIntrospection >::query( xI ); | |
| //xI->queryInterface( ::getCppuType( (const Reference< XIntrospection > *)0 ), xIntrospection ); | |
| } | |
| } | |
| if( !xIntrospection.is() ) | |
| { | |
| StarBASIC::FatalError( ERRCODE_BASIC_EXCEPTION ); | |
| return; | |
| } | |
| // Introspection durchfuehren | |
| try | |
| { | |
| mxUnoAccess = xIntrospection->inspect( maTmpUnoObj ); | |
| } | |
| catch( RuntimeException& e ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, implGetExceptionMsg( e ) ); | |
| } | |
| if( !mxUnoAccess.is() ) | |
| { | |
| // #51475 Ungueltiges Objekt kennzeichnen (kein mxMaterialHolder) | |
| return; | |
| } | |
| // MaterialHolder vom Access holen | |
| mxMaterialHolder = Reference< XMaterialHolder >::query( mxUnoAccess ); | |
| // ExactName vom Access holen | |
| mxExactName = Reference< XExactName >::query( mxUnoAccess ); | |
| } | |
| // #67781 Start einer Liste aller SbUnoMethod-Instanzen | |
| static SbUnoMethod* pFirst = NULL; | |
| void clearUnoMethodsForBasic( StarBASIC* pBasic ) | |
| { | |
| SbUnoMethod* pMeth = pFirst; | |
| while( pMeth ) | |
| { | |
| SbxObject* pObject = dynamic_cast< SbxObject* >( pMeth->GetParent() ); | |
| if ( pObject ) | |
| { | |
| StarBASIC* pModBasic = dynamic_cast< StarBASIC* >( pObject->GetParent() ); | |
| if ( pModBasic == pBasic ) | |
| { | |
| // for now the solution is to remove the method from the list and to clear it, | |
| // but in case the element should be correctly transferred to another StarBASIC, | |
| // we should either set module parent to NULL without clearing it, or even | |
| // set the new StarBASIC as the parent of the module | |
| // pObject->SetParent( NULL ); | |
| if( pMeth == pFirst ) | |
| pFirst = pMeth->pNext; | |
| else if( pMeth->pPrev ) | |
| pMeth->pPrev->pNext = pMeth->pNext; | |
| if( pMeth->pNext ) | |
| pMeth->pNext->pPrev = pMeth->pPrev; | |
| pMeth->pPrev = NULL; | |
| pMeth->pNext = NULL; | |
| pMeth->SbxValue::Clear(); | |
| pObject->SbxValue::Clear(); | |
| // start from the beginning after object clearing, the cycle will end since the method is removed each time | |
| pMeth = pFirst; | |
| } | |
| else | |
| pMeth = pMeth->pNext; | |
| } | |
| else | |
| pMeth = pMeth->pNext; | |
| } | |
| } | |
| void clearUnoMethods( void ) | |
| { | |
| SbUnoMethod* pMeth = pFirst; | |
| while( pMeth ) | |
| { | |
| pMeth->SbxValue::Clear(); | |
| pMeth = pMeth->pNext; | |
| } | |
| } | |
| SbUnoMethod::SbUnoMethod | |
| ( | |
| const String& aName_, | |
| SbxDataType eSbxType, | |
| Reference< XIdlMethod > xUnoMethod_, | |
| bool bInvocation, | |
| bool bDirect | |
| ) | |
| : SbxMethod( aName_, eSbxType ) | |
| , mbInvocation( bInvocation ) | |
| , mbDirectInvocation( bDirect ) | |
| { | |
| m_xUnoMethod = xUnoMethod_; | |
| pParamInfoSeq = NULL; | |
| // #67781 Methode in Liste eintragen | |
| pNext = pFirst; | |
| pPrev = NULL; | |
| pFirst = this; | |
| if( pNext ) | |
| pNext->pPrev = this; | |
| } | |
| SbUnoMethod::~SbUnoMethod() | |
| { | |
| delete pParamInfoSeq; | |
| if( this == pFirst ) | |
| pFirst = pNext; | |
| else if( pPrev ) | |
| pPrev->pNext = pNext; | |
| if( pNext ) | |
| pNext->pPrev = pPrev; | |
| } | |
| SbxInfo* SbUnoMethod::GetInfo() | |
| { | |
| if( !pInfo && m_xUnoMethod.is() ) | |
| { | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| { | |
| pInfo = new SbxInfo(); | |
| const Sequence<ParamInfo>& rInfoSeq = getParamInfos(); | |
| const ParamInfo* pParamInfos = rInfoSeq.getConstArray(); | |
| sal_uInt32 nParamCount = rInfoSeq.getLength(); | |
| for( sal_uInt32 i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| const ParamInfo& rInfo = pParamInfos[i]; | |
| ::rtl::OUString aParamName = rInfo.aName; | |
| // const Reference< XIdlClass >& rxClass = rInfo.aType; | |
| SbxDataType t = SbxVARIANT; | |
| sal_uInt16 nFlags_ = SBX_READ; | |
| pInfo->AddParam( aParamName, t, nFlags_ ); | |
| } | |
| } | |
| } | |
| return pInfo; | |
| } | |
| const Sequence<ParamInfo>& SbUnoMethod::getParamInfos( void ) | |
| { | |
| if( !pParamInfoSeq && m_xUnoMethod.is() ) | |
| { | |
| Sequence<ParamInfo> aTmp = m_xUnoMethod->getParameterInfos() ; | |
| pParamInfoSeq = new Sequence<ParamInfo>( aTmp ); | |
| } | |
| return *pParamInfoSeq; | |
| } | |
| SbUnoProperty::SbUnoProperty | |
| ( | |
| const String& aName_, | |
| SbxDataType eSbxType, | |
| const Property& aUnoProp_, | |
| sal_Int32 nId_, | |
| bool bInvocation | |
| ) | |
| : SbxProperty( aName_, eSbxType ) | |
| , aUnoProp( aUnoProp_ ) | |
| , nId( nId_ ) | |
| , mbInvocation( bInvocation ) | |
| { | |
| // #54548, bei bedarf Dummy-Array einsetzen, damit SbiRuntime::CheckArray() geht | |
| static SbxArrayRef xDummyArray = new SbxArray( SbxVARIANT ); | |
| if( eSbxType & SbxARRAY ) | |
| PutObject( xDummyArray ); | |
| } | |
| SbUnoProperty::~SbUnoProperty() | |
| {} | |
| SbxVariable* SbUnoObject::Find( const String& rName, SbxClassType t ) | |
| { | |
| static Reference< XIdlMethod > xDummyMethod; | |
| static Property aDummyProp; | |
| SbxVariable* pRes = SbxObject::Find( rName, t ); | |
| if( bNeedIntrospection ) | |
| doIntrospection(); | |
| // Neu 4.3.1999: Properties on Demand anlegen, daher jetzt perIntrospectionAccess | |
| // suchen, ob doch eine Property oder Methode des geforderten Namens existiert | |
| if( !pRes ) | |
| { | |
| ::rtl::OUString aUName( rName ); | |
| if( mxUnoAccess.is() && !bNativeCOMObject ) | |
| { | |
| if( mxExactName.is() ) | |
| { | |
| ::rtl::OUString aUExactName = mxExactName->getExactName( aUName ); | |
| if( !aUExactName.isEmpty() ) | |
| aUName = aUExactName; | |
| } | |
| if( mxUnoAccess->hasProperty( aUName, PropertyConcept::ALL - PropertyConcept::DANGEROUS ) ) | |
| { | |
| const Property& rProp = mxUnoAccess-> | |
| getProperty( aUName, PropertyConcept::ALL - PropertyConcept::DANGEROUS ); | |
| // #58455 Wenn die Property void sein kann, muss als Typ Variant gesetzt werden | |
| SbxDataType eSbxType; | |
| if( rProp.Attributes & PropertyAttribute::MAYBEVOID ) | |
| eSbxType = SbxVARIANT; | |
| else | |
| eSbxType = unoToSbxType( rProp.Type.getTypeClass() ); | |
| // Property anlegen und reinbraten | |
| SbxVariableRef xVarRef = new SbUnoProperty( rProp.Name, eSbxType, rProp, 0, false ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| pRes = xVarRef; | |
| } | |
| else if( mxUnoAccess->hasMethod( aUName, | |
| MethodConcept::ALL - MethodConcept::DANGEROUS ) ) | |
| { | |
| // Methode ansprechen | |
| const Reference< XIdlMethod >& rxMethod = mxUnoAccess-> | |
| getMethod( aUName, MethodConcept::ALL - MethodConcept::DANGEROUS ); | |
| // SbUnoMethode anlegen und reinbraten | |
| SbxVariableRef xMethRef = new SbUnoMethod( rxMethod->getName(), | |
| unoToSbxType( rxMethod->getReturnType() ), rxMethod, false ); | |
| QuickInsert( (SbxVariable*)xMethRef ); | |
| pRes = xMethRef; | |
| } | |
| // Wenn immer noch nichts gefunden wurde, muss geprueft werden, ob NameAccess vorliegt | |
| if( !pRes ) | |
| { | |
| try | |
| { | |
| Reference< XNameAccess > xNameAccess( mxUnoAccess->queryAdapter( ::getCppuType( (const Reference< XPropertySet > *)0 ) ), UNO_QUERY ); | |
| ::rtl::OUString aUName2( rName ); | |
| if( xNameAccess.is() && xNameAccess->hasByName( aUName2 ) ) | |
| { | |
| Any aAny = xNameAccess->getByName( aUName2 ); | |
| // ACHTUNG: Die hier erzeugte Variable darf wegen bei XNameAccess | |
| // nicht als feste Property in das Object aufgenommen werden und | |
| // wird daher nirgendwo gehalten. | |
| // Wenn das Probleme gibt, muss das kuenstlich gemacht werden oder | |
| // es muss eine Klasse SbUnoNameAccessProperty geschaffen werden, | |
| // bei der die Existenz staendig neu ueberprueft und die ggf. weg- | |
| // geworfen wird, wenn der Name nicht mehr gefunden wird. | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( pRes, aAny ); | |
| } | |
| } | |
| catch( NoSuchElementException& e ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, implGetExceptionMsg( e ) ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| // Anlegen, damit der Exception-Fehler nicht ueberschrieben wird | |
| if( !pRes ) | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| } | |
| if( !pRes && mxInvocation.is() ) | |
| { | |
| if( mxExactNameInvocation.is() ) | |
| { | |
| ::rtl::OUString aUExactName = mxExactNameInvocation->getExactName( aUName ); | |
| if( !aUExactName.isEmpty() ) | |
| aUName = aUExactName; | |
| } | |
| try | |
| { | |
| if( mxInvocation->hasProperty( aUName ) ) | |
| { | |
| // Property anlegen und reinbraten | |
| SbxVariableRef xVarRef = new SbUnoProperty( aUName, SbxVARIANT, aDummyProp, 0, true ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| pRes = xVarRef; | |
| } | |
| else if( mxInvocation->hasMethod( aUName ) ) | |
| { | |
| // SbUnoMethode anlegen und reinbraten | |
| SbxVariableRef xMethRef = new SbUnoMethod( aUName, SbxVARIANT, xDummyMethod, true ); | |
| QuickInsert( (SbxVariable*)xMethRef ); | |
| pRes = xMethRef; | |
| } | |
| else | |
| { | |
| Reference< XDirectInvocation > xDirectInvoke( mxInvocation, UNO_QUERY ); | |
| if ( xDirectInvoke.is() && xDirectInvoke->hasMember( aUName ) ) | |
| { | |
| SbxVariableRef xMethRef = new SbUnoMethod( aUName, SbxVARIANT, xDummyMethod, true, true ); | |
| QuickInsert( (SbxVariable*)xMethRef ); | |
| pRes = xMethRef; | |
| } | |
| } | |
| } | |
| catch( RuntimeException& e ) | |
| { | |
| // Anlegen, damit der Exception-Fehler nicht ueberschrieben wird | |
| if( !pRes ) | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, implGetExceptionMsg( e ) ); | |
| } | |
| } | |
| } | |
| // Ganz am Schluss noch pruefen, ob die Dbg_-Properties gemeint sind | |
| if( !pRes ) | |
| { | |
| if( rName.EqualsIgnoreCaseAscii( ID_DBG_SUPPORTEDINTERFACES ) || | |
| rName.EqualsIgnoreCaseAscii( ID_DBG_PROPERTIES ) || | |
| rName.EqualsIgnoreCaseAscii( ID_DBG_METHODS ) ) | |
| { | |
| // Anlegen | |
| implCreateDbgProperties(); | |
| // Jetzt muessen sie regulaer gefunden werden | |
| pRes = SbxObject::Find( rName, SbxCLASS_DONTCARE ); | |
| } | |
| } | |
| return pRes; | |
| } | |
| // Hilfs-Methode zum Anlegen der dbg_-Properties | |
| void SbUnoObject::implCreateDbgProperties( void ) | |
| { | |
| Property aProp; | |
| // Id == -1: Implementierte Interfaces gemaess ClassProvider anzeigen | |
| SbxVariableRef xVarRef = new SbUnoProperty( String(RTL_CONSTASCII_USTRINGPARAM(ID_DBG_SUPPORTEDINTERFACES)), SbxSTRING, aProp, -1, false ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| // Id == -2: Properties ausgeben | |
| xVarRef = new SbUnoProperty( String(RTL_CONSTASCII_USTRINGPARAM(ID_DBG_PROPERTIES)), SbxSTRING, aProp, -2, false ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| // Id == -3: Methoden ausgeben | |
| xVarRef = new SbUnoProperty( String(RTL_CONSTASCII_USTRINGPARAM(ID_DBG_METHODS)), SbxSTRING, aProp, -3, false ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| } | |
| void SbUnoObject::implCreateAll( void ) | |
| { | |
| // Bestehende Methoden und Properties alle wieder wegwerfen | |
| pMethods = new SbxArray; | |
| pProps = new SbxArray; | |
| if( bNeedIntrospection ) doIntrospection(); | |
| // Instrospection besorgen | |
| Reference< XIntrospectionAccess > xAccess = mxUnoAccess; | |
| if( !xAccess.is() || bNativeCOMObject ) | |
| { | |
| if( mxInvocation.is() ) | |
| xAccess = mxInvocation->getIntrospection(); | |
| else if( bNativeCOMObject ) | |
| return; | |
| } | |
| if( !xAccess.is() ) | |
| return; | |
| // Properties anlegen | |
| Sequence<Property> props = xAccess->getProperties( PropertyConcept::ALL - PropertyConcept::DANGEROUS ); | |
| sal_uInt32 nPropCount = props.getLength(); | |
| const Property* pProps_ = props.getConstArray(); | |
| sal_uInt32 i; | |
| for( i = 0 ; i < nPropCount ; i++ ) | |
| { | |
| const Property& rProp = pProps_[ i ]; | |
| // #58455 Wenn die Property void sein kann, muss als Typ Variant gesetzt werden | |
| SbxDataType eSbxType; | |
| if( rProp.Attributes & PropertyAttribute::MAYBEVOID ) | |
| eSbxType = SbxVARIANT; | |
| else | |
| eSbxType = unoToSbxType( rProp.Type.getTypeClass() ); | |
| // Property anlegen und reinbraten | |
| SbxVariableRef xVarRef = new SbUnoProperty( rProp.Name, eSbxType, rProp, i, false ); | |
| QuickInsert( (SbxVariable*)xVarRef ); | |
| } | |
| // Dbg_-Properties anlegen | |
| implCreateDbgProperties(); | |
| // Methoden anlegen | |
| Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods | |
| ( MethodConcept::ALL - MethodConcept::DANGEROUS ); | |
| sal_uInt32 nMethCount = aMethodSeq.getLength(); | |
| const Reference< XIdlMethod >* pMethods_ = aMethodSeq.getConstArray(); | |
| for( i = 0 ; i < nMethCount ; i++ ) | |
| { | |
| // Methode ansprechen | |
| const Reference< XIdlMethod >& rxMethod = pMethods_[i]; | |
| // SbUnoMethode anlegen und reinbraten | |
| SbxVariableRef xMethRef = new SbUnoMethod | |
| ( rxMethod->getName(), unoToSbxType( rxMethod->getReturnType() ), rxMethod, false ); | |
| QuickInsert( (SbxVariable*)xMethRef ); | |
| } | |
| } | |
| // Wert rausgeben | |
| Any SbUnoObject::getUnoAny( void ) | |
| { | |
| Any aRetAny; | |
| if( bNeedIntrospection ) doIntrospection(); | |
| if( mxMaterialHolder.is() ) | |
| aRetAny = mxMaterialHolder->getMaterial(); | |
| else if( mxInvocation.is() ) | |
| aRetAny <<= mxInvocation; | |
| return aRetAny; | |
| } | |
| // Hilfsmethode zum Anlegen einer Uno-Struct per CoreReflection | |
| SbUnoObject* Impl_CreateUnoStruct( const String& aClassName ) | |
| { | |
| // CoreReflection holen | |
| Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl(); | |
| if( !xCoreReflection.is() ) | |
| return NULL; | |
| // Klasse suchen | |
| Reference< XIdlClass > xClass; | |
| Reference< XHierarchicalNameAccess > xHarryName = | |
| getCoreReflection_HierarchicalNameAccess_Impl(); | |
| if( xHarryName.is() && xHarryName->hasByHierarchicalName( aClassName ) ) | |
| xClass = xCoreReflection->forName( aClassName ); | |
| if( !xClass.is() ) | |
| return NULL; | |
| // Ist es ueberhaupt ein struct? | |
| TypeClass eType = xClass->getTypeClass(); | |
| if ( ( eType != TypeClass_STRUCT ) && ( eType != TypeClass_EXCEPTION ) ) | |
| return NULL; | |
| // Instanz erzeugen | |
| Any aNewAny; | |
| xClass->createObject( aNewAny ); | |
| // SbUnoObject daraus basteln | |
| SbUnoObject* pUnoObj = new SbUnoObject( aClassName, aNewAny ); | |
| return pUnoObj; | |
| } | |
| // Factory-Klasse fuer das Anlegen von Uno-Structs per DIM AS NEW | |
| SbxBase* SbUnoFactory::Create( sal_uInt16, sal_uInt32 ) | |
| { | |
| // Ueber SbxId laeuft in Uno nix | |
| return NULL; | |
| } | |
| SbxObject* SbUnoFactory::CreateObject( const String& rClassName ) | |
| { | |
| return Impl_CreateUnoStruct( rClassName ); | |
| } | |
| // Provisorische Schnittstelle fuer UNO-Anbindung | |
| // Liefert ein SbxObject, das ein Uno-Interface wrappt | |
| SbxObjectRef GetSbUnoObject( const String& aName, const Any& aUnoObj_ ) | |
| { | |
| return new SbUnoObject( aName, aUnoObj_ ); | |
| } | |
| // Force creation of all properties for debugging | |
| void createAllObjectProperties( SbxObject* pObj ) | |
| { | |
| if( !pObj ) | |
| return; | |
| SbUnoObject* pUnoObj = PTR_CAST(SbUnoObject,pObj); | |
| if( pUnoObj ) | |
| pUnoObj->createAllProperties(); | |
| else | |
| pObj->GetAll( SbxCLASS_DONTCARE ); | |
| } | |
| void RTL_Impl_CreateUnoStruct( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| // Wir brauchen mindestens 1 Parameter | |
| if ( rPar.Count() < 2 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Klassen-Name der struct holen | |
| String aClassName = rPar.Get(1)->GetString(); | |
| // Versuchen, gleichnamige Struct zu erzeugen | |
| SbUnoObjectRef xUnoObj = Impl_CreateUnoStruct( aClassName ); | |
| if( !xUnoObj ) | |
| return; | |
| // Objekt zurueckliefern | |
| SbxVariableRef refVar = rPar.Get(0); | |
| refVar->PutObject( (SbUnoObject*)xUnoObj ); | |
| } | |
| void RTL_Impl_CreateUnoService( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| // Wir brauchen mindestens 1 Parameter | |
| if ( rPar.Count() < 2 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Klassen-Name der struct holen | |
| String aServiceName = rPar.Get(1)->GetString(); | |
| // Service suchen und instanzieren | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() ); | |
| Reference< XInterface > xInterface; | |
| if ( xFactory.is() ) | |
| { | |
| try | |
| { | |
| xInterface = xFactory->createInstance( aServiceName ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| SbxVariableRef refVar = rPar.Get(0); | |
| if( xInterface.is() ) | |
| { | |
| Any aAny; | |
| aAny <<= xInterface; | |
| // SbUnoObject daraus basteln und zurueckliefern | |
| SbUnoObjectRef xUnoObj = new SbUnoObject( aServiceName, aAny ); | |
| if( xUnoObj->getUnoAny().getValueType().getTypeClass() != TypeClass_VOID ) | |
| { | |
| // Objekt zurueckliefern | |
| refVar->PutObject( (SbUnoObject*)xUnoObj ); | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| void RTL_Impl_CreateUnoServiceWithArguments( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| // Wir brauchen mindestens 2 Parameter | |
| if ( rPar.Count() < 3 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Klassen-Name der struct holen | |
| String aServiceName = rPar.Get(1)->GetString(); | |
| Any aArgAsAny = sbxToUnoValue( rPar.Get(2), | |
| getCppuType( (Sequence<Any>*)0 ) ); | |
| Sequence< Any > aArgs; | |
| aArgAsAny >>= aArgs; | |
| // Service suchen und instanzieren | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() ); | |
| Reference< XInterface > xInterface; | |
| if ( xFactory.is() ) | |
| { | |
| try | |
| { | |
| xInterface = xFactory->createInstanceWithArguments( aServiceName, aArgs ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| SbxVariableRef refVar = rPar.Get(0); | |
| if( xInterface.is() ) | |
| { | |
| Any aAny; | |
| aAny <<= xInterface; | |
| // SbUnoObject daraus basteln und zurueckliefern | |
| SbUnoObjectRef xUnoObj = new SbUnoObject( aServiceName, aAny ); | |
| if( xUnoObj->getUnoAny().getValueType().getTypeClass() != TypeClass_VOID ) | |
| { | |
| // Objekt zurueckliefern | |
| refVar->PutObject( (SbUnoObject*)xUnoObj ); | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| void RTL_Impl_GetProcessServiceManager( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| SbxVariableRef refVar = rPar.Get(0); | |
| // Globalen Service-Manager holen | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() ); | |
| if( xFactory.is() ) | |
| { | |
| Any aAny; | |
| aAny <<= xFactory; | |
| // SbUnoObject daraus basteln und zurueckliefern | |
| SbUnoObjectRef xUnoObj = new SbUnoObject( String( RTL_CONSTASCII_USTRINGPARAM("ProcessServiceManager") ), aAny ); | |
| refVar->PutObject( (SbUnoObject*)xUnoObj ); | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| void RTL_Impl_HasInterfaces( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| // Wir brauchen mindestens 2 Parameter | |
| sal_uInt16 nParCount = rPar.Count(); | |
| if( nParCount < 3 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Variable fuer Rueckgabewert | |
| SbxVariableRef refVar = rPar.Get(0); | |
| refVar->PutBool( sal_False ); | |
| // Uno-Objekt holen | |
| SbxBaseRef pObj = (SbxBase*)rPar.Get( 1 )->GetObject(); | |
| if( !(pObj && pObj->ISA(SbUnoObject)) ) | |
| return; | |
| Any aAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny(); | |
| TypeClass eType = aAny.getValueType().getTypeClass(); | |
| if( eType != TypeClass_INTERFACE ) | |
| return; | |
| // Interface aus dem Any besorgen | |
| Reference< XInterface > x = *(Reference< XInterface >*)aAny.getValue(); | |
| // CoreReflection holen | |
| Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl(); | |
| if( !xCoreReflection.is() ) | |
| return; | |
| for( sal_uInt16 i = 2 ; i < nParCount ; i++ ) | |
| { | |
| // Interface-Name der struct holen | |
| String aIfaceName = rPar.Get( i )->GetString(); | |
| // Klasse suchen | |
| Reference< XIdlClass > xClass = xCoreReflection->forName( aIfaceName ); | |
| if( !xClass.is() ) | |
| return; | |
| // Pruefen, ob das Interface unterstuetzt wird | |
| ::rtl::OUString aClassName = xClass->getName(); | |
| Type aClassType( xClass->getTypeClass(), aClassName.getStr() ); | |
| if( !x->queryInterface( aClassType ).hasValue() ) | |
| return; | |
| } | |
| // Alles hat geklappt, dann sal_True liefern | |
| refVar->PutBool( sal_True ); | |
| } | |
| void RTL_Impl_IsUnoStruct( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| // Wir brauchen mindestens 1 Parameter | |
| if ( rPar.Count() < 2 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Variable fuer Rueckgabewert | |
| SbxVariableRef refVar = rPar.Get(0); | |
| refVar->PutBool( sal_False ); | |
| // Uno-Objekt holen | |
| SbxVariableRef xParam = rPar.Get( 1 ); | |
| if( !xParam->IsObject() ) | |
| return; | |
| SbxBaseRef pObj = (SbxBase*)rPar.Get( 1 )->GetObject(); | |
| if( !(pObj && pObj->ISA(SbUnoObject)) ) | |
| return; | |
| Any aAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny(); | |
| TypeClass eType = aAny.getValueType().getTypeClass(); | |
| if( eType == TypeClass_STRUCT ) | |
| refVar->PutBool( sal_True ); | |
| } | |
| void RTL_Impl_EqualUnoObjects( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| if ( rPar.Count() < 3 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Variable fuer Rueckgabewert | |
| SbxVariableRef refVar = rPar.Get(0); | |
| refVar->PutBool( sal_False ); | |
| // Uno-Objekte holen | |
| SbxVariableRef xParam1 = rPar.Get( 1 ); | |
| if( !xParam1->IsObject() ) | |
| return; | |
| SbxBaseRef pObj1 = (SbxBase*)xParam1->GetObject(); | |
| if( !(pObj1 && pObj1->ISA(SbUnoObject)) ) | |
| return; | |
| Any aAny1 = ((SbUnoObject*)(SbxBase*)pObj1)->getUnoAny(); | |
| TypeClass eType1 = aAny1.getValueType().getTypeClass(); | |
| if( eType1 != TypeClass_INTERFACE ) | |
| return; | |
| Reference< XInterface > x1; | |
| aAny1 >>= x1; | |
| //XInterfaceRef x1 = *(XInterfaceRef*)aAny1.get(); | |
| SbxVariableRef xParam2 = rPar.Get( 2 ); | |
| if( !xParam2->IsObject() ) | |
| return; | |
| SbxBaseRef pObj2 = (SbxBase*)xParam2->GetObject(); | |
| if( !(pObj2 && pObj2->ISA(SbUnoObject)) ) | |
| return; | |
| Any aAny2 = ((SbUnoObject*)(SbxBase*)pObj2)->getUnoAny(); | |
| TypeClass eType2 = aAny2.getValueType().getTypeClass(); | |
| if( eType2 != TypeClass_INTERFACE ) | |
| return; | |
| Reference< XInterface > x2; | |
| aAny2 >>= x2; | |
| //XInterfaceRef x2 = *(XInterfaceRef*)aAny2.get(); | |
| if( x1 == x2 ) | |
| refVar->PutBool( sal_True ); | |
| } | |
| typedef std::hash_map< ::rtl::OUString, std::vector< ::rtl::OUString >, ::rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > ModuleHash; | |
| // helper wrapper function to interact with TypeProvider and | |
| // XTypeDescriptionEnumerationAccess. | |
| // if it fails for whatever reason | |
| // returned Reference<> be null e.g. .is() will be false | |
| Reference< XTypeDescriptionEnumeration > | |
| getTypeDescriptorEnumeration( const ::rtl::OUString& sSearchRoot, | |
| const Sequence< TypeClass >& types, TypeDescriptionSearchDepth depth ) | |
| { | |
| Reference< XTypeDescriptionEnumeration > xEnum; | |
| Reference< XTypeDescriptionEnumerationAccess> xTypeEnumAccess( getTypeProvider_Impl(), UNO_QUERY ); | |
| if ( xTypeEnumAccess.is() ) | |
| { | |
| try | |
| { | |
| xEnum = xTypeEnumAccess->createTypeDescriptionEnumeration( | |
| sSearchRoot, types, depth ); | |
| } | |
| catch( NoSuchTypeNameException& /*nstne*/ ) {} | |
| catch( InvalidTypeNameException& /*nstne*/ ) {} | |
| } | |
| return xEnum; | |
| } | |
| typedef std::hash_map< ::rtl::OUString, Any, ::rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > VBAConstantsHash; | |
| SbxVariable* getVBAConstant( const String& rName ) | |
| { | |
| SbxVariable* pConst = NULL; | |
| static VBAConstantsHash aConstCache; | |
| static bool isInited = false; | |
| if ( !isInited ) | |
| { | |
| Sequence< TypeClass > types(1); | |
| types[ 0 ] = TypeClass_CONSTANTS; | |
| Reference< XTypeDescriptionEnumeration > xEnum = getTypeDescriptorEnumeration( defaultNameSpace, types, TypeDescriptionSearchDepth_INFINITE ); | |
| if ( !xEnum.is() ) | |
| return NULL; | |
| while ( xEnum->hasMoreElements() ) | |
| { | |
| Reference< XConstantsTypeDescription > xConstants( xEnum->nextElement(), UNO_QUERY ); | |
| if ( xConstants.is() ) | |
| { | |
| Sequence< Reference< XConstantTypeDescription > > aConsts = xConstants->getConstants(); | |
| Reference< XConstantTypeDescription >* pSrc = aConsts.getArray(); | |
| sal_Int32 nLen = aConsts.getLength(); | |
| for ( sal_Int32 index =0; index<nLen; ++pSrc, ++index ) | |
| { | |
| Reference< XConstantTypeDescription >& rXConst = | |
| *pSrc; | |
| ::rtl::OUString sFullName = rXConst->getName(); | |
| sal_Int32 indexLastDot = sFullName.lastIndexOf('.'); | |
| ::rtl::OUString sLeafName; | |
| if ( indexLastDot > -1 ) | |
| sLeafName = sFullName.copy( indexLastDot + 1); | |
| aConstCache[ sLeafName.toAsciiLowerCase() ] = rXConst->getConstantValue(); | |
| } | |
| } | |
| } | |
| isInited = true; | |
| } | |
| ::rtl::OUString sKey( rName ); | |
| VBAConstantsHash::const_iterator it = aConstCache.find( sKey.toAsciiLowerCase() ); | |
| if ( it != aConstCache.end() ) | |
| { | |
| pConst = new SbxVariable( SbxVARIANT ); | |
| pConst->SetName( rName ); | |
| unoToSbxValue( pConst, it->second ); | |
| } | |
| return pConst; | |
| } | |
| // Funktion, um einen globalen Bezeichner im | |
| // UnoScope zu suchen und fuer Sbx zu wrappen | |
| SbUnoClass* findUnoClass( const String& rName ) | |
| { | |
| // #105550 Check if module exists | |
| SbUnoClass* pUnoClass = NULL; | |
| Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl(); | |
| if( xTypeAccess->hasByHierarchicalName( rName ) ) | |
| { | |
| Any aRet = xTypeAccess->getByHierarchicalName( rName ); | |
| Reference< XTypeDescription > xTypeDesc; | |
| aRet >>= xTypeDesc; | |
| if( xTypeDesc.is() ) | |
| { | |
| TypeClass eTypeClass = xTypeDesc->getTypeClass(); | |
| if( eTypeClass == TypeClass_MODULE || eTypeClass == TypeClass_CONSTANTS ) | |
| pUnoClass = new SbUnoClass( rName ); | |
| } | |
| } | |
| return pUnoClass; | |
| } | |
| SbxVariable* SbUnoClass::Find( const XubString& rName, SbxClassType t ) | |
| { | |
| (void)t; | |
| SbxVariable* pRes = SbxObject::Find( rName, SbxCLASS_VARIABLE ); | |
| // Wenn nichts gefunden wird, ist das Sub-Modul noch nicht bekannt | |
| if( !pRes ) | |
| { | |
| // Wenn es schon eine Klasse ist, nach einen Feld fragen | |
| if( m_xClass.is() ) | |
| { | |
| // Ist es ein Field | |
| ::rtl::OUString aUStr( rName ); | |
| Reference< XIdlField > xField = m_xClass->getField( aUStr ); | |
| Reference< XIdlClass > xClass; | |
| if( xField.is() ) | |
| { | |
| try | |
| { | |
| Any aAny; | |
| aAny = xField->get( aAny ); | |
| // Nach Sbx wandeln | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| pRes->SetName( rName ); | |
| unoToSbxValue( pRes, aAny ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // Vollqualifizierten Namen erweitern | |
| String aNewName = GetName(); | |
| aNewName.AppendAscii( "." ); | |
| aNewName += rName; | |
| // CoreReflection holen | |
| Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl(); | |
| if( xCoreReflection.is() ) | |
| { | |
| // Ist es eine Konstante? | |
| Reference< XHierarchicalNameAccess > xHarryName( xCoreReflection, UNO_QUERY ); | |
| if( xHarryName.is() ) | |
| { | |
| try | |
| { | |
| Any aValue = xHarryName->getByHierarchicalName( aNewName ); | |
| TypeClass eType = aValue.getValueType().getTypeClass(); | |
| // Interface gefunden? Dann ist es eine Klasse | |
| if( eType == TypeClass_INTERFACE ) | |
| { | |
| Reference< XInterface > xIface = *(Reference< XInterface >*)aValue.getValue(); | |
| Reference< XIdlClass > xClass( xIface, UNO_QUERY ); | |
| if( xClass.is() ) | |
| { | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| SbxObjectRef xWrapper = (SbxObject*)new SbUnoClass( aNewName, xClass ); | |
| pRes->PutObject( xWrapper ); | |
| } | |
| } | |
| else | |
| { | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( pRes, aValue ); | |
| } | |
| } | |
| catch( NoSuchElementException& e1 ) | |
| { | |
| String aMsg = implGetExceptionMsg( e1 ); | |
| } | |
| } | |
| // Sonst wieder als Klasse annehmen | |
| if( !pRes ) | |
| { | |
| SbUnoClass* pNewClass = findUnoClass( aNewName ); | |
| if( pNewClass ) | |
| { | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| SbxObjectRef xWrapper = (SbxObject*)pNewClass; | |
| pRes->PutObject( xWrapper ); | |
| } | |
| } | |
| // An UNO service? | |
| if( !pRes ) | |
| { | |
| SbUnoService* pUnoService = findUnoService( aNewName ); | |
| if( pUnoService ) | |
| { | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| SbxObjectRef xWrapper = (SbxObject*)pUnoService; | |
| pRes->PutObject( xWrapper ); | |
| } | |
| } | |
| // An UNO singleton? | |
| if( !pRes ) | |
| { | |
| SbUnoSingleton* pUnoSingleton = findUnoSingleton( aNewName ); | |
| if( pUnoSingleton ) | |
| { | |
| pRes = new SbxVariable( SbxVARIANT ); | |
| SbxObjectRef xWrapper = (SbxObject*)pUnoSingleton; | |
| pRes->PutObject( xWrapper ); | |
| } | |
| } | |
| } | |
| } | |
| if( pRes ) | |
| { | |
| pRes->SetName( rName ); | |
| // Variable einfuegen, damit sie spaeter im Find gefunden wird | |
| QuickInsert( pRes ); | |
| // Uns selbst gleich wieder als Listener rausnehmen, | |
| // die Werte sind alle konstant | |
| if( pRes->IsBroadcaster() ) | |
| EndListening( pRes->GetBroadcaster(), sal_True ); | |
| } | |
| } | |
| return pRes; | |
| } | |
| SbUnoService* findUnoService( const String& rName ) | |
| { | |
| SbUnoService* pSbUnoService = NULL; | |
| Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl(); | |
| if( xTypeAccess->hasByHierarchicalName( rName ) ) | |
| { | |
| Any aRet = xTypeAccess->getByHierarchicalName( rName ); | |
| Reference< XTypeDescription > xTypeDesc; | |
| aRet >>= xTypeDesc; | |
| if( xTypeDesc.is() ) | |
| { | |
| TypeClass eTypeClass = xTypeDesc->getTypeClass(); | |
| if( eTypeClass == TypeClass_SERVICE ) | |
| { | |
| Reference< XServiceTypeDescription2 > xServiceTypeDesc( xTypeDesc, UNO_QUERY ); | |
| if( xServiceTypeDesc.is() ) | |
| pSbUnoService = new SbUnoService( rName, xServiceTypeDesc ); | |
| } | |
| } | |
| } | |
| return pSbUnoService; | |
| } | |
| SbxVariable* SbUnoService::Find( const String& rName, SbxClassType ) | |
| { | |
| SbxVariable* pRes = SbxObject::Find( rName, SbxCLASS_METHOD ); | |
| if( !pRes ) | |
| { | |
| // Wenn es schon eine Klasse ist, nach einen Feld fragen | |
| if( m_bNeedsInit && m_xServiceTypeDesc.is() ) | |
| { | |
| m_bNeedsInit = false; | |
| Sequence< Reference< XServiceConstructorDescription > > aSCDSeq = m_xServiceTypeDesc->getConstructors(); | |
| const Reference< XServiceConstructorDescription >* pCtorSeq = aSCDSeq.getConstArray(); | |
| int nCtorCount = aSCDSeq.getLength(); | |
| for( int i = 0 ; i < nCtorCount ; ++i ) | |
| { | |
| Reference< XServiceConstructorDescription > xCtor = pCtorSeq[i]; | |
| String aName( xCtor->getName() ); | |
| if( !aName.Len() ) | |
| { | |
| if( xCtor->isDefaultConstructor() ) | |
| aName = String::CreateFromAscii( "create" ); | |
| } | |
| if( aName.Len() ) | |
| { | |
| // Create and insert SbUnoServiceCtor | |
| SbxVariableRef xSbCtorRef = new SbUnoServiceCtor( aName, xCtor ); | |
| QuickInsert( (SbxVariable*)xSbCtorRef ); | |
| } | |
| } | |
| pRes = SbxObject::Find( rName, SbxCLASS_METHOD ); | |
| } | |
| } | |
| return pRes; | |
| } | |
| void SbUnoService::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType, | |
| const SfxHint& rHint, const TypeId& rHintType ) | |
| { | |
| const SbxHint* pHint = PTR_CAST(SbxHint,&rHint); | |
| if( pHint ) | |
| { | |
| SbxVariable* pVar = pHint->GetVar(); | |
| SbxArray* pParams = pVar->GetParameters(); | |
| SbUnoServiceCtor* pUnoCtor = PTR_CAST(SbUnoServiceCtor,pVar); | |
| if( pUnoCtor && pHint->GetId() == SBX_HINT_DATAWANTED ) | |
| { | |
| // Parameter count -1 because of Param0 == this | |
| sal_uInt32 nParamCount = pParams ? ((sal_uInt32)pParams->Count() - 1) : 0; | |
| Sequence<Any> args; | |
| sal_Bool bOutParams = sal_False; | |
| Reference< XServiceConstructorDescription > xCtor = pUnoCtor->getServiceCtorDesc(); | |
| Sequence< Reference< XParameter > > aParameterSeq = xCtor->getParameters(); | |
| const Reference< XParameter >* pParameterSeq = aParameterSeq.getConstArray(); | |
| sal_uInt32 nUnoParamCount = aParameterSeq.getLength(); | |
| // Default: Ignore not needed parameters | |
| bool bParameterError = false; | |
| // Is the last parameter a rest parameter? | |
| bool bRestParameterMode = false; | |
| if( nUnoParamCount > 0 ) | |
| { | |
| Reference< XParameter > xLastParam = pParameterSeq[ nUnoParamCount - 1 ]; | |
| if( xLastParam.is() ) | |
| { | |
| if( xLastParam->isRestParameter() ) | |
| bRestParameterMode = true; | |
| } | |
| } | |
| // Too many parameters with context as first parameter? | |
| sal_uInt16 nSbxParameterOffset = 1; | |
| sal_uInt16 nParameterOffsetByContext = 0; | |
| Reference < XComponentContext > xFirstParamContext; | |
| if( nParamCount > nUnoParamCount ) | |
| { | |
| // Check if first parameter is a context and use it | |
| // then in createInstanceWithArgumentsAndContext | |
| Any aArg0 = sbxToUnoValue( pParams->Get( nSbxParameterOffset ) ); | |
| if( (aArg0 >>= xFirstParamContext) && xFirstParamContext.is() ) | |
| nParameterOffsetByContext = 1; | |
| } | |
| sal_uInt32 nEffectiveParamCount = nParamCount - nParameterOffsetByContext; | |
| sal_uInt32 nAllocParamCount = nEffectiveParamCount; | |
| if( nEffectiveParamCount > nUnoParamCount ) | |
| { | |
| if( !bRestParameterMode ) | |
| { | |
| nEffectiveParamCount = nUnoParamCount; | |
| nAllocParamCount = nUnoParamCount; | |
| } | |
| } | |
| // Not enough parameters? | |
| else if( nUnoParamCount > nEffectiveParamCount ) | |
| { | |
| // RestParameterMode only helps if one (the last) parameter is missing | |
| int nDiff = nUnoParamCount - nEffectiveParamCount; | |
| if( !bRestParameterMode || nDiff > 1 ) | |
| { | |
| bParameterError = true; | |
| StarBASIC::Error( SbERR_NOT_OPTIONAL ); | |
| } | |
| } | |
| if( !bParameterError ) | |
| { | |
| if( nAllocParamCount > 0 ) | |
| { | |
| args.realloc( nAllocParamCount ); | |
| Any* pAnyArgs = args.getArray(); | |
| for( sal_uInt32 i = 0 ; i < nEffectiveParamCount ; i++ ) | |
| { | |
| sal_uInt16 iSbx = (sal_uInt16)(i + nSbxParameterOffset + nParameterOffsetByContext); | |
| // bRestParameterMode allows nEffectiveParamCount > nUnoParamCount | |
| Reference< XParameter > xParam; | |
| if( i < nUnoParamCount ) | |
| { | |
| xParam = pParameterSeq[i]; | |
| if( !xParam.is() ) | |
| continue; | |
| Reference< XTypeDescription > xParamTypeDesc = xParam->getType(); | |
| if( !xParamTypeDesc.is() ) | |
| continue; | |
| com::sun::star::uno::Type aType( xParamTypeDesc->getTypeClass(), xParamTypeDesc->getName() ); | |
| // sbx parameter needs offset 1 | |
| pAnyArgs[i] = sbxToUnoValue( pParams->Get( iSbx ), aType ); | |
| // Check for out parameter if not already done | |
| if( !bOutParams ) | |
| { | |
| if( xParam->isOut() ) | |
| bOutParams = sal_True; | |
| } | |
| } | |
| else | |
| { | |
| pAnyArgs[i] = sbxToUnoValue( pParams->Get( iSbx ) ); | |
| } | |
| } | |
| } | |
| // "Call" ctor using createInstanceWithArgumentsAndContext | |
| Reference < XComponentContext > xContext; | |
| if( xFirstParamContext.is() ) | |
| { | |
| xContext = xFirstParamContext; | |
| } | |
| else | |
| { | |
| Reference < XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW ); | |
| xContext.set( xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" )) ), UNO_QUERY_THROW ); | |
| } | |
| Reference< XMultiComponentFactory > xServiceMgr( xContext->getServiceManager() ); | |
| Any aRetAny; | |
| if( xServiceMgr.is() ) | |
| { | |
| String aServiceName = GetName(); | |
| Reference < XInterface > xRet; | |
| try | |
| { | |
| xRet = xServiceMgr->createInstanceWithArgumentsAndContext( aServiceName, args, xContext ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| aRetAny <<= xRet; | |
| } | |
| unoToSbxValue( pVar, aRetAny ); | |
| // Copy back out parameters? | |
| if( bOutParams ) | |
| { | |
| const Any* pAnyArgs = args.getConstArray(); | |
| for( sal_uInt32 j = 0 ; j < nUnoParamCount ; j++ ) | |
| { | |
| Reference< XParameter > xParam = pParameterSeq[j]; | |
| if( !xParam.is() ) | |
| continue; | |
| if( xParam->isOut() ) | |
| unoToSbxValue( (SbxVariable*)pParams->Get( (sal_uInt16)(j+1) ), pAnyArgs[ j ] ); | |
| } | |
| } | |
| } | |
| } | |
| else | |
| SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType ); | |
| } | |
| } | |
| static SbUnoServiceCtor* pFirstCtor = NULL; | |
| void clearUnoServiceCtors( void ) | |
| { | |
| SbUnoServiceCtor* pCtor = pFirstCtor; | |
| while( pCtor ) | |
| { | |
| pCtor->SbxValue::Clear(); | |
| pCtor = pCtor->pNext; | |
| } | |
| } | |
| SbUnoServiceCtor::SbUnoServiceCtor( const String& aName_, Reference< XServiceConstructorDescription > xServiceCtorDesc ) | |
| : SbxMethod( aName_, SbxOBJECT ) | |
| , m_xServiceCtorDesc( xServiceCtorDesc ) | |
| { | |
| } | |
| SbUnoServiceCtor::~SbUnoServiceCtor() | |
| { | |
| } | |
| SbxInfo* SbUnoServiceCtor::GetInfo() | |
| { | |
| SbxInfo* pRet = NULL; | |
| return pRet; | |
| } | |
| SbUnoSingleton* findUnoSingleton( const String& rName ) | |
| { | |
| SbUnoSingleton* pSbUnoSingleton = NULL; | |
| Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl(); | |
| if( xTypeAccess->hasByHierarchicalName( rName ) ) | |
| { | |
| Any aRet = xTypeAccess->getByHierarchicalName( rName ); | |
| Reference< XTypeDescription > xTypeDesc; | |
| aRet >>= xTypeDesc; | |
| if( xTypeDesc.is() ) | |
| { | |
| TypeClass eTypeClass = xTypeDesc->getTypeClass(); | |
| if( eTypeClass == TypeClass_SINGLETON ) | |
| { | |
| Reference< XSingletonTypeDescription > xSingletonTypeDesc( xTypeDesc, UNO_QUERY ); | |
| if( xSingletonTypeDesc.is() ) | |
| pSbUnoSingleton = new SbUnoSingleton( rName, xSingletonTypeDesc ); | |
| } | |
| } | |
| } | |
| return pSbUnoSingleton; | |
| } | |
| SbUnoSingleton::SbUnoSingleton( const String& aName_, | |
| const Reference< XSingletonTypeDescription >& xSingletonTypeDesc ) | |
| : SbxObject( aName_ ) | |
| , m_xSingletonTypeDesc( xSingletonTypeDesc ) | |
| { | |
| SbxVariableRef xGetMethodRef = | |
| new SbxMethod( String( RTL_CONSTASCII_USTRINGPARAM( "get" ) ), SbxOBJECT ); | |
| QuickInsert( (SbxVariable*)xGetMethodRef ); | |
| } | |
| void SbUnoSingleton::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType, | |
| const SfxHint& rHint, const TypeId& rHintType ) | |
| { | |
| const SbxHint* pHint = PTR_CAST(SbxHint,&rHint); | |
| if( pHint ) | |
| { | |
| SbxVariable* pVar = pHint->GetVar(); | |
| SbxArray* pParams = pVar->GetParameters(); | |
| sal_uInt32 nParamCount = pParams ? ((sal_uInt32)pParams->Count() - 1) : 0; | |
| sal_uInt32 nAllowedParamCount = 1; | |
| Reference < XComponentContext > xContextToUse; | |
| if( nParamCount > 0 ) | |
| { | |
| // Check if first parameter is a context and use it then | |
| Reference < XComponentContext > xFirstParamContext; | |
| Any aArg1 = sbxToUnoValue( pParams->Get( 1 ) ); | |
| if( (aArg1 >>= xFirstParamContext) && xFirstParamContext.is() ) | |
| xContextToUse = xFirstParamContext; | |
| } | |
| if( !xContextToUse.is() ) | |
| { | |
| Reference < XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW ); | |
| xContextToUse.set( xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" )) ), UNO_QUERY_THROW ); | |
| --nAllowedParamCount; | |
| } | |
| if( nParamCount > nAllowedParamCount ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| Any aRetAny; | |
| if( xContextToUse.is() ) | |
| { | |
| String aSingletonName( RTL_CONSTASCII_USTRINGPARAM("/singletons/") ); | |
| aSingletonName += GetName(); | |
| Reference < XInterface > xRet; | |
| xContextToUse->getValueByName( aSingletonName ) >>= xRet; | |
| aRetAny <<= xRet; | |
| } | |
| unoToSbxValue( pVar, aRetAny ); | |
| } | |
| else | |
| SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType ); | |
| } | |
| //======================================================================== | |
| //======================================================================== | |
| //======================================================================== | |
| // Implementation eines EventAttacher-bezogenen AllListeners, der | |
| // nur einzelne Events an einen allgemeinen AllListener weiterleitet | |
| class BasicAllListener_Impl : public BasicAllListenerHelper | |
| { | |
| virtual void firing_impl(const AllEventObject& Event, Any* pRet); | |
| public: | |
| SbxObjectRef xSbxObj; | |
| ::rtl::OUString aPrefixName; | |
| BasicAllListener_Impl( const ::rtl::OUString& aPrefixName ); | |
| ~BasicAllListener_Impl(); | |
| // Methoden von XInterface | |
| //virtual sal_Bool queryInterface( Uik aUik, Reference< XInterface > & rOut ); | |
| // Methoden von XAllListener | |
| virtual void SAL_CALL firing(const AllEventObject& Event); | |
| virtual Any SAL_CALL approveFiring(const AllEventObject& Event); | |
| // Methoden von XEventListener | |
| virtual void SAL_CALL disposing(const EventObject& Source); | |
| }; | |
| //======================================================================== | |
| BasicAllListener_Impl::BasicAllListener_Impl | |
| ( | |
| const ::rtl::OUString & aPrefixName_ | |
| ) | |
| : aPrefixName( aPrefixName_ ) | |
| { | |
| } | |
| //======================================================================== | |
| BasicAllListener_Impl::~BasicAllListener_Impl() | |
| { | |
| } | |
| //======================================================================== | |
| void BasicAllListener_Impl::firing_impl( const AllEventObject& Event, Any* pRet ) | |
| { | |
| vos::OGuard guard( Application::GetSolarMutex() ); | |
| if( xSbxObj.Is() ) | |
| { | |
| ::rtl::OUString aMethodName = aPrefixName; | |
| aMethodName = aMethodName + Event.MethodName; | |
| SbxVariable * pP = xSbxObj; | |
| while( pP->GetParent() ) | |
| { | |
| pP = pP->GetParent(); | |
| StarBASIC * pLib = PTR_CAST(StarBASIC,pP); | |
| if( pLib ) | |
| { | |
| // In Basic Array anlegen | |
| SbxArrayRef xSbxArray = new SbxArray( SbxVARIANT ); | |
| const Any * pArgs = Event.Arguments.getConstArray(); | |
| sal_Int32 nCount = Event.Arguments.getLength(); | |
| for( sal_Int32 i = 0; i < nCount; i++ ) | |
| { | |
| // Elemente wandeln | |
| SbxVariableRef xVar = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( (SbxVariable*)xVar, pArgs[i] ); | |
| xSbxArray->Put( xVar, sal::static_int_cast< sal_uInt16 >(i+1) ); | |
| } | |
| pLib->Call( aMethodName, xSbxArray ); | |
| // Return-Wert aus dem Param-Array holen, wenn verlangt | |
| if( pRet ) | |
| { | |
| SbxVariable* pVar = xSbxArray->Get( 0 ); | |
| if( pVar ) | |
| { | |
| // #95792 Avoid a second call | |
| sal_uInt16 nFlags = pVar->GetFlags(); | |
| pVar->SetFlag( SBX_NO_BROADCAST ); | |
| *pRet = sbxToUnoValueImpl( pVar ); | |
| pVar->SetFlags( nFlags ); | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // Methoden von XAllListener | |
| void BasicAllListener_Impl::firing( const AllEventObject& Event ) | |
| { | |
| firing_impl( Event, NULL ); | |
| } | |
| Any BasicAllListener_Impl::approveFiring( const AllEventObject& Event ) | |
| { | |
| Any aRetAny; | |
| firing_impl( Event, &aRetAny ); | |
| return aRetAny; | |
| } | |
| //======================================================================== | |
| // Methoden von XEventListener | |
| void BasicAllListener_Impl ::disposing(const EventObject& ) | |
| { | |
| vos::OGuard guard( Application::GetSolarMutex() ); | |
| xSbxObj.Clear(); | |
| } | |
| //************************************************************************* | |
| // class InvocationToAllListenerMapper | |
| // helper class to map XInvocation to XAllListener (also in project eventattacher!) | |
| //************************************************************************* | |
| class InvocationToAllListenerMapper : public WeakImplHelper1< XInvocation > | |
| { | |
| public: | |
| InvocationToAllListenerMapper( const Reference< XIdlClass >& ListenerType, | |
| const Reference< XAllListener >& AllListener, const Any& Helper ); | |
| // XInvocation | |
| virtual Reference< XIntrospectionAccess > SAL_CALL getIntrospection(void); | |
| virtual Any SAL_CALL invoke(const ::rtl::OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam); | |
| virtual void SAL_CALL setValue(const ::rtl::OUString& PropertyName, const Any& Value); | |
| virtual Any SAL_CALL getValue(const ::rtl::OUString& PropertyName); | |
| virtual sal_Bool SAL_CALL hasMethod(const ::rtl::OUString& Name); | |
| virtual sal_Bool SAL_CALL hasProperty(const ::rtl::OUString& Name); | |
| private: | |
| Reference< XIdlReflection > m_xCoreReflection; | |
| Reference< XAllListener > m_xAllListener; | |
| Reference< XIdlClass > m_xListenerType; | |
| Any m_Helper; | |
| }; | |
| // Function to replace AllListenerAdapterService::createAllListerAdapter | |
| Reference< XInterface > createAllListenerAdapter | |
| ( | |
| const Reference< XInvocationAdapterFactory >& xInvocationAdapterFactory, | |
| const Reference< XIdlClass >& xListenerType, | |
| const Reference< XAllListener >& xListener, | |
| const Any& Helper | |
| ) | |
| { | |
| Reference< XInterface > xAdapter; | |
| if( xInvocationAdapterFactory.is() && xListenerType.is() && xListener.is() ) | |
| { | |
| Reference< XInvocation > xInvocationToAllListenerMapper = | |
| (XInvocation*)new InvocationToAllListenerMapper( xListenerType, xListener, Helper ); | |
| Type aListenerType( xListenerType->getTypeClass(), xListenerType->getName() ); | |
| xAdapter = xInvocationAdapterFactory->createAdapter( xInvocationToAllListenerMapper, aListenerType ); | |
| } | |
| return xAdapter; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| // InvocationToAllListenerMapper | |
| InvocationToAllListenerMapper::InvocationToAllListenerMapper | |
| ( const Reference< XIdlClass >& ListenerType, const Reference< XAllListener >& AllListener, const Any& Helper ) | |
| : m_xAllListener( AllListener ) | |
| , m_xListenerType( ListenerType ) | |
| , m_Helper( Helper ) | |
| { | |
| } | |
| //************************************************************************* | |
| Reference< XIntrospectionAccess > SAL_CALL InvocationToAllListenerMapper::getIntrospection(void) | |
| { | |
| return Reference< XIntrospectionAccess >(); | |
| } | |
| //************************************************************************* | |
| Any SAL_CALL InvocationToAllListenerMapper::invoke(const ::rtl::OUString& FunctionName, const Sequence< Any >& Params, | |
| Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam) | |
| { | |
| (void)OutParamIndex; | |
| (void)OutParam ; | |
| Any aRet; | |
| // Check if to firing or approveFiring has to be called | |
| Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( FunctionName ); | |
| sal_Bool bApproveFiring = sal_False; | |
| if( !xMethod.is() ) | |
| return aRet; | |
| Reference< XIdlClass > xReturnType = xMethod->getReturnType(); | |
| Sequence< Reference< XIdlClass > > aExceptionSeq = xMethod->getExceptionTypes(); | |
| if( ( xReturnType.is() && xReturnType->getTypeClass() != TypeClass_VOID ) || | |
| aExceptionSeq.getLength() > 0 ) | |
| { | |
| bApproveFiring = sal_True; | |
| } | |
| else | |
| { | |
| Sequence< ParamInfo > aParamSeq = xMethod->getParameterInfos(); | |
| sal_uInt32 nParamCount = aParamSeq.getLength(); | |
| if( nParamCount > 1 ) | |
| { | |
| const ParamInfo* pInfos = aParamSeq.getConstArray(); | |
| for( sal_uInt32 i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| if( pInfos[ i ].aMode != ParamMode_IN ) | |
| { | |
| bApproveFiring = sal_True; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| AllEventObject aAllEvent; | |
| aAllEvent.Source = (OWeakObject*) this; | |
| aAllEvent.Helper = m_Helper; | |
| aAllEvent.ListenerType = Type(m_xListenerType->getTypeClass(), m_xListenerType->getName() ); | |
| aAllEvent.MethodName = FunctionName; | |
| aAllEvent.Arguments = Params; | |
| if( bApproveFiring ) | |
| aRet = m_xAllListener->approveFiring( aAllEvent ); | |
| else | |
| m_xAllListener->firing( aAllEvent ); | |
| return aRet; | |
| } | |
| //************************************************************************* | |
| void SAL_CALL InvocationToAllListenerMapper::setValue(const ::rtl::OUString& PropertyName, const Any& Value) | |
| { | |
| (void)PropertyName; | |
| (void)Value; | |
| } | |
| //************************************************************************* | |
| Any SAL_CALL InvocationToAllListenerMapper::getValue(const ::rtl::OUString& PropertyName) | |
| { | |
| (void)PropertyName; | |
| return Any(); | |
| } | |
| //************************************************************************* | |
| sal_Bool SAL_CALL InvocationToAllListenerMapper::hasMethod(const ::rtl::OUString& Name) | |
| { | |
| Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( Name ); | |
| return xMethod.is(); | |
| } | |
| //************************************************************************* | |
| sal_Bool SAL_CALL InvocationToAllListenerMapper::hasProperty(const ::rtl::OUString& Name) | |
| { | |
| Reference< XIdlField > xField = m_xListenerType->getField( Name ); | |
| return xField.is(); | |
| } | |
| //======================================================================== | |
| // Uno-Service erzeugen | |
| // 1. Parameter == Prefix-Name der Makros | |
| // 2. Parameter == voll qualifizierter Name des Listeners | |
| void SbRtl_CreateUnoListener( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| //RTLFUNC(CreateUnoListener) | |
| { | |
| (void)bWrite; | |
| // Wir brauchen 2 Parameter | |
| if ( rPar.Count() != 3 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Klassen-Name der struct holen | |
| String aPrefixName = rPar.Get(1)->GetString(); | |
| String aListenerClassName = rPar.Get(2)->GetString(); | |
| // CoreReflection holen | |
| Reference< XIdlReflection > xCoreReflection = getCoreReflection_Impl(); | |
| if( !xCoreReflection.is() ) | |
| return; | |
| // AllListenerAdapterService holen | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() ); | |
| if( !xFactory.is() ) | |
| return; | |
| // Klasse suchen | |
| Reference< XIdlClass > xClass = xCoreReflection->forName( aListenerClassName ); | |
| if( !xClass.is() ) | |
| return; | |
| // AB, 30.11.1999 InvocationAdapterFactory holen | |
| Reference< XInvocationAdapterFactory > xInvocationAdapterFactory = Reference< XInvocationAdapterFactory >( | |
| xFactory->createInstance( rtl::OUString::createFromAscii("com.sun.star.script.InvocationAdapterFactory") ), UNO_QUERY ); | |
| BasicAllListener_Impl * p; | |
| Reference< XAllListener > xAllLst = p = new BasicAllListener_Impl( aPrefixName ); | |
| Any aTmp; | |
| Reference< XInterface > xLst = createAllListenerAdapter( xInvocationAdapterFactory, xClass, xAllLst, aTmp ); | |
| if( !xLst.is() ) | |
| return; | |
| ::rtl::OUString aClassName = xClass->getName(); | |
| Type aClassType( xClass->getTypeClass(), aClassName.getStr() ); | |
| aTmp = xLst->queryInterface( aClassType ); | |
| if( !aTmp.hasValue() ) | |
| return; | |
| SbUnoObject* pUnoObj = new SbUnoObject( aListenerClassName, aTmp ); | |
| p->xSbxObj = pUnoObj; | |
| p->xSbxObj->SetParent( pBasic ); | |
| // #100326 Register listener object to set Parent NULL in Dtor | |
| SbxArrayRef xBasicUnoListeners = pBasic->getUnoListeners(); | |
| xBasicUnoListeners->Insert( pUnoObj, xBasicUnoListeners->Count() ); | |
| // Objekt zurueckliefern | |
| SbxVariableRef refVar = rPar.Get(0); | |
| refVar->PutObject( p->xSbxObj ); | |
| } | |
| //======================================================================== | |
| // Represents the DefaultContext property of the ProcessServiceManager | |
| // in the Basic runtime system. | |
| void RTL_Impl_GetDefaultContext( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| SbxVariableRef refVar = rPar.Get(0); | |
| Reference< XMultiServiceFactory > xFactory = comphelper::getProcessServiceFactory(); | |
| Reference< XPropertySet> xPSMPropertySet( xFactory, UNO_QUERY ); | |
| if( xPSMPropertySet.is() ) | |
| { | |
| Any aContextAny = xPSMPropertySet->getPropertyValue( | |
| String( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ) ); | |
| SbUnoObjectRef xUnoObj = new SbUnoObject | |
| ( String( RTL_CONSTASCII_USTRINGPARAM("DefaultContext") ), | |
| aContextAny ); | |
| refVar->PutObject( (SbUnoObject*)xUnoObj ); | |
| } | |
| else | |
| { | |
| refVar->PutObject( NULL ); | |
| } | |
| } | |
| //======================================================================== | |
| // Creates a Basic wrapper object for a strongly typed Uno value | |
| // 1. parameter: Uno type as full qualified type name, e.g. "byte[]" | |
| void RTL_Impl_CreateUnoValue( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite ) | |
| { | |
| (void)pBasic; | |
| (void)bWrite; | |
| static String aTypeTypeString( RTL_CONSTASCII_USTRINGPARAM("type") ); | |
| // 2 parameters needed | |
| if ( rPar.Count() != 3 ) | |
| { | |
| StarBASIC::Error( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| // Klassen-Name der struct holen | |
| String aTypeName = rPar.Get(1)->GetString(); | |
| SbxVariable* pVal = rPar.Get(2); | |
| if( aTypeName == aTypeTypeString ) | |
| { | |
| SbxDataType eBaseType = pVal->SbxValue::GetType(); | |
| String aValTypeName; | |
| if( eBaseType == SbxSTRING ) | |
| { | |
| aValTypeName = pVal->GetString(); | |
| } | |
| else if( eBaseType == SbxOBJECT ) | |
| { | |
| // XIdlClass? | |
| Reference< XIdlClass > xIdlClass; | |
| SbxBaseRef pObj = (SbxBase*)pVal->GetObject(); | |
| if( pObj && pObj->ISA(SbUnoObject) ) | |
| { | |
| Any aUnoAny = ((SbUnoObject*)(SbxBase*)pObj)->getUnoAny(); | |
| aUnoAny >>= xIdlClass; | |
| } | |
| if( xIdlClass.is() ) | |
| aValTypeName = xIdlClass->getName(); | |
| } | |
| Type aType; | |
| bool bSuccess = implGetTypeByName( aValTypeName, aType ); | |
| if( bSuccess ) | |
| { | |
| Any aTypeAny( aType ); | |
| SbxVariableRef refVar = rPar.Get(0); | |
| SbxObjectRef xUnoAnyObject = new SbUnoAnyObject( aTypeAny ); | |
| refVar->PutObject( xUnoAnyObject ); | |
| } | |
| return; | |
| } | |
| // Check the type | |
| Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl(); | |
| Any aRet; | |
| try | |
| { | |
| aRet = xTypeAccess->getByHierarchicalName( aTypeName ); | |
| } | |
| catch( NoSuchElementException& e1 ) | |
| { | |
| String aNoSuchElementExceptionName | |
| ( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.NoSuchElementException" ) ); | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( e1, aNoSuchElementExceptionName ) ); | |
| return; | |
| } | |
| Reference< XTypeDescription > xTypeDesc; | |
| aRet >>= xTypeDesc; | |
| TypeClass eTypeClass = xTypeDesc->getTypeClass(); | |
| Type aDestType( eTypeClass, aTypeName ); | |
| // Preconvert value | |
| Any aVal = sbxToUnoValueImpl( pVal ); | |
| Any aConvertedVal = convertAny( aVal, aDestType ); | |
| /* | |
| // Convert | |
| Reference< XTypeConverter > xConverter = getTypeConverter_Impl(); | |
| try | |
| { | |
| aConvertedVal = xConverter->convertTo( aVal, aDestType ); | |
| } | |
| catch( IllegalArgumentException& e1 ) | |
| { | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( ::cppu::getCaughtException() ) ); | |
| return; | |
| } | |
| catch( CannotConvertException& e2 ) | |
| { | |
| String aCannotConvertExceptionName | |
| ( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.lang.IllegalArgumentException" ) ); | |
| StarBASIC::Error( ERRCODE_BASIC_EXCEPTION, | |
| implGetExceptionMsg( e2, aCannotConvertExceptionName ) ); | |
| return; | |
| } | |
| */ | |
| SbxVariableRef refVar = rPar.Get(0); | |
| SbxObjectRef xUnoAnyObject = new SbUnoAnyObject( aConvertedVal ); | |
| refVar->PutObject( xUnoAnyObject ); | |
| } | |
| //========================================================================== | |
| namespace { | |
| class OMutexBasis | |
| { | |
| protected: | |
| // this mutex is necessary for OInterfaceContainerHelper | |
| ::osl::Mutex m_aMutex; | |
| }; | |
| } // namespace | |
| typedef WeakImplHelper2< XInvocation, XComponent > ModuleInvocationProxyHelper; | |
| class ModuleInvocationProxy : public OMutexBasis, | |
| public ModuleInvocationProxyHelper | |
| { | |
| ::rtl::OUString m_aPrefix; | |
| SbxObjectRef m_xScopeObj; | |
| bool m_bProxyIsClassModuleObject; | |
| ::cppu::OInterfaceContainerHelper m_aListeners; | |
| public: | |
| ModuleInvocationProxy( const ::rtl::OUString& aPrefix, SbxObjectRef xScopeObj ); | |
| ~ModuleInvocationProxy() | |
| {} | |
| // XInvocation | |
| virtual Reference< XIntrospectionAccess > SAL_CALL getIntrospection() throw(); | |
| virtual void SAL_CALL setValue( const ::rtl::OUString& rProperty, const Any& rValue ); | |
| virtual Any SAL_CALL getValue( const ::rtl::OUString& rProperty ); | |
| virtual sal_Bool SAL_CALL hasMethod( const ::rtl::OUString& rName ) throw(); | |
| virtual sal_Bool SAL_CALL hasProperty( const ::rtl::OUString& rProp ) throw(); | |
| virtual Any SAL_CALL invoke( const ::rtl::OUString& rFunction, | |
| const Sequence< Any >& rParams, | |
| Sequence< sal_Int16 >& rOutParamIndex, | |
| Sequence< Any >& rOutParam ); | |
| // XComponent | |
| virtual void SAL_CALL dispose(); | |
| virtual void SAL_CALL addEventListener( const Reference< XEventListener >& xListener ); | |
| virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& aListener ); | |
| }; | |
| ModuleInvocationProxy::ModuleInvocationProxy( const ::rtl::OUString& aPrefix, SbxObjectRef xScopeObj ) | |
| : m_aPrefix( aPrefix + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("_") ) ) | |
| , m_xScopeObj( xScopeObj ) | |
| , m_aListeners( m_aMutex ) | |
| { | |
| m_bProxyIsClassModuleObject = xScopeObj.Is() ? xScopeObj->ISA(SbClassModuleObject) : false; | |
| } | |
| Reference< XIntrospectionAccess > SAL_CALL ModuleInvocationProxy::getIntrospection() throw() | |
| { | |
| return Reference< XIntrospectionAccess >(); | |
| } | |
| void SAL_CALL ModuleInvocationProxy::setValue( const ::rtl::OUString& rProperty, const Any& rValue ) | |
| { | |
| if( !m_bProxyIsClassModuleObject ) | |
| throw UnknownPropertyException(); | |
| vos::OGuard guard( Application::GetSolarMutex() ); | |
| ::rtl::OUString aPropertyFunctionName( RTL_CONSTASCII_USTRINGPARAM( "Property Set ") ); | |
| aPropertyFunctionName += m_aPrefix; | |
| aPropertyFunctionName += rProperty; | |
| SbxVariable* p = m_xScopeObj->Find( aPropertyFunctionName, SbxCLASS_METHOD ); | |
| SbMethod* pMeth = p != NULL ? PTR_CAST(SbMethod,p) : NULL; | |
| if( pMeth == NULL ) | |
| { | |
| // TODO: Check vba behavior concernig missing function | |
| //StarBASIC::Error( SbERR_NO_METHOD, aFunctionName ); | |
| throw UnknownPropertyException(); | |
| } | |
| // Setup parameter | |
| SbxArrayRef xArray = new SbxArray; | |
| SbxVariableRef xVar = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( (SbxVariable*)xVar, rValue ); | |
| xArray->Put( xVar, 1 ); | |
| // Call property method | |
| SbxVariableRef xValue = new SbxVariable; | |
| pMeth->SetParameters( xArray ); | |
| pMeth->Call( xValue ); | |
| //aRet = sbxToUnoValue( xValue ); | |
| pMeth->SetParameters( NULL ); | |
| // TODO: OutParameter? | |
| // throw InvocationTargetException(); | |
| //return aRet; | |
| } | |
| Any SAL_CALL ModuleInvocationProxy::getValue( const ::rtl::OUString& rProperty ) | |
| { | |
| if( !m_bProxyIsClassModuleObject ) | |
| throw UnknownPropertyException(); | |
| vos::OGuard guard( Application::GetSolarMutex() ); | |
| ::rtl::OUString aPropertyFunctionName( RTL_CONSTASCII_USTRINGPARAM( "Property Get ") ); | |
| aPropertyFunctionName += m_aPrefix; | |
| aPropertyFunctionName += rProperty; | |
| SbxVariable* p = m_xScopeObj->Find( aPropertyFunctionName, SbxCLASS_METHOD ); | |
| SbMethod* pMeth = p != NULL ? PTR_CAST(SbMethod,p) : NULL; | |
| if( pMeth == NULL ) | |
| { | |
| // TODO: Check vba behavior concernig missing function | |
| //StarBASIC::Error( SbERR_NO_METHOD, aFunctionName ); | |
| throw UnknownPropertyException(); | |
| } | |
| // Call method | |
| SbxVariableRef xValue = new SbxVariable; | |
| pMeth->Call( xValue ); | |
| Any aRet = sbxToUnoValue( xValue ); | |
| return aRet; | |
| } | |
| sal_Bool SAL_CALL ModuleInvocationProxy::hasMethod( const ::rtl::OUString& ) throw() | |
| { | |
| return sal_False; | |
| } | |
| sal_Bool SAL_CALL ModuleInvocationProxy::hasProperty( const ::rtl::OUString& ) throw() | |
| { | |
| return sal_False; | |
| } | |
| Any SAL_CALL ModuleInvocationProxy::invoke( const ::rtl::OUString& rFunction, | |
| const Sequence< Any >& rParams, | |
| Sequence< sal_Int16 >&, | |
| Sequence< Any >& ) | |
| { | |
| vos::OGuard guard( Application::GetSolarMutex() ); | |
| Any aRet; | |
| SbxObjectRef xScopeObj = m_xScopeObj; | |
| if( !xScopeObj.Is() ) | |
| return aRet; | |
| ::rtl::OUString aFunctionName = m_aPrefix; | |
| aFunctionName += rFunction; | |
| sal_Bool bSetRescheduleBack = sal_False; | |
| sal_Bool bOldReschedule = sal_True; | |
| SbiInstance* pInst = pINST; | |
| if( pInst && pInst->IsCompatibility() ) | |
| { | |
| bOldReschedule = pInst->IsReschedule(); | |
| if ( bOldReschedule ) | |
| { | |
| pInst->EnableReschedule( sal_False ); | |
| bSetRescheduleBack = sal_True; | |
| } | |
| } | |
| SbxVariable* p = xScopeObj->Find( aFunctionName, SbxCLASS_METHOD ); | |
| SbMethod* pMeth = p != NULL ? PTR_CAST(SbMethod,p) : NULL; | |
| if( pMeth == NULL ) | |
| { | |
| // TODO: Check vba behavior concernig missing function | |
| //StarBASIC::Error( SbERR_NO_METHOD, aFunctionName ); | |
| return aRet; | |
| } | |
| // Setup parameters | |
| SbxArrayRef xArray; | |
| sal_Int32 nParamCount = rParams.getLength(); | |
| if( nParamCount ) | |
| { | |
| xArray = new SbxArray; | |
| const Any *pArgs = rParams.getConstArray(); | |
| for( sal_Int32 i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| SbxVariableRef xVar = new SbxVariable( SbxVARIANT ); | |
| unoToSbxValue( (SbxVariable*)xVar, pArgs[i] ); | |
| xArray->Put( xVar, sal::static_int_cast< sal_uInt16 >(i+1) ); | |
| } | |
| } | |
| // Call method | |
| SbxVariableRef xValue = new SbxVariable; | |
| if( xArray.Is() ) | |
| pMeth->SetParameters( xArray ); | |
| pMeth->Call( xValue ); | |
| aRet = sbxToUnoValue( xValue ); | |
| pMeth->SetParameters( NULL ); | |
| if( bSetRescheduleBack ) | |
| pInst->EnableReschedule( bOldReschedule ); | |
| // TODO: OutParameter? | |
| return aRet; | |
| } | |
| void SAL_CALL ModuleInvocationProxy::dispose() | |
| { | |
| ::osl::MutexGuard aGuard( m_aMutex ); | |
| EventObject aEvent( (XComponent*)this ); | |
| m_aListeners.disposeAndClear( aEvent ); | |
| m_xScopeObj = NULL; | |
| } | |
| void SAL_CALL ModuleInvocationProxy::addEventListener( const Reference< XEventListener >& xListener ) | |
| { | |
| m_aListeners.addInterface( xListener ); | |
| } | |
| void SAL_CALL ModuleInvocationProxy::removeEventListener( const Reference< XEventListener >& xListener ) | |
| { | |
| m_aListeners.removeInterface( xListener ); | |
| } | |
| Reference< XInterface > createComListener( const Any& aControlAny, const ::rtl::OUString& aVBAType, | |
| const ::rtl::OUString& aPrefix, SbxObjectRef xScopeObj ) | |
| { | |
| Reference< XInterface > xRet; | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| Reference< XMultiComponentFactory > xServiceMgr( xContext->getServiceManager() ); | |
| Reference< XInvocation > xProxy = new ModuleInvocationProxy( aPrefix, xScopeObj ); | |
| Sequence<Any> args( 3 ); | |
| args[0] <<= aControlAny; | |
| args[1] <<= aVBAType; | |
| args[2] <<= xProxy; | |
| try | |
| { | |
| xRet = xServiceMgr->createInstanceWithArgumentsAndContext( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.custom.UnoComListener")), | |
| args, xContext ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| return xRet; | |
| } | |
| typedef std::vector< WeakReference< XComponent > > ComponentRefVector; | |
| struct StarBasicDisposeItem | |
| { | |
| StarBASIC* m_pBasic; | |
| SbxArrayRef m_pRegisteredVariables; | |
| ComponentRefVector m_vComImplementsObjects; | |
| StarBasicDisposeItem( StarBASIC* pBasic ) | |
| : m_pBasic( pBasic ) | |
| { | |
| m_pRegisteredVariables = new SbxArray(); | |
| } | |
| }; | |
| typedef std::vector< StarBasicDisposeItem* > DisposeItemVector; | |
| static DisposeItemVector GaDisposeItemVector; | |
| DisposeItemVector::iterator lcl_findItemForBasic( StarBASIC* pBasic ) | |
| { | |
| DisposeItemVector::iterator it; | |
| for( it = GaDisposeItemVector.begin() ; it != GaDisposeItemVector.end() ; ++it ) | |
| { | |
| StarBasicDisposeItem* pItem = *it; | |
| if( pItem->m_pBasic == pBasic ) | |
| return it; | |
| } | |
| return GaDisposeItemVector.end(); | |
| } | |
| StarBasicDisposeItem* lcl_getOrCreateItemForBasic( StarBASIC* pBasic ) | |
| { | |
| DisposeItemVector::iterator it = lcl_findItemForBasic( pBasic ); | |
| StarBasicDisposeItem* pItem = (it != GaDisposeItemVector.end()) ? *it : NULL; | |
| if( pItem == NULL ) | |
| { | |
| pItem = new StarBasicDisposeItem( pBasic ); | |
| GaDisposeItemVector.push_back( pItem ); | |
| } | |
| return pItem; | |
| } | |
| void registerComponentToBeDisposedForBasic | |
| ( Reference< XComponent > xComponent, StarBASIC* pBasic ) | |
| { | |
| StarBasicDisposeItem* pItem = lcl_getOrCreateItemForBasic( pBasic ); | |
| pItem->m_vComImplementsObjects.push_back( xComponent ); | |
| } | |
| void registerComListenerVariableForBasic( SbxVariable* pVar, StarBASIC* pBasic ) | |
| { | |
| StarBasicDisposeItem* pItem = lcl_getOrCreateItemForBasic( pBasic ); | |
| SbxArray* pArray = pItem->m_pRegisteredVariables; | |
| pArray->Put( pVar, pArray->Count() ); | |
| } | |
| void disposeComVariablesForBasic( StarBASIC* pBasic ) | |
| { | |
| DisposeItemVector::iterator it = lcl_findItemForBasic( pBasic ); | |
| if( it != GaDisposeItemVector.end() ) | |
| { | |
| StarBasicDisposeItem* pItem = *it; | |
| SbxArray* pArray = pItem->m_pRegisteredVariables; | |
| sal_uInt16 nCount = pArray->Count(); | |
| for( sal_uInt16 i = 0 ; i < nCount ; ++i ) | |
| { | |
| SbxVariable* pVar = pArray->Get( i ); | |
| pVar->ClearComListener(); | |
| } | |
| ComponentRefVector& rv = pItem->m_vComImplementsObjects; | |
| ComponentRefVector::iterator itCRV; | |
| for( itCRV = rv.begin() ; itCRV != rv.end() ; ++itCRV ) | |
| { | |
| try | |
| { | |
| Reference< XComponent > xComponent( (*itCRV).get(), UNO_QUERY_THROW ); | |
| xComponent->dispose(); | |
| } | |
| catch( Exception& ) | |
| {} | |
| } | |
| delete pItem; | |
| GaDisposeItemVector.erase( it ); | |
| } | |
| } | |
| // Handle module implements mechanism for OLE types | |
| bool SbModule::createCOMWrapperForIface( Any& o_rRetAny, SbClassModuleObject* pProxyClassModuleObject ) | |
| { | |
| // For now: Take first interface that allows to instantiate COM wrapper | |
| // TODO: Check if support for multiple interfaces is needed | |
| Reference< XComponentContext > xContext = getComponentContext_Impl(); | |
| Reference< XMultiComponentFactory > xServiceMgr( xContext->getServiceManager() ); | |
| Reference< XSingleServiceFactory > xComImplementsFactory | |
| ( | |
| xServiceMgr->createInstanceWithContext( | |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.custom.ComImplementsFactory")), xContext ), | |
| UNO_QUERY | |
| ); | |
| if( !xComImplementsFactory.is() ) | |
| return false; | |
| bool bSuccess = false; | |
| SbxArray* pModIfaces = pClassData->mxIfaces; | |
| sal_uInt16 nCount = pModIfaces->Count(); | |
| for( sal_uInt16 i = 0 ; i < nCount ; ++i ) | |
| { | |
| SbxVariable* pVar = pModIfaces->Get( i ); | |
| ::rtl::OUString aIfaceName = pVar->GetName(); | |
| if( !aIfaceName.isEmpty() ) | |
| { | |
| ::rtl::OUString aPureIfaceName = aIfaceName; | |
| sal_Int32 indexLastDot = aIfaceName.lastIndexOf('.'); | |
| if ( indexLastDot > -1 ) | |
| aPureIfaceName = aIfaceName.copy( indexLastDot + 1 ); | |
| Reference< XInvocation > xProxy = new ModuleInvocationProxy( aPureIfaceName, pProxyClassModuleObject ); | |
| Sequence<Any> args( 2 ); | |
| args[0] <<= aIfaceName; | |
| args[1] <<= xProxy; | |
| Reference< XInterface > xRet; | |
| bSuccess = false; | |
| try | |
| { | |
| xRet = xComImplementsFactory->createInstanceWithArguments( args ); | |
| bSuccess = true; | |
| } | |
| catch( const Exception& ) | |
| { | |
| implHandleAnyException( ::cppu::getCaughtException() ); | |
| } | |
| if( bSuccess ) | |
| { | |
| Reference< XComponent > xComponent( xProxy, UNO_QUERY ); | |
| if( xComponent.is() ) | |
| { | |
| StarBASIC* pParentBasic = NULL; | |
| SbxObject* pCurObject = this; | |
| do | |
| { | |
| SbxObject* pObjParent = pCurObject->GetParent(); | |
| pParentBasic = PTR_CAST( StarBASIC, pObjParent ); | |
| pCurObject = pObjParent; | |
| } | |
| while( pParentBasic == NULL && pCurObject != NULL ); | |
| OSL_ASSERT( pParentBasic != NULL ); | |
| registerComponentToBeDisposedForBasic( xComponent, pParentBasic ); | |
| } | |
| o_rRetAny <<= xRet; | |
| break; | |
| } | |
| } | |
| } | |
| return bSuccess; | |
| } | |
| // Due to an incorrect behavior IE returns an object instead of a string | |
| // in some scenarios. Calling toString at the object may correct this. | |
| // Helper function used in sbxvalue.cxx | |
| bool handleToStringForCOMObjects( SbxObject* pObj, SbxValue* pVal ) | |
| { | |
| bool bSuccess = false; | |
| SbUnoObject* pUnoObj = NULL; | |
| if( pObj != NULL && (pUnoObj = PTR_CAST(SbUnoObject,(SbxObject*)pObj)) != NULL ) | |
| { | |
| // Only for native COM objects | |
| if( pUnoObj->isNativeCOMObject() ) | |
| { | |
| SbxVariableRef pMeth = pObj->Find( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "toString" ) ), SbxCLASS_METHOD ); | |
| if ( pMeth.Is() ) | |
| { | |
| SbxValues aRes; | |
| pMeth->Get( aRes ); | |
| pVal->Put( aRes ); | |
| bSuccess = true; | |
| } | |
| } | |
| } | |
| return bSuccess; | |
| } |