eventattacher/source/eventattacher.cxx

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