/*
* Copyright (c) 2006-2007 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:   Implementation of THuiTimedValue. THuiTimedValue is value 
*                that can change based on time.
*
*/



#include "uiacceltk/HuiTimedValue.h"  // Class definition
#include "uiacceltk/HuiStatic.h"
#include "uiacceltk/HuiUtil.h"
#include "uiacceltk/huifixmath.h"

#include <e32math.h>

EXPORT_C TBool MHuiMappingFunction::MappingFunctionChanged() const
    {
    return EFalse;
    }


EXPORT_C void MHuiMappingFunction::MappingFunctionClearChanged()
    {
    }


EXPORT_C THuiTimedValue::THuiTimedValue(THuiInterpolationStyle aStyle)
        :
          iStyle(aStyle),
          iInternalState(0),
          iInterpolationStartValue(0),
          iTargetValue(0),
          iMapFunction(0),
          iTimeRemainingWhenSuspended(0)
    {
    // Use current time.
    iInterpolationStartTime = CHuiStatic::MilliSecondsSinceStart();
    iInterpolationEndTime = iInterpolationStartTime;

    SetStyle(aStyle);
    }


EXPORT_C THuiTimedValue::THuiTimedValue(TReal32 aInitialValue, THuiInterpolationStyle aStyle) __SOFTFP
        : iStyle(aStyle),
          iInternalState(0),
          iInterpolationStartValue(aInitialValue),
          iTargetValue(aInitialValue),
          iMapFunction(0),
          iTimeRemainingWhenSuspended(0)
    {
    // Use current time.
    iInterpolationStartTime = CHuiStatic::MilliSecondsSinceStart();
    iInterpolationEndTime = iInterpolationStartTime;

    SetStyle(aStyle);
    }


EXPORT_C THuiInterpolationStyle THuiTimedValue::Style() const
    {
    return iStyle;
    }


EXPORT_C void THuiTimedValue::SetStyle(THuiInterpolationStyle aStyle)
    {
    iStyle = aStyle;

    if(iStyle == EHuiTimedValueStyleAdaptive)
        {
        iInternalState |= EFlagAdaptive;
        }
    else
        {
        iInternalState &= ~EFlagAdaptive;
        }
    }


EXPORT_C void THuiTimedValue::SetFunction(MHuiMappingFunction* aFunction)
    {
    TReal32 oldMapped = 0;

    if(!aFunction)
        {
        // We are switching to identity mapping, store the current mapped
        // value.
        oldMapped = Now();
        }

    iMapFunction = aFunction;

    if(!aFunction)
        {
        // No jumping around. Use the previous mapped value.
        Set(oldMapped);
        }
    }


TReal32 THuiTimedValue::SecondsFrom(TUint32 aStart, TUint32 aEnd) const
    {
    TUint32 diff;

    diff = aEnd - aStart;
    
    if (diff > 0x7FFFFFFF)
        {
        // Timer has wrapped, we need to account for overflow.
        diff = (0xFFFFFFFF - aStart) + aEnd;
        }

    return diff / 1000.0;
    }


TReal32 THuiTimedValue::MapValue(TReal32 aValue) const
    {
    if(!iMapFunction)
        {
        // No change.
        return aValue;
        }
    else
        {
        return iMapFunction->MapValue(aValue,
            (iInternalState & EFlagMappingModeMask ? 1 : 0));
        }
    }


EXPORT_C TReal32 THuiTimedValue::Now() const __SOFTFP
    {
    return MapValue(UnmappedNow());
    }

    // This macro is used for modifying the return value appropriately
    // for the clock flag.
#define HUI_EVALUATED_VALUE(aValue)  \
    ((aValue) + (iInternalState & EFlagAddSecondsSinceStart? CHuiStatic::SecondsSinceStart() : 0))

EXPORT_C TReal32 THuiTimedValue::UnmappedNow() const __SOFTFP
    {
    if(iInternalState & EFlagFrozen)
        {
        // Frozen values are not updated in any way.
        return iInterpolationStartValue;
        }

    /** @todo  Wrapping of iInterpolationEndTime and iInterpolationStartTime is 
               not handled at the moment. If wrapping occurs during interpolation, 
               the interpolation is cut short and the value skips to the target. */

    if((iInternalState & EFlagInterpolating) && iInterpolationEndTime > iInterpolationStartTime)
        {
        iInternalState |= EFlagChanged;

        TInt duration = HuiFixMath::FloatToFix(SecondsFrom(iInterpolationStartTime, iInterpolationEndTime));
        TInt elapsed = HuiFixMath::FloatToFix(SecondsFrom(iInterpolationStartTime, CHuiStatic::MilliSecondsSinceStart()));

        if(elapsed > duration)
            {
            // We have reached the destination.
            iInterpolationStartValue = iTargetValue;
            iInterpolationStartTime = iInterpolationEndTime;
            iInternalState &= ~EFlagInterpolating;
            return HUI_EVALUATED_VALUE(iInterpolationStartValue);
            }

        TReal32 t = 0.0f;
        const TInt fixt = HuiFixMath::FixDiv(elapsed,duration);

        switch(iStyle)
            {
            case EHuiTimedValueStyleLinear:
                // Linear interpolation.
                t = HuiFixMath::FixToFloat(fixt);
                break;

            case EHuiTimedValueStyleSineWave:
                {
                TInt angle = HuiFixMath::FixMul(fixt,KFixPi);
                TInt anglePos = HuiFixMath::FixCos(angle);
                t = HuiFixMath::FixToFloat((65535-anglePos)/2);
                break;
                }

            case EHuiTimedValueStyleDecelerate:
                {
                // Decelerating quarter of a sine wave.
                TInt angle = HuiFixMath::FixMul((fixt/2)+32768,KFixPi);
                TInt anglePos = HuiFixMath::FixCos(angle);
                t = HuiFixMath::FixToFloat((((65536 - anglePos) / 2) - 32768) * 2);
                break;
                }

            case EHuiTimedValueStyleAccelerate:
                {
                // Accelerating quarter of a sine wave.
                TInt angle = HuiFixMath::FixMul(fixt/2,KFixPi);
                TInt anglePos = HuiFixMath::FixCos(angle);
                t = HuiFixMath::FixToFloat((65536 - anglePos));
                break;
                }

            case EHuiTimedValueStyleImpulse:
                {
                // Sine wave curve.
                TInt angle = HuiFixMath::FixMul(fixt,KFixPi);
                TInt anglePos = HuiFixMath::FixCos(angle);
                t = HuiFixMath::FixToFloat((65536 - anglePos) / 2);
                break;
                }

            default:
                // No interpolation.
                t = 0;
                break;
            }

        return HUI_EVALUATED_VALUE(iInterpolationStartValue * (1 - t) + iTargetValue * t);
        }
    else
        {
        if(iInternalState & EFlagInterpolating)
            {
            iInternalState |= EFlagChanged;
            iInternalState &= ~EFlagInterpolating;
            }
        return HUI_EVALUATED_VALUE(iInterpolationStartValue);
        }
    }


EXPORT_C TReal32 THuiTimedValue::Target() const __SOFTFP
    {
    return MapValue(iTargetValue);
    }


EXPORT_C void THuiTimedValue::Set(TReal32 aValue) __SOFTFP
    {
    iTargetValue = iInterpolationStartValue = aValue;
    iInternalState &= ~EFlagInterpolating;
    iInternalState |= EFlagChanged;

    CHuiStatic::ContinueRefresh();
    }


EXPORT_C void THuiTimedValue::Set(TReal32 aValue, TInt aMilliSeconds) __SOFTFP
    {
    if(Math::IsNaN(aValue))
        {
        HUI_DEBUG(_L("THuiTimedValue::Set - Math::IsNaN(aValue)"));
        return;
        }
    if(aMilliSeconds <= 0)
        {
        Set(aValue);
        return;
        }

    if(iInternalState & EFlagInterpolating)
        {
        iInterpolationStartValue = UnmappedNow();
        }
    else
        {
        if( HuiUtil::RealCompare(iInterpolationStartValue, aValue ) )
            {
            // This is the current value of the timed value, and it won't
            // change, so we are already at the target.
            return;
            }
        }

    // Adaptive style depends on whether a change is currently underway.
    if(iInternalState & EFlagAdaptive)
        {
        if(iInternalState & EFlagInterpolating)
            {
            iStyle = EHuiTimedValueStyleDecelerate;
            }
        else
            {
            iStyle = EHuiTimedValueStyleSineWave;
            }
        }

    CHuiStatic::ContinueRefresh();

    iTargetValue = aValue;

    // If the difference between the current value and the target value
    // is insignificant, no interpolation is done (it would be subject
    // to round-off problems).
    const TReal32 KEpsilon = .0001;
    TReal32 delta = aValue - iInterpolationStartValue;
    if(delta > -KEpsilon && delta < KEpsilon)
        {
        iInterpolationStartValue = aValue;
        iInternalState &= ~EFlagInterpolating;
        iInternalState |= EFlagChanged;
        return;
        }

    iInterpolationStartTime = CHuiStatic::MilliSecondsSinceStart();

    // Target time is an offset to the current time.
    iInterpolationEndTime = iInterpolationStartTime + aMilliSeconds;

    iTargetValue = aValue;

    iInternalState |= EFlagChanged | EFlagInterpolating;
    }


EXPORT_C void THuiTimedValue::SetWithSpeed(TReal32 aValue,
                                           TReal32 aUnitsPerSecond) __SOFTFP
    {
    if( Math::IsNaN(aUnitsPerSecond) || Math::IsNaN(aValue) )
        {
        HUI_DEBUG(_L("THuiTimedValue::SetWithSpeed - Math::IsNaN()"));
        return;
        }
    TReal32 delta = UnmappedNow() - aValue;

    // don't divide by 0
    if( HuiUtil::RealCompare( delta, 0.f ) || HuiUtil::RealCompare( aUnitsPerSecond, 0.f ) )
        {
        // Already there.
        Set(aValue);
        return;
        }

    if(delta < 0.f)
        {
        delta = -delta;
        }

    Set(aValue, (TInt)((delta / aUnitsPerSecond) * 1000.0));
    }


EXPORT_C TInt THuiTimedValue::RemainingTime() const
    {
    if(iInternalState & EFlagInterpolating)
        {
        TUint32 lastTime = iInterpolationStartTime;
        if(!(iInternalState & EFlagFrozen))
            {
            // If the value is not frozen, just compare against the current time.
            lastTime = CHuiStatic::MilliSecondsSinceStart();
            }

        TReal32 remaining = SecondsFrom(lastTime, iInterpolationEndTime);
        if(remaining < 0)
            {
            return 0;
            }
        return TInt(remaining * 1000);
        }
    else
        {
        // No interpolation occuring.
        return 0;
        }
    }


EXPORT_C void THuiTimedValue::Finish()
    {
    iInterpolationStartTime = iInterpolationEndTime;
    iInterpolationStartValue = iTargetValue;
    }


EXPORT_C void THuiTimedValue::ClearChanged()
    {
    if(iMapFunction)
        {
        iMapFunction->MappingFunctionClearChanged();
        }
    
    if(!(iInternalState & EFlagInterpolating) &&
       !(iInternalState & EFlagAddSecondsSinceStart))
        {
        iInternalState &= ~EFlagChanged;
        }
    }


EXPORT_C void THuiTimedValue::SetMappingMode(TInt aMode)
    {
    switch(aMode)
        {
        case 0:
            iInternalState &= ~EFlagMappingModeMask;
            break;

        case 1:
            iInternalState |= EFlagMappingModeMask;
            break;
            
        default:
            break;
        }
    }


EXPORT_C void THuiTimedValue::EnableClock(TBool aEnable)
    {
    if(aEnable)
        {
        // EFlagChanged is always raised when the clock mode is enabled.
        iInternalState |= EFlagAddSecondsSinceStart | EFlagChanged;
        }
    else
        {
        iInternalState &= ~EFlagAddSecondsSinceStart;
        }
    }


EXPORT_C void THuiTimedValue::Suspend(TBool aDoSuspend)
    {
    if(aDoSuspend && !(iInternalState & EFlagFrozen))
        {
        iInterpolationStartValue = UnmappedNow(); // to report correct value
        iInternalState |= EFlagFrozen;
        iTimeRemainingWhenSuspended = RemainingTime();
        // UnmappedNow() will not update the state of the value any longer.
        }
    else if(!aDoSuspend && (iInternalState & EFlagFrozen))
        {
        iInternalState &= ~EFlagFrozen;

        if (iTimeRemainingWhenSuspended) // move for real
            {
            iInternalState &= ~EFlagInterpolating; // force us to continue from paused position 
                                                   // + to avoid interpolation mode change 
            Set(iTargetValue, iTimeRemainingWhenSuspended);
            iTimeRemainingWhenSuspended = 0;
            }
        else // old functionality
            {
            // Temporal relocation.
            TUint32 difference = CHuiStatic::MilliSecondsSinceStart() - iInterpolationStartTime;
            iInterpolationStartTime += difference;
            iInterpolationEndTime += difference;
            }
        }
    else
        {
        // for PC lint
        }
    }


EXPORT_C THuiTimedValue& THuiTimedValue::operator=(const THuiTimedValue& aOtherValue)
    {
    if ( this == &aOtherValue )
        {
        Suspend(EFalse);
        return *this;
        }
    
    iStyle = aOtherValue.iStyle;
    iInternalState = aOtherValue.iInternalState;
    iInterpolationStartTime = aOtherValue.iInterpolationStartTime;
    iInterpolationEndTime = aOtherValue.iInterpolationEndTime;
    iInterpolationStartValue = aOtherValue.iInterpolationStartValue;
    iTargetValue = aOtherValue.iTargetValue;
    iMapFunction = aOtherValue.iMapFunction;
    Suspend(EFalse);
    return *this;
    }