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: */
|
