Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : // must be first
22 : #include <canvas/debug.hxx>
23 : #include <tools/diagnose_ex.h>
24 : #include <canvas/verbosetrace.hxx>
25 :
26 : #include <animationfactory.hxx>
27 : #include <attributemap.hxx>
28 :
29 : #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
30 : #include <com/sun/star/animations/AnimationTransformType.hpp>
31 : #include <com/sun/star/beans/XPropertySet.hpp>
32 : #include <com/sun/star/drawing/FillStyle.hpp>
33 : #include <com/sun/star/drawing/LineStyle.hpp>
34 : #include <com/sun/star/awt/FontSlant.hpp>
35 : #include <com/sun/star/awt/FontUnderline.hpp>
36 : #include <com/sun/star/awt/FontWeight.hpp>
37 :
38 : #include <basegfx/polygon/b2dpolygon.hxx>
39 : #include <basegfx/polygon/b2dpolygontools.hxx>
40 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
41 :
42 : #include <functional>
43 :
44 :
45 : using namespace ::com::sun::star;
46 :
47 :
48 : namespace slideshow
49 : {
50 : namespace internal
51 : {
52 : namespace
53 : {
54 : // attention, there is a similar implementation of Animation in
55 : // transitions/transitionfactory.cxx
56 :
57 : template< typename ValueT > class TupleAnimation : public PairAnimation
58 : {
59 : public:
60 0 : TupleAnimation( const ShapeManagerSharedPtr& rShapeManager,
61 : int nFlags,
62 : bool (ShapeAttributeLayer::*pIs1stValid)() const,
63 : bool (ShapeAttributeLayer::*pIs2ndValid)() const,
64 : const ValueT& rDefaultValue,
65 : const ::basegfx::B2DSize& rReferenceSize,
66 : double (ShapeAttributeLayer::*pGet1stValue)() const,
67 : double (ShapeAttributeLayer::*pGet2ndValue)() const,
68 : void (ShapeAttributeLayer::*pSetValue)( const ValueT& ) ) :
69 : mpShape(),
70 : mpAttrLayer(),
71 : mpShapeManager( rShapeManager ),
72 : mpIs1stValidFunc(pIs1stValid),
73 : mpIs2ndValidFunc(pIs2ndValid),
74 : mpGet1stValueFunc(pGet1stValue),
75 : mpGet2ndValueFunc(pGet2ndValue),
76 : mpSetValueFunc(pSetValue),
77 : mnFlags( nFlags ),
78 : maReferenceSize( rReferenceSize ),
79 : maDefaultValue( rDefaultValue ),
80 0 : mbAnimationStarted( false )
81 : {
82 0 : ENSURE_OR_THROW( rShapeManager,
83 : "TupleAnimation::TupleAnimation(): Invalid ShapeManager" );
84 0 : ENSURE_OR_THROW( pIs1stValid && pIs2ndValid && pGet1stValue && pGet2ndValue && pSetValue,
85 : "TupleAnimation::TupleAnimation(): One of the method pointers is NULL" );
86 0 : }
87 :
88 0 : ~TupleAnimation()
89 : {
90 0 : end_();
91 0 : }
92 :
93 : // Animation interface
94 : // -------------------
95 0 : virtual void prefetch( const AnimatableShapeSharedPtr&,
96 : const ShapeAttributeLayerSharedPtr& )
97 0 : {}
98 :
99 0 : virtual void start( const AnimatableShapeSharedPtr& rShape,
100 : const ShapeAttributeLayerSharedPtr& rAttrLayer )
101 : {
102 : OSL_ENSURE( !mpShape,
103 : "TupleAnimation::start(): Shape already set" );
104 : OSL_ENSURE( !mpAttrLayer,
105 : "TupleAnimation::start(): Attribute layer already set" );
106 :
107 0 : mpShape = rShape;
108 0 : mpAttrLayer = rAttrLayer;
109 :
110 0 : ENSURE_OR_THROW( rShape,
111 : "TupleAnimation::start(): Invalid shape" );
112 0 : ENSURE_OR_THROW( rAttrLayer,
113 : "TupleAnimation::start(): Invalid attribute layer" );
114 :
115 0 : if( !mbAnimationStarted )
116 : {
117 0 : mbAnimationStarted = true;
118 :
119 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
120 0 : mpShapeManager->enterAnimationMode( mpShape );
121 : }
122 0 : }
123 :
124 0 : virtual void end() { end_(); }
125 0 : void end_()
126 : {
127 0 : if( mbAnimationStarted )
128 : {
129 0 : mbAnimationStarted = false;
130 :
131 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
132 0 : mpShapeManager->leaveAnimationMode( mpShape );
133 :
134 0 : if( mpShape->isContentChanged() )
135 0 : mpShapeManager->notifyShapeUpdate( mpShape );
136 : }
137 0 : }
138 :
139 : // PairAnimation interface
140 : // -----------------------
141 :
142 0 : virtual bool operator()( const ::basegfx::B2DTuple& rValue )
143 : {
144 0 : ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
145 : "TupleAnimation::operator(): Invalid ShapeAttributeLayer" );
146 :
147 : ValueT aValue( rValue.getX(),
148 0 : rValue.getY() );
149 :
150 : // Activitis get values from the expression parser,
151 : // which returns _relative_ sizes/positions.
152 : // Convert back relative to reference coordinate system
153 0 : aValue *= maReferenceSize;
154 :
155 0 : ((*mpAttrLayer).*mpSetValueFunc)( aValue );
156 :
157 0 : if( mpShape->isContentChanged() )
158 0 : mpShapeManager->notifyShapeUpdate( mpShape );
159 :
160 0 : return true;
161 : }
162 :
163 0 : virtual ::basegfx::B2DTuple getUnderlyingValue() const
164 : {
165 0 : ENSURE_OR_THROW( mpAttrLayer,
166 : "TupleAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
167 :
168 0 : ::basegfx::B2DTuple aRetVal;
169 :
170 : // deviated from the (*shared_ptr).*mpFuncPtr
171 : // notation here, since gcc does not seem to parse
172 : // that as a member function call anymore.
173 0 : aRetVal.setX( (mpAttrLayer.get()->*mpIs1stValidFunc)() ?
174 : (mpAttrLayer.get()->*mpGet1stValueFunc)() :
175 : maDefaultValue.getX() );
176 0 : aRetVal.setY( (mpAttrLayer.get()->*mpIs2ndValidFunc)() ?
177 : (mpAttrLayer.get()->*mpGet2ndValueFunc)() :
178 : maDefaultValue.getY() );
179 :
180 : // Activities get values from the expression
181 : // parser, which returns _relative_
182 : // sizes/positions. Convert start value to the
183 : // same coordinate space (i.e. relative to given
184 : // reference size).
185 0 : aRetVal /= maReferenceSize;
186 :
187 0 : return aRetVal;
188 : }
189 :
190 : private:
191 : AnimatableShapeSharedPtr mpShape;
192 : ShapeAttributeLayerSharedPtr mpAttrLayer;
193 : ShapeManagerSharedPtr mpShapeManager;
194 : bool (ShapeAttributeLayer::*mpIs1stValidFunc)() const;
195 : bool (ShapeAttributeLayer::*mpIs2ndValidFunc)() const;
196 : double (ShapeAttributeLayer::*mpGet1stValueFunc)() const;
197 : double (ShapeAttributeLayer::*mpGet2ndValueFunc)() const;
198 : void (ShapeAttributeLayer::*mpSetValueFunc)( const ValueT& );
199 :
200 : const int mnFlags;
201 :
202 : const ::basegfx::B2DSize maReferenceSize;
203 : const ValueT maDefaultValue;
204 : bool mbAnimationStarted;
205 : };
206 :
207 :
208 : class PathAnimation : public NumberAnimation
209 : {
210 : public:
211 0 : PathAnimation( const ::rtl::OUString& rSVGDPath,
212 : sal_Int16 nAdditive,
213 : const ShapeManagerSharedPtr& rShapeManager,
214 : const ::basegfx::B2DVector& rSlideSize,
215 : int nFlags ) :
216 : maPathPoly(),
217 : mpShape(),
218 : mpAttrLayer(),
219 : mpShapeManager( rShapeManager ),
220 : maPageSize( rSlideSize ),
221 : maShapeOrig(),
222 : mnFlags( nFlags ),
223 : mbAnimationStarted( false ),
224 0 : mnAdditive( nAdditive )
225 : {
226 0 : ENSURE_OR_THROW( rShapeManager,
227 : "PathAnimation::PathAnimation(): Invalid ShapeManager" );
228 :
229 0 : ::basegfx::B2DPolyPolygon aPolyPoly;
230 :
231 0 : ENSURE_OR_THROW( ::basegfx::tools::importFromSvgD( aPolyPoly, rSVGDPath ),
232 : "PathAnimation::PathAnimation(): failed to parse SVG:d path" );
233 0 : ENSURE_OR_THROW( aPolyPoly.count() == 1,
234 : "PathAnimation::PathAnimation(): motion path consists of multiple/zero polygon(s)" );
235 :
236 : // TODO(F2): Since getPositionRelative() currently
237 : // cannot handle beziers, have to subdivide.
238 : // AW: Should be no longer necessary; getPositionRelative is now bezier-safe
239 0 : maPathPoly = ::basegfx::tools::adaptiveSubdivideByAngle(aPolyPoly.getB2DPolygon(0) );
240 0 : }
241 :
242 0 : ~PathAnimation()
243 0 : {
244 0 : end_();
245 0 : }
246 :
247 : // Animation interface
248 : // -------------------
249 0 : virtual void prefetch( const AnimatableShapeSharedPtr&,
250 : const ShapeAttributeLayerSharedPtr& )
251 0 : {}
252 :
253 0 : virtual void start( const AnimatableShapeSharedPtr& rShape,
254 : const ShapeAttributeLayerSharedPtr& rAttrLayer )
255 : {
256 : OSL_ENSURE( !mpShape,
257 : "PathAnimation::start(): Shape already set" );
258 : OSL_ENSURE( !mpAttrLayer,
259 : "PathAnimation::start(): Attribute layer already set" );
260 :
261 0 : mpShape = rShape;
262 0 : mpAttrLayer = rAttrLayer;
263 :
264 0 : ENSURE_OR_THROW( rShape,
265 : "PathAnimation::start(): Invalid shape" );
266 0 : ENSURE_OR_THROW( rAttrLayer,
267 : "PathAnimation::start(): Invalid attribute layer" );
268 :
269 : // TODO(F1): Check whether _shape_ bounds are correct here.
270 : // Theoretically, our AttrLayer is way down the stack, and
271 : // we only have to consider _that_ value, not the one from
272 : // the top of the stack as returned by Shape::getBounds()
273 0 : if( mnAdditive == animations::AnimationAdditiveMode::SUM )
274 0 : maShapeOrig = mpShape->getBounds().getCenter();
275 : else
276 0 : maShapeOrig = mpShape->getDomBounds().getCenter();
277 :
278 0 : if( !mbAnimationStarted )
279 : {
280 0 : mbAnimationStarted = true;
281 :
282 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
283 0 : mpShapeManager->enterAnimationMode( mpShape );
284 : }
285 0 : }
286 :
287 0 : virtual void end() { end_(); }
288 0 : void end_()
289 : {
290 0 : if( mbAnimationStarted )
291 : {
292 0 : mbAnimationStarted = false;
293 :
294 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
295 0 : mpShapeManager->leaveAnimationMode( mpShape );
296 :
297 0 : if( mpShape->isContentChanged() )
298 0 : mpShapeManager->notifyShapeUpdate( mpShape );
299 : }
300 0 : }
301 :
302 : // NumberAnimation interface
303 : // -----------------------
304 :
305 0 : virtual bool operator()( double nValue )
306 : {
307 0 : ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
308 : "PathAnimation::operator(): Invalid ShapeAttributeLayer" );
309 :
310 : ::basegfx::B2DPoint rOutPos = ::basegfx::tools::getPositionRelative( maPathPoly,
311 0 : nValue );
312 :
313 : // TODO(F1): Determine whether the path is
314 : // absolute, or shape-relative.
315 :
316 : // interpret path as page-relative. Scale up with page size
317 0 : rOutPos *= maPageSize;
318 :
319 : // TODO(F1): Determine whether the path origin is
320 : // absolute, or shape-relative.
321 :
322 : // interpret path as shape-originated. Offset to shape position
323 :
324 0 : rOutPos += maShapeOrig;
325 :
326 0 : mpAttrLayer->setPosition( rOutPos );
327 :
328 0 : if( mpShape->isContentChanged() )
329 0 : mpShapeManager->notifyShapeUpdate( mpShape );
330 :
331 0 : return true;
332 : }
333 :
334 0 : virtual double getUnderlyingValue() const
335 : {
336 0 : ENSURE_OR_THROW( mpAttrLayer,
337 : "PathAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
338 :
339 0 : return 0.0; // though this should be used in concert with
340 : // ActivitiesFactory::createSimpleActivity, better
341 : // explicitly name our start value.
342 : // Permissible range for operator() above is [0,1]
343 : }
344 :
345 : private:
346 : ::basegfx::B2DPolygon maPathPoly;
347 : AnimatableShapeSharedPtr mpShape;
348 : ShapeAttributeLayerSharedPtr mpAttrLayer;
349 : ShapeManagerSharedPtr mpShapeManager;
350 : const ::basegfx::B2DSize maPageSize;
351 : ::basegfx::B2DPoint maShapeOrig;
352 : const int mnFlags;
353 : bool mbAnimationStarted;
354 : sal_Int16 mnAdditive;
355 : };
356 :
357 :
358 : /** GenericAnimation template
359 :
360 : This template makes heavy use of SFINAE, only one of
361 : the operator()() methods will compile for each of the
362 : base classes.
363 :
364 : Note that we omit the virtual keyword on the
365 : operator()() overrides and getUnderlyingValue() methods on
366 : purpose; those that actually do override baseclass
367 : virtual methods inherit the property, and the others
368 : won't increase our vtable. What's more, having all
369 : those methods in the vtable actually creates POIs for
370 : them, which breaks the whole SFINAE concept (IOW, this
371 : template won't compile any longer).
372 :
373 : @tpl AnimationBase
374 : Type of animation to generate (determines the
375 : interface GenericAnimation will implement). Must be
376 : one of NumberAnimation, ColorAnimation,
377 : StringAnimation, PairAnimation or BoolAnimation.
378 :
379 : @tpl ModifierFunctor
380 : Type of a functor object, which can optionally be used to
381 : modify the getter/setter values.
382 : */
383 : template< typename AnimationBase, typename ModifierFunctor > class GenericAnimation : public AnimationBase
384 : {
385 : public:
386 : typedef typename AnimationBase::ValueType ValueT;
387 :
388 : /** Create generic animation
389 :
390 : @param pIsValid
391 : Function pointer to one of the is*Valid
392 : methods. Used to either take the given getter
393 : method, or the given default value for the start value.
394 :
395 : @param rDefaultValue
396 : Default value, to take as the start value if
397 : is*Valid returns false.
398 :
399 : @param pGetValue
400 : Getter method, to fetch start value if valid.
401 :
402 : @param pSetValue
403 : Setter method. This one puts the current animation
404 : value to the ShapeAttributeLayer.
405 :
406 : @param rGetterModifier
407 : Modifies up values retrieved from the pGetValue method.
408 : Must provide operator()( const ValueT& ) method.
409 :
410 : @param rSetterModifier
411 : Modifies up values before passing them to the pSetValue method.
412 : Must provide operator()( const ValueT& ) method.
413 : */
414 0 : GenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
415 : int nFlags,
416 : bool (ShapeAttributeLayer::*pIsValid)() const,
417 : const ValueT& rDefaultValue,
418 : ValueT (ShapeAttributeLayer::*pGetValue)() const,
419 : void (ShapeAttributeLayer::*pSetValue)( const ValueT& ),
420 : const ModifierFunctor& rGetterModifier,
421 : const ModifierFunctor& rSetterModifier ) :
422 : mpShape(),
423 : mpAttrLayer(),
424 : mpShapeManager( rShapeManager ),
425 : mpIsValidFunc(pIsValid),
426 : mpGetValueFunc(pGetValue),
427 : mpSetValueFunc(pSetValue),
428 : maGetterModifier( rGetterModifier ),
429 : maSetterModifier( rSetterModifier ),
430 : mnFlags( nFlags ),
431 : maDefaultValue(rDefaultValue),
432 0 : mbAnimationStarted( false )
433 : {
434 0 : ENSURE_OR_THROW( rShapeManager,
435 : "GenericAnimation::GenericAnimation(): Invalid ShapeManager" );
436 0 : ENSURE_OR_THROW( pIsValid && pGetValue && pSetValue,
437 : "GenericAnimation::GenericAnimation(): One of the method pointers is NULL" );
438 0 : }
439 :
440 0 : ~GenericAnimation()
441 : {
442 0 : end_();
443 0 : }
444 :
445 : // Animation interface
446 : // -------------------
447 0 : virtual void prefetch( const AnimatableShapeSharedPtr&,
448 : const ShapeAttributeLayerSharedPtr& )
449 0 : {}
450 :
451 0 : virtual void start( const AnimatableShapeSharedPtr& rShape,
452 : const ShapeAttributeLayerSharedPtr& rAttrLayer )
453 : {
454 : OSL_ENSURE( !mpShape,
455 : "GenericAnimation::start(): Shape already set" );
456 : OSL_ENSURE( !mpAttrLayer,
457 : "GenericAnimation::start(): Attribute layer already set" );
458 :
459 0 : mpShape = rShape;
460 0 : mpAttrLayer = rAttrLayer;
461 :
462 0 : ENSURE_OR_THROW( rShape,
463 : "GenericAnimation::start(): Invalid shape" );
464 0 : ENSURE_OR_THROW( rAttrLayer,
465 : "GenericAnimation::start(): Invalid attribute layer" );
466 :
467 : // only start animation once per repeated start() call,
468 : // and only if sprites should be used for display
469 0 : if( !mbAnimationStarted )
470 : {
471 0 : mbAnimationStarted = true;
472 :
473 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
474 0 : mpShapeManager->enterAnimationMode( mpShape );
475 : }
476 0 : }
477 :
478 0 : virtual void end() { end_(); }
479 0 : void end_()
480 : {
481 : // TODO(Q2): Factor out common code (most
482 : // prominently start() and end()) into base class
483 :
484 : // only stop animation once per repeated end() call,
485 : // and only if sprites are used for display
486 0 : if( mbAnimationStarted )
487 : {
488 0 : mbAnimationStarted = false;
489 :
490 0 : if( !(mnFlags & AnimationFactory::FLAG_NO_SPRITE) )
491 0 : mpShapeManager->leaveAnimationMode( mpShape );
492 :
493 : // Attention, this notifyShapeUpdate() is
494 : // somewhat delicate here. Calling it
495 : // unconditional (i.e. not guarded by
496 : // mbAnimationStarted) will lead to shapes
497 : // snapping back to their original state just
498 : // before the slide ends. Not calling it at
499 : // all might swallow final animation
500 : // states. The current implementation relies
501 : // on the fact that end() is either called by
502 : // the Activity (then, the last animation
503 : // state has been set, and corresponds to the
504 : // shape's hold state), or by the animation
505 : // node (then, it's a forced end, and we
506 : // _have_ to snap back).
507 : //
508 : // To reiterate: normally, we're called from
509 : // the Activity first, thus the
510 : // notifyShapeUpdate() below will update to
511 : // the last activity value.
512 :
513 : // force shape update, activity might have changed
514 : // state in the last round.
515 0 : if( mpShape->isContentChanged() )
516 0 : mpShapeManager->notifyShapeUpdate( mpShape );
517 : }
518 0 : }
519 :
520 : // Derived Animation interface
521 : // ---------------------------
522 :
523 : /** For by-reference interfaces (B2DTuple, OUString)
524 : */
525 0 : bool operator()( const ValueT& x )
526 : {
527 0 : ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
528 : "GenericAnimation::operator(): Invalid ShapeAttributeLayer" );
529 :
530 0 : ((*mpAttrLayer).*mpSetValueFunc)( maSetterModifier( x ) );
531 :
532 0 : if( mpShape->isContentChanged() )
533 0 : mpShapeManager->notifyShapeUpdate( mpShape );
534 :
535 0 : return true;
536 : }
537 :
538 : /** For by-value interfaces (bool, double)
539 : */
540 0 : bool operator()( ValueT x )
541 : {
542 0 : ENSURE_OR_RETURN_FALSE( mpAttrLayer && mpShape,
543 : "GenericAnimation::operator(): Invalid ShapeAttributeLayer" );
544 :
545 0 : ((*mpAttrLayer).*mpSetValueFunc)( maSetterModifier( x ) );
546 :
547 0 : if( mpShape->isContentChanged() )
548 0 : mpShapeManager->notifyShapeUpdate( mpShape );
549 :
550 0 : return true;
551 : }
552 :
553 0 : ValueT getUnderlyingValue() const
554 : {
555 0 : ENSURE_OR_THROW( mpAttrLayer,
556 : "GenericAnimation::getUnderlyingValue(): Invalid ShapeAttributeLayer" );
557 :
558 : // deviated from the (*shared_ptr).*mpFuncPtr
559 : // notation here, since gcc does not seem to parse
560 : // that as a member function call anymore.
561 0 : if( (mpAttrLayer.get()->*mpIsValidFunc)() )
562 0 : return maGetterModifier( ((*mpAttrLayer).*mpGetValueFunc)() );
563 : else
564 0 : return maDefaultValue;
565 : }
566 :
567 : private:
568 : AnimatableShapeSharedPtr mpShape;
569 : ShapeAttributeLayerSharedPtr mpAttrLayer;
570 : ShapeManagerSharedPtr mpShapeManager;
571 : bool (ShapeAttributeLayer::*mpIsValidFunc)() const;
572 : ValueT (ShapeAttributeLayer::*mpGetValueFunc)() const;
573 : void (ShapeAttributeLayer::*mpSetValueFunc)( const ValueT& );
574 :
575 : ModifierFunctor maGetterModifier;
576 : ModifierFunctor maSetterModifier;
577 :
578 : const int mnFlags;
579 :
580 : const ValueT maDefaultValue;
581 : bool mbAnimationStarted;
582 : };
583 :
584 : //Current c++0x draft (apparently) has std::identity, but not operator()
585 : template<typename T> struct SGI_identity : public std::unary_function<T,T>
586 : {
587 0 : T& operator()(T& x) const { return x; }
588 0 : const T& operator()(const T& x) const { return x; }
589 : };
590 :
591 : /** Function template wrapper around GenericAnimation template
592 :
593 : @tpl AnimationBase
594 : Type of animation to generate (determines the
595 : interface GenericAnimation will implement).
596 : */
597 : template< typename AnimationBase > ::boost::shared_ptr< AnimationBase >
598 0 : makeGenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
599 : int nFlags,
600 : bool (ShapeAttributeLayer::*pIsValid)() const,
601 : const typename AnimationBase::ValueType& rDefaultValue,
602 : typename AnimationBase::ValueType (ShapeAttributeLayer::*pGetValue)() const,
603 : void (ShapeAttributeLayer::*pSetValue)( const typename AnimationBase::ValueType& ) )
604 : {
605 : return ::boost::shared_ptr< AnimationBase >(
606 : new GenericAnimation< AnimationBase,
607 : SGI_identity< typename AnimationBase::ValueType > >(
608 : rShapeManager,
609 : nFlags,
610 : pIsValid,
611 : rDefaultValue,
612 : pGetValue,
613 : pSetValue,
614 : // no modification necessary, use identity functor here
615 : SGI_identity< typename AnimationBase::ValueType >(),
616 0 : SGI_identity< typename AnimationBase::ValueType >() ) );
617 : }
618 :
619 : class Scaler
620 : {
621 : public:
622 0 : Scaler( double nScale ) :
623 0 : mnScale( nScale )
624 : {
625 0 : }
626 :
627 0 : double operator()( double nVal ) const
628 : {
629 0 : return mnScale * nVal;
630 : }
631 :
632 : private:
633 : double mnScale;
634 : };
635 :
636 : /** Overload for NumberAnimations which need scaling (width,height,x,y currently)
637 : */
638 0 : NumberAnimationSharedPtr makeGenericAnimation( const ShapeManagerSharedPtr& rShapeManager,
639 : int nFlags,
640 : bool (ShapeAttributeLayer::*pIsValid)() const,
641 : double nDefaultValue,
642 : double (ShapeAttributeLayer::*pGetValue)() const,
643 : void (ShapeAttributeLayer::*pSetValue)( const double& ),
644 : double nScaleValue )
645 : {
646 : return NumberAnimationSharedPtr(
647 : new GenericAnimation< NumberAnimation, Scaler >( rShapeManager,
648 : nFlags,
649 : pIsValid,
650 : nDefaultValue / nScaleValue,
651 : pGetValue,
652 : pSetValue,
653 : Scaler( 1.0/nScaleValue ),
654 0 : Scaler( nScaleValue ) ) );
655 : }
656 :
657 :
658 0 : uno::Any getShapeDefault( const AnimatableShapeSharedPtr& rShape,
659 : const ::rtl::OUString& rPropertyName )
660 : {
661 0 : uno::Reference< drawing::XShape > xShape( rShape->getXShape() );
662 :
663 0 : if( !xShape.is() )
664 0 : return uno::Any(); // no regular shape, no defaults available
665 :
666 :
667 : // extract relevant value from XShape's PropertySet
668 : uno::Reference< beans::XPropertySet > xPropSet( xShape,
669 0 : uno::UNO_QUERY );
670 :
671 0 : ENSURE_OR_THROW( xPropSet.is(),
672 : "getShapeDefault(): Cannot query property set from shape" );
673 :
674 0 : return xPropSet->getPropertyValue( rPropertyName );
675 : }
676 :
677 0 : template< typename ValueType > ValueType getDefault( const AnimatableShapeSharedPtr& rShape,
678 : const ::rtl::OUString& rPropertyName )
679 : {
680 : const uno::Any& rAny( getShapeDefault( rShape,
681 0 : rPropertyName ) );
682 :
683 0 : if( !rAny.hasValue() )
684 : {
685 : OSL_FAIL( "getDefault(): cannot get requested shape property" );
686 : OSL_TRACE( "getDefault(): cannot get '%s' shape property",
687 : ::rtl::OUStringToOString( rPropertyName,
688 : RTL_TEXTENCODING_ASCII_US ).getStr() );
689 0 : return ValueType();
690 : }
691 : else
692 : {
693 0 : ValueType aValue = ValueType();
694 :
695 0 : if( !(rAny >>= aValue) )
696 : {
697 : OSL_FAIL( "getDefault(): cannot extract requested shape property" );
698 : OSL_TRACE( "getDefault(): cannot extract '%s' shape property",
699 : ::rtl::OUStringToOString( rPropertyName,
700 : RTL_TEXTENCODING_ASCII_US ).getStr() );
701 0 : return ValueType();
702 : }
703 :
704 0 : return aValue;
705 : }
706 : }
707 :
708 0 : template<> RGBColor getDefault< RGBColor >( const AnimatableShapeSharedPtr& rShape,
709 : const ::rtl::OUString& rPropertyName )
710 : {
711 : const uno::Any& rAny( getShapeDefault( rShape,
712 0 : rPropertyName ) );
713 :
714 0 : if( !rAny.hasValue() )
715 : {
716 : OSL_FAIL( "getDefault(): cannot get requested shape color property" );
717 : OSL_TRACE( "getDefault(): cannot get '%s' shape color property",
718 : ::rtl::OUStringToOString( rPropertyName,
719 : RTL_TEXTENCODING_ASCII_US ).getStr() );
720 0 : return RGBColor();
721 : }
722 : else
723 : {
724 0 : sal_Int32 nValue = 0;
725 :
726 0 : if( !(rAny >>= nValue) )
727 : {
728 : OSL_FAIL( "getDefault(): cannot extract requested shape color property" );
729 : OSL_TRACE( "getDefault(): cannot extract '%s' shape color property",
730 : ::rtl::OUStringToOString( rPropertyName,
731 : RTL_TEXTENCODING_ASCII_US ).getStr() );
732 0 : return RGBColor();
733 : }
734 :
735 : // convert from 0xAARRGGBB API color to 0xRRGGBB00
736 : // canvas color
737 0 : return RGBColor( (nValue << 8U) & 0xFFFFFF00U );
738 0 : }
739 : }
740 : }
741 :
742 0 : AnimationFactory::AttributeClass AnimationFactory::classifyAttributeName( const ::rtl::OUString& rAttrName )
743 : {
744 : // ATTENTION: When changing this map, also the create*PropertyAnimation() methods must
745 : // be checked and possibly adapted in their switch statements
746 :
747 : // TODO(Q2): Since this map must be coherent with the various switch statements
748 : // in the create*PropertyAnimation methods, try to unify into a single method or table
749 0 : switch( mapAttributeName( rAttrName ) )
750 : {
751 : default:
752 : // FALLTHROUGH intended
753 : case ATTRIBUTE_INVALID:
754 0 : return CLASS_UNKNOWN_PROPERTY;
755 :
756 : case ATTRIBUTE_CHAR_COLOR:
757 : // FALLTHROUGH intended
758 : case ATTRIBUTE_COLOR:
759 : // FALLTHROUGH intended
760 : case ATTRIBUTE_DIMCOLOR:
761 : // FALLTHROUGH intended
762 : case ATTRIBUTE_FILL_COLOR:
763 : // FALLTHROUGH intended
764 : case ATTRIBUTE_LINE_COLOR:
765 0 : return CLASS_COLOR_PROPERTY;
766 :
767 : case ATTRIBUTE_CHAR_FONT_NAME:
768 0 : return CLASS_STRING_PROPERTY;
769 :
770 : case ATTRIBUTE_VISIBILITY:
771 0 : return CLASS_BOOL_PROPERTY;
772 :
773 : case ATTRIBUTE_CHAR_HEIGHT:
774 : // FALLTHROUGH intended
775 : case ATTRIBUTE_CHAR_WEIGHT:
776 : // FALLTHROUGH intended
777 : case ATTRIBUTE_CHAR_ROTATION:
778 : // FALLTHROUGH intended
779 : case ATTRIBUTE_HEIGHT:
780 : // FALLTHROUGH intended
781 : case ATTRIBUTE_OPACITY:
782 : // FALLTHROUGH intended
783 : case ATTRIBUTE_ROTATE:
784 : // FALLTHROUGH intended
785 : case ATTRIBUTE_SKEW_X:
786 : // FALLTHROUGH intended
787 : case ATTRIBUTE_SKEW_Y:
788 : // FALLTHROUGH intended
789 : case ATTRIBUTE_WIDTH:
790 : // FALLTHROUGH intended
791 : case ATTRIBUTE_POS_X:
792 : // FALLTHROUGH intended
793 : case ATTRIBUTE_POS_Y:
794 0 : return CLASS_NUMBER_PROPERTY;
795 :
796 : case ATTRIBUTE_CHAR_UNDERLINE:
797 : // FALLTHROUGH intended
798 : case ATTRIBUTE_FILL_STYLE:
799 : // FALLTHROUGH intended
800 : case ATTRIBUTE_LINE_STYLE:
801 : // FALLTHROUGH intended
802 : case ATTRIBUTE_CHAR_POSTURE:
803 0 : return CLASS_ENUM_PROPERTY;
804 : }
805 : }
806 :
807 0 : NumberAnimationSharedPtr AnimationFactory::createNumberPropertyAnimation( const ::rtl::OUString& rAttrName,
808 : const AnimatableShapeSharedPtr& rShape,
809 : const ShapeManagerSharedPtr& rShapeManager,
810 : const ::basegfx::B2DVector& rSlideSize,
811 : int nFlags )
812 : {
813 : // ATTENTION: When changing this map, also the classifyAttributeName() method must
814 : // be checked and possibly adapted in their switch statement
815 0 : switch( mapAttributeName( rAttrName ) )
816 : {
817 : default:
818 : // FALLTHROUGH intended
819 : case ATTRIBUTE_INVALID:
820 0 : ENSURE_OR_THROW( false,
821 : "AnimationFactory::createNumberPropertyAnimation(): Unknown attribute" );
822 : break;
823 :
824 : case ATTRIBUTE_CHAR_COLOR:
825 : // FALLTHROUGH intended
826 : case ATTRIBUTE_CHAR_FONT_NAME:
827 : // FALLTHROUGH intended
828 : case ATTRIBUTE_CHAR_POSTURE:
829 : // FALLTHROUGH intended
830 : case ATTRIBUTE_CHAR_UNDERLINE:
831 : // FALLTHROUGH intended
832 : case ATTRIBUTE_COLOR:
833 : // FALLTHROUGH intended
834 : case ATTRIBUTE_DIMCOLOR:
835 : // FALLTHROUGH intended
836 : case ATTRIBUTE_FILL_COLOR:
837 : // FALLTHROUGH intended
838 : case ATTRIBUTE_FILL_STYLE:
839 : // FALLTHROUGH intended
840 : case ATTRIBUTE_LINE_COLOR:
841 : // FALLTHROUGH intended
842 : case ATTRIBUTE_LINE_STYLE:
843 : // FALLTHROUGH intended
844 : case ATTRIBUTE_VISIBILITY:
845 0 : ENSURE_OR_THROW( false,
846 : "AnimationFactory::createNumberPropertyAnimation(): Attribute type mismatch" );
847 : break;
848 :
849 : case ATTRIBUTE_CHAR_HEIGHT:
850 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
851 : nFlags,
852 : &ShapeAttributeLayer::isCharScaleValid,
853 : 1.0, // CharHeight is a relative attribute, thus
854 : // default is 1.0
855 : &ShapeAttributeLayer::getCharScale,
856 0 : &ShapeAttributeLayer::setCharScale );
857 :
858 : case ATTRIBUTE_CHAR_WEIGHT:
859 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
860 : nFlags,
861 : &ShapeAttributeLayer::isCharWeightValid,
862 0 : getDefault<double>( rShape, rAttrName ),
863 : &ShapeAttributeLayer::getCharWeight,
864 0 : &ShapeAttributeLayer::setCharWeight );
865 :
866 : case ATTRIBUTE_CHAR_ROTATION:
867 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
868 : nFlags,
869 : &ShapeAttributeLayer::isCharRotationAngleValid,
870 0 : getDefault<double>( rShape, rAttrName ),
871 : &ShapeAttributeLayer::getCharRotationAngle,
872 0 : &ShapeAttributeLayer::setCharRotationAngle );
873 :
874 : case ATTRIBUTE_HEIGHT:
875 : return makeGenericAnimation( rShapeManager,
876 : nFlags,
877 : &ShapeAttributeLayer::isHeightValid,
878 : // TODO(F1): Check whether _shape_ bounds are correct here.
879 : // Theoretically, our AttrLayer is way down the stack, and
880 : // we only have to consider _that_ value, not the one from
881 : // the top of the stack as returned by Shape::getBounds()
882 0 : rShape->getBounds().getHeight(),
883 : &ShapeAttributeLayer::getHeight,
884 : &ShapeAttributeLayer::setHeight,
885 : // convert expression parser value from relative page size
886 0 : rSlideSize.getY() );
887 :
888 : case ATTRIBUTE_OPACITY:
889 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
890 : nFlags,
891 : &ShapeAttributeLayer::isAlphaValid,
892 : // TODO(F1): Provide shape default here (FillTransparency?)
893 : 1.0,
894 : &ShapeAttributeLayer::getAlpha,
895 0 : &ShapeAttributeLayer::setAlpha );
896 :
897 : case ATTRIBUTE_ROTATE:
898 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
899 : nFlags,
900 : &ShapeAttributeLayer::isRotationAngleValid,
901 : // NOTE: Since we paint the shape as-is from metafile,
902 : // rotation angle is always 0.0, even for rotated shapes
903 : 0.0,
904 : &ShapeAttributeLayer::getRotationAngle,
905 0 : &ShapeAttributeLayer::setRotationAngle );
906 :
907 : case ATTRIBUTE_SKEW_X:
908 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
909 : nFlags,
910 : &ShapeAttributeLayer::isShearXAngleValid,
911 : // TODO(F1): Is there any shape property for skew?
912 : 0.0,
913 : &ShapeAttributeLayer::getShearXAngle,
914 0 : &ShapeAttributeLayer::setShearXAngle );
915 :
916 : case ATTRIBUTE_SKEW_Y:
917 : return makeGenericAnimation<NumberAnimation>( rShapeManager,
918 : nFlags,
919 : &ShapeAttributeLayer::isShearYAngleValid,
920 : // TODO(F1): Is there any shape property for skew?
921 : 0.0,
922 : &ShapeAttributeLayer::getShearYAngle,
923 0 : &ShapeAttributeLayer::setShearYAngle );
924 :
925 : case ATTRIBUTE_WIDTH:
926 : return makeGenericAnimation( rShapeManager,
927 : nFlags,
928 : &ShapeAttributeLayer::isWidthValid,
929 : // TODO(F1): Check whether _shape_ bounds are correct here.
930 : // Theoretically, our AttrLayer is way down the stack, and
931 : // we only have to consider _that_ value, not the one from
932 : // the top of the stack as returned by Shape::getBounds()
933 0 : rShape->getBounds().getWidth(),
934 : &ShapeAttributeLayer::getWidth,
935 : &ShapeAttributeLayer::setWidth,
936 : // convert expression parser value from relative page size
937 0 : rSlideSize.getX() );
938 :
939 : case ATTRIBUTE_POS_X:
940 : return makeGenericAnimation( rShapeManager,
941 : nFlags,
942 : &ShapeAttributeLayer::isPosXValid,
943 : // TODO(F1): Check whether _shape_ bounds are correct here.
944 : // Theoretically, our AttrLayer is way down the stack, and
945 : // we only have to consider _that_ value, not the one from
946 : // the top of the stack as returned by Shape::getBounds()
947 0 : rShape->getBounds().getCenterX(),
948 : &ShapeAttributeLayer::getPosX,
949 : &ShapeAttributeLayer::setPosX,
950 : // convert expression parser value from relative page size
951 0 : rSlideSize.getX() );
952 :
953 : case ATTRIBUTE_POS_Y:
954 : return makeGenericAnimation( rShapeManager,
955 : nFlags,
956 : &ShapeAttributeLayer::isPosYValid,
957 : // TODO(F1): Check whether _shape_ bounds are correct here.
958 : // Theoretically, our AttrLayer is way down the stack, and
959 : // we only have to consider _that_ value, not the one from
960 : // the top of the stack as returned by Shape::getBounds()
961 0 : rShape->getBounds().getCenterY(),
962 : &ShapeAttributeLayer::getPosY,
963 : &ShapeAttributeLayer::setPosY,
964 : // convert expression parser value from relative page size
965 0 : rSlideSize.getY() );
966 : }
967 :
968 : return NumberAnimationSharedPtr();
969 : }
970 :
971 0 : EnumAnimationSharedPtr AnimationFactory::createEnumPropertyAnimation( const ::rtl::OUString& rAttrName,
972 : const AnimatableShapeSharedPtr& rShape,
973 : const ShapeManagerSharedPtr& rShapeManager,
974 : const ::basegfx::B2DVector& /*rSlideSize*/,
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 0 : switch( mapAttributeName( rAttrName ) )
980 : {
981 : default:
982 : // FALLTHROUGH intended
983 : case ATTRIBUTE_INVALID:
984 0 : ENSURE_OR_THROW( false,
985 : "AnimationFactory::createEnumPropertyAnimation(): Unknown attribute" );
986 : break;
987 :
988 : case ATTRIBUTE_CHAR_COLOR:
989 : // FALLTHROUGH intended
990 : case ATTRIBUTE_CHAR_FONT_NAME:
991 : // FALLTHROUGH intended
992 : case ATTRIBUTE_COLOR:
993 : // FALLTHROUGH intended
994 : case ATTRIBUTE_DIMCOLOR:
995 : // FALLTHROUGH intended
996 : case ATTRIBUTE_FILL_COLOR:
997 : // FALLTHROUGH intended
998 : case ATTRIBUTE_LINE_COLOR:
999 : // FALLTHROUGH intended
1000 : case ATTRIBUTE_VISIBILITY:
1001 : // FALLTHROUGH intended
1002 : case ATTRIBUTE_CHAR_HEIGHT:
1003 : // FALLTHROUGH intended
1004 : case ATTRIBUTE_CHAR_WEIGHT:
1005 : // FALLTHROUGH intended
1006 : case ATTRIBUTE_CHAR_ROTATION:
1007 : // FALLTHROUGH intended
1008 : case ATTRIBUTE_HEIGHT:
1009 : // FALLTHROUGH intended
1010 : case ATTRIBUTE_OPACITY:
1011 : // FALLTHROUGH intended
1012 : case ATTRIBUTE_ROTATE:
1013 : // FALLTHROUGH intended
1014 : case ATTRIBUTE_SKEW_X:
1015 : // FALLTHROUGH intended
1016 : case ATTRIBUTE_SKEW_Y:
1017 : // FALLTHROUGH intended
1018 : case ATTRIBUTE_WIDTH:
1019 : // FALLTHROUGH intended
1020 : case ATTRIBUTE_POS_X:
1021 : // FALLTHROUGH intended
1022 : case ATTRIBUTE_POS_Y:
1023 0 : ENSURE_OR_THROW( false,
1024 : "AnimationFactory::createEnumPropertyAnimation(): Attribute type mismatch" );
1025 : break;
1026 :
1027 :
1028 : case ATTRIBUTE_FILL_STYLE:
1029 : return makeGenericAnimation<EnumAnimation>( rShapeManager,
1030 : nFlags,
1031 : &ShapeAttributeLayer::isFillStyleValid,
1032 : sal::static_int_cast<sal_Int16>(
1033 0 : getDefault<drawing::FillStyle>( rShape, rAttrName )),
1034 : &ShapeAttributeLayer::getFillStyle,
1035 0 : &ShapeAttributeLayer::setFillStyle );
1036 :
1037 : case ATTRIBUTE_LINE_STYLE:
1038 : return makeGenericAnimation<EnumAnimation>( rShapeManager,
1039 : nFlags,
1040 : &ShapeAttributeLayer::isLineStyleValid,
1041 : sal::static_int_cast<sal_Int16>(
1042 0 : getDefault<drawing::LineStyle>( rShape, rAttrName )),
1043 : &ShapeAttributeLayer::getLineStyle,
1044 0 : &ShapeAttributeLayer::setLineStyle );
1045 :
1046 : case ATTRIBUTE_CHAR_POSTURE:
1047 : return makeGenericAnimation<EnumAnimation>( rShapeManager,
1048 : nFlags,
1049 : &ShapeAttributeLayer::isCharPostureValid,
1050 : sal::static_int_cast<sal_Int16>(
1051 0 : getDefault<awt::FontSlant>( rShape, rAttrName )),
1052 : &ShapeAttributeLayer::getCharPosture,
1053 0 : &ShapeAttributeLayer::setCharPosture );
1054 :
1055 : case ATTRIBUTE_CHAR_UNDERLINE:
1056 : return makeGenericAnimation<EnumAnimation>( rShapeManager,
1057 : nFlags,
1058 : &ShapeAttributeLayer::isUnderlineModeValid,
1059 0 : getDefault<sal_Int16>( rShape, rAttrName ),
1060 : &ShapeAttributeLayer::getUnderlineMode,
1061 0 : &ShapeAttributeLayer::setUnderlineMode );
1062 : }
1063 :
1064 : return EnumAnimationSharedPtr();
1065 : }
1066 :
1067 0 : ColorAnimationSharedPtr AnimationFactory::createColorPropertyAnimation( const ::rtl::OUString& rAttrName,
1068 : const AnimatableShapeSharedPtr& rShape,
1069 : const ShapeManagerSharedPtr& rShapeManager,
1070 : const ::basegfx::B2DVector& /*rSlideSize*/,
1071 : int nFlags )
1072 : {
1073 : // ATTENTION: When changing this map, also the classifyAttributeName() method must
1074 : // be checked and possibly adapted in their switch statement
1075 0 : switch( mapAttributeName( rAttrName ) )
1076 : {
1077 : default:
1078 : // FALLTHROUGH intended
1079 : case ATTRIBUTE_INVALID:
1080 0 : ENSURE_OR_THROW( false,
1081 : "AnimationFactory::createColorPropertyAnimation(): Unknown attribute" );
1082 : break;
1083 :
1084 : case ATTRIBUTE_CHAR_FONT_NAME:
1085 : // FALLTHROUGH intended
1086 : case ATTRIBUTE_CHAR_HEIGHT:
1087 : // FALLTHROUGH intended
1088 : case ATTRIBUTE_CHAR_POSTURE:
1089 : // FALLTHROUGH intended
1090 : case ATTRIBUTE_CHAR_ROTATION:
1091 : // FALLTHROUGH intended
1092 : case ATTRIBUTE_CHAR_UNDERLINE:
1093 : // FALLTHROUGH intended
1094 : case ATTRIBUTE_CHAR_WEIGHT:
1095 : // FALLTHROUGH intended
1096 : case ATTRIBUTE_FILL_STYLE:
1097 : // FALLTHROUGH intended
1098 : case ATTRIBUTE_HEIGHT:
1099 : // FALLTHROUGH intended
1100 : case ATTRIBUTE_LINE_STYLE:
1101 : // FALLTHROUGH intended
1102 : case ATTRIBUTE_OPACITY:
1103 : // FALLTHROUGH intended
1104 : case ATTRIBUTE_ROTATE:
1105 : // FALLTHROUGH intended
1106 : case ATTRIBUTE_SKEW_X:
1107 : // FALLTHROUGH intended
1108 : case ATTRIBUTE_SKEW_Y:
1109 : // FALLTHROUGH intended
1110 : case ATTRIBUTE_VISIBILITY:
1111 : // FALLTHROUGH intended
1112 : case ATTRIBUTE_WIDTH:
1113 : // FALLTHROUGH intended
1114 : case ATTRIBUTE_POS_X:
1115 : // FALLTHROUGH intended
1116 : case ATTRIBUTE_POS_Y:
1117 0 : ENSURE_OR_THROW( false,
1118 : "AnimationFactory::createColorPropertyAnimation(): Attribute type mismatch" );
1119 : break;
1120 :
1121 : case ATTRIBUTE_CHAR_COLOR:
1122 : return makeGenericAnimation<ColorAnimation>( rShapeManager,
1123 : nFlags,
1124 : &ShapeAttributeLayer::isCharColorValid,
1125 : getDefault<RGBColor>( rShape, rAttrName ),
1126 : &ShapeAttributeLayer::getCharColor,
1127 0 : &ShapeAttributeLayer::setCharColor );
1128 :
1129 : case ATTRIBUTE_COLOR:
1130 : // TODO(F2): This is just mapped to fill color to make it work
1131 : return makeGenericAnimation<ColorAnimation>( rShapeManager,
1132 : nFlags,
1133 : &ShapeAttributeLayer::isFillColorValid,
1134 : getDefault<RGBColor>( rShape, rAttrName ),
1135 : &ShapeAttributeLayer::getFillColor,
1136 0 : &ShapeAttributeLayer::setFillColor );
1137 :
1138 : case ATTRIBUTE_DIMCOLOR:
1139 : return makeGenericAnimation<ColorAnimation>( rShapeManager,
1140 : nFlags,
1141 : &ShapeAttributeLayer::isDimColorValid,
1142 : getDefault<RGBColor>( rShape, rAttrName ),
1143 : &ShapeAttributeLayer::getDimColor,
1144 0 : &ShapeAttributeLayer::setDimColor );
1145 :
1146 : case ATTRIBUTE_FILL_COLOR:
1147 : return makeGenericAnimation<ColorAnimation>( rShapeManager,
1148 : nFlags,
1149 : &ShapeAttributeLayer::isFillColorValid,
1150 : getDefault<RGBColor>( rShape, rAttrName ),
1151 : &ShapeAttributeLayer::getFillColor,
1152 0 : &ShapeAttributeLayer::setFillColor );
1153 :
1154 : case ATTRIBUTE_LINE_COLOR:
1155 : return makeGenericAnimation<ColorAnimation>( rShapeManager,
1156 : nFlags,
1157 : &ShapeAttributeLayer::isLineColorValid,
1158 : getDefault<RGBColor>( rShape, rAttrName ),
1159 : &ShapeAttributeLayer::getLineColor,
1160 0 : &ShapeAttributeLayer::setLineColor );
1161 : }
1162 :
1163 : return ColorAnimationSharedPtr();
1164 : }
1165 :
1166 0 : PairAnimationSharedPtr AnimationFactory::createPairPropertyAnimation( const AnimatableShapeSharedPtr& rShape,
1167 : const ShapeManagerSharedPtr& rShapeManager,
1168 : const ::basegfx::B2DVector& rSlideSize,
1169 : sal_Int16 nTransformType,
1170 : int nFlags )
1171 : {
1172 0 : const ::basegfx::B2DRectangle& rBounds( rShape->getBounds() );
1173 :
1174 0 : switch( nTransformType )
1175 : {
1176 : case animations::AnimationTransformType::SCALE:
1177 : return PairAnimationSharedPtr(
1178 : new TupleAnimation< ::basegfx::B2DSize >(
1179 : rShapeManager,
1180 : nFlags,
1181 : &ShapeAttributeLayer::isWidthValid,
1182 : &ShapeAttributeLayer::isHeightValid,
1183 : // TODO(F1): Check whether _shape_ bounds are correct here.
1184 : // Theoretically, our AttrLayer is way down the stack, and
1185 : // we only have to consider _that_ value, not the one from
1186 : // the top of the stack as returned by Shape::getBounds()
1187 : rBounds.getRange(),
1188 : rBounds.getRange(),
1189 : &ShapeAttributeLayer::getWidth,
1190 : &ShapeAttributeLayer::getHeight,
1191 0 : &ShapeAttributeLayer::setSize ) );
1192 :
1193 : case animations::AnimationTransformType::TRANSLATE:
1194 : return PairAnimationSharedPtr(
1195 : new TupleAnimation< ::basegfx::B2DPoint >(
1196 : rShapeManager,
1197 : nFlags,
1198 : &ShapeAttributeLayer::isPosXValid,
1199 : &ShapeAttributeLayer::isPosYValid,
1200 : // TODO(F1): Check whether _shape_ bounds are correct here.
1201 : // Theoretically, our AttrLayer is way down the stack, and
1202 : // we only have to consider _that_ value, not the one from
1203 : // the top of the stack as returned by Shape::getBounds()
1204 : rBounds.getCenter(),
1205 : rSlideSize,
1206 : &ShapeAttributeLayer::getPosX,
1207 : &ShapeAttributeLayer::getPosY,
1208 0 : &ShapeAttributeLayer::setPosition ) );
1209 :
1210 : default:
1211 0 : ENSURE_OR_THROW( false,
1212 : "AnimationFactory::createPairPropertyAnimation(): Attribute type mismatch" );
1213 : break;
1214 : }
1215 :
1216 : return PairAnimationSharedPtr();
1217 : }
1218 :
1219 0 : StringAnimationSharedPtr AnimationFactory::createStringPropertyAnimation( const ::rtl::OUString& rAttrName,
1220 : const AnimatableShapeSharedPtr& rShape,
1221 : const ShapeManagerSharedPtr& rShapeManager,
1222 : const ::basegfx::B2DVector& /*rSlideSize*/,
1223 : int nFlags )
1224 : {
1225 : // ATTENTION: When changing this map, also the classifyAttributeName() method must
1226 : // be checked and possibly adapted in their switch statement
1227 0 : switch( mapAttributeName( rAttrName ) )
1228 : {
1229 : default:
1230 : // FALLTHROUGH intended
1231 : case ATTRIBUTE_INVALID:
1232 0 : ENSURE_OR_THROW( false,
1233 : "AnimationFactory::createStringPropertyAnimation(): Unknown attribute" );
1234 : break;
1235 :
1236 : case ATTRIBUTE_CHAR_COLOR:
1237 : // FALLTHROUGH intended
1238 : case ATTRIBUTE_CHAR_HEIGHT:
1239 : // FALLTHROUGH intended
1240 : case ATTRIBUTE_CHAR_ROTATION:
1241 : // FALLTHROUGH intended
1242 : case ATTRIBUTE_CHAR_UNDERLINE:
1243 : // FALLTHROUGH intended
1244 : case ATTRIBUTE_COLOR:
1245 : // FALLTHROUGH intended
1246 : case ATTRIBUTE_DIMCOLOR:
1247 : // FALLTHROUGH intended
1248 : case ATTRIBUTE_FILL_COLOR:
1249 : // FALLTHROUGH intended
1250 : case ATTRIBUTE_HEIGHT:
1251 : // FALLTHROUGH intended
1252 : case ATTRIBUTE_LINE_COLOR:
1253 : // FALLTHROUGH intended
1254 : case ATTRIBUTE_OPACITY:
1255 : // FALLTHROUGH intended
1256 : case ATTRIBUTE_ROTATE:
1257 : // FALLTHROUGH intended
1258 : case ATTRIBUTE_SKEW_X:
1259 : // FALLTHROUGH intended
1260 : case ATTRIBUTE_SKEW_Y:
1261 : // FALLTHROUGH intended
1262 : case ATTRIBUTE_VISIBILITY:
1263 : // FALLTHROUGH intended
1264 : case ATTRIBUTE_WIDTH:
1265 : // FALLTHROUGH intended
1266 : case ATTRIBUTE_POS_X:
1267 : // FALLTHROUGH intended
1268 : case ATTRIBUTE_POS_Y:
1269 : // FALLTHROUGH intended
1270 : case ATTRIBUTE_CHAR_POSTURE:
1271 : // FALLTHROUGH intended
1272 : case ATTRIBUTE_CHAR_WEIGHT:
1273 : // FALLTHROUGH intended
1274 : case ATTRIBUTE_FILL_STYLE:
1275 : // FALLTHROUGH intended
1276 : case ATTRIBUTE_LINE_STYLE:
1277 0 : ENSURE_OR_THROW( false,
1278 : "AnimationFactory::createStringPropertyAnimation(): Attribute type mismatch" );
1279 : break;
1280 :
1281 : case ATTRIBUTE_CHAR_FONT_NAME:
1282 : return makeGenericAnimation<StringAnimation>( rShapeManager,
1283 : nFlags,
1284 : &ShapeAttributeLayer::isFontFamilyValid,
1285 : getDefault< ::rtl::OUString >( rShape, rAttrName ),
1286 : &ShapeAttributeLayer::getFontFamily,
1287 0 : &ShapeAttributeLayer::setFontFamily );
1288 : }
1289 :
1290 : return StringAnimationSharedPtr();
1291 : }
1292 :
1293 0 : BoolAnimationSharedPtr AnimationFactory::createBoolPropertyAnimation( const ::rtl::OUString& rAttrName,
1294 : const AnimatableShapeSharedPtr& /*rShape*/,
1295 : const ShapeManagerSharedPtr& rShapeManager,
1296 : const ::basegfx::B2DVector& /*rSlideSize*/,
1297 : int nFlags )
1298 : {
1299 : // ATTENTION: When changing this map, also the classifyAttributeName() method must
1300 : // be checked and possibly adapted in their switch statement
1301 0 : switch( mapAttributeName( rAttrName ) )
1302 : {
1303 : default:
1304 : // FALLTHROUGH intended
1305 : case ATTRIBUTE_INVALID:
1306 0 : ENSURE_OR_THROW( false,
1307 : "AnimationFactory::createBoolPropertyAnimation(): Unknown attribute" );
1308 : break;
1309 :
1310 : case ATTRIBUTE_CHAR_COLOR:
1311 : // FALLTHROUGH intended
1312 : case ATTRIBUTE_CHAR_FONT_NAME:
1313 : // FALLTHROUGH intended
1314 : case ATTRIBUTE_CHAR_HEIGHT:
1315 : // FALLTHROUGH intended
1316 : case ATTRIBUTE_CHAR_POSTURE:
1317 : // FALLTHROUGH intended
1318 : case ATTRIBUTE_CHAR_ROTATION:
1319 : // FALLTHROUGH intended
1320 : case ATTRIBUTE_CHAR_WEIGHT:
1321 : // FALLTHROUGH intended
1322 : case ATTRIBUTE_COLOR:
1323 : // FALLTHROUGH intended
1324 : case ATTRIBUTE_DIMCOLOR:
1325 : // FALLTHROUGH intended
1326 : case ATTRIBUTE_FILL_COLOR:
1327 : // FALLTHROUGH intended
1328 : case ATTRIBUTE_FILL_STYLE:
1329 : // FALLTHROUGH intended
1330 : case ATTRIBUTE_HEIGHT:
1331 : // FALLTHROUGH intended
1332 : case ATTRIBUTE_LINE_COLOR:
1333 : // FALLTHROUGH intended
1334 : case ATTRIBUTE_LINE_STYLE:
1335 : // FALLTHROUGH intended
1336 : case ATTRIBUTE_OPACITY:
1337 : // FALLTHROUGH intended
1338 : case ATTRIBUTE_ROTATE:
1339 : // FALLTHROUGH intended
1340 : case ATTRIBUTE_SKEW_X:
1341 : // FALLTHROUGH intended
1342 : case ATTRIBUTE_SKEW_Y:
1343 : // FALLTHROUGH intended
1344 : case ATTRIBUTE_WIDTH:
1345 : // FALLTHROUGH intended
1346 : case ATTRIBUTE_POS_X:
1347 : // FALLTHROUGH intended
1348 : case ATTRIBUTE_POS_Y:
1349 : // FALLTHROUGH intended
1350 : case ATTRIBUTE_CHAR_UNDERLINE:
1351 0 : ENSURE_OR_THROW( false,
1352 : "AnimationFactory::createBoolPropertyAnimation(): Attribute type mismatch" );
1353 : break;
1354 :
1355 : case ATTRIBUTE_VISIBILITY:
1356 : return makeGenericAnimation<BoolAnimation>( rShapeManager,
1357 : nFlags,
1358 : &ShapeAttributeLayer::isVisibilityValid,
1359 : // TODO(F1): Is there a corresponding shape property?
1360 : true,
1361 : &ShapeAttributeLayer::getVisibility,
1362 0 : &ShapeAttributeLayer::setVisibility );
1363 : }
1364 :
1365 : return BoolAnimationSharedPtr();
1366 : }
1367 :
1368 0 : NumberAnimationSharedPtr AnimationFactory::createPathMotionAnimation( const ::rtl::OUString& rSVGDPath,
1369 : sal_Int16 nAdditive,
1370 : const AnimatableShapeSharedPtr& /*rShape*/,
1371 : const ShapeManagerSharedPtr& rShapeManager,
1372 : const ::basegfx::B2DVector& rSlideSize,
1373 : int nFlags )
1374 : {
1375 : return NumberAnimationSharedPtr(
1376 : new PathAnimation( rSVGDPath, nAdditive,
1377 : rShapeManager,
1378 : rSlideSize,
1379 0 : nFlags ) );
1380 : }
1381 :
1382 : }
1383 : }
1384 :
1385 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
