sd/source/filter/eppt/pptexanimations.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 #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
  21 #include <com/sun/star/animations/AnimationFill.hpp>
  22 #include <com/sun/star/animations/AnimationRestart.hpp>
  23 #include <com/sun/star/animations/Timing.hpp>
  24 #include <com/sun/star/animations/Event.hpp>
  25 #include <com/sun/star/animations/AnimationEndSync.hpp>
  26 #include <com/sun/star/animations/EventTrigger.hpp>
  27 #include <com/sun/star/presentation/EffectNodeType.hpp>
  28 #include <com/sun/star/presentation/EffectPresetClass.hpp>
  29 #include <com/sun/star/animations/AnimationNodeType.hpp>
  30 #include <com/sun/star/animations/AnimationTransformType.hpp>
  31 #include <com/sun/star/animations/AnimationCalcMode.hpp>
  32 #include <com/sun/star/util/XCloneable.hpp>
  33 #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
  34 #include <com/sun/star/animations/XAnimateSet.hpp>
  35 #include <com/sun/star/animations/XAudio.hpp>
  36 #include <com/sun/star/animations/XTransitionFilter.hpp>
  37 #include <com/sun/star/animations/XAnimateColor.hpp>
  38 #include <com/sun/star/animations/XAnimateMotion.hpp>
  39 #include <com/sun/star/animations/XAnimateTransform.hpp>
  40 #include <com/sun/star/animations/ValuePair.hpp>
  41 #include <com/sun/star/animations/AnimationColorSpace.hpp>
  42 #include <com/sun/star/drawing/FillStyle.hpp>
  43 #include <com/sun/star/drawing/LineStyle.hpp>
  44 #include <com/sun/star/awt/FontWeight.hpp>
  45 #include <com/sun/star/awt/FontUnderline.hpp>
  46 #include <com/sun/star/awt/FontSlant.hpp>
  47 #include <com/sun/star/container/XEnumerationAccess.hpp>
  48 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  49 #include <com/sun/star/text/XSimpleText.hpp>
  50 #include <com/sun/star/animations/XIterateContainer.hpp>
  51 #include <com/sun/star/presentation/TextAnimationType.hpp>
  52
  53 #include <oox/ppt/pptfilterhelpers.hxx>
  54 #include "pptexanimations.hxx"
  55 #include "pptexsoundcollection.hxx"
  56 #include "../ppt/pptanimations.hxx"
  57 #include <filter/msfilter/escherex.hxx>
  58 #include <osl/diagnose.h>
  59 #include <tools/debug.hxx>
  60
  61 #include <algorithm>
  62
  63 using ::com::sun::star::uno::Any;
  64 using ::com::sun::star::util::XCloneable;
  65 using ::com::sun::star::uno::Reference;
  66 using ::com::sun::star::uno::UNO_QUERY;
  67 using ::com::sun::star::uno::UNO_QUERY_THROW;
  68 using ::com::sun::star::uno::Sequence;
  69 using ::com::sun::star::uno::Exception;
  70 using ::com::sun::star::beans::NamedValue;
  71 using ::com::sun::star::container::XEnumerationAccess;
  72 using ::com::sun::star::container::XEnumeration;
  73
  74 using namespace ::com::sun::star::text;
  75 using namespace ::com::sun::star::drawing;
  76 using namespace ::com::sun::star::animations;
  77 using namespace ::com::sun::star::presentation;
  78
  79 namespace ppt
  80 {
  81
  82 static void ImplTranslateAttribute( OUString& rString, const TranslateMode eTranslateMode )
  83 {
  84     if ( eTranslateMode == TRANSLATE_NONE )
  85         return;
  86
  87     if ( ( eTranslateMode & TRANSLATE_VALUE ) || ( eTranslateMode & TRANSLATE_ATTRIBUTE ) )
  88     {
  89         const oox::ppt::ImplAttributeNameConversion* p = oox::ppt::getAttributeConversionList();
  90         while( p->mpAPIName )
  91         {
  92             if( rString.equalsAscii( p->mpAPIName ) )
  93                 break;
  94             p++;
  95         }
  96         if( p->mpMSName )
  97         {
  98             if ( eTranslateMode & TRANSLATE_VALUE )
  99             {
 100                 rString = "#";
 101                 rString += OUString::createFromAscii( p->mpMSName );
 102             }
 103             else
 104                 rString = OUString::createFromAscii( p->mpMSName );
 105         }
 106     }
 107     else if ( eTranslateMode & TRANSLATE_MEASURE )
 108     {
 109         const sal_Char* pDest[] = { "#ppt_x", "#ppt_y", "#ppt_w", "#ppt_h", nullptr };
 110         const sal_Char* pSource[] = { "x", "y", "width", "height", nullptr };
 111         sal_Int32 nIndex = 0;
 112
 113         const sal_Char** ps = pSource;
 114         const sal_Char** pd = pDest;
 115
 116         while( *ps )
 117         {
 118             const OUString aSearch( OUString::createFromAscii( *ps ) );
 119             while( (nIndex = rString.indexOf( aSearch, nIndex )) != -1  )
 120             {
 121                 sal_Int32 nLength = aSearch.getLength();
 122                 if( nIndex && ( rString[nIndex-1] == '#' ) )
 123                 {
 124                     nIndex--;
 125                     nLength++;
 126                 }
 127
 128                 const OUString aNew( OUString::createFromAscii( *pd ) );
 129                 rString = rString.replaceAt( nIndex, nLength, aNew );
 130                 nIndex += aNew.getLength();
 131             }
 132             ps++;
 133             pd++;
 134         }
 135     }
 136 }
 137
 138 sal_uInt32 AnimationExporter::TranslatePresetSubType( const sal_uInt32 nPresetClass, const sal_uInt32 nPresetId, const OUString& rPresetSubType )
 139 {
 140     sal_uInt32  nPresetSubType = 0;
 141     bool    bTranslated = false;
 142
 143     if ( ( nPresetClass == sal_uInt32(EffectPresetClass::ENTRANCE) ) || ( nPresetClass == sal_uInt32(EffectPresetClass::EXIT) ) )
 144     {
 145         if ( nPresetId != 21 )
 146         {
 147             switch( nPresetId )
 148             {
 149                 case 5 :
 150                 {
 151                     if ( rPresetSubType == "downward" )
 152                     {
 153                         nPresetSubType = 5;
 154                         bTranslated = true;
 155                     }
 156                     else if ( rPresetSubType == "across" )
 157                     {
 158                         nPresetSubType = 10;
 159                         bTranslated = true;
 160                     }
 161                 }
 162                 break;
 163                 case 17 :
 164                 {
 165                     if ( rPresetSubType == "across" )
 166                     {
 167                         nPresetSubType = 10;
 168                         bTranslated = true;
 169                     }
 170                 }
 171                 break;
 172                 case 18 :
 173                 {
 174                     if ( rPresetSubType == "right-to-top" )
 175                     {
 176                         nPresetSubType = 3;
 177                         bTranslated = true;
 178                     }
 179                     else if ( rPresetSubType == "right-to-bottom" )
 180                     {
 181                         nPresetSubType = 6;
 182                         bTranslated = true;
 183                     }
 184                     else if ( rPresetSubType == "left-to-top" )
 185                     {
 186                         nPresetSubType = 9;
 187                         bTranslated = true;
 188                     }
 189                     else if ( rPresetSubType == "left-to-bottom" )
 190                     {
 191                         nPresetSubType = 12;
 192                         bTranslated = true;
 193                     }
 194                 }
 195                 break;
 196             }
 197         }
 198         if ( !bTranslated )
 199         {
 200             const oox::ppt::convert_subtype* p = oox::ppt::convert_subtype::getList();
 201             while( p->mpStrSubType )
 202             {
 203                 if ( rPresetSubType.equalsAscii( p->mpStrSubType ) )
 204                 {
 205                     nPresetSubType = p->mnID;
 206                     bTranslated = true;
 207                     break;
 208                 }
 209                 p++;
 210             }
 211         }
 212     }
 213     if ( !bTranslated )
 214         nPresetSubType = rPresetSubType.toUInt32();
 215     return nPresetSubType;
 216 }
 217
 218 const sal_Char* AnimationExporter::FindTransitionName( const sal_Int16 nType, const sal_Int16 nSubType, const bool bDirection )
 219 {
 220     const sal_Char* pRet = nullptr;
 221     int             nFit = 0;
 222
 223     const oox::ppt::transition* p = oox::ppt::transition::getList();
 224     while( p->mpName )
 225     {
 226         int nF = 0;
 227         if ( nType == p->mnType )
 228             nF += 4;
 229         if ( nSubType == p->mnSubType )
 230             nF += 2;
 231         if ( bDirection == p->mbDirection )
 232             nF += 1;
 233         if ( nF > nFit )
 234         {
 235             pRet = p->mpName;
 236             nFit = nF;
 237         }
 238         if ( nFit == 7 )    // maximum
 239             break;
 240         p++;
 241     }
 242     return pRet;
 243 }
 244
 245 SvStream& WriteAnimationNode(SvStream& rOut, AnimationNode const & rNode )
 246 {
 247     rOut.WriteInt32( rNode.mnU1 );
 248     rOut.WriteInt32( rNode.mnRestart );
 249     rOut.WriteInt32( rNode.mnGroupType );
 250     rOut.WriteInt32( rNode.mnFill );
 251     rOut.WriteInt32( rNode.mnU3 );
 252     rOut.WriteInt32( rNode.mnU4 );
 253     rOut.WriteInt32( rNode.mnDuration );
 254     rOut.WriteInt32( rNode.mnNodeType );
 255
 256     return rOut;
 257 }
 258
 259 AnimationExporter::AnimationExporter( const EscherSolverContainer& rSolverContainer, ppt::ExSoundCollection& rExSoundCollection ) :
 260     mrSolverContainer   ( rSolverContainer ),
 261     mrExSoundCollection ( rExSoundCollection ),
 262     mnCurrentGroup(0)
 263 {
 264 }
 265
 266 sal_Int16 AnimationExporter::GetFillMode( const Reference< XAnimationNode >& xNode, const sal_Int16 nFillDefault )
 267 {
 268     sal_Int16 nFill = xNode->getFill();
 269     //#i119699 <Animation> The animation effect "Emphasis->FlashBulb" play incorrectly in Aoo saves a .ppt to another .ppt and plays the saved one.
 270     //#i119740 <Animation> The animation effect "Entrance->Flash Once" fails to play in Aoo while Aoo saves a .ppt to another .ppt and plays the saved one.
 271     if ((xNode->getType() == AnimationNodeType::ANIMATE)
 272         ||(xNode->getType() == AnimationNodeType::SET)
 273         ||(xNode->getType() == AnimationNodeType::TRANSITIONFILTER))
 274     {
 275         if ( nFill == AnimationFill::DEFAULT )
 276             return nFill;
 277     }
 278
 279     if ( nFill == AnimationFill::DEFAULT )
 280     {
 281         nFill = nFillDefault;
 282     }
 283     if( nFill == AnimationFill::AUTO )
 284     {
 285         nFill = AnimationFill::REMOVE;
 286         bool bIsIndefiniteTiming = true;
 287         Any aAny = xNode->getDuration();
 288         if( aAny.hasValue() )
 289         {
 290             Timing eTiming;
 291             if( aAny >>= eTiming )
 292                 bIsIndefiniteTiming = eTiming == Timing_INDEFINITE;
 293         }
 294         if ( bIsIndefiniteTiming )
 295         {
 296             aAny = xNode->getEnd();
 297             if( aAny.hasValue() )
 298             {
 299                 Timing eTiming;
 300                 if( aAny >>= eTiming )
 301                     bIsIndefiniteTiming = eTiming == Timing_INDEFINITE;
 302             }
 303             if ( bIsIndefiniteTiming )
 304             {
 305                 if ( !xNode->getRepeatCount().hasValue() )
 306                 {
 307                     aAny = xNode->getRepeatDuration();
 308                     if( aAny.hasValue() )
 309                     {
 310                         Timing eTiming;
 311                         if( aAny >>= eTiming )
 312                             bIsIndefiniteTiming = eTiming == Timing_INDEFINITE;
 313                     }
 314                     if ( bIsIndefiniteTiming )
 315                         nFill = AnimationFill::FREEZE;
 316                 }
 317             }
 318         }
 319     }
 320     return nFill;
 321 }
 322
 323 void AnimationExporter::doexport( const Reference< XDrawPage >& xPage, SvStream& rStrm )
 324 {
 325     Reference< XAnimationNodeSupplier > xNodeSupplier( xPage, UNO_QUERY );
 326     if( xNodeSupplier.is() )
 327     {
 328         const Reference< XAnimationNode > xRootNode( xNodeSupplier->getAnimationNode() );
 329         if( xRootNode.is() )
 330         {
 331             processAfterEffectNodes( xRootNode );
 332             exportNode( rStrm, xRootNode, DFF_msofbtAnimGroup, 1, 0, false, AnimationFill::AUTO );
 333         }
 334     }
 335 }
 336
 337 void AnimationExporter::processAfterEffectNodes( const Reference< XAnimationNode >& xRootNode )
 338 {
 339     try
 340     {
 341         Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
 342         Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), css::uno::UNO_SET_THROW );
 343         while( xEnumeration->hasMoreElements() )
 344         {
 345             Reference< XAnimationNode > xNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
 346
 347             Reference< XEnumerationAccess > xEnumerationAccess2( xNode, UNO_QUERY );
 348             if ( xEnumerationAccess2.is() )
 349             {
 350                 Reference< XEnumeration > xEnumeration2( xEnumerationAccess2->createEnumeration(), css::uno::UNO_SET_THROW );
 351                 while( xEnumeration2->hasMoreElements() )
 352                 {
 353                     Reference< XAnimationNode > xChildNode( xEnumeration2->nextElement(), UNO_QUERY_THROW );
 354
 355                     Reference< XEnumerationAccess > xEnumerationAccess3( xChildNode, UNO_QUERY_THROW );
 356                     Reference< XEnumeration > xEnumeration3( xEnumerationAccess3->createEnumeration(), css::uno::UNO_SET_THROW );
 357                     while( xEnumeration3->hasMoreElements() )
 358                     {
 359                         Reference< XAnimationNode > xChildNode2( xEnumeration3->nextElement(), UNO_QUERY_THROW );
 360
 361                         Reference< XEnumerationAccess > xEnumerationAccess4( xChildNode2, UNO_QUERY_THROW );
 362                         Reference< XEnumeration > xEnumeration4( xEnumerationAccess4->createEnumeration(), css::uno::UNO_SET_THROW );
 363                         while( xEnumeration4->hasMoreElements() )
 364                         {
 365                             Reference< XAnimationNode > xChildNode3( xEnumeration4->nextElement(), UNO_QUERY_THROW );
 366
 367                             switch( xChildNode3->getType() )
 368                             {
 369                             // found an after effect
 370                             case AnimationNodeType::SET:
 371                             case AnimationNodeType::ANIMATECOLOR:
 372                                 {
 373                                     Reference< XAnimationNode > xMaster;
 374
 375                                     Sequence< NamedValue > aUserData( xChildNode3->getUserData() );
 376                                     const NamedValue* p = std::find_if(aUserData.begin(), aUserData.end(),
 377                                         [](const NamedValue& rProp) { return rProp.Name == "master-element"; });
 378
 379                                     if (p != aUserData.end())
 380                                         p->Value >>= xMaster;
 381
 382                                     AfterEffectNodePtr pAfterEffectNode( new AfterEffectNode( xChildNode3, xMaster ) );
 383                                     maAfterEffectNodes.push_back( pAfterEffectNode );
 384                                 }
 385                                 break;
 386                             }
 387                         }
 388                     }
 389                 }
 390             }
 391         }
 392     }
 393     catch( Exception& )
 394     {
 395         OSL_FAIL( "(@CL)AnimationExporter::processAfterEffectNodes(), exception caught!" );
 396     }
 397 }
 398
 399 bool AnimationExporter::isAfterEffectNode( const Reference< XAnimationNode >& xNode ) const
 400 {
 401     return std::any_of(maAfterEffectNodes.begin(), maAfterEffectNodes.end(),
 402         [&xNode](const AfterEffectNodePtr& rxNode) { return rxNode->mxNode == xNode; });
 403 }
 404
 405 bool AnimationExporter::hasAfterEffectNode( const Reference< XAnimationNode >& xNode, Reference< XAnimationNode >& xAfterEffectNode ) const
 406 {
 407     auto aIter = std::find_if(maAfterEffectNodes.begin(), maAfterEffectNodes.end(),
 408         [&xNode](const AfterEffectNodePtr& rxNode) { return rxNode->mxMaster == xNode; });
 409     if (aIter != maAfterEffectNodes.end())
 410     {
 411         xAfterEffectNode = (*aIter)->mxNode;
 412         return true;
 413     }
 414
 415     return false;
 416 }
 417
 418 // check if this group only contain empty groups. this may happen when
 419 // after effect nodes are not exported at their original position
 420 bool AnimationExporter::isEmptyNode( const Reference< XAnimationNode >& xNode ) const
 421 {
 422     if( xNode.is() ) switch( xNode->getType() )
 423     {
 424     case AnimationNodeType::PAR :
 425     case AnimationNodeType::SEQ :
 426     case AnimationNodeType::ITERATE :
 427         {
 428             Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY );
 429             if( xEnumerationAccess.is() )
 430             {
 431                 Reference< XEnumeration > xEnumeration = xEnumerationAccess->createEnumeration();
 432                 if( xEnumeration.is() )
 433                 {
 434                     while( xEnumeration->hasMoreElements() )
 435                     {
 436                         Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
 437                         if( xChildNode.is() && !isEmptyNode( xChildNode ) )
 438                             return false;
 439                     }
 440                 }
 441             }
 442         }
 443         break;
 444
 445     case AnimationNodeType::SET :
 446     case AnimationNodeType::ANIMATECOLOR :
 447         return isAfterEffectNode( xNode );
 448     default:
 449         return false;
 450     }
 451
 452     return true;
 453 }
 454
 455 void AnimationExporter::exportNode( SvStream& rStrm, Reference< XAnimationNode > const & xNode_in, const sal_uInt16 nContainerRecType,
 456                                     const sal_uInt16 nInstance, const sal_Int32 nGroupLevel, const bool bTakeBackInteractiveSequenceTiming, const sal_Int16 nFDef )
 457 {
 458     auto xNode = xNode_in;
 459
 460     if( (nGroupLevel == 4) && isEmptyNode( xNode ) )
 461         return;
 462
 463     if ( ( nContainerRecType == DFF_msofbtAnimGroup ) && ( nGroupLevel == 2 ) && isEmptyNode( xNode ) )
 464         return;
 465
 466     if( nContainerRecType == DFF_msofbtAnimGroup )
 467         mnCurrentGroup++;
 468
 469     bool bTakeBackInteractiveSequenceTimingForChild = false;
 470     sal_Int16 nFillDefault = GetFillMode( xNode, nFDef );
 471
 472     Reference< XAnimationNode > xAudioNode;
 473     static sal_uInt32 nAudioGroup;
 474
 475     {
 476         bool bSkipChildren = false;
 477         EscherExContainer aContainer( rStrm, nContainerRecType, nInstance );
 478         switch( xNode->getType() )
 479         {
 480             case AnimationNodeType::CUSTOM :
 481             {
 482                 exportAnimNode( rStrm, xNode, nFillDefault );
 483                 exportAnimPropertySet( rStrm, xNode );
 484                 exportAnimEvent( rStrm, xNode );
 485                 exportAnimValue( rStrm, xNode, false );
 486             }
 487             break;
 488
 489             case AnimationNodeType::PAR :
 490             {
 491                 exportAnimNode( rStrm, xNode, nFillDefault );
 492                 exportAnimPropertySet( rStrm, xNode );
 493                 sal_Int32 nFlags = nGroupLevel == 2 ? 0x10 : 0;
 494                 if ( bTakeBackInteractiveSequenceTiming )
 495                     nFlags |= 0x40;
 496                 exportAnimEvent( rStrm, xNode, nFlags );
 497                 exportAnimValue( rStrm, xNode, nGroupLevel == 4 );
 498             }
 499             break;
 500
 501             case AnimationNodeType::SEQ :
 502             {
 503                 exportAnimNode( rStrm, xNode, nFillDefault );
 504                 sal_Int16 nNodeType = exportAnimPropertySet( rStrm, xNode );
 505                 sal_Int32 nFlags = 12;
 506                 if ( ( nGroupLevel == 1 ) && ( nNodeType == css::presentation::EffectNodeType::INTERACTIVE_SEQUENCE ) )
 507                 {
 508                     nFlags |= 0x20;
 509                     bTakeBackInteractiveSequenceTimingForChild = true;
 510                 }
 511                 exportAnimAction( rStrm, xNode );
 512                 exportAnimEvent( rStrm, xNode, nFlags );
 513                 exportAnimValue( rStrm, xNode, false );
 514             }
 515             break;
 516
 517             case AnimationNodeType::ITERATE :
 518             {
 519                 {
 520                     EscherExAtom aAnimNodeExAtom( rStrm, DFF_msofbtAnimNode );
 521                     AnimationNode aAnim;
 522                     aAnim.mnGroupType = mso_Anim_GroupType_PAR;
 523                     aAnim.mnNodeType = 1;
 524                     // attribute Restart
 525                     switch( xNode->getRestart() )
 526                     {
 527                         default:
 528                         case AnimationRestart::DEFAULT : aAnim.mnRestart = 0; break;
 529                         case AnimationRestart::ALWAYS  : aAnim.mnRestart = 1; break;
 530                         case AnimationRestart::WHEN_NOT_ACTIVE : aAnim.mnRestart = 2; break;
 531                         case AnimationRestart::NEVER : aAnim.mnRestart = 3; break;
 532                     }
 533                     // attribute Fill
 534                     switch( xNode->getFill() )
 535                     {
 536                         default:
 537                         case AnimationFill::DEFAULT : aAnim.mnFill = 0; break;
 538                         case AnimationFill::REMOVE : aAnim.mnFill = 1; break;
 539                         case AnimationFill::FREEZE : aAnim.mnFill = 2; break;
 540                         case AnimationFill::HOLD : aAnim.mnFill = 3; break;
 541                         case AnimationFill::TRANSITION : aAnim.mnFill = 4; break;
 542                     }
 543                     WriteAnimationNode( rStrm, aAnim );
 544                 }
 545                 exportIterate( rStrm, xNode );
 546                 exportAnimPropertySet( rStrm, xNode );
 547                 exportAnimEvent( rStrm, xNode );
 548                 exportAnimValue( rStrm, xNode, false );
 549             }
 550             break;
 551
 552             case AnimationNodeType::ANIMATE :
 553             {
 554                 exportAnimNode( rStrm, xNode, nFillDefault );
 555                 exportAnimPropertySet( rStrm, xNode );
 556                 exportAnimEvent( rStrm, xNode );
 557                 exportAnimValue( rStrm, xNode, false );
 558                 exportAnimate( rStrm, xNode );
 559             }
 560             break;
 561
 562             case AnimationNodeType::SET :
 563             {
 564                 bool bIsAfterEffectNode( isAfterEffectNode( xNode ) );
 565                 if( (nGroupLevel != 4) || !bIsAfterEffectNode )
 566                 {
 567                     exportAnimNode( rStrm, xNode, nFillDefault );
 568                     exportAnimPropertySet( rStrm, xNode );
 569                     exportAnimateSet( rStrm, xNode, bIsAfterEffectNode ? AFTEREFFECT_SET : AFTEREFFECT_NONE );
 570                     exportAnimEvent( rStrm, xNode );
 571                     exportAnimValue( rStrm, xNode, false );
 572                 }
 573                 else
 574                 {
 575                     bSkipChildren = true;
 576                 }
 577             }
 578             break;
 579
 580             case AnimationNodeType::ANIMATEMOTION :
 581             {
 582                 exportAnimNode( rStrm, xNode, nFillDefault );
 583                 exportAnimPropertySet( rStrm, xNode );
 584                 exportAnimateMotion( rStrm, xNode );
 585                 exportAnimEvent( rStrm, xNode );
 586                 exportAnimValue( rStrm, xNode, false );
 587             }
 588             break;
 589
 590             case AnimationNodeType::ANIMATECOLOR :
 591             {
 592                 bool bIsAfterEffectNode( isAfterEffectNode( xNode ) );
 593                 if( (nGroupLevel != 4) || !bIsAfterEffectNode )
 594                 {
 595                     if( bIsAfterEffectNode )
 596                         xNode = createAfterEffectNodeClone( xNode );
 597
 598                     exportAnimNode( rStrm, xNode, nFillDefault );
 599                     exportAnimPropertySet( rStrm, xNode );
 600                     exportAnimateColor( rStrm, xNode, bIsAfterEffectNode ? AFTEREFFECT_COLOR : AFTEREFFECT_NONE );
 601                     exportAnimEvent( rStrm, xNode );
 602                     exportAnimValue( rStrm, xNode, false );
 603                 }
 604                 else
 605                 {
 606                     bSkipChildren = true;
 607                 }
 608             }
 609             break;
 610
 611             case AnimationNodeType::ANIMATETRANSFORM :
 612             {
 613                 exportAnimNode( rStrm, xNode, nFillDefault );
 614                 exportAnimPropertySet( rStrm, xNode );
 615                 exportAnimateTransform( rStrm, xNode );
 616                 exportAnimEvent( rStrm, xNode );
 617                 exportAnimValue( rStrm, xNode, false );
 618             }
 619             break;
 620
 621             case AnimationNodeType::TRANSITIONFILTER :
 622             {
 623                 exportAnimNode( rStrm, xNode, nFillDefault );
 624                 exportAnimPropertySet( rStrm, xNode );
 625                 exportAnimEvent( rStrm, xNode );
 626                 exportAnimValue( rStrm, xNode, false );
 627                 exportTransitionFilter( rStrm, xNode );
 628             }
 629             break;
 630
 631             case AnimationNodeType::AUDIO :     // #i58428#
 632             {
 633                 exportAnimNode( rStrm, xNode, nFillDefault );
 634                 exportAnimPropertySet( rStrm, xNode );
 635
 636                 Reference< XAudio > xAudio( xNode, UNO_QUERY );
 637                 if( xAudio.is() )
 638                 {
 639                     Any aAny( xAudio->getSource() );
 640                     OUString aURL;
 641
 642                     if ( ( aAny >>= aURL)  &&  !aURL.isEmpty()  )
 643                     {
 644                         sal_Int32 nU1 = 2;
 645                         sal_Int32 nTrigger = 3;
 646                         sal_Int32 nU3 = nAudioGroup;
 647                         sal_Int32 nBegin = 0;
 648                         {
 649                             EscherExContainer aAnimEvent( rStrm, DFF_msofbtAnimEvent, 1 );
 650                             {
 651                                 EscherExAtom aAnimTrigger( rStrm, DFF_msofbtAnimTrigger );
 652                                 rStrm.WriteInt32( nU1 ).WriteInt32( nTrigger ).WriteInt32( nU3 ).WriteInt32( nBegin );
 653                             }
 654                         }
 655                         nU1 = 1;
 656                         nTrigger = 0xb;
 657                         nU3 = 0;
 658                         {
 659                             EscherExContainer aAnimEvent( rStrm, DFF_msofbtAnimEvent, 2 );
 660                             {
 661                                 EscherExAtom aAnimTrigger( rStrm, DFF_msofbtAnimTrigger );
 662                                 rStrm.WriteInt32( nU1 ).WriteInt32( nTrigger ).WriteInt32( nU3 ).WriteInt32( nBegin );
 663                             }
 664                         }
 665                         EscherExContainer aAnimateTargetElement( rStrm, DFF_msofbtAnimateTargetElement );
 666                         {
 667                             sal_uInt32 const nRefMode = 3;
 668                             sal_uInt32 const nRefType = 2;
 669                             sal_uInt32 nRefId = mrExSoundCollection.GetId( aURL );
 670                             sal_Int32 const begin = -1;
 671                             sal_Int32 const end = -1;
 672
 673                             EscherExAtom aAnimReference( rStrm, DFF_msofbtAnimReference );
 674                             rStrm.WriteUInt32( nRefMode ).WriteUInt32( nRefType ).WriteUInt32( nRefId ).WriteInt32( begin ).WriteInt32( end );
 675                         }
 676                     }
 677                 }
 678                 exportAnimValue( rStrm, xNode, false );
 679             }
 680             break;
 681         }
 682         if( !bSkipChildren )
 683         {
 684             // export after effect node if one exists for this node
 685             Reference< XAnimationNode > xAfterEffectNode;
 686             if( hasAfterEffectNode( xNode, xAfterEffectNode ) )
 687             {
 688                 exportNode( rStrm, xAfterEffectNode, DFF_msofbtAnimSubGoup, 1, nGroupLevel + 1, bTakeBackInteractiveSequenceTimingForChild, nFillDefault );
 689             }
 690
 691             Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY );
 692             if( xEnumerationAccess.is() )
 693             {
 694                 Reference< XEnumeration > xEnumeration = xEnumerationAccess->createEnumeration();
 695                 if( xEnumeration.is() )
 696                 {
 697                     while( xEnumeration->hasMoreElements() )
 698                     {
 699                         Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
 700                         if( xChildNode.is() )
 701                         {
 702                             if ( xChildNode->getType() == AnimationNodeType::AUDIO )
 703                             {
 704                                 xAudioNode = xChildNode;
 705                                 nAudioGroup = mnCurrentGroup;
 706                             }
 707                             else
 708                                 exportNode( rStrm, xChildNode, DFF_msofbtAnimGroup, 1, nGroupLevel + 1, bTakeBackInteractiveSequenceTimingForChild, nFillDefault );
 709                         }
 710                     }
 711                 }
 712             }
 713         }
 714     }
 715     if ( xAudioNode.is() )
 716         exportNode( rStrm, xAudioNode, DFF_msofbtAnimGroup, 1, nGroupLevel, bTakeBackInteractiveSequenceTimingForChild, nFillDefault );
 717
 718     if( xNode->getType() == AnimationNodeType::ITERATE )
 719         aTarget = Any();
 720 }
 721
 722 Reference< XAnimationNode > AnimationExporter::createAfterEffectNodeClone( const Reference< XAnimationNode >& xNode )
 723 {
 724     try
 725     {
 726         Reference< css::util::XCloneable > xClonable( xNode, UNO_QUERY_THROW );
 727         Reference< XAnimationNode > xCloneNode( xClonable->createClone(), UNO_QUERY_THROW );
 728
 729         Any aEmpty;
 730         xCloneNode->setBegin( aEmpty );
 731
 732         return xCloneNode;
 733     }
 734     catch( Exception& )
 735     {
 736         OSL_FAIL("(@CL)sd::ppt::AnimationExporter::createAfterEffectNodeClone(), could not create clone!" );
 737     }
 738     return xNode;
 739 }
 740
 741 bool AnimationExporter::GetNodeType( const Reference< XAnimationNode >& xNode, sal_Int16& nType )
 742 {
 743     // trying to get the nodetype
 744     const Sequence< NamedValue > aUserData = xNode->getUserData();
 745     for( const NamedValue& rProp : aUserData )
 746     {
 747         if ( rProp.Name == "node-type" )
 748         {
 749             if ( rProp.Value >>= nType )
 750                 return true;
 751         }
 752     }
 753
 754     return false;
 755 }
 756
 757 void AnimationExporter::exportAnimNode( SvStream& rStrm, const Reference< XAnimationNode >& xNode,
 758         const sal_Int16 nFillDefault )
 759 {
 760     EscherExAtom    aAnimNodeExAtom( rStrm, DFF_msofbtAnimNode );
 761     AnimationNode   aAnim;
 762
 763     // attribute Restart
 764     switch( xNode->getRestart() )
 765     {
 766         default:
 767         case AnimationRestart::DEFAULT : aAnim.mnRestart = 0; break;
 768         case AnimationRestart::ALWAYS  : aAnim.mnRestart = 1; break;
 769         case AnimationRestart::WHEN_NOT_ACTIVE : aAnim.mnRestart = 2; break;
 770         case AnimationRestart::NEVER : aAnim.mnRestart = 3; break;
 771     }
 772
 773     switch( nFillDefault )
 774     {
 775         default:
 776         case AnimationFill::DEFAULT : aAnim.mnFill = 0; break;
 777         case AnimationFill::REMOVE : aAnim.mnFill = 1; break;
 778         case AnimationFill::FREEZE :
 779         case AnimationFill::HOLD :   aAnim.mnFill = 3; break;
 780         case AnimationFill::TRANSITION : aAnim.mnFill = 4; break;
 781     }
 782     // attribute Duration
 783     double fDuration = 0.0;
 784     css::animations::Timing eTiming;
 785     if ( xNode->getDuration() >>= eTiming )
 786     {
 787         if ( eTiming == Timing_INDEFINITE )
 788             aAnim.mnDuration = -1;
 789     }
 790     else if ( xNode->getDuration() >>= fDuration )
 791     {
 792         aAnim.mnDuration = static_cast<sal_Int32>( fDuration * 1000.0 );
 793     }
 794     else
 795         aAnim.mnDuration = -1;
 796
 797     // NodeType, NodeGroup
 798     aAnim.mnNodeType = 1;
 799     aAnim.mnGroupType = mso_Anim_GroupType_SEQ;
 800     switch( xNode->getType() )
 801     {
 802         case AnimationNodeType::PAR :
 803             aAnim.mnGroupType = mso_Anim_GroupType_PAR;
 804             [[fallthrough]];
 805         case AnimationNodeType::SEQ :
 806         {
 807             sal_Int16 nType = 0;
 808             if( GetNodeType( xNode, nType ) )
 809                 switch( nType )
 810                 {
 811                     case css::presentation::EffectNodeType::TIMING_ROOT : aAnim.mnNodeType = 0x12; break;
 812                     case css::presentation::EffectNodeType::MAIN_SEQUENCE : aAnim.mnNodeType = 0x18; break;
 813                 }
 814         }
 815         break;
 816
 817         case AnimationNodeType::ANIMATE :
 818         case AnimationNodeType::SET :
 819
 820         case AnimationNodeType::CUSTOM :
 821         case AnimationNodeType::ITERATE :
 822         case AnimationNodeType::ANIMATEMOTION :
 823         case AnimationNodeType::ANIMATECOLOR :
 824         case AnimationNodeType::ANIMATETRANSFORM :
 825         {
 826             aAnim.mnGroupType = mso_Anim_GroupType_NODE;
 827             aAnim.mnNodeType  = mso_Anim_Behaviour_ANIMATION;
 828         }
 829         break;
 830
 831         case AnimationNodeType::AUDIO :
 832         {
 833             aAnim.mnGroupType = mso_Anim_GroupType_MEDIA;
 834             aAnim.mnNodeType  = mso_Anim_Behaviour_ANIMATION;
 835         }
 836         break;
 837
 838         case AnimationNodeType::TRANSITIONFILTER :
 839         {
 840             aAnim.mnGroupType = mso_Anim_GroupType_NODE;
 841             aAnim.mnNodeType  = mso_Anim_Behaviour_FILTER;
 842         }
 843         break;
 844     }
 845
 846     WriteAnimationNode( rStrm, aAnim );
 847 }
 848
 849 void AnimationExporter::GetUserData( const Sequence< NamedValue >& rUserData, const Any ** pAny, std::size_t nLen )
 850 {
 851     // storing user data into pAny, to allow direct access later
 852     memset( pAny, 0, nLen );
 853     if ( !rUserData.hasElements() )
 854         return;
 855
 856     for( const NamedValue& rProp : rUserData )
 857     {
 858         if ( rProp.Name == "node-type" )
 859         {
 860             pAny[ DFF_ANIM_NODE_TYPE ] = &(rProp.Value);
 861         }
 862         else if ( rProp.Name == "preset-class" )
 863         {
 864             pAny[ DFF_ANIM_PRESET_CLASS ] = &(rProp.Value);
 865         }
 866         else if ( rProp.Name == "preset-id" )
 867         {
 868             pAny[ DFF_ANIM_PRESET_ID ] = &(rProp.Value);
 869         }
 870         else if ( rProp.Name == "preset-sub-type" )
 871         {
 872             pAny[ DFF_ANIM_PRESET_SUB_TYPE ] = &(rProp.Value);
 873         }
 874         else if ( rProp.Name == "master-element" )
 875         {
 876             pAny[ DFF_ANIM_AFTEREFFECT ] = &(rProp.Value);
 877         }
 878     }
 879 }
 880
 881 sal_uInt32 AnimationExporter::GetPresetID( const OUString& rPreset, sal_uInt32 nAPIPresetClass, bool& bPresetId )
 882 {
 883     sal_uInt32 nPresetId = 0;
 884     bPresetId = false;
 885
 886     if ( rPreset.match("ppt_", 0) )
 887     {
 888     sal_Int32 nLast = rPreset.lastIndexOf( '_' );
 889     if ( ( nLast != -1 ) && ( ( nLast + 1 ) < rPreset.getLength() ) )
 890     {
 891         OUString aNumber( rPreset.copy( nLast + 1 ) );
 892         nPresetId = aNumber.toUInt32();
 893         bPresetId = true;
 894     }
 895     }
 896     else
 897     {
 898         const oox::ppt::preset_mapping* p = oox::ppt::preset_mapping::getList();
 899         while( p->mpStrPresetId && ((p->mnPresetClass != static_cast<sal_Int32>(nAPIPresetClass)) || !rPreset.equalsAscii( p->mpStrPresetId )) )
 900             p++;
 901
 902         if( p->mpStrPresetId )
 903         {
 904             nPresetId = p->mnPresetId;
 905             bPresetId = true;
 906         }
 907     }
 908
 909     return nPresetId;
 910 }
 911
 912 sal_Int16 AnimationExporter::exportAnimPropertySet( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
 913 {
 914     sal_Int16 nNodeType = css::presentation::EffectNodeType::DEFAULT;
 915
 916     EscherExContainer aAnimPropertySet( rStrm, DFF_msofbtAnimPropertySet );
 917
 918     Reference< XAnimationNode > xMaster;
 919
 920     Any aMasterRel, aOverride, aRunTimeContext;
 921
 922     // storing user data into pAny, to allow direct access later
 923     const Sequence< NamedValue > aUserData = xNode->getUserData();
 924     const css::uno::Any* pAny[ DFF_ANIM_PROPERTY_ID_COUNT ];
 925     GetUserData( aUserData, pAny, sizeof( pAny ) );
 926
 927     if( pAny[ DFF_ANIM_AFTEREFFECT ] )
 928         ( *pAny[ DFF_ANIM_AFTEREFFECT ] ) >>= xMaster;
 929
 930     // calculate master-rel
 931     if( xMaster.is() )
 932     {
 933         sal_Int32 nMasterRel = 2;
 934         if( xNode.is() && xMaster.is() && (xNode->getParent() == xMaster->getParent() ) )
 935             nMasterRel = 0;
 936
 937         aMasterRel <<= nMasterRel;
 938
 939         pAny[ DFF_ANIM_MASTERREL ] = &aMasterRel;
 940
 941         aOverride <<= sal_Int32(1);
 942         pAny[ DFF_ANIM_OVERRIDE ] = &aOverride;
 943
 944         aRunTimeContext <<= sal_Int32(1);
 945         pAny[ DFF_ANIM_RUNTIMECONTEXT ] = &aRunTimeContext;
 946     }
 947
 948     // the order is important
 949     if ( pAny[ DFF_ANIM_NODE_TYPE ] )
 950     {
 951         if ( *pAny[ DFF_ANIM_NODE_TYPE ] >>= nNodeType )
 952         {
 953             sal_uInt32 nPPTNodeType = DFF_ANIM_NODE_TYPE_ON_CLICK;
 954             switch( nNodeType )
 955             {
 956                 case css::presentation::EffectNodeType::ON_CLICK : nPPTNodeType = DFF_ANIM_NODE_TYPE_ON_CLICK; break;
 957                 case css::presentation::EffectNodeType::WITH_PREVIOUS : nPPTNodeType = DFF_ANIM_NODE_TYPE_WITH_PREVIOUS; break;
 958                 case css::presentation::EffectNodeType::AFTER_PREVIOUS : nPPTNodeType = DFF_ANIM_NODE_TYPE_AFTER_PREVIOUS; break;
 959                 case css::presentation::EffectNodeType::MAIN_SEQUENCE : nPPTNodeType = DFF_ANIM_NODE_TYPE_MAIN_SEQUENCE; break;
 960                 case css::presentation::EffectNodeType::TIMING_ROOT : nPPTNodeType = DFF_ANIM_NODE_TYPE_TIMING_ROOT; break;
 961                 case css::presentation::EffectNodeType::INTERACTIVE_SEQUENCE: nPPTNodeType = DFF_ANIM_NODE_TYPE_INTERACTIVE_SEQ; break;
 962             }
 963             exportAnimPropertyuInt32( rStrm, DFF_ANIM_NODE_TYPE, nPPTNodeType );
 964         }
 965     }
 966     sal_uInt32 nPresetId = 0;
 967     sal_uInt32 nPresetSubType = 0;
 968     sal_uInt32 nAPIPresetClass = EffectPresetClass::CUSTOM;
 969     sal_uInt32 nPresetClass = DFF_ANIM_PRESS_CLASS_USER_DEFINED;
 970     bool bPresetClass, bPresetId, bPresetSubType;
 971     bPresetId = bPresetClass = bPresetSubType = false;
 972
 973     if ( pAny[ DFF_ANIM_PRESET_CLASS ] )
 974     {
 975         if ( *pAny[ DFF_ANIM_PRESET_CLASS ] >>= nAPIPresetClass )
 976         {
 977             sal_uInt8 nPPTPresetClass;
 978             switch( nAPIPresetClass )
 979             {
 980                 case EffectPresetClass::ENTRANCE : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_ENTRANCE; break;
 981                 case EffectPresetClass::EXIT : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_EXIT; break;
 982                 case EffectPresetClass::EMPHASIS : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_EMPHASIS; break;
 983                 case EffectPresetClass::MOTIONPATH : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_MOTIONPATH; break;
 984                 case EffectPresetClass::OLEACTION : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_OLE_ACTION; break;
 985                 case EffectPresetClass::MEDIACALL : nPPTPresetClass = DFF_ANIM_PRESS_CLASS_MEDIACALL; break;
 986                 default :
 987                     nPPTPresetClass = DFF_ANIM_PRESS_CLASS_USER_DEFINED;
 988             }
 989             nPresetClass = nPPTPresetClass;
 990             bPresetClass = true;
 991         }
 992     }
 993     if ( pAny[ DFF_ANIM_PRESET_ID ] )
 994     {
 995         OUString sPreset;
 996         if ( *pAny[ DFF_ANIM_PRESET_ID ] >>= sPreset )
 997             nPresetId = GetPresetID( sPreset, nAPIPresetClass, bPresetId );
 998     }
 999
1000     if ( pAny[ DFF_ANIM_PRESET_SUB_TYPE ] )
1001     {
1002         OUString sPresetSubType;
1003         if ( *pAny[ DFF_ANIM_PRESET_SUB_TYPE ] >>= sPresetSubType )
1004         {
1005             nPresetSubType = TranslatePresetSubType( nPresetClass, nPresetId, sPresetSubType );
1006             bPresetSubType = true;
1007         }
1008     }
1009     if ( bPresetId )
1010         exportAnimPropertyuInt32( rStrm, DFF_ANIM_PRESET_ID, nPresetId );
1011     if ( bPresetSubType )
1012         exportAnimPropertyuInt32( rStrm, DFF_ANIM_PRESET_SUB_TYPE, nPresetSubType );
1013     if ( bPresetClass )
1014         exportAnimPropertyuInt32( rStrm, DFF_ANIM_PRESET_CLASS, nPresetClass );
1015
1016     if ( pAny[ DFF_ANIM_ID ] )
1017     {
1018         // TODO DFF_ANIM_ID
1019     }
1020
1021     if ( pAny[ DFF_ANIM_AFTEREFFECT ] )
1022     {
1023         bool bAfterEffect = false;
1024         if ( *pAny[ DFF_ANIM_AFTEREFFECT ] >>= bAfterEffect )
1025             exportAnimPropertyByte( rStrm, DFF_ANIM_AFTEREFFECT, int(bAfterEffect) );
1026     }
1027
1028     if ( pAny[ DFF_ANIM_RUNTIMECONTEXT ] )
1029     {
1030         sal_Int32 nRunTimeContext = 0;
1031         if ( *pAny[ DFF_ANIM_RUNTIMECONTEXT ] >>= nRunTimeContext )
1032             exportAnimPropertyuInt32( rStrm, DFF_ANIM_RUNTIMECONTEXT, nRunTimeContext );
1033     }
1034     if ( pAny[ DFF_ANIM_PATH_EDIT_MODE ] )
1035     {
1036         // TODO DFF_ANIM_ID
1037     }
1038
1039     if( !xMaster.is() )
1040     {
1041         Reference< XAnimateColor > xColor( xNode, UNO_QUERY );
1042         if( xColor.is() )
1043         {
1044
1045             bool bDirection = !xColor->getDirection();
1046             exportAnimPropertyuInt32( rStrm, DFF_ANIM_DIRECTION, bDirection ? 1 : 0 );
1047         }
1048     }
1049
1050     if ( pAny[ DFF_ANIM_OVERRIDE ] )
1051     {
1052         sal_Int32 nOverride = 0;
1053         if ( *pAny[ DFF_ANIM_OVERRIDE ] >>= nOverride )
1054             exportAnimPropertyuInt32( rStrm, DFF_ANIM_OVERRIDE, nOverride );
1055     }
1056
1057     if ( pAny[ DFF_ANIM_MASTERREL ] )
1058     {
1059         sal_Int32 nMasterRel = 0;
1060         if ( *pAny[ DFF_ANIM_MASTERREL ] >>= nMasterRel )
1061             exportAnimPropertyuInt32( rStrm, DFF_ANIM_MASTERREL, nMasterRel );
1062     }
1063
1064 /* todo
1065     Reference< XAudio > xAudio( xNode, UNO_QUERY );
1066     if( xAudio.is() )
1067     {
1068         sal_Int16 nEndAfterSlide = 0;
1069         nEndAfterSlide = xAudio->getEndAfterSlide();
1070         exportAnimPropertyuInt32( rStrm, DFF_ANIM_ENDAFTERSLIDE, nEndAfterSlide, TRANSLATE_NONE );
1071     }
1072 */
1073     Reference< XAnimate > xAnim( xNode, UNO_QUERY );
1074     if( xAnim.is() )
1075     {
1076         // TODO: DFF_ANIM_TIMEFILTER
1077     }
1078     if ( pAny[ DFF_ANIM_EVENT_FILTER ] )
1079     {
1080         // TODO DFF_ANIM_EVENT_FILTER
1081     }
1082     if ( pAny[ DFF_ANIM_VOLUME ] )
1083     {
1084         // TODO DFF_ANIM_VOLUME
1085     }
1086     return nNodeType;
1087 }
1088
1089 bool AnimationExporter::exportAnimProperty( SvStream& rStrm, const sal_uInt16 nPropertyId, const css::uno::Any& rAny, const TranslateMode eTranslateMode )
1090 {
1091     bool bRet = false;
1092     if ( rAny.hasValue() )
1093     {
1094         switch( rAny.getValueType().getTypeClass() )
1095         {
1096             case css::uno::TypeClass_UNSIGNED_SHORT :
1097             case css::uno::TypeClass_SHORT :
1098             case css::uno::TypeClass_UNSIGNED_LONG :
1099             case css::uno::TypeClass_LONG :
1100             {
1101                 sal_Int32 nVal = 0;
1102                 if ( rAny >>= nVal )
1103                 {
1104                     exportAnimPropertyuInt32( rStrm, nPropertyId, nVal );
1105                     bRet = true;
1106                 }
1107             }
1108             break;
1109
1110             case css::uno::TypeClass_DOUBLE :
1111             {
1112                 double fVal = 0.0;
1113                 if ( rAny >>= fVal )
1114                 {
1115                     exportAnimPropertyFloat( rStrm, nPropertyId, fVal );
1116                     bRet = true;
1117                 }
1118             }
1119             break;
1120             case css::uno::TypeClass_FLOAT :
1121             {
1122                 float fVal = 0.0;
1123                 if ( rAny >>= fVal )
1124                 {
1125                     if ( eTranslateMode & TRANSLATE_NUMBER_TO_STRING )
1126                     {
1127                         OUString aNumber( OUString::number( fVal ) );
1128                         exportAnimPropertyString( rStrm, nPropertyId, aNumber, eTranslateMode );
1129                     }
1130                     else
1131                     {
1132                         exportAnimPropertyFloat( rStrm, nPropertyId, fVal );
1133                         bRet = true;
1134                     }
1135                 }
1136             }
1137             break;
1138             case css::uno::TypeClass_STRING :
1139             {
1140                 OUString aStr;
1141                 if ( rAny >>= aStr )
1142                 {
1143                     exportAnimPropertyString( rStrm, nPropertyId, aStr, eTranslateMode );
1144                     bRet = true;
1145                 }
1146             }
1147             break;
1148             default:
1149                 break;
1150         }
1151     }
1152     return bRet;
1153 }
1154 void AnimationExporter::exportAnimPropertyString( SvStream& rStrm, const sal_uInt16 nPropertyId, const OUString& rVal, const TranslateMode eTranslateMode )
1155 {
1156     EscherExAtom aExAtom( rStrm, DFF_msofbtAnimAttributeValue, nPropertyId );
1157     rStrm.WriteUChar( DFF_ANIM_PROP_TYPE_UNISTRING );
1158     OUString aStr( rVal );
1159     if ( eTranslateMode != TRANSLATE_NONE )
1160         ImplTranslateAttribute( aStr, eTranslateMode );
1161     writeZString( rStrm, aStr );
1162 }
1163
1164 void AnimationExporter::exportAnimPropertyFloat( SvStream& rStrm, const sal_uInt16 nPropertyId, const double& rVal )
1165 {
1166     EscherExAtom aExAtom( rStrm, DFF_msofbtAnimAttributeValue, nPropertyId );
1167     float fFloat = static_cast<float>(rVal);
1168     rStrm.WriteUChar( DFF_ANIM_PROP_TYPE_FLOAT )
1169          .WriteFloat( fFloat );
1170 }
1171
1172 void AnimationExporter::exportAnimPropertyuInt32( SvStream& rStrm, const sal_uInt16 nPropertyId, const sal_uInt32 nVal )
1173 {
1174     EscherExAtom aExAtom( rStrm, DFF_msofbtAnimAttributeValue, nPropertyId );
1175     rStrm.WriteUChar( DFF_ANIM_PROP_TYPE_INT32 )
1176          .WriteUInt32( nVal );
1177 }
1178
1179 void AnimationExporter::exportAnimPropertyByte( SvStream& rStrm, const sal_uInt16 nPropertyId, const sal_uInt8 nVal )
1180 {
1181     EscherExAtom aExAtom( rStrm, DFF_msofbtAnimAttributeValue, nPropertyId );
1182     rStrm.WriteUChar( DFF_ANIM_PROP_TYPE_BYTE )
1183          .WriteUChar( nVal );
1184 }
1185
1186 void AnimationExporter::writeZString( SvStream& rStrm, const OUString& rVal )
1187 {
1188     sal_Int32 i;
1189     for ( i = 0; i < rVal.getLength(); i++ )
1190         rStrm.WriteUInt16( rVal[ i ] );
1191     rStrm.WriteUInt16( 0 );
1192 }
1193
1194 void AnimationExporter::exportAnimAction( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
1195 {
1196     EscherExAtom aExAtom( rStrm, DFF_msofbtAnimAction );
1197
1198     sal_Int32 const nConcurrent = 1;
1199     sal_Int32 const nNextAction = 1;
1200     sal_Int32 nEndSync = 0;
1201     sal_Int32 const nU4 = 0;
1202     sal_Int32 const nU5 = 3;
1203
1204     sal_Int16 nAnimationEndSync = 0;
1205     if ( xNode->getEndSync() >>= nAnimationEndSync )
1206     {
1207         if ( nAnimationEndSync == AnimationEndSync::ALL )
1208             nEndSync = 1;
1209     }
1210     rStrm.WriteInt32( nConcurrent )
1211          .WriteInt32( nNextAction )
1212          .WriteInt32( nEndSync )
1213          .WriteInt32( nU4 )
1214          .WriteInt32( nU5 );
1215
1216 }
1217
1218 // nFlags Bit 6 = fixInteractiveSequenceTiming (for child)
1219 // nFlags Bit 5 = fixInteractiveSequenceTiming (for root)
1220 // nFlags Bit 4 = first node of main sequence -> begin event next has to be replaced to indefinite
1221 void AnimationExporter::exportAnimEvent( SvStream& rStrm, const Reference< XAnimationNode >& xNode, const sal_Int32 nFlags )
1222 {
1223     sal_uInt16 i;
1224     for ( i = 0; i < 4; i++ )
1225     {
1226         sal_Int32 nU1 = 0;
1227         sal_Int32 nTrigger = 0;
1228         sal_Int32 nU3 = 0;
1229         sal_Int32 nBegin = 0;
1230
1231         bool bCreateEvent = false;
1232         Any aSource;
1233
1234         switch( i )
1235         {
1236             case 0 :
1237             case 1 :
1238             {
1239                 Any aAny;
1240                 Event aEvent;
1241                 css::animations::Timing eTiming;
1242                 if ( i == 0 )
1243                 {
1244                     if ( nFlags & 0x20 )
1245                     {
1246                         // taking the first child
1247                         Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
1248                         Reference< XEnumeration > xE( xEA->createEnumeration(), css::uno::UNO_SET_THROW );
1249                         if ( xE->hasMoreElements() )
1250                         {
1251                             Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
1252                             aAny = xClickNode->getBegin();
1253                         }
1254                     }
1255                     else if ( nFlags & 0x40 )
1256                     {
1257                         // begin has to be replaced with void, so don't do anything
1258                     }
1259                     else
1260                     {
1261                         aAny = xNode->getBegin();
1262                         if ( nFlags & 0x10 )    // replace ON_NEXT with INDEFINITE
1263                         {
1264                             if ( ( aAny >>= aEvent ) && ( aEvent.Trigger == EventTrigger::ON_NEXT ) )
1265                             {
1266                                 eTiming = Timing_INDEFINITE;
1267                                 aAny <<= eTiming;
1268                             }
1269                         }
1270                     }
1271                 }
1272                 else
1273                     aAny = xNode->getEnd();
1274
1275                 double fTiming = 0.0;
1276                 if ( aAny >>= aEvent )
1277                 {
1278                     bCreateEvent = true;
1279                     switch( aEvent.Trigger )
1280                     {
1281                         case EventTrigger::NONE : nTrigger = 0; break;
1282                         case EventTrigger::ON_BEGIN : nTrigger = 1; break;
1283                         case EventTrigger::ON_END : nTrigger = 2; break;
1284                         case EventTrigger::BEGIN_EVENT : nTrigger = 3; break;
1285                         case EventTrigger::END_EVENT : nTrigger = 4; nU1 = 2; nU3 = mnCurrentGroup; break;
1286                         case EventTrigger::ON_CLICK : nTrigger = 5; break;
1287                         case EventTrigger::ON_DBL_CLICK : nTrigger = 6; break;
1288                         case EventTrigger::ON_MOUSE_ENTER : nTrigger = 7; break;
1289                         case EventTrigger::ON_MOUSE_LEAVE : nTrigger = 8; break;
1290                         case EventTrigger::ON_NEXT : nTrigger = 9; break;
1291                         case EventTrigger::ON_PREV : nTrigger = 10; break;
1292                         case EventTrigger::ON_STOP_AUDIO : nTrigger = 11; break;
1293                     }
1294                     if ( aEvent.Offset.hasValue() )
1295                     {
1296                         if ( aEvent.Offset >>= eTiming )
1297                         {
1298                             if ( eTiming == Timing_INDEFINITE )
1299                                 nBegin = -1;
1300                         }
1301                         else if ( aEvent.Offset >>= fTiming )
1302                             nBegin = static_cast<sal_Int32>( fTiming * 1000.0 );
1303                     }
1304                     aSource = aEvent.Source;
1305                 }
1306                 else if ( aAny >>= eTiming )
1307                 {
1308                     bCreateEvent = true;
1309                     if ( eTiming == Timing_INDEFINITE )
1310                         nBegin = -1;
1311                 }
1312                 else if ( aAny >>= fTiming )
1313                 {
1314                     bCreateEvent = true;
1315                     nBegin = static_cast<sal_Int32>( fTiming * 1000.0 );
1316                 }
1317             }
1318             break;
1319
1320             case 2 :
1321             {
1322                 if ( nFlags & ( 1 << i ) )
1323                 {
1324                     bCreateEvent = true;
1325                     nU1 = 1;
1326                     nTrigger = 9;
1327                 }
1328             }
1329             break;
1330             case 3 :
1331             {
1332                 if ( nFlags & ( 1 << i ) )
1333                 {
1334                     bCreateEvent = true;
1335                     nU1 = 1;
1336                     nTrigger = 10;
1337                 }
1338             }
1339             break;
1340         };
1341         if ( bCreateEvent )
1342         {
1343             EscherExContainer aAnimEvent( rStrm, DFF_msofbtAnimEvent, i + 1 );
1344             {
1345                 EscherExAtom aAnimTrigger( rStrm, DFF_msofbtAnimTrigger );
1346                 rStrm.WriteInt32( nU1 )
1347                      .WriteInt32( nTrigger )
1348                      .WriteInt32( nU3 )
1349                      .WriteInt32( nBegin );
1350             }
1351             exportAnimateTargetElement( rStrm, aSource, ( nFlags & ( 1 << i ) ) != 0 );
1352         }
1353     }
1354 }
1355
1356 Any AnimationExporter::convertAnimateValue( const Any& rSourceValue, const OUString& rAttributeName )
1357 {
1358     OUString aDest;
1359     if ( rAttributeName == "X"
1360             || rAttributeName == "Y"
1361             || rAttributeName == "Width"
1362             || rAttributeName == "Height"
1363         )
1364     {
1365         OUString aStr;
1366         if ( rSourceValue >>= aStr )
1367         {
1368             ImplTranslateAttribute( aStr, TRANSLATE_MEASURE );
1369             aDest += aStr;
1370         }
1371     }
1372     else if ( rAttributeName == "Rotate"         // "r" or "style.rotation" ?
1373             || rAttributeName == "Opacity"
1374             || rAttributeName == "CharHeight"
1375             || rAttributeName == "SkewX"
1376         )
1377     {
1378         double fNumber = 0.0;
1379         if ( rSourceValue >>= fNumber )
1380             aDest += OUString::number( fNumber );
1381     }
1382     else if ( rAttributeName == "Color"
1383             || rAttributeName == "FillColor"     // "Fillcolor" or "FillColor" ?
1384             || rAttributeName == "LineColor"
1385             || rAttributeName == "CharColor"
1386         )
1387     {
1388         sal_Int32 nColor = 0;
1389         Sequence< double > aHSL( 3 );
1390         OUString aP( "," );
1391         if ( rSourceValue >>= aHSL )
1392         {
1393             aDest += "hsl("
1394                   +  OUString::number( static_cast<sal_Int32>( aHSL[ 0 ] / ( 360.0 / 255 ) ) )
1395                   +  aP
1396                   +  OUString::number( static_cast<sal_Int32>( aHSL[ 1 ] * 255.0 ) )
1397                   +  aP
1398                   +  OUString::number( static_cast<sal_Int32>( aHSL[ 2 ] * 255.0 ) )
1399                   +  ")";
1400         }
1401         else if ( rSourceValue >>= nColor )
1402         {
1403             aDest += "rgb("
1404                   +  OUString::number( static_cast<sal_Int8>(nColor) )
1405                   +  aP
1406                   +  OUString::number( static_cast<sal_Int8>( nColor >> 8 ) )
1407                   +  aP
1408                   +  OUString::number( static_cast<sal_Int8>( nColor >> 16 ) )
1409                   +  ")";
1410         }
1411     }
1412     else if ( rAttributeName == "FillStyle" )
1413     {
1414         css::drawing::FillStyle eFillStyle;
1415         if ( rSourceValue >>= eFillStyle )
1416         {
1417             if ( eFillStyle == css::drawing::FillStyle_NONE )
1418                 aDest += "none";    // ?
1419             else
1420                 aDest += "solid";
1421         }
1422     }
1423     else if (rAttributeName == "FillOn")
1424     {
1425         bool bFillOn;
1426         if ( rSourceValue >>= bFillOn )
1427         {
1428             if ( bFillOn )
1429                 aDest += "true";
1430             else
1431                 aDest += "false";
1432         }
1433     }
1434     else if ( rAttributeName == "LineStyle" )
1435     {
1436         css::drawing::LineStyle eLineStyle;
1437         if ( rSourceValue >>= eLineStyle )
1438         {
1439             if ( eLineStyle == css::drawing::LineStyle_NONE )
1440                 aDest += "false";
1441             else
1442                 aDest += "true";
1443         }
1444     }
1445     else if ( rAttributeName == "CharWeight" )
1446     {
1447         float fFontWeight = 0.0;
1448         if ( rSourceValue >>= fFontWeight )
1449         {
1450             if ( fFontWeight == css::awt::FontWeight::BOLD )
1451                 aDest += "bold";
1452             else
1453                 aDest += "normal";
1454         }
1455     }
1456     else if ( rAttributeName == "CharUnderline" )
1457     {
1458         sal_Int16 nFontUnderline = 0;
1459         if ( rSourceValue >>= nFontUnderline )
1460         {
1461             if ( nFontUnderline == css::awt::FontUnderline::NONE )
1462                 aDest += "false";
1463             else
1464                 aDest += "true";
1465         }
1466     }
1467     else if ( rAttributeName == "CharPosture" )
1468     {
1469         css::awt::FontSlant eFontSlant;
1470         if ( rSourceValue >>= eFontSlant )
1471         {
1472             if ( eFontSlant == css::awt::FontSlant_ITALIC )
1473                 aDest += "italic";
1474             else
1475                 aDest += "normal";  // ?
1476         }
1477     }
1478     else if ( rAttributeName == "Visibility" )
1479     {
1480         bool bVisible = true;
1481         if ( rSourceValue >>= bVisible )
1482         {
1483             if ( bVisible )
1484                 aDest += "visible";
1485             else
1486                 aDest += "hidden";
1487         }
1488     }
1489     Any aRet;
1490     if ( !aDest.isEmpty() )
1491         aRet <<= aDest;
1492     else
1493         aRet = rSourceValue;
1494     return aRet;
1495 }
1496
1497 void AnimationExporter::exportAnimateSet( SvStream& rStrm, const Reference< XAnimationNode >& xNode, int nAfterEffectType )
1498 {
1499     Reference< XAnimateSet > xSet( xNode, UNO_QUERY );
1500     if( !xSet.is() )
1501         return;
1502
1503     EscherExContainer aAnimateSet( rStrm, DFF_msofbtAnimateSet, 0 );
1504     {
1505         EscherExAtom aAnimateSetData( rStrm, DFF_msofbtAnimateSetData );
1506         sal_uInt32 const nId1 = 1;            // ??
1507         sal_uInt32 const nId2 = 1;            // ??
1508         rStrm.WriteUInt32( nId1 ).WriteUInt32( nId2 );
1509     }
1510     Any aConvertedValue( convertAnimateValue( xSet->getTo(), xSet->getAttributeName() ) );
1511     if ( aConvertedValue.hasValue() )
1512         exportAnimProperty( rStrm, 1, aConvertedValue, TRANSLATE_NONE );
1513     exportAnimateTarget( rStrm, xNode, 0, nAfterEffectType );
1514 }
1515
1516 sal_uInt32 AnimationExporter::GetValueTypeForAttributeName( const OUString& rAttributeName )
1517 {
1518     sal_uInt32 nValueType = 0;
1519
1520     struct Entry
1521     {
1522         const sal_Char* pName;
1523         sal_uInt8 nType;
1524     };
1525     static const Entry lcl_attributeMap[] =
1526     {
1527         { "charcolor", 2 },
1528         { "charfontname", 0 },
1529         { "charheight", 1 },
1530         { "charposture", 0 },
1531         // TODO(Q1): This should prolly be changed in PPT import
1532         // { "charrotation", ATTRIBUTE_CHAR_ROTATION },
1533         { "charrotation", 1 },
1534         { "charunderline", 0 },
1535         { "charweight", 0 },
1536         { "color", 2 },
1537         { "dimcolor", 2 },
1538         { "fillcolor", 2 },
1539         { "fillstyle", 0 },
1540         { "height", 1 },
1541         { "linecolor", 2 },
1542         { "linestyle", 0 },
1543         { "opacity", 0 },
1544         { "rotate", 1 },
1545         { "skewx", 1 },
1546         { "skewy", 1 },
1547         { "visibility", 1 },
1548         { "width", 1 },
1549         { "x", 1 },
1550         { "y", 1 },
1551         { nullptr, 0 }
1552     };
1553     const Entry* pPtr = &lcl_attributeMap[ 0 ];
1554     while( pPtr->pName )
1555     {
1556         if ( rAttributeName.equalsIgnoreAsciiCaseAscii( pPtr->pName ) )
1557         {
1558             nValueType = pPtr->nType;
1559             break;
1560         }
1561         pPtr++;
1562     }
1563     DBG_ASSERT( pPtr->pName, "GetValueTypeForAttributeName, unknown property value!" );
1564     return nValueType;
1565 }
1566
1567 void AnimationExporter::exportAnimate( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
1568 {
1569     Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
1570     if ( !xAnimate.is() )
1571         return;
1572
1573     Any aBy  ( xAnimate->getBy() );
1574     Any aFrom( xAnimate->getFrom() );
1575     Any aTo  ( xAnimate->getTo() );
1576
1577     EscherExContainer aContainer( rStrm, DFF_msofbtAnimate, 0 );
1578     {
1579         EscherExAtom    aAnimateData( rStrm, DFF_msofbtAnimateData );
1580         sal_uInt32 nBits = 0x38;
1581         sal_Int16 nTmp = xAnimate->getCalcMode();
1582         sal_uInt32 nCalcMode = /* (nTmp == AnimationCalcMode::FORMULA) ? 2 : */ (nTmp == AnimationCalcMode::LINEAR) ? 1 : 0;
1583         sal_uInt32 nValueType = GetValueTypeForAttributeName( xAnimate->getAttributeName() );
1584
1585         if ( aBy.hasValue() )
1586             nBits |= 1;
1587         if ( aFrom.hasValue() )
1588             nBits |= 2;
1589         if ( aTo.hasValue() )
1590             nBits |= 4;
1591
1592         rStrm.WriteUInt32( nCalcMode )
1593              .WriteUInt32( nBits )
1594              .WriteUInt32( nValueType );
1595     }
1596     if ( aBy.hasValue() )
1597         exportAnimProperty( rStrm, 1, aBy, TRANSLATE_NUMBER_TO_STRING | TRANSLATE_MEASURE );
1598     if ( aFrom.hasValue() )
1599         exportAnimProperty( rStrm, 2, aFrom, TRANSLATE_NUMBER_TO_STRING | TRANSLATE_MEASURE );
1600     if ( aTo.hasValue() )
1601         exportAnimProperty( rStrm, 3, aTo, TRANSLATE_NUMBER_TO_STRING | TRANSLATE_MEASURE );
1602
1603     exportAnimateKeyPoints( rStrm, xAnimate );
1604     exportAnimateTarget( rStrm, xNode );
1605 }
1606
1607 void AnimationExporter::exportAnimateTarget( SvStream& rStrm, const Reference< XAnimationNode >& xNode, const sal_uInt32 nForceAttributeNames, int nAfterEffectType )
1608 {
1609     EscherExContainer aAnimateTarget( rStrm, DFF_msofbtAnimateTarget, 0 );
1610     Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
1611     if ( !xAnimate.is() )
1612         return;
1613
1614     {
1615         EscherExAtom aAnimateTargetSettings( rStrm, DFF_msofbtAnimateTargetSettings, 0 );
1616         // nBits %0001: additive, %0010: accumulate, %0100: attributeName, %1000: transformtype
1617         // nAdditive 0 = base, 1 = sum, 2 = replace, 3 = multiply, 4 = none
1618         // nAccumulate 0 = none, 1 = always
1619         // nTransformType 0: "property" else "image"
1620         sal_uInt32 nBits = 0;
1621         sal_uInt32 nAdditive = 0;
1622         sal_uInt32 nAccumulate = 0;
1623         sal_uInt32 const nTransformType = 0;
1624         if ( xAnimate.is() )
1625         {
1626             if ( !xAnimate->getAttributeName().isEmpty() )
1627                 nBits |= 4;     // what is attributeName ?, maybe this is set if a DFF_msofbtAnimateAttributeNames is written
1628             sal_Int16 nAdditiveMode = xAnimate->getAdditive();
1629             if ( nAdditiveMode != AnimationAdditiveMode::BASE )
1630             {
1631                 nBits |= 1;
1632                 switch( nAdditiveMode )
1633                 {
1634                     case AnimationAdditiveMode::SUM : nAdditive = 1; break;
1635                     case AnimationAdditiveMode::REPLACE : nAdditive = 2; break;
1636                     case AnimationAdditiveMode::MULTIPLY : nAdditive = 3; break;
1637                     case AnimationAdditiveMode::NONE : nAdditive = 4; break;
1638                 }
1639             }
1640             if ( xAnimate->getAccumulate() )
1641             {
1642                 nBits  |= 2;
1643                 nAccumulate = 1;
1644             }
1645         }
1646         rStrm.WriteUInt32( nBits )
1647            .WriteUInt32( nAdditive )
1648            .WriteUInt32( nAccumulate )
1649            .WriteUInt32( nTransformType );
1650     }
1651     if ( !xAnimate->getAttributeName().isEmpty() || nForceAttributeNames )
1652     {
1653         EscherExContainer aAnimateAttributeNames( rStrm, DFF_msofbtAnimateAttributeNames, 1 );
1654         OUString aAttributeName( xAnimate->getAttributeName() );
1655         if ( nForceAttributeNames )
1656         {
1657             if( nForceAttributeNames == 1 )
1658             {
1659                 aAttributeName = "r";
1660             }
1661         }
1662         sal_Int32 nIndex = 0;
1663         do
1664         {
1665             OUString aToken( aAttributeName.getToken( 0, ';', nIndex ) );
1666             exportAnimPropertyString( rStrm, 0, aToken, TRANSLATE_ATTRIBUTE );
1667         }
1668         while ( nIndex >= 0 );
1669     }
1670
1671     if( nAfterEffectType != AFTEREFFECT_NONE )
1672     {
1673         EscherExContainer aAnimPropertySet( rStrm, DFF_msofbtAnimPropertySet );
1674         exportAnimPropertyuInt32( rStrm, 6, 1 );
1675         if( nAfterEffectType == AFTEREFFECT_COLOR )
1676         {
1677             exportAnimPropertyuInt32( rStrm, 4, 0 );
1678             exportAnimPropertyuInt32( rStrm, 5, 0 );
1679         }
1680     }
1681     exportAnimateTargetElement( rStrm, aTarget.hasValue() ? aTarget : xAnimate->getTarget(), false );
1682 }
1683
1684 Reference< XShape > AnimationExporter::getTargetElementShape( const Any& rAny, sal_Int32& rBegin, sal_Int32& rEnd, bool& rParagraphTarget )
1685 {
1686     Reference< XShape > xShape;
1687     rAny >>= xShape;
1688
1689     rParagraphTarget = false;
1690
1691     if( !xShape.is() )
1692     {
1693     ParagraphTarget aParaTarget;
1694     if( rAny >>= aParaTarget )
1695         xShape = aParaTarget.Shape;
1696     if ( xShape.is() )
1697     {
1698         // now calculating the character range for the paragraph
1699         sal_Int16 nParagraph = aParaTarget.Paragraph;
1700         Reference< XSimpleText > xText( xShape, UNO_QUERY );
1701         if ( xText.is() )
1702         {
1703         rParagraphTarget = true;
1704         Reference< XEnumerationAccess > xTextParagraphEnumerationAccess( xText, UNO_QUERY );
1705         if ( xTextParagraphEnumerationAccess.is() )
1706         {
1707             Reference< XEnumeration > xTextParagraphEnumeration( xTextParagraphEnumerationAccess->createEnumeration() );
1708             if ( xTextParagraphEnumeration.is() )
1709             {
1710             sal_Int16 nCurrentParagraph;
1711             rBegin = rEnd = nCurrentParagraph = 0;
1712             while ( xTextParagraphEnumeration->hasMoreElements() )
1713             {
1714                 Reference< XTextRange > xTextRange( xTextParagraphEnumeration->nextElement(), UNO_QUERY );
1715                 if ( xTextRange.is() )
1716                 {
1717                 OUString aParaText( xTextRange->getString() );
1718                 sal_Int32 nLength = aParaText.getLength() + 1;
1719                 rEnd += nLength;
1720                 if ( nCurrentParagraph == nParagraph )
1721                     break;
1722                 nCurrentParagraph++;
1723                 rBegin += nLength;
1724                 }
1725             }
1726             }
1727         }
1728         }
1729     }
1730     }
1731
1732     return xShape;
1733 }
1734
1735 void AnimationExporter::exportAnimateTargetElement( SvStream& rStrm, const Any& rAny, const bool bCreate2b01Atom )
1736 {
1737     sal_uInt32 nRefMode = 0;    // nRefMode == 2 -> Paragraph
1738     sal_Int32 begin = -1;
1739     sal_Int32 end = -1;
1740     bool bParagraphTarget;
1741
1742     Reference< XShape > xShape = getTargetElementShape(rAny, begin, end, bParagraphTarget);
1743
1744     if( bParagraphTarget )
1745         nRefMode = 2;
1746
1747     if ( !(xShape.is() || bCreate2b01Atom) )
1748         return;
1749
1750     EscherExContainer aAnimateTargetElement( rStrm, DFF_msofbtAnimateTargetElement );
1751     if ( xShape.is() )
1752     {
1753         EscherExAtom aAnimReference( rStrm, DFF_msofbtAnimReference );
1754
1755         sal_uInt32 const nRefType = 1;    // TODO: nRefType == 2 -> Sound;
1756         sal_uInt32 nRefId = mrSolverContainer.GetShapeId( xShape );
1757
1758         rStrm.WriteUInt32( nRefMode )
1759              .WriteUInt32( nRefType )
1760              .WriteUInt32( nRefId )
1761              .WriteInt32( begin )
1762              .WriteInt32( end );
1763     }
1764     if ( bCreate2b01Atom )
1765     {
1766         EscherExAtom a2b01Atom( rStrm, 0x2b01 );
1767         rStrm.WriteUInt32( 1 );     // ?
1768     }
1769 }
1770
1771 void AnimationExporter::exportAnimateKeyPoints( SvStream& rStrm, const Reference< XAnimate >& xAnimate )
1772 {
1773     Sequence< double > aKeyTimes( xAnimate->getKeyTimes() );
1774     Sequence< Any > aValues( xAnimate->getValues() );
1775     OUString aFormula( xAnimate->getFormula() );
1776     if ( !aKeyTimes.hasElements() )
1777         return;
1778
1779     EscherExContainer aAnimKeyPoints( rStrm, DFF_msofbtAnimKeyPoints );
1780     sal_Int32 i;
1781     for ( i = 0; i < aKeyTimes.getLength(); i++ )
1782     {
1783         {
1784             EscherExAtom aAnimKeyTime( rStrm, DFF_msofbtAnimKeyTime );
1785             sal_Int32 nKeyTime = static_cast<sal_Int32>( aKeyTimes[ i ] * 1000.0 );
1786             rStrm.WriteInt32( nKeyTime );
1787         }
1788         Any aAny[ 2 ];
1789         if ( aValues[ i ].hasValue() )
1790         {
1791             ValuePair aPair;
1792             if ( aValues[ i ] >>= aPair )
1793             {
1794                 aAny[ 0 ] = convertAnimateValue( aPair.First, xAnimate->getAttributeName() );
1795                 aAny[ 1 ] = convertAnimateValue( aPair.Second, xAnimate->getAttributeName() );
1796             }
1797             else
1798             {
1799                 aAny[ 0 ] = convertAnimateValue( aValues[ i ], xAnimate->getAttributeName() );
1800             }
1801             if ( !i && !aFormula.isEmpty() )
1802             {
1803                 ImplTranslateAttribute( aFormula, TRANSLATE_MEASURE );
1804                 aAny[ 1 ] <<= aFormula;
1805             }
1806             exportAnimProperty( rStrm, 0, aAny[ 0 ], TRANSLATE_NONE );
1807             exportAnimProperty( rStrm, 1, aAny[ 1 ], TRANSLATE_NONE );
1808         }
1809     }
1810 }
1811
1812 void AnimationExporter::exportAnimValue( SvStream& rStrm, const Reference< XAnimationNode >& xNode, const bool bExportAlways )
1813 {
1814     Any aAny;
1815     // repeat count (0)
1816     double fRepeat = 0.0;
1817     float fRepeatCount = 0.0;
1818     css::animations::Timing eTiming;
1819     aAny = xNode->getRepeatCount();
1820     if ( aAny >>= eTiming )
1821     {
1822         if ( eTiming == Timing_INDEFINITE )
1823             fRepeatCount = (float(3.40282346638528860e+38));
1824     }
1825     else if ( aAny >>= fRepeat )
1826         fRepeatCount = static_cast<float>(fRepeat);
1827     if ( fRepeatCount != 0.0 )
1828     {
1829         EscherExAtom aExAtom( rStrm, DFF_msofbtAnimValue );
1830         sal_uInt32 const nType = 0;
1831         rStrm.WriteUInt32( nType )
1832              .WriteFloat( fRepeatCount );
1833     }
1834     // accelerate (3)
1835     float fAccelerate = static_cast<float>(xNode->getAcceleration());
1836     if ( bExportAlways || ( fAccelerate != 0.0 ) )
1837     {
1838         EscherExAtom aExAtom( rStrm, DFF_msofbtAnimValue );
1839         sal_uInt32 const nType = 3;
1840         rStrm.WriteUInt32( nType )
1841              .WriteFloat( fAccelerate );
1842     }
1843
1844     // decelerate (4)
1845     float fDecelerate = static_cast<float>(xNode->getDecelerate());
1846     if ( bExportAlways || ( fDecelerate != 0.0 ) )
1847     {
1848         EscherExAtom aExAtom( rStrm, DFF_msofbtAnimValue );
1849         sal_uInt32 const nType = 4;
1850         rStrm.WriteUInt32( nType )
1851              .WriteFloat( fDecelerate );
1852     }
1853
1854     // autoreverse (5)
1855     bool bAutoReverse = xNode->getAutoReverse();
1856     if ( bExportAlways || bAutoReverse )
1857     {
1858         EscherExAtom aExAtom( rStrm, DFF_msofbtAnimValue );
1859         sal_uInt32 const nType = 5;
1860         sal_uInt32 nVal  = bAutoReverse ? 1 : 0;
1861         rStrm.WriteUInt32( nType )
1862              .WriteUInt32( nVal );
1863     }
1864 }
1865
1866 void AnimationExporter::exportTransitionFilter( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
1867 {
1868     Reference< XTransitionFilter > xFilter( xNode, UNO_QUERY );
1869     if ( !xFilter.is() )
1870         return;
1871
1872     EscherExContainer aAnimateFilter( rStrm, DFF_msofbtAnimateFilter );
1873     {
1874         EscherExAtom aAnimateFilterData( rStrm, DFF_msofbtAnimateFilterData );
1875         sal_uInt32 const nBits = 3;       // bit 0 -> use AnimAttributeValue
1876                                           // bit 1 -> use nTransition
1877
1878         sal_uInt32 nTransition = xFilter->getMode() ? 0 : 1;
1879         rStrm.WriteUInt32( nBits )
1880              .WriteUInt32( nTransition );
1881     }
1882     const sal_Char* pFilter = FindTransitionName( xFilter->getTransition(), xFilter->getSubtype(), xFilter->getDirection() );
1883     if ( pFilter )
1884     {
1885         const OUString aStr( OUString::createFromAscii( pFilter ) );
1886         exportAnimPropertyString( rStrm, 1, aStr, TRANSLATE_NONE );
1887     }
1888     exportAnimateTarget( rStrm, xNode );
1889 }
1890
1891 void AnimationExporter::exportAnimateMotion( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
1892 {
1893     Reference< XAnimateMotion > xMotion( xNode, UNO_QUERY );
1894     if ( !xMotion.is() )
1895         return;
1896
1897     EscherExContainer aAnimateMotion( rStrm, DFF_msofbtAnimateMotion );
1898     {
1899         {   //SJ: Ignored from import filter
1900             EscherExAtom aAnimateMotionData( rStrm, DFF_msofbtAnimateMotionData );
1901             sal_uInt32 const nBits = 0x98;
1902             sal_uInt32 const nOrigin = 0x2;
1903             float const fByX = 100.0; // nBits&1
1904             float const fByY = 100.0; // nBits&1
1905             float const fFromX = 0.0; // nBits&2
1906             float const fFromY = 0.0; // nBits&2
1907             float const fToX = 100.0; // nBits&4
1908             float const fToY = 100.0; // nBits&4
1909             rStrm.WriteUInt32( nBits ).WriteFloat( fByX ).WriteFloat( fByY ).WriteFloat( fFromX ).WriteFloat( fFromY ).WriteFloat( fToX ).WriteFloat( fToY ).WriteUInt32( nOrigin );
1910         }
1911
1912         OUString aStr;
1913         if ( xMotion->getPath() >>= aStr )
1914         {
1915             if ( !aStr.isEmpty() )
1916                 exportAnimPropertyString( rStrm, 1, aStr, TRANSLATE_NONE );
1917         }
1918         exportAnimateTarget( rStrm, xNode );
1919     }
1920 }
1921
1922 void AnimationExporter::exportAnimateTransform( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
1923 {
1924     Reference< XAnimateTransform > xTransform( xNode, UNO_QUERY );
1925     if ( !xTransform.is() )
1926         return;
1927
1928     if ( xTransform->getTransformType() ==  AnimationTransformType::SCALE )
1929     {
1930         EscherExContainer aAnimateScale( rStrm, DFF_msofbtAnimateScale );
1931         {
1932             EscherExAtom aAnimateScaleData( rStrm, DFF_msofbtAnimateScaleData );
1933             sal_uInt32 nBits = 0;
1934             sal_uInt32 const nZoomContents = 1;
1935             float fByX = 100.0;
1936             float fByY = 100.0;
1937             float fFromX = 0.0;
1938             float fFromY = 0.0;
1939             float fToX = 100.0;
1940             float fToY = 100.0;
1941
1942             double fX = 0.0, fY = 0.0;
1943             ValuePair aPair;
1944             if ( xTransform->getBy() >>= aPair )
1945             {
1946                 if ( ( aPair.First >>= fX ) && ( aPair.Second >>= fY ) )
1947                 {
1948                     nBits |= 1;
1949                     fByX = static_cast<float>( fX * 100 );
1950                     fByY = static_cast<float>( fY * 100 );
1951                 }
1952             }
1953             if ( xTransform->getFrom() >>= aPair )
1954             {
1955                 if ( ( aPair.First >>= fX ) && ( aPair.Second >>= fY ) )
1956                 {
1957                     nBits |= 2;
1958                     fFromX = static_cast<float>( fX * 100 );
1959                     fFromY = static_cast<float>( fY * 100 );
1960                 }
1961             }
1962             if( xTransform->getTo() >>= aPair )
1963             {
1964                 if ( ( aPair.First >>= fX ) && ( aPair.Second >>= fY ) )
1965                 {
1966                     nBits |= 4;
1967                     fToX = static_cast<float>( fX * 100 );
1968                     fToY = static_cast<float>( fY * 100 );
1969                 }
1970             }
1971
1972             // TODO: ZoomContents:
1973             //if( nBits & 8 )
1974             //( fprintf( mpFile, " zoomContents=\"%s\"", nZoomContents ? "true" : "false" );
1975
1976             rStrm.WriteUInt32( nBits ).WriteFloat( fByX ).WriteFloat( fByY ).WriteFloat( fFromX ).WriteFloat( fFromY ).WriteFloat( fToX ).WriteFloat( fToY ).WriteUInt32( nZoomContents );
1977         }
1978         exportAnimateTarget( rStrm, xNode );
1979     }
1980     else if ( xTransform->getTransformType() ==  AnimationTransformType::ROTATE )
1981     {
1982         EscherExContainer aAnimateRotation( rStrm, DFF_msofbtAnimateRotation );
1983         {
1984             EscherExAtom aAnimateRotationData( rStrm, DFF_msofbtAnimateRotationData );
1985             sal_uInt32 nBits = 0;
1986             sal_uInt32 const nU1 = 0;
1987             float fBy = 360.0;
1988             float fFrom = 0.0;
1989             float fTo = 360.0;
1990
1991             double fVal = 0.0;
1992             if ( xTransform->getBy() >>= fVal )
1993             {
1994                 nBits |= 1;
1995                 fBy = static_cast<float>(fVal);
1996             }
1997             if ( xTransform->getFrom() >>= fVal )
1998             {
1999                 nBits |= 2;
2000                 fFrom = static_cast<float>(fVal);
2001             }
2002             if ( xTransform->getTo() >>= fVal )
2003             {
2004                 nBits |= 4;
2005                 fTo = static_cast<float>(fVal);
2006             }
2007             rStrm.WriteUInt32( nBits ).WriteFloat( fBy ).WriteFloat( fFrom ).WriteFloat( fTo ).WriteUInt32( nU1 );
2008         }
2009         exportAnimateTarget( rStrm, xNode, 1 );
2010     }
2011 }
2012
2013 bool AnimationExporter::getColorAny( const Any& rAny, const sal_Int16 nColorSpace, sal_Int32& rMode, sal_Int32& rA, sal_Int32& rB, sal_Int32& rC )
2014 {
2015     bool bIsColor = true;
2016
2017     rMode = 0;
2018     if ( nColorSpace == AnimationColorSpace::HSL )
2019         rMode = 1;
2020
2021     sal_Int32 nColor = 0;
2022     Sequence< double > aHSL( 3 );
2023     if ( rAny >>= nColor )      // RGB color
2024     {
2025         rA = static_cast<sal_uInt8>( nColor >> 16 );
2026         rB = static_cast<sal_uInt8>( nColor >> 8 );
2027         rC = static_cast<sal_uInt8>(nColor);
2028     }
2029     else if ( rAny >>= aHSL )   // HSL
2030     {
2031         rA = static_cast<sal_Int32>( aHSL[ 0 ] * 255.0 / 360.0 );
2032         rB = static_cast<sal_Int32>( aHSL[ 1 ] * 255.0 );
2033         rC = static_cast<sal_Int32>( aHSL[ 2 ] * 255.0 );
2034     }
2035     else
2036         bIsColor = false;
2037     return bIsColor;
2038 }
2039
2040 void AnimationExporter::exportAnimateColor( SvStream& rStrm, const Reference< XAnimationNode >& xNode, int nAfterEffectType )
2041 {
2042     Reference< XAnimateColor > xColor( xNode, UNO_QUERY );
2043     if ( !xColor.is() )
2044         return;
2045
2046     EscherExContainer aAnimateColor( rStrm, DFF_msofbtAnimateColor );
2047     {
2048         EscherExAtom aAnimateColorData( rStrm, DFF_msofbtAnimateColorData );
2049         sal_uInt32 nBits = 8;
2050
2051         sal_Int32 nByMode, nByA, nByB, nByC;
2052         nByMode = nByA = nByB = nByC = 0;
2053
2054         sal_Int32 nFromMode, nFromA, nFromB, nFromC;
2055         nFromMode = nFromA = nFromB = nFromC = 0;
2056
2057         sal_Int32 nToMode, nToA, nToB, nToC;
2058         nToMode = nToA = nToB = nToC = 0;
2059
2060         sal_Int16 nColorSpace = xColor->getColorInterpolation();
2061
2062         Any aAny( xColor->getBy() );
2063         if ( aAny.hasValue() )
2064         {
2065             if ( getColorAny( aAny, nColorSpace, nByMode, nByA, nByB, nByC ) )
2066                 nBits |= 0x11;
2067         }
2068         aAny = xColor->getFrom();
2069         if ( aAny.hasValue() )
2070         {
2071             if ( getColorAny( aAny, nColorSpace, nFromMode, nFromA, nFromB, nFromC ) )
2072                 nBits |= 0x12;
2073         }
2074         aAny = xColor->getTo();
2075         if ( aAny.hasValue() )
2076         {
2077             if ( getColorAny( aAny, nColorSpace, nToMode, nToA, nToB, nToC ) )
2078                 nBits |= 0x14;
2079         }
2080         rStrm  .WriteUInt32( nBits )
2081                .WriteInt32( nByMode ).WriteInt32( nByA ).WriteInt32( nByB ).WriteInt32( nByC )
2082                .WriteInt32( nFromMode ).WriteInt32( nFromA ).WriteInt32( nFromB ).WriteInt32( nFromC )
2083                .WriteInt32( nToMode ).WriteInt32( nToA ).WriteInt32( nToB ).WriteInt32( nToC );
2084     }
2085     exportAnimateTarget( rStrm, xNode, 0, nAfterEffectType );
2086 }
2087
2088 void AnimationExporter::exportIterate( SvStream& rStrm, const Reference< XAnimationNode >& xNode )
2089 {
2090     Reference< XIterateContainer > xIterate( xNode, UNO_QUERY );
2091     if ( !xIterate.is() )
2092         return;
2093
2094     EscherExAtom aAnimIteration( rStrm, DFF_msofbtAnimIteration );
2095
2096     float       fInterval = 10.0;
2097     sal_Int32   nTextUnitEffect = 0;
2098     sal_Int32 const nU1 = 1;
2099     sal_Int32 const nU2 = 1;
2100     sal_Int32 const nU3 = 0xe;
2101
2102     sal_Int16 nIterateType = xIterate->getIterateType();
2103     switch( nIterateType )
2104     {
2105         case TextAnimationType::BY_WORD : nTextUnitEffect = 1; break;
2106         case TextAnimationType::BY_LETTER : nTextUnitEffect = 2; break;
2107     }
2108
2109     fInterval = static_cast<float>(xIterate->getIterateInterval());
2110
2111     // convert interval from absolute to percentage
2112     double fDuration = 0.0;
2113
2114     Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY );
2115     if( xEnumerationAccess.is() )
2116     {
2117         Reference< XEnumeration > xEnumeration = xEnumerationAccess->createEnumeration();
2118         if( xEnumeration.is() )
2119         {
2120             while( xEnumeration->hasMoreElements() )
2121             {
2122                 Reference< XAnimate > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
2123                 if( xChildNode.is() )
2124                 {
2125                     double fChildBegin = 0.0;
2126                     double fChildDuration = 0.0;
2127                     xChildNode->getBegin() >>= fChildBegin;
2128                     xChildNode->getDuration() >>= fChildDuration;
2129
2130                     fChildDuration += fChildBegin;
2131                     if( fChildDuration > fDuration )
2132                         fDuration = fChildDuration;
2133                 }
2134             }
2135         }
2136     }
2137
2138     if( fDuration )
2139         fInterval = static_cast<float>(100.0 * fInterval / fDuration);
2140
2141     rStrm.WriteFloat( fInterval ).WriteInt32( nTextUnitEffect ).WriteInt32( nU1 ).WriteInt32( nU2 ).WriteInt32( nU3 );
2142     aTarget = xIterate->getTarget();
2143 }
2144
2145 } // namespace ppt;
2146
2147 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */