| /************************************************************** |
| * |
| * 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_comphelper.hxx" |
| |
| #include <deque> |
| |
| #if defined( OS2 ) || defined( UNX ) |
| #include <wchar.h> |
| #endif |
| #include <osl/mutex.hxx> |
| #ifndef _VOS_DIAGNOSE_HXX_ |
| #include <vos/diagnose.hxx> |
| #endif |
| #include <vos/macros.hxx> |
| #include <comphelper/eventattachermgr.hxx> |
| #include <com/sun/star/beans/XIntrospection.hpp> |
| #include <com/sun/star/io/XObjectInputStream.hpp> |
| #include <com/sun/star/io/XPersistObject.hpp> |
| #include <com/sun/star/io/XObjectOutputStream.hpp> |
| #include <com/sun/star/io/XMarkableStream.hpp> |
| #include <com/sun/star/lang/XInitialization.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/reflection/XIdlClass.hpp> |
| #include <com/sun/star/reflection/XIdlReflection.hpp> |
| #include <com/sun/star/reflection/XIdlMethod.hpp> |
| #include <com/sun/star/script/XTypeConverter.hpp> |
| #include <com/sun/star/script/XEngineListener.hpp> |
| #include <com/sun/star/script/XEventAttacher.hpp> |
| #include <com/sun/star/script/XEventAttacherManager.hpp> |
| #include <com/sun/star/script/XScriptListener.hpp> |
| #include <cppuhelper/weak.hxx> |
| #include <cppuhelper/interfacecontainer.hxx> |
| #include <cppuhelper/implbase1.hxx> |
| #include <cppuhelper/implbase2.hxx> |
| |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::io; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::script; |
| using namespace com::sun::star::reflection; |
| using namespace cppu; |
| using namespace osl; |
| using namespace rtl; |
| |
| namespace comphelper |
| { |
| |
| //----------------------------------------------------------------------------- |
| struct AttachedObject_Impl |
| { |
| Reference< XInterface > xTarget; |
| Sequence< Reference< XEventListener > > aAttachedListenerSeq; |
| Any aHelper; |
| |
| bool operator<( const AttachedObject_Impl & ) const; |
| bool operator==( const AttachedObject_Impl & ) const; |
| }; |
| |
| struct AttacherIndex_Impl |
| { |
| #ifdef DEQUE_OK |
| ::std::deque< ScriptEventDescriptor > aEventList; |
| #else |
| Sequence< ScriptEventDescriptor > aEventList; |
| #endif |
| ::std::deque< AttachedObject_Impl > aObjList; |
| |
| bool operator<( const AttacherIndex_Impl & ) const; |
| bool operator==( const AttacherIndex_Impl & ) const; |
| }; |
| |
| #if 0 |
| bool AttachedObject_Impl::operator<( const AttachedObject_Impl & r ) const |
| { |
| VOS_ENSHURE( FALSE, "not implemented" ); |
| return FALSE; |
| return this < &r; |
| } |
| |
| bool AttachedObject_Impl::operator==( const AttachedObject_Impl & r ) const |
| { |
| VOS_ENSHURE( FALSE, "not implemented" ); |
| return this == &r; |
| } |
| |
| bool AttacherIndex_Impl::operator<( const AttacherIndex_Impl & r ) const |
| { |
| VOS_ENSHURE( FALSE, "not implemented" ); |
| return this < &r; |
| } |
| bool AttacherIndex_Impl::operator==( const AttacherIndex_Impl & r ) const |
| { |
| VOS_ENSHURE( FALSE, "not implemented" ); |
| return this == &r; |
| } |
| #endif |
| |
| //----------------------------------------------------------------------------- |
| class ImplEventAttacherManager |
| : public WeakImplHelper2< XEventAttacherManager, XPersistObject > |
| { |
| friend class AttacherAllListener_Impl; |
| ::std::deque< AttacherIndex_Impl > aIndex; |
| Mutex aLock; |
| // Container fuer die ScriptListener |
| OInterfaceContainerHelper aScriptListeners; |
| // EventAttacher-Instanz |
| Reference< XEventAttacher > xAttacher; |
| Reference< XMultiServiceFactory > mxSMgr; |
| Reference< XIdlReflection > mxCoreReflection; |
| Reference< XIntrospection > mxIntrospection; |
| Reference< XTypeConverter > xConverter; |
| sal_Int16 nVersion; |
| public: |
| ImplEventAttacherManager( const Reference< XIntrospection > & rIntrospection, |
| const Reference< XMultiServiceFactory > rSMgr ); |
| ~ImplEventAttacherManager(); |
| |
| // Methoden von XEventAttacherManager |
| virtual void SAL_CALL registerScriptEvent(sal_Int32 Index, const ScriptEventDescriptor& ScriptEvent) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL registerScriptEvents(sal_Int32 Index, const Sequence< ScriptEventDescriptor >& ScriptEvents) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL revokeScriptEvent(sal_Int32 Index, const OUString& ListenerType, const OUString& EventMethod, const OUString& removeListenerParam) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL revokeScriptEvents(sal_Int32 Index) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL insertEntry(sal_Int32 Index) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL removeEntry(sal_Int32 Index) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual Sequence< ScriptEventDescriptor > SAL_CALL getScriptEvents(sal_Int32 Index) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL attach(sal_Int32 Index, const Reference< XInterface >& Object, const Any& Helper) |
| throw( IllegalArgumentException, ServiceNotRegisteredException, RuntimeException ); |
| virtual void SAL_CALL detach(sal_Int32 nIndex, const Reference< XInterface >& xObject) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL addScriptListener(const Reference< XScriptListener >& aListener) |
| throw( IllegalArgumentException, RuntimeException ); |
| virtual void SAL_CALL removeScriptListener(const Reference< XScriptListener >& Listener) |
| throw( IllegalArgumentException, RuntimeException ); |
| |
| // Methoden von XPersistObject |
| virtual OUString SAL_CALL getServiceName(void) throw( RuntimeException ); |
| virtual void SAL_CALL write(const Reference< XObjectOutputStream >& OutStream) throw( IOException, RuntimeException ); |
| virtual void SAL_CALL read(const Reference< XObjectInputStream >& InStream) throw( IOException, RuntimeException ); |
| |
| private: |
| Reference< XIdlReflection > getReflection() throw( Exception ); |
| |
| /** checks if <arg>_nIndex</arg> is a valid index, throws an <type>IllegalArgumentException</type> if not |
| @param _nIndex |
| the index to check |
| @return |
| the iterator pointing to the position indicated by the index |
| */ |
| ::std::deque<AttacherIndex_Impl>::iterator implCheckIndex( sal_Int32 _nIndex ) SAL_THROW ( ( IllegalArgumentException ) ); |
| }; |
| |
| //======================================================================== |
| //======================================================================== |
| //======================================================================== |
| |
| // Implementation eines EventAttacher-bezogenen AllListeners, der |
| // nur einzelne Events an einen allgemeinen AllListener weiterleitet |
| class AttacherAllListener_Impl : public WeakImplHelper1< XAllListener > |
| { |
| ImplEventAttacherManager* mpManager; |
| Reference< XEventAttacherManager > xManager; |
| OUString aScriptType; |
| OUString aScriptCode; |
| sal_Int16 nVersion; |
| |
| void convertToEventReturn( Any & rRet, const Type & rRetType ) |
| throw( CannotConvertException ); |
| public: |
| AttacherAllListener_Impl( ImplEventAttacherManager* pManager_, const OUString &rScriptType_, |
| const OUString & rScriptCode_ ); |
| |
| // Methoden von XAllListener |
| virtual void SAL_CALL firing(const AllEventObject& Event) throw( RuntimeException ); |
| virtual Any SAL_CALL approveFiring(const AllEventObject& Event) throw( InvocationTargetException, RuntimeException ); |
| |
| // Methoden von XEventListener |
| virtual void SAL_CALL disposing(const EventObject& Source) throw( RuntimeException ); |
| }; |
| |
| //======================================================================== |
| AttacherAllListener_Impl::AttacherAllListener_Impl |
| ( |
| ImplEventAttacherManager* pManager_, |
| const OUString & rScriptType_, |
| const OUString & rScriptCode_ |
| ) |
| : mpManager( pManager_ ) |
| , xManager( pManager_ ) |
| , aScriptType( rScriptType_ ) |
| , aScriptCode( rScriptCode_ ) |
| , nVersion( 2 ) |
| { |
| } |
| |
| |
| //======================================================================== |
| // Methoden von XAllListener |
| void SAL_CALL AttacherAllListener_Impl::firing(const AllEventObject& Event) |
| throw( RuntimeException ) |
| { |
| ScriptEvent aScriptEvent; |
| aScriptEvent.Source = (OWeakObject *)mpManager; // get correct XInterface |
| aScriptEvent.ListenerType = Event.ListenerType; |
| aScriptEvent.MethodName = Event.MethodName; |
| aScriptEvent.Arguments = Event.Arguments; |
| aScriptEvent.Helper = Event.Helper; |
| aScriptEvent.ScriptType = aScriptType; |
| aScriptEvent.ScriptCode = aScriptCode; |
| |
| // ueber alle Listener iterieren und Events senden |
| OInterfaceIteratorHelper aIt( mpManager->aScriptListeners ); |
| while( aIt.hasMoreElements() ) |
| ((XScriptListener *)aIt.next())->firing( aScriptEvent ); |
| } |
| |
| //======================================================================== |
| // Convert to the standard event return |
| void AttacherAllListener_Impl::convertToEventReturn( Any & rRet, const Type & rRetType ) |
| throw( CannotConvertException ) |
| { |
| // no return value? Set to the specified values |
| if( rRet.getValueType().getTypeClass() == TypeClass_VOID ) |
| { |
| switch( rRetType.getTypeClass() ) |
| { |
| case TypeClass_INTERFACE: |
| { |
| rRet <<= Reference< XInterface >(); |
| } |
| break; |
| |
| case TypeClass_BOOLEAN: |
| rRet <<= sal_True; |
| break; |
| |
| case TypeClass_STRING: |
| rRet <<= OUString(); |
| break; |
| |
| case TypeClass_FLOAT: rRet <<= float(0); break; |
| case TypeClass_DOUBLE: rRet <<= double(0.0); break; |
| case TypeClass_BYTE: rRet <<= sal_uInt8(0); break; |
| case TypeClass_SHORT: rRet <<= sal_Int16( 0 ); break; |
| case TypeClass_LONG: rRet <<= sal_Int32( 0 ); break; |
| case TypeClass_UNSIGNED_SHORT: rRet <<= sal_uInt16( 0 ); break; |
| case TypeClass_UNSIGNED_LONG: rRet <<= sal_uInt32( 0 ); break; |
| |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| } |
| else if( !rRet.getValueType().equals( rRetType ) ) |
| { |
| if( mpManager->xConverter.is() ) |
| rRet = mpManager->xConverter->convertTo( rRet, rRetType ); |
| else |
| throw CannotConvertException(); |
| } |
| } |
| |
| //======================================================================== |
| // Methoden von XAllListener |
| Any SAL_CALL AttacherAllListener_Impl::approveFiring( const AllEventObject& Event ) |
| throw( InvocationTargetException, RuntimeException ) |
| { |
| ScriptEvent aScriptEvent; |
| aScriptEvent.Source = (OWeakObject *)mpManager; // get correct XInterface |
| aScriptEvent.ListenerType = Event.ListenerType; |
| aScriptEvent.MethodName = Event.MethodName; |
| aScriptEvent.Arguments = Event.Arguments; |
| aScriptEvent.Helper = Event.Helper; |
| aScriptEvent.ScriptType = aScriptType; |
| aScriptEvent.ScriptCode = aScriptCode; |
| |
| Any aRet; |
| // ueber alle Listener iterieren und Events senden |
| OInterfaceIteratorHelper aIt( mpManager->aScriptListeners ); |
| while( aIt.hasMoreElements() ) |
| { |
| aRet = ((XScriptListener *)aIt.next())->approveFiring( aScriptEvent ); |
| try |
| { |
| Reference< XIdlClass > xListenerType = mpManager->getReflection()-> |
| forName( Event.ListenerType.getTypeName() ); |
| Reference< XIdlMethod > xMeth = xListenerType->getMethod( Event.MethodName ); |
| if( xMeth.is() ) |
| { |
| Reference< XIdlClass > xRetType = xMeth->getReturnType(); |
| Type aRetType(xRetType->getTypeClass(), xRetType->getName()); |
| convertToEventReturn( aRet, aRetType ); |
| } |
| |
| switch( aRet.getValueType().getTypeClass() ) |
| { |
| case TypeClass_INTERFACE: |
| { |
| // Interface not null, return |
| Reference< XInterface > x; |
| aRet >>= x; |
| if( x.is() ) |
| return aRet; |
| } |
| break; |
| |
| case TypeClass_BOOLEAN: |
| // FALSE -> Return |
| if( !(*(sal_Bool*)aRet.getValue()) ) |
| return aRet; |
| break; |
| |
| case TypeClass_STRING: |
| // none empty string -> return |
| if( ((OUString*)aRet.getValue())->isEmpty() == false ) |
| return aRet; |
| break; |
| |
| // none zero number -> return |
| case TypeClass_FLOAT: if( *((float*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_DOUBLE: if( *((double*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_BYTE: if( *((sal_uInt8*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_SHORT: if( *((sal_Int16*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_LONG: if( *((sal_Int32*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_UNSIGNED_SHORT: if( *((sal_uInt16*)aRet.getValue()) ) return aRet; break; |
| case TypeClass_UNSIGNED_LONG: if( *((sal_uInt32*)aRet.getValue()) ) return aRet; break; |
| |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| } |
| catch( CannotConvertException& ) |
| { |
| // silent ignore conversions errors from a script call |
| Reference< XIdlClass > xListenerType = mpManager->getReflection()-> |
| forName( Event.ListenerType.getTypeName() ); |
| Reference< XIdlMethod > xMeth = xListenerType->getMethod( Event.MethodName ); |
| if( xMeth.is() ) |
| { |
| Reference< XIdlClass > xRetType = xMeth->getReturnType(); |
| Type aRetType(xRetType->getTypeClass(), xRetType->getName()); |
| aRet.clear(); |
| convertToEventReturn( aRet, aRetType ); |
| } |
| } |
| } |
| return aRet; |
| } |
| |
| //======================================================================== |
| // Methoden von XEventListener |
| void SAL_CALL AttacherAllListener_Impl::disposing(const EventObject& ) |
| throw( RuntimeException ) |
| { |
| // It is up to the container to release the object |
| } |
| |
| |
| //======================================================================== |
| //======================================================================== |
| //======================================================================== |
| |
| // Create-Methode fuer EventAttacherManager |
| Reference< XEventAttacherManager > createEventAttacherManager( const Reference< XIntrospection > & rIntrospection, |
| const Reference< XMultiServiceFactory > & rSMgr ) |
| throw( Exception ) |
| { |
| return new ImplEventAttacherManager( rIntrospection, rSMgr ); |
| } |
| |
| // Create-Methode fuer EventAttacherManager |
| Reference< XEventAttacherManager > createEventAttacherManager( const Reference< XMultiServiceFactory > & rSMgr ) |
| throw( Exception ) |
| { |
| if ( rSMgr.is() ) |
| { |
| Reference< XInterface > xIFace( rSMgr->createInstance( OUString::createFromAscii("com.sun.star.beans.Introspection") ) ); |
| if ( xIFace.is() ) |
| { |
| Reference< XIntrospection > xIntrospection( xIFace, UNO_QUERY); |
| return new ImplEventAttacherManager( xIntrospection, rSMgr ); |
| } |
| } |
| |
| return Reference< XEventAttacherManager >(); |
| } |
| |
| //----------------------------------------------------------------------------- |
| ImplEventAttacherManager::ImplEventAttacherManager( const Reference< XIntrospection > & rIntrospection, |
| const Reference< XMultiServiceFactory > rSMgr ) |
| : aScriptListeners( aLock ) |
| , mxSMgr( rSMgr ) |
| , mxIntrospection( rIntrospection ) |
| { |
| if ( rSMgr.is() ) |
| { |
| Reference< XInterface > xIFace( rSMgr->createInstance( OUString::createFromAscii("com.sun.star.script.EventAttacher") ) ); |
| if ( xIFace.is() ) |
| { |
| xAttacher = Reference< XEventAttacher >::query( xIFace ); |
| } |
| xIFace = rSMgr->createInstance( OUString::createFromAscii("com.sun.star.script.Converter") ); |
| if ( xIFace.is() ) |
| { |
| xConverter = Reference< XTypeConverter >::query( xIFace ); |
| } |
| } |
| |
| Reference< XInitialization > xInit( xAttacher, UNO_QUERY ); |
| if( xInit.is() ) |
| { |
| Sequence< Any > Arguments( 1 ); |
| Arguments[0] <<= rIntrospection; |
| xInit->initialize( Arguments ); |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| ImplEventAttacherManager::~ImplEventAttacherManager() |
| { |
| } |
| |
| Reference< XIdlReflection > ImplEventAttacherManager::getReflection() throw( Exception ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| // Haben wir den Service schon? Sonst anlegen |
| if( !mxCoreReflection.is() ) |
| { |
| Reference< XInterface > xIFace( mxSMgr->createInstance( OUString::createFromAscii("com.sun.star.reflection.CoreReflection") ) ); |
| mxCoreReflection = Reference< XIdlReflection >( xIFace, UNO_QUERY); |
| } |
| return mxCoreReflection; |
| } |
| |
| |
| //----------------------------------------------------------------------------- |
| ::std::deque<AttacherIndex_Impl>::iterator ImplEventAttacherManager::implCheckIndex( sal_Int32 _nIndex ) SAL_THROW ( ( IllegalArgumentException ) ) |
| { |
| if (_nIndex < 0) |
| throw IllegalArgumentException(); |
| |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = aIndex.begin(); |
| for ( sal_Int32 i = 0; (i < _nIndex) && (aIt != aIndex.end()); ++i, ++aIt ) |
| ; |
| |
| if( aIt == aIndex.end() ) |
| throw IllegalArgumentException(); |
| |
| return aIt; |
| } |
| |
| //----------------------------------------------------------------------------- |
| void detachAll_Impl |
| ( |
| ImplEventAttacherManager * pMgr, |
| sal_Int32 nIdx, |
| ::std::deque< AttachedObject_Impl > & rList |
| ) |
| { |
| ::std::deque< AttachedObject_Impl >::iterator aObjIt = rList.begin(); |
| ::std::deque< AttachedObject_Impl >::iterator aObjEnd = rList.end(); |
| while( aObjIt != aObjEnd ) |
| { |
| pMgr->detach( nIdx, (*aObjIt).xTarget ); |
| aObjIt++; |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| void attachAll_Impl |
| ( |
| ImplEventAttacherManager * pMgr, |
| sal_Int32 nIdx, |
| ::std::deque< AttachedObject_Impl > & rList |
| ) |
| { |
| ::std::deque< AttachedObject_Impl >::iterator aObjIt = rList.begin(); |
| ::std::deque< AttachedObject_Impl >::iterator aObjEnd = rList.end(); |
| while( aObjIt != aObjEnd ) |
| { |
| pMgr->attach( nIdx, (*aObjIt).xTarget, (*aObjIt).aHelper ); |
| aObjIt++; |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| //*** Methoden von XEventAttacherManager *** |
| void SAL_CALL ImplEventAttacherManager::registerScriptEvent |
| ( |
| sal_Int32 nIndex, |
| const ScriptEventDescriptor& ScriptEvent |
| ) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| |
| // Index pruefen und Array anpassen |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| ::std::deque< AttachedObject_Impl > aList = (*aIt).aObjList; |
| |
| ScriptEventDescriptor aEvt = ScriptEvent; |
| const sal_Unicode* pLastDot = aEvt.ListenerType.getStr(); |
| pLastDot += rtl_ustr_lastIndexOfChar( pLastDot, '.' ); |
| if( pLastDot ) |
| aEvt.ListenerType = pLastDot +1; |
| #ifdef DEQUE_OK |
| (*aIt).aEventList.push_back( aEvt ); |
| #else |
| (*aIt).aEventList.realloc( (*aIt).aEventList.getLength() +1 ); |
| (*aIt).aEventList.getArray()[(*aIt).aEventList.getLength() -1] = aEvt; |
| #endif |
| |
| // register new new Event |
| ::std::deque< AttachedObject_Impl >::iterator aObjIt = (*aIt).aObjList.begin(); |
| ::std::deque< AttachedObject_Impl >::iterator aObjEnd = (*aIt).aObjList.end(); |
| while( aObjIt != aObjEnd ) |
| { |
| // resize |
| sal_Int32 nPos = (*aObjIt).aAttachedListenerSeq.getLength(); |
| (*aObjIt).aAttachedListenerSeq.realloc( nPos + 1 ); |
| Reference< XEventListener > * pArray = (*aObjIt).aAttachedListenerSeq.getArray(); |
| |
| Reference< XAllListener > xAll = |
| new AttacherAllListener_Impl( this, ScriptEvent.ScriptType, ScriptEvent.ScriptCode ); |
| try |
| { |
| pArray[nPos] = xAttacher->attachSingleEventListener( (*aObjIt).xTarget, xAll, |
| (*aObjIt).aHelper, ScriptEvent.ListenerType, |
| ScriptEvent.AddListenerParam, ScriptEvent.EventMethod ); |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| aObjIt++; |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::registerScriptEvents |
| ( |
| sal_Int32 nIndex, |
| const Sequence< ScriptEventDescriptor >& ScriptEvents |
| ) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| |
| // Index pruefen und Array anpassen |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| ::std::deque< AttachedObject_Impl > aList = (*aIt).aObjList; |
| detachAll_Impl( this, nIndex, aList ); |
| |
| const ScriptEventDescriptor* pArray = ScriptEvents.getConstArray(); |
| sal_Int32 nLen = ScriptEvents.getLength(); |
| for( sal_Int32 i = 0 ; i < nLen ; i++ ) |
| registerScriptEvent( nIndex, pArray[ i ] ); |
| |
| attachAll_Impl( this, nIndex, aList ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::revokeScriptEvent |
| ( |
| sal_Int32 nIndex, |
| const OUString& ListenerType, |
| const OUString& EventMethod, |
| const OUString& ToRemoveListenerParam |
| ) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| ::std::deque< AttachedObject_Impl > aList = (*aIt).aObjList; |
| detachAll_Impl( this, nIndex, aList ); |
| |
| OUString aLstType = ListenerType; |
| const sal_Unicode * pLastDot = aLstType.getStr(); |
| pLastDot += rtl_ustr_lastIndexOfChar( pLastDot, '.' ); |
| if( pLastDot ) |
| aLstType = pLastDot +1; |
| |
| #ifdef DEQUE_OK |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtIt = (*aIt).aEventList.begin(); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtEnd = (*aIt).aEventList.end(); |
| while( aEvtIt != aEvtEnd ) |
| { |
| if( aLstType == (*aEvtIt).ListenerType |
| && EventMethod == (*aEvtIt).EventMethod |
| && ToRemoveListenerParam == (*aEvtIt).AddListenerParam ) |
| { |
| (*aIt).aEventList.erase( aEvtIt ); |
| break; |
| } |
| |
| aEvtIt++; |
| } |
| #else |
| Sequence< ScriptEventDescriptor >& rEventList = (*aIt).aEventList; |
| |
| ScriptEventDescriptor* pEventList = rEventList.getArray(); |
| const ScriptEventDescriptor* pEventListEnd = pEventList + rEventList.getLength(); |
| for( ; pEventList < pEventListEnd; ++pEventList ) |
| { |
| if ( (aLstType == pEventList->ListenerType ) |
| && (EventMethod == pEventList->EventMethod ) |
| && (ToRemoveListenerParam == pEventList->AddListenerParam) |
| ) |
| { |
| ScriptEventDescriptor* pMoveTo = pEventList; |
| const ScriptEventDescriptor* pMoveFrom = pMoveTo + 1; |
| while (pMoveFrom < pEventListEnd) |
| { |
| *pMoveTo++ = *pMoveFrom++; |
| } |
| rEventList.realloc( rEventList.getLength() - 1 ); |
| break; |
| } |
| } |
| #endif |
| attachAll_Impl( this, nIndex, aList ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::revokeScriptEvents(sal_Int32 nIndex ) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| ::std::deque< AttachedObject_Impl > aList = (*aIt).aObjList; |
| detachAll_Impl( this, nIndex, aList ); |
| #ifdef DEQUE_OK |
| (*aIt).aEventList = ::std::deque< ScriptEventDescriptor >(); |
| #else |
| (*aIt).aEventList.realloc( 0 ); |
| #endif |
| attachAll_Impl( this, nIndex, aList ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::insertEntry(sal_Int32 nIndex) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| if( nIndex < 0 ) |
| throw IllegalArgumentException(); |
| |
| // ::std::deque<AttacherIndex_Impl>::iterator aIt = aIndex.begin(); |
| // while( nIndex-- ) |
| // aIt++; |
| |
| if ( static_cast< ::std::deque< AttacherIndex_Impl >::size_type>(nIndex) >= aIndex.size() ) |
| aIndex.resize(nIndex+1); |
| |
| AttacherIndex_Impl aTmp; |
| aIndex.insert( aIndex.begin() + nIndex, aTmp ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::removeEntry(sal_Int32 nIndex) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| ::std::deque< AttachedObject_Impl > aList = (*aIt).aObjList; |
| detachAll_Impl( this, nIndex, aList ); |
| aIndex.erase( aIt ); |
| } |
| |
| //----------------------------------------------------------------------------- |
| Sequence< ScriptEventDescriptor > SAL_CALL ImplEventAttacherManager::getScriptEvents(sal_Int32 nIndex) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex ); |
| |
| #ifdef DEQUE_OK |
| Sequence< ScriptEventDescriptor > aSeq( (*aIt).aEventList.size() ); |
| ScriptEventDescriptor * pArray = aSeq.getArray(); |
| |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtIt = (*aIt).aEventList.begin(); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtEnd = (*aIt).aEventList.end(); |
| sal_Int32 i = 0; |
| while( aEvtIt != aEvtEnd ) |
| { |
| pArray[i++] = *aEvtIt; |
| aEvtIt++; |
| } |
| return aSeq; |
| #else |
| return (*aIt).aEventList; |
| #endif |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::attach(sal_Int32 nIndex, const Reference< XInterface >& xObject, const Any & Helper) |
| throw( IllegalArgumentException, ServiceNotRegisteredException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| if( nIndex < 0 || !xObject.is() ) |
| throw IllegalArgumentException(); |
| |
| if( static_cast< ::std::deque< AttacherIndex_Impl >::size_type>(nIndex) >= aIndex.size() ) |
| { |
| // alte Dateien lesen |
| if( nVersion == 1 ) |
| { |
| insertEntry( nIndex ); |
| attach( nIndex, xObject, Helper ); |
| return; |
| } |
| else |
| throw IllegalArgumentException(); |
| } |
| |
| ::std::deque< AttacherIndex_Impl >::iterator aCurrentPosition = aIndex.begin() + nIndex; |
| |
| AttachedObject_Impl aTmp; |
| aTmp.xTarget = xObject; |
| aTmp.aHelper = Helper; |
| aCurrentPosition->aObjList.push_back( aTmp ); |
| |
| //::std::deque< AttachedObject_Impl >::iterator aObjIt = (*aIt).aObjList.back(); |
| AttachedObject_Impl & rCurObj = aCurrentPosition->aObjList.back(); |
| #ifdef DEQUE_OK |
| rCurObj.aAttachedListenerSeq = Sequence< Reference< XEventListener > >( aCurrentPosition->aEventList.size() ); |
| #else |
| rCurObj.aAttachedListenerSeq = Sequence< Reference< XEventListener > >( aCurrentPosition->aEventList.getLength() ); |
| #endif |
| Reference< XEventListener > * pArray = rCurObj.aAttachedListenerSeq.getArray(); |
| |
| #ifdef DEQUE_OK |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtIt = aCurrentPosition->aEventList.begin(); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtEnd = aCurrentPosition->aEventList.end(); |
| sal_Int32 i = 0; |
| while( aEvtIt != aEvtEnd ) |
| { |
| Reference< XAllListener > xAll = |
| new AttacherAllListener_Impl( this, (*aEvtIt).ScriptType, (*aEvtIt).ScriptCode ); |
| Reference< XEventListener > xAdapter; |
| try |
| { |
| xAdapter = xAttacher->attachSingleEventListener( rCurObj.xTarget, xAll, |
| rCurObj.aHelper, (*aEvtIt).ScriptType, |
| (*aEvtIt).AddListenerParam, (*aEvtIt).EventMethod ); |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| pArray[i++] = xAdapter; |
| aEvtIt++; |
| } |
| #else |
| sal_Int32 nLen = aCurrentPosition->aEventList.getLength(); |
| ScriptEventDescriptor * pEL = aCurrentPosition->aEventList.getArray(); |
| for(sal_Int32 i = 0; i < nLen; ++i ) |
| { |
| Reference< XAllListener > xAll = |
| new AttacherAllListener_Impl( this, pEL[i].ScriptType, pEL[i].ScriptCode ); |
| Reference< XEventListener > xAdapter; |
| try |
| { |
| xAdapter = xAttacher->attachSingleEventListener( rCurObj.xTarget, xAll, |
| rCurObj.aHelper, pEL[i].ListenerType, |
| pEL[i].AddListenerParam, pEL[i].EventMethod ); |
| } |
| catch( Exception& ) |
| { |
| } |
| |
| pArray[i] = xAdapter; |
| } |
| #endif |
| } |
| |
| //----------------------------------------------------------------------------- |
| void SAL_CALL ImplEventAttacherManager::detach(sal_Int32 nIndex, const Reference< XInterface >& xObject) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| //return; |
| if( nIndex < 0 || static_cast< ::std::deque< AttacherIndex_Impl >::size_type>(nIndex) >= aIndex.size() || !xObject.is() ) |
| throw IllegalArgumentException(); |
| |
| ::std::deque< AttacherIndex_Impl >::iterator aCurrentPosition = aIndex.begin() + nIndex; |
| ::std::deque< AttachedObject_Impl >::iterator aObjIt = aCurrentPosition->aObjList.begin(); |
| ::std::deque< AttachedObject_Impl >::iterator aObjEnd = aCurrentPosition->aObjList.end(); |
| while( aObjIt != aObjEnd ) |
| { |
| if( (*aObjIt).xTarget == xObject ) |
| { |
| Reference< XEventListener > * pArray = (*aObjIt).aAttachedListenerSeq.getArray(); |
| #ifdef DEQUE_OK |
| |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtIt = aCurrentPosition->aEventList.begin(); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtEnd = aCurrentPosition->aEventList.end(); |
| sal_Int32 i = 0; |
| while( aEvtIt != aEvtEnd ) |
| { |
| if( pArray[i].is() ) |
| { |
| try |
| { |
| xAttacher->removeListener( (*aObjIt).xTarget, (*aEvtIt).ListenerType, |
| (*aEvtIt).AddListenerParam, pArray[i] ); |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| i++; |
| aEvtIt++; |
| } |
| #else |
| sal_Int32 nLen = aCurrentPosition->aEventList.getLength(); |
| ScriptEventDescriptor * pEL = aCurrentPosition->aEventList.getArray(); |
| for( sal_Int32 i = 0; i < nLen; i++ ) |
| { |
| if( pArray[i].is() ) |
| { |
| try |
| { |
| xAttacher->removeListener( (*aObjIt).xTarget, pEL[i].ListenerType, |
| pEL[i].AddListenerParam, pArray[i] ); |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| } |
| #endif |
| aCurrentPosition->aObjList.erase( aObjIt ); |
| break; |
| } |
| aObjIt++; |
| } |
| } |
| |
| void SAL_CALL ImplEventAttacherManager::addScriptListener(const Reference< XScriptListener >& aListener) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| aScriptListeners.addInterface( aListener ); |
| } |
| |
| void SAL_CALL ImplEventAttacherManager::removeScriptListener(const Reference< XScriptListener >& aListener) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| aScriptListeners.removeInterface( aListener ); |
| } |
| |
| |
| // Methoden von XPersistObject |
| OUString SAL_CALL ImplEventAttacherManager::getServiceName(void) |
| throw( RuntimeException ) |
| { |
| return OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uno.script.EventAttacherManager") ); |
| } |
| |
| void SAL_CALL ImplEventAttacherManager::write(const Reference< XObjectOutputStream >& OutStream) |
| throw( IOException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| // Ohne XMarkableStream laeuft nichts |
| Reference< XMarkableStream > xMarkStream( OutStream, UNO_QUERY ); |
| if( !xMarkStream.is() ) |
| return; |
| |
| // Version schreiben |
| OutStream->writeShort( 2 ); |
| |
| // Position fuer Laenge merken |
| sal_Int32 nObjLenMark = xMarkStream->createMark(); |
| OutStream->writeLong( 0L ); |
| |
| OutStream->writeLong( aIndex.size() ); |
| |
| // Sequences schreiben |
| ::std::deque<AttacherIndex_Impl>::iterator aIt = aIndex.begin(); |
| ::std::deque<AttacherIndex_Impl>::iterator aEnd = aIndex.end(); |
| while( aIt != aEnd ) |
| { |
| #ifdef DEQUE_OK |
| // Laenge der Sequence und alle Descriptoren schreiben |
| OutStream->writeLong( (*aIt).aEventList.size() ); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtIt = (*aIt).aEventList.begin(); |
| ::std::deque< ScriptEventDescriptor >::iterator aEvtEnd = (*aIt).aEventList.end(); |
| while( aEvtIt != aEvtEnd ) |
| { |
| const ScriptEventDescriptor& rDesc = (*aEvtIt); |
| OutStream->writeUTF( rDesc.ListenerType ); |
| OutStream->writeUTF( rDesc.EventMethod ); |
| OutStream->writeUTF( rDesc.AddListenerParam ); |
| OutStream->writeUTF( rDesc.ScriptType ); |
| OutStream->writeUTF( rDesc.ScriptCode ); |
| |
| aEvtIt++; |
| } |
| #else |
| sal_Int32 nLen = (*aIt).aEventList.getLength(); |
| // Laenge der Sequence und alle Descriptoren schreiben |
| OutStream->writeLong( nLen ); |
| ScriptEventDescriptor * pEL = (*aIt).aEventList.getArray(); |
| for( sal_Int32 i = 0; i < nLen; i++ ) |
| { |
| const ScriptEventDescriptor& rDesc = pEL[i]; |
| OutStream->writeUTF( rDesc.ListenerType ); |
| OutStream->writeUTF( rDesc.EventMethod ); |
| OutStream->writeUTF( rDesc.AddListenerParam ); |
| OutStream->writeUTF( rDesc.ScriptType ); |
| OutStream->writeUTF( rDesc.ScriptCode ); |
| } |
| #endif |
| aIt++; |
| } |
| |
| // Die jetzt bekannte Laenge eintragen |
| sal_Int32 nObjLen = xMarkStream->offsetToMark( nObjLenMark ) -4; |
| xMarkStream->jumpToMark( nObjLenMark ); |
| OutStream->writeLong( nObjLen ); |
| xMarkStream->jumpToFurthest(); |
| xMarkStream->deleteMark( nObjLenMark ); |
| } |
| |
| void SAL_CALL ImplEventAttacherManager::read(const Reference< XObjectInputStream >& InStream) |
| throw( IOException, RuntimeException ) |
| { |
| Guard< Mutex > aGuard( aLock ); |
| // Ohne XMarkableStream laeuft nichts |
| Reference< XMarkableStream > xMarkStream( InStream, UNO_QUERY ); |
| if( !xMarkStream.is() ) |
| return; |
| |
| // Version lesen |
| nVersion = InStream->readShort(); |
| |
| // Zunaechst kommen die Daten gemaess Version 1, |
| // muss auch bei hoeheren Versionen beibehalten werden |
| sal_Int32 nLen = InStream->readLong(); |
| |
| // Position fuer Vergleichszwecke |
| sal_Int32 nObjLenMark = xMarkStream->createMark(); |
| |
| // Anzahl der zu lesenden Sequences |
| sal_Int32 nItemCount = InStream->readLong(); |
| |
| for( sal_Int32 i = 0 ; i < nItemCount ; i++ ) |
| { |
| insertEntry( i ); |
| // Laenge der Sequence lesen |
| sal_Int32 nSeqLen = InStream->readLong(); |
| |
| // Sequence anlegen und Descriptoren lesen |
| Sequence< ScriptEventDescriptor > aSEDSeq( nSeqLen ); |
| ScriptEventDescriptor* pArray = aSEDSeq.getArray(); |
| for( sal_Int32 j = 0 ; j < nSeqLen ; j++ ) |
| { |
| ScriptEventDescriptor& rDesc = pArray[ j ]; |
| rDesc.ListenerType = InStream->readUTF(); |
| rDesc.EventMethod = InStream->readUTF(); |
| rDesc.AddListenerParam = InStream->readUTF(); |
| rDesc.ScriptType = InStream->readUTF(); |
| rDesc.ScriptCode = InStream->readUTF(); |
| } |
| registerScriptEvents( i, aSEDSeq ); |
| } |
| |
| // Haben wir die angegebene Laenge gelesen? |
| sal_Int32 nRealLen = xMarkStream->offsetToMark( nObjLenMark ); |
| if( nRealLen != nLen ) |
| { |
| // Nur wenn die StreamVersion > 1 ist und noch Daten folgen, kann das |
| // Ganze richtig sein. Sonst ist etwas voellig daneben gegangen. |
| if( nRealLen > nLen || nVersion == 1 ) |
| { |
| VOS_ENSHURE( sal_False, "ImplEventAttacherManager::read(): Fatal Error, wrong object length" ); |
| } |
| else |
| { |
| // TODO: Pruefen, ob Zwischen-Speicherung der Daten sinnvoll sein koennte |
| |
| // Vorerst einfach nur Skippen |
| sal_Int32 nSkipCount = nLen - nRealLen; |
| InStream->skipBytes( nSkipCount ); |
| } |
| } |
| xMarkStream->jumpToFurthest(); |
| xMarkStream->deleteMark( nObjLenMark ); |
| } |
| |
| } // namesapce comphelper |
| |
| |
