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 : #include <canvas/debug.hxx>
22 : #include <tools/diagnose_ex.h>
23 : #include <tools/helpers.hxx>
24 : #include <canvas/elapsedtime.hxx>
25 : #include <basegfx/polygon/b2dpolygontools.hxx>
26 :
27 : #include <comphelper/anytostring.hxx>
28 : #include <cppuhelper/exc_hlp.hxx>
29 :
30 : #include <rtl/math.hxx>
31 : #include <vcl/metric.hxx>
32 : #include <vcl/canvastools.hxx>
33 : #include <vcl/metaact.hxx>
34 : #include <com/sun/star/beans/XPropertySet.hpp>
35 : #include <com/sun/star/drawing/TextAnimationKind.hpp>
36 : #include <com/sun/star/drawing/TextAnimationDirection.hpp>
37 : #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
38 : #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
39 : #include <com/sun/star/drawing/HomogenMatrix3.hpp>
40 : #include <com/sun/star/awt/Rectangle.hpp>
41 :
42 : #include "activity.hxx"
43 : #include "wakeupevent.hxx"
44 : #include "eventqueue.hxx"
45 : #include "drawshapesubsetting.hxx"
46 : #include "drawshape.hxx"
47 : #include "shapesubset.hxx"
48 : #include "shapeattributelayerholder.hxx"
49 : #include "slideshowcontext.hxx"
50 : #include "tools.hxx"
51 : #include "gdimtftools.hxx"
52 : #include "eventmultiplexer.hxx"
53 : #include "intrinsicanimationactivity.hxx"
54 : #include "intrinsicanimationeventhandler.hxx"
55 :
56 : #include <boost/weak_ptr.hpp>
57 : #include <boost/enable_shared_from_this.hpp>
58 : #include <boost/noncopyable.hpp>
59 : #include <vector>
60 :
61 : using namespace com::sun::star;
62 : using namespace ::slideshow::internal;
63 :
64 : namespace {
65 :
66 : class ScrollTextAnimNode
67 : {
68 : sal_uInt32 mnDuration; // single duration
69 : sal_uInt32 mnRepeat; // 0 -> endless
70 : double mfStart;
71 : double mfStop;
72 : sal_uInt32 mnFrequency; // in ms
73 : // forth and back change at mnRepeat%2:
74 : bool mbAlternate;
75 :
76 : public:
77 0 : ScrollTextAnimNode(
78 : sal_uInt32 nDuration, sal_uInt32 nRepeat, double fStart, double fStop,
79 : sal_uInt32 nFrequency, bool bAlternate)
80 : : mnDuration(nDuration),
81 : mnRepeat(nRepeat),
82 : mfStart(fStart),
83 : mfStop(fStop),
84 : mnFrequency(nFrequency),
85 0 : mbAlternate(bAlternate)
86 0 : {}
87 :
88 : sal_uInt32 GetDuration() const { return mnDuration; }
89 0 : sal_uInt32 GetRepeat() const { return mnRepeat; }
90 0 : sal_uInt32 GetFullTime() const { return mnDuration * mnRepeat; }
91 : double GetStart() const { return mfStart; }
92 0 : double GetStop() const { return mfStop; }
93 0 : sal_uInt32 GetFrequency() const { return mnFrequency; }
94 0 : bool DoAlternate() const { return mbAlternate; }
95 :
96 : double GetStateAtRelativeTime(sal_uInt32 nRelativeTime) const;
97 : };
98 :
99 0 : double ScrollTextAnimNode::GetStateAtRelativeTime(
100 : sal_uInt32 nRelativeTime) const
101 : {
102 : // Avoid division by zero.
103 0 : if( mnDuration == 0 )
104 0 : return mfStop;
105 :
106 0 : if(mnRepeat)
107 : {
108 : // ending
109 0 : const sal_uInt32 nRepeatCount(nRelativeTime / mnDuration);
110 0 : sal_uInt32 nFrameTime(nRelativeTime - (nRepeatCount * mnDuration));
111 :
112 0 : if(DoAlternate() && (nRepeatCount + 1L) % 2L)
113 0 : nFrameTime = mnDuration - nFrameTime;
114 :
115 : return mfStart + ((mfStop - mfStart) *
116 0 : (double(nFrameTime) / mnDuration));
117 : }
118 : else
119 : {
120 : // endless
121 0 : sal_uInt32 nFrameTime(nRelativeTime % mnDuration);
122 :
123 0 : if(DoAlternate())
124 : {
125 0 : const sal_uInt32 nRepeatCount(nRelativeTime / mnDuration);
126 :
127 0 : if((nRepeatCount + 1L) % 2L)
128 0 : nFrameTime = mnDuration - nFrameTime;
129 : }
130 :
131 0 : return mfStart + ((mfStop - mfStart) * (double(nFrameTime) / mnDuration));
132 : }
133 : }
134 :
135 : class ActivityImpl : public Activity,
136 : public boost::enable_shared_from_this<ActivityImpl>,
137 : private boost::noncopyable
138 : {
139 : public:
140 : virtual ~ActivityImpl();
141 :
142 : ActivityImpl(
143 : SlideShowContext const& rContext,
144 : boost::shared_ptr<WakeupEvent> const& pWakeupEvent,
145 : boost::shared_ptr<DrawShape> const& pDrawShape );
146 :
147 : bool enableAnimations();
148 :
149 : // Disposable:
150 : virtual void dispose();
151 : // Activity:
152 : virtual double calcTimeLag() const;
153 : virtual bool perform();
154 : virtual bool isActive() const;
155 : virtual void dequeued();
156 : virtual void end();
157 :
158 : private:
159 : void updateShapeAttributes( double fTime,
160 : basegfx::B2DRectangle const& parentBounds );
161 :
162 : // Access to VisibleWhenSTarted flags
163 0 : sal_Bool IsVisibleWhenStarted() const { return mbVisibleWhenStarted; }
164 0 : sal_Bool IsVisibleWhenStopped() const { return mbVisibleWhenStopped; }
165 :
166 : // scroll horizontal? if sal_False, scroll is vertical.
167 0 : bool ScrollHorizontal() const {
168 : return (drawing::TextAnimationDirection_LEFT == meDirection ||
169 0 : drawing::TextAnimationDirection_RIGHT == meDirection);
170 : }
171 :
172 : // Access to StepWidth in logical units
173 : sal_uInt32 GetStepWidthLogic() const;
174 :
175 : // is the animation direction opposite?
176 0 : bool DoScrollForward() const {
177 : return (drawing::TextAnimationDirection_RIGHT == meDirection ||
178 0 : drawing::TextAnimationDirection_DOWN == meDirection);
179 : }
180 :
181 : // do alternate text directions?
182 0 : bool DoAlternate() const { return mbAlternate; }
183 :
184 : // do scroll in?
185 0 : bool DoScrollIn() const { return mbScrollIn; }
186 :
187 : // Scroll helper methods
188 : void ImpForceScrollTextAnimNodes();
189 : ScrollTextAnimNode* ImpGetScrollTextAnimNode(
190 : sal_uInt32 nTime, sal_uInt32& rRelativeTime );
191 : sal_uInt32 ImpRegisterAgainScrollTextMixerState(
192 : sal_uInt32 nTime);
193 :
194 : // calculate the MixerState value for given time
195 : double GetMixerState(sal_uInt32 nTime);
196 :
197 : ////////////////////////////////////////////////////////////////////
198 :
199 : SlideShowContext maContext;
200 : boost::shared_ptr<WakeupEvent> mpWakeupEvent;
201 : boost::weak_ptr<DrawShape> mpParentDrawShape;
202 : DrawShapeSharedPtr mpDrawShape;
203 : ShapeAttributeLayerHolder maShapeAttrLayer;
204 : GDIMetaFileSharedPtr mpMetaFile;
205 : IntrinsicAnimationEventHandlerSharedPtr mpListener;
206 : canvas::tools::ElapsedTime maTimer;
207 : double mfRotationAngle;
208 : bool mbIsShapeAnimated;
209 : bool mbIsDisposed;
210 : bool mbIsActive;
211 : drawing::TextAnimationKind meAnimKind;
212 :
213 : // The blink frequency in ms
214 : sal_uInt32 mnFrequency;
215 :
216 : // The repeat count, init to 0L which means endless
217 : sal_uInt32 mnRepeat;
218 :
219 : // Flag to decide if text will be shown when animation has ended
220 : bool mbVisibleWhenStopped;
221 : bool mbVisibleWhenStarted;
222 :
223 : // Flag decides if TextScroll alternates. Default is sal_False.
224 : bool mbAlternate;
225 :
226 : // Flag to remember if this is a simple scrollin text
227 : bool mbScrollIn;
228 :
229 : // start time for this animation
230 : sal_uInt32 mnStartTime;
231 :
232 : // The AnimationDirection
233 : drawing::TextAnimationDirection meDirection;
234 :
235 : // Get width per Step. Negative means pixel, positive logical units
236 : sal_Int32 mnStepWidth;
237 :
238 : // The single anim steps
239 : std::vector< ScrollTextAnimNode > maVector;
240 :
241 : // the scroll rectangle
242 : Rectangle maScrollRectangleLogic;
243 :
244 : // the paint rectangle
245 : Rectangle maPaintRectangleLogic;
246 : };
247 :
248 : //////////////////////////////////////////////////////////////////////
249 :
250 0 : class IntrinsicAnimationListener : public IntrinsicAnimationEventHandler,
251 : private boost::noncopyable
252 : {
253 : public:
254 0 : explicit IntrinsicAnimationListener( ActivityImpl& rActivity ) :
255 0 : mrActivity( rActivity )
256 0 : {}
257 :
258 : private:
259 :
260 0 : virtual bool enableAnimations() { return mrActivity.enableAnimations(); }
261 0 : virtual bool disableAnimations() { mrActivity.end(); return true; }
262 :
263 : ActivityImpl& mrActivity;
264 : };
265 :
266 : //////////////////////////////////////////////////////////////////////
267 :
268 0 : double ActivityImpl::GetMixerState( sal_uInt32 nTime )
269 : {
270 0 : if( meAnimKind == drawing::TextAnimationKind_BLINK )
271 : {
272 : // from AInfoBlinkText:
273 0 : double fRetval(0.0);
274 0 : sal_Bool bDone(sal_False);
275 0 : const sal_uInt32 nLoopTime(2 * mnFrequency);
276 :
277 0 : if(mnRepeat)
278 : {
279 0 : const sal_uInt32 nEndTime(mnRepeat * nLoopTime);
280 :
281 0 : if(nTime >= nEndTime)
282 : {
283 0 : if(mbVisibleWhenStopped)
284 0 : fRetval = 0.0;
285 : else
286 0 : fRetval = 1.0;
287 :
288 0 : bDone = sal_True;
289 : }
290 : }
291 :
292 0 : if(!bDone)
293 : {
294 0 : sal_uInt32 nTimeInLoop(nTime % nLoopTime);
295 0 : fRetval = double(nTimeInLoop) / nLoopTime;
296 : }
297 :
298 0 : return fRetval;
299 : }
300 : else
301 : {
302 : // from AInfoScrollText:
303 0 : double fRetval(0.0);
304 0 : ImpForceScrollTextAnimNodes();
305 :
306 0 : if(!maVector.empty())
307 : {
308 : sal_uInt32 nRelativeTime;
309 : ScrollTextAnimNode* pNode =
310 0 : ImpGetScrollTextAnimNode(nTime, nRelativeTime);
311 :
312 0 : if(pNode)
313 : {
314 : // use node
315 0 : fRetval = pNode->GetStateAtRelativeTime(nRelativeTime);
316 : }
317 : else
318 : {
319 : // end of animation, take last entry's end
320 0 : fRetval = maVector[maVector.size() - 1L].GetStop();
321 : }
322 : }
323 :
324 0 : return fRetval;
325 : }
326 : }
327 :
328 : // Access to StepWidth in logical units
329 0 : sal_uInt32 ActivityImpl::GetStepWidthLogic() const
330 : {
331 : // #i69847# Assuming higher DPI
332 0 : sal_uInt32 const PIXEL_TO_LOGIC = 30;
333 :
334 0 : sal_uInt32 nRetval(0L);
335 :
336 0 : if(mnStepWidth < 0L)
337 : {
338 : // is in pixels, convert to logical units
339 0 : nRetval = (-mnStepWidth * PIXEL_TO_LOGIC);
340 : }
341 0 : else if(mnStepWidth > 0L)
342 : {
343 : // is in logical units
344 0 : nRetval = mnStepWidth;
345 : }
346 :
347 0 : if(0L == nRetval)
348 : {
349 : // step 1 pixel, canned value
350 :
351 : // with very high DPIs like in PDF export, this can
352 : // still get zero. for that cases, set a default, too (taken
353 : // from ainfoscrolltext.cxx)
354 0 : nRetval = 100L;
355 : }
356 :
357 0 : return nRetval;
358 : }
359 :
360 0 : void ActivityImpl::ImpForceScrollTextAnimNodes()
361 : {
362 0 : if(maVector.empty())
363 : {
364 : // prepare values
365 : sal_uInt32 nLoopTime;
366 : double fZeroLogic, fOneLogic, fInitLogic, fDistanceLogic;
367 0 : double fZeroLogicAlternate = 0.0, fOneLogicAlternate = 0.0;
368 : double fZeroRelative, fOneRelative, fInitRelative;
369 :
370 0 : if(ScrollHorizontal())
371 : {
372 0 : if(DoAlternate())
373 : {
374 0 : if(maPaintRectangleLogic.GetWidth() >
375 0 : maScrollRectangleLogic.GetWidth())
376 : {
377 0 : fZeroLogicAlternate = maScrollRectangleLogic.Right() - maPaintRectangleLogic.GetWidth();
378 0 : fOneLogicAlternate = maScrollRectangleLogic.Left();
379 : }
380 : else
381 : {
382 0 : fZeroLogicAlternate = maScrollRectangleLogic.Left();
383 0 : fOneLogicAlternate = maScrollRectangleLogic.Right() - maPaintRectangleLogic.GetWidth();
384 : }
385 : }
386 :
387 0 : fZeroLogic = maScrollRectangleLogic.Left() - maPaintRectangleLogic.GetWidth();
388 0 : fOneLogic = maScrollRectangleLogic.Right();
389 0 : fInitLogic = maPaintRectangleLogic.Left();
390 : }
391 : else
392 : {
393 0 : if(DoAlternate())
394 : {
395 0 : if(maPaintRectangleLogic.GetHeight() > maScrollRectangleLogic.GetHeight())
396 : {
397 0 : fZeroLogicAlternate = maScrollRectangleLogic.Bottom() - maPaintRectangleLogic.GetHeight();
398 0 : fOneLogicAlternate = maScrollRectangleLogic.Top();
399 : }
400 : else
401 : {
402 0 : fZeroLogicAlternate = maScrollRectangleLogic.Top();
403 0 : fOneLogicAlternate = maScrollRectangleLogic.Bottom() - maPaintRectangleLogic.GetHeight();
404 : }
405 : }
406 :
407 0 : fZeroLogic = maScrollRectangleLogic.Top() - maPaintRectangleLogic.GetHeight();
408 0 : fOneLogic = maScrollRectangleLogic.Bottom();
409 0 : fInitLogic = maPaintRectangleLogic.Top();
410 : }
411 :
412 0 : fDistanceLogic = fOneLogic - fZeroLogic;
413 0 : fInitRelative = (fInitLogic - fZeroLogic) / fDistanceLogic;
414 :
415 0 : if(DoAlternate())
416 : {
417 : fZeroRelative =
418 0 : (fZeroLogicAlternate - fZeroLogic) / fDistanceLogic;
419 : fOneRelative =
420 0 : (fOneLogicAlternate - fZeroLogic) / fDistanceLogic;
421 : }
422 : else
423 : {
424 0 : fZeroRelative = 0.0;
425 0 : fOneRelative = 1.0;
426 : }
427 :
428 0 : if(mnStartTime)
429 : {
430 : // Start time loop
431 : ScrollTextAnimNode aStartNode(
432 0 : mnStartTime, 1L, 0.0, 0.0, mnStartTime, false);
433 0 : maVector.push_back(aStartNode);
434 : }
435 :
436 0 : if(IsVisibleWhenStarted())
437 : {
438 : double fRelativeStartValue, fRelativeEndValue,fRelativeDistance;
439 :
440 0 : if(DoScrollForward())
441 : {
442 0 : fRelativeStartValue = fInitRelative;
443 0 : fRelativeEndValue = fOneRelative;
444 0 : fRelativeDistance = fRelativeEndValue - fRelativeStartValue;
445 : }
446 : else
447 : {
448 0 : fRelativeStartValue = fInitRelative;
449 0 : fRelativeEndValue = fZeroRelative;
450 0 : fRelativeDistance = fRelativeStartValue - fRelativeEndValue;
451 : }
452 :
453 : const double fNumberSteps =
454 0 : (fRelativeDistance * fDistanceLogic) / GetStepWidthLogic();
455 0 : nLoopTime = FRound(fNumberSteps * mnFrequency);
456 :
457 : // init loop
458 : ScrollTextAnimNode aInitNode(
459 : nLoopTime, 1L,
460 : fRelativeStartValue, fRelativeEndValue,
461 0 : mnFrequency, false);
462 0 : maVector.push_back(aInitNode);
463 : }
464 :
465 : // prepare main loop values
466 : {
467 : double fRelativeStartValue, fRelativeEndValue, fRelativeDistance;
468 :
469 0 : if(DoScrollForward())
470 : {
471 0 : fRelativeStartValue = fZeroRelative;
472 0 : fRelativeEndValue = fOneRelative;
473 0 : fRelativeDistance = fRelativeEndValue - fRelativeStartValue;
474 : }
475 : else
476 : {
477 0 : fRelativeStartValue = fOneRelative;
478 0 : fRelativeEndValue = fZeroRelative;
479 0 : fRelativeDistance = fRelativeStartValue - fRelativeEndValue;
480 : }
481 :
482 : const double fNumberSteps =
483 0 : (fRelativeDistance * fDistanceLogic) / GetStepWidthLogic();
484 0 : nLoopTime = FRound(fNumberSteps * mnFrequency);
485 :
486 0 : if(0L == mnRepeat)
487 : {
488 0 : if(!DoScrollIn())
489 : {
490 : // endless main loop
491 : ScrollTextAnimNode aMainNode(
492 : nLoopTime, 0L,
493 : fRelativeStartValue, fRelativeEndValue,
494 0 : mnFrequency, DoAlternate());
495 0 : maVector.push_back(aMainNode);
496 : }
497 : }
498 : else
499 : {
500 0 : sal_uInt32 nNumRepeat(mnRepeat);
501 :
502 0 : if(DoAlternate() && (nNumRepeat + 1L) % 2L)
503 0 : nNumRepeat += 1L;
504 :
505 : // ending main loop
506 : ScrollTextAnimNode aMainNode(
507 : nLoopTime, nNumRepeat,
508 : fRelativeStartValue, fRelativeEndValue,
509 0 : mnFrequency, DoAlternate());
510 0 : maVector.push_back(aMainNode);
511 : }
512 : }
513 :
514 0 : if(IsVisibleWhenStopped())
515 : {
516 : double fRelativeStartValue, fRelativeEndValue, fRelativeDistance;
517 :
518 0 : if(DoScrollForward())
519 : {
520 0 : fRelativeStartValue = fZeroRelative;
521 0 : fRelativeEndValue = fInitRelative;
522 0 : fRelativeDistance = fRelativeEndValue - fRelativeStartValue;
523 : }
524 : else
525 : {
526 0 : fRelativeStartValue = fOneRelative;
527 0 : fRelativeEndValue = fInitRelative;
528 0 : fRelativeDistance = fRelativeStartValue - fRelativeEndValue;
529 : }
530 :
531 : const double fNumberSteps =
532 0 : (fRelativeDistance * fDistanceLogic) / GetStepWidthLogic();
533 0 : nLoopTime = FRound(fNumberSteps * mnFrequency);
534 :
535 : // exit loop
536 : ScrollTextAnimNode aExitNode(
537 : nLoopTime, 1L,
538 0 : fRelativeStartValue, fRelativeEndValue, mnFrequency, false);
539 0 : maVector.push_back(aExitNode);
540 : }
541 : }
542 0 : }
543 :
544 0 : ScrollTextAnimNode* ActivityImpl::ImpGetScrollTextAnimNode(
545 : sal_uInt32 nTime, sal_uInt32& rRelativeTime )
546 : {
547 0 : ScrollTextAnimNode* pRetval = 0L;
548 0 : ImpForceScrollTextAnimNodes();
549 :
550 0 : if(!maVector.empty())
551 : {
552 0 : rRelativeTime = nTime;
553 :
554 0 : for(sal_uInt32 a(0L); !pRetval && a < maVector.size(); a++)
555 : {
556 0 : ScrollTextAnimNode & rNode = maVector[a];
557 0 : if(!rNode.GetRepeat())
558 : {
559 : // endless loop, use it
560 0 : pRetval = &rNode;
561 : }
562 0 : else if(rNode.GetFullTime() > rRelativeTime)
563 : {
564 : // ending node
565 0 : pRetval = &rNode;
566 : }
567 : else
568 : {
569 : // look at next
570 0 : rRelativeTime -= rNode.GetFullTime();
571 : }
572 : }
573 : }
574 :
575 0 : return pRetval;
576 : }
577 :
578 0 : sal_uInt32 ActivityImpl::ImpRegisterAgainScrollTextMixerState(sal_uInt32 nTime)
579 : {
580 0 : sal_uInt32 nRetval(0L);
581 0 : ImpForceScrollTextAnimNodes();
582 :
583 0 : if(!maVector.empty())
584 : {
585 : sal_uInt32 nRelativeTime;
586 0 : ScrollTextAnimNode* pNode = ImpGetScrollTextAnimNode(nTime, nRelativeTime);
587 :
588 0 : if(pNode)
589 : {
590 : // take register time
591 0 : nRetval = pNode->GetFrequency();
592 : }
593 : }
594 : else
595 : {
596 : // #i38135# not initialized, return default
597 0 : nRetval = mnFrequency;
598 : }
599 :
600 0 : return nRetval;
601 : }
602 :
603 0 : void ActivityImpl::updateShapeAttributes(
604 : double fTime, basegfx::B2DRectangle const& parentBounds )
605 : {
606 : OSL_ASSERT( meAnimKind != drawing::TextAnimationKind_NONE );
607 0 : if( meAnimKind == drawing::TextAnimationKind_NONE )
608 0 : return;
609 :
610 : double const fMixerState = GetMixerState(
611 0 : static_cast<sal_uInt32>(fTime * 1000.0) );
612 :
613 0 : if( meAnimKind == drawing::TextAnimationKind_BLINK )
614 : {
615 : // show/hide text:
616 0 : maShapeAttrLayer.get()->setVisibility( fMixerState < 0.5 );
617 : }
618 0 : else if(mpMetaFile) // scroll mode:
619 : {
620 : //
621 : // keep care: the below code is highly sensible to changes...
622 : //
623 :
624 : // rectangle of the pure text:
625 0 : double const fPaintWidth = maPaintRectangleLogic.GetWidth();
626 0 : double const fPaintHeight = maPaintRectangleLogic.GetHeight();
627 : // rectangle where the scrolling takes place (-> clipping):
628 0 : double const fScrollWidth = maScrollRectangleLogic.GetWidth();
629 0 : double const fScrollHeight = maScrollRectangleLogic.GetHeight();
630 :
631 0 : basegfx::B2DPoint pos, clipPos;
632 :
633 0 : if(ScrollHorizontal())
634 : {
635 0 : double const fOneEquiv( fScrollWidth );
636 0 : double const fZeroEquiv( -fPaintWidth );
637 :
638 0 : pos.setX( fZeroEquiv + (fMixerState * (fOneEquiv - fZeroEquiv)) );
639 :
640 0 : clipPos.setX( -pos.getX() );
641 0 : clipPos.setY( -pos.getY() );
642 :
643 : // #i69844# Compensation for text-wider-than-shape case
644 0 : if( fPaintWidth > fScrollWidth )
645 0 : pos.setX( pos.getX() + (fPaintWidth-fScrollWidth) / 2.0 );
646 : }
647 : else
648 : {
649 : // scroll vertical:
650 0 : double const fOneEquiv( fScrollHeight );
651 0 : double const fZeroEquiv( -fPaintHeight );
652 :
653 0 : pos.setY( fZeroEquiv + (fMixerState * (fOneEquiv - fZeroEquiv)) );
654 :
655 0 : clipPos.setX( -pos.getX() );
656 0 : clipPos.setY( -pos.getY() );
657 :
658 : // #i69844# Compensation for text-higher-than-shape case
659 0 : if( fPaintHeight > fScrollHeight )
660 0 : pos.setY( pos.getY() + (fPaintHeight-fScrollHeight) / 2.0 );
661 : }
662 :
663 : basegfx::B2DPolygon clipPoly(
664 : basegfx::tools::createPolygonFromRect(
665 : basegfx::B2DRectangle( clipPos.getX(),
666 : clipPos.getY(),
667 0 : clipPos.getX() + fScrollWidth,
668 0 : clipPos.getY() + fScrollHeight ) ) );
669 :
670 0 : if( !::basegfx::fTools::equalZero( mfRotationAngle ))
671 : {
672 0 : maShapeAttrLayer.get()->setRotationAngle( mfRotationAngle );
673 0 : double const fRotate = (mfRotationAngle * M_PI / 180.0);
674 0 : basegfx::B2DHomMatrix aTransform;
675 : // position:
676 0 : aTransform.rotate( fRotate );
677 0 : pos *= aTransform;
678 : }
679 :
680 0 : pos += parentBounds.getCenter();
681 0 : maShapeAttrLayer.get()->setPosition( pos );
682 0 : maShapeAttrLayer.get()->setClip( basegfx::B2DPolyPolygon(clipPoly) );
683 : }
684 : }
685 :
686 0 : bool ActivityImpl::perform()
687 : {
688 0 : if( !isActive() )
689 0 : return false;
690 :
691 0 : ENSURE_OR_RETURN_FALSE(
692 : mpDrawShape,
693 : "ActivityImpl::perform(): still active, but NULL draw shape" );
694 :
695 0 : DrawShapeSharedPtr const pParentDrawShape( mpParentDrawShape );
696 0 : if( !pParentDrawShape )
697 0 : return false; // parent has vanished
698 :
699 0 : if( pParentDrawShape->isVisible() )
700 : {
701 0 : if( !mbIsShapeAnimated )
702 : {
703 0 : mpDrawShape->setVisibility(true); // shape may be initially hidden
704 0 : maContext.mpSubsettableShapeManager->enterAnimationMode( mpDrawShape );
705 0 : maTimer.reset();
706 0 : mbIsShapeAnimated = true;
707 : }
708 : // update attributes related to current time:
709 : basegfx::B2DRectangle const parentBounds(
710 0 : pParentDrawShape->getBounds() );
711 :
712 0 : const double nCurrTime( maTimer.getElapsedTime() );
713 0 : updateShapeAttributes( nCurrTime, parentBounds );
714 :
715 : const sal_uInt32 nFrequency(
716 : ImpRegisterAgainScrollTextMixerState(
717 0 : static_cast<sal_uInt32>(nCurrTime * 1000.0)) );
718 :
719 0 : if(nFrequency)
720 : {
721 0 : mpWakeupEvent->start();
722 : mpWakeupEvent->setNextTimeout(
723 0 : std::max(0.1,nFrequency/1000.0) );
724 0 : maContext.mrEventQueue.addEvent( mpWakeupEvent );
725 :
726 0 : if( mpDrawShape->isContentChanged() )
727 0 : maContext.mpSubsettableShapeManager->notifyShapeUpdate( mpDrawShape );
728 : }
729 : // else: finished, not need to wake up again.
730 : }
731 : else
732 : {
733 : // busy-wait, until parent shape gets visible
734 0 : mpWakeupEvent->start();
735 0 : mpWakeupEvent->setNextTimeout( 2.0 );
736 : }
737 :
738 : // don't reinsert, WakeupEvent will perform that after the given timeout:
739 0 : return false;
740 : }
741 :
742 0 : ActivityImpl::ActivityImpl(
743 : SlideShowContext const& rContext,
744 : boost::shared_ptr<WakeupEvent> const& pWakeupEvent,
745 : boost::shared_ptr<DrawShape> const& pParentDrawShape )
746 : : maContext(rContext),
747 : mpWakeupEvent(pWakeupEvent),
748 : mpParentDrawShape(pParentDrawShape),
749 0 : mpListener( new IntrinsicAnimationListener(*this) ),
750 0 : maTimer(rContext.mrEventQueue.getTimer()),
751 : mbIsShapeAnimated(false),
752 : mbIsDisposed(false),
753 : mbIsActive(true),
754 : meAnimKind(drawing::TextAnimationKind_NONE),
755 0 : mnStartTime(0L)
756 : {
757 : // get doctreenode:
758 0 : sal_Int32 const nNodes = pParentDrawShape->getNumberOfTreeNodes(
759 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH );
760 :
761 : DocTreeNode scrollTextNode(
762 0 : pParentDrawShape->getTreeNode(
763 0 : 0, DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ));
764 : // xxx todo: remove this hack
765 0 : if( nNodes > 1 )
766 : scrollTextNode.setEndIndex(
767 0 : pParentDrawShape->getTreeNode(
768 : nNodes - 1,
769 0 : DocTreeNode::NODETYPE_LOGICAL_PARAGRAPH ).getEndIndex());
770 :
771 : // TODO(Q3): Doing this manually, instead of using
772 : // ShapeSubset. This is because of lifetime issues (ShapeSubset
773 : // generates circular references to parent shape)
774 : mpDrawShape = boost::dynamic_pointer_cast<DrawShape>(
775 0 : maContext.mpSubsettableShapeManager->getSubsetShape(
776 : pParentDrawShape,
777 0 : scrollTextNode ));
778 :
779 0 : mpMetaFile = mpDrawShape->forceScrollTextMetaFile();
780 :
781 : // make scroll text invisible for slide transition bitmaps
782 0 : mpDrawShape->setVisibility(false);
783 :
784 0 : basegfx::B2DRectangle aScrollRect, aPaintRect;
785 0 : ENSURE_OR_THROW( getRectanglesFromScrollMtf( aScrollRect,
786 : aPaintRect,
787 : mpMetaFile ),
788 : "ActivityImpl::ActivityImpl(): Could not extract "
789 : "scroll anim rectangles from mtf" );
790 :
791 : maScrollRectangleLogic = vcl::unotools::rectangleFromB2DRectangle(
792 0 : aScrollRect );
793 : maPaintRectangleLogic = vcl::unotools::rectangleFromB2DRectangle(
794 0 : aPaintRect );
795 :
796 0 : maShapeAttrLayer.createAttributeLayer(mpDrawShape);
797 :
798 0 : uno::Reference<drawing::XShape> const xShape( mpDrawShape->getXShape() );
799 0 : uno::Reference<beans::XPropertySet> const xProps( xShape, uno::UNO_QUERY_THROW );
800 :
801 0 : getPropertyValue( meAnimKind, xProps, OUSTR("TextAnimationKind") );
802 : OSL_ASSERT( meAnimKind != drawing::TextAnimationKind_NONE );
803 0 : mbAlternate = (meAnimKind == drawing::TextAnimationKind_ALTERNATE);
804 0 : mbScrollIn = (meAnimKind == drawing::TextAnimationKind_SLIDE);
805 :
806 : // adopted from in AInfoBlinkText::ImplInit():
807 0 : sal_Int16 nRepeat(0);
808 0 : getPropertyValue( nRepeat, xProps, OUSTR("TextAnimationCount") );
809 0 : mnRepeat = nRepeat;
810 :
811 0 : if(mbAlternate)
812 : {
813 : // force visible when started for scroll-forth-and-back, because
814 : // slide has been coming in with visible text in the middle:
815 0 : mbVisibleWhenStarted = true;
816 : }
817 : else
818 : {
819 : getPropertyValue( mbVisibleWhenStarted, xProps,
820 0 : OUSTR("TextAnimationStartInside") );
821 : }
822 :
823 : // set visible when stopped
824 : getPropertyValue( mbVisibleWhenStopped, xProps,
825 0 : OUSTR("TextAnimatiogonStopInside") );
826 : // rotation:
827 : getPropertyValue( mfRotationAngle, xProps,
828 0 : OUSTR("RotateAngle") );
829 0 : mfRotationAngle /= -100.0; // (switching direction)
830 :
831 : // set frequency
832 0 : sal_Int16 nDelay(0);
833 0 : getPropertyValue( nDelay, xProps, OUSTR("TextAnimationDelay") );
834 : // set delay if not automatic
835 : mnFrequency = (nDelay ? nDelay :
836 : // default:
837 : meAnimKind == drawing::TextAnimationKind_BLINK
838 0 : ? 250L : 50L );
839 :
840 : // adopted from in AInfoScrollText::ImplInit():
841 :
842 : // If it is a simple m_bScrollIn, reset some parameters
843 0 : if( DoScrollIn() )
844 : {
845 : // most parameters are set correctly from the dialog logic, but
846 : // eg VisisbleWhenStopped is grayed out and needs to be corrected here.
847 0 : mbVisibleWhenStopped = true;
848 0 : mbVisibleWhenStarted = false;
849 0 : mnRepeat = 0L;
850 : }
851 :
852 : // Get animation direction
853 0 : getPropertyValue( meDirection, xProps, OUSTR("TextAnimationDirection") );
854 :
855 : // Get step width. Negative means pixel, positive logical units
856 0 : getPropertyValue( mnStepWidth, xProps, OUSTR("TextAnimationAmount") );
857 :
858 0 : maContext.mpSubsettableShapeManager->addIntrinsicAnimationHandler(
859 0 : mpListener );
860 0 : }
861 :
862 0 : bool ActivityImpl::enableAnimations()
863 : {
864 0 : mbIsActive = true;
865 : return maContext.mrActivitiesQueue.addActivity(
866 0 : shared_from_this() );
867 : }
868 :
869 0 : ActivityImpl::~ActivityImpl()
870 : {
871 0 : }
872 :
873 0 : void ActivityImpl::dispose()
874 : {
875 0 : if( !mbIsDisposed )
876 : {
877 0 : end();
878 :
879 : // only remove subset here, since end() is called on slide end
880 : // (and we must not spoil the slide preview bitmap with scroll
881 : // text)
882 0 : maShapeAttrLayer.reset();
883 0 : if( mpDrawShape )
884 : {
885 : // TODO(Q3): Doing this manually, instead of using
886 : // ShapeSubset. This is because of lifetime issues
887 : // (ShapeSubset generates circular references to parent
888 : // shape)
889 0 : DrawShapeSharedPtr pParent( mpParentDrawShape.lock() );
890 0 : if( pParent )
891 0 : maContext.mpSubsettableShapeManager->revokeSubset(
892 : pParent,
893 0 : mpDrawShape );
894 : }
895 :
896 0 : mpMetaFile.reset();
897 0 : mpDrawShape.reset();
898 0 : mpParentDrawShape.reset();
899 0 : mpWakeupEvent.reset();
900 0 : maContext.dispose();
901 0 : mbIsDisposed = true;
902 :
903 0 : maContext.mpSubsettableShapeManager->removeIntrinsicAnimationHandler(
904 0 : mpListener );
905 : }
906 0 : }
907 :
908 0 : double ActivityImpl::calcTimeLag() const
909 : {
910 0 : return 0.0;
911 : }
912 :
913 0 : bool ActivityImpl::isActive() const
914 : {
915 0 : return mbIsActive;
916 : }
917 :
918 0 : void ActivityImpl::dequeued()
919 : {
920 : // not used here
921 0 : }
922 :
923 0 : void ActivityImpl::end()
924 : {
925 : // not used here
926 0 : mbIsActive = false;
927 :
928 0 : if( mbIsShapeAnimated )
929 : {
930 0 : maContext.mpSubsettableShapeManager->leaveAnimationMode( mpDrawShape );
931 0 : mbIsShapeAnimated = false;
932 : }
933 0 : }
934 :
935 : } // anon namespace
936 :
937 : namespace slideshow {
938 : namespace internal {
939 :
940 0 : boost::shared_ptr<Activity> createDrawingLayerAnimActivity(
941 : SlideShowContext const& rContext,
942 : boost::shared_ptr<DrawShape> const& pDrawShape )
943 : {
944 0 : boost::shared_ptr<Activity> pActivity;
945 :
946 : try
947 : {
948 : boost::shared_ptr<WakeupEvent> const pWakeupEvent(
949 0 : new WakeupEvent( rContext.mrEventQueue.getTimer(),
950 0 : rContext.mrActivitiesQueue ) );
951 0 : pActivity.reset( new ActivityImpl( rContext, pWakeupEvent, pDrawShape ) );
952 0 : pWakeupEvent->setActivity( pActivity );
953 : }
954 0 : catch( uno::RuntimeException& )
955 : {
956 0 : throw;
957 : }
958 0 : catch( uno::Exception& )
959 : {
960 : // translate any error into empty factory product.
961 : OSL_FAIL( rtl::OUStringToOString(
962 : comphelper::anyToString( cppu::getCaughtException() ),
963 : RTL_TEXTENCODING_UTF8 ).getStr() );
964 : }
965 :
966 0 : return pActivity;
967 : }
968 :
969 : } // namespace internal
970 0 : } // namespace presentation
971 :
972 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
