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