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