LCOV - code coverage report
Current view: top level - slideshow/source/inc - eventmultiplexer.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 4 6 66.7 %
Date: 2014-11-03 Functions: 4 8 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
      20             : #define INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
      21             : 
      22             : #include "eventhandler.hxx"
      23             : #include "mouseeventhandler.hxx"
      24             : #include "animationeventhandler.hxx"
      25             : #include "pauseeventhandler.hxx"
      26             : #include "shapelistenereventhandler.hxx"
      27             : #include "vieweventhandler.hxx"
      28             : 
      29             : #include <boost/noncopyable.hpp>
      30             : #include <boost/scoped_ptr.hpp>
      31             : #include <boost/shared_ptr.hpp>
      32             : #include <boost/weak_ptr.hpp>
      33             : #include <com/sun/star/uno/Reference.hxx>
      34             : 
      35             : #include "unoview.hxx"
      36             : 
      37             : namespace com { namespace sun { namespace star { namespace drawing
      38             : {
      39             :     class XShape;
      40             : } } } }
      41             : 
      42             : namespace slideshow {
      43             : namespace internal {
      44             : 
      45             : class EventQueue;
      46             : class UnoViewContainer;
      47             : class AnimationNode;
      48             : 
      49             : struct EventMultiplexerImpl;
      50             : 
      51             : class RGBColor;
      52             : 
      53             : /** Interface for handling view repaint events.
      54             : 
      55             :     Classes implementing this interface can be added to an
      56             :     EventMultiplexer object, and are called from there to
      57             :     handle view repaint events.
      58             : */
      59           2 : class ViewRepaintHandler
      60             : {
      61             : public:
      62           2 :     virtual ~ViewRepaintHandler() {}
      63             : 
      64             :     /** Notify clobbered view.
      65             : 
      66             :       Reasons for a viewChanged notification can be
      67             :       different view size, transformation, or other device
      68             :       properties (color resolution or profile, etc.)
      69             : 
      70             :       @param rView
      71             :       The changed view
      72             :      */
      73             :     virtual void viewClobbered( const UnoViewSharedPtr& rView ) = 0;
      74             : };
      75             : 
      76             : typedef ::boost::shared_ptr< ViewRepaintHandler > ViewRepaintHandlerSharedPtr;
      77             : typedef ::boost::weak_ptr< ViewRepaintHandler >   ViewRepaintHandlerWeakPtr;
      78             : 
      79             : /** Interface for handling hyperlink clicks.
      80             : 
      81             :   Classes implementing this interface can be added to an
      82             :   EventMultiplexer object, and are called from there to
      83             :   handle hyperlink events.
      84             :  */
      85           2 : class HyperlinkHandler
      86             : {
      87             : public:
      88             :     /** Handle the event.
      89             : 
      90             :         @param rLink
      91             :         The actual hyperlink URI
      92             : 
      93             :         @return true, if this handler has successfully
      94             :         processed the event. When this method returns false,
      95             :         possibly other, less prioritized handlers are called,
      96             :         too.
      97             :     */
      98             :     virtual bool handleHyperlink( OUString const& rLink ) = 0;
      99             : 
     100             : protected:
     101           2 :     ~HyperlinkHandler() {}
     102             : };
     103             : 
     104             : typedef ::boost::shared_ptr< HyperlinkHandler > HyperlinkHandlerSharedPtr;
     105             : 
     106             : /** Interface for handling user paint state changes.
     107             : 
     108             :     Classes implementing this interface can be added to an
     109             :     EventMultiplexer object, and are called from there to
     110             :     handle user paint events.
     111             : */
     112           0 : class UserPaintEventHandler
     113             : {
     114             : public:
     115           0 :     virtual ~UserPaintEventHandler() {}
     116             :     virtual bool colorChanged( RGBColor const& rUserColor ) = 0;
     117             :     virtual bool widthChanged( double nUserStrokeWidth ) = 0;
     118             :     virtual bool eraseAllInkChanged(bool const& rEraseAllInk) =0;
     119             :     virtual bool eraseInkWidthChanged(sal_Int32 rEraseInkSize) =0;
     120             :     virtual bool switchEraserMode() = 0;
     121             :     virtual bool switchPenMode() = 0;
     122             :     virtual bool disable() = 0;
     123             : };
     124             : 
     125             : typedef ::boost::shared_ptr< UserPaintEventHandler > UserPaintEventHandlerSharedPtr;
     126             : 
     127             : /** Interface for handling view events.
     128             : 
     129             :     Classes implementing this interface can be added to an
     130             :     EventMultiplexer object, and are called from there to
     131             :     handle view events.
     132             : */
     133             : class ShapeCursorEventHandler
     134             : {
     135             : public:
     136             :     virtual ~ShapeCursorEventHandler() {}
     137             : 
     138             :     virtual bool cursorChanged( const ::com::sun::star::uno::Reference<
     139             :                                       ::com::sun::star::drawing::XShape>&   xShape,
     140             :                                       sal_Int16                                nCursor ) = 0;
     141             : };
     142             : 
     143             : typedef ::boost::shared_ptr< ShapeCursorEventHandler > ShapeCursorEventHandlerSharedPtr;
     144             : 
     145             : /** This class multiplexes user-activated and
     146             :     slide-show global events.
     147             : 
     148             :     This class listens at the XSlideShowView and fires events
     149             :     registered for certain user actions. Furthermore, global
     150             :     slide show state changes (such as start or end of a slide)
     151             :     are handled as well. Note that registered events which
     152             :     have a non-zero timeout (i.e. events that return non-zero
     153             :     from getActivationTime()) will not be fired immediately
     154             :     after the user action occurred, but only after the given
     155             :     timeout. Which is actually a feature.
     156             : */
     157             : class EventMultiplexer : private ::boost::noncopyable
     158             : {
     159             : public:
     160             :     /** Create an event multiplexer
     161             : 
     162             :         @param rEventQueue
     163             :         Reference to the main event queue. Since we hold this
     164             :         object by plain reference, it must live longer than we
     165             :         do. On the other hand, that queue must not fire events
     166             :         after this object is destroyed, since we might
     167             :         schedule events there which itself contain plain
     168             :         references to this object. Basically, EventQueue and
     169             :         EventMultiplexer should have the same lifetime, and since
     170             :         this is not possible, both must be destructed in a
     171             :         phased mode: first clear both of any remaining events,
     172             :         then destruct them.
     173             : 
     174             :         @param rViewContainer
     175             :         Globally managed list of all registered views. Used to
     176             :         determine event sources, and for registering view listeners
     177             :         at.
     178             :     */
     179             :     EventMultiplexer( EventQueue&             rEventQueue,
     180             :                       UnoViewContainer const& rViewContainer );
     181             :     ~EventMultiplexer();
     182             : 
     183             :     // Management methods
     184             : 
     185             : 
     186             :     /** Clear all registered handlers.
     187             :      */
     188             :     void clear();
     189             : 
     190             : 
     191             :     // Automatic mode methods
     192             : 
     193             : 
     194             :     /** Change automatic mode.
     195             : 
     196             :         @param bIsAuto
     197             :         When true, events will be fired automatically, not
     198             :         only triggered by UI events. When false, auto events
     199             :         will quit.
     200             :     */
     201             :     void setAutomaticMode( bool bIsAuto );
     202             : 
     203             :     /** Get automatic mode setting.
     204             :      */
     205             :     bool getAutomaticMode() const;
     206             : 
     207             :     /** Set the timeout for automatic mode.
     208             : 
     209             :         @param nTimeout
     210             :         Timeout, between end of effect until start of next
     211             :         effect.
     212             :     */
     213             :     void setAutomaticTimeout( double nTimeout );
     214             : 
     215             :     /** Get automatic mode timeout value.
     216             :      */
     217             :     double getAutomaticTimeout() const;
     218             : 
     219             :     // Handler registration methods
     220             : 
     221             : 
     222             :     /** Register an event handler that will be called when views are
     223             :         changed.
     224             : 
     225             :         For each view added, viewAdded() will be called on the
     226             :         handler. For each view removed, viewRemoved() will be
     227             :         called. Each modified view will cause a viewChanged() call on
     228             :         each handler.
     229             : 
     230             :         You don't need to deregister the handler, it will be
     231             :         automatically removed, once the pointee becomes stale.
     232             : 
     233             :         @param rHandler
     234             :         Handler to call.
     235             :     */
     236             :     void addViewHandler( const ViewEventHandlerWeakPtr& rHandler );
     237             :     void removeViewHandler( const ViewEventHandlerWeakPtr& rHandler );
     238             : 
     239             :     /** Register an event handler that will be called when a view gets
     240             :         clobbered.
     241             : 
     242             :         Note that <em>all</em> registered handlers will be called when
     243             :         the event. This is in contrast to the mouse events below.
     244             : 
     245             :         @param rHandler
     246             :         Handler to call when a view needs a repaint
     247             :     */
     248             :     void addViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler );
     249             :     void removeViewRepaintHandler( const ViewRepaintHandlerSharedPtr& rHandler );
     250             : 
     251             :     /** Register an event handler that will be called when
     252             :         XShapeListeners are changed.
     253             : 
     254             :         @param rHandler
     255             :         Handler to call when a shape listener changes
     256             :     */
     257             :     void addShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler );
     258             :     void removeShapeListenerHandler( const ShapeListenerEventHandlerSharedPtr& rHandler );
     259             : 
     260             :     /** Register an event handler that will be called when
     261             :         user paint parameters change.
     262             : 
     263             :         @param rHandler
     264             :         Handler to call when a shape listener changes
     265             :     */
     266             :     void addUserPaintHandler( const UserPaintEventHandlerSharedPtr& rHandler );
     267             : 
     268             :     /** Register an event handler that will be called when the
     269             :         user requests the next effect.
     270             : 
     271             :         For every nextEffect event, only one of the handlers
     272             :         registered here is called. The handlers are considered
     273             :         with decreasing priority, i.e. the handler with the
     274             :         currently highest priority will be called.
     275             : 
     276             :         @param rHandler
     277             :         Handler to call when the next effect should start
     278             : 
     279             :         @param nPriority
     280             :         Priority with which the handlers are called. The
     281             :         higher the priority, the earlier this handler will be
     282             :         tried.
     283             :     */
     284             :     void addNextEffectHandler( const EventHandlerSharedPtr& rHandler,
     285             :                                double                       nPriority );
     286             :     void removeNextEffectHandler( const EventHandlerSharedPtr& rHandler );
     287             : 
     288             :     /** Register an event handler that will be called when the
     289             :         slide is just shown.
     290             : 
     291             :         Note that <em>all</em> registered handlers will be called
     292             :         when the slide start occurs. This is in contrast to
     293             :         the mouse events below.
     294             : 
     295             :         @param rHandler
     296             :         Handler to call when the next slide starts
     297             :     */
     298             :     void addSlideStartHandler( const EventHandlerSharedPtr& rHandler );
     299             :     void removeSlideStartHandler( const EventHandlerSharedPtr& rHandler );
     300             : 
     301             :     /** Register an event handler that will be called when the
     302             :         slide is about to vanish.
     303             : 
     304             :         Note that <em>all</em> registered handlers will be
     305             :         called when the slide end occurs. This is in contrast
     306             :         to the mouse events below.
     307             : 
     308             :         @param rHandler
     309             :         Handler to call when the current slide ends
     310             :     */
     311             :     void addSlideEndHandler( const EventHandlerSharedPtr& rHandler );
     312             :     void removeSlideEndHandler( const EventHandlerSharedPtr& rHandler );
     313             : 
     314             :     /** Register an event handler that will be called when an
     315             :         XAnimationNode starts its active duration.
     316             : 
     317             :         Note that <em>all</em> registered handlers will be called
     318             :         when the animation start occurs. This is in contrast to
     319             :         the mouse events below.
     320             : 
     321             :         @param rHandler
     322             :         Handler to call when the animation start
     323             :     */
     324             :     void addAnimationStartHandler(
     325             :         const AnimationEventHandlerSharedPtr& rHandler );
     326             :     void removeAnimationStartHandler(
     327             :         const AnimationEventHandlerSharedPtr& rHandler );
     328             : 
     329             :     /** Register an event handler that will be called when an
     330             :         XAnimationNode ends its active duration.
     331             : 
     332             :         Note that <em>all</em> registered handlers will be called
     333             :         when the animation end occurs. This is in contrast to
     334             :         the mouse events below.
     335             : 
     336             :         @param rHandler
     337             :         Handler to call when the animation ends
     338             :     */
     339             :     void addAnimationEndHandler(
     340             :         const AnimationEventHandlerSharedPtr& rHandler );
     341             :     void removeAnimationEndHandler(
     342             :         const AnimationEventHandlerSharedPtr& rHandler );
     343             : 
     344             :     /** Register an event handler that will be called when the
     345             :         main animation sequence of a slide ends its active
     346             :         duration.
     347             : 
     348             :         Note that <em>all</em> registered handlers will be
     349             :         called when the animation end occurs. This is in
     350             :         contrast to the mouse events below.
     351             : 
     352             :         @param rHandler
     353             :         Handler to call when the animation ends
     354             :     */
     355             :     void addSlideAnimationsEndHandler(
     356             :         const EventHandlerSharedPtr& rHandler );
     357             :     void removeSlideAnimationsEndHandler(
     358             :         const EventHandlerSharedPtr& rHandler );
     359             : 
     360             :     /** Register an event handler that will be called when an
     361             :         XAudio node's sound stops playing.
     362             : 
     363             :         Note that <em>all</em> registered handlers will be
     364             :         called when the audio stops. This is in contrast to
     365             :         the mouse events below.
     366             : 
     367             :         @param rHandler
     368             :         Handler to call when the audio stops
     369             :     */
     370             :     void addAudioStoppedHandler(
     371             :         const AnimationEventHandlerSharedPtr& rHandler );
     372             :     void removeAudioStoppedHandler(
     373             :         const AnimationEventHandlerSharedPtr& rHandler );
     374             : 
     375             :     /** Register an event handler that will be called when an
     376             :         XCommand node's with the command STOPAUDIO is activated.
     377             : 
     378             :         Note that <em>all</em> registered handlers will be
     379             :         called when the audio stops. This is in contrast to
     380             :         the mouse events below.
     381             : 
     382             :         @param rHandler
     383             :         Handler to call when command is activated
     384             :     */
     385             :     void addCommandStopAudioHandler(
     386             :         const AnimationEventHandlerSharedPtr& rHandler );
     387             :     void removeCommandStopAudioHandler(
     388             :         const AnimationEventHandlerSharedPtr& rHandler );
     389             : 
     390             :     /** Register a handler that is called when the show enters
     391             :         or exits pause mode.
     392             :     */
     393             :     void addPauseHandler( const PauseEventHandlerSharedPtr& rHandler );
     394             :     void removePauseHandler( const PauseEventHandlerSharedPtr& rHandler );
     395             : 
     396             :     /** Register a mouse handler that is called on mouse click
     397             : 
     398             :         For every mouse click, only one of the handlers
     399             :         registered here is called. The handlers are considered
     400             :         with decreasing priority, i.e. the handler with the
     401             :         currently highest priority will be called.
     402             : 
     403             :         Since the handlers can reject down and up events
     404             :         individually, handlers should expect to be called with
     405             :         non-matching down and up-press counts. If your handler
     406             :         cannot cope with that, it must have the highest
     407             :         priority of all added handlers.
     408             :     */
     409             :     void addClickHandler( const MouseEventHandlerSharedPtr& rHandler,
     410             :                           double                            nPriority );
     411             :     void removeClickHandler( const MouseEventHandlerSharedPtr& rHandler );
     412             : 
     413             :     /** Register a mouse handler that is called on a double
     414             :         mouse click
     415             : 
     416             :         For every mouse double click, only one of the handlers
     417             :         registered here is called. The handlers are considered
     418             :         with decreasing priority, i.e. the handler with the
     419             :         currently highest priority will be called.
     420             : 
     421             :         Since the handlers can reject down and up events
     422             :         individually, handlers should expect to be called with
     423             :         non-matching down and up-press counts. If your handler
     424             :         cannot cope with that, it must have the highest
     425             :         priority of all added handlers.
     426             :     */
     427             :     void addDoubleClickHandler( const MouseEventHandlerSharedPtr&   rHandler,
     428             :                                 double                              nPriority );
     429             :     void removeDoubleClickHandler( const MouseEventHandlerSharedPtr& rHandler );
     430             : 
     431             :     /** Register a mouse handler that is called for mouse moves.
     432             : 
     433             :         For every mouse move, only one of the handlers
     434             :         registered here is called. The handlers are considered
     435             :         with decreasing priority, i.e. the handler with the
     436             :         currently highest priority will be called.
     437             :     */
     438             :     void addMouseMoveHandler( const MouseEventHandlerSharedPtr& rHandler,
     439             :                               double                            nPriority );
     440             :     void removeMouseMoveHandler( const MouseEventHandlerSharedPtr& rHandler );
     441             : 
     442             : 
     443             :     /** Registers a hyperlink click handler.
     444             : 
     445             :         For every hyperlink click, only one of the handlers registered
     446             :         here is called. The handlers are considered with decreasing
     447             :         priority, i.e. the handler with the currently highest priority
     448             :         will be called.
     449             : 
     450             :         @param rHandler
     451             :         @param nPriority
     452             :     */
     453             :     void addHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler,
     454             :                               double                           nPriority );
     455             :     void removeHyperlinkHandler( const HyperlinkHandlerSharedPtr& rHandler );
     456             : 
     457             : 
     458             :     // External event notifications
     459             : 
     460             : 
     461             :     /** View added.
     462             : 
     463             :         This method adds another view, which the show is
     464             :         displayed on. On every added view, the EventMultiplexer
     465             :         registers mouse and motion event listeners.
     466             :     */
     467             :     bool notifyViewAdded( const UnoViewSharedPtr& rView );
     468             : 
     469             :     /** View removed
     470             : 
     471             :         This method removes a view. Registered mouse and
     472             :         motion event listeners are revoked.
     473             :     */
     474             :     bool notifyViewRemoved( const UnoViewSharedPtr& rView );
     475             : 
     476             :     /** View changed
     477             : 
     478             :         This method announces a changed view to all view
     479             :         listeners. View changes include size and transformation.
     480             : 
     481             :         @param rView
     482             :         View that has changed
     483             :     */
     484             :     bool notifyViewChanged( const UnoViewSharedPtr& rView );
     485             : 
     486             :     /** View changed
     487             : 
     488             :         This method announces a changed view to all view
     489             :         listeners. View changes include size and transformation.
     490             : 
     491             :         @param xView
     492             :         View that has changed
     493             :     */
     494             :     bool notifyViewChanged( const ::com::sun::star::uno::Reference<
     495             :                                ::com::sun::star::presentation::XSlideShowView>& xView );
     496             : 
     497             :     /** All Views changed
     498             : 
     499             :         This method announces to all view listeners that
     500             :         <em>every</em> known view has changed. View changes include
     501             :         size and transformation.
     502             :     */
     503             :     bool notifyViewsChanged();
     504             : 
     505             :     /** View clobbered
     506             : 
     507             :         This method announces that the given view has been clobbered
     508             :         by something external to the slideshow, and needs an update.
     509             : 
     510             :         @param xView
     511             :         View that has been clobbered
     512             :     */
     513             :     bool notifyViewClobbered( const ::com::sun::star::uno::Reference<
     514             :                                  ::com::sun::star::presentation::XSlideShowView>& xView );
     515             : 
     516             :     /** New shape event listener added
     517             : 
     518             :         This method announces that the given listener was added for
     519             :         the specified shape.
     520             : 
     521             :         @return true, if at least one handler successfully processed
     522             :         the notification.
     523             :      */
     524             :     bool notifyShapeListenerAdded( const ::com::sun::star::uno::Reference<
     525             :                                       ::com::sun::star::presentation::XShapeEventListener>& xListener,
     526             :                                    const ::com::sun::star::uno::Reference<
     527             :                                       ::com::sun::star::drawing::XShape>&                   xShape );
     528             : 
     529             :     /** A shape event listener was removed
     530             : 
     531             :         This method announces that the given listener was removed for
     532             :         the specified shape.
     533             : 
     534             :         @return true, if at least one handler successfully processed
     535             :         the notification.
     536             :      */
     537             :     bool notifyShapeListenerRemoved( const ::com::sun::star::uno::Reference<
     538             :                                          ::com::sun::star::presentation::XShapeEventListener>& xListener,
     539             :                                      const ::com::sun::star::uno::Reference<
     540             :                                          ::com::sun::star::drawing::XShape>&                   xShape );
     541             : 
     542             :     /** A new shape cursor was set
     543             : 
     544             :         This method announces that the given cursor was set for the
     545             :         specified shape.
     546             : 
     547             :         @return true, if at least one handler successfully processed
     548             :         the notification.
     549             :      */
     550             :     bool notifyShapeCursorChange( const ::com::sun::star::uno::Reference<
     551             :                                      ::com::sun::star::drawing::XShape>&  xShape,
     552             :                                   sal_Int16                               nPointerShape );
     553             : 
     554             :     /** Notify a new user paint color
     555             : 
     556             :         Sending this notification also implies that user paint is
     557             :         enabled. User paint denotes the feature to draw colored lines
     558             :         on top of the slide content.
     559             : 
     560             :         @return true, if this event was processed by
     561             :         anybody. If false is returned, no handler processed
     562             :         this event (and probably, nothing will happen at all)
     563             :     */
     564             :     bool notifyUserPaintColor( RGBColor const& rUserColor );
     565             : 
     566             :     /** Notify a new user paint width
     567             : 
     568             :          Sending this notification also implies that user paint is
     569             :          enabled. .
     570             : 
     571             :          @return true, if this event was processed by
     572             :          anybody. If false is returned, no handler processed
     573             :          this event (and probably, nothing will happen at all)
     574             :          */
     575             :     bool notifyUserPaintStrokeWidth( double rUserStrokeWidth );
     576             : 
     577             : 
     578             :     /** Notify a new user paint erase all ink mode
     579             : 
     580             :      Sending this notification also implies that user paint is
     581             :      enabled. User paint denotes the feature to draw colored lines
     582             :      on top of the slide content.
     583             : 
     584             :      @return true, if this event was processed by
     585             :      anybody. If false is returned, no handler processed
     586             :      this event (and probably, nothing will happen at all)
     587             :      */
     588             :     bool notifyEraseAllInk( bool const& rEraseAllInk );
     589             :     bool notifySwitchPenMode();
     590             :     bool notifySwitchEraserMode();
     591             :     bool notifyEraseInkWidth( sal_Int32 rEraseInkSize );
     592             : 
     593             :     /** Notify that user paint is disabled
     594             : 
     595             :         User paint denotes the feature to draw colored lines on top of
     596             :         the slide content.
     597             : 
     598             :         @return true, if this event was processed by
     599             :         anybody. If false is returned, no handler processed
     600             :         this event (and probably, nothing will happen at all)
     601             :     */
     602             :     bool notifyUserPaintDisabled();
     603             : 
     604             :     /** Notify that the user requested the next effect.
     605             : 
     606             :         This requests the slideshow to display the next
     607             :         effect, or move to the next slide, if none are left.
     608             : 
     609             :         @return true, if this event was processed by
     610             :         anybody. If false is returned, no handler processed
     611             :         this event (and probably, nothing will happen at all)
     612             :     */
     613             :     bool notifyNextEffect();
     614             : 
     615             :     /** Notify that a new slide is about to be displayed
     616             :     */
     617             :     bool notifySlideTransitionStarted();
     618             : 
     619             :     /** Notify that a new slide has started
     620             : 
     621             :         This method is to be used from the Presentation object
     622             :         to signal that a new slide is starting now. This will
     623             :         invoke all registered slide start handlers.
     624             : 
     625             :         @return true, if this event was processed by
     626             :         anybody. If false is returned, no handler processed
     627             :         this event (and probably, nothing will happen at all)
     628             :     */
     629             :     bool notifySlideStartEvent();
     630             : 
     631             :     /** Notify that a slide has ended
     632             : 
     633             :         This method is to be used from the Presentation object
     634             :         to signal that a slide is ending now. This will invoke
     635             :         all registered slide end handlers.
     636             : 
     637             :         @return true, if this event was processed by
     638             :         anybody. If false is returned, no handler processed
     639             :         this event (and probably, nothing will happen at all)
     640             :     */
     641             :     bool notifySlideEndEvent();
     642             : 
     643             :     /** Notify that the given node enters its active duration.
     644             : 
     645             :         This method is to be used from the AnimationNode
     646             :         objects to signal that the active duration
     647             :         begins. This will invoke all registered animation
     648             :         start handlers.
     649             : 
     650             :         @param rNode
     651             :         Node which enters active duration.
     652             : 
     653             :         @return true, if this event was processed by
     654             :         anybody. If false is returned, no handler processed
     655             :         this event (and probably, nothing will happen at all)
     656             :     */
     657             :     bool notifyAnimationStart( const boost::shared_ptr<AnimationNode>& rNode );
     658             : 
     659             :     /** Notify that the given node leaves its active duration.
     660             : 
     661             :         This method is to be used from the AnimationNode
     662             :         objects to signal that the active duration
     663             :         ends now. This will invoke all registered animation
     664             :         end handlers.
     665             : 
     666             :         @param rNode
     667             :         Node which leaves active duration.
     668             : 
     669             :         @return true, if this event was processed by
     670             :         anybody. If false is returned, no handler processed
     671             :         this event (and probably, nothing will happen at all)
     672             :     */
     673             :     bool notifyAnimationEnd( const boost::shared_ptr<AnimationNode>& rNode );
     674             : 
     675             :     /** Notify that the slide animations sequence leaves its
     676             :         active duration.
     677             : 
     678             :         @return true, if this event was processed by
     679             :         anybody. If false is returned, no handler processed
     680             :         this event (and probably, nothing will happen at all)
     681             :     */
     682             :     bool notifySlideAnimationsEnd();
     683             : 
     684             :     /** Notify that for the given node, audio output has stopped.
     685             : 
     686             :         This method is to be used from the AnimationNode
     687             :         objects to signal that audio playback has just
     688             :         stopped.  This will invoke all registered audio
     689             :         stopped andlers.
     690             : 
     691             :         @param rNode
     692             :         Node for which audio has stopped.
     693             : 
     694             :         @return true, if this event was processed by
     695             :         anybody. If false is returned, no handler processed
     696             :         this event (and probably, nothing will happen at all)
     697             :     */
     698             :     bool notifyAudioStopped( const boost::shared_ptr<AnimationNode>& rNode );
     699             : 
     700             :     /** Notify that the show has entered or exited pause mode
     701             : 
     702             :         This method is to be used from the Presentation object
     703             :         to signal that a slide is entering (bPauseShow=true)
     704             :         or exiting (bPauseShow=false) pause mode. This will
     705             :         invoke all registered slide end handlers.
     706             : 
     707             :         @return true, if this event was processed by
     708             :         anybody. If false is returned, no handler processed
     709             :         this event (and probably, nothing will happen at all)
     710             :     */
     711             :     bool notifyPauseMode( bool bPauseShow );
     712             : 
     713             :     /** Notify that all audio has to be stopped.
     714             : 
     715             :         This method is used by XCommand nodes and all sound
     716             :         playing nodes should listen for this command and
     717             :         stop theire sounds when its fired.
     718             : 
     719             :         @return true, if this event was processed by
     720             :         anybody. If false is returned, no handler processed
     721             :         this event (and probably, nothing will happen at all)
     722             :     */
     723             :     bool notifyCommandStopAudio( const boost::shared_ptr<AnimationNode>& rNode );
     724             : 
     725             :     /** Botifies that a hyperlink has been clicked.
     726             : 
     727             :         @return true, if this event was processed by
     728             :         anybody. If false is returned, no handler processed
     729             :         this event (and probably, nothing will happen at all)
     730             :     */
     731             :     bool notifyHyperlinkClicked( OUString const& hyperLink );
     732             : 
     733             : private:
     734             :     boost::scoped_ptr<EventMultiplexerImpl> mpImpl;
     735             : };
     736             : 
     737             : } // namespace internal
     738             : } // namespace Presentation
     739             : 
     740             : #endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENTMULTIPLEXER_HXX
     741             : 
     742             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10