oox/source/ppt/timenode.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: timenode.cxx,v $
  10  * $Revision: 1.4.6.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "oox/ppt/timenode.hxx"
  32
  33 #include <boost/bind.hpp>
  34
  35 #include <com/sun/star/beans/XPropertySet.hpp>
  36 #include <com/sun/star/beans/NamedValue.hpp>
  37 #include <com/sun/star/container/XEnumerationAccess.hpp>
  38 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  39 #include <com/sun/star/frame/XModel.hpp>
  40 #include <com/sun/star/animations/XAnimateColor.hpp>
  41 #include <com/sun/star/animations/XAnimateMotion.hpp>
  42 #include <com/sun/star/animations/XAnimateTransform.hpp>
  43 #include <com/sun/star/animations/XCommand.hpp>
  44 #include <com/sun/star/animations/XIterateContainer.hpp>
  45 #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
  46 #include <com/sun/star/animations/XTimeContainer.hpp>
  47 #include <com/sun/star/animations/AnimationNodeType.hpp>
  48 #include <com/sun/star/animations/Event.hpp>
  49 #include <com/sun/star/animations/EventTrigger.hpp>
  50 #include <com/sun/star/presentation/EffectNodeType.hpp>
  51
  52 #include "oox/helper/helper.hxx"
  53 #include "oox/core/xmlfilterbase.hxx"
  54
  55 using ::rtl::OUString;
  56 using namespace ::oox::core;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::container;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::lang;
  61 using namespace ::com::sun::star::animations;
  62 using namespace ::com::sun::star::frame;
  63 using namespace ::com::sun::star::presentation;
  64
  65 namespace oox { namespace ppt {
  66
  67         OUString TimeNode::getServiceName( sal_Int16 nNodeType )
  68         {
  69             OUString sServiceName;
  70             switch( nNodeType )
  71             {
  72             case AnimationNodeType::PAR:
  73 //                              sServiceName = CREATE_OUSTRING("com.sun.star.animations.IterateContainer");
  74                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.ParallelTimeContainer");
  75                 break;
  76             case AnimationNodeType::SEQ:
  77                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.SequenceTimeContainer");
  78                 break;
  79             case AnimationNodeType::ANIMATE:
  80                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.Animate");
  81                 break;
  82             case AnimationNodeType::ANIMATECOLOR:
  83                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateColor");
  84                 break;
  85             case AnimationNodeType::TRANSITIONFILTER:
  86                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.TransitionFilter");
  87                 break;
  88             case AnimationNodeType::ANIMATEMOTION:
  89                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateMotion");
  90                 break;
  91             case AnimationNodeType::ANIMATETRANSFORM:
  92                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateTransform");
  93                 break;
  94             case AnimationNodeType::COMMAND:
  95                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.Command");
  96                 break;
  97             case AnimationNodeType::SET:
  98                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.AnimateSet");
  99                 break;
 100             case AnimationNodeType::AUDIO:
 101                 sServiceName = CREATE_OUSTRING("com.sun.star.animations.Audio");
 102                 break;
 103             default:
 104                 OSL_TRACE( "OOX: uhandled type %x", nNodeType );
 105                 break;
 106             }
 107             return sServiceName;
 108         }
 109
 110
 111
 112     TimeNode::TimeNode( sal_Int16 nNodeType )
 113         : mnNodeType( nNodeType )
 114         , mbHasEndSyncValue( false )
 115     {
 116     }
 117
 118
 119     TimeNode::~TimeNode()
 120     {
 121     }
 122
 123 // BEGIN CUT&PASTE from sd/source/filter/ppt/pptinanimations.hxx
 124 // --------------------------------------------------------------------
 125     static void fixMainSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
 126     {
 127         try
 128         {
 129             bool bFirst = true;
 130             Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
 131             Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
 132             while( xE->hasMoreElements() )
 133             {
 134                 // click node
 135                 Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
 136
 137                 Event aEvent;
 138                 aEvent.Trigger = EventTrigger::ON_NEXT;
 139                 aEvent.Repeat = 0;
 140                 xClickNode->setBegin( makeAny( aEvent ) );
 141
 142                 if( bFirst )
 143                 {
 144                     bFirst = false;
 145                     Reference< XEnumerationAccess > xEA2( xClickNode, UNO_QUERY_THROW );
 146                     Reference< XEnumeration > xE2( xEA2->createEnumeration(), UNO_QUERY_THROW );
 147                     if( xE2->hasMoreElements() )
 148                     {
 149                         // with node
 150                         xE2->nextElement() >>= xEA2;
 151                         if( xEA2.is() )
 152                             xE2.query( xEA2->createEnumeration() );
 153                         else
 154                             xE2.clear();
 155
 156                         if( xE2.is() && xE2->hasMoreElements() )
 157                         {
 158                             Reference< XAnimationNode > xEffectNode( xE2->nextElement(), UNO_QUERY_THROW );
 159                             const Sequence< NamedValue > aUserData( xEffectNode->getUserData() );
 160                             const NamedValue* p = aUserData.getConstArray();
 161                             sal_Int32 nLength = aUserData.getLength();
 162                             while( nLength-- )
 163                             {
 164                                 if( p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "node-type" ) ) )
 165                                 {
 166                                     sal_Int16 nNodeType = 0;
 167                                     p->Value >>= nNodeType;
 168                                     if( nNodeType != ::com::sun::star::presentation::EffectNodeType::ON_CLICK )
 169                                     {
 170                                         // first effect does not start on click, so correct
 171                                         // first click nodes begin to 0s
 172                                         xClickNode->setBegin( makeAny( (double)0.0 ) );
 173                                         break;
 174                                     }
 175                                 }
 176                                 p++;
 177                             }
 178                         }
 179                     }
 180                 }
 181             }
 182         }
 183         catch( Exception& e )
 184         {
 185             (void)e;
 186             OSL_TRACE("fixMainSequenceTiming(), exception caught!" );
 187         }
 188     }
 189
 190 // --------------------------------------------------------------------
 191
 192     static void fixInteractiveSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
 193     {
 194         try
 195         {
 196             Any aBegin( xNode->getBegin() );
 197             Any aEmpty;
 198             xNode->setBegin( aEmpty );
 199
 200             Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
 201             Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
 202             while( xE->hasMoreElements() )
 203             {
 204                 // click node
 205                 Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
 206                 xClickNode->setBegin( aBegin );
 207             }
 208         }
 209         catch( Exception& e )
 210         {
 211             (void)e;
 212             OSL_TRACE("fixInteractiveSequenceTiming(), exception caught!" );
 213         }
 214     }
 215
 216 // END CUT&PASTE
 217
 218     void TimeNode::addNode( const XmlFilterBase& rFilter, const Reference< XAnimationNode >& rxNode, const SlidePersistPtr & pSlide )
 219     {
 220         try {
 221             OUString sServiceName = getServiceName( mnNodeType );
 222             Reference< XAnimationNode > xNode = createAndInsert( rFilter, sServiceName, rxNode );
 223             setNode( rFilter, xNode, pSlide );
 224         }
 225         catch( const Exception& e )
 226         {
 227             OSL_TRACE( "OOX: exception raised in TimeNode::addNode() - %s",
 228                                  OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
 229         }
 230     }
 231
 232     void TimeNode::setNode( const XmlFilterBase& rFilter, const Reference< XAnimationNode >& xNode, const SlidePersistPtr & pSlide )
 233     {
 234         OSL_ENSURE( xNode.is(), "null node passed" );
 235
 236         try {
 237             if( msId.getLength() )
 238             {
 239                 pSlide->getAnimNodesMap()[ msId ] = xNode;
 240             }
 241
 242             if( mpTarget )
 243             {
 244                 sal_Int16 nSubType;
 245                 maNodeProperties[ NP_TARGET ] = mpTarget->convert( pSlide, nSubType );
 246                 if( mpTarget->mnType == XML_spTgt )
 247                 {
 248                     maNodeProperties[ NP_SUBITEM ] <<= nSubType;
 249                 }
 250             }
 251
 252             if( !maStCondList.empty() )
 253             {
 254                 Any aAny = AnimationCondition::convertList( pSlide, maStCondList );
 255                  if( aAny.hasValue() )
 256                 {
 257                     xNode->setBegin( aAny );
 258                 }
 259
 260             }
 261             if( !maEndCondList.empty() )
 262             {
 263                 Any aAny = AnimationCondition::convertList( pSlide, maEndCondList );
 264                 if( aAny.hasValue() )
 265                 {
 266                     xNode->setEnd( aAny );
 267                 }
 268             }
 269 #if 0  // FIXME even the binary filter has this disabled.
 270             if( !maNextCondList.empty() )
 271             {
 272                 Any aAny = AnimationCondition::convertList( pSlide, maNextCondList );
 273                 if( aAny.hasValue() )
 274                 {
 275                     xNode->setNext( aAny );
 276                 }
 277             }
 278             if( !maPrevCondList.empty() )
 279             {
 280                 Any aAny = AnimationCondition::convertList( pSlide, maPrevCondList );
 281                 if( aAny.hasValue() )
 282                 {
 283                     xNode->setPrev( aAny );
 284                 }
 285             }
 286 #endif
 287             if( mbHasEndSyncValue )
 288             {
 289                 Any aValue = maEndSyncValue.convert( pSlide );
 290                 xNode->setEndSync(aValue);
 291             }
 292
 293             if( !maUserData.empty() )
 294             {
 295                 Sequence< NamedValue > aUserDataSeq( static_cast< sal_Int32 >( maUserData.size() ) );
 296                 NamedValue* pValues = aUserDataSeq.getArray();
 297                 for( UserDataMap::const_iterator aIt = maUserData.begin(), aEnd = maUserData.end(); aIt != aEnd; ++aIt, ++pValues )
 298                 {
 299                     pValues->Name = aIt->first;
 300                     pValues->Value = aIt->second;
 301                 }
 302                 maNodeProperties[ NP_USERDATA ] <<= aUserDataSeq;
 303             }
 304
 305             Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
 306             Reference< XAnimateColor > xAnimateColor( xNode, UNO_QUERY );
 307             Reference< XAnimateMotion > xAnimateMotion( xNode, UNO_QUERY );
 308             Reference< XAnimateTransform > xAnimateTransform( xNode, UNO_QUERY );
 309             Reference< XCommand > xCommand( xNode, UNO_QUERY );
 310             Reference< XIterateContainer > xIterateContainer( xNode, UNO_QUERY );
 311             sal_Int16 nInt16 = 0;
 312             sal_Bool bBool = sal_False;
 313             double fDouble = 0;
 314             OUString sString;
 315             Sequence< NamedValue > aSeq;
 316
 317             for( int i = 0; i < _NP_SIZE; i++)
 318             {
 319                 Any & aValue( maNodeProperties[ i ] );
 320                 if( aValue.hasValue() )
 321                 {
 322                     switch( i )
 323                     {
 324                     case NP_TO:
 325                         if( xAnimate.is() )
 326                             xAnimate->setTo( aValue );
 327                         break;
 328                     case NP_FROM:
 329                         if( xAnimate.is() )
 330                             xAnimate->setFrom( aValue );
 331                         break;
 332                     case NP_BY:
 333                         if( xAnimate.is() )
 334                             xAnimate->setBy( aValue );
 335                         break;
 336                     case NP_TARGET:
 337                         if( xAnimate.is() )
 338                             xAnimate->setTarget( aValue );
 339                         break;
 340                     case NP_SUBITEM:
 341                         if( xAnimate.is() )
 342                         {
 343                             if( aValue >>= nInt16 )
 344                                 xAnimate->setSubItem( nInt16 );
 345                             else
 346                             {
 347                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 348                             }
 349                         }
 350                         break;
 351                     case NP_ATTRIBUTENAME:
 352                         if( xAnimate.is() )
 353                         {
 354                             if( aValue >>= sString )
 355                                 xAnimate->setAttributeName( sString );
 356                             else
 357                             {
 358                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 359                             }
 360                         }
 361                         break;
 362                     case NP_CALCMODE:
 363                         if( xAnimate.is() )
 364                         {
 365                             if( aValue >>= nInt16 )
 366                                 xAnimate->setCalcMode( nInt16 );
 367                             else
 368                             {
 369                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 370                             }
 371                         }
 372                         break;
 373                     case NP_KEYTIMES:
 374                         if( xAnimate.is() )
 375                         {
 376                             Sequence<double> aKeyTimes;
 377                             if( aValue >>= aKeyTimes )
 378                                 xAnimate->setKeyTimes(aKeyTimes);
 379                             else
 380                             {
 381                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 382                             }
 383                         }
 384                         break;
 385                     case NP_VALUES:
 386                         if( xAnimate.is() )
 387                         {
 388                             Sequence<Any> aValues;
 389                             if( aValue >>= aValues )
 390                                 xAnimate->setValues(aValues);
 391                             else
 392                             {
 393                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 394                             }
 395                         }
 396                         break;
 397                     case NP_FORMULA:
 398                         if( xAnimate.is() )
 399                         {
 400                             if( aValue >>= sString )
 401                                 xAnimate->setFormula(sString);
 402                             else
 403                             {
 404                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 405                             }
 406                         }
 407                         break;
 408                     case NP_COLORINTERPOLATION:
 409                         if( xAnimateColor.is() )
 410                         {
 411                             if( aValue >>= nInt16 )
 412                                 xAnimateColor->setColorInterpolation( nInt16 );
 413                             else
 414                             {
 415                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 416                             }
 417                         }
 418                         break;
 419                     case NP_DIRECTION:
 420                         if( xAnimateColor.is() )
 421                         {
 422                             if( aValue >>= bBool )
 423                                 xAnimateColor->setDirection( bBool );
 424                             else
 425                             {
 426                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 427                             }
 428                         }
 429                         break;
 430                     case NP_PATH:
 431                         if( xAnimateMotion.is() )
 432                             xAnimateMotion->setPath( aValue );
 433                         break;
 434                     case NP_TRANSFORMTYPE:
 435                         if( xAnimateTransform.is() )
 436                         {
 437                             if( aValue >>= nInt16 )
 438                                 xAnimateTransform->setTransformType( nInt16 );
 439                             else
 440                             {
 441                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 442                             }
 443                         }
 444                         break;
 445                     case NP_USERDATA:
 446                         if( aValue >>= aSeq )
 447                             xNode->setUserData( aSeq );
 448                         else
 449                         {
 450                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 451                         }
 452                         break;
 453                     case NP_ACCELERATION:
 454                         if( aValue >>= fDouble )
 455                             xNode->setAcceleration( fDouble );
 456                         else
 457                         {
 458                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 459                         }
 460                         break;
 461                     case NP_DECELERATE:
 462                         if( aValue >>= fDouble )
 463                             xNode->setDecelerate( fDouble );
 464                         else
 465                         {
 466                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 467                         }
 468                         break;
 469                     case NP_AUTOREVERSE:
 470                         if( aValue >>= bBool )
 471                             xNode->setAutoReverse( bBool );
 472                         else
 473                         {
 474                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 475                         }
 476                         break;
 477                     case NP_DURATION:
 478                         xNode->setDuration( aValue );
 479                         break;
 480                     case NP_FILL:
 481                         if( aValue >>= nInt16 )
 482                             xNode->setFill( nInt16 );
 483                         else
 484                         {
 485                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 486                         }
 487                         break;
 488                     case NP_REPEATCOUNT:
 489                         xNode->setRepeatCount( aValue );
 490                         break;
 491                     case NP_REPEATDURATION:
 492                         xNode->setRepeatDuration( aValue );
 493                         break;
 494                     case NP_RESTART:
 495                         if( aValue >>= nInt16 )
 496                             xNode->setRestart( nInt16 );
 497                         else
 498                         {
 499                             OSL_TRACE( "any >>= failed %d", __LINE__ );
 500                         }
 501                         break;
 502                     case NP_COMMAND:
 503                         if( xCommand.is() )
 504                         {
 505                             if( aValue >>= nInt16 )
 506                                 xCommand->setCommand( nInt16 );
 507                             else
 508                             {
 509                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 510                             }
 511                         }
 512                         break;
 513                     case NP_PARAMETER:
 514                         if( xCommand.is() )
 515                             xCommand->setParameter( aValue );
 516                         break;
 517                     case NP_ITERATETYPE:
 518                         if( xIterateContainer.is() )
 519                         {
 520                             if( aValue >>= nInt16 )
 521                                 xIterateContainer->setIterateType( nInt16 );
 522                             else
 523                             {
 524                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 525                             }
 526                         }
 527                         break;
 528                     case NP_ITERATEINTERVAL:
 529                         if( xIterateContainer.is() )
 530                         {
 531                             if( aValue >>= fDouble )
 532                                 xIterateContainer->setIterateInterval( fDouble );
 533                             else
 534                             {
 535                                 OSL_TRACE( "any >>= failed %d", __LINE__ );
 536                             }
 537                         }
 538                         break;
 539                     default:
 540                         OSL_TRACE( "ERR-OOX: unknown prop index %d", i );
 541                         break;
 542                     }
 543                 }
 544             }
 545
 546             if( mnNodeType == AnimationNodeType::TRANSITIONFILTER )
 547             {
 548
 549                 Reference< XTransitionFilter > xFilter( xNode, UNO_QUERY );
 550                 maTransitionFilter.setTransitionFilterProperties( xFilter );
 551             }
 552
 553             std::for_each( maChildren.begin(), maChildren.end(),
 554                            boost::bind(&TimeNode::addNode, _1, boost::cref(rFilter), boost::ref(xNode),
 555                                        boost::ref(pSlide) ) );
 556
 557             switch( mnNodeType )
 558             {
 559             case AnimationNodeType::SEQ:
 560             {
 561                 sal_Int16 nEnum = 0;
 562                 if( maUserData[ CREATE_OUSTRING( "node-type" ) ] >>= nEnum )
 563                 {
 564                     if( nEnum == EffectNodeType::MAIN_SEQUENCE )
 565                     {
 566                         fixMainSequenceTiming( xNode );
 567                     }
 568                     else if( nEnum ==  EffectNodeType::INTERACTIVE_SEQUENCE )
 569                     {
 570                         fixInteractiveSequenceTiming( xNode );
 571                     }
 572                 }
 573                 break;
 574             }
 575             case AnimationNodeType::PAR:
 576                 // some other cut&paste... from AnimationImporter::importAnimationContainer()
 577                 break;
 578             }
 579         }
 580         catch( const Exception& e )
 581         {
 582             OSL_TRACE( "OOX: exception raised in TimeNode::setNode() - %s",
 583                                  OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
 584         }
 585     }
 586
 587
 588     Reference< XAnimationNode > TimeNode::createAndInsert(
 589             const XmlFilterBase& rFilter,
 590             const OUString& rServiceName,
 591             const Reference< XAnimationNode >& rxNode )
 592     {
 593         try {
 594             Reference< XAnimationNode > xNode ( rFilter.getGlobalFactory()->createInstance(rServiceName ), UNO_QUERY_THROW );
 595             Reference< XTimeContainer > xParentContainer( rxNode, UNO_QUERY_THROW );
 596
 597             xParentContainer->appendChild( xNode );
 598             return xNode;
 599         }
 600         catch( const Exception& e )
 601         {
 602             OSL_TRACE( "OOX: exception raised in TimeNode::createAndInsert() trying to create a service %s = %s",
 603                                  OUStringToOString( rServiceName, RTL_TEXTENCODING_ASCII_US ).getStr(),
 604                                  OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
 605         }
 606
 607         return Reference< XAnimationNode >();
 608     }
 609
 610
 611     void        TimeNode::setId( sal_Int32 nId )
 612     {
 613         msId = OUString::valueOf(nId);
 614     }
 615
 616     void TimeNode::setTo( const Any & aTo )
 617     {
 618         maNodeProperties[ NP_TO ] = aTo;
 619     }
 620
 621
 622     void TimeNode::setFrom( const Any & aFrom )
 623     {
 624         maNodeProperties[ NP_FROM ] = aFrom;
 625     }
 626
 627     void TimeNode::setBy( const Any & aBy )
 628     {
 629         maNodeProperties[ NP_BY ] = aBy;
 630     }
 631
 632
 633 } }