// Copyright (c) 1998-2009 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:

//

#include <gdi.h>

#ifdef __ARMCC__

#pragma arm

#pragma O3

#pragma Otime

#endif

EXPORT_C TLinearDDA::TLinearDDA():

	iCount(0),

	iDifference(),

	iFinish(),

	iGradient(0),

	iInc(),

	iPos(),

	iStart(),

	iBoundingRect(),

	iBoundingRectSet(EFalse),

	iInsideX(EFalse),

	iInsideY(EFalse),

	iStatus(EComplete)

/** Constructs the default linear DDA.

No start or end point is defined for the line. */

	{}

EXPORT_C TLinearDDA::TLinearDDA(const TLinearDDA& aLine):

	iCount(aLine.iCount),

	iDifference(aLine.iDifference),

	iFinish(aLine.iFinish),

	iGradient(aLine.iGradient),

	iInc(aLine.iInc),

	iPos(aLine.iPos),

	iStart(aLine.iStart),

	iBoundingRect(aLine.iBoundingRect),

	iBoundingRectSet(aLine.iBoundingRectSet),

	iInsideX(aLine.iInsideX),

	iInsideY(aLine.iInsideY),

	iStatus(aLine.iStatus)

/** Copy constructs a linear DDA from the specified linear DDA.

@param aLine The linear DDA to be copied. */

	{}

EXPORT_C void TLinearDDA::Construct(const TPoint& aStart,const TPoint& aFinish,TLineMode aMode)

/** Constructs a linear DDA, setting the start and end points of the line.

@param aStart The start point of the line. 

@param aFinish The end point of the line. 

@param aMode The mode of the line; defaults to centred. */

	{

	iStart=aStart;

	iFinish=aFinish;

	iDifference=(iFinish-iStart).AsSize();

	iDifference.iWidth=Abs(iDifference.iWidth);

	iDifference.iHeight=Abs(iDifference.iHeight);

	iInc.iX=(iStart.iX>iFinish.iX)?-1:1;

	iInc.iY=(iStart.iY>iFinish.iY)?-1:1;

	if(iDifference.iWidth)

		iGradient=(iFinish.iY-iStart.iY)/(iFinish.iX-iStart.iX);

	iPos=iStart;

	if(!iGradient)

		iCount=iDifference.iWidth;

	else

		iCount=iDifference.iHeight;

	if(aMode==ECenter)

		iCount>>=1;

	else

		if(iCount)

			iCount--;

	iStatus=EInitialised;

	if(aStart==aFinish)

		iStatus=EComplete;

	iBoundingRectSet=EFalse;

	iInsideX = EFalse;

	iInsideY = EFalse;

	}

EXPORT_C TBool TLinearDDA::SingleStep(TPoint& aPosition)

/** Gets the pixel co-ordinates of the next pixel on the pixel line.

The function is called repeatedly until the whole line has been traversed or, 

if JumpToRect() has been called, until the part of the line inside the rectangle 

has been traversed. Note that, for performance reasons, JumpToRect() may fail 

to detect the intersection of the line with the rectangle accurately and 

SingleStep() may return more points than strictly necessary.

@param aPosition On entry to the first call, this can be a reference to any 

point. On return from the first call, this is the position of the first pixel 

in the line, as specified during construction of this object. On return from 

subsequent calls, this is the position of subsequent pixels in the line, as 

calculated by the function. On return from the final call, this is the position 

of the last pixel in the line, as specified during construction of this object.

@return ETrue, when the position of the last pixel is returned; EFalse, 

otherwise. */

    {

    switch (iStatus)

        {

        case EInitialised:

            aPosition = iStart;

            iStatus = ECurrent;

            return EFalse;

        case ECurrent:

            if (iDifference.iHeight == 0) // horizontal line

                {

                iPos.iX += iInc.iX;

                if (iPos.iX == iFinish.iX)

                    {

                    iStatus = EComplete;

                    }

                }

            else if (iDifference.iWidth == 0) // vertical line

                {

                iPos.iY += iInc.iY;

                if (iPos.iY == iFinish.iY)

                    {

                    iStatus = EComplete;

                    }

                }

            else // diagonal stripes

                {

                if (!iGradient)

                    {

                    iCount -= iDifference.iHeight;

                    iPos.iX += iInc.iX;

                    if (iCount < 0)

                        {

                        iCount += iDifference.iWidth;

                        iPos.iY += iInc.iY;

                        }

                    }

                else

                    {

                    iCount -= iDifference.iWidth;

                    iPos.iY += iInc.iY;

                    if (iCount < 0)

                        {

                        iCount += iDifference.iHeight;

                        iPos.iX += iInc.iX;

                        }

                    }

                if ((iPos.iX == iFinish.iX) && (iPos.iY == iFinish.iY))

                    {

                    iStatus = EComplete;

                    }

                }

            // common

            aPosition = iPos;

            if (iStatus == EComplete)

                {

                return ETrue;

                }

            if(iBoundingRectSet)

                {

                if (iPos.iX >= iBoundingRect.iTl.iX && iPos.iX < iBoundingRect.iBr.iX)

                    iInsideX = ETrue;

                else

                    if (iInsideX)

                        {

                        iStatus=EComplete;

                        return(ETrue);

                        }

                if (iPos.iY >= iBoundingRect.iTl.iY && iPos.iY < iBoundingRect.iBr.iY)

                    iInsideY = ETrue;

                else

                    if (iInsideY)

                        {

                        iStatus=EComplete;

                        return(ETrue);

                        }

                }

            return EFalse;

        default:

            aPosition = iFinish;

            return ETrue;

        }

    }

EXPORT_C TBool TLinearDDA::NextStep(TPoint& aPosition)

/** Gets the pixel co-ordinates of the start of the next scan line.

The best line that joins the start and end points is formed from all the scan 

lines returned by this function.

The function is called repeatedly until the start position of all scanlines 

has been returned.

The start and end points passed to the constructor of this object define the 

boundaries of the line. Successive scan lines move from the start point to 

the end point.

@param aPosition On entry to the first call, this can be a reference to any 

point. On return from the first call, this is the position of the pixel that 

defines the leftmost position of the first scan line. On return from subsequent 

calls, this is the position of the pixel that defines the leftmost position 

of the next scan line. On return from the final call, this is the position 

of the last pixel in the line, as specified during construction. 

@return ETrue, when the position of the last pixel is returned; EFalse, 

otherwise. */

    {

    if (!iDifference.iHeight) // horizontal line

        {

        iPos = iFinish;

        iStatus = EComplete;

        aPosition = iFinish;

        return ETrue;

        }

    if (!iDifference.iWidth || iGradient || (iStatus != ECurrent))

        {

        return SingleStep(aPosition);

        }

    // !iGradient && (iStatus != EInitialised)

    if(iBoundingRectSet)

        { // slower version

        while ((iCount - iDifference.iHeight) >= 0)

            {

            if (SingleStep(aPosition))

                return ETrue;

            }

        return SingleStep(aPosition);

        }

    // faster version avoids function calls

    TBool lastLoop = EFalse;

    do {

        if ((iCount - iDifference.iHeight) < 0)

            {

            lastLoop = ETrue;

            }

        iCount -= iDifference.iHeight;

        iPos.iX += iInc.iX;

        if (iCount < 0)

            {

            iCount += iDifference.iWidth;

            iPos.iY += iInc.iY;

            }

        if ((iPos.iX == iFinish.iX) && (iPos.iY == iFinish.iY))

            {

            aPosition = iFinish;

            iStatus = EComplete;

            return ETrue;

            }

        }

        while (!lastLoop);

    aPosition = iPos;

    return EFalse;

    }

EXPORT_C TBool TLinearDDA::SingleScanline(TPoint& aStartPosition,TPoint& aEndPosition)

/** Gets the start and end pixel co-ordinates that define the next scan line.

The best line that joins the start and end points is formed from all the scan 

lines returned by this function.

The function is called repeatedly until the position of all scanlines has 

been returned.

The start and end points passed to the constructor of this object define the 

boundaries of the line. Successive scan lines move from the start point to 

the end point.

@param aStartPosition On entry to the first call, this can be a reference 

to any point. On return from the first call, this is the position of the pixel 

that defines the leftmost position of the first scan line. On return from 

subsequent calls, this is the position of the pixel that defines the leftmost 

position of the next scan line. On return from the final call, either this 

or aEndPosition is set to the end point, as specified during construction.

@param aEndPosition On entry to the first call, this can be a reference to 

any point. On return from the first call, this is the position of the pixel 

that defines the rightmost position of the first scan line. On return from 

subsequent calls, this is the position of the pixel that defines the rightmost 

position of the next scan line. On return from the final call, either this 

or aStartPosition is set to the end point, as specified during construction.

@return ETrue, when the position of the last scan line includes the end point; 

EFalse, otherwise. */

    {

    TBool done=EFalse;

    if(iDifference.iHeight==0)

        {

        aStartPosition=iStart;

        aEndPosition=iFinish;

        return(ETrue);

        }

    if(iDifference.iWidth==0 || iGradient)

        {

        done=SingleStep(aStartPosition);

        aEndPosition=aStartPosition;

        return(done);

        }

    // !iGradient

    done=SingleStep(aStartPosition);

    aEndPosition=aStartPosition;

    while(iCount-iDifference.iHeight>=0 && !done)

        {

        iCount -= iDifference.iHeight;

        iPos.iX += iInc.iX;

        if (iCount < 0)

            {

            iCount += iDifference.iWidth;

            iPos.iY += iInc.iY;

            }

        if ((iPos.iX == iFinish.iX) && (iPos.iY == iFinish.iY))

            {

            iStatus = EComplete;

            done = ETrue;

            }

        }

    aEndPosition = iPos;

    return done;

    }

EXPORT_C void TLinearDDA::JumpToRect(const TRect& aRect)

/** Jumps to start of a clipping rectangle.

This will accelerate the linear DDA to the vicinity of the specified rectangle. 

It is NOT guaranteed to reach the rectangle, but will reduce co-ordinates 

that are 1000's out to co-ordinates that are 10's out. Because of this, failure 

to intersect the rectangle may not be detected. If it is, or the line has 

not been constructed or has been run to completion, then a subsequent call 

to the stepping functions returns ETrue.

@param aRect The rectangle to be jumped to. */

	{

	if(aRect.IsEmpty() || iStatus!=EInitialised) return;

	iBoundingRect=aRect;

	iBoundingRectSet=ETrue;

	TInt nearestx = 0;

	if (iStart.iX < aRect.iTl.iX)

		nearestx = aRect.iTl.iX;

	else if (iStart.iX >= aRect.iBr.iX)

		nearestx = aRect.iBr.iX;

	else

		iInsideX = ETrue;

	TInt nearesty = 0;

	if (iStart.iY < aRect.iTl.iY)

		nearesty = aRect.iTl.iY;

	else if (iStart.iY >= aRect.iBr.iY)

		nearesty = aRect.iBr.iY;

	else

		iInsideY = ETrue;

	if (iInsideX && iInsideY)

		return;

	TInt dummy;

	if(!iGradient)

		{

		if (iInsideX)

			return;

		JumpToXCoord(nearestx,dummy);

		}

	else

		{

		if (iInsideY)

			return;

		JumpToYCoord(dummy,nearesty);

		}

	}

EXPORT_C void TLinearDDA::JumpToXCoord(const TInt aXCoord,TInt& aYCoord)

/** Jumps to x co-ordinate.

The other co-ordinate of the intersection is returned through a reference 

argument. After a jump call, the line is ready to continue through calls to 

the stepping functions.

This function accelerates the Linear DDA stepping functions (e.g. SingleStep()) 

making them return EFalse when they reach the specified co-ordinate. If the 

line does not cross the co-ordinate, has not been constructed, has been run 

to completion or the intersection is the end point of the line then the stepping 

functions will return ETrue.

@param aXCoord x co-ordinate to jump to 

@param aYCoord On return, this parameter holds the y co-ordinate which corresponds 

to the specified x co-ordinate */

	{

	if(iStatus==EComplete) return; // not constructed

	if((iStart.iX<aXCoord && iFinish.iX<aXCoord) || (iStart.iX>aXCoord && iFinish.iX>aXCoord))

		return; // no intersection

	aYCoord=iStart.iY;

	if(iStart.iX==aXCoord) return; // trivial first intersection

	iStatus=ECurrent;

	if(iDifference.iHeight==0) // horizontal line

		iPos.iX=aXCoord;

	else

		{

		if(!iGradient)

			{

			TInt64 numsteps=Abs(aXCoord-iPos.iX);

			TInt64 tempcount=TInt64(iCount)-(TInt64(iDifference.iHeight)*numsteps);

			numsteps=Abs(tempcount/iDifference.iWidth);

			tempcount+=numsteps*iDifference.iWidth;

			while(tempcount<0)

				{

				tempcount+=iDifference.iWidth;

				numsteps++;

				}

			iCount = I64INT(tempcount);

			iPos.iY += (iInc.iY * I64INT(numsteps));

			iPos.iX=aXCoord;

			aYCoord=iPos.iY;

			}

		else

			{

			while(iPos.iX!=aXCoord)

				{

				iCount-=iDifference.iWidth;

				if(iCount<0)

					{

					iCount+=iDifference.iHeight;

					iPos.iX+=iInc.iX;

					}

				iPos.iY+=iInc.iY;

				}

			aYCoord=iPos.iY;

			}

		}

    if ((iPos.iX == iFinish.iX) && (iPos.iY == iFinish.iY))

        {

        iStatus=EComplete;

        }

	}

EXPORT_C void TLinearDDA::JumpToYCoord(TInt& aXCoord,const TInt aYCoord)

/** Jumps to a y co-ordinate.

The other co-ordinate of the intersection is returned through a reference 

argument. After a jump call, the line is ready to continue through calls to 

the stepping functions.

This function accelerates the Linear DDA stepping functions (e.g. SingleStep()) 

making them return EFalse when they reach the specified co-ordinate. If the 

line does not cross the co-ordinate, has not been constructed, has been run 

to completion or the intersection is the end point of the line then they will 

return ETrue. 

@param aXCoord On return, this parameter holds the x co-ordinate which corresponds 

to the specified y co-ordinate. 

@param aYCoord y co-ordinate to jump to */

	{

	if(iStatus==EComplete) return; // not constructed

	if((iStart.iY<aYCoord && iFinish.iY<aYCoord) || (iStart.iY>aYCoord && iFinish.iY>aYCoord))

		return; // no intersection

	aXCoord=iStart.iX;

	if(iStart.iY==aYCoord) return; // trivial first intersection

	iStatus=ECurrent;

	if(iDifference.iWidth==0) // vertical line

		iPos.iY=aYCoord;

	else

		{

		if(!iGradient)

			{

			while(iPos.iY!=aYCoord)

				{

				iCount-=iDifference.iHeight;

				if(iCount<0)

					{

					iCount+=iDifference.iWidth;

					iPos.iY+=iInc.iY;

					}

				iPos.iX+=iInc.iX;

				}

			aXCoord=iPos.iX;

			}

		else

			{

			TInt64 numsteps=Abs(aYCoord-iPos.iY);

			TInt64 tempcount=TInt64(iCount)-(TInt64(iDifference.iWidth)*numsteps);

			numsteps=Abs(tempcount/iDifference.iHeight);

			tempcount+=numsteps*iDifference.iHeight;

			while (tempcount<0)

				{

				tempcount+=iDifference.iHeight;

				numsteps++;

				}

			iCount = I64INT(tempcount);

			iPos.iX += (iInc.iX * I64INT(numsteps));

			iPos.iY=aYCoord;

			aXCoord=iPos.iX;

			}

		}

    if ((iPos.iX == iFinish.iX) && (iPos.iY == iFinish.iY))

        {

        iStatus=EComplete;

        }

	}

void TLinearDDA::UpdatePosition()

	{

	}

EXPORT_C void TLinearDDA::JumpToXCoord2(TInt aXCoord,TInt& aYCoord)

/**

Jumps to x co-ordinate.

This works in the same way as TLinearDDA::JumpToXCoord except that it make sure

that using the NextStep function does not return the same value twice.

@param aXCoord x co-ordinate to jump to

@param aYCoord On return, this parameter holds the y co-ordinate which corresponds

to the specified x co-ordinate

@see TLinearDDA::JumpToXCoord(TInt, TInt&)

*/

	{

	JumpToXCoord(aXCoord,aYCoord);

	iStatus=ECurrent;

	}

EXPORT_C void TLinearDDA::JumpToYCoord2(TInt& aXCoord,TInt aYCoord)

/**

Jumps to a y co-ordinate.

This works in the same way as TLinearDDA::JumpToYCoord except that it make sure

that using the NextStep function does not return the same value twice.

@param aXCoord On return, this parameter holds the x co-ordinate which corresponds

to the specified y co-ordinate.

@param aYCoord y co-ordinate to jump to

@see TLinearDDA::JumpToYCoord(TInt&, TInt)

*/ 

	{

	JumpToYCoord(aXCoord,aYCoord);

	iStatus=ECurrent;

	}