// 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;

 	}