LCOV - code coverage report
Current view: top level - animations/source/animcore - animcore.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 707 0.0 %
Date: 2014-04-14 Functions: 0 157 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10