1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  A toolkit class for creating RL effect queues from AnimationLibrary

    15 *                animations.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include "AknsRlCommand.h"

    22 

    23 #include "AknsAlConversionUtil.h"

    24 

    25 #include "AknsAlShared.h"

    26 #include "AknsAlTimingModel.h"

    27 #include "AknsAlAnimationFactory.h"

    28 #include "AknsAlDataAccess.h"

    29 

    30 #include <AknsItemData.h>

    31 #include <AknsConstants.h>

    32 

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

    34 NONSHARABLE_CLASS( CAknsAlAnimConverter ): public CBase

    35     {

    36     protected: // Protected construction

    37         CAknsAlAnimConverter();

    38 

    39     public:

    40         ~CAknsAlAnimConverter();

    41         static CAknsAlAnimConverter* NewL();

    42 

    43         CAknsEffectQueueItemData* CreateEffectQueueL( const CAknsAnimationItemData& aAnim,

    44                                                       const TTime& aTimeStamp );

    45     private:

    46 

    47         MAknsAlTimingModel* FindTimingModelById( TInt aId ) const;

    48         CAknsAlAnimationValueContainer* FindContainerById( TInt aId ) const;

    49 

    50         void CreateTimingModelsL( const CAknsAnimationItemData& aAnim );

    51         void CreateAnimationValueContainersL( const CAknsAnimationItemData& aAnim );

    52 

    53         void Tick( const TTime& aTimeStamp );

    54 

    55     private:

    56         RPointerArray<MAknsAlTimingModel> iTimingModels;

    57         RPointerArray<CAknsAlAnimationValueContainer> iValueContainers;

    58     };

    59 

    60 // -----------------------------------------------------------------------------

    61 // CAknsAlAnimConverter::CAknsAlAnimConverter

    62 // -----------------------------------------------------------------------------

    63 //

    64 CAknsAlAnimConverter::CAknsAlAnimConverter()

    65     {

    66     // Derived from CBase -> members zeroed

    67     }

    68 

    69 // -----------------------------------------------------------------------------

    70 // CAknsAlAnimConverter::~CAknsAlAnimConverter

    71 // -----------------------------------------------------------------------------

    72 //

    73 CAknsAlAnimConverter::~CAknsAlAnimConverter()

    74     {

    75     iTimingModels.ResetAndDestroy(); //lint !e1551 No exception thrown

    76     iValueContainers.ResetAndDestroy(); //lint !e1551 No exception thrown

    77     }

    78 

    79 // -----------------------------------------------------------------------------

    80 // CAknsAlAnimConverter::NewL

    81 // -----------------------------------------------------------------------------

    82 //

    83 CAknsAlAnimConverter* CAknsAlAnimConverter::NewL()

    84     {

    85     return new(ELeave) CAknsAlAnimConverter();

    86     }

    87 

    88 // -----------------------------------------------------------------------------

    89 // CAknsAlAnimConverter::FindTimingModelById

    90 // -----------------------------------------------------------------------------

    91 //

    92 MAknsAlTimingModel* CAknsAlAnimConverter::FindTimingModelById( TInt aId ) const

    93     {

    94     if( 0 <= aId && aId < iTimingModels.Count() )

    95         return iTimingModels[ aId ];

    96 

    97     return NULL;

    98     }

    99 

   100 // -----------------------------------------------------------------------------

   101 // CAknsAlAnimConverter::FindContainerById

   102 // -----------------------------------------------------------------------------

   103 //

   104 CAknsAlAnimationValueContainer* CAknsAlAnimConverter::FindContainerById( TInt aId ) const

   105     {

   106     if( 0 <= aId && aId < iValueContainers.Count() )

   107         return iValueContainers[ aId ];

   108 

   109     return NULL;

   110     }

   111 

   112 // -----------------------------------------------------------------------------

   113 // CAknsAlAnimConverter::CreateTimingModelsL

   114 // -----------------------------------------------------------------------------

   115 //

   116 void CAknsAlAnimConverter::CreateTimingModelsL(

   117     const CAknsAnimationItemData& aAnim )

   118     {

   119     MAknsAlIterator* timingModels = aAnim.TimingModelIteratorL();

   120     CleanupStack::PushL( TCleanupItem( MAknsAlIterator::CleanupOp, timingModels ) );

   121 

   122     while( timingModels->HasNext() )

   123         {

   124         const TAknsAlTimingModelData* item =

   125             static_cast<const TAknsAlTimingModelData*>( timingModels->NextL() );

   126         MAknsAlTimingModel* model =

   127             AknsAlAnimationFactory::CreateTimingModelL( item->iTimingModelUid );

   128         CleanupStack::PushL( TCleanupItem( MAknsAlTimingModel::CleanupOp, model ) );

   129 

   130         if( item->iParamIterator )

   131             model->SetParametersL( *item->iParamIterator );

   132 

   133         User::LeaveIfError( iTimingModels.Append( model ) );

   134 

   135         CleanupStack::Pop(); // model

   136         }

   137 

   138     CleanupStack::PopAndDestroy(); // timingModels

   139     }

   140 

   141 // -----------------------------------------------------------------------------

   142 // CAknsAlAnimConverter::CreateAnimationValueContainersL

   143 // -----------------------------------------------------------------------------

   144 //

   145 void CAknsAlAnimConverter::CreateAnimationValueContainersL(

   146     const CAknsAnimationItemData& aAnim )

   147     {

   148     MAknsAlIterator* iter = aAnim.AnimationValueIteratorL();

   149     CleanupStack::PushL( TCleanupItem( MAknsAlIterator::CleanupOp, iter ) );

   150 

   151     while( iter->HasNext() )

   152         {

   153         const TAknsAlAnimationValueData* data =

   154             static_cast<const TAknsAlAnimationValueData*>( iter->NextL() );

   155 

   156         // Create animation value

   157         MAknsAlAnimationValue* value =

   158             AknsAlAnimationFactory::CreateAnimationValueL( data->iAnimationValueUid );

   159 

   160         CleanupStack::PushL( TCleanupItem( MAknsAlAnimationValue::CleanupOp, value ) );

   161 

   162         if( data->iParamIterator )

   163             value->SetParametersL( *data->iParamIterator );

   164 

   165         // Fetch timing model

   166         MAknsAlTimingModel* timing = FindTimingModelById( data->iTimingModelId );

   167         if( !timing )

   168             User::Leave( KErrNotFound );

   169 

   170         // Create the container

   171         CAknsAlAnimationValueContainer* container =

   172             CAknsAlAnimationValueContainer::NewL( value, timing );

   173 

   174         CleanupStack::Pop(); // value, now owned by container

   175 

   176         CleanupStack::PushL( container );

   177         User::LeaveIfError( iValueContainers.Append( container ) );

   178         CleanupStack::Pop( container );

   179         }

   180 

   181     CleanupStack::PopAndDestroy(); // iter

   182     }

   183 

   184 // -----------------------------------------------------------------------------

   185 // CAknsAlAnimConverter::Tick

   186 // -----------------------------------------------------------------------------

   187 //

   188 void CAknsAlAnimConverter::Tick( const TTime& aTimeStamp )

   189     {

   190     TInt i, count;

   191 

   192     // Update timing models

   193     count = iTimingModels.Count();

   194     for( i=0; i < count; i++ )

   195         {

   196         iTimingModels[i]->Begin();

   197         iTimingModels[i]->Tick( aTimeStamp );

   198         }

   199 

   200     // Update animation values

   201     count = iValueContainers.Count();

   202     for( i=0; i < count; i++ )

   203         {

   204         iValueContainers[i]->Begin();

   205         // Zero delta time is being used because timing models are (or at least

   206         // should be) relative -> no real-time timing models from where to

   207         // fetch delta time.

   208         iValueContainers[i]->Tick( 0 );

   209         }

   210     }

   211 

   212 // -----------------------------------------------------------------------------

   213 // CAknsAlAnimConverter::CreateEffectQueueL

   214 // -----------------------------------------------------------------------------

   215 //

   216 CAknsEffectQueueItemData* CAknsAlAnimConverter::CreateEffectQueueL(

   217     const CAknsAnimationItemData& aAnim,

   218     const TTime& aTimeStamp )

   219     {

   220     // Create timing models and animation values

   221     CreateTimingModelsL( aAnim );

   222     CreateAnimationValueContainersL( aAnim );

   223 

   224     // Tick the animation to time stamp

   225     Tick( aTimeStamp );

   226 

   227     // Start the actual conversion

   228     CAknsEffectQueueItemData* queue = CAknsEffectQueueItemData::NewL();

   229     CleanupStack::PushL( queue );

   230 

   231     // Set up layers

   232     queue->SetInputLayer( aAnim.InputLayer() );

   233     queue->SetInputLayerMode( aAnim.InputLayerMode() );

   234     queue->SetOutputLayer( aAnim.OutputLayer() );

   235     queue->SetOutputLayerMode( aAnim.OutputLayerMode() );

   236 

   237     // This is a concrete effect queue

   238     queue->SetRefItem( KAknsIIDDefault );

   239 

   240     //---------------------------------

   241     // Add preprocessing commands

   242     MAknsRlCommandIterator* cmdIter = aAnim.PreprocessCommandIteratorL();

   243     CleanupStack::PushL( TCleanupItem( MAknsRlCommandIterator::CleanupOperation, cmdIter ) );

   244 

   245     while( cmdIter->HasNext() )

   246         {

   247         const TAknsRlCommandData* data = cmdIter->NextL();

   248         CAknsEffectCommand* cmd = CAknsEffectCommand::NewL();

   249         CleanupStack::PushL( cmd );

   250 

   251         cmd->SetEffectUid( data->iEffectUid );

   252         cmd->SetLayerConf( data->iLayerConf );

   253 

   254         // Add initial parameters

   255         if( data->iParamIterator )

   256             {

   257             MAknsRlParameterIterator* paramIter = data->iParamIterator;

   258             while( paramIter->HasNext() )

   259                 {

   260                 const TAknsRlParameterData* param = paramIter->NextL();

   261                 cmd->AppendParameterL( *param );

   262                 }

   263             }

   264 

   265         // Preprocess commands don't have named references

   266 

   267         queue->AppendCommandL( cmd );

   268         CleanupStack::Pop( cmd );

   269         }

   270 

   271     CleanupStack::PopAndDestroy(); // cmdIter

   272 

   273     //---------------------------------

   274     // Create effect commands

   275     MAknsAlIterator* animCmdIter = aAnim.CommandIteratorL();

   276     CleanupStack::PushL( TCleanupItem( MAknsAlIterator::CleanupOp, animCmdIter ) );

   277 

   278     while( animCmdIter->HasNext() )

   279         {

   280         const TAknsAlAnimationCommandData* data =

   281             static_cast<const TAknsAlAnimationCommandData*>( animCmdIter->NextL() );

   282 

   283         CAknsEffectCommand* cmd = CAknsEffectCommand::NewL();

   284         CleanupStack::PushL( cmd );

   285 

   286         cmd->SetEffectUid( data->iEffectUid );

   287         cmd->SetLayerConf( data->iLayerConf );

   288 

   289         // Add initial parameters

   290         if( data->iParamIterator )

   291             {

   292             MAknsRlParameterIterator* paramIter = data->iParamIterator;

   293             while( paramIter->HasNext() )

   294                 {

   295                 const TAknsRlParameterData* param = paramIter->NextL();

   296                 cmd->AppendParameterL( *param );

   297                 }

   298             }

   299 

   300         // Add named reference values (parameters bound to animation values)

   301         if( data->iNamedReferenceIterator )

   302             {

   303             TAknsRlParameterData paramData;

   304             MAknsAlIterator* refIter = data->iNamedReferenceIterator;

   305             while( refIter->HasNext() )

   306                 {

   307                 const TAknsAlNamedReferenceData* ref =

   308                     static_cast<const TAknsAlNamedReferenceData*>( refIter->NextL() );

   309 

   310                 CAknsAlAnimationValueContainer* container = FindContainerById( ref->iAnimationValueId );

   311                 if( !container )

   312                     User::Leave( KErrNotFound );

   313 

   314                 container->AnimationValue()->FillData( paramData );

   315                 paramData.iName = ref->iName;

   316 

   317                 cmd->AppendParameterL( paramData );

   318                 }

   319             }

   320 

   321         queue->AppendCommandL( cmd );

   322         CleanupStack::Pop( cmd );

   323         }

   324 

   325     CleanupStack::PopAndDestroy(); // animCmdIter

   326 

   327     CleanupStack::Pop( queue );

   328     return queue;

   329     }

   330 

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

   332 

   333 // -----------------------------------------------------------------------------

   334 // AknsAlConversionUtil::AnimationToEffectQueueL

   335 // -----------------------------------------------------------------------------

   336 //

   337 CAknsEffectQueueItemData* AknsAlConversionUtil::AnimationToEffectQueueL(

   338     const CAknsAnimationItemData& aAnim,

   339     const TTime& aTimeStamp )

   340     {

   341     CAknsAlAnimConverter* converter = CAknsAlAnimConverter::NewL();

   342     CleanupStack::PushL( converter );

   343 

   344     CAknsEffectQueueItemData* queue =

   345         converter->CreateEffectQueueL( aAnim, aTimeStamp );

   346 

   347     CleanupStack::PopAndDestroy( converter );

   348 

   349     return queue;

   350     }

   351 

   352 // End of file