/*

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

#define EInitialised  0

#define ECurrent      1

#define EComplete     2

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

// Create a new instance and push it onto the cleanup stack.

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

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

// CGfxEdgeListP* CGfxEdgeListP::NewLC( TGfxRendererInfoP* aRenderInfo )

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

CGfxEdgeListP* CGfxEdgeListP::NewLC( TGfxRendererInfoP* aRenderInfo )

    {

    CGfxEdgeListP* self = new ( ELeave ) CGfxEdgeListP( aRenderInfo );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Create a new instance.

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

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

// CGfxEdgeListP* CGfxEdgeListP::NewL( TGfxRendererInfoP* aRenderInfo )

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

CGfxEdgeListP* CGfxEdgeListP::NewL( TGfxRendererInfoP* aRenderInfo )

    {

    CGfxEdgeListP* self = NewLC( aRenderInfo );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor.

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

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

// CGfxEdgeListP::~CGfxEdgeListP()

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

CGfxEdgeListP::~CGfxEdgeListP()

    {

     delete[] iPoints;

     iPoints = NULL;

     delete[] iSegset;

     iSegset = NULL;

     delete[] iEdges;

     iEdges = NULL;

    }

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

// Constructor

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

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

// CGfxEdgeListP::CGfxEdgeListP( TGfxRendererInfoP* aRenderInfo ) : iWaitingSegList( NULL ),

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

CGfxEdgeListP::CGfxEdgeListP( TGfxRendererInfoP* aRenderInfo ) : iWaitingSegList( NULL ),

                                                                 iActiveSegList( NULL ),

                                                                 iPointsCount( 0 ),

                                                                 iSegsetCount( 0 ),

																 iPointsCountMax( 20 ),

                                                                 iSegsetCountMax( 10 ),

                                                                 iEdgesCountMax( 10 )

    {

    // From CGfxEdgeListP

    iRenderInfo = aRenderInfo;

    iMinX = KMAXFLOATFIX;

    iMinY = KMAXFLOATFIX;

    iMaxX = KMINFLOATFIX;

    iMaxY = KMINFLOATFIX;

    iEdgesCount = 0;

    iLastSegLenSq = 0xffffffff;

    }

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

// Second phase in constructing this object.

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

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

// void CGfxEdgeListP::ConstructL()

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

void CGfxEdgeListP::ConstructL()

    {

    iPoints = new ( ELeave ) TPoint16[iPointsCountMax];

    iSegset = new ( ELeave ) TSegSet[iSegsetCountMax];

    iEdges = new ( ELeave ) TGfxSegEdge[iEdgesCountMax];

    }

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

// reset

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

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

// void CGfxEdgeListP::Reset()

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

void CGfxEdgeListP::Reset()

    {

    // From CGfxEdgeListP

    iEdgesCount = 0;

    iLastSegLenSq = 0xffffffff;

    iPolygonAreaSize = 0;

    iMinX = KMAXFLOATFIX;

    iMinY = KMAXFLOATFIX;

    iMaxX = KMINFLOATFIX;

    iMaxY = KMINFLOATFIX;

    iPointsCount = 0;

    iSegsetCount = 0;

    iActiveSegList = 0;

    iWaitingSegList = 0;

    iSortedEdges = 0;

    iStartSeg = iSegset;

    iIsNewOutlineStarted = EFalse;

    iSubPathSegmentCount = 0;

    }

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

// void CGfxEdgeListP::AdjustShapeComplexityL( TInt32 aVertexSize )

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

void CGfxEdgeListP::AdjustShapeComplexityL( TInt32 aVertexSize )

    {

    if ( aVertexSize < iPointsCountMax )

        return;

    //

    delete[] iPoints;

    delete[] iSegset;

    delete[] iEdges;

    iPoints = NULL;

    iSegset = NULL;

    iEdges = NULL;

    iPointsCountMax = aVertexSize + 4;

    iSegsetCountMax = aVertexSize;

    iEdgesCountMax = aVertexSize;

    iPoints = new ( ELeave ) TPoint16[iPointsCountMax];

    iSegset = new ( ELeave ) TSegSet[iSegsetCountMax];

    iEdges = new ( ELeave ) TGfxSegEdge[iEdgesCountMax];

    }

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

// void CGfxEdgeListP::StartPoint( TFixPt& aX, TFixPt& aY )

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

void CGfxEdgeListP::StartPoint( TFixPt& aX, TFixPt& aY )

    {

    if ( iPointsCount >= iPointsCountMax - 1 ) // No more segments?

        return;

    // New segment set. Add one point and set flag

    TPoint16& p1 = iPoints[iPointsCount++];

    p1.iX = ( TInt16 ) ( TInt ) aX;

    p1.iY = ( TInt16 ) ( TInt ) aY;

    // Min/Max update

    if ( p1.iY < iMinY )

        iMinY = p1.iY;

    else if ( p1.iY > iMaxY )

        iMaxY = p1.iY;

    if ( p1.iX < iMinX )

        iMinX = p1.iX;

    else if ( p1.iX > iMaxX )

        iMaxX = p1.iX;

    iIsNewOutlineStarted = ETrue;

    iSubPathSegmentCount = 0;

    }

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

// void CGfxEdgeListP::AddPoint( TFixPt& aX, TFixPt& aY, TBool aFillOnly, TBool aClosePath )

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

void CGfxEdgeListP::AddPoint( TFixPt& aX, TFixPt& aY, TBool aFillOnly, TBool aClosePath )

    {

    if ( iPointsCount >= iPointsCountMax - 1 ) // No more segments?

        return;

    TBool newSegsetFlag = EFalse;

    TBool completeSubPathFlag = EFalse;

    if ( iIsNewOutlineStarted )

        {

        CheckAndConnect();

        newSegsetFlag = ETrue;

        }

    else if ( aClosePath && ( iSubPathSegmentCount == 1 ) )

        {

        completeSubPathFlag = ETrue;

        newSegsetFlag = ETrue;

        }

    else

        {

        TInt x = ( TInt ) aX, y = ( TInt ) aY;

        switch ( iSegset[iSegsetCount - 1].AddSegment( x,

                                                       y,

                                                       iLastSegLenSq,

                                                       aClosePath ) )

            {

            case ESegAdd:

                // Add point

                iPointsCount++;

                break;

            case ESegMerge:

                // Do nothing

                break;

            case ESegStartNew:

                newSegsetFlag = ETrue;

                break;

            default:

                return;// ESegIgnore - do nothing

            }

        }

    if ( newSegsetFlag && iSegsetCount < iSegsetCountMax )

        {

        // New segment set. Add two points

        TPoint16* p =& iPoints[iPointsCount++];

        p->iX = ( TInt16 ) ( TInt ) aX;

        p->iY = ( TInt16 ) ( TInt ) aY;

        iSubPathSegmentCount++;

        TSegSet& seg = iSegset[iSegsetCount++];

        seg.Construct( p - 1, p );

        if ( iSegsetCount > 1 )

            iSegset[iSegsetCount - 2].iNext = &seg;

        if ( iIsNewOutlineStarted )

            iStartSeg = &seg;

        if ( completeSubPathFlag )      // (cdm)

            {

            iSegset[iSegsetCount - 1].iSign = -1;

            iSegset[iSegsetCount - 2].iSign = 1;

            iSegset[iSegsetCount - 1].iConnectFlag = EFalse;

            iSegset[iSegsetCount - 2].iConnectFlag = EFalse;

            }

        }

    // Min/Max update

    TPoint16& p = iPoints[iPointsCount - 1];

    if ( p.iY < iMinY )

        iMinY = p.iY;

    else if ( p.iY > iMaxY )

        iMaxY = p.iY;

    if ( p.iX < iMinX )

        iMinX = p.iX;

    else if ( p.iX > iMaxX )

        iMaxX = p.iX;

    if ( aFillOnly )

        {

        iSegset[iSegsetCount - 1].iFillOnlySeg = &iPoints[iPointsCount - 1];

        }

    iIsNewOutlineStarted = EFalse;

    }

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

// void CGfxEdgeListP::SetupEdgeList()

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

void CGfxEdgeListP::SetupEdgeList()

    {

    TInt i;

    //

    CheckAndConnect();

    // Sort waiting list

    TSegSet* segset = iSegset;

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

        {

        if ( segset->iValid )

            {

            InsertToList( ETrue, * segset );

            if ( segset->iActualBottomY < 0 )

                segset->iActualBottomY = segset->iBottomPoint->iY;

            }

        segset++;

        }

    // Normalize x coordinates

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

        {

        iPoints[i].iX = ( TInt16 ) ( iPoints[i].iX - iMinX );

        }

    // Setting up for simple polygon, if applicable

    if ( iSegsetCount < 4 )

        {

        TInt ix = 0;

        segset = iWaitingSegList;

        iSegListForSimple[0] = iSegListForSimple[1] = NULL;     // (cdm).

        while ( segset )

            {

            if ( segset->iTopPoint->iY <= iMinY )

                {

                iSegListForSimple[ix++] = segset;

                segset->InitDDA();

                if ( ix > 2 )

                    break;

                }

            segset = segset->iNext;

            }

        }

    }

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

// void CGfxEdgeListP::UpdateActiveEdge( TInt aY )

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

void CGfxEdgeListP::UpdateActiveEdge( TInt aY )

    {

    // if number of segment is less than 4, it means the polygon is

    // a simple polygon, which we can reduce some processing.

    if ( iSegsetCount < 4 )

        {

        UpdateActiveEdgeSimple( aY );

        return;

        }

    // Remove from active segment list

    while ( iActiveSegList )

        {

        if ( aY <= iActiveSegList->iActualBottomY )

            break;

        iActiveSegList = iActiveSegList->iNext;

        }

    // Add newly activated segment to active segment list

    while ( iWaitingSegList )

        {

        if ( aY < iWaitingSegList->iTopPoint->iY )

            break;

        TSegSet* seg = iWaitingSegList;

        iWaitingSegList = iWaitingSegList->iNext;

        InsertToList( EFalse, * seg );  // add to active list

        seg->InitDDA();

        }

    // Add edges from active segements

    TSegSet* asl = iActiveSegList;

    TGfxSegEdge* edge;

    TInt x1, x2;

    TBool fillOnly;

    iSortedEdges = 0;

    iEdgesCount = 0;

    while ( asl )

        {

        fillOnly = asl->GetEdge( x1, x2 );

        edge = AddEdge( x1, x2 );

        if ( !edge )    // no more edges can be added.

            return;

        edge->iSign = ( TInt16 ) asl->iSign;

        edge->iOnlyForFill = ( TInt16 ) fillOnly;

        asl = asl->iNext;

        }

    }

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

// TGfxSegEdge* CGfxEdgeListP::EdgeList()

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

TGfxSegEdge* CGfxEdgeListP::EdgeList()

    {

    return iSortedEdges;

    }

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

// void CGfxEdgeListP::UpdateActiveEdgeSimple( TInt aY )   // (cdm)

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

void CGfxEdgeListP::UpdateActiveEdgeSimple( TInt aY )   // (cdm)

    {

    // Add edges from active segments

    TGfxSegEdge* edge;

    TInt x01, x02, x11, x12;

    TBool fillOnly0, fillOnly1;

    iEdgesCount = 0;

    if ( iSegListForSimple[0] && iSegListForSimple[1] )

        {

        if ( aY > iSegListForSimple[0]->iActualBottomY ) // (cdm)

            iSegListForSimple[0] = iSegListForSimple[0]->iNext;

        if ( aY > iSegListForSimple[1]->iActualBottomY )

            iSegListForSimple[1] = iSegListForSimple[1]->iNext;

        if ( !iSegListForSimple[0] || !iSegListForSimple[1] )

            return;

        iEdgesCount = 2;

        fillOnly0 = iSegListForSimple[0]->GetEdge( x01, x02 );

        fillOnly1 = iSegListForSimple[1]->GetEdge( x11, x12 );

        if ( x01 < x11 )

            {

            // iSegListForSimple[0] is left

            iSortedEdges = iEdges;

            edge = iSortedEdges;

            edge->iStart = ( TInt16 ) x01;

            edge->iEnd = ( TInt16 ) x02;

            edge->iSign = ( TInt16 ) iSegListForSimple[0]->iSign;

            edge->iOnlyForFill = ( TInt16 ) fillOnly0;

            edge->iNext = iEdges + 1;

            edge = edge->iNext;

            edge->iStart = ( TInt16 ) x11;

            edge->iEnd = ( TInt16 ) x12;

            edge->iSign = ( TInt16 ) iSegListForSimple[1]->iSign;

            edge->iOnlyForFill = ( TInt16 ) fillOnly1;

            edge->iNext = NULL;

            }

        else

            {

            // iSegListForSimple[1] is left

            iSortedEdges = iEdges;

            edge = iSortedEdges;

            edge->iStart = ( TInt16 ) x11;

            edge->iEnd = ( TInt16 ) x12;

            edge->iSign = ( TInt16 ) iSegListForSimple[1]->iSign;

            edge->iOnlyForFill = ( TInt16 ) fillOnly1;

            edge->iNext = iEdges + 1;

            edge = edge->iNext;

            edge->iStart = ( TInt16 ) x01;

            edge->iEnd = ( TInt16 ) x02;

            edge->iSign = ( TInt16 ) iSegListForSimple[0]->iSign;

            edge->iOnlyForFill = ( TInt16 ) fillOnly0;

            edge->iNext = NULL;

            }

        }

    }

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

// void CGfxEdgeListP::InsertToList( TBool aWaitingList, TSegSet& aSegSet )

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

void CGfxEdgeListP::InsertToList( TBool aWaitingList, TSegSet& aSegSet )

    {

    TSegSet** next;

    if ( aWaitingList )

        next = &iWaitingSegList;

    else

        next = &iActiveSegList;

	if(aWaitingList)

	{

		while ( *next )

			{

	            if ( ( *next )->iTopPoint->iY >= aSegSet.iTopPoint->iY )

                break;

		        next = &( ( *next )->iNext );

            }

	}

    else

    {

		while( *next )

			{

            if ( ( *next )->iActualBottomY >= aSegSet.iActualBottomY )

                break;

	        next = &( ( *next )->iNext );

            }

    }

    //

    aSegSet.iNext = *next;

    *next = &aSegSet;

    }

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

// TGfxSegEdge* CGfxEdgeListP::AddEdge( TInt32 aSt, TInt32 aEd )//, TInt aSegSign)

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

TGfxSegEdge* CGfxEdgeListP::AddEdge( TInt32 aSt, TInt32 aEd )//, TInt aSegSign)

{

    if ( iEdgesCount >= iEdgesCountMax - 1 ) // No more edges?

        return NULL;

    TGfxSegEdge& newEdge = iEdges[iEdgesCount++];

    newEdge.iStart = ( TInt16 ) aSt;

    newEdge.iEnd = ( TInt16 ) aEd;

    // Insert this edge in sorted link list

    TGfxSegEdge** next;

    next = &iSortedEdges;

    TInt16 lastEnd = KMINFLOATFIX;

    while ( *next )

        {

        if ( newEdge.iStart < ( *next )->iStart )       // (cdm).

            break;

        lastEnd = ( *next )->iEnd;

        next = &( ( *next )->iNext );

        }

    //

    newEdge.iNext = *next;

    *next = &newEdge;

    return &newEdge;

    }

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

// void CGfxEdgeListP::CheckAndConnect()

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

void CGfxEdgeListP::CheckAndConnect()

    {

    if ( iSegsetCount < 3 )     // (cdm)

        return;