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 : : #include <canvas/debug.hxx>
21 : : #include <tools/diagnose_ex.h>
22 : :
23 : : #include <basegfx/matrix/b2dhommatrix.hxx>
24 : : #include <basegfx/tools/canvastools.hxx>
25 : : #include <basegfx/polygon/b2dpolygontools.hxx>
26 : : #include <basegfx/polygon/b2dpolypolygontools.hxx>
27 : :
28 : : #include <cppcanvas/basegfxfactory.hxx>
29 : :
30 : : #include <comphelper/optional.hxx>
31 : : #include <comphelper/make_shared_from_uno.hxx>
32 : :
33 : : #include <com/sun/star/rendering/XIntegerBitmap.hpp>
34 : : #include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
35 : : #include <com/sun/star/animations/TransitionType.hpp>
36 : : #include <com/sun/star/animations/TransitionSubType.hpp>
37 : : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
38 : :
39 : : #include "slidechangebase.hxx"
40 : : #include "transitionfactory.hxx"
41 : : #include "transitiontools.hxx"
42 : : #include "parametricpolypolygonfactory.hxx"
43 : : #include "animationfactory.hxx"
44 : : #include "clippingfunctor.hxx"
45 : : #include "combtransition.hxx"
46 : : #include "tools.hxx"
47 : :
48 : : #include <boost/bind.hpp>
49 : :
50 : :
51 : : /***************************************************
52 : : *** ***
53 : : *** Slide Transition Effects ***
54 : : *** ***
55 : : ***************************************************/
56 : :
57 : : using namespace com::sun::star;
58 : :
59 : : namespace slideshow {
60 : : namespace internal {
61 : :
62 : : namespace {
63 : :
64 : : // helper methods
65 : : // =============================================
66 : :
67 : 0 : void fillPage( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
68 : : const ::basegfx::B2DSize& rPageSizePixel,
69 : : const RGBColor& rFillColor )
70 : : {
71 : : // need to render without any transformation (we
72 : : // assume rPageSizePixel to represent device units)
73 : : const ::cppcanvas::CanvasSharedPtr pDevicePixelCanvas(
74 : 0 : rDestinationCanvas->clone() );
75 : 0 : pDevicePixelCanvas->setTransformation( ::basegfx::B2DHomMatrix() );
76 : :
77 : : // TODO(F2): Properly respect clip here.
78 : : // Might have to be transformed, too.
79 : : const ::basegfx::B2DHomMatrix aViewTransform(
80 : 0 : rDestinationCanvas->getTransformation() );
81 : : const ::basegfx::B2DPoint aOutputPosPixel(
82 : 0 : aViewTransform * ::basegfx::B2DPoint() );
83 : :
84 : : fillRect( pDevicePixelCanvas,
85 : : ::basegfx::B2DRectangle(
86 : : aOutputPosPixel.getX(),
87 : : aOutputPosPixel.getY(),
88 : 0 : aOutputPosPixel.getX() + rPageSizePixel.getX(),
89 : 0 : aOutputPosPixel.getY() + rPageSizePixel.getY() ),
90 : 0 : rFillColor.getIntegerColor() );
91 : 0 : }
92 : :
93 : : class PluginSlideChange: public SlideChangeBase
94 : : {
95 : : struct TransitionViewPair {
96 : : uno::Reference<presentation::XTransition> mxTransition;
97 : : UnoViewSharedPtr mpView;
98 : :
99 : 0 : TransitionViewPair( uno::Reference<presentation::XTransition> xTransition, const UnoViewSharedPtr pView )
100 : 0 : {
101 : 0 : mxTransition = xTransition;
102 : 0 : mpView = pView;
103 : 0 : }
104 : :
105 : 0 : ~TransitionViewPair()
106 : 0 : {
107 : 0 : mxTransition.clear();
108 : 0 : mpView.reset();
109 : 0 : }
110 : :
111 : 0 : void update( double t )
112 : : {
113 : 0 : mxTransition->update( t );
114 : 0 : }
115 : : };
116 : :
117 : : public:
118 : : /** Create a new SlideChanger, for the given leaving and
119 : : entering slide bitmaps, which uses super secret OpenGL
120 : : stuff.
121 : : */
122 : 0 : PluginSlideChange( sal_Int16 nTransitionType,
123 : : sal_Int16 nTransitionSubType,
124 : : boost::optional<SlideSharedPtr> const& leavingSlide_,
125 : : const SlideSharedPtr& pEnteringSlide,
126 : : const UnoViewContainer& rViewContainer,
127 : : ScreenUpdater& rScreenUpdater,
128 : : const uno::Reference<
129 : : presentation::XTransitionFactory>& xFactory,
130 : : const SoundPlayerSharedPtr& pSoundPlayer,
131 : : EventMultiplexer& rEventMultiplexer) :
132 : : SlideChangeBase( leavingSlide_,
133 : : pEnteringSlide,
134 : : pSoundPlayer,
135 : : rViewContainer,
136 : : rScreenUpdater,
137 : : rEventMultiplexer ),
138 : : maTransitions(),
139 : : mbSuccess( false ),
140 : : mnTransitionType( nTransitionType ),
141 : : mnTransitionSubType( nTransitionSubType ),
142 : 0 : mxFactory( xFactory )
143 : : {
144 : : // create one transition per view
145 : 0 : UnoViewVector::const_iterator aCurrView (rViewContainer.begin());
146 : 0 : const UnoViewVector::const_iterator aEnd(rViewContainer.end());
147 : 0 : while( aCurrView != aEnd )
148 : : {
149 : 0 : if(! addTransition( *aCurrView ) )
150 : 0 : return;
151 : :
152 : 0 : ENSURE_OR_THROW(maTransitions.back() && maTransitions.back()->mxTransition.is(),
153 : : "Failed to create plugin transition");
154 : 0 : ++aCurrView;
155 : : }
156 : 0 : mbSuccess = true;
157 : : }
158 : :
159 : 0 : ~PluginSlideChange()
160 : 0 : {
161 : 0 : mxFactory.clear();
162 : :
163 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aCurrView (maTransitions.begin());
164 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aEnd(maTransitions.end());
165 : 0 : while( aCurrView != aEnd )
166 : : {
167 : 0 : delete (*aCurrView);
168 : 0 : ++aCurrView;
169 : : }
170 : 0 : maTransitions.clear();
171 : 0 : }
172 : :
173 : 0 : bool addTransition( const UnoViewSharedPtr& rView )
174 : : {
175 : 0 : uno::Reference<presentation::XTransition> rTransition = mxFactory->createTransition(
176 : : mnTransitionType,
177 : : mnTransitionSubType,
178 : 0 : rView->getUnoView(),
179 : : getLeavingBitmap(ViewEntry(rView))->getXBitmap(),
180 : 0 : getEnteringBitmap(ViewEntry(rView))->getXBitmap() );
181 : :
182 : 0 : if( rTransition.is() )
183 : 0 : maTransitions.push_back( new TransitionViewPair( rTransition, rView ) );
184 : : else
185 : 0 : return false;
186 : :
187 : 0 : return true;
188 : : }
189 : :
190 : 0 : virtual bool operator()( double t )
191 : : {
192 : : std::for_each(maTransitions.begin(),
193 : : maTransitions.end(),
194 : : boost::bind( &TransitionViewPair::update,
195 : 0 : _1, t) );
196 : 0 : return true;
197 : : }
198 : :
199 : 0 : bool Success()
200 : : {
201 : 0 : return mbSuccess;
202 : : }
203 : :
204 : : // ViewEventHandler
205 : 0 : virtual void viewAdded( const UnoViewSharedPtr& rView )
206 : : {
207 : : OSL_TRACE("PluginSlideChange viewAdded");
208 : 0 : SlideChangeBase::viewAdded( rView );
209 : :
210 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aCurrView (maTransitions.begin());
211 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aEnd(maTransitions.end());
212 : 0 : bool bKnown = false;
213 : 0 : while( aCurrView != aEnd )
214 : : {
215 : 0 : if( (*aCurrView)->mpView == rView )
216 : : {
217 : 0 : bKnown = true;
218 : 0 : break;
219 : : }
220 : 0 : ++aCurrView;
221 : : }
222 : :
223 : 0 : if( !bKnown )
224 : : {
225 : : OSL_TRACE("need to be added");
226 : 0 : addTransition( rView );
227 : : }
228 : 0 : }
229 : :
230 : 0 : virtual void viewRemoved( const UnoViewSharedPtr& rView )
231 : : {
232 : : OSL_TRACE("PluginSlideChange viewRemoved");
233 : 0 : SlideChangeBase::viewRemoved( rView );
234 : :
235 : 0 : ::std::vector< TransitionViewPair* >::iterator aCurrView (maTransitions.begin());
236 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aEnd(maTransitions.end());
237 : 0 : while( aCurrView != aEnd )
238 : : {
239 : 0 : if( (*aCurrView)->mpView == rView )
240 : : {
241 : : OSL_TRACE( "view removed" );
242 : 0 : delete (*aCurrView);
243 : 0 : maTransitions.erase( aCurrView );
244 : 0 : break;
245 : : }
246 : 0 : ++aCurrView;
247 : : }
248 : 0 : }
249 : :
250 : 0 : virtual void viewChanged( const UnoViewSharedPtr& rView )
251 : : {
252 : : OSL_TRACE("PluginSlideChange viewChanged");
253 : 0 : SlideChangeBase::viewChanged( rView );
254 : :
255 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aCurrView (maTransitions.begin());
256 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aEnd(maTransitions.end());
257 : 0 : while( aCurrView != aEnd )
258 : : {
259 : 0 : if( (*aCurrView)->mpView == rView )
260 : : {
261 : : OSL_TRACE( "view changed" );
262 : 0 : (*aCurrView)->mxTransition->viewChanged( rView->getUnoView(),
263 : : getLeavingBitmap(ViewEntry(rView))->getXBitmap(),
264 : 0 : getEnteringBitmap(ViewEntry(rView))->getXBitmap() );
265 : : }
266 : : else
267 : : OSL_TRACE( "view did not changed" );
268 : :
269 : 0 : ++aCurrView;
270 : : }
271 : 0 : }
272 : :
273 : 0 : virtual void viewsChanged()
274 : : {
275 : : OSL_TRACE("PluginSlideChange viewsChanged");
276 : 0 : SlideChangeBase::viewsChanged();
277 : :
278 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aCurrView (maTransitions.begin());
279 : 0 : ::std::vector< TransitionViewPair* >::const_iterator aEnd(maTransitions.end());
280 : 0 : while( aCurrView != aEnd )
281 : : {
282 : : OSL_TRACE( "view changed" );
283 : 0 : (*aCurrView)->mxTransition->viewChanged( (*aCurrView)->mpView->getUnoView(),
284 : 0 : getLeavingBitmap(ViewEntry((*aCurrView)->mpView))->getXBitmap(),
285 : 0 : getEnteringBitmap(ViewEntry((*aCurrView)->mpView))->getXBitmap() );
286 : 0 : ++aCurrView;
287 : : }
288 : 0 : }
289 : :
290 : : private:
291 : : // One transition object per view
292 : : std::vector< TransitionViewPair* > maTransitions;
293 : :
294 : : // bool
295 : : bool mbSuccess;
296 : :
297 : : sal_Int16 mnTransitionType;
298 : : sal_Int16 mnTransitionSubType;
299 : :
300 : : uno::Reference<presentation::XTransitionFactory> mxFactory;
301 : : };
302 : :
303 : 0 : class ClippedSlideChange : public SlideChangeBase
304 : : {
305 : : public:
306 : : /** Create a new SlideChanger, for the given leaving and
307 : : entering slide bitmaps, which applies the given clip
308 : : polygon.
309 : : */
310 : 0 : ClippedSlideChange(
311 : : const SlideSharedPtr& pEnteringSlide,
312 : : const ParametricPolyPolygonSharedPtr& rPolygon,
313 : : const TransitionInfo& rTransitionInfo,
314 : : const UnoViewContainer& rViewContainer,
315 : : ScreenUpdater& rScreenUpdater,
316 : : EventMultiplexer& rEventMultiplexer,
317 : : bool bDirectionForward,
318 : : const SoundPlayerSharedPtr& pSoundPlayer ) :
319 : : SlideChangeBase(
320 : : // leaving bitmap is empty, we're leveraging the fact that the
321 : : // old slide is still displayed in the background:
322 : : boost::optional<SlideSharedPtr>(),
323 : : pEnteringSlide,
324 : : pSoundPlayer,
325 : : rViewContainer,
326 : : rScreenUpdater,
327 : : rEventMultiplexer ),
328 : : maClippingFunctor( rPolygon,
329 : : rTransitionInfo,
330 : : bDirectionForward,
331 : 0 : true )
332 : 0 : {}
333 : :
334 : : virtual void performIn(
335 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
336 : : const ViewEntry& rViewEntry,
337 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
338 : : double t );
339 : :
340 : : virtual void performOut(
341 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
342 : : const ViewEntry& rViewEntry,
343 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
344 : : double t );
345 : :
346 : : private:
347 : : ClippingFunctor maClippingFunctor;
348 : : };
349 : :
350 : 0 : void ClippedSlideChange::performIn(
351 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
352 : : const ViewEntry& rViewEntry,
353 : : const ::cppcanvas::CanvasSharedPtr& /*rDestinationCanvas*/,
354 : : double t )
355 : : {
356 : : // #i46602# Better work in device coordinate space here,
357 : : // otherwise, we too easily suffer from roundoffs. Apart from
358 : : // that, getEnteringSizePixel() _guarantees_ to cover the whole
359 : : // slide bitmap. There's a catch, though: this removes any effect
360 : : // of the view transformation (e.g. rotation) from the transition.
361 : 0 : rSprite->setClipPixel(
362 : : maClippingFunctor( t,
363 : 0 : ::basegfx::B2DSize( getEnteringSlideSizePixel(rViewEntry.mpView) ) ) );
364 : 0 : }
365 : :
366 : 0 : void ClippedSlideChange::performOut(
367 : : const ::cppcanvas::CustomSpriteSharedPtr& /*rSprite*/,
368 : : const ViewEntry& /*rViewEntry*/,
369 : : const ::cppcanvas::CanvasSharedPtr& /*rDestinationCanvas*/,
370 : : double /*t*/ )
371 : : {
372 : : // not needed here
373 : 0 : }
374 : :
375 : :
376 : 0 : class FadingSlideChange : public SlideChangeBase
377 : : {
378 : : public:
379 : : /** Create a new SlideChanger, for the given leaving and
380 : : entering slides, which applies a fade effect.
381 : : */
382 : 0 : FadingSlideChange(
383 : : boost::optional<SlideSharedPtr> const & leavingSlide,
384 : : const SlideSharedPtr& pEnteringSlide,
385 : : boost::optional<RGBColor> const& rFadeColor,
386 : : const SoundPlayerSharedPtr& pSoundPlayer,
387 : : const UnoViewContainer& rViewContainer,
388 : : ScreenUpdater& rScreenUpdater,
389 : : EventMultiplexer& rEventMultiplexer )
390 : : : SlideChangeBase( leavingSlide,
391 : : pEnteringSlide,
392 : : pSoundPlayer,
393 : : rViewContainer,
394 : : rScreenUpdater,
395 : : rEventMultiplexer ),
396 : 0 : maFadeColor( rFadeColor )
397 : 0 : {}
398 : :
399 : : virtual void prepareForRun(
400 : : const ViewEntry& rViewEntry,
401 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas );
402 : :
403 : : virtual void performIn(
404 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
405 : : const ViewEntry& rViewEntry,
406 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
407 : : double t );
408 : :
409 : : virtual void performOut(
410 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
411 : : const ViewEntry& rViewEntry,
412 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
413 : : double t );
414 : :
415 : : private:
416 : : const boost::optional< RGBColor > maFadeColor;
417 : : };
418 : :
419 : 0 : void FadingSlideChange::prepareForRun(
420 : : const ViewEntry& rViewEntry,
421 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas )
422 : : {
423 : 0 : if ( maFadeColor )
424 : : {
425 : : // clear page to given fade color. 'Leaving' slide is
426 : : // painted atop of that, but slowly fading out.
427 : : fillPage( rDestinationCanvas,
428 : : ::basegfx::B2DSize( getEnteringSlideSizePixel( rViewEntry.mpView ) ),
429 : 0 : *maFadeColor );
430 : : }
431 : 0 : }
432 : :
433 : 0 : void FadingSlideChange::performIn(
434 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
435 : : const ViewEntry& /*rViewEntry*/,
436 : : const ::cppcanvas::CanvasSharedPtr& /*rDestinationCanvas*/,
437 : : double t )
438 : : {
439 : 0 : ENSURE_OR_THROW(
440 : : rSprite,
441 : : "FadingSlideChange::performIn(): Invalid sprite" );
442 : :
443 : 0 : if( maFadeColor )
444 : : // After half of the active time, fade in new slide
445 : 0 : rSprite->setAlpha( t > 0.5 ? 2.0*(t-0.5) : 0.0 );
446 : : else
447 : : // Fade in new slide over full active time
448 : 0 : rSprite->setAlpha( t );
449 : 0 : }
450 : :
451 : 0 : void FadingSlideChange::performOut(
452 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
453 : : const ViewEntry& /* rViewEntry */,
454 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
455 : : double t )
456 : : {
457 : 0 : ENSURE_OR_THROW(
458 : : rSprite,
459 : : "FadingSlideChange::performOut(): Invalid sprite" );
460 : 0 : ENSURE_OR_THROW(
461 : : rDestinationCanvas,
462 : : "FadingSlideChange::performOut(): Invalid dest canvas" );
463 : :
464 : : // only needed for color fades
465 : 0 : if( maFadeColor )
466 : : {
467 : : // Until half of the active time, fade out old
468 : : // slide. After half of the active time, old slide
469 : : // will be invisible.
470 : 0 : rSprite->setAlpha( t > 0.5 ? 0.0 : 2.0*(0.5-t) );
471 : : }
472 : 0 : }
473 : :
474 : 0 : class CutSlideChange : public SlideChangeBase
475 : : {
476 : : public:
477 : : /** Create a new SlideChanger, for the given leaving and
478 : : entering slides, which applies a cut effect.
479 : : */
480 : 0 : CutSlideChange(
481 : : boost::optional<SlideSharedPtr> const & leavingSlide,
482 : : const SlideSharedPtr& pEnteringSlide,
483 : : const RGBColor& rFadeColor,
484 : : const SoundPlayerSharedPtr& pSoundPlayer,
485 : : const UnoViewContainer& rViewContainer,
486 : : ScreenUpdater& rScreenUpdater,
487 : : EventMultiplexer& rEventMultiplexer )
488 : : : SlideChangeBase( leavingSlide,
489 : : pEnteringSlide,
490 : : pSoundPlayer,
491 : : rViewContainer,
492 : : rScreenUpdater,
493 : : rEventMultiplexer ),
494 : 0 : maFadeColor( rFadeColor )
495 : 0 : {}
496 : :
497 : : virtual void prepareForRun(
498 : : const ViewEntry& rViewEntry,
499 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas );
500 : :
501 : : virtual void performIn(
502 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
503 : : const ViewEntry& rViewEntry,
504 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
505 : : double t );
506 : :
507 : : virtual void performOut(
508 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
509 : : const ViewEntry& rViewEntry,
510 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
511 : : double t );
512 : :
513 : : private:
514 : : RGBColor maFadeColor;
515 : : };
516 : :
517 : 0 : void CutSlideChange::prepareForRun(
518 : : const ViewEntry& rViewEntry,
519 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas )
520 : : {
521 : : // clear page to given fade color. 'Leaving' slide is
522 : : // painted atop of that
523 : : fillPage( rDestinationCanvas,
524 : : ::basegfx::B2DSize( getEnteringSlideSizePixel( rViewEntry.mpView ) ),
525 : 0 : maFadeColor );
526 : 0 : }
527 : :
528 : 0 : void CutSlideChange::performIn(
529 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
530 : : const ViewEntry& /*rViewEntry*/,
531 : : const ::cppcanvas::CanvasSharedPtr& /*rDestinationCanvas*/,
532 : : double t )
533 : : {
534 : 0 : ENSURE_OR_THROW(
535 : : rSprite,
536 : : "CutSlideChange::performIn(): Invalid sprite" );
537 : :
538 : : // After 2/3rd of the active time, display new slide
539 : 0 : rSprite->setAlpha( t > 2/3.0 ? 1.0 : 0.0 );
540 : 0 : }
541 : :
542 : 0 : void CutSlideChange::performOut(
543 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
544 : : const ViewEntry& /* rViewEntry */,
545 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
546 : : double t )
547 : : {
548 : 0 : ENSURE_OR_THROW(
549 : : rSprite,
550 : : "CutSlideChange::performOut(): Invalid sprite" );
551 : 0 : ENSURE_OR_THROW(
552 : : rDestinationCanvas,
553 : : "CutSlideChange::performOut(): Invalid dest canvas" );
554 : :
555 : : // Until 1/3rd of the active time, display old slide.
556 : 0 : rSprite->setAlpha( t > 1/3.0 ? 0.0 : 1.0 );
557 : 0 : }
558 : :
559 : 0 : class MovingSlideChange : public SlideChangeBase
560 : : {
561 : : /// Direction vector for leaving slide,
562 : : const ::basegfx::B2DVector maLeavingDirection;
563 : :
564 : : /// Direction vector for entering slide,
565 : : const ::basegfx::B2DVector maEnteringDirection;
566 : :
567 : : public:
568 : : /** Create a new SlideChanger, for the given entering slide
569 : : bitmaps, which performes a moving slide change effect
570 : :
571 : : @param rLeavingDirection
572 : : Direction vector. The move is performed along this
573 : : direction vector, starting at a position where the leaving
574 : : slide is fully visible, and ending at a position where the
575 : : leaving slide is just not visible. The vector must have
576 : : unit length.
577 : :
578 : : @param rEnteringDirection
579 : : Direction vector. The move is performed along this
580 : : direction vector, starting at a position where the
581 : : entering slide is just not visible, and ending at the
582 : : final slide position. The vector must have unit length.
583 : : */
584 : 0 : MovingSlideChange(
585 : : const boost::optional<SlideSharedPtr>& leavingSlide,
586 : : const SlideSharedPtr& pEnteringSlide,
587 : : const SoundPlayerSharedPtr& pSoundPlayer,
588 : : const UnoViewContainer& rViewContainer,
589 : : ScreenUpdater& rScreenUpdater,
590 : : EventMultiplexer& rEventMultiplexer,
591 : : const ::basegfx::B2DVector& rLeavingDirection,
592 : : const ::basegfx::B2DVector& rEnteringDirection )
593 : : : SlideChangeBase(
594 : : leavingSlide, pEnteringSlide, pSoundPlayer,
595 : : rViewContainer, rScreenUpdater, rEventMultiplexer,
596 : : // Optimization: when leaving bitmap is given,
597 : : // but it does not move, don't create sprites for it,
598 : : // we simply paint it once at startup:
599 : 0 : !rLeavingDirection.equalZero() /* bCreateLeavingSprites */,
600 : 0 : !rEnteringDirection.equalZero() /* bCreateEnteringSprites */ ),
601 : : // TODO(F1): calc correct length of direction
602 : : // vector. Directions not strictly horizontal or vertical
603 : : // must travel a longer distance.
604 : : maLeavingDirection( rLeavingDirection ),
605 : : // TODO(F1): calc correct length of direction
606 : : // vector. Directions not strictly horizontal or vertical
607 : : // must travel a longer distance.
608 : 0 : maEnteringDirection( rEnteringDirection )
609 : 0 : {}
610 : :
611 : : virtual void prepareForRun(
612 : : const ViewEntry& rViewEntry,
613 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas );
614 : :
615 : : virtual void performIn(
616 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
617 : : const ViewEntry& rViewEntry,
618 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
619 : : double t );
620 : :
621 : : virtual void performOut(
622 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
623 : : const ViewEntry& rViewEntry,
624 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
625 : : double t );
626 : : };
627 : :
628 : 0 : void MovingSlideChange::prepareForRun(
629 : : const ViewEntry& rViewEntry,
630 : : const cppcanvas::CanvasSharedPtr& rDestinationCanvas )
631 : : {
632 : 0 : if ( maLeavingDirection.equalZero() )
633 : 0 : renderBitmap( getLeavingBitmap( rViewEntry ), rDestinationCanvas );
634 : 0 : else if ( maEnteringDirection.equalZero() )
635 : 0 : renderBitmap( getEnteringBitmap( rViewEntry ), rDestinationCanvas );
636 : 0 : }
637 : :
638 : 0 : void MovingSlideChange::performIn(
639 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
640 : : const ViewEntry& rViewEntry,
641 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
642 : : double t )
643 : : {
644 : : // intro sprite moves:
645 : :
646 : 0 : ENSURE_OR_THROW(
647 : : rSprite,
648 : : "MovingSlideChange::performIn(): Invalid sprite" );
649 : 0 : ENSURE_OR_THROW(
650 : : rDestinationCanvas,
651 : : "MovingSlideChange::performIn(): Invalid dest canvas" );
652 : :
653 : : // TODO(F1): This does not account for non-translational
654 : : // transformations! If the canvas is rotated, we still
655 : : // move the sprite unrotated (which might or might not
656 : : // produce the intended effect).
657 : : const basegfx::B2DHomMatrix aViewTransform(
658 : 0 : rDestinationCanvas->getTransformation() );
659 : : const basegfx::B2DPoint aPageOrigin(
660 : 0 : aViewTransform * basegfx::B2DPoint() );
661 : :
662 : : // move sprite
663 : 0 : rSprite->movePixel(
664 : : aPageOrigin +
665 : : ((t - 1.0) *
666 : : ::basegfx::B2DSize( getEnteringSlideSizePixel(rViewEntry.mpView) ) *
667 : 0 : maEnteringDirection) );
668 : 0 : }
669 : :
670 : 0 : void MovingSlideChange::performOut(
671 : : const ::cppcanvas::CustomSpriteSharedPtr& rSprite,
672 : : const ViewEntry& rViewEntry,
673 : : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
674 : : double t )
675 : : {
676 : : // outro sprite moves:
677 : :
678 : 0 : ENSURE_OR_THROW(
679 : : rSprite,
680 : : "MovingSlideChange::performOut(): Invalid sprite" );
681 : 0 : ENSURE_OR_THROW(
682 : : rDestinationCanvas,
683 : : "MovingSlideChange::performOut(): Invalid dest canvas" );
684 : :
685 : : // TODO(F1): This does not account for non-translational
686 : : // transformations! If the canvas is rotated, we still
687 : : // move the sprite unrotated (which might or might not
688 : : // produce the intended effect).
689 : : const basegfx::B2DHomMatrix aViewTransform(
690 : 0 : rDestinationCanvas->getTransformation() );
691 : : const basegfx::B2DPoint aPageOrigin(
692 : 0 : aViewTransform * basegfx::B2DPoint() );
693 : :
694 : : // move sprite
695 : 0 : rSprite->movePixel(
696 : : aPageOrigin + (t *
697 : : ::basegfx::B2DSize( getEnteringSlideSizePixel(rViewEntry.mpView) ) *
698 : 0 : maLeavingDirection) );
699 : 0 : }
700 : :
701 : :
702 : 0 : NumberAnimationSharedPtr createPushWipeTransition(
703 : : boost::optional<SlideSharedPtr> const & leavingSlide_,
704 : : const SlideSharedPtr& pEnteringSlide,
705 : : const UnoViewContainer& rViewContainer,
706 : : ScreenUpdater& rScreenUpdater,
707 : : EventMultiplexer& rEventMultiplexer,
708 : : sal_Int16 /*nTransitionType*/,
709 : : sal_Int16 nTransitionSubType,
710 : : bool /*bTransitionDirection*/,
711 : : const SoundPlayerSharedPtr& pSoundPlayer )
712 : : {
713 : 0 : boost::optional<SlideSharedPtr> leavingSlide; // no bitmap
714 : 0 : if (leavingSlide_ && (*leavingSlide_).get() != 0)
715 : : {
716 : : // opt: only page, if we've an
717 : : // actual slide to move out here. We
718 : : // _don't_ need a fake black background
719 : : // bitmap, neither for push nor for comb
720 : : // wipes.
721 : 0 : leavingSlide = leavingSlide_;
722 : : }
723 : :
724 : : // setup direction vector
725 : 0 : bool bComb( false );
726 : 0 : ::basegfx::B2DVector aDirection;
727 : 0 : switch( nTransitionSubType )
728 : : {
729 : : default:
730 : : OSL_FAIL(
731 : : "createPushWipeTransition(): Unexpected transition "
732 : : "subtype for animations::TransitionType::PUSHWIPE "
733 : : "transitions" );
734 : 0 : return NumberAnimationSharedPtr();
735 : :
736 : : case animations::TransitionSubType::FROMTOP:
737 : 0 : aDirection = ::basegfx::B2DVector( 0.0, 1.0 );
738 : 0 : break;
739 : :
740 : : case animations::TransitionSubType::FROMBOTTOM:
741 : 0 : aDirection = ::basegfx::B2DVector( 0.0, -1.0 );
742 : 0 : break;
743 : :
744 : : case animations::TransitionSubType::FROMLEFT:
745 : 0 : aDirection = ::basegfx::B2DVector( 1.0, 0.0 );
746 : 0 : break;
747 : :
748 : : case animations::TransitionSubType::FROMRIGHT:
749 : 0 : aDirection = ::basegfx::B2DVector( -1.0, 0.0 );
750 : 0 : break;
751 : :
752 : : case animations::TransitionSubType::FROMBOTTOMRIGHT:
753 : 0 : aDirection = ::basegfx::B2DVector( -1.0, -1.0 );
754 : 0 : break;
755 : :
756 : : case animations::TransitionSubType::FROMBOTTOMLEFT:
757 : 0 : aDirection = ::basegfx::B2DVector( 1.0, -1.0 );
758 : 0 : break;
759 : :
760 : : case animations::TransitionSubType::FROMTOPRIGHT:
761 : 0 : aDirection = ::basegfx::B2DVector( -1.0, 1.0 );
762 : 0 : break;
763 : :
764 : : case animations::TransitionSubType::FROMTOPLEFT:
765 : 0 : aDirection = ::basegfx::B2DVector( 1.0, 1.0 );
766 : 0 : break;
767 : :
768 : : case animations::TransitionSubType::COMBHORIZONTAL:
769 : 0 : aDirection = ::basegfx::B2DVector( 1.0, 0.0 );
770 : 0 : bComb = true;
771 : 0 : break;
772 : :
773 : : case animations::TransitionSubType::COMBVERTICAL:
774 : 0 : aDirection = ::basegfx::B2DVector( 0.0, 1.0 );
775 : 0 : bComb = true;
776 : 0 : break;
777 : : }
778 : :
779 : 0 : if( bComb )
780 : : {
781 : : return NumberAnimationSharedPtr(
782 : : new CombTransition( leavingSlide,
783 : : pEnteringSlide,
784 : : pSoundPlayer,
785 : : rViewContainer,
786 : : rScreenUpdater,
787 : : rEventMultiplexer,
788 : : aDirection,
789 : 0 : 24 /* comb with 12 stripes */ ));
790 : : }
791 : : else
792 : : {
793 : : return NumberAnimationSharedPtr(
794 : : new MovingSlideChange( leavingSlide,
795 : : pEnteringSlide,
796 : : pSoundPlayer,
797 : : rViewContainer,
798 : : rScreenUpdater,
799 : : rEventMultiplexer,
800 : : aDirection,
801 : 0 : aDirection ));
802 : 0 : }
803 : : }
804 : :
805 : 0 : NumberAnimationSharedPtr createSlideWipeTransition(
806 : : boost::optional<SlideSharedPtr> const & leavingSlide,
807 : : const SlideSharedPtr& pEnteringSlide,
808 : : const UnoViewContainer& rViewContainer,
809 : : ScreenUpdater& rScreenUpdater,
810 : : EventMultiplexer& rEventMultiplexer,
811 : : sal_Int16 /*nTransitionType*/,
812 : : sal_Int16 nTransitionSubType,
813 : : bool bTransitionDirection,
814 : : const SoundPlayerSharedPtr& pSoundPlayer )
815 : : {
816 : : // setup 'in' direction vector
817 : 0 : ::basegfx::B2DVector aInDirection;
818 : 0 : switch( nTransitionSubType )
819 : : {
820 : : default:
821 : : OSL_FAIL(
822 : : "createSlideWipeTransition(): Unexpected transition "
823 : : "subtype for animations::TransitionType::SLIDEWIPE "
824 : : "transitions" );
825 : 0 : return NumberAnimationSharedPtr();
826 : :
827 : : case animations::TransitionSubType::FROMTOP:
828 : 0 : aInDirection = ::basegfx::B2DVector( 0.0, 1.0 );
829 : 0 : break;
830 : :
831 : : case animations::TransitionSubType::FROMRIGHT:
832 : 0 : aInDirection = ::basegfx::B2DVector( -1.0, 0.0 );
833 : 0 : break;
834 : :
835 : : case animations::TransitionSubType::FROMLEFT:
836 : 0 : aInDirection = ::basegfx::B2DVector( 1.0, 0.0 );
837 : 0 : break;
838 : :
839 : : case animations::TransitionSubType::FROMBOTTOM:
840 : 0 : aInDirection = ::basegfx::B2DVector( 0.0, -1.0 );
841 : 0 : break;
842 : :
843 : : case animations::TransitionSubType::FROMBOTTOMRIGHT:
844 : 0 : aInDirection = ::basegfx::B2DVector( -1.0, -1.0 );
845 : 0 : break;
846 : :
847 : : case animations::TransitionSubType::FROMBOTTOMLEFT:
848 : 0 : aInDirection = ::basegfx::B2DVector( 1.0, -1.0 );
849 : 0 : break;
850 : :
851 : : case animations::TransitionSubType::FROMTOPRIGHT:
852 : 0 : aInDirection = ::basegfx::B2DVector( -1.0, 1.0 );
853 : 0 : break;
854 : :
855 : : case animations::TransitionSubType::FROMTOPLEFT:
856 : 0 : aInDirection = ::basegfx::B2DVector( 1.0, 1.0 );
857 : 0 : break;
858 : : }
859 : :
860 : 0 : if( bTransitionDirection )
861 : : {
862 : : // normal, 'forward' slide wipe effect. Since the old
863 : : // content is still on screen (and does not move), we omit
864 : : // the 'leaving' slide.
865 : : // =======================================================
866 : :
867 : : return NumberAnimationSharedPtr(
868 : : new MovingSlideChange(
869 : : boost::optional<SlideSharedPtr>() /* no slide */,
870 : : pEnteringSlide,
871 : : pSoundPlayer,
872 : : rViewContainer,
873 : : rScreenUpdater,
874 : : rEventMultiplexer,
875 : : basegfx::B2DVector(),
876 : 0 : aInDirection ));
877 : : }
878 : : else
879 : : {
880 : : // 'reversed' slide wipe effect. Reverse for slide wipes
881 : : // means, that the new slide is in the back, statically,
882 : : // and the old one is moving off in the foreground.
883 : : // =======================================================
884 : :
885 : : return NumberAnimationSharedPtr(
886 : : new MovingSlideChange( leavingSlide,
887 : : pEnteringSlide,
888 : : pSoundPlayer,
889 : : rViewContainer,
890 : : rScreenUpdater,
891 : : rEventMultiplexer,
892 : : aInDirection,
893 : 0 : basegfx::B2DVector() ));
894 : 0 : }
895 : : }
896 : :
897 : 0 : NumberAnimationSharedPtr createPluginTransition(
898 : : sal_Int16 nTransitionType,
899 : : sal_Int16 nTransitionSubType,
900 : : boost::optional<SlideSharedPtr> const& pLeavingSlide,
901 : : const SlideSharedPtr& pEnteringSlide,
902 : : const UnoViewContainer& rViewContainer,
903 : : ScreenUpdater& rScreenUpdater,
904 : : const uno::Reference<
905 : : presentation::XTransitionFactory>& xFactory,
906 : : const SoundPlayerSharedPtr& pSoundPlayer,
907 : : EventMultiplexer& rEventMultiplexer)
908 : : {
909 : : PluginSlideChange* pTransition =
910 : : new PluginSlideChange(
911 : : nTransitionType,
912 : : nTransitionSubType,
913 : : pLeavingSlide,
914 : : pEnteringSlide,
915 : : rViewContainer,
916 : : rScreenUpdater,
917 : : xFactory,
918 : : pSoundPlayer,
919 : 0 : rEventMultiplexer );
920 : :
921 : 0 : if( pTransition->Success() )
922 : 0 : return NumberAnimationSharedPtr( pTransition );
923 : : else
924 : : {
925 : 0 : delete pTransition;
926 : 0 : return NumberAnimationSharedPtr();
927 : : }
928 : : }
929 : :
930 : : } // anon namespace
931 : :
932 : :
933 : 0 : NumberAnimationSharedPtr TransitionFactory::createSlideTransition(
934 : : const SlideSharedPtr& pLeavingSlide,
935 : : const SlideSharedPtr& pEnteringSlide,
936 : : const UnoViewContainer& rViewContainer,
937 : : ScreenUpdater& rScreenUpdater,
938 : : EventMultiplexer& rEventMultiplexer,
939 : : const uno::Reference<presentation::XTransitionFactory>& xOptionalFactory,
940 : : sal_Int16 nTransitionType,
941 : : sal_Int16 nTransitionSubType,
942 : : bool bTransitionDirection,
943 : : const RGBColor& rTransitionFadeColor,
944 : : const SoundPlayerSharedPtr& pSoundPlayer )
945 : : {
946 : : // xxx todo: change to TransitionType::NONE, TransitionSubType::NONE:
947 : 0 : if (nTransitionType == 0 && nTransitionSubType == 0) {
948 : : // just play sound, no slide transition:
949 : 0 : if (pSoundPlayer) {
950 : 0 : pSoundPlayer->startPlayback();
951 : : // xxx todo: for now, presentation.cxx takes care about the slide
952 : : // #i50492# transition sound object, so just release it here
953 : : }
954 : 0 : return NumberAnimationSharedPtr();
955 : : }
956 : :
957 : 0 : ENSURE_OR_THROW(
958 : : pEnteringSlide,
959 : : "TransitionFactory::createSlideTransition(): Invalid entering slide" );
960 : :
961 : 0 : if( xOptionalFactory.is() &&
962 : 0 : xOptionalFactory->hasTransition(nTransitionType, nTransitionSubType) )
963 : : {
964 : : // #i82460# - optional plugin factory claims this transition. delegate.
965 : : NumberAnimationSharedPtr pTransition(
966 : : createPluginTransition(
967 : : nTransitionType,
968 : : nTransitionSubType,
969 : : comphelper::make_optional(pLeavingSlide),
970 : : pEnteringSlide,
971 : : rViewContainer,
972 : : rScreenUpdater,
973 : : xOptionalFactory,
974 : : pSoundPlayer,
975 : 0 : rEventMultiplexer ));
976 : :
977 : 0 : if( pTransition.get() )
978 : 0 : return pTransition;
979 : : }
980 : :
981 : : const TransitionInfo* pTransitionInfo(
982 : 0 : getTransitionInfo( nTransitionType, nTransitionSubType ) );
983 : :
984 : 0 : if( pTransitionInfo != NULL )
985 : : {
986 : 0 : switch( pTransitionInfo->meTransitionClass )
987 : : {
988 : : default:
989 : : case TransitionInfo::TRANSITION_INVALID:
990 : : OSL_TRACE(
991 : : "TransitionFactory::createSlideTransition(): "
992 : : "Invalid type/subtype (%d/%d) combination encountered.",
993 : : nTransitionType,
994 : : nTransitionSubType );
995 : 0 : return NumberAnimationSharedPtr();
996 : :
997 : :
998 : : case TransitionInfo::TRANSITION_CLIP_POLYPOLYGON:
999 : : {
1000 : : // generate parametric poly-polygon
1001 : : ParametricPolyPolygonSharedPtr pPoly(
1002 : : ParametricPolyPolygonFactory::createClipPolyPolygon(
1003 : 0 : nTransitionType, nTransitionSubType ) );
1004 : :
1005 : : // create a clip transition from that
1006 : : return NumberAnimationSharedPtr(
1007 : : new ClippedSlideChange( pEnteringSlide,
1008 : : pPoly,
1009 : : *pTransitionInfo,
1010 : : rViewContainer,
1011 : : rScreenUpdater,
1012 : : rEventMultiplexer,
1013 : : bTransitionDirection,
1014 : 0 : pSoundPlayer ));
1015 : : }
1016 : :
1017 : : case TransitionInfo::TRANSITION_SPECIAL:
1018 : : {
1019 : 0 : switch( nTransitionType )
1020 : : {
1021 : : default:
1022 : : OSL_FAIL(
1023 : : "TransitionFactory::createSlideTransition(): "
1024 : : "Unexpected transition type for "
1025 : : "TRANSITION_SPECIAL transitions" );
1026 : 0 : return NumberAnimationSharedPtr();
1027 : :
1028 : : case animations::TransitionType::RANDOM:
1029 : : {
1030 : : // select randomly one of the effects from the
1031 : : // TransitionFactoryTable
1032 : :
1033 : : const TransitionInfo* pRandomTransitionInfo(
1034 : 0 : getRandomTransitionInfo() );
1035 : :
1036 : 0 : ENSURE_OR_THROW(
1037 : : pRandomTransitionInfo != NULL,
1038 : : "TransitionFactory::createSlideTransition(): "
1039 : : "Got invalid random transition info" );
1040 : :
1041 : 0 : ENSURE_OR_THROW(
1042 : : pRandomTransitionInfo->mnTransitionType !=
1043 : : animations::TransitionType::RANDOM,
1044 : : "TransitionFactory::createSlideTransition(): "
1045 : : "Got random again for random input!" );
1046 : :
1047 : : // and recurse
1048 : : return createSlideTransition(
1049 : : pLeavingSlide,
1050 : : pEnteringSlide,
1051 : : rViewContainer,
1052 : : rScreenUpdater,
1053 : : rEventMultiplexer,
1054 : : xOptionalFactory,
1055 : : pRandomTransitionInfo->mnTransitionType,
1056 : : pRandomTransitionInfo->mnTransitionSubType,
1057 : : bTransitionDirection,
1058 : : rTransitionFadeColor,
1059 : 0 : pSoundPlayer );
1060 : : }
1061 : :
1062 : : case animations::TransitionType::PUSHWIPE:
1063 : : {
1064 : : return createPushWipeTransition(
1065 : : comphelper::make_optional(pLeavingSlide),
1066 : : pEnteringSlide,
1067 : : rViewContainer,
1068 : : rScreenUpdater,
1069 : : rEventMultiplexer,
1070 : : nTransitionType,
1071 : : nTransitionSubType,
1072 : : bTransitionDirection,
1073 : 0 : pSoundPlayer );
1074 : : }
1075 : :
1076 : : case animations::TransitionType::SLIDEWIPE:
1077 : : {
1078 : : return createSlideWipeTransition(
1079 : : comphelper::make_optional(pLeavingSlide),
1080 : : pEnteringSlide,
1081 : : rViewContainer,
1082 : : rScreenUpdater,
1083 : : rEventMultiplexer,
1084 : : nTransitionType,
1085 : : nTransitionSubType,
1086 : : bTransitionDirection,
1087 : 0 : pSoundPlayer );
1088 : : }
1089 : :
1090 : : case animations::TransitionType::BARWIPE:
1091 : : case animations::TransitionType::FADE:
1092 : : {
1093 : : // black page:
1094 : 0 : boost::optional<SlideSharedPtr> leavingSlide;
1095 : :
1096 : 0 : switch( nTransitionSubType )
1097 : : {
1098 : : case animations::TransitionSubType::CROSSFADE:
1099 : : // crossfade needs no further setup,
1100 : : // just blend new slide over existing
1101 : : // background.
1102 : 0 : break;
1103 : :
1104 : : // TODO(F1): Implement toColor/fromColor fades
1105 : : case animations::TransitionSubType::FADETOCOLOR:
1106 : : // FALLTHROUGH intended
1107 : : case animations::TransitionSubType::FADEFROMCOLOR:
1108 : : // FALLTHROUGH intended
1109 : : case animations::TransitionSubType::FADEOVERCOLOR:
1110 : 0 : if (pLeavingSlide) {
1111 : : // only generate, if fade
1112 : : // effect really needs it.
1113 : 0 : leavingSlide.reset( pLeavingSlide );
1114 : : }
1115 : 0 : break;
1116 : :
1117 : : default:
1118 : 0 : ENSURE_OR_THROW( false,
1119 : : "SlideTransitionFactory::createSlideTransition(): Unknown FADE subtype" );
1120 : : }
1121 : :
1122 : 0 : if( nTransitionType == animations::TransitionType::FADE )
1123 : : return NumberAnimationSharedPtr(
1124 : : new FadingSlideChange(
1125 : : leavingSlide,
1126 : : pEnteringSlide,
1127 : : comphelper::make_optional(
1128 : : rTransitionFadeColor),
1129 : : pSoundPlayer,
1130 : : rViewContainer,
1131 : : rScreenUpdater,
1132 : 0 : rEventMultiplexer ));
1133 : : else
1134 : : return NumberAnimationSharedPtr(
1135 : : new CutSlideChange(
1136 : : leavingSlide,
1137 : : pEnteringSlide,
1138 : : rTransitionFadeColor,
1139 : : pSoundPlayer,
1140 : : rViewContainer,
1141 : : rScreenUpdater,
1142 : 0 : rEventMultiplexer ));
1143 : : }
1144 : : }
1145 : : }
1146 : : break;
1147 : : }
1148 : : }
1149 : :
1150 : : // No animation generated, maybe no table entry for given
1151 : : // transition?
1152 : : OSL_TRACE(
1153 : : "TransitionFactory::createSlideTransition(): "
1154 : : "Unknown type/subtype (%d/%d) combination encountered",
1155 : : nTransitionType,
1156 : : nTransitionSubType );
1157 : : OSL_FAIL(
1158 : : "TransitionFactory::createSlideTransition(): "
1159 : : "Unknown type/subtype combination encountered" );
1160 : :
1161 : 0 : return NumberAnimationSharedPtr();
1162 : : }
1163 : :
1164 : : } // namespace internal
1165 : 0 : } // namespace presentation
1166 : :
1167 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
