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