| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_slideshow.hxx" | |
| // must be first | |
| #include <canvas/debug.hxx> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <simplecontinuousactivitybase.hxx> | |
| namespace slideshow | |
| { | |
| namespace internal | |
| { | |
| SimpleContinuousActivityBase::SimpleContinuousActivityBase( | |
| const ActivityParameters& rParms ) : | |
| ActivityBase( rParms ), | |
| maTimer( rParms.mrActivitiesQueue.getTimer() ), | |
| mnMinSimpleDuration( rParms.mnMinDuration ), | |
| mnMinNumberOfFrames( rParms.mnMinNumberOfFrames ), | |
| mnCurrPerformCalls( 0 ) | |
| { | |
| } | |
| void SimpleContinuousActivityBase::startAnimation() | |
| { | |
| // init timer. We measure animation time only when we're | |
| // actually started. | |
| maTimer.reset(); | |
| } | |
| double SimpleContinuousActivityBase::calcTimeLag() const | |
| { | |
| ActivityBase::calcTimeLag(); | |
| if (! isActive()) | |
| return 0.0; | |
| // retrieve locally elapsed time | |
| const double nCurrElapsedTime( maTimer.getElapsedTime() ); | |
| // log time | |
| VERBOSE_TRACE( "SimpleContinuousActivityBase::calcTimeLag(): " | |
| "next step is based on time: %f", nCurrElapsedTime ); | |
| // go to great length to ensure a proper animation | |
| // run. Since we don't know how often we will be called | |
| // here, try to spread the animator calls uniquely over | |
| // the [0,1] parameter range. Be aware of the fact that | |
| // perform will be called at least mnMinNumberOfTurns | |
| // times. | |
| // fraction of time elapsed | |
| const double nFractionElapsedTime( | |
| nCurrElapsedTime / mnMinSimpleDuration ); | |
| // fraction of minimum calls performed | |
| const double nFractionRequiredCalls( | |
| double(mnCurrPerformCalls) / mnMinNumberOfFrames ); | |
| // okay, so now, the decision is easy: | |
| // | |
| // If the fraction of time elapsed is smaller than the | |
| // number of calls required to be performed, then we calc | |
| // the position on the animation range according to | |
| // elapsed time. That is, we're so to say ahead of time. | |
| // | |
| // In contrary, if the fraction of time elapsed is larger, | |
| // then we're lagging, and we thus calc the position on | |
| // the animation time line according to the fraction of | |
| // calls performed. Thus, the animation is forced to slow | |
| // down, and take the required minimal number of steps, | |
| // sufficiently equally distributed across the animation | |
| // time line. | |
| if( nFractionElapsedTime < nFractionRequiredCalls ) | |
| { | |
| VERBOSE_TRACE( "SimpleContinuousActivityBase::calcTimeLag(): " | |
| "t=%f is based on time", nFractionElapsedTime ); | |
| return 0.0; | |
| } | |
| else | |
| { | |
| VERBOSE_TRACE( "SimpleContinuousActivityBase::perform(): " | |
| "t=%f is based on number of calls", | |
| nFractionRequiredCalls ); | |
| // lag global time, so all other animations lag, too: | |
| return ((nFractionElapsedTime - nFractionRequiredCalls) | |
| * mnMinSimpleDuration); | |
| } | |
| } | |
| bool SimpleContinuousActivityBase::perform() | |
| { | |
| // call base class, for start() calls and end handling | |
| if( !ActivityBase::perform() ) | |
| return false; // done, we're ended | |
| // get relative animation position | |
| // =============================== | |
| const double nCurrElapsedTime( maTimer.getElapsedTime() ); | |
| double nT( nCurrElapsedTime / mnMinSimpleDuration ); | |
| // one of the stop criteria reached? | |
| // ================================= | |
| // will be set to true below, if one of the termination criteria | |
| // matched. | |
| bool bActivityEnding( false ); | |
| if( isRepeatCountValid() ) | |
| { | |
| // Finite duration | |
| // =============== | |
| // When we've autoreverse on, the repeat count | |
| // doubles | |
| const double nRepeatCount( getRepeatCount() ); | |
| const double nEffectiveRepeat( isAutoReverse() ? | |
| 2.0*nRepeatCount : | |
| nRepeatCount ); | |
| // time (or frame count) elapsed? | |
| if( nEffectiveRepeat <= nT ) | |
| { | |
| // okee. done for now. Will not exit right here, | |
| // to give animation the chance to render the last | |
| // frame below | |
| bActivityEnding = true; | |
| // clamp animation to max permissible value | |
| nT = nEffectiveRepeat; | |
| } | |
| } | |
| // need to do auto-reverse? | |
| // ======================== | |
| double nRepeats; | |
| double nRelativeSimpleTime; | |
| // TODO(Q3): Refactor this mess | |
| if( isAutoReverse() ) | |
| { | |
| // divert active duration into repeat and | |
| // fractional part. | |
| const double nFractionalActiveDuration( modf(nT, &nRepeats) ); | |
| // for auto-reverse, map ranges [1,2), [3,4), ... | |
| // to ranges [0,1), [1,2), etc. | |
| if( ((int)nRepeats) % 2 ) | |
| { | |
| // we're in an odd range, reverse sweep | |
| nRelativeSimpleTime = 1.0 - nFractionalActiveDuration; | |
| } | |
| else | |
| { | |
| // we're in an even range, pass on as is | |
| nRelativeSimpleTime = nFractionalActiveDuration; | |
| } | |
| // effective repeat count for autoreverse is half of | |
| // the input time's value (each run of an autoreverse | |
| // cycle is half of a repeat) | |
| nRepeats /= 2; | |
| } | |
| else | |
| { | |
| // determine repeat | |
| // ================ | |
| // calc simple time and number of repeats from nT | |
| // Now, that's easy, since the fractional part of | |
| // nT gives the relative simple time, and the | |
| // integer part the number of full repeats: | |
| nRelativeSimpleTime = modf(nT, &nRepeats); | |
| // clamp repeats to max permissible value (maRepeats.getValue() - 1.0) | |
| if( isRepeatCountValid() && | |
| nRepeats >= getRepeatCount() ) | |
| { | |
| // Note that this code here only gets | |
| // triggered if maRepeats.getValue() is an | |
| // _integer_. Otherwise, nRepeats will never | |
| // reach nor exceed | |
| // maRepeats.getValue(). Thus, the code below | |
| // does not need to handle cases of fractional | |
| // repeats, and can always assume that a full | |
| // animation run has ended (with | |
| // nRelativeSimpleTime=1.0 for | |
| // non-autoreversed activities). | |
| // with modf, nRelativeSimpleTime will never | |
| // become 1.0, since nRepeats is incremented and | |
| // nRelativeSimpleTime set to 0.0 then. | |
| // | |
| // For the animation to reach its final value, | |
| // nRepeats must although become | |
| // maRepeats.getValue()-1.0, and | |
| // nRelativeSimpleTime=1.0. | |
| nRelativeSimpleTime = 1.0; | |
| nRepeats -= 1.0; | |
| } | |
| } | |
| // actually perform something | |
| // ========================== | |
| simplePerform( nRelativeSimpleTime, | |
| // nRepeats is already integer-valued | |
| static_cast<sal_uInt32>( nRepeats ) ); | |
| // delayed endActivity() call from end condition check | |
| // below. Issued after the simplePerform() call above, to | |
| // give animations the chance to correctly reach the | |
| // animation end value, without spurious bail-outs because | |
| // of isActive() returning false. | |
| if( bActivityEnding ) | |
| endActivity(); | |
| // one more frame successfully performed | |
| ++mnCurrPerformCalls; | |
| return isActive(); | |
| } | |
| } | |
| } |