eventattacher/source/eventattacher.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28 #include <osl/diagnose.h>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/lang/XInitialization.hpp>
  31 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  32 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  33 #include <com/sun/star/registry/XRegistryKey.hpp>
  34 #include <com/sun/star/beans/XIntrospection.hpp>
  35 #include <com/sun/star/beans/MethodConcept.hpp>
  36 #include <com/sun/star/script/XEventAttacher2.hpp>
  37 #include <com/sun/star/script/XTypeConverter.hpp>
  38 #include <com/sun/star/script/XAllListener.hpp>
  39 #include <com/sun/star/script/XInvocationAdapterFactory.hpp>
  40 #include <com/sun/star/reflection/XIdlReflection.hpp>
  41
  42 // InvocationToAllListenerMapper
  43 #include <com/sun/star/script/XInvocation.hpp>
  44 #include <cppuhelper/weak.hxx>
  45 #include <cppuhelper/factory.hxx>
  46 #include <cppuhelper/implbase1.hxx>
  47 #include <cppuhelper/implbase3.hxx>
  48
  49 using namespace com::sun::star::uno;
  50 using namespace com::sun::star::registry;
  51 using namespace com::sun::star::lang;
  52 using namespace com::sun::star::beans;
  53 using namespace com::sun::star::script;
  54 using namespace com::sun::star::reflection;
  55 using namespace cppu;
  56 using namespace osl;
  57
  58 using ::rtl::OUString;
  59
  60
  61 #define SERVICENAME "com.sun.star.script.EventAttacher"
  62 #define IMPLNAME    "com.sun.star.comp.EventAttacher"
  63
  64 namespace comp_EventAttacher {
  65
  66 //*************************************************************************
  67 //  class InvocationToAllListenerMapper
  68 //  helper class to map XInvocation to XAllListener
  69 //*************************************************************************
  70 class InvocationToAllListenerMapper : public WeakImplHelper1< XInvocation >
  71 {
  72 public:
  73     InvocationToAllListenerMapper( const Reference< XIdlClass >& ListenerType,
  74         const Reference< XAllListener >& AllListener, const Any& Helper );
  75
  76     // XInvocation
  77     virtual Reference< XIntrospectionAccess > SAL_CALL getIntrospection(void) throw( RuntimeException );
  78     virtual Any SAL_CALL invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam)
  79         throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException );
  80     virtual void SAL_CALL setValue(const OUString& PropertyName, const Any& Value)
  81         throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException );
  82     virtual Any SAL_CALL getValue(const OUString& PropertyName) throw( UnknownPropertyException, RuntimeException );
  83     virtual sal_Bool SAL_CALL hasMethod(const OUString& Name) throw( RuntimeException );
  84     virtual sal_Bool SAL_CALL hasProperty(const OUString& Name) throw( RuntimeException );
  85
  86 private:
  87     Reference< XIdlReflection >  m_xCoreReflection;
  88     Reference< XAllListener >    m_xAllListener;
  89     Reference< XIdlClass >       m_xListenerType;
  90     Any                          m_Helper;
  91 };
  92
  93
  94 // Function to replace AllListenerAdapterService::createAllListerAdapter
  95 Reference< XInterface > createAllListenerAdapter
  96 (
  97     const Reference< XInvocationAdapterFactory >& xInvocationAdapterFactory,
  98     const Reference< XIdlClass >& xListenerType,
  99     const Reference< XAllListener >& xListener,
 100     const Any& Helper
 101 )
 102 {
 103     Reference< XInterface > xAdapter;
 104     if( xInvocationAdapterFactory.is() && xListenerType.is() && xListener.is() )
 105     {
 106        Reference< XInvocation > xInvocationToAllListenerMapper =
 107             (XInvocation*)new InvocationToAllListenerMapper( xListenerType, xListener, Helper );
 108         Type aListenerType( xListenerType->getTypeClass(), xListenerType->getName());
 109         xAdapter = xInvocationAdapterFactory->createAdapter( xInvocationToAllListenerMapper, aListenerType );
 110     }
 111     return xAdapter;
 112 }
 113
 114
 115 //--------------------------------------------------------------------------------------------------
 116 // InvocationToAllListenerMapper
 117 InvocationToAllListenerMapper::InvocationToAllListenerMapper
 118     ( const Reference< XIdlClass >& ListenerType, const Reference< XAllListener >& AllListener, const Any& Helper )
 119         : m_xAllListener( AllListener )
 120         , m_xListenerType( ListenerType )
 121         , m_Helper( Helper )
 122 {
 123 }
 124
 125 //*************************************************************************
 126 Reference< XIntrospectionAccess > SAL_CALL InvocationToAllListenerMapper::getIntrospection(void)
 127     throw( RuntimeException )
 128 {
 129     return Reference< XIntrospectionAccess >();
 130 }
 131
 132 //*************************************************************************
 133 Any SAL_CALL InvocationToAllListenerMapper::invoke(const OUString& FunctionName, const Sequence< Any >& Params,
 134     Sequence< sal_Int16 >& , Sequence< Any >& )
 135         throw( IllegalArgumentException, CannotConvertException,
 136         InvocationTargetException, RuntimeException )
 137 {
 138     Any aRet;
 139
 140     // Check if to firing or approveFiring has to be called
 141     Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( FunctionName );
 142     sal_Bool bApproveFiring = sal_False;
 143     if( !xMethod.is() )
 144         return aRet;
 145     Reference< XIdlClass > xReturnType = xMethod->getReturnType();
 146     Sequence< Reference< XIdlClass > > aExceptionSeq = xMethod->getExceptionTypes();
 147     if( ( xReturnType.is() && xReturnType->getTypeClass() != TypeClass_VOID ) ||
 148         aExceptionSeq.getLength() > 0 )
 149     {
 150         bApproveFiring = sal_True;
 151     }
 152     else
 153     {
 154         Sequence< ParamInfo > aParamSeq = xMethod->getParameterInfos();
 155         sal_uInt32 nParamCount = aParamSeq.getLength();
 156         if( nParamCount > 1 )
 157         {
 158             const ParamInfo* pInfos = aParamSeq.getConstArray();
 159             for( sal_uInt32 i = 0 ; i < nParamCount ; i++ )
 160             {
 161                 if( pInfos[ i ].aMode != ParamMode_IN )
 162                 {
 163                     bApproveFiring = sal_True;
 164                     break;
 165                 }
 166             }
 167         }
 168     }
 169
 170     AllEventObject aAllEvent;
 171     aAllEvent.Source = (OWeakObject*) this;
 172     aAllEvent.Helper = m_Helper;
 173     aAllEvent.ListenerType = Type(m_xListenerType->getTypeClass(), m_xListenerType->getName());
 174     aAllEvent.MethodName = FunctionName;
 175     aAllEvent.Arguments = Params;
 176     if( bApproveFiring )
 177         aRet = m_xAllListener->approveFiring( aAllEvent );
 178     else
 179         m_xAllListener->firing( aAllEvent );
 180     return aRet;
 181 }
 182
 183 //*************************************************************************
 184 void SAL_CALL InvocationToAllListenerMapper::setValue(const OUString& , const Any& )
 185     throw( UnknownPropertyException, CannotConvertException,
 186            InvocationTargetException, RuntimeException )
 187 {
 188 }
 189
 190 //*************************************************************************
 191 Any SAL_CALL InvocationToAllListenerMapper::getValue(const OUString& )
 192     throw( UnknownPropertyException, RuntimeException )
 193 {
 194     return Any();
 195 }
 196
 197 //*************************************************************************
 198 sal_Bool SAL_CALL InvocationToAllListenerMapper::hasMethod(const OUString& Name)
 199     throw( RuntimeException )
 200 {
 201     Reference< XIdlMethod > xMethod = m_xListenerType->getMethod( Name );
 202     return xMethod.is();
 203 }
 204
 205 //*************************************************************************
 206 sal_Bool SAL_CALL InvocationToAllListenerMapper::hasProperty(const OUString& Name)
 207     throw( RuntimeException )
 208 {
 209     Reference< XIdlField > xField = m_xListenerType->getField( Name );
 210     return xField.is();
 211 }
 212
 213 //*************************************************************************
 214 //  class EventAttacherImpl
 215 //  represents an implementation of the EventAttacher service
 216 //*************************************************************************
 217 class EventAttacherImpl : public WeakImplHelper3 < XEventAttacher2, XInitialization, XServiceInfo >
 218 {
 219 public:
 220     EventAttacherImpl( const Reference< XMultiServiceFactory >& );
 221     ~EventAttacherImpl();
 222
 223     // XServiceInfo
 224     virtual OUString SAL_CALL getImplementationName(  ) throw(RuntimeException);
 225     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
 226     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw(RuntimeException);
 227     static OUString SAL_CALL getImplementationName_Static(  );
 228     static Sequence< OUString > SAL_CALL getSupportedServiceNames_Static(  );
 229
 230     // XInitialization
 231     virtual void SAL_CALL initialize( const Sequence< Any >& aArguments )
 232         throw( Exception, RuntimeException);
 233
 234     // Methoden von XEventAttacher
 235     virtual Reference< XEventListener > SAL_CALL attachListener(const Reference< XInterface >& xObject,
 236             const Reference< XAllListener >& AllListener, const Any& Helper,
 237             const OUString& ListenerType, const OUString& AddListenerParam)
 238         throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException );
 239     virtual Reference< XEventListener > SAL_CALL attachSingleEventListener(const Reference< XInterface >& xObject,
 240             const Reference< XAllListener >& AllListener, const Any& Helper,
 241             const OUString& ListenerType, const OUString& AddListenerParam,
 242             const OUString& EventMethod)
 243         throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException );
 244     virtual void SAL_CALL removeListener(const Reference< XInterface >& xObject,
 245             const OUString& ListenerType, const OUString& AddListenerParam,
 246             const Reference< XEventListener >& aToRemoveListener)
 247         throw( IllegalArgumentException, IntrospectionException, RuntimeException );
 248
 249     // XEventAttacher2
 250     virtual Sequence< Reference<XEventListener> > SAL_CALL attachMultipleEventListeners(
 251         const Reference<XInterface>& xObject, const Sequence<com::sun::star::script::EventListener>& aListeners )
 252             throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException );
 253
 254     // used by FilterAllListener_Impl
 255     Reference< XTypeConverter > getConverter() throw( Exception );
 256
 257     friend class FilterAllListenerImpl;
 258
 259 private:
 260     Reference<XEventListener> attachListenerForTarget(
 261         const Reference<XIntrospectionAccess>& xAccess,
 262         const Reference<XInvocationAdapterFactory>& xInvocationAdapterFactory,
 263         const Reference<XAllListener>& xAllListener,
 264         const Any& aObject,
 265         const Any& aHelper,
 266         const OUString& aListenerType,
 267         const OUString& aAddListenerParam );
 268
 269     Sequence< Reference<XEventListener> > attachListeners(
 270         const Reference<XInterface>& xObject,
 271         const Sequence< Reference<XAllListener> >& AllListeners,
 272         const Sequence<com::sun::star::script::EventListener>& aListeners );
 273
 274 private:
 275     Mutex                               m_aMutex;
 276     Reference< XMultiServiceFactory >   m_xSMgr;
 277
 278     // Save Services
 279     Reference< XIntrospection >             m_xIntrospection;
 280     Reference< XIdlReflection >             m_xReflection;
 281     Reference< XTypeConverter >             m_xConverter;
 282     Reference< XInvocationAdapterFactory >  m_xInvocationAdapterFactory;
 283
 284     // needed services
 285     Reference< XIntrospection >             getIntrospection() throw( Exception );
 286     Reference< XIdlReflection >             getReflection() throw( Exception );
 287     Reference< XInvocationAdapterFactory >  getInvocationAdapterService() throw( Exception );
 288 };
 289
 290
 291 //*************************************************************************
 292 EventAttacherImpl::EventAttacherImpl( const Reference< XMultiServiceFactory >& rSMgr )
 293     : m_xSMgr( rSMgr )
 294 {
 295 }
 296
 297 //*************************************************************************
 298 EventAttacherImpl::~EventAttacherImpl()
 299 {
 300 }
 301
 302 //*************************************************************************
 303 Reference< XInterface > SAL_CALL EventAttacherImpl_CreateInstance( const Reference< XMultiServiceFactory >& rSMgr ) throw( Exception )
 304 {
 305     Reference< XInterface > xRet;
 306     XEventAttacher *pEventAttacher = (XEventAttacher*) new EventAttacherImpl(rSMgr);
 307
 308     if (pEventAttacher)
 309     {
 310         xRet = Reference<XInterface>::query(pEventAttacher);
 311     }
 312
 313     return xRet;
 314 }
 315
 316 //*************************************************************************
 317 OUString SAL_CALL EventAttacherImpl::getImplementationName(  )
 318     throw(RuntimeException)
 319 {
 320     return OUString(  IMPLNAME  );
 321 }
 322
 323 //*************************************************************************
 324 sal_Bool SAL_CALL EventAttacherImpl::supportsService( const OUString& ServiceName )
 325     throw(RuntimeException)
 326 {
 327     Sequence< OUString > aSNL = getSupportedServiceNames();
 328     const OUString * pArray = aSNL.getArray();
 329     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 330         if( pArray[i] == ServiceName )
 331             return sal_True;
 332     return sal_False;
 333 }
 334
 335 //*************************************************************************
 336 Sequence<OUString> SAL_CALL EventAttacherImpl::getSupportedServiceNames(  )
 337     throw(RuntimeException)
 338 {
 339     return getSupportedServiceNames_Static();
 340 }
 341
 342 //*************************************************************************
 343 Sequence<OUString> SAL_CALL EventAttacherImpl::getSupportedServiceNames_Static(  )
 344 {
 345     OUString aStr(  SERVICENAME  );
 346     return Sequence< OUString >( &aStr, 1 );
 347 }
 348
 349 //*************************************************************************
 350 void SAL_CALL EventAttacherImpl::initialize(const Sequence< Any >& Arguments) throw( Exception, RuntimeException )
 351 {
 352     // get services from the argument list
 353     const Any * pArray = Arguments.getConstArray();
 354     for( sal_Int32 i = 0; i < Arguments.getLength(); i++ )
 355     {
 356         if( pArray[i].getValueType().getTypeClass() != TypeClass_INTERFACE )
 357             throw IllegalArgumentException();
 358
 359         // InvocationAdapter service ?
 360         Reference< XInvocationAdapterFactory > xALAS;
 361         pArray[i] >>= xALAS;
 362         if( xALAS.is() )
 363         {
 364             Guard< Mutex > aGuard( m_aMutex );
 365             m_xInvocationAdapterFactory = xALAS;
 366         }
 367         // Introspection service ?
 368         Reference< XIntrospection > xI;
 369         pArray[i] >>= xI;
 370         if( xI.is() )
 371         {
 372             Guard< Mutex > aGuard( m_aMutex );
 373             m_xIntrospection = xI;
 374         }
 375         // Reflection service ?
 376         Reference< XIdlReflection > xIdlR;
 377         pArray[i] >>= xIdlR;
 378         if( xIdlR.is() )
 379         {
 380             Guard< Mutex > aGuard( m_aMutex );
 381             m_xReflection = xIdlR;
 382         }
 383         // Converter Service ?
 384         Reference< XTypeConverter > xC;
 385         pArray[i] >>= xC;
 386         if( xC.is() )
 387         {
 388             Guard< Mutex > aGuard( m_aMutex );
 389             m_xConverter = xC;
 390         }
 391
 392         // no right interface
 393         if( !xALAS.is() && !xI.is() && !xIdlR.is() && !xC.is() )
 394             throw IllegalArgumentException();
 395     }
 396 }
 397
 398 //*************************************************************************
 399 //*** Private helper methods ***
 400 Reference< XIntrospection > EventAttacherImpl::getIntrospection() throw( Exception )
 401 {
 402     Guard< Mutex > aGuard( m_aMutex );
 403     if( !m_xIntrospection.is() )
 404     {
 405         Reference< XInterface > xIFace( m_xSMgr->createInstance( rtl::OUString("com.sun.star.beans.Introspection") ) );
 406         m_xIntrospection = Reference< XIntrospection >( xIFace, UNO_QUERY );
 407     }
 408     return m_xIntrospection;
 409 }
 410
 411 //*************************************************************************
 412 //*** Private helper methods ***
 413 Reference< XIdlReflection > EventAttacherImpl::getReflection() throw( Exception )
 414 {
 415     Guard< Mutex > aGuard( m_aMutex );
 416     if( !m_xReflection.is() )
 417     {
 418         Reference< XInterface > xIFace( m_xSMgr->createInstance( rtl::OUString("com.sun.star.reflection.CoreReflection") ) );
 419         m_xReflection = Reference< XIdlReflection >( xIFace, UNO_QUERY);
 420     }
 421     return m_xReflection;
 422 }
 423
 424 //*************************************************************************
 425 //*** Private helper methods ***
 426 Reference< XInvocationAdapterFactory > EventAttacherImpl::getInvocationAdapterService() throw( Exception )
 427 {
 428     Guard< Mutex > aGuard( m_aMutex );
 429     if( !m_xInvocationAdapterFactory.is() )
 430     {
 431         Reference< XInterface > xIFace( m_xSMgr->createInstance( rtl::OUString("com.sun.star.script.InvocationAdapterFactory") ) );
 432         m_xInvocationAdapterFactory = Reference< XInvocationAdapterFactory >( xIFace, UNO_QUERY );
 433     }
 434     return m_xInvocationAdapterFactory;
 435 }
 436
 437
 438 //*************************************************************************
 439 //*** Private helper methods ***
 440 Reference< XTypeConverter > EventAttacherImpl::getConverter() throw( Exception )
 441 {
 442     Guard< Mutex > aGuard( m_aMutex );
 443     if( !m_xConverter.is() )
 444     {
 445         Reference< XInterface > xIFace( m_xSMgr->createInstance( rtl::OUString("com.sun.star.script.Converter") ) );
 446         m_xConverter = Reference< XTypeConverter >( xIFace, UNO_QUERY );
 447     }
 448     return m_xConverter;
 449 }
 450
 451 //------------------------------------------------------------------------
 452 //------------------------------------------------------------------------
 453 //------------------------------------------------------------------------
 454 // Implementation of an EventAttacher-related AllListeners, which brings
 455 // a few Events to a general AllListener
 456 class FilterAllListenerImpl : public WeakImplHelper1< XAllListener  >
 457 {
 458 public:
 459     FilterAllListenerImpl( EventAttacherImpl * pEA_, const OUString& EventMethod_,
 460                            const Reference< XAllListener >& AllListener_ );
 461
 462     // XAllListener
 463     virtual void SAL_CALL firing(const AllEventObject& Event) throw( RuntimeException );
 464     virtual Any SAL_CALL approveFiring(const AllEventObject& Event) throw( InvocationTargetException, RuntimeException );
 465
 466     // XEventListener
 467     virtual void SAL_CALL disposing(const EventObject& Source) throw( RuntimeException );
 468
 469 private:
 470     // convert
 471     void convertToEventReturn( Any & rRet, const Type& rRetType )
 472             throw( CannotConvertException );
 473
 474     EventAttacherImpl *         m_pEA;
 475     Reference< XInterface >     m_xEAHold;
 476     OUString                    m_EventMethod;
 477     Reference< XAllListener >   m_AllListener;
 478 };
 479
 480 //*************************************************************************
 481 FilterAllListenerImpl::FilterAllListenerImpl( EventAttacherImpl * pEA_, const OUString& EventMethod_,
 482                                               const Reference< XAllListener >& AllListener_ )
 483         : m_pEA( pEA_ )
 484         , m_xEAHold( *pEA_ )
 485         , m_EventMethod( EventMethod_ )
 486         , m_AllListener( AllListener_ )
 487 {
 488 }
 489
 490 //*************************************************************************
 491 void SAL_CALL FilterAllListenerImpl::firing(const AllEventObject& Event)
 492     throw( RuntimeException )
 493 {
 494     if( Event.MethodName == m_EventMethod && m_AllListener.is() )
 495         m_AllListener->firing( Event );
 496 }
 497
 498 //*************************************************************************
 499 // Convert to the standard event return
 500 void FilterAllListenerImpl::convertToEventReturn( Any & rRet, const Type & rRetType )
 501     throw( CannotConvertException )
 502 {
 503     // no return value? Set to the specified values
 504     if( rRet.getValueType().getTypeClass() == TypeClass_VOID )
 505     {
 506         switch( rRetType.getTypeClass()  )
 507         {
 508             case TypeClass_INTERFACE:
 509                 {
 510                 rRet <<= Reference< XInterface >();
 511                 }
 512                 break;
 513
 514             case TypeClass_BOOLEAN:
 515                 rRet <<= sal_True;
 516                 break;
 517
 518             case TypeClass_STRING:
 519                 rRet <<= OUString();
 520                 break;
 521
 522             case TypeClass_FLOAT:           rRet <<= float(0);  break;
 523             case TypeClass_DOUBLE:          rRet <<= double(0.0);   break;
 524             case TypeClass_BYTE:            rRet <<= sal_uInt8( 0 );    break;
 525             case TypeClass_SHORT:           rRet <<= sal_Int16( 0 );    break;
 526             case TypeClass_LONG:            rRet <<= sal_Int32( 0 );    break;
 527             case TypeClass_UNSIGNED_SHORT:  rRet <<= sal_uInt16( 0 );   break;
 528             case TypeClass_UNSIGNED_LONG:   rRet <<= sal_uInt32( 0 );   break;
 529                      default:
 530             break;
 531         }
 532     }
 533     else if( !rRet.getValueType().equals( rRetType ) )
 534     {
 535         Reference< XTypeConverter > xConverter = m_pEA->getConverter();
 536         if( xConverter.is() )
 537             rRet = xConverter->convertTo( rRet, rRetType );
 538         else
 539             throw CannotConvertException(); // TODO TypeConversionException
 540     }
 541 }
 542
 543 //*************************************************************************
 544 Any SAL_CALL FilterAllListenerImpl::approveFiring( const AllEventObject& Event )
 545     throw( InvocationTargetException, RuntimeException )
 546 {
 547     Any aRet;
 548
 549     if( Event.MethodName == m_EventMethod && m_AllListener.is() )
 550         aRet = m_AllListener->approveFiring( Event );
 551     else
 552     {
 553         // Convert to the standard event return
 554         try
 555         {
 556             Reference< XIdlClass > xListenerType = m_pEA->getReflection()->
 557                         forName( Event.ListenerType.getTypeName() );
 558             Reference< XIdlMethod > xMeth = xListenerType->getMethod( Event.MethodName );
 559             if( xMeth.is() )
 560             {
 561                 Reference< XIdlClass > xRetType = xMeth->getReturnType();
 562                 Type aRetType( xRetType->getTypeClass(), xRetType->getName() );
 563                 convertToEventReturn( aRet, aRetType );
 564             }
 565         }
 566         catch( const CannotConvertException& e )
 567         {
 568             throw InvocationTargetException( OUString(), Reference< XInterface >(), Any(&e, ::getCppuType( (CannotConvertException*)0)) );
 569         }
 570     }
 571     return aRet;
 572 }
 573
 574 //*************************************************************************
 575 void FilterAllListenerImpl::disposing(const EventObject& )
 576     throw( RuntimeException )
 577 {
 578     // TODO: ???
 579 }
 580
 581
 582 //*************************************************************************
 583 Reference< XEventListener > EventAttacherImpl::attachListener
 584 (
 585     const Reference< XInterface >& xObject,
 586     const Reference< XAllListener >& AllListener,
 587     const Any& Helper,
 588     const OUString& ListenerType,
 589     const OUString& AddListenerParam
 590 )
 591     throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException )
 592 {
 593     if( !xObject.is() || !AllListener.is() )
 594         throw IllegalArgumentException();
 595
 596     Reference< XInvocationAdapterFactory > xInvocationAdapterFactory = getInvocationAdapterService();
 597     if( !xInvocationAdapterFactory.is() )
 598         throw ServiceNotRegisteredException();
 599
 600     Reference< XIdlReflection > xReflection = getReflection();
 601     if( !xReflection.is() )
 602         throw ServiceNotRegisteredException();
 603
 604     // Sign in, Call the fitting addListener method
 605     // First Introspection, as the Methods can be analyzed in the same way
 606     // For better perfomance it is implemented here again or make the Impl-Method
 607     // of the Introspection configurable for this purpose.
 608     Reference< XIntrospection > xIntrospection = getIntrospection();
 609     if( !xIntrospection.is() )
 610         return Reference<XEventListener>();
 611
 612     // Inspect Introspection
 613     Any aObjAny( &xObject, ::getCppuType( (const Reference< XInterface > *)0) );
 614
 615     Reference< XIntrospectionAccess > xAccess = xIntrospection->inspect( aObjAny );
 616     if( !xAccess.is() )
 617         return Reference<XEventListener>();
 618
 619     return attachListenerForTarget(
 620         xAccess, xInvocationAdapterFactory, AllListener, aObjAny, Helper,
 621         ListenerType, AddListenerParam);
 622 }
 623
 624 Reference<XEventListener> EventAttacherImpl::attachListenerForTarget(
 625     const Reference<XIntrospectionAccess>& xAccess,
 626     const Reference<XInvocationAdapterFactory>& xInvocationAdapterFactory,
 627     const Reference<XAllListener>& xAllListener,
 628     const Any& aObject,
 629     const Any& aHelper,
 630     const OUString& aListenerType,
 631     const OUString& aAddListenerParam)
 632 {
 633     Reference< XEventListener > xRet = NULL;
 634
 635     // Construct the name of the addListener-Method.
 636     sal_Int32 nIndex = aListenerType.lastIndexOf('.');
 637     // set index to the interface name without package name
 638     if( nIndex == -1 )
 639         // not found
 640         nIndex = 0;
 641     else
 642         nIndex++;
 643
 644     OUString aListenerName = (aListenerType[nIndex] == 'X') ? aListenerType.copy(nIndex+1) : aListenerType;
 645     OUString aAddListenerName = OUString("add") + aListenerName;
 646
 647     // Send Methods to the correct addListener-Method
 648     Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods( MethodConcept::LISTENER );
 649     const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
 650     for (sal_Int32 i = 0, n = aMethodSeq.getLength(); i < n ; ++i)
 651     {
 652         const Reference< XIdlMethod >& rxMethod = pMethods[i];
 653
 654         // Is it the correct method?
 655         OUString aMethName = rxMethod->getName();
 656
 657         if (aAddListenerName != aMethName)
 658             continue;
 659
 660         Sequence< Reference< XIdlClass > > params = rxMethod->getParameterTypes();
 661         sal_uInt32 nParamCount = params.getLength();
 662
 663         Reference< XIdlClass > xListenerType;
 664         if( nParamCount == 1 )
 665             xListenerType = params.getConstArray()[0];
 666         else if( nParamCount == 2 )
 667             xListenerType = params.getConstArray()[1];
 668
 669         // Request Adapter for the actual Listener type
 670         Reference< XInterface > xAdapter = createAllListenerAdapter(
 671             xInvocationAdapterFactory, xListenerType, xAllListener, aHelper );
 672
 673         if( !xAdapter.is() )
 674             throw CannotCreateAdapterException();
 675         xRet = Reference< XEventListener >( xAdapter, UNO_QUERY );
 676
 677         // Just the Listener as parameter?
 678         if( nParamCount == 1 )
 679         {
 680             Sequence< Any > args( 1 );
 681             args.getArray()[0] <<= xAdapter;
 682             try
 683             {
 684                 rxMethod->invoke( aObject, args );
 685             }
 686             catch( const InvocationTargetException& )
 687             {
 688                 throw IntrospectionException();
 689             }
 690         }
 691         // Else, pass the other parameter now
 692         else if( nParamCount == 2 )
 693         {
 694             Sequence< Any > args( 2 );
 695             Any* pAnys = args.getArray();
 696
 697             // Check the type of the 1st parameter
 698             Reference< XIdlClass > xParamClass = params.getConstArray()[0];
 699             if( xParamClass->getTypeClass() == TypeClass_STRING )
 700             {
 701                 pAnys[0] <<= aAddListenerParam;
 702             }
 703
 704             // 2nd Parameter == Listener? TODO: Test!
 705             pAnys[1] <<= xAdapter;
 706
 707             // TODO: Convert String -> ?
 708             // else
 709             try
 710             {
 711                 rxMethod->invoke( aObject, args );
 712             }
 713             catch( const InvocationTargetException& )
 714             {
 715                 throw IntrospectionException();
 716             }
 717         }
 718         break;
 719         // else...
 720         // Anything else is not supported
 721     }
 722
 723     return xRet;
 724 }
 725
 726 Sequence< Reference<XEventListener> > EventAttacherImpl::attachListeners(
 727     const Reference<XInterface>& xObject,
 728     const Sequence< Reference<XAllListener> >& AllListeners,
 729     const Sequence<com::sun::star::script::EventListener>& aListeners )
 730 {
 731     sal_Int32 nCount = aListeners.getLength();
 732     if (nCount != AllListeners.getLength())
 733         // This is a prerequisite!
 734         throw RuntimeException();
 735
 736     if (!xObject.is())
 737         throw IllegalArgumentException();
 738
 739     Reference< XInvocationAdapterFactory > xInvocationAdapterFactory = getInvocationAdapterService();
 740     if( !xInvocationAdapterFactory.is() )
 741         throw ServiceNotRegisteredException();
 742
 743     Reference< XIdlReflection > xReflection = getReflection();
 744     if( !xReflection.is() )
 745         throw ServiceNotRegisteredException();
 746
 747     // Sign in, Call the fitting addListener method
 748     // First Introspection, as the Methods can be analyzed in the same way
 749     // For better perfomance it is implemented here again or make the Impl-Method
 750     // of the Introspection configurable for this purpose.
 751     Reference< XIntrospection > xIntrospection = getIntrospection();
 752     if( !xIntrospection.is() )
 753         return Sequence< Reference<XEventListener> >();
 754
 755     // Inspect Introspection
 756     Any aObjAny( &xObject, ::getCppuType(static_cast<const Reference<XInterface>*>(0)) );
 757
 758     Reference<XIntrospectionAccess> xAccess = xIntrospection->inspect(aObjAny);
 759     if (!xAccess.is())
 760         return Sequence< Reference<XEventListener> >();
 761
 762     Sequence< Reference<XEventListener> > aRet(nCount);
 763     Reference<XEventListener>* pArray = aRet.getArray();
 764
 765     for (sal_Int32 i = 0; i < nCount; ++i)
 766     {
 767         pArray[i] = attachListenerForTarget(
 768             xAccess, xInvocationAdapterFactory, AllListeners[ i ],
 769             aObjAny, aListeners[i].Helper, aListeners[i].ListenerType, aListeners[i].AddListenerParam);
 770     }
 771
 772     return aRet;
 773 }
 774
 775 // XEventAttacher
 776 Reference< XEventListener > EventAttacherImpl::attachSingleEventListener
 777 (
 778     const Reference< XInterface >& xObject,
 779     const Reference< XAllListener >& AllListener,
 780     const Any& Helper,
 781     const OUString& ListenerType,
 782     const OUString& AddListenerParam,
 783     const OUString& EventMethod
 784 )
 785     throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException )
 786 {
 787     // Subscribe FilterListener
 788     Reference< XAllListener > aFilterListener = (XAllListener*)
 789         new FilterAllListenerImpl( this, EventMethod, AllListener );
 790     return attachListener( xObject, aFilterListener, Helper, ListenerType, AddListenerParam);
 791 }
 792
 793 // XEventAttacher
 794 void EventAttacherImpl::removeListener
 795 (
 796     const Reference< XInterface >& xObject,
 797     const OUString& ListenerType,
 798     const OUString& AddListenerParam,
 799     const Reference< XEventListener >& aToRemoveListener
 800 )
 801     throw( IllegalArgumentException, IntrospectionException, RuntimeException )
 802 {
 803     if( !xObject.is() || !aToRemoveListener.is() )
 804         throw IllegalArgumentException();
 805
 806     Reference< XIdlReflection > xReflection = getReflection();
 807     if( !xReflection.is() )
 808         throw IntrospectionException();
 809
 810     // Sign off, Call the fitting removeListener method
 811     // First Introspection, as the Methods can be analyzed in the same way
 812     // For better perfomance it is implemented here again or make the Impl-Method
 813     // of the Introspection configurable for this purpose.
 814     Reference< XIntrospection > xIntrospection = getIntrospection();
 815     if( !xIntrospection.is() )
 816         throw IntrospectionException();
 817
 818     //Inspect Introspection
 819     Any aObjAny( &xObject, ::getCppuType( (const Reference< XInterface > *)0) );
 820     Reference< XIntrospectionAccess > xAccess = xIntrospection->inspect( aObjAny );
 821     if( !xAccess.is() )
 822         throw IntrospectionException();
 823
 824     // Create name of the removeListener-Method
 825     OUString aRemoveListenerName;
 826     OUString aListenerName( ListenerType );
 827     sal_Int32 nIndex = aListenerName.lastIndexOf( '.' );
 828     // set index to the interface name without package name
 829     if( nIndex == -1 )
 830         // not found
 831         nIndex = 0;
 832     else
 833         nIndex++;
 834     if( aListenerName[nIndex] == 'X' )
 835         // erase X from the interface name
 836         aListenerName = aListenerName.copy( nIndex +1 );
 837     aRemoveListenerName = OUString( "remove" ) + aListenerName;
 838
 839     // Search methods for the correct removeListener method
 840     Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods( MethodConcept::LISTENER );
 841     sal_uInt32 i, nLen = aMethodSeq.getLength();
 842     const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
 843     for( i = 0 ; i < nLen ; i++ )
 844     {
 845         // Call Methode
 846         const Reference< XIdlMethod >& rxMethod = pMethods[i];
 847
 848         // Is it the right method?
 849         if( aRemoveListenerName == rxMethod->getName() )
 850         {
 851             Sequence< Reference< XIdlClass > > params = rxMethod->getParameterTypes();
 852             sal_uInt32 nParamCount = params.getLength();
 853
 854             // Just the Listener as parameter?
 855             if( nParamCount == 1 )
 856             {
 857                 Sequence< Any > args( 1 );
 858                 args.getArray()[0] <<= aToRemoveListener;
 859                 try
 860                 {
 861                     rxMethod->invoke( aObjAny, args );
 862                 }
 863                 catch( const InvocationTargetException& )
 864                 {
 865                     throw IntrospectionException();
 866                 }
 867             }
 868             // Else pass the other parameter
 869             else if( nParamCount == 2 )
 870             {
 871                 Sequence< Any > args( 2 );
 872                 Any* pAnys = args.getArray();
 873
 874                 // Check the type of the 1st parameter
 875                 Reference< XIdlClass > xParamClass = params.getConstArray()[0];
 876                 if( xParamClass->getTypeClass() == TypeClass_STRING )
 877                     pAnys[0] <<= AddListenerParam;
 878
 879                 // 2nd parameter == Listener? TODO: Test!
 880                 pAnys[1] <<= aToRemoveListener;
 881
 882                 // TODO: Convert String -> ?
 883                 // else
 884                 try
 885                 {
 886                     rxMethod->invoke( aObjAny, args );
 887                 }
 888                 catch( const InvocationTargetException& )
 889                 {
 890                     throw IntrospectionException();
 891                 }
 892             }
 893             break;
 894         }
 895     }
 896 }
 897
 898 Sequence< Reference<XEventListener> > EventAttacherImpl::attachMultipleEventListeners(
 899     const Reference<XInterface>& xObject, const Sequence<com::sun::star::script::EventListener>& aListeners )
 900         throw( IllegalArgumentException, ServiceNotRegisteredException, CannotCreateAdapterException, IntrospectionException, RuntimeException )
 901 {
 902     sal_Int32 nCount = aListeners.getLength();
 903     Sequence< Reference<XAllListener> > aFilterListeners(nCount);
 904     for (sal_Int32 i = 0; i < nCount; ++i)
 905     {
 906         aFilterListeners[i] = (XAllListener*)
 907             new FilterAllListenerImpl(this, aListeners[i].EventMethod, aListeners[i].AllListener);
 908     }
 909
 910     return attachListeners(xObject, aFilterListeners, aListeners);
 911 }
 912
 913 }
 914
 915 extern "C"
 916 {
 917 SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory(
 918     const sal_Char * pImplName, void * pServiceManager, void * )
 919 {
 920     void * pRet = 0;
 921
 922     if (pServiceManager && rtl_str_compare( pImplName, IMPLNAME ) == 0)
 923     {
 924         Reference< XSingleServiceFactory > xFactory( createOneInstanceFactory(
 925             reinterpret_cast< XMultiServiceFactory * >( pServiceManager ),
 926             OUString(  IMPLNAME  ),
 927             ::comp_EventAttacher::EventAttacherImpl_CreateInstance,
 928             ::comp_EventAttacher::EventAttacherImpl::getSupportedServiceNames_Static() ) );
 929
 930         if (xFactory.is())
 931         {
 932             xFactory->acquire();
 933             pRet = xFactory.get();
 934         }
 935     }
 936
 937     return pRet;
 938 }
 939 }
 940
 941
 942
 943 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */