UnoControls/source/base/multiplexer.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
  20 #include "multiplexer.hxx"
  21
  22 #include <osl/diagnose.h>
  23 #include <cppuhelper/queryinterface.hxx>
  24
  25 using namespace ::cppu;
  26 using namespace ::osl;
  27 using namespace ::com::sun::star::uno;
  28 using namespace ::com::sun::star::awt;
  29 using namespace ::com::sun::star::lang;
  30
  31 namespace unocontrols{
  32
  33 //  macros
  34
  35 #define MULTIPLEX( INTERFACE, METHOD, EVENTTYP, EVENT )                                                                             \
  36                                                                                                                                     \
  37     /* First get all interfaces from container with right type.*/                                                                   \
  38     OInterfaceContainerHelper* pContainer = m_aListenerHolder.getContainer( cppu::UnoType<INTERFACE>::get() );  \
  39     /* Do the follow only, if elements in container exist.*/                                                                        \
  40     if( pContainer != NULL )                                                                                                        \
  41     {                                                                                                                               \
  42         OInterfaceIteratorHelper aIterator( *pContainer );                                                                          \
  43         EVENTTYP aLocalEvent = EVENT;                                                                                               \
  44         /* Remark: The control is the event source not the peer.*/                                                                  \
  45         /*         We must change the source of the event.      */                                                                  \
  46         aLocalEvent.Source = m_xControl;                                                                                           \
  47         /* Is the control not destroyed? */                                                                                         \
  48         if( aLocalEvent.Source.is() )                                                                                               \
  49         {                                                                                                                           \
  50             if( aIterator.hasMoreElements() )                                                                                       \
  51             {                                                                                                                       \
  52                 INTERFACE * pListener = static_cast<INTERFACE *>(aIterator.next());                                                 \
  53                 try                                                                                                                 \
  54                 {                                                                                                                   \
  55                     pListener->METHOD( aLocalEvent );                                                                               \
  56                 }                                                                                                                   \
  57                 catch(const RuntimeException& )                                                                                     \
  58                 {                                                                                                                   \
  59                     /* Ignore all system exceptions from the listener! */                                                           \
  60                 }                                                                                                                   \
  61             }                                                                                                                       \
  62         }                                                                                                                           \
  63     }
  64
  65 //  construct/destruct
  66
  67 OMRCListenerMultiplexerHelper::OMRCListenerMultiplexerHelper(   const   Reference< XWindow >&   xControl    ,
  68                                                                 const   Reference< XWindow >&   xPeer       )
  69     : m_xPeer           ( xPeer     )
  70     , m_xControl        ( xControl  )
  71     , m_aListenerHolder ( m_aMutex  )
  72 {
  73 }
  74
  75 OMRCListenerMultiplexerHelper::OMRCListenerMultiplexerHelper( const OMRCListenerMultiplexerHelper& /*aCopyInstance*/ )
  76     : XFocusListener()
  77     , XWindowListener()
  78     , XKeyListener()
  79     , XMouseListener()
  80     , XMouseMotionListener()
  81     , XPaintListener()
  82     , XTopWindowListener()
  83     , OWeakObject()
  84     , m_aListenerHolder ( m_aMutex  )
  85 {
  86 }
  87
  88 OMRCListenerMultiplexerHelper::~OMRCListenerMultiplexerHelper()
  89 {
  90 }
  91
  92 //  XInterface
  93
  94 Any SAL_CALL OMRCListenerMultiplexerHelper::queryInterface( const Type& rType ) throw( RuntimeException, std::exception )
  95 {
  96     // Attention:
  97     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  98
  99     // Ask for my own supported interfaces ...
 100     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 101     Any aReturn ( ::cppu::queryInterface(   rType                                           ,
 102                                             static_cast< XWindowListener*       > ( this )  ,
 103                                             static_cast< XKeyListener*          > ( this )  ,
 104                                             static_cast< XFocusListener*        > ( this )  ,
 105                                             static_cast< XMouseListener*        > ( this )  ,
 106                                             static_cast< XMouseMotionListener*  > ( this )  ,
 107                                             static_cast< XPaintListener*        > ( this )  ,
 108                                             static_cast< XTopWindowListener*    > ( this )  ,
 109                                             static_cast< XTopWindowListener*    > ( this )
 110                                         )
 111                 );
 112
 113     // If searched interface supported by this class ...
 114     if ( aReturn.hasValue() )
 115     {
 116         // ... return this information.
 117         return aReturn;
 118     }
 119     else
 120     {
 121         // Else; ... ask baseclass for interfaces!
 122         return OWeakObject::queryInterface( rType );
 123     }
 124 }
 125
 126 //  XInterface
 127
 128 void SAL_CALL OMRCListenerMultiplexerHelper::acquire() throw()
 129 {
 130     // Attention:
 131     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 132
 133     // Forward to baseclass
 134     OWeakObject::acquire();
 135 }
 136
 137 //  XInterface
 138
 139 void SAL_CALL OMRCListenerMultiplexerHelper::release() throw()
 140 {
 141     // Attention:
 142     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 143
 144     // Forward to baseclass
 145     OWeakObject::release();
 146 }
 147
 148 //  container method
 149
 150 void OMRCListenerMultiplexerHelper::setPeer( const Reference< XWindow >& xPeer )
 151 {
 152     MutexGuard aGuard( m_aMutex );
 153     if( m_xPeer != xPeer )
 154     {
 155         if( m_xPeer.is() )
 156         {
 157             // get all types from the listener added to the peer
 158             Sequence< Type >    aContainedTypes = m_aListenerHolder.getContainedTypes();
 159             const Type*         pArray          = aContainedTypes.getConstArray();
 160             sal_Int32           nCount          = aContainedTypes.getLength();
 161             // loop over all listener types and remove the listeners from the peer
 162             for( sal_Int32 i=0; i<nCount; i++ )
 163                 impl_unadviseFromPeer( m_xPeer, pArray[i] );
 164         }
 165         m_xPeer = xPeer;
 166         if( m_xPeer.is() )
 167         {
 168             // get all types from the listener added to the peer
 169             Sequence< Type >    aContainedTypes = m_aListenerHolder.getContainedTypes();
 170             const Type*         pArray          = aContainedTypes.getConstArray();
 171             sal_Int32           nCount          = aContainedTypes.getLength();
 172             // loop over all listener types and add the listeners to the peer
 173             for( sal_Int32 i = 0; i < nCount; i++ )
 174                 impl_adviseToPeer( m_xPeer, pArray[i] );
 175         }
 176     }
 177 }
 178
 179 //  container method
 180
 181 void OMRCListenerMultiplexerHelper::disposeAndClear()
 182 {
 183     EventObject aEvent;
 184     aEvent.Source = m_xControl;
 185     m_aListenerHolder.disposeAndClear( aEvent );
 186 }
 187
 188 //  container method
 189
 190 void OMRCListenerMultiplexerHelper::advise( const   Type&                       aType       ,
 191                                             const   Reference< XInterface >&    xListener   )
 192 {
 193     MutexGuard aGuard( m_aMutex );
 194     if( m_aListenerHolder.addInterface( aType, xListener ) == 1 )
 195     {
 196         // the first listener is added
 197         if( m_xPeer.is() )
 198         {
 199             impl_adviseToPeer( m_xPeer, aType );
 200         }
 201     }
 202 }
 203
 204 //  container method
 205
 206 void OMRCListenerMultiplexerHelper::unadvise(   const   Type&                       aType       ,
 207                                                 const   Reference< XInterface >&    xListener   )
 208 {
 209     MutexGuard aGuard( m_aMutex );
 210     if( m_aListenerHolder.removeInterface( aType, xListener ) == 0 )
 211     {
 212         // the last listener is removed
 213         if ( m_xPeer.is() )
 214         {
 215             impl_unadviseFromPeer( m_xPeer, aType );
 216         }
 217     }
 218 }
 219
 220 //  XEventListener
 221
 222 void SAL_CALL OMRCListenerMultiplexerHelper::disposing( const EventObject& /*aSource*/ ) throw( RuntimeException, std::exception )
 223 {
 224     MutexGuard aGuard( m_aMutex );
 225     // peer is disposed, clear the reference
 226     m_xPeer.clear();
 227 }
 228
 229 //  XFcousListener
 230
 231 void OMRCListenerMultiplexerHelper::focusGained(const FocusEvent& aEvent ) throw( RuntimeException, std::exception )
 232 {
 233     MULTIPLEX( XFocusListener, focusGained, FocusEvent, aEvent )
 234 }
 235
 236 //  XFcousListener
 237
 238 void OMRCListenerMultiplexerHelper::focusLost(const FocusEvent& aEvent ) throw( RuntimeException, std::exception )
 239 {
 240     MULTIPLEX( XFocusListener, focusLost, FocusEvent, aEvent )
 241 }
 242
 243 //  XWindowListener
 244
 245 void OMRCListenerMultiplexerHelper::windowResized(const WindowEvent& aEvent ) throw( RuntimeException, std::exception )
 246 {
 247     MULTIPLEX( XWindowListener, windowResized, WindowEvent, aEvent )
 248 }
 249
 250 //  XWindowListener
 251
 252 void OMRCListenerMultiplexerHelper::windowMoved(const WindowEvent& aEvent ) throw( RuntimeException, std::exception )
 253 {
 254     MULTIPLEX( XWindowListener, windowMoved, WindowEvent, aEvent )
 255 }
 256
 257 //  XWindowListener
 258
 259 void OMRCListenerMultiplexerHelper::windowShown(const EventObject& aEvent ) throw( RuntimeException, std::exception )
 260 {
 261     MULTIPLEX( XWindowListener, windowShown, EventObject, aEvent )
 262 }
 263
 264 //  XWindowListener
 265
 266 void OMRCListenerMultiplexerHelper::windowHidden(const EventObject& aEvent ) throw( RuntimeException, std::exception )
 267 {
 268     MULTIPLEX( XWindowListener, windowHidden, EventObject, aEvent )
 269 }
 270
 271 //  XKeyListener
 272
 273 void OMRCListenerMultiplexerHelper::keyPressed(const KeyEvent& aEvent) throw( RuntimeException, std::exception )
 274 {
 275     MULTIPLEX( XKeyListener, keyPressed, KeyEvent, aEvent )
 276 }
 277
 278 //  XKeyListener
 279
 280 void OMRCListenerMultiplexerHelper::keyReleased(const KeyEvent& aEvent) throw( RuntimeException, std::exception )
 281 {
 282     MULTIPLEX( XKeyListener, keyReleased, KeyEvent, aEvent )
 283 }
 284
 285 //  XMouseListener
 286
 287 void OMRCListenerMultiplexerHelper::mousePressed(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 288 {
 289     MULTIPLEX( XMouseListener, mousePressed, MouseEvent, aEvent )
 290 }
 291
 292 //  XMouseListener
 293
 294 void OMRCListenerMultiplexerHelper::mouseReleased(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 295 {
 296     MULTIPLEX( XMouseListener, mouseReleased, MouseEvent, aEvent )
 297 }
 298
 299 //  XMouseListener
 300
 301 void OMRCListenerMultiplexerHelper::mouseEntered(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 302 {
 303     MULTIPLEX( XMouseListener, mouseEntered, MouseEvent, aEvent )
 304 }
 305
 306 //  XMouseListener
 307
 308 void OMRCListenerMultiplexerHelper::mouseExited(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 309 {
 310     MULTIPLEX( XMouseListener, mouseExited, MouseEvent, aEvent )
 311 }
 312
 313 //  XMouseMotionListener
 314
 315 void OMRCListenerMultiplexerHelper::mouseDragged(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 316 {
 317     MULTIPLEX( XMouseMotionListener, mouseDragged, MouseEvent, aEvent )
 318 }
 319
 320 //  XMouseMotionListener
 321
 322 void OMRCListenerMultiplexerHelper::mouseMoved(const MouseEvent& aEvent) throw( RuntimeException, std::exception )
 323 {
 324     MULTIPLEX( XMouseMotionListener, mouseMoved, MouseEvent, aEvent )
 325 }
 326
 327 //  XPaintListener
 328
 329 void OMRCListenerMultiplexerHelper::windowPaint(const PaintEvent& aEvent) throw( RuntimeException, std::exception )
 330 {
 331     MULTIPLEX( XPaintListener, windowPaint, PaintEvent, aEvent )
 332 }
 333
 334 //  XTopWindowListener
 335
 336 void OMRCListenerMultiplexerHelper::windowOpened(const EventObject& aEvent) throw( RuntimeException, std::exception )
 337 {
 338     MULTIPLEX( XTopWindowListener, windowOpened, EventObject, aEvent )
 339 }
 340
 341 //  XTopWindowListener
 342
 343 void OMRCListenerMultiplexerHelper::windowClosing( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 344 {
 345     MULTIPLEX( XTopWindowListener, windowClosing, EventObject, aEvent )
 346 }
 347
 348 //  XTopWindowListener
 349
 350 void OMRCListenerMultiplexerHelper::windowClosed( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 351 {
 352     MULTIPLEX( XTopWindowListener, windowClosed, EventObject, aEvent )
 353 }
 354
 355 //  XTopWindowListener
 356
 357 void OMRCListenerMultiplexerHelper::windowMinimized( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 358 {
 359     MULTIPLEX( XTopWindowListener, windowMinimized, EventObject, aEvent )
 360 }
 361
 362 //  XTopWindowListener
 363
 364 void OMRCListenerMultiplexerHelper::windowNormalized( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 365 {
 366     MULTIPLEX( XTopWindowListener, windowNormalized, EventObject, aEvent )
 367 }
 368
 369 //  XTopWindowListener
 370
 371 void OMRCListenerMultiplexerHelper::windowActivated( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 372 {
 373     MULTIPLEX( XTopWindowListener, windowActivated, EventObject, aEvent )
 374 }
 375
 376 //  XTopWindowListener
 377
 378 void OMRCListenerMultiplexerHelper::windowDeactivated( const EventObject& aEvent ) throw( RuntimeException, std::exception )
 379 {
 380     MULTIPLEX( XTopWindowListener, windowDeactivated, EventObject, aEvent )
 381 }
 382
 383 //  protected method
 384
 385 void OMRCListenerMultiplexerHelper::impl_adviseToPeer(  const   Reference< XWindow >&   xPeer   ,
 386                                                         const   Type&                   aType   )
 387 {
 388     // add a listener to the source (peer)
 389     if( aType == cppu::UnoType<XWindowListener>::get())
 390         xPeer->addWindowListener( this );
 391     else if( aType == cppu::UnoType<XKeyListener>::get())
 392         xPeer->addKeyListener( this );
 393     else if( aType == cppu::UnoType<XFocusListener>::get())
 394         xPeer->addFocusListener( this );
 395     else if( aType == cppu::UnoType<XMouseListener>::get())
 396         xPeer->addMouseListener( this );
 397     else if( aType == cppu::UnoType<XMouseMotionListener>::get())
 398         xPeer->addMouseMotionListener( this );
 399     else if( aType == cppu::UnoType<XPaintListener>::get())
 400         xPeer->addPaintListener( this );
 401     else if( aType == cppu::UnoType<XTopWindowListener>::get())
 402     {
 403         Reference< XTopWindow > xTop( xPeer, UNO_QUERY );
 404         if( xTop.is() )
 405             xTop->addTopWindowListener( this );
 406     }
 407     else
 408     {
 409         OSL_FAIL( "unknown listener" );
 410     }
 411 }
 412
 413 //  protected method
 414
 415 void OMRCListenerMultiplexerHelper::impl_unadviseFromPeer(  const   Reference< XWindow >&   xPeer   ,
 416                                                             const   Type&                   aType   )
 417 {
 418     // the last listener is removed, remove the listener from the source (peer)
 419     if( aType == cppu::UnoType<XWindowListener>::get())
 420         xPeer->removeWindowListener( this );
 421     else if( aType == cppu::UnoType<XKeyListener>::get())
 422         xPeer->removeKeyListener( this );
 423     else if( aType == cppu::UnoType<XFocusListener>::get())
 424         xPeer->removeFocusListener( this );
 425     else if( aType == cppu::UnoType<XMouseListener>::get())
 426         xPeer->removeMouseListener( this );
 427     else if( aType == cppu::UnoType<XMouseMotionListener>::get())
 428         xPeer->removeMouseMotionListener( this );
 429     else if( aType == cppu::UnoType<XPaintListener>::get())
 430         xPeer->removePaintListener( this );
 431     else if( aType == cppu::UnoType<XTopWindowListener>::get())
 432     {
 433         Reference< XTopWindow >  xTop( xPeer, UNO_QUERY );
 434         if( xTop.is() )
 435             xTop->removeTopWindowListener( this );
 436     }
 437     else
 438     {
 439         OSL_FAIL( "unknown listener" );
 440     }
 441 }
 442
 443 } // namespace unocontrols
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */