/*

* Copyright (c) 2002 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:  Graphics Extension Library source file

*

*/

#include "GfxGeneralPath.h"

#include "GfxGeneralPathIteratorP.h"

#include "GfxFlatteningPathIterator.h"

// ---------------------------------------------------------------------------

// Constructors

// ---------------------------------------------------------------------------

// --------------------------------------------------------------------------

//  CGfxGeneralPath* CGfxGeneralPath::NewL()

// ---------------------------------------------------------------------------

 CGfxGeneralPath* CGfxGeneralPath::NewL()

    {

    CGfxGeneralPath* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

// --------------------------------------------------------------------------

//  CGfxGeneralPath* CGfxGeneralPath::NewLC()

// ---------------------------------------------------------------------------

 CGfxGeneralPath* CGfxGeneralPath::NewLC()

    {

    CGfxGeneralPath* self = new ( ELeave ) CGfxGeneralPath;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// --------------------------------------------------------------------------

// CGfxGeneralPath::CGfxGeneralPath()

// ---------------------------------------------------------------------------

CGfxGeneralPath::CGfxGeneralPath()

{

}

// --------------------------------------------------------------------------

// void CGfxGeneralPath::ConstructL()

// ---------------------------------------------------------------------------

void CGfxGeneralPath::ConstructL()

    {

    iPointTypes = new ( ELeave ) RArray<TUint32>( 4 );

    iPointTypes->AppendL(NULL);

    iPointTypes->Remove(0);

    iPointCoords = new ( ELeave ) RArray<TFloatFixPt>( 8 );

    iPointCoords->AppendL(NULL);

    iPointCoords->Remove(0);

    iPathSegmentTypeArray = NULL;

    iCount = 0;

    }

// --------------------------------------------------------------------------

//  CGfxGeneralPath::~CGfxGeneralPath()

// ---------------------------------------------------------------------------

 CGfxGeneralPath::~CGfxGeneralPath()

    {

	if ( iPointTypes )

		{

		iPointTypes->Close();

		delete iPointTypes;

		iPointTypes = NULL;

		}

	if ( iPointCoords )

		{

	    iPointCoords->Close();

		delete iPointCoords;

		iPointCoords = NULL;

		}

    if (iPathSegmentTypeArray)

       {

    	delete [] iPathSegmentTypeArray;

    	iPathSegmentTypeArray = NULL;

       }

    }

const TUint32 KSegClose = ( TUint32 ) EGfxSegClose;

// --------------------------------------------------------------------------

// TFloatFixPt CGfxGeneralPath::AreaSize()

// ---------------------------------------------------------------------------

TFloatFixPt CGfxGeneralPath::AreaSize()

    {

    return TFloatFixPt(0);

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::ClosePathL()

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::ClosePathL()

    {

    TInt count = iPointTypes->Count();

    if ( count > 0 && (*iPointTypes)[count - 1] != KSegClose )

        {

        iPointTypes->AppendL( KSegClose );

            }

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::HorizonToL( TFloatFixPt& aX, TBool aAbsolute )

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::HorizonToL( TFloatFixPt& aX, TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            aX += iLastX;

            }

        else

            {

            aX += iPointCoords->operator[]( iPointCoords->Count() - 2 );

            }

        }

    TUint32 KSegLineto = ( TUint32 ) EGfxSegLineTo;  // const

    iPointTypes->AppendL( KSegLineto );

    iPointCoords->AppendL( aX );

    TFloatFixPt tmpY = ( iPointCoords->Count() < 2 ) ? TFloatFixPt( 0 ) : iPointCoords->operator[]( iPointCoords->Count() - 2 );

    iPointCoords->AppendL( tmpY );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::VertToL( TFloatFixPt& aY, TBool aAbsolute )

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::VertToL( TFloatFixPt& aY, TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            aY += iLastY;

            }

        else

            {

            aY += iPointCoords->operator[]( iPointCoords->Count() - 1 );

            }

        }

    TUint32 KSegLineto = ( TUint32 ) EGfxSegLineTo;  // const

    iPointTypes->AppendL( KSegLineto );

    TFloatFixPt tmpX = ( iPointCoords->Count() < 2 ) ? TFloatFixPt( 0 ) : iPointCoords->operator[]( iPointCoords->Count() - 2 );

    iPointCoords->AppendL( tmpX );

    iPointCoords->AppendL( aY );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::LineToL( TFloatFixPt& aX,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::LineToL( TFloatFixPt& aX,

                                        TFloatFixPt& aY,

                                        TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        TFloatFixPt lastX = iPointCoords->operator[]( iPointCoords->Count() - 2 );

        TFloatFixPt lastY = iPointCoords->operator[]( iPointCoords->Count() - 1 );

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            lastX = iLastX;

            lastY = iLastY;

            }

        aX += lastX;

        aY += lastY;

        }

    TUint32 KSegLineto = ( TUint32 ) EGfxSegLineTo;  // const

    iPointTypes->AppendL( KSegLineto );

    iPointCoords->AppendL( aX );

    iPointCoords->AppendL( aY );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::RemoveLastPathCommand()

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::RemoveLastPathCommand()

	{

	TInt aTypeCount = iPointTypes->Count();

	TInt aPointCount = iPointCoords->Count();

	if ( aPointCount >= 2 )

    	{

        //we need to remove the last amount from iLastX

        iLastX -= (*iPointCoords)[aPointCount - 2];

        iLastY -= (*iPointCoords)[aPointCount - 1];

	    }

	if ( aTypeCount > 0 )

		{

		iPointTypes->Remove( aTypeCount - 1 );

		if ( aPointCount >= 2 )

			{

            iPointCoords->Remove( aPointCount - 1 );

            iPointCoords->Remove( aPointCount - 2 );

			}

		}

	}

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::MoveToL( TFloatFixPt& aX,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::MoveToL( TFloatFixPt& aX,

                                        TFloatFixPt& aY,

                                        TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            aX += iLastX;

            aY += iLastY;

            }

        else

            {

            TFloatFixPt lastX = iPointCoords->operator[]( iPointCoords->Count() -

                                                     2 );

            TFloatFixPt lastY = iPointCoords->operator[]( iPointCoords->Count() -

                                                     1 );

            aX += lastX;

            aY += lastY;

            }

        }

    TUint32 KSegMoveto = ( TUint32 ) EGfxSegMoveTo;  // const

    iPointTypes->AppendL( KSegMoveto );

    iPointCoords->AppendL( aX );

    iPointCoords->AppendL( aY );

    // Save initial point of a new segment

    // Could be the next initial point

    iLastX = aX;

    iLastY = aY;

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::QuadToL( TFloatFixPt& aX1,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::QuadToL( TFloatFixPt& aX1,

                                        TFloatFixPt& aY1,

                                        TFloatFixPt& aX2,

                                        TFloatFixPt& aY2,

                                        TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        TFloatFixPt lastX = iPointCoords->operator[]( iPointCoords->Count() - 2 );

        TFloatFixPt lastY = iPointCoords->operator[]( iPointCoords->Count() - 1 );

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            lastX = iLastX;

            lastY = iLastY;

            }

        aX1 += lastX;

        aY1 += lastY;

        aX2 += lastX;

        aY2 += lastY;

        }

       TUint32 KSegQuadto = ( TUint32 ) EGfxSegQuadTo;

       iPointTypes->AppendL( KSegQuadto );

       iPointCoords->AppendL( aX1 );

       iPointCoords->AppendL( aY1 );  

       iPointCoords->AppendL( aX2 );

       iPointCoords->AppendL( aY2 );	

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::CubicToL( TFloatFixPt& aX1,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::CubicToL( TFloatFixPt& aX1,

                                         TFloatFixPt& aY1,

                                         TFloatFixPt& aX2,

                                         TFloatFixPt& aY2,

                                         TFloatFixPt& aX3,

                                         TFloatFixPt& aY3,

                                         TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        TFloatFixPt lastX = iPointCoords->operator[]( iPointCoords->Count() - 2 );

        TFloatFixPt lastY = iPointCoords->operator[]( iPointCoords->Count() - 1 );

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            lastX = iLastX;

            lastY = iLastY;

            }

        aX1 += lastX;

        aY1 += lastY;

        aX2 += lastX;

        aY2 += lastY;

        aX3 += lastX;

        aY3 += lastY;

        }

    TUint32 KSegCubicto = ( TUint32 ) EGfxSegCubicTo;  // const

    iPointTypes->AppendL( KSegCubicto );

    iPointCoords->AppendL( aX1 );

    iPointCoords->AppendL( aY1 );

    iPointCoords->AppendL( aX2 );

    iPointCoords->AppendL( aY2 );

    iPointCoords->AppendL( aX3 );

    iPointCoords->AppendL( aY3 );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::ShortQuadToL( TFloatFixPt& aX2,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::ShortQuadToL( TFloatFixPt& aX2,

                                             TFloatFixPt& aY2,

                                             TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            aX2 += iLastX;

            aY2 += iLastY;

            }

        else

            {

            aX2 += iPointCoords->operator[]( iPointCoords->Count() - 2 );

            aY2 += iPointCoords->operator[]( iPointCoords->Count() - 1 );

            }

        }

    TFloatFixPt aX1, aY1;

    GetCurveRefPoint( aX1, aY1 );

    QuadToL( aX1, aY1, aX2, aY2, ETrue );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::ShortCubicToL( TFloatFixPt& aX2,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::ShortCubicToL( TFloatFixPt& aX2,

                                              TFloatFixPt& aY2,

                                              TFloatFixPt& aX3,

                                              TFloatFixPt& aY3,

                                              TBool aAbsolute )

    {

    if ( !aAbsolute && iPointCoords->Count() >= 2 )

        {

        TFloatFixPt lastX = iPointCoords->operator[]( iPointCoords->Count() - 2 );

        TFloatFixPt lastY = iPointCoords->operator[]( iPointCoords->Count() - 1 );

        // If the last command was 'Z'/'z'

        // the current point is the initial point

        // of the previous segment - 'M'/'m' usually

        if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) == KSegClose )

            {

            lastX = iLastX;

            lastY = iLastY;

            }

        aX2 += lastX;

        aY2 += lastY;

        aX3 += lastX;

        aY3 += lastY;

        }

    TFloatFixPt aX1, aY1;

    GetCurveRefPoint( aX1, aY1 );

    // If there is no previous command or if the previous command

   //  was not an C, c, S or s, the first control point shall be coincident 

   //  with the current point.

    TUint32 KSegCubicto = ( TUint32 ) EGfxSegCubicTo;  // const    

    if ( iPointTypes->operator[]( iPointTypes->Count() - 1 ) != KSegCubicto )

        {

        aX1 = iLastX;

        aY1 = iLastY;

        }

    CubicToL( aX1, aY1, aX2, aY2, aX3, aY3, ETrue );

    }

// --------------------------------------------------------------------------

// void CGfxGeneralPath::GetCurveRefPoint( TFloatFixPt& aX, TFloatFixPt& aY )

// ---------------------------------------------------------------------------

void CGfxGeneralPath::GetCurveRefPoint( TFloatFixPt& aX, TFloatFixPt& aY )

    {

    if ( iPointCoords->Count() < 4 )

        {

        aX = TFloatFixPt( 0 );

        aY = TFloatFixPt( 0 );

        return;

        }

    TFloatFixPt x0 = iPointCoords->operator[]( iPointCoords->Count() - 4 );

    TFloatFixPt y0 = iPointCoords->operator[]( iPointCoords->Count() - 3 );

    TFloatFixPt x1 = iPointCoords->operator[]( iPointCoords->Count() - 2 );

    TFloatFixPt y1 = iPointCoords->operator[]( iPointCoords->Count() - 1 );

    aX = x1 + x1 - x0;

    aY = y1 + y1 - y0;

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::Reset()

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::Reset()

    {

    iPointTypes->Reset();

    iPointCoords->Reset();

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::AppendL( CGfxPathIterator* aItr )

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::AppendL( CGfxPathIterator* aItr )

    {

    TFloatFixPt tmpcoords[6];

    // Set path data...

    while ( !aItr->IsDone() )

        {

        switch ( aItr->CurrentSegment( tmpcoords ) )

            {

            case EGfxSegMoveTo:

                MoveToL( tmpcoords[0], tmpcoords[1], ETrue );

                break;

            case EGfxSegLineTo:

                LineToL( tmpcoords[0], tmpcoords[1], ETrue );

                break;

            case EGfxSegQuadTo:

                QuadToL( tmpcoords[0],

                         tmpcoords[1],

                         tmpcoords[2],

                         tmpcoords[3],

                         ETrue );

                break;

            case EGfxSegCubicTo:

                CubicToL( tmpcoords[0],

                          tmpcoords[1],

                          tmpcoords[2],

                          tmpcoords[3],

                          tmpcoords[4],

                          tmpcoords[5],

                          ETrue );

                break;

            case EGfxSegClose:

                ClosePathL();

            }

        aItr->NextL();

        }

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::GetBounds( const TGfxAffineTransform& aAt,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::GetBounds( const TGfxAffineTransform& aAt,

                                          TGfxRectangle2D& aRect )

    {

     TFloatFixPt xMin(KMAXFLOATFIX), yMin(KMAXFLOATFIX), xMax(KMINFLOATFIX), yMax(KMINFLOATFIX);

     for (TInt i=0; i<iPointCoords->Count(); i+=2)

     {

        TGfxPoint2D p((*iPointCoords)[i], (*iPointCoords)[i+1]);

        aAt.Transform(&p, &p, 1);

        if (p.iX < xMin) xMin = p.iX;

        if (p.iX > xMax) xMax = p.iX;

        if (p.iY < yMin) yMin = p.iY;

        if (p.iY > yMax) yMax = p.iY;

     }

     aRect.iX = xMin;

     aRect.iY = yMin;

     aRect.iWidth = xMax - xMin;

     aRect.iHeight = yMax - yMin;

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::GetPathIteratorL( TGfxAffineTransform* aAt,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::GetPathIteratorL( TGfxAffineTransform* aAt,

                                                 CGfxPathIterator*& aPitr )

    {

    aPitr = new ( ELeave ) CGfxGeneralPathIteratorP( this, aAt );

    }

// --------------------------------------------------------------------------

//  void CGfxGeneralPath::GetPathIteratorL( TGfxAffineTransform* aAt,

// ---------------------------------------------------------------------------

 void CGfxGeneralPath::GetPathIteratorL( TGfxAffineTransform* aAt,

                                                 TInt aLimit,

                                                 CGfxPathIterator*& aPitr )

    {

    aPitr = CGfxFlatteningPathIterator::NewL( this, aAt, aLimit );

    }