slideshow/source/engine/eventmultiplexer.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
  21 #include <tools/diagnose_ex.h>
  22
  23 #include <rtl/ref.hxx>
  24 #include <cppuhelper/compbase.hxx>
  25 #include <cppuhelper/basemutex.hxx>
  26
  27 #include <com/sun/star/awt/XMouseListener.hpp>
  28 #include <com/sun/star/awt/XMouseMotionListener.hpp>
  29 #include <com/sun/star/awt/SystemPointer.hpp>
  30 #include <com/sun/star/awt/XWindow.hpp>
  31 #include <com/sun/star/awt/MouseButton.hpp>
  32 #include <com/sun/star/presentation/XSlideShowView.hpp>
  33
  34 #include <basegfx/matrix/b2dhommatrix.hxx>
  35 #include <basegfx/numeric/ftools.hxx>
  36
  37 #include <tools.hxx>
  38 #include <eventqueue.hxx>
  39 #include <eventmultiplexer.hxx>
  40 #include <listenercontainer.hxx>
  41 #include <delayevent.hxx>
  42 #include <unoview.hxx>
  43 #include <unoviewcontainer.hxx>
  44
  45 #include <functional>
  46 #include <memory>
  47 #include <algorithm>
  48 #include <vector>
  49
  50 using namespace ::com::sun::star;
  51
  52
  53 namespace std
  54 {
  55     // add operator== for weak_ptr, so we can use std::find over lists of them
  56     template<typename T> bool operator==( weak_ptr<T> const& rLHS,
  57                                           weak_ptr<T> const& rRHS )
  58     {
  59         return rLHS.lock().get() == rRHS.lock().get();
  60     }
  61 }
  62
  63 namespace slideshow {
  64 namespace internal {
  65
  66 template <typename HandlerT>
  67 class PrioritizedHandlerEntry
  68 {
  69     typedef std::shared_ptr<HandlerT> HandlerSharedPtrT;
  70     HandlerSharedPtrT mpHandler;
  71     double            mnPrio;
  72
  73 public:
  74     PrioritizedHandlerEntry( HandlerSharedPtrT const& pHandler,
  75                              double                   nPrio ) :
  76         mpHandler(pHandler),
  77         mnPrio(nPrio)
  78     {}
  79
  80     HandlerSharedPtrT const& getHandler() const { return mpHandler; }
  81
  82     /// To sort according to priority
  83     bool operator<( PrioritizedHandlerEntry const& rRHS ) const
  84     {
  85         // reversed order - high prioritized entries
  86         // should be at the beginning of the queue
  87         return mnPrio > rRHS.mnPrio;
  88     }
  89
  90     /// To permit std::remove in removeHandler template
  91     bool operator==( PrioritizedHandlerEntry const& rRHS ) const
  92     {
  93         // ignore prio, for removal, only the handler ptr matters
  94         return mpHandler == rRHS.mpHandler;
  95     }
  96 };
  97
  98
  99 typedef cppu::WeakComponentImplHelper<
 100     awt::XMouseListener,
 101     awt::XMouseMotionListener > Listener_UnoBase;
 102
 103 /** Listener class, to decouple UNO lifetime from EventMultiplexer
 104
 105     This class gets registered as the XMouse(Motion)Listener on the
 106     XSlideViews, and passes on the events to the EventMultiplexer (via
 107     EventQueue indirection, to force the events into the main thread)
 108  */
 109 class EventMultiplexerListener : private cppu::BaseMutex,
 110                                  public Listener_UnoBase
 111 {
 112 public:
 113     EventMultiplexerListener( EventQueue&           rEventQueue,
 114                               EventMultiplexerImpl& rEventMultiplexer ) :
 115         Listener_UnoBase( m_aMutex ),
 116         mpEventQueue( &rEventQueue ),
 117         mpEventMultiplexer( &rEventMultiplexer )
 118     {
 119     }
 120
 121     EventMultiplexerListener( const EventMultiplexerListener& ) = delete;
 122     EventMultiplexerListener& operator=( const EventMultiplexerListener& ) = delete;
 123
 124     // WeakComponentImplHelperBase::disposing
 125     virtual void SAL_CALL disposing() override;
 126
 127 private:
 128     virtual void SAL_CALL disposing( const lang::EventObject& Source ) override;
 129
 130     // XMouseListener implementation
 131     virtual void SAL_CALL mousePressed( const awt::MouseEvent& e ) override;
 132     virtual void SAL_CALL mouseReleased( const awt::MouseEvent& e ) override;
 133     virtual void SAL_CALL mouseEntered( const awt::MouseEvent& e ) override;
 134     virtual void SAL_CALL mouseExited( const awt::MouseEvent& e ) override;
 135
 136     // XMouseMotionListener implementation
 137     virtual void SAL_CALL mouseDragged( const awt::MouseEvent& e ) override;
 138     virtual void SAL_CALL mouseMoved( const awt::MouseEvent& e ) override;
 139
 140
 141     EventQueue*           mpEventQueue;
 142     EventMultiplexerImpl* mpEventMultiplexer;
 143 };
 144
 145
 146 struct EventMultiplexerImpl
 147 {
 148     EventMultiplexerImpl( EventQueue&             rEventQueue,
 149                           UnoViewContainer const& rViewContainer ) :
 150         mrEventQueue(rEventQueue),
 151         mrViewContainer(rViewContainer),
 152         mxListener( new EventMultiplexerListener(rEventQueue,
 153                                                  *this) ),
 154         maNextEffectHandlers(),
 155         maSlideStartHandlers(),
 156         maSlideEndHandlers(),
 157         maAnimationStartHandlers(),
 158         maAnimationEndHandlers(),
 159         maSlideAnimationsEndHandlers(),
 160         maAudioStoppedHandlers(),
 161         maCommandStopAudioHandlers(),
 162         maPauseHandlers(),
 163         maViewHandlers(),
 164         maViewRepaintHandlers(),
 165         maShapeListenerHandlers(),
 166         maUserPaintEventHandlers(),
 167         maMouseClickHandlers(),
 168         maMouseDoubleClickHandlers(),
 169         maMouseMoveHandlers(),
 170         maHyperlinkHandlers(),
 171         mnTimeout(0.0),
 172         mpTickEvent(),
 173         mbIsAutoMode(false)
 174     {}
 175
 176     ~EventMultiplexerImpl()
 177     {
 178         if( mxListener.is() )
 179             mxListener->dispose();
 180     }
 181
 182     /// Remove all handlers
 183     void clear();
 184
 185     // actual handler callbacks (get called from the UNO interface
 186     // listeners via event queue)
 187     void mousePressed( const awt::MouseEvent& e );
 188     void mouseReleased( const awt::MouseEvent& e );
 189     void mouseDragged( const awt::MouseEvent& e );
 190     void mouseMoved( const awt::MouseEvent& e );
 191
 192     bool isMouseListenerRegistered() const;
 193
 194     typedef ThreadUnsafeListenerContainer<
 195         PrioritizedHandlerEntry<EventHandler>,
 196         std::vector<
 197             PrioritizedHandlerEntry<EventHandler> > >     ImplNextEffectHandlers;
 198     typedef PrioritizedHandlerEntry<MouseEventHandler>    ImplMouseHandlerEntry;
 199     typedef ThreadUnsafeListenerContainer<
 200         ImplMouseHandlerEntry,
 201         std::vector<ImplMouseHandlerEntry> >              ImplMouseHandlers;
 202     typedef ThreadUnsafeListenerContainer<
 203         EventHandlerSharedPtr,
 204         std::vector<EventHandlerSharedPtr> >              ImplEventHandlers;
 205     typedef ThreadUnsafeListenerContainer<
 206         AnimationEventHandlerSharedPtr,
 207         std::vector<AnimationEventHandlerSharedPtr> >     ImplAnimationHandlers;
 208     typedef ThreadUnsafeListenerContainer<
 209         PauseEventHandlerSharedPtr,
 210         std::vector<PauseEventHandlerSharedPtr> >         ImplPauseHandlers;
 211     typedef ThreadUnsafeListenerContainer<
 212         ViewEventHandlerWeakPtr,
 213         std::vector<ViewEventHandlerWeakPtr> >            ImplViewHandlers;
 214     typedef ThreadUnsafeListenerContainer<
 215         ViewRepaintHandlerSharedPtr,
 216         std::vector<ViewRepaintHandlerSharedPtr> >        ImplRepaintHandlers;
 217     typedef ThreadUnsafeListenerContainer<
 218         ShapeListenerEventHandlerSharedPtr,
 219         std::vector<ShapeListenerEventHandlerSharedPtr> > ImplShapeListenerHandlers;
 220     typedef ThreadUnsafeListenerContainer<
 221         UserPaintEventHandlerSharedPtr,
 222         std::vector<UserPaintEventHandlerSharedPtr> >     ImplUserPaintEventHandlers;
 223     typedef ThreadUnsafeListenerContainer<
 224         PrioritizedHandlerEntry<HyperlinkHandler>,
 225         std::vector<PrioritizedHandlerEntry<HyperlinkHandler> > > ImplHyperLinkHandlers;
 226
 227     template <typename XSlideShowViewFunc>
 228     void forEachView( XSlideShowViewFunc pViewMethod );
 229
 230     UnoViewSharedPtr findUnoView(const uno::Reference<
 231                                    presentation::XSlideShowView>& xView) const;
 232
 233     template< typename RegisterFunction >
 234     void addMouseHandler( ImplMouseHandlers&                rHandlerContainer,
 235                           const MouseEventHandlerSharedPtr& rHandler,
 236                           double                            nPriority,
 237                           RegisterFunction                  pRegisterListener );
 238
 239     static bool notifyAllAnimationHandlers( ImplAnimationHandlers const& rContainer,
 240                                      AnimationNodeSharedPtr const& rNode );
 241
 242     bool notifyMouseHandlers(
 243         const ImplMouseHandlers& rQueue,
 244         bool (MouseEventHandler::*pHandlerMethod)(
 245             const awt::MouseEvent& ),
 246         const awt::MouseEvent& e );
 247
 248     bool notifyNextEffect();
 249
 250     /// Called for automatic nextEffect
 251     void tick();
 252
 253     /// Schedules a tick event
 254     void scheduleTick();
 255
 256     /// Schedules tick events, if mbIsAutoMode is true
 257     void handleTicks();
 258
 259
 260     EventQueue&                         mrEventQueue;
 261     UnoViewContainer const&             mrViewContainer;
 262     ::rtl::Reference<
 263         EventMultiplexerListener>       mxListener;
 264
 265     ImplNextEffectHandlers              maNextEffectHandlers;
 266     ImplEventHandlers                   maSlideStartHandlers;
 267     ImplEventHandlers                   maSlideEndHandlers;
 268     ImplAnimationHandlers               maAnimationStartHandlers;
 269     ImplAnimationHandlers               maAnimationEndHandlers;
 270     ImplEventHandlers                   maSlideAnimationsEndHandlers;
 271     ImplAnimationHandlers               maAudioStoppedHandlers;
 272     ImplAnimationHandlers               maCommandStopAudioHandlers;
 273     ImplPauseHandlers                   maPauseHandlers;
 274     ImplViewHandlers                    maViewHandlers;
 275     ImplRepaintHandlers                 maViewRepaintHandlers;
 276     ImplShapeListenerHandlers           maShapeListenerHandlers;
 277     ImplUserPaintEventHandlers          maUserPaintEventHandlers;
 278     ImplMouseHandlers                   maMouseClickHandlers;
 279     ImplMouseHandlers                   maMouseDoubleClickHandlers;
 280     ImplMouseHandlers                   maMouseMoveHandlers;
 281     ImplHyperLinkHandlers               maHyperlinkHandlers;
 282
 283     /// automatic next effect mode timeout
 284     double                        mnTimeout;
 285
 286     /** Holds ptr to optional tick event weakly
 287
 288         When event queue is cleansed, the next
 289         setAutomaticMode(true) call is then able to
 290         regenerate the event.
 291     */
 292     ::std::weak_ptr< Event >    mpTickEvent;
 293     bool                          mbIsAutoMode;
 294 };
 295
 296
 297 void SAL_CALL EventMultiplexerListener::disposing()
 298 {
 299     osl::MutexGuard const guard( m_aMutex );
 300     mpEventQueue = nullptr;
 301     mpEventMultiplexer = nullptr;
 302 }
 303
 304 void SAL_CALL EventMultiplexerListener::disposing(
 305     const lang::EventObject& /*rSource*/ )
 306 {
 307     // there's no real point in acting on this message - after all,
 308     // the event sources are the XSlideShowViews, which must be
 309     // explicitly removed from the slideshow via
 310     // XSlideShow::removeView(). thus, if a XSlideShowView has
 311     // properly removed itself from the slideshow, it will not be
 312     // found here. and if it hasn't, there'll be other references at
 313     // other places within the slideshow, anyway...
 314 }
 315
 316 void SAL_CALL EventMultiplexerListener::mousePressed(
 317     const awt::MouseEvent& e )
 318 {
 319     osl::MutexGuard const guard( m_aMutex );
 320
 321     // notify mouse press. Don't call handlers directly, this
 322     // might not be the main thread!
 323     if( mpEventQueue )
 324         mpEventQueue->addEvent(
 325             makeEvent( std::bind( &EventMultiplexerImpl::mousePressed,
 326                                     mpEventMultiplexer,
 327                                     e ),
 328                        "EventMultiplexerImpl::mousePressed") );
 329 }
 330
 331 void SAL_CALL EventMultiplexerListener::mouseReleased(
 332     const awt::MouseEvent& e )
 333 {
 334     osl::MutexGuard const guard( m_aMutex );
 335
 336     // notify mouse release. Don't call handlers directly,
 337     // this might not be the main thread!
 338     if( mpEventQueue )
 339         mpEventQueue->addEvent(
 340             makeEvent( std::bind( &EventMultiplexerImpl::mouseReleased,
 341                                     mpEventMultiplexer,
 342                                     e ),
 343                        "EventMultiplexerImpl::mouseReleased") );
 344 }
 345
 346 void SAL_CALL EventMultiplexerListener::mouseEntered(
 347     const awt::MouseEvent& /*e*/ )
 348 {
 349     // not used here
 350 }
 351
 352 void SAL_CALL EventMultiplexerListener::mouseExited(
 353     const awt::MouseEvent& /*e*/ )
 354 {
 355     // not used here
 356 }
 357
 358 // XMouseMotionListener implementation
 359 void SAL_CALL EventMultiplexerListener::mouseDragged(
 360     const awt::MouseEvent& e )
 361 {
 362     osl::MutexGuard const guard( m_aMutex );
 363
 364     // notify mouse drag. Don't call handlers directly, this
 365     // might not be the main thread!
 366     if( mpEventQueue )
 367         mpEventQueue->addEvent(
 368             makeEvent( std::bind( &EventMultiplexerImpl::mouseDragged,
 369                                     mpEventMultiplexer,
 370                                     e ),
 371                        "EventMultiplexerImpl::mouseDragged") );
 372 }
 373
 374 void SAL_CALL EventMultiplexerListener::mouseMoved(
 375     const awt::MouseEvent& e )
 376 {
 377     osl::MutexGuard const guard( m_aMutex );
 378
 379     // notify mouse move. Don't call handlers directly, this
 380     // might not be the main thread!
 381     if( mpEventQueue )
 382         mpEventQueue->addEvent(
 383             makeEvent( std::bind( &EventMultiplexerImpl::mouseMoved,
 384                                     mpEventMultiplexer,
 385                                     e ),
 386                        "EventMultiplexerImpl::mouseMoved") );
 387 }
 388
 389
 390 bool EventMultiplexerImpl::notifyAllAnimationHandlers( ImplAnimationHandlers const& rContainer,
 391                                                        AnimationNodeSharedPtr const& rNode )
 392 {
 393     return rContainer.applyAll(
 394         [&rNode]( const AnimationEventHandlerSharedPtr& pEventHandler )
 395         { return pEventHandler->handleAnimationEvent( rNode ); } );
 396 }
 397
 398 template <typename XSlideShowViewFunc>
 399 void EventMultiplexerImpl::forEachView( XSlideShowViewFunc pViewMethod )
 400 {
 401     if( pViewMethod )
 402     {
 403         // (un)register mouse listener on all views
 404         for( UnoViewVector::const_iterator aIter( mrViewContainer.begin() ),
 405                  aEnd( mrViewContainer.end() ); aIter != aEnd; ++aIter )
 406         {
 407             uno::Reference<presentation::XSlideShowView> xView ((*aIter)->getUnoView());
 408             if (xView.is())
 409             {
 410                 (xView.get()->*pViewMethod)( mxListener.get() );
 411             }
 412             else
 413             {
 414                 OSL_ASSERT(xView.is());
 415             }
 416         }
 417     }
 418 }
 419
 420 UnoViewSharedPtr EventMultiplexerImpl::findUnoView(
 421     const uno::Reference<presentation::XSlideShowView>& xView) const
 422 {
 423     // find view from which the change originated
 424     UnoViewVector::const_iterator       aIter;
 425     const UnoViewVector::const_iterator aEnd ( mrViewContainer.end() );
 426     if( (aIter=std::find_if( mrViewContainer.begin(),
 427                              aEnd,
 428                              [&xView]( const UnoViewSharedPtr& pView )
 429                              { return xView == pView->getUnoView(); } )) == aEnd )
 430     {
 431         OSL_FAIL("EventMultiplexer::findUnoView(): unexpected message source" );
 432         return UnoViewSharedPtr();
 433     }
 434
 435     return *aIter;
 436 }
 437
 438 template< typename RegisterFunction >
 439 void EventMultiplexerImpl::addMouseHandler(
 440     ImplMouseHandlers&                rHandlerContainer,
 441     const MouseEventHandlerSharedPtr& rHandler,
 442     double                            nPriority,
 443     RegisterFunction                  pRegisterListener )
 444 {
 445     ENSURE_OR_THROW(
 446         rHandler,
 447         "EventMultiplexer::addMouseHandler(): Invalid handler" );
 448
 449     // register mouse listener on all views
 450     forEachView( pRegisterListener );
 451
 452     // add into sorted container:
 453     rHandlerContainer.addSorted(
 454         typename ImplMouseHandlers::container_type::value_type(
 455             rHandler,
 456             nPriority ));
 457 }
 458
 459 bool EventMultiplexerImpl::isMouseListenerRegistered() const
 460 {
 461     return !(maMouseClickHandlers.isEmpty() &&
 462              maMouseDoubleClickHandlers.isEmpty());
 463 }
 464
 465 void EventMultiplexerImpl::tick()
 466 {
 467     if( !mbIsAutoMode )
 468         return; // this event is just a left-over, ignore
 469
 470     notifyNextEffect();
 471
 472     if( !maNextEffectHandlers.isEmpty() )
 473     {
 474         // still handlers left, schedule next timeout
 475         // event. Will also set mbIsTickEventOn back to true
 476         scheduleTick();
 477     }
 478 }
 479
 480 void EventMultiplexerImpl::scheduleTick()
 481 {
 482     EventSharedPtr pEvent(
 483         makeDelay( [this] () { this->tick(); },
 484                    mnTimeout,
 485                    "EventMultiplexerImpl::tick with delay"));
 486
 487     // store weak reference to generated event, to notice when
 488     // the event queue gets cleansed (we then have to
 489     // regenerate the tick event!)
 490     mpTickEvent = pEvent;
 491
 492     // enabled auto mode: simply schedule a timeout event,
 493     // which will eventually call our tick() method
 494     mrEventQueue.addEventForNextRound( pEvent );
 495 }
 496
 497 void EventMultiplexerImpl::handleTicks()
 498 {
 499     if( !mbIsAutoMode )
 500         return; // nothing to do, don't need no ticks
 501
 502     EventSharedPtr pTickEvent( mpTickEvent.lock() );
 503     if( pTickEvent )
 504         return; // nothing to do, there's already a tick
 505                 // pending
 506
 507     // schedule initial tick (which reschedules itself
 508     // after that, all by itself)
 509     scheduleTick();
 510 }
 511
 512
 513 void EventMultiplexerImpl::clear()
 514 {
 515     // deregister from all views.
 516     if( isMouseListenerRegistered() )
 517     {
 518         for( UnoViewVector::const_iterator aIter=mrViewContainer.begin(),
 519                  aEnd=mrViewContainer.end();
 520              aIter!=aEnd;
 521              ++aIter )
 522         {
 523             if( (*aIter)->getUnoView().is() )
 524                 (*aIter)->getUnoView()->removeMouseListener( mxListener.get() );
 525         }
 526     }
 527
 528     if( !maMouseMoveHandlers.isEmpty() )
 529     {
 530         for( UnoViewVector::const_iterator aIter=mrViewContainer.begin(),
 531                  aEnd=mrViewContainer.end();
 532              aIter!=aEnd;
 533              ++aIter )
 534         {
 535             if( (*aIter)->getUnoView().is() )
 536                 (*aIter)->getUnoView()->removeMouseMotionListener( mxListener.get() );
 537         }
 538     }
 539
 540     // clear all handlers (releases all references)
 541     maNextEffectHandlers.clear();
 542     maSlideStartHandlers.clear();
 543     maSlideEndHandlers.clear();
 544     maAnimationStartHandlers.clear();
 545     maAnimationEndHandlers.clear();
 546     maSlideAnimationsEndHandlers.clear();
 547     maAudioStoppedHandlers.clear();
 548     maCommandStopAudioHandlers.clear();
 549     maPauseHandlers.clear();
 550     maViewHandlers.clear();
 551     maViewRepaintHandlers.clear();
 552     maMouseClickHandlers.clear();
 553     maMouseDoubleClickHandlers.clear();
 554     maMouseMoveHandlers.clear();
 555     maHyperlinkHandlers.clear();
 556     mpTickEvent.reset();
 557 }
 558
 559 // XMouseListener implementation
 560 bool EventMultiplexerImpl::notifyMouseHandlers(
 561     const ImplMouseHandlers& rQueue,
 562     bool (MouseEventHandler::*pHandlerMethod)( const awt::MouseEvent& ),
 563     const awt::MouseEvent& e )
 564 {
 565     uno::Reference<presentation::XSlideShowView> xView(
 566         e.Source, uno::UNO_QUERY );
 567
 568     ENSURE_OR_RETURN_FALSE( xView.is(), "EventMultiplexer::notifyHandlers(): "
 569                        "event source is not an XSlideShowView" );
 570
 571     // find corresponding view (to map mouse position into user
 572     // coordinate space)
 573     UnoViewVector::const_iterator       aIter;
 574     const UnoViewVector::const_iterator aEnd  ( mrViewContainer.end() );
 575     if( (aIter=::std::find_if(
 576              mrViewContainer.begin(),
 577              aEnd,
 578              [&xView]( const UnoViewSharedPtr& pView )
 579              { return xView == pView->getUnoView(); } )) == aEnd )
 580     {
 581         ENSURE_OR_RETURN_FALSE(
 582             false, "EventMultiplexer::notifyHandlers(): "
 583             "event source not found under registered views" );
 584     }
 585
 586     // convert mouse position to user coordinate space
 587     ::basegfx::B2DPoint     aPosition( e.X, e.Y );
 588     ::basegfx::B2DHomMatrix aMatrix( (*aIter)->getTransformation() );
 589     if( !aMatrix.invert() )
 590         ENSURE_OR_THROW( false, "EventMultiplexer::notifyHandlers():"
 591                           " view matrix singular" );
 592     aPosition *= aMatrix;
 593
 594     awt::MouseEvent aEvent( e );
 595     aEvent.X = ::basegfx::fround( aPosition.getX() );
 596     aEvent.Y = ::basegfx::fround( aPosition.getY() );
 597
 598     // fire event on handlers, try in order of precedence. If
 599     // one high-priority handler rejects the event
 600     // (i.e. returns false), try next handler.
 601     return rQueue.apply(
 602         [&pHandlerMethod, &aEvent]( const ImplMouseHandlerEntry& rMouseHandler )
 603         { return ( ( *rMouseHandler.getHandler() ).*pHandlerMethod )( aEvent ); } );
 604 }
 605
 606 void EventMultiplexerImpl::mousePressed( const awt::MouseEvent& e )
 607 {
 608     // fire double-click events for every second click
 609     sal_Int32 nCurrClickCount = e.ClickCount;
 610     while( nCurrClickCount > 1 &&
 611            notifyMouseHandlers( maMouseDoubleClickHandlers,
 612                                 &MouseEventHandler::handleMousePressed,
 613                                 e ))
 614     {
 615         nCurrClickCount -= 2;
 616     }
 617
 618     // fire single-click events for all remaining clicks
 619     while( nCurrClickCount > 0 &&
 620            notifyMouseHandlers( maMouseClickHandlers,
 621                                 &MouseEventHandler::handleMousePressed,
 622                                 e ))
 623     {
 624         --nCurrClickCount;
 625     }
 626 }
 627
 628 void EventMultiplexerImpl::mouseReleased( const awt::MouseEvent& e )
 629 {
 630     // fire double-click events for every second click
 631     sal_Int32 nCurrClickCount = e.ClickCount;
 632     while( nCurrClickCount > 1 &&
 633            notifyMouseHandlers( maMouseDoubleClickHandlers,
 634                                 &MouseEventHandler::handleMouseReleased,
 635                                 e ))
 636     {
 637         nCurrClickCount -= 2;
 638     }
 639
 640     // fire single-click events for all remaining clicks
 641     while( nCurrClickCount > 0 &&
 642            notifyMouseHandlers( maMouseClickHandlers,
 643                                 &MouseEventHandler::handleMouseReleased,
 644                                 e ))
 645     {
 646         --nCurrClickCount;
 647     }
 648 }
 649
 650 void EventMultiplexerImpl::mouseDragged( const awt::MouseEvent& e )
 651 {
 652     notifyMouseHandlers( maMouseMoveHandlers,
 653                          &MouseEventHandler::handleMouseDragged,
 654                          e );
 655 }
 656
 657 void EventMultiplexerImpl::mouseMoved( const awt::MouseEvent& e )
 658 {
 659     notifyMouseHandlers( maMouseMoveHandlers,
 660                          &MouseEventHandler::handleMouseMoved,
 661                          e );
 662 }
 663
 664 bool EventMultiplexerImpl::notifyNextEffect()
 665 {
 666     // fire event on handlers, try in order of precedence. If one
 667     // high-priority handler rejects the event (i.e. returns false),
 668     // try next handler.
 669     return maNextEffectHandlers.apply(
 670         []( const PrioritizedHandlerEntry< EventHandler >& pHandler )
 671         { return pHandler.getHandler()->handleEvent(); } );
 672 }
 673
 674
 675 EventMultiplexer::EventMultiplexer( EventQueue&             rEventQueue,
 676                                     UnoViewContainer const& rViewContainer ) :
 677     mpImpl( new EventMultiplexerImpl(rEventQueue, rViewContainer) )
 678 {
 679 }
 680
 681 EventMultiplexer::~EventMultiplexer()
 682 {
 683     // outline because of EventMultiplexerImpl's incomplete type
 684 }
 685
 686 void EventMultiplexer::clear()
 687 {
 688     mpImpl->clear();
 689 }
 690
 691 void EventMultiplexer::setAutomaticMode( bool bIsAuto )
 692 {
 693     if( bIsAuto == mpImpl->mbIsAutoMode )
 694         return; // no change, nothing to do
 695
 696     mpImpl->mbIsAutoMode = bIsAuto;
 697
 698     mpImpl->handleTicks();
 699 }
 700
 701 bool EventMultiplexer::getAutomaticMode() const
 702 {
 703     return mpImpl->mbIsAutoMode;
 704 }
 705
 706 void EventMultiplexer::setAutomaticTimeout( double nTimeout )
 707 {
 708     mpImpl->mnTimeout = nTimeout;
 709 }
 710
 711 double EventMultiplexer::getAutomaticTimeout() const
 712 {
 713     return mpImpl->mnTimeout;
 714 }
 715
 716 void EventMultiplexer::addNextEffectHandler(
 717     EventHandlerSharedPtr const& rHandler,
 718     double                       nPriority )
 719 {
 720     mpImpl->maNextEffectHandlers.addSorted(
 721         EventMultiplexerImpl::ImplNextEffectHandlers::container_type::value_type(
 722             rHandler,
 723             nPriority) );
 724
 725     // Enable tick events, if not done already
 726     mpImpl->handleTicks();
 727 }
 728
 729 void EventMultiplexer::removeNextEffectHandler(
 730     const EventHandlerSharedPtr& rHandler )
 731 {
 732     mpImpl->maNextEffectHandlers.remove(
 733         EventMultiplexerImpl::ImplNextEffectHandlers::container_type::value_type(
 734             rHandler,
 735             0.0) );
 736 }
 737
 738 void EventMultiplexer::addSlideStartHandler(
 739     const EventHandlerSharedPtr& rHandler )
 740 {
 741     mpImpl->maSlideStartHandlers.add( rHandler );
 742 }
 743
 744 void EventMultiplexer::removeSlideStartHandler(
 745     const EventHandlerSharedPtr& rHandler )
 746 {
 747     mpImpl->maSlideStartHandlers.remove( rHandler );
 748 }
 749
 750 void EventMultiplexer::addSlideEndHandler(
 751     const EventHandlerSharedPtr& rHandler )
 752 {
 753     mpImpl->maSlideEndHandlers.add( rHandler );
 754 }
 755
 756 void EventMultiplexer::removeSlideEndHandler(
 757     const EventHandlerSharedPtr& rHandler )
 758 {
 759     mpImpl->maSlideEndHandlers.remove( rHandler );
 760 }
 761
 762 void EventMultiplexer::addAnimationStartHandler(
 763     const AnimationEventHandlerSharedPtr& rHandler )
 764 {
 765     mpImpl->maAnimationStartHandlers.add( rHandler );
 766 }
 767
 768 void EventMultiplexer::removeAnimationStartHandler(
 769     const AnimationEventHandlerSharedPtr& rHandler )
 770 {
 771     mpImpl->maAnimationStartHandlers.remove( rHandler );
 772 }
 773
 774 void EventMultiplexer::addAnimationEndHandler(
 775     const AnimationEventHandlerSharedPtr& rHandler )
 776 {
 777     mpImpl->maAnimationEndHandlers.add( rHandler );
 778 }
 779
 780 void EventMultiplexer::removeAnimationEndHandler(
 781     const AnimationEventHandlerSharedPtr& rHandler )
 782 {
 783     mpImpl->maAnimationEndHandlers.remove( rHandler );
 784 }
 785
 786 void EventMultiplexer::addSlideAnimationsEndHandler(
 787     const EventHandlerSharedPtr& rHandler )
 788 {
 789     mpImpl->maSlideAnimationsEndHandlers.add( rHandler );
 790 }
 791
 792 void EventMultiplexer::removeSlideAnimationsEndHandler(
 793     const EventHandlerSharedPtr& rHandler )
 794 {
 795     mpImpl->maSlideAnimationsEndHandlers.remove( rHandler );
 796 }
 797
 798 void EventMultiplexer::addAudioStoppedHandler(
 799     const AnimationEventHandlerSharedPtr& rHandler )
 800 {
 801     mpImpl->maAudioStoppedHandlers.add( rHandler );
 802 }
 803
 804 void EventMultiplexer::removeAudioStoppedHandler(
 805     const AnimationEventHandlerSharedPtr& rHandler )
 806 {
 807     mpImpl->maAudioStoppedHandlers.remove( rHandler );
 808 }
 809
 810 void EventMultiplexer::addCommandStopAudioHandler(
 811     const AnimationEventHandlerSharedPtr& rHandler )
 812 {
 813     mpImpl->maCommandStopAudioHandlers.add( rHandler );
 814 }
 815
 816 void EventMultiplexer::removeCommandStopAudioHandler(
 817     const AnimationEventHandlerSharedPtr& rHandler )
 818 {
 819     mpImpl->maCommandStopAudioHandlers.remove( rHandler );
 820 }
 821
 822 void EventMultiplexer::addPauseHandler(
 823     const PauseEventHandlerSharedPtr& rHandler )
 824 {
 825     mpImpl->maPauseHandlers.add( rHandler );
 826 }
 827
 828 void EventMultiplexer::removePauseHandler(
 829     const PauseEventHandlerSharedPtr&  rHandler )
 830 {
 831     mpImpl->maPauseHandlers.remove( rHandler );
 832 }
 833
 834 void EventMultiplexer::addViewHandler(
 835     const ViewEventHandlerWeakPtr& rHandler )
 836 {
 837     mpImpl->maViewHandlers.add( rHandler );
 838 }
 839
 840 void EventMultiplexer::removeViewHandler( const ViewEventHandlerWeakPtr& rHandler )
 841 {
 842     mpImpl->maViewHandlers.remove( rHandler );
 843 }
 844
 845 void EventMultiplexer::addViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler )
 846 {
 847     mpImpl->maViewRepaintHandlers.add( rHandler );
 848 }
 849
 850 void EventMultiplexer::removeViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler )
 851 {
 852     mpImpl->maViewRepaintHandlers.remove( rHandler );
 853 }
 854
 855 void EventMultiplexer::addShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler )
 856 {
 857     mpImpl->maShapeListenerHandlers.add( rHandler );
 858 }
 859
 860 void EventMultiplexer::removeShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler )
 861 {
 862     mpImpl->maShapeListenerHandlers.remove( rHandler );
 863 }
 864
 865 void EventMultiplexer::addUserPaintHandler( const UserPaintEventHandlerSharedPtr& rHandler )
 866 {
 867     mpImpl->maUserPaintEventHandlers.add( rHandler );
 868 }
 869
 870 void EventMultiplexer::addClickHandler(
 871     const MouseEventHandlerSharedPtr& rHandler,
 872     double                            nPriority )
 873 {
 874     mpImpl->addMouseHandler(
 875         mpImpl->maMouseClickHandlers,
 876         rHandler,
 877         nPriority,
 878         mpImpl->isMouseListenerRegistered()
 879         ? nullptr
 880         : &presentation::XSlideShowView::addMouseListener );
 881 }
 882
 883 void EventMultiplexer::removeClickHandler(
 884     const MouseEventHandlerSharedPtr&  rHandler )
 885 {
 886     mpImpl->maMouseClickHandlers.remove(
 887         EventMultiplexerImpl::ImplMouseHandlers::container_type::value_type(
 888             rHandler,
 889             0.0) );
 890
 891     if( !mpImpl->isMouseListenerRegistered() )
 892         mpImpl->forEachView( &presentation::XSlideShowView::removeMouseListener );
 893 }
 894
 895 void EventMultiplexer::addDoubleClickHandler(
 896     const MouseEventHandlerSharedPtr&   rHandler,
 897     double                              nPriority )
 898 {
 899     mpImpl->addMouseHandler(
 900         mpImpl->maMouseDoubleClickHandlers,
 901         rHandler,
 902         nPriority,
 903         mpImpl->isMouseListenerRegistered()
 904         ? nullptr
 905         : &presentation::XSlideShowView::addMouseListener );
 906 }
 907
 908 void EventMultiplexer::removeDoubleClickHandler(
 909     const MouseEventHandlerSharedPtr&    rHandler )
 910 {
 911     mpImpl->maMouseDoubleClickHandlers.remove(
 912         EventMultiplexerImpl::ImplMouseHandlers::container_type::value_type(
 913             rHandler,
 914             0.0) );
 915
 916     if( !mpImpl->isMouseListenerRegistered() )
 917         mpImpl->forEachView( &presentation::XSlideShowView::removeMouseListener );
 918 }
 919
 920 void EventMultiplexer::addMouseMoveHandler(
 921     const MouseEventHandlerSharedPtr& rHandler,
 922     double                            nPriority )
 923 {
 924     mpImpl->addMouseHandler(
 925         mpImpl->maMouseMoveHandlers,
 926         rHandler,
 927         nPriority,
 928         mpImpl->maMouseMoveHandlers.isEmpty()
 929         ? &presentation::XSlideShowView::addMouseMotionListener
 930         : nullptr );
 931 }
 932
 933 void EventMultiplexer::removeMouseMoveHandler(
 934     const MouseEventHandlerSharedPtr&  rHandler )
 935 {
 936     mpImpl->maMouseMoveHandlers.remove(
 937         EventMultiplexerImpl::ImplMouseHandlers::container_type::value_type(
 938             rHandler,
 939             0.0) );
 940
 941     if( mpImpl->maMouseMoveHandlers.isEmpty() )
 942         mpImpl->forEachView(
 943             &presentation::XSlideShowView::removeMouseMotionListener );
 944 }
 945
 946 void EventMultiplexer::addHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler,
 947                                             double                           nPriority )
 948 {
 949     mpImpl->maHyperlinkHandlers.addSorted(
 950         EventMultiplexerImpl::ImplHyperLinkHandlers::container_type::value_type(
 951             rHandler,
 952             nPriority) );
 953 }
 954
 955 void EventMultiplexer::removeHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler )
 956 {
 957     mpImpl->maHyperlinkHandlers.remove(
 958         EventMultiplexerImpl::ImplHyperLinkHandlers::container_type::value_type(
 959             rHandler,
 960             0.0) );
 961 }
 962
 963 void EventMultiplexer::notifyShapeListenerAdded(
 964     const uno::Reference<presentation::XShapeEventListener>& xListener,
 965     const uno::Reference<drawing::XShape>&                   xShape )
 966 {
 967     mpImpl->maShapeListenerHandlers.applyAll(
 968         [&xListener, &xShape]( const ShapeListenerEventHandlerSharedPtr& pHandler )
 969         { return pHandler->listenerAdded( xListener, xShape ); } );
 970 }
 971
 972 void EventMultiplexer::notifyShapeListenerRemoved(
 973     const uno::Reference<presentation::XShapeEventListener>& xListener,
 974     const uno::Reference<drawing::XShape>&                   xShape )
 975 {
 976     mpImpl->maShapeListenerHandlers.applyAll(
 977         [&xListener, &xShape]( const ShapeListenerEventHandlerSharedPtr& pHandler )
 978         { return pHandler->listenerRemoved( xListener, xShape ); } );
 979 }
 980
 981 void EventMultiplexer::notifyUserPaintColor( RGBColor const& rUserColor )
 982 {
 983     mpImpl->maUserPaintEventHandlers.applyAll(
 984         [&rUserColor]( const UserPaintEventHandlerSharedPtr& pHandler )
 985         { return pHandler->colorChanged( rUserColor ); } );
 986 }
 987
 988 void EventMultiplexer::notifyUserPaintStrokeWidth( double rUserStrokeWidth )
 989 {
 990     mpImpl->maUserPaintEventHandlers.applyAll(
 991         [&rUserStrokeWidth]( const UserPaintEventHandlerSharedPtr& pHandler )
 992         { return pHandler->widthChanged( rUserStrokeWidth ); } );
 993 }
 994
 995 void EventMultiplexer::notifyUserPaintDisabled()
 996 {
 997     mpImpl->maUserPaintEventHandlers.applyAll(
 998         std::mem_fn(&UserPaintEventHandler::disable));
 999 }
1000
1001 void EventMultiplexer::notifySwitchPenMode(){
1002     mpImpl->maUserPaintEventHandlers.applyAll(
1003         std::mem_fn(&UserPaintEventHandler::switchPenMode));
1004 }
1005
1006 void EventMultiplexer::notifySwitchEraserMode(){
1007     mpImpl->maUserPaintEventHandlers.applyAll(
1008         std::mem_fn(&UserPaintEventHandler::switchEraserMode));
1009 }
1010
1011 //adding erasing all ink features with UserPaintOverlay
1012 void EventMultiplexer::notifyEraseAllInk( bool bEraseAllInk )
1013 {
1014     mpImpl->maUserPaintEventHandlers.applyAll(
1015         [&bEraseAllInk]( const UserPaintEventHandlerSharedPtr& pHandler )
1016         { return pHandler->eraseAllInkChanged( bEraseAllInk ); } );
1017 }
1018
1019 //adding erasing features with UserPaintOverlay
1020 void EventMultiplexer::notifyEraseInkWidth( sal_Int32 rEraseInkSize )
1021 {
1022     mpImpl->maUserPaintEventHandlers.applyAll(
1023         [&rEraseInkSize]( const UserPaintEventHandlerSharedPtr& pHandler )
1024         { return pHandler->eraseInkWidthChanged( rEraseInkSize ); } );
1025 }
1026
1027 bool EventMultiplexer::notifyNextEffect()
1028 {
1029     return mpImpl->notifyNextEffect();
1030 }
1031
1032 void EventMultiplexer::notifySlideStartEvent()
1033 {
1034     mpImpl->maSlideStartHandlers.applyAll(
1035         std::mem_fn(&EventHandler::handleEvent) );
1036 }
1037
1038 bool EventMultiplexer::notifySlideEndEvent()
1039 {
1040     return mpImpl->maSlideEndHandlers.applyAll(
1041         std::mem_fn(&EventHandler::handleEvent) );
1042 }
1043
1044 bool EventMultiplexer::notifyAnimationStart(
1045     const AnimationNodeSharedPtr& rNode )
1046 {
1047     return EventMultiplexerImpl::notifyAllAnimationHandlers( mpImpl->maAnimationStartHandlers,
1048                                                rNode );
1049 }
1050
1051 bool EventMultiplexer::notifyAnimationEnd(
1052     const AnimationNodeSharedPtr& rNode )
1053 {
1054     return EventMultiplexerImpl::notifyAllAnimationHandlers( mpImpl->maAnimationEndHandlers,
1055                                                rNode );
1056 }
1057
1058 bool EventMultiplexer::notifySlideAnimationsEnd()
1059 {
1060     return mpImpl->maSlideAnimationsEndHandlers.applyAll(
1061         std::mem_fn(&EventHandler::handleEvent));
1062 }
1063
1064 bool EventMultiplexer::notifyAudioStopped(
1065     const AnimationNodeSharedPtr& rNode )
1066 {
1067     return EventMultiplexerImpl::notifyAllAnimationHandlers(
1068         mpImpl->maAudioStoppedHandlers,
1069         rNode );
1070 }
1071
1072 bool EventMultiplexer::notifyCommandStopAudio(
1073     const AnimationNodeSharedPtr& rNode )
1074 {
1075     return EventMultiplexerImpl::notifyAllAnimationHandlers(
1076         mpImpl->maCommandStopAudioHandlers,
1077         rNode );
1078 }
1079
1080 void EventMultiplexer::notifyPauseMode( bool bPauseShow )
1081 {
1082     mpImpl->maPauseHandlers.applyAll(
1083         [&bPauseShow]( const PauseEventHandlerSharedPtr& pHandler )
1084         { return pHandler->handlePause( bPauseShow ); } );
1085 }
1086
1087 void EventMultiplexer::notifyViewAdded( const UnoViewSharedPtr& rView )
1088 {
1089     ENSURE_OR_THROW( rView, "EventMultiplexer::notifyViewAdded(): Invalid view");
1090
1091     // register event listener
1092     uno::Reference<presentation::XSlideShowView> const rUnoView(
1093         rView->getUnoView() );
1094
1095     if( mpImpl->isMouseListenerRegistered() )
1096         rUnoView->addMouseListener(
1097             mpImpl->mxListener.get() );
1098
1099     if( !mpImpl->maMouseMoveHandlers.isEmpty() )
1100         rUnoView->addMouseMotionListener(
1101             mpImpl->mxListener.get() );
1102
1103     mpImpl->maViewHandlers.applyAll(
1104         [&rView]( const ViewEventHandlerWeakPtr& pHandler )
1105         { return pHandler.lock()->viewAdded( rView ); } );
1106 }
1107
1108 void EventMultiplexer::notifyViewRemoved( const UnoViewSharedPtr& rView )
1109 {
1110     ENSURE_OR_THROW( rView,
1111                       "EventMultiplexer::removeView(): Invalid view" );
1112
1113     // revoke event listeners
1114     uno::Reference<presentation::XSlideShowView> const rUnoView(
1115         rView->getUnoView() );
1116
1117     if( mpImpl->isMouseListenerRegistered() )
1118         rUnoView->removeMouseListener(
1119             mpImpl->mxListener.get() );
1120
1121     if( !mpImpl->maMouseMoveHandlers.isEmpty() )
1122         rUnoView->removeMouseMotionListener(
1123             mpImpl->mxListener.get() );
1124
1125     mpImpl->maViewHandlers.applyAll(
1126         [&rView]( const ViewEventHandlerWeakPtr& pHandler )
1127         { return pHandler.lock()->viewRemoved( rView ); } );
1128 }
1129
1130 bool EventMultiplexer::notifyViewChanged( const UnoViewSharedPtr& rView )
1131 {
1132     return mpImpl->maViewHandlers.applyAll(
1133         [&rView]( const ViewEventHandlerWeakPtr& pHandler )
1134         { return pHandler.lock()->viewChanged( rView ); } );
1135 }
1136
1137 void EventMultiplexer::notifyViewChanged( const uno::Reference<presentation::XSlideShowView>& xView )
1138 {
1139     UnoViewSharedPtr pView( mpImpl->findUnoView(xView) );
1140
1141     if( !pView )
1142         return; // view not registered here
1143
1144     notifyViewChanged( pView );
1145 }
1146
1147 void EventMultiplexer::notifyViewsChanged()
1148 {
1149     mpImpl->maViewHandlers.applyAll(
1150         std::mem_fn( &ViewEventHandler::viewsChanged ));
1151 }
1152
1153 void EventMultiplexer::notifyViewClobbered(
1154     const uno::Reference<presentation::XSlideShowView>& xView )
1155 {
1156     UnoViewSharedPtr pView( mpImpl->findUnoView(xView) );
1157
1158     if( !pView )
1159         return; // view not registered here
1160
1161     mpImpl->maViewRepaintHandlers.applyAll(
1162         [&pView]( const ViewRepaintHandlerSharedPtr& pHandler )
1163         { return pHandler->viewClobbered( pView ); } );
1164 }
1165
1166 void EventMultiplexer::notifyHyperlinkClicked(
1167     OUString const& hyperLink )
1168 {
1169     mpImpl->maHyperlinkHandlers.apply(
1170         [&hyperLink]( const PrioritizedHandlerEntry< HyperlinkHandler >& pHandler )
1171         { return pHandler.getHandler()->handleHyperlink( hyperLink ); } );
1172 }
1173
1174 } // namespace internal
1175 } // namespace presentation
1176
1177 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */