xmloff/source/draw/animationimport.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: animationimport.cxx,v $
  10  * $Revision: 1.15.62.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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34 #include <tools/debug.hxx>
  35 #include <tools/time.hxx>
  36 #include "unointerfacetouniqueidentifiermapper.hxx"
  37 #include <com/sun/star/lang/XServiceInfo.hpp>
  38 #include <com/sun/star/lang/XInitialization.hpp>
  39 #include <com/sun/star/animations/AnimationTransformType.hpp>
  40 #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
  41 #include <com/sun/star/presentation/AnimationEffect.hpp>
  42 #include <com/sun/star/presentation/AnimationSpeed.hpp>
  43 #include <com/sun/star/animations/AnimationNodeType.hpp>
  44 #include <com/sun/star/animations/XIterateContainer.hpp>
  45 #include <com/sun/star/animations/XAnimateMotion.hpp>
  46 #include <com/sun/star/animations/XAnimateColor.hpp>
  47 #include <com/sun/star/animations/XAnimateTransform.hpp>
  48 #include <com/sun/star/animations/XTransitionFilter.hpp>
  49 #include <com/sun/star/animations/XCommand.hpp>
  50 #include <com/sun/star/animations/XAudio.hpp>
  51 #include <com/sun/star/animations/ValuePair.hpp>
  52 #include <com/sun/star/animations/AnimationColorSpace.hpp>
  53 #ifndef _COM_SUN_STAR_PRESENTATION_EffectPresetClass_HPP_
  54 #include <com/sun/star/presentation/EffectPresetClass.hpp>
  55 #endif
  56 #include <com/sun/star/animations/Timing.hpp>
  57 #include <com/sun/star/animations/Event.hpp>
  58 #include <com/sun/star/beans/XPropertySet.hpp>
  59 #include <com/sun/star/xml/sax/XAttributeList.hpp>
  60 #include <com/sun/star/text/XTextCursor.hpp>
  61 #include <com/sun/star/text/XTextRangeCompare.hpp>
  62 #ifndef _COM_SUN_STAR_PRESENTATION_ParagraphTarget_HPP_
  63 #include <com/sun/star/presentation/ParagraphTarget.hpp>
  64 #endif
  65 #include <com/sun/star/container/XEnumerationAccess.hpp>
  66 #include <com/sun/star/beans/XPropertySet.hpp>
  67 #include <com/sun/star/animations/EventTrigger.hpp>
  68 #include <com/sun/star/presentation/EffectCommands.hpp>
  69 #include <comphelper/processfactory.hxx>
  70 #include <cppuhelper/implbase1.hxx>
  71
  72 #include <list>
  73 #include <xmloff/xmltypes.hxx>
  74 #include "sdpropls.hxx"
  75 #include <xmloff/xmltoken.hxx>
  76 #include <xmloff/xmlimp.hxx>
  77 #include "xmlnmspe.hxx"
  78 #include <xmloff/xmluconv.hxx>
  79 #include <osl/mutex.hxx>
  80 #include <xmloff/nmspmap.hxx>
  81 #include "anim.hxx"
  82
  83 #include "animations.hxx"
  84 #include "animationimport.hxx"
  85
  86 using ::rtl::OUString;
  87 using ::rtl::OUStringBuffer;
  88
  89 using namespace ::std;
  90 using namespace ::cppu;
  91 using namespace ::com::sun::star::beans;
  92 using namespace ::com::sun::star::animations;
  93 using namespace ::com::sun::star::presentation;
  94 using namespace ::com::sun::star::drawing;
  95 using namespace ::xmloff::token;
  96
  97 using ::com::sun::star::xml::sax::XAttributeList;
  98 using ::com::sun::star::uno::Any;
  99 using ::com::sun::star::uno::makeAny;
 100 using ::com::sun::star::uno::UNO_QUERY;
 101 using ::com::sun::star::uno::UNO_QUERY_THROW;
 102 using ::com::sun::star::uno::Reference;
 103 using ::com::sun::star::uno::Sequence;
 104 using ::com::sun::star::uno::RuntimeException;
 105 using ::com::sun::star::uno::Exception;
 106 using ::com::sun::star::uno::XInterface;
 107 using ::com::sun::star::uno::Type;
 108 using ::com::sun::star::beans::NamedValue;
 109 using ::com::sun::star::text::XTextRange;
 110 using ::com::sun::star::text::XTextCursor;
 111 using ::com::sun::star::text::XTextRangeCompare;
 112 using ::com::sun::star::container::XEnumerationAccess;
 113 using ::com::sun::star::container::XEnumeration;
 114 using ::com::sun::star::lang::XMultiServiceFactory;
 115 using ::com::sun::star::lang::XInitialization;
 116
 117 namespace xmloff
 118 {
 119
 120 ///////////////////////////////////////////////////////////////////////
 121
 122
 123
 124 ///////////////////////////////////////////////////////////////////////
 125
 126
 127 ///////////////////////////////////////////////////////////////////////
 128
 129 class AnimationsImportHelperImpl
 130 {
 131 private:
 132     SvXMLImport& mrImport;
 133
 134     SvXMLTokenMap* mpAnimationNodeTokenMap;
 135     SvXMLTokenMap* mpAnimationNodeAttributeTokenMap;
 136
 137 public:
 138     AnimationsImportHelperImpl( SvXMLImport& rImport );
 139     ~AnimationsImportHelperImpl();
 140
 141     const SvXMLTokenMap& getAnimationNodeTokenMap();
 142     const SvXMLTokenMap& getAnimationNodeAttributeTokenMap();
 143
 144     Any convertValue( XMLTokenEnum eAttributeName, const OUString& rValue );
 145     Sequence< Any > convertValueSequence( XMLTokenEnum eAttributeName, const OUString& rValue );
 146
 147     Any convertTarget( const OUString& rValue );
 148     Any convertPath( const OUString& rValue );
 149     Any convertTiming( const OUString& rValue );
 150     Sequence< double > convertKeyTimes( const OUString& rValue );
 151     Sequence< TimeFilterPair > convertTimeFilter( const OUString& rValue );
 152
 153     bool convertAnimationValue( XMLTokenEnum eAttributeName, Any& rValue );
 154     const OUString mastrHSL;
 155 };
 156
 157 AnimationsImportHelperImpl::AnimationsImportHelperImpl( SvXMLImport& rImport )
 158 :       mrImport( rImport ),
 159     mpAnimationNodeTokenMap( NULL ),
 160     mpAnimationNodeAttributeTokenMap( NULL ),
 161     mastrHSL( RTL_CONSTASCII_USTRINGPARAM( "hsl" ) )
 162 {
 163 }
 164
 165 AnimationsImportHelperImpl::~AnimationsImportHelperImpl()
 166 {
 167     delete mpAnimationNodeTokenMap;
 168     delete mpAnimationNodeAttributeTokenMap;
 169 }
 170
 171 const SvXMLTokenMap& AnimationsImportHelperImpl::getAnimationNodeTokenMap()
 172 {
 173     if( mpAnimationNodeTokenMap == NULL )
 174     {
 175         static __FAR_DATA SvXMLTokenMapEntry aAnimationNodeTokenMap[] =
 176         {
 177             { XML_NAMESPACE_ANIMATION,  XML_PAR,                                (sal_uInt16)AnimationNodeType::PAR },
 178             { XML_NAMESPACE_ANIMATION,  XML_SEQ,                                (sal_uInt16)AnimationNodeType::SEQ },
 179             { XML_NAMESPACE_ANIMATION,  XML_ITERATE,                    (sal_uInt16)AnimationNodeType::ITERATE },
 180             { XML_NAMESPACE_ANIMATION,  XML_ANIMATE,                    (sal_uInt16)AnimationNodeType::ANIMATE },
 181             { XML_NAMESPACE_ANIMATION,  XML_SET,                                (sal_uInt16)AnimationNodeType::SET },
 182             { XML_NAMESPACE_ANIMATION,  XML_ANIMATEMOTION,              (sal_uInt16)AnimationNodeType::ANIMATEMOTION },
 183             { XML_NAMESPACE_ANIMATION,  XML_ANIMATECOLOR,               (sal_uInt16)AnimationNodeType::ANIMATECOLOR },
 184             { XML_NAMESPACE_ANIMATION,  XML_ANIMATETRANSFORM,   (sal_uInt16)AnimationNodeType::ANIMATETRANSFORM },
 185             { XML_NAMESPACE_ANIMATION,  XML_TRANSITIONFILTER,   (sal_uInt16)AnimationNodeType::TRANSITIONFILTER },
 186             { XML_NAMESPACE_ANIMATION,  XML_AUDIO,                              (sal_uInt16)AnimationNodeType::AUDIO },
 187             { XML_NAMESPACE_ANIMATION,  XML_COMMAND,                    (sal_uInt16)AnimationNodeType::COMMAND },
 188             XML_TOKEN_MAP_END
 189         };
 190
 191         mpAnimationNodeTokenMap = new SvXMLTokenMap( aAnimationNodeTokenMap );
 192     }
 193
 194     return *mpAnimationNodeTokenMap;
 195 }
 196
 197 enum AnimationNodeAttributes
 198 {
 199     ANA_Begin,
 200     ANA_Dur,
 201     ANA_End,
 202     ANA_Fill,
 203     ANA_FillDefault,
 204     ANA_Restart,
 205     ANA_RestartDefault,
 206     ANA_Accelerate,
 207     ANA_Decelerate,
 208     ANA_AutoReverse,
 209     ANA_RepeatCount,
 210     ANA_RepeatDur,
 211     ANA_EndSync,
 212     ANA_Node_Type,
 213     ANA_Preset_ID,
 214     ANA_Preset_Sub_Type,
 215     ANA_Preset_Class,
 216     ANA_After_Effect,
 217     ANA_Target,
 218     ANA_XLink,
 219     ANA_MasterElement,
 220     ANA_SubItem,
 221     ANA_AttributeName,
 222     ANA_Values,
 223     ANA_From,
 224     ANA_By,
 225     ANA_To,
 226     ANA_KeyTimes,
 227     ANA_CalcMode,
 228     ANA_Accumulate,
 229     ANA_AdditiveMode,
 230     ANA_KeySplines,
 231     ANA_Path,
 232     ANA_ColorSpace,
 233     ANA_ColorDirection,
 234     ANA_TransformType,
 235     ANA_TransitionType,
 236     ANA_TransitionSubType,
 237     ANA_Mode,
 238     ANA_Direction,
 239     ANA_FadeColor,
 240     ANA_IterateType,
 241     ANA_IterateInterval,
 242     ANA_Formula,
 243     ANA_ID,
 244     ANA_Group_Id,
 245     ANA_Command,
 246     ANA_Volume
 247 };
 248
 249 const SvXMLTokenMap& AnimationsImportHelperImpl::getAnimationNodeAttributeTokenMap()
 250 {
 251     if( mpAnimationNodeAttributeTokenMap == NULL )
 252     {
 253         static __FAR_DATA SvXMLTokenMapEntry aAnimationNodeAttributeTokenMap[] =
 254         {
 255             { XML_NAMESPACE_SMIL, XML_BEGIN,                                    (sal_uInt16)ANA_Begin },
 256             { XML_NAMESPACE_SMIL, XML_DUR,                                              (sal_uInt16)ANA_Dur },
 257             { XML_NAMESPACE_SMIL, XML_END,                                              (sal_uInt16)ANA_End },
 258             { XML_NAMESPACE_SMIL, XML_FILL,                                             (sal_uInt16)ANA_Fill },
 259             { XML_NAMESPACE_SMIL, XML_FILLDEFAULT,                              (sal_uInt16)ANA_FillDefault },
 260             { XML_NAMESPACE_SMIL, XML_RESTART,                                  (sal_uInt16)ANA_Restart },
 261             { XML_NAMESPACE_SMIL, XML_RESTARTDEFAULT,                   (sal_uInt16)ANA_RestartDefault },
 262             { XML_NAMESPACE_SMIL, XML_ACCELERATE,                               (sal_uInt16)ANA_Accelerate },
 263             { XML_NAMESPACE_SMIL, XML_DECELERATE,                               (sal_uInt16)ANA_Decelerate },
 264             { XML_NAMESPACE_SMIL, XML_AUTOREVERSE,                              (sal_uInt16)ANA_AutoReverse },
 265             { XML_NAMESPACE_SMIL, XML_REPEATCOUNT,                              (sal_uInt16)ANA_RepeatCount },
 266             { XML_NAMESPACE_SMIL, XML_REPEATDUR,                                (sal_uInt16)ANA_RepeatDur },
 267             { XML_NAMESPACE_SMIL, XML_ENDSYNC,                                  (sal_uInt16)ANA_EndSync },
 268             { XML_NAMESPACE_PRESENTATION, XML_NODE_TYPE,                (sal_uInt16)ANA_Node_Type },
 269             { XML_NAMESPACE_PRESENTATION, XML_PRESET_ID,                (sal_uInt16)ANA_Preset_ID },
 270             { XML_NAMESPACE_PRESENTATION, XML_PRESET_SUB_TYPE,  (sal_uInt16)ANA_Preset_Sub_Type },
 271             { XML_NAMESPACE_PRESENTATION, XML_PRESET_CLASS,             (sal_uInt16)ANA_Preset_Class },
 272             { XML_NAMESPACE_PRESENTATION, XML_AFTER_EFFECT,             (sal_uInt16)ANA_After_Effect },
 273             { XML_NAMESPACE_SMIL, XML_TARGETELEMENT,                    (sal_uInt16)ANA_Target },
 274             { XML_NAMESPACE_XLINK, XML_HREF,                                    (sal_uInt16)ANA_XLink },
 275             { XML_NAMESPACE_PRESENTATION, XML_MASTER_ELEMENT,   (sal_uInt16)ANA_MasterElement },
 276             { XML_NAMESPACE_ANIMATION, XML_SUB_ITEM,                    (sal_uInt16)ANA_SubItem },
 277             { XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME,                    (sal_uInt16)ANA_AttributeName },
 278             { XML_NAMESPACE_SMIL, XML_VALUES,                                   (sal_uInt16)ANA_Values },
 279             { XML_NAMESPACE_SMIL, XML_FROM,                                             (sal_uInt16)ANA_From },
 280             { XML_NAMESPACE_SMIL, XML_BY,                                               (sal_uInt16)ANA_By },
 281             { XML_NAMESPACE_SMIL, XML_TO,                                               (sal_uInt16)ANA_To },
 282             { XML_NAMESPACE_SMIL, XML_KEYTIMES,                                 (sal_uInt16)ANA_KeyTimes },
 283             { XML_NAMESPACE_SMIL, XML_CALCMODE,                                 (sal_uInt16)ANA_CalcMode },
 284             { XML_NAMESPACE_SMIL, XML_ACCUMULATE,                               (sal_uInt16)ANA_Accumulate },
 285             { XML_NAMESPACE_PRESENTATION, XML_ADDITIVE,                 (sal_uInt16)ANA_AdditiveMode },
 286             { XML_NAMESPACE_SMIL, XML_ADDITIVE,                                 (sal_uInt16)ANA_AdditiveMode },
 287             { XML_NAMESPACE_SMIL, XML_KEYSPLINES,                               (sal_uInt16)ANA_KeySplines },
 288             { XML_NAMESPACE_SVG, XML_PATH,                                              (sal_uInt16)ANA_Path },
 289             { XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION, (sal_uInt16)ANA_ColorSpace },
 290             { XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION,               (sal_uInt16)ANA_ColorDirection },
 291             { XML_NAMESPACE_SVG, XML_TYPE,                                              (sal_uInt16)ANA_TransformType },
 292             { XML_NAMESPACE_SMIL, XML_TYPE,                                             (sal_uInt16)ANA_TransitionType },
 293             { XML_NAMESPACE_SMIL, XML_SUBTYPE,                                  (sal_uInt16)ANA_TransitionSubType },
 294             { XML_NAMESPACE_SMIL, XML_MODE,                                             (sal_uInt16)ANA_Mode },
 295             { XML_NAMESPACE_SMIL, XML_DIRECTION,                                (sal_uInt16)ANA_Direction },
 296             { XML_NAMESPACE_SMIL, XML_FADECOLOR,                                (sal_uInt16)ANA_FadeColor },
 297             { XML_NAMESPACE_ANIMATION, XML_ITERATE_TYPE,                (sal_uInt16)ANA_IterateType },
 298             { XML_NAMESPACE_ANIMATION, XML_ITERATE_INTERVAL,    (sal_uInt16)ANA_IterateInterval },
 299             { XML_NAMESPACE_ANIMATION, XML_FORMULA,                             (sal_uInt16)ANA_Formula },
 300             { XML_NAMESPACE_ANIMATION, XML_ID,                                  (sal_uInt16)ANA_ID },
 301             { XML_NAMESPACE_XML, XML_ID,                                                (sal_uInt16)ANA_ID },
 302             { XML_NAMESPACE_PRESENTATION, XML_GROUP_ID,                 (sal_uInt16)ANA_Group_Id },
 303             { XML_NAMESPACE_ANIMATION, XML_AUDIO_LEVEL,                 (sal_uInt16)ANA_Volume },
 304             { XML_NAMESPACE_ANIMATION, XML_COMMAND,                             (sal_uInt16)ANA_Command },
 305
 306             XML_TOKEN_MAP_END
 307         };
 308
 309         mpAnimationNodeAttributeTokenMap = new SvXMLTokenMap( aAnimationNodeAttributeTokenMap );
 310     }
 311
 312     return *mpAnimationNodeAttributeTokenMap;
 313 }
 314
 315 static bool isDouble( const OUString& rValue )
 316 {
 317     sal_Int32 nLength = rValue.getLength();
 318     const sal_Unicode * pStr = rValue.getStr();
 319     while( nLength )
 320     {
 321         if( (*pStr >= '0' && *pStr <= '9') || *pStr == '-' || *pStr == '.' || *pStr == '+' || *pStr == 'e' || *pStr == 'E' )
 322         {
 323             pStr++;
 324             nLength--;
 325         }
 326         else
 327         {
 328             return false;
 329         }
 330     }
 331
 332     return true;
 333 }
 334
 335 static bool isTime( const OUString& rValue )
 336 {
 337     sal_Int32 nLength = rValue.getLength();
 338     const sal_Unicode * pStr;
 339     for( pStr = rValue.getStr(); nLength; pStr++, nLength-- )
 340     {
 341         if( !( (*pStr >= '0' && *pStr <= '9') || *pStr == '-' || *pStr == '.' || *pStr == '+' || *pStr == 'e' || *pStr == 'E' ) )
 342             break;
 343     }
 344
 345     // return true if this is a double (if someone forgot the 's' we silently ignore it)
 346     // or if its a double that ends with a 's' or 'S'
 347     return (nLength == 0) || ((*pStr == 's' || *pStr == 'S') && (nLength == 1));
 348 }
 349
 350 static sal_Int32 count_codes( const OUString& rString, sal_Unicode nCode )
 351 {
 352     sal_Int32 nCount = 0;
 353     sal_Int32 fromIndex = 0;
 354
 355     while(true)
 356     {
 357         fromIndex = rString.indexOf( nCode, fromIndex );
 358         if( fromIndex == -1 )
 359             break;
 360
 361         fromIndex++;
 362         nCount++;
 363     }
 364
 365     return nCount;
 366 }
 367
 368 Any AnimationsImportHelperImpl::convertTarget( const OUString& rValue )
 369 {
 370     try
 371     {
 372         Reference< XInterface > xRef( mrImport.getInterfaceToIdentifierMapper().getReference( rValue ) );
 373
 374         Reference< XShape > _xShape( xRef, UNO_QUERY );
 375         if( _xShape.is() )
 376             return makeAny( _xShape );
 377
 378         Reference< XTextCursor > xTextCursor( xRef, UNO_QUERY );
 379         if( xTextCursor.is() )
 380         {
 381             Reference< XTextRange > xStart( xTextCursor->getStart() ), xRange;
 382             Reference< XShape > xShape( xTextCursor->getText(), UNO_QUERY_THROW );
 383             Reference< XTextRangeCompare > xTextRangeCompare( xShape, UNO_QUERY_THROW );
 384
 385             Reference< XEnumerationAccess > xParaEnumAccess( xShape, UNO_QUERY_THROW );
 386             Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), UNO_QUERY_THROW );
 387             sal_Int16 nParagraph = 0;
 388
 389             while( xEnumeration->hasMoreElements() )
 390             {
 391                 xEnumeration->nextElement() >>= xRange;
 392
 393                 // break if start of selection is prior to end of current paragraph
 394                 if( xRange.is() && (xTextRangeCompare->compareRegionEnds( xStart, xRange ) >= 0 ) )
 395                 {
 396                     return makeAny( ParagraphTarget( xShape, nParagraph ) );
 397                 }
 398
 399                 nParagraph++;
 400             }
 401         }
 402     }
 403     catch( RuntimeException& )
 404     {
 405         DBG_ERROR( "xmloff::AnimationsImportImpl::convertTarget(), RuntimeException catched!" );
 406     }
 407
 408     Any aAny;
 409     return aAny;
 410 }
 411
 412 Any AnimationsImportHelperImpl::convertValue( XMLTokenEnum eAttributeName, const OUString& rValue )
 413 {
 414     sal_Int32 nCommaPos = -1, nPos;
 415     sal_Int32 nOpenBrakets = 0;
 416     for( nPos = 0; (nPos < rValue.getLength()) && (nCommaPos == -1); nPos++ )
 417     {
 418         switch( rValue[nPos] )
 419         {
 420         case ',':
 421             if( nOpenBrakets == 0 )
 422                 nCommaPos = nPos;
 423             break;
 424         case '(':
 425         case '[':
 426         case '{':
 427             nOpenBrakets++;
 428             break;
 429         case ')':
 430         case ']':
 431         case '}':
 432             nOpenBrakets--;
 433             break;
 434         }
 435     }
 436
 437     if( nCommaPos >= 0 )
 438     {
 439         ValuePair aPair;
 440         aPair.First = convertValue( eAttributeName, rValue.copy( 0, nCommaPos ) );
 441         aPair.Second = convertValue( eAttributeName, rValue.copy( nCommaPos+1, rValue.getLength() - nCommaPos - 1 ) );
 442         return makeAny( aPair );
 443     }
 444     else
 445     {
 446         Any aAny;
 447         sal_Int32 nType = XML_TYPE_STRING;
 448
 449         if( rValue.getLength() ) switch( eAttributeName )
 450         {
 451         case XML_X:
 452         case XML_Y:
 453         case XML_WIDTH:
 454         case XML_HEIGHT:
 455         case XML_TRANSLATE:
 456         {
 457             return makeAny( rValue );
 458         }
 459
 460         case XML_SCALE:
 461         case XML_SKEWY:
 462         case XML_SKEWX:
 463         case XML_OPACITY:
 464         case XML_ROTATE:                        nType = XML_TYPE_DOUBLE;                                        break;
 465         case XML_TEXT_ROTATION_ANGLE:nType = XML_TYPE_TEXT_ROTATION_ANGLE;              break;
 466         case XML_FILL_COLOR:
 467         case XML_STROKE_COLOR:
 468         case XML_DIM:
 469         case XML_COLOR:                         nType = XML_TYPE_COLOR;                                         break;
 470         case XML_FILL:                          nType = XML_SD_TYPE_FILLSTYLE;                          break;
 471         case XML_STROKE:                        nType = XML_SD_TYPE_STROKE;                                     break;
 472         case XML_FONT_WEIGHT:           nType = XML_TYPE_TEXT_WEIGHT;                           break;
 473         case XML_FONT_STYLE:            nType = XML_TYPE_TEXT_POSTURE;                          break;
 474         case XML_TEXT_UNDERLINE:        nType = XML_TYPE_TEXT_UNDERLINE_STYLE;          break;
 475         case XML_FONT_SIZE:                     nType = XML_TYPE_DOUBLE_PERCENT;                        break;
 476         case XML_VISIBILITY:            nType = XML_SD_TYPE_PRESPAGE_VISIBILITY;        break;
 477
 478         default:
 479             if( rValue.getLength() )
 480                 aAny <<= rValue;
 481             return aAny;
 482         }
 483
 484         const XMLPropertyHandler* pHandler = mrImport.GetShapeImport()->GetSdPropHdlFactory()->GetPropertyHandler( nType );
 485         if( pHandler )
 486             pHandler->importXML( rValue, aAny, mrImport.GetMM100UnitConverter() );
 487
 488         return aAny;
 489
 490 /*
 491         if( rValue.getLength() == 0 )
 492         {
 493             Any aAny;
 494             return aAny;
 495         }
 496         else if( rValue.indexOf( '#' ) == 0 )
 497         {
 498             // color
 499             Color aColor;
 500             SvXMLUnitConverter::convertColor( aColor, rValue );
 501
 502             return makeAny( static_cast< sal_Int32 >( aColor.GetRGBColor() ) );
 503         }
 504         else if( rValue.indexOf( '$' ) != -1 )
 505         {
 506             // formula
 507             return makeAny( rValue );
 508         }
 509         else
 510         {
 511             if( isDouble( rValue ) )
 512             {
 513                 return makeAny( rValue.toDouble() );
 514             }
 515             else
 516             {
 517                 return makeAny( rValue );
 518             }
 519         }
 520 */
 521     }
 522 }
 523
 524 Sequence< Any > AnimationsImportHelperImpl::convertValueSequence( XMLTokenEnum eAttributeName, const OUString& rValue )
 525 {
 526     Sequence< Any > aValues;
 527
 528     // do we have any value at all?
 529     if( rValue.getLength() )
 530     {
 531         sal_Int32 nElements = count_codes( rValue, (sal_Unicode)';') + 1; // a non empty string has at least one value
 532
 533         // prepare the sequence
 534         aValues.realloc( nElements );
 535
 536         // fill the sequence
 537         Any* pValues = aValues.getArray();
 538         sal_Int32 nIndex, nElement;
 539         for( nIndex = 0, nElement = 0; nElements && (nIndex >= 0); nElements-- )
 540         {
 541             *pValues++ = convertValue( eAttributeName, rValue.getToken( 0, ';', nIndex ) );
 542         }
 543     }
 544
 545     return aValues;
 546 }
 547
 548 Any AnimationsImportHelperImpl::convertTiming( const OUString& rValue )
 549 {
 550     Any aAny;
 551
 552     // do we have any value at all?
 553     if( rValue.getLength() )
 554     {
 555         // count the values
 556         sal_Int32 nElements = count_codes( rValue, (sal_Unicode)';' ) + 1; // a non empty string has at least one value
 557
 558         if( nElements == 1 )
 559         {
 560             if( IsXMLToken( rValue, XML_MEDIA ) )
 561             {
 562                 aAny <<= Timing_MEDIA;
 563             }
 564             else if( IsXMLToken( rValue, XML_INDEFINITE ) )
 565             {
 566                 aAny <<= Timing_INDEFINITE;
 567             }
 568             else if( isTime( rValue ) )
 569             {
 570                 aAny <<= rValue.toDouble();
 571             }
 572             else
 573             {
 574                 Event aEvent;
 575                 aEvent.Repeat = 0;
 576                 aEvent.Trigger = 0;
 577
 578                 OUString aEventTrigger;
 579
 580                 sal_Int32 nPos = rValue.indexOf( (sal_Unicode)'+' );
 581                 if( nPos == -1 )
 582                 {
 583                     aEventTrigger = rValue;
 584                 }
 585                 else
 586                 {
 587                     aEventTrigger = rValue.copy( 0, nPos );
 588
 589                     // convert offset
 590                     aEvent.Offset <<= convertTiming( rValue.copy( nPos + 1 ) );
 591                 }
 592
 593                 nPos = aEventTrigger.indexOf( (sal_Unicode)'.' );
 594                 if( nPos != -1 )
 595                 {
 596                     aEvent.Source <<= mrImport.getInterfaceToIdentifierMapper().getReference( aEventTrigger.copy( 0, nPos ) );
 597                     aEventTrigger = aEventTrigger.copy( nPos + 1 );
 598                 }
 599
 600                 sal_uInt16 nEnum;
 601                 if( SvXMLUnitConverter::convertEnum( nEnum, aEventTrigger, getAnimationsEnumMap(Animations_EnumMap_EventTrigger) ) )
 602                 {
 603                     aEvent.Trigger = (sal_Int16)nEnum;
 604                 }
 605                 else
 606                 {
 607                     DBG_ERROR("AnimationsImportHelperImpl::convertTiming(), unknown event trigger!");
 608                 }
 609
 610                 aAny <<= aEvent;
 611             }
 612         }
 613         else
 614         {
 615             // fill the sequence
 616             Sequence< Any > aValues( nElements );
 617             Any* pValues = aValues.getArray();
 618             sal_Int32 nIndex = 0;
 619             while( (nElements--) && (nIndex >= 0) )
 620                 *pValues++ = convertTiming( rValue.getToken( 0, ';', nIndex ) );
 621
 622             aAny <<= aValues;
 623         }
 624     }
 625     return aAny;
 626 }
 627
 628 Sequence< double > AnimationsImportHelperImpl::convertKeyTimes( const OUString& rValue )
 629 {
 630     sal_Int32 nElements = 0;
 631
 632     if( rValue.getLength() )
 633         nElements = count_codes( rValue, (sal_Unicode)';' ) + 1; // a non empty string has at least one value
 634
 635     Sequence< double > aKeyTimes( nElements );
 636
 637     if( nElements )
 638     {
 639         double* pValues = aKeyTimes.getArray();
 640         sal_Int32 nIndex = 0;
 641         while( (nElements--) && (nIndex >= 0) )
 642             *pValues++ = rValue.getToken( 0, ';', nIndex ).toDouble();
 643     }
 644
 645     return aKeyTimes;
 646 }
 647
 648 Sequence< TimeFilterPair > AnimationsImportHelperImpl::convertTimeFilter( const OUString& rValue )
 649 {
 650     sal_Int32 nElements = 0;
 651
 652     if( rValue.getLength() )
 653         nElements = count_codes( rValue, (sal_Unicode)';' ) + 1; // a non empty string has at least one value
 654
 655     Sequence< TimeFilterPair > aTimeFilter( nElements );
 656
 657     if( nElements )
 658     {
 659         TimeFilterPair* pValues = aTimeFilter.getArray();
 660         sal_Int32 nIndex = 0;
 661         while( (nElements--) && (nIndex >= 0) )
 662         {
 663             const OUString aToken( rValue.getToken( 0, ';', nIndex ) );
 664
 665             sal_Int32 nPos = aToken.indexOf( ',' );
 666             if( nPos >= 0 )
 667             {
 668                 pValues->Time = aToken.copy( 0, nPos ).toDouble();
 669                 pValues->Progress = aToken.copy( nPos+1, aToken.getLength() - nPos - 1 ).toDouble();
 670             }
 671             pValues++;
 672         }
 673     }
 674
 675     return aTimeFilter;
 676 }
 677
 678 Any AnimationsImportHelperImpl::convertPath( const OUString& rValue )
 679 {
 680     return makeAny( rValue );
 681 }
 682
 683 ///////////////////////////////////////////////////////////////////////
 684
 685 TYPEINIT1( AnimationNodeContext, SvXMLImportContext );
 686
 687 AnimationNodeContext::AnimationNodeContext(
 688         const Reference< XAnimationNode >& xParentNode,
 689         SvXMLImport& rImport, sal_uInt16 nPrfx, const rtl::OUString& rLocalName,
 690         const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList,
 691         AnimationsImportHelperImpl* pHelper /* = NULL */ )
 692 :       SvXMLImportContext(rImport, nPrfx, rLocalName),
 693     mpHelper( pHelper ),
 694     mbRootContext( pHelper == NULL )
 695 {
 696     try
 697     {
 698         if( mbRootContext )
 699         {
 700             mpHelper = new AnimationsImportHelperImpl( rImport );
 701             mxNode = xParentNode;
 702         }
 703         else
 704         {
 705             Reference< XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
 706
 707             sal_Int16 nPresetClass = EffectPresetClass::CUSTOM;
 708
 709             const sal_Char* pServiceName = 0;
 710
 711             sal_Int16 nNodeType = (sal_Int16)mpHelper->getAnimationNodeTokenMap().Get( nPrfx, rLocalName );
 712             switch( nNodeType )
 713             {
 714             case AnimationNodeType::SEQ:                                pServiceName = "com.sun.star.animations.SequenceTimeContainer"; break;
 715             case AnimationNodeType::ITERATE:                    pServiceName = "com.sun.star.animations.IterateContainer"; break;
 716             case AnimationNodeType::ANIMATE:                    pServiceName = "com.sun.star.animations.Animate"; break;
 717             case AnimationNodeType::SET:                                pServiceName = "com.sun.star.animations.AnimateSet"; break;
 718             case AnimationNodeType::ANIMATEMOTION:              pServiceName = "com.sun.star.animations.AnimateMotion"; break;
 719             case AnimationNodeType::ANIMATECOLOR:               pServiceName = "com.sun.star.animations.AnimateColor"; break;
 720             case AnimationNodeType::ANIMATETRANSFORM:   pServiceName = "com.sun.star.animations.AnimateTransform"; break;
 721             case AnimationNodeType::TRANSITIONFILTER:   pServiceName = "com.sun.star.animations.TransitionFilter"; break;
 722             case AnimationNodeType::AUDIO:                              pServiceName = "com.sun.star.animations.Audio"; break;
 723             case AnimationNodeType::COMMAND:                    pServiceName = "com.sun.star.animations.Command"; break;
 724             case AnimationNodeType::PAR:
 725                 {
 726                     const sal_Int16 nCount = xAttrList.is() ? xAttrList->getLength() : 0;
 727                     sal_Int16 nAttribute;
 728                     for( nAttribute = 0; nAttribute < nCount; nAttribute++ )
 729                     {
 730                         OUString aLocalName;
 731                         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttribute ), &aLocalName );
 732                         if( (nPrefix == XML_NAMESPACE_PRESENTATION) && IsXMLToken( aLocalName, XML_PRESET_ID ) )
 733                         {
 734                             const OUString& rValue = xAttrList->getValueByIndex( nAttribute );
 735                             if( rValue.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ooo-entrance-random" ) ) )
 736                             {
 737                                 nPresetClass = EffectPresetClass::ENTRANCE;
 738                             }
 739                             else if( rValue.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ooo-exit-random" ) ) )
 740                             {
 741                                 nPresetClass = EffectPresetClass::EXIT;
 742                             }
 743
 744                             if( nPresetClass != EffectPresetClass::CUSTOM )
 745                             {
 746                                 pServiceName = "com.sun.star.comp.sd.RandomAnimationNode";
 747                                 break;
 748                             }
 749                         }
 750                     }
 751                     if( !pServiceName )
 752                         pServiceName = "com.sun.star.animations.ParallelTimeContainer";
 753                 }
 754                 break;
 755             default:
 756                 pServiceName = 0;
 757             }
 758
 759             if( pServiceName && xFactory.is() )
 760             {
 761                 mxNode = Reference< XAnimationNode >( xFactory->createInstance(
 762                     OUString::createFromAscii(pServiceName) ), UNO_QUERY_THROW );
 763
 764                 if( nPresetClass != EffectPresetClass::CUSTOM )
 765                 {
 766                     Reference< XInitialization > xInit( mxNode, UNO_QUERY_THROW );
 767                     const Any aAny( makeAny( nPresetClass ) );
 768                     Sequence< Any > aArgs( &aAny, 1 ) ;
 769                     xInit->initialize( aArgs );
 770                 }
 771
 772                 init_node( xAttrList );
 773
 774                 Reference< XTimeContainer > xParentContainer( xParentNode, UNO_QUERY_THROW );
 775                 xParentContainer->appendChild( mxNode );
 776             }
 777         }
 778     }
 779     catch( RuntimeException& )
 780     {
 781         DBG_ERROR( "xmloff::AnimationsImportImpl::AnimationsImportImpl(), RuntimeException catched!" );
 782     }
 783 }
 784
 785 AnimationNodeContext::~AnimationNodeContext()
 786 {
 787     if( mbRootContext )
 788         delete mpHelper;
 789 }
 790
 791 void AnimationNodeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& )
 792 {
 793     // code of StartElement is moved to init_node that is now called
 794     // in c'tor before appending this node to its parent.
 795     // This is needed for random nodes that need the correct target
 796     // set when child nodes are appended.
 797 }
 798
 799 void AnimationNodeContext::init_node(  const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
 800 {
 801     if( mxNode.is() ) try
 802     {
 803         const sal_Int16 nNodeType = mxNode->getType();
 804
 805         // query for optional interfaces that are often used later
 806         Reference< XAnimate > xAnimate( mxNode, UNO_QUERY );
 807         Reference< XCommand > xCommand( mxNode, UNO_QUERY );
 808         Reference< XTransitionFilter > xTransitionFilter( mxNode, UNO_QUERY );
 809         Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
 810
 811         std::list< NamedValue > aUserData;
 812         XMLTokenEnum meAttributeName = XML_TOKEN_INVALID;
 813         OUString aFrom, aBy, aTo, aValues;
 814
 815         const sal_Int16 nCount = xAttrList.is() ? xAttrList->getLength() : 0;
 816         sal_uInt16 nEnum;
 817         sal_Int16 nAttribute;
 818         for( nAttribute = 0; nAttribute < nCount; nAttribute++ )
 819         {
 820             const OUString& rAttrName = xAttrList->getNameByIndex( nAttribute );
 821             const OUString& rValue = xAttrList->getValueByIndex( nAttribute );
 822
 823             OUString aLocalName;
 824             sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName );
 825             switch( mpHelper->getAnimationNodeAttributeTokenMap().Get( nPrefix, aLocalName ) )
 826             {
 827             case ANA_Begin:
 828             {
 829                 mxNode->setBegin( mpHelper->convertTiming( rValue ) );
 830             }
 831             break;
 832             case ANA_Dur:
 833             {
 834                 mxNode->setDuration( mpHelper->convertTiming( rValue ) );
 835             }
 836             break;
 837             case ANA_End:
 838             {
 839                 mxNode->setEnd( mpHelper->convertTiming( rValue ) );
 840             }
 841             break;
 842             case ANA_Fill:
 843             {
 844                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_Fill) ) )
 845                     mxNode->setFill( (sal_Int16)nEnum );
 846             }
 847             break;
 848             case ANA_FillDefault:
 849             {
 850                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_FillDefault) ) )
 851                     mxNode->setFillDefault( (sal_Int16)nEnum );
 852             }
 853             break;
 854             case ANA_Restart:
 855             {
 856                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_Restart) ) )
 857                     mxNode->setRestart( (sal_Int16)nEnum );
 858             }
 859             break;
 860             case ANA_RestartDefault:
 861             {
 862                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_RestartDefault) ) )
 863                     mxNode->setRestartDefault( (sal_Int16)nEnum );
 864             }
 865             break;
 866             case ANA_Accelerate:
 867             {
 868                 if( isDouble( rValue ) )
 869                     mxNode->setAcceleration( rValue.toDouble() );
 870             }
 871             break;
 872             case ANA_Decelerate:
 873             {
 874                 if( isDouble( rValue ) )
 875                     mxNode->setDecelerate( rValue.toDouble() );
 876             }
 877             break;
 878             case ANA_AutoReverse:
 879             {
 880                 sal_Bool bTemp;
 881                 if( SvXMLUnitConverter::convertBool( bTemp, rValue ) )
 882                     mxNode->setAutoReverse( bTemp  );
 883             }
 884             break;
 885             case ANA_RepeatCount:
 886             {
 887                 mxNode->setRepeatCount( mpHelper->convertTiming( rValue ) );
 888             }
 889             break;
 890             case ANA_RepeatDur:
 891             {
 892                 mxNode->setRepeatDuration( mpHelper->convertTiming( rValue ) );
 893             }
 894             break;
 895             case ANA_EndSync:
 896             {
 897                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_Endsync) ) )
 898                     mxNode->setEndSync( makeAny( (sal_Int16)nEnum ) );
 899             }
 900             break;
 901             case ANA_Node_Type:
 902             {
 903                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_EffectNodeType) ) )
 904                     aUserData.push_back( NamedValue( GetXMLToken( XML_NODE_TYPE ), makeAny( (sal_Int16)nEnum ) ) );
 905             }
 906             break;
 907             case ANA_Preset_ID:
 908             {
 909                 aUserData.push_back( NamedValue( GetXMLToken( XML_PRESET_ID ), makeAny( rValue ) ) );
 910             }
 911             break;
 912             case ANA_Preset_Sub_Type:
 913             {
 914                 aUserData.push_back( NamedValue( GetXMLToken( XML_PRESET_SUB_TYPE ), makeAny( rValue ) ) );
 915             }
 916             break;
 917             case ANA_Preset_Class:
 918             {
 919                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_EffectPresetClass) ) )
 920                     aUserData.push_back( NamedValue( GetXMLToken( XML_PRESET_CLASS ), makeAny( (sal_Int16)nEnum ) ) );
 921             }
 922             break;
 923             case ANA_After_Effect:
 924             {
 925                 sal_Bool bTemp;
 926                 if( SvXMLUnitConverter::convertBool( bTemp, rValue ) )
 927                     aUserData.push_back( NamedValue( GetXMLToken( XML_AFTER_EFFECT ), makeAny( bTemp ) ) );
 928             }
 929             break;
 930             case ANA_XLink:
 931             {
 932                 if( nNodeType == AnimationNodeType::AUDIO )
 933                 {
 934                     Reference< XAudio > xAudio( mxNode, UNO_QUERY_THROW );
 935                     xAudio->setSource( makeAny( GetImport().GetAbsoluteReference( rValue ) ) );
 936                     break;
 937                 }
 938
 939             }
 940             // fall through intented!
 941             case ANA_Target:
 942             {
 943                 {
 944                     Any aTarget( mpHelper->convertTarget( rValue ) );
 945
 946                     if( xAnimate.is() )
 947                     {
 948                         xAnimate->setTarget( aTarget );
 949                     }
 950                     else if( xIter.is() )
 951                     {
 952                         xIter->setTarget( aTarget );
 953                     }
 954                     else if( xCommand.is() )
 955                     {
 956                         xCommand->setTarget( aTarget );
 957                     }
 958                 }
 959             }
 960             break;
 961
 962             case ANA_Volume:
 963             {
 964                 if( nNodeType == AnimationNodeType::AUDIO )
 965                 {
 966                     if( isDouble( rValue ) )
 967                     {
 968                         Reference< XAudio > xAudio( mxNode, UNO_QUERY_THROW );
 969                         xAudio->setVolume( rValue.toDouble() );
 970                     }
 971                 }
 972             }
 973             break;
 974
 975             case ANA_MasterElement:
 976             {
 977                 Reference< XAnimationNode > xMaster( GetImport().getInterfaceToIdentifierMapper().getReference( rValue ), UNO_QUERY );
 978                 aUserData.push_back( NamedValue( GetXMLToken( XML_MASTER_ELEMENT ), makeAny( xMaster ) ) );
 979             }
 980             break;
 981
 982             case ANA_SubItem:
 983             {
 984                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_SubItem) ) )
 985                 {
 986                     if( xAnimate.is() )
 987                     {
 988                         xAnimate->setSubItem( (sal_Int16)nEnum );
 989                     }
 990                     else if( xIter.is() )
 991                     {
 992                         xIter->setSubItem( (sal_Int16)nEnum );
 993                     }
 994                 }
 995             }
 996             break;
 997
 998             case ANA_AttributeName:
 999             {
1000                 if( xAnimate.is() )
1001                 {
1002                     OUString aName( rValue );
1003
1004                     ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList();
1005                     while( p->mpAPIName )
1006                     {
1007                         if( IsXMLToken( aName, p->meXMLToken ) )
1008                         {
1009                             aName = OUString::createFromAscii( p->mpAPIName );
1010                             meAttributeName = p->meXMLToken;
1011                             break;
1012                         }
1013
1014                         p++;
1015                     }
1016
1017                     xAnimate->setAttributeName( aName );
1018                 }
1019             }
1020             break;
1021
1022             case ANA_Values:
1023             {
1024                 aValues = rValue;
1025             }
1026             break;
1027
1028             case ANA_From:
1029             {
1030                 aFrom = rValue;
1031             }
1032             break;
1033
1034             case ANA_By:
1035             {
1036                 aBy = rValue;
1037             }
1038             break;
1039
1040             case ANA_To:
1041             {
1042                 aTo = rValue;
1043             }
1044             break;
1045
1046             case ANA_KeyTimes:
1047             {
1048                 if( xAnimate.is() )
1049                     xAnimate->setKeyTimes( mpHelper->convertKeyTimes( rValue ) );
1050             }
1051             break;
1052
1053             case ANA_Formula:
1054             {
1055                 if( xAnimate.is() )
1056                     xAnimate->setFormula( rValue );
1057             }
1058             break;
1059
1060             case ANA_ID:
1061             {
1062                 if( rValue.getLength() )
1063                 {
1064                     Reference< XInterface > xRef( mxNode, UNO_QUERY );
1065                     GetImport().getInterfaceToIdentifierMapper().registerReference( rValue, xRef );
1066                 }
1067             }
1068             break;
1069
1070             case ANA_CalcMode:
1071             {
1072                 if( xAnimate.is() )
1073                 {
1074                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_CalcMode) ) )
1075                         xAnimate->setCalcMode( (sal_Int16)nEnum );
1076                 }
1077             }
1078             break;
1079
1080             case ANA_Accumulate:
1081             {
1082                 if( xAnimate.is() )
1083                     xAnimate->setAccumulate( IsXMLToken( rValue, XML_SUM ) );
1084             }
1085             break;
1086
1087             case ANA_AdditiveMode:
1088             {
1089                 if( xAnimate.is() )
1090                 {
1091                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_AdditiveMode) ) )
1092                         xAnimate->setAdditive( (sal_Int16)nEnum );
1093                 }
1094             }
1095             break;
1096
1097             case ANA_KeySplines:
1098             {
1099                 if( xAnimate.is() )
1100                     xAnimate->setTimeFilter( mpHelper->convertTimeFilter( rValue ) );
1101             }
1102             break;
1103
1104             case ANA_Path:
1105             {
1106                 Reference< XAnimateMotion > xAnimateMotion( mxNode, UNO_QUERY );
1107                 if( xAnimateMotion.is() )
1108                     xAnimateMotion->setPath( mpHelper->convertPath( rValue ) );
1109             }
1110             break;
1111
1112             case ANA_ColorSpace:
1113             {
1114                 Reference< XAnimateColor > xAnimateColor( mxNode, UNO_QUERY );
1115                 if( xAnimateColor.is() )
1116                     xAnimateColor->setColorInterpolation( IsXMLToken( rValue, XML_HSL ) ? AnimationColorSpace::HSL : AnimationColorSpace::RGB );
1117             }
1118             break;
1119
1120             case ANA_ColorDirection:
1121             {
1122                 Reference< XAnimateColor > xAnimateColor( mxNode, UNO_QUERY );
1123                 if( xAnimateColor.is() )
1124                     xAnimateColor->setDirection( IsXMLToken( rValue, XML_CLOCKWISE ) );
1125             }
1126             break;
1127
1128             case ANA_TransformType:
1129             {
1130                 Reference< XAnimateTransform > xTransform( mxNode, UNO_QUERY );
1131                 if( xTransform.is() )
1132                 {
1133                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_TransformType) ) )
1134                     {
1135                         xTransform->setTransformType( (sal_Int16)nEnum );
1136                         switch( nEnum )
1137                         {
1138                         case AnimationTransformType::SCALE: meAttributeName = XML_SCALE; break;
1139                         case AnimationTransformType::ROTATE: meAttributeName = XML_ROTATE; break;
1140                         case AnimationTransformType::SKEWX: meAttributeName = XML_SKEWX; break;
1141                         case AnimationTransformType::SKEWY: meAttributeName = XML_SKEWY; break;
1142                         //case AnimationTransformType::TRANSLATE:
1143                         default:
1144                             meAttributeName = XML_TRANSLATE; break;
1145                         }
1146                     }
1147                 }
1148             }
1149             break;
1150
1151             case ANA_TransitionType:
1152             {
1153                 if( xTransitionFilter.is() )
1154                 {
1155                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_TransitionType) ) )
1156                         xTransitionFilter->setTransition( (sal_Int16)nEnum );
1157                 }
1158             }
1159             break;
1160
1161             case ANA_TransitionSubType:
1162             {
1163                 if( xTransitionFilter.is() )
1164                 {
1165                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_TransitionSubType) ) )
1166                         xTransitionFilter->setSubtype( (sal_Int16)nEnum );
1167                 }
1168             }
1169             break;
1170
1171             case ANA_Mode:
1172             {
1173                 if( xTransitionFilter.is() )
1174                     xTransitionFilter->setMode( IsXMLToken( rValue, XML_IN ) );
1175             }
1176             break;
1177
1178             case ANA_Direction:
1179             {
1180                 if( xTransitionFilter.is() )
1181                     xTransitionFilter->setDirection( IsXMLToken( rValue, XML_FORWARD ) );
1182             }
1183             break;
1184
1185             case ANA_FadeColor:
1186             {
1187                 if( xTransitionFilter.is() )
1188                 {
1189                     Color aColor;
1190                     SvXMLUnitConverter::convertColor( aColor, rValue );
1191                     xTransitionFilter->setFadeColor( static_cast< sal_Int32 >( aColor.GetRGBColor() ) );
1192                 }
1193             }
1194             break;
1195
1196             case ANA_IterateType:
1197             {
1198                 if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_IterateType) ) )
1199                 {
1200                     if( xIter.is() )
1201                         xIter->setIterateType( (sal_Int16)nEnum );
1202                 }
1203             }
1204             break;
1205
1206             case ANA_IterateInterval:
1207             {
1208                 if( xIter.is() )
1209                 {
1210                     double fInterval = 0.0;
1211                     if( rValue.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("P")) )
1212                     {
1213                         ::Time aTime;
1214                         sal_Int32 nSecondsFraction = 0;
1215                         if( SvXMLUnitConverter::convertTimeDuration( rValue, aTime, &nSecondsFraction ) )
1216                         {
1217                             fInterval = ((((aTime.GetHour() * 60) + aTime.GetMin()) * 60) + aTime.GetSec()) + (nSecondsFraction / 1000.0);
1218                         }
1219                     }
1220                     else
1221                     {
1222                         fInterval = rValue.toDouble();
1223                     }
1224
1225                     xIter->setIterateInterval( fInterval );
1226                 }
1227             }
1228             break;
1229
1230             case ANA_Group_Id:
1231             {
1232                 aUserData.push_back( NamedValue( aLocalName, makeAny( rValue.toInt32() ) ) );
1233             }
1234             break;
1235
1236             case ANA_Command:
1237             {
1238                 if( xCommand.is() && nNodeType == AnimationNodeType::COMMAND )
1239                 {
1240                     if( SvXMLUnitConverter::convertEnum( nEnum, rValue, getAnimationsEnumMap(Animations_EnumMap_Command) ) )
1241                     {
1242                         xCommand->setCommand( (sal_Int16)nEnum );
1243                     }
1244                 }
1245             }
1246             break;
1247
1248             default:
1249                 // push all unknown attributes within the presentation namespace as user data
1250                 if( nPrefix == XML_NAMESPACE_PRESENTATION )
1251                 {
1252                     aUserData.push_back( NamedValue( aLocalName, makeAny( rValue ) ) );
1253                 }
1254             }
1255         }
1256
1257         sal_Int32 nUserDataCount = aUserData.size();
1258         if( nUserDataCount )
1259         {
1260             Sequence< NamedValue > aUnoUserData( nUserDataCount );
1261             NamedValue* pData = aUnoUserData.getArray();
1262             std::list< NamedValue >::iterator aIter( aUserData.begin() );
1263             const std::list< NamedValue >::iterator aEnd( aUserData.end() );
1264             while( aIter != aEnd )
1265                 *pData++ = (*aIter++);
1266
1267             mxNode->setUserData( aUnoUserData );
1268         }
1269
1270         // convert values
1271         if( xAnimate.is() )
1272         {
1273             if( aFrom.getLength() )
1274                 xAnimate->setFrom( mpHelper->convertValue( meAttributeName, aFrom ) );
1275
1276             if( aBy.getLength() )
1277                 xAnimate->setBy( mpHelper->convertValue( meAttributeName, aBy ) );
1278
1279             if( aTo.getLength() )
1280                 xAnimate->setTo( mpHelper->convertValue( meAttributeName, aTo ) );
1281
1282             if( aValues.getLength() )
1283                 xAnimate->setValues( mpHelper->convertValueSequence( meAttributeName, aValues ) );
1284         }
1285     }
1286     catch( RuntimeException& )
1287     {
1288         DBG_ERROR( "xmloff::AnimationNodeContext::StartElement(), RuntimeException catched!" );
1289     }
1290 }
1291
1292 SvXMLImportContext * AnimationNodeContext::CreateChildContext( USHORT nPrefix, const ::rtl::OUString& rLocalName,
1293         const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList )
1294 {
1295     if( mxNode.is())
1296         return new AnimationNodeContext( mxNode, GetImport(), nPrefix, rLocalName, xAttrList, mpHelper );
1297     else
1298         return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1299 }
1300
1301 // --------------------------------------------------------------------
1302
1303 class AnimationsImport: public SvXMLImport, public XAnimationNodeSupplier
1304 {
1305 public:
1306     AnimationsImport( const Reference< XMultiServiceFactory > & rSMgr );
1307     ~AnimationsImport() throw ();
1308
1309     SvXMLImportContext* CreateContext(USHORT nPrefix, const OUString& rLocalName,       const Reference<XAttributeList>& xAttrList);
1310
1311     // XInterface
1312     virtual Any SAL_CALL queryInterface( const Type& aType ) throw (RuntimeException);
1313     virtual void SAL_CALL acquire() throw ();
1314     virtual void SAL_CALL release() throw ();
1315
1316     // XAnimationNodeSupplier
1317     Reference< XAnimationNode > SAL_CALL getAnimationNode() throw (RuntimeException);
1318
1319     // XServiceInfo
1320     virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
1321     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
1322     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
1323
1324 private:
1325     Reference< XAnimationNode > mxRootNode;
1326 };
1327
1328 AnimationsImport::AnimationsImport( const Reference< XMultiServiceFactory > & rSMgr )
1329 : SvXMLImport( rSMgr, true )
1330 {
1331     // add namespaces
1332     GetNamespaceMap().Add(
1333         GetXMLToken(XML_NP_PRESENTATION),
1334         GetXMLToken(XML_N_PRESENTATION),
1335         XML_NAMESPACE_PRESENTATION);
1336
1337     GetNamespaceMap().Add(
1338         GetXMLToken(XML_NP_SMIL),
1339         GetXMLToken(XML_N_SMIL),
1340         XML_NAMESPACE_SMIL);
1341
1342     GetNamespaceMap().Add(
1343         GetXMLToken(XML_NP_ANIMATION),
1344         GetXMLToken(XML_N_ANIMATION),
1345         XML_NAMESPACE_ANIMATION);
1346
1347     mxRootNode = Reference< XAnimationNode >::query(rSMgr->createInstance(
1348         OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))));
1349 }
1350
1351 AnimationsImport::~AnimationsImport() throw ()
1352 {
1353 }
1354
1355 // XInterface
1356 Any SAL_CALL AnimationsImport::queryInterface( const Type& aType ) throw (RuntimeException)
1357 {
1358     if ( aType == ::getCppuType((Reference<XAnimationNodeSupplier> *)0) )
1359     {
1360         return makeAny( Reference<XAnimationNodeSupplier>( this ) );
1361     }
1362     else
1363     {
1364         return SvXMLImport::queryInterface( aType );
1365     }
1366 }
1367
1368 void SAL_CALL AnimationsImport::acquire() throw ()
1369 {
1370     SvXMLImport::acquire();
1371 }
1372
1373 void SAL_CALL AnimationsImport::release() throw ()
1374 {
1375     SvXMLImport::release();
1376 }
1377
1378 SvXMLImportContext *AnimationsImport::CreateContext(USHORT nPrefix, const OUString& rLocalName, const Reference<XAttributeList>& xAttrList)
1379 {
1380     SvXMLImportContext* pContext = 0;
1381
1382     if( (XML_NAMESPACE_ANIMATION == nPrefix) && IsXMLToken( rLocalName, XML_SEQ ) )
1383     {
1384          pContext = new AnimationNodeContext( mxRootNode, *this, nPrefix, rLocalName, xAttrList );
1385     }
1386     else
1387     {
1388         pContext = SvXMLImport::CreateContext(nPrefix, rLocalName, xAttrList);
1389     }
1390
1391     return pContext;
1392 }
1393
1394 // XAnimationNodeSupplier
1395 Reference< XAnimationNode > SAL_CALL AnimationsImport::getAnimationNode() throw (RuntimeException)
1396 {
1397     return mxRootNode;
1398 }
1399
1400 void AnimationNodeContext::postProcessRootNode( SvXMLImport& /*rImport*/, const Reference< XAnimationNode >& xRootNode, Reference< XPropertySet >& xPageProps )
1401 {
1402     if( xRootNode.is() && xPageProps.is() ) try
1403     {
1404         Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
1405         Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1406         if( xEnumeration->hasMoreElements() )
1407         {
1408             Reference< XAnimationNode > xNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
1409             if( xNode->getType() == AnimationNodeType::PAR )
1410             {
1411                 Event aEvent;
1412                 if( (xNode->getBegin() >>= aEvent) && (aEvent.Trigger == EventTrigger::BEGIN_EVENT) )
1413                 {
1414                     // found transition node
1415                     Reference< XEnumerationAccess > xChildEnumerationAccess( xNode, UNO_QUERY_THROW );
1416                     Reference< XEnumeration > xChildEnumeration( xChildEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1417                     while( xChildEnumeration->hasMoreElements() )
1418                     {
1419                         Reference< XAnimationNode > xChildNode( xChildEnumeration->nextElement(), UNO_QUERY_THROW );
1420                         switch( xChildNode->getType() )
1421                         {
1422                         case AnimationNodeType::TRANSITIONFILTER:
1423                         {
1424                             Reference< XTransitionFilter > xTransFilter( xChildNode, UNO_QUERY_THROW );
1425
1426
1427                             xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionType" ) ), Any( xTransFilter->getTransition() ) );
1428                             xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionSubtype" ) ), Any( xTransFilter->getSubtype() ) );
1429                             xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionDirection" ) ), Any( xTransFilter->getDirection() ) );
1430                             xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionFadeColor" ) ), Any( xTransFilter->getFadeColor() ) );
1431
1432                             double fDuration;
1433                             if( xTransFilter->getDuration() >>= fDuration )
1434                                 xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TransitionDuration" ) ), Any( fDuration ) );
1435
1436                         }
1437                         break;
1438
1439                         case AnimationNodeType::COMMAND:
1440                         {
1441                             Reference< XCommand > xCommand( xChildNode, UNO_QUERY_THROW );
1442                             if( xCommand->getCommand() == EffectCommands::STOPAUDIO )
1443                             {
1444                                 xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ), Any(sal_True) );
1445                             }
1446                         }
1447                         break;
1448
1449                         case AnimationNodeType::AUDIO:
1450                         {
1451                             Reference< XAudio > xAudio( xChildNode, UNO_QUERY_THROW );
1452                             OUString sSoundURL;
1453                             if( (xAudio->getSource() >>= sSoundURL) && (sSoundURL.getLength() != 0) )
1454                             {
1455                                 xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ), Any(sSoundURL) );
1456
1457                                 Timing eTiming;
1458                                 if( (xAudio->getRepeatCount() >>= eTiming) && (eTiming == Timing_INDEFINITE) )
1459                                     xPageProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "LoopSound" ) ), Any( sal_True ) );
1460                             }
1461                         }
1462                         break;
1463
1464                         }
1465                     }
1466
1467                     Reference< XTimeContainer > xRootContainer( xRootNode, UNO_QUERY_THROW );
1468                     xRootContainer->removeChild( xNode );
1469                 }
1470             }
1471         }
1472     }
1473     catch( Exception& )
1474     {
1475         DBG_ERROR("xmloff::AnimationsImport::postProcessRootNode(), exception caught!");
1476     }
1477 }
1478
1479 } // namespace xmloff
1480
1481 Sequence< OUString > SAL_CALL AnimationsImport_getSupportedServiceNames() throw()
1482 {
1483     const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Xmloff.AnimationsImport" ) );
1484     const Sequence< OUString > aSeq( &aServiceName, 1 );
1485     return aSeq;
1486 }
1487
1488 OUString SAL_CALL AnimationsImport_getImplementationName() throw()
1489 {
1490     return OUString( RTL_CONSTASCII_USTRINGPARAM( "xmloff::AnimationsImport" ) );
1491 }
1492
1493 Reference< XInterface > SAL_CALL AnimationsImport_createInstance(const Reference< XMultiServiceFactory > & rSMgr) throw( Exception )
1494 {
1495     return (cppu::OWeakObject*)new xmloff::AnimationsImport( rSMgr );
1496
1497 }
1498
1499 namespace xmloff
1500 {
1501
1502 OUString SAL_CALL AnimationsImport::getImplementationName() throw(RuntimeException)
1503 {
1504     return AnimationsImport_getImplementationName();
1505 }
1506
1507 sal_Bool SAL_CALL AnimationsImport::supportsService( const OUString& ServiceName ) throw(RuntimeException)
1508 {
1509     return ServiceName.equalsAscii( "com.sun.star.comp.Xmloff.AnimationsImport" );
1510 }
1511
1512 Sequence< OUString > SAL_CALL AnimationsImport::getSupportedServiceNames() throw(RuntimeException)
1513 {
1514     return AnimationsImport_getSupportedServiceNames();
1515 }
1516
1517 } // namespace xmloff
1518