?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sd / source / core / CustomAnimationEffect.cxx
blobffa1778011bf4b4ea3136114f44f2431e9a05f4b
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: CustomAnimationEffect.cxx,v $
10 * $Revision: 1.17.74.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sd.hxx"
33 #include <tools/debug.hxx>
34 #include <com/sun/star/util/XCloneable.hpp>
35 #include <com/sun/star/animations/AnimationFill.hpp>
36 #include <com/sun/star/container/XEnumerationAccess.hpp>
37 #include <com/sun/star/presentation/EffectNodeType.hpp>
38 #include <com/sun/star/presentation/EffectCommands.hpp>
39 #include <com/sun/star/presentation/EffectPresetClass.hpp>
40 #include <com/sun/star/presentation/ParagraphTarget.hpp>
41 #include <com/sun/star/lang/XInitialization.hpp>
42 #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
43 #include <com/sun/star/animations/AnimationNodeType.hpp>
44 #include <com/sun/star/animations/XCommand.hpp>
45 #include <com/sun/star/animations/AnimationTransformType.hpp>
46 #include <com/sun/star/animations/XIterateContainer.hpp>
47 #include <com/sun/star/animations/XAnimateTransform.hpp>
48 #include <com/sun/star/animations/Event.hpp>
49 #include <com/sun/star/animations/EventTrigger.hpp>
50 #include <com/sun/star/animations/Timing.hpp>
51 #include <com/sun/star/drawing/XDrawPage.hpp>
52 #include <com/sun/star/text/XText.hpp>
53 #include <com/sun/star/animations/XAnimate.hpp>
54 #include <com/sun/star/beans/NamedValue.hpp>
55 #include <com/sun/star/beans/XPropertySet.hpp>
56 #include <com/sun/star/util/XChangesNotifier.hpp>
57 #include <com/sun/star/animations/XAnimateMotion.hpp>
58 #include <comphelper/processfactory.hxx>
59 #include <comphelper/sequence.hxx>
60 #include <com/sun/star/lang/Locale.hpp>
61 #include <com/sun/star/i18n/XBreakIterator.hpp>
62 #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
63 #ifndef _COM_SUN_STAR_TEXT_WORDTYPE_HPP_
64 #include <com/sun/star/i18n/WordType.hpp>
65 #endif
66 #include <com/sun/star/presentation/TextAnimationType.hpp>
67
68 #include <basegfx/polygon/b2dpolypolygon.hxx>
69 #include <basegfx/polygon/b2dpolypolygontools.hxx>
70 #include <basegfx/matrix/b2dhommatrix.hxx>
71 #include <basegfx/range/b2drange.hxx>
72
73 #include <algorithm>
74
75 #include <cppuhelper/implbase1.hxx>
76
77 #include <svx/svdopath.hxx>
78 #include <svx/svdpage.hxx>
79 #include <svx/unoapi.hxx>
80 #include "CustomAnimationEffect.hxx"
81 #include <CustomAnimationPreset.hxx>
82 #include "animations.hxx"
83
84 using namespace ::com::sun::star;
85 using namespace ::com::sun::star::presentation;
86 using namespace ::com::sun::star::animations;
87
88 using ::rtl::OUString;
89 using ::com::sun::star::uno::Reference;
90 using ::com::sun::star::uno::Sequence;
91 using ::com::sun::star::uno::XInterface;
92 using ::com::sun::star::uno::UNO_QUERY;
93 using ::com::sun::star::uno::UNO_QUERY_THROW;
94 using ::com::sun::star::uno::Any;
95 using ::com::sun::star::uno::makeAny;
96 using ::com::sun::star::uno::Exception;
97 using ::com::sun::star::uno::RuntimeException;
98 using ::com::sun::star::container::XEnumerationAccess;
99 using ::com::sun::star::container::XEnumeration;
100 using ::com::sun::star::beans::NamedValue;
101 using ::com::sun::star::container::XChild;
102 using ::com::sun::star::container::XElementAccess;
103 using ::com::sun::star::drawing::XShape;
104 using ::com::sun::star::lang::XInitialization;
105 using ::com::sun::star::drawing::XShapes;
106 using ::com::sun::star::drawing::XDrawPage;
107 using ::com::sun::star::text::XText;
108 using ::com::sun::star::text::XTextRange;
109 using ::com::sun::star::beans::XPropertySet;
110 using ::com::sun::star::lang::XMultiServiceFactory;
111 using ::com::sun::star::util::XCloneable;
112 using ::com::sun::star::lang::Locale;
113 using ::com::sun::star::util::XChangesNotifier;
114 using ::com::sun::star::util::XChangesListener;
115
116 namespace sd
117 {
118 class MainSequenceChangeGuard
119 {
120 public:
121 MainSequenceChangeGuard( EffectSequenceHelper* pSequence )
122 {
123 mpMainSequence = dynamic_cast< MainSequence* >( pSequence );
124 if( mpMainSequence == 0 )
125 {
126 InteractiveSequence* pI = dynamic_cast< InteractiveSequence* >( pSequence );
127 if( pI )
128 mpMainSequence = pI->mpMainSequence;
129 }
130 DBG_ASSERT( mpMainSequence, "sd::MainSequenceChangeGuard::MainSequenceChangeGuard(), no main sequence to guard!" );
131
132 if( mpMainSequence )
133 mpMainSequence->mbIgnoreChanges++;
134 }
135
136 ~MainSequenceChangeGuard()
137 {
138 if( mpMainSequence )
139 mpMainSequence->mbIgnoreChanges++;
140 }
141
142 private:
143 MainSequence* mpMainSequence;
144 };
145
146 CustomAnimationEffect::CustomAnimationEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
147 : mnNodeType(-1),
148 mnPresetClass(-1),
149 mfBegin(-1.0),
150 mfDuration(-1.0),
151 mfAbsoluteDuration(-1.0),
152 mnGroupId(-1),
153 mnIterateType(0),
154 mfIterateInterval(0.0),
155 mnParaDepth( -1 ),
156 mbHasText(sal_False),
157 mfAcceleration( 1.0 ),
158 mfDecelerate( 1.0 ),
159 mbAutoReverse(false),
160 mnTargetSubItem(0),
161 mnCommand(0),
162 mpEffectSequence( 0 ),
163 mbHasAfterEffect(false),
164 mbAfterEffectOnNextEffect(false)
165 {
166 setNode( xNode );
167 }
168
169 // --------------------------------------------------------------------
170
171 void CustomAnimationEffect::setNode( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
172 {
173 mxNode = xNode;
174 mxAudio.clear();
175
176 Sequence< NamedValue > aUserData( mxNode->getUserData() );
177 sal_Int32 nLength = aUserData.getLength();
178 const NamedValue* p = aUserData.getConstArray();
179
180 while( nLength-- )
181 {
182 if( p->Name.equalsAscii( "node-type" ) )
183 {
184 p->Value >>= mnNodeType;
185 }
186 else if( p->Name.equalsAscii( "preset-id" ) )
187 {
188 p->Value >>= maPresetId;
189 }
190 else if( p->Name.equalsAscii( "preset-sub-type" ) )
191 {
192 p->Value >>= maPresetSubType;
193 }
194 else if( p->Name.equalsAscii( "preset-class" ) )
195 {
196 p->Value >>= mnPresetClass;
197 }
198 else if( p->Name.equalsAscii( "preset-property" ) )
199 {
200 p->Value >>= maProperty;
201 }
202 else if( p->Name.equalsAscii( "group-id" ) )
203 {
204 p->Value >>= mnGroupId;
205 }
206
207 p++;
208 }
209
210 // get effect start time
211 mxNode->getBegin() >>= mfBegin;
212
213 mfAcceleration = mxNode->getAcceleration();
214 mfDecelerate = mxNode->getDecelerate();
215 mbAutoReverse = mxNode->getAutoReverse();
216
217 // get iteration data
218 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
219 if( xIter.is() )
220 {
221 mfIterateInterval = xIter->getIterateInterval();
222 mnIterateType = xIter->getIterateType();
223 maTarget = xIter->getTarget();
224 mnTargetSubItem = xIter->getSubItem();
225 }
226 else
227 {
228 mfIterateInterval = 0.0f;
229 mnIterateType = 0;
230 }
231
232 // calculate effect duration and get target shape
233 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
234 if( xEnumerationAccess.is() )
235 {
236 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
237 if( xEnumeration.is() )
238 {
239 while( xEnumeration->hasMoreElements() )
240 {
241 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
242 if( !xChildNode.is() )
243 continue;
244
245 if( xChildNode->getType() == AnimationNodeType::AUDIO )
246 {
247 mxAudio.set( xChildNode, UNO_QUERY );
248 }
249 else if( xChildNode->getType() == AnimationNodeType::COMMAND )
250 {
251 Reference< XCommand > xCommand( xChildNode, UNO_QUERY );
252 if( xCommand.is() )
253 {
254 mnCommand = xCommand->getCommand();
255 if( !maTarget.hasValue() )
256 maTarget = xCommand->getTarget();
257 }
258 }
259 else
260 {
261 double fBegin = 0.0;
262 double fDuration = 0.0;
263 xChildNode->getBegin() >>= fBegin;
264 xChildNode->getDuration() >>= fDuration;
265
266 fDuration += fBegin;
267 if( fDuration > mfDuration )
268 mfDuration = fDuration;
269
270 // no target shape yet?
271 if( !maTarget.hasValue() )
272 {
273 // go get it boys!
274 Reference< XAnimate > xAnimate( xChildNode, UNO_QUERY );
275 if( xAnimate.is() )
276 {
277 maTarget = xAnimate->getTarget();
278 mnTargetSubItem = xAnimate->getSubItem();
279 }
280 }
281 }
282 }
283 }
284 }
285
286 mfAbsoluteDuration = mfDuration;
287 checkForText();
288 }
289
290 // --------------------------------------------------------------------
291
292 sal_Int32 CustomAnimationEffect::getNumberOfSubitems( const Any& aTarget, sal_Int16 nIterateType )
293 {
294 sal_Int32 nSubItems = 0;
295
296 try
297 {
298 // first get target text
299 sal_Int32 nOnlyPara = -1;
300
301 Reference< XText > xShape;
302 aTarget >>= xShape;
303 if( !xShape.is() )
304 {
305 ParagraphTarget aParaTarget;
306 if( aTarget >>= aParaTarget )
307 {
308 xShape.set( aParaTarget.Shape, UNO_QUERY );
309 nOnlyPara = aParaTarget.Paragraph;
310 }
311 }
312
313 // now use the break iterator to iterate over the given text
314 // and count the sub items
315
316 if( xShape.is() )
317 {
318 // TODO/LATER: Optimize this, don't create a break iterator each time
319 Reference< lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() );
320 Reference < i18n::XBreakIterator > xBI( xMSF->createInstance( OUString::createFromAscii( "com.sun.star.i18n.BreakIterator" ) ), UNO_QUERY );
321 DBG_ASSERT( xBI.is(), "sd::CustomAnimationEffect::getNumberOfSubitems(), could not create a 'com.sun.star.i18n.BreakIterator'!" );
322
323 if( xBI.is() )
324 {
325 Reference< XEnumerationAccess > xEA( xShape, UNO_QUERY_THROW );
326 Reference< XEnumeration > xEnumeration( xEA->createEnumeration(), UNO_QUERY_THROW );
327 Locale aLocale;
328 const OUString aStrLocaleName( RTL_CONSTASCII_USTRINGPARAM("CharLocale") );
329 Reference< XTextRange > xParagraph;
330
331 sal_Int32 nPara = 0;
332 while( xEnumeration->hasMoreElements() )
333 {
334 xEnumeration->nextElement() >>= xParagraph;
335
336 // skip this if its not the only paragraph we want to count
337 if( (nOnlyPara != -1) && (nOnlyPara != nPara ) )
338 continue;
339
340 if( nIterateType == TextAnimationType::BY_PARAGRAPH )
341 {
342 nSubItems++;
343 }
344 else
345 {
346 const OUString aText( xParagraph->getString() );
347 Reference< XPropertySet > xSet( xParagraph, UNO_QUERY_THROW );
348 xSet->getPropertyValue( aStrLocaleName ) >>= aLocale;
349
350 sal_Int32 nPos;
351 const sal_Int32 nEndPos = aText.getLength();
352
353 if( nIterateType == TextAnimationType::BY_WORD )
354 {
355 for( nPos = 0; nPos < nEndPos; nPos++ )
356 {
357 nPos = xBI->getWordBoundary(aText, nPos, aLocale, i18n::WordType::ANY_WORD, sal_True).endPos;
358 nSubItems++;
359 }
360 break;
361 }
362 else
363 {
364 sal_Int32 nDone;
365 for( nPos = 0; nPos < nEndPos; nPos++ )
366 {
367 nPos = xBI->nextCharacters(aText, nPos, aLocale, i18n::CharacterIteratorMode::SKIPCELL, 0, nDone);
368 nSubItems++;
369 }
370 }
371 }
372
373 if( nPara == nOnlyPara )
374 break;
375
376 nPara++;
377 }
378 }
379 }
380 }
381 catch( Exception& e )
382 {
383 (void)e;
384 nSubItems = 0;
385 DBG_ERROR( "sd::CustomAnimationEffect::getNumberOfSubitems(), exception cought!" );
386 }
387
388 return nSubItems;
389 }
390
391 // --------------------------------------------------------------------
392
393 CustomAnimationEffect::~CustomAnimationEffect()
394 {
395 }
396
397 // --------------------------------------------------------------------
398
399 CustomAnimationEffectPtr CustomAnimationEffect::clone() const
400 {
401 Reference< XCloneable > xCloneable( mxNode, UNO_QUERY_THROW );
402 Reference< XAnimationNode > xNode( xCloneable->createClone(), UNO_QUERY_THROW );
403 CustomAnimationEffectPtr pEffect( new CustomAnimationEffect( xNode ) );
404 pEffect->setEffectSequence( getEffectSequence() );
405 return pEffect;
406 }
407
408 // --------------------------------------------------------------------
409
410 sal_Int32 CustomAnimationEffect::get_node_type( const Reference< XAnimationNode >& xNode )
411 {
412 sal_Int16 nNodeType = -1;
413
414 if( xNode.is() )
415 {
416 Sequence< NamedValue > aUserData( xNode->getUserData() );
417 sal_Int32 nLength = aUserData.getLength();
418 if( nLength )
419 {
420 const NamedValue* p = aUserData.getConstArray();
421 while( nLength-- )
422 {
423 if( p->Name.equalsAscii( "node-type" ) )
424 {
425 p->Value >>= nNodeType;
426 break;
427 }
428 p++;
429 }
430 }
431 }
432
433 return nNodeType;
434 }
435
436 // --------------------------------------------------------------------
437
438 void CustomAnimationEffect::setPresetClass( sal_Int16 nPresetClass )
439 {
440 if( mnPresetClass != nPresetClass )
441 {
442 mnPresetClass = nPresetClass;
443 if( mxNode.is() )
444 {
445 // first try to find a "preset-class" entry in the user data
446 // and change it
447 Sequence< NamedValue > aUserData( mxNode->getUserData() );
448 sal_Int32 nLength = aUserData.getLength();
449 bool bFound = false;
450 if( nLength )
451 {
452 NamedValue* p = aUserData.getArray();
453 while( nLength-- )
454 {
455 if( p->Name.equalsAscii( "preset-class" ) )
456 {
457 p->Value <<= mnPresetClass;
458 bFound = true;
459 break;
460 }
461 p++;
462 }
463 }
464
465 // no "node-type" entry inside user data, so add it
466 if( !bFound )
467 {
468 nLength = aUserData.getLength();
469 aUserData.realloc( nLength + 1);
470 aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "preset-class" ) );
471 aUserData[nLength].Value <<= mnPresetClass;
472 }
473
474 mxNode->setUserData( aUserData );
475 }
476 }
477 }
478
479 void CustomAnimationEffect::setNodeType( sal_Int16 nNodeType )
480 {
481 if( mnNodeType != nNodeType )
482 {
483 mnNodeType = nNodeType;
484 if( mxNode.is() )
485 {
486 // first try to find a "node-type" entry in the user data
487 // and change it
488 Sequence< NamedValue > aUserData( mxNode->getUserData() );
489 sal_Int32 nLength = aUserData.getLength();
490 bool bFound = false;
491 if( nLength )
492 {
493 NamedValue* p = aUserData.getArray();
494 while( nLength-- )
495 {
496 if( p->Name.equalsAscii( "node-type" ) )
497 {
498 p->Value <<= mnNodeType;
499 bFound = true;
500 break;
501 }
502 p++;
503 }
504 }
505
506 // no "node-type" entry inside user data, so add it
507 if( !bFound )
508 {
509 nLength = aUserData.getLength();
510 aUserData.realloc( nLength + 1);
511 aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
512 aUserData[nLength].Value <<= mnNodeType;
513 }
514
515 mxNode->setUserData( aUserData );
516 }
517 }
518 }
519
520 // --------------------------------------------------------------------
521
522 void CustomAnimationEffect::setGroupId( sal_Int32 nGroupId )
523 {
524 mnGroupId = nGroupId;
525 if( mxNode.is() )
526 {
527 // first try to find a "group-id" entry in the user data
528 // and change it
529 Sequence< NamedValue > aUserData( mxNode->getUserData() );
530 sal_Int32 nLength = aUserData.getLength();
531 bool bFound = false;
532 if( nLength )
533 {
534 NamedValue* p = aUserData.getArray();
535 while( nLength-- )
536 {
537 if( p->Name.equalsAscii( "group-id" ) )
538 {
539 p->Value <<= mnGroupId;
540 bFound = true;
541 break;
542 }
543 p++;
544 }
545 }
546
547 // no "node-type" entry inside user data, so add it
548 if( !bFound )
549 {
550 nLength = aUserData.getLength();
551 aUserData.realloc( nLength + 1);
552 aUserData[nLength].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "group-id" ) );
553 aUserData[nLength].Value <<= mnGroupId;
554 }
555
556 mxNode->setUserData( aUserData );
557 }
558 }
559
560 // --------------------------------------------------------------------
561
562 /** checks if the text for this effect has changed and updates internal flags.
563 returns true if something changed.
564 */
565 bool CustomAnimationEffect::checkForText()
566 {
567 bool bChange = false;
568
569 Reference< XText > xText;
570
571 if( maTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
572 {
573 // calc para depth
574 ParagraphTarget aParaTarget;
575 maTarget >>= aParaTarget;
576
577 xText = Reference< XText >::query( aParaTarget.Shape );
578
579 // get paragraph
580 if( xText.is() )
581 {
582 Reference< XEnumerationAccess > xEA( xText, UNO_QUERY );
583 if( xEA.is() )
584 {
585 Reference< XEnumeration > xEnumeration( xEA->createEnumeration(), UNO_QUERY );
586 if( xEnumeration.is() )
587 {
588 sal_Bool bHasText = xEnumeration->hasMoreElements();
589 bChange |= bHasText != mbHasText;
590 mbHasText = bHasText;
591
592 sal_Int32 nPara = aParaTarget.Paragraph;
593
594 while( xEnumeration->hasMoreElements() && nPara-- )
595 xEnumeration->nextElement();
596
597 if( xEnumeration->hasMoreElements() )
598 {
599 Reference< XPropertySet > xParaSet;
600 xEnumeration->nextElement() >>= xParaSet;
601 if( xParaSet.is() )
602 {
603 sal_Int32 nParaDepth = 0;
604 const OUString strNumberingLevel( RTL_CONSTASCII_USTRINGPARAM("NumberingLevel") );
605 xParaSet->getPropertyValue( strNumberingLevel ) >>= nParaDepth;
606 bChange |= nParaDepth != mnParaDepth;
607 mnParaDepth = nParaDepth;
608 }
609 }
610 }
611 }
612 }
613 }
614 else
615 {
616 maTarget >>= xText;
617 sal_Bool bHasText = xText.is() && xText->getString().getLength();
618 bChange |= bHasText != mbHasText;
619 mbHasText = bHasText;
620 }
621
622 bChange |= calculateIterateDuration();
623 return bChange;
624 }
625
626 bool CustomAnimationEffect::calculateIterateDuration()
627 {
628 bool bChange = false;
629
630 // if we have an iteration, we must also calculate the
631 // 'true' container duration, that is
632 // ( ( is form animated ) ? [contained effects duration] : 0 ) +
633 // ( [number of animated children] - 1 ) * [interval-delay] + [contained effects duration]
634 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
635 if( xIter.is() )
636 {
637 double fDuration = mfDuration;
638 const double fSubEffectDuration = mfDuration;
639
640 if( mnTargetSubItem != ShapeAnimationSubType::ONLY_BACKGROUND ) // does not make sense for iterate container but better check
641 {
642 const sal_Int32 nSubItems = getNumberOfSubitems( maTarget, mnIterateType );
643 if( nSubItems )
644 {
645 const double f = (nSubItems-1) * mfIterateInterval;
646 fDuration += f;
647 }
648 }
649
650 // if we also animate the form first, we have to add the
651 // sub effect duration to the whole effect duration
652 if( mnTargetSubItem == ShapeAnimationSubType::AS_WHOLE )
653 fDuration += fSubEffectDuration;
654
655 bChange |= fDuration != mfAbsoluteDuration;
656 mfAbsoluteDuration = fDuration;
657 }
658
659 return bChange;
660 }
661
662 // --------------------------------------------------------------------
663
664 void CustomAnimationEffect::setTarget( const ::com::sun::star::uno::Any& rTarget )
665 {
666 try
667 {
668 maTarget = rTarget;
669
670 // first, check special case for random node
671 Reference< XInitialization > xInit( mxNode, UNO_QUERY );
672 if( xInit.is() )
673 {
674 const Sequence< Any > aArgs( &maTarget, 1 );
675 xInit->initialize( aArgs );
676 }
677 else
678 {
679 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
680 if( xIter.is() )
681 {
682 xIter->setTarget(maTarget);
683 }
684 else
685 {
686 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
687 if( xEnumerationAccess.is() )
688 {
689 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
690 if( xEnumeration.is() )
691 {
692 while( xEnumeration->hasMoreElements() )
693 {
694 const Any aElem( xEnumeration->nextElement() );
695 Reference< XAnimate > xAnimate( aElem, UNO_QUERY );
696 if( xAnimate.is() )
697 xAnimate->setTarget( rTarget );
698 else
699 {
700 Reference< XCommand > xCommand( aElem, UNO_QUERY );
701 if( xCommand.is() )
702 xCommand->setTarget( rTarget );
703 }
704 }
705 }
706 }
707 }
708 }
709 checkForText();
710 }
711 catch( Exception& )
712 {
713 DBG_ERROR( "sd::CustomAnimationEffect::setTarget(), exception cought!" );
714 }
715 }
716
717 // --------------------------------------------------------------------
718
719 void CustomAnimationEffect::setTargetSubItem( sal_Int16 nSubItem )
720 {
721 try
722 {
723 mnTargetSubItem = nSubItem;
724
725 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
726 if( xIter.is() )
727 {
728 xIter->setSubItem(mnTargetSubItem);
729 }
730 else
731 {
732 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
733 if( xEnumerationAccess.is() )
734 {
735 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
736 if( xEnumeration.is() )
737 {
738 while( xEnumeration->hasMoreElements() )
739 {
740 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
741 if( xAnimate.is() )
742 xAnimate->setSubItem( mnTargetSubItem );
743 }
744 }
745 }
746 }
747 }
748 catch( Exception& )
749 {
750 DBG_ERROR( "sd::CustomAnimationEffect::setTargetSubItem(), exception cought!" );
751 }
752 }
753
754 // --------------------------------------------------------------------
755
756 void CustomAnimationEffect::setDuration( double fDuration )
757 {
758 if( (mfDuration != -1.0) && (mfDuration != fDuration) ) try
759 {
760 double fScale = fDuration / mfDuration;
761 mfDuration = fDuration;
762 mfAbsoluteDuration = mfDuration;
763
764 // calculate effect duration and get target shape
765 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
766 if( xEnumerationAccess.is() )
767 {
768 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
769 if( xEnumeration.is() )
770 {
771 while( xEnumeration->hasMoreElements() )
772 {
773 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY );
774 if( !xChildNode.is() )
775 continue;
776
777
778 double fChildBegin = 0.0;
779 xChildNode->getBegin() >>= fChildBegin;
780 if( fChildBegin != 0.0 )
781 {
782 fChildBegin *= fScale;
783 xChildNode->setBegin( makeAny( fChildBegin ) );
784 }
785
786 double fChildDuration = 0.0;
787 xChildNode->getDuration() >>= fChildDuration;
788 if( fChildDuration != 0.0 )
789 {
790 fChildDuration *= fScale;
791 xChildNode->setDuration( makeAny( fChildDuration ) );
792 }
793 }
794 }
795 }
796 calculateIterateDuration();
797 }
798 catch( Exception& )
799 {
800 DBG_ERROR( "sd::CustomAnimationEffect::setDuration(), exception cought!" );
801 }
802 }
803
804 // --------------------------------------------------------------------
805
806 void CustomAnimationEffect::setBegin( double fBegin )
807 {
808 if( mxNode.is() ) try
809 {
810 mfBegin = fBegin;
811 mxNode->setBegin( makeAny( fBegin ) );
812 }
813 catch( Exception& )
814 {
815 DBG_ERROR( "sd::CustomAnimationEffect::setBegin(), exception cought!" );
816 }
817 }
818
819 // --------------------------------------------------------------------
820
821 void CustomAnimationEffect::setAcceleration( double fAcceleration )
822 {
823 if( mxNode.is() ) try
824 {
825 mfAcceleration = fAcceleration;
826 mxNode->setAcceleration( fAcceleration );
827 }
828 catch( Exception& )
829 {
830 DBG_ERROR( "sd::CustomAnimationEffect::setAcceleration(), exception cought!" );
831 }
832 }
833 // --------------------------------------------------------------------
834
835 void CustomAnimationEffect::setDecelerate( double fDecelerate )
836 {
837 if( mxNode.is() ) try
838 {
839 mfDecelerate = fDecelerate;
840 mxNode->setDecelerate( fDecelerate );
841 }
842 catch( Exception& )
843 {
844 DBG_ERROR( "sd::CustomAnimationEffect::setDecelerate(), exception cought!" );
845 }
846 }
847
848 // --------------------------------------------------------------------
849
850 void CustomAnimationEffect::setAutoReverse( sal_Bool bAutoReverse )
851 {
852 if( mxNode.is() ) try
853 {
854 mbAutoReverse = bAutoReverse;
855 mxNode->setAutoReverse( bAutoReverse );
856 }
857 catch( Exception& )
858 {
859 DBG_ERROR( "sd::CustomAnimationEffect::setAutoReverse(), exception cought!" );
860 }
861 }
862
863 // --------------------------------------------------------------------
864
865 void CustomAnimationEffect::replaceNode( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
866 {
867 sal_Int16 nNodeType = mnNodeType;
868 Any aTarget = maTarget;
869
870 double fBegin = mfBegin;
871 double fDuration = mfDuration;
872 double fAcceleration = mfAcceleration;
873 double fDecelerate = mfDecelerate ;
874 sal_Bool bAutoReverse = mbAutoReverse;
875 Reference< XAudio > xAudio( mxAudio );
876 sal_Int16 nIterateType = mnIterateType;
877 double fIterateInterval = mfIterateInterval;
878 sal_Int16 nSubItem = mnTargetSubItem;
879
880 setNode( xNode );
881
882 setAudio( xAudio );
883 setNodeType( nNodeType );
884 setTarget( aTarget );
885 setTargetSubItem( nSubItem );
886 setDuration( fDuration );
887 setBegin( fBegin );
888
889 setAcceleration( fAcceleration );
890 setDecelerate( fDecelerate );
891 setAutoReverse( bAutoReverse );
892
893 if( nIterateType != mnIterateType )
894 setIterateType( nIterateType );
895
896 if( mnIterateType && ( fIterateInterval != mfIterateInterval ) )
897 setIterateInterval( fIterateInterval );
898 }
899
900 // --------------------------------------------------------------------
901
902 Reference< XShape > CustomAnimationEffect::getTargetShape() const
903 {
904 Reference< XShape > xShape;
905 maTarget >>= xShape;
906 if( !xShape.is() )
907 {
908 ParagraphTarget aParaTarget;
909 if( maTarget >>= aParaTarget )
910 xShape = aParaTarget.Shape;
911 }
912
913 return xShape;
914 }
915
916 // --------------------------------------------------------------------
917
918 Any CustomAnimationEffect::getRepeatCount() const
919 {
920 if( mxNode.is() )
921 {
922 return mxNode->getRepeatCount();
923 }
924 else
925 {
926 Any aAny;
927 return aAny;
928 }
929 }
930
931 // --------------------------------------------------------------------
932
933 Any CustomAnimationEffect::getEnd() const
934 {
935 if( mxNode.is() )
936 {
937 return mxNode->getEnd();
938 }
939 else
940 {
941 Any aAny;
942 return aAny;
943 }
944 }
945
946 // --------------------------------------------------------------------
947
948 sal_Int16 CustomAnimationEffect::getFill() const
949 {
950 if( mxNode.is() )
951 return mxNode->getFill();
952 else
953 return 0;
954 }
955
956 // --------------------------------------------------------------------
957
958 void CustomAnimationEffect::setRepeatCount( const Any& rRepeatCount )
959 {
960 if( mxNode.is() )
961 mxNode->setRepeatCount( rRepeatCount );
962 }
963
964 // --------------------------------------------------------------------
965
966 void CustomAnimationEffect::setEnd( const Any& rEnd )
967 {
968 if( mxNode.is() )
969 mxNode->setEnd( rEnd );
970 }
971
972 // --------------------------------------------------------------------
973
974 void CustomAnimationEffect::setFill( sal_Int16 nFill )
975 {
976 if( mxNode.is() )
977 mxNode->setFill( nFill );
978 }
979
980 // --------------------------------------------------------------------
981
982 Reference< XAnimationNode > CustomAnimationEffect::createAfterEffectNode() const throw (Exception)
983 {
984 DBG_ASSERT( mbHasAfterEffect, "sd::CustomAnimationEffect::createAfterEffectNode(), this node has no after effect!" );
985
986 Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
987
988 const char* pServiceName = maDimColor.hasValue() ?
989 "com.sun.star.animations.AnimateColor" : "com.sun.star.animations.AnimateSet";
990
991 Reference< XAnimate > xAnimate( xMsf->createInstance(OUString::createFromAscii(pServiceName) ), UNO_QUERY_THROW );
992
993 Any aTo;
994 OUString aAttributeName;
995
996 if( maDimColor.hasValue() )
997 {
998 aTo = maDimColor;
999 aAttributeName = OUString( RTL_CONSTASCII_USTRINGPARAM( "DimColor" ) );
1000 }
1001 else
1002 {
1003 aTo = makeAny( (sal_Bool)sal_False );
1004 aAttributeName = OUString( RTL_CONSTASCII_USTRINGPARAM( "Visibility" ) );
1005 }
1006
1007 Any aBegin;
1008 if( !mbAfterEffectOnNextEffect ) // sameClick
1009 {
1010 Event aEvent;
1011
1012 aEvent.Source <<= getNode();
1013 aEvent.Trigger = EventTrigger::END_EVENT;
1014 aEvent.Repeat = 0;
1015
1016 aBegin <<= aEvent;
1017 }
1018 else
1019 {
1020 aBegin <<= (double)0.0;
1021 }
1022
1023 xAnimate->setBegin( aBegin );
1024 xAnimate->setTo( aTo );
1025 xAnimate->setAttributeName( aAttributeName );
1026
1027 xAnimate->setDuration( makeAny( (double)0.001 ) );
1028 xAnimate->setFill( AnimationFill::HOLD );
1029 xAnimate->setTarget( maTarget );
1030
1031 return Reference< XAnimationNode >( xAnimate, UNO_QUERY_THROW );
1032 }
1033
1034 // --------------------------------------------------------------------
1035
1036 void CustomAnimationEffect::setIterateType( sal_Int16 nIterateType )
1037 {
1038 if( mnIterateType != nIterateType ) try
1039 {
1040 // do we need to exchange the container node?
1041 if( (mnIterateType == 0) || (nIterateType == 0) )
1042 {
1043 sal_Int16 nTargetSubItem = mnTargetSubItem;
1044
1045 Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
1046 const char * pServiceName =
1047 nIterateType ? "com.sun.star.animations.IterateContainer" : "com.sun.star.animations.ParallelTimeContainer";
1048 Reference< XTimeContainer > xNewContainer(
1049 xMsf->createInstance( OUString::createFromAscii(pServiceName) ), UNO_QUERY_THROW );
1050
1051 Reference< XTimeContainer > xOldContainer( mxNode, UNO_QUERY_THROW );
1052 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
1053 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1054 while( xEnumeration->hasMoreElements() )
1055 {
1056 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
1057 xOldContainer->removeChild( xChildNode );
1058 xNewContainer->appendChild( xChildNode );
1059 }
1060
1061 Reference< XAnimationNode > xNewNode( xNewContainer, UNO_QUERY_THROW );
1062
1063 xNewNode->setBegin( mxNode->getBegin() );
1064 xNewNode->setDuration( mxNode->getDuration() );
1065 xNewNode->setEnd( mxNode->getEnd() );
1066 xNewNode->setEndSync( mxNode->getEndSync() );
1067 xNewNode->setRepeatCount( mxNode->getRepeatCount() );
1068 xNewNode->setFill( mxNode->getFill() );
1069 xNewNode->setFillDefault( mxNode->getFillDefault() );
1070 xNewNode->setRestart( mxNode->getRestart() );
1071 xNewNode->setRestartDefault( mxNode->getRestartDefault() );
1072 xNewNode->setAcceleration( mxNode->getAcceleration() );
1073 xNewNode->setDecelerate( mxNode->getDecelerate() );
1074 xNewNode->setAutoReverse( mxNode->getAutoReverse() );
1075 xNewNode->setRepeatDuration( mxNode->getRepeatDuration() );
1076 xNewNode->setEndSync( mxNode->getEndSync() );
1077 xNewNode->setRepeatCount( mxNode->getRepeatCount() );
1078 xNewNode->setUserData( mxNode->getUserData() );
1079
1080 mxNode = xNewNode;
1081
1082 Any aTarget;
1083 if( nIterateType )
1084 {
1085 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY_THROW );
1086 xIter->setTarget(maTarget);
1087 xIter->setSubItem( nTargetSubItem );
1088 }
1089 else
1090 {
1091 aTarget = maTarget;
1092 }
1093
1094 Reference< XEnumerationAccess > xEA( mxNode, UNO_QUERY_THROW );
1095 Reference< XEnumeration > xE( xEA->createEnumeration(), UNO_QUERY_THROW );
1096 while( xE->hasMoreElements() )
1097 {
1098 Reference< XAnimate > xAnimate( xE->nextElement(), UNO_QUERY );
1099 if( xAnimate.is() )
1100 {
1101 xAnimate->setTarget( aTarget );
1102 xAnimate->setSubItem( nTargetSubItem );
1103 }
1104 }
1105 }
1106
1107 mnIterateType = nIterateType;
1108
1109 // if we have an iteration container, we must set its type
1110 if( mnIterateType )
1111 {
1112 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY_THROW );
1113 xIter->setIterateType( nIterateType );
1114 }
1115
1116 checkForText();
1117 }
1118 catch( Exception& e )
1119 {
1120 (void)e;
1121 DBG_ERROR( "sd::CustomAnimationEffect::setIterateType(), Exception cought!" );
1122 }
1123 }
1124
1125 // --------------------------------------------------------------------
1126
1127 void CustomAnimationEffect::setIterateInterval( double fIterateInterval )
1128 {
1129 if( mfIterateInterval != fIterateInterval )
1130 {
1131 Reference< XIterateContainer > xIter( mxNode, UNO_QUERY );
1132
1133 DBG_ASSERT( xIter.is(), "sd::CustomAnimationEffect::setIterateInterval(), not an iteration node" );
1134 if( xIter.is() )
1135 {
1136 mfIterateInterval = fIterateInterval;
1137 xIter->setIterateInterval( fIterateInterval );
1138 }
1139
1140 calculateIterateDuration();
1141 }
1142 }
1143
1144 // --------------------------------------------------------------------
1145
1146 ::rtl::OUString CustomAnimationEffect::getPath() const
1147 {
1148 ::rtl::OUString aPath;
1149
1150 if( mxNode.is() ) try
1151 {
1152 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
1153 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1154 while( xEnumeration->hasMoreElements() )
1155 {
1156 Reference< XAnimateMotion > xMotion( xEnumeration->nextElement(), UNO_QUERY );
1157 if( xMotion.is() )
1158 {
1159 xMotion->getPath() >>= aPath;
1160 break;
1161 }
1162 }
1163 }
1164 catch( Exception& e )
1165 {
1166 (void)e;
1167 DBG_ERROR("sd::CustomAnimationEffect::getPath(), exception cought!" );
1168 }
1169
1170 return aPath;
1171 }
1172
1173 // --------------------------------------------------------------------
1174
1175 void CustomAnimationEffect::setPath( const ::rtl::OUString& rPath )
1176 {
1177 if( mxNode.is() ) try
1178 {
1179 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY_THROW );
1180 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1181 while( xEnumeration->hasMoreElements() )
1182 {
1183 Reference< XAnimateMotion > xMotion( xEnumeration->nextElement(), UNO_QUERY );
1184 if( xMotion.is() )
1185 {
1186
1187 MainSequenceChangeGuard aGuard( mpEffectSequence );
1188 xMotion->setPath( Any( rPath ) );
1189 break;
1190 }
1191 }
1192 }
1193 catch( Exception& e )
1194 {
1195 (void)e;
1196 DBG_ERROR("sd::CustomAnimationEffect::setPath(), exception cought!" );
1197 }
1198 }
1199
1200 // --------------------------------------------------------------------
1201
1202 Any CustomAnimationEffect::getProperty( sal_Int32 nNodeType, const OUString& rAttributeName, EValue eValue )
1203 {
1204 Any aProperty;
1205 if( mxNode.is() ) try
1206 {
1207 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1208 if( xEnumerationAccess.is() )
1209 {
1210 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1211 if( xEnumeration.is() )
1212 {
1213 while( xEnumeration->hasMoreElements() && !aProperty.hasValue() )
1214 {
1215 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
1216 if( !xAnimate.is() )
1217 continue;
1218
1219 if( xAnimate->getType() == nNodeType )
1220 {
1221 if( xAnimate->getAttributeName() == rAttributeName )
1222 {
1223 switch( eValue )
1224 {
1225 case VALUE_FROM: aProperty = xAnimate->getFrom(); break;
1226 case VALUE_TO: aProperty = xAnimate->getTo(); break;
1227 case VALUE_BY: aProperty = xAnimate->getBy(); break;
1228 case VALUE_FIRST:
1229 case VALUE_LAST:
1230 {
1231 Sequence<Any> aValues( xAnimate->getValues() );
1232 if( aValues.hasElements() )
1233 aProperty = aValues[ eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1 ];
1234 }
1235 break;
1236 }
1237 }
1238 }
1239 }
1240 }
1241 }
1242 }
1243 catch( Exception& e )
1244 {
1245 (void)e;
1246 DBG_ERROR("sd::CustomAnimationEffect::getProperty(), exception cought!" );
1247 }
1248
1249 return aProperty;
1250 }
1251
1252 // --------------------------------------------------------------------
1253
1254 bool CustomAnimationEffect::setProperty( sal_Int32 nNodeType, const OUString& rAttributeName, EValue eValue, const Any& rValue )
1255 {
1256 bool bChanged = false;
1257 if( mxNode.is() ) try
1258 {
1259 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1260 if( xEnumerationAccess.is() )
1261 {
1262 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1263 if( xEnumeration.is() )
1264 {
1265 while( xEnumeration->hasMoreElements() )
1266 {
1267 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
1268 if( !xAnimate.is() )
1269 continue;
1270
1271 if( xAnimate->getType() == nNodeType )
1272 {
1273 if( xAnimate->getAttributeName() == rAttributeName )
1274 {
1275 switch( eValue )
1276 {
1277 case VALUE_FROM:
1278 if( xAnimate->getFrom() != rValue )
1279 {
1280 xAnimate->setFrom( rValue );
1281 bChanged = true;
1282 }
1283 break;
1284 case VALUE_TO:
1285 if( xAnimate->getTo() != rValue )
1286 {
1287 xAnimate->setTo( rValue );
1288 bChanged = true;
1289 }
1290 break;
1291 case VALUE_BY:
1292 if( xAnimate->getTo() != rValue )
1293 {
1294 xAnimate->setBy( rValue );
1295 bChanged = true;
1296 }
1297 break;
1298 case VALUE_FIRST:
1299 case VALUE_LAST:
1300 {
1301 Sequence<Any> aValues( xAnimate->getValues() );
1302 if( !aValues.hasElements() )
1303 aValues.realloc(1);
1304
1305 sal_Int32 nIndex = eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1;
1306
1307 if( aValues[ nIndex ] != rValue )
1308 {
1309 aValues[ nIndex ] = rValue;
1310 xAnimate->setValues( aValues );
1311 bChanged = true;
1312 }
1313 }
1314 }
1315 }
1316 }
1317 }
1318 }
1319 }
1320 }
1321 catch( Exception& e )
1322 {
1323 (void)e;
1324 DBG_ERROR("sd::CustomAnimationEffect::setProperty(), exception cought!" );
1325 }
1326
1327 return bChanged;
1328 }
1329
1330 // --------------------------------------------------------------------
1331
1332 static bool implIsColorAttribute( const OUString& rAttributeName )
1333 {
1334 return rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("FillColor") ) ||
1335 rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("LineColor") ) ||
1336 rAttributeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("CharColor") );
1337 }
1338
1339 // --------------------------------------------------------------------
1340
1341 Any CustomAnimationEffect::getColor( sal_Int32 nIndex )
1342 {
1343 Any aColor;
1344 if( mxNode.is() ) try
1345 {
1346 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1347 if( xEnumerationAccess.is() )
1348 {
1349 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1350 if( xEnumeration.is() )
1351 {
1352 while( xEnumeration->hasMoreElements() && !aColor.hasValue() )
1353 {
1354 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
1355 if( !xAnimate.is() )
1356 continue;
1357
1358 switch( xAnimate->getType() )
1359 {
1360 case AnimationNodeType::SET:
1361 case AnimationNodeType::ANIMATE:
1362 if( !implIsColorAttribute( xAnimate->getAttributeName() ) )
1363 break;
1364 case AnimationNodeType::ANIMATECOLOR:
1365 Sequence<Any> aValues( xAnimate->getValues() );
1366 if( aValues.hasElements() )
1367 {
1368 if( aValues.getLength() > nIndex )
1369 aColor = aValues[nIndex];
1370 }
1371 else if( nIndex == 0 )
1372 aColor = xAnimate->getFrom();
1373 else
1374 aColor = xAnimate->getTo();
1375 }
1376 }
1377 }
1378 }
1379 }
1380 catch( Exception& e )
1381 {
1382 (void)e;
1383 DBG_ERROR("sd::CustomAnimationEffect::getColor(), exception cought!" );
1384 }
1385
1386 return aColor;
1387 }
1388
1389 // --------------------------------------------------------------------
1390
1391 void CustomAnimationEffect::setColor( sal_Int32 nIndex, const Any& rColor )
1392 {
1393 if( mxNode.is() ) try
1394 {
1395 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1396 if( xEnumerationAccess.is() )
1397 {
1398 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1399 if( xEnumeration.is() )
1400 {
1401 while( xEnumeration->hasMoreElements() )
1402 {
1403 Reference< XAnimate > xAnimate( xEnumeration->nextElement(), UNO_QUERY );
1404 if( !xAnimate.is() )
1405 continue;
1406
1407 switch( xAnimate->getType() )
1408 {
1409 case AnimationNodeType::SET:
1410 case AnimationNodeType::ANIMATE:
1411 if( !implIsColorAttribute( xAnimate->getAttributeName() ) )
1412 break;
1413 case AnimationNodeType::ANIMATECOLOR:
1414 {
1415 Sequence<Any> aValues( xAnimate->getValues() );
1416 if( aValues.hasElements() )
1417 {
1418 if( aValues.getLength() > nIndex )
1419 {
1420 aValues[nIndex] = rColor;
1421 xAnimate->setValues( aValues );
1422 }
1423 }
1424 else if( (nIndex == 0) && xAnimate->getFrom().hasValue() )
1425 xAnimate->setFrom(rColor);
1426 else if( (nIndex == 1) && xAnimate->getTo().hasValue() )
1427 xAnimate->setTo(rColor);
1428 }
1429 break;
1430
1431 }
1432 }
1433 }
1434 }
1435 }
1436 catch( Exception& e )
1437 {
1438 (void)e;
1439 DBG_ERROR("sd::CustomAnimationEffect::setColor(), exception cought!" );
1440 }
1441 }
1442
1443 // --------------------------------------------------------------------
1444
1445 Any CustomAnimationEffect::getTransformationProperty( sal_Int32 nTransformType, EValue eValue )
1446 {
1447 Any aProperty;
1448 if( mxNode.is() ) try
1449 {
1450 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1451 if( xEnumerationAccess.is() )
1452 {
1453 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1454 if( xEnumeration.is() )
1455 {
1456 while( xEnumeration->hasMoreElements() && !aProperty.hasValue() )
1457 {
1458 Reference< XAnimateTransform > xTransform( xEnumeration->nextElement(), UNO_QUERY );
1459 if( !xTransform.is() )
1460 continue;
1461
1462 if( xTransform->getTransformType() == nTransformType )
1463 {
1464 switch( eValue )
1465 {
1466 case VALUE_FROM: aProperty = xTransform->getFrom(); break;
1467 case VALUE_TO: aProperty = xTransform->getTo(); break;
1468 case VALUE_BY: aProperty = xTransform->getBy(); break;
1469 case VALUE_FIRST:
1470 case VALUE_LAST:
1471 {
1472 Sequence<Any> aValues( xTransform->getValues() );
1473 if( aValues.hasElements() )
1474 aProperty = aValues[ eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1 ];
1475 }
1476 break;
1477 }
1478 }
1479 }
1480 }
1481 }
1482 }
1483 catch( Exception& e )
1484 {
1485 (void)e;
1486 DBG_ERROR("sd::CustomAnimationEffect::getTransformationProperty(), exception cought!" );
1487 }
1488
1489 return aProperty;
1490 }
1491
1492 // --------------------------------------------------------------------
1493
1494 bool CustomAnimationEffect::setTransformationProperty( sal_Int32 nTransformType, EValue eValue, const Any& rValue )
1495 {
1496 bool bChanged = false;
1497 if( mxNode.is() ) try
1498 {
1499 Reference< XEnumerationAccess > xEnumerationAccess( mxNode, UNO_QUERY );
1500 if( xEnumerationAccess.is() )
1501 {
1502 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY );
1503 if( xEnumeration.is() )
1504 {
1505 while( xEnumeration->hasMoreElements() )
1506 {
1507 Reference< XAnimateTransform > xTransform( xEnumeration->nextElement(), UNO_QUERY );
1508 if( !xTransform.is() )
1509 continue;
1510
1511 if( xTransform->getTransformType() == nTransformType )
1512 {
1513 switch( eValue )
1514 {
1515 case VALUE_FROM:
1516 if( xTransform->getFrom() != rValue )
1517 {
1518 xTransform->setFrom( rValue );
1519 bChanged = true;
1520 }
1521 break;
1522 case VALUE_TO:
1523 if( xTransform->getTo() != rValue )
1524 {
1525 xTransform->setTo( rValue );
1526 bChanged = true;
1527 }
1528 break;
1529 case VALUE_BY:
1530 if( xTransform->getBy() != rValue )
1531 {
1532 xTransform->setBy( rValue );
1533 bChanged = true;
1534 }
1535 break;
1536 case VALUE_FIRST:
1537 case VALUE_LAST:
1538 {
1539 Sequence<Any> aValues( xTransform->getValues() );
1540 if( !aValues.hasElements() )
1541 aValues.realloc(1);
1542
1543 sal_Int32 nIndex = eValue == VALUE_FIRST ? 0 : aValues.getLength() - 1;
1544 if( aValues[nIndex] != rValue )
1545 {
1546 aValues[nIndex] = rValue;
1547 xTransform->setValues( aValues );
1548 bChanged = true;
1549 }
1550 }
1551 }
1552 }
1553 }
1554 }
1555 }
1556 }
1557 catch( Exception& e )
1558 {
1559 (void)e;
1560 DBG_ERROR("sd::CustomAnimationEffect::setTransformationProperty(), exception cought!" );
1561 }
1562
1563 return bChanged;
1564 }
1565
1566 // --------------------------------------------------------------------
1567
1568 void CustomAnimationEffect::createAudio( const ::com::sun::star::uno::Any& rSource, double fVolume /* = 1.0 */ )
1569 {
1570 DBG_ASSERT( !mxAudio.is(), "sd::CustomAnimationEffect::createAudio(), node already has an audio!" );
1571
1572 if( !mxAudio.is() ) try
1573 {
1574 Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
1575 Reference< XAudio > xAudio( xMsf->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.Audio") ) ), UNO_QUERY_THROW );
1576 xAudio->setSource( rSource );
1577 xAudio->setVolume( fVolume );
1578 setAudio( xAudio );
1579 }
1580 catch( Exception& e )
1581 {
1582 (void)e;
1583 DBG_ERROR("sd::CustomAnimationEffect::createAudio(), exception cought!" );
1584 }
1585 }
1586
1587 // --------------------------------------------------------------------
1588
1589 static Reference< XCommand > findCommandNode( const Reference< XAnimationNode >& xRootNode )
1590 {
1591 Reference< XCommand > xCommand;
1592
1593 if( xRootNode.is() ) try
1594 {
1595 Reference< XEnumerationAccess > xEnumerationAccess( xRootNode, UNO_QUERY_THROW );
1596 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
1597 while( !xCommand.is() && xEnumeration->hasMoreElements() )
1598 {
1599 Reference< XAnimationNode > xNode( xEnumeration->nextElement(), UNO_QUERY );
1600 if( xNode.is() && (xNode->getType() == AnimationNodeType::COMMAND) )
1601 xCommand.set( xNode, UNO_QUERY_THROW );
1602 }
1603 }
1604 catch( Exception& e )
1605 {
1606 (void)e;
1607 DBG_ERROR("sd::findCommandNode(), exception caught!" );
1608 }
1609
1610 return xCommand;
1611 }
1612
1613 void CustomAnimationEffect::removeAudio()
1614 {
1615 try
1616 {
1617 Reference< XAnimationNode > xChild;
1618
1619 if( mxAudio.is() )
1620 {
1621 xChild.set( mxAudio, UNO_QUERY );
1622 mxAudio.clear();
1623 }
1624 else if( mnCommand == EffectCommands::STOPAUDIO )
1625 {
1626 xChild.set( findCommandNode( mxNode ), UNO_QUERY );
1627 mnCommand = 0;
1628 }
1629
1630 if( xChild.is() )
1631 {
1632 Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY );
1633 if( xContainer.is() )
1634 xContainer->removeChild( xChild );
1635 }
1636 }
1637 catch( Exception& e )
1638 {
1639 (void)e;
1640 DBG_ERROR("sd::CustomAnimationEffect::removeAudio(), exception caught!" );
1641 }
1642
1643 }
1644
1645 // --------------------------------------------------------------------
1646
1647 void CustomAnimationEffect::setAudio( const Reference< ::com::sun::star::animations::XAudio >& xAudio )
1648 {
1649 if( mxAudio != xAudio ) try
1650 {
1651 removeAudio();
1652 mxAudio = xAudio;
1653 Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY );
1654 Reference< XAnimationNode > xChild( mxAudio, UNO_QUERY );
1655 if( xContainer.is() && xChild.is() )
1656 xContainer->appendChild( xChild );
1657 }
1658 catch( Exception& e )
1659 {
1660 (void)e;
1661 DBG_ERROR("sd::CustomAnimationEffect::setAudio(), exception caught!" );
1662 }
1663 }
1664
1665 // --------------------------------------------------------------------
1666
1667 void CustomAnimationEffect::setStopAudio()
1668 {
1669 if( mnCommand != EffectCommands::STOPAUDIO ) try
1670 {
1671 if( mxAudio.is() )
1672 removeAudio();
1673
1674 Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
1675 Reference< XCommand > xCommand( xMsf->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.Command") ) ), UNO_QUERY_THROW );
1676
1677 xCommand->setCommand( EffectCommands::STOPAUDIO );
1678
1679 Reference< XTimeContainer > xContainer( mxNode, UNO_QUERY_THROW );
1680 Reference< XAnimationNode > xChild( xCommand, UNO_QUERY_THROW );
1681 xContainer->appendChild( xChild );
1682
1683 mnCommand = EffectCommands::STOPAUDIO;
1684 }
1685 catch( Exception& e )
1686 {
1687 (void)e;
1688 DBG_ERROR("sd::CustomAnimationEffect::setStopAudio(), exception caught!" );
1689 }
1690 }
1691
1692 // --------------------------------------------------------------------
1693
1694 bool CustomAnimationEffect::getStopAudio() const
1695 {
1696 return mnCommand == EffectCommands::STOPAUDIO;
1697 }
1698
1699 // --------------------------------------------------------------------
1700
1701 SdrPathObj* CustomAnimationEffect::createSdrPathObjFromPath()
1702 {
1703 SdrPathObj * pPathObj = new SdrPathObj( OBJ_PATHLINE );
1704 updateSdrPathObjFromPath( *pPathObj );
1705 return pPathObj;
1706 }
1707
1708 // --------------------------------------------------------------------
1709
1710 void CustomAnimationEffect::updateSdrPathObjFromPath( SdrPathObj& rPathObj )
1711 {
1712 ::basegfx::B2DPolyPolygon xPolyPoly;
1713 if( ::basegfx::tools::importFromSvgD( xPolyPoly, getPath() ) )
1714 {
1715 SdrObject* pObj = GetSdrObjectFromXShape( getTargetShape() );
1716 if( pObj )
1717 {
1718 ::basegfx::B2DHomMatrix aTransform;
1719
1720 SdrPage* pPage = pObj->GetPage();
1721 if( pPage )
1722 {
1723 const Size aPageSize( pPage->GetSize() );
1724 aTransform.scale( (double)aPageSize.Width(), (double)aPageSize.Height() );
1725 xPolyPoly.transform( aTransform );
1726 aTransform.identity();
1727 }
1728
1729 const Rectangle aBoundRect( pObj->GetCurrentBoundRect() );
1730 const Point aCenter( aBoundRect.Center() );
1731 aTransform.translate( aCenter.X(), aCenter.Y() );
1732 xPolyPoly.transform( aTransform );
1733 }
1734 }
1735
1736 rPathObj.SetPathPoly( xPolyPoly );
1737 }
1738
1739 // --------------------------------------------------------------------
1740
1741 void CustomAnimationEffect::updatePathFromSdrPathObj( const SdrPathObj& rPathObj )
1742 {
1743 ::basegfx::B2DPolyPolygon xPolyPoly( rPathObj.GetPathPoly() );
1744
1745 SdrObject* pObj = GetSdrObjectFromXShape( getTargetShape() );
1746 if( pObj )
1747 {
1748 const Rectangle aBoundRect( pObj->GetCurrentBoundRect() );
1749 const Point aCenter( aBoundRect.Center() );
1750
1751 ::basegfx::B2DHomMatrix aTransform;
1752 aTransform.translate( -aCenter.X(), -aCenter.Y() );
1753 xPolyPoly.transform( aTransform );
1754
1755 SdrPage* pPage = pObj->GetPage();
1756 if( pPage )
1757 {
1758 aTransform.identity();
1759 const Size aPageSize( pPage->GetSize() );
1760 aTransform.scale( 1.0 / (double)aPageSize.Width(), 1.0 / (double)aPageSize.Height() );
1761 xPolyPoly.transform( aTransform );
1762 }
1763 }
1764
1765 setPath( ::basegfx::tools::exportToSvgD( xPolyPoly ) );
1766 }
1767
1768 // ====================================================================
1769
1770 EffectSequenceHelper::EffectSequenceHelper()
1771 : mnSequenceType( EffectNodeType::DEFAULT )
1772 {
1773 }
1774
1775 // --------------------------------------------------------------------
1776
1777 EffectSequenceHelper::EffectSequenceHelper( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XTimeContainer >& xSequenceRoot )
1778 : mxSequenceRoot( xSequenceRoot ), mnSequenceType( EffectNodeType::DEFAULT )
1779 {
1780 Reference< XAnimationNode > xNode( mxSequenceRoot, UNO_QUERY_THROW );
1781 create( xNode );
1782 }
1783
1784 // --------------------------------------------------------------------
1785
1786 EffectSequenceHelper::~EffectSequenceHelper()
1787 {
1788 reset();
1789 }
1790
1791 // --------------------------------------------------------------------
1792
1793 void EffectSequenceHelper::reset()
1794 {
1795 EffectSequence::iterator aIter( maEffects.begin() );
1796 EffectSequence::iterator aEnd( maEffects.end() );
1797 if( aIter != aEnd )
1798 {
1799 CustomAnimationEffectPtr pEffect = (*aIter++);
1800 pEffect->setEffectSequence(0);
1801 }
1802 maEffects.clear();
1803 }
1804
1805 Reference< XAnimationNode > EffectSequenceHelper::getRootNode()
1806 {
1807 Reference< XAnimationNode > xRoot( mxSequenceRoot, UNO_QUERY );
1808 return xRoot;
1809 }
1810
1811 // --------------------------------------------------------------------
1812
1813 void EffectSequenceHelper::append( const CustomAnimationEffectPtr& pEffect )
1814 {
1815 pEffect->setEffectSequence( this );
1816 maEffects.push_back(pEffect);
1817 rebuild();
1818 }
1819
1820 // --------------------------------------------------------------------
1821
1822 void EffectSequenceHelper::insert( EffectSequence::iterator& rPos, const CustomAnimationEffectPtr& pEffect )
1823 {
1824 pEffect->setEffectSequence( this );
1825 maEffects.insert( rPos, pEffect );
1826 rebuild();
1827 }
1828
1829 // --------------------------------------------------------------------
1830
1831 CustomAnimationEffectPtr EffectSequenceHelper::append( const CustomAnimationPresetPtr& pPreset, const Any& rTarget, double fDuration /* = -1.0 */ )
1832 {
1833 CustomAnimationEffectPtr pEffect;
1834
1835 if( pPreset.get() )
1836 {
1837 OUString strEmpty;
1838 Reference< XAnimationNode > xNode( pPreset->create( strEmpty ) );
1839 if( xNode.is() )
1840 {
1841 // first, filter all only ui relevant user data
1842 std::vector< NamedValue > aNewUserData;
1843 Sequence< NamedValue > aUserData( xNode->getUserData() );
1844 sal_Int32 nLength = aUserData.getLength();
1845 const NamedValue* p = aUserData.getConstArray();
1846 bool bFilter = false;
1847
1848 while( nLength-- )
1849 {
1850 if( !p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "text-only" ) ) &&
1851 !p->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "preset-property" ) ) )
1852 {
1853 aNewUserData.push_back( *p );
1854 bFilter = true;
1855 }
1856 p++;
1857 }
1858
1859 if( bFilter )
1860 {
1861 aUserData = ::comphelper::containerToSequence< NamedValue, std::vector< NamedValue > >( aNewUserData );
1862 xNode->setUserData( aUserData );
1863 }
1864
1865 // check target, maybe we need to force it to text
1866 Any aTarget( rTarget );
1867 sal_Int16 nSubItem = ShapeAnimationSubType::AS_WHOLE;
1868
1869 if( aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
1870 {
1871 nSubItem = ShapeAnimationSubType::ONLY_TEXT;
1872 }
1873 else if( pPreset->isTextOnly() )
1874 {
1875 Reference< XShape > xShape;
1876 aTarget >>= xShape;
1877 if( xShape.is() )
1878 {
1879 // thats bad, we target a shape here but the effect is only for text
1880 // so change subitem
1881 nSubItem = ShapeAnimationSubType::ONLY_TEXT;
1882 }
1883 }
1884
1885 // now create effect from preset
1886 pEffect.reset( new CustomAnimationEffect( xNode ) );
1887 pEffect->setEffectSequence( this );
1888 pEffect->setTarget( aTarget );
1889 pEffect->setTargetSubItem( nSubItem );
1890 if( fDuration != -1.0 )
1891 pEffect->setDuration( fDuration );
1892
1893 maEffects.push_back(pEffect);
1894
1895 rebuild();
1896 }
1897 }
1898
1899 DBG_ASSERT( pEffect.get(), "sd::EffectSequenceHelper::append(), failed!" );
1900 return pEffect;
1901 }
1902
1903 // --------------------------------------------------------------------
1904
1905 CustomAnimationEffectPtr EffectSequenceHelper::append( const SdrPathObj& rPathObj, const Any& rTarget, double fDuration /* = -1.0 */ )
1906 {
1907 CustomAnimationEffectPtr pEffect;
1908
1909 if( fDuration <= 0.0 )
1910 fDuration = 2.0;
1911
1912 try
1913 {
1914 Reference< XTimeContainer > xEffectContainer( createParallelTimeContainer() );
1915 const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.animations.AnimateMotion" ) );
1916 Reference< XAnimationNode > xAnimateMotion( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName), UNO_QUERY_THROW );
1917
1918 xAnimateMotion->setDuration( Any( fDuration ) );
1919 xAnimateMotion->setFill( AnimationFill::HOLD );
1920 xEffectContainer->appendChild( xAnimateMotion );
1921
1922 sal_Int16 nSubItem = ShapeAnimationSubType::AS_WHOLE;
1923
1924 if( rTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
1925 nSubItem = ShapeAnimationSubType::ONLY_TEXT;
1926
1927 Reference< XAnimationNode > xEffectNode( xEffectContainer, UNO_QUERY_THROW );
1928 pEffect.reset( new CustomAnimationEffect( xEffectNode ) );
1929 pEffect->setEffectSequence( this );
1930 pEffect->setTarget( rTarget );
1931 pEffect->setTargetSubItem( nSubItem );
1932 pEffect->setNodeType( ::com::sun::star::presentation::EffectNodeType::ON_CLICK );
1933 pEffect->setPresetClass( ::com::sun::star::presentation::EffectPresetClass::MOTIONPATH );
1934 pEffect->setAcceleration( 0.5 );
1935 pEffect->setDecelerate( 0.5 );
1936 pEffect->setFill( AnimationFill::HOLD );
1937 pEffect->setBegin( 0.0 );
1938 pEffect->updatePathFromSdrPathObj( rPathObj );
1939 if( fDuration != -1.0 )
1940 pEffect->setDuration( fDuration );
1941
1942 maEffects.push_back(pEffect);
1943
1944 rebuild();
1945 }
1946 catch( Exception& )
1947 {
1948 DBG_ERROR( "sd::EffectSequenceHelper::append(), exception cought!" );
1949 }
1950
1951 return pEffect;
1952 }
1953
1954 // --------------------------------------------------------------------
1955
1956 void EffectSequenceHelper::replace( const CustomAnimationEffectPtr& pEffect, const CustomAnimationPresetPtr& pPreset, const OUString& rPresetSubType, double fDuration /* = -1.0 */ )
1957 {
1958 if( pEffect.get() && pPreset.get() ) try
1959 {
1960 Reference< XAnimationNode > xNewNode( pPreset->create( rPresetSubType ) );
1961 if( xNewNode.is() )
1962 {
1963 pEffect->replaceNode( xNewNode );
1964 if( fDuration != -1.0 )
1965 pEffect->setDuration( fDuration );
1966 }
1967
1968 rebuild();
1969 }
1970 catch( Exception& e )
1971 {
1972 (void)e;
1973 DBG_ERROR( "sd::EffectSequenceHelper::replace(), exception cought!" );
1974 }
1975 }
1976
1977 // --------------------------------------------------------------------
1978
1979 void EffectSequenceHelper::replace( const CustomAnimationEffectPtr& pEffect, const CustomAnimationPresetPtr& pPreset, double fDuration /* = -1.0 */ )
1980 {
1981 OUString strEmpty;
1982 replace( pEffect, pPreset, strEmpty, fDuration );
1983 }
1984
1985 // --------------------------------------------------------------------
1986
1987 void EffectSequenceHelper::remove( const CustomAnimationEffectPtr& pEffect )
1988 {
1989 if( pEffect.get() )
1990 {
1991 pEffect->setEffectSequence( 0 );
1992 maEffects.remove( pEffect );
1993 }
1994
1995 rebuild();
1996 }
1997
1998 // --------------------------------------------------------------------
1999
2000 void EffectSequenceHelper::rebuild()
2001 {
2002 implRebuild();
2003 }
2004
2005 // --------------------------------------------------------------------
2006
2007 void EffectSequenceHelper::implRebuild()
2008 {
2009 try
2010 {
2011 // first we delete all time containers on the first two levels
2012 Reference< XEnumerationAccess > xEnumerationAccess( mxSequenceRoot, UNO_QUERY_THROW );
2013 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
2014 while( xEnumeration->hasMoreElements() )
2015 {
2016 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
2017 Reference< XTimeContainer > xChildContainer( xChildNode, UNO_QUERY_THROW );
2018
2019 Reference< XEnumerationAccess > xChildEnumerationAccess( xChildNode, UNO_QUERY_THROW );
2020 Reference< XEnumeration > xChildEnumeration( xChildEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
2021 while( xChildEnumeration->hasMoreElements() )
2022 {
2023 Reference< XAnimationNode > xNode( xChildEnumeration->nextElement(), UNO_QUERY_THROW );
2024 xChildContainer->removeChild( xNode );
2025 }
2026
2027 mxSequenceRoot->removeChild( xChildNode );
2028 }
2029
2030 // second, rebuild main sequence
2031 EffectSequence::iterator aIter( maEffects.begin() );
2032 EffectSequence::iterator aEnd( maEffects.end() );
2033 if( aIter != aEnd )
2034 {
2035 AfterEffectNodeList aAfterEffects;
2036
2037 CustomAnimationEffectPtr pEffect = (*aIter++);
2038
2039 bool bFirst = true;
2040 do
2041 {
2042 // create a par container for the next click node and all following with and after effects
2043 Reference< XTimeContainer > xOnClickContainer( createParallelTimeContainer() );
2044
2045 Event aEvent;
2046 if( mxEventSource.is() )
2047 {
2048 aEvent.Source <<= mxEventSource;
2049 aEvent.Trigger = EventTrigger::ON_CLICK;
2050 }
2051 else
2052 {
2053 aEvent.Trigger = EventTrigger::ON_NEXT;
2054 }
2055 aEvent.Repeat = 0;
2056
2057 Any aBegin( makeAny( aEvent ) );
2058 if( bFirst )
2059 {
2060 // if the first node is not a click action, this click container
2061 // must not have INDEFINITE begin but start at 0s
2062 bFirst = false;
2063 if( pEffect->getNodeType() != EffectNodeType::ON_CLICK )
2064 aBegin <<= (double)0.0;
2065 }
2066
2067 xOnClickContainer->setBegin( aBegin );
2068
2069 Reference< XAnimationNode > xOnClickContainerNode( xOnClickContainer, UNO_QUERY_THROW );
2070 mxSequenceRoot->appendChild( xOnClickContainerNode );
2071
2072 double fBegin = 0.0;
2073
2074 do
2075 {
2076 // create a par container for the current click or after effect node and all following with effects
2077 Reference< XTimeContainer > xWithContainer( createParallelTimeContainer() );
2078 Reference< XAnimationNode > xWithContainerNode( xWithContainer, UNO_QUERY_THROW );
2079 xWithContainer->setBegin( makeAny( fBegin ) );
2080 xOnClickContainer->appendChild( xWithContainerNode );
2081
2082 double fDuration = 0.0;
2083 do
2084 {
2085 Reference< XAnimationNode > xEffectNode( pEffect->getNode() );
2086 xWithContainer->appendChild( xEffectNode );
2087
2088 if( pEffect->hasAfterEffect() )
2089 {
2090 Reference< XAnimationNode > xAfterEffect( pEffect->createAfterEffectNode() );
2091 AfterEffectNode a( xAfterEffect, xEffectNode, pEffect->IsAfterEffectOnNext() );
2092 aAfterEffects.push_back( a );
2093 }
2094
2095 double fTemp = pEffect->getBegin() + pEffect->getAbsoluteDuration();
2096 if( fTemp > fDuration )
2097 fDuration = fTemp;
2098
2099 if( aIter != aEnd )
2100 pEffect = (*aIter++);
2101 else
2102 pEffect.reset();
2103 }
2104 while( pEffect.get() && (pEffect->getNodeType() == EffectNodeType::WITH_PREVIOUS) );
2105
2106 fBegin += fDuration;
2107 }
2108 while( pEffect.get() && (pEffect->getNodeType() != EffectNodeType::ON_CLICK) );
2109 }
2110 while( pEffect.get() );
2111
2112 // process after effect nodes
2113 std::for_each( aAfterEffects.begin(), aAfterEffects.end(), stl_process_after_effect_node_func );
2114
2115 updateTextGroups();
2116
2117 // reset duration, might have been altered (see below)
2118 mxSequenceRoot->setDuration( Any() );
2119 }
2120 else
2121 {
2122 // empty sequence, set duration to 0.0 explicitely
2123 // (otherwise, this sequence will never end)
2124 mxSequenceRoot->setDuration( makeAny((double)0.0) );
2125 }
2126 }
2127 catch( Exception& e )
2128 {
2129 (void)e;
2130 DBG_ERROR( "sd::EffectSequenceHelper::rebuild(), exception cought!" );
2131 }
2132 }
2133
2134 // --------------------------------------------------------------------
2135
2136 Reference< XTimeContainer > EffectSequenceHelper::createParallelTimeContainer() const
2137 {
2138 const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.animations.ParallelTimeContainer" ) );
2139 return Reference< XTimeContainer >( ::comphelper::getProcessServiceFactory()->createInstance(aServiceName), UNO_QUERY );
2140 }
2141
2142 // --------------------------------------------------------------------
2143
2144 stl_CustomAnimationEffect_search_node_predict::stl_CustomAnimationEffect_search_node_predict( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xSearchNode )
2145 : mxSearchNode( xSearchNode )
2146 {
2147 }
2148
2149 // --------------------------------------------------------------------
2150
2151 bool stl_CustomAnimationEffect_search_node_predict::operator()( CustomAnimationEffectPtr pEffect ) const
2152 {
2153 return pEffect->getNode() == mxSearchNode;
2154 }
2155
2156 // --------------------------------------------------------------------
2157
2158 static bool implFindNextContainer( Reference< XTimeContainer >& xParent, Reference< XTimeContainer >& xCurrent, Reference< XTimeContainer >& xNext )
2159 throw(Exception)
2160 {
2161 Reference< XEnumerationAccess > xEnumerationAccess( xParent, UNO_QUERY_THROW );
2162 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration() );
2163 if( xEnumeration.is() )
2164 {
2165 Reference< XInterface > x;
2166 while( xEnumeration->hasMoreElements() && !xNext.is() )
2167 {
2168 if( (xEnumeration->nextElement() >>= x) && (x == xCurrent) )
2169 {
2170 if( xEnumeration->hasMoreElements() )
2171 xEnumeration->nextElement() >>= xNext;
2172 }
2173 }
2174 }
2175 return xNext.is();
2176 }
2177
2178 // --------------------------------------------------------------------
2179
2180 void stl_process_after_effect_node_func(AfterEffectNode& rNode)
2181 {
2182 try
2183 {
2184 if( rNode.mxNode.is() && rNode.mxMaster.is() )
2185 {
2186 // set master node
2187 Reference< XAnimationNode > xMasterNode( rNode.mxMaster, UNO_QUERY_THROW );
2188 Sequence< NamedValue > aUserData( rNode.mxNode->getUserData() );
2189 sal_Int32 nSize = aUserData.getLength();
2190 aUserData.realloc(nSize+1);
2191 aUserData[nSize].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "master-element" ) );
2192 aUserData[nSize].Value <<= xMasterNode;
2193 rNode.mxNode->setUserData( aUserData );
2194
2195 // insert after effect node into timeline
2196 Reference< XTimeContainer > xContainer( rNode.mxMaster->getParent(), UNO_QUERY_THROW );
2197
2198 if( !rNode.mbOnNextEffect ) // sameClick
2199 {
2200 // insert the aftereffect after its effect is animated
2201 xContainer->insertAfter( rNode.mxNode, rNode.mxMaster );
2202 }
2203 else // nextClick
2204 {
2205 Reference< XMultiServiceFactory > xMsf( ::comphelper::getProcessServiceFactory() );
2206 // insert the aftereffect in the next group
2207
2208 Reference< XTimeContainer > xClickContainer( xContainer->getParent(), UNO_QUERY_THROW );
2209 Reference< XTimeContainer > xSequenceContainer( xClickContainer->getParent(), UNO_QUERY_THROW );
2210
2211 Reference< XTimeContainer > xNextContainer;
2212
2213 // first try if we have an after effect container
2214 if( !implFindNextContainer( xClickContainer, xContainer, xNextContainer ) )
2215 {
2216 Reference< XTimeContainer > xNextClickContainer;
2217 // if not, try to find the next click effect container
2218 if( implFindNextContainer( xSequenceContainer, xClickContainer, xNextClickContainer ) )
2219 {
2220 Reference< XEnumerationAccess > xEnumerationAccess( xNextClickContainer, UNO_QUERY_THROW );
2221 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
2222 if( xEnumeration->hasMoreElements() )
2223 {
2224 // the next container is the first child container
2225 xEnumeration->nextElement() >>= xNextContainer;
2226 }
2227 else
2228 {
2229 // this does not yet have a child container, create one
2230 const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.ParallelTimeContainer") );
2231 xNextContainer = Reference< XTimeContainer >::query( xMsf->createInstance(aServiceName) );
2232
2233 if( xNextContainer.is() )
2234 {
2235 Reference< XAnimationNode > xNode( xNextContainer, UNO_QUERY_THROW );
2236 xNode->setBegin( makeAny( (double)0.0 ) );
2237 // xNode->setFill( AnimationFill::HOLD );
2238 xNextClickContainer->appendChild( xNode );
2239 }
2240 }
2241 DBG_ASSERT( xNextContainer.is(), "ppt::stl_process_after_effect_node_func::operator(), could not find/create container!" );
2242 }
2243 }
2244
2245 // if we don't have a next container, we add one to the sequence container
2246 if( !xNextContainer.is() )
2247 {
2248 const OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.ParallelTimeContainer") );
2249 Reference< XTimeContainer > xNewClickContainer( xMsf->createInstance(aServiceName), UNO_QUERY_THROW );
2250
2251 Reference< XAnimationNode > xNewClickNode( xNewClickContainer, UNO_QUERY_THROW );
2252
2253 Event aEvent;
2254 aEvent.Trigger = EventTrigger::ON_NEXT;
2255 aEvent.Repeat = 0;
2256 xNewClickNode->setBegin( makeAny( aEvent ) );
2257
2258 Reference< XAnimationNode > xRefNode( xClickContainer, UNO_QUERY_THROW );
2259 xSequenceContainer->insertAfter( xNewClickNode, xRefNode );
2260
2261 xNextContainer = Reference< XTimeContainer >::query( xMsf->createInstance(aServiceName) );
2262
2263 DBG_ASSERT( xNextContainer.is(), "ppt::stl_process_after_effect_node_func::operator(), could not create container!" );
2264 if( xNextContainer.is() )
2265 {
2266 Reference< XAnimationNode > xNode( xNextContainer, UNO_QUERY_THROW );
2267 xNode->setBegin( makeAny( (double)0.0 ) );
2268 // xNode->setFill( AnimationFill::HOLD );
2269 xNewClickContainer->appendChild( xNode );
2270 }
2271 }
2272
2273 if( xNextContainer.is() )
2274 {
2275 // find begin time of first element
2276 Reference< XEnumerationAccess > xEnumerationAccess( xNextContainer, UNO_QUERY_THROW );
2277 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
2278 if( xEnumeration->hasMoreElements() )
2279 {
2280 Reference< XAnimationNode > xChild;
2281 // the next container is the first child container
2282 xEnumeration->nextElement() >>= xChild;
2283 if( xChild.is() )
2284 {
2285 Any aBegin( xChild->getBegin() );
2286 double fBegin = 0.0;
2287 if( (aBegin >>= fBegin) && (fBegin >= 0.0))
2288 rNode.mxNode->setBegin( aBegin );
2289 }
2290 }
2291
2292 xNextContainer->appendChild( rNode.mxNode );
2293 }
2294 }
2295 }
2296 }
2297 catch( Exception& e )
2298 {
2299 (void)e;
2300 DBG_ERROR( "ppt::stl_process_after_effect_node_func::operator(), exception cought!" );
2301 }
2302 }
2303
2304 // --------------------------------------------------------------------
2305
2306 EffectSequence::iterator EffectSequenceHelper::find( const CustomAnimationEffectPtr& pEffect )
2307 {
2308 return std::find( maEffects.begin(), maEffects.end(), pEffect );
2309 }
2310
2311 // --------------------------------------------------------------------
2312
2313 CustomAnimationEffectPtr EffectSequenceHelper::findEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode ) const
2314 {
2315 CustomAnimationEffectPtr pEffect;
2316
2317 EffectSequence::const_iterator aIter( maEffects.begin() );
2318 for( ; aIter != maEffects.end(); aIter++ )
2319 {
2320 if( (*aIter)->getNode() == xNode )
2321 {
2322 pEffect = (*aIter);
2323 break;
2324 }
2325 }
2326
2327 return pEffect;
2328 }
2329
2330 // --------------------------------------------------------------------
2331
2332 sal_Int32 EffectSequenceHelper::getOffsetFromEffect( const CustomAnimationEffectPtr& xEffect ) const
2333 {
2334 sal_Int32 nOffset = 0;
2335
2336 EffectSequence::const_iterator aIter( maEffects.begin() );
2337 for( ; aIter != maEffects.end(); aIter++, nOffset++ )
2338 {
2339 if( (*aIter) == xEffect )
2340 return nOffset;
2341 }
2342
2343 return -1;
2344 }
2345
2346 // --------------------------------------------------------------------
2347
2348 CustomAnimationEffectPtr EffectSequenceHelper::getEffectFromOffset( sal_Int32 nOffset ) const
2349 {
2350 EffectSequence::const_iterator aIter( maEffects.begin() );
2351 while( nOffset-- && aIter != maEffects.end() )
2352 aIter++;
2353
2354 CustomAnimationEffectPtr pEffect;
2355 if( aIter != maEffects.end() )
2356 pEffect = (*aIter);
2357
2358 return pEffect;
2359 }
2360
2361 // --------------------------------------------------------------------
2362
2363 bool EffectSequenceHelper::disposeShape( const Reference< XShape >& xShape )
2364 {
2365 bool bChanges = false;
2366
2367 EffectSequence::iterator aIter( maEffects.begin() );
2368 while( aIter != maEffects.end() )
2369 {
2370 if( (*aIter)->getTargetShape() == xShape )
2371 {
2372 (*aIter)->setEffectSequence( 0 );
2373 bChanges = true;
2374 aIter = maEffects.erase( aIter );
2375 }
2376 else
2377 {
2378 aIter++;
2379 }
2380 }
2381
2382 return bChanges;
2383 }
2384
2385 // --------------------------------------------------------------------
2386
2387 bool EffectSequenceHelper::hasEffect( const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape )
2388 {
2389 EffectSequence::iterator aIter( maEffects.begin() );
2390 while( aIter != maEffects.end() )
2391 {
2392 if( (*aIter)->getTargetShape() == xShape )
2393 return true;
2394 aIter++;
2395 }
2396
2397 return false;
2398 }
2399
2400 // --------------------------------------------------------------------
2401
2402 void EffectSequenceHelper::insertTextRange( const com::sun::star::uno::Any& aTarget )
2403 {
2404 bool bChanges = false;
2405
2406 ParagraphTarget aParaTarget;
2407 if( !(aTarget >>= aParaTarget ) )
2408 return;
2409
2410 EffectSequence::iterator aIter( maEffects.begin() );
2411 while( aIter != maEffects.end() )
2412 {
2413 if( (*aIter)->getTargetShape() == aParaTarget.Shape )
2414 bChanges |= (*aIter)->checkForText();
2415 aIter++;
2416 }
2417
2418 if( bChanges )
2419 rebuild();
2420 }
2421
2422 // --------------------------------------------------------------------
2423
2424 void EffectSequenceHelper::disposeTextRange( const com::sun::star::uno::Any& aTarget )
2425 {
2426 ParagraphTarget aParaTarget;
2427 if( !(aTarget >>= aParaTarget ) )
2428 return;
2429
2430 bool bChanges = false;
2431 bool bErased = false;
2432
2433 EffectSequence::iterator aIter( maEffects.begin() );
2434 while( aIter != maEffects.end() )
2435 {
2436 Any aIterTarget( (*aIter)->getTarget() );
2437 if( aIterTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2438 {
2439 ParagraphTarget aIterParaTarget;
2440 if( (aIterTarget >>= aIterParaTarget) && (aIterParaTarget.Shape == aParaTarget.Shape) )
2441 {
2442 if( aIterParaTarget.Paragraph == aParaTarget.Paragraph )
2443 {
2444 // delete this effect if it targets the disposed paragraph directly
2445 (*aIter)->setEffectSequence( 0 );
2446 aIter = maEffects.erase( aIter );
2447 bChanges = true;
2448 bErased = true;
2449 }
2450 else
2451 {
2452 if( aIterParaTarget.Paragraph > aParaTarget.Paragraph )
2453 {
2454 // shift all paragraphs after disposed paragraph
2455 aIterParaTarget.Paragraph--;
2456 (*aIter)->setTarget( makeAny( aIterParaTarget ) );
2457 }
2458 }
2459 }
2460 }
2461 else if( (*aIter)->getTargetShape() == aParaTarget.Shape )
2462 {
2463 bChanges |= (*aIter)->checkForText();
2464 }
2465
2466 if( bErased )
2467 bErased = false;
2468 else
2469 aIter++;
2470 }
2471
2472 if( bChanges )
2473 rebuild();
2474 }
2475
2476 // --------------------------------------------------------------------
2477
2478 CustomAnimationTextGroup::CustomAnimationTextGroup( const Reference< XShape >& rTarget, sal_Int32 nGroupId )
2479 : maTarget( rTarget ),
2480 mnGroupId( nGroupId )
2481 {
2482 reset();
2483 }
2484
2485 // --------------------------------------------------------------------
2486
2487 void CustomAnimationTextGroup::reset()
2488 {
2489 mnTextGrouping = -1;
2490 mbAnimateForm = false;
2491 mbTextReverse = false;
2492 mfGroupingAuto = -1.0;
2493 mnLastPara = -1; // used to check for TextReverse
2494
2495 int i = 5;
2496 while( i-- ) mnDepthFlags[i] = 0;
2497
2498 maEffects.clear();
2499 }
2500
2501 // --------------------------------------------------------------------
2502
2503 void CustomAnimationTextGroup::addEffect( CustomAnimationEffectPtr& pEffect )
2504 {
2505 maEffects.push_back( pEffect );
2506
2507 Any aTarget( pEffect->getTarget() );
2508 if( aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2509 {
2510 // now look at the paragraph
2511 ParagraphTarget aParaTarget;
2512 aTarget >>= aParaTarget;
2513
2514 if( mnLastPara != -1 )
2515 mbTextReverse = mnLastPara > aParaTarget.Paragraph;
2516
2517 mnLastPara = aParaTarget.Paragraph;
2518
2519 const sal_Int32 nParaDepth = pEffect->getParaDepth();
2520
2521 // only look at the first 5 levels
2522 if( nParaDepth < 5 )
2523 {
2524 // our first paragraph with this level?
2525 if( mnDepthFlags[nParaDepth] == 0 )
2526 {
2527 // so set it to the first found
2528 mnDepthFlags[nParaDepth] = (sal_Int8)pEffect->getNodeType();
2529 }
2530 else if( mnDepthFlags[nParaDepth] != pEffect->getNodeType() )
2531 {
2532 mnDepthFlags[nParaDepth] = -1;
2533 }
2534
2535 if( pEffect->getNodeType() == EffectNodeType::AFTER_PREVIOUS )
2536 mfGroupingAuto = pEffect->getBegin();
2537
2538 mnTextGrouping = 0;
2539 while( (mnTextGrouping < 5) && (mnDepthFlags[mnTextGrouping] > 0) )
2540 mnTextGrouping++;
2541 }
2542 }
2543 else
2544 {
2545 // if we have an effect with the shape as a target, we animate the background
2546 mbAnimateForm = pEffect->getTargetSubItem() != ShapeAnimationSubType::ONLY_TEXT;
2547 }
2548 }
2549
2550 // --------------------------------------------------------------------
2551
2552 class TextGroupMapImpl : public std::map< sal_Int32, CustomAnimationTextGroup* >
2553 {
2554 public:
2555 CustomAnimationTextGroup* findGroup( sal_Int32 nGroupId );
2556 };
2557
2558 // --------------------------------------------------------------------
2559
2560 CustomAnimationTextGroupPtr EffectSequenceHelper::findGroup( sal_Int32 nGroupId )
2561 {
2562 CustomAnimationTextGroupPtr aPtr;
2563
2564 CustomAnimationTextGroupMap::iterator aIter( maGroupMap.find( nGroupId ) );
2565 if( aIter != maGroupMap.end() )
2566 aPtr = (*aIter).second;
2567
2568 return aPtr;
2569 }
2570
2571 // --------------------------------------------------------------------
2572
2573 void EffectSequenceHelper::updateTextGroups()
2574 {
2575 maGroupMap.clear();
2576
2577 // first create all the groups
2578 EffectSequence::iterator aIter( maEffects.begin() );
2579 const EffectSequence::iterator aEnd( maEffects.end() );
2580 while( aIter != aEnd )
2581 {
2582 CustomAnimationEffectPtr pEffect( (*aIter++) );
2583
2584 const sal_Int32 nGroupId = pEffect->getGroupId();
2585
2586 if( nGroupId == -1 )
2587 continue; // trivial case, no group
2588
2589 CustomAnimationTextGroupPtr pGroup = findGroup( nGroupId );
2590 if( !pGroup.get() )
2591 {
2592 pGroup.reset( new CustomAnimationTextGroup( pEffect->getTargetShape(), nGroupId ) );
2593 maGroupMap[nGroupId] = pGroup;
2594 }
2595
2596 pGroup->addEffect( pEffect );
2597 }
2598 }
2599
2600 // --------------------------------------------------------------------
2601
2602 CustomAnimationTextGroupPtr EffectSequenceHelper::createTextGroup( CustomAnimationEffectPtr pEffect, sal_Int32 nTextGrouping, double fTextGroupingAuto, sal_Bool bAnimateForm, sal_Bool bTextReverse )
2603 {
2604 // first finde a free group-id
2605 sal_Int32 nGroupId = 0;
2606
2607 CustomAnimationTextGroupMap::iterator aIter( maGroupMap.begin() );
2608 const CustomAnimationTextGroupMap::iterator aEnd( maGroupMap.end() );
2609 while( aIter != aEnd )
2610 {
2611 if( (*aIter).first == nGroupId )
2612 {
2613 nGroupId++;
2614 aIter = maGroupMap.begin();
2615 }
2616 else
2617 {
2618 aIter++;
2619 }
2620 }
2621
2622 Reference< XShape > xTarget( pEffect->getTargetShape() );
2623
2624 CustomAnimationTextGroupPtr pTextGroup( new CustomAnimationTextGroup( xTarget, nGroupId ) );
2625 maGroupMap[nGroupId] = pTextGroup;
2626
2627 bool bUsed = false;
2628
2629 // do we need to target the shape?
2630 if( (nTextGrouping == 0) || bAnimateForm )
2631 {
2632 sal_Int16 nSubItem;
2633 if( nTextGrouping == 0)
2634 nSubItem = bAnimateForm ? ShapeAnimationSubType::AS_WHOLE : ShapeAnimationSubType::ONLY_TEXT;
2635 else
2636 nSubItem = ShapeAnimationSubType::ONLY_BACKGROUND;
2637
2638 pEffect->setTarget( makeAny( xTarget ) );
2639 pEffect->setTargetSubItem( nSubItem );
2640 pEffect->setEffectSequence( this );
2641 pEffect->setGroupId( nGroupId );
2642
2643 pTextGroup->addEffect( pEffect );
2644 bUsed = true;
2645 }
2646
2647 pTextGroup->mnTextGrouping = nTextGrouping;
2648 pTextGroup->mfGroupingAuto = fTextGroupingAuto;
2649 pTextGroup->mbTextReverse = bTextReverse;
2650
2651 // now add an effect for each paragraph
2652 createTextGroupParagraphEffects( pTextGroup, pEffect, bUsed );
2653
2654 notify_listeners();
2655
2656 return pTextGroup;
2657 }
2658
2659 // --------------------------------------------------------------------
2660
2661 void EffectSequenceHelper::createTextGroupParagraphEffects( CustomAnimationTextGroupPtr pTextGroup, CustomAnimationEffectPtr pEffect, bool bUsed )
2662 {
2663 Reference< XShape > xTarget( pTextGroup->maTarget );
2664
2665 sal_Int32 nTextGrouping = pTextGroup->mnTextGrouping;
2666 double fTextGroupingAuto = pTextGroup->mfGroupingAuto;
2667 sal_Bool bTextReverse = pTextGroup->mbTextReverse;
2668
2669 // now add an effect for each paragraph
2670 if( nTextGrouping >= 0 ) try
2671 {
2672 EffectSequence::iterator aInsertIter( find( pEffect ) );
2673
2674 const OUString strNumberingLevel( RTL_CONSTASCII_USTRINGPARAM("NumberingLevel") );
2675 Reference< XEnumerationAccess > xText( xTarget, UNO_QUERY_THROW );
2676 Reference< XEnumeration > xEnumeration( xText->createEnumeration(), UNO_QUERY_THROW );
2677
2678 std::list< sal_Int16 > aParaList;
2679 sal_Int16 nPara;
2680
2681 // fill the list with all valid paragraphs
2682 for( nPara = 0; xEnumeration->hasMoreElements(); nPara++ )
2683 {
2684 Reference< XTextRange > xRange( xEnumeration->nextElement(), UNO_QUERY );
2685 if( xRange.is() && xRange->getString().getLength() )
2686 {
2687 if( bTextReverse ) // sort them
2688 aParaList.push_front( nPara );
2689 else
2690 aParaList.push_back( nPara );
2691 }
2692 }
2693
2694 ParagraphTarget aTarget;
2695 aTarget.Shape = xTarget;
2696
2697 std::list< sal_Int16 >::iterator aIter( aParaList.begin() );
2698 std::list< sal_Int16 >::iterator aEnd( aParaList.end() );
2699 while( aIter != aEnd )
2700 {
2701 aTarget.Paragraph = (*aIter++);
2702
2703 CustomAnimationEffectPtr pNewEffect;
2704 if( bUsed )
2705 {
2706 // clone a new effect from first effect
2707 pNewEffect = pEffect->clone();
2708 ++aInsertIter;
2709 aInsertIter = maEffects.insert( aInsertIter, pNewEffect );
2710 }
2711 else
2712 {
2713 // reuse first effect if its not yet used
2714 pNewEffect = pEffect;
2715 bUsed = true;
2716 aInsertIter = find( pNewEffect );
2717 }
2718
2719 // set target and group-id
2720 pNewEffect->setTarget( makeAny( aTarget ) );
2721 pNewEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_TEXT );
2722 pNewEffect->setGroupId( pTextGroup->mnGroupId );
2723 pNewEffect->setEffectSequence( this );
2724
2725 // set correct node type
2726 if( pNewEffect->getParaDepth() < nTextGrouping )
2727 {
2728 if( fTextGroupingAuto == -1.0 )
2729 {
2730 pNewEffect->setNodeType( EffectNodeType::ON_CLICK );
2731 pNewEffect->setBegin( 0.0 );
2732 }
2733 else
2734 {
2735 pNewEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
2736 pNewEffect->setBegin( fTextGroupingAuto );
2737 }
2738 }
2739 else
2740 {
2741 pNewEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
2742 pNewEffect->setBegin( 0.0 );
2743 }
2744
2745 pTextGroup->addEffect( pNewEffect );
2746 }
2747 notify_listeners();
2748 }
2749 catch( Exception& e )
2750 {
2751 (void)e;
2752 DBG_ERROR("sd::EffectSequenceHelper::createTextGroup(), exception cought!" );
2753 }
2754 }
2755
2756 // --------------------------------------------------------------------
2757
2758 void EffectSequenceHelper::setTextGrouping( CustomAnimationTextGroupPtr pTextGroup, sal_Int32 nTextGrouping )
2759 {
2760 if( pTextGroup->mnTextGrouping == nTextGrouping )
2761 {
2762 // first case, trivial case, do nothing
2763 }
2764 else if( (pTextGroup->mnTextGrouping == -1) && (nTextGrouping >= 0) )
2765 {
2766 // second case, we need to add new effects for each paragraph
2767
2768 CustomAnimationEffectPtr pEffect( pTextGroup->maEffects.front() );
2769
2770 pTextGroup->mnTextGrouping = nTextGrouping;
2771 createTextGroupParagraphEffects( pTextGroup, pEffect, true );
2772 notify_listeners();
2773 }
2774 else if( (pTextGroup->mnTextGrouping >= 0) && (nTextGrouping == -1 ) )
2775 {
2776 // third case, we need to remove effects for each paragraph
2777
2778 EffectSequence aEffects( pTextGroup->maEffects );
2779 pTextGroup->reset();
2780
2781 EffectSequence::iterator aIter( aEffects.begin() );
2782 const EffectSequence::iterator aEnd( aEffects.end() );
2783 while( aIter != aEnd )
2784 {
2785 CustomAnimationEffectPtr pEffect( (*aIter++) );
2786
2787 if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2788 remove( pEffect );
2789 else
2790 pTextGroup->addEffect( pEffect );
2791 }
2792 notify_listeners();
2793 }
2794 else
2795 {
2796 // fourth case, we need to change the node types for the text nodes
2797 double fTextGroupingAuto = pTextGroup->mfGroupingAuto;
2798
2799 EffectSequence aEffects( pTextGroup->maEffects );
2800 pTextGroup->reset();
2801
2802 EffectSequence::iterator aIter( aEffects.begin() );
2803 const EffectSequence::iterator aEnd( aEffects.end() );
2804 while( aIter != aEnd )
2805 {
2806 CustomAnimationEffectPtr pEffect( (*aIter++) );
2807
2808 if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2809 {
2810 // set correct node type
2811 if( pEffect->getParaDepth() < nTextGrouping )
2812 {
2813 if( fTextGroupingAuto == -1.0 )
2814 {
2815 pEffect->setNodeType( EffectNodeType::ON_CLICK );
2816 pEffect->setBegin( 0.0 );
2817 }
2818 else
2819 {
2820 pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
2821 pEffect->setBegin( fTextGroupingAuto );
2822 }
2823 }
2824 else
2825 {
2826 pEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
2827 pEffect->setBegin( 0.0 );
2828 }
2829 }
2830
2831 pTextGroup->addEffect( pEffect );
2832
2833 }
2834 notify_listeners();
2835 }
2836 }
2837
2838 // --------------------------------------------------------------------
2839
2840 void EffectSequenceHelper::setAnimateForm( CustomAnimationTextGroupPtr pTextGroup, sal_Bool bAnimateForm )
2841 {
2842 if( pTextGroup->mbAnimateForm == bAnimateForm )
2843 {
2844 // trivial case, do nothing
2845 }
2846 else
2847 {
2848 EffectSequence aEffects( pTextGroup->maEffects );
2849 pTextGroup->reset();
2850
2851 EffectSequence::iterator aIter( aEffects.begin() );
2852 const EffectSequence::iterator aEnd( aEffects.end() );
2853
2854 // first insert if we have to
2855 if( bAnimateForm )
2856 {
2857 EffectSequence::iterator aInsertIter( find( (*aIter) ) );
2858
2859 CustomAnimationEffectPtr pEffect;
2860 if( (aEffects.size() == 1) && ((*aIter)->getTarget().getValueType() != ::getCppuType((const ParagraphTarget*)0) ) )
2861 {
2862 // special case, only one effect and that targets whole text,
2863 // convert this to target whole shape
2864 pEffect = (*aIter++);
2865 pEffect->setTargetSubItem( ShapeAnimationSubType::AS_WHOLE );
2866 }
2867 else
2868 {
2869 pEffect = (*aIter)->clone();
2870 pEffect->setTarget( makeAny( (*aIter)->getTargetShape() ) );
2871 pEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_BACKGROUND );
2872 maEffects.insert( aInsertIter, pEffect );
2873 }
2874
2875 pTextGroup->addEffect( pEffect );
2876 }
2877
2878 if( !bAnimateForm && (aEffects.size() == 1) )
2879 {
2880 CustomAnimationEffectPtr pEffect( (*aIter) );
2881 pEffect->setTarget( makeAny( (*aIter)->getTargetShape() ) );
2882 pEffect->setTargetSubItem( ShapeAnimationSubType::ONLY_TEXT );
2883 pTextGroup->addEffect( pEffect );
2884 }
2885 else
2886 {
2887 // readd the rest to the group again
2888 while( aIter != aEnd )
2889 {
2890 CustomAnimationEffectPtr pEffect( (*aIter++) );
2891
2892 if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2893 {
2894 pTextGroup->addEffect( pEffect );
2895 }
2896 else
2897 {
2898 DBG_ASSERT( !bAnimateForm, "sd::EffectSequenceHelper::setAnimateForm(), something is wrong here!" );
2899 remove( pEffect );
2900 }
2901 }
2902 }
2903 notify_listeners();
2904 }
2905 }
2906
2907 // --------------------------------------------------------------------
2908
2909 void EffectSequenceHelper::setTextGroupingAuto( CustomAnimationTextGroupPtr pTextGroup, double fTextGroupingAuto )
2910 {
2911 sal_Int32 nTextGrouping = pTextGroup->mnTextGrouping;
2912
2913 EffectSequence aEffects( pTextGroup->maEffects );
2914 pTextGroup->reset();
2915
2916 EffectSequence::iterator aIter( aEffects.begin() );
2917 const EffectSequence::iterator aEnd( aEffects.end() );
2918 while( aIter != aEnd )
2919 {
2920 CustomAnimationEffectPtr pEffect( (*aIter++) );
2921
2922 if( pEffect->getTarget().getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2923 {
2924 // set correct node type
2925 if( pEffect->getParaDepth() < nTextGrouping )
2926 {
2927 if( fTextGroupingAuto == -1.0 )
2928 {
2929 pEffect->setNodeType( EffectNodeType::ON_CLICK );
2930 pEffect->setBegin( 0.0 );
2931 }
2932 else
2933 {
2934 pEffect->setNodeType( EffectNodeType::AFTER_PREVIOUS );
2935 pEffect->setBegin( fTextGroupingAuto );
2936 }
2937 }
2938 else
2939 {
2940 pEffect->setNodeType( EffectNodeType::WITH_PREVIOUS );
2941 pEffect->setBegin( 0.0 );
2942 }
2943 }
2944
2945 pTextGroup->addEffect( pEffect );
2946
2947 }
2948 notify_listeners();
2949 }
2950
2951 // --------------------------------------------------------------------
2952
2953 struct ImplStlTextGroupSortHelper
2954 {
2955 ImplStlTextGroupSortHelper( bool bReverse ) : mbReverse( bReverse ) {};
2956 bool operator()( const CustomAnimationEffectPtr& p1, const CustomAnimationEffectPtr& p2 );
2957 bool mbReverse;
2958 sal_Int32 getTargetParagraph( const CustomAnimationEffectPtr& p1 );
2959 };
2960
2961 // --------------------------------------------------------------------
2962
2963 sal_Int32 ImplStlTextGroupSortHelper::getTargetParagraph( const CustomAnimationEffectPtr& p1 )
2964 {
2965 const Any aTarget(p1->getTarget());
2966 if( aTarget.hasValue() && aTarget.getValueType() == ::getCppuType((const ParagraphTarget*)0) )
2967 {
2968 ParagraphTarget aParaTarget;
2969 aTarget >>= aParaTarget;
2970 return aParaTarget.Paragraph;
2971 }
2972 else
2973 {
2974 return mbReverse ? 0x7fffffff : -1;
2975 }
2976 }
2977
2978 // --------------------------------------------------------------------
2979
2980 bool ImplStlTextGroupSortHelper::operator()( const CustomAnimationEffectPtr& p1, const CustomAnimationEffectPtr& p2 )
2981 {
2982 if( mbReverse )
2983 {
2984 return getTargetParagraph( p2 ) < getTargetParagraph( p1 );
2985 }
2986 else
2987 {
2988 return getTargetParagraph( p1 ) < getTargetParagraph( p2 );
2989 }
2990 }
2991
2992 // --------------------------------------------------------------------
2993
2994 void EffectSequenceHelper::setTextReverse( CustomAnimationTextGroupPtr pTextGroup, sal_Bool bTextReverse )
2995 {
2996 if( pTextGroup->mbTextReverse == bTextReverse )
2997 {
2998 // do nothing
2999 }
3000 else
3001 {
3002 std::vector< CustomAnimationEffectPtr > aSortedVector(pTextGroup->maEffects.size());
3003 std::copy( pTextGroup->maEffects.begin(), pTextGroup->maEffects.end(), aSortedVector.begin() );
3004 ImplStlTextGroupSortHelper aSortHelper( bTextReverse );
3005 std::sort( aSortedVector.begin(), aSortedVector.end(), aSortHelper );
3006
3007 pTextGroup->reset();
3008
3009 std::vector< CustomAnimationEffectPtr >::iterator aIter( aSortedVector.begin() );
3010 const std::vector< CustomAnimationEffectPtr >::iterator aEnd( aSortedVector.end() );
3011
3012 if( aIter != aEnd )
3013 {
3014 pTextGroup->addEffect( (*aIter ) );
3015 EffectSequence::iterator aInsertIter( find( (*aIter++) ) );
3016 while( aIter != aEnd )
3017 {
3018 CustomAnimationEffectPtr pEffect( (*aIter++) );
3019 maEffects.erase( find( pEffect ) );
3020 aInsertIter = maEffects.insert( ++aInsertIter, pEffect );
3021 pTextGroup->addEffect( pEffect );
3022 }
3023 }
3024 notify_listeners();
3025 }
3026 }
3027
3028 // --------------------------------------------------------------------
3029
3030 void EffectSequenceHelper::addListener( ISequenceListener* pListener )
3031 {
3032 if( std::find( maListeners.begin(), maListeners.end(), pListener ) == maListeners.end() )
3033 maListeners.push_back( pListener );
3034 }
3035
3036 // --------------------------------------------------------------------
3037
3038 void EffectSequenceHelper::removeListener( ISequenceListener* pListener )
3039 {
3040 maListeners.remove( pListener );
3041 }
3042
3043 // --------------------------------------------------------------------
3044
3045 struct stl_notify_listeners_func : public std::unary_function<ISequenceListener*, void>
3046 {
3047 stl_notify_listeners_func() {}
3048 void operator()(ISequenceListener* pListener) { pListener->notify_change(); }
3049 };
3050
3051 // --------------------------------------------------------------------
3052
3053 void EffectSequenceHelper::notify_listeners()
3054 {
3055 stl_notify_listeners_func aFunc;
3056 std::for_each( maListeners.begin(), maListeners.end(), aFunc );
3057 }
3058
3059 // --------------------------------------------------------------------
3060
3061 void EffectSequenceHelper::create( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
3062 {
3063 DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::create(), illegal argument" );
3064
3065 if( xNode.is() ) try
3066 {
3067 Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
3068 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
3069 while( xEnumeration->hasMoreElements() )
3070 {
3071 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
3072 createEffectsequence( xChildNode );
3073 }
3074 }
3075 catch( Exception& )
3076 {
3077 DBG_ERROR( "sd::EffectSequenceHelper::create(), exception cought!" );
3078 }
3079 }
3080
3081 // --------------------------------------------------------------------
3082
3083 void EffectSequenceHelper::createEffectsequence( const Reference< XAnimationNode >& xNode )
3084 {
3085 DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::createEffectsequence(), illegal argument" );
3086
3087 if( xNode.is() ) try
3088 {
3089 Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
3090 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
3091 while( xEnumeration->hasMoreElements() )
3092 {
3093 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
3094
3095 createEffects( xChildNode );
3096 }
3097 }
3098 catch( Exception& )
3099 {
3100 DBG_ERROR( "sd::EffectSequenceHelper::createEffectsequence(), exception cought!" );
3101 }
3102 }
3103
3104 // --------------------------------------------------------------------
3105
3106 void EffectSequenceHelper::createEffects( const Reference< XAnimationNode >& xNode )
3107 {
3108 DBG_ASSERT( xNode.is(), "sd::EffectSequenceHelper::createEffects(), illegal argument" );
3109
3110 if( xNode.is() ) try
3111 {
3112 Reference< XEnumerationAccess > xEnumerationAccess( xNode, UNO_QUERY_THROW );
3113 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
3114 while( xEnumeration->hasMoreElements() )
3115 {
3116 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
3117
3118 switch( xChildNode->getType() )
3119 {
3120 // found an effect
3121 case AnimationNodeType::PAR:
3122 case AnimationNodeType::ITERATE:
3123 {
3124 CustomAnimationEffectPtr pEffect( new CustomAnimationEffect( xChildNode ) );
3125
3126 if( pEffect->mnNodeType != -1 )
3127 {
3128 pEffect->setEffectSequence( this );
3129 maEffects.push_back(pEffect);
3130 }
3131 }
3132 break;
3133
3134 // found an after effect
3135 case AnimationNodeType::SET:
3136 case AnimationNodeType::ANIMATECOLOR:
3137 {
3138 processAfterEffect( xChildNode );
3139 }
3140 break;
3141 }
3142 }
3143 }
3144 catch( Exception& e )
3145 {
3146 (void)e;
3147 DBG_ERROR( "sd::EffectSequenceHelper::createEffects(), exception cought!" );
3148 }
3149 }
3150
3151 // --------------------------------------------------------------------
3152
3153 void EffectSequenceHelper::processAfterEffect( const Reference< XAnimationNode >& xNode )
3154 {
3155 try
3156 {
3157 Reference< XAnimationNode > xMaster;
3158
3159 Sequence< NamedValue > aUserData( xNode->getUserData() );
3160 sal_Int32 nLength = aUserData.getLength();
3161 const NamedValue* p = aUserData.getConstArray();
3162
3163 while( nLength-- )
3164 {
3165 if( p->Name.equalsAscii( "master-element" ) )
3166 {
3167 p->Value >>= xMaster;
3168 break;
3169 }
3170 p++;
3171 }
3172
3173 // only process if this is a valid after effect
3174 if( xMaster.is() )
3175 {
3176 CustomAnimationEffectPtr pMasterEffect;
3177
3178 // find the master effect
3179 stl_CustomAnimationEffect_search_node_predict aSearchPredict( xMaster );
3180 EffectSequence::iterator aIter( std::find_if( maEffects.begin(), maEffects.end(), aSearchPredict ) );
3181 if( aIter != maEffects.end() )
3182 pMasterEffect = (*aIter );
3183
3184 if( pMasterEffect.get() )
3185 {
3186 pMasterEffect->setHasAfterEffect( true );
3187
3188 // find out what kind of after effect this is
3189 if( xNode->getType() == AnimationNodeType::ANIMATECOLOR )
3190 {
3191 // its a dim
3192 Reference< XAnimate > xAnimate( xNode, UNO_QUERY_THROW );
3193 pMasterEffect->setDimColor( xAnimate->getTo() );
3194 pMasterEffect->setAfterEffectOnNext( true );
3195 }
3196 else
3197 {
3198 // its a hide
3199 Reference< XChild > xNodeChild( xNode, UNO_QUERY_THROW );
3200 Reference< XChild > xMasterChild( xMaster, UNO_QUERY_THROW );
3201 pMasterEffect->setAfterEffectOnNext( xNodeChild->getParent() != xMasterChild->getParent() );
3202 }
3203 }
3204 }
3205 }
3206 catch( Exception& e )
3207 {
3208 (void)e;
3209 DBG_ERROR( "sd::EffectSequenceHelper::processAfterEffect(), exception cought!" );
3210 }
3211 }
3212
3213 /*
3214 double EffectSequenceHelper::calculateIterateNodeDuration(
3215 {
3216 Reference< i18n::XBreakIterator > xBI( ImplGetBreakIterator() );
3217
3218 sal_Int32 nDone;
3219 sal_Int32 nNextCellBreak( xBI->nextCharacters(rTxt, nIdx, rLocale, i18n::CharacterIteratorMode::SKIPCELL, 0, nDone) );
3220 i18n::Boundary nNextWordBoundary( xBI->getWordBoundary(rTxt, nIdx, rLocale, i18n::WordType::ANY_WORD, sal_True) );
3221 sal_Int32 nNextSentenceBreak( xBI->endOfSentence(rTxt, nIdx, rLocale) );
3222
3223 const sal_Int32 nEndPos( nIdx + nLen );
3224 sal_Int32 i, currOffset(0);
3225 for( i=nIdx; i<nEndPos; ++i )
3226 {
3227 // TODO: Check whether position update is valid for CTL/BiDi
3228 rOutDev.DrawText( rPos + Point(currOffset,0), rTxt, i, 1 );
3229 currOffset = *pDXArray++;
3230
3231 // issue the comments at the respective break positions
3232 if( i == nNextCellBreak )
3233 {
3234 rMtf.AddAction( new MetaCommentAction( "XTEXT_EOC" ) );
3235 nNextCellBreak = xBI->nextCharacters(rTxt, i, rLocale, i18n::CharacterIteratorMode::SKIPCELL, 1, nDone);
3236 }
3237 if( i == nNextWordBoundary.endPos )
3238 {
3239 rMtf.AddAction( new MetaCommentAction( "XTEXT_EOW" ) );
3240 nNextWordBoundary = xBI->getWordBoundary(rTxt, i+1, rLocale, i18n::WordType::ANY_WORD, sal_True);
3241 }
3242 if( i == nNextSentenceBreak )
3243 {
3244 rMtf.AddAction( new MetaCommentAction( "XTEXT_EOS" ) );
3245 nNextSentenceBreak = xBI->endOfSentence(rTxt, i+1, rLocale);
3246 }
3247 }
3248 }
3249
3250 */
3251 // ====================================================================
3252
3253 class AnimationChangeListener : public cppu::WeakImplHelper1< XChangesListener >
3254 {
3255 public:
3256 AnimationChangeListener( MainSequence* pMainSequence ) : mpMainSequence( pMainSequence ) {}
3257
3258 virtual void SAL_CALL changesOccurred( const ::com::sun::star::util::ChangesEvent& Event ) throw (RuntimeException);
3259 virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException);
3260 private:
3261 MainSequence* mpMainSequence;
3262 };
3263
3264 void SAL_CALL AnimationChangeListener::changesOccurred( const ::com::sun::star::util::ChangesEvent& ) throw (RuntimeException)
3265 {
3266 if( mpMainSequence )
3267 mpMainSequence->startRecreateTimer();
3268 }
3269
3270 void SAL_CALL AnimationChangeListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (RuntimeException)
3271 {
3272 }
3273
3274 // ====================================================================
3275
3276 MainSequence::MainSequence()
3277 : mxTimingRootNode( ::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))), UNO_QUERY )
3278 , mbRebuilding( false )
3279 , mnRebuildLockGuard( 0 )
3280 , mbPendingRebuildRequest( false )
3281 {
3282 if( mxTimingRootNode.is() )
3283 {
3284 Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
3285 aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
3286 aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::MAIN_SEQUENCE;
3287 mxTimingRootNode->setUserData( aUserData );
3288 }
3289 init();
3290 }
3291
3292 // --------------------------------------------------------------------
3293
3294 MainSequence::MainSequence( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode )
3295 : mxTimingRootNode( xNode, UNO_QUERY )
3296 , mbRebuilding( false )
3297 , mnRebuildLockGuard( 0 )
3298 , mbPendingRebuildRequest( false )
3299 , mbIgnoreChanges( 0 )
3300 {
3301 init();
3302 }
3303
3304 // --------------------------------------------------------------------
3305
3306 MainSequence::~MainSequence()
3307 {
3308 reset();
3309 }
3310
3311 // --------------------------------------------------------------------
3312
3313 void MainSequence::init()
3314 {
3315 mnSequenceType = EffectNodeType::MAIN_SEQUENCE;
3316
3317 maTimer.SetTimeoutHdl( LINK(this, MainSequence, onTimerHdl) );
3318 maTimer.SetTimeout(500);
3319
3320 mxChangesListener.set( new AnimationChangeListener( this ) );
3321
3322 createMainSequence();
3323 }
3324
3325 // --------------------------------------------------------------------
3326
3327 void MainSequence::reset( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xTimingRootNode )
3328 {
3329 reset();
3330
3331 mxTimingRootNode.set( xTimingRootNode, UNO_QUERY );
3332
3333 createMainSequence();
3334 }
3335
3336 // --------------------------------------------------------------------
3337
3338 Reference< ::com::sun::star::animations::XAnimationNode > MainSequence::getRootNode()
3339 {
3340 DBG_ASSERT( mnRebuildLockGuard == 0, "MainSequence::getRootNode(), rebuild is locked, ist this really what you want?" );
3341
3342 if( maTimer.IsActive() && mbTimerMode )
3343 {
3344 // force a rebuild NOW if one is pending
3345 maTimer.Stop();
3346 implRebuild();
3347 }
3348
3349 return EffectSequenceHelper::getRootNode();
3350 }
3351
3352 // --------------------------------------------------------------------
3353
3354 void MainSequence::createMainSequence()
3355 {
3356 if( mxTimingRootNode.is() ) try
3357 {
3358 Reference< XEnumerationAccess > xEnumerationAccess( mxTimingRootNode, UNO_QUERY_THROW );
3359 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
3360 while( xEnumeration->hasMoreElements() )
3361 {
3362 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
3363 sal_Int32 nNodeType = CustomAnimationEffect::get_node_type( xChildNode );
3364 if( nNodeType == EffectNodeType::MAIN_SEQUENCE )
3365 {
3366 mxSequenceRoot.set( xChildNode, UNO_QUERY );
3367 EffectSequenceHelper::create( xChildNode );
3368 }
3369 else if( nNodeType == EffectNodeType::INTERACTIVE_SEQUENCE )
3370 {
3371 Reference< XTimeContainer > xInteractiveRoot( xChildNode, UNO_QUERY_THROW );
3372 InteractiveSequencePtr pIS( new InteractiveSequence( xInteractiveRoot, this ) );
3373 pIS->addListener( this );
3374 maInteractiveSequenceList.push_back( pIS );
3375 }
3376 }
3377
3378 // see if we have a mainsequence at all. if not, create one...
3379 if( !mxSequenceRoot.is() )
3380 {
3381 mxSequenceRoot = Reference< XTimeContainer >::query(::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))));
3382 if( mxSequenceRoot.is() )
3383 {
3384 uno::Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
3385 aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
3386 aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::MAIN_SEQUENCE;
3387 mxSequenceRoot->setUserData( aUserData );
3388
3389 // empty sequence until now, set duration to 0.0
3390 // explicitely (otherwise, this sequence will never
3391 // end)
3392 mxSequenceRoot->setDuration( makeAny((double)0.0) );
3393
3394 Reference< XAnimationNode > xMainSequenceNode( mxSequenceRoot, UNO_QUERY_THROW );
3395 mxTimingRootNode->appendChild( xMainSequenceNode );
3396 }
3397 }
3398
3399 updateTextGroups();
3400
3401 notify_listeners();
3402
3403 Reference< XChangesNotifier > xNotifier( mxTimingRootNode, UNO_QUERY );
3404 if( xNotifier.is() )
3405 xNotifier->addChangesListener( mxChangesListener );
3406 }
3407 catch( Exception& e )
3408 {
3409 (void)e;
3410 DBG_ERROR( "sd::MainSequence::create(), exception cought!" );
3411 return;
3412 }
3413
3414 DBG_ASSERT( mxSequenceRoot.is(), "sd::MainSequence::create(), found no main sequence!" );
3415 }
3416
3417 // --------------------------------------------------------------------
3418
3419 void MainSequence::reset()
3420 {
3421 EffectSequenceHelper::reset();
3422
3423 InteractiveSequenceList::iterator aIter;
3424 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
3425 (*aIter)->reset();
3426 maInteractiveSequenceList.clear();
3427
3428 try
3429 {
3430 Reference< XChangesNotifier > xNotifier( mxTimingRootNode, UNO_QUERY );
3431 if( xNotifier.is() )
3432 xNotifier->removeChangesListener( mxChangesListener );
3433 }
3434 catch( Exception& )
3435 {
3436 // ...
3437 }
3438 }
3439
3440 // --------------------------------------------------------------------
3441
3442 InteractiveSequencePtr MainSequence::createInteractiveSequence( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xShape )
3443 {
3444 InteractiveSequencePtr pIS;
3445
3446 // create a new interactive sequence container
3447 Reference< XTimeContainer > xISRoot( ::comphelper::getProcessServiceFactory()->createInstance(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.animations.SequenceTimeContainer"))), UNO_QUERY );
3448 DBG_ASSERT( xISRoot.is(), "sd::MainSequence::createInteractiveSequence(), could not create \"com.sun.star.animations.SequenceTimeContainer\"!");
3449 if( xISRoot.is() )
3450 {
3451 uno::Sequence< ::com::sun::star::beans::NamedValue > aUserData( 1 );
3452 aUserData[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "node-type" ) );
3453 aUserData[0].Value <<= ::com::sun::star::presentation::EffectNodeType::INTERACTIVE_SEQUENCE ;
3454 xISRoot->setUserData( aUserData );
3455
3456 Reference< XChild > xChild( mxSequenceRoot, UNO_QUERY_THROW );
3457 Reference< XAnimationNode > xISNode( xISRoot, UNO_QUERY_THROW );
3458 Reference< XTimeContainer > xParent( xChild->getParent(), UNO_QUERY_THROW );
3459 xParent->appendChild( xISNode );
3460 }
3461 pIS.reset( new InteractiveSequence( xISRoot, this) );
3462 pIS->setTriggerShape( xShape );
3463 pIS->addListener( this );
3464 maInteractiveSequenceList.push_back( pIS );
3465 return pIS;
3466 }
3467
3468 // --------------------------------------------------------------------
3469
3470 CustomAnimationEffectPtr MainSequence::findEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::animations::XAnimationNode >& xNode ) const
3471 {
3472 CustomAnimationEffectPtr pEffect = EffectSequenceHelper::findEffect( xNode );
3473
3474 if( pEffect.get() == 0 )
3475 {
3476 InteractiveSequenceList::const_iterator aIter;
3477 for( aIter = maInteractiveSequenceList.begin(); (aIter != maInteractiveSequenceList.end()) && (pEffect.get() == 0); aIter++ )
3478 {
3479 pEffect = (*aIter)->findEffect( xNode );
3480 }
3481 }
3482 return pEffect;
3483 }
3484
3485 // --------------------------------------------------------------------
3486
3487 sal_Int32 MainSequence::getOffsetFromEffect( const CustomAnimationEffectPtr& pEffect ) const
3488 {
3489 sal_Int32 nOffset = EffectSequenceHelper::getOffsetFromEffect( pEffect );
3490
3491 if( nOffset != -1 )
3492 return nOffset;
3493
3494 nOffset = EffectSequenceHelper::getCount();
3495
3496 InteractiveSequenceList::const_iterator aIter;
3497 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
3498 {
3499 sal_Int32 nTemp = (*aIter)->getOffsetFromEffect( pEffect );
3500 if( nTemp != -1 )
3501 return nOffset + nTemp;
3502
3503 nOffset += (*aIter)->getCount();
3504 }
3505
3506 return -1;
3507 }
3508
3509 // --------------------------------------------------------------------
3510
3511 CustomAnimationEffectPtr MainSequence::getEffectFromOffset( sal_Int32 nOffset ) const
3512 {
3513 if( nOffset >= 0 )
3514 {
3515 if( nOffset < getCount() )
3516 return EffectSequenceHelper::getEffectFromOffset( nOffset );
3517
3518 nOffset -= getCount();
3519
3520 InteractiveSequenceList::const_iterator aIter( maInteractiveSequenceList.begin() );
3521
3522 while( (aIter != maInteractiveSequenceList.end()) && (nOffset > (*aIter)->getCount()) )
3523 nOffset -= (*aIter++)->getCount();
3524
3525 if( (aIter != maInteractiveSequenceList.end()) && (nOffset >= 0) )
3526 return (*aIter)->getEffectFromOffset( nOffset );
3527 }
3528
3529 CustomAnimationEffectPtr pEffect;
3530 return pEffect;
3531 }
3532
3533 // --------------------------------------------------------------------
3534
3535 bool MainSequence::disposeShape( const Reference< XShape >& xShape )
3536 {
3537 bool bChanges = EffectSequenceHelper::disposeShape( xShape );
3538
3539 InteractiveSequenceList::iterator aIter;
3540 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); )
3541 {
3542 if( (*aIter)->getTriggerShape() == xShape )
3543 {
3544 aIter = maInteractiveSequenceList.erase( aIter );
3545 bChanges = true;
3546 }
3547 else
3548 {
3549 bChanges |= (*aIter++)->disposeShape( xShape );
3550 }
3551 }
3552
3553 if( bChanges )
3554 startRebuildTimer();
3555
3556 return bChanges;
3557 }
3558
3559 // --------------------------------------------------------------------
3560
3561 bool MainSequence::hasEffect( const com::sun::star::uno::Reference< com::sun::star::drawing::XShape >& xShape )
3562 {
3563 if( EffectSequenceHelper::hasEffect( xShape ) )
3564 return true;
3565
3566 InteractiveSequenceList::iterator aIter;
3567 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); )
3568 {
3569 if( (*aIter)->getTriggerShape() == xShape )
3570 return true;
3571
3572 if( (*aIter++)->hasEffect( xShape ) )
3573 return true;
3574 }
3575
3576 return false;
3577 }
3578
3579 // --------------------------------------------------------------------
3580
3581 void MainSequence::insertTextRange( const com::sun::star::uno::Any& aTarget )
3582 {
3583 EffectSequenceHelper::insertTextRange( aTarget );
3584
3585 InteractiveSequenceList::iterator aIter;
3586 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
3587 {
3588 (*aIter)->insertTextRange( aTarget );
3589 }
3590 }
3591 // --------------------------------------------------------------------
3592
3593 void MainSequence::disposeTextRange( const com::sun::star::uno::Any& aTarget )
3594 {
3595 EffectSequenceHelper::disposeTextRange( aTarget );
3596
3597 InteractiveSequenceList::iterator aIter;
3598 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
3599 {
3600 (*aIter)->disposeTextRange( aTarget );
3601 }
3602 }
3603
3604 // --------------------------------------------------------------------
3605
3606 /** callback from the sd::View when an object just left text edit mode */
3607 void MainSequence::onTextChanged( const Reference< XShape >& xShape )
3608 {
3609 EffectSequenceHelper::onTextChanged( xShape );
3610
3611 InteractiveSequenceList::iterator aIter;
3612 for( aIter = maInteractiveSequenceList.begin(); aIter != maInteractiveSequenceList.end(); aIter++ )
3613 {
3614 (*aIter)->onTextChanged( xShape );
3615 }
3616 }
3617
3618 // --------------------------------------------------------------------
3619
3620 void EffectSequenceHelper::onTextChanged( const Reference< XShape >& xShape )
3621 {
3622 bool bChanges = false;
3623
3624 EffectSequence::iterator aIter;
3625 for( aIter = maEffects.begin(); aIter != maEffects.end(); aIter++ )
3626 {
3627 if( (*aIter)->getTargetShape() == xShape )
3628 bChanges |= (*aIter)->checkForText();
3629 }
3630
3631 if( bChanges )
3632 EffectSequenceHelper::implRebuild();
3633 }
3634
3635 // --------------------------------------------------------------------
3636
3637 void MainSequence::rebuild()
3638 {
3639 startRebuildTimer();
3640 }
3641
3642 // --------------------------------------------------------------------
3643
3644 void MainSequence::lockRebuilds()
3645 {
3646 mnRebuildLockGuard++;
3647 }
3648
3649 // --------------------------------------------------------------------
3650
3651 void MainSequence::unlockRebuilds()
3652 {
3653 DBG_ASSERT( mnRebuildLockGuard, "sd::MainSequence::unlockRebuilds(), no corresponding lockRebuilds() call!" );
3654 if( mnRebuildLockGuard )
3655 mnRebuildLockGuard--;
3656
3657 if( (mnRebuildLockGuard == 0) && mbPendingRebuildRequest )
3658 {
3659 mbPendingRebuildRequest = false;
3660 startRebuildTimer();
3661 }
3662 }
3663
3664 // --------------------------------------------------------------------
3665
3666 void MainSequence::implRebuild()
3667 {
3668 if( mnRebuildLockGuard )
3669 {
3670 mbPendingRebuildRequest = true;
3671 return;
3672 }
3673
3674 mbRebuilding = true;
3675
3676 EffectSequenceHelper::implRebuild();
3677
3678 InteractiveSequenceList::iterator aIter( maInteractiveSequenceList.begin() );
3679 const InteractiveSequenceList::iterator aEnd( maInteractiveSequenceList.end() );
3680 while( aIter != aEnd )
3681 {
3682 InteractiveSequencePtr pIS( (*aIter) );
3683 if( pIS->maEffects.empty() )
3684 {
3685 // remove empty interactive sequences
3686 aIter = maInteractiveSequenceList.erase( aIter );
3687
3688 Reference< XChild > xChild( mxSequenceRoot, UNO_QUERY_THROW );
3689 Reference< XTimeContainer > xParent( xChild->getParent(), UNO_QUERY_THROW );
3690 Reference< XAnimationNode > xISNode( pIS->mxSequenceRoot, UNO_QUERY_THROW );
3691 xParent->removeChild( xISNode );
3692 }
3693 else
3694 {
3695 pIS->implRebuild();
3696 aIter++;
3697 }
3698 }
3699
3700 notify_listeners();
3701 mbRebuilding = false;
3702 }
3703
3704 // --------------------------------------------------------------------
3705
3706 void MainSequence::notify_change()
3707 {
3708 notify_listeners();
3709 }
3710
3711 // --------------------------------------------------------------------
3712
3713 bool MainSequence::setTrigger( const CustomAnimationEffectPtr& pEffect, const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xTriggerShape )
3714 {
3715 EffectSequenceHelper* pOldSequence = pEffect->getEffectSequence();
3716
3717 EffectSequenceHelper* pNewSequence = 0;
3718 if( xTriggerShape.is() )
3719 {
3720 InteractiveSequenceList::iterator aIter( maInteractiveSequenceList.begin() );
3721 const InteractiveSequenceList::iterator aEnd( maInteractiveSequenceList.end() );
3722 while( aIter != aEnd )
3723 {
3724 InteractiveSequencePtr pIS( (*aIter++) );
3725 if( pIS->getTriggerShape() == xTriggerShape )
3726 {
3727 pNewSequence = pIS.get();
3728 break;
3729 }
3730 }
3731
3732 if( !pNewSequence )
3733 pNewSequence = createInteractiveSequence( xTriggerShape ).get();
3734 }
3735 else
3736 {
3737 pNewSequence = this;
3738 }
3739
3740 if( pOldSequence != pNewSequence )
3741 {
3742 if( pOldSequence )
3743 pOldSequence->maEffects.remove( pEffect );
3744 if( pNewSequence )
3745 pNewSequence->maEffects.push_back( pEffect );
3746 pEffect->setEffectSequence( pNewSequence );
3747 return true;
3748 }
3749 else
3750 {
3751 return false;
3752 }
3753
3754 }
3755
3756 // --------------------------------------------------------------------
3757
3758 IMPL_LINK( MainSequence, onTimerHdl, Timer *, EMPTYARG )
3759 {
3760 if( mbTimerMode )
3761 {
3762 implRebuild();
3763 }
3764 else
3765 {
3766 reset();
3767 createMainSequence();
3768 }
3769
3770 return 0;
3771 }
3772
3773 // --------------------------------------------------------------------
3774
3775 /** starts a timer that recreates the internal structure from the API core after 1 second */
3776 void MainSequence::startRecreateTimer()
3777 {
3778 if( !mbRebuilding && (mbIgnoreChanges == 0) )
3779 {
3780 mbTimerMode = false;
3781 maTimer.Start();
3782 }
3783 }
3784
3785 // --------------------------------------------------------------------
3786
3787 /** starts a timer that rebuilds the API core from the internal structure after 1 second */
3788 void MainSequence::startRebuildTimer()
3789 {
3790 mbTimerMode = true;
3791 maTimer.Start();
3792 }
3793
3794 // ====================================================================
3795
3796 InteractiveSequence::InteractiveSequence( const Reference< XTimeContainer >& xSequenceRoot, MainSequence* pMainSequence )
3797 : EffectSequenceHelper( xSequenceRoot ), mpMainSequence( pMainSequence )
3798 {
3799 mnSequenceType = EffectNodeType::INTERACTIVE_SEQUENCE;
3800
3801 try
3802 {
3803 if( mxSequenceRoot.is() )
3804 {
3805 Reference< XEnumerationAccess > xEnumerationAccess( mxSequenceRoot, UNO_QUERY_THROW );
3806 Reference< XEnumeration > xEnumeration( xEnumerationAccess->createEnumeration(), UNO_QUERY_THROW );
3807 while( !mxEventSource.is() && xEnumeration->hasMoreElements() )
3808 {
3809 Reference< XAnimationNode > xChildNode( xEnumeration->nextElement(), UNO_QUERY_THROW );
3810
3811 Event aEvent;
3812 if( (xChildNode->getBegin() >>= aEvent) && (aEvent.Trigger == EventTrigger::ON_CLICK) )
3813 aEvent.Source >>= mxEventSource;
3814 }
3815 }
3816 }
3817 catch( Exception& e )
3818 {
3819 (void)e;
3820 DBG_ERROR( "sd::InteractiveSequence::InteractiveSequence(), exception cought!" );
3821 return;
3822 }
3823 }
3824
3825 // --------------------------------------------------------------------
3826
3827 void InteractiveSequence::rebuild()
3828 {
3829 mpMainSequence->rebuild();
3830 }
3831
3832 void InteractiveSequence::implRebuild()
3833 {
3834 EffectSequenceHelper::implRebuild();
3835 }
3836
3837 // --------------------------------------------------------------------
3838
3839 MainSequenceRebuildGuard::MainSequenceRebuildGuard( const MainSequencePtr& pMainSequence )
3840 : mpMainSequence( pMainSequence )
3841 {
3842 if( mpMainSequence.get() )
3843 mpMainSequence->lockRebuilds();
3844 }
3845
3846 MainSequenceRebuildGuard::~MainSequenceRebuildGuard()
3847 {
3848 if( mpMainSequence.get() )
3849 mpMainSequence->unlockRebuilds();
3850 }
3851
3852
3853 }
vba interoperability for OOo