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