/*

* 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:  Interface for animation value.

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <e32base.h> // Required to make include AknsRlParameter.h ok

#include <AknsRlParameter.h>

#include "AknsAlAnimationValue.h"

#include "AknsAlPolyLine.h"

#include "AknsAlPolyLine1D.h"

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

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

// CAknsAlValueLinearRange::CAknsAlValueLinearRange

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

//

CAknsAlValueLinearRange::CAknsAlValueLinearRange():

    iValue( 0 ),

    iStart( 0 ),

    iEnd( 255 )

    {}

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

// CAknsAlValueLinearRange::NewL

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

//

CAknsAlValueLinearRange* CAknsAlValueLinearRange::NewL()

    {

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

    return self;

    }

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

// CAknsAlValueLinearRange::~CAknsAlValueLinearRange

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

//

CAknsAlValueLinearRange::~CAknsAlValueLinearRange()

    {

    }

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

// CAknsAlValueLinearRange::Tick

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

//

void CAknsAlValueLinearRange::Tick( TUint32 /*aDeltaTime*/, TUint32 aRelative )

    {

    // Note: It is assumed that arithmetic shifting is supported

    // -> negative values are shifted correctly

    iValue = iStart + ( ( ( iEnd - iStart ) * aRelative ) >> 16 );

    }

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

// CAknsAlValueLinearRange::FillData

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

//

void CAknsAlValueLinearRange::FillData( TAknsRlParameterData& aData ) const

    {

    aData.iType   = EAknsRlParameterTypeNumber;

    aData.iNumber = iValue;

    }

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

// CAknsAlValueLinearRange::SetParametersL

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

//

void CAknsAlValueLinearRange::SetParametersL( MAknsRlParameterIterator& aParameters )

    {

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iStart = param->iNumber;

            }

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iEnd = param->iNumber;

            }

        }

    }

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

// CAknsAlValueLinearRange::Begin

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

//

void CAknsAlValueLinearRange::Begin()

    {

    iValue = iStart;

    }

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

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

// CAknsAlValueConstant::CAknsAlValueConstant

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

//

CAknsAlValueConstant::CAknsAlValueConstant():

    iValue( 0 )

    {}

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

// CAknsAlValueConstant::NewL

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

//

CAknsAlValueConstant* CAknsAlValueConstant::NewL()

    {

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

    return self;

    }

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

// CAknsAlValueConstant::~CAknsAlValueConstant

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

//

CAknsAlValueConstant::~CAknsAlValueConstant()

    {

    }

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

// CAknsAlValueConstant::Tick

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

//

void CAknsAlValueConstant::Tick( TUint32 /*aDeltaTime*/, TUint32 /*aRelative*/ )

    {

    }

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

// CAknsAlValueConstant::FillData

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

//

void CAknsAlValueConstant::FillData( TAknsRlParameterData& aData ) const

    {

    aData.iType   = EAknsRlParameterTypeNumber;

    aData.iNumber = iValue;

    }

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

// CAknsAlValueConstant::SetParametersL

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

//

void CAknsAlValueConstant::SetParametersL( MAknsRlParameterIterator& aParameters )

    {

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iValue = param->iNumber;

            }

        }

    }

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

// CAknsAlValueConstant::Begin

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

//

void CAknsAlValueConstant::Begin()

    {

    }

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

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

// CAknsAlValueRandom::CAknsAlValueRandom

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

//

CAknsAlValueRandom::CAknsAlValueRandom():

    iCurrentSeed( 0 ),

    iValue( 0 ),

    iMin( 0 ),

    iMax( 255 )

    {}

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

// CAknsAlValueRandom::NewL

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

//

CAknsAlValueRandom* CAknsAlValueRandom::NewL()

    {

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

    return self;

    }

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

// CAknsAlValueRandom::~CAknsAlValueRandom

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

//

CAknsAlValueRandom::~CAknsAlValueRandom()

    {

    }

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

// CAknsAlValueRandom::Tick

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

//

void CAknsAlValueRandom::Tick( TUint32 /*aDeltaTime*/, TUint32 /*aRelative*/ )

    {

    // iMax - iMin is always > 0

    iValue = iMin + ( Math::Rand( iCurrentSeed ) % ( iMax - iMin ) );

    }

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

// CAknsAlValueRandom::FillData

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

//

void CAknsAlValueRandom::FillData( TAknsRlParameterData& aData ) const

    {

    aData.iType   = EAknsRlParameterTypeNumber;

    aData.iNumber = iValue;

    }

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

// CAknsAlValueRandom::SetParametersL

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

//

void CAknsAlValueRandom::SetParametersL( MAknsRlParameterIterator& aParameters )

    {

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iMin = param->iNumber;

            }

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iMax = param->iNumber;

            }

        }

    // Sanity check

    if( iMax <= iMin )

        User::Leave( KErrArgument );

    // Randomize the starting seed

    iCurrentSeed = TInt64( User::TickCount() );

    }

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

// CAknsAlValueRandom::Begin

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

//

void CAknsAlValueRandom::Begin()

    {

    iCurrentSeed = TInt64( User::TickCount() );

    }

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

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

// CAknsAlValuePoly1D::CAknsAlValuePoly1D

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

//

CAknsAlValuePoly1D::CAknsAlValuePoly1D()

    {

    // Derived from CBase -> members zeroed

    }

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

// CAknsAlValuePoly1D::ConstructL

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

//

void CAknsAlValuePoly1D::ConstructL()

    {

    iPoly = CAknsAlPolyLine1D::NewL();

    }

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

// CAknsAlValuePoly1D::NewL

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

//

CAknsAlValuePoly1D* CAknsAlValuePoly1D::NewL()

    {

    CAknsAlValuePoly1D* self =

        new(ELeave) CAknsAlValuePoly1D();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknsAlValuePoly1D::~CAknsAlValuePoly1D

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

//

CAknsAlValuePoly1D::~CAknsAlValuePoly1D()

    {

    delete iPoly; //lint !e1551 Doesn't throw exception

    }

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

// CAknsAlValuePoly1D::Tick

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

//

void CAknsAlValuePoly1D::Tick( TUint32 /*aDeltaTime*/, TUint32 aRelative )

    {

    TPoint p = iPoly->GetPolyPoint( aRelative << 16 ); // Make relative .32 integer

    iValue = p.iY;

    }

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

// CAknsAlValuePoly1D::FillData

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

//

void CAknsAlValuePoly1D::FillData(

    TAknsRlParameterData& aData ) const

    {

    aData.iType   = EAknsRlParameterTypeNumber;

    aData.iNumber = iValue;

    }

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

// CAknsAlValuePoly1D::SetParametersL

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

//

void CAknsAlValuePoly1D::SetParametersL(

    MAknsRlParameterIterator& aParameters )

    {

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

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

            {

            if( param->iType != EAknsRlParameterTypeString )

                User::Leave( KErrArgument );

            if( !param->iString )

                User::Leave( KErrArgument );

            if( ( param->iString->Length() % 2 ) != 0 ) // Array size is odd

                User::Leave( KErrArgument );

            iPoly->SetPolyPoints1DL( *(param->iString) );

            iPoly->CalculateLengthsL();

            }

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

            {

            if( param->iType != EAknsRlParameterTypeNumber )

                User::Leave( KErrArgument );

            iPoly->SetScaledArea( TSize( 1, param->iNumber ) );

            }

        }

    }

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

// CAknsAlValuePoly1D::Begin

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

//

void CAknsAlValuePoly1D::Begin()

    {

    TPoint p = iPoly->GetPolyPoint( 0 );

    iValue = p.iY;

    }

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

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

// CAknsAlValuePoly2D::CAknsAlValuePoly2D

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

//

CAknsAlValuePoly2D::CAknsAlValuePoly2D()

    {

    // Derived from CBase -> members zeroed

    }

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

// CAknsAlValuePoly2D::ConstructL

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

//

void CAknsAlValuePoly2D::ConstructL()

    {

    iPoly = CAknsAlPolyLine::NewL();

    iValue.SetLength(2);

    iValue[0] = 0;

    iValue[1] = 0;

    }

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

// CAknsAlValuePoly2D::NewL

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

//

CAknsAlValuePoly2D* CAknsAlValuePoly2D::NewL()

    {

    CAknsAlValuePoly2D* self =

        new(ELeave) CAknsAlValuePoly2D();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknsAlValuePoly2D::~CAknsAlValuePoly2D

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

//

CAknsAlValuePoly2D::~CAknsAlValuePoly2D()

    {

    delete iPoly; //lint !e1551 Doesn't throw exception

    }

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

// CAknsAlValuePoly2D::Tick

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

//

void CAknsAlValuePoly2D::Tick(

    TUint32 /*aDeltaTime*/, TUint32 aRelative )

    {

    TPoint p = iPoly->GetPolyPoint( aRelative << 16 ); // Make relative .32 integer

    iValue[0] = p.iX;

    iValue[1] = p.iY;

    }

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

// CAknsAlValuePoly2D::FillData

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

//

void CAknsAlValuePoly2D::FillData(

    TAknsRlParameterData& aData ) const

    {

    aData.iType   = EAknsRlParameterTypeString;

    aData.iString = &iValue;

    }

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

// CAknsAlValuePoly2D::SetParametersL

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

//

void CAknsAlValuePoly2D::SetParametersL(

    MAknsRlParameterIterator& aParameters )

    {

    // Iterate over available parameters

    while( aParameters.HasNext() )

        {

        const TAknsRlParameterData* param = aParameters.NextL();

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

            {

            if( param->iType != EAknsRlParameterTypeString )

                User::Leave( KErrArgument );

            if( !param->iString )

                User::Leave( KErrArgument );

            if( ( param->iString->Length() % 2 ) != 0 ) // Array size is odd

                User::Leave( KErrArgument );

            iPoly->SetPolyPointsL( *(param->iString) );

            iPoly->CalculateLengthsL();

            }

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

            {

            if( param->iType != EAknsRlParameterTypeString )

                User::Leave( KErrArgument );

            if( !param->iString )

                User::Leave( KErrArgument );

            // We need 2 or more elements

            if( param->iString->Length() < 2 )

                User::Leave( KErrArgument );

            iPoly->SetScaledArea( TSize( (*param->iString)[0],

                                         (*param->iString)[1] ) );

            }

        }

    }

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

// CAknsAlValuePoly2D::Begin

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

//

void CAknsAlValuePoly2D::Begin()

    {

    TPoint p = iPoly->GetPolyPoint( 0 );

    iValue[0] = p.iX;

    iValue[1] = p.iY;

    }