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