/*

* 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 "GfxFlatteningPathIterator.h"

#include "GfxShape.h"

#include "GfxAffineTransform.h"

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

// Constructors

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

CGfxFlatteningPathIterator::CGfxFlatteningPathIterator( TInt32 aLimit )

    : iIdx( 0 ),

      iSegType( EGfxSegClose ),

      iIsDone( EFalse ),

      iLimit( aLimit )

    {

    }

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

// Create a new instance.

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

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

//  CGfxFlatteningPathIterator* CGfxFlatteningPathIterator::NewL( MGfxShape* aSrc,

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

 CGfxFlatteningPathIterator* CGfxFlatteningPathIterator::NewL( MGfxShape* aSrc,

                                                                       TGfxAffineTransform* aAt,

                                                                       TInt32 aLimit )

    {

    CGfxFlatteningPathIterator* self = new ( ELeave )

                                       CGfxFlatteningPathIterator( aLimit );

    CleanupStack::PushL( self );

    self->ConstructL( aSrc, aAt );

    CleanupStack::Pop();

    return self;

    }

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

// Second phase in constructing this object.

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

void CGfxFlatteningPathIterator::ConstructL( MGfxShape* aSrc,

                                             TGfxAffineTransform* aAt )

    {

    aSrc->GetPathIteratorL( aAt, iSrc );

    iCoords = new ( ELeave ) RArray<TFloatFixPt>( 10 );

    iCoords->AppendL( NULL );

    iCoords->Remove(0);

    NextL();

    }

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

// Destructor.

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

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

//  CGfxFlatteningPathIterator::~CGfxFlatteningPathIterator()

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

 CGfxFlatteningPathIterator::~CGfxFlatteningPathIterator()

    {

	if ( iSrc )

		{

		delete iSrc;

		iSrc = NULL;

		}

	if ( iCoords )

		{

		iCoords->Close();

		delete iCoords;

		iCoords = NULL;

		}

    }

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

//  TGfxSegType CGfxFlatteningPathIterator::CurrentSegment( TFloatFixPt* aCoords )

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

 TGfxSegType CGfxFlatteningPathIterator::CurrentSegment( TFloatFixPt* aCoords )

    {

    if ( iCoords->Count() > 0 && iCoords->Count() > iIdx )

        {

        aCoords[0] = ( *iCoords )[iIdx];

        aCoords[1] = ( *iCoords )[iIdx + 1];

        }

    return iSegType;

    }

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

//  TBool CGfxFlatteningPathIterator::IsDone()

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

 TBool CGfxFlatteningPathIterator::IsDone()

    {

    return iIsDone;

    }

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

//  void CGfxFlatteningPathIterator::Next()

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

 void CGfxFlatteningPathIterator::NextL()

    {

    iIdx += 2;

    if ( iCoords->Count() <= 0 || iCoords->Count() <= iIdx )

        {

        TFloatFixPt tmpcoords[6];

        TInt i;

        iCoords->Reset();

        iIdx = 0;

        if ( iSrc->IsDone() )

            {

            iIsDone = ETrue;

            }

        else

            {

            iSegType = iSrc->CurrentSegment( tmpcoords );

            switch ( iSegType )

                {

                case EGfxSegMoveTo:

                    iLastX = tmpcoords[0];

                    iLastY = tmpcoords[1];

                    iCoords->AppendL( iLastX );

                    iCoords->AppendL( iLastY );

                    break;

                case EGfxSegLineTo:

                    iLastX = tmpcoords[0];

                    iLastY = tmpcoords[1];

                    iCoords->AppendL( iLastX );

                    iCoords->AppendL( iLastY );

                    break;

                case EGfxSegQuadTo:

                    iCoords->AppendL( iLastX );

                    iCoords->AppendL( iLastY );

                    iCoords->AppendL( tmpcoords[0] );

                    iCoords->AppendL( tmpcoords[1] );

                    iCoords->AppendL( tmpcoords[2] );

                    iCoords->AppendL( tmpcoords[3] );

                    for ( i = 0; i < iLimit; i++ )

                        CreateSubcurveQuadL( iCoords );

                    //CreateSubcurveQuad(iCoords);

                    //CreateSubcurveQuad(iCoords);

                    //CreateSubcurveQuad(iCoords);

                    iIdx = 2;

                    iLastX = tmpcoords[2];

                    iLastY = tmpcoords[3];

                    iSegType = EGfxSegLineTo;

                    break;

                case EGfxSegCubicTo:

                    iCoords->AppendL( iLastX );

                    iCoords->AppendL( iLastY );

                    iCoords->AppendL( tmpcoords[0] );

                    iCoords->AppendL( tmpcoords[1] );

                    iCoords->AppendL( tmpcoords[2] );

                    iCoords->AppendL( tmpcoords[3] );

                    iCoords->AppendL( tmpcoords[4] );

                    iCoords->AppendL( tmpcoords[5] );

                    for ( i = 0; i < iLimit; i++ )

                        CreateSubcurveCubicL( iCoords );

                    iIdx = 2;

                    iLastX = tmpcoords[4];

                    iLastY = tmpcoords[5];

                    iSegType = EGfxSegLineTo;

                    break;

                case EGfxSegClose:              // (cdm)

                    iLastX = tmpcoords[0];

                    iLastY = tmpcoords[1];

                    iCoords->AppendL( iLastX );

                    iCoords->AppendL( iLastY );

                    break;

                 default:

                    break;

                }

            iSrc->NextL();

            }

        }

    }

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

//  void CGfxFlatteningPathIterator::SetFlatness( TFloatFixPt& aFlatness )

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

 void CGfxFlatteningPathIterator::SetFlatness( TFloatFixPt& aFlatness )

    {

    iFlatness = aFlatness;

    }

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

//  void CGfxFlatteningPathIterator::SetRecursionLimit( TInt32 aLimit )

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

 void CGfxFlatteningPathIterator::SetRecursionLimit( TInt32 aLimit )

    {

    iLimit = aLimit;

    }

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

//  TFloatFixPt CGfxFlatteningPathIterator::Flatness()

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

 TFloatFixPt CGfxFlatteningPathIterator::Flatness()

    {

    return iFlatness;

    }

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

//  TInt32 CGfxFlatteningPathIterator::RecursionLimit()

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

 TInt32 CGfxFlatteningPathIterator::RecursionLimit()

    {

    return iLimit;

    }

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

// void CGfxFlatteningPathIterator::CreateSubcurveQuad( RArray<TFloatFixPt>* aCtrlPoints )

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

void CGfxFlatteningPathIterator::CreateSubcurveQuadL( RArray<TFloatFixPt>* aCtrlPoints )

    {

    TInt32 ix = 0;

    TFloatFixPt x0, y0, xm, ym, x1, y1;

	TInt32 lCount;

    while ( ix + 5 < aCtrlPoints->Count() )

        {

		lCount = ix;

        x0 = ( *aCtrlPoints )[lCount++];

        y0 = ( *aCtrlPoints )[lCount++];

        xm = ( *aCtrlPoints )[lCount++];

        ym = ( *aCtrlPoints )[lCount++];

        x1 = ( *aCtrlPoints )[lCount++];

        y1 = ( *aCtrlPoints )[lCount++];

	#ifdef SVG_FLOAT_BUILD

        x0 = ( x0 + xm ) * .5f;

        y0 = ( y0 + ym ) * .5f;

        x1 = ( x1 + xm ) * .5f;

        y1 = ( y1 + ym ) * .5f;

        xm = ( x0 + x1 ) * .5f;

        ym = ( y0 + y1 ) * .5f;

	#else

        x0 = ( x0 + xm ) >> 1;

        y0 = ( y0 + ym ) >> 1;

        x1 = ( x1 + xm ) >> 1;

        y1 = ( y1 + ym ) >> 1;

        xm = ( x0 + x1 ) >> 1;

        ym = ( y0 + y1 ) >> 1;

	#endif

		lCount=ix + 2;

        ( *aCtrlPoints )[lCount] = xm;

        ( *aCtrlPoints )[lCount + 1] = ym;

        aCtrlPoints->InsertL( TFloatFixPt( x0 ), lCount++);

        aCtrlPoints->InsertL( TFloatFixPt( y0 ), lCount );

        aCtrlPoints->InsertL( TFloatFixPt( x1 ), ix + 6 );

        aCtrlPoints->InsertL( TFloatFixPt( y1 ), ix + 7 );

        ix += 8;

        }

    }

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

// void CGfxFlatteningPathIterator::CreateSubcurveCubic( RArray<TFloatFixPt>* aCtrlPoints )

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

void CGfxFlatteningPathIterator::CreateSubcurveCubicL( RArray<TFloatFixPt>* aCtrlPoints )

    {

    TInt32 ix = 0;

    TFloatFixPt x0, y0, xm, ym, xm1, ym1, xm2, ym2, x1, y1;

	TInt32 lCount;

    while ( ix + 7 < aCtrlPoints->Count() )

        {

		lCount = ix;

        x0 = ( *aCtrlPoints )[lCount++];

        y0 = ( *aCtrlPoints )[lCount++];

        xm1 = ( *aCtrlPoints )[lCount++];

        ym1 = ( *aCtrlPoints )[lCount++];

        xm2 = ( *aCtrlPoints )[lCount++];

        ym2 = ( *aCtrlPoints )[lCount++];

        x1 = ( *aCtrlPoints )[lCount++];

        y1 = ( *aCtrlPoints )[lCount ];

	#ifdef SVG_FLOAT_BUILD

        x0 = ( x0 + xm1 ) * .5f;

        y0 = ( y0 + ym1 ) * .5f;

        x1 = ( x1 + xm2 ) * .5f;

        y1 = ( y1 + ym2 ) * .5f;

        xm = ( xm1 + xm2 ) * .5f;

        ym = ( ym1 + ym2 ) * .5f;

        xm1 = ( x0 + xm ) * .5f;

        ym1 = ( y0 + ym ) * .5f;

        xm2 = ( x1 + xm ) * .5f;

        ym2 = ( y1 + ym ) * .5f;

        xm = ( xm1 + xm2 ) * .5f;

        ym = ( ym1 + ym2 ) * .5f;

	#else

        x0 = ( x0 + xm1 ) >> 1;

        y0 = ( y0 + ym1 ) >> 1;

        x1 = ( x1 + xm2 ) >> 1;

        y1 = ( y1 + ym2 ) >> 1;

        xm = ( xm1 + xm2 ) >> 1;

        ym = ( ym1 + ym2 ) >> 1;

        xm1 = ( x0 + xm ) >> 1;

        ym1 = ( y0 + ym ) >> 1;

        xm2 = ( x1 + xm ) >> 1;

        ym2 = ( y1 + ym ) >> 1;

        xm = ( xm1 + xm2 ) >> 1;

        ym = ( ym1 + ym2 ) >> 1;

	#endif

		lCount=ix + 2;

        ( *aCtrlPoints )[lCount++] = x0;

        ( *aCtrlPoints )[lCount++] = y0;

        ( *aCtrlPoints )[lCount++] = xm1;

        ( *aCtrlPoints )[lCount++] = ym1;

        aCtrlPoints->InsertL( TFloatFixPt( y1 ), lCount);

        aCtrlPoints->InsertL( TFloatFixPt( x1 ), lCount );

        aCtrlPoints->InsertL( TFloatFixPt( ym2 ), lCount );

        aCtrlPoints->InsertL( TFloatFixPt( xm2 ), lCount );

        aCtrlPoints->InsertL( TFloatFixPt( ym ), lCount );

        aCtrlPoints->InsertL( TFloatFixPt( xm ), lCount );

        ix += 12;

        }

    }

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

//  void CGfxFlatteningPathIterator::PolygonizeL( CGfxEdgeListP* /* aRenderer */, TInt /* aFlatness */ )

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

 void CGfxFlatteningPathIterator::PolygonizeL( CGfxEdgeListP* /* aRenderer */, TInt /* aFlatness */ )

{

}