Branch data 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 : : #include <cppuhelper/exc_hlp.hxx>
25 : : #include <comphelper/anytostring.hxx>
26 : : #include <com/sun/star/presentation/ParagraphTarget.hpp>
27 : : #include <com/sun/star/animations/AnimationNodeType.hpp>
28 : : #include <com/sun/star/animations/Timing.hpp>
29 : : #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
30 : : #include <com/sun/star/presentation/ShapeAnimationSubType.hpp>
31 : :
32 : : #include "nodetools.hxx"
33 : : #include "doctreenode.hxx"
34 : : #include "animationbasenode.hxx"
35 : : #include "delayevent.hxx"
36 : : #include "framerate.hxx"
37 : :
38 : : #include <boost/bind.hpp>
39 : : #include <boost/optional.hpp>
40 : : #include <algorithm>
41 : :
42 : : using namespace com::sun::star;
43 : :
44 : : namespace slideshow {
45 : : namespace internal {
46 : :
47 : 0 : AnimationBaseNode::AnimationBaseNode(
48 : : const uno::Reference< animations::XAnimationNode >& xNode,
49 : : const BaseContainerNodeSharedPtr& rParent,
50 : : const NodeContext& rContext )
51 : : : BaseNode( xNode, rParent, rContext ),
52 : : mxAnimateNode( xNode, uno::UNO_QUERY_THROW ),
53 : : maAttributeLayerHolder(),
54 : : maSlideSize( rContext.maSlideSize ),
55 : : mpActivity(),
56 : : mpShape(),
57 : : mpShapeSubset(),
58 : : mpSubsetManager(rContext.maContext.mpSubsettableShapeManager),
59 : 0 : mbIsIndependentSubset( rContext.mbIsIndependentSubset )
60 : : {
61 : : // extract native node targets
62 : : // ===========================
63 : :
64 : : // plain shape target
65 : 0 : uno::Reference< drawing::XShape > xShape( mxAnimateNode->getTarget(),
66 : 0 : uno::UNO_QUERY );
67 : :
68 : : // distinguish 5 cases:
69 : : //
70 : : // - plain shape target
71 : : // (NodeContext.mpMasterShapeSubset full set)
72 : : //
73 : : // - parent-generated subset (generate an
74 : : // independent subset)
75 : : //
76 : : // - parent-generated subset from iteration
77 : : // (generate a dependent subset)
78 : : //
79 : : // - XShape target at the XAnimatioNode (generate
80 : : // a plain shape target)
81 : : //
82 : : // - ParagraphTarget target at the XAnimationNode
83 : : // (generate an independent shape subset)
84 : 0 : if( rContext.mpMasterShapeSubset )
85 : : {
86 : 0 : if( rContext.mpMasterShapeSubset->isFullSet() )
87 : : {
88 : : // case 1: plain shape target from parent
89 : 0 : mpShape = rContext.mpMasterShapeSubset->getSubsetShape();
90 : : }
91 : : else
92 : : {
93 : : // cases 2 & 3: subset shape
94 : 0 : mpShapeSubset = rContext.mpMasterShapeSubset;
95 : : }
96 : : }
97 : : else
98 : : {
99 : : // no parent-provided shape, try to extract
100 : : // from XAnimationNode - cases 4 and 5
101 : :
102 : 0 : if( xShape.is() )
103 : : {
104 : 0 : mpShape = lookupAttributableShape( getContext().mpSubsettableShapeManager,
105 : 0 : xShape );
106 : : }
107 : : else
108 : : {
109 : : // no shape provided. Maybe a ParagraphTarget?
110 : 0 : presentation::ParagraphTarget aTarget;
111 : :
112 : 0 : if( !(mxAnimateNode->getTarget() >>= aTarget) )
113 : 0 : ENSURE_OR_THROW(
114 : : false, "could not extract any target information" );
115 : :
116 : 0 : xShape = aTarget.Shape;
117 : :
118 : 0 : ENSURE_OR_THROW( xShape.is(), "invalid shape in ParagraphTarget" );
119 : :
120 : 0 : mpShape = lookupAttributableShape( getContext().mpSubsettableShapeManager,
121 : 0 : xShape );
122 : :
123 : : // NOTE: For shapes with ParagraphTarget, we ignore
124 : : // the SubItem property. We implicitely assume that it
125 : : // is set to ONLY_TEXT.
126 : : OSL_ENSURE(
127 : : mxAnimateNode->getSubItem() ==
128 : : presentation::ShapeAnimationSubType::ONLY_TEXT ||
129 : : mxAnimateNode->getSubItem() ==
130 : : presentation::ShapeAnimationSubType::AS_WHOLE,
131 : : "ParagraphTarget given, but subitem not AS_TEXT or AS_WHOLE? "
132 : : "Make up your mind, I'll ignore the subitem." );
133 : :
134 : : // okay, found a ParagraphTarget with a valid XShape. Does the shape
135 : : // provide the given paragraph?
136 : 0 : if( aTarget.Paragraph >= 0 &&
137 : 0 : mpShape->getTreeNodeSupplier().getNumberOfTreeNodes(
138 : 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH) > aTarget.Paragraph )
139 : : {
140 : : const DocTreeNode& rTreeNode(
141 : 0 : mpShape->getTreeNodeSupplier().getTreeNode(
142 : : aTarget.Paragraph,
143 : 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ) );
144 : :
145 : : // CAUTION: the creation of the subset shape
146 : : // _must_ stay in the node constructor, since
147 : : // Slide::prefetchShow() initializes shape
148 : : // attributes right after animation import (or
149 : : // the Slide class must be changed).
150 : : mpShapeSubset.reset(
151 : : new ShapeSubset( mpShape,
152 : : rTreeNode,
153 : 0 : mpSubsetManager ));
154 : :
155 : : // Override NodeContext, and flag this node as
156 : : // a special independent subset one. This is
157 : : // important when applying initial attributes:
158 : : // independent shape subsets must be setup
159 : : // when the slide starts, since they, as their
160 : : // name suggest, can have state independent to
161 : : // the master shape. The following example
162 : : // might illustrate that: a master shape has
163 : : // no effect, one of the text paragraphs
164 : : // within it has an appear effect. Now, the
165 : : // respective paragraph must be invisible when
166 : : // the slide is initially shown, and become
167 : : // visible only when the effect starts.
168 : 0 : mbIsIndependentSubset = true;
169 : :
170 : : // already enable subset right here, the
171 : : // setup of initial shape attributes of
172 : : // course needs the subset shape
173 : : // generated, to apply e.g. visibility
174 : : // changes.
175 : 0 : mpShapeSubset->enableSubsetShape();
176 : 0 : }
177 : : }
178 : 0 : }
179 : 0 : }
180 : :
181 : 0 : void AnimationBaseNode::dispose()
182 : : {
183 : 0 : if (mpActivity) {
184 : 0 : mpActivity->dispose();
185 : 0 : mpActivity.reset();
186 : : }
187 : :
188 : 0 : maAttributeLayerHolder.reset();
189 : 0 : mxAnimateNode.clear();
190 : 0 : mpShape.reset();
191 : 0 : mpShapeSubset.reset();
192 : :
193 : 0 : BaseNode::dispose();
194 : 0 : }
195 : :
196 : 0 : bool AnimationBaseNode::init_st()
197 : : {
198 : : // if we've still got an old activity lying around, dispose it:
199 : 0 : if (mpActivity) {
200 : 0 : mpActivity->dispose();
201 : 0 : mpActivity.reset();
202 : : }
203 : :
204 : : // note: actually disposing the activity too early might cause problems,
205 : : // because on dequeued() it calls endAnimation(pAnim->end()), thus ending
206 : : // animation _after_ last screen update.
207 : : // review that end() is properly called (which calls endAnimation(), too).
208 : :
209 : : try {
210 : : // TODO(F2): For restart functionality, we must regenerate activities,
211 : : // since they are not able to reset their state (or implement _that_)
212 : 0 : mpActivity = createActivity();
213 : : }
214 : 0 : catch (uno::Exception const&) {
215 : : OSL_FAIL( rtl::OUStringToOString(
216 : : comphelper::anyToString(cppu::getCaughtException()),
217 : : RTL_TEXTENCODING_UTF8).getStr() );
218 : : // catch and ignore. We later handle empty activities, but for
219 : : // other nodes to function properly, the core functionality of
220 : : // this node must remain up and running.
221 : : }
222 : 0 : return true;
223 : : }
224 : :
225 : 0 : bool AnimationBaseNode::resolve_st()
226 : : {
227 : : // enable shape subset for automatically generated
228 : : // subsets. Independent subsets are already setup
229 : : // during construction time. Doing it only here
230 : : // saves us a lot of sprites and shapes lying
231 : : // around. This is especially important for
232 : : // character-wise iterations, since the shape
233 : : // content (e.g. thousands of characters) would
234 : : // otherwise be painted character-by-character.
235 : 0 : if (isDependentSubsettedShape() && mpShapeSubset) {
236 : 0 : mpShapeSubset->enableSubsetShape();
237 : : }
238 : 0 : return true;
239 : : }
240 : :
241 : 0 : void AnimationBaseNode::activate_st()
242 : : {
243 : : // create new attribute layer
244 : 0 : maAttributeLayerHolder.createAttributeLayer( getShape() );
245 : :
246 : 0 : ENSURE_OR_THROW( maAttributeLayerHolder.get(),
247 : : "Could not generate shape attribute layer" );
248 : :
249 : : // TODO(Q2): This affects the way mpActivity
250 : : // works, but is performed here because of
251 : : // locality (we're fiddling with the additive mode
252 : : // here, anyway, and it's the only place where we
253 : : // do). OTOH, maybe the complete additive mode
254 : : // setup should be moved to the activities.
255 : :
256 : : // for simple by-animations, the SMIL spec
257 : : // requires us to emulate "0,by-value" value list
258 : : // behaviour, with additive mode forced to "sum",
259 : : // no matter what the input is
260 : : // (http://www.w3.org/TR/smil20/animation.html#adef-by).
261 : 0 : if( mxAnimateNode->getBy().hasValue() &&
262 : 0 : !mxAnimateNode->getTo().hasValue() &&
263 : 0 : !mxAnimateNode->getFrom().hasValue() )
264 : : {
265 : : // force attribute mode to REPLACE (note the
266 : : // subtle discrepancy to the paragraph above,
267 : : // where SMIL requires SUM. This is internally
268 : : // handled by the FromToByActivity, and is
269 : : // because otherwise DOM values would not be
270 : : // handled correctly: the activity cannot
271 : : // determine whether an
272 : : // Activity::getUnderlyingValue() yields the
273 : : // DOM value, or already a summed-up conglomerate)
274 : : //
275 : : // Note that this poses problems with our
276 : : // hybrid activity duration (time or min number of frames),
277 : : // since if activities
278 : : // exceed their duration, wrong 'by' start
279 : : // values might arise ('Laser effect')
280 : : maAttributeLayerHolder.get()->setAdditiveMode(
281 : 0 : animations::AnimationAdditiveMode::REPLACE );
282 : : }
283 : : else
284 : : {
285 : : // apply additive mode to newly created Attribute layer
286 : : maAttributeLayerHolder.get()->setAdditiveMode(
287 : 0 : mxAnimateNode->getAdditive() );
288 : : }
289 : :
290 : : // fake normal animation behaviour, even if we
291 : : // show nothing. This is the appropriate way to
292 : : // handle errors on Activity generation, because
293 : : // maybe all other effects on the slide are
294 : : // correctly initialized (but won't run, if we
295 : : // signal an error here)
296 : 0 : if (mpActivity) {
297 : : // supply Activity (and the underlying Animation) with
298 : : // it's AttributeLayer, to perform the animation on
299 : 0 : mpActivity->setTargets( getShape(), maAttributeLayerHolder.get() );
300 : :
301 : : // add to activities queue
302 : 0 : getContext().mrActivitiesQueue.addActivity( mpActivity );
303 : : }
304 : : else {
305 : : // Actually, DO generate the event for empty activity,
306 : : // to keep the chain of animations running
307 : 0 : BaseNode::scheduleDeactivationEvent();
308 : : }
309 : 0 : }
310 : :
311 : 0 : void AnimationBaseNode::deactivate_st( NodeState eDestState )
312 : : {
313 : 0 : if (eDestState == FROZEN) {
314 : 0 : if (mpActivity)
315 : 0 : mpActivity->end();
316 : : }
317 : :
318 : 0 : if (isDependentSubsettedShape()) {
319 : : // for dependent subsets, remove subset shape
320 : : // from layer, re-integrate subsetted part
321 : : // back into original shape. For independent
322 : : // subsets, we cannot make any assumptions
323 : : // about subset attribute state relative to
324 : : // master shape, thus, have to keep it. This
325 : : // will effectively re-integrate the subsetted
326 : : // part into the original shape (whose
327 : : // animation will hopefully have ended, too)
328 : :
329 : : // this statement will save a whole lot of
330 : : // sprites for iterated text effects, since
331 : : // those sprites will only exist during the
332 : : // actual lifetime of the effects
333 : 0 : if (mpShapeSubset) {
334 : 0 : mpShapeSubset->disableSubsetShape();
335 : : }
336 : : }
337 : :
338 : 0 : if (eDestState == ENDED) {
339 : :
340 : : // no shape anymore, no layer needed:
341 : 0 : maAttributeLayerHolder.reset();
342 : :
343 : 0 : if (! isDependentSubsettedShape()) {
344 : :
345 : : // for all other shapes, removing the
346 : : // attribute layer quite possibly changes
347 : : // shape display. Thus, force update
348 : 0 : AttributableShapeSharedPtr const pShape( getShape() );
349 : :
350 : : // don't anybody dare to check against
351 : : // pShape->isVisible() here, removing the
352 : : // attribute layer might actually make the
353 : : // shape invisible!
354 : 0 : getContext().mpSubsettableShapeManager->notifyShapeUpdate( pShape );
355 : : }
356 : :
357 : 0 : if (mpActivity) {
358 : : // kill activity, if still running
359 : 0 : mpActivity->dispose();
360 : 0 : mpActivity.reset();
361 : : }
362 : : }
363 : 0 : }
364 : :
365 : 0 : bool AnimationBaseNode::hasPendingAnimation() const
366 : : {
367 : : // TODO(F1): This might not always be true. Are there 'inactive'
368 : : // animation nodes?
369 : 0 : return true;
370 : : }
371 : :
372 : : #if OSL_DEBUG_LEVEL >= 2 && defined(DBG_UTIL)
373 : : void AnimationBaseNode::showState() const
374 : : {
375 : : BaseNode::showState();
376 : :
377 : : VERBOSE_TRACE( "AnimationBaseNode info: independent subset=%s",
378 : : mbIsIndependentSubset ? "y" : "n" );
379 : : }
380 : : #endif
381 : :
382 : : ActivitiesFactory::CommonParameters
383 : 0 : AnimationBaseNode::fillCommonParameters() const
384 : : {
385 : 0 : double nDuration = 0.0;
386 : :
387 : : // TODO(F3): Duration/End handling is barely there
388 : 0 : if( !(mxAnimateNode->getDuration() >>= nDuration) ) {
389 : 0 : mxAnimateNode->getEnd() >>= nDuration; // Wah.
390 : : }
391 : :
392 : : // minimal duration we fallback to (avoid 0 here!)
393 : 0 : nDuration = ::std::max( 0.001, nDuration );
394 : :
395 : 0 : const bool bAutoReverse( mxAnimateNode->getAutoReverse() );
396 : :
397 : 0 : boost::optional<double> aRepeats;
398 : 0 : double nRepeats = 0;
399 : 0 : if( (mxAnimateNode->getRepeatCount() >>= nRepeats) ) {
400 : 0 : aRepeats.reset( nRepeats );
401 : : }
402 : : else {
403 : 0 : if( (mxAnimateNode->getRepeatDuration() >>= nRepeats) ) {
404 : : // when repeatDuration is given,
405 : : // autoreverse does _not_ modify the
406 : : // active duration. Thus, calc repeat
407 : : // count with already adapted simple
408 : : // duration (twice the specified duration)
409 : :
410 : : // convert duration back to repeat counts
411 : 0 : if( bAutoReverse )
412 : 0 : aRepeats.reset( nRepeats / (2.0 * nDuration) );
413 : : else
414 : 0 : aRepeats.reset( nRepeats / nDuration );
415 : : }
416 : : else
417 : : {
418 : : // no double value for both values - Timing::INDEFINITE?
419 : : animations::Timing eTiming;
420 : :
421 : 0 : if( !(mxAnimateNode->getRepeatDuration() >>= eTiming) ||
422 : : eTiming != animations::Timing_INDEFINITE )
423 : : {
424 : 0 : if( !(mxAnimateNode->getRepeatCount() >>= eTiming) ||
425 : : eTiming != animations::Timing_INDEFINITE )
426 : : {
427 : : // no indefinite timing, no other values given -
428 : : // use simple run, i.e. repeat of 1.0
429 : 0 : aRepeats.reset( 1.0 );
430 : : }
431 : : }
432 : : }
433 : : }
434 : :
435 : : // calc accel/decel:
436 : 0 : double nAcceleration = 0.0;
437 : 0 : double nDeceleration = 0.0;
438 : 0 : BaseNodeSharedPtr const pSelf( getSelf() );
439 : 0 : for ( boost::shared_ptr<BaseNode> pNode( pSelf );
440 : 0 : pNode; pNode = pNode->getParentNode() )
441 : : {
442 : : uno::Reference<animations::XAnimationNode> const xAnimationNode(
443 : 0 : pNode->getXAnimationNode() );
444 : : nAcceleration = std::max( nAcceleration,
445 : 0 : xAnimationNode->getAcceleration() );
446 : : nDeceleration = std::max( nDeceleration,
447 : 0 : xAnimationNode->getDecelerate() );
448 : 0 : }
449 : :
450 : 0 : EventSharedPtr pEndEvent;
451 : 0 : if (pSelf) {
452 : 0 : pEndEvent = makeEvent(
453 : : boost::bind( &AnimationNode::deactivate, pSelf ),
454 : 0 : "AnimationBaseNode::deactivate");
455 : : }
456 : :
457 : : // Calculate the minimum frame count that depends on the duration and
458 : : // the minimum frame count.
459 : : const sal_Int32 nMinFrameCount (basegfx::clamp<sal_Int32>(
460 : 0 : basegfx::fround(nDuration * FrameRate::MinimumFramesPerSecond), 1, 10));
461 : :
462 : : return ActivitiesFactory::CommonParameters(
463 : : pEndEvent,
464 : 0 : getContext().mrEventQueue,
465 : 0 : getContext().mrActivitiesQueue,
466 : : nDuration,
467 : : nMinFrameCount,
468 : : bAutoReverse,
469 : : aRepeats,
470 : : nAcceleration,
471 : : nDeceleration,
472 : : getShape(),
473 : 0 : getSlideSize());
474 : : }
475 : :
476 : 0 : AttributableShapeSharedPtr AnimationBaseNode::getShape() const
477 : : {
478 : : // any subsetting at all?
479 : 0 : if (mpShapeSubset)
480 : 0 : return mpShapeSubset->getSubsetShape();
481 : : else
482 : 0 : return mpShape; // nope, plain shape always
483 : : }
484 : :
485 : : } // namespace internal
486 : 0 : } // namespace slideshow
487 : :
488 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
