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