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