/*

* 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:  Defines public item data classes (extension).

*

*/

// INCLUDE FILES

#include <AknsItemData.h>

#include "AknsRlCommand.h"

#include "AknsAlDataAccess.h"

#include "AknsDebug.h"

// CONSTANTS

static const TInt KDefaultAnimationMinimumInterval = 10; // Milliseconds

// INTERNAL CLASSES

NONSHARABLE_CLASS(CAknsEffectParameter) : public CBase

    {

    public: // Construction and destruction

        CAknsEffectParameter()

            {

            }

        virtual ~CAknsEffectParameter()

            {

            delete iName;

            delete iBuffer;

            }

    public: // Setters and getters

        void SetDataL( const TAknsRlParameterData& aData )

            {

            HBufC* temp = aData.iName->AllocL();

            delete iName;

            iName = temp;

            temp = NULL;

            delete iBuffer;

            iBuffer = NULL;

            iType = aData.iType;

            switch( aData.iType )

                {

                case EAknsRlParameterTypeNumber:

                    iNumber = aData.iNumber;

                    break;

                case EAknsRlParameterTypeString:

                    iBuffer = aData.iString->AllocL();

                    break;

                case EAknsRlParameterTypeGraphics:

                    iBuffer = aData.iGfx->iFilename->AllocL();

                    iGfx.iFilename = iBuffer;

                    iGfx.iIndex = aData.iGfx->iIndex;

                    iGfx.iMaskIndex = aData.iGfx->iMaskIndex;

                    break;

                }

            }

        void GetData( TAknsRlParameterData& aData )

            {

            aData.iName = iName;

            aData.iType = iType;

            switch( iType )

                {

                case EAknsRlParameterTypeNumber:

                    aData.iNumber = iNumber;

                    break;

                case EAknsRlParameterTypeString:

                    aData.iString = iBuffer;

                    break;

                case EAknsRlParameterTypeGraphics:

                    aData.iGfx = &iGfx;

                    break;

                }

            }

    private: // Data

        HBufC* iName;

        TAknsRlParameterType iType;

        HBufC* iBuffer;

        TInt iNumber;

        TAknsRlGraphicsParam iGfx;

    };

NONSHARABLE_CLASS(CAknsParameterIterator) : public CBase,

    public MAknsRlParameterIterator

    {

    public: // Construction and destruction

        CAknsParameterIterator( RPointerArray<CAknsEffectParameter>* aArray )

            : iNextIndex(0), iArray( aArray )

            {

            }

        virtual ~CAknsParameterIterator()

            {

            }

    public: // Methods

        TBool HasNext()

            {

            if( !iArray ) return EFalse;

            if( iNextIndex>=iArray->Count() ) return EFalse;

            return ETrue;

            }

        const TAknsRlParameterData* NextL()

            {

            if( !HasNext() ) User::Leave( KErrArgument );

            (*iArray)[iNextIndex++]->GetData( iCurData );

            return &iCurData;

            }

    private: // Data

        TAknsRlParameterData iCurData;

        TInt iNextIndex;

        RPointerArray<CAknsEffectParameter>* iArray;

    };

NONSHARABLE_CLASS(CAknsCommandIterator) : public CBase,

    public MAknsRlCommandIterator

    {

    public: // Construction and destruction

        CAknsCommandIterator( const RPointerArray<CAknsEffectCommand>* aArray )

            : iNextIndex(0), iArray( aArray )

            {

            iCurData.iParamIterator = NULL;

            }

        virtual ~CAknsCommandIterator()

            {

            delete iCurData.iParamIterator;

            }

    public: // Methods

        TBool HasNext()

            {

            if( !iArray ) return EFalse;

            if( iNextIndex>=iArray->Count() ) return EFalse;

            return ETrue;

            }

        const TAknsRlCommandData* NextL()

            {

            if( !HasNext() ) User::Leave( KErrArgument );

            delete iCurData.iParamIterator;

            iCurData.iParamIterator = NULL;

            iCurData.iEffectUid = (*iArray)[iNextIndex]->EffectUid();

            iCurData.iLayerConf = (*iArray)[iNextIndex]->LayerConf();

            iCurData.iParamIterator =

                (*iArray)[iNextIndex++]->CreateParameterIteratorL();

            return &iCurData;

            }

    private: // Data

        TAknsRlCommandData iCurData;

        TInt iNextIndex;

        const RPointerArray<CAknsEffectCommand>* iArray;

    };

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

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

// C++ constructor can NOT contain any code, that might leave.

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

//

CAknsEffectCommand::CAknsEffectCommand()

    // CBase initializes: iUid(0)

    {

    }

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

// Two-phased constructor.

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

//

EXPORT_C CAknsEffectCommand* CAknsEffectCommand::NewL()

    {

    return new (ELeave) CAknsEffectCommand();

    }

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

// Destructor.

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

//

CAknsEffectCommand::~CAknsEffectCommand()

    {

    iParameters.ResetAndDestroy();

    }

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

// CAknsEffectCommand::SetEffectUid

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

//

EXPORT_C void CAknsEffectCommand::SetEffectUid( const TUid aValue )

    {

    iUid = aValue;

    }

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

// CAknsEffectCommand::EffectUid

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

//

EXPORT_C TUid CAknsEffectCommand::EffectUid() const

    {

    return iUid;

    }

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

// CAknsEffectCommand::SetLayerConf

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

//

EXPORT_C void CAknsEffectCommand::SetLayerConf(

    const TAknsRlRenderOpParam aValue )

    {

    iLayerConf = aValue;

    }

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

// CAknsEffectCommand::LayerConf

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

//

EXPORT_C TAknsRlRenderOpParam CAknsEffectCommand::LayerConf() const

    {

    return iLayerConf;

    }

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

// CAknsEffectCommand::AppendParameterL

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

//

EXPORT_C void CAknsEffectCommand::AppendParameterL(

    const TAknsRlParameterData& aParameter )

    {

    CAknsEffectParameter* newParam = new (ELeave) CAknsEffectParameter();

    CleanupStack::PushL( newParam );

    newParam->SetDataL( aParameter );

    User::LeaveIfError( iParameters.Append( newParam ) );

    CleanupStack::Pop( newParam );

    }

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

// CAknsEffectCommand::CreateParameterIteratorL

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

//

EXPORT_C MAknsRlParameterIterator* CAknsEffectCommand::CreateParameterIteratorL()

    {

    return new (ELeave) CAknsParameterIterator( &iParameters );

    }

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

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

// C++ constructor can NOT contain any code, that might leave.

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

//

CAknsEffectQueueItemData::CAknsEffectQueueItemData( const TAknsItemType aType )

    : CAknsItemData( aType ), iInputLayer(-1), iOutputLayer(-1)

    {

    }

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

// Two-phased constructor.

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

//

EXPORT_C CAknsEffectQueueItemData* CAknsEffectQueueItemData::NewL()

    {

    return new (ELeave) CAknsEffectQueueItemData( EAknsITEffectQueue );

    }

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

// Destructor.

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

//

CAknsEffectQueueItemData::~CAknsEffectQueueItemData()

    {

    iCommands.ResetAndDestroy();

    }

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

// CAknsEffectQueueItemData::SetRefItem

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

//

EXPORT_C void CAknsEffectQueueItemData::SetRefItem( const TAknsItemID aValue )

    {

    iRefId = aValue;

    }

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

// CAknsEffectQueueItemData::RefItem

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

//

EXPORT_C TAknsItemID CAknsEffectQueueItemData::RefItem() const

    {

    return iRefId;

    }

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

// CAknsEffectQueueItemData::SetInputLayer

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

//

EXPORT_C void CAknsEffectQueueItemData::SetInputLayer( const TInt aValue )

    {

    iInputLayer = aValue;

    }

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

// CAknsEffectQueueItemData::InputLayer

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

//

EXPORT_C TInt CAknsEffectQueueItemData::InputLayer() const

    {

    return iInputLayer;

    }

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

// CAknsEffectQueueItemData::SetInputLayerMode

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

//

EXPORT_C void CAknsEffectQueueItemData::SetInputLayerMode( const TInt aValue )

    {

    iInputLayerMode = aValue;

    }

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

// CAknsEffectQueueItemData::InputLayerMode

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

//

EXPORT_C TInt CAknsEffectQueueItemData::InputLayerMode() const

    {

    return iInputLayerMode;

    }

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

// CAknsEffectQueueItemData::SetOutputLayer

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

//

EXPORT_C void CAknsEffectQueueItemData::SetOutputLayer( const TInt aValue )

    {

    iOutputLayer = aValue;

    }

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

// CAknsEffectQueueItemData::OutputLayer

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

//

EXPORT_C TInt CAknsEffectQueueItemData::OutputLayer() const

    {

    return iOutputLayer;

    }

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

// CAknsEffectQueueItemData::SetOutputLayerMode

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

//

EXPORT_C void CAknsEffectQueueItemData::SetOutputLayerMode( const TInt aValue )

    {

    iOutputLayerMode = aValue;

    }

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

// CAknsEffectQueueItemData::OutputLayerMode

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

//

EXPORT_C TInt CAknsEffectQueueItemData::OutputLayerMode() const

    {

    return iOutputLayerMode;

    }

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

// CAknsEffectQueueItemData::AppendCommandL

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

//

EXPORT_C void CAknsEffectQueueItemData::AppendCommandL(

    const CAknsEffectCommand* aCommand )

    {

    User::LeaveIfError( iCommands.Append( aCommand ) );

    }

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

// CAknsEffectQueueItemData::CreateCommandIteratorL

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

//

EXPORT_C MAknsRlCommandIterator* CAknsEffectQueueItemData::CreateCommandIteratorL()

    {

    return new (ELeave) CAknsCommandIterator( &iCommands );

    }

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

template < class TOut, class TIn >

class CAknsAlIterator: public CBase, public MAknsAlIterator

    {

    public: // Construction and destruction

        CAknsAlIterator( const RPointerArray<TIn>* aArray )

            : iNextIndex(0), iArray( aArray )

            {

            TIn::InitializeOut( iCurData );

            }

        virtual ~CAknsAlIterator()

            {

            TIn::ReleaseOut( iCurData );

            }

    public: // Methods

        TBool HasNext()

            {

            if( !iArray ) return EFalse;

            if( iNextIndex>=iArray->Count() ) return EFalse;

            return ETrue;

            }

        const TAny* NextL()

            {

            if( !HasNext() ) User::Leave( KErrArgument );

            (*iArray)[iNextIndex++]->AssignOutL( iCurData );

            return &iCurData;

            }

    private: // Data

        TOut iCurData;

        TInt iNextIndex;

        const RPointerArray<TIn>* iArray;

    };

// Some convenient type definitions

typedef CAknsAlIterator< TAknsAlAnimationCommandData, CAknsAnimationCommand > CAknsCommandIter;

typedef CAknsAlIterator< TAknsAlTimingModelData, CAknsTimingModel > CAknsTimingModelIter;

typedef CAknsAlIterator< TAknsAlAnimationValueData, CAknsAnimationValue > CAknsValueIter;

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

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

// Symbian two-phase constructor.

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

//

CAknsTimingModel* CAknsTimingModel::NewL()

    {

    return new (ELeave) CAknsTimingModel();

    }

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

// Destructor.

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

//

CAknsTimingModel::~CAknsTimingModel()

    {

    iParameters.ResetAndDestroy(); // Deletes the referenced parameters

    }

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

// C++ default constructor.

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

//

CAknsTimingModel::CAknsTimingModel()

    {

    }

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

// CAknsEffectQueueItemData::SetTimingModelUid

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

//

void CAknsTimingModel::SetTimingModelUid( const TUid aValue )

    {

    iTimingModelUid = aValue;

    }

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

// CAknsEffectQueueItemData::TimingModelUid

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

//

TUid CAknsTimingModel::TimingModelUid() const

    {

    return iTimingModelUid;

    }

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

// CAknsEffectQueueItemData::AppendParameterL

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

//

void CAknsTimingModel::AppendParameterL( const TAknsRlParameterData& aParameter )

    {

    CAknsEffectParameter* newParam = new (ELeave) CAknsEffectParameter();

    CleanupStack::PushL( newParam );

    newParam->SetDataL( aParameter );

    User::LeaveIfError( iParameters.Append( newParam ) );

    CleanupStack::Pop( newParam );

    }

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

// CAknsEffectQueueItemData::CreateParameterIteratorL

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

//

MAknsRlParameterIterator* CAknsTimingModel::CreateParameterIteratorL()

    {

    return new (ELeave) CAknsParameterIterator( &iParameters );

    }

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

// CAknsEffectQueueItemData::AssignOutL

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

//

void CAknsTimingModel::AssignOutL( TAknsAlTimingModelData& aData )

    {

    delete aData.iParamIterator;

    aData.iParamIterator = NULL;

    aData.iTimingModelUid = iTimingModelUid;

    aData.iParamIterator  = CreateParameterIteratorL();

    }

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