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 :
21 : #include <com/sun/star/animations/XAnimateColor.hpp>
22 : #include <com/sun/star/animations/XAnimateSet.hpp>
23 : #include <com/sun/star/animations/XCommand.hpp>
24 : #include <com/sun/star/animations/Timing.hpp>
25 : #include <com/sun/star/animations/Event.hpp>
26 : #include <com/sun/star/animations/XAnimateMotion.hpp>
27 : #include <com/sun/star/animations/XAnimateTransform.hpp>
28 : #include <com/sun/star/animations/XTransitionFilter.hpp>
29 : #include <com/sun/star/animations/XIterateContainer.hpp>
30 : #include <com/sun/star/animations/XAudio.hpp>
31 : #include <com/sun/star/animations/AnimationColorSpace.hpp>
32 : #include <com/sun/star/animations/AnimationNodeType.hpp>
33 : #include <com/sun/star/animations/AnimationRestart.hpp>
34 : #include <com/sun/star/animations/EventTrigger.hpp>
35 : #include <com/sun/star/animations/AnimationFill.hpp>
36 : #include <com/sun/star/animations/AnimationEndSync.hpp>
37 : #include <com/sun/star/animations/AnimationCalcMode.hpp>
38 : #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
39 : #include <com/sun/star/animations/AnimationTransformType.hpp>
40 : #include <com/sun/star/animations/TransitionType.hpp>
41 : #include <com/sun/star/animations/TransitionSubType.hpp>
42 : #include <com/sun/star/animations/ValuePair.hpp>
43 : #include <com/sun/star/container/XEnumerationAccess.hpp>
44 : #include <com/sun/star/beans/NamedValue.hpp>
45 : #include <com/sun/star/presentation/EffectNodeType.hpp>
46 : #include <com/sun/star/presentation/EffectPresetClass.hpp>
47 : #include <com/sun/star/presentation/ParagraphTarget.hpp>
48 : #include <com/sun/star/presentation/TextAnimationType.hpp>
49 : #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
50 : #include <com/sun/star/presentation/EffectCommands.hpp>
51 : #include <com/sun/star/drawing/XShape.hpp>
52 :
53 : #include <sax/tools/converter.hxx>
54 :
55 : #include <tools/debug.hxx>
56 : #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
57 : #include "sdxmlexp_impl.hxx"
58 : #include "sdpropls.hxx"
59 : #include <xmloff/xmltoken.hxx>
60 : #include <xmloff/xmlnmspe.hxx>
61 : #include <xmloff/xmluconv.hxx>
62 : #include <xmloff/xmlexp.hxx>
63 : #include <xmloff/xmlement.hxx>
64 : #include <xmloff/nmspmap.hxx>
65 : #include <xmloff/shapeexport.hxx>
66 : #include <xmloff/xmlprhdl.hxx>
67 :
68 : #include "animations.hxx"
69 : #include <xmloff/animationexport.hxx>
70 :
71 :
72 : using namespace ::std;
73 : using namespace ::cppu;
74 : using namespace ::com::sun::star::animations;
75 : using namespace ::com::sun::star::presentation;
76 : using namespace ::com::sun::star::drawing;
77 : using namespace ::com::sun::star::beans;
78 : using namespace ::xmloff::token;
79 :
80 : using ::com::sun::star::uno::Any;
81 : using ::com::sun::star::uno::UNO_QUERY;
82 : using ::com::sun::star::uno::UNO_QUERY_THROW;
83 : using ::com::sun::star::uno::Reference;
84 : using ::com::sun::star::uno::Sequence;
85 : using ::com::sun::star::uno::Exception;
86 : using ::com::sun::star::uno::RuntimeException;
87 : using ::com::sun::star::uno::XInterface;
88 : using ::com::sun::star::beans::NamedValue;
89 : using ::com::sun::star::container::XEnumerationAccess;
90 : using ::com::sun::star::container::XEnumeration;
91 :
92 : namespace xmloff
93 : {
94 :
95 4476 : const SvXMLEnumMapEntry* getAnimationsEnumMap( sal_uInt16 nMap )
96 : {
97 4476 : switch( nMap )
98 : {
99 : case Animations_EnumMap_Fill:
100 : {
101 : static const SvXMLEnumMapEntry aAnimations_EnumMap_Fill[] =
102 : {
103 : { XML_DEFAULT, AnimationFill::DEFAULT },
104 : { XML_REMOVE, AnimationFill::REMOVE },
105 : { XML_FREEZE, AnimationFill::FREEZE },
106 : { XML_HOLD, AnimationFill::HOLD },
107 : { XML_TRANSITION, AnimationFill::TRANSITION },
108 : { XML_AUTO, AnimationFill::AUTO },
109 : { XML_TOKEN_INVALID, 0 }
110 : };
111 8 : return aAnimations_EnumMap_Fill;
112 : }
113 : case Animations_EnumMap_FillDefault:
114 : {
115 : static const SvXMLEnumMapEntry aAnimations_EnumMap_Fill[] =
116 : {
117 : { XML_INHERIT, AnimationFill::INHERIT },
118 : { XML_REMOVE, AnimationFill::REMOVE },
119 : { XML_FREEZE, AnimationFill::FREEZE },
120 : { XML_HOLD, AnimationFill::HOLD },
121 : { XML_TRANSITION, AnimationFill::TRANSITION },
122 : { XML_AUTO, AnimationFill::AUTO },
123 : { XML_TOKEN_INVALID, 0 }
124 : };
125 0 : return aAnimations_EnumMap_Fill;
126 : }
127 : case Animations_EnumMap_Restart:
128 : {
129 : static const SvXMLEnumMapEntry aAnimations_EnumMap_Restart[] =
130 : {
131 : { XML_DEFAULT, AnimationRestart::DEFAULT },
132 : { XML_ALWAYS, AnimationRestart::ALWAYS },
133 : { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
134 : { XML_NEVER, AnimationRestart::NEVER },
135 : { XML_TOKEN_INVALID, 0 }
136 : };
137 0 : return aAnimations_EnumMap_Restart;
138 : }
139 : case Animations_EnumMap_RestartDefault:
140 : {
141 : static const SvXMLEnumMapEntry aAnimations_EnumMap_RestartDefault[] =
142 : {
143 : { XML_INHERIT, AnimationRestart::INHERIT },
144 : { XML_ALWAYS, AnimationRestart::ALWAYS },
145 : { XML_WHENNOTACTIVE,AnimationRestart::WHEN_NOT_ACTIVE },
146 : { XML_NEVER, AnimationRestart::NEVER },
147 : { XML_TOKEN_INVALID, 0 }
148 : };
149 0 : return aAnimations_EnumMap_RestartDefault;
150 : }
151 : case Animations_EnumMap_Endsync:
152 : {
153 : static const SvXMLEnumMapEntry aAnimations_EnumMap_Endsync[] =
154 : {
155 : { XML_FIRST, AnimationEndSync::FIRST },
156 : { XML_LAST, AnimationEndSync::LAST },
157 : { XML_ALL, AnimationEndSync::ALL },
158 : { XML_MEDIA, AnimationEndSync::MEDIA },
159 : { XML_TOKEN_INVALID, 0 }
160 : };
161 0 : return aAnimations_EnumMap_Endsync;
162 : }
163 : case Animations_EnumMap_CalcMode:
164 : {
165 : static const SvXMLEnumMapEntry aAnimations_EnumMap_CalcMode[] =
166 : {
167 : { XML_DISCRETE, AnimationCalcMode::DISCRETE },
168 : { XML_LINEAR, AnimationCalcMode::LINEAR },
169 : { XML_PACED, AnimationCalcMode::PACED },
170 : { XML_SPLINE, AnimationCalcMode::SPLINE },
171 : { XML_TOKEN_INVALID, 0 }
172 : };
173 0 : return aAnimations_EnumMap_CalcMode;
174 : }
175 : case Animations_EnumMap_AdditiveMode:
176 : {
177 : static const SvXMLEnumMapEntry aAnimations_EnumMap_AdditiveMode[] =
178 : {
179 : { XML_BASE, AnimationAdditiveMode::BASE },
180 : { XML_SUM, AnimationAdditiveMode::SUM },
181 : { XML_REPLACE, AnimationAdditiveMode::REPLACE },
182 : { XML_MULTIPLY, AnimationAdditiveMode::MULTIPLY },
183 : { XML_NONE, AnimationAdditiveMode::NONE },
184 : { XML_TOKEN_INVALID, 0 }
185 : };
186 0 : return aAnimations_EnumMap_AdditiveMode;
187 : }
188 : case Animations_EnumMap_TransformType:
189 : {
190 : static const SvXMLEnumMapEntry aAnimations_EnumMap_TransformType[] =
191 : {
192 : { XML_TRANSLATE, AnimationTransformType::TRANSLATE },
193 : { XML_SCALE, AnimationTransformType::SCALE },
194 : { XML_ROTATE, AnimationTransformType::ROTATE },
195 : { XML_SKEWX, AnimationTransformType::SKEWX },
196 : { XML_SKEWY, AnimationTransformType::SKEWY },
197 : { XML_TOKEN_INVALID, 0 }
198 : };
199 0 : return aAnimations_EnumMap_TransformType;
200 : }
201 : case Animations_EnumMap_TransitionType:
202 : {
203 : static const SvXMLEnumMapEntry aAnimations_EnumMap_TransitionType[] =
204 : {
205 : { XML_BARWIPE, TransitionType::BARWIPE },
206 : { XML_BOXWIPE, TransitionType::BOXWIPE },
207 : { XML_FOURBOXWIPE, TransitionType::FOURBOXWIPE },
208 : { XML_BARNDOORWIPE, TransitionType::BARNDOORWIPE },
209 : { XML_DIAGONALWIPE, TransitionType::DIAGONALWIPE },
210 : { XML_BOWTIEWIPE, TransitionType::BOWTIEWIPE },
211 : { XML_MISCDIAGONALWIPE, TransitionType::MISCDIAGONALWIPE },
212 : { XML_VEEWIPE, TransitionType::VEEWIPE },
213 : { XML_BARNVEEWIPE, TransitionType::BARNVEEWIPE },
214 : { XML_ZIGZAGWIPE, TransitionType::ZIGZAGWIPE },
215 : { XML_BARNZIGZAGWIPE, TransitionType::BARNZIGZAGWIPE },
216 : { XML_IRISWIPE, TransitionType::IRISWIPE },
217 : { XML_TRIANGLEWIPE, TransitionType::TRIANGLEWIPE },
218 : { XML_ARROWHEADWIPE, TransitionType::ARROWHEADWIPE },
219 : { XML_PENTAGONWIPE, TransitionType::PENTAGONWIPE },
220 : { XML_HEXAGONWIPE, TransitionType::HEXAGONWIPE },
221 : { XML_ELLIPSEWIPE, TransitionType::ELLIPSEWIPE },
222 : { XML_EYEWIPE, TransitionType::EYEWIPE },
223 : { XML_ROUNDRECTWIPE, TransitionType::ROUNDRECTWIPE },
224 : { XML_STARWIPE, TransitionType::STARWIPE },
225 : { XML_MISCSHAPEWIPE, TransitionType::MISCSHAPEWIPE },
226 : { XML_CLOCKWIPE, TransitionType::CLOCKWIPE },
227 : { XML_PINWHEELWIPE, TransitionType::PINWHEELWIPE },
228 : { XML_SINGLESWEEPWIPE, TransitionType::SINGLESWEEPWIPE },
229 : { XML_FANWIPE, TransitionType::FANWIPE },
230 : { XML_DOUBLEFANWIPE, TransitionType::DOUBLEFANWIPE },
231 : { XML_DOUBLESWEEPWIPE, TransitionType::DOUBLESWEEPWIPE },
232 : { XML_SALOONDOORWIPE, TransitionType::SALOONDOORWIPE },
233 : { XML_WINDSHIELDWIPE, TransitionType::WINDSHIELDWIPE },
234 : { XML_SNAKEWIPE, TransitionType::SNAKEWIPE },
235 : { XML_SPIRALWIPE, TransitionType::SPIRALWIPE },
236 : { XML_PARALLELSNAKESWIPE,TransitionType::PARALLELSNAKESWIPE },
237 : { XML_BOXSNAKESWIPE, TransitionType::BOXSNAKESWIPE },
238 : { XML_WATERFALLWIPE, TransitionType::WATERFALLWIPE },
239 : { XML_PUSHWIPE, TransitionType::PUSHWIPE },
240 : { XML_SLIDEWIPE, TransitionType::SLIDEWIPE },
241 : { XML_FADE, TransitionType::FADE },
242 : { XML_RANDOMBARWIPE, TransitionType::RANDOMBARWIPE },
243 : { XML_CHECKERBOARDWIPE, TransitionType::CHECKERBOARDWIPE },
244 : { XML_DISSOLVE, TransitionType::DISSOLVE },
245 : { XML_BLINDSWIPE, TransitionType::BLINDSWIPE },
246 : { XML_RANDOM, TransitionType::RANDOM },
247 : { XML_ZOOM, TransitionType::ZOOM },
248 : { XML_TOKEN_INVALID, 0 }
249 : };
250 2232 : return aAnimations_EnumMap_TransitionType;
251 : }
252 : case Animations_EnumMap_TransitionSubType:
253 : {
254 : static const SvXMLEnumMapEntry aAnimations_EnumMap_TransitionSubType[] =
255 : {
256 : { XML_DEFAULT, TransitionSubType::DEFAULT },
257 : { XML_LEFTTORIGHT, TransitionSubType::LEFTTORIGHT },
258 : { XML_TOPTOBOTTOM, TransitionSubType::TOPTOBOTTOM },
259 : { XML_TOPLEFT, TransitionSubType::TOPLEFT },
260 : { XML_TOPRIGHT, TransitionSubType::TOPRIGHT },
261 : { XML_BOTTOMRIGHT, TransitionSubType::BOTTOMRIGHT },
262 : { XML_BOTTOMLEFT, TransitionSubType::BOTTOMLEFT },
263 : { XML_TOPCENTER, TransitionSubType::TOPCENTER },
264 : { XML_RIGHTCENTER, TransitionSubType::RIGHTCENTER },
265 : { XML_BOTTOMCENTER, TransitionSubType::BOTTOMCENTER },
266 : { XML_LEFTCENTER, TransitionSubType::LEFTCENTER },
267 : { XML_CORNERSIN, TransitionSubType::CORNERSIN },
268 : { XML_CORNERSOUT, TransitionSubType::CORNERSOUT },
269 : { XML_VERTICAL, TransitionSubType::VERTICAL },
270 : { XML_HORIZONTAL, TransitionSubType::HORIZONTAL },
271 : { XML_DIAGONALBOTTOMLEFT, TransitionSubType::DIAGONALBOTTOMLEFT },
272 : { XML_DIAGONALTOPLEFT, TransitionSubType::DIAGONALTOPLEFT },
273 : { XML_DOUBLEBARNDOOR, TransitionSubType::DOUBLEBARNDOOR },
274 : { XML_DOUBLEDIAMOND, TransitionSubType::DOUBLEDIAMOND },
275 : { XML_DOWN, TransitionSubType::DOWN },
276 : { XML_LEFT, TransitionSubType::LEFT },
277 : { XML_UP, TransitionSubType::UP },
278 : { XML_RIGHT, TransitionSubType::RIGHT },
279 : { XML_RECTANGLE, TransitionSubType::RECTANGLE },
280 : { XML_DIAMOND, TransitionSubType::DIAMOND },
281 : { XML_CIRCLE, TransitionSubType::CIRCLE },
282 : { XML_FOURPOINT, TransitionSubType::FOURPOINT },
283 : { XML_FIVEPOINT, TransitionSubType::FIVEPOINT },
284 : { XML_SIXPOINT, TransitionSubType::SIXPOINT },
285 : { XML_HEART, TransitionSubType::HEART },
286 : { XML_KEYHOLE, TransitionSubType::KEYHOLE },
287 : { XML_CLOCKWISETWELVE, TransitionSubType::CLOCKWISETWELVE },
288 : { XML_CLOCKWISETHREE, TransitionSubType::CLOCKWISETHREE },
289 : { XML_CLOCKWISESIX, TransitionSubType::CLOCKWISESIX },
290 : { XML_CLOCKWISENINE, TransitionSubType::CLOCKWISENINE },
291 : { XML_TWOBLADEVERTICAL, TransitionSubType::TWOBLADEVERTICAL },
292 : { XML_TWOBLADEHORIZONTAL, TransitionSubType::TWOBLADEHORIZONTAL },
293 : { XML_FOURBLADE, TransitionSubType::FOURBLADE },
294 : { XML_CLOCKWISETOP, TransitionSubType::CLOCKWISETOP },
295 : { XML_CLOCKWISERIGHT, TransitionSubType::CLOCKWISERIGHT },
296 : { XML_CLOCKWISEBOTTOM, TransitionSubType::CLOCKWISEBOTTOM },
297 : { XML_CLOCKWISELEFT, TransitionSubType::CLOCKWISELEFT },
298 : { XML_CLOCKWISETOPLEFT, TransitionSubType::CLOCKWISETOPLEFT },
299 : { XML_COUNTERCLOCKWISEBOTTOMLEFT,TransitionSubType::COUNTERCLOCKWISEBOTTOMLEFT },
300 : { XML_CLOCKWISEBOTTOMRIGHT, TransitionSubType::CLOCKWISEBOTTOMRIGHT },
301 : { XML_COUNTERCLOCKWISETOPRIGHT,TransitionSubType::COUNTERCLOCKWISETOPRIGHT },
302 : { XML_CENTERTOP, TransitionSubType::CENTERTOP },
303 : { XML_CENTERRIGHT, TransitionSubType::CENTERRIGHT },
304 : { XML_TOP, TransitionSubType::TOP },
305 : { XML_BOTTOM, TransitionSubType::BOTTOM },
306 : { XML_FANOUTVERTICAL, TransitionSubType::FANOUTVERTICAL },
307 : { XML_FANOUTHORIZONTAL, TransitionSubType::FANOUTHORIZONTAL },
308 : { XML_FANINVERTICAL, TransitionSubType::FANINVERTICAL },
309 : { XML_FANINHORIZONTAL, TransitionSubType::FANINHORIZONTAL },
310 : { XML_PARALLELVERTICAL, TransitionSubType::PARALLELVERTICAL },
311 : { XML_PARALLELDIAGONAL, TransitionSubType::PARALLELDIAGONAL },
312 : { XML_OPPOSITEVERTICAL, TransitionSubType::OPPOSITEVERTICAL },
313 : { XML_OPPOSITEHORIZONTAL, TransitionSubType::OPPOSITEHORIZONTAL },
314 : { XML_PARALLELDIAGONALTOPLEFT,TransitionSubType::PARALLELDIAGONALTOPLEFT },
315 : { XML_PARALLELDIAGONALBOTTOMLEFT,TransitionSubType::PARALLELDIAGONALBOTTOMLEFT },
316 : { XML_TOPLEFTHORIZONTAL, TransitionSubType::TOPLEFTHORIZONTAL },
317 : { XML_TOPLEFTDIAGONAL, TransitionSubType::TOPLEFTDIAGONAL },
318 : { XML_TOPRIGHTDIAGONAL, TransitionSubType::TOPRIGHTDIAGONAL },
319 : { XML_BOTTOMRIGHTDIAGONAL, TransitionSubType::BOTTOMRIGHTDIAGONAL },
320 : { XML_BOTTOMLEFTDIAGONAL, TransitionSubType::BOTTOMLEFTDIAGONAL },
321 : { XML_TOPLEFTCLOCKWISE, TransitionSubType::TOPLEFTCLOCKWISE },
322 : { XML_TOPRIGHTCLOCKWISE, TransitionSubType::TOPRIGHTCLOCKWISE },
323 : { XML_BOTTOMRIGHTCLOCKWISE, TransitionSubType::BOTTOMRIGHTCLOCKWISE },
324 : { XML_BOTTOMLEFTCLOCKWISE, TransitionSubType::BOTTOMLEFTCLOCKWISE },
325 : { XML_TOPLEFTCOUNTERCLOCKWISE,TransitionSubType::TOPLEFTCOUNTERCLOCKWISE },
326 : { XML_TOPRIGHTCOUNTERCLOCKWISE,TransitionSubType::TOPRIGHTCOUNTERCLOCKWISE },
327 : { XML_BOTTOMRIGHTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMRIGHTCOUNTERCLOCKWISE },
328 : { XML_BOTTOMLEFTCOUNTERCLOCKWISE,TransitionSubType::BOTTOMLEFTCOUNTERCLOCKWISE },
329 : { XML_VERTICALTOPSAME, TransitionSubType::VERTICALTOPSAME },
330 : { XML_VERTICALBOTTOMSAME, TransitionSubType::VERTICALBOTTOMSAME },
331 : { XML_VERTICALTOPLEFTOPPOSITE,TransitionSubType::VERTICALTOPLEFTOPPOSITE },
332 : { XML_VERTICALBOTTOMLEFTOPPOSITE,TransitionSubType::VERTICALBOTTOMLEFTOPPOSITE },
333 : { XML_HORIZONTALLEFTSAME, TransitionSubType::HORIZONTALLEFTSAME },
334 : { XML_HORIZONTALRIGHTSAME, TransitionSubType::HORIZONTALRIGHTSAME },
335 : { XML_HORIZONTALTOPLEFTOPPOSITE,TransitionSubType::HORIZONTALTOPLEFTOPPOSITE },
336 : { XML_HORIZONTALTOPRIGHTOPPOSITE,TransitionSubType::HORIZONTALTOPRIGHTOPPOSITE },
337 : { XML_DIAGONALBOTTOMLEFTOPPOSITE,TransitionSubType::DIAGONALBOTTOMLEFTOPPOSITE },
338 : { XML_DIAGONALTOPLEFTOPPOSITE,TransitionSubType::DIAGONALTOPLEFTOPPOSITE },
339 : { XML_TWOBOXTOP, TransitionSubType::TWOBOXTOP },
340 : { XML_TWOBOXBOTTOM, TransitionSubType::TWOBOXBOTTOM },
341 : { XML_TWOBOXLEFT, TransitionSubType::TWOBOXLEFT },
342 : { XML_TWOBOXRIGHT, TransitionSubType::TWOBOXRIGHT },
343 : { XML_FOURBOXVERTICAL, TransitionSubType::FOURBOXVERTICAL },
344 : { XML_FOURBOXHORIZONTAL, TransitionSubType::FOURBOXHORIZONTAL },
345 : { XML_VERTICALLEFT, TransitionSubType::VERTICALLEFT },
346 : { XML_VERTICALRIGHT, TransitionSubType::VERTICALRIGHT },
347 : { XML_HORIZONTALLEFT, TransitionSubType::HORIZONTALLEFT },
348 : { XML_HORIZONTALRIGHT, TransitionSubType::HORIZONTALRIGHT },
349 : { XML_FROMLEFT, TransitionSubType::FROMLEFT },
350 : { XML_FROMTOP, TransitionSubType::FROMTOP },
351 : { XML_FROMRIGHT, TransitionSubType::FROMRIGHT },
352 : { XML_FROMBOTTOM, TransitionSubType::FROMBOTTOM },
353 : { XML_CROSSFADE, TransitionSubType::CROSSFADE },
354 : { XML_FADETOCOLOR, TransitionSubType::FADETOCOLOR },
355 : { XML_FADEFROMCOLOR, TransitionSubType::FADEFROMCOLOR },
356 : { XML_FADEOVERCOLOR, TransitionSubType::FADEOVERCOLOR },
357 : { XML_THREEBLADE, TransitionSubType::THREEBLADE },
358 : { XML_EIGHTBLADE, TransitionSubType::EIGHTBLADE },
359 : { XML_ONEBLADE, TransitionSubType::ONEBLADE },
360 : { XML_ACROSS, TransitionSubType::ACROSS },
361 : { XML_TOPLEFTVERTICAL, TransitionSubType::TOPLEFTVERTICAL },
362 : { XML_COMBHORIZONTAL, TransitionSubType::COMBHORIZONTAL },
363 : { XML_COMBVERTICAL, TransitionSubType::COMBVERTICAL },
364 : { XML_IN, TransitionSubType::IN },
365 : { XML_OUT, TransitionSubType::OUT },
366 : { XML_ROTATEIN, TransitionSubType::ROTATEIN },
367 : { XML_ROTATEOUT, TransitionSubType::ROTATEOUT },
368 : { XML_FROMTOPLEFT, TransitionSubType::FROMTOPLEFT },
369 : { XML_FROMTOPRIGHT, TransitionSubType::FROMTOPRIGHT },
370 : { XML_FROMBOTTOMLEFT, TransitionSubType::FROMBOTTOMLEFT },
371 : { XML_FROMBOTTOMRIGHT, TransitionSubType::FROMBOTTOMRIGHT },
372 :
373 : { XML_TOKEN_INVALID, 0 }
374 : };
375 2228 : return aAnimations_EnumMap_TransitionSubType;
376 : }
377 : case Animations_EnumMap_EventTrigger:
378 : {
379 : static const SvXMLEnumMapEntry aAnimations_EnumMap_EventTrigger[] =
380 : {
381 : { XML_ONBEGIN, EventTrigger::ON_BEGIN },
382 : { XML_ONEND, EventTrigger::ON_END },
383 : { XML_BEGIN, EventTrigger::BEGIN_EVENT },
384 : { XML_END, EventTrigger::END_EVENT },
385 : { XML_CLICK, EventTrigger::ON_CLICK },
386 : { XML_DOUBLECLICK, EventTrigger::ON_DBL_CLICK },
387 : { XML_MOUSEOVER, EventTrigger::ON_MOUSE_ENTER },
388 : { XML_MOUSEOUT, EventTrigger::ON_MOUSE_LEAVE },
389 : { XML_NEXT, EventTrigger::ON_NEXT },
390 : { XML_PREVIOUS, EventTrigger::ON_PREV },
391 : { XML_STOP_AUDIO, EventTrigger::ON_STOP_AUDIO },
392 : { XML_REPEAT, EventTrigger::REPEAT },
393 : { XML_TOKEN_INVALID, 0 }
394 : };
395 2 : return aAnimations_EnumMap_EventTrigger;
396 : }
397 :
398 : case Animations_EnumMap_EffectPresetClass:
399 : {
400 : static const SvXMLEnumMapEntry aAnimations_EnumMap_EffectPresetClass[] =
401 : {
402 : { XML_CUSTOM, EffectPresetClass::CUSTOM },
403 : { XML_ENTRANCE, EffectPresetClass::ENTRANCE },
404 : { XML_EXIT, EffectPresetClass::EXIT },
405 : { XML_EMPHASIS, EffectPresetClass::EMPHASIS },
406 : { XML_MOTION_PATH, EffectPresetClass::MOTIONPATH },
407 : { XML_OLE_ACTION, EffectPresetClass::OLEACTION },
408 : { XML_MEDIA_CALL, EffectPresetClass::MEDIACALL },
409 : { XML_TOKEN_INVALID, 0 }
410 : };
411 2 : return aAnimations_EnumMap_EffectPresetClass;
412 : }
413 :
414 : case Animations_EnumMap_EffectNodeType:
415 : {
416 : static const SvXMLEnumMapEntry aAnimations_EnumMap_EffectNodeType[] =
417 : {
418 : { XML_DEFAULT, EffectNodeType::DEFAULT },
419 : { XML_ON_CLICK, EffectNodeType::ON_CLICK },
420 : { XML_WITH_PREVIOUS, EffectNodeType::WITH_PREVIOUS },
421 : { XML_AFTER_PREVIOUS, EffectNodeType::AFTER_PREVIOUS },
422 : { XML_MAIN_SEQUENCE, EffectNodeType::MAIN_SEQUENCE },
423 : { XML_TIMING_ROOT, EffectNodeType::TIMING_ROOT },
424 : { XML_INTERACTIVE_SEQUENCE, EffectNodeType::INTERACTIVE_SEQUENCE },
425 : { XML_TOKEN_INVALID, 0 }
426 : };
427 4 : return aAnimations_EnumMap_EffectNodeType;
428 : }
429 : case Animations_EnumMap_SubItem:
430 : {
431 : static const SvXMLEnumMapEntry aAnimations_EnumMap_SubItem[] =
432 : {
433 : { XML_WHOLE, ShapeAnimationSubType::AS_WHOLE },
434 : { XML_BACKGROUND, ShapeAnimationSubType::ONLY_BACKGROUND },
435 : { XML_TEXT, ShapeAnimationSubType::ONLY_TEXT },
436 : { XML_TOKEN_INVALID, 0 }
437 : };
438 0 : return aAnimations_EnumMap_SubItem;
439 : }
440 : case Animations_EnumMap_IterateType:
441 : {
442 : static const SvXMLEnumMapEntry aAnimations_EnumMap_IterateType[] =
443 : {
444 : { XML_BY_PARAGRAPH, TextAnimationType::BY_PARAGRAPH },
445 : { XML_BY_WORD, TextAnimationType::BY_WORD },
446 : { XML_BY_LETTER, TextAnimationType::BY_LETTER },
447 : { XML_TOKEN_INVALID, 0 }
448 : };
449 0 : return aAnimations_EnumMap_IterateType;
450 : }
451 : case Animations_EnumMap_Command:
452 : {
453 : static const SvXMLEnumMapEntry aAnimations_EnumMap_Command[] =
454 : {
455 : { XML_CUSTOM, EffectCommands::CUSTOM },
456 : { XML_VERB, EffectCommands::VERB },
457 : { XML_PLAY, EffectCommands::PLAY },
458 : { XML_TOGGLE_PAUSE, EffectCommands::TOGGLEPAUSE },
459 : { XML_STOP, EffectCommands::STOP },
460 : { XML_STOP_AUDIO, EffectCommands::STOPAUDIO },
461 : { XML_TOKEN_INVALID, 0 }
462 : };
463 0 : return aAnimations_EnumMap_Command;
464 : }
465 : }
466 :
467 : OSL_FAIL( "xmloff::getAnimationsEnumMap(), invalid map!" );
468 0 : return NULL;
469 : }
470 :
471 6 : const struct ImplAttributeNameConversion* getAnimationAttributeNamesConversionList()
472 : {
473 : static const struct ImplAttributeNameConversion gImplConversionList[] =
474 : {
475 : { XML_X, "X" },
476 : { XML_Y, "Y" },
477 : { XML_WIDTH, "Width" },
478 : { XML_HEIGHT, "Height" },
479 : { XML_ROTATE, "Rotate" },
480 : { XML_SKEWX, "SkewX" },
481 : { XML_FILL_COLOR, "FillColor" },
482 : { XML_FILL, "FillStyle" },
483 : { XML_STROKE_COLOR, "LineColor" },
484 : { XML_STROKE, "LineStyle" },
485 : { XML_COLOR, "CharColor" },
486 : { XML_TEXT_ROTATION_ANGLE, "CharRotation" },
487 : { XML_FONT_WEIGHT, "CharWeight" },
488 : { XML_TEXT_UNDERLINE, "CharUnderline" },
489 : { XML_FONT_FAMILY, "CharFontName" },
490 : { XML_FONT_SIZE, "CharHeight" },
491 : { XML_FONT_STYLE, "CharPosture" },
492 : { XML_VISIBILITY, "Visibility" },
493 : { XML_OPACITY, "Opacity" },
494 : { XML_DIM, "DimColor" },
495 : { XML_TOKEN_INVALID, NULL }
496 : };
497 :
498 6 : return gImplConversionList;
499 : }
500 :
501 :
502 : class AnimationsExporterImpl
503 : {
504 : public:
505 : AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps );
506 : virtual ~AnimationsExporterImpl();
507 :
508 : void prepareNode( const Reference< XAnimationNode >& xNode );
509 : void exportNode( const Reference< XAnimationNode >& xNode );
510 :
511 : void exportContainer( const Reference< XTimeContainer >& xNode, sal_Int16 nContainerNodeType );
512 : void exportAnimate( const Reference< XAnimate >& xNode );
513 : void exportAudio( const Reference< XAudio >& xAudio );
514 : void exportCommand( const Reference< XCommand >& xCommand );
515 :
516 : Reference< XInterface > getParagraphTarget( const ParagraphTarget* pTarget ) const;
517 :
518 : void convertPath( OUStringBuffer& sTmp, const Any& rPath ) const;
519 : void convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const;
520 : void convertTiming( OUStringBuffer& sTmp, const Any& rTiming ) const;
521 : void convertSource( OUStringBuffer& sTmp, const Any& rSource ) const;
522 : void convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const;
523 :
524 : void prepareValue( const Any& rValue );
525 :
526 : void exportTransitionNode();
527 : void prepareTransitionNode();
528 :
529 : bool mbHasTransition;
530 : private:
531 : SvXMLExport& mrExport;
532 : Reference< XInterface > mxExport;
533 : Reference< XPropertySet > mxPageProps;
534 : XMLSdPropHdlFactory* mpSdPropHdlFactory;
535 : };
536 :
537 6 : AnimationsExporterImpl::AnimationsExporterImpl( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
538 : : mbHasTransition(false)
539 : , mrExport( rExport )
540 6 : , mxPageProps( xPageProps )
541 : {
542 : try
543 : {
544 6 : mxExport = static_cast< ::com::sun::star::document::XFilter *>(&rExport);
545 : }
546 0 : catch (const RuntimeException&)
547 : {
548 : OSL_FAIL( "xmloff::AnimationsExporterImpl::AnimationsExporterImpl(), RuntimeException caught!" );
549 : }
550 :
551 6 : mpSdPropHdlFactory = new XMLSdPropHdlFactory( mrExport.GetModel(), mrExport );
552 6 : if( mpSdPropHdlFactory )
553 : {
554 : // set lock to avoid deletion
555 6 : mpSdPropHdlFactory->acquire();
556 : }
557 :
558 6 : }
559 :
560 18 : AnimationsExporterImpl::~AnimationsExporterImpl()
561 : {
562 : // cleanup factory, decrease refcount. Should lead to destruction.
563 6 : if(mpSdPropHdlFactory)
564 : {
565 6 : mpSdPropHdlFactory->release();
566 6 : mpSdPropHdlFactory = 0L;
567 : }
568 12 : }
569 :
570 0 : void AnimationsExporterImpl::exportTransitionNode()
571 : {
572 0 : if( mbHasTransition && mxPageProps.is() )
573 : {
574 0 : sal_Int16 nTransition = 0;
575 0 : mxPageProps->getPropertyValue("TransitionType") >>= nTransition;
576 :
577 0 : Any aSound( mxPageProps->getPropertyValue("Sound") );
578 0 : OUString sSoundURL;
579 0 : aSound >>= sSoundURL;
580 0 : bool bStopSound = false;
581 0 : if( !(aSound >>= bStopSound) )
582 0 : bStopSound = false;
583 :
584 :
585 0 : OUStringBuffer sTmp;
586 0 : if( (nTransition != 0) || !sSoundURL.isEmpty() || bStopSound )
587 : {
588 0 : Reference< XInterface > xSource( mxPageProps.get() );
589 0 : Event aEvent;
590 0 : aEvent.Source <<= xSource;
591 0 : aEvent.Trigger = EventTrigger::BEGIN_EVENT;
592 0 : aEvent.Repeat = 0;
593 :
594 0 : convertTiming( sTmp, Any( aEvent ) );
595 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );
596 :
597 0 : SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_PAR, true, true );
598 :
599 0 : if( nTransition != 0 )
600 : {
601 0 : sal_Int16 nSubtype = 0;
602 0 : bool bDirection = false;
603 0 : sal_Int32 nFadeColor = 0;
604 0 : double fDuration = 0.0;
605 0 : mxPageProps->getPropertyValue("TransitionSubtype") >>= nSubtype;
606 0 : mxPageProps->getPropertyValue("TransitionDirection") >>= bDirection;
607 0 : mxPageProps->getPropertyValue("TransitionFadeColor") >>= nFadeColor;
608 0 : mxPageProps->getPropertyValue("TransitionDuration") >>= fDuration;
609 :
610 0 : ::sax::Converter::convertDouble( sTmp, fDuration );
611 0 : sTmp.append( 's');
612 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );
613 :
614 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTransition, getAnimationsEnumMap(Animations_EnumMap_TransitionType) );
615 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );
616 :
617 0 : if( nSubtype != TransitionSubType::DEFAULT )
618 : {
619 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nSubtype, getAnimationsEnumMap(Animations_EnumMap_TransitionSubType) );
620 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
621 : }
622 :
623 0 : if( !bDirection )
624 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );
625 :
626 0 : if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) ))
627 : {
628 0 : ::sax::Converter::convertColor( sTmp, nFadeColor );
629 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
630 : }
631 0 : SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_TRANSITIONFILTER, true, true );
632 : }
633 :
634 0 : if( bStopSound )
635 : {
636 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, XML_STOP_AUDIO );
637 0 : SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );
638 : }
639 0 : else if( !sSoundURL.isEmpty())
640 : {
641 0 : mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference( sSoundURL ) );
642 :
643 0 : bool bLoopSound = false;
644 0 : mxPageProps->getPropertyValue("LoopSound") >>= bLoopSound;
645 :
646 0 : if( bLoopSound )
647 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
648 0 : SvXMLElementExport aElement2( mrExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );
649 0 : }
650 0 : }
651 : }
652 0 : }
653 :
654 6 : void AnimationsExporterImpl::prepareTransitionNode()
655 : {
656 6 : if( mxPageProps.is() ) try
657 : {
658 6 : sal_Int16 nTransition = 0;
659 6 : mxPageProps->getPropertyValue("TransitionType") >>= nTransition;
660 :
661 6 : bool bStopSound = false;
662 6 : OUString sSoundURL;
663 :
664 6 : if( nTransition == 0 )
665 : {
666 6 : Any aSound( mxPageProps->getPropertyValue("Sound") );
667 6 : aSound >>= sSoundURL;
668 :
669 6 : if( !(aSound >>= bStopSound) )
670 6 : bStopSound = false;
671 : }
672 :
673 6 : if( (nTransition != 0) || !sSoundURL.isEmpty() || bStopSound )
674 : {
675 0 : mbHasTransition = true;
676 0 : Reference< XInterface > xInt( mxPageProps.get() );
677 0 : mrExport.getInterfaceToIdentifierMapper().registerReference( xInt );
678 6 : }
679 : }
680 0 : catch (const Exception&)
681 : {
682 : OSL_FAIL( "xmloff::AnimationsExporterImpl::prepareNode(), Exception caught!" );
683 : }
684 :
685 6 : }
686 :
687 6 : void AnimationsExporterImpl::prepareNode( const Reference< XAnimationNode >& xNode )
688 : {
689 : try
690 : {
691 6 : prepareValue( xNode->getBegin() );
692 6 : prepareValue( xNode->getEnd() );
693 :
694 6 : sal_Int16 nNodeType = xNode->getType();
695 6 : switch( nNodeType )
696 : {
697 : case AnimationNodeType::ITERATE:
698 : {
699 0 : Reference< XIterateContainer > xIter( xNode, UNO_QUERY_THROW );
700 0 : prepareValue( xIter->getTarget() );
701 : }
702 : // its intended that here is no break!
703 : case AnimationNodeType::PAR:
704 : case AnimationNodeType::SEQ:
705 : {
706 6 : Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
707 12 : Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
708 12 : while( xEnumeration->hasMoreElements() )
709 : {
710 0 : Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
711 0 : prepareNode( xChildNode );
712 6 : }
713 : }
714 6 : break;
715 :
716 : case AnimationNodeType::ANIMATE:
717 : case AnimationNodeType::SET:
718 : case AnimationNodeType::ANIMATEMOTION:
719 : case AnimationNodeType::ANIMATECOLOR:
720 : case AnimationNodeType::ANIMATETRANSFORM:
721 : case AnimationNodeType::TRANSITIONFILTER:
722 : {
723 0 : Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
724 0 : prepareValue( xAnimate->getTarget() );
725 : }
726 0 : break;
727 :
728 : case AnimationNodeType::COMMAND:
729 : {
730 0 : Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
731 0 : prepareValue( xCommand->getTarget() );
732 : }
733 0 : break;
734 :
735 : case AnimationNodeType::AUDIO:
736 : {
737 0 : Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
738 0 : prepareValue( xAudio->getSource() );
739 : }
740 0 : break;
741 : }
742 :
743 6 : Sequence< NamedValue > aUserData( xNode->getUserData() );
744 6 : if( aUserData.hasElements() )
745 : {
746 6 : const NamedValue* pValue = aUserData.getConstArray();
747 6 : const sal_Int32 nLength = aUserData.getLength();
748 : sal_Int32 nElement;
749 12 : for( nElement = 0; nElement < nLength; nElement++, pValue++ )
750 : {
751 6 : if( IsXMLToken( pValue->Name, XML_MASTER_ELEMENT ) )
752 : {
753 0 : Reference< XInterface > xMaster;
754 0 : pValue->Value >>= xMaster;
755 0 : if( xMaster.is() )
756 0 : mrExport.getInterfaceToIdentifierMapper().registerReference( xMaster );
757 : }
758 : }
759 6 : }
760 : }
761 0 : catch (const Exception&)
762 : {
763 : OSL_FAIL( "xmloff::AnimationsExporterImpl::prepareNode(), RuntimeException caught!" );
764 : }
765 6 : }
766 :
767 0 : void AnimationsExporterImpl::exportNode( const Reference< XAnimationNode >& xNode )
768 : {
769 : try
770 : {
771 0 : OUStringBuffer sTmp;
772 :
773 0 : const OUString& rExportIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xNode );
774 0 : if( !rExportIdentifier.isEmpty() )
775 : {
776 : mrExport.AddAttributeIdLegacy(
777 0 : XML_NAMESPACE_ANIMATION, rExportIdentifier);
778 : }
779 :
780 0 : Any aTemp( xNode->getBegin() );
781 0 : if( aTemp.hasValue() )
782 : {
783 0 : convertTiming( sTmp, aTemp );
784 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BEGIN, sTmp.makeStringAndClear() );
785 : }
786 :
787 0 : double fTemp = 0;
788 : sal_Int32 nTemp;
789 :
790 0 : aTemp = xNode->getDuration();
791 0 : if( aTemp.hasValue() )
792 : {
793 0 : if( aTemp >>= fTemp )
794 : {
795 0 : ::sax::Converter::convertDouble( sTmp, fTemp );
796 0 : sTmp.append( 's');
797 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, sTmp.makeStringAndClear() );
798 : }
799 : else
800 : {
801 : Timing eTiming;
802 0 : if( aTemp >>= eTiming )
803 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DUR, eTiming == Timing_INDEFINITE ? XML_INDEFINITE : XML_MEDIA );
804 : }
805 : }
806 :
807 0 : aTemp = xNode->getEnd();
808 0 : if( aTemp.hasValue() )
809 : {
810 0 : convertTiming( sTmp, aTemp );
811 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_END, sTmp.makeStringAndClear() );
812 : }
813 :
814 0 : nTemp = xNode->getFill();
815 0 : if( nTemp != AnimationFill::DEFAULT )
816 : {
817 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Fill) );
818 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FILL, sTmp.makeStringAndClear() );
819 : }
820 :
821 0 : nTemp = xNode->getFillDefault();
822 0 : if( nTemp != AnimationFill::INHERIT )
823 : {
824 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_FillDefault) );
825 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FILLDEFAULT, sTmp.makeStringAndClear() );
826 : }
827 :
828 0 : nTemp = xNode->getRestart();
829 0 : if( nTemp != AnimationRestart::DEFAULT )
830 : {
831 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Restart) );
832 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_RESTART, sTmp.makeStringAndClear() );
833 : }
834 :
835 0 : nTemp = xNode->getRestartDefault();
836 0 : if( nTemp != AnimationRestart::INHERIT )
837 : {
838 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_RestartDefault) );
839 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_RESTARTDEFAULT, sTmp.makeStringAndClear() );
840 : }
841 :
842 0 : fTemp = xNode->getAcceleration();
843 0 : if( fTemp != 0.0 )
844 : {
845 0 : ::sax::Converter::convertDouble( sTmp, fTemp );
846 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ACCELERATE, sTmp.makeStringAndClear() );
847 : }
848 :
849 0 : fTemp = xNode->getDecelerate();
850 0 : if( fTemp != 0.0 )
851 : {
852 0 : ::sax::Converter::convertDouble( sTmp, fTemp );
853 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DECELERATE, sTmp.makeStringAndClear() );
854 : }
855 :
856 0 : bool bTemp = xNode->getAutoReverse();
857 0 : if( bTemp )
858 : {
859 0 : ::sax::Converter::convertBool( sTmp, bTemp );
860 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_AUTOREVERSE, sTmp.makeStringAndClear() );
861 : }
862 :
863 0 : aTemp = xNode->getRepeatCount();
864 0 : if( aTemp.hasValue() )
865 : {
866 : Timing eTiming;
867 0 : if( (aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE ) )
868 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, XML_INDEFINITE );
869 0 : else if( aTemp >>= fTemp )
870 : {
871 0 : ::sax::Converter::convertDouble( sTmp, fTemp );
872 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATCOUNT, sTmp.makeStringAndClear() );
873 : }
874 : }
875 :
876 0 : aTemp = xNode->getRepeatDuration();
877 0 : if( aTemp.hasValue() )
878 : {
879 : Timing eTiming;
880 0 : if( ( aTemp >>= eTiming ) && (eTiming == Timing_INDEFINITE) )
881 : {
882 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, XML_INDEFINITE );
883 : }
884 0 : else if( aTemp >>= fTemp )
885 : {
886 0 : ::sax::Converter::convertDouble( sTmp, fTemp );
887 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_REPEATDUR, sTmp.makeStringAndClear() );
888 : }
889 : }
890 :
891 0 : aTemp = xNode->getEndSync();
892 0 : if( aTemp.hasValue() )
893 : {
894 0 : if( aTemp >>= nTemp )
895 : {
896 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_Endsync) );
897 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ENDSYNC, sTmp.makeStringAndClear() );
898 : }
899 : }
900 :
901 0 : sal_Int16 nContainerNodeType = EffectNodeType::DEFAULT;
902 0 : OUString aPresetId;
903 0 : Sequence< NamedValue > aUserData( xNode->getUserData() );
904 0 : if( aUserData.hasElements() )
905 : {
906 0 : const NamedValue* pValue = aUserData.getConstArray();
907 0 : const sal_Int32 nLength = aUserData.getLength();
908 : sal_Int32 nElement;
909 0 : for( nElement = 0; nElement < nLength; nElement++, pValue++ )
910 : {
911 0 : if( IsXMLToken( pValue->Name, XML_NODE_TYPE ) )
912 : {
913 0 : if( (pValue->Value >>= nContainerNodeType) && (nContainerNodeType != EffectNodeType::DEFAULT) )
914 : {
915 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nContainerNodeType, getAnimationsEnumMap(Animations_EnumMap_EffectNodeType) );
916 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_NODE_TYPE, sTmp.makeStringAndClear() );
917 : }
918 : }
919 0 : else if( IsXMLToken( pValue->Name, XML_PRESET_ID ) )
920 : {
921 0 : if( pValue->Value >>= aPresetId )
922 : {
923 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_ID, aPresetId );
924 : }
925 : }
926 0 : else if( IsXMLToken( pValue->Name, XML_PRESET_SUB_TYPE ) )
927 : {
928 0 : OUString aPresetSubType;
929 0 : if( pValue->Value >>= aPresetSubType )
930 : {
931 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_SUB_TYPE, aPresetSubType );
932 0 : }
933 : }
934 0 : else if( IsXMLToken( pValue->Name, XML_PRESET_CLASS ) )
935 : {
936 0 : sal_Int16 nEffectPresetClass = sal_Int16();
937 0 : if( pValue->Value >>= nEffectPresetClass )
938 : {
939 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nEffectPresetClass, getAnimationsEnumMap(Animations_EnumMap_EffectPresetClass) );
940 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PRESET_CLASS, sTmp.makeStringAndClear() );
941 : }
942 : }
943 0 : else if( IsXMLToken( pValue->Name, XML_MASTER_ELEMENT ) )
944 : {
945 0 : Reference< XInterface > xMaster;
946 0 : pValue->Value >>= xMaster;
947 0 : if( xMaster.is() )
948 : {
949 0 : const OUString& rIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier(xMaster);
950 0 : if( !rIdentifier.isEmpty() )
951 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_MASTER_ELEMENT, rIdentifier );
952 0 : }
953 : }
954 0 : else if( IsXMLToken( pValue->Name, XML_GROUP_ID ) )
955 : {
956 0 : sal_Int32 nGroupId = 0;
957 0 : if( pValue->Value >>= nGroupId )
958 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_GROUP_ID, OUString::number( nGroupId ) );
959 : }
960 : else
961 : {
962 0 : OUString aTmp;
963 0 : if( pValue->Value >>= aTmp )
964 0 : mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, pValue->Name, aTmp );
965 : }
966 : }
967 : }
968 :
969 0 : nTemp = xNode->getType();
970 0 : switch( nTemp )
971 : {
972 : case AnimationNodeType::PAR:
973 : case AnimationNodeType::SEQ:
974 : case AnimationNodeType::ITERATE:
975 : {
976 0 : Reference< XTimeContainer > xContainer( xNode, UNO_QUERY_THROW );
977 0 : exportContainer( xContainer, nContainerNodeType );
978 : }
979 0 : break;
980 :
981 : case AnimationNodeType::ANIMATE:
982 : case AnimationNodeType::SET:
983 : case AnimationNodeType::ANIMATEMOTION:
984 : case AnimationNodeType::ANIMATECOLOR:
985 : case AnimationNodeType::ANIMATETRANSFORM:
986 : case AnimationNodeType::TRANSITIONFILTER:
987 : {
988 0 : Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
989 0 : exportAnimate( xAnimate );
990 : }
991 0 : break;
992 : case AnimationNodeType::AUDIO:
993 : {
994 0 : Reference< XAudio > xAudio( xNode, UNO_QUERY_THROW );
995 0 : exportAudio( xAudio );
996 : }
997 0 : break;
998 : case AnimationNodeType::COMMAND:
999 : {
1000 0 : Reference< XCommand > xCommand( xNode, UNO_QUERY_THROW );
1001 0 : exportCommand( xCommand );
1002 : }
1003 0 : break;
1004 : default:
1005 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportNode(), invalid AnimationNodeType!" );
1006 0 : }
1007 : }
1008 0 : catch (const RuntimeException&)
1009 : {
1010 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportNode(), RuntimeException caught!" );
1011 : }
1012 :
1013 : // if something goes wrong, its always a good idea to clear the attribute list
1014 0 : mrExport.ClearAttrList();
1015 0 : }
1016 :
1017 0 : void AnimationsExporterImpl::exportContainer( const Reference< XTimeContainer >& xContainer, sal_Int16 nContainerNodeType )
1018 : {
1019 : try
1020 : {
1021 0 : const sal_Int32 nNodeType = xContainer->getType();
1022 :
1023 0 : if( nNodeType == AnimationNodeType::ITERATE )
1024 : {
1025 0 : OUStringBuffer sTmp;
1026 0 : Reference< XIterateContainer > xIter( xContainer, UNO_QUERY_THROW );
1027 :
1028 0 : Any aTemp( xIter->getTarget() );
1029 0 : if( aTemp.hasValue() )
1030 : {
1031 0 : convertTarget( sTmp, aTemp );
1032 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
1033 : }
1034 :
1035 0 : sal_Int16 nTemp = xIter->getSubItem();
1036 0 : if( nTemp )
1037 : {
1038 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_SubItem) );
1039 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
1040 : }
1041 :
1042 0 : nTemp = xIter->getIterateType();
1043 0 : if( nTemp )
1044 : {
1045 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_IterateType) );
1046 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_TYPE, sTmp.makeStringAndClear() );
1047 : }
1048 :
1049 0 : double fTemp = xIter->getIterateInterval();
1050 0 : if( fTemp )
1051 : {
1052 0 : if( 0 == ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ) )
1053 : {
1054 : // issue 146582
1055 0 : OUStringBuffer buf;
1056 0 : ::sax::Converter::convertDuration(buf, fTemp / (24*60*60));
1057 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION,
1058 0 : XML_ITERATE_INTERVAL, buf.makeStringAndClear());
1059 : }
1060 : else
1061 : {
1062 0 : sTmp.append( fTemp );
1063 0 : sTmp.append( 's' );
1064 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_ITERATE_INTERVAL, sTmp.makeStringAndClear() );
1065 : }
1066 0 : }
1067 : }
1068 :
1069 : XMLTokenEnum eElementToken;
1070 0 : switch( nNodeType )
1071 : {
1072 0 : case AnimationNodeType::PAR: eElementToken = XML_PAR; break;
1073 0 : case AnimationNodeType::SEQ: eElementToken = XML_SEQ; break;
1074 0 : case AnimationNodeType::ITERATE:eElementToken = XML_ITERATE; break;
1075 : default:
1076 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportContainer(), invalid TimeContainerType!" );
1077 0 : return;
1078 : }
1079 0 : SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );
1080 :
1081 0 : if( nContainerNodeType == EffectNodeType::TIMING_ROOT )
1082 0 : exportTransitionNode();
1083 :
1084 0 : Reference< XEnumerationAccess > xEnumerationAccess( xContainer, UNO_QUERY_THROW );
1085 0 : Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1086 0 : while( xEnumeration->hasMoreElements() )
1087 : {
1088 0 : Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
1089 0 : exportNode( xChildNode );
1090 0 : }
1091 : }
1092 0 : catch (const RuntimeException&)
1093 : {
1094 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportContainer(), RuntimeException caught!" );
1095 : }
1096 : }
1097 :
1098 0 : void AnimationsExporterImpl::exportAnimate( const Reference< XAnimate >& xAnimate )
1099 : {
1100 : try
1101 : {
1102 0 : const sal_Int16 nNodeType = xAnimate->getType();
1103 :
1104 0 : OUStringBuffer sTmp;
1105 : sal_Int32 nTemp;
1106 : bool bTemp;
1107 :
1108 0 : Any aTemp( xAnimate->getTarget() );
1109 0 : if( aTemp.hasValue() )
1110 : {
1111 0 : convertTarget( sTmp, aTemp );
1112 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
1113 : }
1114 :
1115 0 : nTemp = xAnimate->getSubItem();
1116 0 : if( nTemp )
1117 : {
1118 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_SubItem) );
1119 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_SUB_ITEM, sTmp.makeStringAndClear() );
1120 : }
1121 :
1122 0 : XMLTokenEnum eAttributeName = XML_TOKEN_INVALID;
1123 :
1124 0 : if( nNodeType == AnimationNodeType::TRANSITIONFILTER )
1125 : {
1126 0 : eAttributeName = XML_TRANSITIONFILTER;
1127 : }
1128 0 : else if( nNodeType == AnimationNodeType::ANIMATETRANSFORM )
1129 : {
1130 0 : eAttributeName = XML_ANIMATETRANSFORM;
1131 : }
1132 0 : else if( nNodeType == AnimationNodeType::ANIMATEMOTION )
1133 : {
1134 0 : eAttributeName = XML_ANIMATEMOTION;
1135 : }
1136 : else
1137 : {
1138 0 : OUString sTemp( xAnimate->getAttributeName() );
1139 0 : if( !sTemp.isEmpty() )
1140 : {
1141 0 : const struct ImplAttributeNameConversion* p = getAnimationAttributeNamesConversionList();
1142 0 : while( p->mpAPIName )
1143 : {
1144 0 : if( sTemp.equalsAscii( p->mpAPIName ) )
1145 : {
1146 0 : sTemp = GetXMLToken( p->meXMLToken );
1147 0 : eAttributeName = p->meXMLToken;
1148 0 : break;
1149 : }
1150 :
1151 0 : p++;
1152 : }
1153 :
1154 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, sTemp );
1155 : }
1156 : else
1157 : {
1158 0 : OUString aStr( "invalid" );
1159 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, aStr );
1160 0 : }
1161 : }
1162 :
1163 0 : Sequence< Any > aValues( xAnimate->getValues() );
1164 0 : if( aValues.getLength() )
1165 : {
1166 0 : aTemp <<= aValues;
1167 0 : convertValue( eAttributeName, sTmp, aTemp );
1168 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_VALUES, sTmp.makeStringAndClear() );
1169 : }
1170 : else
1171 : {
1172 0 : aTemp = xAnimate->getFrom();
1173 0 : if( aTemp.hasValue() )
1174 : {
1175 0 : convertValue( eAttributeName, sTmp, aTemp );
1176 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FROM, sTmp.makeStringAndClear() );
1177 : }
1178 :
1179 0 : aTemp = xAnimate->getBy();
1180 0 : if( aTemp.hasValue() )
1181 : {
1182 0 : convertValue( eAttributeName, sTmp, aTemp );
1183 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_BY, sTmp.makeStringAndClear() );
1184 : }
1185 :
1186 0 : aTemp = xAnimate->getTo();
1187 0 : if( aTemp.hasValue() )
1188 : {
1189 0 : convertValue( eAttributeName, sTmp, aTemp );
1190 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TO, sTmp.makeStringAndClear() );
1191 : }
1192 : }
1193 :
1194 0 : if(nNodeType != AnimationNodeType::SET)
1195 : {
1196 0 : Sequence< double > aKeyTimes( xAnimate->getKeyTimes() );
1197 0 : if( aKeyTimes.getLength() )
1198 : {
1199 0 : sal_Int32 nLength = aKeyTimes.getLength();
1200 0 : const double* p = aKeyTimes.getConstArray();
1201 :
1202 0 : while( nLength-- )
1203 : {
1204 0 : if( !sTmp.isEmpty() )
1205 0 : sTmp.append( ';' );
1206 :
1207 0 : sTmp.append( *p++ );
1208 : }
1209 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_KEYTIMES, sTmp.makeStringAndClear() );
1210 : }
1211 :
1212 0 : OUString sTemp( xAnimate->getFormula() );
1213 0 : if( !sTemp.isEmpty() )
1214 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_FORMULA, sTemp );
1215 :
1216 0 : if( (nNodeType != AnimationNodeType::TRANSITIONFILTER) &&
1217 : (nNodeType != AnimationNodeType::AUDIO ) )
1218 : {
1219 : // calcMode = "discrete | linear | paced | spline"
1220 0 : nTemp = xAnimate->getCalcMode();
1221 0 : if( ((nNodeType == AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::PACED)) ||
1222 0 : ((nNodeType != AnimationNodeType::ANIMATEMOTION ) && (nTemp != AnimationCalcMode::LINEAR)) )
1223 : {
1224 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_CalcMode) );
1225 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_CALCMODE, sTmp.makeStringAndClear() );
1226 : }
1227 :
1228 0 : bTemp = xAnimate->getAccumulate();
1229 0 : if( bTemp )
1230 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ACCUMULATE, XML_SUM );
1231 :
1232 0 : nTemp = xAnimate->getAdditive();
1233 0 : if( nTemp != AnimationAdditiveMode::REPLACE )
1234 : {
1235 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_AdditiveMode) );
1236 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ADDITIVE, sTmp.makeStringAndClear() );
1237 : }
1238 : }
1239 :
1240 0 : Sequence< TimeFilterPair > aTimeFilter( xAnimate->getTimeFilter() );
1241 0 : if( aTimeFilter.getLength() )
1242 : {
1243 0 : sal_Int32 nLength = aTimeFilter.getLength();
1244 0 : const TimeFilterPair* p = aTimeFilter.getConstArray();
1245 :
1246 0 : while( nLength-- )
1247 : {
1248 0 : if( !sTmp.isEmpty() )
1249 0 : sTmp.append( ';' );
1250 :
1251 0 : sTmp.append( OUString::number(p->Time) + "," + OUString::number(p->Progress) );
1252 :
1253 0 : p++;
1254 : }
1255 :
1256 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_KEYSPLINES, sTmp.makeStringAndClear() );
1257 0 : }
1258 : }
1259 :
1260 0 : XMLTokenEnum eElementToken = XML_ANIMATE;
1261 :
1262 0 : switch( nNodeType )
1263 : {
1264 : case AnimationNodeType::ANIMATE:
1265 0 : eElementToken = XML_ANIMATE;
1266 0 : break;
1267 :
1268 : case AnimationNodeType::SET:
1269 0 : eElementToken = XML_SET;
1270 0 : break;
1271 :
1272 : case AnimationNodeType::ANIMATEMOTION:
1273 : {
1274 0 : eElementToken = XML_ANIMATEMOTION;
1275 :
1276 0 : Reference< XAnimateMotion > xAnimateMotion( xAnimate, UNO_QUERY_THROW );
1277 :
1278 0 : aTemp = xAnimateMotion->getPath();
1279 0 : if( aTemp.hasValue() )
1280 : {
1281 0 : convertPath( sTmp, aTemp );
1282 0 : mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_PATH, sTmp.makeStringAndClear() );
1283 : }
1284 :
1285 : // TODO: origin = ( parent | layout )
1286 0 : aTemp = xAnimateMotion->getOrigin();
1287 : }
1288 0 : break;
1289 :
1290 : case AnimationNodeType::ANIMATECOLOR:
1291 : {
1292 0 : eElementToken = XML_ANIMATECOLOR;
1293 :
1294 0 : Reference< XAnimateColor > xAnimateColor( xAnimate, UNO_QUERY_THROW );
1295 :
1296 0 : nTemp = xAnimateColor->getColorInterpolation();
1297 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION, (nTemp == AnimationColorSpace::RGB) ? XML_RGB : XML_HSL );
1298 :
1299 0 : bTemp = xAnimateColor->getDirection();
1300 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COLOR_INTERPOLATION_DIRECTION, bTemp ? XML_CLOCKWISE : XML_COUNTER_CLOCKWISE );
1301 : }
1302 0 : break;
1303 :
1304 : case AnimationNodeType::ANIMATETRANSFORM:
1305 : {
1306 0 : eElementToken = XML_ANIMATETRANSFORM;
1307 :
1308 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_ATTRIBUTENAME, XML_TRANSFORM );
1309 :
1310 0 : Reference< XAnimateTransform > xTransform( xAnimate, UNO_QUERY_THROW );
1311 0 : nTemp = xTransform->getTransformType();
1312 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTemp, getAnimationsEnumMap(Animations_EnumMap_TransformType) );
1313 0 : mrExport.AddAttribute( XML_NAMESPACE_SVG, XML_TYPE, sTmp.makeStringAndClear() );
1314 : }
1315 0 : break;
1316 :
1317 : case AnimationNodeType::TRANSITIONFILTER:
1318 : {
1319 0 : Reference< XTransitionFilter > xTransitionFilter( xAnimate, UNO_QUERY );
1320 0 : eElementToken = XML_TRANSITIONFILTER;
1321 :
1322 0 : sal_Int16 nTransition = xTransitionFilter->getTransition();
1323 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nTransition, getAnimationsEnumMap(Animations_EnumMap_TransitionType) );
1324 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TYPE, sTmp.makeStringAndClear() );
1325 :
1326 0 : sal_Int16 nSubtype = xTransitionFilter->getSubtype();
1327 0 : if( nSubtype != TransitionSubType::DEFAULT )
1328 : {
1329 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nSubtype, getAnimationsEnumMap(Animations_EnumMap_TransitionSubType) );
1330 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_SUBTYPE, sTmp.makeStringAndClear() );
1331 : }
1332 :
1333 0 : bTemp = xTransitionFilter->getMode();
1334 0 : if( !bTemp )
1335 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_MODE, XML_OUT );
1336 :
1337 0 : bTemp = xTransitionFilter->getDirection();
1338 0 : if( !bTemp )
1339 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_DIRECTION, XML_REVERSE );
1340 :
1341 0 : if( (nTransition == TransitionType::FADE) && ((nSubtype == TransitionSubType::FADETOCOLOR) || (nSubtype == TransitionSubType::FADEFROMCOLOR) ))
1342 : {
1343 0 : nTemp = xTransitionFilter->getFadeColor();
1344 0 : ::sax::Converter::convertColor( sTmp, nTemp );
1345 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_FADECOLOR, sTmp.makeStringAndClear() );
1346 0 : }
1347 : }
1348 0 : break;
1349 : }
1350 :
1351 0 : SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, eElementToken, true, true );
1352 :
1353 : }
1354 0 : catch (const Exception&)
1355 : {
1356 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportAnimate(), exception caught!" );
1357 : }
1358 0 : }
1359 :
1360 0 : void AnimationsExporterImpl::exportAudio( const Reference< XAudio >& xAudio )
1361 : {
1362 0 : if( xAudio.is() ) try
1363 : {
1364 0 : OUString aSourceURL;
1365 0 : xAudio->getSource() >>= aSourceURL;
1366 0 : if( !aSourceURL.isEmpty() )
1367 0 : mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, mrExport.GetRelativeReference( aSourceURL ) );
1368 :
1369 0 : const double fVolume = xAudio->getVolume();
1370 0 : if( fVolume != 1.0 )
1371 : {
1372 0 : OUStringBuffer sTmp;
1373 0 : ::sax::Converter::convertDouble( sTmp, fVolume );
1374 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_AUDIO_LEVEL, sTmp.makeStringAndClear() );
1375 : }
1376 :
1377 : /* todo?
1378 : sal_Int32 nEndAfterSlide = 0;
1379 : xAudio->getEndAfterSlide() >>= nEndAfterSlide;
1380 : if( nEndAfterSlide != 0 )
1381 : mrExport.AddAttribute( );
1382 : */
1383 0 : SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_AUDIO, true, true );
1384 :
1385 : }
1386 0 : catch (const Exception&)
1387 : {
1388 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportAudio(), exception caught!" );
1389 : }
1390 0 : }
1391 :
1392 0 : void AnimationsExporterImpl::exportCommand( const Reference< XCommand >& xCommand )
1393 : {
1394 0 : if( xCommand.is() ) try
1395 : {
1396 0 : OUStringBuffer sTmp;
1397 0 : Any aTemp( xCommand->getTarget() );
1398 0 : if( aTemp.hasValue() )
1399 : {
1400 0 : convertTarget( sTmp, aTemp );
1401 0 : mrExport.AddAttribute( XML_NAMESPACE_SMIL, XML_TARGETELEMENT, sTmp.makeStringAndClear() );
1402 : }
1403 :
1404 0 : sal_Int16 nCommand = xCommand->getCommand();
1405 0 : SvXMLUnitConverter::convertEnum( sTmp, (sal_uInt16)nCommand, getAnimationsEnumMap(Animations_EnumMap_Command) );
1406 0 : mrExport.AddAttribute( XML_NAMESPACE_ANIMATION, XML_COMMAND, sTmp.makeStringAndClear() );
1407 :
1408 : // todo virtual ::com::sun::star::uno::Any SAL_CALL getParameter() throw (::com::sun::star::uno::RuntimeException) = 0;
1409 :
1410 0 : SvXMLElementExport aElement( mrExport, XML_NAMESPACE_ANIMATION, XML_COMMAND, true, true );
1411 :
1412 : }
1413 0 : catch (const Exception&)
1414 : {
1415 : OSL_FAIL( "xmloff::AnimationsExporterImpl::exportCommand(), exception caught!" );
1416 : }
1417 0 : }
1418 :
1419 0 : Reference< XInterface > AnimationsExporterImpl::getParagraphTarget( const ParagraphTarget* pTarget ) const
1420 : {
1421 0 : if( pTarget ) try
1422 : {
1423 0 : Reference< XEnumerationAccess > xParaEnumAccess( pTarget->Shape, UNO_QUERY_THROW );
1424 :
1425 0 : Reference< XEnumeration > xEnumeration( xParaEnumAccess->createEnumeration(), UNO_QUERY_THROW );
1426 0 : sal_Int32 nParagraph = pTarget->Paragraph;
1427 :
1428 0 : while( xEnumeration->hasMoreElements() )
1429 : {
1430 0 : Reference< XInterface > xRef( xEnumeration->nextElement(), UNO_QUERY );
1431 0 : if( nParagraph-- == 0 )
1432 0 : return xRef;
1433 0 : }
1434 : }
1435 0 : catch (const RuntimeException&)
1436 : {
1437 : OSL_FAIL( "xmloff::AnimationsExporterImpl::getParagraphTarget(), RuntimeException caught!" );
1438 : }
1439 :
1440 0 : Reference< XInterface > xRef;
1441 0 : return xRef;
1442 : }
1443 :
1444 0 : void AnimationsExporterImpl::convertPath( OUStringBuffer& sTmp, const Any& rPath ) const
1445 : {
1446 0 : OUString aStr;
1447 0 : rPath >>= aStr;
1448 :
1449 0 : sTmp = aStr;
1450 0 : }
1451 :
1452 0 : void AnimationsExporterImpl::convertValue( XMLTokenEnum eAttributeName, OUStringBuffer& sTmp, const Any& rValue ) const
1453 : {
1454 0 : if( !rValue.hasValue() )
1455 0 : return;
1456 :
1457 0 : if( rValue.getValueType() == cppu::UnoType<ValuePair>::get() )
1458 : {
1459 0 : const ValuePair* pValuePair = static_cast< const ValuePair* >( rValue.getValue() );
1460 0 : OUStringBuffer sTmp2;
1461 0 : convertValue( eAttributeName, sTmp, pValuePair->First );
1462 0 : sTmp.append( ',' );
1463 0 : convertValue( eAttributeName, sTmp2, pValuePair->Second );
1464 0 : sTmp.append( sTmp2.makeStringAndClear() );
1465 : }
1466 0 : else if( rValue.getValueType() == cppu::UnoType< Sequence<Any> >::get() )
1467 : {
1468 0 : const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() );
1469 0 : const sal_Int32 nLength = pSequence->getLength();
1470 : sal_Int32 nElement;
1471 0 : const Any* pAny = pSequence->getConstArray();
1472 :
1473 0 : OUStringBuffer sTmp2;
1474 :
1475 0 : for( nElement = 0; nElement < nLength; nElement++, pAny++ )
1476 : {
1477 0 : if( !sTmp.isEmpty() )
1478 0 : sTmp.append( ';' );
1479 0 : convertValue( eAttributeName, sTmp2, *pAny );
1480 0 : sTmp.append( sTmp2.makeStringAndClear() );
1481 0 : }
1482 : }
1483 : else
1484 : {
1485 0 : OUString aString;
1486 : sal_Int32 nType;
1487 :
1488 0 : switch( eAttributeName )
1489 : {
1490 : case XML_X:
1491 : case XML_Y:
1492 : case XML_WIDTH:
1493 : case XML_HEIGHT:
1494 : case XML_ANIMATETRANSFORM:
1495 : case XML_ANIMATEMOTION:
1496 : {
1497 0 : if( rValue >>= aString )
1498 : {
1499 0 : sTmp.append( aString );
1500 : }
1501 0 : else if( rValue.getValueType() == cppu::UnoType<double>::get() )
1502 : {
1503 0 : sTmp.append( *(static_cast< const double* >( rValue.getValue() )) );
1504 : }
1505 : else
1506 : {
1507 : OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid value type!" );
1508 : }
1509 0 : return;
1510 : }
1511 :
1512 : case XML_SKEWX:
1513 0 : case XML_ROTATE: nType = XML_TYPE_DOUBLE; break;
1514 0 : case XML_TEXT_ROTATION_ANGLE: nType = XML_TYPE_NUMBER16; break;
1515 : case XML_FILL_COLOR:
1516 : case XML_STROKE_COLOR:
1517 : case XML_DIM:
1518 0 : case XML_COLOR: nType = XML_TYPE_COLOR; break;
1519 0 : case XML_FILL: nType = XML_SD_TYPE_FILLSTYLE; break;
1520 0 : case XML_STROKE: nType = XML_SD_TYPE_STROKE; break;
1521 0 : case XML_FONT_WEIGHT: nType = XML_TYPE_TEXT_WEIGHT; break;
1522 0 : case XML_FONT_STYLE: nType = XML_TYPE_TEXT_POSTURE; break;
1523 0 : case XML_TEXT_UNDERLINE: nType = XML_TYPE_TEXT_UNDERLINE_STYLE; break;
1524 0 : case XML_FONT_SIZE: nType = XML_TYPE_DOUBLE_PERCENT; break;
1525 0 : case XML_VISIBILITY: nType = XML_SD_TYPE_PRESPAGE_VISIBILITY; break;
1526 : case XML_OPACITY:
1527 0 : case XML_TRANSITIONFILTER: nType = XML_TYPE_DOUBLE; break;
1528 : default:
1529 : OSL_FAIL( "xmloff::AnimationsExporterImpl::convertValue(), invalid AttributeName!" );
1530 0 : nType = XML_TYPE_STRING;
1531 : }
1532 :
1533 : //const XMLPropertyHandler* pHandler = static_cast<SdXMLExport*>(&mrExport)->GetSdPropHdlFactory()->GetPropertyHandler( nType );
1534 0 : const XMLPropertyHandler* pHandler = mpSdPropHdlFactory->GetPropertyHandler( nType );
1535 0 : if( pHandler )
1536 : {
1537 0 : pHandler->exportXML( aString, rValue, mrExport.GetMM100UnitConverter() );
1538 0 : sTmp.append( aString );
1539 0 : }
1540 : }
1541 : }
1542 :
1543 0 : void AnimationsExporterImpl::convertTiming( OUStringBuffer& sTmp, const Any& rValue ) const
1544 : {
1545 0 : if( !rValue.hasValue() )
1546 0 : return;
1547 :
1548 0 : if( rValue.getValueType() == cppu::UnoType< Sequence<Any> >::get() )
1549 : {
1550 0 : const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() );
1551 0 : const sal_Int32 nLength = pSequence->getLength();
1552 : sal_Int32 nElement;
1553 0 : const Any* pAny = pSequence->getConstArray();
1554 :
1555 0 : OUStringBuffer sTmp2;
1556 :
1557 0 : for( nElement = 0; nElement < nLength; nElement++, pAny++ )
1558 : {
1559 0 : if( !sTmp.isEmpty() )
1560 0 : sTmp.append( ';' );
1561 0 : convertTiming( sTmp2, *pAny );
1562 0 : sTmp.append( sTmp2.makeStringAndClear() );
1563 0 : }
1564 : }
1565 0 : else if( rValue.getValueType() == cppu::UnoType<double>::get() )
1566 : {
1567 0 : sTmp.append( *(static_cast< const double* >( rValue.getValue() )) );
1568 0 : sTmp.append( 's');
1569 : }
1570 0 : else if( rValue.getValueType() == cppu::UnoType<Timing>::get() )
1571 : {
1572 0 : const Timing* pTiming = static_cast< const Timing* >( rValue.getValue() );
1573 0 : sTmp.append( GetXMLToken( (*pTiming == Timing_MEDIA) ? XML_MEDIA : XML_INDEFINITE ) );
1574 : }
1575 0 : else if( rValue.getValueType() == cppu::UnoType<Event>::get() )
1576 : {
1577 0 : OUStringBuffer sTmp2;
1578 :
1579 0 : const Event* pEvent = static_cast< const Event* >( rValue.getValue() );
1580 :
1581 0 : if( pEvent->Trigger != EventTrigger::NONE )
1582 : {
1583 0 : if( pEvent->Source.hasValue() )
1584 : {
1585 0 : convertSource( sTmp, pEvent->Source );
1586 0 : sTmp.append( '.' );
1587 : }
1588 :
1589 0 : SvXMLUnitConverter::convertEnum( sTmp2, (sal_uInt16)pEvent->Trigger, getAnimationsEnumMap(Animations_EnumMap_EventTrigger) );
1590 :
1591 0 : sTmp.append( sTmp2.makeStringAndClear() );
1592 : }
1593 :
1594 0 : if( pEvent->Offset.hasValue() )
1595 : {
1596 0 : convertTiming( sTmp2, pEvent->Offset );
1597 :
1598 0 : if( !sTmp.isEmpty() )
1599 0 : sTmp.append( '+' );
1600 :
1601 0 : sTmp.append( sTmp2.makeStringAndClear() );
1602 0 : }
1603 : }
1604 : else
1605 : {
1606 : OSL_FAIL( "xmloff::AnimationsExporterImpl::convertTiming(), invalid value type!" );
1607 : }
1608 : }
1609 :
1610 0 : void AnimationsExporterImpl::convertSource( OUStringBuffer& sTmp, const Any& rSource ) const
1611 : {
1612 0 : convertTarget( sTmp, rSource );
1613 0 : }
1614 :
1615 0 : void AnimationsExporterImpl::convertTarget( OUStringBuffer& sTmp, const Any& rTarget ) const
1616 : {
1617 0 : if( !rTarget.hasValue() )
1618 0 : return;
1619 :
1620 0 : Reference< XInterface > xRef;
1621 :
1622 0 : if( rTarget.getValueTypeClass() == ::com::sun::star::uno::TypeClass_INTERFACE )
1623 : {
1624 0 : rTarget >>= xRef;
1625 : }
1626 0 : else if( rTarget.getValueType() == cppu::UnoType<ParagraphTarget>::get() )
1627 : {
1628 0 : xRef = getParagraphTarget( static_cast< const ParagraphTarget* >( rTarget.getValue() ) );
1629 : }
1630 :
1631 : DBG_ASSERT( xRef.is(), "xmloff::AnimationsExporterImpl::convertTarget(), invalid target type!" );
1632 0 : if( xRef.is() )
1633 : {
1634 0 : const OUString& rIdentifier = mrExport.getInterfaceToIdentifierMapper().getIdentifier(xRef);
1635 0 : if( !rIdentifier.isEmpty() )
1636 0 : sTmp.append( rIdentifier );
1637 0 : }
1638 : }
1639 :
1640 12 : void AnimationsExporterImpl::prepareValue( const Any& rValue )
1641 : {
1642 12 : if( !rValue.hasValue() )
1643 24 : return;
1644 :
1645 0 : if( rValue.getValueType() == cppu::UnoType<ValuePair>::get() )
1646 : {
1647 0 : const ValuePair* pValuePair = static_cast< const ValuePair* >( rValue.getValue() );
1648 0 : prepareValue( pValuePair->First );
1649 0 : prepareValue( pValuePair->Second );
1650 : }
1651 0 : else if( rValue.getValueType() == cppu::UnoType< Sequence<Any> >::get() )
1652 : {
1653 0 : const Sequence<Any>* pSequence = static_cast< const Sequence<Any>* >( rValue.getValue() );
1654 0 : const sal_Int32 nLength = pSequence->getLength();
1655 : sal_Int32 nElement;
1656 0 : const Any* pAny = pSequence->getConstArray();
1657 :
1658 0 : for( nElement = 0; nElement < nLength; nElement++, pAny++ )
1659 0 : prepareValue( *pAny );
1660 : }
1661 0 : else if( rValue.getValueTypeClass() == ::com::sun::star::uno::TypeClass_INTERFACE )
1662 : {
1663 0 : Reference< XInterface> xRef( rValue, UNO_QUERY );
1664 0 : if( xRef.is() )
1665 0 : mrExport.getInterfaceToIdentifierMapper().registerReference( xRef );
1666 : }
1667 0 : else if( rValue.getValueType() == cppu::UnoType<ParagraphTarget>::get() )
1668 : {
1669 0 : Reference< XInterface> xRef( getParagraphTarget( static_cast< const ParagraphTarget* >( rValue.getValue() ) ) );
1670 0 : if( xRef.is() )
1671 0 : mrExport.getInterfaceToIdentifierMapper().registerReference( xRef );
1672 : }
1673 0 : else if( rValue.getValueType() == cppu::UnoType<Event>::get() )
1674 : {
1675 0 : const Event* pEvent = static_cast< const Event* >( rValue.getValue() );
1676 0 : prepareValue( pEvent->Source );
1677 : }
1678 : }
1679 :
1680 6 : AnimationsExporter::AnimationsExporter( SvXMLExport& rExport, const Reference< XPropertySet >& xPageProps )
1681 : {
1682 6 : mpImpl = new AnimationsExporterImpl( rExport, xPageProps );
1683 6 : }
1684 :
1685 18 : AnimationsExporter::~AnimationsExporter()
1686 : {
1687 6 : delete mpImpl;
1688 12 : }
1689 :
1690 6 : void AnimationsExporter::prepare( Reference< XAnimationNode > xRootNode )
1691 : {
1692 : try
1693 : {
1694 6 : if( xRootNode.is() )
1695 : {
1696 6 : mpImpl->prepareTransitionNode();
1697 6 : mpImpl->prepareNode( xRootNode );
1698 : }
1699 : }
1700 0 : catch (const RuntimeException&)
1701 : {
1702 : OSL_FAIL( "xmloff::AnimationsExporter::prepare(), exception caught" );
1703 : }
1704 6 : }
1705 :
1706 6 : void AnimationsExporter::exportAnimations( Reference< XAnimationNode > xRootNode )
1707 : {
1708 : try
1709 : {
1710 6 : if( xRootNode.is() )
1711 : {
1712 6 : bool bHasEffects = mpImpl->mbHasTransition;
1713 :
1714 6 : if( !bHasEffects )
1715 : {
1716 : // first check if there are no animations
1717 6 : Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
1718 12 : Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1719 6 : if( xEnumeration->hasMoreElements() )
1720 : {
1721 : // first child node may be an empty main sequence, check this
1722 0 : Reference< XAnimationNode > xMainNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
1723 0 : Reference< XEnumerationAccess > xMainEnumerationAccess( xMainNode, UNO_QUERY_THROW );
1724 0 : Reference< XEnumeration > xMainEnumeration( xMainEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1725 :
1726 : // only export if the main sequence is not empty or if there are additional
1727 : // trigger sequences
1728 0 : bHasEffects = xMainEnumeration->hasMoreElements() || xEnumeration->hasMoreElements();
1729 6 : }
1730 : }
1731 :
1732 6 : if( bHasEffects )
1733 0 : mpImpl->exportNode( xRootNode );
1734 : }
1735 : }
1736 0 : catch (const RuntimeException&)
1737 : {
1738 : OSL_FAIL( "xmloff::AnimationsExporter::exportAnimations(), exception caught" );
1739 : }
1740 6 : }
1741 :
1742 : }
1743 :
1744 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
