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_sd.hxx"
26 #include <com/sun/star/animations/XAnimationNodeSupplier.hpp>
27 #include <com/sun/star/animations/AnimationFill.hpp>
28 #include <com/sun/star/animations/AnimationRestart.hpp>
29 #include <com/sun/star/animations/Timing.hpp>
30 #include <com/sun/star/animations/Event.hpp>
31 #include <com/sun/star/animations/AnimationEndSync.hpp>
32 #include <com/sun/star/animations/EventTrigger.hpp>
33 #include <com/sun/star/presentation/EffectNodeType.hpp>
34 #include <com/sun/star/presentation/EffectPresetClass.hpp>
35 #include <com/sun/star/animations/AnimationNodeType.hpp>
36 #include <com/sun/star/animations/AnimationTransformType.hpp>
37 #include <com/sun/star/animations/AnimationCalcMode.hpp>
38 #include <com/sun/star/animations/AnimationValueType.hpp>
39 #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
40 #include <com/sun/star/animations/XIterateContainer.hpp>
41 #include <com/sun/star/animations/XAnimateSet.hpp>
42 #include <com/sun/star/animations/XAudio.hpp>
43 #include <com/sun/star/animations/XCommand.hpp>
44 #include <com/sun/star/animations/XTransitionFilter.hpp>
45 #include <com/sun/star/animations/XAnimateColor.hpp>
46 #include <com/sun/star/animations/XAnimateMotion.hpp>
47 #include <com/sun/star/animations/XAnimateTransform.hpp>
48 #include <com/sun/star/animations/ValuePair.hpp>
49 #include <com/sun/star/animations/AnimationColorSpace.hpp>
50 #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
51 #include <com/sun/star/presentation/EffectCommands.hpp>
52 #include <com/sun/star/beans/NamedValue.hpp>
53 #include <com/sun/star/drawing/FillStyle.hpp>
54 #include <com/sun/star/drawing/LineStyle.hpp>
55 #include <com/sun/star/awt/FontWeight.hpp>
56 #include <com/sun/star/awt/FontUnderline.hpp>
57 #include <com/sun/star/awt/FontSlant.hpp>
58 #include <com/sun/star/container/XEnumerationAccess.hpp>
59 #include <com/sun/star/presentation/ParagraphTarget.hpp>
60 #include <com/sun/star/presentation/TextAnimationType.hpp>
61 #include <comphelper/processfactory.hxx>
62 #include <rtl/ustrbuf.hxx>
63 #include <rtl/math.hxx>
64
65 #include <vcl/vclenum.hxx>
66 #include <svx/svdotext.hxx>
67 #include <editeng/outlobj.hxx>
68 #include <editeng/editobj.hxx>
69 #include <pptinanimations.hxx>
70 #include <pptatom.hxx>
71 #include "pptin.hxx"
72 #include <algorithm>
73
74 using ::std::map;
75 using ::rtl::OUString;
76 using ::rtl::OUStringBuffer;
77 using ::com::sun::star::uno::Any;
78 using ::com::sun::star::uno::Reference;
79 using ::com::sun::star::uno::UNO_QUERY;
80 using ::com::sun::star::uno::UNO_QUERY_THROW;
81 using ::com::sun::star::uno::Sequence;
82 using ::com::sun::star::uno::makeAny;
83 using ::com::sun::star::uno::Exception;
84 using ::com::sun::star::uno::XInterface;
85 using ::com::sun::star::beans::NamedValue;
86 using ::com::sun::star::container::XEnumerationAccess;
87 using ::com::sun::star::container::XEnumeration;
88 using ::com::sun::star::lang::XMultiServiceFactory;
89
90 using namespace ::com::sun::star::drawing;
91 using namespace ::com::sun::star::animations;
92 using namespace ::com::sun::star::presentation;
93
94 namespace sd
95 {
96 extern Reference< XInterface > RandomAnimationNode_createInstance( sal_Int16 nPresetClass );
97 }
98
99 namespace ppt
100 {
101
find(const OUString & rName)102 const transition* transition::find( const OUString& rName )
103 {
104 const transition* p = gTransitions;
105
106 while( p->mpName )
107 {
108 if( rName.compareToAscii( p->mpName ) == 0 )
109 return p;
110
111 p++;
112 }
113
114 return NULL;
115 }
116
117 // ====================================================================
118
119
120
121 // ====================================================================
122
operator >>(SvStream & rIn,AnimationNode & rNode)123 SvStream& operator>>(SvStream& rIn, AnimationNode& rNode )
124 {
125 rIn >> rNode.mnU1;
126 rIn >> rNode.mnRestart;
127 rIn >> rNode.mnGroupType;
128 rIn >> rNode.mnFill;
129 rIn >> rNode.mnU3;
130 rIn >> rNode.mnU4;
131 rIn >> rNode.mnDuration;
132 rIn >> rNode.mnNodeType;
133
134 return rIn;
135 }
136
137 // ====================================================================
138
convertMeasure(OUString & rString)139 static bool convertMeasure( OUString& rString )
140 {
141 bool bRet = false;
142
143 const sal_Char* pSource[] = { "ppt_x", "ppt_y", "ppt_w", "ppt_h", NULL };
144 const sal_Char* pDest[] = { "x", "y", "width", "height", NULL };
145 sal_Int32 nIndex = 0;
146
147 const sal_Char** ps = pSource;
148 const sal_Char** pd = pDest;
149
150 while( *ps )
151 {
152 const OUString aSearch( OUString::createFromAscii( *ps ) );
153 while( (nIndex = rString.indexOf( aSearch, nIndex )) != -1 )
154 {
155 sal_Int32 nLength = aSearch.getLength();
156 if( nIndex && (rString.getStr()[nIndex-1] == '#' ) )
157 {
158 nIndex--;
159 nLength++;
160 }
161
162 const OUString aNew( OUString::createFromAscii( *pd ) );
163 rString = rString.replaceAt( nIndex, nLength, aNew );
164 nIndex += aNew.getLength();
165 bRet = true;
166 }
167 ps++;
168 pd++;
169 }
170
171 return bRet;
172 }
173
174
175 // ====================================================================
176
hasProperty(sal_Int32 nProperty) const177 bool PropertySet::hasProperty( sal_Int32 nProperty ) const
178 {
179 return maProperties.find( nProperty ) != maProperties.end();
180 }
181
182 // --------------------------------------------------------------------
183
getProperty(sal_Int32 nProperty) const184 Any PropertySet::getProperty( sal_Int32 nProperty ) const
185 {
186 PropertySetMap_t::const_iterator aIter( maProperties.find( nProperty ) );
187 if( aIter != maProperties.end() )
188 return (*aIter).second;
189 else
190 return Any();
191 }
192
193 // ====================================================================
194
195 /** this adds an any to another any.
196 if rNewValue is empty, rOldValue is returned.
197 if rOldValue is empty, rNewValue is returned.
198 if rOldValue contains a value, a sequence with rOldValue and rNewValue is returned.
199 if rOldValue contains a sequence, a new sequence with the old sequence and rNewValue is returned.
200 */
addToSequence(const Any & rOldValue,const Any & rNewValue)201 static Any addToSequence( const Any& rOldValue, const Any& rNewValue )
202 {
203 if( !rNewValue.hasValue() )
204 {
205 return rOldValue;
206 }
207 else if( !rOldValue.hasValue() )
208 {
209 return rNewValue;
210 }
211 else
212 {
213 Sequence< Any > aNewSeq;
214 if( rOldValue >>= aNewSeq )
215 {
216 sal_Int32 nSize = aNewSeq.getLength();
217 aNewSeq.realloc(nSize+1);
218 aNewSeq[nSize] = rNewValue;
219 }
220 else
221 {
222 aNewSeq.realloc(2);
223 aNewSeq[0] = rOldValue;
224 aNewSeq[1] = rNewValue;
225 }
226 return makeAny( aNewSeq );
227 }
228 }
229
230 // ====================================================================
231
AnimationImporter(ImplSdPPTImport * pPPTImport,SvStream & rStCtrl)232 AnimationImporter::AnimationImporter( ImplSdPPTImport* pPPTImport, SvStream& rStCtrl )
233 : mpPPTImport( pPPTImport ), mrStCtrl( rStCtrl )
234 {
235 }
236
237 // --------------------------------------------------------------------
238
import(const Reference<XDrawPage> & xPage,const DffRecordHeader & rProgTagContentHd)239 void AnimationImporter::import( const Reference< XDrawPage >& xPage, const DffRecordHeader& rProgTagContentHd )
240 {
241 #ifdef DBG_ANIM_LOG
242 mpFile = fopen( "c:\\output.xml", "w+" );
243 //mpFile = stdout;
244 #endif
245 dump("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
246
247 Reference< XAnimationNodeSupplier > xNodeSupplier( xPage, UNO_QUERY );
248 if( xNodeSupplier.is() )
249 {
250 mxRootNode = xNodeSupplier->getAnimationNode();
251 if( mxRootNode.is() )
252 {
253 Reference< XAnimationNode > xParent;
254
255 const Atom* pAtom = Atom::import( rProgTagContentHd, mrStCtrl );
256 if( pAtom )
257 {
258 importAnimationContainer( pAtom, xParent );
259 }
260
261 processAfterEffectNodes();
262 }
263 }
264
265 #ifdef DBG_ANIM_LOG
266 fclose( mpFile );
267 #endif
268 }
269
270 // --------------------------------------------------------------------
271
processAfterEffectNodes()272 void AnimationImporter::processAfterEffectNodes()
273 {
274 std::for_each( maAfterEffectNodes.begin(), maAfterEffectNodes.end(), sd::stl_process_after_effect_node_func );
275 }
276
277 // --------------------------------------------------------------------
278
createNode(const Atom * pAtom,const AnimationNode & rNode)279 Reference< XAnimationNode > AnimationImporter::createNode( const Atom* pAtom, const AnimationNode& rNode )
280 {
281 const char* pServiceName = NULL;
282
283 switch( rNode.mnGroupType )
284 {
285 case mso_Anim_GroupType_PAR:
286 if( pAtom->hasChildAtom( DFF_msofbtAnimIteration ) )
287 pServiceName = "com.sun.star.animations.IterateContainer";
288 else
289 pServiceName = "com.sun.star.animations.ParallelTimeContainer";
290 break;
291 case mso_Anim_GroupType_SEQ:
292 pServiceName = "com.sun.star.animations.SequenceTimeContainer";
293 break;
294 case mso_Anim_GroupType_NODE:
295 {
296 switch( rNode.mnNodeType )
297 {
298 case mso_Anim_Behaviour_FILTER:
299 /*
300 pServiceName = "com.sun.star.animations.TransitionFilter";
301 break;
302 */
303 case mso_Anim_Behaviour_ANIMATION:
304 if( pAtom->hasChildAtom( DFF_msofbtAnimateSet ) )
305 pServiceName = "com.sun.star.animations.AnimateSet";
306 else if( pAtom->hasChildAtom( DFF_msofbtAnimateColor ) )
307 pServiceName = "com.sun.star.animations.AnimateColor";
308 else if( pAtom->hasChildAtom( DFF_msofbtAnimateScale ) )
309 pServiceName = "com.sun.star.animations.AnimateTransform";
310 else if( pAtom->hasChildAtom( DFF_msofbtAnimateRotation ) )
311 pServiceName = "com.sun.star.animations.AnimateTransform";
312 else if( pAtom->hasChildAtom( DFF_msofbtAnimateMotion ) )
313 pServiceName = "com.sun.star.animations.AnimateMotion";
314 else if( pAtom->hasChildAtom( DFF_msofbtAnimateFilter ) )
315 pServiceName = "com.sun.star.animations.TransitionFilter";
316 else if( pAtom->hasChildAtom( DFF_msofbtAnimCommand ) )
317 pServiceName = "com.sun.star.animations.Command";
318 else
319 pServiceName = "com.sun.star.animations.Animate";
320 break;
321 }
322 break;
323 }
324 case mso_Anim_GroupType_MEDIA:
325 pServiceName = "com.sun.star.animations.Audio";
326 break;
327
328 default:
329 pServiceName = "com.sun.star.animations.Animate";
330 break;
331 }
332
333 Reference< XAnimationNode > xNode;
334 if( pServiceName )
335 {
336 const OUString aServiceName( OUString::createFromAscii(pServiceName) );
337 Reference< XInterface > xFac( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName) );
338 xNode.set(xFac , UNO_QUERY );
339 }
340
341 DBG_ASSERT( xNode.is(), "sd::AnimationImporter::createNode(), node creation failed!" );
342 return xNode;
343 }
344
345 // --------------------------------------------------------------------
346
is_random(const AnimationNode & rNode,const PropertySet & rSet,sal_Int32 & rPresetClass)347 static bool is_random( const AnimationNode& rNode, const PropertySet& rSet, sal_Int32& rPresetClass )
348 {
349 if( rNode.mnGroupType != mso_Anim_GroupType_PAR )
350 return false;
351
352 if( !rSet.hasProperty( DFF_ANIM_PRESET_ID ) || !rSet.hasProperty( DFF_ANIM_PRESET_CLASS ) )
353 return false;
354
355 sal_Int32 nPresetId = 0;
356 if( !(rSet.getProperty( DFF_ANIM_PRESET_ID ) >>= nPresetId) || (nPresetId != 24) )
357 return false;
358
359 sal_Int32 nPresetClass = 0;
360 if( !(rSet.getProperty( DFF_ANIM_PRESET_CLASS ) >>= nPresetClass) )
361 return false;
362
363 switch( nPresetClass )
364 {
365 case DFF_ANIM_PRESS_CLASS_ENTRANCE: rPresetClass = EffectPresetClass::ENTRANCE; return true;
366 case DFF_ANIM_PRESS_CLASS_EXIT: rPresetClass = EffectPresetClass::EXIT; return true;
367 }
368 return false;
369 }
370
371
importAnimationContainer(const Atom * pAtom,const Reference<XAnimationNode> & xParent)372 void AnimationImporter::importAnimationContainer( const Atom* pAtom, const Reference< XAnimationNode >& xParent )
373 {
374 if( pAtom->seekToContent() )
375 {
376 AnimationNode aNode;
377 const Atom* pAnimationNodeAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimNode );
378 if( pAnimationNodeAtom && pAnimationNodeAtom->seekToContent() )
379 mrStCtrl >> aNode;
380
381 PropertySet aSet;
382 const Atom* pAnimationPropertySetAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimPropertySet );
383 if( pAnimationPropertySetAtom )
384 importPropertySetContainer( pAnimationPropertySetAtom, aSet );
385
386 Reference< XAnimationNode > xNode;
387
388 if( xParent.is() )
389 {
390 sal_Int32 nPresetClass;
391 if( is_random( aNode, aSet, nPresetClass ) )
392 {
393 // create a random animation node with the given preset class
394 xNode.set( sd::RandomAnimationNode_createInstance( (sal_Int16)nPresetClass ), UNO_QUERY );
395 }
396
397 if( !xNode.is() )
398 {
399 // create a node for the given atom
400 xNode = createNode( pAtom, aNode );
401 }
402 }
403 else
404 {
405 // if we have no parent we fill the root node
406 xNode = mxRootNode;
407 }
408
409 // import if we have a node and its not random
410 if( xNode.is() )
411 {
412 fillNode( xNode, aNode, aSet );
413
414 switch( aNode.mnGroupType )
415 {
416 case mso_Anim_GroupType_PAR:
417 {
418 dump( "<par" );
419 dump( aNode );
420 dump( aSet );
421 importTimeContainer( pAtom, xNode );
422 dump( "</par>\n" );
423
424 // for iteration containers, map target from childs to iteration
425 Reference< XIterateContainer > xIter( xNode, UNO_QUERY );
426 if( xIter.is() )
427 {
428 double fDuration = 0.0;
429 Any aTarget, aEmpty;
430 Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY );
431 if( xEnumerationAccess.is() )
432 {
433 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
434 if( xEnumeration.is() )
435 {
436 while( xEnumeration->hasMoreElements() )
437 {
438 Reference< XAnimate > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
439 if( xChildNode.is() )
440 {
441 double fChildBegin = 0.0;
442 double fChildDuration = 0.0;
443 xChildNode->getBegin() >>= fChildBegin;
444 xChildNode->getDuration() >>= fChildDuration;
445
446 fChildDuration += fChildBegin;
447 if( fChildDuration > fDuration )
448 fDuration = fChildDuration;
449
450 if( !aTarget.hasValue() )
451 aTarget = xChildNode->getTarget();
452
453 xChildNode->setTarget( aEmpty );
454 }
455 }
456 }
457 }
458
459 xIter->setTarget( aTarget );
460
461 double fIterateInterval = xIter->getIterateInterval() * fDuration / 100;
462 xIter->setIterateInterval( fIterateInterval );
463 }
464 }
465 break;
466
467 case mso_Anim_GroupType_SEQ:
468 {
469 dump( "<seq" );
470 dump( aNode );
471 dump( aSet );
472 importTimeContainer( pAtom, xNode );
473 dump( "</seq>\n" );
474
475 if( aSet.hasProperty( DFF_ANIM_NODE_TYPE ) )
476 {
477 sal_Int32 nPPTNodeType = 0;
478 if( aSet.getProperty( DFF_ANIM_NODE_TYPE ) >>= nPPTNodeType )
479 {
480 switch(nPPTNodeType)
481 {
482 case DFF_ANIM_NODE_TYPE_MAIN_SEQUENCE:
483 fixMainSequenceTiming( xNode );
484 break;
485 case DFF_ANIM_NODE_TYPE_INTERACTIVE_SEQ:
486 fixInteractiveSequenceTiming( xNode );
487 break;
488 }
489 }
490 }
491 }
492 break;
493
494 case mso_Anim_GroupType_NODE:
495 {
496 #ifdef DBG_ANIM_LOG
497 if( pAtom->hasChildAtom( DFF_msofbtAnimateSet ) )
498 {
499 dump( "<set" );
500 }
501 else if( pAtom->hasChildAtom( DFF_msofbtAnimateColor ) )
502 {
503 dump( "<animateColor" );
504 }
505 else if( pAtom->hasChildAtom( DFF_msofbtAnimateScale ) )
506 {
507 dump( "<animateScale" );
508 }
509 else if( pAtom->hasChildAtom( DFF_msofbtAnimateRotation ) )
510 {
511 dump( "<animateRotation" );
512 }
513 else if( pAtom->hasChildAtom( DFF_msofbtAnimateMotion ) )
514 {
515 dump( "<animateMotion" );
516 }
517 else if( pAtom->hasChildAtom( DFF_msofbtAnimate ) )
518 {
519 dump( "<animate" );
520 }
521 else if( pAtom->hasChildAtom( DFF_msofbtAnimateFilter ) )
522 {
523 dump( "<animateFilter" );
524 }
525 else if( pAtom->hasChildAtom( DFF_msofbtAnimCommand ) )
526 {
527 dump( "<command" );
528 }
529 else
530 {
531 DBG_ERROR( "unknown node atom!" );
532 dump_atom_header( pAtom, true, false );
533 dump_atom( pAtom );
534 dump_atom_header( pAtom, false, false );
535 break;
536 }
537 dump( aNode );
538 dump( aSet );
539 #endif
540 importAnimationNodeContainer( pAtom, xNode );
541 if( !convertAnimationNode( xNode, xParent ) )
542 xNode = 0;
543 dump( "/>\n");
544
545 }
546 break;
547
548 case mso_Anim_GroupType_MEDIA:
549 {
550 dump( "<audio" );
551 dump( aNode );
552 dump( aSet );
553 importAudioContainer( pAtom, xNode );
554 dump( "</audio>\n" );
555 }
556 break;
557
558 default:
559 DBG_ERROR( "unknown group atom!" );
560
561 dump_atom_header( pAtom, true, false );
562 dump_atom( pAtom );
563 dump_atom_header( pAtom, false, false );
564 break;
565
566 }
567 }
568
569 if( xParent.is() && xNode.is() )
570 {
571 Reference< XTimeContainer > xParentContainer( xParent, UNO_QUERY );
572 DBG_ASSERT( xParentContainer.is(), "parent is no container, then why do I have a child here?" );
573 if( xParentContainer.is() )
574 {
575 xParentContainer->appendChild( xNode );
576 }
577 }
578 }
579 }
580
581 // --------------------------------------------------------------------
fixMainSequenceTiming(const::com::sun::star::uno::Reference<::com::sun::star::animations::XAnimationNode> & xNode)582 void AnimationImporter::fixMainSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
583 {
584 try
585 {
586 bool bFirst = true;
587 Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
588 Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
589 while( xE->hasMoreElements() )
590 {
591 // click node
592 Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
593
594 Event aEvent;
595 aEvent.Trigger = EventTrigger::ON_NEXT;
596 aEvent.Repeat = 0;
597 xClickNode->setBegin( makeAny( aEvent ) );
598
599 if( bFirst )
600 {
601 bFirst = false;
602 Reference< XEnumerationAccess > xEA2( xClickNode, UNO_QUERY_THROW );
603 Reference< XEnumeration > xE2( xEA2->createEnumeration(), UNO_QUERY_THROW );
604 if( xE2->hasMoreElements() )
605 {
606 // with node
607 xE2->nextElement() >>= xEA2;
608 if( xEA2.is() )
609 xE2.query( xEA2->createEnumeration() );
610 else
611 xE2.clear();
612
613 if( xE2.is() && xE2->hasMoreElements() )
614 {
615 Reference< XAnimationNode > xEffectNode( xE2->nextElement(), UNO_QUERY_THROW );
616 const Sequence< NamedValue > aUserData( xEffectNode->getUserData() );
617 const NamedValue* p = aUserData.getConstArray();
618 sal_Int32 nLength = aUserData.getLength();
619 while( nLength-- )
620 {
621 if( p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "node-type" ) ) )
622 {
623 sal_Int16 nNodeType = 0;
624 p->Value >>= nNodeType;
625 if( nNodeType != ::com::sun::star::presentation::EffectNodeType::ON_CLICK )
626 {
627 // first effect does not start on click, so correct
628 // first click nodes begin to 0s
629 xClickNode->setBegin( makeAny( (double)0.0 ) );
630 break;
631 }
632 }
633 p++;
634 }
635 }
636 }
637 }
638 }
639 }
640 catch( Exception& e )
641 {
642 (void)e;
643 DBG_ERROR("sd::AnimationImporter::fixMainSequenceTiming(), exception caught!" );
644 }
645 }
646
647 // --------------------------------------------------------------------
648
fixInteractiveSequenceTiming(const::com::sun::star::uno::Reference<::com::sun::star::animations::XAnimationNode> & xNode)649 void AnimationImporter::fixInteractiveSequenceTiming( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
650 {
651 try
652 {
653 Any aBegin( xNode->getBegin() );
654 Any aEmpty;
655 xNode->setBegin( aEmpty );
656
657 Reference< XEnumerationAccess > xEA( xNode, UNO_QUERY_THROW );
658 Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
659 while( xE->hasMoreElements() )
660 {
661 // click node
662 Reference< XAnimationNode > xClickNode( xE->nextElement(), UNO_QUERY );
663 xClickNode->setBegin( aBegin );
664 }
665 }
666 catch( Exception& e )
667 {
668 (void)e;
669 DBG_ERROR("sd::AnimationImporter::fixInteractiveSequenceTiming(), exception caught!" );
670 }
671 }
672
673 // --------------------------------------------------------------------
674
convertAnimationNode(const Reference<XAnimationNode> & xNode,const Reference<XAnimationNode> & xParent)675 bool AnimationImporter::convertAnimationNode( const Reference< XAnimationNode >& xNode, const Reference< XAnimationNode >& xParent )
676 {
677 Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
678 if( !xAnimate.is() )
679 return true;
680
681 if( !xAnimate->getTarget().hasValue() )
682 return false;
683
684 const sal_Int16 nNodeType = xNode->getType();
685
686 if( nNodeType == AnimationNodeType::TRANSITIONFILTER )
687 return true;
688
689 OUString aAttributeName( xAnimate->getAttributeName() );
690
691 if( (nNodeType == AnimationNodeType::SET) && aAttributeName.equalsAscii( "fill.on" ) )
692 return false;
693
694 const ImplAttributeNameConversion* p = gImplConversionList;
695
696 MS_AttributeNames eAttribute = MS_UNKNOWN;
697
698 if( (nNodeType == AnimationNodeType::ANIMATEMOTION) ||
699 (nNodeType == AnimationNodeType::ANIMATETRANSFORM) )
700 {
701 OUString aEmpty;
702 aAttributeName = aEmpty;
703 }
704 else
705 {
706 while( p->mpMSName )
707 {
708 if( aAttributeName.compareToAscii( p->mpMSName ) == 0 )
709 break;
710
711 p++;
712 }
713
714 DBG_ASSERT( p->mpMSName || (aAttributeName.getLength() == 0), "sd::AnimationImporter::convertAnimationNode(), unknown attribute!" );
715 #ifdef DBG_ANIM_LOG
716 if( p->mpMSName == 0 ) dump( "<error text=\"sd::AnimationImporter::convertAnimationNode(), unknown attribute!\"/>\n" );
717 #endif
718
719 eAttribute = p->meAttribute;
720
721 if( p->mpAPIName )
722 aAttributeName = OUString::createFromAscii( p->mpAPIName );
723 }
724
725 xAnimate->setAttributeName( aAttributeName );
726
727 if( eAttribute != MS_UNKNOWN )
728 {
729 Any aAny( xAnimate->getFrom() );
730 if( aAny.hasValue() )
731 {
732 if( convertAnimationValue( eAttribute, aAny ) )
733 xAnimate->setFrom( aAny );
734 }
735
736 aAny = xAnimate->getBy();
737 if( aAny.hasValue() )
738 {
739 if( convertAnimationValue( eAttribute, aAny ) )
740 xAnimate->setBy( aAny );
741 }
742
743 aAny = xAnimate->getTo();
744 if( aAny.hasValue() )
745 {
746 if( convertAnimationValue( eAttribute, aAny ) )
747 xAnimate->setTo( aAny );
748 }
749
750 Sequence< Any > aValues( xAnimate->getValues() );
751 sal_Int32 nValues = aValues.getLength();
752 if( nValues )
753 {
754 Any* p2 = aValues.getArray();
755 while( nValues-- )
756 convertAnimationValue( eAttribute, *p2++ );
757
758 xAnimate->setValues( aValues );
759 }
760
761 OUString aFormula( xAnimate->getFormula() );
762 if( aFormula.getLength() )
763 {
764 if( convertMeasure( aFormula ) )
765 xAnimate->setFormula( aFormula );
766 }
767 }
768
769 // check for after-affect
770 Sequence< NamedValue > aUserData( xNode->getUserData() );
771 NamedValue* pValue = aUserData.getArray();
772 NamedValue* pLastValue = pValue;
773 sal_Int32 nLength = aUserData.getLength(), nRemoved = 0;
774
775 sal_Bool bAfterEffect = false;
776 sal_Int32 nMasterRel = 0;
777 for( ; nLength--; pValue++ )
778 {
779 if( pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("after-effect") ) )
780 {
781 pValue->Value >>= bAfterEffect;
782 nRemoved++;
783 }
784 else if( pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("master-rel") ) )
785 {
786 pValue->Value >>= nMasterRel;
787 nRemoved++;
788 }
789 else
790 {
791 if( nRemoved )
792 *pLastValue = *pValue;
793 pLastValue++;
794 }
795 }
796
797 if( nRemoved )
798 {
799 aUserData.realloc( aUserData.getLength() - nRemoved );
800 xNode->setUserData( aUserData );
801 }
802
803 // if its an after effect node, add it to the list for
804 // later processing
805 // after effect nodes are not inserted at their import
806 // position, so return false in this case
807 if( bAfterEffect )
808 {
809 if( nMasterRel != 2 )
810 {
811 Event aEvent;
812
813 aEvent.Source <<= xParent;
814 aEvent.Trigger = EventTrigger::END_EVENT;
815 aEvent.Repeat = 0;
816
817 xNode->setBegin( makeAny( aEvent ) );
818 }
819
820 // add to after effect nodes for later processing
821 sd::AfterEffectNode aNode( xNode, xParent, nMasterRel == 2 );
822 maAfterEffectNodes.push_back( aNode );
823 return false;
824 }
825
826 return true;
827 }
828
lcl_gethex(int nChar)829 static int lcl_gethex( int nChar )
830 {
831 if( nChar >= '0' && nChar <= '9' )
832 return nChar - '0';
833 else if( nChar >= 'a' && nChar <= 'f' )
834 return nChar - 'a' + 10;
835 else if( nChar >= 'A' && nChar <= 'F' )
836 return nChar - 'A' + 10;
837 else
838 return 0;
839 }
840
convertAnimationValue(MS_AttributeNames eAttribute,Any & rValue)841 bool AnimationImporter::convertAnimationValue( MS_AttributeNames eAttribute, Any& rValue )
842 {
843 bool bRet = false;
844 switch( eAttribute )
845 {
846 case MS_PPT_X:
847 case MS_PPT_Y:
848 case MS_PPT_W:
849 case MS_PPT_H:
850 {
851 OUString aString;
852
853 if( rValue.getValueType() == ::getCppuType((const ValuePair*)0) )
854 {
855 ValuePair aValuePair;
856 if( rValue >>= aValuePair )
857 {
858 if( aValuePair.First >>= aString )
859 {
860 if( convertMeasure( aString ) )
861 {
862 aValuePair.First <<= aString;
863 bRet = true;
864 }
865 }
866
867 if( aValuePair.Second >>= aString )
868 {
869 if( convertMeasure( aString ) )
870 {
871 aValuePair.Second <<= aString;
872 bRet = true;
873 }
874 }
875 }
876 }
877 else if( rValue.getValueType() == ::getCppuType((const OUString*)0) )
878 {
879 if( rValue >>= aString )
880 {
881 bRet = convertMeasure( aString );
882
883 if( bRet )
884 rValue <<= aString;
885 }
886 }
887 }
888 break;
889
890 case MS_XSHEAR:
891 case MS_R:
892 {
893 OUString aString;
894 if( rValue >>= aString )
895 {
896 rValue <<= aString.toDouble();
897 bRet = true;
898 }
899 }
900 break;
901
902 case MS_STYLEROTATION:
903 {
904 if( rValue.getValueType() == ::getCppuType((const OUString*)0) )
905 {
906 OUString aString;
907 rValue >>= aString;
908 rValue <<= (sal_Int16)aString.toDouble();
909 bRet = true;
910 }
911 else if( rValue.getValueType() == ::getCppuType((const double*)0) )
912 {
913 double fValue = 0.0;
914 rValue >>= fValue;
915 rValue <<= (sal_Int16)fValue;
916 bRet = true;
917 }
918 }
919 break;
920
921 case MS_FILLCOLOR:
922 case MS_STROKECOLOR:
923 case MS_STYLECOLOR:
924 case MS_PPT_C:
925 {
926 OUString aString;
927 if( rValue >>= aString )
928 {
929 if( aString.getLength() >= 7 && aString[0] == '#' )
930 {
931 Color aColor;
932 aColor.SetRed( (sal_uInt8)(lcl_gethex( aString[1] ) * 16 + lcl_gethex( aString[2] )) );
933 aColor.SetGreen( (sal_uInt8)(lcl_gethex( aString[3] ) * 16 + lcl_gethex( aString[4] )) );
934 aColor.SetBlue( (sal_uInt8)(lcl_gethex( aString[5] ) * 16 + lcl_gethex( aString[6] )) );
935 rValue <<= (sal_Int32)aColor.GetColor();
936 bRet = true;
937 }
938 else if( aString.matchAsciiL( "rgb(", 4, 0 ) )
939 {
940 aString = aString.copy( 4, aString.getLength() - 5 );
941 Color aColor;
942 sal_Int32 index = 0;
943 aColor.SetRed( (sal_uInt8)aString.getToken( 0, (sal_Unicode)',', index ).toInt32() );
944 aColor.SetGreen( (sal_uInt8)aString.getToken( 0, (sal_Unicode)',', index ).toInt32() );
945 aColor.SetRed( (sal_uInt8)aString.getToken( 0, (sal_Unicode)',', index ).toInt32() );
946 rValue <<= (sal_Int32)aColor.GetColor();
947 bRet = true;
948 }
949 else if( aString.matchAsciiL( "hsl(", 4, 0 ) )
950 {
951 sal_Int32 index = 0;
952 sal_Int32 nA = aString.getToken( 0, (sal_Unicode)',', index ).toInt32();
953 sal_Int32 nB = aString.getToken( 0, (sal_Unicode)',', index ).toInt32();
954 sal_Int32 nC = aString.getToken( 0, (sal_Unicode)',', index ).toInt32();
955 dump( "hsl(%ld", nA );
956 dump( ",%ld", nB );
957 dump( ",%ld)", nC );
958 Sequence< double > aHSL( 3 );
959 aHSL[0] = nA * 360.0/255.0;
960 aHSL[1] = nB / 255.0;
961 aHSL[2] = nC / 255.0;
962 rValue <<= aHSL;
963 bRet = true;
964 }
965 }
966 }
967 break;
968
969 case MS_FILLTYPE:
970 {
971 OUString aString;
972 if( rValue >>= aString )
973 {
974 rValue <<= aString.equalsAscii( "solid" ) ? FillStyle_SOLID : FillStyle_NONE;
975 bRet = true;
976 }
977 }
978 break;
979
980 case MS_STROKEON:
981 {
982 OUString aString;
983 if( rValue >>= aString )
984 {
985 rValue <<= aString.equalsAscii( "true" ) ? ::com::sun::star::drawing::LineStyle_SOLID : ::com::sun::star::drawing::LineStyle_NONE;
986 bRet = true;
987 }
988 }
989 break;
990
991 case MS_FONTWEIGHT:
992 {
993 OUString aString;
994 if( rValue >>= aString )
995 {
996 rValue <<= aString.equalsAscii( "bold" ) ? com::sun::star::awt::FontWeight::BOLD : com::sun::star::awt::FontWeight::NORMAL;
997 bRet = true;
998 }
999 }
1000 break;
1001
1002 case MS_STYLEFONTSTYLE:
1003 {
1004 OUString aString;
1005 if( rValue >>= aString )
1006 {
1007 rValue <<= aString.equalsAscii( "italic" ) ? com::sun::star::awt::FontSlant_ITALIC : com::sun::star::awt::FontSlant_NONE;
1008 bRet = true;
1009 }
1010 }
1011 break;
1012
1013 case MS_STYLEUNDERLINE:
1014 {
1015 OUString aString;
1016 if( rValue >>= aString )
1017 {
1018 rValue <<= aString.equalsAscii( "true" ) ? com::sun::star::awt::FontUnderline::SINGLE : com::sun::star::awt::FontUnderline::NONE;
1019 bRet = true;
1020 }
1021 }
1022 break;
1023
1024 case MS_STYLEOPACITY:
1025 case MS_STYLEFONTSIZE:
1026 {
1027 OUString aString;
1028 if( rValue >>= aString )
1029 {
1030 rValue <<= (float)aString.toDouble();
1031 bRet = true;
1032 }
1033 }
1034 break;
1035
1036 case MS_STYLEVISIBILITY:
1037 {
1038 OUString aString;
1039 if( rValue >>= aString )
1040 {
1041 rValue <<= aString.equalsAscii( "visible" ) ? sal_True : sal_False;
1042 bRet = true;
1043 }
1044 }
1045 break;
1046 default:
1047 break;
1048 }
1049
1050 return bRet;
1051 }
1052
1053 // --------------------------------------------------------------------
1054
getConvertedSubType(sal_Int16 nPresetClass,sal_Int32 nPresetId,sal_Int32 nPresetSubType)1055 static OUString getConvertedSubType( sal_Int16 nPresetClass, sal_Int32 nPresetId, sal_Int32 nPresetSubType )
1056 {
1057 const sal_Char* pStr = 0;
1058
1059 if( (nPresetClass == EffectPresetClass::ENTRANCE) || (nPresetClass == EffectPresetClass::EXIT) )
1060 {
1061 // skip wheel effect
1062 if( nPresetId != 21 )
1063 {
1064 if( nPresetId == 5 )
1065 {
1066 // checkerboard
1067 switch( nPresetSubType )
1068 {
1069 case 5: pStr = "downward"; break;
1070 case 10: pStr = "across"; break;
1071 }
1072 }
1073 else if( nPresetId == 17 )
1074 {
1075 // stretch
1076 if( nPresetSubType == 10 )
1077 pStr = "across";
1078 }
1079 else if( nPresetId == 18 )
1080 {
1081 // strips
1082 switch( nPresetSubType )
1083 {
1084 case 3: pStr = "right-to-top"; break;
1085 case 6: pStr = "right-to-bottom"; break;
1086 case 9: pStr = "left-to-top"; break;
1087 case 12: pStr = "left-to-bottom"; break;
1088 }
1089 }
1090
1091 if( pStr == 0 )
1092 {
1093 const convert_subtype* p = gConvertArray;
1094
1095 while( p->mpStrSubType )
1096 {
1097 if( p->mnID == nPresetSubType )
1098 {
1099 pStr = p->mpStrSubType;
1100 break;
1101 }
1102 p++;
1103 }
1104 }
1105 }
1106 }
1107
1108 if( pStr )
1109 return OUString::createFromAscii( pStr );
1110 else
1111 return OUString::valueOf( nPresetSubType );
1112 }
1113
1114 // --------------------------------------------------------------------
1115
fillNode(Reference<XAnimationNode> & xNode,const AnimationNode & rNode,const PropertySet & rSet)1116 void AnimationImporter::fillNode( Reference< XAnimationNode >& xNode, const AnimationNode& rNode, const PropertySet& rSet )
1117 {
1118 sal_Bool bAfterEffect = false;
1119
1120 // attribute Restart
1121 if( rNode.mnRestart )
1122 {
1123 sal_Int16 nRestart = AnimationRestart::DEFAULT;
1124 switch( rNode.mnRestart )
1125 {
1126 case 1: nRestart = AnimationRestart::ALWAYS; break;
1127 case 2: nRestart = AnimationRestart::WHEN_NOT_ACTIVE; break;
1128 case 3: nRestart = AnimationRestart::NEVER; break;
1129 }
1130 xNode->setRestart( nRestart );
1131 }
1132
1133 // attribute Fill
1134 if( rNode.mnFill )
1135 {
1136 sal_Int16 nFill = AnimationFill::DEFAULT;
1137 switch( rNode.mnFill )
1138 {
1139 case 1: nFill = AnimationFill::REMOVE; break;
1140 case 2: nFill = AnimationFill::FREEZE; break;
1141 case 3: nFill = AnimationFill::HOLD; break;
1142 case 4: nFill = AnimationFill::TRANSITION; break;
1143 }
1144 xNode->setFill( nFill );
1145 }
1146
1147 // attribute Duration
1148 if( rNode.mnDuration )
1149 {
1150 Any aDuration;
1151 if( rNode.mnDuration > 0 )
1152 {
1153 aDuration <<= (double)(rNode.mnDuration / 1000.0);
1154 }
1155 else if( rNode.mnDuration < 0 )
1156 {
1157 aDuration <<= Timing_INDEFINITE;
1158 }
1159 xNode->setDuration( aDuration );
1160 }
1161
1162 // TODO: DFF_ANIM_PATH_EDIT_MODE
1163 if( rSet.hasProperty( DFF_ANIM_PATH_EDIT_MODE ) )
1164 {
1165 sal_Int32 nPathEditMode ;
1166 if( rSet.getProperty( DFF_ANIM_PATH_EDIT_MODE ) >>= nPathEditMode )
1167 {
1168 }
1169 }
1170
1171 // set user data
1172 Sequence< NamedValue > aUserData;
1173
1174 // attribute Type
1175 if( rSet.hasProperty( DFF_ANIM_NODE_TYPE ) )
1176 {
1177 sal_Int32 nPPTNodeType = 0;
1178 if( rSet.getProperty( DFF_ANIM_NODE_TYPE ) >>= nPPTNodeType )
1179 {
1180 sal_Int16 nNodeType = ::com::sun::star::presentation::EffectNodeType::DEFAULT;
1181 switch( nPPTNodeType )
1182 {
1183 case DFF_ANIM_NODE_TYPE_ON_CLICK: nNodeType = ::com::sun::star::presentation::EffectNodeType::ON_CLICK; break;
1184 case DFF_ANIM_NODE_TYPE_WITH_PREVIOUS: nNodeType = ::com::sun::star::presentation::EffectNodeType::WITH_PREVIOUS; break;
1185 case DFF_ANIM_NODE_TYPE_AFTER_PREVIOUS: nNodeType = ::com::sun::star::presentation::EffectNodeType::AFTER_PREVIOUS; break;
1186 case DFF_ANIM_NODE_TYPE_MAIN_SEQUENCE: nNodeType = ::com::sun::star::presentation::EffectNodeType::MAIN_SEQUENCE; break;
1187 case DFF_ANIM_NODE_TYPE_TIMING_ROOT: nNodeType = ::com::sun::star::presentation::EffectNodeType::TIMING_ROOT; break;
1188 case DFF_ANIM_NODE_TYPE_INTERACTIVE_SEQ:nNodeType = ::com::sun::star::presentation::EffectNodeType::INTERACTIVE_SEQUENCE; break;
1189 }
1190
1191 sal_Int32 nSize = aUserData.getLength();
1192 aUserData.realloc(nSize+1);
1193 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
1194 aUserData[nSize].Value <<= nNodeType;
1195 }
1196 }
1197
1198 if( rSet.hasProperty( DFF_ANIM_GROUP_ID ) )
1199 {
1200 sal_Int32 nGroupId;
1201 if( rSet.getProperty( DFF_ANIM_GROUP_ID ) >>= nGroupId )
1202 {
1203 sal_Int32 nSize = aUserData.getLength();
1204 aUserData.realloc(nSize+1);
1205 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "group-id" ) );
1206 aUserData[nSize].Value <<= nGroupId;
1207 }
1208 }
1209
1210 sal_Int16 nEffectPresetClass = EffectPresetClass::CUSTOM;
1211 sal_Int32 nPresetId = 0;
1212
1213 if( rSet.hasProperty( DFF_ANIM_PRESET_CLASS ) )
1214 {
1215 sal_Int32 nPresetClass = 0;
1216 if ( rSet.getProperty( DFF_ANIM_PRESET_CLASS ) >>= nPresetClass )
1217 {
1218 switch( nPresetClass )
1219 {
1220 case DFF_ANIM_PRESS_CLASS_ENTRANCE: nEffectPresetClass = EffectPresetClass::ENTRANCE; break;
1221 case DFF_ANIM_PRESS_CLASS_EXIT: nEffectPresetClass = EffectPresetClass::EXIT; break;
1222 case DFF_ANIM_PRESS_CLASS_EMPHASIS: nEffectPresetClass = EffectPresetClass::EMPHASIS; break;
1223 case DFF_ANIM_PRESS_CLASS_MOTIONPATH: nEffectPresetClass = EffectPresetClass::MOTIONPATH; break;
1224 case DFF_ANIM_PRESS_CLASS_OLE_ACTION: nEffectPresetClass = EffectPresetClass::OLEACTION; break;
1225 case DFF_ANIM_PRESS_CLASS_MEDIACALL: nEffectPresetClass = EffectPresetClass::MEDIACALL; break;
1226 }
1227 sal_Int32 nSize = aUserData.getLength();
1228 aUserData.realloc(nSize+1);
1229 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "preset-class" ) );
1230 aUserData[nSize].Value <<= nEffectPresetClass;
1231 }
1232 }
1233
1234 if( rSet.hasProperty( DFF_ANIM_PRESET_ID ) )
1235 {
1236 if( rSet.getProperty( DFF_ANIM_PRESET_ID ) >>= nPresetId )
1237 {
1238 sal_Int32 nSize = aUserData.getLength();
1239 aUserData.realloc(nSize+1);
1240 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "preset-id" ) );
1241
1242 const preset_maping* p = gPresetMaping;
1243 while( p->mpStrPresetId && ((p->mnPresetClass != nEffectPresetClass) || (p->mnPresetId != nPresetId )) )
1244 p++;
1245
1246 if( p->mpStrPresetId )
1247 {
1248 aUserData[nSize].Value <<= OUString::createFromAscii( p->mpStrPresetId );
1249 }
1250 else
1251 {
1252 OUStringBuffer sBuffer;
1253 sBuffer.appendAscii( "ppt_" );
1254 switch( nEffectPresetClass )
1255 {
1256 case EffectPresetClass::ENTRANCE: sBuffer.appendAscii( "entrance_" ); break;
1257 case EffectPresetClass::EXIT: sBuffer.appendAscii( "exit_" ); break;
1258 case EffectPresetClass::EMPHASIS: sBuffer.appendAscii( "emphasis_" ); break;
1259 case EffectPresetClass::MOTIONPATH: sBuffer.appendAscii( "motionpath_" ); break;
1260 case EffectPresetClass::OLEACTION: sBuffer.appendAscii( "oleaction_" ); break;
1261 case EffectPresetClass::MEDIACALL: sBuffer.appendAscii( "mediacall_" ); break;
1262 }
1263 sBuffer.append( nPresetId );
1264
1265 aUserData[nSize].Value <<= sBuffer.makeStringAndClear();
1266 }
1267 }
1268 }
1269
1270 if( rSet.hasProperty( DFF_ANIM_PRESET_SUB_TYPE ) )
1271 {
1272 sal_Int32 nPresetSubType = 0;
1273 if( (rSet.getProperty( DFF_ANIM_PRESET_SUB_TYPE ) >>= nPresetSubType) )
1274 {
1275 if( nPresetSubType )
1276 {
1277 sal_Int32 nSize = aUserData.getLength();
1278 aUserData.realloc(nSize+1);
1279 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "preset-sub-type" ) );
1280 aUserData[nSize].Value <<= getConvertedSubType( nEffectPresetClass, nPresetId, nPresetSubType );
1281 }
1282 }
1283 }
1284
1285 if( rSet.hasProperty( DFF_ANIM_AFTEREFFECT ) )
1286 {
1287 if( rSet.getProperty( DFF_ANIM_AFTEREFFECT ) >>= bAfterEffect )
1288 {
1289 sal_Int32 nSize = aUserData.getLength();
1290 aUserData.realloc(nSize+1);
1291 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "after-effect" ) );
1292 aUserData[nSize].Value <<= bAfterEffect;
1293 }
1294 }
1295
1296 if( bAfterEffect && rSet.hasProperty( DFF_ANIM_MASTERREL ) )
1297 {
1298 sal_Int32 nMasterRel = 2;
1299 if( rSet.getProperty( DFF_ANIM_MASTERREL ) >>= nMasterRel )
1300 {
1301 sal_Int32 nSize = aUserData.getLength();
1302 aUserData.realloc(nSize+1);
1303 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "master-rel" ) );
1304 aUserData[nSize].Value <<= nMasterRel;
1305 }
1306 }
1307
1308 xNode->setUserData( aUserData );
1309
1310 // TODO: DFF_ANIM_ID
1311 if( rSet.hasProperty( DFF_ANIM_ID ) )
1312 {
1313 rtl::OUString aString;
1314 rSet.getProperty( DFF_ANIM_ID ) >>= aString;
1315 if( aString.getLength() )
1316 {
1317 }
1318 }
1319
1320 // TODO: DFF_ANIM_EVENT_FILTER
1321 if( rSet.hasProperty( DFF_ANIM_EVENT_FILTER ) )
1322 {
1323 rtl::OUString aString;
1324 rSet.getProperty( DFF_ANIM_EVENT_FILTER ) >>= aString;
1325 if( aString.getLength() )
1326 {
1327 }
1328 }
1329
1330 // DFF_ANIM_TIMEFILTER
1331 if( rSet.hasProperty( DFF_ANIM_TIMEFILTER ) )
1332 {
1333 Reference< XAnimate > xAnim( xNode, UNO_QUERY );
1334 if( xAnim.is() )
1335 {
1336 rtl::OUString aString;
1337 rSet.getProperty( DFF_ANIM_TIMEFILTER ) >>= aString;
1338 if( aString.getLength() )
1339 {
1340 sal_Int32 nElements = 1; // a non empty string has at least one value
1341
1342 sal_Int32 fromIndex = 0;
1343 while(true)
1344 {
1345 fromIndex = aString.indexOf( (sal_Unicode)';', fromIndex );
1346 if( fromIndex == -1 )
1347 break;
1348
1349 fromIndex++;
1350 nElements++;
1351 }
1352
1353 Sequence< TimeFilterPair > aTimeFilter( nElements );
1354
1355 TimeFilterPair* pValues = aTimeFilter.getArray();
1356 sal_Int32 nIndex = 0;
1357 while( (nElements--) && (nIndex >= 0) )
1358 {
1359 const OUString aToken( aString.getToken( 0, ';', nIndex ) );
1360
1361 sal_Int32 nPos = aToken.indexOf( ',' );
1362 if( nPos >= 0 )
1363 {
1364 pValues->Time = aToken.copy( 0, nPos ).toDouble();
1365 pValues->Progress = aToken.copy( nPos+1, aToken.getLength() - nPos - 1 ).toDouble();
1366 }
1367 pValues++;
1368 }
1369
1370 xAnim->setTimeFilter( aTimeFilter );
1371 }
1372 }
1373 }
1374
1375 /* todo
1376 Reference< XAudio > xAudio( xNode, UNO_QUERY );
1377 if( xAudio.is() )
1378 {
1379 if( rSet.hasProperty( DFF_ANIM_ENDAFTERSLIDE ) )
1380 {
1381 sal_Int16 nEndAfterSlide = 0;
1382 if( rSet.getProperty( DFF_ANIM_ENDAFTERSLIDE ) >>= nEndAfterSlide )
1383 xAudio->setEndAfterSlide( nEndAfterSlide );
1384 }
1385
1386 if( rSet.hasProperty( DFF_ANIM_VOLUME ) )
1387 {
1388 double fVolume = 1.0;
1389 rSet.getProperty( DFF_ANIM_VOLUME ) >>= fVolume;
1390 xAudio->setVolume( fVolume );
1391 }
1392 }
1393 */
1394 Reference< XAnimateColor > xColor( xNode, UNO_QUERY );
1395 if( xColor.is() )
1396 {
1397 if( rSet.hasProperty( DFF_ANIM_DIRECTION ) )
1398 {
1399 sal_Bool bDirection = sal_False;
1400 if( rSet.getProperty( DFF_ANIM_DIRECTION ) >>= bDirection )
1401 xColor->setDirection( (sal_Bool)!bDirection );
1402 }
1403
1404 if( rSet.hasProperty( DFF_ANIM_COLORSPACE ) )
1405 {
1406 sal_Int32 nColorSpace = 0;
1407 rSet.getProperty( DFF_ANIM_COLORSPACE ) >>= nColorSpace;
1408 xColor->setColorInterpolation( (nColorSpace == 0) ? AnimationColorSpace::RGB : AnimationColorSpace::HSL );
1409 }
1410 }
1411 }
1412
1413 // --------------------------------------------------------------------
1414
importTimeContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1415 void AnimationImporter::importTimeContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1416 {
1417 DBG_ASSERT( pAtom && xNode.is(), "invalid call to ppt::AnimationImporter::importTimeContainer()!");
1418 if( pAtom && xNode.is() )
1419 {
1420 importAnimationEvents( pAtom, xNode );
1421 importAnimationValues( pAtom, xNode );
1422 importAnimationActions( pAtom, xNode );
1423
1424 dump(">\n");
1425
1426 // import sub containers
1427 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1428
1429 while( pChildAtom )
1430 {
1431 switch( pChildAtom->getType() )
1432 {
1433 case DFF_msofbtAnimNode:
1434 case DFF_msofbtAnimEvent:
1435 case DFF_msofbtAnimValue:
1436 case DFF_msofbtAnimAction:
1437 case DFF_msofbtAnimPropertySet:
1438 break;
1439
1440 case DFF_msofbtAnimSubGoup :
1441 {
1442 if( pChildAtom->hasChildAtom( DFF_msofbtAnimCommand ) )
1443 {
1444 const OUString aServiceName( OUString::createFromAscii("com.sun.star.animations.Command") );
1445 Reference< XAnimationNode > xChildNode( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName), UNO_QUERY );
1446 importAnimationNodeContainer( pChildAtom, xChildNode );
1447 Reference< XTimeContainer > xParentContainer( xNode, UNO_QUERY );
1448 if( xParentContainer.is() && xChildNode.is() )
1449 xParentContainer->appendChild( xChildNode );
1450 }
1451 else
1452 {
1453 importAnimationContainer( pChildAtom, xNode );
1454 }
1455 }
1456 break;
1457 case DFF_msofbtAnimGroup :
1458 {
1459 importAnimationContainer( pChildAtom, xNode );
1460 }
1461 break;
1462 case DFF_msofbtAnimIteration:
1463 {
1464 if( pChildAtom->seekToContent() )
1465 {
1466 float fInterval;
1467 sal_Int32 nTextUnitEffect, nU1, nU2, nU3;
1468
1469 mrStCtrl >> fInterval >> nTextUnitEffect >> nU1 >> nU2 >> nU3;
1470
1471 Reference< XIterateContainer > xIter( xNode, UNO_QUERY );
1472 if( xIter.is() )
1473 {
1474 sal_Int16 nIterateType = TextAnimationType::BY_PARAGRAPH;
1475 switch( nTextUnitEffect )
1476 {
1477 case 1: nIterateType = TextAnimationType::BY_WORD; break;
1478 case 2: nIterateType = TextAnimationType::BY_LETTER; break;
1479 }
1480 xIter->setIterateType( nIterateType );
1481 xIter->setIterateInterval( (double)fInterval );
1482 }
1483
1484 dump( "<iterate" );
1485 dump( " iterateType=\"%s\"", (nTextUnitEffect == 0) ? "byElement" : (nTextUnitEffect == 1) ? "byWord" : "byLetter" );
1486 dump( " iterateInterval=\"%g\"", fInterval );
1487 dump( " u1=\"%ld\"", nU1 );
1488 dump( " u2=\"%ld\"", nU2 );
1489 dump( " u3=\"%ld\"/>\n", nU3 );
1490 }
1491 }
1492 break;
1493
1494 case 0xf136:
1495 {
1496 #ifdef DBG_ANIM_LOG
1497 sal_uInt32 nU1, nU2;
1498 mrStCtrl >> nU1 >> nU2;
1499
1500 fprintf( mpFile, "<unknown_0xf136 nU1=\"%ld\" nU2=\"%ld\"/>\n", nU1, nU2 );
1501 #endif
1502 }
1503 break;
1504
1505 default:
1506 {
1507 dump_atom_header( pChildAtom, true, false );
1508 dump_atom( pChildAtom );
1509 dump_atom_header( pChildAtom, false, false );
1510 }
1511 break;
1512 }
1513
1514 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
1515 }
1516 }
1517 }
1518
1519 // --------------------------------------------------------------------
1520
importAnimationNodeContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1521 void AnimationImporter::importAnimationNodeContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1522 {
1523 DBG_ASSERT( pAtom && xNode.is(), "invalid call to ppt::AnimationImporter::importAnimationNodeContainer()!");
1524 if( pAtom && xNode.is() )
1525 {
1526 importAnimationEvents( pAtom, xNode );
1527 importAnimationValues( pAtom, xNode );
1528 importAnimationActions( pAtom, xNode );
1529
1530 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1531
1532 while( pChildAtom )
1533 {
1534 switch( pChildAtom->getType() )
1535 {
1536 case DFF_msofbtAnimNode:
1537 case DFF_msofbtAnimEvent:
1538 case DFF_msofbtAnimValue:
1539 case DFF_msofbtAnimAction:
1540 case DFF_msofbtAnimPropertySet:
1541 break;
1542
1543 case DFF_msofbtAnimateFilter:
1544 importAnimateFilterContainer( pChildAtom, xNode );
1545 break;
1546
1547 case DFF_msofbtAnimateSet:
1548 importAnimateSetContainer( pChildAtom, xNode );
1549 break;
1550
1551 case DFF_msofbtAnimate:
1552 importAnimateContainer( pChildAtom, xNode );
1553 break;
1554
1555 case DFF_msofbtAnimateScale:
1556 importAnimateScaleContainer( pChildAtom, xNode );
1557 break;
1558
1559 case DFF_msofbtAnimateColor:
1560 importAnimateColorContainer( pChildAtom, xNode );
1561 break;
1562
1563 case DFF_msofbtAnimateRotation:
1564 importAnimateRotationContainer( pChildAtom, xNode );
1565 break;
1566
1567 case DFF_msofbtAnimateMotion:
1568 importAnimateMotionContainer( pChildAtom, xNode );
1569 break;
1570
1571 case DFF_msofbtAnimCommand:
1572 importCommandContainer( pChildAtom, xNode );
1573 break;
1574
1575 default:
1576 {
1577 dump_atom_header( pChildAtom, true, false );
1578 dump_atom( pChildAtom );
1579 dump_atom_header( pChildAtom, false, false );
1580 }
1581 break;
1582 }
1583
1584 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
1585 }
1586 }
1587 }
1588
1589 // --------------------------------------------------------------------
1590
importAnimateFilterContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1591 void AnimationImporter::importAnimateFilterContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1592 {
1593 Reference< XTransitionFilter > xFilter( xNode, UNO_QUERY );
1594
1595 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateFilter && xFilter.is(), "invalid call to ppt::AnimationImporter::importAnimateFilterContainer()!");
1596 if( pAtom && xFilter.is() )
1597 {
1598 sal_uInt32 nBits = 0;
1599
1600 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1601
1602 while( pChildAtom )
1603 {
1604 if( !pChildAtom->isContainer() )
1605 {
1606 if( !pChildAtom->seekToContent() )
1607 break;
1608 }
1609
1610 switch( pChildAtom->getType() )
1611 {
1612 case DFF_msofbtAnimateFilterData:
1613 {
1614 sal_uInt32 transition;
1615 mrStCtrl >> nBits;
1616 mrStCtrl >> transition;
1617
1618 if( nBits & 1 )
1619 xFilter->setMode( transition == 0 );
1620
1621 dump( " transition=\"%s\"", (transition == 0) ? "in" : "out" );
1622 }
1623 break;
1624
1625 case DFF_msofbtAnimAttributeValue:
1626 {
1627 if( (nBits & 2 ) && ( pChildAtom->getInstance() == 1 ) )
1628 {
1629 Any aAny;
1630 if ( importAttributeValue( pChildAtom, aAny ) )
1631 {
1632 rtl::OUString filter;
1633 aAny >>= filter;
1634
1635 dump( " filter=\"%s\"", filter );
1636
1637 const transition* pTransition = transition::find( filter );
1638 if( pTransition )
1639 {
1640 xFilter->setTransition( pTransition->mnType );
1641 xFilter->setSubtype( pTransition->mnSubType );
1642 xFilter->setDirection( pTransition->mbDirection );
1643 }
1644 else
1645 {
1646 DBG_ERROR( "unknown transition!" );
1647 }
1648 }
1649 }
1650 }
1651 break;
1652
1653 case DFF_msofbtAnimateTarget:
1654 importAnimateAttributeTargetContainer( pChildAtom, xNode );
1655 break;
1656
1657 default:
1658 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
1659 break;
1660
1661 }
1662
1663 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
1664 }
1665 }
1666 }
1667
1668 // --------------------------------------------------------------------
1669
importAnimateAttributeTargetContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1670 void AnimationImporter::importAnimateAttributeTargetContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1671 {
1672 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateTarget, "invalid call to ppt::AnimationImporter::importAnimateAttributeTargetContainer()!");
1673
1674 Any aTarget;
1675
1676 Reference< XAnimate > xAnimate( xNode, UNO_QUERY );
1677
1678 bool bWrongContext = false;
1679
1680 if( pAtom )
1681 {
1682 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1683
1684 while( pChildAtom )
1685 {
1686 if( !pChildAtom->isContainer() )
1687 {
1688 if( !pChildAtom->seekToContent() )
1689 break;
1690 }
1691
1692 switch( pChildAtom->getType() )
1693 {
1694 case DFF_msofbtAnimPropertySet:
1695 {
1696 PropertySet aSet;
1697 importPropertySetContainer( pChildAtom, aSet );
1698 if( aSet.hasProperty( DFF_ANIM_RUNTIMECONTEXT ) )
1699 {
1700 OUString aContext;
1701 if( aSet.getProperty( DFF_ANIM_RUNTIMECONTEXT ) >>= aContext )
1702 {
1703 if( !aContext.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("PPT") ) )
1704 bWrongContext = true;
1705 }
1706 }
1707
1708 dump( aSet );
1709 }
1710 break;
1711
1712 case DFF_msofbtAnimateTargetSettings:
1713 {
1714 if( xAnimate.is() )
1715 {
1716 sal_uInt32 nBits;
1717 sal_uInt32 nAdditive;
1718 sal_uInt32 nAccumulate;
1719 sal_uInt32 nTransformType;
1720
1721 mrStCtrl >> nBits >> nAdditive >> nAccumulate >> nTransformType;
1722
1723 // nBits %0001: additive, %0010: accumulate, %0100: attributeName, %1000: transformtype
1724 // nAdditive 0 = base, 1 = sum, 2 = replace, 3 = multiply, 4 = none
1725 // nAccumulate 0 = none, 1 = always
1726 // nTransformType 0: "property" else "image"
1727
1728 if( nBits & 3 )
1729 {
1730 if( xAnimate.is() )
1731 {
1732 if( nBits & 1 )
1733 {
1734 sal_Int16 nTemp = AnimationAdditiveMode::BASE;
1735 switch( nAdditive )
1736 {
1737 case 1: nTemp = AnimationAdditiveMode::SUM; break;
1738 case 2: nTemp = AnimationAdditiveMode::REPLACE; break;
1739 case 3: nTemp = AnimationAdditiveMode::MULTIPLY; break;
1740 case 4: nTemp = AnimationAdditiveMode::NONE; break;
1741 }
1742 xAnimate->setAdditive( nTemp );
1743 }
1744
1745 if( nBits & 2 )
1746 {
1747 xAnimate->setAccumulate( (nAccumulate == 0) ? sal_True : sal_False );
1748 }
1749 }
1750 }
1751 #ifdef DBG_ANIM_LOG
1752 if( nBits & 1 )
1753 fprintf( mpFile, " additive=\"%s\"", (nAdditive == 0) ? "base" : (nAdditive == 2) ? "replace" : (nAdditive == 1) ? "sum" : (nAdditive == 3 ) ? "multiply" : (nAdditive == 4) ? "none" : "unknown" );
1754
1755 if( nBits & 2 )
1756 fprintf( mpFile, " accumulate=\"%s\"", (nAccumulate == 0) ? "none" : "always" );
1757
1758 if( nBits & 8 )
1759 fprintf( mpFile, " transformType=\"%s\"", (nTransformType == 0) ? "property" : "image" );
1760 #endif
1761 }
1762 }
1763 break;
1764
1765 case DFF_msofbtAnimateAttributeNames:
1766 {
1767 if( xAnimate.is() )
1768 {
1769 OUString aAttributeName;
1770 importAttributeNamesContainer( pChildAtom, aAttributeName );
1771 if( xAnimate.is() )
1772 xAnimate->setAttributeName( aAttributeName );
1773 dump( " attributeName=\"%s\"", aAttributeName );
1774 }
1775 }
1776 break;
1777
1778 case DFF_msofbtAnimateTargetElement:
1779 {
1780 sal_Int16 nSubType;
1781 importTargetElementContainer( pChildAtom, aTarget, nSubType );
1782 if( xAnimate.is() )
1783 xAnimate->setSubItem( nSubType );
1784
1785 dump( " target=\"" );
1786 dump_target( aTarget );
1787 dump( "\"" );
1788 }
1789 break;
1790
1791 default:
1792 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
1793 break;
1794 }
1795
1796 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
1797 }
1798 }
1799
1800 if( bWrongContext )
1801 aTarget.clear();
1802
1803 if( xAnimate.is() )
1804 xAnimate->setTarget( aTarget );
1805 else
1806 {
1807 Reference< XCommand > xCommand( xNode, UNO_QUERY );
1808 if( xCommand.is() )
1809 xCommand->setTarget( aTarget );
1810 }
1811 }
1812
1813 // --------------------------------------------------------------------
1814
implGetColorSpace(sal_Int32 nMode,sal_Int32,sal_Int32,sal_Int32)1815 sal_Int16 AnimationImporter::implGetColorSpace( sal_Int32 nMode, sal_Int32 /*nA*/, sal_Int32 /*nB*/, sal_Int32 /*nC*/ )
1816 {
1817 switch( nMode )
1818 {
1819 case 2: // index
1820 // FALLTHROUGH intended
1821 default:
1822 // FALLTHROUGH intended
1823 case 0: // rgb
1824 return AnimationColorSpace::RGB;
1825
1826 case 1: // hsl
1827 return AnimationColorSpace::HSL;
1828 }
1829 }
1830
1831 // --------------------------------------------------------------------
1832
implGetColorAny(sal_Int32 nMode,sal_Int32 nA,sal_Int32 nB,sal_Int32 nC)1833 Any AnimationImporter::implGetColorAny( sal_Int32 nMode, sal_Int32 nA, sal_Int32 nB, sal_Int32 nC )
1834 {
1835 switch( nMode )
1836 {
1837 case 0: // rgb
1838 {
1839 dump( "rgb(%ld", nA );
1840 dump( ",%ld", nB );
1841 dump( ",%ld)", nC );
1842 Color aColor( (sal_uInt8)nA, (sal_uInt8)nB, (sal_uInt8)nC );
1843 return makeAny( (sal_Int32)aColor.GetRGBColor() );
1844 }
1845 case 1: // hsl
1846 {
1847 dump( "hsl(%ld", nA );
1848 dump( ",%ld", nB );
1849 dump( ",%ld)", nC );
1850 Sequence< double > aHSL( 3 );
1851 aHSL[0] = nA * 360.0/255.0;
1852 aHSL[1] = nB / 255.0;
1853 aHSL[2] = nC / 255.0;
1854 return makeAny( aHSL );
1855 }
1856
1857 case 2: // index
1858 {
1859 Color aColor;
1860 mpPPTImport->GetColorFromPalette((sal_uInt16)nA, aColor );
1861 dump( "index(%ld", nA );
1862 dump( " [%ld", (sal_Int32)aColor.GetRed() );
1863 dump( ",%ld", (sal_Int32)aColor.GetGreen() );
1864 dump( ",%ld])", (sal_Int32)aColor.GetBlue() );
1865 return makeAny( (sal_Int32)aColor.GetRGBColor() );
1866 }
1867
1868 default:
1869 {
1870 dump( "unknown_%ld(", nMode );
1871 dump( "%ld", nA );
1872 dump( ",%ld", nB );
1873 dump( ",%ld)", nC );
1874 DBG_ERROR( "ppt::implGetColorAny(), unhandled color type" );
1875
1876 Any aAny;
1877 return aAny;
1878 }
1879 }
1880 }
1881
importAnimateColorContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1882 void AnimationImporter::importAnimateColorContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1883 {
1884 Reference< XAnimateColor > xColor( xNode, UNO_QUERY );
1885
1886 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateColor && xColor.is(), "invalid call to ppt::AnimationImporter::importAnimateColorContainer()!");
1887 if( pAtom && xColor.is() )
1888 {
1889 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1890
1891 while( pChildAtom )
1892 {
1893 if( !pChildAtom->isContainer() )
1894 {
1895 if( !pChildAtom->seekToContent() )
1896 break;
1897 }
1898
1899 switch( pChildAtom->getType() )
1900 {
1901 case DFF_msofbtAnimateColorData:
1902 {
1903 sal_uInt32 nBits;
1904 sal_Int32 nByMode, nByA, nByB, nByC;
1905 sal_Int32 nFromMode, nFromA, nFromB, nFromC;
1906 sal_Int32 nToMode, nToA, nToB, nToC;
1907 mrStCtrl >> nBits;
1908 mrStCtrl >> nByMode >> nByA >> nByB >> nByC;
1909 mrStCtrl >> nFromMode >> nFromA >> nFromB >> nFromC;
1910 mrStCtrl >> nToMode >> nToA >> nToB >> nToC;
1911
1912 if( nBits & 1 )
1913 {
1914 dump( " by=\"" );
1915 xColor->setBy( implGetColorAny( nByMode, nByA, nByB, nByC ) );
1916 xColor->setColorInterpolation( implGetColorSpace( nByMode, nByA, nByB, nByC ) );
1917 dump( "\"");
1918 }
1919
1920 if( nBits & 2 )
1921 {
1922 dump( " from=\"" );
1923 xColor->setFrom( implGetColorAny( nFromMode, nFromA, nFromB, nFromC ) );
1924 xColor->setColorInterpolation( implGetColorSpace( nFromMode, nFromA, nFromB, nFromC ) );
1925 dump( "\"");
1926 }
1927
1928 if( nBits & 4 )
1929 {
1930 dump( " to=\"" );
1931 xColor->setTo( implGetColorAny( nToMode, nToA, nToB, nToC ) );
1932 xColor->setColorInterpolation( implGetColorSpace( nToMode, nToA, nToB, nToC ) );
1933 dump( "\"");
1934 }
1935 }
1936 break;
1937
1938 case DFF_msofbtAnimateTarget:
1939 importAnimateAttributeTargetContainer( pChildAtom, xNode );
1940 break;
1941
1942 default:
1943 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
1944 break;
1945 }
1946
1947 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
1948 }
1949 }
1950 }
1951
1952 // --------------------------------------------------------------------
1953
importAnimateSetContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)1954 void AnimationImporter::importAnimateSetContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
1955 {
1956 Reference< XAnimateSet > xSet( xNode, UNO_QUERY );
1957
1958 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateSet && xSet.is(), "invalid call to ppt::AnimationImporter::importAnimateSetContainer()!");
1959 if( pAtom && xSet.is() )
1960 {
1961 const Atom* pChildAtom = pAtom->findFirstChildAtom();
1962
1963 while( pChildAtom )
1964 {
1965 if( !pChildAtom->isContainer() )
1966 {
1967 if( !pChildAtom->seekToContent() )
1968 break;
1969 }
1970
1971 switch( pChildAtom->getType() )
1972 {
1973 case DFF_msofbtAnimateSetData:
1974 {
1975 sal_Int32 nU1, nU2;
1976 mrStCtrl >> nU1 >> nU2;
1977
1978 dump( " set_1=\"%ld\"", nU1 ),
1979 dump( " set_2=\"%ld\"", nU2 );
1980 }
1981 break;
1982
1983 case DFF_msofbtAnimAttributeValue:
1984 {
1985 Any aTo;
1986 if ( importAttributeValue( pChildAtom, aTo ) )
1987 {
1988 xSet->setTo( aTo );
1989
1990 dump( " value=\"" );
1991 dump( aTo );
1992 dump( "\"" );
1993 }
1994 }
1995 break;
1996
1997 case DFF_msofbtAnimateTarget:
1998 importAnimateAttributeTargetContainer( pChildAtom, xNode );
1999 break;
2000
2001 default:
2002 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2003 break;
2004 }
2005
2006 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2007 }
2008 }
2009 }
2010
2011 // --------------------------------------------------------------------
2012
importAnimateContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2013 void AnimationImporter::importAnimateContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2014 {
2015 Reference< XAnimate > xAnim( xNode, UNO_QUERY );
2016
2017 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimate && xAnim.is(), "invalid call to ppt::AnimationImporter::importAnimateContainer()!");
2018 if( pAtom && xAnim.is() )
2019 {
2020 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2021
2022 while( pChildAtom )
2023 {
2024 if( !pChildAtom->isContainer() )
2025 {
2026 if( !pChildAtom->seekToContent() )
2027 break;
2028 }
2029
2030 switch( pChildAtom->getType() )
2031 {
2032 case DFF_msofbtAnimateData:
2033 {
2034 sal_uInt32 nCalcmode, nBits, nValueType;
2035 mrStCtrl >> nCalcmode >> nBits >> nValueType;
2036
2037 if( nBits & 0x08 )
2038 {
2039 sal_Int16 n = (nCalcmode == 1) ? AnimationCalcMode::LINEAR : /* (nCalcmode == 2) ? AnimationCalcMode::FORMULA : */ AnimationCalcMode::DISCRETE;
2040 xAnim->setCalcMode( n );
2041 dump( " calcmode=\"%s\"", (nCalcmode == 0) ? "discrete" : (nCalcmode == 1) ? "linear" : (nCalcmode == 2) ? "formula" : "unknown" );
2042 }
2043
2044 if( nBits & 0x30 )
2045 {
2046 sal_Int16 n = (nValueType == 1) ? AnimationValueType::NUMBER : (nValueType == 2 ) ? AnimationValueType::COLOR : AnimationValueType::STRING;
2047 xAnim->setValueType( n );
2048 dump( " valueType=\"%s\"", (nValueType == 0) ? "string" : (nValueType == 1) ? "number" : (nValueType == 2) ? "color" : "unknown" );
2049 }
2050 }
2051 break;
2052
2053 case DFF_msofbtAnimateTarget:
2054 importAnimateAttributeTargetContainer( pChildAtom, xNode );
2055 break;
2056
2057 case DFF_msofbtAnimKeyPoints:
2058 importAnimateKeyPoints( pChildAtom, xNode );
2059 break;
2060
2061 case DFF_msofbtAnimAttributeValue:
2062 {
2063 Any a;
2064 if ( importAttributeValue( pChildAtom, a ) )
2065 {
2066 switch( pChildAtom->getInstance() )
2067 {
2068 case 1: xAnim->setBy( a ); dump( " by=\"" ); break;
2069 case 2: xAnim->setFrom( a ); dump( " from=\"" ); break;
2070 case 3: xAnim->setTo( a ); dump( " to=\"" ); break;
2071 default:
2072 dump( " unknown_value=\"" );
2073 }
2074
2075 dump( a );
2076 dump( "\"" );
2077 }
2078 }
2079 break;
2080 default:
2081 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2082 break;
2083 }
2084
2085 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2086 }
2087 }
2088 }
2089
2090 // --------------------------------------------------------------------
2091
importAnimateMotionContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2092 void AnimationImporter::importAnimateMotionContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2093 {
2094 Reference< XAnimateMotion > xMotion( xNode, UNO_QUERY );
2095
2096 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateMotion && xMotion.is(), "invalid call to ppt::AnimationImporter::importAnimateMotionContainer()!");
2097 if( pAtom && xMotion.is() )
2098 {
2099 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2100
2101 while( pChildAtom )
2102 {
2103 if( !pChildAtom->isContainer() )
2104 {
2105 if( !pChildAtom->seekToContent() )
2106 break;
2107 }
2108
2109 switch( pChildAtom->getType() )
2110 {
2111 case DFF_msofbtAnimateMotionData:
2112 {
2113 sal_uInt32 nBits, nOrigin;
2114 float fByX, fByY, fFromX, fFromY, fToX, fToY;
2115
2116 mrStCtrl >> nBits >> fByX >> fByY >> fFromX >> fFromY >> fToX >> fToY >> nOrigin;
2117
2118 #ifdef DBG_ANIM_LOG
2119 if( nBits & 1 )
2120 fprintf( mpFile, " by=\"%g,%g\"", (double)fByX, (double)fByY );
2121
2122 if( nBits & 2 )
2123 fprintf( mpFile, " from=\"%g,%g\"", (double)fFromX, (double)fFromY );
2124
2125 if( nBits & 4 )
2126 fprintf( mpFile, " to=\"%g,%g\"", (double)fToX, (double)fToY );
2127
2128 if( nBits & 8 )
2129 fprintf( mpFile, " origin=\"%s\"", (nOrigin == 1) ? "parent" : (nOrigin == 2) ? "layout" : "unknown" );
2130
2131 #endif
2132 }
2133 break;
2134
2135 case DFF_msofbtAnimAttributeValue:
2136 {
2137 Any aPath;
2138 if ( importAttributeValue( pChildAtom, aPath ) )
2139 {
2140 rtl::OUString aStr;
2141 if ( aPath >>= aStr )
2142 {
2143 aStr = aStr.replace( 'E', ' ' );
2144 aStr = aStr.trim();
2145 aPath <<= aStr;
2146 xMotion->setPath( aPath );
2147 dump( " path=\"" );
2148 dump( aPath );
2149 dump( "\"" );
2150 }
2151 }
2152 }
2153 break;
2154
2155 case DFF_msofbtAnimateTarget:
2156 importAnimateAttributeTargetContainer( pChildAtom, xNode );
2157 break;
2158
2159 default:
2160 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2161 break;
2162 }
2163
2164 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2165 }
2166 }
2167 }
2168
2169 // --------------------------------------------------------------------
2170
importCommandContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2171 void AnimationImporter::importCommandContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2172 {
2173 Reference< XCommand > xCommand( xNode, UNO_QUERY );
2174 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimCommand && xCommand.is(), "invalid call to ppt::AnimationImporter::importCommandContainer()!");
2175 if( pAtom && xCommand.is() )
2176 {
2177 sal_Int32 nBits = 0, nType = 0;
2178 Any aValue;
2179
2180 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2181
2182 while( pChildAtom )
2183 {
2184 if( !pChildAtom->isContainer() )
2185 {
2186 if( !pChildAtom->seekToContent() )
2187 break;
2188 }
2189
2190 switch( pChildAtom->getType() )
2191 {
2192 case DFF_msofbtCommandData:
2193 {
2194 sal_Int32 nCommandType;
2195 // looks like U1 is a bitset, bit 1 enables the type and bit 2 enables
2196 // a propertyvalue that follows
2197 mrStCtrl >> nBits;
2198 mrStCtrl >> nCommandType;
2199
2200 if( nBits & 1 )
2201 {
2202 dump( " type=\"%s\"", (nCommandType == 0) ? "event" : ( nCommandType == 1) ? "call" : "verb" );
2203 }
2204 }
2205 break;
2206
2207 case DFF_msofbtAnimAttributeValue:
2208 {
2209 if ( importAttributeValue( pChildAtom, aValue ) )
2210 {
2211 if( nBits & 2 )
2212 {
2213 dump( " cmd=\"" );
2214 dump( aValue );
2215 dump( "\"" );
2216 }
2217 }
2218 }
2219 break;
2220
2221 case DFF_msofbtAnimateTarget:
2222 importAnimateAttributeTargetContainer( pChildAtom, xNode );
2223 break;
2224
2225 default:
2226 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2227 break;
2228 }
2229
2230 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2231 }
2232
2233 if( nBits & 3 )
2234 {
2235 OUString aParam;
2236 aValue >>= aParam;
2237
2238 sal_Int16 nCommand = EffectCommands::CUSTOM;
2239
2240 NamedValue aParamValue;
2241
2242 switch( nType )
2243 {
2244 case 0: // event
2245 case 1: // call
2246 if( aParam.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "onstopaudio" ) ) )
2247 {
2248 nCommand = EffectCommands::STOPAUDIO;
2249 }
2250 else if( aParam.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("play") ) )
2251 {
2252 nCommand = EffectCommands::PLAY;
2253 }
2254 else if( aParam.compareToAscii( RTL_CONSTASCII_STRINGPARAM("playFrom") ) == 0 )
2255 {
2256 const OUString aMediaTime( aParam.copy( 9, aParam.getLength() - 10 ) );
2257 rtl_math_ConversionStatus eStatus;
2258 double fMediaTime = ::rtl::math::stringToDouble( aMediaTime, (sal_Unicode)('.'), (sal_Unicode)(','), &eStatus, NULL );
2259 if( eStatus == rtl_math_ConversionStatus_Ok )
2260 {
2261 aParamValue.Name = OUString(RTL_CONSTASCII_USTRINGPARAM("MediaTime"));
2262 aParamValue.Value <<= fMediaTime;
2263 }
2264 nCommand = EffectCommands::PLAY;
2265 }
2266 else if( aParam.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("togglePause") ) )
2267 {
2268 nCommand = EffectCommands::TOGGLEPAUSE;
2269 }
2270 else if( aParam.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("stop") ) )
2271 {
2272 nCommand = EffectCommands::STOP;
2273 }
2274 break;
2275 case 2: // verb
2276 {
2277 aParamValue.Name = OUString(RTL_CONSTASCII_USTRINGPARAM("Verb"));
2278 aParamValue.Value <<= aParam.toInt32();
2279
2280 nCommand = EffectCommands::VERB;
2281 }
2282 break;
2283 }
2284
2285 xCommand->setCommand( nCommand );
2286 if( nCommand == EffectCommands::CUSTOM )
2287 {
2288 DBG_ERROR("sd::AnimationImporter::importCommandContainer(), unknown command!");
2289 aParamValue.Name = OUString(RTL_CONSTASCII_USTRINGPARAM("UserDefined"));
2290 aParamValue.Value <<= aParam;
2291 }
2292
2293 if( aParamValue.Value.hasValue() )
2294 {
2295 Sequence< NamedValue > aParamSeq( &aParamValue, 1 );
2296 xCommand->setParameter( makeAny( aParamSeq ) );
2297 }
2298 }
2299 }
2300 }
2301
2302 // --------------------------------------------------------------------
2303
importAudioContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2304 void AnimationImporter::importAudioContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2305 {
2306 Reference< XAudio > xAudio( xNode, UNO_QUERY );
2307 DBG_ASSERT( pAtom && xAudio.is() &&
2308 ( (pAtom->getType() == DFF_msofbtAnimGroup) ||
2309 (pAtom->getType() == DFF_msofbtAnimSubGoup) ), "invalid call to ppt::AnimationImporter::importAudioContainer()!");
2310 if( pAtom && xAudio.is() )
2311 {
2312 importAnimationEvents( pAtom, xNode );
2313 importAnimationValues( pAtom, xNode );
2314 importAnimationActions( pAtom, xNode );
2315
2316 dump(">\n");
2317
2318 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2319
2320 while( pChildAtom )
2321 {
2322 if( !pChildAtom->isContainer() )
2323 {
2324 if( !pChildAtom->seekToContent() )
2325 break;
2326 }
2327
2328 switch( pChildAtom->getType() )
2329 {
2330 case DFF_msofbtAnimNode:
2331 case DFF_msofbtAnimEvent:
2332 case DFF_msofbtAnimValue:
2333 case DFF_msofbtAnimAction:
2334 case DFF_msofbtAnimPropertySet:
2335 break;
2336
2337 case DFF_msofbtAnimAttributeValue:
2338 {
2339 Any aValue;
2340 if ( importAttributeValue( pChildAtom, aValue ) )
2341 {
2342 dump( " value=\"" );
2343 dump( aValue );
2344 dump( "\"" );
2345 }
2346 }
2347 break;
2348
2349 case DFF_msofbtAnimateTargetElement:
2350 {
2351 sal_Int16 nSubType;
2352 Any aSource;
2353 importTargetElementContainer( pChildAtom, aSource, nSubType );
2354 if( xAudio.is() )
2355 xAudio->setSource( aSource );
2356 }
2357 break;
2358
2359 default:
2360 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2361 break;
2362 }
2363
2364 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2365 }
2366
2367 // TODO: What to do with them?
2368 Any aEmpty;
2369 xAudio->setBegin( aEmpty );
2370 xAudio->setEnd( aEmpty );
2371 }
2372 }
2373
2374 // --------------------------------------------------------------------
2375
importAnimateScaleContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2376 void AnimationImporter::importAnimateScaleContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2377 {
2378 Reference< XAnimateTransform > xTransform( xNode, UNO_QUERY );
2379
2380 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateScale && xTransform.is(), "invalid call to ppt::AnimationImporter::importAnimateScaleContainer()!");
2381 if( pAtom && xTransform.is() )
2382 {
2383 xTransform->setTransformType( AnimationTransformType::SCALE );
2384
2385 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2386
2387 while( pChildAtom )
2388 {
2389 if( !pChildAtom->isContainer() )
2390 {
2391 if( !pChildAtom->seekToContent() )
2392 break;
2393 }
2394
2395 switch( pChildAtom->getType() )
2396 {
2397 case DFF_msofbtAnimateScaleData:
2398 {
2399 sal_uInt32 nBits, nZoomContents;
2400 float fByX, fByY, fFromX, fFromY, fToX, fToY;
2401
2402 // nBits %001: by, %010: from, %100: to, %1000: zoomContents(bool)
2403 mrStCtrl >> nBits >> fByX >> fByY >> fFromX >> fFromY >> fToX >> fToY >> nZoomContents;
2404
2405 ValuePair aPair;
2406 // 'from' value
2407 if( nBits & 2 )
2408 {
2409 aPair.First <<= (double)fFromX / 100.0;
2410 aPair.Second <<= (double)fFromY / 100.0;
2411 xTransform->setFrom( makeAny( aPair ) );
2412 }
2413
2414 // 'to' value
2415 if( nBits & 4 )
2416 {
2417 aPair.First <<= (double)fToX / 100.0;
2418 aPair.Second <<= (double)fToY / 100.0;
2419 xTransform->setTo( makeAny( aPair ) );
2420 }
2421
2422 // 'by' value
2423 if( nBits & 1 )
2424 {
2425 aPair.First <<= (double)fByX / 100.0;
2426 aPair.Second <<= (double)fByY / 100.0;
2427
2428 if( nBits & 2 )
2429 {
2430 // 'from' value given, import normally
2431 xTransform->setBy( makeAny( aPair ) );
2432 }
2433 else
2434 {
2435 // mapping 'by' to 'to', if no 'from' is
2436 // given. This is due to a non-conformity in
2437 // PPT, which exports animateScale effects
2438 // with a sole 'by' value, but with the
2439 // semantics of a sole 'to' animation
2440 xTransform->setTo( makeAny( aPair ) );
2441 }
2442 }
2443
2444
2445 #ifdef DBG_ANIM_LOG
2446 if( nBits & 1 )
2447 fprintf( mpFile, " by=\"%g,%g\"", (double)fByX, (double)fByY );
2448
2449 if( nBits & 2 )
2450 fprintf( mpFile, " from=\"%g,%g\"", (double)fFromX, (double)fFromY );
2451
2452 if( nBits & 4 )
2453 fprintf( mpFile, " to=\"%g,%g\"", (double)fToX, (double)fToY );
2454
2455 if( nBits & 8 )
2456 fprintf( mpFile, " zoomContents=\"%s\"", nZoomContents ? "true" : "false" );
2457 #endif
2458 }
2459 break;
2460
2461 case DFF_msofbtAnimateTarget:
2462 importAnimateAttributeTargetContainer( pChildAtom, xNode );
2463 break;
2464
2465 default:
2466 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2467 break;
2468 }
2469
2470 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2471 }
2472 }
2473 }
2474
2475 // --------------------------------------------------------------------
2476
importAnimateRotationContainer(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2477 void AnimationImporter::importAnimateRotationContainer( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2478 {
2479 Reference< XAnimateTransform > xTransform( xNode, UNO_QUERY );
2480
2481 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimateRotation && xTransform.is(), "invalid call to ppt::AnimationImporter::importAnimateRotationContainer()!");
2482 if( pAtom && xTransform.is() )
2483 {
2484 xTransform->setTransformType( AnimationTransformType::ROTATE );
2485
2486 const Atom* pChildAtom = pAtom->findFirstChildAtom();
2487
2488 while( pChildAtom )
2489 {
2490 if( !pChildAtom->isContainer() )
2491 {
2492 if( !pChildAtom->seekToContent() )
2493 break;
2494 }
2495
2496 switch( pChildAtom->getType() )
2497 {
2498 case DFF_msofbtAnimateRotationData:
2499 {
2500 sal_uInt32 nBits, nU1;
2501 float fBy, fFrom, fTo;
2502
2503 // nBits %001: by, %010: from, %100: to, %1000: zoomContents(bool)
2504 mrStCtrl >> nBits >> fBy >> fFrom >> fTo >> nU1;
2505
2506 if( nBits & 1 )
2507 xTransform->setBy( makeAny( (double) fBy ) );
2508
2509 if( nBits & 2 )
2510 xTransform->setFrom( makeAny( (double) fFrom ) );
2511
2512 if( nBits & 4 )
2513 xTransform->setTo( makeAny( (double) fTo ) );
2514
2515 #ifdef DBG_ANIM_LOG
2516 if( nBits & 1 )
2517 fprintf( mpFile, " by=\"%g\"", (double)fBy );
2518
2519 if( nBits & 2 )
2520 fprintf( mpFile, " from=\"%g\"", (double)fFrom );
2521
2522 if( nBits & 4 )
2523 fprintf( mpFile, " to=\"%g\"", (double)fTo );
2524
2525 if( nU1 )
2526 fprintf( mpFile, " rotation_1=\"%ld\"", nU1 );
2527 #endif
2528 }
2529 break;
2530
2531 case DFF_msofbtAnimateTarget:
2532 importAnimateAttributeTargetContainer( pChildAtom, xNode );
2533 break;
2534
2535 default:
2536 dump( " unknown_atom=\"%ld\"", (sal_Int32)pChildAtom->getType() );
2537 break;
2538 }
2539
2540 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
2541 }
2542 }
2543 }
2544 // --------------------------------------------------------------------
2545
importAttributeNamesContainer(const Atom * pAtom,OUString & rAttributeNames)2546 bool AnimationImporter::importAttributeNamesContainer( const Atom* pAtom, OUString& rAttributeNames )
2547 {
2548 OUStringBuffer aNames;
2549
2550 DBG_ASSERT( pAtom && (pAtom->getType() == DFF_msofbtAnimateAttributeNames), "invalid call to ppt::AnimationImporter::importAttributeName()!" );
2551 if( pAtom )
2552 {
2553 const Atom* pAttributeValueAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimAttributeValue );
2554
2555 while( pAttributeValueAtom )
2556 {
2557 Any aAny;
2558 if ( importAttributeValue( pAttributeValueAtom, aAny ) )
2559 {
2560 OUString aName;
2561 if( aAny >>= aName )
2562 {
2563 if( aNames.getLength() )
2564 aNames.append( (sal_Unicode)';' );
2565
2566 aNames.append( aName );
2567 }
2568 }
2569 else
2570 {
2571 DBG_ERROR( "error during ppt::AnimationImporter::importAttributeName()!" );
2572 }
2573
2574 pAttributeValueAtom = pAtom->findNextChildAtom( DFF_msofbtAnimAttributeValue, pAttributeValueAtom );
2575 }
2576 }
2577
2578 rAttributeNames = aNames.makeStringAndClear();
2579 return true;
2580 }
2581
2582 // --------------------------------------------------------------------
2583
importAnimationValues(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2584 void AnimationImporter::importAnimationValues( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2585 {
2586 DBG_ASSERT( pAtom, "invalid call to ppt::AnimationImporter::importAnimationValues()!" );
2587
2588 if( pAtom )
2589 {
2590 const Atom* pValueAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimValue );
2591
2592 while( pValueAtom && pValueAtom->seekToContent() )
2593 {
2594 sal_uInt32 nType;
2595 mrStCtrl >> nType;
2596 switch( nType )
2597 {
2598 case 0:
2599 {
2600 float fRepeat;
2601 mrStCtrl >> fRepeat;
2602 xNode->setRepeatCount( (fRepeat < ((float)3.40282346638528860e+38)) ? makeAny( (double)fRepeat ) : makeAny( Timing_INDEFINITE ) );
2603
2604 #ifdef DBG_ANIM_LOG
2605 if( (fRepeat < ((float)3.40282346638528860e+38)) )
2606 {
2607 dump( " repeat=\"%g\"", (double)fRepeat );
2608 }
2609 else
2610 {
2611 dump( " repeat=\"indefinite\"" );
2612 }
2613 #endif
2614 }
2615 break;
2616
2617 case 3:
2618 {
2619 float faccelerate;
2620 mrStCtrl >> faccelerate;
2621 xNode->setAcceleration( faccelerate );
2622 dump( " accelerate=\"%g\"", (double)faccelerate );
2623 }
2624 break;
2625
2626 case 4:
2627 {
2628 float fdecelerate;
2629 mrStCtrl >> fdecelerate;
2630 xNode->setDecelerate( fdecelerate );
2631 dump( " decelerate=\"%g\"", (double)fdecelerate );
2632 }
2633 break;
2634
2635 case 5:
2636 {
2637 sal_Int32 nAutoreverse;
2638 mrStCtrl >> nAutoreverse;
2639 xNode->setAutoReverse( nAutoreverse != 0 );
2640 dump( " autoreverse=\"%#lx\"", nAutoreverse );
2641 }
2642 break;
2643
2644 default:
2645 {
2646 sal_uInt32 nUnknown;
2647 mrStCtrl >> nUnknown;
2648 #ifdef DBG_ANIM_LOG
2649 fprintf(mpFile, " attribute_%d=\"%#lx\"", nType, nUnknown );
2650 #endif
2651 }
2652 break;
2653 }
2654
2655 pValueAtom = pAtom->findNextChildAtom( DFF_msofbtAnimValue, pValueAtom );
2656 }
2657 }
2658 }
2659
2660 // --------------------------------------------------------------------
2661
importAnimateKeyPoints(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2662 void AnimationImporter::importAnimateKeyPoints( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2663 {
2664 Reference< XAnimate > xAnim( xNode, UNO_QUERY );
2665
2666 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimKeyPoints && xAnim.is(), "invalid call to ppt::AnimationImporter::importAnimateKeyPoints()!" );
2667
2668 if( pAtom && xAnim.is() )
2669 {
2670 // first count keytimes
2671 const Atom* pIter = NULL;
2672 int nKeyTimes = 0;
2673
2674 while( (pIter = pAtom->findNextChildAtom( DFF_msofbtAnimKeyTime, pIter )) != 0 )
2675 nKeyTimes++;
2676
2677 Sequence< double > aKeyTimes( nKeyTimes );
2678 Sequence< Any > aValues( nKeyTimes );
2679 OUString aFormula;
2680
2681 pIter = pAtom->findFirstChildAtom(DFF_msofbtAnimKeyTime);
2682 int nKeyTime;
2683 sal_Int32 nTemp;
2684 for( nKeyTime = 0; (nKeyTime < nKeyTimes) && pIter; nKeyTime++ )
2685 {
2686 if( pIter->seekToContent() )
2687 {
2688 mrStCtrl >> nTemp;
2689 double fTemp = (double)nTemp / 1000.0;
2690 aKeyTimes[nKeyTime] = fTemp;
2691
2692 const Atom* pValue = pAtom->findNextChildAtom(pIter);
2693 if( pValue && pValue->getType() == DFF_msofbtAnimAttributeValue )
2694 {
2695 Any aValue1, aValue2;
2696 if( importAttributeValue( pValue, aValue1 ) )
2697 {
2698 pValue = pAtom->findNextChildAtom(pValue);
2699 if( pValue && pValue->getType() == DFF_msofbtAnimAttributeValue )
2700 importAttributeValue( pValue, aValue2 );
2701
2702 bool bCouldBeFormula = false;
2703 bool bHasValue = aValue2.hasValue();
2704 if( bHasValue )
2705 {
2706 if( aValue2.getValueType() == ::getCppuType((const OUString*)0) )
2707 {
2708 OUString aTest;
2709 aValue2 >>= aTest;
2710 bHasValue = aTest.getLength() != 0;
2711 bCouldBeFormula = true;
2712 }
2713 }
2714
2715 if( bHasValue && bCouldBeFormula && (aValue1.getValueType() == ::getCppuType((const double*)0)) )
2716 {
2717 aValue2 >>= aFormula;
2718 bHasValue = false;
2719 }
2720
2721 if( bHasValue )
2722 {
2723 aValues[nKeyTime] = makeAny( ValuePair( aValue1, aValue2 ) );
2724 }
2725 else
2726 {
2727 aValues[nKeyTime] = aValue1;
2728 }
2729 }
2730 }
2731 }
2732 pIter = pAtom->findNextChildAtom(DFF_msofbtAnimKeyTime, pIter);
2733 }
2734
2735 #ifdef DBG_ANIM_LOG
2736 dump( " keyTimes=\"" );
2737 for( int i=0; i<nKeyTimes; ++i )
2738 dump( "%f;", aKeyTimes[i] );
2739
2740 if( aFormula.getLength() )
2741 {
2742 dump( "formula=\"%s", aFormula );
2743 }
2744
2745 dump( "\" values=\"" );
2746 double nVal;
2747 OUString aStr;
2748 for( int i=0; i<nKeyTimes; ++i )
2749 {
2750 if( i != 0 )
2751 dump( ";" );
2752
2753 if( aValues[i] >>= aStr )
2754 dump( "%s",
2755 ::rtl::OUStringToOString( aStr,
2756 RTL_TEXTENCODING_ASCII_US ).getStr() );
2757 else if( aValues[i] >>= nVal )
2758 dump( "%f", nVal );
2759 else
2760 {
2761 ValuePair aValuePair;
2762
2763 if( aValues[i] >>= aValuePair )
2764 {
2765 if( aValuePair.First >>= aStr )
2766 dump( "%s",
2767 ::rtl::OUStringToOString( aStr,
2768 RTL_TEXTENCODING_ASCII_US ).getStr() );
2769 else if( aValuePair.First >>= nVal )
2770 dump( "%f", nVal );
2771 else
2772 dump( "%X", (sal_Int32)&aValuePair.First );
2773
2774 if( aValuePair.Second >>= aStr )
2775 dump( ",%s",
2776 ::rtl::OUStringToOString( aStr,
2777 RTL_TEXTENCODING_ASCII_US ).getStr() );
2778 else if( aValuePair.Second >>= nVal )
2779 dump( ",%f", nVal );
2780 else
2781 dump( ",%X", (sal_Int32)&aValuePair.Second );
2782 }
2783 }
2784 }
2785 dump( "\"" );
2786 #endif
2787
2788 xAnim->setKeyTimes( aKeyTimes );
2789 xAnim->setValues( aValues );
2790 xAnim->setFormula( aFormula );
2791 }
2792 }
2793
2794 // --------------------------------------------------------------------
2795
importAttributeValue(const Atom * pAtom,Any & rAny)2796 bool AnimationImporter::importAttributeValue( const Atom* pAtom, Any& rAny )
2797 {
2798 DBG_ASSERT( pAtom && pAtom->getType() == DFF_msofbtAnimAttributeValue, "invalid call to ppt::AnimationImporter::importAttributeValue()!" );
2799
2800 bool bOk = false;
2801
2802 if( pAtom && pAtom->seekToContent() )
2803 {
2804 sal_uInt32 nRecLen = pAtom->getLength();
2805 if ( nRecLen >= 1 )
2806 {
2807 sal_Int8 nType;
2808 mrStCtrl >> nType;
2809 switch( nType )
2810 {
2811 case DFF_ANIM_PROP_TYPE_BYTE :
2812 {
2813 if ( nRecLen == 2 )
2814 {
2815 sal_uInt8 nByte;
2816 mrStCtrl >> nByte;
2817 rAny <<= nByte;
2818
2819 bOk = true;
2820 }
2821 }
2822 break;
2823
2824 case DFF_ANIM_PROP_TYPE_INT32 :
2825 {
2826 if ( nRecLen == 5 )
2827 {
2828 sal_uInt32 nInt32;
2829 mrStCtrl >> nInt32;
2830 rAny <<= nInt32;
2831
2832 bOk = true;
2833 }
2834 }
2835 break;
2836
2837 case DFF_ANIM_PROP_TYPE_FLOAT:
2838 {
2839 if( nRecLen == 5 )
2840 {
2841 float fFloat;
2842 mrStCtrl >> fFloat;
2843 rAny <<= (double)fFloat;
2844
2845 bOk = true;
2846 }
2847 }
2848 break;
2849
2850 case DFF_ANIM_PROP_TYPE_UNISTRING :
2851 {
2852 if ( ( nRecLen & 1 ) && ( nRecLen > 1 ) )
2853 {
2854 String aString;
2855 mpPPTImport->MSDFFReadZString( mrStCtrl, aString, nRecLen - 1, sal_True );
2856 rtl::OUString aOUString( aString );
2857 rAny <<= aOUString;
2858
2859 bOk = true;
2860 }
2861 }
2862 break;
2863 }
2864 }
2865 }
2866
2867 DBG_ASSERT( bOk, "invalid value inside ppt::AnimationImporter::importAttributeValue()!" );
2868 return bOk;
2869 }
2870
2871 // --------------------------------------------------------------------
2872
importAnimationEvents(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2873 void AnimationImporter::importAnimationEvents( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2874 {
2875 DBG_ASSERT( xNode.is() && pAtom, "invalid call to ppt::AnimationImporter::importAnimationEvents()!" );
2876
2877 Any aBegin, aEnd, aNext, aPrev;
2878
2879 const Atom* pEventAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimEvent );
2880 while( pEventAtom )
2881 {
2882 Any* pEvents = NULL;
2883
2884 switch( pEventAtom->getInstance() )
2885 {
2886 case 1: pEvents = &aBegin; break;
2887 case 2: pEvents = &aEnd; break;
2888 case 3: pEvents = &aNext; break;
2889 case 4: pEvents = &aPrev; break;
2890 }
2891
2892 if( pEvents )
2893 {
2894 Event aEvent;
2895 aEvent.Trigger = EventTrigger::NONE;
2896 aEvent.Repeat = 0;
2897
2898 const Atom* pChildAtom = pEventAtom->findFirstChildAtom();
2899
2900 while( pChildAtom && pChildAtom->seekToContent() )
2901 {
2902 switch( pChildAtom->getType() )
2903 {
2904 case DFF_msofbtAnimTrigger:
2905 {
2906 sal_Int32 nU1, nTrigger, nU3, nBegin;
2907 mrStCtrl >> nU1;
2908 mrStCtrl >> nTrigger;
2909 mrStCtrl >> nU3;
2910 mrStCtrl >> nBegin;
2911
2912 switch( nTrigger )
2913 {
2914 case 0: aEvent.Trigger = EventTrigger::NONE; break;
2915 case 1: aEvent.Trigger = EventTrigger::ON_BEGIN; break;
2916 case 2: aEvent.Trigger = EventTrigger::ON_END; break;
2917 case 3: aEvent.Trigger = EventTrigger::BEGIN_EVENT; break;
2918 case 4: aEvent.Trigger = EventTrigger::END_EVENT; break;
2919 case 5: aEvent.Trigger = EventTrigger::ON_CLICK; break;
2920 case 6: aEvent.Trigger = EventTrigger::ON_DBL_CLICK; break;
2921 case 7: aEvent.Trigger = EventTrigger::ON_MOUSE_ENTER; break;
2922 case 8: aEvent.Trigger = EventTrigger::ON_MOUSE_LEAVE; break;
2923 case 9: aEvent.Trigger = EventTrigger::ON_NEXT; break;
2924 case 10: aEvent.Trigger = EventTrigger::ON_PREV; break;
2925 case 11: aEvent.Trigger = EventTrigger::ON_STOP_AUDIO; break;
2926 }
2927
2928 if( (nBegin != 0) || (aEvent.Trigger == EventTrigger::NONE) )
2929 aEvent.Offset = (nBegin == -1) ? makeAny( Timing_INDEFINITE ) : makeAny( (double)(nBegin / 1000.0) );
2930 }
2931 break;
2932 case DFF_msofbtAnimateTargetElement:
2933 {
2934 sal_Int16 nSubType;
2935 importTargetElementContainer( pChildAtom, aEvent.Source, nSubType );
2936 }
2937 break;
2938 default:
2939 {
2940 DBG_ERROR("unknown atom inside ppt::AnimationImporter::importAnimationEvents()!");
2941 }
2942 }
2943
2944 pChildAtom = pEventAtom->findNextChildAtom( pChildAtom );
2945 }
2946
2947 *pEvents = addToSequence( *pEvents, (aEvent.Trigger == EventTrigger::NONE) ? aEvent.Offset : makeAny( aEvent ) );
2948 }
2949
2950 pEventAtom = pAtom->findNextChildAtom( DFF_msofbtAnimEvent, pEventAtom );
2951 }
2952
2953 xNode->setBegin( aBegin );
2954 xNode->setEnd( aEnd );
2955 // TODO: xNode->setNext( aNext );
2956 // TODO: xNode->setPrev( aNext );
2957
2958 #ifdef DBG_ANIM_LOG
2959 if( aBegin.hasValue() )
2960 {
2961 dump( " begin=\"" );
2962 dump( aBegin );
2963 dump( "\"" );
2964 }
2965
2966 if( aEnd.hasValue() )
2967 {
2968 dump( " end=\"" );
2969 dump( aEnd );
2970 dump( "\"" );
2971 }
2972
2973 if( aNext.hasValue() )
2974 {
2975 dump( " next=\"" );
2976 dump( aNext );
2977 dump( "\"" );
2978 }
2979
2980 if( aPrev.hasValue() )
2981 {
2982 dump( " prev=\"" );
2983 dump( aPrev );
2984 dump( "\"" );
2985 }
2986 #endif
2987 }
2988
2989 // --------------------------------------------------------------------
2990
importAnimationActions(const Atom * pAtom,const Reference<XAnimationNode> & xNode)2991 void AnimationImporter::importAnimationActions( const Atom* pAtom, const Reference< XAnimationNode >& xNode )
2992 {
2993 DBG_ASSERT( pAtom && xNode.is(), "invalid call to ppt::AnimationImporter::importAnimationActions()!");
2994
2995 if( pAtom )
2996 {
2997 const Atom* pActionAtom = pAtom->findFirstChildAtom( DFF_msofbtAnimAction );
2998
2999 if( pActionAtom && pActionAtom->seekToContent() )
3000 {
3001 sal_Int32 nConcurrent, nNextAction, nEndSync, nU4, nU5;
3002 mrStCtrl >> nConcurrent;
3003 mrStCtrl >> nNextAction;
3004 mrStCtrl >> nEndSync;
3005 mrStCtrl >> nU4;
3006 mrStCtrl >> nU5;
3007
3008 if( nEndSync == 1 )
3009 xNode->setEndSync( makeAny( AnimationEndSync::ALL ) );
3010
3011 #ifdef DBG_ANIM_LOG
3012 dump( " concurrent=\"%s\"", nConcurrent == 0 ? "disabled" : (nConcurrent == 1 ? "enabled" : "unknown") );
3013
3014 dump( " nextAction=\"%s\"", nNextAction == 0 ? "none" : (nNextAction == 1 ? "seek" : "unknown") );
3015
3016 if( nEndSync != 0 )
3017 {
3018 dump( " endSync=\"%s\"", nEndSync == 1 ? "all" : "unknown" );
3019 }
3020
3021 dump( " action_4=\"%#lx\"", nU4 );
3022 dump( " action_5=\"%#lx\"", nU5 );
3023 #endif
3024 }
3025 }
3026 }
3027
3028 // --------------------------------------------------------------------
3029
importTargetElementContainer(const Atom * pAtom,Any & rTarget,sal_Int16 & rSubType)3030 sal_Int32 AnimationImporter::importTargetElementContainer( const Atom* pAtom, Any& rTarget, sal_Int16& rSubType )
3031 {
3032 rSubType = ShapeAnimationSubType::AS_WHOLE;
3033 sal_Int32 nRefMode = -1;
3034
3035 DBG_ASSERT( pAtom && (pAtom->getType() == DFF_msofbtAnimateTargetElement), "invalid call to ppt::AnimationImporter::importTargetElementContainer()!" );
3036 if( pAtom )
3037 {
3038 const Atom* pChildAtom = pAtom->findFirstChildAtom();
3039 while( pChildAtom && pChildAtom->seekToContent() )
3040 {
3041 switch( pChildAtom->getType() )
3042 {
3043 case DFF_msofbtAnimReference:
3044 {
3045 sal_Int32 nRefType,nRefId;
3046 sal_Int32 begin,end;
3047 mrStCtrl >> nRefMode;
3048 mrStCtrl >> nRefType;
3049 mrStCtrl >> nRefId;
3050 mrStCtrl >> begin;
3051 mrStCtrl >> end;
3052
3053 switch( nRefType )
3054 {
3055 case 1: // shape
3056 {
3057 SdrObject* pSdrObject = mpPPTImport->getShapeForId( nRefId );
3058 if( pSdrObject == NULL )
3059 break;
3060
3061 rTarget <<= pSdrObject->getUnoShape();
3062
3063 switch( nRefMode )
3064 {
3065 // default case 0: rSubType = ShapeAnimationSubType::AS_WHOLE; break;
3066 case 6: rSubType = ShapeAnimationSubType::ONLY_BACKGROUND; break;
3067 case 8: rSubType = ShapeAnimationSubType::ONLY_TEXT; break;
3068 case 2: // one paragraph
3069 {
3070 if( ((begin == -1) && (end == -1)) || !pSdrObject->ISA( SdrTextObj ) )
3071 break;
3072
3073 SdrTextObj* pTextObj = static_cast< SdrTextObj* >( pSdrObject );
3074
3075 const OutlinerParaObject* pOPO = pTextObj->GetOutlinerParaObject();
3076 if( pOPO == NULL )
3077 break;
3078
3079 const EditTextObject& rEditTextObject = pOPO->GetTextObject();
3080
3081 const sal_uInt32 nParaCount = rEditTextObject.GetParagraphCount();
3082
3083 sal_uInt32 nPara = 0;
3084
3085 while( (nPara < nParaCount) && (begin > 0) )
3086 {
3087 sal_Int32 nParaLength = rEditTextObject.GetText( nPara ).Len() + 1;
3088 begin -= nParaLength;
3089 end -= nParaLength;
3090 nPara++;
3091 }
3092
3093 if( nPara < nParaCount )
3094 {
3095 ParagraphTarget aParaTarget;
3096 rTarget >>= aParaTarget.Shape;
3097 aParaTarget.Paragraph = nPara;
3098 rTarget = makeAny( aParaTarget );
3099
3100 rSubType = ShapeAnimationSubType::ONLY_TEXT;
3101 dump( " paragraph %d,", (sal_Int32)nPara);
3102 dump( " %d characters", (sal_Int32)end );
3103 }
3104 }
3105 }
3106 }
3107 break;
3108
3109 case 2: // sound
3110 {
3111 OUString aSoundURL( ((ImplSdPPTImport*)mpPPTImport)->ReadSound( nRefId ) );
3112 rTarget <<= aSoundURL;
3113 dump( " srcRef=\"%s\"", aSoundURL );
3114 }
3115 break;
3116 case 3: // audio object
3117 case 4: // video object
3118 {
3119 SdrObject* pSdrObject = mpPPTImport->getShapeForId( nRefId );
3120 if( pSdrObject == NULL )
3121 break;
3122
3123 rTarget <<= pSdrObject->getUnoShape();
3124 }
3125 break;
3126 default:
3127 DBG_ERROR("unknown reference type");
3128 }
3129
3130
3131 // dump( " ref=\"%s\"", nRefMode == 3 ? "source" : ( nRefMode == 0 ? "target" : "unknown" ) );
3132 // dump( " type=\"%s\"", nRefType == 1 ? "shape" : ( nRefType == 2 ? "sound": "unknown" ) );
3133 // dump( " id=\"%lu\"", (sal_Int32)nRefId );
3134 #ifdef DBG_ANIM_LOG
3135 if((begin != -1) || (end != -1) )
3136 {
3137 // dump( " text_begin=\"%ld\"", begin );
3138 // dump( " text_end=\"%ld\"", end );
3139 }
3140 #endif
3141 }
3142 break;
3143 case 0x2b01:
3144 {
3145 sal_Int32 nU1;
3146 mrStCtrl >> nU1;
3147
3148 // HINT: nU1 == 1 : target document. ?
3149 // dump( " unknown_0x2b01=\"%#lx\"", nU1 );
3150 }
3151 break;
3152 default:
3153 DBG_ERROR("unknown atom inside ppt::AnimationImporter::importTargetElementContainer()!");
3154 break;
3155 }
3156
3157 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
3158
3159 }
3160 }
3161
3162 return nRefMode;
3163 }
3164
3165 // --------------------------------------------------------------------
3166
importPropertySetContainer(const Atom * pAtom,PropertySet & rSet)3167 void AnimationImporter::importPropertySetContainer( const Atom* pAtom, PropertySet& rSet )
3168 {
3169 DBG_ASSERT( pAtom && (pAtom->getType() == DFF_msofbtAnimPropertySet), "invalid call to ppt::AnimationImporter::importPropertySetContainer()!" );
3170
3171 if( pAtom )
3172 {
3173 const Atom* pChildAtom = pAtom->findFirstChildAtom();
3174 while( pChildAtom )
3175 {
3176 if( pChildAtom->getType() == DFF_msofbtAnimAttributeValue )
3177 {
3178 Any aAny;
3179 importAttributeValue( pChildAtom, aAny );
3180 rSet.maProperties[ pChildAtom->getInstance() ] = aAny;
3181 }
3182 else
3183 {
3184 DBG_ERROR("unknown atom inside ppt::AnimationImporter::importPropertySetContainer()!");
3185 }
3186
3187 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
3188 }
3189 }
3190 }
3191
3192 // ====================================================================
3193
3194 #ifdef DBG_ANIM_LOG
dump_atom_header(const Atom * pAtom,bool bOpen,bool bAppend)3195 void AnimationImporter::dump_atom_header( const Atom* pAtom, bool bOpen, bool bAppend )
3196 {
3197 if( pAtom )
3198 {
3199 const char* pTitle;
3200
3201 bool bUnknown = false;
3202
3203 switch( pAtom->getType() )
3204 {
3205 case DFF_msofbtAnimEvent: pTitle = "AnimEvent"; break;
3206 case DFF_msofbtAnimTrigger: pTitle = "AnimTrigger"; break;
3207 case DFF_msofbtAnimateMotion: pTitle = "AnimateMotion"; break;
3208 case DFF_msofbtAnimPropertySet: pTitle = "AnimPropertySet"; break;
3209 case DFF_msofbtAnimateAttributeNames: pTitle = "AnimAttributeName"; break;
3210 case DFF_msofbtAnimAttributeValue: pTitle = "AnimAttributeValue"; break;
3211 case DFF_msofbtAnimGroup: pTitle = "AnimGroup"; break;
3212 case DFF_msofbtAnimNode: pTitle = "AnimNode"; break;
3213 case DFF_msofbtAnimValue: pTitle = "AnimValue"; break;
3214 case DFF_msofbtAnimateFilter: pTitle = "animateFilter"; break;
3215 case DFF_msofbtAnimate: pTitle = "animate"; break;
3216 case DFF_msofbtAnimateSet: pTitle = "set"; break;
3217 case DFF_msofbtAnimKeyTime: pTitle = "AnimKeyTime"; break;
3218 case DFF_msofbtAnimKeyPoints: pTitle = "AnimKeyPoints"; break;
3219 case DFF_msofbtAnimReference: pTitle = "AnimReference"; break;
3220 case DFF_msofbtAnimateTargetElement: pTitle = "AnimTargetElementContainer"; break;
3221 case DFF_msofbtAnimAction: pTitle = "AnimAction"; break;
3222 case DFF_msofbtAnimCommand: pTitle = "AnimCommand"; break;
3223 case DFF_msofbtAnimateTarget: pTitle = "TransformationTarget"; break;
3224 case DFF_msofbtAnimateTargetSettings: pTitle = "TransformationTargetSettings"; break;
3225 case DFF_msofbtAnimIteration: pTitle = "iterate"; break;
3226 case DFF_msofbtAnimateColorData: pTitle = "colorData"; break;
3227 case DFF_msofbtAnimateScaleData: pTitle = "scaleData"; break;
3228 case DFF_msofbtAnimateSetData: pTitle = "setData"; break;
3229
3230 default:
3231 {
3232 static char buffer[128];
3233 sprintf( buffer, "unknown_%#x", pAtom->getType() );
3234 pTitle = buffer;
3235 }
3236 }
3237
3238 if( bOpen )
3239 {
3240 fprintf(mpFile, "<%s", pTitle );
3241
3242 fprintf(mpFile, " instance=\"%hu\"%s",
3243 pAtom->getInstance(),
3244 bAppend ? "" : ">\n");
3245 }
3246 else
3247 {
3248 if( bAppend )
3249 fprintf(mpFile,"/>\n");
3250 else
3251 fprintf(mpFile, "</%s>\n", pTitle );
3252 }
3253 }
3254 }
3255
3256 // --------------------------------------------------------------------
3257
dump(sal_uInt32 nLen,bool bNewLine)3258 void AnimationImporter::dump( sal_uInt32 nLen, bool bNewLine )
3259 {
3260 char * faul = "0123456789abcdef";
3261
3262 sal_uInt32 i = 0;
3263 int b = 0;
3264 sal_Int8 nData;
3265
3266 for( i = 0; i < nLen; i++ )
3267 {
3268 mrStCtrl >> nData;
3269
3270 fprintf( mpFile, "%c%c ", faul[ (nData >> 4) & 0x0f ], faul[ nData & 0x0f ] );
3271
3272 b++;
3273 if( bNewLine && (b == 32) )
3274 {
3275 fprintf(mpFile,"\n");
3276 b = 0;
3277 }
3278 }
3279 if( (b != 0) && bNewLine )
3280 fprintf(mpFile,"\n");
3281 }
3282
3283 // --------------------------------------------------------------------
3284
dump_atom(const Atom * pAtom,bool bNewLine)3285 void AnimationImporter::dump_atom( const Atom* pAtom, bool bNewLine )
3286 {
3287 if( pAtom )
3288 {
3289 if( pAtom->isContainer() )
3290 {
3291 const Atom* pChildAtom = pAtom->findFirstChildAtom();
3292 while( pChildAtom )
3293 {
3294 if( pChildAtom->getType() == DFF_msofbtAnimAttributeValue )
3295 {
3296 fprintf(mpFile, "<attributeValue instance=\"%hu\"", pChildAtom->getInstance() );
3297
3298 Any aValue;
3299 if( importAttributeValue( pChildAtom, aValue ) )
3300 {
3301 sal_Int32 nInt;
3302 rtl::OUString aString;
3303 double fDouble;
3304
3305 if( aValue >>= nInt )
3306 {
3307 fprintf(mpFile, " value=\"%ld\"", nInt );
3308 }
3309 else if( aValue >>= aString )
3310 {
3311 UniString aTmp( aString );
3312 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3313 fprintf(mpFile, " value=\"%s\"", aStr.GetBuffer() );
3314 }
3315 else if( aValue >>= fDouble )
3316 {
3317 fprintf(mpFile, " value=\"%g\"", fDouble );
3318 }
3319 }
3320 else
3321 {
3322 if( pChildAtom->seekToContent() )
3323 {
3324 fprintf(mpFile, " value=\"" );
3325 dump_atom( pChildAtom, false );
3326 fprintf(mpFile, "\"");
3327 }
3328 }
3329
3330 fprintf(mpFile, "/>\n" );
3331 }
3332 else
3333 {
3334 dump_atom_header( pChildAtom, true, pChildAtom->getType() == DFF_msofbtAnimAttributeValue );
3335 dump_atom( pChildAtom );
3336 dump_atom_header( pChildAtom, false, pChildAtom->getType() == DFF_msofbtAnimAttributeValue );
3337 }
3338
3339 pChildAtom = pAtom->findNextChildAtom(pChildAtom);
3340 }
3341 }
3342 else if( pAtom->seekToContent() )
3343 {
3344 dump( pAtom->getLength(), bNewLine );
3345 }
3346 }
3347 }
3348
3349 // --------------------------------------------------------------------
3350
dump_anim_group(const Atom * pAtom,const AnimationNode & rNode,const PropertySet & rSet,bool bOpen)3351 void AnimationImporter::dump_anim_group( const Atom* pAtom, const AnimationNode& rNode, const PropertySet& rSet, bool bOpen )
3352 {
3353 fprintf( mpFile, bOpen ? "<" : "</" );
3354
3355 switch( rNode.mnGroupType )
3356 {
3357 case mso_Anim_GroupType_PAR:
3358 fprintf( mpFile, "par" );
3359 break;
3360 case mso_Anim_GroupType_SEQ:
3361 fprintf( mpFile, "seq" );
3362 break;
3363 case mso_Anim_GroupType_NODE:
3364 switch( rNode.mnNodeType )
3365 {
3366 case mso_Anim_Behaviour_FILTER:
3367 fprintf( mpFile, "animateFilter" );
3368 break;
3369 case mso_Anim_Behaviour_ANIMATION:
3370 if( pAtom->hasChildAtom( DFF_msofbtAnimateSet ) )
3371 fprintf( mpFile, "set" );
3372 else if( pAtom->hasChildAtom( DFF_msofbtAnimateColor ) )
3373 fprintf( mpFile, "animateColor" );
3374 else if( pAtom->hasChildAtom( DFF_msofbtAnimateScale ) )
3375 fprintf( mpFile, "animateScale" );
3376 else if( pAtom->hasChildAtom( DFF_msofbtAnimateRotation ) )
3377 fprintf( mpFile, "animateRotation" );
3378 else if( pAtom->hasChildAtom( DFF_msofbtAnimateMotion ) )
3379 fprintf( mpFile, "animateMotion" );
3380 else if( pAtom->hasChildAtom( DFF_msofbtAnimCommand ) )
3381 fprintf( mpFile, "command" );
3382 else
3383 fprintf( mpFile, "animation" );
3384 break;
3385 default:
3386 {
3387 fprintf( mpFile, "unknown_node_%#lx", rNode.mnNodeType );
3388 }
3389 break;
3390 }
3391 break;
3392 case mso_Anim_GroupType_MEDIA:
3393 fprintf( mpFile, "media" );
3394 break;
3395 default:
3396 fprintf( mpFile, "unknown_group_%#lx", rNode.mnGroupType );
3397 break;
3398 }
3399
3400 if( bOpen )
3401 {
3402 dump( rNode );
3403 dump( rSet );
3404 }
3405
3406 fprintf(mpFile,">\n");
3407 }
3408
dump(const AnimationNode & rNode)3409 void AnimationImporter::dump( const AnimationNode& rNode )
3410 {
3411 // dump animation node
3412 if( rNode.mnRestart != 0 )
3413 {
3414 fprintf(mpFile," restart=\"%s\"",
3415 rNode.mnRestart == 1 ? "always" : (rNode.mnRestart == 2 ? "whenOff" : (rNode.mnRestart == 3 ? "never" : "unknown")) );
3416 }
3417
3418 if( rNode.mnFill )
3419 {
3420 fprintf(mpFile," fill=\"%s\"",
3421 rNode.mnFill == 1 ? "remove" : (rNode.mnFill == 3 ? "hold" : (rNode.mnFill == 2 ? "freeze" : "unknown")) );
3422 }
3423
3424 if( rNode.mnDuration > 0 )
3425 {
3426 double fSeconds = rNode.mnDuration;
3427 fSeconds /= 1000.0;
3428 fprintf(mpFile, " dur=\"%g\"", fSeconds);
3429 }
3430 else if( rNode.mnDuration < 0 )
3431 {
3432 fprintf(mpFile, " dur=\"indefinite\"" );
3433 }
3434
3435 if( rNode.mnU1 ) fprintf(mpFile," u1=\"%#lx\"", rNode.mnU1);
3436 if( rNode.mnU3 ) fprintf(mpFile," u3=\"%#lx\"", rNode.mnU3);
3437 if( rNode.mnU4 ) fprintf(mpFile," u4=\"%#lx\"", rNode.mnU4);
3438 }
3439
dump(Any & rAny)3440 void AnimationImporter::dump( Any& rAny )
3441 {
3442 Sequence< Any > aSeq;
3443 sal_Int32 nInt;
3444 double fDouble;
3445 OUString aString;
3446 sal_Bool bBool;
3447 Event aEvent;
3448 Timing aTiming;
3449
3450 if( rAny >>= aSeq )
3451 {
3452 const sal_Int32 nSize = aSeq.getLength();
3453 sal_Int32 nIndex = 0;
3454 while( nIndex < nSize )
3455 {
3456 dump( aSeq[nIndex++] );
3457 if(nIndex < nSize)
3458 fprintf( mpFile, "," );
3459 }
3460 }
3461 else if( rAny >>= aString )
3462 {
3463 UniString aTmp(aString);
3464 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3465 fprintf( mpFile, "%s", aStr.GetBuffer() );
3466 }
3467 else if( rAny >>= nInt )
3468 {
3469 fprintf( mpFile, "%ld", nInt );
3470 }
3471 else if( rAny >>= bBool )
3472 {
3473 fprintf( mpFile, "%s", bBool ? "true" : "false" );
3474 }
3475 else if( rAny >>= fDouble )
3476 {
3477 fprintf( mpFile, "%g", fDouble );
3478 }
3479 else if( rAny >>= aTiming )
3480 {
3481 fprintf( mpFile, "%s", aTiming == (Timing_INDEFINITE) ? "indefinite" : "media" );
3482 }
3483 else if( rAny >>= aEvent )
3484 {
3485 static const char* triggers[] =
3486 {
3487 "none","onbegin","onend","begin",
3488 "end","onclick","ondoubleclick","onmouseenter",
3489 "onmouseleave","onpptnext","onpptprev","onstopaudio"
3490 };
3491
3492 if( aEvent.Trigger != EventTrigger::NONE )
3493 {
3494 if( aEvent.Source.hasValue() )
3495 {
3496 dump_target( aEvent.Source );
3497 dump( "." );
3498 }
3499
3500 dump( triggers[ aEvent.Trigger ] );
3501 }
3502
3503 if( aEvent.Offset.hasValue() )
3504 {
3505 double fOffset;
3506 if( aEvent.Offset >>= fOffset )
3507 fprintf( mpFile, "%g", fOffset );
3508 else
3509 dump( "indefinite" );
3510 }
3511 }
3512 }
3513
dump(const PropertySet & rSet)3514 void AnimationImporter::dump( const PropertySet& rSet )
3515 {
3516 // dump property set
3517
3518 map< sal_Int32, Any >::const_iterator aIter( rSet.maProperties.begin() );
3519 const map< sal_Int32, Any >::const_iterator aEnd( rSet.maProperties.end() );
3520 while( aIter != aEnd )
3521 {
3522 bool bKnown = false;
3523
3524 const sal_Int32 nInstance = (*aIter).first;
3525 Any aAny( (*aIter).second );
3526
3527 switch ( nInstance )
3528 {
3529 case DFF_ANIM_COLORSPACE:
3530 {
3531 sal_Int32 nColorSpace;
3532 if( aAny >>= nColorSpace )
3533 {
3534 fprintf( mpFile, " colorSpace=\"%s\"", (nColorSpace == 0) ? "rgb" : (nColorSpace == 1) ? "hsl" : "unknown" );
3535 bKnown = true;
3536 }
3537 }
3538 break;
3539
3540 case DFF_ANIM_DIRECTION:
3541 // case DFF_ANIM_MASTERREL:
3542 {
3543 sal_Bool bDirection;
3544 if( aAny >>= bDirection )
3545 {
3546 fprintf( mpFile, " direction=\"%s\"", bDirection ? "cclockwise" : "clockwise" );
3547 bKnown = true;
3548 }
3549 else
3550 {
3551 sal_Int32 nMasterRel;
3552 if( aAny >>= nMasterRel )
3553 {
3554 fprintf( mpFile, " direction=\"%s\"", nMasterRel == 0 ? "sameClick" : ( nMasterRel == 2 ? "nextClick" : "lastClick" ) );
3555 bKnown = true;
3556 }
3557 }
3558 }
3559 break;
3560
3561 case DFF_ANIM_OVERRIDE: // TODO
3562 {
3563 sal_Int32 nOverride;
3564 if( aAny >>= nOverride )
3565 {
3566 fprintf( mpFile, " override=\"%s\"", (nOverride == 1) ? "childStyle" : (nOverride == 0) ? "normal" : "unknown" );
3567 bKnown = true;
3568 }
3569 }
3570 break;
3571
3572 case DFF_ANIM_PATH_EDIT_MODE:
3573 {
3574 sal_Bool bPathEditMode;
3575 if( aAny >>= bPathEditMode )
3576 {
3577 fprintf( mpFile, " pptPathEditMode=\"%s\"", bPathEditMode ? "relative" : "fixed" );
3578 bKnown = true;
3579 }
3580 }
3581 break;
3582
3583 case DFF_ANIM_PRESET_ID :
3584 {
3585 sal_Int32 nPresetId ;
3586 if( aAny >>= nPresetId )
3587 {
3588 fprintf(mpFile, " presetid=\"%ld\"", nPresetId );
3589 bKnown = true;
3590 }
3591 }
3592 break;
3593
3594 case DFF_ANIM_PRESET_SUB_TYPE :
3595 {
3596 sal_Int32 nPointsType ;
3597 if( aAny >>= nPointsType )
3598 {
3599 fprintf(mpFile, " presetSubType=\"%ld\"", nPointsType );
3600 bKnown = true;
3601 }
3602 }
3603 break;
3604
3605 case DFF_ANIM_PRESET_CLASS :
3606 {
3607 sal_Int32 nPresetClass;
3608 if ( aAny >>= nPresetClass )
3609 {
3610 const char* pMode;
3611 switch( nPresetClass )
3612 {
3613 case DFF_ANIM_PRESS_CLASS_USER_DEFINED: pMode = "userdefined"; break;
3614 case DFF_ANIM_PRESS_CLASS_ENTRANCE: pMode = "entrance"; break;
3615 case DFF_ANIM_PRESS_CLASS_EXIT: pMode = "exit"; break;
3616 case DFF_ANIM_PRESS_CLASS_EMPHASIS: pMode = "emphasis"; break;
3617 case DFF_ANIM_PRESS_CLASS_MOTIONPATH: pMode = "motionpath"; break;
3618 case DFF_ANIM_PRESS_CLASS_OLE_ACTION: pMode = "oleaction"; break;
3619 case DFF_ANIM_PRESS_CLASS_MEDIACALL: pMode = "mediacall"; break;
3620 default:
3621 {
3622 static char buffer[128];
3623 sprintf( buffer, "%ld", nPresetClass );
3624 pMode = buffer;
3625 }
3626 break;
3627 }
3628
3629 fprintf(mpFile, " class=\"%s\"", pMode);
3630 bKnown = true;
3631 }
3632 }
3633 break;
3634
3635 case DFF_ANIM_NODE_TYPE :
3636 {
3637 sal_Int32 nNodeType;
3638 if ( aAny >>= nNodeType )
3639 {
3640 const char* pNode;
3641 switch( nNodeType )
3642 {
3643 case DFF_ANIM_NODE_TYPE_ON_CLICK: pNode = "onclick"; break;
3644 case DFF_ANIM_NODE_TYPE_WITH_PREVIOUS: pNode = "withprevious"; break;
3645 case DFF_ANIM_NODE_TYPE_AFTER_PREVIOUS: pNode = "afterprevious"; break;
3646 case DFF_ANIM_NODE_TYPE_MAIN_SEQUENCE: pNode = "mainsequence"; break;
3647 case DFF_ANIM_NODE_TYPE_TIMING_ROOT: pNode = "timingroot"; break;
3648 case DFF_ANIM_NODE_TYPE_INTERACTIVE_SEQ:pNode = "interactivesequence"; break;
3649 default :
3650 {
3651 static char buffer[128];
3652 sprintf( buffer, "%ld", nNodeType );
3653 pNode = buffer;
3654 }
3655 break;
3656 }
3657
3658 fprintf(mpFile, " nodeType=\"%s\"", pNode);
3659 bKnown = true;
3660 }
3661 }
3662 break;
3663
3664 case DFF_ANIM_GROUP_ID:
3665 {
3666 sal_Int32 nGroupId;
3667 if ( aAny >>= nGroupId )
3668 {
3669 fprintf( mpFile, " groupId=\"%ld\"", nGroupId );
3670 bKnown = true;
3671 }
3672 }
3673 break;
3674
3675 case DFF_ANIM_ID:
3676 {
3677 rtl::OUString aString;
3678 if( aAny >>= aString )
3679 {
3680 UniString aTmp(aString);
3681 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3682 fprintf( mpFile, " id=\"%s\"", aStr.GetBuffer() );
3683 bKnown = true;
3684 }
3685 }
3686 break;
3687
3688 case DFF_ANIM_EVENT_FILTER:
3689 {
3690 rtl::OUString aString;
3691 if( aAny >>= aString )
3692 {
3693 UniString aTmp(aString);
3694 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3695 fprintf( mpFile, " eventFilter=\"%s\"", aStr.GetBuffer() );
3696 bKnown = true;
3697 }
3698 }
3699 break;
3700
3701 case DFF_ANIM_ENDAFTERSLIDE:
3702 {
3703 sal_Int32 nEndAfterSlide;
3704 if( aAny >>= nEndAfterSlide )
3705 {
3706 fprintf(mpFile, " endAfterSlide=\"%ld\"", nEndAfterSlide );
3707 bKnown = true;
3708 }
3709 }
3710
3711 case DFF_ANIM_TIMEFILTER:
3712 {
3713 rtl::OUString aString;
3714 if( aAny >>= aString )
3715 {
3716 UniString aTmp(aString);
3717 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3718 fprintf( mpFile, " timeFilter=\"%s\"", aStr.GetBuffer() );
3719 bKnown = true;
3720 }
3721 }
3722 break;
3723
3724 case DFF_ANIM_RUNTIMECONTEXT:
3725 {
3726 rtl::OUString aString;
3727 if( aAny >>= aString )
3728 {
3729 UniString aTmp(aString);
3730 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3731 fprintf( mpFile, " runtimeContext=\"%s\"", aStr.GetBuffer() );
3732 bKnown = true;
3733 }
3734 }
3735 break;
3736
3737 case DFF_ANIM_VOLUME:
3738 {
3739 double fVolume;
3740 if( aAny >>= fVolume )
3741 {
3742 fprintf( mpFile, " volume=\"%g%%\"", (double)(fVolume * 100.0) );
3743 bKnown = true;
3744 }
3745 }
3746 break;
3747
3748 case DFF_ANIM_AFTEREFFECT:
3749 {
3750 sal_Bool bAfterEffect;
3751 if( aAny >>= bAfterEffect )
3752 {
3753 fprintf( mpFile, "afterEffect=\"%s\"", bAfterEffect ? "true" : "false" );
3754 bKnown = true;
3755 }
3756 }
3757 break;
3758
3759 }
3760
3761
3762 if( !bKnown )
3763 {
3764 fprintf( mpFile, " unknown_%lu=\"", nInstance );
3765 dump( aAny );
3766 fprintf( mpFile, "\"" );
3767 }
3768
3769 aIter++;
3770 }
3771 }
3772
dump_target(Any & rAny)3773 void AnimationImporter::dump_target( Any& rAny )
3774 {
3775 Any aSource, aSourceData;
3776 Sequence< Any > aSeq;
3777 if( rAny >>= aSeq )
3778 {
3779 if( aSeq.getLength() >= 1 ) aSource = aSeq[0];
3780 if( aSeq.getLength() >= 2 ) aSourceData = aSeq[1];
3781 }
3782 else
3783 {
3784 aSource = rAny;
3785 }
3786
3787 Reference< XShape > xShape;
3788 aSource >>= xShape;
3789 if( xShape.is() )
3790 {
3791 OUString aStr( xShape->getShapeType() );
3792 dump( aStr );
3793
3794 if( aSourceData.hasValue() )
3795 {
3796 dump( "(" );
3797 dump( aSourceData );
3798 dump( ")" );
3799 }
3800 }
3801 }
3802
dump(const char * pText)3803 void AnimationImporter::dump( const char * pText )
3804 {
3805 fprintf( mpFile, "%s", pText );
3806 }
3807
dump(const rtl::OUString & rString)3808 void AnimationImporter::dump( const rtl::OUString& rString )
3809 {
3810 UniString aTmp( rString );
3811 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3812 fprintf( mpFile, aStr.GetBuffer() );
3813 }
3814
dump(const char * pText,sal_Int32 nInt)3815 void AnimationImporter::dump( const char * pText, sal_Int32 nInt )
3816 {
3817 fprintf( mpFile, pText, nInt );
3818 }
3819
dump(const char * pText,double fDouble)3820 void AnimationImporter::dump( const char * pText, double fDouble )
3821 {
3822 fprintf( mpFile, pText, fDouble );
3823 }
3824
dump(const char * pText,const char * pText2)3825 void AnimationImporter::dump( const char * pText, const char * pText2 )
3826 {
3827 fprintf( mpFile, pText, pText2 );
3828 }
3829
dump(const char * pText,const OUString & rString)3830 void AnimationImporter::dump( const char * pText, const OUString& rString )
3831 {
3832 UniString aTmp( rString );
3833 ByteString aStr( aTmp, RTL_TEXTENCODING_UTF8 );
3834 fprintf( mpFile, pText, aStr.GetBuffer() );
3835 }
3836
3837 #else
3838
dump_atom_header(const Atom *,bool,bool)3839 void AnimationImporter::dump_atom_header( const Atom* , bool , bool )
3840 {
3841 }
3842
dump_atom(const Atom *,bool)3843 void AnimationImporter::dump_atom( const Atom* , bool )
3844 {
3845 }
3846
dump_target(::com::sun::star::uno::Any &)3847 void AnimationImporter::dump_target( ::com::sun::star::uno::Any& )
3848 {
3849 }
3850
dump(::com::sun::star::uno::Any &)3851 void AnimationImporter::dump( ::com::sun::star::uno::Any& )
3852 {
3853 }
3854
dump(const PropertySet &)3855 void AnimationImporter::dump( const PropertySet& )
3856 {
3857 }
3858
dump(const AnimationNode &)3859 void AnimationImporter::dump( const AnimationNode& )
3860 {
3861 }
3862
dump(const char *)3863 void AnimationImporter::dump( const char * )
3864 {
3865 }
3866
dump(const char *,sal_Int32)3867 void AnimationImporter::dump( const char * , sal_Int32 )
3868 {
3869 }
3870
dump(const char *,double)3871 void AnimationImporter::dump( const char * , double )
3872 {
3873 }
3874
dump(const char *,const char *)3875 void AnimationImporter::dump( const char * , const char * )
3876 {
3877 }
3878
dump(const char *,const rtl::OUString &)3879 void AnimationImporter::dump( const char * , const rtl::OUString& )
3880 {
3881 }
3882
3883 #endif
3884
3885 } // namespace ppt;
3886
3887