slideshow/source/engine/animationfactory.cxx

   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
  41 using namespace ::com::sun::star;
  42
  43
  44 namespace 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
 523             /** GenericAnimation template
 524
 525                 This template makes heavy use of SFINAE, only one of
 526                 the operator()() methods will compile for each of the
 527                 base classes.
 528
 529                 Note that we omit the virtual keyword on the
 530                 operator()() overrides and getUnderlyingValue() methods on
 531                 purpose; those that actually do override baseclass
 532                 virtual methods inherit the property, and the others
 533                 won't increase our vtable. What's more, having all
 534                 those methods in the vtable actually creates POIs for
 535                 them, which breaks the whole SFINAE concept (IOW, this
 536                 template won't compile any longer).
 537
 538                 @tpl AnimationBase
 539                 Type of animation to generate (determines the
 540                 interface GenericAnimation will implement). Must be
 541                 one of NumberAnimation, ColorAnimation,
 542                 StringAnimation, PairAnimation or BoolAnimation.
 543
 544                 @tpl ModifierFunctor
 545                 Type of a functor object, which can optionally be used to
 546                 modify the getter/setter values.
 547              */
 548             template< typename AnimationBase, typename ModifierFunctor > class GenericAnimation : public AnimationBase
 549             {
 550             public:
 551                 typedef typename AnimationBase::ValueType ValueT;
 552
 553                 /** Create generic animation
 554
 555                     @param pIsValid
 556                     Function pointer to one of the is*Valid
 557                     methods. Used to either take the given getter
 558                     method, or the given default value for the start value.
 559
 560                     @param rDefaultValue
 561                     Default value, to take as the start value if
 562                     is*Valid returns false.
 563
 564                     @param pGetValue
 565                     Getter method, to fetch start value if valid.
 566
 567                     @param pSetValue
 568                     Setter method. This one puts the current animation
 569                     value to the ShapeAttributeLayer.
 570
 571                     @param rGetterModifier
 572                     Modifies up values retrieved from the pGetValue method.
 573                     Must provide operator()( const ValueT& ) method.
 574
 575                     @param rSetterModifier
 576                     Modifies up values before passing them to the pSetValue method.
 577                     Must provide operator()( const ValueT& ) method.
 578                  */
 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
 697                 /** For by-reference interfaces (B2DTuple, OUString)
 698                  */
 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
 714                 /** For by-value interfaces (bool, double)
 715                  */
 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
 779             /** Function template wrapper around GenericAnimation template
 780
 781                 @tpl AnimationBase
 782                 Type of animation to generate (determines the
 783                 interface GenericAnimation will implement).
 784              */
 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
 827             /** Overload for NumberAnimations which need scaling (width,height,x,y currently)
 828              */
 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: */