/************************************************************** * * 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 #include #include 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( 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(); } } }