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