eventattacher/source/eventattacher.cxx

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