oox/source/ppt/timenodelistcontext.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: timenodelistcontext.cxx,v $
  10  * $Revision: 1.4.20.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/timenodelistcontext.hxx"
  32
  33 #include "comphelper/anytostring.hxx"
  34 #include "cppuhelper/exc_hlp.hxx"
  35 #include <osl/diagnose.h>
  36 #include <rtl/math.hxx>
  37
  38 #include <com/sun/star/animations/XTimeContainer.hpp>
  39 #include <com/sun/star/animations/XAnimationNode.hpp>
  40 #include <com/sun/star/animations/XAnimateColor.hpp>
  41 #include <com/sun/star/animations/XAnimateSet.hpp>
  42 #include <com/sun/star/animations/XAnimateTransform.hpp>
  43 #include <com/sun/star/animations/AnimationTransformType.hpp>
  44 #include <com/sun/star/animations/AnimationCalcMode.hpp>
  45 #include <com/sun/star/animations/AnimationColorSpace.hpp>
  46 #include <com/sun/star/animations/AnimationNodeType.hpp>
  47 #include <com/sun/star/animations/XCommand.hpp>
  48 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  49 #include <com/sun/star/presentation/EffectCommands.hpp>
  50 #include <com/sun/star/beans/NamedValue.hpp>
  51
  52 #include "oox/helper/attributelist.hxx"
  53 #include "oox/core/namespaces.hxx"
  54 #include "oox/core/xmlfilterbase.hxx"
  55 #include "oox/drawingml/drawingmltypes.hxx"
  56 #include "oox/drawingml/colorchoicecontext.hxx"
  57 #include "oox/ppt/slidetransition.hxx"
  58 #include "tokens.hxx"
  59
  60 #include "animvariantcontext.hxx"
  61 #include "commonbehaviorcontext.hxx"
  62 #include "conditioncontext.hxx"
  63 #include "commontimenodecontext.hxx"
  64 #include "timeanimvaluecontext.hxx"
  65 #include "animationtypes.hxx"
  66
  67 using namespace ::oox::core;
  68 using namespace ::oox::drawingml;
  69 using namespace ::com::sun::star::uno;
  70 using namespace ::com::sun::star::lang;
  71 using namespace ::com::sun::star::animations;
  72 using namespace ::com::sun::star::presentation;
  73 using namespace ::com::sun::star::xml::sax;
  74 using namespace ::com::sun::star::awt;
  75 using ::com::sun::star::beans::NamedValue;
  76
  77 using ::rtl::OUString;
  78
  79 namespace oox { namespace ppt {
  80
  81     struct AnimColor
  82     {
  83         AnimColor(sal_Int16 cs, sal_Int32 o, sal_Int32 t, sal_Int32 th )
  84             : colorSpace( cs ), one( o ), two( t ), three( th )
  85             {
  86             }
  87
  88         sal_Int32 get()
  89             {
  90                 sal_Int32 nColor;
  91
  92                 switch( colorSpace )
  93                 {
  94                 case AnimationColorSpace::HSL:
  95                     nColor = ( ( ( one * 128 ) / 360 ) & 0xff ) << 16
  96                         | ( ( ( two * 128 ) / 1000 ) & 0xff ) << 8
  97                         | ( ( ( three * 128 ) / 1000 )  & 0xff );
  98                     break;
  99                 case AnimationColorSpace::RGB:
 100                     nColor = ( ( ( one * 128 ) / 1000 ) & 0xff ) << 16
 101                         | ( ( ( two * 128 ) / 1000 ) & 0xff ) << 8
 102                         | ( ( ( three * 128 ) / 1000 )  & 0xff );
 103                     break;
 104                 default:
 105                     nColor = 0;
 106                     break;
 107                 }
 108                 return  nColor;
 109             }
 110
 111         sal_Int16 colorSpace;
 112         sal_Int32 one;
 113         sal_Int32 two;
 114         sal_Int32 three;
 115     };
 116
 117
 118     /** CT_TLMediaNodeAudio
 119             CT_TLMediaNodeVideo */
 120     class MediaNodeContext
 121         : public TimeNodeContext
 122     {
 123     public:
 124         MediaNodeContext( ContextHandler& rParent, sal_Int32  aElement,
 125                             const Reference< XFastAttributeList >& xAttribs,
 126                             const TimeNodePtr & pNode )
 127             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 128                 , mbIsNarration( false )
 129                 , mbFullScrn( false )
 130             {
 131                 AttributeList attribs( xAttribs );
 132
 133                 switch( aElement )
 134                 {
 135                 case NMSP_PPT|XML_audio:
 136                     mbIsNarration = attribs.getBool( XML_isNarration, false );
 137                     break;
 138                 case NMSP_PPT|XML_video:
 139                     mbFullScrn = attribs.getBool( XML_fullScrn, false );
 140                     break;
 141                 default:
 142                     break;
 143                 }
 144             }
 145
 146         virtual void SAL_CALL endFastElement( sal_Int32 aElement )
 147             throw ( SAXException, RuntimeException)
 148             {
 149                 if( aElement == ( NMSP_PPT|XML_audio ) )
 150                 {
 151                     // TODO deal with mbIsNarration
 152                 }
 153                 else if( aElement == ( NMSP_PPT|XML_video ) )
 154                 {
 155                     // TODO deal with mbFullScrn
 156                 }
 157             }
 158
 159         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 160                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 161             throw ( SAXException, RuntimeException )
 162             {
 163                 Reference< XFastContextHandler > xRet;
 164
 165                 switch ( aElementToken )
 166                 {
 167                 case NMSP_PPT|XML_cBhvr:
 168                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 169                     break;
 170                 default:
 171                     break;
 172                 }
 173
 174                 if( !xRet.is() )
 175                     xRet.set( this );
 176
 177                 return xRet;
 178             }
 179
 180     private:
 181         bool mbIsNarration;
 182         bool mbFullScrn;
 183     };
 184
 185
 186     /** CT_TLSetBehavior
 187      */
 188     class SetTimeNodeContext
 189         : public TimeNodeContext
 190     {
 191     public:
 192         SetTimeNodeContext( ContextHandler& rParent, sal_Int32  aElement,
 193                             const Reference< XFastAttributeList >& xAttribs,
 194                             const TimeNodePtr & pNode )
 195             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 196             {
 197
 198             }
 199
 200         ~SetTimeNodeContext() throw ()
 201             {
 202                 if( maTo.hasValue() )
 203                 {
 204                     // TODO
 205                     // HACK !!! discard and refactor
 206                     OUString aString;
 207                     if( maTo >>= aString )
 208                     {
 209                         OSL_TRACE( "Magic conversion %s", OUSTRING_TO_CSTR( aString ) );
 210                         maTo = makeAny( aString.equalsAscii( "visible" ) ? sal_True : sal_False );
 211                         if( !maTo.has<sal_Bool>() )
 212                             OSL_TRACE( "conversion failed" );
 213                     }
 214                     mpNode->setTo( maTo );
 215                 }
 216
 217             }
 218
 219         virtual void SAL_CALL endFastElement( sal_Int32 /*aElement*/ )
 220             throw ( SAXException, RuntimeException)
 221             {
 222             }
 223
 224
 225         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 226                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 227             throw ( SAXException, RuntimeException )
 228             {
 229                 Reference< XFastContextHandler > xRet;
 230
 231                 switch ( aElementToken )
 232                 {
 233                 case NMSP_PPT|XML_cBhvr:
 234                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 235                     break;
 236                 case NMSP_PPT|XML_to:
 237                     // CT_TLAnimVariant
 238                     xRet.set( new AnimVariantContext( *this, aElementToken, maTo ) );
 239                     break;
 240                 default:
 241                     break;
 242                 }
 243
 244                 if( !xRet.is() )
 245                     xRet.set( this );
 246
 247                 return xRet;
 248             }
 249     private:
 250         Any  maTo;
 251     };
 252
 253     /** CT_TLCommandBehavior
 254      */
 255     class CmdTimeNodeContext
 256         : public TimeNodeContext
 257     {
 258     public:
 259         CmdTimeNodeContext( ContextHandler& rParent, sal_Int32  aElement,
 260                             const Reference< XFastAttributeList >& xAttribs,
 261                             const TimeNodePtr & pNode )
 262             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 263                 , maType(0)
 264             {
 265                 switch ( aElement )
 266                 {
 267                 case NMSP_PPT|XML_cmd:
 268                     msCommand = xAttribs->getOptionalValue( XML_cmd );
 269                     maType = xAttribs->getOptionalValueToken( XML_type, 0 );
 270                     break;
 271                 default:
 272                     break;
 273                 }
 274             }
 275
 276         ~CmdTimeNodeContext() throw ()
 277             {
 278             }
 279
 280         virtual void SAL_CALL endFastElement( sal_Int32 aElement )
 281             throw ( SAXException, RuntimeException)
 282             {
 283                 if( aElement == ( NMSP_PPT|XML_cmd ) )
 284                 {
 285                     try {
 286                         // see sd/source/filter/ppt/pptinanimations.cxx
 287                         // in AnimationImporter::importCommandContainer()
 288                         // REFACTOR?
 289                         // a good chunk of this code has been copied verbatim *sigh*
 290                         sal_Int16 nCommand = EffectCommands::CUSTOM;
 291                         NamedValue aParamValue;
 292
 293                         switch( maType )
 294                         {
 295                         case XML_verb:
 296                             aParamValue.Name = OUString(RTL_CONSTASCII_USTRINGPARAM("Verb"));
 297                             // TODO make sure msCommand has what we want
 298                             aParamValue.Value <<= msCommand.toInt32();
 299                             nCommand = EffectCommands::VERB;
 300                             break;
 301                         case XML_evt:
 302                         case XML_call:
 303                             if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "onstopaudio" ) ) )
 304                             {
 305                                 nCommand = EffectCommands::STOPAUDIO;
 306                             }
 307                             else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("play") ) )
 308                             {
 309                                 nCommand = EffectCommands::PLAY;
 310                             }
 311                             else if( msCommand.compareToAscii( RTL_CONSTASCII_STRINGPARAM("playFrom") ) == 0 )
 312                             {
 313                                 const OUString aMediaTime( msCommand.copy( 9, msCommand.getLength() - 10 ) );
 314                                 rtl_math_ConversionStatus eStatus;
 315                                 double fMediaTime = ::rtl::math::stringToDouble( aMediaTime, (sal_Unicode)('.'), (sal_Unicode)(','), &eStatus, NULL );
 316                                 if( eStatus == rtl_math_ConversionStatus_Ok )
 317                                 {
 318                                     aParamValue.Name = CREATE_OUSTRING("MediaTime");
 319                                     aParamValue.Value <<= fMediaTime;
 320                                 }
 321                                 nCommand = EffectCommands::PLAY;
 322                             }
 323                             else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("togglePause") ) )
 324                             {
 325                                 nCommand = EffectCommands::TOGGLEPAUSE;
 326                             }
 327                             else if( msCommand.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("stop") ) )
 328                             {
 329                                 nCommand = EffectCommands::STOP;
 330                             }
 331                             break;
 332                         }
 333                         mpNode->getNodeProperties()[ NP_COMMAND ] = makeAny((sal_Int16)nCommand);
 334                         if( nCommand == EffectCommands::CUSTOM )
 335                         {
 336                             OSL_TRACE("OOX: CmdTimeNodeContext::endFastElement(), unknown command!");
 337                             aParamValue.Name = CREATE_OUSTRING("UserDefined");
 338                             aParamValue.Value <<= msCommand;
 339                         }
 340                         if( aParamValue.Value.hasValue() )
 341                         {
 342                             Sequence< NamedValue > aParamSeq( &aParamValue, 1 );
 343                             mpNode->getNodeProperties()[ NP_PARAMETER ] = makeAny( aParamSeq );
 344                         }
 345                     }
 346                     catch( RuntimeException& )
 347                     {
 348                         OSL_TRACE( "OOX: Exception in CmdTimeNodeContext::endFastElement()" );
 349                     }
 350                 }
 351             }
 352
 353
 354         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 355                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 356             throw ( SAXException, RuntimeException )
 357             {
 358                 Reference< XFastContextHandler > xRet;
 359
 360                 switch ( aElementToken )
 361                 {
 362                 case NMSP_PPT|XML_cBhvr:
 363                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 364                     break;
 365                 default:
 366                     break;
 367                 }
 368
 369                 if( !xRet.is() )
 370                     xRet.set( this );
 371
 372                 return xRet;
 373             }
 374
 375     private:
 376         OUString msCommand;
 377         sal_Int32 maType;
 378     };
 379
 380
 381     /** CT_TLTimeNodeSequence
 382      */
 383     class SequenceTimeNodeContext
 384         : public TimeNodeContext
 385     {
 386     public:
 387         SequenceTimeNodeContext( ContextHandler& rParent, sal_Int32  aElement,
 388                                  const Reference< XFastAttributeList >& xAttribs,
 389                                  const TimeNodePtr & pNode )
 390             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 391                 , mnNextAc(0)
 392                 , mnPrevAc(0)
 393             {
 394                 AttributeList attribs(xAttribs);
 395                 mbConcurrent = attribs.getBool( XML_concurrent, false );
 396                 // ST_TLNextActionType { none, seek }
 397                 mnNextAc = xAttribs->getOptionalValueToken( XML_nextAc, 0 );
 398                 // ST_TLPreviousActionType { none, skipTimed }
 399                 mnPrevAc = xAttribs->getOptionalValueToken( XML_prevAc, 0 );
 400             }
 401
 402         ~SequenceTimeNodeContext() throw()
 403             {
 404             }
 405
 406
 407         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 408                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 409             throw ( SAXException, RuntimeException )
 410             {
 411                 Reference< XFastContextHandler > xRet;
 412
 413                 switch ( aElementToken )
 414                 {
 415                 case NMSP_PPT|XML_cTn:
 416                     xRet.set( new CommonTimeNodeContext( *this, aElementToken, xAttribs, mpNode ) );
 417                     break;
 418                 case NMSP_PPT|XML_nextCondLst:
 419                     xRet.set( new CondListContext( *this, aElementToken, xAttribs, mpNode,
 420                                                    mpNode->getNextCondition() ) );
 421                     break;
 422                 case NMSP_PPT|XML_prevCondLst:
 423                     xRet.set( new CondListContext( *this, aElementToken, xAttribs, mpNode,
 424                                                    mpNode->getPrevCondition() ) );
 425                     break;
 426                 default:
 427                     break;
 428                 }
 429
 430                 if( !xRet.is() )
 431                     xRet.set( this );
 432
 433                 return xRet;
 434             }
 435     private:
 436         bool mbConcurrent;
 437         sal_Int32 mnNextAc, mnPrevAc;
 438     };
 439
 440
 441     /** CT_TLTimeNodeParallel
 442      *  CT_TLTimeNodeExclusive
 443      */
 444     class ParallelExclTimeNodeContext
 445         : public TimeNodeContext
 446     {
 447     public:
 448         ParallelExclTimeNodeContext( ContextHandler& rParent, sal_Int32  aElement,
 449                                      const Reference< XFastAttributeList >& xAttribs,
 450                                      const TimeNodePtr & pNode )
 451             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 452             {
 453             }
 454
 455         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 456                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 457             throw ( SAXException, RuntimeException )
 458             {
 459                 Reference< XFastContextHandler > xRet;
 460
 461                 switch ( aElementToken )
 462                 {
 463                 case NMSP_PPT|XML_cTn:
 464                     xRet.set( new CommonTimeNodeContext( *this, aElementToken, xAttribs, mpNode ) );
 465                     break;
 466                 default:
 467                     break;
 468                 }
 469
 470                 if( !xRet.is() )
 471                     xRet.set( this );
 472
 473                 return xRet;
 474             }
 475
 476     protected:
 477
 478     };
 479
 480
 481     /** CT_TLAnimateColorBehavior */
 482     class AnimColorContext
 483         : public TimeNodeContext
 484     {
 485     public:
 486         AnimColorContext( ContextHandler& rParent, sal_Int32  aElement,
 487                             const Reference< XFastAttributeList >& xAttribs,
 488                             const TimeNodePtr & pNode ) throw()
 489             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 490                 // ST_TLAnimateColorSpace ( XML_rgb, XML_hsl }
 491             , mnColorSpace( xAttribs->getOptionalValueToken( XML_clrSpc, 0 ) )
 492                 // ST_TLAnimateColorDirection { XML_cw, XML_ccw }
 493             , mnDir( xAttribs->getOptionalValueToken( XML_dir, 0 ) )
 494             , mbHasByColor( false )
 495             , m_byColor( AnimationColorSpace::RGB, 0, 0, 0)
 496             {
 497             }
 498         ~AnimColorContext() throw()
 499             {
 500             }
 501
 502         virtual void SAL_CALL endFastElement( sal_Int32 aElement ) throw ( SAXException, RuntimeException)
 503             {
 504                 //xParentNode
 505                 if( aElement == mnElement )
 506                 {
 507                     NodePropertyMap & pProps(mpNode->getNodeProperties());
 508                     pProps[ NP_DIRECTION ] = makeAny( mnDir == XML_cw );
 509                     pProps[ NP_COLORINTERPOLATION ] = makeAny( mnColorSpace == XML_hsl ? AnimationColorSpace::HSL : AnimationColorSpace::RGB );
 510                     if( maToClr.isUsed() )
 511                     {
 512                         mpNode->setTo( Any( maToClr.getColor( getFilter() ) ) );
 513                     }
 514                     if( maFromClr.isUsed() )
 515                     {
 516                         mpNode->setFrom( Any( maFromClr.getColor( getFilter() ) ) );
 517                     }
 518                     if( mbHasByColor )
 519                     {
 520                         mpNode->setBy( Any ( m_byColor.get() ) );
 521                     }
 522
 523                 }
 524             }
 525
 526
 527         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
 528             {
 529                 Reference< XFastContextHandler > xRet;
 530
 531                 switch ( aElementToken )
 532                 {
 533                 case NMSP_PPT|XML_hsl:
 534                     // CT_TLByHslColorTransform
 535                 {
 536                     if( mbHasByColor )
 537                     {
 538                         m_byColor.colorSpace = AnimationColorSpace::HSL;
 539                         m_byColor.one = xAttribs->getOptionalValue( XML_h ).toInt32( );
 540                         m_byColor.two = xAttribs->getOptionalValue( XML_s ).toInt32( );
 541                         m_byColor.three = xAttribs->getOptionalValue( XML_l ).toInt32( );
 542                     }
 543                     xRet.set(this);
 544                     break;
 545                 }
 546                 case NMSP_PPT|XML_rgb:
 547                 {
 548                     if( mbHasByColor )
 549                     {
 550                         // CT_TLByRgbColorTransform
 551                         m_byColor.colorSpace = AnimationColorSpace::RGB;
 552                         m_byColor.one = xAttribs->getOptionalValue( XML_r ).toInt32();
 553                         m_byColor.two = xAttribs->getOptionalValue( XML_g ).toInt32();
 554                         m_byColor.three = xAttribs->getOptionalValue( XML_b ).toInt32();
 555                     }
 556                     xRet.set(this);
 557                     break;
 558                 }
 559                 case NMSP_PPT|XML_by:
 560                     // CT_TLByAnimateColorTransform
 561                     mbHasByColor = true;
 562                     xRet.set(this);
 563                     break;
 564                 case NMSP_PPT|XML_cBhvr:
 565                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 566                     break;
 567                 case NMSP_PPT|XML_to:
 568                     // CT_Color
 569                     xRet.set( new ColorContext( *this, maToClr ) );
 570                     break;
 571                 case NMSP_PPT|XML_from:
 572                     // CT_Color
 573                     xRet.set( new ColorContext( *this, maFromClr ) );
 574                     break;
 575
 576                 default:
 577                     break;
 578                 }
 579
 580                 if( !xRet.is() )
 581                     xRet.set( this );
 582
 583                 return xRet;
 584             }
 585
 586
 587     private:
 588         sal_Int32 mnColorSpace;
 589         sal_Int32 mnDir;
 590         bool mbHasByColor;
 591         AnimColor m_byColor;
 592         oox::drawingml::Color maToClr;
 593         oox::drawingml::Color maFromClr;
 594     };
 595
 596
 597     /** CT_TLAnimateBehavior */
 598     class AnimContext
 599         : public TimeNodeContext
 600     {
 601     public:
 602         AnimContext( ContextHandler& rParent, sal_Int32  aElement,
 603                      const Reference< XFastAttributeList >& xAttribs,
 604                       const TimeNodePtr & pNode ) throw()
 605             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 606             {
 607                 NodePropertyMap & aProps( pNode->getNodeProperties() );
 608                 sal_Int32 nCalcMode = xAttribs->getOptionalValueToken( XML_calcmode, 0 );
 609                 if(nCalcMode)
 610                 {
 611                     sal_Int16 nEnum = 0;
 612                     switch(nCalcMode)
 613                     {
 614                     case XML_discrete:
 615                         nEnum = AnimationCalcMode::DISCRETE;
 616                         break;
 617                     case XML_lin:
 618                         nEnum = AnimationCalcMode::LINEAR;
 619                         break;
 620                     case XML_fmla:
 621                     default:
 622                         // TODO what value is good ?
 623                         nEnum = AnimationCalcMode::DISCRETE;
 624                         break;
 625                     }
 626                     aProps[ NP_CALCMODE ] = makeAny(nEnum);
 627                 }
 628                 OUString aStr;
 629                 aStr = xAttribs->getOptionalValue( XML_from );
 630                 if( aStr.getLength() )
 631                 {
 632                     pNode->setFrom( makeAny( aStr ) );
 633                 }
 634                 aStr = xAttribs->getOptionalValue( XML_by );
 635                 if( aStr.getLength() )
 636                 {
 637                     pNode->setBy( makeAny( aStr ) );
 638                 }
 639                 aStr = xAttribs->getOptionalValue( XML_to );
 640                 if( aStr.getLength() )
 641                 {
 642                     pNode->setTo( makeAny( aStr ) );
 643                 }
 644                 mnValueType = xAttribs->getOptionalValueToken( XML_valueType, 0 );
 645             }
 646
 647
 648         ~AnimContext() throw ()
 649             {
 650                 ::std::list< TimeAnimationValue >::iterator iter, end;
 651                 int nKeyTimes = maTavList.size();
 652                 if( nKeyTimes > 0)
 653                 {
 654                     int i;
 655                     Sequence< double > aKeyTimes( nKeyTimes );
 656                     Sequence< Any > aValues( nKeyTimes );
 657
 658                     NodePropertyMap & aProps( mpNode->getNodeProperties() );
 659                     end = maTavList.end();
 660                     for(iter = maTavList.begin(), i=0; iter != end; iter++,i++)
 661                     {
 662                         // TODO what to do if it is Timing_INFINITE ?
 663                         Any aTime = GetTimeAnimateValueTime( iter->msTime );
 664                         aTime >>= aKeyTimes[i];
 665                         aValues[i] = iter->maValue;
 666
 667                         OUString aTest;
 668                         iter->maValue >>= aTest;
 669                         if( aTest.getLength() != 0 )
 670                         {
 671                             aValues[i] = iter->maValue;
 672                         }
 673                         else
 674                         {
 675                             aProps[ NP_FORMULA ] <<= iter->msFormula;
 676                         }
 677                     }
 678                     aProps[ NP_VALUES ] <<= aValues;
 679                     aProps[ NP_KEYTIMES ] <<= aKeyTimes;
 680                 }
 681             }
 682
 683
 684         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
 685             {
 686                 Reference< XFastContextHandler > xRet;
 687
 688                 switch ( aElementToken )
 689                 {
 690                 case NMSP_PPT|XML_cBhvr:
 691                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 692                     break;
 693                 case NMSP_PPT|XML_tavLst:
 694                     xRet.set( new TimeAnimValueListContext ( *this, xAttribs, maTavList ) );
 695                     break;
 696                 default:
 697                     break;
 698                 }
 699
 700                 if( !xRet.is() )
 701                     xRet.set( this );
 702
 703                 return xRet;
 704             }
 705     private:
 706         sal_Int32              mnValueType;
 707         TimeAnimationValueList maTavList;
 708     };
 709
 710
 711     /** CT_TLAnimateScaleBehavior */
 712     class AnimScaleContext
 713         : public TimeNodeContext
 714     {
 715     public:
 716         AnimScaleContext( ContextHandler& rParent, sal_Int32  aElement,
 717                             const Reference< XFastAttributeList >& xAttribs,
 718                             const TimeNodePtr & pNode ) throw()
 719             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 720                 , mbZoomContents( false )
 721             {
 722                 AttributeList attribs( xAttribs );
 723                 // TODO what to do with mbZoomContents
 724                 mbZoomContents = attribs.getBool( XML_zoomContents, false );
 725                 pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
 726                     = makeAny((sal_Int16)AnimationTransformType::SCALE);
 727             }
 728
 729         ~AnimScaleContext( ) throw( )
 730             {
 731             }
 732
 733         virtual void SAL_CALL endFastElement( sal_Int32 aElement ) throw ( SAXException, RuntimeException)
 734             {
 735                 if( aElement == mnElement )
 736                 {
 737                     if( maTo.hasValue() )
 738                     {
 739                         mpNode->setTo( maTo );
 740                     }
 741                     if( maBy.hasValue() )
 742                     {
 743                         mpNode->setBy( maBy );
 744                     }
 745                     if( maFrom.hasValue() )
 746                     {
 747                         mpNode->setFrom( maFrom );
 748                     }
 749                 }
 750             }
 751
 752         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 753                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 754             throw ( SAXException, RuntimeException )
 755             {
 756                 Reference< XFastContextHandler > xRet;
 757
 758                 switch ( aElementToken )
 759                 {
 760                 case NMSP_PPT|XML_cBhvr:
 761                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 762                     break;
 763                 case NMSP_PPT|XML_to:
 764                 {
 765                     // CT_TLPoint
 766                     Point p = GetPointPercent( xAttribs );
 767                     maTo <<= p.X;
 768                     maTo <<= p.Y;
 769                     break;
 770                 }
 771                 case NMSP_PPT|XML_from:
 772                 {
 773                     // CT_TLPoint
 774                     Point p = GetPointPercent( xAttribs );
 775                     maFrom <<= p.X;
 776                     maFrom <<= p.Y;
 777                     break;
 778                 }
 779                 case NMSP_PPT|XML_by:
 780                 {
 781                     // CT_TLPoint
 782                     Point p = GetPointPercent( xAttribs );
 783                     maBy <<= p.X;
 784                     maBy <<= p.Y;
 785                     break;
 786                 }
 787                 default:
 788                     break;
 789                 }
 790
 791                 if( !xRet.is() )
 792                     xRet.set( this );
 793
 794                 return xRet;
 795             }
 796     private:
 797         Any maBy;
 798         Any maFrom;
 799         Any maTo;
 800         bool mbZoomContents;
 801     };
 802
 803
 804     /** CT_TLAnimateRotationBehavior */
 805     class AnimRotContext
 806         : public TimeNodeContext
 807     {
 808     public:
 809         AnimRotContext( ContextHandler& rParent, sal_Int32  aElement,
 810                         const Reference< XFastAttributeList >& xAttribs,
 811                          const TimeNodePtr & pNode ) throw()
 812             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 813             {
 814                 AttributeList attribs( xAttribs );
 815
 816                 pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
 817                     = makeAny((sal_Int16)AnimationTransformType::ROTATE);
 818                 // TODO make sure the units are OK
 819                 if(attribs.hasAttribute( XML_by ) )
 820                 {
 821                     sal_Int32 nBy = attribs.getInteger( XML_by, 0 );
 822                     pNode->setBy( makeAny( nBy ) );
 823                 }
 824                 if(attribs.hasAttribute( XML_from ) )
 825                 {
 826                     sal_Int32 nFrom = attribs.getInteger( XML_from, 0 );
 827                     pNode->setFrom( makeAny( nFrom ) );
 828                 }
 829                 if(attribs.hasAttribute( XML_to ) )
 830                 {
 831                     sal_Int32 nTo = attribs.getInteger( XML_to, 0 );
 832                     pNode->setTo( makeAny( nTo ) );
 833                 }
 834             }
 835
 836         ~AnimRotContext( ) throw( )
 837             {
 838             }
 839
 840         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
 841             {
 842                 Reference< XFastContextHandler > xRet;
 843
 844                 switch ( aElementToken )
 845                 {
 846                 case NMSP_PPT|XML_cBhvr:
 847                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 848                     break;
 849                 default:
 850                     break;
 851                 }
 852
 853                 if( !xRet.is() )
 854                     xRet.set( this );
 855
 856                 return xRet;
 857             }
 858     };
 859
 860
 861
 862     /** CT_TLAnimateMotionBehavior */
 863     class AnimMotionContext
 864         : public TimeNodeContext
 865     {
 866     public:
 867         AnimMotionContext( ContextHandler& rParent, sal_Int32  aElement,
 868                          const Reference< XFastAttributeList >& xAttribs,
 869                           const TimeNodePtr & pNode ) throw()
 870             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 871             {
 872                 pNode->getNodeProperties()[ NP_TRANSFORMTYPE ]
 873                     = makeAny((sal_Int16)AnimationTransformType::TRANSLATE);
 874
 875                 AttributeList attribs( xAttribs );
 876                 // ST_TLAnimateMotionBehaviorOrigin { parent, layour }
 877                 sal_Int32 nOrigin = xAttribs->getOptionalValueToken( XML_origin, 0 );
 878                 if( nOrigin != 0 )
 879                 {
 880                     switch(nOrigin)
 881                     {
 882                     case XML_layout:
 883                     case XML_parent:
 884                         break;
 885                     }
 886                     // TODO
 887                 }
 888
 889                 OUString aStr = xAttribs->getOptionalValue( XML_path );
 890                 aStr = aStr.replace( 'E', ' ' );
 891                 aStr = aStr.trim();
 892                 pNode->getNodeProperties()[ NP_PATH ] = makeAny(aStr);
 893
 894                 // ST_TLAnimateMotionPathEditMode{ fixed, relative }
 895                 mnPathEditMode = xAttribs->getOptionalValueToken( XML_pathEditMode, 0 );
 896                 msPtsTypes = xAttribs->getOptionalValue( XML_ptsTypes );
 897                 mnAngle = attribs.getInteger( XML_rAng, 0 );
 898                 // TODO make sure the units are right. Likely not.
 899             }
 900
 901         ~AnimMotionContext( ) throw()
 902             {
 903             }
 904
 905
 906         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken,
 907                                                                                                                                                             const Reference< XFastAttributeList >& xAttribs )
 908             throw ( SAXException, RuntimeException )
 909             {
 910                 Reference< XFastContextHandler > xRet;
 911
 912                 switch ( aElementToken )
 913                 {
 914                 case NMSP_PPT|XML_cBhvr:
 915                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
 916                     break;
 917                 case NMSP_PPT|XML_to:
 918                 {
 919                     // CT_TLPoint
 920                     Point p = GetPointPercent( xAttribs );
 921                     Any rAny;
 922                     rAny <<= p.X;
 923                     rAny <<= p.Y;
 924                     mpNode->setTo( rAny );
 925                     break;
 926                 }
 927                 case NMSP_PPT|XML_from:
 928                 {
 929                     // CT_TLPoint
 930                     Point p = GetPointPercent( xAttribs );
 931                     Any rAny;
 932                     rAny <<= p.X;
 933                     rAny <<= p.Y;
 934                     mpNode->setFrom( rAny );
 935                     break;
 936                 }
 937                 case NMSP_PPT|XML_by:
 938                 {
 939                     // CT_TLPoint
 940                     Point p = GetPointPercent( xAttribs );
 941                     Any rAny;
 942                     rAny <<= p.X;
 943                     rAny <<= p.Y;
 944                     mpNode->setBy( rAny );
 945                     break;
 946                 }
 947                 case NMSP_PPT|XML_rCtr:
 948                 {
 949                     // CT_TLPoint
 950                     Point p = GetPointPercent( xAttribs );
 951                     // TODO push
 952                     break;
 953                 }
 954                 default:
 955                     break;
 956                 }
 957
 958                 if( !xRet.is() )
 959                     xRet.set( this );
 960
 961                 return xRet;
 962             }
 963     private:
 964         OUString msPtsTypes;
 965         sal_Int32 mnPathEditMode;
 966         sal_Int32 mnAngle;
 967     };
 968
 969
 970     /** CT_TLAnimateEffectBehavior */
 971     class AnimEffectContext
 972         : public TimeNodeContext
 973     {
 974     public:
 975         AnimEffectContext( ContextHandler& rParent, sal_Int32  aElement,
 976                              const Reference< XFastAttributeList >& xAttribs,
 977                              const TimeNodePtr & pNode ) throw()
 978             : TimeNodeContext( rParent, aElement, xAttribs, pNode )
 979             {
 980                 sal_Int32 nDir = xAttribs->getOptionalValueToken( XML_transition, 0 );
 981                 OUString sFilter = xAttribs->getOptionalValue( XML_filter );
 982                 // TODO
 983 //                              OUString sPrList = xAttribs->getOptionalValue( XML_prLst );
 984
 985                 if( sFilter.getLength() )
 986                 {
 987                     SlideTransition aFilter( sFilter );
 988                     aFilter.setMode( nDir == XML_out ? false : true );
 989                     pNode->setTransitionFilter( aFilter );
 990                 }
 991             }
 992
 993
 994         ~AnimEffectContext( ) throw()
 995             {
 996             }
 997
 998
 999         virtual Reference< XFastContextHandler > SAL_CALL createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException )
1000             {
1001                 Reference< XFastContextHandler > xRet;
1002
1003                 switch ( aElementToken )
1004                 {
1005                 case NMSP_PPT|XML_cBhvr:
1006                     xRet.set( new CommonBehaviorContext ( *this, xAttribs, mpNode ) );
1007                     break;
1008                 case NMSP_PPT|XML_progress:
1009                     xRet.set( new AnimVariantContext( *this, aElementToken, maProgress ) );
1010                     // TODO handle it.
1011                     break;
1012                 default:
1013                     break;
1014                 }
1015
1016                 if( !xRet.is() )
1017                     xRet.set( this );
1018
1019                 return xRet;
1020             }
1021     private:
1022         Any maProgress;
1023         OUString msFilter;
1024         OUString msPrList;
1025     };
1026
1027
1028
1029     TimeNodeContext * TimeNodeContext::makeContext(
1030             ContextHandler& rParent, sal_Int32  aElement,
1031             const Reference< XFastAttributeList >& xAttribs,
1032             const TimeNodePtr & pNode )
1033     {
1034         TimeNodeContext *pCtx = NULL;
1035         switch( aElement )
1036         {
1037         case NMSP_PPT|XML_animClr:
1038             pCtx = new AnimColorContext( rParent, aElement, xAttribs, pNode );
1039             break;
1040         case NMSP_PPT|XML_par:
1041             pCtx = new ParallelExclTimeNodeContext( rParent, aElement, xAttribs, pNode );
1042             break;
1043         case NMSP_PPT|XML_seq:
1044             pCtx = new SequenceTimeNodeContext( rParent, aElement, xAttribs, pNode );
1045             break;
1046         case NMSP_PPT|XML_excl:
1047             pCtx = new ParallelExclTimeNodeContext( rParent, aElement, xAttribs, pNode );
1048             break;
1049         case NMSP_PPT|XML_anim:
1050             pCtx = new AnimContext ( rParent, aElement, xAttribs, pNode );
1051             break;
1052         case NMSP_PPT|XML_animEffect:
1053             pCtx = new AnimEffectContext( rParent, aElement, xAttribs, pNode );
1054             break;
1055         case NMSP_PPT|XML_animMotion:
1056             pCtx = new AnimMotionContext( rParent, aElement, xAttribs, pNode );
1057             break;
1058         case NMSP_PPT|XML_animRot:
1059             pCtx = new AnimRotContext( rParent, aElement, xAttribs, pNode );
1060             break;
1061         case NMSP_PPT|XML_animScale:
1062             pCtx = new AnimScaleContext( rParent, aElement, xAttribs, pNode );
1063             break;
1064         case NMSP_PPT|XML_cmd:
1065             pCtx = new CmdTimeNodeContext( rParent, aElement, xAttribs, pNode );
1066             break;
1067         case NMSP_PPT|XML_set:
1068             pCtx = new SetTimeNodeContext( rParent, aElement, xAttribs, pNode );
1069             break;
1070         case NMSP_PPT|XML_audio:
1071         case NMSP_PPT|XML_video:
1072             pCtx = new MediaNodeContext( rParent, aElement, xAttribs, pNode );
1073             break;
1074         default:
1075             break;
1076         }
1077         return pCtx;
1078     }
1079
1080
1081     TimeNodeContext::TimeNodeContext( ContextHandler& rParent, sal_Int32 aElement,
1082             const Reference< XFastAttributeList >& /*xAttribs*/,
1083             const TimeNodePtr & pNode ) throw()
1084         : ContextHandler( rParent )
1085         , mnElement( aElement )
1086         , mpNode( pNode )
1087     {
1088     }
1089
1090
1091     TimeNodeContext::~TimeNodeContext( ) throw()
1092     {
1093
1094     }
1095
1096
1097     TimeNodeListContext::TimeNodeListContext( ContextHandler& rParent, TimeNodePtrList & aList )
1098         throw()
1099         : ContextHandler( rParent )
1100             , maList( aList )
1101     {
1102     }
1103
1104
1105     TimeNodeListContext::~TimeNodeListContext( ) throw()
1106     {
1107     }
1108
1109
1110     Reference< XFastContextHandler > SAL_CALL TimeNodeListContext::createFastChildContext( ::sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException)
1111     {
1112         Reference< XFastContextHandler > xRet;
1113
1114         sal_Int16 nNodeType;
1115
1116         switch( aElementToken )
1117         {
1118         case NMSP_PPT|XML_par:
1119             nNodeType = AnimationNodeType::PAR;
1120             break;
1121         case NMSP_PPT|XML_seq:
1122             nNodeType = AnimationNodeType::SEQ;
1123             break;
1124         case NMSP_PPT|XML_excl:
1125             // TODO pick the right type. We choose parallel for now as
1126             // there does not seem to be an "Exclusive"
1127             nNodeType = AnimationNodeType::PAR;
1128             break;
1129         case NMSP_PPT|XML_anim:
1130             nNodeType = AnimationNodeType::ANIMATE;
1131             break;
1132         case NMSP_PPT|XML_animClr:
1133             nNodeType = AnimationNodeType::ANIMATECOLOR;
1134             break;
1135         case NMSP_PPT|XML_animEffect:
1136             nNodeType = AnimationNodeType::TRANSITIONFILTER;
1137             break;
1138         case NMSP_PPT|XML_animMotion:
1139             nNodeType = AnimationNodeType::ANIMATEMOTION;
1140             break;
1141         case NMSP_PPT|XML_animRot:
1142         case NMSP_PPT|XML_animScale:
1143             nNodeType = AnimationNodeType::ANIMATETRANSFORM;
1144             break;
1145         case NMSP_PPT|XML_cmd:
1146             nNodeType = AnimationNodeType::COMMAND;
1147             break;
1148         case NMSP_PPT|XML_set:
1149             nNodeType = AnimationNodeType::SET;
1150             break;
1151         case NMSP_PPT|XML_audio:
1152             nNodeType = AnimationNodeType::AUDIO;
1153             break;
1154         case NMSP_PPT|XML_video:
1155             nNodeType = AnimationNodeType::AUDIO;
1156             OSL_TRACE( "OOX: video requested, gave Audio instead" );
1157             break;
1158
1159         default:
1160             nNodeType = AnimationNodeType::CUSTOM;
1161             OSL_TRACE( "OOX: uhandled token %x", aElementToken );
1162             break;
1163         }
1164
1165         TimeNodePtr pNode(new TimeNode(nNodeType));
1166         maList.push_back( pNode );
1167         ContextHandler * pContext = TimeNodeContext::makeContext( *this, aElementToken, xAttribs, pNode );
1168         xRet.set( pContext ? pContext : this );
1169
1170         return xRet;
1171     }
1172
1173
1174 } }