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 	// attributes 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 	// attributes 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