/*

* 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 for CHuiCurvePath. Curve paths are composed of 

*                path segments and can be used as mapping functions, and in 

*                line visuals.

*

*/

#include "uiacceltk/HuiCurvePath.h"

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiRealPoint.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/huifixmath.h"

#include "huicurvepathprivdata.h"

#include <e32math.h>

EXPORT_C CHuiCurvePath* CHuiCurvePath::NewL()

    {

    CHuiCurvePath* self = CHuiCurvePath::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CHuiCurvePath* CHuiCurvePath::NewLC()

    {

    // Create a curve path suitable for the current renderer.

    CHuiCurvePath* self = CHuiStatic::Renderer().CreateCurvePathL();

    self->iExtension = new (ELeave) THuiCurvePathExtension;

    self->iExtension->iLooped = ETrue;

    self->iExtension->iLegacyAPIUsed = EFalse;

    self->iExtension->iVisual = NULL;

    CleanupStack::PushL(self);

    return self;

    }

EXPORT_C CHuiCurvePath::CHuiCurvePath()

        : iExtension(NULL), iChanged(ETrue)

    {

    }

EXPORT_C CHuiCurvePath::~CHuiCurvePath()

    {

    iSegments.Close();

    delete iExtension;

    }

EXPORT_C void CHuiCurvePath::Reset()

    {

    iSegments.Reset();

    iTotalLength = 0;

    iOffset.Set(TPoint(0, 0));

    iPosOrigin = 0;

    iChanged = ETrue;

    }

EXPORT_C void CHuiCurvePath::EnableLoop(TBool aEnable)

    {

    iExtension->iLooped = aEnable;

    iChanged = ETrue;

    }

EXPORT_C TBool CHuiCurvePath::Loop() const

    {

    return iExtension->iLooped;

    }

EXPORT_C TBool CHuiCurvePath::NeedUpdate() const

    {

    if ( iOffset.Changed() )

        {

        return ETrue;

        }

    return iNeedUpdate;

    }

EXPORT_C void CHuiCurvePath::SetNeedsUpdate()

    {

    iNeedUpdate = ETrue;

    }

EXPORT_C void CHuiCurvePath::SetOrigin(TReal32 aPosOrigin) __SOFTFP

    {

    iPosOrigin = aPosOrigin;

    iNeedUpdate = ETrue;    

    iChanged = ETrue;

    }

/**

 * @deprecated 

 */

EXPORT_C void 

CHuiCurvePath::AppendLineL(const TPoint& aStart, const TPoint& aEnd, 

                           TReal32 aLength) __SOFTFP

    {

    AppendLineL(THuiRealPoint(aStart), THuiRealPoint(aEnd), aLength);

    iExtension->iLegacyAPIUsed = ETrue;

    }

EXPORT_C void 

CHuiCurvePath::AppendLineL(const THuiRealPoint& aStart, const THuiRealPoint& aEnd, 

                           TReal32 aLength) __SOFTFP

    {

    TSegment segment;

    segment.iType = ESegmentTypeLine;

    segment.iOrigin = aStart;

    segment.iDelta = aEnd - aStart;

    segment.iStartAngle = segment.iAngleDelta = 0;

    if(aLength < 0)

        {

        TReal length2 = segment.iDelta.iX * segment.iDelta.iX + 

                        segment.iDelta.iY * segment.iDelta.iY;

        TReal target;

        Math::Sqrt(target, length2);

        segment.iLength = TReal32(target);

        }

    else

        {

        segment.iLength = aLength;

        }

    TReal32 length = CalculateLength();        

    segment.iTotalPos = length;

    User::LeaveIfError(iSegments.Append(segment)); 

    iTotalLength = length + segment.iLength;

    iNeedUpdate = ETrue;

    iChanged = ETrue;

    }

/**

 * @deprecated 

 */

EXPORT_C void 

CHuiCurvePath::AppendArcL(const TPoint& aOrigin, const TSize& aSize,

                          TReal32 aStartAngle, TReal32 aEndAngle,

                          TReal32 aLength) __SOFTFP

    {

    AppendArcL(THuiRealPoint(aOrigin), THuiRealSize(aSize), aStartAngle, aEndAngle, aLength);    

    iExtension->iLegacyAPIUsed = ETrue;

    }

EXPORT_C void 

CHuiCurvePath::AppendArcL(const THuiRealPoint& aOrigin, const THuiRealSize& aSize,

                          TReal32 aStartAngle, TReal32 aEndAngle,

                          TReal32 aLength) __SOFTFP

    {

    TSegment segment;

    segment.iType = ESegmentTypeArc;

    segment.iOrigin = aOrigin;

    segment.iDelta = THuiRealPoint(aSize.iWidth, aSize.iHeight);

    segment.iStartAngle = aStartAngle;

    segment.iAngleDelta = aEndAngle - aStartAngle;

    if(aLength < 0)

        {

        // Calculate ellipse arc length.

        // Approximation: 2 * pi * sqrt((a^2+b^2)/2) 

        TReal temp = 0;

        TReal a = (aSize.iWidth*aSize.iWidth + 

                   aSize.iHeight*aSize.iHeight) / 2.0;

        Math::Sqrt(temp, a);

        TReal32 angleLength = segment.iAngleDelta;

        if(angleLength < 0)

            {

            angleLength = -angleLength;

            }

        segment.iLength = 2.f * KPi * temp * angleLength / 360.f;

        }

    else

        {

        segment.iLength = aLength;

        }

    TReal32 length = CalculateLength();        

    segment.iTotalPos = length;

    User::LeaveIfError(iSegments.Append(segment));

    iTotalLength = length + segment.iLength;

    iNeedUpdate = ETrue;

    iChanged = ETrue;

    }

EXPORT_C TReal32 CHuiCurvePath::CalculateLength() const

    {

    TReal32 length = 0;

    for(TInt i = 0; i < iSegments.Count(); ++i)

        {

        length += iSegments[i].iLength;

        }

    return length;        

    }

EXPORT_C TReal32 CHuiCurvePath::Length() const __SOFTFP

    {

    return iTotalLength;

    }

EXPORT_C void CHuiCurvePath::Evaluate(TReal32 aPos, THuiRealPoint& aPoint) const __SOFTFP

    {

    if(!iSegments.Count())

        {

        // No segments to evalute.

        aPoint = THuiRealPoint(0.f, 0.f);

        return;

        }

    aPos += iPosOrigin;

    TReal32 length = Length();

    if(iExtension->iLooped)

        {

        // Wrap to range so that negative positions are mapped to the end.

        HuiUtil::WrapValue(aPos, 0.f, length);

        }

    else

        {

        aPos = Max(0.f, aPos);

        aPos = Min(aPos, length);

        }

    if(aPos < 0)

        {

        // Not a valid position on the path. Beginning of the first segment.

        EvaluateSegment(0.f, iSegments[0], aPoint);

        return;

        }                        

    for(TInt i = 0; i < iSegments.Count(); ++i)

        {

        const TSegment& segment = iSegments[i];

        if(aPos < segment.iLength)

            {

            EvaluateSegment(aPos, segment, aPoint);

            return;

            }

        aPos -= segment.iLength;

        }

    // The position is past the end of the last segment.

    const TSegment& lastSegment = iSegments[iSegments.Count() - 1];

    EvaluateSegment(lastSegment.iLength, lastSegment, aPoint);

    }

EXPORT_C TInt CHuiCurvePath::SegmentCount() const

    {

    return iSegments.Count();

    }

EXPORT_C CHuiCurvePath::TSegment CHuiCurvePath::Segment(TInt aIndex) const

    {

    return iSegments[aIndex];

    }

EXPORT_C void CHuiCurvePath::EvaluateSegment(TReal32 aPos, const TSegment& aSegment,

                                    THuiRealPoint& aPoint,

                                    THuiRealPoint* aNormal) const

    {

    // aPos is in range [0,width].

    if(aSegment.iLength > 0)

        {

        // Normalize position.

        aPos /= aSegment.iLength;

        }

    if(aSegment.iType == ESegmentTypeLine)

        {

        aPoint.iX = aSegment.iOrigin.iX + aPos * aSegment.iDelta.iX;

        aPoint.iY = aSegment.iOrigin.iY + aPos * aSegment.iDelta.iY;

        if(aNormal)

            {

            aNormal->iX = -aSegment.iDelta.iY;

            aNormal->iY = aSegment.iDelta.iX;

            HuiUtil::QuickNormalize(*aNormal);

            }

        }

    else if(aSegment.iType == ESegmentTypeArc)

        {

        TReal a = 0.0;

        TReal b = 0.0;

        const TReal angle = ((aSegment.iStartAngle + aPos * aSegment.iAngleDelta) / 180.f ) * KPi;

        Math::Cos( a, angle );

        Math::Sin( b, angle );

        aPoint.iX = aSegment.iOrigin.iX + aSegment.iDelta.iX * a;

        aPoint.iY = aSegment.iOrigin.iY + aSegment.iDelta.iY * b;

        if(aNormal)

            {

            aNormal->iX = a * aSegment.iDelta.iX;

            aNormal->iY = b * aSegment.iDelta.iY;

            HuiUtil::QuickNormalize(*aNormal);

            // Reverse normal, if arc going the other way.

            if(aSegment.iAngleDelta > 0)

                {

                aNormal->iX = -aNormal->iX;

                aNormal->iY = -aNormal->iY;

                }

            }

        }

    else

        {

        // for PC lint

        }

    // Apply an offset.        

    aPoint += iOffset.RealNow();        

    }

EXPORT_C TReal32 CHuiCurvePath::MapValue(TReal32 aValue, TInt aComponent) const __SOFTFP

    {

    THuiRealPoint point;

    Evaluate(aValue, point);

    if(aComponent == 0)

        {

        return point.iX;

        }

    else

        {

        return point.iY;

        }

    }

EXPORT_C TBool CHuiCurvePath::MappingFunctionChanged() const

    {

    return iChanged;

    }

EXPORT_C void CHuiCurvePath::MappingFunctionClearChanged()

    {

    iChanged = EFalse;

    }

EXPORT_C void CHuiCurvePath::Update(TReal32 /*aStartPos*/, 

                           TReal32 /*aEndPos*/, 

                           TReal32 /*aAlphaFactor*/,

                           MHuiMappingFunction* /*aAlphaFunction*/,

                           MHuiMappingFunction* /*aWidthFunction*/) __SOFTFP

    {

    iNeedUpdate = EFalse;

    iOffset.ClearChanged();

    }

EXPORT_C void CHuiCurvePath::Draw(const TPoint& /*aOrigin*/, CHuiGc* /*aGc*/) const

    {

    }

EXPORT_C void CHuiCurvePath::SetVisual(const CHuiVisual* aVisual) const

    {

    if (!iExtension->iLegacyAPIUsed)

        {

        iExtension->iVisual = const_cast<CHuiVisual*>(aVisual);   

        }

    }

EXPORT_C const CHuiVisual* CHuiCurvePath::GetVisual() const

    {

    return iExtension->iVisual;

    }

EXPORT_C TBool CHuiCurvePath::IsLegacyApiUsed() const

	{

	return(iExtension->iLegacyAPIUsed);

	}

EXPORT_C void CHuiCurvePath::CurvePathExtension(const TUid& /*aExtensionUid*/, TAny** aExtensionParams)

    {

    // If no extension with given UID was found, indicate it by returning null

    *aExtensionParams = NULL;

    }