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 :
21 : // must be first
22 : #include <canvas/debug.hxx>
23 : #include <canvas/verbosetrace.hxx>
24 :
25 : #include <com/sun/star/drawing/XShape.hpp>
26 : #include <com/sun/star/animations/XAnimate.hpp>
27 : #include <com/sun/star/animations/AnimationNodeType.hpp>
28 : #include <com/sun/star/presentation/EffectNodeType.hpp>
29 : #include <com/sun/star/presentation/TextAnimationType.hpp>
30 : #include <com/sun/star/animations/XAnimateSet.hpp>
31 : #include <com/sun/star/animations/XIterateContainer.hpp>
32 : #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
33 : #include <com/sun/star/animations/XAnimateMotion.hpp>
34 : #include <com/sun/star/animations/XAnimateColor.hpp>
35 : #include <com/sun/star/animations/XAnimateTransform.hpp>
36 : #include <com/sun/star/animations/AnimationTransformType.hpp>
37 : #include <com/sun/star/animations/XTransitionFilter.hpp>
38 : #include <com/sun/star/animations/XAudio.hpp>
39 : #include <com/sun/star/presentation/ParagraphTarget.hpp>
40 : #include <com/sun/star/beans/XPropertySet.hpp>
41 : #include <animations/animationnodehelper.hxx>
42 : #include <basegfx/numeric/ftools.hxx>
43 :
44 : #include "animationnodefactory.hxx"
45 : #include "paralleltimecontainer.hxx"
46 : #include "sequentialtimecontainer.hxx"
47 : #include "propertyanimationnode.hxx"
48 : #include "animationsetnode.hxx"
49 : #include "animationpathmotionnode.hxx"
50 : #include "animationcolornode.hxx"
51 : #include "animationtransformnode.hxx"
52 : #include "animationtransitionfilternode.hxx"
53 : #include "animationaudionode.hxx"
54 : #include "animationcommandnode.hxx"
55 : #include "nodetools.hxx"
56 : #include "tools.hxx"
57 :
58 : #include <boost/shared_ptr.hpp>
59 :
60 : using namespace ::com::sun::star;
61 :
62 : namespace slideshow {
63 : namespace internal {
64 :
65 : namespace {
66 :
67 : // forward declaration needed by NodeCreator
68 : BaseNodeSharedPtr implCreateAnimationNode(
69 : const uno::Reference< animations::XAnimationNode >& xNode,
70 : const BaseContainerNodeSharedPtr& rParent,
71 : const NodeContext& rContext );
72 :
73 : class NodeCreator
74 : {
75 : public:
76 0 : NodeCreator( BaseContainerNodeSharedPtr& rParent,
77 : const NodeContext& rContext )
78 0 : : mrParent( rParent ), mrContext( rContext ) {}
79 :
80 0 : void operator()(
81 : const uno::Reference< animations::XAnimationNode >& xChildNode ) const
82 : {
83 0 : createChild( xChildNode, mrContext );
84 0 : }
85 :
86 : protected:
87 0 : void createChild(
88 : const uno::Reference< animations::XAnimationNode >& xChildNode,
89 : const NodeContext& rContext ) const
90 : {
91 : BaseNodeSharedPtr pChild( implCreateAnimationNode( xChildNode,
92 : mrParent,
93 0 : rContext ) );
94 :
95 : OSL_ENSURE( pChild,
96 : "NodeCreator::operator(): child creation failed" );
97 :
98 : // TODO(Q1): This yields circular references, which, it seems, is
99 : // unavoidable here
100 0 : if( pChild )
101 0 : mrParent->appendChildNode( pChild );
102 0 : }
103 :
104 : BaseContainerNodeSharedPtr& mrParent;
105 : const NodeContext& mrContext;
106 : };
107 :
108 : /** Same as NodeCreator, only that NodeContext's
109 : SubsetShape is cloned for every child node.
110 :
111 : This is used for iterated animation node generation
112 : */
113 : class CloningNodeCreator : private NodeCreator
114 : {
115 : public:
116 0 : CloningNodeCreator( BaseContainerNodeSharedPtr& rParent,
117 : const NodeContext& rContext )
118 0 : : NodeCreator( rParent, rContext ) {}
119 :
120 0 : void operator()(
121 : const uno::Reference< animations::XAnimationNode >& xChildNode ) const
122 : {
123 0 : NodeContext aContext( mrContext );
124 :
125 : // TODO(Q1): There's a catch here. If you clone a
126 : // subset whose actual subsetting has already been
127 : // realized (i.e. if enableSubsetShape() has been
128 : // called already), and the original of your clone
129 : // goes out of scope, then your subset will be
130 : // gone (SubsettableShapeManager::revokeSubset() be
131 : // called). As of now, this behaviour is not
132 : // triggered here (we either clone, XOR we enable
133 : // subset initially), but one might consider
134 : // reworking DrawShape/ShapeSubset to avoid this.
135 :
136 : // clone ShapeSubset, since each node needs their
137 : // own version of the ShapeSubset (otherwise,
138 : // e.g. activity counting does not work - subset
139 : // would be removed after first animation node
140 : // disables it).
141 : //
142 : // NOTE: this is only a problem for animation
143 : // nodes that explicitly call
144 : // disableSubsetShape(). Independent shape subsets
145 : // (like those created for ParagraphTargets)
146 : // solely rely on the ShapeSubset destructor to
147 : // normalize things, which does the right thing
148 : // here: the subset is only removed after _the
149 : // last_ animation node releases the shared ptr.
150 : aContext.mpMasterShapeSubset.reset(
151 0 : new ShapeSubset( *aContext.mpMasterShapeSubset ) );
152 :
153 0 : createChild( xChildNode, aContext );
154 0 : }
155 : };
156 :
157 : /** Create animation nodes for text iterations
158 :
159 : This method clones the animation nodes below xIterNode
160 : for every iterated shape entity.
161 : */
162 0 : bool implCreateIteratedNodes(
163 : const uno::Reference< animations::XIterateContainer >& xIterNode,
164 : BaseContainerNodeSharedPtr& rParent,
165 : const NodeContext& rContext )
166 : {
167 0 : ENSURE_OR_THROW( xIterNode.is(),
168 : "implCreateIteratedNodes(): Invalid node" );
169 :
170 0 : const double nIntervalTimeout( xIterNode->getIterateInterval() );
171 :
172 : // valid iterate interval? We're ruling out monstrous
173 : // values here, to avoid pseudo 'hangs' in the
174 : // presentation
175 0 : if( nIntervalTimeout < 0.0 ||
176 : nIntervalTimeout > 1000.0 )
177 : {
178 0 : return false; // not an active iteration
179 : }
180 :
181 0 : if( ::basegfx::fTools::equalZero( nIntervalTimeout ) )
182 : OSL_TRACE( "implCreateIteratedNodes(): "
183 : "iterate interval close to zero, there's "
184 : "no point in defining such an effect "
185 : "(visually equivalent to whole-shape effect)" );
186 :
187 : // Determine target shape (or subset)
188 : // ==================================
189 :
190 : // TODO(E1): I'm not too sure what to expect here...
191 0 : ENSURE_OR_RETURN_FALSE(
192 : xIterNode->getTarget().hasValue(),
193 : "implCreateIteratedNodes(): no target on ITERATE node" );
194 :
195 0 : uno::Reference< drawing::XShape > xTargetShape( xIterNode->getTarget(),
196 0 : uno::UNO_QUERY );
197 :
198 0 : presentation::ParagraphTarget aTarget;
199 0 : sal_Int16 nSubItem( xIterNode->getSubItem() );
200 0 : bool bParagraphTarget( false );
201 :
202 0 : if( !xTargetShape.is() )
203 : {
204 : // no shape provided. Maybe a ParagraphTarget?
205 0 : if( !(xIterNode->getTarget() >>= aTarget) )
206 0 : ENSURE_OR_RETURN_FALSE(
207 : false,
208 : "implCreateIteratedNodes(): could not extract any "
209 : "target information" );
210 :
211 0 : xTargetShape = aTarget.Shape;
212 :
213 0 : ENSURE_OR_RETURN_FALSE(
214 : xTargetShape.is(),
215 : "implCreateIteratedNodes(): invalid shape in ParagraphTarget" );
216 :
217 : // we've a paragraph target to iterate over, thus,
218 : // the whole animation container refers only to
219 : // the text
220 0 : nSubItem = presentation::ShapeAnimationSubType::ONLY_TEXT;
221 :
222 0 : bParagraphTarget = true;
223 : }
224 :
225 : // Lookup shape, and fill NodeContext
226 : // ==================================
227 :
228 : AttributableShapeSharedPtr pTargetShape(
229 : lookupAttributableShape( rContext.maContext.mpSubsettableShapeManager,
230 0 : xTargetShape ) );
231 :
232 : const DocTreeNodeSupplier& rTreeNodeSupplier(
233 0 : pTargetShape->getTreeNodeSupplier() );
234 :
235 0 : ShapeSubsetSharedPtr pTargetSubset;
236 :
237 0 : NodeContext aContext( rContext );
238 :
239 : // paragraph targets already need a subset as the
240 : // master shape (they're representing only a single
241 : // paragraph)
242 0 : if( bParagraphTarget )
243 : {
244 0 : ENSURE_OR_RETURN_FALSE(
245 : aTarget.Paragraph >= 0 &&
246 : rTreeNodeSupplier.getNumberOfTreeNodes(
247 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ) > aTarget.Paragraph,
248 : "implCreateIteratedNodes(): paragraph index out of range" );
249 :
250 : pTargetSubset.reset(
251 : new ShapeSubset(
252 : pTargetShape,
253 : // retrieve index aTarget.Paragraph of
254 : // type PARAGRAPH from this shape
255 : rTreeNodeSupplier.getTreeNode(
256 : aTarget.Paragraph,
257 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ),
258 0 : rContext.maContext.mpSubsettableShapeManager ) );
259 :
260 : // iterate target is not the whole shape, but only
261 : // the selected paragraph - subset _must_ be
262 : // independent, to be able to affect visibility
263 : // independent of master shape
264 0 : aContext.mbIsIndependentSubset = true;
265 :
266 : // already enable parent subset right here, to
267 : // make potentially generated subsets subtract
268 : // their content from the parent subset (and not
269 : // the original shape). Otherwise, already
270 : // subsetted parents (e.g. paragraphs) would not
271 : // have their characters removed, when the child
272 : // iterations start.
273 : // Furthermore, the setup of initial shape
274 : // attributes of course needs the subset shape
275 : // generated, to apply e.g. visibility changes.
276 0 : pTargetSubset->enableSubsetShape();
277 : }
278 : else
279 : {
280 : pTargetSubset.reset(
281 : new ShapeSubset( pTargetShape,
282 0 : rContext.maContext.mpSubsettableShapeManager ));
283 : }
284 :
285 0 : aContext.mpMasterShapeSubset = pTargetSubset;
286 : uno::Reference< animations::XAnimationNode > xNode( xIterNode,
287 0 : uno::UNO_QUERY_THROW );
288 :
289 : // Generate subsets
290 : // ================
291 :
292 0 : if( bParagraphTarget ||
293 : nSubItem != presentation::ShapeAnimationSubType::ONLY_TEXT )
294 : {
295 : // prepend with animations for
296 : // full Shape (will be subtracted
297 : // from the subset parts within
298 : // the Shape::createSubset()
299 : // method). For ONLY_TEXT effects,
300 : // we skip this part, to animate
301 : // only the text.
302 : //
303 : // OR
304 : //
305 : // prepend with subset animation for full
306 : // _paragraph_, from which the individual
307 : // paragraph subsets are subtracted. Note that the
308 : // subitem is superfluous here, we always assume
309 : // ONLY_TEXT, if a paragraph is referenced as the
310 : // master of an iteration effect.
311 0 : NodeCreator aCreator( rParent, aContext );
312 0 : if( !::anim::for_each_childNode( xNode,
313 0 : aCreator ) )
314 : {
315 0 : ENSURE_OR_RETURN_FALSE(
316 : false,
317 : "implCreateIteratedNodes(): iterated child node creation failed" );
318 : }
319 : }
320 :
321 : // TODO(F2): This does not do the correct
322 : // thing. Having nSubItem be set to ONLY_BACKGROUND
323 : // should result in the text staying unanimated in the
324 : // foreground, while the shape moves in the background
325 : // (this behaviour is perfectly possible with the
326 : // slideshow engine, only that the text won't be
327 : // currently visible, because animations are always in
328 : // the foreground)
329 0 : if( nSubItem != presentation::ShapeAnimationSubType::ONLY_BACKGROUND )
330 : {
331 : // determine type of subitem iteration (logical
332 : // text unit to animate)
333 : DocTreeNode::NodeType eIterateNodeType(
334 0 : DocTreeNode::NODETYPE_LOGICAL_CHARACTER_CELL );
335 :
336 0 : switch( xIterNode->getIterateType() )
337 : {
338 : case presentation::TextAnimationType::BY_PARAGRAPH:
339 0 : eIterateNodeType = DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH;
340 0 : break;
341 :
342 : case presentation::TextAnimationType::BY_WORD:
343 0 : eIterateNodeType = DocTreeNode::NODETYPE_LOGICAL_WORD;
344 0 : break;
345 :
346 : case presentation::TextAnimationType::BY_LETTER:
347 0 : eIterateNodeType = DocTreeNode::NODETYPE_LOGICAL_CHARACTER_CELL;
348 0 : break;
349 :
350 : default:
351 0 : ENSURE_OR_THROW(
352 : false, "implCreateIteratedNodes(): "
353 : "Unexpected IterateType on XIterateContainer");
354 : break;
355 : }
356 :
357 0 : if( bParagraphTarget &&
358 : eIterateNodeType != DocTreeNode::NODETYPE_LOGICAL_WORD &&
359 : eIterateNodeType != DocTreeNode::NODETYPE_LOGICAL_CHARACTER_CELL )
360 : {
361 : // will not animate the whole paragraph, when
362 : // only the paragraph is animated at all.
363 : OSL_FAIL( "implCreateIteratedNodes(): Ignoring paragraph iteration for paragraph master" );
364 : }
365 : else
366 : {
367 : // setup iteration parameters
368 : // --------------------------
369 :
370 : // iterate target is the whole shape (or the
371 : // whole parent subshape), thus, can save
372 : // loads of subset shapes by generating them
373 : // only when the effects become active -
374 : // before and after the effect active
375 : // duration, all attributes are shared by
376 : // master shape and subset (since the iterated
377 : // effects are all the same).
378 0 : aContext.mbIsIndependentSubset = false;
379 :
380 : // determine number of nodes for given subitem
381 : // type
382 0 : sal_Int32 nTreeNodes( 0 );
383 0 : if( bParagraphTarget )
384 : {
385 : // create the iterated subset _relative_ to
386 : // the given paragraph index (i.e. animate the
387 : // given subset type, but only when it's part
388 : // of the given paragraph)
389 : nTreeNodes = rTreeNodeSupplier.getNumberOfSubsetTreeNodes(
390 0 : pTargetSubset->getSubset(),
391 0 : eIterateNodeType );
392 : }
393 : else
394 : {
395 : // generate normal subset
396 : nTreeNodes = rTreeNodeSupplier.getNumberOfTreeNodes(
397 0 : eIterateNodeType );
398 : }
399 :
400 :
401 : // iterate node, generate copies of the children for each subset
402 : // -------------------------------------------------------------
403 :
404 : // NodeContext::mnStartDelay contains additional node delay.
405 : // This will make the duplicated nodes for each iteration start
406 : // increasingly later.
407 0 : aContext.mnStartDelay = nIntervalTimeout;
408 :
409 0 : for( sal_Int32 i=0; i<nTreeNodes; ++i )
410 : {
411 : // create subset with the corresponding tree nodes
412 0 : if( bParagraphTarget )
413 : {
414 : // create subsets relative to paragraph subset
415 : aContext.mpMasterShapeSubset.reset(
416 : new ShapeSubset(
417 : pTargetSubset,
418 : rTreeNodeSupplier.getSubsetTreeNode(
419 0 : pTargetSubset->getSubset(),
420 : i,
421 0 : eIterateNodeType ) ) );
422 : }
423 : else
424 : {
425 : // create subsets from main shape
426 : aContext.mpMasterShapeSubset.reset(
427 : new ShapeSubset( pTargetSubset,
428 : rTreeNodeSupplier.getTreeNode(
429 : i,
430 0 : eIterateNodeType ) ) );
431 : }
432 :
433 0 : CloningNodeCreator aCreator( rParent, aContext );
434 0 : if( !::anim::for_each_childNode( xNode,
435 0 : aCreator ) )
436 : {
437 0 : ENSURE_OR_RETURN_FALSE(
438 : false, "implCreateIteratedNodes(): "
439 : "iterated child node creation failed" );
440 : }
441 :
442 0 : aContext.mnStartDelay += nIntervalTimeout;
443 : }
444 : }
445 : }
446 :
447 : // done with iterate child generation
448 0 : return true;
449 : }
450 :
451 0 : BaseNodeSharedPtr implCreateAnimationNode(
452 : const uno::Reference< animations::XAnimationNode >& xNode,
453 : const BaseContainerNodeSharedPtr& rParent,
454 : const NodeContext& rContext )
455 : {
456 0 : ENSURE_OR_THROW( xNode.is(),
457 : "implCreateAnimationNode(): invalid XAnimationNode" );
458 :
459 0 : BaseNodeSharedPtr pCreatedNode;
460 0 : BaseContainerNodeSharedPtr pCreatedContainer;
461 :
462 : // create the internal node, corresponding to xNode
463 0 : switch( xNode->getType() )
464 : {
465 : case animations::AnimationNodeType::CUSTOM:
466 : OSL_FAIL( "implCreateAnimationNode(): "
467 : "CUSTOM not yet implemented" );
468 0 : return pCreatedNode;
469 :
470 : case animations::AnimationNodeType::PAR:
471 : pCreatedNode = pCreatedContainer = BaseContainerNodeSharedPtr(
472 0 : new ParallelTimeContainer( xNode, rParent, rContext ) );
473 0 : break;
474 :
475 : case animations::AnimationNodeType::ITERATE:
476 : // map iterate container to ParallelTimeContainer.
477 : // the iterating functionality is to be found
478 : // below, (see method implCreateIteratedNodes)
479 : pCreatedNode = pCreatedContainer = BaseContainerNodeSharedPtr(
480 0 : new ParallelTimeContainer( xNode, rParent, rContext ) );
481 0 : break;
482 :
483 : case animations::AnimationNodeType::SEQ:
484 : pCreatedNode = pCreatedContainer = BaseContainerNodeSharedPtr(
485 0 : new SequentialTimeContainer( xNode, rParent, rContext ) );
486 0 : break;
487 :
488 : case animations::AnimationNodeType::ANIMATE:
489 : pCreatedNode.reset( new PropertyAnimationNode(
490 0 : xNode, rParent, rContext ) );
491 0 : break;
492 :
493 : case animations::AnimationNodeType::SET:
494 : pCreatedNode.reset( new AnimationSetNode(
495 0 : xNode, rParent, rContext ) );
496 0 : break;
497 :
498 : case animations::AnimationNodeType::ANIMATEMOTION:
499 : pCreatedNode.reset( new AnimationPathMotionNode(
500 0 : xNode, rParent, rContext ) );
501 0 : break;
502 :
503 : case animations::AnimationNodeType::ANIMATECOLOR:
504 : pCreatedNode.reset( new AnimationColorNode(
505 0 : xNode, rParent, rContext ) );
506 0 : break;
507 :
508 : case animations::AnimationNodeType::ANIMATETRANSFORM:
509 : pCreatedNode.reset( new AnimationTransformNode(
510 0 : xNode, rParent, rContext ) );
511 0 : break;
512 :
513 : case animations::AnimationNodeType::TRANSITIONFILTER:
514 : pCreatedNode.reset( new AnimationTransitionFilterNode(
515 0 : xNode, rParent, rContext ) );
516 0 : break;
517 :
518 : case animations::AnimationNodeType::AUDIO:
519 : pCreatedNode.reset( new AnimationAudioNode(
520 0 : xNode, rParent, rContext ) );
521 0 : break;
522 :
523 : case animations::AnimationNodeType::COMMAND:
524 : pCreatedNode.reset( new AnimationCommandNode(
525 0 : xNode, rParent, rContext ) );
526 0 : break;
527 :
528 : default:
529 : OSL_FAIL( "implCreateAnimationNode(): "
530 : "invalid AnimationNodeType" );
531 0 : return pCreatedNode;
532 : }
533 :
534 : // TODO(Q1): This yields circular references, which, it seems, is
535 : // unavoidable here
536 :
537 : // HACK: node objects need shared_ptr to themselves,
538 : // which we pass them here.
539 0 : pCreatedNode->setSelf( pCreatedNode );
540 :
541 : // if we've got a container node object, recursively add
542 : // its children
543 0 : if( pCreatedContainer )
544 : {
545 : uno::Reference< animations::XIterateContainer > xIterNode(
546 0 : xNode, uno::UNO_QUERY );
547 :
548 : // when this node is an XIterateContainer with
549 : // active iterations, this method will generate
550 : // the appropriate children
551 0 : if( xIterNode.is() )
552 : {
553 : // note that implCreateIteratedNodes() might
554 : // choose not to generate any child nodes
555 : // (e.g. when the iterate timeout is outside
556 : // sensible limits). Then, no child nodes are
557 : // generated at all, since typically, child
558 : // node attribute are incomplete for iteration
559 : // children.
560 : implCreateIteratedNodes( xIterNode,
561 : pCreatedContainer,
562 0 : rContext );
563 : }
564 : else
565 : {
566 : // no iterate subset node, just plain child generation now
567 0 : NodeCreator aCreator( pCreatedContainer, rContext );
568 0 : if( !::anim::for_each_childNode( xNode, aCreator ) )
569 : {
570 : OSL_FAIL( "implCreateAnimationNode(): "
571 : "child node creation failed" );
572 0 : return BaseNodeSharedPtr();
573 : }
574 0 : }
575 : }
576 :
577 0 : return pCreatedNode;
578 : }
579 :
580 : } // anon namespace
581 :
582 0 : AnimationNodeSharedPtr AnimationNodeFactory::createAnimationNode(
583 : const uno::Reference< animations::XAnimationNode >& xNode,
584 : const ::basegfx::B2DVector& rSlideSize,
585 : const SlideShowContext& rContext )
586 : {
587 0 : ENSURE_OR_THROW(
588 : xNode.is(),
589 : "AnimationNodeFactory::createAnimationNode(): invalid XAnimationNode" );
590 :
591 : return BaseNodeSharedPtr( implCreateAnimationNode(
592 : xNode,
593 : BaseContainerNodeSharedPtr(), // no parent
594 : NodeContext( rContext,
595 0 : rSlideSize )));
596 : }
597 :
598 : #if OSL_DEBUG_LEVEL >= 2 && defined(DBG_UTIL)
599 : void AnimationNodeFactory::showTree( AnimationNodeSharedPtr& pRootNode )
600 : {
601 : if( pRootNode )
602 : DEBUG_NODES_SHOWTREE( boost::dynamic_pointer_cast<BaseContainerNode>(
603 : pRootNode).get() );
604 : }
605 : #endif
606 :
607 : } // namespace internal
608 : } // namespace slideshow
609 :
610 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
