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