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