Branch data 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 : : #include <canvas/debug.hxx>
22 : : #include <tools/diagnose_ex.h>
23 : :
24 : : #include <cppuhelper/basemutex.hxx>
25 : : #include <cppuhelper/compbase1.hxx>
26 : : #include <cppuhelper/factory.hxx>
27 : : #include <cppuhelper/implementationentry.hxx>
28 : : #include <cppuhelper/compbase2.hxx>
29 : : #include <cppuhelper/interfacecontainer.h>
30 : : #include <cppuhelper/exc_hlp.hxx>
31 : :
32 : : #include <comphelper/anytostring.hxx>
33 : : #include <comphelper/make_shared_from_uno.hxx>
34 : : #include <comphelper/scopeguard.hxx>
35 : : #include <comphelper/optional.hxx>
36 : : #include <comphelper/servicedecl.hxx>
37 : : #include <comphelper/namecontainer.hxx>
38 : :
39 : : #include <cppcanvas/spritecanvas.hxx>
40 : : #include <cppcanvas/vclfactory.hxx>
41 : : #include <cppcanvas/basegfxfactory.hxx>
42 : :
43 : : #include <tools/debug.hxx>
44 : :
45 : : #include <basegfx/point/b2dpoint.hxx>
46 : : #include <basegfx/polygon/b2dpolygon.hxx>
47 : : #include <basegfx/matrix/b2dhommatrix.hxx>
48 : : #include <basegfx/polygon/b2dpolygontools.hxx>
49 : : #include <basegfx/polygon/b2dpolypolygontools.hxx>
50 : : #include <basegfx/tools/canvastools.hxx>
51 : :
52 : : #include <vcl/font.hxx>
53 : : #include "rtl/ref.hxx"
54 : :
55 : : #include <com/sun/star/beans/XPropertySet.hpp>
56 : : #include <com/sun/star/util/XModifyListener.hpp>
57 : : #include <com/sun/star/util/XUpdatable.hpp>
58 : : #include <com/sun/star/awt/XPaintListener.hpp>
59 : : #include <com/sun/star/awt/SystemPointer.hpp>
60 : : #include <com/sun/star/animations/TransitionType.hpp>
61 : : #include <com/sun/star/animations/TransitionSubType.hpp>
62 : : #include <com/sun/star/presentation/XSlideShow.hpp>
63 : : #include <com/sun/star/presentation/XSlideShowListener.hpp>
64 : : #include <com/sun/star/lang/XServiceInfo.hpp>
65 : : #include <com/sun/star/lang/XServiceName.hpp>
66 : : #include <com/sun/star/lang/XComponent.hpp>
67 : : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
68 : : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
69 : : #include <com/sun/star/drawing/PointSequence.hpp>
70 : : #include <com/sun/star/drawing/XLayer.hpp>
71 : : #include <com/sun/star/drawing/XLayerSupplier.hpp>
72 : : #include <com/sun/star/drawing/XLayerManager.hpp>
73 : : #include <com/sun/star/container/XNameAccess.hpp>
74 : :
75 : : #include "com/sun/star/uno/Reference.hxx"
76 : : #include <com/sun/star/loader/CannotActivateFactoryException.hpp>
77 : :
78 : : #include "unoviewcontainer.hxx"
79 : : #include "transitionfactory.hxx"
80 : : #include "eventmultiplexer.hxx"
81 : : #include "usereventqueue.hxx"
82 : : #include "eventqueue.hxx"
83 : : #include "cursormanager.hxx"
84 : : #include "slideshowcontext.hxx"
85 : : #include "activitiesqueue.hxx"
86 : : #include "activitiesfactory.hxx"
87 : : #include "interruptabledelayevent.hxx"
88 : : #include "slide.hxx"
89 : : #include "shapemaps.hxx"
90 : : #include "slideview.hxx"
91 : : #include "tools.hxx"
92 : : #include "unoview.hxx"
93 : : #include "slidebitmap.hxx"
94 : : #include "rehearsetimingsactivity.hxx"
95 : : #include "waitsymbol.hxx"
96 : : #include "effectrewinder.hxx"
97 : : #include "framerate.hxx"
98 : :
99 : : #include <boost/noncopyable.hpp>
100 : : #include <boost/bind.hpp>
101 : :
102 : : #include <map>
103 : : #include <vector>
104 : : #include <iterator>
105 : : #include <string>
106 : : #include <algorithm>
107 : : #include <stdio.h>
108 : : #include <iostream>
109 : :
110 : : using namespace com::sun::star;
111 : : using namespace ::slideshow::internal;
112 : :
113 : : namespace {
114 : :
115 : : /** During animations the update() method tells its caller to call it as
116 : : soon as possible. This gives us more time to render the next frame and
117 : : still maintain a steady frame rate. This class is responsible for
118 : : synchronizing the display of new frames and thus keeping the frame rate
119 : : steady.
120 : : */
121 : 0 : class FrameSynchronization
122 : : {
123 : : public:
124 : : /** Create new object with a predefined duration between two frames.
125 : : @param nFrameDuration
126 : : The preferred duration between the display of two frames in
127 : : seconds.
128 : : */
129 : : FrameSynchronization (const double nFrameDuration);
130 : :
131 : : /** Set the current time as the time at which the current frame is
132 : : displayed. From this the target time of the next frame is derived.
133 : : */
134 : : void MarkCurrentFrame (void);
135 : :
136 : : /** When there is time left until the next frame is due then wait.
137 : : Otherwise return without delay.
138 : : */
139 : : void Synchronize (void);
140 : :
141 : : /** Activate frame synchronization when an animation is active and
142 : : frames are to be displayed in a steady rate. While active
143 : : Synchronize() will wait until the frame duration time has passed.
144 : : */
145 : : void Activate (void);
146 : :
147 : : /** Deactivate frame sychronization when no animation is active and the
148 : : time between frames depends on user actions and other external
149 : : sources. While deactivated Synchronize() will return without delay.
150 : : */
151 : : void Deactivate (void);
152 : :
153 : : private:
154 : : /** The timer that is used for synchronization is independent from the
155 : : one used by SlideShowImpl: it is not paused or modified by
156 : : animations.
157 : : */
158 : : canvas::tools::ElapsedTime maTimer;
159 : : /** Time between the display of frames. Enforced only when mbIsActive
160 : : is <TRUE/>.
161 : : */
162 : : const double mnFrameDuration;
163 : : /** Time (of maTimer) when the next frame shall be displayed.
164 : : Synchronize() will wait until this time.
165 : : */
166 : : double mnNextFrameTargetTime;
167 : : /** Synchronize() will wait only when this flag is <TRUE/>. Otherwise
168 : : it returns immediately.
169 : : */
170 : : bool mbIsActive;
171 : : };
172 : :
173 : : /******************************************************************************
174 : :
175 : : SlideShowImpl
176 : :
177 : : This class encapsulates the slideshow presentation viewer.
178 : :
179 : : With an instance of this class, it is possible to statically
180 : : and dynamically show a presentation, as defined by the
181 : : constructor-provided draw model (represented by a sequence
182 : : of ::com::sun::star::drawing::XDrawPage objects).
183 : :
184 : : It is possible to show the presentation on multiple views
185 : : simultaneously (e.g. for a multi-monitor setup). Since this
186 : : class also relies on user interaction, the corresponding
187 : : XSlideShowView interface provides means to register some UI
188 : : event listeners (mostly borrowed from awt::XWindow interface).
189 : :
190 : : Since currently (mid 2004), OOo isn't very well suited to
191 : : multi-threaded rendering, this class relies on <em>very
192 : : frequent</em> external update() calls, which will render the
193 : : next frame of animations. This works as follows: after the
194 : : displaySlide() has been successfully called (which setup and
195 : : starts an actual slide show), the update() method must be
196 : : called until it returns false.
197 : : Effectively, this puts the burden of providing
198 : : concurrency to the clients of this class, which, as noted
199 : : above, is currently unavoidable with the current state of
200 : : affairs (I've actually tried threading here, but failed
201 : : miserably when using the VCL canvas as the render backend -
202 : : deadlocked).
203 : :
204 : : ******************************************************************************/
205 : :
206 : : typedef cppu::WeakComponentImplHelper1<presentation::XSlideShow> SlideShowImplBase;
207 : :
208 : : typedef ::std::vector< ::cppcanvas::PolyPolygonSharedPtr> PolyPolygonVector;
209 : :
210 : : /// Maps XDrawPage for annotations persistence
211 : : typedef ::std::map< ::com::sun::star::uno::Reference<
212 : : ::com::sun::star::drawing::XDrawPage>,
213 : : PolyPolygonVector> PolygonMap;
214 : :
215 : 0 : class SlideShowImpl : private cppu::BaseMutex,
216 : : public CursorManager,
217 : : public SlideShowImplBase
218 : : {
219 : : public:
220 : : explicit SlideShowImpl(
221 : : uno::Reference<uno::XComponentContext> const& xContext );
222 : :
223 : : /** Notify that the transition phase of the current slide
224 : : has ended.
225 : :
226 : : The life of a slide has three phases: the transition
227 : : phase, when the previous slide vanishes, and the
228 : : current slide becomes visible, the shape animation
229 : : phase, when shape effects are running, and the phase
230 : : after the last shape animation has ended, but before
231 : : the next slide transition starts.
232 : :
233 : : This method notifies the end of the first phase.
234 : :
235 : : @param bPaintSlide
236 : : When true, Slide::show() is passed a true as well, denoting
237 : : explicit paint of slide content. Pass false here, if e.g. a
238 : : slide transition has already rendered the initial slide image.
239 : : */
240 : : void notifySlideTransitionEnded( bool bPaintSlide );
241 : :
242 : : /** Notify that the shape animation phase of the current slide
243 : : has ended.
244 : :
245 : : The life of a slide has three phases: the transition
246 : : phase, when the previous slide vanishes, and the
247 : : current slide becomes visible, the shape animation
248 : : phase, when shape effects are running, and the phase
249 : : after the last shape animation has ended, but before
250 : : the next slide transition starts.
251 : :
252 : : This method notifies the end of the second phase.
253 : : */
254 : : void notifySlideAnimationsEnded();
255 : :
256 : : /** Notify that the slide has ended.
257 : :
258 : : The life of a slide has three phases: the transition
259 : : phase, when the previous slide vanishes, and the
260 : : current slide becomes visible, the shape animation
261 : : phase, when shape effects are running, and the phase
262 : : after the last shape animation has ended, but before
263 : : the next slide transition starts.
264 : :
265 : : This method notifies the end of the third phase.
266 : : */
267 : : void notifySlideEnded (const bool bReverse);
268 : :
269 : : /** Notification from eventmultiplexer that a hyperlink
270 : : has been clicked.
271 : : */
272 : : bool notifyHyperLinkClicked( rtl::OUString const& hyperLink );
273 : :
274 : : /** Notification from eventmultiplexer that an animation event has occoured.
275 : : This will be forewarded to all registered XSlideShowListener
276 : : */
277 : : bool handleAnimationEvent( const AnimationNodeSharedPtr& rNode );
278 : :
279 : : private:
280 : : // XSlideShow:
281 : : virtual sal_Bool SAL_CALL nextEffect() throw (uno::RuntimeException);
282 : : virtual sal_Bool SAL_CALL previousEffect() throw (uno::RuntimeException);
283 : : virtual sal_Bool SAL_CALL startShapeActivity(
284 : : uno::Reference<drawing::XShape> const& xShape )
285 : : throw (uno::RuntimeException);
286 : : virtual sal_Bool SAL_CALL stopShapeActivity(
287 : : uno::Reference<drawing::XShape> const& xShape )
288 : : throw (uno::RuntimeException);
289 : : virtual sal_Bool SAL_CALL pause( sal_Bool bPauseShow )
290 : : throw (uno::RuntimeException);
291 : : virtual uno::Reference<drawing::XDrawPage> SAL_CALL getCurrentSlide()
292 : : throw (uno::RuntimeException);
293 : : virtual void SAL_CALL displaySlide(
294 : : uno::Reference<drawing::XDrawPage> const& xSlide,
295 : : uno::Reference<drawing::XDrawPagesSupplier> const& xDrawPages,
296 : : uno::Reference<animations::XAnimationNode> const& xRootNode,
297 : : uno::Sequence<beans::PropertyValue> const& rProperties )
298 : : throw (uno::RuntimeException);
299 : : virtual void SAL_CALL registerUserPaintPolygons( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xDocFactory ) throw (::com::sun::star::uno::RuntimeException);
300 : : virtual sal_Bool SAL_CALL setProperty(
301 : : beans::PropertyValue const& rProperty ) throw (uno::RuntimeException);
302 : : virtual sal_Bool SAL_CALL addView(
303 : : uno::Reference<presentation::XSlideShowView> const& xView )
304 : : throw (uno::RuntimeException);
305 : : virtual sal_Bool SAL_CALL removeView(
306 : : uno::Reference<presentation::XSlideShowView> const& xView )
307 : : throw (uno::RuntimeException);
308 : : virtual sal_Bool SAL_CALL update( double & nNextTimeout )
309 : : throw (uno::RuntimeException);
310 : : virtual void SAL_CALL addSlideShowListener(
311 : : uno::Reference<presentation::XSlideShowListener> const& xListener )
312 : : throw (uno::RuntimeException);
313 : : virtual void SAL_CALL removeSlideShowListener(
314 : : uno::Reference<presentation::XSlideShowListener> const& xListener )
315 : : throw (uno::RuntimeException);
316 : : virtual void SAL_CALL addShapeEventListener(
317 : : uno::Reference<presentation::XShapeEventListener> const& xListener,
318 : : uno::Reference<drawing::XShape> const& xShape )
319 : : throw (uno::RuntimeException);
320 : : virtual void SAL_CALL removeShapeEventListener(
321 : : uno::Reference<presentation::XShapeEventListener> const& xListener,
322 : : uno::Reference<drawing::XShape> const& xShape )
323 : : throw (uno::RuntimeException);
324 : : virtual void SAL_CALL setShapeCursor(
325 : : uno::Reference<drawing::XShape> const& xShape, sal_Int16 nPointerShape )
326 : : throw (uno::RuntimeException);
327 : :
328 : : // CursorManager
329 : : // -----------------------------------------------------------
330 : :
331 : : virtual bool requestCursor( sal_Int16 nCursorShape );
332 : : virtual void resetCursor();
333 : :
334 : : /** This is somewhat similar to displaySlide when called for the current
335 : : slide. It has been simplified to take advantage of that no slide
336 : : change takes place. Furthermore it does not show the slide
337 : : transition.
338 : : */
339 : : void redisplayCurrentSlide (void);
340 : :
341 : : protected:
342 : : // WeakComponentImplHelperBase
343 : : virtual void SAL_CALL disposing();
344 : :
345 : 0 : bool isDisposed() const
346 : : {
347 : 0 : return (rBHelper.bDisposed || rBHelper.bInDispose);
348 : : }
349 : :
350 : : private:
351 : : struct SeparateListenerImpl; friend struct SeparateListenerImpl;
352 : : class PrefetchPropertiesFunc; friend class PrefetchPropertiesFunc;
353 : :
354 : : /// Stop currently running show.
355 : : void stopShow();
356 : :
357 : : ///Find a polygons vector in maPolygons (map)
358 : : PolygonMap::iterator findPolygons( uno::Reference<drawing::XDrawPage> const& xDrawPage);
359 : :
360 : : /// Creates a new slide.
361 : : SlideSharedPtr makeSlide(
362 : : uno::Reference<drawing::XDrawPage> const& xDrawPage,
363 : : uno::Reference<drawing::XDrawPagesSupplier> const& xDrawPages,
364 : : uno::Reference<animations::XAnimationNode> const& xRootNode );
365 : :
366 : : /// Checks whether the given slide/animation node matches mpPrefetchSlide
367 : 0 : static bool matches(
368 : : SlideSharedPtr const& pSlide,
369 : : uno::Reference<drawing::XDrawPage> const& xSlide,
370 : : uno::Reference<animations::XAnimationNode> const& xNode )
371 : : {
372 : 0 : if (pSlide)
373 : 0 : return (pSlide->getXDrawPage() == xSlide &&
374 : 0 : pSlide->getXAnimationNode() == xNode);
375 : : else
376 : 0 : return (!xSlide.is() && !xNode.is());
377 : : }
378 : :
379 : : /// Resets the current slide transition sound object with a new one:
380 : : SoundPlayerSharedPtr resetSlideTransitionSound(
381 : : uno::Any const& url = uno::Any(), bool bLoopSound = false );
382 : :
383 : : /// stops the current slide transition sound
384 : : void stopSlideTransitionSound();
385 : :
386 : : /** Prepare a slide transition
387 : :
388 : : This method registers all necessary events and
389 : : activities for a slide transition.
390 : :
391 : : @return the slide change activity, or NULL for no transition effect
392 : : */
393 : : ActivitySharedPtr createSlideTransition(
394 : : const uno::Reference< drawing::XDrawPage >& xDrawPage,
395 : : const SlideSharedPtr& rLeavingSlide,
396 : : const SlideSharedPtr& rEnteringSlide,
397 : : const EventSharedPtr& rTransitionEndEvent );
398 : :
399 : : /** Request/release the wait symbol. The wait symbol is displayed when
400 : : there are more requests then releases. Locking the wait symbol
401 : : helps to avoid intermediate repaints.
402 : :
403 : : Do not call this method directly. Use WaitSymbolLock instead.
404 : : */
405 : : void requestWaitSymbol (void);
406 : : void releaseWaitSymbol (void);
407 : :
408 : : class WaitSymbolLock {public:
409 : 0 : WaitSymbolLock(SlideShowImpl& rSlideShowImpl) : mrSlideShowImpl(rSlideShowImpl)
410 : 0 : { mrSlideShowImpl.requestWaitSymbol(); }
411 : 0 : ~WaitSymbolLock(void)
412 : 0 : { mrSlideShowImpl.releaseWaitSymbol(); }
413 : : private: SlideShowImpl& mrSlideShowImpl;
414 : : };
415 : :
416 : : /// Filter requested cursor shape against hard slideshow cursors (wait, etc.)
417 : : sal_Int16 calcActiveCursor( sal_Int16 nCursorShape ) const;
418 : :
419 : : /** This method is called asynchronously to finish the rewinding of an
420 : : effect to the previous slide that was initiated earlier.
421 : : */
422 : : void rewindEffectToPreviousSlide (void);
423 : :
424 : : /// all registered views
425 : : UnoViewContainer maViewContainer;
426 : :
427 : : /// all registered slide show listeners
428 : : cppu::OInterfaceContainerHelper maListenerContainer;
429 : :
430 : : /// map of vectors, containing all registered listeners for a shape
431 : : ShapeEventListenerMap maShapeEventListeners;
432 : : /// map of sal_Int16 values, specifying the mouse cursor for every shape
433 : : ShapeCursorMap maShapeCursors;
434 : :
435 : : //map of vector of Polygons, containing polygons drawn on each slide.
436 : : PolygonMap maPolygons;
437 : :
438 : : boost::optional<RGBColor> maUserPaintColor;
439 : :
440 : : double maUserPaintStrokeWidth;
441 : :
442 : : //changed for the eraser project
443 : : boost::optional<bool> maEraseAllInk;
444 : : boost::optional<bool> maSwitchPenMode;
445 : : boost::optional<bool> maSwitchEraserMode;
446 : : boost::optional<sal_Int32> maEraseInk;
447 : : //end changed
448 : :
449 : : boost::shared_ptr<canvas::tools::ElapsedTime> mpPresTimer;
450 : : ScreenUpdater maScreenUpdater;
451 : : EventQueue maEventQueue;
452 : : EventMultiplexer maEventMultiplexer;
453 : : ActivitiesQueue maActivitiesQueue;
454 : : UserEventQueue maUserEventQueue;
455 : : SubsettableShapeManagerSharedPtr mpDummyPtr;
456 : :
457 : : boost::shared_ptr<SeparateListenerImpl> mpListener;
458 : :
459 : : boost::shared_ptr<RehearseTimingsActivity> mpRehearseTimingsActivity;
460 : : boost::shared_ptr<WaitSymbol> mpWaitSymbol;
461 : :
462 : : /// the current slide transition sound object:
463 : : SoundPlayerSharedPtr mpCurrentSlideTransitionSound;
464 : :
465 : : uno::Reference<uno::XComponentContext> mxComponentContext;
466 : : uno::Reference<
467 : : presentation::XTransitionFactory> mxOptionalTransitionFactory;
468 : :
469 : : /// the previously running slide
470 : : SlideSharedPtr mpPreviousSlide;
471 : : /// the currently running slide
472 : : SlideSharedPtr mpCurrentSlide;
473 : : /// the already prefetched slide: best candidate for upcoming slide
474 : : SlideSharedPtr mpPrefetchSlide;
475 : : /// slide to be prefetched: best candidate for upcoming slide
476 : : uno::Reference<drawing::XDrawPage> mxPrefetchSlide;
477 : : /// save the XDrawPagesSupplier to retieve polygons
478 : : uno::Reference<drawing::XDrawPagesSupplier> mxDrawPagesSupplier;
479 : : /// slide animation to be prefetched:
480 : : uno::Reference<animations::XAnimationNode> mxPrefetchAnimationNode;
481 : :
482 : : sal_Int16 mnCurrentCursor;
483 : :
484 : : sal_Int32 mnWaitSymbolRequestCount;
485 : : bool mbAutomaticAdvancementMode;
486 : : bool mbImageAnimationsAllowed;
487 : : bool mbNoSlideTransitions;
488 : : bool mbMouseVisible;
489 : : bool mbForceManualAdvance;
490 : : bool mbShowPaused;
491 : : bool mbSlideShowIdle;
492 : : bool mbDisableAnimationZOrder;
493 : :
494 : : EffectRewinder maEffectRewinder;
495 : : FrameSynchronization maFrameSynchronization;
496 : : };
497 : :
498 : : /** Separate event listener for animation, view and hyperlink events.
499 : :
500 : : This handler is registered for slide animation end, view and
501 : : hyperlink events at the global EventMultiplexer, and forwards
502 : : notifications to the SlideShowImpl
503 : : */
504 : 0 : struct SlideShowImpl::SeparateListenerImpl : public EventHandler,
505 : : public ViewRepaintHandler,
506 : : public HyperlinkHandler,
507 : : public AnimationEventHandler,
508 : : private boost::noncopyable
509 : : {
510 : : SlideShowImpl& mrShow;
511 : : ScreenUpdater& mrScreenUpdater;
512 : : EventQueue& mrEventQueue;
513 : :
514 : 0 : SeparateListenerImpl( SlideShowImpl& rShow,
515 : : ScreenUpdater& rScreenUpdater,
516 : : EventQueue& rEventQueue ) :
517 : : mrShow( rShow ),
518 : : mrScreenUpdater( rScreenUpdater ),
519 : 0 : mrEventQueue( rEventQueue )
520 : 0 : {}
521 : :
522 : : // EventHandler
523 : 0 : virtual bool handleEvent()
524 : : {
525 : : // DON't call notifySlideAnimationsEnded()
526 : : // directly, but queue an event. handleEvent()
527 : : // might be called from e.g.
528 : : // showNext(), and notifySlideAnimationsEnded() must not be called
529 : : // in recursion. Note that the event is scheduled for the next
530 : : // frame so that its expensive execution does not come in between
531 : : // sprite hiding and shape redraw (at the end of the animation of a
532 : : // shape), which would cause a flicker.
533 : : mrEventQueue.addEventForNextRound(
534 : 0 : makeEvent(
535 : : boost::bind( &SlideShowImpl::notifySlideAnimationsEnded, boost::ref(mrShow) ),
536 : 0 : "SlideShowImpl::notifySlideAnimationsEnded"));
537 : 0 : return true;
538 : : }
539 : :
540 : : // ViewRepaintHandler
541 : 0 : virtual void viewClobbered( const UnoViewSharedPtr& rView )
542 : : {
543 : : // given view needs repaint, request update
544 : 0 : mrScreenUpdater.notifyUpdate(rView, true);
545 : 0 : }
546 : :
547 : : // HyperlinkHandler
548 : 0 : virtual bool handleHyperlink( ::rtl::OUString const& rLink )
549 : : {
550 : 0 : return mrShow.notifyHyperLinkClicked(rLink);
551 : : }
552 : :
553 : : // AnimationEventHandler
554 : 0 : virtual bool handleAnimationEvent( const AnimationNodeSharedPtr& rNode )
555 : : {
556 : 0 : return mrShow.handleAnimationEvent(rNode);
557 : : }
558 : : };
559 : :
560 : 0 : SlideShowImpl::SlideShowImpl(
561 : : uno::Reference<uno::XComponentContext> const& xContext )
562 : : : SlideShowImplBase(m_aMutex),
563 : : maViewContainer(),
564 : : maListenerContainer( m_aMutex ),
565 : : maShapeEventListeners(),
566 : : maShapeCursors(),
567 : : maUserPaintColor(),
568 : : maUserPaintStrokeWidth(4.0),
569 : 0 : mpPresTimer( new canvas::tools::ElapsedTime ),
570 : : maScreenUpdater(maViewContainer),
571 : : maEventQueue( mpPresTimer ),
572 : : maEventMultiplexer( maEventQueue,
573 : : maViewContainer ),
574 : : maActivitiesQueue( mpPresTimer ),
575 : : maUserEventQueue( maEventMultiplexer,
576 : : maEventQueue,
577 : : *this ),
578 : : mpDummyPtr(),
579 : : mpListener(),
580 : : mpRehearseTimingsActivity(),
581 : : mpWaitSymbol(),
582 : : mpCurrentSlideTransitionSound(),
583 : : mxComponentContext( xContext ),
584 : : mxOptionalTransitionFactory(),
585 : : mpCurrentSlide(),
586 : : mpPrefetchSlide(),
587 : : mxPrefetchSlide(),
588 : : mxDrawPagesSupplier(),
589 : : mxPrefetchAnimationNode(),
590 : : mnCurrentCursor(awt::SystemPointer::ARROW),
591 : : mnWaitSymbolRequestCount(0),
592 : : mbAutomaticAdvancementMode(false),
593 : : mbImageAnimationsAllowed( true ),
594 : : mbNoSlideTransitions( false ),
595 : : mbMouseVisible( true ),
596 : : mbForceManualAdvance( false ),
597 : : mbShowPaused( false ),
598 : : mbSlideShowIdle( true ),
599 : : mbDisableAnimationZOrder( false ),
600 : : maEffectRewinder(maEventMultiplexer, maEventQueue, maUserEventQueue),
601 : 0 : maFrameSynchronization(1.0 / FrameRate::PreferredFramesPerSecond)
602 : :
603 : : {
604 : : // keep care not constructing any UNO references to this inside ctor,
605 : : // shift that code to create()!
606 : :
607 : : uno::Reference<lang::XMultiComponentFactory> xFactory(
608 : 0 : mxComponentContext->getServiceManager() );
609 : :
610 : 0 : if( xFactory.is() )
611 : : {
612 : : try
613 : : {
614 : : // #i82460# try to retrieve special transition factory
615 : : mxOptionalTransitionFactory.set(
616 : 0 : xFactory->createInstanceWithContext(
617 : : ::rtl::OUString("com.sun.star.presentation.TransitionFactory" ),
618 : 0 : mxComponentContext ),
619 : 0 : uno::UNO_QUERY );
620 : : }
621 : 0 : catch (loader::CannotActivateFactoryException const&)
622 : : {
623 : : }
624 : : }
625 : :
626 : : mpListener.reset( new SeparateListenerImpl(
627 : : *this,
628 : : maScreenUpdater,
629 : 0 : maEventQueue ));
630 : 0 : maEventMultiplexer.addSlideAnimationsEndHandler( mpListener );
631 : 0 : maEventMultiplexer.addViewRepaintHandler( mpListener );
632 : 0 : maEventMultiplexer.addHyperlinkHandler( mpListener, 0.0 );
633 : 0 : maEventMultiplexer.addAnimationStartHandler( mpListener );
634 : 0 : maEventMultiplexer.addAnimationEndHandler( mpListener );
635 : 0 : }
636 : :
637 : : // we are about to be disposed (someone call dispose() on us)
638 : 0 : void SlideShowImpl::disposing()
639 : : {
640 : 0 : osl::MutexGuard const guard( m_aMutex );
641 : :
642 : 0 : maEffectRewinder.dispose();
643 : :
644 : : // stop slide transition sound, if any:
645 : 0 : stopSlideTransitionSound();
646 : :
647 : 0 : mxComponentContext.clear();
648 : :
649 : 0 : if( mpCurrentSlideTransitionSound )
650 : : {
651 : 0 : mpCurrentSlideTransitionSound->dispose();
652 : 0 : mpCurrentSlideTransitionSound.reset();
653 : : }
654 : :
655 : 0 : mpWaitSymbol.reset();
656 : :
657 : 0 : if( mpRehearseTimingsActivity )
658 : : {
659 : 0 : mpRehearseTimingsActivity->dispose();
660 : 0 : mpRehearseTimingsActivity.reset();
661 : : }
662 : :
663 : 0 : if( mpListener )
664 : : {
665 : 0 : maEventMultiplexer.removeSlideAnimationsEndHandler(mpListener);
666 : 0 : maEventMultiplexer.removeViewRepaintHandler(mpListener);
667 : 0 : maEventMultiplexer.removeHyperlinkHandler(mpListener);
668 : 0 : maEventMultiplexer.removeAnimationStartHandler( mpListener );
669 : 0 : maEventMultiplexer.removeAnimationEndHandler( mpListener );
670 : :
671 : 0 : mpListener.reset();
672 : : }
673 : :
674 : 0 : maUserEventQueue.clear();
675 : 0 : maActivitiesQueue.clear();
676 : 0 : maEventMultiplexer.clear();
677 : 0 : maEventQueue.clear();
678 : 0 : mpPresTimer.reset();
679 : 0 : maShapeCursors.clear();
680 : 0 : maShapeEventListeners.clear();
681 : :
682 : : // send all listeners a disposing() that we are going down:
683 : : maListenerContainer.disposeAndClear(
684 : 0 : lang::EventObject( static_cast<cppu::OWeakObject *>(this) ) );
685 : :
686 : 0 : maViewContainer.dispose();
687 : :
688 : : // release slides:
689 : 0 : mxPrefetchAnimationNode.clear();
690 : 0 : mxPrefetchSlide.clear();
691 : 0 : mpPrefetchSlide.reset();
692 : 0 : mpCurrentSlide.reset();
693 : 0 : mpPreviousSlide.reset();
694 : 0 : }
695 : :
696 : : /// stops the current slide transition sound
697 : 0 : void SlideShowImpl::stopSlideTransitionSound()
698 : : {
699 : 0 : if (mpCurrentSlideTransitionSound)
700 : : {
701 : 0 : mpCurrentSlideTransitionSound->stopPlayback();
702 : 0 : mpCurrentSlideTransitionSound->dispose();
703 : 0 : mpCurrentSlideTransitionSound.reset();
704 : : }
705 : 0 : }
706 : :
707 : 0 : SoundPlayerSharedPtr SlideShowImpl::resetSlideTransitionSound( const uno::Any& rSound, bool bLoopSound )
708 : : {
709 : 0 : sal_Bool bStopSound = sal_False;
710 : 0 : rtl::OUString url;
711 : :
712 : 0 : if( !(rSound >>= bStopSound) )
713 : 0 : bStopSound = sal_False;
714 : 0 : rSound >>= url;
715 : :
716 : 0 : if( !bStopSound && url.isEmpty() )
717 : 0 : return SoundPlayerSharedPtr();
718 : :
719 : 0 : stopSlideTransitionSound();
720 : :
721 : 0 : if (!url.isEmpty())
722 : : {
723 : : try
724 : : {
725 : : mpCurrentSlideTransitionSound = SoundPlayer::create(
726 : 0 : maEventMultiplexer, url, mxComponentContext );
727 : 0 : mpCurrentSlideTransitionSound->setPlaybackLoop( bLoopSound );
728 : : }
729 : 0 : catch (lang::NoSupportException const&)
730 : : {
731 : : // catch possible exceptions from SoundPlayer, since
732 : : // being not able to playback the sound is not a hard
733 : : // error here (still, the slide transition should be
734 : : // shown).
735 : : }
736 : : }
737 : 0 : return mpCurrentSlideTransitionSound;
738 : : }
739 : :
740 : 0 : ActivitySharedPtr SlideShowImpl::createSlideTransition(
741 : : const uno::Reference< drawing::XDrawPage >& xDrawPage,
742 : : const SlideSharedPtr& rLeavingSlide,
743 : : const SlideSharedPtr& rEnteringSlide,
744 : : const EventSharedPtr& rTransitionEndEvent)
745 : : {
746 : 0 : ENSURE_OR_THROW( !maViewContainer.empty(),
747 : : "createSlideTransition(): No views" );
748 : 0 : ENSURE_OR_THROW( rEnteringSlide,
749 : : "createSlideTransition(): No entering slide" );
750 : :
751 : : // return empty transition, if slide transitions
752 : : // are disabled.
753 : 0 : if (mbNoSlideTransitions)
754 : 0 : return ActivitySharedPtr();
755 : :
756 : : // retrieve slide change parameters from XDrawPage
757 : : uno::Reference< beans::XPropertySet > xPropSet( xDrawPage,
758 : 0 : uno::UNO_QUERY );
759 : :
760 : 0 : if( !xPropSet.is() )
761 : : {
762 : : OSL_TRACE( "createSlideTransition(): "
763 : : "Slide has no PropertySet - assuming no transition\n" );
764 : 0 : return ActivitySharedPtr();
765 : : }
766 : :
767 : 0 : sal_Int16 nTransitionType(0);
768 : 0 : if( !getPropertyValue( nTransitionType,
769 : : xPropSet,
770 : 0 : OUSTR("TransitionType" )) )
771 : : {
772 : : OSL_TRACE( "createSlideTransition(): "
773 : : "Could not extract slide transition type from XDrawPage - assuming no transition\n" );
774 : 0 : return ActivitySharedPtr();
775 : : }
776 : :
777 : 0 : sal_Int16 nTransitionSubType(0);
778 : 0 : if( !getPropertyValue( nTransitionSubType,
779 : : xPropSet,
780 : 0 : OUSTR("TransitionSubtype" )) )
781 : : {
782 : : OSL_TRACE( "createSlideTransition(): "
783 : : "Could not extract slide transition subtype from XDrawPage - assuming no transition\n" );
784 : 0 : return ActivitySharedPtr();
785 : : }
786 : :
787 : 0 : bool bTransitionDirection(false);
788 : 0 : if( !getPropertyValue( bTransitionDirection,
789 : : xPropSet,
790 : 0 : OUSTR("TransitionDirection")) )
791 : : {
792 : : OSL_TRACE( "createSlideTransition(): "
793 : : "Could not extract slide transition direction from XDrawPage - assuming default direction\n" );
794 : : }
795 : :
796 : 0 : sal_Int32 aUnoColor(0);
797 : 0 : if( !getPropertyValue( aUnoColor,
798 : : xPropSet,
799 : 0 : OUSTR("TransitionFadeColor")) )
800 : : {
801 : : OSL_TRACE( "createSlideTransition(): "
802 : : "Could not extract slide transition fade color from XDrawPage - assuming black\n" );
803 : : }
804 : :
805 : 0 : const RGBColor aTransitionFadeColor( unoColor2RGBColor( aUnoColor ));
806 : :
807 : 0 : uno::Any aSound;
808 : 0 : sal_Bool bLoopSound = sal_False;
809 : :
810 : 0 : if( !getPropertyValue( aSound, xPropSet, OUSTR("Sound")) )
811 : : OSL_TRACE( "createSlideTransition(): Could not determine transition sound effect URL from XDrawPage - using no sound" );
812 : :
813 : 0 : if( !getPropertyValue( bLoopSound, xPropSet, OUSTR("LoopSound") ) )
814 : : OSL_TRACE( "createSlideTransition(): Could not get slide property 'LoopSound' - using no sound" );
815 : :
816 : : NumberAnimationSharedPtr pTransition(
817 : : TransitionFactory::createSlideTransition(
818 : : rLeavingSlide,
819 : : rEnteringSlide,
820 : : maViewContainer,
821 : : maScreenUpdater,
822 : : maEventMultiplexer,
823 : : mxOptionalTransitionFactory,
824 : : nTransitionType,
825 : : nTransitionSubType,
826 : : bTransitionDirection,
827 : : aTransitionFadeColor,
828 : 0 : resetSlideTransitionSound( aSound, bLoopSound ) ));
829 : :
830 : 0 : if( !pTransition )
831 : 0 : return ActivitySharedPtr(); // no transition effect has been
832 : : // generated. Normally, that means
833 : : // that simply no transition is
834 : : // set on this slide.
835 : :
836 : 0 : double nTransitionDuration(0.0);
837 : 0 : if( !getPropertyValue( nTransitionDuration,
838 : : xPropSet,
839 : 0 : OUSTR("TransitionDuration")) )
840 : : {
841 : : OSL_TRACE( "createSlideTransition(): "
842 : : "Could not extract slide transition duration from XDrawPage - assuming no transition\n" );
843 : 0 : return ActivitySharedPtr();
844 : : }
845 : :
846 : 0 : sal_Int32 nMinFrames(5);
847 : 0 : if( !getPropertyValue( nMinFrames,
848 : : xPropSet,
849 : 0 : OUSTR("MinimalFrameNumber")) )
850 : : {
851 : : OSL_TRACE( "createSlideTransition(): "
852 : : "No minimal number of frames given - assuming 5\n" );
853 : : }
854 : :
855 : : // prefetch slide transition bitmaps, but postpone it after
856 : : // displaySlide() has finished - sometimes, view size has not yet
857 : : // reached final size
858 : : maEventQueue.addEvent(
859 : : makeEvent(
860 : : boost::bind(
861 : : &::slideshow::internal::Animation::prefetch,
862 : : pTransition,
863 : : AnimatableShapeSharedPtr(),
864 : : ShapeAttributeLayerSharedPtr()),
865 : 0 : "Animation::prefetch"));
866 : :
867 : : return ActivitySharedPtr(
868 : : ActivitiesFactory::createSimpleActivity(
869 : : ActivitiesFactory::CommonParameters(
870 : : rTransitionEndEvent,
871 : : maEventQueue,
872 : : maActivitiesQueue,
873 : : nTransitionDuration,
874 : : nMinFrames,
875 : : false,
876 : : boost::optional<double>(1.0),
877 : : 0.0,
878 : : 0.0,
879 : : ShapeSharedPtr(),
880 : 0 : basegfx::B2DSize( rEnteringSlide->getSlideSize() ) ),
881 : : pTransition,
882 : 0 : true ));
883 : : }
884 : :
885 : 0 : PolygonMap::iterator SlideShowImpl::findPolygons( uno::Reference<drawing::XDrawPage> const& xDrawPage)
886 : : {
887 : : // TODO(P2) : Optimze research in the map.
888 : 0 : bool bFound = false;
889 : 0 : PolygonMap::iterator aIter=maPolygons.begin();
890 : :
891 : 0 : while(aIter!=maPolygons.end() && !bFound)
892 : : {
893 : 0 : if(aIter->first == xDrawPage)
894 : 0 : bFound = true;
895 : : else
896 : 0 : ++aIter;
897 : : }
898 : :
899 : 0 : return aIter;
900 : : }
901 : :
902 : 0 : SlideSharedPtr SlideShowImpl::makeSlide(
903 : : uno::Reference<drawing::XDrawPage> const& xDrawPage,
904 : : uno::Reference<drawing::XDrawPagesSupplier> const& xDrawPages,
905 : : uno::Reference<animations::XAnimationNode> const& xRootNode )
906 : : {
907 : 0 : if( !xDrawPage.is() )
908 : 0 : return SlideSharedPtr();
909 : :
910 : : //Retrieve polygons for the current slide
911 : 0 : PolygonMap::iterator aIter;
912 : 0 : aIter = findPolygons(xDrawPage);
913 : :
914 : : const SlideSharedPtr pSlide( createSlide(xDrawPage,
915 : : xDrawPages,
916 : : xRootNode,
917 : : maEventQueue,
918 : : maEventMultiplexer,
919 : : maScreenUpdater,
920 : : maActivitiesQueue,
921 : : maUserEventQueue,
922 : : *this,
923 : : maViewContainer,
924 : : mxComponentContext,
925 : : maShapeEventListeners,
926 : : maShapeCursors,
927 : 0 : (aIter != maPolygons.end()) ? aIter->second : PolyPolygonVector(),
928 : 0 : maUserPaintColor ? *maUserPaintColor : RGBColor(),
929 : : maUserPaintStrokeWidth,
930 : 0 : !!maUserPaintColor,
931 : : mbImageAnimationsAllowed,
932 : 0 : mbDisableAnimationZOrder) );
933 : :
934 : : // prefetch show content (reducing latency for slide
935 : : // bitmap and effect start later on)
936 : 0 : pSlide->prefetch();
937 : :
938 : 0 : return pSlide;
939 : : }
940 : :
941 : 0 : void SlideShowImpl::requestWaitSymbol (void)
942 : : {
943 : 0 : ++mnWaitSymbolRequestCount;
944 : : OSL_ASSERT(mnWaitSymbolRequestCount>0);
945 : :
946 : 0 : if (mnWaitSymbolRequestCount == 1)
947 : : {
948 : 0 : if( !mpWaitSymbol )
949 : : {
950 : : // fall back to cursor
951 : 0 : requestCursor(calcActiveCursor(mnCurrentCursor));
952 : : }
953 : : else
954 : 0 : mpWaitSymbol->show();
955 : : }
956 : 0 : }
957 : :
958 : 0 : void SlideShowImpl::releaseWaitSymbol (void)
959 : : {
960 : 0 : --mnWaitSymbolRequestCount;
961 : : OSL_ASSERT(mnWaitSymbolRequestCount>=0);
962 : :
963 : 0 : if (mnWaitSymbolRequestCount == 0)
964 : : {
965 : 0 : if( !mpWaitSymbol )
966 : : {
967 : : // fall back to cursor
968 : 0 : requestCursor(calcActiveCursor(mnCurrentCursor));
969 : : }
970 : : else
971 : 0 : mpWaitSymbol->hide();
972 : : }
973 : 0 : }
974 : :
975 : 0 : sal_Int16 SlideShowImpl::calcActiveCursor( sal_Int16 nCursorShape ) const
976 : : {
977 : 0 : if( mnWaitSymbolRequestCount>0 && !mpWaitSymbol ) // enforce wait cursor
978 : 0 : nCursorShape = awt::SystemPointer::WAIT;
979 : 0 : else if( !mbMouseVisible ) // enforce INVISIBLE
980 : 0 : nCursorShape = awt::SystemPointer::INVISIBLE;
981 : 0 : else if( maUserPaintColor &&
982 : 0 : nCursorShape == awt::SystemPointer::ARROW )
983 : 0 : nCursorShape = awt::SystemPointer::PEN;
984 : :
985 : 0 : return nCursorShape;
986 : : }
987 : :
988 : 0 : void SlideShowImpl::stopShow()
989 : : {
990 : : // Force-end running animation
991 : : // ===========================
992 : 0 : if (mpCurrentSlide)
993 : : {
994 : 0 : mpCurrentSlide->hide();
995 : : //Register polygons in the map
996 : 0 : if(findPolygons(mpCurrentSlide->getXDrawPage()) != maPolygons.end())
997 : 0 : maPolygons.erase(mpCurrentSlide->getXDrawPage());
998 : :
999 : 0 : maPolygons.insert(make_pair(mpCurrentSlide->getXDrawPage(),mpCurrentSlide->getPolygons()));
1000 : : }
1001 : :
1002 : : // clear all queues
1003 : 0 : maEventQueue.clear();
1004 : 0 : maActivitiesQueue.clear();
1005 : :
1006 : : // Attention: we MUST clear the user event queue here,
1007 : : // this is because the current slide might have registered
1008 : : // shape events (click or enter/leave), which might
1009 : : // otherwise dangle forever in the queue (because of the
1010 : : // shared ptr nature). If someone needs to change this:
1011 : : // somehow unregister those shapes at the user event queue
1012 : : // on notifySlideEnded().
1013 : 0 : maUserEventQueue.clear();
1014 : :
1015 : : // re-enable automatic effect advancement
1016 : : // (maEventQueue.clear() above might have killed
1017 : : // maEventMultiplexer's tick events)
1018 : 0 : if (mbAutomaticAdvancementMode)
1019 : : {
1020 : : // toggle automatic mode (enabling just again is
1021 : : // ignored by EventMultiplexer)
1022 : 0 : maEventMultiplexer.setAutomaticMode( false );
1023 : 0 : maEventMultiplexer.setAutomaticMode( true );
1024 : : }
1025 : 0 : }
1026 : :
1027 : : class SlideShowImpl::PrefetchPropertiesFunc
1028 : : {
1029 : : public:
1030 : 0 : PrefetchPropertiesFunc( SlideShowImpl * that_,
1031 : : bool& rbSkipAllMainSequenceEffects,
1032 : : bool& rbSkipSlideTransition)
1033 : : : mpSlideShowImpl(that_),
1034 : : mrbSkipAllMainSequenceEffects(rbSkipAllMainSequenceEffects),
1035 : 0 : mrbSkipSlideTransition(rbSkipSlideTransition)
1036 : 0 : {}
1037 : :
1038 : 0 : void operator()( beans::PropertyValue const& rProperty ) const {
1039 : 0 : if (rProperty.Name == "Prefetch" )
1040 : : {
1041 : 0 : uno::Sequence<uno::Any> seq;
1042 : 0 : if ((rProperty.Value >>= seq) && seq.getLength() == 2)
1043 : : {
1044 : 0 : seq[0] >>= mpSlideShowImpl->mxPrefetchSlide;
1045 : 0 : seq[1] >>= mpSlideShowImpl->mxPrefetchAnimationNode;
1046 : 0 : }
1047 : : }
1048 : 0 : else if ( rProperty.Name == "SkipAllMainSequenceEffects" )
1049 : : {
1050 : 0 : rProperty.Value >>= mrbSkipAllMainSequenceEffects;
1051 : : }
1052 : 0 : else if ( rProperty.Name == "SkipSlideTransition" )
1053 : : {
1054 : 0 : rProperty.Value >>= mrbSkipSlideTransition;
1055 : : }
1056 : : else
1057 : : {
1058 : : OSL_FAIL( rtl::OUStringToOString(
1059 : : rProperty.Name, RTL_TEXTENCODING_UTF8 ).getStr() );
1060 : : }
1061 : 0 : }
1062 : : private:
1063 : : SlideShowImpl *const mpSlideShowImpl;
1064 : : bool& mrbSkipAllMainSequenceEffects;
1065 : : bool& mrbSkipSlideTransition;
1066 : : };
1067 : :
1068 : 0 : void SlideShowImpl::displaySlide(
1069 : : uno::Reference<drawing::XDrawPage> const& xSlide,
1070 : : uno::Reference<drawing::XDrawPagesSupplier> const& xDrawPages,
1071 : : uno::Reference<animations::XAnimationNode> const& xRootNode,
1072 : : uno::Sequence<beans::PropertyValue> const& rProperties )
1073 : : throw (uno::RuntimeException)
1074 : : {
1075 : 0 : osl::MutexGuard const guard( m_aMutex );
1076 : :
1077 : 0 : if (isDisposed())
1078 : : return;
1079 : :
1080 : 0 : maEffectRewinder.setRootAnimationNode(xRootNode);
1081 : :
1082 : : // precondition: must only be called from the main thread!
1083 : : DBG_TESTSOLARMUTEX();
1084 : :
1085 : 0 : mxDrawPagesSupplier = xDrawPages;
1086 : :
1087 : 0 : stopShow(); // MUST call that: results in
1088 : : // maUserEventQueue.clear(). What's more,
1089 : : // stopShow()'s currSlide->hide() call is
1090 : : // now also required, notifySlideEnded()
1091 : : // relies on that
1092 : : // unconditionally. Otherwise, genuine
1093 : : // shape animations (drawing layer and
1094 : : // GIF) will not be stopped.
1095 : :
1096 : 0 : bool bSkipAllMainSequenceEffects (false);
1097 : 0 : bool bSkipSlideTransition (false);
1098 : : std::for_each( rProperties.getConstArray(),
1099 : 0 : rProperties.getConstArray() + rProperties.getLength(),
1100 : 0 : PrefetchPropertiesFunc(this, bSkipAllMainSequenceEffects, bSkipSlideTransition) );
1101 : :
1102 : : OSL_ENSURE( !maViewContainer.empty(), "### no views!" );
1103 : 0 : if (maViewContainer.empty())
1104 : : return;
1105 : :
1106 : : // this here might take some time
1107 : : {
1108 : 0 : WaitSymbolLock aLock (*this);
1109 : :
1110 : 0 : mpPreviousSlide = mpCurrentSlide;
1111 : 0 : mpCurrentSlide.reset();
1112 : :
1113 : 0 : if (matches( mpPrefetchSlide, xSlide, xRootNode ))
1114 : : {
1115 : : // prefetched slide matches:
1116 : 0 : mpCurrentSlide = mpPrefetchSlide;
1117 : : }
1118 : : else
1119 : 0 : mpCurrentSlide = makeSlide( xSlide, xDrawPages, xRootNode );
1120 : :
1121 : : OSL_ASSERT( mpCurrentSlide );
1122 : 0 : if (mpCurrentSlide)
1123 : : {
1124 : 0 : basegfx::B2DSize oldSlideSize;
1125 : 0 : if( mpPreviousSlide )
1126 : 0 : oldSlideSize = basegfx::B2DSize( mpPreviousSlide->getSlideSize() );
1127 : :
1128 : 0 : basegfx::B2DSize const slideSize( mpCurrentSlide->getSlideSize() );
1129 : :
1130 : : // push new transformation to all views, if size changed
1131 : 0 : if( !mpPreviousSlide || oldSlideSize != slideSize )
1132 : : {
1133 : : std::for_each( maViewContainer.begin(),
1134 : : maViewContainer.end(),
1135 : : boost::bind( &View::setViewSize, _1,
1136 : 0 : boost::cref(slideSize) ));
1137 : :
1138 : : // explicitly notify view change here,
1139 : : // because transformation might have changed:
1140 : : // optimization, this->notifyViewChange() would
1141 : : // repaint slide which is not necessary.
1142 : 0 : maEventMultiplexer.notifyViewsChanged();
1143 : : }
1144 : :
1145 : : // create slide transition, and add proper end event
1146 : : // (which then starts the slide effects
1147 : : // via CURRENT_SLIDE.show())
1148 : : ActivitySharedPtr pSlideChangeActivity (
1149 : : createSlideTransition(
1150 : 0 : mpCurrentSlide->getXDrawPage(),
1151 : : mpPreviousSlide,
1152 : : mpCurrentSlide,
1153 : 0 : makeEvent(
1154 : : boost::bind(
1155 : : &SlideShowImpl::notifySlideTransitionEnded,
1156 : : this,
1157 : : false ),
1158 : 0 : "SlideShowImpl::notifySlideTransitionEnded")));
1159 : :
1160 : 0 : if (bSkipSlideTransition)
1161 : : {
1162 : : // The transition activity was created for the side effects
1163 : : // (like sound transitions). Because we want to skip the
1164 : : // acutual transition animation we do not need the activity
1165 : : // anymore.
1166 : 0 : pSlideChangeActivity.reset();
1167 : : }
1168 : :
1169 : 0 : if (pSlideChangeActivity)
1170 : : {
1171 : : // factory generated a slide transition - activate it!
1172 : 0 : maActivitiesQueue.addActivity( pSlideChangeActivity );
1173 : : }
1174 : : else
1175 : : {
1176 : : // no transition effect on this slide - schedule slide
1177 : : // effect start event right away.
1178 : : maEventQueue.addEvent(
1179 : 0 : makeEvent(
1180 : : boost::bind(
1181 : : &SlideShowImpl::notifySlideTransitionEnded,
1182 : : this,
1183 : : true ),
1184 : 0 : "SlideShowImpl::notifySlideTransitionEnded"));
1185 : 0 : }
1186 : 0 : }
1187 : : } // finally
1188 : :
1189 : 0 : maEventMultiplexer.notifySlideTransitionStarted();
1190 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
1191 : 0 : boost::mem_fn( &presentation::XSlideShowListener::slideTransitionStarted ) );
1192 : :
1193 : : // We are currently rewinding an effect. This lead us from the next
1194 : : // slide to this one. To complete this we have to play back all main
1195 : : // sequence effects on this slide.
1196 : 0 : if (bSkipAllMainSequenceEffects)
1197 : 0 : maEffectRewinder.skipAllMainSequenceEffects();
1198 : : }
1199 : :
1200 : 0 : void SlideShowImpl::redisplayCurrentSlide (void)
1201 : : {
1202 : 0 : osl::MutexGuard const guard( m_aMutex );
1203 : :
1204 : 0 : if (isDisposed())
1205 : : return;
1206 : :
1207 : : // precondition: must only be called from the main thread!
1208 : : DBG_TESTSOLARMUTEX();
1209 : 0 : stopShow();
1210 : :
1211 : : OSL_ENSURE( !maViewContainer.empty(), "### no views!" );
1212 : 0 : if (maViewContainer.empty())
1213 : : return;
1214 : :
1215 : : // No transition effect on this slide - schedule slide
1216 : : // effect start event right away.
1217 : : maEventQueue.addEvent(
1218 : 0 : makeEvent(
1219 : : boost::bind(
1220 : : &SlideShowImpl::notifySlideTransitionEnded,
1221 : : this,
1222 : : true ),
1223 : 0 : "SlideShowImpl::notifySlideTransitionEnded"));
1224 : :
1225 : 0 : maEventMultiplexer.notifySlideTransitionStarted();
1226 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
1227 : 0 : boost::mem_fn( &presentation::XSlideShowListener::slideTransitionStarted ) );
1228 : : }
1229 : :
1230 : 0 : sal_Bool SlideShowImpl::nextEffect() throw (uno::RuntimeException)
1231 : : {
1232 : 0 : osl::MutexGuard const guard( m_aMutex );
1233 : :
1234 : 0 : if (isDisposed())
1235 : 0 : return false;
1236 : :
1237 : : // precondition: must only be called from the main thread!
1238 : : DBG_TESTSOLARMUTEX();
1239 : :
1240 : 0 : if (mbShowPaused)
1241 : 0 : return true;
1242 : : else
1243 : 0 : return maEventMultiplexer.notifyNextEffect();
1244 : : }
1245 : :
1246 : 0 : sal_Bool SlideShowImpl::previousEffect() throw (uno::RuntimeException)
1247 : : {
1248 : 0 : osl::MutexGuard const guard( m_aMutex );
1249 : :
1250 : 0 : if (isDisposed())
1251 : 0 : return false;
1252 : :
1253 : : // precondition: must only be called from the main thread!
1254 : : DBG_TESTSOLARMUTEX();
1255 : :
1256 : 0 : if (mbShowPaused)
1257 : 0 : return true;
1258 : : else
1259 : : {
1260 : : return maEffectRewinder.rewind(
1261 : : maScreenUpdater.createLock(false),
1262 : : ::boost::bind<void>(::boost::mem_fn(&SlideShowImpl::redisplayCurrentSlide), this),
1263 : 0 : ::boost::bind<void>(::boost::mem_fn(&SlideShowImpl::rewindEffectToPreviousSlide), this));
1264 : 0 : }
1265 : : }
1266 : :
1267 : 0 : void SlideShowImpl::rewindEffectToPreviousSlide (void)
1268 : : {
1269 : : // Show the wait symbol now and prevent it from showing temporary slide
1270 : : // content while effects are played back.
1271 : 0 : WaitSymbolLock aLock (*this);
1272 : :
1273 : : // A previous call to EffectRewinder::Rewind could not rewind the current
1274 : : // effect because there are no effects on the current slide or none has
1275 : : // yet been displayed. Go to the previous slide.
1276 : 0 : notifySlideEnded(true);
1277 : :
1278 : : // Process pending events once more in order to have the following
1279 : : // screen update show the last effect. Not sure whether this should be
1280 : : // necessary.
1281 : 0 : maEventQueue.forceEmpty();
1282 : :
1283 : : // We have to call the screen updater before the wait symbol is turned
1284 : : // off. Otherwise the wait symbol would force the display of an
1285 : : // intermediate state of the slide (before the effects are replayed.)
1286 : 0 : maScreenUpdater.commitUpdates();
1287 : 0 : }
1288 : :
1289 : 0 : sal_Bool SlideShowImpl::startShapeActivity(
1290 : : uno::Reference<drawing::XShape> const& /*xShape*/ )
1291 : : throw (uno::RuntimeException)
1292 : : {
1293 : 0 : osl::MutexGuard const guard( m_aMutex );
1294 : :
1295 : : // precondition: must only be called from the main thread!
1296 : : DBG_TESTSOLARMUTEX();
1297 : :
1298 : : // TODO(F3): NYI
1299 : : OSL_FAIL( "not yet implemented!" );
1300 : 0 : return false;
1301 : : }
1302 : :
1303 : 0 : sal_Bool SlideShowImpl::stopShapeActivity(
1304 : : uno::Reference<drawing::XShape> const& /*xShape*/ )
1305 : : throw (uno::RuntimeException)
1306 : : {
1307 : 0 : osl::MutexGuard const guard( m_aMutex );
1308 : :
1309 : : // precondition: must only be called from the main thread!
1310 : : DBG_TESTSOLARMUTEX();
1311 : :
1312 : : // TODO(F3): NYI
1313 : : OSL_FAIL( "not yet implemented!" );
1314 : 0 : return false;
1315 : : }
1316 : :
1317 : 0 : sal_Bool SlideShowImpl::pause( sal_Bool bPauseShow )
1318 : : throw (uno::RuntimeException)
1319 : : {
1320 : 0 : osl::MutexGuard const guard( m_aMutex );
1321 : :
1322 : 0 : if (isDisposed())
1323 : 0 : return false;
1324 : :
1325 : : // precondition: must only be called from the main thread!
1326 : : DBG_TESTSOLARMUTEX();
1327 : :
1328 : 0 : if (bPauseShow)
1329 : 0 : mpPresTimer->pauseTimer();
1330 : : else
1331 : 0 : mpPresTimer->continueTimer();
1332 : :
1333 : 0 : maEventMultiplexer.notifyPauseMode(bPauseShow);
1334 : :
1335 : 0 : mbShowPaused = bPauseShow;
1336 : 0 : return true;
1337 : : }
1338 : :
1339 : 0 : uno::Reference<drawing::XDrawPage> SlideShowImpl::getCurrentSlide()
1340 : : throw (uno::RuntimeException)
1341 : : {
1342 : 0 : osl::MutexGuard const guard( m_aMutex );
1343 : :
1344 : 0 : if (isDisposed())
1345 : 0 : return uno::Reference<drawing::XDrawPage>();
1346 : :
1347 : : // precondition: must only be called from the main thread!
1348 : : DBG_TESTSOLARMUTEX();
1349 : :
1350 : 0 : if (mpCurrentSlide)
1351 : 0 : return mpCurrentSlide->getXDrawPage();
1352 : : else
1353 : 0 : return uno::Reference<drawing::XDrawPage>();
1354 : : }
1355 : :
1356 : 0 : sal_Bool SlideShowImpl::addView(
1357 : : uno::Reference<presentation::XSlideShowView> const& xView )
1358 : : throw (uno::RuntimeException)
1359 : : {
1360 : 0 : osl::MutexGuard const guard( m_aMutex );
1361 : :
1362 : 0 : if (isDisposed())
1363 : 0 : return false;
1364 : :
1365 : : // precondition: must only be called from the main thread!
1366 : : DBG_TESTSOLARMUTEX();
1367 : :
1368 : : // first of all, check if view has a valid canvas
1369 : 0 : ENSURE_OR_RETURN_FALSE( xView.is(), "addView(): Invalid view" );
1370 : 0 : ENSURE_OR_RETURN_FALSE( xView->getCanvas().is(),
1371 : : "addView(): View does not provide a valid canvas" );
1372 : :
1373 : : UnoViewSharedPtr const pView( createSlideView(
1374 : : xView,
1375 : : maEventQueue,
1376 : 0 : maEventMultiplexer ));
1377 : 0 : if (!maViewContainer.addView( pView ))
1378 : 0 : return false; // view already added
1379 : :
1380 : : // initialize view content
1381 : : // =======================
1382 : :
1383 : 0 : if (mpCurrentSlide)
1384 : : {
1385 : : // set view transformation
1386 : 0 : const basegfx::B2ISize slideSize = mpCurrentSlide->getSlideSize();
1387 : 0 : pView->setViewSize( basegfx::B2DSize( slideSize.getX(),
1388 : 0 : slideSize.getY() ) );
1389 : : }
1390 : :
1391 : : // clear view area (since its newly added,
1392 : : // we need a clean slate)
1393 : 0 : pView->clearAll();
1394 : :
1395 : : // broadcast newly added view
1396 : 0 : maEventMultiplexer.notifyViewAdded( pView );
1397 : :
1398 : : // set current mouse ptr
1399 : 0 : pView->setCursorShape( calcActiveCursor(mnCurrentCursor) );
1400 : :
1401 : 0 : return true;
1402 : : }
1403 : :
1404 : 0 : sal_Bool SlideShowImpl::removeView(
1405 : : uno::Reference<presentation::XSlideShowView> const& xView )
1406 : : throw (uno::RuntimeException)
1407 : : {
1408 : 0 : osl::MutexGuard const guard( m_aMutex );
1409 : :
1410 : : // precondition: must only be called from the main thread!
1411 : : DBG_TESTSOLARMUTEX();
1412 : :
1413 : 0 : ENSURE_OR_RETURN_FALSE( xView.is(), "removeView(): Invalid view" );
1414 : :
1415 : 0 : UnoViewSharedPtr const pView( maViewContainer.removeView( xView ) );
1416 : 0 : if( !pView )
1417 : 0 : return false; // view was not added in the first place
1418 : :
1419 : : // remove view from EventMultiplexer (mouse events etc.)
1420 : 0 : maEventMultiplexer.notifyViewRemoved( pView );
1421 : :
1422 : 0 : pView->_dispose();
1423 : :
1424 : 0 : return true;
1425 : : }
1426 : :
1427 : 0 : void SlideShowImpl::registerUserPaintPolygons( const uno::Reference< lang::XMultiServiceFactory >& xDocFactory ) throw (uno::RuntimeException)
1428 : : {
1429 : : //Retrieve Polygons if user ends presentation by context menu
1430 : 0 : if (mpCurrentSlide)
1431 : : {
1432 : 0 : if(findPolygons(mpCurrentSlide->getXDrawPage()) != maPolygons.end())
1433 : 0 : maPolygons.erase(mpCurrentSlide->getXDrawPage());
1434 : :
1435 : 0 : maPolygons.insert(make_pair(mpCurrentSlide->getXDrawPage(),mpCurrentSlide->getPolygons()));
1436 : : }
1437 : :
1438 : : //Creating the layer for shapes
1439 : : // query for the XLayerManager
1440 : 0 : uno::Reference< drawing::XLayerSupplier > xLayerSupplier(xDocFactory, uno::UNO_QUERY);
1441 : 0 : uno::Reference< container::XNameAccess > xNameAccess = xLayerSupplier->getLayerManager();
1442 : :
1443 : 0 : uno::Reference< drawing::XLayerManager > xLayerManager(xNameAccess, uno::UNO_QUERY);
1444 : : // create a layer and set its properties
1445 : 0 : uno::Reference< drawing::XLayer > xDrawnInSlideshow = xLayerManager->insertNewByIndex(xLayerManager->getCount());
1446 : 0 : uno::Reference< beans::XPropertySet > xLayerPropSet(xDrawnInSlideshow, uno::UNO_QUERY);
1447 : :
1448 : : //Layer Name which enables to catch annotations
1449 : 0 : rtl::OUString layerName = rtl::OUString("DrawnInSlideshow");
1450 : 0 : uno::Any aPropLayer;
1451 : :
1452 : 0 : aPropLayer <<= layerName;
1453 : 0 : xLayerPropSet->setPropertyValue(rtl::OUString("Name"), aPropLayer);
1454 : :
1455 : 0 : aPropLayer <<= true;
1456 : 0 : xLayerPropSet->setPropertyValue(rtl::OUString("IsVisible"), aPropLayer);
1457 : :
1458 : 0 : aPropLayer <<= false;
1459 : 0 : xLayerPropSet->setPropertyValue(rtl::OUString("IsLocked"), aPropLayer);
1460 : :
1461 : 0 : PolygonMap::iterator aIter=maPolygons.begin();
1462 : :
1463 : 0 : PolyPolygonVector aPolygons;
1464 : 0 : ::cppcanvas::PolyPolygonSharedPtr pPolyPoly;
1465 : 0 : ::basegfx::B2DPolyPolygon b2DPolyPoly;
1466 : :
1467 : : //Register polygons for each slide
1468 : 0 : while(aIter!=maPolygons.end())
1469 : : {
1470 : 0 : aPolygons = aIter->second;
1471 : : //Get shapes for the slide
1472 : 0 : ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShapes > Shapes(aIter->first, ::com::sun::star::uno::UNO_QUERY);
1473 : : //Retrieve polygons for one slide
1474 : 0 : for( PolyPolygonVector::iterator aIterPoly=aPolygons.begin(),
1475 : 0 : aEnd=aPolygons.end();
1476 : : aIterPoly!=aEnd; ++aIterPoly )
1477 : : {
1478 : 0 : pPolyPoly = (*aIterPoly);
1479 : 0 : b2DPolyPoly = ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(pPolyPoly->getUNOPolyPolygon());
1480 : :
1481 : : //Normally there is only one polygon
1482 : 0 : for(sal_uInt32 i=0; i< b2DPolyPoly.count();i++)
1483 : : {
1484 : 0 : const ::basegfx::B2DPolygon& aPoly = b2DPolyPoly.getB2DPolygon(i);
1485 : 0 : sal_uInt32 nPoints = aPoly.count();
1486 : :
1487 : 0 : if( nPoints > 1)
1488 : : {
1489 : : //create the PolyLineShape
1490 : 0 : uno::Reference< uno::XInterface > polyshape(xDocFactory->createInstance(
1491 : 0 : rtl::OUString("com.sun.star.drawing.PolyLineShape") ) );
1492 : 0 : uno::Reference< drawing::XShape > rPolyShape(polyshape, uno::UNO_QUERY);
1493 : :
1494 : : //Add the shape to the slide
1495 : 0 : Shapes->add(rPolyShape);
1496 : :
1497 : : //Retrieve shape properties
1498 : 0 : uno::Reference< beans::XPropertySet > aXPropSet = uno::Reference< beans::XPropertySet >( rPolyShape, uno::UNO_QUERY );
1499 : : //Construct a sequence of points sequence
1500 : 0 : drawing::PointSequenceSequence aRetval;
1501 : : //Create only one sequence for one polygon
1502 : 0 : aRetval.realloc( 1 );
1503 : : // Retrieve the sequence of points from aRetval
1504 : 0 : drawing::PointSequence* pOuterSequence = aRetval.getArray();
1505 : : // Create 2 points in this sequence
1506 : 0 : pOuterSequence->realloc(nPoints);
1507 : : // Get these points which are in an array
1508 : 0 : awt::Point* pInnerSequence = pOuterSequence->getArray();
1509 : 0 : for( sal_uInt32 n = 0; n < nPoints; n++ )
1510 : : {
1511 : : //Create a point from the polygon
1512 : : *pInnerSequence++ = awt::Point(
1513 : 0 : basegfx::fround(aPoly.getB2DPoint(n).getX()),
1514 : 0 : basegfx::fround(aPoly.getB2DPoint(n).getY()));
1515 : : }
1516 : :
1517 : : //Fill the properties
1518 : : //Give the built PointSequenceSequence.
1519 : 0 : uno::Any aParam;
1520 : 0 : aParam <<= aRetval;
1521 : 0 : aXPropSet->setPropertyValue( rtl::OUString("PolyPolygon"), aParam );
1522 : :
1523 : : //LineStyle : SOLID by default
1524 : 0 : uno::Any aAny;
1525 : : drawing::LineStyle eLS;
1526 : 0 : eLS = drawing::LineStyle_SOLID;
1527 : 0 : aAny <<= eLS;
1528 : 0 : aXPropSet->setPropertyValue( rtl::OUString("LineStyle"), aAny );
1529 : :
1530 : : //LineColor
1531 : : sal_uInt32 nLineColor;
1532 : 0 : nLineColor = pPolyPoly->getRGBALineColor();
1533 : : //Transform polygon color from RRGGBBAA to AARRGGBB
1534 : 0 : aAny <<= RGBAColor2UnoColor(nLineColor);
1535 : 0 : aXPropSet->setPropertyValue( rtl::OUString("LineColor"), aAny );
1536 : :
1537 : : //LineWidth
1538 : : double fLineWidth;
1539 : 0 : fLineWidth = pPolyPoly->getStrokeWidth();
1540 : 0 : aAny <<= (sal_Int32)fLineWidth;
1541 : 0 : aXPropSet->setPropertyValue( rtl::OUString("LineWidth"), aAny );
1542 : :
1543 : : // make polygons special
1544 : 0 : xLayerManager->attachShapeToLayer(rPolyShape, xDrawnInSlideshow);
1545 : : }
1546 : 0 : }
1547 : : }
1548 : 0 : ++aIter;
1549 : 0 : }
1550 : 0 : }
1551 : :
1552 : 0 : sal_Bool SlideShowImpl::setProperty( beans::PropertyValue const& rProperty )
1553 : : throw (uno::RuntimeException)
1554 : : {
1555 : 0 : osl::MutexGuard const guard( m_aMutex );
1556 : :
1557 : 0 : if (isDisposed())
1558 : 0 : return false;
1559 : :
1560 : : // precondition: must only be called from the main thread!
1561 : : DBG_TESTSOLARMUTEX();
1562 : :
1563 : 0 : if ( rProperty.Name == "AutomaticAdvancement" )
1564 : : {
1565 : 0 : double nTimeout(0.0);
1566 : 0 : mbAutomaticAdvancementMode = (rProperty.Value >>= nTimeout);
1567 : 0 : if (mbAutomaticAdvancementMode)
1568 : : {
1569 : 0 : maEventMultiplexer.setAutomaticTimeout( nTimeout );
1570 : : }
1571 : 0 : maEventMultiplexer.setAutomaticMode( mbAutomaticAdvancementMode );
1572 : 0 : return true;
1573 : : }
1574 : :
1575 : 0 : if ( rProperty.Name == "UserPaintColor" )
1576 : : {
1577 : 0 : sal_Int32 nColor(0);
1578 : 0 : if (rProperty.Value >>= nColor)
1579 : : {
1580 : : OSL_ENSURE( mbMouseVisible,
1581 : : "setProperty(): User paint overrides invisible mouse" );
1582 : :
1583 : : // enable user paint
1584 : 0 : maUserPaintColor.reset( unoColor2RGBColor( nColor ) );
1585 : 0 : if( mpCurrentSlide && !mpCurrentSlide->isPaintOverlayActive() )
1586 : 0 : mpCurrentSlide->enablePaintOverlay();
1587 : :
1588 : 0 : maEventMultiplexer.notifyUserPaintColor( *maUserPaintColor );
1589 : : }
1590 : : else
1591 : : {
1592 : : // disable user paint
1593 : 0 : maUserPaintColor.reset();
1594 : 0 : maEventMultiplexer.notifyUserPaintDisabled();
1595 : 0 : if( mpCurrentSlide )
1596 : 0 : mpCurrentSlide->disablePaintOverlay();
1597 : : }
1598 : :
1599 : 0 : resetCursor();
1600 : :
1601 : 0 : return true;
1602 : : }
1603 : :
1604 : : //adding support for erasing features in UserPaintOverlay
1605 : 0 : if ( rProperty.Name == "EraseAllInk" )
1606 : : {
1607 : 0 : bool nEraseAllInk(false);
1608 : 0 : if (rProperty.Value >>= nEraseAllInk)
1609 : : {
1610 : : OSL_ENSURE( mbMouseVisible,
1611 : : "setProperty(): User paint overrides invisible mouse" );
1612 : :
1613 : : // enable user paint
1614 : 0 : maEraseAllInk.reset( nEraseAllInk );
1615 : 0 : maEventMultiplexer.notifyEraseAllInk( *maEraseAllInk );
1616 : : }
1617 : :
1618 : 0 : return true;
1619 : : }
1620 : :
1621 : 0 : if ( rProperty.Name == "SwitchPenMode" )
1622 : : {
1623 : 0 : bool nSwitchPenMode(false);
1624 : 0 : if (rProperty.Value >>= nSwitchPenMode)
1625 : : {
1626 : : OSL_ENSURE( mbMouseVisible,
1627 : : "setProperty(): User paint overrides invisible mouse" );
1628 : :
1629 : 0 : if(nSwitchPenMode == true){
1630 : : // Switch to Pen Mode
1631 : 0 : maSwitchPenMode.reset( nSwitchPenMode );
1632 : 0 : maEventMultiplexer.notifySwitchPenMode();
1633 : : }
1634 : : }
1635 : 0 : return true;
1636 : : }
1637 : :
1638 : 0 : if ( rProperty.Name == "SwitchEraserMode" )
1639 : : {
1640 : 0 : bool nSwitchEraserMode(false);
1641 : 0 : if (rProperty.Value >>= nSwitchEraserMode)
1642 : : {
1643 : : OSL_ENSURE( mbMouseVisible,
1644 : : "setProperty(): User paint overrides invisible mouse" );
1645 : 0 : if(nSwitchEraserMode == true){
1646 : : // switch to Eraser mode
1647 : 0 : maSwitchEraserMode.reset( nSwitchEraserMode );
1648 : 0 : maEventMultiplexer.notifySwitchEraserMode();
1649 : : }
1650 : : }
1651 : :
1652 : 0 : return true;
1653 : : }
1654 : :
1655 : 0 : if ( rProperty.Name == "EraseInk" )
1656 : : {
1657 : 0 : sal_Int32 nEraseInk(100);
1658 : 0 : if (rProperty.Value >>= nEraseInk)
1659 : : {
1660 : : OSL_ENSURE( mbMouseVisible,
1661 : : "setProperty(): User paint overrides invisible mouse" );
1662 : :
1663 : : // enable user paint
1664 : 0 : maEraseInk.reset( nEraseInk );
1665 : 0 : maEventMultiplexer.notifyEraseInkWidth( *maEraseInk );
1666 : : }
1667 : :
1668 : 0 : return true;
1669 : : }
1670 : :
1671 : : // new Property for pen's width
1672 : 0 : if ( rProperty.Name == "UserPaintStrokeWidth" )
1673 : : {
1674 : 0 : double nWidth(4.0);
1675 : 0 : if (rProperty.Value >>= nWidth)
1676 : : {
1677 : : OSL_ENSURE( mbMouseVisible,"setProperty(): User paint overrides invisible mouse" );
1678 : : // enable user paint stroke width
1679 : 0 : maUserPaintStrokeWidth = nWidth;
1680 : 0 : maEventMultiplexer.notifyUserPaintStrokeWidth( maUserPaintStrokeWidth );
1681 : : }
1682 : :
1683 : 0 : return true;
1684 : : }
1685 : :
1686 : 0 : if ( rProperty.Name == "AdvanceOnClick" )
1687 : : {
1688 : 0 : sal_Bool bAdvanceOnClick = sal_False;
1689 : 0 : if (! (rProperty.Value >>= bAdvanceOnClick))
1690 : 0 : return false;
1691 : 0 : maUserEventQueue.setAdvanceOnClick( bAdvanceOnClick );
1692 : 0 : return true;
1693 : : }
1694 : :
1695 : 0 : if ( rProperty.Name == "DisableAnimationZOrder" )
1696 : : {
1697 : 0 : sal_Bool bDisableAnimationZOrder = sal_False;
1698 : 0 : if (! (rProperty.Value >>= bDisableAnimationZOrder))
1699 : 0 : return false;
1700 : 0 : mbDisableAnimationZOrder = bDisableAnimationZOrder == sal_True;
1701 : 0 : return true;
1702 : : }
1703 : :
1704 : 0 : if ( rProperty.Name == "ImageAnimationsAllowed" )
1705 : : {
1706 : 0 : if (! (rProperty.Value >>= mbImageAnimationsAllowed))
1707 : 0 : return false;
1708 : :
1709 : : // TODO(F3): Forward to slides!
1710 : : // if( bOldValue != mbImageAnimationsAllowed )
1711 : : // {
1712 : : // if( mbImageAnimationsAllowed )
1713 : : // maEventMultiplexer.notifyIntrinsicAnimationsEnabled();
1714 : : // else
1715 : : // maEventMultiplexer.notifyIntrinsicAnimationsDisabled();
1716 : : // }
1717 : :
1718 : 0 : return true;
1719 : : }
1720 : :
1721 : 0 : if ( rProperty.Name == "MouseVisible" )
1722 : : {
1723 : 0 : if (! (rProperty.Value >>= mbMouseVisible))
1724 : 0 : return false;
1725 : :
1726 : 0 : requestCursor(mnCurrentCursor);
1727 : :
1728 : 0 : return true;
1729 : : }
1730 : :
1731 : 0 : if ( rProperty.Name == "ForceManualAdvance" )
1732 : : {
1733 : 0 : return (rProperty.Value >>= mbForceManualAdvance);
1734 : : }
1735 : :
1736 : 0 : if ( rProperty.Name == "RehearseTimings" )
1737 : : {
1738 : 0 : bool bRehearseTimings = false;
1739 : 0 : if (! (rProperty.Value >>= bRehearseTimings))
1740 : 0 : return false;
1741 : :
1742 : 0 : if (bRehearseTimings)
1743 : : {
1744 : : // TODO(Q3): Move to slide
1745 : : mpRehearseTimingsActivity = RehearseTimingsActivity::create(
1746 : : SlideShowContext(
1747 : : mpDummyPtr,
1748 : : maEventQueue,
1749 : : maEventMultiplexer,
1750 : : maScreenUpdater,
1751 : : maActivitiesQueue,
1752 : : maUserEventQueue,
1753 : : *this,
1754 : : maViewContainer,
1755 : 0 : mxComponentContext) );
1756 : : }
1757 : 0 : else if (mpRehearseTimingsActivity)
1758 : : {
1759 : : // removes timer from all views:
1760 : 0 : mpRehearseTimingsActivity->dispose();
1761 : 0 : mpRehearseTimingsActivity.reset();
1762 : : }
1763 : 0 : return true;
1764 : : }
1765 : :
1766 : 0 : if ( rProperty.Name == "WaitSymbolBitmap" )
1767 : : {
1768 : 0 : uno::Reference<rendering::XBitmap> xBitmap;
1769 : 0 : if (! (rProperty.Value >>= xBitmap))
1770 : 0 : return false;
1771 : :
1772 : : mpWaitSymbol = WaitSymbol::create( xBitmap,
1773 : : maScreenUpdater,
1774 : : maEventMultiplexer,
1775 : 0 : maViewContainer );
1776 : :
1777 : 0 : return true;
1778 : : }
1779 : :
1780 : 0 : if (rProperty.Name.equalsAsciiL(
1781 : 0 : RTL_CONSTASCII_STRINGPARAM("NoSlideTransitions") ))
1782 : : {
1783 : 0 : return (rProperty.Value >>= mbNoSlideTransitions);
1784 : : }
1785 : :
1786 : 0 : if ( rProperty.Name == "IsSoundEnabled" )
1787 : : {
1788 : 0 : uno::Sequence<uno::Any> aValues;
1789 : 0 : uno::Reference<presentation::XSlideShowView> xView;
1790 : 0 : sal_Bool bValue (false);
1791 : 0 : if ((rProperty.Value >>= aValues)
1792 : 0 : && aValues.getLength()==2
1793 : 0 : && (aValues[0] >>= xView)
1794 : 0 : && (aValues[1] >>= bValue))
1795 : : {
1796 : : // Look up the view.
1797 : 0 : for (UnoViewVector::const_iterator
1798 : 0 : iView (maViewContainer.begin()),
1799 : 0 : iEnd (maViewContainer.end());
1800 : : iView!=iEnd;
1801 : : ++iView)
1802 : : {
1803 : 0 : if (*iView && (*iView)->getUnoView()==xView)
1804 : : {
1805 : : // Store the flag at the view so that media shapes have
1806 : : // access to it.
1807 : 0 : (*iView)->setIsSoundEnabled(bValue);
1808 : 0 : return true;
1809 : : }
1810 : : }
1811 : 0 : }
1812 : : }
1813 : :
1814 : 0 : return false;
1815 : : }
1816 : :
1817 : 0 : void SlideShowImpl::addSlideShowListener(
1818 : : uno::Reference<presentation::XSlideShowListener> const& xListener )
1819 : : throw (uno::RuntimeException)
1820 : : {
1821 : 0 : osl::MutexGuard const guard( m_aMutex );
1822 : :
1823 : 0 : if (isDisposed())
1824 : 0 : return;
1825 : :
1826 : : // container syncs with passed mutex ref
1827 : 0 : maListenerContainer.addInterface(xListener);
1828 : : }
1829 : :
1830 : 0 : void SlideShowImpl::removeSlideShowListener(
1831 : : uno::Reference<presentation::XSlideShowListener> const& xListener )
1832 : : throw (uno::RuntimeException)
1833 : : {
1834 : 0 : osl::MutexGuard const guard( m_aMutex );
1835 : :
1836 : : // container syncs with passed mutex ref
1837 : 0 : maListenerContainer.removeInterface(xListener);
1838 : 0 : }
1839 : :
1840 : 0 : void SlideShowImpl::addShapeEventListener(
1841 : : uno::Reference<presentation::XShapeEventListener> const& xListener,
1842 : : uno::Reference<drawing::XShape> const& xShape )
1843 : : throw (uno::RuntimeException)
1844 : : {
1845 : 0 : osl::MutexGuard const guard( m_aMutex );
1846 : :
1847 : 0 : if (isDisposed())
1848 : 0 : return;
1849 : :
1850 : : // precondition: must only be called from the main thread!
1851 : : DBG_TESTSOLARMUTEX();
1852 : :
1853 : 0 : ShapeEventListenerMap::iterator aIter;
1854 : 0 : if( (aIter=maShapeEventListeners.find( xShape )) ==
1855 : 0 : maShapeEventListeners.end() )
1856 : : {
1857 : : // no entry for this shape -> create one
1858 : : aIter = maShapeEventListeners.insert(
1859 : : ShapeEventListenerMap::value_type(
1860 : : xShape,
1861 : : boost::shared_ptr<cppu::OInterfaceContainerHelper>(
1862 : 0 : new cppu::OInterfaceContainerHelper(m_aMutex)))).first;
1863 : : }
1864 : :
1865 : : // add new listener to broadcaster
1866 : 0 : if( aIter->second.get() )
1867 : 0 : aIter->second->addInterface( xListener );
1868 : :
1869 : : maEventMultiplexer.notifyShapeListenerAdded(xListener,
1870 : 0 : xShape);
1871 : : }
1872 : :
1873 : 0 : void SlideShowImpl::removeShapeEventListener(
1874 : : uno::Reference<presentation::XShapeEventListener> const& xListener,
1875 : : uno::Reference<drawing::XShape> const& xShape )
1876 : : throw (uno::RuntimeException)
1877 : : {
1878 : 0 : osl::MutexGuard const guard( m_aMutex );
1879 : :
1880 : : // precondition: must only be called from the main thread!
1881 : : DBG_TESTSOLARMUTEX();
1882 : :
1883 : 0 : ShapeEventListenerMap::iterator aIter;
1884 : 0 : if( (aIter = maShapeEventListeners.find( xShape )) !=
1885 : 0 : maShapeEventListeners.end() )
1886 : : {
1887 : : // entry for this shape found -> remove listener from
1888 : : // helper object
1889 : 0 : ENSURE_OR_THROW(
1890 : : aIter->second.get(),
1891 : : "SlideShowImpl::removeShapeEventListener(): "
1892 : : "listener map contains NULL broadcast helper" );
1893 : :
1894 : 0 : aIter->second->removeInterface( xListener );
1895 : : }
1896 : :
1897 : : maEventMultiplexer.notifyShapeListenerRemoved(xListener,
1898 : 0 : xShape);
1899 : 0 : }
1900 : :
1901 : 0 : void SlideShowImpl::setShapeCursor(
1902 : : uno::Reference<drawing::XShape> const& xShape, sal_Int16 nPointerShape )
1903 : : throw (uno::RuntimeException)
1904 : : {
1905 : 0 : osl::MutexGuard const guard( m_aMutex );
1906 : :
1907 : 0 : if (isDisposed())
1908 : 0 : return;
1909 : :
1910 : : // precondition: must only be called from the main thread!
1911 : : DBG_TESTSOLARMUTEX();
1912 : :
1913 : 0 : ShapeCursorMap::iterator aIter;
1914 : 0 : if( (aIter=maShapeCursors.find( xShape )) == maShapeCursors.end() )
1915 : : {
1916 : : // no entry for this shape -> create one
1917 : 0 : if( nPointerShape != awt::SystemPointer::ARROW )
1918 : : {
1919 : : // add new entry, unless shape shall display
1920 : : // normal pointer arrow -> no need to handle that
1921 : : // case
1922 : : maShapeCursors.insert(
1923 : : ShapeCursorMap::value_type(xShape,
1924 : 0 : nPointerShape) );
1925 : : }
1926 : : }
1927 : 0 : else if( nPointerShape == awt::SystemPointer::ARROW )
1928 : : {
1929 : : // shape shall display normal cursor -> can disable
1930 : : // the cursor and clear the entry
1931 : 0 : maShapeCursors.erase( xShape );
1932 : : }
1933 : : else
1934 : : {
1935 : : // existing entry found, update with new cursor ID
1936 : 0 : aIter->second = nPointerShape;
1937 : : }
1938 : :
1939 : : maEventMultiplexer.notifyShapeCursorChange(xShape,
1940 : 0 : nPointerShape);
1941 : : }
1942 : :
1943 : 0 : bool SlideShowImpl::requestCursor( sal_Int16 nCursorShape )
1944 : : {
1945 : 0 : mnCurrentCursor = nCursorShape;
1946 : :
1947 : 0 : const sal_Int16 nActualCursor = calcActiveCursor(mnCurrentCursor);
1948 : :
1949 : : // change all views to the requested cursor ID
1950 : : std::for_each( maViewContainer.begin(),
1951 : : maViewContainer.end(),
1952 : : boost::bind( &View::setCursorShape,
1953 : : _1,
1954 : 0 : nActualCursor ));
1955 : :
1956 : 0 : return nActualCursor==nCursorShape;
1957 : : }
1958 : :
1959 : 0 : void SlideShowImpl::resetCursor()
1960 : : {
1961 : 0 : mnCurrentCursor = awt::SystemPointer::ARROW;
1962 : :
1963 : : // change all views to the default cursor ID
1964 : : std::for_each( maViewContainer.begin(),
1965 : : maViewContainer.end(),
1966 : : boost::bind( &View::setCursorShape,
1967 : : _1,
1968 : 0 : calcActiveCursor(mnCurrentCursor) ));
1969 : 0 : }
1970 : :
1971 : 0 : sal_Bool SlideShowImpl::update( double & nNextTimeout )
1972 : : throw (uno::RuntimeException)
1973 : : {
1974 : 0 : osl::MutexGuard const guard( m_aMutex );
1975 : :
1976 : 0 : if (isDisposed())
1977 : 0 : return false;
1978 : :
1979 : : // precondition: update() must only be called from the
1980 : : // main thread!
1981 : : DBG_TESTSOLARMUTEX();
1982 : :
1983 : 0 : if( mbShowPaused )
1984 : : {
1985 : : // commit frame (might be repaints pending)
1986 : 0 : maScreenUpdater.commitUpdates();
1987 : :
1988 : 0 : return false;
1989 : : }
1990 : : else
1991 : : {
1992 : : // TODO(F2): re-evaluate whether that timer lagging makes
1993 : : // sense.
1994 : :
1995 : : // hold timer, while processing the queues:
1996 : : // 1. when there is more than one active activity this ensures the
1997 : : // same time for all activities and events
1998 : : // 2. processing of events may lead to creation of further events
1999 : : // that have zero delay. While the timer is stopped these events
2000 : : // are processed in the same run.
2001 : : {
2002 : : //Get a shared-ptr that outlives the scope-guard which will
2003 : : //ensure that the pointed-to-item exists in the case of a
2004 : : //::dispose clearing mpPresTimer
2005 : 0 : boost::shared_ptr<canvas::tools::ElapsedTime> xTimer(mpPresTimer);
2006 : : comphelper::ScopeGuard scopeGuard(
2007 : : boost::bind( &canvas::tools::ElapsedTime::releaseTimer,
2008 : 0 : boost::cref(xTimer) ) );
2009 : 0 : xTimer->holdTimer();
2010 : :
2011 : : // process queues
2012 : 0 : maEventQueue.process();
2013 : 0 : maActivitiesQueue.process();
2014 : :
2015 : : // commit frame to screen
2016 : 0 : maFrameSynchronization.Synchronize();
2017 : 0 : maScreenUpdater.commitUpdates();
2018 : :
2019 : : // TODO(Q3): remove need to call dequeued() from
2020 : : // activities. feels like a wart.
2021 : : //
2022 : : // Rationale for ActivitiesQueue::processDequeued(): when
2023 : : // an activity ends, it usually pushed the end state to
2024 : : // the animated shape in question, and ends the animation
2025 : : // (which, in turn, will usually disable shape sprite
2026 : : // mode). Disabling shape sprite mode causes shape
2027 : : // repaint, which, depending on slide content, takes
2028 : : // considerably more time than sprite updates. Thus, the
2029 : : // last animation step tends to look delayed. To
2030 : : // camouflage this, reaching end position and disabling
2031 : : // sprite mode is split into two (normal Activity::end(),
2032 : : // and Activity::dequeued()). Now, the reason to call
2033 : : // commitUpdates() twice here is caused by the unrelated
2034 : : // fact that during wait cursor display/hide, the screen
2035 : : // is updated, and shows hidden sprites, but, in case of
2036 : : // leaving the second commitUpdates() call out and punting
2037 : : // that to the next round, no updated static slide
2038 : : // content. In short, the last shape animation of a slide
2039 : : // tends to blink at its end.
2040 : :
2041 : : // process dequeued activities _after_ commit to screen
2042 : 0 : maActivitiesQueue.processDequeued();
2043 : :
2044 : : // commit frame to screen
2045 : 0 : maScreenUpdater.commitUpdates();
2046 : : }
2047 : : // Time held until here
2048 : :
2049 : 0 : const bool bActivitiesLeft = (! maActivitiesQueue.isEmpty());
2050 : 0 : const bool bTimerEventsLeft = (! maEventQueue.isEmpty());
2051 : 0 : const bool bRet = (bActivitiesLeft || bTimerEventsLeft);
2052 : :
2053 : 0 : if (bRet)
2054 : : {
2055 : : // calc nNextTimeout value:
2056 : 0 : if (bActivitiesLeft)
2057 : : {
2058 : : // Activity queue is not empty. Tell caller that we would
2059 : : // like to render another frame.
2060 : :
2061 : : // Return a zero time-out to signal our caller to call us
2062 : : // back as soon as possible. The actual timing, waiting the
2063 : : // appropriate amount of time between frames, is then done
2064 : : // by the maFrameSynchronization object.
2065 : 0 : nNextTimeout = 0;
2066 : 0 : maFrameSynchronization.Activate();
2067 : : }
2068 : : else
2069 : : {
2070 : : // timer events left:
2071 : : // difference from current time (nota bene:
2072 : : // time no longer held here!) to the next event in
2073 : : // the event queue.
2074 : :
2075 : : // #i61190# Retrieve next timeout only _after_
2076 : : // processing activity queue
2077 : :
2078 : : // ensure positive value:
2079 : 0 : nNextTimeout = std::max( 0.0, maEventQueue.nextTimeout() );
2080 : :
2081 : : // There is no active animation so the frame rate does not
2082 : : // need to be synchronized.
2083 : 0 : maFrameSynchronization.Deactivate();
2084 : : }
2085 : :
2086 : 0 : mbSlideShowIdle = false;
2087 : : }
2088 : :
2089 : : #if OSL_DEBUG_LEVEL >= 2 && defined(DBG_UTIL)
2090 : : // when slideshow is idle, issue an XUpdatable::update() call
2091 : : // exactly once after a previous animation sequence finished -
2092 : : // this might trigger screen dumps on some canvas
2093 : : // implementations
2094 : : if( !mbSlideShowIdle &&
2095 : : (!bRet ||
2096 : : nNextTimeout > 1.0) )
2097 : : {
2098 : : UnoViewVector::const_iterator aCurr(maViewContainer.begin());
2099 : : const UnoViewVector::const_iterator aEnd(maViewContainer.end());
2100 : : while( aCurr != aEnd )
2101 : : {
2102 : : try
2103 : : {
2104 : : uno::Reference< presentation::XSlideShowView > xView( (*aCurr)->getUnoView(),
2105 : : uno::UNO_QUERY_THROW );
2106 : : uno::Reference< util::XUpdatable > xUpdatable( xView->getCanvas(),
2107 : : uno::UNO_QUERY_THROW );
2108 : : xUpdatable->update();
2109 : : }
2110 : : catch( uno::RuntimeException& )
2111 : : {
2112 : : throw;
2113 : : }
2114 : : catch( uno::Exception& )
2115 : : {
2116 : : OSL_FAIL( rtl::OUStringToOString(
2117 : : comphelper::anyToString( cppu::getCaughtException() ),
2118 : : RTL_TEXTENCODING_UTF8 ).getStr() );
2119 : : }
2120 : :
2121 : : ++aCurr;
2122 : : }
2123 : :
2124 : : mbSlideShowIdle = true;
2125 : : }
2126 : : #endif
2127 : :
2128 : 0 : return bRet;
2129 : 0 : }
2130 : : }
2131 : :
2132 : 0 : void SlideShowImpl::notifySlideTransitionEnded( bool bPaintSlide )
2133 : : {
2134 : 0 : osl::MutexGuard const guard( m_aMutex );
2135 : :
2136 : : OSL_ENSURE( !isDisposed(), "### already disposed!" );
2137 : : OSL_ENSURE( mpCurrentSlide,
2138 : : "notifySlideTransitionEnded(): Invalid current slide" );
2139 : 0 : if (mpCurrentSlide)
2140 : : {
2141 : 0 : mpCurrentSlide->update_settings( !!maUserPaintColor, maUserPaintColor ? *maUserPaintColor : RGBColor(), maUserPaintStrokeWidth );
2142 : :
2143 : : // first init show, to give the animations
2144 : : // the chance to register SlideStartEvents
2145 : 0 : const bool bBackgroundLayerRendered( !bPaintSlide );
2146 : 0 : mpCurrentSlide->show( bBackgroundLayerRendered );
2147 : 0 : maEventMultiplexer.notifySlideStartEvent();
2148 : 0 : }
2149 : 0 : }
2150 : :
2151 : 0 : void queryAutomaticSlideTransition( uno::Reference<drawing::XDrawPage> const& xDrawPage,
2152 : : double& nAutomaticNextSlideTimeout,
2153 : : bool& bHasAutomaticNextSlide )
2154 : : {
2155 : : // retrieve slide change parameters from XDrawPage
2156 : : // ===============================================
2157 : :
2158 : : uno::Reference< beans::XPropertySet > xPropSet( xDrawPage,
2159 : 0 : uno::UNO_QUERY );
2160 : :
2161 : 0 : sal_Int32 nChange(0);
2162 : 0 : if( !xPropSet.is() ||
2163 : : !getPropertyValue( nChange,
2164 : : xPropSet,
2165 : : ::rtl::OUString(
2166 : 0 : "Change")) )
2167 : : {
2168 : : OSL_TRACE(
2169 : : "queryAutomaticSlideTransition(): "
2170 : : "Could not extract slide change mode from XDrawPage - assuming <none>\n" );
2171 : : }
2172 : :
2173 : 0 : bHasAutomaticNextSlide = nChange == 1;
2174 : :
2175 : 0 : if( !xPropSet.is() ||
2176 : : !getPropertyValue( nAutomaticNextSlideTimeout,
2177 : : xPropSet,
2178 : : ::rtl::OUString(
2179 : 0 : "Duration")) )
2180 : : {
2181 : : OSL_TRACE(
2182 : : "queryAutomaticSlideTransition(): "
2183 : : "Could not extract slide transition timeout from "
2184 : : "XDrawPage - assuming 1 sec\n" );
2185 : 0 : }
2186 : 0 : }
2187 : :
2188 : 0 : void SlideShowImpl::notifySlideAnimationsEnded()
2189 : : {
2190 : 0 : osl::MutexGuard const guard( m_aMutex );
2191 : :
2192 : : //Draw polygons above animations
2193 : 0 : mpCurrentSlide->drawPolygons();
2194 : :
2195 : : OSL_ENSURE( !isDisposed(), "### already disposed!" );
2196 : :
2197 : : // This struct will receive the (interruptable) event,
2198 : : // that triggers the notifySlideEnded() method.
2199 : 0 : InterruptableEventPair aNotificationEvents;
2200 : :
2201 : 0 : if( maEventMultiplexer.getAutomaticMode() )
2202 : : {
2203 : : OSL_ENSURE( ! mpRehearseTimingsActivity,
2204 : : "unexpected: RehearseTimings mode!" );
2205 : :
2206 : : // schedule a slide end event, with automatic mode's
2207 : : // delay
2208 : : aNotificationEvents = makeInterruptableDelay(
2209 : 0 : boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
2210 : 0 : maEventMultiplexer.getAutomaticTimeout() );
2211 : : }
2212 : : else
2213 : : {
2214 : : OSL_ENSURE( mpCurrentSlide,
2215 : : "notifySlideAnimationsEnded(): Invalid current slide!" );
2216 : :
2217 : 0 : bool bHasAutomaticNextSlide=false;
2218 : 0 : double nAutomaticNextSlideTimeout=0.0;
2219 : 0 : queryAutomaticSlideTransition(mpCurrentSlide->getXDrawPage(),
2220 : : nAutomaticNextSlideTimeout,
2221 : 0 : bHasAutomaticNextSlide);
2222 : :
2223 : : // check whether slide transition should happen
2224 : : // 'automatically'. If yes, simply schedule the
2225 : : // specified timeout.
2226 : : // NOTE: mbForceManualAdvance and mpRehearseTimingsActivity
2227 : : // override any individual slide setting, to always
2228 : : // step slides manually.
2229 : 0 : if( !mbForceManualAdvance &&
2230 : 0 : !mpRehearseTimingsActivity &&
2231 : : bHasAutomaticNextSlide )
2232 : : {
2233 : : aNotificationEvents = makeInterruptableDelay(
2234 : 0 : boost::bind<void>( boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
2235 : 0 : nAutomaticNextSlideTimeout);
2236 : :
2237 : : // TODO(F2): Provide a mechanism to let the user override
2238 : : // this automatic timeout via next()
2239 : : }
2240 : : else
2241 : : {
2242 : 0 : if (mpRehearseTimingsActivity)
2243 : 0 : mpRehearseTimingsActivity->start();
2244 : :
2245 : : // generate click event. Thus, the user must
2246 : : // trigger the actual end of a slide. No need to
2247 : : // generate interruptable event here, there's no
2248 : : // timeout involved.
2249 : : aNotificationEvents.mpImmediateEvent =
2250 : 0 : makeEvent( boost::bind<void>(
2251 : : boost::mem_fn(&SlideShowImpl::notifySlideEnded), this, false ),
2252 : 0 : "SlideShowImpl::notifySlideEnded");
2253 : : }
2254 : : }
2255 : :
2256 : : // register events on the queues. To make automatic slide
2257 : : // changes interruptable, register the interruption event
2258 : : // as a nextEffectEvent target. Note that the timeout
2259 : : // event is optional (e.g. manual slide changes don't
2260 : : // generate a timeout)
2261 : : maUserEventQueue.registerNextEffectEvent(
2262 : 0 : aNotificationEvents.mpImmediateEvent );
2263 : :
2264 : 0 : if( aNotificationEvents.mpTimeoutEvent )
2265 : 0 : maEventQueue.addEvent( aNotificationEvents.mpTimeoutEvent );
2266 : :
2267 : : // current slide's main sequence is over. Now should be
2268 : : // the time to prefetch the next slide (if any), and
2269 : : // prepare the initial slide bitmap (speeds up slide
2270 : : // change setup time a lot). Show the wait cursor, this
2271 : : // indeed might take some seconds.
2272 : : {
2273 : 0 : WaitSymbolLock aLock (*this);
2274 : :
2275 : 0 : if (! matches( mpPrefetchSlide,
2276 : 0 : mxPrefetchSlide, mxPrefetchAnimationNode ))
2277 : : {
2278 : : mpPrefetchSlide = makeSlide( mxPrefetchSlide, mxDrawPagesSupplier,
2279 : 0 : mxPrefetchAnimationNode );
2280 : : }
2281 : 0 : if (mpPrefetchSlide)
2282 : : {
2283 : : // ignore return value, this is just to populate
2284 : : // Slide's internal bitmap buffer, such that the time
2285 : : // needed to generate the slide bitmap is not spent
2286 : : // when the slide change is requested.
2287 : 0 : mpPrefetchSlide->getCurrentSlideBitmap( *maViewContainer.begin() );
2288 : 0 : }
2289 : : } // finally
2290 : :
2291 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
2292 : 0 : boost::mem_fn( &presentation::XSlideShowListener::slideAnimationsEnded ) );
2293 : 0 : }
2294 : :
2295 : 0 : void SlideShowImpl::notifySlideEnded (const bool bReverse)
2296 : : {
2297 : 0 : osl::MutexGuard const guard( m_aMutex );
2298 : :
2299 : : OSL_ENSURE( !isDisposed(), "### already disposed!" );
2300 : :
2301 : 0 : if (mpRehearseTimingsActivity && !bReverse)
2302 : : {
2303 : 0 : const double time = mpRehearseTimingsActivity->stop();
2304 : 0 : if (mpRehearseTimingsActivity->hasBeenClicked())
2305 : : {
2306 : : // save time at current drawpage:
2307 : : uno::Reference<beans::XPropertySet> xPropSet(
2308 : 0 : mpCurrentSlide->getXDrawPage(), uno::UNO_QUERY );
2309 : : OSL_ASSERT( xPropSet.is() );
2310 : 0 : if (xPropSet.is())
2311 : : {
2312 : 0 : xPropSet->setPropertyValue(
2313 : : OUSTR("Change"),
2314 : 0 : uno::Any( static_cast<sal_Int32>(1) ) );
2315 : 0 : xPropSet->setPropertyValue(
2316 : : OUSTR("Duration"),
2317 : 0 : uno::Any( static_cast<sal_Int32>(time) ) );
2318 : 0 : }
2319 : : }
2320 : : }
2321 : :
2322 : 0 : if (bReverse)
2323 : 0 : maEventMultiplexer.notifySlideEndEvent();
2324 : :
2325 : 0 : stopShow(); // MUST call that: results in
2326 : : // maUserEventQueue.clear(). What's more,
2327 : : // stopShow()'s currSlide->hide() call is
2328 : : // now also required, notifySlideEnded()
2329 : : // relies on that
2330 : : // unconditionally. Otherwise, genuine
2331 : : // shape animations (drawing layer and
2332 : : // GIF) will not be stopped.
2333 : :
2334 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
2335 : : boost::bind<void>(
2336 : : ::boost::mem_fn(&presentation::XSlideShowListener::slideEnded),
2337 : : _1,
2338 : 0 : sal_Bool(bReverse)));
2339 : 0 : }
2340 : :
2341 : 0 : bool SlideShowImpl::notifyHyperLinkClicked( rtl::OUString const& hyperLink )
2342 : : {
2343 : 0 : osl::MutexGuard const guard( m_aMutex );
2344 : :
2345 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
2346 : : boost::bind( &presentation::XSlideShowListener::hyperLinkClicked,
2347 : : _1,
2348 : 0 : boost::cref(hyperLink) ));
2349 : 0 : return true;
2350 : : }
2351 : :
2352 : : /** Notification from eventmultiplexer that an animation event has occoured.
2353 : : This will be forewarded to all registered XSlideShoeListener
2354 : : */
2355 : 0 : bool SlideShowImpl::handleAnimationEvent( const AnimationNodeSharedPtr& rNode )
2356 : : {
2357 : 0 : osl::MutexGuard const guard( m_aMutex );
2358 : :
2359 : 0 : uno::Reference<animations::XAnimationNode> xNode( rNode->getXAnimationNode() );
2360 : :
2361 : 0 : switch( rNode->getState() )
2362 : : {
2363 : : case AnimationNode::ACTIVE:
2364 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
2365 : : boost::bind( &animations::XAnimationListener::beginEvent,
2366 : : _1,
2367 : 0 : boost::cref(xNode) ));
2368 : 0 : break;
2369 : :
2370 : : case AnimationNode::FROZEN:
2371 : : case AnimationNode::ENDED:
2372 : : maListenerContainer.forEach<presentation::XSlideShowListener>(
2373 : : boost::bind( &animations::XAnimationListener::endEvent,
2374 : : _1,
2375 : 0 : boost::cref(xNode) ));
2376 : 0 : if(mpCurrentSlide->isPaintOverlayActive())
2377 : 0 : mpCurrentSlide->drawPolygons();
2378 : 0 : break;
2379 : : default:
2380 : 0 : break;
2381 : : }
2382 : :
2383 : 0 : return true;
2384 : : }
2385 : :
2386 : : //===== FrameSynchronization ==================================================
2387 : :
2388 : 0 : FrameSynchronization::FrameSynchronization (const double nFrameDuration)
2389 : : : maTimer(),
2390 : : mnFrameDuration(nFrameDuration),
2391 : : mnNextFrameTargetTime(0),
2392 : 0 : mbIsActive(false)
2393 : : {
2394 : 0 : MarkCurrentFrame();
2395 : 0 : }
2396 : :
2397 : 0 : void FrameSynchronization::MarkCurrentFrame (void)
2398 : : {
2399 : 0 : mnNextFrameTargetTime = maTimer.getElapsedTime() + mnFrameDuration;
2400 : 0 : }
2401 : :
2402 : 0 : void FrameSynchronization::Synchronize (void)
2403 : : {
2404 : 0 : if (mbIsActive)
2405 : : {
2406 : : // Do busy waiting for now.
2407 : 0 : while (maTimer.getElapsedTime() < mnNextFrameTargetTime)
2408 : : ;
2409 : : }
2410 : :
2411 : 0 : MarkCurrentFrame();
2412 : 0 : }
2413 : :
2414 : 0 : void FrameSynchronization::Activate (void)
2415 : : {
2416 : 0 : mbIsActive = true;
2417 : 0 : }
2418 : :
2419 : 0 : void FrameSynchronization::Deactivate (void)
2420 : : {
2421 : 0 : mbIsActive = false;
2422 : 0 : }
2423 : :
2424 : : } // anon namespace
2425 : :
2426 : : namespace sdecl = comphelper::service_decl;
2427 : 0 : const sdecl::ServiceDecl slideShowDecl(
2428 : : sdecl::class_<SlideShowImpl>(),
2429 : : "com.sun.star.comp.presentation.SlideShow",
2430 : 0 : "com.sun.star.presentation.SlideShow" );
2431 : :
2432 : : // The C shared lib entry points
2433 : 0 : COMPHELPER_SERVICEDECL_EXPORTS1(slideshow, slideShowDecl)
2434 : :
2435 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
