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