diff -r 000000000000 -r 15bf7259bb7c uiaccelerator_plat/alf_visual_api/inc/alf/alftimedvalue.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiaccelerator_plat/alf_visual_api/inc/alf/alftimedvalue.h Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,595 @@ +/* +* 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: Timed values +* +*/ + + + +#ifndef __ALF_TIMED_VALUE__ +#define __ALF_TIMED_VALUE__ + +#include + +// Todo: is there need to expose these +enum TAlfTimedValueFlags + { + EAlfValueFlagsNone = 0, + EAlfValueNowChanged = 1, + EAlfValueTargetChanged = 2, + EAlfInterpolationStyleChanged =4, + EAlfMappingFunctionChanged = 8, + EAlfSpeedChanged = 16, + EAlfValueFlagsAll = 0xffffffff + }; + +/** + * Timed value interpolation styles. + * + * @see To implement custom interpolation styles, you can use + * mapping functions. + * + * @see MAlfMappingFunction + * @see TAlfTimedValue::SetFunction() + */ +enum TAlfInterpolationStyle + { + /** No interpolation is done. The target value becomes effective + in a single step. */ + EAlfTimedValueStyleUseSystemDefault, + + EAlfTimedValueStyleNone, + + /** Use linear interpolation between the current value and the + target value. */ + EAlfTimedValueStyleLinear, + + /** Use a sine wave for approximating preservation of momentum. */ + EAlfTimedValueStyleSineWave, + + /** Quarter of a sine wave for decelerating movement. */ + EAlfTimedValueStyleDecelerate, + + /** Quarter of a sine wave for accelerating movement. */ + EAlfTimedValueStyleAccelerate, + + /** Sine wave or decelerating style based on when the target value + is defined. */ + EAlfTimedValueStyleAdaptive, + + /** Combination of linear and deceleration. */ + EAlfTimedValueStyleImpulse, + + EAlfTimedValueStyleLast + }; + +/** + * + * Timed value class. + * + * Timed values are able to interpolate their value independently based on + * time. The interpolation can be configured to follow a curve instead of + * being linear. Timed value does not restrict the value units but interpolates + * on any given real value. Mapping function can be used that maps the interpolated + * values to some other real value space. If no mapping function is specified an + * identity mapping is used. Current values and target values of timed value can be + * set through class methods. Delays for timed value to achieve the target value can + * be given in the Set - method. Timed value supports number of different interpolation + * styles. + * + * @code + * // Here are some examples how the timed value can be used. + * // In the examples, the opacity of the visual is used as + * // an example, but any of the timed values work the same. + * + * // #1 New variable - getters are not really relevant + * TAlfTimedValue opacity; + * opacity->SetTarget( 1, 500 ); + * visual->SetOpacity( opacity ); // changes only the target + * + * // 2# Data fetching + * // a) preferred + * const TAlfTimedValue& opacity = visual->Opacity(); + * TReal32 valueNow = opacity->ValueNow(); + * TReal32 target = opacity->Target(); + * // b) + * TReal32 valueNow = visual->Opacity().ValueNow(); + * TReal32 target = visual->Opacity().Target(); + * + * // 3# Data fetching and value update + * TAlfTimedValue opacity( visual->Opacity() ); + * TReal32 target = opacity->Target(); + * opacity->SetTarget( target*2, 500 ); + * visual->SetOpacity( opacity ); + * + * // 4# Use the same timed value for other places: + * // a) + * const TAlfTimedValue& visualOpacity = visual->Opacity(); + * layout->SetOpacity( visualOpacity ); + * // b) + * TAlfTimedValue visualOpacity( visual->Opacity() ); + * visualOpacity->SetTarget( 1, 500 ); + * layout->SetOpacity( visualOpacity ); + * @endcode + * + * @lib alfclient.lib + * @since S60 v3.2 + **/ +class TAlfTimedValue + { + public: + + /** + * Constructor. Enables creation of timed value with no explicitly set initial value. + * The timed value is set to zero. + * + */ + IMPORT_C TAlfTimedValue(); + + /** + * Constructor. Enables initial value setting. + * + * @param aInitialValue Initial value. + * + */ + IMPORT_C TAlfTimedValue(TReal32 aInitialValue) __SOFTFP; + + /** + * Constructor. Enables target value setting. + * + * @param aTargetValue Target value. + * @param aTime When the target value will be in effect. Transition duration in milliseconds. + * + */ + IMPORT_C TAlfTimedValue(TReal32 aTargetValue, TInt aTime) __SOFTFP; + + /** + * Set a new current value Change becomes effective immediately. + * + * @param aValueNow New currentvalue. + */ + IMPORT_C void SetValueNow(const TReal32& aValueNow); + + /** + * Gets current value. + * + * @return Current value. + */ + IMPORT_C TReal32 ValueNow() const __SOFTFP; + + /** + * Set a new target value that becomes effective after a delay. + * @see SetTargetWithSpeed() + * + * @param aValue New target value. + * @param aTime Time duration after the target value will be in effect. Transition duration in milliseconds. + */ + IMPORT_C void SetTarget(const TReal32& aTarget, TInt aTime); + + /** + * Sets a new target value. The transition time depends on the speed. + * @see SetTarget() + * + * @param aTarget New target value. + * @param aUnitsPerSecond Speed of change. + */ + IMPORT_C void SetTargetWithSpeed(TReal32 aTarget, TReal32 aUnitsPerSecond) __SOFTFP; + + /** + * Gets target value. + * + * @return Target value. + */ + IMPORT_C TReal32 Target() const __SOFTFP; + + /** + * Gets duration of the transition. + * + * @return Duration time in milliseconds.. + */ + IMPORT_C TInt TimeToTargetinMilliSeconds() const; + + /** + * Gets speed of the transition in units per second if it has been set + * with SetTargetWithSpeed. + * + * @return Speed of the transition in units per second. + */ + IMPORT_C TReal32 Speed() const __SOFTFP; + + /** + * Sets the interpolation style of the timed value. + * + * @param aStyle Interpolation style used to reach target value. + */ + IMPORT_C void SetStyle(TAlfInterpolationStyle aStyle); + + /** + * Sets identifier of a mapping function that affects the timed value. + * + * @param aIdentifier Identifier of a function that will map the current value to required + * number space. + */ + IMPORT_C void SetMappingFunctionIdentifier(TInt aIdentifier); + + /** + * Gets identifier of a mapping function that affects the timed value. + * + * @return aIdentifier Identifier of a function that will map the current value to required + * number space. + */ + IMPORT_C TInt MappingFunctionIdentifier() const; + + /** + * Gets flags. + * + * @return Flags. + */ + IMPORT_C TInt& Flags(); + + /** + * Gets the interpolation style of the timed value. + * + * @return Interpolation style used to reach target value. + */ + IMPORT_C TAlfInterpolationStyle Style(); + +private: + TReal32 iValueNow; + TReal32 iValueTarget; + TInt iTimeToTarget; + TInt iInterpolationStyle; + TInt iMappingFunctionIdentifier; + TReal32 iSpeed; + TInt iFlags; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +struct TAlfRealPoint + { + TAlfRealPoint():iX(0),iY(0){} + TAlfRealPoint(const TReal32& aX, const TReal32& aY):iX(aX),iY(aY){} + TAlfRealPoint(const TPoint& aPoint):iX(aPoint.iX),iY(aPoint.iY){} + + inline operator TPoint() const + { + return TPoint((TInt)iX, (TInt)iY); + } + + inline TSize AsSize() const + { + return TSize((TInt)iX, (TInt)iY); + } + + inline TAlfRealPoint operator-(const TAlfRealPoint& aPoint) const + { + return TAlfRealPoint(iX - aPoint.iX, iY - aPoint.iY); + } + + inline TAlfRealPoint operator+(const TAlfRealPoint& aPoint) const + { + return TAlfRealPoint(iX + aPoint.iX, iY + aPoint.iY); + } + + inline TAlfRealPoint& operator+=(const TAlfRealPoint& aPoint) + { + iX += aPoint.iX; + iY += aPoint.iY; + return *this; + } + + inline TAlfRealPoint& operator-=(const TAlfRealPoint& aPoint) + { + iX -= aPoint.iX; + iY -= aPoint.iY; + return *this; + } + + inline TBool operator==(const TAlfRealPoint& aPoint) const + { + if ( Abs(iX-aPoint.iX) < 0.0001 && Abs(iY-aPoint.iY) < 0.0001 ) + { + return ETrue; + } + + return EFalse; + } + + TReal32 iX; + TReal32 iY; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +struct TAlfRealSize + { + TAlfRealSize() + : iWidth(0.f), iHeight(0.f) {} + + inline TAlfRealSize(TReal32 aWidth, TReal32 aHeight) + : iWidth(aWidth), iHeight(aHeight) + { + } + + inline TAlfRealSize(const TSize& aSize) + : iWidth((TReal32)aSize.iWidth), iHeight((TReal32)aSize.iHeight) + { + } + + inline TAlfRealSize(const TAlfRealPoint& aPoint) + : iWidth( aPoint.iX ), iHeight( aPoint.iY ) + { + } + + inline operator TSize() const + { + return TSize((TInt)iWidth, (TInt)iHeight); + } + +public: + + /** Width. */ + TReal32 iWidth; + + /** Height. */ + TReal32 iHeight; + +private: + TInt iSpare1; + TInt iSpare2; + }; + + +struct TAlfRealRect + { + TAlfRealRect(){} + TAlfRealRect(const TRect& aRect):iTl(aRect.iTl),iBr(aRect.iBr){} + TAlfRealRect(const TAlfRealPoint& aTl, const TAlfRealPoint& aBr):iTl(aTl),iBr(aBr){} + inline operator TRect() const + { + return TRect((TPoint)iTl, (TPoint)iBr); + } + + inline TReal32 Width() const + { + return iBr.iX - iTl.iX; + } + + inline TReal32 Height() const + { + return iBr.iY - iTl.iY; + } + + inline TAlfRealPoint TopRight() const + { + return TAlfRealPoint(iBr.iX, iTl.iY); + } + + inline TAlfRealPoint BottomLeft() const + { + return TAlfRealPoint(iTl.iX, iBr.iY); + } + + inline TAlfRealSize Size() const + { + return TAlfRealSize(Width(), Height()); + } + + + inline TAlfRealPoint Center() const + { + return iTl + TAlfRealPoint(Width()/2, Height()/2); + } + + + inline void Grow(TReal32 aX, TReal32 aY) + { + iTl.iX -= aX; + iTl.iY -= aY; + iBr.iX += aX; + iBr.iY += aY; + } + + inline void Shrink(TReal32 aX, TReal32 aY) + { + iTl.iX += aX; + iTl.iY += aY; + iBr.iX -= aX; + iBr.iY -= aY; + } + + inline void Shrink(const TPoint& aPoint) + { + iTl.iX += aPoint.iX; + iTl.iY += aPoint.iY; + iBr.iX -= aPoint.iX; + iBr.iY -= aPoint.iY; + } + + inline void Shrink(const TAlfRealPoint& aPoint) + { + iTl.iX += aPoint.iX; + iTl.iY += aPoint.iY; + iBr.iX -= aPoint.iX; + iBr.iY -= aPoint.iY; + } + + inline void Shrink(const TAlfRealRect& aRect) + { + iTl.iX += aRect.iTl.iX; + iTl.iY += aRect.iTl.iY; + iBr.iX -= aRect.iBr.iX; + iBr.iY -= aRect.iBr.iY; + } + + inline void Move(TReal32 aDx, TReal32 aDy) + { + iTl.iX += aDx; + iTl.iY += aDy; + iBr.iX += aDx; + iBr.iY += aDy; + } + + TAlfRealPoint iTl; + TAlfRealPoint iBr; + +private: + TInt iSpare1; + TInt iSpare2; + }; + +class TAlfTimedPoint + { +public: + /** + * Default constructor. + */ + IMPORT_C TAlfTimedPoint(); + + /** + * Constructor that sets default values. + */ + IMPORT_C TAlfTimedPoint(TReal32 aX, TReal32 aY) __SOFTFP; + + /** + * Constructor. Enables target value setting. + * + * @param aXTarget Target X value. + * @param aYTarget Target Y value. + * @param aTransitionTime When the target value will be in effect. Transition duration in milliseconds. + * + */ + IMPORT_C TAlfTimedPoint(TReal32 aXTarget, TReal32 aYTarget, TInt aTransitionTime) __SOFTFP; + + /** + * Sets the interpolation style of both components of the point. + * + * @param aStyle Timed value interpolation style. + */ + IMPORT_C void SetStyle(TAlfInterpolationStyle aStyle); + + /** + * Sets identifier of a mapping function that affects the timed value for both + * components of the point. + * + * @param aIdentifier Identifier of a function that will map the current value to required + * number space. + */ + IMPORT_C void SetMappingFunctionIdentifier(TInt aIdentifier); + + /** + * Sets the target for the timed point. + * + * @param aPoint Target point. + * @param aTransitionTime Duration for reaching the target. + */ + IMPORT_C void SetTarget(const TAlfRealPoint& aPoint, TInt aTransitionTime = 0); + + /** + * Sets the target value of both components of the timed point. + * + * @param aValue New target value. + * @param aTransitionTime Duration for reaching the target. + */ + IMPORT_C void SetTarget(TReal32 aValue, TInt aTransitionTime = 0) __SOFTFP; + + /** + * Sets the target value for the timed point, with a transition that is + * done using a specific speed. + * + * @param aPoint Target point. + * @param aUnitsPerSecond Units per second during the transition. + */ + IMPORT_C void SetTargetWithSpeed(const TAlfRealPoint& aPoint, TReal32 aUnitsPerSecond) __SOFTFP; + + /** + * Sets the target value of both components of the timed point. + * + * @param aValue New target value. + * @param aUnitsPerSecond Speed of change. + */ + IMPORT_C void SetTargetWithSpeed(TReal32 aValue, TReal32 aUnitsPerSecond) __SOFTFP; + + /** + * Returns the current value of the point. + * + * @return Current values as a regular TAlfRealPoint. + */ + inline TAlfRealPoint ValueNow() const + { + return TAlfRealPoint(iX.ValueNow(), iY.ValueNow()); + } + + /** + * Returns the target value of the point. + * + * @return Target as a TAlfRealPoint. + */ + inline TAlfRealPoint Target() const + { + return TAlfRealPoint(iX.Target(), iY.Target()); + } + + /** + * Returns the transition time value of the point. + * + * @return Transition times as a TAlfRealPoint. + */ + inline TAlfRealPoint TimeToTargetinMilliSeconds() const + { + return TAlfRealPoint(iX.TimeToTargetinMilliSeconds(), iY.TimeToTargetinMilliSeconds()); + } + + /** + * Returns the current interpolatad value of the point rounded to nearest + * integer values. Note that the TAlfTimedPoint values are + * floating-point. + * + * @see ValueNow() For returning the floating-point current value. + * + * @return Current values as a regular TPoint. + */ + IMPORT_C TPoint IntValueNow() const; + + /** + * Returns the target value of the point rounded to nearest + * integer values. Note that the TAlfTimedPoint values are + * floating-point. + * + * @see Target() For returning the floating-point values. + * + * @return Target values as a normal TPoint - target value rounded to + * nearest integer. + */ + IMPORT_C TPoint IntTarget() const; + +public: + + TAlfTimedValue iX; + TAlfTimedValue iY; + +private: + TInt iSpare1; + TInt iSpare2; + }; + + + + +#endif \ No newline at end of file