/*

* Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Real-time timing model.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <AknsRlParameter.h>

#include "AknsAlTimingModelRealTime.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::CAknsAlTimingModelRealTime

// -----------------------------------------------------------------------------

//

CAknsAlTimingModelRealTime::CAknsAlTimingModelRealTime():

    iDuration( 0 ),

    iTotalDuration( 0 ),

    iElapsedTime( 0 ),

    iRelative( 0 ),

    iWrap( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::NewL

// -----------------------------------------------------------------------------

//

CAknsAlTimingModelRealTime* CAknsAlTimingModelRealTime::NewL()

    {

    CAknsAlTimingModelRealTime* self = new(ELeave) CAknsAlTimingModelRealTime();

    return self;

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::CAknsAlTimingModelRealTime

// -----------------------------------------------------------------------------

//

CAknsAlTimingModelRealTime::~CAknsAlTimingModelRealTime()

    {

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::Duration

// -----------------------------------------------------------------------------

//

TInt CAknsAlTimingModelRealTime::Duration() const

    {

    return iDuration;

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::TotalDuration

// -----------------------------------------------------------------------------

//

TInt CAknsAlTimingModelRealTime::TotalDuration() const

    {

    return iTotalDuration;

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::Configure

// -----------------------------------------------------------------------------

//

void CAknsAlTimingModelRealTime::Configure( TInt aD, TInt aRC, TInt aRD, TBool aWrap )

    {

    iElapsedTime = 0;

    iWrap = aWrap;

    iRelative = 0;

    // Because we use fixed point arithmetic, duration and repeat duration

    // absolute value must be clamped.

    if( Defined( aRD ) && aRD > KAlMaxDurationVal )

        {

        aRD = KAlMaxDurationVal;

        }

    if( Defined( aD ) && aD > KAlMaxDurationVal )

        {

        aD = KAlMaxDurationVal;

        }

    // Determine duration and total duration

    if( Defined( aD ) ) // Cases from #6 to #14

        {

        // Duration is the same in all cases

        iDuration = aD;

        if( Infinite( aRC ) )

            {

            if( Undefined( aRD ) ) // #6

                {

                iTotalDuration = -1;

                }

            else if( Defined( aRD ) ) // #7

                {

                iTotalDuration = aRD;

                }

            else // aRD must be infinite, #8

                {

                iTotalDuration = -1;

                }

            }

        else if( Undefined( aRC ) )

            {

            if( Undefined( aRD ) ) // #9

                {

                iTotalDuration = aD;

                }

            else if( Defined( aRD ) ) // #10

                {

                iTotalDuration = aRD;

                }

            else // aRD must be infinite, #11

                {

                iTotalDuration = -1;

                }

            }

        else // aRC must be defined

            {

            if( Undefined( aRD ) ) // #12

                {

                iTotalDuration = aD * aRC;

                }

            else if( Defined( aRD ) ) // #13

                {

                // total duration = MIN( D * RC, RD )

                iTotalDuration = aD * aRC < aRD ? aD * aRC: aRD;

                }

            else // aRD must be infinite, #14

                {

                iTotalDuration = aD * aRC;

                }

            }

        }

    else if( Infinite( aD ) ) // Cases from #15 to #17

        {

        // Repeat count is ignored

        if( Defined( aRD ) ) // #15

            {

            iDuration      = aRD;

            iTotalDuration = aRD;

            }

        else // #16 and #17

            {

            // Undefined and infinite produce the same result

            iDuration      = -1;

            iTotalDuration = -1;

            }

        }

    else // Duration is undefined, cases from #1 to #5

        {

        // Cases, #4 and #5

        if( Undefined( aRD ) && !Infinite( aRC ) )

            {

            // These are basically impossible cases

            iDuration      = 0;

            iTotalDuration = 0;

            }

        // Case #1

        else if( Defined( aRD ) )

            {

            iDuration      = aRD;

            iTotalDuration = aRD;

            }

        else // Must be cases #2 and #3

            {

            iDuration      = -1;

            iTotalDuration = -1;

            }

         }

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::SetParametersL

// -----------------------------------------------------------------------------

//

void CAknsAlTimingModelRealTime::SetParametersL(

    MAknsRlParameterIterator& aParameters )

    {

    TInt duration = 0;

    TInt repeatCount = 0;

    TInt repeatDuration = 0;

    TBool wrap = EFalse;

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

        if( param->iName->Compare( KAknsAlRealTimeDuration ) == 0 )

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            duration = param->iNumber;

            }

        else if( param->iName->Compare( KAknsAlRealTimeRepeatCount ) == 0 )

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            repeatCount = param->iNumber;

            }

        else if( param->iName->Compare( KAknsAlRealTimeRepeatDuration ) == 0 )

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            repeatDuration = param->iNumber;

            }

        else if( param->iName->Compare( KAknsAlRealTimeWrap ) == 0 )

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            wrap = ( param->iNumber != 0 ) ? ETrue: EFalse;

            }

        }

    // Configure the model

    Configure( duration, repeatCount, repeatDuration, wrap );

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::Tick

// -----------------------------------------------------------------------------

//

void CAknsAlTimingModelRealTime::Tick( const TInt aDeltaTime )

    {

    iElapsedTime = iElapsedTime + aDeltaTime;

    // Cases #4 and #5 are the only ones that will produce undefined durations

    // in Configure. This kind of animation will never run properly

    if( Undefined( iDuration ) || Undefined( iTotalDuration ) )

        return;

    // Starting from here the durations are either defined or infinite

    // Check if the the total duration has been exceeded

    if( IsFinished() )

        return;

    // Relative value is undefined if duration is either undefined or infinite

    if( !Defined( iDuration ) ) // iDuration <= 0

        {

        iRelative = 0;

        }

    else // Duration is defined, relative value can be calculated

        {

        // Note: iDuration is always > 0 here

        // Elapsed time and duration always >= 0 -> conversion ok

        TUint32 durationPos = TUint32( iElapsedTime % iDuration ); //lint !e414 iDuration > 0

        TBool ascending = ETrue;

        // When wrapping, odd durations are descending, even ascending

        if( iWrap && ( iElapsedTime / iDuration ) % 2 ) //lint !e414 iDuration > 0 Remainder != 0

            ascending = EFalse;

        // TODO Allow longer durations -> promote results to 64bit integer

        // Calculate the relative value

        if( ascending )

            {

            iRelative = ( durationPos << 16 ) / TUint32( iDuration ); //lint !e414 iDuration > 0

            }

        else // Current range must be descending

            {

            iRelative = ( ( iDuration - durationPos ) << 16 ) / TUint32( iDuration ); //lint !e414 iDuration > 0

            }

        }

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::Tick

// -----------------------------------------------------------------------------

//

void CAknsAlTimingModelRealTime::Tick( const TTime& /*aStamp*/ )

    {

    // Not supported

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::RelativeValue

// -----------------------------------------------------------------------------

//

TUint32 CAknsAlTimingModelRealTime::RelativeValue() const

    {

    return iRelative;

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::IsFinished

// -----------------------------------------------------------------------------

//

TBool CAknsAlTimingModelRealTime::IsFinished() const

    {

    if( Defined( iTotalDuration ) && iElapsedTime > iTotalDuration )

        {

        return ETrue;

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CAknsAlTimingModelRealTime::Begin

// -----------------------------------------------------------------------------

//

void CAknsAlTimingModelRealTime::Begin()

    {

    iElapsedTime = 0;

    iRelative = 0;

    }

// End of file