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 <osl/diagnose.hxx>
22 : #include <canvas/debug.hxx>
23 : #include <tools/diagnose_ex.h>
24 : #include <canvas/canvastools.hxx>
25 : #include <cppcanvas/basegfxfactory.hxx>
26 :
27 : #include <basegfx/matrix/b2dhommatrix.hxx>
28 : #include <basegfx/point/b2dpoint.hxx>
29 : #include <basegfx/polygon/b2dpolygon.hxx>
30 : #include <basegfx/polygon/b2dpolygontools.hxx>
31 : #include <basegfx/numeric/ftools.hxx>
32 :
33 : #include <com/sun/star/awt/SystemPointer.hpp>
34 : #include <com/sun/star/container/XIndexAccess.hpp>
35 : #include <com/sun/star/drawing/XMasterPageTarget.hpp>
36 : #include <com/sun/star/beans/XPropertySet.hpp>
37 : #include <com/sun/star/container/XEnumerationAccess.hpp>
38 : #include <com/sun/star/awt/Rectangle.hpp>
39 : #include <com/sun/star/presentation/ParagraphTarget.hpp>
40 : #include <com/sun/star/presentation/EffectNodeType.hpp>
41 : #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
42 : #include <com/sun/star/animations/XTargetPropertiesCreator.hpp>
43 : #include <com/sun/star/drawing/TextAnimationKind.hpp>
44 :
45 : #include <animations/animationnodehelper.hxx>
46 :
47 : #include <cppuhelper/exc_hlp.hxx>
48 : #include <comphelper/anytostring.hxx>
49 :
50 : #include "slide.hxx"
51 : #include "slideshowcontext.hxx"
52 : #include "slideanimations.hxx"
53 : #include "doctreenode.hxx"
54 : #include "screenupdater.hxx"
55 : #include "cursormanager.hxx"
56 : #include "shapeimporter.hxx"
57 : #include "slideshowexceptions.hxx"
58 : #include "eventqueue.hxx"
59 : #include "activitiesqueue.hxx"
60 : #include "layermanager.hxx"
61 : #include "shapemanagerimpl.hxx"
62 : #include "usereventqueue.hxx"
63 : #include "userpaintoverlay.hxx"
64 : #include "event.hxx"
65 : #include "tools.hxx"
66 :
67 : #include <o3tl/compat_functional.hxx>
68 :
69 : #include <boost/bind.hpp>
70 : #include <iterator>
71 : #include <algorithm>
72 : #include <functional>
73 : #include <iostream>
74 :
75 : using namespace ::com::sun::star;
76 :
77 : // -----------------------------------------------------------------------------
78 :
79 : namespace slideshow
80 : {
81 : namespace internal
82 : {
83 : namespace
84 : {
85 :
86 : class SlideImpl : public Slide,
87 : public CursorManager,
88 : public ViewEventHandler,
89 : public ::osl::DebugBase<SlideImpl>
90 : {
91 : public:
92 : SlideImpl( const uno::Reference<drawing::XDrawPage>& xDrawPage,
93 : const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages,
94 : const uno::Reference<animations::XAnimationNode>& xRootNode,
95 : EventQueue& rEventQueue,
96 : EventMultiplexer& rEventMultiplexer,
97 : ScreenUpdater& rScreenUpdater,
98 : ActivitiesQueue& rActivitiesQueue,
99 : UserEventQueue& rUserEventQueue,
100 : CursorManager& rCursorManager,
101 : const UnoViewContainer& rViewContainer,
102 : const uno::Reference<uno::XComponentContext>& xContext,
103 : const ShapeEventListenerMap& rShapeListenerMap,
104 : const ShapeCursorMap& rShapeCursorMap,
105 : const PolyPolygonVector& rPolyPolygonVector,
106 : RGBColor const& rUserPaintColor,
107 : double dUserPaintStrokeWidth,
108 : bool bUserPaintEnabled,
109 : bool bIntrinsicAnimationsAllowed,
110 : bool bDisableAnimationZOrder );
111 :
112 : ~SlideImpl();
113 :
114 :
115 : // Disposable interface
116 : // -------------------------------------------------------------------
117 :
118 : virtual void dispose();
119 :
120 :
121 : // Slide interface
122 : // -------------------------------------------------------------------
123 :
124 : virtual bool prefetch();
125 : virtual bool show( bool );
126 : virtual void hide();
127 :
128 : virtual basegfx::B2ISize getSlideSize() const;
129 : virtual uno::Reference<drawing::XDrawPage > getXDrawPage() const;
130 : virtual uno::Reference<animations::XAnimationNode> getXAnimationNode() const;
131 : virtual PolyPolygonVector getPolygons();
132 : virtual void drawPolygons() const;
133 : virtual bool isPaintOverlayActive() const;
134 : virtual void enablePaintOverlay();
135 : virtual void disablePaintOverlay();
136 : virtual void update_settings( bool bUserPaintEnabled, RGBColor const& aUserPaintColor, double dUserPaintStrokeWidth );
137 :
138 :
139 : // TODO(F2): Rework SlideBitmap to no longer be based on XBitmap,
140 : // but on canvas-independent basegfx bitmaps
141 : virtual SlideBitmapSharedPtr getCurrentSlideBitmap( const UnoViewSharedPtr& rView ) const;
142 :
143 :
144 : private:
145 : // ViewEventHandler
146 : virtual void viewAdded( const UnoViewSharedPtr& rView );
147 : virtual void viewRemoved( const UnoViewSharedPtr& rView );
148 : virtual void viewChanged( const UnoViewSharedPtr& rView );
149 : virtual void viewsChanged();
150 :
151 : // CursorManager
152 : virtual bool requestCursor( sal_Int16 nCursorShape );
153 : virtual void resetCursor();
154 :
155 : void activatePaintOverlay();
156 : void deactivatePaintOverlay();
157 :
158 : /** Query whether the slide has animations at all
159 :
160 : If the slide doesn't have animations, show() displays
161 : only static content. If an event is registered with
162 : registerSlideEndEvent(), this event will be
163 : immediately activated at the end of the show() method.
164 :
165 : @return true, if this slide has animations, false
166 : otherwise
167 : */
168 : bool isAnimated();
169 :
170 : /// Set all Shapes to their initial attributes for slideshow
171 : bool applyInitialShapeAttributes( const ::com::sun::star::uno::Reference<
172 : ::com::sun::star::animations::XAnimationNode >& xRootAnimationNode );
173 :
174 : /// Renders current slide content to bitmap
175 : SlideBitmapSharedPtr createCurrentSlideBitmap(
176 : const UnoViewSharedPtr& rView,
177 : ::basegfx::B2ISize const & rSlideSize ) const;
178 :
179 : /// Prefetch all shapes (not the animations)
180 : bool loadShapes();
181 :
182 : /// Retrieve slide size from XDrawPage
183 : basegfx::B2ISize getSlideSizeImpl() const;
184 :
185 : /// Prefetch show, but don't call applyInitialShapeAttributes()
186 : bool implPrefetchShow();
187 :
188 : /// Query the rectangle covered by the slide
189 : ::basegfx::B2DRectangle getSlideRect() const;
190 :
191 : /// Start GIF and other intrinsic shape animations
192 : void endIntrinsicAnimations();
193 :
194 : /// End GIF and other intrinsic shape animations
195 : void startIntrinsicAnimations();
196 :
197 : /// Add Polygons to the member maPolygons
198 : void addPolygons(PolyPolygonVector aPolygons);
199 :
200 : // Types
201 : // =====
202 :
203 : enum SlideAnimationState
204 : {
205 : CONSTRUCTING_STATE=0,
206 : INITIAL_STATE=1,
207 : SHOWING_STATE=2,
208 : FINAL_STATE=3,
209 : SlideAnimationState_NUM_ENTRIES=4
210 : };
211 :
212 : typedef std::vector< SlideBitmapSharedPtr > VectorOfSlideBitmaps;
213 : /** Vector of slide bitmaps.
214 :
215 : Since the bitmap content is sensitive to animation
216 : effects, we have an inner vector containing a distinct
217 : bitmap for each of the SlideAnimationStates.
218 : */
219 : typedef ::std::vector< std::pair< UnoViewSharedPtr,
220 : VectorOfSlideBitmaps > > VectorOfVectorOfSlideBitmaps;
221 :
222 :
223 : // Member variables
224 : // ================
225 :
226 : /// The page model object
227 : uno::Reference< drawing::XDrawPage > mxDrawPage;
228 : uno::Reference< drawing::XDrawPagesSupplier > mxDrawPagesSupplier;
229 : uno::Reference< animations::XAnimationNode > mxRootNode;
230 :
231 : LayerManagerSharedPtr mpLayerManager;
232 : boost::shared_ptr<ShapeManagerImpl> mpShapeManager;
233 : boost::shared_ptr<SubsettableShapeManager> mpSubsettableShapeManager;
234 :
235 : /// Contains common objects needed throughout the slideshow
236 : SlideShowContext maContext;
237 :
238 : /// parent cursor manager
239 : CursorManager& mrCursorManager;
240 :
241 : /// Handles the animation and event generation for us
242 : SlideAnimations maAnimations;
243 : PolyPolygonVector maPolygons;
244 :
245 : RGBColor maUserPaintColor;
246 : double mdUserPaintStrokeWidth;
247 : UserPaintOverlaySharedPtr mpPaintOverlay;
248 :
249 : /// Bitmaps with slide content at various states
250 : mutable VectorOfVectorOfSlideBitmaps maSlideBitmaps;
251 :
252 : SlideAnimationState meAnimationState;
253 :
254 : const basegfx::B2ISize maSlideSize;
255 :
256 : sal_Int16 mnCurrentCursor;
257 :
258 : /// True, when intrinsic shape animations are allowed
259 : bool mbIntrinsicAnimationsAllowed;
260 :
261 : /// True, when user paint overlay is enabled
262 : bool mbUserPaintOverlayEnabled;
263 :
264 : /// True, if initial load of all page shapes succeeded
265 : bool mbShapesLoaded;
266 :
267 : /// True, if initial load of all animation info succeeded
268 : bool mbShowLoaded;
269 :
270 : /** True, if this slide is not static.
271 :
272 : If this slide has animated content, this variable will
273 : be true, and false otherwise.
274 : */
275 : bool mbHaveAnimations;
276 :
277 : /** True, if this slide has a main animation sequence.
278 :
279 : If this slide has animation content, which in turn has
280 : a main animation sequence (which must be fully run
281 : before EventMultiplexer::notifySlideAnimationsEnd() is
282 : called), this member is true.
283 : */
284 : bool mbMainSequenceFound;
285 :
286 : /// When true, show() was called. Slide hidden oherwise.
287 : bool mbActive;
288 :
289 : ///When true, enablePaintOverlay was called and mbUserPaintOverlay = true
290 : bool mbPaintOverlayActive;
291 : };
292 :
293 :
294 : //////////////////////////////////////////////////////////////////////////////////
295 :
296 :
297 : class SlideRenderer
298 : {
299 : public:
300 0 : explicit SlideRenderer( SlideImpl& rSlide ) :
301 0 : mrSlide( rSlide )
302 : {
303 0 : }
304 :
305 0 : void operator()( const UnoViewSharedPtr& rView )
306 : {
307 : // fully clear view content to background color
308 0 : rView->clearAll();
309 :
310 0 : SlideBitmapSharedPtr pBitmap( mrSlide.getCurrentSlideBitmap( rView ) );
311 0 : ::cppcanvas::CanvasSharedPtr pCanvas( rView->getCanvas() );
312 :
313 0 : const ::basegfx::B2DHomMatrix aViewTransform( rView->getTransformation() );
314 0 : const ::basegfx::B2DPoint aOutPosPixel( aViewTransform * ::basegfx::B2DPoint() );
315 :
316 : // setup a canvas with device coordinate space, the slide
317 : // bitmap already has the correct dimension.
318 0 : ::cppcanvas::CanvasSharedPtr pDevicePixelCanvas( pCanvas->clone() );
319 0 : pDevicePixelCanvas->setTransformation( ::basegfx::B2DHomMatrix() );
320 :
321 : // render at given output position
322 0 : pBitmap->move( aOutPosPixel );
323 :
324 : // clear clip (might have been changed, e.g. from comb
325 : // transition)
326 0 : pBitmap->clip( ::basegfx::B2DPolyPolygon() );
327 0 : pBitmap->draw( pDevicePixelCanvas );
328 0 : }
329 :
330 : private:
331 : SlideImpl& mrSlide;
332 : };
333 :
334 :
335 : //////////////////////////////////////////////////////////////////////////////////
336 :
337 :
338 0 : SlideImpl::SlideImpl( const uno::Reference< drawing::XDrawPage >& xDrawPage,
339 : const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages,
340 : const uno::Reference< animations::XAnimationNode >& xRootNode,
341 : EventQueue& rEventQueue,
342 : EventMultiplexer& rEventMultiplexer,
343 : ScreenUpdater& rScreenUpdater,
344 : ActivitiesQueue& rActivitiesQueue,
345 : UserEventQueue& rUserEventQueue,
346 : CursorManager& rCursorManager,
347 : const UnoViewContainer& rViewContainer,
348 : const uno::Reference< uno::XComponentContext >& xComponentContext,
349 : const ShapeEventListenerMap& rShapeListenerMap,
350 : const ShapeCursorMap& rShapeCursorMap,
351 : const PolyPolygonVector& rPolyPolygonVector,
352 : RGBColor const& aUserPaintColor,
353 : double dUserPaintStrokeWidth,
354 : bool bUserPaintEnabled,
355 : bool bIntrinsicAnimationsAllowed,
356 : bool bDisableAnimationZOrder ) :
357 : mxDrawPage( xDrawPage ),
358 : mxDrawPagesSupplier( xDrawPages ),
359 : mxRootNode( xRootNode ),
360 : mpLayerManager( new LayerManager(
361 : rViewContainer,
362 : getSlideRect(),
363 0 : bDisableAnimationZOrder) ),
364 : mpShapeManager( new ShapeManagerImpl(
365 : rEventMultiplexer,
366 : mpLayerManager,
367 : rCursorManager,
368 : rShapeListenerMap,
369 0 : rShapeCursorMap)),
370 : mpSubsettableShapeManager( mpShapeManager ),
371 : maContext( mpSubsettableShapeManager,
372 : rEventQueue,
373 : rEventMultiplexer,
374 : rScreenUpdater,
375 : rActivitiesQueue,
376 : rUserEventQueue,
377 : *this,
378 : rViewContainer,
379 : xComponentContext ),
380 : mrCursorManager( rCursorManager ),
381 : maAnimations( maContext,
382 : basegfx::B2DSize( getSlideSizeImpl() ) ),
383 : maPolygons(rPolyPolygonVector),
384 : maUserPaintColor(aUserPaintColor),
385 : mdUserPaintStrokeWidth(dUserPaintStrokeWidth),
386 : mpPaintOverlay(),
387 : maSlideBitmaps(),
388 : meAnimationState( CONSTRUCTING_STATE ),
389 : maSlideSize(getSlideSizeImpl()),
390 : mnCurrentCursor( awt::SystemPointer::ARROW ),
391 : mbIntrinsicAnimationsAllowed( bIntrinsicAnimationsAllowed ),
392 : mbUserPaintOverlayEnabled(bUserPaintEnabled),
393 : mbShapesLoaded( false ),
394 : mbShowLoaded( false ),
395 : mbHaveAnimations( false ),
396 : mbMainSequenceFound( false ),
397 : mbActive( false ),
398 0 : mbPaintOverlayActive( false )
399 : {
400 : // clone already existing views for slide bitmaps
401 : std::for_each( rViewContainer.begin(),
402 : rViewContainer.end(),
403 : boost::bind( &SlideImpl::viewAdded,
404 : this,
405 0 : _1 ));
406 :
407 : // register screen update (LayerManager needs to signal pending
408 : // updates)
409 0 : maContext.mrScreenUpdater.addViewUpdate(mpShapeManager);
410 0 : }
411 :
412 0 : void SlideImpl::update_settings( bool bUserPaintEnabled, RGBColor const& aUserPaintColor, double dUserPaintStrokeWidth )
413 : {
414 0 : maUserPaintColor = aUserPaintColor;
415 0 : mdUserPaintStrokeWidth = dUserPaintStrokeWidth;
416 0 : mbUserPaintOverlayEnabled = bUserPaintEnabled;
417 0 : }
418 :
419 0 : SlideImpl::~SlideImpl()
420 : {
421 0 : if( mpShapeManager )
422 : {
423 0 : maContext.mrScreenUpdater.removeViewUpdate(mpShapeManager);
424 0 : mpShapeManager->dispose();
425 :
426 : // TODO(Q3): Make sure LayerManager (and thus Shapes) dies
427 : // first, because SlideShowContext has SubsettableShapeManager
428 : // as reference member.
429 0 : mpLayerManager.reset();
430 : }
431 0 : }
432 :
433 0 : void SlideImpl::dispose()
434 : {
435 0 : maSlideBitmaps.clear();
436 0 : mpPaintOverlay.reset();
437 0 : maAnimations.dispose();
438 0 : maContext.dispose();
439 :
440 0 : if( mpShapeManager )
441 : {
442 0 : maContext.mrScreenUpdater.removeViewUpdate(mpShapeManager);
443 0 : mpShapeManager->dispose();
444 : }
445 :
446 : // TODO(Q3): Make sure LayerManager (and thus Shapes) dies first,
447 : // because SlideShowContext has SubsettableShapeManager as
448 : // reference member.
449 0 : mpLayerManager.reset();
450 0 : mpSubsettableShapeManager.reset();
451 0 : mpShapeManager.reset();
452 0 : mxRootNode.clear();
453 0 : mxDrawPage.clear();
454 0 : mxDrawPagesSupplier.clear();
455 0 : }
456 :
457 0 : bool SlideImpl::prefetch()
458 : {
459 0 : if( !mxRootNode.is() )
460 0 : return false;
461 :
462 0 : return applyInitialShapeAttributes(mxRootNode);
463 : }
464 :
465 0 : bool SlideImpl::show( bool bSlideBackgoundPainted )
466 : {
467 : // ---------------------------------------------------------------
468 :
469 0 : if( mbActive )
470 0 : return true; // already active
471 :
472 0 : if( !mpShapeManager || !mpLayerManager )
473 0 : return false; // disposed
474 :
475 : // ---------------------------------------------------------------
476 :
477 : // set initial shape attributes (e.g. hide shapes that have
478 : // 'appear' effect set)
479 0 : if( !applyInitialShapeAttributes(mxRootNode) )
480 0 : return false;
481 :
482 : // ---------------------------------------------------------------
483 :
484 : // activate and take over view - clears view, if necessary
485 0 : mbActive = true;
486 0 : requestCursor( mnCurrentCursor );
487 :
488 : // enable shape management & event broadcasting for shapes of this
489 : // slide. Also enables LayerManager to record updates. Currently,
490 : // never let LayerManager render initial slide content, use
491 : // buffered slide bitmaps instead.
492 0 : mpShapeManager->activate( true );
493 :
494 : // ---------------------------------------------------------------
495 :
496 : // render slide to screen, if requested
497 0 : if( !bSlideBackgoundPainted )
498 : {
499 : std::for_each(maContext.mrViewContainer.begin(),
500 : maContext.mrViewContainer.end(),
501 0 : boost::mem_fn(&View::clearAll));
502 :
503 : std::for_each( maContext.mrViewContainer.begin(),
504 : maContext.mrViewContainer.end(),
505 0 : SlideRenderer(*this) );
506 0 : maContext.mrScreenUpdater.notifyUpdate();
507 : }
508 :
509 : // ---------------------------------------------------------------
510 :
511 : // fire up animations
512 0 : const bool bIsAnimated( isAnimated() );
513 0 : if( bIsAnimated )
514 0 : maAnimations.start(); // feeds initial events into queue
515 :
516 : // NOTE: this looks slightly weird, but is indeed correct:
517 : // as isAnimated() might return false, _although_ there is
518 : // a main sequence (because the animation nodes don't
519 : // contain any executable effects), we gotta check both
520 : // conditions here.
521 0 : if( !bIsAnimated || !mbMainSequenceFound )
522 : {
523 : // manually trigger a slide animation end event (we don't have
524 : // animations at all, or we don't have a main animation
525 : // sequence, but if we had, it'd end now). Note that having
526 : // animations alone does not matter here, as only main
527 : // sequence animations prevents showing the next slide on
528 : // nextEvent().
529 0 : maContext.mrEventMultiplexer.notifySlideAnimationsEnd();
530 : }
531 :
532 : // enable shape-intrinsic animations (drawing layer animations or
533 : // GIF animations)
534 0 : if( mbIntrinsicAnimationsAllowed )
535 0 : startIntrinsicAnimations();
536 :
537 : // ---------------------------------------------------------------
538 :
539 : // enable paint overlay, if maUserPaintColor is valid
540 0 : activatePaintOverlay();
541 :
542 : // ---------------------------------------------------------------
543 :
544 : // from now on, animations might be showing
545 0 : meAnimationState = SHOWING_STATE;
546 :
547 0 : return true;
548 : }
549 :
550 0 : void SlideImpl::hide()
551 : {
552 0 : if( !mbActive || !mpShapeManager )
553 0 : return; // already hidden/disposed
554 :
555 : // ---------------------------------------------------------------
556 :
557 : // from now on, all animations are stopped
558 0 : meAnimationState = FINAL_STATE;
559 :
560 : // ---------------------------------------------------------------
561 :
562 : // disable user paint overlay under all circumstances,
563 : // this slide now ceases to be active.
564 0 : deactivatePaintOverlay();
565 :
566 : // ---------------------------------------------------------------
567 :
568 : // switch off all shape-intrinsic animations.
569 0 : endIntrinsicAnimations();
570 :
571 : // force-end all SMIL animations, too
572 0 : maAnimations.end();
573 :
574 : // ---------------------------------------------------------------
575 :
576 : // disable shape management & event broadcasting for shapes of this
577 : // slide. Also disables LayerManager.
578 0 : mpShapeManager->deactivate();
579 :
580 : // vanish from view
581 0 : resetCursor();
582 0 : mbActive = false;
583 :
584 : // ---------------------------------------------------------------
585 : }
586 :
587 0 : basegfx::B2ISize SlideImpl::getSlideSize() const
588 : {
589 0 : return maSlideSize;
590 : }
591 :
592 0 : uno::Reference<drawing::XDrawPage > SlideImpl::getXDrawPage() const
593 : {
594 0 : return mxDrawPage;
595 : }
596 :
597 0 : uno::Reference<animations::XAnimationNode> SlideImpl::getXAnimationNode() const
598 : {
599 0 : return mxRootNode;
600 : }
601 :
602 0 : PolyPolygonVector SlideImpl::getPolygons()
603 : {
604 0 : if(mbPaintOverlayActive)
605 0 : maPolygons = mpPaintOverlay->getPolygons();
606 0 : return maPolygons;
607 : }
608 :
609 0 : SlideBitmapSharedPtr SlideImpl::getCurrentSlideBitmap( const UnoViewSharedPtr& rView ) const
610 : {
611 : // search corresponding entry in maSlideBitmaps (which
612 : // contains the views as the key)
613 0 : VectorOfVectorOfSlideBitmaps::iterator aIter;
614 0 : const VectorOfVectorOfSlideBitmaps::iterator aEnd( maSlideBitmaps.end() );
615 0 : if( (aIter=std::find_if( maSlideBitmaps.begin(),
616 : aEnd,
617 : boost::bind(
618 : std::equal_to<UnoViewSharedPtr>(),
619 : rView,
620 : // select view:
621 : boost::bind(
622 : o3tl::select1st<VectorOfVectorOfSlideBitmaps::value_type>(),
623 0 : _1 )))) == aEnd )
624 : {
625 : // corresponding view not found - maybe view was not
626 : // added to Slide?
627 0 : ENSURE_OR_THROW( false,
628 : "SlideImpl::getInitialSlideBitmap(): view does not "
629 : "match any of the added ones" );
630 : }
631 :
632 : // ensure that the show is loaded
633 0 : if( !mbShowLoaded )
634 : {
635 : // only prefetch and init shapes when not done already
636 : // (otherwise, at least applyInitialShapeAttributes() will be
637 : // called twice for initial slide rendering). Furthermore,
638 : // applyInitialShapeAttributes() _always_ performs
639 : // initializations, which would be highly unwanted during a
640 : // running show. OTOH, a slide whose mbShowLoaded is false is
641 : // guaranteed not be running a show.
642 :
643 : // set initial shape attributes (e.g. hide 'appear' effect
644 : // shapes)
645 0 : if( !const_cast<SlideImpl*>(this)->applyInitialShapeAttributes( mxRootNode ) )
646 0 : ENSURE_OR_THROW(false,
647 : "SlideImpl::getCurrentSlideBitmap(): Cannot "
648 : "apply initial attributes");
649 : }
650 :
651 0 : SlideBitmapSharedPtr& rBitmap( aIter->second.at( meAnimationState ));
652 : const ::basegfx::B2ISize& rSlideSize(
653 0 : getSlideSizePixel( ::basegfx::B2DSize( getSlideSize() ),
654 0 : rView ));
655 :
656 : // is the bitmap valid (actually existent, and of correct
657 : // size)?
658 0 : if( !rBitmap || rBitmap->getSize() != rSlideSize )
659 : {
660 : // no bitmap there yet, or wrong size - create one
661 0 : rBitmap = createCurrentSlideBitmap(rView, rSlideSize);
662 : }
663 :
664 0 : return rBitmap;
665 : }
666 :
667 :
668 : // private methods
669 : //--------------------------------------------------------------------------------------------------------------
670 :
671 :
672 0 : void SlideImpl::viewAdded( const UnoViewSharedPtr& rView )
673 : {
674 : maSlideBitmaps.push_back(
675 : std::make_pair( rView,
676 0 : VectorOfSlideBitmaps(SlideAnimationState_NUM_ENTRIES) ));
677 :
678 0 : if( mpLayerManager )
679 0 : mpLayerManager->viewAdded( rView );
680 0 : }
681 :
682 0 : void SlideImpl::viewRemoved( const UnoViewSharedPtr& rView )
683 : {
684 0 : if( mpLayerManager )
685 0 : mpLayerManager->viewRemoved( rView );
686 :
687 0 : const VectorOfVectorOfSlideBitmaps::iterator aEnd( maSlideBitmaps.end() );
688 : maSlideBitmaps.erase(
689 : std::remove_if( maSlideBitmaps.begin(),
690 : aEnd,
691 : boost::bind(
692 : std::equal_to<UnoViewSharedPtr>(),
693 : rView,
694 : // select view:
695 : boost::bind(
696 : o3tl::select1st<VectorOfVectorOfSlideBitmaps::value_type>(),
697 : _1 ))),
698 0 : aEnd );
699 0 : }
700 :
701 0 : void SlideImpl::viewChanged( const UnoViewSharedPtr& rView )
702 : {
703 : // nothing to do for the Slide - getCurrentSlideBitmap() lazily
704 : // handles bitmap resizes
705 0 : if( mbActive && mpLayerManager )
706 0 : mpLayerManager->viewChanged(rView);
707 0 : }
708 :
709 0 : void SlideImpl::viewsChanged()
710 : {
711 : // nothing to do for the Slide - getCurrentSlideBitmap() lazily
712 : // handles bitmap resizes
713 0 : if( mbActive && mpLayerManager )
714 0 : mpLayerManager->viewsChanged();
715 0 : }
716 :
717 0 : bool SlideImpl::requestCursor( sal_Int16 nCursorShape )
718 : {
719 0 : mnCurrentCursor = nCursorShape;
720 0 : return mrCursorManager.requestCursor(mnCurrentCursor);
721 : }
722 :
723 0 : void SlideImpl::resetCursor()
724 : {
725 0 : mnCurrentCursor = awt::SystemPointer::ARROW;
726 0 : mrCursorManager.resetCursor();
727 0 : }
728 :
729 0 : bool SlideImpl::isAnimated()
730 : {
731 : // prefetch, but don't apply initial shape attributes
732 0 : if( !implPrefetchShow() )
733 0 : return false;
734 :
735 0 : return mbHaveAnimations && maAnimations.isAnimated();
736 : }
737 :
738 0 : SlideBitmapSharedPtr SlideImpl::createCurrentSlideBitmap( const UnoViewSharedPtr& rView,
739 : const ::basegfx::B2ISize& rBmpSize ) const
740 : {
741 0 : ENSURE_OR_THROW( rView && rView->getCanvas(),
742 : "SlideImpl::createCurrentSlideBitmap(): Invalid view" );
743 0 : ENSURE_OR_THROW( mpLayerManager,
744 : "SlideImpl::createCurrentSlideBitmap(): Invalid layer manager" );
745 0 : ENSURE_OR_THROW( mbShowLoaded,
746 : "SlideImpl::createCurrentSlideBitmap(): No show loaded" );
747 :
748 0 : ::cppcanvas::CanvasSharedPtr pCanvas( rView->getCanvas() );
749 :
750 : // create a bitmap of appropriate size
751 : ::cppcanvas::BitmapSharedPtr pBitmap(
752 0 : ::cppcanvas::BaseGfxFactory::getInstance().createBitmap(
753 : pCanvas,
754 0 : rBmpSize ) );
755 :
756 0 : ENSURE_OR_THROW( pBitmap,
757 : "SlideImpl::createCurrentSlideBitmap(): Cannot create page bitmap" );
758 :
759 0 : ::cppcanvas::BitmapCanvasSharedPtr pBitmapCanvas( pBitmap->getBitmapCanvas() );
760 :
761 0 : ENSURE_OR_THROW( pBitmapCanvas,
762 : "SlideImpl::createCurrentSlideBitmap(): Cannot create page bitmap canvas" );
763 :
764 : // apply linear part of destination canvas transformation (linear means in this context:
765 : // transformation without any translational components)
766 0 : ::basegfx::B2DHomMatrix aLinearTransform( rView->getTransformation() );
767 0 : aLinearTransform.set( 0, 2, 0.0 );
768 0 : aLinearTransform.set( 1, 2, 0.0 );
769 0 : pBitmapCanvas->setTransformation( aLinearTransform );
770 :
771 : // output all shapes to bitmap
772 0 : initSlideBackground( pBitmapCanvas, rBmpSize );
773 0 : mpLayerManager->renderTo( pBitmapCanvas );
774 :
775 0 : return SlideBitmapSharedPtr( new SlideBitmap( pBitmap ) );
776 : }
777 :
778 : namespace
779 : {
780 0 : class MainSequenceSearcher
781 : {
782 : public:
783 0 : MainSequenceSearcher()
784 0 : {
785 0 : maSearchKey.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
786 0 : maSearchKey.Value <<= presentation::EffectNodeType::MAIN_SEQUENCE;
787 0 : }
788 :
789 0 : void operator()( const uno::Reference< animations::XAnimationNode >& xChildNode )
790 : {
791 0 : uno::Sequence< beans::NamedValue > aUserData( xChildNode->getUserData() );
792 :
793 0 : if( findNamedValue( aUserData, maSearchKey ) )
794 : {
795 0 : maMainSequence = xChildNode;
796 0 : }
797 0 : }
798 :
799 0 : uno::Reference< animations::XAnimationNode > getMainSequence() const
800 : {
801 0 : return maMainSequence;
802 : }
803 :
804 : private:
805 : beans::NamedValue maSearchKey;
806 : uno::Reference< animations::XAnimationNode > maMainSequence;
807 : };
808 : }
809 :
810 0 : bool SlideImpl::implPrefetchShow()
811 : {
812 0 : if( mbShowLoaded )
813 0 : return true;
814 :
815 0 : ENSURE_OR_RETURN_FALSE( mxDrawPage.is(),
816 : "SlideImpl::implPrefetchShow(): Invalid draw page" );
817 0 : ENSURE_OR_RETURN_FALSE( mpLayerManager,
818 : "SlideImpl::implPrefetchShow(): Invalid layer manager" );
819 :
820 : // fetch desired page content
821 : // ==========================
822 :
823 0 : if( !loadShapes() )
824 0 : return false;
825 :
826 : // New animations framework: import the shape effect info
827 : // ======================================================
828 :
829 : try
830 : {
831 0 : if( mxRootNode.is() )
832 : {
833 0 : if( !maAnimations.importAnimations( mxRootNode ) )
834 : {
835 : OSL_FAIL( "SlideImpl::implPrefetchShow(): have animation nodes, "
836 : "but import animations failed." );
837 :
838 : // could not import animation framework,
839 : // _although_ some animation nodes are there -
840 : // this is an error (not finding animations at
841 : // all is okay - might be a static slide)
842 0 : return false;
843 : }
844 :
845 : // now check whether we've got a main sequence (if
846 : // not, we must manually call
847 : // EventMultiplexer::notifySlideAnimationsEnd()
848 : // above, as e.g. interactive sequences alone
849 : // don't block nextEvent() from issuing the next
850 : // slide)
851 0 : MainSequenceSearcher aSearcher;
852 0 : if( ::anim::for_each_childNode( mxRootNode, aSearcher ) )
853 0 : mbMainSequenceFound = aSearcher.getMainSequence().is();
854 :
855 : // import successfully done
856 0 : mbHaveAnimations = true;
857 : }
858 : }
859 0 : catch( uno::RuntimeException& )
860 : {
861 0 : throw;
862 : }
863 0 : catch( uno::Exception& )
864 : {
865 : OSL_FAIL(
866 : rtl::OUStringToOString(
867 : comphelper::anyToString(cppu::getCaughtException()),
868 : RTL_TEXTENCODING_UTF8).getStr() );
869 : // TODO(E2): Error handling. For now, bail out
870 : }
871 :
872 0 : mbShowLoaded = true;
873 :
874 0 : return true;
875 : }
876 :
877 0 : void SlideImpl::enablePaintOverlay()
878 : {
879 0 : if( !mbUserPaintOverlayEnabled || !mbPaintOverlayActive )
880 : {
881 0 : mbUserPaintOverlayEnabled = true;
882 0 : activatePaintOverlay();
883 : }
884 0 : }
885 :
886 0 : void SlideImpl::disablePaintOverlay()
887 : {
888 0 : }
889 :
890 0 : void SlideImpl::activatePaintOverlay()
891 : {
892 0 : if( mbUserPaintOverlayEnabled || !maPolygons.empty() )
893 : {
894 : mpPaintOverlay = UserPaintOverlay::create( maUserPaintColor,
895 : mdUserPaintStrokeWidth,
896 : maContext,
897 : maPolygons,
898 0 : mbUserPaintOverlayEnabled );
899 0 : mbPaintOverlayActive = true;
900 : }
901 0 : }
902 :
903 0 : void SlideImpl::drawPolygons() const
904 : {
905 0 : if( mpPaintOverlay )
906 0 : mpPaintOverlay->drawPolygons();
907 0 : }
908 :
909 0 : void SlideImpl::addPolygons(PolyPolygonVector aPolygons)
910 : {
911 0 : if(!aPolygons.empty())
912 : {
913 0 : for( PolyPolygonVector::iterator aIter=aPolygons.begin(),
914 0 : aEnd=aPolygons.end();
915 : aIter!=aEnd;
916 : ++aIter )
917 : {
918 0 : maPolygons.push_back(*aIter);
919 : }
920 : }
921 0 : }
922 :
923 0 : bool SlideImpl::isPaintOverlayActive() const
924 : {
925 0 : return mbPaintOverlayActive;
926 : }
927 :
928 0 : void SlideImpl::deactivatePaintOverlay()
929 : {
930 0 : if(mbPaintOverlayActive)
931 0 : maPolygons = mpPaintOverlay->getPolygons();
932 :
933 0 : mpPaintOverlay.reset();
934 0 : mbPaintOverlayActive = false;
935 0 : }
936 :
937 0 : ::basegfx::B2DRectangle SlideImpl::getSlideRect() const
938 : {
939 0 : const basegfx::B2ISize slideSize( getSlideSizeImpl() );
940 : return ::basegfx::B2DRectangle(0.0,0.0,
941 0 : slideSize.getX(),
942 0 : slideSize.getY());
943 : }
944 :
945 0 : void SlideImpl::endIntrinsicAnimations()
946 : {
947 0 : mpSubsettableShapeManager->notifyIntrinsicAnimationsDisabled();
948 0 : }
949 :
950 0 : void SlideImpl::startIntrinsicAnimations()
951 : {
952 0 : mpSubsettableShapeManager->notifyIntrinsicAnimationsEnabled();
953 0 : }
954 :
955 0 : bool SlideImpl::applyInitialShapeAttributes(
956 : const uno::Reference< animations::XAnimationNode >& xRootAnimationNode )
957 : {
958 0 : if( !implPrefetchShow() )
959 0 : return false;
960 :
961 0 : if( !xRootAnimationNode.is() )
962 : {
963 0 : meAnimationState = INITIAL_STATE;
964 :
965 0 : return true; // no animations - no attributes to apply -
966 : // succeeded
967 : }
968 :
969 0 : uno::Reference< animations::XTargetPropertiesCreator > xPropsCreator;
970 :
971 : try
972 : {
973 0 : ENSURE_OR_RETURN_FALSE( maContext.mxComponentContext.is(),
974 : "SlideImpl::applyInitialShapeAttributes(): Invalid component context" );
975 :
976 : uno::Reference<lang::XMultiComponentFactory> xFac(
977 0 : maContext.mxComponentContext->getServiceManager() );
978 :
979 : xPropsCreator.set(
980 0 : xFac->createInstanceWithContext(
981 : ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
982 : "com.sun.star.animations.TargetPropertiesCreator") ),
983 0 : maContext.mxComponentContext ),
984 0 : uno::UNO_QUERY_THROW );
985 : }
986 0 : catch( uno::RuntimeException& )
987 : {
988 0 : throw;
989 : }
990 0 : catch( uno::Exception& )
991 : {
992 : OSL_FAIL(
993 : rtl::OUStringToOString(
994 : comphelper::anyToString(cppu::getCaughtException()),
995 : RTL_TEXTENCODING_UTF8).getStr() );
996 :
997 : // could not determine initial shape attributes - this
998 : // is an error, as some effects might then be plainly
999 : // invisible
1000 0 : ENSURE_OR_RETURN_FALSE( false,
1001 : "SlideImpl::applyInitialShapeAttributes(): "
1002 : "couldn't create TargetPropertiesCreator." );
1003 : }
1004 :
1005 : uno::Sequence< animations::TargetProperties > aProps(
1006 0 : xPropsCreator->createInitialTargetProperties( xRootAnimationNode ) );
1007 :
1008 : // apply extracted values to our shapes
1009 0 : const ::std::size_t nSize( aProps.getLength() );
1010 0 : for( ::std::size_t i=0; i<nSize; ++i )
1011 : {
1012 0 : sal_Int16 nParaIndex( -1 );
1013 0 : uno::Reference< drawing::XShape > xShape( aProps[i].Target,
1014 0 : uno::UNO_QUERY );
1015 :
1016 0 : if( !xShape.is() )
1017 : {
1018 : // not a shape target. Maybe a ParagraphTarget?
1019 0 : presentation::ParagraphTarget aParaTarget;
1020 :
1021 0 : if( (aProps[i].Target >>= aParaTarget) )
1022 : {
1023 : // yep, ParagraphTarget found - extract shape
1024 : // and index
1025 0 : xShape = aParaTarget.Shape;
1026 0 : nParaIndex = aParaTarget.Paragraph;
1027 0 : }
1028 : }
1029 :
1030 0 : if( xShape.is() )
1031 : {
1032 0 : ShapeSharedPtr pShape( mpLayerManager->lookupShape( xShape ) );
1033 :
1034 0 : if( !pShape )
1035 : {
1036 : OSL_FAIL( "SlideImpl::applyInitialShapeAttributes(): no shape found for given target" );
1037 0 : continue;
1038 : }
1039 :
1040 : AttributableShapeSharedPtr pAttrShape(
1041 0 : ::boost::dynamic_pointer_cast< AttributableShape >( pShape ) );
1042 :
1043 0 : if( !pAttrShape )
1044 : {
1045 : OSL_FAIL( "SlideImpl::applyInitialShapeAttributes(): shape found does not "
1046 : "implement AttributableShape interface" );
1047 0 : continue;
1048 : }
1049 :
1050 0 : if( nParaIndex != -1 )
1051 : {
1052 : // our target is a paragraph subset, thus look
1053 : // this up first.
1054 0 : const DocTreeNodeSupplier& rNodeSupplier( pAttrShape->getTreeNodeSupplier() );
1055 :
1056 0 : if( rNodeSupplier.getNumberOfTreeNodes(
1057 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ) <= nParaIndex )
1058 : {
1059 : OSL_FAIL( "SlideImpl::applyInitialShapeAttributes(): shape found does not "
1060 : "provide a subset for requested paragraph index" );
1061 0 : continue;
1062 : }
1063 :
1064 0 : pAttrShape = pAttrShape->getSubset(
1065 : rNodeSupplier.getTreeNode(
1066 : nParaIndex,
1067 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ) );
1068 :
1069 0 : if( !pAttrShape )
1070 : {
1071 : OSL_FAIL( "SlideImpl::applyInitialShapeAttributes(): shape found does not "
1072 : "provide a subset for requested paragraph index" );
1073 0 : continue;
1074 : }
1075 : }
1076 :
1077 0 : const uno::Sequence< beans::NamedValue >& rShapeProps( aProps[i].Properties );
1078 0 : const ::std::size_t nShapePropSize( rShapeProps.getLength() );
1079 0 : for( ::std::size_t j=0; j<nShapePropSize; ++j )
1080 : {
1081 0 : bool bVisible=false;
1082 0 : if( rShapeProps[j].Name.equalsIgnoreAsciiCaseAsciiL(RTL_CONSTASCII_STRINGPARAM("visibility")) &&
1083 : extractValue( bVisible,
1084 0 : rShapeProps[j].Value,
1085 : pShape,
1086 0 : ::basegfx::B2DSize( getSlideSize() ) ))
1087 : {
1088 0 : pAttrShape->setVisibility( bVisible );
1089 : }
1090 : else
1091 : {
1092 : OSL_FAIL( "SlideImpl::applyInitialShapeAttributes(): Unexpected "
1093 : "(and unimplemented) property encountered" );
1094 : }
1095 0 : }
1096 : }
1097 0 : }
1098 :
1099 0 : meAnimationState = INITIAL_STATE;
1100 :
1101 0 : return true;
1102 : }
1103 :
1104 0 : bool SlideImpl::loadShapes()
1105 : {
1106 0 : if( mbShapesLoaded )
1107 0 : return true;
1108 :
1109 0 : ENSURE_OR_RETURN_FALSE( mxDrawPage.is(),
1110 : "SlideImpl::loadShapes(): Invalid draw page" );
1111 0 : ENSURE_OR_RETURN_FALSE( mpLayerManager,
1112 : "SlideImpl::loadShapes(): Invalid layer manager" );
1113 :
1114 : // fetch desired page content
1115 : // ==========================
1116 :
1117 : // also take master page content
1118 0 : uno::Reference< drawing::XDrawPage > xMasterPage;
1119 0 : uno::Reference< drawing::XShapes > xMasterPageShapes;
1120 0 : sal_Int32 nCurrCount(0);
1121 :
1122 : uno::Reference< drawing::XMasterPageTarget > xMasterPageTarget( mxDrawPage,
1123 0 : uno::UNO_QUERY );
1124 0 : if( xMasterPageTarget.is() )
1125 : {
1126 0 : xMasterPage = xMasterPageTarget->getMasterPage();
1127 : xMasterPageShapes.set( xMasterPage,
1128 0 : uno::UNO_QUERY );
1129 :
1130 0 : if( xMasterPage.is() && xMasterPageShapes.is() )
1131 : {
1132 : // TODO(P2): maybe cache master pages here (or treat the
1133 : // masterpage as a single metafile. At least currently,
1134 : // masterpages do not contain animation effects)
1135 : try
1136 : {
1137 : // load the masterpage shapes
1138 : // -------------------------------------------------------------------------
1139 : ShapeImporter aMPShapesFunctor( xMasterPage,
1140 : mxDrawPage,
1141 : mxDrawPagesSupplier,
1142 : maContext,
1143 : 0, /* shape num starts at 0 */
1144 0 : true );
1145 :
1146 : mpLayerManager->addShape(
1147 0 : aMPShapesFunctor.importBackgroundShape() );
1148 :
1149 0 : while( !aMPShapesFunctor.isImportDone() )
1150 : {
1151 : ShapeSharedPtr const& rShape(
1152 0 : aMPShapesFunctor.importShape() );
1153 0 : if( rShape )
1154 0 : mpLayerManager->addShape( rShape );
1155 0 : }
1156 0 : addPolygons(aMPShapesFunctor.getPolygons());
1157 :
1158 0 : nCurrCount = static_cast<sal_Int32>(aMPShapesFunctor.getImportedShapesCount());
1159 : }
1160 0 : catch( uno::RuntimeException& )
1161 : {
1162 0 : throw;
1163 : }
1164 0 : catch( ShapeLoadFailedException& )
1165 : {
1166 : // TODO(E2): Error handling. For now, bail out
1167 : OSL_FAIL( "SlideImpl::loadShapes(): caught ShapeLoadFailedException" );
1168 0 : return false;
1169 :
1170 : }
1171 0 : catch( uno::Exception& )
1172 : {
1173 : OSL_FAIL( rtl::OUStringToOString(
1174 : comphelper::anyToString( cppu::getCaughtException() ),
1175 : RTL_TEXTENCODING_UTF8 ).getStr() );
1176 :
1177 0 : return false;
1178 : }
1179 : }
1180 : }
1181 :
1182 : try
1183 : {
1184 : // load the normal page shapes
1185 : // -------------------------------------------------------------------------
1186 :
1187 : ShapeImporter aShapesFunctor( mxDrawPage,
1188 : mxDrawPage,
1189 : mxDrawPagesSupplier,
1190 : maContext,
1191 : nCurrCount,
1192 0 : false );
1193 :
1194 0 : while( !aShapesFunctor.isImportDone() )
1195 : {
1196 : ShapeSharedPtr const& rShape(
1197 0 : aShapesFunctor.importShape() );
1198 0 : if( rShape )
1199 0 : mpLayerManager->addShape( rShape );
1200 0 : }
1201 0 : addPolygons(aShapesFunctor.getPolygons());
1202 : }
1203 0 : catch( uno::RuntimeException& )
1204 : {
1205 0 : throw;
1206 : }
1207 0 : catch( ShapeLoadFailedException& )
1208 : {
1209 : // TODO(E2): Error handling. For now, bail out
1210 : OSL_FAIL( "SlideImpl::loadShapes(): caught ShapeLoadFailedException" );
1211 0 : return false;
1212 : }
1213 0 : catch( uno::Exception& )
1214 : {
1215 : OSL_FAIL( rtl::OUStringToOString(
1216 : comphelper::anyToString( cppu::getCaughtException() ),
1217 : RTL_TEXTENCODING_UTF8 ).getStr() );
1218 :
1219 0 : return false;
1220 : }
1221 :
1222 0 : mbShapesLoaded = true;
1223 :
1224 0 : return true;
1225 : }
1226 :
1227 0 : basegfx::B2ISize SlideImpl::getSlideSizeImpl() const
1228 : {
1229 : uno::Reference< beans::XPropertySet > xPropSet(
1230 0 : mxDrawPage, uno::UNO_QUERY_THROW );
1231 :
1232 0 : sal_Int32 nDocWidth = 0;
1233 0 : sal_Int32 nDocHeight = 0;
1234 0 : xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Width") ) ) >>= nDocWidth;
1235 0 : xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Height") ) ) >>= nDocHeight;
1236 :
1237 0 : return basegfx::B2ISize( nDocWidth, nDocHeight );
1238 : }
1239 :
1240 : } // namespace
1241 :
1242 :
1243 0 : SlideSharedPtr createSlide( const uno::Reference< drawing::XDrawPage >& xDrawPage,
1244 : const uno::Reference<drawing::XDrawPagesSupplier>& xDrawPages,
1245 : const uno::Reference< animations::XAnimationNode >& xRootNode,
1246 : EventQueue& rEventQueue,
1247 : EventMultiplexer& rEventMultiplexer,
1248 : ScreenUpdater& rScreenUpdater,
1249 : ActivitiesQueue& rActivitiesQueue,
1250 : UserEventQueue& rUserEventQueue,
1251 : CursorManager& rCursorManager,
1252 : const UnoViewContainer& rViewContainer,
1253 : const uno::Reference< uno::XComponentContext >& xComponentContext,
1254 : const ShapeEventListenerMap& rShapeListenerMap,
1255 : const ShapeCursorMap& rShapeCursorMap,
1256 : const PolyPolygonVector& rPolyPolygonVector,
1257 : RGBColor const& rUserPaintColor,
1258 : double dUserPaintStrokeWidth,
1259 : bool bUserPaintEnabled,
1260 : bool bIntrinsicAnimationsAllowed,
1261 : bool bDisableAnimationZOrder )
1262 : {
1263 : boost::shared_ptr<SlideImpl> pRet( new SlideImpl( xDrawPage, xDrawPages, xRootNode, rEventQueue,
1264 : rEventMultiplexer, rScreenUpdater,
1265 : rActivitiesQueue, rUserEventQueue,
1266 : rCursorManager, rViewContainer,
1267 : xComponentContext, rShapeListenerMap,
1268 : rShapeCursorMap, rPolyPolygonVector, rUserPaintColor,
1269 : dUserPaintStrokeWidth, bUserPaintEnabled,
1270 : bIntrinsicAnimationsAllowed,
1271 0 : bDisableAnimationZOrder ));
1272 :
1273 0 : rEventMultiplexer.addViewHandler( pRet );
1274 :
1275 0 : return pRet;
1276 : }
1277 :
1278 : } // namespace internal
1279 0 : } // namespace slideshow
1280 :
1281 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
