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 <simplecontinuousactivitybase.hxx>
26 :
27 :
28 : namespace slideshow
29 : {
30 : namespace internal
31 : {
32 0 : SimpleContinuousActivityBase::SimpleContinuousActivityBase(
33 : const ActivityParameters& rParms ) :
34 : ActivityBase( rParms ),
35 0 : maTimer( rParms.mrActivitiesQueue.getTimer() ),
36 : mnMinSimpleDuration( rParms.mnMinDuration ),
37 : mnMinNumberOfFrames( rParms.mnMinNumberOfFrames ),
38 0 : mnCurrPerformCalls( 0 )
39 : {
40 0 : }
41 :
42 0 : void SimpleContinuousActivityBase::startAnimation()
43 : {
44 : // init timer. We measure animation time only when we're
45 : // actually started.
46 0 : maTimer.reset();
47 0 : }
48 :
49 0 : double SimpleContinuousActivityBase::calcTimeLag() const
50 : {
51 0 : ActivityBase::calcTimeLag();
52 0 : if (! isActive())
53 0 : return 0.0;
54 :
55 : // retrieve locally elapsed time
56 0 : const double nCurrElapsedTime( maTimer.getElapsedTime() );
57 :
58 : // log time
59 : VERBOSE_TRACE( "SimpleContinuousActivityBase::calcTimeLag(): "
60 : "next step is based on time: %f", nCurrElapsedTime );
61 :
62 : // go to great length to ensure a proper animation
63 : // run. Since we don't know how often we will be called
64 : // here, try to spread the animator calls uniquely over
65 : // the [0,1] parameter range. Be aware of the fact that
66 : // perform will be called at least mnMinNumberOfTurns
67 : // times.
68 :
69 : // fraction of time elapsed
70 : const double nFractionElapsedTime(
71 0 : nCurrElapsedTime / mnMinSimpleDuration );
72 :
73 : // fraction of minimum calls performed
74 : const double nFractionRequiredCalls(
75 0 : double(mnCurrPerformCalls) / mnMinNumberOfFrames );
76 :
77 : // okay, so now, the decision is easy:
78 :
79 : // If the fraction of time elapsed is smaller than the
80 : // number of calls required to be performed, then we calc
81 : // the position on the animation range according to
82 : // elapsed time. That is, we're so to say ahead of time.
83 :
84 : // In contrary, if the fraction of time elapsed is larger,
85 : // then we're lagging, and we thus calc the position on
86 : // the animation time line according to the fraction of
87 : // calls performed. Thus, the animation is forced to slow
88 : // down, and take the required minimal number of steps,
89 : // sufficiently equally distributed across the animation
90 : // time line.
91 0 : if( nFractionElapsedTime < nFractionRequiredCalls )
92 : {
93 : VERBOSE_TRACE( "SimpleContinuousActivityBase::calcTimeLag(): "
94 : "t=%f is based on time", nFractionElapsedTime );
95 0 : return 0.0;
96 : }
97 : else
98 : {
99 : VERBOSE_TRACE( "SimpleContinuousActivityBase::perform(): "
100 : "t=%f is based on number of calls",
101 : nFractionRequiredCalls );
102 :
103 : // lag global time, so all other animations lag, too:
104 0 : return ((nFractionElapsedTime - nFractionRequiredCalls)
105 0 : * mnMinSimpleDuration);
106 : }
107 : }
108 :
109 0 : bool SimpleContinuousActivityBase::perform()
110 : {
111 : // call base class, for start() calls and end handling
112 0 : if( !ActivityBase::perform() )
113 0 : return false; // done, we're ended
114 :
115 :
116 : // get relative animation position
117 : // ===============================
118 :
119 0 : const double nCurrElapsedTime( maTimer.getElapsedTime() );
120 0 : double nT( nCurrElapsedTime / mnMinSimpleDuration );
121 :
122 :
123 : // one of the stop criteria reached?
124 : // =================================
125 :
126 : // will be set to true below, if one of the termination criteria
127 : // matched.
128 0 : bool bActivityEnding( false );
129 :
130 0 : if( isRepeatCountValid() )
131 : {
132 : // Finite duration
133 : // ===============
134 :
135 : // When we've autoreverse on, the repeat count
136 : // doubles
137 0 : const double nRepeatCount( getRepeatCount() );
138 0 : const double nEffectiveRepeat( isAutoReverse() ?
139 : 2.0*nRepeatCount :
140 0 : nRepeatCount );
141 :
142 : // time (or frame count) elapsed?
143 0 : if( nEffectiveRepeat <= nT )
144 : {
145 : // okee. done for now. Will not exit right here,
146 : // to give animation the chance to render the last
147 : // frame below
148 0 : bActivityEnding = true;
149 :
150 : // clamp animation to max permissible value
151 0 : nT = nEffectiveRepeat;
152 : }
153 : }
154 :
155 :
156 : // need to do auto-reverse?
157 : // ========================
158 :
159 : double nRepeats;
160 : double nRelativeSimpleTime;
161 :
162 : // TODO(Q3): Refactor this mess
163 0 : if( isAutoReverse() )
164 : {
165 : // divert active duration into repeat and
166 : // fractional part.
167 0 : const double nFractionalActiveDuration( modf(nT, &nRepeats) );
168 :
169 : // for auto-reverse, map ranges [1,2), [3,4), ...
170 : // to ranges [0,1), [1,2), etc.
171 0 : if( ((int)nRepeats) % 2 )
172 : {
173 : // we're in an odd range, reverse sweep
174 0 : nRelativeSimpleTime = 1.0 - nFractionalActiveDuration;
175 : }
176 : else
177 : {
178 : // we're in an even range, pass on as is
179 0 : nRelativeSimpleTime = nFractionalActiveDuration;
180 : }
181 :
182 : // effective repeat count for autoreverse is half of
183 : // the input time's value (each run of an autoreverse
184 : // cycle is half of a repeat)
185 0 : nRepeats /= 2;
186 : }
187 : else
188 : {
189 : // determine repeat
190 : // ================
191 :
192 : // calc simple time and number of repeats from nT
193 : // Now, that's easy, since the fractional part of
194 : // nT gives the relative simple time, and the
195 : // integer part the number of full repeats:
196 0 : nRelativeSimpleTime = modf(nT, &nRepeats);
197 :
198 : // clamp repeats to max permissible value (maRepeats.getValue() - 1.0)
199 0 : if( isRepeatCountValid() &&
200 0 : nRepeats >= getRepeatCount() )
201 : {
202 : // Note that this code here only gets
203 : // triggered if maRepeats.getValue() is an
204 : // _integer_. Otherwise, nRepeats will never
205 : // reach nor exceed
206 : // maRepeats.getValue(). Thus, the code below
207 : // does not need to handle cases of fractional
208 : // repeats, and can always assume that a full
209 : // animation run has ended (with
210 : // nRelativeSimpleTime=1.0 for
211 : // non-autoreversed activities).
212 :
213 : // with modf, nRelativeSimpleTime will never
214 : // become 1.0, since nRepeats is incremented and
215 : // nRelativeSimpleTime set to 0.0 then.
216 :
217 : // For the animation to reach its final value,
218 : // nRepeats must although become
219 : // maRepeats.getValue()-1.0, and
220 : // nRelativeSimpleTime=1.0.
221 0 : nRelativeSimpleTime = 1.0;
222 0 : nRepeats -= 1.0;
223 : }
224 : }
225 :
226 : // actually perform something
227 : // ==========================
228 :
229 : simplePerform( nRelativeSimpleTime,
230 : // nRepeats is already integer-valued
231 0 : static_cast<sal_uInt32>( nRepeats ) );
232 :
233 :
234 : // delayed endActivity() call from end condition check
235 : // below. Issued after the simplePerform() call above, to
236 : // give animations the chance to correctly reach the
237 : // animation end value, without spurious bail-outs because
238 : // of isActive() returning false.
239 0 : if( bActivityEnding )
240 0 : endActivity();
241 :
242 : // one more frame successfully performed
243 0 : ++mnCurrPerformCalls;
244 :
245 0 : return isActive();
246 : }
247 : }
248 3 : }
249 :
250 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
