animations/source/animcore/animcore.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/util/XCloneable.hpp>
  21 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  22 #include <com/sun/star/lang/XServiceInfo.hpp>
  23 #include <com/sun/star/lang/XTypeProvider.hpp>
  24 #include <com/sun/star/animations/XAnimateColor.hpp>
  25 #include <com/sun/star/animations/XAnimateSet.hpp>
  26 #include <com/sun/star/animations/XAnimateMotion.hpp>
  27 #include <com/sun/star/animations/XAnimatePhysics.hpp>
  28 #include <com/sun/star/animations/XAnimateTransform.hpp>
  29 #include <com/sun/star/animations/XParallelTimeContainer.hpp>
  30 #include <com/sun/star/animations/XTransitionFilter.hpp>
  31 #include <com/sun/star/animations/XTimeContainer.hpp>
  32 #include <com/sun/star/animations/XIterateContainer.hpp>
  33 #include <com/sun/star/animations/XAudio.hpp>
  34 #include <com/sun/star/animations/XCommand.hpp>
  35 #include <com/sun/star/animations/AnimationNodeType.hpp>
  36 #include <com/sun/star/animations/AnimationCalcMode.hpp>
  37 #include <com/sun/star/animations/AnimationFill.hpp>
  38 #include <com/sun/star/animations/AnimationRestart.hpp>
  39 #include <com/sun/star/animations/AnimationColorSpace.hpp>
  40 #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
  41 #include <com/sun/star/animations/AnimationTransformType.hpp>
  42 #include <com/sun/star/animations/TransitionType.hpp>
  43 #include <com/sun/star/animations/TransitionSubType.hpp>
  44 #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
  45 #include <com/sun/star/container/ElementExistException.hpp>
  46 #include <com/sun/star/container/XEnumerationAccess.hpp>
  47 #include <com/sun/star/util/XChangesNotifier.hpp>
  48 #include <cppuhelper/queryinterface.hxx>
  49 #include <comphelper/interfacecontainer4.hxx>
  50 #include <cppuhelper/supportsservice.hxx>
  51
  52 #include <cppuhelper/implbase.hxx>
  53
  54 #include <sal/log.hxx>
  55 #include <unotools/weakref.hxx>
  56 #include <array>
  57 #include <mutex>
  58 #include <vector>
  59 #include <algorithm>
  60
  61 namespace com::sun::star::uno { class XComponentContext; }
  62 namespace com::sun::star::beans { struct NamedValue; }
  63
  64 using ::comphelper::OInterfaceContainerHelper4;
  65 using ::comphelper::OInterfaceIteratorHelper4;
  66 using ::com::sun::star::uno::Any;
  67 using ::com::sun::star::uno::UNO_QUERY;
  68 using ::com::sun::star::uno::XInterface;
  69 using ::com::sun::star::uno::Sequence;
  70 using ::com::sun::star::uno::Reference;
  71 using ::com::sun::star::uno::Exception;
  72 using ::com::sun::star::uno::XWeak;
  73 using ::com::sun::star::uno::Type;
  74 using ::com::sun::star::uno::Any;
  75 using ::com::sun::star::lang::IllegalArgumentException;
  76 using ::com::sun::star::lang::XServiceInfo;
  77 using ::com::sun::star::lang::XTypeProvider;
  78 using ::com::sun::star::container::NoSuchElementException;
  79 using ::com::sun::star::container::ElementExistException;
  80 using ::com::sun::star::container::XEnumeration;
  81 using ::com::sun::star::container::XEnumerationAccess;
  82 using ::com::sun::star::beans::NamedValue;
  83 using ::com::sun::star::util::XCloneable;
  84 using ::com::sun::star::util::XChangesNotifier;
  85 using ::com::sun::star::util::XChangesListener;
  86 using ::com::sun::star::util::ElementChange;
  87 using ::com::sun::star::util::ChangesEvent;
  88
  89 using ::cppu::OWeakObject;
  90
  91 using namespace ::com::sun::star::animations;
  92 using namespace ::com::sun::star::animations::AnimationNodeType;
  93
  94 namespace animcore
  95 {
  96
  97 namespace {
  98 class AnimationNodeBase :   public XAnimateMotion,
  99                             public XAnimatePhysics,
 100                             public XAnimateColor,
 101                             public XTransitionFilter,
 102                             public XAnimateSet,
 103                             public XAnimateTransform,
 104                             public XParallelTimeContainer,
 105                             public XIterateContainer,
 106                             public XServiceInfo,
 107                             public XTypeProvider,
 108                             public XAudio,
 109                             public XCommand,
 110                             public XCloneable,
 111                             public XChangesNotifier,
 112                             public OWeakObject
 113 {
 114
 115 };
 116
 117 class AnimationNode final:  public AnimationNodeBase
 118 {
 119 public:
 120     explicit AnimationNode(sal_Int16 nNodeType);
 121     explicit AnimationNode(const AnimationNode& rNode);
 122
 123     // XInterface
 124     virtual Any SAL_CALL queryInterface( const Type& aType ) override;
 125     virtual void SAL_CALL acquire() noexcept override;
 126     virtual void SAL_CALL release() noexcept override;
 127
 128     // XTypeProvider
 129     virtual Sequence< Type > SAL_CALL getTypes() override;
 130     virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() override;
 131
 132     // XServiceInfo
 133     OUString SAL_CALL getImplementationName() override;
 134     Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 135     sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
 136
 137     // XChild
 138     virtual Reference< XInterface > SAL_CALL getParent() override;
 139     virtual void SAL_CALL setParent( const Reference< XInterface >& Parent ) override;
 140
 141     // XCloneable
 142     virtual Reference< XCloneable > SAL_CALL createClone() override;
 143
 144     // XAnimationNode
 145     virtual sal_Int16 SAL_CALL getType() override;
 146     virtual Any SAL_CALL getBegin() override;
 147     virtual void SAL_CALL setBegin( const Any& _begin ) override;
 148     virtual Any SAL_CALL getDuration() override;
 149     virtual void SAL_CALL setDuration( const Any& _duration ) override;
 150     virtual Any SAL_CALL getEnd() override;
 151     virtual void SAL_CALL setEnd( const Any& _end ) override;
 152     virtual Any SAL_CALL getEndSync() override;
 153     virtual void SAL_CALL setEndSync( const Any& _endsync ) override;
 154     virtual Any SAL_CALL getRepeatCount() override;
 155     virtual void SAL_CALL setRepeatCount( const Any& _repeatcount ) override;
 156     virtual Any SAL_CALL getRepeatDuration() override;
 157     virtual void SAL_CALL setRepeatDuration( const Any& _repeatduration ) override;
 158     virtual sal_Int16 SAL_CALL getFill() override;
 159     virtual void SAL_CALL setFill( sal_Int16 _fill ) override;
 160     virtual sal_Int16 SAL_CALL getFillDefault() override;
 161     virtual void SAL_CALL setFillDefault( sal_Int16 _filldefault ) override;
 162     virtual sal_Int16 SAL_CALL getRestart() override;
 163     virtual void SAL_CALL setRestart( sal_Int16 _restart ) override;
 164     virtual sal_Int16 SAL_CALL getRestartDefault() override;
 165     virtual void SAL_CALL setRestartDefault( sal_Int16 _restartdefault ) override;
 166     virtual double SAL_CALL getAcceleration() override;
 167     virtual void SAL_CALL setAcceleration( double _acceleration ) override;
 168     virtual double SAL_CALL getDecelerate() override;
 169     virtual void SAL_CALL setDecelerate( double _decelerate ) override;
 170     virtual sal_Bool SAL_CALL getAutoReverse() override;
 171     virtual void SAL_CALL setAutoReverse( sal_Bool _autoreverse ) override;
 172     virtual Sequence< NamedValue > SAL_CALL getUserData() override;
 173     virtual void SAL_CALL setUserData( const Sequence< NamedValue >& _userdata ) override;
 174
 175     // XAnimate
 176     virtual Any SAL_CALL getTarget() override;
 177     virtual void SAL_CALL setTarget( const Any& _target ) override;
 178     virtual sal_Int16 SAL_CALL getSubItem() override;
 179     virtual void SAL_CALL setSubItem( sal_Int16 _subitem ) override;
 180     virtual OUString SAL_CALL getAttributeName() override;
 181     virtual void SAL_CALL setAttributeName( const OUString& _attribute ) override;
 182     virtual Sequence< Any > SAL_CALL getValues() override;
 183     virtual void SAL_CALL setValues( const Sequence< Any >& _values ) override;
 184     virtual Sequence< double > SAL_CALL getKeyTimes() override;
 185     virtual void SAL_CALL setKeyTimes( const Sequence< double >& _keytimes ) override;
 186     virtual sal_Int16 SAL_CALL getValueType() override;
 187     virtual void SAL_CALL setValueType( sal_Int16 _valuetype ) override;
 188     virtual sal_Int16 SAL_CALL getCalcMode() override;
 189     virtual void SAL_CALL setCalcMode( sal_Int16 _calcmode ) override;
 190     virtual sal_Bool SAL_CALL getAccumulate() override;
 191     virtual void SAL_CALL setAccumulate( sal_Bool _accumulate ) override;
 192     virtual sal_Int16 SAL_CALL getAdditive() override;
 193     virtual void SAL_CALL setAdditive( sal_Int16 _additive ) override;
 194     virtual Any SAL_CALL getFrom() override;
 195     virtual void SAL_CALL setFrom( const Any& _from ) override;
 196     virtual Any SAL_CALL getTo() override;
 197     virtual void SAL_CALL setTo( const Any& _to ) override;
 198     virtual Any SAL_CALL getBy() override;
 199     virtual void SAL_CALL setBy( const Any& _by ) override;
 200     virtual Sequence< TimeFilterPair > SAL_CALL getTimeFilter() override;
 201     virtual void SAL_CALL setTimeFilter( const Sequence< TimeFilterPair >& _timefilter ) override;
 202     virtual OUString SAL_CALL getFormula() override;
 203     virtual void SAL_CALL setFormula( const OUString& _formula ) override;
 204
 205     // XAnimateColor
 206     virtual sal_Int16 SAL_CALL getColorInterpolation() override;
 207     virtual void SAL_CALL setColorInterpolation( sal_Int16 _colorspace ) override;
 208     virtual sal_Bool SAL_CALL getDirection() override;
 209     virtual void SAL_CALL setDirection( sal_Bool _direction ) override;
 210
 211     // XAnimateMotion
 212     virtual Any SAL_CALL getPath() override;
 213     virtual void SAL_CALL setPath( const Any& _path ) override;
 214     virtual Any SAL_CALL getOrigin() override;
 215     virtual void SAL_CALL setOrigin( const Any& _origin ) override;
 216
 217     // XAnimatePhysics
 218     virtual Any SAL_CALL getStartVelocityX() override;
 219     virtual void SAL_CALL setStartVelocityX( const Any& _startvelocityx ) override;
 220     virtual Any SAL_CALL getStartVelocityY() override;
 221     virtual void SAL_CALL setStartVelocityY( const Any& _startvelocityy ) override;
 222     virtual Any SAL_CALL getDensity() override;
 223     virtual void SAL_CALL setDensity( const Any& _density ) override;
 224     virtual Any SAL_CALL getBounciness() override;
 225     virtual void SAL_CALL setBounciness( const Any& _bounciness ) override;
 226
 227     // XAnimateTransform
 228     virtual sal_Int16 SAL_CALL getTransformType() override;
 229     virtual void SAL_CALL setTransformType( sal_Int16 _transformtype ) override;
 230
 231     // XTransitionFilter
 232     virtual sal_Int16 SAL_CALL getTransition() override;
 233     virtual void SAL_CALL setTransition( sal_Int16 _transition ) override;
 234     virtual sal_Int16 SAL_CALL getSubtype() override;
 235     virtual void SAL_CALL setSubtype( sal_Int16 _subtype ) override;
 236     virtual sal_Bool SAL_CALL getMode() override;
 237     virtual void SAL_CALL setMode( sal_Bool _mode ) override;
 238     virtual sal_Int32 SAL_CALL getFadeColor() override;
 239     virtual void SAL_CALL setFadeColor( sal_Int32 _fadecolor ) override;
 240
 241     // XAudio
 242     virtual Any SAL_CALL getSource() override;
 243     virtual void SAL_CALL setSource( const Any& _source ) override;
 244     virtual double SAL_CALL getVolume() override;
 245     virtual void SAL_CALL setVolume( double _volume ) override;
 246     sal_Bool SAL_CALL getHideDuringShow() override;
 247     void SAL_CALL setHideDuringShow(sal_Bool bHideDuringShow) override;
 248     sal_Bool SAL_CALL getNarration() override;
 249     void SAL_CALL setNarration(sal_Bool bNarration) override;
 250
 251
 252     // XCommand - the following two shadowed by animate, unfortunately
 253 //    virtual Any SAL_CALL getTarget() throw (RuntimeException);
 254 //    virtual void SAL_CALL setTarget( const Any& _target ) throw (RuntimeException);
 255     virtual sal_Int16 SAL_CALL getCommand() override;
 256     virtual void SAL_CALL setCommand( sal_Int16 _command ) override;
 257     virtual Any SAL_CALL getParameter() override;
 258     virtual void SAL_CALL setParameter( const Any& _parameter ) override;
 259
 260     // XElementAccess
 261     virtual Type SAL_CALL getElementType() override;
 262     virtual sal_Bool SAL_CALL hasElements() override;
 263
 264     // XEnumerationAccess
 265     virtual Reference< XEnumeration > SAL_CALL createEnumeration() override;
 266
 267     // XTimeContainer
 268     virtual Reference< XAnimationNode > SAL_CALL insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) override;
 269     virtual Reference< XAnimationNode > SAL_CALL insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) override;
 270     virtual Reference< XAnimationNode > SAL_CALL replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& oldChild ) override;
 271     virtual Reference< XAnimationNode > SAL_CALL removeChild( const Reference< XAnimationNode >& oldChild ) override;
 272     virtual Reference< XAnimationNode > SAL_CALL appendChild( const Reference< XAnimationNode >& newChild ) override;
 273
 274     // XIterateContainer
 275     virtual sal_Int16 SAL_CALL getIterateType() override;
 276     virtual void SAL_CALL setIterateType( sal_Int16 _iteratetype ) override;
 277     virtual double SAL_CALL getIterateInterval() override;
 278     virtual void SAL_CALL setIterateInterval( double _iterateinterval ) override;
 279
 280     // XChangesNotifier
 281     virtual void SAL_CALL addChangesListener( const Reference< XChangesListener >& aListener ) override;
 282     virtual void SAL_CALL removeChangesListener( const Reference< XChangesListener >& aListener ) override;
 283
 284     void fireChangeListener(std::unique_lock<std::mutex>&);
 285
 286 private:
 287     std::mutex m_aMutex;
 288     OInterfaceContainerHelper4<XChangesListener>   maChangeListener;
 289
 290     static void initTypeProvider( sal_Int16 nNodeType ) noexcept;
 291
 292     const sal_Int16 mnNodeType;
 293
 294     // for XTypeProvider
 295     static std::array<Sequence< Type >*, 13> mpTypes;
 296
 297     // attributes for the XAnimationNode interface implementation
 298     Any maBegin, maDuration, maEnd, maEndSync, maRepeatCount, maRepeatDuration;
 299     sal_Int16 mnFill, mnFillDefault, mnRestart, mnRestartDefault;
 300     double mfAcceleration, mfDecelerate;
 301     bool mbAutoReverse;
 302     Sequence< NamedValue > maUserData;
 303
 304     // parent interface for XChild interface implementation
 305     unotools::WeakReference<AnimationNode> mxParent;
 306
 307     // attributes for XAnimate
 308     Any maTarget;
 309     OUString maAttributeName, maFormula;
 310     Sequence< Any > maValues;
 311     Sequence< double > maKeyTimes;
 312     sal_Int16 mnValueType, mnSubItem;
 313     sal_Int16 mnCalcMode, mnAdditive;
 314     bool mbAccumulate;
 315     Any maFrom, maTo, maBy;
 316     Sequence< TimeFilterPair > maTimeFilter;
 317
 318     // attributes for XAnimateColor
 319     sal_Int16 mnColorSpace;
 320     bool mbDirection;
 321
 322     // attributes for XAnimateMotion
 323     Any maPath, maOrigin;
 324
 325     // attributes for XAnimatePhysics
 326     Any maStartVelocityX, maStartVelocityY, maDensity, maBounciness;
 327
 328     // attributes for XAnimateTransform
 329     sal_Int16 mnTransformType;
 330
 331     // attributes for XTransitionFilter
 332     sal_Int16 mnTransition;
 333     sal_Int16 mnSubtype;
 334     bool mbMode;
 335     sal_Int32 mnFadeColor;
 336
 337     // XAudio
 338     double mfVolume;
 339     bool mbHideDuringShow;
 340     bool mbNarration;
 341
 342     // XCommand
 343     sal_Int16 mnCommand;
 344     Any maParameter;
 345
 346     // XIterateContainer
 347     sal_Int16 mnIterateType;
 348     double  mfIterateInterval;
 349
 350     /** sorted list of child nodes for XTimeContainer*/
 351     std::vector< Reference< XAnimationNode > > maChildren;
 352 };
 353
 354
 355 class TimeContainerEnumeration : public ::cppu::WeakImplHelper< XEnumeration >
 356 {
 357 public:
 358     explicit TimeContainerEnumeration( std::vector< Reference< XAnimationNode > >&& rChildren );
 359
 360     // Methods
 361     virtual sal_Bool SAL_CALL hasMoreElements() override;
 362     virtual Any SAL_CALL nextElement(  ) override;
 363
 364 private:
 365     std::mutex m_aMutex;
 366
 367     /** sorted list of child nodes */
 368     std::vector< Reference< XAnimationNode > > maChildren;
 369
 370     /** current iteration position */
 371     std::vector< Reference< XAnimationNode > >::iterator   maIter;
 372 };
 373
 374 }
 375
 376 TimeContainerEnumeration::TimeContainerEnumeration( std::vector< Reference< XAnimationNode > >&& rChildren )
 377 : maChildren( std::move(rChildren) )
 378 {
 379     maIter = maChildren.begin();
 380 }
 381
 382 // Methods
 383 sal_Bool SAL_CALL TimeContainerEnumeration::hasMoreElements()
 384 {
 385     std::unique_lock aGuard( m_aMutex );
 386
 387     return maIter != maChildren.end();
 388 }
 389
 390 Any SAL_CALL TimeContainerEnumeration::nextElement()
 391 {
 392     std::unique_lock aGuard( m_aMutex );
 393
 394     if( maIter == maChildren.end() )
 395         throw NoSuchElementException();
 396
 397     return Any( *maIter++ );
 398 }
 399
 400
 401 std::array<Sequence< Type >*, 13> AnimationNode::mpTypes = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
 402
 403 AnimationNode::AnimationNode( sal_Int16 nNodeType )
 404 :   AnimationNodeBase(),
 405     mnNodeType( nNodeType ),
 406     mnFill( AnimationFill::DEFAULT ),
 407     mnFillDefault( AnimationFill::INHERIT ),
 408     mnRestart( AnimationRestart:: DEFAULT ),
 409     mnRestartDefault( AnimationRestart:: INHERIT ),
 410     mfAcceleration( 0.0 ),
 411     mfDecelerate( 0.0 ),
 412     mbAutoReverse( false ),
 413     mnValueType( 0 ),
 414     mnSubItem( 0 ),
 415     mnCalcMode( (nNodeType == AnimationNodeType::ANIMATEMOTION) ? AnimationCalcMode::PACED : AnimationCalcMode::LINEAR),
 416     mnAdditive(AnimationAdditiveMode::REPLACE),
 417     mbAccumulate(false),
 418     mnColorSpace( AnimationColorSpace::RGB ),
 419     mbDirection( true ),
 420     mnTransformType( AnimationTransformType::TRANSLATE ),
 421     mnTransition(TransitionType::BARWIPE),
 422     mnSubtype(TransitionSubType::DEFAULT),
 423     mbMode(true),
 424     mnFadeColor(0),
 425     mfVolume(1.0),
 426     mbHideDuringShow(false),
 427     mbNarration(false),
 428     mnCommand(0),
 429     mnIterateType( css::presentation::ShapeAnimationSubType::AS_WHOLE ),
 430     mfIterateInterval(0.0)
 431 {
 432     assert(nNodeType >= 0 && o3tl::make_unsigned(nNodeType) < mpTypes.size());
 433 }
 434
 435 AnimationNode::AnimationNode( const AnimationNode& rNode )
 436 :   AnimationNodeBase(),
 437     mnNodeType( rNode.mnNodeType ),
 438
 439     // attributes for the XAnimationNode interface implementation
 440     maBegin( rNode.maBegin ),
 441     maDuration( rNode.maDuration ),
 442     maEnd( rNode.maEnd ),
 443     maEndSync( rNode.maEndSync ),
 444     maRepeatCount( rNode.maRepeatCount ),
 445     maRepeatDuration( rNode.maRepeatDuration ),
 446     mnFill( rNode.mnFill ),
 447     mnFillDefault( rNode.mnFillDefault ),
 448     mnRestart( rNode.mnRestart ),
 449     mnRestartDefault( rNode.mnRestartDefault ),
 450     mfAcceleration( rNode.mfAcceleration ),
 451     mfDecelerate( rNode.mfDecelerate ),
 452     mbAutoReverse( rNode.mbAutoReverse ),
 453     maUserData( rNode.maUserData ),
 454
 455     // attributes for XAnimate
 456     maTarget( rNode.maTarget ),
 457     maAttributeName( rNode.maAttributeName ),
 458     maFormula( rNode.maFormula ),
 459     maValues( rNode.maValues ),
 460     maKeyTimes( rNode.maKeyTimes ),
 461     mnValueType( rNode.mnValueType ),
 462     mnSubItem( rNode.mnSubItem ),
 463     mnCalcMode( rNode.mnCalcMode ),
 464     mnAdditive( rNode.mnAdditive ),
 465     mbAccumulate( rNode.mbAccumulate ),
 466     maFrom( rNode.maFrom ),
 467     maTo( rNode.maTo ),
 468     maBy( rNode.maBy ),
 469     maTimeFilter( rNode.maTimeFilter ),
 470
 471     // attributes for XAnimateColor
 472     mnColorSpace( rNode.mnColorSpace ),
 473     mbDirection( rNode.mbDirection ),
 474
 475     // attributes for XAnimateMotion
 476     maPath( rNode.maPath ),
 477     maOrigin( rNode.maOrigin ),
 478
 479     // attributes for XAnimatePhysics
 480     maStartVelocityX( rNode.maStartVelocityX ),
 481     maStartVelocityY( rNode.maStartVelocityY ),
 482     maDensity( rNode.maDensity ),
 483     maBounciness( rNode.maBounciness ),
 484
 485     // attributes for XAnimateTransform
 486     mnTransformType( rNode.mnTransformType ),
 487
 488     // attributes for XTransitionFilter
 489     mnTransition( rNode.mnTransition ),
 490     mnSubtype( rNode.mnSubtype ),
 491     mbMode( rNode.mbMode ),
 492     mnFadeColor( rNode.mnFadeColor ),
 493
 494     // XAudio
 495     mfVolume( rNode.mfVolume ),
 496     mbHideDuringShow(rNode.mbHideDuringShow),
 497     mbNarration(rNode.mbNarration),
 498
 499     // XCommand
 500     mnCommand( rNode.mnCommand ),
 501     maParameter( rNode.maParameter ),
 502
 503     // XIterateContainer
 504     mnIterateType( rNode.mnIterateType ),
 505     mfIterateInterval( rNode.mfIterateInterval )
 506 {
 507 }
 508
 509 static Sequence<OUString> getSupportedServiceNames_PAR()
 510 {
 511     return { u"com.sun.star.animations.ParallelTimeContainer"_ustr };
 512 }
 513
 514 static OUString getImplementationName_PAR()
 515 {
 516     return u"animcore::ParallelTimeContainer"_ustr;
 517 }
 518
 519 static Sequence<OUString> getSupportedServiceNames_SEQ()
 520 {
 521     return { u"com.sun.star.animations.SequenceTimeContainer"_ustr };
 522 }
 523
 524 static OUString getImplementationName_SEQ()
 525 {
 526     return u"animcore::SequenceTimeContainer"_ustr;
 527 }
 528
 529 static Sequence<OUString> getSupportedServiceNames_ITERATE()
 530 {
 531     return { u"com.sun.star.animations.IterateContainer"_ustr };
 532 }
 533
 534 static OUString getImplementationName_ITERATE()
 535 {
 536     return u"animcore::IterateContainer"_ustr;
 537 }
 538
 539 static Sequence<OUString> getSupportedServiceNames_ANIMATE()
 540 {
 541     return { u"com.sun.star.animations.Animate"_ustr };
 542 }
 543
 544 static OUString getImplementationName_ANIMATE()
 545 {
 546         return u"animcore::Animate"_ustr;
 547 }
 548
 549 static Sequence<OUString> getSupportedServiceNames_SET()
 550 {
 551     return { u"com.sun.star.animations.AnimateSet"_ustr };
 552 }
 553
 554 static OUString getImplementationName_SET()
 555 {
 556     return u"animcore::AnimateSet"_ustr;
 557 }
 558
 559 static Sequence<OUString> getSupportedServiceNames_ANIMATECOLOR()
 560 {
 561     return { u"com.sun.star.animations.AnimateColor"_ustr };
 562 }
 563
 564 static OUString getImplementationName_ANIMATECOLOR()
 565 {
 566     return u"animcore::AnimateColor"_ustr;
 567 }
 568
 569 static Sequence<OUString> getSupportedServiceNames_ANIMATEMOTION()
 570 {
 571     return { u"com.sun.star.animations.AnimateMotion"_ustr };
 572 }
 573
 574 static OUString getImplementationName_ANIMATEMOTION()
 575 {
 576     return u"animcore::AnimateMotion"_ustr;
 577 }
 578
 579 static Sequence<OUString> getSupportedServiceNames_ANIMATEPHYSICS()
 580 {
 581     return { u"com.sun.star.animations.AnimatePhysics"_ustr };
 582 }
 583
 584 static OUString getImplementationName_ANIMATEPHYSICS()
 585 {
 586     return u"animcore::AnimatePhysics"_ustr;
 587 }
 588
 589 static Sequence<OUString> getSupportedServiceNames_ANIMATETRANSFORM()
 590 {
 591     return { u"com.sun.star.animations.AnimateTransform"_ustr };
 592 }
 593
 594 static OUString getImplementationName_ANIMATETRANSFORM()
 595 {
 596     return u"animcore::AnimateTransform"_ustr;
 597 }
 598
 599 static Sequence<OUString> getSupportedServiceNames_TRANSITIONFILTER()
 600 {
 601     return { u"com.sun.star.animations.TransitionFilter"_ustr };
 602 }
 603
 604 static OUString getImplementationName_TRANSITIONFILTER()
 605 {
 606         return u"animcore::TransitionFilter"_ustr;
 607 }
 608
 609 static Sequence<OUString> getSupportedServiceNames_AUDIO()
 610 {
 611     return { u"com.sun.star.animations.Audio"_ustr };
 612 }
 613
 614 static OUString getImplementationName_AUDIO()
 615 {
 616         return u"animcore::Audio"_ustr;
 617 }
 618
 619 static Sequence<OUString> getSupportedServiceNames_COMMAND()
 620 {
 621     return { u"com.sun.star.animations.Command"_ustr };
 622 }
 623
 624 static OUString getImplementationName_COMMAND()
 625 {
 626     return u"animcore::Command"_ustr;
 627 }
 628
 629 // XInterface
 630 Any SAL_CALL AnimationNode::queryInterface( const Type& aType )
 631 {
 632     Any aRet( ::cppu::queryInterface(
 633         aType,
 634         static_cast< XServiceInfo * >( this ),
 635         static_cast< XTypeProvider * >( this ),
 636         static_cast< XChild * >( static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ) ),
 637         static_cast< XCloneable* >( this ),
 638         static_cast< XAnimationNode* >( static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ) ),
 639         static_cast< XInterface* >(static_cast< OWeakObject * >(this)),
 640         static_cast< XWeak* >(static_cast< OWeakObject * >(this)),
 641         static_cast< XChangesNotifier* >( this ) ) );
 642
 643     if(!aRet.hasValue())
 644     {
 645         switch( mnNodeType )
 646         {
 647         case AnimationNodeType::PAR:
 648             aRet = ::cppu::queryInterface(
 649                 aType,
 650                 static_cast< XParallelTimeContainer * >( this ),
 651                 static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
 652                 static_cast< XEnumerationAccess * >( this ),
 653                 static_cast< XElementAccess * >( this ) );
 654             break;
 655         case AnimationNodeType::SEQ:
 656             aRet = ::cppu::queryInterface(
 657                 aType,
 658                 static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
 659                 static_cast< XEnumerationAccess * >( this ),
 660                 static_cast< XElementAccess * >( this ) );
 661             break;
 662         case AnimationNodeType::ITERATE:
 663             aRet = ::cppu::queryInterface(
 664                 aType,
 665                 static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
 666                 static_cast< XIterateContainer * >( this ),
 667                 static_cast< XEnumerationAccess * >( this ),
 668                 static_cast< XElementAccess * >( this ) );
 669             break;
 670         case AnimationNodeType::ANIMATE:
 671             aRet = ::cppu::queryInterface(
 672                 aType,
 673                 static_cast< XAnimate * >( static_cast< XAnimateMotion * >(this) ) );
 674             break;
 675         case AnimationNodeType::ANIMATEMOTION:
 676             aRet = ::cppu::queryInterface(
 677                 aType,
 678                 static_cast< XAnimate * >( static_cast< XAnimateMotion * >(this) ),
 679                 static_cast< XAnimateMotion * >( this ) );
 680             break;
 681         case AnimationNodeType::ANIMATEPHYSICS:
 682             aRet = ::cppu::queryInterface(
 683                 aType,
 684                 static_cast< XAnimate * >( static_cast< XAnimatePhysics * >(this) ),
 685                 static_cast< XAnimatePhysics * >( this ) );
 686             break;
 687         case AnimationNodeType::ANIMATECOLOR:
 688             aRet = ::cppu::queryInterface(
 689                 aType,
 690                 static_cast< XAnimate * >( static_cast< XAnimateColor * >(this) ),
 691                 static_cast< XAnimateColor * >( this ) );
 692             break;
 693         case AnimationNodeType::SET:
 694             aRet = ::cppu::queryInterface(
 695                 aType,
 696                 static_cast< XAnimate * >( static_cast< XAnimateSet * >(this) ),
 697                 static_cast< XAnimateSet * >( this ) );
 698             break;
 699         case AnimationNodeType::ANIMATETRANSFORM:
 700             aRet = ::cppu::queryInterface(
 701                 aType,
 702                 static_cast< XAnimate * >( static_cast< XAnimateTransform * >(this) ),
 703                 static_cast< XAnimateTransform * >( this ) );
 704             break;
 705         case AnimationNodeType::AUDIO:
 706             aRet = ::cppu::queryInterface(aType, static_cast< XAudio * >(this) );
 707             break;
 708         case AnimationNodeType::COMMAND:
 709             aRet = ::cppu::queryInterface(
 710                 aType, static_cast< XCommand * >(this) );
 711             break;
 712         case AnimationNodeType::TRANSITIONFILTER:
 713             aRet = ::cppu::queryInterface(
 714                 aType,
 715                 static_cast< XAnimate * >( static_cast< XTransitionFilter * >(this) ),
 716                 static_cast< XTransitionFilter * >( this ) );
 717             break;
 718         }
 719     }
 720
 721     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( aType );
 722 }
 723
 724
 725 void AnimationNode::initTypeProvider( sal_Int16 nNodeType ) noexcept
 726 {
 727     static std::mutex aMutex;
 728
 729     std::scoped_lock aGuard(aMutex);
 730
 731     if( mpTypes[nNodeType] )
 732         return;
 733
 734     static constexpr std::array<sal_Int32, mpTypes.size()> type_numbers =
 735     {
 736         6, // CUSTOM
 737         8, // PAR
 738         8, // SEQ
 739         8, // ITERATE
 740         7, // ANIMATE
 741         7, // SET
 742         7, // ANIMATEMOTION
 743         7, // ANIMATECOLOR
 744         7, // ANIMATETRANSFORM
 745         7, // TRANSITIONFILTER
 746         7, // AUDIO
 747         7, // COMMAND
 748         7, // ANIMATEPHYSICS
 749     };
 750
 751     // collect types
 752     Sequence< Type > * types = new Sequence< Type >( type_numbers[nNodeType] );
 753     Type * pTypeAr = types->getArray();
 754     sal_Int32 nPos = 0;
 755
 756     pTypeAr[nPos++] = cppu::UnoType<XWeak>::get();
 757     pTypeAr[nPos++] = cppu::UnoType<XChild>::get();
 758     pTypeAr[nPos++] = cppu::UnoType<XCloneable>::get();
 759     pTypeAr[nPos++] = cppu::UnoType<XTypeProvider>::get();
 760     pTypeAr[nPos++] = cppu::UnoType<XServiceInfo>::get();
 761     pTypeAr[nPos++] = cppu::UnoType<XChangesNotifier>::get();
 762
 763     switch( nNodeType )
 764     {
 765     case AnimationNodeType::PAR:
 766     case AnimationNodeType::SEQ:
 767         pTypeAr[nPos++] = cppu::UnoType<XTimeContainer>::get();
 768         pTypeAr[nPos++] = cppu::UnoType<XEnumerationAccess>::get();
 769         break;
 770     case AnimationNodeType::ITERATE:
 771         pTypeAr[nPos++] = cppu::UnoType<XIterateContainer>::get();
 772         pTypeAr[nPos++] = cppu::UnoType<XEnumerationAccess>::get();
 773         break;
 774     case AnimationNodeType::ANIMATE:
 775         pTypeAr[nPos++] = cppu::UnoType<XAnimate>::get();
 776         break;
 777     case AnimationNodeType::ANIMATEMOTION:
 778         pTypeAr[nPos++] = cppu::UnoType<XAnimateMotion>::get();
 779         break;
 780     case AnimationNodeType::ANIMATEPHYSICS:
 781         pTypeAr[nPos++] = cppu::UnoType<XAnimatePhysics>::get();
 782         break;
 783     case AnimationNodeType::ANIMATECOLOR:
 784         pTypeAr[nPos++] = cppu::UnoType<XAnimateColor>::get();
 785         break;
 786     case AnimationNodeType::ANIMATETRANSFORM:
 787         pTypeAr[nPos++] = cppu::UnoType<XAnimateTransform>::get();
 788         break;
 789     case AnimationNodeType::SET:
 790         pTypeAr[nPos++] = cppu::UnoType<XAnimateSet>::get();
 791         break;
 792     case AnimationNodeType::TRANSITIONFILTER:
 793         pTypeAr[nPos++] = cppu::UnoType<XTransitionFilter>::get();
 794         break;
 795     case AnimationNodeType::AUDIO:
 796         pTypeAr[nPos++] = cppu::UnoType<XAudio>::get();
 797         break;
 798     case AnimationNodeType::COMMAND:
 799         pTypeAr[nPos++] = cppu::UnoType<XCommand>::get();
 800         break;
 801     }
 802     mpTypes[nNodeType] = types;
 803 }
 804
 805
 806 Sequence< Type > AnimationNode::getTypes()
 807 {
 808     if (! mpTypes[mnNodeType])
 809         initTypeProvider(mnNodeType);
 810     return *mpTypes[mnNodeType];
 811 }
 812
 813
 814 Sequence< sal_Int8 > AnimationNode::getImplementationId()
 815 {
 816     return css::uno::Sequence<sal_Int8>();
 817 }
 818
 819
 820 // XInterface
 821 void SAL_CALL AnimationNode::acquire(  ) noexcept
 822 {
 823     OWeakObject::acquire();
 824 }
 825
 826
 827 // XInterface
 828 void SAL_CALL AnimationNode::release(  ) noexcept
 829 {
 830     OWeakObject::release();
 831 }
 832
 833
 834 // XServiceInfo
 835 OUString AnimationNode::getImplementationName()
 836 {
 837     switch( mnNodeType )
 838     {
 839     case AnimationNodeType::PAR:
 840         return getImplementationName_PAR();
 841     case AnimationNodeType::SEQ:
 842         return getImplementationName_SEQ();
 843     case AnimationNodeType::ITERATE:
 844         return getImplementationName_ITERATE();
 845     case AnimationNodeType::SET:
 846         return getImplementationName_SET();
 847     case AnimationNodeType::ANIMATECOLOR:
 848         return getImplementationName_ANIMATECOLOR();
 849     case AnimationNodeType::ANIMATEMOTION:
 850         return getImplementationName_ANIMATEMOTION();
 851     case AnimationNodeType::ANIMATEPHYSICS:
 852         return getImplementationName_ANIMATEPHYSICS();
 853     case AnimationNodeType::TRANSITIONFILTER:
 854         return getImplementationName_TRANSITIONFILTER();
 855     case AnimationNodeType::ANIMATETRANSFORM:
 856         return getImplementationName_ANIMATETRANSFORM();
 857     case AnimationNodeType::AUDIO:
 858         return getImplementationName_AUDIO();
 859     case AnimationNodeType::COMMAND:
 860         return getImplementationName_COMMAND();
 861     case AnimationNodeType::ANIMATE:
 862     default:
 863         return getImplementationName_ANIMATE();
 864     }
 865 }
 866
 867 // XServiceInfo
 868 sal_Bool AnimationNode::supportsService(const OUString& ServiceName)
 869 {
 870     return cppu::supportsService(this, ServiceName);
 871 }
 872
 873 // XServiceInfo
 874 Sequence< OUString > AnimationNode::getSupportedServiceNames()
 875 {
 876     switch( mnNodeType )
 877     {
 878     case AnimationNodeType::PAR:
 879         return getSupportedServiceNames_PAR();
 880     case AnimationNodeType::SEQ:
 881         return getSupportedServiceNames_SEQ();
 882     case AnimationNodeType::ITERATE:
 883         return getSupportedServiceNames_ITERATE();
 884     case AnimationNodeType::SET:
 885         return getSupportedServiceNames_SET();
 886     case AnimationNodeType::ANIMATECOLOR:
 887         return getSupportedServiceNames_ANIMATECOLOR();
 888     case AnimationNodeType::ANIMATEMOTION:
 889         return getSupportedServiceNames_ANIMATEMOTION();
 890     case AnimationNodeType::ANIMATEPHYSICS:
 891         return getSupportedServiceNames_ANIMATEPHYSICS();
 892     case AnimationNodeType::TRANSITIONFILTER:
 893         return getSupportedServiceNames_TRANSITIONFILTER();
 894     case AnimationNodeType::ANIMATETRANSFORM:
 895         return getSupportedServiceNames_ANIMATETRANSFORM();
 896     case AnimationNodeType::AUDIO:
 897         return getSupportedServiceNames_AUDIO();
 898     case AnimationNodeType::COMMAND:
 899         return getSupportedServiceNames_COMMAND();
 900     case AnimationNodeType::ANIMATE:
 901     default:
 902         return getSupportedServiceNames_ANIMATE();
 903     }
 904 }
 905
 906
 907 // XAnimationNode
 908 sal_Int16 SAL_CALL AnimationNode::getType()
 909 {
 910     return mnNodeType;
 911 }
 912
 913
 914 // XAnimationNode
 915 Any SAL_CALL AnimationNode::getBegin()
 916 {
 917     std::unique_lock aGuard( m_aMutex );
 918     return maBegin;
 919 }
 920
 921
 922 // XAnimationNode
 923 void SAL_CALL AnimationNode::setBegin( const Any& _begin )
 924 {
 925     std::unique_lock aGuard( m_aMutex );
 926     if( _begin != maBegin )
 927     {
 928         maBegin = _begin;
 929         fireChangeListener(aGuard);
 930     }
 931 }
 932
 933
 934 // XAnimationNode
 935 Any SAL_CALL AnimationNode::getDuration()
 936 {
 937     std::unique_lock aGuard( m_aMutex );
 938     return maDuration;
 939 }
 940
 941
 942 // XAnimationNode
 943 void SAL_CALL AnimationNode::setDuration( const Any& _duration )
 944 {
 945     std::unique_lock aGuard( m_aMutex );
 946     if( _duration != maDuration )
 947     {
 948         maDuration = _duration;
 949         fireChangeListener(aGuard);
 950     }
 951 }
 952
 953
 954 // XAnimationNode
 955 Any SAL_CALL AnimationNode::getEnd()
 956 {
 957     std::unique_lock aGuard( m_aMutex );
 958     return maEnd;
 959 }
 960
 961
 962 // XAnimationNode
 963 void SAL_CALL AnimationNode::setEnd( const Any& _end )
 964 {
 965     std::unique_lock aGuard( m_aMutex );
 966     if( _end != maEnd )
 967     {
 968         maEnd = _end;
 969         fireChangeListener(aGuard);
 970     }
 971 }
 972
 973
 974 // XAnimationNode
 975 Any SAL_CALL AnimationNode::getEndSync()
 976 {
 977     std::unique_lock aGuard( m_aMutex );
 978     return maEndSync;
 979 }
 980
 981
 982 // XAnimationNode
 983 void SAL_CALL AnimationNode::setEndSync( const Any& _endsync )
 984 {
 985     std::unique_lock l( m_aMutex );
 986     if( _endsync != maEndSync )
 987     {
 988         maEndSync = _endsync;
 989         fireChangeListener(l);
 990     }
 991 }
 992
 993
 994 // XAnimationNode
 995 Any SAL_CALL AnimationNode::getRepeatCount()
 996 {
 997     std::unique_lock aGuard( m_aMutex );
 998     return maRepeatCount;
 999 }
1000
1001
1002 // XAnimationNode
1003 void SAL_CALL AnimationNode::setRepeatCount( const Any& _repeatcount )
1004 {
1005     std::unique_lock l( m_aMutex );
1006     if( _repeatcount != maRepeatCount )
1007     {
1008         maRepeatCount = _repeatcount;
1009         fireChangeListener(l);
1010     }
1011 }
1012
1013
1014 // XAnimationNode
1015 Any SAL_CALL AnimationNode::getRepeatDuration()
1016 {
1017     std::unique_lock aGuard( m_aMutex );
1018     return maRepeatDuration;
1019 }
1020
1021
1022 // XAnimationNode
1023 void SAL_CALL AnimationNode::setRepeatDuration( const Any& _repeatduration )
1024 {
1025     std::unique_lock l( m_aMutex );
1026     if( _repeatduration != maRepeatDuration )
1027     {
1028         maRepeatDuration = _repeatduration;
1029         fireChangeListener(l);
1030     }
1031 }
1032
1033
1034 // XAnimationNode
1035 sal_Int16 SAL_CALL AnimationNode::getFill()
1036 {
1037     std::unique_lock aGuard( m_aMutex );
1038     return mnFill;
1039 }
1040
1041
1042 // XAnimationNode
1043 void SAL_CALL AnimationNode::setFill( sal_Int16 _fill )
1044 {
1045     std::unique_lock l( m_aMutex );
1046     if( _fill != mnFill )
1047     {
1048         mnFill = _fill;
1049         fireChangeListener(l);
1050     }
1051 }
1052
1053
1054 // XAnimationNode
1055 sal_Int16 SAL_CALL AnimationNode::getFillDefault()
1056 {
1057     std::unique_lock aGuard( m_aMutex );
1058     return mnFillDefault;
1059 }
1060
1061
1062 // XAnimationNode
1063 void SAL_CALL AnimationNode::setFillDefault( sal_Int16 _filldefault )
1064 {
1065     std::unique_lock l( m_aMutex );
1066     if( _filldefault != mnFillDefault )
1067     {
1068         mnFillDefault = _filldefault;
1069         fireChangeListener(l);
1070     }
1071 }
1072
1073
1074 // XAnimationNode
1075 sal_Int16 SAL_CALL AnimationNode::getRestart()
1076 {
1077     std::unique_lock aGuard( m_aMutex );
1078     return mnRestart;
1079 }
1080
1081
1082 // XAnimationNode
1083 void SAL_CALL AnimationNode::setRestart( sal_Int16 _restart )
1084 {
1085     std::unique_lock l( m_aMutex );
1086     if( _restart != mnRestart )
1087     {
1088         mnRestart = _restart;
1089         fireChangeListener(l);
1090     }
1091 }
1092
1093
1094 // XAnimationNode
1095 sal_Int16 SAL_CALL AnimationNode::getRestartDefault()
1096 {
1097     std::unique_lock aGuard( m_aMutex );
1098     return mnRestartDefault;
1099 }
1100
1101
1102 // XAnimationNode
1103 void SAL_CALL AnimationNode::setRestartDefault( sal_Int16 _restartdefault )
1104 {
1105     std::unique_lock l( m_aMutex );
1106     if( _restartdefault != mnRestartDefault )
1107     {
1108         mnRestartDefault = _restartdefault;
1109         fireChangeListener(l);
1110     }
1111 }
1112
1113
1114 // XAnimationNode
1115 double SAL_CALL AnimationNode::getAcceleration()
1116 {
1117     std::unique_lock aGuard( m_aMutex );
1118     return mfAcceleration;
1119 }
1120
1121
1122 // XAnimationNode
1123 void SAL_CALL AnimationNode::setAcceleration( double _acceleration )
1124 {
1125     std::unique_lock l( m_aMutex );
1126     if( _acceleration != mfAcceleration )
1127     {
1128         mfAcceleration = _acceleration;
1129         fireChangeListener(l);
1130     }
1131 }
1132
1133
1134 // XAnimationNode
1135 double SAL_CALL AnimationNode::getDecelerate()
1136 {
1137     std::unique_lock aGuard( m_aMutex );
1138     return mfDecelerate;
1139 }
1140
1141
1142 // XAnimationNode
1143 void SAL_CALL AnimationNode::setDecelerate( double _decelerate )
1144 {
1145     std::unique_lock l( m_aMutex );
1146     if( _decelerate != mfDecelerate )
1147     {
1148         mfDecelerate = _decelerate;
1149         fireChangeListener(l);
1150     }
1151 }
1152
1153
1154 // XAnimationNode
1155 sal_Bool SAL_CALL AnimationNode::getAutoReverse()
1156 {
1157     std::unique_lock aGuard( m_aMutex );
1158     return mbAutoReverse;
1159 }
1160
1161
1162 // XAnimationNode
1163 void SAL_CALL AnimationNode::setAutoReverse( sal_Bool _autoreverse )
1164 {
1165     std::unique_lock l( m_aMutex );
1166     if( bool(_autoreverse) != mbAutoReverse )
1167     {
1168         mbAutoReverse = _autoreverse;
1169         fireChangeListener(l);
1170     }
1171 }
1172
1173
1174 Sequence< NamedValue > SAL_CALL AnimationNode::getUserData()
1175 {
1176     std::unique_lock aGuard( m_aMutex );
1177     return maUserData;
1178 }
1179
1180
1181 void SAL_CALL AnimationNode::setUserData( const Sequence< NamedValue >& _userdata )
1182 {
1183     std::unique_lock l( m_aMutex );
1184     maUserData = _userdata;
1185     fireChangeListener(l);
1186 }
1187
1188
1189 // XChild
1190 Reference< XInterface > SAL_CALL AnimationNode::getParent()
1191 {
1192     std::unique_lock aGuard( m_aMutex );
1193     return static_cast<cppu::OWeakObject*>(mxParent.get().get());
1194 }
1195
1196
1197 // XChild
1198 void SAL_CALL AnimationNode::setParent( const Reference< XInterface >& Parent )
1199 {
1200     std::unique_lock l( m_aMutex );
1201     if( Parent.get() != static_cast<cppu::OWeakObject*>(mxParent.get().get()) )
1202     {
1203         rtl::Reference<AnimationNode> xParent = dynamic_cast<AnimationNode*>(Parent.get());
1204         mxParent = xParent.get();
1205         assert(bool(xParent) == bool(Parent) && "only support AnimationNode subtypes");
1206
1207         fireChangeListener(l);
1208     }
1209 }
1210
1211
1212 // XCloneable
1213 Reference< XCloneable > SAL_CALL AnimationNode::createClone()
1214 {
1215     std::unique_lock aGuard( m_aMutex );
1216
1217     Reference< XCloneable > xNewNode;
1218     try
1219     {
1220         xNewNode = new AnimationNode( *this );
1221
1222         if( !maChildren.empty() )
1223         {
1224             Reference< XTimeContainer > xContainer( xNewNode, UNO_QUERY );
1225             if( xContainer.is() )
1226             {
1227                 for (auto const& child : maChildren)
1228                 {
1229                     Reference< XCloneable > xCloneable(child, UNO_QUERY );
1230                     if( xCloneable.is() ) try
1231                     {
1232                         Reference< XAnimationNode > xNewChildNode( xCloneable->createClone(), UNO_QUERY );
1233                         if( xNewChildNode.is() )
1234                             xContainer->appendChild( xNewChildNode );
1235                     }
1236                     catch(const Exception&)
1237                     {
1238                         SAL_INFO("animations", "animations::AnimationNode::createClone(), exception caught!");
1239                     }
1240                 }
1241             }
1242         }
1243     }
1244     catch(const Exception&)
1245     {
1246         SAL_INFO("animations", "animations::AnimationNode::createClone(), exception caught!");
1247     }
1248
1249     return xNewNode;
1250 }
1251
1252
1253 // XAnimate
1254 Any SAL_CALL AnimationNode::getTarget()
1255 {
1256     std::unique_lock aGuard( m_aMutex );
1257     return maTarget;
1258 }
1259
1260
1261 // XAnimate
1262 void SAL_CALL AnimationNode::setTarget( const Any& _target )
1263 {
1264     std::unique_lock l( m_aMutex );
1265     if( _target != maTarget )
1266     {
1267         maTarget= _target;
1268         fireChangeListener(l);
1269     }
1270 }
1271
1272
1273 // XAnimate
1274 OUString SAL_CALL AnimationNode::getAttributeName()
1275 {
1276     std::unique_lock aGuard( m_aMutex );
1277     return maAttributeName;
1278 }
1279
1280
1281 // XAnimate
1282 void SAL_CALL AnimationNode::setAttributeName( const OUString& _attribute )
1283 {
1284     std::unique_lock l( m_aMutex );
1285     if( _attribute != maAttributeName )
1286     {
1287         maAttributeName = _attribute;
1288         fireChangeListener(l);
1289     }
1290 }
1291
1292
1293 // XAnimate
1294 Sequence< Any > SAL_CALL AnimationNode::getValues()
1295 {
1296     std::unique_lock aGuard( m_aMutex );
1297     return maValues;
1298 }
1299
1300
1301 // XAnimate
1302 void SAL_CALL AnimationNode::setValues( const Sequence< Any >& _values )
1303 {
1304     std::unique_lock l( m_aMutex );
1305     maValues = _values;
1306     fireChangeListener(l);
1307 }
1308
1309
1310 // XAnimate
1311 sal_Int16 SAL_CALL AnimationNode::getSubItem()
1312 {
1313     std::unique_lock aGuard( m_aMutex );
1314     return mnSubItem;
1315 }
1316
1317
1318 // XAnimate
1319 void SAL_CALL AnimationNode::setSubItem( sal_Int16 _subitem )
1320 {
1321     std::unique_lock l( m_aMutex );
1322     if( _subitem != mnSubItem )
1323     {
1324         mnSubItem = _subitem;
1325         fireChangeListener(l);
1326     }
1327 }
1328
1329
1330 // XAnimate
1331 Sequence< double > SAL_CALL AnimationNode::getKeyTimes()
1332 {
1333     std::unique_lock aGuard( m_aMutex );
1334     return maKeyTimes;
1335 }
1336
1337
1338 // XAnimate
1339 void SAL_CALL AnimationNode::setKeyTimes( const Sequence< double >& _keytimes )
1340 {
1341     std::unique_lock l( m_aMutex );
1342     maKeyTimes = _keytimes;
1343     fireChangeListener(l);
1344 }
1345
1346
1347 // XAnimate
1348 sal_Int16 SAL_CALL AnimationNode::getValueType()
1349 {
1350     std::unique_lock aGuard( m_aMutex );
1351     return mnValueType;
1352 }
1353
1354
1355 void SAL_CALL AnimationNode::setValueType( sal_Int16 _valuetype )
1356 {
1357     std::unique_lock l( m_aMutex );
1358     if( _valuetype != mnValueType )
1359     {
1360         mnValueType = _valuetype;
1361         fireChangeListener(l);
1362     }
1363 }
1364
1365
1366 // XAnimate
1367 sal_Int16 SAL_CALL AnimationNode::getCalcMode()
1368 {
1369     std::unique_lock aGuard( m_aMutex );
1370     return mnCalcMode;
1371 }
1372
1373
1374 // XAnimate
1375 void SAL_CALL AnimationNode::setCalcMode( sal_Int16 _calcmode )
1376 {
1377     std::unique_lock l( m_aMutex );
1378     if( _calcmode != mnCalcMode )
1379     {
1380         mnCalcMode = _calcmode;
1381         fireChangeListener(l);
1382     }
1383 }
1384
1385
1386 // XAnimate
1387 sal_Bool SAL_CALL AnimationNode::getAccumulate()
1388 {
1389     std::unique_lock aGuard( m_aMutex );
1390     return mbAccumulate;
1391 }
1392
1393
1394 // XAnimate
1395 void SAL_CALL AnimationNode::setAccumulate( sal_Bool _accumulate )
1396 {
1397     std::unique_lock l( m_aMutex );
1398     if( bool(_accumulate) != mbAccumulate )
1399     {
1400         mbAccumulate = _accumulate;
1401         fireChangeListener(l);
1402     }
1403 }
1404
1405
1406 // XAnimate
1407 sal_Int16 SAL_CALL AnimationNode::getAdditive()
1408 {
1409     std::unique_lock aGuard( m_aMutex );
1410     return mnAdditive;
1411 }
1412
1413
1414 // XAnimate
1415 void SAL_CALL AnimationNode::setAdditive( sal_Int16 _additive )
1416 {
1417     std::unique_lock l( m_aMutex );
1418     if( _additive != mnAdditive )
1419     {
1420         mnAdditive = _additive;
1421         fireChangeListener(l);
1422     }
1423 }
1424
1425
1426 // XAnimate
1427 Any SAL_CALL AnimationNode::getFrom()
1428 {
1429     std::unique_lock aGuard( m_aMutex );
1430     return maFrom;
1431 }
1432
1433
1434 // XAnimate
1435 void SAL_CALL AnimationNode::setFrom( const Any& _from )
1436 {
1437     std::unique_lock l( m_aMutex );
1438     if( _from != maFrom )
1439     {
1440         maFrom = _from;
1441         fireChangeListener(l);
1442     }
1443 }
1444
1445
1446 // XAnimate
1447 Any SAL_CALL AnimationNode::getTo()
1448 {
1449     std::unique_lock aGuard( m_aMutex );
1450     return maTo;
1451 }
1452
1453
1454 // XAnimate
1455 void SAL_CALL AnimationNode::setTo( const Any& _to )
1456 {
1457     std::unique_lock l( m_aMutex );
1458     if( _to != maTo )
1459     {
1460         maTo = _to;
1461         fireChangeListener(l);
1462     }
1463 }
1464
1465
1466 // XAnimate
1467 Any SAL_CALL AnimationNode::getBy()
1468 {
1469     std::unique_lock aGuard( m_aMutex );
1470     return maBy;
1471 }
1472
1473
1474 // XAnimate
1475 void SAL_CALL AnimationNode::setBy( const Any& _by )
1476 {
1477     std::unique_lock l( m_aMutex );
1478     if( _by != maBy )
1479     {
1480         maBy = _by;
1481         fireChangeListener(l);
1482     }
1483 }
1484
1485
1486 // XAnimate
1487 Sequence< TimeFilterPair > SAL_CALL AnimationNode::getTimeFilter()
1488 {
1489     std::unique_lock aGuard( m_aMutex );
1490     return maTimeFilter;
1491 }
1492
1493
1494 // XAnimate
1495 void SAL_CALL AnimationNode::setTimeFilter( const Sequence< TimeFilterPair >& _timefilter )
1496 {
1497     std::unique_lock l( m_aMutex );
1498     maTimeFilter = _timefilter;
1499     fireChangeListener(l);
1500 }
1501
1502
1503 OUString SAL_CALL AnimationNode::getFormula()
1504 {
1505     std::unique_lock aGuard( m_aMutex );
1506     return maFormula;
1507 }
1508
1509
1510 void SAL_CALL AnimationNode::setFormula( const OUString& _formula )
1511 {
1512     std::unique_lock l( m_aMutex );
1513     if( _formula != maFormula )
1514     {
1515         maFormula = _formula;
1516         fireChangeListener(l);
1517     }
1518 }
1519
1520
1521 // XAnimateColor
1522 sal_Int16 SAL_CALL AnimationNode::getColorInterpolation()
1523 {
1524     std::unique_lock aGuard( m_aMutex );
1525     return mnColorSpace;
1526 }
1527
1528
1529 // XAnimateColor
1530 void SAL_CALL AnimationNode::setColorInterpolation( sal_Int16 _colorspace )
1531 {
1532     std::unique_lock l( m_aMutex );
1533     if( _colorspace != mnColorSpace )
1534     {
1535         mnColorSpace = _colorspace;
1536         fireChangeListener(l);
1537     }
1538 }
1539
1540
1541 // XAnimateColor
1542 sal_Bool SAL_CALL AnimationNode::getDirection()
1543 {
1544     std::unique_lock aGuard( m_aMutex );
1545     return mbDirection;
1546 }
1547
1548
1549 // XAnimateColor
1550 void SAL_CALL AnimationNode::setDirection( sal_Bool _direction )
1551 {
1552     std::unique_lock l( m_aMutex );
1553     if( bool(_direction) != mbDirection )
1554     {
1555         mbDirection = _direction;
1556         fireChangeListener(l);
1557     }
1558 }
1559
1560
1561 // XAnimateMotion
1562 Any SAL_CALL AnimationNode::getPath()
1563 {
1564     std::unique_lock aGuard( m_aMutex );
1565     return maPath;
1566 }
1567
1568
1569 // XAnimateMotion
1570 void SAL_CALL AnimationNode::setPath( const Any& _path )
1571 {
1572     std::unique_lock l( m_aMutex );
1573     maPath = _path;
1574     fireChangeListener(l);
1575 }
1576
1577
1578 // XAnimateMotion
1579 Any SAL_CALL AnimationNode::getOrigin()
1580 {
1581     std::unique_lock aGuard( m_aMutex );
1582     return maOrigin;
1583 }
1584
1585
1586 // XAnimateMotion
1587 void SAL_CALL AnimationNode::setOrigin( const Any& _origin )
1588 {
1589     std::unique_lock l( m_aMutex );
1590     maOrigin = _origin;
1591     fireChangeListener(l);
1592 }
1593
1594 // XAnimatePhysics
1595 Any SAL_CALL AnimationNode::getStartVelocityX()
1596 {
1597     std::unique_lock aGuard( m_aMutex );
1598     return maStartVelocityX;
1599 }
1600
1601
1602 // XAnimatePhysics
1603 void SAL_CALL AnimationNode::setStartVelocityX( const Any& _startvelocityx )
1604 {
1605     std::unique_lock l( m_aMutex );
1606     maStartVelocityX = _startvelocityx;
1607     fireChangeListener(l);
1608 }
1609
1610 // XAnimatePhysics
1611 Any SAL_CALL AnimationNode::getStartVelocityY()
1612 {
1613     std::unique_lock aGuard( m_aMutex );
1614     return maStartVelocityY;
1615 }
1616
1617
1618 // XAnimatePhysics
1619 void SAL_CALL AnimationNode::setStartVelocityY( const Any& _startvelocityy )
1620 {
1621     std::unique_lock l( m_aMutex );
1622     maStartVelocityY = _startvelocityy;
1623     fireChangeListener(l);
1624 }
1625
1626
1627 // XAnimatePhysics
1628 Any SAL_CALL AnimationNode::getDensity()
1629 {
1630     std::unique_lock aGuard( m_aMutex );
1631     return maDensity;
1632 }
1633
1634
1635 // XAnimatePhysics
1636 void SAL_CALL AnimationNode::setDensity( const Any& _density )
1637 {
1638     std::unique_lock l( m_aMutex );
1639     maDensity = _density;
1640     fireChangeListener(l);
1641 }
1642
1643
1644 // XAnimatePhysics
1645 Any SAL_CALL AnimationNode::getBounciness()
1646 {
1647     std::unique_lock aGuard( m_aMutex );
1648     return maBounciness;
1649 }
1650
1651
1652 // XAnimatePhysics
1653 void SAL_CALL AnimationNode::setBounciness( const Any& _bounciness )
1654 {
1655     std::unique_lock l( m_aMutex );
1656     maBounciness = _bounciness;
1657     fireChangeListener(l);
1658 }
1659
1660
1661 // XAnimateTransform
1662 sal_Int16 SAL_CALL AnimationNode::getTransformType()
1663 {
1664     std::unique_lock aGuard( m_aMutex );
1665     return mnTransformType;
1666 }
1667
1668
1669 // XAnimateTransform
1670 void SAL_CALL AnimationNode::setTransformType( sal_Int16 _transformtype )
1671 {
1672     std::unique_lock l( m_aMutex );
1673     if( _transformtype != mnTransformType )
1674     {
1675         mnTransformType = _transformtype;
1676         fireChangeListener(l);
1677     }
1678 }
1679
1680
1681 // XTransitionFilter
1682 sal_Int16 SAL_CALL AnimationNode::getTransition()
1683 {
1684     std::unique_lock aGuard( m_aMutex );
1685     return mnTransition;
1686 }
1687
1688
1689 // XTransitionFilter
1690 void SAL_CALL AnimationNode::setTransition( sal_Int16 _transition )
1691 {
1692     std::unique_lock l( m_aMutex );
1693     if( _transition != mnTransition )
1694     {
1695         mnTransition = _transition;
1696         fireChangeListener(l);
1697     }
1698 }
1699
1700
1701 // XTransitionFilter
1702 sal_Int16 SAL_CALL AnimationNode::getSubtype()
1703 {
1704     std::unique_lock aGuard( m_aMutex );
1705     return mnSubtype;
1706 }
1707
1708
1709 // XTransitionFilter
1710 void SAL_CALL AnimationNode::setSubtype( sal_Int16 _subtype )
1711 {
1712     std::unique_lock l( m_aMutex );
1713     if( _subtype != mnSubtype )
1714     {
1715         mnSubtype = _subtype;
1716         fireChangeListener(l);
1717     }
1718 }
1719
1720
1721 // XTransitionFilter
1722 sal_Bool SAL_CALL AnimationNode::getMode()
1723 {
1724     std::unique_lock aGuard( m_aMutex );
1725     return mbMode;
1726 }
1727
1728
1729 // XTransitionFilter
1730 void SAL_CALL AnimationNode::setMode( sal_Bool _mode )
1731 {
1732     std::unique_lock l( m_aMutex );
1733     if( bool(_mode) != mbMode )
1734     {
1735         mbMode = _mode;
1736         fireChangeListener(l);
1737     }
1738 }
1739
1740
1741 // XTransitionFilter
1742 sal_Int32 SAL_CALL AnimationNode::getFadeColor()
1743 {
1744     std::unique_lock aGuard( m_aMutex );
1745     return mnFadeColor;
1746 }
1747
1748
1749 // XTransitionFilter
1750 void SAL_CALL AnimationNode::setFadeColor( sal_Int32 _fadecolor )
1751 {
1752     std::unique_lock l( m_aMutex );
1753     if( _fadecolor != mnFadeColor )
1754     {
1755         mnFadeColor = _fadecolor;
1756         fireChangeListener(l);
1757     }
1758 }
1759
1760
1761 // XAudio
1762 Any SAL_CALL AnimationNode::getSource()
1763 {
1764     std::unique_lock aGuard( m_aMutex );
1765     return maTarget;
1766 }
1767
1768
1769 // XAudio
1770 void SAL_CALL AnimationNode::setSource( const Any& _source )
1771 {
1772     std::unique_lock l( m_aMutex );
1773     maTarget = _source;
1774     fireChangeListener(l);
1775 }
1776
1777
1778 // XAudio
1779 double SAL_CALL AnimationNode::getVolume()
1780 {
1781     std::unique_lock aGuard( m_aMutex );
1782     return mfVolume;
1783 }
1784
1785
1786 // XAudio
1787 void SAL_CALL AnimationNode::setVolume( double _volume )
1788 {
1789     std::unique_lock l( m_aMutex );
1790     if( _volume != mfVolume )
1791     {
1792         mfVolume = _volume;
1793         fireChangeListener(l);
1794     }
1795 }
1796
1797 sal_Bool SAL_CALL AnimationNode::getHideDuringShow()
1798 {
1799     std::unique_lock aGuard(m_aMutex);
1800     return mbHideDuringShow;
1801 }
1802
1803 void SAL_CALL AnimationNode::setHideDuringShow(sal_Bool bHideDuringShow)
1804 {
1805     std::unique_lock l(m_aMutex);
1806     if (static_cast<bool>(bHideDuringShow) != mbHideDuringShow)
1807     {
1808         mbHideDuringShow = bHideDuringShow;
1809         fireChangeListener(l);
1810     }
1811 }
1812
1813 sal_Bool SAL_CALL AnimationNode::getNarration()
1814 {
1815     std::unique_lock aGuard(m_aMutex);
1816     return mbNarration;
1817 }
1818
1819 void SAL_CALL AnimationNode::setNarration(sal_Bool bNarration)
1820 {
1821     std::unique_lock l(m_aMutex);
1822     if (static_cast<bool>(bNarration) != mbNarration)
1823     {
1824         mbNarration = bNarration;
1825         fireChangeListener(l);
1826     }
1827 }
1828
1829 // XCommand
1830 sal_Int16 SAL_CALL AnimationNode::getCommand()
1831 {
1832     std::unique_lock aGuard( m_aMutex );
1833     return mnCommand;
1834 }
1835
1836
1837 // XCommand
1838 void SAL_CALL AnimationNode::setCommand( sal_Int16 _command )
1839 {
1840     std::unique_lock l( m_aMutex );
1841     if( _command != mnCommand )
1842     {
1843         mnCommand = _command;
1844         fireChangeListener(l);
1845     }
1846 }
1847
1848
1849 // XCommand
1850 Any SAL_CALL AnimationNode::getParameter()
1851 {
1852     std::unique_lock aGuard( m_aMutex );
1853     return maParameter;
1854 }
1855
1856
1857 // XCommand
1858 void SAL_CALL AnimationNode::setParameter( const Any& _parameter )
1859 {
1860     std::unique_lock l( m_aMutex );
1861     maParameter = _parameter;
1862     fireChangeListener(l);
1863 }
1864
1865
1866 // XElementAccess
1867 Type SAL_CALL AnimationNode::getElementType()
1868 {
1869     return cppu::UnoType<XAnimationNode>::get();
1870 }
1871
1872
1873 // XElementAccess
1874 sal_Bool SAL_CALL AnimationNode::hasElements()
1875 {
1876     std::unique_lock aGuard( m_aMutex );
1877     return !maChildren.empty();
1878 }
1879
1880
1881 // XEnumerationAccess
1882 Reference< XEnumeration > SAL_CALL AnimationNode::createEnumeration()
1883 {
1884     std::unique_lock aGuard( m_aMutex );
1885
1886     return new TimeContainerEnumeration(std::vector(maChildren));
1887 }
1888
1889
1890 // XTimeContainer
1891 Reference< XAnimationNode > SAL_CALL AnimationNode::insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild )
1892 {
1893     std::unique_lock l( m_aMutex );
1894
1895     if( !newChild.is() || !refChild.is() )
1896         throw IllegalArgumentException(u"no child"_ustr, static_cast<cppu::OWeakObject*>(this), -1);
1897
1898     if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
1899         throw ElementExistException();
1900
1901     auto before = std::find(maChildren.begin(), maChildren.end(), refChild);
1902     if( before == maChildren.end() )
1903         throw NoSuchElementException();
1904
1905     maChildren.insert( before, newChild );
1906
1907     Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
1908     l.unlock();
1909     newChild->setParent( xThis );
1910
1911     return newChild;
1912 }
1913
1914
1915 // XTimeContainer
1916 Reference< XAnimationNode > SAL_CALL AnimationNode::insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild )
1917 {
1918     std::unique_lock l( m_aMutex );
1919
1920     if( !newChild.is() || !refChild.is() )
1921         throw IllegalArgumentException(u"no child"_ustr, static_cast<cppu::OWeakObject*>(this), -1);
1922
1923     if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
1924         throw ElementExistException();
1925
1926     auto before = std::find(maChildren.begin(), maChildren.end(), refChild);
1927     if( before == maChildren.end() )
1928         throw NoSuchElementException();
1929
1930     ++before;
1931     if( before != maChildren.end() )
1932         maChildren.insert( before, newChild );
1933     else
1934         maChildren.push_back( newChild );
1935
1936     Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
1937     l.unlock();
1938     newChild->setParent( xThis );
1939
1940     return newChild;
1941 }
1942
1943
1944 // XTimeContainer
1945 Reference< XAnimationNode > SAL_CALL AnimationNode::replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& oldChild )
1946 {
1947     std::unique_lock l( m_aMutex );
1948
1949     if( !newChild.is() || !oldChild.is() )
1950         throw IllegalArgumentException(u"no child"_ustr, static_cast<cppu::OWeakObject*>(this), -1);
1951
1952     if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
1953         throw ElementExistException();
1954
1955     auto replace = std::find(maChildren.begin(), maChildren.end(), oldChild);
1956     if( replace == maChildren.end() )
1957         throw NoSuchElementException();
1958
1959     (*replace) = newChild;
1960
1961     Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
1962     l.unlock();
1963     oldChild->setParent( Reference< XInterface >() );
1964     newChild->setParent( xThis );
1965
1966     return newChild;
1967 }
1968
1969
1970 // XTimeContainer
1971 Reference< XAnimationNode > SAL_CALL AnimationNode::removeChild( const Reference< XAnimationNode >& oldChild )
1972 {
1973     std::unique_lock l( m_aMutex );
1974
1975     if( !oldChild.is() )
1976         throw IllegalArgumentException(u"no child"_ustr, static_cast<cppu::OWeakObject*>(this), 1);
1977
1978     auto old = std::find(maChildren.begin(), maChildren.end(), oldChild);
1979     if( old == maChildren.end() )
1980         throw NoSuchElementException();
1981
1982     maChildren.erase( old );
1983
1984     l.unlock();
1985     oldChild->setParent( Reference< XInterface >() );
1986
1987     return oldChild;
1988 }
1989
1990
1991 // XTimeContainer
1992 Reference< XAnimationNode > SAL_CALL AnimationNode::appendChild( const Reference< XAnimationNode >& newChild )
1993 {
1994     Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
1995     {
1996         std::unique_lock aGuard( m_aMutex );
1997
1998         if( !newChild.is() )
1999             throw IllegalArgumentException(u"no child"_ustr, xThis, 1);
2000
2001         if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
2002             throw ElementExistException({}, xThis);
2003
2004         if( xThis == newChild )
2005             throw IllegalArgumentException(u"cannot append self"_ustr, xThis, -1);
2006
2007         maChildren.push_back( newChild );
2008     }
2009     newChild->setParent( xThis );
2010
2011     return newChild;
2012 }
2013
2014
2015 // XIterateContainer
2016 sal_Int16 SAL_CALL AnimationNode::getIterateType()
2017 {
2018     std::unique_lock aGuard( m_aMutex );
2019     return mnIterateType;
2020 }
2021
2022
2023 // XIterateContainer
2024 void SAL_CALL AnimationNode::setIterateType( sal_Int16 _iteratetype )
2025 {
2026     std::unique_lock l( m_aMutex );
2027     if( _iteratetype != mnIterateType )
2028     {
2029         mnIterateType = _iteratetype;
2030         fireChangeListener(l);
2031     }
2032 }
2033
2034
2035 // XIterateContainer
2036 double SAL_CALL AnimationNode::getIterateInterval()
2037 {
2038     std::unique_lock aGuard( m_aMutex );
2039     return mfIterateInterval;
2040 }
2041
2042
2043 // XIterateContainer
2044 void SAL_CALL AnimationNode::setIterateInterval( double _iterateinterval )
2045 {
2046     std::unique_lock l( m_aMutex );
2047     if( _iterateinterval != mfIterateInterval )
2048     {
2049         mfIterateInterval = _iterateinterval;
2050         fireChangeListener(l);
2051     }
2052 }
2053
2054
2055 // XChangesNotifier
2056 void SAL_CALL AnimationNode::addChangesListener( const Reference< XChangesListener >& aListener )
2057 {
2058     std::unique_lock l( m_aMutex );
2059     maChangeListener.addInterface( l, aListener );
2060 }
2061
2062
2063 // XChangesNotifier
2064 void SAL_CALL AnimationNode::removeChangesListener( const Reference< XChangesListener >& aListener )
2065 {
2066     std::unique_lock l( m_aMutex );
2067     maChangeListener.removeInterface(l, aListener);
2068 }
2069
2070
2071 void AnimationNode::fireChangeListener(std::unique_lock<std::mutex>& l)
2072 {
2073     if( maChangeListener.getLength(l) != 0 )
2074     {
2075         Reference< XInterface > xSource( static_cast<OWeakObject*>(this), UNO_QUERY );
2076         Sequence< ElementChange > aChanges;
2077         const ChangesEvent aEvent( xSource, Any( css::uno::Reference<XInterface>(static_cast<cppu::OWeakObject*>(mxParent.get().get())) ), aChanges );
2078         OInterfaceIteratorHelper4 aIterator( l, maChangeListener );
2079         l.unlock();
2080         while( aIterator.hasMoreElements() )
2081             aIterator.next()->changesOccurred( aEvent );
2082         l.lock();
2083     }
2084
2085     //fdo#69645 use WeakReference of mxParent to test if mpParent is still valid
2086     rtl::Reference<AnimationNode> xGuard(mxParent);
2087     if (xGuard.is())
2088     {
2089         l.unlock();
2090         std::unique_lock l2(xGuard->m_aMutex);
2091         xGuard->fireChangeListener(l2);
2092     }
2093 }
2094
2095
2096 } // namespace animcore
2097
2098
2099 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2100 com_sun_star_animations_ParallelTimeContainer_get_implementation(css::uno::XComponentContext*,
2101                                                              css::uno::Sequence<css::uno::Any> const &)
2102 {
2103     return cppu::acquire(new animcore::AnimationNode(PAR));
2104 }
2105
2106 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2107 com_sun_star_animations_SequenceTimeContainer_get_implementation(css::uno::XComponentContext*,
2108                                                              css::uno::Sequence<css::uno::Any> const &)
2109 {
2110     return cppu::acquire(new animcore::AnimationNode(SEQ));
2111 }
2112
2113 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2114 com_sun_star_animations_IterateContainer_get_implementation(css::uno::XComponentContext*,
2115                                                              css::uno::Sequence<css::uno::Any> const &)
2116 {
2117     return cppu::acquire(new animcore::AnimationNode(ITERATE));
2118 }
2119
2120 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2121 com_sun_star_animations_Animate_get_implementation(css::uno::XComponentContext*,
2122                                                              css::uno::Sequence<css::uno::Any> const &)
2123 {
2124     return cppu::acquire(new animcore::AnimationNode(ANIMATE));
2125 }
2126
2127 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2128 com_sun_star_animations_AnimateSet_get_implementation(css::uno::XComponentContext*,
2129                                                              css::uno::Sequence<css::uno::Any> const &)
2130 {
2131     return cppu::acquire(new animcore::AnimationNode(SET));
2132 }
2133
2134 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2135 com_sun_star_animations_AnimateColor_get_implementation(css::uno::XComponentContext*,
2136                                                              css::uno::Sequence<css::uno::Any> const &)
2137 {
2138     return cppu::acquire(new animcore::AnimationNode(ANIMATECOLOR));
2139 }
2140
2141 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2142 com_sun_star_animations_AnimateMotion_get_implementation(css::uno::XComponentContext*,
2143                                                              css::uno::Sequence<css::uno::Any> const &)
2144 {
2145     return cppu::acquire(new animcore::AnimationNode(ANIMATEMOTION));
2146 }
2147
2148 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2149 com_sun_star_animations_AnimatePhysics_get_implementation(css::uno::XComponentContext*,
2150                                                              css::uno::Sequence<css::uno::Any> const &)
2151 {
2152     return cppu::acquire(new animcore::AnimationNode(ANIMATEPHYSICS));
2153 }
2154
2155 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2156 com_sun_star_animations_AnimateTransform_get_implementation(css::uno::XComponentContext*,
2157                                                              css::uno::Sequence<css::uno::Any> const &)
2158 {
2159     return cppu::acquire(new animcore::AnimationNode(ANIMATETRANSFORM));
2160 }
2161
2162 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2163 com_sun_star_animations_TransitionFilter_get_implementation(css::uno::XComponentContext*,
2164                                                              css::uno::Sequence<css::uno::Any> const &)
2165 {
2166     return cppu::acquire(new animcore::AnimationNode(TRANSITIONFILTER));
2167 }
2168
2169 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2170 com_sun_star_animations_Audio_get_implementation(css::uno::XComponentContext*,
2171                                                              css::uno::Sequence<css::uno::Any> const &)
2172 {
2173     return cppu::acquire(new animcore::AnimationNode(AUDIO));
2174 }
2175
2176 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
2177 com_sun_star_animations_Command_get_implementation(css::uno::XComponentContext*,
2178                                                              css::uno::Sequence<css::uno::Any> const &)
2179 {
2180     return cppu::acquire(new animcore::AnimationNode(COMMAND));
2181 }
2182
2183 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */