/*
* Copyright (c) 2005-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:  Utility class for storing animation value and binding the animation
*                value to timing model.
*
*/


// INCLUDE FILES
#include "AknsAlShared.h"

#include "AknsRlEffectPlugin.h"
#include "AknsAlEffectParamContainer.h"

// ============================ MEMBER FUNCTIONS ===============================
/**
* Utility class for binding animation value to name.
*/
NONSHARABLE_CLASS( CAknsAlNamedReference ): public CBase
    {
    protected:
        CAknsAlNamedReference();
        void ConstructL( const TDesC& aName,
                         const MAknsAlAnimationValue* aValue );

    public:
        ~CAknsAlNamedReference();
        static CAknsAlNamedReference* NewL(  const TDesC& aName,
                                             const MAknsAlAnimationValue* aValue );
        inline void FillData( TAknsRlParameterData& aData ) const;

    private:
        HBufC* iName; // Owned
        const MAknsAlAnimationValue* iAnimationValue; // Referenced only
    };

// -----------------------------------------------------------------------------
// CAknsAlNamedReference::CAknsAlNamedReference
// -----------------------------------------------------------------------------
//
CAknsAlNamedReference::CAknsAlNamedReference()
    {
    // Derived from CBase -> members are zeroed
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReference::ConstructL
// -----------------------------------------------------------------------------
//
void CAknsAlNamedReference::ConstructL(
    const TDesC& aName, const MAknsAlAnimationValue* aValue )
    {
    if( NULL == aValue )
        User::Leave( KErrArgument );

    iAnimationValue = aValue;
    iName           = aName.AllocL();
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReference::~CAknsAlNamedReference
// -----------------------------------------------------------------------------
//
CAknsAlNamedReference::~CAknsAlNamedReference()
    {
    delete iName;
    iAnimationValue = NULL; // Removes lint nag
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReference::NewL
// -----------------------------------------------------------------------------
//
CAknsAlNamedReference* CAknsAlNamedReference::NewL(
    const TDesC& aName, const MAknsAlAnimationValue* aValue )
    {
    CAknsAlNamedReference* self = new(ELeave) CAknsAlNamedReference();
    CleanupStack::PushL( self );
    self->ConstructL( aName, aValue);
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReference::FillData
// -----------------------------------------------------------------------------
//
inline void CAknsAlNamedReference::FillData( TAknsRlParameterData& aData ) const
    {
    iAnimationValue->FillData( aData );
    aData.iName   = iName;
    }

// ============================ MEMBER FUNCTIONS ===============================
/**
* Utility class for storing named references and providing a parameter iterator
* access to them.
*/
NONSHARABLE_CLASS( CAknsAlNamedReferenceContainer ):
    public CBase, public MAknsRlParameterIterator
    {
    public:
        CAknsAlNamedReferenceContainer();
        ~CAknsAlNamedReferenceContainer();
        void AddNamedReferenceL( const TDesC& aName,
                                 const MAknsAlAnimationValue* aValue );
        void Begin();

    public: // Implementation of MAknsRlParameterIterator
        TBool HasNext();
        const TAknsRlParameterData* NextL();

    private:
        TAknsRlParameterData iIteratorData;
        // Stores the time bound parameters, owned
        RPointerArray<CAknsAlNamedReference> iNamedRefs;
        TInt iIteratorIndex;
    };

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::CAknsAlNamedReferenceContainer
// -----------------------------------------------------------------------------
//
CAknsAlNamedReferenceContainer::CAknsAlNamedReferenceContainer()
    {
    // Derived from CBase -> members are zeroed
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::~CAknsAlNamedReferenceContainer
// -----------------------------------------------------------------------------
//
CAknsAlNamedReferenceContainer::~CAknsAlNamedReferenceContainer()
    {
    iNamedRefs.ResetAndDestroy(); //lint !e1551 No exception thrown
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::AddNamedReferenceL
// -----------------------------------------------------------------------------
//
void CAknsAlNamedReferenceContainer::AddNamedReferenceL(
    const TDesC& aName, const MAknsAlAnimationValue* aValue )
    {
    CAknsAlNamedReference* ref = CAknsAlNamedReference::NewL( aName, aValue );
    CleanupStack::PushL( ref );
    User::LeaveIfError( iNamedRefs.Append( ref ) );
    CleanupStack::Pop( ref );
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::Begin
// -----------------------------------------------------------------------------
//
void CAknsAlNamedReferenceContainer::Begin()
    {
    iIteratorIndex = 0;
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::HasNext
// -----------------------------------------------------------------------------
//
TBool CAknsAlNamedReferenceContainer::HasNext()
    {
    if( iIteratorIndex < iNamedRefs.Count() )
        return ETrue;

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CAknsAlNamedReferenceContainer::NextL
// -----------------------------------------------------------------------------
//
const TAknsRlParameterData* CAknsAlNamedReferenceContainer::NextL()
    {
    if( iNamedRefs.Count() <= iIteratorIndex )
        User::Leave( KErrOverflow );

    CAknsAlNamedReference* ref = iNamedRefs[iIteratorIndex];
    ref->FillData( iIteratorData );

    iIteratorIndex++;

    return &iIteratorData;
    }

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

// -----------------------------------------------------------------------------
// CAknsAlAnimationValueContainer::CAknsAlAnimationValueContainer
// -----------------------------------------------------------------------------
//
CAknsAlAnimationValueContainer::CAknsAlAnimationValueContainer()
    {
    // Derived from CBase -> members are zeroed
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationValueContainer::ConstructL
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationValueContainer::ConstructL( MAknsAlAnimationValue* aValue,
                 const MAknsAlTimingModel* aModel )
    {
    if( NULL == aValue || NULL == aModel )
        User::Leave( KErrArgument );

    iAnimationValue = aValue;
    iTimingModel    = aModel;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationValueContainer::~CAknsAlAnimationValueContainer
// -----------------------------------------------------------------------------
//
CAknsAlAnimationValueContainer::~CAknsAlAnimationValueContainer()
    {
    delete iAnimationValue; //lint !e1551 No exception thrown
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationValueContainer::NewL
// -----------------------------------------------------------------------------
//
CAknsAlAnimationValueContainer* CAknsAlAnimationValueContainer::NewL(
    MAknsAlAnimationValue* aValue, const MAknsAlTimingModel* aModel )
    {
    CAknsAlAnimationValueContainer* self = new(ELeave) CAknsAlAnimationValueContainer();
    CleanupStack::PushL( self );
    self->ConstructL( aValue, aModel );
    CleanupStack::Pop( self );
    return self;
    }

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

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::CAknsAlAnimationCommand
// -----------------------------------------------------------------------------
//
CAknsAlAnimationCommand::CAknsAlAnimationCommand()
    {
    // Derived from CBase -> members are zeroed
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::ConstructL
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationCommand::ConstructL()
    {
    iParamContainer = CAknsAlEffectParamContainer::NewL();
    iReferenceContainer = new(ELeave) CAknsAlNamedReferenceContainer();
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::NewL
// -----------------------------------------------------------------------------
//
CAknsAlAnimationCommand* CAknsAlAnimationCommand::NewL()
    {
    CAknsAlAnimationCommand* self = new(ELeave) CAknsAlAnimationCommand();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::~CAknsAlAnimationCommand
// -----------------------------------------------------------------------------
//
CAknsAlAnimationCommand::~CAknsAlAnimationCommand()
    {
    delete iPlugin; //lint !e1551 No exception thrown
    delete iParamContainer; //lint !e1551 No exception thrown
    delete iReferenceContainer; //lint !e1551 No exception thrown
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::Effect
// -----------------------------------------------------------------------------
//
MAknsRlEffect* CAknsAlAnimationCommand::Effect()
    {
    return iPlugin->Effect( KAknsRlEffectPluginInterfaceEffect );
    }


// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::AddParameterL
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationCommand::AddParameterL( const TAknsRlParameterData& aParam )
    {
    iParamContainer->AddParamL( aParam );
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::AddNamedReferenceL
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationCommand::AddNamedReferenceL( const TDesC& aName,
                         const MAknsAlAnimationValue* aValue )
    {
    iReferenceContainer->AddNamedReferenceL( aName, aValue );
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::SetPlugin
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationCommand::SetPlugin( CAknsRlEffectPlugin* aPlugin )
    {
    iPlugin = aPlugin;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::SetLayerConfig
// -----------------------------------------------------------------------------
//
void CAknsAlAnimationCommand::SetLayerConfig( const TAknsRlRenderOpParam& aConfig )
    {
    iLayerConfig = aConfig;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::LayerConfig
// -----------------------------------------------------------------------------
//
const TAknsRlRenderOpParam& CAknsAlAnimationCommand::LayerConfig() const
    {
    return iLayerConfig;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::ParameterIterator
// -----------------------------------------------------------------------------
//
MAknsRlParameterIterator* CAknsAlAnimationCommand::ParameterIterator()
    {
    iParamContainer->Begin();
    return iParamContainer;
    }

// -----------------------------------------------------------------------------
// CAknsAlAnimationCommand::NamedReferenceIterator
// -----------------------------------------------------------------------------
//
MAknsRlParameterIterator* CAknsAlAnimationCommand::NamedReferenceIterator()
    {
    iReferenceContainer->Begin();
    return iReferenceContainer;
    }

// End of file.