LibreOffice Module slideshow (master) 1
animationfactory.cxx
Go to the documentation of this file.
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 <comphelper/diagnose_ex.hxx>
22#include <sal/log.hxx>
23
24#include <animationfactory.hxx>
25#include <attributemap.hxx>
26
27#include <com/sun/star/animations/AnimationAdditiveMode.hpp>
28#include <com/sun/star/animations/AnimationTransformType.hpp>
29#include <com/sun/star/beans/XPropertySet.hpp>
30#include <com/sun/star/drawing/FillStyle.hpp>
31#include <com/sun/star/drawing/LineStyle.hpp>
32#include <com/sun/star/awt/FontSlant.hpp>
33
34#include <basegfx/polygon/b2dpolygon.hxx>
35#include <basegfx/polygon/b2dpolygontools.hxx>
36#include <basegfx/polygon/b2dpolypolygontools.hxx>
37
38#include <box2dtools.hxx>
39#include <utility>
40
41using namespace ::com::sun::star;
42
43
44namespace slideshow::internal
45{
46 namespace
47 {
48 // attention, there is a similar implementation of Animation in
49 // transitions/transitionfactory.cxx
50
51 template< typename ValueT > class TupleAnimation : public PairAnimation
52 {
53 public:
54 TupleAnimation( const ShapeManagerSharedPtr& rShapeManager,
55 int nFlags,
56 bool (ShapeAttributeLayer::*pIs1stValid)() const,
57 bool (ShapeAttributeLayer::*pIs2ndValid)() const,
58 const ValueT& rDefaultValue,
59 const ::basegfx::B2DSize& rReferenceSize,
60 double (ShapeAttributeLayer::*pGet1stValue)() const,
61 double (ShapeAttributeLayer::*pGet2ndValue)() const,
62 void (ShapeAttributeLayer::*pSetValue)( const ValueT& ) ) :
63 mpShape(),
64 mpAttrLayer(),
65 mpShapeManager( rShapeManager ),
66 mpIs1stValidFunc(pIs1stValid),
67 mpIs2ndValidFunc(pIs2ndValid),
68 mpGet1stValueFunc(pGet1stValue),
69 mpGet2ndValueFunc(pGet2ndValue),
70 mpSetValueFunc(pSetValue),
71 mnFlags( nFlags ),
72 maReferenceSize( rReferenceSize ),
73 maDefaultValue( rDefaultValue ),
74 mbAnimationStarted( false )
75 {
76 ENSURE_OR_THROW( rShapeManager,
77 "TupleAnimation::TupleAnimation(): Invalid ShapeManager" );
78 ENSURE_OR_THROW( pIs1stValid && pIs2ndValid && pGet1stValue && pGet2ndValue && pSetValue,
79 "TupleAnimation::TupleAnimation(): One of the method pointers is NULL" );
80 }
81
82 virtual ~TupleAnimation() override
83 {
84 end_();
85 }
86
87 // Animation interface
88
89 virtual void prefetch() override
90 {}
91
92 virtual void start( const AnimatableShapeSharedPtr& rShape,
93 const ShapeAttributeLayerSharedPtr& rAttrLayer ) override
94 {
95 OSL_ENSURE( !mpShape,
96 "TupleAnimation::start(): Shape already set" );
97 OSL_ENSURE( !mpAttrLayer,
98 "TupleAnimation::start(): Attribute layer already set" );
99
100 mpShape = rShape;
101 mpAttrLayer = rAttrLayer;
102
103 ENSURE_OR_THROW( rShape,
104 "TupleAnimation::start(): Invalid shape" );
105 ENSURE_OR_THROW( rAttrLayer,
106 "TupleAnimation::start(): Invalid attribute layer" );
107
108 if( !mbAnimationStarted )
109 {
110 mbAnimationStarted = true;
111
112 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
113 mpShapeManager->enterAnimationMode( mpShape );
114 }
115 }
116
117 virtual void end() override { end_(); }
118 void end_()
119 {
120 if( mbAnimationStarted )
121 {
122 mbAnimationStarted = false;
123
124 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
125 mpShapeManager->leaveAnimationMode( mpShape );
126
127 if( mpShape->isContentChanged() )
128 mpShapeManager->notifyShapeUpdate( mpShape );
129 }
130 }
131
132 // PairAnimation interface
133
134
135 virtual bool operator()( const ::basegfx::B2DTuple& rValue ) override
136 {
137 ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
138 "TupleAnimation::operator(): Invalid ShapeAttributeLayer" );
139
140 ValueT aValue(rValue.getX(), rValue.getY());
141
142 // Activities get values from the expression parser,
143 // which returns _relative_ sizes/positions.
144 // Convert back relative to reference coordinate system
145 aValue *= basegfx::B2DPoint(maReferenceSize);
146
147 ((*mpAttrLayer).*mpSetValueFunc)( aValue );
148
149 if( mpShape->isContentChanged() )
150 mpShapeManager->notifyShapeUpdate( mpShape );
151
152 return true;
153 }
154
155 virtual ::basegfx::B2DTuple getUnderlyingValue() const override
156 {
157 ENSURE_OR_THROW( mpAttrLayer,
158 "TupleAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
159
160 ::basegfx::B2DTuple aRetVal;
161
162 // deviated from the (*shared_ptr).*mpFuncPtr
163 // notation here, since gcc does not seem to parse
164 // that as a member function call anymore.
165 basegfx::B2DPoint aPoint(maDefaultValue);
166 aRetVal.setX( (mpAttrLayer.get()->*mpIs1stValidFunc)() ?
167 (mpAttrLayer.get()->*mpGet1stValueFunc)() :
168 aPoint.getX() );
169 aRetVal.setY( (mpAttrLayer.get()->*mpIs2ndValidFunc)() ?
170 (mpAttrLayer.get()->*mpGet2ndValueFunc)() :
171 aPoint.getY() );
172
173 // Activities get values from the expression
174 // parser, which returns _relative_
175 // sizes/positions. Convert start value to the
176 // same coordinate space (i.e. relative to given
177 // reference size).
178 aRetVal /= basegfx::B2DPoint(maReferenceSize);
179
180 return aRetVal;
181 }
182
183 private:
184 AnimatableShapeSharedPtr mpShape;
185 ShapeAttributeLayerSharedPtr mpAttrLayer;
186 ShapeManagerSharedPtr mpShapeManager;
187 bool (ShapeAttributeLayer::*mpIs1stValidFunc)() const;
188 bool (ShapeAttributeLayer::*mpIs2ndValidFunc)() const;
189 double (ShapeAttributeLayer::*mpGet1stValueFunc)() const;
190 double (ShapeAttributeLayer::*mpGet2ndValueFunc)() const;
191 void (ShapeAttributeLayer::*mpSetValueFunc)( const ValueT& );
192
193 const int mnFlags;
194
195 const ::basegfx::B2DSize maReferenceSize;
196 const ValueT maDefaultValue;
197 bool mbAnimationStarted;
198 };
199
200
201 class PathAnimation : public NumberAnimation
202 {
203 public:
204 PathAnimation( std::u16string_view rSVGDPath,
205 sal_Int16 nAdditive,
206 const ShapeManagerSharedPtr& rShapeManager,
207 const ::basegfx::B2DVector& rSlideSize,
208 int nFlags,
209 box2d::utils::Box2DWorldSharedPtr pBox2DWorld ) :
210 maPathPoly(),
211 mpShape(),
212 mpAttrLayer(),
213 mpShapeManager( rShapeManager ),
214 maPageSize( rSlideSize.getX(), rSlideSize.getY() ),
215 maShapeOrig(),
216 mnFlags( nFlags ),
217 mbAnimationStarted( false ),
218 mbAnimationFirstUpdate( true ),
219 mnAdditive( nAdditive ),
220 mpBox2DWorld(std::move( pBox2DWorld ))
221 {
222 ENSURE_OR_THROW( rShapeManager,
223 "PathAnimation::PathAnimation(): Invalid ShapeManager" );
224
225 ::basegfx::B2DPolyPolygon aPolyPoly;
226
227 ENSURE_OR_THROW( ::basegfx::utils::importFromSvgD( aPolyPoly, rSVGDPath, false, nullptr ),
228 "PathAnimation::PathAnimation(): failed to parse SVG:d path" );
229 ENSURE_OR_THROW( aPolyPoly.count() == 1,
230 "PathAnimation::PathAnimation(): motion path consists of multiple/zero polygon(s)" );
231
232 maPathPoly = aPolyPoly.getB2DPolygon(0);
233 }
234
235 virtual ~PathAnimation() override
236 {
237 end_();
238 }
239
240 // Animation interface
241
242 virtual void prefetch() override
243 {}
244
245 virtual void start( const AnimatableShapeSharedPtr& rShape,
246 const ShapeAttributeLayerSharedPtr& rAttrLayer ) override
247 {
248 OSL_ENSURE( !mpShape,
249 "PathAnimation::start(): Shape already set" );
250 OSL_ENSURE( !mpAttrLayer,
251 "PathAnimation::start(): Attribute layer already set" );
252
253 mpShape = rShape;
254 mpAttrLayer = rAttrLayer;
255
256 ENSURE_OR_THROW( rShape,
257 "PathAnimation::start(): Invalid shape" );
258 ENSURE_OR_THROW( rAttrLayer,
259 "PathAnimation::start(): Invalid attribute layer" );
260
261 // TODO(F1): Check whether _shape_ bounds are correct here.
262 // Theoretically, our AttrLayer is way down the stack, and
263 // we only have to consider _that_ value, not the one from
264 // the top of the stack as returned by Shape::getBounds()
265 if( mnAdditive == animations::AnimationAdditiveMode::SUM )
266 maShapeOrig = mpShape->getBounds().getCenter();
267 else
268 maShapeOrig = mpShape->getDomBounds().getCenter();
269
270 if( !mbAnimationStarted )
271 {
272 mbAnimationStarted = true;
273
274 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
275 mpShapeManager->enterAnimationMode( mpShape );
276 }
277 }
278
279 virtual void end() override { end_(); }
280 void end_()
281 {
282 if( !mbAnimationStarted )
283 return;
284
285 mbAnimationStarted = false;
286
287 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
288 mpShapeManager->leaveAnimationMode( mpShape );
289
290 if( mpShape->isContentChanged() )
291 mpShapeManager->notifyShapeUpdate( mpShape );
292
293 // if there is a physics animation going on report the animation ending
294 // and zero out the velocity of the shape
295 if( mpBox2DWorld->isInitialized() )
296 mpBox2DWorld->queueLinearVelocityUpdate( mpShape->getXShape(), {0,0});
297 }
298
299 // NumberAnimation interface
300
301
302 virtual bool operator()( double nValue ) override
303 {
304 ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
305 "PathAnimation::operator(): Invalid ShapeAttributeLayer" );
306
307 ::basegfx::B2DPoint rOutPos = ::basegfx::utils::getPositionRelative( maPathPoly,
308 nValue );
309
310 // TODO(F1): Determine whether the path is
311 // absolute, or shape-relative.
312
313 // interpret path as page-relative. Scale up with page size
314 rOutPos *= basegfx::B2DPoint(maPageSize);
315
316 // TODO(F1): Determine whether the path origin is
317 // absolute, or shape-relative.
318
319 // interpret path as shape-originated. Offset to shape position
320
321 rOutPos += maShapeOrig;
322
323 mpAttrLayer->setPosition( rOutPos );
324
325 if( mpShape->isContentChanged() )
326 {
327 mpShapeManager->notifyShapeUpdate( mpShape );
328
329 // if there's a physics animation going on report the change to it
330 if ( mpBox2DWorld->isInitialized() )
331 {
332 mpBox2DWorld->queueShapePathAnimationUpdate( mpShape->getXShape(),
333 mpAttrLayer,
334 mbAnimationFirstUpdate );
335 }
336 }
337
338 if( mbAnimationFirstUpdate ) mbAnimationFirstUpdate = false;
339
340 return true;
341 }
342
343 virtual double getUnderlyingValue() const override
344 {
345 ENSURE_OR_THROW( mpAttrLayer,
346 "PathAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
347
348 return 0.0; // though this should be used in concert with
349 // ActivitiesFactory::createSimpleActivity, better
350 // explicitly name our start value.
351 // Permissible range for operator() above is [0,1]
352 }
353
354 private:
355 ::basegfx::B2DPolygon maPathPoly;
356 AnimatableShapeSharedPtr mpShape;
357 ShapeAttributeLayerSharedPtr mpAttrLayer;
358 ShapeManagerSharedPtr mpShapeManager;
359 const ::basegfx::B2DSize maPageSize;
360 ::basegfx::B2DPoint maShapeOrig;
361 const int mnFlags;
362 bool mbAnimationStarted;
363 bool mbAnimationFirstUpdate;
364 sal_Int16 mnAdditive;
365 box2d::utils::Box2DWorldSharedPtr mpBox2DWorld;
366 };
367
368 class PhysicsAnimation : public NumberAnimation
369 {
370 public:
371 PhysicsAnimation( ::box2d::utils::Box2DWorldSharedPtr pBox2DWorld,
372 const double fDuration,
373 const ShapeManagerSharedPtr& rShapeManager,
374 const ::basegfx::B2DVector& rSlideSize,
375 const ::basegfx::B2DVector& rStartVelocity,
376 const double fDensity,
377 const double fBounciness,
378 int nFlags ) :
379 mpShape(),
380 mpAttrLayer(),
381 mpShapeManager( rShapeManager ),
382 maPageSize( rSlideSize ),
383 mnFlags( nFlags ),
384 mbAnimationStarted( false ),
385 mpBox2DBody(),
386 mpBox2DWorld(std::move( pBox2DWorld )),
387 mfDuration(fDuration),
388 maStartVelocity(rStartVelocity),
389 mfDensity(fDensity),
390 mfBounciness(fBounciness),
391 mfPreviousElapsedTime(0.00f),
392 mbIsBox2dWorldStepper(false)
393 {
394 ENSURE_OR_THROW( rShapeManager,
395 "PhysicsAnimation::PhysicsAnimation(): Invalid ShapeManager" );
396 }
397
398 virtual ~PhysicsAnimation() override
399 {
400 end_();
401 }
402
403 // Animation interface
404
405 virtual void prefetch() override
406 {}
407
408 virtual void start( const AnimatableShapeSharedPtr& rShape,
409 const ShapeAttributeLayerSharedPtr& rAttrLayer ) override
410 {
411 OSL_ENSURE( !mpShape,
412 "PhysicsAnimation::start(): Shape already set" );
413 OSL_ENSURE( !mpAttrLayer,
414 "PhysicsAnimation::start(): Attribute layer already set" );
415
416 mpShape = rShape;
417 mpAttrLayer = rAttrLayer;
418
419 ENSURE_OR_THROW( rShape,
420 "PhysicsAnimation::start(): Invalid shape" );
421 ENSURE_OR_THROW( rAttrLayer,
422 "PhysicsAnimation::start(): Invalid attribute layer" );
423
424 if( !mbAnimationStarted )
425 {
426 mbAnimationStarted = true;
427
428 mpBox2DWorld->alertPhysicsAnimationStart(basegfx::B2DVector(maPageSize.getWidth(), maPageSize.getHeight()), mpShapeManager);
429 mpBox2DBody = mpBox2DWorld->makeShapeDynamic( mpShape->getXShape(), maStartVelocity, mfDensity, mfBounciness );
430
431 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
432 mpShapeManager->enterAnimationMode( mpShape );
433 }
434 }
435
436 virtual void end() override { end_(); }
437 void end_()
438 {
439 if( mbIsBox2dWorldStepper )
440 {
441 mbIsBox2dWorldStepper = false;
442 mpBox2DWorld->setHasWorldStepper(false);
443 }
444
445 if( !mbAnimationStarted )
446 return;
447
448 mbAnimationStarted = false;
449
450 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
451 mpShapeManager->leaveAnimationMode( mpShape );
452
453 if( mpShape->isContentChanged() )
454 mpShapeManager->notifyShapeUpdate( mpShape );
455
456 mpBox2DWorld->alertPhysicsAnimationEnd(mpShape);
457 // if this was the only physics animation effect going on
458 // all box2d bodies were destroyed on alertPhysicsAnimationEnd
459 // except the one owned by the animation.
460 // Try to destroy the remaining body - if it is unique
461 // (it being unique means all physics animation effects have ended
462 // since otherwise mpBox2DWorld would own a copy of the shared_ptr )
463 mpBox2DBody.reset();
464
465 }
466
467 // NumberAnimation interface
468
469
470 virtual bool operator()( double nValue ) override
471 {
472 ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
473 "PhysicsAnimation::operator(): Invalid ShapeAttributeLayer" );
474
475 // if there are multiple physics animations going in parallel
476 // Only one of them should step the box2d world
477 if( !mpBox2DWorld->hasWorldStepper() )
478 {
479 mbIsBox2dWorldStepper = true;
480 mpBox2DWorld->setHasWorldStepper(true);
481 }
482
483 if( mbIsBox2dWorldStepper )
484 {
485 double fPassedTime = (mfDuration * nValue) - mfPreviousElapsedTime;
486 mfPreviousElapsedTime += mpBox2DWorld->stepAmount( fPassedTime );
487 }
488
489 mpAttrLayer->setPosition( mpBox2DBody->getPosition() );
490 mpAttrLayer->setRotationAngle( mpBox2DBody->getAngle() );
491
492 if( mpShape->isContentChanged() )
493 mpShapeManager->notifyShapeUpdate( mpShape );
494
495 return true;
496 }
497
498 virtual double getUnderlyingValue() const override
499 {
500 ENSURE_OR_THROW( mpAttrLayer,
501 "PhysicsAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
502
503 return 0.0;
504 }
505
506 private:
507 AnimatableShapeSharedPtr mpShape;
508 ShapeAttributeLayerSharedPtr mpAttrLayer;
509 ShapeManagerSharedPtr mpShapeManager;
510 const ::basegfx::B2DSize maPageSize;
511 const int mnFlags;
512 bool mbAnimationStarted;
513 box2d::utils::Box2DBodySharedPtr mpBox2DBody;
514 box2d::utils::Box2DWorldSharedPtr mpBox2DWorld;
515 double mfDuration;
516 const ::basegfx::B2DVector maStartVelocity;
517 const double mfDensity;
518 const double mfBounciness;
519 double mfPreviousElapsedTime;
520 bool mbIsBox2dWorldStepper;
521 };
522
548 template< typename AnimationBase, typename ModifierFunctor > class GenericAnimation : public AnimationBase
549 {
550 public:
551 typedef typename AnimationBase::ValueType ValueT;
552
579 GenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
580 int nFlags,
581 bool (ShapeAttributeLayer::*pIsValid)() const,
582 ValueT aDefaultValue,
583 ValueT (ShapeAttributeLayer::*pGetValue)() const,
584 void (ShapeAttributeLayer::*pSetValue)( const ValueT& ),
585 const ModifierFunctor& rGetterModifier,
586 const ModifierFunctor& rSetterModifier,
587 const AttributeType eAttrType,
588 box2d::utils::Box2DWorldSharedPtr pBox2DWorld ) :
589 mpShape(),
590 mpAttrLayer(),
591 mpShapeManager( rShapeManager ),
592 mpIsValidFunc(pIsValid),
593 mpGetValueFunc(pGetValue),
594 mpSetValueFunc(pSetValue),
595 maGetterModifier( rGetterModifier ),
596 maSetterModifier( rSetterModifier ),
597 mnFlags( nFlags ),
598 maDefaultValue(std::move(aDefaultValue)),
599 mbAnimationStarted( false ),
600 mbAnimationFirstUpdate( true ),
601 meAttrType( eAttrType ),
602 mpBox2DWorld (std::move( pBox2DWorld ))
603 {
604 ENSURE_OR_THROW( rShapeManager,
605 "GenericAnimation::GenericAnimation(): Invalid ShapeManager" );
606 ENSURE_OR_THROW( pIsValid && pGetValue && pSetValue,
607 "GenericAnimation::GenericAnimation(): One of the method pointers is NULL" );
608 }
609
610 ~GenericAnimation()
611 {
612 end();
613 }
614
615 // Animation interface
616
617 virtual void prefetch()
618 {}
619
620 virtual void start( const AnimatableShapeSharedPtr& rShape,
621 const ShapeAttributeLayerSharedPtr& rAttrLayer )
622 {
623 OSL_ENSURE( !mpShape,
624 "GenericAnimation::start(): Shape already set" );
625 OSL_ENSURE( !mpAttrLayer,
626 "GenericAnimation::start(): Attribute layer already set" );
627
628 mpShape = rShape;
629 mpAttrLayer = rAttrLayer;
630
631 ENSURE_OR_THROW( rShape,
632 "GenericAnimation::start(): Invalid shape" );
633 ENSURE_OR_THROW( rAttrLayer,
634 "GenericAnimation::start(): Invalid attribute layer" );
635
636 // only start animation once per repeated start() call,
637 // and only if sprites should be used for display
638 if( !mbAnimationStarted )
639 {
640 mbAnimationStarted = true;
641
642 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
643 mpShapeManager->enterAnimationMode( mpShape );
644 }
645 }
646
647 void end()
648 {
649 // TODO(Q2): Factor out common code (most
650 // prominently start() and end()) into base class
651
652 // only stop animation once per repeated end() call,
653 // and only if sprites are used for display
654 if( !mbAnimationStarted )
655 return;
656
657 mbAnimationStarted = false;
658
659 if( mpBox2DWorld && mpBox2DWorld->isInitialized() )
660 {
661 // if there's a physics animation going on report the animation ending to it
662 mpBox2DWorld->queueShapeAnimationEndUpdate( mpShape->getXShape(), meAttrType );
663 }
664
665 if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
666 mpShapeManager->leaveAnimationMode( mpShape );
667
668 // Attention, this notifyShapeUpdate() is
669 // somewhat delicate here. Calling it
670 // unconditional (i.e. not guarded by
671 // mbAnimationStarted) will lead to shapes
672 // snapping back to their original state just
673 // before the slide ends. Not calling it at
674 // all might swallow final animation
675 // states. The current implementation relies
676 // on the fact that end() is either called by
677 // the Activity (then, the last animation
678 // state has been set, and corresponds to the
679 // shape's hold state), or by the animation
680 // node (then, it's a forced end, and we
681 // _have_ to snap back).
682
683 // To reiterate: normally, we're called from
684 // the Activity first, thus the
685 // notifyShapeUpdate() below will update to
686 // the last activity value.
687
688 // force shape update, activity might have changed
689 // state in the last round.
690 if( mpShape->isContentChanged() )
691 mpShapeManager->notifyShapeUpdate( mpShape );
692 }
693
694 // Derived Animation interface
695
696
699 bool operator()( const ValueT& x )
700 {
701 ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
702 "GenericAnimation::operator(): Invalid ShapeAttributeLayer" );
703
704 ((*mpAttrLayer).*mpSetValueFunc)( maSetterModifier( x ) );
705
706 if( mpShape->isContentChanged() )
707 mpShapeManager->notifyShapeUpdate( mpShape );
708
709 if( mbAnimationFirstUpdate ) mbAnimationFirstUpdate = false;
710
711 return true;
712 }
713
716 bool operator()( ValueT x )
717 {
718 ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
719 "GenericAnimation::operator(): Invalid ShapeAttributeLayer" );
720
721 ((*mpAttrLayer).*mpSetValueFunc)( maSetterModifier( x ) );
722
723 if( mpBox2DWorld && mpBox2DWorld->isInitialized() )
724 {
725 // if there's a physics animation going on report the change to it
726 mpBox2DWorld->queueShapeAnimationUpdate( mpShape->getXShape(), mpAttrLayer, meAttrType, mbAnimationFirstUpdate );
727 }
728
729 if( mpShape->isContentChanged() )
730 mpShapeManager->notifyShapeUpdate( mpShape );
731
732 if( mbAnimationFirstUpdate ) mbAnimationFirstUpdate = false;
733
734 return true;
735 }
736
737 ValueT getUnderlyingValue() const
738 {
739 ENSURE_OR_THROW( mpAttrLayer,
740 "GenericAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
741
742 // deviated from the (*shared_ptr).*mpFuncPtr
743 // notation here, since gcc does not seem to parse
744 // that as a member function call anymore.
745 if( (mpAttrLayer.get()->*mpIsValidFunc)() )
746 return maGetterModifier( ((*mpAttrLayer).*mpGetValueFunc)() );
747 else
748 return maDefaultValue;
749 }
750
751 private:
752 AnimatableShapeSharedPtr mpShape;
753 ShapeAttributeLayerSharedPtr mpAttrLayer;
754 ShapeManagerSharedPtr mpShapeManager;
755 bool (ShapeAttributeLayer::*mpIsValidFunc)() const;
756 ValueT (ShapeAttributeLayer::*mpGetValueFunc)() const;
757 void (ShapeAttributeLayer::*mpSetValueFunc)( const ValueT& );
758
759 ModifierFunctor maGetterModifier;
760 ModifierFunctor maSetterModifier;
761
762 const int mnFlags;
763
764 const ValueT maDefaultValue;
765 bool mbAnimationStarted;
766 bool mbAnimationFirstUpdate;
767
768 const AttributeType meAttrType;
769 const box2d::utils::Box2DWorldSharedPtr mpBox2DWorld;
770 };
771
772 //Current c++0x draft (apparently) has std::identity, but not operator()
773 template<typename T> struct SGI_identity
774 {
775 T& operator()(T& x) const { return x; }
776 const T& operator()(const T& x) const { return x; }
777 };
778
785 template< typename AnimationBase > ::std::shared_ptr< AnimationBase >
786 makeGenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
787 int nFlags,
788 bool (ShapeAttributeLayer::*pIsValid)() const,
789 const typename AnimationBase::ValueType& rDefaultValue,
790 typename AnimationBase::ValueType (ShapeAttributeLayer::*pGetValue)() const,
791 void (ShapeAttributeLayer::*pSetValue)( const typename AnimationBase::ValueType& ),
792 const AttributeType eAttrType,
793 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld )
794 {
795 return std::make_shared<GenericAnimation< AnimationBase,
796 SGI_identity< typename AnimationBase::ValueType > >>(
797 rShapeManager,
798 nFlags,
799 pIsValid,
800 rDefaultValue,
801 pGetValue,
802 pSetValue,
803 // no modification necessary, use identity functor here
804 SGI_identity< typename AnimationBase::ValueType >(),
805 SGI_identity< typename AnimationBase::ValueType >(),
806 eAttrType,
807 pBox2DWorld );
808 }
809
810 class Scaler
811 {
812 public:
813 explicit Scaler( double nScale ) :
814 mnScale( nScale )
815 {
816 }
817
818 double operator()( double nVal ) const
819 {
820 return mnScale * nVal;
821 }
822
823 private:
824 double mnScale;
825 };
826
829 NumberAnimationSharedPtr makeGenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
830 int nFlags,
831 bool (ShapeAttributeLayer::*pIsValid)() const,
832 double nDefaultValue,
833 double (ShapeAttributeLayer::*pGetValue)() const,
834 void (ShapeAttributeLayer::*pSetValue)( const double& ),
835 double nScaleValue,
836 const AttributeType eAttrType,
837 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld )
838 {
839 return std::make_shared<GenericAnimation< NumberAnimation, Scaler >>( rShapeManager,
840 nFlags,
841 pIsValid,
842 nDefaultValue / nScaleValue,
843 pGetValue,
844 pSetValue,
845 Scaler( 1.0/nScaleValue ),
846 Scaler( nScaleValue ),
847 eAttrType,
848 pBox2DWorld );
849 }
850
851
852 uno::Any getShapeDefault( const AnimatableShapeSharedPtr& rShape,
853 const OUString& rPropertyName )
854 {
855 uno::Reference< drawing::XShape > xShape( rShape->getXShape() );
856
857 if( !xShape.is() )
858 return uno::Any(); // no regular shape, no defaults available
859
860
861 // extract relevant value from XShape's PropertySet
862 uno::Reference< beans::XPropertySet > xPropSet( xShape,
863 uno::UNO_QUERY );
864
865 ENSURE_OR_THROW( xPropSet.is(),
866 "getShapeDefault(): Cannot query property set from shape" );
867
868 return xPropSet->getPropertyValue( rPropertyName );
869 }
870
871 template< typename ValueType > ValueType getDefault( const AnimatableShapeSharedPtr& rShape,
872 const OUString& rPropertyName )
873 {
874 const uno::Any& rAny( getShapeDefault( rShape,
875 rPropertyName ) );
876
877 if( !rAny.hasValue() )
878 {
879 SAL_WARN("slideshow", "getDefault(): cannot get shape property " << rPropertyName );
880 return ValueType();
881 }
882 else
883 {
884 ValueType aValue = ValueType();
885
886 if( !(rAny >>= aValue) )
887 {
888 SAL_WARN("slideshow", "getDefault(): cannot extract shape property " << rPropertyName);
889 return ValueType();
890 }
891
892 return aValue;
893 }
894 }
895
896 template<> RGBColor getDefault< RGBColor >( const AnimatableShapeSharedPtr& rShape,
897 const OUString& rPropertyName )
898 {
899 const uno::Any& rAny( getShapeDefault( rShape,
900 rPropertyName ) );
901
902 if( !rAny.hasValue() )
903 {
904 SAL_WARN("slideshow", "getDefault(): cannot get shape color property " << rPropertyName);
905 return RGBColor();
906 }
907 else
908 {
909 sal_Int32 nValue = 0;
910
911 if( !(rAny >>= nValue) )
912 {
913 SAL_INFO("slideshow", "getDefault(): cannot extract shape color property " << rPropertyName);
914 return RGBColor();
915 }
916
917 // convert from 0xAARRGGBB API color to 0xRRGGBB00
918 // canvas color
919 return RGBColor( (nValue << 8U) & 0xFFFFFF00U );
920 }
921 }
922 }
923
924 AnimationFactory::AttributeClass AnimationFactory::classifyAttributeName( const OUString& rAttrName )
925 {
926 // ATTENTION: When changing this map, also the create*PropertyAnimation() methods must
927 // be checked and possibly adapted in their switch statements
928
929 // TODO(Q2): Since this map must be coherent with the various switch statements
930 // in the create*PropertyAnimation methods, try to unify into a single method or table
931 switch( mapAttributeName( rAttrName ) )
932 {
933 default:
934 case AttributeType::Invalid:
935 return CLASS_UNKNOWN_PROPERTY;
936
937 case AttributeType::CharColor:
938 case AttributeType::Color:
939 case AttributeType::DimColor:
940 case AttributeType::FillColor:
941 case AttributeType::LineColor:
942 return CLASS_COLOR_PROPERTY;
943
944 case AttributeType::CharFontName:
945 return CLASS_STRING_PROPERTY;
946
947 case AttributeType::Visibility:
948 return CLASS_BOOL_PROPERTY;
949
950 case AttributeType::CharHeight:
951 case AttributeType::CharWeight:
952 case AttributeType::Height:
953 case AttributeType::Opacity:
954 case AttributeType::Rotate:
955 case AttributeType::SkewX:
956 case AttributeType::SkewY:
957 case AttributeType::Width:
958 case AttributeType::PosX:
959 case AttributeType::PosY:
960 return CLASS_NUMBER_PROPERTY;
961
962 case AttributeType::CharUnderline:
963 case AttributeType::FillStyle:
964 case AttributeType::LineStyle:
965 case AttributeType::CharPosture:
966 return CLASS_ENUM_PROPERTY;
967 }
968 }
969
970 NumberAnimationSharedPtr AnimationFactory::createNumberPropertyAnimation( const OUString& rAttrName,
971 const AnimatableShapeSharedPtr& rShape,
972 const ShapeManagerSharedPtr& rShapeManager,
973 const ::basegfx::B2DVector& rSlideSize,
974 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
975 int nFlags )
976 {
977 // ATTENTION: When changing this map, also the classifyAttributeName() method must
978 // be checked and possibly adapted in their switch statement
979 AttributeType eAttrType = mapAttributeName(rAttrName);
980 switch( eAttrType )
981 {
982 default:
983 case AttributeType::Invalid:
984 ENSURE_OR_THROW( false,
985 "AnimationFactory::createNumberPropertyAnimation(): Unknown attribute" );
986 break;
987
988 case AttributeType::CharColor:
989 case AttributeType::CharFontName:
990 case AttributeType::CharPosture:
991 case AttributeType::CharUnderline:
992 case AttributeType::Color:
993 case AttributeType::DimColor:
994 case AttributeType::FillColor:
995 case AttributeType::FillStyle:
996 case AttributeType::LineColor:
997 case AttributeType::LineStyle:
998 case AttributeType::Visibility:
999 ENSURE_OR_THROW( false,
1000 "AnimationFactory::createNumberPropertyAnimation(): Attribute type mismatch" );
1001 break;
1002
1003 case AttributeType::CharHeight:
1004 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1005 nFlags,
1006 &ShapeAttributeLayer::isCharScaleValid,
1007 1.0, // CharHeight is a relative attribute, thus
1008 // default is 1.0
1009 &ShapeAttributeLayer::getCharScale,
1010 &ShapeAttributeLayer::setCharScale,
1011 eAttrType,
1012 pBox2DWorld );
1013
1014 case AttributeType::CharWeight:
1015 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1016 nFlags,
1017 &ShapeAttributeLayer::isCharWeightValid,
1018 getDefault<double>( rShape, rAttrName ),
1019 &ShapeAttributeLayer::getCharWeight,
1020 &ShapeAttributeLayer::setCharWeight,
1021 eAttrType,
1022 pBox2DWorld );
1023
1024 case AttributeType::Height:
1025 return makeGenericAnimation( rShapeManager,
1026 nFlags,
1027 &ShapeAttributeLayer::isHeightValid,
1028 // TODO(F1): Check whether _shape_ bounds are correct here.
1029 // Theoretically, our AttrLayer is way down the stack, and
1030 // we only have to consider _that_ value, not the one from
1031 // the top of the stack as returned by Shape::getBounds()
1032 rShape->getBounds().getHeight(),
1033 &ShapeAttributeLayer::getHeight,
1034 &ShapeAttributeLayer::setHeight,
1035 // convert expression parser value from relative page size
1036 rSlideSize.getY(),
1037 eAttrType,
1038 pBox2DWorld );
1039
1040 case AttributeType::Opacity:
1041 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1042 nFlags,
1043 &ShapeAttributeLayer::isAlphaValid,
1044 // TODO(F1): Provide shape default here (FillTransparency?)
1045 1.0,
1046 &ShapeAttributeLayer::getAlpha,
1047 &ShapeAttributeLayer::setAlpha,
1048 eAttrType,
1049 pBox2DWorld );
1050
1051 case AttributeType::Rotate:
1052 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1053 nFlags,
1054 &ShapeAttributeLayer::isRotationAngleValid,
1055 // NOTE: Since we paint the shape as-is from metafile,
1056 // rotation angle is always 0.0, even for rotated shapes
1057 0.0,
1058 &ShapeAttributeLayer::getRotationAngle,
1059 &ShapeAttributeLayer::setRotationAngle,
1060 eAttrType,
1061 pBox2DWorld );
1062
1063 case AttributeType::SkewX:
1064 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1065 nFlags,
1066 &ShapeAttributeLayer::isShearXAngleValid,
1067 // TODO(F1): Is there any shape property for skew?
1068 0.0,
1069 &ShapeAttributeLayer::getShearXAngle,
1070 &ShapeAttributeLayer::setShearXAngle,
1071 eAttrType,
1072 pBox2DWorld );
1073
1074 case AttributeType::SkewY:
1075 return makeGenericAnimation<NumberAnimation>( rShapeManager,
1076 nFlags,
1077 &ShapeAttributeLayer::isShearYAngleValid,
1078 // TODO(F1): Is there any shape property for skew?
1079 0.0,
1080 &ShapeAttributeLayer::getShearYAngle,
1081 &ShapeAttributeLayer::setShearYAngle,
1082 eAttrType,
1083 pBox2DWorld );
1084
1085 case AttributeType::Width:
1086 return makeGenericAnimation( rShapeManager,
1087 nFlags,
1088 &ShapeAttributeLayer::isWidthValid,
1089 // TODO(F1): Check whether _shape_ bounds are correct here.
1090 // Theoretically, our AttrLayer is way down the stack, and
1091 // we only have to consider _that_ value, not the one from
1092 // the top of the stack as returned by Shape::getBounds()
1093 rShape->getBounds().getWidth(),
1094 &ShapeAttributeLayer::getWidth,
1095 &ShapeAttributeLayer::setWidth,
1096 // convert expression parser value from relative page size
1097 rSlideSize.getX(),
1098 eAttrType,
1099 pBox2DWorld );
1100
1101 case AttributeType::PosX:
1102 return makeGenericAnimation( rShapeManager,
1103 nFlags,
1104 &ShapeAttributeLayer::isPosXValid,
1105 // TODO(F1): Check whether _shape_ bounds are correct here.
1106 // Theoretically, our AttrLayer is way down the stack, and
1107 // we only have to consider _that_ value, not the one from
1108 // the top of the stack as returned by Shape::getBounds()
1109 rShape->getBounds().getCenterX(),
1110 &ShapeAttributeLayer::getPosX,
1111 &ShapeAttributeLayer::setPosX,
1112 // convert expression parser value from relative page size
1113 rSlideSize.getX(),
1114 eAttrType,
1115 pBox2DWorld );
1116
1117 case AttributeType::PosY:
1118 return makeGenericAnimation( rShapeManager,
1119 nFlags,
1120 &ShapeAttributeLayer::isPosYValid,
1121 // TODO(F1): Check whether _shape_ bounds are correct here.
1122 // Theoretically, our AttrLayer is way down the stack, and
1123 // we only have to consider _that_ value, not the one from
1124 // the top of the stack as returned by Shape::getBounds()
1125 rShape->getBounds().getCenterY(),
1126 &ShapeAttributeLayer::getPosY,
1127 &ShapeAttributeLayer::setPosY,
1128 // convert expression parser value from relative page size
1129 rSlideSize.getY(),
1130 eAttrType,
1131 pBox2DWorld );
1132 }
1133
1134 return NumberAnimationSharedPtr();
1135 }
1136
1137 EnumAnimationSharedPtr AnimationFactory::createEnumPropertyAnimation( const OUString& rAttrName,
1138 const AnimatableShapeSharedPtr& rShape,
1139 const ShapeManagerSharedPtr& rShapeManager,
1140 const ::basegfx::B2DVector& /*rSlideSize*/,
1141 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1142 int nFlags )
1143 {
1144 // ATTENTION: When changing this map, also the classifyAttributeName() method must
1145 // be checked and possibly adapted in their switch statement
1146 AttributeType eAttrType = mapAttributeName( rAttrName );
1147 switch( eAttrType )
1148 {
1149 default:
1150 case AttributeType::Invalid:
1151 ENSURE_OR_THROW( false,
1152 "AnimationFactory::createEnumPropertyAnimation(): Unknown attribute" );
1153 break;
1154
1155 case AttributeType::CharColor:
1156 case AttributeType::CharFontName:
1157 case AttributeType::Color:
1158 case AttributeType::DimColor:
1159 case AttributeType::FillColor:
1160 case AttributeType::LineColor:
1161 case AttributeType::Visibility:
1162 case AttributeType::CharHeight:
1163 case AttributeType::CharWeight:
1164 case AttributeType::Height:
1165 case AttributeType::Opacity:
1166 case AttributeType::Rotate:
1167 case AttributeType::SkewX:
1168 case AttributeType::SkewY:
1169 case AttributeType::Width:
1170 case AttributeType::PosX:
1171 case AttributeType::PosY:
1172 ENSURE_OR_THROW( false,
1173 "AnimationFactory::createEnumPropertyAnimation(): Attribute type mismatch" );
1174 break;
1175
1176
1177 case AttributeType::FillStyle:
1178 return makeGenericAnimation<EnumAnimation>( rShapeManager,
1179 nFlags,
1180 &ShapeAttributeLayer::isFillStyleValid,
1181 sal::static_int_cast<sal_Int16>(
1182 getDefault<drawing::FillStyle>( rShape, rAttrName )),
1183 &ShapeAttributeLayer::getFillStyle,
1184 &ShapeAttributeLayer::setFillStyle,
1185 eAttrType,
1186 pBox2DWorld );
1187
1188 case AttributeType::LineStyle:
1189 return makeGenericAnimation<EnumAnimation>( rShapeManager,
1190 nFlags,
1191 &ShapeAttributeLayer::isLineStyleValid,
1192 sal::static_int_cast<sal_Int16>(
1193 getDefault<drawing::LineStyle>( rShape, rAttrName )),
1194 &ShapeAttributeLayer::getLineStyle,
1195 &ShapeAttributeLayer::setLineStyle,
1196 eAttrType,
1197 pBox2DWorld );
1198
1199 case AttributeType::CharPosture:
1200 return makeGenericAnimation<EnumAnimation>( rShapeManager,
1201 nFlags,
1202 &ShapeAttributeLayer::isCharPostureValid,
1203 sal::static_int_cast<sal_Int16>(
1204 getDefault<awt::FontSlant>( rShape, rAttrName )),
1205 &ShapeAttributeLayer::getCharPosture,
1206 &ShapeAttributeLayer::setCharPosture,
1207 eAttrType,
1208 pBox2DWorld );
1209
1210 case AttributeType::CharUnderline:
1211 return makeGenericAnimation<EnumAnimation>( rShapeManager,
1212 nFlags,
1213 &ShapeAttributeLayer::isUnderlineModeValid,
1214 getDefault<sal_Int16>( rShape, rAttrName ),
1215 &ShapeAttributeLayer::getUnderlineMode,
1216 &ShapeAttributeLayer::setUnderlineMode,
1217 eAttrType,
1218 pBox2DWorld );
1219 }
1220
1221 return EnumAnimationSharedPtr();
1222 }
1223
1224 ColorAnimationSharedPtr AnimationFactory::createColorPropertyAnimation( const OUString& rAttrName,
1225 const AnimatableShapeSharedPtr& rShape,
1226 const ShapeManagerSharedPtr& rShapeManager,
1227 const ::basegfx::B2DVector& /*rSlideSize*/,
1228 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1229 int nFlags )
1230 {
1231 // ATTENTION: When changing this map, also the classifyAttributeName() method must
1232 // be checked and possibly adapted in their switch statement
1233 AttributeType eAttrType = mapAttributeName(rAttrName);
1234 switch( eAttrType )
1235 {
1236 default:
1237 case AttributeType::Invalid:
1238 ENSURE_OR_THROW( false,
1239 "AnimationFactory::createColorPropertyAnimation(): Unknown attribute" );
1240 break;
1241
1242 case AttributeType::CharFontName:
1243 case AttributeType::CharHeight:
1244 case AttributeType::CharPosture:
1245 case AttributeType::CharUnderline:
1246 case AttributeType::CharWeight:
1247 case AttributeType::FillStyle:
1248 case AttributeType::Height:
1249 case AttributeType::LineStyle:
1250 case AttributeType::Opacity:
1251 case AttributeType::Rotate:
1252 case AttributeType::SkewX:
1253 case AttributeType::SkewY:
1254 case AttributeType::Visibility:
1255 case AttributeType::Width:
1256 case AttributeType::PosX:
1257 case AttributeType::PosY:
1258 ENSURE_OR_THROW( false,
1259 "AnimationFactory::createColorPropertyAnimation(): Attribute type mismatch" );
1260 break;
1261
1262 case AttributeType::CharColor:
1263 return makeGenericAnimation<ColorAnimation>( rShapeManager,
1264 nFlags,
1265 &ShapeAttributeLayer::isCharColorValid,
1266 getDefault<RGBColor>( rShape, rAttrName ),
1267 &ShapeAttributeLayer::getCharColor,
1268 &ShapeAttributeLayer::setCharColor,
1269 eAttrType,
1270 pBox2DWorld );
1271
1272 case AttributeType::Color:
1273 // TODO(F2): This is just mapped to fill color to make it work
1274 return makeGenericAnimation<ColorAnimation>( rShapeManager,
1275 nFlags,
1276 &ShapeAttributeLayer::isFillColorValid,
1277 getDefault<RGBColor>( rShape, rAttrName ),
1278 &ShapeAttributeLayer::getFillColor,
1279 &ShapeAttributeLayer::setFillColor,
1280 eAttrType,
1281 pBox2DWorld );
1282
1283 case AttributeType::DimColor:
1284 return makeGenericAnimation<ColorAnimation>( rShapeManager,
1285 nFlags,
1286 &ShapeAttributeLayer::isDimColorValid,
1287 getDefault<RGBColor>( rShape, rAttrName ),
1288 &ShapeAttributeLayer::getDimColor,
1289 &ShapeAttributeLayer::setDimColor,
1290 eAttrType,
1291 pBox2DWorld );
1292
1293 case AttributeType::FillColor:
1294 return makeGenericAnimation<ColorAnimation>( rShapeManager,
1295 nFlags,
1296 &ShapeAttributeLayer::isFillColorValid,
1297 getDefault<RGBColor>( rShape, rAttrName ),
1298 &ShapeAttributeLayer::getFillColor,
1299 &ShapeAttributeLayer::setFillColor,
1300 eAttrType,
1301 pBox2DWorld );
1302
1303 case AttributeType::LineColor:
1304 return makeGenericAnimation<ColorAnimation>( rShapeManager,
1305 nFlags,
1306 &ShapeAttributeLayer::isLineColorValid,
1307 getDefault<RGBColor>( rShape, rAttrName ),
1308 &ShapeAttributeLayer::getLineColor,
1309 &ShapeAttributeLayer::setLineColor,
1310 eAttrType,
1311 pBox2DWorld );
1312 }
1313
1314 return ColorAnimationSharedPtr();
1315 }
1316
1317 PairAnimationSharedPtr AnimationFactory::createPairPropertyAnimation( const AnimatableShapeSharedPtr& rShape,
1318 const ShapeManagerSharedPtr& rShapeManager,
1319 const ::basegfx::B2DVector& rSlideSize,
1320 sal_Int16 nTransformType,
1321 int nFlags )
1322 {
1323 const ::basegfx::B2DRectangle& rBounds( rShape->getBounds() );
1324
1325 switch( nTransformType )
1326 {
1327 case animations::AnimationTransformType::SCALE:
1328 return std::make_shared<TupleAnimation< ::basegfx::B2DSize >>(
1329 rShapeManager,
1330 nFlags,
1331 &ShapeAttributeLayer::isWidthValid,
1332 &ShapeAttributeLayer::isHeightValid,
1333 // TODO(F1): Check whether _shape_ bounds are correct here.
1334 // Theoretically, our AttrLayer is way down the stack, and
1335 // we only have to consider _that_ value, not the one from
1336 // the top of the stack as returned by Shape::getBounds()
1337 basegfx::B2DSize(rBounds.getRange().getX(), rBounds.getRange().getY()),
1338 basegfx::B2DSize(rBounds.getRange().getX(), rBounds.getRange().getY()),
1339 &ShapeAttributeLayer::getWidth,
1340 &ShapeAttributeLayer::getHeight,
1341 &ShapeAttributeLayer::setSize );
1342
1343 case animations::AnimationTransformType::TRANSLATE:
1344 return std::make_shared<TupleAnimation< ::basegfx::B2DPoint >>(
1345 rShapeManager,
1346 nFlags,
1347 &ShapeAttributeLayer::isPosXValid,
1348 &ShapeAttributeLayer::isPosYValid,
1349 // TODO(F1): Check whether _shape_ bounds are correct here.
1350 // Theoretically, our AttrLayer is way down the stack, and
1351 // we only have to consider _that_ value, not the one from
1352 // the top of the stack as returned by Shape::getBounds()
1353 rBounds.getCenter(),
1354 basegfx::B2DSize(rSlideSize.getX(), rSlideSize.getY()),
1355 &ShapeAttributeLayer::getPosX,
1356 &ShapeAttributeLayer::getPosY,
1357 &ShapeAttributeLayer::setPosition );
1358
1359 default:
1360 ENSURE_OR_THROW( false,
1361 "AnimationFactory::createPairPropertyAnimation(): Attribute type mismatch" );
1362 break;
1363 }
1364
1365 return PairAnimationSharedPtr();
1366 }
1367
1368 StringAnimationSharedPtr AnimationFactory::createStringPropertyAnimation( const OUString& rAttrName,
1369 const AnimatableShapeSharedPtr& rShape,
1370 const ShapeManagerSharedPtr& rShapeManager,
1371 const ::basegfx::B2DVector& /*rSlideSize*/,
1372 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1373 int nFlags )
1374 {
1375 // ATTENTION: When changing this map, also the classifyAttributeName() method must
1376 // be checked and possibly adapted in their switch statement
1377 AttributeType eAttrType = mapAttributeName(rAttrName);
1378 switch( eAttrType )
1379 {
1380 default:
1381 case AttributeType::Invalid:
1382 ENSURE_OR_THROW( false,
1383 "AnimationFactory::createStringPropertyAnimation(): Unknown attribute" );
1384 break;
1385
1386 case AttributeType::CharColor:
1387 case AttributeType::CharHeight:
1388 case AttributeType::CharUnderline:
1389 case AttributeType::Color:
1390 case AttributeType::DimColor:
1391 case AttributeType::FillColor:
1392 case AttributeType::Height:
1393 case AttributeType::LineColor:
1394 case AttributeType::Opacity:
1395 case AttributeType::Rotate:
1396 case AttributeType::SkewX:
1397 case AttributeType::SkewY:
1398 case AttributeType::Visibility:
1399 case AttributeType::Width:
1400 case AttributeType::PosX:
1401 case AttributeType::PosY:
1402 case AttributeType::CharPosture:
1403 case AttributeType::CharWeight:
1404 case AttributeType::FillStyle:
1405 case AttributeType::LineStyle:
1406 ENSURE_OR_THROW( false,
1407 "AnimationFactory::createStringPropertyAnimation(): Attribute type mismatch" );
1408 break;
1409
1410 case AttributeType::CharFontName:
1411 return makeGenericAnimation<StringAnimation>( rShapeManager,
1412 nFlags,
1413 &ShapeAttributeLayer::isFontFamilyValid,
1414 getDefault< OUString >( rShape, rAttrName ),
1415 &ShapeAttributeLayer::getFontFamily,
1416 &ShapeAttributeLayer::setFontFamily,
1417 eAttrType,
1418 pBox2DWorld );
1419 }
1420
1421 return StringAnimationSharedPtr();
1422 }
1423
1424 BoolAnimationSharedPtr AnimationFactory::createBoolPropertyAnimation( const OUString& rAttrName,
1425 const AnimatableShapeSharedPtr& /*rShape*/,
1426 const ShapeManagerSharedPtr& rShapeManager,
1427 const ::basegfx::B2DVector& /*rSlideSize*/,
1428 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1429 int nFlags )
1430 {
1431 // ATTENTION: When changing this map, also the classifyAttributeName() method must
1432 // be checked and possibly adapted in their switch statement
1433 AttributeType eAttrType = mapAttributeName(rAttrName);
1434 switch( eAttrType )
1435 {
1436 default:
1437 case AttributeType::Invalid:
1438 ENSURE_OR_THROW( false,
1439 "AnimationFactory::createBoolPropertyAnimation(): Unknown attribute" );
1440 break;
1441
1442 case AttributeType::CharColor:
1443 case AttributeType::CharFontName:
1444 case AttributeType::CharHeight:
1445 case AttributeType::CharPosture:
1446 case AttributeType::CharWeight:
1447 case AttributeType::Color:
1448 case AttributeType::DimColor:
1449 case AttributeType::FillColor:
1450 case AttributeType::FillStyle:
1451 case AttributeType::Height:
1452 case AttributeType::LineColor:
1453 case AttributeType::LineStyle:
1454 case AttributeType::Opacity:
1455 case AttributeType::Rotate:
1456 case AttributeType::SkewX:
1457 case AttributeType::SkewY:
1458 case AttributeType::Width:
1459 case AttributeType::PosX:
1460 case AttributeType::PosY:
1461 case AttributeType::CharUnderline:
1462 ENSURE_OR_THROW( false,
1463 "AnimationFactory::createBoolPropertyAnimation(): Attribute type mismatch" );
1464 break;
1465
1466 case AttributeType::Visibility:
1467 return makeGenericAnimation<BoolAnimation>( rShapeManager,
1468 nFlags,
1469 &ShapeAttributeLayer::isVisibilityValid,
1470 // TODO(F1): Is there a corresponding shape property?
1471 true,
1472 &ShapeAttributeLayer::getVisibility,
1473 &ShapeAttributeLayer::setVisibility,
1474 eAttrType,
1475 pBox2DWorld );
1476 }
1477
1478 return BoolAnimationSharedPtr();
1479 }
1480
1481 NumberAnimationSharedPtr AnimationFactory::createPathMotionAnimation( const OUString& rSVGDPath,
1482 sal_Int16 nAdditive,
1483 const AnimatableShapeSharedPtr& /*rShape*/,
1484 const ShapeManagerSharedPtr& rShapeManager,
1485 const ::basegfx::B2DVector& rSlideSize,
1486 const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1487 int nFlags )
1488 {
1489 return std::make_shared<PathAnimation>( rSVGDPath, nAdditive,
1490 rShapeManager,
1491 rSlideSize,
1492 nFlags,
1493 pBox2DWorld);
1494 }
1495
1496 NumberAnimationSharedPtr AnimationFactory::createPhysicsAnimation( const box2d::utils::Box2DWorldSharedPtr& pBox2DWorld,
1497 const double fDuration,
1498 const ShapeManagerSharedPtr& rShapeManager,
1499 const ::basegfx::B2DVector& rSlideSize,
1500 const ::basegfx::B2DVector& rStartVelocity,
1501 const double fDensity,
1502 const double fBounciness,
1503 int nFlags )
1504 {
1505 return std::make_shared<PhysicsAnimation>( pBox2DWorld, fDuration,
1506 rShapeManager,
1507 rSlideSize,
1508 rStartVelocity,
1509 fDensity,
1510 fBounciness,
1511 nFlags );
1512 }
1513
1514}
1515
1516/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
maStartVelocity
const ::basegfx::B2DVector maStartVelocity
Definition: animationfactory.cxx:516
mnFlags
const int mnFlags
Definition: animationfactory.cxx:193
mfDuration
double mfDuration
Definition: animationfactory.cxx:515
mpShapeManager
ShapeManagerSharedPtr mpShapeManager
Definition: animationfactory.cxx:186
mbIsBox2dWorldStepper
bool mbIsBox2dWorldStepper
Definition: animationfactory.cxx:520
mbAnimationStarted
bool mbAnimationStarted
Definition: animationfactory.cxx:197
mfDensity
const double mfDensity
Definition: animationfactory.cxx:517
maReferenceSize
const ::basegfx::B2DSize maReferenceSize
Definition: animationfactory.cxx:195
mpShape
AnimatableShapeSharedPtr mpShape
Definition: animationfactory.cxx:184
mfBounciness
const double mfBounciness
Definition: animationfactory.cxx:518
maDefaultValue
const ValueT maDefaultValue
Definition: animationfactory.cxx:196
mpGet1stValueFunc
double(ShapeAttributeLayer::* mpGet1stValueFunc)() const
Definition: animationfactory.cxx:189
mnScale
double mnScale
Definition: animationfactory.cxx:824
mpAttrLayer
ShapeAttributeLayerSharedPtr mpAttrLayer
Definition: animationfactory.cxx:185
maPageSize
const ::basegfx::B2DSize maPageSize
Definition: animationfactory.cxx:359
mpGetValueFunc
ValueT(ShapeAttributeLayer::* mpGetValueFunc)() const
Definition: animationfactory.cxx:756
mpIs1stValidFunc
bool(ShapeAttributeLayer::* mpIs1stValidFunc)() const
Definition: animationfactory.cxx:187
mpBox2DBody
box2d::utils::Box2DBodySharedPtr mpBox2DBody
Definition: animationfactory.cxx:513
mpIsValidFunc
bool(ShapeAttributeLayer::* mpIsValidFunc)() const
Definition: animationfactory.cxx:755
mpSetValueFunc
void(ShapeAttributeLayer::* mpSetValueFunc)(const ValueT &)
Definition: animationfactory.cxx:191
maShapeOrig
::basegfx::B2DPoint maShapeOrig
Definition: animationfactory.cxx:360
mbAnimationFirstUpdate
bool mbAnimationFirstUpdate
Definition: animationfactory.cxx:363
maSetterModifier
ModifierFunctor maSetterModifier
Definition: animationfactory.cxx:760
maPathPoly
::basegfx::B2DPolygon maPathPoly
Definition: animationfactory.cxx:355
mfPreviousElapsedTime
double mfPreviousElapsedTime
Definition: animationfactory.cxx:519
meAttrType
const AttributeType meAttrType
Definition: animationfactory.cxx:768
mpIs2ndValidFunc
bool(ShapeAttributeLayer::* mpIs2ndValidFunc)() const
Definition: animationfactory.cxx:188
maGetterModifier
ModifierFunctor maGetterModifier
Definition: animationfactory.cxx:759
mpGet2ndValueFunc
double(ShapeAttributeLayer::* mpGet2ndValueFunc)() const
Definition: animationfactory.cxx:190
mnAdditive
sal_Int16 mnAdditive
Definition: animationfactory.cxx:364
mpBox2DWorld
box2d::utils::Box2DWorldSharedPtr mpBox2DWorld
Definition: animationfactory.cxx:365
basegfx::B2DPolyPolygon::getB2DPolygon
B2DPolygon const & getB2DPolygon(sal_uInt32 nIndex) const
basegfx::B2DPolyPolygon::count
sal_uInt32 count() const
basegfx::Size2D::getWidth
TYPE getWidth() const
basegfx::Size2D::getHeight
TYPE getHeight() const
basegfx::Tuple2D::setY
void setY(TYPE fY)
basegfx::Tuple2D::setX
void setX(TYPE fX)
slideshow::internal::ShapeAttributeLayer::setCharPosture
void setCharPosture(const sal_Int16 &rStyle)
Set the italic style globally for the whole shape.
Definition: shapeattributelayer.cxx:729
slideshow::internal::ShapeAttributeLayer::setWidth
void setWidth(const double &rNewWidth)
Set the new width of the shape.
Definition: shapeattributelayer.cxx:268
slideshow::internal::ShapeAttributeLayer::getFontFamily
OUString getFontFamily() const
Get the current text font family for the whole shape.
Definition: shapeattributelayer.cxx:693
slideshow::internal::ShapeAttributeLayer::getShearYAngle
double getShearYAngle() const
Query the current shear angle at the y axis of the shape.
Definition: shapeattributelayer.cxx:420
slideshow::internal::ShapeAttributeLayer::setVisibility
void setVisibility(const bool &bVisible)
Set the shape visibility.
Definition: shapeattributelayer.cxx:611
slideshow::internal::ShapeAttributeLayer::setShearYAngle
void setShearYAngle(const double &rNewAngle)
Set the new shear angle at the y axis of the shape.
Definition: shapeattributelayer.cxx:428
slideshow::internal::ShapeAttributeLayer::getFillColor
RGBColor getFillColor() const
Get the fill color for the whole shape.
Definition: shapeattributelayer.cxx:509
slideshow::internal::ShapeAttributeLayer::getDimColor
RGBColor getDimColor() const
Get the dim color for the whole shape.
Definition: shapeattributelayer.cxx:489
slideshow::internal::ShapeAttributeLayer::isUnderlineModeValid
bool isUnderlineModeValid() const
Query whether the underline mode attribute is valid.
Definition: shapeattributelayer.cxx:663
slideshow::internal::ShapeAttributeLayer::isShearXAngleValid
bool isShearXAngleValid() const
Query whether the shear x angle attribute is valid.
Definition: shapeattributelayer.cxx:392
slideshow::internal::ShapeAttributeLayer::setFontFamily
void setFontFamily(const OUString &rName)
Set the text font family name globally for the whole shape.
Definition: shapeattributelayer.cxx:705
slideshow::internal::ShapeAttributeLayer::setPosX
void setPosX(const double &rNewX)
Set the new x position of the shape.
Definition: shapeattributelayer.cxx:327
slideshow::internal::ShapeAttributeLayer::setLineStyle
void setLineStyle(const sal_Int16 &rStyle)
Set line style for the whole shape.
Definition: shapeattributelayer.cxx:586
slideshow::internal::ShapeAttributeLayer::setSize
void setSize(const ::basegfx::B2DSize &rNewSize)
Set the new size of the shape.
Definition: shapeattributelayer.cxx:302
slideshow::internal::ShapeAttributeLayer::isShearYAngleValid
bool isShearYAngleValid() const
Query whether the shear y angle attribute is valid.
Definition: shapeattributelayer.cxx:415
slideshow::internal::ShapeAttributeLayer::getCharWeight
double getCharWeight() const
Get the current char weight value for the whole shape.
Definition: shapeattributelayer.cxx:643
slideshow::internal::ShapeAttributeLayer::setCharWeight
void setCharWeight(const double &rStyle)
Set the char weight globally for the whole shape.
Definition: shapeattributelayer.cxx:655
slideshow::internal::ShapeAttributeLayer::setAlpha
void setAlpha(const double &rNewValue)
Set the new alpha value of the shape.
Definition: shapeattributelayer.cxx:451
slideshow::internal::ShapeAttributeLayer::isCharPostureValid
bool isCharPostureValid() const
Query whether the italic mode attribute is valid.
Definition: shapeattributelayer.cxx:712
slideshow::internal::ShapeAttributeLayer::setPosition
void setPosition(const ::basegfx::B2DPoint &rNewPos)
Set the new position of the shape.
Definition: shapeattributelayer.cxx:361
slideshow::internal::ShapeAttributeLayer::setFillStyle
void setFillStyle(const sal_Int16 &rStyle)
Changes polygon fillings.
Definition: shapeattributelayer.cxx:561
slideshow::internal::ShapeAttributeLayer::isFillColorValid
bool isFillColorValid() const
Query whether the fill color attribute is valid.
Definition: shapeattributelayer.cxx:504
slideshow::internal::ShapeAttributeLayer::setUnderlineMode
void setUnderlineMode(const sal_Int16 &bUnderline)
Set the underline status globally for the whole shape.
Definition: shapeattributelayer.cxx:680
slideshow::internal::ShapeAttributeLayer::setHeight
void setHeight(const double &rNewHeight)
Set the new height of the shape.
Definition: shapeattributelayer.cxx:292
slideshow::internal::ShapeAttributeLayer::isLineColorValid
bool isLineColorValid() const
Query whether the line color attribute is valid.
Definition: shapeattributelayer.cxx:524
slideshow::internal::ShapeAttributeLayer::isFontFamilyValid
bool isFontFamilyValid() const
Query whether the font family attribute is valid.
Definition: shapeattributelayer.cxx:688
slideshow::internal::ShapeAttributeLayer::isVisibilityValid
bool isVisibilityValid() const
Query whether the visibility state attribute is valid.
Definition: shapeattributelayer.cxx:594
slideshow::internal::ShapeAttributeLayer::isRotationAngleValid
bool isRotationAngleValid() const
Query whether the rotation angle attribute is valid.
Definition: shapeattributelayer.cxx:368
slideshow::internal::ShapeAttributeLayer::getCharColor
RGBColor getCharColor() const
Get the text color for the whole shape.
Definition: shapeattributelayer.cxx:623
slideshow::internal::ShapeAttributeLayer::getPosY
double getPosY() const
Query the current y position of the shape.
Definition: shapeattributelayer.cxx:342
slideshow::internal::ShapeAttributeLayer::setRotationAngle
void setRotationAngle(const double &rNewAngle)
Set the new rotation angle of the shape.
Definition: shapeattributelayer.cxx:382
slideshow::internal::ShapeAttributeLayer::isCharColorValid
bool isCharColorValid() const
Query whether the char color attribute is valid.
Definition: shapeattributelayer.cxx:618
slideshow::internal::ShapeAttributeLayer::getLineStyle
sal_Int16 getLineStyle() const
Get the current line mode for line drawing.
Definition: shapeattributelayer.cxx:574
slideshow::internal::ShapeAttributeLayer::setCharColor
void setCharColor(const RGBColor &nNewColor)
Set the text color globally for the whole shape.
Definition: shapeattributelayer.cxx:631
slideshow::internal::ShapeAttributeLayer::isCharScaleValid
bool isCharScaleValid() const
Query whether the char scaling attribute is valid.
Definition: shapeattributelayer.cxx:737
slideshow::internal::ShapeAttributeLayer::isPosXValid
bool isPosXValid() const
Query whether the x position attribute is valid.
Definition: shapeattributelayer.cxx:313
slideshow::internal::ShapeAttributeLayer::isDimColorValid
bool isDimColorValid() const
Query whether the dim color attribute is valid.
Definition: shapeattributelayer.cxx:484
slideshow::internal::ShapeAttributeLayer::getShearXAngle
double getShearXAngle() const
Query the current shear angle at the x axis of the shape.
Definition: shapeattributelayer.cxx:397
slideshow::internal::ShapeAttributeLayer::getFillStyle
sal_Int16 getFillStyle() const
Get the current fill mode for polygon fillings.
Definition: shapeattributelayer.cxx:549
slideshow::internal::ShapeAttributeLayer::getAlpha
double getAlpha() const
Query the current alpha value of the shape.
Definition: shapeattributelayer.cxx:443
slideshow::internal::ShapeAttributeLayer::isWidthValid
bool isWidthValid() const
Query whether the width attribute is valid.
Definition: shapeattributelayer.cxx:254
slideshow::internal::ShapeAttributeLayer::setFillColor
void setFillColor(const RGBColor &nNewColor)
Set the fill color globally for the whole shape.
Definition: shapeattributelayer.cxx:517
slideshow::internal::ShapeAttributeLayer::setCharScale
void setCharScale(const double &rNewScale)
Set the new char scale globally for the shape.
Definition: shapeattributelayer.cxx:750
slideshow::internal::ShapeAttributeLayer::isPosYValid
bool isPosYValid() const
Query whether the y position attribute is valid.
Definition: shapeattributelayer.cxx:337
slideshow::internal::ShapeAttributeLayer::isAlphaValid
bool isAlphaValid() const
Query whether the alpha attribute is valid.
Definition: shapeattributelayer.cxx:438
slideshow::internal::ShapeAttributeLayer::getRotationAngle
double getRotationAngle() const
Query the current rotation angle of the shape.
Definition: shapeattributelayer.cxx:373
slideshow::internal::ShapeAttributeLayer::setDimColor
void setDimColor(const RGBColor &nNewColor)
Set the dim color globally for the whole shape.
Definition: shapeattributelayer.cxx:497
slideshow::internal::ShapeAttributeLayer::isLineStyleValid
bool isLineStyleValid() const
Query whether the line mode attribute is valid.
Definition: shapeattributelayer.cxx:569
slideshow::internal::ShapeAttributeLayer::getHeight
double getHeight() const
Query the current height of the shape.
Definition: shapeattributelayer.cxx:283
slideshow::internal::ShapeAttributeLayer::getWidth
double getWidth() const
Query the current width of the shape.
Definition: shapeattributelayer.cxx:259
slideshow::internal::ShapeAttributeLayer::getUnderlineMode
sal_Int16 getUnderlineMode() const
Get the current text underline status for the whole shape.
Definition: shapeattributelayer.cxx:668
slideshow::internal::ShapeAttributeLayer::isFillStyleValid
bool isFillStyleValid() const
Query whether the fill mode attribute is valid.
Definition: shapeattributelayer.cxx:544
slideshow::internal::ShapeAttributeLayer::getCharPosture
sal_Int16 getCharPosture() const
Get the current text italic style for the whole shape.
Definition: shapeattributelayer.cxx:717
slideshow::internal::ShapeAttributeLayer::isCharWeightValid
bool isCharWeightValid() const
Query whether the char weight attribute is valid.
Definition: shapeattributelayer.cxx:638
slideshow::internal::ShapeAttributeLayer::getVisibility
bool getVisibility() const
Get the current shape visibility.
Definition: shapeattributelayer.cxx:599
slideshow::internal::ShapeAttributeLayer::getPosX
double getPosX() const
Query the current x position of the shape.
Definition: shapeattributelayer.cxx:318
slideshow::internal::ShapeAttributeLayer::setShearXAngle
void setShearXAngle(const double &rNewAngle)
Set the new shear angle at the x axis of the shape.
Definition: shapeattributelayer.cxx:405
slideshow::internal::ShapeAttributeLayer::getCharScale
double getCharScale() const
Query the current char scaling attribute globally for the shape.
Definition: shapeattributelayer.cxx:742
slideshow::internal::ShapeAttributeLayer::setLineColor
void setLineColor(const RGBColor &nNewColor)
Set the line color globally for the whole shape.
Definition: shapeattributelayer.cxx:537
slideshow::internal::ShapeAttributeLayer::getLineColor
RGBColor getLineColor() const
Get the line color for the whole shape.
Definition: shapeattributelayer.cxx:529
slideshow::internal::ShapeAttributeLayer::isHeightValid
bool isHeightValid() const
Query whether the height attribute is valid.
Definition: shapeattributelayer.cxx:278
slideshow::internal::ShapeAttributeLayer::setPosY
void setPosY(const double &rNewY)
Set the new y position of the shape.
Definition: shapeattributelayer.cxx:351
diagnose_ex.hxx
ENSURE_OR_RETURN_FALSE
#define ENSURE_OR_RETURN_FALSE(c, m)
ENSURE_OR_THROW
#define ENSURE_OR_THROW(c, m)
x
float x
nValue
sal_Int16 nValue
SAL_WARN
#define SAL_WARN(area, stream)
SAL_INFO
#define SAL_INFO(area, stream)
box2d::utils::Box2DBodySharedPtr
std::shared_ptr< box2DBody > Box2DBodySharedPtr
Definition: box2dtools.hxx:32
box2d::utils::Box2DWorldSharedPtr
::std::shared_ptr< box2DWorld > Box2DWorldSharedPtr
Definition: slideshowimpl.cxx:94
end
end
ValueType
ValueType
slideshow::internal::AnimationFactory::FLAG_NO_SPRITE
@ FLAG_NO_SPRITE
Don't call enter/leaveAnimation for the Shape.
Definition: animationfactory.hxx:77
slideshow::internal::AnimationFactory::createNumberPropertyAnimation
NumberAnimationSharedPtr createNumberPropertyAnimation(const OUString &rAttrName, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags=0)
Definition: animationfactory.cxx:970
slideshow::internal::AnimationFactory::createPairPropertyAnimation
PairAnimationSharedPtr createPairPropertyAnimation(const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, sal_Int16 nTransformType, int nFlags)
Create scale or move animation.
Definition: animationfactory.cxx:1317
slideshow::internal::AnimationFactory::createPhysicsAnimation
NumberAnimationSharedPtr createPhysicsAnimation(const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, const double fDuration, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const ::basegfx::B2DVector &rStartVelocity, const double fDensity, const double fBounciness, int nFlags)
Definition: animationfactory.cxx:1496
slideshow::internal::AnimationFactory::classifyAttributeName
AttributeClass classifyAttributeName(const OUString &rAttrName)
Definition: animationfactory.cxx:924
slideshow::internal::AnimationFactory::createColorPropertyAnimation
ColorAnimationSharedPtr createColorPropertyAnimation(const OUString &rAttrName, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags=0)
Definition: animationfactory.cxx:1224
slideshow::internal::AnimationFactory::createPathMotionAnimation
NumberAnimationSharedPtr createPathMotionAnimation(const OUString &rSVGDPath, sal_Int16 nAdditive, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags)
Definition: animationfactory.cxx:1481
slideshow::internal::AnimationFactory::AttributeClass
AttributeClass
Classifies the attribute name.
Definition: animationfactory.hxx:53
slideshow::internal::AnimationFactory::CLASS_STRING_PROPERTY
@ CLASS_STRING_PROPERTY
Use createStringPropertyAnimation.
Definition: animationfactory.hxx:63
slideshow::internal::AnimationFactory::CLASS_UNKNOWN_PROPERTY
@ CLASS_UNKNOWN_PROPERTY
Unknown, prolly invalid name.
Definition: animationfactory.hxx:55
slideshow::internal::AnimationFactory::CLASS_COLOR_PROPERTY
@ CLASS_COLOR_PROPERTY
Use createColorPropertyAnimation.
Definition: animationfactory.hxx:61
slideshow::internal::AnimationFactory::CLASS_BOOL_PROPERTY
@ CLASS_BOOL_PROPERTY
Use createBoolPropertyAnimation.
Definition: animationfactory.hxx:65
slideshow::internal::AnimationFactory::CLASS_NUMBER_PROPERTY
@ CLASS_NUMBER_PROPERTY
Use createNumberPropertyAnimation.
Definition: animationfactory.hxx:57
slideshow::internal::AnimationFactory::CLASS_ENUM_PROPERTY
@ CLASS_ENUM_PROPERTY
Use createEnumPropertyAnimation.
Definition: animationfactory.hxx:59
slideshow::internal::AnimationFactory::createBoolPropertyAnimation
BoolAnimationSharedPtr createBoolPropertyAnimation(const OUString &rAttrName, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags)
Definition: animationfactory.cxx:1424
slideshow::internal::AnimationFactory::createEnumPropertyAnimation
EnumAnimationSharedPtr createEnumPropertyAnimation(const OUString &rAttrName, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags)
Definition: animationfactory.cxx:1137
slideshow::internal::AnimationFactory::createStringPropertyAnimation
StringAnimationSharedPtr createStringPropertyAnimation(const OUString &rAttrName, const AnimatableShapeSharedPtr &rShape, const ShapeManagerSharedPtr &rShapeManager, const ::basegfx::B2DVector &rSlideSize, const box2d::utils::Box2DWorldSharedPtr &pBox2DWorld, int nFlags)
Definition: animationfactory.cxx:1368
slideshow::internal::NumberAnimationSharedPtr
::std::shared_ptr< NumberAnimation > NumberAnimationSharedPtr
Definition: numberanimation.hxx:64
slideshow::internal::AnimatableShapeSharedPtr
::std::shared_ptr< AnimatableShape > AnimatableShapeSharedPtr
Definition: animatableshape.hxx:73
slideshow::internal::ShapeAttributeLayerSharedPtr
::std::shared_ptr< ShapeAttributeLayer > ShapeAttributeLayerSharedPtr
Definition: shapeattributelayer.hxx:54
slideshow::internal::PairAnimationSharedPtr
::std::shared_ptr< PairAnimation > PairAnimationSharedPtr
Definition: pairanimation.hxx:63
slideshow::internal::BoolAnimationSharedPtr
::std::shared_ptr< BoolAnimation > BoolAnimationSharedPtr
Definition: boolanimation.hxx:62
slideshow::internal::EnumAnimationSharedPtr
::std::shared_ptr< EnumAnimation > EnumAnimationSharedPtr
Definition: enumanimation.hxx:64
slideshow::internal::StringAnimationSharedPtr
::std::shared_ptr< StringAnimation > StringAnimationSharedPtr
Definition: stringanimation.hxx:62
slideshow::internal::AttributeType
AttributeType
Type of to-be-animated attribute.
Definition: attributemap.hxx:35
slideshow::internal::ShapeManagerSharedPtr
std::shared_ptr< ShapeManager > ShapeManagerSharedPtr
Definition: box2dtools.hxx:23
slideshow::internal::ColorAnimationSharedPtr
::std::shared_ptr< ColorAnimation > ColorAnimationSharedPtr
Definition: coloranimation.hxx:62
slideshow::internal::mapAttributeName
AttributeType mapAttributeName(const OUString &rAttrName)
Map attribute name to AttributeType enum.
Definition: attributemap.cxx:31
Generated on Sun Jul 30 2023 04:26:34 for LibreOffice Module slideshow (master) by doxygen 1.9.3