// Copyright (c) 1997-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 <bitstd.h>
#include <bitdev.h>
#include "BITPANIC.H"
#include <bitdraw.h>
#include <graphics/fbsrasterizer.h>

/*
 * TEllipse
 */
 
 /**
 Initialises the values of the ellipse so that it conforms to a rectangle entered as a parameter.
 @param aRect the rectangle within which the ellipse is drawn
 */
EXPORT_C void TEllipse::Construct(const TRect& aRect)
	{
	TInt width=aRect.Width();
	TInt height=aRect.Height();
	iA=(width-1)>>1;
	iB=(height-1)>>1;
	iXAdj=(width+1)&1;
	iYAdj=(height+1)&1;
	iOffset=aRect.iTl;
	iX=0;
	iY=iB;
	iASquared=iA*iA;
	iBSquared=iB*iB;
	iASquBSqu=iASquared*iBSquared;
	iD1=iBSquared-iASquared*iB+(iASquared>>1);
	if(width<=0 || height<=0)
		iStatus=EComplete;
	else if(width<=2 || height<=2)
		iStatus=ELine;
	else if(iA+iXAdj==0 || iB+iYAdj==0)
		iStatus=EComplete;
	else
		iStatus=EInitialised;
	}

/**
Does the next stage in producing an ellipse by taking four points (the corners of 
the rectangle the ellipse should fill) as parameters. Updates TEllipse status 
accordingly and calls <code>Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight)</code>.
@param aTopLeft Top left corner of rectangle 
@param aTopRight Top right corner of rectangle
@param aBottomLeft Bottom left corner of rectangle
@param aBottomRight Bottom right corner of rectangle
@return TBool ETrue if step completed successfully.
*/
EXPORT_C TBool TEllipse::SingleStep(TPoint& aTopLeft,TPoint& aTopRight,
									TPoint& aBottomLeft,TPoint& aBottomRight)
	{
	TBool ret=EFalse;
	if(iStatus==EFirstSector)
		{
		if(iD1<0)
			iD1+=iBSquared*((iX<<1)+3);
		else if(iY>0)
			{
			iD1+=iBSquared*((iX<<1)+3)+iASquared*(2-(iY<<1));
			iY--;
			}
		iX++;
		ret=Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight);
		if(iStatus==EComplete && iX<iA)
			{
			iStatus=EFirstSector;
			return(EFalse);
			}
		if(iASquared*iY<=iBSquared*(iX+1) && ret==EFalse)
			{
			iStatus=ESecondSector;
			iD2=-iASquBSqu+iBSquared*iX*iX+iASquared*(iY-1)*(iY-1);
			}
		return(ret);
		}
	if(iStatus==ESecondSector)
		{
		if(iD2<0)
			{
			iD2+=iBSquared*((iX<<1)+2)+iASquared*(3-(iY<<1));
			iX++;
			}
		else
			iD2+=iASquared*(3-(iY<<1));
		iY--;
		return(Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight));
		}
	if(iStatus==ELine)
		{
		ret=Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight);
		if(iA==0)
			iY--;
		else
			{
			iX++;
			if(iX>iA+iXAdj) ret=ETrue;
			else
				{
				iStatus=ELine;
				ret=EFalse;
				}
			}
		return(ret);
		}
	if(iStatus==EInitialised)
		{
		iStatus=EFirstSector;
		return(Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight));
		}
	Output(aTopLeft,aTopRight,aBottomLeft,aBottomRight);
	return(ETrue);
	}

/**
Sets the absolute points that define the ellipse as calculated using its iOffset 
from the origin and using the half width and half height of the rectangle iA and iB.
@param aTopLeft The absolute (x,y) position for the top left point.
@param aTopRight The absolute (x,y) position for the top right point.
@param aBottomLeft The absolute (x,y) position for the bottom left point.
@param aBottomRight The absolute (x,y) position for the bottom right point.
@return TBool ETrue if a valid rectangle is produced, else EFalse. Also sets
iStatus to EComplete.
*/
EXPORT_C TBool TEllipse::Output(TPoint& aTopLeft,TPoint& aTopRight,
								TPoint& aBottomLeft,TPoint& aBottomRight)
	{
	TInt lx=iA-iX+iOffset.iX;
	TInt ty=iB-iY+iOffset.iY;
	TInt rx=iA+iX+iXAdj+iOffset.iX;
	TInt by=iB+iY+iYAdj+iOffset.iY;
	aTopLeft.SetXY(lx,ty);
	aTopRight.SetXY(rx,ty);
	aBottomLeft.SetXY(lx,by);
	aBottomRight.SetXY(rx,by);
	if(iY<=0)
		{
		iStatus=EComplete;
		if(iYAdj==0 || ty>by)
			return(ETrue);
		}
	return(EFalse);
	}

/**
By analysing the current state of the ellipse the process is taken to the next appropriate step.
If iStatus = EInitialised only one step will be taken, if the ellipse is already semi constructed then 
it will be taken to completion. Takes in four point parameters that defines the rectangle in order to pass to 
SingleStep(aTopLeft,aTopRight,aBottomLeft,aBottomRight).
@param aTopLeft Top left corner of rectangle 
@param aTopRight Top right corner of rectangle
@param aBottomLeft Bottom left corner of rectangle
@param aBottomRight Bottom right corner of rectangle
@return TBool ETrue if a valid rectangle is produced, else EFalse.
*/
EXPORT_C TBool TEllipse::NextStep(TPoint& aTopLeft,TPoint& aTopRight,
								  TPoint& aBottomLeft,TPoint& aBottomRight)
	{
	if(iStatus==EInitialised)
		return(SingleStep(aTopLeft,aTopRight,aBottomLeft,aBottomRight));
	TInt prevlev=iY;
	TBool ret;
	do
		ret=SingleStep(aTopLeft,aTopRight,aBottomLeft,aBottomRight);
	while(prevlev==iY && ret==EFalse);
	return(ret);
	}

/**
Constructs an ellipse from the rectangle which it is given and assesses the 
points position with regard to the ellipse and where they intersect. 
@param aRect The rectangle within which the ellipse is drawn.
@param aPoint A point to compare with the ellipse to determine if intersection occurs. 
@return TPoint The point is set to the corner which the intersection is nearest to.
*/
EXPORT_C TPoint TEllipse::Intersection(const TRect& aRect,const TPoint& aPoint)
	{
	Construct(aRect);					//constructs the rect (an elipse object)
	TPoint centre=aRect.Center();		//centre of ellipse
	TPoint ptcpy(aPoint);				
	ptcpy-=iOffset;						//ptcpy = aPoint - iOffset - TPoint(iA,iB)	//radius from centre of ellipse		
	ptcpy-=TPoint(iA,iB);				
	TPoint pt[4],opt[4];			
	TInt mpt[4],ompt[4];
	TInt count=0;
	for(;count<4;count++)
		ompt[count]=KMaxTInt;			//fills ompt 1->4 with KMaxTInt
	while(SingleStep(pt[0],pt[1],pt[2],pt[3])==EFalse) 	//creates a complete ellipse with pts as rect
		for(count=0;count<4;count++)
			{
			mpt[count]=Abs((pt[count].iY-iOffset.iY-iB)*(ptcpy.iX)-(ptcpy.iY)*(pt[count].iX-iOffset.iX-iA));
			if(mpt[count]<ompt[count]) //use the larger number set.
				{
				ompt[count]=mpt[count];
				opt[count]=pt[count];
				}						
			}
	if(pt[0].iY==pt[2].iY)	//if it is horizontal
		for(count=0;count<4;count++)
			{
			mpt[count]=Abs((pt[count].iY-iOffset.iY-iB)*(ptcpy.iX)-(ptcpy.iY)*(pt[count].iX-iOffset.iX-iA));
			if(mpt[count]<ompt[count]) //use the larger number set.
				{
				ompt[count]=mpt[count];
				opt[count]=pt[count];
				}
			}
	if(ptcpy.iX<0 && ptcpy.iY<0)	//if point is further left and higher than centre of rect
		return(opt[0]);
	if(ptcpy.iY<0)			//if point is higher than centre of rect
		return(opt[1]);
	if(ptcpy.iX<0)			//if point is further left than centre of rect
		return(opt[2]);
	if(aPoint.iX<centre.iX && aPoint.iY<centre.iY)	//if point is further left and higher than centre of rect
		return(opt[0]);
	if(aPoint.iY<centre.iY)	//if point is higher than centre of rect
		return(opt[1]);
	if(aPoint.iX<centre.iX)	//if point is further left than centre of rect
		return(opt[2]);
	return(opt[3]);			//else 
	}

//
// Ellipse drawing
//

/**
Draws and fills an ellipse.

The function provides a concrete implementation of the pure virtual
function <code>CGraphicsContext::DrawEllipse()</code>. The function
behaviour is the same as documented in that class.
*/
EXPORT_C void CFbsBitGc::DrawEllipse(const TRect& aRect)
	{
	if(CheckDevice(aRect)) return;
	TRect rcpy(aRect);
	rcpy.Move(iOrigin);
	iDevice->TruncateRect(rcpy);
	TRect clippedRect(rcpy);
	clippedRect.Grow((iPenSize.iWidth>>1)+1,(iPenSize.iHeight>>1)+1);
	if(UserClipRect(clippedRect)) return;
	SetupDevice();
	iDevice->DrawingBegin(&iBrushBitmap);
	CFbsRasterizer* brushRasterizer = PrepareRasterizerForExtendedBitmap(iBrushBitmap);
	if(iBrushStyle!=ENullBrush)
		EllipseFill(rcpy);
	if(iPenStyle!=ENullPen)
		{
		if(iPenSize.iWidth>1 && iPenSize.iHeight>1)
			EllipseOutlineWide(rcpy);
		else
			if(iPenSize.iWidth==1 || iPenSize.iHeight==1)
				EllipseOutline(rcpy);
		}
	if (brushRasterizer)
		{
		brushRasterizer->EndBitmap(iBrushBitmap.SerialNumber());
		}
	iDevice->DrawingEnd(&iBrushBitmap);
	}

void CFbsBitGc::EllipseOutline(const TRect& aRect)
	{
	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;
	TPoint tl,tr,bl,br;
	AddRect(aRect);
#if defined(_DEBUG)
	TRect deviceDestRect;
	drawDevice->GetDrawRect(deviceDestRect);
#endif
	for(TInt count=0;count<iDefaultRegionPtr->Count();count++)
		{
		iClipRect=(*iDefaultRegionPtr)[count];
		if(!iClipRect.Intersects(aRect))
			continue;
		iClipRect.Intersection(aRect);
		if(UserClipRect(iClipRect)) continue;
		BG_ASSERT_DEBUG(iClipRect.iTl.iX >= deviceDestRect.iTl.iX, EBitgdiPanicOutOfBounds);
		BG_ASSERT_DEBUG(iClipRect.iTl.iY >= deviceDestRect.iTl.iY, EBitgdiPanicOutOfBounds);
		BG_ASSERT_DEBUG(iClipRect.iBr.iX <= deviceDestRect.iBr.iX, EBitgdiPanicOutOfBounds);
		BG_ASSERT_DEBUG(iClipRect.iBr.iY <= deviceDestRect.iBr.iY, EBitgdiPanicOutOfBounds);
		TEllipse ellipse;
		ellipse.Construct(aRect);
		TInt pattern=0;
		while(!ellipse.SingleStep(tl,tr,bl,br))
			{
			if(iPenStyle==CGraphicsContext::ESolidPen || (iDotMask&(1<<(pattern%iDotLength))))
				{
				if(tl.iY>=iClipRect.iTl.iY && tl.iY<iClipRect.iBr.iY)
					{
					if(tl.iX>=iClipRect.iTl.iX && tl.iX<iClipRect.iBr.iX)
						drawDevice->WriteRgb(tl.iX,tl.iY,iPenColor,iDrawMode);
					if(tr.iX>=iClipRect.iTl.iX && tr.iX<iClipRect.iBr.iX && tl.iX!=tr.iX)
						drawDevice->WriteRgb(tr.iX,tr.iY,iPenColor,iDrawMode);
					}
				if(bl.iY>=iClipRect.iTl.iY && bl.iY<iClipRect.iBr.iY)
					{
					if(bl.iX>=iClipRect.iTl.iX && bl.iX<iClipRect.iBr.iX)
						drawDevice->WriteRgb(bl.iX,bl.iY,iPenColor,iDrawMode);
					if(br.iX>=iClipRect.iTl.iX && br.iX<iClipRect.iBr.iX && bl.iX!=br.iX)
						drawDevice->WriteRgb(br.iX,br.iY,iPenColor,iDrawMode);
					}
				}
			pattern++;
			}
		if(tl.iY==bl.iY && tl.iY>=iClipRect.iTl.iY && tl.iY<iClipRect.iBr.iY)
			{
			if(tl.iX>=iClipRect.iTl.iX && tl.iX<iClipRect.iBr.iX)
				drawDevice->WriteRgb(tl.iX,tl.iY,iPenColor,iDrawMode);
			if(tr.iX>=iClipRect.iTl.iX && tr.iX<iClipRect.iBr.iX && tl.iX!=tr.iX)
				drawDevice->WriteRgb(tr.iX,tr.iY,iPenColor,iDrawMode);
			}
		drawDevice->UpdateRegion(iClipRect);
		}
	}

void CFbsBitGc::EllipseOutlineWide(const TRect& aRect)
	{
	TRect rcpy(aRect);
	TPoint tl,tr,bl,br;
	TInt halfpenwidth=(iPenSize.iWidth+1)>>1;
	TInt halfpenheight=(iPenSize.iHeight+1)>>1;
	rcpy.Grow(halfpenwidth,halfpenheight);
	AddRect(rcpy);
	TInt dp=iDotParam;
	for(TInt count=0;count<iDefaultRegionPtr->Count();count++)
		{
		iClipRect=(*iDefaultRegionPtr)[count];
		if(!iClipRect.Intersects(rcpy))
			continue;
		iClipRect.Intersection(rcpy);
		if(UserClipRect(iClipRect)) continue;
		TEllipse ellipse;
		ellipse.Construct(aRect);
		iDotParam=Max(iPenSize.iWidth>>1,iPenSize.iHeight>>1);
		while(!ellipse.SingleStep(tl,tr,bl,br))
			{
			PenDrawClipped(tl);
			PenDrawClipped(tr);
			PenDrawClipped(bl);
			PenDrawClipped(br);
			iDotParam+=iDotDirection;
			}
		if(tl.iY==bl.iY)
			{
			PenDrawClipped(tl);
			PenDrawClipped(tr);
			}
		iDevice->iDrawDevice->UpdateRegion(iClipRect);
		}
	iDotParam=dp;
	}

// if iBrushBitmap is an extended bitmap, PrepareRasterizerForExtendedBitmap() must have been called before this method
void CFbsBitGc::EllipseFill(const TRect& aRect)
	{
	TRect rcpy(aRect);
	if(iPenSize.iWidth==0 || iPenSize.iHeight==0)
		rcpy.Grow(1,1);
	AddRect(aRect);
	TPoint tl,tr,bl,br;
	for(TInt count=0;count<iDefaultRegionPtr->Count();count++)
		{
		iClipRect=(*iDefaultRegionPtr)[count];
		if(!iClipRect.Intersects(rcpy))
			continue;
		iClipRect.Intersection(rcpy);
		if(UserClipRect(iClipRect)) continue;
		TEllipse ellipse;
		ellipse.Construct(rcpy);
		while(!ellipse.NextStep(tl,tr,bl,br))
			{
			tl.iX++;
			tr.iX--;
			bl.iX++;
			br.iX--;
			ClipFillLine(tl,tr);
			ClipFillLine(bl,br);
			}
		if(tl.iY==bl.iY)
			{
			tl.iX++;
			tr.iX--;
			ClipFillLine(tl,tr);
			}
		iDevice->iDrawDevice->UpdateRegion(iClipRect);
		}
	}