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

 #include "bitgcextradata.h"

 /**  Draws a straight line between two points.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsContext::DrawLine(). The function

 behaviour is the same as documented in that class. */	

 EXPORT_C void CFbsBitGc::DrawLine(const TPoint& aPt1,const TPoint& aPt2)

     {

 	CheckDevice();

 	TRect lineBoundingRect(aPt1,aPt2);

 	lineBoundingRect.Normalize();

 	lineBoundingRect.Move(iOrigin);

 	lineBoundingRect.Grow((iPenSize.iWidth >> 1) + 1,(iPenSize.iHeight >> 1) + 1);

 	if(!lineBoundingRect.Intersects(iUserClipRect))

 		{

 		iLinePosition = aPt2;// if DrawLine returns due to aPt2 being outside of the clipping rect then subsequent line are drawn from correct point.

 		return;

 		}

 	SetupDevice();

 	iDevice->DrawingBegin();

 	DoDrawLine(aPt1,aPt2,ETrue);

 	iDevice->DrawingEnd();

 	}

 /** Draws a straight line from the current drawing point to a specified

 point.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsContext::DrawLineTo(). The function

 behaviour is the same as documented in that class. */

 EXPORT_C void CFbsBitGc::DrawLineTo(const TPoint& aPoint)

 	{

 	DrawLine(iLinePosition,aPoint);

 	}

 /** Draws a straight line relative to the current drawing point, using a

 vector.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsContext::DrawLineBy(). The function

 behaviour is the same as documented in that class. */	

 EXPORT_C void CFbsBitGc::DrawLineBy(const TPoint& aVector)

     {

 	DrawLine(iLinePosition,iLinePosition + aVector);

 	}

 /** Draws a polyline from a set of points specified in a list.

 The functions provides a concrete implementation of the pure virtual

 functions CGraphicsContext::DrawPolyLine(). The function

 behaviour is the same as documented in that class. */

 EXPORT_C void CFbsBitGc::DrawPolyLine(const CArrayFix<TPoint>* aPointList)

 	{

 	if(!aPointList || iPenSize.iWidth < 1 || iPenSize.iHeight < 1)

 		return;

 	const TInt vertexes = aPointList->Count()-1;

 	for (TInt count = 0; count < vertexes; count++)

 		DrawLine((*aPointList)[count],(*aPointList)[count + 1]);

 	if (iPenStyle == CGraphicsContext::ESolidPen && vertexes >= 0)

 		Plot((*aPointList)[vertexes]);

 	}

 /** Draws a polyline from a set of points specified in an array, but does not draw 

 the final point of the last line.

 @param aPointList An array containing the points on the polyline. */

 EXPORT_C void CFbsBitGc::DrawPolyLineNoEndPoint(const CArrayFix<TPoint>* aPointList)

 	{

 	if(!aPointList || iPenSize.iWidth < 1 || iPenSize.iHeight < 1)

 		return;

 	const TInt vertexes = aPointList->Count() - 1;

 	for (TInt count = 0; count < vertexes; count++)

 		DrawLine((*aPointList)[count],(*aPointList)[count + 1]);

 	}

 /** Draws a polyline from a set of points specified in a list.

 The functions provides a concrete implementation of the pure virtual

 functions CGraphicsContext::DrawPolyLine(). The function

 behaviour is the same as documented in that class. */

 EXPORT_C void CFbsBitGc::DrawPolyLine(const TPoint* aPointList,TInt aNumPoints)

 	{

     DrawPolyLineNoEndPoint(aPointList,aNumPoints);

 	if (iPenStyle == CGraphicsContext::ESolidPen)

 		Plot(aPointList[aNumPoints - 1]);

 	}

 /** Draws a polyline from a set of points specified in a list, but does not 

 draw the final point of the last line.

 @param aPointList Pointer to a set of points on the polyline. 

 @param aNumPoints Number of points in the list. */

 EXPORT_C void CFbsBitGc::DrawPolyLineNoEndPoint(const TPoint* aPointList,TInt aNumPoints)

 	{

 	if (!aPointList || iPenSize.iWidth < 1 || iPenSize.iHeight < 1)

 		return;

 	const TInt vertexes = aNumPoints - 1;

 	for (TInt count = 0; count < vertexes; count++)

 		DrawLine(aPointList[count],aPointList[count + 1]);

 	}

 /** Draws and fills a polygon defined using a list of points.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsContext::DrawPolygon(). The function

 behaviour is the same as documented in that class. */

 EXPORT_C TInt CFbsBitGc::DrawPolygon(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule)

 	{

 	CheckDevice();

 	if (!aPointList)

 		return KErrArgument;

 	const TInt numpoints = aPointList->Count();

 	if (numpoints == 0)

 		return KErrNone; // Nothing to do!

 	SetupDevice();

 	iDevice->DrawingBegin(&iBrushBitmap);

 	CFbsRasterizer* brushRasterizer = PrepareRasterizerForExtendedBitmap(iBrushBitmap);

 	if (iBrushStyle != ENullBrush)

 		{

 		TRect pointrect(0,0,0,0);

 		TRect truncrect(0,0,0,0);

 		TBool largepolygon = EFalse;

 		for (TInt count = 0; count < numpoints; count++)

 			{

 			pointrect.iTl = (*aPointList)[count] + iOrigin;

 			truncrect.iTl = pointrect.iTl;

 			iDevice->TruncateRect(truncrect);

 			if (pointrect.iTl != truncrect.iTl)

 				{

 				largepolygon = ETrue;

 				break;

 				}

 			}

 		if (largepolygon)

 			PolyFillLarge(aPointList,aFillRule);

 		else

 			PolyFill(aPointList,aFillRule);

 		}

 	if (iPenStyle != ENullPen)

 		if (iPenSize.iWidth > 0 && iPenSize.iHeight > 0)

 			PolyOutline(aPointList);

 	if (brushRasterizer)

 		{

 		brushRasterizer->EndBitmap(iBrushBitmap.SerialNumber());

 		}

 	iDevice->DrawingEnd(&iBrushBitmap);

 	return KErrNone;

 	}

 /** Draws and fills a polygon defined using a list of points.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsContext::DrawPolygon(). The function

 behaviour is the same as documented in that class. */	

 EXPORT_C TInt CFbsBitGc::DrawPolygon(const TPoint* aPointList,

 									 TInt aNumPoints,

 									 CGraphicsContext::TFillRule aFillRule)

     {

 	CheckDevice();

 	if (!aPointList || aNumPoints < 0)

 		return KErrArgument;

 	if (aNumPoints == 0)

 		return KErrNone; // Nothing to do!

 	SetupDevice();

 	iDevice->DrawingBegin(&iBrushBitmap);

 	CFbsRasterizer* brushRasterizer = PrepareRasterizerForExtendedBitmap(iBrushBitmap);

 	if (iBrushStyle != ENullBrush)

 		{

 		TRect pointrect(0,0,0,0);

 		TRect truncrect(0,0,0,0);

 		TBool largepolygon = EFalse;

 		for (TInt count = 0; count < aNumPoints; count++)

 			{

 			pointrect.iTl = aPointList[count] + iOrigin;

 			truncrect.iTl = pointrect.iTl;

 			iDevice->TruncateRect(truncrect);

 			if (pointrect.iTl != truncrect.iTl)

 				{

 				largepolygon = ETrue;

 				break;

 				}

 			}

 		if (largepolygon)

 			PolyFillLarge(aPointList,aNumPoints,aFillRule);

 		else

 			PolyFill(aPointList,aNumPoints,aFillRule);

 		}

 	if (iPenStyle != ENullPen && iPenSize.iWidth > 0 && iPenSize.iHeight > 0)

 		PolyOutline(aPointList,aNumPoints);

 	if (brushRasterizer)

 		{

 		brushRasterizer->EndBitmap(iBrushBitmap.SerialNumber());

 		}

 	iDevice->DrawingEnd(&iBrushBitmap);

 	return KErrNone;

 	}

 void CFbsBitGc::DoDrawLine(TPoint aPt1,TPoint aPt2,TBool aDrawStartPoint)

 	{

 	iLinePosition = aPt2;

 	if (aPt1 == aPt2 || iPenStyle == ENullPen || !iPenSize.iWidth || !iPenSize.iHeight)

 		return;

 	aPt1 += iOrigin;

 	aPt2 += iOrigin;

 	TRect temp(aPt1,aPt2);

 	temp.Normalize();

 	temp.Grow(iPenSize.iWidth,iPenSize.iHeight);

 	AddRect(temp);

 	if (UserClipRect(temp))

 		return;

 	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

 	TRect screenRect;

 	drawDevice->GetDrawRect(screenRect);

 	screenRect.Grow(iPenSize.iWidth,iPenSize.iHeight);

 	const TInt dotParam = iDotParam;

 	TPoint plotpt(0,0);

 	for (TInt count = 0; count < iDefaultRegionPtr->Count(); count++)

 		{

 		iDotParam = dotParam;

 		iClipRect = (*iDefaultRegionPtr)[count];

 		if (!iClipRect.Intersects(temp))

 			{

 			TLinearDDA line;

 			line.Construct(aPt1,aPt2);

 			line.JumpToRect(screenRect);

 			if (iPenStyle != ESolidPen)

 				while (!line.SingleStep(plotpt))

 					iDotParam += iDotDirection;

 			continue;

 			}

 		iClipRect.Intersection(temp);

 		if ((iPenSize.iWidth > 1 || iPenSize.iHeight > 1) && iPenStyle == ESolidPen) // wide solid line

 			DoDrawSolidWideLine(aPt1,aPt2,aDrawStartPoint,screenRect);

 		else if (iPenSize.iWidth > 1 || iPenSize.iHeight > 1) // dotted line

 			DoDrawDottedWideLine(aPt1,aPt2,aDrawStartPoint,screenRect);

 		else if (iPenStyle != ESolidPen) // single pixel dotted line

 			{

 			TLinearDDA line;

 			line.Construct(aPt1,aPt2);

 			line.JumpToRect(screenRect);

 			iDotParam = dotParam;

 			if (!aDrawStartPoint)

 				{

 				line.SingleStep(plotpt);

 				iDotParam += iDotDirection;

 				}

 			while (!line.SingleStep(plotpt))

 				{

 				PenDrawClipped(plotpt);

 				iDotParam += iDotDirection;

 				}

 			}

 		else if (aPt1.iY == aPt2.iY && 

 				 (aPt1.iY >= iClipRect.iTl.iY && aPt1.iY < iClipRect.iBr.iY))

 			{ // single pixel solid horizontal line

 			TInt start = Min(aPt1.iX,aPt2.iX + 1);

 			TInt length = Abs(aPt2.iX - aPt1.iX);

 			if (!aDrawStartPoint)

 				if (aPt1.iX < aPt2.iX)

 					start++;

 				else

 					length--;

 			if (start < iClipRect.iTl.iX)

 				{

 				length += start - iClipRect.iTl.iX;

 				start = iClipRect.iTl.iX;

 				}

 			if (start + length > iClipRect.iBr.iX)

 				length = iClipRect.iBr.iX - start;

 			if (length > 0)

 				{

 				BG_ASSERT_DEBUG(start >= iUserClipRect.iTl.iX,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(aPt1.iY >= iUserClipRect.iTl.iY,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(start + length <= iUserClipRect.iBr.iX,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(aPt1.iY < iUserClipRect.iBr.iY,EBitgdiPanicOutOfBounds);

 				drawDevice->WriteRgbMulti(start,aPt1.iY,length,1,iPenColor,iDrawMode);

 				}

 			}

 		else if (aPt1.iX == aPt2.iX && (aPt1.iX >= iClipRect.iTl.iX && aPt1.iX < iClipRect.iBr.iX))

 			{ // single pixel solid vertical line

 			TInt start = Min(aPt1.iY,aPt2.iY + 1);

 			TInt length = Abs(aPt2.iY - aPt1.iY);

 			if (!aDrawStartPoint)

 				if (aPt1.iY < aPt2.iY)

 					start++;

 				else

 					length--;

 			if (start < iClipRect.iTl.iY)

 				{

 				length += start - iClipRect.iTl.iY;

 				start = iClipRect.iTl.iY;

 				}

 			if (start + length > iClipRect.iBr.iY)

 				length = iClipRect.iBr.iY - start;

 			if (length > 0)

 				{

 				BG_ASSERT_DEBUG(aPt1.iX >= iUserClipRect.iTl.iX,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(start >= iUserClipRect.iTl.iY,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(aPt1.iX < iUserClipRect.iBr.iX,EBitgdiPanicOutOfBounds);

 				BG_ASSERT_DEBUG(start + length <= iUserClipRect.iBr.iY,EBitgdiPanicOutOfBounds);

 				drawDevice->WriteRgbMulti(aPt1.iX,start,1,length,iPenColor,iDrawMode);

 				}

 			}

 		else

 			{ // single pixel solid diagonal line

 			TLinearDDA line;

 			line.Construct(aPt1,aPt2);

 			line.JumpToRect(screenRect);

 			if (!aDrawStartPoint)

 				line.SingleStep(plotpt);

 			while (!line.SingleStep(plotpt))

 				{

 				if (iClipRect.Contains(plotpt))

 					{

 					BG_ASSERT_DEBUG(plotpt.iX >= iUserClipRect.iTl.iX,EBitgdiPanicOutOfBounds);

 					BG_ASSERT_DEBUG(plotpt.iY >= iUserClipRect.iTl.iY,EBitgdiPanicOutOfBounds);

 					BG_ASSERT_DEBUG(plotpt.iX < iUserClipRect.iBr.iX,EBitgdiPanicOutOfBounds);

 					BG_ASSERT_DEBUG(plotpt.iY < iUserClipRect.iBr.iY,EBitgdiPanicOutOfBounds);

 					drawDevice->WriteRgb(plotpt.iX,plotpt.iY,iPenColor,iDrawMode);

 					}

 				}

 			}

 		drawDevice->UpdateRegion(iClipRect);

 		}

 	}

 void CFbsBitGc::DoDrawSolidWideLine(const TPoint& aPt1,

 									const TPoint& aPt2,

 									TBool aDrawStartPoint,

 									const TRect& aScreenRect)

 	{

 	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

 	TLinearDDA line;

 	line.Construct(aPt1,aPt2);

 	TPoint plotpt(aPt1);

 	line.JumpToRect(aScreenRect);

 	if (!aScreenRect.Contains(plotpt) || !aDrawStartPoint)

 		line.SingleStep(plotpt);

 	TInt* deferred = NULL;

 	const TInt doubleheight = iPenSize.iHeight << 1;

 	if (iFbsBitGcExtraData->PenArray())

 		deferred = new TInt[doubleheight];

 	if (!iFbsBitGcExtraData->PenArray() || !deferred)

 		{

 		while (!line.SingleStep(plotpt))

 			PenDrawClipped(plotpt);

 		}

 	else

 		{

 		const TBool down = (aPt2.iY >= aPt1.iY);

 		for (TInt fillcount = 0; fillcount < doubleheight; )

 			{

 			deferred[fillcount++] = KMaxTInt;

 			deferred[fillcount++] = KMinTInt;

 			}

 		TInt nextline = 0;

 		TInt nexty = plotpt.iY;

 		if (down)

 			nexty -= ((iPenSize.iHeight - 1) >> 1);

 		else

 			nexty += (iPenSize.iHeight >> 1);

 		TInt lasty = plotpt.iY;

 		while (!line.SingleStep(plotpt))

 			{

 			if (plotpt.iY != lasty)

 				{

 				if (nexty >= iClipRect.iTl.iY && nexty < iClipRect.iBr.iY)

 					{

 					TInt left = deferred[nextline];

 					TInt right = deferred[nextline + 1];

 					if (left < iClipRect.iTl.iX)

 						left = iClipRect.iTl.iX;

 					if (right >= iClipRect.iBr.iX)

 						right = iClipRect.iBr.iX - 1;

 					if (left <= right)

 						drawDevice->WriteRgbMulti(left,nexty,right - left + 1,1,iPenColor,CGraphicsContext::EDrawModePEN);

 					}

 				if (down)

 					nexty++;

 				else

 					nexty--;

 				lasty = plotpt.iY;

 				deferred[nextline++] = KMaxTInt;

 				deferred[nextline++] = KMinTInt;

 				if (nextline == doubleheight)

 					nextline = 0;

 				}

 			PenDrawDeferred(plotpt,deferred,nextline);

 			}

 		for (TInt restofline = 0; restofline < doubleheight; restofline += 2,nextline += 2)

 			{

 			if (nextline == doubleheight)

 				nextline = 0;

 			if (nexty >= iClipRect.iTl.iY && nexty < iClipRect.iBr.iY)

 				{

 				TInt left = deferred[nextline];

 				TInt right = deferred[nextline+1];

 				if (left < iClipRect.iTl.iX)

 					left = iClipRect.iTl.iX;

 				if (right >= iClipRect.iBr.iX)

 					right = iClipRect.iBr.iX-1;

 				if (left <= right)

 					drawDevice->WriteRgbMulti(left,nexty,right - left + 1,1,iPenColor,CGraphicsContext::EDrawModePEN);

 				}

 			if (down)

 				nexty++;

 			else

 				nexty--;

 			}

 		delete[] deferred;

 		}

 	}

 void CFbsBitGc::DoDrawDottedWideLine(const TPoint& aPt1,

 									 const TPoint& aPt2,

 									 TBool aDrawStartPoint,

 									 const TRect& aScreenRect)

 	{

 	TLinearDDA line;

 	line.Construct(aPt1,aPt2);

 	TPoint plotpt(aPt1);

 	line.JumpToRect(aScreenRect);

 	if (!aDrawStartPoint)

 		{

 		line.SingleStep(plotpt);

 		iDotParam += iDotDirection;

 		}

 	const TInt maxdim = Max(iPenSize.iWidth,iPenSize.iHeight);

 	TBool done = EFalse;

 	while (!done)

 		{

 		while (!done && !(iDotMask & (1 << ((iDotParam / maxdim) % iDotLength))))

 			{

 			done = line.SingleStep(plotpt);

 			iDotParam += iDotDirection;

 			}

 		TPoint startdash(plotpt);

 		TPoint enddash(plotpt);

 		while (!done && (iDotMask & (1 << ((iDotParam / maxdim) % iDotLength))))

 			{

 			enddash = plotpt;

 			done = line.SingleStep(plotpt);

 			iDotParam += iDotDirection;

 			}

 		DoDrawSolidWideLine(startdash,enddash,ETrue,aScreenRect);

 		}

 	}

 // if iBrushBitmap is an extended bitmap, PrepareRasterizerForExtendedBitmap() must have been called before this method

 void CFbsBitGc::PolyFill(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule)

 	{

 	TBool exists;

 	TInt scanline;

 	TInt pixelRunStart;

 	TInt pixelRunEnd;

 	const TInt limit = iDefaultRegionPtr->Count();

 	for (TInt count = 0; count < limit; count++)

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		AddRect(iClipRect);

 		if (UserClipRect(iClipRect))

 			continue;

 		CPolygonFiller polyfill;

 		polyfill.Construct(aPointList,aFillRule);

 		for(polyfill.GetNextPixelRun(exists,scanline,pixelRunStart,pixelRunEnd);exists;

 						polyfill.GetNextPixelRun(exists,scanline,pixelRunStart,pixelRunEnd))

 			{

 			TPoint start(pixelRunStart,scanline),end(pixelRunEnd,scanline);

 			start += iOrigin;

 			end += iOrigin;

 			ClipFillLine(start,end);

 			}

 		polyfill.Reset();

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	}

 // if iBrushBitmap is an extended bitmap, PrepareRasterizerForExtendedBitmap() must have been called before this method

 void CFbsBitGc::PolyFillLarge(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule)

 	{

 	TBool exists;

 	TInt pixelRunStart;

 	TInt pixelRunEnd;

 	const TInt limit = iDefaultRegionPtr->Count();

 	for (TInt count = 0; count < limit; count++)

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		AddRect(iClipRect);

 		if (UserClipRect(iClipRect))

 			continue;

 		CPolygonFiller polyfill;

 		polyfill.Construct(aPointList,aFillRule,CPolygonFiller::EGetPixelRunsSequentiallyForSpecifiedScanLines);

 		TInt clipRectOffsetStart = iClipRect.iTl.iY - iOrigin.iY;

 		TInt clipRectOffsetEnd = iClipRect.iBr.iY - iOrigin.iY;

 		for (TInt scanline = clipRectOffsetStart; scanline < clipRectOffsetEnd; scanline++)

 			{

 			polyfill.GetNextPixelRunOnSpecifiedScanLine(exists,scanline,pixelRunStart,pixelRunEnd);

 			while (exists)

 				{

 				TPoint start(pixelRunStart,scanline),end(pixelRunEnd,scanline);

 				start += iOrigin;

 				end += iOrigin;

 				ClipFillLine(start,end);

 				polyfill.GetNextPixelRunOnSpecifiedScanLine(exists,scanline,pixelRunStart,pixelRunEnd);

 				}

 			}

 		polyfill.Reset();

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	}

 void CFbsBitGc::PolyOutline(const CArrayFix<TPoint>* aPointList)

 	{

 	const TInt vertexes = aPointList->Count();

 	for (TInt count = 0; count < vertexes; count++)

 		{

 		TPoint point1((*aPointList)[count]);

 		TPoint point2((*aPointList)[(count + 1) % vertexes]);

 		if (point1.iY < point2.iY)

 			DoDrawLine(point1,point2,ETrue);

 		else

 			{

 			iDotDirection = -1;

 			iDotParam += Max(Abs(point2.iX - point1.iX),Abs(point2.iY - point1.iY));

 			const TInt dotParam = iDotParam;

 			DoDrawLine(point2,point1,EFalse);

 			if (Abs(point2.iX - point1.iX) > Abs(point2.iY - point1.iY))

 				{

 				if (iPenStyle == CGraphicsContext::ESolidPen || (iDotMask & (1 << ((iDotParam / iPenSize.iWidth) % iDotLength))))

 					DoPlot((*aPointList)[count]);

 				}

 			else

 				{

 				if (iPenStyle == CGraphicsContext::ESolidPen || (iDotMask & (1 << ((iDotParam / iPenSize.iHeight) % iDotLength))))

 					DoPlot((*aPointList)[count]);

 				}

 			iDotDirection = 1;

 			iDotParam = dotParam;

 			}

 		}

 	}

 // if iBrushBitmap is an extended bitmap, PrepareRasterizerForExtendedBitmap() must have been called before this method

 void CFbsBitGc::PolyFill(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule)

 	{

 	TBool exists;

 	TInt scanline;

 	TInt pixelRunStart;

 	TInt pixelRunEnd;

 	const TInt limit = iDefaultRegionPtr->Count();

 	for (TInt count = 0; count < limit; count++)

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		AddRect(iClipRect);

 		if (UserClipRect(iClipRect))

 			continue;

 		CPolygonFiller polyfill;

 		polyfill.Construct(aPointList,aNumPoints,aFillRule);

 		for (polyfill.GetNextPixelRun(exists,scanline,pixelRunStart,pixelRunEnd);exists;

 						polyfill.GetNextPixelRun(exists,scanline,pixelRunStart,pixelRunEnd))

 			{

 			TPoint start(pixelRunStart,scanline),end(pixelRunEnd,scanline);

 			start += iOrigin;

 			end += iOrigin;

 			ClipFillLine(start,end);

 			}

 		polyfill.Reset();

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	}

 // if iBrushBitmap is an extended bitmap, PrepareRasterizerForExtendedBitmap() must have been called before this method

 void CFbsBitGc::PolyFillLarge(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule)

 	{

 	TBool exists;

 	TInt pixelRunStart;

 	TInt pixelRunEnd;

 	const TInt limit = iDefaultRegionPtr->Count();

 	for (TInt count = 0; count < limit; count++)

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		AddRect(iClipRect);

 		if (UserClipRect(iClipRect))

 			continue;

 		CPolygonFiller polyfill;

 		polyfill.Construct(aPointList,aNumPoints,aFillRule,CPolygonFiller::EGetPixelRunsSequentiallyForSpecifiedScanLines);

 		TInt clipRectOffsetStart = iClipRect.iTl.iY - iOrigin.iY;

 		TInt clipRectOffsetEnd = iClipRect.iBr.iY - iOrigin.iY;

 		for (TInt scanline = clipRectOffsetStart; scanline < clipRectOffsetEnd; scanline++)

 			{

 			polyfill.GetNextPixelRunOnSpecifiedScanLine(exists,scanline,pixelRunStart,pixelRunEnd);

 			while (exists)

 				{

 				TPoint start(pixelRunStart,scanline),end(pixelRunEnd,scanline);

 				start += iOrigin;

 				end += iOrigin;

 				ClipFillLine(start,end);

 				polyfill.GetNextPixelRunOnSpecifiedScanLine(exists,scanline,pixelRunStart,pixelRunEnd);

 				}

 			}

 		polyfill.Reset();

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	}

 void CFbsBitGc::PolyOutline(const TPoint* aPointList,TInt aNumPoints)

 	{

 	for (TInt count = 0; count < aNumPoints; count++)

 		{

 		TPoint point1(aPointList[count]);

 		TPoint point2(aPointList[(count + 1) % aNumPoints]);

 		if (point1.iY < point2.iY)

 			DoDrawLine(point1,point2,ETrue);

 		else

 			{

 			iDotDirection = -1;

 			iDotParam += Max(Abs(point2.iX - point1.iX),Abs(point2.iY - point1.iY));

 			const TInt dotParam = iDotParam;

 			DoDrawLine(point2,point1,EFalse);

 			if (Abs(point2.iX - point1.iX) > Abs(point2.iY - point1.iY))

 				{

 				if (iPenStyle == CGraphicsContext::ESolidPen || (iDotMask & (1 << ((iDotParam / iPenSize.iWidth) % iDotLength))))

 					DoPlot(aPointList[count]);

 				}

 			else

 				{

 				if (iPenStyle == CGraphicsContext::ESolidPen || (iDotMask & (1 << ((iDotParam / iPenSize.iHeight) % iDotLength))))

 					DoPlot(aPointList[count]);

 				}

 			iDotDirection = 1;

 			iDotParam = dotParam;

 			}

 		}

 	}