summaryrefslogtreecommitdiffstats
path: root/animations/source/animcore/animcore.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'animations/source/animcore/animcore.cxx')
-rw-r--r--animations/source/animcore/animcore.cxx2211
1 files changed, 2211 insertions, 0 deletions
diff --git a/animations/source/animcore/animcore.cxx b/animations/source/animcore/animcore.cxx
new file mode 100644
index 000000000..737da604a
--- /dev/null
+++ b/animations/source/animcore/animcore.cxx
@@ -0,0 +1,2211 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/util/XCloneable.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XTypeProvider.hpp>
+#include <com/sun/star/animations/XAnimateColor.hpp>
+#include <com/sun/star/animations/XAnimateSet.hpp>
+#include <com/sun/star/animations/XAnimateMotion.hpp>
+#include <com/sun/star/animations/XAnimatePhysics.hpp>
+#include <com/sun/star/animations/XAnimateTransform.hpp>
+#include <com/sun/star/animations/XParallelTimeContainer.hpp>
+#include <com/sun/star/animations/XTransitionFilter.hpp>
+#include <com/sun/star/animations/XTimeContainer.hpp>
+#include <com/sun/star/animations/XIterateContainer.hpp>
+#include <com/sun/star/animations/XAudio.hpp>
+#include <com/sun/star/animations/XCommand.hpp>
+#include <com/sun/star/animations/AnimationNodeType.hpp>
+#include <com/sun/star/animations/AnimationCalcMode.hpp>
+#include <com/sun/star/animations/AnimationFill.hpp>
+#include <com/sun/star/animations/AnimationRestart.hpp>
+#include <com/sun/star/animations/AnimationColorSpace.hpp>
+#include <com/sun/star/animations/AnimationAdditiveMode.hpp>
+#include <com/sun/star/animations/AnimationTransformType.hpp>
+#include <com/sun/star/animations/TransitionType.hpp>
+#include <com/sun/star/animations/TransitionSubType.hpp>
+#include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/util/XChangesNotifier.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <comphelper/servicehelper.hxx>
+#include <cppuhelper/basemutex.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <comphelper/interfacecontainer3.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/weakref.hxx>
+
+#include <cppuhelper/implbase.hxx>
+
+#include <o3tl/safeint.hxx>
+#include <osl/mutex.hxx>
+#include <sal/log.hxx>
+#include <array>
+#include <vector>
+#include <algorithm>
+#include <mutex>
+
+namespace com::sun::star::uno { class XComponentContext; }
+namespace com::sun::star::beans { struct NamedValue; }
+
+using ::osl::Mutex;
+using ::osl::Guard;
+using ::comphelper::OInterfaceContainerHelper3;
+using ::comphelper::OInterfaceIteratorHelper3;
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::XInterface;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::WeakReference;
+using ::com::sun::star::uno::XComponentContext;
+using ::com::sun::star::uno::Exception;
+using ::com::sun::star::uno::XWeak;
+using ::com::sun::star::uno::Type;
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::lang::IllegalArgumentException;
+using ::com::sun::star::lang::XServiceInfo;
+using ::com::sun::star::lang::XTypeProvider;
+using ::com::sun::star::container::NoSuchElementException;
+using ::com::sun::star::container::ElementExistException;
+using ::com::sun::star::container::XEnumeration;
+using ::com::sun::star::container::XEnumerationAccess;
+using ::com::sun::star::beans::NamedValue;
+using ::com::sun::star::util::XCloneable;
+using ::com::sun::star::lang::XUnoTunnel;
+using ::com::sun::star::util::XChangesNotifier;
+using ::com::sun::star::util::XChangesListener;
+using ::com::sun::star::util::ElementChange;
+using ::com::sun::star::util::ChangesEvent;
+
+using ::cppu::OWeakObject;
+
+using namespace ::com::sun::star::animations;
+using namespace ::com::sun::star::animations::AnimationNodeType;
+
+namespace animcore
+{
+
+namespace {
+class AnimationNodeBase : public cppu::BaseMutex,
+ public XAnimateMotion,
+ public XAnimatePhysics,
+ public XAnimateColor,
+ public XTransitionFilter,
+ public XAnimateSet,
+ public XAnimateTransform,
+ public XParallelTimeContainer,
+ public XIterateContainer,
+ public XServiceInfo,
+ public XTypeProvider,
+ public XAudio,
+ public XCommand,
+ public XCloneable,
+ public XChangesNotifier,
+ public XUnoTunnel,
+ public OWeakObject
+{
+
+};
+
+class AnimationNode final: public AnimationNodeBase
+{
+public:
+ explicit AnimationNode(sal_Int16 nNodeType);
+ explicit AnimationNode(const AnimationNode& rNode);
+
+ // XInterface
+ virtual Any SAL_CALL queryInterface( const Type& aType ) override;
+ virtual void SAL_CALL acquire() noexcept override;
+ virtual void SAL_CALL release() noexcept override;
+
+ // XTypeProvider
+ virtual Sequence< Type > SAL_CALL getTypes() override;
+ virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() override;
+
+ // XServiceInfo
+ OUString SAL_CALL getImplementationName() override;
+ Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+ sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
+
+ // XChild
+ virtual Reference< XInterface > SAL_CALL getParent() override;
+ virtual void SAL_CALL setParent( const Reference< XInterface >& Parent ) override;
+
+ // XCloneable
+ virtual Reference< XCloneable > SAL_CALL createClone() override;
+
+ // XAnimationNode
+ virtual sal_Int16 SAL_CALL getType() override;
+ virtual Any SAL_CALL getBegin() override;
+ virtual void SAL_CALL setBegin( const Any& _begin ) override;
+ virtual Any SAL_CALL getDuration() override;
+ virtual void SAL_CALL setDuration( const Any& _duration ) override;
+ virtual Any SAL_CALL getEnd() override;
+ virtual void SAL_CALL setEnd( const Any& _end ) override;
+ virtual Any SAL_CALL getEndSync() override;
+ virtual void SAL_CALL setEndSync( const Any& _endsync ) override;
+ virtual Any SAL_CALL getRepeatCount() override;
+ virtual void SAL_CALL setRepeatCount( const Any& _repeatcount ) override;
+ virtual Any SAL_CALL getRepeatDuration() override;
+ virtual void SAL_CALL setRepeatDuration( const Any& _repeatduration ) override;
+ virtual sal_Int16 SAL_CALL getFill() override;
+ virtual void SAL_CALL setFill( sal_Int16 _fill ) override;
+ virtual sal_Int16 SAL_CALL getFillDefault() override;
+ virtual void SAL_CALL setFillDefault( sal_Int16 _filldefault ) override;
+ virtual sal_Int16 SAL_CALL getRestart() override;
+ virtual void SAL_CALL setRestart( sal_Int16 _restart ) override;
+ virtual sal_Int16 SAL_CALL getRestartDefault() override;
+ virtual void SAL_CALL setRestartDefault( sal_Int16 _restartdefault ) override;
+ virtual double SAL_CALL getAcceleration() override;
+ virtual void SAL_CALL setAcceleration( double _acceleration ) override;
+ virtual double SAL_CALL getDecelerate() override;
+ virtual void SAL_CALL setDecelerate( double _decelerate ) override;
+ virtual sal_Bool SAL_CALL getAutoReverse() override;
+ virtual void SAL_CALL setAutoReverse( sal_Bool _autoreverse ) override;
+ virtual Sequence< NamedValue > SAL_CALL getUserData() override;
+ virtual void SAL_CALL setUserData( const Sequence< NamedValue >& _userdata ) override;
+
+ // XAnimate
+ virtual Any SAL_CALL getTarget() override;
+ virtual void SAL_CALL setTarget( const Any& _target ) override;
+ virtual sal_Int16 SAL_CALL getSubItem() override;
+ virtual void SAL_CALL setSubItem( sal_Int16 _subitem ) override;
+ virtual OUString SAL_CALL getAttributeName() override;
+ virtual void SAL_CALL setAttributeName( const OUString& _attribute ) override;
+ virtual Sequence< Any > SAL_CALL getValues() override;
+ virtual void SAL_CALL setValues( const Sequence< Any >& _values ) override;
+ virtual Sequence< double > SAL_CALL getKeyTimes() override;
+ virtual void SAL_CALL setKeyTimes( const Sequence< double >& _keytimes ) override;
+ virtual sal_Int16 SAL_CALL getValueType() override;
+ virtual void SAL_CALL setValueType( sal_Int16 _valuetype ) override;
+ virtual sal_Int16 SAL_CALL getCalcMode() override;
+ virtual void SAL_CALL setCalcMode( sal_Int16 _calcmode ) override;
+ virtual sal_Bool SAL_CALL getAccumulate() override;
+ virtual void SAL_CALL setAccumulate( sal_Bool _accumulate ) override;
+ virtual sal_Int16 SAL_CALL getAdditive() override;
+ virtual void SAL_CALL setAdditive( sal_Int16 _additive ) override;
+ virtual Any SAL_CALL getFrom() override;
+ virtual void SAL_CALL setFrom( const Any& _from ) override;
+ virtual Any SAL_CALL getTo() override;
+ virtual void SAL_CALL setTo( const Any& _to ) override;
+ virtual Any SAL_CALL getBy() override;
+ virtual void SAL_CALL setBy( const Any& _by ) override;
+ virtual Sequence< TimeFilterPair > SAL_CALL getTimeFilter() override;
+ virtual void SAL_CALL setTimeFilter( const Sequence< TimeFilterPair >& _timefilter ) override;
+ virtual OUString SAL_CALL getFormula() override;
+ virtual void SAL_CALL setFormula( const OUString& _formula ) override;
+
+ // XAnimateColor
+ virtual sal_Int16 SAL_CALL getColorInterpolation() override;
+ virtual void SAL_CALL setColorInterpolation( sal_Int16 _colorspace ) override;
+ virtual sal_Bool SAL_CALL getDirection() override;
+ virtual void SAL_CALL setDirection( sal_Bool _direction ) override;
+
+ // XAnimateMotion
+ virtual Any SAL_CALL getPath() override;
+ virtual void SAL_CALL setPath( const Any& _path ) override;
+ virtual Any SAL_CALL getOrigin() override;
+ virtual void SAL_CALL setOrigin( const Any& _origin ) override;
+
+ // XAnimatePhysics
+ virtual Any SAL_CALL getStartVelocityX() override;
+ virtual void SAL_CALL setStartVelocityX( const Any& _startvelocityx ) override;
+ virtual Any SAL_CALL getStartVelocityY() override;
+ virtual void SAL_CALL setStartVelocityY( const Any& _startvelocityy ) override;
+ virtual Any SAL_CALL getDensity() override;
+ virtual void SAL_CALL setDensity( const Any& _density ) override;
+ virtual Any SAL_CALL getBounciness() override;
+ virtual void SAL_CALL setBounciness( const Any& _bounciness ) override;
+
+ // XAnimateTransform
+ virtual sal_Int16 SAL_CALL getTransformType() override;
+ virtual void SAL_CALL setTransformType( sal_Int16 _transformtype ) override;
+
+ // XTransitionFilter
+ virtual sal_Int16 SAL_CALL getTransition() override;
+ virtual void SAL_CALL setTransition( sal_Int16 _transition ) override;
+ virtual sal_Int16 SAL_CALL getSubtype() override;
+ virtual void SAL_CALL setSubtype( sal_Int16 _subtype ) override;
+ virtual sal_Bool SAL_CALL getMode() override;
+ virtual void SAL_CALL setMode( sal_Bool _mode ) override;
+ virtual sal_Int32 SAL_CALL getFadeColor() override;
+ virtual void SAL_CALL setFadeColor( sal_Int32 _fadecolor ) override;
+
+ // XAudio
+ virtual Any SAL_CALL getSource() override;
+ virtual void SAL_CALL setSource( const Any& _source ) override;
+ virtual double SAL_CALL getVolume() override;
+ virtual void SAL_CALL setVolume( double _volume ) override;
+ sal_Bool SAL_CALL getHideDuringShow() override;
+ void SAL_CALL setHideDuringShow(sal_Bool bHideDuringShow) override;
+ sal_Bool SAL_CALL getNarration() override;
+ void SAL_CALL setNarration(sal_Bool bNarration) override;
+
+
+ // XCommand - the following two shadowed by animate, unfortunately
+// virtual Any SAL_CALL getTarget() throw (RuntimeException);
+// virtual void SAL_CALL setTarget( const Any& _target ) throw (RuntimeException);
+ virtual sal_Int16 SAL_CALL getCommand() override;
+ virtual void SAL_CALL setCommand( sal_Int16 _command ) override;
+ virtual Any SAL_CALL getParameter() override;
+ virtual void SAL_CALL setParameter( const Any& _parameter ) override;
+
+ // XElementAccess
+ virtual Type SAL_CALL getElementType() override;
+ virtual sal_Bool SAL_CALL hasElements() override;
+
+ // XEnumerationAccess
+ virtual Reference< XEnumeration > SAL_CALL createEnumeration() override;
+
+ // XTimeContainer
+ virtual Reference< XAnimationNode > SAL_CALL insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) override;
+ virtual Reference< XAnimationNode > SAL_CALL insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild ) override;
+ virtual Reference< XAnimationNode > SAL_CALL replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& oldChild ) override;
+ virtual Reference< XAnimationNode > SAL_CALL removeChild( const Reference< XAnimationNode >& oldChild ) override;
+ virtual Reference< XAnimationNode > SAL_CALL appendChild( const Reference< XAnimationNode >& newChild ) override;
+
+ // XIterateContainer
+ virtual sal_Int16 SAL_CALL getIterateType() override;
+ virtual void SAL_CALL setIterateType( sal_Int16 _iteratetype ) override;
+ virtual double SAL_CALL getIterateInterval() override;
+ virtual void SAL_CALL setIterateInterval( double _iterateinterval ) override;
+
+ // XChangesNotifier
+ virtual void SAL_CALL addChangesListener( const Reference< XChangesListener >& aListener ) override;
+ virtual void SAL_CALL removeChangesListener( const Reference< XChangesListener >& aListener ) override;
+
+ // XUnoTunnel
+ virtual ::sal_Int64 SAL_CALL getSomething( const Sequence< ::sal_Int8 >& aIdentifier ) override;
+
+ static const Sequence< sal_Int8 > & getUnoTunnelId();
+ void fireChangeListener();
+
+private:
+ OInterfaceContainerHelper3<XChangesListener> maChangeListener;
+
+ static void initTypeProvider( sal_Int16 nNodeType ) noexcept;
+
+ const sal_Int16 mnNodeType;
+
+ // for XTypeProvider
+ static std::array<Sequence< Type >*, 13> mpTypes;
+
+ // attributes for the XAnimationNode interface implementation
+ Any maBegin, maDuration, maEnd, maEndSync, maRepeatCount, maRepeatDuration;
+ sal_Int16 mnFill, mnFillDefault, mnRestart, mnRestartDefault;
+ double mfAcceleration, mfDecelerate;
+ bool mbAutoReverse;
+ Sequence< NamedValue > maUserData;
+
+ // parent interface for XChild interface implementation
+ WeakReference<XInterface> mxParent;
+ AnimationNode* mpParent;
+
+ // attributes for XAnimate
+ Any maTarget;
+ OUString maAttributeName, maFormula;
+ Sequence< Any > maValues;
+ Sequence< double > maKeyTimes;
+ sal_Int16 mnValueType, mnSubItem;
+ sal_Int16 mnCalcMode, mnAdditive;
+ bool mbAccumulate;
+ Any maFrom, maTo, maBy;
+ Sequence< TimeFilterPair > maTimeFilter;
+
+ // attributes for XAnimateColor
+ sal_Int16 mnColorSpace;
+ bool mbDirection;
+
+ // attributes for XAnimateMotion
+ Any maPath, maOrigin;
+
+ // attributes for XAnimatePhysics
+ Any maStartVelocityX, maStartVelocityY, maDensity, maBounciness;
+
+ // attributes for XAnimateTransform
+ sal_Int16 mnTransformType;
+
+ // attributes for XTransitionFilter
+ sal_Int16 mnTransition;
+ sal_Int16 mnSubtype;
+ bool mbMode;
+ sal_Int32 mnFadeColor;
+
+ // XAudio
+ double mfVolume;
+ bool mbHideDuringShow;
+ bool mbNarration;
+
+ // XCommand
+ sal_Int16 mnCommand;
+ Any maParameter;
+
+ // XIterateContainer
+ sal_Int16 mnIterateType;
+ double mfIterateInterval;
+
+ /** sorted list of child nodes for XTimeContainer*/
+ std::vector< Reference< XAnimationNode > > maChildren;
+};
+
+
+class TimeContainerEnumeration : public ::cppu::WeakImplHelper< XEnumeration >
+{
+public:
+ explicit TimeContainerEnumeration( std::vector< Reference< XAnimationNode > >&& rChildren );
+
+ // Methods
+ virtual sal_Bool SAL_CALL hasMoreElements() override;
+ virtual Any SAL_CALL nextElement( ) override;
+
+private:
+ std::mutex m_aMutex;
+
+ /** sorted list of child nodes */
+ std::vector< Reference< XAnimationNode > > maChildren;
+
+ /** current iteration position */
+ std::vector< Reference< XAnimationNode > >::iterator maIter;
+};
+
+}
+
+TimeContainerEnumeration::TimeContainerEnumeration( std::vector< Reference< XAnimationNode > >&& rChildren )
+: maChildren( std::move(rChildren) )
+{
+ maIter = maChildren.begin();
+}
+
+// Methods
+sal_Bool SAL_CALL TimeContainerEnumeration::hasMoreElements()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ return maIter != maChildren.end();
+}
+
+Any SAL_CALL TimeContainerEnumeration::nextElement()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if( maIter == maChildren.end() )
+ throw NoSuchElementException();
+
+ return Any( *maIter++ );
+}
+
+
+std::array<Sequence< Type >*, 13> AnimationNode::mpTypes = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+
+AnimationNode::AnimationNode( sal_Int16 nNodeType )
+: AnimationNodeBase(),
+ maChangeListener(m_aMutex),
+ mnNodeType( nNodeType ),
+ mnFill( AnimationFill::DEFAULT ),
+ mnFillDefault( AnimationFill::INHERIT ),
+ mnRestart( AnimationRestart:: DEFAULT ),
+ mnRestartDefault( AnimationRestart:: INHERIT ),
+ mfAcceleration( 0.0 ),
+ mfDecelerate( 0.0 ),
+ mbAutoReverse( false ),
+ mpParent(nullptr),
+ mnValueType( 0 ),
+ mnSubItem( 0 ),
+ mnCalcMode( (nNodeType == AnimationNodeType::ANIMATEMOTION) ? AnimationCalcMode::PACED : AnimationCalcMode::LINEAR),
+ mnAdditive(AnimationAdditiveMode::REPLACE),
+ mbAccumulate(false),
+ mnColorSpace( AnimationColorSpace::RGB ),
+ mbDirection( true ),
+ mnTransformType( AnimationTransformType::TRANSLATE ),
+ mnTransition(TransitionType::BARWIPE),
+ mnSubtype(TransitionSubType::DEFAULT),
+ mbMode(true),
+ mnFadeColor(0),
+ mfVolume(1.0),
+ mbHideDuringShow(false),
+ mbNarration(false),
+ mnCommand(0),
+ mnIterateType( css::presentation::ShapeAnimationSubType::AS_WHOLE ),
+ mfIterateInterval(0.0)
+{
+ assert(nNodeType >= 0 && o3tl::make_unsigned(nNodeType) < mpTypes.size());
+}
+
+AnimationNode::AnimationNode( const AnimationNode& rNode )
+: AnimationNodeBase(),
+ maChangeListener(m_aMutex),
+ mnNodeType( rNode.mnNodeType ),
+
+ // attributes for the XAnimationNode interface implementation
+ maBegin( rNode.maBegin ),
+ maDuration( rNode.maDuration ),
+ maEnd( rNode.maEnd ),
+ maEndSync( rNode.maEndSync ),
+ maRepeatCount( rNode.maRepeatCount ),
+ maRepeatDuration( rNode.maRepeatDuration ),
+ mnFill( rNode.mnFill ),
+ mnFillDefault( rNode.mnFillDefault ),
+ mnRestart( rNode.mnRestart ),
+ mnRestartDefault( rNode.mnRestartDefault ),
+ mfAcceleration( rNode.mfAcceleration ),
+ mfDecelerate( rNode.mfDecelerate ),
+ mbAutoReverse( rNode.mbAutoReverse ),
+ maUserData( rNode.maUserData ),
+ mpParent(nullptr),
+
+ // attributes for XAnimate
+ maTarget( rNode.maTarget ),
+ maAttributeName( rNode.maAttributeName ),
+ maFormula( rNode.maFormula ),
+ maValues( rNode.maValues ),
+ maKeyTimes( rNode.maKeyTimes ),
+ mnValueType( rNode.mnValueType ),
+ mnSubItem( rNode.mnSubItem ),
+ mnCalcMode( rNode.mnCalcMode ),
+ mnAdditive( rNode.mnAdditive ),
+ mbAccumulate( rNode.mbAccumulate ),
+ maFrom( rNode.maFrom ),
+ maTo( rNode.maTo ),
+ maBy( rNode.maBy ),
+ maTimeFilter( rNode.maTimeFilter ),
+
+ // attributes for XAnimateColor
+ mnColorSpace( rNode.mnColorSpace ),
+ mbDirection( rNode.mbDirection ),
+
+ // attributes for XAnimateMotion
+ maPath( rNode.maPath ),
+ maOrigin( rNode.maOrigin ),
+
+ // attributes for XAnimatePhysics
+ maStartVelocityX( rNode.maStartVelocityX ),
+ maStartVelocityY( rNode.maStartVelocityY ),
+ maDensity( rNode.maDensity ),
+ maBounciness( rNode.maBounciness ),
+
+ // attributes for XAnimateTransform
+ mnTransformType( rNode.mnTransformType ),
+
+ // attributes for XTransitionFilter
+ mnTransition( rNode.mnTransition ),
+ mnSubtype( rNode.mnSubtype ),
+ mbMode( rNode.mbMode ),
+ mnFadeColor( rNode.mnFadeColor ),
+
+ // XAudio
+ mfVolume( rNode.mfVolume ),
+ mbHideDuringShow(rNode.mbHideDuringShow),
+ mbNarration(rNode.mbNarration),
+
+ // XCommand
+ mnCommand( rNode.mnCommand ),
+ maParameter( rNode.maParameter ),
+
+ // XIterateContainer
+ mnIterateType( rNode.mnIterateType ),
+ mfIterateInterval( rNode.mfIterateInterval )
+{
+}
+
+static Sequence<OUString> getSupportedServiceNames_PAR()
+{
+ return { "com.sun.star.animations.ParallelTimeContainer" };
+}
+
+static OUString getImplementationName_PAR()
+{
+ return "animcore::ParallelTimeContainer";
+}
+
+static Sequence<OUString> getSupportedServiceNames_SEQ()
+{
+ return { "com.sun.star.animations.SequenceTimeContainer" };
+}
+
+static OUString getImplementationName_SEQ()
+{
+ return "animcore::SequenceTimeContainer";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ITERATE()
+{
+ return { "com.sun.star.animations.IterateContainer" };
+}
+
+static OUString getImplementationName_ITERATE()
+{
+ return "animcore::IterateContainer";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ANIMATE()
+{
+ return { "com.sun.star.animations.Animate" };
+}
+
+static OUString getImplementationName_ANIMATE()
+{
+ return "animcore::Animate";
+}
+
+static Sequence<OUString> getSupportedServiceNames_SET()
+{
+ return { "com.sun.star.animations.AnimateSet" };
+}
+
+static OUString getImplementationName_SET()
+{
+ return "animcore::AnimateSet";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ANIMATECOLOR()
+{
+ return { "com.sun.star.animations.AnimateColor" };
+}
+
+static OUString getImplementationName_ANIMATECOLOR()
+{
+ return "animcore::AnimateColor";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ANIMATEMOTION()
+{
+ return { "com.sun.star.animations.AnimateMotion" };
+}
+
+static OUString getImplementationName_ANIMATEMOTION()
+{
+ return "animcore::AnimateMotion";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ANIMATEPHYSICS()
+{
+ return { "com.sun.star.animations.AnimatePhysics" };
+}
+
+static OUString getImplementationName_ANIMATEPHYSICS()
+{
+ return "animcore::AnimatePhysics";
+}
+
+static Sequence<OUString> getSupportedServiceNames_ANIMATETRANSFORM()
+{
+ return { "com.sun.star.animations.AnimateTransform" };
+}
+
+static OUString getImplementationName_ANIMATETRANSFORM()
+{
+ return "animcore::AnimateTransform";
+}
+
+static Sequence<OUString> getSupportedServiceNames_TRANSITIONFILTER()
+{
+ return { "com.sun.star.animations.TransitionFilter" };
+}
+
+static OUString getImplementationName_TRANSITIONFILTER()
+{
+ return "animcore::TransitionFilter";
+}
+
+static Sequence<OUString> getSupportedServiceNames_AUDIO()
+{
+ return { "com.sun.star.animations.Audio" };
+}
+
+static OUString getImplementationName_AUDIO()
+{
+ return "animcore::Audio";
+}
+
+static Sequence<OUString> getSupportedServiceNames_COMMAND()
+{
+ return { "com.sun.star.animations.Command" };
+}
+
+static OUString getImplementationName_COMMAND()
+{
+ return "animcore::Command";
+}
+
+// XInterface
+Any SAL_CALL AnimationNode::queryInterface( const Type& aType )
+{
+ Any aRet( ::cppu::queryInterface(
+ aType,
+ static_cast< XServiceInfo * >( this ),
+ static_cast< XTypeProvider * >( this ),
+ static_cast< XChild * >( static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ) ),
+ static_cast< XCloneable* >( this ),
+ static_cast< XAnimationNode* >( static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ) ),
+ static_cast< XInterface* >(static_cast< OWeakObject * >(this)),
+ static_cast< XWeak* >(static_cast< OWeakObject * >(this)),
+ static_cast< XChangesNotifier* >( this ),
+ static_cast< XUnoTunnel* >( this ) ) );
+
+ if(!aRet.hasValue())
+ {
+ switch( mnNodeType )
+ {
+ case AnimationNodeType::PAR:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XParallelTimeContainer * >( this ),
+ static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
+ static_cast< XEnumerationAccess * >( this ),
+ static_cast< XElementAccess * >( this ) );
+ break;
+ case AnimationNodeType::SEQ:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
+ static_cast< XEnumerationAccess * >( this ),
+ static_cast< XElementAccess * >( this ) );
+ break;
+ case AnimationNodeType::ITERATE:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XTimeContainer * >( static_cast< XIterateContainer * >(this) ),
+ static_cast< XIterateContainer * >( this ),
+ static_cast< XEnumerationAccess * >( this ),
+ static_cast< XElementAccess * >( this ) );
+ break;
+ case AnimationNodeType::ANIMATE:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimateMotion * >(this) ) );
+ break;
+ case AnimationNodeType::ANIMATEMOTION:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimateMotion * >(this) ),
+ static_cast< XAnimateMotion * >( this ) );
+ break;
+ case AnimationNodeType::ANIMATEPHYSICS:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimatePhysics * >(this) ),
+ static_cast< XAnimatePhysics * >( this ) );
+ break;
+ case AnimationNodeType::ANIMATECOLOR:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimateColor * >(this) ),
+ static_cast< XAnimateColor * >( this ) );
+ break;
+ case AnimationNodeType::SET:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimateSet * >(this) ),
+ static_cast< XAnimateSet * >( this ) );
+ break;
+ case AnimationNodeType::ANIMATETRANSFORM:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XAnimateTransform * >(this) ),
+ static_cast< XAnimateTransform * >( this ) );
+ break;
+ case AnimationNodeType::AUDIO:
+ aRet = ::cppu::queryInterface(aType, static_cast< XAudio * >(this) );
+ break;
+ case AnimationNodeType::COMMAND:
+ aRet = ::cppu::queryInterface(
+ aType, static_cast< XCommand * >(this) );
+ break;
+ case AnimationNodeType::TRANSITIONFILTER:
+ aRet = ::cppu::queryInterface(
+ aType,
+ static_cast< XAnimate * >( static_cast< XTransitionFilter * >(this) ),
+ static_cast< XTransitionFilter * >( this ) );
+ break;
+ }
+ }
+
+ return aRet.hasValue() ? aRet : OWeakObject::queryInterface( aType );
+}
+
+
+void AnimationNode::initTypeProvider( sal_Int16 nNodeType ) noexcept
+{
+ ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
+
+ if( mpTypes[nNodeType] )
+ return;
+
+ static constexpr std::array<sal_Int32, mpTypes.size()> type_numbers =
+ {
+ 7, // CUSTOM
+ 9, // PAR
+ 9, // SEQ
+ 9, // ITERATE
+ 8, // ANIMATE
+ 8, // SET
+ 8, // ANIMATEMOTION
+ 8, // ANIMATECOLOR
+ 8, // ANIMATETRANSFORM
+ 8, // TRANSITIONFILTER
+ 8, // AUDIO
+ 8, // COMMAND
+ 8, // ANIMATEPHYSICS
+ };
+
+ // collect types
+ Sequence< Type > * types = new Sequence< Type >( type_numbers[nNodeType] );
+ Type * pTypeAr = types->getArray();
+ sal_Int32 nPos = 0;
+
+ pTypeAr[nPos++] = cppu::UnoType<XWeak>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XChild>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XCloneable>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XTypeProvider>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XServiceInfo>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XUnoTunnel>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XChangesNotifier>::get();
+
+ switch( nNodeType )
+ {
+ case AnimationNodeType::PAR:
+ case AnimationNodeType::SEQ:
+ pTypeAr[nPos++] = cppu::UnoType<XTimeContainer>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XEnumerationAccess>::get();
+ break;
+ case AnimationNodeType::ITERATE:
+ pTypeAr[nPos++] = cppu::UnoType<XIterateContainer>::get();
+ pTypeAr[nPos++] = cppu::UnoType<XEnumerationAccess>::get();
+ break;
+ case AnimationNodeType::ANIMATE:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimate>::get();
+ break;
+ case AnimationNodeType::ANIMATEMOTION:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimateMotion>::get();
+ break;
+ case AnimationNodeType::ANIMATEPHYSICS:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimatePhysics>::get();
+ break;
+ case AnimationNodeType::ANIMATECOLOR:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimateColor>::get();
+ break;
+ case AnimationNodeType::ANIMATETRANSFORM:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimateTransform>::get();
+ break;
+ case AnimationNodeType::SET:
+ pTypeAr[nPos++] = cppu::UnoType<XAnimateSet>::get();
+ break;
+ case AnimationNodeType::TRANSITIONFILTER:
+ pTypeAr[nPos++] = cppu::UnoType<XTransitionFilter>::get();
+ break;
+ case AnimationNodeType::AUDIO:
+ pTypeAr[nPos++] = cppu::UnoType<XAudio>::get();
+ break;
+ case AnimationNodeType::COMMAND:
+ pTypeAr[nPos++] = cppu::UnoType<XCommand>::get();
+ break;
+ }
+ mpTypes[nNodeType] = types;
+}
+
+
+Sequence< Type > AnimationNode::getTypes()
+{
+ if (! mpTypes[mnNodeType])
+ initTypeProvider(mnNodeType);
+ return *mpTypes[mnNodeType];
+}
+
+
+Sequence< sal_Int8 > AnimationNode::getImplementationId()
+{
+ return css::uno::Sequence<sal_Int8>();
+}
+
+
+// XInterface
+void SAL_CALL AnimationNode::acquire( ) noexcept
+{
+ OWeakObject::acquire();
+}
+
+
+// XInterface
+void SAL_CALL AnimationNode::release( ) noexcept
+{
+ OWeakObject::release();
+}
+
+
+// XServiceInfo
+OUString AnimationNode::getImplementationName()
+{
+ switch( mnNodeType )
+ {
+ case AnimationNodeType::PAR:
+ return getImplementationName_PAR();
+ case AnimationNodeType::SEQ:
+ return getImplementationName_SEQ();
+ case AnimationNodeType::ITERATE:
+ return getImplementationName_ITERATE();
+ case AnimationNodeType::SET:
+ return getImplementationName_SET();
+ case AnimationNodeType::ANIMATECOLOR:
+ return getImplementationName_ANIMATECOLOR();
+ case AnimationNodeType::ANIMATEMOTION:
+ return getImplementationName_ANIMATEMOTION();
+ case AnimationNodeType::ANIMATEPHYSICS:
+ return getImplementationName_ANIMATEPHYSICS();
+ case AnimationNodeType::TRANSITIONFILTER:
+ return getImplementationName_TRANSITIONFILTER();
+ case AnimationNodeType::ANIMATETRANSFORM:
+ return getImplementationName_ANIMATETRANSFORM();
+ case AnimationNodeType::AUDIO:
+ return getImplementationName_AUDIO();
+ case AnimationNodeType::COMMAND:
+ return getImplementationName_COMMAND();
+ case AnimationNodeType::ANIMATE:
+ default:
+ return getImplementationName_ANIMATE();
+ }
+}
+
+// XServiceInfo
+sal_Bool AnimationNode::supportsService(const OUString& ServiceName)
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+// XServiceInfo
+Sequence< OUString > AnimationNode::getSupportedServiceNames()
+{
+ switch( mnNodeType )
+ {
+ case AnimationNodeType::PAR:
+ return getSupportedServiceNames_PAR();
+ case AnimationNodeType::SEQ:
+ return getSupportedServiceNames_SEQ();
+ case AnimationNodeType::ITERATE:
+ return getSupportedServiceNames_ITERATE();
+ case AnimationNodeType::SET:
+ return getSupportedServiceNames_SET();
+ case AnimationNodeType::ANIMATECOLOR:
+ return getSupportedServiceNames_ANIMATECOLOR();
+ case AnimationNodeType::ANIMATEMOTION:
+ return getSupportedServiceNames_ANIMATEMOTION();
+ case AnimationNodeType::ANIMATEPHYSICS:
+ return getSupportedServiceNames_ANIMATEPHYSICS();
+ case AnimationNodeType::TRANSITIONFILTER:
+ return getSupportedServiceNames_TRANSITIONFILTER();
+ case AnimationNodeType::ANIMATETRANSFORM:
+ return getSupportedServiceNames_ANIMATETRANSFORM();
+ case AnimationNodeType::AUDIO:
+ return getSupportedServiceNames_AUDIO();
+ case AnimationNodeType::COMMAND:
+ return getSupportedServiceNames_COMMAND();
+ case AnimationNodeType::ANIMATE:
+ default:
+ return getSupportedServiceNames_ANIMATE();
+ }
+}
+
+
+// XAnimationNode
+sal_Int16 SAL_CALL AnimationNode::getType()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnNodeType;
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getBegin()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maBegin;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setBegin( const Any& _begin )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _begin != maBegin )
+ {
+ maBegin = _begin;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getDuration()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maDuration;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setDuration( const Any& _duration )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _duration != maDuration )
+ {
+ maDuration = _duration;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getEnd()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maEnd;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setEnd( const Any& _end )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _end != maEnd )
+ {
+ maEnd = _end;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getEndSync()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maEndSync;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setEndSync( const Any& _endsync )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _endsync != maEndSync )
+ {
+ maEndSync = _endsync;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getRepeatCount()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maRepeatCount;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setRepeatCount( const Any& _repeatcount )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _repeatcount != maRepeatCount )
+ {
+ maRepeatCount = _repeatcount;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+Any SAL_CALL AnimationNode::getRepeatDuration()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maRepeatDuration;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setRepeatDuration( const Any& _repeatduration )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _repeatduration != maRepeatDuration )
+ {
+ maRepeatDuration = _repeatduration;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+sal_Int16 SAL_CALL AnimationNode::getFill()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnFill;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setFill( sal_Int16 _fill )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _fill != mnFill )
+ {
+ mnFill = _fill;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+sal_Int16 SAL_CALL AnimationNode::getFillDefault()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnFillDefault;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setFillDefault( sal_Int16 _filldefault )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _filldefault != mnFillDefault )
+ {
+ mnFillDefault = _filldefault;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+sal_Int16 SAL_CALL AnimationNode::getRestart()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnRestart;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setRestart( sal_Int16 _restart )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _restart != mnRestart )
+ {
+ mnRestart = _restart;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+sal_Int16 SAL_CALL AnimationNode::getRestartDefault()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnRestartDefault;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setRestartDefault( sal_Int16 _restartdefault )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _restartdefault != mnRestartDefault )
+ {
+ mnRestartDefault = _restartdefault;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+double SAL_CALL AnimationNode::getAcceleration()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mfAcceleration;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setAcceleration( double _acceleration )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _acceleration != mfAcceleration )
+ {
+ mfAcceleration = _acceleration;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+double SAL_CALL AnimationNode::getDecelerate()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mfDecelerate;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setDecelerate( double _decelerate )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _decelerate != mfDecelerate )
+ {
+ mfDecelerate = _decelerate;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimationNode
+sal_Bool SAL_CALL AnimationNode::getAutoReverse()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mbAutoReverse;
+}
+
+
+// XAnimationNode
+void SAL_CALL AnimationNode::setAutoReverse( sal_Bool _autoreverse )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( bool(_autoreverse) != mbAutoReverse )
+ {
+ mbAutoReverse = _autoreverse;
+ fireChangeListener();
+ }
+}
+
+
+Sequence< NamedValue > SAL_CALL AnimationNode::getUserData()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maUserData;
+}
+
+
+void SAL_CALL AnimationNode::setUserData( const Sequence< NamedValue >& _userdata )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maUserData = _userdata;
+ fireChangeListener();
+}
+
+
+// XChild
+Reference< XInterface > SAL_CALL AnimationNode::getParent()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mxParent.get();
+}
+
+
+// XChild
+void SAL_CALL AnimationNode::setParent( const Reference< XInterface >& Parent )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( Parent != mxParent.get() )
+ {
+ mxParent = Parent;
+ mpParent = comphelper::getFromUnoTunnel<AnimationNode>(mxParent.get());
+
+ fireChangeListener();
+ }
+}
+
+
+// XCloneable
+Reference< XCloneable > SAL_CALL AnimationNode::createClone()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ Reference< XCloneable > xNewNode;
+ try
+ {
+ xNewNode = new AnimationNode( *this );
+
+ if( !maChildren.empty() )
+ {
+ Reference< XTimeContainer > xContainer( xNewNode, UNO_QUERY );
+ if( xContainer.is() )
+ {
+ for (auto const& child : maChildren)
+ {
+ Reference< XCloneable > xCloneable(child, UNO_QUERY );
+ if( xCloneable.is() ) try
+ {
+ Reference< XAnimationNode > xNewChildNode( xCloneable->createClone(), UNO_QUERY );
+ if( xNewChildNode.is() )
+ xContainer->appendChild( xNewChildNode );
+ }
+ catch(const Exception&)
+ {
+ SAL_INFO("animations", "animations::AnimationNode::createClone(), exception caught!");
+ }
+ }
+ }
+ }
+ }
+ catch(const Exception&)
+ {
+ SAL_INFO("animations", "animations::AnimationNode::createClone(), exception caught!");
+ }
+
+ return xNewNode;
+}
+
+
+// XAnimate
+Any SAL_CALL AnimationNode::getTarget()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maTarget;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setTarget( const Any& _target )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _target != maTarget )
+ {
+ maTarget= _target;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+OUString SAL_CALL AnimationNode::getAttributeName()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maAttributeName;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setAttributeName( const OUString& _attribute )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _attribute != maAttributeName )
+ {
+ maAttributeName = _attribute;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Sequence< Any > SAL_CALL AnimationNode::getValues()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maValues;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setValues( const Sequence< Any >& _values )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maValues = _values;
+ fireChangeListener();
+}
+
+
+// XAnimate
+sal_Int16 SAL_CALL AnimationNode::getSubItem()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnSubItem;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setSubItem( sal_Int16 _subitem )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _subitem != mnSubItem )
+ {
+ mnSubItem = _subitem;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Sequence< double > SAL_CALL AnimationNode::getKeyTimes()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maKeyTimes;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setKeyTimes( const Sequence< double >& _keytimes )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maKeyTimes = _keytimes;
+ fireChangeListener();
+}
+
+
+// XAnimate
+sal_Int16 SAL_CALL AnimationNode::getValueType()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnValueType;
+}
+
+
+void SAL_CALL AnimationNode::setValueType( sal_Int16 _valuetype )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _valuetype != mnValueType )
+ {
+ mnValueType = _valuetype;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+sal_Int16 SAL_CALL AnimationNode::getCalcMode()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnCalcMode;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setCalcMode( sal_Int16 _calcmode )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _calcmode != mnCalcMode )
+ {
+ mnCalcMode = _calcmode;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+sal_Bool SAL_CALL AnimationNode::getAccumulate()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mbAccumulate;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setAccumulate( sal_Bool _accumulate )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( bool(_accumulate) != mbAccumulate )
+ {
+ mbAccumulate = _accumulate;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+sal_Int16 SAL_CALL AnimationNode::getAdditive()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnAdditive;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setAdditive( sal_Int16 _additive )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _additive != mnAdditive )
+ {
+ mnAdditive = _additive;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Any SAL_CALL AnimationNode::getFrom()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maFrom;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setFrom( const Any& _from )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _from != maFrom )
+ {
+ maFrom = _from;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Any SAL_CALL AnimationNode::getTo()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maTo;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setTo( const Any& _to )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _to != maTo )
+ {
+ maTo = _to;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Any SAL_CALL AnimationNode::getBy()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maBy;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setBy( const Any& _by )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _by != maBy )
+ {
+ maBy = _by;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimate
+Sequence< TimeFilterPair > SAL_CALL AnimationNode::getTimeFilter()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maTimeFilter;
+}
+
+
+// XAnimate
+void SAL_CALL AnimationNode::setTimeFilter( const Sequence< TimeFilterPair >& _timefilter )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maTimeFilter = _timefilter;
+ fireChangeListener();
+}
+
+
+OUString SAL_CALL AnimationNode::getFormula()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maFormula;
+}
+
+
+void SAL_CALL AnimationNode::setFormula( const OUString& _formula )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _formula != maFormula )
+ {
+ maFormula = _formula;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimateColor
+sal_Int16 SAL_CALL AnimationNode::getColorInterpolation()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnColorSpace;
+}
+
+
+// XAnimateColor
+void SAL_CALL AnimationNode::setColorInterpolation( sal_Int16 _colorspace )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _colorspace != mnColorSpace )
+ {
+ mnColorSpace = _colorspace;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimateColor
+sal_Bool SAL_CALL AnimationNode::getDirection()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mbDirection;
+}
+
+
+// XAnimateColor
+void SAL_CALL AnimationNode::setDirection( sal_Bool _direction )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( bool(_direction) != mbDirection )
+ {
+ mbDirection = _direction;
+ fireChangeListener();
+ }
+}
+
+
+// XAnimateMotion
+Any SAL_CALL AnimationNode::getPath()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maPath;
+}
+
+
+// XAnimateMotion
+void SAL_CALL AnimationNode::setPath( const Any& _path )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maPath = _path;
+ fireChangeListener();
+}
+
+
+// XAnimateMotion
+Any SAL_CALL AnimationNode::getOrigin()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maOrigin;
+}
+
+
+// XAnimateMotion
+void SAL_CALL AnimationNode::setOrigin( const Any& _origin )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maOrigin = _origin;
+ fireChangeListener();
+}
+
+// XAnimatePhysics
+Any SAL_CALL AnimationNode::getStartVelocityX()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maStartVelocityX;
+}
+
+
+// XAnimatePhysics
+void SAL_CALL AnimationNode::setStartVelocityX( const Any& _startvelocityx )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maStartVelocityX = _startvelocityx;
+ fireChangeListener();
+}
+
+// XAnimatePhysics
+Any SAL_CALL AnimationNode::getStartVelocityY()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maStartVelocityY;
+}
+
+
+// XAnimatePhysics
+void SAL_CALL AnimationNode::setStartVelocityY( const Any& _startvelocityy )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maStartVelocityY = _startvelocityy;
+ fireChangeListener();
+}
+
+
+// XAnimatePhysics
+Any SAL_CALL AnimationNode::getDensity()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maDensity;
+}
+
+
+// XAnimatePhysics
+void SAL_CALL AnimationNode::setDensity( const Any& _density )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maDensity = _density;
+ fireChangeListener();
+}
+
+
+// XAnimatePhysics
+Any SAL_CALL AnimationNode::getBounciness()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maBounciness;
+}
+
+
+// XAnimatePhysics
+void SAL_CALL AnimationNode::setBounciness( const Any& _bounciness )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maBounciness = _bounciness;
+ fireChangeListener();
+}
+
+
+// XAnimateTransform
+sal_Int16 SAL_CALL AnimationNode::getTransformType()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnTransformType;
+}
+
+
+// XAnimateTransform
+void SAL_CALL AnimationNode::setTransformType( sal_Int16 _transformtype )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _transformtype != mnTransformType )
+ {
+ mnTransformType = _transformtype;
+ fireChangeListener();
+ }
+}
+
+
+// XTransitionFilter
+sal_Int16 SAL_CALL AnimationNode::getTransition()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnTransition;
+}
+
+
+// XTransitionFilter
+void SAL_CALL AnimationNode::setTransition( sal_Int16 _transition )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _transition != mnTransition )
+ {
+ mnTransition = _transition;
+ fireChangeListener();
+ }
+}
+
+
+// XTransitionFilter
+sal_Int16 SAL_CALL AnimationNode::getSubtype()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnSubtype;
+}
+
+
+// XTransitionFilter
+void SAL_CALL AnimationNode::setSubtype( sal_Int16 _subtype )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _subtype != mnSubtype )
+ {
+ mnSubtype = _subtype;
+ fireChangeListener();
+ }
+}
+
+
+// XTransitionFilter
+sal_Bool SAL_CALL AnimationNode::getMode()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mbMode;
+}
+
+
+// XTransitionFilter
+void SAL_CALL AnimationNode::setMode( sal_Bool _mode )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( bool(_mode) != mbMode )
+ {
+ mbMode = _mode;
+ fireChangeListener();
+ }
+}
+
+
+// XTransitionFilter
+sal_Int32 SAL_CALL AnimationNode::getFadeColor()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnFadeColor;
+}
+
+
+// XTransitionFilter
+void SAL_CALL AnimationNode::setFadeColor( sal_Int32 _fadecolor )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _fadecolor != mnFadeColor )
+ {
+ mnFadeColor = _fadecolor;
+ fireChangeListener();
+ }
+}
+
+
+// XAudio
+Any SAL_CALL AnimationNode::getSource()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maTarget;
+}
+
+
+// XAudio
+void SAL_CALL AnimationNode::setSource( const Any& _source )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maTarget = _source;
+ fireChangeListener();
+}
+
+
+// XAudio
+double SAL_CALL AnimationNode::getVolume()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mfVolume;
+}
+
+
+// XAudio
+void SAL_CALL AnimationNode::setVolume( double _volume )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _volume != mfVolume )
+ {
+ mfVolume = _volume;
+ fireChangeListener();
+ }
+}
+
+sal_Bool SAL_CALL AnimationNode::getHideDuringShow()
+{
+ osl::Guard<osl::Mutex> aGuard(m_aMutex);
+ return mbHideDuringShow;
+}
+
+void SAL_CALL AnimationNode::setHideDuringShow(sal_Bool bHideDuringShow)
+{
+ osl::Guard<osl::Mutex> aGuard(m_aMutex);
+ if (static_cast<bool>(bHideDuringShow) != mbHideDuringShow)
+ {
+ mbHideDuringShow = bHideDuringShow;
+ fireChangeListener();
+ }
+}
+
+sal_Bool SAL_CALL AnimationNode::getNarration()
+{
+ osl::Guard<osl::Mutex> aGuard(m_aMutex);
+ return mbNarration;
+}
+
+void SAL_CALL AnimationNode::setNarration(sal_Bool bNarration)
+{
+ osl::Guard<osl::Mutex> aGuard(m_aMutex);
+ if (static_cast<bool>(bNarration) != mbNarration)
+ {
+ mbNarration = bNarration;
+ fireChangeListener();
+ }
+}
+
+// XCommand
+sal_Int16 SAL_CALL AnimationNode::getCommand()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnCommand;
+}
+
+
+// XCommand
+void SAL_CALL AnimationNode::setCommand( sal_Int16 _command )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _command != mnCommand )
+ {
+ mnCommand = _command;
+ fireChangeListener();
+ }
+}
+
+
+// XCommand
+Any SAL_CALL AnimationNode::getParameter()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return maParameter;
+}
+
+
+// XCommand
+void SAL_CALL AnimationNode::setParameter( const Any& _parameter )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ maParameter = _parameter;
+ fireChangeListener();
+}
+
+
+// XElementAccess
+Type SAL_CALL AnimationNode::getElementType()
+{
+ return cppu::UnoType<XAnimationNode>::get();
+}
+
+
+// XElementAccess
+sal_Bool SAL_CALL AnimationNode::hasElements()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return !maChildren.empty();
+}
+
+
+// XEnumerationAccess
+Reference< XEnumeration > SAL_CALL AnimationNode::createEnumeration()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ return new TimeContainerEnumeration(std::vector(maChildren));
+}
+
+
+// XTimeContainer
+Reference< XAnimationNode > SAL_CALL AnimationNode::insertBefore( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ if( !newChild.is() || !refChild.is() )
+ throw IllegalArgumentException("no child", static_cast<cppu::OWeakObject*>(this), -1);
+
+ if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
+ throw ElementExistException();
+
+ auto before = std::find(maChildren.begin(), maChildren.end(), refChild);
+ if( before == maChildren.end() )
+ throw NoSuchElementException();
+
+ maChildren.insert( before, newChild );
+
+ Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
+ newChild->setParent( xThis );
+
+ return newChild;
+}
+
+
+// XTimeContainer
+Reference< XAnimationNode > SAL_CALL AnimationNode::insertAfter( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& refChild )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ if( !newChild.is() || !refChild.is() )
+ throw IllegalArgumentException("no child", static_cast<cppu::OWeakObject*>(this), -1);
+
+ if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
+ throw ElementExistException();
+
+ auto before = std::find(maChildren.begin(), maChildren.end(), refChild);
+ if( before == maChildren.end() )
+ throw NoSuchElementException();
+
+ ++before;
+ if( before != maChildren.end() )
+ maChildren.insert( before, newChild );
+ else
+ maChildren.push_back( newChild );
+
+ Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
+ newChild->setParent( xThis );
+
+ return newChild;
+}
+
+
+// XTimeContainer
+Reference< XAnimationNode > SAL_CALL AnimationNode::replaceChild( const Reference< XAnimationNode >& newChild, const Reference< XAnimationNode >& oldChild )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ if( !newChild.is() || !oldChild.is() )
+ throw IllegalArgumentException("no child", static_cast<cppu::OWeakObject*>(this), -1);
+
+ if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
+ throw ElementExistException();
+
+ auto replace = std::find(maChildren.begin(), maChildren.end(), oldChild);
+ if( replace == maChildren.end() )
+ throw NoSuchElementException();
+
+ oldChild->setParent( Reference< XInterface >() );
+
+ (*replace) = newChild;
+
+ Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
+ newChild->setParent( xThis );
+
+ return newChild;
+}
+
+
+// XTimeContainer
+Reference< XAnimationNode > SAL_CALL AnimationNode::removeChild( const Reference< XAnimationNode >& oldChild )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ if( !oldChild.is() )
+ throw IllegalArgumentException("no child", static_cast<cppu::OWeakObject*>(this), 1);
+
+ auto old = std::find(maChildren.begin(), maChildren.end(), oldChild);
+ if( old == maChildren.end() )
+ throw NoSuchElementException();
+
+ oldChild->setParent( Reference< XInterface >() );
+
+ maChildren.erase( old );
+
+ return oldChild;
+}
+
+
+// XTimeContainer
+Reference< XAnimationNode > SAL_CALL AnimationNode::appendChild( const Reference< XAnimationNode >& newChild )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ if( !newChild.is() )
+ throw IllegalArgumentException("no child", static_cast<cppu::OWeakObject*>(this), 1);
+
+ if( std::find(maChildren.begin(), maChildren.end(), newChild) != maChildren.end() )
+ throw ElementExistException();
+
+ Reference< XInterface > xThis( static_cast< OWeakObject * >(this) );
+ Reference< XInterface > xChild( newChild );
+
+ if( xThis == xChild )
+ throw IllegalArgumentException("cannot append self", static_cast<cppu::OWeakObject*>(this), -1);
+
+ maChildren.push_back( newChild );
+
+ newChild->setParent( xThis );
+
+ return newChild;
+}
+
+
+// XIterateContainer
+sal_Int16 SAL_CALL AnimationNode::getIterateType()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mnIterateType;
+}
+
+
+// XIterateContainer
+void SAL_CALL AnimationNode::setIterateType( sal_Int16 _iteratetype )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _iteratetype != mnIterateType )
+ {
+ mnIterateType = _iteratetype;
+ fireChangeListener();
+ }
+}
+
+
+// XIterateContainer
+double SAL_CALL AnimationNode::getIterateInterval()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ return mfIterateInterval;
+}
+
+
+// XIterateContainer
+void SAL_CALL AnimationNode::setIterateInterval( double _iterateinterval )
+{
+ Guard< Mutex > aGuard( m_aMutex );
+ if( _iterateinterval != mfIterateInterval )
+ {
+ mfIterateInterval = _iterateinterval;
+ fireChangeListener();
+ }
+}
+
+
+// XChangesNotifier
+void SAL_CALL AnimationNode::addChangesListener( const Reference< XChangesListener >& aListener )
+{
+ maChangeListener.addInterface( aListener );
+}
+
+
+// XChangesNotifier
+void SAL_CALL AnimationNode::removeChangesListener( const Reference< XChangesListener >& aListener )
+{
+ maChangeListener.removeInterface(aListener);
+}
+
+
+// XUnoTunnel
+::sal_Int64 SAL_CALL AnimationNode::getSomething( const Sequence< ::sal_Int8 >& rId )
+{
+ return comphelper::getSomethingImpl(rId, this);
+}
+
+const css::uno::Sequence< sal_Int8 > & AnimationNode::getUnoTunnelId()
+{
+ static const comphelper::UnoIdInit theAnimationNodeUnoTunnelId;
+ return theAnimationNodeUnoTunnelId.getSeq();
+}
+
+
+void AnimationNode::fireChangeListener()
+{
+ Guard< Mutex > aGuard( m_aMutex );
+
+ OInterfaceIteratorHelper3 aIterator( maChangeListener );
+ if( aIterator.hasMoreElements() )
+ {
+ Reference< XInterface > xSource( static_cast<OWeakObject*>(this), UNO_QUERY );
+ Sequence< ElementChange > aChanges;
+ const ChangesEvent aEvent( xSource, Any( mxParent.get() ), aChanges );
+ while( aIterator.hasMoreElements() )
+ aIterator.next()->changesOccurred( aEvent );
+ }
+
+ //fdo#69645 use WeakReference of mxParent to test if mpParent is still valid
+ if (mpParent)
+ {
+ Reference<XInterface> xGuard(mxParent);
+ if (xGuard.is())
+ mpParent->fireChangeListener();
+ }
+}
+
+
+} // namespace animcore
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_ParallelTimeContainer_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(PAR));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_SequenceTimeContainer_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(SEQ));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_IterateContainer_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ITERATE));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_Animate_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ANIMATE));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_AnimateSet_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(SET));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_AnimateColor_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ANIMATECOLOR));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_AnimateMotion_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ANIMATEMOTION));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_AnimatePhysics_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ANIMATEPHYSICS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_AnimateTransform_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(ANIMATETRANSFORM));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_TransitionFilter_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(TRANSITIONFILTER));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_Audio_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(AUDIO));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_animations_Command_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new animcore::AnimationNode(COMMAND));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */