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