1 /*

     2 * Copyright (c) 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:   

    15 *

    16 */

    17 

    18 

    19 

    20 #include "HuiFxParameterManager.h"

    21 #include "HuiFxEngine.h"

    22 #include "HuiFxScalarParameter.h"

    23 #include "HuiFxColorParameter.h"

    24 #include <e32base.h>

    25 

    26 CHuiFxParameterManager* CHuiFxParameterManager::NewL()

    27     {

    28     CHuiFxParameterManager* self = new (ELeave) CHuiFxParameterManager();

    29     CleanupStack::PushL(self);

    30     self->ConstructL();

    31     CleanupStack::Pop(self);

    32     return self;

    33     }

    34 

    35 CHuiFxParameterManager::CHuiFxParameterManager()

    36     {

    37 #ifdef HUIFX_TRACE    

    38     RDebug::Print(_L("CHuiFxParameterManager::CHuiFxParameterManager - 0x%x "), this);

    39 #endif

    40     }

    41 

    42 void CHuiFxParameterManager::ConstructL()

    43     {

    44     }

    45 

    46 CHuiFxParameterManager* CHuiFxParameterManager::CloneL() const

    47 {

    48   CHuiFxParameterManager *params = CHuiFxParameterManager::NewL();

    49   return params;

    50 }

    51 

    52 void CHuiFxParameterManager::CopyParameterL(const TDesC &aName, TReal32 *aValue, const CHuiFxParameterManager *aOldValues)

    53     {

    54     MHuiFxParameter *param = const_cast<CHuiFxParameterManager*>(aOldValues)->Parameter(aName);

    55     MHuiFxParameter *param2 = param->CloneL();

    56     param2->ReRef(aValue);

    57     iParameters.InsertL(aName.AllocL(), param2);

    58     }

    59 void CHuiFxParameterManager::CopyParameterL(const TDesC &aName, TRgb *aValue, const CHuiFxParameterManager *aOldValues)

    60     {

    61     MHuiFxParameter *param = const_cast<CHuiFxParameterManager*>(aOldValues)->Parameter(aName);

    62     MHuiFxParameter *param2 = param->CloneL();

    63     param2->ReRef(aValue);

    64     iParameters.InsertL(aName.AllocL(), param2);

    65     }

    66 

    67 

    68 CHuiFxParameterManager::~CHuiFxParameterManager()

    69     {

    70     // Free registered parameters

    71     /*TPtrHashMapIter<TDesC, MHuiFxParameter> i(iParameters);

    72     for (i.NextValue(); i.CurrentValue(); i.NextValue())

    73         {

    74         delete i.CurrentKey();

    75         delete i.CurrentValue();

    76         }

    77     iParameters.Close();*/

    78     iParameters.ResetAndDestroy();

    79     iParameters.Close();

    80 #ifdef HUIFX_TRACE    

    81     RDebug::Print(_L("CHuiFxParameterManager::~CHuiFxParameterManager - 0x%x "), this);

    82 #endif

    83     }

    84 

    85 void CHuiFxParameterManager::RegisterParameterL(const TDesC& aName, TReal32* aValue)

    86     {

    87 #ifdef HUIFX_TRACE    

    88     RDebug::Print(_L("CHuiFxParameterManager::RegisterParameterL - 0x%x %S scal: 0x%x"), this, &aName, *aValue);

    89 #endif

    90     MHuiFxParameter* param = new (ELeave) CHuiFxScalarParameter(aValue);

    91     CleanupStack::PushL(param);

    92     iParameters.InsertL(aName.AllocL(), param);

    93     CleanupStack::Pop(param);

    94     }

    95 

    96 void CHuiFxParameterManager::RegisterParameterL(const TDesC& aName, TRgb* aValue)

    97     {

    98 #ifdef HUIFX_TRACE    

    99     RDebug::Print(_L("CHuiFxParameterManager::RegisterParameterL - 0x%x %S rgb: 0x%x"), this, &aName, *aValue);

   100 #endif //#ifdef HUIFX_TRACE    

   101     MHuiFxParameter* param = new (ELeave) CHuiFxColorParameter(aValue);

   102     CleanupStack::PushL(param);

   103     iParameters.InsertL(aName.AllocL(), param);

   104     CleanupStack::Pop(param);

   105     }

   106 

   107 TBool CHuiFxParameterManager::HasAnimatedParameters() const

   108     {

   109     TPtrHashMapIter<TDesC, MHuiFxParameter> i(iParameters);

   110     for (i.NextValue(); i.CurrentValue(); i.NextValue())

   111         {

   112         if (i.CurrentValue()->IsAnimated())

   113             {

   114             return ETrue;

   115             }

   116         }

   117     return EFalse;

   118     }

   119 

   120 void CHuiFxParameterManager::AdvanceTime(TReal32 aElapsedTime)

   121     {

   122     TPtrHashMapIter<TDesC, MHuiFxParameter> i(iParameters);

   123     for (i.NextValue(); i.CurrentValue(); i.NextValue())

   124         {

   125         MHuiFxParameter* p = (MHuiFxParameter*)i.CurrentValue();

   126         p->AdvanceTime(aElapsedTime);

   127         }

   128     }

   129 

   130 TBool CHuiFxParameterManager::Update(CHuiFxEngine& aEngine, const TRect& aVisualRect)

   131     {

   132     // Calculate all current parameter values

   133     TPtrHashMapIter<TDesC, MHuiFxParameter> i(iParameters);

   134     

   135     TBool parameterChanged = EFalse;

   136     for (i.NextValue(); i.CurrentValue(); i.NextValue())

   137         {

   138         MHuiFxParameter* p = (MHuiFxParameter*)i.CurrentValue();

   139         if ( p->IsAnimated() )

   140             {

   141             parameterChanged = ETrue;

   142             }

   143         

   144         TReal32 newValue = p->ReferenceValue();

   145         ResolveReference( newValue, p->ReferencePoint(), aEngine, aVisualRect );

   146         if ( newValue != p->ReferenceValue() )

   147             {

   148             p->SetReferenceValue( newValue );

   149             parameterChanged = ETrue;

   150             }

   151             

   152         if ( p->StartReference() != EReferencePointUndefined )

   153             {

   154             newValue = p->StartValue();

   155             ResolveReference( newValue, p->StartReference(), aEngine, aVisualRect );

   156             if ( newValue != p->StartValue() )

   157                 {

   158                 p->SetStartValue( newValue );

   159                 parameterChanged = ETrue;

   160                 }

   161             }

   162             

   163         if ( p->EndReference() != EReferencePointUndefined )

   164             {

   165             newValue = p->EndValue();

   166             ResolveReference( newValue, p->EndReference(), aEngine, aVisualRect );

   167             if ( newValue != p->EndValue() )

   168                 {

   169                 p->SetEndValue( newValue );

   170                 parameterChanged = ETrue;

   171                 }

   172             }

   173             

   174         p->Update();

   175         }

   176     return parameterChanged;

   177     }

   178     

   179 MHuiFxParameter* CHuiFxParameterManager::Parameter(const TDesC& aName)

   180     {

   181     return iParameters.Find(aName);

   182     }

   183     

   184 void CHuiFxParameterManager::ResolveReference( TReal32& aDefaultValue, THuiFxReferencePoint aRef, CHuiFxEngine& aEngine, const TRect& aVisualRect )

   185     {

   186     switch ( aRef )

   187         {

   188         case EReferencePointIdentity:

   189         case EReferencePointUndefined:

   190         // If the reference point is an external value, it will not change

   191         // after it has been set

   192         case EReferencePointExtRectWidth:

   193         case EReferencePointExtRectHeight:

   194         case EReferencePointExtRectTop:

   195         case EReferencePointExtRectBottom:

   196         case EReferencePointExtRectLeft:

   197         case EReferencePointExtRectRight:

   198             break;

   199         case EReferencePointVisualWidth:

   200             aDefaultValue = aVisualRect.Size().iWidth;

   201             break;

   202         case EReferencePointVisualHeight:

   203             aDefaultValue = aVisualRect.Size().iHeight;

   204             break;

   205         case EReferencePointVisualTop:

   206             aDefaultValue = aVisualRect.iTl.iY;

   207             break;

   208         case EReferencePointVisualBottom:

   209             // the bottom right corner of a rect is actually outside the rect

   210             aDefaultValue = aVisualRect.iBr.iY;

   211             break;

   212         case EReferencePointVisualLeft:

   213             aDefaultValue = aVisualRect.iTl.iX;

   214             break;

   215         case EReferencePointVisualRight:

   216             // the bottom right corner of a rect is actually outside the rect

   217             aDefaultValue = aVisualRect.iBr.iX;

   218             break;

   219         default:

   220             // This will return reference points that depend on display size

   221             aDefaultValue = aEngine.GetReferenceValue( aRef );

   222             break;

   223         }

   224     }

   225